Hel 509/search history

database/dataSource.ts

@@ -38,7 +38,9 @@ import { AjouterBlocBudgetFinanceEJ1677495763184 } from "./migrations/1677495763
 import { AjouteHAD1680014929754 } from "./migrations/1680014929754-AjouteHAD";
 import { AjoutCapacitesSanitaireEJ1680076022425 } from "./migrations/1680076022425-AjoutCapacitesSanitaireEJ";
 import { AjoutTableUtilisateurRoleEtablissement1686646154737 } from "./migrations/1686646154737-AjoutTableUtilisateurRoleEtablissement";
-import { ModificationTableInstitution1688376404752 } from "./migrations/1688376404752-ModificationTableInstitution"
+import { ModificationTableInstitution1688376404752 } from "./migrations/1688376404752-ModificationTableInstitution";
+import { AjoutTableFavori1691393817990 } from "./migrations/1691393817990-AjoutTableFavori";
+import { AjoutTableSearchHistory1691400360927 } from "./migrations/1691400360927-AjoutTableSearchHistory";
 import { ActivitéMédicoSocialModel } from "./models/ActivitéMédicoSocialModel";
 import { ActivitéSanitaireEntitéJuridiqueModel } from "./models/ActivitéSanitaireEntitéJuridiqueModel";
 import { ActivitéSanitaireModel } from "./models/ActivitéSanitaireModel";
@@ -52,11 +54,13 @@ import { CapacitéAutorisationSanitaireModel } from "./models/CapacitéAutorisat
 import { CpomModel } from "./models/CpomModel";
 import { DateMiseÀJourFichierSourceModel } from "./models/DateMiseÀJourFichierSourceModel";
 import { EntitéJuridiqueModel } from "./models/EntitéJuridiqueModel";
+import { FavorisModel } from "./models/FavorisModel";
 import { InstitutionModel } from "./models/InstitutionModel";
 import { RechercheModel } from "./models/RechercheModel";
 import { ReconnaissanceContractuelleSanitaireModel } from "./models/ReconnaissanceContractuelleSanitaireModel";
 import { RessourcesHumainesMédicoSocialModel } from "./models/RessourcesHumainesMédicoSocialModel";
 import { RoleModel } from "./models/RoleModel";
+import { SearchHistoryModel } from "./models/SearchHistoryModel";
 import { UtilisateurModel } from "./models/UtilisateurModel";
 import { ÉquipementMatérielLourdSanitaireModel } from "./models/ÉquipementMatérielLourdSanitaireModel";
 import { ÉtablissementTerritorialIdentitéModel } from "./models/ÉtablissementTerritorialIdentitéModel";
@@ -79,6 +83,7 @@ export default new DataSource({
     CpomModel,
     DateMiseÀJourFichierSourceModel,
     EntitéJuridiqueModel,
+    FavorisModel,
     ÉquipementMatérielLourdSanitaireModel,
     ÉtablissementTerritorialIdentitéModel,
     RechercheModel,
@@ -88,6 +93,7 @@ export default new DataSource({
     UtilisateurModel,
     RoleModel,
     InstitutionModel,
+    SearchHistoryModel,
   ],
   logger: "debug",
   logging: [environmentVariables.ORM_DEBUG] as LoggerOptions,
@@ -126,6 +132,8 @@ export default new DataSource({
     AjouterBlocBudgetFinanceEJ1677495763184,
     AjoutCapacitesSanitaireEJ1680076022425,
     AjouteHAD1680014929754,
+    AjoutTableSearchHistory1691400360927,
+    AjoutTableFavori1691393817990,
     AjoutTableUtilisateurRoleEtablissement1686646154737,
     ModificationTableInstitution1688376404752,
   ],

database/migrations/1691393817990-AjoutTableFavori.ts

@@ -0,0 +1,28 @@
+import { MigrationInterface, QueryRunner } from "typeorm"
+
+export class AjoutTableFavori1691393817990 implements MigrationInterface {
+
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`
+            CREATE TABLE public.favori(
+                fav_id bigserial NOT NULL,
+                user_id uuid NOT NULL,
+                type character varying(255) NOT NULL,
+                finess_number character varying(255),
+                social_reason character varying(255) NOT NULL,
+                commune character varying(255) NOT NULL,
+                departement character varying(255) NOT NULL,
+
+                PRIMARY KEY (fav_id),
+
+                constraint favori_user_id_fkey foreign key (user_id) references public.utilisateur(ut_code)
+            );`);
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`
+            DROP TABLE public.favori;
+        `);
+    }
+
+}

database/migrations/1691400360927-AjoutTableSearchHistory.ts

@@ -0,0 +1,26 @@
+import { MigrationInterface, QueryRunner } from "typeorm"
+
+export class AjoutTableSearchHistory1691400360927 implements MigrationInterface {
+
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`
+            CREATE TABLE public.search_history(
+                id bigserial NOT NULL,
+                user_id uuid NOT NULL,
+                title character varying(255) NOT NULL,
+                finess_number character varying(255) NOT NULL,
+                date timestamp NOT NULL,
+                type character varying(255) NOT NULL,
+                PRIMARY KEY (id),
+
+                constraint search_history_user_id_fkey foreign key (user_id) references public.utilisateur(ut_code)
+            );`);
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`
+            DROP TABLE public.search_history;
+        `);
+    }
+
+}

database/models/FavorisModel.ts

@@ -0,0 +1,32 @@
+import { Entity, PrimaryGeneratedColumn, Column, ManyToOne, JoinColumn } from "typeorm";
+
+import { UtilisateurModel } from "./UtilisateurModel";
+
+@Entity({ name: "favori" })
+export class FavorisModel {
+    @PrimaryGeneratedColumn({ name: "fav_id" })
+    public id!: number;
+
+    @Column({ name: "finess_number" })
+    public finessNumber!: string;
+
+    @Column({ name: 'type' })
+    public type!: string;
+
+    @Column({ name: 'user_id' })
+    public userId!: string;
+
+    @Column({ name: 'social_reason' })
+    public socialReason!: string;
+
+    @Column({ name: 'commune' })
+    public commune!: string;
+
+    @Column({ name: 'departement' })
+    public departement!: string;
+
+    @ManyToOne(() => UtilisateurModel)
+    @JoinColumn({ name: "user_id", referencedColumnName: "id" })
+    public user!: UtilisateurModel;
+
+}

database/models/SearchHistoryModel.ts

@@ -0,0 +1,29 @@
+import { Entity, PrimaryGeneratedColumn, Column, ManyToOne, JoinColumn } from "typeorm";
+
+import { UtilisateurModel } from "./UtilisateurModel";
+
+@Entity({ name: "search_history" })
+export class SearchHistoryModel {
+    @PrimaryGeneratedColumn({ name: "id" })
+    public id!: number;
+
+    @Column({ name: "title" })
+    public title!: string;
+
+    @Column({ name: "finess_number" })
+    public finessNumber!: string;
+
+    @Column({ name: "type" })
+    public type!: string;
+
+    @Column({ name: "date" })
+    public date!: Date;
+
+    @Column({ name: 'user_id' })
+    public userId!: string;
+
+    @ManyToOne(() => UtilisateurModel)
+    @JoinColumn({ name: "user_id", referencedColumnName: "id" })
+    public user!: UtilisateurModel;
+
+}

src/backend/infrastructure/controllers/addToFavorisEndpoint.ts

@@ -0,0 +1,15 @@
+import { AddToFavorisUseCase } from "../../métier/use-cases/FavorisUseCase";
+import { Dependencies } from "../dependencies";
+
+export async function addToFavorisEndpoint(dependencies: Dependencies, finessNumber: string, type: string, idUser: number, commune: string, departement: string, socialReason
+    : string): Promise<void> {
+    try {
+        const addToFavorisUseCase = new AddToFavorisUseCase(dependencies.favorisLoader);
+        const userId = idUser.toString();
+
+        return await addToFavorisUseCase.exécute(finessNumber, type, userId, commune, departement, socialReason);
+    } catch (error) {
+        dependencies.logger.error(error);
+        throw error;
+    }
+}

src/backend/infrastructure/controllers/getAllFavorisEndpoint.ts

@@ -0,0 +1,13 @@
+import { FavorisModel } from "../../../../database/models/FavorisModel";
+import { GetAllFavorisUseCase } from "../../métier/use-cases/FavorisUseCase";
+import { Dependencies } from "../dependencies";
+
+export async function getAllFavorisEndpoint(dependencies: Dependencies, idUser: string): Promise<FavorisModel[]> {
+    try {
+        const getAllFavorisUseCase = new GetAllFavorisUseCase(dependencies.favorisLoader);
+        return await getAllFavorisUseCase.exécute(idUser);
+    } catch (error) {
+        dependencies.logger.error(error);
+        throw error;
+    }
+}

src/backend/infrastructure/controllers/getAllUserSearchHistory.ts

@@ -0,0 +1,13 @@
+import { SearchHistoryModel } from "../../../../database/models/SearchHistoryModel";
+import { GetAllUserSearchHistoryUseCase } from "../../métier/use-cases/SearchHistoryUseCase";
+import { Dependencies } from "../dependencies";
+
+export async function getAllUserSearchHistoryEndpoint(dependencies: Dependencies, idUser: string): Promise<SearchHistoryModel[]> {
+    try {
+        const getAllUserSearchHistoryUseCase = new GetAllUserSearchHistoryUseCase(dependencies.searchHistoryLoader);
+        return await getAllUserSearchHistoryUseCase.exécute(idUser);
+    } catch (error) {
+        dependencies.logger.error(error);
+        throw error;
+    }
+}

src/backend/infrastructure/controllers/removeFromFavorisEndpoint.ts

@@ -0,0 +1,13 @@
+import { RemoveFromFavorisUseCase } from "../../métier/use-cases/FavorisUseCase";
+import { Dependencies } from "../dependencies";
+
+export async function removeFromFavorisEndpoint(dependencies: Dependencies, idUser: number, finessNumber: string): Promise<void> {
+    try {
+        const removeFromFavorisUseCase = new RemoveFromFavorisUseCase(dependencies.favorisLoader);
+        const userId = idUser.toString();
+        return await removeFromFavorisUseCase.exécute(userId, finessNumber);
+    } catch (error) {
+        dependencies.logger.error(error);
+        throw error;
+    }
+}

src/backend/infrastructure/controllers/saveSearchHistoryEndpoint.ts

@@ -0,0 +1,13 @@
+import { SaveSearchHistoryUseCase } from "../../métier/use-cases/SearchHistoryUseCase";
+import { Dependencies } from "../dependencies";
+
+export async function saveSearchHistoryEndpoint(dependencies: Dependencies, titre: string, idUser: string, finessNumber: string, type: string): Promise<void> {
+    try {
+        const saveSearchHistoryUseCase = new SaveSearchHistoryUseCase(dependencies.searchHistoryLoader);
+
+        return await saveSearchHistoryUseCase.exécute(titre, idUser, finessNumber, type);
+    } catch (error) {
+        dependencies.logger.error(error);
+        throw error;
+    }
+}

src/backend/infrastructure/dependencies.ts

@@ -3,8 +3,10 @@ import * as Sentry from "@sentry/nextjs";
 import { ChangePasswordLoader } from "../métier/gateways/ChangePasswordLoader";
 import { EntitéJuridiqueLoader } from "../métier/gateways/EntitéJuridiqueLoader";
 import { EnvironmentVariables } from "../métier/gateways/EnvironmentVariables";
+import { FavorisLoader } from "../métier/gateways/FavorisLoader";
 import { Logger } from "../métier/gateways/Logger";
 import { RechercheLoader } from "../métier/gateways/RechercheLoader";
+import { SearchHistoryLoader } from "../métier/gateways/SearchHistoryLoader";
 import { UtilisateurLoader } from "../métier/gateways/UtilisateurLoader";
 import { ÉtablissementTerritorialMédicoSocialLoader } from "../métier/gateways/ÉtablissementTerritorialMédicoSocialLoader";
 import { ÉtablissementTerritorialRattachéLoader } from "../métier/gateways/ÉtablissementTerritorialRattachéLoader";
@@ -13,10 +15,12 @@ import { TypeOrmChangePasswordLoader } from "./gateways/change-password-loader/T
 import { dotEnvConfig } from "./gateways/dot-env/dotEnvConfig";
 import { TypeOrmEntitéJuridiqueLoader } from "./gateways/entité-juridique-loader/TypeOrmEntitéJuridiqueLoader";
 import { NodeEnvironmentVariables } from "./gateways/environnement-variables/NodeEnvironmentVariables";
+import { TypeOrmFavorisLoader } from "./gateways/favoris-loader/TypeOrmFavorisLoader";
 import { TypeOrmForgetPasswordLoader } from "./gateways/forget-password-loader/TypeOrmForgetPasswordLoader";
 import { ConsoleLogger } from "./gateways/logger/ConsoleLogger";
 import { typeOrmOrm } from "./gateways/orm/typeOrmOrm";
 import { TypeOrmRechercheLoader } from "./gateways/recherche-loader/TypeOrmRechercheLoader";
+import { TypeOrmSearchHistoryLoader } from "./gateways/search-history-loader/TypeOrmSearchHistoryLoader";
 import { TypeOrmUtilisateurLoader } from "./gateways/utilisateur-loader/TypeOrmUtilisateurLoader";
 import { TypeOrmÉtablissementTerritorialMédicoSocialLoader } from "./gateways/établissement-territorial-loader/TypeOrmÉtablissementTerritorialMédicoSocialLoader";
 import { TypeOrmÉtablissementTerritorialRattachéLoader } from "./gateways/établissement-territorial-loader/TypeOrmÉtablissementTerritorialRattachéLoader";
@@ -31,8 +35,10 @@ export type Dependencies = Readonly<{
   établissementTerritorialMédicoSocialLoader: ÉtablissementTerritorialMédicoSocialLoader;
   établissementTerritorialRattachéLoader: ÉtablissementTerritorialRattachéLoader;
   établissementTerritorialSanitaireLoader: ÉtablissementTerritorialSanitaireLoader;
+  favorisLoader: FavorisLoader;
   changePasswordLoader: ChangePasswordLoader;
-  forgetPasswordLoader : TypeOrmForgetPasswordLoader;
+  forgetPasswordLoader: TypeOrmForgetPasswordLoader;
+  searchHistoryLoader: SearchHistoryLoader
 }>;
 
 const createDependencies = (): Dependencies => {
@@ -56,8 +62,10 @@ const createDependencies = (): Dependencies => {
     établissementTerritorialMédicoSocialLoader: new TypeOrmÉtablissementTerritorialMédicoSocialLoader(orm),
     établissementTerritorialRattachéLoader: new TypeOrmÉtablissementTerritorialRattachéLoader(orm),
     établissementTerritorialSanitaireLoader: new TypeOrmÉtablissementTerritorialSanitaireLoader(orm),
+    favorisLoader: new TypeOrmFavorisLoader(orm),
     changePasswordLoader: new TypeOrmChangePasswordLoader(orm),
-    forgetPasswordLoader : new  TypeOrmForgetPasswordLoader(orm)
+    forgetPasswordLoader: new TypeOrmForgetPasswordLoader(orm),
+    searchHistoryLoader: new TypeOrmSearchHistoryLoader(orm)
   };
 };
 

src/backend/infrastructure/gateways/favoris-loader/TypeOrmFavorisLoader.ts

@@ -0,0 +1,29 @@
+import { DataSource } from "typeorm";
+
+import { FavorisModel } from "../../../../../database/models/FavorisModel";
+import { FavorisLoader } from "../../../métier/gateways/FavorisLoader";
+
+export class TypeOrmFavorisLoader implements FavorisLoader {
+    constructor(private readonly orm: Promise<DataSource>) { }
+
+
+    async addToFavoris(finessNumber: string, type: string, idUser: string, commune: string, departement: string, socialReason
+        : string) {
+        const favori = new FavorisModel();
+        favori.finessNumber = finessNumber;
+        favori.type = type;
+        favori.userId = idUser;
+        favori.commune = commune;
+        favori.departement = departement;
+        favori.socialReason = socialReason;
+        await (await this.orm).getRepository(FavorisModel).save(favori);
+    }
+
+    async removeFromFavoris(idUser: string, finessNumber: string) {
+        await (await this.orm).getRepository(FavorisModel).delete({ userId: idUser, finessNumber: finessNumber });
+    }
+
+    async getAllFavoris(idUser: string): Promise<FavorisModel[]> {
+        return await (await this.orm).getRepository(FavorisModel).find({ where: { userId: idUser } });
+    }
+}

src/backend/infrastructure/gateways/search-history-loader/TypeOrmSearchHistoryLoader.ts

@@ -0,0 +1,38 @@
+import { DataSource } from "typeorm";
+
+import { SearchHistoryModel } from "../../../../../database/models/SearchHistoryModel";
+import { SearchHistoryLoader } from "../../../métier/gateways/SearchHistoryLoader";
+
+export class TypeOrmSearchHistoryLoader implements SearchHistoryLoader {
+    constructor(private readonly orm: Promise<DataSource>) { }
+
+
+    async saveSearchHistory(title: string, idUser: string, finessNumber: string, type: string) {
+        const history = await (await this.orm).getRepository(SearchHistoryModel).findOne({ where: { userId: idUser, finessNumber: finessNumber } });
+        if (history) {
+            await (await this.orm).getRepository(SearchHistoryModel).update(history.id, { date: new Date() });
+        } else {
+            // make sure to keep only the last 10 search
+            const count = await (await this.orm).getRepository(SearchHistoryModel).countBy({ userId: idUser });
+            const searchHistory = new SearchHistoryModel();
+            searchHistory.date = new Date();
+            searchHistory.finessNumber = finessNumber;
+            searchHistory.title = title;
+            searchHistory.userId = idUser;
+            searchHistory.type = type;
+            if (count === 10) {
+                // delete the oldest line
+                const oldestElement = await (await this.orm).getRepository(SearchHistoryModel).findOne({
+                    where: { userId: idUser },
+                    order: { date: 'ASC' },
+                });
+                if (oldestElement) await (await this.orm).getRepository(SearchHistoryModel).remove(oldestElement);
+            }
+            await (await this.orm).getRepository(SearchHistoryModel).save(searchHistory);
+        }
+    }
+
+    async getAllUserSearchHistory(idUser: string) {
+        return await (await this.orm).getRepository(SearchHistoryModel).find({ where: { userId: idUser }, order: { date: 'DESC' } });
+    }
+}

src/backend/métier/gateways/FavorisLoader.ts

@@ -0,0 +1,7 @@
+import { FavorisModel } from "../../../../database/models/FavorisModel";
+
+export interface FavorisLoader {
+    addToFavoris(finessNumber: string, type: string, idUser: string, commune: string, departement: string, social_reason: string): Promise<void>;
+    removeFromFavoris(idUser: string, finessNumber: string): Promise<void>;
+    getAllFavoris(idUser: string): Promise<FavorisModel[]>;
+}

src/backend/métier/gateways/SearchHistoryLoader.ts

@@ -0,0 +1,6 @@
+import { SearchHistoryModel } from "../../../../database/models/SearchHistoryModel";
+
+export interface SearchHistoryLoader {
+    saveSearchHistory(titre: string, idUser: string, finessNumber: string, type: string): Promise<void>;
+    getAllUserSearchHistory(idUser: string): Promise<SearchHistoryModel[]>
+}