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

package dutyassess

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

	"github.com/flipped-aurora/gin-vue-admin/server/api/v1/archiveapi"
	"github.com/flipped-aurora/gin-vue-admin/server/api/v1/assessment"
	"github.com/flipped-aurora/gin-vue-admin/server/api/v1/examtestpage"
	"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) 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
	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)
	}
	// 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
		}
		dtargetInfo, dtErr := commonus.GetDetailedTargetInfo(v.TargetConfig)
		if dtErr == true {
			outCont.DetailedTargetTitle = dtargetInfo.Title
		}
		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 outInfor OutDutyListes
	outInfor.DepartmentId, outInfor.DepartmentAry = commonus.GetBranchDepartAry(strings.Split(assessInfor.Departmentmap, ","))

	// 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(strings.Split(assessInfor.Departmentmap, ","))

	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.Group
			orgCont, _ := commonus.GetNewOrgCont(where, "id", "name")
			userCont.GroupName = orgCont.Name

			whereDepart := commonus.MapOut()
			whereDepart["id"] = usCont.DepartmentId
			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)
}