scheduler-node-models 1.0.134 → 1.0.136

package/general/report.d.ts

@@ -1,11 +1,11 @@
-import { Style, Worksheet } from "exceljs";
+import { RichText, Style, Worksheet } from "exceljs";
 export declare class Formula {
     formula: string;
     constructor(formula: string);
 }
 export declare class Report {
     getCellID(col: string | number, row: number): string;
-    setCell(sheet: Worksheet, begin: string, end: string, style: Partial<Style>, value: string | number | Formula, numFmt?: string): void;
+    setCell(sheet: Worksheet, begin: string, end: string, style: Partial<Style>, value: string | number | Formula | RichText[], numFmt?: string): void;
     getDateString(date: Date): string;
     getTimeString(minutes: number): string;
     getNumberString(value: number, decimal: number): string;

package/general/report.js

@@ -48,9 +48,12 @@ class Report {
         if (value instanceof Formula) {
             sheet.getCell(begin).value = { formula: value.formula };
         }
-        else {
+        else if (typeof value === 'string' || typeof value === 'number') {
             sheet.getCell(begin).value = value;
         }
+        else {
+            sheet.getCell(begin).value = { 'richText': value };
+        }
     }
     getDateString(date) {
         const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scheduler-node-models",
-  "version": "1.0.134",
+  "version": "1.0.136",
   "main": "index.js",
   "types": "index.d.ts",
   "files": [

package/scheduler/reports/index.d.ts

@@ -2,3 +2,5 @@ export * from './cofsReports';
 export * from './enterpriseSchedule';
 export * from './scheduleReport';
 export * from './chargeStatus';
+export * from './leaveReport';
+export * from './leaves';

package/scheduler/reports/index.js

@@ -18,3 +18,5 @@ __exportStar(require("./cofsReports"), exports);
 __exportStar(require("./enterpriseSchedule"), exports);
 __exportStar(require("./scheduleReport"), exports);
 __exportStar(require("./chargeStatus"), exports);
+__exportStar(require("./leaveReport"), exports);
+__exportStar(require("./leaves"), exports);

package/scheduler/reports/leaveReport.d.ts

@@ -0,0 +1,50 @@
+import { Workbook, Worksheet } from "exceljs";
+import { Report } from "../../general";
+import { Employee, IEmployee } from "../employees";
+import { IHoliday } from "../teams/company";
+import { User } from "../../users";
+import { IWorkcode } from "../labor";
+export declare class LeaveReport extends Report {
+    private employees;
+    private holidays;
+    private fonts;
+    private fills;
+    private borders;
+    private alignments;
+    private numformats;
+    private workcodes;
+    constructor(holidays: IHoliday[], workcodes: IWorkcode[]);
+    /**
+     * This method is used to start the workbook creation and will call the other functional
+     * sheets to create the report.
+     * @param user The user object for the employee who is creating the report
+     * @param iEmps A list of employee objects to use in creating the report
+     * @param site A string value for the site identifier for the report
+     * @param reqDate A date object for the requested date
+     * @returns The workbook object with the report data.
+     */
+    create(user: User, iEmps: IEmployee[], site: string, reqDate: Date): Workbook;
+    /**
+     * This function will create the basic style information to be used within the sheet
+     * cells, which consists for font styles, cell fill styles, borders, and alignments for
+     * the text within the cell.  Plus a late addition of the various number formats to
+     * present.
+     */
+    createStyles(): void;
+    /**
+     * This function will create the PTO/Holiday Section
+     * @param workbook The report object in which a sheet is created into.
+     * @param year the integer value for the year of the report
+     */
+    createLeaveListing(workbook: Workbook, year: number, showHolidays: boolean): void;
+    /**
+     * This function will create the employee's Holidays and PTO report section
+     * @param sheet The worksheet object in which to add this employee's section
+     * @param emp The employee object used to determine the information about the section
+     * @param row The numeric value for the beginning of the section
+     * @param year The numeric value year the report is for.
+     * @param showHoliday A boolean value on whether to show the holidays for not.
+     * @returns the numeric value for the last row of this employee's section
+     */
+    employeePTOHolidaySection(sheet: Worksheet, emp: Employee, row: number, year: number, showHoliday: boolean): number;
+}

package/scheduler/reports/leaveReport.js

@@ -0,0 +1,667 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LeaveReport = void 0;
+const exceljs_1 = require("exceljs");
+const general_1 = require("../../general");
+const employees_1 = require("../employees");
+const company_1 = require("../teams/company");
+const leaves_1 = require("./leaves");
+const labor_1 = require("../labor");
+class LeaveReport extends general_1.Report {
+    employees;
+    holidays;
+    fonts;
+    fills;
+    borders;
+    alignments;
+    numformats;
+    workcodes;
+    constructor(holidays, workcodes) {
+        super();
+        this.employees = [];
+        this.holidays = [];
+        holidays.forEach(hol => {
+            this.holidays.push(new company_1.Holiday(hol));
+        });
+        this.holidays.sort((a, b) => a.compareTo(b));
+        this.fonts = new Map();
+        this.fills = new Map();
+        this.borders = new Map();
+        this.alignments = new Map();
+        this.numformats = new Map();
+        this.workcodes = new Map();
+        if (workcodes.length > 0) {
+            workcodes.forEach(wc => {
+                this.workcodes.set(wc.id, new labor_1.Workcode(wc));
+            });
+        }
+    }
+    /**
+     * This method is used to start the workbook creation and will call the other functional
+     * sheets to create the report.
+     * @param user The user object for the employee who is creating the report
+     * @param iEmps A list of employee objects to use in creating the report
+     * @param site A string value for the site identifier for the report
+     * @param reqDate A date object for the requested date
+     * @returns The workbook object with the report data.
+     */
+    create(user, iEmps, site, reqDate) {
+        const start = new Date(Date.UTC(reqDate.getUTCFullYear(), 0, 1));
+        const end = new Date(Date.UTC(reqDate.getUTCFullYear() + 1, 0, 1));
+        iEmps.forEach(iemp => {
+            const emp = new employees_1.Employee(iemp);
+            if (emp.atSite(site, start, end)) {
+                this.employees.push(emp);
+            }
+        });
+        this.employees.sort((a, b) => a.compareTo(b));
+        const workbook = new exceljs_1.Workbook();
+        workbook.creator = user.getFullName();
+        workbook.created = new Date();
+        this.createStyles();
+        return workbook;
+    }
+    /**
+     * This function will create the basic style information to be used within the sheet
+     * cells, which consists for font styles, cell fill styles, borders, and alignments for
+     * the text within the cell.  Plus a late addition of the various number formats to
+     * present.
+     */
+    createStyles() {
+        // set fonts
+        this.fonts.set("bold14", { bold: true, size: 14, color: { argb: 'ff000000' } });
+        this.fonts.set("bold12", { bold: true, size: 12, color: { argb: 'ff000000' } });
+        this.fonts.set("bold10", { bold: true, size: 10, color: { argb: 'ff000000' } });
+        this.fonts.set("nobold10", { bold: false, size: 10, color: { argb: 'ff000000' } });
+        this.fonts.set("bold8", { bold: true, size: 8, color: { argb: 'ff000000' } });
+        this.fonts.set("blue10", { bold: false, size: 10, color: { argb: 'ff00ffff' } });
+        this.fonts.set("noblue10", { bold: false, size: 10, color: { argb: 'ff3366ff' } });
+        this.fonts.set("blue8", { bold: true, size: 8, color: { argb: 'ff3366ff' } });
+        this.fonts.set("white14", { bold: true, size: 14, color: { argb: 'ffffffff' } });
+        this.fonts.set("white10", { bold: true, size: 10, color: { argb: 'ffffffff' } });
+        // set fills
+        this.fills.set('ptoname', { type: 'pattern', pattern: 'solid', fgColor: { argb: 'ff00ffff' } });
+        this.fills.set('asof', { type: 'pattern', pattern: 'solid', fgColor: { argb: 'ff800000' } });
+        this.fills.set('section', { type: 'pattern', pattern: 'solid', fgColor: { argb: 'ffcccccc' } });
+        this.fills.set('white', { type: 'pattern', pattern: 'solid', fgColor: { argb: 'ffffffff' } });
+        this.fills.set('dkgray', { type: 'pattern', pattern: 'solid', fgColor: { argb: 'ff999999' } });
+        this.fills.set('yellow', { type: 'pattern', pattern: 'solid', fgColor: { argb: 'ffffff00' } });
+        this.fills.set('month', { type: 'pattern', pattern: 'solid', fgColor: { argb: 'ff009933' } });
+        this.fills.set('ltblue', { type: 'pattern', pattern: 'solid', fgColor: { argb: 'ff66ffff' } });
+        this.fills.set('ltbrown', { type: 'pattern', pattern: 'solid', fgColor: { argb: 'fffcd5b4' } });
+        this.fills.set('gray', { type: 'pattern', pattern: 'solid', fgColor: { argb: 'ffc0c0c0' } });
+        this.fills.set('ltgray', { type: 'pattern', pattern: 'solid', fgColor: { argb: 'ffbfbfbf' } });
+        // set borders
+        this.borders.set('blackthin', {
+            top: { style: 'thin', color: { argb: 'ff000000' } },
+            left: { style: 'thin', color: { argb: 'ff000000' } },
+            bottom: { style: 'thin', color: { argb: 'ff000000' } },
+            right: { style: 'thin', color: { argb: 'ff000000' } }
+        });
+        this.borders.set('up', {
+            top: { style: 'thick', color: { argb: 'ff000000' } },
+            left: { style: 'thin', color: { argb: 'ff000000' } },
+            bottom: undefined,
+            right: { style: 'thin', color: { argb: 'ff000000' } }
+        });
+        this.borders.set('dn', {
+            top: undefined,
+            left: { style: 'thin', color: { argb: 'ff000000' } },
+            bottom: { style: 'thick', color: { argb: 'ff000000' } },
+            right: { style: 'thin', color: { argb: 'ff000000' } }
+        });
+        this.borders.set('bottom', {
+            top: undefined,
+            left: undefined,
+            bottom: { style: 'thin', color: { argb: 'ff000000' } },
+            right: undefined
+        });
+        // set alignments
+        this.alignments.set('center', { horizontal: 'center', vertical: 'middle', wrapText: true });
+        this.alignments.set('leftctr', { horizontal: 'left', vertical: 'middle', wrapText: true });
+        // set number formats
+        this.numformats.set('num', '0.0;mm/dd/yyy;@');
+        this.numformats.set('int', '0;@');
+        this.numformats.set('bal', '0.0;[Red]-0.0;@');
+    }
+    /**
+     * This function will create the PTO/Holiday Section
+     * @param workbook The report object in which a sheet is created into.
+     * @param year the integer value for the year of the report
+     */
+    createLeaveListing(workbook, year, showHolidays) {
+        const sheetLabel = `${year} PTO-Hol`;
+        const sheet = workbook.addWorksheet(sheetLabel, {
+            pageSetup: {
+                paperSize: undefined,
+                orientation: 'landscape',
+                fitToHeight: 1,
+                fitToWidth: 1,
+                blackAndWhite: false,
+                fitToPage: true,
+                showGridLines: false,
+                horizontalCentered: true,
+                verticalCentered: true
+            },
+            properties: {
+                defaultRowHeight: 20,
+                defaultColWidth: 4,
+                outlineLevelCol: 0
+            },
+            views: [{
+                    state: 'frozen',
+                    ySplit: 2
+                }]
+        });
+        let extendWidth = 3;
+        if (showHolidays) {
+            extendWidth += 4;
+        }
+        const formatter = new Intl.DateTimeFormat('en-US', {
+            month: '2-digit',
+            day: '2-digit',
+            year: 'numeric'
+        });
+        const now = new Date();
+        // add current as of reference
+        let style = {
+            fill: this.fills.get('asof'),
+            font: this.fonts.get("bold12"),
+            alignment: this.alignments.get("center"),
+            border: this.borders.get("blackthin")
+        };
+        this.setCell(sheet, this.getCellID(0, 1), this.getCellID(extendWidth, 1), style, formatter.format(now));
+        // set column widths
+        if (showHolidays) {
+            sheet.getColumn(1).width = 4.5;
+            sheet.getColumn(2).width = 13;
+            sheet.getColumn(3).width = 30;
+            sheet.getColumn(4).width = 7;
+            sheet.getColumn(5).width = 30;
+            sheet.getColumn(6).width = 7;
+            sheet.getColumn(7).width = 7;
+            sheet.getColumn(8).width = 7;
+            sheet.getColumn(9).width = 7;
+        }
+        else {
+            sheet.getColumn(1).width = 30;
+            sheet.getColumn(2).width = 7;
+            sheet.getColumn(3).width = 7;
+            sheet.getColumn(4).width = 7;
+            sheet.getColumn(5).width = 7;
+        }
+        let row = 2;
+        this.employees.forEach(emp => {
+            row = this.employeePTOHolidaySection(sheet, emp, row, year, showHolidays) + 1;
+        });
+    }
+    /**
+     * This function will create the employee's Holidays and PTO report section
+     * @param sheet The worksheet object in which to add this employee's section
+     * @param emp The employee object used to determine the information about the section
+     * @param row The numeric value for the beginning of the section
+     * @param year The numeric value year the report is for.
+     * @param showHoliday A boolean value on whether to show the holidays for not.
+     * @returns the numeric value for the last row of this employee's section
+     */
+    employeePTOHolidaySection(sheet, emp, row, year, showHoliday) {
+        let annual = 0.0;
+        let carry = 0.0;
+        emp.balance.forEach(bal => {
+            if (bal.year === year) {
+                annual = bal.annual;
+                carry = bal.carryover;
+            }
+        });
+        let extendedWidth = 5;
+        if (showHoliday) {
+            extendedWidth += 4;
+        }
+        const tdate = new Date(Date.UTC(year, 5, 1));
+        const std = emp.getStandardWorkday(tdate);
+        let style = {
+            fill: this.fills.get("ptoname"),
+            font: this.fonts.get("bold12"),
+            alignment: this.alignments.get("center"),
+            border: this.borders.get("blackthin")
+        };
+        this.setCell(sheet, this.getCellID(0, row), this.getCellID(extendedWidth - 1, row), style, emp.name.getLastFirst());
+        row++;
+        let col = 0;
+        style = {
+            fill: this.fills.get('section'),
+            font: this.fonts.get('bold10'),
+            alignment: this.alignments.get('center'),
+            border: this.borders.get('blackthin')
+        };
+        if (showHoliday) {
+            this.setCell(sheet, this.getCellID(0, row), this.getCellID(3, row), style, 'Holidays');
+            col = 4;
+        }
+        this.setCell(sheet, this.getCellID(col, row), this.getCellID(col + 4, row), style, 'Leaves');
+        // create holidays and leave months
+        const months = [];
+        for (let i = 0; i < 12; i++) {
+            const dtMonth = new Date(Date.UTC(year, i, 1));
+            months.push(new leaves_1.LeaveMonth(dtMonth, false));
+        }
+        months.sort((a, b) => a.compareTo(b));
+        const holidays = [];
+        this.holidays.forEach(hol => {
+            const dt = hol.getActual(year);
+            if (dt) {
+                holidays.push(new leaves_1.LeaveMonth(dt, false, hol));
+            }
+            else {
+                holidays.push(new leaves_1.LeaveMonth(new Date(0), false, hol));
+            }
+        });
+        holidays.sort((a, b) => a.compareTo(b));
+        // add labels to the sections
+        row++;
+        col = 0;
+        style = {
+            fill: this.fills.get('section'),
+            font: this.fonts.get('bold8'),
+            alignment: this.alignments.get('center'),
+            border: this.borders.get('blackthin')
+        };
+        if (showHoliday) {
+            this.setCell(sheet, this.getCellID(0, row), this.getCellID(0, row), style, '');
+            this.setCell(sheet, this.getCellID(1, row), this.getCellID(1, row), style, 'Reference Date');
+            this.setCell(sheet, this.getCellID(2, row), this.getCellID(2, row), style, 'Hours');
+            const rcell = sheet.getCell(this.getCellID(3, row));
+            rcell.style = {
+                fill: this.fills.get('section'),
+                font: this.fonts.get('bold8'),
+                alignment: this.alignments.get('center'),
+                border: this.borders.get('blackthin')
+            };
+            rcell.value = { 'richText': [
+                    { 'font': { 'size': 8, 'bold': true, 'color': { 'argb': 'ff000000' } }, 'text': 'Date Taken (' },
+                    { 'font': { 'size': 8, 'bold': true, 'color': { 'argb': 'ff3366ff' } }, 'text': 'Projected' },
+                    { 'font': { 'size': 8, 'bold': true, 'color': { 'argb': 'ff000000' } }, 'text': ')' }
+                ] };
+            col = 4;
+        }
+        sheet.mergeCells(this.getCellID(col, row), this.getCellID(col + 1, row));
+        let cell = sheet.getCell(this.getCellID(col, row));
+        cell.style = {
+            fill: this.fills.get('section'),
+            font: this.fonts.get('bold8'),
+            alignment: this.alignments.get('center'),
+            border: this.borders.get('blackthin')
+        };
+        cell.value = { 'richText': [
+                { 'font': { 'size': 8, 'bold': true, 'color': { 'argb': 'ff000000' } }, 'text': 'Leave Taken (' },
+                { 'font': { 'size': 8, 'bold': true, 'color': { 'argb': 'ff3366ff' } }, 'text': 'Projected' },
+                { 'font': { 'size': 8, 'bold': true, 'color': { 'argb': 'ff000000' } }, 'text': ')' }
+            ] };
+        style = {
+            fill: this.fills.get('section'),
+            font: this.fonts.get('bold8'),
+            alignment: this.alignments.get('center'),
+            border: this.borders.get('blackthin')
+        };
+        this.setCell(sheet, this.getCellID(col + 2, row), this.getCellID(col + 2, row), style, "Taken");
+        style.font = this.fonts.get('bblue8');
+        this.setCell(sheet, this.getCellID(col + 3, row), this.getCellID(col + 3, row), style, "Request");
+        row++;
+        const startAsgmt = emp.assignments[0];
+        const endAsgmt = emp.assignments[emp.assignments.length - 1];
+        // ensure months are clear, plus check if the month should be disabled.
+        months.forEach((month, m) => {
+            const startMonth = new Date(Date.UTC(month.month.getUTCFullYear(), month.month.getUTCMonth() + 1, 1));
+            month.periods = [];
+            month.disabled = (startAsgmt.startDate.getTime() > startMonth.getTime()
+                || endAsgmt.endDate.getTime() < month.month.getTime());
+            months[m] = month;
+        });
+        // ensure the holidays are clear, plus check if the holiday should be disabled.
+        // Only holidays with id of "H" can be disabled, floating holidays aren't.
+        holidays.forEach((hol, h) => {
+            hol.periods = [];
+            if (hol.holiday && hol.holiday.id.toLowerCase().substring(0, 1) === 'h') {
+                hol.disabled = (startAsgmt.startDate.getTime() > hol.month.getTime()
+                    || endAsgmt.endDate.getTime() < hol.month.getTime());
+            }
+            holidays[h] = hol;
+        });
+        // sort the employee's leaves, then put the ones for the selected year into arrays
+        // for further use.
+        emp.leaves.sort((a, b) => a.compareTo(b));
+        const empHolidays = [];
+        const empOtherLeaves = [];
+        emp.leaves.forEach(lv => {
+            if (lv.leavedate.getUTCFullYear() === year) {
+                if (lv.code.toLowerCase() === 'h') {
+                    empHolidays.push(new employees_1.Leave(lv));
+                }
+                else {
+                    empOtherLeaves.push(new employees_1.Leave(lv));
+                }
+            }
+        });
+        // next process the employee's holidays into the holidays array
+        // 1.  Go through the leaves and place the tagged holidays into the holiday list
+        empHolidays.forEach((empHol, eh) => {
+            if (empHol.tagday && empHol.tagday !== '') {
+                const code = empHol.tagday.substring(0, 1);
+                const num = Number(empHol.tagday.substring(1));
+                holidays.forEach((hol, h) => {
+                    if (hol.holiday && hol.holiday.id.toLowerCase() === code
+                        && hol.holiday.sort === num) {
+                        hol.periods.push(new leaves_1.LeavePeriod(empHol.code, new Date(empHol.leavedate), empHol.status, new employees_1.Leave(empHol)));
+                        empHol.used = true;
+                        holidays[h] = hol;
+                        empHolidays[eh] = empHol;
+                    }
+                });
+            }
+        });
+        // 2. For those not tagged, actuals are listed first.
+        empHolidays.forEach((empHol, eh) => {
+            if (!empHol.used && empHol.status.toLowerCase() === 'actual') {
+                holidays.forEach((hol, h) => {
+                    if (hol.holiday && hol.holiday.id.toLowerCase() === 'h'
+                        && !hol.disabled && hol.getHours() + empHol.hours <= 8.0) {
+                        hol.periods.push(new leaves_1.LeavePeriod(empHol.code, empHol.leavedate, empHol.status, new employees_1.Leave(empHol)));
+                        empHol.used = true;
+                        holidays[h] = hol;
+                        empHolidays[eh] = empHol;
+                    }
+                });
+            }
+        });
+        // 3. Next check for those holidays that match the actual date
+        empHolidays.forEach((empHol, eh) => {
+            if (!empHol.used) {
+                holidays.forEach((hol, h) => {
+                    if (hol.holiday && hol.holiday.id.toLowerCase() === 'h'
+                        && hol.month.getTime() === empHol.leavedate.getTime()
+                        && !hol.disabled && hol.getHours() + empHol.hours <= 8.0) {
+                        hol.periods.push(new leaves_1.LeavePeriod(empHol.code, empHol.leavedate, empHol.status, new employees_1.Leave(empHol)));
+                        empHol.used = true;
+                        holidays[h] = hol;
+                        empHolidays[eh] = empHol;
+                    }
+                });
+            }
+        });
+        // 4. next, with any holidays not already used
+        empHolidays.forEach((empHol, eh) => {
+            if (!empHol.used) {
+                let found = false;
+                holidays.forEach((hol, h) => {
+                    if (!found && !hol.disabled) {
+                        if (hol.getHours() + empHol.hours <= 8.0) {
+                            hol.periods.push(new leaves_1.LeavePeriod(empHol.code, empHol.leavedate, empHol.status, new employees_1.Leave(empHol)));
+                            holidays[h] = hol;
+                            found = true;
+                            empHol.used = true;
+                        }
+                    }
+                });
+            }
+        });
+        // 5.  if there are any unused holidays, plug them into disabled holidays.
+        empHolidays.forEach((empHol, eh) => {
+            if (!empHol.used) {
+                let found = false;
+                holidays.forEach((hol, h) => {
+                    if (!found && hol.disabled) {
+                        found = true;
+                        hol.periods.push(new leaves_1.LeavePeriod(empHol.code, empHol.leavedate, empHol.status, new employees_1.Leave(empHol)));
+                    }
+                });
+            }
+        });
+        // next, place the non-holiday leaves into the months they are using in.
+        empOtherLeaves.forEach(lv => {
+            months.forEach((month, m) => {
+                if (month.month.getUTCFullYear() === lv.leavedate.getUTCFullYear()
+                    && month.month.getUTCMonth() === lv.leavedate.getUTCMonth()) {
+                    let found = false;
+                    month.periods.forEach((prd, p) => {
+                        if (!found && prd.addLeave(lv)) {
+                            found = true;
+                            month.periods[p] = prd;
+                        }
+                    });
+                    if (!found) {
+                        month.periods.push(new leaves_1.LeavePeriod(lv.code, lv.leavedate, lv.status, new employees_1.Leave(lv)));
+                    }
+                    months[m] = month;
+                }
+            });
+        });
+        // now insert the holidays for companies that have holidays designated.
+        const now = new Date();
+        col = 0;
+        if (showHoliday) {
+            holidays.sort((a, b) => a.compareTo(b));
+            holidays.forEach((hol, h) => {
+                hol.periods.sort((a, b) => a.compareTo(b));
+                const holRow = row + h;
+                style = {
+                    fill: this.fills.get('white'),
+                    font: this.fonts.get('bold10'),
+                    alignment: this.alignments.get('center'),
+                    border: this.borders.get('blackthin'),
+                    numFmt: this.numformats.get('num')
+                };
+                if (hol.disabled) {
+                    style.fill = this.fills.get('dkgray');
+                    style.font = this.fonts.get('nobold10');
+                }
+                else if (hol.holiday && hol.holiday.getActual(year)
+                    && hol.holiday.getActual(year).getTime() > now.getTime()) {
+                    style.fill = this.fills.get('white');
+                    style.font = this.fonts.get('nobold10');
+                }
+                this.setCell(sheet, this.getCellID(col, holRow), this.getCellID(col, holRow), style, hol.holiday.toString());
+                if (hol.holiday.getActual(year)) {
+                    const formatter = new Intl.DateTimeFormat('en-US', {
+                        month: 'short',
+                        day: '2-digit',
+                        year: '2-digit'
+                    });
+                    this.setCell(sheet, this.getCellID(col + 1, holRow), this.getCellID(col + 1, holRow), style, formatter.format(hol.holiday.getActual(year)));
+                }
+                else {
+                    this.setCell(sheet, this.getCellID(col + 1, holRow), this.getCellID(col + 1, holRow), style, '');
+                }
+                const cellText = [];
+                hol.periods.forEach((prd, p) => {
+                    prd.leaves.forEach((lv, l) => {
+                        if (p > 0 || l > 0) {
+                            cellText.push({ 'font': { 'size': 10, 'bold': true,
+                                    'color': { 'argb': 'ff000000' } }, 'text': ',' });
+                        }
+                        const formatter = new Intl.DateTimeFormat('en-US', {
+                            day: '2-digit',
+                            month: 'short'
+                        });
+                        if (lv.status.toLowerCase() === 'actual') {
+                            cellText.push({ 'font': { 'size': 10, 'bold': true,
+                                    'color': { 'argb': 'ff000000' } }, 'text': formatter.format(lv.leavedate) });
+                            if (lv.hours < 8) {
+                                cellText.push({ 'font': { 'size': 7, 'bold': true, 'vertAlign': 'superscript',
+                                        'color': { 'argb': 'ff000000' } }, 'text': `(${lv.hours.toFixed(1)})` });
+                            }
+                        }
+                        else {
+                            cellText.push({ 'font': { 'size': 10, 'bold': true,
+                                    'color': { 'argb': 'ff3366ff' } }, 'text': formatter.format(lv.leavedate) });
+                            if (lv.hours < 8) {
+                                cellText.push({ 'font': { 'size': 7, 'bold': true, 'vertAlign': 'superscript',
+                                        'color': { 'argb': 'ff3366ff' } }, 'text': `(${lv.hours.toFixed(1)})` });
+                            }
+                        }
+                    });
+                });
+                this.setCell(sheet, this.getCellID(col + 3, holRow), this.getCellID(col + 3, holRow), {
+                    fill: this.fills.get('white'),
+                    alignment: this.alignments.get('center'),
+                    border: this.borders.get('blackthin')
+                }, cellText);
+                this.setCell(sheet, this.getCellID(col + 3, holRow), this.getCellID(col + 3, holRow), style, hol.getHours());
+            });
+            col = 4;
+        }
+        months.sort((a, b) => a.compareTo(b));
+        months.forEach((month, m) => {
+            const lvRow = row + m;
+            style = {
+                fill: this.fills.get('white'),
+                font: this.fonts.get('nobold10'),
+                alignment: this.alignments.get('leftctr'),
+                border: this.borders.get('blackthin'),
+                numFmt: this.numformats.get('num')
+            };
+            if (month.disabled) {
+                style = {
+                    fill: this.fills.get('dkgray'),
+                    font: this.fonts.get('nobold10'),
+                    alignment: this.alignments.get('leftctr'),
+                    border: this.borders.get('blackthin')
+                };
+            }
+            const cellText = [];
+            const formatter = new Intl.DateTimeFormat('en-US', {
+                month: 'short'
+            });
+            cellText.push({ 'font': { 'size': 10, 'bold': true,
+                    'color': { 'argb': 'ffff0000' } }, 'text': `${formatter.format(month.month)}: ` });
+            month.periods.forEach((prd, p) => {
+                if (p > 0) {
+                    cellText.push({ 'font': { 'size': 10, 'bold': true,
+                            'color': { 'argb': 'ff000000' } }, 'text': ',' });
+                }
+                let text = '';
+                let bHours = false;
+                if (prd.start.getTime() === prd.end.getTime()) {
+                    text = `${prd.start.getDate()}-${prd.end.getDate()}`;
+                }
+                else {
+                    text = `${prd.start.getDate()}`;
+                    if (prd.getHours() < std) {
+                        bHours = true;
+                    }
+                }
+                let color = 'ff';
+                if (prd.code.toLowerCase() === 'v' && prd.status.toLowerCase() === 'actual') {
+                    color += '000000';
+                }
+                else {
+                    const wc = this.workcodes.get(prd.code);
+                    if (wc) {
+                        color += wc.backcolor;
+                    }
+                    else {
+                        color += '000000';
+                    }
+                }
+                cellText.push({ 'font': { 'size': 10, 'bold': true, 'color': { 'argb': color } },
+                    'text': text });
+                if (bHours) {
+                    cellText.push({ 'font': { 'size': 7, 'bold': true, 'vertAlign': 'superscript',
+                            'color': { 'argb': color } }, 'text': `(${prd.getHours().toFixed(1)})` });
+                }
+            });
+            this.setCell(sheet, this.getCellID(col, lvRow), this.getCellID(col + 1, lvRow), style, cellText);
+            style = {
+                fill: this.fills.get('white'),
+                font: this.fonts.get('nobold10'),
+                alignment: this.alignments.get('center'),
+                border: this.borders.get('blackthin'),
+                numFmt: this.numformats.get('num')
+            };
+            if (month.disabled) {
+                style.fill = this.fills.get('dkgray');
+            }
+            this.setCell(sheet, this.getCellID(col + 2, lvRow), this.getCellID(col + 2, lvRow), style, month.getHours('v', true));
+            style.font = this.fonts.get('noblue10');
+            this.setCell(sheet, this.getCellID(col + 3, lvRow), this.getCellID(col + 3, lvRow), style, month.getHours('v', false));
+        });
+        // now add the totals section to the employee's chart
+        if (months.length > holidays.length) {
+            row += months.length;
+        }
+        else {
+            row += holidays.length;
+        }
+        style = {
+            fill: this.fills.get('section'),
+            font: this.fonts.get('bold8'),
+            alignment: this.alignments.get('center'),
+            border: this.borders.get('blackthin')
+        };
+        col = 0;
+        if (showHoliday) {
+            this.setCell(sheet, this.getCellID(col, row), this.getCellID(col, row), style, '');
+            this.setCell(sheet, this.getCellID(col + 1, row), this.getCellID(col + 1, row), style, 'Days Left');
+            this.setCell(sheet, this.getCellID(col + 2, row), this.getCellID(col + 2, row), style, 'Hours Left');
+            this.setCell(sheet, this.getCellID(col + 3, row), this.getCellID(col + 3, row), style, 'Total Hours');
+            let daysLeft = 0;
+            let hoursTaken = 0;
+            holidays.forEach(hol => {
+                if (hol.getHours() < 8 && !hol.disabled) {
+                    daysLeft++;
+                }
+                if (hol.getHours() > 0) {
+                    hoursTaken += hol.getHours();
+                }
+            });
+            const hoursLeft = (holidays.length * 8.0) - hoursTaken;
+            style = {
+                fill: this.fills.get('white'),
+                font: this.fonts.get('bold10'),
+                alignment: this.alignments.get('center'),
+                border: this.borders.get('blackthin'),
+                numFmt: this.numformats.get('int')
+            };
+            this.setCell(sheet, this.getCellID(col, row + 1), this.getCellID(col, row + 1), style, '');
+            this.setCell(sheet, this.getCellID(col + 1, row + 1), this.getCellID(col + 1, row + 1), style, daysLeft);
+            this.setCell(sheet, this.getCellID(col + 2, row + 1), this.getCellID(col + 2, row + 1), style, hoursLeft);
+            this.setCell(sheet, this.getCellID(col + 3, row + 1), this.getCellID(col + 3, row + 1), style, hoursTaken);
+            col = 4;
+        }
+        style = {
+            fill: this.fills.get('section'),
+            font: this.fonts.get('bold8'),
+            alignment: this.alignments.get('center'),
+            border: this.borders.get('blackthin')
+        };
+        this.setCell(sheet, this.getCellID(col, row), this.getCellID(col, row), style, 'Annual Leave');
+        this.setCell(sheet, this.getCellID(col + 1, row), this.getCellID(col + 1, row), style, 'Carry');
+        this.setCell(sheet, this.getCellID(col + 2, row), this.getCellID(col + 2, row), style, 'Total Taken');
+        this.setCell(sheet, this.getCellID(col + 3, row), this.getCellID(col + 3, row), style, 'Request');
+        this.setCell(sheet, this.getCellID(col + 4, row), this.getCellID(col + 4, row), style, 'Balance');
+        let totalTaken = 0;
+        let totalRequested = 0;
+        months.forEach(month => {
+            totalRequested += month.getHours('v', false);
+            totalTaken += month.getHours('v', true);
+        });
+        const balance = (annual + carry) - (totalTaken + totalRequested);
+        style = {
+            fill: this.fills.get('white'),
+            font: this.fonts.get('bold10'),
+            alignment: this.alignments.get('center'),
+            border: this.borders.get('blackthin'),
+            numFmt: this.numformats.get('num')
+        };
+        this.setCell(sheet, this.getCellID(col, row + 1), this.getCellID(col, row + 1), style, annual);
+        this.setCell(sheet, this.getCellID(col + 1, row + 1), this.getCellID(col + 1, row + 1), style, carry);
+        this.setCell(sheet, this.getCellID(col + 2, row + 1), this.getCellID(col + 2, row + 1), style, totalTaken);
+        style.font = this.fonts.get('noblue10');
+        this.setCell(sheet, this.getCellID(col + 3, row + 1), this.getCellID(col + 3, row + 1), style, totalRequested);
+        style.fill = this.fills.get('yellow');
+        style.font = this.fonts.get('nobold10');
+        style.numFmt = this.numformats.get('bal');
+        this.setCell(sheet, this.getCellID(col + 4, row + 1), this.getCellID(col + 4, row + 1), style, balance);
+        return row + 2;
+    }
+}
+exports.LeaveReport = LeaveReport;

package/scheduler/reports/leaves.d.ts

@@ -0,0 +1,22 @@
+import { Leave } from "../employees";
+import { Holiday } from "../teams/company";
+export declare class LeavePeriod {
+    code: string;
+    start: Date;
+    end: Date;
+    status: string;
+    leaves: Leave[];
+    constructor(code: string, start: Date, status: string, leave?: Leave);
+    compareTo(other?: LeavePeriod): number;
+    getHours(type?: string, actual?: boolean): number;
+    addLeave(leave: Leave): boolean;
+}
+export declare class LeaveMonth {
+    month: Date;
+    holiday?: Holiday;
+    disabled: boolean;
+    periods: LeavePeriod[];
+    constructor(start: Date, disabled: boolean, holiday?: Holiday);
+    compareTo(other?: LeaveMonth): number;
+    getHours(type?: string, actuals?: boolean): number;
+}

package/scheduler/reports/leaves.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LeaveMonth = exports.LeavePeriod = void 0;
+const employees_1 = require("../employees");
+const company_1 = require("../teams/company");
+class LeavePeriod {
+    code;
+    start;
+    end;
+    status;
+    leaves;
+    constructor(code, start, status, leave) {
+        this.code = code;
+        this.start = new Date(start);
+        this.end = new Date(start);
+        this.status = status;
+        this.leaves = [];
+        if (leave) {
+            this.leaves.push(new employees_1.Leave(leave));
+        }
+    }
+    compareTo(other) {
+        if (other) {
+            return (this.start.getTime() < other.start.getTime()) ? -1 : 1;
+        }
+        return -1;
+    }
+    getHours(type, actual) {
+        let hours = 0.0;
+        if (type && type.toLowerCase() === 'v') {
+            this.leaves.forEach(lv => {
+                if (lv.code.toLowerCase() === 'v') {
+                    if (actual && lv.status.toLowerCase() === 'actual') {
+                        hours += lv.hours;
+                    }
+                    else if (!actual && lv.status.toLowerCase() !== 'actual') {
+                        hours += lv.hours;
+                    }
+                }
+            });
+        }
+        else {
+            this.leaves.forEach(lv => {
+                hours += lv.hours;
+            });
+        }
+        return hours;
+    }
+    addLeave(leave) {
+        // the leave's hours and code must equal the previous one, unless this is the 
+        // first leave
+        try {
+            if (this.leaves.length === 0) {
+                this.leaves.push(new employees_1.Leave(leave));
+                return true;
+            }
+            else {
+                let add = true;
+                this.leaves.forEach(lv => {
+                    if (leave.hours === lv.hours
+                        && leave.code.toLowerCase() !== lv.code.toLowerCase()
+                        && leave.status.toLowerCase() !== lv.code.toLowerCase()
+                        && leave.leavedate.getUTCDate() !== (this.end.getUTCDate() + 1)) {
+                        add = false;
+                    }
+                });
+                if (add) {
+                    this.leaves.push(new employees_1.Leave(leave));
+                    this.end = new Date(leave.leavedate);
+                }
+                return add;
+            }
+        }
+        catch (error) {
+            return false;
+        }
+    }
+}
+exports.LeavePeriod = LeavePeriod;
+class LeaveMonth {
+    month;
+    holiday;
+    disabled;
+    periods;
+    constructor(start, disabled, holiday) {
+        this.month = new Date(start);
+        this.disabled = disabled;
+        this.periods = [];
+        this.holiday = undefined;
+        if (holiday) {
+            this.holiday = new company_1.Holiday(holiday);
+        }
+    }
+    compareTo(other) {
+        if (other) {
+            if (this.holiday && other.holiday) {
+                if (this.holiday.id.toLowerCase() === other.holiday.id.toLowerCase()) {
+                    return (this.holiday.sort < other.holiday.sort) ? -1 : 1;
+                }
+                return (this.holiday.id.toLowerCase() === 'h') ? -1 : 1;
+            }
+            else {
+                return (this.month.getTime() < other.month.getTime()) ? -1 : 1;
+            }
+        }
+        return -1;
+    }
+    getHours(type, actuals) {
+        let hours = 0.0;
+        this.periods.forEach(prd => {
+            hours += prd.getHours(type, actuals);
+        });
+        return hours;
+    }
+}
+exports.LeaveMonth = LeaveMonth;

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

@@ -23,6 +23,12 @@ export declare class Holiday implements IHoliday {
     sort: number;
     actualdates: Date[];
     constructor(hol?: IHoliday);
+    /**
+     * This function will provide string for the combined id and sort code into a single
+     * string value.
+     * @returns A string value for the id and sort code.
+     */
+    toString(): string;
     /**
      * This function is used in sorting holidays by comparing their ids and sort values
      * @param other The holiday object used in comparison

package/scheduler/teams/company/holiday.js

@@ -27,6 +27,14 @@ class Holiday {
             this.actualdates.sort((a, b) => (a.getTime() < b.getTime()) ? -1 : 1);
         }
     }
+    /**
+     * This function will provide string for the combined id and sort code into a single
+     * string value.
+     * @returns A string value for the id and sort code.
+     */
+    toString() {
+        return `${this.id}${this.sort}`.toUpperCase();
+    }
     /**
      * This function is used in sorting holidays by comparing their ids and sort values
      * @param other The holiday object used in comparison