renguanyu
/
gin-vue-admin
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

数据考核改版

qin_1
超级管理员 4 years ago
parent
a63a8cc79f
commit
cdd938a052
18 changed files with 3469 additions and 88 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 65
      gin_server_admin/api/v1/assessment/assesshandle.go
  2. 89
      gin_server_admin/api/v1/assessment/department_target.go
  3. 310
      gin_server_admin/api/v1/assessment/detailed_target.go
  4. 26
      gin_server_admin/api/v1/assessment/dutyhandle.go
  5. 117
      gin_server_admin/api/v1/assessment/dutylist.go
  6. 428
      gin_server_admin/api/v1/assessment/dutytype.go
  7. 1
      gin_server_admin/api/v1/assessment/enter.go
  8. 267
      gin_server_admin/api/v1/assessment/programme.go
  9. 801
      gin_server_admin/api/v1/assessment/qualitative_evaluation.go
  10. 269
      gin_server_admin/api/v1/assessment/qualitative_target.go
  11. 296
      gin_server_admin/api/v1/assessment/ration_evaluation.go
  12. 492
      gin_server_admin/api/v1/assessment/target.go
  13. 31
      gin_server_admin/api/v1/examtestpage/grouphandle.go
  14. 62
      gin_server_admin/commonus/publichaneld.go
  15. 1
      gin_server_admin/initialize/router.go
  16. 159
      gin_server_admin/model/assessmentmodel/dutyclass.go
  17. 71
      gin_server_admin/router/assessment/assessmentrouter.go
  18. 2
      gin_server_admin/router/examtestpage/grouphandle.go

65
gin_server_admin/api/v1/assessment/assesshandle.go
View File

@ -69,6 +69,12 @@ func (d *DutyHandle) AssEssList(c *gin.Context) {
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)
@ -100,6 +106,28 @@ func (d *DutyHandle) AddAssEssInfo(c *gin.Context) {
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
@ -114,6 +142,12 @@ func (d *DutyHandle) AddAssEssInfo(c *gin.Context) {
}
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)
@ -190,8 +224,37 @@ func (d *DutyHandle) EiteAssEssInfo(c *gin.Context) {
if requestData.Content != "" {
saveData["ai_content"] = requestData.Content
}
var assessInfo assessmentmodel.AssessMentitems
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 {

89
gin_server_admin/api/v1/assessment/department_target.go
View File

@ -0,0 +1,89 @@
package assessment
import (
"strconv"
"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/flipped-aurora/gin-vue-admin/server/model/testpage"
"github.com/gin-gonic/gin"
)
//部门考核
func (d *DutyHandle) DepartmentList(c *gin.Context) {
var requestData rationSelect
c.ShouldBindJSON(&requestData)
var groupId int64 = 3
if requestData.Group != "" {
groupId, _ = strconv.ParseInt(requestData.Group, 10, 64)
}
var departList []deparMentModel
gromDb := global.GVA_DB_Master.Model(&testpage.BranchFactory{}).Select("bf_id", "bf_name", "bf_wechat_id").Where("`bf_set` = 1 AND `bf_group` = ?", groupId)
if requestData.DepartmentId != "" {
gromDb = gromDb.Where("`bf_id` = ?", requestData.DepartmentId)
}
departMentErr := gromDb.Find(&departList).Error
if departMentErr != nil || len(departList) < 1 {
response.Result(101, departMentErr, "没有数据！", c)
return
}
var departAryList []departmentDuty
for _, v := range departList {
var departCont departmentDuty
departCont.Id = strconv.FormatInt(v.Id, 10)
departCont.Name = v.Name
departCont.Child = getDepartDimension(groupId, v.Id)
departAryList = append(departAryList, departCont)
}
response.Result(0, departAryList, "数据获取成功！", c)
}
//获取部门考核维度
func getDepartDimension(groupId, departId int64) (dimensionAry []departmentDimension) {
var fileAry []int64
dimErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DepartmentDimension{}).Select("dd_dimension").Where("`dd_group` = ? AND `dd_department` = ?", groupId, departId).Group("dd_dimension").Find(&fileAry).Error
// fmt.Printf("1--------------->%v\n", dimErr)
if dimErr == nil {
for _, v := range fileAry {
dimInfo, dimInfoErr := commonus.GetDutyClassInfo(v)
// fmt.Printf("2--------------->%v\n", dimInfo)
if dimInfoErr == true {
var dimCont departmentDimension
dimCont.Id = strconv.FormatInt(v, 10)
dimCont.Name = dimInfo.Title
dimCont.Child = targetRationDepartList(groupId, departId, v)
dimensionAry = append(dimensionAry, dimCont)
}
}
}
return
}
//部门考核项目
func targetRationDepartList(groupID, departmentID, dimension int64) (contentList []taskDetails) {
var fileTargetAry []assessmentmodel.QualitativeEvaluation
listTargetErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Where("`qe_group` = ? AND `qe_accept_evaluation` = ? AND `qe_dimension` = ?", groupID, departmentID, dimension).Find(&fileTargetAry).Error
if listTargetErr != nil {
return
}
for _, v := range fileTargetAry {
var content taskDetails
targetInfo, targetErr := commonus.GetTargetInfo(v.Target)
if targetErr == true {
content.Id = strconv.FormatInt(v.Target, 10)
content.Name = targetInfo.Title
content.Unit = v.Unit
content.ReferenceScore = v.ReferenceScore
content.Cycles = v.Cycles
content.CycleAttres = v.CycleAttres
content.State = v.State
contentList = append(contentList, content)
}
}
return
}

310
gin_server_admin/api/v1/assessment/detailed_target.go
View File

@ -0,0 +1,310 @@
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) AddDetailedTarget(c *gin.Context) {
var requestData addDetailedTargetType
err := c.ShouldBindJSON(&requestData)
if err != nil {
response.Result(101, requestData, "数据获取失败！", c)
return
}
if requestData.Title == "" {
response.Result(102, err, "请输入考核细则！", c)
return
}
if requestData.ParentId == "" {
response.Result(102, err, "请选择考核细则归属", c)
return
}
var parentIdSun int64 = 0
juadgeMap := commonus.MapOut()
juadgeGormDb := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DetailedTarget{}).Select("dt_title").Where("`dt_title` = ? AND `dt_parentid` = ?", requestData.Title, requestData.ParentId)
if requestData.ParentIdSun != "" {
parentIdSuns, parentIdSunErr := strconv.ParseInt(requestData.ParentIdSun, 10, 64)
if parentIdSunErr != nil {
response.Result(102, err, "请选择考核细则归属", c)
return
}
parentIdSun = parentIdSuns
juadgeGormDb = juadgeGormDb.Where("`dt_parentid_sun` = ?", requestData.ParentIdSun)
}
juadgeTitleErr := juadgeGormDb.First(&juadgeMap).Error
if juadgeTitleErr == nil {
response.Result(102, err, "此定考核细则已经存在！请不要重复录入！", c)
return
}
var saveData assessmentmodel.DetailedTarget
saveData.Title = requestData.Title
saveData.Content = requestData.Content
parentId, parentIdErr := strconv.ParseInt(requestData.ParentId, 10, 64)
if parentIdErr != nil {
response.Result(102, err, "请选择考核细则归属", c)
return
}
saveData.ParentId = parentId
saveData.ParentIdSun = parentIdSun
saveData.State = 1
saveData.AddTime = time.Now().Unix()
dutyInfoErr := global.GVA_DB_Performanceappraisal.Create(&saveData).Error
if dutyInfoErr != nil {
response.Result(106, saveData, "数据写入失败！", c)
} else {
response.Result(0, saveData, "数据写入成功！", c)
}
}
//获取考核细则详细内容
func (d *DutyHandle) GetDetailedTarget(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 systemEvalCont outDetailedTargetType
contErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DetailedTarget{}).Select("dt_id", "dt_title", "dt_content", "dt_parentid", "dt_parentid_sun", "dt_state", "dt_time").Where("`dt_id` = ?", requestData.Id).First(&systemEvalCont).Error
if contErr != nil {
response.Result(103, err, "数据获取失败！", c)
return
}
systemEvalCont.OutId = strconv.FormatInt(systemEvalCont.Id, 10)
systemEvalCont.ParentIdStr = strconv.FormatInt(systemEvalCont.ParentId, 10)
parentCont, parentIsTrue := commonus.GetTargetInfo(systemEvalCont.ParentId)
if parentIsTrue == true {
systemEvalCont.ParentTitle = parentCont.Title
}
systemEvalCont.ParentIdSunStr = strconv.FormatInt(systemEvalCont.ParentIdSun, 10)
parentSunCont, parentSunIsTrue := commonus.GetQualitativeTargetInfo(systemEvalCont.ParentIdSun)
if parentSunIsTrue == true {
systemEvalCont.ParentSunTitle = parentSunCont.Title
}
response.Result(0, systemEvalCont, "数据获取成功！", c)
}
//获取考核细则详细内容
func (d *DutyHandle) GetDetailedTargetList(c *gin.Context) {
var requestData detailedTargetTypeList
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)
gormDb := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DetailedTarget{}).Select("dt_id", "dt_title", "dt_content", "dt_parentid", "dt_parentid_sun", "dt_state", "dt_time")
if requestData.ParentId != "" {
gormDb = gormDb.Where("`dt_parentid` = ?", requestData.ParentId)
}
if requestData.ParentIdSun != "" {
gormDb = gormDb.Where("`dt_parentid_sun` = ?", requestData.ParentIdSun)
}
if requestData.State != 0 {
gormDb = gormDb.Where("`dt_state` = ?", requestData.State)
} else {
gormDb = gormDb.Where("`dt_state` IN (1,2)")
}
if requestData.Title != "" {
gormDb = gormDb.Where("(`dt_title` LIKE ?)", "%"+requestData.Title+"%")
}
var total int64
totalErr := gormDb.Count(&total).Error
if totalErr != nil {
total = 0
}
// response.Result(0, requestData, "查询成功！", c)
// var dataList []assessmentmodel.QualitativeTarget
var dataList []outDetailedTargetType
dataListerr := gormDb.Limit(requestData.PageSize).Offset(offSetPage).Find(&dataList).Error
if dataListerr != nil {
response.Result(103, dataList, "数据获取失败！", c)
return
}
for i, v := range dataList {
dataList[i].OutId = strconv.FormatInt(v.Id, 10)
dataList[i].ParentIdStr = strconv.FormatInt(v.ParentId, 10)
parentCont, parentIsTrue := commonus.GetTargetInfo(v.ParentId)
if parentIsTrue == true {
dataList[i].ParentTitle = parentCont.Title
}
dataList[i].ParentIdSunStr = strconv.FormatInt(v.ParentIdSun, 10)
parentSunCont, parentSunIsTrue := commonus.GetQualitativeTargetInfo(v.ParentIdSun)
if parentSunIsTrue == true {
dataList[i].ParentSunTitle = parentSunCont.Title
}
}
countSum := len(dataList)
printData := commonus.OutPutList(total, int64(countSum), requestData.Page, requestData.PageSize, dataList)
response.Result(0, printData, "查询成功！", c)
}
//编辑考核细则数据处理
func eiteDetailedTargetInfo(saveId int64, saveData map[string]interface{}) (isTrue bool, infoErr error) {
isTrue = false
infoErr = global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DetailedTarget{}).Where("`dt_id` = ?", saveId).Updates(saveData).Error
if infoErr != nil {
return
}
isTrue = true
return
}
//编辑考核细则内容
func (d *DutyHandle) EiteDetailedTargetCont(c *gin.Context) {
var requestData eitedetailedTargetCon
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 oldTargetCont assessmentmodel.DetailedTarget
targetInfoErr := global.GVA_DB_Performanceappraisal.Where("`dt_id` = ?", requestData.Id).First(&oldTargetCont).Error
if targetInfoErr != nil {
response.Result(102, err, "该考核细则不存在！请检查您的参数！", c)
return
}
saveData := commonus.MapOut()
if requestData.Title == "" {
response.Result(102, err, "请输入指标名称！", c)
return
} else {
if requestData.Title != oldTargetCont.Title {
if requestData.ParentId != "" && requestData.ParentIdSun != "" {
judgeTargetErr := global.GVA_DB_Performanceappraisal.Where("`dt_title` = ? AND `dt_parentid` = ? AND `dt_parentid_sun` = ?", requestData.Title, requestData.ParentId, requestData.ParentIdSun).First(&oldTargetCont).Error
if judgeTargetErr == nil {
response.Result(102, err, "该考核细则已经存在！请不要重复输入！", c)
return
}
} else if requestData.ParentId != "" && requestData.ParentIdSun == "" {
judgeTargetErr := global.GVA_DB_Performanceappraisal.Where("`dt_title` = ? AND `dt_parentid` = ?", requestData.Title, requestData.ParentId).First(&oldTargetCont).Error
if judgeTargetErr == nil {
response.Result(102, err, "该考核细则已经存在！请不要重复输入！", c)
return
}
} else {
judgeTargetErr := global.GVA_DB_Performanceappraisal.Where("`dt_title` = ? AND `dt_parentid` = ? AND `dt_parentid_sun` = ?", requestData.Title, oldTargetCont.ParentId, oldTargetCont.ParentIdSun).First(&oldTargetCont).Error
if judgeTargetErr == nil {
response.Result(102, err, "该考核细则已经存在！请不要重复输入！", c)
return
} else {
judgeTargetErr := global.GVA_DB_Performanceappraisal.Where("`dt_title` = ? AND `dt_parentid` = ?", requestData.Title, oldTargetCont.ParentId).First(&oldTargetCont).Error
if judgeTargetErr == nil {
response.Result(102, err, "该考核细则已经存在！请不要重复输入！", c)
return
}
}
}
saveData["dt_title"] = requestData.Title
}
}
if requestData.Content != "" {
saveData["dt_content"] = requestData.Content
}
if requestData.ParentId != "" {
saveData["dt_parentid"] = requestData.ParentId
}
if requestData.ParentIdSun != "" {
saveData["dt_parentid_sun"] = requestData.ParentIdSun
}
saveData["dt_time"] = time.Now().Unix()
roleIsTrue, roleErr := eiteDetailedTargetInfo(requestData.Id, saveData)
if roleIsTrue != true {
response.Result(106, roleErr, "编辑失败!", c)
} else {
response.Result(0, saveData, "编辑成功!", c)
}
}
//删除考核细则
func (d *DutyHandle) DelDetailedTargetCont(c *gin.Context) {
var requestData dutyClassState
err := c.ShouldBindJSON(&requestData)
if err != nil {
response.Result(101, requestData, "数据获取失败！", 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["dt_state"] = requestData.State
saveData["dt_time"] = time.Now().Unix()
if requestData.IsDel != 1 {
roleIsTrue, roleErr := eiteDetailedTargetInfo(requestData.Id, saveData)
if roleIsTrue != true {
response.Result(103, roleErr, "修改失败！", c)
return
}
response.Result(0, requestData, "修改成功！", c)
} else {
if requestData.State == 3 {
roleErr := global.GVA_DB_Performanceappraisal.Where("dt_id = ?", requestData.Id).Delete(&assessmentmodel.DetailedTarget{}).Error
if roleErr != nil {
response.Result(104, saveData, "删除失败！", c)
return
}
response.Result(0, saveData, "删除成功！", c)
} else {
roleIsTrue, roleErr := eiteDetailedTargetInfo(requestData.Id, saveData)
if roleIsTrue != true {
response.Result(103, roleErr, "修改失败！", c)
return
}
response.Result(0, requestData, "修改成功！", c)
}
}
}

26
gin_server_admin/api/v1/assessment/dutyhandle.go
View File

@ -90,10 +90,19 @@ func (d *DutyHandle) AddDutyClass(c *gin.Context) {
response.Result(102, err, "请输入职责名称", c)
return
}
if requestData.Type == 0 {
requestData.Type = 1
}
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 = 1
dutyClassCont.Type = requestData.Type
dutyClassCont.Weight = 0
dutyClassCont.State = 1
dutyClassCont.Time = time.Now().Unix()
@ -155,6 +164,21 @@ func (d *DutyHandle) EiteDutyClassInfo(c *gin.Context) {
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

117
gin_server_admin/api/v1/assessment/dutylist.go
View File

@ -45,28 +45,8 @@ func (d *DutyHandle) DutyList(c *gin.Context) {
}
if requestData.AssEssType != 0 {
gormDb = gormDb.Where("`dc_user_type` = ?", requestData.AssEssType)
if requestData.AssEssUserId != "" {
assessUserId, assessErr := strconv.ParseInt(requestData.AssEssUserId, 10, 64)
if assessErr == nil {
if requestData.AssEssType == 1 {
gormDb = gormDb.Where("`dc_user_dump` = ?", assessUserId)
} else {
gormDb = gormDb.Where("`dc_dump` = ?", assessUserId)
}
}
}
} else {
if requestData.AssEssUserId != "" {
assessUserId, assessErr := strconv.ParseInt(requestData.AssEssUserId, 10, 64)
if assessErr == nil {
if requestData.AssEssType == 1 {
gormDb = gormDb.Where("`dc_user_dump` = ?", assessUserId)
} else {
gormDb = gormDb.Where("`dc_dump` = ?", assessUserId)
}
}
}
gormDb = gormDb.Where("`dc_type` = ?", requestData.AssEssType)
}
var total int64
@ -94,6 +74,12 @@ func (d *DutyHandle) DutyList(c *gin.Context) {
outDutyInfo.Dump = val.Dump
outDutyInfo.OutId = strconv.FormatInt(outDutyInfo.Id, 10)
outDutyInfo.UnitTitle = val.Uniteing
outDutyInfo.Cycle = val.Cycles
outDutyInfo.CycleAttr = val.CycleAttres
outDutyInfo.Content = val.Contentes
outDutyInfo.Type = val.Types
outDutyInfo.ParentIdStr = strconv.FormatInt(val.PartId, 10)
isTrue, parentCont := GetAssEssCont(val.PartId)
if isTrue == true {
@ -127,7 +113,7 @@ func (d *DutyHandle) DutyList(c *gin.Context) {
response.Result(0, printData, "查询成功！", c)
}
//添加具体职责
//添加考核细则
func (d *DutyHandle) AddDutyInfo(c *gin.Context) {
var requestData addDutyContent
err := c.ShouldBindJSON(&requestData)
@ -136,43 +122,67 @@ func (d *DutyHandle) AddDutyInfo(c *gin.Context) {
return
}
if requestData.Title == "" {
response.Result(102, err, "请输入具体职责名称", c)
response.Result(102, err, "请输入考核细则名称", c)
return
}
if requestData.ParentId == "" {
response.Result(103, err, "请指定该具体归属于职责项目", c)
response.Result(103, err, "请指定该具体归属于考核项目", c)
return
}
if requestData.UserId == "" {
response.Result(103, err, "请指定该具体职责执行人或执行部门", c)
outDutyCont := commonus.MapOut()
inFoErres := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DutyContent{}).Where("`dc_parent` = ? AND `dc_title` = ?", requestData.ParentId, requestData.Title).First(&outDutyCont).Error
if inFoErres == nil {
response.Result(105, inFoErres, "该考核项目下此考核细则已经存在！请不要重复提交", c)
return
}
// if requestData.SectionId == "" {
// response.Result(103, err, "请指定该考核细则执行部门", c)
// return
// }
if requestData.Type == 0 {
requestData.Type = 1
}
var dutyInfo assessmentmodel.DutyContent
dutyInfo.Id = commonus.GetFileNumberEs()
dutyInfo.Title = requestData.Title
dutyInfo.Time = time.Now().Unix()
dutyInfo.State = 1
dutyInfo.UserType = 1
parentId, parentIdErr := strconv.ParseInt(requestData.ParentId, 10, 64)
if parentIdErr == nil {
dutyInfo.PartId = parentId
} else {
dutyInfo.PartId = 0
}
userID, userIDErr := strconv.ParseInt(requestData.UserId, 10, 64)
if userIDErr != nil {
userID = 0
}
dutyInfo.UserType = requestData.Type
if requestData.Type == 1 {
dutyInfo.UserDump = userID
dutyInfo.Dump = 0
} else {
dutyInfo.UserDump = 0
dutyInfo.Dump = userID
// userID, userIDErr := strconv.ParseInt(requestData.UserId, 10, 64)
// if userIDErr != nil {
// userID = 0
// }
dutyInfo.Types = requestData.Type
// dutyInfo.UserDump = userID
// DumpID, DumpIDErr := strconv.ParseInt(requestData.SectionId, 10, 64)
// if DumpIDErr != nil {
// DumpID = 0
// }
// dutyInfo.Dump = DumpID
assContErr, assCont := GetAssEssCont(parentId)
if assContErr != true {
response.Result(103, err, "该考核项目不存在！请你检查！", c)
return
}
dutyInfo.Uniteing = assCont.Unites
dutyInfo.Cycles = assCont.Cycle
dutyInfo.CycleAttres = assCont.CycleAttr
dutyInfo.Contentes = requestData.Content
// if requestData.Type == 1 {
// dutyInfo.UserDump = userID
// dutyInfo.Dump = 0
// } else {
// dutyInfo.UserDump = 0
// dutyInfo.Dump = userID
// }
dutyInfoErr := global.GVA_DB_Performanceappraisal.Create(&dutyInfo).Error
if dutyInfoErr != nil {
response.Result(104, dutyInfo, "数据写入失败！", c)
@ -260,6 +270,22 @@ func (d *DutyHandle) EiteDutyInfor(c *gin.Context) {
response.Result(103, err, "请输入具体职责", c)
return
}
var dutyOutInfo dutyOutput
inFoErr := global.GVA_DB_Performanceappraisal.Where("`dc_id` = ?", requestData.Id).First(&dutyOutInfo).Error
if inFoErr != nil {
response.Result(103, inFoErr, "数据查询失败！", c)
return
}
if requestData.Title != "" && requestData.Title != dutyOutInfo.Title {
outDutyCont := commonus.MapOut()
inFoErres := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DutyContent{}).Where("`dc_parent` = ? AND `dc_title` = ?", requestData.ParentId, requestData.Title).First(&outDutyCont).Error
if inFoErres == nil {
response.Result(105, inFoErr, "该考核细则已经存在！请不要重复提交", c)
return
}
}
if requestData.ParentId != "" {
parentIdInt, parentErr := strconv.ParseInt(requestData.ParentId, 10, 64)
if parentErr == nil {
@ -267,21 +293,24 @@ func (d *DutyHandle) EiteDutyInfor(c *gin.Context) {
}
}
if requestData.Type != 0 {
saveData["dc_user_type"] = requestData.Type
saveData["dc_type"] = requestData.Type
}
if requestData.UserId != "" {
userID, userIDErr := strconv.ParseInt(requestData.UserId, 10, 64)
if userIDErr != nil {
userID = 0
}
if requestData.Type == 1 {
saveData["dc_user_dump"] = userID
saveData["dc_dump"] = 0
} else {
saveData["dc_user_dump"] = 0
saveData["dc_dump"] = userID
}
if requestData.SectionId != "" {
sectionID, sectionIDErr := strconv.ParseInt(requestData.SectionId, 10, 64)
if sectionIDErr != nil {
sectionID = 0
}
saveData["dc_dump"] = sectionID
}
var assessInfo assessmentmodel.DutyContent
saveData["dc_title"] = requestData.Title
saveData["dc_time"] = time.Now().Unix()

428
gin_server_admin/api/v1/assessment/dutytype.go
View File

@ -1,10 +1,29 @@
package assessment
import (
"sync"
"github.com/flipped-aurora/gin-vue-admin/server/commonus"
"github.com/flipped-aurora/gin-vue-admin/server/model/assessmentmodel"
)
//协程设置
var syncProcess = sync.WaitGroup{}
//数据锁统计
type dataLockStatistics struct {
dataMap []map[string]interface{}
dataErrMap []map[string]interface{}
mutext sync.RWMutex
}
//读取锁数据
func (d *dataLockStatistics) readMyDayData() ([]map[string]interface{}, []map[string]interface{}) {
d.mutext.RLock()
defer d.mutext.RUnlock()
return d.dataMap, d.dataErrMap
}
//职责考核
type DutyHandle struct{}
@ -30,6 +49,7 @@ type dutyClassOutput struct {
//职责类别添加
type dutyClassAdd struct {
Title string `json:"title"`
Type int `json:"type"` //1：定性考核；2：定量考核
}
//职责类别修改
@ -64,16 +84,24 @@ type assessOutput struct {
//添加考核项目内容
type addAssEssInfo struct {
dutyClassAdd
Content string `json:"content"`
Content string `json:"content"` //描述
ParentId string `json:"parentId"` //父级
Type int `json:"type"` //1：定量考核；2：定性考核
UnitTitle string `json:"unittitle"` //计量单位
Cycle int `json:"cycle"` //1：天；2：周；3：月；4：季度；5：年
CycleAttr int `json:"cycleattr"` //辅助计数
}
//修改考核项目内容
type eiteAssEssCont struct {
commonus.SetId
dutyClassAdd
Content string `json:"content"`
Content string `json:"content"` //描述
ParentId string `json:"parentId"` //父级
Type int `json:"type"` //1：定量考核；2：定性考核
UnitTitle string `json:"unittitle"` //计量单位
Cycle int `json:"cycle"` //1：天；2：周；3：月；4：季度；5：年
CycleAttr int `json:"cycleattr"` //辅助计数
}
//具体职责查询
@ -96,14 +124,24 @@ type dutyOutput struct {
UserName string `json:"username"` //执行人姓名
DumpTitle string `json:"dumpTitle"` //执行人部门
UserDumpId string `json:"userDumpId"` //执行人ID
Type int `json:"typestate"` //1：定量考核；2：定性考核
UnitTitle string `json:"unittitle"` //计量单位
Cycle int `json:"cycleing"` //1：天；2：周；3：月；4：季度；5：年
CycleAttr int `json:"cycleattring"` //辅助计数
Content string `json:"contenting"` //描述
}
//添加具体职责
type addDutyContent struct {
dutyClassAdd
Type int `json:"type"`
Type int `json:"type"` //1：定量考核；2：定性考核
ParentId string `json:"parentId"` //父级
UserId string `json:"userid"`
UserId string `json:"userid"` //执行人
SectionId string `json:"section"` //执行部门
UnitTitle string `json:"unittitle"` //计量单位
Cycle int `json:"cycle"` //1：天；2：周；3：月；4：季度；5：年
CycleAttr int `json:"cycleattr"` //辅助计数
Content string `json:"content"` //描述
}
//编辑具体项目
@ -112,7 +150,12 @@ type eiteDutyCont struct {
dutyClassAdd
Type int `json:"type"`
ParentId string `json:"parentId"` //父级
UserId string `json:"userid"`
UserId string `json:"userid"` //执行人
SectionId string `json:"section"` //执行部门
UnitTitle string `json:"unittitle"` //计量单位
Cycle int `json:"cycle"` //1：天；2：周；3：月；4：季度；5：年
CycleAttr int `json:"cycleattr"` //辅助计数
Content string `json:"content"` //描述
}
//部门具体职责
@ -191,3 +234,378 @@ type dutyAssClass struct {
AssPartId int64 `json:"AsspartId" gorm:"column:ai_parent;type:bigint(20) unsigned;default:0;not null;comment:父级"`
ClassTitle string `json:"Classtitle" gorm:"column:title;type:varchar(255);comment:职责类别名称"`
}
/*
考核方案
*/
type EvaluationScheme struct{}
//添加考核方案
type AddScheme struct {
dutyClassAdd //标题
Group int64 `json:"group"` //集团
Department []int64 `json:"department"` //分厂
Dimension string `json:"dimension"` //考核维度
Project string `json:"project"` //考核项目
Weight int `json:"weight"` //权重
ExecutiveDepartment int64 `json:"executivedepartment"` //执行部门
Content []schemeContent `json:"content"` //方案内容
}
type schemeContent struct {
Id string `json:"id"`
Title string `json:"title"`
Type int `json:"type"`
ParentId string `json:"parentId"`
Section string `json:"section"`
Unittitle string `json:"unittitle"`
Cycle int `json:"cycle"`
Cycleattr int `json:"cycleattr"`
Content string `json:"content"`
}
/*
指标相关
*/
//指标列表查询字段
type listTarget struct {
commonus.PageSetLimt
Title string `json:"title"`
Type int `json:"type"` //1：定性考核；2：定量考核
Share int `json:"share"` //1：共用；2：私用
State int `json:"state"` //状态（1：启用；2：禁用；3：删除）
RelevantDepartments []string `json:"relevantdepartments"` //相关部门
VisibleRangeGroup []string `json:"visiblerangegroup"` //可见范围(集团)
VisibleRangeDepart []string `json:"visiblerangedepart"` //可见范围（分厂）
}
//添加指标
type addTargetType struct {
Title string `json:"title"`
Type int `json:"type"` //1：定性考核；2：定量考核
Share int `json:"share"` //1：共用；2：私用
RelevantDepartments []string `json:"relevantdepartments"` //相关部门
Dimension string `json:"dimension"` //维度 (待定是否使用)
Report []string `json:"report"` //上报人
Uniteing string `json:"unites"` //单位
Cycles int `json:"cycle"` //1：班；2：天；3：周；4：月；5：季度；6：年
CycleAttres int `json:"cycleattr"` //辅助计数
VisibleRangeGroup []string `json:"visiblerangegroup"` //可见范围(集团)
VisibleRangeDepart []string `json:"visiblerangedepart"` //可见范围（分厂）
}
//列表输出
type outTargetList struct {
assessmentmodel.EvaluationTarget
OutId string `json:"outid"`
RelevantDepartmentMap []outTargetAttr `json:"relevantdepartmentsmap"`
ReportMap []outTargetAttr `json:"reportmap"`
VisibleRangeGroupMap []outTargetAttr `json:"visiblerangegroupmap"` //可见范围(集团)
VisibleRangeDepartMap []outTargetAttr `json:"visiblerangedepartmap"` //可见范围（分厂）
}
//输出结构体
type outTargetAttr struct {
Key string `json:"key"`
Title string `json:"title"`
}
//详细内容输出
type outTargetInfo struct {
assessmentmodel.EvaluationTarget
RelevantDepartmentMap []string `json:"relevantdepartmentsmap"`
ReportMap []string `json:"reportmap"`
VisibleRangeGroupMap []string `json:"visiblerangegroupmap"` //可见范围(集团)
VisibleRangeDepartMap []string `json:"visiblerangedepartmap"` //可见范围（分厂）
}
//指标内容修改
type eiteTargetTypeCont struct {
commonus.SetId
addTargetType
}
/*
定性指标相关操作
*/
type addAttTarget struct {
Title string `json:"title"`
ParentId string `json:"parentid"`
}
//子栏目列表
type attTargetList struct {
commonus.PageSetLimt
addAttTarget
State int `json:"state"` //状态（1：启用；2：禁用；3：删除）
}
//子栏目列表输出
type attTargetListOut struct {
assessmentmodel.QualitativeTarget
ParentIdStr string `json:"parentidstr"`
ParentTitle string `json:"parenttitle"`
OutId string `json:"outid"`
}
//指标子栏目修改
type eiteAttTarget struct {
commonus.SetId
addAttTarget
}
/*
考核细则相关处理
*/
type addDetailedTargetType struct {
Title string `json:"title"`
Content string `json:"content"`
ParentId string `json:"parentid"`
ParentIdSun string `json:"parentidsun"`
}
//考核细则输出
type outDetailedTargetType struct {
assessmentmodel.DetailedTarget
ParentIdStr string `json:"parentidstr"`
ParentTitle string `json:"parenttitle"`
ParentIdSunStr string `json:"parentidsunstr"`
ParentSunTitle string `json:"parentsuntitle"`
OutId string `json:"outid"`
}
//考核细则列表
type detailedTargetTypeList struct {
commonus.PageSetLimt
addDetailedTargetType
State int `json:"state"` //状态（1：启用；2：禁用；3：删除）
}
//修改考核细则
type eitedetailedTargetCon struct {
commonus.SetId
addDetailedTargetType
}
/*
定性考核
*/
type AddQualEval struct {
AcceptDepartmentId []string `json:"parentid"` //接受考核部门
Dimension string `json:"dimension"` //考核维度
Type int `json:"type"` //1：定性考核；2：定量考核
Target string `json:"target"` //考核指标
TargetSun string `json:"targetsun"` //考核指标子栏目
Group string `json:"group"` //归属集团
EvaluationList []QualEvalSunList `json:"evaluationlist"` //测评详情
}
//定性考核内容
type QualEvalSunList struct {
DetailedTarget string `json:"id"` //考核细则
Unit string `json:"unit"` //单位
ReferenceScore int64 `json:"referencescore"` //标准分值
Cycles int `json:"cycle"` //1：班；2：天；3：周；4：月；5：季度；6：年
CycleAttres int `json:"cycleattr"` //辅助计数
DepartmentId string `json:"parentid"` //执行考核部门ID
Operator []string `json:"userlist"` //考核执行人
}
//查询定性考核列表
type SelectQualEval struct {
Group string `json:"group"` //归属集团
DepartmentId string `json:"parentid"` //接受考核部门
}
//定性考核列表输出
type QualEvalArrt struct {
Id string `json:"id"`
Name string `json:"name"`
}
type QualEvalListOut struct {
QualEvalArrt
Child []QualEvalListOutDepart `json:"child"` //定性考核部门
}
//定性考核部门
type QualEvalListOutDepart struct {
QualEvalArrt
Child []DimensionList `json:"child"` //维度列表
}
//定性考核列表维度项目
type DimensionList struct {
QualEvalArrt
Child []TargetList `json:"child"` //定性指标
}
//定性指标
type TargetList struct {
QualEvalArrt
Child []TargetSunList `json:"child"` //定性指标子栏目
}
//定性指标子栏目
type TargetSunList struct {
QualEvalArrt
Child []taskDetails `json:"child"` //考核细则
}
//具体职责
type taskDetails struct {
QualEvalArrt
Content string `json:"content"` //指标说明
Unit string `json:"unit"` //单位"`
ReferenceScore int64 `json:"referencescore"` //标准分值"`
Cycles int `json:"cycle"` //1：班；2：天；3：周；4：月；5：季度；6：年"`
CycleAttres int `json:"cycleattr"` //辅助计数"`
State int `json:"state"`
}
//具体职责输出
type taskDatalsContOut struct {
Id int64 `json:"id" gorm:"column:qe_id;type:bigint(20) unsigned;not null;comment:Id;index"`
DetailedTarget int64 `json:"detailedtarget" gorm:"column:qe_detailed_target;type:bigint(20) unsigned;default:0;not null;comment:考核细则"`
Unit string `json:"unit" gorm:"column:qe_unit;type:varchar(255);comment:单位"`
ReferenceScore int64 `json:"referencescore" gorm:"column:qe_reference_score;type:int(9) unsigned;default:0;not null;comment:标准分值"`
Cycles int `json:"cycle" gorm:"column:qe_cycle;type:tinyint(1) unsigned;default:1;not null;comment:1：班；2：天；3：周；4：月；5：季度；6：年"`
CycleAttres int `json:"cycleattr" gorm:"column:qe_cycleattr;type:int(9) unsigned;default:1;not null;comment:辅助计数"`
State int `json:"state" gorm:"column:qe_state;type:int(1) unsigned;default:1;not null;comment:状态（1：启用；2：禁用；3：删除）"`
}
//定量指标
type QualEvalRationListOut struct {
QualEvalArrt
Child []QualEvalRationListOutDepart `json:"child"` //定量考核部门
}
//定量考核部门
type QualEvalRationListOutDepart struct {
QualEvalArrt
Child []DimensionRationList `json:"child"` //维度列表
}
//定量考核列表维度项目
type DimensionRationList struct {
QualEvalArrt
Child []taskDetails `json:"child"` //定量指标
}
//定量指标
type TargetRationList struct {
QualEvalArrt
Child []taskDetails `json:"child"` //定量指标子栏目
}
//获取相关任务目标
type taskTargetList struct {
Type int `json:"type"` //1：定性考核；2：定量考核
Group string `json:"group"` //归属集团
DepartMent []string `json:"department"`
}
//根据条件获取考核细则
type SelectTaskTarget struct {
Type int `json:"type"` //1：定性考核；2：定量考核
TargetId string `json:"targetid"`
TargetSunId string `json:"targetsunid"`
}
/*
定量考核
*/
type AddRationCont struct {
AcceptDepartmentId []string `json:"parentid"` //接受考核部门
Dimension string `json:"dimension"` //考核维度
Type int `json:"type"` //1：定性考核；2：定量考核
Group string `json:"group"` //归属集团
RationList []rationList `json:"rationlist"` //考核明细列表
}
//定量考核明细
type rationList struct {
Target string `json:"id"` //考核指标
DepartmentId string `json:"parentid"` //执行考核部门ID
Unit string `json:"unit"` //单位
ReferenceScore int64 `json:"referencescore"` //标准分值
Cycles int `json:"cycle"` //1：班；2：天；3：周；4：月；5：季度；6：年
CycleAttres int `json:"cycleattr"` //辅助计数
Operator []string `json:"userlist"` //考核执行人
}
//定量考核列表查询
type rationSelect struct {
Group string `json:"group"` //归属集团
DepartmentId string `json:"parentid"` //接受考核部门
}
//部门考核
type deparMentModel struct {
Id int64 `json:"id" gorm:"column:bf_id;type:bigint(20);;primaryKey;unique;not null;autoIncrement;index"`
Name string `json:"name" gorm:"column:bf_name;type:varchar(30);not null;comment:分厂名称"` //'分厂名称',
WechatId int `json:"wechatid" gorm:"column:bf_wechat_id;type:int(4) unsigned;default:0;not null;comment:对照微信id"` //'对照微信id',
}
//部门考核输出列表
type departmentDuty struct {
QualEvalArrt
Child []departmentDimension `json:"child"` //考核细则
}
//部门考核维度输出列表
type departmentDimension struct {
QualEvalArrt
Child []taskDetails `json:"child"` //考核细则
}
//考核细则联动列表
type taskDetailsLinkage struct {
QualEvalArrt
Content string `json:"content"` //指标说明
Unit string `json:"unit"` //单位"`
ReferenceScore int64 `json:"referencescore"` //标准分值"`
Cycles int `json:"cycle"` //1：班；2：天；3：周；4：月；5：季度；6：年"`
CycleAttres int `json:"cycleattr"` //辅助计数"`
State int `json:"state"`
UserList []string `json:"userlist"` //执行人列表
UserListAry []QualEvalArrt `json:"userlistary"` //执行人列表
}
//添加定性考核权重
type addDepartmentDimensionWeight struct {
Hierarchy int64 `json:"hierarchy"` //层级
Type int64 `json:"type"` //1：定性考核；2：定量考核
Group string `json:"group"` //归属集团
DepartmentId string `json:"parentid"` //接受考核部门
Dimension string `json:"dimension"` //维度
TargetId string `json:"targetid"` //指标
Weight int64 `json:"weight"` //权重
}
//批量添加指标权重
type addDepartDimensionWeightAry struct {
// Hierarchy int64 `json:"hierarchy"` //层级
Type int64 `json:"type"` //1：定性考核；2：定量考核
Group string `json:"group"` //归属集团
DepartmentId string `json:"parentid"` //接受考核部门
Dimension string `json:"dimension"` //维度
TargetList []targetListType `json:"targetlist"` //指标
}
type targetListType struct {
Id string `json:"id"`
Weight int64 `json:"weight"` //权重
}
//批量添加维度权重
type addDepartDimenWeightAry struct {
// Hierarchy int64 `json:"hierarchy"` //层级
Type int64 `json:"type"` //1：定性考核；2：定量考核
Group string `json:"group"` //归属集团
DepartmentId string `json:"parentid"` //接受考核部门
Dimension []targetListType `json:"dimension"` //维度
}
//获取定量考核相关列表
type getDaulEvalDuty struct {
assessmentmodel.EvaluationTarget
}

1
gin_server_admin/api/v1/assessment/enter.go
View File

@ -2,4 +2,5 @@ package assessment
type ApiGroup struct {
DutyHandle
EvaluationScheme
}

267
gin_server_admin/api/v1/assessment/programme.go
View File

@ -0,0 +1,267 @@
package assessment
import (
"encoding/json"
"fmt"
"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 (a *EvaluationScheme) Index(c *gin.Context) {
outPut := commonus.MapOut()
response.Result(0, outPut, "测评方案获取成功", c)
}
//添加考核方案
func (a *EvaluationScheme) AddEvaluationScheme(c *gin.Context) {
var requestData AddScheme
err := c.ShouldBindJSON(&requestData)
if err != nil {
response.Result(101, err, "参数错误！请重新提交！", c)
return
}
if requestData.Title == "" {
response.Result(102, err, "请输入考核名称！", c)
return
}
if requestData.Group == 0 {
response.Result(103, err, "请选择归属集团！", c)
return
}
// if requestData.Department == "" {
// response.Result(104, err, "请选择被考核的部门（分厂）！", c)
// return
// }
if requestData.Dimension == "" {
response.Result(105, err, "请选择考核维度！", c)
return
}
if requestData.Project == "" {
response.Result(106, err, "请选择考核项目！", c)
return
}
if requestData.Weight == 0 {
response.Result(107, err, "请输入权重！", c)
return
}
if len(requestData.Content) < 1 {
response.Result(108, err, "请输入方案内容！", c)
return
}
if requestData.ExecutiveDepartment == 0 {
response.Result(109, err, "请选择执行部门（分厂）！", c)
return
}
if len(requestData.Department) < 1 {
response.Result(111, err, "请选择被考核的部门（分厂）！", c)
return
}
var dataStruct dataLockStatistics
for _, departId := range requestData.Department {
syncProcess.Add(1)
go dataStruct.addEvaluationSchemeHandel(departId, requestData)
}
syncProcess.Wait()
returData := commonus.MapOut()
readDataMap, readBaoJinf := dataStruct.readMyDayData()
returData["istrue"] = readDataMap
returData["isfalse"] = readBaoJinf
if len(readBaoJinf) > 0 {
response.Result(112, returData, "有未处理失败的数据！请检查", c)
} else {
response.Result(0, returData, "数据处理完成！", c)
}
}
//并发写入考核方案
func (d *dataLockStatistics) addEvaluationSchemeHandel(departId int64, addData AddScheme) {
d.mutext.Lock()
defer d.mutext.Unlock()
// fmt.Printf("%v\n", departId)
juadgeOut := commonus.MapOut()
juadeIsTrue := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.EvaluationScheme{}).Where("`es_evaluation_department` = ? AND `es_title` = ?", departId, addData.Title).First(&juadgeOut).Error
if juadeIsTrue == nil {
errMap := commonus.MapOut()
errMap["departid"] = departId
bfErr, bfCont := commonus.GetBranchFactory(departId)
if bfErr == true {
errMap["departmentname"] = bfCont.Name
} else {
errMap["departmentname"] = ""
}
errMap["title"] = addData.Title
errMap["msg"] = fmt.Sprintf("在%v中已经存在《%v》考核方案！请不要重复添加！", errMap["departmentname"], addData.Title)
d.dataErrMap = append(d.dataErrMap, errMap)
} else {
var saveData assessmentmodel.EvaluationScheme
saveData.Id = commonus.GetFileNumberEs()
saveData.Title = addData.Title
saveData.Group = addData.Group
saveData.EvaluationDepartment = departId
dimensionId, dimensionIdErr := strconv.ParseInt(addData.Dimension, 10, 64)
if dimensionIdErr == nil {
saveData.Dimension = dimensionId
}
projectId, projectIdErr := strconv.ParseInt(addData.Project, 10, 64)
if projectIdErr == nil {
saveData.Project = projectId
}
saveData.Weight = addData.Weight
saveData.ExecutiveDepartment = addData.ExecutiveDepartment
jsonCont, jsonContErr := json.Marshal(addData.Content)
if jsonContErr == nil {
saveData.Content = string(jsonCont)
}
saveData.AddTime = time.Now().Unix()
saveData.EiteTime = time.Now().Unix()
saveData.Maker = 1
saveDataes, isError := d.NewsAddRules(projectId, addData.Content)
if isError != true {
msg := commonus.MapOut()
msg["id"] = saveData.Id
msg["title"] = saveData.Title
msg["msg"] = "此考核方案的细则录入失败！请重新处理此方案"
d.dataMap = append(d.dataMap, msg)
} else {
jsonSection, jsonErr := json.Marshal(saveDataes)
if jsonErr != nil {
msg := commonus.MapOut()
msg["id"] = saveData.Id
msg["title"] = saveData.Title
msg["msg"] = "此考核方案的细则录入失败！请重新处理此方案"
d.dataMap = append(d.dataMap, msg)
} else {
saveData.Content = string(jsonSection)
juSaveDataErr := global.GVA_DB_Performanceappraisal.Create(&saveData)
if juSaveDataErr == nil {
msg := commonus.MapOut()
msg["id"] = saveData.Id
msg["title"] = saveData.Title
msg["msg"] = "此考核方案录入成功！"
d.dataMap = append(d.dataMap, msg)
} else {
msg := commonus.MapOut()
msg["id"] = saveData.Id
msg["title"] = saveData.Title
msg["msg"] = "此考核方案录入失败！"
d.dataMap = append(d.dataMap, msg)
}
}
}
}
syncProcess.Done()
}
//判断要新增的考核细则
func (d *dataLockStatistics) NewsAddRules(parentId int64, dataAry []schemeContent) (rulesSaveData []map[string]interface{}, isTrue bool) {
isTrue = false
for _, val := range dataAry {
writeData := commonus.MapOut()
if val.Id == "" {
writeId := commonus.GetFileNumberEs()
writeData["dc_id"] = writeId
writeData["dc_title"] = val.Title
writeData["dc_time"] = time.Now().Unix()
writeData["dc_state"] = 1
writeData["dc_parent"] = parentId
writeData["dc_user_type"] = 1
writeData["dc_dump"] = val.Section
writeData["dc_type"] = val.Type
writeData["dc_unit"] = val.Unittitle
writeData["dc_cycle"] = val.Cycle
writeData["dc_cycleattr"] = val.Cycleattr
writeData["dc_cont"] = val.Content
juadgeOut := commonus.MapOut()
juadgeAddDataErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DutyContent{}).Where("`dc_parent` = ? AND `dc_title` = ?", parentId, val.Title).First(&juadgeOut).Error
if juadgeAddDataErr == nil {
rulesSaveData = append(rulesSaveData, juadgeOut)
} else {
saveDataErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DutyContent{}).Create(&writeData).Error
if saveDataErr == nil {
rulesSaveData = append(rulesSaveData, writeData)
} else {
msg := commonus.MapOut()
msg["id"] = val.Id
msg["title"] = val.Title
msg["msg"] = "此考核细则写入失败！请重新处理此细则"
d.dataErrMap = append(d.dataErrMap, msg)
}
}
} else {
dataOut := commonus.MapOut()
juadgeErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DutyContent{}).Where("`dc_id` = ?", val.Id).First(&dataOut).Error
if juadgeErr == nil {
rulesSaveData = append(rulesSaveData, dataOut)
} else {
writeId := commonus.GetFileNumberEs()
writeData["dc_id"] = writeId
writeData["dc_title"] = val.Title
writeData["dc_time"] = time.Now().Unix()
writeData["dc_state"] = 1
writeData["dc_parent"] = parentId
writeData["dc_user_type"] = 1
writeData["dc_dump"] = val.Section
writeData["dc_type"] = val.Type
writeData["dc_unit"] = val.Unittitle
writeData["dc_cycle"] = val.Cycle
writeData["dc_cycleattr"] = val.Cycleattr
writeData["dc_cont"] = val.Content
saveDataErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DutyContent{}).Create(&writeData).Error
if saveDataErr == nil {
rulesSaveData = append(rulesSaveData, writeData)
} else {
msg := commonus.MapOut()
msg["id"] = val.Id
msg["title"] = val.Title
msg["msg"] = "此考核细则写入失败！请重新处理此细则"
d.dataErrMap = append(d.dataErrMap, msg)
}
}
}
}
if len(rulesSaveData) > 0 {
isTrue = true
}
return
}
// {
// "title": "2022年恒信高科01号考核方案",
// "group": 3,
// "department": "[1,2,3,4]",
// "dimension": "1644884869457674",
// "project": "16448868625724229",
// "weight": 30,
// "ExecutiveDepartment": 15,
// "content": [
// {
// "id": "16448933707009289",
// "title": "各区域卫生保持情况；",
// "type": 1,
// "parentId": "16448868625724229",
// "section": "15",
// "unittitle": "分",
// "cycle": 3,
// "cycleattr": 1,
// "content": "区域卫生保持不到位、打扫不及时根据情况扣除0.1-0.3分。"
// }
// ]
// }
// {"title":"2022年恒信高科01号考核方案","group":3,"department":[1,2,3,4],"dimension":"1644884869457674","project":"16448868625724229","weight":30,"ExecutiveDepartment":15,"content":[{"id":"16448933707009289","title":"各区域卫生保持情况；","type":1,"parentId":"16448868625724229","section":"15","unittitle":"\u5206","cycle":3,"cycleattr":1,"content":"区域卫生保持不到位、打扫不及时根据情况扣除0.1-0.3分。"}]}

801
gin_server_admin/api/v1/assessment/qualitative_evaluation.go
View File

@ -0,0 +1,801 @@
package assessment
import (
"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 *DutyHandle) AddQualEval(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(102, err, "请选择接受考核的部门！", c)
return
}
if requestData.Dimension == "" {
response.Result(102, err, "请选择考核维度", c)
return
}
if requestData.Target == "" {
response.Result(102, err, "请选择考核指标", c)
return
}
if requestData.TargetSun == "" {
response.Result(102, err, "请选择考核指标子栏目", c)
return
}
if len(requestData.EvaluationList) <= 0 {
response.Result(102, err, "请添加测评详情！", c)
return
}
var synergeticProcess dataLockStatistics
for _, deparmentId := range requestData.AcceptDepartmentId {
addDepartDimension(requestData.Group, deparmentId, requestData.Dimension, 1)
syncProcess.Add(1)
go synergeticProcess.addQualEvalList(deparmentId, requestData)
}
syncProcess.Wait()
returData := commonus.MapOut()
readDataMap, readBaoJinf := synergeticProcess.readMyDayData()
returData["istrue"] = readDataMap
returData["isfalse"] = readBaoJinf
if len(readBaoJinf) > 0 && len(readDataMap) == 0 {
response.Result(112, returData, "有未处理失败的数据！请检查", c)
} else if len(readBaoJinf) > 0 && len(readDataMap) > 0 {
response.Result(1, returData, "有部门数据处理失败！请针对性输入！", c)
} else {
response.Result(0, returData, "数据处理完成！", c)
}
}
func (d *dataLockStatistics) addQualEvalList(departmentId string, addData AddQualEval) {
d.mutext.Lock()
defer d.mutext.Unlock()
var saveDataAry []assessmentmodel.QualitativeEvaluation
for _, v := range addData.EvaluationList {
var saveData assessmentmodel.QualitativeEvaluation
juadgeMap := commonus.MapOut()
juadgeInsetErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Select("qe_id").Where("`qe_accept_evaluation` = ? AND `qe_dimension` = ? AND `qe_target` = ? AND `qe_target_sun` = ? AND `qe_detailed_target` = ?", departmentId, addData.Dimension, addData.Target, addData.TargetSun, v.DetailedTarget).First(&juadgeMap).Error
if juadgeInsetErr != nil {
groupInt, groupIntErr := strconv.ParseInt(addData.Group, 10, 64)
if groupIntErr == nil {
saveData.Group = groupInt
}
saveData.Type = addData.Type
departidInt, departinIntErr := strconv.ParseInt(v.DepartmentId, 10, 64)
// if departidInt == 0 {
// saveData.DepartmentId = departidInt
// }
if departinIntErr == nil {
saveData.DepartmentId = departidInt
}
dimensionInt, departinIntErr := strconv.ParseInt(addData.Dimension, 10, 64)
if departinIntErr == nil {
saveData.Dimension = dimensionInt
}
targetInt, targetIntErr := strconv.ParseInt(addData.Target, 10, 64)
if targetIntErr == nil {
saveData.Target = targetInt
}
targetSunInt, targetSunIntErr := strconv.ParseInt(addData.TargetSun, 10, 64)
if targetSunIntErr == nil {
saveData.TargetSun = targetSunInt
}
detailedTargetInt, detailedTargetIntErr := strconv.ParseInt(v.DetailedTarget, 10, 64)
if detailedTargetIntErr == nil {
saveData.DetailedTarget = detailedTargetInt
}
saveData.Unit = v.Unit
saveData.ReferenceScore = v.ReferenceScore
saveData.Cycles = v.Cycles
saveData.CycleAttres = v.CycleAttres
saveData.State = 1
saveData.Addtime = time.Now().Unix()
saveData.Eitetime = time.Now().Unix()
departmentIdInt, departmentIdIntErr := strconv.ParseInt(departmentId, 10, 64)
if departmentIdIntErr == nil {
saveData.AcceptEvaluation = departmentIdInt
}
saveData.Operator = strings.Join(v.Operator, ",")
// operatorInt, operatorIntErr := strconv.ParseInt(v.Operator, 10, 64)
// if operatorIntErr == nil {
// saveData.Operator = strings.Join(v.Operator,",")
// }
// saveData.AcceptEvaluation = departmentIdInt
saveDataAry = append(saveDataAry, saveData)
msg := commonus.MapOut()
msg["msg"] = saveData
d.dataMap = append(d.dataMap, msg)
} else {
detailedTargetInts, _ := strconv.ParseInt(v.DetailedTarget, 10, 64)
dtCont, dtIsTrue := commonus.GetDetailedTargetInfo(detailedTargetInts)
groupInt, _ := strconv.ParseInt(addData.Group, 10, 64)
departidInt, _ := strconv.ParseInt(departmentId, 10, 64)
_, groupCont := commonus.GetGroupCont(groupInt)
_, deparConCont := commonus.GetBranchFactory(departidInt)
msg := commonus.MapOut()
if dtIsTrue == true {
msg["msg"] = fmt.Sprintf("%v-%v《%v》考核细则录入失败！请重新处理此方案！->ID:%v", groupCont.Name, deparConCont.Name, dtCont.Title, v.DetailedTarget)
} else {
msg["msg"] = fmt.Sprintf("%v-%v《%v》考核细则录入失败！请重新处理此方案", groupCont.Name, deparConCont.Name, v.DetailedTarget)
}
d.dataErrMap = append(d.dataErrMap, msg)
}
}
if len(saveDataAry) > 0 {
addErr := global.GVA_DB_Performanceappraisal.Create(&saveDataAry).Error
if addErr != nil {
msg := commonus.MapOut()
msg["data"] = saveDataAry
msg["msg"] = fmt.Sprintf("《%v》考核维度录入失败！请重新处理此方案", addData.Dimension)
d.dataErrMap = append(d.dataErrMap, msg)
}
}
syncProcess.Done()
}
//定性考核列表
func (d *DutyHandle) GetQualEvalList(c *gin.Context) {
var requestData SelectQualEval
c.ShouldBindJSON(&requestData)
//归档集团
gormDb := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Select("qe_group").Where("qe_type = 1").Group("qe_group")
if requestData.Group != "" {
gormDb = gormDb.Having("qe_group = ?", requestData.Group)
}
var fileAry []int64
listErr := gormDb.Find(&fileAry).Error
if listErr != nil {
response.Result(101, listErr, "没有数据！", c)
return
}
if len(fileAry) < 1 {
response.Result(102, listErr, "没有数据！", c)
return
}
var aualEvalArrtAry []QualEvalListOut
for _, v := range fileAry {
var aualEvalArrtCont QualEvalListOut
groupErr, groupCont := commonus.GetGroupCont(v)
if groupErr == true {
aualEvalArrtCont.Id = strconv.FormatInt(v, 10)
aualEvalArrtCont.Name = groupCont.Name
//归档分厂-部室
departAry, departAryErr := deparmentList(v, requestData.DepartmentId)
if departAryErr == true {
//分厂部室列表
aualEvalArrtCont.Child = departAry
}
//组合集团
aualEvalArrtAry = append(aualEvalArrtAry, aualEvalArrtCont)
}
}
response.Result(0, aualEvalArrtAry, "查询完成！", c)
}
//归档部门
func deparmentList(groupID int64, departmentIDStr string) (contentList []QualEvalListOutDepart, isTrue bool) {
isTrue = false
gormDbDepart := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Select("qe_accept_evaluation").Where("qe_type = 1 AND `qe_group` = ?", groupID).Group("qe_accept_evaluation")
if departmentIDStr != "" {
gormDbDepart = gormDbDepart.Having("qe_accept_evaluation = ?", departmentIDStr)
}
var fileDepartAry []int64
listDepartErr := gormDbDepart.Find(&fileDepartAry).Error
if listDepartErr == nil {
for _, v := range fileDepartAry {
deparConErr, deparConCont := commonus.GetBranchFactory(v)
var deparCont QualEvalListOutDepart
if deparConErr == true {
deparCont.Id = strconv.FormatInt(v, 10)
deparCont.Name = deparConCont.Name
//归档维度
dimensionAry, dimensionAryErr := dimensionList(groupID, v)
if dimensionAryErr == true {
//维度列表
deparCont.Child = dimensionAry
}
}
//组合分厂部室
contentList = append(contentList, deparCont)
}
}
if len(contentList) > 0 {
isTrue = true
}
return
}
//归档维度
func dimensionList(groupID, departmentID int64) (contentList []DimensionList, isTrue bool) {
isTrue = false
var fileDimensionAry []int64
listDimensionErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Select("qe_dimension").Where("qe_type = 1 AND `qe_group` = ? AND `qe_accept_evaluation` = ?", groupID, departmentID).Group("qe_dimension").Find(&fileDimensionAry).Error
if listDimensionErr == nil {
for _, v := range fileDimensionAry {
dutyClassCont, dutyClassErr := commonus.GetDutyClassInfo(v)
var dimenCont DimensionList
if dutyClassErr == true {
dimenCont.Id = strconv.FormatInt(v, 10)
dimenCont.Name = dutyClassCont.Title
//归档指标
targerAry, targerAryErr := targetList(groupID, departmentID, v)
if targerAryErr == true {
//定性考核指标列表
dimenCont.Child = targerAry
}
//组合维度
contentList = append(contentList, dimenCont)
}
}
}
if len(contentList) > 0 {
isTrue = true
}
return
}
//查询归档定性指标
func targetList(groupID, departmentID, dimension int64) (contentList []TargetList, isTrue bool) {
isTrue = false
var fileTargetAry []int64
listTargetErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Select("qe_target").Where("qe_type = 1 AND `qe_group` = ? AND `qe_accept_evaluation` = ? AND `qe_dimension` = ?", groupID, departmentID, dimension).Group("qe_target").Find(&fileTargetAry).Error
if listTargetErr != nil {
return
}
for _, tar_v := range fileTargetAry {
var targetCont TargetList
targetInfo, targetErr := commonus.GetTargetInfo(tar_v)
if targetErr == true {
targetCont.Id = strconv.FormatInt(tar_v, 10)
targetCont.Name = targetInfo.Title
//归档指标子栏目
targerSunAry, targerSunAryErr := targetSunList(groupID, departmentID, dimension, tar_v)
if targerSunAryErr == true {
targetCont.Child = targerSunAry
}
//定性考核指标维度
contentList = append(contentList, targetCont)
}
}
if len(contentList) > 0 {
isTrue = true
}
return
}
//查询归档定性子栏目
func targetSunList(groupID, departmentID, dimension, targetId int64) (contentList []TargetSunList, isTrue bool) {
isTrue = false
var fileTargetSunAry []int64
listTargetSunErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Select("qe_target_sun").Where("qe_type = 1 AND `qe_group` = ? AND `qe_accept_evaluation` = ? AND `qe_dimension` = ? AND `qe_target` = ?", groupID, departmentID, dimension, targetId).Group("qe_target_sun").Find(&fileTargetSunAry).Error
if listTargetSunErr != nil {
return
}
for _, v := range fileTargetSunAry {
info, infoErr := commonus.GetQualitativeTargetInfo(v)
if infoErr == true {
var content TargetSunList
content.Id = strconv.FormatInt(v, 10)
content.Name = info.Title
listAry, listAryErr := taskDetailsList(groupID, departmentID, dimension, targetId, v)
if listAryErr == true {
content.Child = listAry
}
contentList = append(contentList, content)
}
}
if len(contentList) > 0 {
isTrue = true
}
return
}
//考核细则
func taskDetailsList(groupID, departmentID, dimension, targetId, targetSunId int64) (contentList []taskDetails, isTrue bool) {
isTrue = false
var taskDetailsCont []taskDatalsContOut
listTargetSunErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Select("qe_id", "qe_detailed_target", "qe_unit", "qe_reference_score", "qe_cycle", "qe_cycleattr", "qe_state").Where("qe_type = 1 AND `qe_group` = ? AND `qe_accept_evaluation` = ? AND `qe_dimension` = ? AND `qe_target` = ? AND `qe_target_sun` = ? AND `qe_state` = 1", groupID, departmentID, dimension, targetId, targetSunId).Find(&taskDetailsCont).Error
if listTargetSunErr != nil {
return
}
for _, v := range taskDetailsCont {
var content taskDetails
content.Id = strconv.FormatInt(v.Id, 10)
dtCont, dtIsTrue := commonus.GetDetailedTargetInfo(v.DetailedTarget)
if dtIsTrue == true {
content.Name = dtCont.Title
content.Content = dtCont.Content
}
content.Unit = v.Unit
content.ReferenceScore = v.ReferenceScore
content.Cycles = v.Cycles
content.CycleAttres = v.CycleAttres
content.State = v.State
contentList = append(contentList, content)
}
if len(contentList) > 0 {
isTrue = true
}
return
}
//获取考核指标
func (d *DutyHandle) GetTaskTarget(c *gin.Context) {
var requestData taskTargetList
err := c.ShouldBindJSON(&requestData)
if err != nil {
response.Result(101, err, "数据获取失败！", c)
return
}
if requestData.Type == 0 {
response.Result(101, requestData, "请选择您操作的时定性指标还是定量指标！", c)
return
}
var contAry []assessmentmodel.EvaluationTarget
gormDb := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.EvaluationTarget{}).Where("et_state = 1 AND `et_type` = ?", requestData.Type)
// if requestData.Group == "" && len(requestData.DepartMent) < 1 {
// gormDb = gormDb.Where("`et_visible_group` = '' AND `et_visible_range` = '' AND `et_share` = 1")
// } else if requestData.Group != "" && len(requestData.DepartMent) < 1 {
// gormDb = gormDb.Where("FIND_IN_SET(?,`et_visible_group`) OR (`et_visible_group` = '' AND `et_visible_range` = '')", requestData.Group)
// } else {
// }
if len(requestData.DepartMent) < 1 {
gormDb = gormDb.Where("`et_share` = 1")
} else {
var sqlOrStr string = ""
for s_i, s_v := range requestData.DepartMent {
if s_i == 0 {
sqlOrStr = fmt.Sprintf("FIND_IN_SET(%v,`et_relevant_departments`)", s_v)
} else {
sqlOrStr = fmt.Sprintf("%v OR FIND_IN_SET(%v,`et_relevant_departments`)", sqlOrStr, s_v)
}
}
sqlOrStr = fmt.Sprintf("`et_share` = 1 OR (`et_share` = 2 AND (%v))", sqlOrStr)
gormDb = gormDb.Where(sqlOrStr)
}
listErr := gormDb.Find(&contAry).Error
if listErr != nil {
response.Result(201, listErr, "没有相关数据！", c)
return
}
response.Result(0, contAry, "数据获取成功！", c)
}
//获取定性指标子栏目
func (d *DutyHandle) GetTaskTargetSun(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 contAry []assessmentmodel.QualitativeTarget
contErr := global.GVA_DB_Performanceappraisal.Where("q_state = 1 AND `q_parent_id` = ?", requestData.Id).Find(&contAry).Error
if contErr != nil {
response.Result(201, contErr, "没有相关数据！", c)
return
}
response.Result(0, contAry, "数据获取成功！", c)
}
//根据条件获取考核详情
func (d *DutyHandle) GetTaskTargetContAry(c *gin.Context) {
var requestData SelectTaskTarget
err := c.ShouldBindJSON(&requestData)
if err != nil {
response.Result(101, err, "数据获取失败！", c)
return
}
if requestData.Type == 0 {
response.Result(102, err, "位置指标性质！", c)
return
}
if requestData.TargetId == "" {
response.Result(102, err, "请选择指标！", c)
return
}
if requestData.Type == 1 && requestData.TargetSunId == "" {
response.Result(102, err, "未知子栏目！请选择", c)
return
}
var contAry []assessmentmodel.DetailedTarget
gormDb := global.GVA_DB_Performanceappraisal.Where("dt_state = 1 AND `dt_parentid` = ?", requestData.TargetId)
if requestData.TargetSunId != "" {
gormDb = gormDb.Where("`dt_parentid_sun` = ?", requestData.TargetSunId)
}
contErr := gormDb.Find(&contAry).Error
if contErr != nil {
response.Result(201, contErr, "没有相关数据！", c)
return
}
var targetInfo assessmentmodel.EvaluationTarget
targetInfoErr := global.GVA_DB_Performanceappraisal.Where("`et_id` = ?", requestData.TargetId).First(&targetInfo).Error
var outContList []taskDetailsLinkage
for _, v := range contAry {
var outCont taskDetailsLinkage
outCont.Id = strconv.FormatInt(v.Id, 10)
outCont.Name = v.Title
outCont.Content = v.Content
outCont.State = v.State
if targetInfoErr == nil {
outCont.Unit = targetInfo.Uniteing
// outCont.ReferenceScore = v.Content
outCont.Cycles = targetInfo.Cycles
outCont.CycleAttres = targetInfo.CycleAttres
if targetInfo.Report != "" {
userKeyAry := strings.Split(targetInfo.Report, ",")
if len(userKeyAry) > 0 {
outCont.UserList = userKeyAry
// for _, u_v := range userKeyAry {
// usCont, usErr := archiveapi.GetUserInfo([]string{"worker_man.wm_number", "worker_man_data.wmd_name"}, map[string]interface{}{"wm_key": u_v})
// if usErr == true {
// var userCont QualEvalArrt
// userCont.Id = u_v
// userCont.Name = usCont.Name
// outCont.UserListAry = append(outCont.UserListAry, userCont)
// }
// }
}
}
}
outContList = append(outContList, outCont)
}
response.Result(0, outContList, "数据获取成功！", c)
}
//添加定性考核权重
func (d *DutyHandle) AddQualEvalWeight(c *gin.Context) {
var requestData addDepartmentDimensionWeight
err := c.ShouldBindJSON(&requestData)
if err != nil {
response.Result(101, err, "数据获取失败！", c)
return
}
if requestData.Hierarchy == 0 {
response.Result(101, err, "请指定当前添加的是维度权重还是指标权重！", c)
return
}
if requestData.Type == 0 {
response.Result(101, err, "请指定当前添加的是定性考核权重还是定量考核权重！", c)
return
}
if requestData.Group == "" {
response.Result(101, err, "请指定当前为哪个集团添加！", c)
return
}
if requestData.DepartmentId == "" {
response.Result(101, err, "请指定当前为哪个分厂或部室添加！", c)
return
}
if requestData.Dimension == "" {
response.Result(101, err, "请指定当前为哪个维度添加！", c)
return
}
if requestData.Hierarchy > 1 && requestData.TargetId == "" {
response.Result(101, err, "请指定当前为哪个指标添加！", c)
return
}
//判断当前权重是否写入
judgeAry := commonus.MapOut()
gromDbJudeg := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DepartmentDimensionWeight{}).Where("`ddw_hierarchy` = ? AND `ddw_type` = ? AND `ddw_group` = ? AND `ddw_derpatment` = ? AND `ddw_dimension` = ?", requestData.Hierarchy, requestData.Type, requestData.Group, requestData.DepartmentId, requestData.Dimension)
if requestData.Hierarchy > 1 && requestData.TargetId != "" {
gromDbJudeg = gromDbJudeg.Where("`ddw_target` = ?", requestData.TargetId)
}
scoreJudegErr := gromDbJudeg.First(&judgeAry).Error
if scoreJudegErr == nil {
response.Result(101, err, "此权重项已经添加！请不要重复添加！", c)
return
}
//获取当前条件下的权重总和
var sumScore int64 = 0
gromDb := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DepartmentDimensionWeight{}).Where("`ddw_hierarchy` = ? AND `ddw_type` = ? AND `ddw_group` = ? AND `ddw_derpatment` = ? AND `ddw_dimension` = ?", requestData.Hierarchy, requestData.Type, requestData.Group, requestData.DepartmentId, requestData.Dimension)
if requestData.Hierarchy > 1 && requestData.TargetId != "" {
gromDb = gromDb.Where("`ddw_target` = ?", requestData.TargetId)
}
scoreErr := gromDb.Pluck("COALESCE(SUM(ddw_weight), 0) as rescore", &sumScore).Error
if scoreErr != nil {
sumScore = 0
}
resultScore := 10000 - sumScore*100
if resultScore-(requestData.Weight*100) < 0 {
msgStr := fmt.Sprintf("权重超出剩余可分配权重最大值！当前可使用的权重为：（%v）。您要写入的权重为：《%v》。请您合理分配权重！", resultScore/100, requestData.Weight)
response.Result(101, err, msgStr, c)
return
}
var saveData assessmentmodel.DepartmentDimensionWeight
saveData.Type = requestData.Type
groupId, _ := strconv.ParseInt(requestData.Group, 10, 64)
saveData.Group = groupId
departmentId, _ := strconv.ParseInt(requestData.DepartmentId, 10, 64)
saveData.DepartmentId = departmentId
dimensionId, _ := strconv.ParseInt(requestData.Dimension, 10, 64)
saveData.Dimension = dimensionId
targetId, _ := strconv.ParseInt(requestData.TargetId, 10, 64)
saveData.Target = targetId
saveData.Weight = requestData.Weight * 100
saveData.Addtime = time.Now().Unix()
saveData.Hierarchy = requestData.Hierarchy
addErr := global.GVA_DB_Performanceappraisal.Create(&saveData).Error
if addErr != nil {
response.Result(101, addErr, "数据写入失败！", c)
return
}
response.Result(0, saveData, "数据写入成功！", c)
}
//批量添加指标权重
func (d *DutyHandle) AddQualEvalDimWeightBatch(c *gin.Context) {
var requestData addDepartDimensionWeightAry
err := c.ShouldBindJSON(&requestData)
if err != nil {
response.Result(101, err, "数据获取失败！", c)
return
}
if requestData.Type == 0 {
response.Result(102, err, "请指定当前添加的是定性考核权重还是定量考核权重！", c)
return
}
if requestData.Group == "" {
response.Result(103, err, "请指定当前为哪个集团添加！", c)
return
}
if requestData.DepartmentId == "" {
response.Result(104, err, "请指定当前为哪个分厂或部室添加！", c)
return
}
if requestData.Dimension == "" {
response.Result(105, err, "请指定当前为哪个维度添加！", c)
return
}
var targetIdAry []int64
if len(requestData.TargetList) < 1 {
response.Result(106, err, "请指定当前为哪些指标添加！", c)
return
} else {
var judgeSumScoer int64 = 0
for _, t_v := range requestData.TargetList {
judgeSumScoer = judgeSumScoer + t_v.Weight
tarIdInt, tarIdIntErr := strconv.ParseInt(t_v.Id, 10, 64)
if tarIdIntErr == nil {
targetIdAry = append(targetIdAry, tarIdInt)
}
}
if 10000-judgeSumScoer*100 < 0 {
response.Result(107, judgeSumScoer, "权重综合超过了限定值100！请重新输入", c)
return
}
}
//判断是否已经存在其他的已添加选项
var sumScoreNotIn int64 = 0
gromDbNotIn := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DepartmentDimensionWeight{}).Where("`ddw_hierarchy` = 2 AND `ddw_type` = ? AND `ddw_group` = ? AND `ddw_derpatment` = ? AND `ddw_dimension` = ?", requestData.Type, requestData.Group, requestData.DepartmentId, requestData.Dimension)
if len(targetIdAry) > 0 {
gromDbNotIn = gromDbNotIn.Where("`ddw_target` NOT IN ?", targetIdAry)
}
scoreNotInErr := gromDbNotIn.Pluck("COALESCE(SUM(ddw_weight), 0) as rescore", &sumScoreNotIn).Error
if scoreNotInErr != nil {
sumScoreNotIn = 0
}
sumScoreNotIn = sumScoreNotIn * 100
//获取当前维度下的指标权重总和
var sumScore int64 = 0
gromDb := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DepartmentDimensionWeight{}).Where("`ddw_hierarchy` = 2 AND `ddw_type` = ? AND `ddw_group` = ? AND `ddw_derpatment` = ? AND `ddw_dimension` = ?", requestData.Type, requestData.Group, requestData.DepartmentId, requestData.Dimension)
if len(targetIdAry) > 0 {
gromDb = gromDb.Where("`ddw_target` IN ?", targetIdAry)
}
scoreErr := gromDb.Pluck("COALESCE(SUM(ddw_weight), 0) as rescore", &sumScore).Error
if scoreErr != nil {
sumScore = 0
}
sumScore = sumScore * 100
if sumScore == 0 && sumScoreNotIn == 0 {
var saveData []assessmentmodel.DepartmentDimensionWeight
for _, v := range requestData.TargetList {
var saveDataCont assessmentmodel.DepartmentDimensionWeight
saveDataCont.Type = requestData.Type
groupId, _ := strconv.ParseInt(requestData.Group, 10, 64)
saveDataCont.Group = groupId
departmentId, _ := strconv.ParseInt(requestData.DepartmentId, 10, 64)
saveDataCont.DepartmentId = departmentId
dimensionId, _ := strconv.ParseInt(requestData.Dimension, 10, 64)
saveDataCont.Dimension = dimensionId
targetId, _ := strconv.ParseInt(v.Id, 10, 64)
saveDataCont.Target = targetId
saveDataCont.Weight = v.Weight * 100
saveDataCont.Addtime = time.Now().Unix()
saveDataCont.Hierarchy = 2
// addErr := global.GVA_DB_Performanceappraisal.Create(&saveData).Error
saveData = append(saveData, saveDataCont)
}
if len(saveData) > 0 {
addErr := global.GVA_DB_Performanceappraisal.Create(&saveData).Error
if addErr != nil {
response.Result(108, addErr, "数据写入失败", c)
return
}
}
} else {
var depDimIdAry []int64
gromDbDim := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DepartmentDimensionWeight{}).Select("ddw_id").Where("`ddw_hierarchy` = 2 AND `ddw_type` = ? AND `ddw_group` = ? AND `ddw_derpatment` = ? AND `ddw_dimension` = ?", requestData.Type, requestData.Group, requestData.DepartmentId, requestData.Dimension)
gromDbDimErr := gromDbDim.Where("`ddw_target` NOT IN ?", targetIdAry).Find(&depDimIdAry).Error
if gromDbDimErr == nil {
global.GVA_DB_Performanceappraisal.Where("`ddw_id` IN ?", depDimIdAry).Delete(&assessmentmodel.DepartmentDimensionWeight{})
}
var saveData []assessmentmodel.DepartmentDimensionWeight
for _, v := range requestData.TargetList {
var ddwId int64
ddwIdErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DepartmentDimensionWeight{}).Select("ddw_id").Where("`ddw_hierarchy` = 2 AND `ddw_type` = ? AND `ddw_group` = ? AND `ddw_derpatment` = ? AND `ddw_dimension` = ? AND `ddw_target` = ?", requestData.Type, requestData.Group, requestData.DepartmentId, requestData.Dimension, v.Id).First(&ddwId).Error
if ddwIdErr == nil {
saveMap := commonus.MapOut()
saveMap["ddw_weight"] = v.Weight * 100
saveMap["ddw_time"] = time.Now().Unix()
ddwIdEiteErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DepartmentDimensionWeight{}).Where("`ddw_id` = ?", ddwId).Updates(saveMap).Error
if ddwIdEiteErr == nil {
}
} else {
var saveDataCont assessmentmodel.DepartmentDimensionWeight
saveDataCont.Type = requestData.Type
groupId, _ := strconv.ParseInt(requestData.Group, 10, 64)
saveDataCont.Group = groupId
departmentId, _ := strconv.ParseInt(requestData.DepartmentId, 10, 64)
saveDataCont.DepartmentId = departmentId
dimensionId, _ := strconv.ParseInt(requestData.Dimension, 10, 64)
saveDataCont.Dimension = dimensionId
targetId, _ := strconv.ParseInt(v.Id, 10, 64)
saveDataCont.Target = targetId
saveDataCont.Weight = v.Weight * 100
saveDataCont.Addtime = time.Now().Unix()
saveDataCont.Hierarchy = 2
// addErr := global.GVA_DB_Performanceappraisal.Create(&saveData).Error
saveData = append(saveData, saveDataCont)
}
}
if len(saveData) > 0 {
addErr := global.GVA_DB_Performanceappraisal.Create(&saveData).Error
if addErr != nil {
response.Result(108, addErr, "数据写入失败", c)
return
}
}
}
response.Result(0, sumScore, "数据写入成功", c)
}
//批量添加维度权重
func (d *DutyHandle) AddDimWeightBatch(c *gin.Context) {
var requestData addDepartDimenWeightAry
err := c.ShouldBindJSON(&requestData)
if err != nil {
response.Result(101, err, "数据获取失败！", c)
return
}
if requestData.Type == 0 {
response.Result(102, err, "请指定当前添加的是定性考核权重还是定量考核权重！", c)
return
}
if requestData.Group == "" {
response.Result(103, err, "请指定当前为哪个集团添加！", c)
return
}
if requestData.DepartmentId == "" {
response.Result(104, err, "请指定当前为哪个分厂或部室添加！", c)
return
}
var targetIdAry []int64
if len(requestData.Dimension) < 1 {
response.Result(106, err, "请指定当前为哪些维度添加！", c)
return
} else {
var judgeSumScoer int64 = 0
for _, t_v := range requestData.Dimension {
judgeSumScoer = judgeSumScoer + t_v.Weight
tarIdInt, tarIdIntErr := strconv.ParseInt(t_v.Id, 10, 64)
if tarIdIntErr == nil {
targetIdAry = append(targetIdAry, tarIdInt)
}
}
if 10000-judgeSumScoer*100 < 0 {
response.Result(105, judgeSumScoer, "权重综合超过了限定值100！请重新输入", c)
return
}
}
var depDimIdAry []int64
gromDbDim := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DepartmentDimensionWeight{}).Select("ddw_id").Where("`ddw_hierarchy` = 1 AND `ddw_type` = ? AND `ddw_group` = ? AND `ddw_derpatment` = ?", requestData.Type, requestData.Group, requestData.DepartmentId)
gromDbDimErr := gromDbDim.Find(&depDimIdAry).Error
if gromDbDimErr == nil {
global.GVA_DB_Performanceappraisal.Where("`ddw_dimension` IN ?", depDimIdAry).Delete(&assessmentmodel.DepartmentDimensionWeight{})
}
var saveData []assessmentmodel.DepartmentDimensionWeight
for _, v := range requestData.Dimension {
var ddwId int64
ddwIdErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DepartmentDimensionWeight{}).Select("ddw_id").Where("`ddw_hierarchy` = 1 AND `ddw_type` = ? AND `ddw_group` = ? AND `ddw_derpatment` = ? AND `ddw_dimension` = ?", requestData.Type, requestData.Group, requestData.DepartmentId, v.Id).First(&ddwId).Error
if ddwIdErr == nil {
saveMap := commonus.MapOut()
saveMap["ddw_weight"] = v.Weight * 100
saveMap["ddw_time"] = time.Now().Unix()
ddwIdEiteErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DepartmentDimensionWeight{}).Where("`ddw_id` = ?", ddwId).Updates(saveMap).Error
if ddwIdEiteErr == nil {
}
} else {
var saveDataCont assessmentmodel.DepartmentDimensionWeight
saveDataCont.Type = requestData.Type
groupId, _ := strconv.ParseInt(requestData.Group, 10, 64)
saveDataCont.Group = groupId
departmentId, _ := strconv.ParseInt(requestData.DepartmentId, 10, 64)
saveDataCont.DepartmentId = departmentId
dimensionId, _ := strconv.ParseInt(v.Id, 10, 64)
saveDataCont.Dimension = dimensionId
saveDataCont.Target = 0
saveDataCont.Weight = v.Weight * 100
saveDataCont.Addtime = time.Now().Unix()
saveDataCont.Hierarchy = 1
// addErr := global.GVA_DB_Performanceappraisal.Create(&saveData).Error
saveData = append(saveData, saveDataCont)
}
}
if len(saveData) > 0 {
addErr := global.GVA_DB_Performanceappraisal.Create(&saveData).Error
if addErr != nil {
response.Result(108, addErr, "数据写入失败", c)
return
}
}
response.Result(0, depDimIdAry, "数据写入成功", c)
}

269
gin_server_admin/api/v1/assessment/qualitative_target.go
View File

@ -0,0 +1,269 @@
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) AddQualitativeTarget(c *gin.Context) {
var requestData addAttTarget
err := c.ShouldBindJSON(&requestData)
if err != nil {
response.Result(101, requestData, "数据获取失败！", c)
return
}
if requestData.Title == "" {
response.Result(102, err, "请输入定性指标子栏目名称！", c)
return
}
if requestData.ParentId == "" {
response.Result(102, err, "请选择定性指标子栏目归属", c)
return
}
juadgeMap := commonus.MapOut()
juadgeTitleErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeTarget{}).Select("q_title").Where("`q_title` = ? AND `q_parent_id` = ?", requestData.Title, requestData.ParentId).First(&juadgeMap).Error
if juadgeTitleErr == nil {
response.Result(102, err, "此定性指标子栏目已经存在！请不要重复录入！", c)
return
}
var saveData assessmentmodel.QualitativeTarget
saveData.Title = requestData.Title
parentId, parentIdErr := strconv.ParseInt(requestData.ParentId, 10, 64)
if parentIdErr != nil {
response.Result(102, err, "请选择定性指标子栏目归属", c)
return
}
saveData.ParentId = parentId
saveData.State = 1
saveData.AddTime = time.Now().Unix()
dutyInfoErr := global.GVA_DB_Performanceappraisal.Create(&saveData).Error
if dutyInfoErr != nil {
response.Result(106, saveData, "数据写入失败！", c)
} else {
response.Result(0, saveData, "数据写入成功！", c)
}
}
//获取定性指标子栏目列表
func (d *DutyHandle) GetQualitativeTargetList(c *gin.Context) {
var requestData attTargetList
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)
gormDb := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeTarget{})
if requestData.ParentId != "" {
gormDb = gormDb.Where("`q_parent_id` = ?", requestData.ParentId)
}
if requestData.State != 0 {
gormDb = gormDb.Where("`q_state` = ?", requestData.State)
} else {
gormDb = gormDb.Where("`q_state` IN (1,2)")
}
if requestData.Title != "" {
gormDb = gormDb.Where("(`q_title` LIKE ?)", "%"+requestData.Title+"%")
}
var total int64
totalErr := gormDb.Count(&total).Error
if totalErr != nil {
total = 0
}
// response.Result(0, requestData, "查询成功！", c)
var dataList []assessmentmodel.QualitativeTarget
dataListerr := gormDb.Limit(requestData.PageSize).Offset(offSetPage).Find(&dataList).Error
if dataListerr != nil {
response.Result(103, dataList, "数据获取失败！", c)
return
}
var outList []attTargetListOut
for _, val := range dataList {
var outContent attTargetListOut
outContent.Id = val.Id
outContent.Title = val.Title
outContent.ParentId = val.ParentId
outContent.State = val.State
outContent.AddTime = val.AddTime
outContent.OutId = strconv.FormatInt(val.Id, 10)
outContent.ParentIdStr = strconv.FormatInt(val.ParentId, 10)
parentCont, parentIsTrue := commonus.GetTargetInfo(val.ParentId)
if parentIsTrue == true {
outContent.ParentTitle = parentCont.Title
}
outList = append(outList, outContent)
}
countSum := len(outList)
printData := commonus.OutPutList(total, int64(countSum), requestData.Page, requestData.PageSize, outList)
response.Result(0, printData, "查询成功！", c)
}
//编辑指标数据处理
func eiteQualTargetInfoes(saveId int64, saveData map[string]interface{}) (isTrue bool, infoErr error) {
isTrue = false
infoErr = global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeTarget{}).Where("`q_id` = ?", saveId).Updates(saveData).Error
if infoErr != nil {
return
}
isTrue = true
return
}
//获取定性测评指标子栏目详细内容
func (d *DutyHandle) GetQualTargetInfo(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 systemEvalCont attTargetListOut
contErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeTarget{}).Select("q_id", "q_title", "q_parent_id", "q_state", "q_time").Where("`q_id` = ?", requestData.Id).First(&systemEvalCont).Error
if contErr != nil {
response.Result(103, err, "数据获取失败！", c)
return
}
systemEvalCont.ParentIdStr = strconv.FormatInt(systemEvalCont.ParentId, 10)
systemEvalCont.OutId = strconv.FormatInt(systemEvalCont.Id, 10)
parentCont, parentIsTrue := commonus.GetTargetInfo(systemEvalCont.ParentId)
if parentIsTrue == true {
systemEvalCont.ParentTitle = parentCont.Title
}
response.Result(0, systemEvalCont, "数据获取成功！", c)
}
//修改定性指标子栏目
func (d *DutyHandle) EiteQualTargetInfo(c *gin.Context) {
var requestData eiteAttTarget
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 oldTargetCont assessmentmodel.QualitativeTarget
targetInfoErr := global.GVA_DB_Performanceappraisal.Where("`q_id` = ?", requestData.Id).First(&oldTargetCont).Error
if targetInfoErr != nil {
response.Result(102, err, "该指标不存在！请检查您的参数！", c)
return
}
saveData := commonus.MapOut()
if requestData.Title == "" {
response.Result(102, err, "请输入指标名称！", c)
return
} else {
if requestData.Title != oldTargetCont.Title {
if requestData.ParentId != "" {
judgeTargetErr := global.GVA_DB_Performanceappraisal.Where("`q_title` = ? AND `q_parent_id` = ?", requestData.Title, requestData.ParentId).First(&oldTargetCont).Error
if judgeTargetErr == nil {
response.Result(102, err, "该指标子栏目名称已经存在！请不要重复输入！", c)
return
}
} else {
judgeTargetErr := global.GVA_DB_Performanceappraisal.Where("`q_title` = ? AND `q_parent_id` = ?", requestData.Title, oldTargetCont.ParentId).First(&oldTargetCont).Error
if judgeTargetErr == nil {
response.Result(102, err, "该指标子栏目名称已经存在！请不要重复输入！", c)
return
}
}
saveData["q_title"] = requestData.Title
}
}
if requestData.ParentId != "" {
saveData["q_parent_id"] = requestData.ParentId
}
saveData["q_time"] = time.Now().Unix()
roleIsTrue, roleErr := eiteQualTargetInfoes(requestData.Id, saveData)
if roleIsTrue != true {
response.Result(106, roleErr, "编辑失败!", c)
} else {
response.Result(0, saveData, "编辑成功!", c)
}
}
func (d *DutyHandle) DelQualTargetInfo(c *gin.Context) {
var requestData dutyClassState
err := c.ShouldBindJSON(&requestData)
if err != nil {
response.Result(101, requestData, "数据获取失败！", 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["q_state"] = requestData.State
saveData["q_time"] = time.Now().Unix()
if requestData.IsDel != 1 {
roleIsTrue, roleErr := eiteQualTargetInfoes(requestData.Id, saveData)
if roleIsTrue != true {
response.Result(103, roleErr, "修改失败！", c)
return
}
response.Result(0, requestData, "修改成功！", c)
} else {
if requestData.State == 3 {
roleErr := global.GVA_DB_Performanceappraisal.Where("q_id = ?", requestData.Id).Delete(&assessmentmodel.QualitativeTarget{}).Error
if roleErr != nil {
response.Result(104, saveData, "删除失败！", c)
return
}
response.Result(0, saveData, "删除成功！", c)
} else {
roleIsTrue, roleErr := eiteQualTargetInfoes(requestData.Id, saveData)
if roleIsTrue != true {
response.Result(103, roleErr, "修改失败！", c)
return
}
response.Result(0, requestData, "修改成功！", c)
}
}
}

296
gin_server_admin/api/v1/assessment/ration_evaluation.go
View File

@ -0,0 +1,296 @@
package assessment
import (
"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 *DutyHandle) AddRation(c *gin.Context) {
var requestData AddRationCont
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(102, err, "请选择接受考核的部门！", c)
return
}
if requestData.Dimension == "" {
response.Result(102, err, "请选择考核维度", c)
return
}
if len(requestData.RationList) <= 0 {
response.Result(102, err, "请添加测评详情！", c)
return
}
var synergeticProcess dataLockStatistics
for _, deparmentId := range requestData.AcceptDepartmentId {
addDepartDimension(requestData.Group, deparmentId, requestData.Dimension, 2)
syncProcess.Add(1)
go synergeticProcess.addRationContList(deparmentId, requestData)
}
syncProcess.Wait()
returData := commonus.MapOut()
readDataMap, readBaoJinf := synergeticProcess.readMyDayData()
returData["istrue"] = readDataMap
returData["isfalse"] = readBaoJinf
if len(readBaoJinf) > 0 && len(readDataMap) == 0 {
response.Result(112, returData, "有未处理失败的数据！请检查", c)
} else if len(readBaoJinf) > 0 && len(readDataMap) > 0 {
response.Result(1, returData, "有部门数据处理失败！请针对性输入！", c)
} else {
response.Result(0, returData, "数据处理完成！", c)
}
}
//关联集团部门考核维度
func addDepartDimension(groupID, departId, dimensionId string, key int64) {
judgeMap := commonus.MapOut()
judgeErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DepartmentDimension{}).Select("dd_id").Where("`dd_group` = ? AND `dd_department` = ? AND `dd_dimension` = ?", groupID, departId, dimensionId).First(&judgeMap).Error
if judgeErr != nil {
var saveData assessmentmodel.DepartmentDimension
saveData.Key = key
departIdVal, _ := strconv.ParseInt(departId, 10, 64)
saveData.DepartmentId = departIdVal
dimensionIdVal, _ := strconv.ParseInt(dimensionId, 10, 64)
saveData.Dimension = dimensionIdVal
groupIDVal, _ := strconv.ParseInt(groupID, 10, 64)
saveData.Group = groupIDVal
saveData.Addtime = time.Now().Unix()
insetErr := global.GVA_DB_Performanceappraisal.Create(&saveData).Error
if insetErr == nil {
}
}
}
func (d *dataLockStatistics) addRationContList(deparmentId string, addData AddRationCont) {
d.mutext.Lock()
defer d.mutext.Unlock()
var saveDataAry []assessmentmodel.QualitativeEvaluation
for _, v := range addData.RationList {
var saveData assessmentmodel.QualitativeEvaluation
juadgeMap := commonus.MapOut()
juadgeInsetErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Select("qe_id").Where("`qe_accept_evaluation` = ? AND `qe_dimension` = ? AND `qe_target` = ? ", deparmentId, addData.Dimension, v.Target).First(&juadgeMap).Error
if juadgeInsetErr != nil {
groupInt, groupIntErr := strconv.ParseInt(addData.Group, 10, 64)
if groupIntErr == nil {
saveData.Group = groupInt
}
saveData.Type = addData.Type
departidInt, departinIntErr := strconv.ParseInt(v.DepartmentId, 10, 64)
if departinIntErr == nil {
saveData.DepartmentId = departidInt
}
dimensionInt, departinIntErr := strconv.ParseInt(addData.Dimension, 10, 64)
if departinIntErr == nil {
saveData.Dimension = dimensionInt
}
targetInt, targetIntErr := strconv.ParseInt(v.Target, 10, 64)
if targetIntErr == nil {
saveData.Target = targetInt
}
saveData.Unit = v.Unit
saveData.ReferenceScore = v.ReferenceScore
saveData.Cycles = v.Cycles
saveData.CycleAttres = v.CycleAttres
saveData.State = 1
saveData.Addtime = time.Now().Unix()
saveData.Eitetime = time.Now().Unix()
departmentIdInt, departmentIdIntErr := strconv.ParseInt(deparmentId, 10, 64)
if departmentIdIntErr == nil {
saveData.AcceptEvaluation = departmentIdInt
}
// operatorInt, operatorIntErr := strconv.ParseInt(v.Operator, 10, 64)
// if operatorIntErr == nil {
// saveData.Operator = operatorInt
// }
saveData.Operator = strings.Join(v.Operator, ",")
saveDataAry = append(saveDataAry, saveData)
msg := commonus.MapOut()
msg["msg"] = saveData
d.dataMap = append(d.dataMap, msg)
} else {
detailedTargetInts, _ := strconv.ParseInt(v.Target, 10, 64)
dtCont, dtIsTrue := commonus.GetTargetInfo(detailedTargetInts)
groupInt, _ := strconv.ParseInt(addData.Group, 10, 64)
departidInt, _ := strconv.ParseInt(deparmentId, 10, 64)
_, groupCont := commonus.GetGroupCont(groupInt)
_, deparConCont := commonus.GetBranchFactory(departidInt)
msg := commonus.MapOut()
if dtIsTrue == true {
msg["msg"] = fmt.Sprintf("%v-%v定量考核《%v》考核项目已经存在！请重新处理此方案！->ID:%v", groupCont.Name, deparConCont.Name, dtCont.Title, detailedTargetInts)
} else {
msg["msg"] = fmt.Sprintf("%v-%v定量考核《%v》考核项目已经存在！请重新处理此方案！", groupCont.Name, deparConCont.Name, detailedTargetInts)
}
d.dataErrMap = append(d.dataErrMap, msg)
}
}
if len(saveDataAry) > 0 {
addErr := global.GVA_DB_Performanceappraisal.Create(&saveDataAry).Error
if addErr != nil {
msg := commonus.MapOut()
msg["data"] = saveDataAry
msg["msg"] = fmt.Sprintf("《%v》考核维度录入失败！请重新处理此方案", addData.Dimension)
d.dataErrMap = append(d.dataErrMap, msg)
}
}
syncProcess.Done()
}
//定量考核方案列表
func (d *DutyHandle) RationList(c *gin.Context) {
var requestData rationSelect
c.ShouldBindJSON(&requestData)
//归档集团
gormDb := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Select("qe_group").Where("qe_type = 2").Group("qe_group")
if requestData.Group != "" {
gormDb = gormDb.Having("qe_group = ?", requestData.Group)
}
var fileAry []int64
listErr := gormDb.Find(&fileAry).Error
if listErr != nil {
response.Result(101, listErr, "没有数据！", c)
return
}
if len(fileAry) < 1 {
response.Result(102, listErr, "没有数据！", c)
return
}
var aualEvalArrtAry []QualEvalRationListOut
for _, v := range fileAry {
var aualEvalArrtCont QualEvalRationListOut
groupErr, groupCont := commonus.GetGroupCont(v)
if groupErr == true {
aualEvalArrtCont.Id = strconv.FormatInt(v, 10)
aualEvalArrtCont.Name = groupCont.Name
// 归档分厂-部室
departAry, departAryErr := deparmentRationList(v, requestData.DepartmentId)
if departAryErr == true {
//分厂部室列表
aualEvalArrtCont.Child = departAry
}
//组合集团
aualEvalArrtAry = append(aualEvalArrtAry, aualEvalArrtCont)
}
}
response.Result(0, aualEvalArrtAry, "查询完成！", c)
}
//归档部门
func deparmentRationList(groupID int64, departmentIDStr string) (contentList []QualEvalRationListOutDepart, isTrue bool) {
isTrue = false
gormDbDepart := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Select("qe_accept_evaluation").Where("qe_type = 2 AND `qe_group` = ?", groupID).Group("qe_accept_evaluation")
if departmentIDStr != "" {
gormDbDepart = gormDbDepart.Having("qe_accept_evaluation = ?", departmentIDStr)
}
var fileDepartAry []int64
listDepartErr := gormDbDepart.Find(&fileDepartAry).Error
if listDepartErr == nil {
for _, v := range fileDepartAry {
deparConErr, deparConCont := commonus.GetBranchFactory(v)
var deparCont QualEvalRationListOutDepart
if deparConErr == true {
deparCont.Id = strconv.FormatInt(v, 10)
deparCont.Name = deparConCont.Name
//归档维度
dimensionAry, dimensionAryErr := dimensionRationList(groupID, v)
if dimensionAryErr == true {
//维度列表
deparCont.Child = dimensionAry
}
}
//组合分厂部室
contentList = append(contentList, deparCont)
}
}
if len(contentList) > 0 {
isTrue = true
}
return
}
//归档维度
func dimensionRationList(groupID, departmentID int64) (contentList []DimensionRationList, isTrue bool) {
isTrue = false
var fileDimensionAry []int64
listDimensionErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Select("qe_dimension").Where("qe_type = 2 AND `qe_group` = ? AND `qe_accept_evaluation` = ?", groupID, departmentID).Group("qe_dimension").Find(&fileDimensionAry).Error
if listDimensionErr == nil {
for _, v := range fileDimensionAry {
dutyClassCont, dutyClassErr := commonus.GetDutyClassInfo(v)
var dimenCont DimensionRationList
if dutyClassErr == true {
dimenCont.Id = strconv.FormatInt(v, 10)
dimenCont.Name = dutyClassCont.Title
//归档指标
targerAry, targerAryErr := targetRationList(groupID, departmentID, v)
if targerAryErr == true {
//定性考核指标列表
dimenCont.Child = targerAry
}
//组合维度
contentList = append(contentList, dimenCont)
}
}
}
if len(contentList) > 0 {
isTrue = true
}
return
}
//查询归档定性指标
func targetRationList(groupID, departmentID, dimension int64) (contentList []taskDetails, isTrue bool) {
isTrue = false
var fileTargetAry []assessmentmodel.QualitativeEvaluation
listTargetErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.QualitativeEvaluation{}).Where("qe_type = 2 AND `qe_group` = ? AND `qe_accept_evaluation` = ? AND `qe_dimension` = ?", groupID, departmentID, dimension).Find(&fileTargetAry).Error
if listTargetErr != nil {
return
}
for _, v := range fileTargetAry {
var content taskDetails
targetInfo, targetErr := commonus.GetTargetInfo(v.Target)
if targetErr == true {
content.Id = strconv.FormatInt(v.Target, 10)
content.Name = targetInfo.Title
content.Unit = v.Unit
content.ReferenceScore = v.ReferenceScore
content.Cycles = v.Cycles
content.CycleAttres = v.CycleAttres
content.State = v.State
contentList = append(contentList, content)
}
}
if len(contentList) > 0 {
isTrue = true
}
return
}

492
gin_server_admin/api/v1/assessment/target.go
View File

@ -0,0 +1,492 @@
package assessment
import (
"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/flipped-aurora/gin-vue-admin/server/model/testpage"
"github.com/gin-gonic/gin"
)
//获取指标列表
func (d *DutyHandle) GetTargetList(c *gin.Context) {
var requestData listTarget
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)
gormDb := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.EvaluationTarget{})
if requestData.State == 0 {
gormDb = gormDb.Where("`et_state` IN (1,2)")
} else {
gormDb = gormDb.Where("`et_state` = ?", requestData.State)
}
if requestData.Type != 0 {
gormDb = gormDb.Where("`et_type` = ?", requestData.Type)
}
if requestData.Share != 0 {
gormDb = gormDb.Where("`et_share` = ?", requestData.Share)
}
if requestData.Title != "" {
gormDb = gormDb.Where("(`et_title` LIKE ?)", "%"+requestData.Title+"%")
}
if len(requestData.RelevantDepartments) > 0 {
var sqlOrStr string = ""
for s_i, s_v := range requestData.RelevantDepartments {
if s_i == 0 {
sqlOrStr = fmt.Sprintf("FIND_IN_SET(%v,`et_relevant_departments`)", s_v)
} else {
sqlOrStr = fmt.Sprintf("%v OR FIND_IN_SET(%v,`et_relevant_departments`)", sqlOrStr, s_v)
}
}
gormDb = gormDb.Where(sqlOrStr)
}
if len(requestData.VisibleRangeGroup) > 0 {
var sqlOrStrGroup string = ""
for s_i, s_v := range requestData.VisibleRangeGroup {
if s_i == 0 {
sqlOrStrGroup = fmt.Sprintf("FIND_IN_SET(%v,`et_visible_range`)", s_v)
} else {
sqlOrStrGroup = fmt.Sprintf("%v OR FIND_IN_SET(%v,`et_visible_range`)", sqlOrStrGroup, s_v)
}
}
gormDb = gormDb.Where(sqlOrStrGroup)
}
if len(requestData.VisibleRangeDepart) > 0 {
var sqlOrStrDepart string = ""
for s_i, s_v := range requestData.VisibleRangeDepart {
if s_i == 0 {
sqlOrStrDepart = fmt.Sprintf("FIND_IN_SET(%v,`et_visible_range`)", s_v)
} else {
sqlOrStrDepart = fmt.Sprintf("%v OR FIND_IN_SET(%v,`et_visible_range`)", sqlOrStrDepart, s_v)
}
}
gormDb = gormDb.Where(sqlOrStrDepart)
}
var total int64
totalErr := gormDb.Count(&total).Error
if totalErr != nil {
total = 0
}
// response.Result(0, requestData, "查询成功！", c)
var dataList []assessmentmodel.EvaluationTarget
dataListerr := gormDb.Limit(requestData.PageSize).Offset(offSetPage).Find(&dataList).Error
if dataListerr != nil {
response.Result(103, dataList, "数据获取失败！", c)
return
}
var outMap []outTargetList
for _, tg_val := range dataList {
var outMapCont outTargetList
outMapCont.Id = tg_val.Id
outMapCont.OutId = strconv.FormatInt(tg_val.Id, 10)
outMapCont.Title = tg_val.Title
outMapCont.Type = tg_val.Type
outMapCont.State = tg_val.State
outMapCont.AddTime = tg_val.AddTime
outMapCont.Share = tg_val.Share
outMapCont.RelevantDepartments = tg_val.RelevantDepartments
if tg_val.RelevantDepartments != "" {
departIdAry := strings.Split(tg_val.RelevantDepartments, ",")
for _, dia_val := range departIdAry {
diaInt, diaIntErr := strconv.ParseInt(dia_val, 10, 64)
if diaIntErr == nil {
diaValErr, diaVal := GetBranchFactory(diaInt)
if diaValErr == true {
var bfCont outTargetAttr
bfCont.Key = dia_val
bfCont.Title = diaVal.Name
outMapCont.RelevantDepartmentMap = append(outMapCont.RelevantDepartmentMap, bfCont)
}
}
}
}
outMapCont.Dimension = tg_val.Dimension
outMapCont.Key = tg_val.Key
outMapCont.Report = tg_val.Report
if tg_val.Report != "" {
userIdAry := strings.Split(tg_val.Report, ",")
for _, u_val := range userIdAry {
uidInt, uidIntErr := strconv.ParseInt(u_val, 10, 64)
if uidIntErr == nil {
whe := commonus.MapOut()
whe["wm_key"] = uidInt
uidVal, uidValErr := commonus.GetUserInfoPublic("worker_man.*,worker_man_data.*", whe)
if uidValErr == true {
var bfContUser outTargetAttr
bfContUser.Key = u_val
bfContUser.Title = uidVal.Name
outMapCont.ReportMap = append(outMapCont.ReportMap, bfContUser)
}
}
}
}
outMapCont.Uniteing = tg_val.Uniteing
outMapCont.Cycles = tg_val.Cycles
outMapCont.CycleAttres = tg_val.CycleAttres
outMapCont.VisibleRange = tg_val.VisibleRange
if tg_val.VisibleRange != "" {
rangeIdAry := strings.Split(tg_val.VisibleRange, ",")
for _, rge_val := range rangeIdAry {
rgeInt, rgeIntErr := strconv.ParseInt(rge_val, 10, 64)
if rgeIntErr == nil {
rgeValErr, rgeVal := GetBranchFactory(rgeInt)
if rgeValErr == true {
var bfContRge outTargetAttr
bfContRge.Key = rge_val
bfContRge.Title = rgeVal.Name
outMapCont.VisibleRangeDepartMap = append(outMapCont.VisibleRangeDepartMap, bfContRge)
}
}
}
}
outMapCont.VisibleRangeGroup = tg_val.VisibleRangeGroup
if tg_val.VisibleRangeGroup != "" {
rangeGroupIdAry := strings.Split(tg_val.VisibleRangeGroup, ",")
for _, rgeup_val := range rangeGroupIdAry {
rgeIntGup, rgeIntGupErr := strconv.ParseInt(rgeup_val, 10, 64)
if rgeIntGupErr == nil {
rgeValGupErr, rgeValGup := GetGroupCont(rgeIntGup)
if rgeValGupErr == true {
var bfContRge outTargetAttr
bfContRge.Key = rgeup_val
bfContRge.Title = rgeValGup.Name
outMapCont.VisibleRangeGroupMap = append(outMapCont.VisibleRangeGroupMap, bfContRge)
}
}
}
}
outMap = append(outMap, outMapCont)
}
countSum := len(outMap)
printData := commonus.OutPutList(total, int64(countSum), requestData.Page, requestData.PageSize, outMap)
response.Result(0, printData, "查询成功！", c)
}
//添加指标
func (d *DutyHandle) AddTarget(c *gin.Context) {
var requestData addTargetType
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.Share == 0 {
requestData.Share = 1
} else {
if requestData.Share > 1 {
if len(requestData.RelevantDepartments) == 0 {
response.Result(103, err, "您选择了此指标为指定部门使用！但您未指定具体使用部门！请指定相关使用部门！", c)
return
}
}
}
if requestData.Uniteing == "" {
response.Result(104, err, "请输入计量单位！", c)
return
}
if requestData.Cycles == 0 {
requestData.Cycles = 4
}
if requestData.CycleAttres == 0 {
requestData.CycleAttres = 1
}
gormDb := global.GVA_DB_Performanceappraisal
gormDb = gormDb.Model(&assessmentmodel.EvaluationTarget{}).Select("et_title").Where("`et_title` = ? AND `et_type` = ?", requestData.Title, requestData.Type)
dimensionId, dimensionErr := strconv.ParseInt(requestData.Dimension, 10, 64)
if dimensionErr == nil && dimensionId != 0 {
gormDb = gormDb.Where("`et_dimension` = ?", requestData.Dimension)
}
judgeOut := commonus.MapOut()
judgeErr := gormDb.First(&judgeOut)
if judgeErr == nil {
response.Result(105, err, "此考核指标已经存在！请不要重复添加！", c)
return
}
var saveData assessmentmodel.EvaluationTarget
saveData.Title = requestData.Title
saveData.Type = requestData.Type
saveData.State = 1
saveData.AddTime = time.Now().Unix()
saveData.Share = requestData.Share
if len(requestData.RelevantDepartments) > 0 {
saveData.RelevantDepartments = strings.Join(requestData.RelevantDepartments, ",")
}
if dimensionErr == nil {
saveData.Dimension = dimensionId
}
saveData.Key = commonus.GetFileNumberEs()
if len(requestData.Report) > 0 {
saveData.Report = strings.Join(requestData.Report, ",")
}
saveData.Uniteing = requestData.Uniteing
saveData.Cycles = requestData.Cycles
saveData.CycleAttres = requestData.CycleAttres
if len(requestData.VisibleRangeGroup) > 0 {
saveData.VisibleRangeGroup = strings.Join(requestData.VisibleRangeGroup, ",")
}
if len(requestData.VisibleRangeDepart) > 0 {
saveData.VisibleRange = strings.Join(requestData.VisibleRangeDepart, ",")
}
dutyInfoErr := global.GVA_DB_Performanceappraisal.Create(&saveData).Error
if dutyInfoErr != nil {
response.Result(106, saveData, "数据写入失败！", c)
} else {
response.Result(0, saveData, "数据写入成功！", c)
}
}
//计算可见范围
func calculVisibleRange(groupStr, depart []string) (visibleRange string) {
if len(depart) > 0 {
for d_index, d_val := range depart {
if d_index == 0 {
visibleRange = d_val
} else {
visibleRange = visibleRange + "," + d_val
}
}
return
} else {
if len(groupStr) > 0 {
for g_index, g_val := range groupStr {
if g_index == 0 {
visibleRange = getBranchFactoryList(g_val)
} else {
visibleRange = visibleRange + "," + getBranchFactoryList(g_val)
}
}
return
}
}
return
}
//获得分厂列表
func getBranchFactoryList(id string) (bfIdStr string) {
var ContInfo []testpage.BranchFactory
err := global.GVA_DB_Master.Select("bf_id").Where("bf_group = ? AND `bf_set` = 1", id).Find(&ContInfo).Error
if err != nil {
return
}
for b_index, b_val := range ContInfo {
if b_index == 0 {
bfIdStr = strconv.FormatInt(b_val.Id, 10)
} else {
bfIdStr = bfIdStr + "," + strconv.FormatInt(b_val.Id, 10)
}
}
return
}
//获取考核指标详情
func (d *DutyHandle) GetTarget(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 systemEvalCont outTargetInfo
contErr := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.EvaluationTarget{}).Where("`et_id` = ?", requestData.Id).First(&systemEvalCont).Error
if contErr != nil {
response.Result(103, err, "数据获取失败！", c)
return
}
if systemEvalCont.RelevantDepartments != "" {
systemEvalCont.RelevantDepartmentMap = strings.Split(systemEvalCont.RelevantDepartments, ",")
}
if systemEvalCont.Report != "" {
systemEvalCont.ReportMap = strings.Split(systemEvalCont.Report, ",")
}
if systemEvalCont.VisibleRangeGroup != "" {
systemEvalCont.VisibleRangeGroupMap = strings.Split(systemEvalCont.VisibleRangeGroup, ",")
}
if systemEvalCont.VisibleRange != "" {
systemEvalCont.VisibleRangeDepartMap = strings.Split(systemEvalCont.VisibleRange, ",")
}
response.Result(0, systemEvalCont, "数据获取成功！", c)
}
//编辑指标数据处理
func eiteTargetInfoes(saveId int64, saveData map[string]interface{}) (isTrue bool, infoErr error) {
isTrue = false
infoErr = global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.EvaluationTarget{}).Where("`et_id` = ?", saveId).Updates(saveData).Error
if infoErr != nil {
return
}
isTrue = true
return
}
//删除工段内容
func (d *DutyHandle) DelTarget(c *gin.Context) {
var requestData dutyClassState
err := c.ShouldBindJSON(&requestData)
if err != nil {
response.Result(101, requestData, "数据获取失败！", 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["et_state"] = requestData.State
saveData["et_time"] = time.Now().Unix()
if requestData.IsDel != 1 {
roleIsTrue, roleErr := eiteTargetInfoes(requestData.Id, saveData)
if roleIsTrue != true {
response.Result(103, roleErr, "修改失败！", c)
return
}
response.Result(0, requestData, "修改成功！", c)
} else {
if requestData.State == 3 {
roleErr := global.GVA_DB_Performanceappraisal.Where("et_id = ?", requestData.Id).Delete(&assessmentmodel.EvaluationTarget{}).Error
if roleErr != nil {
response.Result(104, saveData, "删除失败！", c)
return
}
response.Result(0, saveData, "删除成功！", c)
} else {
roleIsTrue, roleErr := eiteTargetInfoes(requestData.Id, saveData)
if roleIsTrue != true {
response.Result(103, roleErr, "修改失败！", c)
return
}
response.Result(0, requestData, "修改成功！", c)
}
}
}
//修改指标内容
func (d *DutyHandle) EiteTarget(c *gin.Context) {
var requestData eiteTargetTypeCont
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
}
}
saveData := commonus.MapOut()
var oldTargetCont assessmentmodel.EvaluationTarget
targetInfoErr := global.GVA_DB_Performanceappraisal.Where("`et_id` = ?", requestData.Id).First(&oldTargetCont).Error
if targetInfoErr != nil {
response.Result(102, err, "该指标不存在！请检查您的参数！", c)
return
}
if requestData.Title == "" {
response.Result(102, err, "请输入指标名称！", c)
return
} else {
if requestData.Title != oldTargetCont.Title {
judgeTargetErr := global.GVA_DB_Performanceappraisal.Where("`et_title` = ? AND `et_type` = ?", requestData.Title, oldTargetCont.Type).First(&oldTargetCont).Error
if judgeTargetErr == nil {
response.Result(102, err, "该指标名称已经存在！请不要重复输入！", c)
return
}
}
saveData["et_title"] = requestData.Title
}
if requestData.Type != 0 {
saveData["et_type"] = requestData.Type
}
if requestData.Share != 0 {
saveData["et_share"] = requestData.Share
if requestData.Share > 1 {
if len(requestData.RelevantDepartments) == 0 {
response.Result(103, err, "您选择了此指标为指定部门使用！但您未指定具体使用部门！请指定相关使用部门！", c)
return
}
saveData["et_relevant_departments"] = strings.Join(requestData.RelevantDepartments, ",")
}
}
if requestData.Dimension != "" {
saveData["et_dimension"] = requestData.Dimension
}
if len(requestData.Report) > 0 {
saveData["et_report"] = strings.Join(requestData.Report, ",")
}
if requestData.Uniteing != "" {
saveData["et_unit"] = requestData.Uniteing
}
if requestData.Cycles != 0 {
saveData["et_cycle"] = requestData.Cycles
}
if requestData.CycleAttres != 0 {
saveData["et_cycleattr"] = requestData.CycleAttres
}
if len(requestData.VisibleRangeGroup) > 0 {
saveData["et_visible_group"] = strings.Join(requestData.VisibleRangeGroup, ",")
}
if len(requestData.VisibleRangeDepart) > 0 {
saveData["et_visible_range"] = strings.Join(requestData.VisibleRangeDepart, ",")
}
saveData["et_time"] = time.Now().Unix()
roleIsTrue, roleErr := eiteTargetInfoes(requestData.Id, saveData)
if roleIsTrue != true {
response.Result(106, roleErr, "编辑失败!", c)
} else {
response.Result(0, saveData, "编辑成功!", c)
}
}

31
gin_server_admin/api/v1/examtestpage/grouphandle.go
View File

@ -1028,3 +1028,34 @@ func GetBranchFactoryUser(printId int64) (isTrue bool, departMap []groupUser) {
isTrue = true
return
}
type departSelect struct {
Id string `json:"id"`
}
//获取分厂列表
func (g *GroupHandleApi) GetDepartmentList(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 bfList []testpage.BranchFactory
errData := global.GVA_DB_Master.Where("bf_group = ? AND bf_set = 1", requestData.Id).Find(&bfList).Error
if errData != nil {
response.Result(101, errData, "数据获取失败！", c)
return
}
response.Result(0, bfList, "数据获取成功！", c)
}

62
gin_server_admin/commonus/publichaneld.go
View File

@ -960,3 +960,65 @@ func GetGroupCont(id int64) (isTrue bool, ContInfo wechat.GroupForm) {
}
return
}
//获取考核细则相关内容
func GetDutyCont(field, whereData interface{}) (isTrue bool, outData map[string]interface{}) {
isTrue = false
errAss := global.GVA_DB_Performanceappraisal.Model(&assessmentmodel.DutyContent{}).Select(field).Where(whereData).First(&outData).Error
if errAss != nil {
return
}
isTrue = true
return
}
//获取人员信息
func GetUserInfoPublic(field interface{}, whereMap map[string]interface{}) (userCont testpage.PersonalDetails, isTrue bool) {
isTrue = false
var userInfo testpage.WorkMan
userErr := global.GVA_DB_Master.Model(&userInfo).Select(field).Joins("left join worker_man_data on worker_man_data.wmd_key = worker_man.wm_key").Where(whereMap).Find(&userCont).Error
if userErr == nil {
isTrue = true
}
return
}
//获取考核指标信息
func GetTargetInfo(id int64) (content assessmentmodel.EvaluationTarget, isTrue bool) {
isTrue = false
err := global.GVA_DB_Performanceappraisal.Where("et_id = ?", id).First(&content).Error
if err == nil {
isTrue = true
}
return
}
//获取考核指标信息
func GetQualitativeTargetInfo(id int64) (content assessmentmodel.QualitativeTarget, isTrue bool) {
isTrue = false
err := global.GVA_DB_Performanceappraisal.Where("q_id = ?", id).First(&content).Error
if err == nil {
isTrue = true
}
return
}
//获取考核指标细则
func GetDetailedTargetInfo(id int64) (content assessmentmodel.DetailedTarget, isTrue bool) {
isTrue = false
err := global.GVA_DB_Performanceappraisal.Where("dt_id = ?", id).First(&content).Error
if err == nil {
isTrue = true
}
return
}
//获取考核类别
func GetDutyClassInfo(id int64) (content assessmentmodel.DutyClass, isTrue bool) {
isTrue = false
err := global.GVA_DB_Performanceappraisal.Where("id = ?", id).First(&content).Error
if err == nil {
isTrue = true
}
return
}

1
gin_server_admin/initialize/router.go
View File

@ -106,6 +106,7 @@ func Routers() *gin.Engine {
dutyAssEss.InitAssessmentRouter(PublicGroup) //数据考核
dutyAssEss.NoInitDutyHandelRouter(PublicGroup) //数据考核无需验证
dutyAssEss.InitEvaluationSchemeRouter(PublicGroup) //考核方案
staffMan.InitStaffRouter(PublicGroup) //员工相关操作

159
gin_server_admin/model/assessmentmodel/dutyclass.go
View File

@ -4,7 +4,7 @@ package assessmentmodel
type DutyClass struct {
Id int64 `json:"id" gorm:"column:id;type:bigint(20) unsigned;not null;comment:Id"`
Title string `json:"title" gorm:"column:title;type:varchar(255);comment:职责类别名称"`
Type int `json:"type" gorm:"column:type;type:tinyint(1) unsigned;default:1;not null;comment:类型（1：职能部门；2：生产部门）"`
Type int `json:"type" gorm:"column:type;type:tinyint(1) unsigned;default:1;not null;comment:类型（1：定性考核；2：定量考核）"`
Weight int `json:"weight" gorm:"column:weight;type:int(3) unsigned;default:0;not null;comment:权重比例"`
Time int64 `json:"time" gorm:"column:time;type:bigint(20) unsigned;default:0;not null;comment:创建时间"`
State int `json:"state" gorm:"column:state;type:tinyint(1) unsigned;default:1;not null;comment:状态"`
@ -32,7 +32,7 @@ func (DepartDuty *DepartDuty) TableName() string {
return "departduty"
}
//职责详情
//考核细则
type DutyContent struct {
Id int64 `json:"id" gorm:"column:dc_id;type:bigint(20) unsigned;not null;comment:Id"`
Title string `json:"title" gorm:"column:dc_title;type:text;comment:具体职责"`
@ -42,6 +42,11 @@ type DutyContent struct {
UserType int `json:"userType" gorm:"column:dc_user_type;type:tinyint(1) unsigned;default:1;not null;comment:考核部门类型（1：指定人;2:指定部门）"`
UserDump int64 `json:"userDump" gorm:"column:dc_user_dump;type:bigint(20) unsigned;default:0;not null;comment:考核人执行人"`
Dump int64 `json:"dump" gorm:"column:dc_dump;type:bigint(20) unsigned;default:0;not null;comment:考核执行部门"`
Types int `json:"type" gorm:"column:dc_type;type:tinyint(1) unsigned;default:1;not null;comment:1：定量考核；2：定性考核"`
Uniteing string `json:"unites" gorm:"column:dc_unit;type:varchar(255);comment:计量单位"`
Cycles int `json:"cycle" gorm:"column:dc_cycle;type:tinyint(1) unsigned;default:1;not null;comment:1：班；2：天；3：周；4：月；5：季度；6：年"`
CycleAttres int `json:"cycleattr" gorm:"column:dc_cycleattr;type:int(9) unsigned;default:1;not null;comment:辅助计数"`
Contentes string `json:"content" gorm:"column:dc_cont;type:mediumtext;comment:考核细则说明"`
}
func (DutyContent *DutyContent) TableName() string {
@ -58,6 +63,10 @@ type AssessMentitems struct {
PartId int64 `json:"partId" gorm:"column:ai_parent;type:bigint(20) unsigned;default:0;not null;comment:父级"`
Time int64 `json:"time" gorm:"column:ai_time;type:bigint(20) unsigned;default:0;not null;comment:创建时间"`
State int `json:"state" gorm:"column:ai_state;type:tinyint(1) unsigned;default:1;not null;comment:状态（1：启用；2：禁用；3：删除）"`
Type int `json:"type" gorm:"column:ai_type;type:tinyint(1) unsigned;default:1;not null;comment:1：定量考核；2：定性考核"`
Unites string `json:"unites" gorm:"column:ai_unit;type:varchar(255);comment:计量单位"`
Cycle int `json:"cycle" gorm:"column:ai_cycle;type:tinyint(1) unsigned;default:1;not null;comment:1：天；2：周；3：月；4：季度；5：年"`
CycleAttr int `json:"cycleattr" gorm:"column:ai_cycle_attr;type:int(9) unsigned;default:1;not null;comment:辅助计数"`
}
func (AssessMentitems *AssessMentitems) TableName() string {
@ -139,3 +148,149 @@ type AssessmentLog struct {
func (AssessmentLog *AssessmentLog) TableName() string {
return "assessment_log"
}
//考核方案
type EvaluationScheme struct {
Id int64 `json:"id" gorm:"column:es_id;type:bigint(20) unsigned;not null;comment:Id"`
Title string `json:"title" gorm:"column:es_title;type:varchar(255);comment:方案名称"`
Group int64 `json:"group" gorm:"column:es_group;type:bigint(10) unsigned;default:1;not null;comment:归属集团"`
EvaluationDepartment int64 `json:"evaluationdepartment" gorm:"column:es_evaluation_department;type:bigint(20);not null;comment:被考核部门"`
Dimension int64 `json:"dimension" gorm:"column:es_dimension;type:bigint(20) unsigned;default:0;not null;comment:考核维度"`
Project int64 `json:"project" gorm:"column:es_project;type:bigint(20) unsigned;default:0;not null;comment:考核项目"`
Weight int `json:"weight" gorm:"column:es_weight;type:int(5) unsigned;default:0;not null;comment:权重"`
ExecutiveDepartment int64 `json:"executivedepartment" gorm:"column:es_executive_department;type:bigint(20) unsigned;default:0;not null;comment:执行部门"`
Content string `json:"content" gorm:"column:es_content;type:longtext;not null;comment:方案内容"`
AddTime int64 `json:"addTime" gorm:"column:es_time;type:bigint(20) unsigned;default:0;not null;comment:方案制定时间"`
EiteTime int64 `json:"eiteTime" gorm:"column:es_eite_time;type:bigint(20) unsigned;default:0;not null;comment:方案修改时间"`
Maker int64 `json:"maker" gorm:"column:es_maker;type:bigint(20) unsigned;default:0;not null;comment:制定人"`
}
func (EvaluationScheme *EvaluationScheme) TableName() string {
return "evaluationscheme"
}
//测评指标
type EvaluationTarget struct {
Id int64 `json:"id" gorm:"column:et_id;type:bigint(20) unsigned;not null;comment:Id;index"`
Title string `json:"title" gorm:"column:et_title;type:varchar(255);comment:指标名称"`
Type int `json:"type" gorm:"column:et_type;type:int(1) unsigned;default:1;not null;comment:1：定性考核；2：定量考核"`
State int `json:"state" gorm:"column:et_state;type:int(1) unsigned;default:1;not null;comment:状态（1：启用；2：禁用；3：删除）"`
AddTime int64 `json:"addTime" gorm:"column:et_time;type:bigint(20) unsigned;default:0;not null;comment:制定时间"`
Share int `json:"share" gorm:"column:et_share;type:int(1) unsigned;default:1;not null;comment:1：共用；2：私用"`
RelevantDepartments string `json:"relevantdepartments" gorm:"column:et_relevant_departments;type:text;comment:相关部门"`
Dimension int64 `json:"dimension" gorm:"column:et_dimension;type:bigint(20) unsigned;default:0;not null;comment:维度"`
Key int64 `json:"key" gorm:"column:et_key;type:bigint(20) unsigned;default:0;not null;comment:UUID"`
Report string `json:"report" gorm:"column:et_report;type:text;comment:上报人"`
Uniteing string `json:"unites" gorm:"column:et_unit;type:varchar(255);comment:计量单位"`
Cycles int `json:"cycle" gorm:"column:et_cycle;type:tinyint(1) unsigned;default:1;not null;comment:1：班；2：天；3：周；4：月；5：季度；6：年"`
CycleAttres int `json:"cycleattr" gorm:"column:et_cycleattr;type:int(9) unsigned;default:1;not null;comment:辅助计数"`
VisibleRange string `json:"visiblerange" gorm:"column:et_visible_range;type:text;comment:可见范围"`
VisibleRangeGroup string `json:"visiblerangegroup" gorm:"column:et_visible_group;type:text;comment:可见范围(集团)"`
}
func (EvaluationTarget *EvaluationTarget) TableName() string {
return "evaluationtarget"
}
//定性测评指标子栏目
type QualitativeTarget struct {
Id int64 `json:"id" gorm:"column:q_id;type:bigint(20) unsigned;not null;comment:Id;index"`
Title string `json:"title" gorm:"column:q_title;type:varchar(255);comment:指标子栏目名称"`
ParentId int64 `json:"parentid" gorm:"column:q_parent_id;type:bigint(20) unsigned;default:0;not null;comment:归属指标"`
State int `json:"state" gorm:"column:q_state;type:int(1) unsigned;default:1;not null;comment:状态（1：启用；2：禁用；3：删除）"`
AddTime int64 `json:"addTime" gorm:"column:q_time;type:bigint(20) unsigned;default:0;not null;comment:制定时间"`
}
func (QualitativeTarget *QualitativeTarget) TableName() string {
return "qualitative_target"
}
//指标细则
type DetailedTarget struct {
Id int64 `json:"id" gorm:"column:dt_id;type:bigint(20) unsigned;not null;comment:Id;index"`
Title string `json:"title" gorm:"column:dt_title;type:text;comment:指标细则"`
Content string `json:"content" gorm:"column:dt_content;type:text;comment:指标说明"`
ParentId int64 `json:"parentid" gorm:"column:dt_parentid;type:bigint(20) unsigned;default:0;not null;comment:归属指标栏目"`
ParentIdSun int64 `json:"parentidsun" gorm:"column:dt_parentid_sun;type:bigint(20) unsigned;default:0;not null;comment:归属指标子栏目"`
State int `json:"state" gorm:"column:dt_state;type:int(1) unsigned;default:1;not null;comment:状态（1：启用；2：禁用；3：删除）"`
AddTime int64 `json:"addtime" gorm:"column:dt_time;type:bigint(20) unsigned;default:0;not null;comment:制定时间"`
}
func (DetailedTarget *DetailedTarget) TableName() string {
return "detailed_target"
}
//性质考核方案
type QualitativeEvaluationScheme struct {
Id int64 `json:"id" gorm:"column:qes_id;type:bigint(20) unsigned;not null;comment:Id;index"`
Title string `json:"title" gorm:"column:qes_title;type:text;comment:方案名称"`
Key int64 `json:"key" gorm:"column:qes_key;type:bigint(20) unsigned;default:0;not null;comment:key"`
DepartmentId int64 `json:"parentid" gorm:"column:qes_department_id;type:bigint(20) unsigned;default:0;not null;comment:归属部门"`
Group int64 `json:"group" gorm:"column:qes_group;type:bigint(20) unsigned;default:0;not null;comment:归属集团"`
Addtime int64 `json:"addtime" gorm:"column:qes_addtime;type:bigint(20) unsigned;default:0;not null;comment:添加时间"`
Eitetime int64 `json:"eitetime" gorm:"column:qes_eitetime;type:bigint(20) unsigned;default:0;not null;comment:编辑时间"`
}
func (QualitativeEvaluationScheme *QualitativeEvaluationScheme) TableName() string {
return "qualitative_evaluation_scheme"
}
//性质考核方案明细
type QualitativeEvaluation struct {
Id int64 `json:"id" gorm:"column:qe_id;type:bigint(20) unsigned;not null;comment:Id;index"`
Title string `json:"title" gorm:"column:qe_title;type:text;comment:考核名称"`
DepartmentId int64 `json:"parentid" gorm:"column:qe_department_id;type:bigint(20) unsigned;default:0;not null;comment:执行考核部门ID"`
Dimension int64 `json:"dimension" gorm:"column:qe_dimension;type:bigint(20) unsigned;default:0;not null;comment:考核维度"`
Target int64 `json:"target" gorm:"column:qe_target;type:bigint(20) unsigned;default:0;not null;comment:考核指标"`
TargetSun int64 `json:"targetsun" gorm:"column:qe_target_sun;type:bigint(20) unsigned;default:0;not null;comment:考核指标子栏目"`
DetailedTarget int64 `json:"detailedtarget" gorm:"column:qe_detailed_target;type:bigint(20) unsigned;default:0;not null;comment:考核细则"`
Type int `json:"type" gorm:"column:qe_type;type:int(1) unsigned;default:1;not null;comment:1：定性考核；2：定量考核"`
Weight int64 `json:"weight" gorm:"column:qe_weight;type:int(5) unsigned;default:0;not null;comment:权重"`
Unit string `json:"unit" gorm:"column:qe_unit;type:varchar(255);comment:单位"`
ReferenceScore int64 `json:"referencescore" gorm:"column:qe_reference_score;type:int(9) unsigned;default:0;not null;comment:标准分值"`
State int `json:"state" gorm:"column:qe_state;type:int(1) unsigned;default:1;not null;comment:状态（1：启用；2：禁用；3：删除）"`
Addtime int64 `json:"addtime" gorm:"column:qe_addtime;type:bigint(20) unsigned;default:0;not null;comment:添加时间"`
Eitetime int64 `json:"eitetime" gorm:"column:qe_eitetime;type:bigint(20) unsigned;default:0;not null;comment:编辑时间"`
Group int64 `json:"group" gorm:"column:qe_group;type:bigint(20) unsigned;default:0;not null;comment:归属集团"`
QualEvalId int64 `json:"qualevalid" gorm:"column:qe_qual_eval_id;type:bigint(20) unsigned;default:0;not null;comment:性质考核方案"`
Cycles int `json:"cycle" gorm:"column:qe_cycle;type:tinyint(1) unsigned;default:1;not null;comment:1：班；2：天；3：周；4：月；5：季度；6：年"`
CycleAttres int `json:"cycleattr" gorm:"column:qe_cycleattr;type:int(9) unsigned;default:1;not null;comment:辅助计数"`
AcceptEvaluation int64 `json:"acceptevaluation" gorm:"column:qe_accept_evaluation;type:bigint(20) unsigned;default:0;not null;comment:接受考核部门"`
Operator string `json:"operator" gorm:"column:qe_operator;type:text;comment:执行人"`
}
func (QualitativeEvaluation *QualitativeEvaluation) TableName() string {
return "qualitative_evaluation"
}
//性质考核方案
type DepartmentDimension struct {
Id int64 `json:"id" gorm:"column:dd_id;type:bigint(20) unsigned;not null;comment:Id;index"`
Key int64 `json:"key" gorm:"column:dd_type;type:bigint(20) unsigned;default:0;not null;comment:1：定性考核；2：定量考核"`
DepartmentId int64 `json:"parentid" gorm:"column:dd_department;type:bigint(20) unsigned;default:0;not null;comment:部门ID"`
Dimension int64 `json:"dimension" gorm:"column:dd_dimension;type:bigint(20) unsigned;default:0;not null;comment:考核维度"`
Group int64 `json:"group" gorm:"column:dd_group;type:bigint(20) unsigned;default:0;not null;comment:归属集团"`
Addtime int64 `json:"addtime" gorm:"column:dd_time;type:bigint(20) unsigned;default:0;not null;comment:添加时间"`
Weight int64 `json:"weight" gorm:"column:dd_weight;type:int(6) unsigned;default:0;not null;comment:权重"`
}
func (DepartmentDimension *DepartmentDimension) TableName() string {
return "department_dimension"
}
//性质考核方案
type DepartmentDimensionWeight struct {
Id int64 `json:"id" gorm:"column:ddw_id;type:bigint(20) unsigned;not null;comment:Id;index"`
Type int64 `json:"type" gorm:"column:ddw_type;type:bigint(20) unsigned;default:0;not null;comment:1：定性考核；2：定量考核"`
Group int64 `json:"group" gorm:"column:ddw_group;type:bigint(20) unsigned;default:0;not null;comment:归属集团"`
DepartmentId int64 `json:"parentid" gorm:"column:ddw_derpatment;type:bigint(20) unsigned;default:0;not null;comment:部门ID"`
Dimension int64 `json:"dimension" gorm:"column:ddw_dimension;type:bigint(20) unsigned;default:0;not null;comment:考核维度"`
Target int64 `json:"target" gorm:"column:ddw_target;type:bigint(20) unsigned;default:0;not null;comment:指标"`
Weight int64 `json:"weight" gorm:"column:ddw_weight;type:int(6) unsigned;default:0;not null;comment:权重"`
Addtime int64 `json:"addtime" gorm:"column:ddw_time;type:bigint(20) unsigned;default:0;not null;comment:添加时间"`
Hierarchy int64 `json:"hierarchy" gorm:"column:ddw_hierarchy;type:bigint(20) unsigned;default:0;not null;comment:维度；2：指标"`
}
func (DepartmentDimensionWeight *DepartmentDimensionWeight) TableName() string {
return "department_dimension_weight"
}

71
gin_server_admin/router/assessment/assessmentrouter.go
View File

@ -43,6 +43,62 @@ func (s *AssessmentRouter) InitAssessmentRouter(Router *gin.RouterGroup) {
dutyCodeRouter.POST("adddepartdutyinfo", authorityApi.AddDepartDutyInfo) // 添加具体部门考核项目(副本)
dutyCodeRouter.POST("eitedepartdutyinfo", authorityApi.EiteDepartDutyInfo) // 修改具体部门考核项目详情(副本)
/*
指标相关
*/
dutyCodeRouter.POST("addtarget", authorityApi.AddTarget) // 添加考核指标
dutyCodeRouter.POST("gettarget", authorityApi.GetTargetList) // 获取考核指标列表
dutyCodeRouter.POST("gettargetinfo", authorityApi.GetTarget) // 获取考核指标详细内容
dutyCodeRouter.POST("deltarget", authorityApi.DelTarget) // 删除指标/更改考核指标状态
dutyCodeRouter.POST("eitetarget", authorityApi.EiteTarget) // 修改指标内容
/*
定性指标子栏目相关
*/
dutyCodeRouter.POST("addqualitativetarget", authorityApi.AddQualitativeTarget) // 添加定性指标子栏目
dutyCodeRouter.POST("getqualitativetargetlist", authorityApi.GetQualitativeTargetList) // 获取定性指标子栏目列表
dutyCodeRouter.POST("getqualitativetargetinfo", authorityApi.GetQualTargetInfo) // 获取定性指标子栏目详细内容
dutyCodeRouter.POST("eitequalitativetargetinfo", authorityApi.EiteQualTargetInfo) // 修改定性指标子栏目详细内容
dutyCodeRouter.POST("delqualitativetargetinfo", authorityApi.DelQualTargetInfo) // 修改定性指标子栏目状态或删除
/*
新考核细则处理
*/
dutyCodeRouter.POST("adddetailedtarget", authorityApi.AddDetailedTarget) // 添加考核细则
dutyCodeRouter.POST("getdetailedtarget", authorityApi.GetDetailedTarget) // 获取考核细则内容
dutyCodeRouter.POST("getdetailedtargetlist", authorityApi.GetDetailedTargetList) // 获取考核细则列表
dutyCodeRouter.POST("eitedetailedtarget", authorityApi.EiteDetailedTargetCont) // 编辑考核细则内容
dutyCodeRouter.POST("deldetailedtarget", authorityApi.DelDetailedTargetCont) // 删除考核细则内容
/*
定性考核
*/
dutyCodeRouter.POST("addqualeval", authorityApi.AddQualEval) // 添加定性考核
dutyCodeRouter.POST("getqualevallist", authorityApi.GetQualEvalList) // 定性考核列表
dutyCodeRouter.POST("addqualevalweight", authorityApi.AddQualEvalWeight) // 添加定性考核权重
/*
定量考核
*/
dutyCodeRouter.POST("addration", authorityApi.AddRation) // 添加定量考核
dutyCodeRouter.POST("addrationlist", authorityApi.RationList) // 定量考核列表
/*
指标组合列表
*/
dutyCodeRouter.POST("gettasktarget", authorityApi.GetTaskTarget) // 根据条件获取组合指标
dutyCodeRouter.POST("gettasktargetsun", authorityApi.GetTaskTargetSun) // 根据条件获取组合指标子栏目
dutyCodeRouter.POST("gettasktargetcontary", authorityApi.GetTaskTargetContAry) // 根据条件获取考核详情
// dutyCodeRouter.POST("addqualevalweight", authorityApi.AddQualEvalWeight) //添加权重（单发）
dutyCodeRouter.POST("addqubatch", authorityApi.AddQualEvalDimWeightBatch) //添加指标权重（批量）
dutyCodeRouter.POST("adddimweightbatch", authorityApi.AddDimWeightBatch) //添加维度权重（批量）
/*
部门考核
*/
dutyCodeRouter.POST("departmentlist", authorityApi.DepartmentList) // 部门考核列表
}
}
@ -83,3 +139,18 @@ func (s *AssessmentRouter) NoInitDutyHandelRouter(Router *gin.RouterGroup) {
}
}
func (s *AssessmentRouter) InitEvaluationSchemeRouter(Router *gin.RouterGroup) {
dutyCodeRouter := Router.Group("scheme")
var authorityApi = v1.ApiGroupApp.DutyHandleApi.EvaluationScheme
{
dutyCodeRouter.POST("/", authorityApi.Index) // 入口
dutyCodeRouter.POST("", authorityApi.Index) // 入口
dutyCodeRouter.GET("/", authorityApi.Index) // 入口
dutyCodeRouter.GET("", authorityApi.Index) // 入口
dutyCodeRouter.POST("addevaluationscheme", authorityApi.AddEvaluationScheme) // 添加考核方案
}
}

2
gin_server_admin/router/examtestpage/grouphandle.go
View File

@ -29,5 +29,7 @@ func (g *GroupHandleRouter) InitGroupRouter(Router *gin.RouterGroup) {
groupCodeRouter.POST("/getgroupuser", authorityApi.GetGroupUser) //获取集团架构人员信息对照表
groupCodeRouter.POST("/departmentlist", authorityApi.GetDepartmentList) // 获取分厂部室列表
}
}

Write Preview
Loading…
Cancel
Save