scheduler-models 1.3.5

package/scheduler/employees/employee.js

@@ -0,0 +1,1723 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Employee = void 0;
+const employeename_1 = require("./employeename");
+const assignment_1 = require("./assignment");
+const variation_1 = require("./variation");
+const leaverequest_1 = require("./leaverequest");
+const labor_1 = require("./labor");
+const work_1 = require("./work");
+const users_1 = require("../../users");
+const contact_1 = require("./contact");
+const specialty_1 = require("./specialty");
+const leave_1 = require("./leave");
+const workday_1 = require("./workday");
+const balance_1 = require("./balance");
+const uuid_1 = require("uuid");
+class Employee {
+    id;
+    team;
+    site;
+    email;
+    name;
+    companyinfo;
+    assignments;
+    variations;
+    balances;
+    leaves;
+    requests;
+    laborCodes;
+    work;
+    user;
+    contactinfo;
+    specialties;
+    emails;
+    constructor(emp) {
+        this.id = (emp && emp.id) ? emp.id : '';
+        if (this.id === '') {
+            this.id = (emp && emp._id) ? emp._id.toString() : '';
+        }
+        this.team = (emp) ? emp.team : '';
+        this.site = (emp) ? emp.site : '';
+        this.email = (emp) ? emp.email : '';
+        this.name = (emp) ? new employeename_1.EmployeeName(emp.name) : new employeename_1.EmployeeName();
+        this.companyinfo = (emp) ? emp.companyinfo : { company: '', employeeid: '' };
+        this.assignments = [];
+        if (emp && emp.assignments && emp.assignments.length > 0) {
+            emp.assignments.forEach(a => {
+                this.assignments.push(new assignment_1.Assignment(a));
+            });
+            this.assignments.sort((a, b) => a.compareTo(b));
+        }
+        this.variations = [];
+        if (emp && emp.variations && emp.variations.length > 0) {
+            emp.variations.forEach(v => {
+                this.variations.push(new variation_1.Variation(v));
+            });
+            this.variations.sort((a, b) => a.compareTo(b));
+        }
+        this.balances = [];
+        if (emp && emp.balances && emp.balances.length > 0) {
+            emp.balances.forEach(b => {
+                this.balances.push(new balance_1.AnnualLeave(b));
+            });
+            this.balances.sort((a, b) => a.compareTo(b));
+        }
+        this.leaves = [];
+        if (emp && emp.leaves && emp.leaves.length > 0) {
+            emp.leaves.forEach(l => {
+                this.leaves.push(new leave_1.Leave(l));
+            });
+            this.leaves.sort((a, b) => a.compareTo(b));
+        }
+        this.requests = [];
+        if (emp && emp.requests && emp.requests.length > 0) {
+            emp.requests.forEach(r => {
+                this.requests.push(new leaverequest_1.LeaveRequest(r));
+            });
+            this.requests.sort((a, b) => a.compareTo(b));
+        }
+        this.laborCodes = [];
+        if (emp && emp.laborCodes && emp.laborCodes.length > 0) {
+            emp.laborCodes.forEach(l => {
+                this.laborCodes.push(new labor_1.EmployeeLaborCode(l));
+            });
+            this.laborCodes.sort((a, b) => a.compareTo(b));
+        }
+        this.contactinfo = [];
+        if (emp && emp.contactinfo && emp.contactinfo.length > 0) {
+            emp.contactinfo.forEach(c => {
+                this.contactinfo.push(new contact_1.Contact(c));
+            });
+            this.contactinfo.sort((a, b) => a.compareTo(b));
+        }
+        this.specialties = [];
+        if (emp && emp.specialties && emp.specialties.length > 0) {
+            emp.specialties.forEach(sp => {
+                this.specialties.push(new specialty_1.Specialty(sp));
+            });
+            this.specialties.sort((a, b) => a.compareTo(b));
+        }
+        this.emails = [];
+        if (emp && emp.emails && emp.emails.length > 0) {
+            emp.emails.forEach(e => {
+                this.emails.push(e);
+            });
+            this.emails.sort((a, b) => (a < b) ? -1 : 1);
+        }
+        if (emp && emp.work && emp.work.length > 0) {
+            this.work = [];
+            emp.work.forEach(w => {
+                this.work.push(new work_1.Work(w));
+            });
+            this.work.sort((a, b) => a.compareTo(b));
+        }
+        else {
+            this.work = undefined;
+        }
+        if (emp && emp.user) {
+            this.user = new users_1.User(emp.user);
+        }
+        else {
+            this.user = undefined;
+        }
+    }
+    compareTo(other) {
+        if (other) {
+            if (this.name.lastname === other.name.lastname) {
+                if (this.name.firstname === other.name.firstname) {
+                    if (this.name.middlename && other.name.middlename) {
+                        return (this.name.middlename < other.name.middlename) ? -1 : 1;
+                    }
+                    else if (this.name.middlename) {
+                        return -1;
+                    }
+                    else {
+                        return 1;
+                    }
+                }
+                return (this.name.firstname < other.name.firstname) ? -1 : 1;
+            }
+            return (this.name.lastname < other.name.lastname) ? -1 : 1;
+        }
+        return -1;
+    }
+    cloneForSave() {
+        const result = new Employee(this);
+        result.work = undefined;
+        result.user = undefined;
+        return result;
+    }
+    purge(date) {
+        this.variations.sort((a, b) => a.compareTo(b));
+        for (let v = this.variations.length - 1; v >= 0; v--) {
+            if (this.variations[v].enddate.getTime() < date.getTime()) {
+                this.variations.splice(v, 1);
+            }
+        }
+        this.leaves.sort((a, b) => a.compareTo(b));
+        for (let l = this.leaves.length - 1; l >= 0; l--) {
+            if (this.leaves[l].leavedate.getTime() < date.getTime()) {
+                this.leaves.splice(l, 1);
+            }
+        }
+        for (let l = this.requests.length - 1; l >= 0; l--) {
+            if (this.requests[l].enddate.getTime() < date.getTime()) {
+                this.requests.splice(l, 1);
+            }
+        }
+        this.balances.sort((a, b) => a.compareTo(b));
+        for (let b = this.balances.length - 1; b >= 0; b--) {
+            if (this.balances[b].year < date.getUTCFullYear()) {
+                this.balances.splice(b, 1);
+            }
+        }
+        this.assignments.sort((a, b) => a.compareTo(b));
+        const last = this.assignments[this.assignments.length - 1];
+        return (last.endDate.getTime() < date.getTime());
+    }
+    removeLeaves(start, end, reqID = '', includeActuals = true) {
+        this.leaves.sort((a, b) => a.compareTo(b));
+        for (let l = this.leaves.length - 1; l >= 0; l--) {
+            if (reqID === '' && includeActuals) {
+                if (this.leaves[l].leavedate.getTime() >= start.getTime()
+                    && this.leaves[l].leavedate.getTime() <= end.getTime()) {
+                    this.leaves.splice(l, 1);
+                }
+            }
+            else if (reqID !== '' && includeActuals) {
+                if (this.leaves[l].leavedate.getTime() >= start.getTime()
+                    && this.leaves[l].leavedate.getTime() <= end.getTime()
+                    && this.leaves[l].requestid === reqID) {
+                    this.leaves.splice(l, 1);
+                }
+            }
+            else if (reqID === '' && !includeActuals) {
+                if (this.leaves[l].leavedate.getTime() >= start.getTime()
+                    && this.leaves[l].leavedate.getTime() <= end.getTime()
+                    && this.leaves[l].status.toLowerCase() !== 'actual') {
+                    this.leaves.splice(l, 1);
+                }
+            }
+            else if (reqID !== '' && !includeActuals) {
+                if (this.leaves[l].leavedate.getTime() >= start.getTime()
+                    && this.leaves[l].leavedate.getTime() <= end.getTime()
+                    && this.leaves[l].status.toLowerCase() !== 'actual'
+                    && this.leaves[l].requestid === reqID) {
+                    this.leaves.splice(l, 1);
+                }
+            }
+        }
+    }
+    isActive(date) {
+        let result = false;
+        this.assignments.forEach(a => {
+            if (a.useSiteAssignment(this.site, date)) {
+                result = true;
+            }
+        });
+        return result;
+    }
+    isActiveBetween(start, end) {
+        let result = false;
+        this.assignments.forEach(a => {
+            if (a.useAssignment(start, end)) {
+                result = true;
+            }
+        });
+        return result;
+    }
+    isAssigned(site, wkctr, start, end) {
+        let result = false;
+        this.assignments.forEach(a => {
+            if (a.site.toLowerCase() === site.toLowerCase()
+                && a.workcenter.toLowerCase() === wkctr.toLowerCase()
+                && ((start.getTime() < a.startDate.getTime()
+                    && end.getTime() > a.endDate.getTime())
+                    || (end.getTime() > a.startDate.getTime()
+                        && end.getTime() < a.endDate.getTime())
+                    || (start.getTime() > a.startDate.getTime()
+                        && end.getTime() < a.endDate.getTime()))) {
+                result = true;
+            }
+        });
+        return result;
+    }
+    atSite(site, start, end) {
+        let result = false;
+        this.assignments.forEach(a => {
+            if (a.site.toLowerCase() === site.toLowerCase()
+                && ((start.getTime() < a.startDate.getTime()
+                    && end.getTime() > a.endDate.getTime())
+                    || (end.getTime() > a.startDate.getTime()
+                        && end.getTime() < a.endDate.getTime())
+                    || (start.getTime() > a.startDate.getTime()
+                        && end.getTime() < a.endDate.getTime()))) {
+                result = true;
+            }
+        });
+        return result;
+    }
+    getWorkday(date, type = 'general', labor) {
+        switch (type.toLowerCase()) {
+            case "actuals":
+                return this.getWorkdayActual(date, labor);
+                break;
+            case "noleaves":
+                return this.getWorkdayWOLeaves(date);
+                break;
+            default:
+                return this.getWorkdayGeneral(date);
+        }
+    }
+    getWorkdayGeneral(date) {
+        let wday;
+        let stdWorkday = 8.0;
+        let work = 0.0;
+        let siteid = '';
+        let lastWorked = new Date(0);
+        this.assignments.forEach(asgmt => {
+            if (asgmt.useSiteAssignment(this.site, date)) {
+                stdWorkday = asgmt.getStandardWorkHours();
+            }
+        });
+        if (this.work) {
+            this.work.forEach(wk => {
+                if (wk.useWork(date) && wk.modtime) {
+                    work += wk.hours;
+                }
+                if (wk.dateworked.getTime() > lastWorked.getTime()) {
+                    lastWorked = new Date(wk.dateworked);
+                }
+            });
+        }
+        this.assignments.forEach(asgmt => {
+            if (asgmt.useAssignment(date)) {
+                wday = asgmt.getWorkday(date);
+                siteid = asgmt.site;
+            }
+        });
+        this.variations.forEach(vari => {
+            if (vari.useVariation(date)) {
+                wday = vari.getWorkday(date);
+            }
+        });
+        if (work > 0.0) {
+            while (!wday || (wday && wday.code === '')) {
+                date = new Date(date.getTime() - (24 * 3600000));
+                this.assignments.forEach(asgmt => {
+                    if (asgmt.useAssignment(date)) {
+                        wday = asgmt.getWorkday(date);
+                    }
+                });
+            }
+            wday.hours = work;
+            return wday;
+        }
+        this.leaves.forEach(lv => {
+            if (lv.useLeave(date)
+                && (lv.hours > stdWorkday / 2 || lv.status.toLowerCase() === 'actual')) {
+                wday = new workday_1.Workday({
+                    id: 0,
+                    workcenter: '',
+                    code: lv.code,
+                    hours: lv.hours
+                });
+            }
+        });
+        return wday;
+    }
+    getWorkdayActual(date, labor) {
+        let wday;
+        let siteid = '';
+        let bPrimary = false;
+        this.assignments.forEach(asgmt => {
+            if (asgmt.useAssignment(date)) {
+                siteid = asgmt.site;
+                wday = asgmt.getWorkday(date);
+                labor?.forEach(lc => {
+                    asgmt.laborcodes.forEach(alc => {
+                        if (lc.chargenumber.toLowerCase() === alc.chargenumber.toLowerCase()
+                            && lc.extension.toLowerCase() === alc.extension.toLowerCase()) {
+                            bPrimary = true;
+                        }
+                    });
+                });
+            }
+        });
+        this.variations.forEach(vari => {
+            if (vari.useVariation(date)) {
+                wday = vari.getWorkday(date);
+            }
+        });
+        let bLeave = false;
+        if (bPrimary || labor?.length === 0) {
+            this.leaves.forEach(lv => {
+                if (lv.useLeave(date) && lv.status.toLowerCase() === 'actual') {
+                    if (!bLeave) {
+                        wday = new workday_1.Workday({
+                            id: 0,
+                            workcenter: '',
+                            code: lv.code,
+                            hours: lv.hours
+                        });
+                    }
+                    else {
+                        if (wday) {
+                            if (lv.hours <= wday.hours) {
+                                wday.hours += lv.hours;
+                            }
+                            else {
+                                wday.hours += lv.hours;
+                                wday.code = lv.code;
+                            }
+                        }
+                    }
+                }
+            });
+        }
+        return wday;
+    }
+    getWorkdayWOLeaves(date, useWork) {
+        let wday;
+        let stdWorkday = 8.0;
+        let work = 0.0;
+        let siteid = '';
+        let lastWorked = new Date(0);
+        this.assignments.forEach(asgmt => {
+            if (asgmt.useSiteAssignment(this.site, date)) {
+                stdWorkday = asgmt.getStandardWorkHours();
+            }
+        });
+        if (this.work) {
+            this.work.forEach(wk => {
+                if (wk.useWork(date) && wk.modtime) {
+                    work += wk.hours;
+                }
+                if (wk.dateworked.getTime() > lastWorked.getTime()) {
+                    lastWorked = new Date(wk.dateworked);
+                }
+            });
+        }
+        this.assignments.forEach(asgmt => {
+            if (asgmt.useAssignment(date)) {
+                wday = asgmt.getWorkday(date);
+                siteid = asgmt.site;
+            }
+        });
+        this.variations.forEach(vari => {
+            if (vari.useVariation(date)) {
+                wday = vari.getWorkday(date);
+            }
+        });
+        if (work > 0.0) {
+            while (!wday || (wday && wday.code === '')) {
+                date = new Date(date.getTime() - (24 * 3600000));
+                this.assignments.forEach(asgmt => {
+                    if (asgmt.useAssignment(date)) {
+                        wday = asgmt.getWorkday(date);
+                    }
+                });
+            }
+            wday.hours = work;
+            return wday;
+        }
+        if (useWork && date.getTime() <= lastWorked.getTime()) {
+            wday = undefined;
+        }
+        return wday;
+    }
+    getStandardWorkday(date) {
+        let answer = 8.0;
+        this.assignments.forEach(asgmt => {
+            if (asgmt.useAssignment(date)) {
+                answer = asgmt.getStandardWorkHours();
+            }
+        });
+        return answer;
+    }
+    addAssignment(site, wkctr, start) {
+        let max = -1;
+        this.assignments.sort((a, b) => a.compareTo(b));
+        this.assignments.forEach(asgmt => {
+            if (asgmt.id > max) {
+                max = asgmt.id;
+            }
+        });
+        const lastAsgmt = this.assignments[this.assignments.length - 1];
+        lastAsgmt.endDate = new Date(start.getTime() - (24 * 3600000));
+        this.assignments[this.assignments.length - 1] = lastAsgmt;
+        const newAsgmt = new assignment_1.Assignment({
+            id: max + 1,
+            site: site,
+            workcenter: wkctr,
+            startDate: new Date(start),
+            endDate: new Date(Date.UTC(9999, 11, 31)),
+            schedules: []
+        });
+        newAsgmt.addSchedule(7);
+        for (let d = 1; d < 6; d++) {
+            newAsgmt.changeWorkday(0, d, wkctr, 'D', 8.0);
+        }
+        this.assignments.push(newAsgmt);
+    }
+    updateAssignment(id, field, value, schedule, workday) {
+        let found = false;
+        this.assignments.sort((a, b) => a.compareTo(b));
+        this.assignments.forEach((asgmt, i) => {
+            if (asgmt.id === id) {
+                found = true;
+                switch (field.toLowerCase()) {
+                    case "site":
+                        asgmt.site = value;
+                        break;
+                    case "workcenter":
+                        asgmt.workcenter = value;
+                        break;
+                    case "start":
+                    case "startdate":
+                        asgmt.startDate = this.getDateFromString(value);
+                        break;
+                    case "end":
+                    case "enddate":
+                        asgmt.endDate = this.getDateFromString(value);
+                        break;
+                    case "rotationdate":
+                        asgmt.rotationdate = this.getDateFromString(value);
+                        break;
+                    case "rotationdays":
+                        asgmt.rotationdays = Number(value);
+                        break;
+                    case "addschedule":
+                        asgmt.addSchedule(Number(value));
+                        break;
+                    case "removeschedule":
+                        if (schedule) {
+                            asgmt.removeSchedule(schedule);
+                        }
+                        else {
+                            throw new Error('Assignment schedule id not provided');
+                        }
+                        break;
+                    case "scheduledays":
+                        if (schedule) {
+                            asgmt.changeScheduleDays(schedule, Number(value));
+                        }
+                        else {
+                            throw new Error('Assignment schedule id not provided');
+                        }
+                        break;
+                    case "workday-code":
+                    case "workday-workcenter":
+                    case "workday-hours":
+                    case "workday-copy":
+                        const wparts = field.split('-');
+                        if (schedule && workday) {
+                            asgmt.updateWorkday(schedule, workday, wparts[1], value);
+                        }
+                        else {
+                            throw new Error('Assignment schedule and/or workday id not provided');
+                        }
+                        break;
+                    case "addlaborcode":
+                        const vparts = value.split('|');
+                        asgmt.addLaborCode(vparts[0], vparts[1]);
+                        break;
+                    case "removelaborcode":
+                        const rparts = value.split('|');
+                        asgmt.removeLaborCode(rparts[0], rparts[1]);
+                        break;
+                }
+                this.assignments[i] = asgmt;
+            }
+        });
+        if (!found) {
+            throw new Error('Assignment not found');
+        }
+    }
+    removeAssignment(id) {
+        this.assignments.sort((a, b) => a.compareTo(b));
+        let pos = -1;
+        for (let a = 0; a < this.assignments.length && pos < 0; a++) {
+            if (this.assignments[a].id === id) {
+                pos = a;
+            }
+        }
+        if (pos === 0) {
+            const asgmt = this.assignments[pos];
+            const nextAsgmt = this.assignments[pos + 1];
+            nextAsgmt.startDate = new Date(asgmt.startDate);
+            this.assignments[pos + 1] = nextAsgmt;
+            this.assignments.splice(pos, 1);
+        }
+        else if (pos === this.assignments.length - 1) {
+            if (pos > 0) {
+                this.assignments[pos - 1].endDate = new Date(Date.UTC(9999, 11, 31));
+                this.assignments.pop();
+            }
+        }
+        else {
+            this.assignments[pos - 1].endDate
+                = new Date(this.assignments[pos + 1].startDate.getTime() - (24 * 3600000));
+            this.assignments.splice(pos, 1);
+        }
+    }
+    addVariation(site, start) {
+        let newID = -1;
+        this.variations.forEach(vari => {
+            if (vari.id > newID) {
+                newID = vari.id;
+            }
+        });
+        newID++;
+        const newVari = new variation_1.Variation();
+        newVari.id = newID;
+        newVari.site = site;
+        newVari.startdate = new Date(start);
+        newVari.enddate = new Date(start);
+        this.variations.push(newVari);
+        this.variations.sort((a, b) => a.compareTo(b));
+    }
+    updateVariation(varID, field, value, workday) {
+        this.variations.sort((a, b) => a.compareTo(b));
+        let found = false;
+        this.variations.forEach((vari, v) => {
+            if (vari.id === varID) {
+                found = true;
+                switch (field.toLowerCase()) {
+                    case "site":
+                        vari.site = value;
+                        break;
+                    case "mids":
+                    case "ismids":
+                        vari.mids = Boolean(value);
+                        break;
+                    case "dates":
+                        vari.schedule.showdates = Boolean(value);
+                        break;
+                    case "start":
+                    case "startdate":
+                        vari.startdate = this.getDateFromString(value);
+                        break;
+                    case "end":
+                    case "enddate":
+                        vari.enddate = this.getDateFromString(value);
+                        break;
+                    case "changeschedule":
+                        vari.schedule.setScheduleDays(Number(value));
+                        break;
+                    case "workday-code":
+                    case "workday-workcenter":
+                    case "workday-hours":
+                    case "workday-copy":
+                        const wparts = field.split('-');
+                        if (workday) {
+                            vari.updateWorkday(workday, wparts[1], value);
+                        }
+                        break;
+                }
+                this.variations[v] = vari;
+            }
+        });
+        if (!found) {
+            throw new Error('Variation not found');
+        }
+    }
+    getDateFromString(date) {
+        const reDateFormat = new RegExp('^[0-9]{4}\-[0-9]{2}\-[0-9]{2}$');
+        if (reDateFormat.test(date)) {
+            const parts = date.split('-');
+            const year = parseInt(parts[0]);
+            const month = parseInt(parts[1]);
+            const day = parseInt(parts[2]);
+            const result = new Date(Date.UTC(year, month - 1, day));
+            return result;
+        }
+        else {
+            throw new Error('Date not in correct format (yyyy-mm-dd)');
+        }
+    }
+    removeVariation(varID) {
+        let found = -1;
+        this.variations.forEach((vari, v) => {
+            if (vari.id === varID) {
+                found = v;
+            }
+        });
+        if (found >= 0) {
+            this.variations.splice(found, 1);
+        }
+        else {
+            throw new Error('Variation not found');
+        }
+    }
+    isPrimaryCode(date, labor) {
+        let answer = false;
+        this.assignments.forEach(asgmt => {
+            if (asgmt.useAssignment(date)) {
+                asgmt.laborcodes.forEach(lc => {
+                    if (labor.chargenumber.toLowerCase() === lc.chargenumber.toLowerCase()
+                        && labor.extension.toLowerCase() === lc.extension.toLowerCase()) {
+                        answer = true;
+                    }
+                });
+            }
+        });
+        return answer;
+    }
+    hasLaborCode(chargeNumber, extension) {
+        let found = false;
+        this.assignments.forEach(asgmt => {
+            asgmt.laborcodes.forEach(lc => {
+                if (lc.chargenumber.toLowerCase() === chargeNumber.toLowerCase()
+                    && lc.extension.toLowerCase() === extension.toLowerCase()) {
+                    found = true;
+                }
+            });
+        });
+        return found;
+    }
+    hasLaborCodeOnDate(date, chgNo, ext) {
+        let found = false;
+        this.assignments.forEach(asgmt => {
+            if (asgmt.useAssignment(date)) {
+                asgmt.laborcodes.forEach(lc => {
+                    if (lc.chargenumber.toLowerCase() === chgNo.toLowerCase()
+                        && lc.extension.toLowerCase() === ext.toLowerCase()) {
+                        found = true;
+                    }
+                });
+            }
+        });
+        return found;
+    }
+    getAssignmentForPeriod(start, end) {
+        const assigned = new Map();
+        start = new Date(Date.UTC(start.getFullYear(), start.getMonth(), start.getDate()));
+        end = new Date(Date.UTC(end.getFullYear(), end.getMonth(), end.getDate()));
+        while (start.getTime() <= end.getTime()) {
+            const wd = this.getWorkdayWOLeaves(start);
+            if (wd) {
+                const label = `${wd.workcenter}-${wd.code}`;
+                if (label !== '-') {
+                    if (assigned.has(label)) {
+                        let num = assigned.get(label);
+                        if (num) {
+                            num++;
+                            assigned.set(label, num);
+                        }
+                        else {
+                            assigned.set(label, 1);
+                        }
+                    }
+                    else {
+                        assigned.set(label, 1);
+                    }
+                }
+            }
+            start = new Date(start.getTime() + (24 * 3600000));
+        }
+        let max = 0;
+        let label = '';
+        const keys = Array.from(assigned.keys());
+        keys.forEach(key => {
+            const num = assigned.get(key);
+            if (num && num > max) {
+                max = num;
+                label = key;
+            }
+        });
+        const work = label.split('-');
+        return new workday_1.Workday({
+            id: 0,
+            workcenter: work[0],
+            code: work[1],
+            hours: 0.0
+        });
+    }
+    getForecastHours(labor, start, end, codes) {
+        let answer = 0.0;
+        start = new Date(Date.UTC(start.getFullYear(), start.getMonth(), start.getDate()));
+        end = new Date(Date.UTC(end.getFullYear(), end.getMonth(), end.getDate()));
+        let found = false;
+        this.assignments.forEach(asgmt => {
+            if (asgmt.useAssignment(start, end, labor)) {
+                found = true;
+            }
+        });
+        if (!found) {
+            return 0.0;
+        }
+        if (!labor.startDate || !labor.endDate
+            || labor.endDate.getTime() < start.getTime()
+            || labor.startDate.getTime() > end.getTime()) {
+            return 0.0;
+        }
+        let lastWorked = new Date(0);
+        if (this.work && this.work.length > 0) {
+            this.work.sort((a, b) => a.compareTo(b));
+            lastWorked = new Date(this.work[this.work.length - 1].dateworked);
+        }
+        this.leaves.sort((a, b) => a.compareTo(b));
+        this.leaves.forEach(lv => {
+            if (lv.status.toLowerCase() === 'actual' && lv.leavedate.getTime() > lastWorked.getTime()) {
+                lastWorked = new Date(lv.leavedate);
+            }
+        });
+        let current = new Date(start);
+        while (current.getTime() <= end.getTime()) {
+            if (current.getTime() > lastWorked.getTime()) {
+                const nextday = new Date(current.getTime() + (24 * 3600000));
+                let hours = this.getWorkedHours(current, nextday);
+                if (hours === 0.0) {
+                    if (current.getTime() >= labor.startDate.getTime()
+                        && current.getTime() <= labor.endDate.getTime()) {
+                        const wd = this.getWorkday(current);
+                        if (wd && wd.code !== '') {
+                            codes.forEach(code => {
+                                if (code.id.toLowerCase() === wd.code.toLowerCase() && !code.isLeave) {
+                                    this.assignments.forEach(asgmt => {
+                                        if (asgmt.useAssignment(current, nextday, labor)) {
+                                            answer += wd.hours;
+                                        }
+                                    });
+                                }
+                            });
+                        }
+                    }
+                }
+            }
+            current = new Date(current.getTime() + (24 * 3600000));
+        }
+        return answer;
+    }
+    getWorkedHours(start, end, chgno, ext) {
+        start = new Date(Date.UTC(start.getFullYear(), start.getMonth(), start.getDate()));
+        end = new Date(Date.UTC(end.getFullYear(), end.getMonth(), end.getDate()));
+        let answer = 0.0;
+        if (this.work) {
+            this.work.forEach(wk => {
+                if (wk.dateworked.getTime() >= start.getTime()
+                    && wk.dateworked.getTime() <= end.getTime()
+                    && !wk.modtime) {
+                    if (!chgno) {
+                        answer += wk.hours;
+                    }
+                    else if (chgno && ext) {
+                        if (chgno.toLowerCase() === wk.chargenumber.toLowerCase()
+                            && ext.toLowerCase() === wk.extension.toLowerCase()) {
+                            answer += wk.hours;
+                        }
+                    }
+                }
+            });
+        }
+        return answer;
+    }
+    getLastWorkday() {
+        let answer = new Date(0);
+        if (this.work && this.work.length > 0) {
+            this.work.sort((a, b) => a.compareTo(b));
+            const last = this.work[this.work.length - 1];
+            answer = new Date(last.dateworked);
+        }
+        return answer;
+    }
+    getModTime(start, end) {
+        let answer = 0.0;
+        this.work?.forEach(wk => {
+            if (wk.dateworked.getTime() >= start.getTime()
+                && wk.dateworked.getTime() <= end.getTime()
+                && wk.modtime) {
+                answer += wk.hours;
+            }
+        });
+        return answer;
+    }
+    hasModTime(start, end) {
+        let answer = false;
+        this.work?.forEach(wk => {
+            if (wk.dateworked.getTime() >= start.getTime()
+                && wk.dateworked.getTime() <= end.getTime()
+                && wk.modtime) {
+                answer = true;
+            }
+        });
+        return answer;
+    }
+    createLeaveBalance(year) {
+        let found = false;
+        let lastAnnual = 0.0;
+        let lastCarry = 0.0;
+        this.balances.forEach(bal => {
+            if (bal.year === year) {
+                found = true;
+            }
+            if (bal.year === year - 1) {
+                lastAnnual = bal.annual;
+                lastCarry = bal.carryover;
+            }
+        });
+        if (!found) {
+            const bal = new balance_1.AnnualLeave({
+                year: year,
+                annual: lastAnnual,
+                carryover: lastCarry
+            });
+            if (lastAnnual === 0.0) {
+                bal.annual = 100;
+            }
+            else {
+                let carry = lastAnnual + lastCarry;
+                this.leaves.forEach(lv => {
+                    if (lv.leavedate.getFullYear() === year && lv.code.toLowerCase() === 'v'
+                        && lv.status.toLowerCase() === 'actual') {
+                        carry -= lv.hours;
+                    }
+                });
+                bal.carryover = carry;
+            }
+            this.balances.push(bal);
+            this.balances.sort((a, b) => a.compareTo(b));
+        }
+        else {
+            throw new Error('Leave Balance year already exists');
+        }
+    }
+    updateLeaveBalance(year, field, value) {
+        let found = false;
+        for (let lb = 0; lb < this.balances.length && !found; lb++) {
+            if (this.balances[lb].year === year) {
+                found = true;
+                switch (field.toLowerCase()) {
+                    case "annual":
+                        this.balances[lb].annual = value;
+                        break;
+                    case 'carry':
+                    case 'carryover':
+                        this.balances[lb].carryover = value;
+                        break;
+                }
+            }
+        }
+        if (!found) {
+            throw new Error('Leave Balance year not found');
+        }
+        this.balances.sort((a, b) => a.compareTo(b));
+    }
+    deleteLeaveBalance(year) {
+        let found = -1;
+        this.balances.forEach((bal, i) => {
+            if (bal.year === year) {
+                found = i;
+            }
+        });
+        if (found >= 0) {
+            this.balances.splice(found, 1);
+        }
+        else {
+            throw new Error('Leave Balance year not found');
+        }
+    }
+    addLeave(id, date, code, status, hours, requestid, holCode) {
+        let found = false;
+        let max = 0;
+        date = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+        this.leaves.forEach((lv, l) => {
+            if ((lv.useLeave(date) && lv.code.toLowerCase() === code.toLowerCase())
+                || lv.id === id) {
+                found = true;
+                lv.status = status;
+                lv.hours = hours;
+                if (lv.requestid === '') {
+                    lv.requestid = requestid;
+                }
+                if (holCode && holCode !== '') {
+                    lv.tagday = holCode;
+                }
+                this.leaves[l] = lv;
+            }
+            else if (lv.id > max) {
+                max = lv.id;
+            }
+        });
+        if (!found) {
+            const lv = new leave_1.Leave({
+                id: max + 1,
+                leavedate: new Date(date),
+                code: code,
+                hours: hours,
+                status: status,
+                requestid: requestid,
+                used: false,
+                tagday: holCode
+            });
+            this.leaves.push(lv);
+            this.leaves.sort((a, b) => a.compareTo(b));
+        }
+    }
+    updateLeave(id, field, value) {
+        let answer = undefined;
+        this.leaves.forEach((lv, l) => {
+            if (lv.id === id) {
+                switch (field.toLowerCase()) {
+                    case "date":
+                        const newdate = new Date(Date.parse(value));
+                        lv.leavedate = newdate;
+                        break;
+                    case "code":
+                        lv.code = value;
+                        break;
+                    case "hours":
+                        lv.hours = Number(value);
+                        break;
+                    case 'status':
+                        lv.status = value;
+                        break;
+                    case 'requestid':
+                        lv.requestid = value;
+                        break;
+                    case 'tagday':
+                        lv.tagday = value;
+                        break;
+                }
+            }
+            this.leaves[l] = lv;
+            this.leaves.sort((a, b) => a.compareTo(b));
+            answer = lv;
+        });
+        return answer;
+    }
+    deleteLeave(id) {
+        let found = -1;
+        this.leaves.forEach((lv, l) => {
+            if (lv.id === id) {
+                found = l;
+            }
+        });
+        if (found >= 0) {
+            this.leaves.splice(found, 1);
+        }
+    }
+    getLeaveHours(start, end) {
+        let answer = 0.0;
+        this.leaves.forEach(lv => {
+            if (lv.leavedate.getTime() >= start.getTime()
+                && end.getTime() >= lv.leavedate.getTime()
+                && lv.status.toLowerCase() === 'actual') {
+                answer += lv.hours;
+            }
+        });
+        return answer;
+    }
+    getLeave(start) {
+        const workday = new workday_1.Workday();
+        this.leaves.forEach(lv => {
+            if (lv.leavedate.getUTCFullYear() === start.getUTCFullYear()
+                && lv.leavedate.getUTCMonth() === start.getUTCMonth()
+                && lv.leavedate.getUTCDate() === start.getUTCDate()) {
+                if (workday.code === '') {
+                    workday.code = lv.code;
+                    workday.hours = lv.hours;
+                }
+                else {
+                    if (workday.hours < lv.hours) {
+                        workday.code = lv.code;
+                        workday.hours += lv.hours;
+                    }
+                }
+            }
+        });
+        return workday;
+    }
+    getPTOHours(start, end) {
+        let answer = 0.0;
+        this.leaves.forEach(lv => {
+            if (lv.leavedate.getTime() >= start.getTime()
+                && end.getTime() >= lv.leavedate.getTime()
+                && lv.status.toLowerCase() === 'actual'
+                && lv.code.toLowerCase() === 'v') {
+                answer += lv.hours;
+            }
+        });
+        return answer;
+    }
+    createLeaveRequest(start, end, code, comment) {
+        start = new Date(Date.UTC(start.getFullYear(), start.getMonth(), start.getDate()));
+        end = new Date(Date.UTC(end.getFullYear(), end.getMonth(), end.getDate()));
+        let answer = undefined;
+        this.requests.forEach((req, r) => {
+            if (req.startdate.getTime() === start.getTime()
+                && req.enddate.getTime() === end.getTime()) {
+                if (comment) {
+                    const cmt = new leaverequest_1.LeaveRequestComment({
+                        commentdate: new Date(),
+                        comment: comment
+                    });
+                    req.comments.push(cmt);
+                    req.comments.sort((a, b) => a.compareTo(b));
+                }
+                answer = new leaverequest_1.LeaveRequest(req);
+            }
+        });
+        if (!answer) {
+            const id = (0, uuid_1.v4)().toString();
+            answer = new leaverequest_1.LeaveRequest({
+                id: id,
+                employeeid: this.id,
+                requestdate: new Date(),
+                primarycode: code,
+                startdate: start,
+                enddate: end,
+                status: 'DRAFT',
+                approvalDate: new Date(0),
+                approvedby: '',
+                requesteddays: [],
+                comments: []
+            });
+            answer.comments.push(new leaverequest_1.LeaveRequestComment({
+                commentdate: new Date(),
+                comment: 'Request Created'
+            }));
+            if (comment) {
+                answer.comments.push(new leaverequest_1.LeaveRequestComment({
+                    commentdate: new Date(),
+                    comment: comment
+                }));
+            }
+            answer.setLeaveDays(this);
+            this.requests.push(new leaverequest_1.LeaveRequest(answer));
+        }
+        return answer;
+    }
+    updateLeaveRequest(id, field, value) {
+        const answer = {
+            message: '',
+            leaverequest: undefined,
+            error: undefined
+        };
+        this.requests.forEach((req, r) => {
+            if (req.useRequest(id)) {
+                switch (field.toLowerCase()) {
+                    case "startdate":
+                    case "start":
+                        let date = new Date(Date.parse(value));
+                        date = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+                        if (date.getTime() < req.startdate.getTime()
+                            || date.getTime() > req.enddate.getTime()) {
+                            if (req.status.toLowerCase() === 'approved') {
+                                this.leaves.sort((a, b) => a.compareTo(b));
+                                let count = 0;
+                                let startpos = -1;
+                                this.leaves.forEach((lv, l) => {
+                                    if (lv.requestid === id && lv.status.toLowerCase() !== 'actual') {
+                                        if (startpos < 0) {
+                                            startpos = l;
+                                            count++;
+                                        }
+                                        else {
+                                            count++;
+                                        }
+                                    }
+                                });
+                                if (startpos >= 0) {
+                                    this.leaves.splice(startpos, count);
+                                }
+                            }
+                            req.status = 'DRAFT';
+                            req.approvalDate = new Date(0);
+                            req.approvedby = '';
+                            answer.message = `Leave Request: ${this.name.getFirstLast()} leave request `
+                                + `(${req.startdate.toLocaleDateString('en-US')}-`
+                                + `${req.enddate.toLocaleDateString('en-US')}) start date was changed to `
+                                + `before original date.  This converted the leave request back to draft `
+                                + `for resubmittal.`;
+                        }
+                        else {
+                            if (req.status.toLowerCase() === 'approved') {
+                                this.leaves.sort((a, b) => a.compareTo(b));
+                                let count = 0;
+                                let startpos = -1;
+                                this.leaves.forEach((lv, l) => {
+                                    if (lv.requestid === id && lv.status.toLowerCase() !== 'actual'
+                                        && lv.leavedate.getTime() < date.getTime()) {
+                                        if (startpos < 0) {
+                                            startpos = l;
+                                            count++;
+                                        }
+                                        else {
+                                            count++;
+                                        }
+                                    }
+                                });
+                                if (startpos >= 0 && count > 0) {
+                                    this.leaves.splice(startpos, count);
+                                }
+                            }
+                            answer.message = `Leave Request: ${this.name.getFirstLast()} leave request `
+                                + `(${req.startdate.toLocaleDateString('en-US')}-`
+                                + `${req.enddate.toLocaleDateString('en-US')}) start date was changed `
+                                + `within the original dates.  Approved Leave days were updated in the database `
+                                + 'as approved.';
+                        }
+                        req.startdate = new Date(date);
+                        req.setLeaveDays(this);
+                        req.comments.push(new leaverequest_1.LeaveRequestComment({
+                            commentdate: new Date(),
+                            comment: `Start date for request was changed to ${date.toDateString()}`
+                        }));
+                        req.comments.sort((a, b) => a.compareTo(b));
+                        break;
+                    case "enddate":
+                    case "end":
+                        date = new Date(Date.parse(value));
+                        date = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+                        if (date.getTime() < req.startdate.getTime()
+                            || date.getTime() > req.enddate.getTime()) {
+                            if (req.status.toLowerCase() === 'approved') {
+                                this.leaves.sort((a, b) => a.compareTo(b));
+                                let count = 0;
+                                let startpos = -1;
+                                this.leaves.forEach((lv, l) => {
+                                    if (lv.requestid === id && lv.status.toLowerCase() !== 'actual') {
+                                        if (startpos < 0) {
+                                            startpos = l;
+                                            count++;
+                                        }
+                                        else {
+                                            count++;
+                                        }
+                                    }
+                                });
+                                if (startpos >= 0) {
+                                    this.leaves.splice(startpos, count);
+                                }
+                            }
+                            req.status = 'DRAFT';
+                            req.approvalDate = new Date(0);
+                            req.approvedby = '';
+                            answer.message = `Leave Request: ${this.name.getFirstLast()} leave request `
+                                + `(${req.startdate.toLocaleDateString('en-US')}-`
+                                + `${req.enddate.toLocaleDateString('en-US')}) ending date was changed to `
+                                + `after original date.  This converted the leave request back to draft `
+                                + `for resubmittal.`;
+                        }
+                        else {
+                            if (req.status.toLowerCase() === 'approved') {
+                                this.leaves.sort((a, b) => a.compareTo(b));
+                                let count = 0;
+                                let startpos = -1;
+                                this.leaves.forEach((lv, l) => {
+                                    if (lv.requestid === id && lv.status.toLowerCase() !== 'actual'
+                                        && lv.leavedate.getTime() > date.getTime()) {
+                                        if (startpos < 0) {
+                                            startpos = l;
+                                            count++;
+                                        }
+                                        else {
+                                            count++;
+                                        }
+                                    }
+                                });
+                                if (startpos >= 0 && count > 0) {
+                                    this.leaves.splice(startpos, count);
+                                }
+                                answer.message = `Leave Request: ${this.name.getFirstLast()} leave request `
+                                    + `(${req.startdate.toLocaleDateString('en-US')}-`
+                                    + `${req.enddate.toLocaleDateString('en-US')}) start date was changed `
+                                    + `within the original dates.  Approved leave dates were updated in the`
+                                    + 'database as approved';
+                            }
+                        }
+                        req.enddate = new Date(date);
+                        req.setLeaveDays(this);
+                        req.comments.push(new leaverequest_1.LeaveRequestComment({
+                            commentdate: new Date(),
+                            comment: `End date for request was changed to ${date.toDateString()}`
+                        }));
+                        req.comments.sort((a, b) => a.compareTo(b));
+                        break;
+                    case 'dates':
+                        const values = value.split('|');
+                        let newstart = new Date(Date.parse(values[0]));
+                        newstart = new Date(Date.UTC(newstart.getFullYear(), newstart.getMonth(), newstart.getDate()));
+                        let newend = new Date(Date.parse(values[1]));
+                        newend = new Date(Date.UTC(newend.getFullYear(), newend.getMonth(), newend.getDate()));
+                        if (newstart.getTime() < req.startdate.getTime()
+                            || newstart.getTime() > req.enddate.getTime()
+                            || newend.getTime() < req.startdate.getTime()
+                            || newend.getTime() > req.enddate.getTime()) {
+                            if (req.status.toLowerCase() === 'approved') {
+                                this.leaves.sort((a, b) => a.compareTo(b));
+                                let count = 0;
+                                let startpos = -1;
+                                this.leaves.forEach((lv, l) => {
+                                    if (lv.requestid === id && lv.status.toLowerCase() !== 'actual') {
+                                        if (startpos < 0) {
+                                            startpos = l;
+                                            count++;
+                                        }
+                                        else {
+                                            count++;
+                                        }
+                                    }
+                                });
+                                if (startpos >= 0) {
+                                    this.leaves.splice(startpos, count);
+                                }
+                            }
+                            req.status = 'DRAFT';
+                            req.approvalDate = new Date(0);
+                            req.approvedby = '';
+                            answer.message = `Leave Request: ${this.name.getFirstLast()} leave request `
+                                + `(${req.startdate.toLocaleDateString('en-US')}-`
+                                + `${req.enddate.toLocaleDateString('en-US')}) start date was changed to `
+                                + `outside the original dates.  This converted the leave request back to draft `
+                                + `for resubmittal.`;
+                        }
+                        else {
+                            if (req.status.toLowerCase() === 'approved') {
+                                this.leaves.sort((a, b) => a.compareTo(b));
+                                let startcount = 0;
+                                let startpos = -1;
+                                let endcount = 0;
+                                let endpos = -1;
+                                this.leaves.forEach((lv, l) => {
+                                    if (lv.requestid === id && lv.status.toLowerCase() !== 'actual'
+                                        && lv.leavedate.getTime() < newstart.getTime()) {
+                                        if (startpos < 0) {
+                                            startpos = l;
+                                            startcount++;
+                                        }
+                                        else {
+                                            startcount++;
+                                        }
+                                    }
+                                    else if (lv.requestid === id && lv.status.toLowerCase() !== 'actual'
+                                        && lv.leavedate.getTime() > newend.getTime()) {
+                                        if (endpos < 0) {
+                                            endpos = l;
+                                            endcount++;
+                                        }
+                                        else {
+                                            endcount++;
+                                        }
+                                    }
+                                });
+                                if (startpos >= 0 && endcount > 0) {
+                                    this.leaves.splice(startpos, startcount);
+                                }
+                                if (endpos >= 0 && endcount > 0) {
+                                    this.leaves.splice(endpos, endcount);
+                                }
+                                answer.message = `Leave Request: ${this.name.getFirstLast()} leave request `
+                                    + `(${req.startdate.toLocaleDateString('en-US')}-`
+                                    + `${req.enddate.toLocaleDateString('en-US')}) both dates were changed to `
+                                    + `within the original dates.  All approved leave dates were updated in `
+                                    + 'the database.';
+                            }
+                        }
+                        req.startdate = new Date(newstart);
+                        req.enddate = new Date(newend);
+                        req.setLeaveDays(this);
+                        req.comments.push(new leaverequest_1.LeaveRequestComment({
+                            commentdate: new Date(),
+                            comment: `Request dates for request were changed to `
+                                + `${newstart.toDateString()} - ${newend.toDateString()}`
+                        }));
+                        req.comments.sort((a, b) => a.compareTo(b));
+                        break;
+                    case "code":
+                    case "primarycode":
+                        req.primarycode = value;
+                        req.setLeaveDays(this, true);
+                        req.comments.push(new leaverequest_1.LeaveRequestComment({
+                            commentdate: new Date(),
+                            comment: `Primary Code for request was changed to ${value}`
+                        }));
+                        req.comments.sort((a, b) => a.compareTo(b));
+                        break;
+                    case "requested":
+                        req.status = 'REQUESTED';
+                        req.requesteddays.forEach((lv, l) => {
+                            if (lv.code !== '') {
+                                lv.status = 'REQUESTED';
+                                req.requesteddays[l] = lv;
+                            }
+                        });
+                        req.comments.push(new leaverequest_1.LeaveRequestComment({
+                            commentdate: new Date(),
+                            comment: 'Leave request was submitted for approval.'
+                        }));
+                        req.comments.sort((a, b) => a.compareTo(b));
+                        answer.message = `Leave Request from ${this.name.getLastFirst()} `
+                            + `submitted for approval.  Requested leave dates: `
+                            + `${req.startdate.toDateString()} - ${req.enddate.toDateString()}.`;
+                        break;
+                    case "unapprove":
+                        req.approvedby = '';
+                        req.approvalDate = new Date(0);
+                        req.status = 'DRAFT';
+                        req.requesteddays.forEach((lv, l) => {
+                            if (lv.code !== '') {
+                                lv.status = 'REQUESTED';
+                                req.requesteddays[l] = lv;
+                            }
+                        });
+                        req.comments.push(new leaverequest_1.LeaveRequestComment({
+                            commentdate: new Date(),
+                            comment: value
+                        }));
+                        req.comments.sort((a, b) => a.compareTo(b));
+                        answer.message = `Leave Request: ${this.name.getFirstLast()} leave request `
+                            + `(${req.startdate.toLocaleDateString('en-US')}-`
+                            + `${req.enddate.toLocaleDateString('en-US')}) was declined by approver.`;
+                        break;
+                    case 'day':
+                    case 'requestday':
+                        const bApproved = req.status.toLowerCase() === 'approved';
+                        let found = false;
+                        let max = 0;
+                        const svalues = value.split('|');
+                        let lvDate = new Date(Date.parse(svalues[0]));
+                        let code = svalues[1];
+                        let hours = Number(svalues[2]);
+                        let status = '';
+                        let workcenter = '';
+                        if (svalues.length > 3) {
+                            workcenter = svalues[3];
+                        }
+                        req.requesteddays.forEach((lv, l) => {
+                            if (lv.useLeave(lvDate)) {
+                                found = true;
+                                lv.code = code;
+                                if (status == '') {
+                                    status = lv.status;
+                                }
+                                lv.status = workcenter;
+                                if (code == '') {
+                                    lv.hours = 0.0;
+                                }
+                                else {
+                                    lv.hours = hours;
+                                }
+                                req.requesteddays[l] = lv;
+                            }
+                            if (max < lv.id) {
+                                max = lv.id;
+                            }
+                        });
+                        if (!found) {
+                            const lv = new leave_1.Leave({
+                                id: max + 1,
+                                leavedate: new Date(lvDate),
+                                code: code,
+                                hours: hours,
+                                status: status,
+                                requestid: req.id,
+                                used: false
+                            });
+                            req.requesteddays.push(lv);
+                            req.requesteddays.sort((a, b) => a.compareTo(b));
+                        }
+                        if (bApproved) {
+                            found = false;
+                            this.leaves.forEach((lv, l) => {
+                                if (lv.useLeave(lvDate)) {
+                                    found = true;
+                                    lv.code = code;
+                                    if (code === '') {
+                                        lv.hours = 0.0;
+                                    }
+                                    else {
+                                        lv.hours = hours;
+                                    }
+                                    this.leaves[l] = lv;
+                                }
+                            });
+                            if (!found && code !== '') {
+                                this.leaves.push(new leave_1.Leave({
+                                    id: max + 1,
+                                    leavedate: new Date(lvDate),
+                                    code: code,
+                                    hours: hours,
+                                    status: req.status,
+                                    requestid: req.id,
+                                    used: false
+                                }));
+                            }
+                        }
+                        req.comments.push(new leaverequest_1.LeaveRequestComment({
+                            commentdate: new Date(),
+                            comment: `Requested Days Updated: ${lvDate.toDateString()} to Code: ${code}, `
+                                + `hours: ${hours}`
+                        }));
+                    case "comment":
+                    case "addcomment":
+                        req.comments.push(new leaverequest_1.LeaveRequestComment({
+                            commentdate: new Date(),
+                            comment: value
+                        }));
+                        req.comments.sort((a, b) => a.compareTo(b));
+                        break;
+                }
+                answer.leaverequest = req;
+            }
+        });
+        return answer;
+    }
+    approveLeaveRequest(id, approver, leavecodes) {
+        const answer = {
+            message: '',
+            leaverequest: undefined,
+            error: undefined
+        };
+        this.requests.forEach((req, r) => {
+            if (req.id === id) {
+                req.approvalDate = new Date();
+                req.approvedby = approver;
+                req.status = 'Approved';
+                let max = 0;
+                this.removeLeaves(req.startdate, req.enddate, req.id, false);
+                this.leaves.forEach(lv => {
+                    if (max < lv.id) {
+                        max = lv.id;
+                    }
+                });
+                if (req.primarycode.toLowerCase() !== 'mod') {
+                    req.requesteddays.forEach((day, d) => {
+                        if (day.code !== '') {
+                            max++;
+                            day.status = 'Approved';
+                            req.requesteddays[d] = day;
+                            this.leaves.push(new leave_1.Leave({
+                                id: max,
+                                leavedate: new Date(day.leavedate),
+                                code: day.code,
+                                hours: day.hours,
+                                status: day.status,
+                                requestid: req.id,
+                                used: false
+                            }));
+                        }
+                    });
+                    answer.message = `Leave Request was approved for period of `
+                        + `${req.startdate.toDateString()} - ${req.enddate.toDateString()}.`;
+                    answer.leaverequest = req;
+                }
+                else {
+                    let found = false;
+                    this.variations.forEach((vari, v) => {
+                        if (vari.startdate.getTime() === req.startdate.getTime()
+                            && vari.enddate.getTime() === req.enddate.getTime()
+                            && vari.mod) {
+                            found = true;
+                            let start = new Date(req.startdate);
+                            while (start.getDay() !== 0) {
+                                start = new Date(start.getTime() - (24 * 3600000));
+                            }
+                            vari.setScheduleDays();
+                            let lastcode = '';
+                            let workcenter = '';
+                            req.requesteddays.forEach(day => {
+                                let isLeave = false;
+                                leavecodes.forEach(wc => {
+                                    if (wc.id.toLowerCase() === day.code.toLowerCase() && wc.isLeave) {
+                                        isLeave = true;
+                                    }
+                                });
+                                if (isLeave) {
+                                    max++;
+                                    this.leaves.push(new leave_1.Leave({
+                                        id: max,
+                                        leavedate: new Date(day.leavedate),
+                                        code: day.code,
+                                        hours: day.hours,
+                                        status: 'APPROVED',
+                                        requestid: req.id,
+                                        used: false
+                                    }));
+                                    this.leaves.sort((a, b) => a.compareTo(b));
+                                }
+                                else {
+                                    lastcode = day.code;
+                                    workcenter = day.status;
+                                }
+                                const dos = Math.floor((day.leavedate.getTime() - start.getTime())
+                                    / (24 * 3600000));
+                                vari.schedule.workdays[dos].code = lastcode;
+                                vari.schedule.workdays[dos].hours = day.hours;
+                                vari.schedule.workdays[dos].workcenter = workcenter;
+                            });
+                        }
+                    });
+                    if (!found) {
+                        let max = 0;
+                        this.variations.forEach(vari => {
+                            if (max < vari.id) {
+                                max = vari.id;
+                            }
+                        });
+                        const vari = new variation_1.Variation({
+                            id: max + 1,
+                            mids: false,
+                            mod: true,
+                            startdate: new Date(req.startdate),
+                            enddate: new Date(req.enddate),
+                            site: this.site,
+                            schedule: new workday_1.Schedule()
+                        });
+                        vari.setScheduleDays();
+                        vari.schedule.showdates = true;
+                        req.requesteddays.forEach(day => {
+                            vari.updateWorkdayByDate;
+                        });
+                    }
+                }
+            }
+        });
+        return answer;
+    }
+    deleteLeaveRequest(id) {
+        let req = this.requests.find(r => r.id === id);
+        if (req) {
+            if (req.status.toLowerCase() === 'approved') {
+                let pos = this.leaves.findIndex(l => l.requestid === id);
+                while (pos >= 0) {
+                    this.leaves.splice(pos, 1);
+                    pos = this.leaves.findIndex(l => l.requestid === id);
+                }
+                if (req.primarycode.toLowerCase() === 'mod') {
+                    pos = this.variations.findIndex(v => (v.mod && v.startdate.getTime() === req.startdate.getTime()
+                        && v.enddate.getTime() === req.enddate.getTime()));
+                    if (pos >= 0) {
+                        this.variations.splice(pos, 1);
+                    }
+                }
+            }
+            let pos = this.requests.findIndex(r => r.id === id);
+            if (pos >= 0) {
+                this.requests.splice(pos, 1);
+            }
+        }
+    }
+    addContactInfo(typeid, value, sortid) {
+        let found = false;
+        let next = -1;
+        this.contactinfo.forEach((ci, c) => {
+            if (ci.id > next)
+                next = ci.id;
+            if (ci.typeid === typeid) {
+                found = true;
+                ci.value = value;
+                this.contactinfo[c] = ci;
+            }
+        });
+        if (!found) {
+            const contact = new contact_1.Contact({
+                id: next + 1,
+                typeid: typeid,
+                value: value,
+                sort: sortid
+            });
+            this.contactinfo.push(contact);
+            this.contactinfo.sort((a, b) => a.compareTo(b));
+        }
+    }
+    resortContactInfo(teamcontacts) {
+        this.contactinfo.forEach((ci, c) => {
+            const tc = teamcontacts.get(ci.typeid);
+            ci.sort = (tc) ? tc : 0;
+            this.contactinfo[c] = ci;
+        });
+        this.contactinfo.sort((a, b) => a.compareTo(b));
+    }
+    deleteContactInfoByType(type) {
+        let found = -1;
+        this.contactinfo.forEach((ci, c) => {
+            if (ci.typeid === type) {
+                found = c;
+            }
+        });
+        if (found >= 0) {
+            this.contactinfo.splice(found, 1);
+        }
+    }
+    deleteContactInfo(id) {
+        let found = -1;
+        this.contactinfo.forEach((ci, c) => {
+            if (ci.id === id) {
+                found = c;
+            }
+        });
+        if (found >= 0) {
+            this.contactinfo.splice(found, 1);
+        }
+    }
+    addSpecialty(specid, qualified, sort) {
+        let found = false;
+        let next = -1;
+        this.specialties.forEach((spc, s) => {
+            if (spc.id > next)
+                next = spc.id;
+            if (spc.specialtyid === specid) {
+                found = true;
+                spc.qualified = qualified;
+                this.specialties[s] = spc;
+            }
+        });
+        if (!found) {
+            const spc = new specialty_1.Specialty({
+                id: next + 1,
+                specialtyid: specid,
+                qualified: qualified,
+                sort: sort
+            });
+            this.specialties.push(spc);
+            this.specialties.sort((a, b) => a.compareTo(b));
+        }
+    }
+    resortSpecialties(teamspecs) {
+        this.specialties.forEach((spc, s) => {
+            const ts = teamspecs.get(spc.specialtyid);
+            spc.sort = (ts) ? ts : 0;
+            this.specialties[s] = spc;
+        });
+        this.specialties.sort((a, b) => a.compareTo(b));
+    }
+    deleteSpecialty(id) {
+        let found = -1;
+        this.specialties.forEach((spc, s) => {
+            if (spc.id === id) {
+                found = s;
+            }
+        });
+        if (found >= 0) {
+            this.specialties.splice(found, 1);
+        }
+        this.specialties.sort((a, b) => a.compareTo(b));
+    }
+    deleteSpecialtyByType(type) {
+        let found = -1;
+        this.specialties.forEach((spc, s) => {
+            if (spc.specialtyid === type) {
+                found = s;
+            }
+        });
+        if (found >= 0) {
+            this.specialties.splice(found, 1);
+        }
+        this.specialties.sort((a, b) => a.compareTo(b));
+    }
+    hasSpecialty(spec) {
+        let answer = false;
+        this.specialties.forEach(spc => {
+            if (spc.specialtyid === spec) {
+                answer = true;
+            }
+        });
+        return answer;
+    }
+}
+exports.Employee = Employee;
+//# sourceMappingURL=employee.js.map