package dutyassess

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

	"github.com/flipped-aurora/gin-vue-admin/server/commonus"
	"github.com/flipped-aurora/gin-vue-admin/server/global"
	"github.com/flipped-aurora/gin-vue-admin/server/model/assessmentmodel"
	"github.com/flipped-aurora/gin-vue-admin/server/model/common/response"
	"github.com/gin-gonic/gin"
)

//获取正在激活的考核方案
func (d *DutyAssessApi) GetActivationPlanVersion(c *gin.Context) {
	var requestData DutyPlanVersio
	c.ShouldBindJSON(&requestData)
	if requestData.Group == "" {
		response.Result(101, requestData, "请选择集团！", c)
		return
	}
	if requestData.DeaprtId == "" {
		response.Result(101, requestData, "请选择部门！", c)
		return
	}
	gormDb := global.GVA_DB_Performanceappraisal
	gormDb = gormDb.Where("`group` = ?", requestData.Group)
	gormDb = gormDb.Where("`department` = ?", requestData.DeaprtId)
	gormDb = gormDb.Where("`state` = 1")
	var planVersio []DutyPlanVersioOut
	dataErr := gormDb.Order("`addtime` DESC").Find(&planVersio).Error
	if dataErr != nil {
		response.Result(104, dataErr, "没有查询到数据", c)
		return
	}
	response.Result(0, planVersio, "获取成功", c)
}

//部门考核方案版本列表
func (d *DutyAssessApi) DepartDutyPlanVersion(c *gin.Context) {
	var requestData DutyPlanVersio
	err := c.ShouldBindJSON(&requestData)

	if err != nil {
		// response.Result(101, err, "数据获取失败！", c)
		// return
	}
	gormDb := global.GVA_DB_Performanceappraisal
	if requestData.Group != "" {
		gormDb = gormDb.Where("`group` = ?", requestData.Group)
	}
	if requestData.DeaprtId != "" {
		gormDb = gormDb.Where("`department` = ?", requestData.DeaprtId)
	}
	if requestData.Year != "" {
		gormDb = gormDb.Where("`yeares` = ?", requestData.Year)
	}
	if requestData.Versio != "" {
		gormDb = gormDb.Where("`versio` LIKE ?", "%"+requestData.Versio+"%")
	}
	if requestData.VersioNum != "" {
		gormDb = gormDb.Where("`key` LIKE ?", "%"+requestData.VersioNum+"%")
	}
	if requestData.State != 0 {
		gormDb = gormDb.Where("`state` = ?", requestData.State)
	} else {
		gormDb = gormDb.Where("`state` IN (1,2)")
	}
	// response.Result(104, requestData, "没有查询到数据", c)
	// return
	var planVersio []DutyPlanVersioOut
	// dataErr := gormDb.Order("`group` ASC").Order("`department` ASC").Order("`state` ASC").Order("`addtime` ASC").Find(&planVersio).Error
	dataErr := gormDb.Order("`group` ASC").Order("`department` ASC").Order("`addtime` DESC").Find(&planVersio).Error
	if dataErr != nil {
		response.Result(104, dataErr, "没有查询到数据", c)
		return
	}
	for i, v := range planVersio {
		where := commonus.MapOut()
		where["id"] = v.Group
		orgCont, _ := commonus.GetNewOrgCont(where, "id", "name")
		planVersio[i].GroupName = orgCont.Name
		// _, groupCont := commonus.GetGroupCont(v.Group)
		// planVersio[i].GroupName = groupCont.Name
		whereDepart := commonus.MapOut()
		whereDepart["id"] = v.Department
		orgContDepart, _ := commonus.GetNewOrgCont(whereDepart, "id", "name")
		planVersio[i].DeaprtName = orgContDepart.Name
		// _, departMent := commonus.GetBranchFactory(v.Department)
		// planVersio[i].DeaprtName = departMent.Name
		planVersio[i].Time = commonus.TimeStampToDate(v.AddTime, 20)
	}
	response.Result(0, planVersio, "获取成功", c)
}

//添加部门考核方案（待版本号的版本）
func (d *DutyAssessApi) AddDepartDutyVersio(c *gin.Context) {
	var requestData AddDutyNewContGroup
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if requestData.Group == "" {
		response.Result(102, err, "数据获取失败！", c)
		return
	}
	groupId, groupErr := strconv.ParseInt(requestData.Group, 10, 64) //集团ID
	if groupErr != nil {
		groupId = 0
	}

	where := commonus.MapOut()
	where["id"] = groupId
	orgCont, _ := commonus.GetNewOrgCont(where, "id", "abbreviation")
	groupInitials := commonus.ChinaToPinYinFirstWord(orgCont.Abbreviation) //获取集团首字母

	// _, groupCont := commonus.GetGroupCont(groupId)
	// groupInitials := commonus.ChinaToPinYinFirstWord(groupCont.Name) //获取集团首字母
	if requestData.DepartmentId == "" {
		response.Result(103, err, "数据获取失败！", c)
		return
	}
	departId, departErr := strconv.ParseInt(requestData.DepartmentId, 10, 64) //部门ID
	if departErr != nil {
		departId = 0
	}
	if requestData.Year == "" {
		response.Result(104, requestData, "请选择年份", c)
		return
	}
	yearInt, _ := strconv.ParseInt(requestData.Year, 10, 64) //部门ID

	if len(requestData.Child) < 0 {
		response.Result(105, err, "没有要添加的数据", c)
		return
	}
	judgeState := 1
	//判断是否有新生成的方案
	var versionState []int
	judgeVersio := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.PlanVersio{}).Select("`state`").Where("`group` = ? AND `department` = ?", requestData.Group, requestData.DepartmentId).Find(&versionState).Error //判断是否有启用的方案
	if judgeVersio == nil {
		for _, s_v := range versionState {
			if s_v == 1 {
				judgeState = 2
			}
		}
	}
	var versioNum string
	//判断年度是否存在版本
	var sumVerson float64
	judgeVersioNum := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.PlanVersio{}).Select("`id`").Where("`group` = ? AND  `yeares` = ?", requestData.Group, requestData.Year).Pluck("COALESCE(COUNT(id), 0) as countid", &sumVerson).Error
	// fmt.Printf("sumVerson---->%v\n", sumVerson)
	if judgeVersioNum == nil {
		if sumVerson == 0 {
			versioNum = "0001"
		} else {
			sumVerson++
			versioNum = fmt.Sprintf("%04v", sumVerson)
			// if sumVerson <= 9999 {
			// 	versioNumGuoDu := strconv.FormatFloat(sumVerson/10000, 'f', -1, 64)
			// 	versioNumAry := strings.Split(versioNumGuoDu, ".")
			// 	if len(versioNumAry) == 2 {
			// 		versioNum = versioNumAry[1]
			// 	} else {
			// 		versioNum = "0001"
			// 	}
			// } else {
			// 	versioNumGuoDu := strconv.FormatFloat(sumVerson/10000000, 'f', -1, 64)
			// 	versioNumAry := strings.Split(versioNumGuoDu, ".")
			// 	if len(versioNumAry) == 2 {
			// 		versioNum = versioNumAry[1]
			// 	} else {
			// 		versioNum = "0001"
			// 	}
			// }

		}
	} else {
		versioNum = "0001"
	}
	todyTime := time.Now().Unix()
	keyStr := fmt.Sprintf("%v%v%v", groupInitials, commonus.TimeStampToDate(todyTime, 14), versioNum)
	//方案版本
	var savePlanVersio assessmentmodel.PlanVersio
	savePlanVersio.Group = groupId
	savePlanVersio.Department = departId
	savePlanVersio.Year = yearInt
	savePlanVersio.Versio = versioNum
	savePlanVersio.Key = keyStr
	savePlanVersio.State = judgeState
	savePlanVersio.AddTime = todyTime
	savePlanVersio.EiteTime = todyTime
	if len(requestData.Child) > 0 {
		planJsonCont, planJsonErr := json.Marshal(requestData.Child)
		if planJsonErr == nil {
			savePlanVersio.Content = string(planJsonCont)
		}
	}

	// response.Result(0, savePlanVersio, "添加成功！", c)
	// return
	var saveDataAry []assessmentmodel.QualitativeEvaluation //新增条目
	for _, v := range requestData.Child {                   //维度
		commonus.AddWeight(requestData.Group, v.Id, requestData.DepartmentId, "", int64(v.ZhiFraction), 1) //添加维度权重
		for _, tar_v := range v.Child {                                                                    //指标
			if tar_v.Status == 1 || tar_v.Status == 3 {
				targetId, _ := strconv.ParseInt(tar_v.Id, 10, 64)               //指标ID转换
				evalTarCont, evalTarContErr := commonus.GetTargetInfo(targetId) //获取指标内容
				if evalTarContErr == true {
					//判断是定量还是定性
					if evalTarCont.Type == 2 {
						//定量指标操作
						commonus.AddWeight(requestData.Group, v.Id, requestData.DepartmentId, tar_v.Id, tar_v.ReferenceScore, 2)
						var saveData assessmentmodel.QualitativeEvaluation

						//维度ID
						dimId, dimErr := strconv.ParseInt(v.Id, 10, 64)
						if dimErr == nil {
							saveData.Dimension = dimId
						}
						saveData.Target = targetId                     //指标
						saveData.Type = evalTarCont.Type               //类型
						saveData.Unit = evalTarCont.Uniteing           //单位
						saveData.ReferenceScore = tar_v.ReferenceScore //分值
						// saveData.ReferenceScore = v_s.ReferenceScore //分值
						saveData.State = judgeState //状态
						saveData.Addtime = time.Now().Unix()
						saveData.Eitetime = time.Now().Unix()
						saveData.Group = groupId                       //集团
						saveData.Cycles = evalTarCont.Cycles           //单位
						saveData.CycleAttres = evalTarCont.CycleAttres //辅助计数
						saveData.AcceptEvaluation = departId           //接受考核部门
						saveData.Content = tar_v.Content               //描述
						saveData.Operator = evalTarCont.Report         //执行考核人

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

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

						saveData.QualEvalId = keyStr
						//要新增的条目
						saveDataAry = append(saveDataAry, saveData)
					} else {
						//定性操作
						commonus.AddWeight(requestData.Group, v.Id, requestData.DepartmentId, tar_v.Id, tar_v.ReferenceScore, 1)
						//获取部门关联考核指标项目
						var assessTarList []assessmentmodel.Assesstarget
						judgeARTErr := global.GVA_DB_Performanceappraisal.Where("`group` = ? AND `dimension` = ? AND `targetid` = ? AND FIND_IN_SET(?,`departmentmap`)", groupId, v.Id, tar_v.Id, departId).Find(&assessTarList).Error
						if judgeARTErr == nil {
							var guoDu []AddPartMentGuodu
							for _, ass_v := range assessTarList {
								judgeTure := commonus.JudegSunTarToDepart(ass_v.SunTargetId, departId)
								if judgeTure == true {
									var guoDuCont AddPartMentGuodu
									guoDuCont.Group = groupId
									guoDuCont.DeaprtId = departId
									guoDuCont.Dimension = ass_v.Dimension
									guoDuCont.TargetId = ass_v.TargetId
									guoDuCont.SunTargetId = ass_v.SunTargetId
									if ass_v.Content != "" {
										//拆解指标详情
										var detailedList []DutyAssEssTarget
										detailedListErr := json.Unmarshal([]byte(ass_v.Content), &detailedList)
										if detailedListErr == nil {
											for _, det_v := range detailedList {
												var deparmentStr string
												deErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DetailedTarget{}).Select("`dt_paretment`").Where("`dt_id` = ? AND (FIND_IN_SET(?,`dt_paretment`) OR `dt_paretment` = '')", det_v.Id, departId).First(&deparmentStr).Error
												if deErr == nil {
													if deparmentStr != "" {
														guoDuCont.DetailedTarget = det_v.Id
														guoDuCont.Operator = det_v.Operator
														guoDu = append(guoDu, guoDuCont)
													}
												}
												fmt.Printf("Targer---7---->%v---->%v---->%v---->%v---->%v\n", det_v.Id, departId, deparmentStr, guoDu, deErr)
											}
										} else {
											// guoDu = append(guoDu, guoDuCont)
										}
									} else {
										// guoDu = append(guoDu, guoDuCont)
									}
								}

							}

							//判断关联项目
							if len(guoDu) > 0 {
								// guoDuJsonm, _ := json.Marshal(guoDu)
								// fmt.Printf("Targer---7---->%v---->%v\n", string(guoDuJsonm), guoDu)
								for _, ae_v := range guoDu {
									//写入新的定性考核细则
									var saveData assessmentmodel.QualitativeEvaluation
									saveData.Dimension = ae_v.Dimension
									saveData.Target = ae_v.TargetId //指标
									saveData.Type = 1               //类型

									saveData.TargetSun = ae_v.SunTargetId

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

									saveData.DetailedTarget = ae_v.DetailedTarget

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

									saveData.MinScore = getEvalTarCont.MinScore
									saveData.MaxScore = getEvalTarCont.MaxScore

									saveData.CensorType = getEvalTarCont.CensorType
									saveData.CensorCont = getEvalTarCont.CensorCont
									saveData.CensorRate = getEvalTarCont.CensorRate
									// saveData.ReferenceScore = v_s.ReferenceScore //分值
									saveData.State = judgeState //状态
									saveData.Addtime = time.Now().Unix()
									saveData.Eitetime = time.Now().Unix()
									saveData.Group = ae_v.Group //集团

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

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

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

									saveDataJsonm, _ := json.Marshal(saveData)
									fmt.Printf("Targer---9---->%v---->%v\n", string(saveDataJsonm), saveData)
									saveData.QualEvalId = keyStr
									//要新增的条目
									saveDataAry = append(saveDataAry, saveData)
								}
							}
						}
					}
				}
			}
		}
	}

	// saveDataJsonmww, _ := json.Marshal(saveDataAry)
	// fmt.Printf("Targer---19---->%v\n", string(saveDataJsonmww))
	// panic(saveDataAry)
	if len(saveDataAry) > 0 {

		affairDb := global.GVA_DB_Performanceappraisal.Begin()
		addSysAdminContErr := affairDb.Create(&savePlanVersio).Error
		addSysAdminAttrContErr := affairDb.Create(&saveDataAry).Error
		if addSysAdminContErr == nil && addSysAdminAttrContErr == nil {
			affairDbErr := affairDb.Commit().Error
			if affairDbErr == nil {
				response.Result(0, affairDbErr, "数据写入成功！", c)
			} else {
				response.Result(108, affairDbErr, "数据写入失败！", c)
			}
		} else {
			affairDbErr := affairDb.Rollback().Error
			response.Result(109, affairDbErr, "数据写入失败！", c)
		}
	}
	// response.Result(0, saveDataAry, "添加成功！", c)
}

//查看考核方案
func (d *DutyAssessApi) LookDepartDutyVersioOld(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 qualitativeEvaluationAry []assessmentmodel.QualitativeEvaluation
	listTargetErr := global.GVA_DB_Performanceappraisal.Select("qualitative_evaluation.*,dutyclass.sort").Where("`qe_qual_eval_id` = ?", requestData.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 {
		response.Result(101, listTargetErr, "没有数据！", c)
		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.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
				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)
	}
	response.Result(0, uotContAry, "数据获取成功！", c)
}

//启用禁用删除
func (d *DutyAssessApi) OnOffDepartDutyVersio(c *gin.Context) {
	var requestData SetOnOffDutyVersio
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if requestData.Key == "" {
		response.Result(102, err, "数据获取失败！", c)
		return
	}
	if requestData.State == 0 {
		requestData.State = 1
	}
	if requestData.IsTrue == 0 {
		requestData.IsTrue = 2
	}
	//判断是否存在
	var ContInfo assessmentmodel.PlanVersio
	getContErr := global.GVA_DB_Performanceappraisal.Where("`key` = ? AND `state` <> 3", requestData.Key).First(&ContInfo).Error
	if getContErr != nil {
		response.Result(103, getContErr, "没有该方案！", c)
		return
	}
	//判断是否可以执行该操作
	if judgeOnOffVersio(ContInfo, requestData.IsTrue) == true {
		response.Result(1003, ContInfo, "要禁用的方案还有未走完的审批流程！请不要进行此操作！", c)
		return
	}
	//获取

	if requestData.State != 3 {
		eiteOtherData := commonus.MapOut()
		eiteOtherData["state"] = 2
		eiteOtherData["eitetime"] = time.Now().Unix()
		// global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.PlanVersio{}).Where("`group` = ? AND `department` = ? AND `yeares` = ?", ContInfo.Group, ContInfo.Department, ContInfo.Year).Updates(eiteOtherData)
		global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.PlanVersio{}).Where("`group` = ? AND `department` = ? AND `state` <> 3 AND `key` <> ?", ContInfo.Group, ContInfo.Department, requestData.Key).Updates(eiteOtherData)
	}

	eiteData := commonus.MapOut()
	eiteData["state"] = requestData.State
	eiteData["eitetime"] = time.Now().Unix()
	errOne := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.PlanVersio{}).Where("`key` = ?", requestData.Key).Updates(eiteData).Error

	eiteQuerData := commonus.MapOut()
	eiteQuerData["qe_state"] = requestData.State
	eiteQuerData["qe_eitetime"] = time.Now().Unix()
	global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Where("`qe_qual_eval_id` = ?", requestData.Key).Updates(eiteQuerData)

	var planKey []assessmentmodel.PlanVersio
	plankeErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.PlanVersio{}).Where("`group` = ? AND `department` = ? AND `state` <> 3 AND `key` <> ?", ContInfo.Group, ContInfo.Department, requestData.Key).Find(&planKey).Error
	if plankeErr == nil {
		var keyPlanStr []string
		for _, plv := range planKey {
			keyPlanStr = append(keyPlanStr, plv.Key)
		}
		if requestData.State == 1 {
			if len(keyPlanStr) > 0 {
				eiteQuerDataAll := commonus.MapOut()
				eiteQuerDataAll["qe_state"] = 2
				eiteQuerDataAll["qe_eitetime"] = time.Now().Unix()
				global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Where("`qe_qual_eval_id` IN ?", keyPlanStr).Updates(eiteQuerDataAll)
			}

		}
	}

	if errOne != nil {
		response.Result(102, errOne, "修改失败", c)
		return
	}
	response.Result(0, errOne, "修改成功", c)
}

//判断是否可以执行启用禁用操作
func judgeOnOffVersio(contInfo assessmentmodel.PlanVersio, onOff int) (isTrue bool) {
	isTrue = false
	if onOff == 1 {
		var isOpen []assessmentmodel.PlanVersio
		isErr := global.GVA_DB_Performanceappraisal.Where("`group` = ? AND `department` = ? AND `yeares` = ?", contInfo.Group, contInfo.Department, contInfo.Year).Find(&isOpen).Error
		if isErr != nil {
			return
		}
		for _, v := range isOpen {
			if v.State == 1 {
				isTrue = selectServio(v.Key)
			}
		}
	} else {
		isTrue = selectServio(contInfo.Key)
	}
	return
}

//查询
func selectServio(key string) (isTrue bool) {
	isTrue = false
	fmt.Printf("HGJK--------1---------->%v", key)
	var dutyList []assessmentmodel.QualitativeEvaluation
	dutyErr := global.GVA_DB_Performanceappraisal.Where("`qe_state` = 1 AND `qe_qual_eval_id` = ?", key).Find(&dutyList).Error
	fmt.Printf("HGJK--------2---------->%v", dutyErr)
	if dutyErr != nil {
		return
	}
	var dingXing []int64
	var dingLiang []int64
	for _, v := range dutyList {
		if v.Type == 1 {
			dingXing = append(dingXing, v.Id)
		} else {
			dingLiang = append(dingLiang, v.Id)
		}
	}
	var dataStruct dataLockStatistics

	syncProcess.Add(1)
	go dataStruct.SelectDutyVersioProcessXing(dingXing)
	syncProcess.Add(1)
	go dataStruct.SelectDutyVersioProcessLing(dingLiang)
	syncProcess.Wait()

	readDingXingDataMap, readDingLiangDataMap := dataStruct.readMyDayData()
	if len(readDingXingDataMap) > 0 || len(readDingLiangDataMap) > 0 {
		isTrue = true
	}
	return
}

//并发查询定性考核方案
func (d *dataLockStatistics) SelectDutyVersioProcessXing(departId []int64) {
	d.mutext.Lock()
	defer d.mutext.Unlock()
	if len(departId) > 0 {
		var stateIsTrue []bingFaOut
		err := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.ScoreFlow{}).Select("sf_id,sf_key,sf_evaluation_plan,sf_reply,ep_order_key,ep_state").Where("`sf_evaluation_plan` IN ?", departId).Joins("left join evaluation_process on ep_order_key = sf_key").Find(&stateIsTrue).Error
		if err == nil {
			for _, v := range stateIsTrue {
				if v.State == 1 {
					isIn := commonus.MapOut()
					isIn["id"] = v.Id
					isIn["key"] = v.Key
					isIn["state"] = v.State
					d.dataMap = append(d.dataMap, isIn)
				}
			}
		}
	}
	syncProcess.Done()
}

//并发查询定量考核方案
func (d *dataLockStatistics) SelectDutyVersioProcessLing(departId []int64) {
	d.mutext.Lock()
	defer d.mutext.Unlock()
	if len(departId) > 0 {
		var stateIsTrue []bingFaOutDingLiang
		err := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.FlowLog{}).Select("fl_id,fl_key,fl_evaluation_id,fl_reply,ep_order_key,ep_state").Where("`sf_evaluation_plan` IN ?", departId).Joins("left join evaluation_process on ep_order_key = fl_key").Find(&stateIsTrue).Error
		if err == nil {
			for _, v := range stateIsTrue {
				if v.State == 1 {
					isIn := commonus.MapOut()
					isIn["id"] = v.Id
					isIn["key"] = v.Key
					isIn["state"] = v.State
					d.dataErrMap = append(d.dataErrMap, isIn)
				}
			}
		}
	}
	syncProcess.Done()
}

//修改部门考核方案内的说明
func (d *DutyAssessApi) EiteDepartExplain(c *gin.Context) {
	var requestData EitrDepartExplan
	c.ShouldBindJSON(&requestData)
	// err := c.ShouldBindJSON(&requestData)
	// if err != nil {
	// 	response.Result(101, err, "数据获取失败！", c)
	// 	return
	// }
	if requestData.Group == "" {
		response.Result(102, requestData, "数据获取失败！", c)
		return
	}
	if requestData.DeaprtId == "" {
		response.Result(103, requestData, "数据获取失败！", c)
		return
	}
	if requestData.Dimension == "" {
		response.Result(104, requestData, "数据获取失败！", c)
		return
	}
	if requestData.TargetId == "" {
		response.Result(105, requestData, "数据获取失败！", c)
		return
	}
	if requestData.QualEvalId == "" {
		response.Result(106, requestData, "数据获取失败！", c)
		return
	}
	eiteData := commonus.MapOut()
	eiteData["qe_eitetime"] = time.Now().Unix()
	eiteData["qe_content"] = requestData.Content
	if requestData.State > 0 {
		eiteData["qe_state"] = requestData.State
	} else {
		eiteData["qe_state"] = 2
	}
	if len(requestData.Operator) > 0 {
		eiteData["qe_operator"] = strings.Join(requestData.Operator, ",")
	}
	saveErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Where("`qe_qual_eval_id` = ? AND `qe_group` = ? AND `qe_accept_evaluation` = ? AND `qe_dimension` = ? AND `qe_target` = ?", requestData.QualEvalId, requestData.Group, requestData.DeaprtId, requestData.Dimension, requestData.TargetId).Updates(eiteData).Error
	if saveErr == nil {
		if requestData.State != 0 {
			eitePlanVersion(requestData.QualEvalId, requestData.TargetId, requestData.State, requestData.Content)
		}
		response.Result(0, eiteData, "数据处理成功！", c)
	} else {
		response.Result(102, saveErr, "数据处理失败！", c)
	}
}

//编辑版本主体
func eitePlanVersion(key string, tarId string, state int, contStr string) {
	var planVersioCont assessmentmodel.PlanVersio
	planErr := global.GVA_DB_Performanceappraisal.Where("`key` = ?", key).First(&planVersioCont).Error
	var planContSave []AddDutyNewCont
	// fmt.Printf("Plan--------1----------->%v\n", planErr)
	if planErr == nil {
		if planVersioCont.Content != "" {
			// fmt.Printf("Plan--------2----------->%v\n", planVersioCont)
			var planCont []AddDutyNewCont
			jsonErrPlan := json.Unmarshal([]byte(planVersioCont.Content), &planCont)
			// fmt.Printf("Plan--------3----------->%v\n", jsonErrPlan)
			if jsonErrPlan == nil {

				for _, v := range planCont {
					var saveCont AddDutyNewCont
					saveCont.Id = v.Id
					saveCont.Name = v.Name
					saveCont.ZhiFraction = v.ZhiFraction
					for _, cv := range v.Child {
						var chidCont EvaluPross
						if cv.Id == tarId {
							chidCont.Id = cv.Id
							chidCont.Name = cv.Name                     // `json:"name"`
							chidCont.Content = contStr                  // `json:"content"`        //指标说明
							chidCont.Unit = cv.Unit                     // `json:"unit"`           //单位"`
							chidCont.ReferenceScore = cv.ReferenceScore //  `json:"referencescore"` //标准分值"`
							chidCont.Cycles = cv.Cycles                 //    `json:"cycle"`          //1：班；2：天；3：周；4：月；5：季度；6：年"`
							chidCont.CycleAttres = cv.CycleAttres       //    `json:"cycleattr"`      //辅助计数"`
							chidCont.State = state                      //    `json:"state"`
							chidCont.Score = cv.Score                   //  `json:"score"` //分数
							chidCont.QualEvalId = cv.QualEvalId         // `json:"qeid"`
							chidCont.Status = state                     //    `json:"status"`
						} else {
							chidCont.Id = cv.Id
							chidCont.Name = cv.Name                     // `json:"name"`
							chidCont.Content = cv.Content               // `json:"content"`        //指标说明
							chidCont.Unit = cv.Unit                     // `json:"unit"`           //单位"`
							chidCont.ReferenceScore = cv.ReferenceScore //  `json:"referencescore"` //标准分值"`
							chidCont.Cycles = cv.Cycles                 //    `json:"cycle"`          //1：班；2：天；3：周；4：月；5：季度；6：年"`
							chidCont.CycleAttres = cv.CycleAttres       //    `json:"cycleattr"`      //辅助计数"`
							chidCont.State = cv.State                   //    `json:"state"`
							chidCont.Score = cv.Score                   //  `json:"score"` //分数
							chidCont.QualEvalId = cv.QualEvalId         // `json:"qeid"`
							chidCont.Status = cv.Status                 //    `json:"status"`

						}
						saveCont.Child = append(saveCont.Child, chidCont)
					}
					planContSave = append(planContSave, saveCont)
				}

			}
		}

	}
	// fmt.Printf("Plan--------4----------->%v\n", len(planContSave))
	if len(planContSave) > 0 {
		planContInfo, planJsonErr := json.Marshal(planContSave)
		if planJsonErr == nil {
			eitaData := commonus.MapOut()
			eitaData["content"] = string(planContInfo)
			eitaData["eitetime"] = time.Now().Unix()
			global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.PlanVersio{}).Where("`key` = ?", key).Updates(eitaData)
		}

	}
}