审查视图

pkg/application/evaluation_cycle/cycle_service.go 15.9 KB
郑周 authored
1 2 3 4 5
package service

import (
	"github.com/linmadan/egglib-go/core/application"
	"github.com/linmadan/egglib-go/utils/tool_funs"
6
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/evaluation_cycle/adapter"
郑周 authored
7 8 9
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/evaluation_cycle/command"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/factory"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/domain"
10
	"strconv"
郑周 authored
11
	"time"
郑周 authored
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
)

type EvaluationCycleService struct {
}

func NewEvaluationCycleService() *EvaluationCycleService {
	newRoleService := &EvaluationCycleService{}
	return newRoleService
}

// Create 创建
func (rs *EvaluationCycleService) Create(in *command.CreateCycleCommand) (interface{}, error) {
	transactionContext, err := factory.ValidateStartTransaction(in)
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	cycleRepository := factory.CreateEvaluationCycleRepository(map[string]interface{}{"transactionContext": transactionContext})
32
	cycleTemplateRepository := factory.CreateEvaluationCycleTemplateRepository(map[string]interface{}{"transactionContext": transactionContext})
郑周 authored
33
	templateRepository := factory.CreateEvaluationTemplateRepository(map[string]interface{}{"transactionContext": transactionContext})
34
	ruleRepository := factory.CreateEvaluationRuleRepository(map[string]interface{}{"transactionContext": transactionContext})
郑周 authored
35 36 37 38 39 40 41

	// 检测名称重复
	count, err := cycleRepository.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 {
郑周 authored
42
		return nil, application.ThrowError(application.BUSINESS_ERROR, "已存在相同名称的周期")
郑周 authored
43 44 45 46 47 48 49 50 51 52
	}

	_, templates, err := templateRepository.Find(map[string]interface{}{"companyId": in.CompanyId, "ids": in.TemplateIds})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if len(templates) == 0 {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "模板不存在, 请重新选择")
	}
郑周 authored
53 54 55 56 57 58 59 60 61
	start, err := time.ParseInLocation("2006-01-02 15:04:05", in.TimeStart, time.Local)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	end, err := time.ParseInLocation("2006-01-02 15:04:05", in.TimeEnd, time.Local)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
62
	// 生成新周期数据
郑周 authored
63 64 65
	newCycle := &domain.EvaluationCycle{
		Id:        0,
		Name:      in.Name,
郑周 authored
66 67
		TimeStart: &start,
		TimeEnd:   &end,
郑周 authored
68 69 70 71
		CompanyId: in.CompanyId,
		CreatorId: in.CreatorId,
		KpiCycle:  in.KpiCycle,
	}
72
	cycle, err := cycleRepository.Insert(newCycle)
郑周 authored
73 74 75
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
76
77
	// 获取所有模板中的规则对象数据
郑周 authored
78
	ruleIdsMap := map[int64]int64{}
79 80 81 82 83 84
	for i := range templates {
		v := templates[i]
		for j := range v.LinkNodes {
			node := v.LinkNodes[j]
			for k := range node.NodeContents {
				nodeContent := node.NodeContents[k]
郑周 authored
85 86 87
				if nodeContent.RuleId != 0 {
					ruleIdsMap[nodeContent.RuleId] = nodeContent.RuleId
				}
88 89 90
			}
		}
	}
郑周 authored
91 92 93 94 95
	ruleIds := make([]int64, 0)
	for k := range ruleIdsMap {
		ruleIds = append(ruleIds, k)
	}
96
	_, rules, err := ruleRepository.Find(map[string]interface{}{"ids": ruleIds, "companyId": in.CompanyId})
郑周 authored
97 98

	ruleMap := map[int64]*domain.EvaluationRule{}
99 100 101 102
	for i := range rules {
		ruleMap[rules[i].Id] = rules[i]
	}
郑周 authored
103 104
	ctAdapter := &adapter.CycleTemplateAdapter{}
	ctAdapter.EvaluationCycle = cycle
105 106
	for i := range templates {
		v := templates[i]
107 108 109 110 111 112 113 114 115 116 117 118

		// 对评估模板中的评估规则进行数据赋值
		for j := range v.LinkNodes {
			node := v.LinkNodes[j]
			for k := range node.NodeContents {
				nodeContent := node.NodeContents[k]
				if rule, ok := ruleMap[nodeContent.RuleId]; ok {
					nodeContent.Rule = rule
				}
			}
		}
郑周 authored
119
		// 周期模板数据表中插入数据
120
		cycleTemplate := &domain.EvaluationCycleTemplate{
121 122 123 124 125
			Id:                0,
			Name:              v.Name,
			TemplateCreatedAt: v.CreatedAt,
			Template:          v,
			CycleId:           cycle.Id,
126 127 128 129 130
		}
		_, err := cycleTemplateRepository.Insert(cycleTemplate)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
郑周 authored
131
132
		// 输出模板简单信息
郑周 authored
133
		ctAdapter.TemplateSimples = append(ctAdapter.TemplateSimples, &domain.TemplateSimple{
134 135
			Id:        cycleTemplate.Id,
			Name:      cycleTemplate.Name,
136
			CreatedAt: cycleTemplate.TemplateCreatedAt, // 模板创建时间
郑周 authored
137
		})
138 139
	}
郑周 authored
140 141 142
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
郑周 authored
143
	return ctAdapter, nil
郑周 authored
144 145 146 147 148 149 150 151 152 153 154 155 156

}

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

	cycleRepository := factory.CreateEvaluationCycleRepository(map[string]interface{}{"transactionContext": transactionContext})
157
	cycleTemplateRepository := factory.CreateEvaluationCycleTemplateRepository(map[string]interface{}{"transactionContext": transactionContext})
郑周 authored
158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173
	templateRepository := factory.CreateEvaluationTemplateRepository(map[string]interface{}{"transactionContext": transactionContext})

	// 检测名称重复(排除自己)
	count, err := cycleRepository.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, "名称已存在")
	}

	cycle, err := cycleRepository.FindOne(map[string]interface{}{"id": in.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
174
	_, oldCycleTemplates, err := cycleTemplateRepository.Find(map[string]interface{}{"cycleId": cycle.Id}, "template")
郑周 authored
175 176 177
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199

	// 当前周期的所有模板数据
	oldTemplateMap := map[int64]*domain.EvaluationCycleTemplate{}
	for i := range oldCycleTemplates {
		oldTemplateMap[oldCycleTemplates[i].Id] = oldCycleTemplates[i]
	}
	// 拆离新旧模板Id
	newTemplateIds := make([]int64, 0)
	for i := range in.TemplateIds {
		int64Id, _ := strconv.ParseInt(in.TemplateIds[i], 10, 64)
		if _, ok := oldTemplateMap[int64Id]; ok {
			delete(oldTemplateMap, int64Id) // 旧模板继续被引用
		} else {
			newTemplateIds = append(newTemplateIds, int64Id) // 增加新模板ID
		}
	}
	// 旧模板未被引用,则进行删除处理
	for k := range oldTemplateMap {
		_, err := cycleTemplateRepository.Remove(oldTemplateMap[k])
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
郑周 authored
200
	}
201 202 203 204 205 206 207 208 209
	// 增加新模板数据
	if len(newTemplateIds) > 0 {
		_, templates, err := templateRepository.Find(map[string]interface{}{"companyId": cycle.CompanyId, "ids": newTemplateIds})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		for i := range templates {
			v := templates[i]
			cycleTemplate := &domain.EvaluationCycleTemplate{
210 211 212 213 214
				Id:                0,
				Name:              v.Name,
				TemplateCreatedAt: v.CreatedAt,
				Template:          v,
				CycleId:           cycle.Id,
215 216 217 218 219 220 221 222
			}
			_, err := cycleTemplateRepository.Insert(cycleTemplate)
			if err != nil {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
			}
		}
	}
郑周 authored
223 224 225 226 227 228 229 230 231
	start, err := time.ParseInLocation("2006-01-02 15:04:05", in.TimeStart, time.Local)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	end, err := time.ParseInLocation("2006-01-02 15:04:05", in.TimeEnd, time.Local)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
郑周 authored
232
	cycle.Name = in.Name
郑周 authored
233 234
	cycle.TimeStart = &start
	cycle.TimeEnd = &end
郑周 authored
235 236 237 238 239
	cycle.KpiCycle = in.KpiCycle
	cycle, err = cycleRepository.Insert(cycle)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
郑周 authored
240 241 242 243 244 245 246 247 248 249 250 251

	_, cycleTemplates, err := cycleTemplateRepository.Find(map[string]interface{}{"cycleId": cycle.Id}, "template")
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	ctAdapter := &adapter.CycleTemplateAdapter{}
	ctAdapter.EvaluationCycle = cycle
	for i := range cycleTemplates {
		ctAdapter.TemplateSimples = append(ctAdapter.TemplateSimples, &domain.TemplateSimple{
			Id:        cycleTemplates[i].Id,
			Name:      cycleTemplates[i].Name,
252
			CreatedAt: cycleTemplates[i].TemplateCreatedAt,
郑周 authored
253 254 255
		})
	}
郑周 authored
256 257 258
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
郑周 authored
259
	return ctAdapter, nil
郑周 authored
260 261 262
}

func (rs *EvaluationCycleService) Get(in *command.GetCycleCommand) (interface{}, error) {
263
	transactionContext, err := factory.ValidateStartTransaction(in)
郑周 authored
264
	if err != nil {
265
		return nil, err
郑周 authored
266
	}
267 268 269
	defer func() {
		transactionContext.RollbackTransaction()
	}()
郑周 authored
270
	cycleRepository := factory.CreateEvaluationCycleRepository(map[string]interface{}{"transactionContext": transactionContext})
271 272
	cycleTemplateRepository := factory.CreateEvaluationCycleTemplateRepository(map[string]interface{}{"transactionContext": transactionContext})
郑周 authored
273 274 275 276
	cycle, err := cycleRepository.FindOne(map[string]interface{}{"id": in.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
277 278 279 280 281 282 283 284 285 286 287 288

	_, cycleTemplates, err := cycleTemplateRepository.Find(map[string]interface{}{"cycleId": cycle.Id}, "template")
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	ctAdapter := &adapter.CycleTemplateAdapter{}
	ctAdapter.EvaluationCycle = cycle
	for i := range cycleTemplates {
		ctAdapter.TemplateSimples = append(ctAdapter.TemplateSimples, &domain.TemplateSimple{
			Id:        cycleTemplates[i].Id,
			Name:      cycleTemplates[i].Name,
289
			CreatedAt: cycleTemplates[i].TemplateCreatedAt,
290 291
		})
	}
292 293 294 295

	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
296
	return ctAdapter, nil
郑周 authored
297 298 299 300 301 302 303 304 305 306 307 308
}

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

	cycleRepository := factory.CreateEvaluationCycleRepository(map[string]interface{}{"transactionContext": transactionContext})
309
	cycleTemplateRepository := factory.CreateEvaluationCycleTemplateRepository(map[string]interface{}{"transactionContext": transactionContext})
郑周 authored
310 311 312 313 314 315 316 317 318

	cycle, err := cycleRepository.FindOne(map[string]interface{}{"id": in.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if _, err := cycleRepository.Remove(cycle); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
319 320 321 322 323
	// FIXME 删除周期关联的所有模板...   还需要删除关联的定时内容
	if err := cycleTemplateRepository.BatchDeleteByCycleId(cycle.Id); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
郑周 authored
324 325 326 327 328 329 330 331 332 333 334 335 336 337 338
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	return cycle, nil
}

func (rs *EvaluationCycleService) List(in *command.QueryCycleCommand) (interface{}, error) {
	transactionContext, err := factory.StartTransaction()
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	cycleRepository := factory.CreateEvaluationCycleRepository(map[string]interface{}{"transactionContext": transactionContext})
郑周 authored
339
	total, cycles, err := cycleRepository.Find(tool_funs.SimpleStructToMap(in))
郑周 authored
340 341 342
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
郑周 authored
343 344 345 346
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
郑周 authored
347
	return tool_funs.SimpleWrapGridMap(total, cycles), nil
郑周 authored
348
}
郑周 authored
349 350 351 352 353 354 355 356 357 358

func (rs *EvaluationCycleService) StatisticCycleUser(in *command.StatisticCycleProjectUserCommand) (interface{}, error) {
	transactionContext, err := factory.ValidateStartTransaction(in)
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	projectRepository := factory.CreateEvaluationProjectRepository(map[string]interface{}{"transactionContext": transactionContext})
郑周 authored
359
	_, projects, err := projectRepository.Find(tool_funs.SimpleStructToMap(in), "template")
郑周 authored
360 361 362 363 364 365 366 367 368 369 370 371 372
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	userIds := make([]int64, 0)
	userIdMap := map[int64]int64{}
	for i := range projects {
		project := projects[i]
		for j := range project.Recipients {
			userId, _ := strconv.ParseInt(project.Recipients[j], 10, 64)
			userIdMap[userId] = userId
		}
	}
郑周 authored
373 374
	for k := range userIdMap {
		userIds = append(userIds, k)
郑周 authored
375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396
	}

	userTotal := 0
	departmentTotal := 0
	if len(userIds) > 0 {
		userRepository := factory.CreateUserRepository(map[string]interface{}{"transactionContext": transactionContext})
		_, users, _ := userRepository.Find(map[string]interface{}{"ids": userIds, "limit": len(userIds)})
		departmentIdMap := map[int]int{}
		for i := range users {
			for _, v := range users[i].DepartmentId {
				departmentIdMap[v] = v
			}
		}
		userTotal = len(users)
		departmentTotal = len(departmentIdMap)
	}

	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	return map[string]interface{}{"userTotal": userTotal, "departmentTotal": departmentTotal}, nil
}
397
398
func (rs *EvaluationCycleService) CycleTemplateList(in *command.CycleTemplateListCommand) (interface{}, error) {
399 400 401 402 403 404 405 406 407 408
	transactionContext, err := factory.ValidateStartTransaction(in)
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()

	cycleTemplateRepository := factory.CreateEvaluationCycleTemplateRepository(map[string]interface{}{"transactionContext": transactionContext})
	_, cycleTemplates, err := cycleTemplateRepository.Find(map[string]interface{}{"cycleId": in.CycleId}, "template")
409 410 411
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
412 413 414 415 416 417 418 419 420 421 422 423 424 425 426

	list := make([]*domain.TemplateSimple, 0)
	for i := range cycleTemplates {
		list = append(list, &domain.TemplateSimple{
			Id:        cycleTemplates[i].Id,
			Name:      cycleTemplates[i].Name,
			CreatedAt: cycleTemplates[i].TemplateCreatedAt,
		})
	}

	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	return map[string]interface{}{"list": list}, nil
}
427 428 429 430 431 432 433 434 435 436 437

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

	cycleTemplateRepository := factory.CreateEvaluationCycleTemplateRepository(map[string]interface{}{"transactionContext": transactionContext})
郑周 authored
438
	cycleTemplate, err := cycleTemplateRepository.FindOne(map[string]interface{}{"id": in.Id})
439 440 441 442 443 444 445 446
	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 cycleTemplate.Template, nil
}