scheduler-node-models 1.2.1 → 1.2.2

package/metrics/missionsensor.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissionSensor = void 0;
+const images_1 = require("./images");
+const missionSensorOutage_1 = require("./missionSensorOutage");
+const systemdata_1 = require("./systemdata");
+/**
+ * this class implements the mission sensor data members and actions.
+ */
+class MissionSensor {
+    sensorID;
+    sensorType;
+    preflightMinutes;
+    scheduledMinutes;
+    executedMinutes;
+    postflightMinutes;
+    additionalMinutes;
+    finalCode;
+    kitNumber;
+    sensorOutage;
+    groundOutage;
+    hasHap;
+    towerID;
+    sortID;
+    comments;
+    equipment;
+    images;
+    constructor(ms) {
+        this.sensorID = (ms) ? ms.sensorID : '';
+        this.sensorType = (ms) ? ms.sensorType : systemdata_1.GeneralTypes.OTHER;
+        this.preflightMinutes = (ms) ? ms.preflightMinutes : 0;
+        this.scheduledMinutes = (ms) ? ms.scheduledMinutes : 0;
+        this.executedMinutes = (ms) ? ms.executedMinutes : 0;
+        this.postflightMinutes = (ms) ? ms.postflightMinutes : 0;
+        this.additionalMinutes = (ms) ? ms.additionalMinutes : 0;
+        this.finalCode = (ms) ? ms.finalCode : 0;
+        this.kitNumber = (ms) ? ms.kitNumber : '';
+        this.sensorOutage = (ms) ? new missionSensorOutage_1.MissionSensorOutage(ms.sensorOutage)
+            : new missionSensorOutage_1.MissionSensorOutage();
+        this.groundOutage = (ms) ? ms.groundOutage : 0;
+        this.hasHap = (ms) ? ms.hasHap : false;
+        this.towerID = (ms) ? ms.towerID : 0;
+        this.sortID = (ms) ? ms.sortID : 0;
+        this.comments = (ms) ? ms.comments : '';
+        if (ms && ms.equipment) {
+            this.equipment = [];
+            ms.equipment.forEach(eq => {
+                this.equipment?.push(eq);
+            });
+            this.equipment.sort();
+        }
+        if (ms && ms.images) {
+            this.images = [];
+            ms.images.forEach(img => {
+                this.images?.push(new images_1.ImageType(img));
+            });
+            this.images.sort((a, b) => a.compareTo(b));
+        }
+    }
+    /**
+     * This function is used in sorting this mission sensor from another.
+     * @param other The mission sensor object used for comparison.
+     * @returns numeric value for the relative position of this to another.
+     */
+    compareTo(other) {
+        if (other) {
+            return (this.sortID < other.sortID) ? -1 : 1;
+        }
+        return -1;
+    }
+    /**
+     * This function will check to ensure the requested equipment is present in the
+     * equipment list.
+     * @param sid The string value for the equipment to check for.
+     * @returns boolean value for whether or not the equipment is in the list.
+     */
+    equipmentInUse(sid) {
+        let answer = false;
+        if (this.equipment) {
+            this.equipment.forEach(eq => {
+                if (eq.toLowerCase() === sid.toLowerCase()) {
+                    answer = true;
+                }
+            });
+        }
+        return answer;
+    }
+    /**
+     * This function will modify the equipment list, adding or removing equipment.
+     * @param item The string value for the equipment to add/remove.
+     * @param value A string value for a boolean value, true to add, false to remove.
+     */
+    modifyEquipment(item, value) {
+        if (item.toLowerCase() === 'apsplus') {
+            item = 'aps+';
+        }
+        if (value.toLowerCase() === 'true') {
+            let found = false;
+            if (this.equipment) {
+                this.equipment.forEach(eq => {
+                    if (eq.toLowerCase() === item.toLowerCase()) {
+                        found = true;
+                    }
+                });
+            }
+            if (!found) {
+                if (!this.equipment) {
+                    this.equipment = [];
+                }
+                this.equipment.push(item);
+            }
+        }
+        else {
+            let found = -1;
+            if (this.equipment) {
+                this.equipment.forEach((eq, e) => {
+                    if (eq.toLowerCase() === item.toLowerCase()) {
+                        found = e;
+                    }
+                });
+                if (found >= 0) {
+                    this.equipment.splice(found, 1);
+                }
+            }
+        }
+    }
+}
+exports.MissionSensor = MissionSensor;

package/metrics/outage.d.ts

@@ -0,0 +1,43 @@
+import { ObjectId } from "mongodb";
+/**
+ * This interface defines the data members associated with a ground outage
+ */
+export interface IOutage {
+    _id?: ObjectId;
+    id?: string;
+    outageDate: Date;
+    groundSystem: string;
+    classification: string;
+    outageNumber: number;
+    outageMinutes: number;
+    subSystem: string;
+    referenceId: string;
+    majorSystem: string;
+    problem: string;
+    fixAction: string;
+    missionOutage: boolean;
+    capability?: string;
+}
+export declare class Outage implements IOutage {
+    id: string;
+    outageDate: Date;
+    groundSystem: string;
+    classification: string;
+    outageNumber: number;
+    outageMinutes: number;
+    subSystem: string;
+    referenceId: string;
+    majorSystem: string;
+    problem: string;
+    fixAction: string;
+    missionOutage: boolean;
+    capability?: string;
+    constructor(outage?: IOutage);
+    /**
+     * This function is used in sorting outages by comparing the outage's dates and numbers.
+     * @param other Another outage object used for comparison
+     * @returns A numeric value for the relative position of this object to the other.
+     */
+    compareTo(other?: Outage): number;
+    useOutage(start: Date, end: Date): boolean;
+}

package/metrics/outage.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Outage = void 0;
+class Outage {
+    id;
+    outageDate;
+    groundSystem;
+    classification;
+    outageNumber;
+    outageMinutes;
+    subSystem;
+    referenceId;
+    majorSystem;
+    problem;
+    fixAction;
+    missionOutage;
+    capability;
+    constructor(outage) {
+        this.id = (outage && outage.id) ? outage.id : '';
+        if (this.id === '') {
+            this.id = (outage && outage._id) ? outage?._id?.toString() : '';
+        }
+        this.outageDate = (outage) ? new Date(outage.outageDate) : new Date();
+        this.groundSystem = (outage) ? outage.groundSystem : '';
+        this.classification = (outage) ? outage.classification : '';
+        this.outageNumber = (outage) ? outage.outageNumber : 0;
+        this.outageMinutes = (outage) ? outage.outageMinutes : 0;
+        this.subSystem = (outage) ? outage.subSystem : '';
+        this.referenceId = (outage) ? outage.referenceId : '';
+        this.majorSystem = (outage) ? outage.majorSystem : '';
+        this.problem = (outage) ? outage.problem : '';
+        this.fixAction = (outage) ? outage.fixAction : '';
+        this.missionOutage = (outage) ? outage.missionOutage : false;
+        this.capability = (outage && outage.capability) ? outage.capability : undefined;
+    }
+    /**
+     * This function is used in sorting outages by comparing the outage's dates and numbers.
+     * @param other Another outage object used for comparison
+     * @returns A numeric value for the relative position of this object to the other.
+     */
+    compareTo(other) {
+        if (other) {
+            if (this.outageDate.getTime() === other.outageDate.getTime()) {
+                return (this.outageNumber < other.outageNumber) ? -1 : 1;
+            }
+            return (this.outageDate.getTime() < other.outageDate.getTime()) ? -1 : 1;
+        }
+        return -1;
+    }
+    useOutage(start, end) {
+        return (start.getTime() <= this.outageDate.getTime()
+            && end.getTime() > this.outageDate.getTime());
+    }
+}
+exports.Outage = Outage;

package/metrics/systemdata/classifications.d.ts

@@ -0,0 +1,18 @@
+/**
+ * This interface defines the data members of a classification object.
+ */
+export interface IClassification {
+    id: string;
+    title: string;
+    sortID: number;
+}
+/**
+ * This class defines the data members and actions for a classification object.
+ */
+export declare class Classification implements IClassification {
+    id: string;
+    title: string;
+    sortID: number;
+    constructor(cl?: IClassification);
+    compareTo(other?: Classification): number;
+}

package/metrics/systemdata/classifications.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Classification = void 0;
+/**
+ * This class defines the data members and actions for a classification object.
+ */
+class Classification {
+    id;
+    title;
+    sortID;
+    constructor(cl) {
+        this.id = (cl) ? cl.id : '';
+        this.title = (cl) ? cl.title : '';
+        this.sortID = (cl) ? cl.sortID : 0;
+    }
+    compareTo(other) {
+        if (other) {
+            return (this.sortID < other.sortID) ? -1 : 1;
+        }
+        return -1;
+    }
+}
+exports.Classification = Classification;

package/metrics/systemdata/communications.d.ts

@@ -0,0 +1,21 @@
+/**
+ * This interface defines the data members for communications data.
+ */
+export interface ICommunication {
+    id: string;
+    explanation: string;
+    exploitations: string[];
+    sortID: number;
+}
+/**
+ * This class defines the data members plus actions for a communication object.
+ */
+export declare class Communication implements ICommunication {
+    id: string;
+    explanation: string;
+    exploitations: string[];
+    sortID: number;
+    constructor(comm?: ICommunication);
+    compareTo(other?: Communication): number;
+    hasExploitation(exp: string): boolean;
+}

package/metrics/systemdata/communications.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Communication = void 0;
+/**
+ * This class defines the data members plus actions for a communication object.
+ */
+class Communication {
+    id;
+    explanation;
+    exploitations;
+    sortID;
+    constructor(comm) {
+        this.id = (comm) ? comm.id : '';
+        this.explanation = (comm) ? comm.explanation : '';
+        this.exploitations = [];
+        if (comm) {
+            comm.exploitations.forEach(exp => {
+                this.exploitations.push(exp);
+            });
+            this.exploitations.sort();
+        }
+        this.sortID = (comm) ? comm.sortID : 0;
+    }
+    compareTo(other) {
+        if (other) {
+            return (this.sortID < other.sortID) ? -1 : 1;
+        }
+        return -1;
+    }
+    hasExploitation(exp) {
+        let answer = false;
+        this.exploitations.forEach(exploit => {
+            if (exploit.toLowerCase() === exp.toLowerCase()) {
+                answer = true;
+            }
+        });
+        return answer;
+    }
+}
+exports.Communication = Communication;

package/metrics/systemdata/dcgs.d.ts

@@ -0,0 +1,19 @@
+/**
+ * This interface is used to list a Distributed Common Ground Station site and the
+ * types of exploitation done at that site.
+ */
+export interface IDCGS {
+    id: string;
+    exploitations?: string[];
+    sortID: number;
+}
+/**
+ * This class implements the DCGS interface plus actions
+ */
+export declare class DCGS implements IDCGS {
+    id: string;
+    exploitations?: string[] | undefined;
+    sortID: number;
+    constructor(d?: IDCGS);
+    compareTo(other?: DCGS): number;
+}

package/metrics/systemdata/dcgs.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DCGS = void 0;
+/**
+ * This class implements the DCGS interface plus actions
+ */
+class DCGS {
+    id;
+    exploitations;
+    sortID;
+    constructor(d) {
+        this.id = (d) ? d.id : '';
+        this.sortID = (d) ? d.sortID : 0;
+        if (d && d.exploitations) {
+            this.exploitations = [];
+            d.exploitations.forEach(ex => {
+                this.exploitations?.push(ex);
+            });
+            this.exploitations.sort();
+        }
+    }
+    compareTo(other) {
+        if (other) {
+            return (this.sortID < other.sortID) ? -1 : 1;
+        }
+        return -1;
+    }
+}
+exports.DCGS = DCGS;

package/metrics/systemdata/exploitations.d.ts

@@ -0,0 +1,18 @@
+/**
+ * This interface will be used to define a exploitation type by id and explanation.
+ */
+export interface IExploitation {
+    id: string;
+    explanation: string;
+    sortID: number;
+}
+/**
+ * This class implements the IExploitation interface plus actions
+ */
+export declare class Exploitation implements IExploitation {
+    id: string;
+    explanation: string;
+    sortID: number;
+    constructor(ex?: IExploitation);
+    compareTo(other?: Exploitation): number;
+}

package/metrics/systemdata/exploitations.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Exploitation = void 0;
+/**
+ * This class implements the IExploitation interface plus actions
+ */
+class Exploitation {
+    id;
+    explanation;
+    sortID;
+    constructor(ex) {
+        this.id = (ex) ? ex.id : '';
+        this.explanation = (ex) ? ex.explanation : '';
+        this.sortID = (ex) ? ex.sortID : 0;
+    }
+    compareTo(other) {
+        if (other) {
+            return (this.sortID < other.sortID) ? -1 : 1;
+        }
+        return -1;
+    }
+}
+exports.Exploitation = Exploitation;

package/metrics/systemdata/groundSystems.d.ts

@@ -0,0 +1,86 @@
+/**
+ * This interface defines the data members associated with a ground system exploitation
+ * object.
+ */
+export interface IGroundSystemExploitation {
+    platformID: string;
+    sensorType: string;
+    exploitation: string;
+    communicationID: string;
+    enclaves?: string[];
+}
+/**
+ * This class implements the data members of the GroundSystemExploitation interface,
+ * plus functions to used the object.
+ */
+export declare class GroundSystemExploitation implements IGroundSystemExploitation {
+    platformID: string;
+    sensorType: string;
+    exploitation: string;
+    communicationID: string;
+    enclaves: string[];
+    constructor(gse?: IGroundSystemExploitation);
+    /**
+     * This function is used in sorting a list of Ground System Exploitation objects.
+     * @param other The ground system exploitation object for comparison
+     * @returns The numeric value to indicate this object's relative position compared to
+     * the other object.
+     */
+    compareTo(other?: GroundSystemExploitation): number;
+    /**
+     * This function will indicate if this exploitation should be used based on the
+     * information provided.
+     * @param platform The string value for the platform
+     * @param sensor The string value for the sensor
+     * @param exploit The string value for the exploitation
+     * @param comm The string value for the communications
+     * @param enclave The string value for the enclave
+     * @returns boolean value to indicate whether all the conditions are present
+     */
+    use(platform: string, sensor: string, exploit: string, comm: string, enclave: string): boolean;
+}
+/**
+ * This interface defines the data members of a ground system object
+ */
+export interface IGroundSystem {
+    id: string;
+    enclaves: string[];
+    showOnGEOINT: boolean;
+    showOnGSEG: boolean;
+    showOnMIST: boolean;
+    showOnXINT: boolean;
+    checkForUse?: boolean;
+    exploitations: IGroundSystemExploitation[];
+}
+/**
+ * This class implements the data members for a ground system, plus all the action to
+ * use the object
+ */
+export declare class GroundSystem implements IGroundSystem {
+    id: string;
+    enclaves: string[];
+    showOnGEOINT: boolean;
+    showOnGSEG: boolean;
+    showOnMIST: boolean;
+    showOnXINT: boolean;
+    checkForUse: boolean;
+    exploitations: GroundSystemExploitation[];
+    constructor(gs?: IGroundSystem);
+    /**
+     * This function will be used when sorting a list of ground system objects.
+     * @param other The ground system object used for comparison
+     * @returns a numeric value for whether this object is before or after the other.
+     */
+    compareTo(other?: GroundSystem): number;
+    /**
+     * This function will indicate if this exploitation should be used based on the
+     * information provided.
+     * @param platform The string value for the platform
+     * @param sensor The string value for the sensor
+     * @param exploit The string value for the exploitation
+     * @param comm The string value for the communications
+     * @param enclave The string value for the enclave
+     * @returns boolean value to indicate whether all the conditions are present
+     */
+    useSensor(platform: string, sensor: string, exploit: string, comm: string, enclave: string): boolean;
+}

package/metrics/systemdata/groundSystems.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroundSystem = exports.GroundSystemExploitation = void 0;
+/**
+ * This class implements the data members of the GroundSystemExploitation interface,
+ * plus functions to used the object.
+ */
+class GroundSystemExploitation {
+    platformID;
+    sensorType;
+    exploitation;
+    communicationID;
+    enclaves;
+    constructor(gse) {
+        this.platformID = (gse) ? gse.platformID : '';
+        this.sensorType = (gse) ? gse.sensorType : '';
+        this.exploitation = (gse) ? gse.exploitation : '';
+        this.communicationID = (gse) ? gse.communicationID : '';
+        this.enclaves = [];
+        if (gse && gse.enclaves) {
+            gse.enclaves.forEach(en => {
+                this.enclaves.push(en);
+            });
+        }
+    }
+    /**
+     * This function is used in sorting a list of Ground System Exploitation objects.
+     * @param other The ground system exploitation object for comparison
+     * @returns The numeric value to indicate this object's relative position compared to
+     * the other object.
+     */
+    compareTo(other) {
+        if (other) {
+            if (this.platformID === other.platformID) {
+                if (this.sensorType === other.sensorType) {
+                    if (this.exploitation === other.exploitation) {
+                        return (this.communicationID < other.communicationID) ? -1 : 1;
+                    }
+                    return (this.exploitation < other.exploitation) ? -1 : 1;
+                }
+                return (this.sensorType < other.sensorType) ? -1 : 1;
+            }
+            return (this.platformID < other.platformID) ? -1 : 1;
+        }
+        return -1;
+    }
+    /**
+     * This function will indicate if this exploitation should be used based on the
+     * information provided.
+     * @param platform The string value for the platform
+     * @param sensor The string value for the sensor
+     * @param exploit The string value for the exploitation
+     * @param comm The string value for the communications
+     * @param enclave The string value for the enclave
+     * @returns boolean value to indicate whether all the conditions are present
+     */
+    use(platform, sensor, exploit, comm, enclave) {
+        let answer = false;
+        if (platform.toLowerCase() === this.platformID.toLowerCase()
+            && sensor.toLowerCase() === this.sensorType.toLowerCase()
+            && this.exploitation.toLowerCase().indexOf(exploit.toLowerCase()) >= 0
+            && comm.toLowerCase() === this.communicationID.toLowerCase()) {
+            if (this.enclaves.length === 0)
+                return true;
+            if (enclave === '')
+                return true;
+            this.enclaves.forEach(enc => {
+                if (enc.toLowerCase() === enclave.toLowerCase()) {
+                    answer = true;
+                }
+            });
+        }
+        return answer;
+    }
+}
+exports.GroundSystemExploitation = GroundSystemExploitation;
+/**
+ * This class implements the data members for a ground system, plus all the action to
+ * use the object
+ */
+class GroundSystem {
+    id;
+    enclaves;
+    showOnGEOINT;
+    showOnGSEG;
+    showOnMIST;
+    showOnXINT;
+    checkForUse;
+    exploitations;
+    constructor(gs) {
+        this.id = (gs) ? gs.id : '';
+        this.enclaves = [];
+        if (gs && gs.enclaves.length > 0) {
+            gs.enclaves.forEach(en => {
+                this.enclaves.push(en);
+            });
+        }
+        this.showOnGEOINT = (gs) ? gs.showOnGEOINT : false;
+        this.showOnGSEG = (gs) ? gs.showOnGSEG : false;
+        this.showOnMIST = (gs) ? gs.showOnMIST : false;
+        this.showOnXINT = (gs) ? gs.showOnXINT : false;
+        this.checkForUse = (gs && gs.checkForUse) ? gs.checkForUse : false;
+        this.exploitations = [];
+        if (gs && gs.exploitations.length > 0) {
+            gs.exploitations.forEach(ex => {
+                this.exploitations.push(new GroundSystemExploitation(ex));
+            });
+        }
+    }
+    /**
+     * This function will be used when sorting a list of ground system objects.
+     * @param other The ground system object used for comparison
+     * @returns a numeric value for whether this object is before or after the other.
+     */
+    compareTo(other) {
+        if (other) {
+            return (this.id < other.id) ? -1 : 1;
+        }
+        return -1;
+    }
+    /**
+     * This function will indicate if this exploitation should be used based on the
+     * information provided.
+     * @param platform The string value for the platform
+     * @param sensor The string value for the sensor
+     * @param exploit The string value for the exploitation
+     * @param comm The string value for the communications
+     * @param enclave The string value for the enclave
+     * @returns boolean value to indicate whether all the conditions are present
+     */
+    useSensor(platform, sensor, exploit, comm, enclave) {
+        if (this.exploitations.length === 0)
+            return true;
+        let answer = false;
+        this.exploitations.forEach(exp => {
+            if (exp.use(platform, sensor, exploit, comm, enclave)) {
+                answer = true;
+            }
+        });
+        return answer;
+    }
+}
+exports.GroundSystem = GroundSystem;

package/metrics/systemdata/index.d.ts

@@ -0,0 +1,7 @@
+export * from './classifications';
+export * from './communications';
+export * from './dcgs';
+export * from './exploitations';
+export * from './groundSystems';
+export * from './platform';
+export * from './systeminfo';

package/metrics/systemdata/index.js

@@ -0,0 +1,23 @@
+"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("./classifications"), exports);
+__exportStar(require("./communications"), exports);
+__exportStar(require("./dcgs"), exports);
+__exportStar(require("./exploitations"), exports);
+__exportStar(require("./groundSystems"), exports);
+__exportStar(require("./platform"), exports);
+__exportStar(require("./systeminfo"), exports);