scheduler-node-models 1.0.81 → 1.0.83

package/scheduler/sites/reports/cofsReport.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CofSReport = void 0;
+const section_1 = require("./section");
+/**
+ * This class implements the interface data members plus actions.
+ */
+class CofSReport {
+    id;
+    name;
+    shortname;
+    unit;
+    startdate;
+    enddate;
+    sections;
+    constructor(rpt) {
+        this.id = (rpt) ? rpt.id : 0;
+        this.name = (rpt) ? rpt.name : '';
+        this.shortname = (rpt) ? rpt.shortname : '';
+        this.unit = (rpt) ? rpt.unit : '';
+        this.startdate = (rpt) ? new Date(rpt.startdate) : new Date(0);
+        this.enddate = (rpt) ? new Date(rpt.enddate) : new Date(0);
+        this.sections = [];
+        if (rpt && rpt.sections && rpt.sections.length) {
+            rpt.sections.forEach(sec => {
+                this.sections.push(new section_1.Section(sec));
+            });
+            this.sections.sort((a, b) => a.compareTo(b));
+        }
+    }
+    compareTo(other) {
+        if (other) {
+            if (this.startdate.getTime() === other.startdate.getTime()) {
+                return (this.name < other.name) ? -1 : 1;
+            }
+            return (this.startdate.getTime() < other.startdate.getTime()) ? -1 : 1;
+        }
+        return -1;
+    }
+    use(start, end) {
+        return (this.startdate.getTime() <= end.getTime()
+            && this.enddate.getTime() >= start.getTime());
+    }
+    /**
+     * This function will create an XML file from a CofS Report description.
+     * @param start The date object used for the start of the report period.
+     * @param end The date object used to signify the end of the period, but not included
+     * in the report (1st day of next month).
+     * @param workcodes The list of work codes used to signify shift or leave.
+     * @param employees The list of possible employees used in this report.  Usually a list
+     * of the site's employees.
+     * @returns A File object for the XML data.
+     */
+    create(start, end, workcodes, employees) {
+        const options = { type: 'text/xml' };
+        const now = new Date();
+        const filename = `${this.shortname}-${now.getFullYear()}`
+            + `${(now.getMonth() + 1).toString().padStart(2, '0')}`
+            + `${now.getDate().toString().padStart(2, '0')}`;
+        let content = '';
+        const remarks = [];
+        // Create the xml formated output and attach to content string.
+        // 1. start with the standard header for xml plus entries for month and year, 
+        //  and unit.
+        const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct',
+            'Nov', 'Dec'];
+        content += '<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>\n'
+            + '<fields xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">\n'
+            + `\t<Month-Year>${months[start.getMonth()]}-${start.getFullYear()}`
+            + '</Month-Year>\n'
+            + `\t<Month-Year1>${months[start.getMonth()]}-${start.getFullYear()}`
+            + '</Month-Year1>\n'
+            + `\t<Unit>${this.unit}</Unit>\n`
+            + `\t<Unit1>${this.unit}</Unit1>\n`;
+        // next add in the report sections, which produce a table.
+        this.sections.forEach((section, sid) => {
+            const result = section.createReportSection(start, end, workcodes, employees, sid + 1, this.unit);
+            if (result.output !== '') {
+                const lines = result.output.split('\n');
+                lines.forEach(line => {
+                    content += `\t${line}\n`;
+                });
+            }
+            if (result.remarks.length > 0) {
+                result.remarks.forEach(rmk => {
+                    remarks.push(rmk);
+                });
+            }
+        });
+        // lastly, add in the remarks section as a series of strings
+        if (remarks.length > 0) {
+            content += `\t<REMARKS>\n`;
+            remarks.forEach(rmk => {
+                content += `${rmk}\n`;
+            });
+            content += `\t</REMARKS>\n`;
+        }
+        // close the xml tag and finish.
+        content += '</fields>\n';
+        const xmlFile = new File([content], filename, options);
+        return xmlFile;
+    }
+}
+exports.CofSReport = CofSReport;

package/scheduler/sites/reports/forecast.d.ts

@@ -0,0 +1,57 @@
+import { ILaborCode, LaborCode } from "../../labor";
+import { IPeriod, Period } from "./period";
+export interface IForecast {
+    id: number;
+    name: string;
+    startDate: Date;
+    endDate: Date;
+    periods?: IPeriod[];
+    laborCodes?: ILaborCode[];
+    companyid?: string;
+    sortfirst?: boolean;
+}
+export declare class Forecast implements IForecast {
+    id: number;
+    name: string;
+    startDate: Date;
+    endDate: Date;
+    periods: Period[];
+    laborCodes: LaborCode[];
+    companyid: string;
+    sortfirst: boolean;
+    constructor(fore?: IForecast);
+    compareTo(other?: Forecast): number;
+    /**
+     * This function is used to change the standard work period dates based on the day of
+     * the week the period ends.  This function will ensure that the reports period all end
+     * on the day of the week provided.
+     * @param weekday The numeric value for the weekday the periods are to end at.
+     */
+    changePeriodsStart(weekday: number): void;
+    /**
+     * This function is used to remove forecast periods that have no subperiods.
+     */
+    removeUnusedPeriods(): void;
+    /**
+     * This function will move a single sub-period from one month to another adjacent
+     * month.
+     * @param from The date object representing the month period for the giving subperiod.
+     * @param to The date object representing the month period for the receiving subperiod.
+     */
+    movePeriodBetweenMonths(from: Date, to: Date): void;
+    /**
+     * This function adds a sub period to the list of periods where it fits best or add a
+     * new period for the subperiod.
+     * @param dt The date object for the sub period to add
+     */
+    addOutofCycleSubPeriod(dt: Date): void;
+    /**
+     * This function is used to determine if a forecast report is to be used for a report
+     * date requested.
+     * @param date The date object used for the testing.
+     * @param company The string value for company identifier for the testing.
+     * @returns A boolean value to indicate if the date is between the start and end dates
+     * of this forecast report and is for the company indicated.
+     */
+    use(date: Date, company: string): boolean;
+}

package/scheduler/sites/reports/forecast.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Forecast = void 0;
+const labor_1 = require("../../labor");
+const period_1 = require("./period");
+class Forecast {
+    id;
+    name;
+    startDate;
+    endDate;
+    periods;
+    laborCodes;
+    companyid;
+    sortfirst;
+    constructor(fore) {
+        this.id = (fore) ? fore.id : 0;
+        this.name = (fore) ? fore.name : '';
+        this.startDate = (fore) ? new Date(fore.startDate) : new Date(0);
+        this.endDate = (fore) ? new Date(fore.endDate) : new Date(0);
+        this.periods = [];
+        if (fore && fore.periods && fore.periods.length > 0) {
+            fore.periods.forEach(per => {
+                this.periods.push(new period_1.Period(per));
+            });
+            this.periods.sort((a, b) => a.compareTo(b));
+        }
+        this.laborCodes = [];
+        if (fore && fore.laborCodes && fore.laborCodes.length > 0) {
+            fore.laborCodes.forEach(lc => {
+                this.laborCodes.push(new labor_1.LaborCode(lc));
+            });
+            this.laborCodes.sort((a, b) => a.compareTo(b));
+        }
+        this.companyid = (fore && fore.companyid) ? fore.companyid : '';
+        this.sortfirst = (fore && fore.sortfirst) ? fore.sortfirst : false;
+    }
+    compareTo(other) {
+        if (other) {
+            if (this.startDate.getTime() === other.startDate.getTime()) {
+                if (this.endDate.getTime() === other.endDate.getTime()) {
+                    return (this.name < other.name) ? -1 : 1;
+                }
+                return (this.endDate.getTime() < other.endDate.getTime()) ? -1 : 1;
+            }
+            return (this.startDate.getTime() < other.startDate.getTime()) ? -1 : 1;
+        }
+        return -1;
+    }
+    /**
+     * This function is used to change the standard work period dates based on the day of
+     * the week the period ends.  This function will ensure that the reports period all end
+     * on the day of the week provided.
+     * @param weekday The numeric value for the weekday the periods are to end at.
+     */
+    changePeriodsStart(weekday) {
+        let end = new Date(Date.UTC(this.endDate.getFullYear(), this.endDate.getMonth(), this.endDate.getDate()));
+        while (end.getDay() !== weekday) {
+            end = new Date(end.getTime() + (24 * 3600000));
+        }
+        let start = new Date(Date.UTC(this.startDate.getFullYear(), this.startDate.getMonth(), this.startDate.getDate()));
+        while (start.getDay() !== weekday) {
+            start = new Date(start.getTime() + (24 * 3600000));
+        }
+        // clear the old periods' subperiods.
+        this.periods.forEach(per => {
+            per.periods = [];
+        });
+        while (start.getTime() < end.getTime()) {
+            let found = false;
+            this.periods.forEach((per, p) => {
+                if (per.month.getFullYear() === start.getFullYear()
+                    && per.month.getMonth() === start.getMonth()) {
+                    per.periods.push(new Date(start));
+                    per.sortSubperiods();
+                    found = true;
+                    this.periods[p] = per;
+                }
+            });
+            if (!found) {
+                const month = new period_1.Period({
+                    month: new Date(Date.UTC(start.getFullYear(), start.getMonth(), 1)),
+                    periods: [start]
+                });
+                this.periods.push(month);
+                this.periods.sort((a, b) => a.compareTo(b));
+            }
+            start = new Date(start.getTime() + (7 * 24 * 3600000));
+        }
+        this.removeUnusedPeriods();
+    }
+    /**
+     * This function is used to remove forecast periods that have no subperiods.
+     */
+    removeUnusedPeriods() {
+        for (let p = this.periods.length - 1; p >= 0; p--) {
+            if (this.periods[p].periods.length === 0) {
+                this.periods.splice(p, 1);
+            }
+        }
+        this.periods.sort((a, b) => a.compareTo(b));
+    }
+    /**
+     * This function will move a single sub-period from one month to another adjacent
+     * month.
+     * @param from The date object representing the month period for the giving subperiod.
+     * @param to The date object representing the month period for the receiving subperiod.
+     */
+    movePeriodBetweenMonths(from, to) {
+        let fromPrd;
+        let toPrd;
+        let fromPos = -1;
+        let toPos = -1;
+        // determine the two periods the sub period will be move from and to.
+        this.periods.sort((a, b) => a.compareTo(b));
+        this.periods.forEach((prd, p) => {
+            if (prd.month.getTime() === from.getTime()) {
+                fromPrd = new period_1.Period(prd);
+                fromPos = p;
+            }
+            else if (prd.month.getTime() === to.getTime()) {
+                toPrd = new period_1.Period(prd);
+                toPos = p;
+            }
+        });
+        // if the to period isn't selected, create a new one for the month prior to 0
+        if (toPos < 0) {
+            toPrd = new period_1.Period({
+                month: to,
+                periods: []
+            });
+            this.periods.push(toPrd);
+            toPos = this.periods.length - 1;
+        }
+        // now sort the subperiod of the from period 
+        if (fromPrd && toPrd) {
+            fromPrd.sortSubperiods();
+            if (from.getTime() < to.getTime()) {
+                // when the from period is before the to period
+                // we will pop a period from the end of the list and push it onto the end of 
+                // the to period then sort it
+                const sprd = fromPrd.periods.pop();
+                if (sprd) {
+                    toPrd.periods.push(new Date(sprd));
+                }
+            }
+            else {
+                // else pull the first sub period and push it to the to period
+                const sprd = fromPrd.periods.shift();
+                if (sprd) {
+                    toPrd.periods.push(new Date(sprd));
+                }
+            }
+            toPrd.sortSubperiods();
+            // re-set the from and to periods, then re-sort the periods and remove unused periods.
+            this.periods[fromPos] = fromPrd;
+            this.periods[toPos] = toPrd;
+            this.periods.sort((a, b) => a.compareTo(b));
+            this.removeUnusedPeriods();
+        }
+    }
+    /**
+     * This function adds a sub period to the list of periods where it fits best or add a
+     * new period for the subperiod.
+     * @param dt The date object for the sub period to add
+     */
+    addOutofCycleSubPeriod(dt) {
+        const periodID = new Date(Date.UTC(dt.getFullYear(), dt.getMonth(), 1));
+        let found = false;
+        this.periods.forEach((prd, p) => {
+            if (prd.month.getTime() === periodID.getTime()) {
+                prd.periods.forEach((sprd, sp) => {
+                    if (sprd.getTime() === dt.getTime()) {
+                        found = true;
+                    }
+                });
+                if (!found) {
+                    prd.periods.push(new Date(dt));
+                    prd.sortSubperiods();
+                    this.periods[p] = prd;
+                }
+                found = true;
+            }
+        });
+        if (!found) {
+            const prd = new period_1.Period({
+                month: periodID
+            });
+            prd.periods.push(new Date(dt));
+        }
+    }
+    /**
+     * This function is used to determine if a forecast report is to be used for a report
+     * date requested.
+     * @param date The date object used for the testing.
+     * @param company The string value for company identifier for the testing.
+     * @returns A boolean value to indicate if the date is between the start and end dates
+     * of this forecast report and is for the company indicated.
+     */
+    use(date, company) {
+        return (date.getTime() >= this.startDate.getTime()
+            && date.getTime() <= this.endDate.getTime()
+            && company.toLowerCase() === this.companyid.toLowerCase());
+    }
+}
+exports.Forecast = Forecast;

package/scheduler/sites/reports/index.d.ts

@@ -0,0 +1,4 @@
+export * from './cofsReport';
+export * from './forecast';
+export * from './period';
+export * from './section';

package/scheduler/sites/reports/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./cofsReport"), exports);
+__exportStar(require("./forecast"), exports);
+__exportStar(require("./period"), exports);
+__exportStar(require("./section"), exports);

package/scheduler/sites/reports/period.d.ts

@@ -0,0 +1,11 @@
+export interface IPeriod {
+    month: Date;
+    periods?: Date[];
+}
+export declare class Period implements IPeriod {
+    month: Date;
+    periods: Date[];
+    constructor(per?: IPeriod);
+    compareTo(other?: Period): number;
+    sortSubperiods(): void;
+}

package/scheduler/sites/reports/period.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Period = void 0;
+class Period {
+    month;
+    periods;
+    constructor(per) {
+        this.month = (per) ? new Date(per.month) : new Date(0);
+        this.periods = [];
+        if (per && per.periods && per.periods.length > 0) {
+            per.periods.forEach(p => {
+                this.periods.push(new Date(p));
+            });
+            per.periods.sort((a, b) => (a.getTime() < b.getTime()) ? -1 : 1);
+        }
+    }
+    compareTo(other) {
+        if (other) {
+            return (this.month.getTime() < other.month.getTime()) ? -1 : 1;
+        }
+        return -1;
+    }
+    sortSubperiods() {
+        this.periods.sort((a, b) => (a.getTime() < b.getTime()) ? -1 : 1);
+    }
+}
+exports.Period = Period;

package/scheduler/sites/reports/section.d.ts

@@ -0,0 +1,63 @@
+import { Employee } from "../../employees";
+import { ILaborCode, LaborCode, Workcode } from "../../labor";
+/**
+ * This interface will define the data members for a report section of a CofS report
+ * definition.
+ */
+export interface ISection {
+    id: number;
+    company: string;
+    label: string;
+    signature: string;
+    laborcodes?: ILaborCode[];
+    showunit: boolean;
+}
+/**
+ * This class implements the data members and actions for CofS report sections.
+ */
+export declare class Section implements ISection {
+    id: number;
+    company: string;
+    label: string;
+    signature: string;
+    laborcodes: LaborCode[];
+    showunit: boolean;
+    constructor(sec?: ISection);
+    compareTo(other?: Section): number;
+    /**
+     * This function will produce a Certificate of Service report section, which usually
+     * holds the employees and their work hours in respect to the period provided as an
+     * XML output string.
+     * @param start The date object used for the start of the report period.
+     * @param end The date object to mark the end of the period, but not included in the
+     * period.
+     * @param workcodes A mapped list of workcodes to be used in this report.
+     * @param employees A list of employees that may or may not have worked on labor codes
+     * associated with this section.
+     * @param sectionID The numeric value (integer) for the position this section holds
+     * within the overall report file.
+     * @param unit The string value for the unit the report is associated with.
+     * @returns An interface consisting of the xml output for section's data, plus
+     * an array of strings for remarks created during the section creation.
+     */
+    createReportSection(start: Date, end: Date, workcodes: Map<string, Workcode>, employees: Employee[], sectionID: number, unit: string): {
+        output: string;
+        remarks: string[];
+    };
+    /**
+     * This function will create a CofS Section's employee row data based on the information
+     * provided
+     * @param count The numeric value for the position the employee is in the section list
+     * @param coCount The section identifier, numeric value Section count.
+     * @param emp The employee object for the row of data
+     * @param start The date object representing the start of the report period.
+     * @param end The date object for the end of the report period (not included in report)
+     * @param workcodes A mapped list of the workcodes to be used within the report.
+     * @returns An interface consisting of the xml output for the employee row data, plus
+     * an array of strings for remarks created during the row creation.
+     */
+    createEmployeeSectionData(count: number, coCount: number, emp: Employee, start: Date, end: Date, workcodes: Map<string, Workcode>): {
+        output: string;
+        remarks: string[];
+    };
+}

package/scheduler/sites/reports/section.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Section = void 0;
+const labor_1 = require("../../labor");
+/**
+ * This class implements the data members and actions for CofS report sections.
+ */
+class Section {
+    id;
+    company;
+    label;
+    signature;
+    laborcodes;
+    showunit;
+    constructor(sec) {
+        this.id = (sec) ? sec.id : 0;
+        this.company = (sec) ? sec.company : '';
+        this.label = (sec) ? sec.label : '';
+        this.signature = (sec) ? sec.signature : '';
+        this.showunit = (sec) ? sec.showunit : false;
+        this.laborcodes = [];
+        if (sec && sec.laborcodes && sec.laborcodes.length) {
+            sec.laborcodes.forEach(lc => {
+                this.laborcodes.push(new labor_1.LaborCode(lc));
+            });
+            this.laborcodes.sort((a, b) => a.compareTo(b));
+        }
+    }
+    compareTo(other) {
+        if (other) {
+            return (this.id < other.id) ? -1 : 1;
+        }
+        return -1;
+    }
+    /**
+     * This function will produce a Certificate of Service report section, which usually
+     * holds the employees and their work hours in respect to the period provided as an
+     * XML output string.
+     * @param start The date object used for the start of the report period.
+     * @param end The date object to mark the end of the period, but not included in the
+     * period.
+     * @param workcodes A mapped list of workcodes to be used in this report.
+     * @param employees A list of employees that may or may not have worked on labor codes
+     * associated with this section.
+     * @param sectionID The numeric value (integer) for the position this section holds
+     * within the overall report file.
+     * @param unit The string value for the unit the report is associated with.
+     * @returns An interface consisting of the xml output for section's data, plus
+     * an array of strings for remarks created during the section creation.
+     */
+    createReportSection(start, end, workcodes, employees, sectionID, unit) {
+        const remarks = [];
+        let output = '';
+        output += `<Company${sectionID}>${this.label}</Company${sectionID}>\n`
+            + `<Section${sectionID}_Lead>${this.signature}</Section${sectionID}_Lead>\n`;
+        if (this.showunit) {
+            output += `<Unit${sectionID}>${unit}</Unit${sectionID}>\n`;
+        }
+        let count = 0;
+        employees.forEach(emp => {
+            if (emp.isActive(start) || emp.isActive(end)) {
+                let hours = 0.0;
+                let bPrimary = false;
+                this.laborcodes.forEach(lc => {
+                    hours += emp.getWorkedHours(start, end, lc.chargeNumber, lc.extension);
+                    if (emp.isPrimaryCode(start, lc)) {
+                        bPrimary = true;
+                    }
+                });
+                if (hours > 0.0 || bPrimary) {
+                    count++;
+                    const result = this.createEmployeeSectionData(count, sectionID, emp, start, end, workcodes);
+                    if (result.output !== '') {
+                        const lines = result.output.split('\n');
+                        lines.forEach(line => {
+                            output += `\t${line}\n`;
+                        });
+                    }
+                    if (result.remarks.length > 0) {
+                        result.remarks.forEach(rmk => {
+                            remarks.push(rmk);
+                        });
+                    }
+                }
+            }
+        });
+        return { output: output, remarks: remarks };
+    }
+    /**
+     * This function will create a CofS Section's employee row data based on the information
+     * provided
+     * @param count The numeric value for the position the employee is in the section list
+     * @param coCount The section identifier, numeric value Section count.
+     * @param emp The employee object for the row of data
+     * @param start The date object representing the start of the report period.
+     * @param end The date object for the end of the report period (not included in report)
+     * @param workcodes A mapped list of the workcodes to be used within the report.
+     * @returns An interface consisting of the xml output for the employee row data, plus
+     * an array of strings for remarks created during the row creation.
+     */
+    createEmployeeSectionData(count, coCount, emp, start, end, workcodes) {
+        const remarks = [];
+        let output = '';
+        let total = 0.0;
+        const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct',
+            'Nov', 'Dec'];
+        // every employee row starts with name and job title.
+        let label = `NameRow${count}`;
+        if (coCount > 1) {
+            label += `_${coCount}`;
+        }
+        output += `<${label}>${emp.name.getLastFirst()}</${label}>\n`;
+        label = `PositionRow${count}`;
+        if (coCount > 1) {
+            label += `_${coCount}`;
+        }
+        output += `<${label}>${emp.companyinfo.jobtitle}</${label}>\n`;
+        // next add the daily information
+        let current = new Date(Date.UTC(start.getFullYear(), start.getMonth(), start.getDate()));
+        while (current.getTime() < end.getTime()) {
+            let hours = 0.0;
+            label = `Section${coCount}Row${count}_${current.getDate().toString().padStart(2, '0')}`;
+            this.laborcodes.forEach(lc => {
+                hours += emp.getWorkedHours(current, new Date(current.getTime() + (24 * 3600000)), lc.chargeNumber, lc.extension);
+            });
+            if (hours > 0.0) {
+                total += hours;
+                const iHours = Math.floor(hours * 10);
+                const icHours = Math.floor(hours) * 10;
+                if (icHours === iHours) {
+                    output += `<${label}>${hours.toFixed(0)}</${label}>\n`;
+                }
+                else {
+                    output += `<${label}>${hours.toFixed(1)}</${label}>\n`;
+                }
+                if (hours > 12.0) {
+                    const remark = `${this.company.toUpperCase()}: ${emp.name.getFirstLast()} `
+                        + `received a safety briefing for working over 12 hours on `
+                        + `${current.getDate().toString().padStart(2, '0')} ${months[current.getMonth()]}`;
+                    remarks.push(remark);
+                }
+            }
+            else {
+                const wd = emp.getWorkday(current, 'actuals', this.laborcodes);
+                if (wd && wd.code !== '') {
+                    let wc = workcodes.get(wd.code);
+                    if (wc && wc.altcode && wc.altcode !== '') {
+                        output += `<${label}>${wc.altcode}</${label}>\n`;
+                    }
+                    else {
+                        output += `<${label}/>\n`;
+                    }
+                }
+                else {
+                    output += `<${label}/>\n`;
+                }
+            }
+            current = new Date(current.getTime() + (24 * 3600000));
+        }
+        // add total hours information
+        label = `TotalHoursRow${count}`;
+        if (coCount > 1) {
+            label += `_${coCount}`;
+        }
+        output += `<${label}>${total.toFixed(1)}</${label}>\n`;
+        if (total > 200.0) {
+            const remark = `${this.company.toUpperCase()}: ${emp.name.getFirstLast()} exceeded `
+                + '200 hours to support ops tempo.';
+            remarks.push(remark);
+        }
+        return { output: output, remarks: remarks };
+    }
+}
+exports.Section = Section;