feat: 1084 agrement etape un

Author: admin

.talismanrc

@@ -229,6 +229,10 @@ fileignoreconfig:
     checksum: 8513c95ff253eb7ef038d5cdd5aff7d09b478c31409ea5644cd0081afbf6428e
   - filename: packages/frontend-usagers/src/components/address/search-address.vue
     checksum: e22412a54064dea24f7e200e9887726a4ef110f13570feea628c70c4fe2886a9
+  - filename: packages/frontend-usagers/src/components/agrement/personne-morale.vue
+    checksum: 76de358518d21d7cf5b522e31979b676147585540098a1419976d0120edaac93
+  - filename: packages/frontend-usagers/src/components/agrement/representants.vue
+    checksum: e1944c26baf528554fbfb052068ccbdf9ac9b158b5152760fae9b2bc0858b4e9
   - filename: packages/frontend-usagers/src/components/customInput.vue
     checksum: ff3d0adca5a28cd4e4c25ed981250d5b8e253f8554ad4ec7280a2b05900faf33
   - filename: packages/frontend-usagers/src/components/demande-sejour/table.vue

packages/backend/src/controllers/__tests__/agrement.get.test.ts

@@ -0,0 +1,82 @@
+import type { Request, Response } from "express";
+
+import getByOrganismeIdController from "../../controllers/agrement"; // ton contrôleur
+import getByOrganismeIdService from "../../services/agrements/Agrements";
+import AppError from "../../utils/error";
+
+// On mocke les dépendances
+jest.mock("../../services/agrements/Agrements");
+jest.mock("../../utils/logger", () => () => ({
+  d: jest.fn(),
+  i: jest.fn(),
+  w: jest.fn(),
+}));
+
+describe("🧪 Controller: agrement.getByOrganismeId", () => {
+  const mockReq = {} as Request;
+  const mockRes = {} as Response;
+  const mockNext = jest.fn();
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockRes.json = jest.fn().mockReturnValue(mockRes);
+  });
+
+  it("Renvoie le résultat du service avec un ID valide", async () => {
+    (getByOrganismeIdService as jest.Mock).mockResolvedValue({
+      agrement: { id: 1, organismeId: 42 },
+    });
+
+    mockReq.params = { id: "42" };
+
+    await getByOrganismeIdController.getByOrganismeId(
+      mockReq as any,
+      mockRes,
+      mockNext,
+    );
+
+    expect(getByOrganismeIdService).toHaveBeenCalledWith({ organismeId: 42 });
+    expect(mockRes.json).toHaveBeenCalledWith({
+      agrement: { id: 1, organismeId: 42 },
+    });
+    expect(mockNext).not.toHaveBeenCalled();
+  });
+
+  it("Appelle next avec une AppError si l'id est invalide", async () => {
+    mockReq.params = { id: "abc" };
+
+    await getByOrganismeIdController.getByOrganismeId(
+      mockReq as any,
+      mockRes,
+      mockNext,
+    );
+
+    expect(getByOrganismeIdService).not.toHaveBeenCalled();
+    expect(mockNext).toHaveBeenCalledTimes(1);
+
+    const error = mockNext.mock.calls[0][0];
+    expect(error).toBeInstanceOf(AppError);
+    expect(error.message).toBe("Paramètre incorrect");
+    expect(error.statusCode).toBe(400);
+  });
+
+  it("Appelle next si le service lève une erreur", async () => {
+    (getByOrganismeIdService as jest.Mock).mockRejectedValue(
+      new Error("DB fail"),
+    );
+    mockReq.params = { id: "10" };
+
+    await getByOrganismeIdController.getByOrganismeId(
+      mockReq as any,
+      mockRes,
+      mockNext,
+    );
+
+    expect(getByOrganismeIdService).toHaveBeenCalledWith({ organismeId: 10 });
+    expect(mockNext).toHaveBeenCalledTimes(1);
+
+    const error = mockNext.mock.calls[0][0];
+    expect(error).toBeInstanceOf(Error);
+    expect(error.message).toBe("DB fail");
+  });
+});

packages/backend/src/controllers/agrement/getByOrganismeId.ts

@@ -0,0 +1,37 @@
+import type { NextFunction, Response } from "express";
+
+import getByOrganismeId from "../../services/agrements/Agrements";
+import type { UserRequest } from "../../types/request";
+import AppError from "../../utils/error";
+import logger from "../../utils/logger";
+
+const log = logger(module.filename);
+
+export default async function get(
+  req: UserRequest,
+  res: Response,
+  next: NextFunction,
+) {
+  log.i("IN");
+  const organismeId = Number(req.params.id);
+
+  if (Number.isNaN(organismeId)) {
+    log.w("missing or invalid parameter");
+    return next(
+      new AppError("Paramètre incorrect", {
+        statusCode: 400,
+      }),
+    );
+  }
+
+  try {
+    const { agrement } = await getByOrganismeId({
+      organismeId,
+    });
+    log.d(agrement);
+    res.json({ agrement });
+  } catch (error) {
+    log.w("DONE with error");
+    next(error);
+  }
+}

packages/backend/src/repositories/usagers/Agrements.ts

@@ -0,0 +1,27 @@
+import Logger from "../../utils/logger";
+import { getPool } from "../../utils/pgpool";
+
+const log = Logger(module.filename);
+
+const pool = getPool();
+
+export const AgrementsRepository = {
+  getByOrganismeId: async ({ organismeId }: { organismeId: number }) => {
+    log.i("getByOrganismeId - IN");
+
+    const query = () => `
+        SELECT
+            *
+        FROM
+        front.agrements agr
+        WHERE
+            agr.organisme_id = $1
+        `;
+    const response = await pool.query(query(), [organismeId]);
+    log.i("getAdminStats - DONE");
+
+    return {
+      agrement: response.rows[0],
+    };
+  },
+};

packages/backend/src/routes/__tests__/agrement/agrement.test.ts

@@ -0,0 +1,49 @@
+import express from "express";
+import request from "supertest";
+
+import agrementController from "../../../controllers/agrement";
+import checkJWT from "../../../middlewares/checkJWT";
+import checkPermissionAgrement from "../../../middlewares/checkPermissionAgrement";
+import router from "../../agrement";
+
+// 🧱 On mocke les middlewares et le contrôleur
+jest.mock("../../../middlewares/checkJWT", () =>
+  jest.fn((req, res, next) => next()),
+);
+jest.mock("../../../middlewares/checkPermissionAgrement", () =>
+  jest.fn((req, res, next) => next()),
+);
+jest.mock("../../../controllers/agrement", () => ({
+  getByOrganismeId: jest.fn((req, res) => res.status(200).json({ ok: true })),
+  post: jest.fn((req, res) => res.status(201).json({ created: true })),
+}));
+
+const app = express();
+app.use(express.json());
+app.use("/agrement", router);
+
+describe("🧪 Routes /agrement", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("GET /agrement/organisme/:id appelle les middlewares et le contrôleur", async () => {
+    const res = await request(app).get("/agrement/organisme/123");
+
+    expect(checkJWT).toHaveBeenCalled();
+    expect(checkPermissionAgrement).toHaveBeenCalled();
+    expect(agrementController.getByOrganismeId).toHaveBeenCalled();
+    expect(res.status).toBe(200);
+    expect(res.body).toEqual({ ok: true });
+  });
+
+  it("POST /agrement appelle les middlewares et le contrôleur post", async () => {
+    const res = await request(app).post("/agrement").send({ organismeId: 42 });
+
+    expect(checkJWT).toHaveBeenCalled();
+    expect(checkPermissionAgrement).toHaveBeenCalled();
+    expect(agrementController.post).toHaveBeenCalled();
+    expect(res.status).toBe(201);
+    expect(res.body).toEqual({ created: true });
+  });
+});

packages/backend/src/routes/agrement.ts

@@ -0,0 +1,18 @@
+import express from "express";
+
+import agrementController from "../controllers/agrement";
+import checkJWT from "../middlewares/checkJWT";
+import checkPermissionAgrement from "../middlewares/checkPermissionAgrement";
+
+const router = express.Router();
+
+router.get(
+  "/organisme/:id",
+  checkJWT,
+  checkPermissionAgrement,
+  agrementController.getByOrganismeId,
+);
+
+router.post("/", checkJWT, checkPermissionAgrement, agrementController.post);
+
+export default router;

packages/backend/src/routes/index.js

@@ -9,7 +9,6 @@ module.exports.organisme = require("./organisme");
 module.exports.siret = require("./siret");
 module.exports.sejour = require("./sejour");
 module.exports.hebergement = require("./hebergement").default;
-
 module.exports.message = require("./message");
 module.exports.territoire = require("./territoire");
 

packages/backend/src/services/__tests__/Agrements.test.ts

@@ -0,0 +1,58 @@
+import type { AgrementsDto } from "../../dto/AgrementsDto";
+import { AgrementsRepository } from "../../repositories/usagers/Agrements";
+import getByOrganismeId from "../agrements/Agrements";
+
+// On mocke le module repository
+jest.mock("../../repositories/usagers/Agrements", () => ({
+  AgrementsRepository: {
+    getByOrganismeId: jest.fn(),
+  },
+}));
+
+describe("Service: getByOrganismeId", () => {
+  const mockAgrement: AgrementsDto = {
+    dateDebut: "2025-01-01",
+    dateFin: "2025-12-31",
+    id: 123,
+    organismeId: 1,
+    statut: "VALIDE",
+  } as unknown as AgrementsDto;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("devrait appeler AgrementsRepository.getByOrganismeId avec le bon id", async () => {
+    (AgrementsRepository.getByOrganismeId as jest.Mock).mockResolvedValue({
+      agrement: mockAgrement,
+    });
+
+    const organismeId = 42;
+    await getByOrganismeId({ organismeId });
+
+    expect(AgrementsRepository.getByOrganismeId).toHaveBeenCalledTimes(1);
+    expect(AgrementsRepository.getByOrganismeId).toHaveBeenCalledWith({
+      organismeId,
+    });
+  });
+
+  it("devrait retourner un objet contenant l'agrement", async () => {
+    (AgrementsRepository.getByOrganismeId as jest.Mock).mockResolvedValue({
+      agrement: mockAgrement,
+    });
+
+    const result = await getByOrganismeId({ organismeId: 99 });
+
+    expect(result).toEqual({ agrement: mockAgrement });
+  });
+
+  it("devrait propager une erreur si le repository échoue", async () => {
+    (AgrementsRepository.getByOrganismeId as jest.Mock).mockRejectedValue(
+      new Error("Erreur DB"),
+    );
+
+    await expect(getByOrganismeId({ organismeId: 10 })).rejects.toThrow(
+      "Erreur DB",
+    );
+  });
+});

packages/backend/src/services/agrements/Agrements.ts

@@ -0,0 +1,15 @@
+import { AgrementsDto } from "../../dto/AgrementsDto";
+import { AgrementsRepository } from "../../repositories/usagers/Agrements";
+
+export default async function getByOrganismeId({
+  organismeId,
+}: {
+  organismeId: number;
+}) {
+  const { agrement }: { agrement: AgrementsDto } =
+    await AgrementsRepository.getByOrganismeId({
+      organismeId,
+    });
+
+  return { agrement };
+}

packages/frontend-usagers/src/components/agrement/MenuAgrement.vue

@@ -0,0 +1,48 @@
+<template>
+  <DsfrSideMenu heading-title="">
+    <DsfrSideMenuList
+      id="agrement-menu-list"
+      :menu-items="sommaireOptionsToDisplay"
+      @select="onSelect"
+    />
+  </DsfrSideMenu>
+</template>
+
+<script setup>
+const props = defineProps({
+  activeId: { type: String, default: "coordonnees", required: false },
+});
+
+const emit = defineEmits(["select"]);
+
+const menus = [
+  {
+    id: "coordonnees",
+    text: "Coordonnées à vérifier",
+    to: { hash: "#coordonnees" },
+  },
+  { id: "dossier", text: "Dossier de candidature", to: { hash: "#dossier" } },
+  {
+    id: "bilan",
+    text: "Bilan des 4 années précédentes",
+    to: { hash: "#bilan" },
+  },
+  {
+    id: "projets",
+    text: "Projets de séjours envisagés pour les 12 prochains mois",
+    to: { hash: "#projets" },
+  },
+  { id: "synthese", text: "Synthèse", to: { hash: "#synthese" } },
+];
+
+const sommaireOptionsToDisplay = computed(() =>
+  menus.map((menu) => ({
+    ...menu,
+    active: menu.id === props.activeId,
+  })),
+);
+
+function onSelect(idx) {
+  emit("select", menus[idx].id);
+}
+</script>