add a column to store number of hours actually made in the assessment

Author: JeromeBu

back/src/config/pg/kysely/model/database.ts

@@ -666,6 +666,7 @@ interface EstablishmentsDeleted {
 interface ImmersionAssessments {
   convention_id: string;
   status: string;
+  number_of_hours_actually_made: number | null;
   last_day_of_presence: Timestamp | null;
   number_of_missed_hours: number | null;
   ended_with_a_job: boolean;

back/src/config/pg/migrations/1737646984091_add-number-of-hours-actually-made-in-assessment-table.ts

@@ -0,0 +1,14 @@
+import { MigrationBuilder } from "node-pg-migrate";
+
+export async function up(pgm: MigrationBuilder): Promise<void> {
+  pgm.addColumn("immersion_assessments", {
+    number_of_hours_actually_made: {
+      type: "numeric(5, 2)",
+      notNull: false,
+    },
+  });
+}
+
+export async function down(pgm: MigrationBuilder): Promise<void> {
+  pgm.dropColumn("immersion_assessments", "number_of_hours_actually_made");
+}

back/src/domains/convention/adapters/PgAssessmentRepository.integration.test.ts

@@ -25,11 +25,13 @@ const convention = new ConventionDtoBuilder().withId(conventionId).build();
 const minimalAssessment: AssessmentEntity = {
   ...new AssessmentDtoBuilder().withMinimalInformations().build(),
   _entityName: "Assessment",
+  numberOfHoursActuallyMade: convention.schedule.totalHours,
 };
 
 const fullAssessment: AssessmentEntity = {
   ...new AssessmentDtoBuilder().withFullInformations().build(),
   _entityName: "Assessment",
+  numberOfHoursActuallyMade: convention.schedule.totalHours,
 };
 
 describe("PgAssessmentRepository", () => {
@@ -112,12 +114,10 @@ describe("PgAssessmentRepository", () => {
       expect(
         await db.selectFrom("immersion_assessments").selectAll().execute(),
       ).toHaveLength(1);
-      expectToEqual(
-        await assessmentRepository.getByConventionId(
-          fullAssessment.conventionId,
-        ),
-        fullAssessment,
+      const savedAssessment = await assessmentRepository.getByConventionId(
+        fullAssessment.conventionId,
       );
+      expectToEqual(savedAssessment, fullAssessment);
     });
   });
 
@@ -151,6 +151,7 @@ describe("PgAssessmentRepository", () => {
         endedWithAJob: false,
         establishmentFeedback: "Ca s'est bien passé",
         establishmentAdvices: "mon conseil",
+        numberOfHoursActuallyMade: 404,
         _entityName: "Assessment",
       };
 

back/src/domains/convention/adapters/PgAssessmentRepository.ts

@@ -1,15 +1,10 @@
 import { sql } from "kysely";
-import {
-  AssessmentStatus,
-  ConventionId,
-  DateString,
-  assessmentSchema,
-  errors,
-} from "shared";
+import { AssessmentStatus, ConventionId, DateString, errors } from "shared";
 import {
   KyselyDb,
   jsonBuildObject,
 } from "../../../config/pg/kysely/kyselyUtils";
+import { assessmentEntitySchema } from "../../../utils/assessment";
 import { AssessmentEntity } from "../entities/AssessmentEntity";
 import { AssessmentRepository } from "../ports/AssessmentRepository";
 
@@ -25,17 +20,20 @@ const createAssessmentQueryBuilder = (transaction: KyselyDb) => {
       typeOfContract: eb.ref("type_of_contract"),
       lastDayOfPresence: sql<DateString>`date_to_iso(last_day_of_presence)`,
       numberOfMissedHours: eb.ref("number_of_missed_hours"),
+      numberOfHoursActuallyMade: eb.ref("number_of_hours_actually_made"),
     }).as("assessment"),
   ]);
 };
 
-const parseAssessmentSchema = (assessment: any) => {
-  return assessmentSchema.parse({
+const parseAssessmentEntitySchema = (assessment: any) =>
+  assessmentEntitySchema.parse({
+    _entityName: "Assessment",
     conventionId: assessment.conventionId,
     status: assessment.status,
     establishmentFeedback: assessment.establishmentFeedback,
     establishmentAdvices: assessment.establishmentAdvices,
     endedWithAJob: assessment.endedWithAJob,
+    numberOfHoursActuallyMade: assessment.numberOfHoursActuallyMade,
     ...(assessment.contractStartDate
       ? { contractStartDate: assessment.contractStartDate }
       : {}),
@@ -49,7 +47,6 @@ const parseAssessmentSchema = (assessment: any) => {
       ? { numberOfMissedHours: assessment.numberOfMissedHours }
       : {}),
   });
-};
 
 export class PgAssessmentRepository implements AssessmentRepository {
   constructor(private transaction: KyselyDb) {}
@@ -64,12 +61,7 @@ export class PgAssessmentRepository implements AssessmentRepository {
     const assessment = result?.assessment;
     if (!assessment) return;
 
-    const dto = parseAssessmentSchema(assessment);
-
-    return {
-      _entityName: "Assessment",
-      ...dto,
-    };
+    return parseAssessmentEntitySchema(assessment);
   }
 
   public async getByConventionIds(
@@ -81,12 +73,9 @@ export class PgAssessmentRepository implements AssessmentRepository {
       .where("convention_id", "in", conventionIds)
       .execute();
 
-    return result.map(({ assessment }) => {
-      return {
-        _entityName: "Assessment",
-        ...parseAssessmentSchema(assessment),
-      };
-    });
+    return result.map(({ assessment }) =>
+      parseAssessmentEntitySchema(assessment),
+    );
   }
 
   public async save(assessmentEntity: AssessmentEntity): Promise<void> {
@@ -112,6 +101,8 @@ export class PgAssessmentRepository implements AssessmentRepository {
           : null,
         establishment_feedback: assessmentEntity.establishmentFeedback,
         establishment_advices: assessmentEntity.establishmentAdvices,
+        number_of_hours_actually_made:
+          assessmentEntity.numberOfHoursActuallyMade,
       })
       .execute()
       .catch((error) => {

back/src/domains/convention/entities/AssessmentEntity.ts

@@ -1,26 +1,55 @@
-import { AssessmentDto, ConventionDto, ConventionStatus, errors } from "shared";
+import {
+  AssessmentDto,
+  ConventionDto,
+  ConventionStatus,
+  calculateTotalImmersionHoursBetweenDateComplex,
+  errors,
+} from "shared";
 import { EntityFromDto } from "../../../utils/EntityFromDto";
 
-export type AssessmentEntity = EntityFromDto<AssessmentDto, "Assessment">;
+export type AssessmentEntity = EntityFromDto<AssessmentDto, "Assessment"> & {
+  numberOfHoursActuallyMade: number | null;
+};
 
 export const acceptedConventionStatusesForAssessment: ConventionStatus[] = [
   "ACCEPTED_BY_VALIDATOR",
 ];
 
+const calculateNumberOfHoursActuallyMade = (
+  assessment: AssessmentDto,
+  convention: ConventionDto,
+): number => {
+  if (assessment.status === "DID_NOT_SHOW") return 0;
+  if (assessment.status === "COMPLETED") return convention.schedule.totalHours;
+
+  return (
+    calculateTotalImmersionHoursBetweenDateComplex({
+      complexSchedule: convention.schedule.complexSchedule,
+      dateStart: convention.dateStart,
+      dateEnd: assessment.lastDayOfPresence ?? convention.dateEnd,
+    }) - assessment.numberOfMissedHours
+  );
+};
+
 export const createAssessmentEntity = (
-  dto: AssessmentDto,
+  assessment: AssessmentDto,
   convention: ConventionDto,
 ): AssessmentEntity => {
   if (!acceptedConventionStatusesForAssessment.includes(convention.status))
     throw errors.assessment.badStatus(convention.status);
 
   return {
     _entityName: "Assessment",
-    ...dto,
+    ...assessment,
+    numberOfHoursActuallyMade: calculateNumberOfHoursActuallyMade(
+      assessment,
+      convention,
+    ),
   };
 };
 
 export const toAssessmentDto = ({
   _entityName,
+  numberOfHoursActuallyMade: _,
   ...assessmentEntity
 }: AssessmentEntity): AssessmentDto => assessmentEntity;

back/src/domains/convention/use-cases/CreateAssessment.ts

@@ -3,7 +3,7 @@ import {
   ConventionDomainPayload,
   ConventionDto,
   ForbiddenError,
-  assessmentSchema,
+  assessmentDtoSchema,
   errors,
 } from "shared";
 import { agencyWithRightToAgencyDto } from "../../../utils/agency";
@@ -26,7 +26,7 @@ export const makeCreateAssessment = createTransactionalUseCase<
   ConventionDomainPayload | undefined,
   WithCreateNewEvent
 >(
-  { name: "CreateAssessment", inputSchema: assessmentSchema },
+  { name: "CreateAssessment", inputSchema: assessmentDtoSchema },
   async ({
     inputParams: assessment,
     uow,

back/src/domains/convention/use-cases/CreateAssessment.unit.test.ts

@@ -13,6 +13,7 @@ import {
   expectObjectInArrayToMatch,
   expectPromiseToFailWithError,
   makeEmailHash,
+  reasonableSchedule,
   splitCasesBetweenPassingAndFailing,
 } from "shared";
 import { toAgencyWithRights } from "../../../utils/agency";
@@ -128,7 +129,11 @@ describe("CreateAssessment", () => {
 
     it("throws ConflictError if the assessment already exists for the Convention", async () => {
       uow.assessmentRepository.setAssessments([
-        { ...assessment, _entityName: "Assessment" },
+        {
+          ...assessment,
+          _entityName: "Assessment",
+          numberOfHoursActuallyMade: validatedConvention.schedule.totalHours,
+        },
       ]);
       await expectPromiseToFailWithError(
         createAssessment.execute(assessment, tutorPayload),
@@ -213,11 +218,49 @@ describe("CreateAssessment", () => {
           {
             ...assessment,
             _entityName: "Assessment",
+            numberOfHoursActuallyMade: validatedConvention.schedule.totalHours,
           },
         ]);
       },
     );
 
+    it("should create an assessment with correct duration when partially completed", async () => {
+      const convention = new ConventionDtoBuilder(validatedConvention)
+        .withStatus("ACCEPTED_BY_VALIDATOR")
+        .withDateStart(new Date("2025-01-20").toISOString())
+        .withDateEnd(new Date("2025-01-24").toISOString())
+        .withSchedule(reasonableSchedule)
+        .build();
+
+      const partiallyCompletedAssessment: AssessmentDto = {
+        conventionId: validatedConvention.id,
+        status: "PARTIALLY_COMPLETED",
+        lastDayOfPresence: new Date("2025-01-23").toISOString(),
+        numberOfMissedHours: 2.5,
+        endedWithAJob: false,
+        establishmentFeedback: "Ca c'est bien passé",
+        establishmentAdvices: "mon conseil",
+      };
+
+      uow.conventionRepository.setConventions([convention]);
+
+      await createAssessment.execute(partiallyCompletedAssessment, {
+        ...tutorPayload,
+        role: "establishment-tutor",
+        emailHash: makeHashByRolesForTest(convention, counsellor, validator)[
+          "establishment-tutor"
+        ],
+      });
+
+      expectArraysToEqual(uow.assessmentRepository.assessments, [
+        {
+          ...partiallyCompletedAssessment,
+          _entityName: "Assessment",
+          numberOfHoursActuallyMade: 25.5, // 4 days * 7 hours - 2.5 missed hours
+        },
+      ]);
+    });
+
     it("should dispatch an AssessmentCreated event", async () => {
       await createAssessment.execute(assessment, tutorPayload);
 

back/src/domains/convention/use-cases/GetAssessmentByConventionId.unit.test.ts

@@ -72,6 +72,7 @@ describe("GetAssessmentByConventionId", () => {
     uow.assessmentRepository.setAssessments([
       {
         _entityName: "Assessment",
+        numberOfHoursActuallyMade: convention.schedule.totalHours,
         ...assessment,
       },
     ]);

back/src/utils/assessment.ts

@@ -3,9 +3,12 @@ import {
   ConventionDomainPayload,
   ConventionDto,
   Role,
+  assessmentDtoSchema,
   errors,
   isSomeEmailMatchingEmailHash,
 } from "shared";
+import { z } from "zod";
+import { AssessmentEntity } from "../domains/convention/entities/AssessmentEntity";
 
 export const throwForbiddenIfNotAllowedForAssessments = (
   convention: ConventionDto,
@@ -22,6 +25,14 @@ export const throwForbiddenIfNotAllowedForAssessments = (
     throw errors.assessment.forbidden();
 };
 
+export const assessmentEntitySchema: z.Schema<AssessmentEntity> =
+  assessmentDtoSchema.and(
+    z.object({
+      _entityName: z.literal("Assessment"),
+      numberOfHoursActuallyMade: z.number().or(z.null()),
+    }),
+  );
+
 const assessmentEmailsByRole = (
   convention: ConventionDto,
   agency: AgencyDto,

front/src/app/components/forms/assessment/AssessmentForm.tsx

@@ -23,7 +23,7 @@ import {
   ConventionReadDto,
   DotNestedKeys,
   InternshipKind,
-  assessmentSchema,
+  assessmentDtoSchema,
   assessmentStatuses,
   computeTotalHours,
   convertLocaleDateToUtcTimezoneDate,
@@ -90,7 +90,7 @@ export const AssessmentForm = ({
     endedWithAJob: false,
   };
   const methods = useForm<AssessmentDto>({
-    resolver: zodResolver(assessmentSchema),
+    resolver: zodResolver(assessmentDtoSchema),
     mode: "onTouched",
     defaultValues: initialValues,
   });

shared/src/assessment/assessment.schema.test.ts

@@ -1,7 +1,7 @@
 import { ZodError } from "zod";
 import { expectToEqual } from "../test.helpers";
 import { AssessmentDto, DateRange } from "./assessment.dto";
-import { assessmentSchema, withDateRangeSchema } from "./assessment.schema";
+import { assessmentDtoSchema, withDateRangeSchema } from "./assessment.schema";
 
 describe("Assessment schema date range", () => {
   it("accepts valid date range", () => {
@@ -46,7 +46,7 @@ describe("Assessment schema", () => {
       establishmentAdvices: "establishment advice",
       establishmentFeedback: "establishment feedback",
     };
-    const parsedAssessment = assessmentSchema.parse(assessment);
+    const parsedAssessment = assessmentDtoSchema.parse(assessment);
     expectToEqual(assessment, parsedAssessment);
   });
 
@@ -62,7 +62,7 @@ describe("Assessment schema", () => {
       establishmentAdvices: "establishment advices",
       establishmentFeedback: "establishment feedback",
     };
-    const parsedAssessment = assessmentSchema.parse(assessment);
+    const parsedAssessment = assessmentDtoSchema.parse(assessment);
     expectToEqual(assessment, parsedAssessment);
   });
 
@@ -74,7 +74,7 @@ describe("Assessment schema", () => {
       establishmentAdvices: "establishment advices",
       establishmentFeedback: "establishment feedback",
     };
-    const parsedAssessment = assessmentSchema.parse(assessment);
+    const parsedAssessment = assessmentDtoSchema.parse(assessment);
     expectToEqual(assessment, parsedAssessment);
   });
 
@@ -90,7 +90,7 @@ describe("Assessment schema", () => {
       establishmentAdvices: "my minimum establishment advices",
       establishmentFeedback: "my minimum establishment feedback",
     };
-    expect(() => assessmentSchema.parse(assessment)).toThrowError();
+    expect(() => assessmentDtoSchema.parse(assessment)).toThrowError();
   });
 });
 const expectDateRangeToFailWithError = (