CShark/Business/Manager.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
{
    public class Manager
    {
        public ObservableCollection<Requin> Requins { get; private set; }
        public ObservableCollection<Requin> RequinsEdit { get; private set; }

        public ObservableCollection<Requin> RequinsAdd { get; private set; }
        public Requin SelectedRequin { get; set; }

        /// <summary>
        ///  DéPENDANCE
        /// </summary>
    
        public IPersistanceManager Pers { get; set; }

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

        public Manager(IPersistanceManager pers)
        {
            Requins = new ObservableCollection<Requin>();
            RequinsEdit = new ObservableCollection<Requin>();
            RequinsAdd = new ObservableCollection<Requin>();
            Pers = pers;
        }
        public void LoadRequins()
        {
            Requins.Clear();
            foreach (Requin req in Pers.LoadRequins())
            {
                Requins.Add(req);
            }
            RequinsEdit.Clear();
            foreach (Requin req in Pers.LoadRequinsEdit())
            {
                RequinsEdit.Add(req);
            }
            RequinsAdd.Clear();
            foreach (Requin req in Pers.LoadRequinsAdd())
            {
                RequinsAdd.Add(req);
            }
            SelectedRequin = null;
        }

        public void SaveRequins() 
        {
            Pers.SaveRequins(Requins);
            Pers.SaveRequinsEdit(RequinsEdit);
            Pers.SaveRequinsAdd(RequinsAdd);
        }

        public bool AjouterRequin(Requin req)
        {
            Requin test = Requins.SingleOrDefault(r => r.Equals(req));
            if (Requins.Contains(req) && test!=null){
                return false;

            }
            Requins.Add(req);
            return true;
        }

        public bool SupprimerRequin(Requin req)
        {
            Requin test = Requins.SingleOrDefault(r => r.Equals(req));
            if (!Requins.Contains(req) || test == null)
            {
                return false;
            }
            Requins.Remove(req);
            return true;
        }

        public Requin GetRequin(Requin req)
        {
            return Requins.SingleOrDefault(r => r.Equals(req));
        }

        public bool ModifieRequin(Requin oldR, Requin newR)
        {
            if (!oldR.Equals(newR))
            {
                return false;
            }
            Requins.Remove(oldR);
            Requins.Add(newR);
            return true;
        }

        public bool AjouterRequinEdit(Requin req)
        {
            Requin test = RequinsEdit.SingleOrDefault(r => r.Equals(req));
            if (RequinsEdit.Contains(req) && test != null)
            {
                return false;

            }
            RequinsEdit.Add(req);
            return true;
        }

        public bool SupprimerRequinEdit(Requin req)
        {
            Requin test = RequinsEdit.SingleOrDefault(r => r.Equals(req));
            if (!RequinsEdit.Contains(req) || test == null)
            {
                return false;
            }
            RequinsEdit.Remove(req);
            return true;
        }


        public bool AjouterRequinAdd(Requin req)
        {
            Requin test = RequinsAdd.SingleOrDefault(r => r.Equals(req));
            if (RequinsAdd.Contains(req) && test != null)
            {
                return false;

            }
            RequinsAdd.Add(req);
            return true;
        }

        public bool SupprimerRequinAdd(Requin req)
        {
            Requin test = RequinsAdd.SingleOrDefault(r => r.Equals(req));
            if (!RequinsAdd.Contains(req) || test == null)
            {
                return false;
            }
            RequinsAdd.Remove(req);
            return true;
        }

        public Requin GetRequinEdit(Requin req)
        {
            return RequinsEdit.SingleOrDefault(r => r.Equals(req));
        }

        public Requin GetRequinAdd(Requin req)
        {
            return RequinsAdd.SingleOrDefault(r => r.Equals(req));
        }

        public List<Requin> rechercherRequins(ObservableCollection<Requin> lRech, Nullable<Zone> zone, string motif)
        {
            List<Requin> nvReq = new List<Requin>();
            int test = 0;
            if (!string.IsNullOrWhiteSpace(motif))
            {
                foreach (Requin req in lRech)
                {
                    if (zone == null)
                    {
                        if (req.Nom.Contains(motif) || req.NomSci.Contains(motif))
                        {
                            nvReq.Add(req);
                        }
                    }
                    else
                    {
                        foreach (Zone z in req.Repartition)
                        {
                            if ((req.Nom.Contains(motif) || req.NomSci.Contains(motif)) && zone == z)
                            {
                                test++;
                            }
                        }
                        if (test > 0)
                        {
                            nvReq.Add(req);
                        }
                    }
                    test = 0;
                }
            }
            return nvReq;
        }
    }
}