981 lines
30 KiB
Go
981 lines
30 KiB
Go
package controllers
|
|
|
|
import (
|
|
"encoding/json"
|
|
"io"
|
|
"log"
|
|
"regexp"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"server/models"
|
|
"server/pkg/jwtutil"
|
|
|
|
"github.com/beego/beego/v2/client/orm"
|
|
beego "github.com/beego/beego/v2/server/web"
|
|
)
|
|
|
|
// BackendEmployeeFileController 员工档案管理（OA 人事档案）。
|
|
// 档案与员工（yz_backend_employee）按 tid + employee_id 一对一，
|
|
// 子记录表统一存放教育经历 / 工作经历 / 合同信息 / 证照附件。
|
|
// 数据按 JWT 中的租户隔离。
|
|
type BackendEmployeeFileController struct {
|
|
beego.Controller
|
|
}
|
|
|
|
func (c *BackendEmployeeFileController) efClaims() (*jwtutil.Claims, error) {
|
|
auth := c.Ctx.Request.Header.Get("Authorization")
|
|
if auth == "" {
|
|
return nil, orm.ErrNoRows
|
|
}
|
|
parts := strings.SplitN(auth, " ", 2)
|
|
if len(parts) != 2 || parts[0] != "Bearer" {
|
|
return nil, orm.ErrNoRows
|
|
}
|
|
claims, err := jwtutil.ParseToken(parts[1])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if claims.UserType != "backend" {
|
|
return nil, orm.ErrNoRows
|
|
}
|
|
return claims, nil
|
|
}
|
|
|
|
func (c *BackendEmployeeFileController) efOk(data interface{}) {
|
|
c.Data["json"] = map[string]interface{}{"code": 200, "msg": "success", "data": data}
|
|
_ = c.ServeJSON()
|
|
}
|
|
|
|
func (c *BackendEmployeeFileController) efErr(httpStatus, bizCode int, msg string) {
|
|
c.Ctx.Output.SetStatus(httpStatus)
|
|
c.Data["json"] = map[string]interface{}{"code": bizCode, "msg": msg}
|
|
_ = c.ServeJSON()
|
|
}
|
|
|
|
var efDatePattern = regexp.MustCompile(`^\d{4}-\d{2}-\d{2}$`)
|
|
|
|
// efIsValidDate 校验 "YYYY-MM-DD" 日期字符串；允许为空（可空字段）。
|
|
func efIsValidDate(s string) bool {
|
|
s = strings.TrimSpace(s)
|
|
if s == "" {
|
|
return true
|
|
}
|
|
if !efDatePattern.MatchString(s) {
|
|
return false
|
|
}
|
|
_, err := time.ParseInLocation("2006-01-02", s, time.Local)
|
|
return err == nil
|
|
}
|
|
|
|
// efNormalizeDate 将可空 DATE 列统一输出为 "YYYY-MM-DD"。
|
|
func efNormalizeDate(value *time.Time) string {
|
|
if value == nil {
|
|
return ""
|
|
}
|
|
return value.Format("2006-01-02")
|
|
}
|
|
|
|
// efDatePointer 将前端可选日期转为可空 DATE 值；空字符串明确保存为 SQL NULL。
|
|
func efDatePointer(value string) *time.Time {
|
|
value = strings.TrimSpace(value)
|
|
if value == "" {
|
|
return nil
|
|
}
|
|
date, err := time.ParseInLocation("2006-01-02", value, time.Local)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
return &date
|
|
}
|
|
|
|
// efQuery 档案查询基座：强制附加租户过滤与未删除条件。
|
|
func (c *BackendEmployeeFileController) efQuery(tid int) orm.QuerySeter {
|
|
return models.Orm.QueryTable(new(models.BackendEmployeeFile)).
|
|
Filter("tid", tid).
|
|
Filter("is_deleted", 0)
|
|
}
|
|
|
|
// efEmployeeQuery 员工查询基座（与组织架构控制器保持同一过滤口径）。
|
|
func efEmployeeQuery(tid int) orm.QuerySeter {
|
|
return models.Orm.QueryTable(new(models.BackendEmployee)).
|
|
Filter("tid", tid).
|
|
Filter("delete_time__isnull", true)
|
|
}
|
|
|
|
// efOrgNameMap 组织ID -> 名称映射，用于展示员工的隶属单位/部门名称。
|
|
func (c *BackendEmployeeFileController) efOrgNameMap(tid int) 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 map[uint64]string{}
|
|
}
|
|
names := make(map[uint64]string, len(rows))
|
|
for _, row := range rows {
|
|
names[row.ID] = row.OrgName
|
|
}
|
|
return names
|
|
}
|
|
|
|
// efOrgNameByID 组织ID字符串转名称；非数字时原样返回（手输文本兜底）。
|
|
func efOrgNameByID(names map[uint64]string, id string) string {
|
|
if id == "" {
|
|
return ""
|
|
}
|
|
if v, err := strconv.ParseUint(id, 10, 64); err == nil {
|
|
return names[v]
|
|
}
|
|
return id
|
|
}
|
|
|
|
// efSubtreeOrgIDs 收集组织节点及其全部下级的ID（BFS，含环保护）。
|
|
func (c *BackendEmployeeFileController) efSubtreeOrgIDs(tid int, rootID uint64) []uint64 {
|
|
var rows []models.BackendOrganization
|
|
if _, err := models.Orm.QueryTable(new(models.BackendOrganization)).
|
|
Filter("tid", tid).
|
|
Filter("delete_time__isnull", true).
|
|
All(&rows, "ID", "ParentID"); err != nil {
|
|
return []uint64{rootID}
|
|
}
|
|
childrenOf := map[uint64][]uint64{}
|
|
for _, row := range rows {
|
|
childrenOf[row.ParentID] = append(childrenOf[row.ParentID], row.ID)
|
|
}
|
|
|
|
result := []uint64{rootID}
|
|
queue := []uint64{rootID}
|
|
visited := map[uint64]bool{rootID: true}
|
|
for len(queue) > 0 {
|
|
current := queue[0]
|
|
queue = queue[1:]
|
|
for _, child := range childrenOf[current] {
|
|
if visited[child] {
|
|
continue
|
|
}
|
|
visited[child] = true
|
|
result = append(result, child)
|
|
queue = append(queue, child)
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
// efEmployeeIDsInOrgs 取部门集合内的员工ID（档案按员工过滤时使用）。
|
|
func (c *BackendEmployeeFileController) efEmployeeIDsInOrgs(tid int, orgIDs []uint64) []uint64 {
|
|
values := make([]string, 0, len(orgIDs))
|
|
for _, id := range orgIDs {
|
|
values = append(values, strconv.FormatUint(id, 10))
|
|
}
|
|
var rows []models.BackendEmployee
|
|
if _, err := efEmployeeQuery(tid).Filter("department__in", values).All(&rows, "ID"); err != nil {
|
|
return nil
|
|
}
|
|
ids := make([]uint64, 0, len(rows))
|
|
for _, row := range rows {
|
|
ids = append(ids, uint64(row.ID))
|
|
}
|
|
return ids
|
|
}
|
|
|
|
// efEmployeeIDsByKeyword 取姓名/账号/手机命中的员工ID（档案关键词搜索联动员工字段）。
|
|
func (c *BackendEmployeeFileController) efEmployeeIDsByKeyword(tid int, keyword string) []uint64 {
|
|
cond := orm.NewCondition().
|
|
Or("name__icontains", keyword).
|
|
Or("account__icontains", keyword).
|
|
Or("phone__icontains", keyword)
|
|
var rows []models.BackendEmployee
|
|
if _, err := efEmployeeQuery(tid).SetCond(cond).All(&rows, "ID"); err != nil {
|
|
return nil
|
|
}
|
|
ids := make([]uint64, 0, len(rows))
|
|
for _, row := range rows {
|
|
ids = append(ids, uint64(row.ID))
|
|
}
|
|
return ids
|
|
}
|
|
|
|
// employeeFileDTO 档案 + 关联员工展示信息（JSON 平铺，前端表格/详情直接用）。
|
|
type employeeFileDTO struct {
|
|
models.BackendEmployeeFile
|
|
EmployeeName string `json:"employee_name"`
|
|
EmployeeAccount string `json:"employee_account"`
|
|
Gender int8 `json:"gender"`
|
|
Birthday string `json:"birthday"`
|
|
AffiliateUnit string `json:"affiliate_unit"`
|
|
AffiliateUnitName string `json:"affiliate_unit_name"`
|
|
Department string `json:"department"`
|
|
DepartmentName string `json:"department_name"`
|
|
Position string `json:"position"`
|
|
Phone string `json:"phone"`
|
|
Email string `json:"email"`
|
|
Education string `json:"education"`
|
|
Nation string `json:"nation"`
|
|
HomeAddress string `json:"home_address"`
|
|
AccountStatus int8 `json:"account_status"`
|
|
HireDate string `json:"hire_date"`
|
|
RegularDate string `json:"regular_date"`
|
|
LeaveDate string `json:"leave_date"`
|
|
Completeness int `json:"completeness"`
|
|
}
|
|
|
|
// efFileCompleteness 计算档案资料完整度。仅统计应由档案模块维护的有效字段：
|
|
// 离职日期仅在离职时要求，转正日期仅在正式员工时要求，备注为可选项不计入。
|
|
func efFileCompleteness(file models.BackendEmployeeFile) int {
|
|
items := []bool{
|
|
strings.TrimSpace(file.IDCard) != "",
|
|
strings.TrimSpace(file.PoliticalStatus) != "",
|
|
file.MaritalStatus > 0,
|
|
strings.TrimSpace(file.NativePlace) != "",
|
|
strings.TrimSpace(file.HouseholdAddress) != "",
|
|
strings.TrimSpace(file.CurrentAddress) != "",
|
|
strings.TrimSpace(file.WorkEmail) != "",
|
|
file.HireDate != nil,
|
|
strings.TrimSpace(file.EmergencyContact) != "",
|
|
strings.TrimSpace(file.EmergencyPhone) != "",
|
|
strings.TrimSpace(file.EmergencyRelation) != "",
|
|
strings.TrimSpace(file.EducationPhoto) != "",
|
|
strings.TrimSpace(file.IDCardFront) != "",
|
|
strings.TrimSpace(file.IDCardBack) != "",
|
|
}
|
|
if file.EmploymentStatus == 2 {
|
|
items = append(items, file.RegularDate != nil)
|
|
}
|
|
if file.EmploymentStatus == 3 {
|
|
items = append(items, file.LeaveDate != nil)
|
|
}
|
|
|
|
filled := 0
|
|
for _, item := range items {
|
|
if item {
|
|
filled++
|
|
}
|
|
}
|
|
if len(items) == 0 {
|
|
return 0
|
|
}
|
|
return filled * 100 / len(items)
|
|
}
|
|
|
|
// efAssembleDTOList 档案列表批量组装员工展示信息。
|
|
func (c *BackendEmployeeFileController) efAssembleDTOList(tid int, files []models.BackendEmployeeFile) []employeeFileDTO {
|
|
list := make([]employeeFileDTO, 0, len(files))
|
|
if len(files) == 0 {
|
|
return list
|
|
}
|
|
|
|
empIDs := make([]uint64, 0, len(files))
|
|
for _, f := range files {
|
|
empIDs = append(empIDs, f.EmployeeID)
|
|
}
|
|
var emps []models.BackendEmployee
|
|
if _, err := efEmployeeQuery(tid).Filter("id__in", empIDs).All(&emps); err != nil {
|
|
emps = nil
|
|
}
|
|
empByID := make(map[uint64]models.BackendEmployee, len(emps))
|
|
for _, e := range emps {
|
|
empByID[uint64(e.ID)] = e
|
|
}
|
|
|
|
orgNames := c.efOrgNameMap(tid)
|
|
|
|
for _, f := range files {
|
|
dto := employeeFileDTO{BackendEmployeeFile: f}
|
|
dto.Completeness = efFileCompleteness(f)
|
|
dto.HireDate = efNormalizeDate(f.HireDate)
|
|
dto.RegularDate = efNormalizeDate(f.RegularDate)
|
|
dto.LeaveDate = efNormalizeDate(f.LeaveDate)
|
|
if emp, ok := empByID[f.EmployeeID]; ok {
|
|
birthday := ""
|
|
if emp.Birthday != nil {
|
|
birthday = emp.Birthday.Format("2006-01-02")
|
|
}
|
|
affiliate := derefString(emp.AffiliateUnit)
|
|
department := derefString(emp.Department)
|
|
dto.EmployeeName = emp.Name
|
|
dto.EmployeeAccount = emp.Account
|
|
dto.Gender = emp.Gender
|
|
dto.Birthday = birthday
|
|
dto.AffiliateUnit = affiliate
|
|
dto.AffiliateUnitName = efOrgNameByID(orgNames, affiliate)
|
|
dto.Department = department
|
|
dto.DepartmentName = efOrgNameByID(orgNames, department)
|
|
dto.Position = derefString(emp.Position)
|
|
dto.Phone = derefString(emp.Phone)
|
|
dto.Email = derefString(emp.Email)
|
|
dto.Education = derefString(emp.Education)
|
|
dto.Nation = derefString(emp.Nation)
|
|
dto.HomeAddress = derefString(emp.HomeAddress)
|
|
dto.AccountStatus = emp.AccountStatus
|
|
}
|
|
list = append(list, dto)
|
|
}
|
|
return list
|
|
}
|
|
|
|
// List GET /backend/oa/employeefile/list
|
|
// 分页查询档案，支持 keyword（档案编号/身份证/员工姓名/账号/手机）、
|
|
// status（在职状态）、org_id（部门，含下级）筛选。
|
|
func (c *BackendEmployeeFileController) List() {
|
|
claims, err := c.efClaims()
|
|
if err != nil {
|
|
c.efErr(401, 401, "未登录或无权限")
|
|
return
|
|
}
|
|
tid := claims.TenantId
|
|
|
|
page, _ := c.GetInt("page", 1)
|
|
pageSize, _ := c.GetInt("pageSize", 10)
|
|
keyword := strings.TrimSpace(c.GetString("keyword"))
|
|
statusRaw := strings.TrimSpace(c.GetString("status"))
|
|
orgID, _ := c.GetUint64("org_id")
|
|
if page < 1 {
|
|
page = 1
|
|
}
|
|
if pageSize < 1 || pageSize > 200 {
|
|
pageSize = 10
|
|
}
|
|
|
|
qs := c.efQuery(tid)
|
|
|
|
if orgID > 0 {
|
|
empIDs := c.efEmployeeIDsInOrgs(tid, c.efSubtreeOrgIDs(tid, orgID))
|
|
if len(empIDs) == 0 {
|
|
c.efOk(map[string]interface{}{"list": []employeeFileDTO{}, "total": 0})
|
|
return
|
|
}
|
|
qs = qs.Filter("employee_id__in", empIDs)
|
|
}
|
|
if statusRaw != "" {
|
|
status, convErr := strconv.Atoi(statusRaw)
|
|
if convErr != nil || status < 1 || status > 3 {
|
|
c.efErr(400, 400, "在职状态参数无效")
|
|
return
|
|
}
|
|
qs = qs.Filter("employment_status", int8(status))
|
|
}
|
|
if keyword != "" {
|
|
// 关键词同时命中档案自身字段（编号/身份证）与员工字段（姓名/账号/手机）
|
|
empIDs := c.efEmployeeIDsByKeyword(tid, keyword)
|
|
cond := orm.NewCondition().
|
|
Or("file_no__icontains", keyword).
|
|
Or("id_card__icontains", keyword)
|
|
if len(empIDs) > 0 {
|
|
cond = cond.Or("employee_id__in", empIDs)
|
|
}
|
|
qs = qs.SetCond(orm.NewCondition().AndCond(cond))
|
|
}
|
|
|
|
total, _ := qs.Count()
|
|
|
|
var files []models.BackendEmployeeFile
|
|
if _, err := qs.OrderBy("-id").Limit(pageSize).Offset((page - 1) * pageSize).All(&files); err != nil && err != orm.ErrNoRows {
|
|
c.efErr(500, 500, "查询失败")
|
|
return
|
|
}
|
|
|
|
c.efOk(map[string]interface{}{
|
|
"list": c.efAssembleDTOList(tid, files),
|
|
"total": total,
|
|
})
|
|
}
|
|
|
|
// Stats GET /backend/oa/employeefile/stats
|
|
// 返回档案总数与在职状态分布，供页面顶部统计卡片展示。
|
|
func (c *BackendEmployeeFileController) Stats() {
|
|
claims, err := c.efClaims()
|
|
if err != nil {
|
|
c.efErr(401, 401, "未登录或无权限")
|
|
return
|
|
}
|
|
tid := claims.TenantId
|
|
|
|
total, _ := c.efQuery(tid).Count()
|
|
probation, _ := c.efQuery(tid).Filter("employment_status", 1).Count()
|
|
active, _ := c.efQuery(tid).Filter("employment_status", 2).Count()
|
|
resigned, _ := c.efQuery(tid).Filter("employment_status", 3).Count()
|
|
|
|
c.efOk(map[string]interface{}{
|
|
"total": total,
|
|
"probation": probation,
|
|
"active": active,
|
|
"resigned": resigned,
|
|
})
|
|
}
|
|
|
|
// Detail GET /backend/oa/employeefile/detail/:id
|
|
// 返回档案详情（含员工展示信息）与全部子记录（教育/工作/合同/证照）。
|
|
func (c *BackendEmployeeFileController) Detail() {
|
|
claims, err := c.efClaims()
|
|
if err != nil {
|
|
c.efErr(401, 401, "未登录或无权限")
|
|
return
|
|
}
|
|
tid := claims.TenantId
|
|
|
|
id, err := strconv.ParseUint(c.Ctx.Input.Param(":id"), 10, 64)
|
|
if err != nil || id == 0 {
|
|
c.efErr(400, 400, "无效ID")
|
|
return
|
|
}
|
|
|
|
var file models.BackendEmployeeFile
|
|
if err := c.efQuery(tid).Filter("id", id).One(&file); err != nil {
|
|
c.efErr(404, 404, "档案不存在")
|
|
return
|
|
}
|
|
|
|
var records []models.BackendEmployeeFileRecord
|
|
if _, err := models.Orm.QueryTable(new(models.BackendEmployeeFileRecord)).
|
|
Filter("tid", tid).
|
|
Filter("is_deleted", 0).
|
|
Filter("employee_id", file.EmployeeID).
|
|
OrderBy("sort", "id").
|
|
All(&records); err != nil && err != orm.ErrNoRows {
|
|
c.efErr(500, 500, "查询档案记录失败")
|
|
return
|
|
}
|
|
if records == nil {
|
|
records = []models.BackendEmployeeFileRecord{}
|
|
}
|
|
list := c.efAssembleDTOList(tid, []models.BackendEmployeeFile{file})
|
|
c.efOk(map[string]interface{}{"file": list[0], "records": records})
|
|
}
|
|
|
|
// employeeFilePayload 建档/编辑档案请求体。
|
|
type employeeFilePayload struct {
|
|
EmployeeID uint64 `json:"employee_id"`
|
|
FileNo string `json:"file_no"`
|
|
IDCard string `json:"id_card"`
|
|
IDCardFront string `json:"id_card_front"`
|
|
IDCardBack string `json:"id_card_back"`
|
|
EducationPhoto string `json:"education_photo"`
|
|
PoliticalStatus string `json:"political_status"`
|
|
MaritalStatus int8 `json:"marital_status"`
|
|
NativePlace string `json:"native_place"`
|
|
HouseholdAddress string `json:"household_address"`
|
|
CurrentAddress string `json:"current_address"`
|
|
EmergencyContact string `json:"emergency_contact"`
|
|
EmergencyPhone string `json:"emergency_phone"`
|
|
EmergencyRelation string `json:"emergency_relation"`
|
|
WorkEmail string `json:"work_email"`
|
|
HireDate string `json:"hire_date"`
|
|
RegularDate string `json:"regular_date"`
|
|
LeaveDate string `json:"leave_date"`
|
|
EmploymentStatus int8 `json:"employment_status"`
|
|
Remark string `json:"remark"`
|
|
}
|
|
|
|
// efParsePayload 读取并校验建档/编辑档案的请求体；校验失败时直接输出错误响应。
|
|
func (c *BackendEmployeeFileController) efParsePayload() (employeeFilePayload, bool) {
|
|
var payload employeeFilePayload
|
|
raw, err := io.ReadAll(c.Ctx.Request.Body)
|
|
if err != nil || json.Unmarshal(raw, &payload) != nil {
|
|
c.efErr(400, 400, "参数错误")
|
|
return payload, false
|
|
}
|
|
|
|
payload.FileNo = strings.TrimSpace(payload.FileNo)
|
|
payload.IDCard = strings.TrimSpace(payload.IDCard)
|
|
payload.WorkEmail = strings.TrimSpace(payload.WorkEmail)
|
|
if payload.IDCard != "" && len(payload.IDCard) > 30 {
|
|
c.efErr(400, 400, "身份证号过长")
|
|
return payload, false
|
|
}
|
|
// 证照附件地址长度限制（与列宽一致）
|
|
for label, url := range map[string]string{
|
|
"身份证正面": payload.IDCardFront,
|
|
"身份证反面": payload.IDCardBack,
|
|
"学历照片": payload.EducationPhoto,
|
|
} {
|
|
if len(url) > 500 {
|
|
c.efErr(400, 400, label+"地址过长")
|
|
return payload, false
|
|
}
|
|
}
|
|
if payload.WorkEmail != "" && !strings.Contains(payload.WorkEmail, "@") {
|
|
c.efErr(400, 400, "工作邮箱格式无效")
|
|
return payload, false
|
|
}
|
|
for label, value := range map[string]string{
|
|
"入职日期": payload.HireDate,
|
|
"转正日期": payload.RegularDate,
|
|
"离职日期": payload.LeaveDate,
|
|
} {
|
|
if !efIsValidDate(value) {
|
|
c.efErr(400, 400, label+"格式无效")
|
|
return payload, false
|
|
}
|
|
}
|
|
if payload.EmploymentStatus < 1 || payload.EmploymentStatus > 3 {
|
|
payload.EmploymentStatus = 2
|
|
}
|
|
if payload.MaritalStatus < 0 || payload.MaritalStatus > 4 {
|
|
payload.MaritalStatus = 0
|
|
}
|
|
return payload, true
|
|
}
|
|
|
|
// Create POST /backend/oa/employeefile/create
|
|
// 为员工建档；一人一档，重复建档会被唯一约束与前置校验拦截。
|
|
func (c *BackendEmployeeFileController) Create() {
|
|
claims, err := c.efClaims()
|
|
if err != nil {
|
|
c.efErr(401, 401, "未登录或无权限")
|
|
return
|
|
}
|
|
tid := claims.TenantId
|
|
|
|
payload, ok := c.efParsePayload()
|
|
if !ok {
|
|
return
|
|
}
|
|
if payload.EmployeeID == 0 {
|
|
c.efErr(400, 400, "请选择员工")
|
|
return
|
|
}
|
|
|
|
// 员工必须存在
|
|
var emp models.BackendEmployee
|
|
if err := efEmployeeQuery(tid).Filter("id", payload.EmployeeID).One(&emp); err != nil {
|
|
c.efErr(404, 404, "员工不存在")
|
|
return
|
|
}
|
|
// 一人一档
|
|
dup, _ := c.efQuery(tid).Filter("employee_id", payload.EmployeeID).Count()
|
|
if dup > 0 {
|
|
c.efErr(400, 400, "该员工已建档，请勿重复创建")
|
|
return
|
|
}
|
|
|
|
// 档案编号留空自动生成：EF + 时间戳
|
|
fileNo := payload.FileNo
|
|
if fileNo == "" {
|
|
fileNo = "EF" + time.Now().Format("20060102150405")
|
|
}
|
|
|
|
// 证照资料只能在建档完成后，于档案详情中维护；创建接口不接受附件。
|
|
payload.IDCardFront = ""
|
|
payload.IDCardBack = ""
|
|
payload.EducationPhoto = ""
|
|
|
|
now := time.Now()
|
|
item := &models.BackendEmployeeFile{
|
|
Tid: tid,
|
|
EmployeeID: payload.EmployeeID,
|
|
FileNo: fileNo,
|
|
IDCard: payload.IDCard,
|
|
IDCardFront: payload.IDCardFront,
|
|
IDCardBack: payload.IDCardBack,
|
|
EducationPhoto: payload.EducationPhoto,
|
|
PoliticalStatus: payload.PoliticalStatus,
|
|
MaritalStatus: payload.MaritalStatus,
|
|
NativePlace: payload.NativePlace,
|
|
HouseholdAddress: payload.HouseholdAddress,
|
|
CurrentAddress: payload.CurrentAddress,
|
|
EmergencyContact: payload.EmergencyContact,
|
|
EmergencyPhone: payload.EmergencyPhone,
|
|
EmergencyRelation: payload.EmergencyRelation,
|
|
WorkEmail: payload.WorkEmail,
|
|
HireDate: efDatePointer(payload.HireDate),
|
|
RegularDate: efDatePointer(payload.RegularDate),
|
|
LeaveDate: efDatePointer(payload.LeaveDate),
|
|
EmploymentStatus: payload.EmploymentStatus,
|
|
Remark: payload.Remark,
|
|
IsDeleted: 0,
|
|
CreateTime: now,
|
|
UpdateTime: &now,
|
|
}
|
|
if _, err := models.Orm.Insert(item); err != nil {
|
|
log.Printf("员工档案创建失败: tid=%d employee_id=%d err=%v", tid, payload.EmployeeID, err)
|
|
c.efErr(500, 500, "保存失败，请检查员工档案表字段及日期数据")
|
|
return
|
|
}
|
|
|
|
// 建档后同步通讯录（工作邮箱、家庭地址以档案为准）
|
|
SyncContactOnEmployeeFileChange(uint64(tid), item.EmployeeID)
|
|
|
|
c.efOk(item)
|
|
}
|
|
|
|
// Update POST /backend/oa/employeefile/update/:id
|
|
// 更新档案基本资料；员工归属（employee_id）不允许修改。
|
|
func (c *BackendEmployeeFileController) Update() {
|
|
claims, err := c.efClaims()
|
|
if err != nil {
|
|
c.efErr(401, 401, "未登录或无权限")
|
|
return
|
|
}
|
|
tid := claims.TenantId
|
|
|
|
id, err := strconv.ParseUint(c.Ctx.Input.Param(":id"), 10, 64)
|
|
if err != nil || id == 0 {
|
|
c.efErr(400, 400, "无效ID")
|
|
return
|
|
}
|
|
|
|
payload, ok := c.efParsePayload()
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
var item models.BackendEmployeeFile
|
|
if err := c.efQuery(tid).Filter("id", id).One(&item); err != nil {
|
|
c.efErr(404, 404, "档案不存在")
|
|
return
|
|
}
|
|
|
|
now := time.Now()
|
|
item.FileNo = payload.FileNo
|
|
item.IDCard = payload.IDCard
|
|
// 证照字段由 UpdateCertificates 独立维护，基础资料保存不得覆盖已有附件。
|
|
item.PoliticalStatus = payload.PoliticalStatus
|
|
item.MaritalStatus = payload.MaritalStatus
|
|
item.NativePlace = payload.NativePlace
|
|
item.HouseholdAddress = payload.HouseholdAddress
|
|
item.CurrentAddress = payload.CurrentAddress
|
|
item.EmergencyContact = payload.EmergencyContact
|
|
item.EmergencyPhone = payload.EmergencyPhone
|
|
item.EmergencyRelation = payload.EmergencyRelation
|
|
item.WorkEmail = payload.WorkEmail
|
|
item.HireDate = efDatePointer(payload.HireDate)
|
|
item.RegularDate = efDatePointer(payload.RegularDate)
|
|
item.LeaveDate = efDatePointer(payload.LeaveDate)
|
|
item.EmploymentStatus = payload.EmploymentStatus
|
|
item.Remark = payload.Remark
|
|
item.UpdateTime = &now
|
|
|
|
if _, err := models.Orm.Update(&item,
|
|
"FileNo", "IDCard", "PoliticalStatus", "MaritalStatus", "NativePlace",
|
|
"HouseholdAddress", "CurrentAddress", "EmergencyContact", "EmergencyPhone",
|
|
"EmergencyRelation", "WorkEmail", "HireDate", "RegularDate", "LeaveDate",
|
|
"EmploymentStatus", "Remark", "UpdateTime"); err != nil {
|
|
log.Printf("员工档案更新失败: tid=%d file_id=%d err=%v", tid, id, err)
|
|
c.efErr(500, 500, "保存失败，请检查员工档案表字段及日期数据")
|
|
return
|
|
}
|
|
|
|
// 档案变更后同步通讯录（工作邮箱、家庭地址以档案为准）
|
|
SyncContactOnEmployeeFileChange(uint64(tid), item.EmployeeID)
|
|
|
|
c.efOk(item)
|
|
}
|
|
|
|
// employeeFileCertificatesPayload 证照资料单独更新请求体。
|
|
// 该接口仅在档案详情中使用，避免上传附件时覆盖基础资料。
|
|
type employeeFileCertificatesPayload struct {
|
|
IDCardFront string `json:"id_card_front"`
|
|
IDCardBack string `json:"id_card_back"`
|
|
EducationPhoto string `json:"education_photo"`
|
|
}
|
|
|
|
// UpdateCertificates POST /backend/oa/employeefile/certificates/:id
|
|
// 仅更新学历照片、身份证正反面；档案必须已创建，不能通过建档接口上传。
|
|
func (c *BackendEmployeeFileController) UpdateCertificates() {
|
|
claims, err := c.efClaims()
|
|
if err != nil {
|
|
c.efErr(401, 401, "未登录或无权限")
|
|
return
|
|
}
|
|
tid := claims.TenantId
|
|
|
|
id, err := strconv.ParseUint(c.Ctx.Input.Param(":id"), 10, 64)
|
|
if err != nil || id == 0 {
|
|
c.efErr(400, 400, "无效ID")
|
|
return
|
|
}
|
|
|
|
var payload employeeFileCertificatesPayload
|
|
raw, err := io.ReadAll(c.Ctx.Request.Body)
|
|
if err != nil || json.Unmarshal(raw, &payload) != nil {
|
|
c.efErr(400, 400, "参数错误")
|
|
return
|
|
}
|
|
for label, url := range map[string]string{
|
|
"身份证正面": payload.IDCardFront,
|
|
"身份证反面": payload.IDCardBack,
|
|
"学历照片": payload.EducationPhoto,
|
|
} {
|
|
if len(url) > 500 {
|
|
c.efErr(400, 400, label+"地址过长")
|
|
return
|
|
}
|
|
}
|
|
|
|
var item models.BackendEmployeeFile
|
|
if err := c.efQuery(tid).Filter("id", id).One(&item); err != nil {
|
|
c.efErr(404, 404, "档案不存在")
|
|
return
|
|
}
|
|
|
|
now := time.Now()
|
|
item.IDCardFront = strings.TrimSpace(payload.IDCardFront)
|
|
item.IDCardBack = strings.TrimSpace(payload.IDCardBack)
|
|
item.EducationPhoto = strings.TrimSpace(payload.EducationPhoto)
|
|
item.UpdateTime = &now
|
|
if _, err := models.Orm.Update(&item,
|
|
"IDCardFront", "IDCardBack", "EducationPhoto", "UpdateTime"); err != nil {
|
|
c.efErr(500, 500, "证照保存失败")
|
|
return
|
|
}
|
|
|
|
c.efOk(item)
|
|
}
|
|
|
|
// Delete DELETE /backend/oa/employeefile/delete/:id 档案离职/禁用（档案不做删除）。
|
|
//
|
|
// 与员工同理：人事档案属于企业数据，通讯录（yz_backend_erp_contact）也以 employee_id 关联，
|
|
// 软删档案会让通讯录里对应的人失去数据来源。因此这里只把在职状态置为"离职"（3），
|
|
// 不写 is_deleted / delete_time，档案与通讯录记录始终保留可查。
|
|
// 在职状态调整（试用/正式/离职）走 update 接口即可，这里只是给"删除"动作一个不毁数据的语义。
|
|
func (c *BackendEmployeeFileController) Delete() {
|
|
claims, err := c.efClaims()
|
|
if err != nil {
|
|
c.efErr(401, 401, "未登录或无权限")
|
|
return
|
|
}
|
|
tid := claims.TenantId
|
|
|
|
id, err := strconv.ParseUint(c.Ctx.Input.Param(":id"), 10, 64)
|
|
if err != nil || id == 0 {
|
|
c.efErr(400, 400, "无效ID")
|
|
return
|
|
}
|
|
|
|
var item models.BackendEmployeeFile
|
|
if err := c.efQuery(tid).Filter("id", id).One(&item); err != nil {
|
|
c.efErr(404, 404, "档案不存在")
|
|
return
|
|
}
|
|
|
|
now := time.Now()
|
|
// 离职日期留空时补当天，保证档案资料（离职需填离职日期）完整
|
|
if item.LeaveDate == nil {
|
|
today := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
|
|
item.LeaveDate = &today
|
|
}
|
|
item.EmploymentStatus = 3
|
|
item.UpdateTime = &now
|
|
|
|
if _, err := models.Orm.Update(&item, "EmploymentStatus", "LeaveDate", "UpdateTime"); err != nil {
|
|
log.Printf("员工档案离职失败: tid=%d file_id=%d err=%v", tid, id, err)
|
|
c.efErr(500, 500, "离职操作失败")
|
|
return
|
|
}
|
|
|
|
c.efOk(nil)
|
|
}
|
|
|
|
// FiledEmployees GET /backend/oa/employeefile/filedEmployees
|
|
// 返回已建档的员工ID列表，前端用于过滤出可建档（未建档）员工。
|
|
func (c *BackendEmployeeFileController) FiledEmployees() {
|
|
claims, err := c.efClaims()
|
|
if err != nil {
|
|
c.efErr(401, 401, "未登录或无权限")
|
|
return
|
|
}
|
|
tid := claims.TenantId
|
|
|
|
var files []models.BackendEmployeeFile
|
|
if _, err := c.efQuery(tid).All(&files, "EmployeeID"); err != nil {
|
|
c.efErr(500, 500, "查询失败")
|
|
return
|
|
}
|
|
ids := make([]uint64, 0, len(files))
|
|
for _, f := range files {
|
|
ids = append(ids, f.EmployeeID)
|
|
}
|
|
c.efOk(ids)
|
|
}
|
|
|
|
// employeeFileRecordPayload 档案子记录请求体。
|
|
// type: 1-教育经历 2-工作经历 3-合同信息 4-证照附件。
|
|
type employeeFileRecordPayload struct {
|
|
EmployeeID uint64 `json:"employee_id"`
|
|
Type int8 `json:"type"`
|
|
Title string `json:"title"`
|
|
SubTitle string `json:"sub_title"`
|
|
Extra string `json:"extra"`
|
|
StartDate string `json:"start_date"`
|
|
EndDate string `json:"end_date"`
|
|
Description string `json:"description"`
|
|
AttachmentURL string `json:"attachment_url"`
|
|
Sort int `json:"sort"`
|
|
}
|
|
|
|
// efParseRecordPayload 读取并校验子记录请求体；校验失败时直接输出错误响应。
|
|
func (c *BackendEmployeeFileController) efParseRecordPayload() (employeeFileRecordPayload, bool) {
|
|
var payload employeeFileRecordPayload
|
|
raw, err := io.ReadAll(c.Ctx.Request.Body)
|
|
if err != nil || json.Unmarshal(raw, &payload) != nil {
|
|
c.efErr(400, 400, "参数错误")
|
|
return payload, false
|
|
}
|
|
|
|
if payload.EmployeeID == 0 {
|
|
c.efErr(400, 400, "参数缺少员工")
|
|
return payload, false
|
|
}
|
|
if payload.Type < 1 || payload.Type > 4 {
|
|
c.efErr(400, 400, "记录类型无效")
|
|
return payload, false
|
|
}
|
|
payload.Title = strings.TrimSpace(payload.Title)
|
|
if payload.Title == "" {
|
|
c.efErr(400, 400, "请输入名称")
|
|
return payload, false
|
|
}
|
|
if len(payload.Title) > 100 {
|
|
c.efErr(400, 400, "名称不能超过100字")
|
|
return payload, false
|
|
}
|
|
payload.StartDate = strings.TrimSpace(payload.StartDate)
|
|
payload.EndDate = strings.TrimSpace(payload.EndDate)
|
|
if !efIsValidDate(payload.StartDate) || !efIsValidDate(payload.EndDate) {
|
|
c.efErr(400, 400, "日期格式无效")
|
|
return payload, false
|
|
}
|
|
if payload.StartDate != "" && payload.EndDate != "" && payload.EndDate < payload.StartDate {
|
|
c.efErr(400, 400, "结束日期不能早于开始日期")
|
|
return payload, false
|
|
}
|
|
if len(payload.AttachmentURL) > 500 {
|
|
c.efErr(400, 400, "附件地址过长")
|
|
return payload, false
|
|
}
|
|
return payload, true
|
|
}
|
|
|
|
// CreateRecord POST /backend/oa/employeefile/record/create 新增子记录。
|
|
func (c *BackendEmployeeFileController) CreateRecord() {
|
|
claims, err := c.efClaims()
|
|
if err != nil {
|
|
c.efErr(401, 401, "未登录或无权限")
|
|
return
|
|
}
|
|
tid := claims.TenantId
|
|
|
|
payload, ok := c.efParseRecordPayload()
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
// 档案必须存在（记录挂在员工上，但以建档为前提）
|
|
exists, _ := c.efQuery(tid).Filter("employee_id", payload.EmployeeID).Count()
|
|
if exists == 0 {
|
|
c.efErr(404, 404, "档案不存在，请先建档")
|
|
return
|
|
}
|
|
|
|
now := time.Now()
|
|
item := &models.BackendEmployeeFileRecord{
|
|
Tid: tid,
|
|
EmployeeID: payload.EmployeeID,
|
|
Type: payload.Type,
|
|
Title: payload.Title,
|
|
SubTitle: payload.SubTitle,
|
|
Extra: payload.Extra,
|
|
StartDate: efDatePointer(payload.StartDate),
|
|
EndDate: efDatePointer(payload.EndDate),
|
|
Description: payload.Description,
|
|
AttachmentURL: payload.AttachmentURL,
|
|
Sort: payload.Sort,
|
|
IsDeleted: 0,
|
|
CreateTime: now,
|
|
UpdateTime: &now,
|
|
}
|
|
if _, err := models.Orm.Insert(item); err != nil {
|
|
c.efErr(500, 500, "保存失败")
|
|
return
|
|
}
|
|
|
|
c.efOk(item)
|
|
}
|
|
|
|
// UpdateRecord POST /backend/oa/employeefile/record/update/:id 更新子记录。
|
|
func (c *BackendEmployeeFileController) UpdateRecord() {
|
|
claims, err := c.efClaims()
|
|
if err != nil {
|
|
c.efErr(401, 401, "未登录或无权限")
|
|
return
|
|
}
|
|
tid := claims.TenantId
|
|
|
|
id, err := strconv.ParseUint(c.Ctx.Input.Param(":id"), 10, 64)
|
|
if err != nil || id == 0 {
|
|
c.efErr(400, 400, "无效ID")
|
|
return
|
|
}
|
|
|
|
payload, ok := c.efParseRecordPayload()
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
var item models.BackendEmployeeFileRecord
|
|
if err := models.Orm.QueryTable(new(models.BackendEmployeeFileRecord)).
|
|
Filter("tid", tid).
|
|
Filter("is_deleted", 0).
|
|
Filter("id", id).
|
|
One(&item); err != nil {
|
|
c.efErr(404, 404, "记录不存在")
|
|
return
|
|
}
|
|
|
|
now := time.Now()
|
|
item.Type = payload.Type
|
|
item.Title = payload.Title
|
|
item.SubTitle = payload.SubTitle
|
|
item.Extra = payload.Extra
|
|
item.StartDate = efDatePointer(payload.StartDate)
|
|
item.EndDate = efDatePointer(payload.EndDate)
|
|
item.Description = payload.Description
|
|
item.AttachmentURL = payload.AttachmentURL
|
|
item.Sort = payload.Sort
|
|
item.UpdateTime = &now
|
|
|
|
if _, err := models.Orm.Update(&item,
|
|
"Type", "Title", "SubTitle", "Extra", "StartDate", "EndDate",
|
|
"Description", "AttachmentURL", "Sort", "UpdateTime"); err != nil {
|
|
c.efErr(500, 500, "保存失败")
|
|
return
|
|
}
|
|
|
|
c.efOk(item)
|
|
}
|
|
|
|
// DeleteRecord DELETE /backend/oa/employeefile/record/delete/:id 软删除子记录。
|
|
func (c *BackendEmployeeFileController) DeleteRecord() {
|
|
claims, err := c.efClaims()
|
|
if err != nil {
|
|
c.efErr(401, 401, "未登录或无权限")
|
|
return
|
|
}
|
|
tid := claims.TenantId
|
|
|
|
id, err := strconv.ParseUint(c.Ctx.Input.Param(":id"), 10, 64)
|
|
if err != nil || id == 0 {
|
|
c.efErr(400, 400, "无效ID")
|
|
return
|
|
}
|
|
|
|
now := time.Now()
|
|
n, err := models.Orm.QueryTable(new(models.BackendEmployeeFileRecord)).
|
|
Filter("tid", tid).
|
|
Filter("is_deleted", 0).
|
|
Filter("id", id).
|
|
Update(map[string]interface{}{
|
|
"IsDeleted": int8(1),
|
|
"DeleteTime": now,
|
|
"UpdateTime": now,
|
|
})
|
|
if err != nil || n == 0 {
|
|
c.efErr(404, 404, "记录不存在或已删除")
|
|
return
|
|
}
|
|
|
|
c.efOk(nil)
|
|
}
|