PnP: Mismatched Reporting Quarter / Missing Summary % -> 0 (#3324)

Co-authored-by: Carson Full <[email protected]>

Author: atGit2021

src/common/fiscal-year.ts

@@ -2,6 +2,9 @@ import { range } from 'lodash';
 import { DateTime } from 'luxon';
 import { CalendarDate, DateInterval } from './temporal';
 
+export const fiscalQuarterLabel = (date: CalendarDate) =>
+  `Q${fiscalQuarter(date)} FY${fiscalYear(date)}`;
+
 export const fiscalYear = (dt: DateTime) => dt.year + (dt.month >= 10 ? 1 : 0);
 
 export const fiscalYears = (start?: DateTime, end?: DateTime) =>
@@ -44,3 +47,12 @@ export const fullFiscalQuarter = (
     fiscalQuarterStartDate.endOf('quarter'),
   );
 };
+
+export const isReasonableYear = (year: unknown) =>
+  isInt(year) && year >= 1970 && year <= 3000;
+
+export const isQuarterNumber = (quarter: unknown) =>
+  isInt(quarter) && quarter >= 1 && quarter <= 4;
+
+// Not true for falsy case, thus not built-in, but fine for our cases here.
+const isInt = (x: unknown): x is number => Number.isInteger(x);

src/components/pnp/progress-sheet.ts

@@ -1,4 +1,5 @@
 import { LazyGetter as Once } from 'lazy-get-decorator';
+import { fullFiscalQuarter, isQuarterNumber, isReasonableYear } from '~/common';
 import { Column, Range, Row, Sheet, WorkBook } from '~/common/xlsx.util';
 
 export abstract class ProgressSheet extends Sheet {
@@ -48,6 +49,25 @@ export abstract class ProgressSheet extends Sheet {
     return this.namedRange('PrcntFinishedYears');
   }
 
+  /**
+   * This is just an artificial filter.
+   * It can be greater than the quarter we need, and we can still extract data fine.
+   */
+  @Once() get reportingQuarter() {
+    const year = this.reportingQuarterCells.year.asNumber!;
+    const quarterStr = this.reportingQuarterCells.quarter.asString;
+    const quarter = Number(quarterStr?.slice(1));
+    return isReasonableYear(year) && isQuarterNumber(quarter)
+      ? fullFiscalQuarter(quarter, year)
+      : undefined;
+  }
+  @Once() get reportingQuarterCells() {
+    return {
+      quarter: this.namedRange('RptQtr').start,
+      year: this.namedRange('RptYr').start,
+    };
+  }
+
   columnForQuarterSummary(fiscalQuarter: number) {
     return this.book.namedRange(`Q${fiscalQuarter}Column`).start.column;
   }

src/components/progress-summary/progress-summary.extractor.ts

@@ -1,7 +1,12 @@
 import { Injectable } from '@nestjs/common';
-import { Nil } from '@seedcompany/common';
+import { oneLine } from 'common-tags';
 import { clamp, round } from 'lodash';
-import { CalendarDate, fiscalQuarter, fiscalYear } from '~/common';
+import {
+  CalendarDate,
+  fiscalQuarter,
+  fiscalQuarterLabel,
+  fiscalYear,
+} from '~/common';
 import { Column, Row } from '~/common/xlsx.util';
 import { Downloadable } from '../file/dto';
 import { Pnp, ProgressSheet } from '../pnp';
@@ -18,26 +23,33 @@ export class ProgressSummaryExtractor {
     const pnp = await Pnp.fromDownloadable(file);
     const sheet = pnp.progress;
 
+    if (!(sheet.reportingQuarter && date <= sheet.reportingQuarter.end)) {
+      const cells = sheet.reportingQuarterCells;
+      result.addProblem({
+        severity: 'Error',
+        groups: 'Mismatched Reporting Quarter',
+        message: oneLine`
+          The PnP's Reporting Quarter
+            (_${
+              sheet.reportingQuarter
+                ? fiscalQuarterLabel(sheet.reportingQuarter.start)
+                : 'undetermined'
+            }_ \`${cells.quarter.ref}\`/\`${cells.year.ref}\`)
+          needs to be *at least* the quarter of this CORD report
+            (_${fiscalQuarterLabel(date)}_).
+        `,
+        source: cells.quarter,
+      });
+      return {};
+    }
+
     const currentFiscalYear = fiscalYear(date);
     const yearRow = findFiscalYearRow(sheet, currentFiscalYear);
     const quarterCol = sheet.columnForQuarterSummary(fiscalQuarter(date));
     return {
-      reportPeriod: summaryFrom(
-        yearRow,
-        quarterCol,
-        quarterCol,
-        result,
-        'Quarterly',
-        currentFiscalYear,
-      ),
-      fiscalYear: summaryFrom(
-        yearRow,
-        ...sheet.columnsForFiscalYear,
-        result,
-        'Yearly',
-        currentFiscalYear,
-      ),
-      cumulative: findLatestCumulative(yearRow, result, currentFiscalYear),
+      reportPeriod: summaryFrom(yearRow, quarterCol, quarterCol),
+      fiscalYear: summaryFrom(yearRow, ...sheet.columnsForFiscalYear),
+      cumulative: findLatestCumulative(yearRow),
     };
   }
 }
@@ -51,21 +63,11 @@ const findFiscalYearRow = (sheet: ProgressSheet, fiscalYear: number) => {
   throw new Error('Unable to find fiscal year in pnp file');
 };
 
-const findLatestCumulative = (
-  currentYear: Row<ProgressSheet>,
-  result: PnpProgressExtractionResult,
-  currentFiscalYear: number,
-) => {
+const findLatestCumulative = (currentYear: Row<ProgressSheet>) => {
   const { sheet } = currentYear;
   // eslint-disable-next-line no-constant-condition
   while (true) {
-    const summary = summaryFrom(
-      currentYear,
-      ...sheet.columnsForCumulative,
-      result,
-      'Cumulative',
-      currentFiscalYear,
-    );
+    const summary = summaryFrom(currentYear, ...sheet.columnsForCumulative);
     if (summary) {
       return summary;
     }
@@ -80,41 +82,10 @@ const summaryFrom = (
   fiscalYear: Row<ProgressSheet>,
   plannedColumn: Column,
   actualColumn: Column,
-  result: PnpProgressExtractionResult,
-  period: string,
-  currentFiscalYear: number,
-): Progress | null => {
-  const plannedCell = fiscalYear.cell(plannedColumn);
-  const actualCell = fiscalYear.cell(actualColumn);
-  let planned = plannedCell.asNumber;
-  let actual = actualCell.asNumber;
-  if (!planned && +plannedColumn !== +actualColumn) {
-    result.addProblem({
-      severity: 'Error',
-      groups: [
-        'Missing progress summary percents',
-        `The _${period}_ summary percents for _FY${currentFiscalYear}_ is missing`,
-      ],
-      message: `The _${period} Planned_ percent for _FY${currentFiscalYear}_ \`${plannedCell.ref}\` is missing`,
-      source: plannedCell,
-    });
-  }
-  if (!actual) {
-    result.addProblem({
-      severity: 'Error',
-      groups: [
-        'Missing progress summary percents',
-        `The _${period}_ summary percents for _FY${currentFiscalYear}_ is missing`,
-      ],
-      message: `The _${period} Actual_ percent for _FY${currentFiscalYear}_ \`${actualCell.ref}\` is missing`,
-      source: actualCell,
-    });
-  }
-  if (!planned && !actual) {
-    return null;
-  }
-  const normalize = (val: number | Nil) => {
-    if (!val) return 0;
+): Progress => {
+  let planned = fiscalYear.cell(plannedColumn).asNumber ?? 0;
+  let actual = fiscalYear.cell(actualColumn).asNumber ?? 0;
+  const normalize = (val: number) => {
     if (round(val, 4) > 1) {
       // The PnP has the macro option to do calculations as percents or verse equivalents.
       // We need to standardize as percents here.