Système de sauvegarde de QSE Planner (PARRA Quentin - Stage RUVALOR)

SaveSystem.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using QSE_Planner.Classes.StaffPackage;
using Newtonsoft.Json;
using System.IO;
using System.Windows.Forms;
using QSE_Planner.Classes.EventPlanner;
using QSE_Planner.Classes.Component;
using QSE_Planner.Classes.Signal;
using System.Threading;

namespace QSE_Planner.Classes
{
    public sealed class SaveSystem
    {
        // INSTANCE DE SAVESYSTEM ET SON LOCK POUR SÉCURISER L'ACCES MÉMOIRE
        private static SaveSystem _instance = null;
        private static readonly object _lock = new object();

        // UTILISATEUR ACTUEL
        private Employee CurrentUser = null;
        
        // LISTE DE TOUS LES UTILISATEURS
        private List<Employee> AllUsers = new List<Employee>();
		// LISTE DE TOUS LES MATÉRIELS
		private List<Material> MaterialList = new List<Material>();
        // LISTE DES EVENTS PLANNIFIÉS
        private List<Event> EventsList = new List<Event>();
        // LISTE DES FOURNISSEURS
        private List<Fournisseur> FournisseurList = new List<Fournisseur>();
        // LISTE DES CATEGORIES FOURNISSEUR 
        private List<Categorie> FournisseurCategoryList = new List<Categorie>();
        // LISTE DES CRITERES
        private List<CriteriaFournisseur> CritereList = new List<CriteriaFournisseur>();
        // LISTE DES SIGNALEMENTS MATIERE
        private List<MatiereSignal> MatiereSignalList = new List<MatiereSignal>();
        // LISTE DES SIGNALEMENTS NORMAUX
        private List<NormalSignal> NormalSignalList = new List<NormalSignal>();

        // CONSTRUCTEUR
        SaveSystem()
        {
            AllUsers = GetAllUsers();
			MaterialList = GetAllMaterials();
            EventsList = GetAllEvents();
            FournisseurList = GetAllFournisseurs();
            FournisseurCategoryList = GetAllCategory();
            CritereList = GetAllCriteres();
            MatiereSignalList = GetAllMatiereSignal();
            NormalSignalList = GetAllNormalSignal();	
        }

        #region ACCESSEURS

        // GETTER DE L'INSTANCE
        public static SaveSystem Instance
        {
            get
            {
                lock (_lock)
                {
                    if (_instance == null)
                    {
                        _instance = new SaveSystem();
                    }
                    return _instance;
                }
            }
        }

        // MISE A JOUR DE L'UTILISATEUR ACTUEL
        public void setCurrentUser(Employee e)
        {
            CurrentUser = e;
        }

        // GETTER DE L'UTILISATEUR ACTUEL
        public Employee getCurrentUser()
        {
            return CurrentUser;
        }

        // MISE A JOUR DE LA LISTE DE TOUS LES UTILISATEURS
        public void setAllUsers(List<Employee> e)
        {
            AllUsers = e;
        }

        // GETTER DE LA LISTE DE TOUS LES UTILISATEURS
        public List<Employee> getAllUsers()
        {
            return AllUsers;
        }

        // MISE A JOUR DE LA LISTE DES MATERIELS
        public void setMaterialList(List<Material> e)
        {
            MaterialList = e;
        }

        // GETTER DE LA LISTE DES MATERIELS
        public List<Material> getMaterialList()
        {
            return MaterialList;
        }

        // MISE A JOUR DE LA LISTE DE TOUS LES EVENTS
        public void setEventsList(List<Event> e)
        {
            EventsList = e;
        }

        // GETTER DE LA LISTE DE TOUS LES EVENTS
        public List<Event> getEventsLists()
        {
            return EventsList;
        }

        // MISE A JOUR DE LA LISTE DES FOURNISSEURS
        public void setFournisseurList(List<Fournisseur> e)
        {
            FournisseurList = e;
        }

        // GETTER DE LA LISTE DES FOURNISSEURS
        public List<Fournisseur> getFournisseurList()
        {
            return FournisseurList;
        }

        // MISE A JOUR DE LA LISTE DES CATEGORIES
        public void setFournisseurCategoryList(List<Categorie> e)
        {
            FournisseurCategoryList = e;
        }

        // GETTER DE LA LISTE DES CATEGORIES
        public List<Categorie> getFournisseurCategoryList()
        {
            return FournisseurCategoryList;
        }

        // MISE A JOUR DE LA LISTE DES CRITERES FOURNISSEUR
        public void setCritereList(List<CriteriaFournisseur> e)
        {
            CritereList = e;
        }

        // GETTER DE LA LISTE DES CRITERES FOURNISSEURS
        public List<CriteriaFournisseur> getCritereList()
        {
            return CritereList;
        }

        // MISE A JOUR DE LA LISTE DE TOUS LES SIGNALEMENTS MATIERE
        public void setMatiereSignalList(List<MatiereSignal> e)
        {
            MatiereSignalList = e;
        }

        // GETTER DE LA LISTE DE TOUS LES SIGNALEMENTS MATIERE
        public List<MatiereSignal> getMatiereSignalList()
        {
            return MatiereSignalList;
        }


        // MISE A JOUR DE LA LISTE DE TOUS LES SIGNALEMENTS NORMAUX
        public void setNormalSignalList(List<NormalSignal> e)
        {
            NormalSignalList = e;
        }

        // GETTER DE LA LISTE DE TOUS LES SIGNALEMENTS NORMAUX
        public List<NormalSignal> getNormalSignalList()
        {
            return NormalSignalList;
        }

        #endregion

        #region SAUVEGARDE/RÉCUPÉRATION UTILISATEUR

        /// SAUVEGARDE/RÉCUPÉRATION UTILISATEUR
        /// 
        /// Concerne le partie du système de sauvegarde qui sauvegarde et récupère les utilisateurs
        /// - SaveUser()           : void
        /// - GetAllUsers()        : List<Employee>
        /// - GetUserByUsername()  : Employee
        /// - GetUserByLastname()  : List<Employee>
        /// - GetUserByFirstname() : List<Employee>
        /// - GetUserByFullname()  : List<Employee>

        // SAUVEGARDE UTILISATEUR
        public static void SaveUser(Employee e)
        {
            try
            {
                // VALEUR A CRYPTER
                string output = JsonConvert.SerializeObject(e);

                // RÉCUPÉRATION DES DIFFÉRENTS DOSSIERS
                string CurrentFolder = Path.GetDirectoryName(Application.ExecutablePath);
                string FileName = CurrentFolder + "/data/users/" + e.getUsername() + "-" + e.getLastName() + "_" + e.getFirstName();

                // CRYPTAGE DES DONNÉES + SAUVEGARDE
                Obfuscate(FileName, output);
            }
            catch (Exception ex)
            {
                // EN CAS D'ERREUR
                MessageBox.Show(ex.ToString());
            }
        }

        // RÉCUPÉRATION DE TOUS LES UTILISATEURS
        public static List<Employee> GetAllUsers()
        {
            List<Employee> toReturn = new List<Employee>();

            try
            {
                // RÉCUPÉRATION DU DOSSIER
                string CurrentFolder = Path.GetDirectoryName(Application.ExecutablePath);

                // INFORMATIONS DU DOSSIER
                DirectoryInfo di = new DirectoryInfo(CurrentFolder + "/data/users/");

                // POUR CHAQUE UTILISATEUR..
                foreach (var file in di.GetFiles())
                {
                    Employee e = JsonConvert.DeserializeObject<Employee>(Deobfuscate((CurrentFolder + "/data/users/" + file.Name)));
                    toReturn.Add(e);
                }

                return toReturn;
            }
            catch
            {
                // SI L'UTILISATEUR N'EXISTE PAS
                return null;
            }
        }

        // RÉCUPÉRATION UTILISATEUR PAR USERNAME (NOM D'UTILISATEUR)
        public static Employee GetUserByUsername(string Username)
        {
            try
            {
                // RÉCUPÉRATION DU DOSSIER
                string CurrentFolder = Path.GetDirectoryName(Application.ExecutablePath);

                // INFORMATIONS DU DOSSIER
                DirectoryInfo di = new DirectoryInfo(CurrentFolder + "/data/users/");

                // POUR CHAQUE UTILISATEUR..
                foreach (var file in di.GetFiles())
                {
                    string[] sub = file.Name.Split('-'); // Nom d'utilisateur en [0] et Nom_Prénom en [1]

                    if (sub[0] == Username)
                    {
                        // RÉCUPÉRATION DE L'OBJET
                        return JsonConvert.DeserializeObject<Employee>(Deobfuscate((CurrentFolder + "/data/users/" + file.Name)));
                    }
                }

                // SI AUCUN UTILISATEUR
                return null;
            }
            catch
            {
                // SI L'UTILISATEUR N'EXISTE PAS
                return null;
            }
        }

        // RÉCUPÉRATION UTILISATEUR PAR NOM DE FAMILLE
        public static List<Employee> GetUserByLastname(string Lastname)
        {
            List<Employee> toReturn = new List<Employee>();

            try
            {
                // RÉCUPÉRATION DU DOSSIER
                string CurrentFolder = Path.GetDirectoryName(Application.ExecutablePath);

                // INFORMATIONS DU DOSSIER
                DirectoryInfo di = new DirectoryInfo(CurrentFolder + "/data/users/");

                // POUR CHAQUE UTILISATEUR..
                foreach (var file in di.GetFiles())
                {
                    string[] s = file.Name.Split('-'); // Nom d'utilisateur en [0] et Nom_Prénom en [1]
                    string[] sub = s[1].Split('_'); // Nom d'utilisateur en [0] et Nom_Prénom en [1]

                    if (sub[0] == Lastname)
                    {
                        // RÉCUPÉRATION DES DONNÉES
                        Employee e = JsonConvert.DeserializeObject<Employee>(Deobfuscate((CurrentFolder + "/data/users/" + file.Name)));
                        toReturn.Add(e);
                    }
                }

                return toReturn;
            }
            catch
            {
                // SI L'UTILISATEUR N'EXISTE PAS
                return null;
            }
        }

        // RÉCUPÉRATION UTILISATEUR PAR PRÉNOM
        public static List<Employee> GetUserByFirstname(string Firstname)
        {
            List<Employee> toReturn = new List<Employee>();

            try
            {
                // RÉCUPÉRATION DU DOSSIER
                string CurrentFolder = Path.GetDirectoryName(Application.ExecutablePath);

                // INFORMATIONS DU DOSSIER
                DirectoryInfo di = new DirectoryInfo(CurrentFolder + "/data/users/");

                // POUR CHAQUE UTILISATEUR..
                foreach (var file in di.GetFiles())
                {
                    string[] s = file.Name.Split('-'); // Nom d'utilisateur en [0] et Nom_Prénom en [1]
                    string[] sub = s[1].Split('_'); // Nom d'utilisateur en [0] et Nom_Prénom en [1]

                    if (sub[1] == Firstname)
                    {
                        // RÉCUPÉRATION DES DONNÉES
                        Employee e = JsonConvert.DeserializeObject<Employee>(Deobfuscate((CurrentFolder + "/data/users/" + file.Name)));
                        toReturn.Add(e);
                    }
                }

                return toReturn;
            }
            catch
            {
                // SI L'UTILISATEUR N'EXISTE PAS
                return null;
            }
        }

        // RÉCUPÉRATION UTILISATEUR PAR NOM COMPLET
        public static List<Employee> GetUserByFullname(string Lastname, string Firstname)
        {
            List<Employee> toReturn = new List<Employee>();

            try
            {
                // RÉCUPÉRATION DU DOSSIER
                string CurrentFolder = Path.GetDirectoryName(Application.ExecutablePath);

                // INFORMATIONS DU DOSSIER
                DirectoryInfo di = new DirectoryInfo(CurrentFolder + "/data/users/");

                // POUR CHAQUE UTILISATEUR..
                foreach (var file in di.GetFiles())
                {
                    string[] s = file.Name.Split('-'); // Nom d'utilisateur en [0] et Nom_Prénom en [1]
                    string[] sub = s[1].Split('_'); // Nom d'utilisateur en [0] et Nom_Prénom en [1]

                    if (sub[0] == Lastname)
                    {
                        if (sub[1] == Firstname)
                        {
                            // RÉCUPÉRATION DES DONNÉES
                            Employee e = JsonConvert.DeserializeObject<Employee>(Deobfuscate((CurrentFolder + "/data/users/" + file.Name)));
                            toReturn.Add(e);
                        }
                    }
                }

                return toReturn;
            }
            catch
            {
                // SI L'UTILISATEUR N'EXISTE PAS
                return null;
            }
        }

        #endregion

        #region SAUVEGARDE/RÉCUPÉRATION MATÉRIEL

        /// SAUVEGARDE/RÉCUPÉRATION MATÉRIEL
        /// 
        /// Concerne le partie du système de sauvegarde qui sauvegarde et récupère les matériels
        /// - SaveMaterial()       : void
        /// - GetAllMaterials()    : List<Material>
        /// - GetMaterialByImmat() : Material

        public static void SaveMaterial(Material m)
        {
            try
            {
                // VALEUR A CRYPTER
                string output = JsonConvert.SerializeObject(m);

                // RÉCUPÉRATION DES DIFFÉRENTS DOSSIERS
                string CurrentFolder = Path.GetDirectoryName(Application.ExecutablePath);
                string FileName = CurrentFolder + "/data/materials/" + m.Immatriculation;

                // CRYPTAGE DES DONNÉES + SAUVEGARDE
                Obfuscate(FileName, output);
            }
            catch (Exception ex)
            {
                // EN CAS D'ERREUR
                MessageBox.Show(ex.ToString());
            }
        }

        // RÉCUPÉRATION DE TOUS LES MATÉRIELS
        public static List<Material> GetAllMaterials()
        {
            List<Material> toReturn = new List<Material>();

            try
            {
                // RÉCUPÉRATION DU DOSSIER
                string CurrentFolder = Path.GetDirectoryName(Application.ExecutablePath);

                // INFORMATIONS DU DOSSIER
                DirectoryInfo di = new DirectoryInfo(CurrentFolder + "/data/materials/");

                // POUR CHAQUE MATERIEL..
                foreach (var file in di.GetFiles())
                {
                    Material m = JsonConvert.DeserializeObject<Material>(Deobfuscate((CurrentFolder + "/data/materials/" + file.Name)));
                    toReturn.Add(m);
                }

                return toReturn;
            }
            catch
            {
                // SI AUCUN MATERIEL
                return null;
            }
        }

        // RÉCUPÉRATION UTILISATEUR PAR USERNAME (NOM D'UTILISATEUR)
        public static Material GetMaterialByImmat(string Immat)
        {
            try
            {
                // RÉCUPÉRATION DU DOSSIER
                string CurrentFolder = Path.GetDirectoryName(Application.ExecutablePath);

                // INFORMATIONS DU DOSSIER
                DirectoryInfo di = new DirectoryInfo(CurrentFolder + "/data/materials/");

                // POUR CHAQUE UTILISATEUR..
                foreach (var file in di.GetFiles())
                {
                    if (file.Name == Immat)
                    {
                        // RÉCUPÉRATION DE L'OBJET
                        return JsonConvert.DeserializeObject<Material>(Deobfuscate((CurrentFolder + "/data/materials/" + file.Name)));
                    }
                }

                // SI AUCUN UTILISATEUR
                return null;
            }
            catch
            {
                // SI L'UTILISATEUR N'EXISTE PAS
                return null;
            }
        }

        #endregion

        #region SAUVEGARDE/RÉCUPÉRATION EVENT

        /// SAUVEGARDE/RÉCUPÉRATION EVENT
        /// 
        /// Concerne le partie du système de sauvegarde qui sauvegarde et récupère les évènements
        /// -  SaveEvent()    : void
        /// -  GetAllEvents() : List<Event>
        /// -  GetEvent()     : Event

        public static void SaveEvent(Event e)
        {
            try
            {
                // VALEUR A CRYPTER
                string output = JsonConvert.SerializeObject(e);

                // RÉCUPÉRATION DES DIFFÉRENTS DOSSIERS
                string CurrentFolder = Path.GetDirectoryName(Application.ExecutablePath);

                // VÉRIFICATION DE L'EXISTENCE DU CHEMIN
                if (!Directory.Exists(CurrentFolder + "/data/events/" + e.Date.Year + "/" + e.Date.Month + "/" + e.Date.Day))
                    Directory.CreateDirectory(CurrentFolder + "/data/events/" + e.Date.Year + "/" + e.Date.Month + "/" + e.Date.Day);

                string FileName = CurrentFolder + "/data/events/" + e.Date.Year + "/" + e.Date.Month + "/" + e.Date.Day + "/" + "event";

                // CRYPTAGE DES DONNÉES
                Obfuscate(FileName, output);
            }
            catch(Exception ex)
            {
                // EN CAS D'ERREUR
                MessageBox.Show(ex.ToString());
            }
        }
		
        public static List<Event> GetAllEvents()
        {
            List<Event> toReturn = new List<Event>();

            try
            {
                // RÉCUPÉRATION DU DOSSIER
                string CurrentFolder = Path.GetDirectoryName(Application.ExecutablePath);

                // INFORMATIONS DU DOSSIER
                DirectoryInfo di = new DirectoryInfo(CurrentFolder + "/data/events/");

                // POUR CHAQUE EVENT..
                foreach (var year in di.GetDirectories())
                {
                    foreach (var month in year.GetDirectories())
                    {
                        foreach (var day in month.GetDirectories())
                        {
                            string y, m, d;
                            y = year.Name;
                            m = month.Name;
                            d = day.Name;
                            Event ev = JsonConvert.DeserializeObject<Event>(Deobfuscate((CurrentFolder + "/data/events/" + y + "/" + m + "/" + d + "/event")));
                            toReturn.Add(ev);
                        }
                    }
                }

                return toReturn;
            }
            catch
            {
                // SI AUCUN EVENT
                return null;
            }
        }

        public static Event GetEvent(DateTime d)
        {
            try
            {
                // RÉCUPÉRATION DES DIFFÉRENTS DOSSIERS
                string CurrentFolder = Path.GetDirectoryName(Application.ExecutablePath);
                string FileName = CurrentFolder + "/data/events/" + d.Year + "/" + d.Month + "/" + d.Day + "/" + "event";

                // RÉCUPÉRATION DE L'OBJET
                return JsonConvert.DeserializeObject<Event>(Deobfuscate(FileName));
            }
            catch
            {
                // SI L'EVENT N'EXISTE PAS
                return null;
            }
        }

        public static List<Event> GetEventsYearMonth(int y, int m)
        {
            List<Event> toReturn = new List<Event>();

            try
            {
                // RÉCUPÉRATION DES DIFFÉRENTS DOSSIERS
                string CurrentFolder = Path.GetDirectoryName(Application.ExecutablePath);

                // INFORMATIONS DU DOSSIER
                DirectoryInfo di = new DirectoryInfo(CurrentFolder + "/data/events/" + y + "/" + m + "/");

                foreach (var d in di.GetDirectories())
                {
                    foreach (var f in d.GetFiles())
                    {
                        toReturn.Add(JsonConvert.DeserializeObject<Event>(Deobfuscate((CurrentFolder + "/data/events/" + y + "/" + m + "/" + d.Name + "/" + f.Name))));
                    }
                }

                // RÉCUPÉRATION DE L'OBJET
                return toReturn;
            }
            catch
            {
                return toReturn;
            }
        }

        #endregion

        #region SAUVEGARDE/RÉCUPÉRATION/SUPPRESSION FOURNISSEUR + CATEGORIE

        /// SAUVEGARDE/RÉCUPÉRATION/SUPPRESSION FOURNISSEUR + CATEGORIE
        /// 
        /// Concerne le partie du système de sauvegarde qui sauvegarde, récupère et supprime les fournisseurs & catégories
        /// -  SaveFournisseur()    : void
        /// -  SaveCategory()       : void
        /// -  GetAllFournisseurs() : List<Fournisseur>
        /// -  GetAllCategory()     : List<Categorie>
        /// -  GetFournisseur()     : Fournisseur
        /// -  GetCategory()        : Categorie
        /// -  DeleteAllCategory()  : void
        /// -  DeleteFournisseur()  : void

        public static void SaveFournisseur(Fournisseur e)
        {
            try
            {
                // VALEUR A CRYPTER
                string output = JsonConvert.SerializeObject(e);

                // RÉCUPÉRATION DES DIFFÉRENTS DOSSIERS
                string CurrentFolder = Path.GetDirectoryName(Application.ExecutablePath);

                string FileName = CurrentFolder + "/data/providers/" + e.Nom;

                // CRYPTAGE DES DONNÉES
                Obfuscate(FileName, output);
            }
            catch (Exception ex)
            {
                // EN CAS D'ERREUR
                MessageBox.Show("Impossible de sauvegarder, le fournisseur existe déjà.");
            }
        }

        public static void SaveCategory(Categorie e)
        {
            try
            {
                // VALEUR A CRYPTER
                string output = JsonConvert.SerializeObject(e);

                // RÉCUPÉRATION DES DIFFÉRENTS DOSSIERS
                string CurrentFolder = Path.GetDirectoryName(Application.ExecutablePath);

                string FileName = CurrentFolder + "/data/providers/category/" + e.Nom;

                // CRYPTAGE DES DONNÉES
                Obfuscate(FileName, output);
            }
            catch (Exception ex)
            {
                // EN CAS D'ERREUR
                MessageBox.Show("Impossible de sauvegarder, la catégorie existe déjà.");
            }
        }

        public static List<Fournisseur> GetAllFournisseurs()
        {
            List<Fournisseur> toReturn = new List<Fournisseur>();

            try
            {
                // RÉCUPÉRATION DU DOSSIER
                string CurrentFolder = Path.GetDirectoryName(Application.ExecutablePath);

                // INFORMATIONS DU DOSSIER
                DirectoryInfo di = new DirectoryInfo(CurrentFolder + "/data/providers/");

                // POUR CHAQUE FOURNISSEUR..
                foreach (var file in di.GetFiles())
                {
                    Fournisseur cr = JsonConvert.DeserializeObject<Fournisseur>(Deobfuscate((CurrentFolder + "/data/providers/" + file.Name)));
                    toReturn.Add(cr);
                }

                return toReturn;
            }
            catch
                // SI AUCUN FOURNISSEUR
            {
                return null;
            }
        }

        public static List<Categorie> GetAllCategory()
        {
            List<Categorie> toReturn = new List<Categorie>();

            try
            {
                // RÉCUPÉRATION DU DOSSIER
                string CurrentFolder = Path.GetDirectoryName(Application.ExecutablePath);

                // INFORMATIONS DU DOSSIER
                DirectoryInfo di = new DirectoryInfo(CurrentFolder + "/data/providers/category/");

                // POUR CHAQUE CATEGORIE..
                foreach (var file in di.GetFiles())
                {
                    Categorie cr = JsonConvert.DeserializeObject<Categorie>(Deobfuscate((CurrentFolder + "/data/providers/category/" + file.Name)));
                    toReturn.Add(cr);
                }

                return toReturn;
            }
            catch
            // SI AUCUNE CATEGORIE
            {
                return null;
            }
        }

        public static Categorie GetCategory(string d)
        {
            try
            {
                // RÉCUPÉRATION DES DIFFÉRENTS DOSSIERS
                string CurrentFolder = Path.GetDirectoryName(Application.ExecutablePath);
                string FileName = CurrentFolder + "/data/providers/category/" + d;

                // RÉCUPÉRATION DE L'OBJET
                return JsonConvert.DeserializeObject<Categorie>(Deobfuscate(FileName));
            }
            catch
            {
                // SI L'EVENT N'EXISTE PAS
                return null;
            }
        }

        public static Fournisseur GetFournisseur(string d)
        {
            try
            {
                // RÉCUPÉRATION DES DIFFÉRENTS DOSSIERS
                string CurrentFolder = Path.GetDirectoryName(Application.ExecutablePath);
                string FileName = CurrentFolder + "/data/providers/" + d;

                // RÉCUPÉRATION DE L'OBJET
                return JsonConvert.DeserializeObject<Fournisseur>(Deobfuscate(FileName));
            }
            catch
            {
                // SI L'EVENT N'EXISTE PAS
                return null;
            }
        }

        public static void DeleteAllCategory()
        {
            try
            {
                // RÉCUPÉRATION DU DOSSIER
                string CurrentFolder = Path.GetDirectoryName(Application.ExecutablePath);

                // INFORMATIONS DU DOSSIER
                DirectoryInfo di = new DirectoryInfo(CurrentFolder + "/data/providers/category/");

                // SUPPRESSION
                foreach (var file in di.GetFiles())
                    file.Delete();
            }
            catch (Exception ex)
            {
                // ERROR
                MessageBox.Show(ex.ToString());
            }
        }

        public static void DeleteFournisseur(Fournisseur f)
        {
            try
            {
                // RÉCUPÉRATION DU DOSSIER
                string CurrentFolder = Path.GetDirectoryName(Application.ExecutablePath);

                // INFORMATIONS DU DOSSIER
                DirectoryInfo di = new DirectoryInfo(CurrentFolder + "/data/providers/");
                DirectoryInfo di_doc = new DirectoryInfo(CurrentFolder + "/data/providers/documents/");

                if (File.Exists(CurrentFolder + "/data/providers/" + f.Nom))
                    File.Delete(CurrentFolder + "/data/providers/" + f.Nom);

                foreach (var file in di_doc.GetFiles())
                {
                    // RÉCUPÉRATION DE L'EXTENSION
                    string[] sp = file.Name.Split('\\'); // sp1[sp1.Lenght-1] == nom du fichier
                    string[] sp1 = sp[sp.Length -1].Split('-');

                    if (sp1[0] == f.Nom)
                        file.Delete();
                }

            }
            catch (Exception ex)
            {
                // ERROR
                MessageBox.Show(ex.ToString());
            }
        }

        #endregion

        #region SAUVEGARDE/RÉCUPÉRATION CRITERE

        /// SAUVEGARDE/RÉCUPÉRATION CRITERE
        /// 
        /// Concerne le partie du système de sauvegarde qui sauvegarde et récupère les critères fournisseur
        /// -  SaveCritere()       : void
        /// -  GetAllCriteres()    : List<CriteriaFournisseur>
        /// -  DeleteAllCriteres() : void

        public static void SaveCritere(CriteriaFournisseur e)
        {
            try
            {
                // VALEUR A CRYPTER
                string output = JsonConvert.SerializeObject(e);

                // RÉCUPÉRATION DES DIFFÉRENTS DOSSIERS
                string CurrentFolder = Path.GetDirectoryName(Application.ExecutablePath);

                // INFORMATIONS DU DOSSIER
                DirectoryInfo di = new DirectoryInfo(CurrentFolder + "/data/criteria/");

                string FileName = CurrentFolder + "/data/criteria/" + di.GetFiles().Length;

                // CRYPTAGE DES DONNÉES
                Obfuscate(FileName, output);
            }
            catch (Exception ex)
            {
                // EN CAS D'ERREUR
                MessageBox.Show(ex.ToString());
            }
        }

        public static List<CriteriaFournisseur> GetAllCriteres()
        {
            List<CriteriaFournisseur> toReturn = new List<CriteriaFournisseur>();

            try
            {
                // RÉCUPÉRATION DU DOSSIER
                string CurrentFolder = Path.GetDirectoryName(Application.ExecutablePath);

                // INFORMATIONS DU DOSSIER
                DirectoryInfo di = new DirectoryInfo(CurrentFolder + "/data/criteria/");

                // POUR CHAQUE CRITERE..
                foreach (var file in di.GetFiles())
                {
                    CriteriaFournisseur cr = JsonConvert.DeserializeObject<CriteriaFournisseur>(Deobfuscate((CurrentFolder + "/data/criteria/" + file.Name)));
                    toReturn.Add(cr);
                }

                return toReturn;
            }
            catch
            {
                // SI AUCUN CRITERE
                return null;
            }
        }

        public static void DeleteAllCriteres()
        {
            try
            {
                // RÉCUPÉRATION DU DOSSIER
                string CurrentFolder = Path.GetDirectoryName(Application.ExecutablePath);

                // INFORMATIONS DU DOSSIER
                DirectoryInfo di = new DirectoryInfo(CurrentFolder + "/data/criteria/");

                // SUPPRESSION
                foreach (var file in di.GetFiles())
                    file.Delete();
            }
            catch (Exception ex)
            {
                // ERROR
                MessageBox.Show(ex.ToString());
            }
        }

        #endregion

        #region SAUVEGARDE/RÉCUPÉRATION SIGNALEMENTS

        /// SAUVEGARDE/RÉCUPÉRATION SIGNALEMENTS
        /// 
        /// Concerne le partie du système de sauvegarde qui sauvegarde et récupère les signalements (normaux et matières)
        /// -   SaveNormalSignal()         : void
        /// -   SaveMatiereSignal()        : void
        /// -   GetAllNormalSignal()       : List<NormalSignal>
        /// -   GetAllMatiereSignal()      : List<MatiereSignal>
        /// -   GetNormalSignalByChrono()  : NormalSignal
        /// -   GetMatiereSignalByChrono() : MatiereSignal

        public static void SaveNormalSignal(NormalSignal e)
        {
            try
            {
                // VALEUR A CRYPTER
                string output = JsonConvert.SerializeObject(e);

                // RÉCUPÉRATION DES DIFFÉRENTS DOSSIERS
                string CurrentFolder = Path.GetDirectoryName(Application.ExecutablePath);

                string oldchrono = File.ReadAllText(CurrentFolder + "/data/signals/lastchrono");
                int newchrono = (Convert.ToInt32(oldchrono));

                if (newchrono < e.Chrono)
                    File.WriteAllText(CurrentFolder + "/data/signals/lastchrono", e.Chrono.ToString(), Encoding.ASCII);

                string FileName = CurrentFolder + "/data/signals/normal/" + e.Chrono;

                // CRYPTAGE DES DONNÉES
                Obfuscate(FileName, output);
            }
            catch (Exception ex)
            {
                // EN CAS D'ERREUR
                MessageBox.Show(ex.ToString());
            }
        }

        public static void SaveMatiereSignal(MatiereSignal e)
        {
            try
            {
                // VALEUR A CRYPTER
                string output = JsonConvert.SerializeObject(e);

                // RÉCUPÉRATION DES DIFFÉRENTS DOSSIERS
                string CurrentFolder = Path.GetDirectoryName(Application.ExecutablePath);

                string oldchrono = File.ReadAllText(CurrentFolder + "/data/signals/lastchrono");
                int newchrono = (Convert.ToInt32(oldchrono));

                if (newchrono < e.Chrono)
                    File.WriteAllText(CurrentFolder + "/data/signals/lastchrono", e.Chrono.ToString(), Encoding.ASCII);

                string FileName = CurrentFolder + "/data/signals/material/" + e.Chrono;

                // CRYPTAGE DES DONNÉES
                Obfuscate(FileName, output);
            }
            catch (Exception ex)
            {
                // EN CAS D'ERREUR
                MessageBox.Show(ex.ToString());
            }
        }

        public static List<NormalSignal> GetAllNormalSignal()
        {
            List<NormalSignal> toReturn = new List<NormalSignal>();

            try
            {
                // RÉCUPÉRATION DU DOSSIER
                string CurrentFolder = Path.GetDirectoryName(Application.ExecutablePath);

                // INFORMATIONS DU DOSSIER
                DirectoryInfo di = new DirectoryInfo(CurrentFolder + "/data/signals/normal/");

                // POUR CHAQUE CRITERE..
                foreach (var file in di.GetFiles())
                {
                    NormalSignal ns = JsonConvert.DeserializeObject<NormalSignal>(Deobfuscate((CurrentFolder + "/data/signals/normal/" + file.Name)));
                    toReturn.Add(ns);
                }

                return toReturn;
            }
            catch
            {
                // SI AUCUN CRITERE
                return null;
            }
        }

        public static List<MatiereSignal> GetAllMatiereSignal()
        {
            List<MatiereSignal> toReturn = new List<MatiereSignal>();

            try
            {
                // RÉCUPÉRATION DU DOSSIER
                string CurrentFolder = Path.GetDirectoryName(Application.ExecutablePath);

                // INFORMATIONS DU DOSSIER
                DirectoryInfo di = new DirectoryInfo(CurrentFolder + "/data/signals/material/");

                // POUR CHAQUE CRITERE..
                foreach (var file in di.GetFiles())
                {
                    MatiereSignal ms = JsonConvert.DeserializeObject<MatiereSignal>(Deobfuscate((CurrentFolder + "/data/signals/material/" + file.Name)));
                    toReturn.Add(ms);
                }

                return toReturn;
            }
            catch
            {
                // SI AUCUN CRITERE
                return null;
            }
        }

        public static NormalSignal GetNormalSignalByChrono(string s)
        {
            try
            {
                // RÉCUPÉRATION DU DOSSIER
                string CurrentFolder = Path.GetDirectoryName(Application.ExecutablePath);

                // INFORMATIONS DU DOSSIER
                DirectoryInfo di = new DirectoryInfo(CurrentFolder + "/data/signals/normal/");

                // POUR CHAQUE CRITERE..
                foreach (var file in di.GetFiles())
                {
                    if (file.Name == s)
                        return JsonConvert.DeserializeObject<NormalSignal>(Deobfuscate((CurrentFolder + "/data/signals/normal/" + file.Name)));
                }

                return null;
            }
            catch
            {
                // SI AUCUN CRITERE
                return null;
            }
        }

        public static MatiereSignal GetMatiereSignalByChrono(string s)
        {
            try
            {
                // RÉCUPÉRATION DU DOSSIER
                string CurrentFolder = Path.GetDirectoryName(Application.ExecutablePath);

                // INFORMATIONS DU DOSSIER
                DirectoryInfo di = new DirectoryInfo(CurrentFolder + "/data/signals/material/");

                // POUR CHAQUE CRITERE..
                foreach (var file in di.GetFiles())
                {
                    if (file.Name == s)
                        return JsonConvert.DeserializeObject<MatiereSignal>(Deobfuscate((CurrentFolder + "/data/signals/material/" + file.Name)));
                }

                return null;
            }
            catch
            {
                // SI AUCUN CRITERE
                return null;
            }
        }

        public static object SearchSignalByChrono(string s)
        {
            foreach(NormalSignal ns in Instance.NormalSignalList)
            {
                if (ns.Chrono.ToString() == s)
                    return ns;
            }

            foreach (MatiereSignal ms in Instance.MatiereSignalList)
            {
                if (ms.Chrono.ToString() == s)
                    return ms;
            }

            return null;
        }

        public static List<NormalSignal> SearchNormalSignalByTypeAndMore(Material m, Fournisseur f, string VISA)
        {
            List<NormalSignal> toReturn = new List<NormalSignal>();

            // MATERIEL = TRUE ; FOURNISSEUR = TRUE
            if (m != null && f != null)
            {
                if (VISA == "Validé")
                {
                    foreach (NormalSignal ns in Instance.NormalSignalList)
                    {
                        if (ns.Fournisseur != null && ns.Materiel != null)
                            if (ns.Materiel.Immatriculation == m.Immatriculation && ns.Fournisseur.Nom == f.Nom && ns.VISA == true)
                                toReturn.Add(ns);
                    }
                }
                else if (VISA == "Non-Validé")
                {
                    foreach (NormalSignal ns in Instance.NormalSignalList)
                    {
                        if (ns.Fournisseur != null && ns.Materiel != null)
                            if (ns.Materiel.Immatriculation == m.Immatriculation && ns.Fournisseur.Nom == f.Nom && ns.VISA == false)
                                toReturn.Add(ns);
                    }
                }
                else
                {
                    foreach (NormalSignal ns in Instance.NormalSignalList)
                    {
                        if (ns.Fournisseur != null && ns.Materiel != null)
                            if (ns.Materiel.Immatriculation == m.Immatriculation && ns.Fournisseur.Nom == f.Nom)
                                toReturn.Add(ns);
                    }
                }
            }
            // MATERIEL = FALSE ; FOURNISSEUR = TRUE
            else if (m == null && f != null)
            {
                if (VISA == "Validé")
                {
                    foreach (NormalSignal ns in Instance.NormalSignalList)
                    {
                        if (ns.Fournisseur != null)
                            if (ns.Fournisseur.Nom == f.Nom && ns.VISA == true)
                                toReturn.Add(ns);
                    }
                }
                else if (VISA == "Non-Validé")
                {
                    foreach (NormalSignal ns in Instance.NormalSignalList)
                    {
                        if (ns.Fournisseur != null)
                            if (ns.Fournisseur.Nom == f.Nom && ns.VISA == false)
                                toReturn.Add(ns);
                    }
                }
                else
                {
                    foreach (NormalSignal ns in Instance.NormalSignalList)
                    {
                        if (ns.Fournisseur != null)
                            if (ns.Fournisseur.Nom == f.Nom)
                                toReturn.Add(ns);
                    }
                }
            }
            // MATERIEL = TRUE ; FOURNISSEUR = FALSE
            else if (m != null && f == null)
            {
                if (VISA == "Validé")
                {
                    foreach (NormalSignal ns in Instance.NormalSignalList)
                    {
                        if (ns.Materiel != null)
                            if (ns.Materiel.Immatriculation == m.Immatriculation && ns.VISA == true)
                                toReturn.Add(ns);
                    }
                }
                else if (VISA == "Non-Validé")
                {
                    foreach (NormalSignal ns in Instance.NormalSignalList)
                    {
                        if (ns.Materiel != null)
                            if (ns.Materiel.Immatriculation == m.Immatriculation && ns.VISA == false)
                                toReturn.Add(ns);
                    }
                }
                else
                {
                    foreach (NormalSignal ns in Instance.NormalSignalList)
                    {
                        if (ns.Materiel != null)
                            if (ns.Materiel.Immatriculation == m.Immatriculation)
                                toReturn.Add(ns);
                    }
                }
            }
            // MATERIEL = FALSE ; FOURNISSEUR = FALSE
            else if (m == null && f == null)
            {
                if (VISA == "Validé")
                {
                    foreach (NormalSignal ns in Instance.NormalSignalList)
                    {
                        if (ns.VISA == true)
                            toReturn.Add(ns);
                    }
                }
                else if (VISA == "Non-Validé")
                {
                    foreach (NormalSignal ns in Instance.NormalSignalList)
                    {
                        if (ns.VISA == false)
                            toReturn.Add(ns);
                    }
                }
                else
                    return Instance.NormalSignalList;
            }

            return toReturn;
        }

        public static List<MatiereSignal> SearchMatiereSignalByTypeAndMore(Fournisseur f, string VISA)
        {
            List<MatiereSignal> toReturn = new List<MatiereSignal>();

            // FOURNISSEUR = TRUE
            if (f != null)
            {
                if (VISA == "Validé")
                {
                    foreach (MatiereSignal ms in Instance.MatiereSignalList)
                    {
                        if (ms.Fournisseur != null)
                            if (ms.Fournisseur.Nom == f.Nom && ms.VISA == true)
                                toReturn.Add(ms);
                    }
                }
                else if (VISA == "Non-Validé")
                {
                    foreach (MatiereSignal ms in Instance.MatiereSignalList)
                    {
                        if (ms.Fournisseur != null)
                            if (ms.Fournisseur.Nom == f.Nom && ms.VISA == false)
                                toReturn.Add(ms);
                    }
                }
                else
                {
                    foreach (MatiereSignal ms in Instance.MatiereSignalList)
                    {
                        if (ms.Fournisseur != null)
                            if (ms.Fournisseur.Nom == f.Nom)
                                toReturn.Add(ms);
                    }
                }
            }
            // FOURNISSEUR = FALSE
            else if (f == null)
            {
                if (VISA == "Validé")
                {
                    foreach (MatiereSignal ms in Instance.MatiereSignalList)
                    {
                        if (ms.VISA == true)
                            toReturn.Add(ms);
                    }
                }
                else if (VISA == "Non-Validé")
                {
                    foreach (MatiereSignal ms in Instance.MatiereSignalList)
                    {
                        if (ms.VISA == false)
                            toReturn.Add(ms);
                    }
                }
                else
                    return Instance.MatiereSignalList;
            }

            return toReturn;
        }

        #endregion

        #region SÉCURITÉ DE LA SAUVEGARDE (ILLISIBLE)

        // ECRITURE DU FICHIER ILLISIBLE
        private static void Obfuscate(string fileName, string data)
        {
            var bytes = Encoding.UTF8.GetBytes(data);
            for (int i = 0; i < bytes.Length; i++) bytes[i] ^= 0x5a;
            File.WriteAllText(fileName, Convert.ToBase64String(bytes));
        }

        // RÉCUPÉRATION DU FICHIER ILLISIBLE
        private static string Deobfuscate(string fileName)
        {
            var bytes = Convert.FromBase64String(File.ReadAllText(fileName));
            for (int i = 0; i < bytes.Length; i++) bytes[i] ^= 0x5a;
            return Encoding.UTF8.GetString(bytes);
        }

        #endregion
    }
}