package service

import (
	"errors"
	"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"
	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/infrastructure/xredis"
)

type SummaryEvaluationService struct {
}

func NewSummaryEvaluationService() *SummaryEvaluationService {
	newService := &SummaryEvaluationService{}
	return newService
}

// GetExecutorCycleList
// 获取评估执行人可用的周期列表
func (srv *SummaryEvaluationService) GetExecutorCycleList(param *command.QueryCycleList) (map[string]interface{}, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	evaluationDao := dao.NewSummaryEvaluationDao(map[string]interface{}{
		"transactionContext": transactionContext,
	})

	flagHrbp, err := roleService.GetHrBp(transactionContext, param.CompanyId, param.UserId)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	var isHrbp bool
	if flagHrbp == 1 {
		isHrbp = true
	}
	limit := 300
	offset := 0
	if param.PageSize > 0 {
		limit = param.PageSize
	}
	if param.PageNumber > 0 {
		offset = (param.PageNumber - 1) * param.PageSize
	}

	cycleData, err := evaluationDao.GetExecutorCycleList(param.CompanyId, param.UserId, offset, limit, isHrbp)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取周期列表"+err.Error())
	}

	cnt, err := evaluationDao.CountExecutorCycleList(param.CompanyId, param.UserId, isHrbp)
	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())
	}
	cycleList := []adapter.CycleListAdapter{}
	for _, v := range cycleData {
		m := adapter.CycleListAdapter{
			CycleId:   v.CycleId,
			CycleName: v.CycleName,
		}
		cycleList = append(cycleList, m)
	}
	return tool_funs.SimpleWrapGridMap(int64(cnt), cycleList), nil
}

// GetMenu
// 根据周期获取菜单显示
func (srv *SummaryEvaluationService) GetMenu(param *command.QueryMenu) (map[string]interface{}, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	evaluationRepo := factory.CreateSummaryEvaluationRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})

	//查找我的绩效
	_, selfEvaluation, err := evaluationRepo.Find(map[string]interface{}{
		"types":      int(domain.EvaluationSelf),
		"cycleId":    param.CycleId,
		"executorId": param.UserId,
		"limit":      1,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	var cntAll360 int
	var cntUncompleted360 int
	//查找360评估,统计全部的
	cntAll360, _, err = evaluationRepo.Find(map[string]interface{}{
		"types":      int(domain.Evaluation360),
		"executorId": param.UserId,
		"limit":      1,
		"cycleId":    param.CycleId,
		"beginTime":  time.Now(),
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if cntAll360 > 0 {
		//查找360评估,统计未完成的
		cntUncompleted360, _, err = evaluationRepo.Find(map[string]interface{}{
			"types":      int(domain.Evaluation360),
			"executorId": param.UserId,
			"limit":      1,
			"cycleId":    param.CycleId,
			"status":     string(domain.EvaluationUncompleted),
			"beginTime":  time.Now(),
		})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
	}

	var cntAllSuper int
	var cntUncompletedSuper int

	//查询需要执行上级评估,全部的
	cntAllSuper, _, err = evaluationRepo.Find(map[string]interface{}{
		"types":      int(domain.EvaluationSuper),
		"executorId": param.UserId,
		"limit":      1,
		"cycleId":    param.CycleId,
		"beginTime":  time.Now(),
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if cntAllSuper > 0 {
		//查询需要执行上级评估,统计未完成
		cntUncompletedSuper, _, err = evaluationRepo.Find(map[string]interface{}{
			"types":      int(domain.EvaluationSuper),
			"executorId": param.UserId,
			"limit":      1,
			"cycleId":    param.CycleId,
			"status":     string(domain.EvaluationUncompleted),
			"beginTime":  time.Now(),
		})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
	}

	var cntAllHrbp int
	var cntUncompletedHrbp int

	//查询需要执行人资评估,全部的
	cntAllHrbp, _, err = evaluationRepo.Find(map[string]interface{}{
		"types":     int(domain.EvaluationHrbp),
		"limit":     1,
		"cycleId":   param.CycleId,
		"beginTime": time.Now(),
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if cntAllHrbp > 0 {
		// 查询需要执行人资评估,统计未完成
		cntUncompletedHrbp, _, err = evaluationRepo.Find(map[string]interface{}{
			"types":     int(domain.EvaluationHrbp),
			"limit":     1,
			"cycleId":   param.CycleId,
			"status":    string(domain.EvaluationUncompleted),
			"beginTime": time.Now(),
		})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
	}
	isHrbp, err := roleService.GetHrBp(transactionContext, param.CompanyId, param.UserId)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	//查找当前周期,我的考核结果
	_, myEvaluationFinish, _ := evaluationRepo.Find(map[string]interface{}{
		"types":        int(domain.EvaluationFinish),
		"limit":        1,
		"targetUserId": param.UserId,
		"cycleId":      param.CycleId,
		"beginTime":    time.Now(),
	})

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

	menuList := []adapter.MenuListAdapter{}

	//模块-我的绩效
	menu1 := adapter.MenuListAdapter{
		CycleId:    0,
		NodeName:   "我的绩效",
		StatusName: "",
		Types:      "",
		Child:      []adapter.MenuListAdapter{},
	}
	menu1_1 := adapter.MenuListAdapter{
		CycleId:      param.CycleId,
		NodeName:     "填写综合自评",
		StatusName:   "",
		TargetUserId: param.UserId,
		Types:        "填写综合自评",
	}
	menu1_2 := adapter.MenuListAdapter{
		CycleId:      param.CycleId,
		NodeName:     "查看我的绩效",
		StatusName:   "",
		TargetUserId: param.UserId,
		Types:        "查看我的绩效",
	}
	if len(selfEvaluation) > 0 {
		if selfEvaluation[0].Status == domain.EvaluationCompleted {
			menu1_1.StatusName = "已完成"
		} else {
			menu1_1.StatusName = "未完成"
		}
		menu1.Child = append(menu1.Child, menu1_1)
	}
	if len(myEvaluationFinish) > 0 {
		if myEvaluationFinish[0].CheckResult == domain.EvaluationCheckCompleted {
			menu1_2.StatusName = "已完成"
		} else {
			menu1_2.StatusName = "未完成"
		}
		menu1.Child = append(menu1.Child, menu1_2)
	}

	if len(selfEvaluation) > 0 {
		menuList = append(menuList, menu1)
	}
	menu2 := adapter.MenuListAdapter{
		CycleId:    0,
		NodeName:   "给他人评估",
		StatusName: "",
		Types:      "",
		Child:      []adapter.MenuListAdapter{},
	}
	menu2_1 := adapter.MenuListAdapter{
		CycleId:    param.CycleId,
		NodeName:   "360综评",
		StatusName: "",
		Types:      "360综评",
	}
	if cntUncompleted360 > 0 {
		menu2_1.StatusName = "未完成"
	} else if cntAll360 > 0 {
		menu2_1.StatusName = "已完成"
	}
	menu2.Child = append(menu2.Child, menu2_1)
	if cntAll360 > 0 {
		menuList = append(menuList, menu2)
	}
	menu3 := adapter.MenuListAdapter{
		CycleId:    0,
		NodeName:   "人资评估",
		StatusName: "",
		Types:      "",
		Child:      []adapter.MenuListAdapter{},
	}
	menu3_1 := adapter.MenuListAdapter{
		CycleId:    param.CycleId,
		NodeName:   "人资综评",
		StatusName: "",
		Types:      "人资综评",
	}
	if cntUncompletedHrbp > 0 {
		menu3_1.StatusName = "未完成"
	} else if cntAllHrbp > 0 {
		menu3_1.StatusName = "已完成"
	}
	menu3.Child = append(menu3.Child, menu3_1)
	//hrbp 才有这个菜单
	if isHrbp > 0 && cntAllHrbp > 0 {
		menuList = append(menuList, menu3)
	}
	menu4 := adapter.MenuListAdapter{
		CycleId:    0,
		NodeName:   "我的团队绩效",
		StatusName: "",
		Types:      "",
		Child:      []adapter.MenuListAdapter{},
	}
	menu4_1 := adapter.MenuListAdapter{
		CycleId:    param.CycleId,
		NodeName:   "上级综评",
		StatusName: "",
		Types:      "上级综评",
	}
	if cntUncompletedSuper > 0 {
		menu4_1.StatusName = "未完成"
	} else if cntAllSuper > 0 {
		menu4_1.StatusName = "已完成"
	}
	menu4.Child = append(menu4.Child, menu4_1)
	if cntAllSuper > 0 {
		menuList = append(menuList, menu4)
	}
	result := map[string]interface{}{
		"menus": menuList,
	}
	return result, nil
}

// buildSummaryItemValue 将填写值填充进评估项
func (srv *SummaryEvaluationService) buildSummaryItemValue(itemList []*domain.EvaluationItemUsed, valueList []*domain.SummaryEvaluationValue) (itemValues []adapter.EvaluationItemAdapter) {
	itemValues = []adapter.EvaluationItemAdapter{}
	valueMap := map[int]*domain.SummaryEvaluationValue{}
	for _, v := range valueList {
		valueMap[v.EvaluationItemId] = v
	}
	for _, v := range itemList {
		item := adapter.EvaluationItemAdapter{
			EvaluationItemId: v.Id,
			SortBy:           v.SortBy,
			Category:         v.Category,
			Name:             v.Name,
			PromptTitle:      v.PromptTitle,
			PromptText:       "",
			EntryItems:       v.EntryItems,
			RuleType:         v.RuleType,
			Rule:             v.Rule,
			Weight:           v.Weight,
			Required:         v.Required,
			Value:            "",
			Score:            "",
			Remark:           "",
			EvaluatorId:      v.EvaluatorId,
		}
		//PromptText 页面展示 特殊处理
		// if len(v.EntryItems) > 0 {

		for _, v2 := range v.EntryItems {
			item.PromptText += v2.Title + "\n"
		}
		item.PromptText += v.PromptText
		// }
		value, ok := valueMap[v.Id]
		if ok {
			item.Score = value.Score
			item.Value = value.Value
			item.Remark = value.Remark
			item.Rating = value.Rating
			item.EvaluatorName = value.Executor.UserName
		}
		itemValues = append(itemValues, item)
	}
	return itemValues
}

// 根据周期id和被评估人获取综合自评详情
func (srv *SummaryEvaluationService) GetEvaluationSelfByCycle(param *command.QueryEvaluation) (*adapter.EvaluationInfoSelfAdapter, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	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,
	})
	_, evaluationList, err := evaluationRepo.Find(map[string]interface{}{
		"limit":        1,
		"cycleId":      param.CycleId,
		"targetUserId": param.TargetUserId,
		"types":        domain.EvaluationSelf,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if len(evaluationList) == 0 {
		return &adapter.EvaluationInfoSelfAdapter{}, nil
	}
	evaluationData := evaluationList[0]
	if evaluationData.CompanyId != param.CompanyId {
		return nil, application.ThrowError(application.BUSINESS_ERROR, "没有操作权限")
	}
	_, itemList, err := evaluationItemRepo.Find(map[string]interface{}{
		"evaluationProjectId": evaluationData.EvaluationProjectId,
		"nodeType":            int(domain.LinkNodeSelfAssessment),
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	_, itemValues, err := itemValueRepo.Find(map[string]interface{}{
		"summaryEvaluationId": evaluationData.Id,
	})

	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	//获取组装基本信息
	evaluationBase := srv.getSummaryEvaluation(transactionContext, evaluationData)
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	itemValuesAdapter := srv.buildSummaryItemValue(itemList, itemValues)

	result := adapter.EvaluationInfoSelfAdapter{
		EvaluationBaseAdapter: evaluationBase,
	}
	result.EvaluationItems = itemValuesAdapter
	return &result, nil
}

func (srv *SummaryEvaluationService) getSummaryEvaluation(transactionContext application.TransactionContext, evaluationData *domain.SummaryEvaluation) adapter.EvaluationBaseAdapter {
	result := adapter.EvaluationBaseAdapter{
		SummaryEvaluationId:   evaluationData.Id,
		CycleId:               int(evaluationData.CycleId),
		CycleName:             evaluationData.CycleName,
		EvaluationProjectId:   evaluationData.EvaluationProjectId,
		EvaluationProjectName: evaluationData.EvaluationProjectName,
		LinkNodeId:            evaluationData.NodeId,
		BeginTime:             evaluationData.BeginTime.Local().Format("2006-01-02 15:04:05"),
		EndTime:               evaluationData.EndTime.Local().Format("2006-01-02 15:04:05"),
		TargetUserId:          evaluationData.TargetUser.UserId,
		TargetUserName:        evaluationData.TargetUser.UserName,
		CompanyLogo:           "",
		CompanyName:           "",
		SupperUser:            "",
		DutyTime:              "",
		Types:                 int(evaluationData.Types),
		Status:                string(evaluationData.Status),
		CheckResult:           string(evaluationData.CheckResult),
		TotalScore:            evaluationData.TotalScore,
	}
	//获取用户信息
	companyRepo := factory.CreateCompanyRepository(map[string]interface{}{"transactionContext": transactionContext})
	userRepo := factory.CreateUserRepository(map[string]interface{}{"transactionContext": transactionContext})

	companyData, err := companyRepo.FindOne(map[string]interface{}{"id": evaluationData.CompanyId})
	if err != nil {
		return result
	}
	userData, err := userRepo.FindOne(map[string]interface{}{"id": evaluationData.TargetUser.UserId})
	if err != nil {
		return result
	}
	result.DutyTime = userData.EntryTime
	result.CompanyLogo = companyData.Logo
	result.CompanyName = companyData.Name

	if userData.ParentId > 0 {
		pUserData, err := userRepo.FindOne(map[string]interface{}{"id": userData.ParentId})
		if err != nil {
			return result
		}
		result.SupperUser = pUserData.Name
	}
	return result
}

// 编辑综合自评详情
func (srv *SummaryEvaluationService) EditEvaluationSelf(param *command.EditEvaluationValue) (map[string][]adapter.EvaluationItemAdapter, error) {
	lock := xredis.NewLockSummaryEvaluationId(param.SummaryEvaluationId)
	err := lock.Lock()
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "未能完全提交评估内容")
	}
	defer func() {
		lock.UnLock()
	}()
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	evaluationRepo := factory.CreateSummaryEvaluationRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	itemUsedRepo := factory.CreateEvaluationItemUsedRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})

	itemValueRepo := factory.CreateSummaryEvaluationValueRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	evaluationData, err := evaluationRepo.FindOne(map[string]interface{}{
		"id": param.SummaryEvaluationId,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取评估"+err.Error())
	}
	if evaluationData.Types != domain.EvaluationSelf {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "没有操作权限")
	}

	if evaluationData.Executor.UserId != param.ExecutorId {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "没有操作权限")
	}

	if evaluationData.CompanyId != param.CompanyId {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "没有操作权限")
	}

	_, itemList, err := itemUsedRepo.Find(map[string]interface{}{
		"evaluationProjectId": evaluationData.EvaluationProjectId,
		"nodeType":            domain.LinkNodeSelfAssessment,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	_, itemValueList, err := itemValueRepo.Find(map[string]interface{}{
		"summaryEvaluationId": evaluationData.Id,
	})

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

	err = srv.editEvaluationValue(evaluationData, &itemValueList, itemList, param.EvaluationItems, nil, param.IsTemporary)
	if err != nil {
		return nil, application.ThrowError(application.BUSINESS_ERROR, err.Error())
	}

	//保存填写值
	for _, v := range itemValueList {
		err = itemValueRepo.Save(v)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
	}
	if !param.IsTemporary {
		evaluationData.Status = domain.EvaluationCompleted
	}
	err = evaluationRepo.Save(evaluationData)
	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())
	}
	if !param.IsTemporary {
		err = srv.AfterCompletedEvaluationSelf(evaluationData)
		if err != nil {
			return nil, err
		}
	}

	itemValueAdapter := srv.buildSummaryItemValue(itemList, itemValueList)
	return map[string][]adapter.EvaluationItemAdapter{
		"EvaluationItems": itemValueAdapter,
	}, nil
}

// 员工提交自评内容后,
// 员工作为被评估人,
// 变更360评估/人资评估/的开始时间
// 或者变更上级评估的开始时间
// 或者生成考核结果
func (srv *SummaryEvaluationService) AfterCompletedEvaluationSelf(param *domain.SummaryEvaluation) error {
	lock := xredis.NewLockSummaryEvaluation(param.TargetUser.UserId)
	err := lock.Lock()
	if err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, "未能完全提交评估内容")
	}
	defer func() {
		lock.UnLock()
	}()
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	evaluationRepo := factory.CreateSummaryEvaluationRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	_, evaluationList, err := evaluationRepo.Find(map[string]interface{}{
		"targetUserId": param.TargetUser.UserId,
		"typesList":    []int{int(domain.Evaluation360), int(domain.EvaluationHrbp)},
		"cycleId":      param.CycleId,
		"limit":        1000,
	})
	if err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if len(evaluationList) == 0 {
		//如果没有360评估和hrbp 评估,查找上级评估
		_, evaluationList, err = evaluationRepo.Find(map[string]interface{}{
			"targetUserId": param.TargetUser.UserId,
			"typesList":    []int{int(domain.EvaluationSuper)},
			"cycleId":      param.CycleId,
			"limit":        10,
		})
		if err != nil {
			return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
	}
	nowTime := time.Now()
	updatedId := []int{}
	// 变更360评估/人资评估/上级评估的开始时间
	for _, v := range evaluationList {
		if v.BeginTime.After(nowTime) {
			v.BeginTime = nowTime
			updatedId = append(updatedId, v.Id)
		}
	}
	evaluationDao := dao.NewSummaryEvaluationDao(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	err = evaluationDao.UpdateBeginTime(updatedId, nowTime)
	if err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if len(evaluationList) == 0 {
		//没有上级评估、360评估、hrbp 评估
		//直接进入考核结果阶段
		_, evaluationList, err = evaluationRepo.Find(map[string]interface{}{
			"targetUserId": param.TargetUser.UserId,
			"typesList":    []int{int(domain.EvaluationFinish)},
			"cycleId":      param.CycleId,
			"limit":        1,
		})
		if err != nil {
			return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		if len(evaluationList) > 0 {
			//进入考核结果
			//自评的结束时间
			evaluationList[0].BeginTime = param.EndTime
			evaluationList[0].Status = domain.EvaluationCompleted
			err = evaluationRepo.Save(evaluationList[0])
			if err != nil {
				return application.ThrowError(application.INTERNAL_SERVER_ERROR, "保存考核结果,"+err.Error())
			}
		}
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	return nil
}

// 提交员工的人资评估 或者 360 评估
// 变更上级评估的开始时间
// 或者生成考核结果
func (srv *SummaryEvaluationService) AfterCompletedEvaluation360Hrbp(param *domain.SummaryEvaluation) error {
	lock := xredis.NewLockSummaryEvaluation(param.TargetUser.UserId)
	err := lock.Lock()
	if err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, "未能完全提交评估内容")
	}
	defer func() {
		lock.UnLock()
	}()
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()

	evaluationRepo := factory.CreateSummaryEvaluationRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	_, evaluation360HrbList, err := evaluationRepo.Find(map[string]interface{}{
		"targetUserId": param.TargetUser.UserId,
		"typesList":    []int{int(domain.Evaluation360), int(domain.EvaluationHrbp)},
		"cycleId":      param.CycleId,
		"limit":        1000,
	})
	if err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	allCompleted := true
	for _, v := range evaluation360HrbList {
		if v.Status == domain.EvaluationUncompleted {
			allCompleted = false
			break
		}
	}
	if !allCompleted {
		return nil
	}
	_, evaluationList, err := evaluationRepo.Find(map[string]interface{}{
		"targetUserId": param.TargetUser.UserId,
		"typesList":    []int{int(domain.EvaluationSuper)},
		"cycleId":      param.CycleId,
		"limit":        1,
	})
	if err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	nowTime := time.Now()
	updatedId := []int{}
	// 变更上级评估的开始时间
	for _, v := range evaluationList {
		if v.BeginTime.After(nowTime) {
			v.BeginTime = nowTime
			updatedId = append(updatedId, v.Id)
		}
	}
	evaluationDao := dao.NewSummaryEvaluationDao(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	err = evaluationDao.UpdateBeginTime(updatedId, nowTime)
	if err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if len(evaluationList) == 0 {
		//没有上级评估
		//直接进入考核结果阶段
		_, evaluationList, err = evaluationRepo.Find(map[string]interface{}{
			"targetUserId": param.TargetUser.UserId,
			"typesList":    []int{int(domain.EvaluationFinish)},
			"cycleId":      param.CycleId,
			"limit":        1,
		})
		if err != nil {
			return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		if len(evaluationList) > 0 {
			//360评估的结束时间
			evaluationList[0].BeginTime = param.EndTime
			evaluationList[0].Status = domain.EvaluationCompleted
			err = evaluationRepo.Save(evaluationList[0])
			if err != nil {
				return application.ThrowError(application.INTERNAL_SERVER_ERROR, "保存考核结果,"+err.Error())
			}
		}
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	return nil
}

// 员工提交上级评估后
// 生成考核结果
func (srv *SummaryEvaluationService) AfterCompletedEvaluationSuper(param *domain.SummaryEvaluation) error {
	lock := xredis.NewLockSummaryEvaluation(param.TargetUser.UserId)
	err := lock.Lock()
	if err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, "未能完全提交评估内容")
	}
	defer func() {
		lock.UnLock()
	}()
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()

	evaluationRepo := factory.CreateSummaryEvaluationRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	//没有上级评估
	//直接进入考核结果阶段
	_, evaluationList, err := evaluationRepo.Find(map[string]interface{}{
		"targetUserId": param.TargetUser.UserId,
		"typesList":    []int{int(domain.EvaluationFinish)},
		"cycleId":      param.CycleId,
		"limit":        1,
	})
	if err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	if len(evaluationList) > 0 {
		//上级评估的结束时间
		evaluationList[0].BeginTime = param.EndTime
		evaluationList[0].Status = domain.EvaluationCompleted
		err = evaluationRepo.Save(evaluationList[0])
		if err != nil {
			return application.ThrowError(application.INTERNAL_SERVER_ERROR, "保存考核结果,"+err.Error())
		}
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	return nil
}

// GetTargetUserCycleList
// 获取周期列表,被评估的周期列表
func (srv *SummaryEvaluationService) GetTargetUserCycleList(param *command.QueryCycleList) (map[string]interface{}, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	evaluationDao := dao.NewSummaryEvaluationDao(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	limit := 300
	offset := 0
	if param.PageSize > 0 {
		limit = param.PageSize
	}
	if param.PageNumber > 0 {
		offset = (param.PageNumber - 1) * param.PageSize
	}

	cycleData, err := evaluationDao.GetTargetUserCycleList(param.UserId, offset, limit, param.Types)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取周期列表"+err.Error())
	}

	cnt, err := evaluationDao.CountTargetUserCycleList(param.UserId, param.Types)
	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())
	}
	cycleList := []adapter.CycleListAdapter{}
	for _, v := range cycleData {
		m := adapter.CycleListAdapter{
			CycleId:   v.CycleId,
			CycleName: v.CycleName,
		}

		cycleList = append(cycleList, m)
	}
	return tool_funs.SimpleWrapGridMap(int64(cnt), cycleList), nil
}

// 周期综合自评小结详情
func (srv *SummaryEvaluationService) CountEvaluationSelfLevel(param *command.QueryEvaluation) (*adapter.EvaluationInfoCountCodeAdapter, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	//统计周期内,评估项等级的数量
	assessDao := dao.NewStaffAssessDao(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	evaluationRepo := factory.CreateSummaryEvaluationRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	evaluationItemRepo := factory.CreateEvaluationItemUsedRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	itemValueRepo := factory.CreateSummaryEvaluationValueRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	_, evaluationList, err := evaluationRepo.Find(map[string]interface{}{
		"limit":        1,
		"cycleId":      param.CycleId,
		"targetUserId": param.TargetUserId,
		"types":        domain.EvaluationSelf,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if len(evaluationList) == 0 {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	evaluationData := evaluationList[0]
	levelCodeCountList, err := assessDao.CountAssessContentLevelCode(evaluationData.EvaluationProjectId, param.TargetUserId, domain.AssessSelf, param.CycleId)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	_, itemList, err := evaluationItemRepo.Find(map[string]interface{}{
		"evaluationProjectId": evaluationData.EvaluationProjectId,
		"nodeType":            int(domain.LinkNodeSelfAssessment),
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	_, itemValues, err := itemValueRepo.Find(map[string]interface{}{
		"summaryEvaluationId": evaluationData.Id,
	})

	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	// 获取组装基本信息
	evaluationBase := srv.getSummaryEvaluation(transactionContext, evaluationData)
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	evaluationItems := srv.buildSummaryItemValue(itemList, itemValues)

	levelCodeMap := map[int][]adapter.LevalCodeCount{}
	for _, v := range evaluationItems {
		codes := v.Rule.GetLevelCodes()
		levelCode := []adapter.LevalCodeCount{}
		for _, v2 := range codes {
			levelCode = append(levelCode, adapter.LevalCodeCount{
				Code:   v2,
				Number: 0,
			})
		}
		levelCodeMap[v.EvaluationItemId] = levelCode
	}
	levelCodeCountMap := map[string]int{}
	for _, v := range levelCodeCountList {
		key := fmt.Sprintf("%s-%s-%s", v.Category, v.Name, v.LevelValue)
		levelCodeCountMap[key] = v.Cnt
	}

	evaluationItemCount := []adapter.EvaluationItemCountCodeAdapter{}
	for i := range evaluationItems {
		itemCount := adapter.EvaluationItemCountCodeAdapter{
			EvaluationItemAdapter: evaluationItems[i],
			LevelCount:            []adapter.LevalCodeCount{},
		}
		evaluationItemCount = append(evaluationItemCount, itemCount)
		itemId := evaluationItems[i].EvaluationItemId
		levelCodes, ok := levelCodeMap[itemId]
		if !ok {
			continue
		}
		evaluationItemCount[i].LevelCount = levelCodes
		for i2 := range levelCodes {
			key := fmt.Sprintf("%s-%s-%s",
				evaluationItems[i].Category,
				evaluationItems[i].Name,
				levelCodes[i2].Code,
			)
			if mVal, ok := levelCodeCountMap[key]; ok {
				levelCodes[i2].Number = mVal
			}
		}
	}
	evaluationInfo := adapter.EvaluationInfoCountCodeAdapter{
		EvaluationBaseAdapter: evaluationBase,
		EvaluationItems:       evaluationItemCount,
	}
	return &evaluationInfo, nil
}

// GetEvaluationSuper 根据执行人获取上级评估详情
func (srv *SummaryEvaluationService) GetEvaluationSuper(param *command.QueryEvaluationSuper) (*adapter.EvaluationInfoSuperAdapter, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	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,
	})
	// permissionRepository := factory.CreatePermissionRepository(map[string]interface{}{"transactionContext": transactionContext})
	// 获取权限配置
	// _, permissionList, err := permissionRepository.Find(map[string]interface{}{"companyId": param.CompanyId})
	// if err != nil {
	// 	return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	// }
	permissinData, err := getPermission(int64(param.CompanyId))
	if err != nil {
		return nil, err
	}
	evaluationData, err := evaluationRepo.FindOne(map[string]interface{}{
		"id": param.SummaryEvaluationId,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if evaluationData.Types != domain.EvaluationSuper {
		return nil, application.ThrowError(application.BUSINESS_ERROR, "没有操作权限")
	}
	if evaluationData.CompanyId != param.CompanyId {
		return nil, application.ThrowError(application.BUSINESS_ERROR, "没有操作权限")
	}
	_, itemList, err := evaluationItemRepo.Find(map[string]interface{}{
		"evaluationProjectId": evaluationData.EvaluationProjectId,
		"nodeType":            int(domain.LinkNodeSelfAssessment),
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	//获取已填写的评估内容
	_, itemValues, err := itemValueRepo.Find(map[string]interface{}{
		"summaryEvaluationId": evaluationData.Id,
	})

	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if len(itemValues) == 0 {
		//上级还未填写评估,获取 360 ,人资评估
		_, evaluationListOther, err := evaluationRepo.Find(map[string]interface{}{
			"typesList":    []int{int(domain.Evaluation360), int(domain.EvaluationHrbp)},
			"targetUserId": evaluationData.TargetUser.UserId,
			"cycleId":      evaluationData.CycleId,
		})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		evaluationIds := []int{}
		for _, v := range evaluationListOther {
			evaluationIds = append(evaluationIds, v.Id)
		}
		if len(evaluationIds) > 0 {
			_, itemValues, err = itemValueRepo.Find(map[string]interface{}{
				"summaryEvaluationIdList": evaluationIds,
			})
			if err != nil {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
			}
		}
	}
	evaluationBase := srv.getSummaryEvaluation(transactionContext, evaluationData)
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	//组合 评估填写的值和评估项
	itemValuesAdapter := srv.buildSummaryItemValue(itemList, itemValues)
	for i, v := range itemValuesAdapter {
		if permissinData.OptEvalScore == domain.PermissionOff &&
			v.EvaluatorId > 0 {
			itemValuesAdapter[i].ForbidEdit = true
		}
		if permissinData.OptHrScore == domain.PermissionOff &&
			v.EvaluatorId < 0 {
			itemValuesAdapter[i].ForbidEdit = true
		}
	}
	result := adapter.EvaluationInfoSuperAdapter{
		EvaluationBaseAdapter: evaluationBase,
		// LevelCount:            codeList,
		EvaluationItems: itemValuesAdapter,
	}
	return &result, nil
}

// EditEvaluationSuper 更新上级评估内容
func (srv *SummaryEvaluationService) EditEvaluationSuper(param *command.EditEvaluationValue) (interface{}, error) {
	lock := xredis.NewLockSummaryEvaluationId(param.SummaryEvaluationId)
	err := lock.Lock()
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "未能完全提交评估内容")
	}
	defer func() {
		lock.UnLock()
	}()
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	evaluationRepo := factory.CreateSummaryEvaluationRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	itemUsedRepo := factory.CreateEvaluationItemUsedRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})

	itemValueRepo := factory.CreateSummaryEvaluationValueRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	evaluationData, err := evaluationRepo.FindOne(map[string]interface{}{
		"id": param.SummaryEvaluationId,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if evaluationData.Types != domain.EvaluationSuper {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "没有操作权限")
	}

	if evaluationData.Executor.UserId != param.ExecutorId {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "没有操作权限")
	}

	if evaluationData.CompanyId != param.CompanyId {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "没有操作权限")
	}

	_, itemList, err := itemUsedRepo.Find(map[string]interface{}{
		"evaluationProjectId": evaluationData.EvaluationProjectId,
		"nodeType":            domain.LinkNodeSelfAssessment,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	//获取已填写的评估内容
	_, itemValueList, err := itemValueRepo.Find(map[string]interface{}{
		"summaryEvaluationId": evaluationData.Id,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	//记录人资评估或者360评估的 填写项id
	hrbpOr360ItemValue, err := srv.getEvaluationSuperDefaultValue(transactionContext, evaluationData)
	if err != nil {
		return nil, err
	}

	err = srv.editEvaluationValue(evaluationData, &itemValueList, itemList, param.EvaluationItems, hrbpOr360ItemValue, param.IsTemporary)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if !param.IsTemporary {
		//变更评估状态为已填写
		evaluationData.Status = domain.EvaluationCompleted
	}
	for _, v := range itemValueList {
		//保存填写值
		err = itemValueRepo.Save(v)
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
	}
	//保存填写值
	err = evaluationRepo.Save(evaluationData)
	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())
	}

	if !param.IsTemporary {
		err = srv.AfterCompletedEvaluationSuper(evaluationData)
		if err != nil {
			return nil, err
		}
	}

	itemValueAdapter := srv.buildSummaryItemValue(itemList, itemValueList)
	return map[string][]adapter.EvaluationItemAdapter{
		"EvaluationItems": itemValueAdapter,
	}, nil
}

// getEvaluationSuperDefaultValue
// 按照权限设置,是否获取上级评估内容的默认值
func (srv *SummaryEvaluationService) getEvaluationSuperDefaultValue(transactionContext application.TransactionContext, evaluationData *domain.SummaryEvaluation) (
	[]*domain.SummaryEvaluationValue, error) {
	evaluationRepo := factory.CreateSummaryEvaluationRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})

	itemValueRepo := factory.CreateSummaryEvaluationValueRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})

	// permissionRepository := factory.CreatePermissionRepository(map[string]interface{}{"transactionContext": transactionContext})
	// // 获取权限配置
	// _, permissionList, err := permissionRepository.Find(map[string]interface{}{"companyId": evaluationData.CompanyId})
	// if err != nil {
	// 	return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	// }
	// if len(permissionList) == 0 {
	// 	return nil, nil
	// }
	permissionData, err := getPermission(int64(evaluationData.CompanyId))
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if permissionData.OptEvalScore == domain.PermissionOn && permissionData.OptHrScore == domain.PermissionOn {
		return nil, nil
	}
	// 获取360评估,人资评估填写的值
	_, evaluationListOther, err := evaluationRepo.Find(map[string]interface{}{
		"typesList":    []int{int(domain.Evaluation360), int(domain.EvaluationHrbp)},
		"targetUserId": evaluationData.TargetUser.UserId,
		"cycleId":      evaluationData.CycleId,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	evaluationIds := []int{}
	for _, v := range evaluationListOther {
		evaluationIds = append(evaluationIds, v.Id)
	}
	if len(evaluationIds) == 0 {
		return nil, nil
	}
	// 将360评估,人资评估填写的值 作为默认值
	_, itemValuesOther, err := itemValueRepo.Find(map[string]interface{}{
		"summaryEvaluationIdList": evaluationIds,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	// 记录人资评估或者360评估的 填写项id
	hrbpOr360ItemValue := []*domain.SummaryEvaluationValue{}
	if permissionData.OptEvalScore == domain.PermissionOff {
		//上级是否可以修改360°综评分数
		//获取360综合评分
		for _, v := range itemValuesOther {
			//记录人资评估或者360评估的填写值
			if v.Types != domain.Evaluation360 {
				continue
			}
			hrbpOr360ItemValue = append(hrbpOr360ItemValue, v)
		}
	}
	if permissionData.OptHrScore == domain.PermissionOff {
		//上级是否可以修改人资综评分数
		//获取人资综合评分
		for _, v := range itemValuesOther {
			//记录人资评估或者360评估的填写值
			if v.Types != domain.EvaluationHrbp {
				continue
			}

			hrbpOr360ItemValue = append(hrbpOr360ItemValue, v)
		}
	}
	return hrbpOr360ItemValue, nil
}

// 获取执行人的上级评估的列表
func (srv *SummaryEvaluationService) ListExecutorEvaluationSuper(param *command.QueryExecutorEvaluationList) (map[string]interface{}, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	evaluationRepo := factory.CreateSummaryEvaluationRepository(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 := (param.PageNumber - 1) * param.PageSize

	//获取评估列表信息
	condition1 := map[string]interface{}{
		"cycleId":    param.CycleId,
		"executorId": param.ExecutorId,
		"types":      int(domain.EvaluationSuper),
		"limit":      limit,
		"beginTime":  time.Now(),
	}
	if offset > 0 {
		condition1["offset"] = offset
	}
	if len(param.TargetUserName) > 0 {
		condition1["targetUserName"] = "%" + param.TargetUserName + "%"
	}
	//获取评估列表信息
	cnt, evaluationList, err := evaluationRepo.Find(condition1)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	//获取未完成上级评估的数量
	cntUn, _, err := evaluationRepo.Find(map[string]interface{}{
		"cycleId":    param.CycleId,
		"executorId": param.ExecutorId,
		"types":      int(domain.EvaluationSuper),
		"status":     domain.EvaluationUncompleted,
		"limit":      1,
		"beginTime":  time.Now(),
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	targetUserIds := []int{}
	for _, v := range evaluationList {
		targetUserIds = append(targetUserIds, v.TargetUser.UserId)
	}
	//获取员工的综合自评
	evaluationSelfMap := map[int]*domain.SummaryEvaluation{}
	for _, v := range evaluationList {
		_, evaluationSelfList, err := evaluationRepo.Find(map[string]interface{}{
			"cycleId":    param.CycleId,
			"executorId": v.TargetUser.UserId,
			"types":      int(domain.EvaluationSelf),
			"limit":      1,
		})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取综合自评"+err.Error())
		}
		if len(evaluationSelfList) > 0 {
			evaluationSelfMap[v.TargetUser.UserId] = evaluationSelfList[0]
		}
	}

	//获取员工信息
	userMap := map[int64]*domain.User{}
	if len(targetUserIds) > 0 {
		_, userList, err := userRepo.Find(map[string]interface{}{
			"ids": targetUserIds,
		})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		for _, v := range userList {
			userMap[v.Id] = v
		}
	}
	var positionIds []int
	//获取职位列表
	positionMap := map[int64]*domain.Position{}
	for _, v := range userMap {
		positionIds = append(positionIds, v.PositionId...)
	}

	if len(positionIds) > 0 {
		_, positionList, err := positionRepo.Find(map[string]interface{}{"ids": positionIds})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取部门信息"+err.Error())
		}
		for _, v := range positionList {
			positionMap[v.Id] = v
		}
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	evaluationListAdapter := []*adapter.EvaluationSuperListAdapter{}
	for _, v := range evaluationList {
		item := adapter.EvaluationSuperListAdapter{
			SummaryEvaluationId: v.Id,
			TargetUserName:      v.TargetUser.UserName,
			TargetUserId:        v.TargetUser.UserId,
			EvaluationStatus:    string(v.Status),
			EndTime:             v.EndTime.Format("2006-01-02 15:04:05"),
			TotalScoreSelf:      "",
			Department:          "",
			Position:            "",
			EntryTime:           "",
		}
		for _, dep := range v.TargetDepartment {
			item.Department += dep.DepartmentName + " "
		}
		//填充员工信息
		if targetUser, ok := userMap[int64(v.TargetUser.UserId)]; ok {
			//填充职位信息
			for _, positionId := range targetUser.PositionId {
				if position, ok := positionMap[int64(positionId)]; ok {
					item.Position += position.Name + " "
				}
			}
			//填充入职时间
			item.EntryTime = targetUser.EntryTime
		}
		//填充自评总分
		if evaluationSelf, ok := evaluationSelfMap[v.TargetUser.UserId]; ok {
			item.TotalScoreSelf = evaluationSelf.TotalScore
		}
		evaluationListAdapter = append(evaluationListAdapter, &item)
	}
	result := tool_funs.SimpleWrapGridMap(int64(cnt), evaluationListAdapter)
	result["endTime"] = ""
	result["uncompleted_number"] = 0
	if len(evaluationList) > 0 {
		result["endTime"] = evaluationList[0].EndTime.Format("2006-01-02 15:04:05")
		result["uncompleted_number"] = cntUn
	}
	return result, nil
}

// ConfirmScoreEvaluation 员工确认考核结果
func (srv *SummaryEvaluationService) ConfirmScoreEvaluation(param *command.ConfirmScore) error {
	transactionContext, err := factory.ValidateStartTransaction(param)
	if err != nil {
		return 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})

	// 考核结果
	result, err := evaluationRepo.FindOne(map[string]interface{}{"id": param.SummaryEvaluationId})
	if err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if result.Types != domain.EvaluationFinish {
		return application.ThrowError(application.TRANSACTION_ERROR, "操作方式错误")
	}
	if result.TargetUser.UserId != param.UserId {
		return application.ThrowError(application.TRANSACTION_ERROR, "没有操作权限")
	}
	if result.CheckResult == domain.EvaluationCheckCompleted {
		return application.ThrowError(application.TRANSACTION_ERROR, "考核结果已确认过了!")
	}
	if result.Status == domain.EvaluationUncompleted {
		return application.ThrowError(application.TRANSACTION_ERROR, "前面流程暂未完成提交评估内容")
	}

	_, evaluationList, err := evaluationRepo.Find(map[string]interface{}{
		"companyId":    result.CompanyId,
		"cycleId":      result.CycleId,
		"targetUserId": result.TargetUser.UserId,
	})
	if err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	var super *domain.SummaryEvaluation // 上级评估
	for i := range evaluationList {
		it := evaluationList[i]
		if it.Types == domain.EvaluationSuper {
			super = it
			break
		}
	}

	// 评估内容和值
	var itemList []*domain.EvaluationItemUsed
	var itemValues []*domain.SummaryEvaluationValue

	// 获取自评模板内容
	_, itemList, err = evaluationItemRepo.Find(map[string]interface{}{"evaluationProjectId": result.EvaluationProjectId, "nodeType": domain.LinkNodeSelfAssessment})
	if err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	// 按评估项优先级顺序(已确认考核结果 ->上级评估 ->HR或360评估或自评)
	if super != nil {
		_, itemValues, err = itemValueRepo.Find(map[string]interface{}{"summaryEvaluationId": super.Id}) // 获取已填写的评估内容
		if err != nil {
			return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		// 更新填写值
		itemValues, err = srv.updateItemValuePriority(result, itemList, itemValues, true)
		if err != nil {
			return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
	} else {
		// 评估项ID(除考核结果和上级)
		var evaluationIds = make([]int, 0)
		for i := range evaluationList {
			it := evaluationList[i]
			if it.Types == domain.EvaluationSelf || it.Types == domain.Evaluation360 || it.Types == domain.EvaluationHrbp {
				evaluationIds = append(evaluationIds, it.Id)
			}
		}
		if len(evaluationIds) > 0 {
			// 获取已填写的评估内容
			_, itemValues, err = itemValueRepo.Find(map[string]interface{}{"summaryEvaluationIdList": evaluationIds})
			if err != nil {
				return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
			}

			// 更新填写值
			itemValues, err = srv.updateItemValuePriority(result, itemList, itemValues, false)
			if err != nil {
				return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
			}
		}
	}

	for i := range itemValues {
		if err := itemValueRepo.Save(itemValues[i]); err != nil {
			return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
	}
	//重置评级汇总
	result.TotalRating = nil
	for i := range itemList {
		result.ResetTotalRating(itemList[i])
	}
	if err := result.EvaluationTotalScore(itemValues); err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}

	result.CheckResult = domain.EvaluationCheckCompleted
	if err := evaluationRepo.Save(result); err != nil {
		return application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	return nil
}

// 处理优先级
func (srv *SummaryEvaluationService) updateItemValuePriority(
	result *domain.SummaryEvaluation,
	itemList []*domain.EvaluationItemUsed,
	itemValues []*domain.SummaryEvaluationValue,
	superior bool) ([]*domain.SummaryEvaluationValue, error) {

	tempSelf := map[int]*domain.SummaryEvaluationValue{}
	temp360 := map[int]*domain.SummaryEvaluationValue{}
	tempHRBP := map[int]*domain.SummaryEvaluationValue{}
	tempSuperior := map[int]*domain.SummaryEvaluationValue{}

	for i := range itemValues {
		it := itemValues[i]
		if it.Types == domain.EvaluationSelf {
			tempSelf[it.EvaluationItemId] = it
		} else if it.Types == domain.Evaluation360 {
			temp360[it.EvaluationItemId] = it
		} else if it.Types == domain.EvaluationHrbp {
			tempHRBP[it.EvaluationItemId] = it
		} else if it.Types == domain.EvaluationSuper {
			tempSuperior[it.EvaluationItemId] = it
		}
	}
	nowTime := time.Now()
	var newItemValues = make([]*domain.SummaryEvaluationValue, 0)
	for i := range itemList {
		it := itemList[i]

		var tempValue domain.SummaryEvaluationValue
		tempValue.SetBlankValue(result, it)

		if superior /* 上级数据 */ {
			if v, ok := tempSuperior[it.Id]; ok {
				tempValue = *v
			}
			tempValue.Types = domain.EvaluationSuper
		} else /* 其它数据 */ {
			if it.EvaluatorId == 0 {
				if v, ok := tempSelf[it.Id]; ok {
					tempValue = *v
				}
				tempValue.Types = domain.EvaluationSelf
			} else if it.EvaluatorId == -1 {
				if v, ok := tempHRBP[it.Id]; ok {
					tempValue = *v
				}
				tempValue.Types = domain.EvaluationHrbp
			} else if it.EvaluatorId > 0 {
				if v, ok := temp360[it.Id]; ok {
					tempValue = *v
				}
				tempValue.Types = domain.Evaluation360
			}
		}

		// ID置空
		tempValue.Id = 0
		tempValue.SummaryEvaluationId = result.Id
		tempValue.CreatedAt = nowTime
		tempValue.UpdatedAt = nowTime
		newItemValues = append(newItemValues, &tempValue)
	}
	return newItemValues, nil
}

// GetTargetEvaluationResult 按照周期和被评估的人 获取考核结果
func (srv *SummaryEvaluationService) GetTargetEvaluationResult(param *command.QueryEvaluation) (*adapter.EvaluationInfoSuperAdapter, error) {
	transactionContext, err := factory.ValidateStartTransaction(param)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	// if err := transactionContext.StartTransaction(); err != nil {
	// 	return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	// }
	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})

	_, evaluationList, err := evaluationRepo.Find(map[string]interface{}{
		"companyId":    param.CompanyId,
		"cycleId":      param.CycleId,
		"targetUserId": param.TargetUserId,
	})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	var result *domain.SummaryEvaluation // 绩效考核结果项
	var super *domain.SummaryEvaluation  // 上级评估
	for i := range evaluationList {
		it := evaluationList[i]
		if it.Types == domain.EvaluationFinish {
			result = it
			continue
		}
		if it.Types == domain.EvaluationSuper {
			super = it
			continue
		}
	}
	if result == nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "没有找到符合条件的数据")
	}

	// 评估内容和值
	var itemList []*domain.EvaluationItemUsed
	var itemValues []*domain.SummaryEvaluationValue

	// 获取自评模板内容
	_, itemList, err = evaluationItemRepo.Find(map[string]interface{}{"evaluationProjectId": result.EvaluationProjectId, "nodeType": domain.LinkNodeSelfAssessment})
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}

	// 按评估项优先级顺序(已确认考核结果 ->上级评估 ->HR或360评估或自评)
	if result.CheckResult == domain.EvaluationCheckCompleted { /* 已完成考核*/
		_, itemValues, err = itemValueRepo.Find(map[string]interface{}{"summaryEvaluationId": result.Id}) // 获取已填写的评估内容
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
	} else {
		if super != nil {
			_, itemValues, err = itemValueRepo.Find(map[string]interface{}{"summaryEvaluationId": super.Id}) // 获取已填写的评估内容
			if err != nil {
				return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
			}
		} else {
			// 评估项ID(除考核结果和上级)
			var evaluationIds = make([]int, 0)
			for i := range evaluationList {
				it := evaluationList[i]
				if it.Types == domain.EvaluationSelf || it.Types == domain.Evaluation360 || it.Types == domain.EvaluationHrbp {
					evaluationIds = append(evaluationIds, it.Id)
				}
			}
			if len(evaluationIds) > 0 {
				// 获取已填写的评估内容
				_, itemValues, err = itemValueRepo.Find(map[string]interface{}{"summaryEvaluationIdList": evaluationIds})
				if err != nil {
					return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
				}

				// 更新填写值
				itemValues, err = srv.updateItemValuePriority(result, itemList, itemValues, false)
				if err != nil {
					return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
				}
			}
		}
	}
	// 未完成考核,需要重新计算分数
	if result.CheckResult == domain.EvaluationCheckUncompleted {
		result.TotalRating = nil
		for i := range itemList {
			result.ResetTotalRating(itemList[i])
		}
		if err = result.EvaluationTotalScore(itemValues); err != nil {
			return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
		}
	}

	// 基础数据
	evaluationBase := srv.getSummaryEvaluation(transactionContext, result)

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

	// 组合 评估填写的值和评估项
	itemValuesAdapter := srv.buildSummaryItemValue(itemList, itemValues)

	codeMap := map[string]*adapter.LevalCodeCount{}
	for _, v := range itemValuesAdapter {
		//处理加分项评级汇总
		if v.Weight == 0 && len(v.Value) > 0 {
			if _, ok := codeMap[v.Value]; !ok {
				code := &adapter.LevalCodeCount{
					Code:     v.Value,
					Number:   0,
					ItemList: []string{},
				}
				codeMap[v.Value] = code
			}
			codeMap[v.Value].ItemList = append(codeMap[v.Value].ItemList, v.Name)
			codeMap[v.Value].Number += 1
		}
	}
	codeList := make([]*adapter.LevalCodeCount, 0)
	for _, val := range result.TotalRating {
		if codeItem, ok := codeMap[val.Code]; ok {
			codeList = append(codeList, codeItem)
		} else {
			codeList = append(codeList, &adapter.LevalCodeCount{
				Code:     val.Code,
				Number:   0,
				ItemList: []string{},
			})
		}
	}
	eiAdapter := adapter.EvaluationInfoSuperAdapter{
		EvaluationBaseAdapter: evaluationBase,
		LevelCount:            codeList,
		EvaluationItems:       itemValuesAdapter,
	}
	return &eiAdapter, nil
}

// 按周期获取所有员工的评估考核结果
func (srv *SummaryEvaluationService) ListAllEvaluationFinish(param *command.QueryEvaluationList) (map[string]interface{}, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	//判断是否是hrbp
	flagHrbp, err := roleService.GetHrBp(transactionContext, param.CompanyId, param.UserId)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	if flagHrbp != domain.RoleTypeSystem {
		return tool_funs.SimpleWrapGridMap(0, []string{}), nil
	}
	//判断是否是上级
	userRepo := factory.CreateUserRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})

	_, parentUser, _ := userRepo.Find(map[string]interface{}{
		"parentId": param.UserId,
		"limit":    1,
	})
	if len(parentUser) == 0 && flagHrbp != domain.RoleTypeSystem {
		return tool_funs.SimpleWrapGridMap(0, []string{}), nil
	}
	evaluationRepo := factory.CreateSummaryEvaluationRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})

	positionRepo := factory.CreatePositionRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	limit := param.PageSize
	offset := (param.PageNumber - 1) * param.PageSize

	//获取评估列表信息
	condition1 := map[string]interface{}{
		"cycleId":   param.CycleId,
		"types":     int(domain.EvaluationFinish),
		"limit":     limit,
		"beginTime": time.Now(),
	}
	if offset > 0 {
		condition1["offset"] = offset
	}
	if len(param.TargetUserName) > 0 {
		condition1["targetUserName"] = "%" + param.TargetUserName + "%"
	}
	//获取评估列表信息
	cnt, evaluationList, err := evaluationRepo.Find(condition1)
	if err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	targetUserIds := []int{}
	for _, v := range evaluationList {
		targetUserIds = append(targetUserIds, v.TargetUser.UserId)
	}

	//获取员工信息
	userMap := map[int64]*domain.User{}
	if len(targetUserIds) > 0 {
		_, userList, err := userRepo.Find(map[string]interface{}{
			"ids": targetUserIds,
		})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
		}
		for _, v := range userList {
			userMap[v.Id] = v
		}
	}
	var positionIds []int
	//获取职位列表
	positionMap := map[int64]*domain.Position{}
	for _, v := range userMap {
		positionIds = append(positionIds, v.PositionId...)
	}
	if len(positionIds) > 0 {
		_, positionList, err := positionRepo.Find(map[string]interface{}{"ids": positionIds})
		if err != nil {
			return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取部门信息"+err.Error())
		}
		for _, v := range positionList {
			positionMap[v.Id] = v
		}
	}
	if err := transactionContext.CommitTransaction(); err != nil {
		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
	}
	evaluationListAdapter := []*adapter.EvaluationSuperItemAdapter{}
	for _, v := range evaluationList {
		item := adapter.EvaluationSuperItemAdapter{
			SummaryEvaluationId: v.Id,
			TargetUserName:      v.TargetUser.UserName,
			TargetUserId:        v.TargetUser.UserId,
			CycleId:             v.CycleId,
			TotalScore:          v.TotalScore,
			Department:          "",
			Position:            "",
		}
		for _, dep := range v.TargetDepartment {
			item.Department += dep.DepartmentName + " "
		}
		//填充员工信息
		if targetUser, ok := userMap[int64(v.TargetUser.UserId)]; ok {
			//填充职位信息
			for _, positionId := range targetUser.PositionId {
				if position, ok := positionMap[int64(positionId)]; ok {
					item.Position += position.Name + " "
				}
			}
		}
		evaluationListAdapter = append(evaluationListAdapter, &item)
	}
	result := tool_funs.SimpleWrapGridMap(int64(cnt), evaluationListAdapter)
	return result, nil
}

// editEvaluationValue 编辑评估的填写值
// evaluationData 对应的评估任务
// evaluationItems 对应的评估项
// oldItemValue  旧的评估项填写的值
// updatedValue 新填的评估值
// defaultItemvalue 评估项保持的默认值
func (srv *SummaryEvaluationService) editEvaluationValue(
	evaluationData *domain.SummaryEvaluation,
	itemValueList *[]*domain.SummaryEvaluationValue,
	evaluationItems []*domain.EvaluationItemUsed,
	updatedValue []command.UpdatedItemValue,
	defaultItemValue []*domain.SummaryEvaluationValue,
	isTemporary bool,
) error {

	ok := evaluationData.EndTime.Before(time.Now())
	if ok {
		return errors.New("评估时间已截止")
	}
	evaluationItemMap := map[int]*domain.EvaluationItemUsed{}
	evaluationValueMap := map[int]*domain.SummaryEvaluationValue{}
	evaluationValueSlice := []*domain.SummaryEvaluationValue{}
	evaluationData.TotalRating = nil //清空评级数量统计
	for _, v := range evaluationItems {
		newValue := &domain.SummaryEvaluationValue{}
		newValue.SetBlankValue(evaluationData, v)
		evaluationValueMap[v.Id] = newValue
		evaluationItemMap[v.Id] = v
		evaluationValueSlice = append(evaluationValueSlice, newValue)
		//重置计数
		evaluationData.ResetTotalRating(v)
	}
	//如果存在旧值
	//新值的id 替换为旧值id
	for _, v := range *itemValueList {
		if mValue, ok := evaluationValueMap[v.EvaluationItemId]; ok {
			mValue.Id = v.Id
		}
	}
	//填入填写的更新值
	for _, v := range updatedValue {
		v.Value = strings.TrimSpace(v.Value)
		newItemValue, ok := evaluationValueMap[v.EvaluationItemId]
		if !ok {
			continue
		}
		evaluationItem, ok := evaluationItemMap[v.EvaluationItemId]
		if !ok {
			continue
		}
		if !isTemporary {
			if evaluationData.Types != domain.EvaluationSelf {
				//除了综合自评,其他的评估任务 评估项直接全部按必填项处理
				if len(v.Value) == 0 {
					return fmt.Errorf("%s-%s 未填写", evaluationItem.Category, evaluationItem.Name)
				}
			} else if evaluationItem.Required == domain.NodeRequiredYes {
				// 综合自评 评估项必填项处理
				if len(v.Value) == 0 {
					return fmt.Errorf("%s-%s 未填写", evaluationItem.Category, evaluationItem.Name)
				}
			}
		}
		//填充评估填写值
		err := newItemValue.FillValue(evaluationItem, v.Value, v.Remark)
		if err != nil {
			return err
		}
	}
	// 填入固定的默认值
	for _, v := range defaultItemValue {
		newItemValue, ok := evaluationValueMap[v.EvaluationItemId]
		if !ok {
			continue
		}
		evaluationItem, ok := evaluationItemMap[v.EvaluationItemId]
		if !ok {
			continue
		}
		//填充评估填写值
		err := newItemValue.FillValue(evaluationItem, v.Value, newItemValue.Remark)
		if err != nil {
			return err
		}
	}
	//完全更新itemValueList
	*itemValueList = evaluationValueSlice
	// *itemValueList = (*itemValueList)[0:0]
	// for _, v := range evaluationValueMap {
	// 	*itemValueList = append(*itemValueList, v)
	// }
	// sort.Slice(*itemValueList, func(i, j int) bool {
	// 	return (*itemValueList)[i].EvaluationItemId < (*itemValueList)[j].EvaluationItemId
	// })
	// 计算总得分
	err := evaluationData.EvaluationTotalScore(*itemValueList)
	if err != nil {
		return err
	}
	return nil
}

// 获取现在待执行的综合自评
func (srv *SummaryEvaluationService) ListExecutorNowEvaluationSelf(param *command.QueryExecutorEvaluationList) (map[string]interface{}, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, err
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	evaluationRepo := factory.CreateSummaryEvaluationRepository(map[string]interface{}{
		"transactionContext": transactionContext,
	})
	condition1 := map[string]interface{}{
		"types":        int(domain.EvaluationSelf),
		"targetUserId": param.ExecutorId,
		"limit":        20,
		"beginTime":    time.Now(),
		"endTime":      time.Now(),
		"status":       string(domain.EvaluationUncompleted),
	}
	//获取评估列表信息
	cnt, evaluationList, err := evaluationRepo.Find(condition1)
	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())
	}

	listResult := []map[string]string{}
	for _, v := range evaluationList {
		item := map[string]string{
			"summaryEvaluationId": strconv.Itoa(v.Id),
			"cycleId":             strconv.Itoa(int(v.CycleId)),
			"cycleName":           v.CycleName,
			"evaluationStatus":    string(v.Status),
			"endTime":             v.EndTime.Local().Format("2006-01-02 15:04:05"),
			"beginTime":           v.BeginTime.Local().Format("2006-01-02 15:04:05"),
		}
		listResult = append(listResult, item)
	}
	result := tool_funs.SimpleWrapGridMap(int64(cnt), listResult)
	return result, nil
}

// SearchAssessRemark
func (srv *SummaryEvaluationService) SearchAssessRemark(param *command.QueryAssessRemark) (map[string][]map[string]string, error) {
	transactionContext, err := factory.CreateTransactionContext(nil)
	if err != nil {
		return nil, err
	}
	if err := transactionContext.StartTransaction(); err != nil {
		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
	}
	defer func() {
		_ = transactionContext.RollbackTransaction()
	}()
	assessDao := dao.NewStaffAssessDao(map[string]interface{}{"transactionContext": transactionContext})

	data, err := assessDao.SearchAssessSelfContentRemark(param.ProjectId, param.TargetUserId, param.Category, param.Name, param.LevelValue)
	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())
	}
	listData := []map[string]string{}
	for _, val := range data {
		remark := ""
		for _, val2 := range val.Remark {
			remark = remark + val2.RemarkText + "\n"
		}
		d := map[string]string{
			"beginDay": val.BeginDay,
			"category": val.Category,
			"name":     val.Name,
			"remark":   remark,
		}
		listData = append(listData, d)
	}
	result := map[string][]map[string]string{
		"list": listData,
	}
	return result, nil
}