package controllers import ( "encoding/json" "io" "log" "regexp" "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 BackendEmployeeFileController struct { beego.Controller } func (c *BackendEmployeeFileController) efClaims() (*jwtutil.Claims, error) { return identity.Claims(c.Ctx.Request.Header.Get("Authorization"), identity.EndBackend) } 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}$`) 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 } func efNormalizeDate(value *time.Time) string { if value == nil { return "" } return value.Format("2006-01-02") } 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 } func (c *BackendEmployeeFileController) efQuery(tid int) orm.QuerySeter { return models.Orm.QueryTable(new(models.BackendEmployeeFile)). Filter("tid", tid). Filter("is_deleted", 0) } func efEmployeeQuery(tid int) orm.QuerySeter { return models.Orm.QueryTable(new(models.BackendEmployee)). Filter("tid", tid). Filter("delete_time__isnull", true) } 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 } 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 } 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 } 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 } 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 } 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"` 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"` } func efFileCompleteness(file models.BackendEmployeeFile) int { items := []bool{ strings.TrimSpace(file.IDCard) != "", strings.TrimSpace(file.Education) != "", strings.TrimSpace(file.Nation) != "", 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) } 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.HomeAddress = derefString(emp.HomeAddress) dto.AccountStatus = emp.AccountStatus } list = append(list, dto) } return list } func (c *BackendEmployeeFileController) List() { claims, err := c.efClaims() if err != nil { code := identity.Status(err) c.efErr(code, code, err.Error()) 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, }) } func (c *BackendEmployeeFileController) Stats() { claims, err := c.efClaims() if err != nil { code := identity.Status(err) c.efErr(code, code, err.Error()) 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, }) } func (c *BackendEmployeeFileController) Detail() { claims, err := c.efClaims() if err != nil { code := identity.Status(err) c.efErr(code, code, err.Error()) 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}) } 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"` Education string `json:"education"` Nation string `json:"nation"` 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"` } 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.Education = strings.TrimSpace(payload.Education) payload.Nation = strings.TrimSpace(payload.Nation) 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 } func (c *BackendEmployeeFileController) Create() { claims, err := c.efClaims() if err != nil { code := identity.Status(err) c.efErr(code, code, err.Error()) 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 } 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, Education: payload.Education, Nation: payload.Nation, 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) } func (c *BackendEmployeeFileController) Update() { claims, err := c.efClaims() if err != nil { code := identity.Status(err) c.efErr(code, code, err.Error()) 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 item.PoliticalStatus = payload.PoliticalStatus item.Education = payload.Education item.Nation = payload.Nation 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", "Education", "Nation", "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) } type employeeFileCertificatesPayload struct { IDCardFront string `json:"id_card_front"` IDCardBack string `json:"id_card_back"` EducationPhoto string `json:"education_photo"` } func (c *BackendEmployeeFileController) UpdateCertificates() { claims, err := c.efClaims() if err != nil { code := identity.Status(err) c.efErr(code, code, err.Error()) 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) } func (c *BackendEmployeeFileController) Delete() { claims, err := c.efClaims() if err != nil { code := identity.Status(err) c.efErr(code, code, err.Error()) 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) } func (c *BackendEmployeeFileController) FiledEmployees() { claims, err := c.efClaims() if err != nil { code := identity.Status(err) c.efErr(code, code, err.Error()) 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) } 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"` } 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 } func (c *BackendEmployeeFileController) CreateRecord() { claims, err := c.efClaims() if err != nil { code := identity.Status(err) c.efErr(code, code, err.Error()) 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) } func (c *BackendEmployeeFileController) UpdateRecord() { claims, err := c.efClaims() if err != nil { code := identity.Status(err) c.efErr(code, code, err.Error()) 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) } func (c *BackendEmployeeFileController) DeleteRecord() { claims, err := c.efClaims() if err != nil { code := identity.Status(err) c.efErr(code, code, err.Error()) 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) }