CShark/Business/ManagerUsers.cs

using Modèle;
using Persistance;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Business
{
    /// <summary>
    /// Class Manager qui gère les Experts et les Utilisateurs
    /// </summary>
    public class ManagerUsers
    {
        /// <summary>
        /// List d'Utilisateur, la liste des utilisateurs de l'application
        /// </summary>
        public List<Utilisateur> Utilisateurs { get; private set; }
        /// <summary>
        /// List d'Expert, la liste des experts de l'application
        /// </summary>
        public List<Expert> Experts { get; private set; }
        /// <summary>
        /// L'utilisateur ou l'expert actuellement connecté
        /// </summary>
        public Personne SelectedUser { get; set; }

        /// <summary>
        ///  DéPENDANCE
        /// </summary>

        public IPersistanceManager Pers { get; set; }

        /// <summary>
        /// constructeur avec INJECTION DE LA DéPENDANCE
        /// </summary>

        public ManagerUsers(IPersistanceManager pers)
        {
            Utilisateurs = new List<Utilisateur>();
            Experts = new List<Expert>();
            Pers = pers;
        }


        /// <summary>
        /// Méthode LoadUsers de la classe ManagerUser qui permet de charger les liste d'Utilisateurs et d'Experts grâce à l'IPersistanceManager
        /// </summary>
        public void LoadUsers()
        {

            var data = Pers.LoadUsers();

            Utilisateurs.Clear();
            foreach (var u in data.users)
            {
                Utilisateurs.Add(u);
            }
            Experts.Clear();
            foreach (var e in data.experts)
            {
                Experts.Add(e);
            }

        }

        /// <summary>
        /// Méthode SaveUsers de la classe ManagerUser qui permet de sauvegarder les listes d'Utilisateurs et d'Experts grâce à l'IPersistanceManager
        /// </summary>
        public void SaveUsers()
        {
            Pers.SaveUsers(Utilisateurs, Experts);
        }


        /// <summary>
        /// Méthode AjouterUtilisateur de la classe ManagerUser qui permet d'ajouter un Utilisateur dans la liste d'Utilisateurs
        /// </summary>
        /// <param name="user">Utilisateur qui va être ajouté dans la liste</param>
        /// <returns>Booléen : true si il a été ajouté, false sinon</returns>
        public bool AjouterUtilisateur(Utilisateur user)
        {
            if (Utilisateurs.Contains(user))
            {
                return false;

            }
            Utilisateurs.Add(user);
            return true;
        }

        /// <summary>
        /// Méthode SupprmierUtilisateur de la classe ManagerUser qui permet de supprimer un Utilisateur de la liste des Utilisateurs 
        /// </summary>
        /// <param name="user">Utilisateur qui va être supprimé dans la liste</param>
        /// <returns>Booléen : true si il a été supprimé, false sinon</returns>
        public bool SupprimerUtilisateur(Utilisateur user)
        {
            if (!Utilisateurs.Contains(user))
            {
                return false;
            }
            Utilisateurs.Remove(user);
            return true;
        }


        /// <summary>
        /// Méthode AjouterExpert de la classe ManagerUser qui permet d'ajouter un Expert dans la liste d'Experts
        /// </summary>
        /// <param name="expert">Expert qui va être ajouté dans la liste</param>
        /// <returns>Booléen : true si il a été ajouté, false sinon</returns>
        public bool AjouterExpert(Expert expert)
        {
            if (Experts.Contains(expert))
            {
                return false;

            }
            Experts.Add(expert);
            return true;
        }

        /// <summary>
        /// Méthode SupprmierExpertr de la classe ManagerUser qui permet de supprimer un Expert de la liste des Experts 
        /// </summary>
        /// <param name="expert">Expert qui va être supprimé dans la liste</param>
        /// <returns>Booléen : true si il a été supprimé, false sinon</returns>
        public bool SupprimerExpert(Expert expert)
        {
            if (!Experts.Contains(expert))
            {
                return false;
            }
            Experts.Remove(expert);
            return true;
        }


        /// <summary>
        /// Méthode GetPersonne de la classe ManagerUser qui permet de récupérer une personne dans la liste de personne (Expert et Utilisateur)
        /// </summary>
        /// <param name="pers">Personne que l'on cherche dans dans la liste</param>
        /// <returns>Personne trouvée</returns>
        public Personne GetPersonne(Personne pers)
        {
            return Utilisateurs.SingleOrDefault(r => r.Equals(pers));
        }


        /// <summary>
        /// Méthode ModifieUtilisateur de la classe ManagerUser qui permet de modifier un ancien Utilisateur de la liste des Utilisateurs à partir d'un nouveau
        /// </summary>
        /// <param name="oldU">Utilisateur l'ancien Utilisateur dans la liste des utilisateurs</param>
        /// <param name="newU">Utilisateur le nouvel requin</param>
        /// <returns>Booléen : true si il a été modifié, false sinon</returns>
        public bool ModifieUtilisateur(Utilisateur oldU, Utilisateur newU)
        {
            if (!oldU.Equals(newU))
            {
                return false;
            }
            Utilisateurs.Remove(oldU);
            Utilisateurs.Add(newU);
            return true;
        }


        /// <summary>
        /// Méthode ModifieExpert de la classe ManagerUser qui permet de modifier un ancien Expert de la liste des Experts à partir d'un nouveau
        /// </summary>
        /// <param name="oldE">Expert l'ancien Expert dans la liste des experts</param>
        /// <param name="newE">Expert le nouveau Expert</param>
        /// <returns>Booléen : true si il a été modifié, false sinon</returns>
        public bool ModifieExpert(Expert oldE, Expert newE)
        {
            if (!oldE.Equals(newE))
            {
                return false;
            }
            Experts.Remove(oldE);
            Experts.Add(newE);
            return true;
        }


    }
}