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_rule/adapter" "gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/evaluation_rule/command" "gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/factory" "gitlab.fjmaimaimai.com/allied-creation/performance/pkg/domain" "sort" ) type EvaluationRuleService struct { } func NewEvaluationRuleService() *EvaluationRuleService { newRoleService := &EvaluationRuleService{} return newRoleService } // Create 创建 func (rs *EvaluationRuleService) Create(in *command.CreateRuleCommand) (interface{}, error) { transactionContext, err := factory.ValidateStartTransaction(in) if err != nil { return nil, err } defer func() { transactionContext.RollbackTransaction() }() ruleRepository := factory.CreateEvaluationRuleRepository(map[string]interface{}{"transactionContext": transactionContext}) // 检测名称重复 count, err := ruleRepository.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, "已存在相同名称的评估规则") } if in.Type == domain.EvaluationTypeRating { // 按等级量化值排序 sort.SliceStable(in.Rating.Levels, func(i, j int) bool { return in.Rating.Levels[i].QuantizedValue < in.Rating.Levels[j].QuantizedValue }) } newRule := &domain.EvaluationRule{ Id: 0, Name: in.Name, Remark: in.Remark, CompanyId: in.CompanyId, CreatorId: in.CreatorId, Type: in.Type, SysType: domain.EvaluationSysTypeCommon, Rating: in.Rating, Score: in.Score, } rule, err := ruleRepository.Insert(newRule) 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 rule, nil } func (rs *EvaluationRuleService) Update(in *command.UpdateRuleCommand) (interface{}, error) { transactionContext, err := factory.ValidateStartTransaction(in) if err != nil { return nil, err } defer func() { transactionContext.RollbackTransaction() }() ruleRepository := factory.CreateEvaluationRuleRepository(map[string]interface{}{"transactionContext": transactionContext}) // 检测名称重复(排除自己) count, err := ruleRepository.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, "已存在相同名称的评估规则") } rule, err := ruleRepository.FindOne(map[string]interface{}{"id": in.Id}) if err != nil { return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error()) } if in.Type == domain.EvaluationTypeRating { // 按等级量化值排序 sort.SliceStable(in.Rating.Levels, func(i, j int) bool { return in.Rating.Levels[i].QuantizedValue < in.Rating.Levels[j].QuantizedValue }) } rule.Name = in.Name rule.Remark = in.Remark rule.Type = in.Type rule.Rating = in.Rating rule.Score = in.Score rule, err = ruleRepository.Insert(rule) 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 rule, nil } func (rs *EvaluationRuleService) Get(in *command.GetRuleCommand) (interface{}, error) { transactionContext, err := factory.ValidateStartTransaction(in) if err != nil { return nil, err } defer func() { transactionContext.RollbackTransaction() }() ruleRepository := factory.CreateEvaluationRuleRepository(map[string]interface{}{"transactionContext": transactionContext}) rule, err := ruleRepository.FindOne(map[string]interface{}{"id": in.Id}) 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 rule, nil } func (rs *EvaluationRuleService) Remove(in *command.DeleteRuleCommand) (interface{}, error) { transactionContext, err := factory.ValidateStartTransaction(in) if err != nil { return nil, err } defer func() { transactionContext.RollbackTransaction() }() ruleRepository := factory.CreateEvaluationRuleRepository(map[string]interface{}{"transactionContext": transactionContext}) rule, err := ruleRepository.FindOne(map[string]interface{}{"id": in.Id}) if err != nil { return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error()) } if rule.SysType == domain.EvaluationSysTypeSystem { return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "系统默认规则不可删除") } if _, err := ruleRepository.Remove(rule); 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 rule, nil } func (rs *EvaluationRuleService) ListRelCreator(in *command.QueryRuleCommand) (interface{}, error) { transactionContext, err := factory.ValidateStartTransaction(in) if err != nil { return nil, err } defer func() { transactionContext.RollbackTransaction() }() ruleRepository := factory.CreateEvaluationRuleRepository(map[string]interface{}{"transactionContext": transactionContext}) userRepository := factory.CreateUserRepository(map[string]interface{}{"transactionContext": transactionContext}) // 查询系统默认规则 _, sysRules, err := ruleRepository.Find(map[string]interface{}{"companyId": in.CompanyId, "sysType": domain.EvaluationSysTypeSystem, "limit": 1}) if err != nil { return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error()) } // 不存在,生成默认规则 if len(sysRules) == 0 { newRule := domain.GenerateSysRule(in.CompanyId) if _, err := ruleRepository.Insert(newRule); err != nil { return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error()) } } total, rules, err := ruleRepository.Find(tool_funs.SimpleStructToMap(in)) if err != nil { return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error()) } ras := make([]*adapter.RuleAdapter, 0) creatorIds := make([]int64, 0) for i := range rules { ra := &adapter.RuleAdapter{} ra.EvaluationRule = rules[i] ras = append(ras, ra) creatorIds = append(creatorIds, rules[i].CreatorId) } _, users, _ := userRepository.Find(map[string]interface{}{"ids": creatorIds, "limit": len(creatorIds)}) userNameMap := map[int64]string{} if users != nil { for i := range users { userNameMap[users[i].Id] = users[i].Name } } for i := range ras { if v, ok := userNameMap[ras[i].CreatorId]; ok { ras[i].CreatorName = v } } if err := transactionContext.CommitTransaction(); err != nil { return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) } return tool_funs.SimpleWrapGridMap(total, ras), nil } func (rs *EvaluationRuleService) ListCreator(in *command.QueryCreatorCommand) (interface{}, error) { transactionContext, err := factory.ValidateStartTransaction(in) if err != nil { return nil, err } defer func() { transactionContext.RollbackTransaction() }() ruleRepository := factory.CreateEvaluationRuleRepository(map[string]interface{}{"transactionContext": transactionContext}) userRepository := factory.CreateUserRepository(map[string]interface{}{"transactionContext": transactionContext}) _, rules, err := ruleRepository.Find(tool_funs.SimpleStructToMap(in)) if err != nil { return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error()) } // 获取所有创建人ID creatorMap := map[int64]int64{} for i := range rules { creatorMap[rules[i].CreatorId] = rules[i].CreatorId } creatorIds := make([]int64, 0) for k := range creatorMap { creatorIds = append(creatorIds, k) } _, users, _ := userRepository.Find(map[string]interface{}{"ids": creatorIds, "limit": len(creatorIds)}) cas := make([]*adapter.CreatorAdapter, 0) for i := range users { ca := &adapter.CreatorAdapter{ Id: users[i].Id, Name: users[i].Name, } cas = append(cas, ca) } if err := transactionContext.CommitTransaction(); err != nil { return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error()) } return map[string]interface{}{"list": cas}, nil }