gin_server_admin/api/v1/assessment/assesshandle.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) AssEssList(c *gin.Context) {
	var requestData assessRequest
	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 assessList assessmentmodel.AssessMentitems
	gormDb := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.AssessMentitems{})
	if requestData.ParentId != "" {
		parenId, parenIdErr := strconv.ParseInt(requestData.ParentId, 10, 64)
		if parenIdErr == nil {
			gormDb = gormDb.Where("`ai_parent` = ?", parenId)
		}

	}
	if requestData.Title != "" {
		gormDb = gormDb.Where("ai_title LIKE ?", "%"+requestData.Title+"%")
	}

	if requestData.State != 0 {
		gormDb = gormDb.Where("`ai_state` = ?", requestData.State)
	} else {
		gormDb = gormDb.Where("`ai_state` IN ?", []int{1, 2})
	}
	var total int64
	totalErr := gormDb.Count(&total).Error
	if totalErr != nil {
		total = 0
	}

	// response.Result(0, requestData, "查询成功！", c)
	var assessList []assessmentmodel.AssessMentitems
	assessListerr := gormDb.Limit(requestData.PageSize).Offset(offSetPage).Find(&assessList).Error
	if assessListerr != nil {
		response.Result(103, assessListerr, "数据获取失败！", c)
		return
	}
	var assessOutMap []assessOutput
	for _, val := range assessList {
		var assessOutInfo assessOutput
		assessOutInfo.Id = val.Id
		assessOutInfo.Title = val.Title
		assessOutInfo.Weight = val.Weight
		assessOutInfo.Fraction = val.Fraction
		assessOutInfo.Content = val.Content
		assessOutInfo.PartId = val.PartId
		assessOutInfo.Time = val.Time
		assessOutInfo.State = val.State

		assessOutInfo.Type = val.Type
		assessOutInfo.Unites = val.Unites
		assessOutInfo.Cycle = val.Cycle
		assessOutInfo.CycleAttr = val.CycleAttr

		assessOutInfo.OutId = strconv.FormatInt(val.Id, 10)
		assessOutInfo.ParentIdStr = strconv.FormatInt(val.PartId, 10)

		isTrue, parentCont := GetDutyClassCont(val.PartId)
		if isTrue == true {
			assessOutInfo.ParentTitle = parentCont.Title
		}

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

//添加考核项目
func (d *DutyHandle) AddAssEssInfo(c *gin.Context) {
	var requestData addAssEssInfo
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "参数错误！请重新提交！", c)
		return
	}
	if requestData.Title == "" {
		response.Result(102, err, "请输入考核项目名称", c)
		return
	}
	if requestData.ParentId == "" {
		response.Result(103, err, "请指定该考核项目归属于职责分类", c)
		return
	}
	if requestData.Type == 0 {
		requestData.Type = 1
	}
	// if requestData.UnitTitle == "" {
	// 	response.Result(105, err, "请输入计量单位", c)
	// 	return
	// }
	// if requestData.Cycle == 0 {
	// 	requestData.Cycle = 3
	// }
	// if requestData.CycleAttr == 0 {
	// 	requestData.CycleAttr = 1
	// }
	if requestData.Title != "" {
		outTitle := commonus.MapOut()
		assErrs := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.AssessMentitems{}).Where("ai_parent = ? AND ai_title = ?", requestData.ParentId, requestData.Title).First(&outTitle).Error
		if assErrs == nil {
			response.Result(106, assErrs, "该考核维度下已经存在此考核项目！请不要重复提交！", c)
			return
		}
	}

	var assessInfo assessmentmodel.AssessMentitems
	assessInfo.Id = commonus.GetFileNumberEs()
	assessInfo.Title = requestData.Title
	assessInfo.Weight = 0
	assessInfo.Fraction = 0
	assessInfo.Content = requestData.Content
	partIdInt, partIdIntErr := strconv.ParseInt(requestData.ParentId, 10, 64)
	if partIdIntErr == nil {
		assessInfo.PartId = partIdInt
	} else {
		assessInfo.PartId = 0
	}
	assessInfo.Time = time.Now().Unix()
	assessInfo.State = 1

	assessInfo.Type = requestData.Type
	assessInfo.Unites = requestData.UnitTitle
	assessInfo.Cycle = requestData.Cycle
	assessInfo.CycleAttr = requestData.CycleAttr

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

//获取考核项目详细内容
func (d *DutyHandle) GetAssEssInfo(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 assessOutInfo assessOutput
	inFoErr := global.GVA_DB_Performanceappraisal.Where("`ai_id` = ?", requestData.Id).First(&assessOutInfo).Error
	assessOutInfo.OutId = strconv.FormatInt(assessOutInfo.Id, 10)

	assessOutInfo.ParentIdStr = strconv.FormatInt(assessOutInfo.PartId, 10)
	isTrue, parentCont := GetDutyClassCont(assessOutInfo.PartId)
	if isTrue == true {
		assessOutInfo.ParentTitle = parentCont.Title
	}
	if inFoErr != nil {
		response.Result(103, inFoErr, "数据查询失败！", c)
		return
	}
	response.Result(0, assessOutInfo, "数据查询成功！", c)

}

//修改考核项目内容
func (d *DutyHandle) EiteAssEssInfo(c *gin.Context) {
	var requestData eiteAssEssCont
	err := c.ShouldBindJSON(&requestData)
	if err != nil {
		response.Result(101, err, "参数错误！请重新提交！", c)
		return
	}
	saveData := commonus.MapOut()
	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
	}
	if requestData.ParentId != "" {
		parentIdInt, parentErr := strconv.ParseInt(requestData.ParentId, 10, 64)
		if parentErr == nil {
			saveData["ai_parent"] = parentIdInt
		}

	}
	if requestData.Content != "" {
		saveData["ai_content"] = requestData.Content
	}

	if requestData.Type == 0 {
		saveData["ai_type"] = requestData.Type
	}
	if requestData.UnitTitle != "" {
		saveData["ai_unit"] = requestData.UnitTitle
	}
	if requestData.Cycle != 0 {
		saveData["ai_cycle"] = requestData.Cycle
	}
	if requestData.CycleAttr != 0 {
		saveData["ai_cycle_attr"] = requestData.CycleAttr
	}

	var assCont assessmentmodel.AssessMentitems
	assErr := global.GVA_DB_Performanceappraisal.Where("ai_id = ?", requestData.Id).First(&assCont).Error
	if assErr != nil {
		response.Result(105, assErr, "该条目不存在！请重新提交！", c)
		return
	}
	if requestData.Title != "" && requestData.Title != assCont.Title {
		outTitle := commonus.MapOut()
		assErrs := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.AssessMentitems{}).Where("ai_parent = ? AND ai_title = ?", assCont.PartId, requestData.Title).First(&outTitle).Error
		if assErrs == nil {
			response.Result(106, assErrs, "该考核维度下已经存在此考核项目！请不要重复提交！", c)
			return
		}
		saveData["ai_title"] = requestData.Title
	}
	var assessInfo assessmentmodel.AssessMentitems

	saveData["ai_time"] = time.Now().Unix()
	isTrue, isErr := eiteAssEssInfoCont(requestData.Id, assessInfo, saveData)
	if isTrue != true {
		response.Result(104, isErr, "修改失败！", c)
		return
	}
	response.Result(0, saveData, "修改成功！", c)
}

//考核项目编辑操作
func eiteAssEssInfoCont(saveId int64, modelInfo assessmentmodel.AssessMentitems, saveData map[string]interface{}) (isTrue bool, dutyClassInfoErr error) {
	isTrue = false
	dutyClassInfoErr = global.GVA_DB_Performanceappraisal.Model(&modelInfo).Where("ai_id = ?", saveId).Updates(saveData).Error
	if dutyClassInfoErr != nil {
		return
	}
	isTrue = true
	return
}

//修改考核项目的状态
func (d *DutyHandle) EiteAssEssState(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
	}
	saveData := commonus.MapOut()
	saveData["ai_state"] = requestData.State
	saveData["ai_time"] = time.Now().Unix()
	var eiteAssEssStateInfo assessmentmodel.AssessMentitems
	if requestData.IsDel != 1 {
		isTrue, dutyErr := eiteAssEssInfoCont(requestData.Id, eiteAssEssStateInfo, saveData)
		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("ai_id = ?", requestData.Id).Delete(&eiteAssEssStateInfo).Error
			if archiveInfoErr != nil {
				response.Result(104, requestData, "删除失败！", c)
				return
			}
			response.Result(0, requestData, "删除成功！", c)
		} else {
			isTrue, saveErr := eiteAssEssInfoCont(requestData.Id, eiteAssEssStateInfo, saveData)
			if isTrue != true {
				response.Result(105, saveErr, "修改失败！", c)
				return
			}
			response.Result(0, requestData, "修改成功！", c)
		}
	}
}

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

//获取职责项目及类别
func GetAssessClass(id int64) (istrue bool, sssessClass assessmentmodel.AssessClass) {
	istrue = false
	assessErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.AssessMentitems{}).Select("assessmentitems.*,dutyclass.*").Joins("left join dutyclass on dutyclass.id = assessmentitems.ai_parent").Where("`ai_id` = ?", id).First(&sssessClass).Error
	if assessErr != nil {
		return
	}
	istrue = true
	return
}