审查视图

pkg/application/evaluation_project/project_service.go 18.8 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
	_, projects, err := projectRepository.Find(map[string]interface{}{"companyId": in.CompanyId, "cycleId": in.CycleId}, "template")
郑周 authored
139 140 141 142
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
郑周 authored
143 144 145 146 147
	cycle, err := cycleRepository.FindOne(map[string]interface{}{"id": in.CycleId})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
郑周 authored
148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169
	// 周期内的所有项目,员工不能重复被评估
	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
170 171 172 173 174
	project, err := projectRepository.FindOne(map[string]interface{}{"id": in.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
郑周 authored
175
	cycleTemplate, err := cycleTemplateRepository.FindOne(map[string]interface{}{"id": in.TemplateId, "includeDeleted": true})
郑周 authored
176 177 178 179
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
郑周 authored
180 181 182 183 184 185
	if cycleTemplate == nil || cycleTemplate.Template == nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, "请添加模板")
	}

	if len(in.Recipients) == 0 {
		return nil, application.ThrowError(application.BUSINESS_ERROR, "请添加被评估人")
郑周 authored
186
	}
郑周 authored
187
郑周 authored
188 189 190 191 192 193 194 195 196 197 198 199 200
	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())
	}
	kpiStart, err := time.ParseInLocation("2006-01-02 15:04:05", in.KpiResultStart, time.Local)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
郑周 authored
201 202
	minTime := cycle.TimeStart.Local()
	maxTime := cycle.TimeEnd.Local()
郑周 authored
203 204

	if start.Before(minTime) {
郑周 authored
205 206 207
		return nil, application.ThrowError(application.BUSINESS_ERROR, "评估起始时间不能超出周期起始时间")
	}
郑周 authored
208
	if end.After(maxTime) {
郑周 authored
209 210 211
		return nil, application.ThrowError(application.BUSINESS_ERROR, "评估截至时间不能超出周期截至时间")
	}
郑周 authored
212 213 214 215 216 217 218 219
	//// FIXME 启动时,需要激活定时任务
	//if in.Activate == 1 {
	//	project.State = domain.ProjectStateEnable
	//} else {
	//	project.State = domain.ProjectStateWaitActive
	//}
	project.State = domain.ProjectStateWaitActive
郑周 authored
220 221 222 223 224 225
	project.Recipients = in.Recipients
	project.Template = cycleTemplate.Template
	for i := range project.Template.LinkNodes {
		node := project.Template.LinkNodes[i]
		node.KpiCycle = in.KpiCycle // 设置周期
		if node.Type == domain.LinkNodeViewResult {
郑周 authored
226 227
			node.TimeStart = &kpiStart
			node.TimeEnd = &maxTime // 绩效查看时间跟随周期截止时间
郑周 authored
228
		} else {
郑周 authored
229 230
			node.TimeStart = &start
			node.TimeEnd = &end
郑周 authored
231
		}
郑周 authored
232 233 234 235 236 237 238 239 240 241 242 243 244
	}

	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
}

func (rs *EvaluationProjectService) Get(in *command.GetProjectCommand) (interface{}, error) {
245
	transactionContext, err := factory.ValidateStartTransaction(in)
郑周 authored
246
	if err != nil {
247
		return nil, err
郑周 authored
248
	}
249 250 251
	defer func() {
		transactionContext.RollbackTransaction()
	}()
郑周 authored
252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271
	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)
	}
272 273 274
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
郑周 authored
275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312
	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})

	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())
	}

	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) {
	transactionContext, err := factory.StartTransaction()
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()

	projectRepository := factory.CreateEvaluationProjectRepository(map[string]interface{}{"transactionContext": transactionContext})
郑周 authored
313
	total, projects, err := projectRepository.Find(tool_funs.SimpleStructToMap(in), "template")
郑周 authored
314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	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)
		}
	}
	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
	}
	projectAdapters := adapter.TransformProjectListAdapter(projects, pmpUsers)
郑周 authored
332
	return tool_funs.SimpleWrapGridMap(total, projectAdapters), nil
郑周 authored
333 334
}
郑周 authored
335
func (rs *EvaluationProjectService) Activate(in *command.ActivateProjectCommand) (interface{}, error) {
郑周 authored
336 337 338 339 340 341 342 343 344
	transactionContext, err := factory.ValidateStartTransaction(in)
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()

	projectRepository := factory.CreateEvaluationProjectRepository(map[string]interface{}{"transactionContext": transactionContext})
郑周 authored
345 346
	//cycleRepository := factory.CreateEvaluationCycleRepository(map[string]interface{}{"transactionContext": transactionContext})
郑周 authored
347 348 349 350 351
	project, err := projectRepository.FindOne(map[string]interface{}{"id": in.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
郑周 authored
352 353 354 355 356 357 358
	if project.Template == nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, "请添加评估模板")
	}

	if len(project.Recipients) == 0 {
		return nil, application.ThrowError(application.BUSINESS_ERROR, "请添加被评估人")
	}
郑周 authored
359 360 361
	if project.State == domain.TemplateStateEnable {
		return nil, application.ThrowError(application.BUSINESS_ERROR, "项目已启动")
	}
郑周 authored
362 363 364 365 366 367 368
	//cycle, err := cycleRepository.FindOne(map[string]interface{}{"id": project.CycleId})
	//if err != nil {
	//	return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	//}
	//startMin := cycle.TimeStart
	//maxTime := cycle.TimeEnd
郑周 authored
369
	project.State = domain.TemplateStateEnable
郑周 authored
370 371 372 373
	project, err = projectRepository.Insert(project)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
郑周 authored
374 375 376 377 378 379 380 381 382

	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
383 384 385 386 387 388 389 390
			Id:           0,
			CompanyId:    project.CompanyId,
			CycleId:      project.CycleId,
			ProjectId:    project.Id,
			NodeId:       node.Id,
			NodeType:     node.Type,
			NodeName:     node.Name,
			NodeDescribe: node.Describe,
郑周 authored
391
			NodeSort:     i + 1,
郑周 authored
392 393 394
			TimeStart:    node.TimeStart,
			TimeEnd:      node.TimeEnd,
			KpiCycle:     node.KpiCycle,
郑周 authored
395
		}
郑周 authored
396 397 398 399 400

		// 环节起始和截止本地时间
		startLocal := node.TimeStart.Local()
		endLocal := node.TimeEnd.Local()
郑周 authored
401
		// 在当前时间之前,则计算下一个周期时间
郑周 authored
402 403
		if startLocal.Before(now) {
			nextTime := utils.NextTime(nowO, startLocal, node.KpiCycle)
郑周 authored
404 405
			task.NextSentAt = &nextTime
		} else {
郑周 authored
406
			task.NextSentAt = &startLocal
郑周 authored
407 408
		}
		// 如果超出截至时间,则周期置空
郑周 authored
409
		if task.NextSentAt.After(endLocal) {
郑周 authored
410 411 412 413 414 415 416 417 418
			task.NextSentAt = nil
		}

		task, err := taskRepository.Insert(task)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
	}
郑周 authored
419 420 421 422 423 424
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	return project, nil
}
郑周 authored
425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460
//
//// 0点时刻为标准计算
//func (rs *EvaluationProjectService) nextTime(now0 time.Time, start *time.Time, kpiCycle int) time.Time {
//	// 起始时间0点时刻
//	start0 := time.Date(start.Year(), start.Month(), start.Day(), 0, 0, 0, 0, time.Local)
//
//	var nextTime time.Time
//	switch kpiCycle {
//	case domain.KpiCycleDay:
//		nextTime = timeconv.AddDate(now0, 0, 0, 1) // 当前时间的下一天开始发送
//		break
//	case domain.KpiCycleWeek:
//		offsetSeconds := int64(now0.Sub(start0).Seconds())
//		offsetDay := offsetSeconds / (24 * 60 * 60)
//		cycleCount := int(offsetDay)/7 + 1
//		nextTime = timeconv.AddDate(start0, 0, 0, cycleCount*7)
//		break
//	case domain.KpiCycleOneMonth:
//		nextTime = timeconv.AddDate(start0, 0, 1, 0)
//		break
//	case domain.KpiCycleTwoMonth:
//		nextTime = timeconv.AddDate(start0, 0, 2, 0)
//		break
//	case domain.KpiCycleThreeMonth:
//		nextTime = timeconv.AddDate(start0, 0, 3, 0)
//		break
//	case domain.KpiCycleSixMonth:
//		nextTime = timeconv.AddDate(start0, 0, 6, 0)
//		break
//	case domain.KpiCycleYear:
//		nextTime = timeconv.AddDate(start0, 1, 0, 0)
//		break
//	}
//	return nextTime
//}
郑周 authored
461 462 463 464 465 466 467 468 469 470 471 472 473 474 475
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
476 477 478 479
	project.Name = project.Name + " 副本"
	project.CreatorId = in.CreatorId
	project.Recipients = make([]string, 0) // 重置被评估人
郑周 authored
480 481 482 483 484 485 486 487 488 489 490 491 492
	// 如果拷贝已经启用的模板,默认先设置为待启用
	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
}
493
郑周 authored
494
func (rs *EvaluationProjectService) CheckRecipients(in *command.CheckRecipientCommand) (interface{}, error) {
495 496 497 498 499 500 501
	transactionContext, err := factory.ValidateStartTransaction(in)
	if err != nil {
		return nil, err
	}
	defer func() {
		transactionContext.RollbackTransaction()
	}()
郑周 authored
502
503
	projectRepository := factory.CreateEvaluationProjectRepository(map[string]interface{}{"transactionContext": transactionContext})
郑周 authored
504
郑周 authored
505
	_, projects, err := projectRepository.Find(map[string]interface{}{"companyId": in.CompanyId, "cycleId": in.CycleId}, "template")
506 507 508 509
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
郑周 authored
510 511
	// 周期内的所有项目,员工不能重复被评估
	rids := map[string]bool{}
512
	for i := range projects {
郑周 authored
513 514 515 516 517 518
		// 排除当前项目
		if in.Id != projects[i].Id {
			ids := projects[i].Recipients
			for j := range ids {
				rids[ids[j]] = true
			}
519 520
		}
	}
郑周 authored
521 522 523 524 525
	repeatNum := 0
	for i := range in.Recipients {
		id := in.Recipients[i]
		if _, ok := rids[id]; ok {
			repeatNum++
526 527
		}
	}
郑周 authored
528 529 530
	//if repeatNum > 0 {
	//	return nil, application.ThrowError(application.BUSINESS_ERROR, fmt.Sprintf("有%d人已经在本周期其他项目内,需要将他们移除", repeatNum))
	//}
531
郑周 authored
532 533 534
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
535 536 537
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
郑周 authored
538
	return map[string]interface{}{"repeatNum": repeatNum}, nil
539
}