605 lines
15 KiB
Go
605 lines
15 KiB
Go
package controllers
|
|
|
|
import (
|
|
"encoding/json"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"server/models"
|
|
"server/pkg/identity"
|
|
"server/pkg/jwtutil"
|
|
|
|
"github.com/beego/beego/v2/client/orm"
|
|
beego "github.com/beego/beego/v2/server/web"
|
|
)
|
|
|
|
type BackendJobRankController struct {
|
|
beego.Controller
|
|
}
|
|
|
|
type jobRankDTO struct {
|
|
ID uint64 `json:"id"`
|
|
Tid uint64 `json:"tid"`
|
|
TenantID uint64 `json:"tenant_id"`
|
|
RankCode string `json:"rank_code"`
|
|
RankName string `json:"rank_name"`
|
|
LevelNo int `json:"level_no"`
|
|
DepartmentID uint64 `json:"department_id"`
|
|
DepartmentName string `json:"department_name"`
|
|
SalaryMin float64 `json:"salary_min"`
|
|
SalaryMax float64 `json:"salary_max"`
|
|
DefaultRoleID uint64 `json:"default_role_id"`
|
|
Status int8 `json:"status"`
|
|
Sort int `json:"sort"`
|
|
Remark string `json:"remark"`
|
|
CreateTime string `json:"create_time"`
|
|
}
|
|
|
|
type jobRankPayload struct {
|
|
RankCode *string `json:"rank_code"`
|
|
RankName *string `json:"rank_name"`
|
|
LevelNo *int `json:"level_no"`
|
|
DepartmentID *uint64 `json:"department_id"`
|
|
SalaryMin *float64 `json:"salary_min"`
|
|
SalaryMax *float64 `json:"salary_max"`
|
|
DefaultRoleID *uint64 `json:"default_role_id"`
|
|
Status *int8 `json:"status"`
|
|
Sort *int `json:"sort"`
|
|
Remark *string `json:"remark"`
|
|
}
|
|
|
|
func (c *BackendJobRankController) claims() (*jwtutil.Claims, bool) {
|
|
claims, err := identity.Claims(c.Ctx.Request.Header.Get("Authorization"), identity.EndBackend)
|
|
if err != nil || claims.TenantId <= 0 {
|
|
return nil, false
|
|
}
|
|
return claims, true
|
|
}
|
|
|
|
func (c *BackendJobRankController) pathUint64(name string) (uint64, bool) {
|
|
id, err := strconv.ParseUint(c.Ctx.Input.Param(name), 10, 64)
|
|
return id, err == nil && id > 0
|
|
}
|
|
|
|
func (c *BackendJobRankController) nowString() string {
|
|
return time.Now().Format("2006-01-02 15:04:05")
|
|
}
|
|
|
|
func (c *BackendJobRankController) tenantID() (uint64, bool) {
|
|
claims, ok := c.claims()
|
|
if !ok {
|
|
c.jsonError(401, "未登录或登录已过期")
|
|
return 0, false
|
|
}
|
|
return uint64(claims.TenantId), true
|
|
}
|
|
|
|
func (c *BackendJobRankController) jsonOK(data interface{}) {
|
|
resp := map[string]interface{}{"code": 200, "msg": "success"}
|
|
if data != nil {
|
|
resp["data"] = data
|
|
}
|
|
c.Data["json"] = resp
|
|
_ = c.ServeJSON()
|
|
}
|
|
|
|
func (c *BackendJobRankController) jsonError(code int, msg string) {
|
|
if code == 401 {
|
|
c.Ctx.Output.SetStatus(401)
|
|
}
|
|
c.Data["json"] = map[string]interface{}{"code": code, "msg": msg}
|
|
_ = c.ServeJSON()
|
|
}
|
|
|
|
func (c *BackendJobRankController) rankQuery(tid uint64) orm.QuerySeter {
|
|
return models.Orm.QueryTable(new(models.BackendJobRank)).
|
|
Filter("tid", tid).
|
|
Filter("delete_time__isnull", true)
|
|
}
|
|
|
|
func (c *BackendJobRankController) jobRankPayloadOf() (jobRankPayload, bool) {
|
|
var payload jobRankPayload
|
|
contentType := strings.ToLower(c.Ctx.Input.Header("Content-Type"))
|
|
if strings.Contains(contentType, "json") && len(c.Ctx.Input.RequestBody) > 0 {
|
|
if err := json.Unmarshal(c.Ctx.Input.RequestBody, &payload); err != nil {
|
|
return payload, false
|
|
}
|
|
return payload, true
|
|
}
|
|
getString := func(key string) *string {
|
|
v := strings.TrimSpace(c.GetString(key))
|
|
if v == "" {
|
|
return nil
|
|
}
|
|
return &v
|
|
}
|
|
getFloat := func(key string) *float64 {
|
|
v := strings.TrimSpace(c.GetString(key))
|
|
if v == "" {
|
|
return nil
|
|
}
|
|
f, err := strconv.ParseFloat(v, 64)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
return &f
|
|
}
|
|
getInt := func(key string) *int {
|
|
v := strings.TrimSpace(c.GetString(key))
|
|
if v == "" {
|
|
return nil
|
|
}
|
|
i, err := strconv.Atoi(v)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
return &i
|
|
}
|
|
getUint64 := func(key string) *uint64 {
|
|
v := strings.TrimSpace(c.GetString(key))
|
|
if v == "" {
|
|
return nil
|
|
}
|
|
i, err := strconv.ParseUint(v, 10, 64)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
return &i
|
|
}
|
|
payload.RankCode = getString("rank_code")
|
|
payload.RankName = getString("rank_name")
|
|
payload.LevelNo = getInt("level_no")
|
|
payload.DepartmentID = getUint64("department_id")
|
|
payload.SalaryMin = getFloat("salary_min")
|
|
payload.SalaryMax = getFloat("salary_max")
|
|
payload.DefaultRoleID = getUint64("default_role_id")
|
|
payload.Sort = getInt("sort")
|
|
payload.Remark = getString("remark")
|
|
if v := getString("status"); v != nil {
|
|
status := int8(0)
|
|
if s, err := strconv.Atoi(*v); err == nil {
|
|
status = int8(s)
|
|
}
|
|
payload.Status = &status
|
|
}
|
|
return payload, true
|
|
}
|
|
|
|
func (c *BackendJobRankController) List() {
|
|
tid, ok := c.tenantID()
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
cond := orm.NewCondition().And("tid", tid).And("delete_time__isnull", true)
|
|
departmentID, _ := c.GetUint64("department_id")
|
|
scope := strings.ToLower(strings.TrimSpace(c.GetString("scope")))
|
|
if scope == "assign" {
|
|
if departmentID > 0 {
|
|
cond = cond.And("department_id__in", []uint64{0, departmentID})
|
|
}
|
|
} else if departmentID > 0 {
|
|
cond = cond.And("department_id", departmentID)
|
|
}
|
|
if keyword := strings.TrimSpace(c.GetString("keyword")); keyword != "" {
|
|
cond = cond.AndCond(orm.NewCondition().
|
|
Or("rank_name__icontains", keyword).
|
|
Or("rank_code__icontains", keyword))
|
|
}
|
|
if raw := strings.TrimSpace(c.GetString("status")); raw != "" {
|
|
if status, err := strconv.Atoi(raw); err == nil {
|
|
cond = cond.And("status", int8(status))
|
|
}
|
|
}
|
|
|
|
var rows []models.BackendJobRank
|
|
if _, err := models.Orm.QueryTable(new(models.BackendJobRank)).
|
|
SetCond(cond).OrderBy("level_no", "sort", "id").All(&rows); err != nil {
|
|
c.jsonError(500, "查询职级失败: "+err.Error())
|
|
return
|
|
}
|
|
|
|
deptNames := jobRankDeptNameMap(tid)
|
|
list := make([]jobRankDTO, 0, len(rows))
|
|
for _, row := range rows {
|
|
list = append(list, jobRankDTOOf(row, deptNames))
|
|
}
|
|
c.jsonOK(list)
|
|
}
|
|
|
|
func (c *BackendJobRankController) Detail() {
|
|
tid, ok := c.tenantID()
|
|
if !ok {
|
|
return
|
|
}
|
|
id, valid := c.pathUint64(":id")
|
|
if !valid {
|
|
c.jsonError(400, "无效ID")
|
|
return
|
|
}
|
|
var row models.BackendJobRank
|
|
if err := c.rankQuery(tid).Filter("id", id).One(&row); err != nil {
|
|
c.jsonError(404, "职级不存在")
|
|
return
|
|
}
|
|
c.jsonOK(jobRankDTOOf(row, jobRankDeptNameMap(tid)))
|
|
}
|
|
|
|
func (c *BackendJobRankController) Create() {
|
|
tid, ok := c.tenantID()
|
|
if !ok {
|
|
return
|
|
}
|
|
payload, ok := c.jobRankPayloadOf()
|
|
if !ok {
|
|
c.jsonError(400, "参数错误")
|
|
return
|
|
}
|
|
|
|
rankName := ""
|
|
if payload.RankName != nil {
|
|
rankName = strings.TrimSpace(*payload.RankName)
|
|
}
|
|
if rankName == "" {
|
|
c.jsonError(400, "职级名称不能为空")
|
|
return
|
|
}
|
|
|
|
rankCode := ""
|
|
if payload.RankCode != nil {
|
|
rankCode = strings.TrimSpace(*payload.RankCode)
|
|
}
|
|
if rankCode == "" {
|
|
c.jsonError(400, "职级编码不能为空")
|
|
return
|
|
}
|
|
count, err := c.rankQuery(tid).Filter("rank_code", rankCode).Count()
|
|
if err != nil {
|
|
c.jsonError(500, "校验职级编码失败: "+err.Error())
|
|
return
|
|
}
|
|
if count > 0 {
|
|
c.jsonError(400, "职级编码已存在")
|
|
return
|
|
}
|
|
|
|
departmentID := uint64(0)
|
|
if payload.DepartmentID != nil {
|
|
departmentID = *payload.DepartmentID
|
|
}
|
|
if departmentID > 0 && !jobRankOrgExists(tid, departmentID) {
|
|
c.jsonError(400, "适用部门不存在")
|
|
return
|
|
}
|
|
|
|
salaryMin, salaryMax := 0.0, 0.0
|
|
if payload.SalaryMin != nil {
|
|
salaryMin = *payload.SalaryMin
|
|
}
|
|
if payload.SalaryMax != nil {
|
|
salaryMax = *payload.SalaryMax
|
|
}
|
|
if salaryMin < 0 || salaryMax < 0 {
|
|
c.jsonError(400, "标准薪资不能为负数")
|
|
return
|
|
}
|
|
if salaryMax > 0 && salaryMax < salaryMin {
|
|
c.jsonError(400, "标准薪资上限不能小于下限")
|
|
return
|
|
}
|
|
|
|
row := models.BackendJobRank{
|
|
Tid: tid,
|
|
RankCode: rankCode,
|
|
RankName: rankName,
|
|
LevelNo: 0,
|
|
DepartmentID: departmentID,
|
|
SalaryMin: salaryMin,
|
|
SalaryMax: salaryMax,
|
|
DefaultRoleID: 0,
|
|
Status: 1,
|
|
Sort: 0,
|
|
}
|
|
if payload.LevelNo != nil {
|
|
row.LevelNo = *payload.LevelNo
|
|
}
|
|
if payload.DefaultRoleID != nil {
|
|
row.DefaultRoleID = *payload.DefaultRoleID
|
|
}
|
|
if payload.Status != nil {
|
|
row.Status = int8(1)
|
|
if *payload.Status == 0 {
|
|
row.Status = 0
|
|
}
|
|
}
|
|
if payload.Sort != nil {
|
|
row.Sort = *payload.Sort
|
|
}
|
|
if payload.Remark != nil {
|
|
row.Remark = strPtrIfNotEmpty(strings.TrimSpace(*payload.Remark))
|
|
}
|
|
|
|
id, err := models.Orm.Insert(&row)
|
|
if err != nil {
|
|
c.jsonError(500, "创建职级失败: "+err.Error())
|
|
return
|
|
}
|
|
c.jsonOK(map[string]interface{}{"id": id, "rank_code": rankCode})
|
|
}
|
|
|
|
func (c *BackendJobRankController) Update() {
|
|
tid, ok := c.tenantID()
|
|
if !ok {
|
|
return
|
|
}
|
|
id, valid := c.pathUint64(":id")
|
|
if !valid {
|
|
c.jsonError(400, "无效ID")
|
|
return
|
|
}
|
|
if !c.rankQuery(tid).Filter("id", id).Exist() {
|
|
c.jsonError(404, "职级不存在")
|
|
return
|
|
}
|
|
|
|
payload, ok := c.jobRankPayloadOf()
|
|
if !ok {
|
|
c.jsonError(400, "参数错误")
|
|
return
|
|
}
|
|
|
|
update := orm.Params{}
|
|
|
|
if payload.RankCode != nil {
|
|
code := strings.TrimSpace(*payload.RankCode)
|
|
if code == "" {
|
|
c.jsonError(400, "职级编码不能为空")
|
|
return
|
|
}
|
|
count, err := c.rankQuery(tid).Filter("rank_code", code).Exclude("id", id).Count()
|
|
if err != nil {
|
|
c.jsonError(500, "校验职级编码失败: "+err.Error())
|
|
return
|
|
}
|
|
if count > 0 {
|
|
c.jsonError(400, "职级编码已存在")
|
|
return
|
|
}
|
|
update["rank_code"] = code
|
|
}
|
|
if payload.RankName != nil {
|
|
name := strings.TrimSpace(*payload.RankName)
|
|
if name == "" {
|
|
c.jsonError(400, "职级名称不能为空")
|
|
return
|
|
}
|
|
update["rank_name"] = name
|
|
}
|
|
if payload.LevelNo != nil {
|
|
update["level_no"] = *payload.LevelNo
|
|
}
|
|
if payload.DepartmentID != nil {
|
|
departmentID := *payload.DepartmentID
|
|
if departmentID > 0 && !jobRankOrgExists(tid, departmentID) {
|
|
c.jsonError(400, "适用部门不存在")
|
|
return
|
|
}
|
|
update["department_id"] = departmentID
|
|
}
|
|
if payload.SalaryMin != nil || payload.SalaryMax != nil {
|
|
var row models.BackendJobRank
|
|
if err := c.rankQuery(tid).Filter("id", id).One(&row); err != nil {
|
|
c.jsonError(404, "职级不存在")
|
|
return
|
|
}
|
|
salaryMin, salaryMax := row.SalaryMin, row.SalaryMax
|
|
if payload.SalaryMin != nil {
|
|
salaryMin = *payload.SalaryMin
|
|
}
|
|
if payload.SalaryMax != nil {
|
|
salaryMax = *payload.SalaryMax
|
|
}
|
|
if salaryMin < 0 || salaryMax < 0 {
|
|
c.jsonError(400, "标准薪资不能为负数")
|
|
return
|
|
}
|
|
if salaryMax > 0 && salaryMax < salaryMin {
|
|
c.jsonError(400, "标准薪资上限不能小于下限")
|
|
return
|
|
}
|
|
update["salary_min"] = salaryMin
|
|
update["salary_max"] = salaryMax
|
|
}
|
|
if payload.DefaultRoleID != nil {
|
|
update["default_role_id"] = *payload.DefaultRoleID
|
|
}
|
|
if payload.Status != nil {
|
|
status := int8(1)
|
|
if *payload.Status == 0 {
|
|
status = 0
|
|
}
|
|
update["status"] = status
|
|
}
|
|
if payload.Sort != nil {
|
|
update["sort"] = *payload.Sort
|
|
}
|
|
if payload.Remark != nil {
|
|
update["remark"] = nullableString(strings.TrimSpace(*payload.Remark))
|
|
}
|
|
|
|
if len(update) == 0 {
|
|
c.jsonError(400, "无更新字段")
|
|
return
|
|
}
|
|
if _, err := c.rankQuery(tid).Filter("id", id).Update(update); err != nil {
|
|
c.jsonError(500, "更新职级失败: "+err.Error())
|
|
return
|
|
}
|
|
c.jsonOK(nil)
|
|
}
|
|
|
|
func (c *BackendJobRankController) Delete() {
|
|
tid, ok := c.tenantID()
|
|
if !ok {
|
|
return
|
|
}
|
|
id, valid := c.pathUint64(":id")
|
|
if !valid {
|
|
c.jsonError(400, "无效ID")
|
|
return
|
|
}
|
|
|
|
positionCount, err := models.Orm.QueryTable(new(models.BackendPosition)).
|
|
Filter("tid", tid).
|
|
Filter("rank_id", id).
|
|
Filter("delete_time__isnull", true).
|
|
Count()
|
|
if err != nil {
|
|
c.jsonError(500, "校验职级引用失败: "+err.Error())
|
|
return
|
|
}
|
|
if positionCount > 0 {
|
|
c.jsonError(400, "该职级已被 "+strconv.FormatInt(positionCount, 10)+" 个职位引用,请先调整职位的职级")
|
|
return
|
|
}
|
|
schemeCount, err := models.Orm.QueryTable(new(models.BackendOaCompensationScheme)).
|
|
Filter("tid", tid).
|
|
Filter("rank_id", id).
|
|
Filter("is_deleted", 0).
|
|
Count()
|
|
if err != nil {
|
|
c.jsonError(500, "校验职级引用失败: "+err.Error())
|
|
return
|
|
}
|
|
if schemeCount > 0 {
|
|
c.jsonError(400, "该职级已被 "+strconv.FormatInt(schemeCount, 10)+" 个薪酬方案引用,请先调整方案的职级")
|
|
return
|
|
}
|
|
|
|
num, err := c.rankQuery(tid).Filter("id", id).
|
|
Update(orm.Params{"delete_time": c.nowString(), "status": int8(0)})
|
|
if err != nil {
|
|
c.jsonError(500, "删除职级失败: "+err.Error())
|
|
return
|
|
}
|
|
if num == 0 {
|
|
c.jsonError(404, "职级不存在")
|
|
return
|
|
}
|
|
c.jsonOK(nil)
|
|
}
|
|
|
|
func (c *BackendJobRankController) CheckCodeUnique() {
|
|
tid, ok := c.tenantID()
|
|
if !ok {
|
|
return
|
|
}
|
|
code := strings.TrimSpace(c.GetString("rank_code"))
|
|
if code == "" {
|
|
c.jsonError(400, "职级编码不能为空")
|
|
return
|
|
}
|
|
excludeID, _ := c.GetUint64("exclude_id")
|
|
qs := c.rankQuery(tid).Filter("rank_code", code)
|
|
if excludeID > 0 {
|
|
qs = qs.Exclude("id", excludeID)
|
|
}
|
|
count, err := qs.Count()
|
|
if err != nil {
|
|
c.jsonError(500, "检查编码唯一性失败: "+err.Error())
|
|
return
|
|
}
|
|
c.jsonOK(map[string]interface{}{"unique": count == 0, "message": uniqueMessage(count == 0, "编码")})
|
|
}
|
|
|
|
func jobRankDTOOf(row models.BackendJobRank, deptNames map[uint64]string) jobRankDTO {
|
|
deptName := ""
|
|
if row.DepartmentID > 0 {
|
|
deptName = deptNames[row.DepartmentID]
|
|
}
|
|
if row.DepartmentID == 0 {
|
|
deptName = "全公司通用"
|
|
}
|
|
return jobRankDTO{
|
|
ID: row.ID,
|
|
Tid: row.Tid,
|
|
TenantID: row.Tid,
|
|
RankCode: row.RankCode,
|
|
RankName: row.RankName,
|
|
LevelNo: row.LevelNo,
|
|
DepartmentID: row.DepartmentID,
|
|
DepartmentName: deptName,
|
|
SalaryMin: row.SalaryMin,
|
|
SalaryMax: row.SalaryMax,
|
|
DefaultRoleID: row.DefaultRoleID,
|
|
Status: row.Status,
|
|
Sort: row.Sort,
|
|
Remark: derefString(row.Remark),
|
|
CreateTime: formatDateTime(&row.CreateTime),
|
|
}
|
|
}
|
|
|
|
func jobRankDeptNameMap(tid uint64) map[uint64]string {
|
|
result := map[uint64]string{}
|
|
var rows []models.BackendOrganization
|
|
if _, err := models.Orm.QueryTable(new(models.BackendOrganization)).
|
|
Filter("tid", tid).
|
|
Filter("delete_time__isnull", true).
|
|
All(&rows, "ID", "OrgName"); err != nil {
|
|
return result
|
|
}
|
|
for _, row := range rows {
|
|
result[row.ID] = row.OrgName
|
|
}
|
|
return result
|
|
}
|
|
|
|
func jobRankOrgExists(tid, id uint64) bool {
|
|
if id == 0 {
|
|
return false
|
|
}
|
|
return models.Orm.QueryTable(new(models.BackendOrganization)).
|
|
Filter("tid", tid).
|
|
Filter("id", id).
|
|
Filter("delete_time__isnull", true).
|
|
Exist()
|
|
}
|
|
|
|
func JobRankMap(tid uint64) map[uint64]models.BackendJobRank {
|
|
result := map[uint64]models.BackendJobRank{}
|
|
if tid == 0 {
|
|
return result
|
|
}
|
|
var rows []models.BackendJobRank
|
|
if _, err := models.Orm.QueryTable(new(models.BackendJobRank)).
|
|
Filter("tid", tid).
|
|
Filter("delete_time__isnull", true).
|
|
All(&rows); err != nil {
|
|
return result
|
|
}
|
|
for _, row := range rows {
|
|
result[row.ID] = row
|
|
}
|
|
return result
|
|
}
|
|
|
|
func ResolveEmployeeRankID(tid uint64, employee models.BackendEmployee) uint64 {
|
|
positionName := strings.TrimSpace(derefString(employee.Position))
|
|
if positionName == "" {
|
|
return 0
|
|
}
|
|
qs := models.Orm.QueryTable(new(models.BackendPosition)).
|
|
Filter("tid", tid).
|
|
Filter("position_name", positionName).
|
|
Filter("delete_time__isnull", true)
|
|
if departmentID, err := strconv.ParseUint(strings.TrimSpace(derefString(employee.Department)), 10, 64); err == nil && departmentID > 0 {
|
|
qs = qs.Filter("department_id", departmentID)
|
|
}
|
|
var row models.BackendPosition
|
|
if err := qs.OrderBy("id").One(&row); err != nil {
|
|
return 0
|
|
}
|
|
return row.RankID
|
|
}
|