CShark/Persistance/DataContractPersistance.cs

using Modèle;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
using System.Runtime.Serialization;
using System.Text;
using System.Threading.Tasks;

namespace Persistance
{
    public class DataContractPersistance : IPersistanceManager
    {

        // DataContractSerializer pour chaque type
        public DataContractSerializer SerializerReq { get; set; }
            = new DataContractSerializer(typeof(List<Requin>));
        public DataContractSerializer SerializerUsers { get; set; }
            = new DataContractSerializer(typeof(List<Personne>));



        // Chemin des fichiers
        string FilePath { get; set; } = Path.Combine(Directory.GetCurrentDirectory(), "..//..//..//Persistance");



        // Noms des fichiers
        string FileNameReq { get; set; }
            = "ficReq";
        string FileNameReqAdd { get; set; }
            = "ficReqAdd";
        string FileNameReqEdit { get; set; }
            = "ficReqEdit";
        string FileNameUsers { get; set; }
            = "ficUsers";



        // Fichiers complets
        string FileReq => Path.Combine(FilePath, FileNameReq);
        string FileReqAdd => Path.Combine(FilePath, FileNameReqAdd);
        string FileReqEdit => Path.Combine(FilePath, FileNameReqEdit);
        string FileUsers => Path.Combine(FilePath, FileNameUsers);



        // Listes des requins et utilisateurs
        ObservableCollection<Requin> requins = new ObservableCollection<Requin>();
        ObservableCollection<Requin> requinsAdd = new ObservableCollection<Requin>();
        ObservableCollection<Requin> requinsEdit = new ObservableCollection<Requin>();
        ObservableCollection<Personne> users = new ObservableCollection<Personne>();



        // Méthodes pour les requins de l'application
        public ObservableCollection<Requin> LoadRequins()
        {
            if (!File.Exists(FileReq))
            {
                throw new FileNotFoundException("The persisance ficReq does not exist");
            }

            using (Stream stream = File.OpenRead(FileReq))
            {
                requins = SerializerReq.ReadObject(stream) as ObservableCollection<Requin>;
            }

            return requins;
        }
        public void SaveRequins(ObservableCollection<Requin> reqs)
        {
            if (!Directory.Exists(FilePath))
            {
                Directory.CreateDirectory(FilePath);
            }

            using (Stream stream = File.Create(FileReq))
            {
                SerializerReq.WriteObject(stream, requins);
            }
        }



        // Méthodes pour les requins ajoutés par les Utilisateurs
        public ObservableCollection<Requin> LoadRequinsAdd()
        {
            if (!File.Exists(FileReqAdd))
            {
                throw new FileNotFoundException("The persisance file ficReqAdd does not exist");
            }

            using (Stream stream = File.OpenRead(FileReqAdd))
            {
                requinsAdd = SerializerReq.ReadObject(stream) as ObservableCollection<Requin>;
            }

            return requinsAdd;
        }

        public void SaveRequinsAdd(ObservableCollection<Requin> reqs)
        {
            if (!Directory.Exists(FilePath))
            {
                Directory.CreateDirectory(FilePath);
            }

            using (Stream stream = File.Create(FileReqAdd))
            {
                SerializerReq.WriteObject(stream, requinsAdd);
            }
        }



        // Méthodes pour les requins édités par les utilisateurs
        public ObservableCollection<Requin> LoadRequinsEdit()
        {
            if (!File.Exists(FileReqEdit))
            {
                throw new FileNotFoundException("The persisance file ficReqEdit does not exist");
            }

            using (Stream stream = File.OpenRead(FileReqEdit))
            {
                requinsEdit = SerializerReq.ReadObject(stream) as ObservableCollection<Requin>;
            }

            return requinsEdit;
        }

        public void SaveRequinsEdit(ObservableCollection<Requin> reqs)
        {
            if (!Directory.Exists(FilePath))
            {
                Directory.CreateDirectory(FilePath);
            }

            using (Stream stream = File.Create(FileReqEdit))
            {
                SerializerReq.WriteObject(stream, requinsEdit);
            }
        }



        // Méthodes pour les utilisateurs (Utilisateur et Manager)
        public ObservableCollection<Personne> LoadUsers()
        {
            if (!File.Exists(FileUsers))
            {
                throw new FileNotFoundException("The persisance file ficUsers does not exist");
            }

            using (Stream stream = File.OpenRead(FileUsers))
            {
                users = SerializerUsers.ReadObject(stream) as ObservableCollection<Personne>;
            }

            return users;
        }

        public void SaveUsers(ObservableCollection<Personne> pers)
        {
            if (!Directory.Exists(FilePath))
            {
                Directory.CreateDirectory(FilePath);
            }

            using (Stream stream = File.Create(FileUsers))
            {
                SerializerUsers.WriteObject(stream, users);
            }
        }

    }
}