gin_server_admin/api/admin/dutyassess/assess.go

package dutyassess

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

	"gin_server_admin/api/v1/archiveapi"
	"gin_server_admin/api/v1/assessment"
	"gin_server_admin/api/v1/examtestpage"
	"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) Index(c *gin.Context) {
	outPut := commonus.MapOut()
	response.Result(0, outPut, "管理端获取成功", c)
}

// 获取部门被考核时间表
func (d *DutyAssessApi) GetDepartEvaluate(c *gin.Context) {
	isTrue, userCont := commonus.AdminClientIdentity()
	if isTrue != true {
		response.Result(101, isTrue, "您的身份令牌已经失效！请重新登录获取身份令牌！", c)
		return
	}
	var requestData getDepartAssObtain
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		// response.Result(101, err, "参数错误！请重新提交！", c)
		// return
	}
	if requestData.PageSize == 0 {
		requestData.PageSize = 20
	}
	if requestData.Page <= 0 {
		requestData.Page = 1
	}
	var timeUnix int64
	if requestData.Time != "" {
		timeStr := requestData.Time + "-01 12:00:00"
		assessmentTime, assessmentTimeErr := commonus.DateToTimeStampEs(timeStr)
		if assessmentTimeErr == true {
			timeUnix = assessmentTime
		}
	} else {
		timeUnix = 0
	}

	offSetPage := commonus.CalculatePages(requestData.Page, requestData.PageSize)
	//获取管理信息
	attriButeId, attriButeErr := strconv.ParseInt(userCont.AttriBute, 10, 64) //转换管理员属性部门

	var departScorsList []assessmentmodel.Departscores

	gormDb := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.Departscores{}).Select("s_file_time", "s_depart_id").Where("`s_state` = 1")
	if requestData.DepartID != "" {
		if timeUnix != 0 {
			gormDb = gormDb.Group("s_file_time,s_depart_id").Having("`s_file_time` = ? AND `s_depart_id` = ?", timeUnix, requestData.DepartID)
		} else {
			gormDb = gormDb.Group("s_file_time,s_depart_id").Having("`s_depart_id` = ?", requestData.DepartID)
		}
	} else {
		if attriButeErr == nil {
			if attriButeId != 0 {
				if timeUnix != 0 {
					gormDb = gormDb.Group("s_file_time,s_depart_id").Having("`s_file_time` = ? AND `s_depart_id` = ?", timeUnix, attriButeId)
				} else {
					gormDb = gormDb.Group("s_file_time,s_depart_id").Having("`s_depart_id` = ?", attriButeId)
				}
			} else {
				groupId, groupIdErr := strconv.ParseInt(userCont.Group, 10, 64)
				if groupIdErr == nil {
					if groupId != 1 {
						deparIsTrue, departMap := getGroupDepartIdMap(groupId)
						if deparIsTrue == true {
							if len(departMap.Id) > 0 {
								gormDb = gormDb.Group("s_file_time,s_depart_id").Having("`s_file_time` = ? AND `s_depart_id` IN ?", timeUnix, departMap.Id)
							} else {
								gormDb = gormDb.Group("s_file_time,s_depart_id").Having("`s_depart_id` = ?", attriButeId)
							}
						} else {
							if timeUnix != 0 {
								gormDb = gormDb.Group("s_file_time,s_depart_id").Having("`s_file_time` = ?", timeUnix)
							} else {
								gormDb = gormDb.Group("s_file_time,s_depart_id")
							}
						}
					} else {
						if timeUnix != 0 {
							gormDb = gormDb.Group("s_file_time,s_depart_id").Having("`s_file_time` = ?", timeUnix)
						} else {
							gormDb = gormDb.Group("s_file_time,s_depart_id")
						}
					}

				} else {
					if timeUnix != 0 {
						gormDb = gormDb.Group("s_file_time,s_depart_id").Having("`s_file_time` = ?", timeUnix)
					} else {
						gormDb = gormDb.Group("s_file_time,s_depart_id")
					}
				}
			}
		} else {
			if timeUnix != 0 {
				gormDb = gormDb.Group("s_file_time,s_depart_id").Having("`s_file_time` = ?", timeUnix)
			} else {
				gormDb = gormDb.Group("s_file_time,s_depart_id")
			}
		}
	}

	/*
		获取总共有多少记录
	*/
	var total int64
	totalErr := gormDb.Count(&total).Error
	if totalErr != nil {
		total = 0
	}
	//获取记录数据
	evaErr := gormDb.Limit(requestData.PageSize).Offset(offSetPage).Find(&departScorsList).Error

	if evaErr != nil {
		response.Result(104, evaErr, "数据获取失败！", c)
		return
	}
	var departMonthAry []departMonthMap
	for _, val := range departScorsList {
		var departMonthCont departMonthMap
		departMonthCont.DepartId = val.DepartId

		// departMonthCont.DepartId = val.DepartId
		bfIsTrue, bfInfo := assessment.GetBranchFactory(val.DepartId)
		if bfIsTrue == true {
			departMonthCont.DepartTitle = bfInfo.Name
		}
		departMonthCont.TimeStr = strconv.FormatInt(val.FileTime, 10)
		departMonthCont.DateStr = commonus.TimeStampToDate(val.FileTime, 10)
		departMonthAry = append(departMonthAry, departMonthCont)
	}
	countSum := len(departMonthAry)
	printData := commonus.OutPutList(total, int64(countSum), requestData.Page, requestData.PageSize, departMonthAry)
	response.Result(0, printData, "查询成功！", c)
}

// 获取部门考核列表
func (d *DutyAssessApi) GetDepartmentAssessList(c *gin.Context) {
	var requestData getDepartAssObtains
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		// response.Result(101, err, "参数错误！请重新提交！", c)
		// return
	}
	// if requestData.PageSize == 0 {
	// 	requestData.PageSize = 20
	// }
	// if requestData.Page <= 0 {
	// 	requestData.Page = 1
	// }
	if requestData.Time == "" {
		response.Result(103, err, "未知时间！", c)
		return
	}
	if requestData.DepartID == "" {
		response.Result(103, err, "未知部门！", c)
		return
	}
	timeStr := requestData.Time + "-01 12:00:00"
	assessmentTime, assessmentTimeErr := commonus.DateToTimeStampEs(timeStr)
	if assessmentTimeErr != true {
		response.Result(104, timeStr, "你提交的考核日期错误！", c)
		return
	}

	isTrue, _ := commonus.AdminClientIdentity()
	// isTrue, userCont := commonus.AdminClientIdentity()
	if isTrue != true {
		response.Result(101, err, "您的身份令牌已经失效！请重新登录获取身份令牌！", c)
		return
	}

	// var departScorsList []assessmentmodel.Departscores

	// gormDb := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.Departscores{}).Select("s_class").Where("`s_file_time` = ? AND `s_state` = 1", assessmentTime)

	// attriButeId, attriButeErr := strconv.ParseInt(userCont.AttriBute, 10, 64) //转换管理员属性部门
	// if attriButeErr == nil {
	// 	if attriButeId != 0 {
	// 		gormDb = gormDb.Where("`s_depart_id` = ?", attriButeId)
	// 	} else {
	// 		groupId, groupIdErr := strconv.ParseInt(userCont.Group, 10, 64)
	// 		if groupIdErr == nil {
	// 			if groupId != 1 {
	// 				deparIsTrue, departMap := getGroupDepartIdMap(groupId)
	// 				if deparIsTrue == true {
	// 					if len(departMap.Id) > 0 {
	// 						gormDb = gormDb.Where("`s_depart_id` IN ?", departMap.Id)
	// 					}
	// 				}
	// 			}

	// 		}

	// 	}
	// }
	// scorErr := gormDb.Group("s_class").Find(&departScorsList).Error

	// if scorErr != nil {
	// 	response.Result(104, scorErr, "未能获取到数据！", c)
	// 	return
	// }

	// var departMonthList []departMonth
	// for _, val := range departScorsList {
	// 	var departMonthInfo departMonth
	// 	departMonthInfo.Id = val.ClassId
	// 	classErr, classInfo := assessment.GetDutyClassCont(val.ClassId)
	// 	if classErr == true {
	// 		departMonthInfo.Title = classInfo.Title
	// 	}
	// 	assErr, assList := GetAssList(val.ClassId, val.DepartId, assessmentTime)
	// 	if assErr == true {
	// 		departMonthInfo.Clide = assList
	// 	}
	// 	fmt.Printf("-------->%v----->%v\n", assErr, assList)
	// 	departMonthList = append(departMonthList, departMonthInfo)
	// }
	// outPrint := commonus.MapOut()
	// outPrint["list"] = departMonthList
	// response.Result(0, outPrint, "获取成功！", c)
	var departScorsList []assessmentmodel.Departscores
	scorErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.Departscores{}).Select("s_class").Where("`s_depart_id` = ? AND `s_file_time` = ? AND `s_state` = 1", requestData.DepartID, assessmentTime).Group("s_class").Find(&departScorsList).Error
	if scorErr != nil {
		response.Result(104, scorErr, "未能获取到数据！", c)
		return
	}
	departIdInt, _ := strconv.ParseInt(requestData.DepartID, 10, 64) //部门ID转换成int64
	var departMonthList []departMonth
	for _, val := range departScorsList {
		var departMonthInfo departMonth
		departMonthInfo.Id = val.ClassId
		classErr, classInfo := assessment.GetDutyClassCont(val.ClassId)
		if classErr == true {
			departMonthInfo.Title = classInfo.Title
		}
		assErr, assList := GetAssList(val.ClassId, departIdInt, assessmentTime)
		if assErr == true {
			departMonthInfo.Clide = assList
		}
		departMonthList = append(departMonthList, departMonthInfo)
	}
	outPrint := commonus.MapOut()
	outPrint["list"] = departMonthList
	response.Result(0, outPrint, "获取成功！", c)

}

// 获取集团下属分厂
func getGroupDepartIdMap(groupId int64) (isTrue bool, departId getGroupDepart) {
	isTrue = false
	err, departCont := examtestpage.GetBranchFactoryMap(groupId)
	if err != true {
		return
	}
	var idAry []int64
	for _, val := range departCont {
		idAry = append(idAry, val.Id)
	}
	departId.Id = idAry
	return
}

// 获取考核项目列表
func GetAssList(classId, depart, timeVal int64) (isTrue bool, departMonthAss []departMonthSun) {
	isTrue = false
	var departScorsList []assessmentmodel.Departscores
	scorErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.Departscores{}).Select("s_assess").Where("`s_depart_id` = ? AND `s_file_time` = ? AND `s_class` = ? AND `s_state` = 1", depart, timeVal, classId).Group("s_assess").Find(&departScorsList).Error
	if scorErr != nil {
		return
	}
	for _, val := range departScorsList {
		var departMonthSunsInfo departMonthSun
		departMonthSunsInfo.Id = val.AssessId

		classErr, classInfo := assessment.GetAssessClass(val.AssessId)
		if classErr == true {
			departMonthSunsInfo.Title = classInfo.Title
		}
		isErr, userDuty := GetDetailedDuty(classId, val.AssessId, depart, timeVal)
		if isErr == true {
			departMonthSunsInfo.Clide = userDuty
		}
		departMonthAss = append(departMonthAss, departMonthSunsInfo)
	}
	isTrue = true
	return
}

// 获取具体考核项目
func GetDetailedDuty(classId, assId, depart, timeVal int64) (isTrue bool, departMonthUser []departMonthSun) {
	isTrue = false
	var departScorsList []commentUser
	scorErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.Departscores{}).Select("s_comment_user").Where("`s_depart_id` = ? AND `s_file_time` = ? AND `s_class` = ? AND `s_assess` = ? AND `s_state` = 1", depart, timeVal, classId, assId).Group("s_comment_user").Find(&departScorsList).Error
	// fmt.Printf("----------->%v\n", departScorsList)
	if scorErr != nil {
		return
	}
	// var departMonthUser []departMonthSun
	for _, val := range departScorsList {
		var departMonthUserInfo departMonthSun
		departMonthUserInfo.Id = val.UserKey
		usCont, usErr := archiveapi.GetUserInfo([]string{"worker_man.wm_number", "worker_man_data.wmd_name", "worker_man.wm_bf_id", "worker_man.wm_ws_id", "worker_man.wm_pt_id", "worker_man.wm_group"}, map[string]interface{}{"wm_key": val.UserKey})
		if usErr == true {
			departMonthUserInfo.Title = usCont.Name

			isTrueBranFact, branFactCont := assessment.GetBranchFactory(usCont.DepartmentId)
			if isTrueBranFact == true {
				departMonthUserInfo.DepartTitle = branFactCont.Name
			}

		}

		dutyErr, dutyMap := GetDutyContAry(classId, assId, depart, val.UserKey, timeVal)
		if dutyErr == true {
			departMonthUserInfo.List = dutyMap
		}

		departMonthUser = append(departMonthUser, departMonthUserInfo)
	}
	isTrue = true
	return
}

// 获取考核具体职责项目
func GetDutyContAry(classId, assId, depart, userKey, timeVal int64) (isTrue bool, dutyList []departDutyList) {
	// fmt.Printf("--->%v--->%v\n", classId, assId)
	isTrue = false
	var dutyListMAp []departDutyList
	scorErr := global.GVA_DB_Performanceappraisal.Where("`s_depart_id` = ? AND `s_file_time` = ? AND `s_class` = ? AND `s_assess` = ? AND `s_comment_user` = ? AND `s_state` = 1", depart, timeVal, classId, assId, userKey).Find(&dutyListMAp).Error
	if scorErr != nil {
		return
	}
	// fmt.Printf("1--->%v--->%v\n", classId, assId)
	for _, val := range dutyListMAp {
		// fmt.Printf("2--->%v--->%v\n", classId, assId)
		var dutyCont departDutyList

		dutyCont.Id = val.Id
		dutyCont.ClassId = val.ClassId
		dutyCont.AssessId = val.AssessId
		dutyCont.DutyId = val.DutyId
		dutyCont.DeductPoints = val.DeductPoints
		dutyCont.ExtraPoints = val.ExtraPoints
		dutyCont.Score = val.Score
		dutyCont.FileTime = val.FileTime
		dutyCont.DepartId = val.DepartId
		dutyCont.CommentUser = val.CommentUser
		dutyCont.AddTime = val.AddTime
		dutyCont.EiteTime = val.EiteTime
		dutyCont.State = val.State
		dtyContErr, dtyCont := GetDutyInfoCont(val.DutyId)

		if dtyContErr == true {
			dutyCont.DutyTitle = dtyCont.DutyTitle
		}
		dutyList = append(dutyList, dutyCont)
	}
	isTrue = true
	return
}

// 获取职责类别内容
func GetDutyInfoCont(id int64) (isTrue bool, outAssDutyInfo outAessDuty) {
	isTrue = false
	var ContInfo dutyAssClass
	err := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DutyContent{}).Select("dc_title", "dc_parent", "ai_title", "ai_parent").Joins("left join assessmentitems on assessmentitems.ai_id = dutycontent.dc_parent").Where("dc_id = ?", id).First(&ContInfo).Error
	if err != nil {
		return
	}
	outAssDutyInfo.AssessId = ContInfo.PartId
	outAssDutyInfo.AssessTitle = ContInfo.AssTitle
	outAssDutyInfo.DutyTitle = ContInfo.Title
	outAssDutyInfo.ClassId = ContInfo.AssPartId
	classErr, classInfo := assessment.GetDutyClassCont(ContInfo.AssPartId)
	if classErr == true {
		outAssDutyInfo.ClassTitle = classInfo.Title
	}
	isTrue = true
	return
}

// 查看定量考核目标设定
func (e *DutyAssessApi) LookQuantitativeConfig(c *gin.Context) {
	var requestData SelectQuantitativeConfig
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	// var qualConfigList []assessmentmodel.QuantitativeConfig
	var qualConfigList []assessmentmodel.QuantitativeConfigView
	gormDb := global.GVA_DB_Performanceappraisal
	if requestData.GroupId != "" {
		gormDb = gormDb.Where("`group` = ?", requestData.GroupId)
	}
	if requestData.DepartmentID != "" {
		gormDb = gormDb.Where("`departmentid` = ?", requestData.DepartmentID)
	}
	if requestData.Dimension != "" {
		gormDb = gormDb.Where("`dimension` = ?", requestData.Dimension)
	}
	if requestData.Target != "" {
		gormDb = gormDb.Where("`target` = ?", requestData.Target)
	}
	if requestData.DetailedTarget != "" {
		gormDb = gormDb.Where("`targetconfig` = ?", requestData.DetailedTarget)
	}
	switch requestData.Type {
	case 1:
		gormDb = gormDb.Where("`type` = ?", requestData.Type)
	case 2:
		gormDb = gormDb.Where("`type` = ?", requestData.Type)
		if requestData.Class != 0 {
			gormDb = gormDb.Where("`timecopy` = ?", requestData.Class)
		}
	case 3:
		gormDb = gormDb.Where("`type` = ?", requestData.Type)
		if requestData.Class != 0 {
			gormDb = gormDb.Where("`timecopy` = ?", requestData.Class)
		}
	default:
	}
	if requestData.Year != 0 {
		gormDb = gormDb.Where("`year` = ?", requestData.Year)
	}
	if requestData.State != 0 {
		gormDb = gormDb.Where("`state` = ?", requestData.State)
	}
	if requestData.Title != "" {
		gormDb = gormDb.Where("`title` LIKE ?", "%"+requestData.Title+"%")
	}
	// gormDb = gormDb.Order("group ASC,departmentid ASC,dimension ASC,target ASC,targetconfig ASC").Order("year DESC").Order("timecopy ASC,id ASC")
	gormDb = gormDb.Order("`group` ASC").Order("`departmentid` ASC").Order("`dimension` ASC").Order("`target` ASC").Order("`targetconfig` ASC").Order("`year` DESC").Order("`timecopy` ASC").Order("`id` ASC")
	contErr := gormDb.Find(&qualConfigList).Error
	if contErr != nil {
		response.Result(102, err, "没有数据！", c)
		return
	}
	var outList []OutQuantitativeConfig
	for _, v := range qualConfigList {
		var outCont OutQuantitativeConfig
		outCont.Id = v.Id
		outCont.DepartmentId = v.DepartmentId
		outCont.Group = v.Group
		outCont.Dimension = v.Dimension
		outCont.Target = v.Target
		outCont.TargetConfig = v.TargetConfig
		outCont.Type = v.Type
		outCont.Year = v.Year
		outCont.Timecopy = v.Timecopy
		outCont.Zeroprize = v.Zeroprize / 100
		outCont.Allprize = v.Allprize / 100
		outCont.Time = v.Time
		outCont.State = v.State
		outCont.DimensionId = strconv.FormatInt(v.Dimension, 10)

		where := commonus.MapOut()
		where["id"] = v.Group
		orgCont, _ := commonus.GetNewOrgCont(where, "id", "name")
		outCont.GroupTitle = orgCont.Name
		// gErr, groupInfo := commonus.GetGroupCont(v.Group)
		// if gErr == true {
		// 	outCont.GroupTitle = groupInfo.Name
		// }
		whereDepart := commonus.MapOut()
		whereDepart["id"] = v.DepartmentId
		orgContDepart, _ := commonus.GetNewOrgCont(whereDepart, "id", "name")
		outCont.DimensionTitle = orgContDepart.Name

		// dErr, departmentInfo := commonus.GetBranchFactory(v.DepartmentId)
		// if dErr == true {
		// 	outCont.DimensionTitle = departmentInfo.Name
		// }
		// targetInfo, tErr := commonus.GetTargetInfo(v.Target)
		// if tErr == true {
		// 	outCont.TargetTitle = targetInfo.Title
		// }
		outCont.TargetTitle = v.Title
		if v.TargetConfig != 0 {
			dtargetInfo, dtErr := commonus.GetDetailedTargetInfo(v.TargetConfig)
			if dtErr == true {
				outCont.DetailedTargetTitle = dtargetInfo.Title
			}
		}

		outCont.Capping = v.Capping
		outCont.CappingVal = v.CappingVal / 100
		outList = append(outList, outCont)
	}
	response.Result(0, outList, "获取成功！", c)
}

// 删除部门考核指标(New)
func (d *DutyAssessApi) DelDepartDutyTarger(c *gin.Context) {
	var requestData DelDutyDepartTarget
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if requestData.Group == "" {
		response.Result(102, err, "数据获取失败！", c)
		return
	}
	if requestData.DeaprtId == "" {
		response.Result(103, err, "数据获取失败！", c)
		return
	}
	if requestData.Dimension == "" {
		response.Result(104, err, "数据获取失败！", c)
		return
	}
	if requestData.TargetId == "" {
		response.Result(105, err, "数据获取失败！", c)
		return
	}

	eiteCont := commonus.MapOut()
	eiteCont["State"] = 3
	eiteCont["qe_eitetime"] = time.Now().Unix()
	delErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Where("`qe_group` = ? AND `qe_accept_evaluation` = ? AND `qe_dimension` = ? AND `qe_target` = ?", requestData.Group, requestData.DeaprtId, requestData.Dimension, requestData.TargetId).Updates(eiteCont).Error
	if delErr != nil {
		response.Result(106, delErr, "数据处理失败！", c)
		return
	}
	response.Result(0, eiteCont, "处理成功", c)
}

// 删除部门考核方案
func (d *DutyAssessApi) DelDepartDuty(c *gin.Context) {
	var requestData DelDutyDepartTarget
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if requestData.Group == "" {
		response.Result(102, err, "数据获取失败！", c)
		return
	}
	if requestData.DeaprtId == "" {
		response.Result(103, err, "数据获取失败！", c)
		return
	}

	eiteCont := commonus.MapOut()
	eiteCont["State"] = 3
	eiteCont["qe_eitetime"] = time.Now().Unix()
	delErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Where("`qe_group` = ? AND `qe_accept_evaluation` = ? ", requestData.Group, requestData.DeaprtId).Updates(eiteCont).Error
	if delErr != nil {
		response.Result(106, delErr, "数据处理失败！", c)
		return
	}
	response.Result(0, eiteCont, "处理成功", c)
}

// 获取定性考核相关部门
func (d *DutyAssessApi) GetDepartForDuty(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 assessInfor assessmentmodel.Assesstarget
	delErr := global.GVA_DB_Performanceappraisal.Where("`group` = ? AND `dimension` = ? AND `targetid` = ?", requestData.Group, requestData.Dimension, requestData.TargetId).First(&assessInfor).Error
	if delErr != nil {
		response.Result(106, delErr, "获取失败失败！", c)
		return
	}
	var assessList []assessmentmodel.Assesstarget
	global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.Assesstarget{}).Select("`departmentmap`").Where("`group` = ? AND `dimension` = ? AND `targetid` = ?", requestData.Group, requestData.Dimension, requestData.TargetId).Find(&assessList)

	var departmentAry []string
	for _, asv := range assessList {
		gdAry := strings.Split(asv.Departmentmap, ",")
		if len(gdAry) > 0 {
			for _, gdv := range gdAry {
				if commonus.IsInTrue[string](gdv, departmentAry) == false {
					departmentAry = append(departmentAry, gdv)
				}
			}
		}
	}

	var outInfor OutDutyListes
	outInfor.DepartmentId, outInfor.DepartmentAry = commonus.GetBranchDepartAry(departmentAry)

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

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

	outInfor.DepartmentId, outInfor.DepartmentAry = commonus.GetBranchDepartAry(departmentAry)

	shenPiRen := strings.Split(tarCont.Report, ",")
	outInfor.UserList = shenPiRen
	for _, v := range shenPiRen {
		usCont, usErr := commonus.GetWorkUser(v)
		// GetWorkUser
		if usErr == true {
			var userCont QualEvalArrt
			userCont.Id = 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
			outInfor.UserListAry = append(outInfor.UserListAry, userCont)
		}
	}
	response.Result(0, outInfor, "获取成功！", c)
}

// 修改已知定性考核指标关联部门
func (d *DutyAssessApi) EiteDepartForDuty(c *gin.Context) {
	var requestData EiteDutyForDepart
	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 len(requestData.DepartAry) < 1 {
		response.Result(105, err, "请指定所属部门！", c)
		return
	}
	//获取所有子栏目
	var sunTargetId []int64
	global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.Assesstarget{}).Select("suntargetid").Where("`group` = ? AND `dimension` = ? AND `targetid` = ?", requestData.Group, requestData.Dimension, requestData.TargetId).Find(&sunTargetId)

	saveData := commonus.MapOut()
	saveData["departmentmap"] = strings.Join(requestData.DepartAry, ",")
	saveData["time"] = time.Now().Unix()
	delErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.Assesstarget{}).Where("`group` = ? AND `dimension` = ? AND `targetid` = ?", requestData.Group, requestData.Dimension, requestData.TargetId).Updates(saveData).Error
	if delErr != nil {
		response.Result(106, delErr, "编辑失败！", c)
		return
	}
	// //修改相关子类
	if len(sunTargetId) > 0 {
		saveDataSun := commonus.MapOut()
		saveDataSun["q_depart"] = strings.Join(requestData.DepartAry, ",")
		saveDataSun["q_time"] = time.Now().Unix()
		global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeTarget{}).Where("`q_id` IN ?", sunTargetId).Updates(saveDataSun)
	}
	//考核细则
	var detarTarget []string
	global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.Assesstarget{}).Select("content").Where("`group` = ? AND `dimension` = ? AND `targetid` = ?", requestData.Group, requestData.Dimension, requestData.TargetId).Find(&detarTarget)
	if len(detarTarget) > 0 {
		for _, dtv := range detarTarget {
			var detarCont []DutyAssEssTarget
			jsonErr := json.Unmarshal([]byte(dtv), detarCont)
			if jsonErr == nil {
				if len(detarCont) > 0 {
					for _, dcv := range detarCont {
						eiteDetailedTarget := commonus.MapOut()
						eiteDetailedTarget["dt_id"] = dcv.Id
						savDTCont := commonus.MapOut()
						savDTCont["dt_paretment"] = strings.Join(requestData.DepartAry, ",")
						savDTCont["dt_time"] = time.Now().Unix()
						global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DetailedTarget{}).Where(eiteDetailedTarget).Updates(savDTCont)
					}

				}
			}
		}

	}

	response.Result(0, sunTargetId, "编辑成功！", c)
}

// 查看考核方案
func (d *DutyAssessApi) LookDepartDutyVersio(c *gin.Context) {
	var requestData LookDutyVersio
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if requestData.Key == "" {
		response.Result(102, err, "数据获取失败！", c)
		return
	}
	//获取考核方案
	var assessTargetContent assessmentmodel.PlanVersio

	planVersioErr := global.GVA_DB_Performanceappraisal.Where("`key` = ?", requestData.Key).First(&assessTargetContent).Error
	if planVersioErr != nil {
		response.Result(103, planVersioErr, "数据获取失败！", c)
		return
	}
	var uotContAry []TargetContOutCont
	if assessTargetContent.Content != "" {
		var planVersioInfo []AddDutyNewCont
		jsonErr := json.Unmarshal([]byte(assessTargetContent.Content), &planVersioInfo)
		if jsonErr == nil {
			for _, pv := range planVersioInfo { //维度
				for _, pvChild := range pv.Child { //指标
					if pvChild.Status == 1 || pvChild.Status == 3 { //判断是不是禁止指标
						var uotCont TargetContOutCont
						//集团
						uotCont.Group = strconv.FormatInt(assessTargetContent.Group, 10)
						if assessTargetContent.Group != 0 {
							where := commonus.MapOut()
							where["id"] = assessTargetContent.Group
							orgCont, _ := commonus.GetNewOrgCont(where, "id", "name")
							uotCont.GroupNAme = orgCont.Name
						}
						//部门
						uotCont.DepartmentId = strconv.FormatInt(assessTargetContent.Department, 10)
						// where := commonus.MapOut()
						// where["id"] = assessTargetContent.Group
						// orgCont, _ := commonus.GetNewOrgCont(where, "id", "name")
						// uotCont.GroupNAme = orgCont.Name
						//维度
						uotCont.Id = pvChild.Id
						uotCont.Dimension = pv.Id
						uotCont.DimensionName = pv.Name
						uotCont.DimensionWeight = int64(pv.ZhiFraction)
						//指标
						uotCont.Target = pvChild.Id
						uotCont.TargetName = pvChild.Name
						uotCont.TargetWeight = pvChild.ReferenceScore
						uotCont.Unit = pvChild.Unit
						uotCont.Content = pvChild.Content
						uotCont.State = pvChild.Status
						//获取指标内容
						var qualEvalContInfo assessmentmodel.QualitativeEvaluation
						qualEvalErr := global.GVA_DB_Performanceappraisal.Where("`qe_qual_eval_id` = ? AND qe_dimension = ? AND qe_target = ? AND qe_accept_evaluation = ?", requestData.Key, pv.Id, pvChild.Id, assessTargetContent.Department).First(&qualEvalContInfo).Error
						if qualEvalErr == nil {
							uotCont.Type = qualEvalContInfo.Type
							if pvChild.Cycles == 0 {
								uotCont.Cycles = qualEvalContInfo.Cycles
							} else {
								uotCont.Cycles = pvChild.Cycles
							}

							if pvChild.CycleAttres == 0 {
								uotCont.CycleAttres = qualEvalContInfo.CycleAttres
							} else {
								uotCont.CycleAttres = pvChild.CycleAttres
							}

							// uotCont.CycleAttres = qualEvalContInfo.CycleAttres
							uotCont.UserListAry, uotCont.UserList, _ = getQualEvalUser(requestData.Key, pv.Id, pvChild.Id)
						} else {
							var evalTargerCont assessmentmodel.EvaluationTarget
							evalErr := global.GVA_DB_Performanceappraisal.Where("`et_id` = ?", pvChild.Id).First(&evalTargerCont).Error
							if evalErr == nil {
								uotCont.Type = evalTargerCont.Type
								// uotCont.Cycles = evalTargerCont.Cycles
								// uotCont.CycleAttres = evalTargerCont.CycleAttres
								// if uotCont.Type == 1 {
								// } else {

								// }
								if pvChild.Cycles == 0 {
									uotCont.Cycles = evalTargerCont.Cycles
								} else {
									uotCont.Cycles = pvChild.Cycles
								}

								if pvChild.CycleAttres == 0 {
									uotCont.CycleAttres = evalTargerCont.CycleAttres
								} else {
									uotCont.CycleAttres = pvChild.CycleAttres
								}
								//获取执行人
								uotCont.UserListAry, uotCont.UserList, _ = getQualEvalUser(requestData.Key, pv.Id, pvChild.Id)
							}
						}

						uotCont.QualEvalId = requestData.Key
						uotContAry = append(uotContAry, uotCont)
					}
					// return
				}
			}
		} else {
			var uotErr bool = false
			uotContAry, uotErr = getLookAssessQualEvalList(requestData.Key)
			if uotErr == false {
				response.Result(103, uotErr, "数据获取失败！", c)
				return
			}
		}
	} else {
		var uotErr bool = false
		uotContAry, uotErr = getLookAssessQualEvalList(requestData.Key)
		if uotErr == false {
			response.Result(103, uotErr, "数据获取失败！", c)
			return
		}
	}
	// var uotErr bool = false
	// uotContAry, uotErr = getLookAssessQualEvalList(requestData.Key)
	// if uotErr == false {
	// 	return
	// }
	response.Result(0, uotContAry, "数据获取成功！", c)
}

//获取执行人
/*
@key				版本号码
@dimensionId		维度
@targetId			指标
*/
func getQualEvalUser(key, dimensionId, targetId string) (userContAry []QualEvalArrt, userKey []string, istrue bool) {
	istrue = false
	var qualEvalCont []assessmentmodel.QualitativeEvaluation
	listTargetErr := global.GVA_DB_Performanceappraisal.Select("qe_operator").Where("`qe_dimension` = ? AND `qe_target` = ? AND `qe_qual_eval_id` = ?", dimensionId, targetId, key).Find(&qualEvalCont).Error
	if listTargetErr != nil {
		return
	}
	// var userKey []string
	for _, v := range qualEvalCont {
		//判断执行人是否为空
		if v.Operator != "" {
			//解析执行人数值
			userCont := strings.Split(v.Operator, ",")
			if len(userCont) > 0 {
				for _, uv := range userCont {
					//判断执行人是否已经存在
					if commonus.IsItTrueString(uv, userKey) == false {
						userKey = append(userKey, uv)
					}
				}

			}
		}

	}
	//获取执行人信息
	if len(userKey) > 0 {
		for _, ukv := range userKey {
			usWhere := commonus.MapOut()
			usWhere["`key`"] = ukv
			usCont, usErr := commonus.GetNewHrPeopleInfo(usWhere, "`number`", "`name`", "`company`", "`maindeparment`", "`deparment`", "`icon`")
			if usErr == true {
				var userCont QualEvalArrt
				userCont.Id = ukv
				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
				userContAry = append(userContAry, userCont)

			}
		}

	}
	return
}

// 获取部门考核项目
func getLookAssessQualEvalList(Key string) (uotContAry []TargetContOutCont, errMsg bool) {
	errMsg = false
	var qualitativeEvaluationAry []assessmentmodel.QualitativeEvaluation
	listTargetErr := global.GVA_DB_Performanceappraisal.Select("qualitative_evaluation.*,dutyclass.sort").Where("`qe_state` IN (1,2) AND `qe_qual_eval_id` = ?", Key).Joins("left join dutyclass on id = qe_dimension").Order("qe_group asc,qe_accept_evaluation asc,sort asc,qe_type asc,qe_target asc,qe_target_sun asc").Find(&qualitativeEvaluationAry).Error

	if listTargetErr != nil || len(qualitativeEvaluationAry) < 1 {
		return
	}
	// var uotContAry []TargetContOutCont
	for _, v := range qualitativeEvaluationAry {
		var uotCont TargetContOutCont
		uotCont.Id = strconv.FormatInt(v.Id, 10)
		uotCont.Type = v.Type
		uotCont.Group = strconv.FormatInt(v.Group, 10)

		where := commonus.MapOut()
		where["id"] = v.Group
		orgCont, _ := commonus.GetNewOrgCont(where, "id", "name")
		uotCont.GroupNAme = orgCont.Name

		whereDepart := commonus.MapOut()
		whereDepart["id"] = v.AcceptEvaluation
		orgContDepart, _ := commonus.GetNewOrgCont(whereDepart, "id", "name")
		uotCont.DepartmentName = orgContDepart.Name

		// groupErr, groupCont := commonus.GetGroupCont(v.Group)
		// if groupErr == true {
		// 	uotCont.GroupNAme = groupCont.Name
		// }
		uotCont.DepartmentId = strconv.FormatInt(v.AcceptEvaluation, 10)
		// deparConErr, deparConCont := commonus.GetBranchFactory(v.AcceptEvaluation)
		// if deparConErr == true {
		// 	uotCont.DepartmentName = deparConCont.Name
		// }

		uotCont.Dimension = strconv.FormatInt(v.Dimension, 10)
		dutyClassCont, dutyClassErr := commonus.GetDutyClassInfo(v.Dimension)
		if dutyClassErr == true {
			uotCont.DimensionName = dutyClassCont.Title
		}
		uotCont.DimensionWeight = commonus.GetDimesionTargetWeight(1, v.Group, v.AcceptEvaluation, v.Dimension, 0)

		uotCont.Target = strconv.FormatInt(v.Target, 10)
		targetInfo, targetErr := commonus.GetTargetInfo(v.Target)
		if targetErr == true {
			uotCont.TargetName = targetInfo.Title
		}
		uotCont.TargetWeight = commonus.GetDimesionTargetWeight(2, v.Group, v.AcceptEvaluation, v.Dimension, v.Target)
		uotCont.TargetSun = strconv.FormatInt(v.TargetSun, 10)
		info, infoErr := commonus.GetQualitativeTargetInfo(v.TargetSun)
		if infoErr == true {
			uotCont.TargetSunName = info.Title
		}
		uotCont.DetailedTarget = strconv.FormatInt(v.DetailedTarget, 10)
		dtCont, dtIsTrue := commonus.GetDetailedTargetInfo(v.DetailedTarget)
		if dtIsTrue == true {
			uotCont.DetailedTargetName = dtCont.Title
			if v.Content == "" {
				uotCont.Content = dtCont.Content
			} else {
				uotCont.Content = v.Content
			}

		} else {
			uotCont.Content = v.Content
		}
		uotCont.QualEvalId = v.QualEvalId
		uotCont.Unit = v.Unit
		uotCont.ReferenceScore = v.ReferenceScore
		uotCont.Cycles = v.Cycles
		uotCont.CycleAttres = v.CycleAttres
		uotCont.State = v.State
		userAry := strings.Split(v.Operator, ",")
		uotCont.UserList = userAry
		for _, u_v := range userAry {
			// 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
			// 	uotCont.UserListAry = append(uotCont.UserListAry, userCont)
			// }
			usCont, usErr := commonus.GetWorkUser(u_v)
			// GetWorkUser
			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)
			}
		}

		if v.MinScore > 0 && v.MaxScore > 0 {
			uotCont.MinOrMaxScore = fmt.Sprintf("%v-%v", float64(v.MinScore)/100, float64(v.MaxScore)/100)
		} else if v.MinScore > 0 && v.MaxScore <= 0 {
			uotCont.MinOrMaxScore = fmt.Sprintf("%v", float64(v.MinScore)/100)
		} else if v.MinScore <= 0 && v.MaxScore > 0 {
			uotCont.MinOrMaxScore = fmt.Sprintf("%v", float64(v.MaxScore)/100)
		} else {
			uotCont.MinOrMaxScore = "0"
		}

		uotCont.DetailedTarget = strconv.FormatInt(v.DetailedTarget, 10)
		uotContAry = append(uotContAry, uotCont)
	}
	errMsg = true
	return
}

// 查看考核方案
func (d *DutyAssessApi) CopyDepartDutyVersio(c *gin.Context) {
	var requestData LookDutyVersio
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if requestData.Key == "" {
		response.Result(102, err, "数据获取失败！", c)
		return
	}
	//获取考核方案
	var assessTargetContent assessmentmodel.PlanVersio

	planVersioErr := global.GVA_DB_Performanceappraisal.Where("`key` = ?", requestData.Key).First(&assessTargetContent).Error
	if planVersioErr != nil {
		response.Result(103, planVersioErr, "数据获取失败！", c)
		return
	}
	var copyCont CopyPlanVersion
	copyCont.Group = strconv.FormatInt(assessTargetContent.Group, 10)
	copyCont.Department = strconv.FormatInt(assessTargetContent.Department, 10)
	copyCont.Year = fmt.Sprintf("%v", assessTargetContent.Year)
	if assessTargetContent.Content != "" {
		var planVersioInfo []AddDutyNewCont
		jsonErr := json.Unmarshal([]byte(assessTargetContent.Content), &planVersioInfo)

		if jsonErr == nil {
			var copyInfoAry []CopyDutyNewCont
			for _, v := range planVersioInfo {
				var copyInfoXonr CopyDutyNewCont
				copyInfoXonr.Id = v.Id //维度ID
				copyInfoXonr.Name = v.Name
				copyInfoXonr.ZhiFraction = v.ZhiFraction
				var displayTargetId []string
				for _, cv := range v.Child {
					var copyEvalCont CopyEvaluPross
					copyEvalCont.Id = cv.Id //`json:"id"` //指标ID
					if commonus.IsInTrue[string](cv.Id, displayTargetId) == false {
						displayTargetId = append(displayTargetId, cv.Id)
					}
					var tarGetContent assessmentmodel.EvaluationTarget
					tarGetContentErr := tarGetContent.GetCont(map[string]interface{}{"et_id": cv.Id}, "et_title")
					if tarGetContentErr == nil {
						copyEvalCont.Name = tarGetContent.Title
					} else {
						copyEvalCont.Name = cv.Name //`json:"name"`
					}

					copyEvalCont.Content = cv.Content               //`json:"content"`        //指标说明
					copyEvalCont.Unit = cv.Unit                     //`json:"unit"`           //单位"`
					copyEvalCont.ReferenceScore = cv.ReferenceScore //`json:"referencescore"` //标准分值"`
					if cv.Status == 0 {
						copyEvalCont.State = 2
					} else {
						copyEvalCont.State = cv.Status //`json:"state"`
					}

					copyEvalCont.Istrue = 2 //`json:"istrue"` //是否允许修改

					copyInfoXonr.Child = append(copyInfoXonr.Child, copyEvalCont)
				}
				if len(displayTargetId) > 0 {
					copyEvalContFuBen := GetTargetGroup(strconv.FormatInt(assessTargetContent.Group, 10), v.Id, strconv.FormatInt(assessTargetContent.Department, 10))
					// var copyEvalContAry []CopyEvaluPross
					for _, cecfv := range copyEvalContFuBen {
						if commonus.IsInTrue[string](cecfv.Id, displayTargetId) == false {
							var copyEvalCont CopyEvaluPross
							copyEvalCont.Id = cecfv.Id
							copyEvalCont.Name = cecfv.Name
							copyEvalCont.Content = cecfv.Content
							copyEvalCont.Unit = cecfv.Unit
							copyEvalCont.ReferenceScore = 0
							copyEvalCont.State = cecfv.State
							copyEvalCont.Istrue = cecfv.IsTrue
							// copyEvalContAry = append(copyEvalContAry, copyEvalCont)
							copyInfoXonr.Child = append(copyInfoXonr.Child, copyEvalCont)
						}

					}

				} else {

					copyEvalContFuBen := GetTargetGroup(strconv.FormatInt(assessTargetContent.Group, 10), v.Id, strconv.FormatInt(assessTargetContent.Department, 10))
					// var copyEvalContAry []CopyEvaluPross
					for _, cecfv := range copyEvalContFuBen {
						var copyEvalCont CopyEvaluPross
						copyEvalCont.Id = cecfv.Id
						copyEvalCont.Name = cecfv.Name
						copyEvalCont.Content = cecfv.Content
						copyEvalCont.Unit = cecfv.Unit
						copyEvalCont.ReferenceScore = 0
						copyEvalCont.State = cecfv.State
						copyEvalCont.Istrue = cecfv.IsTrue
						copyInfoXonr.Child = append(copyInfoXonr.Child, copyEvalCont)
					}
				}

				copyInfoAry = append(copyInfoAry, copyInfoXonr)
			}
			copyCont.Child = copyInfoAry
		}
	}
	response.Result(0, copyCont, "查询完成！", c)
}

// 修改考核目标设置
func (e *DutyAssessApi) EiteQuantitativeConfig(c *gin.Context) {
	var requestData []EiteQuantConfig
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if len(requestData) < 1 {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	for _, v := range requestData {
		eiteCont := commonus.MapOut()
		eiteCont["allprize"] = v.Allprize * 100
		eiteCont["zeroprize"] = v.Zeroprize * 100
		eiteCont["capping_val"] = v.Capping * 100
		err = global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QuantitativeConfig{}).Where("`id` = ?", v.Id).Updates(eiteCont).Error
	}
	if err != nil {
		response.Result(101, err, "数据编辑失败！", c)
	} else {
		response.Result(0, err, "数据编辑成功！", c)
	}
}

// 修改考核目标设置
func (e *DutyAssessApi) DelQuantitativeConfig(c *gin.Context) {
	var requestData []string
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if len(requestData) < 1 {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	err = global.GVA_DB_Performanceappraisal.Where("`id` IN ?", requestData).Delete(&assessmentmodel.QuantitativeConfig{}).Error
	if err != nil {
		response.Result(101, err, "删除失败！", c)
	} else {
		response.Result(0, err, "删除成功！", c)
	}
}