scheduler-node-models 1.2.1 → 1.2.2

package/scheduler/employees/work.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkRecord = exports.Work = void 0;
+/**
+ * This class description for a work object. The data members are:
+ * date worked (date object for the date the work record),
+ * charge number (string value for the labor code's charge number),
+ * extension (string value for the labor code's extension),
+ * paycode (numeric value for the pay code used by the company),
+ * modtime (boolean value to indicate if the recorded information is for modified time),
+ * hours (numeric value for the number of hours worked for the labor code)
+ */
+class Work {
+    dateworked;
+    chargenumber;
+    extension;
+    paycode;
+    modtime;
+    hours;
+    constructor(wk) {
+        this.dateworked = (wk) ? new Date(wk.dateworked) : new Date(0);
+        this.chargenumber = (wk) ? wk.chargenumber : '';
+        this.extension = (wk) ? wk.extension : '';
+        this.paycode = (wk) ? wk.paycode : 1;
+        this.modtime = (wk && wk.modtime) ? wk.modtime : false;
+        this.hours = (wk) ? wk.hours : 0.0;
+    }
+    /**
+     * This function is used in sorting work objects.  Based on date worked and the labor
+     * code.
+     * @param other The work object to use in comparison
+     * @returns A numeric value to indicate whether this object is before or after the other
+     * object.  -1 is before or 1 for after.
+     */
+    compareTo(other) {
+        if (other) {
+            if (this.dateworked.getTime() === other.dateworked.getTime()) {
+                if (this.chargenumber === other.chargenumber) {
+                    return this.extension < other.extension ? -1 : 1;
+                }
+                return this.chargenumber < other.chargenumber ? -1 : 1;
+            }
+            return this.dateworked.getTime() < other.dateworked.getTime() ? -1 : 1;
+        }
+        return -1;
+    }
+    /**
+     * This function is used to compare this object's date worked with a date provided.
+     * @param date A date object used for comparison.
+     * @returns A boolean value to indicate whether the work object is on the date provided.
+     */
+    useWork(date) {
+        return this.dateworked.getUTCFullYear() === date.getUTCFullYear()
+            && this.dateworked.getUTCMonth() === date.getUTCMonth()
+            && this.dateworked.getUTCDate() === date.getUTCDate();
+    }
+}
+exports.Work = Work;
+/**
+ * This class description for the employee's yearly work record.  The data members are:
+ * id (string value representing the database's _id value - primary key)
+ * empID (string value for the associated employee's identifier)
+ * year (numeric value for the year associated with the work records)
+ * work (an array of work objects containing all the actual work performed)
+ */
+class WorkRecord {
+    id;
+    empID;
+    year;
+    work;
+    constructor(wr) {
+        this.id = (wr && wr.id) ? wr.id : '';
+        if (this.id === '') {
+            this.id = (wr && wr._id) ? wr._id.toString() : '';
+        }
+        this.empID = (wr && wr.empID) ? wr.empID : '';
+        if (this.empID === '') {
+            this.empID = (wr && wr.employeeID) ? wr.employeeID.toString() : '';
+        }
+        this.year = (wr) ? wr.year : (new Date()).getFullYear();
+        this.work = [];
+        if (wr && wr.work && wr.work.length > 0) {
+            wr.work.forEach(wk => {
+                this.work.push(new Work(wk));
+            });
+            this.work.sort((a, b) => a.compareTo(b));
+        }
+    }
+    /**
+     * This function is used in sorting these annual work records.  Based on employee
+     * identifier and year.
+     * @param other The annual work record used for comparison.
+     * @returns A numeric value to indicate whether this object is before or after the other
+     * object.  -1 is before or 1 for after.
+     */
+    compareTo(other) {
+        if (other) {
+            if (this.empID === other.empID) {
+                return (this.year < other.year) ? -1 : 1;
+            }
+            return (this.empID < other.empID) ? -1 : 1;
+        }
+        return -1;
+    }
+    /**
+     * This function will remove work objects from this object's work array based on the
+     * period defined by the start and end dates.
+     * @param start The date object for the start of the removal period
+     * @param end The date object for the end of the removal period
+     */
+    removeWork(start, end) {
+        for (let w = this.work.length - 1; w >= 0; w--) {
+            if (this.work[w].dateworked.getTime() >= start.getTime()
+                && this.work[w].dateworked.getTime() <= end.getTime()) {
+                this.work.splice(w, 1);
+            }
+        }
+    }
+    /**
+     * This function will remove work objects from this object's work array
+     * @param purgeDate The date object to remove all data before it.
+     * @returns A boolean value to indicate whether or not the work array is empty.
+     */
+    purge(purgeDate) {
+        for (let w = this.work.length - 1; w >= 0; w--) {
+            if (this.work[w].dateworked.getTime() < purgeDate.getTime()) {
+                this.work.splice(w, 1);
+            }
+        }
+        return this.work.length === 0;
+    }
+}
+exports.WorkRecord = WorkRecord;

package/scheduler/employees/workday.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Workday interface and class descriptions
+ */
+/**
+ * This interface describes the data members to describe a workday object.
+ */
+export interface IWorkday {
+    id: number;
+    workcenter: string;
+    code: string;
+    hours: number;
+}
+/**
+ * This class provide the data members and the action a workday can complete.  It will be
+ * used a children of a schedule class object in an assignment or variation.
+ */
+export declare class Workday implements IWorkday {
+    id: number;
+    workcenter: string;
+    code: string;
+    hours: number;
+    constructor(wd?: IWorkday);
+    /**
+     * This function is used to sort two workday objects based on the workday's identifier.
+     * @param other The workday object used for the comparison
+     * @returns A number value to signify this object is before or after the other.  -1
+     * represents before and 1 for after.
+     */
+    compareTo(other?: Workday): number;
+}
+/**
+ * The schedule class and interface is for holding workdays within an assignment
+ * and variation.
+ */
+/**
+ * This interface describes the data members to describe a schedule object.
+ */
+export interface ISchedule {
+    id: number;
+    workdays: IWorkday[];
+    showdates?: boolean;
+}
+/**
+ * This class provide the data members and the action a schedule can complete.  It will be
+ * used a children of an assignment or variation.
+ */
+export declare class Schedule implements ISchedule {
+    id: number;
+    workdays: Workday[];
+    showdates: boolean;
+    constructor(sch?: ISchedule);
+    /**
+     * This function will be used to sort multiple schedules based on the schedules' id.
+     * @param other A schedule object used for comparison
+     * @returns A numeric value to indicate whether the schedule is before or after the
+     * other schedule in a list.  -1 for before and 1 for after.
+     */
+    compareTo(other?: Schedule): number;
+    /**
+     * This function will retrieve a workday from the list based on the identifier provided.
+     * @param id A numeric value for the identifier
+     * @returns A workday object representing the requested workday.
+     */
+    getWorkday(id: number): Workday;
+    /**
+     * This function allows the caller to update a schedule's workday with the values
+     * provided.
+     * @param id A numeric value to identify which workday to update.
+     * @param wkctr A string value representing the workcenter.
+     * @param code A string value representing the work code (shift) to assign.
+     * @param hours A numeric value (float) for the number of hours to work.
+     */
+    changeWorkday(id: number, wkctr: string, code: string, hours: number): void;
+    /**
+     * This function will update a field on a particular workday, based on the field and
+     * value.
+     * @param id The numeric value to identify which workday object to change.
+     * @param field The string value used to identify which data member to update.
+     * @param value The string value representing the new value, either string or numeric
+     * value given as a string.
+     */
+    updateWorkday(id: number, field: string, value: string): void;
+    /**
+     * This function will either add or subtract workdays from the list to ensure
+     * that there was a certain number of days in the schedule.  All schedules must
+     * contain a multiple of 7 workdays.
+     * @param days A numeric value, greater than zero (0) and a multiple of 7.
+     * @throws An error indicating the provided parameter is zero or not a multiple of 7.
+     */
+    setScheduleDays(days: number): void;
+}

package/scheduler/employees/workday.js

@@ -0,0 +1,170 @@
+"use strict";
+/**
+ * Workday interface and class descriptions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Schedule = exports.Workday = void 0;
+/**
+ * This class provide the data members and the action a workday can complete.  It will be
+ * used a children of a schedule class object in an assignment or variation.
+ */
+class Workday {
+    id;
+    workcenter;
+    code;
+    hours;
+    constructor(wd) {
+        this.id = (wd) ? wd.id : 0;
+        this.workcenter = (wd) ? wd.workcenter : '';
+        this.code = (wd) ? wd.code : '';
+        this.hours = (wd) ? wd.hours : 0;
+    }
+    /**
+     * This function is used to sort two workday objects based on the workday's identifier.
+     * @param other The workday object used for the comparison
+     * @returns A number value to signify this object is before or after the other.  -1
+     * represents before and 1 for after.
+     */
+    compareTo(other) {
+        if (other) {
+            return (this.id < other.id) ? -1 : 1;
+        }
+        return 0;
+    }
+}
+exports.Workday = Workday;
+/**
+ * This class provide the data members and the action a schedule can complete.  It will be
+ * used a children of an assignment or variation.
+ */
+class Schedule {
+    id;
+    workdays;
+    showdates;
+    constructor(sch) {
+        this.id = (sch) ? sch.id : 0;
+        this.workdays = [];
+        if (sch && sch.workdays.length > 0) {
+            sch.workdays.forEach(wd => {
+                this.workdays.push(new Workday(wd));
+            });
+            this.workdays.sort((a, b) => a.compareTo(b));
+        }
+        this.showdates = (sch && sch.showdates) ? sch.showdates : false;
+    }
+    /**
+     * This function will be used to sort multiple schedules based on the schedules' id.
+     * @param other A schedule object used for comparison
+     * @returns A numeric value to indicate whether the schedule is before or after the
+     * other schedule in a list.  -1 for before and 1 for after.
+     */
+    compareTo(other) {
+        if (other) {
+            return (this.id < other.id) ? -1 : 1;
+        }
+        return -1;
+    }
+    /**
+     * This function will retrieve a workday from the list based on the identifier provided.
+     * @param id A numeric value for the identifier
+     * @returns A workday object representing the requested workday.
+     */
+    getWorkday(id) {
+        let result = new Workday();
+        this.workdays.forEach(wd => {
+            if (wd.id === id) {
+                result = new Workday(wd);
+            }
+        });
+        return result;
+    }
+    /**
+     * This function allows the caller to update a schedule's workday with the values
+     * provided.
+     * @param id A numeric value to identify which workday to update.
+     * @param wkctr A string value representing the workcenter.
+     * @param code A string value representing the work code (shift) to assign.
+     * @param hours A numeric value (float) for the number of hours to work.
+     */
+    changeWorkday(id, wkctr, code, hours) {
+        let found = false;
+        for (let w = 0; w < this.workdays.length && !found; w++) {
+            const wd = this.workdays[w];
+            if (wd.id === id) {
+                found = true;
+                wd.hours = hours;
+                wd.code = code;
+                wd.workcenter = wkctr;
+                this.workdays[w] = wd;
+            }
+        }
+        if (!found) {
+            const wd = new Workday({
+                id: id,
+                workcenter: wkctr,
+                code: code,
+                hours: hours
+            });
+            this.workdays.push(wd);
+            this.workdays.sort((a, b) => a.compareTo(b));
+        }
+    }
+    /**
+     * This function will update a field on a particular workday, based on the field and
+     * value.
+     * @param id The numeric value to identify which workday object to change.
+     * @param field The string value used to identify which data member to update.
+     * @param value The string value representing the new value, either string or numeric
+     * value given as a string.
+     */
+    updateWorkday(id, field, value) {
+        let found = false;
+        for (let w = 0; w < this.workdays.length && !found; w++) {
+            const wd = this.workdays[w];
+            if (wd.id === id) {
+                found = true;
+                switch (field.toLowerCase()) {
+                    case "workcenter":
+                        wd.workcenter = value;
+                        break;
+                    case "code":
+                        wd.code = value;
+                        break;
+                    case 'hours':
+                        wd.hours = Number(value);
+                        break;
+                }
+                this.workdays[w] = wd;
+            }
+        }
+    }
+    /**
+     * This function will either add or subtract workdays from the list to ensure
+     * that there was a certain number of days in the schedule.  All schedules must
+     * contain a multiple of 7 workdays.
+     * @param days A numeric value, greater than zero (0) and a multiple of 7.
+     * @throws An error indicating the provided parameter is zero or not a multiple of 7.
+     */
+    setScheduleDays(days) {
+        if (days <= 0 || days % 7 !== 0) {
+            throw new Error('New days value must be greater than zero and a multiple of seven');
+        }
+        this.workdays.sort((a, b) => a.compareTo(b));
+        if (days > this.workdays.length) {
+            for (let w = this.workdays.length; w < days; w++) {
+                const wd = new Workday();
+                wd.id = w;
+                this.workdays.push(wd);
+            }
+        }
+        else if (days < this.workdays.length) {
+            while (this.workdays.length > days) {
+                this.workdays.pop();
+            }
+        }
+        for (let w = 0; w < this.workdays.length; w++) {
+            this.workdays[w].id = w;
+        }
+    }
+}
+exports.Schedule = Schedule;

package/scheduler/labor/index.d.ts

@@ -0,0 +1,2 @@
+export * from './workcode';
+export * from './laborcode';

package/scheduler/labor/index.js

@@ -0,0 +1,18 @@
+"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("./workcode"), exports);
+__exportStar(require("./laborcode"), exports);

package/scheduler/labor/laborcode.d.ts

@@ -0,0 +1,33 @@
+export interface ILaborCode {
+    chargeNumber: string;
+    extension: string;
+    clin?: string;
+    slin?: string;
+    location?: string;
+    wbs?: string;
+    minimumEmployees?: number;
+    notAssignedName?: string;
+    hoursPerEmployee?: number;
+    exercise?: boolean;
+    startDate?: Date;
+    endDate?: Date;
+    sort?: number;
+}
+export declare class LaborCode implements ILaborCode {
+    chargeNumber: string;
+    extension: string;
+    clin?: string;
+    slin?: string;
+    location?: string;
+    wbs?: string;
+    minimumEmployees?: number;
+    notAssignedName?: string;
+    hoursPerEmployee?: number;
+    exercise?: boolean;
+    startDate?: Date;
+    endDate?: Date;
+    sort: number;
+    constructor(lc?: ILaborCode);
+    compareTo(other?: LaborCode): 1 | -1;
+    inTimePeriod(start: Date, end: Date): boolean;
+}

package/scheduler/labor/laborcode.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LaborCode = void 0;
+class LaborCode {
+    chargeNumber;
+    extension;
+    clin;
+    slin;
+    location;
+    wbs;
+    minimumEmployees;
+    notAssignedName;
+    hoursPerEmployee;
+    exercise;
+    startDate;
+    endDate;
+    sort;
+    constructor(lc) {
+        this.chargeNumber = (lc) ? lc.chargeNumber : '';
+        this.extension = (lc) ? lc.extension : '';
+        this.clin = (lc && lc.clin) ? lc.clin : undefined;
+        this.slin = (lc && lc.slin) ? lc.slin : undefined;
+        this.location = (lc && lc.location) ? lc.location : undefined;
+        this.wbs = (lc && lc.wbs) ? lc.wbs : undefined;
+        this.minimumEmployees = (lc && lc.minimumEmployees) ? lc.minimumEmployees : undefined;
+        this.notAssignedName = (lc && lc.notAssignedName) ? lc.notAssignedName : undefined;
+        this.hoursPerEmployee = (lc && lc.hoursPerEmployee) ? lc.hoursPerEmployee : undefined;
+        this.exercise = (lc && lc.exercise) ? lc.exercise : undefined;
+        this.startDate = (lc && lc.startDate) ? lc.startDate : undefined;
+        this.endDate = (lc && lc.endDate) ? lc.endDate : undefined;
+        this.sort = (lc && lc.sort) ? lc.sort : 0;
+    }
+    compareTo(other) {
+        if (other) {
+            if (this.sort === other.sort) {
+                if (this.chargeNumber.toLowerCase() === other.chargeNumber.toLowerCase()) {
+                    return (this.extension.toLowerCase() < other.extension.toLowerCase()) ? -1 : 1;
+                }
+                return (this.chargeNumber.toLowerCase() < other.chargeNumber.toLowerCase()) ? -1 : 1;
+            }
+            return (this.sort < other.sort) ? -1 : 1;
+        }
+        return -1;
+    }
+    inTimePeriod(start, end) {
+        if (this.startDate && this.endDate) {
+            return ((start.getTime() >= this.startDate.getTime()
+                && start.getTime() <= this.endDate.getTime())
+                || (end.getTime() >= this.startDate.getTime()
+                    && end.getTime() <= this.endDate.getTime()));
+        }
+        return true;
+    }
+}
+exports.LaborCode = LaborCode;

package/scheduler/labor/workcode.d.ts

@@ -0,0 +1,28 @@
+export interface IWorkcode {
+    id: string;
+    title: string;
+    start: number;
+    shiftCode: string;
+    altcode?: string;
+    search?: string;
+    isLeave: boolean;
+    textcolor: string;
+    backcolor: string;
+}
+export declare class Workcode implements IWorkcode {
+    id: string;
+    title: string;
+    start: number;
+    shiftCode: string;
+    altcode?: string;
+    search?: string;
+    isLeave: boolean;
+    textcolor: string;
+    backcolor: string;
+    constructor(wc?: IWorkcode);
+    compareTo(other?: Workcode): number;
+}
+export interface CompareWorkCode {
+    code: string;
+    isLeave: boolean;
+}

package/scheduler/labor/workcode.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Workcode = void 0;
+class Workcode {
+    id;
+    title;
+    start;
+    shiftCode;
+    altcode;
+    search;
+    isLeave;
+    textcolor;
+    backcolor;
+    constructor(wc) {
+        this.id = (wc) ? wc.id : '';
+        this.title = (wc) ? wc.title : '';
+        this.start = (wc) ? wc.start : 7;
+        this.shiftCode = (wc) ? wc.shiftCode : '';
+        this.altcode = (wc && wc.altcode) ? wc.altcode : undefined;
+        this.search = (wc && wc.search) ? wc.search : undefined;
+        this.isLeave = (wc) ? wc.isLeave : false;
+        this.textcolor = (wc) ? wc.textcolor : '000000';
+        this.backcolor = (wc) ? wc.backcolor : 'ffffff';
+    }
+    compareTo(other) {
+        if (other) {
+            if (this.isLeave === other.isLeave) {
+                return (this.id < other.id) ? -1 : 1;
+            }
+            return (this.isLeave && !other.isLeave) ? -1 : 1;
+        }
+        return -1;
+    }
+}
+exports.Workcode = Workcode;

package/scheduler/sites/index.d.ts

@@ -0,0 +1 @@
+export * from './site';

package/scheduler/sites/index.js

@@ -0,0 +1,17 @@
+"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("./site"), exports);

package/scheduler/sites/reports/cofsReport.d.ts

@@ -0,0 +1,41 @@
+import { Employee } from "../../employees";
+import { Workcode } from "../../labor";
+import { ISection, Section } from "./section";
+/**
+ * This interface will define the data members associated with a CofS Report.
+ */
+export interface ICofSReport {
+    id: number;
+    name: string;
+    shortname: string;
+    unit: string;
+    startdate: Date;
+    enddate: Date;
+    sections?: ISection[];
+}
+/**
+ * This class implements the interface data members plus actions.
+ */
+export declare class CofSReport implements ICofSReport {
+    id: number;
+    name: string;
+    shortname: string;
+    unit: string;
+    startdate: Date;
+    enddate: Date;
+    sections: Section[];
+    constructor(rpt?: ICofSReport);
+    compareTo(other?: CofSReport): number;
+    use(start: Date, end: Date): boolean;
+    /**
+     * This function will create an XML file from a CofS Report description.
+     * @param start The date object used for the start of the report period.
+     * @param end The date object used to signify the end of the period, but not included
+     * in the report (1st day of next month).
+     * @param workcodes The list of work codes used to signify shift or leave.
+     * @param employees The list of possible employees used in this report.  Usually a list
+     * of the site's employees.
+     * @returns A File object for the XML data.
+     */
+    create(start: Date, end: Date, workcodes: Map<string, Workcode>, employees: Employee[]): File;
+}