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/ReferentEPService.cs

231 lines
8.1 KiB

using EPAServeur.Context;
using EPAServeur.Exceptions;
using EPAServeur.IServices;
using EPAServeur.Models.EP;
using IO.Swagger.ApiCollaborateur;
using IO.Swagger.ClientCollaborateur;
using IO.Swagger.DTO;
using IO.Swagger.ModelCollaborateur;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
namespace EPAServeur.Services
{
public class ReferentEPService : IReferentEPService
{
private readonly EpContext context;
private readonly ICollaborateurApi collaborateurApi;
#region Constructeurs
public ReferentEPService(EpContext _context, ICollaborateurApi _collaborateurApi)
{
context = _context;
collaborateurApi = _collaborateurApi;
}
#endregion
#region Service Async
public async Task<ReferentEPDTO> UpdateCollaborateursReferentAsync(ReferentEPDTO body, Guid? idReferent)
{
//Vérifier que l'id du référent et l'id référent dans l'objet body est le même
CheckReferentId(idReferent, body);
Collaborateur referent = await collaborateurApi.ChercherCollabIdAsync(idReferent);
//Vérifier que le référent est valide
CheckReferentValide(referent);
IEnumerable<Collaborateur> collaborateurs = await collaborateurApi.ChercherCollabAsync(collabsId: body.IdsCollaborateur);
//Vérifier que la liste des collaborateurs est valide
CheckListesCollaborateurs(collaborateurs);
//Si il manque un collaborateur, c'est qu'il n'a pas été trouvé
if (collaborateurs.Count() < body.IdsCollaborateur.Count)
throw new CollaborateurNotFoundException("Un collaborateur n'a pas pu être récupéré");
//Si on se retrouve avec plus de collaborateur que demandé
if (collaborateurs.Count() > body.IdsCollaborateur.Count)
throw new ApiException(415, "Une erreur est survenu lors de la récupération des données avec le serveur");
this.SetReferentEPAsync(body.IdsCollaborateur, idReferent);
return body;
}
public async Task<ReferentEPDTO> UpdateReferentCollaborateurAsync(ReferentEPDTO body, Guid? idCollaborateur)
{
CheckCollaborateurId(idCollaborateur, body);
CheckListesIdsCollaborateurs(body.IdsCollaborateur);
Collaborateur referent = await collaborateurApi.ChercherCollabIdAsync(body.IdReferent);
CheckReferentValide(referent);
Collaborateur collaborateur = await collaborateurApi.ChercherCollabIdAsync(idCollaborateur);
CheckCollaborateurValide(collaborateur);
bool premierReferentEP = false;
ReferentEP referentEP = await context.ReferentEP.FindAsync(idCollaborateur);
if (referentEP == null)
{
referentEP = new ReferentEP
{
IdCollaborateur = idCollaborateur.Value
};
premierReferentEP = true;
}
//Si le nouveau référent est déjà le référent actuel du collaborateur, il n'est pas nécessaire de faire quoique ce soit
if (referentEP.IdReferent != null && referentEP.IdReferent.HasValue && referentEP.IdReferent.Value.Equals(body.IdReferent.Value))
{
return body;
}
Guid? ancienReferent = referentEP.IdReferent; //Si non null, il faudra notifier le référent qu'il n'est plus le référent EP du collaborateur
referentEP.IdReferent = body.IdReferent;
if (premierReferentEP)
{
await context.ReferentEP.AddAsync(referentEP);
}
await context.SaveChangesAsync();
if (ancienReferent != null && ancienReferent.HasValue)
{
//notifier l'ancien référent
}
//TODO : Notifier le référent et le collaborateur
return body;
}
#endregion
#region Methodes privees Sync
/// <summary>
/// Vérifier que l'id référent en paramètre et celui dans l'objet sont les même
/// </summary>
/// <param name="idReferent">Id du référent dans l'url</param>
/// <param name="body">objet contenant l'id du référent</param>
private void CheckReferentId(Guid? idReferent, ReferentEPDTO body) {
if (!body.IdReferent.HasValue || !idReferent.Value.Equals(body.IdReferent.Value))
throw new ReferentIncompatibleException("Les données du référents ne correspondent pas");
}
/// <summary>
/// Vérifier que le référent existe et qu'il est toujours présent chez Apside
/// </summary>
/// <param name="referent">Le référent a validé</param>
private void CheckReferentValide(Collaborateur referent)
{
//Vérifier que le référent existe
if (referent == null)
throw new ReferentNotFoundException("Le référent n'a pas été trouvé");
//Vérifier que le référent est toujours présent dans l'entreprise
if (referent.DateDepart.HasValue)
throw new CollaborateurPartiException("Le référent récupéré ne travail plus pour l'entreprise");
}
/// <summary>
/// Vérfier que l'id du collaborateur en paramtère ete l'id du collaborateur dans la liste des ids sont les même
/// </summary>
/// <param name="idCollaborateur">L'id du collaborateur</param>
/// <param name="body">objet contenat l'id du collaborateur</param>
private void CheckCollaborateurId(Guid? idCollaborateur, ReferentEPDTO body) {
if (!body.IdsCollaborateur[0].HasValue || !idCollaborateur.Value.Equals(body.IdsCollaborateur[0].Value))
{
throw new CollaborateurIncompatibleException("Les ids du collaborateur ne correspondent pas ou sont nulls");
}
}
/// <summary>
/// Vérifier que le collaborateur existe est qu'il est toujours présent chez Apside
/// </summary>
/// <param name="collaborateur">Le collaborateur a validé</param>
private void CheckCollaborateurValide(Collaborateur collaborateur)
{
//Aucune valeur nulle n'a été retrouvée
if (collaborateur == null)
throw new CollaborateurNotFoundException("Un collaborateur n'a pas été retrouvé");
//Le collaborateur est toujours présent dans l'entreprise
if (collaborateur.DateDepart.HasValue)
throw new CollaborateurPartiException("Un collaborateur récupéré ne travaille plus pour l'entreprise");
}
private void CheckListesCollaborateurs(IEnumerable<Collaborateur> collaborateurs)
{
foreach(Collaborateur c in collaborateurs) {
//Aucune valeur nulle n'a été retrouvée
CheckCollaborateurValide(c);
}
}
private void CheckListesIdsCollaborateurs(IEnumerable<Guid?> idsCollaborateurs)
{
if (idsCollaborateurs == null || idsCollaborateurs.Count() == 0)
throw new ListeIdsCollaborateursVideException("La liste des collaborateurs ne peut pas être vide");
}
#endregion
#region Methodes privees Async
private async void SetReferentEPAsync(IEnumerable<Guid?> idsCollaborateur, Guid? idReferent)
{
//Garder le lien entre l'anciens référent et le collaborateur pour notifier les anciens référents qu'ils ne sont plus référents
Dictionary<Guid?, Guid?> anciensReferentCollaborateurs = new Dictionary<Guid?, Guid?>();
//La liste des nouveaux collaborateurs du référents qui devront être notifiés de leur nouveau référent
List<Guid?> nouveauxCollaborateurs = new List<Guid?>();
foreach (Guid? idCollaborateur in idsCollaborateur)
{
ReferentEP referentEP = await context.ReferentEP.FindAsync(idCollaborateur);
//Le collaborateur n'a jamais eu de référent donc on lui crée un référentEP et il en sera simplement notifié
if (referentEP == null)
{
referentEP = new ReferentEP
{
IdReferent = idReferent,
IdCollaborateur = idCollaborateur.Value
};
await context.ReferentEP.AddAsync(referentEP);
//context.SaveChanges();
//nouveauxCollaborateurs.Add(idCollaborateur);
}
else
{
//Si le collaborateur a actuellement un référent
if (referentEP.IdReferent != null && referentEP.IdReferent.HasValue)
{
//Si le nouveau référent est déjà le référent actuel du collaborateur, il n'y a rien à faire
if (referentEP.IdReferent.Value.Equals(idReferent.Value))
continue;
//Sauvegarder l'ancien référent et le collaborateur suite au changement
anciensReferentCollaborateurs.Add(idCollaborateur, idReferent);
}
referentEP.IdReferent = idReferent;
//context.SaveChanges();
//nouveauxCollaborateurs.Add(idCollaborateur);
}
await context.SaveChangesAsync();
nouveauxCollaborateurs.Add(idCollaborateur);
}
}
#endregion
}
}