gin_server_admin/api/v1/assessment/target.go

package assessment

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

	"gin_server_admin/commonus"
	"gin_server_admin/global"
	"gin_server_admin/model/assessmentmodel"
	"gin_server_admin/model/common/response"
	"gin_server_admin/model/hrsystem"
	"gin_server_admin/model/testpage"
	"github.com/gin-gonic/gin"
)

// 获取指标列表
func (d *DutyHandle) GetTargetList(c *gin.Context) {
	var requestData listTarget
	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
	}
	offSetPage := commonus.CalculatePages(requestData.Page, requestData.PageSize)
	gormDb := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.EvaluationTarget{})
	if requestData.State == 0 {
		gormDb = gormDb.Where("`et_state` IN (1,2)")
	} else {
		gormDb = gormDb.Where("`et_state` = ?", requestData.State)
	}
	if requestData.Type != 0 {
		gormDb = gormDb.Where("`et_type` = ?", requestData.Type)
	}
	if requestData.Share != 0 {
		gormDb = gormDb.Where("`et_share` = ?", requestData.Share)
	}
	if requestData.Dimension != "" {
		gormDb = gormDb.Where("`et_dimension` = ?", requestData.Dimension)
	}
	if requestData.Title != "" {
		gormDb = gormDb.Where("(`et_title` LIKE ?)", "%"+requestData.Title+"%")
	}
	if len(requestData.RelevantDepartments) > 0 {
		var sqlOrStr string = ""
		for s_i, s_v := range requestData.RelevantDepartments {
			if s_i == 0 {
				sqlOrStr = fmt.Sprintf("FIND_IN_SET(%v,`et_relevant_departments`)", s_v)
			} else {
				sqlOrStr = fmt.Sprintf("%v OR FIND_IN_SET(%v,`et_relevant_departments`)", sqlOrStr, s_v)
			}
		}
		gormDb = gormDb.Where(sqlOrStr)
	}

	if len(requestData.VisibleRangeGroup) > 0 {
		var sqlOrStrGroup string = ""
		for s_i, s_v := range requestData.VisibleRangeGroup {
			if s_i == 0 {
				sqlOrStrGroup = fmt.Sprintf("FIND_IN_SET(%v,`et_visible_range`)", s_v)
			} else {
				sqlOrStrGroup = fmt.Sprintf("%v OR FIND_IN_SET(%v,`et_visible_range`)", sqlOrStrGroup, s_v)
			}
		}
		gormDb = gormDb.Where(sqlOrStrGroup)
	}
	if len(requestData.VisibleRangeDepart) > 0 {
		var sqlOrStrDepart string = ""
		for s_i, s_v := range requestData.VisibleRangeDepart {
			if s_i == 0 {
				sqlOrStrDepart = fmt.Sprintf("FIND_IN_SET(%v,`et_visible_range`)", s_v)
			} else {
				sqlOrStrDepart = fmt.Sprintf("%v OR FIND_IN_SET(%v,`et_visible_range`)", sqlOrStrDepart, s_v)
			}
		}
		gormDb = gormDb.Where(sqlOrStrDepart)
	}

	var total int64
	totalErr := gormDb.Count(&total).Error
	if totalErr != nil {
		total = 0
	}

	// response.Result(0, requestData, "查询成功！", c)
	var dataList []assessmentmodel.EvaluationTarget
	dataListerr := gormDb.Order("et_id DESC").Limit(requestData.PageSize).Offset(offSetPage).Find(&dataList).Error
	if dataListerr != nil {
		response.Result(103, dataList, "数据获取失败！", c)
		return
	}
	var outMap []outTargetList
	for _, tg_val := range dataList {
		var outMapCont outTargetList
		outMapCont.Id = tg_val.Id
		outMapCont.OutId = strconv.FormatInt(tg_val.Id, 10)
		outMapCont.Title = tg_val.Title
		outMapCont.Type = tg_val.Type
		outMapCont.State = tg_val.State
		outMapCont.AddTime = tg_val.AddTime
		outMapCont.Share = 2
		outMapCont.RelevantDepartments = tg_val.RelevantDepartments
		if tg_val.RelevantDepartments != "" {
			departIdAry := strings.Split(tg_val.RelevantDepartments, ",")
			for _, dia_val := range departIdAry {

				where := commonus.MapOut()
				where["id"] = dia_val
				orgCont, orgErr := commonus.GetNewOrgCont(where, "id", "name")
				if orgErr == nil {
					var bfCont outTargetAttr
					bfCont.Key = dia_val
					bfCont.Title = orgCont.Name
					outMapCont.RelevantDepartmentMap = append(outMapCont.RelevantDepartmentMap, bfCont)
				}

				// diaInt, diaIntErr := strconv.ParseInt(dia_val, 10, 64)
				// if diaIntErr == nil {
				// 	diaValErr, diaVal := GetBranchFactory(diaInt)
				// 	if diaValErr == true {
				// 		var bfCont outTargetAttr
				// 		bfCont.Key = dia_val
				// 		bfCont.Title = diaVal.Name
				// 		outMapCont.RelevantDepartmentMap = append(outMapCont.RelevantDepartmentMap, bfCont)
				// 	}

				// }
			}
		}

		outMapCont.Dimension = tg_val.Dimension
		dimClass, dimClassErr := commonus.GetDutyClassInfo(tg_val.Dimension)
		if dimClassErr == true {
			outMapCont.DimensionName = dimClass.Title
		}
		outMapCont.Key = tg_val.Key
		outMapCont.Report = tg_val.Report
		if tg_val.Report != "" {
			userIdAry := strings.Split(tg_val.Report, ",")
			for _, u_val := range userIdAry {
				uidInt, uidIntErr := strconv.ParseInt(u_val, 10, 64)
				if uidIntErr == nil {
					// whe := commonus.MapOut()
					// whe["wm_key"] = uidInt
					// uidVal, uidValErr := commonus.GetUserInfoPublic("worker_man.*,worker_man_data.*", whe)

					var myContInfo hrsystem.PersonArchives
					uidValErr := myContInfo.GetCont(map[string]interface{}{"`key`": uidInt}, "`key`", "`name`")

					if uidValErr == nil {
						var bfContUser outTargetAttr
						bfContUser.Key = u_val
						bfContUser.Title = myContInfo.Name
						outMapCont.ReportMap = append(outMapCont.ReportMap, bfContUser)
					}
				}

			}
		}
		outMapCont.Uniteing = tg_val.Uniteing
		outMapCont.Cycles = tg_val.Cycles
		outMapCont.CycleAttres = tg_val.CycleAttres
		outMapCont.VisibleRange = tg_val.VisibleRange
		if tg_val.VisibleRange != "" {
			rangeIdAry := strings.Split(tg_val.VisibleRange, ",")
			for _, rge_val := range rangeIdAry {
				rgeInt, rgeIntErr := strconv.ParseInt(rge_val, 10, 64)
				if rgeIntErr == nil {
					rgeValErr, rgeVal := GetBranchFactory(rgeInt)
					if rgeValErr == true {
						var bfContRge outTargetAttr
						bfContRge.Key = rge_val
						bfContRge.Title = rgeVal.Name
						outMapCont.VisibleRangeDepartMap = append(outMapCont.VisibleRangeDepartMap, bfContRge)
					}
				}
			}
		}
		outMapCont.VisibleRangeGroup = tg_val.VisibleRangeGroup
		outMapCont.ScoringMethod = tg_val.ScoringMethod
		if tg_val.VisibleRangeGroup != "" {
			rangeGroupIdAry := strings.Split(tg_val.VisibleRangeGroup, ",")
			for _, rgeup_val := range rangeGroupIdAry {
				rgeIntGup, rgeIntGupErr := strconv.ParseInt(rgeup_val, 10, 64)
				if rgeIntGupErr == nil {

					where := commonus.MapOut()
					where["id"] = rgeIntGup
					orgCont, rgeValGupErr := commonus.GetNewOrgCont(where, "id", "name")
					// outCont.GroupName = orgCont.Name

					// rgeValGupErr, rgeValGup := GetGroupCont(rgeIntGup)
					if rgeValGupErr == nil {
						var bfContRge outTargetAttr
						bfContRge.Key = rgeup_val
						bfContRge.Title = orgCont.Name
						outMapCont.VisibleRangeGroupMap = append(outMapCont.VisibleRangeGroupMap, bfContRge)
					}
				}
			}
		}

		outMap = append(outMap, outMapCont)
	}
	countSum := len(outMap)
	printData := commonus.OutPutList(total, int64(countSum), requestData.Page, requestData.PageSize, outMap)
	response.Result(0, printData, "查询成功！", c)
}

// 添加指标
func (d *DutyHandle) AddTarget(c *gin.Context) {
	var requestData addTargetType
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "参数错误！请重新提交！", c)
		return
	}
	if requestData.Title == "" {
		response.Result(102, err, "请输入指标名称！", c)
		return
	}
	if requestData.Type == 0 {
		requestData.Type = 1
	}
	if requestData.Share == 0 {
		requestData.Share = 1
	} else {
		if requestData.Share > 1 {
			if len(requestData.RelevantDepartments) == 0 {
				response.Result(103, err, "您选择了此指标为指定部门使用！但您未指定具体使用部门！请指定相关使用部门！", c)
				return
			}
		}
	}
	if requestData.Uniteing == "" {
		response.Result(104, err, "请输入计量单位！", c)
		return
	}
	if requestData.Cycles == 0 {
		requestData.Cycles = 4
	}
	if requestData.CycleAttres == 0 {
		requestData.CycleAttres = 1
	}
	if requestData.ScoringMethod == 0 {
		requestData.ScoringMethod = 1
	}
	gormDb := global.GVA_DB_Performanceappraisal
	gormDb = gormDb.Model(&assessmentmodel.EvaluationTarget{}).Select("et_title").Where("`et_title` = ? AND `et_type` = ?", requestData.Title, requestData.Type)
	dimensionId, dimensionErr := strconv.ParseInt(requestData.Dimension, 10, 64)
	if dimensionErr == nil && dimensionId != 0 {
		gormDb = gormDb.Where("`et_dimension` = ?", requestData.Dimension)
	}
	judgeOut := commonus.MapOut()
	judgeErr := gormDb.First(&judgeOut).Error
	if judgeErr == nil {
		response.Result(105, err, "此考核指标已经存在！请不要重复添加！", c)
		return
	}
	var saveData assessmentmodel.EvaluationTarget
	saveData.Title = requestData.Title
	saveData.Type = requestData.Type
	saveData.State = 1
	saveData.AddTime = time.Now().Unix()
	saveData.Share = requestData.Share
	if len(requestData.RelevantDepartments) > 0 {
		saveData.RelevantDepartments = strings.Join(requestData.RelevantDepartments, ",")
	}
	if dimensionErr == nil {
		saveData.Dimension = dimensionId
	}
	saveData.Key = commonus.GetFileNumberEs()
	if len(requestData.Report) > 0 {
		saveData.Report = strings.Join(requestData.Report, ",")
	}
	saveData.Uniteing = requestData.Uniteing
	saveData.Cycles = requestData.Cycles
	saveData.CycleAttres = requestData.CycleAttres

	if len(requestData.VisibleRangeGroup) > 0 {
		saveData.VisibleRangeGroup = strings.Join(requestData.VisibleRangeGroup, ",")
	}
	if len(requestData.VisibleRangeDepart) > 0 {
		saveData.VisibleRange = strings.Join(requestData.VisibleRangeDepart, ",")
	}
	saveData.ScoringMethod = requestData.ScoringMethod
	dutyInfoErr := global.GVA_DB_Performanceappraisal.Create(&saveData).Error
	if dutyInfoErr != nil {
		response.Result(106, saveData, "数据写入失败！", c)
	} else {
		response.Result(0, saveData, "数据写入成功！", c)
	}
}

// 计算可见范围
func calculVisibleRange(groupStr, depart []string) (visibleRange string) {
	if len(depart) > 0 {
		for d_index, d_val := range depart {
			if d_index == 0 {
				visibleRange = d_val
			} else {
				visibleRange = visibleRange + "," + d_val
			}
		}
		return
	} else {
		if len(groupStr) > 0 {
			for g_index, g_val := range groupStr {
				if g_index == 0 {
					visibleRange = getBranchFactoryList(g_val)
				} else {
					visibleRange = visibleRange + "," + getBranchFactoryList(g_val)
				}
			}
			return
		}
	}
	return
}

// 获得分厂列表
func getBranchFactoryList(id string) (bfIdStr string) {
	var ContInfo []testpage.BranchFactory
	err := global.GVA_DB_Master.Select("bf_id").Where("bf_group = ? AND `bf_set` = 1", id).Find(&ContInfo).Error
	if err != nil {
		return
	}
	for b_index, b_val := range ContInfo {
		if b_index == 0 {
			bfIdStr = strconv.FormatInt(b_val.Id, 10)
		} else {
			bfIdStr = bfIdStr + "," + strconv.FormatInt(b_val.Id, 10)
		}
	}
	return
}

// 获取考核指标详情
func (d *DutyHandle) GetTarget(c *gin.Context) {
	var requestData commonus.SetIds
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if requestData.Id == 0 && requestData.OutId == "" {
		response.Result(102, err, "参数错误！请重新提交！", c)
		return
	}
	if requestData.OutId != "" {
		idInt, inIntErr := strconv.ParseInt(requestData.OutId, 10, 64)
		if inIntErr == nil {
			requestData.Id = idInt
		}
	}
	var systemEvalCont outTargetInfo
	contErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.EvaluationTarget{}).Where("`et_id` = ?", requestData.Id).First(&systemEvalCont).Error
	if contErr != nil {
		response.Result(103, err, "数据获取失败！", c)
		return
	}
	if systemEvalCont.RelevantDepartments != "" {
		systemEvalCont.RelevantDepartmentMap = strings.Split(systemEvalCont.RelevantDepartments, ",")
		systemEvalCont.GroupMap = commonus.GetDuboDepart(strings.Split(systemEvalCont.RelevantDepartments, ","))
	}
	if systemEvalCont.Report != "" {
		systemEvalCont.ReportMap = strings.Split(systemEvalCont.Report, ",")
	}
	if systemEvalCont.VisibleRangeGroup != "" {
		systemEvalCont.VisibleRangeGroupMap = strings.Split(systemEvalCont.VisibleRangeGroup, ",")
	}
	if systemEvalCont.VisibleRange != "" {
		systemEvalCont.VisibleRangeDepartMap = strings.Split(systemEvalCont.VisibleRange, ",")
	}
	systemEvalCont.Share = 2
	systemEvalCont.DimensionIdStr = strconv.FormatInt(systemEvalCont.Dimension, 10)
	response.Result(0, systemEvalCont, "数据获取成功！", c)
}

// 编辑指标数据处理
func eiteTargetInfoes(saveId int64, saveData map[string]interface{}) (isTrue bool, infoErr error) {
	isTrue = false
	infoErr = global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.EvaluationTarget{}).Where("`et_id` = ?", saveId).Updates(saveData).Error
	if infoErr != nil {
		return
	}
	isTrue = true
	return
}

// 删除工段内容
func (d *DutyHandle) DelTarget(c *gin.Context) {
	var requestData dutyClassState
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, requestData, "数据获取失败！", c)
		return
	}
	if requestData.Id == 0 && requestData.OutId == "" {
		response.Result(102, err, "参数错误！请重新提交！", c)
		return
	}
	if requestData.OutId != "" {
		idInt, inIntErr := strconv.ParseInt(requestData.OutId, 10, 64)
		if inIntErr == nil {
			requestData.Id = idInt
		}
	}
	if requestData.State == 0 {
		requestData.State = 1
	}
	//判断该指标是否已经被使用过
	// var qualitativeEvaluationAry []assessmentmodel.QualitativeEvaluation
	var qeId int64 = 0
	judgeErrQe := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Select("qe_id").Where("`qe_state` IN (1,2) AND `qe_target` = ?", requestData.Id).Find(&qeId)
	if judgeErrQe == nil {
		if qeId != 0 {
			response.Result(103, qeId, "该指标已经再考核方案中使用！请先解除使用关系，再进行删除操作！", c)
			return
		}
	}
	saveData := commonus.MapOut()
	saveData["et_state"] = requestData.State
	saveData["et_time"] = time.Now().Unix()
	if requestData.IsDel != 1 {
		roleIsTrue, roleErr := eiteTargetInfoes(requestData.Id, saveData)
		if roleIsTrue != true {
			response.Result(103, roleErr, "修改失败！", c)
			return
		}
		response.Result(0, requestData, "修改成功！", c)
	} else {
		if requestData.State == 3 {
			roleErr := global.GVA_DB_Performanceappraisal.Where("et_id = ?", requestData.Id).Delete(&assessmentmodel.EvaluationTarget{}).Error
			if roleErr != nil {
				response.Result(104, saveData, "删除失败！", c)
				return
			}
			response.Result(0, saveData, "删除成功！", c)
		} else {
			roleIsTrue, roleErr := eiteTargetInfoes(requestData.Id, saveData)
			if roleIsTrue != true {
				response.Result(103, roleErr, "修改失败！", c)
				return
			}
			response.Result(0, requestData, "修改成功！", c)
		}
	}
}

// 修改指标内容
func (d *DutyHandle) EiteTarget(c *gin.Context) {
	var requestData eiteTargetTypeCont
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "数据获取失败！", c)
		return
	}
	if requestData.Id == 0 && requestData.OutId == "" {
		response.Result(102, err, "参数错误！请重新提交！", c)
		return
	}
	if requestData.OutId != "" {
		idInt, inIntErr := strconv.ParseInt(requestData.OutId, 10, 64)
		if inIntErr == nil {
			requestData.Id = idInt
		}
	}

	saveData := commonus.MapOut()

	var oldTargetCont assessmentmodel.EvaluationTarget
	targetInfoErr := global.GVA_DB_Performanceappraisal.Where("`et_id` = ?", requestData.Id).First(&oldTargetCont).Error
	if targetInfoErr != nil {
		response.Result(102, err, "该指标不存在！请检查您的参数！", c)
		return
	}
	if requestData.Title == "" {
		response.Result(102, err, "请输入指标名称！", c)
		return
	} else {
		if requestData.Title != oldTargetCont.Title {
			judgeTargetErr := global.GVA_DB_Performanceappraisal.Where("`et_title` = ? AND `et_type` = ?", requestData.Title, oldTargetCont.Type).First(&oldTargetCont).Error
			if judgeTargetErr == nil {
				response.Result(102, err, "该指标名称已经存在！请不要重复输入！", c)
				return
			}
		}
		saveData["et_title"] = requestData.Title
	}
	if requestData.Type != 0 {
		saveData["et_type"] = requestData.Type
	}

	if len(requestData.RelevantDepartments) > 0 {
		saveData["et_relevant_departments"] = strings.Join(requestData.RelevantDepartments, ",")
		saveData["et_share"] = 2
	} else {
		saveData["et_relevant_departments"] = ""
		saveData["et_share"] = 1
	}

	// if requestData.Share != 0 {
	// 	saveData["et_share"] = requestData.Share
	// 	if requestData.Share > 1 {
	// 		if len(requestData.RelevantDepartments) == 0 {
	// 			response.Result(103, err, "您选择了此指标为指定部门使用！但您未指定具体使用部门！请指定相关使用部门！", c)
	// 			return
	// 		}
	// 		saveData["et_relevant_departments"] = strings.Join(requestData.RelevantDepartments, ",")
	// 	} else {
	// 		saveData["et_relevant_departments"] = ""
	// 	}
	// }

	if requestData.Dimension != "" {
		saveData["et_dimension"] = requestData.Dimension
	}
	if len(requestData.Report) > 0 {
		saveData["et_report"] = strings.Join(requestData.Report, ",")
	}
	if requestData.Uniteing != "" {
		saveData["et_unit"] = requestData.Uniteing
	}
	if requestData.Cycles != 0 {
		saveData["et_cycle"] = requestData.Cycles
	}
	if requestData.CycleAttres != 0 {
		saveData["et_cycleattr"] = requestData.CycleAttres
	}
	if len(requestData.VisibleRangeGroup) > 0 {
		saveData["et_visible_group"] = strings.Join(requestData.VisibleRangeGroup, ",")
	}
	if len(requestData.VisibleRangeDepart) > 0 {
		saveData["et_visible_range"] = strings.Join(requestData.VisibleRangeDepart, ",")
	}

	if requestData.ScoringMethod != 0 {
		saveData["et_scoring_method"] = requestData.ScoringMethod
	}

	saveData["et_time"] = time.Now().Unix()
	roleIsTrue, roleErr := eiteTargetInfoes(requestData.Id, saveData)
	if roleIsTrue != true {
		response.Result(106, roleErr, "编辑失败!", c)
	} else {

		assTarEite := commonus.MapOut()
		assTarEite["departmentmap"] = saveData["et_relevant_departments"]
		assTarEite["time"] = time.Now().Unix()
		global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.Assesstarget{}).Where("`targetid` = ?", requestData.Id).Updates(assTarEite)

		if len(requestData.Report) > 0 {
			//获取原来的指标指定审批人
			var assessInfo []assessmentmodel.Assesstarget
			assessErr := global.GVA_DB_Performanceappraisal.Where("`targetid` = ?", requestData.Id).Find(&assessInfo).Error
			if assessErr == nil {
				for _, aev := range assessInfo {
					var assUser []DutyAssEssTarget
					assJsonErr := json.Unmarshal([]byte(aev.Content), &assUser)
					if assJsonErr == nil {
						var eiteAssUser []DutyAssEssTarget
						for _, ajv := range assUser {
							var eiteAssUserInfo DutyAssEssTarget
							eiteAssUserInfo.Id = ajv.Id
							eiteAssUserInfo.Operator = requestData.Report
							eiteAssUser = append(eiteAssUser, eiteAssUserInfo)
						}
						assTarEiteCont := commonus.MapOut()
						jsonAssUser, jsonAssUserErr := json.Marshal(eiteAssUser)
						if jsonAssUserErr == nil {
							assTarEiteCont["content"] = string(jsonAssUser)
							assTarEiteCont["time"] = time.Now().Unix()
							global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.Assesstarget{}).Where("`at_id` = ?", aev.Id).Updates(assTarEiteCont)
						}

					}

				}
			}
		}

		qualTarEite := commonus.MapOut()
		qualTarEite["q_depart"] = saveData["et_relevant_departments"]
		qualTarEite["q_time"] = time.Now().Unix()
		global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeTarget{}).Where("`q_parent_id` = ?", requestData.Id).Updates(qualTarEite)
		response.Result(0, saveData, "编辑成功!", c)
	}
}