voc list factory UT coverage

possiblité d'ajouter du vocabulaire et fix de 2/3 bugitos

.drone.yml

@@ -29,11 +29,17 @@ steps:
       sonar_host: https://codefirst.iut.uca.fr/sonar/
       sonar_token:
         from_secret: SECRET_SONAR_LOGIN
+      coverage_exclusions: "adminBlazor.Api/**,adminBlazor/Components/**,adminBlazor/Controllers/**,adminBlazor/Modals/**,adminBlazor/Pages/**,adminBlazor/Services/**,adminBlazor/Shared/**,adminBlazor/Program.cs"
+
+      
     commands:
       - cd Project/adminBlazor
       - dotnet restore adminBlazor.sln
-      - dotnet sonarscanner begin /k:$${project_key} /d:sonar.host.url=$${sonar_host} /d:sonar.login=$${sonar_token}
+      - dotnet sonarscanner begin /k:$${project_key} /d:sonar.host.url=$${sonar_host} /d:sonar.coverageReportPaths="coveragereport/SonarQube.xml" /d:sonar.coverage.exclusions=$${coverage_exclusions} /d:sonar.login=$${sonar_token}
       - dotnet build adminBlazor.sln -c Release --no-restore
+      - dotnet test adminBlazor.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 adminBlazor.sln -c Release --no-restore -o CI_PROJECT_DIR/build/release
       - dotnet sonarscanner end /d:sonar.login=$${sonar_token}
     depends_on: [tests]
 
@@ -74,6 +80,7 @@ steps:
         CONTAINERNAME: api-in-english-please
         COMMAND: create
         OVERWRITE: true
+        CODEFIRST_CLIENTDRONE_ENV_BASE_PATH: /containers/antoinejourdain-api-in-english-please/
     depends_on: [ docker-build-api ]
     when:
       branch:
@@ -103,6 +110,7 @@ steps:
         CONTAINERNAME: in-english-please
         COMMAND: create
         OVERWRITE: true
+        CODEFIRST_CLIENTDRONE_ENV_BASE_PATH: /containers/antoinejourdain-in-english-please/
     depends_on: [ docker-build-app ]
     when:
       branch:

Project/adminBlazor/TestUnit/AppUser_UT.cs

@@ -0,0 +1,28 @@
+using adminBlazor.Models;
+
+namespace TestUnit
+{
+    public class AppUser_UT
+    {
+        public static IEnumerable<object[]> SimpleAttributes()
+        {
+            yield return new object[]
+            {
+                "password",
+                new List<String>(),
+                "username"
+            };
+        }
+
+        [Theory]
+        [MemberData(nameof(SimpleAttributes))]
+        public void SimpleAttribut_Validation(string password, List<String> roles, string username)
+        {
+            var appUser = new AppUser { Password = password, Roles = roles, UserName = username };
+
+            Assert.Equal(password, appUser.Password);
+            Assert.Equal(roles, appUser.Roles);
+            Assert.Equal(username, appUser.UserName);
+        }
+    }
+}

Project/adminBlazor/TestUnit/CreatorOptions_UT.cs

@@ -0,0 +1,24 @@
+using adminBlazor.Models;
+
+namespace TestUnit
+{
+    public class CreatorOptions_UT
+    {
+        public static IEnumerable<object[]> SimpleAttributes()
+        {
+            yield return new object[]
+            {
+                new List<String>()
+            };
+        }
+
+        [Theory]
+        [MemberData(nameof(SimpleAttributes))]
+        public void SimpleAttribute_Validation(List<String> name)
+        {
+            var creatorOptions = new CreatorOptions { Name = name };
+
+            Assert.Equal(name, creatorOptions.Name);
+        }
+    }
+}

Project/adminBlazor/TestUnit/CurrentUser_UT.cs

@@ -0,0 +1,28 @@
+using adminBlazor.Models;
+
+namespace TestUnit
+{
+    public class CurrentUser_UT
+    {
+        public static IEnumerable<object[]> SimpleAttributes()
+        {
+            yield return new object[]
+            {
+                new Dictionary<string, string>(),
+                false,
+                "username"
+            };
+        }
+
+        [Theory]
+        [MemberData(nameof(SimpleAttributes))]
+        public void SimpleAttribut_Validation(Dictionary<string, string> claims, bool isAuthenticated, string username)
+        {
+            var currentUser = new CurrentUser { Claims = claims, IsAuthenticated = isAuthenticated, UserName = username };
+
+            Assert.Equal(claims, currentUser.Claims);
+            Assert.Equal(isAuthenticated, currentUser.IsAuthenticated);
+            Assert.Equal(username, currentUser.UserName);
+        }
+    }
+}

Project/adminBlazor/TestUnit/LoginRequest_UT.cs

@@ -0,0 +1,38 @@
+using adminBlazor.Models;
+using System.ComponentModel.DataAnnotations;
+
+namespace TestUnit
+{
+    public class LoginRequest_UT
+    {
+        [Theory]
+        //correct
+        [InlineData(true, "password", "username")]
+
+        //password incorrect (required)
+        [InlineData(false, null, "username")]
+        //password incorrect (required)
+        [InlineData(false, "", "username")]
+        //username incorrect (required)
+        [InlineData(false, "password", null)]
+        //username incorrect (required)
+        [InlineData(false, "password", "")]
+
+        public void LoginRequest_Validation(bool isValid, string password, string userName)
+        {
+            var loginRequest = new LoginRequest { Password = password, UserName = userName };
+
+            Assert.Equal(isValid, ValidateModel(loginRequest));
+        }
+
+        public static bool ValidateModel(LoginRequest loginRequest)
+        {
+            var validationContext = new ValidationContext(loginRequest, serviceProvider: null, items: null);
+            var validationResults = new List<ValidationResult>();
+
+            Validator.TryValidateObject(loginRequest, validationContext, validationResults, validateAllProperties: true);
+
+            return !validationResults.Any();
+        }
+    }
+}

Project/adminBlazor/TestUnit/RegisterRequest_UT.cs

@@ -0,0 +1,44 @@
+using adminBlazor.Models;
+using System.ComponentModel.DataAnnotations;
+
+namespace TestUnit
+{
+    public class RegisterRequest_UT
+    {
+        [Theory]
+        //correct
+        [InlineData(true, "password", "password", "username")]
+
+        //password incorrect (required)
+        [InlineData(false, null, "password", "username")]
+        //password incorrect (required)
+        [InlineData(false, "", "password", "username")]
+        //password confirm incorrect (required)
+        [InlineData(false, "password", null, "username")]
+        //password confirm incorrect (required)
+        [InlineData(false, "password", "", "username")]
+        //password confirm incorrect (compare)
+        [InlineData(false, "password", "passwordDifferent", "username")]
+        //username incorrect (required)
+        [InlineData(false, "password", "password", null)]
+        //username incorrect (required)
+        [InlineData(false, "password", "password", "")]
+
+        public void RegisterRequest_Validation(bool isValid, string password, string passwordConfirm, string userName)
+        {
+            var registerRequest = new RegisterRequest { Password = password, PasswordConfirm = passwordConfirm, UserName = userName };
+
+            Assert.Equal(isValid, ValidateModel(registerRequest));
+        }
+
+        public static bool ValidateModel(RegisterRequest registerRequest)
+        {
+            var validationContext = new ValidationContext(registerRequest, serviceProvider: null, items: null);
+            var validationResults = new List<ValidationResult>();
+
+            Validator.TryValidateObject(registerRequest, validationContext, validationResults, validateAllProperties: true);
+
+            return !validationResults.Any();
+        }
+    }
+}

Project/adminBlazor/TestUnit/TestUnit.csproj

@@ -0,0 +1,27 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net7.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="coverlet.collector" Version="3.2.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.1" />
+    <PackageReference Include="xunit" Version="2.4.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\adminBlazor\adminBlazor.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="Xunit" />
+  </ItemGroup>
+
+</Project>

Project/adminBlazor/TestUnit/TranslationFactory_UT.cs

@@ -0,0 +1,83 @@
+using adminBlazor.Factories;
+using adminBlazor.Models;
+using System.Transactions;
+
+namespace TestUnit
+{
+    public class TranslationFactory_UT
+    {
+        public static IEnumerable<object[]> Dataset()
+        {
+            yield return new object[]
+            {
+                new TranslationModel[]
+                {
+                    new()
+                    {
+                        Id = 1,
+                        FirstWord = "firstword",
+                        SecondWord = "secondword"
+                    },
+                    new()
+                    {
+                        Id = 2,
+                        FirstWord = "firstword2",
+                        SecondWord = "secondword2"
+                    },
+                    new()
+                    {
+                        Id = 3,
+                        FirstWord = "firstword3",
+                        SecondWord = "secondword3"
+                    }
+                }
+            };
+        }
+        [Theory]
+        [MemberData(nameof(Dataset))]
+        public void Create_Validation(TranslationModel[] translationMdls)
+        {
+            foreach (var translationMdl in translationMdls)
+            {
+                var translation = TranslationFactory.Create(translationMdl);
+
+                Assert.Equal(translationMdl.Id, translation.Id);
+                Assert.Equal(translationMdl.FirstWord, translation.FirstWord);
+                Assert.Equal(translationMdl.SecondWord, translation.SecondWord);
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(Dataset))]
+        public void Update_Validation(TranslationModel[] translationMdls)
+        {
+            foreach (var translationMdl in translationMdls)
+            {
+                var translation = TranslationFactory.Create(translationMdl);
+
+                translationMdl.FirstWord = "a";
+                translationMdl.SecondWord = "b";
+
+                TranslationFactory.Update(translation, translationMdl);
+
+                Assert.Equal(translationMdl.FirstWord, translation.FirstWord);
+                Assert.Equal(translationMdl.SecondWord, translation.SecondWord);
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(Dataset))]
+        public void ToModel_Validation(TranslationModel[] translationMdls)
+        {
+            foreach (var translationMdl in translationMdls)
+            {
+                var translation = TranslationFactory.Create(translationMdl);
+                var translationMdl2 = TranslationFactory.ToModel(translation);
+
+                Assert.Equal(translationMdl.Id, translationMdl2.Id);
+                Assert.Equal(translationMdl.FirstWord, translationMdl2.FirstWord);
+                Assert.Equal(translationMdl.SecondWord, translationMdl2.SecondWord);
+            }
+        }
+    }
+}

Project/adminBlazor/TestUnit/TranslationModel_UT.cs

@@ -0,0 +1,37 @@
+using adminBlazor.Models;
+using System.ComponentModel.DataAnnotations;
+
+namespace TestUnit
+{
+    public class TranslationModel_UT
+    {
+        [Theory]
+        //correct
+        [InlineData(true, 0, "firstWord", "secondWord")]
+        //first word incorrect (required)
+        [InlineData(false, 1, "", "secondWord")]
+        //first word incorrect (required)
+        [InlineData(false, 2, null, "secondWord")]
+        //second word incorrect (required)
+        [InlineData(false, 3, "firstWord", "")]
+        //second word incorrect (required)
+        [InlineData(false, 4, "firstWord", null)]
+
+        public void TranslationModel_Validation(bool isValid, int id, string firstWord, string secondWord)
+        {
+            var translationModel = new TranslationModel { Id = id, FirstWord = firstWord, SecondWord = secondWord };
+
+            Assert.Equal(isValid, ValidateModel(translationModel));
+        }
+
+        public static bool ValidateModel(TranslationModel translationModel)
+        {
+            var validationContext = new ValidationContext(translationModel, serviceProvider: null, items: null);
+            var validationResults = new List<ValidationResult>();
+
+            Validator.TryValidateObject(translationModel, validationContext, validationResults, validateAllProperties: true);
+
+            return !validationResults.Any();
+        }
+    }
+}

Project/adminBlazor/TestUnit/Translation_UT.cs

@@ -0,0 +1,28 @@
+using adminBlazor.Models;
+
+namespace TestUnit
+{
+    public class Translation_UT
+    {
+        public static IEnumerable<object[]> SimpleAttributes()
+        {
+            yield return new object[]
+            {
+                10,
+                "firstword",
+                "secondword"
+            };
+        }
+
+        [Theory]
+        [MemberData(nameof(SimpleAttributes))]
+        public void SimpleAttribut_Validation(int id, string firstWord, string secondWord)
+        {
+            var translation = new Translation { Id = id, FirstWord = firstWord, SecondWord = secondWord };
+
+            Assert.Equal(id, translation.Id);
+            Assert.Equal(firstWord, translation.FirstWord);
+            Assert.Equal(secondWord, translation.SecondWord);
+        }
+    }
+}

Project/adminBlazor/TestUnit/UserFactory_UT.cs

@@ -0,0 +1,157 @@
+using adminBlazor.Factories;
+using adminBlazor.Models;
+
+namespace TestUnit
+{
+    public class UserFactory_UT
+    {
+        public static IEnumerable<object[]> Dataset()
+        {
+            yield return new object[]
+            {
+                new UserModel[]
+                {
+                    new()
+                    {
+                        Id = 0,
+                        Password = "password",
+                        Email = "email",
+                        Name = "name",
+                        Surname = "surname",
+                        Nickname = "nickname",
+                        ExtraTime = false,
+                        Group = 5,
+                        Roles = new List<string>() { "student" }
+                    },
+                    new()
+                    {
+                        Id = 1,
+                        Password = "password2",
+                        Email = "email2",
+                        Name = "name2",
+                        Surname = "surname2",
+                        Nickname = "nickname2",
+                        ExtraTime = true,
+                        Group = 10,
+                        Roles = new List<string>() {"teacher"},
+                        Image = new byte[] {3, 4, 5}
+                    },
+                    new()
+                    {
+                        Id = 2,
+                        Password = "password3",
+                        Email = "email3",
+                        Name = "name3",
+                        Surname = "surname3",
+                        Nickname = "nickname3",
+                        ExtraTime = false,
+                        Group = 15,
+                        Roles = new List<string>() {"admin"},
+                        Image = new byte[] {6, 7, 8}
+                    }
+                }
+            };
+        }
+        [Theory]
+        [MemberData(nameof(Dataset))]
+        public void Create_Validation(UserModel[] userMdls)
+        {
+            foreach (var userMdl in  userMdls)
+            {
+                var user = UserFactory.Create(userMdl);
+
+                Assert.Equal(userMdl.Id, user.Id);
+                Assert.Equal(userMdl.Password, user.Password);
+                Assert.Equal(userMdl.Email, user.Email);
+                Assert.Equal(userMdl.Name, user.Name);
+                Assert.Equal(userMdl.Surname, user.Surname);
+                Assert.Equal(userMdl.Nickname, user.Nickname);
+                Assert.Equal(userMdl.ExtraTime, user.ExtraTime);
+                Assert.Equal(userMdl.Group, user.Group);
+                if (userMdl.Image != null)
+                {
+                    Assert.Equal(Convert.ToBase64String(userMdl.Image), user.ImageBase64);
+                }
+                else
+                {
+                    Assert.Null(user.ImageBase64);
+                }
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(Dataset))]
+        public void Update_Validation(UserModel[] userMdls)
+        {
+            foreach (var userMdl in userMdls)
+            {
+                if (userMdl.Image != null)
+                {
+                    userMdl.ImageBase64 = Convert.ToBase64String(userMdl.Image);
+                }
+                
+                var user = UserFactory.Create(userMdl);
+
+                userMdl.Password = "a";
+                userMdl.Email = "a.a@a.com";
+                userMdl.Name = "a";
+                userMdl.Surname = "a";
+                userMdl.Nickname = "a";
+                userMdl.ExtraTime = true;
+                userMdl.Group = 50;
+
+                UserFactory.Update(user, userMdl);
+
+                Assert.Equal(userMdl.Password, user.Password);
+                Assert.Equal(userMdl.Email, user.Email);
+                Assert.Equal(userMdl.Name, user.Name);
+                Assert.Equal(userMdl.Surname, user.Surname);
+                Assert.Equal(userMdl.Nickname, user.Nickname);
+                Assert.Equal(userMdl.ExtraTime, user.ExtraTime);
+                Assert.Equal(userMdl.Group, user.Group);
+                for (int i=0;i<user.Roles.Count;i++)
+                {
+                    user.Roles[i] = user.Roles[i].ToLower();
+                }
+                Assert.True(userMdl.Roles.SequenceEqual(user.Roles));
+
+                if(userMdl.Image != null)
+                {
+                    Assert.Equal(userMdl.ImageBase64, user.ImageBase64);
+                }
+                else
+                {
+                    Assert.Null(user.ImageBase64);
+                }
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(Dataset))]
+        public void ToModel_Validation(UserModel[] userMdls)
+        {
+            foreach (var userMdl in userMdls)
+            {
+                var user = UserFactory.Create(userMdl);
+                var userMdl2 = UserFactory.ToModel(user, Array.Empty<byte>());
+
+                Assert.Equal(userMdl.Password, userMdl2.Password);
+                Assert.Equal(userMdl.Email, userMdl2.Email);
+                Assert.Equal(userMdl.Name, userMdl2.Name);
+                Assert.Equal(userMdl.Surname, userMdl2.Surname);
+                Assert.Equal(userMdl.Nickname, userMdl2.Nickname);
+                Assert.Equal(userMdl.ExtraTime, userMdl2.ExtraTime);
+                Assert.Equal(userMdl.Group, userMdl2.Group);
+
+                if (user.ImageBase64 != null)
+                {
+                    Assert.Equal(user.ImageBase64, userMdl2.ImageBase64);
+                }
+                else
+                {
+                    Assert.Equal("", userMdl2.ImageBase64);
+                }
+            }
+        }
+    }
+}

Project/adminBlazor/TestUnit/UserModel_UT.cs

@@ -0,0 +1,60 @@
+using System.Collections.Generic;
+using Xunit;
+using adminBlazor.Models;
+using System.ComponentModel.DataAnnotations;
+
+namespace TestUnit
+{
+    public class UserModel_UT
+    {
+        [Theory]
+        //correct (minimal)
+        [InlineData(true, 0, "password", null, "name", null, null, null)]
+        //Email correct
+        [InlineData(true, 0, "password", "test@example.com", "name", null, null, null)]
+        //Surname correct
+        [InlineData(true, 0, "password", null, "name", "surname", null, null)]
+        //Nickname correct
+        [InlineData(true, 0, "password", null, "name", null, "nickname", null)]
+        //Group correct
+        [InlineData(true, 0, "password", null, "name", null, null, 5)]
+
+        //Password incorrect (required)
+        [InlineData(false, 0, "", null, "name", null, null, null)]
+        //Password incorrect (required)
+        [InlineData(false, 0, null, null, "name", null, null, null)]
+        //Password incorrect (too long)
+        [InlineData(false, 0, "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", null, "name", null, null, null)]
+        //Email incorrect (format)
+        [InlineData(false, 0, "password", "test", "name", null, null, null)]
+        //Name incorrect (required)
+        [InlineData(false, 0, "password", null, "", null, null, null)]
+        //Name incorrect (required)
+        [InlineData(false, 0, "password", null, null, null, null, null)]
+        //Name incorrect (too long)
+        [InlineData(false, 0, "password", null, "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", null, null, null)]
+        //Surname incorrect (too long)
+        [InlineData(false, 0, "password", null, "name", "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", null, null)]
+        //Nickname incorrect (too long)
+        [InlineData(false, 0, "password", null, "name", null, "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", null)]
+        //Group incorrect (range)
+        [InlineData(false, 0, "password", null, "name", null, null, 5000)]
+
+        public void UserModel_Validation(bool isValid, int id, string password, string email, string name, string surname, string nickname, int group)
+        {
+            var userModel = new UserModel { Id = id, Password = password, Email = email, Name = name , Surname = surname, Nickname = nickname, Group = group};
+
+            Assert.Equal(isValid, ValidateModel(userModel));
+        }
+
+        public static bool ValidateModel(UserModel userModel)
+        {
+            var validationContext = new ValidationContext(userModel, serviceProvider: null, items: null);
+            var validationResults = new List<ValidationResult>();
+
+            Validator.TryValidateObject(userModel, validationContext, validationResults, validateAllProperties: true);
+
+            return !validationResults.Any();
+        }
+    }
+}

Project/adminBlazor/TestUnit/User_UT.cs

@@ -0,0 +1,26 @@
+using adminBlazor.Models;
+
+namespace TestUnit
+{
+    public class User_UT
+    {
+        public static IEnumerable<object[]> SimpleAttributes()
+        {
+            yield return new object[]
+            {
+                new List<String>(),
+                "imageBase64"
+            };
+        }
+
+        [Theory]
+        [MemberData(nameof(SimpleAttributes))]
+        public void SimpleAttribut_Validation(List<String> roles, string imageBase64)
+        {
+            var user = new User { Roles = roles, ImageBase64 = imageBase64 };
+
+            Assert.Equal(roles, user.Roles);
+            Assert.Equal(imageBase64, user.ImageBase64);
+        }
+    }
+}

Project/adminBlazor/TestUnit/VocListFactory_UT.cs

@@ -0,0 +1,159 @@
+using adminBlazor.Factories;
+using adminBlazor.Models;
+using adminBlazor.Pages;
+
+namespace TestUnit
+{
+    public class VocListFactory_UT
+    {
+        public static IEnumerable<object[]> Dataset()
+        {
+            yield return new object[]
+            {
+                new VocabularyListModel[]
+                {
+                    new ()
+                    {
+                        Id = 0,
+                        Name = "name",
+                        Image = new byte[] { 0x00 },
+                        Aut = 42,
+                        Translations = new List<TranslationModel>()
+                        {
+                            new()
+                            {
+                                Id = 1,
+                                FirstWord = "firstword",
+                                SecondWord = "secondword"
+                            }
+                        }
+                    },
+                    new()
+                    {
+                        Id = 1,
+                        Name = "name2",
+                        Aut = 50,
+                        Translations = new List<TranslationModel>()
+                        {
+                            new()
+                            {
+                                Id = 2,
+                                FirstWord = "firstword2",
+                                SecondWord = "secondword2"
+                            }
+                        }
+                    },
+                    new()
+                    {
+                        Id = 1,
+                        Name = "name3",
+                        Image = new byte[] { 0x00, 0x01, 0x02 },
+                        Aut = 60,
+                        Translations = new List<TranslationModel>()
+                        {
+                            new()
+                            {
+                                Id = 3,
+                                FirstWord = "firstword3",
+                                SecondWord = "secondword3"
+                            }
+                        }
+                    }
+                }                
+            };
+        }
+        [Theory]
+        [MemberData(nameof(Dataset))]
+        public void Create_Validation(VocabularyListModel[] vocabListMdls)
+        {
+            foreach (var vocabListMdl in vocabListMdls)
+            {
+                if (vocabListMdl.Image != null)
+                {
+                    vocabListMdl.ImageBase64 = Convert.ToBase64String(vocabListMdl.Image);
+                }
+                var vocabList = VocListFactory.Create(vocabListMdl);
+
+                Assert.Equal(vocabListMdl.Id, vocabList.Id);
+                Assert.Equal(vocabListMdl.Name, vocabList.Name);
+                Assert.Equal(vocabListMdl.Aut, vocabList.Aut);
+                Assert.Equal(vocabListMdl.Image, vocabList.Image);
+                if (vocabList.Translations != null)
+                {
+                    Assert.Single(vocabList.Translations);
+                }
+                if (vocabListMdl.Image != null)
+                {
+                    Assert.Equal(vocabListMdl.ImageBase64, vocabList.ImageBase64);
+                }
+                else
+                {
+                    Assert.Null(vocabList.ImageBase64);
+                }
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(Dataset))]
+        public void Update_Validation(VocabularyListModel[] vocabListMdls)
+        {
+            foreach (var vocabListMdl in vocabListMdls)
+            {
+                if (vocabListMdl.Image != null)
+                {
+                    vocabListMdl.ImageBase64 = Convert.ToBase64String(vocabListMdl.Image);
+                }
+                var vocabList = VocListFactory.Create(vocabListMdl);
+
+                vocabListMdl.Name = "a";
+                vocabListMdl.Aut = 100;
+
+                VocListFactory.Update(vocabList, vocabListMdl);
+
+                Assert.Equal(vocabListMdl.Id, vocabList.Id);
+                Assert.Equal(vocabListMdl.Name, vocabList.Name);
+                Assert.Equal(vocabListMdl.Aut, vocabList.Aut);
+                if (vocabList.Translations != null)
+                {
+                    Assert.Single(vocabList.Translations);
+                }
+                if (vocabListMdl.Image != null)
+                {
+                    Assert.Equal(vocabListMdl.ImageBase64, vocabList.ImageBase64);
+                }
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(Dataset))]
+        public void ToModel_Validation(VocabularyListModel[] vocabListMdls)
+        {
+            foreach (var vocabListMdl in vocabListMdls)
+            {
+                if (vocabListMdl.Image != null)
+                {
+                    vocabListMdl.ImageBase64 = Convert.ToBase64String(vocabListMdl.Image);
+                }
+                var vocabList = VocListFactory.Create(vocabListMdl);
+                var vocabListMdl2 = VocListFactory.ToModel(vocabList, Array.Empty<byte>());
+
+                Assert.Equal(vocabListMdl.Id, vocabListMdl2.Id);
+                Assert.Equal(vocabListMdl.Name, vocabListMdl2.Name);
+                Assert.Equal(vocabListMdl.Aut, vocabListMdl2.Aut);
+                Assert.Equal(vocabListMdl.Image, vocabListMdl2.Image);
+                if (vocabListMdl2.Translations != null)
+                {
+                    Assert.Single(vocabListMdl2.Translations);
+                }
+                if (vocabList.ImageBase64 != null)
+                {
+                    Assert.Equal(vocabList.ImageBase64, vocabListMdl2.ImageBase64);
+                }
+                else
+                {
+                    Assert.Equal("", vocabListMdl2.ImageBase64);
+                }
+            }
+        }
+    }
+}

Project/adminBlazor/TestUnit/VocabularyListModel_UT.cs

@@ -0,0 +1,62 @@
+using adminBlazor.Models;
+using System.ComponentModel;
+using System.ComponentModel.DataAnnotations;
+using System.Data;
+using System.Runtime.Serialization;
+
+namespace TestUnit
+{
+    public class VocabularyListModel_UT
+    {
+        public static IEnumerable<object[]> SimpleAttributes()
+        {
+            yield return new object[]
+            {
+                new byte[] { 0x00, 0x01, 0x02 },
+                42,
+                "base64encodedstring",
+                new List<TranslationModel>()
+            };
+        }
+
+        [Theory]
+        //correct
+        [InlineData(true, 0, "name")]
+
+        //Name incorrect (required)
+        [InlineData(false, 0, "")]
+        //Name incorrect (required)
+        [InlineData(false, 0, null)]
+        //Name incorrect (too long)
+        [InlineData(false, 0, "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA")]
+
+        public void VocabularyListModel_Validation(bool isValid, int id, string name)
+        {
+            var vocabularyListModel = new VocabularyListModel { Id = id, Name = name };
+
+            Assert.Equal(isValid, ValidateModel(vocabularyListModel));
+        }
+
+        [Theory]
+        [MemberData(nameof(SimpleAttributes))]
+        public void SimpleAttribute_Validation(byte[] image, int aut, string imageBase64, List<TranslationModel> translations)
+        {
+            var vocabularyListModel = new VocabularyListModel { Image = image, Aut = aut, ImageBase64 = imageBase64, Translations = translations };
+            
+            Assert.Equal(image, vocabularyListModel.Image);
+            Assert.Equal(aut, vocabularyListModel.Aut);
+            Assert.Equal(imageBase64, vocabularyListModel.ImageBase64);
+            Assert.Equal(translations, vocabularyListModel.Translations);
+        }
+
+        public static bool ValidateModel(VocabularyListModel vocabularyListModel)
+        {
+            var validationContext = new ValidationContext(vocabularyListModel, serviceProvider: null, items: null);
+            var validationResults = new List<ValidationResult>();
+
+            Validator.TryValidateObject(vocabularyListModel, validationContext, validationResults, validateAllProperties: true);
+
+            return !validationResults.Any();
+        }
+    }
+}

Project/adminBlazor/TestUnit/VocabularyList_UT.cs

@@ -0,0 +1,34 @@
+using adminBlazor.Models;
+
+namespace TestUnit
+{
+    public class VocabularyList_UT
+    {
+        public static IEnumerable<object[]> SimpleAttributes()
+        {
+            yield return new object[]
+            {
+                10,
+                "name",
+                new byte[] { 0x00, 0x01, 0x02 },
+                15,
+                "imageBase64",
+                new List<Translation>()
+            };
+        }
+
+        [Theory]
+        [MemberData(nameof(SimpleAttributes))]
+        public void SimpleAttribut_Validation(int id, string name, byte[] image, int aut, string imageBase64, List<Translation> translations)
+        {
+            var vocabularyList = new VocabularyList { Id = id, Name = name, Image = image, Aut = aut, ImageBase64 = imageBase64, Translations = translations };
+
+            Assert.Equal(id, vocabularyList.Id);
+            Assert.Equal(name, vocabularyList.Name);
+            Assert.Equal(image, vocabularyList.Image);
+            Assert.Equal(aut, vocabularyList.Aut);
+            Assert.Equal(imageBase64, vocabularyList.ImageBase64);
+            Assert.Equal(translations, vocabularyList.Translations);
+        }
+    }
+}

Project/adminBlazor/adminBlazor.Api/Controllers/UserController.cs

@@ -34,7 +34,7 @@ namespace Minecraft.Crafting.Api.Controllers
         /// <param name="item">The item.</param>
         /// <returns>The async task.</returns>
         [HttpPost]
-        [Route("")]
+        [Route("add")]
         public Task Add(User item)
         {
             var data = JsonSerializer.Deserialize<List<User>>(System.IO.File.ReadAllText("Data/users.json"), _jsonSerializerOptions);
@@ -46,6 +46,11 @@ namespace Minecraft.Crafting.Api.Controllers
 
             // Simulate the Id
             item.Id = data.Max(s => s.Id) + 1;
+            if(item.ImageBase64 == "string")
+                item.ImageBase64 = null;
+            if (item.Roles.FirstOrDefault() == "string")
+                item.Roles.Add("Student");
+
 
             data.Add(item);
 

Project/adminBlazor/adminBlazor.sln

@@ -7,6 +7,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "adminBlazor", "adminBlazor\
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "adminBlazor.Api", "adminBlazor.Api\adminBlazor.Api.csproj", "{69C7F430-9B80-4253-B572-FDBC90076C5E}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TestUnit", "TestUnit\TestUnit.csproj", "{CB813C21-C3DC-455A-8D56-17EAB8583EA2}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -21,6 +23,10 @@ Global
 		{69C7F430-9B80-4253-B572-FDBC90076C5E}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{69C7F430-9B80-4253-B572-FDBC90076C5E}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{69C7F430-9B80-4253-B572-FDBC90076C5E}.Release|Any CPU.Build.0 = Release|Any CPU
+		{CB813C21-C3DC-455A-8D56-17EAB8583EA2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{CB813C21-C3DC-455A-8D56-17EAB8583EA2}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{CB813C21-C3DC-455A-8D56-17EAB8583EA2}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{CB813C21-C3DC-455A-8D56-17EAB8583EA2}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

Project/adminBlazor/adminBlazor/Factories/TranslationFactory.cs

@@ -0,0 +1,35 @@
+using adminBlazor.Models;
+
+namespace adminBlazor.Factories;
+
+public class TranslationFactory
+{
+    public static Translation Create(TranslationModel model)
+    {
+        return new Translation
+        {
+            Id = model.Id,
+            FirstWord = model.FirstWord,
+            SecondWord = model.SecondWord
+        };
+    }
+    
+    public static TranslationModel ToModel(Translation translation)
+    {
+        return new TranslationModel
+        {
+            Id = translation.Id,
+            FirstWord = translation.FirstWord,
+            SecondWord = translation.SecondWord
+        };
+    }
+    
+    public static void Update(Translation item, TranslationModel model)
+    {
+        if (!string.IsNullOrEmpty(model.FirstWord))
+            item.FirstWord = model.FirstWord;
+
+        if (!string.IsNullOrEmpty(model.SecondWord))
+            item.SecondWord = model.SecondWord;
+    }
+}

Project/adminBlazor/adminBlazor/Factories/UserFactory.cs

@@ -36,7 +36,6 @@ namespace adminBlazor.Factories
                 Surname = user.Surname,
                 Nickname = user.Nickname,
                 ExtraTime = user.ExtraTime,
-                //Image = user.Image,
                 Group = user.Group,
                 Password = user.Password,
                 Email = user.Email,

Project/adminBlazor/adminBlazor/Factories/VocListFactory.cs

@@ -9,34 +9,73 @@ namespace adminBlazor.Factories
 {
     public static class VocListFactory
     {
-        public static VocabularyListModel ToModel(VocabularyList voc)
+        public static VocabularyListModel ToModel(VocabularyList voc, byte[] imageContent)
         {
-            return new VocabularyListModel
+            VocabularyListModel model = new VocabularyListModel
             {
                 Id = voc.Id,
                 Name = voc.Name,
                 Image = voc.Image,
-                Aut = voc.Aut
+                Aut = voc.Aut,
+                ImageBase64 = string.IsNullOrWhiteSpace(voc.ImageBase64) ? Convert.ToBase64String(imageContent) : voc.ImageBase64
             };
+                model.Translations = new List<TranslationModel>();
+                foreach (var item in voc.Translations)
+                {
+                    model.Translations.Add(new TranslationModel
+                    {
+                        Id = item.Id,
+                        FirstWord = item.FirstWord,
+                        SecondWord = item.SecondWord
+                    });
+            }
+            return model;
         }
 
         public static VocabularyList Create(VocabularyListModel voc)
         {
-            return new VocabularyList
+            VocabularyList model = new VocabularyList
             {
                 Id = voc.Id,
                 Name = voc.Name,
                 Image = voc.Image,
-                Aut = voc.Aut
+                Aut = voc.Aut,
+                ImageBase64 = voc.Image != null ? Convert.ToBase64String(voc.Image) : null
             };
+            model.Translations = new List<Translation>();
+            foreach (var item in voc.Translations)
+            {
+                model.Translations.Add(new Translation
+                {
+                    Id = item.Id,
+                    FirstWord = item.FirstWord,
+                    SecondWord = item.SecondWord
+                });
+            }
+            return model;
         }
         public static void Update(VocabularyList item, VocabularyListModel voc)
         {
             if (!string.IsNullOrEmpty(voc.Name))
                 item.Name = voc.Name;
 
-            if (!string.IsNullOrEmpty(voc.Image))
+            if (voc.ImageBase64 != null && voc.Image != null)
-                item.Image = voc.Image;
+                item.ImageBase64 = Convert.ToBase64String(voc.Image);
+
+            if (voc.Aut != null)
+                item.Aut = voc.Aut;
+
+            if (voc.Translations == null) return;
+            item.Translations = new List<Translation>();
+            foreach (var translation in voc.Translations)
+            {
+                item.Translations.Add(new Translation
+                {
+                    Id = translation.Id,
+                    FirstWord = translation.FirstWord,
+                    SecondWord = translation.SecondWord
+                });
+            }
         }
 
     }

Project/adminBlazor/adminBlazor/Models/Translation.cs

@@ -3,10 +3,9 @@ namespace adminBlazor.Models
 {
 	public class Translation
 	{
-        private int id;
+		public int Id { get; set; }
-		private string word1;
+		public string FirstWord { get; set; }
-		private string word2;
+		public string SecondWord { get; set; }
-		private int listVoc;
 	}
 }
 

Project/adminBlazor/adminBlazor/Models/TranslationModel.cs

@@ -0,0 +1,15 @@
+using System;
+using System.ComponentModel.DataAnnotations;
+
+namespace adminBlazor.Models
+{
+	public class TranslationModel
+	{
+		public int Id { get; set; }
+		[Required]
+		public string FirstWord { get; set; }
+		[Required]
+		public string SecondWord { get; set; }
+	}
+}
+

Project/adminBlazor/adminBlazor/Models/VocabularyList.cs

@@ -5,8 +5,11 @@ namespace adminBlazor.Models
 	{
 		public int Id { get; set; }
         public string Name { get; set; }
-        public string Image { get; set; }
+        public byte[] Image { get; set; }
         public int? Aut { get; set; }
-    }
+        
+        public string? ImageBase64 { get; set; }
+        public List<Translation>? Translations { get; set; }
+	}
 }
 

Project/adminBlazor/adminBlazor/Models/VocabularyListModel.cs

@@ -8,11 +8,16 @@ namespace adminBlazor.Models
         [Required]
         public int Id { get; set; }
 
+        [Required]
+        [StringLength(50, ErrorMessage = "Name length can't be more than 50.")]
         public string Name { get; set; }
 
-        public string Image { get; set; }
+        public byte[] Image { get; set; }
 
         public int? Aut { get; set; }
+        
+        public string ImageBase64 { get; set; }
+        public List<TranslationModel>? Translations { get; set; }
     }
 }
 

Project/adminBlazor/adminBlazor/Pages/AddUser.razor

@@ -1,5 +1,6 @@
-@page "/add"
+@page "/addUser"
 @attribute [Authorize(Roles = "admin")]
+@using adminBlazor.Models
 <h3>Add</h3>
 
 <EditForm Model="@user" OnValidSubmit="@HandleValidSubmit">

Project/adminBlazor/adminBlazor/Pages/AddUser.razor.cs

@@ -7,7 +7,7 @@ using adminBlazor.Services;
 
 namespace adminBlazor.Pages
 {
-    public partial class Add
+    public partial class AddUser
     {
         [Inject]
         public NavigationManager NavigationManager { get; set; }
@@ -26,7 +26,7 @@ namespace adminBlazor.Pages
         /// <summary>
         /// The current user model
         /// </summary>
-        private Models.UserModel user = new Models.UserModel()
+        private UserModel user = new UserModel()
         {
             Roles = new List<string>()
     };

Project/adminBlazor/adminBlazor/Pages/AddVoc.razor

@@ -0,0 +1,44 @@
+@page "/addVoc"
+@attribute [Authorize(Roles = "teacher")]
+@using adminBlazor.Models
+@using Blazorise.Extensions
+<h3>Add Vocabulary List</h3>
+
+<EditForm Model="@voc" OnValidSubmit="@HandleValidSubmit">
+    <DataAnnotationsValidator />
+    <ValidationSummary />
+
+    <p>
+        <label for="name">
+            Name:
+            <InputText id="name" @bind-Value="voc.Name" />
+            <ValidationMessage For="@(() => voc.Name)"/>
+        </label>
+    </p>
+    <h4>Words:</h4>
+                @if (voc.Translations.IsNullOrEmpty() == false)
+                {
+                    foreach (var word in voc.Translations)
+                    {
+                        {
+                            <div class="word-container">
+                                <label>
+                                    First Word:
+                                    <InputText @bind-Value="word.FirstWord"/>
+                                </label>
+                                <label>
+                                    Second Word:
+                                    <InputText @bind-Value="word.SecondWord"/>
+                                </label>
+                            </div>
+                            <button type="button" @onclick="() => RemoveWord(word)">Remove Word</button>
+                        }
+                    }
+                }
+                else
+                {
+                    <p>No words</p>
+                }
+                <button type="button" @onclick="AddWord">Add Word</button>
+                <button type="submit">Submit</button>
+</EditForm>

Project/adminBlazor/adminBlazor/Pages/AddVoc.razor.cs

@@ -0,0 +1,40 @@
+using Blazored.LocalStorage;
+using Microsoft.AspNetCore.Components.Forms;
+using Microsoft.AspNetCore.Components;
+using adminBlazor.Models;
+using Microsoft.AspNetCore.Mvc.RazorPages;
+using adminBlazor.Services;
+
+namespace adminBlazor.Pages
+{
+    public partial class AddVoc
+    {
+        [Inject] public NavigationManager NavigationManager { get; set; }
+
+        [Inject] public IVocListService VocService { get; set; }
+
+        private VocabularyListModel voc = new VocabularyListModel();
+
+        private async void HandleValidSubmit()
+        {
+            voc.Translations ??= new List<TranslationModel>();
+            await VocService.Add(voc);
+
+            NavigationManager.NavigateTo("voc");
+        }
+        
+        private void AddWord()
+        {
+            if (voc.Translations == null)
+            {
+                voc.Translations = new List<TranslationModel>();
+            }
+            voc.Translations.Add(new TranslationModel());
+        }
+        
+        private void RemoveWord(TranslationModel word)
+        {
+            voc.Translations.Remove(word);
+        }
+    }
+}

Project/adminBlazor/adminBlazor/Pages/EditUser.razor.cs

@@ -54,10 +54,9 @@ namespace adminBlazor.Pages
         {
             var item = await DataService.GetById(Id);
 
-               var fileContent = await File.ReadAllBytesAsync($"{WebHostEnvironment.WebRootPath}/images/default.jpeg");
+            var fileContent = await File.ReadAllBytesAsync($"{WebHostEnvironment.WebRootPath}/images/default.jpeg");
 
             // Set the model with the item
-
             user = UserFactory.ToModel(item,fileContent);
         }
 

Project/adminBlazor/adminBlazor/Pages/EditVoc.razor

@@ -1,29 +1,55 @@
 @page "/editVoc/{Id:int}"
 @attribute [Authorize(Roles = "teacher")]
 @using adminBlazor.Models
+@using Blazorise.Extensions
 
 
 <h3>Edit</h3>
 <h4>Voc id : @Id</h4>
-<EditForm Model="@voc" OnValidSubmit="@HandleValidSubmit">
+@if (voc != null)
-    <DataAnnotationsValidator />
+{
-    <ValidationSummary />
+    <EditForm Model="@voc" OnValidSubmit="@HandleValidSubmit">
+        <DataAnnotationsValidator />
+        <ValidationSummary />
         
-    <p>
+        <p>
-        <label for="name">
+            <label for="name">
-            Name:
+                Name:
-            <InputText id="name" @bind-Value="voc.Name" />
+                <InputText id="name" @bind-Value="voc.Name" />
-            <ValidationMessage For="@(() => voc.Name)" />
+                <ValidationMessage For="@(() => voc.Name)" />
-        </label>
+            </label>
-    </p>
 
-    <p>
+        </p>
-        <label for="image">
-            Image:
-            <InputText id="image" @bind-Value="voc.Image" />
-            <ValidationMessage For="@(() => voc.Image)" />
-        </label>
-    </p>
         
-    <button type="submit">Submit</button>
+        <h4>Words:</h4>
-</EditForm>
+        @if (voc.Translations.IsNullOrEmpty() == false)
+        {
+            foreach (var word in voc.Translations)
+            {
+                {
+                    <div class="word-container">
+                        <label>
+                            First Word:
+                            <InputText @bind-Value="word.FirstWord"/>
+                        </label>
+                        <label>
+                            Second Word:
+                            <InputText @bind-Value="word.SecondWord"/>
+                        </label>
+                    </div>
+                    <button type="button" @onclick="() => RemoveWord(word)">Remove Word</button>
+                }
+            }
+        }
+        else
+        {
+            <p>No words</p>
+        }
+        <button type="button" @onclick="AddWord">Add Word</button>
+        <button type="submit">Submit</button>
+    </EditForm>
+}
+else
+{
+    <p>Loading...</p>
+}

Project/adminBlazor/adminBlazor/Pages/EditVoc.razor.cs

@@ -3,7 +3,11 @@ using adminBlazor.Models;
 using adminBlazor.Services;
 using Blazored.LocalStorage;
 using Microsoft.AspNetCore.Components;
+using Microsoft.AspNetCore.Components.Forms;
 using Microsoft.AspNetCore.Hosting;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
 
 
 namespace adminBlazor.Pages
@@ -22,23 +26,46 @@ namespace adminBlazor.Pages
         [Inject]
         public IWebHostEnvironment WebHostEnvironment { get; set; }
 
-        public VocabularyList currVoc;
-
         private VocabularyListModel voc = new VocabularyListModel();
 
         private async void HandleValidSubmit()
         {
             await VocListService.Update(Id, voc);
 
-            NavigationManager.NavigateTo("list");
+            NavigationManager.NavigateTo("voc");
+        }
+        
+        private async Task LoadImage(InputFileChangeEventArgs e)
+        {
+            // Set the content of the image to the model
+            using (var memoryStream = new MemoryStream())
+            {
+                await e.File.OpenReadStream().CopyToAsync(memoryStream);
+                voc.Image = memoryStream.ToArray();
+            }
+        }
+
+        private void AddWord()
+        {
+            if (voc.Translations == null)
+            {
+                voc.Translations = new List<TranslationModel>();
+            }
+            voc.Translations.Add(new TranslationModel());
         }
         
+        private void RemoveWord(TranslationModel word)
+        {
+            voc.Translations.Remove(word);
+        }
 
-        protected async Task OnInitializedAsync()
+        protected override async Task OnInitializedAsync()
         {
             var item = await VocListService.GetById(Id);
 
-            voc = VocListFactory.ToModel(item);
+            var fileContent = await File.ReadAllBytesAsync($"{WebHostEnvironment.WebRootPath}/images/default.jpeg");
+            
+            voc = VocListFactory.ToModel(item,fileContent);
         }
     }
 }

Project/adminBlazor/adminBlazor/Pages/List.razor

@@ -11,9 +11,7 @@
 <h3>List</h3>
 
 <div>
-    <NavLink class="btn btn-primary" href="Add" Match="NavLinkMatch.All">
+      <a href="addUser" class="btn btn-primary" > <i class="fa fa-plus"></i> Ajouter </a> 
-        <i class="fa fa-plus"></i> Ajouter
-    </NavLink>
 </div>
 
 <DataGrid TItem="User"

Project/adminBlazor/adminBlazor/Pages/Voc.razor

@@ -10,6 +10,10 @@
 <link href="_content/Blazorise.Bootstrap/blazorise.bootstrap.css" rel="stylesheet" />
 <h3>Vocabulary Lists</h3>
 
+<div>
+      <a href="addVoc" class="btn btn-primary" > <i class="fa fa-plus"></i> Ajouter </a> 
+</div>
+
 <DataGrid TItem="VocabularyList"
           Data="@_vocList"
           ReadData="@OnReadData"
@@ -18,9 +22,20 @@
           ShowPager
           Responsive>
 
+    <DataGridColumn TItem="VocabularyList" Field="@nameof(VocabularyList.Id)" Caption="Image">
+        <DisplayTemplate>
+            @if (!string.IsNullOrWhiteSpace(context.ImageBase64))
+            {
+                <img src="@($"data:image/png;base64, {context.ImageBase64}")" class="img-thumbnail" style="min-width: 50px; max-width: 150px" />
+            }
+            else
+            {
+                <img src="images/words.jpg" class="img-thumbnail" style="max-width: 150px" />
+            }
+        </DisplayTemplate>
+    </DataGridColumn>
     <DataGridColumn TItem="VocabularyList" Field="@nameof(VocabularyList.Id)" Caption="id" />
     <DataGridColumn TItem="VocabularyList" Field="@nameof(VocabularyList.Name)" Caption="Name" />
-    <DataGridColumn TItem="VocabularyList" Field="@nameof(VocabularyList.Image)" Caption="Image" />
     <DataGridColumn TItem="VocabularyList" Field="@nameof(VocabularyList.Aut)" Caption="Author ID">
         <DisplayTemplate>
             @if (context is VocabularyList voc)

Project/adminBlazor/adminBlazor/Pages/_Host.cshtml

@@ -1,5 +1,6 @@
 @page "/"
 @using Microsoft.AspNetCore.Components.Web
+@using Microsoft.AspNetCore.Mvc.TagHelpers
 @namespace adminBlazor.Pages
 @addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
 

Project/adminBlazor/adminBlazor/Program.cs

@@ -25,7 +25,6 @@ builder.Services.AddBlazoredModal();
 builder.Services.AddRazorPages();
     builder.Services.AddServerSideBlazor();
 builder.Services.AddScoped<IDataService, DataLocalService>();
-builder.Services.AddScoped<IDataService, DataApiService>();
 
 
 builder.Services.AddScoped<IVocListService, VocListLocalService>();

Project/adminBlazor/adminBlazor/Properties/launchSettings.json

@@ -1,14 +1,5 @@
 {
   "profiles": {
-    "http": {
-      "commandName": "Project",
-      "launchBrowser": true,
-      "environmentVariables": {
-        "ASPNETCORE_ENVIRONMENT": "Development"
-      },
-      "applicationUrl": "http://localhost:5138",
-      "dotnetRunMessages": true
-    },
     "https": {
       "commandName": "Project",
       "launchBrowser": true,

Project/adminBlazor/adminBlazor/Services/AuthService.cs

@@ -20,8 +20,8 @@
         {
             CurrentUser = new List<AppUser>
             {
-                new AppUser { UserName = "Admin", Password = "123456", Roles = new List<string> { "admin" } },
+                new AppUser { UserName = "Admin", Password = "1", Roles = new List<string> { "admin" } },
-                new AppUser{ UserName ="Teacher1", Password = "123456", Roles = new List<string>{ "teacher" } }
+                new AppUser{ UserName = "Teacher", Password = "1", Roles = new List<string>{ "teacher" } }
             };
         }
 

Project/adminBlazor/adminBlazor/Services/DataApiService.cs

@@ -1,6 +1,7 @@
 using adminBlazor.Components;
 using adminBlazor.Factories;
 using adminBlazor.Models;
+using Microsoft.AspNetCore.Http.HttpResults;
 using System.Reflection.Metadata.Ecma335;
 
 namespace adminBlazor.Services
@@ -24,24 +25,24 @@ namespace adminBlazor.Services
             var item = UserFactory.Create(model);
 
             // Save the data
-            await _http.PostAsJsonAsync("https://localhost:7234/api/User/", item);
+            await _http.PostAsJsonAsync("http://host.docker.internal:7234/api/User/", item);
         }
 
         public async Task<int> Count()
         {
-            return await _http.GetFromJsonAsync<int>("https://localhost:7234/api/User/count");
+            return await _http.GetFromJsonAsync<int>("http://host.docker.internal:7234/api/User/count");
         }
 
         public async Task<List<User>> List(int currentPage, int pageSize)
         {
             _logger.LogInformation("User API : call of method LIST.");
-            return await _http.GetFromJsonAsync<List<User>>($"https://localhost:7234/api/User/?currentPage={currentPage}&pageSize={pageSize}");
+            return await _http.GetFromJsonAsync<List<User>>($"http://host.docker.internal:7234/api/User/?currentPage={currentPage}&pageSize={pageSize}");
         }
 
         public async Task<User> GetById(int id)
         {
             _logger.LogInformation("User API : call of method GetByID.");
-            return await _http.GetFromJsonAsync<User>($"https://localhost:7234/api/User/{id}");
+            return await _http.GetFromJsonAsync<User>($"http://host.docker.internal:7234/api/User/{id}");
         }
 
         public async Task Update(int id, UserModel model)
@@ -51,18 +52,18 @@ namespace adminBlazor.Services
 
             _logger.LogInformation("User API : call of method UPDATE on User ID : {Id}.", id);
 
-             await _http.PutAsJsonAsync($"https://localhost:7234/api/User/{id}", item);
+             await _http.PutAsJsonAsync($"http://host.docker.internal:7234/api/User/{id}", item);
         }
 
         public async Task Delete(int id)
         {
             _logger.LogInformation("User API : call of method DELETE on User ID : {Id}.", id);
-            await _http.DeleteAsync($"https://localhost:7234/api/User/{id}");
+            await _http.DeleteAsync($"http://host.docker.internal:7234/api/User/{id}");
         }
 
          public async Task<List<CraftingRecipe>> GetRecipes()
          {
-            return await _http.GetFromJsonAsync<List<CraftingRecipe>>("https://localhost:7234/api/User/recipe");
+            return await _http.GetFromJsonAsync<List<CraftingRecipe>>("http://host.docker.internal:7234/api/User/recipe");
          }
     }
 }

Project/adminBlazor/adminBlazor/Services/VocListLocalService.cs

@@ -62,6 +62,7 @@ namespace adminBlazor.Services
             {
                 // this code add in the local storage the fake data
                 var originalData = await _http.GetFromJsonAsync<VocabularyList[]>($"{_navigationManager.BaseUri}voc.json");
+                
                 await _localStorage.SetItemAsync("voc", originalData);
             }
 

Project/adminBlazor/adminBlazor/appsettings.json

@@ -1,4 +1,5 @@
 {
+  "https_port": 443,
   "Creators": {
     "Name": [
       "Patrick Brugière",
@@ -10,7 +11,8 @@
   "Logging": {
     "LogLevel": { 
       "Default": "Error", 
-      "Microsoft": "Warning" 
+      "Microsoft.AspNetCore": "Warning",
+      "Microsoft.AspNetCore.DataProtection": "None"
     },
     "Debug": {
       "LogLevel": {

Project/adminBlazor/adminBlazor/wwwroot/voc.json

@@ -2,13 +2,27 @@
   {
     "id": 1,
     "name": "Entreprise",
-    "image": "link",
+    "image": null,
-    "aut": null
+    "aut": null,
+    "translations" : [{
+      "id": 1,
+      "firstWord" : "pain",
+      "secondWord" : "bread"
+    },
+      {"id": 1,
+        "firstWord" : "vin",
+        "secondWord" : "wine"
+      }]
   },
   {
     "id": 2,
     "name": "Animaux",
-    "image": "link",
+    "image": null,
-    "aut" :  1
+    "aut" :  1,
+    "translations": [{
+      "id": 1,
+      "firstWord" : "baguette",
+      "secondWord" : "pain"
+    }]
   }
 ]