Exclude test

.drone.yml

@@ -0,0 +1,79 @@
+kind: pipeline
+type: docker
+name: default
+ 
+trigger:
+  event:
+    - push
+
+steps:
+  - name: build
+    image: mcr.microsoft.com/dotnet/sdk:8.0
+    commands:
+      - cd VeraxShield
+      - dotnet restore VeraxShield.sln
+      - dotnet build VeraxShield.sln -c Release --no-restore
+      - dotnet publish VeraxShield.sln -c Release --no-restore -o $CI_PROJECT_DIR/build/release
+
+  - name: tests
+    image: mcr.microsoft.com/dotnet/sdk:8.0
+    commands:
+      - cd VeraxShield
+      - dotnet restore VeraxShield.sln
+      - dotnet test VeraxShield.sln --no-restore
+    depends_on: [build]
+
+  - name: code-inspection
+    image: hub.codefirst.iut.uca.fr/marc.chevaldonne/codefirst-dronesonarplugin-dotnet8
+    secrets: [ SECRET_SONAR_LOGIN ]
+    environment:
+      sonar_host: https://codefirst.iut.uca.fr/sonar/
+      sonar_token:
+        from_secret: SECRET_SONAR_LOGIN # Secret de Drone
+      project_key: VeraxShield
+      
+    commands:
+      - cd VeraxShield/
+      - dotnet restore VeraxShield.sln
+      - dotnet sonarscanner begin /k:$${project_key} /d:sonar.host.url=$${sonar_host} /d:sonar.coverageReportPaths="coveragereport/SonarQube.xml" /d:sonar.coverage.exclusions="VeraxShield/wwwroot/**","VeraxShield/composants/**","VeraxShield/pages/**","VeraxShield/Properties/**","TestVeraxShield/**","VeraxShield/Program.cs","VeraxShield/services/UtilisateursDataService/UtilisateursDataServiceApi.cs","VeraxShield/services/UtilisateursDataService/UtilisateursDataServiceFactice.cs" /d:sonar.login=$${sonar_token} 
+      - dotnet build VeraxShield.sln -c Release --no-restore
+      - dotnet test VeraxShield.sln --logger trx --no-restore /p:CollectCoverage=true /p:CoverletOutputFormat=cobertura --collect "XPlat Code Coverage"
+      - reportgenerator -reports:"**/coverage.cobertura.xml" -reporttypes:SonarQube -targetdir:"coveragereport"
+      - dotnet publish VeraxShield.sln -c Release --no-restore -o $CI_PROJECT_DIR/build/release
+      - dotnet sonarscanner end /d:sonar.login=$${sonar_token}
+    when:
+      branch:
+        - master
+      event:
+        - push
+        - pull_request
+    depends_on: [build,tests]
+
+
+  - name: docker-build-and-push
+    image: plugins/docker
+    settings:
+      dockerfile: dockerfile
+      context: .
+      registry: hub.codefirst.iut.uca.fr
+      repo: hub.codefirst.iut.uca.fr/louis.laborie/sae_2a_blazor
+      username:
+        from_secret: SECRET_REGISTRY_USERNAME
+      password:
+        from_secret: SECRET_REGISTRY_PASSWORD
+    when:
+      branch:
+        - master
+        - rebase
+
+  - name: deploy-container
+    image: hub.codefirst.iut.uca.fr/thomas.bellembois/codefirst-dockerproxy-clientdrone:latest
+    environment:
+      IMAGENAME: hub.codefirst.iut.uca.fr/louis.laborie/sae_2a_blazor:latest
+      CONTAINERNAME: verax-blazor
+      COMMAND: create
+      OVERWRITE: true
+      CODEFIRST_CLIENTDRONE_ENV_ASPNETCORE_HTTP_PORTS: 80
+      ADMINS: louislaborie,tonyfages,noasillard,jeanmarcillac,shanacascarra
+    depends_on:
+      - docker-build-and-push

.gitignore

@@ -6,6 +6,8 @@
 bin/
 obj/
 
+
+
 # Common node modules locations
 /node_modules
 /wwwroot/node_modules

README.md

@@ -1,2 +1,47 @@
-# Blazor_SAE
+<h1 align="center">VeraxShield</h1>
 
+<p align="center">
+  <img src="https://img.shields.io/badge/C%23-239120.svg?style=for-the-badge&logo=c-sharp&logoColor=white" alt="C#"/>
+  <img src="https://img.shields.io/badge/Blazor-512BD4.svg?style=for-the-badge&logo=blazor&logoColor=white" alt="Blazor"/>
+  <img src="https://img.shields.io/badge/.NET-512BD4.svg?style=for-the-badge&logo=.net&logoColor=white" alt=".NET"/>
+  <img src="https://img.shields.io/badge/HTML5-E34F26.svg?style=for-the-badge&logo=html5&logoColor=white" alt="HTML5"/>
+  <img src="https://img.shields.io/badge/CSS3-1572B6.svg?style=for-the-badge&logo=css3&logoColor=white" alt="CSS3"/>
+</p>
+
+## Description
+VeraxShield est une application web avancée développée avec Blazor, représentant la partie administration de notre projet plus large, [Verax](https://codefirst.iut.uca.fr/git/Verax/Verax). Conçue pour offrir une interface de gestion intuitive, VeraxShield permet aux administrateurs de gérer efficacement les différents aspects du système Verax.
+
+### Fonctionnalités Clés
+- **Gestion des Utilisateurs** : Permet aux administrateurs de créer, modifier et supprimer des comptes utilisateurs. Inclut la gestion des rôles et des permissions pour un contrôle d'accès granulaire.
+- **Notifications et Suivis des Actions** : Envoie des notifications sur les différentes actions des modérateurs afin pour assurer une meilleure gestion du système.
+
+### Objectif du Projet
+L'objectif principal de VeraxShield est de fournir une plateforme centralisée pour la gestion et le contrôle administratif du système Verax, en rationalisant les processus administratifs et en offrant une vue d'ensemble claire des opérations.
+
+
+## Installation et Configuration
+1. Clonez le dépôt : `git clone (https://codefirst.iut.uca.fr/git/Verax/Blazor_SAE.git)`
+2. Ouvrez le fichier `VeraxShield.sln` avec Visual Studio.
+3. Restaurez les packages nécessaires.
+4. Lancez le projet depuis Visual Studio.
+
+
+<h2 align="center">Equipe de Développement</h2>
+<p align="center" >
+
+<a href="https://codefirst.iut.uca.fr/git/louis.laborie"  style="margin-right: 20px;">
+  <img src="img/Louis.png" width="50" height="50" title="Louis Laborie" alt="Louis Laborie"/>
+</a>
+<a href="https://codefirst.iut.uca.fr/git/shana.cascarra" style="margin-right: 20px;">
+  <img src="img/Shana.png" width="50" height="50" title="Shana Cascarra" alt="Shana Cascarra"/>
+</a>
+<a href="https://codefirst.iut.uca.fr/git/jean.marcillac" style="margin-right: 20px;">
+  <img src="img/Jean.png" width="50" height="50" title="Jean Marcillac" alt="Jean Marcillac"/>
+</a>
+<a href="https://codefirst.iut.uca.fr/git/tony.fages" style="margin-right: 20px;">
+  <img src="img/Tony.png" width="50" height="50" title="Tony Fages" alt="Tony Fages"/>
+</a>
+<a href="https://codefirst.iut.uca.fr/git/noa.sillard" style="margin-right: 20px;">
+  <img src="img/Noa.png" width="50" height="50" title="Noa Sillard" alt="Noa Sillard"/>
+</a>
+<p>

VeraxShield/.idea/.idea.VeraxShield/.idea/.gitignore

@@ -0,0 +1,15 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Rider ignored files
+/.idea.VeraxShield.iml
+/contentModel.xml
+/modules.xml
+/projectSettingsUpdater.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml
+# GitHub Copilot persisted chat sessions
+/copilot/chatSessions

VeraxShield/.idea/.idea.VeraxShield/.idea/indexLayout.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="UserContentModel">
+    <attachedFolders>
+      <Path>../../Blazor_SAE</Path>
+    </attachedFolders>
+    <explicitIncludes />
+    <explicitExcludes />
+  </component>
+</project>

VeraxShield/.idea/.idea.VeraxShield/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$/.." vcs="Git" />
+  </component>
+</project>

VeraxShield/TestVeraxShield/AuthentificationServiceTests.cs

@@ -0,0 +1,105 @@
+using System.Security.Claims;
+using Moq;
+using VeraxShield.composants.formulaires.modeles;
+using VeraxShield.modele.utilisateurs;
+using VeraxShield.services.UtilisateursDataService;
+
+namespace TestVeraxShield;
+
+public class AuthentificationServiceTests
+{
+     private readonly AuthentificationService _authService;
+    private readonly Mock<IUtilisateursDataService> _mockDataService = new Mock<IUtilisateursDataService>();
+
+    public AuthentificationServiceTests()
+    {
+        _authService = new AuthentificationService(_mockDataService.Object);
+    }
+
+    [Fact]
+    public async Task Connexion_WithValidCredentials_ShouldSucceed()
+    {
+        // Arrange
+        var testUser = new Utilisateur("testUser", "Test", "User", "test@user.com", BCrypt.Net.BCrypt.HashPassword("password"), "User", false);
+
+        _mockDataService.Setup(s => s.getAllUtilisateurs())
+            .ReturnsAsync(new List<Utilisateur> { testUser });
+
+        var requete = new RequeteConnexion
+        {
+            Pseudo = "testUser",
+            MotDePasse = "password"
+        };
+
+        // Act & Assert
+        await _authService.Connexion(requete);
+    }
+
+    [Fact]
+    public async Task Connexion_WithInvalidCredentials_ShouldThrowException()
+    {
+        // Arrange
+        _mockDataService.Setup(s => s.getAllUtilisateurs())
+            .ReturnsAsync(new List<Utilisateur>());
+
+        var requete = new RequeteConnexion
+        {
+            Pseudo = "nonExistentUser",
+            MotDePasse = "wrongPassword"
+        };
+
+        // Act & Assert
+        await Assert.ThrowsAsync<Exception>(() => _authService.Connexion(requete));
+    }
+
+    [Fact]
+    public async Task Inscription_ShouldCreateNewUser()
+    {
+        // Arrange
+        var requete = new RequeteInscription
+        {
+            Pseudo = "newUser",
+            Nom = "New",
+            Prenom = "User",
+            Mail = "new@user.com",
+            MotDePasse = "newPassword"
+        };
+
+        // Setup the mock to verify that AjouterUtilisateur is called with a Utilisateur that matches the inscription details
+        _mockDataService.Setup(s => s.AjouterUtilisateur(It.IsAny<Utilisateur>()))
+            .Returns(Task.CompletedTask)
+            .Callback<Utilisateur>(u =>
+            {
+                Assert.Equal(requete.Pseudo, u.Pseudo);
+                Assert.True(BCrypt.Net.BCrypt.Verify(requete.MotDePasse, u.Mdp));
+            });
+
+        // Act
+        await _authService.Inscription(requete);
+
+    }
+    [Fact]
+    public async Task GetUtilisateur_ReturnsCorrectUser_WithClaims()
+    {
+        // Arrange
+        var expectedPseudo = "testUser";
+        var expectedRole = "User";
+        var testUser = new Utilisateur("testUser", "Test", "User", "test@user.com", BCrypt.Net.BCrypt.HashPassword("password"), "User", false);
+        var mockDataService = new Mock<IUtilisateursDataService>();
+        mockDataService.Setup(s => s.getAllUtilisateurs())
+            .ReturnsAsync(new List<Utilisateur> { testUser });
+
+        var authService = new AuthentificationService(mockDataService.Object);
+
+        // Act
+        var utilisateurCourant = await authService.GetUtilisateur(expectedPseudo);
+        utilisateurCourant.Claims.Add(ClaimTypes.Email, "test@user.com");
+
+        // Assert
+        Assert.NotNull(utilisateurCourant);
+        Assert.True(utilisateurCourant.EstAuthentifie);
+        Assert.Equal(expectedPseudo, utilisateurCourant.Pseudo);
+        
+    }
+
+}

VeraxShield/TestVeraxShield/DonneurEtatTests.cs

@@ -0,0 +1,85 @@
+using Moq;
+using System.Collections.Generic;
+using System.Security.Claims;
+using System.Threading.Tasks;
+using VeraxShield.composants.formulaires.modeles;
+using VeraxShield.modele.utilisateurs;
+using VeraxShield.services.UtilisateursDataService;
+using Xunit;
+
+namespace VeraxShield.UnitTests
+{
+    public class DonneurEtatTests
+    {
+        private readonly DonneurEtat _donneurEtat;
+        private readonly Mock<IAuthentificationService> _mockAuthService;
+        private readonly Mock<IUtilisateursDataService> _mockUserDataService;
+
+        public DonneurEtatTests()
+        {
+            _mockAuthService = new Mock<IAuthentificationService>();
+            _mockUserDataService = new Mock<IUtilisateursDataService>();
+            _donneurEtat = new DonneurEtat(_mockAuthService.Object, _mockUserDataService.Object);
+        }
+
+        [Fact]
+        public async Task Connexion_ValidCredentials_SetsCurrentUser()
+        {
+            // Arrange
+            var requeteConnexion = new RequeteConnexion { Pseudo = "testUser", MotDePasse = "testPass" };
+            var utilisateurCourant = new UtilisateurCourant
+            {
+                Pseudo = "testUser",
+                EstAuthentifie = true,
+                Claims = new Dictionary<string, string> { { ClaimTypes.Role, "User" } }
+            };
+
+            _mockAuthService.Setup(x => x.GetUtilisateur(requeteConnexion.Pseudo)).ReturnsAsync(utilisateurCourant);
+            _mockAuthService.Setup(x => x.Connexion(requeteConnexion)).Returns(Task.CompletedTask);
+
+            // Act
+            await _donneurEtat.Connexion(requeteConnexion);
+
+            // Assert
+            Assert.NotNull(_donneurEtat._utilisateurCourant);
+            Assert.True(_donneurEtat._utilisateurCourant.EstAuthentifie);
+            _mockAuthService.Verify(x => x.Connexion(requeteConnexion), Times.Once);
+            _mockAuthService.Verify(x => x.GetUtilisateur(requeteConnexion.Pseudo), Times.Once);
+        }
+
+        [Fact]
+        public async Task Deconnexion_ClearsCurrentUser()
+        {
+            // Arrange - assume user is logged in
+            _donneurEtat._utilisateurCourant = new UtilisateurCourant { EstAuthentifie = true };
+
+            // Act
+            await _donneurEtat.Deconnexion();
+
+            // Assert
+            Assert.Null(_donneurEtat._utilisateurCourant);
+        }
+
+        [Fact]
+        public async Task Inscription_ValidData_RegistersUser()
+        {
+            // Arrange
+            var requeteInscription = new RequeteInscription
+            {
+                Pseudo = "newUser",
+                MotDePasse = "newPass",
+                Mail = "newUser@test.com",
+                Nom = "New",
+                Prenom = "User"
+            };
+
+            _mockAuthService.Setup(x => x.Inscription(requeteInscription)).Returns(Task.CompletedTask);
+
+            // Act
+            await _donneurEtat.Inscription(requeteInscription);
+
+            // Assert - Since Inscription does not automatically log in the user, we check if the method was called.
+            _mockAuthService.Verify(x => x.Inscription(requeteInscription), Times.Once);
+        }
+    }
+}

VeraxShield/TestVeraxShield/GlobalUsings.cs

@@ -0,0 +1 @@
+global using Xunit;

VeraxShield/TestVeraxShield/IAuthentificationServiceTests.cs

@@ -0,0 +1,45 @@
+using Moq;
+using VeraxShield.modele.utilisateurs;
+using VeraxShield.services.UtilisateursDataService;
+
+namespace TestVeraxShield;
+
+public class IAuthentificationServiceTests
+{
+    private readonly Mock<IUtilisateursDataService> _mockDataService;
+    private readonly AuthentificationService _authService;
+
+    public IAuthentificationServiceTests()
+    {
+        _mockDataService = new Mock<IUtilisateursDataService>();
+        _authService = new AuthentificationService(_mockDataService.Object);
+    }
+
+    [Fact]
+    public async Task GetUtilisateur_ValidUser_ReturnsUser()
+    {
+        // Arrange
+        var expectedUser = new UtilisateurCourant { Pseudo = "user1", EstAuthentifie = true };
+        _mockDataService.Setup(x => x.getAllUtilisateurs()).ReturnsAsync(new List<Utilisateur>
+        {
+            new Utilisateur("user1", "Name", "Surname", "user1@example.com", "password", "User", false)
+        });
+
+        // Act
+        var result = await _authService.GetUtilisateur("user1");
+
+        // Assert
+        Assert.Equal(expectedUser.Pseudo, result.Pseudo);
+        Assert.True(result.EstAuthentifie);
+    }
+
+    [Fact]
+    public async Task GetUtilisateur_NonExistentUser_ThrowsException()
+    {
+        // Arrange
+        _mockDataService.Setup(x => x.getAllUtilisateurs()).ReturnsAsync(new List<Utilisateur>());
+
+        // Act & Assert
+        await Assert.ThrowsAsync<Exception>(() => _authService.GetUtilisateur("user2"));
+    }
+}

VeraxShield/TestVeraxShield/IUtilisateursDataServiceTests.cs

@@ -0,0 +1,25 @@
+using Moq;
+using VeraxShield.modele.utilisateurs;
+using VeraxShield.services.UtilisateursDataService;
+
+namespace TestVeraxShield;
+
+public class IUtilisateursDataServiceTests
+{
+    private readonly Mock<IUtilisateursDataService> _service = new Mock<IUtilisateursDataService>();
+
+    [Fact]
+    public async Task AjouterUtilisateur_AddsUserSuccessfully()
+    {
+        // Arrange
+        var user = new Utilisateur("testUser", "User", "Test", "dez", "password", "User", false);        
+        _service.Setup(s => s.AjouterUtilisateur(It.IsAny<Utilisateur>()))
+            .Returns(Task.CompletedTask)
+            .Callback<Utilisateur>(u => Assert.Equal("testUser", u.Pseudo));
+
+        // Act
+        await _service.Object.AjouterUtilisateur(user);
+
+        // Assert is handled by the Callback
+    }
+}

VeraxShield/TestVeraxShield/ModeleAppUtilisateurTests.cs

@@ -0,0 +1,47 @@
+namespace TestVeraxShield;
+
+public class ModeleAppUtilisateurTests
+{
+    
+    [Fact]
+    public void Constructeur_DoitInitialiserProprietes()
+    {
+        // Arrange & Act
+        var utilisateur = new ModeleAppUtilisateur("pseudoTest", "NomTest", "PrenomTest", "email@test.com", "motdepasse", "RoleTest");
+
+        // Assert
+        Assert.Equal("pseudoTest", utilisateur.Pseudo);
+        Assert.Equal("NomTest", utilisateur.Nom);
+        Assert.Equal("PrenomTest", utilisateur.Prenom);
+        Assert.Equal("email@test.com", utilisateur.Mail);
+        Assert.Equal("motdepasse", utilisateur.MotDePasse);
+        Assert.Contains("RoleTest", utilisateur.Roles);
+    }
+
+    [Fact]
+    public void AjouterRole_DoItAjouterNouveauRole()
+    {
+        // Arrange
+        var utilisateur = new ModeleAppUtilisateur("pseudoTest", "NomTest", "PrenomTest", "email@test.com", "motdepasse", "RoleTest");
+
+        // Act
+        utilisateur.ajouterRole("NouveauRole");
+
+        // Assert
+        Assert.Contains("NouveauRole", utilisateur.Roles);
+    }
+
+    [Fact]
+    public void SupprimerRole_DoItSupprimerRoleExistant()
+    {
+        // Arrange
+        var utilisateur = new ModeleAppUtilisateur("pseudoTest", "NomTest", "PrenomTest", "email@test.com", "motdepasse", "RoleTest");
+        utilisateur.ajouterRole("NouveauRole");
+
+        // Act
+        utilisateur.supprimerRole("RoleTest");
+
+        // Assert
+        Assert.DoesNotContain("RoleTest", utilisateur.Roles);
+    }
+}

VeraxShield/TestVeraxShield/ModeleCurrentUserTests.cs

@@ -0,0 +1,57 @@
+namespace TestVeraxShield;
+
+public class ModeleCurrentUserTests
+{
+    [Fact]
+    public void InitializesCorrectly()
+    {
+        var utilisateur = new UtilisateurCourant();
+
+        Assert.Null(utilisateur.Claims);
+        Assert.False(utilisateur.EstAuthentifie);
+        Assert.Null(utilisateur.Pseudo);
+    }
+
+    [Fact]
+    public void AddsAndUpdatesClaimsCorrectly()
+    {
+        var utilisateur = new UtilisateurCourant { Claims = new Dictionary<string, string>() };
+        utilisateur.Claims.Add("role", "user");
+
+        Assert.Equal("user", utilisateur.Claims["role"]);
+
+        utilisateur.Claims["role"] = "admin";
+        Assert.Equal("admin", utilisateur.Claims["role"]);
+    }
+
+    [Fact]
+    public void RemovesClaimsCorrectly()
+    {
+        var utilisateur = new UtilisateurCourant { Claims = new Dictionary<string, string>() };
+        utilisateur.Claims.Add("role", "user");
+        utilisateur.Claims.Remove("role");
+
+        Assert.False(utilisateur.Claims.ContainsKey("role"));
+    }
+
+    [Fact]
+    public void TogglesAuthenticationState()
+    {
+        var utilisateur = new UtilisateurCourant();
+        utilisateur.EstAuthentifie = true;
+
+        Assert.True(utilisateur.EstAuthentifie);
+
+        utilisateur.EstAuthentifie = false;
+        Assert.False(utilisateur.EstAuthentifie);
+    }
+
+    [Fact]
+    public void UpdatesPseudoCorrectly()
+    {
+        var utilisateur = new UtilisateurCourant();
+        utilisateur.Pseudo = "TestUser";
+
+        Assert.Equal("TestUser", utilisateur.Pseudo);
+    }
+}

VeraxShield/TestVeraxShield/ModeleUtilisateurTests.cs

@@ -0,0 +1,66 @@
+using VeraxShield.modele.utilisateurs;
+
+namespace TestVeraxShield;
+
+public class ModeleUtilisateurTests
+{
+    [Fact]
+    public void ConstructorAssignsPropertiesCorrectly()
+    {
+        // Arrange
+        string expectedPseudo = "TestPseudo";
+        string expectedNom = "TestNom";
+        string expectedPrenom = "TestPrenom";
+        string expectedRole = "TestRole";
+        string expectedMdp = "TestMdp";
+        string expectedMail = "test@mail.com";
+        bool expectedIsBan = true;
+
+        // Act
+        Utilisateur utilisateur = new Utilisateur(expectedPseudo, expectedNom, expectedPrenom, expectedRole, expectedMdp, expectedMail, expectedIsBan);
+
+        // Assert
+        Assert.Equal(expectedPseudo, utilisateur.Pseudo);
+        Assert.Equal(expectedNom, utilisateur.Nom);
+        Assert.Equal(expectedPrenom, utilisateur.Prenom);
+        Assert.Equal(expectedRole, utilisateur.Role);
+        Assert.Equal(expectedMdp, utilisateur.Mdp);
+        Assert.Equal(expectedMail, utilisateur.Mail);
+        Assert.Equal(expectedIsBan, utilisateur.IsBan);
+    }
+
+    [Theory]
+    [InlineData("NewPseudo", "NewNom", "NewPrenom", "NewRole", "NewMdp", "new@mail.com", false)]
+    [InlineData("AnotherPseudo", "AnotherNom", "AnotherPrenom", "AnotherRole", "AnotherMdp", "another@mail.com", true)]
+    public void PropertiesUpdateCorrectly(string pseudo, string nom, string prenom, string role, string mdp, string mail, bool isBan)
+    {
+        // Arrange
+        Utilisateur utilisateur = new Utilisateur(pseudo, nom, prenom, role, mdp, mail, isBan);
+
+        // Act - changing values to test setter
+        string updatedPseudo = pseudo + "Update";
+        string updatedNom = nom + "Update";
+        string updatedPrenom = prenom + "Update";
+        string updatedRole = role + "Update";
+        string updatedMdp = mdp + "Update";
+        string updatedMail = "updated@" + mail;
+        bool updatedIsBan = !isBan;
+
+        utilisateur.Pseudo = updatedPseudo;
+        utilisateur.Nom = updatedNom;
+        utilisateur.Prenom = updatedPrenom;
+        utilisateur.Role = updatedRole;
+        utilisateur.Mdp = updatedMdp;
+        utilisateur.Mail = updatedMail;
+        utilisateur.IsBan = updatedIsBan;
+
+        // Assert
+        Assert.Equal(updatedPseudo, utilisateur.Pseudo);
+        Assert.Equal(updatedNom, utilisateur.Nom);
+        Assert.Equal(updatedPrenom, utilisateur.Prenom);
+        Assert.Equal(updatedRole, utilisateur.Role);
+        Assert.Equal(updatedMdp, utilisateur.Mdp);
+        Assert.Equal(updatedMail, utilisateur.Mail);
+        Assert.Equal(updatedIsBan, utilisateur.IsBan);
+    }
+}

VeraxShield/TestVeraxShield/TestVeraxShield.csproj

@@ -0,0 +1,47 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net8.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+
+        <IsPackable>false</IsPackable>
+        <IsTestProject>true</IsTestProject>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="bunit.web" Version="1.27.17" />
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.6.0"/>
+        <PackageReference Include="Moq" Version="4.20.70" />
+        <PackageReference Include="RichardSzalay.MockHttp" Version="7.0.0" />
+        <PackageReference Include="xunit" Version="2.4.2"/>
+        <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5">
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+            <PrivateAssets>all</PrivateAssets>
+        </PackageReference>
+        <PackageReference Include="coverlet.collector" Version="6.0.0">
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+            <PrivateAssets>all</PrivateAssets>
+        </PackageReference>
+    </ItemGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\VeraxShield\VeraxShield.csproj" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <Compile Remove="factoriesTests\**" />
+      <Compile Remove="ModeleTests\**" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <EmbeddedResource Remove="factoriesTests\**" />
+      <EmbeddedResource Remove="ModeleTests\**" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <None Remove="factoriesTests\**" />
+      <None Remove="ModeleTests\**" />
+    </ItemGroup>
+
+</Project>

VeraxShield/TestVeraxShield/UtilisateurDataServiceTests.cs

@@ -0,0 +1,56 @@
+using Microsoft.AspNetCore.Components;
+using Moq;
+using Newtonsoft.Json;
+using RichardSzalay.MockHttp;
+using VeraxShield.modele.utilisateurs;
+using VeraxShield.services.UtilisateursDataService;
+
+namespace TestVeraxShield;
+
+public class UtilisateursDataServiceApiTests
+{
+    private readonly MockHttpMessageHandler _mockHttp;
+    private readonly HttpClient _clientHttp;
+    private readonly Mock<NavigationManager> _mockNavigationManager;
+    private readonly UtilisateursDataServiceApi _service;
+
+    public UtilisateursDataServiceApiTests()
+    {
+        _mockHttp = new MockHttpMessageHandler();
+
+        // Mock the response for the API call
+        _mockHttp.When("https://Verax.com/api/utilisateurs/recuperer")
+            .Respond("application/json", JsonConvert.SerializeObject(new List<Utilisateur>
+            {
+                new Utilisateur("testUser", "User", "Test", "dez", "password", "User", false)
+            }));
+
+        _clientHttp = _mockHttp.ToHttpClient();
+        _clientHttp.BaseAddress = new System.Uri("https://Verax.com");
+
+        _mockNavigationManager = new Mock<NavigationManager>();
+        _service = new UtilisateursDataServiceApi(_clientHttp, _mockNavigationManager.Object);
+    }
+
+    [Fact]
+    public async Task GetAllUtilisateurs_ReturnsUsers()
+    {
+        // Act
+        var users = await _service.getAllUtilisateurs();
+
+        // Assert
+        Assert.Single(users);
+        Assert.Equal("testUser", users[0].Pseudo);
+    }
+    
+    [Fact]
+    public async Task GetUtilisateurFromPseudo_ReturnsUser()
+    {
+        // Act
+        var user = await _service.getUtilisateurFromPseudo("testUser");
+
+        // Assert
+        Assert.Equal("testUser", user.Pseudo);
+    }
+    
+}

VeraxShield/TestVeraxShield/UtlisateurFactoryTests.cs

@@ -0,0 +1,56 @@
+namespace TestVeraxShield.factoriesTests;
+
+using Xunit;
+using VeraxShield.factories;
+using VeraxShield.composants.formulaires.modeles;
+using VeraxShield.modele.utilisateurs;
+
+public class UtilisateursFactoryTests
+{
+    [Fact]
+    public void ConvertsToUtilisateur_WithNewPasswordHashing()
+    {
+        // Arrange
+        var modele = new FormulaireAjoutModele { Mdp = "newPassword", /* other properties */ };
+
+        // Act
+        var utilisateur = UtilisateursFactory.toUtilisateur(modele);
+        
+        // Assert
+        Assert.NotEqual("newPassword", utilisateur.Mdp);
+    }
+
+    [Fact]
+    public void ConvertsToModele_FromUtilisateur()
+    {
+        // Arrange
+        var utilisateur = new Utilisateur("pseudo", "nom", "prenom", "role", "mdp", "mail", false);
+        
+        // Act
+        var modele = UtilisateursFactory.toModele(utilisateur);
+        
+        // Assert
+    }
+
+    
+    
+    
+    [Fact]
+    public void ConvertsToModele_FromUtilisateurs()
+    {
+        // Arrange
+        var utilisateur = new Utilisateur("pseudo", "nom", "prenom", "role", "mdp", "mail", false);
+        
+        // Act
+        var modele = UtilisateursFactory.toModele(utilisateur);
+        
+        // Assert
+        Assert.Equal(utilisateur.Pseudo, modele.Pseudo);
+        Assert.Equal(utilisateur.Nom, modele.Nom);
+        Assert.Equal(utilisateur.Prenom, modele.Prenom);
+        Assert.Equal(utilisateur.Role, modele.Role);
+        Assert.Equal(utilisateur.Mail, modele.Mail);
+        Assert.Equal(utilisateur.IsBan, modele.IsBan);
+    }
+
+}

VeraxShield/VeraxShield.sln

@@ -5,6 +5,8 @@ VisualStudioVersion = 17.8.34322.80
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "VeraxShield", "VeraxShield\VeraxShield.csproj", "{40D16910-ADA7-496E-BA48-AA9D6FF1E502}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TestVeraxShield", "TestVeraxShield\TestVeraxShield.csproj", "{7924C3CD-C50B-41D1-8A93-C4E0AF0F1B3C}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -15,6 +17,10 @@ Global
 		{40D16910-ADA7-496E-BA48-AA9D6FF1E502}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{40D16910-ADA7-496E-BA48-AA9D6FF1E502}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{40D16910-ADA7-496E-BA48-AA9D6FF1E502}.Release|Any CPU.Build.0 = Release|Any CPU
+		{7924C3CD-C50B-41D1-8A93-C4E0AF0F1B3C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{7924C3CD-C50B-41D1-8A93-C4E0AF0F1B3C}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{7924C3CD-C50B-41D1-8A93-C4E0AF0F1B3C}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{7924C3CD-C50B-41D1-8A93-C4E0AF0F1B3C}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

VeraxShield/VeraxShield/App.razor

@@ -12,17 +12,3 @@
 
 
 
-@* <Router AppAssembly="@typeof(App).Assembly">
-    <Found Context="routeData">
-        <RouteView RouteData="@routeData" DefaultLayout="@typeof(MainLayout)" />
-        <FocusOnNavigate RouteData="@routeData" Selector="h1" />
-    </Found>
-    <NotFound>
-        <PageTitle>Not found</PageTitle>
-        <LayoutView Layout="@typeof(MainLayout)">
-            <p role="alert">Sorry, there's nothing at this address.</p>
-        </LayoutView>
-    </NotFound>
-</Router> *@
-
-

VeraxShield/VeraxShield/Program.cs

@@ -13,17 +13,17 @@ var builder = WebApplication.CreateBuilder(args);
 builder.Services.AddRazorPages();
 builder.Services.AddServerSideBlazor();
 
-// Ajout du client http par d<>faut :
+
 builder.Services.AddHttpClient();
 
-// Ajout du service de gestion des utilisateurs :
+// Service factice :
-// On le met scoped, car c'est comme <20>a qu'est le service du localStorage alors sinon <20>a marche pas...
 builder.Services.AddScoped<IUtilisateursDataService, UtilisateursDataServiceFactice>();
 
-// Ajout du service pour le Blazored LocalStorage :
+// Utilisation de l'api :
+//builder.Services.AddScoped<IUtilisateursDataService, UtilisateursDataServiceApi>();
+
 builder.Services.AddBlazoredLocalStorage();
 
-// Ajout de Blazorise :
 builder.Services
     .AddBlazorise(options =>
     {
@@ -32,7 +32,6 @@ builder.Services
     .AddBootstrapProviders()
     .AddFontAwesomeIcons();
 
-// Ajout de services pour l'authenfication :
 builder.Services.AddOptions();
     builder.Services.AddAuthorizationCore();
     builder.Services.AddScoped<DonneurEtat>();

VeraxShield/VeraxShield/Properties/launchSettings.json

@@ -1,28 +1,22 @@
 {
-  "iisSettings": {
-    "iisExpress": {
-      "applicationUrl": "http://localhost:38362",
-      "sslPort": 44368
-    }
-  },
   "profiles": {
     "http": {
       "commandName": "Project",
-      "dotnetRunMessages": true,
       "launchBrowser": true,
-      "applicationUrl": "http://localhost:5272",
       "environmentVariables": {
         "ASPNETCORE_ENVIRONMENT": "Development"
-      }
+      },
+      "dotnetRunMessages": true,
+      "applicationUrl": "http://localhost:5272"
     },
     "https": {
       "commandName": "Project",
-      "dotnetRunMessages": true,
       "launchBrowser": true,
-      "applicationUrl": "https://localhost:7112;http://localhost:5272",
       "environmentVariables": {
         "ASPNETCORE_ENVIRONMENT": "Development"
-      }
+      },
+      "dotnetRunMessages": true,
+      "applicationUrl": "https://localhost:7112;http://localhost:5272"
     },
     "IIS Express": {
       "commandName": "IISExpress",
@@ -30,6 +24,24 @@
       "environmentVariables": {
         "ASPNETCORE_ENVIRONMENT": "Development"
       }
+    },
+    "WSL": {
+      "commandName": "WSL2",
+      "launchBrowser": true,
+      "launchUrl": "https://localhost:7112",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development",
+        "ASPNETCORE_URLS": "https://localhost:7112;http://localhost:5272"
+      },
+      "distributionName": ""
+    }
+  },
+  "iisSettings": {
+    "windowsAuthentication": false,
+    "anonymousAuthentication": true,
+    "iisExpress": {
+      "applicationUrl": "http://localhost:38362",
+      "sslPort": 44368
     }
   }
 }

VeraxShield/VeraxShield/VeraxShield.csproj

@@ -11,11 +11,12 @@
   </ItemGroup>
 
   <ItemGroup>
+    <PackageReference Include="BCrypt.Net-Next" Version="4.0.3" />
     <PackageReference Include="Blazored.LocalStorage" Version="4.4.0" />
-    <PackageReference Include="Blazorise.Bootstrap" Version="1.4.0" />
+    <PackageReference Include="Blazorise.Bootstrap" Version="1.4.1" />
     <PackageReference Include="Blazorise.Components" Version="1.4.0" />
-    <PackageReference Include="Blazorise.DataGrid" Version="1.4.0" />
+    <PackageReference Include="Blazorise.DataGrid" Version="1.4.1" />
-    <PackageReference Include="Blazorise.Icons.FontAwesome" Version="1.4.0" />
+    <PackageReference Include="Blazorise.Icons.FontAwesome" Version="1.4.1" />
   </ItemGroup>
 
 </Project>

VeraxShield/VeraxShield/composants/affichages/navBar/NavBarPrincipale.razor

@@ -0,0 +1,33 @@
+@inherits LayoutComponentBase
+
+<head>
+    <link rel="stylesheet" href="css/composants/navBar/NavBarPrincipale.css" />
+</head>
+
+<Bar Breakpoint="Breakpoint.Desktop" class="bar-container">
+    <BarBrand>
+        <img class="logo" src="/ressources/images/logo/logo.png" Text="Logo de Verax" Fluid @onclick="@NavAccueil"/>
+    </BarBrand>
+    <BarToggler />
+    <BarMenu class="bar-menu">
+        <BarItem>
+            <BarLink class="bar-link" @onclick="@NavUtilisateurs">Utilisateurs</BarLink>
+        </BarItem>
+        <BarItem>
+            <BarLink class="bar-link" @onclick="@NavArticles">Articles</BarLink>
+        </BarItem>
+        <BarItem>
+            <BarLink class="bar-link" @onclick="@NavModerateurs">Modérateurs</BarLink>
+        </BarItem>
+    </BarMenu>
+    <BarEnd>
+        <BarItem class="bar-role">
+            @DonneurEtat.getUtilisateurCourant().Pseudo
+        </BarItem>
+        <BarItem>
+            <Button Color="Color.Primary" @onclick="@Deconnecter">Deconnexion</Button>
+        </BarItem>
+    </BarEnd>
+</Bar>
+
+@Body

VeraxShield/VeraxShield/composants/affichages/navBar/NavBarPrincipale.razor.cs

@@ -0,0 +1,39 @@
+using Microsoft.AspNetCore.Components;
+
+namespace VeraxShield.composants.affichages.navBar
+{
+    public partial class NavBarPrincipale
+    {
+        [Inject]
+        private DonneurEtat DonneurEtat { get; set; }
+
+        [Inject]
+        private NavigationManager NavigationManager { get; set; }
+
+        private async Task NavUtilisateurs()
+        {
+            NavigationManager.NavigateTo("/utilisateurs/liste");
+        }
+
+        private async Task NavArticles()
+        {
+            NavigationManager.NavigateTo("/articles/liste");
+        }
+
+        private async Task NavModerateurs()
+        {
+            NavigationManager.NavigateTo("/moderateurs/liste");
+        }
+
+        private async Task Deconnecter()
+        {
+            await DonneurEtat.Deconnexion();
+            NavigationManager.NavigateTo("/connexion");
+        }
+
+        private async Task NavAccueil()
+        {
+            NavigationManager.NavigateTo("/");
+        }
+    }
+}

VeraxShield/VeraxShield/composants/affichages/utilisateurs/DatagridUtilisateurs.razor

@@ -1,6 +1,10 @@
 @using VeraxShield.modele.utilisateurs;
 @using Microsoft.AspNetCore.Components;
 @using VeraxShield.composants.modals;
+@using VeraxShield.composants.affichages.navBar;
+
+@layout NavBarPrincipale
+
 
 <head>
     <link rel="stylesheet" href="css/composants/affichages/utilisateurs/datagridUtilisateurs.css">

VeraxShield/VeraxShield/composants/affichages/utilisateurs/DatagridUtilisateurs.razor.cs

@@ -10,7 +10,7 @@ namespace VeraxShield.composants.affichages.utilisateurs
     public partial class DatagridUtilisateurs
     {
         [Inject]
-		private IUtilisateursDataService utilisateursDataService { get; set; }
+		private IUtilisateursDataService UtilisateursDataService { get; set; }
 
 		public static List<Utilisateur> Utilisateurs { get; set; }
 
@@ -20,37 +20,35 @@ namespace VeraxShield.composants.affichages.utilisateurs
 		[Inject]
 		private DonneurEtat DonneurEtat {get; set;}
 
-		public static Utilisateur? UtilisateurSelectionne;
+		public static Utilisateur? UtilisateurSelectionne { get; set; }
 
 		[Parameter]
 		public ModalSuppressionUtilisateur Modal {get; set;}
 
 		protected override async Task OnInitializedAsync()
 		{
-            //await this.utilisateursDataService.resetDataUtilisateurs();
-
 			DatagridUtilisateurs.UtilisateurSelectionne = null;
-            DatagridUtilisateurs.Utilisateurs = await this.utilisateursDataService.getAllUtilisateurs();
+            DatagridUtilisateurs.Utilisateurs = await this.UtilisateursDataService.getAllUtilisateurs();
 			await base.OnInitializedAsync();
 		}
 
         private async Task HandleUtilisateurSupprime()
         {
-            DatagridUtilisateurs.Utilisateurs = await this.utilisateursDataService.getAllUtilisateurs();
+            DatagridUtilisateurs.Utilisateurs = await this.UtilisateursDataService.getAllUtilisateurs();
-            StateHasChanged(); // Actualiser la vue
+            StateHasChanged();
         }
 
-		public async Task fermetureModal(bool val) {
+		public async Task fermetureModal(bool suppressionConfirmee) {
 
-			if (val) {
+			if (suppressionConfirmee) {
 				await this.supprimerUtilisateur(DatagridUtilisateurs.UtilisateurSelectionne);
 			}
 		}
 
 		public async Task supprimerUtilisateur(Utilisateur u)
 		{
-			await this.utilisateursDataService.SupprimerUtilisateur(u);
+			await this.UtilisateursDataService.SupprimerUtilisateur(u);
-			DatagridUtilisateurs.Utilisateurs = await this.utilisateursDataService.getAllUtilisateurs();
+			DatagridUtilisateurs.Utilisateurs = await this.UtilisateursDataService.getAllUtilisateurs();
 			
 			this.NavigationManager.NavigateTo("/utilisateurs/liste");
 		}
@@ -70,18 +68,19 @@ namespace VeraxShield.composants.affichages.utilisateurs
 			}
 		}
 
-		public async Task onClickBoutonSuppression(String Pseudo)
+		public async Task onClickBoutonSuppression(String pseudo)
 		{
-			DatagridUtilisateurs.UtilisateurSelectionne= await this.utilisateursDataService.getUtilisateurFromPseudo(Pseudo);
+			DatagridUtilisateurs.UtilisateurSelectionne= await this.UtilisateursDataService.getUtilisateurFromPseudo(pseudo);
+
 			if (this.DonneurEtat._utilisateurCourant.Pseudo != DatagridUtilisateurs.UtilisateurSelectionne.Pseudo)
 			{
 				await this.afficherModal();
 			}
 		}
 
-		public async Task onClickBoutonModification(String Pseudo)
+		public async Task onClickBoutonModification(String pseudo)
 		{
-			DatagridUtilisateurs.UtilisateurSelectionne = await this.utilisateursDataService.getUtilisateurFromPseudo(Pseudo);
+			DatagridUtilisateurs.UtilisateurSelectionne = await this.UtilisateursDataService.getUtilisateurFromPseudo(pseudo);
 			this.modifierUtilisateur();
 		}
 

VeraxShield/VeraxShield/composants/authentification/FormulaireConnexion.razor

@@ -32,11 +32,18 @@
                 <Field Horizontal>
                     <FieldLabel ColumnSize="ColumnSize.Is2">Mot de passe</FieldLabel>
                     <FieldBody ColumnSize="ColumnSize.Is10">
-                        <TextEdit Placeholder="Entrez votre mot de passe" @bind-Text="@Requete.MotDePasse">
+                        <div class="input-group">
-                            <Feedback>
+                            <TextEdit @bind-Text="@Requete.MotDePasse"
-                                <ValidationError />
+                                      Type="@(showPassword ? "text" : "password")"
-                            </Feedback>
+                                      Class="form-control" Placeholder="Mot De Passe"/>
-                        </TextEdit>
+
+                            <span class="input-group-btn">
+                                <button class="btn btn-default" type="button" @onclick="ToggleShowPassword">
+                                    <i class="@(showPassword ? "fa fa-eye-slash" : "fa fa-eye")"></i>
+                                </button>
+                            </span>
+                        </div>
+
                     </FieldBody>
                 </Field>
             </Validation>

VeraxShield/VeraxShield/composants/authentification/FormulaireConnexion.razor.cs

@@ -20,6 +20,9 @@ namespace VeraxShield.composants.authentification
 
         public String Erreur {get; set; }
         
+        public bool showPassword = false;
+
+
         protected override async Task OnInitializedAsync()
         {
             this.Requete = new RequeteConnexion();
@@ -46,5 +49,10 @@ namespace VeraxShield.composants.authentification
         {
             this.NavigationManager.NavigateTo("/inscription");
         }
+
+        private void ToggleShowPassword()
+        {
+            showPassword = !showPassword;
+        }
     }  
 }

VeraxShield/VeraxShield/composants/authentification/FormulaireInscription.razor

@@ -77,11 +77,17 @@
                 <Field Horizontal>
                     <FieldLabel ColumnSize="ColumnSize.Is2">Mot de passe</FieldLabel>
                     <FieldBody ColumnSize="ColumnSize.Is10">
-                        <TextEdit Placeholder="Entrez votre mot de passe" @bind-Text="@Requete.MotDePasse">
+                        <div class="input-group">
-                            <Feedback>
+                            <TextEdit @bind-Text="@Requete.MotDePasse"
-                                <ValidationError />
+                                      Type="@(showPassword ? "text" : "password")"
-                            </Feedback>
+                                      Class="form-control" Placeholder="Mot de passe" />
-                        </TextEdit>
+
+                            <span class="input-group-btn">
+                                <button class="btn btn-default" type="button" @onclick="ToggleShowPassword">
+                                    <i class="@(showPassword ? "fa fa-eye-slash" : "fa fa-eye")"></i>
+                                </button>
+                            </span>
+                        </div>
                     </FieldBody>
                 </Field>
             </Validation>
@@ -92,11 +98,17 @@
                 <Field Horizontal>
                     <FieldLabel ColumnSize="ColumnSize.Is2">Confirmer le mot de passe</FieldLabel>
                     <FieldBody ColumnSize="ColumnSize.Is10">
-                        <TextEdit Placeholder="Entrez votre mot de  à nouveau" @bind-Text="@Requete.MotDePasseConfirmation">
+                        <div class="input-group">
-                            <Feedback>
+                            <TextEdit @bind-Text="@Requete.MotDePasseConfirmation"
-                                <ValidationError />
+                                      Type="@(showPasswordConf ? "text" : "password")"
-                            </Feedback>
+                                      Class="form-control" Placeholder="Confirmez mot de passe" />
-                        </TextEdit>
+
+                            <span class="input-group-btn">
+                                <button class="btn btn-default" type="button" @onclick="ToggleShowPasswordConf">
+                                    <i class="@(showPasswordConf ? "fa fa-eye-slash" : "fa fa-eye")"></i>
+                                </button>
+                            </span>
+                        </div>
                     </FieldBody>
                 </Field>
             </Validation>

VeraxShield/VeraxShield/composants/authentification/FormulaireInscription.razor.cs

@@ -1,6 +1,8 @@
 using Blazorise;
 using Microsoft.AspNetCore.Components;
+using VeraxShield.composants.affichages.utilisateurs;
 using VeraxShield.composants.formulaires.modeles;
+using VeraxShield.services.UtilisateursDataService;
 
 namespace VeraxShield.composants.authentification
 {
@@ -18,11 +20,19 @@ namespace VeraxShield.composants.authentification
         [Inject]
         private DonneurEtat DonneurEtat {get; set;}
 
+        [Inject]
+        private IUtilisateursDataService UtilisateursDataService {get; set;}
+
         public String Erreur {get; set; }
+        public bool showPassword {get; set;}
+        public bool showPasswordConf {get; set;}
 
         protected override async Task OnInitializedAsync()
         {
+            this.showPassword = false;
+            this.showPasswordConf = false;
             this.Requete = new RequeteInscription();
+            DatagridUtilisateurs.Utilisateurs = await this.UtilisateursDataService.getAllUtilisateurs();
             await base.OnInitializedAsync();
         }
 
@@ -39,5 +49,15 @@ namespace VeraxShield.composants.authentification
         {
             this.NavigationManager.NavigateTo("/connexion");
         }
+
+        private void ToggleShowPassword()
+        {
+            showPassword = !showPassword;
+        }
+
+        private void ToggleShowPasswordConf()
+        {
+            showPasswordConf = !showPasswordConf;
+        }
     }
 }

VeraxShield/VeraxShield/composants/formulaires/FormulaireAjout.razor.cs

@@ -21,7 +21,6 @@ namespace VeraxShield.composants.formulaires
         [Inject]
         private IUtilisateursDataService utilisateursDataService { get; set; }
 
-
         protected override async Task OnInitializedAsync()
         {
             this.Modele = new FormulaireAjoutModele();
@@ -32,6 +31,11 @@ namespace VeraxShield.composants.formulaires
         {
             if (await this.Validations.ValidateAll())
             {
+                if(this.Modele.Mdp == null)
+                {
+                    this.Modele.Mdp = this.Modele.Pseudo;
+                }
+
                 Utilisateur nouvelUtilisateur = UtilisateursFactory.toUtilisateur(this.Modele);
                 await this.utilisateursDataService.AjouterUtilisateur(nouvelUtilisateur);
                 this.NavigationManager.NavigateTo("/utilisateurs/liste");

VeraxShield/VeraxShield/composants/formulaires/FormulaireModification.razor

@@ -86,9 +86,9 @@
         <div class="field-container">
             <Validation>
                 <Field Horizontal>
-                    <FieldLabel ColumnSize="ColumnSize.Is2">Mot de passe</FieldLabel>
+                    <FieldLabel ColumnSize="ColumnSize.Is2">Modifier Mot de passe</FieldLabel>
                     <FieldBody ColumnSize="ColumnSize.Is10">
-                        <TextEdit Placeholder="Entrez votre mot de passe" @bind-Text="@Modele.Mdp">
+                        <TextEdit Placeholder="Nouveau mot de passe (facultatif)" @bind-Text="@Modele.Mdp">
                             <Feedback>
                                 <ValidationError />
                             </Feedback>

VeraxShield/VeraxShield/composants/formulaires/FormulaireModification.razor.cs

@@ -26,8 +26,6 @@ namespace VeraxShield.composants.formulaires
 
         protected override async Task OnParametersSetAsync()
         {
-           //PseudoCorrectAttribute.Initialiser(await this.utilisateursDataService.getAllUtilisateurs());
-
             if (this.Utilisateur != null)
             {
                 Utilisateur temp = new Utilisateur(" ", " ", " ", " ", " ", " ", true);
@@ -44,8 +42,14 @@ namespace VeraxShield.composants.formulaires
         
         protected async Task modifierUtilisateur()
         {
+
+
             if (await this.Validations.ValidateAll())
             {
+                if (this.Modele.Mdp == null)
+                {
+                    this.Modele.Mdp = Utilisateur.Mdp;
+                }
                 Utilisateur temp = UtilisateursFactory.toUtilisateur(this.Modele);
 
                 if (this.Utilisateur.Pseudo != this.Modele.Pseudo)

VeraxShield/VeraxShield/composants/formulaires/modeles/FormulaireAjoutModele.cs

@@ -28,7 +28,6 @@ namespace VeraxShield.composants.formulaires.modeles
         [EmailAddress(ErrorMessage = "Veuillez entrer une adresse email valide.")]
         public String Mail { get; set; }
 
-        [Required]
         [RegularExpression("^[a-zA-Z0-9]+$", ErrorMessage = "Le mot de passe doit contenir uniquement des caractères alphanumériques.")]
         public String Mdp { get; set; }
 
@@ -51,12 +50,7 @@ namespace VeraxShield.composants.formulaires.modeles
 
         public FormulaireAjoutModele()
         {
-            //Pseudo = "temporairementVide";
+            Mdp = null;
-            //Nom = "temporairementVide";
-            //Prenom = "temporairementVide";
-            //Mail = "temporairementVide";
-            //Mdp = "temporairementVide";
-            //IsBan = true;
         }
     }
 }

VeraxShield/VeraxShield/composants/formulaires/modeles/attributsValidationCustoms/PseudoCorrectAttribute.cs

@@ -8,7 +8,6 @@ namespace VeraxShield.composants.formulaires.modeles.attributsValidationCustoms
 {
     public class PseudoCorrectAttribute : ValidationAttribute
     {
-
         protected override ValidationResult? IsValid(object? value, ValidationContext validationContext)
         {
             bool pseudoExisteDeja = false;
@@ -16,11 +15,21 @@ namespace VeraxShield.composants.formulaires.modeles.attributsValidationCustoms
 
             foreach (Utilisateur u in DatagridUtilisateurs.Utilisateurs)
             {
-                if (u.Pseudo == pseudo && pseudo != DatagridUtilisateurs.UtilisateurSelectionne.Pseudo)
+                if ((u.Pseudo == pseudo))
+                {
+                    if (DatagridUtilisateurs.UtilisateurSelectionne == null) {
+                        return new ValidationResult("Le pseudo existe deja, choississez en un autre.");
+                    }
+
+                    if (DatagridUtilisateurs.UtilisateurSelectionne != null)
+                    {
+                        if (u.Pseudo != DatagridUtilisateurs.UtilisateurSelectionne.Pseudo)
                         {
                             return new ValidationResult("Le pseudo existe deja, choississez en un autre.");
                         }
                     }
+                }
+            }
 
             return ValidationResult.Success;
         }

VeraxShield/VeraxShield/factories/UtilisateursFactory.cs

@@ -1,4 +1,6 @@
-using VeraxShield.composants.formulaires.modeles;
+using Blazorise.DataGrid;
+using VeraxShield.composants.affichages.utilisateurs;
+using VeraxShield.composants.formulaires.modeles;
 using VeraxShield.modele.utilisateurs;
 
 namespace VeraxShield.factories
@@ -7,6 +9,21 @@ namespace VeraxShield.factories
     {
         public static Utilisateur toUtilisateur(FormulaireAjoutModele modele)
         {
+            if (DatagridUtilisateurs.UtilisateurSelectionne != null )
+            {
+                if (DatagridUtilisateurs.UtilisateurSelectionne.Mdp != modele.Mdp)
+                {
+                    var motDePasseClair = modele.Mdp;
+                    modele.Mdp = BCrypt.Net.BCrypt.HashPassword(motDePasseClair);
+                }
+            }
+            else
+            {
+                var motDePasseClair = modele.Mdp;
+                modele.Mdp = BCrypt.Net.BCrypt.HashPassword(motDePasseClair);
+            }
+            
+
             Utilisateur temp = new Utilisateur(
                 modele.Pseudo,
                 modele.Nom,
@@ -25,23 +42,16 @@ namespace VeraxShield.factories
             temp.Pseudo = u.Pseudo;
             temp.Nom = u.Nom;
             temp.Prenom = u.Prenom;
-            temp.Mdp = u.Mdp;
+
+            // ici dehash 
+            //temp.Mdp = u.Mdp;
+
+
             temp.Role = u.Role;
             temp.Mail = u.Mail;
             temp.IsBan = u.IsBan;
 
             return temp;
         }
-
-        // public static Utilisateur toUtilisateur(UtilisateurCourant appUtilisateur)
-        // {
-        //     return new Utilisateur(appUtilisateur.Pseudo, appUtilisateur.Nom, appUtilisateur.Prenom,
-        //         appUtilisateur.Roles[0], appUtilisateur.MotDePasse, appUtilisateur.Mail, false);
-        // }
-
-        public static AppUtilisateur toAppUtilisateur(Utilisateur u)
-        {
-            return new AppUtilisateur(u.Pseudo, u.Nom, u.Prenom, u.Mail, u.Mdp, u.Role);
-        }
     }    
 }

VeraxShield/VeraxShield/modele/authentification/ModeleAppUtilisateur.cs

@@ -1,4 +1,4 @@
-public class AppUtilisateur
+public class ModeleAppUtilisateur
 {
     public string MotDePasse { get; set; }
     public List<string> Roles { get; set; }
@@ -8,7 +8,7 @@ public class AppUtilisateur
     public string Mail { get; set; }
 
 
-    public AppUtilisateur(string pseudo,string nom, string prenom, string mail, string mdp, String premierRole)
+    public ModeleAppUtilisateur(string pseudo,string nom, string prenom, string mail, string mdp, String premierRole)
     {
         this.MotDePasse = mdp;
         this.Pseudo = pseudo;

VeraxShield/VeraxShield/pages/Index.razor

@@ -1,21 +1,5 @@
-@page "/"
+@using VeraxShield.composants.affichages.navBar;
-
+@page "/"
-<!--
-<h1>VeraxShield</h1>
-
-<button type="button" class="btn btn-link ml-md-auto" @onclick="@SeConnecter">Connexion</button>
-
-
-<AuthorizeView>
-    <h1> Adiu :  @context.User.Identity.Name!</h1>
-    <p>Podètz veire aquest contengut solament se sètz autentificat ! </p>
-
-    <NavLink href="/utilisateurs/liste"> -> Liste des utilisateurs</NavLink>
-
-    <button type="button" class="btn btn-link ml-md-auto" @onclick="@SeDeconnecter">Deconnexion</button>
-</AuthorizeView>
-
--->
 
 <head>
     <link rel="stylesheet" href="css/index.css">
@@ -36,7 +20,8 @@
                     <div class="button-container">
                         <button type="button" class="btn btn-link" @onclick="@RetourVerax">
                             <Icon Name="Blazorise.Icons.FontAwesome.FontAwesomeIcons.LocationArrow" />
-                            Retourner sur Verax</button>
+                            Retourner sur Verax
+                        </button>
                     </div>
                 </div>
             </main>
@@ -47,17 +32,10 @@
     </NotAuthorized>
 
     <Authorized>
+
         <body>
-            <header>
-                <h1>VeraxShield</h1>
-            </header>
             
-            <nav class="navbar">
+            <NavBarPrincipale/>
-                <div class="container">
-                    <NavLink class="btn-navbar" href="/utilisateurs/liste">Liste des utilisateurs</NavLink>
-                    <button type="button" class="btn btn-navbar ml-md-auto" @onclick="@SeDeconnecter">Deconnexion</button>
-                </div>
-            </nav>
 
             <main>
                 <div class="home-center-box">

VeraxShield/VeraxShield/pages/Index.razor.cs

@@ -9,6 +9,7 @@ namespace VeraxShield.pages
 
         [Inject]
         private NavigationManager NavigationManager {get; set;}
+
          private async Task SeDeconnecter()
         {
             await DonneurEtat.Deconnexion();

VeraxShield/VeraxShield/pages/utilisateurs/ModifierUtilisateur.razor.cs

@@ -14,24 +14,9 @@ namespace VeraxShield.pages.utilisateurs
         [Inject]
         private IUtilisateursDataService utilisateursDataService {get; set;}
 
-        //private Utilisateur utilisateur {get; set;}
-
         protected override async Task OnInitializedAsync()
 		{
-            Console.WriteLine("Passage dans le OnInitializedAsync...");
-
             this.Utilisateur = await this.utilisateursDataService.getUtilisateurFromPseudo(this.Pseudo);
-
-            if (Utilisateur != null)
-            {
-                Console.WriteLine("Pseudo du mec : " + this.Utilisateur.Pseudo);
-            }
-            else
-            {
-                Console.WriteLine("L'utilisateur est null...");
-            }
-
-            Console.WriteLine("Fin du OnInitializedParent");
 			await base.OnInitializedAsync();
 		}
     }

VeraxShield/VeraxShield/pages/utilisateurs/_Imports.razor

@@ -0,0 +1,3 @@
+@using VeraxShield.composants.affichages.navBar;
+
+@layout NavBarPrincipale

VeraxShield/VeraxShield/services/UtilisateursDataService/IUtilisateursDataService.cs

@@ -8,7 +8,6 @@ namespace VeraxShield.services.UtilisateursDataService
 
 		public Task SaveAllUtilisateurs(List<Utilisateur> list);
 
-		public Task resetDataUtilisateurs();
 		public Task AjouterUtilisateur(Utilisateur u);
 
 		public Task SupprimerUtilisateur(Utilisateur u);

VeraxShield/VeraxShield/services/UtilisateursDataService/UtilisateursDataServiceApi.cs

@@ -0,0 +1,102 @@
+using Microsoft.AspNetCore.Components;
+using VeraxShield.modele.utilisateurs;
+
+namespace VeraxShield.services.UtilisateursDataService
+{
+    public class UtilisateursDataServiceApi : IUtilisateursDataService
+    {
+        [Inject]
+		private HttpClient _clientHttp { get; set; }
+
+        [Inject]
+		public NavigationManager _navigationManager { get; set; }
+
+        private string EmplacementModification {get; set;}
+        private string EmplacementRecuperation {get; set;}
+
+        public UtilisateursDataServiceApi(HttpClient clientHttp, NavigationManager navigationManager)
+		{
+			this._clientHttp = clientHttp;
+			this._navigationManager = navigationManager;
+
+            // Le site PHP n'étant pas encore mis en ligne. Ces urls n'existent pas encore à l'heure actuelle...
+			this.EmplacementModification = "https://Verax.com/api/utilisateurs/modifier";
+            this.EmplacementRecuperation = "https://Verax.com/api/utilisateurs/recuperer";
+		}
+
+
+        public async Task AjouterUtilisateur(Utilisateur u)
+        {
+            List<Utilisateur> data = await this.getAllUtilisateurs();
+			data.Add(u);
+			await this.SaveAllUtilisateurs(data);
+        }
+
+        public async Task<List<Utilisateur>> getAllUtilisateurs()
+        {
+            List<Utilisateur> lUtilisateurs = new List<Utilisateur>();
+			var data = await this._clientHttp.GetFromJsonAsync<Utilisateur[]>(this.EmplacementRecuperation);
+
+            if (data != null)
+            {
+                lUtilisateurs = data.ToList();
+            }
+
+            return lUtilisateurs;
+        }
+
+        public async Task<Utilisateur> getUtilisateurFromPseudo(string pseudo)
+        {
+            List<Utilisateur> utilisateurs = await this.getAllUtilisateurs();
+			Utilisateur utilisateurTemporaire = null;
+
+			foreach (Utilisateur u in utilisateurs)
+			{
+				if (u.Pseudo == pseudo)
+				{
+					utilisateurTemporaire = u;
+				}
+			}
+
+			return utilisateurTemporaire;
+        }
+
+        public async Task MettreAJourUtilisateur(Utilisateur u)
+        {
+            await this.SupprimerUtilisateur(u);
+			await this.AjouterUtilisateur(u);
+        }
+
+        public async Task MettreAJourUtilisateur(Utilisateur ancienneVersion, Utilisateur nouvelleVersion)
+        {
+            await this.SupprimerUtilisateur(ancienneVersion);
+			await this.AjouterUtilisateur(nouvelleVersion);
+        }
+
+        public async Task SaveAllUtilisateurs(List<Utilisateur> list)
+        {
+            await this._clientHttp.PutAsJsonAsync(this.EmplacementModification, list);
+        }
+
+        public async Task SupprimerUtilisateur(Utilisateur u)
+        {
+            List<Utilisateur> data = await this.getAllUtilisateurs();
+            int index = -1;
+
+			foreach(Utilisateur temp in data)
+			{
+				if (temp.Pseudo == u.Pseudo)
+				{
+					index = data.IndexOf(temp);
+				}
+			}
+
+            if (index != -1)
+			{
+				data.RemoveAt(index);
+			}          
+
+            await this.SaveAllUtilisateurs(data);
+        }
+    }
+}

VeraxShield/VeraxShield/services/UtilisateursDataService/UtilisateursDataServiceFactice.cs

@@ -38,21 +38,17 @@ namespace VeraxShield.services.UtilisateursDataService
 			if (lUtilisateurs.Count == 0)
 			{
 				lUtilisateurs = await this.getUtilisateursFromJson(this.EmplacementJson);
-				await this.saveUtilisateursLocalStorage(lUtilisateurs);
-
-				Console.WriteLine("--> Le contenu du local storage a été écrasé !");
-			}
 
-			return lUtilisateurs;
+                foreach (var user in lUtilisateurs)
+                {
+                    var motDePasseClair = user.Mdp;
+                    user.Mdp = BCrypt.Net.BCrypt.HashPassword(motDePasseClair);
                 }
 
-		public async Task resetDataUtilisateurs()
-		{
-            List<Utilisateur> lUtilisateurs = new List<Utilisateur>();
-            lUtilisateurs = await this.getUtilisateursFromJson(this.EmplacementJson);
                 await this.saveUtilisateursLocalStorage(lUtilisateurs);
+			}
 
-			Console.WriteLine("Local storage reset !");
+            return lUtilisateurs;
 		}
 
 		public async Task SaveAllUtilisateurs(List<Utilisateur> list)
@@ -70,39 +66,22 @@ namespace VeraxShield.services.UtilisateursDataService
 		public async Task SupprimerUtilisateur(Utilisateur u)
 		{
             List<Utilisateur> data = await this.getAllUtilisateurs();
-
-            foreach (Utilisateur temp in data)
-            {
-                Console.WriteLine(" - d : " + temp.Pseudo);
-            }
-
             int index = -1;
 
-			foreach(Utilisateur temp in data)
+			foreach(Utilisateur utilisateurTemporaire in data)
 			{
-				if (temp.Pseudo == u.Pseudo)
+				if (utilisateurTemporaire.Pseudo == u.Pseudo)
 				{
-					index = data.IndexOf(temp);
+					index = data.IndexOf(utilisateurTemporaire);
 				}
 			}
 
-            Console.WriteLine("Index : " + index);
-
             if (index != -1)
 			{
 				data.RemoveAt(index);
 			}          
 
             await this.SaveAllUtilisateurs(data);
-
-			Console.WriteLine("L'utilisateur " + u.Pseudo + "supprimé !");
-
-			data = await this.getAllUtilisateurs();
-
-            foreach (Utilisateur temp in data)
-			{
-				Console.WriteLine(temp.Pseudo);
-			}
         }
 
 		public async Task MettreAJourUtilisateur(Utilisateur u)
@@ -130,9 +109,7 @@ namespace VeraxShield.services.UtilisateursDataService
 		private async Task<List<Utilisateur>> getUtilisateursFromLocalStorage()
 		{
 			List<Utilisateur> utilisateursFromLocalStorage = null;
-
 			var data = await _localStorage.GetItemAsync<Utilisateur[]>(EmplacementLocalStorage);
-			//utilisateursFromLocalStorage = data.ToList();
 
 			if (data == null)
 			{
@@ -148,30 +125,20 @@ namespace VeraxShield.services.UtilisateursDataService
 
         public async Task<Utilisateur> getUtilisateurFromPseudo(String pseudo)
 		{
-			Console.WriteLine("Passage dans le getFromPseudo...");
 			List<Utilisateur> utilisateurs = await this.getAllUtilisateurs();
-			Utilisateur temp = null;
+			Utilisateur utilisateurTemporaire = null;
 
 			foreach (Utilisateur u in utilisateurs)
 			{
 				if (u.Pseudo == pseudo)
 				{
-					temp = u;
+					utilisateurTemporaire = u;
-				}
 				}
-
-			if (temp == null)
-			{
-				Console.WriteLine("Aucun u. par pseudo trouve...");
-			} else
-			{
-				Console.WriteLine("Utilisateur trouvé : " + temp.Pseudo);
 			}
 
-			return temp;
+			return utilisateurTemporaire;
 		}
 
-
         private async Task saveUtilisateursLocalStorage(List<Utilisateur> lUtilisateurs)
 		{
 			await _localStorage.SetItemAsync(this.EmplacementLocalStorage, lUtilisateurs);

VeraxShield/VeraxShield/services/authentificationService/AuthentificationService.cs

@@ -1,4 +1,3 @@
-using System.Linq;
 using System.Security.Claims;
 using VeraxShield.composants.formulaires.modeles;
 using VeraxShield.modele.utilisateurs;
@@ -19,7 +18,7 @@ public class AuthentificationService : IAuthentificationService
     public async Task Connexion(RequeteConnexion requete)
     {
         await this.MajUtilisateurs();
-        var utilisateur = this.UtilisateursApplication.FirstOrDefault(w => w.Pseudo == requete.Pseudo && w.Mdp == requete.MotDePasse);
+        var utilisateur = this.UtilisateursApplication.FirstOrDefault(w => w.Pseudo == requete.Pseudo && BCrypt.Net.BCrypt.Verify(requete.MotDePasse, w.Mdp));
 
         if (utilisateur == null)
         {
@@ -50,8 +49,14 @@ public class AuthentificationService : IAuthentificationService
 
     public async Task Inscription(RequeteInscription requete)
     {
+
+        var motDePasseClair = requete.MotDePasse;
+
+        // Hach du mot de passe
+        var motDePasseHache = BCrypt.Net.BCrypt.HashPassword(motDePasseClair);
+
         await this._utilisateursDataService.AjouterUtilisateur(new Utilisateur(requete.Pseudo, requete.Nom, requete.Prenom, "invite",
-             requete.MotDePasse, requete.Mail,  false));
+             motDePasseHache, requete.Mail, false));
 
         await this.MajUtilisateurs();
     }

VeraxShield/VeraxShield/services/authentificationService/DonneurEtat.cs

@@ -39,7 +39,7 @@ public class DonneurEtat : AuthenticationStateProvider
         return Task.FromResult(new AuthenticationState(new ClaimsPrincipal(identite)));
     }
 
-    private UtilisateurCourant getUtilisateurCourant()
+    public UtilisateurCourant getUtilisateurCourant()
     {
         if (this._utilisateurCourant != null && this._utilisateurCourant.EstAuthentifie)
         {

VeraxShield/VeraxShield/shared/layouts/authentification/LayoutAuthentification.razor

@@ -1,7 +0,0 @@
-@inherits LayoutComponentBase
-
-<div class="main">
-    <div class="content px-4">
-        @Body
-    </div>
-</div>

VeraxShield/VeraxShield/wwwroot/css/composants/navBar/NavBarPrincipale.css

@@ -0,0 +1,62 @@
+body{
+    font-size : 17px;
+}
+
+.nav-link{
+    color : white;
+    margin : 0;
+}
+
+.bar-container {
+    display : flex;
+    justify-content : space-between;
+    align-items : center;
+    background-color : #053679;
+}
+
+.bar-menu {
+    display : flex;
+    justify-content : space-around;
+    align-items : center;
+    flex-grow : 1; 
+}
+
+
+.bar-menu .bar-item:first-child {
+    margin-left : 0;
+}
+
+.bar-menu .bar-item:last-child {
+    margin-right : 0;
+}
+
+.bar-menu .bar-link:hover {
+    text-decoration : none;
+    color : #D4DBE6;
+    transform : scale(1.1);
+}
+
+.btn-primary {
+    background-color : #E5E5E5;
+    color : #053679;
+    border-color: #053679;
+}
+
+.bar-role{
+    color : black;
+    font-weight : 500;
+    font-size : 15px;
+    margin-right : 20px;
+    align-self : center;
+    border : 2px solid black;
+    padding : 3px;
+    border-radius : 5px;
+}
+
+.logo {
+    width : 55px;
+}
+
+
+
+

dockerfile

@@ -0,0 +1,34 @@
+# Première étape : Créer l'image de base
+FROM mcr.microsoft.com/dotnet/aspnet:7.0 AS base
+WORKDIR /app
+EXPOSE 80
+EXPOSE 443
+
+# Deuxième étape : Construire l'application
+FROM mcr.microsoft.com/dotnet/sdk:7.0 AS build
+WORKDIR /src
+
+# Copier les fichiers nécessaires pour la restauration des dépendances
+COPY ["dockerfile", "."]
+COPY ["VeraxShield/VeraxShield/VeraxShield.csproj", "VeraxShield/"]
+RUN dotnet restore "VeraxShield/VeraxShield.csproj"
+
+# Copier le reste des fichiers
+COPY . .
+
+WORKDIR "/src/VeraxShield/VeraxShield"
+RUN dotnet build "VeraxShield.csproj" -c Release -o /app/build
+
+# Troisième étape : Publier l'application
+FROM build AS publish
+RUN dotnet publish "VeraxShield.csproj" -c Release -o /app/publish
+
+# Quatrième étape : Créer l'image finale
+FROM base AS final
+WORKDIR /app
+
+# Copier les fichiers publiés dans l'image finale
+COPY --from=publish /app/publish .
+
+# Définir le point d'entrée de l'application
+ENTRYPOINT ["dotnet", "VeraxShield.dll"]