scriptable-testlab/src/mocks/services/reminder.ts

A lightweight, efficient tool designed to manage and update scripts for Scriptable.

import {AbsReminder} from 'scriptable-abstract';

interface ReminderState {
  identifier: string;
  title: string;
  notes: string;
  dueDate: Date | null;
  dueDateIncludesTime: boolean;
  isCompleted: boolean;
  isOverdue: boolean;
  priority: number;
  calendar: Calendar | null;
  recurrenceRules: RecurrenceRule[];
  completionDate: Date | null;
  creationDate: Date;
}

const DEFAULT_STATE: ReminderState = {
  identifier: '',
  title: '',
  notes: '',
  dueDate: null,
  dueDateIncludesTime: false,
  isCompleted: false,
  isOverdue: false,
  priority: 0,
  calendar: null,
  recurrenceRules: [],
  completionDate: null,
  creationDate: new Date(),
};

/**
 * Mock implementation of Scriptable's Reminder.
 * Provides functionality for managing reminders.
 * @implements Reminder
 */
export class MockReminder extends AbsReminder<ReminderState> {
  private static _instance: MockReminder | null = null;
  private static _reminders: MockReminder[] = [];

  static get instance(): MockReminder {
    if (!this._instance) {
      this._instance = new MockReminder();
    }
    return this._instance;
  }

  constructor() {
    super(DEFAULT_STATE);
  }

  // Basic properties
  get identifier(): string {
    return this.state.identifier;
  }

  get title(): string {
    return this.state.title;
  }

  set title(value: string) {
    this.setState({title: value});
  }

  get notes(): string {
    return this.state.notes;
  }

  set notes(value: string) {
    this.setState({notes: value});
  }

  get dueDate(): Date | null {
    return this.state.dueDate ? new Date(this.state.dueDate) : null;
  }

  set dueDate(value: Date | null) {
    this.setState({
      dueDate: value ? new Date(value) : null,
    });
  }

  get dueDateIncludesTime(): boolean {
    return this.state.dueDateIncludesTime;
  }

  set dueDateIncludesTime(value: boolean) {
    this.setState({dueDateIncludesTime: value});
  }

  get isCompleted(): boolean {
    return this.state.isCompleted;
  }

  set isCompleted(value: boolean) {
    this.setState({
      isCompleted: value,
      completionDate: value ? new Date() : null,
    });
  }

  get isOverdue(): boolean {
    if (!this.dueDate) return false;
    return this.dueDate < new Date() && !this.isCompleted;
  }

  get priority(): number {
    return this.state.priority;
  }

  set priority(value: number) {
    this.setState({priority: value});
  }

  get calendar(): Calendar | null {
    return this.state.calendar;
  }

  set calendar(value: Calendar | null) {
    this.setState({calendar: value});
  }

  get completionDate(): Date | null {
    return this.state.completionDate ? new Date(this.state.completionDate) : null;
  }

  get creationDate(): Date {
    return new Date(this.state.creationDate);
  }

  // Recurrence rules
  addRecurrenceRule(recurrenceRule: RecurrenceRule): void {
    this.setState(state => ({
      recurrenceRules: [...state.recurrenceRules, recurrenceRule],
    }));
  }

  removeAllRecurrenceRules(): void {
    this.setState({recurrenceRules: []});
  }

  // Save and remove
  save(): void {
    MockReminder._reminders.push(this);
  }

  remove(): void {
    const index = MockReminder._reminders.indexOf(this);
    if (index > -1) {
      MockReminder._reminders.splice(index, 1);
    }
  }

  // Static methods for fetching reminders
  private static async filterReminders(
    calendars: readonly Calendar[] | undefined,
    predicate: (reminder: MockReminder) => boolean,
  ): Promise<Reminder[]> {
    const reminders = this._reminders.filter(reminder => {
      if (calendars && calendars.length > 0) {
        return calendars.includes(reminder.calendar as Calendar) && predicate(reminder);
      }
      return predicate(reminder);
    });
    return reminders as unknown as Reminder[];
  }

  // Due Today
  static async allDueToday(calendars?: readonly Calendar[]): Promise<Reminder[]> {
    const today = new Date();
    today.setHours(0, 0, 0, 0);
    const tomorrow = new Date(today);
    tomorrow.setDate(tomorrow.getDate() + 1);

    return this.filterReminders(calendars, reminder => {
      const dueDate = reminder.dueDate;
      return dueDate !== null && dueDate >= today && dueDate < tomorrow;
    });
  }

  static async completedDueToday(calendars?: readonly Calendar[]): Promise<Reminder[]> {
    const today = new Date();
    today.setHours(0, 0, 0, 0);
    const tomorrow = new Date(today);
    tomorrow.setDate(tomorrow.getDate() + 1);

    return this.filterReminders(calendars, reminder => {
      const dueDate = reminder.dueDate;
      return dueDate !== null && dueDate >= today && dueDate < tomorrow && reminder.isCompleted;
    });
  }

  static async incompleteDueToday(calendars?: readonly Calendar[]): Promise<Reminder[]> {
    const today = new Date();
    today.setHours(0, 0, 0, 0);
    const tomorrow = new Date(today);
    tomorrow.setDate(tomorrow.getDate() + 1);

    return this.filterReminders(calendars, reminder => {
      const dueDate = reminder.dueDate;
      return dueDate !== null && dueDate >= today && dueDate < tomorrow && !reminder.isCompleted;
    });
  }

  // Due Tomorrow
  static async allDueTomorrow(calendars?: readonly Calendar[]): Promise<Reminder[]> {
    const tomorrow = new Date();
    tomorrow.setDate(tomorrow.getDate() + 1);
    tomorrow.setHours(0, 0, 0, 0);
    const dayAfter = new Date(tomorrow);
    dayAfter.setDate(dayAfter.getDate() + 1);

    return this.filterReminders(calendars, reminder => {
      const dueDate = reminder.dueDate;
      return dueDate !== null && dueDate >= tomorrow && dueDate < dayAfter;
    });
  }

  static async completedDueTomorrow(calendars?: readonly Calendar[]): Promise<Reminder[]> {
    const tomorrow = new Date();
    tomorrow.setDate(tomorrow.getDate() + 1);
    tomorrow.setHours(0, 0, 0, 0);
    const dayAfter = new Date(tomorrow);
    dayAfter.setDate(dayAfter.getDate() + 1);

    return this.filterReminders(calendars, reminder => {
      const dueDate = reminder.dueDate;
      return dueDate !== null && dueDate >= tomorrow && dueDate < dayAfter && reminder.isCompleted;
    });
  }

  static async incompleteDueTomorrow(calendars?: readonly Calendar[]): Promise<Reminder[]> {
    const tomorrow = new Date();
    tomorrow.setDate(tomorrow.getDate() + 1);
    tomorrow.setHours(0, 0, 0, 0);
    const dayAfter = new Date(tomorrow);
    dayAfter.setDate(dayAfter.getDate() + 1);

    return this.filterReminders(calendars, reminder => {
      const dueDate = reminder.dueDate;
      return dueDate !== null && dueDate >= tomorrow && dueDate < dayAfter && !reminder.isCompleted;
    });
  }

  // Due Yesterday
  static async allDueYesterday(calendars?: readonly Calendar[]): Promise<Reminder[]> {
    const yesterday = new Date();
    yesterday.setDate(yesterday.getDate() - 1);
    yesterday.setHours(0, 0, 0, 0);
    const today = new Date();
    today.setHours(0, 0, 0, 0);

    return this.filterReminders(calendars, reminder => {
      const dueDate = reminder.dueDate;
      return dueDate !== null && dueDate >= yesterday && dueDate < today;
    });
  }

  static async completedDueYesterday(calendars?: readonly Calendar[]): Promise<Reminder[]> {
    const yesterday = new Date();
    yesterday.setDate(yesterday.getDate() - 1);
    yesterday.setHours(0, 0, 0, 0);
    const today = new Date();
    today.setHours(0, 0, 0, 0);

    return this.filterReminders(calendars, reminder => {
      const dueDate = reminder.dueDate;
      return dueDate !== null && dueDate >= yesterday && dueDate < today && reminder.isCompleted;
    });
  }

  static async incompleteDueYesterday(calendars?: readonly Calendar[]): Promise<Reminder[]> {
    const yesterday = new Date();
    yesterday.setDate(yesterday.getDate() - 1);
    yesterday.setHours(0, 0, 0, 0);
    const today = new Date();
    today.setHours(0, 0, 0, 0);

    return this.filterReminders(calendars, reminder => {
      const dueDate = reminder.dueDate;
      return dueDate !== null && dueDate >= yesterday && dueDate < today && !reminder.isCompleted;
    });
  }

  // Due This Week
  static async allDueThisWeek(calendars?: readonly Calendar[]): Promise<Reminder[]> {
    const today = new Date();
    today.setHours(0, 0, 0, 0);
    const startOfWeek = new Date(today);
    startOfWeek.setDate(today.getDate() - today.getDay());
    const endOfWeek = new Date(startOfWeek);
    endOfWeek.setDate(endOfWeek.getDate() + 7);

    return this.filterReminders(calendars, reminder => {
      const dueDate = reminder.dueDate;
      return dueDate !== null && dueDate >= startOfWeek && dueDate < endOfWeek;
    });
  }

  static async completedDueThisWeek(calendars?: readonly Calendar[]): Promise<Reminder[]> {
    const today = new Date();
    today.setHours(0, 0, 0, 0);
    const startOfWeek = new Date(today);
    startOfWeek.setDate(today.getDate() - today.getDay());
    const endOfWeek = new Date(startOfWeek);
    endOfWeek.setDate(endOfWeek.getDate() + 7);

    return this.filterReminders(calendars, reminder => {
      const dueDate = reminder.dueDate;
      return dueDate !== null && dueDate >= startOfWeek && dueDate < endOfWeek && reminder.isCompleted;
    });
  }

  static async incompleteDueThisWeek(calendars?: readonly Calendar[]): Promise<Reminder[]> {
    const today = new Date();
    today.setHours(0, 0, 0, 0);
    const startOfWeek = new Date(today);
    startOfWeek.setDate(today.getDate() - today.getDay());
    const endOfWeek = new Date(startOfWeek);
    endOfWeek.setDate(endOfWeek.getDate() + 7);

    return this.filterReminders(calendars, reminder => {
      const dueDate = reminder.dueDate;
      return dueDate !== null && dueDate >= startOfWeek && dueDate < endOfWeek && !reminder.isCompleted;
    });
  }

  // Due Between
  static async allDueBetween(startDate: Date, endDate: Date, calendars?: readonly Calendar[]): Promise<Reminder[]> {
    return this.filterReminders(calendars, reminder => {
      const dueDate = reminder.dueDate;
      return dueDate !== null && dueDate >= startDate && dueDate < endDate;
    });
  }

  static async completedDueBetween(
    startDate: Date,
    endDate: Date,
    calendars?: readonly Calendar[],
  ): Promise<Reminder[]> {
    return this.filterReminders(calendars, reminder => {
      const dueDate = reminder.dueDate;
      return dueDate !== null && dueDate >= startDate && dueDate < endDate && reminder.isCompleted;
    });
  }

  static async incompleteDueBetween(
    startDate: Date,
    endDate: Date,
    calendars?: readonly Calendar[],
  ): Promise<Reminder[]> {
    return this.filterReminders(calendars, reminder => {
      const dueDate = reminder.dueDate;
      return dueDate !== null && dueDate >= startDate && dueDate < endDate && !reminder.isCompleted;
    });
  }

  // Completed
  static async completedToday(calendars?: readonly Calendar[]): Promise<Reminder[]> {
    const today = new Date();
    today.setHours(0, 0, 0, 0);
    const tomorrow = new Date(today);
    tomorrow.setDate(tomorrow.getDate() + 1);

    return this.filterReminders(calendars, reminder => {
      const completionDate = reminder.completionDate;
      return completionDate !== null && completionDate >= today && completionDate < tomorrow;
    });
  }

  static async completedThisWeek(calendars?: readonly Calendar[]): Promise<Reminder[]> {
    const today = new Date();
    today.setHours(0, 0, 0, 0);
    const startOfWeek = new Date(today);
    startOfWeek.setDate(today.getDate() - today.getDay());
    const endOfWeek = new Date(startOfWeek);
    endOfWeek.setDate(endOfWeek.getDate() + 7);

    return this.filterReminders(calendars, reminder => {
      const completionDate = reminder.completionDate;
      return completionDate !== null && completionDate >= startOfWeek && completionDate < endOfWeek;
    });
  }

  static async completedLastWeek(calendars?: readonly Calendar[]): Promise<Reminder[]> {
    const today = new Date();
    today.setHours(0, 0, 0, 0);
    const endOfLastWeek = new Date(today);
    endOfLastWeek.setDate(today.getDate() - today.getDay());
    const startOfLastWeek = new Date(endOfLastWeek);
    startOfLastWeek.setDate(endOfLastWeek.getDate() - 7);

    return this.filterReminders(calendars, reminder => {
      const completionDate = reminder.completionDate;
      return completionDate !== null && completionDate >= startOfLastWeek && completionDate < endOfLastWeek;
    });
  }

  // Helper method to clear all reminders (for testing)
  static clearAll(): void {
    this._reminders = [];
  }
}