gin_server_admin/api/v1/assessment/qualitative_evaluation.go

package assessment

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

	"gin_server_admin/api/v1/archiveapi"
	"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 *DutyHandle) AddQualEval(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(102, err, "请选择接受考核的部门！", c)
		return
	}
	// if requestData.Dimension == "" {
	// 	response.Result(102, err, "请选择考核维度", c)
	// 	return
	// }
	if requestData.Target == "" {
		response.Result(102, err, "请选择考核指标", c)
		return
	}
	if requestData.TargetSunTitle == "" {
		response.Result(102, err, "请输入栏目名称！", c)
		return
	}
	if len(requestData.EvaluationList) <= 0 {
		response.Result(102, err, "请添加测评详情！", c)
		return
	}
	var synergeticProcess dataLockStatistics
	for _, deparmentId := range requestData.AcceptDepartmentId {

		syncProcess.Add(1)
		// go synergeticProcess.addQualEvalList(deparmentId, requestData)
		go synergeticProcess.AddCardAssEss(deparmentId, requestData)
	}
	syncProcess.Wait()
	returData := commonus.MapOut()
	readDataMap, readBaoJinf := synergeticProcess.readMyDayData()

	returData["istrue"] = readDataMap
	returData["isfalse"] = readBaoJinf
	if len(readBaoJinf) > 0 && len(readDataMap) == 0 {
		response.Result(112, returData, "有未处理失败的数据！请检查", c)
	} else if len(readBaoJinf) > 0 && len(readDataMap) > 0 {
		response.Result(1, returData, "有部门数据处理失败！请针对性输入！", c)
	} else {
		response.Result(0, returData, "数据处理完成！", c)
	}
}

func (d *dataLockStatistics) addQualEvalList(departmentId string, addData AddQualEval) {
	d.mutext.Lock()
	defer d.mutext.Unlock()
	var saveDataAry []assessmentmodel.QualitativeEvaluation
	for _, v := range addData.EvaluationList {
		var saveData assessmentmodel.QualitativeEvaluation
		juadgeMap := commonus.MapOut()
		juadgeInsetErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Select("qe_id").Where("`qe_accept_evaluation` = ? AND `qe_dimension` = ? AND `qe_target` = ? AND `qe_target_sun` = ? AND `qe_detailed_target` = ?", departmentId, addData.Dimension, addData.Target, addData.TargetSun, v.DetailedTarget).First(&juadgeMap).Error
		if juadgeInsetErr != nil {
			groupInt, groupIntErr := strconv.ParseInt(addData.Group, 10, 64)
			if groupIntErr == nil {
				saveData.Group = groupInt
			}
			saveData.Type = addData.Type

			// departidInt, departinIntErr := strconv.ParseInt(v.DepartmentId, 10, 64)
			// if departinIntErr == nil {
			// 	saveData.DepartmentId = departidInt
			// }

			dimensionInt, departinIntErr := strconv.ParseInt(addData.Dimension, 10, 64)
			if departinIntErr == nil {
				saveData.Dimension = dimensionInt
			}

			targetInt, targetIntErr := strconv.ParseInt(addData.Target, 10, 64)
			if targetIntErr == nil {
				saveData.Target = targetInt
			}

			targetSunInt, targetSunIntErr := strconv.ParseInt(addData.TargetSun, 10, 64)
			if targetSunIntErr == nil {
				saveData.TargetSun = targetSunInt
			}

			detailedTargetInt, detailedTargetIntErr := strconv.ParseInt(v.DetailedTarget, 10, 64)
			if detailedTargetIntErr == nil {
				saveData.DetailedTarget = detailedTargetInt
			}

			saveData.Unit = v.Unit
			saveData.ReferenceScore = v.ReferenceScore
			saveData.Cycles = v.Cycles
			saveData.CycleAttres = v.CycleAttres

			saveData.State = 1
			saveData.Addtime = time.Now().Unix()
			saveData.Eitetime = time.Now().Unix()

			departmentIdInt, departmentIdIntErr := strconv.ParseInt(departmentId, 10, 64)
			if departmentIdIntErr == nil {
				saveData.AcceptEvaluation = departmentIdInt
			}
			saveData.Operator = strings.Join(v.Operator, ",")
			saveData.DepartmentId = strings.Join(GetDepartmentByUserBast(v.Operator), ",")
			// operatorInt, operatorIntErr := strconv.ParseInt(v.Operator, 10, 64)
			// if operatorIntErr == nil {
			// 	saveData.Operator = strings.Join(v.Operator,",")
			// }
			// saveData.AcceptEvaluation = departmentIdInt

			saveDataAry = append(saveDataAry, saveData)
			msg := commonus.MapOut()
			msg["msg"] = saveData
			d.dataMap = append(d.dataMap, msg)
		} else {
			detailedTargetInts, _ := strconv.ParseInt(v.DetailedTarget, 10, 64)
			dtCont, dtIsTrue := commonus.GetDetailedTargetInfo(detailedTargetInts)

			groupInt, _ := strconv.ParseInt(addData.Group, 10, 64)
			departidInt, _ := strconv.ParseInt(departmentId, 10, 64)
			// _, groupCont := commonus.GetGroupCont(groupInt)
			// _, deparConCont := commonus.GetBranchFactory(departidInt)

			where := commonus.MapOut()
			where["id"] = groupInt
			orgCont, _ := commonus.GetNewOrgCont(where, "id", "name")
			// outCont.GroupName = orgCont.Name

			whereDepart := commonus.MapOut()
			whereDepart["id"] = departidInt
			orgContDepart, _ := commonus.GetNewOrgCont(whereDepart, "id", "name")
			// outCont.DepartmentName = orgContDepart.Name

			msg := commonus.MapOut()
			if dtIsTrue == true {
				// msg["msg"] = fmt.Sprintf("%v-%v《%v》考核细则录入失败！请重新处理此方案！->ID:%v", groupCont.Name, deparConCont.Name, dtCont.Title, v.DetailedTarget)
				msg["msg"] = fmt.Sprintf("%v-%v《%v》考核细则录入失败！请重新处理此方案！->ID:%v", orgCont.Name, orgContDepart.Name, dtCont.Title, v.DetailedTarget)
			} else {
				// msg["msg"] = fmt.Sprintf("%v-%v《%v》考核细则录入失败！请重新处理此方案", groupCont.Name, deparConCont.Name, v.DetailedTarget)
				msg["msg"] = fmt.Sprintf("%v-%v《%v》考核细则录入失败！请重新处理此方案", orgCont.Name, orgContDepart.Name, v.DetailedTarget)
			}

			d.dataErrMap = append(d.dataErrMap, msg)
		}
	}
	if len(saveDataAry) > 0 {
		addErr := global.GVA_DB_Performanceappraisal.Create(&saveDataAry).Error
		if addErr != nil {
			msg := commonus.MapOut()
			msg["data"] = saveDataAry
			msg["msg"] = fmt.Sprintf("《%v》考核维度录入失败！请重新处理此方案", addData.Dimension)
			d.dataErrMap = append(d.dataErrMap, msg)
		}
	}
	syncProcess.Done()
}

// 定性考核列表
func (d *DutyHandle) GetQualEvalList(c *gin.Context) {
	var requestData SelectQualEval
	c.ShouldBindJSON(&requestData)
	//归档集团
	gormDb := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Select("qe_group").Where("qe_type = 1").Group("qe_group")
	if requestData.Group != "" {
		gormDb = gormDb.Having("qe_group = ?", requestData.Group)
	}
	var fileAry []int64
	listErr := gormDb.Find(&fileAry).Error
	if listErr != nil {
		response.Result(101, listErr, "没有数据！", c)
		return
	}
	if len(fileAry) < 1 {
		response.Result(102, listErr, "没有数据！", c)
		return
	}
	var aualEvalArrtAry []QualEvalListOut
	for _, v := range fileAry {
		var aualEvalArrtCont QualEvalListOut

		where := commonus.MapOut()
		where["id"] = v
		orgCont, groupErr := commonus.GetNewOrgCont(where, "id", "name")
		// outCont.GroupName = orgCont.Name

		// groupErr, groupCont := commonus.GetGroupCont(v)
		if groupErr == nil {
			aualEvalArrtCont.Id = strconv.FormatInt(v, 10)
			// aualEvalArrtCont.Name = groupCont.Name
			aualEvalArrtCont.Name = orgCont.Name
			//归档分厂-部室
			departAry, departAryErr := deparmentList(v, requestData.DepartmentId)
			if departAryErr == true {
				//分厂部室列表
				aualEvalArrtCont.Child = departAry
			}
			//组合集团
			aualEvalArrtAry = append(aualEvalArrtAry, aualEvalArrtCont)
		}
	}
	response.Result(0, aualEvalArrtAry, "查询完成！", c)
}

// 归档部门
func deparmentList(groupID int64, departmentIDStr string) (contentList []QualEvalListOutDepart, isTrue bool) {
	isTrue = false
	gormDbDepart := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Select("qe_accept_evaluation").Where("qe_type = 1 AND `qe_group` = ?", groupID).Group("qe_accept_evaluation")
	if departmentIDStr != "" {
		gormDbDepart = gormDbDepart.Having("qe_accept_evaluation = ?", departmentIDStr)
	}
	var fileDepartAry []int64
	listDepartErr := gormDbDepart.Find(&fileDepartAry).Error
	if listDepartErr == nil {
		for _, v := range fileDepartAry {

			whereDepart := commonus.MapOut()
			whereDepart["id"] = v
			orgContDepart, deparConErr := commonus.GetNewOrgCont(whereDepart, "id", "name")
			// userCont.DepartmentName = orgContDepart.Name

			// deparConErr, deparConCont := commonus.GetBranchFactory(v)
			var deparCont QualEvalListOutDepart
			if deparConErr == nil {
				deparCont.Id = strconv.FormatInt(v, 10)
				deparCont.Name = orgContDepart.Name
				//归档维度
				dimensionAry, dimensionAryErr := dimensionList(groupID, v)
				if dimensionAryErr == true {
					//维度列表
					deparCont.Child = dimensionAry
				}
			}
			//组合分厂部室
			contentList = append(contentList, deparCont)
		}

	}
	if len(contentList) > 0 {
		isTrue = true
	}
	return
}

// 归档维度
func dimensionList(groupID, departmentID int64) (contentList []DimensionList, isTrue bool) {
	isTrue = false
	var fileDimensionAry []int64
	listDimensionErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Select("qe_dimension").Where("qe_type = 1 AND `qe_group` = ? AND `qe_accept_evaluation` = ?", groupID, departmentID).Group("qe_dimension").Find(&fileDimensionAry).Error
	if listDimensionErr == nil {
		for _, v := range fileDimensionAry {
			dutyClassCont, dutyClassErr := commonus.GetDutyClassInfo(v)
			var dimenCont DimensionList
			if dutyClassErr == true {
				dimenCont.Id = strconv.FormatInt(v, 10)
				dimenCont.Name = dutyClassCont.Title
				//归档指标
				targerAry, targerAryErr := targetList(groupID, departmentID, v)
				if targerAryErr == true {
					//定性考核指标列表
					dimenCont.Child = targerAry
				}
				//组合维度
				contentList = append(contentList, dimenCont)
			}
		}
	}
	if len(contentList) > 0 {
		isTrue = true
	}
	return
}

// 查询归档定性指标
func targetList(groupID, departmentID, dimension int64) (contentList []TargetList, isTrue bool) {
	isTrue = false
	var fileTargetAry []int64
	listTargetErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Select("qe_target").Where("qe_type = 1 AND `qe_group` = ? AND `qe_accept_evaluation` = ? AND `qe_dimension` = ?", groupID, departmentID, dimension).Group("qe_target").Find(&fileTargetAry).Error
	if listTargetErr != nil {
		return
	}
	for _, tar_v := range fileTargetAry {
		var targetCont TargetList
		targetInfo, targetErr := commonus.GetTargetInfo(tar_v)
		if targetErr == true {
			targetCont.Id = strconv.FormatInt(tar_v, 10)
			targetCont.Name = targetInfo.Title
			//归档指标子栏目
			targerSunAry, targerSunAryErr := targetSunList(groupID, departmentID, dimension, tar_v)
			if targerSunAryErr == true {
				targetCont.Child = targerSunAry
			}
			//定性考核指标维度
			contentList = append(contentList, targetCont)
		}
	}
	if len(contentList) > 0 {
		isTrue = true
	}
	return
}

// 查询归档定性子栏目
func targetSunList(groupID, departmentID, dimension, targetId int64) (contentList []TargetSunList, isTrue bool) {
	isTrue = false
	var fileTargetSunAry []int64
	listTargetSunErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Select("qe_target_sun").Where("qe_type = 1 AND `qe_group` = ? AND `qe_accept_evaluation` = ? AND `qe_dimension` = ? AND `qe_target` = ?", groupID, departmentID, dimension, targetId).Group("qe_target_sun").Find(&fileTargetSunAry).Error
	if listTargetSunErr != nil {
		return
	}
	for _, v := range fileTargetSunAry {
		info, infoErr := commonus.GetQualitativeTargetInfo(v)
		if infoErr == true {
			var content TargetSunList
			content.Id = strconv.FormatInt(v, 10)
			content.Name = info.Title
			listAry, listAryErr := taskDetailsList(groupID, departmentID, dimension, targetId, v)
			if listAryErr == true {
				content.Child = listAry
			}

			contentList = append(contentList, content)
		}
	}
	if len(contentList) > 0 {
		isTrue = true
	}
	return
}

// 考核细则
func taskDetailsList(groupID, departmentID, dimension, targetId, targetSunId int64) (contentList []taskDetails, isTrue bool) {
	isTrue = false
	var taskDetailsCont []taskDatalsContOut
	listTargetSunErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Select("qe_id", "qe_detailed_target", "qe_unit", "qe_reference_score", "qe_cycle", "qe_cycleattr", "qe_state").Where("qe_type = 1 AND  `qe_group` = ? AND `qe_accept_evaluation` = ? AND `qe_dimension` = ? AND `qe_target` = ? AND `qe_target_sun` = ? AND `qe_state` = 1", groupID, departmentID, dimension, targetId, targetSunId).Find(&taskDetailsCont).Error
	if listTargetSunErr != nil {
		return
	}
	for _, v := range taskDetailsCont {
		var content taskDetails
		content.Id = strconv.FormatInt(v.Id, 10)
		content.QeId = strconv.FormatInt(v.Id, 10)
		dtCont, dtIsTrue := commonus.GetDetailedTargetInfo(v.DetailedTarget)
		if dtIsTrue == true {
			content.Name = dtCont.Title
			content.Content = dtCont.Content
		}
		content.Unit = v.Unit
		content.ReferenceScore = v.ReferenceScore
		content.Cycles = v.Cycles
		content.CycleAttres = v.CycleAttres
		content.State = v.State

		contentList = append(contentList, content)
	}
	if len(contentList) > 0 {
		isTrue = true
	}
	return
}

// 获取考核指标
func (d *DutyHandle) GetTaskTarget(c *gin.Context) {
	var requestData taskTargetList
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if requestData.Type == 0 {
		response.Result(101, requestData, "请选择您操作的时定性指标还是定量指标！", c)
		return
	}
	var contAry []assessmentmodel.EvaluationTarget
	gormDb := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.EvaluationTarget{}).Where("et_state = 1 AND `et_type` = ?", requestData.Type)

	// if requestData.Group == "" && len(requestData.DepartMent) < 1 {
	// 	gormDb = gormDb.Where("`et_visible_group` = '' AND `et_visible_range` = '' AND `et_share` = 1")
	// } else if requestData.Group != "" && len(requestData.DepartMent) < 1 {
	// 	gormDb = gormDb.Where("FIND_IN_SET(?,`et_visible_group`) OR (`et_visible_group` = '' AND `et_visible_range` = '')", requestData.Group)
	// } else {

	// }
	if len(requestData.DepartMent) < 1 {
		gormDb = gormDb.Where("`et_share` = 1")
	} else {
		var sqlOrStr string = ""
		for s_i, s_v := range requestData.DepartMent {
			if s_i == 0 {
				sqlOrStr = fmt.Sprintf("FIND_IN_SET(%v,`et_relevant_departments`)", s_v)
			} else {
				sqlOrStr = fmt.Sprintf("%v OR FIND_IN_SET(%v,`et_relevant_departments`)", sqlOrStr, s_v)
			}
		}
		sqlOrStr = fmt.Sprintf("`et_share` = 1 OR (`et_share` = 2 AND (%v))", sqlOrStr)
		gormDb = gormDb.Where(sqlOrStr)
	}
	listErr := gormDb.Find(&contAry).Error
	var taskTargetNewOut []GetTaskTargetNewList
	for _, val := range contAry {
		var taskTargetNewOutcont GetTaskTargetNewList
		taskTargetNewOutcont.Id = val.Id
		taskTargetNewOutcont.Title = val.Title
		taskTargetNewOutcont.Type = val.Type
		taskTargetNewOutcont.State = val.State
		taskTargetNewOutcont.AddTime = val.AddTime
		taskTargetNewOutcont.Share = val.Share
		taskTargetNewOutcont.RelevantDepartments = val.RelevantDepartments
		taskTargetNewOutcont.Dimension = val.Dimension
		taskTargetNewOutcont.Key = val.Key
		taskTargetNewOutcont.Report = val.Report
		taskTargetNewOutcont.Uniteing = val.Uniteing
		taskTargetNewOutcont.Cycles = val.Cycles
		taskTargetNewOutcont.CycleAttres = val.CycleAttres
		taskTargetNewOutcont.VisibleRange = val.VisibleRange
		taskTargetNewOutcont.VisibleRangeGroup = val.VisibleRangeGroup
		taskTargetNewOutcont.ReportList = strings.Split(val.Report, ",")
		taskTargetNewOut = append(taskTargetNewOut, taskTargetNewOutcont)
	}
	if listErr != nil {
		response.Result(201, listErr, "没有相关数据！", c)
		return
	}
	response.Result(0, taskTargetNewOut, "数据获取成功！", c)
}

// 获取定性指标子栏目
func (d *DutyHandle) GetTaskTargetSun(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 contAry []assessmentmodel.QualitativeTarget
	contErr := global.GVA_DB_Performanceappraisal.Where("q_state = 1 AND `q_parent_id` = ?", requestData.Id).Find(&contAry).Error
	if contErr != nil {
		response.Result(201, contErr, "没有相关数据！", c)
		return
	}
	response.Result(0, contAry, "数据获取成功！", c)
}

// 根据条件获取考核详情
func (d *DutyHandle) GetTaskTargetContAry(c *gin.Context) {
	var requestData SelectTaskTarget
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if requestData.Type == 0 {
		response.Result(102, err, "位置指标性质！", c)
		return
	}
	if requestData.TargetId == "" {
		response.Result(102, err, "请选择指标！", c)
		return
	}
	if requestData.Type == 1 && requestData.TargetSunId == "" {
		response.Result(102, err, "未知子栏目！请选择", c)
		return
	}
	var contAry []assessmentmodel.DetailedTarget
	gormDb := global.GVA_DB_Performanceappraisal.Where("dt_state = 1 AND `dt_parentid` = ?", requestData.TargetId)
	if requestData.TargetSunId != "" {
		gormDb = gormDb.Where("`dt_parentid_sun` = ?", requestData.TargetSunId)
	}
	contErr := gormDb.Find(&contAry).Error
	if contErr != nil {
		response.Result(201, contErr, "没有相关数据！", c)
		return
	}
	var targetInfo assessmentmodel.EvaluationTarget
	targetInfoErr := global.GVA_DB_Performanceappraisal.Where("`et_id` = ?", requestData.TargetId).First(&targetInfo).Error
	var outContList []taskDetailsLinkage
	for _, v := range contAry {
		var outCont taskDetailsLinkage
		outCont.Id = strconv.FormatInt(v.Id, 10)
		outCont.Name = v.Title
		outCont.Content = v.Content
		outCont.State = v.State
		if targetInfoErr == nil {
			outCont.Unit = targetInfo.Uniteing
			// outCont.ReferenceScore = v.Content
			outCont.Cycles = targetInfo.Cycles
			outCont.CycleAttres = targetInfo.CycleAttres
			if targetInfo.Report != "" {
				userKeyAry := strings.Split(targetInfo.Report, ",")
				if len(userKeyAry) > 0 {
					outCont.UserList = userKeyAry
					for _, u_v := range userKeyAry {
						usCont, usErr := archiveapi.GetUserInfo([]string{"worker_man.wm_number", "worker_man_data.wmd_name"}, map[string]interface{}{"wm_key": u_v})
						if usErr == true {
							var userCont QualEvalArrt
							userCont.Id = u_v
							userCont.Name = usCont.Name
							outCont.UserListAry = append(outCont.UserListAry, userCont)
						}
					}
				}
			}
		}

		outContList = append(outContList, outCont)
	}
	response.Result(0, outContList, "数据获取成功！", c)
}

// 添加定性考核权重
func (d *DutyHandle) AddQualEvalWeight(c *gin.Context) {
	var requestData addDepartmentDimensionWeight
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if requestData.Hierarchy == 0 {
		response.Result(101, err, "请指定当前添加的是维度权重还是指标权重！", c)
		return
	}
	if requestData.Type == 0 {
		response.Result(101, err, "请指定当前添加的是定性考核权重还是定量考核权重！", c)
		return
	}
	if requestData.Group == "" {
		response.Result(101, err, "请指定当前为哪个集团添加！", c)
		return
	}
	if requestData.DepartmentId == "" {
		response.Result(101, err, "请指定当前为哪个分厂或部室添加！", c)
		return
	}
	if requestData.Dimension == "" {
		response.Result(101, err, "请指定当前为哪个维度添加！", c)
		return
	}
	if requestData.Hierarchy > 1 && requestData.TargetId == "" {
		response.Result(101, err, "请指定当前为哪个指标添加！", c)
		return
	}
	//判断当前权重是否写入
	judgeAry := commonus.MapOut()
	gromDbJudeg := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DepartmentDimensionWeight{}).Where("`ddw_hierarchy` = ? AND `ddw_type` = ? AND `ddw_group` = ? AND `ddw_derpatment` = ? AND `ddw_dimension` = ?", requestData.Hierarchy, requestData.Type, requestData.Group, requestData.DepartmentId, requestData.Dimension)
	if requestData.Hierarchy > 1 && requestData.TargetId != "" {
		gromDbJudeg = gromDbJudeg.Where("`ddw_target` = ?", requestData.TargetId)
	}
	scoreJudegErr := gromDbJudeg.First(&judgeAry).Error
	if scoreJudegErr == nil {
		response.Result(101, err, "此权重项已经添加！请不要重复添加！", c)
		return
	}

	//获取当前条件下的权重总和
	var sumScore int64 = 0
	gromDb := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DepartmentDimensionWeight{}).Where("`ddw_hierarchy` = ? AND `ddw_type` = ? AND `ddw_group` = ? AND `ddw_derpatment` = ? AND `ddw_dimension` = ?", requestData.Hierarchy, requestData.Type, requestData.Group, requestData.DepartmentId, requestData.Dimension)
	if requestData.Hierarchy > 1 && requestData.TargetId != "" {
		gromDb = gromDb.Where("`ddw_target` = ?", requestData.TargetId)
	}
	scoreErr := gromDb.Pluck("COALESCE(SUM(ddw_weight), 0) as rescore", &sumScore).Error
	if scoreErr != nil {
		sumScore = 0
	}
	resultScore := 10000 - sumScore*100
	if resultScore-(requestData.Weight*100) < 0 {
		msgStr := fmt.Sprintf("权重超出剩余可分配权重最大值！当前可使用的权重为：（%v）。您要写入的权重为：《%v》。请您合理分配权重！", resultScore/100, requestData.Weight)
		response.Result(101, err, msgStr, c)
		return
	}
	var saveData assessmentmodel.DepartmentDimensionWeight
	saveData.Type = requestData.Type
	groupId, _ := strconv.ParseInt(requestData.Group, 10, 64)
	saveData.Group = groupId
	departmentId, _ := strconv.ParseInt(requestData.DepartmentId, 10, 64)
	saveData.DepartmentId = departmentId
	dimensionId, _ := strconv.ParseInt(requestData.Dimension, 10, 64)
	saveData.Dimension = dimensionId
	targetId, _ := strconv.ParseInt(requestData.TargetId, 10, 64)
	saveData.Target = targetId
	saveData.Weight = requestData.Weight * 100
	saveData.Addtime = time.Now().Unix()
	saveData.Hierarchy = requestData.Hierarchy
	addErr := global.GVA_DB_Performanceappraisal.Create(&saveData).Error
	if addErr != nil {
		response.Result(101, addErr, "数据写入失败！", c)
		return
	}
	response.Result(0, saveData, "数据写入成功！", c)
}

// 批量添加指标权重
func (d *DutyHandle) AddQualEvalDimWeightBatch(c *gin.Context) {
	var requestData addDepartDimensionWeightAry
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}

	if requestData.Type == 0 {
		response.Result(102, err, "请指定当前添加的是定性考核权重还是定量考核权重！", c)
		return
	}
	if requestData.Group == "" {
		response.Result(103, err, "请指定当前为哪个集团添加！", c)
		return
	}
	if requestData.DepartmentId == "" {
		response.Result(104, err, "请指定当前为哪个分厂或部室添加！", c)
		return
	}
	if requestData.Dimension == "" {
		response.Result(105, err, "请指定当前为哪个维度添加！", c)
		return
	}
	var targetIdAry []int64
	if len(requestData.TargetList) < 1 {
		response.Result(106, err, "请指定当前为哪些指标添加！", c)
		return
	} else {
		var judgeSumScoer int64 = 0
		for _, t_v := range requestData.TargetList {
			judgeSumScoer = judgeSumScoer + t_v.Weight
			tarIdInt, tarIdIntErr := strconv.ParseInt(t_v.Id, 10, 64)
			if tarIdIntErr == nil {
				targetIdAry = append(targetIdAry, tarIdInt)
			}
		}
		if 10000-judgeSumScoer*100 < 0 {
			response.Result(107, judgeSumScoer, "权重综合超过了限定值100！请重新输入", c)
			return
		}
	}
	//判断是否已经存在其他的已添加选项
	var sumScoreNotIn int64 = 0
	gromDbNotIn := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DepartmentDimensionWeight{}).Where("`ddw_hierarchy` = 2 AND `ddw_type` = ? AND `ddw_group` = ? AND `ddw_derpatment` = ? AND `ddw_dimension` = ?", requestData.Type, requestData.Group, requestData.DepartmentId, requestData.Dimension)
	if len(targetIdAry) > 0 {
		gromDbNotIn = gromDbNotIn.Where("`ddw_target` NOT IN ?", targetIdAry)
	}
	scoreNotInErr := gromDbNotIn.Pluck("COALESCE(SUM(ddw_weight), 0) as rescore", &sumScoreNotIn).Error
	if scoreNotInErr != nil {
		sumScoreNotIn = 0
	}
	sumScoreNotIn = sumScoreNotIn * 100

	//获取当前维度下的指标权重总和
	var sumScore int64 = 0
	gromDb := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DepartmentDimensionWeight{}).Where("`ddw_hierarchy` = 2 AND `ddw_type` = ? AND `ddw_group` = ? AND `ddw_derpatment` = ? AND `ddw_dimension` = ?", requestData.Type, requestData.Group, requestData.DepartmentId, requestData.Dimension)
	if len(targetIdAry) > 0 {
		gromDb = gromDb.Where("`ddw_target` IN ?", targetIdAry)
	}
	scoreErr := gromDb.Pluck("COALESCE(SUM(ddw_weight), 0) as rescore", &sumScore).Error
	if scoreErr != nil {
		sumScore = 0
	}
	sumScore = sumScore * 100
	if sumScore == 0 && sumScoreNotIn == 0 {
		var saveData []assessmentmodel.DepartmentDimensionWeight
		for _, v := range requestData.TargetList {
			var saveDataCont assessmentmodel.DepartmentDimensionWeight

			saveDataCont.Type = requestData.Type
			groupId, _ := strconv.ParseInt(requestData.Group, 10, 64)
			saveDataCont.Group = groupId
			departmentId, _ := strconv.ParseInt(requestData.DepartmentId, 10, 64)
			saveDataCont.DepartmentId = departmentId
			dimensionId, _ := strconv.ParseInt(requestData.Dimension, 10, 64)
			saveDataCont.Dimension = dimensionId
			targetId, _ := strconv.ParseInt(v.Id, 10, 64)
			saveDataCont.Target = targetId
			saveDataCont.Weight = v.Weight * 100
			saveDataCont.Addtime = time.Now().Unix()
			saveDataCont.Hierarchy = 2
			// addErr := global.GVA_DB_Performanceappraisal.Create(&saveData).Error
			saveData = append(saveData, saveDataCont)
		}
		if len(saveData) > 0 {
			addErr := global.GVA_DB_Performanceappraisal.Create(&saveData).Error
			if addErr != nil {
				response.Result(108, addErr, "数据写入失败", c)
				return
			}
		}
	} else {
		var depDimIdAry []int64
		gromDbDim := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DepartmentDimensionWeight{}).Select("ddw_id").Where("`ddw_hierarchy` = 2 AND `ddw_type` = ? AND `ddw_group` = ? AND `ddw_derpatment` = ? AND `ddw_dimension` = ?", requestData.Type, requestData.Group, requestData.DepartmentId, requestData.Dimension)
		gromDbDimErr := gromDbDim.Where("`ddw_target` NOT IN ?", targetIdAry).Find(&depDimIdAry).Error
		if gromDbDimErr == nil {
			global.GVA_DB_Performanceappraisal.Where("`ddw_id` IN ?", depDimIdAry).Delete(&assessmentmodel.DepartmentDimensionWeight{})
		}
		var saveData []assessmentmodel.DepartmentDimensionWeight

		for _, v := range requestData.TargetList {
			var ddwId int64
			ddwIdErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DepartmentDimensionWeight{}).Select("ddw_id").Where("`ddw_hierarchy` = 2 AND `ddw_type` = ? AND `ddw_group` = ? AND `ddw_derpatment` = ? AND `ddw_dimension` = ? AND `ddw_target` = ?", requestData.Type, requestData.Group, requestData.DepartmentId, requestData.Dimension, v.Id).First(&ddwId).Error
			if ddwIdErr == nil {
				saveMap := commonus.MapOut()
				saveMap["ddw_weight"] = v.Weight * 100
				saveMap["ddw_time"] = time.Now().Unix()
				ddwIdEiteErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DepartmentDimensionWeight{}).Where("`ddw_id` = ?", ddwId).Updates(saveMap).Error
				if ddwIdEiteErr == nil {
				}
			} else {
				var saveDataCont assessmentmodel.DepartmentDimensionWeight
				saveDataCont.Type = requestData.Type
				groupId, _ := strconv.ParseInt(requestData.Group, 10, 64)
				saveDataCont.Group = groupId
				departmentId, _ := strconv.ParseInt(requestData.DepartmentId, 10, 64)
				saveDataCont.DepartmentId = departmentId
				dimensionId, _ := strconv.ParseInt(requestData.Dimension, 10, 64)
				saveDataCont.Dimension = dimensionId
				targetId, _ := strconv.ParseInt(v.Id, 10, 64)
				saveDataCont.Target = targetId
				saveDataCont.Weight = v.Weight * 100
				saveDataCont.Addtime = time.Now().Unix()
				saveDataCont.Hierarchy = 2
				// addErr := global.GVA_DB_Performanceappraisal.Create(&saveData).Error
				saveData = append(saveData, saveDataCont)
			}
		}
		if len(saveData) > 0 {
			addErr := global.GVA_DB_Performanceappraisal.Create(&saveData).Error
			if addErr != nil {
				response.Result(108, addErr, "数据写入失败", c)
				return
			}
		}
	}
	response.Result(0, sumScore, "数据写入成功", c)
}

// 批量添加维度权重
func (d *DutyHandle) AddDimWeightBatch(c *gin.Context) {
	var requestData addDepartDimenWeightAry
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}

	if requestData.Type == 0 {
		response.Result(102, err, "请指定当前添加的是定性考核权重还是定量考核权重！", c)
		return
	}
	if requestData.Group == "" {
		response.Result(103, err, "请指定当前为哪个集团添加！", c)
		return
	}
	if requestData.DepartmentId == "" {
		response.Result(104, err, "请指定当前为哪个分厂或部室添加！", c)
		return
	}
	var targetIdAry []int64
	if len(requestData.Dimension) < 1 {
		response.Result(106, err, "请指定当前为哪些维度添加！", c)
		return
	} else {
		var judgeSumScoer int64 = 0
		for _, t_v := range requestData.Dimension {
			judgeSumScoer = judgeSumScoer + t_v.Weight
			tarIdInt, tarIdIntErr := strconv.ParseInt(t_v.Id, 10, 64)
			if tarIdIntErr == nil {
				targetIdAry = append(targetIdAry, tarIdInt)
			}
		}
		if 10000-judgeSumScoer*100 < 0 {
			response.Result(105, judgeSumScoer, "权重综合超过了限定值100！请重新输入", c)
			return
		}
	}

	var depDimIdAry []int64
	gromDbDim := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DepartmentDimensionWeight{}).Select("ddw_id").Where("`ddw_hierarchy` = 1 AND `ddw_type` = ? AND `ddw_group` = ? AND `ddw_derpatment` = ?", requestData.Type, requestData.Group, requestData.DepartmentId)
	gromDbDimErr := gromDbDim.Find(&depDimIdAry).Error
	if gromDbDimErr == nil {
		global.GVA_DB_Performanceappraisal.Where("`ddw_dimension` IN ?", depDimIdAry).Delete(&assessmentmodel.DepartmentDimensionWeight{})
	}
	var saveData []assessmentmodel.DepartmentDimensionWeight

	for _, v := range requestData.Dimension {
		var ddwId int64
		ddwIdErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DepartmentDimensionWeight{}).Select("ddw_id").Where("`ddw_hierarchy` = 1 AND `ddw_type` = ? AND `ddw_group` = ? AND `ddw_derpatment` = ? AND `ddw_dimension` = ?", requestData.Type, requestData.Group, requestData.DepartmentId, v.Id).First(&ddwId).Error
		if ddwIdErr == nil {
			saveMap := commonus.MapOut()
			saveMap["ddw_weight"] = v.Weight * 100
			saveMap["ddw_time"] = time.Now().Unix()
			ddwIdEiteErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DepartmentDimensionWeight{}).Where("`ddw_id` = ?", ddwId).Updates(saveMap).Error
			if ddwIdEiteErr == nil {
			}
		} else {
			var saveDataCont assessmentmodel.DepartmentDimensionWeight
			saveDataCont.Type = requestData.Type
			groupId, _ := strconv.ParseInt(requestData.Group, 10, 64)
			saveDataCont.Group = groupId
			departmentId, _ := strconv.ParseInt(requestData.DepartmentId, 10, 64)
			saveDataCont.DepartmentId = departmentId
			dimensionId, _ := strconv.ParseInt(v.Id, 10, 64)
			saveDataCont.Dimension = dimensionId
			saveDataCont.Target = 0
			saveDataCont.Weight = v.Weight * 100
			saveDataCont.Addtime = time.Now().Unix()
			saveDataCont.Hierarchy = 1
			// addErr := global.GVA_DB_Performanceappraisal.Create(&saveData).Error
			saveData = append(saveData, saveDataCont)
		}
	}
	if len(saveData) > 0 {
		addErr := global.GVA_DB_Performanceappraisal.Create(&saveData).Error
		if addErr != nil {
			response.Result(108, addErr, "数据写入失败", c)
			return
		}
	}
	response.Result(0, depDimIdAry, "数据写入成功", c)
}

// 获取部门考核指标详情
func (d *DutyHandle) GetQualEval(c *gin.Context) {
	var requestData QualitativeEite
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if requestData.Group == "" {
		response.Result(102, err, "请选择归属集团", c)
		return
	}
	if requestData.DepartmentId == "" {
		response.Result(102, err, "请选择接受考核的部门！", c)
		return
	}
	if requestData.Dimension == "" {
		response.Result(102, err, "请选择考核维度", c)
		return
	}
	if requestData.Target == "" {
		response.Result(102, err, "请选择考核指标", c)
		return
	}
	if requestData.TargetSun == "" {
		response.Result(102, err, "请选择考核指标子栏目", c)
		return
	}
	var quaAry []assessmentmodel.QualitativeEvaluation
	var quaOutAry QualitativeEiteOut
	quaOutAry.Group = requestData.Group
	quaOutAry.DepartmentId = requestData.DepartmentId
	quaOutAry.Dimension = requestData.Dimension
	quaOutAry.Target = requestData.Target
	quaOutAry.TargetSun = requestData.TargetSun
	// quaOutAry.List = requestData.List
	quaErr := global.GVA_DB_Performanceappraisal.Where("`qe_type` = 1 AND `qe_group` = ? AND `qe_accept_evaluation` = ? AND `qe_dimension` = ? AND `qe_target` = ? AND `qe_target_sun` = ?", requestData.Group, requestData.DepartmentId, requestData.Dimension, requestData.Target, requestData.TargetSun).Find(&quaAry).Error
	if quaErr != nil {
		response.Result(102, quaErr, "数据获取失败！", c)
		return
	}
	var targetInfo assessmentmodel.EvaluationTarget
	targetInfoErr := global.GVA_DB_Performanceappraisal.Where("`et_id` = ?", requestData.Target).First(&targetInfo).Error
	for _, v := range quaAry {

		detTarCont, detTarContErr := commonus.GetDetailedTargetInfo(v.DetailedTarget)
		if detTarContErr == true {
			var outCont taskDetailsLinkage
			outCont.Id = strconv.FormatInt(v.Id, 10)
			outCont.Name = detTarCont.Title
			outCont.Content = detTarCont.Content
			outCont.State = v.State
			if targetInfoErr == nil {
				outCont.Unit = targetInfo.Uniteing
				outCont.ReferenceScore = v.ReferenceScore
				outCont.Cycles = targetInfo.Cycles
				outCont.CycleAttres = targetInfo.CycleAttres
				if targetInfo.Report != "" {
					userKeyAry := strings.Split(targetInfo.Report, ",")
					if len(userKeyAry) > 0 {
						outCont.UserList = userKeyAry
						for _, u_v := range userKeyAry {
							usCont, usErr := archiveapi.GetUserInfo([]string{"worker_man.wm_number", "worker_man_data.wmd_name"}, map[string]interface{}{"wm_key": u_v})
							if usErr == true {
								var userCont QualEvalArrt
								userCont.Id = u_v
								userCont.Name = usCont.Name
								outCont.UserListAry = append(outCont.UserListAry, userCont)
							}
						}
					}
				}
			}

			quaOutAry.List = append(quaOutAry.List, outCont)
		}

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

// 修改定性考核内容
func (d *DutyHandle) EiteQualEvalCont(c *gin.Context) {
	var requestData QualitativeEiteOut
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if requestData.Group == "" {
		response.Result(102, err, "请选择归属集团", c)
		return
	}
	if requestData.DepartmentId == "" {
		response.Result(102, err, "请选择接受考核的部门！", c)
		return
	}
	if requestData.Dimension == "" {
		response.Result(102, err, "请选择考核维度", c)
		return
	}
	if requestData.Target == "" {
		response.Result(102, err, "请选择考核指标", c)
		return
	}
	if requestData.TargetSun == "" {
		response.Result(102, err, "请选择考核指标子栏目", c)
		return
	}
	if len(requestData.List) < 1 {
		response.Result(102, err, "考核细则不能为空", c)
		return
	}
	groupInt, groupIntErr := strconv.ParseInt(requestData.Group, 10, 64)
	if groupIntErr != nil {
		groupInt = 0
	}
	dimensionInt, departinIntErr := strconv.ParseInt(requestData.Dimension, 10, 64)
	if departinIntErr != nil {
		dimensionInt = 0
	}
	targetInt, targetIntErr := strconv.ParseInt(requestData.Target, 10, 64)
	if targetIntErr != nil {
		targetInt = 0
	}
	targetSunInt, targetSunIntErr := strconv.ParseInt(requestData.TargetSun, 10, 64)
	if targetSunIntErr != nil {
		targetSunInt = 0
	}
	departmentIdInt, departmentIdIntErr := strconv.ParseInt(requestData.DepartmentId, 10, 64)
	if departmentIdIntErr != nil {
		departmentIdInt = 0
	}
	var writeInfo []int
	for _, v := range requestData.List {
		var qeInfo assessmentmodel.QualitativeEvaluation
		judjeisErr := global.GVA_DB_Performanceappraisal.Where("qe_id = ?", v.Id).First(&qeInfo).Error
		if judjeisErr == nil {
			qeSaveMap := commonus.MapOut()
			qeSaveMap["qe_reference_score"] = v.ReferenceScore
			qeSaveMap["qe_operator"] = strings.Join(v.UserList, ",")
			qeSaveMap["qe_department_id"] = strings.Join(GetDepartmentByUserBast(v.UserList), ",")
			qeSaveMap["qe_eitetime"] = time.Now().Unix()
			eiteErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Where("qe_id = ?", v.Id).Updates(&qeSaveMap).Error
			if eiteErr == nil {
				detaTargetMap := commonus.MapOut()
				detaTargetMap["dt_title"] = v.Name
				detaTargetMap["dt_content"] = v.Content
				detaTargetMap["dt_time"] = time.Now().Unix()
				eiteDetaErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DetailedTarget{}).Where("dt_id = ?", qeInfo.DetailedTarget).Updates(&detaTargetMap).Error
				if eiteDetaErr == nil {
					writeInfo = append(writeInfo, 1)
				}
			}
		} else {
			var saveData assessmentmodel.QualitativeEvaluation
			saveData.Group = groupInt
			saveData.Type = 1
			saveData.Dimension = dimensionInt
			saveData.Target = targetInt
			saveData.TargetSun = targetSunInt
			detailedTargetInt, detailedTargetIntErr := strconv.ParseInt(v.Id, 10, 64)
			if detailedTargetIntErr == nil {
				saveData.DetailedTarget = detailedTargetInt
			}
			saveData.Unit = v.Unit
			saveData.ReferenceScore = v.ReferenceScore
			saveData.Cycles = v.Cycles
			saveData.CycleAttres = v.CycleAttres

			saveData.State = 1
			saveData.Addtime = time.Now().Unix()
			saveData.Eitetime = time.Now().Unix()

			saveData.AcceptEvaluation = departmentIdInt
			saveData.Operator = strings.Join(v.UserList, ",")
			saveData.DepartmentId = strings.Join(GetDepartmentByUserBast(v.UserList), ",")
			addDataErr := global.GVA_DB_Performanceappraisal.Create(&saveData).Error
			if addDataErr == nil {
				writeInfo = append(writeInfo, 1)
			}
		}

	}
	if len(writeInfo) <= 0 {
		response.Result(102, writeInfo, "数据写入失败！请重新提交！", c)
		return
	}
	response.Result(0, err, "数据写入成功！", c)
	// eiteDataSave := commonus.MapOut()
	// eiteDataSave["qe_state"] = 2
	// eiteDataSave["qe_eitetime"] = time.Now().Unix()
	// //开启事务处理
	// affairDb := global.GVA_DB_Performanceappraisal.Begin()
	// delOldContErr := affairDb.Where("`qe_type` = 1 AND `qe_group` = ? AND `qe_accept_evaluation` = ? AND `qe_dimension` = ? AND `qe_target` = ? AND `qe_target_sun` = ?", requestData.Group, requestData.DepartmentId, requestData.Dimension, requestData.Target, requestData.TargetSun).Delete(&assessmentmodel.QualitativeEvaluation{}).Error
	// delOldContErr := affairDb.Model(&assessmentmodel.QualitativeEvaluation{}).Where("`qe_type` = 1 AND `qe_group` = ? AND `qe_accept_evaluation` = ? AND `qe_dimension` = ? AND `qe_target` = ? AND `qe_target_sun` = ?", requestData.Group, requestData.DepartmentId, requestData.Dimension, requestData.Target, requestData.TargetSun).Updates(&eiteDataSave).Error
	// var quaEvaCont []assessmentmodel.QualitativeEvaluation
	// for _, v := range requestData.List {
	// 	var saveData assessmentmodel.QualitativeEvaluation

	// 	saveData.Group = groupInt
	// 	saveData.Type = 1

	// 	saveData.Dimension = dimensionInt

	// 	saveData.Target = targetInt

	// 	saveData.TargetSun = targetSunInt

	// 	detailedTargetInt, detailedTargetIntErr := strconv.ParseInt(v.Id, 10, 64)
	// 	if detailedTargetIntErr == nil {
	// 		saveData.DetailedTarget = detailedTargetInt
	// 	}

	// 	saveData.Unit = v.Unit
	// 	saveData.ReferenceScore = v.ReferenceScore
	// 	saveData.Cycles = v.Cycles
	// 	saveData.CycleAttres = v.CycleAttres

	// 	saveData.State = 1
	// 	saveData.Addtime = time.Now().Unix()
	// 	saveData.Eitetime = time.Now().Unix()

	// 	saveData.AcceptEvaluation = departmentIdInt
	// 	saveData.Operator = strings.Join(v.UserList, ",")
	// 	// fmt.Printf("%v-------->%v\n", GetDepartmentByUserBast(v.UserList), strings.Join(GetDepartmentByUserBast(v.UserList), ","))
	// 	saveData.DepartmentId = strings.Join(GetDepartmentByUserBast(v.UserList), ",")
	// 	// operatorInt, operatorIntErr := strconv.ParseInt(v.Operator, 10, 64)
	// 	// if operatorIntErr == nil {
	// 	// 	saveData.Operator = strings.Join(v.Operator,",")
	// 	// }
	// 	// saveData.AcceptEvaluation = departmentIdInt

	// 	quaEvaCont = append(quaEvaCont, saveData)
	// }
	// var infoAttrErr error
	// if len(quaEvaCont) > 0 {
	// 	infoAttrErr = affairDb.Create(&quaEvaCont).Error
	// 	if delOldContErr == nil && infoAttrErr == nil {
	// 		delOldContErr = affairDb.Commit().Error
	// 		if delOldContErr != nil {
	// 			delOldContErr = affairDb.Rollback().Error
	// 			response.Result(102, err, "数据写入失败！请重新提交！", c)
	// 			return
	// 		}
	// 		commonus.AddDimenTargetWeight(1, groupInt, departmentIdInt, dimensionInt, targetInt)
	// 		response.Result(0, err, "数据写入成功！", c)
	// 	} else {
	// 		delOldContErr = affairDb.Rollback().Error
	// 		response.Result(102, err, "数据写入失败！请重新提交！", c)
	// 	}
	// } else {
	// 	response.Result(0, err, "数据写入成功！", c)
	// }

}

// 删除定性考核
func (d *DutyHandle) DelQualEvalCont(c *gin.Context) {
	var requestData DelQualitative
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if requestData.Group == "" {
		response.Result(102, err, "请选择归属集团", c)
		return
	}
	if requestData.DepartmentId == "" {
		response.Result(103, err, "请选择接受考核的部门！", c)
		return
	}
	if requestData.Dimension == "" {
		response.Result(104, err, "请选择考核维度", c)
		return
	}
	if requestData.Target == "" {
		response.Result(105, err, "请选择考核指标", c)
		return
	}
	if requestData.TargetSun == "" {
		response.Result(106, err, "请选择考核指标子栏目", c)
		return
	}

	if requestData.Type == 0 {
		requestData.Type = 1
	}

	groupInt, groupIntErr := strconv.ParseInt(requestData.Group, 10, 64)
	if groupIntErr != nil {
		groupInt = 0
	}
	dimensionInt, departinIntErr := strconv.ParseInt(requestData.Dimension, 10, 64)
	if departinIntErr != nil {
		dimensionInt = 0
	}
	targetInt, targetIntErr := strconv.ParseInt(requestData.Target, 10, 64)
	if targetIntErr != nil {
		targetInt = 0
	}
	// targetSunInt, targetSunIntErr := strconv.ParseInt(requestData.TargetSun, 10, 64)
	// if targetSunIntErr != nil {
	// 	targetSunInt = 0
	// }
	departmentIdInt, departmentIdIntErr := strconv.ParseInt(requestData.DepartmentId, 10, 64)
	if departmentIdIntErr != nil {
		departmentIdInt = 0
	}

	affairDb := global.GVA_DB_Performanceappraisal.Begin()
	delOldContErr := affairDb.Where("`qe_type` = 1 AND `qe_group` = ? AND `qe_accept_evaluation` = ? AND `qe_dimension` = ? AND `qe_target` = ? AND `qe_target_sun` = ?", requestData.Group, requestData.DepartmentId, requestData.Dimension, requestData.Target, requestData.TargetSun).Delete(&assessmentmodel.QualitativeEvaluation{}).Error

	var dimSurplusSum int64
	sumScoreEr := affairDb.Model(&assessmentmodel.QualitativeEvaluation{}).Where("`qe_type` = 1 AND `qe_group` = ? AND `qe_accept_evaluation` = ? AND `qe_dimension` = ? AND `qe_target` = ?", requestData.Group, requestData.DepartmentId, requestData.Dimension, requestData.Target).Pluck("COALESCE(COUNT(qe_id), 0) as rescore", &dimSurplusSum).Error
	var delDimErr error
	delDimErr = nil
	if sumScoreEr == nil && dimSurplusSum == 0 {
		delDimErr = affairDb.Where("`ddw_type` = 1 AND `ddw_hierarchy` = 2 AND `ddw_group` = ? AND `ddw_derpatment` = ? AND `ddw_dimension` = ? AND `ddw_target` = ?", requestData.Group, requestData.DepartmentId, requestData.Dimension, requestData.Target).Delete(&assessmentmodel.DepartmentDimensionWeight{}).Error
	}
	if delOldContErr == nil && delDimErr == nil {
		delOldContErr = affairDb.Commit().Error
		if delOldContErr != nil {
			delOldContErr = affairDb.Rollback().Error
			response.Result(103, delOldContErr, "删除失败！", c)
			return
		}
		commonus.AddDimenTargetWeight(requestData.Type, groupInt, departmentIdInt, dimensionInt, targetInt)
		response.Result(0, delOldContErr, "删除成功！", c)
	} else {
		delOldContErr = affairDb.Rollback().Error
		response.Result(102, delOldContErr, "删除失败！", c)
	}
}