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

package departmentpc

import (
	"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"
)

// 部门指标列表
func (a *ApiMethod) DepartmentTargetList(c *gin.Context) {
	var receivedValue departListQuery
	c.ShouldBindJSON(&receivedValue)
	if receivedValue.Page == 0 {
		receivedValue.Page = 1
	}
	if receivedValue.PageSize == 0 {
		receivedValue.PageSize = 20
	}
	gormDb := overall.CONSTANT_DB_KPI.Model(&modelskpi.EvaluationTarget{})
	if receivedValue.State != 0 { //状态（1：启用；2：禁用；3：删除）
		gormDb = gormDb.Where("et_state = ?", receivedValue.State)
	} else {
		gormDb = gormDb.Where("et_state BETWEEN  ? AND ?", 1, 2)
	}
	if receivedValue.Title != "" { //指标名称
		gormDb = gormDb.Where("et_state LIKE ?", "%"+receivedValue.Title+"%")
	}
	if receivedValue.Class != 0 { //1：定性考核；2：定量考核
		gormDb = gormDb.Where("et_type = ?", receivedValue.Class)
	}
	if receivedValue.DepartmentId != "" { //部门ID
		gormDb = gormDb.Where("FIND_IN_SET(?,`departments_post`)", receivedValue.DepartmentId)
	}
	if receivedValue.DimensionId != "" { //维度ID
		gormDb = gormDb.Where("et_dimension = ?", receivedValue.DimensionId)
	}
	if receivedValue.ReportPerson != "" { //上报人
		gormDb = gormDb.Where("FIND_IN_SET(?,`et_report`)", receivedValue.ReportPerson)
	}
	if receivedValue.ScoringMethod != 0 { //计分方式（1：自动；2：手动）
		gormDb = gormDb.Where("et_scoring_method = ?", receivedValue.ScoringMethod)
	}
	if receivedValue.Cycle != 0 { //1：班；2：天；3：周；4：月；5：季度；6：年
		gormDb = gormDb.Where("et_cycle = ?", receivedValue.Cycle)
	}

	var total int64
	totalErr := gormDb.Count(&total).Error
	if totalErr != nil {
		total = 0
	}
	var departmentTargetList []modelskpi.EvaluationTarget
	gormDb = publicmethod.PageTurningSettings(gormDb, receivedValue.Page, receivedValue.PageSize)
	err := gormDb.Order("`et_id` DESC").Find(&departmentTargetList).Error
	if err != nil {
		publicmethod.Result(105, err, c)
		return
	}
	var targetList []printDepartmentTarget
	for _, v := range departmentTargetList {
		var targetCont printDepartmentTarget
		targetCont.Id = v.Id
		targetCont.Title = v.Title                             //指标名称"`
		targetCont.Type = v.Type                               //1：定性考核；2：定量考核"`
		targetCont.State = v.State                             //状态（1：启用；2：禁用；3：删除）"`
		targetCont.AddTime = v.AddTime                         //制定时间"`
		targetCont.Share = v.Share                             //1：共用；2：私用"`
		targetCont.RelevantDepartments = v.RelevantDepartments //相关部门"`
		targetCont.Dimension = v.Dimension                     //维度"`
		targetCont.Key = v.Key                                 //UUID"`
		targetCont.Report = v.Report                           //上报人"`
		targetCont.Uniteing = v.Uniteing                       //计量单位"`
		targetCont.Cycles = v.Cycles                           //1：班；2：天；3：周；4：月；5：季度；6：年"`
		targetCont.CycleAttres = v.CycleAttres                 //辅助计数"`
		targetCont.VisibleRange = v.VisibleRange               //可见范围"`
		targetCont.VisibleRangeGroup = v.VisibleRangeGroup     //可见范围(集团)"`
		targetCont.ScoringMethod = v.ScoringMethod             //计分方式（1：自动；2：手动）"`
		var dutyClassCont modelskpi.DutyClass
		dutyClassCont.GetCont(map[string]interface{}{"`id`": v.Dimension}, "`title`")
		targetCont.DimensionTitle = dutyClassCont.Title
		targetList = append(targetList, targetCont)
	}
	publicmethod.ResultList(0, receivedValue.Page, receivedValue.PageSize, total, int64(len(targetList)), targetList, c)
}

// 实验查询
func (a *ApiMethod) Shiyan(c *gin.Context) {
	// var receivedValue departListQuery
	// c.ShouldBindJSON(&receivedValue)

	// if receivedValue.DepartmentId == "" {
	// 	receivedValue.DepartmentId = "316"
	// }
	// if receivedValue.DimensionId == "" {
	// 	receivedValue.DimensionId = "1"
	// }

	// var evalCont []modelskpi.EvaluationTarget

	// // gormDb := overall.CONSTANT_DB_KPI.Model(&modelskpi.EvaluationTarget{}).Select("evaluationtarget.*,(?) AS tdm", overall.CONSTANT_DB_KPI.Model(&modelskpi.TargetDepartment{}).Select("id").Where("department_id = ? AND target_id = et_id ", receivedValue.DepartmentId).Find(&modelskpi.TargetDepartment{})).Having("tdm IS NOT NULL").Find(&evalCont).Error
	// // fmt.Printf("gormDb----->%v----->%v\n", gormDb, evalCont)
	// err := overall.CONSTANT_DB_KPI.Raw("SELECT e.*,(SELECT id FROM target_department td WHERE td.department_id = ? AND td.post_id = ? AND td.target_id = e.et_id) as tdm FROM evaluationtarget e HAVING tdm IS NOT NULL", receivedValue.DepartmentId, receivedValue.DimensionId).Scan(&evalCont).Error
	// fmt.Printf("gormDb----->%v----->%v\n", err, evalCont)
	//校正部门级考核
	var dimeTargetList []modelskpi.DetailedTarget
	err := overall.CONSTANT_DB_KPI.Where("dt_state = 1").Find(&dimeTargetList).Error
	if err != nil || len(dimeTargetList) < 1 {
		publicmethod.Result(107, err, c)
		return
	}
	// fmt.Printf("总数---->%v\n", len(dimeTargetList))
	// var xieChengChuli []modelskpi.DetailedTarget
	// for i, v := range dimeTargetList {
	// 	if (i+1)%100 == 0 {
	// 		xieChengChuli = append(xieChengChuli, v)
	// 		fmt.Printf("循环--%v-->%v\n", i, len(xieChengChuli))
	// 		xieChengChuli = []modelskpi.DetailedTarget{}
	// 	} else {
	// 		xieChengChuli = append(xieChengChuli, v)
	// 	}
	// }

	for _, v := range dimeTargetList {
		xiaoZhengBuMen(v)
	}

	fmt.Printf("jieshu---->%v\n", len(dimeTargetList))
}

// 校正部门定性考核关联关系
func xiaoZhengBuMen(detaTar modelskpi.DetailedTarget) {
	if detaTar.Paretment != "" {
		bumenAry := strings.Split(detaTar.Paretment, ",")
		if len(bumenAry) > 0 {
			for _, v := range bumenAry {
				zbLmXzBm(detaTar.ParentId, detaTar.ParentIdSun, detaTar.Id, 3, v)
			}
		}
	}
}

//编辑指标、栏目、细则关联部门
/*
@tarId				指标
@sunId				栏目
@lawsId				细则
@class				类型（1：指标；2：子目标；3：细则）
@bumenId			部门
*/
func zbLmXzBm(tarId, sunId, lawsId int64, class int, bumenId string) {
	var tarDepCont modelskpi.TargetDepartment
	where := publicmethod.MapOut[string]()
	where["`target_id`"] = tarId
	where["`target_sun_id`"] = sunId
	where["`target_bylaws`"] = lawsId
	where["`department_id`"] = bumenId
	err := tarDepCont.GetCont(where, "`id`", "`state`")
	if err == nil {
		//存在，判断状态
		if tarDepCont.State != 1 { //不是启用状态，改为启用
			eidtWher := publicmethod.MapOut[string]()
			eidtWher["``id``"] = tarDepCont.Id
			saveErr := tarDepCont.EiteCont(eidtWher, map[string]interface{}{"`state`": 1, "`time`": time.Now().Unix()})

			fmt.Printf("编辑---->tarId----%v---->sunId----%v---->lawsId----%v---->class----%v---->bumenId----%v------>saveErr----->%v\n", tarId, sunId, lawsId, class, bumenId, saveErr)
		}
	} else {
		tarDepCont.TargetId = tarId      //指标ID"`
		tarDepCont.TargetSunId = sunId   //子目标"`
		tarDepCont.TargetBylaws = lawsId //指标细则"`
		tarDepCont.Type = class          //类型（1：指标；2：子目标；3：细则）"`
		bumenIdInt, _ := strconv.ParseInt(bumenId, 10, 64)
		tarDepCont.DepartmentId = bumenIdInt //部门ID"`
		tarDepCont.PostId = 0                //岗位ID"`
		tarDepCont.ReportPerson = ""         //上报人"`
		tarDepCont.State = 1                 //状态（1：启用；2：禁用；3：删除）"`
		tarDepCont.Time = time.Now().Unix()  //写入时间"`
		addErr := overall.CONSTANT_DB_KPI.Create(&tarDepCont).Error
		fmt.Printf("编辑---->tarId----%v---->sunId----%v---->lawsId----%v---->class----%v---->bumenId----%v------>saveErr----->%v\n", tarId, sunId, lawsId, class, bumenId, addErr)
	}
}

// 获取部门定性考核部门关联列表
func (a *ApiMethod) GetDepartAboutTarget(c *gin.Context) {
	var receivedValue publicmethod.PublicId
	err := c.ShouldBindJSON(&receivedValue)
	if err != nil {
		publicmethod.Result(100, err, c)
		return
	}
	var targetDepartmentID []int64
	disrErr := overall.CONSTANT_DB_KPI.Model(&modelskpi.TargetDepartment{}).Distinct("`department_id`").Where("`state` = 1 AND `target_id` = ?", receivedValue.Id).Find(&targetDepartmentID).Error
	if disrErr != nil {
		publicmethod.Result(107, err, c)
		return
	}
	var departmentList []modelshr.AdministrativeOrganization
	departErr := overall.CONSTANT_DB_HR.Model(&modelshr.AdministrativeOrganization{}).Select("`id`,`name`,`superior`,`ispower`").Where("`id` IN ?", targetDepartmentID).Find(&departmentList).Error
	if departErr != nil || len(departmentList) < 1 {
		publicmethod.Result(107, err, c)
		return
	}
	var outList []departOutcome
	for _, v := range departmentList {
		var outCont departOutcome
		outCont.Id = strconv.FormatInt(v.Id, 10)
		outCont.Name = v.Name
		outCont.Superior = strconv.FormatInt(v.Superior, 10)
		outCont.Ispower = v.IsPower
		outList = append(outList, outCont)
	}
	publicmethod.Result(0, outList, c)
}