Digitalisation_EPA_Serveur/EPAServeur/Services/CollaborateurService.cs

using EPAServeur.Context;
using EPAServeur.Exceptions;
using EPAServeur.IServices;
using EPAServeur.Models.EP;
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;

		/// <summary>
		/// Nombre d'éléments min à afficher par page
		/// </summary>
		private readonly int minParPage = 5;

		/// <summary>
		/// Nom d'éléments max à affichar par page
		/// </summary>
		private readonly int maxParPage = 100;

		/// <summary>
		/// Nombre d'éléments à afficher par défaut par page
		/// </summary>
		private readonly int defaultParPage = 15;

		/// <summary>
		/// Accès et gestion de la base de données
		/// </summary>
		private readonly EpContext context;
		#endregion


		#region Constructeurs
		public CollaborateurService(ICollaborateurApi _collaborateurApi, EpContext _contexte)
		{
			collaborateurApi = _collaborateurApi;
			context = _contexte;
		}
		#endregion


		#region Services Async
		/// <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("Le collaborateur recherché n'a pas été trouvé");
			return await GetCollaborateurDTOAsync(collaborateur, true);
		}

		/// <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("Le collaborateur recherché n'a pas été trouvé");
			return await GetCollaborateurDTOAsync(collaborateur, true);
		}


		/// <summary>
		///  Récupérer la liste de tous les collaborateurs de manière asynchrone
		/// </summary>
		/// 
		/// <param name="roles">Liste des rôles auxquels les collaborateurs à récupérer appartiennent</param>
		/// <param name="idBUs">Liste des business units auxquelles sont rattachés les 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="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>
		/// <param name="dateDebut">Date à partir de laquelle les collaborateurs sont arrivés</param>
		/// <param name="dateFin">Date jusqu'à laquelle les collaborateurs sont arrivés</param>
		/// <returns>Renvoie la liste des collaborateurs en fonction des paramètres</returns>
		public async Task<IEnumerable<CollaborateurDTO>> GetCollaborateursAsync(List<string> roles, List<long?> idBUs, bool? asc, int? numPage, int? parPage, string texte, string tri, DateTime? dateDebut, DateTime? dateFin)
		{
			IEnumerable<Collaborateur> collaborateurs;
			IEnumerable<CollaborateurDTO> collaborateursDTO;

			collaborateurs = await collaborateurApi.ChercherCollabAsync(ancienCollaborateur: false, roles: roles, buIds: idBUs);
			/*collaborateursDTO = (from c in collaborateurs
								 select GetCollaborateurDTO(c, false));*/

			var task = collaborateurs.Select(c => GetCollaborateurDTOAsync(c, true));
			collaborateursDTO = await Task.WhenAll(task);

			if (parPage.Value < minParPage || parPage.Value > maxParPage)
				parPage = defaultParPage;
			if (numPage.Value <= 0)
				numPage = 1;

			int skip = (numPage.Value - 1) * parPage.Value;
			int take = parPage.Value;
			if (texte != null)
				collaborateursDTO = TriTexte(collaborateursDTO, texte.ToLower());


			collaborateursDTO = TriDates(collaborateursDTO, dateDebut, dateFin);

			return collaborateursDTO.Skip(skip).Take(take);
		}


		/// <summary>
		///  Récupérer le nombre de collaborateurs correspondant aux paramètres de la requête de manière asynchrone
		/// </summary>
		/// 
		/// <param name="roles">Liste des rôles auxquels les collaborateurs à récupérer appartiennent</param>
		/// <param name="idBUs">Liste des business units auxquelles sont rattachés les collaborateurs à récupérer</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="dateDebut">Date à partir de laquelle les collaborateurs sont arrivés</param>
		/// <param name="dateFin">Date jusqu'à laquelle les collaborateurs sont arrivés</param>
		/// <returns>Renvoie la liste des collaborateurs en fonction des paramètres</returns>
		/// <returns>Le nombre de collaborateur</returns>
		public async Task<int> GetCollaborateursCountAsync(List<string> roles, List<long?> idBUs, string texte, DateTime? dateDebut, DateTime? dateFin)
		{
			IEnumerable<Collaborateur> collaborateurs;
			IEnumerable<CollaborateurDTO> collaborateursDTO;

			collaborateurs = await collaborateurApi.ChercherCollabAsync(ancienCollaborateur: false, roles: roles, buIds: idBUs);
			
			var tasks = collaborateurs.Select(c => GetCollaborateurDTOAsync(c, false));
			collaborateursDTO = await Task.WhenAll(tasks);
			
			if (texte != null)
				collaborateursDTO = TriTexte(collaborateursDTO, texte.ToLower());

			collaborateursDTO = TriDates(collaborateursDTO, dateDebut, dateFin);

			return collaborateursDTO.Count();
		}

		/// <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 en paramètre</returns>
		public async Task<IEnumerable<CollaborateurDTO>> GetCollaborateursByReferentAsync(Guid? idReferent, bool? asc, int? numPage, int? parPage, string texte, string tri)
		{
			Collaborateur referent = await collaborateurApi.ChercherCollabIdAsync(idReferent);
			if (referent == null)
				throw new ReferentNotFoundException("Le référent recherché n'a pas été trouvé");

			List<Guid?> collaborateursIds = (from r in context.ReferentEP
											 where r.IdReferent.Value.Equals(idReferent)
											 select (Guid?) r.IdCollaborateur).ToList();

			IEnumerable<Collaborateur> collaborateurs = await collaborateurApi.ChercherCollabAsync(collabsId: collaborateursIds);
			int skip = (numPage.Value - 1) * parPage.Value;
			int take = parPage.Value;
			
			var tasks = collaborateurs.Select(c => GetCollaborateurDTOAsync(c, false));
			IEnumerable<CollaborateurDTO> collaborateursDTO = await Task.WhenAll(tasks);
			if (texte != null)
				collaborateursDTO = TriTexte(collaborateursDTO, texte.ToLower());
			return collaborateursDTO.Skip(skip).Take(take);
		}

		/// <summary>
		/// Récupérer le nombre de collaborateurs d'un référent en fonction des paramètres de manière asynchrone
		/// </summary>
		/// <param name="idReferent">id du référent des collaborateurs à récupérer</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>
		/// <returns>Renvoyer le nombre collaborateurs du référent en fonction des paramètres</returns>
		public async Task<int> GetCollaborateursCountByReferentAsync(Guid? idReferent, string texte)
		{
			Collaborateur referent = await collaborateurApi.ChercherCollabIdAsync(idReferent);
			if (referent == null)
				throw new ReferentNotFoundException("Le référent recherché n'a pas été trouvé");

			List<Guid?> collaborateursIds = (from r in context.ReferentEP
											 where r.IdReferent.Value.Equals(idReferent)
											 select (Guid?)r.IdCollaborateur).ToList();
			IEnumerable<Collaborateur> collaborateurs = await collaborateurApi.ChercherCollabAsync(collabsId: collaborateursIds);


			var tasks = collaborateurs.Select(c => GetCollaborateurDTOAsync(c, false));
			IEnumerable<CollaborateurDTO> collaborateursDTO = await Task.WhenAll(tasks);
			if (texte != null)
				collaborateursDTO = TriTexte(collaborateursDTO, texte.ToLower());
			return collaborateursDTO.Count();
		}

		/// <summary>
		/// Récupérer la liste référents ayant fait passer des EP au collaborateur 
		/// </summary>
		/// <param name="idCollaborateur">id du collaborateur concerné</param>
		/// <returns>Liste des référents</returns>
		public Task<IEnumerable<CollaborateurDTO>> GetReferentsPrecedentsEPAsync(Guid? idCollaborateur)
		{
			throw new NotImplementedException();
		}

		

		#endregion


		#region Methode de tri
		/// <summary>
		/// Permettre de récupéer les collaborateurs en fonction de leur nom et/ou prénom
		/// </summary>
		/// <param name="collaborateurs">Liste des collaborateurs à trier</param>
		/// <param name="texte">Texte permettant de trier par rapport aux noms et prénoms</param>
		/// <returns>Une liste de collaborateurs</returns>
		private IEnumerable<CollaborateurDTO> TriTexte(IEnumerable<CollaborateurDTO> collaborateurs, string texte)
		{
			return (from c in collaborateurs
					where (c.Nom + " " + c.Prenom).ToLower().Contains(texte) || (c.Prenom + " " + c.Nom).ToLower().Contains(texte)
					select c);
		}

		/// <summary>
		/// Permettre de trier les données collaborateurs en fonction d'un attribut
		/// </summary>
		/// <param name="collaborateurs">La liste des collaborateurs à trier</param>
		/// <param name="tri">L'attribut sur lequel les données sont triées</param>
		/// <param name="asc">Indique si les données sont rangées dans l'ordre croissant ou non</param>
		/// <returns>Une liste de collaborateur</returns>
		private IEnumerable<CollaborateurDTO> TriAttribut(IEnumerable<CollaborateurDTO> collaborateurs, string tri, bool asc)
		{
			throw new NotImplementedException();
		}

		/// <summary>
		/// Cette fonction va permettre de récupérer les collaborteurs dont la date d'arrivée se situe dans un intervalle de dates
		/// </summary>
		/// <param name="collaborateurs">La liste des collaborateurs à trier</param>
		/// <param name="dateDebut">La date à partir de laquelle les dates d'arrivées sont récupérées</param>
		/// <param name="dateFin">La data limite d'arrivée du collaborateur</param>
		/// <returns>Une liste de collaborateurs</returns>
		private IEnumerable<CollaborateurDTO> TriDates(IEnumerable<CollaborateurDTO> collaborateurs, DateTime? dateDebut, DateTime? dateFin)
		{
			if(dateDebut.HasValue && dateFin.HasValue)
			{
				DateTime dateFinValue = dateFin.Value.AddDays(1);
				return (from c in collaborateurs
						where c.DateArrivee >= dateDebut.Value && c.DateArrivee < dateFinValue
						select c);
			}
			if(dateDebut.HasValue)
			{
				return (from c in collaborateurs
								  where c.DateArrivee >= dateDebut.Value
								  select c);
			}
			if(dateFin.HasValue)
			{
				DateTime dateFinValue = dateFin.Value.AddDays(1);
				return  (from c in collaborateurs
								  where c.DateArrivee < dateFinValue
						 select c);
			}
			return collaborateurs;
		}
		#endregion


		#region DTO To Object

		/// <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 de manière asynchrone
		/// </summary>
		/// <param name="collaborateur">collaborateur à transformer en collaborateurDTO</param>
		/// <param name="chercherReferent">Indiquer si le référent du collaborateur doit être récupéré ou non</param>
		/// <returns>Renvoie la transformation DTO du collaborateur</returns>
		private async Task<CollaborateurDTO> GetCollaborateurDTOAsync(Collaborateur collaborateur, bool chercherReferent)
		{
			CollaborateurDTO collaborateurDTO = new CollaborateurDTO()
			{
				Id = collaborateur.Id,
				Prenom = collaborateur.Prenom,
				Nom = collaborateur.Nom,
				MailApside = collaborateur.MailApside,
				DateArrivee = collaborateur.DateArrivee,

			};
			collaborateurDTO.BusinessUnit = GetBusinessUnitDTO(collaborateur.BusinessUnit);
			//Si le référent du collaborateur doit être récupérer en même temps
			if (chercherReferent)
				collaborateurDTO.Referent = await GetReferentAsync(collaborateurDTO);
			return collaborateurDTO;
		}



		/// <summary>
		/// Récupérer le référent EP d'un collaborateur de manière asynchrone si il existe
		/// </summary>
		/// <param name="collaborateur">Le collaborateur dont on cherche le référent EP</param>
		/// <returns>Le référent EP du collaborateur</returns>
		private async Task<CollaborateurDTO> GetReferentAsync(CollaborateurDTO collaborateur)
		{
			ReferentEP referentEP = await context.ReferentEP.FindAsync(collaborateur.Id);
			//vérifier que le collaorateur a un référent EP
			if (referentEP == null || referentEP.IdReferent == null || !referentEP.IdReferent.HasValue || referentEP.IdReferent.Value == null)
				return null;
			Collaborateur referent = await collaborateurApi.ChercherCollabIdAsync(referentEP.IdReferent);
			if (referent == null)
				return null;
			return await GetCollaborateurDTOAsync(referent, false);
		}
		#endregion
	}
}