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

424 lines
17 KiB

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