scheduler-node-models 1.0.81 → 1.0.83

package/scheduler/teams/company/company.js

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Company = void 0;
+const holiday_1 = require("./holiday");
+const modperiod_1 = require("./modperiod");
+/**
+ * This class definition implements the company interface, plus necessary actions to
+ * manipulate the object.
+ */
+class Company {
+    id;
+    name;
+    ingest;
+    ingestPeriod;
+    startDay;
+    ingestPwd;
+    holidays;
+    modperiods;
+    constructor(co) {
+        this.id = (co) ? co.id : '';
+        this.name = (co) ? co.name : '';
+        this.ingest = (co) ? co.ingest : 'mexcel';
+        this.ingestPeriod = (co && co.ingestPeriod) ? co.ingestPeriod : 0;
+        this.startDay = (co && co.startDay) ? co.startDay : 0;
+        this.ingestPwd = (co) ? co.ingestPwd : '';
+        this.holidays = [];
+        if (co && co.holidays && co.holidays.length > 0) {
+            co.holidays.forEach(hol => {
+                this.holidays.push(new holiday_1.Holiday(hol));
+            });
+            this.holidays.sort((a, b) => a.compareTo(b));
+        }
+        this.modperiods = [];
+        if (co && co.modperiods && co.modperiods.length > 0) {
+            co.modperiods.forEach(mod => {
+                this.modperiods.push(new modperiod_1.ModPeriod(mod));
+            });
+            this.modperiods.sort((a, b) => a.compareTo(b));
+        }
+    }
+    /**
+     * This function is used in sorting this company with another.
+     * @param other The company object used in the comparison.
+     * @returns a numeric value to show relative position between the objects
+     */
+    compareTo(other) {
+        if (other) {
+            return (this.name.toLowerCase() < other.name.toLowerCase()) ? -1 : 1;
+        }
+        return -1;
+    }
+    /**
+     * This function is used to purge any old data from the company record, mainly holiday
+     * actual dates.
+     * @param date A date object used as the cutoff date.
+     */
+    purge(date) {
+        this.holidays.forEach((hol, h) => {
+            hol.purge(date);
+            this.holidays[h] = hol;
+        });
+        for (let m = this.modperiods.length - 1; m >= 0; m--) {
+            if (this.modperiods[m].year < date.getFullYear()) {
+                this.modperiods.splice(m, 1);
+            }
+        }
+    }
+    /**
+     * The function checks the company's list of mod periods to see if one of them fits
+     * within its start and end dates.
+     * @param date The date object for checking mod periods.
+     * @returns A boolean value to indicate if the list contains a mod period for the date.
+     */
+    hasModPeriod(date) {
+        let answer = false;
+        this.modperiods.forEach(mod => {
+            if (date.getTime() >= mod.start.getTime() || date.getTime() <= mod.end.getTime()) {
+                answer = true;
+            }
+        });
+        return answer;
+    }
+    /**
+     * This function will add a new mod period to the company's mod period list.
+     * @param year numeric value for the full year.
+     * @param start The date object to specify the first day of the company's mod period.
+     * @param end The date object to specify the last day of the company's mod period.
+     */
+    addModPeriod(year, start, end) {
+        let found = false;
+        this.modperiods.forEach((mod, m) => {
+            if (mod.year === year) {
+                mod.start = new Date(start);
+                mod.end = new Date(end);
+                this.modperiods[m] = mod;
+                found = true;
+            }
+        });
+        if (!found) {
+            this.modperiods.push(new modperiod_1.ModPeriod({
+                year: year,
+                start: new Date(start),
+                end: new Date(end)
+            }));
+            this.modperiods.sort((a, b) => a.compareTo(b));
+        }
+    }
+    /**
+     * This function is used update either the start or end dates.
+     * @param year A numeric value for the mod period's year value
+     * @param field A string value to designate which date field to update
+     * @param value A date object used in the update.
+     */
+    updateModPeriod(year, field, value) {
+        this.modperiods.forEach((mod, m) => {
+            if (mod.year === year) {
+                switch (field.toLowerCase()) {
+                    case "start":
+                        mod.start = new Date(value);
+                        break;
+                    case "end":
+                        mod.end = new Date(value);
+                        break;
+                }
+                this.modperiods[m] = mod;
+            }
+        });
+    }
+    /**
+     * This function will remove a mod period from the company's list.
+     * @param year a numeric value for the year to delete.
+     */
+    deleteModPeriod(year) {
+        let found = -1;
+        this.modperiods.forEach((mod, m) => {
+            if (mod.year === year) {
+                found = m;
+            }
+        });
+        if (found >= 0) {
+            this.modperiods.splice(found, 1);
+        }
+    }
+    /**
+     * This function checks whether a particular holiday based on a combined identifier of
+     * holiday type and a sort value is present in the company's list.
+     * @param type The holiday type value for comparison to the list
+     * @param sort A numeric value for the second part of the identifier.
+     * @returns A boolean value to signify if the holiday is present in the company's list.
+     */
+    hasHoliday(type, sort) {
+        let answer = false;
+        this.holidays.forEach(hol => {
+            if (hol.id === type && hol.sort === sort) {
+                answer = true;
+            }
+        });
+        return answer;
+    }
+    /**
+     * This function will add a new holiday, after checking for the name given.
+     * @param type The holiday type value for the new holiday
+     * @param name A string value for the name of the new holiday
+     * @returns A holiday object with the type and name.
+     */
+    addHoliday(type, name) {
+        let max = 0;
+        let holiday = new holiday_1.Holiday();
+        this.holidays.forEach(hol => {
+            if (hol.id === type && max < hol.sort) {
+                max = hol.sort;
+            }
+            if (hol.name.toLowerCase() === name.toLowerCase()) {
+                holiday = new holiday_1.Holiday(hol);
+            }
+        });
+        if (holiday.sort === 0) {
+            holiday = new holiday_1.Holiday({
+                id: type,
+                name: name,
+                sort: max + 1
+            });
+            this.holidays.push(holiday);
+        }
+        return holiday;
+    }
+    /**
+     * This function is used to update a company holiday.
+     * @param type The holiday type value for the holiday to update
+     * @param sort The sort value for the holiday to update
+     * @param field The string value to point to which field to update within the holiday.
+     * @param value The string value for the new value to update to.
+     */
+    updateHoliday(type, sort, field, value) {
+        this.holidays.sort((a, b) => a.compareTo(b));
+        this.holidays.forEach((hol, h) => {
+            if (hol.id === type && hol.sort === sort) {
+                switch (field.toLowerCase()) {
+                    case "name":
+                        hol.name = value;
+                        break;
+                    case "move":
+                        if (value.toLowerCase().substring(0, 2) === 'up') {
+                            if (h > 0) {
+                                const otherHol = this.holidays[h - 1];
+                                if (otherHol.id === hol.id) {
+                                    const temp = otherHol.sort;
+                                    otherHol.sort = hol.sort;
+                                    hol.sort = temp;
+                                    this.holidays[h - 1] = otherHol;
+                                }
+                            }
+                        }
+                        else {
+                            if (h < this.holidays.length - 1) {
+                                const otherHol = this.holidays[h + 1];
+                                if (otherHol.id === hol.id) {
+                                    const temp = otherHol.sort;
+                                    otherHol.sort = hol.sort;
+                                    hol.sort = temp;
+                                    this.holidays[h - 1] = otherHol;
+                                }
+                            }
+                        }
+                        break;
+                    case "addactual":
+                        const newActual = new Date(Date.parse(value));
+                        hol.addActual(newActual);
+                        break;
+                    case "deleteactual":
+                        const oldActual = new Date(Date.parse(value));
+                        hol.deleteActual(oldActual);
+                        break;
+                }
+                this.holidays[h] = hol;
+            }
+        });
+    }
+    /**
+     * This function will remove the company holiday based on the type and identifier.
+     * @param type The holiday type to look for
+     * @param sort The numeric identifier for the holiday type.
+     */
+    deleteHoliday(type, sort) {
+        let found = -1;
+        this.holidays.forEach((hol, h) => {
+            if (hol.id === type && hol.sort === sort) {
+                found = h;
+            }
+        });
+        if (found >= 0) {
+            this.holidays.splice(found, 1);
+        }
+    }
+}
+exports.Company = Company;

package/scheduler/teams/company/holiday.d.ts

@@ -0,0 +1,55 @@
+export declare enum HolidayType {
+    holiday = "H",
+    floating = "F"
+}
+/**
+ * This interface holds a listed company holiday and the data members involved.  The
+ * id is either H for regular, date determined holiday and F for floating or date-less
+ * holiday.  The sort value is the sort order within the company's H and F types holidays.
+ */
+export interface IHoliday {
+    id: HolidayType;
+    name: string;
+    sort: number;
+    actualdates?: Date[];
+}
+/**
+ * This class definition implements the holiday interface and add needed actions to
+ * manipulate the holiday object.
+ */
+export declare class Holiday implements IHoliday {
+    id: HolidayType;
+    name: string;
+    sort: number;
+    actualdates: Date[];
+    constructor(hol?: IHoliday);
+    /**
+     * This function is used in sorting holidays by comparing their ids and sort values
+     * @param other The holiday object used in comparison
+     * @returns A numeric value for relative location compared to other (-1 before, 1 after).
+     */
+    compareTo(other?: Holiday): 1 | -1;
+    /**
+     * This function will retrieve any set date for the actual holiday, based on the year
+     * provided.
+     * @param year The numeric (integer) value for the 4-digit year
+     * @returns A date object or undefined for the set day of the year.
+     */
+    getActual(year: number): Date | undefined;
+    /**
+     * The function will add a new date to the actuals list, if not already present.
+     * @param date The date object to add.
+     */
+    addActual(date: Date): void;
+    /**
+     * The function will remove a date from the actuals list.
+     * @param date The date object to remove.
+     */
+    deleteActual(date: Date): void;
+    /**
+     * This function will check the holiday's actual dates for dates before a cutoff date
+     * and remove them from the object.
+     * @param date The date object used as a cutoff for the purged dates.
+     */
+    purge(date: Date): void;
+}

package/scheduler/teams/company/holiday.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Holiday = exports.HolidayType = void 0;
+var HolidayType;
+(function (HolidayType) {
+    HolidayType["holiday"] = "H";
+    HolidayType["floating"] = "F";
+})(HolidayType || (exports.HolidayType = HolidayType = {}));
+/**
+ * This class definition implements the holiday interface and add needed actions to
+ * manipulate the holiday object.
+ */
+class Holiday {
+    id;
+    name;
+    sort;
+    actualdates;
+    constructor(hol) {
+        this.id = (hol) ? hol.id : HolidayType.holiday;
+        this.name = (hol) ? hol.name : '';
+        this.sort = (hol) ? hol.sort : 0;
+        this.actualdates = [];
+        if (hol && hol.actualdates && hol.actualdates.length > 0) {
+            hol.actualdates.forEach(dt => {
+                this.actualdates.push(new Date(dt));
+            });
+            this.actualdates.sort((a, b) => (a.getTime() < b.getTime()) ? -1 : 1);
+        }
+    }
+    /**
+     * This function is used in sorting holidays by comparing their ids and sort values
+     * @param other The holiday object used in comparison
+     * @returns A numeric value for relative location compared to other (-1 before, 1 after).
+     */
+    compareTo(other) {
+        if (other) {
+            if (this.id.toLowerCase() === other.id.toLowerCase()) {
+                return (this.sort < other.sort) ? -1 : 1;
+            }
+            return (this.id.toLowerCase() === 'h') ? -1 : 1;
+        }
+        return -1;
+    }
+    /**
+     * This function will retrieve any set date for the actual holiday, based on the year
+     * provided.
+     * @param year The numeric (integer) value for the 4-digit year
+     * @returns A date object or undefined for the set day of the year.
+     */
+    getActual(year) {
+        let answer = undefined;
+        const start = new Date(Date.UTC(year, 0, 1));
+        const end = new Date(Date.UTC(year + 1, 0, 1));
+        this.actualdates.forEach(dt => {
+            if (dt.getTime() >= start.getTime() && dt.getTime() < end.getTime()) {
+                answer = new Date(dt);
+            }
+        });
+        return answer;
+    }
+    /**
+     * The function will add a new date to the actuals list, if not already present.
+     * @param date The date object to add.
+     */
+    addActual(date) {
+        let found = false;
+        this.actualdates.forEach(ad => {
+            if (ad.getUTCFullYear() === date.getUTCFullYear()
+                && ad.getUTCMonth() === date.getUTCMonth()
+                && ad.getUTCDate() === date.getUTCDate()) {
+                found = true;
+            }
+        });
+        this.actualdates.push(new Date(date));
+    }
+    /**
+     * The function will remove a date from the actuals list.
+     * @param date The date object to remove.
+     */
+    deleteActual(date) {
+        let found = -1;
+        this.actualdates.forEach((ad, a) => {
+            if (ad.getUTCFullYear() === date.getUTCFullYear()
+                && ad.getUTCMonth() === date.getUTCMonth()
+                && ad.getUTCDate() === date.getUTCDate()) {
+                found = a;
+            }
+        });
+        if (found >= 0) {
+            this.actualdates.splice(found, 1);
+        }
+    }
+    /**
+     * This function will check the holiday's actual dates for dates before a cutoff date
+     * and remove them from the object.
+     * @param date The date object used as a cutoff for the purged dates.
+     */
+    purge(date) {
+        for (let i = this.actualdates.length - 1; i >= 0; i--) {
+            if (this.actualdates[i].getTime() < date.getTime()) {
+                // checking to see if the actual date is before the cutoff date given.
+                // if so, remove it from the list.
+                this.actualdates.splice(i, 1);
+            }
+        }
+    }
+}
+exports.Holiday = Holiday;

package/scheduler/teams/company/index.d.ts

@@ -0,0 +1,3 @@
+export * from './holiday';
+export * from './modperiod';
+export * from './company';

package/scheduler/teams/company/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./holiday"), exports);
+__exportStar(require("./modperiod"), exports);
+__exportStar(require("./company"), exports);

package/scheduler/teams/company/modperiod.d.ts

@@ -0,0 +1,21 @@
+/**
+ * This interface defines a company's modified work period for pay recording.  The
+ * modified work period is to ensure employee's can't carry over modified time from one
+ * fiscal period to another, so it has definitive start and ending dates.
+ */
+export interface IModPeriod {
+    year: number;
+    start: Date;
+    end: Date;
+}
+/**
+ * This class defines the implementation of the company's modified work period, plus an
+ * action to sort the periods with.
+ */
+export declare class ModPeriod implements IModPeriod {
+    year: number;
+    start: Date;
+    end: Date;
+    constructor(mod?: IModPeriod);
+    compareTo(other?: ModPeriod): number;
+}

package/scheduler/teams/company/modperiod.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModPeriod = void 0;
+/**
+ * This class defines the implementation of the company's modified work period, plus an
+ * action to sort the periods with.
+ */
+class ModPeriod {
+    year;
+    start;
+    end;
+    constructor(mod) {
+        this.year = (mod) ? mod.year : 0;
+        this.start = (mod) ? new Date(mod.start) : new Date(0);
+        this.end = (mod) ? new Date(mod.end) : new Date(0);
+    }
+    compareTo(other) {
+        if (other) {
+            return (this.year < other.year) ? -1 : 1;
+        }
+        return -1;
+    }
+}
+exports.ModPeriod = ModPeriod;

package/scheduler/teams/contact.d.ts

@@ -0,0 +1,18 @@
+/**
+ * This interface defines the data members for a contact type.
+ */
+export interface IContact {
+    id: number;
+    name: string;
+    sort: number;
+}
+/**
+ * this class defines the implementation of the contact type plus actions
+ */
+export declare class Contact implements IContact {
+    id: number;
+    name: string;
+    sort: number;
+    constructor(co?: IContact);
+    compareTo(other?: Contact): number;
+}

package/scheduler/teams/contact.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Contact = void 0;
+/**
+ * this class defines the implementation of the contact type plus actions
+ */
+class Contact {
+    id;
+    name;
+    sort;
+    constructor(co) {
+        this.id = (co) ? co.id : 0;
+        this.name = (co) ? co.name : '';
+        this.sort = (co) ? co.sort : 0;
+    }
+    compareTo(other) {
+        if (other) {
+            return (this.sort < other.sort) ? -1 : 1;
+        }
+        return -1;
+    }
+}
+exports.Contact = Contact;

package/scheduler/teams/index.d.ts

@@ -0,0 +1,3 @@
+export * from './contact';
+export * from './specialty';
+export * from './team';

package/scheduler/teams/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./contact"), exports);
+__exportStar(require("./specialty"), exports);
+__exportStar(require("./team"), exports);

package/scheduler/teams/specialty.d.ts

@@ -0,0 +1,18 @@
+/**
+ * This interface defines the data members for a specialty
+ */
+export interface ISpecialty {
+    id: number;
+    name: string;
+    sort: number;
+}
+/**
+ * This class defines the implementation of the specialty infterface plus action.
+ */
+export declare class Specialty implements ISpecialty {
+    id: number;
+    name: string;
+    sort: number;
+    constructor(sp?: ISpecialty);
+    compareTo(other?: Specialty): number;
+}

package/scheduler/teams/specialty.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Specialty = void 0;
+/**
+ * This class defines the implementation of the specialty infterface plus action.
+ */
+class Specialty {
+    id;
+    name;
+    sort;
+    constructor(sp) {
+        this.id = (sp) ? sp.id : 0;
+        this.sort = (sp) ? sp.sort : 0;
+        this.name = (sp) ? sp.name : '';
+    }
+    compareTo(other) {
+        if (other) {
+            return (this.sort < other.sort) ? -1 : 1;
+        }
+        return -1;
+    }
+}
+exports.Specialty = Specialty;