Digitalisation_EPA_Serveur/EPAServeur/Services/CollaborateurService.cs

using EPAServeur.Context;
using EPAServeur.Exceptions;
using EPAServeur.IServices;
using EPAServeur.Models.EP;
using EPAServeur.Models.Formation;
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>
		/// Accès au service permettant de transformer un modèle en dto 
		/// </summary>
		private readonly ITransformDTO transformDTO;

		/// <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, ITransformDTO _transformDTO)
		{
			collaborateurApi = _collaborateurApi;
			context = _contexte;
			transformDTO = _transformDTO;
		}
		#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.HasValue || parPage.Value < minParPage || parPage.Value > maxParPage)
				parPage = defaultParPage;
			if (!numPage.HasValue ||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);

			if (tri != null)
				collaborateursDTO = TriAttribut(collaborateursDTO, tri);

			if (asc.HasValue && !asc.Value)
				collaborateursDTO = collaborateursDTO.Reverse();

			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();
			if (collaborateursIds.Count == 0)
				return new List<CollaborateurDTO>();
			IEnumerable<Collaborateur> collaborateurs = await collaborateurApi.ChercherCollabAsync(collabsId: collaborateursIds);
			if (!parPage.HasValue || parPage.Value < minParPage || parPage.Value > maxParPage)
				parPage = maxParPage;
			if (!numPage.HasValue || numPage.Value <= 0)
				numPage = 1;
			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 && texte != "")
				collaborateursDTO = TriTexte(collaborateursDTO, texte.ToLower());

			if (tri != null)
				collaborateursDTO = TriAttribut(collaborateursDTO, tri);

			if(asc != null && asc == false)
				collaborateursDTO = collaborateursDTO.Reverse();

			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();
			if (collaborateursIds.Count == 0)
				return 0;
			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();
		}

		

		public async Task<IEnumerable<CollaborateurDTO>> GetCollaborateurDTOsAsync(List<Guid?> guids)
		{

			IEnumerable<Collaborateur> collaborateurs = await collaborateurApi.ChercherCollabAsync(collabsId: guids);
			var tasks = collaborateurs.Select(c => GetCollaborateurDTOAsync(c, false));
			IEnumerable<CollaborateurDTO> collaborateursDTO = await Task.WhenAll(tasks);
			return collaborateursDTO;
		}

		/// <summary>
		/// Transformer 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>
		public 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 = transformDTO.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 une liste de CollaborateurDTO contenant les collaborateurs et les référents.
		/// </summary>
		/// <param name="participationsFormation"></param>
		/// <returns></returns>
		public async Task<IEnumerable<CollaborateurDTO>> GetCollaborateurDTOsAsync(List<ParticipationFormation> participationsFormation)
		{
			if (participationsFormation == null || participationsFormation.Count == 0)
				return null;

			List<Guid?> guids = participationsFormation.SelectMany(participationFormation => new[] { (Guid?)participationFormation.DemandeFormation.Ep.IdCollaborateur, participationFormation.DemandeFormation.Ep.IdReferent }).ToList();

			return await GetCollaborateurDTOsAsync(guids);
		}

		/// <summary>
		/// Récupérer une liste de CollaborateurDTO contenant les collaborateurs et les référents.
		/// </summary>
		/// <param name="participationsFormation"></param>
		/// <returns></returns>
		public async Task<IEnumerable<CollaborateurDTO>> GetCollaborateurDTOsAsync(IEnumerable<ParticipationFormation> participationsFormation)
		{
			if (participationsFormation == null || !participationsFormation.Any())
				return null;

			List<Guid?> guids = participationsFormation.SelectMany(participationFormation => new[] { (Guid?)participationFormation.DemandeFormation.Ep.IdCollaborateur, participationFormation.DemandeFormation.Ep.IdReferent }).ToList();

			return await GetCollaborateurDTOsAsync(guids);
		}

		/// <summary>
		/// Récupérer une liste de CollaborateurDTO contenant les collaborateurs et les référents.
		/// </summary>
		/// <param name="demandeFormations"></param>
		/// <returns></returns>
		public async Task<IEnumerable<CollaborateurDTO>> GetCollaborateurDTOsAsync(IEnumerable<DemandeFormation> demandeFormations)
		{
			if (demandeFormations == null || !demandeFormations.Any())
				return null;

			List<Guid?> guids = demandeFormations.SelectMany(participationFormation => new[] { (Guid?)participationFormation.Ep.IdCollaborateur, participationFormation.Ep.IdReferent }).ToList();

			return await GetCollaborateurDTOsAsync(guids);
		}


		/// <summary>
		/// Récupérer le collaborateur et le référent qui sont présent dans l'EP qui est lié à l'engagement.
		/// </summary>
		/// <param name="engagement"></param>
		/// <returns></returns>
		public async Task<IEnumerable<CollaborateurDTO>> GetCollaborateurDTOsAsync(Engagement engagement)
		{
			if (engagement == null)
				return null;

			List<Guid?> guids = new List<Guid?>();

			guids.Add((Guid?)engagement.Ep.IdCollaborateur);
			guids.Add(engagement.Ep.IdReferent);

			return await GetCollaborateurDTOsAsync(guids);
		}

		/// <summary>
		/// Récupérer les collaborateurs et les référents qui sont présent dans les EP qui sont liés aux engagements.
		/// </summary>
		/// <param name="engagements"></param>
		/// <returns></returns>
		public async Task<IEnumerable<CollaborateurDTO>> GetCollaborateurDTOsAsync(IEnumerable<Engagement> engagements)
		{
			if (engagements == null || !engagements.Any())
				return null;

			List<Guid?> guids = engagements.SelectMany(engagement => new[] { (Guid?)engagement.Ep.IdCollaborateur, engagement.Ep.IdReferent }).ToList();

			return await GetCollaborateurDTOsAsync(guids);
		}

		/// <summary>
		/// Récupérer le collaborateur et le référent qui sont présent dans les EP.
		/// </summary>
		/// <param name="eps"></param>
		/// <returns></returns>
		public async Task<IEnumerable<CollaborateurDTO>> GetCollaborateurDTOsAsync(IEnumerable<Ep> eps)
		{
			if (eps == null || !eps.Any())
				return null;

			List<Guid?> guids = eps.SelectMany(ep => new Guid?[] { ep.IdReferent, ep.IdCollaborateur }).Distinct().ToList();

			return await GetCollaborateurDTOsAsync(guids);
		}

		/// <summary>
		/// Récupérer le référent EP d'un collaborateur de manière asynchrone s'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>
		public 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


		#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)
		{
			switch(tri)
			{
				case "datearrivee":
					collaborateurs = collaborateurs.OrderBy(c => c.DateArrivee);
					break;
				case "businessunit":
					collaborateurs = collaborateurs.OrderBy(c => c.BusinessUnit.Nom);
					break;
				case "referent":
					collaborateurs = collaborateurs.OrderBy(c => c.Referent.Nom	);
					break;
				default:
					collaborateurs = collaborateurs.OrderBy(c => c.Nom);
					break;
			}
			return collaborateurs;
		}

		/// <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

	}
}