Merge branch 'test' of http://gitlab.fjmaimaimai.com/allied-creation/performance into test

-FROM golang:latest
+FROM 192.168.0.243:5000/mmm/performance-back:20221121test
 #FROM 192.168.0.243:5000/mmm/digital-platform:20220831
 ENV APP_DIR $GOPATH/src/performance
 RUN mkdir -p $APP_DIR

+#!/bin/bash
+export PATH=/root/local/bin:$PATH
+kubectl -n mmm-suplus-prd get pods | grep -q performance-back
+if [ "$?" == "1" ];then
+	kubectl create -f /tmp/prd/performance-back/performance-back.yaml --record
+	kubectl -n mmm-suplus-prd get svc | grep -q performance-back
+	if [ "$?" == "0" ];then
+		echo "performance-back service install success!"
+	else
+		echo "performance-back service install fail!"
+	fi
+	kubectl -n mmm-suplus-prd get pods | grep -q performance-back
+	if [ "$?" == "0" ];then
+		echo "performance-back deployment install success!"
+	else
+		echo "performance-back deployment install fail!"
+	fi
+else
+	kubectl delete -f /tmp/prd/performance-back/performance-back.yaml
+	kubectl -n mmm-suplus-prd get svc | grep -q performance-back
+	while [ "$?" == "0" ]
+	do
+	kubectl -n mmm-suplus-prd get svc | grep -q performance-back
+	done
+	kubectl -n mmm-suplus-prd get pods | grep -q performance-back
+	while [ "$?" == "0" ]
+	do
+	kubectl -n mmm-suplus-prd get pods | grep -q performance-back
+	done
+	kubectl create -f /tmp/prd/performance-back/performance-back.yaml --record
+	kubectl -n mmm-suplus-prd get svc | grep -q performance-back
+	if [ "$?" == "0" ];then
+		echo "performance-back service update success!"
+	else
+		echo "performance-back service update fail!"
+	fi
+	kubectl -n mmm-suplus-prd get pods | grep -q performance-back
+	if [ "$?" == "0" ];then
+		echo "performance-back deployment update success!"
+	else
+		echo "performance-back deployment update fail!"
+	fi
+fi
\ No newline at end of file

+apiVersion: v1
+kind: Service
+metadata:
+  name: performance-back
+  namespace: mmm-suplus-prd
+  labels:
+    k8s-app: performance-back
+spec:
+  ports:
+     - name: "http"
+       port: 80
+       targetPort: 8082
+     - name: "https"
+       port: 443
+       targetPort: 443      
+  selector:
+    k8s-app: performance-back
+---
+apiVersion: extensions/v1beta1
+kind: Deployment
+metadata:
+  name: performance-back
+  namespace: mmm-suplus-prd
+  labels:
+    k8s-app: performance-back
+spec:
+  replicas: 1
+  template:
+    metadata:
+      labels:
+        k8s-app: performance-back
+    spec:
+      affinity:
+        nodeAffinity:
+          preferredDuringSchedulingIgnoredDuringExecution:
+            - preference: {}
+              weight: 100
+          requiredDuringSchedulingIgnoredDuringExecution:
+            nodeSelectorTerms:
+              - matchExpressions:
+                  - key: kubernetes.io/hostname
+                    operator: In
+                    values:
+                      - cn-hangzhou.i-bp1djh1xn7taumbue1ze
+                      - cn-hangzhou.i-bp1djh1xn7taumbue1zd
+                      - cn-hangzhou.i-bp1euf5u1ph9kbhtndhb
+                      - cn-hangzhou.i-bp1hyp5oips9cdwxxgxy
+      containers:
+      - name: performance-back
+        image: 192.168.0.243:5000/mmm/performance-back:master
+        imagePullPolicy: Always
+        ports:
+        - containerPort: 8082
+        - containerPort: 443
+        volumeMounts:
+        - mountPath: /opt/logs
+          name: accesslogs
+        env:
+        - name: LOG_LEVEL
+          value: "debug"
+        - name: LOG_FILE
+          value: "true"
+        - name: ERROR_BASE_CODE
+          value: "1"
+        - name: ERROR_BASE_CODE_MULTIPLE
+          value: "1000"
+        - name: POSTGRESQL_DB_NAME
+          value: "performance_prd"
+        - name: ENABLE_HTTPS
+          value: "true"
+        - name: POSTGRESQL_USER
+          valueFrom:
+            configMapKeyRef:
+              name: suplus-config
+              key: postgresql.user
+        - name: POSTGRESQL_PASSWORD
+          valueFrom:
+            configMapKeyRef:
+              name: suplus-config
+              key: postgresql.password
+        - name: POSTGRESQL_HOST
+          valueFrom:
+            configMapKeyRef:
+              name: suplus-config
+              key: postgresql.host    
+        - name: POSTGRESQL_PORT
+          valueFrom:
+            configMapKeyRef:
+              name: suplus-config
+              key: postgresql.port
+        - name: REDIS_HOST
+          valueFrom:
+            configMapKeyRef:
+              name: suplus-config
+              key: redis.ip
+        - name: REDIS_PORT
+          valueFrom:
+            configMapKeyRef:
+              name: suplus-config
+              key: redis.port
+        - name: KAFKA_HOSTS
+          valueFrom:
+            configMapKeyRef:
+              name: suplus-config
+              key: kafka.host
+        - name: KAFKA_PERFORMANCE_ID
+          valueFrom:
+            configMapKeyRef:
+              name: suplus-config
+              key: kafkaperformance.id
+        - name: KAFKA_BUSINESS_TOPIC
+          value: "mmm_business_prd"
+        - name: UCENTER_SERVICE_HOST
+          value: "https://suplus-ucenter-prd.fjmaimaimai.com"
+        - name: BUSINESS_ADMIN_SERVICE_HOST
+          value: "https://suplus-business-admin-prd.fjmaimaimai.com"
+      volumes:
+        - name: accesslogs
+          emptyDir: {}
+  
\ No newline at end of file

@@ -88,16 +88,20 @@ func (rs *EvaluationCycleService) Create(in *command.CreateCycleCommand) (interf
 			}
 		}
 	}
+
+	ruleMap := map[int64]*domain.EvaluationRule{}
 	ruleIds := make([]int64, 0)
 	for k := range ruleIdsMap {
 		ruleIds = append(ruleIds, k)
 	}
-
-	_, rules, err := ruleRepository.Find(map[string]interface{}{"ids": ruleIds, "companyId": in.CompanyId})
-
-	ruleMap := map[int64]*domain.EvaluationRule{}
-	for i := range rules {
-		ruleMap[rules[i].Id] = rules[i]
+	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]
+			}
+		}
 	}
 
 	ctAdapter := &adapter.CycleTemplateAdapter{}
@@ -307,7 +311,10 @@ func (rs *EvaluationCycleService) Remove(in *command.DeleteCycleCommand) (interf
 
 	cycleRepository := factory.CreateEvaluationCycleRepository(map[string]interface{}{"transactionContext": transactionContext})
 	cycleTemplateRepository := factory.CreateEvaluationCycleTemplateRepository(map[string]interface{}{"transactionContext": transactionContext})
+	projectRepository := factory.CreateEvaluationProjectRepository(map[string]interface{}{"transactionContext": transactionContext})
+	taskRepository := factory.CreateNodeTaskRepository(map[string]interface{}{"transactionContext": transactionContext})
 
+	// 删除周期
 	cycle, err := cycleRepository.FindOne(map[string]interface{}{"id": in.Id})
 	if err != nil {
 		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
@@ -316,11 +323,34 @@ func (rs *EvaluationCycleService) Remove(in *command.DeleteCycleCommand) (interf
 		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
 	}
 
-	// FIXME 删除周期关联的所有模板...   还需要删除关联的定时内容
+	// 删除周期关联的所有模板，真删
 	if err := cycleTemplateRepository.BatchDeleteByCycleId(cycle.Id); err != nil {
 		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
 	}
 
+	// 删除周期下的所有项目
+	_, 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())
+		}
+	}
+
+	// 删除周期下的所有任务
+	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())
+		}
+	}
+
 	if err := transactionContext.CommitTransaction(); err != nil {
 		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
 	}

@@ -17,16 +17,14 @@ type UpdateProjectCommand struct {
 }
 
 type UpdateProjectTemplateCommand struct {
-	CompanyId      int64    `cname:"公司ID" json:"companyId"`
-	CycleId        int64    `cname:"周期ID" json:"cycleId,string" valid:"Required"`
-	Id             int64    `cname:"项目ID" json:"id,string" valid:"Required"`
-	TemplateId     int64    `cname:"模板ID" json:"templateId,string"`
-	Recipients     []string `cname:"被评估人ID"  json:"recipients"`
-	TimeStart      string   `cname:"自评起始时间" json:"timeStart" valid:"Required"`
-	TimeEnd        string   `cname:"自评截止时间" json:"timeEnd" valid:"Required"`
-	KpiCycle       int      `cname:"评估周期" json:"kpiCycle" valid:"Required"`
-	KpiResultStart string   `cname:"绩效结果开始查看时间" json:"kpiResultStart"`
-	Activate       int      `cname:"启动项目" json:"activate"`
+	CompanyId  int64    `cname:"公司ID" json:"companyId"`
+	CycleId    int64    `cname:"周期ID" json:"cycleId,string" valid:"Required"`
+	Id         int64    `cname:"项目ID" json:"id,string" valid:"Required"`
+	TemplateId int64    `cname:"模板ID" json:"templateId,string"`
+	Recipients []string `cname:"被评估人ID"  json:"recipients"`
+	TimeStart  string   `cname:"自评起始时间" json:"timeStart" valid:"Required"`
+	TimeEnd    string   `cname:"自评截止时间" json:"timeEnd" valid:"Required"`
+	KpiCycle   int      `cname:"评估周期" json:"kpiCycle" valid:"Required"`
 }
 
 type CheckRecipientCommand struct {

@@ -135,110 +135,169 @@ func (rs *EvaluationProjectService) UpdateTemplate(in *command.UpdateProjectTemp
 	cycleRepository := factory.CreateEvaluationCycleRepository(map[string]interface{}{"transactionContext": transactionContext})
 	cycleTemplateRepository := factory.CreateEvaluationCycleTemplateRepository(map[string]interface{}{"transactionContext": transactionContext})
 
-	_, projects, err := projectRepository.Find(map[string]interface{}{"companyId": in.CompanyId, "cycleId": in.CycleId}, "template")
+	project, err := projectRepository.FindOne(map[string]interface{}{"id": in.Id})
 	if err != nil {
 		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
 	}
 
-	cycle, err := cycleRepository.FindOne(map[string]interface{}{"id": in.CycleId})
-	if err != nil {
-		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
-	}
+	// 如果是已经启用的项目，只能编辑环节的截至时间
+	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())
+		}
 
-	// 周期内的所有项目，员工不能重复被评估
-	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
+		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
 			}
 		}
-	}
-	repeatNum := 0
-	for i := range in.Recipients {
-		id := in.Recipients[i]
-		if _, ok := rids[id]; ok {
-			repeatNum++
+		// 项目起始截止时间（暂时环节中的时间未分开）
+		project.EndTime = end
+		project, err = projectRepository.Insert(project)
+		if err != nil {
+			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
 		}
-	}
-	if repeatNum > 0 {
-		return nil, application.ThrowError(application.BUSINESS_ERROR, fmt.Sprintf("有%d人已经在本周期其他项目内，需要将他们移除", repeatNum))
-	}
 
-	project, err := projectRepository.FindOne(map[string]interface{}{"id": in.Id})
-	if err != nil {
-		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
-	}
+		// 查看任务过程，重新日计算任务截至期
+		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())
+		}
 
-	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())
-	}
+		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 {
+				// 环节起始和截止本地时间
+				startLocal := task.TimeStart.Local()
+				endLocal := task.TimeEnd.Local()
+
+				// 在当前时间之前，则计算下一个周期时间
+				if startLocal.Before(now) {
+					nextTime := utils.NextTime(nowO, startLocal, task.KpiCycle)
+					task.NextSentAt = &nextTime
+				} else {
+					task.NextSentAt = &startLocal
+				}
+				// 如果超出截至时间，则周期置空
+				if task.NextSentAt.After(endLocal) {
+					task.NextSentAt = nil
+				}
+			} else {
+				// 新的截止时间在下一次发送周期任务之前，则结束
+				if end.Before(task.NextSentAt.Local()) {
+					task.NextSentAt = nil
+				} else {
+					// do nothing
+				}
+			}
+		}
 
-	if cycleTemplate == nil || cycleTemplate.Template == nil {
-		return nil, application.ThrowError(application.BUSINESS_ERROR, "请添加模板")
-	}
+		if err := transactionContext.CommitTransaction(); err != nil {
+			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
+		}
+		return project, nil
 
-	if len(in.Recipients) == 0 {
-		return nil, application.ThrowError(application.BUSINESS_ERROR, "请添加被评估人")
-	}
+	} 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))
+		}
 
-	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())
-	}
+		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, "请添加模板")
+		}
 
-	minTime := cycle.TimeStart.Local()
-	maxTime := cycle.TimeEnd.Local()
+		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())
+		}
 
-	if start.Before(minTime) {
-		return nil, application.ThrowError(application.BUSINESS_ERROR, "评估起始时间不能超出周期起始时间")
-	}
+		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()
 
-	if end.After(maxTime) {
-		return nil, application.ThrowError(application.BUSINESS_ERROR, "评估截至时间不能超出周期截至时间")
-	}
+		if start.Before(minTime) {
+			return nil, application.ThrowError(application.BUSINESS_ERROR, "评估起始时间不能超出周期起始时间")
+		}
 
-	//// FIXME 启动时，需要激活定时任务
-	//if in.Activate == 1 {
-	//	project.State = domain.ProjectStateEnable
-	//} else {
-	//	project.State = domain.ProjectStateWaitActive
-	//}
-	project.State = domain.ProjectStateWaitActive
+		if end.After(maxTime) {
+			return nil, application.ThrowError(application.BUSINESS_ERROR, "评估截至时间不能超出周期截至时间")
+		}
 
-	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 {
-			node.TimeStart = &kpiStart
-			node.TimeEnd = &maxTime // 绩效查看时间跟随周期截止时间
-		} else {
+		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 // 设置周期
 			node.TimeStart = &start
 			node.TimeEnd = &end
 		}
-	}
 
-	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())
+		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
 	}
-	return project, nil
 }
 
 func (rs *EvaluationProjectService) Get(in *command.GetProjectCommand) (interface{}, error) {
@@ -285,6 +344,7 @@ func (rs *EvaluationProjectService) Remove(in *command.DeleteProjectCommand) (in
 	}()
 
 	projectRepository := factory.CreateEvaluationProjectRepository(map[string]interface{}{"transactionContext": transactionContext})
+	taskRepository := factory.CreateNodeTaskRepository(map[string]interface{}{"transactionContext": transactionContext})
 
 	project, err := projectRepository.FindOne(map[string]interface{}{"id": in.Id})
 	if err != nil {
@@ -294,6 +354,17 @@ func (rs *EvaluationProjectService) Remove(in *command.DeleteProjectCommand) (in
 		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
 	}
 
+	// 查看任务过程，移除项目关联的所有任务
+	tasks, err := taskRepository.Find(map[string]interface{}{"projectId": 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())
+		}
+	}
+
 	if err := transactionContext.CommitTransaction(); err != nil {
 		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
 	}
@@ -314,6 +385,8 @@ func (rs *EvaluationProjectService) List(in *command.QueryProjectCommand) (inter
 	if err != nil {
 		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
 	}
+
+	now := time.Now().Unix()
 	pmpUsers := make([]*domain.User, 0)
 	pmpUserIds := make([]int64, 0)
 	for i := range projects {
@@ -322,7 +395,13 @@ func (rs *EvaluationProjectService) List(in *command.QueryProjectCommand) (inter
 			userId, _ := strconv.ParseInt(project.PmpIds[j], 10, 64)
 			pmpUserIds = append(pmpUserIds, userId)
 		}
+
+		// 当前时间超过截至时间显示【已结束】
+		if now > project.EndTime.Unix() {
+			project.State = domain.ProjectStateDisable
+		}
 	}
+
 	if len(pmpUserIds) > 0 {
 		userRepository := factory.CreateUserRepository(map[string]interface{}{"transactionContext": transactionContext})
 		_, users, _ := userRepository.Find(map[string]interface{}{"ids": pmpUserIds, "limit": len(pmpUserIds)})
@@ -342,29 +421,20 @@ func (rs *EvaluationProjectService) Activate(in *command.ActivateProjectCommand)
 	}()
 
 	projectRepository := factory.CreateEvaluationProjectRepository(map[string]interface{}{"transactionContext": transactionContext})
-	//cycleRepository := factory.CreateEvaluationCycleRepository(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 project.Template == nil {
 		return nil, application.ThrowError(application.BUSINESS_ERROR, "请添加评估模板")
 	}
-
 	if len(project.Recipients) == 0 {
 		return nil, application.ThrowError(application.BUSINESS_ERROR, "请添加被评估人")
 	}
 	if project.State == domain.TemplateStateEnable {
 		return nil, application.ThrowError(application.BUSINESS_ERROR, "项目已启动")
 	}
-	//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
 
 	project.State = domain.TemplateStateEnable
 	project, err = projectRepository.Insert(project)
@@ -422,42 +492,6 @@ func (rs *EvaluationProjectService) Activate(in *command.ActivateProjectCommand)
 	return project, nil
 }
 
-//
-//// 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
-//}
-
 func (rs *EvaluationProjectService) Copy(in *command.CopyProjectCommand) (interface{}, error) {
 	transactionContext, err := factory.ValidateStartTransaction(in)
 	if err != nil {

@@ -8,7 +8,7 @@ const (
 	ProjectStateWaitConfig int = 0 // 项目状态-待完成配置
 	ProjectStateWaitActive int = 1 // 项目状态-待启用
 	ProjectStateEnable     int = 2 // 项目状态-启用
-	ProjectStateDisable    int = 3 // 项目状态-停用
+	ProjectStateDisable    int = 3 // 项目状态-停用（假状态）
 )
 
 // 项目的评估内容配置
@@ -25,6 +25,8 @@ type EvaluationProject struct {
 	PmpIds     []string            `json:"pmpIds" comment:"项目管理员ID"`
 	Recipients []string            `json:"recipients" comment:"被评估人ID"`
 	Template   *EvaluationTemplate `json:"template" comment:"评估模板"`
+	BeginTime  time.Time           `json:"beginTime" comment:"项目起始时间"`
+	EndTime    time.Time           `json:"endTime" comment:"项目截至时间"`
 	CreatedAt  time.Time           `json:"createdAt" comment:"创建时间"`
 	UpdatedAt  time.Time           `json:"updatedAt" comment:"更新时间"`
 	DeletedAt  *time.Time          `json:"deletedAt" comment:"删除时间"`

@@ -19,6 +19,8 @@ type EvaluationProject struct {
 	PmpIds     []string                   `comment:"项目管理员ID"`
 	Recipients []string                   `comment:"被评估人ID"`
 	Template   *domain.EvaluationTemplate `comment:"评估模板"`
+	BeginTime  time.Time                  `comment:"项目起始时间"`
+	EndTime    time.Time                  `comment:"项目截至时间  "`
 	CreatedAt  time.Time                  `comment:"创建时间"`
 	UpdatedAt  time.Time                  `comment:"更新时间"`
 	DeletedAt  *time.Time                 `comment:"删除时间"`

-package models
-
-import (
-	"time"
-)
-
-type NodeTimerTask struct {
-	tableName  struct{}   `pg:"node_timer_task" comment:"流程节点定时任务"`
-	Id         int64      `comment:"ID"`
-	CompanyId  int64      `comment:"公司ID"`
-	CycleId    int64      `comment:"周期ID"`
-	ProjectId  int64      `comment:"项目ID"`
-	NodeId     int64      `comment:"流程ID"`
-	LastSentAt *time.Time `comment:"最后一次发送时间"`
-	NextSentAt *time.Time `comment:"下一次发送时间"`
-	CreatedAt  time.Time  `comment:"创建时间"`
-	UpdatedAt  time.Time  `comment:"更新时间"`
-	DeletedAt  *time.Time `comment:"删除时间"`
-}

@@ -148,6 +148,9 @@ func (repo *EvaluationCycleRepository) Find(queryOptions map[string]interface{})
 		query.Where("time_end>=?", t)
 	}
 
+	// 按创建时间降序
+	query.Order("created_at DESC")
+
 	count, err := query.SelectAndCount()
 	if err != nil {
 		return 0, nil, err

@@ -34,6 +34,8 @@ func (repo *EvaluationProjectRepository) TransformToDomain(m *models.EvaluationP
 		PmpIds:     m.PmpIds,
 		Recipients: m.Recipients,
 		Template:   m.Template,
+		BeginTime:  m.BeginTime,
+		EndTime:    m.EndTime,
 		CreatedAt:  m.CreatedAt,
 		UpdatedAt:  m.UpdatedAt,
 		DeletedAt:  m.DeletedAt,
@@ -54,6 +56,8 @@ func (repo *EvaluationProjectRepository) TransformToModel(d *domain.EvaluationPr
 		PmpIds:     d.PmpIds,
 		Recipients: d.Recipients,
 		Template:   d.Template,
+		BeginTime:  d.BeginTime,
+		EndTime:    d.EndTime,
 		CreatedAt:  d.CreatedAt,
 		UpdatedAt:  d.UpdatedAt,
 		DeletedAt:  d.DeletedAt,
@@ -166,6 +170,8 @@ func (repo *EvaluationProjectRepository) Find(queryOptions map[string]interface{
 	if v, ok := queryOptions["offset"].(int64); ok {
 		query.Offset(int(v))
 	}
+	// 按创建时间降序
+	query.Order("created_at DESC")
 
 	count, err := query.SelectAndCount()
 	if err != nil {

@@ -21,8 +21,6 @@ func (controller *ProjectController) CreateProject() {
 		ua := middlewares.GetUser(controller.Ctx)
 		in.CompanyId = ua.CompanyId
 		in.CreatorId = ua.UserId
-		//in.CompanyId = middlewares.GetCompanyId(controller.Ctx)
-		//in.CreatorId = middlewares.GetUserId(controller.Ctx)
 		controller.Response(ruService.Create(in))
 	}
 }
@@ -35,7 +33,6 @@ func (controller *ProjectController) UpdateProject() {
 	} else {
 		ua := middlewares.GetUser(controller.Ctx)
 		in.CompanyId = ua.CompanyId
-		//in.CompanyId = middlewares.GetCompanyId(controller.Ctx)
 		controller.Response(ruService.Update(in))
 	}
 }
@@ -48,7 +45,6 @@ func (controller *ProjectController) UpdateProjectForTemplate() {
 	} else {
 		ua := middlewares.GetUser(controller.Ctx)
 		in.CompanyId = ua.CompanyId
-		//in.CompanyId = middlewares.GetCompanyId(controller.Ctx)
 		controller.Response(ruService.UpdateTemplate(in))
 	}
 }
@@ -86,7 +82,6 @@ func (controller *ProjectController) ListProject() {
 		}
 		ua := middlewares.GetUser(controller.Ctx)
 		in.CompanyId = ua.CompanyId
-		//in.CompanyId = middlewares.GetCompanyId(controller.Ctx)
 		controller.Response(ruService.List(in))
 	}
 }

@@ -5,6 +5,7 @@ import (
 	timeconv "github.com/Andrew-M-C/go.timeconv"
 	"github.com/beego/beego/v2/core/validation"
 	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/domain"
+	"math"
 	"reflect"
 	"strings"
 	"time"
@@ -53,24 +54,92 @@ func NextTime(now0 time.Time, start time.Time, kpiCycle int) time.Time {
 		nextTime = timeconv.AddDate(start0, 0, 0, cycleCount*7)
 		break
 	case domain.KpiCycleOneMonth:
-		nextTime = timeconv.AddDate(start0, 0, 1, 0)
+		offsetMonth := SubMonth(now0, start0)
+		nextTime = timeconv.AddDate(start0, 0, offsetMonth, 0)
+		if nextTime.Before(now0) {
+			nextTime = timeconv.AddDate(nextTime, 0, 1, 0)
+		}
 		break
 	case domain.KpiCycleTwoMonth:
-		nextTime = timeconv.AddDate(start0, 0, 2, 0)
+		offsetMonth := SubMonth(now0, start0)
+		multiple := float64(offsetMonth) / 2
+		if multiple == 0 {
+			multiple = 1
+		} else {
+			multiple = math.Ceil(multiple)
+		}
+		nextTime = timeconv.AddDate(start0, 0, int(multiple)*2, 0)
+		if nextTime.Before(now0) {
+			nextTime = timeconv.AddDate(nextTime, 0, 2, 0)
+		}
 		break
 	case domain.KpiCycleThreeMonth:
-		nextTime = timeconv.AddDate(start0, 0, 3, 0)
+		offsetMonth := SubMonth(now0, start0)
+		multiple := float64(offsetMonth) / 3
+		if multiple == 0 {
+			multiple = 1
+		} else {
+			multiple = math.Ceil(multiple)
+		}
+		nextTime = timeconv.AddDate(start0, 0, int(multiple)*3, 0)
+		if nextTime.Before(now0) {
+			nextTime = timeconv.AddDate(nextTime, 0, 3, 0)
+		}
 		break
 	case domain.KpiCycleSixMonth:
-		nextTime = timeconv.AddDate(start0, 0, 6, 0)
+		offsetMonth := SubMonth(now0, start0)
+		multiple := float64(offsetMonth) / 6
+		if multiple == 0 {
+			multiple = 1
+		} else {
+			multiple = math.Ceil(multiple)
+		}
+		nextTime = timeconv.AddDate(start0, 0, int(multiple)*6, 0)
+		if nextTime.Before(now0) {
+			nextTime = timeconv.AddDate(nextTime, 0, 6, 0)
+		}
 		break
 	case domain.KpiCycleYear:
-		nextTime = timeconv.AddDate(start0, 1, 0, 0)
+		offsetMonth := SubMonth(now0, start0)
+		multiple := float64(offsetMonth) / 12
+		if multiple == 0 {
+			multiple = 1
+		} else {
+			multiple = math.Ceil(multiple)
+		}
+		nextTime = timeconv.AddDate(start0, 0, int(multiple)*12, 0)
+		if nextTime.Before(now0) {
+			nextTime = timeconv.AddDate(nextTime, 0, 12, 0)
+		}
 		break
 	}
 	return nextTime
 }
 
+// SubMonth 计算日期相差多少月
+func SubMonth(t1, t2 time.Time) (month int) {
+	y1 := t1.Year()
+	y2 := t2.Year()
+	m1 := int(t1.Month())
+	m2 := int(t2.Month())
+	d1 := t1.Day()
+	d2 := t2.Day()
+
+	yearInterval := y1 - y2
+	// 如果 d1的 月-日 小于 d2的 月-日 那么 yearInterval-- 这样就得到了相差的年数
+	if m1 < m2 || (m1 == m2 && d1 < d2) {
+		yearInterval--
+	}
+	// 获取月数差值
+	monthInterval := (m1 + 12) - m2
+	if d1 < d2 {
+		monthInterval--
+	}
+	monthInterval %= 12
+	month = yearInterval*12 + monthInterval
+	return
+}
+
 // NextTimeInc 0点时刻为标准计算
 func NextTimeInc(start time.Time, kpiCycle int) time.Time {
 	year, month, day := start.Date()