product_line.go 8.6 KB
package service

import (
	"github.com/linmadan/egglib-go/core/application"
	pgTransaction "github.com/linmadan/egglib-go/transaction/pg"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-manufacture/pkg/application/factory"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-manufacture/pkg/application/productLine/command"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-manufacture/pkg/application/productLine/query"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-manufacture/pkg/domain"
	"gitlab.fjmaimaimai.com/allied-creation/allied-creation-manufacture/pkg/infrastructure/dao"
)

// 生产线服务
type ProductLineService struct {
}

// 创建生产线
func (productLineService *ProductLineService) CreateProductLine(createProductLineCommand *command.CreateProductLineCommand) (interface{}, error) {
	if err := createProductLineCommand.ValidateCommand(); err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
	}
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()

	uniqueIdDao, _ := dao.NewUniqueIdDao(transactionContext.(*pgTransaction.TransactionContext))
	uniqueId, err := uniqueIdDao.GenerateUniqueId()
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	newProductLine := &domain.ProductLine{
		LineId:          uniqueId,
		LineName:        createProductLineCommand.LineName,
		ProductSections: []*domain.ProductSection{},
		Removed:         domain.NotDeleted,
	}

	var workshopRepository domain.WorkshopRepository
	var workshop *domain.Workshop
	workshopRepository, workshop, err = factory.FastPgWorkshop(transactionContext, createProductLineCommand.WorkshopId)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if err = workshop.AddLine(newProductLine); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if workshop, err = workshopRepository.Save(workshop); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	return map[string]interface{}{
		"lineId":     newProductLine.LineId,
		"lineName":   newProductLine.LineName,
		"workshopId": createProductLineCommand.WorkshopId,
	}, nil
}

// 返回生产线
func (productLineService *ProductLineService) GetProductLine(getProductLineQuery *query.GetProductLineQuery) (interface{}, error) {
	if err := getProductLineQuery.ValidateQuery(); err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
	}
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	//var workshopRepository domain.WorkshopRepository
	var workshop *domain.Workshop
	_, workshop, err = factory.FastPgWorkshop(transactionContext, getProductLineQuery.WorkshopId)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	line, err := workshop.FindLine(getProductLineQuery.LineId)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	return line, nil
}

// 返回生产线列表
func (productLineService *ProductLineService) ListProductLine(listProductLineQuery *query.ListProductLineQuery) (interface{}, error) {
	if err := listProductLineQuery.ValidateQuery(); err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
	}
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	//var productLineRepository productLine.ProductLineRepository
	//if value, err := factory.CreateProductLineRepository(map[string]interface{}{
	//	"transactionContext": transactionContext,
	//}); err != nil {
	//	return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	//} else {
	//	productLineRepository = value
	//}
	//if count, productLines, err := productLineRepository.Find(tool_funs.SimpleStructToMap(listProductLineQuery)); err != nil {
	//	return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	//} else {
	//	if err := transactionContext.CommitTransaction(); err != nil {
	//		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	//	}
	//	return map[string]interface{}{
	//		"count":        count,
	//		"productLines": productLines,
	//	}, nil
	//}
	return nil, nil
}

// 移除生产线
func (productLineService *ProductLineService) RemoveProductLine(removeProductLineCommand *command.RemoveProductLineCommand) (interface{}, error) {
	if err := removeProductLineCommand.ValidateCommand(); err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
	}
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	var workshopRepository domain.WorkshopRepository
	var workshop *domain.Workshop
	workshopRepository, workshop, err = factory.FastPgWorkshop(transactionContext, removeProductLineCommand.WorkshopId)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if _, err = workshop.RemoveLine(removeProductLineCommand.LineId); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if workshop, err = workshopRepository.Save(workshop); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	return struct{}{}, nil
}

// 更新生产线
func (productLineService *ProductLineService) UpdateProductLine(updateProductLineCommand *command.UpdateProductLineCommand) (interface{}, error) {
	if err := updateProductLineCommand.ValidateCommand(); err != nil {
		return nil, application.ThrowError(application.ARG_ERROR, err.Error())
	}
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	var workshopRepository domain.WorkshopRepository
	var workshop *domain.Workshop
	workshopRepository, workshop, err = factory.FastPgWorkshop(transactionContext, updateProductLineCommand.WorkshopId)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if err = workshop.UpdateLine(updateProductLineCommand.LineId, updateProductLineCommand.LineName); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if workshop, err = workshopRepository.Save(workshop); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	return updateProductLineCommand, nil
}

func NewProductLineService(options map[string]interface{}) *ProductLineService {
	newProductLineService := &ProductLineService{}
	return newProductLineService
}