scheduler-node-models 1.2.1 → 1.2.3

package/metrics/systemdata/platform.d.ts

@@ -0,0 +1,124 @@
+import { IImageType, ImageType } from "../images";
+/**
+ * This interface will defined the data members of a sensor's standard times
+ */
+export interface ISensorTimes {
+    preflightMinutes: number;
+    scheduledMinutes: number;
+    postflightMinutes: number;
+    executedMinutes?: number;
+}
+/**
+ * This class defines the created object for sensor's standard times
+ */
+export declare class SensorTimes implements ISensorTimes {
+    preflightMinutes: number;
+    scheduledMinutes: number;
+    postflightMinutes: number;
+    executedMinutes?: number;
+    constructor(st?: ISensorTimes);
+}
+/**
+ * This interface defines the data members for a sensor's exploitation record.
+ */
+export interface ISensorExploitation {
+    exploitation: string;
+    showOnGEOINT: boolean;
+    showOnGSEG: boolean;
+    showOnMIST: boolean;
+    showOnXINT: boolean;
+    standardTimes: ISensorTimes;
+}
+/**
+ * This class defines the data members plus actions for a sensor's exploitation.
+ */
+export declare class SensorExploitation {
+    exploitation: string;
+    showOnGEOINT: boolean;
+    showOnGSEG: boolean;
+    showOnMIST: boolean;
+    showOnXINT: boolean;
+    standardTimes: ISensorTimes;
+    constructor(se?: ISensorExploitation);
+    compareTo(other?: SensorExploitation): number;
+}
+export declare enum GeneralTypes {
+    GEOINT = 1,
+    XINT = 2,
+    MIST = 3,
+    SYERS = 4,
+    ADMIN = 9,
+    OTHER = 99,
+    ALL = 9999
+}
+/**
+ * This interface defines the data members for a platform's sensor
+ */
+export interface IPlatformSensor {
+    id: string;
+    association: string;
+    generalType: GeneralTypes;
+    showTailNumber: boolean;
+    sortID: number;
+    exploitations?: ISensorExploitation[];
+    imageTypes?: IImageType[];
+}
+/**
+ * This class defines the data members and actions associated with a platform's sensor
+ */
+export declare class PlatformSensor {
+    id: string;
+    association: string;
+    generalType: GeneralTypes;
+    showTailNumber: boolean;
+    sortID: number;
+    exploitations?: SensorExploitation[];
+    imageTypes?: ImageType[];
+    constructor(ps?: IPlatformSensor);
+    /**
+     * This function will be used to sort this object as compared to another.
+     * @param other A Platform Sensor object to compare with
+     * @returns A numeric value to show whether this object is before or after the other.
+     */
+    compareTo(other?: PlatformSensor): number;
+    /**
+     * This method is used to determine if this object meets the requirement for use, based
+     * on the exploitation and general type.
+     * @param exploit The string value for the exploitation.
+     * @param rpt The general type value for the sensor type for use.
+     * @returns A boolean value to indicate whether or not it should be used.
+     */
+    use(exploit: string, rpt: GeneralTypes): boolean;
+}
+/**
+ * This interface defines the data members of a platform object.
+ */
+export interface IPlatform {
+    id: string;
+    sensors: IPlatformSensor[];
+    sortID: number;
+}
+/**
+ * This class defines the data members plus actions for a platform object
+ */
+export declare class Platform implements IPlatform {
+    id: string;
+    sensors: PlatformSensor[];
+    sortID: number;
+    constructor(pl: IPlatform);
+    /**
+     * This function will be used in sorting this platform from other platforms
+     * @param other The platform object to be used in comparison.
+     * @returns A numeric value to indicate whether this object should be placed before the
+     * other.
+     */
+    compareTo(other?: Platform): number;
+    /**
+     * This method is used to determine if this object meets the requirement for use, based
+     * on the exploitation and general type.
+     * @param exploit The string value for the exploitation.
+     * @param rpt The general type value for the sensor type for use.
+     * @returns A boolean value to indicate whether or not it should be used.
+     */
+    use(exploit: string, rpt: GeneralTypes): boolean;
+}

package/metrics/systemdata/platform.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Platform = exports.PlatformSensor = exports.GeneralTypes = exports.SensorExploitation = exports.SensorTimes = void 0;
+const images_1 = require("../images");
+/**
+ * This class defines the created object for sensor's standard times
+ */
+class SensorTimes {
+    preflightMinutes;
+    scheduledMinutes;
+    postflightMinutes;
+    executedMinutes;
+    constructor(st) {
+        this.postflightMinutes = (st) ? st.postflightMinutes : 0;
+        this.preflightMinutes = (st) ? st.preflightMinutes : 0;
+        this.scheduledMinutes = (st) ? st.scheduledMinutes : 0;
+        this.executedMinutes = (st && st.executedMinutes) ? st?.executedMinutes : undefined;
+    }
+}
+exports.SensorTimes = SensorTimes;
+/**
+ * This class defines the data members plus actions for a sensor's exploitation.
+ */
+class SensorExploitation {
+    exploitation;
+    showOnGEOINT;
+    showOnGSEG;
+    showOnMIST;
+    showOnXINT;
+    standardTimes;
+    constructor(se) {
+        this.exploitation = (se) ? se.exploitation : '';
+        this.showOnGEOINT = (se) ? se.showOnGEOINT : false;
+        this.showOnGSEG = (se) ? se.showOnGSEG : false;
+        this.showOnMIST = (se) ? se.showOnMIST : false;
+        this.showOnXINT = (se) ? se.showOnXINT : false;
+        this.standardTimes = (se) ? new SensorTimes(se.standardTimes) : new SensorTimes();
+    }
+    compareTo(other) {
+        if (other) {
+            return (this.exploitation < other.exploitation) ? -1 : 1;
+        }
+        return -1;
+    }
+}
+exports.SensorExploitation = SensorExploitation;
+var GeneralTypes;
+(function (GeneralTypes) {
+    GeneralTypes[GeneralTypes["GEOINT"] = 1] = "GEOINT";
+    GeneralTypes[GeneralTypes["XINT"] = 2] = "XINT";
+    GeneralTypes[GeneralTypes["MIST"] = 3] = "MIST";
+    GeneralTypes[GeneralTypes["SYERS"] = 4] = "SYERS";
+    GeneralTypes[GeneralTypes["ADMIN"] = 9] = "ADMIN";
+    GeneralTypes[GeneralTypes["OTHER"] = 99] = "OTHER";
+    GeneralTypes[GeneralTypes["ALL"] = 9999] = "ALL";
+})(GeneralTypes || (exports.GeneralTypes = GeneralTypes = {}));
+/**
+ * This class defines the data members and actions associated with a platform's sensor
+ */
+class PlatformSensor {
+    id;
+    association;
+    generalType;
+    showTailNumber;
+    sortID;
+    exploitations;
+    imageTypes;
+    constructor(ps) {
+        this.id = (ps) ? ps.id : '';
+        this.association = (ps) ? ps.association : '';
+        this.generalType = (ps) ? ps.generalType : GeneralTypes.OTHER;
+        this.showTailNumber = (ps) ? ps.showTailNumber : false;
+        this.sortID = (ps) ? ps.sortID : 0;
+        if (ps && ps.exploitations) {
+            this.exploitations = [];
+            ps.exploitations.forEach(ex => {
+                this.exploitations?.push(new SensorExploitation(ex));
+            });
+            this.exploitations.sort((a, b) => a.compareTo(b));
+        }
+        if (ps && ps.imageTypes) {
+            this.imageTypes = [];
+            ps.imageTypes.forEach(it => {
+                this.imageTypes?.push(new images_1.ImageType(it));
+            });
+        }
+    }
+    /**
+     * This function will be used to sort this object as compared to another.
+     * @param other A Platform Sensor object to compare with
+     * @returns A numeric value to show whether this object is before or after the other.
+     */
+    compareTo(other) {
+        if (other) {
+            return (this.sortID < other.sortID) ? -1 : 1;
+        }
+        return -1;
+    }
+    /**
+     * This method is used to determine if this object meets the requirement for use, based
+     * on the exploitation and general type.
+     * @param exploit The string value for the exploitation.
+     * @param rpt The general type value for the sensor type for use.
+     * @returns A boolean value to indicate whether or not it should be used.
+     */
+    use(exploit, rpt) {
+        let answer = false;
+        if (rpt <= 0 || rpt > GeneralTypes.SYERS) {
+            rpt = GeneralTypes.ALL;
+        }
+        if (this.exploitations) {
+            this.exploitations.forEach(exp => {
+                if ((exp.exploitation.toLowerCase().indexOf(exploit.toLowerCase()) >= 0)
+                    && (rpt === GeneralTypes.ALL || (rpt === GeneralTypes.XINT && exp.showOnXINT)
+                        || (rpt === GeneralTypes.GEOINT && exp.showOnGEOINT)
+                        || (rpt === GeneralTypes.SYERS && exp.showOnGSEG)
+                        || (rpt === GeneralTypes.MIST && exp.showOnMIST))) {
+                    answer = true;
+                }
+            });
+        }
+        return answer;
+    }
+}
+exports.PlatformSensor = PlatformSensor;
+/**
+ * This class defines the data members plus actions for a platform object
+ */
+class Platform {
+    id;
+    sensors;
+    sortID;
+    constructor(pl) {
+        this.id = (pl) ? pl.id : '';
+        this.sensors = [];
+        if (pl && pl.sensors.length > 0) {
+            pl.sensors.forEach(sen => {
+                this.sensors.push(new PlatformSensor(sen));
+            });
+            this.sensors.sort((a, b) => a.compareTo(b));
+        }
+        this.sortID = (pl) ? pl.sortID : 0;
+    }
+    /**
+     * This function will be used in sorting this platform from other platforms
+     * @param other The platform object to be used in comparison.
+     * @returns A numeric value to indicate whether this object should be placed before the
+     * other.
+     */
+    compareTo(other) {
+        if (other) {
+            return (this.sortID < other.sortID) ? -1 : 1;
+        }
+        return -1;
+    }
+    /**
+     * This method is used to determine if this object meets the requirement for use, based
+     * on the exploitation and general type.
+     * @param exploit The string value for the exploitation.
+     * @param rpt The general type value for the sensor type for use.
+     * @returns A boolean value to indicate whether or not it should be used.
+     */
+    use(exploit, rpt) {
+        if (rpt < GeneralTypes.GEOINT || rpt > GeneralTypes.SYERS) {
+            rpt = GeneralTypes.ALL;
+        }
+        let answer = false;
+        this.sensors.forEach(sen => {
+            if (sen.use(exploit, rpt)) {
+                answer = true;
+            }
+        });
+        return answer;
+    }
+}
+exports.Platform = Platform;

package/metrics/systemdata/systeminfo.d.ts

@@ -0,0 +1,28 @@
+import { Classification, IClassification } from "./classifications";
+import { Communication, ICommunication } from "./communications";
+import { DCGS, IDCGS } from "./dcgs";
+import { Exploitation, IExploitation } from "./exploitations";
+import { GroundSystem, IGroundSystem } from "./groundSystems";
+import { IPlatform, Platform } from "./platform";
+/**
+ * This interface will define the data members for the overall system data obtained from
+ * a json document on the server.  A class inplementation will also be included to allow
+ * all the data to be compiled, sorted and sent to the client.
+ */
+export interface ISystemInfo {
+    classifications?: IClassification[];
+    communications?: ICommunication[];
+    dCGSs?: IDCGS[];
+    exploitations?: IExploitation[];
+    groundSystems?: IGroundSystem[];
+    platforms?: IPlatform[];
+}
+export declare class SystemInfo implements ISystemInfo {
+    classifications?: Classification[] | undefined;
+    communications?: Communication[] | undefined;
+    dCGSs?: DCGS[] | undefined;
+    exploitations?: Exploitation[] | undefined;
+    groundSystems?: GroundSystem[] | undefined;
+    platforms?: Platform[] | undefined;
+    constructor(si?: ISystemInfo);
+}

package/metrics/systemdata/systeminfo.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SystemInfo = void 0;
+const classifications_1 = require("./classifications");
+const communications_1 = require("./communications");
+const dcgs_1 = require("./dcgs");
+const exploitations_1 = require("./exploitations");
+const groundSystems_1 = require("./groundSystems");
+const platform_1 = require("./platform");
+class SystemInfo {
+    classifications;
+    communications;
+    dCGSs;
+    exploitations;
+    groundSystems;
+    platforms;
+    constructor(si) {
+        if (si) {
+            if (si.classifications) {
+                this.classifications = [];
+                si.classifications.forEach(cl => {
+                    this.classifications?.push(new classifications_1.Classification(cl));
+                });
+                this.classifications.sort((a, b) => a.compareTo(b));
+            }
+            if (si.communications) {
+                this.communications = [];
+                si.communications.forEach(com => {
+                    this.communications?.push(new communications_1.Communication(com));
+                });
+                this.communications.sort((a, b) => a.compareTo(b));
+            }
+            if (si.dCGSs) {
+                this.dCGSs = [];
+                si.dCGSs.forEach(d => {
+                    this.dCGSs?.push(new dcgs_1.DCGS(d));
+                });
+                this.dCGSs.sort((a, b) => a.compareTo(b));
+            }
+            if (si.exploitations) {
+                this.exploitations = [];
+                si.exploitations.forEach(exp => {
+                    this.exploitations?.push(new exploitations_1.Exploitation(exp));
+                });
+                this.exploitations.sort((a, b) => a.compareTo(b));
+            }
+            if (si.groundSystems) {
+                this.groundSystems = [];
+                si.groundSystems.forEach(gs => {
+                    this.groundSystems?.push(new groundSystems_1.GroundSystem(gs));
+                });
+                this.groundSystems.sort((a, b) => a.compareTo(b));
+            }
+            if (si.platforms) {
+                this.platforms = [];
+                si.platforms.forEach(plat => {
+                    this.platforms?.push(new platform_1.Platform(plat));
+                });
+                this.platforms.sort((a, b) => a.compareTo(b));
+            }
+        }
+    }
+}
+exports.SystemInfo = SystemInfo;

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "scheduler-node-models",
-  "version": "1.2.1",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "version": "1.2.3",
+  "main": "index.js",
+  "types": "index.d.ts",
   "files": [
-    "/dist"
+    "/"
   ],
   "scripts": {
     "build": "tsc",

package/scheduler/employees/assignment.d.ts

@@ -0,0 +1,139 @@
+import { LaborCode } from "../labor/laborcode";
+import { EmployeeLaborCode, IEmployeeLaborCode } from "./labor";
+import { ISchedule, Schedule, Workday } from "./workday";
+/**
+ * Assignments are the first level of scheduling.  It defines the current normal work
+ * schedule(s).  It should start with the employee's initial hire date and the employee's
+ * last assignment will have the employee's departure date from the company.  Each time an
+ * employee's schedule permanently changes, a new assignment needs to be created to
+ * maintain a work history.
+ */
+/**
+ * This interface defines a work assignment for an employee.
+ */
+export interface IAssignment {
+    id: number;
+    site: string;
+    workcenter: string;
+    startDate: Date;
+    endDate: Date;
+    schedules: ISchedule[];
+    rotationdate?: Date;
+    rotationdays?: number;
+    laborcodes?: IEmployeeLaborCode[];
+}
+/**
+ * This class defines an employee's work assignment.  The data members are:
+ * id (numeric value for the key to this assignment)
+ * site (the string value for the work site within the team)
+ * workcenter (the string value for the work center the schedule applies to)
+ * startdate (date object to define the start of the assignment.)
+ * enddate (date object to define the end of an assignment, to no longer use)
+ * rotationdate (Optional - defines a base date when multiple schedule are used in an
+ * assignment, especially for schedules that rotate every ### number of days.)
+ * rotationdays (Optional - defines the number of days to rotate upon from the base
+ * rotation date.  It must be a multiple of the number of days in the schedule.)
+ * laborcodes (an array of employeelaborcode objects to define the assigned labor codes
+ * for consideration)
+ */
+export declare class Assignment {
+    id: number;
+    site: string;
+    workcenter: string;
+    startDate: Date;
+    endDate: Date;
+    schedules: Schedule[];
+    rotationdate?: Date;
+    rotationdays?: number;
+    laborcodes: EmployeeLaborCode[];
+    constructor(asgmt?: IAssignment);
+    /**
+     * This function is used in sorting of the assignment from others.  It used the
+     * assignment start and end dates for sorting comparison.
+     * @param other An assignment object to use in comparison
+     * @returns A numeric value to indicate whether this object is before or after the other
+     * object.  -1 is before, 1 for after or 0 for equal.
+     */
+    compareTo(other?: Assignment): number;
+    /**
+     * This function is used to determine if this assignment should be used at a particular
+     * site and date.
+     * @param site The string value of a site designation.
+     * @param date The date object to compare with the start and end dates.
+     * @returns The boolean value for whether this assignment is for a site and between
+     * this start and end dates.
+     */
+    useSiteAssignment(site: string, date: Date): boolean;
+    /**
+     * This function is used to determine if this assignment should be used based on the
+     * date provided.
+     * @param date The date object used in comparision
+     * @returns The boolean value for whether this assignment is between the start and end
+     * dates.
+     */
+    useAssignment(date: Date, date2?: Date, labor?: LaborCode): boolean;
+    /**
+     * This function will provide the daily standard work day hours, based on a count of
+     * the schedule's workdays and a 40 hour work week.
+     * @returns A numeric value for the standard day's work hours.
+     */
+    getStandardWorkHours(): number;
+    /**
+     * This function is used to provide the workday object for a particular date.
+     * @param date The date object used to find the workday
+     * @returns A workday object if the schedule can be used or undefined if not.
+     */
+    getWorkday(date: Date): Workday | undefined;
+    /**
+     * This function adds a new schedule with a set number of days in the schedule.
+     * @param days The numeric value for the number of workday objects within the schedule.
+     * This must be a multiple of 7.
+     */
+    addSchedule(days: number): Error | undefined;
+    /**
+     * This function will change the number of workdays within an existing schedule.
+     * @param schID The numeric value for the schedule's identifier to change.
+     * @param days The numeric value for the number of workday objects to change the
+     * schedule to.  This must be a multiple of 7.
+     */
+    changeScheduleDays(schID: number, days: number): Error | undefined;
+    /**
+     * This function is used to completely change a schedule's workday
+     * @param schID The numeric value to identify the schedule to update
+     * @param wdID The numeric value to identity which of the schedule's workday to change
+     * @param wkctr The string value for the new workcenter.
+     * @param code The string value for the new work code.
+     * @param hours The numeric valur for the hours to work.
+     */
+    changeWorkday(schID: number, wdID: number, wkctr: string, code: string, hours: number): void;
+    /**
+     * This function is used to update a single field  in a schedule's workday.
+     * @param schID The numeric value to identify the schedule to update
+     * @param wdID The numeric value to identify which of the schedule's workdays to update
+     * @param field The string value to identify which field within the workday to update
+     * @param value The string value (string or numeric string) to update the value of the
+     * data member.
+     */
+    updateWorkday(schID: number, wdID: number, field: string, value: string): void;
+    /**
+     * This function is used to remove a schedule from this assignment.  An assignment must
+     * have a minimum of one schedule, so if removal put the schedule list below 1, a new
+     * schedule is added and empty.
+     * @param schid The numeric value key for the schedule to remove.
+     */
+    removeSchedule(schid: number): void;
+    /**
+     * This function will add a new labor code (charge number and extension) to this
+     * assignment's labor code list.
+     * @param chgno The string value for the charge number to add
+     * @param ext The string value for the extension to add
+     */
+    addLaborCode(chgno: string, ext: string): void;
+    /**
+     * This function will remove an employee labor code from the list, based on its
+     * charge number and extension.
+     * @param chgno The string value for the charge number to remove
+     * @param ext The string value for the extension to remove
+     */
+    removeLaborCode(chgno: string, ext: string): void;
+}