Registration page (#365)

* filter v1

* gestion profils profil7 ET MS

* EJ/ET-MS IHM filters

* ET SAN front filters

* change notAuthrized title style

* mise en place de la table de reference departement region

* add codeRegion to updateET and updateEJ scripts

fix unit tests errors

* filter EJ data with user profil coming from database

* filter ET-MS data with user profil coming from database

* filter ET-SAN data with user profil coming from database

* combine profiles

* first draft of profiles

* correct combine profiles logic

* profiles tabs draft

* setting profiles new design

* get profiles from server

* get profile by code from server

* save profile changes in server

* save new profile in server

* correct unit tests

* secure ws get/add/update profile and make setting page authorized only for admins

* (hel-529) correct merge issues

* work in progress

* ws create account

* (hel-529) fix code issues

* add code profile to profiles list table and save default profile in db

* add profiles to ws create accout

* correct ws create account password save

---------

Co-authored-by: NbyDev <n.benyahia@cat-amania.com>

database/dataSource.ts

@@ -44,7 +44,7 @@ import { AjoutTableSearchHistory1691400360927 } from "./migrations/1691400360927
 import { AjoutRefDepartementRegion1694523233904 } from "./migrations/1694523233904-AjoutRefDepartementRegion";
 import { AjoutRégionDansEntitéJuridique1694616724703 } from "./migrations/1694616724703-AjoutRégionDansEntitéJuridique";
 import { AjoutRégionDansEtablissementTerritorial1694617579347 } from "./migrations/1694617579347-AjoutRégionDansEtablissementTerritorial";
-import { ajoutTableProfil1695731844298 } from "./migrations/1695731844278-ajoutTableProfil";
+import { ajoutTableProfil1795731844298 } from "./migrations/1795731844278-ajoutTableProfil";
 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";
@@ -147,7 +147,7 @@ export default new DataSource({
     AjoutRefDepartementRegion1694523233904,
     AjoutRégionDansEntitéJuridique1694616724703,
     AjoutRégionDansEtablissementTerritorial1694617579347,
-    ajoutTableProfil1695731844298,
+    ajoutTableProfil1795731844298,
   ],
   type: "postgres",
   url: environmentVariables.DATABASE_URL,

database/migrations/1695731844278-ajoutTableProfil.ts → database/migrations/1795731844278-ajoutTableProfil.ts

@@ -1,7 +1,8 @@
 import { MigrationInterface, QueryRunner } from "typeorm"
 
-export class ajoutTableProfil1695731844298 implements MigrationInterface {
+import { DefaultProfile } from "../../src/frontend/configuration/DefaultProfile";
 
+export class ajoutTableProfil1795731844298 implements MigrationInterface {
     public async up(queryRunner: QueryRunner): Promise<void> {
         await queryRunner.query(`
             CREATE TABLE public.profil(
@@ -13,6 +14,12 @@ export class ajoutTableProfil1695731844298 implements MigrationInterface {
                 profil_date_modification timestamp,
                 PRIMARY KEY (profil_id)
             );`);
+
+        await queryRunner.query(
+            `INSERT INTO public.profil(profil_label, profil_value, profil_date_creation) VALUES ($1, $2, $3)`,
+            ['Utilisateur lambda', DefaultProfile, new Date()]
+        );
+
     }
 
     public async down(queryRunner: QueryRunner): Promise<void> {

database/models/UtilisateurModel.ts

@@ -53,7 +53,7 @@ export class UtilisateurModel {
   @Column({ name: "ut_password", nullable: true })
   public password!: string;
 
-  @Column('simple-array', { nullable: true, name: "ut_profiles" })
+  @Column("text", { array: true, nullable: true, name: "ut_profiles" })
   public profils: string[] = [];
 
   @CreateDateColumn({ name: "ut_date_creation" })

src/backend/infrastructure/controllers/createAccountEndpoint.ts

@@ -0,0 +1,12 @@
+import { LoginUseCase } from "../../métier/use-cases/LoginUseCase";
+import { Dependencies } from "../dependencies";
+
+export async function createAccountEndpoint(dependencies: Dependencies, firstName: string, lastName: string, email: string, institution: string): Promise<void> {
+    try {
+        const loginUseCase = new LoginUseCase(dependencies.utilisateurLoader);
+        return await loginUseCase.createAccount(firstName, lastName, email, institution);
+    } catch (error) {
+        dependencies.logger.error(error);
+        throw error;
+    }
+}

src/backend/infrastructure/controllers/getInstitutionsEndpoint.ts

@@ -0,0 +1,13 @@
+import { Institution } from "../../métier/entities/Utilisateur/Institution";
+import { LoginUseCase } from "../../métier/use-cases/LoginUseCase";
+import { Dependencies } from "../dependencies";
+
+export async function getInstitutionsEndpoint(dependencies: Dependencies): Promise<Institution[]> {
+    try {
+        const loginUseCase = new LoginUseCase(dependencies.utilisateurLoader);
+        return await loginUseCase.getInstitutions();
+    } catch (error) {
+        dependencies.logger.error(error);
+        throw error;
+    }
+}

src/backend/infrastructure/gateways/utilisateur-loader/TypeOrmUtilisateurLoader.ts

@@ -1,11 +1,15 @@
-import { compare } from 'bcrypt';
+import { compare, genSalt, hash } from 'bcrypt';
 import { createHash } from 'crypto';
 import { DataSource } from "typeorm";
 
+import { InstitutionModel } from '../../../../../database/models/InstitutionModel';
 import { ProfilModel } from '../../../../../database/models/ProfilModel';
+import { RoleModel } from '../../../../../database/models/RoleModel';
 import { UtilisateurModel } from "../../../../../database/models/UtilisateurModel";
+import { Institution } from '../../../métier/entities/Utilisateur/Institution';
 import { RésultatLogin } from "../../../métier/entities/Utilisateur/RésultatLogin";
 import { UtilisateurLoader } from "../../../métier/gateways/UtilisateurLoader";
+import { sendEmail } from '../../../sendEmail';
 
 
 export class TypeOrmUtilisateurLoader implements UtilisateurLoader {
@@ -30,6 +34,51 @@ export class TypeOrmUtilisateurLoader implements UtilisateurLoader {
         } else return false;
     }
 
+    async getInstitutions(): Promise<Institution[]> {
+        const institutions = await (await this.orm).getRepository(InstitutionModel).find();
+        return institutions;
+    }
+
+    async createAccount(firstName: string, lastName: string, email: string, institution: string): Promise<void> {
+        try {
+            const account = new UtilisateurModel();
+
+            const institutionToSave = await (await this.orm).getRepository(InstitutionModel).findOneBy({ code: institution });
+            const roleToSave = await (await this.orm).getRepository(RoleModel).findOneBy({ code: 'USER' });
+            const profileToSave = await (await this.orm).getRepository(ProfilModel).findOneBy({ id: 1 });
+
+            const passwordToSave = 'HeliosConnect-' + institutionToSave?.codeGeo;
+
+            const salt = await genSalt(10);
+            const hashedPassword = await hash(passwordToSave, salt);
+
+            if (institutionToSave && roleToSave && profileToSave) {
+                account.nom = lastName;
+                account.prenom = firstName;
+                account.email = email;
+                account.institution = institutionToSave;
+                account.role = roleToSave;
+                account.password = hashedPassword;
+                account.profils = [profileToSave.code];
+                account.actif = true;
+                account.dateCreation = new Date();
+            }
+
+            (await this.orm).getRepository(UtilisateurModel).save(account)
+                .then(async () => {
+                    sendEmail(email, 'Creation de compte Helios', 'hello')
+                })
+                .catch((error) => {
+                    // eslint-disable-next-line no-console
+                    console.log("error", error);
+                });
+
+        } catch (error) {
+            // eslint-disable-next-line no-console
+            console.log("error", error);
+        }
+    }
+
     async checkIfAdmin(userId: string): Promise<boolean> {
         const user = await (await this.orm).getRepository(UtilisateurModel).findOneBy({ code: userId.trim() });
         if (user && user.roleId === '1') {

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

@@ -1,9 +1,12 @@
 import { ProfilModel } from "../../../../database/models/ProfilModel";
+import { Institution } from "../entities/Utilisateur/Institution";
 import { RésultatLogin } from "../entities/Utilisateur/RésultatLogin";
 
 export interface UtilisateurLoader {
   login(email: string, password: string): Promise<RésultatLogin>;
   checkIfEmailExists(email: string): Promise<boolean>;
+  getInstitutions(): Promise<Institution[]>;
+  createAccount(firstName: string, lastName: string, email: string, institution: string): Promise<void>;
   getUserProfiles(codes: string[]): Promise<ProfilModel[] | null>;
   checkIfAdmin(userId: string): Promise<boolean>
 }

src/backend/métier/use-cases/LoginUseCase.ts

@@ -1,4 +1,5 @@
 import { ProfilModel } from "../../../../database/models/ProfilModel";
+import { Institution } from "../entities/Utilisateur/Institution";
 import { RésultatLogin } from "../entities/Utilisateur/RésultatLogin";
 import { UtilisateurLoader } from "../gateways/UtilisateurLoader";
 
@@ -13,6 +14,15 @@ export class LoginUseCase {
     return await this.utilisateurLoader.checkIfEmailExists(email);
   }
 
+  async getInstitutions(): Promise<Institution[]> {
+    return await this.utilisateurLoader.getInstitutions();
+  }
+
+  async createAccount(firstName: string, lastName: string, email: string, institution: string): Promise<void> {
+
+    return this.utilisateurLoader.createAccount(firstName, lastName, email, institution);
+  }
+
   async checkIfAdmin(userId: string): Promise<boolean> {
     return await this.utilisateurLoader.checkIfAdmin(userId);
   }

src/backend/sendEmail.ts

@@ -0,0 +1,29 @@
+const buildEmailBody = (receiver: string, subject: string, htmlBody: string) => {
+    const body = {
+        to: [
+            {
+                address: receiver,
+            }
+        ],
+        msg: {
+            from: {
+                personalName: process.env['TIPIMAIL_SENDER_NAME'],
+                address: process.env['TIPIMAIL_SENDER_ADDRESS']
+            },
+            subject: subject,
+            html: htmlBody
+
+        }
+    }
+    return JSON.stringify(body);
+}
+
+export const sendEmail = async (receiver: string, subject: string, htmlBody: string) => await fetch('https://api.tipimail.com/v1/messages/send', {
+    method: 'POST',
+    headers: {
+        'Content-Type': 'application/json',
+        'X-Tipimail-ApiUser': process.env['TIPIMAIL_APIUSER'] || '',
+        'X-Tipimail-ApiKey': process.env['TIPIMAIL_APIKEY'] || ''
+    },
+    body: buildEmailBody(receiver, subject, htmlBody)
+});