Merge branch 'developpement'

.drone.yml

@@ -0,0 +1,67 @@
+kind: pipeline
+type: docker
+name: pipelinefordeveloppement
+
+trigger:
+  branch:
+    - developpement
+    - master
+    - upgradeclass
+  event:
+    - push 
+
+steps:
+  - name: build
+    image: mcr.microsoft.com/dotnet/sdk:7.0
+    commands:
+      - cd notus/
+      - dotnet restore notus_without_maui.sln
+      - dotnet build notus_without_maui.sln -c Release --no-restore /p:AndroidSdkDirectory=$ANDROID_SDK_ROOT -property:Aapt2ToolPath=$ANDROID_SDK_ROOT/build-tools/33.0.0
+      - dotnet publish notus_without_maui.sln -c Release --no-restore -o $CI_PROJECT_DIR/build/release
+
+  - name: tests
+    image: mcr.microsoft.com/dotnet/sdk:7.0
+    commands:
+      - cd notus/
+      - dotnet restore notus_without_maui.sln
+      - dotnet test notus_without_maui.sln --no-restore
+    depends_on: [build]
+
+  - name: sonar
+    image: hub.codefirst.iut.uca.fr/marc.chevaldonne/codefirst-dronesonarplugin-dotnet7
+    secrets: [ Sonar_Login ]
+    environment:
+      sonar_host: https://codefirst.iut.uca.fr/sonar/
+      sonar_token:
+        from_secret: Sonar_Login
+      project_key: notus_ThMo
+      coverage_exclusions: "Tests/**/**,Notus_Console/**"
+    commands:
+      - cd notus/
+      - dotnet restore notus_without_maui.sln
+      - 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 notus_without_maui.sln -c Release --no-restore
+      - dotnet test notus_without_maui.sln --logger trx --no-restore /p:CollectCoverage=true /p:CoverletOutputFormat=cobertura --collect "XPlat Code Coverage"
+      - reportgenerator -reports:'**/coverage.cobertura.xml' -reporttypes:SonarQube -targetdir:"coveragereport" -verbosity:Verbose
+      - dotnet publish notus_without_maui.sln -c Release --no-restore -o CI_PROJECT_DIR/build/release
+      - dotnet sonarscanner end /d:sonar.login=$${sonar_token}
+    branch:
+      - developpement
+    depends_on: [build,tests]
+
+  - name: generate-and-deploy-docs
+    image: hub.codefirst.iut.uca.fr/thomas.bellembois/codefirst-docdeployer
+    failure: ignore
+    volumes:
+      - name: docs
+        path: /docs
+    commands:
+      - /entrypoint.sh
+    when:
+      branch:
+        - master
+#    environment: 
+#      NODOXYGEN: true
+volumes:
+- name: docs
+  temp: {}

README.md

@@ -0,0 +1,12 @@
+[![Build Status](https://codefirst.iut.uca.fr/api/badges/matheo.thierry/notus/status.svg)](https://codefirst.iut.uca.fr/matheo.thierry/notus)  
+[![Quality Gate Status](https://codefirst.iut.uca.fr/sonar/api/project_badges/measure?project=notus_ThMo&metric=alert_status&token=f49680ff7f8cbaaa0872d836ad12346debbf5164)](https://codefirst.iut.uca.fr/sonar/dashboard?id=notus_ThMo)
+[![Coverage](https://codefirst.iut.uca.fr/sonar/api/project_badges/measure?project=notus_ThMo&metric=coverage&token=f49680ff7f8cbaaa0872d836ad12346debbf5164)](https://codefirst.iut.uca.fr/sonar/dashboard?id=notus_ThMo)
+[![Lines of Code](https://codefirst.iut.uca.fr/sonar/api/project_badges/measure?project=notus_ThMo&metric=ncloc&token=f49680ff7f8cbaaa0872d836ad12346debbf5164)](https://codefirst.iut.uca.fr/sonar/dashboard?id=notus_ThMo)
+
+# SAE 2.01 - Développement d'une application
+
+## Présentation 
+
+Dans le cadre de la SAE, notre mission consiste à développer une application de prise de notes. Cette application sera un outil pratique pour les personnes qui cherchent à organiser leurs idées et leurs pensées.
+
+Notre application sera facile à utiliser et intuitive, avec une interface simple et épurée qui permettra à l'utilisateur de s'orienter facilement. Elle permettra de partager les notes avec d'autres utilisateurs et de les gérer avec des tags. L’application sera personnalisable grâce à la possibilité de choisir parmi plusieurs thèmes et logos fournis. Les utilisateurs pourront également créer leurs propres thèmes.

notus/Biblioteque_de_Class/Biblioteque_de_Class.csproj

@@ -6,4 +6,8 @@
     <Nullable>enable</Nullable>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="NHibernate" Version="5.4.2" />
+  </ItemGroup>
+
 </Project>

notus/Biblioteque_de_Class/Biblioteque_de_Class.sln

@@ -0,0 +1,34 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.5.33424.131
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Biblioteque_de_Class", "Biblioteque_de_Class.csproj", "{CC2FF847-9D3A-44F7-8672-C70A4FE87C5B}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Notus_Console", "..\Notus_Console\Notus_Console.csproj", "{F48CF8AB-163E-4D63-B210-BDA22BE5251D}"
+	ProjectSection(ProjectDependencies) = postProject
+		{CC2FF847-9D3A-44F7-8672-C70A4FE87C5B} = {CC2FF847-9D3A-44F7-8672-C70A4FE87C5B}
+	EndProjectSection
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{CC2FF847-9D3A-44F7-8672-C70A4FE87C5B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{CC2FF847-9D3A-44F7-8672-C70A4FE87C5B}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{CC2FF847-9D3A-44F7-8672-C70A4FE87C5B}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{CC2FF847-9D3A-44F7-8672-C70A4FE87C5B}.Release|Any CPU.Build.0 = Release|Any CPU
+		{F48CF8AB-163E-4D63-B210-BDA22BE5251D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{F48CF8AB-163E-4D63-B210-BDA22BE5251D}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{F48CF8AB-163E-4D63-B210-BDA22BE5251D}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{F48CF8AB-163E-4D63-B210-BDA22BE5251D}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {0AA9469C-FA7B-4AF1-9C90-056193DA2415}
+	EndGlobalSection
+EndGlobal

notus/Biblioteque_de_Class/Category.cs

@@ -1,13 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Biblioteque_de_Class
-{
-    internal class Category
-    {
-        public string nom { get; set; }
-    }
-}

notus/Biblioteque_de_Class/Database.cs

@@ -0,0 +1,206 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.ComponentModel.Design;
+using System.Data;
+using System.Linq;
+using System.Runtime.Serialization;
+using System.Text;
+using System.Threading.Tasks;
+using System.Web;
+
+namespace Biblioteque_de_Class
+{
+    [DataContract]
+    public class Database
+    {
+        [DataMember]
+        public List<Logo> DefaultLogoList { get; private set; }
+        [DataMember]
+        public List<Theme> ThemeList { get; private set; }
+        [DataMember]
+        public List<User> Users;
+        public List<User> UserList
+        {
+            get => Users; private set
+            {
+                Users = value;
+            }
+        }
+
+        public Database()
+        {
+            DefaultLogoList = new List<Logo>();
+            ThemeList = new List<Theme>();
+            UserList = new List<User>();
+        }
+
+        public void SetDefaultLogoList(List<Logo> defaultLogoList) {  DefaultLogoList = defaultLogoList; }
+        public void SetDefaultThemeList(List<Theme> defaultThemeList) { ThemeList = defaultThemeList; }
+        public void SetUserList(List<User> userList) { UserList = userList; }
+
+        /// <summary>
+        /// recherche un utilisateur dans la liste d'utilisateur
+        /// </summary>
+        public User SearchUser(string name)
+        {
+            foreach(User user in UserList)
+            {
+                if (user.Username == name)
+                {
+                    return user;
+                }
+            }
+            throw new NotFoundException("No user found with this username.");
+        }
+
+        /// <summary>
+        /// récupérer le lien d'un logo
+        /// </summary>
+        public string? GetLogoLink(string name)
+        {
+            foreach (Logo logo in DefaultLogoList)
+            {
+                if (logo.Name == name) { return logo.LogoLink; }
+            }
+            throw new NotFoundException("No logo link found.");
+        }
+
+        /// <summary>
+        /// récupérer un utilisateur
+        /// </summary>
+        public User GetUser(string name)
+        {
+            foreach (User user in UserList)
+            {
+                if (user.Username == name)
+                {
+                    return user;
+                }
+            }
+            throw new AlreadyUsedException("No user found with this username.");
+        }
+
+        /// <summary>
+        /// comparer le mot de passe entré avec celui de l'utilisateur
+        /// </summary>
+        public static bool ComparePassword(User user, string? password) => user.Password == password;
+
+        /// <summary>
+        /// rechercher un mail dans la liste d'utilisateur
+        /// </summary>
+        public bool FindEmail(string email)
+        {
+            foreach (User user in UserList)
+            {
+                if (string.Equals(user.Email, email))
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// ajouter un utilisateur dans la liste d'utilisateur
+        /// </summary>
+        public void AddUser(User user)
+        {
+            foreach (User existingUser in UserList)
+            {
+                if (existingUser.Username == user.Username)
+                {
+                    throw new AlreadyUsedException("Username already used.");
+                }
+                else if (existingUser.Email == user.Email)
+                {
+                    throw new AlreadyUsedException("Email already used.");
+                }
+            }
+            UserList.Add(user);
+        }
+
+        /// <summary>
+        /// supprimer un utilisateur dans la liste d'utilisateur
+        /// </summary>
+        public void RemoveUser(User user)
+        {
+            if (UserList.Contains(user))
+            {
+                UserList.Remove(user);
+            }
+            else
+            {
+                throw new NotFoundException("User not found.");
+            }
+        }
+
+        /// <summary>
+        /// ajouter un theme dans la liste de theme
+        /// </summary>
+        public void AddTheme(Theme theme)
+        {
+            foreach (Theme existingTheme in ThemeList)
+            {
+                if (existingTheme.Name == theme.Name)
+                {
+                    throw new AlreadyExistException("Theme already Existing.");
+                }
+            }
+            ThemeList.Add(theme);
+        }
+
+        /// <summary>
+        /// récupérer un theme
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns></returns>
+        /// <exception cref="NotFoundException"></exception>
+        public Theme GetTheme(string name)
+        {
+            foreach (Theme theme in ThemeList)
+            {
+                if (theme.Name == name)
+                {
+                    return theme;
+                }
+            }
+            throw new NotFoundException("Theme not found.");
+        }
+
+        /// <summary>
+        /// changer le pseudo d'un utilisateur
+        /// </summary>
+        /// <param name="user"></param>
+        /// <param name="newUsername"></param>
+        /// <exception cref="AlreadyUsedException"></exception>
+        public void ChangeUsername(User user, string newUsername) 
+        {
+            foreach(User existingUser in UserList)
+            {
+                if(existingUser.Username == newUsername)
+                {
+                    throw new AlreadyUsedException("this username is already used.");
+                }
+            }
+            user.Username = newUsername;
+        }
+
+        /// <summary>
+        /// vérifier si le nom du theme n'est pas déjà pris
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns></returns>
+        public bool VerifThemeNameNotTaken(string name)
+        {
+            foreach (Theme theme in ThemeList)
+            {
+                if (theme.Name == name)
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+}

notus/Biblioteque_de_Class/Exception.cs

@@ -0,0 +1,63 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Runtime.Serialization;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Biblioteque_de_Class
+{
+    [Serializable, ExcludeFromCodeCoverage]
+    public class NotAllowedException : Exception
+    {
+        public NotAllowedException(string message) : base(message)
+        {
+        }
+        protected  NotAllowedException(SerializationInfo info, StreamingContext context) : base(info, context)
+        {
+        }
+    }
+    [Serializable, ExcludeFromCodeCoverage]
+    public class AlreadyUsedException : Exception
+    {
+        public AlreadyUsedException(string message) : base(message)
+        {
+        }
+        protected  AlreadyUsedException(SerializationInfo info, StreamingContext context) : base(info, context)
+        {
+        }
+    }
+    [Serializable, ExcludeFromCodeCoverage]
+    public class NotFoundException : Exception
+    {
+        public NotFoundException(string message) : base(message)
+        {
+        }
+        protected  NotFoundException(SerializationInfo info, StreamingContext context) : base(info, context)
+        {
+        }
+    }
+    [Serializable, ExcludeFromCodeCoverage]
+    public class AlreadyExistException : Exception
+    {
+        public AlreadyExistException(string message) : base(message)
+        {
+        }
+        protected  AlreadyExistException(SerializationInfo info, StreamingContext context) : base(info, context)
+        {
+        }
+    }
+
+    [Serializable, ExcludeFromCodeCoverage]
+    public class FileException : Exception
+    {
+        public FileException(string message) : base(message)
+        {
+        }
+        protected  FileException(SerializationInfo info, StreamingContext context) : base(info, context)
+        {
+
+        }
+    }
+}

notus/Biblioteque_de_Class/HashCodeModel.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Biblioteque_de_Class
+{
+    public class HashCodeModel
+    {
+        public static string GetSHA256Hash(string input)
+        {
+            using (SHA256 sha256Hash = SHA256.Create())
+            {
+                byte[] bytes = sha256Hash.ComputeHash(Encoding.UTF8.GetBytes(input));
+
+                StringBuilder builder = new StringBuilder();
+                for (int i = 0; i < bytes.Length; i++)
+                {
+                    builder.Append(bytes[i].ToString("x2"));
+                }
+
+                return builder.ToString();
+            } 
+        }
+    }
+}

notus/Biblioteque_de_Class/IManager.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Biblioteque_de_Class
+{
+    public interface IManager
+    {
+        public void SaveDatabaseData(List<User> UserList);
+        public void SaveDefaultData(List<Theme> DefaultThemeList, List<Logo> DefaultLogoList);
+        public List<User> LoadDatabaseData();
+        public List<Theme> LoadDefaultTheme();
+        public List<Logo> LoadDefaultLogo();
+    }
+}

notus/Biblioteque_de_Class/Logo.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.Serialization;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Biblioteque_de_Class
+{
+    [DataContract]
+    public class Logo
+    {
+        [DataMember]
+        public string Name { get; set; }
+        [DataMember]
+        public string LogoLink { get; set; }
+
+        public Logo(string name, string logoLink)
+        {
+            Name = name;
+            LogoLink = logoLink;
+        }
+
+        public override string ToString() => $"Logo -> Name: {Name}\nLink: {LogoLink}";
+    }
+}

notus/Biblioteque_de_Class/Note.cs

@@ -1,43 +1,177 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Runtime.Serialization;
 using System.Text;
 using System.Threading.Tasks;
 
 namespace Biblioteque_de_Class
 {
-    internal class Note
+    [DataContract(IsReference = true)]
+    public class Note
     {
-        public string Nom { 
-            get { return Nom; }
-            set { if (value==null) { Nom = "Note sans nom"; } else { Nom = value; } }
+        [DataMember]
+        public int id { get; init; }
+        [DataMember]
+        private string name;
+        [DataMember]
+        public string Name
+        {
+            get { return name; }
+            set { if (value == null) { name = "Unnamed Note"; } else { name = value; } }
+        }
+
+        [DataMember]
+        public string Text { get; private set; } = "";
+
+        [DataMember]
+        private string logoPath;
+        [DataMember]
+        public string LogoPath
+        {
+            get { return logoPath; }
+            private set { if (value == null) { logoPath = "PATH TO DEFAULT LOGO"; } else { logoPath = value; } }
+        }
+
+        [DataMember]
+        public DateOnly CreationDate { get; init; }
+        [DataMember]
+        public DateOnly ModificationDate { get; private set; }
+        [DataMember]
+        public List<NoteImage> ImageList { get; private set; }
+        [DataMember]
+        public List<User> Collaborators { get; private set; }
+        [DataMember]
+        public List<User> Editors { get; private set; }
+        [DataMember]
+        public User Owner { get; private set; }
+
+        public Note(int initId,string name, string logoPath, User owner)
+        {
+            id = initId;
+            Name = name;
+            LogoPath = logoPath;
+            CreationDate = DateOnly.FromDateTime(DateTime.Now);
+            ModificationDate = DateOnly.FromDateTime(DateTime.Now);
+            ImageList = new List<NoteImage>();
+            Collaborators = new List<User>();
+            Editors = new List<User>() { owner };
+            Owner = owner;
         }
-        public string LogoPATH {
-            get { return LogoPATH; }
-            set { if (value == null) { LogoPATH = "PATH TO DEFAULT LOGO"; } else { LogoPATH = value; } }
+
+        public override string ToString() => $"Note -> Name: {Name}\nLogoPath: {LogoPath}";
+
+        /// <summary>
+        /// vérifier si l'utilisateur est le propriétaire de la note
+        /// </summary>
+        public bool VerifyOwner(User user) 
+        {
+            if (user == Owner) { return true; }
+            else { throw new NotAllowedException("User is not the owner"); }
         }
-        public List<Category> atributionTag;
-        public List<String> listeImage;
-        public List<String> listeLigneTexte;
-        public List<String> listePosiImage;
 
-        public Note(string nom, string logoPATH)
+        /// <summary>
+        /// ajouter une image à la note
+        /// </summary>
+        /// <param name="imageLink"></param>
+        /// <param name="position"></param>
+        public void AddImage(string imageLink, List<int> position)
         {
-            Nom = nom;
-            LogoPATH = logoPATH;
+            string newname = (ImageList.Count + 1).ToString();
+            ImageList.Add(new NoteImage(newname, imageLink, position));
         }
 
-        public Note RechercherNote(List<Note> listeNote, string nom)
+        /// <summary>
+        /// supprimer une image de la note
+        /// </summary>
+        /// <param name="name"></param>
+        /// <exception cref="NotFoundException"></exception>
+        public void RemoveImage(string name)
         {
-            foreach (Note note in listeNote)
+            foreach (NoteImage image in ImageList)
             {
-                if (note.Nom == nom)
+                if (image.Name == name)
                 {
-                    return note;
+                    ImageList.Remove(image);
+                    return;
                 }
             }
-            return null;
+            throw new NotFoundException("Image not found");
+        }
+
+        /// <summary>
+        /// ajouter du texte à la note
+        /// </summary>
+        /// <param name="text"></param>
+        public void AddText( User user, string text)
+        {
+            if (user == Owner || Editors.Contains(user)) { ModificationDate = DateOnly.FromDateTime(DateTime.Now); }
+            else { throw new NotAllowedException("User is not the owner or an editor"); }
+            Text = Text + "\n" + text;
+        }
+
+        /// <summary>
+        /// vérifier si l'utilisateur est un éditeur de la note
+        /// </summary>
+        public bool VerifyPrivilege(User user)
+        {
+            return Editors.Contains(user);
         }
 
+        /// <summary>
+        /// ajouter un utilisateur en tant que coopérateur
+        /// </summary>
+        public void AddCollaborator(User owner, User user)
+        {
+            if (VerifyOwner(owner)) { Collaborators.Add(user); }
+            user.NoteList.Add(this);
+        }
+
+        /// <summary>
+        /// supprimer un utilisateur en tant que coopérateur
+        /// </summary>
+        public void RemoveCollaborator(User owner, User user)
+        {
+            if (VerifyOwner(owner)) { Collaborators.Remove(user); }
+            user.NoteList.Remove(this);
+        }
+
+        /// <summary>
+        /// passer un coopérateur en tant qu'éditeur
+        /// </summary>
+        public void AddEditor(User owner, User user)
+        {
+            if (Editors.Contains(user)) { throw new AlreadyExistException("user already in editors."); }
+            if (VerifyOwner(owner)) { Editors.Add(user); }
+        }
+
+        /// <summary>
+        /// supprimer un coopérateur de la liste des éditeurs
+        /// </summary>
+        public void RemoveEditor(User owner, User user)
+        {
+            if (!Editors.Contains(user)) { throw new NotFoundException("user not found in editors."); }
+            if (VerifyOwner(owner)) { Editors.Remove(user); }
+        }
+
+        /// <summary>
+        /// changer le nom de la note
+        /// </summary>
+        /// <param name="user"></param>
+        /// <param name="newName"></param>
+        public void ChangeName(User user, string newName)
+        {
+            if (VerifyOwner(user)) { Name = newName; }
+        }
+
+        /// <summary>
+        /// changer le logo de la note
+        /// </summary>
+        /// <param name="user"></param>
+        /// <param name="newLogoPath"></param>
+        public void ChangeLogo(User user, string newLogoPath)
+        {
+            if (VerifyOwner(user)) { LogoPath = newLogoPath; }
+        }
     }
 }

notus/Biblioteque_de_Class/NoteImage.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.Serialization;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Biblioteque_de_Class
+{
+    [DataContract]
+    public class NoteImage
+    {
+        [DataMember]
+        public string Name { get; set; }
+        [DataMember]
+        public string ImageLink { get; set; }
+        [DataMember]
+        public List<int> Position { get; set; }
+
+        public NoteImage(string name, string imageLink, List<int> position)
+        {
+            Name = name;
+            ImageLink = imageLink;
+            Position = position;
+        }
+
+        public override string ToString() => $"image -> name: {Name}\nlink: {ImageLink}";
+    }
+}

notus/Biblioteque_de_Class/PersistenceManager.cs

@@ -0,0 +1,52 @@
+using Microsoft.VisualBasic;
+
+namespace Biblioteque_de_Class
+{
+    public class PersistenceManager
+    {
+        private Database db = new Database();
+
+        private readonly IManager persistence;
+
+        public PersistenceManager(IManager pers)
+        {
+            persistence = pers;
+        }
+        
+        public void SaveDatabaseData(Database database)
+        {
+            persistence.SaveDatabaseData(database.UserList);
+        }
+
+        public void SaveDefaultData(Database database)
+        {
+            persistence.SaveDefaultData(database.ThemeList, database.DefaultLogoList); 
+        }
+
+        public  Database LoadDatabaseData()
+        {
+            db.SetUserList(persistence.LoadDatabaseData());
+            db.SetDefaultThemeList(persistence.LoadDefaultTheme());
+            db.SetDefaultLogoList(persistence.LoadDefaultLogo());
+            return db;
+        }
+
+        public Database GetOnlyDatabaseUser()
+        {
+            db.SetUserList(persistence.LoadDatabaseData());
+            return db;
+        }
+
+        public Database GetOnlyDatabaseDefaultTheme()
+        {
+            db.SetDefaultThemeList(persistence.LoadDefaultTheme());
+            return db;
+        }
+
+        public Database GetOnlyDatabaseDefaultLogo()
+        {
+            db.SetDefaultLogoList(persistence.LoadDefaultLogo());
+            return db;
+        }
+    }
+}

notus/Biblioteque_de_Class/Tags.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.Serialization;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Biblioteque_de_Class
+{
+    [DataContract]
+    public class Tags
+    {
+        [DataMember]
+        public string Name { get; set; }
+        [DataMember]
+        public string Color { get; set; }
+            
+        public Tags(string name, string color)
+        {
+            Name = name;
+            Color = color;
+        }
+
+        public override string ToString() => $"tag -> name: {Name}\ncolor: {Color}";
+    }
+}

notus/Biblioteque_de_Class/Theme.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.Serialization;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Biblioteque_de_Class
+{
+    [DataContract]
+    public class Theme
+    {
+        [DataMember]
+        public string Name { get; set; }
+        [DataMember]
+        public List<string> ColorList { get; private set; }
+
+        public Theme(string name, List<string> colorList)
+        {
+            Name = name;
+            ColorList = colorList;
+        }
+
+        public override string ToString() => $"name: {Name}\ncolor 1: {ColorList[0]}\ncolor 2: {ColorList[1]}\ncolor 3: {ColorList[2]}\n";
+
+        /// <summary>
+        /// Change a specific color of the theme.
+        /// </summary>
+        public void ChangeColor(string color, string newColor)
+        {
+            for (int i = 0; i < ColorList.Count; i++)
+            {
+                if (ColorList[i] == color)
+                {
+                    ColorList[i] = newColor;
+                }
+            }
+        }
+    }
+}

notus/Biblioteque_de_Class/User.cs

@@ -0,0 +1,493 @@
+using Microsoft.VisualBasic.FileIO;
+using System.ComponentModel;
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Runtime.Serialization;
+
+namespace Biblioteque_de_Class
+{
+    [DataContract]
+    public class User
+    {
+        [DataMember]
+        public string Username { get; set; }
+        [DataMember]
+        public string Email { get; private set; }
+        [DataMember]
+        public string Password { get; private set; }
+        [DataMember]
+        public string Picture { get; private set; }
+        [DataMember]
+        public Theme UseTheme { get; set; }
+        [DataMember]
+        public List<Note> NoteList { get; set; }
+        [DataMember]
+        public List<Tags> TagList { get; private set; }
+        [DataMember]
+        public List<Note> FavList { get; private set; }
+        [DataMember(EmitDefaultValue = false)]
+        public bool IsConnected { get; set; }
+        [DataMember]
+        public Dictionary<Note, List<Tags>> NoteTagged { get; set; }
+        public List<Theme> AddedTheme { get; set; }
+
+        public User(string username, string email, string password)
+        {
+            Username = username;
+            Email = email;
+            Password = password;
+            Picture = "defaultpicture.png";
+            UseTheme = new("", ",,".Split(',').ToList());
+            NoteList = new List<Note>();
+            TagList = new List<Tags>();
+            FavList = new List<Note>();
+            NoteTagged = new Dictionary<Note, List<Tags>>();
+            AddedTheme = new List<Theme>();
+        }
+        public override string ToString() => $"username: {Username}\nemail: {Email}\npassword: {Password}\nOwned notes: {NoteList.Count}";
+
+        /// <summary>
+        /// rechercher une note dans la liste de note de l'utilisateur et la liste de note favoris de l'utilisateur
+        /// </summary>
+        public List<Note> SearchNoteByName(List<Note> toResearchIntoList, string name)
+        {
+            List<Note> searchedNotes = new List<Note>();
+            string search = name.ToLower();
+            foreach (Note note in toResearchIntoList)
+            {
+                if (note.Name.ToLower().Contains(search))
+                {
+                    searchedNotes.Add(note);
+                }
+            }
+            return searchedNotes;
+        }
+
+        public List<Note> SearchNoteByTag(List<Note> toResearchIntoList, string name)
+        {
+            List<Note> searchedNotes = new();
+            Tags tagtoresearchby = GetTagByName(name);
+            foreach(Note note in toResearchIntoList)
+            {
+                if (NoteTagged[note].Contains(tagtoresearchby))
+                {
+                    searchedNotes.Add(note);
+                }
+            }
+            return searchedNotes;
+        }
+
+        /// <summary>
+        /// rechercher un tag dans la liste de tag de l'utilisateur
+        /// </summary>
+        public List<Tags> SearchTagByName(List<Tags> ToResearchIntoList, string name)
+        {
+            List<Tags> searchedTags = new List<Tags>();
+            string search = name.ToLower();
+            foreach (Tags tag in ToResearchIntoList)
+            {
+                if (tag.Name.ToLower().Contains(search))
+                {
+                    searchedTags.Add(tag);
+                }
+            }
+            return searchedTags;
+        }
+
+        /// <summary>
+        /// rechercher par date de création ou de modification
+        /// </summary>
+        /// <param name="ToResearchIntoList"></param>
+        /// <param name="name"></param>
+        /// <param name="FirstDate"></param>
+        /// <param name="SecondeDate"></param>
+        /// <returns></returns>
+        public List<Note> SearchNoteByDate(List<Note> ToResearchIntoList, string name, DateOnly FirstDate, DateOnly SecondeDate)
+        {
+            List<Note> searchedNotes = new List<Note>();
+            string search = name.ToLower();
+            foreach (Note note in ToResearchIntoList)
+            {
+                if (note.Name.ToLower().Contains(search) && note.CreationDate >= FirstDate && note.CreationDate <= SecondeDate || note.Name.ToLower().Contains(search) && note.ModificationDate >= FirstDate && note.ModificationDate <= SecondeDate)
+                {
+                    searchedNotes.Add(note);
+                }
+            }
+            return searchedNotes;
+        }
+
+        /// <summary>
+        /// rechercher par nom de la note
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns></returns>
+        /// <exception cref="NotFoundException"></exception>
+        public Note GetNoteByName(string name)
+        {
+            foreach (Note note in NoteList)
+            {
+                if (note.Name == name)
+                {
+                    return note;
+                }
+            }
+            throw new NotFoundException("Note not found");
+        }
+
+        /// <summary>
+        /// rechercher par nom du tag
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns></returns>
+        /// <exception cref="NotFoundException"></exception>
+        public Tags GetTagByName(string name)
+        {
+            foreach (Tags tag in TagList)
+            {
+                if (tag.Name == name)
+                {
+                    return tag;
+                }
+            }
+            throw new NotFoundException("Tag not found");
+        }
+
+        /// <summary>
+        /// ajouter une note dans la liste de note favorite de l'utilisateur
+        /// </summary>
+        public void AddFavorite(Note note)
+        {
+            if (FavList.Contains(note))
+            {
+                throw new AlreadyExistException("Note already in favorites");
+            }
+            FavList.Add(note);
+        }
+
+        /// <summary>
+        /// supprimer une note dans la liste de note favorite de l'utilisateur
+        /// </summary>
+        public void RemoveFavorite(Note note)
+        {
+            if (FavList.Contains(note))
+            {
+                FavList.Remove(note);
+            }
+            else
+            {
+                throw new NotFoundException("Note not found");
+            }
+        }
+
+        /// <summary>
+        ///creer une note
+        /// </summary>
+        public Note CreateNote(string name, string imagePath)
+        {
+            foreach (Note existingNote in NoteList)
+            {
+                if (existingNote.Name == name)
+                {
+                    throw new AlreadyExistException("Note already exists");
+                }
+            }
+            Note note;
+            if (NoteList.Count == 0) { note = new Note(0, name, imagePath, this); }
+            else { note = new Note(NoteList[NoteList.Count - 1].id + 1, name, imagePath, this); }
+            NoteList.Add(note);
+            NoteTagged.Add(note, new List<Tags>());
+            return note;
+        }
+
+        /// <summary>
+        /// supprimer une note
+        /// </summary>
+        public void DeleteNote(Note note)
+        {
+            note.VerifyOwner(this);
+            foreach (Note existingNote in NoteList)
+            {
+                if (existingNote == note)
+                {
+                    NoteList.Remove(existingNote);
+                    NoteTagged.Remove(existingNote);
+                    return;
+                }
+            }
+            throw new NotFoundException("Note not found");
+        }
+
+        /// <summary>
+        /// creer un tag
+        /// </summary>
+        public void CreateTag(string name, string color)
+        {
+            foreach (Tags tag in TagList)
+            {
+                if (tag.Name == name)
+                {
+                    throw new AlreadyExistException("Tag already exists");
+                }
+            }
+            TagList.Add(new Tags(name, color));
+        }
+
+        /// <summary>
+        /// supprimer un tag
+        /// </summary>
+        public void DeleteTag(Tags tagtodelete)
+        {
+            foreach (Tags tag in TagList)
+            {
+                if (tag == tagtodelete)
+                {
+                    TagList.Remove(tag);
+                    return;
+                }
+            }
+            throw new NotFoundException("Tag not found");
+        }
+
+        public void EditTagName(Tags tag, string newName)
+        {
+            if (!TagList.Contains(tag))
+            {
+                throw new NotFoundException("Tag not found");
+            }
+            else
+            {
+                foreach (Tags existingTag in TagList)
+                {
+                    if (existingTag.Name == newName)
+                    {
+                        throw new AlreadyExistException("Tag already exists");
+                    }
+                }
+            }
+            tag.Name = newName;
+        }
+
+        public void EditTagColor(Tags tag, string newColor)
+        {
+            if (!TagList.Contains(tag))
+            {
+                throw new NotFoundException("Tag not found");
+            }
+            tag.Color = newColor;
+        }
+
+        /// <summary>
+        /// ajouter un tag a une note
+        /// </summary>
+        public void AddTagFromNoteList(Note note, Tags tagToAdd)
+        {
+            if (!TagList.Contains(tagToAdd))
+            {
+                throw new NotFoundException("Tag not found");
+            }
+            if (!NoteList.Contains(note))
+            {
+                throw new NotFoundException("Note not found");
+            }
+            NoteTagged[note].Add(tagToAdd);
+        }
+
+        /// <summary>
+        /// supprimer un tag a une note
+        /// </summary>
+        public void RemoveTagFromNoteList(Note note, Tags tagToRemove)
+        {
+            if (!TagList.Contains(tagToRemove))
+            {
+                throw new NotFoundException("Tag not found");
+            }
+            if (!NoteList.Contains(note))
+            {
+                throw new NotFoundException("Note not found");
+            }
+            NoteTagged[note].Remove(tagToRemove);
+        }
+
+        /// <summary>
+        /// modifier le nom d'une note
+        /// </summary>
+        /// <param name="note"></param>
+        /// <param name="newname"></param>
+        /// <exception cref="AlreadyUsedException"></exception>
+        public void SetNoteName(Note note, string newname)
+        {
+            if (!NoteList.Contains(note))
+            {
+                throw new NotFoundException("Note not found");
+            }
+            foreach(Note n in NoteList)
+            {
+                if(n.Name == newname)
+                {
+                    throw new AlreadyUsedException("This name is already used");
+                }
+            }
+            note.Name = newname;
+        }
+
+        /// <summary>
+        /// modifier le mot de passe de l'utilisateur
+        /// </summary>
+        /// <param name="newPassword"></param>
+        /// <exception cref="AlreadyExistException"></exception>
+        /// <exception cref="NotAllowedException"></exception>
+        public void ChangePassword(string newPassword)
+        {
+            if (newPassword.Length < 8) { throw new NotAllowedException("this password is too short."); }
+            if (Password == HashCodeModel.GetSHA256Hash(newPassword).ToString())
+            {
+                throw new AlreadyUsedException("this password is already used.");
+            }
+            else
+            {
+                Password = HashCodeModel.GetSHA256Hash(newPassword).ToString();
+            }
+        }
+
+        /// <summary>
+        /// modifier le theme de l'utilisateur
+        /// </summary>
+        /// <param name="theme"></param>
+        /// <exception cref="AlreadyExistException"></exception>
+        public void ChangeTheme(Theme theme)
+        {
+            if (UseTheme.Name == theme.Name)
+            {
+                throw new AlreadyExistException("this theme is already selected.");
+            }
+            UseTheme = theme;
+        }
+
+        public void ChangeThemeName(Theme theme, string newName)
+        {
+            foreach (Theme existingTheme in AddedTheme)
+            {
+                if (existingTheme.Name == newName)
+                {
+                    throw new AlreadyExistException("this theme is already existing.");
+                }
+            }
+            if (theme.Name == newName)
+            {
+                throw new AlreadyExistException("this theme is already selected.");
+            }
+            theme.Name = newName;
+        }
+
+        public void ChangeThemeColors(Theme theme, List<string> newColor)
+        {
+            int compteurSameColor = 0;
+            for(int i = 0; i < theme.ColorList.Count; i++)
+            {
+                if (theme.ColorList[i] == newColor[i])
+                {
+                    compteurSameColor++;
+                }
+            }
+            if (compteurSameColor == theme.ColorList.Count)
+            {
+                throw new AlreadyExistException("this theme those colors");
+            }
+            if (theme.ColorList.Count != newColor.Count)
+            {
+                throw new NotFoundException("this theme doesn't have the same number of colors");
+            }
+            for (int i = 0; i < theme.ColorList.Count; i++)
+            {
+                theme.ChangeColor(theme.ColorList[i], newColor[i]);
+            }
+        }
+
+        /// <summary>
+        /// ajouter un theme dans la liste de theme
+        /// </summary>
+        public void AddTheme(Theme theme)
+        {
+            foreach (Theme existingTheme in AddedTheme)
+            {
+                if (existingTheme.Name == theme.Name)
+                {
+                    throw new AlreadyExistException("Theme already used.");
+                }
+            }
+            AddedTheme.Add(theme);
+        }
+
+        /// <summary>
+        /// supprimer un theme dans la liste de theme
+        /// </summary>
+        public void RemoveTheme(Theme theme)
+        {
+            if (AddedTheme.Contains(theme))
+            {
+                AddedTheme.Remove(theme);
+            }
+            else
+            {
+                throw new NotFoundException("Theme not found.");
+            }
+        }
+
+        /// <summary>
+        /// recuperer un theme dans la liste de theme ajouté par l'utilisateur
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns></returns>
+        /// <exception cref="NotFoundException"></exception>
+        public Theme GetTheme(string name)
+        {
+            foreach (Theme theme in AddedTheme)
+            {
+                if (theme.Name == name)
+                {
+                    return theme;
+                }
+            }
+            throw new NotFoundException("Theme not found.");
+        }
+
+        /// <summary>
+        /// modifier l'email de l'utilisateur
+        /// </summary>
+        /// <param name="newEmail"></param>
+        /// <exception cref="AlreadyExistException"></exception>
+        public void ChangeEmail(string newEmail)
+        {
+            if (newEmail.Length < 3 ) { throw new NotAllowedException("this is not a mail address."); }
+            if (Email == newEmail) { throw new AlreadyUsedException("this email is the same."); }
+            Email = newEmail;
+        }
+
+        /// <summary>
+        /// changer la photo de profil de l'utilisateur
+        /// </summary>
+        /// <param name="path"></param>
+        public void ChangeProfilePicture(string path)
+        {
+            if (path.Length < 3)
+            {
+                Picture = "default.png";
+            }
+            else
+            {
+                List<string> picture = new();
+                picture = path.Split('.').ToList();
+                string extension = picture.Last();
+                if (extension != "png" && extension != "jpg" && extension != "jpeg")
+                {
+                    throw new NotFoundException("this extension is not allowed.");
+                }
+                Picture = path;
+            }
+        }
+
+        public void SetDefaultTheme(Theme theme)
+        {
+            UseTheme = theme;
+        }
+    }
+}

notus/Biblioteque_de_Class/Utilisateur.cs

@@ -1,24 +0,0 @@
-namespace Biblioteque_de_Class
-{
-    public class Utilisateur
-    {
-        private string Psd { get; set; }
-        private string Mail { get; set; }
-        private string Mdp { get; set; }
-        private List<Note> NoteList;
-
-        public Utilisateur(string Upseudo, string Umail, string Upassword)
-        {
-            Psd = Upseudo; 
-            Mail=Umail; 
-            Mdp = Upassword;
-            NoteList = new List<Note>();
-        }
-
-        public override string ToString()
-        {
-            return $"pseudo : {Psd}\nmail : {Mail}\npassword : {Mdp}\nNote possédé : { NoteList.Count}";
-        }
-
-    }
-}

notus/Notus_Console/Notus_Console.csproj

@@ -7,4 +7,9 @@
     <Nullable>enable</Nullable>
   </PropertyGroup>
 
+  <ItemGroup>
+    <ProjectReference Include="..\Biblioteque_de_Class\Biblioteque_de_Class.csproj" />
+    <ProjectReference Include="..\Notus_Persistence\Notus_Persistance.csproj" />
+  </ItemGroup>
+
 </Project>

notus/Notus_Persistence/Notus_Persistance.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net7.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Biblioteque_de_Class\Biblioteque_de_Class.csproj" />
+  </ItemGroup>
+
+</Project>

notus/Notus_Persistence/Stub.cs

@@ -0,0 +1,82 @@
+using Biblioteque_de_Class;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.Serialization.Json;
+using System.Text;
+using System.Security.Cryptography;
+using System.Threading.Tasks;
+
+
+namespace Notus_Persistance
+{
+    public class Stub : IManager
+    {
+        public void SaveDatabaseData(List<User> UserList)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void SaveDefaultData(List<Theme> DefaultThemeList, List<Logo> DefaultLogoList)
+        {
+            throw new NotImplementedException() ;
+        }
+
+        //Loaders
+        List<User> IManager.LoadDatabaseData()
+        {
+            List<User> userList = new List<User>();
+            Note nselect;
+            User uselect;
+
+            // add some users
+            userList.Add(new User("Nicolas", "leHeros@gmail.com", "FeurFeur"));
+            userList.Add(new User("Benjamin", "labsent@gmail.com", "Moto2005"));
+            userList.Add(new User("Liam", "liammonchanin@gmail.com", "Baguette"));
+            userList.Add(new User("Brigitte", "Macroutte@gmail.com", "4949Trois"));
+
+            // add some notes and tags to go faster
+
+            for (int i = 0; i < userList.Count; i++)
+            {
+                userList[i].CreateNote($"Note {i}", "DefaultLogo.png");
+                userList[i].CreateTag($"Tag {i}", "#5555FF");
+            }
+
+            // add note to user for sharing note test mixed with tag
+
+            uselect = userList[0];
+            nselect = uselect.NoteList[0];
+            nselect.AddCollaborator(uselect, userList[1]);
+            nselect.AddCollaborator(uselect, userList[2]);
+            uselect.AddTagFromNoteList(nselect, uselect.TagList[0]);
+            nselect.AddEditor(uselect, userList[2]);
+
+            // add some default logos and themes
+            foreach (User user in userList)
+            {
+                user.ChangePassword(user.Password);
+            }
+
+            return userList;
+        }
+
+        public List<Theme> LoadDefaultTheme()
+        {
+            List<Theme> DefaultThemeList = new List<Theme>();
+            DefaultThemeList.Add(new("blacktheme", "#000000,#FF00FF,#OOFFOO".Split(',').ToList()));
+            DefaultThemeList.Add(new("whitetheme", "#FFFFFF,#FF00FF,#OOFFOO".Split(',').ToList()));
+            return DefaultThemeList;
+        }
+        public List<Logo> LoadDefaultLogo()
+        {
+            List<Logo> DefaultLogoList = new List<Logo>();
+            DefaultLogoList.Add(new("default","DefaultLogo.png"));
+            DefaultLogoList.Add(new("1", "Logo1.png"));
+            DefaultLogoList.Add(new("2", "Logo2.png"));
+            return DefaultLogoList;
+        }
+
+    }
+}
+

notus/Notus_Persistence/ToXML.cs

@@ -0,0 +1,107 @@
+using Biblioteque_de_Class;
+using System.Runtime.Serialization;
+using System.Xml;
+using System.IO;
+using System.Diagnostics.CodeAnalysis;
+
+namespace Notus_Persistance
+{
+    [ExcludeFromCodeCoverage]
+    public class ToXML : IManager
+    {
+        // /../../../..
+        private string DataFilePath { get; set; } = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "NotusData");
+        private const string DataFileName = "/Userdata.xml";
+        private const string DefaultThemeName = "/defaultTheme.xml";
+        private const string DefaultLogoName = "/defaultLogo.xml";
+        private static readonly DataContractSerializer DatabaseXmlSerializer = new(typeof(Database), GetKnownTypes());
+
+        public void SaveDatabaseData(List<User> UserList)
+        {
+            if (!Directory.Exists(DataFilePath))
+            {
+                Directory.CreateDirectory(DataFilePath);
+            }
+            XmlWriterSettings settings = new() { Indent = true };
+            using TextWriter tw = File.CreateText(Path.Combine(DataFilePath + DataFileName));
+            using XmlWriter writer = XmlWriter.Create(tw, settings);
+            DatabaseXmlSerializer.WriteObject(writer, UserList);
+        }
+
+        public void SaveDefaultData(List<Theme> DefaultThemeList, List<Logo> DefaultLogoList)
+        {
+            if (!Directory.Exists(DataFilePath))
+            { Directory.CreateDirectory(DataFilePath); }
+            XmlWriterSettings settings = new() { Indent = true };
+            using TextWriter tw = File.CreateText(Path.Combine(DataFilePath + DefaultThemeName));
+            using XmlWriter writer = XmlWriter.Create(tw, settings);
+            DatabaseXmlSerializer.WriteObject(writer, DefaultThemeList);
+
+            using TextWriter tw2 = File.CreateText(Path.Combine(DataFilePath + DefaultLogoName));
+            using XmlWriter writer2 = XmlWriter.Create(tw2, settings);
+            DatabaseXmlSerializer.WriteObject(writer2, DefaultLogoList);
+        }
+
+        private static IEnumerable<Type> GetKnownTypes()
+        {
+            yield return typeof(User);
+            yield return typeof(List<User>);
+            yield return typeof(Theme);
+            yield return typeof(List<Theme>);
+            yield return typeof(Logo);
+            yield return typeof(List<Logo>);
+        }
+
+        public List<User> LoadDatabaseData()
+        {
+            if (File.Exists(Path.Combine(DataFilePath + DataFileName)))
+            {
+                using (FileStream fileStream = File.OpenRead(Path.Combine(DataFilePath + DataFileName)))
+                {
+                    return DatabaseXmlSerializer.ReadObject(fileStream) is not List<User> user
+                        ? throw new FileException("Failed to load Database. The loaded object is null.")
+                        : user;
+                }
+            }
+            else
+            {
+                throw new FileException("No data file found.");
+            }
+        }
+
+        public List<Theme> LoadDefaultTheme()
+        {
+            if (File.Exists(Path.Combine(DataFilePath + DefaultThemeName)))
+            {
+                using (FileStream fileStream = File.OpenRead(Path.Combine(DataFilePath + DefaultThemeName)))
+                {
+                    return DatabaseXmlSerializer.ReadObject(fileStream) is not List<Theme> DefaultThemeList
+                        ? throw new FileException("Failed to load Default Theme. The loaded object is null.")
+                        : DefaultThemeList;
+                }
+            }
+            else
+            {
+                throw new FileException("No data file found.");
+            }
+        }
+
+        public List<Logo> LoadDefaultLogo()
+        {
+            if (File.Exists(Path.Combine(DataFilePath + DefaultLogoName)))
+            {
+                using (FileStream fileStream = File.OpenRead(Path.Combine(DataFilePath + DefaultLogoName)))
+                {
+                    return DatabaseXmlSerializer.ReadObject(fileStream) is not List<Logo> DefaultLogoList
+                        ? throw new FileException("Failed to load Default Logo. The loaded object is null.")
+                        : DefaultLogoList;
+                }
+            }
+            else
+            {
+                throw new FileException("No data file found.");
+            }
+        }
+
+    }
+}

notus/Tests/UnitTests_Model/Database_Tests.cs

@@ -0,0 +1,223 @@
+using Biblioteque_de_Class;
+namespace UnitTests_Model
+{
+    [TestFixture]
+    public class Database_Tests
+    {
+        private Database database;
+
+        [SetUp]
+        public void Setup()
+        {
+            database = new Database();
+            database.UserList.Add(new User("John", "john@example.com", "password123"));
+            database.UserList.Add(new User("Jane", "jane@example.com", "choco"));
+            database.UserList.Add(new User("Alice", "alice@example.com", "choco"));
+            database.DefaultLogoList.Add(new Logo("Logo1", "link1"));
+            database.DefaultLogoList.Add(new Logo("Logo2", "link2"));
+            database.DefaultLogoList.Add(new Logo("Logo3", "link3"));
+        }
+
+        // SearchUser tests
+
+        [Test]
+        public void SearchUser_UserDoesNotExist_ThrowsException()
+        {
+            string searchName = "Bob";
+            Assert.Throws<NotFoundException>(() => database.SearchUser(searchName));
+        }
+
+        [Test]
+        public void SearchUser_CaseInsensitiveSearch_ReturnsMatchingUsers()
+        {
+            string searchName = "Alice";
+            User searchedUser = database.SearchUser(searchName);
+            Assert.That(searchedUser.Username, Is.EqualTo("Alice"));
+        }
+
+        // GetLogoLink tests
+        [Test]
+        public void GetLogoLink_LogoExists_ReturnsLogoLink()
+        {
+            Assert.That(database.GetLogoLink("Logo2"), Is.EqualTo("link2"));
+        }
+
+        [Test]
+        public void GetLogoLink_LogoDoesNotExist_ThrowsException()
+        {
+            string logoName = "Logo4";
+            Assert.Throws<NotFoundException>(() => database.GetLogoLink(logoName));
+        }
+
+        // GetUser tests
+        [Test]
+        public void GetUser_UserExists_ReturnsUser()
+        {
+            string userName = "Alice";
+            User user = database.GetUser(userName);
+            Assert.IsNotNull(user);
+            Assert.That(user.Username, Is.EqualTo(userName));
+        }
+
+        [Test]
+        public void GetUser_UserDoesNotExist_ThrowsException()
+        {
+            string userName = "Eve";
+            Assert.Throws<AlreadyUsedException>(() => database.GetUser(userName));
+        }
+
+        // ComparePassword tests
+        [Test]
+        public void ComparePassword_CorrectPassword_ReturnsTrue()
+        {
+            User user = database.UserList[0];
+            string password = "password123";
+            bool result = Database.ComparePassword(user, password);
+            Assert.That(result, Is.True);
+        }
+
+        [Test]
+        public void ComparePassword_IncorrectPassword_ReturnsFalse()
+        {
+            User user = database.UserList[0];
+            string password = "incorrectPassword";
+            bool result = Database.ComparePassword(user, password);
+            Assert.That(result, Is.False);
+        }
+
+        // FindEmail tests
+        [Test]
+        public void FindEmail_ExistingEmail_ReturnsTrue()
+        {
+            string email = "john@example.com";
+            bool result = database.FindEmail(email);
+            Assert.IsTrue(result);
+        }
+
+        [Test]
+        public void FindEmail_NonExistingEmail_ReturnsFalse()
+        {
+            string email = "olivedecarglass@example.com";
+            bool result = database.FindEmail(email);
+            Assert.IsFalse(result);
+        }
+
+        // AddUser tests
+        [Test]
+        public void AddUser_ValidUser_AddsUserToList()
+        {
+            User user = new User("Bob", "bob@example.com", "password123");
+            database.AddUser(user);
+            Assert.That(database.UserList, Contains.Item(user));
+        }
+
+        [Test]
+        public void AddUser_DuplicateUserName_ThrowsException()
+        {
+            User user = new User("John", "johnDae@example.com", "password123");
+            Assert.Throws<AlreadyUsedException>(() => database.AddUser(user));
+        }
+
+        [Test]
+        public void AddUser_DuplicateUserEmail_ThrowsException()
+        {
+            User user = new User("Bob", "john@example.com", "password123");
+            Assert.Throws<AlreadyUsedException>(() => database.AddUser(user));
+        }
+
+        // removeUser tests
+        [Test]
+        public void RemoveUser_ExistingUser_RemovesUserFromList()
+        {
+            User user = database.UserList[0];
+            database.RemoveUser(user);
+            Assert.That(database.UserList, !Contains.Item(user));
+        }
+
+        [Test]
+        public void RemoveUser_NotExistingUser_ThrowsException()
+        {
+            User user = new User("Bob", "bob@example.com", "password123");
+            Assert.Throws<NotFoundException>(() => database.RemoveUser(user));
+        }
+
+        // AddTheme tests
+        [Test]
+        public void AddTheme_ValidTheme_AddsThemeToList()
+        {
+            Theme theme = new Theme("Theme1", ",,,".Split().ToList());
+            database.AddTheme(theme);
+            Assert.That(database.ThemeList, Contains.Item(theme));
+        }
+
+        [Test]
+        public void AddTheme_DuplicateTheme_ThrowsException()
+        {
+            Theme theme = new Theme("Theme1", ",,,".Split().ToList());
+            database.ThemeList.Add(theme);
+            Assert.Throws<AlreadyExistException>(() => database.AddTheme(theme));
+        }
+
+        // GetTheme tests
+        [Test]
+        public void GetTheme_ExistingTheme_ReturnsTheme()
+        {
+            Theme expectedTheme = new Theme("Theme1", ",,,".Split().ToList());
+            database.ThemeList.Add(expectedTheme);
+
+            Theme theme = database.GetTheme("Theme1");
+            Assert.IsNotNull(theme);
+            Assert.That(theme, Is.EqualTo(expectedTheme));
+        }
+
+        [Test]
+        public void GetTheme_NonExistingTheme_ReturnsNull()
+        {
+            Theme expectedTheme = new Theme("Theme1", ",,,".Split().ToList());
+            database.ThemeList.Add(expectedTheme);
+            Assert.Throws<NotFoundException>(() => database.GetTheme("NonExistingTheme"));
+        }
+
+        // ChangeUsername tests
+        [Test]
+        public void ChangeUsername_CorrectReplaceName_ChangesUsername()
+        {
+            User userSelected = database.UserList[0];
+            string newUsername = "duberlute";
+
+            database.ChangeUsername(userSelected, newUsername);
+
+            User updatedUser = database.UserList.Where(u => u.Username == newUsername).First();
+            Assert.IsNotNull(updatedUser);
+            Assert.That(updatedUser.Username, Is.EqualTo(newUsername));
+        }
+
+        [Test]
+        public void ChangeUsername_UsernameAlreadyUsed_ThrowsException()
+        {
+            User userNotSelected = database.UserList[2];
+            string newUsername = "Jane";
+
+            Assert.Throws<AlreadyUsedException>(() => database.ChangeUsername(userNotSelected, newUsername));
+        }
+
+        // VerifThemeNameNotTaken tests
+        [Test]
+        public void VerifThemeNameNotTaken_NameNotTaken_ReturnsTrue()
+        {
+            string themeName = "NewTheme";
+            bool result = database.VerifThemeNameNotTaken(themeName);
+            Assert.IsTrue(result);
+        }
+
+        [Test]
+        public void VerifThemeNameNotTaken_NameAlreadyTaken_ReturnsFalse()
+        {
+            Theme expectedTheme = new Theme("Theme1", ",,,".Split().ToList());
+            database.ThemeList.Add(expectedTheme);
+            string themeName = "Theme1";
+            bool result = database.VerifThemeNameNotTaken(themeName);
+            Assert.IsFalse(result);
+        }
+    }
+}

notus/Tests/UnitTests_Model/Note_Tests.cs

@@ -0,0 +1,265 @@
+using Biblioteque_de_Class;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace UnitTests_Model
+{
+    [TestFixture]
+    public class Note_Tests
+    {
+        private User owner;
+        private Note note;
+
+        [SetUp]
+        public void Setup()
+        {
+            owner = new User("John", "john@example.com", "password123");
+            note = new Note(1, "Note 1", "logoPath", owner);
+        }
+
+        [Test]
+        public void Note_Constructor_InitializesProperties()
+        {
+            Assert.That(note.id, Is.EqualTo(1));
+            Assert.That(note.Name, Is.EqualTo("Note 1"));
+            Assert.That(note.LogoPath, Is.EqualTo("logoPath"));
+            Assert.That(note.Owner, Is.EqualTo(owner));
+            Assert.That(note.ImageList.Count, Is.EqualTo(0));
+            Assert.That(note.Collaborators.Count, Is.EqualTo(0));
+            Assert.That(note.Editors.Count, Is.EqualTo(1));
+            Assert.That(note.Editors[0], Is.EqualTo(owner));
+        }
+
+        [Test]
+        public void Note_VerifyOwner_UserIsOwner_ReturnsTrue()
+        {
+            bool result = note.VerifyOwner(owner);
+            Assert.IsTrue(result);
+        }
+
+        [Test]
+        public void Note_VerifyOwner_UserIsNotOwner_ThrowsNotAllowedException()
+        {
+            User otherUser = new User("Jane", "jane@example.com", "password123");
+
+            Assert.Throws<NotAllowedException>(() => note.VerifyOwner(otherUser));
+        }
+
+        [Test]
+        public void Note_AddImage_ValidData_AddsImage()
+        {
+            string imageLink = "imageLink";
+            List<int> position = new List<int> { 1, 2, 3 };
+
+            note.AddImage(imageLink, position);
+
+            Assert.That(note.ImageList.Count, Is.EqualTo(1));
+            Assert.That(note.ImageList[0].Name, Is.EqualTo("1"));
+            Assert.That(note.ImageList[0].ImageLink, Is.EqualTo(imageLink));
+            Assert.That(note.ImageList[0].Position, Is.EqualTo(position));
+        }
+
+        [Test]
+        public void Note_RemoveImage_ExistingImage_RemovesImage()
+        {
+            string imageLink = "imageLink";
+            List<int> position = new List<int> { 1, 2, 3 };
+            note.AddImage(imageLink, position);
+
+            note.RemoveImage("1");
+
+            Assert.That(note.ImageList.Count, Is.EqualTo(0));
+        }
+
+        [Test]
+        public void Note_RemoveImage_NonExistingImage_ThrowsNotFoundException()
+        {
+            string imageLink = "imageLink";
+            List<int> position = new List<int> { 1, 2, 3 };
+            note.AddImage(imageLink, position);
+
+            Assert.Throws<NotFoundException>(() => note.RemoveImage("2"));
+        }
+
+        [Test]
+        public void Note_AddText_UserIsOwner_AddsText()
+        {
+            User user = owner;
+            string text = "Some text";
+
+            note.AddText(user, text);
+
+            Assert.That(note.Text, Is.EqualTo("\n" + text));
+            Assert.That(note.ModificationDate, Is.EqualTo(DateOnly.FromDateTime(DateTime.Now)));
+        }
+
+        [Test]
+        public void Note_AddText_UserIsEditor_AddsText()
+        {
+            User user = new User("Editor", "editor@example.com", "password123");
+            note.AddEditor(owner, user);
+            string text = "Some text";
+
+            note.AddText(user, text);
+
+            Assert.That(note.Text, Is.EqualTo("\n"+text));
+            Assert.That(note.ModificationDate, Is.EqualTo(DateOnly.FromDateTime(DateTime.Now)));
+        }
+
+        [Test]
+        public void Note_AddText_UserIsNotOwnerOrEditor_ThrowsNotAllowedException()
+        {
+            User user = new User("Jane", "jane@example.com", "password123");
+            string text = "Some text";
+
+            Assert.Throws<NotAllowedException>(() => note.AddText(user, text));
+        }
+
+        [Test]
+        public void Note_VerifyPrivilege_UserIsEditor_ReturnsTrue()
+        {
+            User editor = new User("Editor", "editor@example.com", "password123");
+            note.AddEditor(owner, editor);
+
+            bool result = note.VerifyPrivilege(editor);
+
+            Assert.IsTrue(result);
+        }
+
+        [Test]
+        public void Note_VerifyPrivilege_UserIsNotEditor_ReturnsFalse()
+        {
+            User user = new User("User", "user@example.com", "password123");
+
+            bool result = note.VerifyPrivilege(user);
+
+            Assert.IsFalse(result);
+        }
+
+        [Test]
+        public void Note_AddCollaborator_UserIsOwner_AddsCollaborator()
+        {
+            User collaborator = new User("Collaborator", "collaborator@example.com", "password123");
+
+            note.AddCollaborator(owner, collaborator);
+
+            Assert.That(note.Collaborators.Count, Is.EqualTo(1));
+            Assert.That(note.Collaborators[0], Is.EqualTo(collaborator));
+            Assert.IsTrue(collaborator.NoteList.Contains(note));
+        }
+
+        [Test]
+        public void Note_AddCollaborator_UserIsNotOwner_ThrowsNotAllowedException()
+        {
+            User otherUser = new User("OtherUser", "otheruser@example.com", "password123");
+            User collaborator = new User("Collaborator", "collaborator@example.com", "password123");
+
+            Assert.Throws<NotAllowedException>(() => note.AddCollaborator(otherUser, collaborator));
+        }
+
+        [Test]
+        public void Note_RemoveCollaborator_UserIsOwner_RemovesCollaborator()
+        {
+            User collaborator = new User("Collaborator", "collaborator@example.com", "password123");
+            note.AddCollaborator(owner, collaborator);
+
+            note.RemoveCollaborator(owner, collaborator);
+
+            Assert.That(note.Collaborators.Count, Is.EqualTo(0));
+            Assert.IsFalse(collaborator.NoteList.Contains(note));
+        }
+
+        [Test]
+        public void Note_RemoveCollaborator_UserIsNotOwner_ThrowsNotAllowedException()
+        {
+            User otherUser = new User("OtherUser", "otheruser@example.com", "password123");
+            User collaborator = new User("Collaborator", "collaborator@example.com", "password123");
+            note.AddCollaborator(owner, collaborator);
+
+            Assert.Throws<NotAllowedException>(() => note.RemoveCollaborator(otherUser, collaborator));
+        }
+
+        [Test]
+        public void Note_AddEditor_UserAlreadyEditor_ThrowsAlreadyExistException()
+        {
+            User editor = new User("Editor", "editor@example.com", "password123");
+            note.AddEditor(owner, editor);
+
+            Assert.Throws<AlreadyExistException>(() => note.AddEditor(owner, editor));
+        }
+
+        [Test]
+        public void Note_AddEditor_UserIsOwner_AddsEditor()
+        {
+            User editor = new User("Editor", "editor@example.com", "password123");
+
+            note.AddEditor(owner, editor);
+
+            Assert.That(note.Editors.Count, Is.EqualTo(2));
+            Assert.That(note.Editors[1], Is.EqualTo(editor));
+        }
+
+        [Test]
+        public void Note_RemoveEditor_UserNotEditor_ThrowsNotFoundException()
+        {
+            User user = new User("User", "user@example.com", "password123");
+
+            Assert.Throws<NotFoundException>(() => note.RemoveEditor(owner, user));
+        }
+
+        [Test]
+        public void Note_RemoveEditor_UserIsOwner_RemovesEditor()
+        {
+            User editor = new User("Editor", "editor@example.com", "password123");
+            note.AddEditor(owner, editor);
+
+            note.RemoveEditor(owner, editor);
+
+            Assert.That(note.Editors.Count, Is.EqualTo(1));
+            Assert.IsFalse(note.Editors.Contains(editor));
+        }
+
+        [Test]
+        public void Note_ChangeName_UserIsOwner_ChangesName()
+        {
+            User user = owner;
+            string newName = "New Note Name";
+
+            note.ChangeName(user, newName);
+
+            Assert.That(note.Name, Is.EqualTo(newName));
+        }
+
+        [Test]
+        public void Note_ChangeName_UserIsNotOwner_NameNotChanged()
+        {
+            User user = new User("OtherUser", "otheruser@example.com", "password123");
+            string newName = "New Note Name";
+
+            Assert.Throws<NotAllowedException>(() => note.ChangeName(user, newName));
+        }
+
+        [Test]
+        public void Note_ChangeLogo_UserIsOwner_ChangesLogo()
+        {
+            User user = owner;
+            string newLogoPath = "newLogoPath";
+
+            note.ChangeLogo(user, newLogoPath);
+
+            Assert.That(note.LogoPath, Is.EqualTo(newLogoPath));
+        }
+
+        [Test]
+        public void Note_ChangeLogo_UserIsNotOwner_LogoNotChanged()
+        {
+            User user = new User("OtherUser", "otheruser@example.com", "password123");
+            string newLogoPath = "newLogoPath";
+
+            Assert.Throws<NotAllowedException>(() => note.ChangeLogo(user, newLogoPath));
+        }
+    }
+}

notus/Tests/UnitTests_Model/UnitTests_Model.csproj

@@ -0,0 +1,24 @@
+<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="Microsoft.NET.Test.Sdk" Version="17.5.0" />
+    <PackageReference Include="NUnit" Version="3.13.3" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.4.2" />
+    <PackageReference Include="NUnit.Analyzers" Version="3.6.1" />
+    <PackageReference Include="coverlet.collector" Version="3.2.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\Biblioteque_de_Class\Biblioteque_de_Class.csproj" />
+  </ItemGroup>
+
+</Project>

notus/Tests/UnitTests_Model/User_Tests.cs

@@ -0,0 +1,481 @@
+using Biblioteque_de_Class;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace UnitTests_Model
+{
+    public class User_Tests
+    {
+        private User user;
+
+        [SetUp]
+        public void Setup()
+        {
+            user = new User("John", "john@example.com", "password123");
+            user.CreateTag("tag1","#FF0000");
+            user.CreateTag("tag2", "#00FF00");
+            user.CreateNote("note1", "default.png");
+            user.AddTagFromNoteList(user.NoteList[0], user.TagList[0]);
+            user.CreateNote("note2", "default.png");
+            user.AddTheme(new Theme("white","#FFAAAA,#000000,#999999".Split(',').ToList()));
+        }
+
+        //test searchnoteByName
+        [Test]
+        public void User_SearchNoteByName_ValidData_ReturnsNote()
+        {
+            Note note = user.SearchNoteByName(user.NoteList,"note1").First();
+            Assert.That(note.Name, Is.EqualTo("note1"));
+        }
+        [Test]
+        public void User_SearchNoteByName_InvalidData_ReturnsNull()
+        {
+            Assert.That(user.SearchNoteByName(user.NoteList, "note3"), Is.Empty);
+        }
+
+        //test seachNoteBytag
+        [Test]
+        public void User_SearchNoteByTag_ValidData_ReturnsNote()
+        {
+            Note note = user.SearchNoteByTag(user.NoteList, "tag1").First();
+            Assert.That(note.Name, Is.EqualTo("note1"));
+        }
+        [Test]
+        public void User_SearchNoteByTag_InvalidData_ReturnsNull()
+        {
+            Assert.Throws<NotFoundException>(() => user.SearchNoteByTag(user.NoteList, "tag3"));
+        }
+
+        //test SearchNoteByDate
+        [Test]
+        public void User_SearchNoteByDate_ValidData_ReturnsNote()
+        {
+            Note note = user.SearchNoteByDate(user.NoteList, "note1", DateOnly.FromDateTime(DateTime.Now), DateOnly.FromDateTime(DateTime.Now)).First();
+            Assert.That(note.Name, Is.EqualTo("note1"));
+        }
+
+        [Test]
+        public void User_SearchNoteByDate_InvalidData_ReturnsNull()
+        {
+            Assert.That(user.SearchNoteByDate(user.NoteList, "note3", DateOnly.FromDateTime(DateTime.Now), DateOnly.FromDateTime(DateTime.Now)), Is.Empty);
+        }
+
+        //test GetNoteByName
+        [Test]
+        public void User_GetNoteByName_ValidData_ReturnsNote()
+        {
+            Note note = user.GetNoteByName("note1");
+            Assert.That(note.Name, Is.EqualTo("note1"));
+        }
+
+        [Test]
+        public void User_GetNoteByName_InvalidData_ReturnsNull()
+        {
+            Assert.Throws<NotFoundException>(() => user.GetNoteByName("note3"));
+        }
+
+        //test searchTagByName
+        [Test]
+        public void User_SearchTagByName_ValidData_ReturnsTag()
+        {
+            Tags tag = user.SearchTagByName(user.TagList, "tag1").First();
+            Assert.That(tag.Name, Is.EqualTo("tag1"));
+        }
+        [Test]
+        public void User_SearchTagByName_InvalidData_ReturnsNull()
+        {
+            Assert.That(user.SearchTagByName(user.TagList, "tag3"), Is.Empty);
+        }
+
+        //test AddFavorite
+        [Test]
+        public void User_AddFavorite_ValidData_AddNote()
+        {
+            user.AddFavorite(user.NoteList[0]);
+            Assert.That(user.FavList.Count, Is.EqualTo(1));
+        }
+        [Test]
+        public void User_AddFavorite_InvalidData_ThrowException()
+        {
+            user.AddFavorite(user.NoteList[0]);
+            Assert.Throws<AlreadyExistException>(() => user.AddFavorite(user.NoteList[0]));
+        }
+
+        //test RemoveFavorite
+
+        [Test]
+        public void User_RemoveFavorite_ValidData_RemoveNote()
+        {
+            user.AddFavorite(user.NoteList[0]);
+            user.RemoveFavorite(user.NoteList[0]);
+            Assert.That(user.FavList, Is.Empty);
+        }
+        [Test]
+        public void User_RemoveFavorite_InvalidData_ThrowException()
+        {
+            Assert.Throws<NotFoundException>(() => user.RemoveFavorite(user.NoteList[0]));
+        }
+
+        //test createNote
+        [Test]
+        public void User_CreateNote_ValidData_AddNote()
+        {
+            user.CreateNote("note3", "default.png");
+            Assert.That(user.NoteList.Count, Is.EqualTo(3));
+        }
+
+        [Test]
+        public void User_CreateNote_InvalidData_ThrowException()
+        {
+            user.CreateNote("note3", "default.png");
+            Assert.Throws<AlreadyExistException>(() => user.CreateNote("note3", "default.png"));
+        }
+        [Test]
+        public void User_CreateNote_ValidData_secondNote_AddNote()
+        {
+            User user2 = new User("John", "rien", "choco");
+            user2.CreateNote("note3", "default.png");
+            user2.CreateNote("note4", "default.png");
+            Assert.That(user2.NoteList.Count, Is.EqualTo(2));
+            Assert.That(user2.NoteList[1].id, Is.EqualTo(1));
+        }
+
+        //test DeleteNote
+        [Test]
+        public void User_DeleteNote_ValidData_RemoveNote()
+        {
+            Note note = user.NoteList[0];
+            user.DeleteNote(note);
+            Assert.That(user.NoteList.Count, Is.EqualTo(1));
+        }
+
+        [Test]
+        public void User_DeleteNote_InvalidData_ThrowException()
+        {
+            Note note = user.NoteList[0];
+            user.DeleteNote(note);
+            Assert.Throws<NotFoundException>(() => user.DeleteNote(note));
+        }
+
+        //test CreateTag
+        [Test]
+        public void User_CreateTag_ValidData_AddTag()
+        {
+            user.CreateTag("tag3", "#FF0000");
+            Assert.That(user.TagList.Count, Is.EqualTo(3));
+        }
+
+        [Test]
+        public void User_CreateTag_InvalidData_ThrowException()
+        {
+            user.CreateTag("tag3", "#FF0000");
+            Assert.Throws<AlreadyExistException>(() => user.CreateTag("tag2", "#FF0000"));
+        }
+
+        //test DeleteTag
+        [Test]
+        public void User_DeleteTag_ValidData_RemoveTag()
+        {
+            Tags tag = user.TagList[0];
+            user.DeleteTag(tag);
+            Assert.That(user.TagList.Count, Is.EqualTo(1));
+        }
+
+        [Test]
+        public void User_DeleteTag_InvalidData_ThrowException()
+        {
+            Tags tag = user.TagList[0];
+            user.DeleteTag(tag);
+            Assert.Throws<NotFoundException>(() => user.DeleteTag(tag));
+        }
+
+        //test EditTagName
+        [Test]
+        public void User_EditTagName_ValidData_EditTag()
+        {
+            user.EditTagName(user.TagList[0], "tag3");
+            Assert.That(user.TagList[0].Name, Is.EqualTo("tag3"));
+        }
+
+        [Test]
+        public void User_EditTagName_InvalidData_ThrowException()
+        {
+            Tags tags = new Tags("tag2", "#FF0000");
+            Assert.Throws<NotFoundException>(() => user.EditTagName(tags, "tag1"));
+        }
+
+        [Test]
+        public void User_EditTagName_InvalidData2_ThrowException()
+        {
+            Assert.Throws<AlreadyExistException>(() => user.EditTagName(user.TagList[0], "tag1"));
+        }
+
+        //test EditTagColor
+        [Test]
+        public void User_EditTagColor_ValidData_EditTag()
+        {
+            user.EditTagColor(user.TagList[0], "#FF0000");
+            Assert.That(user.TagList[0].Color, Is.EqualTo("#FF0000"));
+        }
+
+        [Test]
+        public void User_EditTagColor_InvalidData_ThrowException()
+        {
+            Tags tags = new Tags("tag2", "#FF0000");
+            Assert.Throws<NotFoundException>(() => user.EditTagColor(tags, "#000000"));
+        }
+
+        //Test AddTagFromNoteList
+        [Test]
+        public void User_AddTagFromNoteList_ValidData_AddTag()
+        {
+            user.AddTagFromNoteList(user.NoteList[0], user.TagList[1]);
+            Assert.That(user.NoteTagged[user.NoteList[0]].Count, Is.EqualTo(2));
+        }
+
+        [Test]
+        public void User_AddTagFromNoteList_InvalidData_ThrowException()
+        {
+            Tags tags = new Tags("tag2", "#FF0000");
+            Assert.Throws<NotFoundException>(() => user.AddTagFromNoteList(user.NoteList[0], tags));
+        }
+
+
+        [Test]
+        public void User_AddTagFromNoteList_InvalidData2_ThrowException()
+        {
+            User uvide = new User("", "", "");
+            Note note = new Note(4,"rien", "default.png", uvide);
+            Assert.Throws<NotFoundException>(() => user.AddTagFromNoteList(note, user.TagList[0]));
+        }
+
+        //Test RemoveTagFromNoteList
+        [Test]
+        public void User_RemoveTagFromNoteList_ValidData_RemoveTag()
+        {
+            user.RemoveTagFromNoteList(user.NoteList[0], user.TagList[0]);
+            Assert.That(user.NoteTagged[user.NoteList[0]], Is.Empty);
+        }
+
+        [Test]
+        public void User_RemoveTagFromNoteList_InvalidData_ThrowException()
+        {
+            Tags tags = new Tags("tag2", "#FF0000");
+            Assert.Throws<NotFoundException>(() => user.RemoveTagFromNoteList(user.NoteList[0], tags));
+        }
+
+        [Test]
+        public void User_RemoveTagFromNoteList_InvalidData2_ThrowException()
+        {
+            User uvide = new User("", "", "");
+            Note note = new Note(4, "rien", "default.png", uvide);
+            Assert.Throws<NotFoundException>(() => user.RemoveTagFromNoteList(note, user.TagList[0]));
+        }
+
+        //test SetNoteName
+        [Test]
+        public void User_SetNoteName_ValidData_EditNote()
+        {
+            user.SetNoteName(user.NoteList[0], "note3");
+            Assert.That(user.NoteList[0].Name, Is.EqualTo("note3"));
+        }
+
+        [Test]
+        public void User_SetNoteName_InvalidData_ThrowException()
+        {
+            User uvide = new User("", "", "");
+            Note note = new Note(4, "rien", "default.png", uvide);
+            Assert.Throws<NotFoundException>(() => user.SetNoteName(note, "note2"));
+        }
+
+        [Test]
+        public void User_SetNoteName_InvalidData2_ThrowException()
+        {
+            Assert.Throws<AlreadyUsedException>(() => user.SetNoteName(user.NoteList[0], "note1"));
+        }
+
+        //test ChangePassword
+        [Test]
+        public void User_ChangePassword_ValidData_ChangePassword()
+        {
+            user.ChangePassword("chocoChoco");
+            Assert.That(user.Password, Is.EqualTo(HashCodeModel.GetSHA256Hash("chocoChoco").ToString()));
+        }
+
+        [Test]
+        public void User_ChangePassword_InvalidData_ThrowException()
+        {
+            user.ChangePassword("chocoChoco");
+            Assert.Throws<AlreadyUsedException>(() => user.ChangePassword("chocoChoco"));
+        }
+
+        [Test]
+        public void User_ChangePassword_InvalidData1_ThrowException()
+        {
+            Assert.Throws<NotAllowedException>(() => user.ChangePassword("choco"));
+        }
+
+        [Test]
+        public void User_ChangePassword_InvalidData2_ThrowException()
+        {
+            Assert.Throws<NotAllowedException>(() => user.ChangePassword(""));
+        }
+
+        //test ChangeTheme
+        [Test]
+        public void User_ChangeTheme_ValidData_ChangeTheme()
+        {
+            user.ChangeTheme(new Theme("dark", "#0000FF,#FF00FF,#FFFFFF".Split(',').ToList()));
+            Assert.That(user.UseTheme.Name, Is.EqualTo("dark"));
+        }
+
+        [Test]
+        public void User_ChangeTheme_InvalidData_ThrowException()
+        {
+            user.ChangeTheme(new Theme("dark", "#0000FF,#FF00FF,#FFFFFF".Split(',').ToList()));
+            Assert.Throws<AlreadyExistException>(() => user.ChangeTheme(new Theme("dark", "#0000FF,#FF00FF,#FFFFFF".Split(',').ToList())));
+        }
+
+        //test ChangeThemeName
+        [Test]
+        public void User_ChangeThemeName_ValidData_ChangeThemeName()
+        {
+            user.ChangeThemeName(user.AddedTheme[0], "dark");
+            Assert.That(user.AddedTheme[0].Name, Is.EqualTo("dark"));
+        }
+
+        [Test]
+        public void User_ChangeThemeName_InvalidData_ThrowException()
+        {
+            user.AddTheme(new Theme("dark", "#0000FF,#FF00FF,#FFFFFF".Split(',').ToList()));
+            Assert.Throws<AlreadyExistException>(() => user.ChangeThemeName(user.AddedTheme[0], "dark"));
+        }
+
+        [Test]
+        public void User_ChangeThemeName_InvalidData2_ThrowException()
+        {
+            Assert.Throws<AlreadyExistException>(() => user.ChangeThemeName(user.AddedTheme[0], "white"));
+        }
+
+        //test ChangeThemeColors
+        [Test]
+        public void User_ChangeThemeColors_ValidData_ChangeThemeColors()
+        {
+            // Arrange
+            var theme = new Theme("blacktheme", new List<string> { "#000000", "#FF00FF", "#OOFFOO" });
+            var newColors = new List<string> { "#111111", "#222222", "#333333" };
+
+            // Act
+            user.ChangeThemeColors(theme, newColors);
+
+            // Assert
+            Assert.That(theme.ColorList[0], Is.EqualTo(newColors[0]));
+            Assert.That(theme.ColorList[1], Is.EqualTo(newColors[1]));
+            Assert.That(theme.ColorList[2], Is.EqualTo(newColors[2]));
+        }
+
+        [Test]
+        public void User_ChangeThemeColors_InvalidData_ThrowException()
+        {
+            // Arrange
+            var theme = new Theme("blacktheme", new List<string> { "#000000", "#FF00FF", "#OOFFOO" });
+            var sameColors = new List<string> { "#000000", "#FF00FF", "#OOFFOO" };
+
+            // Act & Assert
+            Assert.Throws<AlreadyExistException>(() => user.ChangeThemeColors(theme, sameColors));
+        }
+
+        [Test]
+        public void User_ChangeThemeColors_InvalidData1_ThrowException()
+        {
+            // Arrange
+            var theme = new Theme("blacktheme", new List<string> { "#000000", "#FF00FF", "#OOFFOO" });
+            var differentColors = new List<string> { "#111111", "#222222", "#333333", "#444444" };
+
+            // Act & Assert
+            Assert.Throws<NotFoundException>(() => user.ChangeThemeColors(theme, differentColors));
+        }
+
+        //test AddTheme
+        [Test]
+        public void User_AddTheme_ValidData_AddTheme()
+        {
+            user.AddTheme(new Theme("dark", "#0000FF,#FF00FF,#FFFFFF".Split(',').ToList()));
+            Assert.That(user.AddedTheme[1].Name, Is.EqualTo("dark"));
+        }
+
+        [Test]
+        public void User_AddTheme_InvalidData_ThrowException()
+        {
+            user.AddTheme(new Theme("dark", "#0000FF,#FF00FF,#FFFFFF".Split(',').ToList()));
+            Assert.Throws<AlreadyExistException>(() => user.AddTheme(new Theme("dark", "#0000FF,#FF00FF,#FFFFFF".Split(',').ToList())));
+        }
+
+        //test RemoveTheme
+        [Test]
+        public void User_RemoveTheme_ValidData_RemoveTheme()
+        {
+            user.AddTheme(new Theme("dark", "#0000FF,#FF00FF,#FFFFFF".Split(',').ToList()));
+            user.RemoveTheme(user.AddedTheme[1]);
+            Assert.That(user.AddedTheme.Count, Is.EqualTo(1));
+        }
+
+        [Test]
+        public void User_RemoveTheme_InvalidData_ThrowException()
+        {
+            Assert.Throws<NotFoundException>(() => user.RemoveTheme(new Theme("dark", "#0000FF,#FF00FF,#FFFFFF".Split(',').ToList())));
+        }
+
+        //test GetTheme
+        [Test]
+        public void User_GetTheme_ValidData_GetTheme()
+        {
+            user.AddTheme(new Theme("dark", "#0000FF,#FF00FF,#FFFFFF".Split(',').ToList()));
+            Assert.That(user.GetTheme("dark").Name, Is.EqualTo("dark"));
+        }
+
+        [Test]
+        public void User_GetTheme_InvalidData_ThrowException()
+        {
+            Assert.Throws<NotFoundException>(() => user.GetTheme("dark"));
+        }
+
+        //test ChangeEmail
+        [Test]
+        public void User_ChangeEmail_ValidData_ChangeEmail()
+        {
+            user.ChangeEmail("nouvelleEmail@gmail.com");
+            Assert.That(user.Email, Is.EqualTo("nouvelleEmail@gmail.com"));
+        }
+
+        [Test]
+        public void User_ChangeEmail_InvalidData_ThrowException()
+        {
+            Assert.Throws<NotAllowedException>(() => user.ChangeEmail(""));
+        }
+
+        //test ChangeProfilePicture
+        [Test]
+        public void User_ChangeProfilePicture_ValidData_ChangeProfilePicture()
+        {
+            user.ChangeProfilePicture("nouvellePhoto.png");
+            Assert.That(user.Picture, Is.EqualTo("nouvellePhoto.png"));
+        }
+
+        [Test]
+        public void User_ChangeProfilePicture_InvalidData_ThrowException()
+        {
+            Assert.Throws<NotFoundException>(() => user.ChangeProfilePicture("photosansextesion"));
+        }
+
+        [Test]
+        public void User_ChangeProfilePicture_InvalidData2_ThrowException()
+        {
+            user.ChangeProfilePicture("");
+            Assert.That(user.Picture, Is.EqualTo("default.png"));
+        }
+    }
+}

notus/Tests/UnitTests_Model/Usings.cs

@@ -0,0 +1 @@
+global using NUnit.Framework;

notus/Tests/UnitTests_Persistance/Stub_Tests.cs

@@ -0,0 +1,76 @@
+using Biblioteque_de_Class;
+using Notus_Persistance;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace UnitTests_Persistance
+{
+    public class Stub_Tests
+    {
+        PersistenceManager manager;
+        Database result;
+
+        [SetUp]
+        public void Setup()
+        {
+            manager = new PersistenceManager(new Stub());
+            result = new Database();
+        }
+
+        [Test]
+        public void SaveDatabaseData_Test()
+        {
+            Assert.Throws<NotImplementedException>(() => manager.SaveDatabaseData(result));
+        }
+
+        [Test]
+        public void LoadDatabaseData_Test()
+        {
+            result = manager.GetOnlyDatabaseUser();
+
+            Assert.NotNull(result);
+            Assert.NotNull(result.UserList);
+            Assert.That(result.UserList.Count, Is.EqualTo(4));
+            User user1 = result.UserList[0];
+            Assert.That(user1.Username, Is.EqualTo("Nicolas"));
+            Assert.That(user1.Email, Is.EqualTo("leHeros@gmail.com"));
+            Assert.That(user1.Password, Is.EqualTo(HashCodeModel.GetSHA256Hash("FeurFeur")));
+            Note user1Note = user1.NoteList[0];
+            Tags user1Tag = user1.TagList[0];
+            Assert.That(user1Note.Name, Is.EqualTo("Note 0"));
+            Assert.That(user1Note.LogoPath, Is.EqualTo("DefaultLogo.png"));
+            Assert.That(user1Tag.Name, Is.EqualTo("Tag 0"));
+            Assert.That(user1Tag.Color, Is.EqualTo("#5555FF"));
+        }
+
+        [Test]
+        public void LoadDefaultTheme_Test()
+        {
+            result = manager.GetOnlyDatabaseDefaultTheme();
+
+            Assert.NotNull(result);
+            Assert.That(result.ThemeList.Count, Is.EqualTo(2));
+            Theme theme1 = result.ThemeList[0];
+            Assert.That(theme1.Name, Is.EqualTo("blacktheme"));
+            Assert.That(theme1.ColorList[0], Is.EqualTo("#000000"));
+            Assert.That(theme1.ColorList[1], Is.EqualTo("#FF00FF"));
+            Assert.That(theme1.ColorList[2], Is.EqualTo("#OOFFOO"));
+        }
+
+        [Test]
+        public void LoadDefaultLogo_Test()
+        {
+            result = manager.GetOnlyDatabaseDefaultLogo();
+
+            Assert.NotNull(result);
+            Assert.That(result.DefaultLogoList.Count, Is.EqualTo(3));
+            Logo logo1 = result.DefaultLogoList[0];
+            Assert.That(logo1.Name, Is.EqualTo("default"));
+            Assert.That(logo1.LogoLink, Is.EqualTo("DefaultLogo.png"));
+        }
+
+    }
+}

notus/Tests/UnitTests_Persistance/ToXML_Tests.cs

@@ -0,0 +1,115 @@
+using Biblioteque_de_Class;
+using Notus_Persistance;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace UnitTests_Persistance
+{
+    public class ToXML_Tests
+    {
+        PersistenceManager manager;
+        Database result;
+
+        [SetUp]
+        public void Setup()
+        {
+            manager = new PersistenceManager(new Stub());
+            result = new Database();
+        }
+
+        [Test]
+        public void SaveDatabaseData_Test()
+        {
+            PersistenceManager manager2 = new PersistenceManager(new ToXML());
+            Database result2 = manager.LoadDatabaseData();
+
+            manager2.SaveDatabaseData(result2);
+
+            Database result3 = manager2.GetOnlyDatabaseUser();
+            Assert.NotNull(result3);
+
+            Assert.That(result2.UserList.Count, Is.EqualTo(result3.UserList.Count));
+            Assert.That(result2.UserList[0].Username, Is.EqualTo(result3.UserList[0].Username));
+            Assert.That(result2.UserList[0].Email, Is.EqualTo(result3.UserList[0].Email));
+            Assert.That(result2.UserList[0].Password, Is.EqualTo(result3.UserList[0].Password));
+        }
+
+        [Test]
+        public void LoadDefaultData_Test()
+        {
+            PersistenceManager manager2 = new PersistenceManager(new ToXML());
+            Database result2 = new();
+            result2.SetDefaultThemeList(manager.GetOnlyDatabaseDefaultTheme().ThemeList);
+            result2.SetDefaultLogoList(manager.GetOnlyDatabaseDefaultLogo().DefaultLogoList);
+
+            manager2.SaveDefaultData(result2);
+
+            Database result3 = new();
+            result3.SetDefaultThemeList(manager2.GetOnlyDatabaseDefaultTheme().ThemeList);
+            result3.SetDefaultLogoList(manager2.GetOnlyDatabaseDefaultLogo().DefaultLogoList);
+            Assert.NotNull(result3);
+
+            Assert.That(result2.ThemeList.Count, Is.EqualTo(result3.ThemeList.Count));
+            Assert.That(result2.DefaultLogoList.Count, Is.EqualTo(result3.DefaultLogoList.Count));
+
+            Assert.That(result2.ThemeList[0].Name, Is.EqualTo(result3.ThemeList[0].Name));
+            Assert.That(result2.ThemeList[0].ColorList[0], Is.EqualTo(result3.ThemeList[0].ColorList[0]));
+            Assert.That(result2.ThemeList[0].ColorList[1], Is.EqualTo(result3.ThemeList[0].ColorList[1]));
+            Assert.That(result2.ThemeList[0].ColorList[2], Is.EqualTo(result3.ThemeList[0].ColorList[2]));
+
+            Assert.That(result2.DefaultLogoList[0].Name, Is.EqualTo(result3.DefaultLogoList[0].Name));
+            Assert.That(result2.DefaultLogoList[0].LogoLink, Is.EqualTo(result3.DefaultLogoList[0].LogoLink));
+
+        }
+
+        [Test]
+        public void LoadDatabaseData_Test()
+        {
+            result = manager.GetOnlyDatabaseUser();
+
+            Assert.NotNull(result);
+            Assert.NotNull(result.UserList);
+            Assert.That(result.UserList.Count, Is.EqualTo(4));
+            User user1 = result.UserList[0];
+            Assert.That(user1.Username, Is.EqualTo("Nicolas"));
+            Assert.That(user1.Email, Is.EqualTo("leHeros@gmail.com"));
+            Assert.That(user1.Password, Is.EqualTo(HashCodeModel.GetSHA256Hash("FeurFeur")));
+            Note user1Note = user1.NoteList[0];
+            Tags user1Tag = user1.TagList[0];
+            Assert.That(user1Note.Name, Is.EqualTo("Note 0"));
+            Assert.That(user1Note.LogoPath, Is.EqualTo("DefaultLogo.png"));
+            Assert.That(user1Tag.Name, Is.EqualTo("Tag 0"));
+            Assert.That(user1Tag.Color, Is.EqualTo("#5555FF"));
+        }
+
+        [Test]
+        public void LoadDefaultTheme_Test()
+        {
+            result = manager.GetOnlyDatabaseDefaultTheme();
+
+            Assert.NotNull(result);
+            Assert.That(result.ThemeList.Count, Is.EqualTo(2));
+            Theme theme1 = result.ThemeList[0];
+            Assert.That(theme1.Name, Is.EqualTo("blacktheme"));
+            Assert.That(theme1.ColorList[0], Is.EqualTo("#000000"));
+            Assert.That(theme1.ColorList[1], Is.EqualTo("#FF00FF"));
+            Assert.That(theme1.ColorList[2], Is.EqualTo("#OOFFOO"));
+        }
+
+        [Test]
+        public void LoadDefaultLogo_Test()
+        {
+            result = manager.GetOnlyDatabaseDefaultLogo();
+
+            Assert.NotNull(result);
+            Assert.That(result.DefaultLogoList.Count, Is.EqualTo(3));
+            Logo logo1 = result.DefaultLogoList[0];
+            Assert.That(logo1.Name, Is.EqualTo("default"));
+            Assert.That(logo1.LogoLink, Is.EqualTo("DefaultLogo.png"));
+        }
+    }
+}
+

notus/Tests/UnitTests_Persistance/UnitTests_Persistance.csproj

@@ -0,0 +1,25 @@
+<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="Microsoft.NET.Test.Sdk" Version="17.5.0" />
+    <PackageReference Include="NUnit" Version="3.13.3" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.4.2" />
+    <PackageReference Include="NUnit.Analyzers" Version="3.6.1" />
+    <PackageReference Include="coverlet.collector" Version="3.2.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\Biblioteque_de_Class\Biblioteque_de_Class.csproj" />
+    <ProjectReference Include="..\..\Notus_Persistence\Notus_Persistance.csproj" />
+  </ItemGroup>
+
+</Project>

notus/Tests/UnitTests_Persistance/Usings.cs

@@ -0,0 +1 @@
+global using NUnit.Framework;

notus/notus.sln

@@ -3,11 +3,24 @@ Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio Version 17
 VisualStudioVersion = 17.0.31611.283
 MinimumVisualStudioVersion = 10.0.40219.1
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "notus", "notus\notus.csproj", "{561264A1-4611-40FB-A662-3EF65550CA71}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Notus_Vue", "notus_vue\Notus_Vue.csproj", "{561264A1-4611-40FB-A662-3EF65550CA71}"
+	ProjectSection(ProjectDependencies) = postProject
+		{184478A9-E14F-42E0-B963-B3A4474C9C1C} = {184478A9-E14F-42E0-B963-B3A4474C9C1C}
+		{7B7F1062-9498-44E5-AC77-84BC90A3B730} = {7B7F1062-9498-44E5-AC77-84BC90A3B730}
+		{92DD50C5-EEAD-44ED-AEFF-E21935725477} = {92DD50C5-EEAD-44ED-AEFF-E21935725477}
+		{AFCEAA99-3A25-4E9E-B498-72DD76A6B7FF} = {AFCEAA99-3A25-4E9E-B498-72DD76A6B7FF}
+		{EE443C17-B31D-4AD0-9141-920876E7DF79} = {EE443C17-B31D-4AD0-9141-920876E7DF79}
+	EndProjectSection
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Biblioteque_de_Class", "Biblioteque_de_Class\Biblioteque_de_Class.csproj", "{92DD50C5-EEAD-44ED-AEFF-E21935725477}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Biblioteque_de_Class", "Biblioteque_de_Class\Biblioteque_de_Class.csproj", "{92DD50C5-EEAD-44ED-AEFF-E21935725477}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Notus_Console", "Notus_Console\Notus_Console.csproj", "{0A5E5F33-6B39-42BF-A46D-0752EDB666FB}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Notus_Console", "Notus_Console\Notus_Console.csproj", "{0A5E5F33-6B39-42BF-A46D-0752EDB666FB}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Notus_Persistance", "Notus_Persistence\Notus_Persistance.csproj", "{184478A9-E14F-42E0-B963-B3A4474C9C1C}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "UnitTests_Model", "Tests\UnitTests_Model\UnitTests_Model.csproj", "{CB4664CE-F451-401D-862F-4A74A80B8161}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "UnitTests_Persistance", "Tests\UnitTests_Persistance\UnitTests_Persistance.csproj", "{E2BCA278-8741-4116-B0E0-B20849D66739}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -29,6 +42,18 @@ Global
 		{0A5E5F33-6B39-42BF-A46D-0752EDB666FB}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{0A5E5F33-6B39-42BF-A46D-0752EDB666FB}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{0A5E5F33-6B39-42BF-A46D-0752EDB666FB}.Release|Any CPU.Build.0 = Release|Any CPU
+		{184478A9-E14F-42E0-B963-B3A4474C9C1C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{184478A9-E14F-42E0-B963-B3A4474C9C1C}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{184478A9-E14F-42E0-B963-B3A4474C9C1C}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{184478A9-E14F-42E0-B963-B3A4474C9C1C}.Release|Any CPU.Build.0 = Release|Any CPU
+		{CB4664CE-F451-401D-862F-4A74A80B8161}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{CB4664CE-F451-401D-862F-4A74A80B8161}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{CB4664CE-F451-401D-862F-4A74A80B8161}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{CB4664CE-F451-401D-862F-4A74A80B8161}.Release|Any CPU.Build.0 = Release|Any CPU
+		{E2BCA278-8741-4116-B0E0-B20849D66739}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{E2BCA278-8741-4116-B0E0-B20849D66739}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{E2BCA278-8741-4116-B0E0-B20849D66739}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{E2BCA278-8741-4116-B0E0-B20849D66739}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

notus/notus/App.xaml.cs

@@ -1,11 +0,0 @@
-namespace notus;
-
-public partial class App : Application
-{
-	public App()
-	{
-		InitializeComponent();
-
-		MainPage = new AppShell();
-	}
-}

notus/notus/ConnecPage.xaml.cs

@@ -1,9 +0,0 @@
-namespace notus;
-
-public partial class ConnecPage : ContentPage
-{
-	public ConnecPage()
-	{
-		InitializeComponent();
-	}
-}

notus/notus/MainPage.xaml.cs

@@ -1,8 +0,0 @@
-namespace notus;
-
-public partial class MainPage : ContentPage{
-	public MainPage(){
-		InitializeComponent();
-	}
-}
-

notus/notus/RecherPage.xaml

@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="utf-8" ?>
-<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
-             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
-             xmlns:toolkit="http://schemas.microsoft.com/dodnet/2022/maui/toolkit"
-             x:Class="notus.RecherPage"
-             Title="RecherPage"
-             BackgroundColor="#1C1C1C">
-    
-    
-    
-    
-    
-    
-    
-    
-    
-</ContentPage>

notus/notus/RecherPage.xaml.cs

@@ -1,9 +0,0 @@
-namespace notus;
-
-public partial class RecherPage : ContentPage
-{
-	public RecherPage()
-	{
-		InitializeComponent();
-	}
-}

notus/notus_vue/App.xaml.cs

@@ -0,0 +1,20 @@
+
+using Biblioteque_de_Class;
+using Notus_Persistance;
+
+namespace notus;
+
+public partial class App : Application
+{
+    public PersistenceManager manager = new PersistenceManager(new Stub());
+	public Database db = new Database();
+
+    public App()
+	{
+		InitializeComponent();
+		db = manager.LoadDatabaseData();
+        MainPage = new AppShell();
+	}
+
+	
+}

notus/notus_vue/AppShell.xaml

@@ -6,7 +6,8 @@
     xmlns:local="clr-namespace:notus"
     Shell.FlyoutBehavior="Locked"
     Shell.FlyoutWidth="30"
-    Shell.NavBarIsVisible="False">
+    Shell.NavBarIsVisible="True"
+    Shell.BackgroundColor="Grey">
 
     <ShellContent
         Title="main_page"
@@ -23,5 +24,14 @@
         ContentTemplate="{DataTemplate local:RecherPage}"
         Route="RecherPage"/>
 
+    <ShellContent
+        Title="Inscription_Page"
+        ContentTemplate="{DataTemplate local:InscrPage}"
+        Route="InscrPage"/>
+
+    <ShellContent
+        Title="ProfilPage"
+        ContentTemplate="{DataTemplate local:ProfilPage}"
+        Route="ProfilPage"/>
 </Shell>
 

notus/notus_vue/ConnecPage.xaml

@@ -18,6 +18,7 @@
             <RowDefinition Height="1*"/>
             <RowDefinition Height="4*"/>
         </Grid.RowDefinitions>
+        
         <Grid.ColumnDefinitions>
             <ColumnDefinition Width="4*"/>
             <ColumnDefinition Width="4*"/>
@@ -35,35 +36,51 @@
             Text="Connection"
             TextColor="#74fabd"
             FontSize="80"
-            FontFamily="strong"/>
+            FontFamily="strong"
+            />
         
-        <Entry
+        <Entry x:Name="Mail"
             Grid.Column="1" 
             Grid.ColumnSpan="3" 
             Grid.Row="3"
             FontSize="22"
             Placeholder="entrer votre e-mail"
             PlaceholderColor="#74fabd"
-        BackgroundColor="#4A4A4A"/>
+            TextColor="#74fabd"
+            BackgroundColor="#4A4A4A"
+            />
 
-        <Entry 
+        <Entry x:Name="Password"
             Grid.Column="1" 
             Grid.ColumnSpan="3" 
             Grid.Row="5"
             FontSize="22"
             Placeholder="entrer votre mot de passe"
             PlaceholderColor="#74fabd"
-        BackgroundColor="#4A4A4A"/>
+            TextColor="#74fabd"
+            IsPassword="true"
+            BackgroundColor="#4A4A4A"
+            />
 
         <Button  
             Grid.Column="2" 
             Grid.ColumnSpan="1" 
             Grid.Row="7"
-        BackgroundColor="#74fabd"/>
-
-    </Grid>
-
+            Text="Valider"
+            TextColor="Black"
+            BackgroundColor="#74fabd"
+            Clicked="Valid_Clicked"
+            />
 
+        <Label
+            x:Name="ResultSearch"
+            Text="Mail ou mot de passe incorrect."
+            IsVisible="false"
+            Grid.Column="2"
+            Grid.Row="7"
+            TextColor="Red"
+            />
 
+    </Grid>
 
 </ContentPage>

notus/notus_vue/ConnecPage.xaml.cs

@@ -0,0 +1,28 @@
+using Biblioteque_de_Class;
+
+namespace notus;
+
+public partial class ConnecPage : ContentPage
+{
+    string mail = "";
+    string MDP = "";
+
+    public ConnecPage()
+	{
+        InitializeComponent();
+	}
+
+    private async void Valid_Clicked(object sender, EventArgs e)
+    {
+        mail = Mail.Text;
+        MDP = Password.Text;
+        if ((Application.Current as App).db.SearchUser(mail, MDP))
+        {
+            await Navigation.PushAsync(new RecherPage());
+        }
+        else
+        {
+            ResultSearch.IsVisible = true;
+        }
+    }
+}

notus/notus_vue/InscrPage.xaml

@@ -0,0 +1,82 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+             x:Class="notus.InscrPage"
+             Title="InscrPage">
+
+    <Grid BackgroundColor="#1C1C1C">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="1*"/>
+                <ColumnDefinition Width="Auto"/>
+                <ColumnDefinition Width="1*"/>
+            </Grid.ColumnDefinitions>
+        
+            <Grid.RowDefinitions>
+                <RowDefinition Height="1*"/>
+                <RowDefinition Height="150"/>
+                <RowDefinition Height="150"/>
+                <RowDefinition Height="150"/>
+                <RowDefinition Height="1*"/>
+            </Grid.RowDefinitions>
+            
+            <Entry
+                Placeholder="Pseudo"
+                HorizontalOptions="Center"
+                VerticalOptions="Center"
+                WidthRequest="600"
+                HeightRequest="100"
+                FontSize="32"
+                Grid.Column="1"
+                Grid.Row="1"
+                TextColor="#74fabd"
+                BackgroundColor="#4A4A4A"
+                PlaceholderColor="#74fabd"
+                />
+            
+            <Entry
+                Placeholder="Mot de passe"
+                HorizontalOptions="Center"
+                VerticalOptions="Center"
+                WidthRequest="600"
+                HeightRequest="100"
+                FontSize="32"
+                Grid.Column="1"
+                Grid.Row="2"
+                IsPassword="true"
+                TextColor="#74fabd"
+                BackgroundColor="#4A4A4A"
+                PlaceholderColor="#74fabd"
+                />
+
+            <Entry
+                Placeholder ="Verif mot de passe"
+                HorizontalOptions="Center"
+                VerticalOptions="Center"
+                WidthRequest="600"
+                HeightRequest="100"
+                FontSize="32"
+                Grid.Column="1"
+                Grid.Row="3"
+                IsPassword="true"
+                TextColor="#74fabd"
+                BackgroundColor="#4A4A4A"
+                PlaceholderColor="#74fabd"
+                />
+
+            <Button
+                Text="Valider"
+                Grid.Column="1"
+                Grid.Row="4"
+                HorizontalOptions="End"
+                VerticalOptions="Center"
+                WidthRequest="110"
+                HeightRequest="70"
+                BackgroundColor="#74fabd"
+                TextColor="Black"
+                CornerRadius="10"
+                Clicked="Valid_Clicked"
+                />
+
+    </Grid>
+    
+</ContentPage>

notus/notus_vue/InscrPage.xaml.cs

@@ -0,0 +1,14 @@
+namespace notus;
+
+public partial class InscrPage : ContentPage
+{
+    public InscrPage()
+    {
+        InitializeComponent();
+    }
+
+    private async void Valid_Clicked(object sender, EventArgs e)
+    {
+        await Navigation.PushAsync(new RecherPage());
+    }
+}

notus/notus_vue/MainPage.xaml

@@ -14,6 +14,7 @@
             <RowDefinition Height="2*"/>
             <RowDefinition Height="2*"/>
         </Grid.RowDefinitions>
+        
         <Grid.ColumnDefinitions>
             <ColumnDefinition Width="3*"/>
             <ColumnDefinition Width="4*"/>
@@ -29,17 +30,20 @@
             TextColor="#74fabd"
             FontSize="120"
             FontAttributes="Bold"
-            FontFamily="strong"/>
+            FontFamily="strong"
+            />
 
         <Button
             CornerRadius="50"
-            Text="Connection"
+            Text="Connexion"
             TextColor="#74fabd"
             FontSize="30"
             Grid.Row="2"
             Grid.Column="1"
             HeightRequest="75"
-            BackgroundColor="#4A4A4A"/>
+            BackgroundColor="#4A4A4A"
+            Clicked="Connec_Clicked"
+            />
         
         <Button
             CornerRadius="50"
@@ -49,7 +53,9 @@
             Grid.Row="3"
             Grid.Column="1"
             HeightRequest="75"
-            BackgroundColor="#4A4A4A"/>
+            BackgroundColor="#4A4A4A"
+            Clicked="Inscr_Clicked"
+            />
 
     </Grid>
 

notus/notus_vue/MainPage.xaml.cs

@@ -0,0 +1,19 @@
+namespace notus;
+
+public partial class MainPage : ContentPage{
+	public MainPage(){
+		InitializeComponent();
+	}
+
+    private async void Connec_Clicked(object sender, EventArgs e)
+    {
+        await Navigation.PushAsync(new ConnecPage());
+    }
+
+    private async void Inscr_Clicked(object sender, EventArgs e)
+    {
+        await Navigation.PushAsync(new InscrPage());
+    }
+
+}
+

notus/notus_vue/ProfilPage.xaml

@@ -0,0 +1,74 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+             xmlns:toolkit="http://schemas.microsoft.com/dodnet/2022/maui/toolkit"
+             x:Class="notus.ProfilPage"
+             Title="ProfilPage"
+             BackgroundColor="#1C1C1C">
+
+    <Grid>
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="1.5*"/>
+            <RowDefinition Height="1.5*"/>
+            <RowDefinition Height="1.5*"/>
+            <RowDefinition Height="1.5*"/>
+            <RowDefinition Height="1.5*"/>
+        </Grid.RowDefinitions>
+
+        <Grid.ColumnDefinitions>
+            <ColumnDefinition Width="1*"/>
+            <ColumnDefinition Width="1*"/>
+            <ColumnDefinition Width="1*"/>
+        </Grid.ColumnDefinitions>
+
+        <Button
+            Text="Modifier Profil"
+            TextColor="#74fabd"
+            BackgroundColor="#4A4A4A"
+            Grid.Column="1"
+            Grid.Row="4"
+            VerticalOptions="Center"
+            HeightRequest="80"
+            FontSize="30"
+            />
+
+        <Button
+            Text="Modifier Theme"
+            TextColor="#74fabd"
+            BackgroundColor="#4A4A4A"
+            Grid.Column="1"
+            Grid.Row="5"
+            FontSize="30"
+            VerticalOptions="Start"
+            HeightRequest="80"
+            />
+
+        <Label
+            Text="Profil"
+            FontSize="30"
+            HorizontalTextAlignment="Center"
+            VerticalTextAlignment="Center"
+            TextColor="#74fabd"
+            BackgroundColor="#4A4A4A"
+            Grid.Column="1"
+            Grid.Row="3"
+            VerticalOptions="End"
+            HeightRequest="80"
+            />
+        
+        <ImageButton
+            Source="profil.png"
+            Aspect="AspectFit"
+            Grid.Column="1"
+            Grid.Row="2"
+            WidthRequest="550"
+            HeightRequest="250"
+            BackgroundColor="#6E6E6E"
+            CornerRadius="10"
+            Clicked="ProfilClicked"
+            />
+
+    </Grid>
+
+</ContentPage>

notus/notus_vue/ProfilPage.xaml.cs

@@ -0,0 +1,17 @@
+using Microsoft.Maui.Controls;
+using Biblioteque_de_Class;
+using Notus_Persistance;
+
+namespace notus;
+
+public partial class ProfilPage : ContentPage
+{
+	public ProfilPage()
+	{
+        InitializeComponent();
+    }
+    void ProfilClicked(System.Object sender, System.EventArgs e)
+    {
+
+    }
+}

notus/notus_vue/RecherPage.xaml

@@ -0,0 +1,134 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+             xmlns:toolkit="http://schemas.microsoft.com/dodnet/2022/maui/toolkit"
+             x:Class="notus.RecherPage"
+             Title="RecherPage"
+             BackgroundColor="#1C1C1C">
+
+    <Grid>
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="1.5*"/>
+            <RowDefinition Height="1*"/>
+            <RowDefinition Height="1.8*"/>
+            <RowDefinition Height="1*"/>
+            <RowDefinition Height="1.8*"/>
+            <RowDefinition Height="1*"/>
+            <RowDefinition Height="1*"/>
+            <RowDefinition Height="4*"/>
+        </Grid.RowDefinitions>
+        
+        <Grid.ColumnDefinitions>
+            <ColumnDefinition Width="Auto"/>
+            <ColumnDefinition Width="1*"/>
+            <ColumnDefinition Width="1*"/>
+            <ColumnDefinition Width="Auto"/>
+            <ColumnDefinition Width="Auto"/>
+        </Grid.ColumnDefinitions>
+
+        <Border
+            Background="#6E6E6E"
+            Grid.Column="0" 
+            Grid.RowSpan="9" 
+            />
+        
+        <ImageButton
+            Source="profl.png"
+            Aspect="AspectFit"
+            Grid.Column="4"
+            Grid.Row="0"
+            HorizontalOptions="Start"
+            VerticalOptions="Start"
+            WidthRequest="200"
+            HeightRequest="120"
+            BackgroundColor="#6E6E6E"
+            CornerRadius="10"
+            Clicked="Profil_Clicked"
+            />
+        
+        <ImageButton
+            Source="supp.png"
+            Aspect="AspectFill"
+            Grid.Column="2"
+            Grid.Row="0"
+            Margin="20"
+            HorizontalOptions="End"
+            VerticalOptions="Start"
+            WidthRequest="50"
+            HeightRequest="50"
+            BackgroundColor="#4A4A4A"
+            CornerRadius="50"
+            />
+        
+        <Label x:Name="NomNote"
+            Text="{Binding Name}"
+            Grid.Column="1"
+            Grid.Row="0"
+            TextColor="#74fabd"
+            Margin="20"
+            FontSize="34"
+            BackgroundColor="#4A4A4A"
+            WidthRequest="250"
+            HeightRequest="50"
+            HorizontalOptions="Center"
+            VerticalOptions="Start"
+            />
+
+        <ImageButton
+            Source="edit.png"
+            Aspect="AspectFit"
+            Grid.Column="1"
+            Grid.Row="0"
+            Margin="20"
+            HorizontalOptions="Start"
+            VerticalOptions="Start"
+            WidthRequest="50"
+            HeightRequest="50"
+            BackgroundColor="#4A4A4A"
+            CornerRadius="50"
+            />
+        
+        <Entry
+            Placeholder="Rechercher"
+            HorizontalOptions="Start"
+            Margin="20"
+            VerticalOptions="Center"
+            WidthRequest="300"
+            HeightRequest="50"
+            FontSize="25"
+            Grid.Column="0"
+            Grid.Row="0"
+            TextColor="#74fabd"
+            BackgroundColor="#4A4A4A"
+            PlaceholderColor="#74fabd"
+            />
+
+        <ListView x:Name="ListNote"
+            Grid.Column="0"
+            Grid.Row="2"
+            Grid.RowSpan="5"
+            ItemsSource="{Binding NoteList}"
+            />
+
+        <Editor
+            Placeholder="Texte"
+            IsSpellCheckEnabled="True"
+            FontSize="20"
+            HorizontalOptions="Start"
+            VerticalOptions="Center"
+            Margin="20"
+            WidthRequest="800"
+            HeightRequest="750"
+            Grid.Column="1"
+            Grid.ColumnSpan="4"
+            Grid.Row="4"
+            Grid.RowSpan="3"
+            TextColor="White"
+            BackgroundColor="#4A4A4A"
+            PlaceholderColor="#74fabd"
+            />
+        
+    </Grid>
+    
+</ContentPage>

notus/notus_vue/RecherPage.xaml.cs

@@ -0,0 +1,23 @@
+using Microsoft.Maui.Controls;
+using Biblioteque_de_Class;
+using Notus_Persistance;
+
+
+namespace notus;
+
+public partial class RecherPage : ContentPage
+{
+    PersistenceManager manager = (Application.Current as App).manager;
+    public RecherPage()
+	{
+        manager.LoadDatabaseData();
+		InitializeComponent();
+        ListNote.BindingContext = manager;
+        NomNote.BindingContext = manager;
+	}
+
+    private async void Profil_Clicked(object sender, EventArgs e)
+    {
+        await Navigation.PushAsync(new ProfilPage());
+    }
+}

notus/notus_vue/notus_vue.csproj

@@ -6,7 +6,7 @@
 		<!-- Uncomment to also build the tizen app. You will need to install tizen by following this: https://github.com/Samsung/Tizen.NET -->
 		<!-- <TargetFrameworks>$(TargetFrameworks);net7.0-tizen</TargetFrameworks> -->
 		<OutputType>Exe</OutputType>
-		<RootNamespace>notus</RootNamespace>
+		<RootNamespace>Notus_Vue</RootNamespace>
 		<UseMaui>true</UseMaui>
 		<SingleProject>true</SingleProject>
 		<ImplicitUsings>enable</ImplicitUsings>
@@ -53,10 +53,21 @@
 		<PackageReference Include="Microsoft.Extensions.Logging.Debug" Version="7.0.0" />
 	</ItemGroup>
 
+	<ItemGroup>
+	  <ProjectReference Include="..\Biblioteque_de_Class\Biblioteque_de_Class.csproj" />
+	  <ProjectReference Include="..\Notus_Persistence\Notus_Persistance.csproj" />
+	</ItemGroup>
+
 	<ItemGroup>
 	  <Compile Update="ConnecPage.xaml.cs">
 	    <DependentUpon>ConnecPage.xaml</DependentUpon>
 	  </Compile>
+	  <Compile Update="InscrPage.xaml.cs">
+	    <DependentUpon>InscrPage.xaml</DependentUpon>
+	  </Compile>
+	  <Compile Update="ProfilPage.xaml.cs">
+	    <DependentUpon>ProfilPage.xaml</DependentUpon>
+	  </Compile>
 	  <Compile Update="RecherPage.xaml.cs">
 	    <DependentUpon>RecherPage.xaml</DependentUpon>
 	  </Compile>
@@ -66,6 +77,12 @@
 	  <MauiXaml Update="ConnecPage.xaml">
 	    <Generator>MSBuild:Compile</Generator>
 	  </MauiXaml>
+	  <MauiXaml Update="InscrPage.xaml">
+	    <Generator>MSBuild:Compile</Generator>
+	  </MauiXaml>
+	  <MauiXaml Update="ProfilPage.xaml">
+	    <Generator>MSBuild:Compile</Generator>
+	  </MauiXaml>
 	  <MauiXaml Update="RecherPage.xaml">
 	    <Generator>MSBuild:Compile</Generator>
 	  </MauiXaml>

notus/notus_without_maui.sln

@@ -0,0 +1,55 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.0.31611.283
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Notus_Vue", "notus_vue\Notus_Vue.csproj", "{561264A1-4611-40FB-A662-3EF65550CA71}"
+	ProjectSection(ProjectDependencies) = postProject
+		{184478A9-E14F-42E0-B963-B3A4474C9C1C} = {184478A9-E14F-42E0-B963-B3A4474C9C1C}
+		{92DD50C5-EEAD-44ED-AEFF-E21935725477} = {92DD50C5-EEAD-44ED-AEFF-E21935725477}
+	EndProjectSection
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Biblioteque_de_Class", "Biblioteque_de_Class\Biblioteque_de_Class.csproj", "{92DD50C5-EEAD-44ED-AEFF-E21935725477}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Notus_Console", "Notus_Console\Notus_Console.csproj", "{0A5E5F33-6B39-42BF-A46D-0752EDB666FB}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Notus_Persistance", "Notus_Persistence\Notus_Persistance.csproj", "{184478A9-E14F-42E0-B963-B3A4474C9C1C}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "UnitTests_Model", "Tests\UnitTests_Model\UnitTests_Model.csproj", "{CB4664CE-F451-401D-862F-4A74A80B8161}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "UnitTests_Persistance", "Tests\UnitTests_Persistance\UnitTests_Persistance.csproj", "{E2BCA278-8741-4116-B0E0-B20849D66739}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{92DD50C5-EEAD-44ED-AEFF-E21935725477}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{92DD50C5-EEAD-44ED-AEFF-E21935725477}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{92DD50C5-EEAD-44ED-AEFF-E21935725477}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{92DD50C5-EEAD-44ED-AEFF-E21935725477}.Release|Any CPU.Build.0 = Release|Any CPU
+		{0A5E5F33-6B39-42BF-A46D-0752EDB666FB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{0A5E5F33-6B39-42BF-A46D-0752EDB666FB}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{0A5E5F33-6B39-42BF-A46D-0752EDB666FB}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{0A5E5F33-6B39-42BF-A46D-0752EDB666FB}.Release|Any CPU.Build.0 = Release|Any CPU
+		{184478A9-E14F-42E0-B963-B3A4474C9C1C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{184478A9-E14F-42E0-B963-B3A4474C9C1C}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{184478A9-E14F-42E0-B963-B3A4474C9C1C}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{184478A9-E14F-42E0-B963-B3A4474C9C1C}.Release|Any CPU.Build.0 = Release|Any CPU
+		{CB4664CE-F451-401D-862F-4A74A80B8161}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{CB4664CE-F451-401D-862F-4A74A80B8161}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{CB4664CE-F451-401D-862F-4A74A80B8161}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{CB4664CE-F451-401D-862F-4A74A80B8161}.Release|Any CPU.Build.0 = Release|Any CPU
+		{E2BCA278-8741-4116-B0E0-B20849D66739}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{E2BCA278-8741-4116-B0E0-B20849D66739}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{E2BCA278-8741-4116-B0E0-B20849D66739}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{E2BCA278-8741-4116-B0E0-B20849D66739}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {61F7FB11-1E47-470C-91E2-47F8143E1572}
+	EndGlobalSection
+EndGlobal