key_performance_indicators/api/version1/departmentseting/departmentpc/programme.go

package departmentpc

import (
	"encoding/json"
	"fmt"
	"key_performance_indicators/models/modelshr"
	"key_performance_indicators/models/modelskpi"
	"key_performance_indicators/overall"
	"key_performance_indicators/overall/publicmethod"
	"strconv"
	"strings"
	"time"

	"github.com/gin-gonic/gin"
)

//部门级考核方案

/*
*
@ 作者: 秦东
@ 时间: 2022-12-14 13:58:18
@ 功能: 部门考核方案列表
@ 参数

	#

@ 返回值

	#

@ 方法原型

	#
*/
func (a *ApiMethod) DepartmentProgramme(c *gin.Context) {
	var receivedValue DepartPrograList
	c.ShouldBindJSON(&receivedValue)
	gormDb := overall.CONSTANT_DB_KPI.Where("`state` BETWEEN ? AND ?", 1, 2)
	if receivedValue.OrgId != "" {
		orgIdInt, _ := strconv.ParseInt(receivedValue.OrgId, 10, 64)
		orgAllSunId := publicmethod.GetDepartmentSun(orgIdInt, []int64{})
		orgAllSunId = append(orgAllSunId, orgIdInt)
		if len(orgAllSunId) > 0 {
			gormDb = gormDb.Where("`department` IN ?", orgAllSunId)
		}
	}
	if receivedValue.Year != "" {
		gormDb = gormDb.Where("`yeares` = ?", receivedValue.Year)
	}
	if receivedValue.Version != "" {
		gormDb = gormDb.Where("`key` LIKE ?", "%"+receivedValue.Version+"%")
	}
	var planVersionList []modelskpi.PlanVersio
	err := gormDb.Order("`group` ASC").Order("`department` ASC").Order("`state` ASC").Order("`addtime` DESC").Find(&planVersionList).Error
	if err != nil {
		publicmethod.Result(105, err, c)
		return
	}
	var sendList []SendDepartPrograList
	for _, v := range planVersionList {
		var sendCont SendDepartPrograList
		sendCont.Id = v.Id                 //
		sendCont.Group = v.Group           //集团ID"`
		sendCont.Department = v.Department //部门ID"`
		sendCont.Year = v.Year             //年度"`
		sendCont.Versio = v.Versio         //版本号"`
		sendCont.Key = v.Key               //编码"`
		sendCont.State = v.State           //状态（1：启用；2：禁用；3：删除）"`
		if v.State == 1 {
			sendCont.States = true
		} else {
			sendCont.States = false
		}
		sendCont.AddTime = v.AddTime   //创建时间"`
		sendCont.EiteTime = v.EiteTime //l修改时间"`
		// sendCont.Content = v.Content       //版本内容"`
		json.Unmarshal([]byte(v.Content), &sendCont.VersionCont)
		var companyCont modelshr.AdministrativeOrganization
		companyCont.GetCont(map[string]interface{}{"`id`": v.Group}, "`name`")
		sendCont.GroupName = companyCont.Name
		var dempartCont modelshr.AdministrativeOrganization
		dempartCont.GetCont(map[string]interface{}{"`id`": v.Department}, "`name`")
		sendCont.DeaprtName = dempartCont.Name
		sendCont.Time = publicmethod.UnixTimeToDay(v.AddTime, 11)
		sendList = append(sendList, sendCont)
	}
	publicmethod.Result(0, sendList, c)
}

/*
*
@ 作者: 秦东
@ 时间: 2022-12-14 16:38:02
@ 功能: 编辑部门方案状态
@ 参数

	#

@ 返回值

	#

@ 方法原型

	#
*/
func (a *ApiMethod) EditDepartPrograState(c *gin.Context) {
	var receivedValue publicmethod.PublicState
	err := c.ShouldBindJSON(&receivedValue)
	if err != nil {
		publicmethod.Result(100, err, c)
		return
	}
	if receivedValue.Id == "" {
		publicmethod.Result(101, receivedValue, c)
		return
	}
	if receivedValue.State == 0 {
		receivedValue.State = 2
	}
	if receivedValue.IsTrue == 0 {
		receivedValue.IsTrue = 2
	}
	//判断该方案是否存在
	var planVersionCont modelskpi.PlanVersio
	err = planVersionCont.GetCont(map[string]interface{}{"`key`": receivedValue.Id})
	if err != nil {
		publicmethod.Result(107, receivedValue, c)
		return
	}
	//判断是否可执行操作
	if editDepartStateIsTrue(planVersionCont, receivedValue.State) {
		msg := "要操作的方案还有未走完的审批流程！请不要进行此操作！"
		if receivedValue.State == 1 {
			msg = "当前激活的方案中还有未走完的审批流程！请不要进行此操作!"
		}
		publicmethod.Result(1, receivedValue, c, msg)
		return
	}
	//根据操作不同执行相应函数
	editState := publicmethod.MapOut[string]()
	editState["`state`"] = 2
	editState["`eitetime`"] = time.Now().Unix()
	switch receivedValue.State {
	case 1:
		//执行启用操作
		//1、获取已经启用的方案西信息
		var planIsRun modelskpi.PlanVersio
		err = planIsRun.GetCont(map[string]interface{}{"`group`": planVersionCont.Group, "`department`": planVersionCont.Department, "`state`": 1}, "`id`", "`key`")
		if err == nil {
			planIsRun.EiteCont(map[string]interface{}{"`id`": planIsRun.Id}, editState)
			var qualEval modelskpi.QualitativeEvaluation
			qualEval.EiteCont(map[string]interface{}{"`qe_qual_eval_id`": planIsRun.Key}, map[string]interface{}{"`qe_state`": 2, "`qe_eitetime`": time.Now().Unix()})
		}
		err = planVersionCont.EiteCont(map[string]interface{}{"`id`": planVersionCont.Id}, map[string]interface{}{"`state`": 1, "`eitetime`": time.Now().Unix()})
		var qualEvalMain modelskpi.QualitativeEvaluation
		qualEvalMain.EiteCont(map[string]interface{}{"`qe_qual_eval_id`": planVersionCont.Key}, map[string]interface{}{"`qe_state`": 1, "`qe_eitetime`": time.Now().Unix()})
	case 3:
		if receivedValue.IsTrue == 1 {
			var qualEval modelskpi.QualitativeEvaluation
			qualEval.DelCont(map[string]interface{}{"`qe_qual_eval_id`": planVersionCont.Key})
			err = planVersionCont.DelCont(map[string]interface{}{"`id`": planVersionCont.Id})
		} else {
			var qualEval modelskpi.QualitativeEvaluation
			qualEval.EiteCont(map[string]interface{}{"`qe_qual_eval_id`": planVersionCont.Key}, map[string]interface{}{"`qe_state`": 3, "`qe_eitetime`": time.Now().Unix()})
			err = planVersionCont.EiteCont(map[string]interface{}{"`id`": planVersionCont.Id}, map[string]interface{}{"`state`": 3, "`eitetime`": time.Now().Unix()})
		}
	default:
		var qualEval modelskpi.QualitativeEvaluation
		qualEval.EiteCont(map[string]interface{}{"`qe_qual_eval_id`": planVersionCont.Key}, map[string]interface{}{"`qe_state`": 2, "`qe_eitetime`": time.Now().Unix()})
		err = planVersionCont.EiteCont(map[string]interface{}{"`id`": planVersionCont.Id}, editState)
	}
	if err != nil {
		publicmethod.Result(106, err, c)
		return
	}
	publicmethod.Result(0, err, c)
}

/*
*
@ 作者: 秦东
@ 时间: 2022-12-14 16:48:55
@ 功能: 判断是否可执行部门方案状态更改操作
@ 参数

	#planVersionCont             要操作的方案主体
	#state 						状态1：启用；2：禁用；3：删除

@ 返回值

	#

@ 方法原型

	#
*/
func editDepartStateIsTrue(planVersionCont modelskpi.PlanVersio, state int) (isTrue bool) {
	isTrue = false
	//判断是否启用
	if state == 1 {
		//1、判断同部门是否有已经启用的方案
		var planRuning modelskpi.PlanVersio
		err := planRuning.GetCont(map[string]interface{}{"`group`": planVersionCont.Group, "`department`": planVersionCont.Department, "`state`": 1}, "`id`", "`key`")
		if err != nil {
			return
		}
		isTrue = SearchPlanVersion(planRuning.Key)
	} else {
		//执行非启用状态，判断该方案主体是否有政治执行的操作
		isTrue = SearchPlanVersion(planVersionCont.Key)
	}
	return
}

/*
*
@ 作者: 秦东
@ 时间: 2022-12-14 16:54:44
@ 功能: 查询方案正在执行的操作
@ 参数

	#

@ 返回值

	#isTrue         true:存在正在执行的操作；false：不存在正在执行的操作

@ 方法原型

	#
*/
func SearchPlanVersion(key string) (isTrue bool) {
	isTrue = false
	//获取本方案中的所有内容
	var planContList []modelskpi.QualitativeEvaluation
	err := overall.CONSTANT_DB_KPI.Model(&modelskpi.QualitativeEvaluation{}).Select("qe_id,qe_type").Where("`qe_state` = 1 AND `qe_qual_eval_id` = ?", key).Find(&planContList).Error
	if err != nil {
		return
	}
	//分别获取定性和定量的项目Id列表
	var dingXing []int64
	var dingLiang []int64
	for _, v := range planContList {
		if v.Type == 1 {
			if publicmethod.IsInTrue[int64](v.Id, dingXing) == false {
				dingXing = append(dingXing, v.Id)
			}
		} else {
			if publicmethod.IsInTrue[int64](v.Id, dingLiang) == false {
				dingLiang = append(dingLiang, v.Id)
			}
		}
	}
	var syncListCont judgePlanTask
	SyncSeting.Add(1)
	go syncListCont.SearchDingXingPlan(dingXing)
	SyncSeting.Add(1)
	go syncListCont.SearchDingLiangPlan(dingLiang)
	SyncSeting.Wait()

	readDingXingMap, readDingLiangMap := syncListCont.readPlanTaskData()
	if len(readDingXingMap) > 0 || len(readDingLiangMap) > 0 {
		isTrue = true
	}
	return
}

/*
*
@ 作者: 秦东
@ 时间: 2022-12-14 17:24:37
@ 功能: 判断方案中是否有正在执行的定性考核项
@ 参数

	#id         方案中定性考核项

@ 返回值

	#

@ 方法原型

	#(j *judgePlanTask) SearchDingXingPlan(id []int64)
*/
func (j *judgePlanTask) SearchDingXingPlan(id []int64) {
	j.mutext.Lock()
	defer j.mutext.Unlock()
	if len(id) > 0 {
		//获取该方案在执行中的数据
		var dingXingTask []bingFaOut
		err := overall.CONSTANT_DB_KPI.Model(&modelskpi.ScoreFlow{}).Select("sf_id,sf_key,sf_evaluation_plan,ep_order_key,ep_state").Joins("left join evaluation_process on ep_order_key = sf_key").Where("`sf_evaluation_plan` IN ? AND ep_state IN (1,2)", id).Find(&dingXingTask).Error
		if err == nil {
			for _, v := range dingXingTask {
				isIn := publicmethod.MapOut[string]()
				isIn["id"] = v.Id
				isIn["key"] = v.Key
				isIn["state"] = v.State
				j.dingXingTask = append(j.dingXingTask, isIn)
			}
		}
	}
	SyncSeting.Done()
}

/*
*
@ 作者: 秦东
@ 时间: 2022-12-15 08:34:42
@ 功能: 判断方案中是否有正在执行的定量考核项
@ 参数

	#

@ 返回值

	#

@ 方法原型

	#
*/
func (j *judgePlanTask) SearchDingLiangPlan(id []int64) {
	j.mutext.Lock()
	defer j.mutext.Unlock()
	if len(id) > 0 {
		//获取该方案在执行中的数据
		var stateIsTrue []bingFaOutDingLiang
		err := overall.CONSTANT_DB_KPI.Model(&modelskpi.FlowLog{}).Select("fl_id,fl_key,fl_evaluation_id,fl_reply,ep_order_key,ep_state").Where("`fl_key` IN ?  AND ep_state IN (1,2)", id).Joins("left join evaluation_process on ep_order_key = fl_key").Find(&stateIsTrue).Error
		if err == nil {
			for _, v := range stateIsTrue {
				isIn := publicmethod.MapOut[string]()
				isIn["id"] = v.Id
				isIn["key"] = v.Key
				isIn["state"] = v.State
				j.dingLiangTask = append(j.dingLiangTask, isIn)
			}
		}
	}
	SyncSeting.Done()
}

/*
*
@ 作者: 秦东
@ 时间: 2022-12-15 10:49:36
@ 功能: 添加方案
@ 参数

	#

@ 返回值

	#

@ 方法原型

	#
*/
func (a *ApiMethod) CreateSchemeForDeparment(c *gin.Context) {
	var receivedValue AddDutyNewContGroup
	err := c.ShouldBindJSON(&receivedValue)
	if err != nil {
		publicmethod.Result(100, err, c)
		return
	}
	if receivedValue.Group == "" {
		publicmethod.Result(101, receivedValue, c)
		return
	}
	if receivedValue.DepartmentId == "" {
		publicmethod.Result(101, receivedValue, c)
		return
	}
	if receivedValue.Year == "" {
		publicmethod.Result(1, receivedValue, c, "请选择年份")
		return
	}
	if len(receivedValue.Child) < 1 {
		publicmethod.Result(1, receivedValue, c, "没有要添加的数据")
		return
	}
	departId, _ := strconv.ParseInt(receivedValue.DepartmentId, 10, 64) //部门ID
	yearInt, _ := strconv.ParseInt(receivedValue.Year, 10, 64)          //年
	//获取编号首字母
	groupId, groupErr := strconv.ParseInt(receivedValue.Group, 10, 64) //集团ID
	if groupErr != nil {
		groupId = 0
	}
	var groupCont modelshr.AdministrativeOrganization
	groupCont.GetCont(map[string]interface{}{"`id`": groupId}, "`id`", "`name`", "`abbreviation`")
	nameCont := groupCont.Abbreviation
	if nameCont == "" {
		nameCont = groupCont.Name
	}
	companyFirstWord := publicmethod.ChineseFirstWordCapitalize(nameCont) //公司首字母
	//判断当前部门是否已经有正启用得方案
	judgeState := 1
	var judgePlanState modelskpi.PlanVersio
	err = judgePlanState.GetCont(map[string]interface{}{"`state`": 1, "`group`": groupId, "`department`": departId}, "`id`")
	if err == nil {
		judgeState = 2
	}
	//判断年度是否存在版本
	var versioNum string  //版本号
	var sumVerson float64 //已经存在得方案数量
	err = overall.CONSTANT_DB_KPI.Model(&modelskpi.PlanVersio{}).Select("`id`").Where("`group` = ? AND  `yeares` = ?", groupId, yearInt).Pluck("COALESCE(COUNT(id), 0) as countid", &sumVerson).Error
	if err != nil {
		versioNum = "0001"
	} else {
		if sumVerson == 0 {
			versioNum = "0001"
		} else {
			versioNum = fmt.Sprintf("%04v", sumVerson)
		}
	}
	//统一编辑时间
	todyTime := time.Now().Unix()
	//方案编号
	keyStr := fmt.Sprintf("%v%v%v", companyFirstWord, publicmethod.UnixTimeToDay(todyTime, 20), versioNum)

	//合成方案主数据
	var savePlanVersionCont modelskpi.PlanVersio
	savePlanVersionCont.Group = groupId
	savePlanVersionCont.Department = departId
	savePlanVersionCont.Year = yearInt
	savePlanVersionCont.Versio = versioNum
	savePlanVersionCont.Key = keyStr
	savePlanVersionCont.State = judgeState
	savePlanVersionCont.AddTime = todyTime
	savePlanVersionCont.EiteTime = todyTime
	//组装方案结构体，转换json数据
	if len(receivedValue.Child) > 0 {
		var planListCont []AddDutyNewCont
		for _, v := range receivedValue.Child {
			var planCont AddDutyNewCont
			//第一层；纬度操作
			planCont.Id = v.Id
			planCont.Name = v.Name
			planCont.ZhiFraction = v.ZhiFraction
			for _, cv := range v.Child {
				//第二层；指标操作
				var targetCont EvaluPross
				targetCont.Id = cv.Id                         //指标ID
				targetCont.Name = cv.Name                     //指标名称
				targetCont.Content = cv.Content               //指标说明
				targetCont.Unit = cv.Unit                     //单位"`
				targetCont.ReferenceScore = cv.ReferenceScore //标准分值"`
				targetCont.State = cv.State                   //    `json:"state"`
				targetCont.Status = cv.Status                 // 1:使用；2：禁用；3：观察
				targetCont.Score = cv.Score                   //    `json:"state"`
				targetCont.QualEvalId = cv.QualEvalId         //    `json:"state"`
				//获取指标统计属性
				var getTarCont modelskpi.EvaluationTarget
				err = getTarCont.GetCont(map[string]interface{}{"et_id": cv.Id}, "et_cycle,et_cycleattr")
				if err == nil {
					targetCont.Cycles = getTarCont.Cycles           //1：班；2：天；3：周；4：月；5：季度；6：年"`
					targetCont.CycleAttres = getTarCont.CycleAttres //辅助计数"`
				}
				planCont.Child = append(planCont.Child, targetCont)
			}
			planListCont = append(planListCont, planCont)
		}
		planJsonCont, planJsonErr := json.Marshal(planListCont)
		if planJsonErr == nil {
			savePlanVersionCont.Content = string(planJsonCont)
		}
	}

	//往考核方案中写入考核数据
	var qualEvalList []modelskpi.QualitativeEvaluation
	//解析方案结构体
	for _, v := range receivedValue.Child {
		//维度操作
		AddWeight(receivedValue.Group, v.Id, receivedValue.DepartmentId, "", int64(v.ZhiFraction), 1) //添加维度权重
		for _, cv := range v.Child {
			//指标操作
			if cv.Status != 2 { //操作非禁用得指标
				//获取指标定义
				var targetInfo modelskpi.EvaluationTarget
				err := targetInfo.GetCont(map[string]interface{}{"`et_id`": cv.Id})
				if err == nil { //判断指标是否存在
					//判断指标是定性还是定量
					if targetInfo.Type == 2 {
						//定量指标
						AddWeight(receivedValue.Group, v.Id, receivedValue.DepartmentId, cv.Id, cv.ReferenceScore, 2)
						var qualEvalContXing modelskpi.QualitativeEvaluation
						qualEvalContXing.Dimension, _ = strconv.ParseInt(v.Id, 10, 64)
						qualEvalContXing.Target, _ = strconv.ParseInt(cv.Id, 10, 64) //指标
						qualEvalContXing.Type = targetInfo.Type                      //类型
						qualEvalContXing.Unit = targetInfo.Uniteing                  //单位
						qualEvalContXing.ReferenceScore = cv.ReferenceScore          //分值
						qualEvalContXing.State = judgeState                          //状态
						qualEvalContXing.Addtime = time.Now().Unix()
						qualEvalContXing.Eitetime = time.Now().Unix()
						qualEvalContXing.Group = groupId                      //集团
						qualEvalContXing.Cycles = targetInfo.Cycles           //单位
						qualEvalContXing.CycleAttres = targetInfo.CycleAttres //辅助计数
						qualEvalContXing.AcceptEvaluation = departId          //接受考核部门
						qualEvalContXing.Content = cv.Content                 //描述
						qualEvalContXing.Operator = targetInfo.Report         //执行考核人
						qualEvalContXing.QualEvalId = keyStr
						qualEvalContXing.Observer = cv.Status
						var departAry []string
						userKeyAry := strings.Split(targetInfo.Report, ",")
						if len(userKeyAry) > 0 {
							for _, u_v := range userKeyAry {
								var userCont modelshr.PersonArchives
								err = userCont.GetCont(map[string]interface{}{"`key`": u_v}, "`maindeparment`")
								mainDepartStr := strconv.FormatInt(userCont.MainDeparment, 10)
								if publicmethod.IsInTrue[string](mainDepartStr, departAry) == false {
									departAry = append(departAry, mainDepartStr)
								}
							}
						}
						qualEvalContXing.DepartmentId = strings.Join(departAry, ",") //处理关联部门

						qualEvalList = append(qualEvalList, qualEvalContXing)
					} else {
						//定性指标
						AddWeight(receivedValue.Group, v.Id, receivedValue.DepartmentId, cv.Id, cv.ReferenceScore, 1)
						//获取定性指标得关联关系
						var assessList []modelskpi.Assesstarget
						err = overall.CONSTANT_DB_KPI.Model(&modelskpi.Assesstarget{}).Where("`state` = 1 AND `group` = ? AND `dimension` = ? AND `targetid` = ? AND FIND_IN_SET(?,`departmentmap`)", groupId, v.Id, cv.Id, departId).Find(&assessList).Error
						if err == nil {
							var sunTarget []int64
							for _, sv := range assessList { //遍历与此部门相关得子栏目
								if publicmethod.IsInTrue[int64](sv.Id, sunTarget) == false { //次子栏目未操作过
									//拆解指标详情
									var detailedList []DutyAssEssTarget
									json.Unmarshal([]byte(sv.Content), &detailedList)

									sunTarget = append(sunTarget, sv.Id)
									//获取指标细则列表
									var targetDetailsList []modelskpi.DetailedTarget
									err = overall.CONSTANT_DB_KPI.Model(&modelskpi.DetailedTarget{}).Where("`dt_state` = 1 AND `dt_parentid` = ? AND `dt_parentid_sun` = ? AND (FIND_IN_SET(?,`dt_paretment`) OR `dt_paretment` = '')", cv.Id, sv.SunTargetId, departId).Find(&targetDetailsList).Error
									fmt.Printf("获取指标细则列表-------->%v-------->%v-------->%v-------->%v\n", cv.Id, sv.Id, departId, len(targetDetailsList))
									if err == nil {
										for _, tv := range targetDetailsList { //指标细则

											//写入新的定性考核细则
											var saveData modelskpi.QualitativeEvaluation
											saveData.Dimension = sv.Dimension   //纬度
											saveData.Target = targetInfo.Id     //指标
											saveData.Type = 1                   //类型
											saveData.TargetSun = sv.SunTargetId //子栏目
											saveData.DetailedTarget = tv.Id     //指标细则
											if tv.Company != "" {
												saveData.Unit = tv.Company
											} else {
												saveData.Unit = targetInfo.Uniteing
											}
											saveData.ReferenceScore = 0     //分值
											saveData.MinScore = tv.MinScore //最低分
											saveData.MaxScore = tv.MaxScore //最高分

											saveData.CensorType = tv.CensorType //检查方式
											saveData.CensorCont = tv.CensorCont //检查依据
											saveData.CensorRate = tv.CensorRate //检查频次
											saveData.State = judgeState         //状态
											saveData.Addtime = time.Now().Unix()
											saveData.Eitetime = time.Now().Unix()
											saveData.Group = groupId //集团

											if tv.Cycles > 0 {
												saveData.Cycles = tv.Cycles           //1：班；2：天；3：周；4：月；5：季度；6：年
												saveData.CycleAttres = tv.CycleAttres //辅助计数
											} else {
												saveData.Cycles = targetInfo.Cycles           //1：班；2：天；3：周；4：月；5：季度；6：年
												saveData.CycleAttres = targetInfo.CycleAttres //辅助计数
											}
											saveData.AcceptEvaluation = departId //接受考核部门
											saveData.Content = tv.Content        //描述
											reportStr := tv.Reportary
											if tv.Reportary != "" {
												saveData.Operator = tv.Reportary //执行考核人
											} else {
												if len(detailedList) > 0 {
													for _, dev := range detailedList {
														if dev.Id == tv.Id {
															saveData.Operator = strings.Join(dev.Operator, ",") //执行考核人 //执行考核人
															reportStr = strings.Join(dev.Operator, ",")
															saveData.DepartmentId = strings.Join(dev.Department, ",")
														}
													}
												}
											}
											var departAry []string
											userKeyAry := strings.Split(reportStr, ",")
											if len(userKeyAry) > 0 {
												for _, u_v := range userKeyAry {
													var userCont modelshr.PersonArchives
													err = userCont.GetCont(map[string]interface{}{"`key`": u_v}, "`maindeparment`")
													mainDepartStr := strconv.FormatInt(userCont.MainDeparment, 10)
													if publicmethod.IsInTrue[string](mainDepartStr, departAry) == false {
														departAry = append(departAry, mainDepartStr)
													}
												}
											}
											saveData.DepartmentId = strings.Join(departAry, ",") //处理关联部门
											saveData.QualEvalId = keyStr
											saveData.Observer = cv.Status
											qualEvalList = append(qualEvalList, saveData)
										}
									}
								}
							}

						}
					}
				}
			}
		}
	}
	//判断是否有要写入得内容
	if len(qualEvalList) > 0 {
		affairDb := overall.CONSTANT_DB_KPI.Begin()
		addSysAdminContErr := affairDb.Create(&savePlanVersionCont).Error
		addSysAdminAttrContErr := affairDb.Create(&qualEvalList).Error
		if addSysAdminContErr == nil && addSysAdminAttrContErr == nil {
			affairDbErr := affairDb.Commit().Error
			if affairDbErr == nil {
				publicmethod.Result(0, affairDbErr, c, "数据写入成功！")
				return
			} else {
				publicmethod.Result(108, affairDbErr, c, "数据写入失败！")
				return
			}
		} else {
			affairDbErr := affairDb.Rollback().Error
			publicmethod.Result(109, affairDbErr, c, "数据写入失败！")
			return
		}
	}
	publicmethod.Result(1, qualEvalList, c, "数据写入失败！")
}

/*
*
@ 作者: 秦东
@ 时间: 2022-12-15 13:42:54
@ 功能: 写入权重操作
@ 参数

	#group              集团
	#dimension          维度
	#derpatment         部门
	#target             指标
	#class              1：定性考核；2：定量考核

@ 返回值

	#isTrue

@ 方法原型

	#
*/
func AddWeight(group, dimension, derpatment, target string, score, class int64) (isTrue bool) {
	isTrue = false
	//判断指标是否为空
	if target != "" {
		var departSionWeightCont modelskpi.DepartmentDimensionWeight
		err := departSionWeightCont.GetCont(map[string]interface{}{"`ddw_hierarchy`": 2, "`ddw_group`": group, "`ddw_derpatment`": derpatment, "`ddw_dimension`": dimension, "`ddw_target`": target, "`ddw_type`": class}, "`ddw_id`")
		if err == nil {
			//存在，进行更新
			editCont := publicmethod.MapOut[string]()
			editCont["ddw_time"] = time.Now().Unix()
			editCont["ddw_weight"] = score
			err = departSionWeightCont.EiteCont(map[string]interface{}{"`ddw_id`": departSionWeightCont.Id}, editCont)
			if err == nil {
				isTrue = true
			}
		} else {
			//不存在，进行新增
			var addCont modelskpi.DepartmentDimensionWeight
			groupId, _ := strconv.ParseInt(group, 10, 64)
			addCont.Group = groupId
			derpatmentId, _ := strconv.ParseInt(derpatment, 10, 64)
			addCont.DepartmentId = derpatmentId
			dimensionId, _ := strconv.ParseInt(dimension, 10, 64)
			addCont.Dimension = dimensionId
			targetId, _ := strconv.ParseInt(target, 10, 64)
			addCont.Target = targetId
			addCont.Weight = score
			addCont.Addtime = time.Now().Unix()
			addCont.Type = class
			addCont.Hierarchy = 2
			err = overall.CONSTANT_DB_KPI.Create(&addCont).Error
			if err == nil {
				isTrue = true
			}
		}
	} else {
		//写入纬度操作
		var departSionWeightCont modelskpi.DepartmentDimensionWeight
		err := departSionWeightCont.GetCont(map[string]interface{}{"`ddw_hierarchy`": 1, "`ddw_group`": group, "`ddw_derpatment`": derpatment, "`ddw_dimension`": dimension}, "`ddw_id`")
		if err == nil {
			//存在，进行更新
			editCont := publicmethod.MapOut[string]()
			editCont["ddw_time"] = time.Now().Unix()
			editCont["ddw_weight"] = score
			err = departSionWeightCont.EiteCont(map[string]interface{}{"`ddw_id`": departSionWeightCont.Id}, editCont)
			if err == nil {
				isTrue = true
			}
		} else {
			//不存在，进行新增
			var addCont modelskpi.DepartmentDimensionWeight
			groupId, _ := strconv.ParseInt(group, 10, 64)
			addCont.Group = groupId
			derpatmentId, _ := strconv.ParseInt(derpatment, 10, 64)
			addCont.DepartmentId = derpatmentId
			dimensionId, _ := strconv.ParseInt(dimension, 10, 64)
			addCont.Dimension = dimensionId
			addCont.Target = 0
			addCont.Weight = score
			addCont.Addtime = time.Now().Unix()
			addCont.Type = 1
			addCont.Hierarchy = 1
			err = overall.CONSTANT_DB_KPI.Create(&addCont).Error
			if err == nil {
				isTrue = true
			}
		}
	}
	return
}