sprinklers3/common/sprinklersRpc/schedule.ts

import { observable } from "mobx";
import { Moment } from "moment";

export class TimeOfDay {
    static fromMoment(m: Moment): TimeOfDay {
        return new TimeOfDay(m.hour(), m.minute(), m.second(), m.millisecond());
    }

    static fromDate(date: Date): TimeOfDay {
        return new TimeOfDay(date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds());
    }

    static equals(a: TimeOfDay | null | undefined, b: TimeOfDay | null | undefined): boolean {
        return (a === b) || ((a != null && b != null) && a.hour === b.hour &&
            a.minute === b.minute &&
            a.second === b.second &&
            a.millisecond === b.millisecond);
    }

    readonly hour: number;
    readonly minute: number;
    readonly second: number;
    readonly millisecond: number;

    constructor(hour: number = 0, minute: number = 0, second: number = 0, millisecond: number = 0) {
        this.hour = hour;
        this.minute = minute;
        this.second = second;
        this.millisecond = millisecond;
    }
}

export enum Weekday {
    Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday,
}

export const WEEKDAYS: Weekday[] = Object.keys(Weekday)
    .map((weekday) => Number(weekday))
    .filter((weekday) => !isNaN(weekday));

export enum Month {
    January = 1,
    February = 2,
    March = 3,
    April = 4,
    May = 5,
    June = 6,
    July = 7,
    August = 8,
    September = 9,
    October = 10,
    November = 11,
    December = 12,
}

export class DateOfYear {
    static readonly DEFAULT = new DateOfYear({ day: 1, month: Month.January, year: 0 });

    static equals(a: DateOfYear | null | undefined, b: DateOfYear | null | undefined): boolean {
        return (a === b) || ((a instanceof DateOfYear && b instanceof DateOfYear) &&
            a.day === b.day &&
            a.month === b.month &&
            a.year === b.year);
    }

    static fromMoment(m: Moment): DateOfYear {
        return new DateOfYear({ day: m.date(), month: m.month(), year: m.year() });
    }

    readonly day!: number;
    readonly month!: Month;
    readonly year!: number;

    constructor(data?: Partial<DateOfYear>) {
        Object.assign(this, DateOfYear.DEFAULT, data);
    }

    with(data: Partial<DateOfYear>): DateOfYear {
        return new DateOfYear(Object.assign({}, this, data));
    }

    toString() {
        return `${Month[this.month]} ${this.day}, ${this.year}`;
    }
}

export class Schedule {
    @observable times: TimeOfDay[] = [];
    @observable weekdays: Weekday[] = [];
    @observable from: DateOfYear | null = null;
    @observable to: DateOfYear | null = null;

    constructor(data?: Partial<Schedule>) {
        if (typeof data === "object") {
            Object.assign(this, data);
        }
    }

    clone(): Schedule {
        return new Schedule(this);
    }
}