gin_server_admin/api/v1/assessment/newassessment.go

package assessment

import (
	"fmt"
	"strconv"
	"strings"
	"time"

	"gin_server_admin/commonus"
	"gin_server_admin/global"
	"gin_server_admin/model/assessmentmodel"
)

// 添加卡片考核数据处理
func (d *dataLockStatistics) AddCardAssEss(deparmentId string, addData AddQualEval) {
	d.mutext.Lock()
	defer d.mutext.Unlock()
	//获取子目标情况
	sunTargetCont, sunTargetErr := judgeColumn(addData.Target, addData.TargetSun, addData.TargetSunTitle)
	if sunTargetErr != true {
	}
	// jsonCont, _ := json.Marshal(sunTargetCont)
	// fmt.Printf("jsonKKKK----------------->%v\n", string(jsonCont))
	groupInt, groupIntErr := strconv.ParseInt(addData.Group, 10, 64)
	if groupIntErr != nil {
		groupInt = 1
	}
	dimensionInt, departinIntErr := strconv.ParseInt(addData.Dimension, 10, 64)
	if departinIntErr != nil {
		dimensionInt = 0
	}
	targetInt, targetIntErr := strconv.ParseInt(addData.Target, 10, 64)
	if targetIntErr != nil {
		targetInt = 0
	}
	departmentIdInt, departmentIdIntErr := strconv.ParseInt(deparmentId, 10, 64)
	if departmentIdIntErr != nil {
		departmentIdInt = 0
	}
	// var dimIdInt int64 = 0
	//获取所属维度
	// targetInfo, targetInfoErr := commonus.GetDutyClassInfo(targetInt)
	targetInfo, targetInfoErr := commonus.GetTargetInfo(targetInt)
	// jsonDim, _ := json.Marshal(targetInfo)
	// fmt.Printf("dim---------------->%v\n", jsonDim)s
	if targetInfoErr == true {
		if dimensionInt == 0 {
			dimensionInt = targetInfo.Dimension
		}
	}

	addDepartDimension(addData.Group, strconv.FormatInt(dimensionInt, 10), addData.Dimension, 1)
	var jiBuQi int = 0
	var saveDataAry []assessmentmodel.QualitativeEvaluation
	for _, v := range addData.EvaluationList {

		wheAry := commonus.MapOut()

		var saveData assessmentmodel.QualitativeEvaluation

		saveData.Group = groupInt
		saveData.Type = addData.Type

		// departidInt, departinIntErr := strconv.ParseInt(v.DepartmentId, 10, 64)
		// if departinIntErr == nil {
		// 	saveData.DepartmentId = departidInt
		// }

		saveData.Dimension = dimensionInt

		saveData.Target = targetInt
		saveData.TargetSun = sunTargetCont.Id

		wheAry["qe_dimension"] = dimensionInt
		wheAry["qe_target"] = targetInt
		wheAry["qe_target_sun"] = sunTargetCont.Id
		wheAry["qe_group"] = groupInt
		wheAry["qe_type"] = addData.Type

		// targetSunInt, targetSunIntErr := strconv.ParseInt(addData.TargetSun, 10, 64)
		// if targetSunIntErr == nil {
		// 	saveData.TargetSun = targetSunInt
		// }
		explainCont, explainErr := judgeDetails(addData.Target, v.Title, v.Content, v.DetailedTarget, sunTargetCont.Id)
		if explainErr == true {
			saveData.DetailedTarget = explainCont.Id
			wheAry["qe_detailed_target"] = explainCont.Id
		}
		// detailedTargetInt, detailedTargetIntErr := strconv.ParseInt(v.DetailedTarget, 10, 64)
		// if detailedTargetIntErr == nil {
		// 	saveData.DetailedTarget = detailedTargetInt
		// }

		saveData.Unit = v.Unit
		saveData.ReferenceScore = v.ReferenceScore
		saveData.Cycles = v.Cycles
		saveData.CycleAttres = v.CycleAttres

		saveData.State = 1
		saveData.Addtime = time.Now().Unix()
		saveData.Eitetime = time.Now().Unix()

		if departmentIdInt != 0 {
			saveData.AcceptEvaluation = departmentIdInt
			wheAry["qe_accept_evaluation"] = departmentIdInt
		}
		saveData.Operator = strings.Join(v.Operator, ",")
		saveData.DepartmentId = strings.Join(GetDepartmentByUserBast(v.Operator), ",")

		//判断该项目是否存在！
		judgeIsSet := global.GVA_DB_Performanceappraisal.Where(wheAry).First(&saveData).Error

		if judgeIsSet == nil {
			jiBuQi++
			eiteData := commonus.MapOut()
			eiteData["qe_unit"] = v.Unit
			eiteData["qe_reference_score"] = v.ReferenceScore
			eiteData["qe_eitetime"] = time.Now().Unix()
			eiteData["qe_cycle"] = v.Cycles
			eiteData["qe_cycleattr"] = v.CycleAttres
			eiteData["qe_content"] = v.Content
			global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Where("qe_id = ?", saveData.Id).Updates(&eiteData)
		} else {
			saveDataAry = append(saveDataAry, saveData)
		}

		msg := commonus.MapOut()
		msg["msg"] = saveData
		d.dataMap = append(d.dataMap, msg)
	}
	if len(saveDataAry) > 0 {
		addErr := global.GVA_DB_Performanceappraisal.Create(&saveDataAry).Error
		if addErr != nil {
			msg := commonus.MapOut()
			msg["data"] = saveDataAry
			msg["msg"] = fmt.Sprintf("《%v》考核维度录入失败！请重新处理此方案", addData.Dimension)
			d.dataErrMap = append(d.dataErrMap, msg)
		}
	}
	commonus.AddDimenTargetWeight(int64(addData.Type), groupInt, departmentIdInt, dimensionInt, targetInt)
	syncProcess.Done()
}

//判断该子栏目是否存在
/*
@ascription				指标ID
@columId				子指标ID
@title					指标名称
*/
func judgeColumn(ascription, columId, title string) (content assessmentmodel.QualitativeTarget, isTrue bool) {
	isTrue = false
	if columId != "" {
		judgeIdErr := global.GVA_DB_Performanceappraisal.Where("`q_id` = ?", columId).First(&content).Error
		if judgeIdErr == nil {
			isTrue = true
			return
		}
	}
	judgeErr := global.GVA_DB_Performanceappraisal.Where("`q_parent_id` = ? AND `q_title` = ?", ascription, title).First(&content).Error
	if judgeErr == nil {
		isTrue = true
		return
	}
	ascriptionId, ascriptionErr := strconv.ParseInt(ascription, 10, 64)
	if ascriptionErr != nil {
		ascriptionId = 0
	}
	saveColum := assessmentmodel.QualitativeTarget{Title: title, ParentId: ascriptionId, State: 1, AddTime: time.Now().Unix()}
	addErr := global.GVA_DB_Performanceappraisal.Create(&saveColum).Error
	if addErr != nil {
		return
	}
	isTrue = true
	content = saveColum
	return
}

//判断考核细则是否存在
/*
参数说明
@ascription				归属指标栏目
@title					指标细则
@explain				指标说明'
@explainId				指标明细ID
@sunTargetId			子栏目
*/
func judgeDetails(ascription, title, explain, explainId string, sunTargetId int64) (content assessmentmodel.DetailedTarget, isTrue bool) {
	isTrue = false
	if explainId != "" {
		judgeIdErr := global.GVA_DB_Performanceappraisal.Where("`dt_id` = ?", explainId).First(&content).Error
		if judgeIdErr == nil {
			// fmt.Printf("echo --------------1---------->%v\n", content)
			isTrue = true
			return
		}
	}
	judgeErr := global.GVA_DB_Performanceappraisal.Where("`dt_parentid` = ? AND `dt_title` = ?", ascription, title).First(&content).Error
	if judgeErr == nil {
		isTrue = true
		// fmt.Printf("echo --------------2---------->%v\n", content)
		return
	}
	ascriptionId, ascriptionErr := strconv.ParseInt(ascription, 10, 64)
	if ascriptionErr != nil {
		ascriptionId = 0
	}
	saveColum := assessmentmodel.DetailedTarget{Title: title, Content: explain, ParentId: ascriptionId, ParentIdSun: sunTargetId, State: 1, AddTime: time.Now().Unix()}
	addErr := global.GVA_DB_Performanceappraisal.Create(&saveColum).Error
	if addErr != nil {
		// fmt.Printf("echo --------------3---------->%v\n", saveColum.Id)
		return
	}
	// fmt.Printf("echo --------------4---------->%v\n", saveColum.Id)
	isTrue = true
	content = saveColum
	return
}