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.
467 lines
19 KiB
467 lines
19 KiB
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 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
|
|
|
|
}
|
|
}
|
|
|