gin_server_admin/api/admin/dutyassess/dutyhandle.go

package dutyassess

import (
	"encoding/json"
	"fmt"
	"strconv"
	"strings"
	"time"

	"gin_server_admin/commonus"
	"gin_server_admin/global"
	"gin_server_admin/model/assessmentmodel"
	"gin_server_admin/model/common/response"
	"github.com/gin-gonic/gin"
)

// 获取定性考核指标列表(下拉列表)
func (d *DutyAssessApi) SelectDutyList(c *gin.Context) {
	var evalTargetList []assessmentmodel.EvaluationTarget
	err := global.GVA_DB_Performanceappraisal.Where("`et_type` = 1 AND `et_state` = 1").Find(&evalTargetList).Error
	if err != nil {
		response.Result(101, err, "没有数据！", c)
		return
	}
	var listAry []DutySelectList
	for _, v := range evalTargetList {
		var cont DutySelectList
		cont.Id = v.Id

		cont.Title = v.Title
		cont.Type = v.Type
		cont.State = v.State
		cont.AddTime = v.AddTime
		cont.Share = v.Share
		cont.RelevantDepartments = v.RelevantDepartments
		cont.Dimension = v.Dimension
		cont.Key = v.Key
		cont.Report = v.Report
		cont.Uniteing = v.Uniteing
		cont.Cycles = v.Cycles
		cont.CycleAttres = v.CycleAttres
		cont.VisibleRange = v.VisibleRange
		cont.VisibleRangeGroup = v.VisibleRangeGroup
		cont.DepartmentList = strings.Split(v.RelevantDepartments, ",")
		listAry = append(listAry, cont)
	}
	response.Result(0, listAry, "查询完成！", c)
}

// 定性考核列表（部门方案用的）
func (d *DutyAssessApi) DutyDepartmentList(c *gin.Context) {
	var requestData getDepartAssObtains
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		// response.Result(101, err, "参数错误！请重新提交！", c)
		// return
	}
	var targetId []int64
	gormDb := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Select("qe_target")
	if requestData.DepartID != "" {
		gormDb = gormDb.Where("`qe_accept_evaluation` = ?", requestData.DepartID)
	}
	gormDb = gormDb.Where("`qe_state` = 1 AND `qe_type` = 1")
	listTargetErr := gormDb.Group("qe_target").Find(&targetId).Error
	if listTargetErr != nil {
		response.Result(101, listTargetErr, "没有数据！", c)
		return
	}
	var targetList []OutDutyList
	for _, v := range targetId {
		var targetCont OutDutyList
		targetCont.Id = strconv.FormatInt(v, 10)
		tarCont, _ := commonus.GetTargetInfo(v)

		targetCont.Target = strconv.FormatInt(v, 10)                    //指标ID
		targetCont.TargetName = tarCont.Title                           //指标名称
		targetCont.Dimension = strconv.FormatInt(tarCont.Dimension, 10) //维度ID
		dutyClassCont, dutyClassErr := commonus.GetDutyClassInfo(tarCont.Dimension)
		if dutyClassErr == true {
			targetCont.DimensionName = dutyClassCont.Title //维度名称
		}
		targetCont.Content = ""                      //指标说明
		targetCont.Unit = tarCont.Uniteing           //单位"`
		targetCont.ReferenceScore = 0                //标准分值"`
		targetCont.Cycles = tarCont.Cycles           //1：班；2：天；3：周；4：月；5：季度；6：年"`
		targetCont.CycleAttres = tarCont.CycleAttres //辅助计数"`
		targetCont.State = 1
		targetCont.DepartmentId, targetCont.DepartmentAry = GetDutyFangAnDepart(v, 1)

		shenPiRen := strings.Split(tarCont.Report, ",")
		targetCont.UserList = shenPiRen
		for _, v := range shenPiRen {
			usCont, usErr := commonus.GetUserInfoPublic([]string{"worker_man.wm_number", "worker_man_data.wmd_name"}, map[string]interface{}{"wm_key": v})
			if usErr == true {
				var userCont QualEvalArrt
				userCont.Id = v
				userCont.Name = usCont.Name
				targetCont.UserListAry = append(targetCont.UserListAry, userCont)
			}
		}

		targetList = append(targetList, targetCont)
	}
	// var qualitativeEvaluationAry []assessmentmodel.QualitativeEvaluation
	response.Result(0, targetList, "查询完成！", c)
}

// 获取方案中的所有所有相关部们
func GetDutyFangAnDepart(dutyId int64, class int) (departId []int64, departAry []DepartmentAryType) {
	err := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Select("qe_accept_evaluation").Where("`qe_state` = 1 AND `qe_target` = ? AND `qe_type` = ?", dutyId, class).Group("qe_accept_evaluation").Find(&departId).Error
	if err != nil {
		return
	}

	for _, v := range departId {
		deparConErr, deparConCont := commonus.GetBranchFactory(v)
		if deparConErr == true {
			var departcont DepartmentAryType
			departcont.Parentname = deparConCont.Name
			departcont.Parentid = strconv.FormatInt(v, 10)
			departAry = append(departAry, departcont)
		}
	}
	return
}

// 根据指标ID获取列表信息
func (d *DutyAssessApi) IdToTargetSunList(c *gin.Context) {
	var requestData commonus.SetIds
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if requestData.Id == 0 && requestData.OutId == "" {
		response.Result(102, err, "参数错误！请重新提交！", c)
		return
	}
	if requestData.OutId != "" {
		idInt, inIntErr := strconv.ParseInt(requestData.OutId, 10, 64)
		if inIntErr == nil {
			requestData.Id = idInt
		}
	}
	tarCont, isTrue := commonus.GetTargetInfo(requestData.Id)
	if isTrue != true {
		response.Result(103, err, "数据获取失败！", c)
		return
	}
	var targetCont TargetFormId
	targetCont.Id = strconv.FormatInt(requestData.Id, 10)
	targetCont.Target = strconv.FormatInt(requestData.Id, 10)       //指标ID
	targetCont.TargetName = tarCont.Title                           //指标名称
	targetCont.Dimension = strconv.FormatInt(tarCont.Dimension, 10) //维度ID
	dutyClassCont, dutyClassErr := commonus.GetDutyClassInfo(tarCont.Dimension)
	if dutyClassErr == true {
		targetCont.DimensionName = dutyClassCont.Title //维度名称
	}
	targetCont.Content = ""                      //指标说明
	targetCont.Unit = tarCont.Uniteing           //单位"`
	targetCont.ReferenceScore = 0                //标准分值"`
	targetCont.Cycles = tarCont.Cycles           //1：班；2：天；3：周；4：月；5：季度；6：年"`
	targetCont.CycleAttres = tarCont.CycleAttres //辅助计数"`
	targetCont.State = 1
	targetCont.DepartmentId, targetCont.DepartmentAry = GetDutyFangAnDepart(requestData.Id, 1)
	targetCont.SunTargetList = GetSunTargetList(requestData.Id, tarCont.Dimension, targetCont.DepartmentId)
	targetCont.Reportmap = strings.Split(tarCont.Report, ",")

	// for _, vv := range jieguo {
	// 	targetCont.SunTargetList = append(targetCont.SunTargetList, vv)
	// }
	// targetCont.SunTargetList = jieguo
	// jsonstr, _ := json.Marshal(targetCont)
	// fmt.Printf("+++++++++>%v----->\n", string(jsonstr))
	response.Result(0, targetCont, "查询完成！", c)
}

// 获取子指标和指标详情
func GetSunTargetList(targetId, demID int64, parAryId []int64) (cont []SunTargetListType) {
	var qualTargetCont []assessmentmodel.QualitativeTarget
	err := global.GVA_DB_Performanceappraisal.Where("`q_state` = 1 AND `q_parent_id` = ?", targetId).Find(&qualTargetCont).Error
	if err != nil {
		return
	}
	// fmt.Printf("%v\n", qualTargetCont)
	for _, v := range qualTargetCont {
		var sunCont SunTargetListType
		sunCont.Id = strconv.FormatInt(v.Id, 10)
		sunCont.Title = v.Title
		sunCont.DetailedTarget = GetDetailTrager(targetId, v.Id, demID, parAryId)
		// fmt.Printf("-->%v-->%v\n", v.Id, v.Title)
		cont = append(cont, sunCont)
	}
	// fmt.Printf("=========>%v\n", cont)
	return
}

// 获取指标详情
func GetDetailTrager(targetId, detId, demID int64, parAryId []int64) (cont []DetailedTargetType) {
	var qualTargetCont []assessmentmodel.DetailedTarget
	err := global.GVA_DB_Performanceappraisal.Where("`dt_state` = 1 AND `dt_parentid` = ? AND `dt_parentid_sun` = ?", targetId, detId).Find(&qualTargetCont).Error
	if err != nil {
		return
	}
	for _, v := range qualTargetCont {
		var sunCont DetailedTargetType
		sunCont.Id = strconv.FormatInt(v.Id, 10)
		sunCont.Title = v.Title
		sunCont.UserList, sunCont.UserListAry = GetOperator(demID, targetId, detId, v.Id, parAryId)
		cont = append(cont, sunCont)
	}
	return
}

// 获取执行人
func GetOperator(dimID, tarId, sunTarId, detaId int64, parAryId []int64) (UserList []string, UserListAry []QualEvalArrt) {
	var qualEval []assessmentmodel.QualitativeEvaluation
	err := global.GVA_DB_Performanceappraisal.Where("`qe_state` = 1 AND `qe_dimension` = ? AND `qe_target` = ? AND `qe_target_sun` = ? AND `qe_detailed_target` = ? AND `qe_accept_evaluation` IN ?", dimID, tarId, sunTarId, detaId, parAryId).Find(&qualEval).Error
	if err != nil {
		return
	}

	for _, v := range qualEval {
		if v.Operator != "" {
			usAry := strings.Split(v.Operator, ",")
			if len(usAry) > 0 {
				for _, vv := range usAry {

					if commonus.IsItTrueString(vv, UserList) == false {
						UserList = append(UserList, vv)
						usCont, usErr := commonus.GetUserInfoPublic([]string{"worker_man.wm_number", "worker_man_data.wmd_name"}, map[string]interface{}{"wm_key": vv})
						if usErr == true {
							var userCont QualEvalArrt
							userCont.Id = vv
							userCont.Name = usCont.Name
							UserListAry = append(UserListAry, userCont)
						}
					}
				}
			}
		}
	}
	return
}

// 获取定性指标->指标细则修改回显
func (d *DutyAssessApi) GetDetailedTargetCallBack(c *gin.Context) {
	var requestData commonus.SetIds
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if requestData.Id == 0 && requestData.OutId == "" {
		response.Result(102, err, "参数错误！请重新提交！", c)
		return
	}
	if requestData.OutId != "" {
		idInt, inIntErr := strconv.ParseInt(requestData.OutId, 10, 64)
		if inIntErr == nil {
			requestData.Id = idInt
		}
	}
	var cont assessmentmodel.QualitativeEvaluation
	errErr := global.GVA_DB_Performanceappraisal.Where("`qe_id` = ?", requestData.Id).Find(&cont).Error
	if errErr != nil {
		response.Result(103, err, "没有获取到数据！", c)
		return
	}
	//输出格式
	var content OutTargetCont
	content.Id = strconv.FormatInt(requestData.Id, 10)
	//获取子栏目信息
	sunTargetCont, _ := commonus.GetQualitativeTargetInfo(cont.TargetSun)
	content.SunTargerId = strconv.FormatInt(sunTargetCont.Id, 10)
	content.SunTargetName = sunTargetCont.Title
	//获取指标细则信息
	detaileInfo, _ := commonus.GetDetailedTargetInfo(cont.DetailedTarget)
	content.DetailedTargetId = strconv.FormatInt(detaileInfo.Id, 10)
	content.DetailedTargetName = detaileInfo.Title
	content.DetailedTargetContent = detaileInfo.Content
	shenPiRen := strings.Split(cont.Operator, ",")
	content.Operator = shenPiRen
	for _, v := range shenPiRen {
		usCont, usErr := commonus.GetUserInfoPublic([]string{"worker_man.wm_number", "worker_man_data.wmd_name"}, map[string]interface{}{"wm_key": v})
		if usErr == true {
			var userCont QualEvalArrt
			userCont.Id = v
			userCont.Name = usCont.Name
			content.OperatorAry = append(content.OperatorAry, userCont)
		}
	}
	//获取所有子栏目
	var qualTar []assessmentmodel.QualitativeTarget
	quaTarErr := global.GVA_DB_Performanceappraisal.Where("`q_parent_id` = ?", cont.Target).Find(&qualTar).Error
	if quaTarErr == nil {
		for _, s_v := range qualTar {
			var sunTarCont QualEvalArrt
			sunTarCont.Id = strconv.FormatInt(s_v.Id, 10)
			sunTarCont.Name = s_v.Title
			content.SunTargerList = append(content.SunTargerList, sunTarCont)
		}
	}
	response.Result(0, content, "获取成功！", c)
}

// 获取定性指标->指标细则修改回显
func (d *DutyAssessApi) EiteDetailedTargetCallBack(c *gin.Context) {
	var requestData GetEiteTargetCont
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if requestData.Id == "" {
		response.Result(102, err, "参数错误！请重新提交！", c)
		return
	}
	var cont assessmentmodel.QualitativeEvaluation
	errErr := global.GVA_DB_Performanceappraisal.Where("`qe_id` = ?", requestData.Id).Find(&cont).Error
	if errErr != nil {
		response.Result(103, err, "未能获取到数据！", c)
		return
	}
	isTrue := false
	if requestData.Class != 1 {
		isTrue = NewEiteData(requestData, cont)
	} else {
		isTrue = NewAddData(requestData, cont)
	}
	if isTrue == false {
		response.Result(104, err, "数据处理失败", c)
		return
	}
	response.Result(0, err, "数据处理成功", c)
}

// 新增
func NewAddData(getData GetEiteTargetCont, oldData assessmentmodel.QualitativeEvaluation) (isTrue bool) {
	isTrue = false
	var detailedTargetInfo assessmentmodel.DetailedTarget
	detailedTargetInfo.Title = getData.DetailedTargetName
	detailedTargetInfo.Content = getData.DetailedTargetContent
	detailedTargetInfo.ParentId = oldData.Target
	detailedTargetInfo.ParentIdSun = oldData.TargetSun
	detailedTargetInfo.State = 1
	detailedTargetInfo.AddTime = time.Now().Unix()
	addErr := global.GVA_DB_Performanceappraisal.Create(&detailedTargetInfo).Error
	if addErr != nil {
		return
	}
	var saveData assessmentmodel.QualitativeEvaluation
	saveData.Title = oldData.Title
	saveData.DepartmentId = oldData.DepartmentId
	saveData.Dimension = oldData.Dimension
	saveData.Target = oldData.Target
	saveData.TargetSun = oldData.TargetSun
	saveData.DetailedTarget = detailedTargetInfo.Id
	saveData.Type = oldData.Type
	saveData.Weight = oldData.Weight
	saveData.Unit = oldData.Unit
	saveData.ReferenceScore = oldData.ReferenceScore
	saveData.State = oldData.State
	saveData.Addtime = time.Now().Unix()
	saveData.Eitetime = time.Now().Unix()
	saveData.Group = oldData.Group
	saveData.QualEvalId = oldData.QualEvalId
	saveData.Cycles = oldData.Cycles
	saveData.CycleAttres = oldData.CycleAttres
	saveData.AcceptEvaluation = oldData.AcceptEvaluation
	saveData.Operator = oldData.Operator
	saveData.Content = oldData.Content
	addErrQE := global.GVA_DB_Performanceappraisal.Create(&saveData).Error
	if addErrQE != nil {
		return
	}
	isTrue = true
	return
}

// 修改
func NewEiteData(getData GetEiteTargetCont, oldData assessmentmodel.QualitativeEvaluation) (isTrue bool) {
	isTrue = false
	eiteDetailedInfo := commonus.MapOut()
	eiteDetailedInfo["dt_time"] = time.Now().Unix()
	if getData.DetailedTargetName != "" {
		eiteDetailedInfo["dt_title"] = getData.DetailedTargetName
	}
	if getData.DetailedTargetContent != "" {
		eiteDetailedInfo["dt_content"] = getData.DetailedTargetContent
	}
	eiteDetaInfoErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DetailedTarget{}).Where("`dt_id` = ?", oldData.DetailedTarget).Updates(&eiteDetailedInfo).Error
	if eiteDetaInfoErr != nil {
		return
	}
	if len(getData.Operator) > 0 {
		eiteQualEvlInfo := commonus.MapOut()
		eiteQualEvlInfo["qe_eitetime"] = time.Now().Unix()
		eiteQualEvlInfo["qe_operator"] = strings.Join(getData.Operator, ",")
		eiteQualEvlInfo["qe_department_id"] = strings.Join(commonus.GetDepartmentByUserBast(getData.Operator), ",")
		eiteDetaQuaInfoErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Where("`qe_id` = ?", oldData.Id).Updates(&eiteQualEvlInfo).Error
		if eiteDetaQuaInfoErr != nil {
			return
		}
	}
	isTrue = true
	return
}

// 修改子栏目名称
func (d *DutyAssessApi) EiteSunTargetName(c *gin.Context) {
	var requestData EiteTargetContListSun
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if requestData.Id == "" {
		response.Result(102, requestData, "参数错误！请重新提交！", c)
		return
	}
	if requestData.Name == "" {
		response.Result(103, err, "参数错误！请重新提交！", c)
		return
	}
	if requestData.Group == "" {
		response.Result(104, err, "参数错误！无法获取数据", c)
		return
	}
	if requestData.Dimension == "" {
		response.Result(105, err, "参数错误！无法获取数据", c)
		return
	}
	if requestData.TargetId == "" {
		response.Result(106, err, "参数错误！无法获取数据", c)
		return
	}
	if len(requestData.Operator) < 1 {
		response.Result(107, err, "没有执行人！", c)
		return
	}

	var assCont assessmentmodel.Assesstarget
	assErr := global.GVA_DB_Performanceappraisal.Where("`group` = ? AND `dimension` = ? AND `targetid` = ? AND `suntargetid` = ?", requestData.Group, requestData.Dimension, requestData.TargetId, requestData.Id).First(&assCont).Error

	if assErr != nil {
		response.Result(104, err, "没有该数据！", c)
		return
	}

	var userMap []DutyAssEssTarget

	jsonErr := json.Unmarshal([]byte(assCont.Content), &userMap)
	var detaTargetid []int64
	if jsonErr == nil {
		var saveUserAry []DutyAssEssTarget
		for _, um_v := range userMap {
			var saveUserCont DutyAssEssTarget
			saveUserCont.Id = um_v.Id
			saveUserCont.Operator = requestData.Operator
			saveUserAry = append(saveUserAry, saveUserCont)
			detaTargetid = append(detaTargetid, um_v.Id)
		}
		if len(saveUserAry) > 0 {
			eiteAssCont := commonus.MapOut()
			eiteAssCont["time"] = time.Now().Unix()
			eiteUserJson, _ := json.Marshal(saveUserAry)
			eiteAssCont["content"] = string(eiteUserJson)
			global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.Assesstarget{}).Where("`at_id` = ?", assCont.Id).Updates(eiteAssCont)
		}
		if len(detaTargetid) > 0 {
			eiteAssContDeite := commonus.MapOut()
			eiteAssContDeite["dt_time"] = time.Now().Unix()
			if requestData.Cycles > 0 {
				eiteAssContDeite["dt_cycle"] = requestData.Cycles
			}
			if requestData.CycleAttres > 0 {
				eiteAssContDeite["dt_cycleattr"] = requestData.CycleAttres
			}
			if requestData.CensorType > 0 {
				eiteAssContDeite["dt_censor_type"] = requestData.CensorType
			}
			eiteAssContDeite["dt_censor_cont"] = requestData.CensorCont
			if requestData.CensorRate > 0 {
				// eiteAssContDeite["dt_censor_rate"] = requestData.CensorRate
				eiteAssContDeite["dt_cycle"] = requestData.CensorRate
			}
			if len(requestData.DepartmentMap) > 0 {
				eiteAssContDeite["dt_paretment"] = strings.Join(requestData.DepartmentMap, ",")
			}

			global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DetailedTarget{}).Where("`dt_id` IN ?", detaTargetid).Updates(eiteAssContDeite)
		}
	}

	var oldId int64
	errCont := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeTarget{}).Select("q_id").Where("`q_id` = ?", requestData.Id).First(&oldId).Error
	if errCont != nil {
		response.Result(104, err, "没有该数据！", c)
		return
	}
	eiteCont := commonus.MapOut()
	eiteCont["q_time"] = time.Now().Unix()
	eiteCont["q_title"] = requestData.Name
	if len(requestData.DepartmentMap) > 0 {
		eiteCont["q_depart"] = strings.Join(requestData.DepartmentMap, ",")
	} else {
		eiteCont["q_depart"] = ""
	}
	errEiteCont := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeTarget{}).Where("`q_id` = ?", requestData.Id).Updates(&eiteCont).Error
	if errEiteCont != nil {
		response.Result(105, err, "修改失败！", c)
		return
	}
	WriteBackTargetDepartment(requestData.TargetId, requestData.DepartmentMap)
	response.Result(0, err, "数据处理成功", c)
}

// 删除定性考核指标
func (d *DutyAssessApi) DelDutyTarget(c *gin.Context) {
	var requestData QualEvalArrt
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if requestData.Id == "" {
		response.Result(102, err, "参数错误！请重新提交！", c)
		return
	}
	eiteCont := commonus.MapOut()
	eiteCont["qe_eitetime"] = time.Now().Unix()
	eiteCont["qe_state"] = 3
	errEiteCont := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Where("`qe_target` = ?", requestData.Id).Updates(&eiteCont).Error
	if errEiteCont != nil {
		response.Result(105, errEiteCont, "删除失败！", c)
		return
	}
	response.Result(0, err, "数据处理成功", c)
}

// 删除子栏目及附属指标详情
func (d *DutyAssessApi) DelSunTarDimeat(c *gin.Context) {
	var requestData QualEvalArrt
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if requestData.Id == "" {
		response.Result(102, err, "参数错误！请重新提交！", c)
		return
	}
	var qualId int64
	errEiteQualGuiShuCont := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeTarget{}).Select("q_parent_id").Where("`q_id` = ?", requestData.Id).First(&qualId).Error
	if errEiteQualGuiShuCont != nil {
		response.Result(103, err, "参数错误！请重新提交！", c)
		return
	}
	eiteCont := commonus.MapOut()
	eiteCont["qe_eitetime"] = time.Now().Unix()
	eiteCont["qe_state"] = 3
	errEiteCont := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Where("`qe_target_sun` = ?", requestData.Id).Updates(&eiteCont).Error
	if errEiteCont != nil {
		response.Result(105, errEiteCont, "删除失败！", c)
		return
	}
	eiteQualTar := commonus.MapOut()
	eiteQualTar["q_time"] = time.Now().Unix()
	eiteQualTar["q_state"] = 3
	errEiteQualCont := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeTarget{}).Where("`q_id` = ?", requestData.Id).Updates(&eiteQualTar).Error
	if errEiteQualCont == nil {
		eiteQualTarDited := commonus.MapOut()
		eiteQualTarDited["dt_time"] = time.Now().Unix()
		eiteQualTarDited["dt_state"] = 3
		global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DetailedTarget{}).Where("`dt_parentid` = ? AND `dt_parentid_sun` = ?", qualId, requestData.Id).Updates(&eiteQualTarDited)
	}

	response.Result(0, err, "数据处理成功", c)
}

// 添加 定性考核指标关系指定
func (d *DutyAssessApi) AddDutyRelationOld(c *gin.Context) {
	var requestData AddQualEval
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		// response.Result(101, err, "数据获取失败！", c)
		// return
	}
	if requestData.Group == "" {
		response.Result(102, err, "请选择归属集团", c)
		return
	}
	if len(requestData.AcceptDepartmentId) <= 0 {
		response.Result(103, err, "请选择接受考核的部门！", c)
		return
	}
	// if requestData.Dimension == "" {
	// 	response.Result(102, err, "请选择考核维度", c)
	// 	return
	// }
	if requestData.Target == "" {
		response.Result(104, err, "请选择考核指标", c)
		return
	}
	if requestData.TargetSunTitle == "" {
		response.Result(105, err, "请输入栏目名称！", c)
		return
	}
	if len(requestData.EvaluationList) <= 0 {
		response.Result(106, err, "请添加测评详情！", c)
		return
	}
	// fmt.Printf("kjh------11------>%v\n", requestData)
	sunTarDepartStr := strings.Join(requestData.AcceptDepartmentId, ",")
	//获取子目标情况
	sunTargetCont, sunTargetErr := commonus.JudgeColumn(requestData.Target, requestData.TargetSun, requestData.TargetSunTitle, sunTarDepartStr)
	if sunTargetErr != true {
	}
	//将集团Id转化成整型
	groupInt, groupIntErr := strconv.ParseInt(requestData.Group, 10, 64)
	if groupIntErr != nil {
		groupInt = 1
	}
	//指标
	targetInt, targetIntErr := strconv.ParseInt(requestData.Target, 10, 64)
	if targetIntErr != nil {
		targetInt = 0
	}
	//维度
	dimensionInt, departinIntErr := strconv.ParseInt(requestData.Dimension, 10, 64)
	if departinIntErr != nil {
		dimensionInt = 0
	}
	if dimensionInt == 0 {
		targetInfo, targetInfoErr := commonus.GetTargetInfo(targetInt)
		if targetInfoErr == true {
			dimensionInt = targetInfo.Dimension
		}
	}
	//关联集团部门考核维度
	commonus.AddDepartDimension(requestData.Group, strconv.FormatInt(dimensionInt, 10), requestData.Dimension, 1)

	//原指标细则
	var oldId []int64
	global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DetailedTarget{}).Select("`dt_id`").Where("`dt_state` = 1 AND `dt_parentid` = ? AND `dt_parentid_sun` = ?", requestData.Target, sunTargetCont.Id).Find(&oldId)
	//遍历指标细则
	var targetContList []DutyAssEssTarget

	var newAddId []int64
	for _, v := range requestData.EvaluationList {
		// detailedTargetInfo, dtiIsTrue := commonus.JudgeDetails(requestData.Target, v.Title, v.Content, v.DetailedTarget, sunTargetCont.Id)
		// detailedTargetInfo, dtiIsTrue := commonus.JudgeDetailsCopy(requestData.Target, v.Title, v.Content, v.DetailedTarget, v.ReferenceScore, v.Unit, sunTargetCont.Id, v.AddOrReduce)
		// fmt.Printf("关联部门------11------>%v\n", sunTarDepartStr)
		// panic(sunTarDepartStr)
		detailedTargetInfo, dtiIsTrue := JudgeDetailsCopyEs(requestData.Target, sunTarDepartStr, sunTargetCont.Id, v)

		/*
			参数说明
			@ascription				归属指标栏目
			@title					指标细则
			@explain				指标说明'
			@explainId				指标明细ID
			@ReferenceScore			分数
			@CompanyCont				单位
			@sunTargetId			子栏目
		*/

		if dtiIsTrue == true {
			if detailedTargetInfo.Id != 0 {
				newAddId = append(newAddId, detailedTargetInfo.Id)
				var targetContInfo DutyAssEssTarget
				targetContInfo.Id = detailedTargetInfo.Id
				targetContInfo.Operator = v.Operator
				targetContList = append(targetContList, targetContInfo)
			}
		}
	}

	mergeMap := append(oldId, newAddId...) //合并两个数组
	var finalResultId []int64              //最终结果
	for _, m_v := range mergeMap {
		if commonus.IsItTrue(m_v, finalResultId) != true {
			finalResultId = append(finalResultId, m_v)
		}
	}

	//组合写入数据
	for _, f_v := range finalResultId {
		if commonus.IsItTrue(f_v, newAddId) != true {
			var targetContInfos DutyAssEssTarget
			targetContInfos.Id = f_v
			targetContList = append(targetContList, targetContInfos)
		}
	}
	// response.Result(0, targetContList, "处理成功！", c)
	// return
	//判断该集团指标子栏目是否存在
	var arTaegetInfo assessmentmodel.Assesstarget
	judgeARTErr := global.GVA_DB_Performanceappraisal.Where("`group` = ? AND `dimension` = ? AND `targetid` = ? AND `suntargetid` = ?", groupInt, dimensionInt, targetInt, sunTargetCont.Id).First(&arTaegetInfo).Error

	//判断指标是否存在并且获取已存在的所有指标关联部门
	var guanLianBuMen []string
	for _, vvk_vs := range requestData.AcceptDepartmentId {
		if commonus.IsItTrueString(vvk_vs, guanLianBuMen) == false {
			guanLianBuMen = append(guanLianBuMen, vvk_vs)
		}
	}
	var sunTarId []int64
	judgeARkTErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.Assesstarget{}).Select("`suntargetid`").Where("`group` = ? AND `dimension` = ? AND `targetid` = ? ", groupInt, dimensionInt, targetInt).Find(&sunTarId).Error
	// fmt.Printf("kjh------1------>%v------>%v\n", sunTarId, judgeARkTErr)
	if judgeARkTErr == nil {
		var sunTarDepartMap []string
		judgeSunTarkTErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeTarget{}).Select("`q_depart`").Where("`q_id` IN ?", sunTarId).Find(&sunTarDepartMap).Error
		// fmt.Printf("kjh------2------>%v\n", sunTarDepartMap)
		if judgeSunTarkTErr == nil {
			// var departStrAry []string
			for _, vvk := range sunTarDepartMap {
				departStrAry := strings.Split(vvk, ",")
				for _, vvk_v := range departStrAry {
					if commonus.IsItTrueString(vvk_v, guanLianBuMen) == false {
						guanLianBuMen = append(guanLianBuMen, vvk_v)
					}
				}
			}

		}
		eiteContkk := commonus.MapOut()
		eiteContkk["departmentmap"] = strings.Join(guanLianBuMen, ",")
		eiteContkk["time"] = time.Now().Unix()
		global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.Assesstarget{}).Where("`suntargetid` IN ?", sunTarId).Updates(eiteContkk)
		// fmt.Printf("kjh------3------>%v\n", eiteContkk)
	}

	if judgeARTErr == nil {

		var eiteTarList []DutyAssEssTarget
		// var eiteId []int64
		if arTaegetInfo.Content != "" && arTaegetInfo.Content != "null" {
			var tarList []DutyAssEssTarget
			jsonErr := json.Unmarshal([]byte(arTaegetInfo.Content), &tarList)
			if jsonErr == nil {
				// if len(tarList) > len(targetContList) {
				// 	for _, tl_v := range tarList {

				// 		tarInfo, tarInfoErr := JudgeDeiScor(tl_v.Id, targetContList)
				// 		if tarInfoErr == false {
				// 			eiteTarList = append(eiteTarList, tarInfo)
				// 		} else {
				// 			eiteTarList = append(eiteTarList, tl_v)
				// 		}
				// 	}
				// } else {
				// 	for _, ttl_v := range targetContList {
				// 		tarInfo, tarInfoErr := JudgeDeiScor(ttl_v.Id, tarList)
				// 		if tarInfoErr == true {
				// 			eiteTarList = append(eiteTarList, tarInfo)
				// 		} else {
				// 			eiteTarList = append(eiteTarList, ttl_v)
				// 		}

				// 	}
				// }
				for _, ttl_v := range targetContList {
					eiteTarList = append(eiteTarList, ttl_v)
				}
				for _, tl_v := range tarList {
					_, tarInfoErr := JudgeDeiScor(tl_v.Id, targetContList)
					if tarInfoErr == false {
						eiteTarList = append(eiteTarList, tl_v)
					}
				}
			}

		} else {
			eiteTarList = targetContList
		}

		// fmt.Printf("llllllllllll----->%v\n", newAddId)

		eiteCont := commonus.MapOut()

		// oldDepartAry := strings.Join(",",",")
		// oldDepartAry := strings.Split(arTaegetInfo.Departmentmap, ",")
		// mergeDepartMap := append(oldDepartAry, requestData.AcceptDepartmentId...)

		// var finalResultDepartId []string //最终结果
		// for _, mdm_v := range mergeDepartMap {
		// 	if commonus.IsItTrueString(mdm_v, finalResultDepartId) != true {
		// 		finalResultDepartId = append(finalResultDepartId, mdm_v)
		// 	}
		// }

		// eiteCont["departmentmap"] = strings.Join(requestData.AcceptDepartmentId, ",")
		// eiteCont["departmentmap"] = strings.Join(guanLianBuMen, ",")
		eiteCont["time"] = time.Now().Unix()
		jsonStr, jsonMErr := json.Marshal(eiteTarList)
		if jsonMErr == nil {
			eiteCont["content"] = string(jsonStr)
		}

		eiteErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.Assesstarget{}).Where("`at_id` = ?", arTaegetInfo.Id).Updates(eiteCont).Error
		if eiteErr == nil {
			response.Result(0, err, "处理成功！1", c)
		} else {
			response.Result(107, err, "请添加测评详情！", c)
		}
	} else {
		arTaegetInfo.Group = groupInt

		arTaegetInfo.Departmentmap = strings.Join(guanLianBuMen, ",")
		arTaegetInfo.TargetId = targetInt
		arTaegetInfo.SunTargetId = sunTargetCont.Id
		arTaegetInfo.Dimension = dimensionInt
		jsonStr, jsonMErr := json.Marshal(targetContList)
		if jsonMErr == nil {
			arTaegetInfo.Content = string(jsonStr)
		}
		arTaegetInfo.Time = time.Now().Unix()
		addErr := global.GVA_DB_Performanceappraisal.Create(&arTaegetInfo).Error
		if addErr == nil {
			response.Result(0, err, "处理成功！2", c)
		} else {
			response.Result(107, err, "请添加测评详情！", c)
		}
	}
}

// 判断是否存在项目
func JudgeDeiScor(id int64, listCont []DutyAssEssTarget) (cont DutyAssEssTarget, isTrue bool) {
	isTrue = false
	for _, v := range listCont {
		if id == v.Id {
			cont = v
			isTrue = true
		}
	}
	return
}

// 获取定性考核指标关系指定列表
func (d *DutyAssessApi) GetDutyRelationList(c *gin.Context) {
	var targetAssessAry []assessmentmodel.Assesstarget
	errGroup := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.Assesstarget{}).Select("`group`,`dimension`,`targetid`").Group("`group`,`dimension`,`targetid`").Order("`group` ASC").Order("`dimension` ASC").Order("`targetid` ASC").Find(&targetAssessAry).Error
	if errGroup != nil {
		response.Result(107, errGroup, "没有信息", c)
		return
	}
	var outContList []dutyOutNew
	for _, v := range targetAssessAry {
		var tarContMap assessmentmodel.EvaluationTarget
		tarErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.EvaluationTarget{}).Select("`et_title`,`et_cycle`,`et_cycleattr`").Where("`et_id` = ?", v.TargetId).First(&tarContMap).Error
		if tarErr == nil {
			var outInfo dutyOutNew
			outInfo.Group = strconv.FormatInt(v.Group, 10)
			//维度信息
			dutyClassCont, _ := commonus.GetDutyClassInfo(v.Dimension)
			outInfo.Dimension = strconv.FormatInt(v.Dimension, 10)
			outInfo.Dimensionname = dutyClassCont.Title

			//指标信息
			outInfo.Target = strconv.FormatInt(v.TargetId, 10)
			tarCont, _ := commonus.GetTargetInfo(v.TargetId)
			outInfo.Targetname = tarCont.Title
			outInfo.Cycles = tarCont.Cycles           //1：班；2：天；3：周；4：月；5：季度；6：年"`
			outInfo.CycleAttres = tarCont.CycleAttres //辅助计数"`

			outInfo.Departmentid, outInfo.Departmentmap, outInfo.UserList, outInfo.UserListAry = jieXiDutyList(v.Group, v.Dimension, v.TargetId)

			outContList = append(outContList, outInfo)
		}

	}

	response.Result(0, outContList, "查询完成！", c)
	return
	// var list []assessmentmodel.Assesstarget
	// err := global.GVA_DB_Performanceappraisal.Order("`group` ASC").Order("`targetid` ASC").Order("`suntargetid` ASC").Find(&list).Error
	// if err != nil {
	// 	response.Result(107, err, "没有信息", c)
	// 	return
	// }
	// var outList []OutDutyListes
	// for _, v := range list {
	// 	var outCont OutDutyListes

	// 	outCont.Id = strconv.FormatInt(v.Id, 10)
	// 	outCont.Group = strconv.FormatInt(v.Group, 10)
	// 	//指标信息
	// 	outCont.Target = strconv.FormatInt(v.TargetId, 10)
	// 	tarCont, _ := commonus.GetTargetInfo(v.TargetId)
	// 	outCont.TargetName = tarCont.Title
	// 	//维度信息
	// 	dutyClassCont, _ := commonus.GetDutyClassInfo(tarCont.Dimension)
	// 	outCont.Dimension = strconv.FormatInt(tarCont.Dimension, 10)
	// 	outCont.DimensionName = dutyClassCont.Title

	// 	outCont.Content = ""                      //指标说明
	// 	outCont.Unit = tarCont.Uniteing           //单位"`
	// 	outCont.ReferenceScore = 0                //标准分值"`
	// 	outCont.Cycles = tarCont.Cycles           //1：班；2：天；3：周；4：月；5：季度；6：年"`
	// 	outCont.CycleAttres = tarCont.CycleAttres //辅助计数"`
	// 	outCont.State = 1

	// 	// outCont.DepartmentId, outCont.DepartmentAry = commonus.GetBranchDepartAry(strings.Split(v.Departmentmap, ","))
	// 	outCont.DepartmentId, outCont.DepartmentAry = commonus.GetNewOrgList(strings.Split(v.Departmentmap, ","))

	// 	shenPiRen := strings.Split(tarCont.Report, ",")
	// 	outCont.UserList = shenPiRen
	// 	for _, v := range shenPiRen {
	// 		// usCont, usErr := commonus.GetWorkUser(v)
	// 		userWher := commonus.MapOut()
	// 		userWher["key"] = v
	// 		usCont, usErr := commonus.GetNewHrPeopleInfo(userWher)
	// 		// GetWorkUser
	// 		if usErr == true {
	// 			var userCont QualEvalArrt
	// 			userCont.Id = v
	// 			userCont.Name = usCont.Name
	// 			userCont.Icon = usCont.Icon

	// 			where := commonus.MapOut()
	// 			// where["id"] = usCont.Group
	// 			where["id"] = usCont.Company
	// 			orgCont, _ := commonus.GetNewOrgCont(where, "id", "name", "abbreviation")
	// 			userCont.GroupName = orgCont.Name
	// 			if orgCont.Abbreviation != "" {
	// 				userCont.GroupName = orgCont.Abbreviation
	// 			}

	// 			whereDepart := commonus.MapOut()
	// 			// whereDepart["id"] = usCont.DepartmentId
	// 			whereDepart["id"] = usCont.Deparment
	// 			orgContDepart, _ := commonus.GetNewOrgCont(whereDepart, "id", "name")
	// 			userCont.DepartmentName = orgContDepart.Name

	// 			// _, groupInfo := commonus.GetGroupCont(usCont.Group)
	// 			// userCont.GroupName = groupInfo.Name
	// 			// _, bfInfo := commonus.GetBranchFactory(usCont.DepartmentId)
	// 			// userCont.DepartmentName = bfInfo.Name
	// 			userCont.Number = usCont.Number
	// 			outCont.UserListAry = append(outCont.UserListAry, userCont)
	// 		}
	// 	}

	// 	outList = append(outList, outCont)
	// }
	// response.Result(0, outList, "查询完成！", c)
}

// 查看定性考核项目详情
func (d *DutyAssessApi) LookDutyTargetInfoOld(c *gin.Context) {
	var requestData LookTargetContList
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if requestData.Group == "" {
		response.Result(102, err, "参数错误！无法获取数据", c)
		return
	}
	if requestData.Dimension == "" {
		response.Result(103, err, "参数错误！无法获取数据", c)
		return
	}
	if requestData.TargetId == "" {
		response.Result(104, err, "参数错误！无法获取数据", c)
		return
	}
	var assessInfoList []assessmentmodel.Assesstarget
	goromDb := global.GVA_DB_Performanceappraisal.Where("`group` = ? AND `dimension` = ? AND `targetid` = ?", requestData.Group, requestData.Dimension, requestData.TargetId)
	// if requestData.DepartId != "" {
	// 	goromDb = goromDb.Where("FIND_IN_SET(?,`qe_operator`)", requestData.DepartId)
	// }

	assErr := goromDb.Find(&assessInfoList).Error
	if assErr != nil {
		response.Result(105, assErr, "没有获取到数据！", c)
		return
	}
	// response.Result(104, assessInfoList, "参数错误！无法获取数据", c)
	// return
	var uotContAry []TargetContOutCont
	for _, v := range assessInfoList {
		var uotCont TargetContOutCont
		uotCont.DutyAssessId = strconv.FormatInt(v.Id, 10)
		uotCont.Type = 1
		//集团
		uotCont.Group = requestData.Group
		// _, groupCont := commonus.GetGroupCont(v.Group)
		// uotCont.GroupNAme = groupCont.Name

		where := commonus.MapOut()
		where["id"] = v.Group
		orgCont, _ := commonus.GetNewOrgCont(where, "id", "name")
		uotCont.GroupNAme = orgCont.Name
		//执行部门
		uotCont.DepartmentId = v.Departmentmap

		_, DepartmentAry := commonus.GetNewOrgList(strings.Split(v.Departmentmap, ","))

		var depNameMap []string
		for _, sep_v := range DepartmentAry {
			depNameMap = append(depNameMap, sep_v.Parentname)
		}

		// _, departInfoAry := commonus.GetBranchDepartAry(strings.Split(v.Departmentmap, ","))
		// var depNameMap []string
		// for _, sep_v := range departInfoAry {
		// 	depNameMap = append(depNameMap, sep_v.Parentname)
		// }
		uotCont.DepartmentName = strings.Join(depNameMap, ",")
		uotCont.DepartNameMap = depNameMap
		//维度
		uotCont.Dimension = strconv.FormatInt(v.Dimension, 10)
		dutyClassCont, _ := commonus.GetDutyClassInfo(v.Dimension)
		uotCont.DimensionName = dutyClassCont.Title
		//指标
		uotCont.Target = requestData.TargetId
		targetInfo, _ := commonus.GetTargetInfo(v.TargetId)
		uotCont.TargetName = targetInfo.Title
		//子栏目
		uotCont.TargetSun = strconv.FormatInt(v.SunTargetId, 10)
		info, _ := commonus.GetQualitativeTargetInfo(v.SunTargetId)
		sunTarDepartMap := strings.Split(info.Depart, ",")
		uotCont.DepartIdMap = sunTarDepartMap
		//查询部门
		isShow := true
		// if requestData.DepartId != "" {
		// 	if commonus.IsItTrueString(requestData.DepartId, sunTarDepartMap) == true {
		// 		isShow = true
		// 	}
		// } else {
		// 	isShow = true
		// }
		fmt.Printf("isShow-------->%v-------->%v-------->%v---->%v\n", isShow, requestData.DepartId, sunTarDepartMap, v.SunTargetId)
		if isShow == true {
			uotCont.TargetSunName = info.Title
			//拆解指标详情
			var detailedList []DutyAssEssTarget
			detailedListErr := json.Unmarshal([]byte(v.Content), &detailedList)
			if detailedListErr == nil {
				// var detaiList []TargetContOutCont
				// for _,d_v := range detailedList{}
				if len(detailedList) > 0 {
					for _, d_v := range detailedList {
						uotCont.Id = strconv.FormatInt(d_v.Id, 10)
						uotCont.DetailedTarget = strconv.FormatInt(d_v.Id, 10)
						uotCont.UserList = d_v.Operator

						// dtCont, _ := commonus.GetDetailedTargetInfo(d_v.Id)

						// isDepartAry := strings.Split(dtCont.Paretment, ",")
						// isShowTar := false
						// if len(isDepartAry) > 0 && requestData.DepartId != "" {
						// 	if commonus.IsItTrueString(requestData.DepartId, isDepartAry) == true {
						// 		isShowTar = true
						// 	} else {
						// 		isShowTar = false
						// 	}
						// } else {
						// 	isShowTar = true
						// }
						isShowTar := false
						var dtCont assessmentmodel.DetailedTarget
						gormDbDetaTar := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DetailedTarget{}).Where("dt_id = ?", d_v.Id)
						if requestData.DepartId != "" {
							gormDbDetaTar = gormDbDetaTar.Where("FIND_IN_SET(?,`dt_paretment`)", requestData.DepartId)
						}
						if requestData.CensorRate != 0 {
							gormDbDetaTar = gormDbDetaTar.Where("dt_censor_rate = ?", requestData.CensorRate)
						}
						if requestData.CensorCont != "" {
							gormDbDetaTar = gormDbDetaTar.Where("dt_censor_cont LIKE ?", "%"+requestData.CensorCont+"%")
						}
						errDetaTar := gormDbDetaTar.First(&dtCont).Error
						if errDetaTar == nil {
							if len(requestData.CensorType) > 0 {
								conCensorType := strings.Split(dtCont.CensorType, ",")
								for _, cvk := range requestData.CensorType {
									if commonus.IsItTrueString(cvk, conCensorType) == true {
										isShowTar = true
									}
								}
							} else {
								isShowTar = true
							}

						}
						fmt.Printf("isShowTar------isShowTar-->%v--requestData-->%v--DepartId-->%v--dtCont-->%v\n", isShowTar, requestData, requestData.DepartId, dtCont)
						if isShowTar == true {
							uotCont.DetailedTargetName = dtCont.Title
							uotCont.Content = dtCont.Content
							uotCont.Unit = dtCont.Company
							uotCont.State = dtCont.State
							uotCont.MinScore = float64(dtCont.MinScore) / 100
							uotCont.MaxScore = float64(dtCont.MaxScore) / 100

							uotCont.CyclesDetTar = dtCont.Cycles                       //`json:"cycledettar"`     //1：班；2：天；3：周；4：月；5：季度；6：年
							uotCont.CycleDetTarAttres = dtCont.CycleAttres             //`json:"cycleattrdettar"` //辅助计数
							uotCont.CensorType = strings.Split(dtCont.CensorType, ",") //`json:"censortype"`      //检查方式（1：现场检查；2：资料检查；3：事件触发）
							uotCont.CensorCont = dtCont.CensorCont                     //`json:"censorcont"`      //检查依据
							uotCont.CensorRate = dtCont.CensorRate                     //`json:"censorrate"`      //检查频次

							uotCont.ScoreIng = "0"
							if dtCont.MinScore > 0 && dtCont.MaxScore > 0 {
								uotCont.ScoreIng = fmt.Sprintf("%v-%v", float64(dtCont.MinScore)/100, float64(dtCont.MaxScore)/100)
							} else if dtCont.MinScore > 0 && dtCont.MaxScore <= 0 {
								uotCont.ScoreIng = fmt.Sprintf("%v", float64(dtCont.MinScore)/100)
							} else if dtCont.MinScore <= 0 && dtCont.MaxScore > 0 {
								uotCont.ScoreIng = fmt.Sprintf("%v", float64(dtCont.MaxScore)/100)
							} else {
								uotCont.ScoreIng = "0"
							}
							for _, u_v := range d_v.Operator {
								usCont, usErr := commonus.GetWorkUser(u_v)
								if usErr == true {
									var userCont QualEvalArrt
									userCont.Id = u_v
									userCont.Name = usCont.Name
									userCont.Icon = usCont.Icon

									where := commonus.MapOut()
									where["id"] = usCont.Company
									orgCont, _ := commonus.GetNewOrgCont(where, "id", "name")
									userCont.GroupName = orgCont.Name

									whereDepart := commonus.MapOut()
									whereDepart["id"] = usCont.MainDeparment
									orgContDepart, _ := commonus.GetNewOrgCont(whereDepart, "id", "name")
									userCont.DepartmentName = orgContDepart.Name

									// _, groupInfo := commonus.GetGroupCont(usCont.Group)
									// userCont.GroupName = groupInfo.Name
									// _, bfInfo := commonus.GetBranchFactory(usCont.DepartmentId)
									// userCont.DepartmentName = bfInfo.Name
									userCont.Number = usCont.Number
									uotCont.UserListAry = append(uotCont.UserListAry, userCont)
								}
							}

							uotContAry = append(uotContAry, uotCont)
						}

					}
				} else {
					uotContAry = append(uotContAry, uotCont)
				}
			} else {
				uotContAry = append(uotContAry, uotCont)
			}
		}

	}
	if len(uotContAry) <= 0 {
		response.Result(106, uotContAry, "没有获取到数据！", c)
	} else {
		response.Result(0, uotContAry, "获取成功！", c)
	}
}

// 删除考核指标
func (d *DutyAssessApi) NewDelTarGet(c *gin.Context) {
	var requestData LookTargetContList
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if requestData.Group == "" {
		response.Result(102, err, "参数错误！无法获取数据", c)
		return
	}
	if requestData.Dimension == "" {
		response.Result(103, err, "参数错误！无法获取数据", c)
		return
	}
	if requestData.TargetId == "" {
		response.Result(104, err, "参数错误！无法获取数据", c)
		return
	}
	groupId, _ := strconv.ParseInt(requestData.Group, 10, 64)
	dimensionId, _ := strconv.ParseInt(requestData.Dimension, 10, 64)
	targetId, _ := strconv.ParseInt(requestData.TargetId, 10, 64)
	isTrue := commonus.JudegDutyIsUse(groupId, dimensionId, targetId, 0, 0)
	if isTrue != true {
		response.Result(105, err, "你当前要删除的项目已经使用！请不要删除！以免造成正在进行的审批统计产生数据误差！", c)
		return
	}
	var oldAssEssData []assessmentmodel.Assesstarget
	global.GVA_DB_Performanceappraisal.Where("`group` = ? AND `dimension` = ? AND `targetid` = ?", requestData.Group, requestData.Dimension, requestData.TargetId).Find(&oldAssEssData)
	if len(oldAssEssData) > 0 {
		assessAttbar(oldAssEssData)
	}
	// response.Result(0, oldAssEssData, "删除成功！", c)
	delErr := global.GVA_DB_Performanceappraisal.Where("`group` = ? AND `dimension` = ? AND `targetid` = ?", requestData.Group, requestData.Dimension, requestData.TargetId).Delete(&assessmentmodel.Assesstarget{}).Error
	if delErr != nil {
		response.Result(106, delErr, "删除失败！", c)
		return
	}
	response.Result(0, delErr, "删除成功！", c)
}

// 执行附属软删除
func assessAttbar(oldAssEssData []assessmentmodel.Assesstarget) {
	var targetId []int64
	var targetSunId []int64
	var detaredTargetSunId []int64
	for _, v := range oldAssEssData {
		if commonus.IsItTrue(v.TargetId, targetId) == false {
			targetId = append(targetId, v.TargetId)
		}

		if commonus.IsItTrue(v.SunTargetId, targetSunId) == false {
			targetSunId = append(targetSunId, v.SunTargetId)
		}
		var duyEssTarget []DutyAssEssTarget
		duyTarJsonErr := json.Unmarshal([]byte(v.Content), &duyEssTarget)
		if duyTarJsonErr == nil {
			if len(duyEssTarget) > 0 {
				for _, dv := range duyEssTarget {
					if commonus.IsItTrue(dv.Id, detaredTargetSunId) == false {
						detaredTargetSunId = append(detaredTargetSunId, dv.Id)
					}

				}
			}
		}
	}
	// if len(targetId) > 0 {
	// 	saveTarData := commonus.MapOut()
	// 	saveTarData["et_state"] = 3
	// 	saveTarData["et_time"] = time.Now().Unix()
	// 	global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.EvaluationTarget{}).Where("`et_id` IN ?", targetId).Updates(&saveTarData)
	// }
	if len(targetSunId) > 0 {
		saveSunTarData := commonus.MapOut()
		saveSunTarData["q_state"] = 3
		saveSunTarData["q_time"] = time.Now().Unix()
		global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeTarget{}).Where("`q_id` IN ?", targetSunId).Updates(&saveSunTarData)
	}
	if len(detaredTargetSunId) > 0 {
		saveTarData := commonus.MapOut()
		saveTarData["dt_time"] = time.Now().Unix()
		saveTarData["dt_state"] = 3
		global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DetailedTarget{}).Where("`dt_id` IN ?", detaredTargetSunId).Updates(&saveTarData)
	}
	// panic(detaredTargetSunId)
}

// 获取被修改指标细则的详情
func (d *DutyAssessApi) GetNewEiteDetailedTarget(c *gin.Context) {
	var requestData GetDeitalTarCont
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if requestData.Id == "" {
		response.Result(102, requestData, "参数错误！请重新提交！", c)
		return
	}
	if requestData.AssId == "" {
		response.Result(103, requestData, "参数错误！请重新提交！", c)
		return
	}
	var cont assessmentmodel.DetailedTarget
	errErr := global.GVA_DB_Performanceappraisal.Where("`dt_id` = ?", requestData.Id).First(&cont).Error
	if errErr != nil {
		response.Result(104, errErr, "没有获取到数据！", c)
		return
	}
	var assCont assessmentmodel.Assesstarget
	errAssErr := global.GVA_DB_Performanceappraisal.Where("`at_id` = ?", requestData.AssId).First(&assCont).Error
	if errAssErr != nil {
		response.Result(105, errAssErr, "没有获取到数据！", c)
		return
	}
	var outPutCont NewOutPutDetailedTarget
	outPutCont.Id = strconv.FormatInt(cont.Id, 10)
	//获取子栏目信息
	sunTargetCont, _ := commonus.GetQualitativeTargetInfo(cont.ParentIdSun)
	outPutCont.SunTargerId = strconv.FormatInt(sunTargetCont.Id, 10)
	outPutCont.SunTargetName = sunTargetCont.Title
	//获取指标细则信息
	outPutCont.DetailedTargetId = strconv.FormatInt(cont.Id, 10)
	outPutCont.DetailedTargetName = cont.Title
	outPutCont.DetailedTargetContent = cont.Content

	outPutCont.Cycles = cont.Cycles
	outPutCont.CycleAttres = cont.CycleAttres
	cenType := strings.Split(cont.CensorType, ",")
	outPutCont.CensorType = cenType
	outPutCont.CensorCont = cont.CensorCont
	outPutCont.CensorRate = cont.CensorRate

	outPutCont.AddReduce = cont.AddReduce
	//单位
	outPutCont.Unit = cont.Company
	if cont.MinScore > 0 && cont.MaxScore > 0 {
		outPutCont.Score = fmt.Sprintf("%v-%v", float64(cont.MinScore)/100, float64(cont.MaxScore)/100)
	} else if cont.MinScore > 0 && cont.MaxScore <= 0 {
		outPutCont.Score = fmt.Sprintf("%v", float64(cont.MinScore)/100)
	} else if cont.MinScore <= 0 && cont.MaxScore > 0 {
		outPutCont.Score = fmt.Sprintf("%v", float64(cont.MaxScore)/100)
	} else {
		outPutCont.Score = "0"
	}
	if cont.Paretment != "" {
		outPutCont.DepartmentId = strings.Split(cont.Paretment, ",")
	}
	//解析考核方案内的指标关联人
	//拆解指标详情
	var detailedList []DutyAssEssTarget
	detailedListErr := json.Unmarshal([]byte(assCont.Content), &detailedList)
	if detailedListErr == nil {
		for _, v := range detailedList {
			if v.Id == cont.Id {
				for _, us_key := range v.Operator {
					usCont, _ := commonus.GetWorkUser(us_key)
					var userCont QualEvalArrt
					userCont.Id = us_key
					userCont.Name = usCont.Name
					userCont.Icon = usCont.Icon

					where := commonus.MapOut()
					where["id"] = usCont.Company
					orgCont, _ := commonus.GetNewOrgCont(where, "id", "name")
					userCont.GroupName = orgCont.Name

					whereDepart := commonus.MapOut()
					whereDepart["id"] = usCont.MainDeparment
					orgContDepart, _ := commonus.GetNewOrgCont(whereDepart, "id", "name")
					userCont.DepartmentName = orgContDepart.Name

					// _, groupInfo := commonus.GetGroupCont(usCont.Group)
					// userCont.GroupName = groupInfo.Name
					// _, bfInfo := commonus.GetBranchFactory(usCont.DepartmentId)
					// userCont.DepartmentName = bfInfo.Name
					userCont.Number = usCont.Number
					outPutCont.OperatorAry = append(outPutCont.OperatorAry, userCont)
					outPutCont.Operator = append(outPutCont.Operator, us_key)
				}
			}
		}
	}

	//获取所有子栏目
	var qualTar []assessmentmodel.QualitativeTarget
	quaTarErr := global.GVA_DB_Performanceappraisal.Where("`q_parent_id` = ?", cont.ParentId).Find(&qualTar).Error
	if quaTarErr == nil {
		for _, s_v := range qualTar {
			var sunTarCont QualEvalArrt
			sunTarCont.Id = strconv.FormatInt(s_v.Id, 10)
			sunTarCont.Name = s_v.Title
			outPutCont.SunTargerList = append(outPutCont.SunTargerList, sunTarCont)
		}
	}
	outPutCont.AssId = requestData.AssId
	response.Result(0, outPutCont, "获取成功！", c)

}

// 修改定性考核指标细则内容
func (d *DutyAssessApi) NewEiteDetailedTarget(c *gin.Context) {
	var requestData NewEiteDtyDiteCont
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	// if requestData.Id == "" {
	// 	response.Result(102, requestData, "参数错误！请重新提交！", c)
	// 	return
	// }
	if requestData.AssId == "" {
		response.Result(103, requestData, "参数错误！请重新提交！", c)
		return
	}
	var assCont assessmentmodel.Assesstarget
	errAssErr := global.GVA_DB_Performanceappraisal.Where("`at_id` = ?", requestData.AssId).First(&assCont).Error
	if errAssErr != nil {
		response.Result(104, errAssErr, "没有获取到数据！", c)
		return
	}
	var departmentStr string
	if len(requestData.DepartmentId) > 0 {
		departmentStr = strings.Join(requestData.DepartmentId, ",")
	} else {
		departmentStr = assCont.Departmentmap
	}
	// detailedTargetInfo, dtiIsTrue := commonus.JudgeDetailsCopy(strconv.FormatInt(assCont.TargetId, 10), requestData.DetailedTargetName, requestData.DetailedTargetContent, requestData.Id, requestData.Score, requestData.Unit, assCont.SunTargetId, requestData.AddOrReduce)

	//判断考核细则是否存在(新规则)
	/*
	   参数说明
	   @ascription				归属指标栏目
	   @title					指标细则
	   @explain				指标说明'
	   @explainId				指标明细ID
	   @ReferenceScore			分数
	   @CompanyCont				单位
	   @sunTargetId			子栏目
	*/
	// func JudgeDetailsCopy(ascription, title, explain, explainId, ReferenceScore, CompanyCont string, sunTargetId int64, addReduce int) (content assessmentmodel.DetailedTarget, isTrue bool)

	var detailedTarget QualEvalSunList

	detailedTarget.DetailedTarget = requestData.Id             //`json:"id"`             //考核细则
	detailedTarget.Title = requestData.DetailedTargetName      //`json:"title"`          //指标说明
	detailedTarget.Content = requestData.DetailedTargetContent //`json:"content"`        //指标说明
	detailedTarget.Unit = requestData.Unit                     //`json:"unit"`           //单位
	detailedTarget.ReferenceScore = requestData.Score          //`json:"referencescore"` //标准分值
	// detailedTarget.Cycles = fmt.Sprintf("%v", requestData.Cycles) //`json:"cycle"`          //1：班；2：天；3：周；4：月；5：季度；6：年
	detailedTarget.Cycles = requestData.Cycles           //`json:"cycle"`          //1：班；2：天；3：周；4：月；5：季度；6：年
	detailedTarget.CycleAttres = requestData.CycleAttres // `json:"cycleattr"`      //辅助计数
	// detailedTarget.DepartmentId   =requestData.   `json:"parentid"`       //执行考核部门ID
	detailedTarget.Operator = requestData.Operator //`json:"userlist"`       //考核执行人
	// detailedTarget.MinScore       =requestData.    //`json:"minscore"`       //最小分*100保存
	// detailedTarget.MaxScore       =requestData.    //`json:"maxscore"`       //最大分*100保存
	detailedTarget.AddOrReduce = requestData.AddOrReduce //`json:"addorreduce"`    //1：减少；2：增加
	detailedTarget.CensorType = requestData.CensorType   //`json:"censortype"`     //检查方式（1：现场检查；2：资料检查；3：事件触发）
	detailedTarget.CensorCont = requestData.CensorCont   //`json:"censorcont"`     //检查依据
	detailedTarget.CensorRate = requestData.CensorRate   //`json:"censorrate"`     //检查频次

	// Id                    string   `json:"id"`
	// Class                 int      `json:"class"` //1、新增；2、修改
	// SunTargerId           string   `json:"suntargetid"`
	// SunTargetName         string   `json:"suntargetname"`
	// DetailedTargetName    string   `json:"detailedtargetname"`
	// DetailedTargetContent string   `json:"detailedtargetcontent"`
	// Operator              []string `json:"operator"`

	// Cycles      int    `json:"cycle"`      //1：班；2：天；3：周；4：月；5：季度；6：年
	// CycleAttres int    `json:"cycleattr"`  //辅助计数
	// CensorType  int    `json:"censortype"` //检查方式（1：现场检查；2：资料检查；3：事件触发）
	// CensorCont  string `json:"censorcont"` //检查依据
	// CensorRate  int    `json:"censorrate"` //检查频次

	// AssId       string `json:"assid"`
	// Unit        string `json:"unit"`        //单位
	// Score       string `json:"score"`       //分值
	// AddOrReduce int    `json:"addorreduce"` //1：减少；2：增加

	detailedTargetInfo, dtiIsTrue := JudgeDetailsCopyEs(strconv.FormatInt(assCont.TargetId, 10), departmentStr, assCont.SunTargetId, detailedTarget)
	if dtiIsTrue != true {
		response.Result(105, errAssErr, "指标明细编辑失败！", c)
		return
	}

	WriteBackTargetDepartment(strconv.FormatInt(assCont.TargetId, 10), strings.Split(departmentStr, ","))
	WriteBackSunTargetDepartment(assCont.Group, assCont.Dimension, assCont.TargetId, strconv.FormatInt(assCont.SunTargetId, 10), strings.Split(departmentStr, ","))

	//设定定性考核指标新增键对关系
	var addOpentDetial DutyAssEssTarget
	addOpentDetial.Id = detailedTargetInfo.Id
	addOpentDetial.Operator = requestData.Operator
	//拆解指标详情
	var detailedList []DutyAssEssTarget
	detailedListErr := json.Unmarshal([]byte(assCont.Content), &detailedList)
	// ssss := commonus.MapOut()
	// ssss["Content"] = assCont.Content
	// ssss["detailedList"] = detailedList
	// ssss["detailedListErr"] = detailedListErr
	// response.Result(105, ssss, "指标明细编辑失败！", c)
	// return
	if detailedListErr != nil {
		var eiteOpentDetiallist []DutyAssEssTarget
		isAdd := false
		for _, dil_v := range detailedList {
			var detailedEiteCont DutyAssEssTarget
			if dil_v.Id == detailedTargetInfo.Id {
				detailedEiteCont.Id = dil_v.Id
				detailedEiteCont.Operator = requestData.Operator
				isAdd = true
			} else {
				detailedEiteCont.Id = dil_v.Id
				detailedEiteCont.Operator = dil_v.Operator
			}
			eiteOpentDetiallist = append(eiteOpentDetiallist, detailedEiteCont)
		}
		if isAdd == false {
			eiteOpentDetiallist = append(eiteOpentDetiallist, addOpentDetial)
		}
		eiteContIng := commonus.MapOut()
		eiteContIng["time"] = time.Now().Unix()
		jsonStr, jsonMErr := json.Marshal(eiteOpentDetiallist)
		if jsonMErr == nil {
			eiteContIng["content"] = string(jsonStr)
		}
		eiteErring := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.Assesstarget{}).Where("`at_id` = ?", assCont.Id).Updates(&eiteContIng).Error
		if eiteErring == nil {
			// WriteBackTargetDepartment(strconv.FormatInt(assCont.TargetId, 10), strings.Split(departmentStr, ","))
			// WriteBackSunTargetDepartment(strconv.FormatInt(assCont.SunTargetId, 10), strings.Split(departmentStr, ","))
			response.Result(0, err, "处理成功！2", c)
		} else {
			response.Result(107, err, "请添加测评详情！", c)
		}
	} else {
		// var eiteOpentDetiallist []DutyAssEssTarget
		var eiteOpentDetiallist []DutyAssEssTarget
		isAdd := false
		for _, dil_v := range detailedList {
			var detailedEiteCont DutyAssEssTarget
			if dil_v.Id == detailedTargetInfo.Id {
				detailedEiteCont.Id = dil_v.Id
				detailedEiteCont.Operator = requestData.Operator
				isAdd = true
			} else {
				detailedEiteCont.Id = dil_v.Id
				detailedEiteCont.Operator = dil_v.Operator
			}
			eiteOpentDetiallist = append(eiteOpentDetiallist, detailedEiteCont)
		}
		if isAdd == false {
			eiteOpentDetiallist = append(eiteOpentDetiallist, addOpentDetial)
		}
		eiteCont := commonus.MapOut()
		eiteCont["time"] = time.Now().Unix()
		jsonStr, jsonMErr := json.Marshal(eiteOpentDetiallist)
		if jsonMErr == nil {
			eiteCont["content"] = string(jsonStr)
		}
		eiteErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.Assesstarget{}).Where("`at_id` = ?", assCont.Id).Updates(&eiteCont).Error
		if eiteErr == nil {
			// WriteBackTargetDepartment(strconv.FormatInt(assCont.TargetId, 10), strings.Split(departmentStr, ","))
			// WriteBackSunTargetDepartment(strconv.FormatInt(assCont.SunTargetId, 10), strings.Split(departmentStr, ","))
			response.Result(0, err, "处理成功！1", c)
		} else {
			response.Result(107, err, "请添加测评详情！", c)
		}
	}
}

// 删除指标
func (d *DutyAssessApi) NewDelDetailedTarget(c *gin.Context) {
	var requestData GetDeitalTarCont
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if requestData.Id == "" {
		response.Result(102, requestData, "参数错误！请重新提交！", c)
		return
	}
	if requestData.AssId == "" {
		response.Result(103, requestData, "参数错误！请重新提交！", c)
		return
	}
	detailId, _ := strconv.ParseInt(requestData.Id, 10, 64)
	var assCont assessmentmodel.Assesstarget
	errAssErr := global.GVA_DB_Performanceappraisal.Where("`at_id` = ?", requestData.AssId).First(&assCont).Error
	if errAssErr != nil {
		response.Result(105, errAssErr, "没有获取到数据！", c)
		return
	}
	eiteCont := commonus.MapOut()
	eiteCont["dt_time"] = time.Now().Unix()
	eiteCont["dt_state"] = 3
	global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DetailedTarget{}).Where("`dt_id` = ?", requestData.Id).Updates(&eiteCont)
	var detailedList []DutyAssEssTarget
	detailedListErr := json.Unmarshal([]byte(assCont.Content), &detailedList)
	if detailedListErr == nil {
		var eiteAssContList []DutyAssEssTarget
		for _, v := range detailedList {
			if v.Id != detailId {
				eiteAssContList = append(eiteAssContList, v)
			}
		}
		if len(eiteAssContList) > 0 {
			eiteAssCont := commonus.MapOut()
			eiteAssCont["time"] = time.Now().Unix()
			jsonStr, jsonMErr := json.Marshal(eiteAssContList)
			if jsonMErr == nil {
				eiteAssCont["content"] = string(jsonStr)
			}
			global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.Assesstarget{}).Where("`at_id` = ?", requestData.AssId).Updates(&eiteAssCont)
		}
	}
	response.Result(0, requestData, "修改完成！", c)
}

// 删除子栏目
func (d *DutyAssessApi) NewDelSunTarget(c *gin.Context) {
	var requestData GetDeitalTarCont
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if requestData.Id == "" {
		response.Result(102, requestData, "参数错误！请重新提交！", c)
		return
	}
	if requestData.AssId == "" {
		response.Result(103, requestData, "参数错误！请重新提交！", c)
		return
	}
	var assCont []assessmentmodel.Assesstarget
	errAssErr := global.GVA_DB_Performanceappraisal.Where("`targetid` = ? AND `suntargetid` = ?", requestData.AssId, requestData.Id).Find(&assCont).Error
	if errAssErr != nil {
		response.Result(105, errAssErr, "没有获取到数据！", c)
		return
	}
	var delDetaId []int64
	var delAssId []int64
	for _, v := range assCont {
		var detailedList []DutyAssEssTarget
		detailedListErr := json.Unmarshal([]byte(v.Content), &detailedList)
		if detailedListErr == nil {
			for _, d_v := range detailedList {
				delDetaId = append(delDetaId, d_v.Id)
			}
		}
		delAssId = append(delAssId, v.Id)
	}
	if len(delDetaId) > 0 {
		eiteCont := commonus.MapOut()
		eiteCont["dt_time"] = time.Now().Unix()
		eiteCont["dt_state"] = 3
		global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DetailedTarget{}).Where("`dt_id` IN ?", delDetaId).Updates(&eiteCont)
	}
	if len(delAssId) > 0 {
		global.GVA_DB_Performanceappraisal.Where("`at_id` IN ?", delAssId).Delete(&assessmentmodel.Assesstarget{})
	}
	response.Result(0, requestData, "修改完成！", c)
}

// 新的部门考核指标获取列表
func (d *DutyAssessApi) NewGerDerpatTarList(c *gin.Context) {
	var requestData rationSelect
	c.ShouldBindJSON(&requestData)
	//获取维度列表
	var dutyClassAry []assessmentmodel.DutyClass
	gromDb := global.GVA_DB_Performanceappraisal
	gromDb = gromDb.Where("`state` = 1")
	classErr := gromDb.Order("sort ASC").Find(&dutyClassAry).Error

	if classErr != nil {
		response.Result(0, classErr, "未获取到数据", c)
		return
	}
	var departAryList []DepartTargetListTop
	for _, v := range dutyClassAry {
		conList := GetTargetGroup(requestData.Group, strconv.FormatInt(v.Id, 10), requestData.DepartmentId)
		var departcontInfo DepartTargetListTop
		departcontInfo.Id = strconv.FormatInt(v.Id, 10)
		departcontInfo.Name = v.Title
		departcontInfo.Child = conList
		if len(conList) > 0 {
			departAryList = append(departAryList, departcontInfo)
		}

	}
	response.Result(0, departAryList, "数据获取成功！", c)
}

//获取指标组合
/*
@group					集团
@dimensionId			维度
@departID				部门
*/
func GetTargetGroup(group, dimensionId, departID string) (contAry []DepartTargetList) {
	var rationId []int64
	gormDb := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.EvaluationTarget{}).Select("et_id").Where("`et_type` = 2 AND `et_state` = 1 AND `et_dimension` = ?", dimensionId)
	if departID != "" {
		// sqlOrStr := fmt.Sprintf("FIND_IN_SET(%v,`et_relevant_departments`)", departID)
		// sqlOrStr = fmt.Sprintf("`et_share` = 1 OR (`et_share` = 2 AND (%v))", sqlOrStr)

		sqlOrStr := fmt.Sprintf("`et_relevant_departments` = '' OR FIND_IN_SET(%v,`et_relevant_departments`)", departID)
		gormDb = gormDb.Where(sqlOrStr)
	}
	listErr := gormDb.Find(&rationId).Error
	if listErr != nil {
		// return
	}

	var qualit []int64
	errAssErr := global.GVA_DB_Performanceappraisal.Select("targetid").Model(&assessmentmodel.Assesstarget{}).Where("`state` = 1 AND `group` = ? AND `dimension` = ? AND FIND_IN_SET(?,`departmentmap`)", group, dimensionId, departID).Find(&qualit).Error
	if errAssErr != nil {
		// return
	}

	mergeMap := append(rationId, qualit...) //合并两个数组
	var finalResultId []int64               //最终结果
	for _, m_v := range mergeMap {
		if commonus.IsItTrue(m_v, finalResultId) != true {
			finalResultId = append(finalResultId, m_v)
		}
	}
	//获取指标列表
	var evaluatCont []assessmentmodel.EvaluationTarget
	aryErr := global.GVA_DB_Performanceappraisal.Where("`et_state` = 1 AND `et_id` IN ?", finalResultId).Find(&evaluatCont).Error
	if aryErr != nil {
		return
	}
	for _, e_v := range evaluatCont {
		var cont DepartTargetList
		cont.Id = strconv.FormatInt(e_v.Id, 10)
		cont.Name = e_v.Title
		cont.Content = ""
		cont.Unit = e_v.Uniteing
		cont.State = e_v.State
		cont.ReferenceScore = commonus.GetWeight(group, dimensionId, departID, strconv.FormatInt(e_v.Id, 10), int64(e_v.Type))
		cont.IsTrue = 2
		contAry = append(contAry, cont)
	}
	return
}

// 部门考核添加。NEW
func (d *DutyAssessApi) NewAddDepartDuty(c *gin.Context) {
	var requestData AddDutyNewContGroup
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if requestData.Group == "" {
		response.Result(102, err, "数据获取失败！", c)
		return
	}
	groupId, groupErr := strconv.ParseInt(requestData.Group, 10, 64) //集团ID
	if groupErr != nil {
		groupId = 0
	}
	if requestData.DepartmentId == "" {
		response.Result(103, err, "数据获取失败！", c)
		return
	}
	departId, departErr := strconv.ParseInt(requestData.DepartmentId, 10, 64) //部门ID
	if departErr != nil {
		departId = 0
	}
	if len(requestData.Child) < 0 {
		response.Result(104, err, "没有要添加的数据", c)
		return
	}
	var eiteIdAry []int64                                   //被修改的考核条目
	var saveDataAry []assessmentmodel.QualitativeEvaluation //新增条目
	for _, v := range requestData.Child {                   //维度

		commonus.AddWeight(requestData.Group, v.Id, requestData.DepartmentId, "", int64(v.ZhiFraction), 1)

		for _, tar_v := range v.Child { //指标

			if tar_v.Status == 1 {

				//使用
				targetId, targetErr := strconv.ParseInt(tar_v.Id, 10, 64) //指标ID转换
				if targetErr == nil {
					fmt.Printf("Targer---1---->%v\n", targetId)
					evalTarCont, evalTarContErr := commonus.GetTargetInfo(targetId) //获取指标内容
					if evalTarContErr == true {
						fmt.Printf("Targer---2---->%v\n", targetId)
						//判断是定量还是定性
						if evalTarCont.Type == 2 {
							commonus.AddWeight(requestData.Group, v.Id, requestData.DepartmentId, tar_v.Id, tar_v.ReferenceScore, 2)
							//定量指标操作
							var saveData assessmentmodel.QualitativeEvaluation
							var qeId []int64                          //需要编辑的ID
							eiteQualEvalSaveData := commonus.MapOut() //需要编辑的内容

							gormQualEval := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Select("qe_id").Where("`qe_group` = ? AND `qe_dimension` = ? AND `qe_target` = ? AND `qe_type` = ? AND `qe_accept_evaluation` = ?", groupId, v.Id, targetId, evalTarCont.Type, departId)
							judgeContErr := gormQualEval.Find(&qeId).Error
							fmt.Printf("Targer---4---->%v---->%v\n", qeId, judgeContErr)
							//维度ID
							dimId, dimErr := strconv.ParseInt(v.Id, 10, 64)
							if dimErr == nil {
								saveData.Dimension = dimId
							}
							saveData.Target = targetId                     //指标
							saveData.Type = evalTarCont.Type               //类型
							saveData.Unit = evalTarCont.Uniteing           //单位
							saveData.ReferenceScore = tar_v.ReferenceScore //分值
							// saveData.ReferenceScore = v_s.ReferenceScore //分值
							saveData.State = 1 //状态
							saveData.Addtime = time.Now().Unix()
							saveData.Eitetime = time.Now().Unix()
							saveData.Group = groupId                       //集团
							saveData.Cycles = evalTarCont.Cycles           //单位
							saveData.CycleAttres = evalTarCont.CycleAttres //辅助计数
							saveData.AcceptEvaluation = departId           //接受考核部门
							saveData.Content = tar_v.Content               //描述
							saveData.Operator = evalTarCont.Report         //执行考核人

							var departAry []string
							userKeyAry := strings.Split(evalTarCont.Report, ",")
							if len(userKeyAry) > 0 {
								for _, u_v := range userKeyAry {
									usCont, usErr := commonus.GetWorkUser(u_v)
									if usErr == true {
										departIdStr := strconv.FormatInt(usCont.MainDeparment, 10)
										if commonus.IsItTrueString(departIdStr, departAry) == false {
											departAry = append(departAry, departIdStr)
										}

									}
								}
							}
							saveData.DepartmentId = strings.Join(departAry, ",")
							eiteQualEvalSaveData["qe_department_id"] = strings.Join(departAry, ",")
							if judgeContErr == nil {
								if len(qeId) > 0 {
									eiteQualEvalSaveData["qe_dimension"] = dimId
									eiteQualEvalSaveData["qe_target"] = targetId
									eiteQualEvalSaveData["qe_type"] = evalTarCont.Type
									eiteQualEvalSaveData["qe_unit"] = evalTarCont.Uniteing
									eiteQualEvalSaveData["qe_reference_score"] = tar_v.ReferenceScore
									eiteQualEvalSaveData["qe_state"] = 1
									eiteQualEvalSaveData["qe_eitetime"] = time.Now().Unix()
									eiteQualEvalSaveData["qe_group"] = groupId
									eiteQualEvalSaveData["qe_cycle"] = evalTarCont.Cycles
									eiteQualEvalSaveData["qe_cycleattr"] = evalTarCont.CycleAttres
									eiteQualEvalSaveData["qe_accept_evaluation"] = departId
									eiteQualEvalSaveData["qe_operator"] = evalTarCont.Report
									eiteQualEvalSaveData["qe_content"] = tar_v.Content
									eiteIdAry = append(eiteIdAry, dimId)
									//修改已经存在的内容
									global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Where("`qe_id` IN ?", qeId).Updates(eiteQualEvalSaveData)
								} else {
									saveDataAry = append(saveDataAry, saveData)
								}
							} else {
								//要新增的条目
								saveDataAry = append(saveDataAry, saveData)
							}

						} else {
							commonus.AddWeight(requestData.Group, v.Id, requestData.DepartmentId, tar_v.Id, tar_v.ReferenceScore, 1)
							//定性指标操作
							//获取部门关联考核指标项目
							var assessTarList []assessmentmodel.Assesstarget
							judgeARTErr := global.GVA_DB_Performanceappraisal.Where("`group` = ? AND `dimension` = ? AND `targetid` = ? AND FIND_IN_SET(?,`departmentmap`)", groupId, v.Id, tar_v.Id, departId).Find(&assessTarList).Error

							fmt.Printf("Targer---5---->%v---->%v---->%v\n", targetId, v.Id, tar_v.Id)

							if judgeARTErr == nil {
								var guoDu []AddPartMentGuodu
								for _, ass_v := range assessTarList {
									judgeTure := commonus.JudegSunTarToDepart(ass_v.SunTargetId, departId)
									if judgeTure == true {
										var guoDuCont AddPartMentGuodu
										guoDuCont.Group = groupId
										guoDuCont.DeaprtId = departId
										guoDuCont.Dimension = ass_v.Dimension
										guoDuCont.TargetId = ass_v.TargetId
										guoDuCont.SunTargetId = ass_v.SunTargetId
										if ass_v.Content != "" {
											//拆解指标详情
											var detailedList []DutyAssEssTarget
											detailedListErr := json.Unmarshal([]byte(ass_v.Content), &detailedList)
											if detailedListErr == nil {
												for _, det_v := range detailedList {
													guoDuCont.DetailedTarget = det_v.Id
													guoDuCont.Operator = det_v.Operator
													guoDu = append(guoDu, guoDuCont)
													fmt.Printf("Targer---6---->%v---->%v---->%v\n", ass_v.TargetId, ass_v.SunTargetId, det_v.Id)
												}
											} else {
												guoDu = append(guoDu, guoDuCont)
											}
										} else {
											guoDu = append(guoDu, guoDuCont)
										}
									}

								}
								//判断关联项目
								if len(guoDu) > 0 {
									guoDuJsonm, _ := json.Marshal(guoDu)
									fmt.Printf("Targer---7---->%v---->%v\n", string(guoDuJsonm), guoDu)
									for _, ae_v := range guoDu {
										//判断该项是否已经存在
										var eiteGetId int64
										gormQualEval := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Select("qe_id").Where("`qe_group` = ? AND `qe_accept_evaluation` = ? AND `qe_dimension` = ? AND `qe_target` = ? AND `qe_target_sun` = ? AND `qe_detailed_target` = ? AND `qe_type` = 1", ae_v.Group, ae_v.DeaprtId, ae_v.Dimension, ae_v.TargetId, ae_v.SunTargetId, ae_v.DetailedTarget)
										judgeContErr := gormQualEval.First(&eiteGetId).Error
										fmt.Printf("Targer---8---->%v---->%v---->%v---->%v---->%v---->%v---->%v\n", eiteGetId, ae_v.Group, ae_v.DeaprtId, ae_v.Dimension, ae_v.TargetId, ae_v.SunTargetId, ae_v.DetailedTarget)
										if judgeContErr == nil {
											eiteQualEvalSaveData := commonus.MapOut() //需要编辑的内容
											eiteQualEvalSaveData["qe_dimension"] = ae_v.Dimension
											eiteQualEvalSaveData["qe_target"] = ae_v.TargetId
											eiteQualEvalSaveData["qe_type"] = 1

											getEvalTarCont, _ := commonus.GetDetailedTargetInfo(ae_v.DetailedTarget) //获取指标内容

											eiteQualEvalSaveData["qe_unit"] = getEvalTarCont.Company
											eiteQualEvalSaveData["qe_reference_score"] = 0

											eiteQualEvalSaveData["qe_min_score"] = getEvalTarCont.MinScore
											eiteQualEvalSaveData["qe_max_score"] = getEvalTarCont.MaxScore

											eiteQualEvalSaveData["qe_state"] = 1
											eiteQualEvalSaveData["qe_eitetime"] = time.Now().Unix()
											eiteQualEvalSaveData["qe_group"] = ae_v.Group
											evaDingXinglTarCont, _ := commonus.GetTargetInfo(ae_v.TargetId) //获取指标内容
											eiteQualEvalSaveData["qe_cycle"] = evaDingXinglTarCont.Cycles
											eiteQualEvalSaveData["qe_cycleattr"] = evaDingXinglTarCont.CycleAttres
											eiteQualEvalSaveData["qe_accept_evaluation"] = ae_v.DeaprtId
											eiteQualEvalSaveData["qe_operator"] = strings.Join(ae_v.Operator, ",")
											eiteQualEvalSaveData["qe_content"] = getEvalTarCont.Content
											//获取执行人部门
											var departAry []string
											if len(ae_v.Operator) > 0 {
												for _, u_v := range ae_v.Operator {
													usCont, usErr := commonus.GetWorkUser(u_v)
													if usErr == true {
														departIdStr := strconv.FormatInt(usCont.MainDeparment, 10)
														if commonus.IsItTrueString(departIdStr, departAry) == false {
															departAry = append(departAry, departIdStr)
														}

													}
												}
											}
											eiteQualEvalSaveData["qe_department_id"] = strings.Join(departAry, ",")
											eiteIdAry = append(eiteIdAry, eiteGetId)
											//修改已经存在的内容
											global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Where("`qe_id` = ?", eiteGetId).Updates(eiteQualEvalSaveData)
										} else {
											//写入新的定性考核细则
											var saveData assessmentmodel.QualitativeEvaluation
											saveData.Dimension = ae_v.Dimension
											saveData.Target = ae_v.TargetId //指标
											saveData.Type = 1               //类型

											saveData.TargetSun = ae_v.SunTargetId

											getEvalTarCont, _ := commonus.GetDetailedTargetInfo(ae_v.DetailedTarget) //获取指标内容

											saveData.DetailedTarget = ae_v.DetailedTarget

											saveData.Unit = getEvalTarCont.Company //单位
											saveData.ReferenceScore = 0            //分值

											saveData.MinScore = getEvalTarCont.MinScore
											saveData.MaxScore = getEvalTarCont.MaxScore
											// saveData.ReferenceScore = v_s.ReferenceScore //分值
											saveData.State = 1 //状态
											saveData.Addtime = time.Now().Unix()
											saveData.Eitetime = time.Now().Unix()
											saveData.Group = ae_v.Group //集团

											evaDingXinglTarCont, _ := commonus.GetTargetInfo(ae_v.TargetId) //获取指标内容
											saveData.Cycles = evaDingXinglTarCont.Cycles                    //1：班；2：天；3：周；4：月；5：季度；6：年
											saveData.CycleAttres = evaDingXinglTarCont.CycleAttres          //辅助计数

											saveData.AcceptEvaluation = ae_v.DeaprtId            //接受考核部门
											saveData.Content = getEvalTarCont.Content            //描述
											saveData.Operator = strings.Join(ae_v.Operator, ",") //执行考核人
											//获取执行人部门
											var departAry []string
											if len(ae_v.Operator) > 0 {
												for _, u_v := range ae_v.Operator {
													usCont, usErr := commonus.GetWorkUser(u_v)
													if usErr == true {
														departIdStr := strconv.FormatInt(usCont.MainDeparment, 10)
														if commonus.IsItTrueString(departIdStr, departAry) == false {
															departAry = append(departAry, departIdStr)
														}

													}
												}
											}
											saveData.DepartmentId = strings.Join(departAry, ",")

											saveDataJsonm, _ := json.Marshal(saveData)
											fmt.Printf("Targer---9---->%v---->%v\n", string(saveDataJsonm), saveData)

											//要新增的条目
											saveDataAry = append(saveDataAry, saveData)
										}
									}
								}

							}
						}
					}
				} else {
					fmt.Printf("Targer---3---->%v\n", targetId)
				}
			} else {
				//禁用
				qualEvalSave := commonus.MapOut()
				qualEvalSave["qe_state"] = 2
				qualEvalSave["qe_eitetime"] = time.Now().Unix()
				global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Where("`qe_group` = ? AND `qe_accept_evaluation` = ? AND `qe_dimension` = ? AND `qe_target` = ?", groupId, departId, v.Id, tar_v.Id).Updates(qualEvalSave)
			}
		}
	}
	if len(saveDataAry) <= 0 && len(eiteIdAry) <= 0 {
		response.Result(105, saveDataAry, "没有要添加的数据", c)
		return
	}
	if len(saveDataAry) > 0 {
		addErr := global.GVA_DB_Performanceappraisal.Create(&saveDataAry).Error
		if addErr != nil {
			response.Result(106, len(saveDataAry), "数据添加失败", c)
			return
		}
	}
	response.Result(0, saveDataAry, "数据添加成功", c)
}

// 获取考核方法要修改的数据
func (d *DutyAssessApi) GetEiteSunTarterInfo(c *gin.Context) {
	var requestData LookTargetContListSun
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if requestData.Group == "" {
		response.Result(102, err, "参数错误！无法获取数据", c)
		return
	}
	if requestData.Dimension == "" {
		response.Result(103, err, "参数错误！无法获取数据", c)
		return
	}
	if requestData.TargetId == "" {
		response.Result(104, err, "参数错误！无法获取数据", c)
		return
	}
	// var assessInfoList assessmentmodel.Assesstarget
	var userStr string
	assErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.Assesstarget{}).Select("content").Where("`group` = ? AND `dimension` = ? AND `targetid` = ? AND `suntargetid` = ?", requestData.Group, requestData.Dimension, requestData.TargetId, requestData.SunTargetId).First(&userStr).Error
	if assErr != nil {
		response.Result(105, assErr, "没有获取到数据！", c)
		return
	}
	var userMap []DutyAssEssTarget

	jsonErr := json.Unmarshal([]byte(userStr), &userMap)
	if jsonErr != nil {
		response.Result(104, jsonErr, "没有数据", c)
		return
	}
	var userAry []string
	for _, v := range userMap {
		for _, o_v := range v.Operator {
			if commonus.IsItTrueString(o_v, userAry) == false {
				userAry = append(userAry, o_v)
			}
		}
	}
	response.Result(0, userAry, "没有数据", c)
}

// 修改考核方法指标审核人
func (d *DutyAssessApi) EiteSunTarterInfoUser(c *gin.Context) {
	var requestData EiteTargetContListSun
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if requestData.Group == "" {
		response.Result(102, err, "参数错误！无法获取数据", c)
		return
	}
	if requestData.Dimension == "" {
		response.Result(103, err, "参数错误！无法获取数据", c)
		return
	}
	if requestData.TargetId == "" {
		response.Result(104, err, "参数错误！无法获取数据", c)
		return
	}
	// if
}