审查视图

pkg/application/evaluation_project/project_service.go 20.4 KB
郑周 authored
1 2 3
package service

import (
郑周 authored
4
	"fmt"
郑周 authored
5 6 7 8 9 10
	"github.com/linmadan/egglib-go/core/application"
	"github.com/linmadan/egglib-go/utils/tool_funs"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/evaluation_project/adapter"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/evaluation_project/command"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/factory"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/domain"
郑周 authored
11
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/utils"
郑周 authored
12
	"strconv"
郑周 authored
13
	"time"
郑周 authored
14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48
)

type EvaluationProjectService struct {
}

func NewEvaluationProjectService() *EvaluationProjectService {
	newRoleService := &EvaluationProjectService{}
	return newRoleService
}

// Create 创建
func (rs *EvaluationProjectService) Create(in *command.CreateProjectCommand) (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})

	// 检测名称重复
	count, err := projectRepository.Count(map[string]interface{}{"name": in.Name, "cycleId": in.CycleId, "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, "名称已存在")
	}

	newProject := &domain.EvaluationProject{
		Id:        0,
		Name:      in.Name,
		Describe:  in.Describe,
		CompanyId: in.CompanyId,
郑周 authored
49
		CycleId:   in.CycleId,
郑周 authored
50 51 52 53 54 55 56 57 58 59
		CreatorId: in.CreatorId,
		State:     domain.ProjectStateWaitConfig,
		HrBp:      in.HrBp,
		Pmp:       in.Pmp,
		PmpIds:    in.PmpIds,
	}
	project, err := projectRepository.Insert(newProject)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
郑周 authored
60 61 62 63 64 65 66 67 68

	projectAdapter := &adapter.EvaluationProjectAdapter{}
	projectAdapter.EvaluationProject = project
	if len(project.PmpIds) > 0 {
		userRepository := factory.CreateUserRepository(map[string]interface{}{"transactionContext": transactionContext})
		_, users, _ := userRepository.Find(map[string]interface{}{"ids": project.PmpIds, "limit": len(project.PmpIds)})
		projectAdapter.TransformPmpAdapter(users)
	}
郑周 authored
69 70 71
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
郑周 authored
72
	return projectAdapter, nil
郑周 authored
73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109

}

func (rs *EvaluationProjectService) Update(in *command.UpdateProjectCommand) (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})

	// 检测名称重复(排除自己)
	count, err := projectRepository.Count(map[string]interface{}{"name": in.Name, "cycleId": in.CycleId, "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, "名称已存在")
	}

	project, err := projectRepository.FindOne(map[string]interface{}{"id": in.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	project.Name = in.Name
	project.Describe = in.Describe
	project.HrBp = in.HrBp
	project.Pmp = in.Pmp
	project.PmpIds = in.PmpIds

	project, err = projectRepository.Insert(project)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
郑周 authored
110 111 112 113 114 115 116 117 118

	projectAdapter := &adapter.EvaluationProjectAdapter{}
	projectAdapter.EvaluationProject = project
	if len(project.PmpIds) > 0 {
		userRepository := factory.CreateUserRepository(map[string]interface{}{"transactionContext": transactionContext})
		_, users, _ := userRepository.Find(map[string]interface{}{"ids": project.PmpIds, "limit": len(project.PmpIds)})
		projectAdapter.TransformPmpAdapter(users)
	}
郑周 authored
119 120 121
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
郑周 authored
122
	return projectAdapter, nil
郑周 authored
123 124 125 126 127 128 129 130 131 132 133 134
}

func (rs *EvaluationProjectService) UpdateTemplate(in *command.UpdateProjectTemplateCommand) (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
135
	cycleRepository := factory.CreateEvaluationCycleRepository(map[string]interface{}{"transactionContext": transactionContext})
郑周 authored
136 137
	cycleTemplateRepository := factory.CreateEvaluationCycleTemplateRepository(map[string]interface{}{"transactionContext": transactionContext})
郑周 authored
138
	project, err := projectRepository.FindOne(map[string]interface{}{"id": in.Id})
郑周 authored
139 140 141 142
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
郑周 authored
143 144 145 146 147 148
	// 如果是已经启用的项目,只能编辑环节的截至时间
	if project.State == domain.ProjectStateEnable {
		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
149
郑周 authored
150 151 152 153 154 155 156 157 158 159 160 161
		cycle, err := cycleRepository.FindOne(map[string]interface{}{"id": in.CycleId})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		maxTime := cycle.TimeEnd.Local()
		if end.After(maxTime) {
			return nil, application.ThrowError(application.BUSINESS_ERROR, "评估截至时间不能超出周期截至时间")
		}
		if project.Template != nil {
			for i := range project.Template.LinkNodes {
				node := project.Template.LinkNodes[i]
				node.TimeEnd = &end
郑周 authored
162 163
			}
		}
郑周 authored
164 165 166 167 168
		// 项目起始截止时间(暂时环节中的时间未分开)
		project.EndTime = end
		project, err = projectRepository.Insert(project)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
郑周 authored
169 170
		}
郑周 authored
171 172 173 174 175 176
		// 查看任务过程,重新日计算任务截至期
		taskRepository := factory.CreateNodeTaskRepository(map[string]interface{}{"transactionContext": transactionContext})
		tasks, err := taskRepository.Find(map[string]interface{}{"projectId": in.Id})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
郑周 authored
177
郑周 authored
178 179 180 181 182 183 184 185 186 187
		now := time.Now().Local()
		nowO := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, time.Local) // 当前时间0点0分0秒时刻

		for i := range tasks {
			task := tasks[i]
			task.TimeEnd = &end

			// 重新计算
			if task.NextSentAt == nil {
				// 环节起始和截止本地时间
188 189
				startLocal := task.TimeStart
				endLocal := task.TimeEnd
郑周 authored
190 191 192 193 194 195

				// 在当前时间之前,则计算下一个周期时间
				if startLocal.Before(now) {
					nextTime := utils.NextTime(nowO, startLocal, task.KpiCycle)
					task.NextSentAt = &nextTime
				} else {
196
					task.NextSentAt = startLocal
郑周 authored
197 198
				}
				// 如果超出截至时间,则周期置空
199
				if task.NextSentAt.After(endLocal.Local()) {
郑周 authored
200 201 202 203 204 205 206 207 208 209 210
					task.NextSentAt = nil
				}
			} else {
				// 新的截止时间在下一次发送周期任务之前,则结束
				if end.Before(task.NextSentAt.Local()) {
					task.NextSentAt = nil
				} else {
					// do nothing
				}
			}
		}
郑周 authored
211
郑周 authored
212 213 214 215
		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
		return project, nil
郑周 authored
216
郑周 authored
217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242
	} else {
		_, projects, err := projectRepository.Find(map[string]interface{}{"companyId": in.CompanyId, "cycleId": in.CycleId}, "template")
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		// 周期内的所有项目,员工不能重复被评估
		rids := map[string]bool{}
		for i := range projects {
			// 排除当前项目
			if in.Id != projects[i].Id {
				ids := projects[i].Recipients
				for j := range ids {
					rids[ids[j]] = true
				}
			}
		}
		repeatNum := 0
		for i := range in.Recipients {
			id := in.Recipients[i]
			if _, ok := rids[id]; ok {
				repeatNum++
			}
		}
		if repeatNum > 0 {
			return nil, application.ThrowError(application.BUSINESS_ERROR, fmt.Sprintf("有%d人已经在本周期其他项目内,需要将他们移除", repeatNum))
		}
郑周 authored
243
郑周 authored
244 245 246 247 248 249 250
		cycleTemplate, err := cycleTemplateRepository.FindOne(map[string]interface{}{"id": in.TemplateId, "includeDeleted": true})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		if cycleTemplate == nil || cycleTemplate.Template == nil {
			return nil, application.ThrowError(application.BUSINESS_ERROR, "请添加模板")
		}
郑周 authored
251
郑周 authored
252 253 254 255 256 257 258 259
		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
260
郑周 authored
261 262 263 264 265 266
		cycle, err := cycleRepository.FindOne(map[string]interface{}{"id": in.CycleId})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		minTime := cycle.TimeStart.Local()
		maxTime := cycle.TimeEnd.Local()
郑周 authored
267
郑周 authored
268 269 270
		if start.Before(minTime) {
			return nil, application.ThrowError(application.BUSINESS_ERROR, "评估起始时间不能超出周期起始时间")
		}
郑周 authored
271
郑周 authored
272 273 274
		if end.After(maxTime) {
			return nil, application.ThrowError(application.BUSINESS_ERROR, "评估截至时间不能超出周期截至时间")
		}
郑周 authored
275
郑周 authored
276 277 278 279 280 281 282 283 284 285 286 287
		if project.State == domain.ProjectStateWaitConfig {
			project.State = domain.ProjectStateWaitActive
		}
		project.Recipients = in.Recipients
		project.Template = cycleTemplate.Template

		// 项目起始截止时间(环节中的时间暂未分开计算)
		project.BeginTime = start
		project.EndTime = end
		for i := range project.Template.LinkNodes {
			node := project.Template.LinkNodes[i]
			node.KpiCycle = in.KpiCycle // 设置周期
郑周 authored
288 289
			node.TimeStart = &start
			node.TimeEnd = &end
郑周 authored
290
		}
郑周 authored
291
郑周 authored
292 293 294 295 296 297 298 299
		project, err = projectRepository.Insert(project)
		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 project, nil
郑周 authored
300 301 302 303
	}
}

func (rs *EvaluationProjectService) Get(in *command.GetProjectCommand) (interface{}, error) {
304
	transactionContext, err := factory.ValidateStartTransaction(in)
郑周 authored
305
	if err != nil {
306
		return nil, err
郑周 authored
307
	}
308 309 310
	defer func() {
		transactionContext.RollbackTransaction()
	}()
郑周 authored
311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330
	projectRepository := factory.CreateEvaluationProjectRepository(map[string]interface{}{"transactionContext": transactionContext})
	project, err := projectRepository.FindOne(map[string]interface{}{"id": in.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	projectAdapter := &adapter.EvaluationProjectAdapter{}
	projectAdapter.EvaluationProject = project

	userRepository := factory.CreateUserRepository(map[string]interface{}{"transactionContext": transactionContext})
	if len(project.PmpIds) > 0 {
		_, users, _ := userRepository.Find(map[string]interface{}{"ids": project.PmpIds, "limit": len(project.PmpIds)})
		projectAdapter.TransformPmpAdapter(users)
	}

	if len(project.Recipients) > 0 {
		_, users, _ := userRepository.Find(map[string]interface{}{"ids": project.Recipients, "limit": len(project.Recipients)})
		projectAdapter.TransformRecipientAdapter(users)
	}
331 332 333
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
郑周 authored
334 335 336 337 338 339 340 341 342 343 344 345 346
	return projectAdapter, nil
}

func (rs *EvaluationProjectService) Remove(in *command.DeleteProjectCommand) (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
347
	taskRepository := factory.CreateNodeTaskRepository(map[string]interface{}{"transactionContext": transactionContext})
348
	staffRepository := factory.CreateStaffAssessTaskRepository(map[string]interface{}{"transactionContext": transactionContext})
郑周 authored
349 350 351 352 353 354 355 356 357

	project, err := projectRepository.FindOne(map[string]interface{}{"id": in.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if _, err := projectRepository.Remove(project); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
358 359 360 361 362 363 364
	// 删除项目已生成的周期评估数据
	if err := staffRepository.RemoveByProjectId(int(project.Id)); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	// 移除项目关联的所有定时任务
	tasks, err := taskRepository.Find(map[string]interface{}{"projectId": project.Id})
郑周 authored
365 366 367 368 369 370 371 372 373
	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
374 375 376 377 378 379 380
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	return project, nil
}

func (rs *EvaluationProjectService) List(in *command.QueryProjectCommand) (interface{}, error) {
郑周 authored
381
	transactionContext, err := factory.ValidateStartTransaction(in)
郑周 authored
382 383 384 385 386 387 388 389
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()

	projectRepository := factory.CreateEvaluationProjectRepository(map[string]interface{}{"transactionContext": transactionContext})
郑周 authored
390
	total, projects, err := projectRepository.Find(tool_funs.SimpleStructToMap(in), "template")
郑周 authored
391 392 393
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
郑周 authored
394 395

	now := time.Now().Unix()
郑周 authored
396 397 398 399 400 401 402 403
	pmpUsers := make([]*domain.User, 0)
	pmpUserIds := make([]int64, 0)
	for i := range projects {
		project := projects[i]
		for j := range project.PmpIds {
			userId, _ := strconv.ParseInt(project.PmpIds[j], 10, 64)
			pmpUserIds = append(pmpUserIds, userId)
		}
郑周 authored
404
郑周 authored
405 406 407 408 409
		// 如果是已启用状态时,当前时间超过截至时间显示【已结束】
		if project.State == domain.ProjectStateEnable {
			if now > project.EndTime.Unix() {
				project.State = domain.ProjectStateDisable
			}
郑周 authored
410
		}
郑周 authored
411
郑周 authored
412
	}
郑周 authored
413
郑周 authored
414 415 416 417 418
	if len(pmpUserIds) > 0 {
		userRepository := factory.CreateUserRepository(map[string]interface{}{"transactionContext": transactionContext})
		_, users, _ := userRepository.Find(map[string]interface{}{"ids": pmpUserIds, "limit": len(pmpUserIds)})
		pmpUsers = users
	}
郑周 authored
419 420 421 422 423

	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
郑周 authored
424
	projectAdapters := adapter.TransformProjectListAdapter(projects, pmpUsers)
郑周 authored
425
	return tool_funs.SimpleWrapGridMap(total, projectAdapters), nil
郑周 authored
426 427
}
郑周 authored
428
func (rs *EvaluationProjectService) Activate(in *command.ActivateProjectCommand) (interface{}, error) {
郑周 authored
429 430 431 432 433 434 435 436 437
	transactionContext, err := factory.ValidateStartTransaction(in)
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()

	projectRepository := factory.CreateEvaluationProjectRepository(map[string]interface{}{"transactionContext": transactionContext})
郑周 authored
438
郑周 authored
439 440 441 442
	project, err := projectRepository.FindOne(map[string]interface{}{"id": in.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
郑周 authored
443 444 445 446 447 448
	if project.Template == nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, "请添加评估模板")
	}
	if len(project.Recipients) == 0 {
		return nil, application.ThrowError(application.BUSINESS_ERROR, "请添加被评估人")
	}
郑周 authored
449 450 451
	if project.State == domain.TemplateStateEnable {
		return nil, application.ThrowError(application.BUSINESS_ERROR, "项目已启动")
	}
郑周 authored
452
郑周 authored
453
	project.State = domain.TemplateStateEnable
郑周 authored
454 455 456 457
	project, err = projectRepository.Insert(project)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
郑周 authored
458 459 460 461 462 463 464 465 466

	taskRepository := factory.CreateNodeTaskRepository(map[string]interface{}{"transactionContext": transactionContext})

	now := time.Now().Local()
	nowO := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, time.Local) // 当前时间0点0分0秒时刻

	for i := range project.Template.LinkNodes {
		node := project.Template.LinkNodes[i]
		task := &domain.NodeTask{
郑周 authored
467 468 469 470 471 472 473 474
			Id:           0,
			CompanyId:    project.CompanyId,
			CycleId:      project.CycleId,
			ProjectId:    project.Id,
			NodeId:       node.Id,
			NodeType:     node.Type,
			NodeName:     node.Name,
			NodeDescribe: node.Describe,
郑周 authored
475
			NodeSort:     i + 1,
郑周 authored
476 477 478
			TimeStart:    node.TimeStart,
			TimeEnd:      node.TimeEnd,
			KpiCycle:     node.KpiCycle,
郑周 authored
479
		}
郑周 authored
480 481

		// 环节起始和截止本地时间
482 483
		startLocal := node.TimeStart
		endLocal := node.TimeEnd
郑周 authored
484
郑周 authored
485
		// 在当前时间之前,则计算下一个周期时间
郑周 authored
486 487
		if startLocal.Before(now) {
			nextTime := utils.NextTime(nowO, startLocal, node.KpiCycle)
郑周 authored
488 489
			task.NextSentAt = &nextTime
		} else {
490
			task.NextSentAt = startLocal
郑周 authored
491 492
		}
		// 如果超出截至时间,则周期置空
493
		if task.NextSentAt.After(endLocal.Local()) {
郑周 authored
494 495 496 497 498 499 500 501 502
			task.NextSentAt = nil
		}

		task, err := taskRepository.Insert(task)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
	}
郑周 authored
503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	return project, nil
}

func (rs *EvaluationProjectService) Copy(in *command.CopyProjectCommand) (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})
	project, err := projectRepository.FindOne(map[string]interface{}{"id": in.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	// ID重置
	project.Id = 0
郑周 authored
524 525 526 527
	project.Name = project.Name + " 副本"
	project.CreatorId = in.CreatorId
	project.Recipients = make([]string, 0) // 重置被评估人
郑周 authored
528 529 530 531 532 533 534 535 536 537 538 539 540
	// 如果拷贝已经启用的模板,默认先设置为待启用
	if project.State == domain.ProjectStateEnable {
		project.State = domain.ProjectStateWaitActive
	}
	project, err = projectRepository.Insert(project)
	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 project, nil
}
541
郑周 authored
542
func (rs *EvaluationProjectService) CheckRecipients(in *command.CheckRecipientCommand) (interface{}, error) {
543 544 545 546 547 548 549
	transactionContext, err := factory.ValidateStartTransaction(in)
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
郑周 authored
550
551
	projectRepository := factory.CreateEvaluationProjectRepository(map[string]interface{}{"transactionContext": transactionContext})
郑周 authored
552
郑周 authored
553
	_, projects, err := projectRepository.Find(map[string]interface{}{"companyId": in.CompanyId, "cycleId": in.CycleId}, "template")
554 555 556 557
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
郑周 authored
558 559
	// 周期内的所有项目,员工不能重复被评估
	rids := map[string]bool{}
560
	for i := range projects {
郑周 authored
561 562 563 564 565 566
		// 排除当前项目
		if in.Id != projects[i].Id {
			ids := projects[i].Recipients
			for j := range ids {
				rids[ids[j]] = true
			}
567 568
		}
	}
郑周 authored
569 570 571 572 573
	repeatNum := 0
	for i := range in.Recipients {
		id := in.Recipients[i]
		if _, ok := rids[id]; ok {
			repeatNum++
574 575 576 577 578 579
		}
	}

	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
郑周 authored
580
	return map[string]interface{}{"repeatNum": repeatNum}, nil
581
}