Digitalisation_EPA_Serveur/EPAServeur/Services/CollaborateurService.cs

using EPAServeur.Context;
using EPAServeur.Exceptions;
using EPAServeur.IServices;
using IO.Swagger.ApiCollaborateur;
using IO.Swagger.DTO;
using IO.Swagger.ModelCollaborateur;
using Microsoft.EntityFrameworkCore.ChangeTracking;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Runtime.InteropServices.ComTypes;
using System.Threading.Tasks;

namespace EPAServeur.Services
{
	/// <summary>
	/// Service permettant de récupérer les informations collaborateurs.
	/// </summary>
	public class CollaborateurService : ICollaborateurService
	{
		#region Variables
		/// <summary>
		/// API pour accéder aux données collaborateur en passant par le service collaborateur
		/// </summary>
		private readonly ICollaborateurApi collaborateurApi;
		#endregion

		#region Constructeurs
		public CollaborateurService(ICollaborateurApi _collaborateurApi)
		{
			collaborateurApi = _collaborateurApi;
		}
		#endregion

		#region Services
		/// <summary>
		/// Récupérer un collaborateur en fonction d'un id
		/// </summary>
		/// <param name="id">Identifiant du collaborateur à renvoyer</param>
		/// <returns>Le collaborateur corresponant à l'id en paramètre</returns>
		public CollaborateurDTO GetCollaborateurById(Guid? id)
		{
			Collaborateur collaborateur = collaborateurApi.ChercherCollabId(id);
			if (collaborateur == null)
				throw new CollaborateurNotFoundException();
			return GetCollaborateurDTO(collaborateur);
		}

		/// <summary>
		/// Récupérer un collaborateur en fonction d'un id de manière asynchrone
		/// </summary>
		/// <param name="id">Identifiant du collaborateur à renvoyer</param>
		/// <returns>Le collaborateur corresponant à l'id en paramètre</returns>
		public async Task<CollaborateurDTO> GetCollaborateurByIdAsync(Guid? id)
		{
			Collaborateur collaborateur = await collaborateurApi.ChercherCollabIdAsync(id);
			if (collaborateur == null)
				throw new CollaborateurNotFoundException();
			return GetCollaborateurDTO(collaborateur);
		}

		/// <summary>
		/// Récupérer un collaborateur en fonction d'un mail
		/// </summary>
		/// <param name="mail">Mail du collaborateur à renvoyer</param>
		/// <returns>Le collaborateur correspondant au mail en paramètre</returns>
		public CollaborateurDTO GetCollaborateurByMail(string mail)
		{
			Collaborateur collaborateur = collaborateurApi.ChercherCollabMail(mail);
			if (collaborateur == null)
				throw new CollaborateurNotFoundException();
			return GetCollaborateurDTO(collaborateur);
		}

		/// <summary>
		/// Récupérer un collaborateur en fonction d'un mail de manière asynchrone
		/// </summary>
		/// <param name="mail">Mail du collaborateur à renvoyer</param>
		/// <returns>Le collaborateur correspondant au mail en paramètre</returns>
		public async Task<CollaborateurDTO> GetCollaborateurByMailAsync(string mail)
		{
			Collaborateur collaborateur = await collaborateurApi.ChercherCollabMailAsync(mail);
			if (collaborateur == null)
				throw new CollaborateurNotFoundException();
			return GetCollaborateurDTO(collaborateur);
		}

		/// <summary>
		///  Récupérer la liste de tous les collaborateurs
		/// </summary>
		/// 
		/// <param name="asc">Précise si la liste est trié dans l'ordre croissant ou décroissant</param>
		/// <param name="numPage">Numéro de la page qui est affiché du côté front</param>
		/// <param name="parPage">Nombre de collaborateurs à renvoyer</param>
		/// <param name="fonctions">Liste des fonctions</param>
		/// <param name="idAgence">id de l'agence à laquelle appartient les collaborateurs à récupérer</param>
		/// <param name="idBU"></param>
		/// <param name="texte">permet de récupérer les collaborateurs dont le nom + prénom ou le prénom + nom contient le texte</param>
		/// <param name="tri">Choisir l'attribut par lequel est trié la liste</param>
		/// <remarks>
		/// <para> idBU est à prendre en compte avant l'idAgence</para>
		/// <para> idAgence n'est à prendre en compte que si idBU est nul </para>
		/// </remarks>
		/// 
		/// <returns>Renvoie la liste des collaborateurs en fonction des paramètres</returns>
		public IEnumerable<CollaborateurDTO> GetCollaborateurs(bool? asc, int? numPage, int? parPage, List<string> fonctions, long? idAgence, long? idBU, string texte, string tri)
		{
			if (texte == null)
				texte = "";
			else
				texte = texte.ToLower();
			IEnumerable<Collaborateur> collaborateurs;
			IEnumerable<CollaborateurDTO> collaborateursDTO;
			if(idBU != null)
				collaborateurs = collaborateurApi.ChercherCollabBU(idBU);
			else if( idAgence != null)
				collaborateurs = collaborateurApi.ChercherCollabAgence(idAgence);
			else
				collaborateurs = collaborateurApi.ChercherCollab();
			if (collaborateurs == null)
				return new List<CollaborateurDTO>();
			int skip = (numPage.Value - 1) * parPage.Value;
			int take = parPage.Value;
			collaborateursDTO = (from c in collaborateurs
								 where (c.Nom + " " + c.Prenom).ToLower().Contains(texte) || (c.Prenom + " " + c.Nom).ToLower().Contains(texte)
								 select GetCollaborateurDTO(c)).Skip(skip).Take(take);

			return collaborateursDTO;
		}

		/// <summary>
		///  Récupérer la liste de tous les collaborateurs de manière asynchrone
		/// </summary>
		/// 
		/// <param name="asc">Précise si la liste est trié dans l'ordre croissant ou décroissant</param>
		/// <param name="numPage">Numéro de la page qui est affiché du côté front</param>
		/// <param name="parPage">Nombre de collaborateurs à renvoyer</param>
		/// <param name="fonctions">Liste des fonctions</param>
		/// <param name="idAgence">id de l'agence à laquelle appartient les collaborateurs à récupérer</param>
		/// <param name="idBU"></param>
		/// <param name="texte">permet de récupérer les collaborateurs dont le nom + prénom ou le prénom + nom contient le texte</param>
		/// <param name="tri">Choisir l'attribut par lequel est trié la liste</param>
		/// <remarks>
		/// <para> idBU est à prendre en compte avant l'idAgence</para>
		/// <para> idAgence n'est à prendre en compte que si idBU est nul </para>
		/// </remarks>
		/// 
		/// <returns>Renvoie la liste des collaborateurs en fonction des paramètres</returns>
		public async Task<IEnumerable<CollaborateurDTO>> GetCollaborateursAsync(bool? asc, int? numPage, int? parPage, List<string> fonctions, long? idAgence, long? idBU, string texte, string tri)
		{
			if (texte == null)
				texte = "";
			else
				texte = texte.ToLower();
			IEnumerable<Collaborateur> collaborateurs;
			IEnumerable<CollaborateurDTO> collaborateursDTO;
			if (idBU != null)
				collaborateurs = await collaborateurApi.ChercherCollabBUAsync(idBU);
			else if (idAgence != null)
				collaborateurs = await collaborateurApi.ChercherCollabAgenceAsync(idAgence);
			else
				collaborateurs = await collaborateurApi.ChercherCollabAsync();
			if (collaborateurs == null)
				return new List<CollaborateurDTO>();
			int skip = (numPage.Value - 1) * parPage.Value;
			int take = parPage.Value;
			collaborateursDTO = (from c in collaborateurs
								 where (c.Nom + " " + c.Prenom).ToLower().Contains(texte) || (c.Prenom + " " + c.Nom).ToLower().Contains(texte)
								 select GetCollaborateurDTO(c)).Skip(skip).Take(take);

			return collaborateursDTO;
		}

		/// <summary>
		/// Récupérer les collaborateurs d'un référent
		/// </summary>
		/// <param name="idReferent">id du référent des collaborateurs à récupérer</param>
		/// <param name="asc">Précise si la liste est trié dans l'ordre croissant ou décroissant</param>
		/// <param name="numPage">Numéro de la page qui est affiché du côté front</param>
		/// <param name="parPage">Nombre de collaborateurs à renvoyer</param>
		/// <param name="texte">permet de récupérer les collaborateurs dont le nom + prénom ou le prénom + nom contient le texte</param>
		/// <param name="tri">Choisir l'attribut par lequel est trié la liste</param>
		/// <returns>Renvoyer les collaborateurs du référent dont l'id est passé en paramètre</returns>
		public IEnumerable<CollaborateurDTO> GetCollaborateursByReferent(Guid? idReferent, bool? asc, int? numPage, int? parPage, string texte, string tri)
		{
			/*
			Stopwatch stopwatch = new Stopwatch();
			stopwatch.Start();
			stopwatch.Stop();
			Console.WriteLine("Durée d'exécution numéro 1: {0}", stopwatch.Elapsed.TotalSeconds);
			stopwatch.Restart();
			stopwatch.Stop();
			Console.WriteLine("Durée d'exécution numéro 1: {0}", stopwatch.Elapsed.TotalSeconds);
			*/
			Collaborateur referent = collaborateurApi.ChercherCollabId(idReferent);
			if (referent == null)
				throw new ReferentNotFoundException();

			if (texte == null)
				texte = "";
			else
				texte = texte.ToLower();
			IEnumerable<Collaborateur> collaborateurs = collaborateurApi.ChercherCollabRef(idReferent);
			int skip = (numPage.Value - 1) * parPage.Value;
			int take = parPage.Value;
			IEnumerable<CollaborateurDTO>  collaborateursDTO = (from c in collaborateurs
								 where (c.Nom + " " + c.Prenom).ToLower().Contains(texte) || (c.Prenom + " " + c.Nom).ToLower().Contains(texte)
								 select GetCollaborateurDTO(c)).Skip(skip).Take(take);
			return collaborateursDTO;
		}

		/// <summary>
		/// Récupérer les collaborateurs d'un référent de manière asynchrone
		/// </summary>
		/// <param name="idReferent">id du référent des collaborateurs à récupérer</param>
		/// <param name="asc">Précise si la liste est trié dans l'ordre croissant ou décroissant</param>
		/// <param name="numPage">Numéro de la page qui est affiché du côté front</param>
		/// <param name="parPage">Nombre de collaborateurs à renvoyer</param>
		/// <param name="texte">permet de récupérer les collaborateurs dont le nom + prénom ou le prénom + nom contient le texte</param>
		/// <param name="tri">Choisir l'attribut par lequel est trié la liste</param>
		/// <returns>Renvoyer les collaborateurs du référent dont l'id est passé en paramètre</returns>
		public async Task<IEnumerable<CollaborateurDTO>> GetCollaborateursByReferentAsync(Guid? idReferent, bool? asc, int? numPage, int? parPage, string texte, string tri)
		{
			/*
			Stopwatch stopwatch = new Stopwatch();
			stopwatch.Start();
			stopwatch.Stop();
			Console.WriteLine("Durée d'exécution numéro 1: {0}", stopwatch.Elapsed.TotalSeconds);
			stopwatch.Restart();
			stopwatch.Stop();
			Console.WriteLine("Durée d'exécution numéro 1: {0}", stopwatch.Elapsed.TotalSeconds);
			*/
			Collaborateur referent = await collaborateurApi.ChercherCollabIdAsync(idReferent);
			if (referent == null)
				throw new ReferentNotFoundException();

			if (texte == null)
				texte = "";
			else
				texte = texte.ToLower();
			IEnumerable<Collaborateur> collaborateurs = await collaborateurApi.ChercherCollabRefAsync(idReferent);
			int skip = (numPage.Value - 1) * parPage.Value;
			int take = parPage.Value;
			IEnumerable<CollaborateurDTO> collaborateursDTO = (from c in collaborateurs
															   where (c.Nom + " " + c.Prenom).ToLower().Contains(texte) || (c.Prenom + " " + c.Nom).ToLower().Contains(texte)
															   select GetCollaborateurDTO(c)).Skip(skip).Take(take);
			return collaborateursDTO;
		}

		/// <summary>
		/// Récupérer le profil d'un collaborateur par mail
		/// </summary>
		/// <param name="mail">mail du collaborateur dont on cherche le profil</param>
		/// <returns>Renvoie le profil correspondant au mail passé en paramètre</returns>
		public ProfilDTO GetProfilByMail(string mail)
		{
			Collaborateur collaborateur = collaborateurApi.ChercherCollabMail(mail);
			if (collaborateur == null)
				throw new CollaborateurNotFoundException();
			return GetProfilDTO(collaborateur);
		}

		/// <summary>
		/// Récupérer le profil d'un collaborateur par mail de manière asynchrone
		/// </summary>
		/// <param name="mail">mail du collaborateur dont on cherche le profil</param>
		/// <returns>Renvoie le profil correspondant au mail passé en paramètre</returns>
		public async Task<ProfilDTO> GetProfilByMailAsync(string mail)
		{
			Collaborateur collaborateur = await collaborateurApi.ChercherCollabMailAsync(mail);
			if (collaborateur == null)
				throw new CollaborateurNotFoundException();
			return GetProfilDTO(collaborateur);
		}

		/// <summary>
		/// Récupérer un profil d'un collaborateur par l'id
		/// </summary>
		/// <param name="idCollaborateur">id du collaborateur dont on cherche le profil</param>
		/// <returns>Renvoie le profil correspondant à l'id passé en paramètre</returns>
		public ProfilDTO GetProfilById(Guid? idCollaborateur)
		{
			//Stopwatch stopwatch = new Stopwatch();
			//stopwatch.Start();
			Collaborateur collaborateur = collaborateurApi.ChercherCollabId(idCollaborateur);
			//stopwatch.Stop();
			//Console.WriteLine("Durée d'exécution GetProfil: {0}", stopwatch.Elapsed.TotalSeconds);
			//stopwatch.Restart();
			//stopwatch.Stop();
			//Console.WriteLine("Durée d'exécution numéro 1: {0}", stopwatch.Elapsed.TotalSeconds);

			if (collaborateur == null)
				throw new CollaborateurNotFoundException();
			return GetProfilDTO(collaborateur);
		}

		/// <summary>
		/// Récupérer un profil d'un collaborateur par l'id de manière asynchrone
		/// </summary>
		/// <param name="idCollaborateur">id du collaborateur dont on cherche le profil</param>
		/// <returns>Renvoie le profil correspondant à l'id passé en paramètre</returns>
		public async Task<ProfilDTO> GetProfilByIdAsync(Guid? idCollaborateur)
		{
			//Stopwatch stopwatch = new Stopwatch();
			//stopwatch.Start();
			Collaborateur collaborateur = await collaborateurApi.ChercherCollabIdAsync(idCollaborateur);
			//stopwatch.Stop();
			//Console.WriteLine("Durée d'exécution GetProfil: {0}", stopwatch.Elapsed.TotalSeconds);
			//stopwatch.Restart();
			//stopwatch.Stop();
			//Console.WriteLine("Durée d'exécution numéro 1: {0}", stopwatch.Elapsed.TotalSeconds);

			if (collaborateur == null)
				throw new CollaborateurNotFoundException();
			return GetProfilDTO(collaborateur);
		}
		#endregion

		#region DTO To Object

		/// <summary>
		/// Transformer un objet collaborateur en ProfilDTO
		/// </summary>
		/// <param name="collaborateur">collaborateur a transformé en profilDTO</param>
		/// <returns>Renvoie le profil associé au collaborateur passé en paramètre</returns>
		private ProfilDTO GetProfilDTO(Collaborateur collaborateur)
		{
			ProfilDTO profilDTO = new ProfilDTO()
			{
				Id = collaborateur.Id,
				DateArrivee = collaborateur.DateArrivee,
				MailApside = collaborateur.MailApside,
				Nom = collaborateur.Nom,
				Prenom = collaborateur.Prenom,
				BusinessUnit = GetBusinessUnitDTO(collaborateur.BusinessUnit)
			};
			return profilDTO;
		}

		/// <summary>
		/// Transformer une agence en agenceDTO
		/// </summary>
		/// <param name="agence">agence à transformer en agenceDTO</param>
		/// <returns>Retourne la transformation DTO de l'agence</returns>
		private AgenceDTO GetAgenceDTO(Agence agence)
		{
			if (agence == null)
				return null;
			AgenceDTO agenceDTO = new AgenceDTO()
			{
				Id = agence.Id,
				Nom = agence.Nom,
				Bu = new List<BusinessUnitDTO>()
			};
			agenceDTO.Bu = agence.Bus.Select(bu => new BusinessUnitDTO()
			{
				Id = bu.Id,
				Nom = bu.Nom
			}).ToList();
			return agenceDTO;
		}

		/// <summary>
		/// Transforme une businessUnit en businessUnitDTO
		/// </summary>
		/// <param name="businessUnit">businessUnit à transformer en businessUnitDTO</param>
		/// <returns>Retourne la transformation DTO de la businessUnit</returns>
		private BusinessUnitDTO GetBusinessUnitDTO(BU businessUnit)
		{
			if (businessUnit == null)
				return null;
			BusinessUnitDTO businessUnitDTO = new BusinessUnitDTO()
			{
				Id = businessUnit.Id,
				Nom = businessUnit.Nom,
				Agence = GetAgenceDTO(businessUnit.Agence)
			};
			return businessUnitDTO;
		}

		/// <summary>
		/// Transforme un collaborateur en collaborateurDTO
		/// </summary>
		/// <param name="collaborateur">collaborateur à transformer en collaborateurDTO</param>
		/// <returns>Renvoie la transformation DTO du collaborateur</returns>
		private CollaborateurDTO GetCollaborateurDTO(Collaborateur collaborateur)
		{
			CollaborateurDTO collaborateurDTO = new CollaborateurDTO()
			{
				Id = collaborateur.Id,
				Prenom = collaborateur.Prenom,
				Nom = collaborateur.Nom,
				MailApside = collaborateur.MailApside,
				DateArrivee = collaborateur.DateArrivee,

			};
			collaborateurDTO.BusinessUnit = GetBusinessUnitDTO(collaborateur.BusinessUnit);
			collaborateurDTO.Referent = GetReferentDTO(collaborateur.Referent);
			return collaborateurDTO;
		}

		/// <summary>
		/// Transforme un referent en referentDTO
		/// </summary>
		/// <param name="referent">referent à transformer en referentDTO</param>
		/// <returns>Renvoie la transformation DTO du referent</returns>
		private ReferentDTO GetReferentDTO(Referent referent)
		{
			if (referent == null)
				return null;
			ReferentDTO referentDTO = new ReferentDTO()
			{
				Id = referent.Id,
				Prenom = referent.Prenom,
				Nom = referent.Nom,
				MailApside = referent.MailApside
			};
			return referentDTO;
		}
		#endregion
	}
}