gin-vue-admin/gin_server_admin/api/admin/dutyassess/dutyhandle.go

package dutyassess

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

	"github.com/flipped-aurora/gin-vue-admin/server/commonus"
	"github.com/flipped-aurora/gin-vue-admin/server/global"
	"github.com/flipped-aurora/gin-vue-admin/server/model/assessmentmodel"
	"github.com/flipped-aurora/gin-vue-admin/server/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 QualEvalArrt
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if requestData.Id == "" {
		response.Result(102, err, "参数错误！请重新提交！", c)
		return
	}
	if requestData.Name == "" {
		response.Result(103, err, "参数错误！请重新提交！", c)
		return
	}
	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
	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
	}
	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) AddDutyRelation(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
	}

	//获取子目标情况
	sunTargetCont, sunTargetErr := commonus.JudgeColumn(requestData.Target, requestData.TargetSun, requestData.TargetSunTitle)
	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)
		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 {
		for _, t_v := range targetContList {
			if f_v != t_v.Id {
				var targetContInfos DutyAssEssTarget
				targetContInfos.Id = f_v
				targetContList = append(targetContList, targetContInfos)
			}
		}
	}
	//判断该集团指标子栏目是否存在
	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
	if judgeARTErr == nil {
		if arTaegetInfo.Content != "" {
			var tarList []DutyAssEssTarget
			jsonErr := json.Unmarshal([]byte(arTaegetInfo.Content), &tarList)
			if jsonErr == nil {
				for _, tl_v := range tarList {
					for _, tcl_v := range targetContList {
						if tl_v.Id != tcl_v.Id {
							targetContList = append(targetContList, tl_v)
						}
					}
				}
			}
		}
		eiteCont := commonus.MapOut()
		eiteCont["departmentmap"] = strings.Join(requestData.AcceptDepartmentId, ",")
		eiteCont["time"] = time.Now().Unix()
		jsonStr, jsonMErr := json.Marshal(targetContList)
		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, "处理成功！", c)
		} else {
			response.Result(107, err, "请添加测评详情！", c)
		}
	} else {
		arTaegetInfo.Group = groupInt
		arTaegetInfo.Departmentmap = strings.Join(requestData.AcceptDepartmentId, ",")
		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, "处理成功！", c)
		} else {
			response.Result(107, err, "请添加测评详情！", c)
		}
	}
}

//获取定性考核指标关系指定列表
func (d *DutyAssessApi) GetDutyRelationList(c *gin.Context) {
	var list []assessmentmodel.Assesstarget
	err := global.GVA_DB_Performanceappraisal.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.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, ","))

		shenPiRen := strings.Split(tarCont.Report, ",")
		outCont.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})
			// GetWorkUser
			if usErr == true {
				var userCont QualEvalArrt
				userCont.Id = v
				userCont.Name = usCont.Name
				outCont.UserListAry = append(outCont.UserListAry, userCont)
			}
		}

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

//查看定性考核项目详情
func (d *DutyAssessApi) LookDutyTargetInfo(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(102, err, "参数错误！无法获取数据", c)
		return
	}
	if requestData.TargetId == "" {
		response.Result(102, err, "参数错误！无法获取数据", c)
		return
	}
	var assessInfoList []assessmentmodel.Assesstarget
	assErr := global.GVA_DB_Performanceappraisal.Where("`group` = ? AND `dimension` = ? AND `targetid` = ?", requestData.Group, requestData.Dimension, requestData.TargetId).Find(&assessInfoList).Error
	if assErr != nil {
		response.Result(102, assErr, "没有获取到数据！", c)
		return
	}
	var uotContAry []TargetContOutCont
	for _, v := range assessInfoList {
		var uotCont TargetContOutCont
		uotCont.Type = 1
		//集团
		uotCont.Group = requestData.Group
		_, groupCont := commonus.GetGroupCont(v.Group)
		uotCont.GroupNAme = groupCont.Name
		//执行部门
		uotCont.DepartmentId = v.Departmentmap
		_, 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.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)
		uotCont.TargetSunName = info.Title
		//拆解指标详情
		// detailedList := json.Unmarshal()

		uotContAry = append(uotContAry, uotCont)
	}
}