You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2074 lines
79 KiB
2074 lines
79 KiB
package dutyassess
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"strconv"
|
|
"strings"
|
|
"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 *DutyAssessApi) SelectDutyList(c *gin.Context) {
|
|
var evalTargetList []assessmentmodel.EvaluationTarget
|
|
err := global.GVA_DB_Performanceappraisal.Where("`et_type` = 1 AND `et_state` = 1").Find(&evalTargetList).Error
|
|
if err != nil {
|
|
response.Result(101, err, "没有数据！", c)
|
|
return
|
|
}
|
|
var listAry []DutySelectList
|
|
for _, v := range evalTargetList {
|
|
var cont DutySelectList
|
|
cont.Id = v.Id
|
|
|
|
cont.Title = v.Title
|
|
cont.Type = v.Type
|
|
cont.State = v.State
|
|
cont.AddTime = v.AddTime
|
|
cont.Share = v.Share
|
|
cont.RelevantDepartments = v.RelevantDepartments
|
|
cont.Dimension = v.Dimension
|
|
cont.Key = v.Key
|
|
cont.Report = v.Report
|
|
cont.Uniteing = v.Uniteing
|
|
cont.Cycles = v.Cycles
|
|
cont.CycleAttres = v.CycleAttres
|
|
cont.VisibleRange = v.VisibleRange
|
|
cont.VisibleRangeGroup = v.VisibleRangeGroup
|
|
cont.DepartmentList = strings.Split(v.RelevantDepartments, ",")
|
|
listAry = append(listAry, cont)
|
|
}
|
|
response.Result(0, listAry, "查询完成！", c)
|
|
}
|
|
|
|
// 定性考核列表（部门方案用的）
|
|
func (d *DutyAssessApi) DutyDepartmentList(c *gin.Context) {
|
|
var requestData getDepartAssObtains
|
|
err := c.ShouldBindJSON(&requestData)
|
|
if err != nil {
|
|
// response.Result(101, err, "参数错误！请重新提交！", c)
|
|
// return
|
|
}
|
|
var targetId []int64
|
|
gormDb := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Select("qe_target")
|
|
if requestData.DepartID != "" {
|
|
gormDb = gormDb.Where("`qe_accept_evaluation` = ?", requestData.DepartID)
|
|
}
|
|
gormDb = gormDb.Where("`qe_state` = 1 AND `qe_type` = 1")
|
|
listTargetErr := gormDb.Group("qe_target").Find(&targetId).Error
|
|
if listTargetErr != nil {
|
|
response.Result(101, listTargetErr, "没有数据！", c)
|
|
return
|
|
}
|
|
var targetList []OutDutyList
|
|
for _, v := range targetId {
|
|
var targetCont OutDutyList
|
|
targetCont.Id = strconv.FormatInt(v, 10)
|
|
tarCont, _ := commonus.GetTargetInfo(v)
|
|
|
|
targetCont.Target = strconv.FormatInt(v, 10) //指标ID
|
|
targetCont.TargetName = tarCont.Title //指标名称
|
|
targetCont.Dimension = strconv.FormatInt(tarCont.Dimension, 10) //维度ID
|
|
dutyClassCont, dutyClassErr := commonus.GetDutyClassInfo(tarCont.Dimension)
|
|
if dutyClassErr == true {
|
|
targetCont.DimensionName = dutyClassCont.Title //维度名称
|
|
}
|
|
targetCont.Content = "" //指标说明
|
|
targetCont.Unit = tarCont.Uniteing //单位"`
|
|
targetCont.ReferenceScore = 0 //标准分值"`
|
|
targetCont.Cycles = tarCont.Cycles //1：班；2：天；3：周；4：月；5：季度；6：年"`
|
|
targetCont.CycleAttres = tarCont.CycleAttres //辅助计数"`
|
|
targetCont.State = 1
|
|
targetCont.DepartmentId, targetCont.DepartmentAry = GetDutyFangAnDepart(v, 1)
|
|
|
|
shenPiRen := strings.Split(tarCont.Report, ",")
|
|
targetCont.UserList = shenPiRen
|
|
for _, v := range shenPiRen {
|
|
usCont, usErr := commonus.GetUserInfoPublic([]string{"worker_man.wm_number", "worker_man_data.wmd_name"}, map[string]interface{}{"wm_key": v})
|
|
if usErr == true {
|
|
var userCont QualEvalArrt
|
|
userCont.Id = v
|
|
userCont.Name = usCont.Name
|
|
targetCont.UserListAry = append(targetCont.UserListAry, userCont)
|
|
}
|
|
}
|
|
|
|
targetList = append(targetList, targetCont)
|
|
}
|
|
// var qualitativeEvaluationAry []assessmentmodel.QualitativeEvaluation
|
|
response.Result(0, targetList, "查询完成！", c)
|
|
}
|
|
|
|
// 获取方案中的所有所有相关部们
|
|
func GetDutyFangAnDepart(dutyId int64, class int) (departId []int64, departAry []DepartmentAryType) {
|
|
err := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Select("qe_accept_evaluation").Where("`qe_state` = 1 AND `qe_target` = ? AND `qe_type` = ?", dutyId, class).Group("qe_accept_evaluation").Find(&departId).Error
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
for _, v := range departId {
|
|
deparConErr, deparConCont := commonus.GetBranchFactory(v)
|
|
if deparConErr == true {
|
|
var departcont DepartmentAryType
|
|
departcont.Parentname = deparConCont.Name
|
|
departcont.Parentid = strconv.FormatInt(v, 10)
|
|
departAry = append(departAry, departcont)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// 根据指标ID获取列表信息
|
|
func (d *DutyAssessApi) IdToTargetSunList(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
|
|
}
|
|
}
|
|
tarCont, isTrue := commonus.GetTargetInfo(requestData.Id)
|
|
if isTrue != true {
|
|
response.Result(103, err, "数据获取失败！", c)
|
|
return
|
|
}
|
|
var targetCont TargetFormId
|
|
targetCont.Id = strconv.FormatInt(requestData.Id, 10)
|
|
targetCont.Target = strconv.FormatInt(requestData.Id, 10) //指标ID
|
|
targetCont.TargetName = tarCont.Title //指标名称
|
|
targetCont.Dimension = strconv.FormatInt(tarCont.Dimension, 10) //维度ID
|
|
dutyClassCont, dutyClassErr := commonus.GetDutyClassInfo(tarCont.Dimension)
|
|
if dutyClassErr == true {
|
|
targetCont.DimensionName = dutyClassCont.Title //维度名称
|
|
}
|
|
targetCont.Content = "" //指标说明
|
|
targetCont.Unit = tarCont.Uniteing //单位"`
|
|
targetCont.ReferenceScore = 0 //标准分值"`
|
|
targetCont.Cycles = tarCont.Cycles //1：班；2：天；3：周；4：月；5：季度；6：年"`
|
|
targetCont.CycleAttres = tarCont.CycleAttres //辅助计数"`
|
|
targetCont.State = 1
|
|
targetCont.DepartmentId, targetCont.DepartmentAry = GetDutyFangAnDepart(requestData.Id, 1)
|
|
targetCont.SunTargetList = GetSunTargetList(requestData.Id, tarCont.Dimension, targetCont.DepartmentId)
|
|
targetCont.Reportmap = strings.Split(tarCont.Report, ",")
|
|
|
|
// for _, vv := range jieguo {
|
|
// targetCont.SunTargetList = append(targetCont.SunTargetList, vv)
|
|
// }
|
|
// targetCont.SunTargetList = jieguo
|
|
// jsonstr, _ := json.Marshal(targetCont)
|
|
// fmt.Printf("+++++++++>%v----->\n", string(jsonstr))
|
|
response.Result(0, targetCont, "查询完成！", c)
|
|
}
|
|
|
|
// 获取子指标和指标详情
|
|
func GetSunTargetList(targetId, demID int64, parAryId []int64) (cont []SunTargetListType) {
|
|
var qualTargetCont []assessmentmodel.QualitativeTarget
|
|
err := global.GVA_DB_Performanceappraisal.Where("`q_state` = 1 AND `q_parent_id` = ?", targetId).Find(&qualTargetCont).Error
|
|
if err != nil {
|
|
return
|
|
}
|
|
// fmt.Printf("%v\n", qualTargetCont)
|
|
for _, v := range qualTargetCont {
|
|
var sunCont SunTargetListType
|
|
sunCont.Id = strconv.FormatInt(v.Id, 10)
|
|
sunCont.Title = v.Title
|
|
sunCont.DetailedTarget = GetDetailTrager(targetId, v.Id, demID, parAryId)
|
|
// fmt.Printf("-->%v-->%v\n", v.Id, v.Title)
|
|
cont = append(cont, sunCont)
|
|
}
|
|
// fmt.Printf("=========>%v\n", cont)
|
|
return
|
|
}
|
|
|
|
// 获取指标详情
|
|
func GetDetailTrager(targetId, detId, demID int64, parAryId []int64) (cont []DetailedTargetType) {
|
|
var qualTargetCont []assessmentmodel.DetailedTarget
|
|
err := global.GVA_DB_Performanceappraisal.Where("`dt_state` = 1 AND `dt_parentid` = ? AND `dt_parentid_sun` = ?", targetId, detId).Find(&qualTargetCont).Error
|
|
if err != nil {
|
|
return
|
|
}
|
|
for _, v := range qualTargetCont {
|
|
var sunCont DetailedTargetType
|
|
sunCont.Id = strconv.FormatInt(v.Id, 10)
|
|
sunCont.Title = v.Title
|
|
sunCont.UserList, sunCont.UserListAry = GetOperator(demID, targetId, detId, v.Id, parAryId)
|
|
cont = append(cont, sunCont)
|
|
}
|
|
return
|
|
}
|
|
|
|
// 获取执行人
|
|
func GetOperator(dimID, tarId, sunTarId, detaId int64, parAryId []int64) (UserList []string, UserListAry []QualEvalArrt) {
|
|
var qualEval []assessmentmodel.QualitativeEvaluation
|
|
err := global.GVA_DB_Performanceappraisal.Where("`qe_state` = 1 AND `qe_dimension` = ? AND `qe_target` = ? AND `qe_target_sun` = ? AND `qe_detailed_target` = ? AND `qe_accept_evaluation` IN ?", dimID, tarId, sunTarId, detaId, parAryId).Find(&qualEval).Error
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
for _, v := range qualEval {
|
|
if v.Operator != "" {
|
|
usAry := strings.Split(v.Operator, ",")
|
|
if len(usAry) > 0 {
|
|
for _, vv := range usAry {
|
|
|
|
if commonus.IsItTrueString(vv, UserList) == false {
|
|
UserList = append(UserList, vv)
|
|
usCont, usErr := commonus.GetUserInfoPublic([]string{"worker_man.wm_number", "worker_man_data.wmd_name"}, map[string]interface{}{"wm_key": vv})
|
|
if usErr == true {
|
|
var userCont QualEvalArrt
|
|
userCont.Id = vv
|
|
userCont.Name = usCont.Name
|
|
UserListAry = append(UserListAry, userCont)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// 获取定性指标->指标细则修改回显
|
|
func (d *DutyAssessApi) GetDetailedTargetCallBack(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 cont assessmentmodel.QualitativeEvaluation
|
|
errErr := global.GVA_DB_Performanceappraisal.Where("`qe_id` = ?", requestData.Id).Find(&cont).Error
|
|
if errErr != nil {
|
|
response.Result(103, err, "没有获取到数据！", c)
|
|
return
|
|
}
|
|
//输出格式
|
|
var content OutTargetCont
|
|
content.Id = strconv.FormatInt(requestData.Id, 10)
|
|
//获取子栏目信息
|
|
sunTargetCont, _ := commonus.GetQualitativeTargetInfo(cont.TargetSun)
|
|
content.SunTargerId = strconv.FormatInt(sunTargetCont.Id, 10)
|
|
content.SunTargetName = sunTargetCont.Title
|
|
//获取指标细则信息
|
|
detaileInfo, _ := commonus.GetDetailedTargetInfo(cont.DetailedTarget)
|
|
content.DetailedTargetId = strconv.FormatInt(detaileInfo.Id, 10)
|
|
content.DetailedTargetName = detaileInfo.Title
|
|
content.DetailedTargetContent = detaileInfo.Content
|
|
shenPiRen := strings.Split(cont.Operator, ",")
|
|
content.Operator = shenPiRen
|
|
for _, v := range shenPiRen {
|
|
usCont, usErr := commonus.GetUserInfoPublic([]string{"worker_man.wm_number", "worker_man_data.wmd_name"}, map[string]interface{}{"wm_key": v})
|
|
if usErr == true {
|
|
var userCont QualEvalArrt
|
|
userCont.Id = v
|
|
userCont.Name = usCont.Name
|
|
content.OperatorAry = append(content.OperatorAry, userCont)
|
|
}
|
|
}
|
|
//获取所有子栏目
|
|
var qualTar []assessmentmodel.QualitativeTarget
|
|
quaTarErr := global.GVA_DB_Performanceappraisal.Where("`q_parent_id` = ?", cont.Target).Find(&qualTar).Error
|
|
if quaTarErr == nil {
|
|
for _, s_v := range qualTar {
|
|
var sunTarCont QualEvalArrt
|
|
sunTarCont.Id = strconv.FormatInt(s_v.Id, 10)
|
|
sunTarCont.Name = s_v.Title
|
|
content.SunTargerList = append(content.SunTargerList, sunTarCont)
|
|
}
|
|
}
|
|
response.Result(0, content, "获取成功！", c)
|
|
}
|
|
|
|
// 获取定性指标->指标细则修改回显
|
|
func (d *DutyAssessApi) EiteDetailedTargetCallBack(c *gin.Context) {
|
|
var requestData GetEiteTargetCont
|
|
err := c.ShouldBindJSON(&requestData)
|
|
if err != nil {
|
|
response.Result(101, err, "数据获取失败！", c)
|
|
return
|
|
}
|
|
if requestData.Id == "" {
|
|
response.Result(102, err, "参数错误！请重新提交！", c)
|
|
return
|
|
}
|
|
var cont assessmentmodel.QualitativeEvaluation
|
|
errErr := global.GVA_DB_Performanceappraisal.Where("`qe_id` = ?", requestData.Id).Find(&cont).Error
|
|
if errErr != nil {
|
|
response.Result(103, err, "未能获取到数据！", c)
|
|
return
|
|
}
|
|
isTrue := false
|
|
if requestData.Class != 1 {
|
|
isTrue = NewEiteData(requestData, cont)
|
|
} else {
|
|
isTrue = NewAddData(requestData, cont)
|
|
}
|
|
if isTrue == false {
|
|
response.Result(104, err, "数据处理失败", c)
|
|
return
|
|
}
|
|
response.Result(0, err, "数据处理成功", c)
|
|
}
|
|
|
|
// 新增
|
|
func NewAddData(getData GetEiteTargetCont, oldData assessmentmodel.QualitativeEvaluation) (isTrue bool) {
|
|
isTrue = false
|
|
var detailedTargetInfo assessmentmodel.DetailedTarget
|
|
detailedTargetInfo.Title = getData.DetailedTargetName
|
|
detailedTargetInfo.Content = getData.DetailedTargetContent
|
|
detailedTargetInfo.ParentId = oldData.Target
|
|
detailedTargetInfo.ParentIdSun = oldData.TargetSun
|
|
detailedTargetInfo.State = 1
|
|
detailedTargetInfo.AddTime = time.Now().Unix()
|
|
addErr := global.GVA_DB_Performanceappraisal.Create(&detailedTargetInfo).Error
|
|
if addErr != nil {
|
|
return
|
|
}
|
|
var saveData assessmentmodel.QualitativeEvaluation
|
|
saveData.Title = oldData.Title
|
|
saveData.DepartmentId = oldData.DepartmentId
|
|
saveData.Dimension = oldData.Dimension
|
|
saveData.Target = oldData.Target
|
|
saveData.TargetSun = oldData.TargetSun
|
|
saveData.DetailedTarget = detailedTargetInfo.Id
|
|
saveData.Type = oldData.Type
|
|
saveData.Weight = oldData.Weight
|
|
saveData.Unit = oldData.Unit
|
|
saveData.ReferenceScore = oldData.ReferenceScore
|
|
saveData.State = oldData.State
|
|
saveData.Addtime = time.Now().Unix()
|
|
saveData.Eitetime = time.Now().Unix()
|
|
saveData.Group = oldData.Group
|
|
saveData.QualEvalId = oldData.QualEvalId
|
|
saveData.Cycles = oldData.Cycles
|
|
saveData.CycleAttres = oldData.CycleAttres
|
|
saveData.AcceptEvaluation = oldData.AcceptEvaluation
|
|
saveData.Operator = oldData.Operator
|
|
saveData.Content = oldData.Content
|
|
addErrQE := global.GVA_DB_Performanceappraisal.Create(&saveData).Error
|
|
if addErrQE != nil {
|
|
return
|
|
}
|
|
isTrue = true
|
|
return
|
|
}
|
|
|
|
// 修改
|
|
func NewEiteData(getData GetEiteTargetCont, oldData assessmentmodel.QualitativeEvaluation) (isTrue bool) {
|
|
isTrue = false
|
|
eiteDetailedInfo := commonus.MapOut()
|
|
eiteDetailedInfo["dt_time"] = time.Now().Unix()
|
|
if getData.DetailedTargetName != "" {
|
|
eiteDetailedInfo["dt_title"] = getData.DetailedTargetName
|
|
}
|
|
if getData.DetailedTargetContent != "" {
|
|
eiteDetailedInfo["dt_content"] = getData.DetailedTargetContent
|
|
}
|
|
eiteDetaInfoErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DetailedTarget{}).Where("`dt_id` = ?", oldData.DetailedTarget).Updates(&eiteDetailedInfo).Error
|
|
if eiteDetaInfoErr != nil {
|
|
return
|
|
}
|
|
if len(getData.Operator) > 0 {
|
|
eiteQualEvlInfo := commonus.MapOut()
|
|
eiteQualEvlInfo["qe_eitetime"] = time.Now().Unix()
|
|
eiteQualEvlInfo["qe_operator"] = strings.Join(getData.Operator, ",")
|
|
eiteQualEvlInfo["qe_department_id"] = strings.Join(commonus.GetDepartmentByUserBast(getData.Operator), ",")
|
|
eiteDetaQuaInfoErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Where("`qe_id` = ?", oldData.Id).Updates(&eiteQualEvlInfo).Error
|
|
if eiteDetaQuaInfoErr != nil {
|
|
return
|
|
}
|
|
}
|
|
isTrue = true
|
|
return
|
|
}
|
|
|
|
// 修改子栏目名称
|
|
func (d *DutyAssessApi) EiteSunTargetName(c *gin.Context) {
|
|
var requestData EiteTargetContListSun
|
|
err := c.ShouldBindJSON(&requestData)
|
|
if err != nil {
|
|
response.Result(101, err, "数据获取失败！", c)
|
|
return
|
|
}
|
|
if requestData.Id == "" {
|
|
response.Result(102, requestData, "参数错误！请重新提交！", c)
|
|
return
|
|
}
|
|
if requestData.Name == "" {
|
|
response.Result(103, err, "参数错误！请重新提交！", c)
|
|
return
|
|
}
|
|
if requestData.Group == "" {
|
|
response.Result(104, err, "参数错误！无法获取数据", c)
|
|
return
|
|
}
|
|
if requestData.Dimension == "" {
|
|
response.Result(105, err, "参数错误！无法获取数据", c)
|
|
return
|
|
}
|
|
if requestData.TargetId == "" {
|
|
response.Result(106, err, "参数错误！无法获取数据", c)
|
|
return
|
|
}
|
|
if len(requestData.Operator) < 1 {
|
|
response.Result(107, err, "没有执行人！", c)
|
|
return
|
|
}
|
|
|
|
var assCont assessmentmodel.Assesstarget
|
|
assErr := global.GVA_DB_Performanceappraisal.Where("`group` = ? AND `dimension` = ? AND `targetid` = ? AND `suntargetid` = ?", requestData.Group, requestData.Dimension, requestData.TargetId, requestData.Id).First(&assCont).Error
|
|
|
|
if assErr != nil {
|
|
response.Result(104, err, "没有该数据！", c)
|
|
return
|
|
}
|
|
|
|
var userMap []DutyAssEssTarget
|
|
|
|
jsonErr := json.Unmarshal([]byte(assCont.Content), &userMap)
|
|
var detaTargetid []int64
|
|
if jsonErr == nil {
|
|
var saveUserAry []DutyAssEssTarget
|
|
for _, um_v := range userMap {
|
|
var saveUserCont DutyAssEssTarget
|
|
saveUserCont.Id = um_v.Id
|
|
saveUserCont.Operator = requestData.Operator
|
|
saveUserAry = append(saveUserAry, saveUserCont)
|
|
detaTargetid = append(detaTargetid, um_v.Id)
|
|
}
|
|
if len(saveUserAry) > 0 {
|
|
eiteAssCont := commonus.MapOut()
|
|
eiteAssCont["time"] = time.Now().Unix()
|
|
eiteUserJson, _ := json.Marshal(saveUserAry)
|
|
eiteAssCont["content"] = string(eiteUserJson)
|
|
global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.Assesstarget{}).Where("`at_id` = ?", assCont.Id).Updates(eiteAssCont)
|
|
}
|
|
if len(detaTargetid) > 0 {
|
|
eiteAssContDeite := commonus.MapOut()
|
|
eiteAssContDeite["dt_time"] = time.Now().Unix()
|
|
if requestData.Cycles > 0 {
|
|
eiteAssContDeite["dt_cycle"] = requestData.Cycles
|
|
}
|
|
if requestData.CycleAttres > 0 {
|
|
eiteAssContDeite["dt_cycleattr"] = requestData.CycleAttres
|
|
}
|
|
if requestData.CensorType > 0 {
|
|
eiteAssContDeite["dt_censor_type"] = requestData.CensorType
|
|
}
|
|
eiteAssContDeite["dt_censor_cont"] = requestData.CensorCont
|
|
if requestData.CensorRate > 0 {
|
|
// eiteAssContDeite["dt_censor_rate"] = requestData.CensorRate
|
|
eiteAssContDeite["dt_cycle"] = requestData.CensorRate
|
|
}
|
|
if len(requestData.DepartmentMap) > 0 {
|
|
eiteAssContDeite["dt_paretment"] = strings.Join(requestData.DepartmentMap, ",")
|
|
}
|
|
|
|
global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DetailedTarget{}).Where("`dt_id` IN ?", detaTargetid).Updates(eiteAssContDeite)
|
|
}
|
|
}
|
|
|
|
var oldId int64
|
|
errCont := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeTarget{}).Select("q_id").Where("`q_id` = ?", requestData.Id).First(&oldId).Error
|
|
if errCont != nil {
|
|
response.Result(104, err, "没有该数据！", c)
|
|
return
|
|
}
|
|
eiteCont := commonus.MapOut()
|
|
eiteCont["q_time"] = time.Now().Unix()
|
|
eiteCont["q_title"] = requestData.Name
|
|
if len(requestData.DepartmentMap) > 0 {
|
|
eiteCont["q_depart"] = strings.Join(requestData.DepartmentMap, ",")
|
|
} else {
|
|
eiteCont["q_depart"] = ""
|
|
}
|
|
errEiteCont := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeTarget{}).Where("`q_id` = ?", requestData.Id).Updates(&eiteCont).Error
|
|
if errEiteCont != nil {
|
|
response.Result(105, err, "修改失败！", c)
|
|
return
|
|
}
|
|
WriteBackTargetDepartment(requestData.TargetId, requestData.DepartmentMap)
|
|
response.Result(0, err, "数据处理成功", c)
|
|
}
|
|
|
|
// 删除定性考核指标
|
|
func (d *DutyAssessApi) DelDutyTarget(c *gin.Context) {
|
|
var requestData QualEvalArrt
|
|
err := c.ShouldBindJSON(&requestData)
|
|
if err != nil {
|
|
response.Result(101, err, "数据获取失败！", c)
|
|
return
|
|
}
|
|
if requestData.Id == "" {
|
|
response.Result(102, err, "参数错误！请重新提交！", c)
|
|
return
|
|
}
|
|
eiteCont := commonus.MapOut()
|
|
eiteCont["qe_eitetime"] = time.Now().Unix()
|
|
eiteCont["qe_state"] = 3
|
|
errEiteCont := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Where("`qe_target` = ?", requestData.Id).Updates(&eiteCont).Error
|
|
if errEiteCont != nil {
|
|
response.Result(105, errEiteCont, "删除失败！", c)
|
|
return
|
|
}
|
|
response.Result(0, err, "数据处理成功", c)
|
|
}
|
|
|
|
// 删除子栏目及附属指标详情
|
|
func (d *DutyAssessApi) DelSunTarDimeat(c *gin.Context) {
|
|
var requestData QualEvalArrt
|
|
err := c.ShouldBindJSON(&requestData)
|
|
if err != nil {
|
|
response.Result(101, err, "数据获取失败！", c)
|
|
return
|
|
}
|
|
if requestData.Id == "" {
|
|
response.Result(102, err, "参数错误！请重新提交！", c)
|
|
return
|
|
}
|
|
var qualId int64
|
|
errEiteQualGuiShuCont := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeTarget{}).Select("q_parent_id").Where("`q_id` = ?", requestData.Id).First(&qualId).Error
|
|
if errEiteQualGuiShuCont != nil {
|
|
response.Result(103, err, "参数错误！请重新提交！", c)
|
|
return
|
|
}
|
|
eiteCont := commonus.MapOut()
|
|
eiteCont["qe_eitetime"] = time.Now().Unix()
|
|
eiteCont["qe_state"] = 3
|
|
errEiteCont := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Where("`qe_target_sun` = ?", requestData.Id).Updates(&eiteCont).Error
|
|
if errEiteCont != nil {
|
|
response.Result(105, errEiteCont, "删除失败！", c)
|
|
return
|
|
}
|
|
eiteQualTar := commonus.MapOut()
|
|
eiteQualTar["q_time"] = time.Now().Unix()
|
|
eiteQualTar["q_state"] = 3
|
|
errEiteQualCont := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeTarget{}).Where("`q_id` = ?", requestData.Id).Updates(&eiteQualTar).Error
|
|
if errEiteQualCont == nil {
|
|
eiteQualTarDited := commonus.MapOut()
|
|
eiteQualTarDited["dt_time"] = time.Now().Unix()
|
|
eiteQualTarDited["dt_state"] = 3
|
|
global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DetailedTarget{}).Where("`dt_parentid` = ? AND `dt_parentid_sun` = ?", qualId, requestData.Id).Updates(&eiteQualTarDited)
|
|
}
|
|
|
|
response.Result(0, err, "数据处理成功", c)
|
|
}
|
|
|
|
// 添加 定性考核指标关系指定
|
|
func (d *DutyAssessApi) AddDutyRelationOld(c *gin.Context) {
|
|
var requestData AddQualEval
|
|
err := c.ShouldBindJSON(&requestData)
|
|
if err != nil {
|
|
// response.Result(101, err, "数据获取失败！", c)
|
|
// return
|
|
}
|
|
if requestData.Group == "" {
|
|
response.Result(102, err, "请选择归属集团", c)
|
|
return
|
|
}
|
|
if len(requestData.AcceptDepartmentId) <= 0 {
|
|
response.Result(103, err, "请选择接受考核的部门！", c)
|
|
return
|
|
}
|
|
// if requestData.Dimension == "" {
|
|
// response.Result(102, err, "请选择考核维度", c)
|
|
// return
|
|
// }
|
|
if requestData.Target == "" {
|
|
response.Result(104, err, "请选择考核指标", c)
|
|
return
|
|
}
|
|
if requestData.TargetSunTitle == "" {
|
|
response.Result(105, err, "请输入栏目名称！", c)
|
|
return
|
|
}
|
|
if len(requestData.EvaluationList) <= 0 {
|
|
response.Result(106, err, "请添加测评详情！", c)
|
|
return
|
|
}
|
|
// fmt.Printf("kjh------11------>%v\n", requestData)
|
|
sunTarDepartStr := strings.Join(requestData.AcceptDepartmentId, ",")
|
|
//获取子目标情况
|
|
sunTargetCont, sunTargetErr := commonus.JudgeColumn(requestData.Target, requestData.TargetSun, requestData.TargetSunTitle, sunTarDepartStr)
|
|
if sunTargetErr != true {
|
|
}
|
|
//将集团Id转化成整型
|
|
groupInt, groupIntErr := strconv.ParseInt(requestData.Group, 10, 64)
|
|
if groupIntErr != nil {
|
|
groupInt = 1
|
|
}
|
|
//指标
|
|
targetInt, targetIntErr := strconv.ParseInt(requestData.Target, 10, 64)
|
|
if targetIntErr != nil {
|
|
targetInt = 0
|
|
}
|
|
//维度
|
|
dimensionInt, departinIntErr := strconv.ParseInt(requestData.Dimension, 10, 64)
|
|
if departinIntErr != nil {
|
|
dimensionInt = 0
|
|
}
|
|
if dimensionInt == 0 {
|
|
targetInfo, targetInfoErr := commonus.GetTargetInfo(targetInt)
|
|
if targetInfoErr == true {
|
|
dimensionInt = targetInfo.Dimension
|
|
}
|
|
}
|
|
//关联集团部门考核维度
|
|
commonus.AddDepartDimension(requestData.Group, strconv.FormatInt(dimensionInt, 10), requestData.Dimension, 1)
|
|
|
|
//原指标细则
|
|
var oldId []int64
|
|
global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DetailedTarget{}).Select("`dt_id`").Where("`dt_state` = 1 AND `dt_parentid` = ? AND `dt_parentid_sun` = ?", requestData.Target, sunTargetCont.Id).Find(&oldId)
|
|
//遍历指标细则
|
|
var targetContList []DutyAssEssTarget
|
|
|
|
var newAddId []int64
|
|
for _, v := range requestData.EvaluationList {
|
|
// detailedTargetInfo, dtiIsTrue := commonus.JudgeDetails(requestData.Target, v.Title, v.Content, v.DetailedTarget, sunTargetCont.Id)
|
|
// detailedTargetInfo, dtiIsTrue := commonus.JudgeDetailsCopy(requestData.Target, v.Title, v.Content, v.DetailedTarget, v.ReferenceScore, v.Unit, sunTargetCont.Id, v.AddOrReduce)
|
|
// fmt.Printf("关联部门------11------>%v\n", sunTarDepartStr)
|
|
// panic(sunTarDepartStr)
|
|
detailedTargetInfo, dtiIsTrue := JudgeDetailsCopyEs(requestData.Target, sunTarDepartStr, sunTargetCont.Id, v)
|
|
|
|
/*
|
|
参数说明
|
|
@ascription 归属指标栏目
|
|
@title 指标细则
|
|
@explain 指标说明'
|
|
@explainId 指标明细ID
|
|
@ReferenceScore 分数
|
|
@CompanyCont 单位
|
|
@sunTargetId 子栏目
|
|
*/
|
|
|
|
if dtiIsTrue == true {
|
|
if detailedTargetInfo.Id != 0 {
|
|
newAddId = append(newAddId, detailedTargetInfo.Id)
|
|
var targetContInfo DutyAssEssTarget
|
|
targetContInfo.Id = detailedTargetInfo.Id
|
|
targetContInfo.Operator = v.Operator
|
|
targetContList = append(targetContList, targetContInfo)
|
|
}
|
|
}
|
|
}
|
|
|
|
mergeMap := append(oldId, newAddId...) //合并两个数组
|
|
var finalResultId []int64 //最终结果
|
|
for _, m_v := range mergeMap {
|
|
if commonus.IsItTrue(m_v, finalResultId) != true {
|
|
finalResultId = append(finalResultId, m_v)
|
|
}
|
|
}
|
|
|
|
//组合写入数据
|
|
for _, f_v := range finalResultId {
|
|
if commonus.IsItTrue(f_v, newAddId) != true {
|
|
var targetContInfos DutyAssEssTarget
|
|
targetContInfos.Id = f_v
|
|
targetContList = append(targetContList, targetContInfos)
|
|
}
|
|
}
|
|
// response.Result(0, targetContList, "处理成功！", c)
|
|
// return
|
|
//判断该集团指标子栏目是否存在
|
|
var arTaegetInfo assessmentmodel.Assesstarget
|
|
judgeARTErr := global.GVA_DB_Performanceappraisal.Where("`group` = ? AND `dimension` = ? AND `targetid` = ? AND `suntargetid` = ?", groupInt, dimensionInt, targetInt, sunTargetCont.Id).First(&arTaegetInfo).Error
|
|
|
|
//判断指标是否存在并且获取已存在的所有指标关联部门
|
|
var guanLianBuMen []string
|
|
for _, vvk_vs := range requestData.AcceptDepartmentId {
|
|
if commonus.IsItTrueString(vvk_vs, guanLianBuMen) == false {
|
|
guanLianBuMen = append(guanLianBuMen, vvk_vs)
|
|
}
|
|
}
|
|
var sunTarId []int64
|
|
judgeARkTErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.Assesstarget{}).Select("`suntargetid`").Where("`group` = ? AND `dimension` = ? AND `targetid` = ? ", groupInt, dimensionInt, targetInt).Find(&sunTarId).Error
|
|
// fmt.Printf("kjh------1------>%v------>%v\n", sunTarId, judgeARkTErr)
|
|
if judgeARkTErr == nil {
|
|
var sunTarDepartMap []string
|
|
judgeSunTarkTErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeTarget{}).Select("`q_depart`").Where("`q_id` IN ?", sunTarId).Find(&sunTarDepartMap).Error
|
|
// fmt.Printf("kjh------2------>%v\n", sunTarDepartMap)
|
|
if judgeSunTarkTErr == nil {
|
|
// var departStrAry []string
|
|
for _, vvk := range sunTarDepartMap {
|
|
departStrAry := strings.Split(vvk, ",")
|
|
for _, vvk_v := range departStrAry {
|
|
if commonus.IsItTrueString(vvk_v, guanLianBuMen) == false {
|
|
guanLianBuMen = append(guanLianBuMen, vvk_v)
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
eiteContkk := commonus.MapOut()
|
|
eiteContkk["departmentmap"] = strings.Join(guanLianBuMen, ",")
|
|
eiteContkk["time"] = time.Now().Unix()
|
|
global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.Assesstarget{}).Where("`suntargetid` IN ?", sunTarId).Updates(eiteContkk)
|
|
// fmt.Printf("kjh------3------>%v\n", eiteContkk)
|
|
}
|
|
|
|
if judgeARTErr == nil {
|
|
|
|
var eiteTarList []DutyAssEssTarget
|
|
// var eiteId []int64
|
|
if arTaegetInfo.Content != "" && arTaegetInfo.Content != "null" {
|
|
var tarList []DutyAssEssTarget
|
|
jsonErr := json.Unmarshal([]byte(arTaegetInfo.Content), &tarList)
|
|
if jsonErr == nil {
|
|
// if len(tarList) > len(targetContList) {
|
|
// for _, tl_v := range tarList {
|
|
|
|
// tarInfo, tarInfoErr := JudgeDeiScor(tl_v.Id, targetContList)
|
|
// if tarInfoErr == false {
|
|
// eiteTarList = append(eiteTarList, tarInfo)
|
|
// } else {
|
|
// eiteTarList = append(eiteTarList, tl_v)
|
|
// }
|
|
// }
|
|
// } else {
|
|
// for _, ttl_v := range targetContList {
|
|
// tarInfo, tarInfoErr := JudgeDeiScor(ttl_v.Id, tarList)
|
|
// if tarInfoErr == true {
|
|
// eiteTarList = append(eiteTarList, tarInfo)
|
|
// } else {
|
|
// eiteTarList = append(eiteTarList, ttl_v)
|
|
// }
|
|
|
|
// }
|
|
// }
|
|
for _, ttl_v := range targetContList {
|
|
eiteTarList = append(eiteTarList, ttl_v)
|
|
}
|
|
for _, tl_v := range tarList {
|
|
_, tarInfoErr := JudgeDeiScor(tl_v.Id, targetContList)
|
|
if tarInfoErr == false {
|
|
eiteTarList = append(eiteTarList, tl_v)
|
|
}
|
|
}
|
|
}
|
|
|
|
} else {
|
|
eiteTarList = targetContList
|
|
}
|
|
|
|
// fmt.Printf("llllllllllll----->%v\n", newAddId)
|
|
|
|
eiteCont := commonus.MapOut()
|
|
|
|
// oldDepartAry := strings.Join(",",",")
|
|
// oldDepartAry := strings.Split(arTaegetInfo.Departmentmap, ",")
|
|
// mergeDepartMap := append(oldDepartAry, requestData.AcceptDepartmentId...)
|
|
|
|
// var finalResultDepartId []string //最终结果
|
|
// for _, mdm_v := range mergeDepartMap {
|
|
// if commonus.IsItTrueString(mdm_v, finalResultDepartId) != true {
|
|
// finalResultDepartId = append(finalResultDepartId, mdm_v)
|
|
// }
|
|
// }
|
|
|
|
// eiteCont["departmentmap"] = strings.Join(requestData.AcceptDepartmentId, ",")
|
|
// eiteCont["departmentmap"] = strings.Join(guanLianBuMen, ",")
|
|
eiteCont["time"] = time.Now().Unix()
|
|
jsonStr, jsonMErr := json.Marshal(eiteTarList)
|
|
if jsonMErr == nil {
|
|
eiteCont["content"] = string(jsonStr)
|
|
}
|
|
|
|
eiteErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.Assesstarget{}).Where("`at_id` = ?", arTaegetInfo.Id).Updates(eiteCont).Error
|
|
if eiteErr == nil {
|
|
response.Result(0, err, "处理成功！1", c)
|
|
} else {
|
|
response.Result(107, err, "请添加测评详情！", c)
|
|
}
|
|
} else {
|
|
arTaegetInfo.Group = groupInt
|
|
|
|
arTaegetInfo.Departmentmap = strings.Join(guanLianBuMen, ",")
|
|
arTaegetInfo.TargetId = targetInt
|
|
arTaegetInfo.SunTargetId = sunTargetCont.Id
|
|
arTaegetInfo.Dimension = dimensionInt
|
|
jsonStr, jsonMErr := json.Marshal(targetContList)
|
|
if jsonMErr == nil {
|
|
arTaegetInfo.Content = string(jsonStr)
|
|
}
|
|
arTaegetInfo.Time = time.Now().Unix()
|
|
addErr := global.GVA_DB_Performanceappraisal.Create(&arTaegetInfo).Error
|
|
if addErr == nil {
|
|
response.Result(0, err, "处理成功！2", c)
|
|
} else {
|
|
response.Result(107, err, "请添加测评详情！", c)
|
|
}
|
|
}
|
|
}
|
|
|
|
// 判断是否存在项目
|
|
func JudgeDeiScor(id int64, listCont []DutyAssEssTarget) (cont DutyAssEssTarget, isTrue bool) {
|
|
isTrue = false
|
|
for _, v := range listCont {
|
|
if id == v.Id {
|
|
cont = v
|
|
isTrue = true
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// 获取定性考核指标关系指定列表
|
|
func (d *DutyAssessApi) GetDutyRelationList(c *gin.Context) {
|
|
var targetAssessAry []assessmentmodel.Assesstarget
|
|
errGroup := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.Assesstarget{}).Select("`group`,`dimension`,`targetid`").Group("`group`,`dimension`,`targetid`").Order("`group` ASC").Order("`dimension` ASC").Order("`targetid` ASC").Find(&targetAssessAry).Error
|
|
if errGroup != nil {
|
|
response.Result(107, errGroup, "没有信息", c)
|
|
return
|
|
}
|
|
var outContList []dutyOutNew
|
|
for _, v := range targetAssessAry {
|
|
var tarContMap assessmentmodel.EvaluationTarget
|
|
tarErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.EvaluationTarget{}).Select("`et_title`,`et_cycle`,`et_cycleattr`").Where("`et_id` = ?", v.TargetId).First(&tarContMap).Error
|
|
if tarErr == nil {
|
|
var outInfo dutyOutNew
|
|
outInfo.Group = strconv.FormatInt(v.Group, 10)
|
|
//维度信息
|
|
dutyClassCont, _ := commonus.GetDutyClassInfo(v.Dimension)
|
|
outInfo.Dimension = strconv.FormatInt(v.Dimension, 10)
|
|
outInfo.Dimensionname = dutyClassCont.Title
|
|
|
|
//指标信息
|
|
outInfo.Target = strconv.FormatInt(v.TargetId, 10)
|
|
tarCont, _ := commonus.GetTargetInfo(v.TargetId)
|
|
outInfo.Targetname = tarCont.Title
|
|
outInfo.Cycles = tarCont.Cycles //1：班；2：天；3：周；4：月；5：季度；6：年"`
|
|
outInfo.CycleAttres = tarCont.CycleAttres //辅助计数"`
|
|
|
|
outInfo.Departmentid, outInfo.Departmentmap, outInfo.UserList, outInfo.UserListAry = jieXiDutyList(v.Group, v.Dimension, v.TargetId)
|
|
|
|
outContList = append(outContList, outInfo)
|
|
}
|
|
|
|
}
|
|
|
|
response.Result(0, outContList, "查询完成！", c)
|
|
return
|
|
// var list []assessmentmodel.Assesstarget
|
|
// err := global.GVA_DB_Performanceappraisal.Order("`group` ASC").Order("`targetid` ASC").Order("`suntargetid` ASC").Find(&list).Error
|
|
// if err != nil {
|
|
// response.Result(107, err, "没有信息", c)
|
|
// return
|
|
// }
|
|
// var outList []OutDutyListes
|
|
// for _, v := range list {
|
|
// var outCont OutDutyListes
|
|
|
|
// outCont.Id = strconv.FormatInt(v.Id, 10)
|
|
// outCont.Group = strconv.FormatInt(v.Group, 10)
|
|
// //指标信息
|
|
// outCont.Target = strconv.FormatInt(v.TargetId, 10)
|
|
// tarCont, _ := commonus.GetTargetInfo(v.TargetId)
|
|
// outCont.TargetName = tarCont.Title
|
|
// //维度信息
|
|
// dutyClassCont, _ := commonus.GetDutyClassInfo(tarCont.Dimension)
|
|
// outCont.Dimension = strconv.FormatInt(tarCont.Dimension, 10)
|
|
// outCont.DimensionName = dutyClassCont.Title
|
|
|
|
// outCont.Content = "" //指标说明
|
|
// outCont.Unit = tarCont.Uniteing //单位"`
|
|
// outCont.ReferenceScore = 0 //标准分值"`
|
|
// outCont.Cycles = tarCont.Cycles //1：班；2：天；3：周；4：月；5：季度；6：年"`
|
|
// outCont.CycleAttres = tarCont.CycleAttres //辅助计数"`
|
|
// outCont.State = 1
|
|
|
|
// // outCont.DepartmentId, outCont.DepartmentAry = commonus.GetBranchDepartAry(strings.Split(v.Departmentmap, ","))
|
|
// outCont.DepartmentId, outCont.DepartmentAry = commonus.GetNewOrgList(strings.Split(v.Departmentmap, ","))
|
|
|
|
// shenPiRen := strings.Split(tarCont.Report, ",")
|
|
// outCont.UserList = shenPiRen
|
|
// for _, v := range shenPiRen {
|
|
// // usCont, usErr := commonus.GetWorkUser(v)
|
|
// userWher := commonus.MapOut()
|
|
// userWher["key"] = v
|
|
// usCont, usErr := commonus.GetNewHrPeopleInfo(userWher)
|
|
// // GetWorkUser
|
|
// if usErr == true {
|
|
// var userCont QualEvalArrt
|
|
// userCont.Id = v
|
|
// userCont.Name = usCont.Name
|
|
// userCont.Icon = usCont.Icon
|
|
|
|
// where := commonus.MapOut()
|
|
// // where["id"] = usCont.Group
|
|
// where["id"] = usCont.Company
|
|
// orgCont, _ := commonus.GetNewOrgCont(where, "id", "name", "abbreviation")
|
|
// userCont.GroupName = orgCont.Name
|
|
// if orgCont.Abbreviation != "" {
|
|
// userCont.GroupName = orgCont.Abbreviation
|
|
// }
|
|
|
|
// whereDepart := commonus.MapOut()
|
|
// // whereDepart["id"] = usCont.DepartmentId
|
|
// whereDepart["id"] = usCont.Deparment
|
|
// orgContDepart, _ := commonus.GetNewOrgCont(whereDepart, "id", "name")
|
|
// userCont.DepartmentName = orgContDepart.Name
|
|
|
|
// // _, groupInfo := commonus.GetGroupCont(usCont.Group)
|
|
// // userCont.GroupName = groupInfo.Name
|
|
// // _, bfInfo := commonus.GetBranchFactory(usCont.DepartmentId)
|
|
// // userCont.DepartmentName = bfInfo.Name
|
|
// userCont.Number = usCont.Number
|
|
// outCont.UserListAry = append(outCont.UserListAry, userCont)
|
|
// }
|
|
// }
|
|
|
|
// outList = append(outList, outCont)
|
|
// }
|
|
// response.Result(0, outList, "查询完成！", c)
|
|
}
|
|
|
|
// 查看定性考核项目详情
|
|
func (d *DutyAssessApi) LookDutyTargetInfoOld(c *gin.Context) {
|
|
var requestData LookTargetContList
|
|
err := c.ShouldBindJSON(&requestData)
|
|
if err != nil {
|
|
response.Result(101, err, "数据获取失败！", c)
|
|
return
|
|
}
|
|
if requestData.Group == "" {
|
|
response.Result(102, err, "参数错误！无法获取数据", c)
|
|
return
|
|
}
|
|
if requestData.Dimension == "" {
|
|
response.Result(103, err, "参数错误！无法获取数据", c)
|
|
return
|
|
}
|
|
if requestData.TargetId == "" {
|
|
response.Result(104, err, "参数错误！无法获取数据", c)
|
|
return
|
|
}
|
|
var assessInfoList []assessmentmodel.Assesstarget
|
|
goromDb := global.GVA_DB_Performanceappraisal.Where("`group` = ? AND `dimension` = ? AND `targetid` = ?", requestData.Group, requestData.Dimension, requestData.TargetId)
|
|
// if requestData.DepartId != "" {
|
|
// goromDb = goromDb.Where("FIND_IN_SET(?,`qe_operator`)", requestData.DepartId)
|
|
// }
|
|
|
|
assErr := goromDb.Find(&assessInfoList).Error
|
|
if assErr != nil {
|
|
response.Result(105, assErr, "没有获取到数据！", c)
|
|
return
|
|
}
|
|
// response.Result(104, assessInfoList, "参数错误！无法获取数据", c)
|
|
// return
|
|
var uotContAry []TargetContOutCont
|
|
for _, v := range assessInfoList {
|
|
var uotCont TargetContOutCont
|
|
uotCont.DutyAssessId = strconv.FormatInt(v.Id, 10)
|
|
uotCont.Type = 1
|
|
//集团
|
|
uotCont.Group = requestData.Group
|
|
// _, groupCont := commonus.GetGroupCont(v.Group)
|
|
// uotCont.GroupNAme = groupCont.Name
|
|
|
|
where := commonus.MapOut()
|
|
where["id"] = v.Group
|
|
orgCont, _ := commonus.GetNewOrgCont(where, "id", "name")
|
|
uotCont.GroupNAme = orgCont.Name
|
|
//执行部门
|
|
uotCont.DepartmentId = v.Departmentmap
|
|
|
|
_, DepartmentAry := commonus.GetNewOrgList(strings.Split(v.Departmentmap, ","))
|
|
|
|
var depNameMap []string
|
|
for _, sep_v := range DepartmentAry {
|
|
depNameMap = append(depNameMap, sep_v.Parentname)
|
|
}
|
|
|
|
// _, departInfoAry := commonus.GetBranchDepartAry(strings.Split(v.Departmentmap, ","))
|
|
// var depNameMap []string
|
|
// for _, sep_v := range departInfoAry {
|
|
// depNameMap = append(depNameMap, sep_v.Parentname)
|
|
// }
|
|
uotCont.DepartmentName = strings.Join(depNameMap, ",")
|
|
uotCont.DepartNameMap = depNameMap
|
|
//维度
|
|
uotCont.Dimension = strconv.FormatInt(v.Dimension, 10)
|
|
dutyClassCont, _ := commonus.GetDutyClassInfo(v.Dimension)
|
|
uotCont.DimensionName = dutyClassCont.Title
|
|
//指标
|
|
uotCont.Target = requestData.TargetId
|
|
targetInfo, _ := commonus.GetTargetInfo(v.TargetId)
|
|
uotCont.TargetName = targetInfo.Title
|
|
//子栏目
|
|
uotCont.TargetSun = strconv.FormatInt(v.SunTargetId, 10)
|
|
info, _ := commonus.GetQualitativeTargetInfo(v.SunTargetId)
|
|
sunTarDepartMap := strings.Split(info.Depart, ",")
|
|
uotCont.DepartIdMap = sunTarDepartMap
|
|
//查询部门
|
|
isShow := true
|
|
// if requestData.DepartId != "" {
|
|
// if commonus.IsItTrueString(requestData.DepartId, sunTarDepartMap) == true {
|
|
// isShow = true
|
|
// }
|
|
// } else {
|
|
// isShow = true
|
|
// }
|
|
fmt.Printf("isShow-------->%v-------->%v-------->%v---->%v\n", isShow, requestData.DepartId, sunTarDepartMap, v.SunTargetId)
|
|
if isShow == true {
|
|
uotCont.TargetSunName = info.Title
|
|
//拆解指标详情
|
|
var detailedList []DutyAssEssTarget
|
|
detailedListErr := json.Unmarshal([]byte(v.Content), &detailedList)
|
|
if detailedListErr == nil {
|
|
// var detaiList []TargetContOutCont
|
|
// for _,d_v := range detailedList{}
|
|
if len(detailedList) > 0 {
|
|
for _, d_v := range detailedList {
|
|
uotCont.Id = strconv.FormatInt(d_v.Id, 10)
|
|
uotCont.DetailedTarget = strconv.FormatInt(d_v.Id, 10)
|
|
uotCont.UserList = d_v.Operator
|
|
|
|
// dtCont, _ := commonus.GetDetailedTargetInfo(d_v.Id)
|
|
|
|
// isDepartAry := strings.Split(dtCont.Paretment, ",")
|
|
// isShowTar := false
|
|
// if len(isDepartAry) > 0 && requestData.DepartId != "" {
|
|
// if commonus.IsItTrueString(requestData.DepartId, isDepartAry) == true {
|
|
// isShowTar = true
|
|
// } else {
|
|
// isShowTar = false
|
|
// }
|
|
// } else {
|
|
// isShowTar = true
|
|
// }
|
|
isShowTar := false
|
|
var dtCont assessmentmodel.DetailedTarget
|
|
gormDbDetaTar := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DetailedTarget{}).Where("dt_id = ?", d_v.Id)
|
|
if requestData.DepartId != "" {
|
|
gormDbDetaTar = gormDbDetaTar.Where("FIND_IN_SET(?,`dt_paretment`)", requestData.DepartId)
|
|
}
|
|
if requestData.CensorRate != 0 {
|
|
gormDbDetaTar = gormDbDetaTar.Where("dt_censor_rate = ?", requestData.CensorRate)
|
|
}
|
|
if requestData.CensorCont != "" {
|
|
gormDbDetaTar = gormDbDetaTar.Where("dt_censor_cont LIKE ?", "%"+requestData.CensorCont+"%")
|
|
}
|
|
errDetaTar := gormDbDetaTar.First(&dtCont).Error
|
|
if errDetaTar == nil {
|
|
if len(requestData.CensorType) > 0 {
|
|
conCensorType := strings.Split(dtCont.CensorType, ",")
|
|
for _, cvk := range requestData.CensorType {
|
|
if commonus.IsItTrueString(cvk, conCensorType) == true {
|
|
isShowTar = true
|
|
}
|
|
}
|
|
} else {
|
|
isShowTar = true
|
|
}
|
|
|
|
}
|
|
fmt.Printf("isShowTar------isShowTar-->%v--requestData-->%v--DepartId-->%v--dtCont-->%v\n", isShowTar, requestData, requestData.DepartId, dtCont)
|
|
if isShowTar == true {
|
|
uotCont.DetailedTargetName = dtCont.Title
|
|
uotCont.Content = dtCont.Content
|
|
uotCont.Unit = dtCont.Company
|
|
uotCont.State = dtCont.State
|
|
uotCont.MinScore = float64(dtCont.MinScore) / 100
|
|
uotCont.MaxScore = float64(dtCont.MaxScore) / 100
|
|
|
|
uotCont.CyclesDetTar = dtCont.Cycles //`json:"cycledettar"` //1：班；2：天；3：周；4：月；5：季度；6：年
|
|
uotCont.CycleDetTarAttres = dtCont.CycleAttres //`json:"cycleattrdettar"` //辅助计数
|
|
uotCont.CensorType = strings.Split(dtCont.CensorType, ",") //`json:"censortype"` //检查方式（1：现场检查；2：资料检查；3：事件触发）
|
|
uotCont.CensorCont = dtCont.CensorCont //`json:"censorcont"` //检查依据
|
|
uotCont.CensorRate = dtCont.CensorRate //`json:"censorrate"` //检查频次
|
|
|
|
uotCont.ScoreIng = "0"
|
|
if dtCont.MinScore > 0 && dtCont.MaxScore > 0 {
|
|
uotCont.ScoreIng = fmt.Sprintf("%v-%v", float64(dtCont.MinScore)/100, float64(dtCont.MaxScore)/100)
|
|
} else if dtCont.MinScore > 0 && dtCont.MaxScore <= 0 {
|
|
uotCont.ScoreIng = fmt.Sprintf("%v", float64(dtCont.MinScore)/100)
|
|
} else if dtCont.MinScore <= 0 && dtCont.MaxScore > 0 {
|
|
uotCont.ScoreIng = fmt.Sprintf("%v", float64(dtCont.MaxScore)/100)
|
|
} else {
|
|
uotCont.ScoreIng = "0"
|
|
}
|
|
for _, u_v := range d_v.Operator {
|
|
usCont, usErr := commonus.GetWorkUser(u_v)
|
|
if usErr == true {
|
|
var userCont QualEvalArrt
|
|
userCont.Id = u_v
|
|
userCont.Name = usCont.Name
|
|
userCont.Icon = usCont.Icon
|
|
|
|
where := commonus.MapOut()
|
|
where["id"] = usCont.Company
|
|
orgCont, _ := commonus.GetNewOrgCont(where, "id", "name")
|
|
userCont.GroupName = orgCont.Name
|
|
|
|
whereDepart := commonus.MapOut()
|
|
whereDepart["id"] = usCont.MainDeparment
|
|
orgContDepart, _ := commonus.GetNewOrgCont(whereDepart, "id", "name")
|
|
userCont.DepartmentName = orgContDepart.Name
|
|
|
|
// _, groupInfo := commonus.GetGroupCont(usCont.Group)
|
|
// userCont.GroupName = groupInfo.Name
|
|
// _, bfInfo := commonus.GetBranchFactory(usCont.DepartmentId)
|
|
// userCont.DepartmentName = bfInfo.Name
|
|
userCont.Number = usCont.Number
|
|
uotCont.UserListAry = append(uotCont.UserListAry, userCont)
|
|
}
|
|
}
|
|
|
|
uotContAry = append(uotContAry, uotCont)
|
|
}
|
|
|
|
}
|
|
} else {
|
|
uotContAry = append(uotContAry, uotCont)
|
|
}
|
|
} else {
|
|
uotContAry = append(uotContAry, uotCont)
|
|
}
|
|
}
|
|
|
|
}
|
|
if len(uotContAry) <= 0 {
|
|
response.Result(106, uotContAry, "没有获取到数据！", c)
|
|
} else {
|
|
response.Result(0, uotContAry, "获取成功！", c)
|
|
}
|
|
}
|
|
|
|
// 删除考核指标
|
|
func (d *DutyAssessApi) NewDelTarGet(c *gin.Context) {
|
|
var requestData LookTargetContList
|
|
err := c.ShouldBindJSON(&requestData)
|
|
if err != nil {
|
|
response.Result(101, err, "数据获取失败！", c)
|
|
return
|
|
}
|
|
if requestData.Group == "" {
|
|
response.Result(102, err, "参数错误！无法获取数据", c)
|
|
return
|
|
}
|
|
if requestData.Dimension == "" {
|
|
response.Result(103, err, "参数错误！无法获取数据", c)
|
|
return
|
|
}
|
|
if requestData.TargetId == "" {
|
|
response.Result(104, err, "参数错误！无法获取数据", c)
|
|
return
|
|
}
|
|
groupId, _ := strconv.ParseInt(requestData.Group, 10, 64)
|
|
dimensionId, _ := strconv.ParseInt(requestData.Dimension, 10, 64)
|
|
targetId, _ := strconv.ParseInt(requestData.TargetId, 10, 64)
|
|
isTrue := commonus.JudegDutyIsUse(groupId, dimensionId, targetId, 0, 0)
|
|
if isTrue != true {
|
|
response.Result(105, err, "你当前要删除的项目已经使用！请不要删除！以免造成正在进行的审批统计产生数据误差！", c)
|
|
return
|
|
}
|
|
var oldAssEssData []assessmentmodel.Assesstarget
|
|
global.GVA_DB_Performanceappraisal.Where("`group` = ? AND `dimension` = ? AND `targetid` = ?", requestData.Group, requestData.Dimension, requestData.TargetId).Find(&oldAssEssData)
|
|
if len(oldAssEssData) > 0 {
|
|
assessAttbar(oldAssEssData)
|
|
}
|
|
// response.Result(0, oldAssEssData, "删除成功！", c)
|
|
delErr := global.GVA_DB_Performanceappraisal.Where("`group` = ? AND `dimension` = ? AND `targetid` = ?", requestData.Group, requestData.Dimension, requestData.TargetId).Delete(&assessmentmodel.Assesstarget{}).Error
|
|
if delErr != nil {
|
|
response.Result(106, delErr, "删除失败！", c)
|
|
return
|
|
}
|
|
response.Result(0, delErr, "删除成功！", c)
|
|
}
|
|
|
|
// 执行附属软删除
|
|
func assessAttbar(oldAssEssData []assessmentmodel.Assesstarget) {
|
|
var targetId []int64
|
|
var targetSunId []int64
|
|
var detaredTargetSunId []int64
|
|
for _, v := range oldAssEssData {
|
|
if commonus.IsItTrue(v.TargetId, targetId) == false {
|
|
targetId = append(targetId, v.TargetId)
|
|
}
|
|
|
|
if commonus.IsItTrue(v.SunTargetId, targetSunId) == false {
|
|
targetSunId = append(targetSunId, v.SunTargetId)
|
|
}
|
|
var duyEssTarget []DutyAssEssTarget
|
|
duyTarJsonErr := json.Unmarshal([]byte(v.Content), &duyEssTarget)
|
|
if duyTarJsonErr == nil {
|
|
if len(duyEssTarget) > 0 {
|
|
for _, dv := range duyEssTarget {
|
|
if commonus.IsItTrue(dv.Id, detaredTargetSunId) == false {
|
|
detaredTargetSunId = append(detaredTargetSunId, dv.Id)
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// if len(targetId) > 0 {
|
|
// saveTarData := commonus.MapOut()
|
|
// saveTarData["et_state"] = 3
|
|
// saveTarData["et_time"] = time.Now().Unix()
|
|
// global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.EvaluationTarget{}).Where("`et_id` IN ?", targetId).Updates(&saveTarData)
|
|
// }
|
|
if len(targetSunId) > 0 {
|
|
saveSunTarData := commonus.MapOut()
|
|
saveSunTarData["q_state"] = 3
|
|
saveSunTarData["q_time"] = time.Now().Unix()
|
|
global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeTarget{}).Where("`q_id` IN ?", targetSunId).Updates(&saveSunTarData)
|
|
}
|
|
if len(detaredTargetSunId) > 0 {
|
|
saveTarData := commonus.MapOut()
|
|
saveTarData["dt_time"] = time.Now().Unix()
|
|
saveTarData["dt_state"] = 3
|
|
global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DetailedTarget{}).Where("`dt_id` IN ?", detaredTargetSunId).Updates(&saveTarData)
|
|
}
|
|
// panic(detaredTargetSunId)
|
|
}
|
|
|
|
// 获取被修改指标细则的详情
|
|
func (d *DutyAssessApi) GetNewEiteDetailedTarget(c *gin.Context) {
|
|
var requestData GetDeitalTarCont
|
|
err := c.ShouldBindJSON(&requestData)
|
|
if err != nil {
|
|
response.Result(101, err, "数据获取失败！", c)
|
|
return
|
|
}
|
|
if requestData.Id == "" {
|
|
response.Result(102, requestData, "参数错误！请重新提交！", c)
|
|
return
|
|
}
|
|
if requestData.AssId == "" {
|
|
response.Result(103, requestData, "参数错误！请重新提交！", c)
|
|
return
|
|
}
|
|
var cont assessmentmodel.DetailedTarget
|
|
errErr := global.GVA_DB_Performanceappraisal.Where("`dt_id` = ?", requestData.Id).First(&cont).Error
|
|
if errErr != nil {
|
|
response.Result(104, errErr, "没有获取到数据！", c)
|
|
return
|
|
}
|
|
var assCont assessmentmodel.Assesstarget
|
|
errAssErr := global.GVA_DB_Performanceappraisal.Where("`at_id` = ?", requestData.AssId).First(&assCont).Error
|
|
if errAssErr != nil {
|
|
response.Result(105, errAssErr, "没有获取到数据！", c)
|
|
return
|
|
}
|
|
var outPutCont NewOutPutDetailedTarget
|
|
outPutCont.Id = strconv.FormatInt(cont.Id, 10)
|
|
//获取子栏目信息
|
|
sunTargetCont, _ := commonus.GetQualitativeTargetInfo(cont.ParentIdSun)
|
|
outPutCont.SunTargerId = strconv.FormatInt(sunTargetCont.Id, 10)
|
|
outPutCont.SunTargetName = sunTargetCont.Title
|
|
//获取指标细则信息
|
|
outPutCont.DetailedTargetId = strconv.FormatInt(cont.Id, 10)
|
|
outPutCont.DetailedTargetName = cont.Title
|
|
outPutCont.DetailedTargetContent = cont.Content
|
|
|
|
outPutCont.Cycles = cont.Cycles
|
|
outPutCont.CycleAttres = cont.CycleAttres
|
|
cenType := strings.Split(cont.CensorType, ",")
|
|
outPutCont.CensorType = cenType
|
|
outPutCont.CensorCont = cont.CensorCont
|
|
outPutCont.CensorRate = cont.CensorRate
|
|
|
|
outPutCont.AddReduce = cont.AddReduce
|
|
//单位
|
|
outPutCont.Unit = cont.Company
|
|
if cont.MinScore > 0 && cont.MaxScore > 0 {
|
|
outPutCont.Score = fmt.Sprintf("%v-%v", float64(cont.MinScore)/100, float64(cont.MaxScore)/100)
|
|
} else if cont.MinScore > 0 && cont.MaxScore <= 0 {
|
|
outPutCont.Score = fmt.Sprintf("%v", float64(cont.MinScore)/100)
|
|
} else if cont.MinScore <= 0 && cont.MaxScore > 0 {
|
|
outPutCont.Score = fmt.Sprintf("%v", float64(cont.MaxScore)/100)
|
|
} else {
|
|
outPutCont.Score = "0"
|
|
}
|
|
if cont.Paretment != "" {
|
|
outPutCont.DepartmentId = strings.Split(cont.Paretment, ",")
|
|
}
|
|
//解析考核方案内的指标关联人
|
|
//拆解指标详情
|
|
var detailedList []DutyAssEssTarget
|
|
detailedListErr := json.Unmarshal([]byte(assCont.Content), &detailedList)
|
|
if detailedListErr == nil {
|
|
for _, v := range detailedList {
|
|
if v.Id == cont.Id {
|
|
for _, us_key := range v.Operator {
|
|
usCont, _ := commonus.GetWorkUser(us_key)
|
|
var userCont QualEvalArrt
|
|
userCont.Id = us_key
|
|
userCont.Name = usCont.Name
|
|
userCont.Icon = usCont.Icon
|
|
|
|
where := commonus.MapOut()
|
|
where["id"] = usCont.Company
|
|
orgCont, _ := commonus.GetNewOrgCont(where, "id", "name")
|
|
userCont.GroupName = orgCont.Name
|
|
|
|
whereDepart := commonus.MapOut()
|
|
whereDepart["id"] = usCont.MainDeparment
|
|
orgContDepart, _ := commonus.GetNewOrgCont(whereDepart, "id", "name")
|
|
userCont.DepartmentName = orgContDepart.Name
|
|
|
|
// _, groupInfo := commonus.GetGroupCont(usCont.Group)
|
|
// userCont.GroupName = groupInfo.Name
|
|
// _, bfInfo := commonus.GetBranchFactory(usCont.DepartmentId)
|
|
// userCont.DepartmentName = bfInfo.Name
|
|
userCont.Number = usCont.Number
|
|
outPutCont.OperatorAry = append(outPutCont.OperatorAry, userCont)
|
|
outPutCont.Operator = append(outPutCont.Operator, us_key)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//获取所有子栏目
|
|
var qualTar []assessmentmodel.QualitativeTarget
|
|
quaTarErr := global.GVA_DB_Performanceappraisal.Where("`q_parent_id` = ?", cont.ParentId).Find(&qualTar).Error
|
|
if quaTarErr == nil {
|
|
for _, s_v := range qualTar {
|
|
var sunTarCont QualEvalArrt
|
|
sunTarCont.Id = strconv.FormatInt(s_v.Id, 10)
|
|
sunTarCont.Name = s_v.Title
|
|
outPutCont.SunTargerList = append(outPutCont.SunTargerList, sunTarCont)
|
|
}
|
|
}
|
|
outPutCont.AssId = requestData.AssId
|
|
response.Result(0, outPutCont, "获取成功！", c)
|
|
|
|
}
|
|
|
|
// 修改定性考核指标细则内容
|
|
func (d *DutyAssessApi) NewEiteDetailedTarget(c *gin.Context) {
|
|
var requestData NewEiteDtyDiteCont
|
|
err := c.ShouldBindJSON(&requestData)
|
|
if err != nil {
|
|
response.Result(101, err, "数据获取失败！", c)
|
|
return
|
|
}
|
|
// if requestData.Id == "" {
|
|
// response.Result(102, requestData, "参数错误！请重新提交！", c)
|
|
// return
|
|
// }
|
|
if requestData.AssId == "" {
|
|
response.Result(103, requestData, "参数错误！请重新提交！", c)
|
|
return
|
|
}
|
|
var assCont assessmentmodel.Assesstarget
|
|
errAssErr := global.GVA_DB_Performanceappraisal.Where("`at_id` = ?", requestData.AssId).First(&assCont).Error
|
|
if errAssErr != nil {
|
|
response.Result(104, errAssErr, "没有获取到数据！", c)
|
|
return
|
|
}
|
|
var departmentStr string
|
|
if len(requestData.DepartmentId) > 0 {
|
|
departmentStr = strings.Join(requestData.DepartmentId, ",")
|
|
} else {
|
|
departmentStr = assCont.Departmentmap
|
|
}
|
|
// detailedTargetInfo, dtiIsTrue := commonus.JudgeDetailsCopy(strconv.FormatInt(assCont.TargetId, 10), requestData.DetailedTargetName, requestData.DetailedTargetContent, requestData.Id, requestData.Score, requestData.Unit, assCont.SunTargetId, requestData.AddOrReduce)
|
|
|
|
//判断考核细则是否存在(新规则)
|
|
/*
|
|
参数说明
|
|
@ascription 归属指标栏目
|
|
@title 指标细则
|
|
@explain 指标说明'
|
|
@explainId 指标明细ID
|
|
@ReferenceScore 分数
|
|
@CompanyCont 单位
|
|
@sunTargetId 子栏目
|
|
*/
|
|
// func JudgeDetailsCopy(ascription, title, explain, explainId, ReferenceScore, CompanyCont string, sunTargetId int64, addReduce int) (content assessmentmodel.DetailedTarget, isTrue bool)
|
|
|
|
var detailedTarget QualEvalSunList
|
|
|
|
detailedTarget.DetailedTarget = requestData.Id //`json:"id"` //考核细则
|
|
detailedTarget.Title = requestData.DetailedTargetName //`json:"title"` //指标说明
|
|
detailedTarget.Content = requestData.DetailedTargetContent //`json:"content"` //指标说明
|
|
detailedTarget.Unit = requestData.Unit //`json:"unit"` //单位
|
|
detailedTarget.ReferenceScore = requestData.Score //`json:"referencescore"` //标准分值
|
|
// detailedTarget.Cycles = fmt.Sprintf("%v", requestData.Cycles) //`json:"cycle"` //1：班；2：天；3：周；4：月；5：季度；6：年
|
|
detailedTarget.Cycles = requestData.Cycles //`json:"cycle"` //1：班；2：天；3：周；4：月；5：季度；6：年
|
|
detailedTarget.CycleAttres = requestData.CycleAttres // `json:"cycleattr"` //辅助计数
|
|
// detailedTarget.DepartmentId =requestData. `json:"parentid"` //执行考核部门ID
|
|
detailedTarget.Operator = requestData.Operator //`json:"userlist"` //考核执行人
|
|
// detailedTarget.MinScore =requestData. //`json:"minscore"` //最小分*100保存
|
|
// detailedTarget.MaxScore =requestData. //`json:"maxscore"` //最大分*100保存
|
|
detailedTarget.AddOrReduce = requestData.AddOrReduce //`json:"addorreduce"` //1：减少；2：增加
|
|
detailedTarget.CensorType = requestData.CensorType //`json:"censortype"` //检查方式（1：现场检查；2：资料检查；3：事件触发）
|
|
detailedTarget.CensorCont = requestData.CensorCont //`json:"censorcont"` //检查依据
|
|
detailedTarget.CensorRate = requestData.CensorRate //`json:"censorrate"` //检查频次
|
|
|
|
// Id string `json:"id"`
|
|
// Class int `json:"class"` //1、新增；2、修改
|
|
// SunTargerId string `json:"suntargetid"`
|
|
// SunTargetName string `json:"suntargetname"`
|
|
// DetailedTargetName string `json:"detailedtargetname"`
|
|
// DetailedTargetContent string `json:"detailedtargetcontent"`
|
|
// Operator []string `json:"operator"`
|
|
|
|
// Cycles int `json:"cycle"` //1：班；2：天；3：周；4：月；5：季度；6：年
|
|
// CycleAttres int `json:"cycleattr"` //辅助计数
|
|
// CensorType int `json:"censortype"` //检查方式（1：现场检查；2：资料检查；3：事件触发）
|
|
// CensorCont string `json:"censorcont"` //检查依据
|
|
// CensorRate int `json:"censorrate"` //检查频次
|
|
|
|
// AssId string `json:"assid"`
|
|
// Unit string `json:"unit"` //单位
|
|
// Score string `json:"score"` //分值
|
|
// AddOrReduce int `json:"addorreduce"` //1：减少；2：增加
|
|
|
|
detailedTargetInfo, dtiIsTrue := JudgeDetailsCopyEs(strconv.FormatInt(assCont.TargetId, 10), departmentStr, assCont.SunTargetId, detailedTarget)
|
|
if dtiIsTrue != true {
|
|
response.Result(105, errAssErr, "指标明细编辑失败！", c)
|
|
return
|
|
}
|
|
|
|
WriteBackTargetDepartment(strconv.FormatInt(assCont.TargetId, 10), strings.Split(departmentStr, ","))
|
|
WriteBackSunTargetDepartment(assCont.Group, assCont.TargetId, strconv.FormatInt(assCont.SunTargetId, 10), strings.Split(departmentStr, ","))
|
|
|
|
//设定定性考核指标新增键对关系
|
|
var addOpentDetial DutyAssEssTarget
|
|
addOpentDetial.Id = detailedTargetInfo.Id
|
|
addOpentDetial.Operator = requestData.Operator
|
|
//拆解指标详情
|
|
var detailedList []DutyAssEssTarget
|
|
detailedListErr := json.Unmarshal([]byte(assCont.Content), &detailedList)
|
|
// ssss := commonus.MapOut()
|
|
// ssss["Content"] = assCont.Content
|
|
// ssss["detailedList"] = detailedList
|
|
// ssss["detailedListErr"] = detailedListErr
|
|
// response.Result(105, ssss, "指标明细编辑失败！", c)
|
|
// return
|
|
if detailedListErr != nil {
|
|
var eiteOpentDetiallist []DutyAssEssTarget
|
|
isAdd := false
|
|
for _, dil_v := range detailedList {
|
|
var detailedEiteCont DutyAssEssTarget
|
|
if dil_v.Id == detailedTargetInfo.Id {
|
|
detailedEiteCont.Id = dil_v.Id
|
|
detailedEiteCont.Operator = requestData.Operator
|
|
isAdd = true
|
|
} else {
|
|
detailedEiteCont.Id = dil_v.Id
|
|
detailedEiteCont.Operator = dil_v.Operator
|
|
}
|
|
eiteOpentDetiallist = append(eiteOpentDetiallist, detailedEiteCont)
|
|
}
|
|
if isAdd == false {
|
|
eiteOpentDetiallist = append(eiteOpentDetiallist, addOpentDetial)
|
|
}
|
|
eiteContIng := commonus.MapOut()
|
|
eiteContIng["time"] = time.Now().Unix()
|
|
jsonStr, jsonMErr := json.Marshal(eiteOpentDetiallist)
|
|
if jsonMErr == nil {
|
|
eiteContIng["content"] = string(jsonStr)
|
|
}
|
|
eiteErring := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.Assesstarget{}).Where("`at_id` = ?", assCont.Id).Updates(&eiteContIng).Error
|
|
if eiteErring == nil {
|
|
// WriteBackTargetDepartment(strconv.FormatInt(assCont.TargetId, 10), strings.Split(departmentStr, ","))
|
|
// WriteBackSunTargetDepartment(strconv.FormatInt(assCont.SunTargetId, 10), strings.Split(departmentStr, ","))
|
|
response.Result(0, err, "处理成功！2", c)
|
|
} else {
|
|
response.Result(107, err, "请添加测评详情！", c)
|
|
}
|
|
} else {
|
|
// var eiteOpentDetiallist []DutyAssEssTarget
|
|
var eiteOpentDetiallist []DutyAssEssTarget
|
|
isAdd := false
|
|
for _, dil_v := range detailedList {
|
|
var detailedEiteCont DutyAssEssTarget
|
|
if dil_v.Id == detailedTargetInfo.Id {
|
|
detailedEiteCont.Id = dil_v.Id
|
|
detailedEiteCont.Operator = requestData.Operator
|
|
isAdd = true
|
|
} else {
|
|
detailedEiteCont.Id = dil_v.Id
|
|
detailedEiteCont.Operator = dil_v.Operator
|
|
}
|
|
eiteOpentDetiallist = append(eiteOpentDetiallist, detailedEiteCont)
|
|
}
|
|
if isAdd == false {
|
|
eiteOpentDetiallist = append(eiteOpentDetiallist, addOpentDetial)
|
|
}
|
|
eiteCont := commonus.MapOut()
|
|
eiteCont["time"] = time.Now().Unix()
|
|
jsonStr, jsonMErr := json.Marshal(eiteOpentDetiallist)
|
|
if jsonMErr == nil {
|
|
eiteCont["content"] = string(jsonStr)
|
|
}
|
|
eiteErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.Assesstarget{}).Where("`at_id` = ?", assCont.Id).Updates(&eiteCont).Error
|
|
if eiteErr == nil {
|
|
// WriteBackTargetDepartment(strconv.FormatInt(assCont.TargetId, 10), strings.Split(departmentStr, ","))
|
|
// WriteBackSunTargetDepartment(strconv.FormatInt(assCont.SunTargetId, 10), strings.Split(departmentStr, ","))
|
|
response.Result(0, err, "处理成功！1", c)
|
|
} else {
|
|
response.Result(107, err, "请添加测评详情！", c)
|
|
}
|
|
}
|
|
}
|
|
|
|
// 删除指标
|
|
func (d *DutyAssessApi) NewDelDetailedTarget(c *gin.Context) {
|
|
var requestData GetDeitalTarCont
|
|
err := c.ShouldBindJSON(&requestData)
|
|
if err != nil {
|
|
response.Result(101, err, "数据获取失败！", c)
|
|
return
|
|
}
|
|
if requestData.Id == "" {
|
|
response.Result(102, requestData, "参数错误！请重新提交！", c)
|
|
return
|
|
}
|
|
if requestData.AssId == "" {
|
|
response.Result(103, requestData, "参数错误！请重新提交！", c)
|
|
return
|
|
}
|
|
detailId, _ := strconv.ParseInt(requestData.Id, 10, 64)
|
|
var assCont assessmentmodel.Assesstarget
|
|
errAssErr := global.GVA_DB_Performanceappraisal.Where("`at_id` = ?", requestData.AssId).First(&assCont).Error
|
|
if errAssErr != nil {
|
|
response.Result(105, errAssErr, "没有获取到数据！", c)
|
|
return
|
|
}
|
|
eiteCont := commonus.MapOut()
|
|
eiteCont["dt_time"] = time.Now().Unix()
|
|
eiteCont["dt_state"] = 3
|
|
global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DetailedTarget{}).Where("`dt_id` = ?", requestData.Id).Updates(&eiteCont)
|
|
var detailedList []DutyAssEssTarget
|
|
detailedListErr := json.Unmarshal([]byte(assCont.Content), &detailedList)
|
|
if detailedListErr == nil {
|
|
var eiteAssContList []DutyAssEssTarget
|
|
for _, v := range detailedList {
|
|
if v.Id != detailId {
|
|
eiteAssContList = append(eiteAssContList, v)
|
|
}
|
|
}
|
|
if len(eiteAssContList) > 0 {
|
|
eiteAssCont := commonus.MapOut()
|
|
eiteAssCont["time"] = time.Now().Unix()
|
|
jsonStr, jsonMErr := json.Marshal(eiteAssContList)
|
|
if jsonMErr == nil {
|
|
eiteAssCont["content"] = string(jsonStr)
|
|
}
|
|
global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.Assesstarget{}).Where("`at_id` = ?", requestData.AssId).Updates(&eiteAssCont)
|
|
}
|
|
}
|
|
response.Result(0, requestData, "修改完成！", c)
|
|
}
|
|
|
|
// 删除子栏目
|
|
func (d *DutyAssessApi) NewDelSunTarget(c *gin.Context) {
|
|
var requestData GetDeitalTarCont
|
|
err := c.ShouldBindJSON(&requestData)
|
|
if err != nil {
|
|
response.Result(101, err, "数据获取失败！", c)
|
|
return
|
|
}
|
|
if requestData.Id == "" {
|
|
response.Result(102, requestData, "参数错误！请重新提交！", c)
|
|
return
|
|
}
|
|
if requestData.AssId == "" {
|
|
response.Result(103, requestData, "参数错误！请重新提交！", c)
|
|
return
|
|
}
|
|
var assCont []assessmentmodel.Assesstarget
|
|
errAssErr := global.GVA_DB_Performanceappraisal.Where("`targetid` = ? AND `suntargetid` = ?", requestData.AssId, requestData.Id).Find(&assCont).Error
|
|
if errAssErr != nil {
|
|
response.Result(105, errAssErr, "没有获取到数据！", c)
|
|
return
|
|
}
|
|
var delDetaId []int64
|
|
var delAssId []int64
|
|
for _, v := range assCont {
|
|
var detailedList []DutyAssEssTarget
|
|
detailedListErr := json.Unmarshal([]byte(v.Content), &detailedList)
|
|
if detailedListErr == nil {
|
|
for _, d_v := range detailedList {
|
|
delDetaId = append(delDetaId, d_v.Id)
|
|
}
|
|
}
|
|
delAssId = append(delAssId, v.Id)
|
|
}
|
|
if len(delDetaId) > 0 {
|
|
eiteCont := commonus.MapOut()
|
|
eiteCont["dt_time"] = time.Now().Unix()
|
|
eiteCont["dt_state"] = 3
|
|
global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DetailedTarget{}).Where("`dt_id` IN ?", delDetaId).Updates(&eiteCont)
|
|
}
|
|
if len(delAssId) > 0 {
|
|
global.GVA_DB_Performanceappraisal.Where("`at_id` IN ?", delAssId).Delete(&assessmentmodel.Assesstarget{})
|
|
}
|
|
response.Result(0, requestData, "修改完成！", c)
|
|
}
|
|
|
|
// 新的部门考核指标获取列表
|
|
func (d *DutyAssessApi) NewGerDerpatTarList(c *gin.Context) {
|
|
var requestData rationSelect
|
|
c.ShouldBindJSON(&requestData)
|
|
//获取维度列表
|
|
var dutyClassAry []assessmentmodel.DutyClass
|
|
gromDb := global.GVA_DB_Performanceappraisal
|
|
gromDb = gromDb.Where("`state` = 1")
|
|
classErr := gromDb.Order("sort ASC").Find(&dutyClassAry).Error
|
|
|
|
if classErr != nil {
|
|
response.Result(0, classErr, "未获取到数据", c)
|
|
return
|
|
}
|
|
var departAryList []DepartTargetListTop
|
|
for _, v := range dutyClassAry {
|
|
conList := GetTargetGroup(requestData.Group, strconv.FormatInt(v.Id, 10), requestData.DepartmentId)
|
|
var departcontInfo DepartTargetListTop
|
|
departcontInfo.Id = strconv.FormatInt(v.Id, 10)
|
|
departcontInfo.Name = v.Title
|
|
departcontInfo.Child = conList
|
|
if len(conList) > 0 {
|
|
departAryList = append(departAryList, departcontInfo)
|
|
}
|
|
|
|
}
|
|
response.Result(0, departAryList, "数据获取成功！", c)
|
|
}
|
|
|
|
//获取指标组合
|
|
/*
|
|
@group 集团
|
|
@dimensionId 维度
|
|
@departID 部门
|
|
*/
|
|
func GetTargetGroup(group, dimensionId, departID string) (contAry []DepartTargetList) {
|
|
var rationId []int64
|
|
gormDb := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.EvaluationTarget{}).Select("et_id").Where("`et_type` = 2 AND `et_state` = 1 AND `et_dimension` = ?", dimensionId)
|
|
if departID != "" {
|
|
// sqlOrStr := fmt.Sprintf("FIND_IN_SET(%v,`et_relevant_departments`)", departID)
|
|
// sqlOrStr = fmt.Sprintf("`et_share` = 1 OR (`et_share` = 2 AND (%v))", sqlOrStr)
|
|
|
|
sqlOrStr := fmt.Sprintf("`et_relevant_departments` = '' OR FIND_IN_SET(%v,`et_relevant_departments`)", departID)
|
|
gormDb = gormDb.Where(sqlOrStr)
|
|
}
|
|
listErr := gormDb.Find(&rationId).Error
|
|
if listErr != nil {
|
|
// return
|
|
}
|
|
|
|
var qualit []int64
|
|
errAssErr := global.GVA_DB_Performanceappraisal.Select("targetid").Model(&assessmentmodel.Assesstarget{}).Where("`state` = 1 AND `group` = ? AND `dimension` = ? AND FIND_IN_SET(?,`departmentmap`)", group, dimensionId, departID).Find(&qualit).Error
|
|
if errAssErr != nil {
|
|
// return
|
|
}
|
|
|
|
mergeMap := append(rationId, qualit...) //合并两个数组
|
|
var finalResultId []int64 //最终结果
|
|
for _, m_v := range mergeMap {
|
|
if commonus.IsItTrue(m_v, finalResultId) != true {
|
|
finalResultId = append(finalResultId, m_v)
|
|
}
|
|
}
|
|
//获取指标列表
|
|
var evaluatCont []assessmentmodel.EvaluationTarget
|
|
aryErr := global.GVA_DB_Performanceappraisal.Where("`et_state` = 1 AND `et_id` IN ?", finalResultId).Find(&evaluatCont).Error
|
|
if aryErr != nil {
|
|
return
|
|
}
|
|
for _, e_v := range evaluatCont {
|
|
var cont DepartTargetList
|
|
cont.Id = strconv.FormatInt(e_v.Id, 10)
|
|
cont.Name = e_v.Title
|
|
cont.Content = ""
|
|
cont.Unit = e_v.Uniteing
|
|
cont.State = e_v.State
|
|
cont.ReferenceScore = commonus.GetWeight(group, dimensionId, departID, strconv.FormatInt(e_v.Id, 10), int64(e_v.Type))
|
|
cont.IsTrue = 2
|
|
contAry = append(contAry, cont)
|
|
}
|
|
return
|
|
}
|
|
|
|
// 部门考核添加。NEW
|
|
func (d *DutyAssessApi) NewAddDepartDuty(c *gin.Context) {
|
|
var requestData AddDutyNewContGroup
|
|
err := c.ShouldBindJSON(&requestData)
|
|
if err != nil {
|
|
response.Result(101, err, "数据获取失败！", c)
|
|
return
|
|
}
|
|
if requestData.Group == "" {
|
|
response.Result(102, err, "数据获取失败！", c)
|
|
return
|
|
}
|
|
groupId, groupErr := strconv.ParseInt(requestData.Group, 10, 64) //集团ID
|
|
if groupErr != nil {
|
|
groupId = 0
|
|
}
|
|
if requestData.DepartmentId == "" {
|
|
response.Result(103, err, "数据获取失败！", c)
|
|
return
|
|
}
|
|
departId, departErr := strconv.ParseInt(requestData.DepartmentId, 10, 64) //部门ID
|
|
if departErr != nil {
|
|
departId = 0
|
|
}
|
|
if len(requestData.Child) < 0 {
|
|
response.Result(104, err, "没有要添加的数据", c)
|
|
return
|
|
}
|
|
var eiteIdAry []int64 //被修改的考核条目
|
|
var saveDataAry []assessmentmodel.QualitativeEvaluation //新增条目
|
|
for _, v := range requestData.Child { //维度
|
|
|
|
commonus.AddWeight(requestData.Group, v.Id, requestData.DepartmentId, "", int64(v.ZhiFraction), 1)
|
|
|
|
for _, tar_v := range v.Child { //指标
|
|
|
|
if tar_v.Status == 1 {
|
|
|
|
//使用
|
|
targetId, targetErr := strconv.ParseInt(tar_v.Id, 10, 64) //指标ID转换
|
|
if targetErr == nil {
|
|
fmt.Printf("Targer---1---->%v\n", targetId)
|
|
evalTarCont, evalTarContErr := commonus.GetTargetInfo(targetId) //获取指标内容
|
|
if evalTarContErr == true {
|
|
fmt.Printf("Targer---2---->%v\n", targetId)
|
|
//判断是定量还是定性
|
|
if evalTarCont.Type == 2 {
|
|
commonus.AddWeight(requestData.Group, v.Id, requestData.DepartmentId, tar_v.Id, tar_v.ReferenceScore, 2)
|
|
//定量指标操作
|
|
var saveData assessmentmodel.QualitativeEvaluation
|
|
var qeId []int64 //需要编辑的ID
|
|
eiteQualEvalSaveData := commonus.MapOut() //需要编辑的内容
|
|
|
|
gormQualEval := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Select("qe_id").Where("`qe_group` = ? AND `qe_dimension` = ? AND `qe_target` = ? AND `qe_type` = ? AND `qe_accept_evaluation` = ?", groupId, v.Id, targetId, evalTarCont.Type, departId)
|
|
judgeContErr := gormQualEval.Find(&qeId).Error
|
|
fmt.Printf("Targer---4---->%v---->%v\n", qeId, judgeContErr)
|
|
//维度ID
|
|
dimId, dimErr := strconv.ParseInt(v.Id, 10, 64)
|
|
if dimErr == nil {
|
|
saveData.Dimension = dimId
|
|
}
|
|
saveData.Target = targetId //指标
|
|
saveData.Type = evalTarCont.Type //类型
|
|
saveData.Unit = evalTarCont.Uniteing //单位
|
|
saveData.ReferenceScore = tar_v.ReferenceScore //分值
|
|
// saveData.ReferenceScore = v_s.ReferenceScore //分值
|
|
saveData.State = 1 //状态
|
|
saveData.Addtime = time.Now().Unix()
|
|
saveData.Eitetime = time.Now().Unix()
|
|
saveData.Group = groupId //集团
|
|
saveData.Cycles = evalTarCont.Cycles //单位
|
|
saveData.CycleAttres = evalTarCont.CycleAttres //辅助计数
|
|
saveData.AcceptEvaluation = departId //接受考核部门
|
|
saveData.Content = tar_v.Content //描述
|
|
saveData.Operator = evalTarCont.Report //执行考核人
|
|
|
|
var departAry []string
|
|
userKeyAry := strings.Split(evalTarCont.Report, ",")
|
|
if len(userKeyAry) > 0 {
|
|
for _, u_v := range userKeyAry {
|
|
usCont, usErr := commonus.GetWorkUser(u_v)
|
|
if usErr == true {
|
|
departIdStr := strconv.FormatInt(usCont.MainDeparment, 10)
|
|
if commonus.IsItTrueString(departIdStr, departAry) == false {
|
|
departAry = append(departAry, departIdStr)
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
saveData.DepartmentId = strings.Join(departAry, ",")
|
|
eiteQualEvalSaveData["qe_department_id"] = strings.Join(departAry, ",")
|
|
if judgeContErr == nil {
|
|
if len(qeId) > 0 {
|
|
eiteQualEvalSaveData["qe_dimension"] = dimId
|
|
eiteQualEvalSaveData["qe_target"] = targetId
|
|
eiteQualEvalSaveData["qe_type"] = evalTarCont.Type
|
|
eiteQualEvalSaveData["qe_unit"] = evalTarCont.Uniteing
|
|
eiteQualEvalSaveData["qe_reference_score"] = tar_v.ReferenceScore
|
|
eiteQualEvalSaveData["qe_state"] = 1
|
|
eiteQualEvalSaveData["qe_eitetime"] = time.Now().Unix()
|
|
eiteQualEvalSaveData["qe_group"] = groupId
|
|
eiteQualEvalSaveData["qe_cycle"] = evalTarCont.Cycles
|
|
eiteQualEvalSaveData["qe_cycleattr"] = evalTarCont.CycleAttres
|
|
eiteQualEvalSaveData["qe_accept_evaluation"] = departId
|
|
eiteQualEvalSaveData["qe_operator"] = evalTarCont.Report
|
|
eiteQualEvalSaveData["qe_content"] = tar_v.Content
|
|
eiteIdAry = append(eiteIdAry, dimId)
|
|
//修改已经存在的内容
|
|
global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Where("`qe_id` IN ?", qeId).Updates(eiteQualEvalSaveData)
|
|
} else {
|
|
saveDataAry = append(saveDataAry, saveData)
|
|
}
|
|
} else {
|
|
//要新增的条目
|
|
saveDataAry = append(saveDataAry, saveData)
|
|
}
|
|
|
|
} else {
|
|
commonus.AddWeight(requestData.Group, v.Id, requestData.DepartmentId, tar_v.Id, tar_v.ReferenceScore, 1)
|
|
//定性指标操作
|
|
//获取部门关联考核指标项目
|
|
var assessTarList []assessmentmodel.Assesstarget
|
|
judgeARTErr := global.GVA_DB_Performanceappraisal.Where("`group` = ? AND `dimension` = ? AND `targetid` = ? AND FIND_IN_SET(?,`departmentmap`)", groupId, v.Id, tar_v.Id, departId).Find(&assessTarList).Error
|
|
|
|
fmt.Printf("Targer---5---->%v---->%v---->%v\n", targetId, v.Id, tar_v.Id)
|
|
|
|
if judgeARTErr == nil {
|
|
var guoDu []AddPartMentGuodu
|
|
for _, ass_v := range assessTarList {
|
|
judgeTure := commonus.JudegSunTarToDepart(ass_v.SunTargetId, departId)
|
|
if judgeTure == true {
|
|
var guoDuCont AddPartMentGuodu
|
|
guoDuCont.Group = groupId
|
|
guoDuCont.DeaprtId = departId
|
|
guoDuCont.Dimension = ass_v.Dimension
|
|
guoDuCont.TargetId = ass_v.TargetId
|
|
guoDuCont.SunTargetId = ass_v.SunTargetId
|
|
if ass_v.Content != "" {
|
|
//拆解指标详情
|
|
var detailedList []DutyAssEssTarget
|
|
detailedListErr := json.Unmarshal([]byte(ass_v.Content), &detailedList)
|
|
if detailedListErr == nil {
|
|
for _, det_v := range detailedList {
|
|
guoDuCont.DetailedTarget = det_v.Id
|
|
guoDuCont.Operator = det_v.Operator
|
|
guoDu = append(guoDu, guoDuCont)
|
|
fmt.Printf("Targer---6---->%v---->%v---->%v\n", ass_v.TargetId, ass_v.SunTargetId, det_v.Id)
|
|
}
|
|
} else {
|
|
guoDu = append(guoDu, guoDuCont)
|
|
}
|
|
} else {
|
|
guoDu = append(guoDu, guoDuCont)
|
|
}
|
|
}
|
|
|
|
}
|
|
//判断关联项目
|
|
if len(guoDu) > 0 {
|
|
guoDuJsonm, _ := json.Marshal(guoDu)
|
|
fmt.Printf("Targer---7---->%v---->%v\n", string(guoDuJsonm), guoDu)
|
|
for _, ae_v := range guoDu {
|
|
//判断该项是否已经存在
|
|
var eiteGetId int64
|
|
gormQualEval := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Select("qe_id").Where("`qe_group` = ? AND `qe_accept_evaluation` = ? AND `qe_dimension` = ? AND `qe_target` = ? AND `qe_target_sun` = ? AND `qe_detailed_target` = ? AND `qe_type` = 1", ae_v.Group, ae_v.DeaprtId, ae_v.Dimension, ae_v.TargetId, ae_v.SunTargetId, ae_v.DetailedTarget)
|
|
judgeContErr := gormQualEval.First(&eiteGetId).Error
|
|
fmt.Printf("Targer---8---->%v---->%v---->%v---->%v---->%v---->%v---->%v\n", eiteGetId, ae_v.Group, ae_v.DeaprtId, ae_v.Dimension, ae_v.TargetId, ae_v.SunTargetId, ae_v.DetailedTarget)
|
|
if judgeContErr == nil {
|
|
eiteQualEvalSaveData := commonus.MapOut() //需要编辑的内容
|
|
eiteQualEvalSaveData["qe_dimension"] = ae_v.Dimension
|
|
eiteQualEvalSaveData["qe_target"] = ae_v.TargetId
|
|
eiteQualEvalSaveData["qe_type"] = 1
|
|
|
|
getEvalTarCont, _ := commonus.GetDetailedTargetInfo(ae_v.DetailedTarget) //获取指标内容
|
|
|
|
eiteQualEvalSaveData["qe_unit"] = getEvalTarCont.Company
|
|
eiteQualEvalSaveData["qe_reference_score"] = 0
|
|
|
|
eiteQualEvalSaveData["qe_min_score"] = getEvalTarCont.MinScore
|
|
eiteQualEvalSaveData["qe_max_score"] = getEvalTarCont.MaxScore
|
|
|
|
eiteQualEvalSaveData["qe_state"] = 1
|
|
eiteQualEvalSaveData["qe_eitetime"] = time.Now().Unix()
|
|
eiteQualEvalSaveData["qe_group"] = ae_v.Group
|
|
evaDingXinglTarCont, _ := commonus.GetTargetInfo(ae_v.TargetId) //获取指标内容
|
|
eiteQualEvalSaveData["qe_cycle"] = evaDingXinglTarCont.Cycles
|
|
eiteQualEvalSaveData["qe_cycleattr"] = evaDingXinglTarCont.CycleAttres
|
|
eiteQualEvalSaveData["qe_accept_evaluation"] = ae_v.DeaprtId
|
|
eiteQualEvalSaveData["qe_operator"] = strings.Join(ae_v.Operator, ",")
|
|
eiteQualEvalSaveData["qe_content"] = getEvalTarCont.Content
|
|
//获取执行人部门
|
|
var departAry []string
|
|
if len(ae_v.Operator) > 0 {
|
|
for _, u_v := range ae_v.Operator {
|
|
usCont, usErr := commonus.GetWorkUser(u_v)
|
|
if usErr == true {
|
|
departIdStr := strconv.FormatInt(usCont.MainDeparment, 10)
|
|
if commonus.IsItTrueString(departIdStr, departAry) == false {
|
|
departAry = append(departAry, departIdStr)
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
eiteQualEvalSaveData["qe_department_id"] = strings.Join(departAry, ",")
|
|
eiteIdAry = append(eiteIdAry, eiteGetId)
|
|
//修改已经存在的内容
|
|
global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Where("`qe_id` = ?", eiteGetId).Updates(eiteQualEvalSaveData)
|
|
} else {
|
|
//写入新的定性考核细则
|
|
var saveData assessmentmodel.QualitativeEvaluation
|
|
saveData.Dimension = ae_v.Dimension
|
|
saveData.Target = ae_v.TargetId //指标
|
|
saveData.Type = 1 //类型
|
|
|
|
saveData.TargetSun = ae_v.SunTargetId
|
|
|
|
getEvalTarCont, _ := commonus.GetDetailedTargetInfo(ae_v.DetailedTarget) //获取指标内容
|
|
|
|
saveData.DetailedTarget = ae_v.DetailedTarget
|
|
|
|
saveData.Unit = getEvalTarCont.Company //单位
|
|
saveData.ReferenceScore = 0 //分值
|
|
|
|
saveData.MinScore = getEvalTarCont.MinScore
|
|
saveData.MaxScore = getEvalTarCont.MaxScore
|
|
// saveData.ReferenceScore = v_s.ReferenceScore //分值
|
|
saveData.State = 1 //状态
|
|
saveData.Addtime = time.Now().Unix()
|
|
saveData.Eitetime = time.Now().Unix()
|
|
saveData.Group = ae_v.Group //集团
|
|
|
|
evaDingXinglTarCont, _ := commonus.GetTargetInfo(ae_v.TargetId) //获取指标内容
|
|
saveData.Cycles = evaDingXinglTarCont.Cycles //1：班；2：天；3：周；4：月；5：季度；6：年
|
|
saveData.CycleAttres = evaDingXinglTarCont.CycleAttres //辅助计数
|
|
|
|
saveData.AcceptEvaluation = ae_v.DeaprtId //接受考核部门
|
|
saveData.Content = getEvalTarCont.Content //描述
|
|
saveData.Operator = strings.Join(ae_v.Operator, ",") //执行考核人
|
|
//获取执行人部门
|
|
var departAry []string
|
|
if len(ae_v.Operator) > 0 {
|
|
for _, u_v := range ae_v.Operator {
|
|
usCont, usErr := commonus.GetWorkUser(u_v)
|
|
if usErr == true {
|
|
departIdStr := strconv.FormatInt(usCont.MainDeparment, 10)
|
|
if commonus.IsItTrueString(departIdStr, departAry) == false {
|
|
departAry = append(departAry, departIdStr)
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
saveData.DepartmentId = strings.Join(departAry, ",")
|
|
|
|
saveDataJsonm, _ := json.Marshal(saveData)
|
|
fmt.Printf("Targer---9---->%v---->%v\n", string(saveDataJsonm), saveData)
|
|
|
|
//要新增的条目
|
|
saveDataAry = append(saveDataAry, saveData)
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
fmt.Printf("Targer---3---->%v\n", targetId)
|
|
}
|
|
} else {
|
|
//禁用
|
|
qualEvalSave := commonus.MapOut()
|
|
qualEvalSave["qe_state"] = 2
|
|
qualEvalSave["qe_eitetime"] = time.Now().Unix()
|
|
global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Where("`qe_group` = ? AND `qe_accept_evaluation` = ? AND `qe_dimension` = ? AND `qe_target` = ?", groupId, departId, v.Id, tar_v.Id).Updates(qualEvalSave)
|
|
}
|
|
}
|
|
}
|
|
if len(saveDataAry) <= 0 && len(eiteIdAry) <= 0 {
|
|
response.Result(105, saveDataAry, "没有要添加的数据", c)
|
|
return
|
|
}
|
|
if len(saveDataAry) > 0 {
|
|
addErr := global.GVA_DB_Performanceappraisal.Create(&saveDataAry).Error
|
|
if addErr != nil {
|
|
response.Result(106, len(saveDataAry), "数据添加失败", c)
|
|
return
|
|
}
|
|
}
|
|
response.Result(0, saveDataAry, "数据添加成功", c)
|
|
}
|
|
|
|
// 获取考核方法要修改的数据
|
|
func (d *DutyAssessApi) GetEiteSunTarterInfo(c *gin.Context) {
|
|
var requestData LookTargetContListSun
|
|
err := c.ShouldBindJSON(&requestData)
|
|
if err != nil {
|
|
response.Result(101, err, "数据获取失败！", c)
|
|
return
|
|
}
|
|
if requestData.Group == "" {
|
|
response.Result(102, err, "参数错误！无法获取数据", c)
|
|
return
|
|
}
|
|
if requestData.Dimension == "" {
|
|
response.Result(103, err, "参数错误！无法获取数据", c)
|
|
return
|
|
}
|
|
if requestData.TargetId == "" {
|
|
response.Result(104, err, "参数错误！无法获取数据", c)
|
|
return
|
|
}
|
|
// var assessInfoList assessmentmodel.Assesstarget
|
|
var userStr string
|
|
assErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.Assesstarget{}).Select("content").Where("`group` = ? AND `dimension` = ? AND `targetid` = ? AND `suntargetid` = ?", requestData.Group, requestData.Dimension, requestData.TargetId, requestData.SunTargetId).First(&userStr).Error
|
|
if assErr != nil {
|
|
response.Result(105, assErr, "没有获取到数据！", c)
|
|
return
|
|
}
|
|
var userMap []DutyAssEssTarget
|
|
|
|
jsonErr := json.Unmarshal([]byte(userStr), &userMap)
|
|
if jsonErr != nil {
|
|
response.Result(104, jsonErr, "没有数据", c)
|
|
return
|
|
}
|
|
var userAry []string
|
|
for _, v := range userMap {
|
|
for _, o_v := range v.Operator {
|
|
if commonus.IsItTrueString(o_v, userAry) == false {
|
|
userAry = append(userAry, o_v)
|
|
}
|
|
}
|
|
}
|
|
response.Result(0, userAry, "没有数据", c)
|
|
}
|
|
|
|
// 修改考核方法指标审核人
|
|
func (d *DutyAssessApi) EiteSunTarterInfoUser(c *gin.Context) {
|
|
var requestData EiteTargetContListSun
|
|
err := c.ShouldBindJSON(&requestData)
|
|
if err != nil {
|
|
response.Result(101, err, "数据获取失败！", c)
|
|
return
|
|
}
|
|
if requestData.Group == "" {
|
|
response.Result(102, err, "参数错误！无法获取数据", c)
|
|
return
|
|
}
|
|
if requestData.Dimension == "" {
|
|
response.Result(103, err, "参数错误！无法获取数据", c)
|
|
return
|
|
}
|
|
if requestData.TargetId == "" {
|
|
response.Result(104, err, "参数错误！无法获取数据", c)
|
|
return
|
|
}
|
|
// if
|
|
}
|
|
|