diff --git a/EPAServeur/Controllers/ReferentsEPApi.cs b/EPAServeur/Controllers/ReferentsEPApi.cs index c885ee9..17d60ab 100644 --- a/EPAServeur/Controllers/ReferentsEPApi.cs +++ b/EPAServeur/Controllers/ReferentsEPApi.cs @@ -18,6 +18,12 @@ using IO.Swagger.Attributes; using IO.Swagger.Security; using Microsoft.AspNetCore.Authorization; using IO.Swagger.DTO; +using EPAServeur.IServices; +using Microsoft.Extensions.Logging; +using System.Threading.Tasks; +using EPAServeur.Exceptions; +using IO.Swagger.ClientCollaborateur; +using Microsoft.EntityFrameworkCore; namespace IO.Swagger.Controllers { @@ -26,7 +32,19 @@ namespace IO.Swagger.Controllers /// [ApiController] public class ReferentsEPApiController : ControllerBase - { + { + + private readonly IReferentEPService referentEPService; + private readonly ILogger logger; + + + public ReferentsEPApiController(IReferentEPService _referentEPService, ILogger _logger) + { + referentEPService = _referentEPService; + logger = _logger; + } + + /// /// /// @@ -50,8 +68,104 @@ namespace IO.Swagger.Controllers [SwaggerResponse(statusCode: 404, type: typeof(ErreurDTO), description: "La ressource n'a pas été trouvée")] [SwaggerResponse(statusCode: 415, type: typeof(ErreurDTO), description: "L’opération ne peut pas être effectuée car certaines données sont manquantes")] [SwaggerResponse(statusCode: 500, type: typeof(ErreurDTO), description: "Une erreur est survenue sur le serveur")] - public virtual IActionResult UpdateCollaborateursReferent([FromBody]ReferentEPDTO body, [FromRoute][Required]Guid? idReferent) - { + public virtual async Task UpdateCollaborateursReferent([FromBody]ReferentEPDTO body, [FromRoute][Required]Guid? idReferent) + { + + try + { + body = await referentEPService.UpdateCollaborateursReferentAsync(body, idReferent); + } + catch (ApiException e) + { + ErreurDTO erreur = new ErreurDTO(); + if (e.ErrorCode == 415) + { + erreur.Code = 415; + erreur.Message = e.Message; + } + else + { + erreur.Code = 500; + erreur.Message = "Un erreur est survenue lors de la communication avec le serveur distant"; + } + return StatusCode(erreur.Code.Value, erreur); + } + catch (ReferentIncompatibleException e) + { + ErreurDTO erreur = new ErreurDTO + { + Code = 415, + Message = e.Message, + }; + return StatusCode(erreur.Code.Value, erreur); + } + catch (ReferentNotFoundException e) + { + ErreurDTO erreur = new ErreurDTO + { + Code = 404, + Message = e.Message, + }; + return StatusCode(erreur.Code.Value, erreur); + } + catch (ListeIdsCollaborateursVideException e) + { + ErreurDTO erreur = new ErreurDTO + { + Code = 415, + Message = e.Message, + }; + return StatusCode(erreur.Code.Value, erreur); + } + catch (CollaborateurPartiException e) + { + ErreurDTO erreur = new ErreurDTO + { + Code = 4, + Message = e.Message, + }; + return StatusCode(erreur.Code.Value, erreur); + } + catch (CollaborateurNotFoundException e) + { + ErreurDTO erreur = new ErreurDTO + { + Code = 404, + Message = e.Message, + }; + return StatusCode(erreur.Code.Value, erreur); + } + catch (DbUpdateConcurrencyException) + { + ErreurDTO erreur = new ErreurDTO + { + Code = 500, + Message = "Les données n'ont pas pu être mise à jour car elles ont été modifiés avant votre mise à jour", + }; + return StatusCode(erreur.Code.Value, erreur); + } + catch (DbUpdateException e) + { + logger.LogError("Une erreur est survenue avec la base de données" + e.Message); + ErreurDTO erreur = new ErreurDTO + { + Code = 500, + Message = "Une erreur est survenue sur le serveur", + }; + return StatusCode(erreur.Code.Value, erreur); + } + catch (Exception e) + { + logger.LogError("Une erreur inconnue est survenue :" + e.Message); + ErreurDTO erreur = new ErreurDTO + { + Code = 500, + Message = "Une erreur incconue est survenue", + }; + return StatusCode(erreur.Code.Value, erreur); + } + return Ok(body); + //catch() { } //TODO: Uncomment the next line to return response 200 or use other options such as return this.NotFound(), return this.BadRequest(..), ... // return StatusCode(200, default(ReferentEPDTO)); @@ -68,15 +182,8 @@ namespace IO.Swagger.Controllers // return StatusCode(415, default(ErreurDTO)); //TODO: Uncomment the next line to return response 500 or use other options such as return this.NotFound(), return this.BadRequest(..), ... - // return StatusCode(500, default(ErreurDTO)); - string exampleJson = null; - exampleJson = "{\n \"idReferent\" : \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n \"idsCollaborateur\" : [ \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\", \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\" ]\n}"; - - var example = exampleJson != null - ? JsonConvert.DeserializeObject(exampleJson) - : default(ReferentEPDTO); //TODO: Change the data returned - return new ObjectResult(example); - } + // return StatusCode(500, default(ErreurDTO)); + } /// /// @@ -92,7 +199,7 @@ namespace IO.Swagger.Controllers /// Une erreur est survenue sur le serveur [HttpPut] [Route("/api/referentsep/collaborateur/{idCollaborateur}")] - [Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)] + //[Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)] [ValidateModelState] [SwaggerOperation("UpdateReferentCollaborateur")] [SwaggerResponse(statusCode: 200, type: typeof(ReferentEPDTO), description: "OK")] @@ -101,8 +208,99 @@ namespace IO.Swagger.Controllers [SwaggerResponse(statusCode: 404, type: typeof(ErreurDTO), description: "La ressource n'a pas été trouvée")] [SwaggerResponse(statusCode: 415, type: typeof(ErreurDTO), description: "L’opération ne peut pas être effectuée car certaines données sont manquantes")] [SwaggerResponse(statusCode: 500, type: typeof(ErreurDTO), description: "Une erreur est survenue sur le serveur")] - public virtual IActionResult UpdateReferentCollaborateur([FromBody]ReferentEPDTO body, [FromRoute][Required]Guid? idCollaborateur) - { + public virtual async Task UpdateReferentCollaborateur([FromBody]ReferentEPDTO body, [FromRoute][Required]Guid? idCollaborateur) + { + try + { + body = await referentEPService.UpdateReferentCollaborateurAsync(body, idCollaborateur); + } + + catch (CollaborateurIncompatibleException e) + { + ErreurDTO erreur = new ErreurDTO + { + Code = 415, + Message = e.Message, + }; + return StatusCode(erreur.Code.Value, erreur); + } + catch (ApiException e) + { + ErreurDTO erreur = new ErreurDTO + { + Code = 500, + Message = e.Message, + //Message = "Un erreur est survenue lors de la communication avec le serveur distant", + }; + return StatusCode(500, erreur); + } + catch (ReferentIncompatibleException e) + { + ErreurDTO erreur = new ErreurDTO + { + Code = 415, + Message = e.Message, + }; + return StatusCode(erreur.Code.Value, erreur); + } + catch (ReferentNotFoundException e) + { + ErreurDTO erreur = new ErreurDTO + { + Code = 404, + Message = e.Message, + }; + return StatusCode(erreur.Code.Value, erreur); + } + catch (CollaborateurPartiException e) + { + ErreurDTO erreur = new ErreurDTO + { + Code = 4, + Message = e.Message, + }; + return StatusCode(erreur.Code.Value, erreur); + } + catch (CollaborateurNotFoundException e) + { + ErreurDTO erreur = new ErreurDTO + { + Code = 404, + Message = e.Message, + }; + return StatusCode(erreur.Code.Value, erreur); + } + catch (DbUpdateConcurrencyException) + { + ErreurDTO erreur = new ErreurDTO + { + Code = 500, + Message = "Les données n'ont pas pu être mise à jour car elles ont été modifiés avant votre mise à jour", + }; + return StatusCode(erreur.Code.Value, erreur); + } + catch (DbUpdateException e) + { + logger.LogError("Une erreur est survenue avec la base de données" + e.Message); + ErreurDTO erreur = new ErreurDTO + { + Code = 500, + Message = "Une erreur est survenue sur le serveur", + }; + return StatusCode(erreur.Code.Value, erreur); + } + catch (Exception e) + { + logger.LogError("Une erreur inconnue est survenue :" + e.Message); + ErreurDTO erreur = new ErreurDTO + { + Code = 500, + Message = "Une erreur incconue est survenue", + }; + return StatusCode(erreur.Code.Value, erreur); + } + return Ok(body); + //TODO: Uncomment the next line to return response 200 or use other options such as return this.NotFound(), return this.BadRequest(..), ... // return StatusCode(200, default(ReferentEPDTO)); @@ -120,13 +318,6 @@ namespace IO.Swagger.Controllers //TODO: Uncomment the next line to return response 500 or use other options such as return this.NotFound(), return this.BadRequest(..), ... // return StatusCode(500, default(ErreurDTO)); - string exampleJson = null; - exampleJson = "{\n \"idReferent\" : \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n \"idsCollaborateur\" : [ \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\", \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\" ]\n}"; - - var example = exampleJson != null - ? JsonConvert.DeserializeObject(exampleJson) - : default(ReferentEPDTO); //TODO: Change the data returned - return new ObjectResult(example); } } } diff --git a/EPAServeur/IServices/IReferentEPService.cs b/EPAServeur/IServices/IReferentEPService.cs index f228004..aa02997 100644 --- a/EPAServeur/IServices/IReferentEPService.cs +++ b/EPAServeur/IServices/IReferentEPService.cs @@ -10,5 +10,10 @@ namespace EPAServeur.IServices { public interface IReferentEPService { - } + ReferentEPDTO UpdateCollaborateursReferent(ReferentEPDTO body, Guid? idReferent); + Task UpdateCollaborateursReferentAsync(ReferentEPDTO body, Guid? idReferent); + + ReferentEPDTO UpdateReferentCollaborateur(ReferentEPDTO body, Guid? idCollaborateur); + Task UpdateReferentCollaborateurAsync(ReferentEPDTO body, Guid? idCollaborateur); + } } diff --git a/EPAServeur/Services/ReferentEPService.cs b/EPAServeur/Services/ReferentEPService.cs index 830a7a3..fc50043 100644 --- a/EPAServeur/Services/ReferentEPService.cs +++ b/EPAServeur/Services/ReferentEPService.cs @@ -1,6 +1,9 @@ -using EPAServeur.Exceptions; +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; @@ -10,8 +13,341 @@ using System.Threading.Tasks; namespace EPAServeur.Services { - public class ReferentEPService : IReferentEPService + 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 Services Sync + public ReferentEPDTO UpdateCollaborateursReferent(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 = collaborateurApi.ChercherCollabId(idReferent); + + //Vérifier que le référent est valide + CheckReferentValide(referent); + + + IEnumerable collaborateurs = collaborateurApi.ChercherCollab(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.SetReferentEP(body.IdsCollaborateur, idReferent); + + return body; + } + + public ReferentEPDTO UpdateReferentCollaborateur(ReferentEPDTO body, Guid? idCollaborateur) + { + + CheckCollaborateurId(idCollaborateur, body); + + + Collaborateur referent = collaborateurApi.ChercherCollabId(body.IdReferent); + CheckReferentValide(referent); + + Collaborateur collaborateur = collaborateurApi.ChercherCollabId(idCollaborateur); + CheckCollaborateurValide(collaborateur); + + ReferentEP referentEP = context.ReferentEP.Find(idCollaborateur); + if(referentEP == null) + { + referentEP = new ReferentEP + { + IdCollaborateur = idCollaborateur.Value + }; + } + + //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; + context.SaveChanges(); + + if (ancienReferent != null && ancienReferent.HasValue) + { + //notifier l'ancien référent + } + //TODO : Notifier le référent et le collaborateur + + return body; + } + #endregion + + #region Service Async + public async Task 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 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 UpdateReferentCollaborateurAsync(ReferentEPDTO body, Guid? idCollaborateur) + { + CheckCollaborateurId(idCollaborateur, body); + + + 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 + + /// + /// Vérifier que l'id référent en paramètre et celui dans l'objet sont les même + /// + /// Id du référent dans l'url + /// objet contenant l'id du référent + 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"); + } + + + /// + /// Vérifier que le référent existe et qu'il est toujours présent chez Apside + /// + /// Le référent a validé + 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"); + } + + /// + /// Vérfier que l'id du collaborateur en paramtère ete l'id du collaborateur dans la liste des ids sont les même + /// + /// L'id du collaborateur + /// objet contenat l'id du collaborateur + private void CheckCollaborateurId(Guid? idCollaborateur, ReferentEPDTO body) { + if (!body.IdsCollaborateur[0].HasValue || !idCollaborateur.Value.Equals(body.IdsCollaborateur[0].Value)) + { + throw new CollaborateurIncompatibleException("Les données du collaborateur ne correspondent pas"); + } + } + + /// + /// Vérifier que le collaborateur existe est qu'il est toujours présent chez Apside + /// + /// Le collaborateur a validé + private void CheckCollaborateurValide(Collaborateur collaborateur) + { + //Aucune valeur nulle n'a été retrouvée + if (collaborateur == null) + throw new CollaborateurNotFoundException("Le collaborateur n'a pas été retrouvé"); + //Le collaborateur est toujours présent dans l'entreprise + if (collaborateur.DateDepart.HasValue) + throw new CollaborateurPartiException("Le collaborateur récupéré ne travaille plus pour l'entreprise"); + } + + + private void CheckListesCollaborateurs(IEnumerable collaborateurs) + { + foreach(Collaborateur c in collaborateurs) { + //Aucune valeur nulle n'a été retrouvée + CheckCollaborateurValide(c); + } + } + + + private void SetReferentEP(IEnumerable 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 anciensReferentCollaborateurs = new Dictionary(); + + //La liste des nouveaux collaborateurs du référents qui devront être notifiés de leur nouveau référent + List nouveauxCollaborateurs = new List(); + + foreach(Guid? idCollaborateur in idsCollaborateur) { + ReferentEP referentEP = context.ReferentEP.Find(idCollaborateur); + + //Eviter d'avoir un référent qui devient son propre référent + if(idCollaborateur.Value.Equals(idReferent.Value)) + continue; + + //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 + }; + context.ReferentEP.Add(referentEP); + } + 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(referentEP.IdReferent.Value)) + continue; + + //Sauvegarder l'ancien référent et le collaborateur suite au changement + anciensReferentCollaborateurs.Add(idReferent, idCollaborateur); + } + referentEP.IdReferent = idReferent; + } + + context.SaveChanges(); + //ajouter le nouveau collaborateur à la liste des collaborateurs à notifier + nouveauxCollaborateurs.Add(idCollaborateur); + } + + + + //TODO: notifier chaque collaborateur de leur nouveau référent + + //TODO: notifier le référent suite à ses nouveaux collaborateurs + + //TODO: notifer les anciens référents qu'ils ne sont plus référents des leurs collaborateurs + + + } + + #endregion + + #region Methodes privees Async + private async void SetReferentEPAsync(IEnumerable 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 anciensReferentCollaborateurs = new Dictionary(); + + //La liste des nouveaux collaborateurs du référents qui devront être notifiés de leur nouveau référent + List nouveauxCollaborateurs = new List(); + + 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(referentEP.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 + } }