Merge pull request #3281 from SeedCompany/pnp-validation

Expose PnP Problems on progress upload

Author: CarsonF

src/app.module.ts

@@ -24,6 +24,7 @@ import { PartnershipProducingMediumModule } from './components/partnership-produ
 import { PartnershipModule } from './components/partnership/partnership.module';
 import { PeriodicReportModule } from './components/periodic-report/periodic-report.module';
 import { PinModule } from './components/pin/pin.module';
+import { PnpExtractionResultModule } from './components/pnp/extraction-result/pnp-extraction-result.module';
 import { PostModule } from './components/post/post.module';
 import { ProductProgressModule } from './components/product-progress/product-progress.module';
 import { ProductModule } from './components/product/product.module';
@@ -87,6 +88,7 @@ if (process.env.NODE_ENV !== 'production') {
     PartnershipProducingMediumModule,
     ProgressReportModule,
     PromptsModule,
+    PnpExtractionResultModule,
   ],
 })
 export class AppModule {}

src/common/markdown.scalar.ts

@@ -0,0 +1,24 @@
+import { CustomScalar, Scalar } from '@nestjs/graphql';
+import { GraphQLError, Kind, ValueNode } from 'graphql';
+
+@Scalar('InlineMarkdown')
+export class InlineMarkdownScalar
+  implements CustomScalar<string, string | null>
+{
+  description = 'A string that holds inline Markdown formatted text';
+
+  parseLiteral(ast: ValueNode): string | null {
+    if (ast.kind !== Kind.STRING) {
+      throw new GraphQLError(
+        `Can only validate strings as InlineMarkdown but got a: ${ast.kind}`,
+      );
+    }
+    return ast.value;
+  }
+  parseValue(value: any) {
+    return value;
+  }
+  serialize(value: any) {
+    return value;
+  }
+}

src/common/scalars.ts

@@ -3,6 +3,7 @@ import { CustomScalar } from '@nestjs/graphql';
 import { GraphQLScalarType } from 'graphql';
 import UploadScalar from 'graphql-upload/GraphQLUpload.mjs';
 import { DateScalar, DateTimeScalar } from './luxon.graphql';
+import { InlineMarkdownScalar } from './markdown.scalar';
 import { RichTextScalar } from './rich-text.scalar';
 import { UrlScalar } from './url.field';
 
@@ -15,4 +16,5 @@ export const getRegisteredScalars = (): Scalar[] => [
   RichTextScalar,
   UploadScalar,
   UrlScalar,
+  InlineMarkdownScalar,
 ];

src/common/xlsx.util.ts

@@ -252,9 +252,15 @@ export class Cell<TSheet extends Sheet = Sheet> {
       : undefined;
   }
 
-  toString() {
+  get fqn() {
+    return `${this.sheet.name}!${this.ref}`;
+  }
+  get ref() {
     return `${this.column.a1}${this.row.a1}`;
   }
+  toString() {
+    return this.ref;
+  }
 }
 
 abstract class Rangable<TSheet extends Sheet = Sheet> {
@@ -301,9 +307,12 @@ abstract class Rangable<TSheet extends Sheet = Sheet> {
     );
   }
 
-  toString() {
+  get ref() {
     return `${this.sheet.name}!${this.start.toString()}:${this.end.toString()}`;
   }
+  toString() {
+    return this.ref;
+  }
 }
 
 export class Range<TSheet extends Sheet = Sheet> extends Rangable<TSheet> {

src/components/periodic-report/events/periodic-report-uploaded.event.ts

@@ -1,5 +1,7 @@
+import { LazyGetter as Once } from 'lazy-get-decorator';
 import { Session } from '~/common';
-import { Downloadable, FileNode } from '../../file/dto';
+import { Downloadable, FileVersion } from '../../file/dto';
+import { PnpProgressExtractionResult } from '../../pnp/extraction-result';
 import { PeriodicReport } from '../dto';
 
 /**
@@ -8,7 +10,13 @@ import { PeriodicReport } from '../dto';
 export class PeriodicReportUploadedEvent {
   constructor(
     readonly report: PeriodicReport,
-    readonly file: Downloadable<FileNode>,
+    readonly file: Downloadable<FileVersion>,
     readonly session: Session,
   ) {}
+
+  pnpResultUsed = false;
+  @Once() get pnpResult() {
+    this.pnpResultUsed = true;
+    return new PnpProgressExtractionResult(this.file.id);
+  }
 }

src/components/pnp/extract-scripture.ts

@@ -1,39 +1,88 @@
 import { parseScripture, tryParseScripture } from '@seedcompany/scripture';
 import { Row } from '~/common/xlsx.util';
 import { ScriptureRange } from '../scripture/dto';
+import { PnpExtractionResult } from './extraction-result';
+import { addProblemMismatchScriptureAndVerseCount } from './isGoalRow';
 import { WrittenScripturePlanningSheet } from './planning-sheet';
 
-export const extractScripture = (row: Row<WrittenScripturePlanningSheet>) => {
+export const extractScripture = (
+  row: Row<WrittenScripturePlanningSheet>,
+  result: PnpExtractionResult,
+) => {
   const sheet = row.sheet;
-  const totalVerses = sheet.totalVerses(row)!;
-  const scriptureFromBookCol = parseScripture(sheet.bookName(row));
+
+  const totalVersesCell = sheet.totalVerses(row)!;
+  const totalVerses = totalVersesCell.asNumber!;
+
+  const bookCell = sheet.bookName(row);
+  const scriptureFromBookCol = parseScripture(bookCell.asString);
+  const book = scriptureFromBookCol[0].start.book;
 
   const common = {
-    bookName: scriptureFromBookCol[0].start.book.name,
+    bookName: book.name,
     totalVerses,
   };
+  let mismatchError = false;
 
   // If scripture from book column matches total count, use it.
-  if (ScriptureRange.totalVerses(...scriptureFromBookCol) === totalVerses) {
+  const totalVersesInBookCol = ScriptureRange.totalVerses(
+    ...scriptureFromBookCol,
+  );
+  if (totalVersesInBookCol === totalVerses) {
     return {
       ...common,
       scripture: scriptureFromBookCol.map(ScriptureRange.fromVerses),
     };
+    // If it is more than just the book name (aka not just the book name) then
+    // the verse count will be less and if it doesn't match the total, there is a problem
+  } else if (totalVersesInBookCol < book.totalVerses) {
+    mismatchError = true;
+    // TODO I think this is a redundant check.
+    // I don't think we will ever get here because the row is filtered out with
+    // the isGoalRow function.
+    addProblemMismatchScriptureAndVerseCount(
+      result,
+      totalVersesInBookCol,
+      bookCell,
+      totalVersesCell,
+    );
   }
 
   // Otherwise, if note column has scripture that matches the total count use it.
-  const scriptureFromNoteCol = tryParseScripture(sheet.myNote(row));
-  if (
-    scriptureFromNoteCol &&
-    ScriptureRange.totalVerses(...scriptureFromNoteCol) === totalVerses
-  ) {
-    return {
-      ...common,
-      scripture: scriptureFromNoteCol.map(ScriptureRange.fromVerses),
-    };
+  const noteCell = sheet.myNote(row);
+  const scriptureFromNoteCol = tryParseScripture(noteCell.asString);
+  if (scriptureFromNoteCol) {
+    const totalVersesFromNoteCol = ScriptureRange.totalVerses(
+      ...scriptureFromNoteCol,
+    );
+    if (totalVersesFromNoteCol === totalVerses) {
+      return {
+        ...common,
+        scripture: scriptureFromNoteCol.map(ScriptureRange.fromVerses),
+      };
+    }
+    mismatchError = true;
+    result.addProblem({
+      severity: 'Error',
+      groups:
+        'Mismatch between the planned scripture in _My Notes_ column and the number of verses to translate',
+      message: `"${noteCell.asString!}" \`${
+        noteCell.ref
+      }\` is **${totalVersesFromNoteCol}** verses, but the goal declares **${totalVerses}** verses to translate \`${
+        totalVersesCell.ref
+      }\``,
+      source: noteCell,
+    });
   }
 
   // Otherwise, fallback to unspecified scripture.
+  !mismatchError &&
+    result.addProblem({
+      severity: 'Warning',
+      groups: 'Unspecified scripture reference',
+      message: `"${book.name}" \`${bookCell.ref}\` does not a have specified scripture reference (either in the _Books_ or _My Notes_ column)`,
+      source: totalVersesCell,
+    });
   return {
     ...common,
     scripture: [],

src/components/pnp/extraction-result/extraction-result.dto.ts

@@ -0,0 +1,79 @@
+import { Field, InterfaceType, ObjectType } from '@nestjs/graphql';
+import { many, Many } from '@seedcompany/common';
+import { stripIndent } from 'common-tags';
+import * as uuid from 'uuid';
+import { EnumType, ID, IdField, makeEnum } from '~/common';
+import { InlineMarkdownScalar } from '~/common/markdown.scalar';
+import { Cell } from '~/common/xlsx.util';
+
+export type PnpProblemSeverity = EnumType<typeof PnpProblemSeverity>;
+export const PnpProblemSeverity = makeEnum({
+  name: 'PnpProblemSeverity',
+  values: ['Error', 'Warning', 'Notice'],
+});
+
+@ObjectType()
+export class PnpProblem {
+  @IdField()
+  readonly id: ID;
+
+  @Field(() => PnpProblemSeverity)
+  readonly severity: PnpProblemSeverity;
+
+  @Field(() => InlineMarkdownScalar, {
+    description: 'The message describing this specific problem',
+  })
+  readonly message: string;
+
+  @Field(() => String, {
+    description: 'Sheet!A1',
+  })
+  readonly source: string;
+
+  @Field(() => [InlineMarkdownScalar], {
+    description: stripIndent`
+      Groupings for this problem.
+      Order least specific to most.
+      Formatted as human labels.
+    `,
+  })
+  readonly groups: readonly string[];
+}
+
+@InterfaceType()
+export abstract class PnpExtractionResult {
+  constructor(private readonly fileVersionId: ID<'FileVersion'>) {}
+
+  @Field(() => [PnpProblem])
+  readonly problems: PnpProblem[] = [];
+
+  addProblem(
+    problem: Omit<PnpProblem, 'id' | 'groups' | 'source'> & {
+      id?: string;
+      groups?: Many<string>;
+      source: Cell;
+    },
+  ) {
+    const id = (problem.id ??
+      uuid.v5(
+        [this.fileVersionId, problem.message, problem.source.fqn].join('\0'),
+        ID_NS,
+      )) as ID;
+
+    // Ignore dupes
+    if (this.problems.some((p) => p.id === id)) return;
+
+    this.problems.push({
+      ...problem,
+      id,
+      groups: [problem.source.sheet.name, ...many(problem.groups ?? [])],
+      source: problem.source.fqn,
+    });
+  }
+}
+@ObjectType({ implements: PnpExtractionResult })
+export class PnpPlanningExtractionResult extends PnpExtractionResult {}
+@ObjectType({ implements: PnpExtractionResult })
+export class PnpProgressExtractionResult extends PnpExtractionResult {}
+
+const ID_NS = 'bab2666a-a0f5-4168-977d-7ef6399503f9';

src/components/pnp/extraction-result/index.ts

@@ -0,0 +1 @@
+export * from './extraction-result.dto';

src/components/pnp/extraction-result/pnp-extraction-result-progress-report-connection.resolver.ts

@@ -0,0 +1,24 @@
+import { Parent, ResolveField, Resolver } from '@nestjs/graphql';
+import { Loader, LoaderOf } from '@seedcompany/data-loader';
+import { ProgressReport } from '../../progress-report/dto';
+import { PnpProgressExtractionResult } from './extraction-result.dto';
+import { PnpExtractionResultLoader } from './pnp-extraction-result.loader';
+
+@Resolver(ProgressReport)
+export class PnpExtractionResultProgressReportConnectionResolver {
+  @ResolveField(() => PnpProgressExtractionResult, {
+    nullable: true,
+  })
+  async pnpExtractionResult(
+    @Parent() report: ProgressReport,
+    @Loader(() => PnpExtractionResultLoader)
+    loader: LoaderOf<PnpExtractionResultLoader>,
+  ): Promise<PnpProgressExtractionResult | null> {
+    const fileId = report.reportFile.value;
+    if (!fileId) {
+      return null;
+    }
+    const { result } = await loader.load(fileId);
+    return result;
+  }
+}

src/components/pnp/extraction-result/pnp-extraction-result.edgedb.repository.ts

@@ -0,0 +1,21 @@
+import { Injectable } from '@nestjs/common';
+import { ID, NotImplementedException } from '~/common';
+import { CommonRepository } from '~/core/edgedb';
+import { PnpExtractionResult } from './extraction-result.dto';
+import { PnpExtractionResultLoadResult } from './pnp-extraction-result.loader';
+
+@Injectable()
+export class PnpExtractionResultRepository extends CommonRepository {
+  async read(
+    files: ReadonlyArray<ID<'File'>>,
+  ): Promise<readonly PnpExtractionResultLoadResult[]> {
+    throw new NotImplementedException().with(files);
+  }
+
+  async save(
+    file: ID<'FileVersion'>,
+    result: PnpExtractionResult,
+  ): Promise<void> {
+    throw new NotImplementedException().with(file, result);
+  }
+}