gin-vue-admin/gin_server_admin/api/v1/assessment/dutyhandle.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) Index(c *gin.Context) {
	outPut := commonus.MapOut()
	response.Result(0, outPut, "获取成功", c)
}

//职责类别列表
func (d *DutyHandle) DutyClassList(c *gin.Context) {
	var requestData dutyClassRequest
	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)
	var total int64 //获取所有数据
	//条件
	whereMap := commonus.MapOut()
	if requestData.State != 0 {
		whereMap["state"] = requestData.State
	}
	var dutyClassAry []assessmentmodel.DutyClass
	if requestData.Title != "" {
		listTitleErr := global.GVA_DB_Performanceappraisal.Where(whereMap).Where("`title` LIKE '%"+requestData.Title+"%' AND `state` IN ?", []int{1, 2}).Order("id DESC").Limit(requestData.PageSize).Offset(offSetPage).Find(&dutyClassAry).Error
		if listTitleErr != nil {
			response.Result(103, listTitleErr, "数据获取失败！", c)
			return
		}
		counrErr := global.GVA_DB_Performanceappraisal.Model(&dutyClassAry).Where(whereMap).Where("`title` LIKE '%"+requestData.Title+"%' AND `state` IN ?", []int{1, 2}).Count(&total).Error
		if counrErr != nil {
			total = 0
		}
	} else {
		listTitleErr := global.GVA_DB_Performanceappraisal.Where(whereMap).Where("`state` IN ?", []int{1, 2}).Order("sort ASC,id DESC").Limit(requestData.PageSize).Offset(offSetPage).Find(&dutyClassAry).Error
		if listTitleErr != nil {
			response.Result(103, listTitleErr, "数据获取失败！", c)
			return
		}
		counrErr := global.GVA_DB_Performanceappraisal.Model(&dutyClassAry).Where(whereMap).Where("`state` IN ?", []int{1, 2}).Count(&total).Error
		if counrErr != nil {
			total = 0
		}
	}
	var dutyClassOutputAry []dutyClassOutput
	for _, val := range dutyClassAry {
		var dutyClassCont dutyClassOutput
		dutyClassCont.Id = val.Id
		dutyClassCont.Title = val.Title
		dutyClassCont.Type = val.Type
		dutyClassCont.Weight = val.Weight
		dutyClassCont.Time = val.Time
		dutyClassCont.State = val.State
		dutyClassCont.OutId = strconv.FormatInt(val.Id, 10)
		dutyClassCont.Sort = val.Sort
		dutyClassCont.IsTrue = judgeIsTrue(val.Id)
		dutyClassOutputAry = append(dutyClassOutputAry, dutyClassCont)
	}
	countSum := len(dutyClassOutputAry)
	printData := commonus.OutPutList(total, int64(countSum), requestData.Page, requestData.PageSize, dutyClassOutputAry)
	// fmt.Printf("%v\n", printData)
	response.Result(0, printData, "查询成功！", c)
}

//判断是否已经被使用
func judgeIsTrue(classId int64) (isTrue int) {
	isTrue = 2
	var evalTarCont []assessmentmodel.EvaluationTarget
	err := global.GVA_DB_Performanceappraisal.Where("`et_dimension` = ?", classId).Find(&evalTarCont).Error
	if err == nil {
		if len(evalTarCont) > 0 {
			isTrue = 1
		}
	}
	return
}

//添加职责类别
func (d *DutyHandle) AddDutyClass(c *gin.Context) {
	var requestData dutyClassAdd
	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.Sort == 0 {
		requestData.Sort = 1000
	}
	outMap := commonus.MapOut()
	juadgeErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DutyClass{}).Select("title").Where("`title` = ?", requestData.Title).First(&outMap).Error
	if juadgeErr == nil {
		response.Result(102, err, "该考核维度已经存在！请不要重复添加！", c)
		return
	}
	var dutyClassCont assessmentmodel.DutyClass
	dutyClassCont.Id = commonus.GetFileNumberEs()
	dutyClassCont.Title = requestData.Title
	dutyClassCont.Type = requestData.Type
	dutyClassCont.Weight = 0
	dutyClassCont.State = 1
	dutyClassCont.Sort = requestData.Sort
	dutyClassCont.Time = time.Now().Unix()

	addArchiveFileErr := global.GVA_DB_Performanceappraisal.Create(&dutyClassCont).Error
	if addArchiveFileErr != nil {
		response.Result(108, dutyClassCont, "数据写入失败！", c)
	} else {
		response.Result(0, dutyClassCont, "数据写入成功！", c)
	}
}

//查看职责类别详情
func (d *DutyHandle) GetDutyClassInfo(c *gin.Context) {
	var requestData commonus.SetId
	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 dutyClassCont assessmentmodel.DutyClass
	inFoErr := global.GVA_DB_Performanceappraisal.Where("`id` = ?", requestData.Id).First(&dutyClassCont).Error
	if inFoErr != nil {
		response.Result(103, inFoErr, "数据查询失败！", c)
		return
	}
	response.Result(0, dutyClassCont, "数据查询成功！", c)
}

//修改职责类别内容
func (d *DutyHandle) EiteDutyClassInfo(c *gin.Context) {
	var requestData dutyClassEite
	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
		}
	}
	if requestData.Title == "" {
		response.Result(103, err, "请输入职责名称", c)
		return
	}

	var dutyClassCont assessmentmodel.DutyClass
	inFoErrJuadge := global.GVA_DB_Performanceappraisal.Where("`id` = ?", requestData.Id).First(&dutyClassCont).Error
	if inFoErrJuadge != nil {
		response.Result(103, inFoErrJuadge, "该考核维度不存在！请检查您的提交", c)
		return
	}
	if requestData.Title != dutyClassCont.Title {
		outMap := commonus.MapOut()
		juadgeErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DutyClass{}).Select("title").Where("`title` = ?", requestData.Title).First(&outMap).Error
		if juadgeErr == nil {
			response.Result(102, err, "该考核维度已经存在！请不要重复提交！", c)
			return
		}
	}

	//软处理
	saveData := commonus.MapOut()
	saveData["title"] = requestData.Title
	saveData["time"] = time.Now().Unix()
	if requestData.Sort != 0 {
		saveData["sort"] = requestData.Sort
	}
	var eiteDutyClass assessmentmodel.DutyClass
	inFoErr := global.GVA_DB_Performanceappraisal.Model(&eiteDutyClass).Where("`id` = ?", requestData.Id).Updates(saveData).Error
	if inFoErr != nil {
		response.Result(104, inFoErr, "数据编辑失败！", c)
		return
	}
	response.Result(0, eiteDutyClass, "数据编辑成功！", c)
}

//状态变更及删除
func (d *DutyHandle) StateDutyClass(c *gin.Context) {
	var requestData dutyClassState
	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
		}
	}
	if requestData.State == 0 {
		requestData.State = 1
	}
	var eiteDutyClass assessmentmodel.DutyClass
	if requestData.IsDel != 1 {
		isTrue, dutyErr := dutyInfoStateSet(eiteDutyClass, requestData)
		if isTrue != true {
			response.Result(103, dutyErr, "修改失败！", c)
			return
		}
		response.Result(0, requestData, "修改成功！", c)
	} else {
		if requestData.State == 3 {
			archiveInfoErr := global.GVA_DB_Performanceappraisal.Where("at_id = ?", requestData.Id).Delete(&eiteDutyClass).Error
			if archiveInfoErr != nil {
				response.Result(104, requestData, "删除失败！", c)
				return
			}
			response.Result(0, requestData, "删除成功！", c)
		} else {
			isTrue, saveErr := dutyInfoStateSet(eiteDutyClass, requestData)
			if isTrue != true {
				response.Result(105, saveErr, "修改失败！", c)
				return
			}
			response.Result(0, requestData, "修改成功！", c)
		}
	}
}

//状态软操作
func dutyInfoStateSet(dutyClassInfo assessmentmodel.DutyClass, arrData dutyClassState) (isTrue bool, dutyClassInfoErr error) {
	isTrue = false
	//软处理
	saveData := commonus.MapOut()
	saveData["state"] = arrData.State
	saveData["time"] = time.Now().Unix()
	dutyClassInfoErr = global.GVA_DB_Performanceappraisal.Model(&dutyClassInfo).Where("id = ?", arrData.Id).Updates(saveData).Error
	if dutyClassInfoErr != nil {
		return
	}
	isTrue = true
	return
}

//获取职责类别内容
func GetDutyClassCont(id int64) (isTrue bool, ContInfo assessmentmodel.DutyClass) {
	isTrue = false
	err := global.GVA_DB_Performanceappraisal.Where("id = ?", id).First(&ContInfo).Error
	if err == nil {
		isTrue = true
	}
	return
}