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;
using System.Xml;

namespace Persistance
{
    public class DataContractPersistance : IPersistanceManager
    {

        // Serializers pour requins et utlisateurs/experts
        DataContractSerializer SerializerReq { get; set; }
            = new DataContractSerializer(typeof(DataToPersistReq));
        DataContractSerializer SerializerUsers { get; set; }
            = new DataContractSerializer(typeof(DataToPersistUsers));



        // DataToPersistReq et DataToPersistUsers
        DataToPersistReq dataReq = new DataToPersistReq();
        DataToPersistUsers data = new DataToPersistUsers();



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



        // Noms des fichiers
        string FileNameReq { get; set; }
            = "ficReqs";
        string FileNameUsers { get; set; }
            = "ficUsers";



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



        // Settings
        public XmlWriterSettings settings { get; set; }
            = new XmlWriterSettings() { Indent = true };



        // Méthodes pour les utilisateurs et experts
        public (List<Utilisateur>, List<Expert>) LoadUsers()
        {
            if (!File.Exists(FileUsers))
            {
                throw new FileNotFoundException("The persistance file does not exist");
            }

            using (Stream stream = File.OpenRead(FileUsers))
            {
                data = SerializerUsers.ReadObject(stream) as DataToPersistUsers;
            }

            return (data.Users, data.Experts);
        }



        public void SaveUsers(List<Utilisateur> users, List<Expert> experts)
        {
            if (!Directory.Exists(FilePath))
            {
                Directory.CreateDirectory(FileUsers);
            }

            data.Users.AddRange(users);
            data.Experts.AddRange(experts);

            using (TextWriter tw = File.CreateText(Path.Combine(FilePath, FileNameUsers)))
            {
                using (XmlWriter writer = XmlWriter.Create(tw, settings))
                {
                    SerializerUsers.WriteObject(writer, data);
                }
            }
        }



        // Méthodes pour tous les requins
        public (List<Requin>, List<Requin>, List<Requin>) LoadRequins()
        {
            if (!File.Exists(FileReq))
            {
                throw new FileNotFoundException("The persistance file does not exist");
            }

            using (Stream stream = File.OpenRead(FileReq))
            {
                dataReq = SerializerReq.ReadObject(stream) as DataToPersistReq;
            }

            return (dataReq.Requins, dataReq.RequinsAdd, dataReq.RequinsEdit);
        }



        public void SaveRequins(List<Requin> reqs, List<Requin> reqsAdd, List<Requin> reqsEdit)
        {
            if (!Directory.Exists(FilePath))
            {
                Directory.CreateDirectory(FilePath);
            }

            dataReq.Requins.AddRange(reqs);
            dataReq.RequinsAdd.AddRange(reqsAdd);
            dataReq.RequinsEdit.AddRange(reqsEdit);

            using (TextWriter tw = File.CreateText(Path.Combine(FilePath, FileReq)))
            {
                using (XmlWriter writer = XmlWriter.Create(tw, settings))
                {
                    SerializerReq.WriteObject(writer, dataReq);
                }
            }
        }

    }
}