diff --git a/EPAServeur.Tests/Controllers/NoteApiTests.cs b/EPAServeur.Tests/Controllers/NoteApiTests.cs new file mode 100644 index 0000000..a4e5e36 --- /dev/null +++ b/EPAServeur.Tests/Controllers/NoteApiTests.cs @@ -0,0 +1,139 @@ +using EPAServeur.Context; +using EPAServeur.IServices; +using EPAServeur.Services; +using IO.Swagger.ApiCollaborateur; +using IO.Swagger.Controllers; +using IO.Swagger.DTO; +using Microsoft.AspNetCore.Mvc; +using Microsoft.EntityFrameworkCore; +using Microsoft.Extensions.Logging; +using Microsoft.Extensions.Logging.Abstractions; +using NUnit.Framework; +using System; +using System.Collections.Generic; +using System.Text; +using System.Threading.Tasks; + +namespace EPAServeur.Tests.Controllers +{ + [TestFixture] + public class NoteApiTests + { + #region Variables + private EpContext context; + private ICollaborateurApi collaborateurApi; + private ICollaborateurService collaborateurService; + private INoteService noteService; + private ILogger logger; + private Guid? auteur1, collaborateur1; + #endregion + + #region Setup + [SetUp] + public void Setup() + { + // Utilisation d'une base de données en mémoire + var optionBuider = new DbContextOptionsBuilder() + .UseInMemoryDatabase("server_ep_test") + .Options; + + context = new EpContext(optionBuider); + + context.Database.EnsureDeleted(); + context.Database.EnsureCreated(); + context.SaveChanges(); + + // Ajout du jeu de données pour les tests + DataSeeder.AddNotes(context); + + // Détache les entités du context car la base de données InMemory créé des conflits + // entre les clés primaires lors d'un Update ou d'un Insert + foreach (var entity in context.ChangeTracker.Entries()) + { + entity.State = EntityState.Detached; + } + collaborateurApi = new CollaborateurApi(); + collaborateurService = new CollaborateurService(collaborateurApi, context); + noteService = new NoteService(collaborateurApi, collaborateurService, context); + logger = new NullLogger(); + + auteur1 = new Guid("aa36f34c-9041-42f5-9db3-6536fe7f1696"); + collaborateur1 = new Guid("842650db-a548-4472-a3af-4c5fff3c1ab8"); + + } + #endregion + + + #region Tests + //AddNote + [Test] + public async Task AddNote() + { + NotesApiController notesApiController = new NotesApiController(noteService, logger); + CollaborateurDTO collaborateurDTO = await collaborateurService.GetCollaborateurByIdAsync(collaborateur1); + DateTime date = DateTime.Now; + DetailsNoteDTO nouvelleNote = new DetailsNoteDTO() + { + Collaborateur = collaborateurDTO, + DateCreation = date, + DateMiseAjour = date, + IdAuteur = auteur1, + Texte = "Texte nouvelle note", + Titre = "Titre nouvelle note" + }; + + Task task = notesApiController.AddNote(nouvelleNote); + CreatedResult result = task.Result as CreatedResult; + Assert.AreEqual(201, result.StatusCode); + Assert.IsInstanceOf(result.Value); + } + + + //DeleteNote + [Test] + public void SupprimerNote() + { + NotesApiController notesApiController = new NotesApiController(noteService, logger); + Task task = notesApiController.DeleteNote(1); + NoContentResult result = task.Result as NoContentResult; + Assert.AreEqual(204, result.StatusCode); + } + + //GetNoteById + [Test] + public void GetNoteById() + { + NotesApiController notesApiController = new NotesApiController(noteService, logger); + Task task = notesApiController.GetNoteById(1); + OkObjectResult result = task.Result as OkObjectResult; + Assert.AreEqual(200 ,result.StatusCode); + Assert.IsInstanceOf(result.Value); + } + + + //GetNotesAuteur + + + //GetNotesAuteurCount + + //UpdateNote + [Test] + public async Task UpdateNote() + { + NotesApiController notesApiController = new NotesApiController(noteService, logger); + DetailsNoteDTO updatedNote = await noteService.GetNoteByIdAsync(2); + updatedNote.Texte = "Texte mise à jour"; + updatedNote.Titre = "Titre mise à jour"; + + Task task = notesApiController.UpdateNote(updatedNote, 2); + OkObjectResult result = task.Result as OkObjectResult; + Assert.AreEqual(200, result.StatusCode); + Assert.IsInstanceOf(result.Value); + } + #endregion + + + + + } +} diff --git a/EPAServeur.Tests/Controllers/ReferentEPApiTests.cs b/EPAServeur.Tests/Controllers/ReferentEPApiTests.cs new file mode 100644 index 0000000..4f789a5 --- /dev/null +++ b/EPAServeur.Tests/Controllers/ReferentEPApiTests.cs @@ -0,0 +1,97 @@ +using EPAServeur.Context; +using EPAServeur.IServices; +using EPAServeur.Services; +using IO.Swagger.ApiCollaborateur; +using IO.Swagger.Controllers; +using IO.Swagger.DTO; +using Microsoft.AspNetCore.Mvc; +using Microsoft.EntityFrameworkCore; +using Microsoft.Extensions.Logging.Abstractions; +using NUnit.Framework; +using System; +using System.Collections.Generic; +using System.Text; +using System.Threading.Tasks; + +namespace EPAServeur.Tests.Controllers +{ + [TestFixture] + public class ReferentEPApiTests + { + #region Variables + private EpContext context; + private ICollaborateurApi collaborateurApi; + private IReferentEPService referentEPService; + private Guid? referent, collaborateur1, collaborateur2, collaborateur3; + #endregion + + #region SetUp + [SetUp] + public void SetUp() + { + // Utilisation d'une base de données en mémoire + var optionBuider = new DbContextOptionsBuilder() + .UseInMemoryDatabase("server_ep_test") + .Options; + + context = new EpContext(optionBuider); + + context.Database.EnsureDeleted(); + context.Database.EnsureCreated(); + context.SaveChanges(); + + foreach (var entity in context.ChangeTracker.Entries()) + { + entity.State = EntityState.Detached; + } + collaborateurApi = new CollaborateurApi(); + referentEPService = new ReferentEPService(context, collaborateurApi); + + referent = new Guid("aa36f34c-9041-42f5-9db3-6536fe7f1696"); + collaborateur1 = new Guid("301ba7f3-095e-4912-8998-a7c942dc5f23"); + collaborateur2 = new Guid("a43b6f4f-f199-4dd0-93b6-a1cb2c0a0d14"); + collaborateur3 = new Guid("b5254c6c-7caa-435f-a4bb-e0cf92559832"); + } + #endregion + + #region Tests + + [Test] + public void UpdateReferentCollaborateur() + { + ReferentsEPApiController referentsEPApi = new ReferentsEPApiController(referentEPService, new NullLogger()); + ReferentEPDTO referentEPDTO = new ReferentEPDTO() + { + IdReferent = referent, + IdsCollaborateur = new List() + }; + referentEPDTO.IdsCollaborateur.Add(collaborateur1); + Task task = referentsEPApi.UpdateReferentCollaborateur(referentEPDTO, collaborateur1); + OkObjectResult result = task.Result as OkObjectResult; + Assert.AreEqual(200, result.StatusCode); + Assert.IsInstanceOf(result.Value); + } + + public void UpdateCollaborateursReferent() + { + ReferentsEPApiController referentsEPApi = new ReferentsEPApiController(referentEPService, new NullLogger()); + ReferentEPDTO referentEPDTO = new ReferentEPDTO() + { + IdReferent = referent, + IdsCollaborateur = new List() + }; + referentEPDTO.IdsCollaborateur.Add(collaborateur1); + referentEPDTO.IdsCollaborateur.Add(collaborateur2); + referentEPDTO.IdsCollaborateur.Add(collaborateur3); + Task task = referentsEPApi.UpdateCollaborateursReferent(referentEPDTO, referent); + OkObjectResult result = task.Result as OkObjectResult; + Assert.AreEqual(200, result.StatusCode); + Assert.IsInstanceOf(result.Value); + } + + #endregion + + + } + +} diff --git a/EPAServeur.Tests/Services/CollaborateurServiceTests.cs b/EPAServeur.Tests/Services/CollaborateurServiceTests.cs new file mode 100644 index 0000000..73b9d1e --- /dev/null +++ b/EPAServeur.Tests/Services/CollaborateurServiceTests.cs @@ -0,0 +1,346 @@ +using EPAServeur.Context; +using EPAServeur.Exceptions; +using EPAServeur.IServices; +using EPAServeur.Services; +using IO.Swagger.ApiCollaborateur; +using IO.Swagger.DTO; +using Microsoft.EntityFrameworkCore; +using NUnit.Framework; +using System; +using System.Linq; +using System.Collections.Generic; +using System.Text; +using System.Threading.Tasks; + +namespace EPAServeur.Tests.Services +{ + [TestFixture] + public class CollaborateurServiceTests + { + #region + private EpContext context; + private ICollaborateurApi collaborateurApi; + #endregion + + #region Setup + [SetUp] + public void Setup() + { + // Utilisation d'une base de données en mémoire + var optionBuider = new DbContextOptionsBuilder() + .UseInMemoryDatabase("server_ep_test") + .Options; + + context = new EpContext(optionBuider); + + context.Database.EnsureDeleted(); + context.Database.EnsureCreated(); + context.SaveChanges(); + + // Ajout du jeu de données pour les tests + DataSeeder.AddNotes(context); + + // Détache les entités du context car la base de données InMemory créé des conflits + // entre les clés primaires lors d'un Update ou d'un Insert + foreach (var entity in context.ChangeTracker.Entries()) + { + entity.State = EntityState.Detached; + } + collaborateurApi = new CollaborateurApi(); + } + #endregion + + #region Tests getCollaborateur + + [TestCase("842650db-a548-4472-a3af-4c5fff3c1ab8")] + [TestCase("301ba7f3-095e-4912-8998-a7c942dc5f23")] + [TestCase("4f3fcd23-a1e4-4c9e-afa2-d06ca9216491")] + public async Task GetCollaborateurById_Ok(Guid? id) + { + ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context); + CollaborateurDTO collaborateurDTO = await collaborateurService.GetCollaborateurByIdAsync(id); + + Assert.IsNotNull(collaborateurDTO); + Assert.AreEqual(collaborateurDTO.Id, id); + } + + [TestCase("creola.nicolas@apside-groupe.com")] + [TestCase("lamar.rousseau@apside-groupe.com")] + [TestCase("coty.lemoine@apside-groupe.com")] + public async Task GetCollaborateurByMail_Ok(string mail) + { + ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context); + CollaborateurDTO collaborateurDTO = await collaborateurService.GetCollaborateurByMailAsync(mail); + + Assert.IsNotNull(collaborateurDTO); + Assert.AreEqual(collaborateurDTO.MailApside, mail); + } + + [TestCase("006226f6-51b2-4a02-a302-7447f7fccc04")] + [TestCase("e5d36da4-df16-4d19-8a11-1ba2f6efc80c")] + [TestCase("92b29b9c-40a4-4aa0-9412-bc97a379e52f")] + public async Task GetCollaborateurById_CollaborateurNotFound(Guid? id) + { + ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context); + + AsyncTestDelegate exception = () => collaborateurService.GetCollaborateurByIdAsync(id); + Assert.ThrowsAsync(typeof(CollaborateurNotFoundException), exception); + } + + [TestCase("nicolas@apside.fr")] + [TestCase("rousseau@apside.fr")] + [TestCase("lemoine@apside.fr")] + public async Task GetCollaborateurByMail_CollaborateurNotFound(string mail) + { + ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context); + AsyncTestDelegate exception = () => collaborateurService.GetCollaborateurByMailAsync(mail); + Assert.ThrowsAsync(typeof(CollaborateurNotFoundException), exception); + } + #endregion + + + #region Tests GetCollaborateurs Roles + + [TestCase("RH")] + [TestCase("Collaborateur")] + [TestCase("Assistant")] + [TestCase("Manager")] + [TestCase("RA")] + public async Task GetCollaborateurs_UnRole(string role) + { + ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context); + + List roles = new List(); + roles.Add(role); + + IEnumerable collaborateurs = await collaborateurService.GetCollaborateursAsync(roles, null, true, 1, 50, "", "", null, null); + int count = await collaborateurService.GetCollaborateursCountAsync(roles, null, "", null, null); + + Assert.AreEqual(count, collaborateurs.Count()); + + switch (role) + { + case "RH": + Assert.AreEqual(count, 9); + break; + case "Collaborateur": + Assert.AreEqual(count, 7); + break; + case "Assistant": + Assert.AreEqual(count, 6); + break; + case "Manager": + Assert.AreEqual(count, 10); + break; + case "RA": + Assert.AreEqual(count, 5); + break; + } + } + + + [Test] + public async Task GetCollaborateurs_RoleRH_RoleAssistant() + { + ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context); + + List roles = new List(); + roles.Add("Assistant"); + roles.Add("RH"); + + IEnumerable collaborateurs = await collaborateurService.GetCollaborateursAsync(roles, null, true, 1, 50, "", "", null, null); + int count = await collaborateurService.GetCollaborateursCountAsync(roles, null, "", null, null); + Assert.AreEqual(count, 15); Assert.AreEqual(count, collaborateurs.Count()); + } + + [Test] + public async Task GetCollaborateurs_RoleRA_RoleManager() + { + ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context); + + List roles = new List(); + roles.Add("Manager"); + roles.Add("RA"); + + IEnumerable collaborateurs = await collaborateurService.GetCollaborateursAsync(roles, null, true, 1, 50, "", "", null, null); + int count = await collaborateurService.GetCollaborateursCountAsync(roles, null, "", null, null); + Assert.AreEqual(count, collaborateurs.Count()); + Assert.AreEqual(count, 15); + } + + #endregion + + #region Test GetCollaborateurs Tri et Pagination + + [Test] + public async Task GetCollaborateurs_Asc_Desc() + { + ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context); + IEnumerable collaborateursAsc = await collaborateurService.GetCollaborateursAsync(null, null, true, 1, 50, "", "", null, null); + IEnumerable collaborateursDesc = await collaborateurService.GetCollaborateursAsync(null, null, false, 1, 50, "", "", null, null); + CollaborateurDTO collaborateurDTOFirstAsc = collaborateursAsc.First(); + CollaborateurDTO collaborateurDTLastAsc = collaborateursAsc.Last(); + CollaborateurDTO collaborateurDTOFirstDesc = collaborateursDesc.First(); + CollaborateurDTO collaborateurDTLastDesc = collaborateursDesc.Last(); + + Assert.AreEqual(collaborateurDTOFirstAsc.Id, collaborateurDTLastDesc.Id); + Assert.AreEqual(collaborateurDTLastAsc.Id, collaborateurDTOFirstDesc.Id); + } + + [TestCase("ma")] + [TestCase("z")] + [TestCase("em")] + [TestCase("")] + public async Task GetCollaborateurs_Texte(string texte) + { + ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context); + IEnumerable collaborateurs = await collaborateurService.GetCollaborateursAsync(null, null, true, 1, 50, texte, "", null, null); + string nomprenom, prenomnom; + foreach(CollaborateurDTO collaborateur in collaborateurs) + { + nomprenom = collaborateur.Nom.ToLower() + " " + collaborateur.Prenom.ToLower(); + prenomnom = collaborateur.Prenom.ToLower() + " " + collaborateur.Nom.ToLower(); + Assert.IsTrue(nomprenom.Contains(texte) || prenomnom.Contains(texte)); + } + } + + [TestCase(2015,1,1)] + [TestCase(2016,1,1)] + [TestCase(2017,1,1)] + [TestCase(2018,1,1)] + public async Task GetCollaborateurs_DateDebut(int annee, int mois, int jour) + { + ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context); + DateTime dateDebut = new DateTime(annee, mois, jour); + IEnumerable collaborateurs = await collaborateurService.GetCollaborateursAsync(null, null, true, 1, 50, "", "", dateDebut, null); + foreach(CollaborateurDTO collaborateur in collaborateurs) + { + Assert.IsTrue(collaborateur.DateArrivee >= dateDebut); + } + } + + [TestCase(2020, 12, 31)] + [TestCase(2019, 12, 31)] + [TestCase(2018, 12, 31)] + [TestCase(2017, 12, 31)] + public async Task GetCollaborateurs_DateFin(int annee, int mois, int jour) + { + ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context); + DateTime dateFin = new DateTime(annee, mois, jour); + IEnumerable collaborateurs = await collaborateurService.GetCollaborateursAsync(null, null, true, 1, 50, "", "", null, dateFin); + foreach (CollaborateurDTO collaborateur in collaborateurs) + { + Assert.IsTrue(collaborateur.DateArrivee < dateFin); + } + } + + + [TestCase(2016,1,1,2018,12,31)] + [TestCase(2017,6,1,2017,6,30)] + [TestCase(2019,1,1,2019,12,31)] + public async Task GetCollaborateurs_DateDebutDateFin(int anneeDeb, int moisDeb, int jourDeb, int anneeFin, int moisFin, int jourFin) + { + ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context); + DateTime dateDebut= new DateTime(anneeDeb, moisDeb, jourDeb); + DateTime dateFin = new DateTime(anneeFin, moisFin, jourFin); + IEnumerable collaborateurs = await collaborateurService.GetCollaborateursAsync(null, null, true, 1, 50, "", "", dateDebut, dateFin); + foreach (CollaborateurDTO collaborateur in collaborateurs) + { + Assert.IsTrue(collaborateur.DateArrivee >= dateDebut && collaborateur.DateArrivee < dateFin); + } + } + + + + [TestCase(1,15)] + [TestCase(4,5)] + [TestCase(2,15)] + [TestCase(1,20)] + [TestCase(1,37)] + public async Task GetCollaborateur_Paginaion(int numPage, int parPage) + { + ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context); + IEnumerable collaborateurs = await collaborateurService.GetCollaborateursAsync(null, null, true, numPage, parPage, "", "", null, null); + Assert.AreEqual(collaborateurs.Count(), parPage); + } + + [TestCase(2, 37, 0)] + [TestCase(3, 15, 7)] + [TestCase(8, 5, 2)] + public async Task GetCollaborateur_Paginaion_2(int numPage, int parPage, int res) + { + ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context); + IEnumerable collaborateurs = await collaborateurService.GetCollaborateursAsync(null, null, true, numPage, parPage, "", "", null, null); + Assert.AreEqual(collaborateurs.Count(), res); + } + + [TestCase(0, 4)] + [TestCase(-1, 0)] + [TestCase(-10, -10)] + [TestCase(-10, 20)] + [TestCase(-1, 37)] + public async Task GetCollaborateur_PaginaionValeursParDefaut(int numPage, int parPage) + { + ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context); + IEnumerable collaborateurs = await collaborateurService.GetCollaborateursAsync(null, null, true, numPage, parPage, "", "", null, null); + + if(parPage < 5) + Assert.AreEqual(collaborateurs.Count(), 15); + else + Assert.AreEqual(collaborateurs.Count(), parPage); + } + + + [Test] + public async Task GetCollaborateur_OrderByDateArrive() + { + ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context); + IEnumerable collaborateurs = await collaborateurService.GetCollaborateursAsync(null, null, true, 1, 30, "", "datearrivee", null, null); + DateTime d1, d2; + for(int i = 0; i < collaborateurs.Count() -1; ++i) + { + d1 = collaborateurs.ElementAt(i).DateArrivee.Value; + d2 = collaborateurs.ElementAt(i+1).DateArrivee.Value; + Assert.AreEqual(DateTime.Compare(d1, d2),-1); + } + + } + + + [Test] + public async Task GetCollaborateur_OrderByBU() + { + ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context); + IEnumerable collaborateurs = await collaborateurService.GetCollaborateursAsync(null, null, true, 1, 30, "", "businessunit", null, null); + string bu1, bu2; + for (int i = 0; i < collaborateurs.Count() - 1; ++i) + { + bu1 = collaborateurs.ElementAt(i).BusinessUnit.Nom; + bu2 = collaborateurs.ElementAt(i + 1).BusinessUnit.Nom; + Console.WriteLine(bu1 + " " + bu2); + Assert.IsTrue(string.Compare(bu1, bu2) <= 0); + } + + } + + + [Test] + public async Task GetCollaborateur_OrderByNom() + { + ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context); + IEnumerable collaborateurs = await collaborateurService.GetCollaborateursAsync(null, null, true, 1, 30, "", "collaborateur", null, null); + string nom1, nom2; + for (int i = 0; i < collaborateurs.Count() - 1; ++i) + { + nom1 = collaborateurs.ElementAt(i).Nom; + nom2 = collaborateurs.ElementAt(i+1).Nom; + Assert.IsTrue(string.Compare(nom1, nom2) <= 0); + } + + } + #endregion + + + + } +} diff --git a/EPAServeur.Tests/Services/NoteServiceTests.cs b/EPAServeur.Tests/Services/NoteServiceTests.cs new file mode 100644 index 0000000..3ae3813 --- /dev/null +++ b/EPAServeur.Tests/Services/NoteServiceTests.cs @@ -0,0 +1,510 @@ +using EPAServeur.Context; +using EPAServeur.Exceptions; +using EPAServeur.IServices; +using EPAServeur.Models.Notes; +using EPAServeur.Services; +using IO.Swagger.ApiCollaborateur; +using IO.Swagger.DTO; +using Microsoft.EntityFrameworkCore; +using NUnit.Framework; +using System; +using System.Collections.Generic; +using System.Text; +using System.Threading.Tasks; + +namespace EPAServeur.Tests.Services +{ + [TestFixture] + public class NoteServiceTests + { + #region Variables + private EpContext context; + private ICollaborateurApi collaborateurApi; + private ICollaborateurService collaborateurService; + private Guid? auteur1, auteur2, auteur3; + private Guid? collaborateur1, collaborateur2, collaborateur3; + private Guid? auteurNonExistant, collaborateurNonExistant, collaborateurParti, referentParti; + #endregion + + #region Setup + [SetUp] + public void Setup() + { + // Utilisation d'une base de données en mémoire + var optionBuider = new DbContextOptionsBuilder() + .UseInMemoryDatabase("server_ep_test") + .Options; + + context = new EpContext(optionBuider); + + context.Database.EnsureDeleted(); + context.Database.EnsureCreated(); + context.SaveChanges(); + + // Ajout du jeu de données pour les tests + DataSeeder.AddNotes(context); + + // Détache les entités du context car la base de données InMemory créé des conflits + // entre les clés primaires lors d'un Update ou d'un Insert + foreach (var entity in context.ChangeTracker.Entries()) + { + entity.State = EntityState.Detached; + } + collaborateurApi = new CollaborateurApi(); + collaborateurService = new CollaborateurService(collaborateurApi, context); + + + auteur1 = new Guid("aa36f34c-9041-42f5-9db3-6536fe7f1696"); + auteur2 = new Guid("01ee85ff-d7f3-494b-b1de-26ced8fbfa0d"); + auteur3 = new Guid("eb8b0f33-f529-4985-861e-1207f3312bb5"); + + collaborateur1 = new Guid("842650db-a548-4472-a3af-4c5fff3c1ab8"); + collaborateur2 = new Guid("b5254c6c-7caa-435f-a4bb-e0cf92559832"); + collaborateur3 = new Guid("de98a866-736f-4295-a669-92a8694e2ee3"); + + auteurNonExistant = collaborateurNonExistant = new Guid("397f616e-44ff-11eb-b378-0242ac130002"); + collaborateurParti = new Guid("13fbe621-1bc9-4f04-afde-b54ca076e239"); + referentParti = new Guid("ea027734-ff0f-4308-8879-133a09fb3c46"); + + } + #endregion + + + #region Test AjouterNote + [Test] + public async Task AjouterNote_Ajouter4NoteAvecSucces() + { + + + // récupérer les collaborateurs liés aux notes + CollaborateurDTO collaborateur1DTO = await collaborateurService.GetCollaborateurByIdAsync(collaborateur1); + CollaborateurDTO collaborateur2DTO = await collaborateurService.GetCollaborateurByIdAsync(collaborateur2); + CollaborateurDTO collaborateur3DTO = await collaborateurService.GetCollaborateurByIdAsync(collaborateur3); + + INoteService noteService = new NoteService(collaborateurApi, collaborateurService, context); + DateTime date = DateTime.Now; + + DetailsNoteDTO noteAjoutee1, noteAjoutee2; + Note noteAjoutee3, noteAjoutee4; + + DetailsNoteDTO nouvelleNote1 = new DetailsNoteDTO() + { + Collaborateur = collaborateur1DTO, + DateCreation = date, + DateMiseAjour = date, + IdAuteur = auteur1, + Texte = "Texte nouvelle note 11", + Titre = "Titre nouvelle note 11" + }; + + noteAjoutee1 = await noteService.AjouterNoteAsync(nouvelleNote1); + + DetailsNoteDTO nouvelleNote2 = new DetailsNoteDTO() + { + Collaborateur = collaborateur2DTO, + DateCreation = date, + DateMiseAjour = date, + IdAuteur = auteur2, + Texte = "Texte nouvelle note 12", + Titre = "Titre nouvelle note 12" + }; + + noteAjoutee2 = await noteService.AjouterNoteAsync(nouvelleNote2); + + DetailsNoteDTO nouvelleNote3 = new DetailsNoteDTO() + { + Collaborateur = collaborateur3DTO, + DateCreation = date, + DateMiseAjour = date, + IdAuteur = auteur3, + Texte = "Texte nouvelle note 13", + Titre = "Titre nouvelle note 13", + }; + + await noteService.AjouterNoteAsync(nouvelleNote3); + noteAjoutee3 = await context.Note.FindAsync((long)13); + + DetailsNoteDTO nouvelleNote4 = new DetailsNoteDTO() + { + Collaborateur = collaborateur3DTO, + DateCreation = date, + DateMiseAjour = date, + IdAuteur = auteur1, + Texte = "Texte nouvelle note 14", + Titre = "Titre nouvelle note 14" + }; + + await noteService.AjouterNoteAsync(nouvelleNote4); + noteAjoutee4 = await context.Note.FindAsync((long)14); + + + //Assert note 1 + Assert.IsNotNull(noteAjoutee1); + Assert.AreEqual(11, noteAjoutee1.Id); + Assert.AreEqual(nouvelleNote1.IdAuteur, noteAjoutee1.IdAuteur); + Assert.AreEqual(nouvelleNote1.DateCreation, noteAjoutee1.DateCreation); + Assert.AreEqual(nouvelleNote1.Collaborateur.Id, noteAjoutee1.Collaborateur.Id); + Assert.AreEqual(nouvelleNote1.Titre, noteAjoutee1.Titre); + Assert.AreEqual(nouvelleNote1.Texte, noteAjoutee1.Texte); + Assert.AreEqual(nouvelleNote1.DateMiseAjour, noteAjoutee1.DateMiseAjour); + Assert.AreEqual(nouvelleNote1.DateCreation, noteAjoutee1.DateCreation); + + + + //Assert note 2 + Assert.IsNotNull(noteAjoutee2); + Assert.AreEqual(12, noteAjoutee2.Id); + Assert.AreEqual(nouvelleNote2.IdAuteur, noteAjoutee2.IdAuteur); + Assert.AreEqual(nouvelleNote2.DateCreation, noteAjoutee2.DateCreation); + Assert.AreEqual(nouvelleNote2.Collaborateur.Id, noteAjoutee2.Collaborateur.Id); + Assert.AreEqual(nouvelleNote2.Titre, noteAjoutee2.Titre); + Assert.AreEqual(nouvelleNote2.Texte, noteAjoutee2.Texte); + Assert.AreEqual(nouvelleNote2.DateMiseAjour, noteAjoutee2.DateMiseAjour); + Assert.AreEqual(nouvelleNote2.DateCreation, noteAjoutee2.DateCreation); + + + //Assert note 3 + Assert.IsNotNull(noteAjoutee3); + Assert.AreEqual(13, noteAjoutee3.IdNote); + Assert.AreEqual(nouvelleNote3.IdAuteur, noteAjoutee3.IdAuteur); + Assert.AreEqual(nouvelleNote3.DateCreation, noteAjoutee3.DateCreation); + Assert.AreEqual(nouvelleNote3.Collaborateur.Id, noteAjoutee3.IdCollaborateur); + Assert.AreEqual(nouvelleNote3.Titre, noteAjoutee3.Titre); + Assert.AreEqual(nouvelleNote3.Texte, noteAjoutee3.Texte); + Assert.AreEqual(nouvelleNote3.DateMiseAjour, noteAjoutee3.DateMiseAJour); + Assert.AreEqual(nouvelleNote3.DateCreation, noteAjoutee3.DateCreation); + + + + //Assert note 4 + Assert.IsNotNull(noteAjoutee4); + Assert.AreEqual(14, noteAjoutee4.IdNote); + Assert.AreEqual(nouvelleNote4.IdAuteur, noteAjoutee4.IdAuteur); + Assert.AreEqual(nouvelleNote4.DateCreation, noteAjoutee4.DateCreation); + Assert.AreEqual(nouvelleNote4.Collaborateur.Id, noteAjoutee4.IdCollaborateur); + Assert.AreEqual(nouvelleNote4.Titre, noteAjoutee4.Titre); + Assert.AreEqual(nouvelleNote4.Texte, noteAjoutee4.Texte); + Assert.AreEqual(nouvelleNote4.DateMiseAjour, noteAjoutee4.DateMiseAJour); + Assert.AreEqual(nouvelleNote4.DateCreation, noteAjoutee4.DateCreation); + + + } + + + [TestCase("", "")] + [TestCase("Titre 2", "")] + [TestCase("", "Texte 3")] + [TestCase("Titre 3", "Te")] + [TestCase("T", "Texte 4")] + [TestCase("T", "T")] + public async Task AjouterNote_NoteInvalideException(string titre, string texte) + { + + + CollaborateurDTO collaborateurDTO = await collaborateurService.GetCollaborateurByIdAsync(collaborateur1); + + INoteService noteService = new NoteService(collaborateurApi, collaborateurService, context); + DateTime date = DateTime.Now; + + DetailsNoteDTO noteAjoutee1 = new DetailsNoteDTO() + { + Collaborateur = collaborateurDTO, + DateCreation = date, + DateMiseAjour = date, + IdAuteur = auteur1, + Texte = texte, + Titre = titre, + }; + + AsyncTestDelegate exception = () => noteService.AjouterNoteAsync(noteAjoutee1); + + Assert.ThrowsAsync(typeof(NoteInvalideException), exception); + } + + [Test] + public async Task AjouterNote_ReferentNotFoundException() + { + CollaborateurDTO collaborateurDTO = await collaborateurService.GetCollaborateurByIdAsync(collaborateur1); + + INoteService noteService = new NoteService(collaborateurApi, collaborateurService, context); + DateTime date = DateTime.Now; + + DetailsNoteDTO note = new DetailsNoteDTO() + { + Collaborateur = collaborateurDTO, + DateCreation = date, + DateMiseAjour = date, + IdAuteur = auteurNonExistant, + Texte = "Texte nouvelle note", + Titre = "Titre nouvelle note" + }; + + AsyncTestDelegate exception = () => noteService.AjouterNoteAsync(note); + Assert.ThrowsAsync(typeof(ReferentNotFoundException), exception); + } + + [Test] + public async Task AjouterNote_CollaborateurNotFoundException() + { + CollaborateurDTO collaborateurDTO = await collaborateurService.GetCollaborateurByIdAsync(collaborateur1); + collaborateurDTO.Id = collaborateurNonExistant; + + INoteService noteService = new NoteService(collaborateurApi, collaborateurService, context); + DateTime date = DateTime.Now; + + DetailsNoteDTO note = new DetailsNoteDTO() + { + Collaborateur = collaborateurDTO, + DateCreation = date, + DateMiseAjour = date, + IdAuteur = auteur1, + Texte = "Texte nouvelle note", + Titre = "Titre nouvelle note" + }; + + AsyncTestDelegate exception = () => noteService.AjouterNoteAsync(note); + Assert.ThrowsAsync(typeof(CollaborateurNotFoundException), exception); + } + + + //[Test] + [Test] + public async Task AjouterNote_CollaborateurPartiException() + { + CollaborateurDTO collaborateurDTO = await collaborateurService.GetCollaborateurByIdAsync(collaborateur1); + CollaborateurDTO collaborateurPartiDTO = await collaborateurService.GetCollaborateurByIdAsync(collaborateurParti); + + INoteService noteService = new NoteService(collaborateurApi, collaborateurService, context); + DateTime date = DateTime.Now; + + + DetailsNoteDTO note1 = new DetailsNoteDTO() + { + Collaborateur = collaborateurDTO, + DateCreation = date, + DateMiseAjour = date, + IdAuteur = referentParti, + Texte = "Texte note 1", + Titre = "Titre note 1" + }; + + AsyncTestDelegate exception1 = () => noteService.AjouterNoteAsync(note1); + + DetailsNoteDTO note2 = new DetailsNoteDTO() + { + Collaborateur = collaborateurPartiDTO, + DateCreation = date, + DateMiseAjour = date, + IdAuteur = auteur2, + Texte = "Texte note 2", + Titre = "Titre note 2" + }; + + AsyncTestDelegate exception2 = () => noteService.AjouterNoteAsync(note2); + + Assert.ThrowsAsync(typeof(CollaborateurPartiException), exception1); + Assert.ThrowsAsync(typeof(CollaborateurPartiException), exception2); + } + + #endregion + + #region Tests GetNoteById + [TestCase(1)] + [TestCase(2)] + [TestCase(4)] + [TestCase(5)] + [TestCase(6)] + [TestCase(9)] + public async Task GetNote_NoteNotNull(long id) + { + INoteService noteService = new NoteService(collaborateurApi, collaborateurService, context); + DetailsNoteDTO detailsNoteDTO = await noteService.GetNoteByIdAsync(id); + + Assert.NotNull(detailsNoteDTO); + Assert.NotNull(detailsNoteDTO.Titre); + Assert.NotNull(detailsNoteDTO.Texte); + Assert.NotNull(detailsNoteDTO.IdAuteur); + Assert.NotNull(detailsNoteDTO.Collaborateur); + Assert.NotNull(detailsNoteDTO.DateCreation); + Assert.NotNull(detailsNoteDTO.DateMiseAjour); + Assert.AreEqual(id, detailsNoteDTO.Id); + + } + + + [TestCase(-999)] + [TestCase(-1)] + [TestCase(0)] + [TestCase(11)] + [TestCase(20)] + [TestCase(30)] + [TestCase(100)] + public void GetNote_NoteNotFoundException(long id) + { + INoteService noteService = new NoteService(collaborateurApi, collaborateurService, context); + AsyncTestDelegate exception = () => noteService.GetNoteByIdAsync(id); + Assert.ThrowsAsync(typeof(NoteNotFoundException), exception); + } + + [TestCase(3)] + [TestCase(7)] + public void GetNote_ReferentNotFoundException(long id) + { + INoteService noteService = new NoteService(collaborateurApi, collaborateurService, context); + AsyncTestDelegate exception = () => noteService.GetNoteByIdAsync(id); + Assert.ThrowsAsync(typeof(ReferentNotFoundException), exception); + } + + [TestCase(8)] + [TestCase(10)] + public void GetNote_CollaborateurNotFoundException(long id) + { + INoteService noteService = new NoteService(collaborateurApi, collaborateurService, context); + AsyncTestDelegate exception = () => noteService.GetNoteByIdAsync(id); + Assert.ThrowsAsync(typeof(CollaborateurNotFoundException), exception); + } + + + + #endregion + + + #region Test Supprimer Note + [TestCase(5)] + [TestCase(7)] + [TestCase(8)] + public async Task SupprimerNote_Succes(long id) + { + INoteService noteService = new NoteService(collaborateurApi, collaborateurService, context); + await noteService.SupprimerNoteAsync(id); + + Note note = await context.Note.FindAsync(id); + + Assert.IsNull(note); + } + + + + [TestCase(0)] + [TestCase(-1)] + [TestCase(-999)] + [TestCase(20)] + [TestCase(30)] + [TestCase(100)] + public void SupprimerNote_NoteNotFoundException(long id) + { + INoteService noteService = new NoteService(collaborateurApi, collaborateurService, context); + AsyncTestDelegate exception = () => noteService.SupprimerNoteAsync(id); + Assert.ThrowsAsync(typeof(NoteNotFoundException), exception); + + } + + #endregion + + + #region Tests UpdateNote + + [TestCase(1)] + [TestCase(2)] + [TestCase(6)] + [TestCase(9)] + public async Task UpdateNote_UpdateTitreEtTexte(long id) + { + INoteService noteService = new NoteService(collaborateurApi, collaborateurService, context); + DetailsNoteDTO note = await noteService.GetNoteByIdAsync(id); + note.Titre = "Titre à jour " + id; + note.Texte= "Texte à jour " + id; + DetailsNoteDTO noteUpdate = await noteService.UpdateNoteAsync(id, note); + + Assert.IsNotNull(noteUpdate); + Assert.AreEqual(note.Id, noteUpdate.Id); + Assert.AreEqual(note.IdAuteur, noteUpdate.IdAuteur); + Assert.AreEqual(note.Collaborateur.Id, noteUpdate.Collaborateur.Id); + Assert.AreEqual(note.DateCreation, noteUpdate.DateCreation); + Assert.AreEqual(note.Titre, noteUpdate.Titre); + Assert.AreEqual(note.Texte, noteUpdate.Texte); + Assert.AreNotEqual(note.DateMiseAjour, noteUpdate.DateMiseAjour); + } + + [TestCase(1)] + [TestCase(2)] + [TestCase(6)] + [TestCase(9)] + public async Task UpdateNote_UpdateTexte(long id) + { + INoteService noteService = new NoteService(collaborateurApi, collaborateurService, context); + DetailsNoteDTO note = await noteService.GetNoteByIdAsync(id); + note.Texte = "Texte à jour " + id; + DetailsNoteDTO noteUpdate = await noteService.UpdateNoteAsync(id, note); + + Assert.IsNotNull(noteUpdate); + Assert.AreEqual(note.Id, noteUpdate.Id); + Assert.AreEqual(note.IdAuteur, noteUpdate.IdAuteur); + Assert.AreEqual(note.Collaborateur.Id, noteUpdate.Collaborateur.Id); + Assert.AreEqual(note.DateCreation, noteUpdate.DateCreation); + Assert.AreEqual(note.Titre, noteUpdate.Titre); + Assert.AreEqual(note.Texte, noteUpdate.Texte); + Assert.AreNotEqual(note.DateMiseAjour, noteUpdate.DateMiseAjour); + } + + [TestCase(1)] + [TestCase(2)] + [TestCase(6)] + [TestCase(9)] + public async Task UpdateNote_UpdateTitre(long id) + { + INoteService noteService = new NoteService(collaborateurApi, collaborateurService, context); + DetailsNoteDTO note = await noteService.GetNoteByIdAsync(id); + note.Titre = "Titre à jour " + id; + DetailsNoteDTO noteUpdate = await noteService.UpdateNoteAsync(id, note); + + Assert.IsNotNull(noteUpdate); + Assert.AreEqual(note.Id, noteUpdate.Id); + Assert.AreEqual(note.IdAuteur, noteUpdate.IdAuteur); + Assert.AreEqual(note.Collaborateur.Id, noteUpdate.Collaborateur.Id); + Assert.AreEqual(note.DateCreation, noteUpdate.DateCreation); + Assert.AreEqual(note.Titre, noteUpdate.Titre); + Assert.AreEqual(note.Texte, noteUpdate.Texte); + Assert.AreNotEqual(note.DateMiseAjour, noteUpdate.DateMiseAjour); + } + + [TestCase(1,2)] + [TestCase(1,3)] + [TestCase(2,4)] + [TestCase(2,5)] + [TestCase(9,6)] + [TestCase(9,7)] + public async Task UpdateNote_NoteIdImcompatibleExceptionId(long id, long mauvaisId) + { + INoteService noteService = new NoteService(collaborateurApi, collaborateurService, context); + DetailsNoteDTO note = await noteService.GetNoteByIdAsync(id); + note.Titre = "Titre à jour " + id; + note.Texte = "Texte à jour " + id; + AsyncTestDelegate exception = () => noteService.UpdateNoteAsync(mauvaisId, note); + Assert.ThrowsAsync(typeof(NoteIdImcompatibleException), exception); + } + + [TestCase(1)] + [TestCase(2)] + [TestCase(6)] + [TestCase(9)] + public async Task UpdateNote_NoteIdImcompatibleExceptionDate(long id) + { + INoteService noteService = new NoteService(collaborateurApi, collaborateurService, context); + DetailsNoteDTO note = await noteService.GetNoteByIdAsync(id); + note.Titre = "Titre à jour " + id; + note.Texte = "Texte à jour " + id; + note.DateCreation = DateTime.Now; + AsyncTestDelegate exception = () => noteService.UpdateNoteAsync(id, note); + Assert.ThrowsAsync(typeof(NoteIdImcompatibleException), exception); + } + + + #endregion + + #region Tests GetNoteByAuteur + #endregion. + + + } +} diff --git a/EPAServeur.Tests/Services/ReferentEPTests.cs b/EPAServeur.Tests/Services/ReferentEPTests.cs new file mode 100644 index 0000000..b59bca1 --- /dev/null +++ b/EPAServeur.Tests/Services/ReferentEPTests.cs @@ -0,0 +1,254 @@ +using EPAServeur.Context; +using EPAServeur.Exceptions; +using EPAServeur.IServices; +using EPAServeur.Models.EP; +using EPAServeur.Services; +using IO.Swagger.ApiCollaborateur; +using IO.Swagger.ClientCollaborateur; +using IO.Swagger.DTO; +using Microsoft.EntityFrameworkCore; +using NUnit.Framework; +using System; +using System.Collections.Generic; +using System.Text; +using System.Threading.Tasks; + +namespace EPAServeur.Tests.Services +{ + [TestFixture] + public class ReferentEPTests + { + #region Variables + private EpContext context; + private ICollaborateurApi collaborateurApi; + private ICollaborateurService collaborateurService; + private Guid? referent1; + private Guid? collaborateur1, collaborateur2, collaborateur3; + private Guid? collaborateurNonExistant, collaborateurParti; + #endregion + + #region SetUp + [SetUp] + public void SetUp() + { + // Utilisation d'une base de données en mémoire + var optionBuider = new DbContextOptionsBuilder() + .UseInMemoryDatabase("server_ep_test") + .Options; + + context = new EpContext(optionBuider); + + + context.Database.EnsureDeleted(); + context.Database.EnsureCreated(); + context.SaveChanges(); + + foreach (var entity in context.ChangeTracker.Entries()) + { + entity.State = EntityState.Detached; + } + collaborateurApi = new CollaborateurApi(); + collaborateurService = new CollaborateurService(collaborateurApi, context); + + + referent1 = new Guid("c"); + + collaborateur1 = new Guid("301ba7f3-095e-4912-8998-a7c942dc5f23"); + collaborateur2 = new Guid("a43b6f4f-f199-4dd0-93b6-a1cb2c0a0d14"); + collaborateur3 = new Guid("b5254c6c-7caa-435f-a4bb-e0cf92559832"); + collaborateurNonExistant = new Guid(); + collaborateurParti = new Guid("ea027734-ff0f-4308-8879-133a09fb3c46"); + + } + #endregion + + #region Ajout pour un collaborateur + + [Test] + public async Task UpdateReferentUnCollaborateur() + { + ReferentEPService referentEPService = new ReferentEPService(context, collaborateurApi); + CollaborateurDTO collaborateurDTO1 = await collaborateurService.GetCollaborateurByIdAsync(collaborateur1); + + ReferentEPDTO referentEPDTO1 = new ReferentEPDTO() + { + IdReferent = referent1, + IdsCollaborateur = new List(), + }; + referentEPDTO1.IdsCollaborateur.Add(collaborateur1); + + + await referentEPService.UpdateReferentCollaborateurAsync(referentEPDTO1, collaborateur1); + + + Assert.IsNotNull(collaborateurDTO1); + Assert.IsNull(collaborateurDTO1.Referent); + + collaborateurDTO1 = await collaborateurService.GetCollaborateurByIdAsync(collaborateur1); + + Assert.IsNotNull(collaborateurDTO1); + Assert.IsNotNull(collaborateurDTO1.Referent); + Assert.AreEqual(collaborateurDTO1.Referent.Id, referent1); + } + + [Test] + public void UpdateReferentCollaborateur_CollaborateurIncompatibleException() + { + ReferentEPService referentEPService = new ReferentEPService(context, collaborateurApi); + ReferentEPDTO referentEPDTO1 = new ReferentEPDTO() + { + IdReferent = referent1, + IdsCollaborateur = new List(), + }; + referentEPDTO1.IdsCollaborateur.Add(collaborateur1); + + ReferentEPDTO referentEPDTO2 = new ReferentEPDTO() + { + IdReferent = referent1, + IdsCollaborateur = new List(), + }; + referentEPDTO2.IdsCollaborateur.Add(null); + + AsyncTestDelegate exception1 = () => referentEPService.UpdateReferentCollaborateurAsync(referentEPDTO1, collaborateur2); + Assert.ThrowsAsync(typeof(CollaborateurIncompatibleException), exception1); + + AsyncTestDelegate exception2 = () => referentEPService.UpdateReferentCollaborateurAsync(referentEPDTO2, null); + Assert.ThrowsAsync(typeof(CollaborateurIncompatibleException), exception2); + } + + [Test] + public void UpdateReferentCollaborateur_ReferentNotFoundException() + { + ReferentEPService referentEPService = new ReferentEPService(context, collaborateurApi); + ReferentEPDTO referentEPDTO = new ReferentEPDTO() + { + IdReferent = collaborateurNonExistant, + IdsCollaborateur = new List(), + }; + referentEPDTO.IdsCollaborateur.Add(collaborateur1); + + AsyncTestDelegate exception = () => referentEPService.UpdateReferentCollaborateurAsync(referentEPDTO, collaborateur1); + Assert.ThrowsAsync(typeof(ReferentNotFoundException), exception); + } + + [Test] + public void UpdateReferentCollaborateur_CollaborateurPartiException() + { + ReferentEPService referentEPService = new ReferentEPService(context, collaborateurApi); + ReferentEPDTO referentEPDTO1 = new ReferentEPDTO() + { + IdReferent = collaborateurParti, + IdsCollaborateur = new List(), + }; + referentEPDTO1.IdsCollaborateur.Add(collaborateur1); + + ReferentEPDTO referentEPDTO2 = new ReferentEPDTO() + { + IdReferent = collaborateurParti, + IdsCollaborateur = new List(), + }; + referentEPDTO2.IdsCollaborateur.Add(collaborateurParti); + + AsyncTestDelegate exception1 = () => referentEPService.UpdateReferentCollaborateurAsync(referentEPDTO1, collaborateur1); + AsyncTestDelegate exception2 = () => referentEPService.UpdateReferentCollaborateurAsync(referentEPDTO2, collaborateurParti); + Assert.ThrowsAsync(typeof(CollaborateurPartiException), exception1); + Assert.ThrowsAsync(typeof(CollaborateurPartiException), exception2); + } + + [Test] + public void UpdateReferentCollaborateur_CollaborateurNotFoundException() + { + ReferentEPService referentEPService = new ReferentEPService(context, collaborateurApi); + ReferentEPDTO referentEPDTO = new ReferentEPDTO() + { + IdReferent = referent1, + IdsCollaborateur = new List(), + }; + referentEPDTO.IdsCollaborateur.Add(collaborateurNonExistant); + + AsyncTestDelegate exception = () => referentEPService.UpdateReferentCollaborateurAsync(referentEPDTO, collaborateurNonExistant); + Assert.ThrowsAsync(typeof(CollaborateurNotFoundException), exception); + } + + [Test] + public void UpdateReferentCollaborateur_ApiException() + { + ReferentEPService referentEPService = new ReferentEPService(context, collaborateurApi); + ReferentEPDTO referentEPDTO = new ReferentEPDTO() + { + IdReferent = null, + IdsCollaborateur = new List(), + }; + referentEPDTO.IdsCollaborateur.Add(collaborateur1); + + + AsyncTestDelegate exception = () => referentEPService.UpdateReferentCollaborateurAsync(referentEPDTO, collaborateur1); + Assert.ThrowsAsync(typeof(ApiException), exception); + } + + + #endregion + + + #region ajout de plusieurs collaborateur + + [Test] + public async Task UpdateCollaborateursReferent() + { + ReferentEPService referentEPService = new ReferentEPService(context, collaborateurApi); + ReferentEPDTO referentEPDTO = new ReferentEPDTO() + { + IdReferent = referent1, + IdsCollaborateur = new List(), + }; + referentEPDTO.IdsCollaborateur.Add(collaborateur1); + referentEPDTO.IdsCollaborateur.Add(collaborateur3); + referentEPDTO.IdsCollaborateur.Add(collaborateur2); + + await referentEPService.UpdateCollaborateursReferentAsync(referentEPDTO, referent1); + + foreach(Guid guid in referentEPDTO.IdsCollaborateur) + { + ReferentEP referentEP = await context.ReferentEP.FindAsync(guid); + Assert.AreEqual(referent1, referentEP.IdReferent); + } + } + + [Test] + public void UpdateCollaborateursReferent_CollaborateurNotFound() + { + ReferentEPService referentEPService = new ReferentEPService(context, collaborateurApi); + ReferentEPDTO referentEPDTO = new ReferentEPDTO() + { + IdReferent = referent1, + IdsCollaborateur = new List(), + }; + referentEPDTO.IdsCollaborateur.Add(collaborateur1); + referentEPDTO.IdsCollaborateur.Add(collaborateur3); + referentEPDTO.IdsCollaborateur.Add(collaborateurNonExistant); + referentEPDTO.IdsCollaborateur.Add(collaborateur2); + + AsyncTestDelegate exception = () => referentEPService.UpdateCollaborateursReferentAsync(referentEPDTO, referent1); + Assert.ThrowsAsync(typeof(CollaborateurNotFoundException), exception); + } + + [Test] + public void UpdateCollaborateursReferent_ReferentNotFound() + { + ReferentEPService referentEPService = new ReferentEPService(context, collaborateurApi); + ReferentEPDTO referentEPDTO = new ReferentEPDTO() + { + IdReferent = collaborateurNonExistant, + IdsCollaborateur = new List(), + }; + referentEPDTO.IdsCollaborateur.Add(collaborateur1); + referentEPDTO.IdsCollaborateur.Add(collaborateur3); + referentEPDTO.IdsCollaborateur.Add(collaborateur2); + + AsyncTestDelegate exception = () => referentEPService.UpdateCollaborateursReferentAsync(referentEPDTO, collaborateurNonExistant); + Assert.ThrowsAsync(typeof(ReferentNotFoundException), exception); + + } + #endregion + } +} diff --git a/EPAServeur/ApiCollaborateur/CollaborateurApi.cs b/EPAServeur/ApiCollaborateur/CollaborateurApi.cs index b26b95c..0766e28 100644 --- a/EPAServeur/ApiCollaborateur/CollaborateurApi.cs +++ b/EPAServeur/ApiCollaborateur/CollaborateurApi.cs @@ -858,7 +858,8 @@ namespace IO.Swagger.ApiCollaborateur localVarPathParams, localVarHttpContentType); int localVarStatusCode = (int) localVarResponse.StatusCode; - + if (localVarStatusCode == 404) + return null; if (ExceptionFactory != null) { Exception exception = ExceptionFactory("AjoutCollab", localVarResponse); @@ -927,7 +928,8 @@ namespace IO.Swagger.ApiCollaborateur localVarPathParams, localVarHttpContentType); int localVarStatusCode = (int) localVarResponse.StatusCode; - + if (localVarStatusCode == 404) + return null; if (ExceptionFactory != null) { Exception exception = ExceptionFactory("AjoutCollab", localVarResponse); @@ -951,6 +953,8 @@ namespace IO.Swagger.ApiCollaborateur public List ChercherCollab (List collabsId = null, bool? ancienCollaborateur = null, List roles = null, List buIds = null) { ApiResponse> localVarResponse = ChercherCollabWithHttpInfo(collabsId, ancienCollaborateur, roles, buIds); + if (localVarResponse == null) + return new List(); return localVarResponse.Data; } @@ -998,7 +1002,8 @@ namespace IO.Swagger.ApiCollaborateur localVarPathParams, localVarHttpContentType); int localVarStatusCode = (int) localVarResponse.StatusCode; - + if (localVarStatusCode == 404) + return null; if (ExceptionFactory != null) { Exception exception = ExceptionFactory("ChercherCollab", localVarResponse); @@ -1022,6 +1027,8 @@ namespace IO.Swagger.ApiCollaborateur public async System.Threading.Tasks.Task> ChercherCollabAsync (List collabsId = null, bool? ancienCollaborateur = null, List roles = null, List buIds = null) { ApiResponse> localVarResponse = await ChercherCollabAsyncWithHttpInfo(collabsId, ancienCollaborateur, roles, buIds); + if (localVarResponse == null) + return new List(); return localVarResponse.Data; } @@ -1070,7 +1077,8 @@ namespace IO.Swagger.ApiCollaborateur localVarPathParams, localVarHttpContentType); int localVarStatusCode = (int) localVarResponse.StatusCode; - + if (localVarStatusCode == 404) + return null; if (ExceptionFactory != null) { Exception exception = ExceptionFactory("ChercherCollab", localVarResponse); @@ -1091,7 +1099,9 @@ namespace IO.Swagger.ApiCollaborateur public List ChercherCollabAgence (long? agenceId, List roles = null) { ApiResponse> localVarResponse = ChercherCollabAgenceWithHttpInfo(agenceId, roles); - return localVarResponse.Data; + if (localVarResponse == null) + return new List(); + return localVarResponse.Data; } /// @@ -1137,7 +1147,8 @@ namespace IO.Swagger.ApiCollaborateur localVarPathParams, localVarHttpContentType); int localVarStatusCode = (int) localVarResponse.StatusCode; - + if (localVarStatusCode == 404) + return null; if (ExceptionFactory != null) { Exception exception = ExceptionFactory("ChercherCollabAgence", localVarResponse); @@ -1159,6 +1170,8 @@ namespace IO.Swagger.ApiCollaborateur public async System.Threading.Tasks.Task> ChercherCollabAgenceAsync (long? agenceId, List roles = null) { ApiResponse> localVarResponse = await ChercherCollabAgenceAsyncWithHttpInfo(agenceId, roles); + if (localVarResponse == null) + return new List(); return localVarResponse.Data; } @@ -1206,7 +1219,8 @@ namespace IO.Swagger.ApiCollaborateur localVarPathParams, localVarHttpContentType); int localVarStatusCode = (int) localVarResponse.StatusCode; - + if (localVarStatusCode == 404) + return null; if (ExceptionFactory != null) { Exception exception = ExceptionFactory("ChercherCollabAgence", localVarResponse); @@ -1228,6 +1242,8 @@ namespace IO.Swagger.ApiCollaborateur public List ChercherCollabBU (long? buId, List roles = null) { ApiResponse> localVarResponse = ChercherCollabBUWithHttpInfo(buId, roles); + if (localVarResponse == null) + return new List(); return localVarResponse.Data; } @@ -1274,7 +1290,8 @@ namespace IO.Swagger.ApiCollaborateur localVarPathParams, localVarHttpContentType); int localVarStatusCode = (int) localVarResponse.StatusCode; - + if (localVarStatusCode == 404) + return null; if (ExceptionFactory != null) { Exception exception = ExceptionFactory("ChercherCollabBU", localVarResponse); @@ -1296,7 +1313,9 @@ namespace IO.Swagger.ApiCollaborateur public async System.Threading.Tasks.Task> ChercherCollabBUAsync (long? buId, List roles = null) { ApiResponse> localVarResponse = await ChercherCollabBUAsyncWithHttpInfo(buId, roles); - return localVarResponse.Data; + if (localVarResponse == null) + return new List(); + return localVarResponse.Data; } @@ -1343,7 +1362,8 @@ namespace IO.Swagger.ApiCollaborateur localVarPathParams, localVarHttpContentType); int localVarStatusCode = (int) localVarResponse.StatusCode; - + if (localVarStatusCode == 404) + return null; if (ExceptionFactory != null) { Exception exception = ExceptionFactory("ChercherCollabBU", localVarResponse); @@ -1364,6 +1384,8 @@ namespace IO.Swagger.ApiCollaborateur public Collaborateur ChercherCollabId (Guid? collabId) { ApiResponse localVarResponse = ChercherCollabIdWithHttpInfo(collabId); + if (localVarResponse == null) + return null; return localVarResponse.Data; } @@ -1408,7 +1430,8 @@ namespace IO.Swagger.ApiCollaborateur localVarPathParams, localVarHttpContentType); int localVarStatusCode = (int) localVarResponse.StatusCode; - + if (localVarStatusCode == 404) + return null; if (ExceptionFactory != null) { Exception exception = ExceptionFactory("ChercherCollabId", localVarResponse); @@ -1429,7 +1452,9 @@ namespace IO.Swagger.ApiCollaborateur public async System.Threading.Tasks.Task ChercherCollabIdAsync (Guid? collabId) { ApiResponse localVarResponse = await ChercherCollabIdAsyncWithHttpInfo(collabId); - return localVarResponse.Data; + if (localVarResponse == null) + return null; + return localVarResponse.Data; } @@ -1475,12 +1500,13 @@ namespace IO.Swagger.ApiCollaborateur int localVarStatusCode = (int) localVarResponse.StatusCode; + if (localVarStatusCode == 404) + return null; if (ExceptionFactory != null) { Exception exception = ExceptionFactory("ChercherCollabId", localVarResponse); if (exception != null) throw exception; } - return new ApiResponse(localVarStatusCode, localVarResponse.Headers.ToDictionary(x => x.Name, x => string.Join(",", x.Value)), (Collaborateur) this.Configuration.ApiClient.Deserialize(localVarResponse, typeof(Collaborateur))); @@ -1495,7 +1521,9 @@ namespace IO.Swagger.ApiCollaborateur public Collaborateur ChercherCollabMail (string mailApside) { ApiResponse localVarResponse = ChercherCollabMailWithHttpInfo(mailApside); - return localVarResponse.Data; + if (localVarResponse == null) + return null; + return localVarResponse.Data; } /// @@ -1510,7 +1538,7 @@ namespace IO.Swagger.ApiCollaborateur if (mailApside == null) throw new ApiException(400, "Missing required parameter 'mailApside' when calling CollaborateurApi->ChercherCollabMail"); - var localVarPath = "/collaborateurs/{mailApside}"; + var localVarPath = "/collaborateurs/mail/{mailApside}"; var localVarPathParams = new Dictionary(); var localVarQueryParams = new List>(); var localVarHeaderParams = new Dictionary(this.Configuration.DefaultHeader); @@ -1539,7 +1567,8 @@ namespace IO.Swagger.ApiCollaborateur localVarPathParams, localVarHttpContentType); int localVarStatusCode = (int) localVarResponse.StatusCode; - + if (localVarStatusCode == 404) + return null; if (ExceptionFactory != null) { Exception exception = ExceptionFactory("ChercherCollabMail", localVarResponse); @@ -1560,7 +1589,9 @@ namespace IO.Swagger.ApiCollaborateur public async System.Threading.Tasks.Task ChercherCollabMailAsync (string mailApside) { ApiResponse localVarResponse = await ChercherCollabMailAsyncWithHttpInfo(mailApside); - return localVarResponse.Data; + if (localVarResponse == null) + return null; + return localVarResponse.Data; } @@ -1576,7 +1607,7 @@ namespace IO.Swagger.ApiCollaborateur if (mailApside == null) throw new ApiException(400, "Missing required parameter 'mailApside' when calling CollaborateurApi->ChercherCollabMail"); - var localVarPath = "/collaborateurs/{mailApside}"; + var localVarPath = "/collaborateurs/mail/{mailApside}"; var localVarPathParams = new Dictionary(); var localVarQueryParams = new List>(); var localVarHeaderParams = new Dictionary(this.Configuration.DefaultHeader); @@ -1605,7 +1636,8 @@ namespace IO.Swagger.ApiCollaborateur localVarPathParams, localVarHttpContentType); int localVarStatusCode = (int) localVarResponse.StatusCode; - + if (localVarStatusCode == 404) + return null; if (ExceptionFactory != null) { Exception exception = ExceptionFactory("ChercherCollabMail", localVarResponse); @@ -1626,7 +1658,9 @@ namespace IO.Swagger.ApiCollaborateur public List ChercherCollabRef (Guid? refId) { ApiResponse> localVarResponse = ChercherCollabRefWithHttpInfo(refId); - return localVarResponse.Data; + if (localVarResponse == null) + return new List(); + return localVarResponse.Data; } /// @@ -1670,7 +1704,8 @@ namespace IO.Swagger.ApiCollaborateur localVarPathParams, localVarHttpContentType); int localVarStatusCode = (int) localVarResponse.StatusCode; - + if (localVarStatusCode == 404) + return null; if (ExceptionFactory != null) { Exception exception = ExceptionFactory("ChercherCollabRef", localVarResponse); @@ -1691,7 +1726,9 @@ namespace IO.Swagger.ApiCollaborateur public async System.Threading.Tasks.Task> ChercherCollabRefAsync (Guid? refId) { ApiResponse> localVarResponse = await ChercherCollabRefAsyncWithHttpInfo(refId); - return localVarResponse.Data; + if (localVarResponse == null) + return new List(); + return localVarResponse.Data; } @@ -1736,7 +1773,8 @@ namespace IO.Swagger.ApiCollaborateur localVarPathParams, localVarHttpContentType); int localVarStatusCode = (int) localVarResponse.StatusCode; - + if (localVarStatusCode == 404) + return null; if (ExceptionFactory != null) { Exception exception = ExceptionFactory("ChercherCollabRef", localVarResponse); @@ -1757,7 +1795,9 @@ namespace IO.Swagger.ApiCollaborateur public Collaborateur ChercherRefActuelId (Guid? collabId) { ApiResponse localVarResponse = ChercherRefActuelIdWithHttpInfo(collabId); - return localVarResponse.Data; + if (localVarResponse == null) + return null; + return localVarResponse.Data; } /// @@ -1801,7 +1841,8 @@ namespace IO.Swagger.ApiCollaborateur localVarPathParams, localVarHttpContentType); int localVarStatusCode = (int) localVarResponse.StatusCode; - + if (localVarStatusCode == 404) + return null; if (ExceptionFactory != null) { Exception exception = ExceptionFactory("ChercherRefActuelId", localVarResponse); @@ -1822,7 +1863,9 @@ namespace IO.Swagger.ApiCollaborateur public async System.Threading.Tasks.Task ChercherRefActuelIdAsync (Guid? collabId) { ApiResponse localVarResponse = await ChercherRefActuelIdAsyncWithHttpInfo(collabId); - return localVarResponse.Data; + if (localVarResponse == null) + return null; + return localVarResponse.Data; } @@ -1867,7 +1910,8 @@ namespace IO.Swagger.ApiCollaborateur localVarPathParams, localVarHttpContentType); int localVarStatusCode = (int) localVarResponse.StatusCode; - + if (localVarStatusCode == 404) + return null; if (ExceptionFactory != null) { Exception exception = ExceptionFactory("ChercherRefActuelId", localVarResponse); @@ -1888,7 +1932,9 @@ namespace IO.Swagger.ApiCollaborateur public Collaborateur ChercherRefActuelMail (string mailApside) { ApiResponse localVarResponse = ChercherRefActuelMailWithHttpInfo(mailApside); - return localVarResponse.Data; + if (localVarResponse == null) + return null; + return localVarResponse.Data; } /// @@ -1903,7 +1949,7 @@ namespace IO.Swagger.ApiCollaborateur if (mailApside == null) throw new ApiException(400, "Missing required parameter 'mailApside' when calling CollaborateurApi->ChercherRefActuelMail"); - var localVarPath = "/collaborateurs/{mailApside}/referent"; + var localVarPath = "/collaborateurs/mail/{mailApside}/referent"; var localVarPathParams = new Dictionary(); var localVarQueryParams = new List>(); var localVarHeaderParams = new Dictionary(this.Configuration.DefaultHeader); @@ -1932,7 +1978,8 @@ namespace IO.Swagger.ApiCollaborateur localVarPathParams, localVarHttpContentType); int localVarStatusCode = (int) localVarResponse.StatusCode; - + if (localVarStatusCode == 404) + return null; if (ExceptionFactory != null) { Exception exception = ExceptionFactory("ChercherRefActuelMail", localVarResponse); @@ -1953,7 +2000,9 @@ namespace IO.Swagger.ApiCollaborateur public async System.Threading.Tasks.Task ChercherRefActuelMailAsync (string mailApside) { ApiResponse localVarResponse = await ChercherRefActuelMailAsyncWithHttpInfo(mailApside); - return localVarResponse.Data; + if (localVarResponse == null) + return null; + return localVarResponse.Data; } @@ -1969,7 +2018,7 @@ namespace IO.Swagger.ApiCollaborateur if (mailApside == null) throw new ApiException(400, "Missing required parameter 'mailApside' when calling CollaborateurApi->ChercherRefActuelMail"); - var localVarPath = "/collaborateurs/{mailApside}/referent"; + var localVarPath = "/collaborateurs/mail/{mailApside}/referent"; var localVarPathParams = new Dictionary(); var localVarQueryParams = new List>(); var localVarHeaderParams = new Dictionary(this.Configuration.DefaultHeader); @@ -1998,7 +2047,8 @@ namespace IO.Swagger.ApiCollaborateur localVarPathParams, localVarHttpContentType); int localVarStatusCode = (int) localVarResponse.StatusCode; - + if (localVarStatusCode == 404) + return null; if (ExceptionFactory != null) { Exception exception = ExceptionFactory("ChercherRefActuelMail", localVarResponse); @@ -2019,7 +2069,9 @@ namespace IO.Swagger.ApiCollaborateur public List ChercherRefCollabId (Guid? collabId) { ApiResponse> localVarResponse = ChercherRefCollabIdWithHttpInfo(collabId); - return localVarResponse.Data; + if (localVarResponse == null) + return new List(); + return localVarResponse.Data; } /// @@ -2063,7 +2115,8 @@ namespace IO.Swagger.ApiCollaborateur localVarPathParams, localVarHttpContentType); int localVarStatusCode = (int) localVarResponse.StatusCode; - + if (localVarStatusCode == 404) + return null; if (ExceptionFactory != null) { Exception exception = ExceptionFactory("ChercherRefCollabId", localVarResponse); @@ -2084,7 +2137,9 @@ namespace IO.Swagger.ApiCollaborateur public async System.Threading.Tasks.Task> ChercherRefCollabIdAsync (Guid? collabId) { ApiResponse> localVarResponse = await ChercherRefCollabIdAsyncWithHttpInfo(collabId); - return localVarResponse.Data; + if (localVarResponse == null) + return new List(); + return localVarResponse.Data; } @@ -2129,7 +2184,8 @@ namespace IO.Swagger.ApiCollaborateur localVarPathParams, localVarHttpContentType); int localVarStatusCode = (int) localVarResponse.StatusCode; - + if (localVarStatusCode == 404) + return null; if (ExceptionFactory != null) { Exception exception = ExceptionFactory("ChercherRefCollabId", localVarResponse); @@ -2150,7 +2206,9 @@ namespace IO.Swagger.ApiCollaborateur public List ChercherRefCollabMail (string mailApside) { ApiResponse> localVarResponse = ChercherRefCollabMailWithHttpInfo(mailApside); - return localVarResponse.Data; + if (localVarResponse == null) + return new List(); + return localVarResponse.Data; } /// @@ -2165,7 +2223,7 @@ namespace IO.Swagger.ApiCollaborateur if (mailApside == null) throw new ApiException(400, "Missing required parameter 'mailApside' when calling CollaborateurApi->ChercherRefCollabMail"); - var localVarPath = "/collaborateurs/{mailApside}/referents"; + var localVarPath = "/collaborateurs/mail/{mailApside}/referents"; var localVarPathParams = new Dictionary(); var localVarQueryParams = new List>(); var localVarHeaderParams = new Dictionary(this.Configuration.DefaultHeader); @@ -2194,7 +2252,8 @@ namespace IO.Swagger.ApiCollaborateur localVarPathParams, localVarHttpContentType); int localVarStatusCode = (int) localVarResponse.StatusCode; - + if (localVarStatusCode == 404) + return null; if (ExceptionFactory != null) { Exception exception = ExceptionFactory("ChercherRefCollabMail", localVarResponse); @@ -2215,7 +2274,9 @@ namespace IO.Swagger.ApiCollaborateur public async System.Threading.Tasks.Task> ChercherRefCollabMailAsync (string mailApside) { ApiResponse> localVarResponse = await ChercherRefCollabMailAsyncWithHttpInfo(mailApside); - return localVarResponse.Data; + if (localVarResponse == null) + return new List(); + return localVarResponse.Data; } @@ -2231,7 +2292,7 @@ namespace IO.Swagger.ApiCollaborateur if (mailApside == null) throw new ApiException(400, "Missing required parameter 'mailApside' when calling CollaborateurApi->ChercherRefCollabMail"); - var localVarPath = "/collaborateurs/{mailApside}/referents"; + var localVarPath = "/collaborateurs/mail/{mailApside}/referents"; var localVarPathParams = new Dictionary(); var localVarQueryParams = new List>(); var localVarHeaderParams = new Dictionary(this.Configuration.DefaultHeader); @@ -2260,7 +2321,8 @@ namespace IO.Swagger.ApiCollaborateur localVarPathParams, localVarHttpContentType); int localVarStatusCode = (int) localVarResponse.StatusCode; - + if (localVarStatusCode == 404) + return null; if (ExceptionFactory != null) { Exception exception = ExceptionFactory("ChercherRefCollabMail", localVarResponse); @@ -2334,7 +2396,8 @@ namespace IO.Swagger.ApiCollaborateur localVarPathParams, localVarHttpContentType); int localVarStatusCode = (int) localVarResponse.StatusCode; - + if (localVarStatusCode == 404) + return null; if (ExceptionFactory != null) { Exception exception = ExceptionFactory("MajCollab", localVarResponse); @@ -2409,7 +2472,8 @@ namespace IO.Swagger.ApiCollaborateur localVarPathParams, localVarHttpContentType); int localVarStatusCode = (int) localVarResponse.StatusCode; - + if (localVarStatusCode == 404) + return null; if (ExceptionFactory != null) { Exception exception = ExceptionFactory("MajCollab", localVarResponse); @@ -2446,7 +2510,7 @@ namespace IO.Swagger.ApiCollaborateur if (mailApside == null) throw new ApiException(400, "Missing required parameter 'mailApside' when calling CollaborateurApi->MajCollabMail"); - var localVarPath = "/collaborateurs/{mailApside}"; + var localVarPath = "/collaborateurs/mail/{mailApside}"; var localVarPathParams = new Dictionary(); var localVarQueryParams = new List>(); var localVarHeaderParams = new Dictionary(this.Configuration.DefaultHeader); @@ -2483,7 +2547,8 @@ namespace IO.Swagger.ApiCollaborateur localVarPathParams, localVarHttpContentType); int localVarStatusCode = (int) localVarResponse.StatusCode; - + if (localVarStatusCode == 404) + return null; if (ExceptionFactory != null) { Exception exception = ExceptionFactory("MajCollabMail", localVarResponse); @@ -2521,7 +2586,7 @@ namespace IO.Swagger.ApiCollaborateur if (mailApside == null) throw new ApiException(400, "Missing required parameter 'mailApside' when calling CollaborateurApi->MajCollabMail"); - var localVarPath = "/collaborateurs/{mailApside}"; + var localVarPath = "/collaborateurs/mail/{mailApside}"; var localVarPathParams = new Dictionary(); var localVarQueryParams = new List>(); var localVarHeaderParams = new Dictionary(this.Configuration.DefaultHeader); @@ -2558,7 +2623,8 @@ namespace IO.Swagger.ApiCollaborateur localVarPathParams, localVarHttpContentType); int localVarStatusCode = (int) localVarResponse.StatusCode; - + if (localVarStatusCode == 404) + return null; if (ExceptionFactory != null) { Exception exception = ExceptionFactory("MajCollabMail", localVarResponse); @@ -2632,7 +2698,8 @@ namespace IO.Swagger.ApiCollaborateur localVarPathParams, localVarHttpContentType); int localVarStatusCode = (int) localVarResponse.StatusCode; - + if (localVarStatusCode == 404) + return null; if (ExceptionFactory != null) { Exception exception = ExceptionFactory("MajCollabpatch", localVarResponse); @@ -2707,7 +2774,8 @@ namespace IO.Swagger.ApiCollaborateur localVarPathParams, localVarHttpContentType); int localVarStatusCode = (int) localVarResponse.StatusCode; - + if (localVarStatusCode == 404) + return null; if (ExceptionFactory != null) { Exception exception = ExceptionFactory("MajCollabpatch", localVarResponse); @@ -2744,7 +2812,7 @@ namespace IO.Swagger.ApiCollaborateur if (mailApside == null) throw new ApiException(400, "Missing required parameter 'mailApside' when calling CollaborateurApi->MajCollabpatchMail"); - var localVarPath = "/collaborateurs/{mailApside}"; + var localVarPath = "/collaborateurs/mail/{mailApside}"; var localVarPathParams = new Dictionary(); var localVarQueryParams = new List>(); var localVarHeaderParams = new Dictionary(this.Configuration.DefaultHeader); @@ -2781,7 +2849,8 @@ namespace IO.Swagger.ApiCollaborateur localVarPathParams, localVarHttpContentType); int localVarStatusCode = (int) localVarResponse.StatusCode; - + if (localVarStatusCode == 404) + return null; if (ExceptionFactory != null) { Exception exception = ExceptionFactory("MajCollabpatchMail", localVarResponse); @@ -2819,7 +2888,7 @@ namespace IO.Swagger.ApiCollaborateur if (mailApside == null) throw new ApiException(400, "Missing required parameter 'mailApside' when calling CollaborateurApi->MajCollabpatchMail"); - var localVarPath = "/collaborateurs/{mailApside}"; + var localVarPath = "/collaborateurs/mail/{mailApside}"; var localVarPathParams = new Dictionary(); var localVarQueryParams = new List>(); var localVarHeaderParams = new Dictionary(this.Configuration.DefaultHeader); @@ -2856,7 +2925,8 @@ namespace IO.Swagger.ApiCollaborateur localVarPathParams, localVarHttpContentType); int localVarStatusCode = (int) localVarResponse.StatusCode; - + if (localVarStatusCode == 404) + return null; if (ExceptionFactory != null) { Exception exception = ExceptionFactory("MajCollabpatchMail", localVarResponse); diff --git a/EPAServeur/Context/DataSeeder.cs b/EPAServeur/Context/DataSeeder.cs index f76d731..b041022 100644 --- a/EPAServeur/Context/DataSeeder.cs +++ b/EPAServeur/Context/DataSeeder.cs @@ -143,7 +143,7 @@ namespace EPAServeur.Context ep3 = new Ep { - IdCollaborateur = Guid.Parse("006226f6-51b2-4a02-a302-7447f7fccc04"), + IdCollaborateur = Guid.Parse("17b87130-0e9d-4b78-b0e3-a11e5f70318d"), IdReferent = Guid.Parse("ecf528c3-e509-402f-87bb-c8821467e350"), IdBu = 2, Fonction = "Dev", @@ -161,7 +161,7 @@ namespace EPAServeur.Context ep4 = new Ep { IdCollaborateur = Guid.Parse("f960f851-16b6-4631-952e-d05f38d8d80f"), - IdReferent = Guid.Parse("6aa62dcb-f7c9-4c0c-af40-e934a4d6a7eb"), + IdReferent = Guid.Parse("01ee85ff-d7f3-494b-b1de-26ced8fbfa0d"), IdBu = 2, Fonction = "Dev", TypeEP = TypeEp.EPA, @@ -1290,8 +1290,8 @@ namespace EPAServeur.Context IdNote = 1, Titre = "Titre1", Texte = "Texte1", - IdAuteur = new Guid("ecf528c3-e509-402f-87bb-c8821467e350"), - IdCollaborateur = new Guid("779bf1cf-4d38-48fb-8550-3d583384523b"), + IdAuteur = new Guid("aa36f34c-9041-42f5-9db3-6536fe7f1696"), + IdCollaborateur = new Guid("842650db-a548-4472-a3af-4c5fff3c1ab8"), DateCreation = DateTime.Now, DateMiseAJour = DateTime.Now @@ -1303,8 +1303,8 @@ namespace EPAServeur.Context IdNote = 2, Titre = "Titre2", Texte = "Texte2", - IdAuteur = new Guid("ecf528c3-e509-402f-87bb-c8821467e350"), - IdCollaborateur = new Guid("779bf1cf-4d38-48fb-8550-3d583384523b"), + IdAuteur = new Guid("aa36f34c-9041-42f5-9db3-6536fe7f1696"), + IdCollaborateur = new Guid("842650db-a548-4472-a3af-4c5fff3c1ab8"), DateCreation = DateTime.Now, DateMiseAJour = DateTime.Now @@ -1316,8 +1316,8 @@ namespace EPAServeur.Context IdNote = 3, Titre = "Titre3", Texte = "Texte3", - IdAuteur = new Guid("ecf528c3-e509-402f-87bb-c8821467e350"), - IdCollaborateur = new Guid("779bf1cf-4d38-48fb-8550-3d583384523b"), + IdAuteur = new Guid(), + IdCollaborateur = new Guid("842650db-a548-4472-a3af-4c5fff3c1ab8"), DateCreation = DateTime.Now, DateMiseAJour = DateTime.Now @@ -1329,8 +1329,8 @@ namespace EPAServeur.Context IdNote = 4, Titre = "Titre4", Texte = "Texte4", - IdAuteur = new Guid("ecf528c3-e509-402f-87bb-c8821467e350"), - IdCollaborateur = new Guid("006226f6-51b2-4a02-a302-7447f7fccc04"), + IdAuteur = new Guid("aa36f34c-9041-42f5-9db3-6536fe7f1696"), + IdCollaborateur = new Guid("17b87130-0e9d-4b78-b0e3-a11e5f70318d"), DateCreation = DateTime.Now, DateMiseAJour = DateTime.Now @@ -1342,8 +1342,8 @@ namespace EPAServeur.Context IdNote = 5, Titre = "Titre5", Texte = "Texte5", - IdAuteur = new Guid("ecf528c3-e509-402f-87bb-c8821467e350"), - IdCollaborateur = new Guid("006226f6-51b2-4a02-a302-7447f7fccc04"), + IdAuteur = new Guid("aa36f34c-9041-42f5-9db3-6536fe7f1696"), + IdCollaborateur = new Guid("17b87130-0e9d-4b78-b0e3-a11e5f70318d"), DateCreation = DateTime.Now, DateMiseAJour = DateTime.Now @@ -1355,8 +1355,8 @@ namespace EPAServeur.Context IdNote = 6, Titre = "Titre6", Texte = "Texte6", - IdAuteur = new Guid("6aa62dcb-f7c9-4c0c-af40-e934a4d6a7eb"), - IdCollaborateur = new Guid("006226f6-51b2-4a02-a302-7447f7fccc04"), + IdAuteur = new Guid("01ee85ff-d7f3-494b-b1de-26ced8fbfa0d"), + IdCollaborateur = new Guid("17b87130-0e9d-4b78-b0e3-a11e5f70318d"), DateCreation = DateTime.Now, DateMiseAJour = DateTime.Now @@ -1368,8 +1368,8 @@ namespace EPAServeur.Context IdNote = 7, Titre = "Titre7", Texte = "Texte7", - IdAuteur = new Guid("6aa62dcb-f7c9-4c0c-af40-e934a4d6a7eb"), - IdCollaborateur = new Guid("006226f6-51b2-4a02-a302-7447f7fccc04"), + IdAuteur = new Guid(), + IdCollaborateur = new Guid("17b87130-0e9d-4b78-b0e3-a11e5f70318d"), DateCreation = DateTime.Now, DateMiseAJour = DateTime.Now @@ -1381,8 +1381,8 @@ namespace EPAServeur.Context IdNote = 8, Titre = "Titre8", Texte = "Texte8", - IdAuteur = new Guid("571463f3-b286-4a21-9eab-0707dc506dec"), - IdCollaborateur = new Guid("006226f6-51b2-4a02-a302-7447f7fccc04"), + IdAuteur = new Guid("01ee85ff-d7f3-494b-b1de-26ced8fbfa0d"), + IdCollaborateur = new Guid(), DateCreation = DateTime.Now, DateMiseAJour = DateTime.Now @@ -1394,8 +1394,8 @@ namespace EPAServeur.Context IdNote = 9, Titre = "Titre9", Texte = "Texte9", - IdAuteur = new Guid("571463f3-b286-4a21-9eab-0707dc506dec"), - IdCollaborateur = new Guid("006226f6-51b2-4a02-a302-7447f7fccc04"), + IdAuteur = new Guid("01ee85ff-d7f3-494b-b1de-26ced8fbfa0d"), + IdCollaborateur = new Guid("17b87130-0e9d-4b78-b0e3-a11e5f70318d"), DateCreation = DateTime.Now, DateMiseAJour = DateTime.Now @@ -1407,8 +1407,8 @@ namespace EPAServeur.Context IdNote = 10, Titre = "Titre10", Texte = "Texte10", - IdAuteur = new Guid("6aa62dcb-f7c9-4c0c-af40-e934a4d6a7eb"), - IdCollaborateur = new Guid("006226f6-51b2-4a02-a302-7447f7fccc04"), + IdAuteur = new Guid("01ee85ff-d7f3-494b-b1de-26ced8fbfa0d"), + IdCollaborateur = new Guid(), DateCreation = DateTime.Now, DateMiseAJour = DateTime.Now @@ -1417,5 +1417,90 @@ namespace EPAServeur.Context epContext.SaveChanges(); } + + + /// + /// Insérer un jeu de données fictif pour les référents EP + /// + /// + public static void AddRereferentEP(EpContext epContext) + { + ReferentEP referentEP; + + referentEP = new ReferentEP() + { + IdCollaborateur = new Guid("842650db-a548-4472-a3af-4c5fff3c1ab8"), + IdReferent = new Guid("aa36f34c-9041-42f5-9db3-6536fe7f1696") + }; + + epContext.ReferentEP.Add(referentEP); + + referentEP = new ReferentEP() + { + IdCollaborateur = new Guid(), + IdReferent = new Guid("aa36f34c-9041-42f5-9db3-6536fe7f1696") + }; + + epContext.ReferentEP.Add(referentEP); + + referentEP = new ReferentEP() + { + IdCollaborateur = new Guid("17b87130-0e9d-4b78-b0e3-a11e5f70318d"), + IdReferent = new Guid("aa36f34c-9041-42f5-9db3-6536fe7f1696") + }; + + epContext.ReferentEP.Add(referentEP); + + referentEP = new ReferentEP() + { + IdCollaborateur = new Guid("4f3fcd23-a1e4-4c9e-afa2-d06ca9216491"), + IdReferent = new Guid("01ee85ff-d7f3-494b-b1de-26ced8fbfa0d") + }; + + epContext.ReferentEP.Add(referentEP); + + referentEP = new ReferentEP() + { + IdCollaborateur = new Guid("0968ccd3-1ef5-4041-83f3-1c76afb02bbf"), + IdReferent = new Guid("01ee85ff-d7f3-494b-b1de-26ced8fbfa0d") + }; + + epContext.ReferentEP.Add(referentEP); + + referentEP = new ReferentEP() + { + IdCollaborateur = new Guid("1429be5b-9125-482c-80c4-c1d34afbd8d2"), + IdReferent = new Guid("e7820f92-eab1-42f5-ae96-5c16e71ff1e6") + }; + + epContext.ReferentEP.Add(referentEP); + + referentEP = new ReferentEP() + { + IdCollaborateur = new Guid("13fbe621-1bc9-4f04-afde-b54ca076e239"), + IdReferent = new Guid("e7820f92-eab1-42f5-ae96-5c16e71ff1e6") + }; + + epContext.ReferentEP.Add(referentEP); + + referentEP = new ReferentEP() + { + IdCollaborateur = new Guid("b5254c6c-7caa-435f-a4bb-e0cf92559832"), + IdReferent = new Guid("de98a866-736f-4295-a669-92a8694e2ee3") + }; + + epContext.ReferentEP.Add(referentEP); + + referentEP = new ReferentEP() + { + IdCollaborateur = new Guid("17b87130-0e9d-4b78-b0e3-a11e5f70318d"), + IdReferent = new Guid("de98a866-736f-4295-a669-92a8694e2ee3") + }; + + epContext.ReferentEP.Add(referentEP); + + epContext.SaveChanges(); + + } } } diff --git a/EPAServeur/Controllers/CollaborateursApi.cs b/EPAServeur/Controllers/CollaborateursApi.cs index 249e93b..b0a5144 100644 --- a/EPAServeur/Controllers/CollaborateursApi.cs +++ b/EPAServeur/Controllers/CollaborateursApi.cs @@ -18,6 +18,11 @@ using IO.Swagger.Attributes; using IO.Swagger.Security; using Microsoft.AspNetCore.Authorization; using IO.Swagger.DTO; +using Microsoft.Extensions.Logging; +using EPAServeur.IServices; +using System.Threading.Tasks; +using IO.Swagger.ClientCollaborateur; +using EPAServeur.Exceptions; namespace IO.Swagger.Controllers { @@ -26,7 +31,22 @@ namespace IO.Swagger.Controllers /// [ApiController] public class CollaborateursApiController : ControllerBase - { + { + + private readonly ICollaborateurService collaborateurService; + private readonly ILogger logger; + private readonly IAuthorizationService authorizationService; + + public CollaborateursApiController(ICollaborateurService _collaborateurService, ILogger _logger, IAuthorizationService _authorizationService) + { + collaborateurService = _collaborateurService; + logger = _logger; + authorizationService = _authorizationService; + } + + + + /// /// /// @@ -39,7 +59,7 @@ namespace IO.Swagger.Controllers /// Une erreur est survenue sur le serveur [HttpGet] [Route("/api/collaborateurs/{idCollaborateur}")] - [Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)] + //[Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)] [ValidateModelState] [SwaggerOperation("GetCollaborateurById")] [SwaggerResponse(statusCode: 200, type: typeof(CollaborateurDTO), description: "OK")] @@ -47,8 +67,64 @@ namespace IO.Swagger.Controllers [SwaggerResponse(statusCode: 403, type: typeof(ErreurDTO), description: "L’utilisateur souhaitant accéder à la ressource n’a pas les droits d’accès suffisants")] [SwaggerResponse(statusCode: 404, type: typeof(ErreurDTO), description: "La ressource n'a pas été trouvée")] [SwaggerResponse(statusCode: 500, type: typeof(ErreurDTO), description: "Une erreur est survenue sur le serveur")] - public virtual IActionResult GetCollaborateurById([FromRoute][Required]Guid? idCollaborateur) - { + public virtual async Task GetCollaborateurById([FromRoute][Required]Guid? idCollaborateur) + { + CollaborateurDTO collaborateurDTO; + try + { + collaborateurDTO = await collaborateurService.GetCollaborateurByIdAsync(idCollaborateur); + } + catch (ApiException e) + { + logger.LogError(e.Message); + ErreurDTO erreur = new ErreurDTO() + { + Code = 500, + Message = "Une erreur est survenue lors de la récupération des données collaborateurs" + }; + return StatusCode(500, erreur); + } + catch (CollaborateurNotFoundException e) + { + ErreurDTO erreurDTO = new ErreurDTO() + { + Code = 404, + Message = e.Message, + }; + return NotFound(erreurDTO); + } + catch (Exception e) + { + logger.LogError(e.Message); + //TODO : vérifier des cas d'erreur possible avant ?... + ErreurDTO erreurDTO = new ErreurDTO() + { + Code = 500, + Message = "Une erreur interne est survenue sur le serveur", + }; + return StatusCode(500, erreurDTO); + } + + // Si l'utilisateur connecté est un collaborateur, on vérifie si il est autorisé à accéder au détail du collaborateur + if (User.IsInRole("Collaborateur")) + { + //Le collaborateur récupère ses informations + if (!(await authorizationService.AuthorizeAsync(User, collaborateurDTO, "SameMailRequirement")).Succeeded) + { + ErreurDTO erreurDTO = new ErreurDTO() + { + Code = 403, + Message = "Accès interdit", + }; + return StatusCode(403, erreurDTO); + } + + //TODO : Le collaborateur récupère les informations d'un collaborateur dont il est référentEP + + //TODO : Le collaborateur récupère les informations d'un collaborateur dont il est référent de l'EP actuel + } + return Ok(collaborateurDTO); + //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(CollaborateurDTO)); @@ -63,13 +139,7 @@ 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 \"businessUnit\" : {\n \"agence\" : {\n \"bu\" : [ null, null ],\n \"id\" : 6,\n \"nom\" : \"nom\"\n },\n \"id\" : 0,\n \"nom\" : \"nom\"\n },\n \"mailApside\" : \"\",\n \"dateArrivee\" : \"2000-01-23T04:56:07.000+00:00\",\n \"id\" : \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n \"dateDepart\" : \"2000-01-23T04:56:07.000+00:00\",\n \"nom\" : \"nom\",\n \"prenom\" : \"prenom\"\n}"; - - var example = exampleJson != null - ? JsonConvert.DeserializeObject(exampleJson) - : default(CollaborateurDTO); //TODO: Change the data returned - return new ObjectResult(example); + } /// @@ -83,8 +153,8 @@ namespace IO.Swagger.Controllers /// La ressource n'a pas été trouvée /// Une erreur est survenue sur le serveur [HttpGet] - [Route("/api/collaborateurs/{mail}")] - [Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)] + [Route("/api/collaborateurs/{mail}/mail")] + //[Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)] [ValidateModelState] [SwaggerOperation("GetCollaborateurByMail")] [SwaggerResponse(statusCode: 200, type: typeof(CollaborateurDTO), description: "OK")] @@ -92,8 +162,65 @@ namespace IO.Swagger.Controllers [SwaggerResponse(statusCode: 403, type: typeof(ErreurDTO), description: "L’utilisateur souhaitant accéder à la ressource n’a pas les droits d’accès suffisants")] [SwaggerResponse(statusCode: 404, type: typeof(ErreurDTO), description: "La ressource n'a pas été trouvée")] [SwaggerResponse(statusCode: 500, type: typeof(ErreurDTO), description: "Une erreur est survenue sur le serveur")] - public virtual IActionResult GetCollaborateurByMail([FromRoute][Required]string mail) - { + public virtual async Task GetCollaborateurByMail([FromRoute][Required]string mail) + { + + CollaborateurDTO collaborateurDTO; + try + { + collaborateurDTO = await collaborateurService.GetCollaborateurByMailAsync(mail); + } + catch (ApiException e) + { + logger.LogError(e.Message); + ErreurDTO erreur = new ErreurDTO() + { + Code = 500, + Message = "Une erreur est survenue lors de la récupération des données collaborateurs" + }; + return StatusCode(500, erreur); + } + catch (CollaborateurNotFoundException e) + { + ErreurDTO erreurDTO = new ErreurDTO() + { + Code = 404, + Message = e.Message, + }; + return NotFound(erreurDTO); + } + catch (Exception e) + { + logger.LogError(e.Message); + //TODO : vérifier des cas d'erreur possible avant ?... + ErreurDTO erreurDTO = new ErreurDTO() + { + Code = 500, + Message = "Une erreur interne est survenue sur le serveur", + }; + return StatusCode(500, erreurDTO); + } + + // Si l'utilisateur connecté est un collaborateur, on vérifie si il est autorisé à accéder au détail du collaborateur + if (User.IsInRole("Collaborateur")) + { + //Le collaborateur récupère ses informations + if (!(await authorizationService.AuthorizeAsync(User, collaborateurDTO, "SameMailRequirement")).Succeeded) + { + ErreurDTO erreurDTO = new ErreurDTO() + { + Code = 403, + Message = "Accès interdit", + }; + return StatusCode(403, erreurDTO); + } + + //TODO : Le collaborateur récupère les informations d'un collaborateur dont il est référentEP + + //TODO : Le collaborateur récupère les informations d'un collaborateur dont il est référent de l'EP actuel + } + + return Ok(collaborateurDTO); //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(CollaborateurDTO)); @@ -108,13 +235,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 \"businessUnit\" : {\n \"agence\" : {\n \"bu\" : [ null, null ],\n \"id\" : 6,\n \"nom\" : \"nom\"\n },\n \"id\" : 0,\n \"nom\" : \"nom\"\n },\n \"mailApside\" : \"\",\n \"dateArrivee\" : \"2000-01-23T04:56:07.000+00:00\",\n \"id\" : \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n \"dateDepart\" : \"2000-01-23T04:56:07.000+00:00\",\n \"nom\" : \"nom\",\n \"prenom\" : \"prenom\"\n}"; - - var example = exampleJson != null - ? JsonConvert.DeserializeObject(exampleJson) - : default(CollaborateurDTO); //TODO: Change the data returned - return new ObjectResult(example); } /// @@ -136,15 +256,41 @@ namespace IO.Swagger.Controllers /// Une erreur est survenue sur le serveur [HttpGet] [Route("/api/collaborateurs")] - [Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)] + //[Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)] [ValidateModelState] [SwaggerOperation("GetCollaborateurs")] [SwaggerResponse(statusCode: 200, type: typeof(List), description: "OK")] [SwaggerResponse(statusCode: 401, type: typeof(ErreurDTO), description: "L'utilisateur souhaitant accéder à la ressource n'est pas authentifié")] [SwaggerResponse(statusCode: 403, type: typeof(ErreurDTO), description: "L’utilisateur souhaitant accéder à la ressource n’a pas les droits d’accès suffisants")] [SwaggerResponse(statusCode: 500, type: typeof(ErreurDTO), description: "Une erreur est survenue sur le serveur")] - public virtual IActionResult GetCollaborateurs([FromQuery]List roles, [FromQuery]List idBUs, [FromQuery]bool? asc, [FromQuery]int? numPage, [FromQuery][Range(5, 100)]int? parPAge, [FromQuery]string texte, [FromQuery]string tri, [FromQuery]DateTime? dateDebut, [FromQuery]DateTime? dateFin) - { + public virtual async Task GetCollaborateurs([FromQuery]List roles, [FromQuery]List idBUs, [FromQuery]bool? asc, [FromQuery]int? numPage, [FromQuery][Range(5, 100)]int? parPAge, [FromQuery]string texte, [FromQuery]string tri, [FromQuery]DateTime? dateDebut, [FromQuery]DateTime? dateFin) + { + IEnumerable collaborateurs; + try + { + collaborateurs = await collaborateurService.GetCollaborateursAsync(roles, idBUs, asc, numPage, parPAge, texte, tri, dateDebut, dateFin); + } + catch (ApiException e) + { + logger.LogError(e.Message); + ErreurDTO erreur = new ErreurDTO() + { + Code = 500, + Message = "Une erreur est survenue lors de la récupération des données collaborateurs" + }; + return StatusCode(500, erreur); + } + catch (Exception e) + { + logger.LogError(e.Message); + ErreurDTO erreurDTO = new ErreurDTO() + { + Code = 500, + Message = "Une erreur interne est survenue", + }; + return StatusCode(500, erreurDTO); + } + return Ok(collaborateurs); //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(List)); @@ -156,13 +302,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 \"businessUnit\" : {\n \"agence\" : {\n \"bu\" : [ null, null ],\n \"id\" : 6,\n \"nom\" : \"nom\"\n },\n \"id\" : 0,\n \"nom\" : \"nom\"\n },\n \"mailApside\" : \"\",\n \"dateArrivee\" : \"2000-01-23T04:56:07.000+00:00\",\n \"id\" : \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n \"dateDepart\" : \"2000-01-23T04:56:07.000+00:00\",\n \"nom\" : \"nom\",\n \"prenom\" : \"prenom\"\n}, {\n \"businessUnit\" : {\n \"agence\" : {\n \"bu\" : [ null, null ],\n \"id\" : 6,\n \"nom\" : \"nom\"\n },\n \"id\" : 0,\n \"nom\" : \"nom\"\n },\n \"mailApside\" : \"\",\n \"dateArrivee\" : \"2000-01-23T04:56:07.000+00:00\",\n \"id\" : \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n \"dateDepart\" : \"2000-01-23T04:56:07.000+00:00\",\n \"nom\" : \"nom\",\n \"prenom\" : \"prenom\"\n} ]"; - - var example = exampleJson != null - ? JsonConvert.DeserializeObject>(exampleJson) - : default(List); //TODO: Change the data returned - return new ObjectResult(example); } /// @@ -182,7 +321,7 @@ namespace IO.Swagger.Controllers /// Une erreur est survenue sur le serveur [HttpGet] [Route("/api/collaborateurs/referent/{idReferent}")] - [Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)] + //[Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)] [ValidateModelState] [SwaggerOperation("GetCollaborateursByReferent")] [SwaggerResponse(statusCode: 200, type: typeof(List), description: "OK")] @@ -190,8 +329,45 @@ namespace IO.Swagger.Controllers [SwaggerResponse(statusCode: 403, type: typeof(ErreurDTO), description: "L’utilisateur souhaitant accéder à la ressource n’a pas les droits d’accès suffisants")] [SwaggerResponse(statusCode: 404, type: typeof(ErreurDTO), description: "La ressource n'a pas été trouvée")] [SwaggerResponse(statusCode: 500, type: typeof(ErreurDTO), description: "Une erreur est survenue sur le serveur")] - public virtual IActionResult GetCollaborateursByReferent([FromRoute][Required]Guid? idReferent, [FromQuery]bool? asc, [FromQuery]int? numPage, [FromQuery][Range(5, 100)]int? parPAge, [FromQuery]string texte, [FromQuery]string tri) - { + public virtual async Task GetCollaborateursByReferent([FromRoute][Required]Guid? idReferent, [FromQuery]bool? asc, [FromQuery]int? numPage, [FromQuery][Range(5, 100)]int? parPAge, [FromQuery]string texte, [FromQuery]string tri) + { + IEnumerable collaborateurs; + try + { + collaborateurs = await collaborateurService.GetCollaborateursByReferentAsync(idReferent, asc, numPage, parPAge, texte, tri); + } + catch (ApiException e) + { + logger.LogError(e.Message); + ErreurDTO erreur = new ErreurDTO() + { + Code = 500, + Message = "Une erreur est survenue lors de la récupération des données collaborateurs" + }; + return StatusCode(500, erreur); + } + catch (ReferentNotFoundException e) + { + ErreurDTO erreurDTO = new ErreurDTO() + { + Code = 404, + Message = e.Message, + }; + return NotFound(erreurDTO); + } + catch (Exception e) + { + logger.LogError(e.Message); + //TODO : vérifier des cas d'erreur possible avant ?... + ErreurDTO erreurDTO = new ErreurDTO() + { + Code = 500, + Message = "Une erreur interne est survenue sur le serveur", + }; + return StatusCode(500, erreurDTO); + } + return Ok(collaborateurs); + //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(List)); @@ -206,13 +382,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 \"businessUnit\" : {\n \"agence\" : {\n \"bu\" : [ null, null ],\n \"id\" : 6,\n \"nom\" : \"nom\"\n },\n \"id\" : 0,\n \"nom\" : \"nom\"\n },\n \"mailApside\" : \"\",\n \"dateArrivee\" : \"2000-01-23T04:56:07.000+00:00\",\n \"id\" : \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n \"dateDepart\" : \"2000-01-23T04:56:07.000+00:00\",\n \"nom\" : \"nom\",\n \"prenom\" : \"prenom\"\n}, {\n \"businessUnit\" : {\n \"agence\" : {\n \"bu\" : [ null, null ],\n \"id\" : 6,\n \"nom\" : \"nom\"\n },\n \"id\" : 0,\n \"nom\" : \"nom\"\n },\n \"mailApside\" : \"\",\n \"dateArrivee\" : \"2000-01-23T04:56:07.000+00:00\",\n \"id\" : \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n \"dateDepart\" : \"2000-01-23T04:56:07.000+00:00\",\n \"nom\" : \"nom\",\n \"prenom\" : \"prenom\"\n} ]"; - - var example = exampleJson != null - ? JsonConvert.DeserializeObject>(exampleJson) - : default(List); //TODO: Change the data returned - return new ObjectResult(example); } /// @@ -231,15 +400,51 @@ namespace IO.Swagger.Controllers /// Une erreur est survenue sur le serveur [HttpGet] [Route("/api/collaborateurs/referent/{idReferent}/count")] - [Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)] + //[Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)] [ValidateModelState] [SwaggerOperation("GetCollaborateursByReferentCount")] [SwaggerResponse(statusCode: 200, type: typeof(long?), description: "OK")] [SwaggerResponse(statusCode: 401, type: typeof(ErreurDTO), description: "L'utilisateur souhaitant accéder à la ressource n'est pas authentifié")] [SwaggerResponse(statusCode: 403, type: typeof(ErreurDTO), description: "L’utilisateur souhaitant accéder à la ressource n’a pas les droits d’accès suffisants")] [SwaggerResponse(statusCode: 500, type: typeof(ErreurDTO), description: "Une erreur est survenue sur le serveur")] - public virtual IActionResult GetCollaborateursByReferentCount([FromRoute][Required]Guid? idReferent, [FromQuery]bool? asc, [FromQuery]int? numPage, [FromQuery][Range(5, 100)]int? parPAge, [FromQuery]string texte, [FromQuery]string tri) - { + public virtual async Task GetCollaborateursByReferentCount([FromRoute][Required]Guid? idReferent, [FromQuery]bool? asc, [FromQuery]int? numPage, [FromQuery][Range(5, 100)]int? parPAge, [FromQuery]string texte, [FromQuery]string tri) + { + int collaborateurs; + try + { + collaborateurs = await collaborateurService.GetCollaborateursCountByReferentAsync(idReferent, texte); + } + catch (ApiException e) + { + logger.LogError(e.Message); + ErreurDTO erreur = new ErreurDTO() + { + Code = 500, + Message = "Une erreur est survenue lors de la récupération des données collaborateurs" + }; + return StatusCode(500, erreur); + } + catch (ReferentNotFoundException e) + { + ErreurDTO erreurDTO = new ErreurDTO() + { + Code = 404, + Message = e.Message, + }; + return NotFound(erreurDTO); + } + catch (Exception e) + { + logger.LogError(e.Message); + //TODO : vérifier des cas d'erreur possible avant ?... + ErreurDTO erreurDTO = new ErreurDTO() + { + Code = 500, + Message = "Une erreur interne est survenue sur le serveur", + }; + return StatusCode(500, erreurDTO); + } + return Ok(collaborateurs); //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(long?)); @@ -251,13 +456,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 = "0"; - - var example = exampleJson != null - ? JsonConvert.DeserializeObject(exampleJson) - : default(long?); //TODO: Change the data returned - return new ObjectResult(example); } /// @@ -279,15 +477,42 @@ namespace IO.Swagger.Controllers /// Une erreur est survenue sur le serveur [HttpGet] [Route("/api/collaborateurs/count")] - [Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)] + //[Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)] [ValidateModelState] [SwaggerOperation("GetCollaborateursCount")] [SwaggerResponse(statusCode: 200, type: typeof(long?), description: "OK")] [SwaggerResponse(statusCode: 401, type: typeof(ErreurDTO), description: "L'utilisateur souhaitant accéder à la ressource n'est pas authentifié")] [SwaggerResponse(statusCode: 403, type: typeof(ErreurDTO), description: "L’utilisateur souhaitant accéder à la ressource n’a pas les droits d’accès suffisants")] [SwaggerResponse(statusCode: 500, type: typeof(ErreurDTO), description: "Une erreur est survenue sur le serveur")] - public virtual IActionResult GetCollaborateursCount([FromQuery]List roles, [FromQuery]List idBUs, [FromQuery]bool? asc, [FromQuery]int? numPage, [FromQuery][Range(5, 100)]int? parPAge, [FromQuery]string texte, [FromQuery]string tri, [FromQuery]DateTime? dateDebut, [FromQuery]DateTime? dateFin) - { + public virtual async Task GetCollaborateursCount([FromQuery]List roles, [FromQuery]List idBUs, [FromQuery]bool? asc, [FromQuery]int? numPage, [FromQuery][Range(5, 100)]int? parPAge, [FromQuery]string texte, [FromQuery]string tri, [FromQuery]DateTime? dateDebut, [FromQuery]DateTime? dateFin) + { + int collaborateurs; + try + { + collaborateurs = await collaborateurService.GetCollaborateursCountAsync(roles, idBUs, texte, dateDebut, dateFin); + } + catch (ApiException e) + { + logger.LogError(e.Message); + ErreurDTO erreur = new ErreurDTO() + { + Code = 500, + Message = "Une erreur est survenue lors de la récupération des données collaborateurs" + }; + return StatusCode(500, erreur); + } + catch (Exception e) + { + logger.LogError(e.Message); + //TODO : vérifier des cas d'erreur possible avant ?... + ErreurDTO erreurDTO = new ErreurDTO() + { + Code = 500, + Message = "Une erreur interne est survenue sur le serveur", + }; + return StatusCode(500, erreurDTO); + } + return Ok(collaborateurs); //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(long?)); @@ -299,13 +524,7 @@ 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 = "0"; - - var example = exampleJson != null - ? JsonConvert.DeserializeObject(exampleJson) - : default(long?); //TODO: Change the data returned - return new ObjectResult(example); + } /// @@ -320,7 +539,7 @@ namespace IO.Swagger.Controllers /// Une erreur est survenue sur le serveur [HttpGet] [Route("/api/collaborateurs/{idCollaborateur}/ep/referents")] - [Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)] + //[Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)] [ValidateModelState] [SwaggerOperation("GetReferentsPrecedentEPCollaborateur")] [SwaggerResponse(statusCode: 200, type: typeof(List), description: "OK")] @@ -328,8 +547,43 @@ namespace IO.Swagger.Controllers [SwaggerResponse(statusCode: 403, type: typeof(ErreurDTO), description: "L’utilisateur souhaitant accéder à la ressource n’a pas les droits d’accès suffisants")] [SwaggerResponse(statusCode: 404, type: typeof(ErreurDTO), description: "La ressource n'a pas été trouvée")] [SwaggerResponse(statusCode: 500, type: typeof(ErreurDTO), description: "Une erreur est survenue sur le serveur")] - public virtual IActionResult GetReferentsPrecedentEPCollaborateur([FromRoute][Required]Guid? idCollaborateur) - { + public virtual async Task GetReferentsPrecedentEPCollaborateur([FromRoute][Required]Guid? idCollaborateur) + { + IEnumerable referents = null; + try + { + referents = await collaborateurService.GetReferentsPrecedentsEPAsync(idCollaborateur); + } + catch (CollaborateurNotFoundException e) { + ErreurDTO erreur = new ErreurDTO() + { + Code = 404, + Message = e.Message + }; + return NotFound(erreur); + } + catch (ApiException e) + { + logger.LogError(e.Message); + ErreurDTO erreur = new ErreurDTO() + { + Code = 500, + Message = "Une erreur est survenue lors de la récupération des données collaborateurs" + }; + return StatusCode(500, erreur); + } + catch (Exception e) + { + logger.LogError(e.Message); + //TODO : vérifier des cas d'erreur possible avant ?... + ErreurDTO erreurDTO = new ErreurDTO() + { + Code = 500, + Message = "Une erreur interne est survenue sur le serveur", + }; + return StatusCode(500, erreurDTO); + } + return Ok(referents); //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(List)); @@ -344,13 +598,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 \"businessUnit\" : {\n \"agence\" : {\n \"bu\" : [ null, null ],\n \"id\" : 6,\n \"nom\" : \"nom\"\n },\n \"id\" : 0,\n \"nom\" : \"nom\"\n },\n \"mailApside\" : \"\",\n \"dateArrivee\" : \"2000-01-23T04:56:07.000+00:00\",\n \"id\" : \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n \"dateDepart\" : \"2000-01-23T04:56:07.000+00:00\",\n \"nom\" : \"nom\",\n \"prenom\" : \"prenom\"\n}, {\n \"businessUnit\" : {\n \"agence\" : {\n \"bu\" : [ null, null ],\n \"id\" : 6,\n \"nom\" : \"nom\"\n },\n \"id\" : 0,\n \"nom\" : \"nom\"\n },\n \"mailApside\" : \"\",\n \"dateArrivee\" : \"2000-01-23T04:56:07.000+00:00\",\n \"id\" : \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n \"dateDepart\" : \"2000-01-23T04:56:07.000+00:00\",\n \"nom\" : \"nom\",\n \"prenom\" : \"prenom\"\n} ]"; - - var example = exampleJson != null - ? JsonConvert.DeserializeObject>(exampleJson) - : default(List); //TODO: Change the data returned - return new ObjectResult(example); } } } diff --git a/EPAServeur/Controllers/NotesApi.cs b/EPAServeur/Controllers/NotesApi.cs index 9e82c2d..5e2fb80 100644 --- a/EPAServeur/Controllers/NotesApi.cs +++ b/EPAServeur/Controllers/NotesApi.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 IO.Swagger.ClientCollaborateur; +using EPAServeur.Exceptions; +using Microsoft.EntityFrameworkCore; +using System.Threading.Tasks; namespace IO.Swagger.Controllers { @@ -26,7 +32,25 @@ namespace IO.Swagger.Controllers /// [ApiController] public class NotesApiController : ControllerBase - { + { + + /// + /// Service des note + /// + private readonly INoteService noteService; + + /// + /// Logger du contrôleur + /// + private readonly ILogger logger; + + public NotesApiController(INoteService _noteService, ILogger _logger) + { + noteService = _noteService; + logger = _logger; + } + + /// /// /// @@ -39,16 +63,87 @@ namespace IO.Swagger.Controllers /// Une erreur est survenue sur le serveur [HttpPost] [Route("/api/notes/")] - [Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)] - [ValidateModelState] + //[Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)] + //[ValidateModelState] [SwaggerOperation("AddNote")] [SwaggerResponse(statusCode: 201, type: typeof(DetailsNoteDTO), description: "Note créée avec succès")] [SwaggerResponse(statusCode: 401, type: typeof(ErreurDTO), description: "L'utilisateur souhaitant accéder à la ressource n'est pas authentifié")] [SwaggerResponse(statusCode: 403, type: typeof(ErreurDTO), description: "L’utilisateur souhaitant accéder à la ressource n’a pas les droits d’accès suffisants")] [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 AddNote([FromBody]DetailsNoteDTO body) + public virtual async Task AddNote([FromBody]DetailsNoteDTO body) { + try + { + body = await noteService.AjouterNoteAsync(body); + } + catch(ApiException e) + { + logger.LogError(e.Message); + ErreurDTO erreur = new ErreurDTO() + { + Code = 500, + Message = "Une erreur est survenue lors de la récupération des données collaborateurs", + }; + return StatusCode(erreur.Code.Value, erreur); + } + catch(NoteInvalideException e) + { + ErreurDTO erreur = new ErreurDTO() + { + Code = 415, + Message = e.Message, + }; + return StatusCode(erreur.Code.Value, erreur.Message); + } + catch(ReferentNotFoundException e) + { + ErreurDTO erreur = new ErreurDTO() + { + Code = 404, + Message = e.Message, + }; + return NotFound(erreur); + } + catch(CollaborateurNotFoundException e) + { + ErreurDTO erreur = new ErreurDTO() + { + Code = 404, + Message = e.Message, + }; + return NotFound(erreur); + } + catch(CollaborateurPartiException e) + { + ErreurDTO erreur = new ErreurDTO() + { + Code = 415, + Message = e.Message, + }; + return StatusCode(erreur.Code.Value,erreur); + } + catch(DbUpdateException e) + { + logger.LogError(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(e.Message); + ErreurDTO erreur = new ErreurDTO + { + Code = 500, + Message = "Une erreur inconnue est survenue sur le serveur", + }; + return StatusCode(erreur.Code.Value, erreur); + } + return Created("",body); //TODO: Uncomment the next line to return response 201 or use other options such as return this.NotFound(), return this.BadRequest(..), ... // return StatusCode(201, default(DetailsNoteDTO)); @@ -63,13 +158,7 @@ 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 \"idAuteur\" : \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n \"dateCreation\" : \"2000-01-23T04:56:07.000+00:00\",\n \"dateMiseAjour\" : \"2000-01-23T04:56:07.000+00:00\",\n \"titre\" : \"titre\",\n \"texte\" : \"texte\",\n \"id\" : 0,\n \"collaborateur\" : {\n \"businessUnit\" : {\n \"agence\" : {\n \"bu\" : [ null, null ],\n \"id\" : 6,\n \"nom\" : \"nom\"\n },\n \"id\" : 0,\n \"nom\" : \"nom\"\n },\n \"mailApside\" : \"\",\n \"dateArrivee\" : \"2000-01-23T04:56:07.000+00:00\",\n \"id\" : \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n \"dateDepart\" : \"2000-01-23T04:56:07.000+00:00\",\n \"nom\" : \"nom\",\n \"prenom\" : \"prenom\"\n }\n}"; - var example = exampleJson != null - ? JsonConvert.DeserializeObject(exampleJson) - : default(DetailsNoteDTO); //TODO: Change the data returned - return new ObjectResult(example); } /// @@ -84,15 +173,49 @@ namespace IO.Swagger.Controllers /// Une erreur est survenue sur le serveur [HttpDelete] [Route("/api/notes/{idNote}")] - [Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)] + //[Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)] [ValidateModelState] [SwaggerOperation("DeleteNote")] [SwaggerResponse(statusCode: 401, type: typeof(ErreurDTO), description: "L'utilisateur souhaitant accéder à la ressource n'est pas authentifié")] [SwaggerResponse(statusCode: 403, type: typeof(ErreurDTO), description: "L’utilisateur souhaitant accéder à la ressource n’a pas les droits d’accès suffisants")] [SwaggerResponse(statusCode: 404, type: typeof(ErreurDTO), description: "La ressource n'a pas été trouvée")] [SwaggerResponse(statusCode: 500, type: typeof(ErreurDTO), description: "Une erreur est survenue sur le serveur")] - public virtual IActionResult DeleteNote([FromRoute][Required]long? idNote) + public virtual async Task DeleteNote([FromRoute][Required]long? idNote) { + try + { + await noteService.SupprimerNoteAsync(idNote); + } + catch(NoteNotFoundException e) + { + ErreurDTO erreur = new ErreurDTO() + { + Code = 404, + Message = e.Message + }; + return NotFound(erreur); + } + catch(DbUpdateException e) + { + logger.LogError(e.Message); + ErreurDTO erreur = new ErreurDTO() + { + Code = 500, + Message = "Une erreur est survenue lors de la suppression" + }; + return StatusCode(erreur.Code.Value, erreur); + } + catch (Exception e) + { + logger.LogError(e.Message); + ErreurDTO erreur = new ErreurDTO() + { + Code = 500, + Message = "Une erreur inconnue est survenue" + }; + return StatusCode(erreur.Code.Value, erreur); + } + return NoContent(); //TODO: Uncomment the next line to return response 204 or use other options such as return this.NotFound(), return this.BadRequest(..), ... // return StatusCode(204); @@ -107,8 +230,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)); - - throw new NotImplementedException(); } /// @@ -123,7 +244,7 @@ namespace IO.Swagger.Controllers /// Une erreur est survenue sur le serveur [HttpGet] [Route("/api/notes/{idNote}")] - [Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)] + //[Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)] [ValidateModelState] [SwaggerOperation("GetNoteById")] [SwaggerResponse(statusCode: 200, type: typeof(DetailsNoteDTO), description: "OK")] @@ -131,8 +252,51 @@ namespace IO.Swagger.Controllers [SwaggerResponse(statusCode: 403, type: typeof(ErreurDTO), description: "L’utilisateur souhaitant accéder à la ressource n’a pas les droits d’accès suffisants")] [SwaggerResponse(statusCode: 404, type: typeof(ErreurDTO), description: "La ressource n'a pas été trouvée")] [SwaggerResponse(statusCode: 500, type: typeof(ErreurDTO), description: "Une erreur est survenue sur le serveur")] - public virtual IActionResult GetNoteById([FromRoute][Required]long? idNote) - { + public virtual async Task GetNoteById([FromRoute][Required]long? idNote) + { + DetailsNoteDTO note; + try + { + note = await noteService.GetNoteByIdAsync(idNote); + } + catch(ReferentNotFoundException e) + { + ErreurDTO erreur = new ErreurDTO() + { + Code = 404, + Message = e.Message, + }; + return NotFound(erreur); + } + catch (CollaborateurNotFoundException e) + { + ErreurDTO erreur = new ErreurDTO() + { + Code = 404, + Message = e.Message, + }; + return NotFound(erreur); + } + catch (NoteNotFoundException e) + { + ErreurDTO erreur = new ErreurDTO() + { + Code = 404, + Message = e.Message, + }; + return NotFound(erreur); + } + catch(Exception e) + { + logger.LogError(e.Message); + ErreurDTO erreur = new ErreurDTO() + { + Code = 500, + Message = "Une erreur inconnue est survenue", + }; + return StatusCode(500, erreur); + } + return Ok(note); //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(DetailsNoteDTO)); @@ -147,13 +311,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 \"idAuteur\" : \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n \"dateCreation\" : \"2000-01-23T04:56:07.000+00:00\",\n \"dateMiseAjour\" : \"2000-01-23T04:56:07.000+00:00\",\n \"titre\" : \"titre\",\n \"texte\" : \"texte\",\n \"id\" : 0,\n \"collaborateur\" : {\n \"businessUnit\" : {\n \"agence\" : {\n \"bu\" : [ null, null ],\n \"id\" : 6,\n \"nom\" : \"nom\"\n },\n \"id\" : 0,\n \"nom\" : \"nom\"\n },\n \"mailApside\" : \"\",\n \"dateArrivee\" : \"2000-01-23T04:56:07.000+00:00\",\n \"id\" : \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n \"dateDepart\" : \"2000-01-23T04:56:07.000+00:00\",\n \"nom\" : \"nom\",\n \"prenom\" : \"prenom\"\n }\n}"; - - var example = exampleJson != null - ? JsonConvert.DeserializeObject(exampleJson) - : default(DetailsNoteDTO); //TODO: Change the data returned - return new ObjectResult(example); } /// @@ -172,8 +329,8 @@ namespace IO.Swagger.Controllers /// La ressource n'a pas été trouvée /// Une erreur est survenue sur le serveur [HttpGet] - [Route("/api/notes/{idAuteur}")] - [Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)] + [Route("/api/notes/auteur/{idAuteur}")] + //[Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)] [ValidateModelState] [SwaggerOperation("GetNotesAuteur")] [SwaggerResponse(statusCode: 200, type: typeof(List), description: "OK")] @@ -181,8 +338,45 @@ namespace IO.Swagger.Controllers [SwaggerResponse(statusCode: 403, type: typeof(ErreurDTO), description: "L’utilisateur souhaitant accéder à la ressource n’a pas les droits d’accès suffisants")] [SwaggerResponse(statusCode: 404, type: typeof(ErreurDTO), description: "La ressource n'a pas été trouvée")] [SwaggerResponse(statusCode: 500, type: typeof(ErreurDTO), description: "Une erreur est survenue sur le serveur")] - public virtual IActionResult GetNotesAuteur([FromRoute][Required]Guid? idAuteur, [FromQuery]bool? asc, [FromQuery]int? numPage, [FromQuery][Range(5, 100)]int? parPAge, [FromQuery]string texte, [FromQuery]string tri) - { + public virtual async Task GetNotesAuteur([FromRoute][Required]Guid? idAuteur, [FromQuery]bool? asc, [FromQuery]int? numPage, [FromQuery][Range(5, 100)]int? parPAge, [FromQuery]string texte, [FromQuery]string tri) + { + IEnumerable affichageNotes; + try + { + affichageNotes = await noteService.GetNotesByAuteurAsync(idAuteur, asc, numPage, parPAge, texte, tri); + //affichageNotes = noteService.GetNotesByAuteur(idAuteur, asc, numPage, parPAge, texte, tri); + } + catch(ReferentNotFoundException e) + { + ErreurDTO erreurDTO = new ErreurDTO() + { + Code = 404, + Message = e.Message, + }; + return NotFound(erreurDTO); + } + catch(ApiException e) + { + logger.LogError(e.Message); + ErreurDTO erreur = new ErreurDTO() + { + Code = 500, + Message = "Une erreur est survenue lors de la récupération des informations collaborateurs", + }; + return StatusCode(erreur.Code.Value, erreur); + } + catch(Exception e) + { + logger.LogError(e.Message); + ErreurDTO erreur = new ErreurDTO() + { + Code = 500, + //Message = "Une erreur inconnue est survenue", + Message = e.StackTrace, + }; + return StatusCode(500, erreur); + } + return Ok(affichageNotes); //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(List)); @@ -197,13 +391,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 \"idCollaborateur\" : \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n \"dateMiseAJour\" : \"2000-01-23T04:56:07.000+00:00\",\n \"titre\" : \"titre\",\n \"id\" : 0,\n \"collaborateur\" : \"collaborateur\"\n}, {\n \"idCollaborateur\" : \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n \"dateMiseAJour\" : \"2000-01-23T04:56:07.000+00:00\",\n \"titre\" : \"titre\",\n \"id\" : 0,\n \"collaborateur\" : \"collaborateur\"\n} ]"; - - var example = exampleJson != null - ? JsonConvert.DeserializeObject>(exampleJson) - : default(List); //TODO: Change the data returned - return new ObjectResult(example); } /// @@ -222,8 +409,8 @@ namespace IO.Swagger.Controllers /// La ressource n'a pas été trouvée /// Une erreur est survenue sur le serveur [HttpGet] - [Route("/api/notes/{idAuteur}/count")] - [Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)] + [Route("/api/notes/auteur/{idAuteur}/count")] + //[Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)] [ValidateModelState] [SwaggerOperation("GetNotesAuteurCount")] [SwaggerResponse(statusCode: 200, type: typeof(long?), description: "OK")] @@ -231,8 +418,43 @@ namespace IO.Swagger.Controllers [SwaggerResponse(statusCode: 403, type: typeof(ErreurDTO), description: "L’utilisateur souhaitant accéder à la ressource n’a pas les droits d’accès suffisants")] [SwaggerResponse(statusCode: 404, type: typeof(ErreurDTO), description: "La ressource n'a pas été trouvée")] [SwaggerResponse(statusCode: 500, type: typeof(ErreurDTO), description: "Une erreur est survenue sur le serveur")] - public virtual IActionResult GetNotesAuteurCount([FromRoute][Required]Guid? idAuteur, [FromQuery]bool? asc, [FromQuery]int? numPage, [FromQuery][Range(5, 100)]int? parPAge, [FromQuery]string texte, [FromQuery]string tri) - { + public virtual async Task GetNotesAuteurCount([FromRoute][Required]Guid? idAuteur, [FromQuery]bool? asc, [FromQuery]int? numPage, [FromQuery][Range(5, 100)]int? parPAge, [FromQuery]string texte, [FromQuery]string tri) + { + int notes; + try + { + notes = await noteService.GetNotesByAuteurCountAsync(idAuteur, texte); + } + catch(ApiException e) + { + logger.LogError(e.Message); + ErreurDTO erreurDTO = new ErreurDTO() + { + Code = 500, + Message = "Une erreur est survenue lors de la récupération des informations collaborateurs", + }; + return StatusCode(500, erreurDTO); + } + catch(ReferentNotFoundException e) + { + ErreurDTO erreurDTO = new ErreurDTO() + { + Code = 404, + Message = e.Message, + }; + return NotFound(erreurDTO); + } + catch(Exception e) + { + logger.LogError(e.Message); + ErreurDTO erreurDTO = new ErreurDTO() + { + Code = 500, + Message = "Une erreur inconnue es survenue sur le serveur", + }; + return StatusCode(500, erreurDTO); + } + return Ok(notes); //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(long?)); @@ -247,13 +469,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 = "0"; - - var example = exampleJson != null - ? JsonConvert.DeserializeObject(exampleJson) - : default(long?); //TODO: Change the data returned - return new ObjectResult(example); } /// @@ -270,7 +485,7 @@ namespace IO.Swagger.Controllers /// Une erreur est survenue sur le serveur [HttpPut] [Route("/api/notes/{idNote}")] - [Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)] + //[Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)] [ValidateModelState] [SwaggerOperation("UpdateNote")] [SwaggerResponse(statusCode: 200, type: typeof(DetailsNoteDTO), description: "Note modifiée avec succès")] @@ -279,8 +494,60 @@ 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 UpdateNote([FromBody]DetailsNoteDTO body, [FromRoute][Required]long? idNote) + public virtual async Task UpdateNote([FromBody]DetailsNoteDTO body, [FromRoute][Required]long? idNote) { + try + { + body = await noteService.UpdateNoteAsync(idNote, body); + } + catch(NoteIdImcompatibleException e) + { + ErreurDTO erreur = new ErreurDTO + { + Code = 415, + Message = e.Message, + }; + return StatusCode(erreur.Code.Value, erreur); + }catch(NoteInvalideException e) + { + ErreurDTO erreur = new ErreurDTO + { + Code = 415, + Message = e.Message, + }; + return StatusCode(erreur.Code.Value, erreur); + } + catch (DbUpdateConcurrencyException e) + { + logger.LogError(e.Message); + ErreurDTO erreur = new ErreurDTO + { + Code = 500, + Message = "Une erreur est survenue sur le serveur", + }; + return StatusCode(erreur.Code.Value, erreur); + } + catch (DbUpdateException e) + { + logger.LogError(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(e.Message); + ErreurDTO erreur = new ErreurDTO + { + Code = 500, + Message = "Une erreur inconnue est survenue sur le serveur", + }; + 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(DetailsNoteDTO)); @@ -298,13 +565,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 \"idAuteur\" : \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n \"dateCreation\" : \"2000-01-23T04:56:07.000+00:00\",\n \"dateMiseAjour\" : \"2000-01-23T04:56:07.000+00:00\",\n \"titre\" : \"titre\",\n \"texte\" : \"texte\",\n \"id\" : 0,\n \"collaborateur\" : {\n \"businessUnit\" : {\n \"agence\" : {\n \"bu\" : [ null, null ],\n \"id\" : 6,\n \"nom\" : \"nom\"\n },\n \"id\" : 0,\n \"nom\" : \"nom\"\n },\n \"mailApside\" : \"\",\n \"dateArrivee\" : \"2000-01-23T04:56:07.000+00:00\",\n \"id\" : \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n \"dateDepart\" : \"2000-01-23T04:56:07.000+00:00\",\n \"nom\" : \"nom\",\n \"prenom\" : \"prenom\"\n }\n}"; - - var example = exampleJson != null - ? JsonConvert.DeserializeObject(exampleJson) - : default(DetailsNoteDTO); //TODO: Change the data returned - return new ObjectResult(example); } } } diff --git a/EPAServeur/Controllers/ReferentsEPApi.cs b/EPAServeur/Controllers/ReferentsEPApi.cs index c885ee9..952f0ad 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(ListeIdsCollaborateursVideException 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/DTO/CollaborateurDTO.cs b/EPAServeur/DTO/CollaborateurDTO.cs index 9bf2e5e..7cc156c 100644 --- a/EPAServeur/DTO/CollaborateurDTO.cs +++ b/EPAServeur/DTO/CollaborateurDTO.cs @@ -222,7 +222,12 @@ namespace IO.Swagger.DTO return !Equals(left, right); } - #pragma warning restore 1591 - #endregion Operators - } + public static implicit operator CollaborateurDTO(Guid? v) + { + throw new NotImplementedException(); + } + +#pragma warning restore 1591 + #endregion Operators + } } diff --git a/EPAServeur/Exceptions/CollaborateurIncompatibleException.cs b/EPAServeur/Exceptions/CollaborateurIncompatibleException.cs new file mode 100644 index 0000000..b14d4bb --- /dev/null +++ b/EPAServeur/Exceptions/CollaborateurIncompatibleException.cs @@ -0,0 +1,47 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Runtime.Serialization; +using System.Threading.Tasks; + +namespace EPAServeur.Exceptions +{ + /// + /// Exception à jeter lorsque l'id d'un objet collaborateur ne correspond pas à l'id collaborateur en paramètre + /// + public class CollaborateurIncompatibleException : Exception + { + /// + /// Initialise une nouvelle instance de la classe class. + /// + public CollaborateurIncompatibleException() + { + } + + /// + /// Initialise une nouvelle instance de la classe class. + /// + /// + public CollaborateurIncompatibleException(string message) : base(message) + { + } + + /// + /// Initialise une nouvelle instance de la classe class. + /// + /// + /// + public CollaborateurIncompatibleException(string message, Exception innerException) : base(message, innerException) + { + } + + /// + /// Initialise une nouvelle instance de la classe class. + /// + /// + /// + protected CollaborateurIncompatibleException(SerializationInfo info, StreamingContext context) : base(info, context) + { + } + } +} diff --git a/EPAServeur/Exceptions/CollaborateurNotFoundException.cs b/EPAServeur/Exceptions/CollaborateurNotFoundException.cs index a753e13..3efd39d 100644 --- a/EPAServeur/Exceptions/CollaborateurNotFoundException.cs +++ b/EPAServeur/Exceptions/CollaborateurNotFoundException.cs @@ -1,6 +1,7 @@ using System; using System.Collections.Generic; using System.Linq; +using System.Runtime.Serialization; using System.Threading.Tasks; namespace EPAServeur.Exceptions @@ -10,5 +11,37 @@ namespace EPAServeur.Exceptions /// public class CollaborateurNotFoundException : Exception { + /// + /// Initialise une nouvelle instance de la classe class. + /// + public CollaborateurNotFoundException() + { + } + + /// + /// Initialise une nouvelle instance de la classe class. + /// + /// + public CollaborateurNotFoundException(string message) : base(message) + { + } + + /// + /// Initialise une nouvelle instance de la classe class. + /// + /// + /// + public CollaborateurNotFoundException(string message, Exception innerException) : base(message, innerException) + { + } + + /// + /// Initialise une nouvelle instance de la classe class. + /// + /// + /// + protected CollaborateurNotFoundException(SerializationInfo info, StreamingContext context) : base(info, context) + { + } } } diff --git a/EPAServeur/Exceptions/CollaborateurPartiException.cs b/EPAServeur/Exceptions/CollaborateurPartiException.cs new file mode 100644 index 0000000..53ded23 --- /dev/null +++ b/EPAServeur/Exceptions/CollaborateurPartiException.cs @@ -0,0 +1,27 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Runtime.Serialization; +using System.Threading.Tasks; + +namespace EPAServeur.Exceptions +{ + public class CollaborateurPartiException : Exception + { + public CollaborateurPartiException() + { + } + + public CollaborateurPartiException(string message) : base(message) + { + } + + public CollaborateurPartiException(string message, Exception innerException) : base(message, innerException) + { + } + + protected CollaborateurPartiException(SerializationInfo info, StreamingContext context) : base(info, context) + { + } + } +} diff --git a/EPAServeur/Exceptions/ListeIdsCollaborateursVideException.cs b/EPAServeur/Exceptions/ListeIdsCollaborateursVideException.cs new file mode 100644 index 0000000..938b9ff --- /dev/null +++ b/EPAServeur/Exceptions/ListeIdsCollaborateursVideException.cs @@ -0,0 +1,47 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Runtime.Serialization; +using System.Threading.Tasks; + +namespace EPAServeur.Exceptions +{ + /// + /// Exception à jeter lorsque la liste des ids collaborateurs à mettre à jour pour le réferent EP est null ou vide + /// + public class ListeIdsCollaborateursVideException : Exception + { + /// + /// Initialise une nouvelle instance de la classe class. + /// + public ListeIdsCollaborateursVideException() + { + } + + /// + /// Initialise une nouvelle instance de la classe class. + /// + /// + public ListeIdsCollaborateursVideException(string message) : base(message) + { + } + + /// + /// Initialise une nouvelle instance de la classe class. + /// + /// + /// + public ListeIdsCollaborateursVideException(string message, Exception innerException) : base(message, innerException) + { + } + + /// + /// Initialise une nouvelle instance de la classe class. + /// + /// + /// + protected ListeIdsCollaborateursVideException(SerializationInfo info, StreamingContext context) : base(info, context) + { + } + } +} diff --git a/EPAServeur/Exceptions/NoteIdImcompatibleException.cs b/EPAServeur/Exceptions/NoteIdImcompatibleException.cs index 8a3e5f3..cf6193f 100644 --- a/EPAServeur/Exceptions/NoteIdImcompatibleException.cs +++ b/EPAServeur/Exceptions/NoteIdImcompatibleException.cs @@ -1,6 +1,7 @@ using System; using System.Collections.Generic; using System.Linq; +using System.Runtime.Serialization; using System.Threading.Tasks; namespace EPAServeur.Exceptions @@ -10,5 +11,37 @@ namespace EPAServeur.Exceptions /// public class NoteIdImcompatibleException : Exception { + /// + /// Initialise une nouvelle instance de la classe class. + /// + public NoteIdImcompatibleException() + { + } + + /// + /// Initialise une nouvelle instance de la classe class. + /// + /// + public NoteIdImcompatibleException(string message) : base(message) + { + } + + /// + /// Initialise une nouvelle instance de la classe class. + /// + /// + /// + public NoteIdImcompatibleException(string message, Exception innerException) : base(message, innerException) + { + } + + /// + /// Initialise une nouvelle instance de la classe class. + /// + /// + /// + protected NoteIdImcompatibleException(SerializationInfo info, StreamingContext context) : base(info, context) + { + } } } diff --git a/EPAServeur/Exceptions/NoteInvalideException.cs b/EPAServeur/Exceptions/NoteInvalideException.cs index e85526e..905ed77 100644 --- a/EPAServeur/Exceptions/NoteInvalideException.cs +++ b/EPAServeur/Exceptions/NoteInvalideException.cs @@ -1,6 +1,7 @@ using System; using System.Collections.Generic; using System.Linq; +using System.Runtime.Serialization; using System.Threading.Tasks; namespace EPAServeur.Exceptions @@ -10,5 +11,37 @@ namespace EPAServeur.Exceptions /// public class NoteInvalideException : Exception { + /// + /// Initialise une nouvelle instance de la classe class. + /// + public NoteInvalideException() + { + } + + /// + /// Initialise une nouvelle instance de la classe class. + /// + /// + public NoteInvalideException(string message) : base(message) + { + } + + /// + /// Initialise une nouvelle instance de la classe class. + /// + /// + /// + public NoteInvalideException(string message, Exception innerException) : base(message, innerException) + { + } + + /// + /// Initialise une nouvelle instance de la classe class. + /// + /// + /// + protected NoteInvalideException(SerializationInfo info, StreamingContext context) : base(info, context) + { + } } } diff --git a/EPAServeur/Exceptions/NoteNotFoundException.cs b/EPAServeur/Exceptions/NoteNotFoundException.cs index 4244e57..2abe596 100644 --- a/EPAServeur/Exceptions/NoteNotFoundException.cs +++ b/EPAServeur/Exceptions/NoteNotFoundException.cs @@ -1,6 +1,7 @@ using System; using System.Collections.Generic; using System.Linq; +using System.Runtime.Serialization; using System.Threading.Tasks; namespace EPAServeur.Exceptions @@ -10,6 +11,37 @@ namespace EPAServeur.Exceptions /// public class NoteNotFoundException : Exception { + /// + /// Initialise une nouvelle instance de la classe class. + /// + public NoteNotFoundException() + { + } + /// + /// Initialise une nouvelle instance de la classe class. + /// + /// + public NoteNotFoundException(string message) : base(message) + { + } + + /// + /// Initialise une nouvelle instance de la classe class. + /// + /// + /// + public NoteNotFoundException(string message, Exception innerException) : base(message, innerException) + { + } + + /// + /// Initialise une nouvelle instance de la classe class. + /// + /// + /// + protected NoteNotFoundException(SerializationInfo info, StreamingContext context) : base(info, context) + { + } } } diff --git a/EPAServeur/Exceptions/ReferentIncompatibleException.cs b/EPAServeur/Exceptions/ReferentIncompatibleException.cs new file mode 100644 index 0000000..346f2a3 --- /dev/null +++ b/EPAServeur/Exceptions/ReferentIncompatibleException.cs @@ -0,0 +1,47 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Runtime.Serialization; +using System.Threading.Tasks; + +namespace EPAServeur.Exceptions +{ + /// + /// Excpetion à jeter lorsque que l'id d'un référent passé au paramètre ne correspond à celui de l'id de l'objet collaborateur du référent + /// + public class ReferentIncompatibleException : Exception + { + /// + /// Initialise une nouvelle instance de la classe class. + /// + public ReferentIncompatibleException() + { + } + + /// + /// Initialise une nouvelle instance de la classe class. + /// + /// + public ReferentIncompatibleException(string message) : base(message) + { + } + + /// + /// Initialise une nouvelle instance de la classe class. + /// + /// + /// + public ReferentIncompatibleException(string message, Exception innerException) : base(message, innerException) + { + } + + /// + /// Initialise une nouvelle instance de la classe class. + /// + /// + /// + protected ReferentIncompatibleException(SerializationInfo info, StreamingContext context) : base(info, context) + { + } + } +} diff --git a/EPAServeur/Exceptions/ReferentNotFoundException.cs b/EPAServeur/Exceptions/ReferentNotFoundException.cs index 3559ada..b25a944 100644 --- a/EPAServeur/Exceptions/ReferentNotFoundException.cs +++ b/EPAServeur/Exceptions/ReferentNotFoundException.cs @@ -1,6 +1,7 @@ using System; using System.Collections.Generic; using System.Linq; +using System.Runtime.Serialization; using System.Threading.Tasks; namespace EPAServeur.Exceptions @@ -10,5 +11,37 @@ namespace EPAServeur.Exceptions /// public class ReferentNotFoundException : Exception { + /// + /// Initialise une nouvelle instance de la classe class. + /// + public ReferentNotFoundException() + { + } + + /// + /// Initialise une nouvelle instance de la classe class. + /// + /// + public ReferentNotFoundException(string message) : base(message) + { + } + + /// + /// Initialise une nouvelle instance de la classe class. + /// + /// + /// + public ReferentNotFoundException(string message, Exception innerException) : base(message, innerException) + { + } + + /// + /// Initialise une nouvelle instance de la classe class. + /// + /// + /// + protected ReferentNotFoundException(SerializationInfo info, StreamingContext context) : base(info, context) + { + } } } diff --git a/EPAServeur/IServices/ICollaborateurService.cs b/EPAServeur/IServices/ICollaborateurService.cs index 3b30e43..f8c4a65 100644 --- a/EPAServeur/IServices/ICollaborateurService.cs +++ b/EPAServeur/IServices/ICollaborateurService.cs @@ -11,14 +11,16 @@ namespace EPAServeur.IServices { public interface ICollaborateurService { - CollaborateurDTO GetCollaborateurById(Guid? id); Task GetCollaborateurByIdAsync(Guid? id); - CollaborateurDTO GetCollaborateurByMail(string mail); Task GetCollaborateurByMailAsync(string mail); - IEnumerable GetCollaborateurs(bool? asc, int? numPage, int? parPage, List fonctions, long? idAgence, long? idBU, string texte, string tri); - Task> GetCollaborateursAsync(bool? asc, int? numPage, int? parPage, List fonctions, long? idAgence, long? idBU, string texte, string tri); - IEnumerable GetCollaborateursByReferent(Guid? idReferent, bool? asc, int? numPage, int? parPage, string texte, string tri); + Task> GetCollaborateursAsync(List roles, List idBUs, bool? asc, int? numPage, int? parPAge, string texte, string tri, DateTime? dateDebut, DateTime? dateFin); + Task GetCollaborateursCountAsync(List roles, List idBUs, string texte, DateTime? dateDebut, DateTime? dateFin); Task> GetCollaborateursByReferentAsync(Guid? idReferent, bool? asc, int? numPage, int? parPage, string texte, string tri); + Task GetCollaborateursCountByReferentAsync(Guid? idReferent, string texte); + Task> GetReferentsPrecedentsEPAsync(Guid? idCollaborateur); + Task> GetCollaborateurDTOsAsync(List guids); + + } } diff --git a/EPAServeur/IServices/INoteService.cs b/EPAServeur/IServices/INoteService.cs index 6b69c12..d63515d 100644 --- a/EPAServeur/IServices/INoteService.cs +++ b/EPAServeur/IServices/INoteService.cs @@ -10,13 +10,13 @@ namespace EPAServeur.IServices { public interface INoteService { - //bool? asc, int? numPage, int? parPAge, string texte, string tri) - public IEnumerable GetNotes(bool? asc, int? numPage, int? parPAge, string texte, string tri); - public IEnumerable GetNotesByAuteur(Guid? idAuteur, bool? asc, int? numPage, int? parPAge, string texte, string tri); - public DetailsNoteDTO GetNoteById(long? idNote); - public IEnumerable GetNotesByCollaborateur(Guid? idAuteur, Guid? idCollaborateur, bool? asc, int? numPage, int? parPAge, string texte, string tri); - public DetailsNoteDTO AjouterNote(DetailsNoteDTO nouvelleNote); - public void SupprimerNote(long? idNote); - public DetailsNoteDTO UpdateNote(long? idNote, DetailsNoteDTO note); + Task AjouterNoteAsync(DetailsNoteDTO note); + Task SupprimerNoteAsync(long? idNote); + Task GetNoteByIdAsync(long? idNote); + Task> GetNotesByAuteurAsync(Guid? idAuteur, bool? asc, int? numPage, int? parPAge, string texte, string tri); + Task GetNotesByAuteurCountAsync(Guid? idAuteur, string texte); + Task UpdateNoteAsync(long? idNote, DetailsNoteDTO note); + + } } diff --git a/EPAServeur/IServices/IReferentEPService.cs b/EPAServeur/IServices/IReferentEPService.cs index f228004..cec79f6 100644 --- a/EPAServeur/IServices/IReferentEPService.cs +++ b/EPAServeur/IServices/IReferentEPService.cs @@ -10,5 +10,7 @@ namespace EPAServeur.IServices { public interface IReferentEPService { - } + Task UpdateCollaborateursReferentAsync(ReferentEPDTO body, Guid? idReferent); + Task UpdateReferentCollaborateurAsync(ReferentEPDTO body, Guid? idCollaborateur); + } } diff --git a/EPAServeur/Services/CollaborateurService.cs b/EPAServeur/Services/CollaborateurService.cs index 7844c53..f3c161b 100644 --- a/EPAServeur/Services/CollaborateurService.cs +++ b/EPAServeur/Services/CollaborateurService.cs @@ -1,6 +1,7 @@ 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; @@ -24,29 +25,39 @@ namespace EPAServeur.Services /// API pour accéder aux données collaborateur en passant par le service collaborateur /// private readonly ICollaborateurApi collaborateurApi; + + /// + /// Nombre d'éléments min à afficher par page + /// + private readonly int minParPage = 5; + + /// + /// Nom d'éléments max à affichar par page + /// + private readonly int maxParPage = 100; + + /// + /// Nombre d'éléments à afficher par défaut par page + /// + private readonly int defaultParPage = 15; + + /// + /// Accès et gestion de la base de données + /// + private readonly EpContext context; #endregion + #region Constructeurs - public CollaborateurService(ICollaborateurApi _collaborateurApi) + public CollaborateurService(ICollaborateurApi _collaborateurApi, EpContext _contexte) { collaborateurApi = _collaborateurApi; + context = _contexte; } #endregion - #region Services - /// - /// Récupérer un collaborateur en fonction d'un id - /// - /// Identifiant du collaborateur à renvoyer - /// Le collaborateur corresponant à l'id en paramètre - public CollaborateurDTO GetCollaborateurById(Guid? id) - { - Collaborateur collaborateur = collaborateurApi.ChercherCollabId(id); - if (collaborateur == null) - throw new CollaborateurNotFoundException(); - return GetCollaborateurDTO(collaborateur); - } + #region Services Async /// /// Récupérer un collaborateur en fonction d'un id de manière asynchrone /// @@ -56,21 +67,8 @@ namespace EPAServeur.Services { Collaborateur collaborateur = await collaborateurApi.ChercherCollabIdAsync(id); if (collaborateur == null) - throw new CollaborateurNotFoundException(); - return GetCollaborateurDTO(collaborateur); - } - - /// - /// Récupérer un collaborateur en fonction d'un mail - /// - /// Mail du collaborateur à renvoyer - /// Le collaborateur correspondant au mail en paramètre - public CollaborateurDTO GetCollaborateurByMail(string mail) - { - Collaborateur collaborateur = collaborateurApi.ChercherCollabMail(mail); - if (collaborateur == null) - throw new CollaborateurNotFoundException(); - return GetCollaborateurDTO(collaborateur); + throw new CollaborateurNotFoundException("Le collaborateur recherché n'a pas été trouvé"); + return await GetCollaborateurDTOAsync(collaborateur, true); } /// @@ -82,99 +80,97 @@ namespace EPAServeur.Services { Collaborateur collaborateur = await collaborateurApi.ChercherCollabMailAsync(mail); if (collaborateur == null) - throw new CollaborateurNotFoundException(); - return GetCollaborateurDTO(collaborateur); + throw new CollaborateurNotFoundException("Le collaborateur recherché n'a pas été trouvé"); + return await GetCollaborateurDTOAsync(collaborateur, true); } + /// - /// Récupérer la liste de tous les collaborateurs + /// Récupérer la liste de tous les collaborateurs de manière asynchrone /// /// + /// Liste des rôles auxquels les collaborateurs à récupérer appartiennent + /// Liste des business units auxquelles sont rattachés les collaborateurs à récupérer /// Précise si la liste est trié dans l'ordre croissant ou décroissant /// Numéro de la page qui est affiché du côté front /// Nombre de collaborateurs à renvoyer - /// Liste des fonctions /// id de l'agence à laquelle appartient les collaborateurs à récupérer /// /// permet de récupérer les collaborateurs dont le nom + prénom ou le prénom + nom contient le texte /// Choisir l'attribut par lequel est trié la liste - /// - /// idBU est à prendre en compte avant l'idAgence - /// idAgence n'est à prendre en compte que si idBU est nul - /// - /// + /// Date à partir de laquelle les collaborateurs sont arrivés + /// Date jusqu'à laquelle les collaborateurs sont arrivés /// Renvoie la liste des collaborateurs en fonction des paramètres - public IEnumerable GetCollaborateurs(bool? asc, int? numPage, int? parPage, List fonctions, long? idAgence, long? idBU, string texte, string tri) + public async Task> GetCollaborateursAsync(List roles, List idBUs, bool? asc, int? numPage, int? parPage, string texte, string tri, DateTime? dateDebut, DateTime? dateFin) { - - if (texte == null) - texte = ""; - else - texte = texte.ToLower(); IEnumerable collaborateurs; IEnumerable 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(); + + 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; - 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); + if (texte != null) + collaborateursDTO = TriTexte(collaborateursDTO, texte.ToLower()); - return collaborateursDTO; + + 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); } + /// - /// Récupérer la liste de tous les collaborateurs de manière asynchrone + /// Récupérer le nombre de collaborateurs correspondant aux paramètres de la requête de manière asynchrone /// /// - /// Précise si la liste est trié dans l'ordre croissant ou décroissant - /// Numéro de la page qui est affiché du côté front - /// Nombre de collaborateurs à renvoyer - /// Liste des fonctions - /// id de l'agence à laquelle appartient les collaborateurs à récupérer - /// + /// Liste des rôles auxquels les collaborateurs à récupérer appartiennent + /// Liste des business units auxquelles sont rattachés les collaborateurs à récupérer /// permet de récupérer les collaborateurs dont le nom + prénom ou le prénom + nom contient le texte - /// Choisir l'attribut par lequel est trié la liste - /// - /// idBU est à prendre en compte avant l'idAgence - /// idAgence n'est à prendre en compte que si idBU est nul - /// - /// + /// Date à partir de laquelle les collaborateurs sont arrivés + /// Date jusqu'à laquelle les collaborateurs sont arrivés /// Renvoie la liste des collaborateurs en fonction des paramètres - public async Task> GetCollaborateursAsync(bool? asc, int? numPage, int? parPage, List fonctions, long? idAgence, long? idBU, string texte, string tri) + /// Le nombre de collaborateur + public async Task GetCollaborateursCountAsync(List roles, List idBUs, string texte, DateTime? dateDebut, DateTime? dateFin) { - if (texte == null) - texte = ""; - else - texte = texte.ToLower(); IEnumerable collaborateurs; IEnumerable 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(); - 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; + 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(); } /// - /// Récupérer les collaborateurs d'un référent + /// Récupérer les collaborateurs d'un référent de manière asynchrone /// /// id du référent des collaborateurs à récupérer /// Précise si la liste est trié dans l'ordre croissant ou décroissant @@ -182,79 +178,154 @@ namespace EPAServeur.Services /// Nombre de collaborateurs à renvoyer /// permet de récupérer les collaborateurs dont le nom + prénom ou le prénom + nom contient le texte /// Choisir l'attribut par lequel est trié la liste - /// Renvoyer les collaborateurs du référent dont l'id est passé en paramètre - public IEnumerable GetCollaborateursByReferent(Guid? idReferent, bool? asc, int? numPage, int? parPage, string texte, string tri) + /// Renvoyer les collaborateurs du référent en paramètre + public async Task> 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 = collaborateurApi.ChercherCollabId(idReferent); + Collaborateur referent = await collaborateurApi.ChercherCollabIdAsync(idReferent); if (referent == null) - throw new ReferentNotFoundException(); + throw new ReferentNotFoundException("Le référent recherché n'a pas été trouvé"); + + List collaborateursIds = (from r in context.ReferentEP + where r.IdReferent.Value.Equals(idReferent) + select (Guid?) r.IdCollaborateur).ToList(); - if (texte == null) - texte = ""; - else - texte = texte.ToLower(); - IEnumerable collaborateurs = collaborateurApi.ChercherCollabRef(idReferent); + IEnumerable collaborateurs = await collaborateurApi.ChercherCollabAsync(collabsId: collaborateursIds); int skip = (numPage.Value - 1) * parPage.Value; int take = parPage.Value; - IEnumerable 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; + + var tasks = collaborateurs.Select(c => GetCollaborateurDTOAsync(c, false)); + IEnumerable collaborateursDTO = await Task.WhenAll(tasks); + if (texte != null) + collaborateursDTO = TriTexte(collaborateursDTO, texte.ToLower()); + return collaborateursDTO.Skip(skip).Take(take); } /// - /// Récupérer les collaborateurs d'un référent de manière asynchrone + /// Récupérer le nombre de collaborateurs d'un référent en fonction des paramètres de manière asynchrone /// /// id du référent des collaborateurs à récupérer - /// Précise si la liste est trié dans l'ordre croissant ou décroissant - /// Numéro de la page qui est affiché du côté front - /// Nombre de collaborateurs à renvoyer /// permet de récupérer les collaborateurs dont le nom + prénom ou le prénom + nom contient le texte - /// Choisir l'attribut par lequel est trié la liste - /// Renvoyer les collaborateurs du référent dont l'id est passé en paramètre - public async Task> GetCollaborateursByReferentAsync(Guid? idReferent, bool? asc, int? numPage, int? parPage, string texte, string tri) + /// Renvoyer le nombre collaborateurs du référent en fonction des paramètres + public async Task GetCollaborateursCountByReferentAsync(Guid? idReferent, string texte) { - /* - 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(); + throw new ReferentNotFoundException("Le référent recherché n'a pas été trouvé"); - if (texte == null) - texte = ""; - else - texte = texte.ToLower(); - IEnumerable collaborateurs = await collaborateurApi.ChercherCollabRefAsync(idReferent); - int skip = (numPage.Value - 1) * parPage.Value; - int take = parPage.Value; - IEnumerable 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; + List collaborateursIds = (from r in context.ReferentEP + where r.IdReferent.Value.Equals(idReferent) + select (Guid?)r.IdCollaborateur).ToList(); + IEnumerable collaborateurs = await collaborateurApi.ChercherCollabAsync(collabsId: collaborateursIds); + + + var tasks = collaborateurs.Select(c => GetCollaborateurDTOAsync(c, false)); + IEnumerable collaborateursDTO = await Task.WhenAll(tasks); + if (texte != null) + collaborateursDTO = TriTexte(collaborateursDTO, texte.ToLower()); + return collaborateursDTO.Count(); + } + + /// + /// Récupérer la liste référents ayant fait passer des EP au collaborateur + /// + /// id du collaborateur concerné + /// Liste des référents + public Task> GetReferentsPrecedentsEPAsync(Guid? idCollaborateur) + { + throw new NotImplementedException(); } + + public async Task> GetCollaborateurDTOsAsync(List guids) + { + + IEnumerable collaborateurs = await collaborateurApi.ChercherCollabAsync(collabsId: guids); + var tasks = collaborateurs.Select(c => GetCollaborateurDTOAsync(c, false)); + IEnumerable collaborateursDTO = await Task.WhenAll(tasks); + return collaborateursDTO; + } + + #endregion - #region DTO To Object - + #region Methode de tri + /// + /// Permettre de récupéer les collaborateurs en fonction de leur nom et/ou prénom + /// + /// Liste des collaborateurs à trier + /// Texte permettant de trier par rapport aux noms et prénoms + /// Une liste de collaborateurs + private IEnumerable TriTexte(IEnumerable 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); + } + + /// + /// Permettre de trier les données collaborateurs en fonction d'un attribut + /// + /// La liste des collaborateurs à trier + /// L'attribut sur lequel les données sont triées + /// Indique si les données sont rangées dans l'ordre croissant ou non + /// Une liste de collaborateur + private IEnumerable TriAttribut(IEnumerable 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; + } + + /// + /// Cette fonction va permettre de récupérer les collaborteurs dont la date d'arrivée se situe dans un intervalle de dates + /// + /// La liste des collaborateurs à trier + /// La date à partir de laquelle les dates d'arrivées sont récupérées + /// La data limite d'arrivée du collaborateur + /// Une liste de collaborateurs + private IEnumerable TriDates(IEnumerable 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 /// /// Transformer une agence en agenceDTO @@ -297,12 +368,14 @@ namespace EPAServeur.Services return businessUnitDTO; } + /// - /// Transforme un collaborateur en collaborateurDTO + /// Transforme un collaborateur en collaborateurDTO de manière asynchrone /// /// collaborateur à transformer en collaborateurDTO + /// Indiquer si le référent du collaborateur doit être récupéré ou non /// Renvoie la transformation DTO du collaborateur - private CollaborateurDTO GetCollaborateurDTO(Collaborateur collaborateur) + private async Task GetCollaborateurDTOAsync(Collaborateur collaborateur, bool chercherReferent) { CollaborateurDTO collaborateurDTO = new CollaborateurDTO() { @@ -314,10 +387,30 @@ namespace EPAServeur.Services }; collaborateurDTO.BusinessUnit = GetBusinessUnitDTO(collaborateur.BusinessUnit); - //collaborateurDTO.Referent = GetReferentDTO(collaborateur.Referen + //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; } + + + /// + /// Récupérer le référent EP d'un collaborateur de manière asynchrone si il existe + /// + /// Le collaborateur dont on cherche le référent EP + /// Le référent EP du collaborateur + private async Task 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 } } diff --git a/EPAServeur/Services/EngagementService.cs b/EPAServeur/Services/EngagementService.cs index 867c56e..b5f6a69 100644 --- a/EPAServeur/Services/EngagementService.cs +++ b/EPAServeur/Services/EngagementService.cs @@ -337,7 +337,7 @@ namespace EPAServeur.Services Statut = ep.Statut, DatePrevisionnelle = ep.DatePrevisionnelle, Obligatoire = ep.Obligatoire, - Collaborateur = collaborateurService.GetCollaborateurById(ep.IdCollaborateur), + //Collaborateur = collaborateurService.GetCollaborateurById(ep.IdCollaborateur), //Referent = referentService.GetReferentById(ep.IdReferent) //Ajouter la date de disponibilité }; diff --git a/EPAServeur/Services/NoteService.cs b/EPAServeur/Services/NoteService.cs index 5a01e3c..68a1a62 100644 --- a/EPAServeur/Services/NoteService.cs +++ b/EPAServeur/Services/NoteService.cs @@ -2,6 +2,7 @@ using EPAServeur.Exceptions; using EPAServeur.IServices; using EPAServeur.Models.Notes; +using IO.Swagger.ApiCollaborateur; using IO.Swagger.DTO; using IO.Swagger.ModelCollaborateur; using System; @@ -18,95 +19,95 @@ namespace EPAServeur.Services public class NoteService : INoteService { #region Variables - /// - /// API pour accéder aux données collaborateur en passant par le service collaborateur - /// - private readonly ICollaborateurService collaborateurService; + + + private readonly ICollaborateurApi collaborateurApi; + /// /// Contexte pour interagir avec la base de données MySQL du serveur EP /// private readonly EpContext context; + + /// + /// Service collaborateur pour récupérer les données collaborateurs au format DTO + /// + private readonly ICollaborateurService collaborateurService; #endregion #region Constructeurs - public NoteService(ICollaborateurService _collaborateurService, EpContext _context) + public NoteService(ICollaborateurApi _collaborateurApi, ICollaborateurService _collaborateurService, EpContext _context) { collaborateurService = _collaborateurService; + collaborateurApi = _collaborateurApi; context = _context; } #endregion + + #region Services Async /// - /// Ajouter une nouvelle note dans la base de données + /// Ajouter une nouvelle note dans la base de données de manière async /// /// La nouvelle note a ajouté en base - /// - public DetailsNoteDTO AjouterNote(DetailsNoteDTO nouvelleNote) + /// La nouvelle note ajouté + public async Task AjouterNoteAsync(DetailsNoteDTO nouvelleNote) { - if (!IsDetailsNoteValide(nouvelleNote)) - throw new NoteInvalideException(); + //vérifier qu'il n'y a aucune valeur null + CheckNoteValide(nouvelleNote); + + //vérifier que le référent existe + Collaborateur auteur = await collaborateurApi.ChercherCollabIdAsync((Guid?)nouvelleNote.IdAuteur); + CheckReferent(auteur); + + //vérifier que le collaborateur existe + Collaborateur collaborateur = await collaborateurApi.ChercherCollabIdAsync(nouvelleNote.Collaborateur.Id); + CheckCollaborateur(collaborateur); + + //transformer la note DTO en Note Note note = DetailsNoteDTOToNouvelleNote(nouvelleNote); - context.Note.Add(note); - context.SaveChanges(); - return NoteToDetailSDTO(note); + + //ajouter la note et sauvegarder + await context.Note.AddAsync(note); + await context.SaveChangesAsync(); + nouvelleNote.Id = note.IdNote; + return nouvelleNote; } - #region Services /// - /// Récupérer la liste des notes qu'un auteur a écrit sur un collaborateur + /// Supprimer une note en fonction de son Id de manière async /// - /// Id de l'auteur des notes à récupérer - /// Id du collaborateur pour lesquelles les notes ont été écrites - /// Précise si la liste est trié dans l'ordre croissant ou décroissant - /// Numéro de la page qui est affiché du côté front - /// Nombre de notes à renvoyer - /// permet de récupérer les notes les informations du collaborateur ou le titre de la note contient le texte - /// Choisir l'attribut par lequel est trié la liste - /// Retour la liste des notes à afficher - public IEnumerable GetNotesByCollaborateur(Guid? idAuteur, Guid? idCollaborateur, bool? asc, int? numPage, int? parPage, string texte, string tri) + /// Id de la note à supprimer + public async Task SupprimerNoteAsync(long? idNote) { - //Stopwatch stopwatch = new Stopwatch(); - //stopwatch.Start(); - if (collaborateurService.GetCollaborateurById(idAuteur) == null) - throw new ReferentNotFoundException(); - //stopwatch.Stop(); - //Console.WriteLine("Durée d'exécution GetProfil 1: {0}", stopwatch.Elapsed.TotalSeconds); - //stopwatch.Restart(); - if (collaborateurService.GetCollaborateurById(idAuteur) == null || collaborateurService.GetCollaborateurById(idCollaborateur) == null) - throw new CollaborateurNotFoundException(); - //stopwatch.Stop(); - //Console.WriteLine("Durée d'exécution GetProfil 2: {0}", stopwatch.Elapsed.TotalSeconds); - - if (texte == null) - texte = ""; - else - texte = texte.ToLower(); - int skip = (numPage.Value - 1) * parPage.Value; - int take = parPage.Value; - IEnumerable AffichageNoteDTO = (from n in context.Note - where n.IdAuteur == idAuteur && n.IdCollaborateur == idCollaborateur - select NoteToAffichageDTO(n, collaborateurService)); - AffichageNoteDTO = (from a in AffichageNoteDTO - where a.Titre.ToLower().Contains(texte) - select a).Skip(skip).Take(take); - return AffichageNoteDTO; + Note note = await context.Note.FindAsync(idNote); + if (note == null) + { + throw new NoteNotFoundException("Impossible de supprimer la note car elle n'a pas été trouvée"); + } + context.Remove(note); + await context.SaveChangesAsync(); + return true; } + /// - /// Récupérer une note en fonction de son id + /// Récupérer une note en fonction de son id de manière async /// /// Id de la note à récupérer /// L'objet DTO de la note correspondant à l'id passé en paramètre - public DetailsNoteDTO GetNoteById(long? idNote) + public async Task GetNoteByIdAsync(long? idNote) { - Note note = context.Note.Find(idNote); + + Note note = await context.Note.FindAsync(idNote); + + //vérifier l'existance de la note if (note == null) - throw new NoteNotFoundException(); - return NoteToDetailSDTO(note); - } + throw new NoteNotFoundException("La note cherchée n'a pas été trouvée"); + //vérifier l'existence de l'auteur + Collaborateur auteur = await collaborateurApi.ChercherCollabIdAsync(note.IdAuteur); + if (auteur == null) + throw new ReferentNotFoundException("L'auteur de la note n'existe pas"); - public IEnumerable GetNotes(bool? asc, int? numPage, int? parPage, string texte, string tri) - { - throw new NotImplementedException(); + return await NoteToDetailSDTOAsync(note); } /// @@ -119,107 +120,174 @@ namespace EPAServeur.Services /// permet de récupérer les notes les informations du collaborateur ou le titre de la note contient le texte /// Choisir l'attribut par lequel est trié la liste /// Retour la liste des notes à afficher - public IEnumerable GetNotesByAuteur(Guid? idAuteur, bool? asc, int? numPage, int? parPage, string texte, string tri) + public async Task> GetNotesByAuteurAsync(Guid? idAuteur, bool? asc, int? numPage, int? parPage, string texte, string tri) { - if (collaborateurService.GetCollaborateurById(idAuteur) == null) - throw new CollaborateurNotFoundException(); - if (texte == null) - texte = ""; - else - texte = texte.ToLower(); + Collaborateur auteur = await collaborateurApi.ChercherCollabIdAsync(idAuteur); + if (auteur == null) + throw new ReferentNotFoundException("L'auteur de la note n'existe pas"); + int skip = (numPage.Value - 1) * parPage.Value; int take = parPage.Value; - //Stopwatch stopwatch = new Stopwatch(); - //stopwatch.Start(); - IEnumerable AffichageNoteDTO = (from n in context.Note - where n.IdAuteur == idAuteur - select NoteToAffichageDTO(n, collaborateurService)); - //stopwatch.Stop(); - //Console.WriteLine("Durée d'exécution numéro 1: {0}", stopwatch.Elapsed.TotalSeconds); - //stopwatch.Restart(); - AffichageNoteDTO = (from a in AffichageNoteDTO - where a.Collaborateur.ToLower().Contains(texte) || a.Titre.ToLower().Contains(texte) - select a).Skip(skip).Take(take); - //stopwatch.Stop(); - //Console.WriteLine("Durée d'exécution numéro 2: {0}", stopwatch.Elapsed.TotalSeconds); - return AffichageNoteDTO; + + IEnumerable notes = context.Note.Where(n => n.IdAuteur == idAuteur); + + var task = notes.Select(n => NoteToAffichageDTOAsync(n)); + IEnumerable AffichageNoteDTO = await Task.WhenAll(task); + + if (texte != null) + { + texte = texte.ToLower(); + AffichageNoteDTO = (from a in AffichageNoteDTO + where a.Collaborateur.ToLower().Contains(texte) || a.Titre.ToLower().Contains(texte) + select a); + } + + return AffichageNoteDTO.Skip(skip).Take(take); } /// - /// Supprimer une note en fonction de son Id + /// Récupérer le nombre de notes qu'un auteur a écrit /// - /// Id de la note à supprimer - /// Si oui ou non la notea bien été supprimé - public void SupprimerNote(long? idNote) + /// Id de l'auteur des notes à récupérer + /// permet de récupérer les notes les informations du collaborateur ou le titre de la note contient le texte + /// Le nombre de notes + public async Task GetNotesByAuteurCountAsync(Guid? idAuteur, string texte) { - Note note = context.Note.Find(idNote); - if (note == null) - throw new NoteNotFoundException(); - context.Remove(note); - context.SaveChanges(); + Collaborateur auteur = await collaborateurApi.ChercherCollabIdAsync(idAuteur); + if (auteur == null) + throw new ReferentNotFoundException("L'auteur de la note n'existe pas"); + + IEnumerable notes = context.Note.Where(n => n.IdAuteur == idAuteur); + + var task = notes.Select(n => NoteToAffichageDTOAsync(n)); + IEnumerable AffichageNoteDTO = await Task.WhenAll(task); + + if (texte != null) + { + texte = texte.ToLower(); + AffichageNoteDTO = (from a in AffichageNoteDTO + where a.Collaborateur.ToLower().Contains(texte) || a.Titre.ToLower().Contains(texte) + select a); + } + + return AffichageNoteDTO.Count(); } + /// /// Mettre à jour une note /// /// Id de la note à modifier - /// - /// - public DetailsNoteDTO UpdateNote(long? idNote, DetailsNoteDTO note) + /// Note avec les informations à jour + /// La note mise à jour + public async Task UpdateNoteAsync(long? idNote, DetailsNoteDTO note) { if (idNote != note.Id) - throw new NoteIdImcompatibleException(); - if (!IsDetailsNoteValide(note)) - throw new NoteInvalideException(); - Note noteToUpdate = context.Note.Find(idNote); + throw new NoteIdImcompatibleException("L'id de la note a mettre à jour et la note a mettre à jour sont incompatble"); + CheckNoteValide(note); + Note noteToUpdate = await context.Note.FindAsync(idNote); + if (!noteToUpdate.DateCreation.Equals(note.DateCreation) || note.Collaborateur.Id != noteToUpdate.IdCollaborateur || note.IdAuteur != noteToUpdate.IdAuteur) + throw new NoteIdImcompatibleException("La note a mettre à jour et la note en base de données ne correspondent pas"); noteToUpdate.Titre = note.Titre; noteToUpdate.Texte = note.Texte; noteToUpdate.DateMiseAJour = DateTime.Now; - context.SaveChanges(); - return NoteToDetailSDTO(noteToUpdate); + note.DateMiseAjour = DateTime.Now; + await context.SaveChangesAsync(); + return await NoteToDetailSDTOAsync(noteToUpdate); } + #endregion + #region fonctions privees /// - /// Vérifier si un objet DetailsNoteDTO possède est valide pour ajout ou mise à jour + /// Vérfier si la note est valide /// - /// Un objet DetailsNoteDTO est valide si aucune de ses propriétés n'est à null - /// - /// true si l'objet est valide, false sinon - private bool IsDetailsNoteValide(DetailsNoteDTO note) + /// La note a vérifié + private void CheckNoteValide(DetailsNoteDTO note) { - return !(note == null || note.IdAuteur == null || note.Collaborateur == null || note.Collaborateur.Id == null || note.Titre == null || note.Texte == null) ; + //vérifier que la note n'est pas null + if (note == null) + throw new NoteInvalideException("Aucune note n'a été reçue"); + + //vérfier que la note a bien un auteur + if (note.IdAuteur == null || !note.IdAuteur.HasValue) + throw new NoteInvalideException("Il impossible d'enregistrer sans donnée sur la personne qui l'a écrite"); + + //vérifier que la note est bien lié à un collaboarteur identifiable sur le serveur distant (avec une id) + if (note.Collaborateur == null || note.Collaborateur.Id == null || !note.Collaborateur.Id.HasValue) + throw new NoteInvalideException("Il est impossible d'enregistrer une note qui n'est pas lié à un collaborateur"); + + //vérifier que le titre de la note est valide + if (note.Titre == null || note.Titre == "" || note.Titre.Length < 3) + throw new NoteInvalideException("Vous devez saisir un titre d'au moins 3 caractères"); + + //vérifier que le texte de la note est valide + if(note.Texte == null || note.Texte == "" || note.Texte.Length < 3) + throw new NoteInvalideException("Vous devez saisir une note d'au moins 3 caractères"); + } + + /// + /// Vérifier que l'auteur de la note existe et est toujours présent dans l'entreprise + /// + /// L'auteur de la note + private void CheckReferent(Collaborateur auteur) + { + if (auteur == null) + throw new ReferentNotFoundException("Les informations de l'auteur de la note n'ont pas été trouvé"); + if (auteur.DateDepart.HasValue) + throw new CollaborateurPartiException("Vous ne pouvez pas créer ou modifier de note si vous avez quitté l'entreprise"); } - #endregion + /// + /// Vérifier que le collaborateur concerné par la note existe et est toujorus présent dans l'entreprise + /// + /// Le collaborateur concerné + private void CheckCollaborateur(Collaborateur collaborateur) + { + if (collaborateur == null) + throw new CollaborateurNotFoundException("Le collaborateur pour qui la note est écrite n'a pas été trouvé"); + if (collaborateur.DateDepart.HasValue) + throw new CollaborateurPartiException("Vous ne pouvez pas créer ou modifier de notes pour un collaborateur qui a quitté l'entreprise"); + } + #endregion #region ObjectToDTO + + /// /// Transformer un objet note en objet pour afficher un note dans dans un tableau /// /// Note à transformer /// Service collaborateur pour récupérer les informations des collaborateurs /// La note transformée pour être affichée - private static AffichageNoteDTO NoteToAffichageDTO(Note note, ICollaborateurService collaborateurService) + private async Task NoteToAffichageDTOAsync(Note note) { - CollaborateurDTO collaborateur = collaborateurService.GetCollaborateurById(note.IdCollaborateur); + string infoCollab = "Aucun collaborateur lié"; + Collaborateur collaborateur = await collaborateurApi.ChercherCollabIdAsync((Guid?)note.IdCollaborateur); + if (collaborateur != null) + infoCollab = collaborateur.Prenom + " " + collaborateur.Nom; AffichageNoteDTO affichage = new AffichageNoteDTO() { Id = note.IdNote, IdCollaborateur = note.IdCollaborateur, - Collaborateur = collaborateur.Prenom + collaborateur.Nom, + Collaborateur = infoCollab, Titre = note.Titre, DateMiseAJour = note.DateMiseAJour }; return affichage; } + + /// - /// Transformatino d'une note en DetailsNoteDTO + /// Transformatino d'une note en DetailsNoteDTO de manière asynchrone /// /// Note à transformer /// Note transformer en DetailsNoteDTO - private DetailsNoteDTO NoteToDetailSDTO(Note note) + private async Task NoteToDetailSDTOAsync(Note note) { + CollaborateurDTO collaborateur = await collaborateurService.GetCollaborateurByIdAsync(note.IdCollaborateur); + if (collaborateur == null) + throw new CollaborateurNotFoundException("Il est impossible de récupérer une note donc le collaborateur n'existe plus"); DetailsNoteDTO details = new DetailsNoteDTO() { Id = note.IdNote, @@ -228,7 +296,7 @@ namespace EPAServeur.Services Titre = note.Titre, Texte = note.Texte, IdAuteur = note.IdAuteur, - Collaborateur = collaborateurService.GetCollaborateurById(note.IdCollaborateur) + Collaborateur = collaborateur, }; return details; } @@ -249,8 +317,8 @@ namespace EPAServeur.Services IdCollaborateur = detailsNoteDTO.Collaborateur.Id.Value, Texte = detailsNoteDTO.Texte, Titre = detailsNoteDTO.Titre, - DateCreation = DateTime.Now, - DateMiseAJour = DateTime.Now + DateCreation = detailsNoteDTO.DateCreation.Value, + DateMiseAJour = detailsNoteDTO.DateMiseAjour.Value }; return note; } diff --git a/EPAServeur/Services/ReferentEPService.cs b/EPAServeur/Services/ReferentEPService.cs index 830a7a3..6115daf 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,218 @@ 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 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); + 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 + + /// + /// 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 ids du collaborateur ne correspondent pas ou sont nulls"); + } + } + + /// + /// 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("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 collaborateurs) + { + foreach(Collaborateur c in collaborateurs) { + //Aucune valeur nulle n'a été retrouvée + CheckCollaborateurValide(c); + } + } + + private void CheckListesIdsCollaborateurs(IEnumerable 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 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 + } }