template_service.go 9.1 KB
package service

import (
	"github.com/linmadan/egglib-go/core/application"
	"github.com/linmadan/egglib-go/utils/tool_funs"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/evaluation_template/command"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/factory"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/domain"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/utils"
)

type EvaluationTemplateService struct {
}

func NewEvaluationTemplateService() *EvaluationTemplateService {
	newRoleService := &EvaluationTemplateService{}
	return newRoleService
}

// Create 创建
func (rs *EvaluationTemplateService) Create(in *command.CreateTemplateCommand) (interface{}, error) {
	transactionContext, err := factory.ValidateStartTransaction(in)
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	templateRepository := factory.CreateEvaluationTemplateRepository(map[string]interface{}{"transactionContext": transactionContext})

	// 检测名称重复
	count, err := templateRepository.Count(map[string]interface{}{"name": in.Name, "companyId": in.CompanyId})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if count > 0 {
		return nil, application.ThrowError(application.BUSINESS_ERROR, "名称已存在")
	}

	linkNodes := make([]*domain.LinkNode, 0)
	linkNodes = append(linkNodes, &domain.LinkNode{
		Type:     domain.LinkNodeAssessment,
		Name:     "填写自评反馈",
		KpiCycle: domain.KpiCycleDay,
	})
	linkNodes = append(linkNodes, &domain.LinkNode{
		Type:     domain.LinkNodeAllInvite,
		Name:     "360°邀请",
		KpiCycle: domain.KpiCycleDay,
	})
	linkNodes = append(linkNodes, &domain.LinkNode{
		Type:     domain.LinkNodeAssessment,
		Name:     "360°评估",
		KpiCycle: domain.KpiCycleDay,
	})
	linkNodes = append(linkNodes, &domain.LinkNode{
		Type:     domain.LinkNodeAssessment,
		Name:     "上级评估",
		KpiCycle: domain.KpiCycleDay,
	})
	linkNodes = append(linkNodes, &domain.LinkNode{
		Type:     domain.LinkNodeViewResult,
		Name:     "绩效结果查看",
		KpiCycle: domain.KpiCycleDay,
	})

	newTemplate := &domain.EvaluationTemplate{
		Id:        0,
		Name:      in.Name,
		Describe:  in.Describe,
		CompanyId: in.CompanyId,
		CreatorId: in.CreatorId,
		State:     domain.TemplateStateWaitConfig,
		LinkNodes: linkNodes,
	}
	template, err := templateRepository.Insert(newTemplate)
	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 template, nil

}

func (rs *EvaluationTemplateService) Update(in *command.UpdateTemplateCommand) (interface{}, error) {
	transactionContext, err := factory.ValidateStartTransaction(in)
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()

	templateRepository := factory.CreateEvaluationTemplateRepository(map[string]interface{}{"transactionContext": transactionContext})

	// 检测名称重复(排除自己)
	count, err := templateRepository.Count(map[string]interface{}{"name": in.Name, "companyId": in.CompanyId, "notId": in.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if count > 0 {
		return nil, application.ThrowError(application.BUSINESS_ERROR, "名称已存在")
	}

	template, err := templateRepository.FindOne(map[string]interface{}{"id": in.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	template.Name = in.Name
	template.Describe = in.Describe
	template.LinkNodes = in.LinkNodes

	template, err = templateRepository.Insert(template)
	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 template, nil
}

func (rs *EvaluationTemplateService) Get(in *command.GetTemplateCommand) (interface{}, error) {
	// Get 不需要事务
	if err := utils.ValidateCommand(in); 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())
	}
	templateRepository := factory.CreateEvaluationTemplateRepository(map[string]interface{}{"transactionContext": transactionContext})
	template, err := templateRepository.FindOne(map[string]interface{}{"id": in.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	return template, nil
}

func (rs *EvaluationTemplateService) Remove(in *command.DeleteTemplateCommand) (interface{}, error) {
	transactionContext, err := factory.ValidateStartTransaction(in)
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()

	templateRepository := factory.CreateEvaluationTemplateRepository(map[string]interface{}{"transactionContext": transactionContext})

	template, err := templateRepository.FindOne(map[string]interface{}{"id": in.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if _, err := templateRepository.Remove(template); 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 template, nil
}

func (rs *EvaluationTemplateService) List(in *command.QueryTemplateCommand) (interface{}, error) {
	transactionContext, err := factory.StartTransaction()
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	templateRepository := factory.CreateEvaluationTemplateRepository(map[string]interface{}{"transactionContext": transactionContext})

	// FIXME 总数量是否使用Count获取一个总数量
	count, templates, err := templateRepository.Find(tool_funs.SimpleStructToMap(in), "linkNodes")
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	return tool_funs.SimpleWrapGridMap(count, templates), nil
}

func (rs *EvaluationTemplateService) ListForEnable(in *command.AllEnableTemplateCommand) (interface{}, error) {
	transactionContext, err := factory.StartTransaction()
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	templateRepository := factory.CreateEvaluationTemplateRepository(map[string]interface{}{"transactionContext": transactionContext})

	count, templates, err := templateRepository.Find(map[string]interface{}{
		"companyId": in.CompanyId,
		"state":     domain.TemplateStateEnable,
		"offset":    0,
		"limit":     9999999,
	}, "linkNodes")
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	return tool_funs.SimpleWrapGridMap(count, templates), nil
}

func (rs *EvaluationTemplateService) State(in *command.StateTemplateCommand) (interface{}, error) {
	transactionContext, err := factory.ValidateStartTransaction(in)
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()

	templateRepository := factory.CreateEvaluationTemplateRepository(map[string]interface{}{"transactionContext": transactionContext})

	template, err := templateRepository.FindOne(map[string]interface{}{"id": in.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	template.State = in.State
	template, err = templateRepository.Insert(template)
	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 template, nil
}

func (rs *EvaluationTemplateService) Copy(in *command.CopyTemplateCommand) (interface{}, error) {
	transactionContext, err := factory.ValidateStartTransaction(in)
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	templateRepository := factory.CreateEvaluationTemplateRepository(map[string]interface{}{"transactionContext": transactionContext})
	template, err := templateRepository.FindOne(map[string]interface{}{"id": in.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	// ID重置
	template.Id = 0
	// 如果拷贝已经启用的模板,默认先设置为待启用
	if template.State == domain.TemplateStateEnable {
		template.State = domain.TemplateStateWaitActive
	}
	template, err = templateRepository.Insert(template)
	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 template, nil
}