scheduler-node-models 1.0.81 → 1.0.85

package/scheduler/employees/leaverequest.js

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LeaveRequest = exports.LeaveRequestComment = void 0;
+const leave_1 = require("./leave");
+/**
+ * The class description for a comment to a leave request.  The data members are:
+ * comment date (date object for the date the comment was written on.)
+ * comment (the string value for the actual comment to the request)
+ */
+class LeaveRequestComment {
+    commentdate;
+    comment;
+    constructor(cmt) {
+        this.commentdate = (cmt) ? new Date(cmt.commentdate) : new Date();
+        this.comment = (cmt) ? cmt.comment : '';
+    }
+    /**
+     * This function is used to sort the comments by date.
+     * @param other The comment object used in comparison.
+     * @returns
+  
+    /**
+     * This function is used to sort this object from another variation object
+     * @param other The other variation object 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) {
+            return this.commentdate.getTime() < other.commentdate.getTime() ? -1 : 1;
+        }
+        return -1;
+    }
+}
+exports.LeaveRequestComment = LeaveRequestComment;
+/**
+ * This class describes a leave request object.  The data members are:
+ * id (string value representing a mongo db object identifier)
+ * employeeid (string value representing a mongo db object identifier for the employee)
+ * requestdate (the date object for the date the request was created)
+ * primarycode (string value for the leave code used the most in the request)
+ * startdate (the date object used to define the begining of the leave period)
+ * enddate (the date object used to define the end of the leave period)
+ * status (the string value for the step the request is in the approval process.  The
+ * available statuses are DRAFT, REQUESTED, APPROVED)
+ * approvedby (the string value representing the object id of the supervisor approving
+ * the request)
+ * approvaldate (the date object for the date the request was approved)
+ * requesteddays (the list of proposed leave days within the period)
+ * comments (the list of comments to this request)
+ */
+class LeaveRequest {
+    id;
+    employeeid;
+    requestdate;
+    primarycode;
+    startdate;
+    enddate;
+    status;
+    approvedby;
+    approvalDate;
+    requesteddays;
+    comments;
+    constructor(req) {
+        this.id = (req) ? req.id : '';
+        this.employeeid = (req) ? req.employeeid : '';
+        this.requestdate = (req) ? new Date(req.requestdate) : new Date();
+        this.primarycode = (req) ? req.primarycode : 'V';
+        this.startdate = (req) ? new Date(req.startdate) : new Date();
+        this.enddate = (req) ? new Date(req.enddate) : new Date();
+        this.status = (req) ? req.status : 'REQUESTED';
+        this.approvedby = (req) ? req.approvedby : '';
+        this.approvalDate = (req) ? new Date(req.approvalDate) : new Date(0);
+        this.requesteddays = [];
+        if (req && req.requesteddays && req.requesteddays.length > 0) {
+            req.requesteddays.forEach(day => {
+                this.requesteddays.push(new leave_1.Leave(day));
+            });
+            this.requesteddays.sort((a, b) => a.compareTo(b));
+        }
+        else {
+            const first = new Date(Date.UTC(this.startdate.getFullYear(), this.startdate.getMonth(), this.startdate.getDate()));
+            const leave = new leave_1.Leave();
+            leave.leavedate = first;
+            leave.code = 'V';
+            leave.requestid = this.id;
+            this.requesteddays.push(leave);
+        }
+        this.comments = [];
+        if (req && req.comments && req.comments.length > 0) {
+            req.comments.forEach(cmt => {
+                this.comments?.push(new LeaveRequestComment(cmt));
+            });
+            this.comments.sort((a, b) => a.compareTo(b));
+        }
+    }
+    /**
+     * this function is used to sort this request from another.  They are sorted based on
+     * start, end and request dates.
+     * @param other The request object 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.startdate.getTime() === other.startdate.getTime()) {
+                if (this.enddate.getTime() === other.enddate.getTime()) {
+                    return (this.requestdate.getTime() < other.requestdate.getTime()) ? -1 : 1;
+                }
+                return (this.enddate.getTime() < other.enddate.getTime()) ? -1 : 1;
+            }
+            return (this.startdate.getTime() < other.startdate.getTime()) ? -1 : 1;
+        }
+        return -1;
+    }
+    useRequest(id) {
+        return this.id.toLowerCase() === id.toLowerCase();
+    }
+    /**
+     * This function is used to replace a value on a single proposed leave day.
+     * @param date The date object used to find which leave day to update
+     * @param field The string value for which field in the leave day to update.
+     * @param value The string value for the change.  If can me a string value of a number
+     * or boolean value.
+     */
+    updateLeaveDay(date, field, value) {
+        let lDate = new Date(date);
+        lDate = new Date(Date.UTC(lDate.getUTCFullYear(), lDate.getUTCMonth(), lDate.getUTCDate()));
+        for (let d = 0; d < this.requesteddays.length; d++) {
+            const lv = this.requesteddays[d];
+            if (lv.useLeave(lDate)) {
+                switch (field.toLowerCase()) {
+                    case "code":
+                        lv.code = value;
+                        break;
+                    case "hours":
+                        lv.hours = Number(value);
+                        break;
+                    case "status":
+                        lv.status = value;
+                        break;
+                    case "used":
+                        lv.used = Boolean(value);
+                        break;
+                    case "tag":
+                    case "tagday":
+                        lv.tagday = value;
+                        break;
+                }
+                this.requesteddays[d] = lv;
+            }
+        }
+    }
+    /**
+     * This function is used to set up leave days in the request object based on the
+     * period and whether or not the employee normally works the day.
+     * @param emp This a reference to the employee object where this request resides and
+     * is used to determine if the employee normally works on that day.
+     */
+    setLeaveDays(emp, reset = false) {
+        let start = new Date(Date.UTC(this.startdate.getFullYear(), this.startdate.getMonth(), this.startdate.getDate()));
+        const olddays = [];
+        this.requesteddays.forEach(lv => {
+            olddays.push(new leave_1.Leave(lv));
+        });
+        this.requesteddays = [];
+        let count = -1;
+        while (start.getTime() < this.enddate.getTime()) {
+            const wd = emp.getWorkday(start);
+            let leave = undefined;
+            if (wd && wd.code !== '') {
+                if (this.primarycode.toLowerCase() === 'mod') {
+                    leave = new leave_1.Leave({
+                        id: count++,
+                        leavedate: new Date(start),
+                        code: wd.code,
+                        hours: wd.hours,
+                        status: 'REQUESTED',
+                        requestid: this.id,
+                        used: false
+                    });
+                }
+                else {
+                    let stdHours = emp.getStandardWorkday(start);
+                    if (this.primarycode.toLowerCase() === 'h') {
+                        stdHours = 8.0;
+                    }
+                    leave = new leave_1.Leave({
+                        id: count++,
+                        leavedate: new Date(start),
+                        code: this.primarycode,
+                        hours: stdHours,
+                        status: 'REQUESTED',
+                        requestid: this.id,
+                        used: false
+                    });
+                }
+            }
+            else {
+                leave = new leave_1.Leave({
+                    id: count++,
+                    leavedate: new Date(start),
+                    code: '',
+                    hours: 0.0,
+                    status: 'REQUESTED',
+                    requestid: this.id,
+                    used: false
+                });
+            }
+            if (!reset) {
+                olddays.forEach(olv => {
+                    if (olv.useLeave(start)) {
+                        leave.code = olv.code;
+                        leave.hours = olv.hours;
+                        leave.status = this.status;
+                        leave.tagday = olv.tagday;
+                    }
+                });
+            }
+            this.requesteddays.push(leave);
+            start = new Date(start.getTime() + (24 * 3600000));
+        }
+        this.requesteddays.sort((a, b) => a.compareTo(b));
+    }
+}
+exports.LeaveRequest = LeaveRequest;

package/scheduler/employees/specialty.d.ts

@@ -0,0 +1,35 @@
+/**
+ * This interface and class is for recording the employee's work specialities or the
+ * skills they have from the team's specialty list.
+ */
+/**
+ * This interface is used to describe a user's specialties.
+ */
+export interface ISpecialty {
+    id: number;
+    specialtyid: number;
+    sort: number;
+    qualified: boolean;
+}
+/**
+ * This class is used to describe the relationship of the employee's specialties to the
+ * team's specialties list.  The data members are:
+ * id (numeric value for the key to the relationship list)
+ * specialtyid (numeric value in reference to the team's specialty list)
+ * sort (numeric value used to sort the display of the specialties)
+ * qualified (boolean value to show whether or not the employee is qualfied)
+ */
+export declare class Specialty implements ISpecialty {
+    id: number;
+    specialtyid: number;
+    sort: number;
+    qualified: boolean;
+    constructor(sp?: ISpecialty);
+    /**
+     * This function is used to sort this object from another specialty object
+     * @param other The other specialty object 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?: Specialty): number;
+}

package/scheduler/employees/specialty.js

@@ -0,0 +1,40 @@
+"use strict";
+/**
+ * This interface and class is for recording the employee's work specialities or the
+ * skills they have from the team's specialty list.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Specialty = void 0;
+/**
+ * This class is used to describe the relationship of the employee's specialties to the
+ * team's specialties list.  The data members are:
+ * id (numeric value for the key to the relationship list)
+ * specialtyid (numeric value in reference to the team's specialty list)
+ * sort (numeric value used to sort the display of the specialties)
+ * qualified (boolean value to show whether or not the employee is qualfied)
+ */
+class Specialty {
+    id;
+    specialtyid;
+    sort;
+    qualified;
+    constructor(sp) {
+        this.id = (sp) ? sp.id : 0;
+        this.specialtyid = (sp) ? sp.specialtyid : 0;
+        this.sort = (sp) ? sp.sort : 0;
+        this.qualified = (sp) ? sp.qualified : false;
+    }
+    /**
+     * This function is used to sort this object from another specialty object
+     * @param other The other specialty object 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) {
+            return this.sort < other.sort ? -1 : 1;
+        }
+        return -1;
+    }
+}
+exports.Specialty = Specialty;

package/scheduler/employees/variation.d.ts

@@ -0,0 +1,80 @@
+import { ISchedule, Schedule, Workday } from "./workday";
+/**
+ * This interface provides the basis for a variation (a small change to an employee's
+ * assignment and schedule)
+ */
+export interface IVariation {
+    id: number;
+    site: string;
+    mids: boolean;
+    mod: boolean;
+    startdate: Date;
+    enddate: Date;
+    schedule: ISchedule;
+}
+/**
+ * This class description is for a schedule variation.  A schedule variation is used
+ * for a small change in an employee's schedule, one that will revert back to the primary
+ * schedule after the change period is complete.  The data members are:
+ * id (numeric value for the primary key)
+ * site (the string value for the site the employee is assigned)
+ * mids (A boolean value for variations is associated with a temporary mid shift assignment)
+ * startdate (a date object for the start of the variation period)
+ * enddate (a date object for the end of the variation period)
+ * schedule (a schedule object containing a group of workday objects which is used to
+ * define the days of the variation).
+ */
+export declare class Variation implements IVariation {
+    id: number;
+    site: string;
+    mids: boolean;
+    mod: boolean;
+    startdate: Date;
+    enddate: Date;
+    schedule: Schedule;
+    constructor(vari: IVariation);
+    /**
+     * This function is used to sort this object from another variation object
+     * @param other The other variation object 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?: Variation): number;
+    /**
+     * This function is used to determine if the variation is usable on a particular
+     * date.
+     * @param date The date object used to compare for use.
+     * @returns a boolean value if the date fits within the variation's period.
+     */
+    useVariation(date: Date): boolean;
+    /**
+     * This function will update the variation's schedule with the days from the sunday
+     * prior to start and the saturday after the end date.
+     */
+    setScheduleDays(): void;
+    /**
+     * This function is used to find the workday object from the variation's schedule for
+     * the date requested.  The workday is found by the number of days since the sunday
+     * prior to the start date.
+     * @param date The date object used to determine the workday.
+     * @returns The workday object representing the requested workday.
+     */
+    getWorkday(date: Date): Workday;
+    /**
+     * This function will set the workday's values from the client app where they are set.
+     * @param wdID The numeric value for the identifier of the particular workday.
+     * @param wkctr The string value representing the workcenter.
+     * @param code The string value for the work code to use on the day.
+     * @param hours The numeric value (float) for the number of hours to work on that day.
+     */
+    updateWorkday(wdID: number, wkctr: string, code: string, hours: number): void;
+    /**
+     * This function will set the workday's values from the client app the day of the
+     * schedule from a date.
+     * @param date The date object for the date of the workday.
+     * @param wkctr The string value representing the workcenter.
+     * @param code The string value for the work code to use on the day.
+     * @param hours The numeric value (float) for the number of hours to work on that day.
+     */
+    updateWorkdayByDate(date: Date, wkctr: string, code: string, hours: number): void;
+}

package/scheduler/employees/variation.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Variation = void 0;
+const workday_1 = require("./workday");
+/**
+ * This class description is for a schedule variation.  A schedule variation is used
+ * for a small change in an employee's schedule, one that will revert back to the primary
+ * schedule after the change period is complete.  The data members are:
+ * id (numeric value for the primary key)
+ * site (the string value for the site the employee is assigned)
+ * mids (A boolean value for variations is associated with a temporary mid shift assignment)
+ * startdate (a date object for the start of the variation period)
+ * enddate (a date object for the end of the variation period)
+ * schedule (a schedule object containing a group of workday objects which is used to
+ * define the days of the variation).
+ */
+class Variation {
+    id;
+    site;
+    mids;
+    mod;
+    startdate;
+    enddate;
+    schedule;
+    constructor(vari) {
+        this.id = (vari) ? vari.id : 0;
+        this.site = (vari) ? vari.site : '';
+        this.mids = (vari) ? vari.mids : false;
+        this.mod = (vari) ? vari.mod : false;
+        this.startdate = (vari) ? new Date(vari.startdate) : new Date();
+        this.enddate = (vari) ? new Date(vari.enddate) : new Date();
+        this.schedule = (vari) ? new workday_1.Schedule(vari.schedule)
+            : new workday_1.Schedule();
+    }
+    /**
+     * This function is used to sort this object from another variation object
+     * @param other The other variation object 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.startdate.getTime() === other.startdate.getTime()) {
+                if (this.enddate.getTime() === other.enddate.getTime()) {
+                    return (this.id < other.id) ? -1 : 1;
+                }
+                return (this.enddate.getTime() < other.enddate.getTime()) ? -1 : 1;
+            }
+            return (this.startdate.getTime() < other.startdate.getTime()) ? -1 : 1;
+        }
+        return -1;
+    }
+    /**
+     * This function is used to determine if the variation is usable on a particular
+     * date.
+     * @param date The date object used to compare for use.
+     * @returns a boolean value if the date fits within the variation's period.
+     */
+    useVariation(date) {
+        return (this.startdate.getTime() <= date.getTime()
+            && this.enddate.getTime() >= date.getTime());
+    }
+    /**
+     * This function will update the variation's schedule with the days from the sunday
+     * prior to start and the saturday after the end date.
+     */
+    setScheduleDays() {
+        let start = new Date(this.startdate);
+        while (start.getUTCDay() !== 0) {
+            start = new Date(start.getTime() - (24 * 3600000));
+        }
+        let end = new Date(this.enddate);
+        while (end.getUTCDay() !== 6) {
+            end = new Date(end.getTime() + (24 * 3600000));
+        }
+        this.schedule.workdays = [];
+        let count = -1;
+        while (start.getTime() <= end.getTime()) {
+            count++;
+            const wd = new workday_1.Workday();
+            wd.id = count;
+            this.schedule.workdays.push(wd);
+            start = new Date(start.getTime() + (24 * 3600000));
+        }
+    }
+    /**
+     * This function is used to find the workday object from the variation's schedule for
+     * the date requested.  The workday is found by the number of days since the sunday
+     * prior to the start date.
+     * @param date The date object used to determine the workday.
+     * @returns The workday object representing the requested workday.
+     */
+    getWorkday(date) {
+        let start = new Date(this.startdate);
+        while (start.getUTCDay() !== 0) {
+            start = new Date(start.getTime() - (24 * 3600000));
+        }
+        const days = Math.floor((date.getTime() - start.getTime()) / (24 * 3600000));
+        const iDay = days % this.schedule.workdays.length;
+        return this.schedule.getWorkday(iDay);
+    }
+    /**
+     * This function will set the workday's values from the client app where they are set.
+     * @param wdID The numeric value for the identifier of the particular workday.
+     * @param wkctr The string value representing the workcenter.
+     * @param code The string value for the work code to use on the day.
+     * @param hours The numeric value (float) for the number of hours to work on that day.
+     */
+    updateWorkday(wdID, wkctr, code, hours) {
+        this.schedule.changeWorkday(wdID, wkctr, code, hours);
+    }
+    /**
+     * This function will set the workday's values from the client app the day of the
+     * schedule from a date.
+     * @param date The date object for the date of the workday.
+     * @param wkctr The string value representing the workcenter.
+     * @param code The string value for the work code to use on the day.
+     * @param hours The numeric value (float) for the number of hours to work on that day.
+     */
+    updateWorkdayByDate(date, wkctr, code, hours) {
+        if (date.getTime() >= this.startdate.getTime()
+            && date.getTime() <= this.enddate.getTime()) {
+            let start = new Date(this.startdate);
+            while (start.getDay() !== 0) {
+                start = new Date(start.getTime() - (24 * 3600000));
+            }
+            const dos = Math.floor((date.getTime() - start.getTime()) / (24 * 3600000));
+            this.schedule.changeWorkday(dos, wkctr, code, hours);
+        }
+    }
+}
+exports.Variation = Variation;

package/scheduler/employees/web.d.ts

@@ -0,0 +1,6 @@
+import { LeaveRequest } from "./leaverequest";
+export interface ChangeLeaveRequestResponse {
+    message: string;
+    leaverequest: LeaveRequest | undefined;
+    error: Error | undefined;
+}

package/scheduler/employees/web.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/scheduler/employees/work.d.ts

@@ -0,0 +1,96 @@
+import { ObjectId } from "mongodb";
+/**
+ * Work interface and class descriptions
+ */
+/**
+ * The work interface describing the data members required.
+ */
+export interface IWork {
+    dateworked: Date;
+    chargenumber: string;
+    extension: string;
+    paycode: number;
+    modtime?: boolean;
+    hours: number;
+}
+/**
+ * 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)
+ */
+export declare class Work implements IWork {
+    dateworked: Date;
+    chargenumber: string;
+    extension: string;
+    paycode: number;
+    modtime: boolean;
+    hours: number;
+    constructor(wk?: IWork);
+    /**
+     * 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?: Work): number;
+    /**
+     * 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: Date): boolean;
+}
+/**
+ * The interface and class for holding work objects for an employee and year.
+ */
+/**
+ * This interface describes the data members of a Work Record.
+ */
+export interface IWorkRecord {
+    _id?: ObjectId;
+    id?: string;
+    employeeID?: ObjectId;
+    empID?: string;
+    year: number;
+    work?: IWork[];
+}
+/**
+ * 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)
+ */
+export declare class WorkRecord implements IWorkRecord {
+    id: string;
+    empID: string;
+    year: number;
+    work: Work[];
+    constructor(wr?: IWorkRecord);
+    /**
+     * 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?: WorkRecord): number;
+    /**
+     * 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: Date, end: Date): void;
+    /**
+     * 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: Date): boolean;
+}