@ray-js/lamp-schedule-core 1.0.0-beta-1

package/lib/config/rhythms/index.d.ts

@@ -0,0 +1,10 @@
+export declare const defaultRhythms: {
+    defaultCloud: {
+        name: any;
+        icon: string;
+    }[];
+    defaultSigMeshCloud: {
+        name: any;
+        icon: string;
+    }[];
+};

package/lib/config/rhythms/index.js

@@ -0,0 +1,35 @@
+import Strings from '../../i18n';
+export const defaultRhythms = {
+  defaultCloud: [{
+    name: 'sub_0',
+    icon: ''
+  }, {
+    name: Strings.getLang('rhythms_default_name_0'),
+    icon: 'icon1'
+  }, {
+    name: Strings.getLang('rhythms_default_name_1'),
+    icon: 'icon2'
+  }, {
+    name: Strings.getLang('rhythms_default_name_2'),
+    icon: 'icon3'
+  }, {
+    name: 'sub_3',
+    icon: ''
+  }, {
+    name: Strings.getLang('rhythms_default_name_3'),
+    icon: 'icon4'
+  }],
+  defaultSigMeshCloud: [{
+    name: Strings.getLang('rhythms_default_name_0'),
+    icon: 'icon1'
+  }, {
+    name: Strings.getLang('rhythms_default_name_1'),
+    icon: 'icon2'
+  }, {
+    name: Strings.getLang('rhythms_default_name_2'),
+    icon: 'icon3'
+  }, {
+    name: Strings.getLang('rhythms_default_name_3'),
+    icon: 'icon4'
+  }]
+};

package/lib/conflict/ConflictResolver.d.ts

@@ -0,0 +1,2 @@
+import { Schedule, ConflictResult, ConflictRule } from './type';
+export declare function checkConflicts(scheduleList: Schedule[], currentSchedule: Schedule, rule?: ConflictRule): ConflictResult[];

package/lib/conflict/ConflictResolver.js

@@ -0,0 +1,284 @@
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.flat-map.js";
+import "core-js/modules/esnext.iterator.for-each.js";
+/* eslint-disable no-console */
+import dayjs from 'dayjs';
+import { scheduleLogger } from '../utils/ScheduleLogger';
+import { EScheduleFunctionType } from '../types';
+
+/** 计划模块间的冲突逻辑 */
+// 综述：生物节律、入睡唤醒、随机定时、循环定时、倒计时面板进行互斥判断确保下发的任务不存在互斥任务
+/**
+ * 1. 生物节律
+ * - 冲突判断依据：
+ * 1.1. 开启：生物节律功能以星期为度进行判断，如果相同星期有其他任务，提示冲突
+ * 1.2. 修改：修改星期的时候需要进行判断是否存在时间冲突
+ * - 提示文案：
+ * 1.3 与以下定时任务存在冲突，请关闭后重试
+ */
+
+/**
+ * 2. 入睡唤醒 随机定时 循环定时，任务保存默认开启
+ * - 冲突判断依据：
+ * 2.1 入睡任务时间段为开始入睡到淡出至关灯的时间段
+ * 2.2 唤醒任务时间段为开始唤醒到淡入至完全亮灯的时间段，如果设置了持续时间后关灯，任务时间需要加上持续时间
+ * 2.3 随机定时任务时间段为开始时间到结束时间
+ * - 提示文案：
+ * 2.4 冲突提示：与以下定时任务存在冲突，请关闭后重试
+ * 2.5 时间提示：如果开始时间早于当前时间，提示 当日任务不生效
+ */
+
+/**
+ * 3. 倒计时
+ * - 冲突判断依据：
+ * 3.1 倒计时属于单次任务，任务时间段为设置时的当前时间段到倒计时结束时间点，在这个时间段内，如果存在其他任务时间重叠，提示冲突
+ * - 提示文案：
+ * 3.2 冲突提示：与以下定时任务存在冲突，请关闭后重试
+ */
+
+/**
+ * 4. 定时
+ * - 冲突判断依据：
+ * 4.1 不能生成两个相同的定时任务
+ * - 提示文案：
+ * 4.2 冲突提示：与以下定时任务存在冲突，请关闭后重试
+ */
+
+// 跨天处理的核心冲突检测函数
+function doRangesOverlap(aStart, aEnd, bStart, bEnd) {
+  // 处理跨天时间范围
+  const aIsCrossDay = aEnd < aStart;
+  const bIsCrossDay = bEnd < bStart;
+
+  // 标准化时间范围，将跨天时间段视为两天的总分钟数
+  // 例如：22:00 到 02:00 会被转换为 1320 到 1560 (而不是 1320 到 120)
+  const aStartMin = aStart;
+  const aEndMin = aIsCrossDay ? aEnd + 1440 : aEnd;
+  const bStartMin = bStart;
+  const bEndMin = bIsCrossDay ? bEnd + 1440 : bEnd;
+
+  // 情况1: 两个范围完全相同
+  if (aStartMin === bStartMin && aEndMin === bEndMin) {
+    return true;
+  }
+
+  // 情况2: 两个范围都跨天
+  // 当两个范围都跨天时，它们一定会重叠，因为都覆盖了午夜时间点
+  if (aIsCrossDay && bIsCrossDay) {
+    return true;
+  }
+
+  // 情况3: 一个范围跨天，一个不跨天
+  // 这种情况下，我们已经将跨天范围标准化为连续分钟数
+  // 所以可以直接使用标准区间重叠判断
+
+  // 情况4: 两个范围都不跨天
+  // 使用标准区间重叠判断: [a1,a2] 和 [b1,b2] 重叠当且仅当 a2 > b1 && b2 > a1
+  return aEndMin > bStartMin && bEndMin > aStartMin;
+}
+
+// 辅助函数
+function parseTimeToMinutes(timeStr) {
+  try {
+    if (!timeStr || typeof timeStr !== 'string') {
+      throw new Error(`Invalid time format: ${timeStr}`);
+    }
+    const parts = timeStr.split(':');
+    if (parts.length !== 2) {
+      throw new Error(`Time string must be in format HH:MM, got: ${timeStr}`);
+    }
+    const hour = Number(parts[0]);
+    const minute = Number(parts[1]);
+    if (hour < 0 || hour > 23 || minute < 0 || minute > 59) {
+      throw new Error(`Time values out of range, got: ${timeStr}`);
+    }
+    return hour * 60 + minute;
+  } catch (error) {
+    scheduleLogger.error('Invalid time format:', error, timeStr);
+    return 0;
+  }
+}
+
+// 转换原始任务到统一格式
+function convertToTimeRanges(schedules) {
+  const daysOfWeek = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+
+  // dayjs 获取当前星期
+  const week = dayjs().day();
+  return schedules.flatMap(schedule => {
+    try {
+      // 验证weeks数组
+      if (!schedule.data.weeks || !Array.isArray(schedule.data.weeks) || schedule.data.weeks.length !== 7) {
+        scheduleLogger.error('Invalid weeks format:', schedule);
+        return [];
+      }
+      const activeDays = daysOfWeek.filter((_, i) => schedule.data.weeks[i] === 1);
+
+      // 单次任务（weeks全为0）
+      if (activeDays.length === 0) {
+        try {
+          const startTime = schedule.data.startTime ? schedule.data.startTime : schedule.data.time;
+          const endTime = schedule.data.endTime ? schedule.data.endTime : schedule.data.time;
+          if (!startTime || !endTime) {
+            scheduleLogger.error('Missing time data in schedule:', schedule);
+            return [];
+          }
+          const startMinutes = parseTimeToMinutes(startTime);
+          const endMinutes = parseTimeToMinutes(endTime);
+          const isCrossDay = endMinutes < startMinutes;
+
+          // 如果定时状态为关闭，则设置星期，忽略冲突判断
+          const dayOfWeek = schedule.data.status ? daysOfWeek[isCrossDay ? (week + 1) % 7 : week] : null;
+          return [{
+            id: schedule.id,
+            type: schedule.type,
+            dayOfWeek: dayOfWeek,
+            startMinutes,
+            endMinutes,
+            originalSchedule: schedule,
+            isCrossDay
+          }];
+        } catch (error) {
+          scheduleLogger.error('Error processing single task:', error, schedule);
+          return [];
+        }
+      }
+
+      // 周期性任务（有星期标记）
+      const result = [];
+      activeDays.forEach(day => {
+        try {
+          const startTimeStr = schedule.data.startTime || schedule.data.time;
+          const endTimeStr = schedule.data.endTime || schedule.data.time;
+          if (!startTimeStr || !endTimeStr) {
+            scheduleLogger.error('Missing time data in schedule:', schedule);
+            return;
+          }
+          const start = parseTimeToMinutes(startTimeStr);
+          const end = parseTimeToMinutes(endTimeStr);
+          const isCrossDay = end < start;
+
+          // 如果定时状态为关闭，则设置星期，忽略冲突判断
+          if (!schedule.data.status) {
+            return;
+          }
+
+          // 添加当前星期的时间范围
+          result.push({
+            id: schedule.id,
+            type: schedule.type,
+            dayOfWeek: day,
+            startMinutes: start,
+            endMinutes: end,
+            originalSchedule: schedule,
+            isCrossDay
+          });
+
+          // 如果是跨天任务，还需要添加下一天的时间范围
+          if (isCrossDay) {
+            // 获取下一天的星期
+            const nextDayIndex = (daysOfWeek.indexOf(day) + 1) % 7;
+            const nextDay = daysOfWeek[nextDayIndex];
+
+            // 检查下一天是否在激活的星期中
+            // 注意：即使下一天不在激活的星期中，我们也需要考虑跨天冲突
+            result.push({
+              id: schedule.id,
+              type: schedule.type,
+              dayOfWeek: nextDay,
+              startMinutes: 0,
+              // 从午夜开始
+              endMinutes: end,
+              // 到结束时间
+              originalSchedule: schedule,
+              isCrossDay: false // 这部分不再是跨天
+            });
+          }
+        } catch (error) {
+          scheduleLogger.error('Error processing periodic task:', error, schedule, day);
+        }
+      });
+      return result;
+    } catch (error) {
+      scheduleLogger.error('Error converting schedule to time ranges:', error, schedule);
+      return [];
+    }
+  });
+}
+
+// 默认规则
+const defaultRule = {
+  isConflict(a, b) {
+    return doRangesOverlap(a.startMinutes, a.endMinutes, b.startMinutes, b.endMinutes);
+  },
+  shouldIgnore(a, b) {
+    // 倒计时和生物节律因为每个都只有一个，不需要与自身判断冲突
+    if (a.id === b.id && a.id === EScheduleFunctionType.COUNTDOWN) {
+      return true;
+    }
+    if (a.id === b.id && a.id === EScheduleFunctionType.RHYTHM) {
+      return true;
+    }
+    return false;
+  }
+};
+function mergeListByOtherId(list) {
+  const mergedData = {};
+  list.forEach(item => {
+    if (!item || !item.other || !item.other.id) {
+      scheduleLogger.warn('Invalid conflict item:', item);
+      return;
+    }
+    const otherId = item.other.id;
+    if (!mergedData[otherId]) {
+      mergedData[otherId] = {
+        other: item.other,
+        current: item.current
+      };
+    }
+  });
+  return Object.values(mergedData);
+}
+
+// 冲突检测核心函数（修改后的版本）
+export function checkConflicts(scheduleList, currentSchedule) {
+  let rule = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : defaultRule;
+  const currentRanges = convertToTimeRanges([currentSchedule]);
+  const conflicts = [];
+  scheduleLogger.debug('checkConflicts rule:', rule);
+  scheduleLogger.debug('checkConflicts scheduleList:', scheduleList);
+  scheduleLogger.debug('checkConflicts currentSchedule:', currentSchedule);
+  const newSplicedScheduleList = [...scheduleList];
+  newSplicedScheduleList.forEach(schedule => {
+    const otherRanges = convertToTimeRanges([schedule]);
+    scheduleLogger.debug('checkConflicts currentRanges:', currentRanges);
+    scheduleLogger.debug('checkConflicts otherRanges:', otherRanges);
+    currentRanges.forEach(current => {
+      otherRanges.forEach(other => {
+        var _rule$shouldIgnore, _current$originalSche, _current$originalSche2;
+        // 应用规则中的忽略条件
+        if ((_rule$shouldIgnore = rule.shouldIgnore) !== null && _rule$shouldIgnore !== void 0 && _rule$shouldIgnore.call(rule, current, other)) {
+          return;
+        }
+        const currentPreId = current === null || current === void 0 || (_current$originalSche = current.originalSchedule) === null || _current$originalSche === void 0 ? void 0 : _current$originalSche.prevId;
+        const currentId = current === null || current === void 0 || (_current$originalSche2 = current.originalSchedule) === null || _current$originalSche2 === void 0 ? void 0 : _current$originalSche2.id;
+        const otherId = other.id;
+        // 如果当前定时自身修改 且 与自身冲突 则忽略
+        if (currentPreId && currentId === otherId || otherId === currentPreId) {
+          return;
+        }
+        if (current.dayOfWeek && current.dayOfWeek === other.dayOfWeek && rule.isConflict(current, other)) {
+          conflicts.push({
+            current: current.originalSchedule,
+            other: other.originalSchedule
+          });
+        }
+      });
+    });
+  });
+  scheduleLogger.debug('conflicts', conflicts);
+  // 将 conflicts 中相同的 other 字段数据进行合并,防止重复项目产生
+  const newConflict = mergeListByOtherId(conflicts);
+  scheduleLogger.debug('newConflict', newConflict);
+  return newConflict;
+}

package/lib/conflict/__test__/ConflictResolver.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/conflict/__test__/ConflictResolver.test.js

@@ -0,0 +1,183 @@
+import { checkConflicts } from '../ConflictResolver';
+import { EScheduleFunctionType } from '../../types';
+describe('ConflictResolver', () => {
+  describe('checkConflicts', () => {
+    // 测试基本冲突检测功能
+    it('should detect conflicts between schedules on the same day', () => {
+      // 创建两个在同一天有时间重叠的计划
+      const schedule1 = {
+        id: 'timer_1',
+        type: EScheduleFunctionType.TIMER,
+        data: {
+          status: true,
+          weeks: [1, 0, 0, 0, 0, 0, 0],
+          // 周日
+          startTime: '10:00',
+          endTime: '11:00'
+        }
+      };
+      const schedule2 = {
+        id: 'timer_2',
+        type: EScheduleFunctionType.TIMER,
+        data: {
+          status: true,
+          weeks: [1, 0, 0, 0, 0, 0, 0],
+          // 周日
+          startTime: '10:30',
+          endTime: '11:30'
+        }
+      };
+      const conflicts = checkConflicts([schedule1], schedule2);
+      expect(conflicts.length).toBe(1);
+      expect(conflicts[0].current).toBe(schedule2);
+      expect(conflicts[0].other).toBe(schedule1);
+    });
+
+    // 测试不同天的计划不会冲突
+    it('should not detect conflicts between schedules on different days', () => {
+      const schedule1 = {
+        id: 'timer_1',
+        type: EScheduleFunctionType.TIMER,
+        data: {
+          status: true,
+          weeks: [1, 0, 0, 0, 0, 0, 0],
+          // 周日
+          startTime: '10:00',
+          endTime: '11:00'
+        }
+      };
+      const schedule2 = {
+        id: 'timer_2',
+        type: EScheduleFunctionType.TIMER,
+        data: {
+          status: true,
+          weeks: [0, 1, 0, 0, 0, 0, 0],
+          // 周一
+          startTime: '10:00',
+          endTime: '11:00'
+        }
+      };
+      const conflicts = checkConflicts([schedule1], schedule2);
+      expect(conflicts.length).toBe(0);
+    });
+
+    // 测试跨天计划的冲突检测
+    it('should detect conflicts with cross-day schedules', () => {
+      const schedule1 = {
+        id: 'timer_1',
+        type: EScheduleFunctionType.TIMER,
+        data: {
+          status: true,
+          weeks: [1, 0, 0, 0, 0, 0, 0],
+          // 周日
+          startTime: '23:00',
+          endTime: '01:00' // 跨天到周一
+        }
+      };
+      const schedule2 = {
+        id: 'timer_2',
+        type: EScheduleFunctionType.TIMER,
+        data: {
+          status: true,
+          weeks: [0, 1, 0, 0, 0, 0, 0],
+          // 周一
+          startTime: '00:30',
+          endTime: '02:00'
+        }
+      };
+      const conflicts = checkConflicts([schedule1], schedule2);
+      expect(conflicts.length).toBe(1);
+    });
+
+    // 测试关闭状态的计划不会产生冲突
+    it('should not detect conflicts with schedules that are turned off', () => {
+      const schedule1 = {
+        id: 'timer_1',
+        type: EScheduleFunctionType.TIMER,
+        data: {
+          status: false,
+          // 关闭状态
+          weeks: [1, 0, 0, 0, 0, 0, 0],
+          // 周日
+          startTime: '10:00',
+          endTime: '11:00'
+        }
+      };
+      const schedule2 = {
+        id: 'timer_2',
+        type: EScheduleFunctionType.TIMER,
+        data: {
+          status: true,
+          weeks: [1, 0, 0, 0, 0, 0, 0],
+          // 周日
+          startTime: '10:30',
+          endTime: '11:30'
+        }
+      };
+      const conflicts = checkConflicts([schedule1], schedule2);
+      expect(conflicts.length).toBe(0);
+    });
+
+    // 测试自定义冲突规则
+    it('should apply custom conflict rules', () => {
+      const schedule1 = {
+        id: 'timer_1',
+        type: EScheduleFunctionType.TIMER,
+        data: {
+          status: true,
+          weeks: [1, 0, 0, 0, 0, 0, 0],
+          // 周日
+          startTime: '10:00',
+          endTime: '11:00'
+        }
+      };
+      const schedule2 = {
+        id: 'timer_2',
+        type: EScheduleFunctionType.TIMER,
+        data: {
+          status: true,
+          weeks: [1, 0, 0, 0, 0, 0, 0],
+          // 周日
+          startTime: '10:30',
+          endTime: '11:30'
+        }
+      };
+
+      // 自定义规则：永不冲突
+
+      const conflicts = checkConflicts([schedule1], schedule2, {
+        isConflict: () => false,
+        shouldIgnore: () => false
+      });
+      expect(conflicts.length).toBe(0);
+    });
+
+    // 测试生物节律类型的特殊处理
+    it('should handle RHYTHM type schedules correctly', () => {
+      const rhythmSchedule = {
+        id: EScheduleFunctionType.RHYTHM,
+        type: EScheduleFunctionType.RHYTHM,
+        data: {
+          status: true,
+          weeks: [1, 1, 1, 1, 1, 0, 0],
+          // 周一到周五
+          startTime: '00:00',
+          endTime: '23:59'
+        }
+      };
+      const timerSchedule = {
+        id: 'timer_1',
+        type: EScheduleFunctionType.TIMER,
+        data: {
+          status: true,
+          weeks: [0, 1, 0, 0, 0, 0, 0],
+          // 周一
+          startTime: '10:00',
+          endTime: '11:00'
+        }
+      };
+      const conflicts = checkConflicts([rhythmSchedule], timerSchedule);
+      expect(conflicts.length).toBe(1);
+    });
+  });
+});

package/lib/conflict/__test__/index.test.d.ts

@@ -0,0 +1 @@
+export {};