scheduler-node-models 1.0.81 → 1.0.83

package/scheduler/sites/site.d.ts

@@ -0,0 +1,39 @@
+import { Employee } from "../employees";
+import { ILaborCode, LaborCode } from "../labor";
+import { CofSReport, ICofSReport } from "./reports/cofsReport";
+import { Forecast, IForecast } from "./reports/forecast";
+import { IWorkcenter, Workcenter } from "./workcenters/workcenter";
+/**
+ * This interface defined the data members for a team site.
+ */
+export interface ISite {
+    id: string;
+    name: string;
+    utcOffset: number;
+    showMids: boolean;
+    workcenters?: IWorkcenter[];
+    laborCodes?: ILaborCode[];
+    forecasts?: IForecast[];
+    cofs?: ICofSReport[];
+}
+/**
+ * This class implements the Site interface data members and actions.
+ */
+export declare class Site implements ISite {
+    id: string;
+    name: string;
+    utcOffset: number;
+    showMids: boolean;
+    workcenters: Workcenter[];
+    laborCodes: LaborCode[];
+    forecasts: Forecast[];
+    cofs: CofSReport[];
+    employees?: Employee[];
+    constructor(site?: ISite);
+    /**
+     * This function is used for sorting sites
+     * @param other another site object to use in comparison
+     * @returns A numeric value for the relative position of this site to another.
+     */
+    compareTo(other?: Site): number;
+}

package/scheduler/sites/site.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Site = void 0;
+const labor_1 = require("../labor");
+const forecast_1 = require("./reports/forecast");
+const workcenter_1 = require("./workcenters/workcenter");
+/**
+ * This class implements the Site interface data members and actions.
+ */
+class Site {
+    id;
+    name;
+    utcOffset;
+    showMids;
+    workcenters;
+    laborCodes;
+    forecasts;
+    cofs;
+    employees;
+    constructor(site) {
+        this.id = (site) ? site.id : '';
+        this.name = (site) ? site.name : '';
+        this.utcOffset = (site) ? site.utcOffset : 0;
+        this.showMids = (site) ? site.showMids : false;
+        this.workcenters = [];
+        if (site && site.workcenters) {
+            site.workcenters.forEach(wc => {
+                this.workcenters.push(new workcenter_1.Workcenter(wc));
+            });
+            this.workcenters.sort((a, b) => a.compareTo(b));
+        }
+        this.laborCodes = [];
+        if (site && site.laborCodes) {
+            site.laborCodes.forEach(lc => {
+                this.laborCodes.push(new labor_1.LaborCode(lc));
+            });
+            this.laborCodes.sort((a, b) => a.compareTo(b));
+        }
+        this.forecasts = [];
+        if (site && site.forecasts) {
+            site.forecasts.forEach(fcst => {
+                this.forecasts.push(new forecast_1.Forecast(fcst));
+            });
+            this.forecasts.sort((a, b) => a.compareTo(b));
+        }
+        this.cofs = [];
+        this.employees = [];
+    }
+    /**
+     * This function is used for sorting sites
+     * @param other another site object to use in comparison
+     * @returns A numeric value for the relative position of this site to another.
+     */
+    compareTo(other) {
+        if (other) {
+            return (this.name < other.name) ? -1 : 1;
+        }
+        return -1;
+    }
+}
+exports.Site = Site;

package/scheduler/sites/workcenters/index.d.ts

@@ -0,0 +1,3 @@
+export * from './position';
+export * from './shift';
+export * from './workcenter';

package/scheduler/sites/workcenters/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("./position"), exports);
+__exportStar(require("./shift"), exports);
+__exportStar(require("./workcenter"), exports);

package/scheduler/sites/workcenters/position.d.ts

@@ -0,0 +1,27 @@
+import { Employee } from "../../employees";
+/**
+ * This interface defines the data members for a duty position
+ */
+export interface IPosition {
+    id: string;
+    name: string;
+    sort: number;
+    assigned: string[];
+}
+/**
+ * This class implements the basic duty position definition plus actions.
+ */
+export declare class Position implements IPosition {
+    id: string;
+    name: string;
+    sort: number;
+    assigned: string[];
+    employees?: Employee[];
+    constructor(pos?: IPosition);
+    /**
+     * This function will be used to sort duty positions within a list
+     * @param other A position object to compare against this one.
+     * @returns A numeric value for its relative position to the other.
+     */
+    compareTo(other?: Position): number;
+}

package/scheduler/sites/workcenters/position.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Position = void 0;
+/**
+ * This class implements the basic duty position definition plus actions.
+ */
+class Position {
+    id;
+    name;
+    sort;
+    assigned;
+    employees;
+    constructor(pos) {
+        this.id = (pos) ? pos.id : '';
+        this.name = (pos) ? pos.name : '';
+        this.sort = (pos) ? pos.sort : 0;
+        this.assigned = [];
+        if (pos) {
+            pos.assigned.forEach(emp => {
+                this.assigned.push(emp);
+            });
+        }
+    }
+    /**
+     * This function will be used to sort duty positions within a list
+     * @param other A position object to compare against this one.
+     * @returns A numeric value for its relative position to the other.
+     */
+    compareTo(other) {
+        if (other) {
+            return (this.sort < other.sort) ? -1 : 1;
+        }
+        return -1;
+    }
+}
+exports.Position = Position;

package/scheduler/sites/workcenters/shift.d.ts

@@ -0,0 +1,32 @@
+import { Employee } from "../../employees";
+/**
+ * This interface defines the data members associated with a shift
+ */
+export interface IShift {
+    id: string;
+    name: string;
+    sort: number;
+    associatedCodes: string[];
+    payCode: number;
+    minimums: number;
+}
+/**
+ * This class definition implements the basic shift object plus actions.
+ */
+export declare class Shift implements IShift {
+    id: string;
+    name: string;
+    sort: number;
+    associatedCodes: string[];
+    payCode: number;
+    minimums: number;
+    employees?: Employee[];
+    constructor(shft?: IShift);
+    /**
+     * This function will be used to sort this shift with others.
+     * @param other A Shift object to compare against
+     * @returns A numeric value for the relative position to the other.
+     */
+    compareTo(other?: Shift): number;
+    belowMinimums(): boolean;
+}

package/scheduler/sites/workcenters/shift.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Shift = void 0;
+/**
+ * This class definition implements the basic shift object plus actions.
+ */
+class Shift {
+    id;
+    name;
+    sort;
+    associatedCodes;
+    payCode;
+    minimums;
+    employees;
+    constructor(shft) {
+        this.id = (shft) ? shft.id : '';
+        this.name = (shft) ? shft.name : '';
+        this.sort = (shft) ? shft.sort : 0;
+        this.associatedCodes = [];
+        if (shft) {
+            shft.associatedCodes.forEach(code => {
+                this.associatedCodes.push(code);
+            });
+            this.associatedCodes.sort();
+        }
+        this.payCode = (shft) ? shft.payCode : 1;
+        this.minimums = (shft) ? shft.minimums : 1;
+    }
+    /**
+     * This function will be used to sort this shift with others.
+     * @param other A Shift object to compare against
+     * @returns A numeric value for the relative position to the other.
+     */
+    compareTo(other) {
+        if (other) {
+            return (this.sort < other.sort) ? -1 : 1;
+        }
+        return -1;
+    }
+    belowMinimums() {
+        if (this.employees) {
+            return this.employees.length < this.minimums;
+        }
+        return (this.minimums > 0);
+    }
+}
+exports.Shift = Shift;

package/scheduler/sites/workcenters/workcenter.d.ts

@@ -0,0 +1,43 @@
+import { Employee } from "../../employees";
+import { IPosition, Position } from "./position";
+import { IShift, Shift } from "./shift";
+/**
+ * This interface will define a workcenter.
+ */
+export interface IWorkcenter {
+    id: string;
+    name: string;
+    sort: number;
+    shifts?: IShift[];
+    positions?: IPosition[];
+}
+/**
+ * This class defines a workcenter with its data members and actions
+ */
+export declare class Workcenter implements IWorkcenter {
+    id: string;
+    name: string;
+    sort: number;
+    shifts?: Shift[];
+    positions?: Position[];
+    constructor(wc?: IWorkcenter);
+    /**
+     * This function is used to sort this workcenter in relation to another
+     * @param other The workcenter object used in comparison.
+     * @returns A numeric value for the relative position between two workcenters.
+     */
+    compareTo(other?: Workcenter): number;
+    /**
+     * This function will be used to assign the employee to either a position or a shift
+     * based the positions assignment list or their workday code.
+     * @param emp The employee object to assign to one of the workcenter's postions or
+     * shifts.
+     * @param date The date object to used to find the employee's workday.
+     */
+    assign(emp: Employee, date: Date): void;
+    /**
+     * This function will clear the employees' lists from the workcenter positions and
+     * shifts.
+     */
+    clearEmployees(): void;
+}

package/scheduler/sites/workcenters/workcenter.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Workcenter = void 0;
+const employees_1 = require("../../employees");
+const position_1 = require("./position");
+const shift_1 = require("./shift");
+/**
+ * This class defines a workcenter with its data members and actions
+ */
+class Workcenter {
+    id;
+    name;
+    sort;
+    shifts;
+    positions;
+    constructor(wc) {
+        this.id = (wc) ? wc.id : '';
+        this.name = (wc) ? wc.name : '';
+        this.sort = (wc) ? wc.sort : 0;
+        if (wc && wc.shifts && wc.shifts.length > 0) {
+            this.shifts = [];
+            wc.shifts.forEach(shft => {
+                if (this.shifts) {
+                    this.shifts.push(new shift_1.Shift(shft));
+                }
+            });
+            this.shifts.sort((a, b) => a.compareTo(b));
+        }
+        if (wc && wc.positions && wc.positions.length > 0) {
+            this.positions = [];
+            wc.positions.forEach(pos => {
+                this.positions?.push(new position_1.Position(pos));
+            });
+            this.positions.sort((a, b) => a.compareTo(b));
+        }
+    }
+    /**
+     * This function is used to sort this workcenter in relation to another
+     * @param other The workcenter object used in comparison.
+     * @returns A numeric value for the relative position between two workcenters.
+     */
+    compareTo(other) {
+        if (other) {
+            return (this.sort < other.sort) ? -1 : 1;
+        }
+        return -1;
+    }
+    /**
+     * This function will be used to assign the employee to either a position or a shift
+     * based the positions assignment list or their workday code.
+     * @param emp The employee object to assign to one of the workcenter's postions or
+     * shifts.
+     * @param date The date object to used to find the employee's workday.
+     */
+    assign(emp, date) {
+        // first check to see if the employee is assigned to a position
+        let bPosition = false;
+        if (this.positions) {
+            this.positions.forEach((pos, p) => {
+                pos.assigned.forEach(asgn => {
+                    if (emp.id === asgn) {
+                        bPosition = true;
+                        if (!pos.employees) {
+                            pos.employees = [];
+                            pos.employees.push(new employees_1.Employee(emp));
+                        }
+                        else {
+                            pos.employees.push(new employees_1.Employee(emp));
+                            pos.employees.sort((a, b) => a.compareTo(b));
+                        }
+                    }
+                });
+                if (bPosition && this.positions) {
+                    this.positions[p] = pos;
+                }
+            });
+        }
+        // if not assigned to a position, find their shift and assign to a shift.
+        if (!bPosition && this.shifts) {
+            let wd = emp.getWorkday(date);
+            this.shifts.forEach((shft, s) => {
+                shft.associatedCodes.forEach(cd => {
+                    if (cd.toLowerCase() === wd?.code.toLowerCase()) {
+                        if (!shft.employees) {
+                            shft.employees = [];
+                            shft.employees.push(new employees_1.Employee(emp));
+                        }
+                        else {
+                            shft.employees.push(new employees_1.Employee(emp));
+                            shft.employees.sort((a, b) => a.compareTo(b));
+                        }
+                    }
+                });
+                if (this.shifts) {
+                    this.shifts[s] = shft;
+                }
+            });
+        }
+    }
+    /**
+     * This function will clear the employees' lists from the workcenter positions and
+     * shifts.
+     */
+    clearEmployees() {
+        if (this.positions) {
+            this.positions.forEach((pos, p) => {
+                pos.employees = undefined;
+                if (this.positions) {
+                    this.positions[p] = pos;
+                }
+            });
+        }
+        if (this.shifts) {
+            this.shifts.forEach((shft, s) => {
+                shft.employees = undefined;
+                if (this.shifts) {
+                    this.shifts[s] = shft;
+                }
+            });
+        }
+    }
+}
+exports.Workcenter = Workcenter;

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

@@ -0,0 +1,99 @@
+import { Holiday, HolidayType, IHoliday } from "./holiday";
+import { IModPeriod, ModPeriod } from "./modperiod";
+/**
+ * This interface defines the data members to describe the company information.  The
+ * ingest type, period, start day, and password information are necessary to ingess the
+ * company's timecard information for various reports.
+ */
+export interface ICompany {
+    id: string;
+    name: string;
+    ingest: string;
+    ingestPeriod?: number;
+    startDay?: number;
+    ingestPwd: string;
+    holidays?: IHoliday[];
+    modperiods?: IModPeriod[];
+}
+/**
+ * This class definition implements the company interface, plus necessary actions to
+ * manipulate the object.
+ */
+export declare class Company implements ICompany {
+    id: string;
+    name: string;
+    ingest: string;
+    ingestPeriod?: number | undefined;
+    startDay?: number | undefined;
+    ingestPwd: string;
+    holidays: Holiday[];
+    modperiods: ModPeriod[];
+    constructor(co?: ICompany);
+    /**
+     * 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?: Company): number;
+    /**
+     * 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: Date): void;
+    /**
+     * 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: Date): boolean;
+    /**
+     * 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: number, start: Date, end: Date): void;
+    /**
+     * 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: number, field: string, value: Date): void;
+    /**
+     * This function will remove a mod period from the company's list.
+     * @param year a numeric value for the year to delete.
+     */
+    deleteModPeriod(year: number): void;
+    /**
+     * 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: HolidayType, sort: number): boolean;
+    /**
+     * 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: HolidayType, name: string): 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: HolidayType, sort: number, field: string, value: string): void;
+    /**
+     * 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: HolidayType, sort: number): void;
+}