Feat/pre assignation (#101)

* create model and repositories to preAssign decision

* add preAssignation service tests

* create pre assignation api endpoints

* fix import in controller

* create assignation when there is a preAssignation after nlp annotation

* add delete preassignation route on api

* first step for frontend

* create delete oprtion

* get userName instead of userId

* refetch on delete

* add pre-assignation creation button

* add pre assignation creation

* lint

* adapt clear db

* fix tests

* fix to run script without docker

* change behavior to accept appealNumbers

* fix docker start

* reset path to storage

* fix paths to execute scripts

* changes from review

---------

Co-authored-by: Antoine Jeanneney <antoine.jeanneney@justice.fr>

docs/collections.md

@@ -8,3 +8,4 @@
 - statistics
 - treatments
 - users
+- preAssignations

package.json

@@ -25,6 +25,7 @@
     "init:db": "scripts/initializeTestDb.sh",
     "lint": "lerna run lint",
     "migration:create": "scripts/createMigrationFile.sh",
+    "start:backend": "RUN_MODE=LOCAL lerna run --scope @label/cour-de-cassation start --stream",
     "start:backend:dev": "RUN_MODE=LOCAL nodemon",
     "start:client:dev": "yarn compile:client && cd packages/generic/client && yarn start",
     "test": "lerna run test",

packages/courDeCassation/src/annotator/fetcher/api/nlpLocalApi.ts

@@ -4,7 +4,7 @@ import { nlpApiType, nlpResponseType } from './nlpApiType';
 
 export { buildNlpLocalApi };
 
-const pathToNlpAnnotations = 'packages/courDeCassation/storage/annotations/';
+const pathToNlpAnnotations = './storage/annotations/';
 
 function buildNlpLocalApi(): nlpApiType {
   return {

packages/courDeCassation/src/connector/mapper/extractors/extractRoute/extractRouteForJurica.ts

@@ -28,19 +28,10 @@ function extractRouteForJurica({
     (decEndCaseCode >= 11.01 && decEndCaseCode <= 22.24) ||
     (decEndCaseCode >= 33.01 && decEndCaseCode <= 33.03)
   ) {
-    let endCaseCodeCsv;
-    if (process.env.RUN_MODE === 'LOCAL') {
-      endCaseCodeCsv = fs.readFileSync(
-        'packages/courDeCassation/static/endCaseRoutes.csv',
-        {
-          encoding: 'utf8',
-        },
-      ) as string;
-    } else {
-      endCaseCodeCsv = fs.readFileSync('./static/endCaseRoutes.csv', {
-        encoding: 'utf8',
-      }) as string;
-    }
+    const endCaseCodeCsv = fs.readFileSync('./static/endCaseRoutes.csv', {
+      encoding: 'utf8',
+    }) as string;
+
     const endCaseCodeData = {} as Array<any>;
 
     endCaseCodeCsv.split('\n').forEach((line) => {
@@ -57,19 +48,10 @@ function extractRouteForJurica({
     }
   }
 
-  let NACCodeCsv;
-  if (process.env.RUN_MODE === 'LOCAL') {
-    NACCodeCsv = fs.readFileSync(
-      'packages/courDeCassation/static/NACCodeRoutes.csv',
-      {
-        encoding: 'utf8',
-      },
-    ) as string;
-  } else {
-    NACCodeCsv = fs.readFileSync('./static/NACCodeRoutes.csv', {
-      encoding: 'utf8',
-    }) as string;
-  }
+  const NACCodeCsv = fs.readFileSync('./static/NACCodeRoutes.csv', {
+    encoding: 'utf8',
+  }) as string;
+
   const NACCodeData = {} as Array<any>;
 
   NACCodeCsv.split('\n').forEach((line) => {

packages/courDeCassation/src/sderApi/sderLocalApi.ts

@@ -6,7 +6,7 @@ import { sderApiType } from './sderApiType';
 
 export { sderLocalApi };
 
-const pathToCourtDecisions = 'packages/courDeCassation/storage/documents/';
+const pathToCourtDecisions = './storage/documents/';
 
 async function fetchApi({
   method,

packages/generic/backend/src/api/controllers.ts

@@ -11,6 +11,7 @@ import { userService } from '../modules/user';
 import { buildAuthenticatedController } from './buildAuthenticatedController';
 import { controllersFromSchemaType } from './controllerType';
 import { annotationReportService } from '../modules/annotationReport';
+import { preAssignationService } from '../modules/preAssignation';
 import { replacementTermType } from '@label/core';
 
 export { controllers };
@@ -191,6 +192,12 @@ const controllers: controllersFromSchemaType<typeof apiSchema> = {
       permissions: ['admin', 'scrutator'],
       controllerWithUser: async () => userService.fetchWorkingUsers(),
     }),
+
+    preAssignations: buildAuthenticatedController({
+      permissions: ['admin'],
+      controllerWithUser: async () =>
+        preAssignationService.fetchAllPreAssignation(),
+    }),
   },
 
   post: {
@@ -238,7 +245,13 @@ const controllers: controllersFromSchemaType<typeof apiSchema> = {
           idModule.lib.buildId(problemReportId),
         ),
     }),
-
+    deletePreAssignation: buildAuthenticatedController({
+      permissions: ['admin'],
+      controllerWithUser: async (_, { args: { preAssignationId } }) =>
+        preAssignationService.deletePreAssignation(
+          idModule.lib.buildId(preAssignationId),
+        ),
+    }),
     deleteHumanTreatmentsForDocument: buildAuthenticatedController({
       permissions: ['admin'],
       controllerWithUser: async (_, { args: { documentId } }) => {
@@ -468,5 +481,16 @@ const controllers: controllersFromSchemaType<typeof apiSchema> = {
         );
       },
     }),
+
+    createPreAssignation: buildAuthenticatedController({
+      permissions: ['admin'],
+      controllerWithUser: async (_, { args: { userId, source, number } }) => {
+        preAssignationService.createPreAssignation({
+          userId: idModule.lib.buildId(userId),
+          source,
+          number,
+        });
+      },
+    }),
   },
 };

packages/generic/backend/src/app/scripts/clearDb.ts

@@ -1,3 +1,4 @@
+import { buildPreAssignationRepository } from '../../modules/preAssignation';
 import { buildAnnotationReportRepository } from '../../modules/annotationReport';
 import { buildAssignationRepository } from '../../modules/assignation';
 import { buildDocumentRepository } from '../../modules/document';
@@ -19,6 +20,7 @@ async function clearDb({
   statistic = true,
   treatment = true,
   user = true,
+  preAssignations = true,
 }: {
   annotation?: boolean;
   assignation?: boolean;
@@ -28,6 +30,7 @@ async function clearDb({
   statistic?: boolean;
   treatment?: boolean;
   user?: boolean;
+  preAssignations?: boolean;
 }) {
   logger.log({
     operationName: 'clearDb',
@@ -41,6 +44,7 @@ async function clearDb({
       statistic,
       treatment,
       user,
+      preAssignations,
     },
   });
 
@@ -77,6 +81,10 @@ async function clearDb({
       shouldClear: user,
       buildRepository: buildUserRepository,
     },
+    {
+      shouldClear: preAssignations,
+      buildRepository: buildPreAssignationRepository,
+    },
   ]
     .filter(({ shouldClear }) => shouldClear)
     .map(({ buildRepository }) => buildRepository());

packages/generic/backend/src/app/setup.ts

@@ -2,9 +2,14 @@ import { settingsType } from '@label/core';
 import { settingsLoader } from '../lib/settingsLoader';
 import { logger, mongo } from '../utils';
 import { setIndexesOnAllCollections } from './scripts';
+import * as dotenv from 'dotenv';
 
 export { setup, setupMongo };
 
+if (process.env.RUN_MODE === 'LOCAL') {
+  dotenv.config();
+}
+
 async function setup(settings: settingsType) {
   setupSettings(settings);
   await setupMongo();

packages/generic/backend/src/lib/annotator/buildAnnotator.ts

@@ -8,12 +8,15 @@ import {
   settingsType,
   treatmentModule,
   annotationModule,
+  preAssignationType,
 } from '@label/core';
 import { buildAnnotationReportRepository } from '../../modules/annotationReport';
 import { documentService } from '../../modules/document';
 import { treatmentService } from '../../modules/treatment';
 import { logger } from '../../utils';
 import { annotatorConfigType } from './annotatorConfigType';
+import { preAssignationService } from '../../modules/preAssignation';
+import { assignationService } from '../../modules/assignation';
 
 export { buildAnnotator };
 
@@ -312,16 +315,59 @@ function buildAnnotator(
       publicationCategory: document.publicationCategory,
       route: document.route,
     });
-    await documentService.updateDocumentStatus(
-      document._id,
-      nextDocumentStatus,
-    );
+
+    // Check first pre-assignation by documentNumber and then by appelNumber
+    const preAssignationForDocument =
+      (await preAssignationService.fetchPreAssignationBySourceAndNumber(
+        document.documentNumber.toString(),
+        document.source,
+      )) ||
+      (await preAssignationService.fetchPreAssignationBySourceAndNumber(
+        document.decisionMetadata.appealNumber,
+        document.source,
+      ));
+
+    if (
+      nextDocumentStatus === 'free' &&
+      preAssignationForDocument != undefined
+    ) {
+      logger.log({
+        operationName: 'annotateDocument',
+        msg: `Pre-assignation found for document ${formatDocumentInfos(
+          document,
+        )}. Matching pre-assignation number : ${
+          preAssignationForDocument.number
+        }. Creating assignation...`,
+      });
+      await createAssignation(preAssignationForDocument, document);
+    } else {
+      await documentService.updateDocumentStatus(
+        document._id,
+        nextDocumentStatus,
+      );
+    }
+
     logger.log({
       operationName: 'annotateDocument',
       msg: `Annotation done for document ${formatDocumentInfos(document)}`,
     });
   }
 
+  async function createAssignation(
+    preAssignation: preAssignationType,
+    document: documentType,
+  ) {
+    await assignationService.createAssignation({
+      documentId: idModule.lib.buildId(document._id),
+      userId: idModule.lib.buildId(preAssignation.userId),
+    });
+    await preAssignationService.deletePreAssignation(preAssignation._id);
+    await documentService.updateDocumentStatus(
+      idModule.lib.buildId(document._id),
+      'saved',
+    );
+  }
+
   async function createAnnotatorTreatment({
     annotations,
     documentId,

packages/generic/backend/src/modules/preAssignation/index.ts

@@ -0,0 +1,4 @@
+import { buildPreAssignationRepository } from './repository';
+import { preAssignationService } from './service';
+
+export { buildPreAssignationRepository, preAssignationService };

packages/generic/backend/src/modules/preAssignation/repository/buildFakePreAssignationRepository.ts

@@ -0,0 +1,20 @@
+import { preAssignationType } from '@label/core';
+import { buildFakeRepositoryBuilder } from '../../../repository';
+import { customPreAssignationRepositoryType } from './customPreAssignationRepositoryType';
+
+export { buildFakePreAssignationRepository };
+
+const buildFakePreAssignationRepository = buildFakeRepositoryBuilder<
+  preAssignationType,
+  customPreAssignationRepositoryType
+>({
+  collectionName: 'preAssignations',
+  buildCustomFakeRepository: (collection) => ({
+    async findOneByNumberAndSource({ number, source }) {
+      return collection.find(
+        (preAssignation) =>
+          preAssignation.source === source && preAssignation.number === number,
+      );
+    },
+  }),
+});

packages/generic/backend/src/modules/preAssignation/repository/buildPreAssignationRepository.ts

@@ -0,0 +1,27 @@
+import { preAssignationType } from '@label/core';
+import { buildRepositoryBuilder } from '../../../repository';
+import { customPreAssignationRepositoryType } from './customPreAssignationRepositoryType';
+
+export { buildPreAssignationRepository };
+
+const buildPreAssignationRepository = buildRepositoryBuilder<
+  preAssignationType,
+  customPreAssignationRepositoryType
+>({
+  collectionName: 'preAssignations',
+  indexes: [
+    {
+      index: { source: 1, number: 1 },
+      mustBeUnique: true,
+    } as const,
+  ],
+  buildCustomRepository: (collection) => ({
+    async findOneByNumberAndSource({ number, source }) {
+      const preAssignation = await collection.findOne({
+        number,
+        source,
+      });
+      return preAssignation || undefined;
+    },
+  }),
+});

packages/generic/backend/src/modules/preAssignation/repository/customPreAssignationRepositoryType.ts

@@ -0,0 +1,13 @@
+import { preAssignationType } from '@label/core';
+
+export type { customPreAssignationRepositoryType };
+
+type customPreAssignationRepositoryType = {
+  findOneByNumberAndSource: ({
+    number,
+    source,
+  }: {
+    number: string;
+    source: string;
+  }) => Promise<preAssignationType | undefined>;
+};

packages/generic/backend/src/modules/preAssignation/repository/index.ts

@@ -0,0 +1,11 @@
+import { dependencyManager } from '../../../utils';
+import { buildPreAssignationRepository } from './buildPreAssignationRepository';
+import { buildFakePreAssignationRepository } from './buildFakePreAssignationRepository';
+
+export { buildRepository as buildPreAssignationRepository };
+
+const buildRepository = dependencyManager.inject({
+  forLocal: buildPreAssignationRepository,
+  forProd: buildPreAssignationRepository,
+  forTest: buildFakePreAssignationRepository,
+});

packages/generic/backend/src/modules/preAssignation/service/createPreAssignation.ts

@@ -0,0 +1,27 @@
+import { preAssignationModule, idType } from '@label/core';
+import { buildPreAssignationRepository } from '..';
+
+export { createPreAssignation };
+
+async function createPreAssignation({
+  userId,
+  source,
+  number,
+}: {
+  userId: idType;
+  source: string;
+  number: string;
+}) {
+  const preAssignationRepository = buildPreAssignationRepository();
+
+  const preAssignation = preAssignationModule.lib.buildPreAssignation({
+    userId,
+    source,
+    number,
+    creationDate: new Date().getTime(),
+  });
+
+  await preAssignationRepository.insert(preAssignation);
+
+  return preAssignation;
+}