gin-vue-admin/gin_server_admin/api/v1/assessment/set_evaluation_objectives.go

package assessment

import (
	"strconv"
	"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 *DutyHandle) SetEvaluationObjectives(c *gin.Context) {
	var requestData SetEvaluationObjectives
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if requestData.Year == 0 {
		response.Result(102, err, "请填写年度", c)
		return
	}
	if requestData.Group == 0 {
		response.Result(103, err, "请选择归属集团", c)
		return
	}
	if requestData.DepartMent == 0 {
		response.Result(104, err, "请选择归属部门", c)
		return
	}
	if requestData.Dimension == "" {
		response.Result(105, err, "请选择归属维度", c)
		return
	}
	if requestData.Target == "" {
		response.Result(106, err, "请选择归属指标", c)
		return
	}
	switch requestData.Cycle {
	case 1:
		if len(requestData.CycleAdded) != 1 {
			response.Result(107, err, "年度只可填写一条！", c)
			return
		}
	case 2:
		if len(requestData.CycleAdded) > 4 {
			response.Result(108, err, "季度最多只可填写四条！", c)
			return
		}
		if len(requestData.CycleAdded) < 1 {
			response.Result(109, err, "季度至少填写一条！", c)
			return
		}
	case 3:
		if len(requestData.CycleAdded) > 12 {
			response.Result(110, err, "月度最多只可填写十二条！", c)
			return
		}
		if len(requestData.CycleAdded) < 1 {
			response.Result(111, err, "月度至少填写一条！", c)
			return
		}
	default:
		response.Result(112, err, "请选择周期", c)
		return
	}
	var timecopy []int64
	// gromDb := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QuantitativeConfig{}).Select("Timecopy").Where("`group` = ? AND `departmentid` = ? AND `dimension` = ? AND `target` = ? AND `year` = ? AND `type` = ?", requestData.Group, requestData.DepartMent, requestData.Dimension, requestData.Target, requestData.Year, requestData.Cycle)
	gromDb := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QuantitativeConfig{}).Select("Timecopy").Where("`group` = ? AND `departmentid` = ? AND `dimension` = ? AND `target` = ? AND `year` = ? ", requestData.Group, requestData.DepartMent, requestData.Dimension, requestData.Target, requestData.Year)
	if requestData.TargetDetails != "" {
		gromDb = gromDb.Where("`targetconfig` = ?", requestData.TargetDetails)
	}
	judgeErr := gromDb.Find(&timecopy).Error

	if judgeErr == nil {
		if len(timecopy) > 0 {
			response.Result(121, judgeErr, "已经存在！不要重复添加！", c)
			return
		}
	}

	var saveData []assessmentmodel.QuantitativeConfig
	var eiteAddData []int64
	for _, v := range requestData.CycleAdded {
		if judgeErr != nil {
			var saveDataCont assessmentmodel.QuantitativeConfig
			saveDataCont.DepartmentId = requestData.DepartMent
			saveDataCont.Group = requestData.Group
			dimensionId, dimensionIdErr := strconv.ParseInt(requestData.Dimension, 10, 64)
			if dimensionIdErr == nil {
				saveDataCont.Dimension = dimensionId
			}

			targetId, targetIdErr := strconv.ParseInt(requestData.Target, 10, 64)
			if targetIdErr == nil {
				saveDataCont.Target = targetId
			}

			targetDetailsId, targetDetailsIdErr := strconv.ParseInt(requestData.TargetDetails, 10, 64)
			if targetDetailsIdErr == nil {
				saveDataCont.TargetConfig = targetDetailsId
			}
			saveDataCont.Type = int64(requestData.Cycle)
			saveDataCont.Year = requestData.Year
			saveDataCont.Timecopy = v.Id
			if v.Zeroprize < 0 {
				saveDataCont.Zeroprize = 0
			} else {
				if v.Zeroprize > 100 {
					saveDataCont.Zeroprize = 10000
				} else {
					saveDataCont.Zeroprize = v.Zeroprize * 100
				}
			}
			if v.Allprize < 0 {
				saveDataCont.Allprize = 0
			} else {
				if v.Allprize > 100 {
					saveDataCont.Allprize = 10000
				} else {
					saveDataCont.Allprize = v.Allprize * 100
				}
			}
			if v.Capping > 0 {
				saveDataCont.Capping = 1
				saveDataCont.CappingVal = v.Capping * 100
			} else {
				saveDataCont.Capping = 2
				saveDataCont.CappingVal = 0
			}
			saveDataCont.Time = time.Now().Unix()
			saveDataCont.State = 1
			saveData = append(saveData, saveDataCont)
		} else {
			if len(timecopy) <= 0 {
				var saveDataCont assessmentmodel.QuantitativeConfig
				saveDataCont.DepartmentId = requestData.DepartMent
				saveDataCont.Group = requestData.Group
				dimensionId, dimensionIdErr := strconv.ParseInt(requestData.Dimension, 10, 64)
				if dimensionIdErr == nil {
					saveDataCont.Dimension = dimensionId
				}

				targetId, targetIdErr := strconv.ParseInt(requestData.Target, 10, 64)
				if targetIdErr == nil {
					saveDataCont.Target = targetId
				}

				targetDetailsId, targetDetailsIdErr := strconv.ParseInt(requestData.TargetDetails, 10, 64)
				if targetDetailsIdErr == nil {
					saveDataCont.TargetConfig = targetDetailsId
				}
				saveDataCont.Type = int64(requestData.Cycle)
				saveDataCont.Year = requestData.Year
				saveDataCont.Timecopy = v.Id
				if v.Zeroprize < 0 {
					saveDataCont.Zeroprize = 0
				} else {
					if v.Zeroprize > 100 {
						saveDataCont.Zeroprize = 10000
					} else {
						saveDataCont.Zeroprize = v.Zeroprize * 100
					}
				}
				if v.Allprize < 0 {
					saveDataCont.Allprize = 0
				} else {
					if v.Allprize > 100 {
						saveDataCont.Allprize = 10000
					} else {
						saveDataCont.Allprize = v.Allprize * 100
					}
				}
				if v.Capping > 0 {
					saveDataCont.Capping = 1
					saveDataCont.CappingVal = v.Capping * 100
				} else {
					saveDataCont.Capping = 2
					saveDataCont.CappingVal = 0
				}
				saveDataCont.Time = time.Now().Unix()
				saveDataCont.State = 1
				saveData = append(saveData, saveDataCont)
			} else {
				for _, s_v := range timecopy {
					if s_v != v.Id {
						var saveDataCont assessmentmodel.QuantitativeConfig
						saveDataCont.DepartmentId = requestData.DepartMent
						saveDataCont.Group = requestData.Group
						dimensionId, dimensionIdErr := strconv.ParseInt(requestData.Dimension, 10, 64)
						if dimensionIdErr == nil {
							saveDataCont.Dimension = dimensionId
						}

						targetId, targetIdErr := strconv.ParseInt(requestData.Target, 10, 64)
						if targetIdErr == nil {
							saveDataCont.Target = targetId
						}

						targetDetailsId, targetDetailsIdErr := strconv.ParseInt(requestData.TargetDetails, 10, 64)
						if targetDetailsIdErr == nil {
							saveDataCont.TargetConfig = targetDetailsId
						}
						saveDataCont.Type = int64(requestData.Cycle)
						saveDataCont.Year = requestData.Year
						saveDataCont.Timecopy = v.Id
						if v.Zeroprize < 0 {
							saveDataCont.Zeroprize = 0
						} else {
							if v.Zeroprize > 100 {
								saveDataCont.Zeroprize = 10000
							} else {
								saveDataCont.Zeroprize = v.Zeroprize * 100
							}
						}
						if v.Allprize < 0 {
							saveDataCont.Allprize = 0
						} else {
							if v.Allprize > 100 {
								saveDataCont.Allprize = 10000
							} else {
								saveDataCont.Allprize = v.Allprize * 100
							}
						}
						if v.Capping > 0 {
							saveDataCont.Capping = 1
							saveDataCont.CappingVal = v.Capping * 100
						} else {
							saveDataCont.Capping = 2
							saveDataCont.CappingVal = 0
						}
						saveDataCont.Time = time.Now().Unix()
						saveDataCont.State = 1
						saveData = append(saveData, saveDataCont)
					} else {
						eiteDataMap := commonus.MapOut()
						eiteDataMap["type"] = requestData.Cycle
						eiteDataMap["timecopy"] = v.Id
						if v.Zeroprize < 0 {
							eiteDataMap["zeroprize"] = 0
						} else {
							if v.Zeroprize > 100 {
								eiteDataMap["zeroprize"] = 10000
							} else {
								eiteDataMap["zeroprize"] = v.Zeroprize * 100
							}
						}
						if v.Allprize < 0 {
							eiteDataMap["allprize"] = 0
						} else {
							if v.Allprize > 100 {
								eiteDataMap["allprize"] = 10000
							} else {
								eiteDataMap["allprize"] = v.Allprize * 100
							}
						}
						if v.Capping > 0 {

							eiteDataMap["capping"] = 1
							eiteDataMap["capping_val"] = v.Capping * 100
						} else {
							eiteDataMap["capping"] = 2
							eiteDataMap["capping_val"] = 0
						}
						eiteDataMap["time"] = time.Now().Unix()
						gromDb := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QuantitativeConfig{}).Select("Timecopy").Where("`group` = ? AND `departmentid` = ? AND `dimension` = ? AND `target` = ? AND `year` = ? AND `type` = ?", requestData.Group, requestData.DepartMent, requestData.Dimension, requestData.Target, requestData.Year, requestData.Cycle)
						if requestData.TargetDetails != "" {
							gromDb = gromDb.Where("`targetconfig` = ?", requestData.TargetDetails)
						}
						gromDb.Updates(eiteDataMap)
						eiteAddData = append(eiteAddData, 1)
					}
				}
			}
		}
	}
	if len(saveData) <= 0 && len(eiteAddData) <= 0 {
		response.Result(113, err, "没有要添加的数据！", c)
		return
	}
	if len(saveData) > 0 {
		saveErr := global.GVA_DB_Performanceappraisal.Create(&saveData).Error
		if saveErr != nil {
			response.Result(114, err, "数据添加失败！", c)
			return
		}
	}
	response.Result(0, err, "数据处理完成！", c)
}