using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using NCC.Extend.Entitys.Dto.LqAttendanceRecord;
using NCC.Extend.Entitys.Enum;
using NCC.Extend.Entitys.lq_attendance_record;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
namespace NCC.Extend
{
///
/// 考勤汇总列表用:按自然月、每日一条有效记录口径统计应休/到岗/请假/迟到早退/旷工及可自快照计算的固定扣款。
///
public static class AttendanceSummaryMonthMetricsHelper
{
private const string PersonalLeaveType = "事假";
private const string SickLeaveType = "病假";
///
/// 单月扩展指标
///
public sealed class MonthMetrics
{
/// 应休天数(考勤组月应休额度,优先取当月打卡规则快照中的分组配置)
public decimal EntitledRestDays { get; set; }
/// 到岗天数(正常+迟到)
public decimal OnDutyDays { get; set; }
/// 工作天数(应休+到岗)
public decimal CompositeWorkDays { get; set; }
/// 带薪请假天数(请假状态中假种非事假、非病假;不含病假状态)
public decimal PaidLeaveDays { get; set; }
/// 请假天数(请假+病假状态合计)
public decimal LeaveDaysTotal { get; set; }
/// 迟到或早退分钟大于 0 的天数
public decimal LateEarlyDays { get; set; }
/// 旷工天数
public decimal AbsenteeismDays { get; set; }
/// 补卡天数(含流程补卡与后台补卡)
public decimal SupplementDays { get; set; }
/// 未放行补卡天数(补卡且 SupplementCountAsNormal != 1)
public decimal BlockingSupplementDays { get; set; }
/// 补卡维度是否可算全勤(无未放行补卡日)
public bool IsFullAttendanceEligible { get; set; } = true;
/// 迟到/早退规则为「固定金额」时,自 F_RuleSnapshotJson 汇总
public decimal LateDeductionAmount { get; set; }
/// 事假/病假扣款依赖日薪×倍率;未传日薪时为 0
public decimal LeaveDeductionAmount { get; set; }
/// 旷工规则为「固定金额」时,自 F_AllRuleSnapshotJson 的旷工规则表取首条匹配单日区间
public decimal AbsenteeismDeductionAmount { get; set; }
/// 缺卡次数(当月补卡上班/下班各计 1 次)
public int MissingCardCount { get; set; }
/// 缺卡扣款金额(按忘记打卡规则阶梯:总次数×每次扣款)
public decimal MissingCardDeductionAmount { get; set; }
}
///
/// 按用户当月有效打卡记录计算扩展指标(须已按日折叠为每日一条,与汇总同步口径一致)。
///
/// 该用户该月「每日一条」记录
/// 无快照时的月应休兜底(主档分组)
/// 日薪;为空则请假扣款金额为 0
/// 流程补卡申请单 F_PUNCHTARGETSJSON,键为流程/表单 ID
public static MonthMetrics Compute(
IReadOnlyList perDayRecords,
int fallbackMonthlyRestDays,
decimal? dailySalaryForLeaveDeduct = null,
IReadOnlyDictionary punchTargetsJsonByWorkflowId = null)
{
var metrics = new MonthMetrics();
if (perDayRecords == null || perDayRecords.Count == 0)
{
metrics.EntitledRestDays = fallbackMonthlyRestDays;
metrics.CompositeWorkDays = metrics.EntitledRestDays + metrics.OnDutyDays;
return metrics;
}
var entitled = TryResolveMonthlyRestDays(perDayRecords, fallbackMonthlyRestDays);
metrics.EntitledRestDays = entitled;
decimal? leaveRate = null;
decimal? sickRate = null;
foreach (var r in perDayRecords)
{
TryReadBaseLeaveRates(r.AllRuleSnapshotJson, ref leaveRate, ref sickRate);
}
foreach (var r in perDayRecords)
{
var st = r.Status;
if (st == (int)AttendanceRecordStatusEnum.正常 || st == (int)AttendanceRecordStatusEnum.迟到)
{
metrics.OnDutyDays += 1;
}
if (st == (int)AttendanceRecordStatusEnum.请假)
{
metrics.LeaveDaysTotal += 1;
var lt = ResolveLeaveType(r);
if (IsPaidLeaveCategory(lt))
{
metrics.PaidLeaveDays += 1;
}
if (dailySalaryForLeaveDeduct.HasValue && leaveRate.HasValue
&& string.Equals(lt, PersonalLeaveType, StringComparison.Ordinal))
{
metrics.LeaveDeductionAmount += dailySalaryForLeaveDeduct.Value * leaveRate.Value;
}
}
else if (st == (int)AttendanceRecordStatusEnum.病假)
{
metrics.LeaveDaysTotal += 1;
if (dailySalaryForLeaveDeduct.HasValue && sickRate.HasValue)
{
metrics.LeaveDeductionAmount += dailySalaryForLeaveDeduct.Value * sickRate.Value;
}
}
if (r.LateMinutes > 0 || r.EarlyLeaveMinutes > 0)
{
metrics.LateEarlyDays += 1;
}
if (st == (int)AttendanceRecordStatusEnum.旷工)
{
metrics.AbsenteeismDays += 1;
}
if (IsSupplementRecord(r))
{
metrics.SupplementDays += 1;
if (!IsSupplementCountAsNormal(r))
{
metrics.BlockingSupplementDays += 1;
}
}
metrics.LateDeductionAmount += TrySumFixedLateEarlyDeduction(r);
if (st == (int)AttendanceRecordStatusEnum.旷工)
{
metrics.AbsenteeismDeductionAmount += TryPickFixedAbsenteeismDeduction(r.AllRuleSnapshotJson);
}
}
metrics.CompositeWorkDays = metrics.EntitledRestDays + metrics.OnDutyDays;
metrics.IsFullAttendanceEligible = metrics.BlockingSupplementDays <= 0
&& !perDayRecords.Any(HasHalfDayLeaveWorkflow);
foreach (var r in perDayRecords)
{
metrics.MissingCardCount += CountSupplementPunchSlots(r, punchTargetsJsonByWorkflowId);
}
string allJsonForMissingCard = null;
foreach (var r in perDayRecords.OrderByDescending(x => x.AttendanceDate))
{
if (!string.IsNullOrWhiteSpace(r.AllRuleSnapshotJson))
{
allJsonForMissingCard = r.AllRuleSnapshotJson;
break;
}
}
metrics.MissingCardDeductionAmount = CalcMissingCardDeduction(metrics.MissingCardCount, allJsonForMissingCard);
return metrics;
}
///
/// 统计单条补卡记录新增的打卡次数(上班、下班各计 1 次)。
///
public static int CountSupplementPunchSlots(
LqAttendanceRecordEntity record,
IReadOnlyDictionary punchTargetsJsonByWorkflowId)
{
if (!IsSupplementRecord(record))
{
return 0;
}
var fromAdjust = TryCountSupplementSlotsFromAdjustDetail(record.AdjustDetailJson);
if (fromAdjust.HasValue)
{
return fromAdjust.Value;
}
var json = ResolvePunchTargetsJson(record, punchTargetsJsonByWorkflowId);
if (!string.IsNullOrWhiteSpace(json))
{
return CountSupplementSlotsFromPunchTargets(json, record.AttendanceDate);
}
return 0;
}
///
/// 按忘记打卡规则阶梯计算缺卡扣款:匹配区间后 总次数×每次扣款金额。
///
public static decimal CalcMissingCardDeduction(int totalCount, string allRuleSnapshotJson)
{
if (totalCount <= 0 || string.IsNullOrWhiteSpace(allRuleSnapshotJson))
{
return 0m;
}
try
{
var o = JObject.Parse(allRuleSnapshotJson);
var arr = o["allRules"]?["missingCardRules"] as JArray;
if (arr == null || arr.Count == 0)
{
return 0m;
}
foreach (var token in arr)
{
var minCount = token["minCount"]?.Value() ?? 1;
var maxCount = token["maxCount"]?.Value();
if (totalCount < minCount)
{
continue;
}
if (maxCount.HasValue && totalCount >= maxCount.Value)
{
continue;
}
var deductPerTime = token["deductPerTime"]?.Value() ?? 0m;
return totalCount * deductPerTime;
}
}
catch
{
// ignore
}
return 0m;
}
///
/// 补卡维度整月是否可算全勤(当月任一未放行补卡日则否)。
///
public static bool IsFullAttendanceEligible(IReadOnlyList perDayRecords)
{
if (perDayRecords == null || perDayRecords.Count == 0)
{
return true;
}
foreach (var r in perDayRecords)
{
if (IsSupplementRecord(r) && !IsSupplementCountAsNormal(r))
{
return false;
}
if (HasHalfDayLeaveWorkflow(r))
{
return false;
}
}
return true;
}
///
/// 当日是否存在半天假流程(半天假不计全勤)。
///
public static bool HasHalfDayLeaveWorkflow(LqAttendanceRecordEntity record)
{
var workflows = ParseRelatedWorkflows(record?.RelatedWorkflowsJson);
return workflows.Any(x => x != null
&& x.type == "请假"
&& x.leaveFraction.HasValue
&& x.leaveFraction.Value > 0m
&& x.leaveFraction.Value < 1m);
}
///
/// 是否为补卡日(勿仅用 IsManual:请假同步也会置 1)。
///
public static bool IsSupplementRecord(LqAttendanceRecordEntity record)
{
if (record == null)
{
return false;
}
if (record.SupplementTime.HasValue)
{
return true;
}
if (!string.IsNullOrWhiteSpace(record.SupplementWorkflowId))
{
return true;
}
if (!string.IsNullOrWhiteSpace(record.SupplementRemark)
&& (!string.IsNullOrWhiteSpace(record.SupplementOperatorId)
|| !string.IsNullOrWhiteSpace(record.SupplementOperatorName)))
{
return true;
}
var workflows = ParseRelatedWorkflows(record.RelatedWorkflowsJson);
return workflows.Any(x => x != null && x.type == "补卡");
}
///
/// 补卡日是否已放行按正常考勤计入全勤。
///
public static bool IsSupplementCountAsNormal(LqAttendanceRecordEntity record)
{
return record != null && record.SupplementCountAsNormal == 1;
}
///
/// 将原始当月记录按日取最新一条(UpdateTime 优先)。
///
public static List CollapseToLatestPerDay(
IEnumerable monthRecords)
{
var list = monthRecords?.Where(x => x != null).ToList() ?? new List();
return list
.GroupBy(x => x.AttendanceDate.Date)
.Select(g => g.OrderByDescending(x => x.UpdateTime ?? x.CreateTime ?? DateTime.MinValue).First())
.OrderBy(x => x.AttendanceDate)
.ToList();
}
private static int TryResolveMonthlyRestDays(
IReadOnlyList perDayRecords,
int fallback)
{
foreach (var r in perDayRecords.OrderByDescending(x => x.AttendanceDate))
{
var v = TryGetMonthlyRestFromRuleSnapshot(r.RuleSnapshotJson);
if (v.HasValue)
{
return Math.Max(0, v.Value);
}
}
return Math.Max(0, fallback);
}
private static int? TryGetMonthlyRestFromRuleSnapshot(string json)
{
if (string.IsNullOrWhiteSpace(json))
{
return null;
}
try
{
var o = JObject.Parse(json);
var rg = o["restGroup"];
var fromRest = rg?["monthlyRestDays"]?.Value();
if (fromRest.HasValue)
{
return fromRest;
}
var ag = o["attendanceGroup"];
return ag?["monthlyRestDays"]?.Value();
}
catch
{
return null;
}
}
private static void TryReadBaseLeaveRates(
string allJson,
ref decimal? leaveRate,
ref decimal? sickRate)
{
if (string.IsNullOrWhiteSpace(allJson) || (leaveRate.HasValue && sickRate.HasValue))
{
return;
}
try
{
var o = JObject.Parse(allJson);
var bs = o["baseSetting"];
if (bs == null)
{
return;
}
if (!leaveRate.HasValue)
{
leaveRate = bs["leaveDeductDailySalaryRate"]?.Value();
}
if (!sickRate.HasValue)
{
sickRate = bs["sickLeaveDeductDailySalaryRate"]?.Value();
}
}
catch
{
// ignore
}
}
private static decimal TrySumFixedLateEarlyDeduction(LqAttendanceRecordEntity r)
{
if (string.IsNullOrWhiteSpace(r?.RuleSnapshotJson))
{
return 0m;
}
try
{
var o = JObject.Parse(r.RuleSnapshotJson);
decimal sum = 0;
if (r.LateMinutes > 0)
{
sum += ReadFixedDeductAmount(o["lateRule"]);
}
if (r.EarlyLeaveMinutes > 0)
{
sum += ReadFixedDeductAmount(o["earlyLeaveRule"]);
}
return sum;
}
catch
{
return 0m;
}
}
private static decimal ReadFixedDeductAmount(JToken rule)
{
if (rule == null || rule.Type == JTokenType.Null)
{
return 0m;
}
var mode = rule["deductMode"]?.Value();
if (mode != (int)AttendanceDeductModeEnum.FixedAmount)
{
return 0m;
}
return rule["deductValue"]?.Value() ?? 0m;
}
private static decimal TryPickFixedAbsenteeismDeduction(string allJson)
{
if (string.IsNullOrWhiteSpace(allJson))
{
return 0m;
}
try
{
var o = JObject.Parse(allJson);
var arr = o["allRules"]?["absenteeismRules"] as JArray;
if (arr == null)
{
return 0m;
}
foreach (var token in arr)
{
var minDays = token["minDays"]?.Value() ?? 1m;
var maxDays = token["maxDays"]?.Value();
if (minDays > 1m)
{
continue;
}
if (maxDays.HasValue && maxDays.Value <= 1m)
{
continue;
}
var mode = token["deductMode"]?.Value();
if (mode != (int)AttendanceDeductModeEnum.FixedAmount)
{
continue;
}
return token["deductValue"]?.Value() ?? 0m;
}
}
catch
{
// ignore
}
return 0m;
}
private static string ResolveLeaveType(LqAttendanceRecordEntity r)
{
var workflows = ParseRelatedWorkflows(r.RelatedWorkflowsJson);
var fromWf = workflows
.FirstOrDefault(x => x != null && x.type == "请假" && !string.IsNullOrWhiteSpace(x.leaveType));
if (fromWf != null)
{
return fromWf.leaveType.Trim();
}
return TryGetLeaveTypeLabelFromSyncRemark(r.Remark);
}
private static List ParseRelatedWorkflows(string json)
{
if (string.IsNullOrWhiteSpace(json))
{
return new List();
}
try
{
return Newtonsoft.Json.JsonConvert.DeserializeObject>(json)
?? new List();
}
catch
{
return new List();
}
}
private static string TryGetLeaveTypeLabelFromSyncRemark(string remark)
{
if (string.IsNullOrWhiteSpace(remark))
{
return null;
}
const string prefix = "请假审批通过:";
var idx = remark.IndexOf(prefix, StringComparison.Ordinal);
if (idx < 0)
{
return null;
}
var tail = remark.Substring(idx + prefix.Length);
var paren = tail.IndexOf('(');
if (paren <= 0)
{
return null;
}
var label = tail.Substring(0, paren).Trim();
return string.IsNullOrEmpty(label) ? null : label;
}
private static bool IsPaidLeaveCategory(string leaveType)
{
if (string.IsNullOrWhiteSpace(leaveType))
{
return false;
}
if (string.Equals(leaveType, PersonalLeaveType, StringComparison.Ordinal)
|| string.Equals(leaveType, SickLeaveType, StringComparison.Ordinal))
{
return false;
}
return true;
}
private static int? TryCountSupplementSlotsFromAdjustDetail(string adjustDetailJson)
{
if (string.IsNullOrWhiteSpace(adjustDetailJson))
{
return null;
}
try
{
var o = JObject.Parse(adjustDetailJson);
var before = o["before"];
var after = o["after"];
if (before == null || after == null)
{
return null;
}
var count = 0;
if (IsEmptyPunchTimeToken(before["punchInTime"]) && !IsEmptyPunchTimeToken(after["punchInTime"]))
{
count += 1;
}
if (IsEmptyPunchTimeToken(before["punchOutTime"]) && !IsEmptyPunchTimeToken(after["punchOutTime"]))
{
count += 1;
}
return count;
}
catch
{
return null;
}
}
private static bool IsEmptyPunchTimeToken(JToken token)
{
if (token == null || token.Type == JTokenType.Null)
{
return true;
}
return string.IsNullOrWhiteSpace(token.ToString());
}
private static string ResolvePunchTargetsJson(
LqAttendanceRecordEntity record,
IReadOnlyDictionary punchTargetsJsonByWorkflowId)
{
if (record == null || punchTargetsJsonByWorkflowId == null || punchTargetsJsonByWorkflowId.Count == 0)
{
return null;
}
if (!string.IsNullOrWhiteSpace(record.SupplementWorkflowId)
&& punchTargetsJsonByWorkflowId.TryGetValue(record.SupplementWorkflowId.Trim(), out var json))
{
return json;
}
var workflows = ParseRelatedWorkflows(record.RelatedWorkflowsJson);
foreach (var wf in workflows.Where(x => x != null && x.type == "补卡"))
{
if (!string.IsNullOrWhiteSpace(wf.id)
&& punchTargetsJsonByWorkflowId.TryGetValue(wf.id.Trim(), out json))
{
return json;
}
}
return null;
}
private static int CountSupplementSlotsFromPunchTargets(string punchTargetsJson, DateTime attendanceDate)
{
var lines = ParsePunchApplyTargetLinesFromJson(punchTargetsJson);
var line = FindPunchApplyLineForDate(lines, attendanceDate.Date);
if (line == null)
{
return 0;
}
var count = 0;
if (line.punchIn)
{
count += 1;
}
if (line.punchOut)
{
count += 1;
}
return count;
}
private static List ParsePunchApplyTargetLinesFromJson(string json)
{
var list = new List();
if (string.IsNullOrWhiteSpace(json))
{
return list;
}
try
{
var token = JToken.Parse(json.Trim());
JArray arr = null;
if (token.Type == JTokenType.Array)
{
arr = (JArray)token;
}
else if (token is JObject jo)
{
if (jo["punchTargets"] is JArray a1)
{
arr = a1;
}
else if (jo["targets"] is JArray a2)
{
arr = a2;
}
else if (jo["data"] is JArray a3)
{
arr = a3;
}
}
if (arr != null)
{
foreach (var item in arr)
{
if (item == null || item.Type != JTokenType.Object)
{
continue;
}
var o = (JObject)item;
var dateStr = (string)o["date"] ?? (string)o["Date"];
var punchIn = o["punchIn"]?.Value() ?? o["PunchIn"]?.Value() ?? false;
var punchOut = o["punchOut"]?.Value() ?? o["PunchOut"]?.Value() ?? false;
list.Add(new PunchApplyTargetLineLite
{
date = dateStr,
punchIn = punchIn,
punchOut = punchOut
});
}
}
}
catch
{
// fall through
}
if (list.Count > 0)
{
return list;
}
try
{
return JsonConvert.DeserializeObject>(json) ?? new List();
}
catch
{
return list;
}
}
private static PunchApplyTargetLineLite FindPunchApplyLineForDate(
List lines,
DateTime attendanceDay)
{
var effective = lines?.Where(l => l != null && (l.punchIn || l.punchOut)).ToList()
?? new List();
if (effective.Count == 0)
{
return null;
}
var matched = effective.FirstOrDefault(l => MatchPunchApplyLineDate(l.date, attendanceDay));
if (matched != null)
{
return matched;
}
if (effective.Count != 1)
{
return null;
}
var only = effective[0];
if (string.IsNullOrWhiteSpace(only.date))
{
return only;
}
if (!TryParseLineDateFlexible(only.date, out var parsed))
{
return only;
}
return parsed.Date == attendanceDay.Date ? only : null;
}
private static bool MatchPunchApplyLineDate(string lineDate, DateTime attendanceDay)
{
if (string.IsNullOrWhiteSpace(lineDate))
{
return false;
}
return TryParseLineDateFlexible(lineDate, out var d) && d.Date == attendanceDay.Date;
}
private static bool TryParseLineDateFlexible(string lineDate, out DateTime parsed)
{
parsed = default;
if (string.IsNullOrWhiteSpace(lineDate))
{
return false;
}
var t = lineDate.Trim();
var formats = new[]
{
"yyyy-MM-dd",
"yyyy/MM/dd",
"yyyy/M/d",
"yyyy/MM/d",
"yyyy-M-d",
"yyyy-MM-ddTHH:mm:ss",
"yyyy-MM-ddTHH:mm:ss.fff"
};
foreach (var fmt in formats)
{
if (DateTime.TryParseExact(t, fmt, CultureInfo.InvariantCulture, DateTimeStyles.AllowWhiteSpaces, out parsed))
{
return true;
}
}
return DateTime.TryParse(t, CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out parsed);
}
private sealed class PunchApplyTargetLineLite
{
public string date { get; set; }
public bool punchIn { get; set; }
public bool punchOut { get; set; }
}
}
}