审查视图

pkg/application/evaluation_cycle/cycle_service.go 17.4 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

	ruleMap := map[int64]*domain.EvaluationRule{}
郑周 authored
93 94 95 96
	ruleIds := make([]int64, 0)
	for k := range ruleIdsMap {
		ruleIds = append(ruleIds, k)
	}
郑周 authored
97 98 99 100 101 102 103 104
	if len(ruleIds) > 0 {
		if _, rules, err := ruleRepository.Find(map[string]interface{}{"ids": ruleIds, "companyId": in.CompanyId}); err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		} else {
			for i := range rules {
				ruleMap[rules[i].Id] = rules[i]
			}
		}
105 106
	}
郑周 authored
107 108
	ctAdapter := &adapter.CycleTemplateAdapter{}
	ctAdapter.EvaluationCycle = cycle
109 110
	for i := range templates {
		v := templates[i]
111 112 113 114 115 116 117 118 119 120 121 122

		// 对评估模板中的评估规则进行数据赋值
		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
123
		// 周期模板数据表中插入数据
124
		cycleTemplate := &domain.EvaluationCycleTemplate{
125 126 127 128 129
			Id:                0,
			Name:              v.Name,
			TemplateCreatedAt: v.CreatedAt,
			Template:          v,
			CycleId:           cycle.Id,
130 131 132 133 134
		}
		_, err := cycleTemplateRepository.Insert(cycleTemplate)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
郑周 authored
135
136
		// 输出模板简单信息
郑周 authored
137
		ctAdapter.TemplateSimples = append(ctAdapter.TemplateSimples, &domain.TemplateSimple{
138 139
			Id:        cycleTemplate.Id,
			Name:      cycleTemplate.Name,
140
			CreatedAt: cycleTemplate.TemplateCreatedAt, // 模板创建时间
郑周 authored
141
		})
142 143
	}
郑周 authored
144 145 146
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
郑周 authored
147
	return ctAdapter, nil
郑周 authored
148 149 150 151 152 153 154 155 156 157 158 159 160

}

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})
161
	cycleTemplateRepository := factory.CreateEvaluationCycleTemplateRepository(map[string]interface{}{"transactionContext": transactionContext})
郑周 authored
162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177
	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())
	}
178
	_, oldCycleTemplates, err := cycleTemplateRepository.Find(map[string]interface{}{"cycleId": cycle.Id}, "template")
郑周 authored
179 180 181
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203

	// 当前周期的所有模板数据
	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
204
	}
205 206 207 208 209 210 211 212 213
	// 增加新模板数据
	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{
214 215 216 217 218
				Id:                0,
				Name:              v.Name,
				TemplateCreatedAt: v.CreatedAt,
				Template:          v,
				CycleId:           cycle.Id,
219 220 221 222 223 224 225 226
			}
			_, err := cycleTemplateRepository.Insert(cycleTemplate)
			if err != nil {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
			}
		}
	}
郑周 authored
227 228 229 230 231 232 233 234 235
	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
236
	cycle.Name = in.Name
郑周 authored
237 238
	cycle.TimeStart = &start
	cycle.TimeEnd = &end
郑周 authored
239 240 241 242 243
	cycle.KpiCycle = in.KpiCycle
	cycle, err = cycleRepository.Insert(cycle)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
郑周 authored
244 245 246 247 248 249 250 251 252 253 254 255

	_, 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,
256
			CreatedAt: cycleTemplates[i].TemplateCreatedAt,
郑周 authored
257 258 259
		})
	}
郑周 authored
260 261 262
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
郑周 authored
263
	return ctAdapter, nil
郑周 authored
264 265 266
}

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

	_, 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,
293
			CreatedAt: cycleTemplates[i].TemplateCreatedAt,
294 295
		})
	}
296 297 298 299

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

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})
313
	cycleTemplateRepository := factory.CreateEvaluationCycleTemplateRepository(map[string]interface{}{"transactionContext": transactionContext})
郑周 authored
314 315
	projectRepository := factory.CreateEvaluationProjectRepository(map[string]interface{}{"transactionContext": transactionContext})
	taskRepository := factory.CreateNodeTaskRepository(map[string]interface{}{"transactionContext": transactionContext})
316
	staffRepository := factory.CreateStaffAssessTaskRepository(map[string]interface{}{"transactionContext": transactionContext})
郑周 authored
317
郑周 authored
318
	// 删除周期
郑周 authored
319 320 321 322 323 324 325 326
	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())
	}
郑周 authored
327
	// 删除周期关联的所有模板,真删
328 329 330 331
	if err := cycleTemplateRepository.BatchDeleteByCycleId(cycle.Id); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
郑周 authored
332 333 334 335 336 337 338 339 340
	// 删除周期下的所有项目
	_, projects, err := projectRepository.Find(map[string]interface{}{"cycleId": in.Id}, "template")
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	for i := range projects {
		if _, err := projectRepository.Remove(projects[i]); err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
341 342 343 344 345

		// 删除项目已生成的周期评估数据
		if err := staffRepository.RemoveByProjectId(int(projects[i].Id)); err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
郑周 authored
346 347
	}
348
	// 删除周期下的所有定时任务
郑周 authored
349 350 351 352 353 354 355 356 357 358 359
	tasks, err := taskRepository.Find(map[string]interface{}{"cycleId": in.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	for i := range tasks {
		if _, err := taskRepository.Remove(tasks[i]); err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
	}
郑周 authored
360 361 362 363 364 365 366
	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) {
郑周 authored
367
	transactionContext, err := factory.ValidateStartTransaction(in)
郑周 authored
368 369 370 371 372 373 374
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
	cycleRepository := factory.CreateEvaluationCycleRepository(map[string]interface{}{"transactionContext": transactionContext})
郑周 authored
375
	total, cycles, err := cycleRepository.Find(tool_funs.SimpleStructToMap(in))
郑周 authored
376 377 378
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
郑周 authored
379 380 381 382
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
郑周 authored
383
	return tool_funs.SimpleWrapGridMap(total, cycles), nil
郑周 authored
384
}
郑周 authored
385 386 387 388 389 390 391 392 393 394

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
395
	_, projects, err := projectRepository.Find(tool_funs.SimpleStructToMap(in), "template")
郑周 authored
396 397 398 399 400 401 402 403 404 405 406 407 408
	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
409 410
	for k := range userIdMap {
		userIds = append(userIds, k)
郑周 authored
411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432
	}

	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
}
433
434
func (rs *EvaluationCycleService) CycleTemplateList(in *command.CycleTemplateListCommand) (interface{}, error) {
435 436 437 438 439 440 441 442 443 444
	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")
445 446 447
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
448 449 450 451 452 453 454 455 456 457 458 459 460 461 462

	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
}
463 464 465 466 467 468 469 470 471 472 473

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
474
	cycleTemplate, err := cycleTemplateRepository.FindOne(map[string]interface{}{"id": in.Id})
475 476 477 478 479 480 481 482
	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
}