You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Digitalisation_EPA_Serveur/EPAServeur/Services/CollaborateurService.cs

426 lines
17 KiB

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);
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);
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;
}
#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
#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
}
}