package service

import (
	"fmt"
	"strconv"
	"strings"
	"time"

	"github.com/linmadan/egglib-go/core/application"
	"github.com/linmadan/egglib-go/utils/tool_funs"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/factory"
	roleService "gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/role"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/summary_evaluation/adapter"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/summary_evaluation/command"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/domain"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/infrastructure/dao"
)

// Evaluation360List 获取360综评列表
func (srv *SummaryEvaluationService) Evaluation360List(param *command.QueryEvaluation360List) (map[string]interface{}, error) {
	transactionContext, err := factory.ValidateStartTransaction(param)
	if err != nil {
		return nil, err
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()

	evaluationRepo := factory.CreateSummaryEvaluationRepository(map[string]interface{}{"transactionContext": transactionContext})
	evaluationItemRepo := factory.CreateEvaluationItemUsedRepository(map[string]interface{}{"transactionContext": transactionContext})
	itemValueRepo := factory.CreateSummaryEvaluationValueRepository(map[string]interface{}{"transactionContext": transactionContext})

	var searchTargetName string
	if len(param.SearchName) > 0 {
		searchTargetName = "%" + param.SearchName + "%"
	} else {
		searchTargetName = ""
	}
	limit := param.PageSize
	offset := limit * (param.PageNumber - 1)
	if offset < 0 {
		offset = 0
	}
	count, list, err := evaluationRepo.Find(map[string]interface{}{
		"companyId":      param.CompanyId,
		"cycleId":        param.CycleId,
		"executorId":     param.UserId,
		"types":          domain.Evaluation360,
		"targetUserName": searchTargetName,
		"limit":          limit,
		"offset":         offset,
		"beginTime":      time.Now(),
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	evaluationVersion := ""

	ids := make([]int, 0)
	projectIds := make([]int, 0)
	for i := range list {
		ids = append(ids, list[i].Id)
		projectIds = append(projectIds, list[i].EvaluationProjectId)
		evaluationVersion = string(list[i].Version)
	}

	// 固定列
	changeableHeader := []adapter.TableHeader{
		{Key: "targetUserName", Name: "姓名"},
		{Key: "statusVal", Name: "状态"},
		{Key: "relation", Name: "360°评估关系"},
		{Key: "endTime", Name: "360°评估截止日期"},
	}
	changeableRowMap := map[int]map[string]interface{}{}    // k,v（用户ID -> 数据集合）行数据内容
	itemMap := map[int][]*domain.EvaluationItemUsed{}       // k,v（项目ID -> 评估数组）归类评估内容
	valueMap := map[string]*domain.SummaryEvaluationValue{} // k,v（周期+评估 -> 提交值）
	uniqueColumnsMap := map[string]string{}                 // 列名称唯一

	if len(ids) > 0 {
		// 评估内容（注.使用自评模板，并过滤出360综评人的评估内容）
		_, itemList, err := evaluationItemRepo.Find(map[string]interface{}{"evaluationProjectIds": projectIds, "nodeType": domain.LinkNodeSelfAssessment, "evaluatorId": param.UserId})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		// 填写值
		_, valueList, err := itemValueRepo.Find(map[string]interface{}{"summaryEvaluationIdList": ids})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}

		if err := transactionContext.CommitTransaction(); err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}

		for i := range valueList {
			key := fmt.Sprintf("%d-%d", valueList[i].SummaryEvaluationId, valueList[i].EvaluationItemId)
			valueMap[key] = valueList[i]
		}

		for i := range itemList {
			item := itemList[i]
			key := fmt.Sprintf("k%d", i)
			name := fmt.Sprintf("%s-%s", item.Category, item.Name)
			if _, ok := uniqueColumnsMap[name]; !ok {
				changeableHeader = append(changeableHeader, adapter.TableHeader{Key: key, Name: name})
				uniqueColumnsMap[name] = key
			}

			pList, ok := itemMap[item.EvaluationProjectId]
			if !ok {
				pList = make([]*domain.EvaluationItemUsed, 0)
			}
			itemMap[item.EvaluationProjectId] = append(pList, item)
		}
	}

	now := time.Now().Local() // 当前时间
	var rowMap map[string]interface{}
	for i := range list {
		v := list[i]
		if rm, ok := changeableRowMap[v.TargetUser.UserId]; ok {
			rowMap = rm
		} else {
			rowMap = map[string]interface{}{}
			changeableRowMap[v.TargetUser.UserId] = rowMap
		}

		endTime := v.EndTime.Local()
		statusVal := ""
		if v.Status == domain.EvaluationCompleted {
			if v.CompletedAt > v.EndTime.Unix() {
				statusVal = "逾期完成"
			} else {
				statusVal = "已完成"
			}
		} else {
			if now.After(endTime) {
				statusVal = "已逾期"
			} else {
				statusVal = "待完成"
			}
		}
		rowMap["id"] = v.Id
		rowMap["targetUserId"] = strconv.Itoa(v.TargetUser.UserId)
		rowMap["targetUserName"] = v.TargetUser.UserName
		rowMap["statusVal"] = statusVal
		rowMap["relation"] = "项目组员"
		rowMap["endTime"] = endTime.Local().Format("2006-01-02 15:04")

		// 当前项目所有评估内容
		if pList, ok := itemMap[v.EvaluationProjectId]; ok {
			for _, item := range pList {
				name := fmt.Sprintf("%s-%s", item.Category, item.Name)
				if key, ok := uniqueColumnsMap[name]; ok { // 动态列用name -> key
					valueKey := fmt.Sprintf("%d-%d", v.Id, item.Id)
					if it, ok := valueMap[valueKey]; ok {
						if evaluationVersion == string(domain.EvaluationV1) {
							if it.Weight > 0 {
								rowMap[key] = it.Score
							} else {
								rowMap[key] = it.Rating.Code
							}
						} else if evaluationVersion == string(domain.EvaluationV2) {
							rowMap[key] = it.Score
						}
					} else {
						rowMap[key] = ""
					}
				}
			}
		}
	}

	targetList := make([]map[string]interface{}, 0)
	for _, v1 := range list {
		rowMap := changeableRowMap[v1.TargetUser.UserId]
		for _, v2 := range changeableHeader { // 填充部分动态列缺失字段
			if _, ok := rowMap[v2.Key]; !ok {
				rowMap[v2.Key] = ""
			}
		}
		targetList = append(targetList, rowMap)
	}

	// 外层显示截止时间
	endTime := ""
	if len(list) > 0 {
		endTime = list[0].EndTime.Local().Format("2006-01-02 15:04:05")
	}

	result := &adapter.SummaryEvaluationAdapter{
		TableHeader: changeableHeader,
		Total:       count,
		List:        targetList,
	}
	grid := map[string]interface{}{
		"grid":    result,
		"endTime": endTime,
	}
	return grid, nil
}

// GetEvaluation360 获取360综评详情（我评估目标用户）
func (srv *SummaryEvaluationService) GetEvaluation360(param *command.QueryEvaluation360My) (map[string]interface{}, error) {
	transactionContext, err := factory.ValidateStartTransaction(param)
	if err != nil {
		return nil, err
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()

	evaluationRepo := factory.CreateSummaryEvaluationRepository(map[string]interface{}{"transactionContext": transactionContext})
	evaluationItemRepo := factory.CreateEvaluationItemUsedRepository(map[string]interface{}{"transactionContext": transactionContext})
	itemValueRepo := factory.CreateSummaryEvaluationValueRepository(map[string]interface{}{"transactionContext": transactionContext})

	sEvaluation, err := evaluationRepo.FindOne(map[string]interface{}{"id": param.SummaryEvaluationId})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	// 360评估内容（自评模板、筛选项目评估人）
	_, itemList, err := evaluationItemRepo.Find(map[string]interface{}{
		"evaluationProjectId": sEvaluation.EvaluationProjectId,
		"nodeType":            domain.LinkNodeSelfAssessment,
		"companyId":           param.CompanyId,
		"evaluatorId":         param.UserId,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	// 评估内容对应的分数
	_, itemValues, err := itemValueRepo.Find(map[string]interface{}{"summaryEvaluationId": sEvaluation.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	itemValuesAdapter := srv.buildSummaryItemValue(itemList, itemValues)
	for i := range itemValuesAdapter { // 评估人名称赋值
		itemValuesAdapter[i].EvaluatorName = sEvaluation.Executor.UserName
	}
	// 评估项截止时间
	endTime := sEvaluation.EndTime.Local().Format("2006-01-02 15:04:05")
	return map[string]interface{}{"endTime": endTime, "version": sEvaluation.Version, "list": itemValuesAdapter}, nil
}

// GetEvaluation360Complete 获取360综评详情(他人评估目标用户)（已完成状态）
func (srv *SummaryEvaluationService) GetEvaluation360Complete(param *command.QueryEvaluation360) ([]adapter.EvaluationItemAdapter, error) {
	transactionContext, err := factory.ValidateStartTransaction(param)
	if err != nil {
		return nil, err
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()

	evaluationRepo := factory.CreateSummaryEvaluationRepository(map[string]interface{}{"transactionContext": transactionContext})
	evaluationItemRepo := factory.CreateEvaluationItemUsedRepository(map[string]interface{}{"transactionContext": transactionContext})
	itemValueRepo := factory.CreateSummaryEvaluationValueRepository(map[string]interface{}{"transactionContext": transactionContext})
	_, evaluations, err := evaluationRepo.Find(map[string]interface{}{
		"companyId":    param.CompanyId,
		"cycleId":      param.CycleId,
		"targetUserId": param.TargetUserId,
		"types":        domain.Evaluation360,
		"status":       domain.EvaluationCompleted,
		"limit":        1000,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	if len(evaluations) == 0 {
		list := make([]adapter.EvaluationItemAdapter, 0)
		return list, nil
	}

	executorMap := map[int]domain.StaffDesc{} // 执行人
	evaluationIds := make([]int, 0)           // 评估周期ID
	for i := range evaluations {
		executor := evaluations[i].Executor
		executorMap[executor.UserId] = executor

		evaluationIds = append(evaluationIds, evaluations[i].Id)
	}
	// 得到项目ID
	evaluationProjectId := evaluations[0].EvaluationProjectId
	// 360评估内容（自评模板）
	_, itemList, err := evaluationItemRepo.Find(map[string]interface{}{
		"evaluationProjectId": evaluationProjectId,
		"nodeType":            domain.LinkNodeSelfAssessment,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	// 评估内容对应的分数
	_, itemValues, err := itemValueRepo.Find(map[string]interface{}{
		"summaryEvaluationIdList": evaluationIds,
		"types":                   domain.Evaluation360,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	filterItemList := make([]*domain.EvaluationItemUsed, 0) // 筛选有评估人的评估内容
	for i := range itemList {
		if itemList[i].EvaluatorId > 0 {
			filterItemList = append(filterItemList, itemList[i])
		}
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	itemValuesAdapter := srv.buildSummaryItemValue(filterItemList, itemValues)
	for i := range itemValuesAdapter { // 评估人名称赋值
		if executor, ok := executorMap[itemValuesAdapter[i].EvaluatorId]; ok {
			itemValuesAdapter[i].EvaluatorName = executor.UserName
		}
	}
	return itemValuesAdapter, nil
}

// EvaluationHRBPList 获取人资综评列表
func (srv *SummaryEvaluationService) EvaluationHRBPList(param *command.QueryEvaluationHRList) (map[string]interface{}, error) {
	transactionContext, err := factory.ValidateStartTransaction(param)
	if err != nil {
		return nil, err
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()

	// 必须是HRBP权限的人才能编辑操作
	hrbp, err := roleService.GetHrBp(transactionContext, param.CompanyId, param.UserId)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if hrbp != domain.RoleTypeSystem {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "没有操作权限")
	}

	evaluationRepo := factory.CreateSummaryEvaluationRepository(map[string]interface{}{"transactionContext": transactionContext})
	staffAssessDaoRepo := dao.NewStaffAssessDao(map[string]interface{}{"transactionContext": transactionContext})
	userRepo := factory.CreateUserRepository(map[string]interface{}{"transactionContext": transactionContext})
	positionRepo := factory.CreatePositionRepository(map[string]interface{}{"transactionContext": transactionContext})

	limit := param.PageSize
	offset := limit * (param.PageNumber - 1)
	if offset < 0 {
		offset = 0
	}
	condition := map[string]interface{}{
		"companyId": param.CompanyId,
		"cycleId":   param.CycleId,
		"types":     domain.EvaluationHrbp,
		"limit":     limit,
		"offset":    offset,
		"beginTime": time.Now(),
	}
	if len(param.SearchName) > 0 {
		condition["targetUserName"] = "%" + param.SearchName + "%"
	}
	count, list, err := evaluationRepo.Find(condition)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	userIds := make([]int, 0)
	projectIds := make([]int, 0)
	projectCountMap := map[string]int{}         // 自评逾期数量
	userMap := map[int64]*domain.User{}         // 用户
	positionMap := map[int64]*domain.Position{} // 职位

	for i := range list {
		it := list[i]
		userIds = append(userIds, it.TargetUser.UserId)
		projectIds = append(projectIds, list[i].EvaluationProjectId)
	}
	if len(userIds) > 0 {
		_, users, err := userRepo.Find(map[string]interface{}{"ids": userIds, "companyId": param.CompanyId})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		positionIds := make([]int, 0)
		for i := range users {
			userMap[users[i].Id] = users[i]
			positionIds = append(positionIds, users[i].PositionId...)

		}
		if len(positionIds) > 0 {
			_, positions, err := positionRepo.Find(map[string]interface{}{"ids": positionIds, "companyId": param.CompanyId})
			if err != nil {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
			}
			for i := range positions {
				positionMap[positions[i].Id] = positions[i]
			}
		}
	}

	if len(projectIds) > 0 {
		targetCount, err := staffAssessDaoRepo.CountUncompletedSelfAssess(param.CompanyId, projectIds)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		for i := range targetCount {
			key := fmt.Sprintf("%d-%d", targetCount[i].EvaluationProjectId, targetCount[i].TargetUserId)
			projectCountMap[key] = targetCount[i].Cnt
		}
	}

	now := time.Now().Local() // 当前时间
	resultList := make([]*adapter.SummaryEvaluationHRBPAdapter, 0)
	for i := range list {
		v := list[i]
		endTime := v.EndTime.Local()
		// 状态
		statusVal := ""
		if v.Status == domain.EvaluationCompleted {
			if v.CompletedAt > v.EndTime.Unix() {
				statusVal = "逾期完成"
			} else {
				statusVal = "已完成"
			}
		} else {
			if now.After(endTime) {
				statusVal = "已逾期"
			} else {
				statusVal = "待完成"
			}
		}

		// 部门拼接
		var departmentBuild strings.Builder
		departmentBuild.WriteString("")
		for i2 := range v.TargetDepartment {
			departmentBuild.WriteString(v.TargetDepartment[i2].DepartmentName)
			if i2 != len(v.TargetDepartment)-1 {
				departmentBuild.WriteString(",")
			}
		}
		// 入职时间
		entryTime := ""
		// 职位拼接
		var positionBuild strings.Builder
		positionBuild.WriteString("")
		if user, ok := userMap[int64(v.TargetUser.UserId)]; ok {
			for i2 := range user.PositionId {
				if position, ok := positionMap[int64(user.PositionId[i2])]; ok {
					positionBuild.WriteString(position.Name)
					if i2 != len(user.PositionId)-1 {
						departmentBuild.WriteString(",")
					}
				}
			}
			entryTime = user.EntryTime
		}

		// 自评逾期数量
		overdueCount := 0
		key := fmt.Sprintf("%d-%d", v.EvaluationProjectId, v.TargetUser.UserId)
		if cnt, ok := projectCountMap[key]; ok {
			overdueCount = cnt
		}

		result := &adapter.SummaryEvaluationHRBPAdapter{
			Id:             v.Id,
			TargetUserId:   v.TargetUser.UserId,
			TargetUserName: v.TargetUser.UserName,
			Department:     departmentBuild.String(),
			Position:       positionBuild.String(),
			DutyTime:       entryTime,
			Status:         statusVal,
			EndTime:        endTime.Local().Format("2006-01-02 15:04"),
			OverdueCount:   overdueCount,
		}
		resultList = append(resultList, result)
	}

	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	// 外层显示截止时间
	endTime := ""
	if len(list) > 0 {
		endTime = list[0].EndTime.Local().Format("2006-01-02 15:04:05")
	}
	grid := tool_funs.SimpleWrapGridMap(int64(count), resultList)
	grid["endTime"] = endTime
	return grid, nil
	//return tool_funs.SimpleWrapGridMap(int64(count), resultList), nil
}

// GetEvaluationHRBP 获取人资综评详情
func (srv *SummaryEvaluationService) GetEvaluationHRBP(param *command.QueryEvaluationHRBPMy) (map[string]interface{}, error) {
	transactionContext, err := factory.ValidateStartTransaction(param)
	if err != nil {
		return nil, err
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()

	evaluationRepo := factory.CreateSummaryEvaluationRepository(map[string]interface{}{"transactionContext": transactionContext})
	evaluationItemRepo := factory.CreateEvaluationItemUsedRepository(map[string]interface{}{"transactionContext": transactionContext})
	itemValueRepo := factory.CreateSummaryEvaluationValueRepository(map[string]interface{}{"transactionContext": transactionContext})

	sEvaluation, err := evaluationRepo.FindOne(map[string]interface{}{"id": param.SummaryEvaluationId})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	// 自评评估内容（自评模板、筛选项目评估人）
	_, itemList, err := evaluationItemRepo.Find(map[string]interface{}{
		"evaluationProjectId": sEvaluation.EvaluationProjectId,
		"nodeType":            domain.LinkNodeSelfAssessment,
		"evaluatorId":         -1,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	// 评估内容对应的分数
	_, itemValues, err := itemValueRepo.Find(map[string]interface{}{"summaryEvaluationId": sEvaluation.Id})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	itemValuesAdapter := srv.buildSummaryItemValue(itemList, itemValues)
	for i := range itemValuesAdapter { // 评估人名称赋值
		itemValuesAdapter[i].EvaluatorName = sEvaluation.Executor.UserName
	}

	// 评估项截止时间
	endTime := sEvaluation.EndTime.Local().Format("2006-01-02 15:04:05")
	return map[string]interface{}{"endTime": endTime, "version": sEvaluation.Version, "list": itemValuesAdapter}, nil
}

// GetEvaluationHRBPComplete 获取人资综评详情（已完成状态）
func (srv *SummaryEvaluationService) GetEvaluationHRBPComplete(param *command.QueryEvaluationHRBP) (*[]adapter.EvaluationItemAdapter, error) {
	transactionContext, err := factory.ValidateStartTransaction(param)
	if err != nil {
		return nil, err
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()

	evaluationRepo := factory.CreateSummaryEvaluationRepository(map[string]interface{}{"transactionContext": transactionContext})
	evaluationItemRepo := factory.CreateEvaluationItemUsedRepository(map[string]interface{}{"transactionContext": transactionContext})
	itemValueRepo := factory.CreateSummaryEvaluationValueRepository(map[string]interface{}{"transactionContext": transactionContext})

	_, evaluations, err := evaluationRepo.Find(map[string]interface{}{
		"limit":        99999,
		"companyId":    param.CompanyId,
		"cycleId":      param.CycleId,
		"targetUserId": param.TargetUserId,
		"status":       domain.EvaluationCompleted,
		"types":        domain.EvaluationHrbp},
	)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	if len(evaluations) == 0 {
		list := make([]adapter.EvaluationItemAdapter, 0)
		return &list, nil
	}

	evaluationIds := make([]int, 0) // 评估周期ID
	for i := range evaluations {
		evaluationIds = append(evaluationIds, evaluations[i].Id)
	}
	// 得到项目ID
	evaluationProjectId := evaluations[0].EvaluationProjectId

	// 自评评估内容（自评模板、筛选项目评估人）
	_, itemList, err := evaluationItemRepo.Find(map[string]interface{}{
		"evaluationProjectId": evaluationProjectId,
		"nodeType":            domain.LinkNodeSelfAssessment,
		"evaluatorId":         -1,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	// 评估内容对应的分数
	_, itemValues, err := itemValueRepo.Find(map[string]interface{}{
		"summaryEvaluationIdList": evaluationIds,
		"types":                   domain.EvaluationHrbp,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	itemValuesAdapter := srv.buildSummaryItemValue(itemList, itemValues)
	for i := range itemValuesAdapter { // 评估人名称赋值
		itemValuesAdapter[i].EvaluatorName = evaluations[0].Executor.UserName
	}
	return &itemValuesAdapter, nil
}

// GetUnconfirmedCycleList 获取未确认绩效成绩的周期列表
func (srv *SummaryEvaluationService) GetUnconfirmedCycleList(companyId int, userId int) (map[string]interface{}, error) {
	transactionContext, err := factory.StartTransaction()
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	evaluationDao := dao.NewSummaryEvaluationDao(map[string]interface{}{"transactionContext": transactionContext})

	cycles, err := evaluationDao.TargetUnconfirmedCycleList(companyId, userId)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取周期列表"+err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	var cycleList []adapter.CycleListAdapter
	nowTime := time.Now()
	for _, v := range cycles {
		if nowTime.Before(v.EndTime) {
			continue
		}
		cycleList = append(cycleList, adapter.CycleListAdapter{
			CycleId:   v.CycleId,
			CycleName: v.CycleName,
		})
	}
	return tool_funs.SimpleWrapGridMap(int64(len(cycleList)), cycleList), nil
}