package jnpf.util;
|
|
import jnpf.limsEntity.LimsSxtQuyangJihuaEntity;
|
import lombok.extern.slf4j.Slf4j;
|
|
import java.time.LocalDate;
|
import java.time.temporal.ChronoUnit;
|
|
/**
|
* 取样计划周期判断工具类
|
*
|
*/
|
@Slf4j
|
public class LimsSxtJihuaUtil {
|
/**
|
* 判断计划在指定日期是否应该执行
|
*
|
* @param plan 计划实体
|
* @param date 目标日期
|
* @return true-需要执行，false-不需要执行
|
*/
|
public static boolean shouldExecuteOnDate(LimsSxtQuyangJihuaEntity plan, LocalDate date) {
|
if (plan == null || date == null) {
|
log.debug("计划或日期为空");
|
return false;
|
}
|
|
// 1. 检查删除标志
|
if (isDeleted(plan)) {
|
log.debug("计划已删除，fId={}", plan.getId());
|
return false;
|
}
|
|
// 2. 检查流程状态（2=已通过生效，根据业务调整）
|
if (!isApproved(plan)) {
|
log.debug("计划流程状态未生效，fId={}, state={}", plan.getId(), plan.getFFlowState());
|
return false;
|
}
|
|
// 3. 检查是否在计划时间范围内
|
if (!isInDateRange(plan, date)) {
|
log.debug("计划不在时间范围内，fId={}, date={}", plan.getId(), date);
|
return false;
|
}
|
|
// 4. 根据周期类型判断
|
String cycleType = plan.getJihuaZhouqiLeixing();
|
if (cycleType == null || cycleType.isEmpty()) {
|
log.debug("计划周期类型为空，fId={}", plan.getId());
|
return false;
|
}
|
|
int interval = parseInterval(plan.getJihuaZhouqiJiange());
|
if (interval < 0) {
|
log.debug("计划周期间隔无效，fId={}, interval={}", plan.getId(), interval);
|
return false;
|
}
|
|
LocalDate startDate = plan.getKaishiShijian().toInstant()
|
.atZone(java.time.ZoneId.systemDefault()).toLocalDate();
|
|
return matchCycle(cycleType, startDate, date, interval);
|
}
|
|
// ==================== 前置检查方法 ====================
|
|
/**
|
* 检查是否已删除：f_delete_mark = 1 表示已删除
|
*/
|
private static boolean isDeleted(LimsSxtQuyangJihuaEntity plan) {
|
Integer deleteMark = plan.getFDeleteMark();
|
return deleteMark != null && deleteMark == 1;
|
}
|
|
/**
|
* 检查流程状态是否已通过（2=已通过）
|
*/
|
private static boolean isApproved(LimsSxtQuyangJihuaEntity plan) {
|
Integer flowState = plan.getFFlowState();
|
return flowState != null && flowState == 2;
|
}
|
|
/**
|
* 检查是否在计划时间范围内（包含起止日期）
|
*/
|
private static boolean isInDateRange(LimsSxtQuyangJihuaEntity plan, LocalDate date) {
|
LocalDate startDate = plan.getKaishiShijian().toInstant()
|
.atZone(java.time.ZoneId.systemDefault()).toLocalDate();
|
LocalDate endDate = plan.getJieshuShijian().toInstant()
|
.atZone(java.time.ZoneId.systemDefault()).toLocalDate();
|
return !date.isBefore(startDate) && !date.isAfter(endDate);
|
}
|
|
/**
|
* 解析周期间隔
|
*/
|
private static int parseInterval(String intervalStr) {
|
if (intervalStr == null || intervalStr.trim().isEmpty()) {
|
return -1;
|
}
|
try {
|
return Integer.parseInt(intervalStr.trim());
|
} catch (NumberFormatException e) {
|
log.error("解析周期间隔失败: {}", intervalStr, e);
|
return -1;
|
}
|
}
|
|
// ==================== 周期匹配方法 ====================
|
|
/**
|
* 根据周期类型匹配
|
*/
|
private static boolean matchCycle(String cycleType, LocalDate startDate, LocalDate targetDate, int interval) {
|
long daysDiff = ChronoUnit.DAYS.between(startDate, targetDate);
|
|
switch (cycleType.toLowerCase()) {
|
case "daily":
|
return matchDaily(daysDiff, interval);
|
|
case "weekly":
|
return matchWeekly(startDate, targetDate, daysDiff, interval);
|
|
case "monthly":
|
return matchMonthly(startDate, targetDate, interval);
|
|
case "quarterly":
|
return matchQuarterly(startDate, targetDate, interval);
|
|
case "yearly":
|
return matchYearly(startDate, targetDate, interval);
|
|
default:
|
log.warn("未知的周期类型: {}", cycleType);
|
return false;
|
}
|
}
|
|
// ==================== 各周期具体匹配逻辑 ====================
|
|
/**
|
* 每日周期匹配
|
* 逻辑：距开始日期的天数差 % (间隔 + 1) = 0
|
* 示例：开始7/14，间隔1 → 7/14, 7/16, 7/18...
|
*/
|
private static boolean matchDaily(long daysDiff, int interval) {
|
return daysDiff % executionStep(interval) == 0;
|
}
|
|
/**
|
* 每周周期匹配
|
* 逻辑：星期几相同 + 周数差 % (间隔 + 1) = 0
|
* 示例：开始7/14(周二)，间隔1 → 隔周周二执行
|
*/
|
private static boolean matchWeekly(LocalDate startDate, LocalDate targetDate, long daysDiff, int interval) {
|
// 星期几相同（LocalDate.DayOfWeek: 周一=1, 周日=7）
|
if (targetDate.getDayOfWeek() != startDate.getDayOfWeek()) {
|
return false;
|
}
|
long weekDiff = daysDiff / 7;
|
return weekDiff % executionStep(interval) == 0;
|
}
|
|
/**
|
* 每月周期匹配（含月末边界处理）
|
* 逻辑：日期匹配 + 月份差 % (间隔 + 1) = 0
|
* 示例：开始1/31，间隔1 → 1/31, 3/31, 5/31...
|
*/
|
private static boolean matchMonthly(LocalDate startDate, LocalDate targetDate, int interval) {
|
// 日期匹配（含月末边界）
|
if (!isSameDayOfMonthWithBoundary(startDate, targetDate)) {
|
return false;
|
}
|
long monthDiff = ChronoUnit.MONTHS.between(
|
startDate.withDayOfMonth(1),
|
targetDate.withDayOfMonth(1)
|
);
|
return monthDiff % executionStep(interval) == 0;
|
}
|
|
/**
|
* 每季周期匹配（含月末边界处理）
|
* 逻辑：同月同日 + 季度差 % (间隔 + 1) = 0
|
* 示例：开始1/31，间隔1 → 1/31, 7/31...
|
*/
|
private static boolean matchQuarterly(LocalDate startDate, LocalDate targetDate, int interval) {
|
// 日期匹配（含月末边界）
|
if (!isSameDayOfMonthWithBoundary(startDate, targetDate)) {
|
return false;
|
}
|
long monthDiff = ChronoUnit.MONTHS.between(
|
startDate.withDayOfMonth(1),
|
targetDate.withDayOfMonth(1)
|
);
|
if (monthDiff % 3 != 0) {
|
return false;
|
}
|
long quarterDiff = monthDiff / 3;
|
return quarterDiff % executionStep(interval) == 0;
|
}
|
|
/**
|
* 每年周期匹配（含2月29日处理）
|
* 逻辑：月日相同 + 年份差 % (间隔 + 1) = 0
|
* 示例：开始2024-02-29，间隔1 → 2024-02-29, 2026-02-28...
|
*/
|
private static boolean matchYearly(LocalDate startDate, LocalDate targetDate, int interval) {
|
// 月日匹配（含2月29日处理）
|
if (!isSameMonthAndDayWithLeapYear(startDate, targetDate)) {
|
return false;
|
}
|
long yearDiff = targetDate.getYear() - startDate.getYear();
|
return yearDiff % executionStep(interval) == 0;
|
}
|
|
private static long executionStep(int interval) {
|
return (long) interval + 1;
|
}
|
|
// ==================== 边界处理方法 ====================
|
|
/**
|
* 判断日期是否匹配（含月末边界处理）
|
* <p>
|
* 规则：
|
* - 如果开始日期是当月最后一天 → 目标日期也必须是当月最后一天（自动适配不同月份的天数差异）
|
* - 否则 → 日期必须相同
|
* <p>
|
* 示例：
|
* - 开始 1/31 → 匹配 1/31, 2/28, 3/31, 4/30, 5/31...
|
* - 开始 2/28 → 匹配 1/28, 2/28, 3/28, 4/28...
|
* - 开始 2/29 → 匹配 2/29（闰年）或 2/28（非闰年）
|
*/
|
private static boolean isSameDayOfMonthWithBoundary(LocalDate startDate, LocalDate targetDate) {
|
// 如果开始日期是当月最后一天
|
if (startDate.getDayOfMonth() == startDate.lengthOfMonth()) {
|
// 目标日期也必须是当月最后一天
|
return targetDate.getDayOfMonth() == targetDate.lengthOfMonth();
|
}
|
// 否则日期必须相同
|
return startDate.getDayOfMonth() == targetDate.getDayOfMonth();
|
}
|
|
/**
|
* 判断月日是否匹配（含2月29日处理）
|
* <p>
|
* 规则：
|
* - 开始日期是 2/29 → 目标日期必须是 2/29（闰年）或 2/28（非闰年）
|
* - 否则 → 月日完全相同
|
* <p>
|
* 示例：
|
* - 开始 2024-02-29 → 匹配 2024-02-29, 2025-02-28, 2026-02-28, 2028-02-29
|
* - 开始 2024-03-15 → 匹配 2025-03-15, 2026-03-15...
|
*/
|
private static boolean isSameMonthAndDayWithLeapYear(LocalDate startDate, LocalDate targetDate) {
|
// 如果开始日期是2月29日
|
if (startDate.getMonthValue() == 2 && startDate.getDayOfMonth() == 29) {
|
// 目标日期必须是2月
|
if (targetDate.getMonthValue() != 2) {
|
return false;
|
}
|
// 闰年必须是29日，非闰年可以是28日
|
if (targetDate.isLeapYear()) {
|
return targetDate.getDayOfMonth() == 29;
|
} else {
|
return targetDate.getDayOfMonth() == 28;
|
}
|
}
|
// 普通日期：月日完全相同
|
return startDate.getMonthValue() == targetDate.getMonthValue()
|
&& startDate.getDayOfMonth() == targetDate.getDayOfMonth();
|
}
|
}
|
