920 lines
29 KiB
Go
920 lines
29 KiB
Go
package controllers
|
||
|
||
import (
|
||
"encoding/json"
|
||
"fmt"
|
||
"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"
|
||
)
|
||
|
||
// OA 考勤打卡：移动端签到 / 签退（app_oa_attendance.go）+ 后台考勤记录（本文件）。
|
||
//
|
||
// 打卡与排班联动的方式：
|
||
// 1. 打卡时按「员工 + 日期」查排班明细（yz_backend_oa_schedule_entry），
|
||
// 命中则把班次名称与上下班时间快照进考勤记录，并据此判定正常 / 迟到 / 早退；
|
||
// 2. 未命中排班（含员工档案缺失）不影响打卡，只把 match_status 记为 2、
|
||
// 在 clock_in_note 里写入提醒文案，前端据此做「先提醒、仍可签到」的交互；
|
||
// 3. 后台只读考勤记录 + 缺卡名单，异常说明由管理员在备注里补充。
|
||
|
||
const (
|
||
// oaAttendGraceMinutes 迟到 / 早退容差，避免卡点打卡被判异常。
|
||
oaAttendGraceMinutes = 5
|
||
// oaAttendEarlyLimitMinutes 允许提前签到的分钟数：超过则记为「不在班次时段」。
|
||
oaAttendEarlyLimitMinutes = 60
|
||
// oaAttendMaxRangeDays 单次查询的日期区间上限。
|
||
oaAttendMaxRangeDays = 92
|
||
// oaAttendMaxPageSize 分页大小上限。
|
||
oaAttendMaxPageSize = 200
|
||
)
|
||
|
||
// 考勤「当日结果」：列表与统计统一按这个口径展示。
|
||
const (
|
||
oaDayStatusNormal int8 = 1 // 正常
|
||
oaDayStatusLate int8 = 2 // 迟到
|
||
oaDayStatusEarly int8 = 3 // 早退
|
||
oaDayStatusMissing int8 = 4 // 缺卡（未签到）
|
||
oaDayStatusNoSchedule int8 = 5 // 无排班打卡
|
||
oaDayStatusOffTime int8 = 6 // 不在班次时段
|
||
oaDayStatusNoClockOut int8 = 7 // 未签退
|
||
oaDayStatusRest int8 = 8 // 未排班且未打卡（休息）
|
||
)
|
||
|
||
// oaAttendanceView 考勤记录的对外结构：时间统一转成字符串，避免前端解析 RFC3339。
|
||
type oaAttendanceView struct {
|
||
ID uint64 `json:"id"`
|
||
Uid uint64 `json:"uid"`
|
||
EmployeeID uint `json:"employee_id"`
|
||
EmployeeName string `json:"employee_name"`
|
||
EmployeeAccount string `json:"employee_account"`
|
||
OrgID uint64 `json:"org_id"`
|
||
OrgName string `json:"org_name"`
|
||
Position string `json:"position"`
|
||
AttendDate string `json:"attend_date"`
|
||
Weekday int `json:"weekday"`
|
||
EntryID uint64 `json:"entry_id"`
|
||
ShiftID uint64 `json:"shift_id"`
|
||
ShiftName string `json:"shift_name"`
|
||
ShortName string `json:"short_name"`
|
||
Color string `json:"color"`
|
||
WorkStart string `json:"work_start"`
|
||
WorkEnd string `json:"work_end"`
|
||
ShiftText string `json:"shift_text"`
|
||
MatchStatus int8 `json:"match_status"`
|
||
ClockInTime string `json:"clock_in_time"`
|
||
ClockInHm string `json:"clock_in_hm"`
|
||
ClockInStatus int8 `json:"clock_in_status"`
|
||
ClockInText string `json:"clock_in_text"`
|
||
ClockInNote string `json:"clock_in_note"`
|
||
ClockOutTime string `json:"clock_out_time"`
|
||
ClockOutHm string `json:"clock_out_hm"`
|
||
ClockOutStatus int8 `json:"clock_out_status"`
|
||
ClockOutText string `json:"clock_out_text"`
|
||
ClockOutNote string `json:"clock_out_note"`
|
||
Location string `json:"location"`
|
||
Remark string `json:"remark"`
|
||
Source int8 `json:"source"`
|
||
DayStatus int8 `json:"day_status"`
|
||
DayStatusText string `json:"day_status_text"`
|
||
CreateTime string `json:"create_time"`
|
||
}
|
||
|
||
// BackendOaAttendanceController 后台考勤记录（只读 + 备注）。
|
||
type BackendOaAttendanceController struct {
|
||
beego.Controller
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// 认证与响应
|
||
// ---------------------------------------------------------------------------
|
||
|
||
func (c *BackendOaAttendanceController) atClaims() (*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 *BackendOaAttendanceController) atOperator() (uint64, uint64, bool) {
|
||
claims, ok := c.atClaims()
|
||
if !ok {
|
||
c.atFail(401, 401, "未登录或登录已过期")
|
||
return 0, 0, false
|
||
}
|
||
return uint64(claims.TenantId), uint64(claims.UserID), true
|
||
}
|
||
|
||
func (c *BackendOaAttendanceController) atOK(data interface{}) {
|
||
c.Data["json"] = map[string]interface{}{"code": 200, "msg": "success", "data": data}
|
||
_ = c.ServeJSON()
|
||
}
|
||
|
||
func (c *BackendOaAttendanceController) atFail(httpStatus, bizCode int, msg string) {
|
||
if httpStatus > 0 {
|
||
c.Ctx.Output.SetStatus(httpStatus)
|
||
}
|
||
c.Data["json"] = map[string]interface{}{"code": bizCode, "msg": msg}
|
||
_ = c.ServeJSON()
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// 通用工具
|
||
// ---------------------------------------------------------------------------
|
||
|
||
// oaAttendQuery 本租户考勤记录查询。
|
||
func oaAttendQuery(tid uint64) orm.QuerySeter {
|
||
return models.Orm.QueryTable(new(models.OaAttendance)).Filter("tid", tid)
|
||
}
|
||
|
||
// oaAttendFind 取某人某天的考勤记录：有员工档案按员工，否则按登录身份兜底。
|
||
func oaAttendFind(tid uint64, date string, employeeID uint, uid uint64) *models.OaAttendance {
|
||
qs := oaAttendQuery(tid).Filter("attend_date", date)
|
||
switch {
|
||
case employeeID > 0:
|
||
qs = qs.Filter("employee_id", employeeID)
|
||
case uid > 0:
|
||
qs = qs.Filter("uid", uid)
|
||
default:
|
||
return nil
|
||
}
|
||
var row models.OaAttendance
|
||
if err := qs.OrderBy("-id").Limit(1).One(&row); err != nil {
|
||
return nil
|
||
}
|
||
return &row
|
||
}
|
||
|
||
// oaAttendEntryOf 取某员工某天的排班明细（一人一天一条有效记录）。
|
||
func oaAttendEntryOf(tid uint64, employeeID uint, date string) *models.OaScheduleEntry {
|
||
if employeeID == 0 {
|
||
return nil
|
||
}
|
||
var rows []models.OaScheduleEntry
|
||
_, err := models.Orm.QueryTable(new(models.OaScheduleEntry)).
|
||
Filter("tid", tid).
|
||
Filter("employee_id", employeeID).
|
||
Filter("schedule_date", date).
|
||
Filter("is_deleted", 0).
|
||
OrderBy("-id").Limit(1).All(&rows)
|
||
if err != nil || len(rows) == 0 {
|
||
return nil
|
||
}
|
||
entry := rows[0]
|
||
entry.ScheduleDate = normalizeOaDate(entry.ScheduleDate)
|
||
return &entry
|
||
}
|
||
|
||
// oaAttendOrgName 组织名称快照（失败返回空串，不影响打卡）。
|
||
func oaAttendOrgName(tid, orgID uint64) string {
|
||
if orgID == 0 {
|
||
return ""
|
||
}
|
||
var org models.BackendOrganization
|
||
if err := models.Orm.QueryTable(new(models.BackendOrganization)).
|
||
Filter("tid", tid).Filter("id", orgID).One(&org); err != nil {
|
||
return ""
|
||
}
|
||
return org.OrgName
|
||
}
|
||
|
||
// oaAttendOrgIDs 把组织节点展开成「自身 + 下级」的 ID 列表；org_id=0 表示不限。
|
||
func oaAttendOrgIDs(tid, root uint64, includeChild bool) []uint64 {
|
||
if root == 0 {
|
||
return nil
|
||
}
|
||
if !includeChild {
|
||
return []uint64{root}
|
||
}
|
||
var rows []models.BackendOrganization
|
||
_, err := models.Orm.QueryTable(new(models.BackendOrganization)).
|
||
Filter("tid", tid).
|
||
Filter("delete_time__isnull", true).
|
||
All(&rows)
|
||
if err != nil {
|
||
return []uint64{root}
|
||
}
|
||
children := map[uint64][]uint64{}
|
||
for i := range rows {
|
||
children[rows[i].ParentID] = append(children[rows[i].ParentID], rows[i].ID)
|
||
}
|
||
seen := map[uint64]bool{}
|
||
queue := []uint64{root}
|
||
for len(queue) > 0 {
|
||
current := queue[0]
|
||
queue = queue[1:]
|
||
if seen[current] {
|
||
continue
|
||
}
|
||
seen[current] = true
|
||
queue = append(queue, children[current]...)
|
||
}
|
||
out := make([]uint64, 0, len(seen))
|
||
for id := range seen {
|
||
out = append(out, id)
|
||
}
|
||
return out
|
||
}
|
||
|
||
// oaAttendWeekday 返回 1=周一 ... 7=周日。
|
||
func oaAttendWeekday(date string) int {
|
||
parsed, ok := scParseDate(date)
|
||
if !ok {
|
||
return 0
|
||
}
|
||
weekday := int(parsed.Weekday())
|
||
if weekday == 0 {
|
||
return 7
|
||
}
|
||
return weekday
|
||
}
|
||
|
||
// oaAttendShiftText 班次时间文案。
|
||
func oaAttendShiftText(workStart, workEnd string) string {
|
||
if workStart == "" || workEnd == "" {
|
||
return "未排班"
|
||
}
|
||
return workStart + "-" + workEnd
|
||
}
|
||
|
||
func oaAttendClockText(status int8, isOut bool) string {
|
||
switch status {
|
||
case models.OaAttendClockNone:
|
||
return "未打卡"
|
||
case models.OaAttendClockNormal:
|
||
return "正常"
|
||
case models.OaAttendClockLate:
|
||
if isOut {
|
||
return "早退"
|
||
}
|
||
return "迟到"
|
||
case models.OaAttendClockNoShift:
|
||
return "无排班"
|
||
case models.OaAttendClockOffTime:
|
||
return "时段异常"
|
||
}
|
||
return "未打卡"
|
||
}
|
||
|
||
// oaAttendDayResult 汇总「当天」的考勤结果，列表与统计共用同一口径。
|
||
func oaAttendDayResult(clockIn string, clockInStatus int8, clockOut string, clockOutStatus int8, matchStatus int8) (int8, string) {
|
||
switch {
|
||
case clockIn == "":
|
||
return oaDayStatusMissing, "缺卡"
|
||
case matchStatus == models.OaAttendMatchMissing:
|
||
return oaDayStatusNoSchedule, "无排班"
|
||
case clockInStatus == models.OaAttendClockLate:
|
||
return oaDayStatusLate, "迟到"
|
||
case clockOutStatus == models.OaAttendClockLate:
|
||
return oaDayStatusEarly, "早退"
|
||
case clockInStatus == models.OaAttendClockOffTime || clockOutStatus == models.OaAttendClockOffTime:
|
||
return oaDayStatusOffTime, "时段异常"
|
||
case clockOut == "":
|
||
return oaDayStatusNoClockOut, "未签退"
|
||
}
|
||
return oaDayStatusNormal, "正常"
|
||
}
|
||
|
||
// oaAttendView 记录 → 视图。
|
||
func oaAttendView(row *models.OaAttendance) oaAttendanceView {
|
||
date := normalizeOaDate(row.AttendDate)
|
||
inTime, inHm := "", ""
|
||
if row.ClockInTime != nil {
|
||
inTime = row.ClockInTime.Format("2006-01-02 15:04:05")
|
||
inHm = row.ClockInTime.Format("15:04")
|
||
}
|
||
outTime, outHm := "", ""
|
||
if row.ClockOutTime != nil {
|
||
outTime = row.ClockOutTime.Format("2006-01-02 15:04:05")
|
||
outHm = row.ClockOutTime.Format("15:04")
|
||
}
|
||
dayStatus, dayText := oaAttendDayResult(inHm, row.ClockInStatus, outHm, row.ClockOutStatus, row.MatchStatus)
|
||
return oaAttendanceView{
|
||
ID: row.ID,
|
||
Uid: row.Uid,
|
||
EmployeeID: row.EmployeeID,
|
||
EmployeeName: row.EmployeeName,
|
||
EmployeeAccount: row.EmployeeAccount,
|
||
OrgID: row.OrgID,
|
||
OrgName: row.OrgName,
|
||
Position: row.Position,
|
||
AttendDate: date,
|
||
Weekday: oaAttendWeekday(date),
|
||
EntryID: row.EntryID,
|
||
ShiftID: row.ShiftID,
|
||
ShiftName: row.ShiftName,
|
||
ShortName: row.ShortName,
|
||
Color: row.Color,
|
||
WorkStart: row.WorkStart,
|
||
WorkEnd: row.WorkEnd,
|
||
ShiftText: oaAttendShiftText(row.WorkStart, row.WorkEnd),
|
||
MatchStatus: row.MatchStatus,
|
||
ClockInTime: inTime,
|
||
ClockInHm: inHm,
|
||
ClockInStatus: row.ClockInStatus,
|
||
ClockInText: oaAttendClockText(row.ClockInStatus, false),
|
||
ClockInNote: row.ClockInNote,
|
||
ClockOutTime: outTime,
|
||
ClockOutHm: outHm,
|
||
ClockOutStatus: row.ClockOutStatus,
|
||
ClockOutText: oaAttendClockText(row.ClockOutStatus, true),
|
||
ClockOutNote: row.ClockOutNote,
|
||
Location: row.Location,
|
||
Remark: row.Remark,
|
||
Source: row.Source,
|
||
DayStatus: dayStatus,
|
||
DayStatusText: dayText,
|
||
CreateTime: row.CreateTime.Format("2006-01-02 15:04:05"),
|
||
}
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// 打卡核心（移动端与后续补录共用）
|
||
// ---------------------------------------------------------------------------
|
||
|
||
// oaAttendPunchInput 打卡入参。
|
||
type oaAttendPunchInput struct {
|
||
Type string // in=签到 out=签退
|
||
Location string
|
||
Remark string
|
||
FallbackName string // 员工档案缺失时用于展示的姓名
|
||
}
|
||
|
||
// oaAttendPunchResult 打卡结果。
|
||
type oaAttendPunchResult struct {
|
||
View oaAttendanceView
|
||
Warning string
|
||
Duplicated bool
|
||
Message string
|
||
}
|
||
|
||
// oaShiftWindow 把班次上下班换算成当日分钟区间；下班早于上班视为跨天班次。
|
||
func oaShiftWindow(workStart, workEnd string) (int, int, bool) {
|
||
start, okStart := scMinutes(workStart)
|
||
end, okEnd := scMinutes(workEnd)
|
||
if !okStart || !okEnd {
|
||
return 0, 0, false
|
||
}
|
||
if end <= start {
|
||
end += 24 * 60
|
||
}
|
||
return start, end, true
|
||
}
|
||
|
||
// oaShiftNowMinutes 把当前时刻换算到班次时间轴上（跨天班次凌晨时刻 +24h）。
|
||
func oaShiftNowMinutes(now time.Time, startMinutes int) int {
|
||
value := now.Hour()*60 + now.Minute()
|
||
if startMinutes >= 12*60 && value < startMinutes {
|
||
value += 24 * 60
|
||
}
|
||
return value
|
||
}
|
||
|
||
// oaAttendClockInStatus 签到结果判定：无排班 / 时段异常只提醒，不阻断打卡。
|
||
func oaAttendClockInStatus(row *models.OaAttendance, now time.Time) (int8, string) {
|
||
start, _, ok := oaShiftWindow(row.WorkStart, row.WorkEnd)
|
||
if !ok {
|
||
if row.MatchStatus == models.OaAttendMatchMissing {
|
||
return models.OaAttendClockNoShift, "今日未匹配到排班，已记录为「无排班打卡」，请联系管理员核对排班"
|
||
}
|
||
return models.OaAttendClockOffTime, "班次未配置上下班时间，已记录签到，请核对班次设置"
|
||
}
|
||
nowMinutes := oaShiftNowMinutes(now, start)
|
||
switch {
|
||
case nowMinutes < start-oaAttendEarlyLimitMinutes:
|
||
return models.OaAttendClockOffTime, fmt.Sprintf("当前时间不在班次时段内（班次 %s-%s），已记录签到",
|
||
row.WorkStart, row.WorkEnd)
|
||
case nowMinutes > start+oaAttendGraceMinutes:
|
||
return models.OaAttendClockLate, fmt.Sprintf("迟到 %d 分钟（应到 %s），已记录签到",
|
||
nowMinutes-start, row.WorkStart)
|
||
}
|
||
return models.OaAttendClockNormal, ""
|
||
}
|
||
|
||
// oaAttendClockOutStatus 签退结果判定：早退只提醒，不阻断打卡。
|
||
func oaAttendClockOutStatus(row *models.OaAttendance, now time.Time) (int8, string) {
|
||
start, end, ok := oaShiftWindow(row.WorkStart, row.WorkEnd)
|
||
if !ok {
|
||
if row.MatchStatus == models.OaAttendMatchMissing {
|
||
return models.OaAttendClockNoShift, "今日未匹配到排班，已记录为「无排班签退」，请联系管理员核对排班"
|
||
}
|
||
return models.OaAttendClockOffTime, "班次未配置上下班时间，已记录签退，请核对班次设置"
|
||
}
|
||
nowMinutes := oaShiftNowMinutes(now, start)
|
||
if nowMinutes < end-oaAttendGraceMinutes {
|
||
return models.OaAttendClockLate, fmt.Sprintf("早退 %d 分钟（应退 %s），已记录签退",
|
||
end-nowMinutes, row.WorkEnd)
|
||
}
|
||
return models.OaAttendClockNormal, ""
|
||
}
|
||
|
||
// oaAttendPrevOpen 跨天班次兜底：昨天签到未签退、且班次为跨天班次时，
|
||
// 今天的签退落到昨天那条记录上，避免凌晨签退被记成新的一天。
|
||
func oaAttendPrevOpen(tid uint64, uid uint64, employeeID uint, date string) *models.OaAttendance {
|
||
prevDate := nextOaDate(date, -1)
|
||
if prevDate == "" {
|
||
return nil
|
||
}
|
||
row := oaAttendFind(tid, prevDate, employeeID, uid)
|
||
if row == nil || row.ClockInTime == nil || row.ClockOutTime != nil {
|
||
return nil
|
||
}
|
||
start, end, ok := oaShiftWindow(row.WorkStart, row.WorkEnd)
|
||
if !ok || end <= start || end <= 24*60 {
|
||
return nil
|
||
}
|
||
return row
|
||
}
|
||
|
||
// oaAttendPunch 考勤打卡核心：写库并返回记录、提醒文案与是否重复打卡。
|
||
func oaAttendPunch(tid, uid uint64, employee *models.BackendEmployee, input oaAttendPunchInput) (*oaAttendPunchResult, int, string) {
|
||
clockType := strings.ToLower(strings.TrimSpace(input.Type))
|
||
if clockType != "in" && clockType != "out" {
|
||
return nil, 400, "打卡类型无效"
|
||
}
|
||
|
||
now := time.Now()
|
||
date := now.Format("2006-01-02")
|
||
|
||
employeeID := uint(0)
|
||
name := strings.TrimSpace(input.FallbackName)
|
||
account := ""
|
||
orgID := uint64(0)
|
||
orgName := ""
|
||
position := ""
|
||
if employee != nil {
|
||
employeeID = employee.ID
|
||
name = employee.Name
|
||
account = employee.Account
|
||
orgID = scEmployeeDepartmentID(*employee)
|
||
orgName = oaAttendOrgName(tid, orgID)
|
||
if employee.Position != nil {
|
||
position = strings.TrimSpace(*employee.Position)
|
||
}
|
||
}
|
||
if name == "" {
|
||
name = "未知员工"
|
||
}
|
||
|
||
row := oaAttendFind(tid, date, employeeID, uid)
|
||
if clockType == "out" && (row == nil || row.ClockInTime == nil) {
|
||
if prev := oaAttendPrevOpen(tid, uid, employeeID, date); prev != nil {
|
||
row = prev
|
||
}
|
||
}
|
||
created := row == nil
|
||
if created {
|
||
row = &models.OaAttendance{
|
||
Tid: int(tid),
|
||
Uid: uid,
|
||
EmployeeID: employeeID,
|
||
EmployeeName: name,
|
||
EmployeeAccount: account,
|
||
OrgID: orgID,
|
||
OrgName: orgName,
|
||
Position: position,
|
||
AttendDate: date,
|
||
MatchStatus: models.OaAttendMatchUnknown,
|
||
Source: models.OaAttendSourceApp,
|
||
}
|
||
} else if row.EmployeeID == 0 && employeeID > 0 {
|
||
// 早前未绑定员工档案时打的卡，补齐员工信息
|
||
row.EmployeeID = employeeID
|
||
row.EmployeeName = name
|
||
row.EmployeeAccount = account
|
||
row.OrgID = orgID
|
||
row.OrgName = orgName
|
||
row.Position = position
|
||
}
|
||
|
||
// 排班快照：以打卡时的排班为准，后续调班不影响历史记录
|
||
if entry := oaAttendEntryOf(tid, employeeID, normalizeOaDate(row.AttendDate)); entry != nil {
|
||
row.EntryID = entry.ID
|
||
row.ShiftID = entry.ShiftID
|
||
row.ShiftName = entry.ShiftName
|
||
row.ShortName = entry.ShortName
|
||
row.Color = entry.Color
|
||
row.WorkStart = entry.WorkStart
|
||
row.WorkEnd = entry.WorkEnd
|
||
row.MatchStatus = models.OaAttendMatchOK
|
||
} else if created {
|
||
row.MatchStatus = models.OaAttendMatchMissing
|
||
}
|
||
|
||
warning := ""
|
||
switch clockType {
|
||
case "in":
|
||
if row.ClockInTime != nil {
|
||
return &oaAttendPunchResult{
|
||
View: oaAttendView(row),
|
||
Warning: "今日已于 " + row.ClockInTime.Format("15:04") + " 签到，无需重复签到",
|
||
Duplicated: true,
|
||
Message: "今日已签到",
|
||
}, 200, ""
|
||
}
|
||
row.ClockInTime = &now
|
||
row.ClockInStatus, warning = oaAttendClockInStatus(row, now)
|
||
row.ClockInNote = warning
|
||
if input.Location != "" {
|
||
row.Location = input.Location
|
||
}
|
||
case "out":
|
||
if row.ClockOutTime != nil {
|
||
return &oaAttendPunchResult{
|
||
View: oaAttendView(row),
|
||
Warning: "今日已于 " + row.ClockOutTime.Format("15:04") + " 签退，无需重复签退",
|
||
Duplicated: true,
|
||
Message: "今日已签退",
|
||
}, 200, ""
|
||
}
|
||
if row.ClockInTime == nil {
|
||
warning = "今日尚未签到，本次签退已记录，请联系管理员核实"
|
||
}
|
||
row.ClockOutTime = &now
|
||
status, msg := oaAttendClockOutStatus(row, now)
|
||
row.ClockOutStatus = status
|
||
notes := make([]string, 0, 2)
|
||
if warning != "" {
|
||
notes = append(notes, warning)
|
||
}
|
||
if msg != "" {
|
||
notes = append(notes, msg)
|
||
if warning == "" {
|
||
warning = msg
|
||
}
|
||
}
|
||
row.ClockOutNote = strings.Join(notes, "；")
|
||
}
|
||
if input.Remark != "" {
|
||
row.Remark = input.Remark
|
||
}
|
||
|
||
fields := []string{
|
||
"uid", "employee_id", "employee_name", "employee_account", "org_id", "org_name", "position",
|
||
"entry_id", "shift_id", "shift_name", "short_name", "color", "work_start", "work_end", "match_status",
|
||
"clock_in_time", "clock_in_status", "clock_in_note",
|
||
"clock_out_time", "clock_out_status", "clock_out_note",
|
||
"location", "remark", "source",
|
||
}
|
||
if created {
|
||
if _, err := models.Orm.Insert(row); err != nil {
|
||
// 并发下唯一键冲突：按已打卡返回，避免前端误判失败
|
||
if exist := oaAttendFind(tid, date, employeeID, uid); exist != nil {
|
||
return &oaAttendPunchResult{
|
||
View: oaAttendView(exist),
|
||
Warning: "今日已打卡，请勿重复操作",
|
||
Duplicated: true,
|
||
Message: "今日已打卡",
|
||
}, 200, ""
|
||
}
|
||
return nil, 500, "打卡失败，请稍后重试"
|
||
}
|
||
} else if _, err := models.Orm.Update(row, fields...); err != nil {
|
||
return nil, 500, "打卡失败，请稍后重试"
|
||
}
|
||
|
||
message := "签到成功"
|
||
if clockType == "out" {
|
||
message = "签退成功"
|
||
}
|
||
return &oaAttendPunchResult{
|
||
View: oaAttendView(row),
|
||
Warning: warning,
|
||
Message: message,
|
||
}, 200, ""
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// 统计
|
||
// ---------------------------------------------------------------------------
|
||
|
||
// oaAttendStats 区间考勤统计：应出勤按排班明细统计，实出勤按已签到（含无排班打卡）。
|
||
// orgIDs 非空时按组织过滤；employeeID>0 时只统计该员工。
|
||
func oaAttendStats(tid uint64, startDate, endDate string, orgIDs []uint64, employeeID uint) map[string]interface{} {
|
||
entryQS := models.Orm.QueryTable(new(models.OaScheduleEntry)).
|
||
Filter("tid", tid).
|
||
Filter("is_deleted", 0).
|
||
Filter("schedule_date__gte", startDate).
|
||
Filter("schedule_date__lte", endDate)
|
||
if len(orgIDs) > 0 {
|
||
entryQS = entryQS.Filter("org_id__in", orgIDs)
|
||
}
|
||
if employeeID > 0 {
|
||
entryQS = entryQS.Filter("employee_id", employeeID)
|
||
}
|
||
scheduled, _ := entryQS.Count()
|
||
|
||
recordQS := oaAttendQuery(tid).
|
||
Filter("attend_date__gte", startDate).
|
||
Filter("attend_date__lte", endDate)
|
||
if len(orgIDs) > 0 {
|
||
recordQS = recordQS.Filter("org_id__in", orgIDs)
|
||
}
|
||
if employeeID > 0 {
|
||
recordQS = recordQS.Filter("employee_id", employeeID)
|
||
}
|
||
total, _ := recordQS.Count()
|
||
|
||
baseCond := func() *orm.Condition {
|
||
cond := orm.NewCondition().
|
||
And("tid", tid).
|
||
And("attend_date__gte", startDate).
|
||
And("attend_date__lte", endDate)
|
||
if len(orgIDs) > 0 {
|
||
cond = cond.And("org_id__in", orgIDs)
|
||
}
|
||
if employeeID > 0 {
|
||
cond = cond.And("employee_id", employeeID)
|
||
}
|
||
return cond
|
||
}
|
||
countWith := func(cond *orm.Condition) int64 {
|
||
n, _ := models.Orm.QueryTable(new(models.OaAttendance)).SetCond(cond).Count()
|
||
return n
|
||
}
|
||
|
||
clocked := countWith(baseCond().And("clock_in_time__isnull", false))
|
||
late := countWith(baseCond().And("clock_in_status", models.OaAttendClockLate))
|
||
early := countWith(baseCond().And("clock_out_status", models.OaAttendClockLate))
|
||
noSchedule := countWith(baseCond().And("match_status", models.OaAttendMatchMissing))
|
||
matchedClockIn := countWith(baseCond().
|
||
And("clock_in_time__isnull", false).
|
||
And("match_status", models.OaAttendMatchOK))
|
||
missing := scheduled - matchedClockIn
|
||
if missing < 0 {
|
||
missing = 0
|
||
}
|
||
|
||
rate := 0
|
||
if scheduled > 0 {
|
||
rate = int(matchedClockIn * 100 / scheduled)
|
||
}
|
||
|
||
return map[string]interface{}{
|
||
"scheduled": scheduled,
|
||
"records": total,
|
||
"clocked": clocked,
|
||
"late": late,
|
||
"early": early,
|
||
"noschedule": noSchedule,
|
||
"missing": missing,
|
||
"attendance_rate": rate,
|
||
}
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// 后台：考勤记录
|
||
// ---------------------------------------------------------------------------
|
||
|
||
// RecordList 后台考勤记录列表。
|
||
// GET /backend/oa/attendance/records?page=&pageSize=&start_date=&end_date=
|
||
//
|
||
// &keyword=&org_id=&include_child=1&employee_id=&status=&match_status=
|
||
func (c *BackendOaAttendanceController) RecordList() {
|
||
tid, _, ok := c.atOperator()
|
||
if !ok {
|
||
return
|
||
}
|
||
|
||
page, _ := c.GetInt("page", 1)
|
||
pageSize, _ := c.GetInt("pageSize", 20)
|
||
if page < 1 {
|
||
page = 1
|
||
}
|
||
if pageSize < 1 || pageSize > oaAttendMaxPageSize {
|
||
pageSize = 20
|
||
}
|
||
|
||
startDate := strings.TrimSpace(c.GetString("start_date"))
|
||
endDate := strings.TrimSpace(c.GetString("end_date"))
|
||
if startDate == "" || endDate == "" {
|
||
now := time.Now()
|
||
start := time.Date(now.Year(), now.Month(), 1, 0, 0, 0, 0, now.Location())
|
||
startDate = start.Format("2006-01-02")
|
||
endDate = now.Format("2006-01-02")
|
||
}
|
||
dates, msg := scDateSpan(startDate, endDate)
|
||
if msg != "" {
|
||
c.atFail(400, 400, msg)
|
||
return
|
||
}
|
||
if len(dates) > oaAttendMaxRangeDays {
|
||
c.atFail(400, 400, fmt.Sprintf("单次最多查询 %d 天", oaAttendMaxRangeDays))
|
||
return
|
||
}
|
||
|
||
orgID := uint64(0)
|
||
if raw := strings.TrimSpace(c.GetString("org_id")); raw != "" {
|
||
if parsed, err := strconvParseUint(raw); err == nil {
|
||
orgID = parsed
|
||
}
|
||
}
|
||
includeChild := c.GetString("include_child") != "0"
|
||
orgIDs := oaAttendOrgIDs(tid, orgID, includeChild)
|
||
|
||
keyword := strings.TrimSpace(c.GetString("keyword"))
|
||
employeeID := uint(0)
|
||
if raw := strings.TrimSpace(c.GetString("employee_id")); raw != "" {
|
||
if parsed, err := strconv.ParseUint(raw, 10, 64); err == nil {
|
||
employeeID = uint(parsed)
|
||
}
|
||
}
|
||
// uid：未绑定员工档案的打卡按登录身份归属，汇总行展开明细时用
|
||
uid := uint64(0)
|
||
if raw := strings.TrimSpace(c.GetString("uid")); raw != "" {
|
||
if parsed, err := strconv.ParseUint(raw, 10, 64); err == nil {
|
||
uid = parsed
|
||
}
|
||
}
|
||
status := strings.TrimSpace(c.GetString("status"))
|
||
matchStatus := strings.TrimSpace(c.GetString("match_status"))
|
||
|
||
cond := orm.NewCondition().
|
||
And("tid", tid).
|
||
And("attend_date__gte", startDate).
|
||
And("attend_date__lte", endDate)
|
||
if len(orgIDs) > 0 {
|
||
cond = cond.And("org_id__in", orgIDs)
|
||
}
|
||
if employeeID > 0 {
|
||
cond = cond.And("employee_id", employeeID)
|
||
}
|
||
if uid > 0 {
|
||
cond = cond.And("uid", uid)
|
||
}
|
||
if keyword != "" {
|
||
cond = cond.AndCond(orm.NewCondition().
|
||
Or("employee_name__icontains", keyword).
|
||
Or("employee_account__icontains", keyword))
|
||
}
|
||
if matchStatus == "1" || matchStatus == "2" {
|
||
value, _ := strconv.Atoi(matchStatus)
|
||
cond = cond.And("match_status", int8(value))
|
||
}
|
||
switch status {
|
||
case "normal":
|
||
cond = cond.And("clock_in_status", models.OaAttendClockNormal)
|
||
case "late":
|
||
cond = cond.And("clock_in_status", models.OaAttendClockLate)
|
||
case "early":
|
||
cond = cond.And("clock_out_status", models.OaAttendClockLate)
|
||
case "noschedule":
|
||
cond = cond.And("match_status", models.OaAttendMatchMissing)
|
||
case "missing":
|
||
cond = cond.And("clock_in_time__isnull", true)
|
||
case "offtime":
|
||
cond = cond.AndCond(orm.NewCondition().
|
||
Or("clock_in_status", models.OaAttendClockOffTime).
|
||
Or("clock_out_status", models.OaAttendClockOffTime))
|
||
}
|
||
|
||
qs := models.Orm.QueryTable(new(models.OaAttendance)).SetCond(cond)
|
||
total, _ := qs.Count()
|
||
var rows []models.OaAttendance
|
||
_, err := qs.OrderBy("-attend_date", "employee_name", "id").
|
||
Limit(pageSize).Offset((page - 1) * pageSize).All(&rows)
|
||
if err != nil && err != orm.ErrNoRows {
|
||
c.atFail(500, 500, "查询考勤记录失败: "+err.Error())
|
||
return
|
||
}
|
||
|
||
list := make([]oaAttendanceView, 0, len(rows))
|
||
for i := range rows {
|
||
list = append(list, oaAttendView(&rows[i]))
|
||
}
|
||
|
||
c.atOK(map[string]interface{}{
|
||
"list": list,
|
||
"total": total,
|
||
"start_date": startDate,
|
||
"end_date": endDate,
|
||
"stats": oaAttendStats(tid, startDate, endDate, orgIDs, employeeID),
|
||
})
|
||
}
|
||
|
||
// MissingList 缺卡名单：指定日期有排班但未签到的人。
|
||
// GET /backend/oa/attendance/missing?date=&org_id=&include_child=1&keyword=
|
||
func (c *BackendOaAttendanceController) MissingList() {
|
||
tid, _, ok := c.atOperator()
|
||
if !ok {
|
||
return
|
||
}
|
||
|
||
date := strings.TrimSpace(c.GetString("date"))
|
||
if !isValidOaDate(date) {
|
||
date = time.Now().Format("2006-01-02")
|
||
}
|
||
orgID := uint64(0)
|
||
if raw := strings.TrimSpace(c.GetString("org_id")); raw != "" {
|
||
if parsed, err := strconvParseUint(raw); err == nil {
|
||
orgID = parsed
|
||
}
|
||
}
|
||
orgIDs := oaAttendOrgIDs(tid, orgID, c.GetString("include_child") != "0")
|
||
keyword := strings.TrimSpace(c.GetString("keyword"))
|
||
|
||
entryQS := models.Orm.QueryTable(new(models.OaScheduleEntry)).
|
||
Filter("tid", tid).
|
||
Filter("is_deleted", 0).
|
||
Filter("schedule_date", date)
|
||
if len(orgIDs) > 0 {
|
||
entryQS = entryQS.Filter("org_id__in", orgIDs)
|
||
}
|
||
if keyword != "" {
|
||
entryQS = entryQS.Filter("employee_name__icontains", keyword)
|
||
}
|
||
var entries []models.OaScheduleEntry
|
||
_, err := entryQS.OrderBy("org_id", "employee_name").Limit(1000).All(&entries)
|
||
if err != nil && err != orm.ErrNoRows {
|
||
c.atFail(500, 500, "查询排班失败: "+err.Error())
|
||
return
|
||
}
|
||
|
||
clocked := map[uint]bool{}
|
||
var records []models.OaAttendance
|
||
recordQS := oaAttendQuery(tid).Filter("attend_date", date).Filter("clock_in_time__isnull", false)
|
||
if len(orgIDs) > 0 {
|
||
recordQS = recordQS.Filter("org_id__in", orgIDs)
|
||
}
|
||
_, _ = recordQS.All(&records)
|
||
for i := range records {
|
||
clocked[records[i].EmployeeID] = true
|
||
}
|
||
|
||
list := make([]map[string]interface{}, 0, len(entries))
|
||
for i := range entries {
|
||
entry := entries[i]
|
||
if clocked[entry.EmployeeID] {
|
||
continue
|
||
}
|
||
list = append(list, map[string]interface{}{
|
||
"employee_id": entry.EmployeeID,
|
||
"employee_name": entry.EmployeeName,
|
||
"employee_account": entry.EmployeeAccount,
|
||
"org_id": entry.OrgID,
|
||
"org_name": entry.OrgName,
|
||
"position": entry.Position,
|
||
"date": normalizeOaDate(entry.ScheduleDate),
|
||
"shift_id": entry.ShiftID,
|
||
"shift_name": entry.ShiftName,
|
||
"color": entry.Color,
|
||
"work_start": entry.WorkStart,
|
||
"work_end": entry.WorkEnd,
|
||
"shift_text": oaAttendShiftText(entry.WorkStart, entry.WorkEnd),
|
||
})
|
||
}
|
||
|
||
c.atOK(map[string]interface{}{
|
||
"date": date,
|
||
"list": list,
|
||
"total": len(list),
|
||
})
|
||
}
|
||
|
||
// RecordRemark 管理员备注 / 异常说明。
|
||
// POST /backend/oa/attendance/remark/:id body: {"remark": "..."}
|
||
func (c *BackendOaAttendanceController) RecordRemark() {
|
||
tid, _, ok := c.atOperator()
|
||
if !ok {
|
||
return
|
||
}
|
||
id, err := strconv.ParseUint(strings.TrimSpace(c.Ctx.Input.Param(":id")), 10, 64)
|
||
if err != nil || id == 0 {
|
||
c.atFail(400, 400, "无效的记录ID")
|
||
return
|
||
}
|
||
var payload struct {
|
||
Remark string `json:"remark"`
|
||
}
|
||
if len(c.Ctx.Input.RequestBody) > 0 {
|
||
if err := json.Unmarshal(c.Ctx.Input.RequestBody, &payload); err != nil {
|
||
c.atFail(400, 400, "参数错误")
|
||
return
|
||
}
|
||
}
|
||
remark := strings.TrimSpace(payload.Remark)
|
||
if len([]rune(remark)) > 255 {
|
||
c.atFail(400, 400, "备注不能超过 255 个字符")
|
||
return
|
||
}
|
||
|
||
var row models.OaAttendance
|
||
if err := oaAttendQuery(tid).Filter("id", id).One(&row); err != nil {
|
||
c.atFail(404, 404, "考勤记录不存在")
|
||
return
|
||
}
|
||
row.Remark = remark
|
||
if _, err := models.Orm.Update(&row, "remark"); err != nil {
|
||
c.atFail(500, 500, "保存备注失败: "+err.Error())
|
||
return
|
||
}
|
||
c.atOK(oaAttendView(&row))
|
||
}
|