Merge branch 'develop' into formation

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<NotesApiController> 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<EpContext>()
+				.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<NotesApiController>();
+
+			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<IActionResult> task = notesApiController.AddNote(nouvelleNote);
+			CreatedResult result = task.Result as CreatedResult;
+			Assert.AreEqual(201, result.StatusCode);
+			Assert.IsInstanceOf<DetailsNoteDTO>(result.Value);
+		}
+
+		
+		//DeleteNote
+		[Test]
+		public void SupprimerNote()
+		{
+			NotesApiController notesApiController = new NotesApiController(noteService, logger);
+			Task<IActionResult> 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<IActionResult> task = notesApiController.GetNoteById(1);
+			OkObjectResult result = task.Result as OkObjectResult;
+			Assert.AreEqual(200 ,result.StatusCode);
+			Assert.IsInstanceOf<DetailsNoteDTO>(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<IActionResult> task = notesApiController.UpdateNote(updatedNote, 2);
+			OkObjectResult result = task.Result as OkObjectResult;
+			Assert.AreEqual(200, result.StatusCode);
+			Assert.IsInstanceOf<DetailsNoteDTO>(result.Value);
+		}
+		#endregion
+
+
+
+
+	}
+}

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<EpContext>()
+				.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<ReferentsEPApiController>());
+			ReferentEPDTO referentEPDTO = new ReferentEPDTO()
+			{
+				IdReferent = referent,
+				IdsCollaborateur = new List<Guid?>()
+			};
+			referentEPDTO.IdsCollaborateur.Add(collaborateur1);
+			Task<IActionResult> task = referentsEPApi.UpdateReferentCollaborateur(referentEPDTO, collaborateur1);
+			OkObjectResult result = task.Result as OkObjectResult;
+			Assert.AreEqual(200, result.StatusCode);
+			Assert.IsInstanceOf<ReferentEPDTO>(result.Value);
+		}
+
+		public void UpdateCollaborateursReferent()
+		{
+			ReferentsEPApiController referentsEPApi = new ReferentsEPApiController(referentEPService, new NullLogger<ReferentsEPApiController>());
+			ReferentEPDTO referentEPDTO = new ReferentEPDTO()
+			{
+				IdReferent = referent,
+				IdsCollaborateur = new List<Guid?>()
+			};
+			referentEPDTO.IdsCollaborateur.Add(collaborateur1);
+			referentEPDTO.IdsCollaborateur.Add(collaborateur2);
+			referentEPDTO.IdsCollaborateur.Add(collaborateur3);
+			Task<IActionResult> task = referentsEPApi.UpdateCollaborateursReferent(referentEPDTO, referent);
+			OkObjectResult result = task.Result as OkObjectResult;
+			Assert.AreEqual(200, result.StatusCode);
+			Assert.IsInstanceOf<ReferentEPDTO>(result.Value);
+		}
+
+		#endregion
+
+
+	}
+
+}

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<EpContext>()
+				.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<string> roles = new List<string>();
+			roles.Add(role);
+
+			IEnumerable<CollaborateurDTO> 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<string> roles = new List<string>();
+			roles.Add("Assistant");
+			roles.Add("RH");
+
+			IEnumerable<CollaborateurDTO> 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<string> roles = new List<string>();
+			roles.Add("Manager");
+			roles.Add("RA");
+
+			IEnumerable<CollaborateurDTO> 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<CollaborateurDTO> collaborateursAsc = await collaborateurService.GetCollaborateursAsync(null, null, true, 1, 50, "", "", null, null);
+			IEnumerable<CollaborateurDTO> 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<CollaborateurDTO> 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<CollaborateurDTO> 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<CollaborateurDTO> 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<CollaborateurDTO> 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<CollaborateurDTO> 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<CollaborateurDTO> 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<CollaborateurDTO> 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<CollaborateurDTO> 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<CollaborateurDTO> 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<CollaborateurDTO> 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
+
+
+
+	}
+}

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<EpContext>()
+				.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.	
+
+
+	}
+}

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<EpContext>()
+				.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<Guid?>(),
+			};
+			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<Guid?>(),
+			};
+			referentEPDTO1.IdsCollaborateur.Add(collaborateur1);
+
+			ReferentEPDTO referentEPDTO2 = new ReferentEPDTO()
+			{
+				IdReferent = referent1,
+				IdsCollaborateur = new List<Guid?>(),
+			};
+			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<Guid?>(),
+			};
+			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<Guid?>(),
+			};
+			referentEPDTO1.IdsCollaborateur.Add(collaborateur1);
+			
+			ReferentEPDTO referentEPDTO2 = new ReferentEPDTO()
+			{
+				IdReferent = collaborateurParti,
+				IdsCollaborateur = new List<Guid?>(),
+			};
+			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<Guid?>(),
+			};
+			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<Guid?>(),
+			};
+			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<Guid?>(),
+			};
+			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<Guid?>(),
+			};
+			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<Guid?>(),
+			};
+			referentEPDTO.IdsCollaborateur.Add(collaborateur1);
+			referentEPDTO.IdsCollaborateur.Add(collaborateur3);
+			referentEPDTO.IdsCollaborateur.Add(collaborateur2);
+
+			AsyncTestDelegate exception = () => referentEPService.UpdateCollaborateursReferentAsync(referentEPDTO, collaborateurNonExistant);
+			Assert.ThrowsAsync(typeof(ReferentNotFoundException), exception);
+
+		}
+		#endregion
+	}
+}

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<Collaborateur> ChercherCollab (List<Guid?> collabsId = null, bool? ancienCollaborateur = null, List<string> roles = null, List<long?> buIds = null)
         {
              ApiResponse<List<Collaborateur>> localVarResponse = ChercherCollabWithHttpInfo(collabsId, ancienCollaborateur, roles, buIds);
+            if (localVarResponse == null)
+                return new List<Collaborateur>();
              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<List<Collaborateur>> ChercherCollabAsync (List<Guid?> collabsId = null, bool? ancienCollaborateur = null, List<string> roles = null, List<long?> buIds = null)
         {
              ApiResponse<List<Collaborateur>> localVarResponse = await ChercherCollabAsyncWithHttpInfo(collabsId, ancienCollaborateur, roles, buIds);
+            if (localVarResponse == null)
+                return new List<Collaborateur>();
              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,6 +1099,8 @@ namespace IO.Swagger.ApiCollaborateur
         public List<Collaborateur> ChercherCollabAgence (long? agenceId, List<string> roles = null)
         {
              ApiResponse<List<Collaborateur>> localVarResponse = ChercherCollabAgenceWithHttpInfo(agenceId, roles);
+            if (localVarResponse == null)
+                return new List<Collaborateur>();
             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<List<Collaborateur>> ChercherCollabAgenceAsync (long? agenceId, List<string> roles = null)
         {
              ApiResponse<List<Collaborateur>> localVarResponse = await ChercherCollabAgenceAsyncWithHttpInfo(agenceId, roles);
+            if (localVarResponse == null)
+                return new List<Collaborateur>();
              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<Collaborateur> ChercherCollabBU (long? buId, List<string> roles = null)
         {
              ApiResponse<List<Collaborateur>> localVarResponse = ChercherCollabBUWithHttpInfo(buId, roles);
+            if (localVarResponse == null)
+                return new List<Collaborateur>();
              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,6 +1313,8 @@ namespace IO.Swagger.ApiCollaborateur
         public async System.Threading.Tasks.Task<List<Collaborateur>> ChercherCollabBUAsync (long? buId, List<string> roles = null)
         {
              ApiResponse<List<Collaborateur>> localVarResponse = await ChercherCollabBUAsyncWithHttpInfo(buId, roles);
+            if (localVarResponse == null)
+                return new List<Collaborateur>();
             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<Collaborateur> 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,6 +1452,8 @@ namespace IO.Swagger.ApiCollaborateur
         public async System.Threading.Tasks.Task<Collaborateur> ChercherCollabIdAsync (Guid? collabId)
         {
              ApiResponse<Collaborateur> localVarResponse = await ChercherCollabIdAsyncWithHttpInfo(collabId);
+            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<Collaborateur>(localVarStatusCode,
                 localVarResponse.Headers.ToDictionary(x => x.Name, x => string.Join(",", x.Value)),
                 (Collaborateur) this.Configuration.ApiClient.Deserialize(localVarResponse, typeof(Collaborateur)));
@@ -1495,6 +1521,8 @@ namespace IO.Swagger.ApiCollaborateur
         public Collaborateur ChercherCollabMail (string mailApside)
         {
              ApiResponse<Collaborateur> localVarResponse = ChercherCollabMailWithHttpInfo(mailApside);
+            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<String, String>();
             var localVarQueryParams = new List<KeyValuePair<String, String>>();
             var localVarHeaderParams = new Dictionary<String, String>(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,6 +1589,8 @@ namespace IO.Swagger.ApiCollaborateur
         public async System.Threading.Tasks.Task<Collaborateur> ChercherCollabMailAsync (string mailApside)
         {
              ApiResponse<Collaborateur> localVarResponse = await ChercherCollabMailAsyncWithHttpInfo(mailApside);
+            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<String, String>();
             var localVarQueryParams = new List<KeyValuePair<String, String>>();
             var localVarHeaderParams = new Dictionary<String, String>(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,6 +1658,8 @@ namespace IO.Swagger.ApiCollaborateur
         public List<Collaborateur> ChercherCollabRef (Guid? refId)
         {
              ApiResponse<List<Collaborateur>> localVarResponse = ChercherCollabRefWithHttpInfo(refId);
+            if (localVarResponse == null)
+                return new List<Collaborateur>();
             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,6 +1726,8 @@ namespace IO.Swagger.ApiCollaborateur
         public async System.Threading.Tasks.Task<List<Collaborateur>> ChercherCollabRefAsync (Guid? refId)
         {
              ApiResponse<List<Collaborateur>> localVarResponse = await ChercherCollabRefAsyncWithHttpInfo(refId);
+            if (localVarResponse == null)
+                return new List<Collaborateur>();
             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,6 +1795,8 @@ namespace IO.Swagger.ApiCollaborateur
         public Collaborateur ChercherRefActuelId (Guid? collabId)
         {
              ApiResponse<Collaborateur> localVarResponse = ChercherRefActuelIdWithHttpInfo(collabId);
+            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,6 +1863,8 @@ namespace IO.Swagger.ApiCollaborateur
         public async System.Threading.Tasks.Task<Collaborateur> ChercherRefActuelIdAsync (Guid? collabId)
         {
              ApiResponse<Collaborateur> localVarResponse = await ChercherRefActuelIdAsyncWithHttpInfo(collabId);
+            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,6 +1932,8 @@ namespace IO.Swagger.ApiCollaborateur
         public Collaborateur ChercherRefActuelMail (string mailApside)
         {
              ApiResponse<Collaborateur> localVarResponse = ChercherRefActuelMailWithHttpInfo(mailApside);
+            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<String, String>();
             var localVarQueryParams = new List<KeyValuePair<String, String>>();
             var localVarHeaderParams = new Dictionary<String, String>(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,6 +2000,8 @@ namespace IO.Swagger.ApiCollaborateur
         public async System.Threading.Tasks.Task<Collaborateur> ChercherRefActuelMailAsync (string mailApside)
         {
              ApiResponse<Collaborateur> localVarResponse = await ChercherRefActuelMailAsyncWithHttpInfo(mailApside);
+            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<String, String>();
             var localVarQueryParams = new List<KeyValuePair<String, String>>();
             var localVarHeaderParams = new Dictionary<String, String>(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,6 +2069,8 @@ namespace IO.Swagger.ApiCollaborateur
         public List<Collaborateur> ChercherRefCollabId (Guid? collabId)
         {
              ApiResponse<List<Collaborateur>> localVarResponse = ChercherRefCollabIdWithHttpInfo(collabId);
+            if (localVarResponse == null)
+                return new List<Collaborateur>();
             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,6 +2137,8 @@ namespace IO.Swagger.ApiCollaborateur
         public async System.Threading.Tasks.Task<List<Collaborateur>> ChercherRefCollabIdAsync (Guid? collabId)
         {
              ApiResponse<List<Collaborateur>> localVarResponse = await ChercherRefCollabIdAsyncWithHttpInfo(collabId);
+            if (localVarResponse == null)
+                return new List<Collaborateur>();
             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,6 +2206,8 @@ namespace IO.Swagger.ApiCollaborateur
         public List<Collaborateur> ChercherRefCollabMail (string mailApside)
         {
              ApiResponse<List<Collaborateur>> localVarResponse = ChercherRefCollabMailWithHttpInfo(mailApside);
+            if (localVarResponse == null)
+                return new List<Collaborateur>();
             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<String, String>();
             var localVarQueryParams = new List<KeyValuePair<String, String>>();
             var localVarHeaderParams = new Dictionary<String, String>(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,6 +2274,8 @@ namespace IO.Swagger.ApiCollaborateur
         public async System.Threading.Tasks.Task<List<Collaborateur>> ChercherRefCollabMailAsync (string mailApside)
         {
              ApiResponse<List<Collaborateur>> localVarResponse = await ChercherRefCollabMailAsyncWithHttpInfo(mailApside);
+            if (localVarResponse == null)
+                return new List<Collaborateur>();
             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<String, String>();
             var localVarQueryParams = new List<KeyValuePair<String, String>>();
             var localVarHeaderParams = new Dictionary<String, String>(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<String, String>();
             var localVarQueryParams = new List<KeyValuePair<String, String>>();
             var localVarHeaderParams = new Dictionary<String, String>(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<String, String>();
             var localVarQueryParams = new List<KeyValuePair<String, String>>();
             var localVarHeaderParams = new Dictionary<String, String>(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<String, String>();
             var localVarQueryParams = new List<KeyValuePair<String, String>>();
             var localVarHeaderParams = new Dictionary<String, String>(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<String, String>();
             var localVarQueryParams = new List<KeyValuePair<String, String>>();
             var localVarHeaderParams = new Dictionary<String, String>(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);

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"),
+                IdAuteur = new Guid("aa36f34c-9041-42f5-9db3-6536fe7f1696"),
-                IdCollaborateur = new Guid("779bf1cf-4d38-48fb-8550-3d583384523b"),
+                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"),
+                IdAuteur = new Guid("aa36f34c-9041-42f5-9db3-6536fe7f1696"),
-                IdCollaborateur = new Guid("779bf1cf-4d38-48fb-8550-3d583384523b"),
+                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"),
+                IdAuteur = new Guid(),
-                IdCollaborateur = new Guid("779bf1cf-4d38-48fb-8550-3d583384523b"),
+                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"),
+                IdAuteur = new Guid("aa36f34c-9041-42f5-9db3-6536fe7f1696"),
-                IdCollaborateur = new Guid("006226f6-51b2-4a02-a302-7447f7fccc04"),
+                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"),
+                IdAuteur = new Guid("aa36f34c-9041-42f5-9db3-6536fe7f1696"),
-                IdCollaborateur = new Guid("006226f6-51b2-4a02-a302-7447f7fccc04"),
+                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"),
+                IdAuteur = new Guid("01ee85ff-d7f3-494b-b1de-26ced8fbfa0d"),
-                IdCollaborateur = new Guid("006226f6-51b2-4a02-a302-7447f7fccc04"),
+                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"),
+                IdAuteur = new Guid(),
-                IdCollaborateur = new Guid("006226f6-51b2-4a02-a302-7447f7fccc04"),
+                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"),
+                IdAuteur = new Guid("01ee85ff-d7f3-494b-b1de-26ced8fbfa0d"),
-                IdCollaborateur = new Guid("006226f6-51b2-4a02-a302-7447f7fccc04"),
+                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"),
+                IdAuteur = new Guid("01ee85ff-d7f3-494b-b1de-26ced8fbfa0d"),
-                IdCollaborateur = new Guid("006226f6-51b2-4a02-a302-7447f7fccc04"),
+                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"),
+                IdAuteur = new Guid("01ee85ff-d7f3-494b-b1de-26ced8fbfa0d"),
-                IdCollaborateur = new Guid("006226f6-51b2-4a02-a302-7447f7fccc04"),
+                IdCollaborateur = new Guid(),
                 DateCreation = DateTime.Now,
                 DateMiseAJour = DateTime.Now
 
@@ -1417,5 +1417,90 @@ namespace EPAServeur.Context
 
             epContext.SaveChanges();
         }
+
+
+        /// <summary>
+        /// Insérer un jeu de données fictif pour les référents EP
+        /// </summary>
+        /// <param name="epContext"></param>
+        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();
+
+        }
     }
 }

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
 { 
@@ -27,6 +32,21 @@ namespace IO.Swagger.Controllers
     [ApiController]
     public class CollaborateursApiController : ControllerBase
     {
+
+        private readonly ICollaborateurService collaborateurService;
+        private readonly ILogger<CollaborateursApiController> logger;
+        private readonly IAuthorizationService authorizationService;
+
+        public CollaborateursApiController(ICollaborateurService _collaborateurService, ILogger<CollaborateursApiController> _logger, IAuthorizationService _authorizationService)
+        {
+            collaborateurService = _collaborateurService;
+            logger = _logger;
+            authorizationService = _authorizationService;
+        }
+
+
+
+
         /// <summary>
         /// 
         /// </summary>
@@ -39,7 +59,7 @@ namespace IO.Swagger.Controllers
         /// <response code="500">Une erreur est survenue sur le serveur</response>
         [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&#x27;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<IActionResult> 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<CollaborateurDTO>(exampleJson)
-                        : default(CollaborateurDTO);            //TODO: Change the data returned
-            return new ObjectResult(example);
         }
 
         /// <summary>
@@ -83,8 +153,8 @@ namespace IO.Swagger.Controllers
         /// <response code="404">La ressource n&#x27;a pas été trouvée</response>
         /// <response code="500">Une erreur est survenue sur le serveur</response>
         [HttpGet]
-        [Route("/api/collaborateurs/{mail}")]
+        [Route("/api/collaborateurs/{mail}/mail")]
-        [Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)]
+        //[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&#x27;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<IActionResult> 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<CollaborateurDTO>(exampleJson)
-                        : default(CollaborateurDTO);            //TODO: Change the data returned
-            return new ObjectResult(example);
         }
 
         /// <summary>
@@ -136,15 +256,41 @@ namespace IO.Swagger.Controllers
         /// <response code="500">Une erreur est survenue sur le serveur</response>
         [HttpGet]
         [Route("/api/collaborateurs")]
-        [Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)]
+        //[Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)]
         [ValidateModelState]
         [SwaggerOperation("GetCollaborateurs")]
         [SwaggerResponse(statusCode: 200, type: typeof(List<CollaborateurDTO>), description: "OK")]
         [SwaggerResponse(statusCode: 401, type: typeof(ErreurDTO), description: "L&#x27;utilisateur souhaitant accéder à la ressource n&#x27;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<string> roles, [FromQuery]List<long?> 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<IActionResult> GetCollaborateurs([FromQuery]List<string> roles, [FromQuery]List<long?> 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<CollaborateurDTO> 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<CollaborateurDTO>));
 
@@ -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<List<CollaborateurDTO>>(exampleJson)
-                        : default(List<CollaborateurDTO>);            //TODO: Change the data returned
-            return new ObjectResult(example);
         }
 
         /// <summary>
@@ -182,7 +321,7 @@ namespace IO.Swagger.Controllers
         /// <response code="500">Une erreur est survenue sur le serveur</response>
         [HttpGet]
         [Route("/api/collaborateurs/referent/{idReferent}")]
-        [Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)]
+        //[Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)]
         [ValidateModelState]
         [SwaggerOperation("GetCollaborateursByReferent")]
         [SwaggerResponse(statusCode: 200, type: typeof(List<CollaborateurDTO>), 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&#x27;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<IActionResult> GetCollaborateursByReferent([FromRoute][Required]Guid? idReferent, [FromQuery]bool? asc, [FromQuery]int? numPage, [FromQuery][Range(5, 100)]int? parPAge, [FromQuery]string texte, [FromQuery]string tri)
+        {
+            IEnumerable<CollaborateurDTO> 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<CollaborateurDTO>));
 
@@ -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<List<CollaborateurDTO>>(exampleJson)
-                        : default(List<CollaborateurDTO>);            //TODO: Change the data returned
-            return new ObjectResult(example);
         }
 
         /// <summary>
@@ -231,15 +400,51 @@ namespace IO.Swagger.Controllers
         /// <response code="500">Une erreur est survenue sur le serveur</response>
         [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&#x27;utilisateur souhaitant accéder à la ressource n&#x27;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<IActionResult> 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<long?>(exampleJson)
-                        : default(long?);            //TODO: Change the data returned
-            return new ObjectResult(example);
         }
 
         /// <summary>
@@ -279,15 +477,42 @@ namespace IO.Swagger.Controllers
         /// <response code="500">Une erreur est survenue sur le serveur</response>
         [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&#x27;utilisateur souhaitant accéder à la ressource n&#x27;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<string> roles, [FromQuery]List<long?> 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<IActionResult> GetCollaborateursCount([FromQuery]List<string> roles, [FromQuery]List<long?> 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<long?>(exampleJson)
-                        : default(long?);            //TODO: Change the data returned
-            return new ObjectResult(example);
         }
 
         /// <summary>
@@ -320,7 +539,7 @@ namespace IO.Swagger.Controllers
         /// <response code="500">Une erreur est survenue sur le serveur</response>
         [HttpGet]
         [Route("/api/collaborateurs/{idCollaborateur}/ep/referents")]
-        [Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)]
+        //[Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)]
         [ValidateModelState]
         [SwaggerOperation("GetReferentsPrecedentEPCollaborateur")]
         [SwaggerResponse(statusCode: 200, type: typeof(List<CollaborateurDTO>), 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&#x27;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<IActionResult> GetReferentsPrecedentEPCollaborateur([FromRoute][Required]Guid? idCollaborateur)
+        {
+            IEnumerable<CollaborateurDTO> 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<CollaborateurDTO>));
 
@@ -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<List<CollaborateurDTO>>(exampleJson)
-                        : default(List<CollaborateurDTO>);            //TODO: Change the data returned
-            return new ObjectResult(example);
         }
     }
 }

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
 { 
@@ -27,6 +33,24 @@ namespace IO.Swagger.Controllers
     [ApiController]
     public class NotesApiController : ControllerBase
     {
+
+        /// <summary>
+        /// Service des note
+        /// </summary>
+        private readonly INoteService noteService;
+
+        /// <summary>
+        /// Logger du contrôleur
+        /// </summary>
+        private readonly ILogger<NotesApiController> logger;
+
+        public NotesApiController(INoteService _noteService, ILogger<NotesApiController> _logger)
+		{
+            noteService = _noteService;
+            logger = _logger;
+		}
+
+
         /// <summary>
         /// 
         /// </summary>
@@ -39,16 +63,87 @@ namespace IO.Swagger.Controllers
         /// <response code="500">Une erreur est survenue sur le serveur</response>
         [HttpPost]
         [Route("/api/notes/")]
-        [Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)]
+        //[Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)]
-        [ValidateModelState]
+        //[ValidateModelState]
         [SwaggerOperation("AddNote")]
         [SwaggerResponse(statusCode: 201, type: typeof(DetailsNoteDTO), description: "Note créée avec succès")]
         [SwaggerResponse(statusCode: 401, type: typeof(ErreurDTO), description: "L&#x27;utilisateur souhaitant accéder à la ressource n&#x27;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<IActionResult> 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<DetailsNoteDTO>(exampleJson)
-                        : default(DetailsNoteDTO);            //TODO: Change the data returned
-            return new ObjectResult(example);
         }
 
         /// <summary>
@@ -84,15 +173,49 @@ namespace IO.Swagger.Controllers
         /// <response code="500">Une erreur est survenue sur le serveur</response>
         [HttpDelete]
         [Route("/api/notes/{idNote}")]
-        [Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)]
+        //[Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)]
         [ValidateModelState]
         [SwaggerOperation("DeleteNote")]
         [SwaggerResponse(statusCode: 401, type: typeof(ErreurDTO), description: "L&#x27;utilisateur souhaitant accéder à la ressource n&#x27;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&#x27;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<IActionResult> 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();
         }
 
         /// <summary>
@@ -123,7 +244,7 @@ namespace IO.Swagger.Controllers
         /// <response code="500">Une erreur est survenue sur le serveur</response>
         [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&#x27;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<IActionResult> 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<DetailsNoteDTO>(exampleJson)
-                        : default(DetailsNoteDTO);            //TODO: Change the data returned
-            return new ObjectResult(example);
         }
 
         /// <summary>
@@ -172,8 +329,8 @@ namespace IO.Swagger.Controllers
         /// <response code="404">La ressource n&#x27;a pas été trouvée</response>
         /// <response code="500">Une erreur est survenue sur le serveur</response>
         [HttpGet]
-        [Route("/api/notes/{idAuteur}")]
+        [Route("/api/notes/auteur/{idAuteur}")]
-        [Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)]
+        //[Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)]
         [ValidateModelState]
         [SwaggerOperation("GetNotesAuteur")]
         [SwaggerResponse(statusCode: 200, type: typeof(List<AffichageNoteDTO>), 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&#x27;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<IActionResult> GetNotesAuteur([FromRoute][Required]Guid? idAuteur, [FromQuery]bool? asc, [FromQuery]int? numPage, [FromQuery][Range(5, 100)]int? parPAge, [FromQuery]string texte, [FromQuery]string tri)
+        {
+            IEnumerable<AffichageNoteDTO> 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<AffichageNoteDTO>));
 
@@ -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<List<AffichageNoteDTO>>(exampleJson)
-                        : default(List<AffichageNoteDTO>);            //TODO: Change the data returned
-            return new ObjectResult(example);
         }
 
         /// <summary>
@@ -222,8 +409,8 @@ namespace IO.Swagger.Controllers
         /// <response code="404">La ressource n&#x27;a pas été trouvée</response>
         /// <response code="500">Une erreur est survenue sur le serveur</response>
         [HttpGet]
-        [Route("/api/notes/{idAuteur}/count")]
+        [Route("/api/notes/auteur/{idAuteur}/count")]
-        [Authorize(AuthenticationSchemes = BearerAuthenticationHandler.SchemeName)]
+        //[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&#x27;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<IActionResult> 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<long?>(exampleJson)
-                        : default(long?);            //TODO: Change the data returned
-            return new ObjectResult(example);
         }
 
         /// <summary>
@@ -270,7 +485,7 @@ namespace IO.Swagger.Controllers
         /// <response code="500">Une erreur est survenue sur le serveur</response>
         [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&#x27;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<IActionResult> 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<DetailsNoteDTO>(exampleJson)
-                        : default(DetailsNoteDTO);            //TODO: Change the data returned
-            return new ObjectResult(example);
         }
     }
 }

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
 { 
@@ -27,6 +33,18 @@ namespace IO.Swagger.Controllers
     [ApiController]
     public class ReferentsEPApiController : ControllerBase
     {
+
+        private readonly IReferentEPService referentEPService;
+        private readonly ILogger<ReferentsEPApiController> logger;
+
+
+        public ReferentsEPApiController(IReferentEPService _referentEPService, ILogger<ReferentsEPApiController> _logger)
+		{
+            referentEPService = _referentEPService;
+            logger = _logger;
+		}
+
+
         /// <summary>
         /// 
         /// </summary>
@@ -50,8 +68,104 @@ namespace IO.Swagger.Controllers
         [SwaggerResponse(statusCode: 404, type: typeof(ErreurDTO), description: "La ressource n&#x27;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<IActionResult> 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));
 
@@ -69,13 +183,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<ReferentEPDTO>(exampleJson)
-                        : default(ReferentEPDTO);            //TODO: Change the data returned
-            return new ObjectResult(example);
             }
 
         /// <summary>
@@ -92,7 +199,7 @@ namespace IO.Swagger.Controllers
         /// <response code="500">Une erreur est survenue sur le serveur</response>
         [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&#x27;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<IActionResult> 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<ReferentEPDTO>(exampleJson)
-                        : default(ReferentEPDTO);            //TODO: Change the data returned
-            return new ObjectResult(example);
         }
     }
 }

EPAServeur/DTO/CollaborateurDTO.cs

@@ -222,7 +222,12 @@ namespace IO.Swagger.DTO
             return !Equals(left, right);
         }
 
-        #pragma warning restore 1591
+		public static implicit operator CollaborateurDTO(Guid? v)
+		{
+			throw new NotImplementedException();
+		}
+
+#pragma warning restore 1591
 		#endregion Operators
 	}
 }

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
+{
+	/// <summary>
+	/// Exception à jeter lorsque l'id d'un objet collaborateur ne correspond pas à l'id collaborateur en paramètre
+	/// </summary>
+	public class CollaborateurIncompatibleException : Exception
+	{
+		/// <summary>
+		/// Initialise une nouvelle instance de la classe <see cref="CollaborateurIncompatibleException"/> class.
+		/// </summary>
+		public CollaborateurIncompatibleException()
+		{
+		}
+
+		/// <summary>
+		/// Initialise une nouvelle instance de la classe <see cref="CollaborateurIncompatibleException"/> class.
+		/// </summary>
+		/// <param name="message"></param>
+		public CollaborateurIncompatibleException(string message) : base(message)
+		{
+		}
+
+		/// <summary>
+		/// Initialise une nouvelle instance de la classe <see cref="CollaborateurIncompatibleException"/> class.
+		/// </summary>
+		/// <param name="message"></param>
+		/// <param name="innerException"></param>
+		public CollaborateurIncompatibleException(string message, Exception innerException) : base(message, innerException)
+		{
+		}
+
+		/// <summary>
+		/// Initialise une nouvelle instance de la classe <see cref="CollaborateurIncompatibleException"/> class.
+		/// </summary>
+		/// <param name="info"></param>
+		/// <param name="context"></param>
+		protected CollaborateurIncompatibleException(SerializationInfo info, StreamingContext context) : base(info, context)
+		{
+		}
+	}
+}

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
 	/// </summary>
 	public class CollaborateurNotFoundException : Exception
 	{
+		/// <summary>
+		/// Initialise une nouvelle instance de la classe <see cref="CollaborateurNotFoundException"/> class.
+		/// </summary>
+		public CollaborateurNotFoundException()
+		{
+		}
+
+		/// <summary>
+		/// Initialise une nouvelle instance de la classe <see cref="CollaborateurNotFoundException"/> class.
+		/// </summary>
+		/// <param name="message"></param>
+		public CollaborateurNotFoundException(string message) : base(message)
+		{
+		}
+
+		/// <summary>
+		/// Initialise une nouvelle instance de la classe <see cref="CollaborateurNotFoundException"/> class.
+		/// </summary>
+		/// <param name="message"></param>
+		/// <param name="innerException"></param>
+		public CollaborateurNotFoundException(string message, Exception innerException) : base(message, innerException)
+		{
+		}
+
+		/// <summary>
+		/// Initialise une nouvelle instance de la classe <see cref="CollaborateurNotFoundException"/> class.
+		/// </summary>
+		/// <param name="info"></param>
+		/// <param name="context"></param>
+		protected CollaborateurNotFoundException(SerializationInfo info, StreamingContext context) : base(info, context)
+		{
+		}
 	}
 }

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)
+		{
+		}
+	}
+}

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
+{
+	/// <summary>
+	/// Exception à jeter lorsque la liste des ids collaborateurs à mettre à jour pour le réferent EP est null ou vide
+	/// </summary>
+	public class ListeIdsCollaborateursVideException : Exception
+	{
+		/// <summary>
+		/// Initialise une nouvelle instance de la classe <see cref="ListeIdsCollaborateursVideException"/> class.
+		/// </summary>
+		public ListeIdsCollaborateursVideException()
+		{
+		}
+
+		/// <summary>
+		/// Initialise une nouvelle instance de la classe <see cref="ListeIdsCollaborateursVideException"/> class.
+		/// </summary>
+		/// <param name="message"></param>
+		public ListeIdsCollaborateursVideException(string message) : base(message)
+		{
+		}
+
+		/// <summary>
+		/// Initialise une nouvelle instance de la classe <see cref="ListeIdsCollaborateursVideException"/> class.
+		/// </summary>
+		/// <param name="message"></param>
+		/// <param name="innerException"></param>
+		public ListeIdsCollaborateursVideException(string message, Exception innerException) : base(message, innerException)
+		{
+		}
+
+		/// <summary>
+		/// Initialise une nouvelle instance de la classe <see cref="ListeIdsCollaborateursVideException"/> class.
+		/// </summary>
+		/// <param name="info"></param>
+		/// <param name="context"></param>
+		protected ListeIdsCollaborateursVideException(SerializationInfo info, StreamingContext context) : base(info, context)
+		{
+		}
+	}
+}

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
 	/// </summary>
 	public class NoteIdImcompatibleException : Exception
 	{
+		/// <summary>
+		/// Initialise une nouvelle instance de la classe <see cref="NoteIdImcompatibleException"/> class.
+		/// </summary>
+		public NoteIdImcompatibleException()
+		{
+		}
+
+		/// <summary>
+		/// Initialise une nouvelle instance de la classe <see cref="NoteIdImcompatibleException"/> class.
+		/// </summary>
+		/// <param name="message"></param>
+		public NoteIdImcompatibleException(string message) : base(message)
+		{
+		}
+
+		/// <summary>
+		/// Initialise une nouvelle instance de la classe <see cref="NoteIdImcompatibleException"/> class.
+		/// </summary>
+		/// <param name="message"></param>
+		/// <param name="innerException"></param>
+		public NoteIdImcompatibleException(string message, Exception innerException) : base(message, innerException)
+		{
+		}
+
+		/// <summary>
+		/// Initialise une nouvelle instance de la classe <see cref="NoteIdImcompatibleException"/> class.
+		/// </summary>
+		/// <param name="info"></param>
+		/// <param name="context"></param>
+		protected NoteIdImcompatibleException(SerializationInfo info, StreamingContext context) : base(info, context)
+		{
+		}
 	}
 }

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
 	/// </summary>
 	public class NoteInvalideException : Exception
 	{
+		/// <summary>
+		/// Initialise une nouvelle instance de la classe <see cref="NoteInvalideException"/> class.
+		/// </summary>
+		public NoteInvalideException()
+		{
+		}
+
+		/// <summary>
+		/// Initialise une nouvelle instance de la classe <see cref="NoteInvalideException"/> class.
+		/// </summary>
+		/// <param name="message"></param>
+		public NoteInvalideException(string message) : base(message)
+		{
+		}
+
+		/// <summary>
+		/// Initialise une nouvelle instance de la classe <see cref="NoteInvalideException"/> class.
+		/// </summary>
+		/// <param name="message"></param>
+		/// <param name="innerException"></param>
+		public NoteInvalideException(string message, Exception innerException) : base(message, innerException)
+		{
+		}
+
+		/// <summary>
+		/// Initialise une nouvelle instance de la classe <see cref="NoteInvalideException"/> class.
+		/// </summary>
+		/// <param name="info"></param>
+		/// <param name="context"></param>
+		protected NoteInvalideException(SerializationInfo info, StreamingContext context) : base(info, context)
+		{
+		}
 	}
 }

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
 	/// </summary>
 	public class NoteNotFoundException : Exception
 	{
+		/// <summary>
+		/// Initialise une nouvelle instance de la classe <see cref="NoteNotFoundException"/> class.
+		/// </summary>
+		public NoteNotFoundException()
+		{
+		}
+
+		/// <summary>
+		/// Initialise une nouvelle instance de la classe <see cref="NoteNotFoundException"/> class.
+		/// </summary>
+		/// <param name="message"></param>
+		public NoteNotFoundException(string message) : base(message)
+		{
+		}
 
+		/// <summary>
+		/// Initialise une nouvelle instance de la classe <see cref="NoteNotFoundException"/> class.
+		/// </summary>
+		/// <param name="message"></param>
+		/// <param name="innerException"></param>
+		public NoteNotFoundException(string message, Exception innerException) : base(message, innerException)
+		{
+		}
+
+		/// <summary>
+		/// Initialise une nouvelle instance de la classe <see cref="NoteNotFoundException"/> class.
+		/// </summary>
+		/// <param name="info"></param>
+		/// <param name="context"></param>
+		protected NoteNotFoundException(SerializationInfo info, StreamingContext context) : base(info, context)
+		{
+		}
 	}
 }

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
+{
+	/// <summary>
+	/// 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
+	/// </summary>
+	public class ReferentIncompatibleException : Exception
+	{
+		/// <summary>
+		/// Initialise une nouvelle instance de la classe <see cref="ReferentIncompatibleException"/> class.
+		/// </summary>
+		public ReferentIncompatibleException()
+		{
+		}
+
+		/// <summary>
+		/// Initialise une nouvelle instance de la classe <see cref="ReferentIncompatibleException"/> class.
+		/// </summary>
+		/// <param name="message"></param>
+		public ReferentIncompatibleException(string message) : base(message)
+		{
+		}
+
+		/// <summary>
+		/// Initialise une nouvelle instance de la classe <see cref="ReferentIncompatibleException"/> class.
+		/// </summary>
+		/// <param name="message"></param>
+		/// <param name="innerException"></param>
+		public ReferentIncompatibleException(string message, Exception innerException) : base(message, innerException)
+		{
+		}
+
+		/// <summary>
+		/// Initialise une nouvelle instance de la classe <see cref="ReferentIncompatibleException"/> class.
+		/// </summary>
+		/// <param name="info"></param>
+		/// <param name="context"></param>
+		protected ReferentIncompatibleException(SerializationInfo info, StreamingContext context) : base(info, context)
+		{
+		}
+	}
+}

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
 	/// </summary>
 	public class ReferentNotFoundException : Exception
 	{
+		/// <summary>
+		/// Initialise une nouvelle instance de la classe <see cref="ReferentNotFoundException"/> class.
+		/// </summary>
+		public ReferentNotFoundException()
+		{
+		}
+
+		/// <summary>
+		/// Initialise une nouvelle instance de la classe <see cref="ReferentNotFoundException"/> class.
+		/// </summary>
+		/// <param name="message"></param>
+		public ReferentNotFoundException(string message) : base(message)
+		{
+		}
+
+		/// <summary>
+		/// Initialise une nouvelle instance de la classe <see cref="ReferentNotFoundException"/> class.
+		/// </summary>
+		/// <param name="message"></param>
+		/// <param name="innerException"></param>
+		public ReferentNotFoundException(string message, Exception innerException) : base(message, innerException)
+		{
+		}
+
+		/// <summary>
+		/// Initialise une nouvelle instance de la classe <see cref="ReferentNotFoundException"/> class.
+		/// </summary>
+		/// <param name="info"></param>
+		/// <param name="context"></param>
+		protected ReferentNotFoundException(SerializationInfo info, StreamingContext context) : base(info, context)
+		{
+		}
 	}
 }

EPAServeur/IServices/ICollaborateurService.cs

@@ -11,14 +11,16 @@ namespace EPAServeur.IServices
 {
 	public interface ICollaborateurService
 	{
-		CollaborateurDTO GetCollaborateurById(Guid? id);
 		Task<CollaborateurDTO> GetCollaborateurByIdAsync(Guid? id);
-		CollaborateurDTO GetCollaborateurByMail(string mail);
 		Task<CollaborateurDTO> GetCollaborateurByMailAsync(string mail);
-		IEnumerable<CollaborateurDTO> GetCollaborateurs(bool? asc, int? numPage, int? parPage, List<string> fonctions, long? idAgence, long? idBU, string texte, string tri);
+		Task<IEnumerable<CollaborateurDTO>> GetCollaborateursAsync(List<string> roles, List<long?> idBUs, bool? asc, int? numPage, int? parPAge, string texte, string tri, DateTime? dateDebut, DateTime? dateFin);
-		Task<IEnumerable<CollaborateurDTO>> GetCollaborateursAsync(bool? asc, int? numPage, int? parPage, List<string> fonctions, long? idAgence, long? idBU, string texte, string tri);
+		Task<int> GetCollaborateursCountAsync(List<string> roles, List<long?> idBUs, string texte, DateTime? dateDebut, DateTime? dateFin);
-		IEnumerable<CollaborateurDTO> GetCollaborateursByReferent(Guid? idReferent, bool? asc, int? numPage, int? parPage, string texte, string tri);
 		Task<IEnumerable<CollaborateurDTO>> GetCollaborateursByReferentAsync(Guid? idReferent, bool? asc, int? numPage, int? parPage, string texte, string tri);
+		Task<int> GetCollaborateursCountByReferentAsync(Guid? idReferent, string texte);
+		Task<IEnumerable<CollaborateurDTO>> GetReferentsPrecedentsEPAsync(Guid? idCollaborateur);
+		Task<IEnumerable<CollaborateurDTO>> GetCollaborateurDTOsAsync(List<Guid?> guids);
+
+
 
 	}
 }

EPAServeur/IServices/INoteService.cs

@@ -10,13 +10,13 @@ namespace EPAServeur.IServices
 {
 	public interface INoteService
 	{
-		//bool? asc, int? numPage, int? parPAge, string texte, string tri)
+		Task<DetailsNoteDTO> AjouterNoteAsync(DetailsNoteDTO note);
-		public IEnumerable<AffichageNoteDTO> GetNotes(bool? asc, int? numPage, int? parPAge, string texte, string tri);
+		Task<bool> SupprimerNoteAsync(long? idNote);
-		public IEnumerable<AffichageNoteDTO> GetNotesByAuteur(Guid? idAuteur, bool? asc, int? numPage, int? parPAge, string texte, string tri);
+		Task<DetailsNoteDTO> GetNoteByIdAsync(long? idNote);
-		public DetailsNoteDTO GetNoteById(long? idNote);
+		Task<IEnumerable<AffichageNoteDTO>> GetNotesByAuteurAsync(Guid? idAuteur, bool? asc, int? numPage, int? parPAge, string texte, string tri);
-		public IEnumerable<AffichageNoteDTO> GetNotesByCollaborateur(Guid? idAuteur, Guid? idCollaborateur, bool? asc, int? numPage, int? parPAge, string texte, string tri);
+		Task<int> GetNotesByAuteurCountAsync(Guid? idAuteur, string texte);
-		public DetailsNoteDTO AjouterNote(DetailsNoteDTO nouvelleNote);
+		Task<DetailsNoteDTO> UpdateNoteAsync(long? idNote, DetailsNoteDTO note);
-		public void SupprimerNote(long? idNote);
+
-		public DetailsNoteDTO UpdateNote(long? idNote, DetailsNoteDTO note);
+
 	}
 }

EPAServeur/IServices/IReferentEPService.cs

@@ -10,5 +10,7 @@ namespace EPAServeur.IServices
 {
 	public interface IReferentEPService
 	{
+		Task<ReferentEPDTO> UpdateCollaborateursReferentAsync(ReferentEPDTO body, Guid? idReferent);
+		Task<ReferentEPDTO> UpdateReferentCollaborateurAsync(ReferentEPDTO body, Guid? idCollaborateur);
 	}
 }

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
 		/// </summary>
 		private readonly ICollaborateurApi collaborateurApi;
+
+		/// <summary>
+		/// Nombre d'éléments min à afficher par page
+		/// </summary>
+		private readonly int minParPage = 5;
+
+		/// <summary>
+		/// Nom d'éléments max à affichar par page
+		/// </summary>
+		private readonly int maxParPage = 100;
+
+		/// <summary>
+		/// Nombre d'éléments à afficher par défaut par page
+		/// </summary>
+		private readonly int defaultParPage = 15;
+
+		/// <summary>
+		/// Accès et gestion de la base de données
+		/// </summary>
+		private readonly EpContext context;
 		#endregion
 
+
 		#region Constructeurs
-		public CollaborateurService(ICollaborateurApi _collaborateurApi)
+		public CollaborateurService(ICollaborateurApi _collaborateurApi, EpContext _contexte)
 		{
 			collaborateurApi = _collaborateurApi;
+			context = _contexte;
 		}
 		#endregion
 
-		#region Services
-		/// <summary>
-		/// Récupérer un collaborateur en fonction d'un id
-		/// </summary>
-		/// <param name="id">Identifiant du collaborateur à renvoyer</param>
-		/// <returns>Le collaborateur corresponant à l'id en paramètre</returns>
-		public CollaborateurDTO GetCollaborateurById(Guid? id)
-		{
-			Collaborateur collaborateur = collaborateurApi.ChercherCollabId(id);
-			if (collaborateur == null)
-				throw new CollaborateurNotFoundException();
-			return GetCollaborateurDTO(collaborateur);
-		}
 
+		#region Services Async
 		/// <summary>
 		/// Récupérer un collaborateur en fonction d'un id de manière asynchrone
 		/// </summary>
@@ -56,21 +67,8 @@ namespace EPAServeur.Services
 		{
 			Collaborateur collaborateur = await collaborateurApi.ChercherCollabIdAsync(id);
 			if (collaborateur == null)
-				throw new CollaborateurNotFoundException();
+				throw new CollaborateurNotFoundException("Le collaborateur recherché n'a pas été trouvé");
-			return GetCollaborateurDTO(collaborateur);
+			return await GetCollaborateurDTOAsync(collaborateur, true);
-		}
-
-		/// <summary>
-		/// Récupérer un collaborateur en fonction d'un mail
-		/// </summary>
-		/// <param name="mail">Mail du collaborateur à renvoyer</param>
-		/// <returns>Le collaborateur correspondant au mail en paramètre</returns>
-		public CollaborateurDTO GetCollaborateurByMail(string mail)
-		{
-			Collaborateur collaborateur = collaborateurApi.ChercherCollabMail(mail);
-			if (collaborateur == null)
-				throw new CollaborateurNotFoundException();
-			return GetCollaborateurDTO(collaborateur);
 		}
 
 		/// <summary>
@@ -82,99 +80,97 @@ namespace EPAServeur.Services
 		{
 			Collaborateur collaborateur = await collaborateurApi.ChercherCollabMailAsync(mail);
 			if (collaborateur == null)
-				throw new CollaborateurNotFoundException();
+				throw new CollaborateurNotFoundException("Le collaborateur recherché n'a pas été trouvé");
-			return GetCollaborateurDTO(collaborateur);
+			return await GetCollaborateurDTOAsync(collaborateur, true);
 		}
 
+
 		/// <summary>
-		///  Récupérer la liste de tous les collaborateurs
+		///  Récupérer la liste de tous les collaborateurs de manière asynchrone
 		/// </summary>
 		/// 
+		/// <param name="roles">Liste des rôles auxquels les collaborateurs à récupérer appartiennent</param>
+		/// <param name="idBUs">Liste des business units auxquelles sont rattachés les collaborateurs à récupérer</param>
 		/// <param name="asc">Précise si la liste est trié dans l'ordre croissant ou décroissant</param>
 		/// <param name="numPage">Numéro de la page qui est affiché du côté front</param>
 		/// <param name="parPage">Nombre de collaborateurs à renvoyer</param>
-		/// <param name="fonctions">Liste des fonctions</param>
 		/// <param name="idAgence">id de l'agence à laquelle appartient les collaborateurs à récupérer</param>
 		/// <param name="idBU"></param>
 		/// <param name="texte">permet de récupérer les collaborateurs dont le nom + prénom ou le prénom + nom contient le texte</param>
 		/// <param name="tri">Choisir l'attribut par lequel est trié la liste</param>
-		/// <remarks>
+		/// <param name="dateDebut">Date à partir de laquelle les collaborateurs sont arrivés</param>
-		/// <para> idBU est à prendre en compte avant l'idAgence</para>
+		/// <param name="dateFin">Date jusqu'à laquelle les collaborateurs sont arrivés</param>
-		/// <para> idAgence n'est à prendre en compte que si idBU est nul </para>
-		/// </remarks>
-		/// 
 		/// <returns>Renvoie la liste des collaborateurs en fonction des paramètres</returns>
-		public IEnumerable<CollaborateurDTO> GetCollaborateurs(bool? asc, int? numPage, int? parPage, List<string> fonctions, long? idAgence, long? idBU, string texte, string tri)
+		public async Task<IEnumerable<CollaborateurDTO>> GetCollaborateursAsync(List<string> roles, List<long?> idBUs, bool? asc, int? numPage, int? parPage, string texte, string tri, DateTime? dateDebut, DateTime? dateFin)
 		{
-
-			if (texte == null)
-				texte = "";
-			else
-				texte = texte.ToLower();
 			IEnumerable<Collaborateur> collaborateurs;
 			IEnumerable<CollaborateurDTO> collaborateursDTO;
-			if(idBU != null)
+
-				collaborateurs = collaborateurApi.ChercherCollabBU(idBU);
+			collaborateurs = await collaborateurApi.ChercherCollabAsync(ancienCollaborateur: false, roles: roles, buIds: idBUs);
-			else if( idAgence != null)
+			/*collaborateursDTO = (from c in collaborateurs
-				collaborateurs = collaborateurApi.ChercherCollabAgence(idAgence);
+								 select GetCollaborateurDTO(c, false));*/
-			else
+
-				collaborateurs = collaborateurApi.ChercherCollab();
+			var task = collaborateurs.Select(c => GetCollaborateurDTOAsync(c, true));
-			if (collaborateurs == null)
+			collaborateursDTO = await Task.WhenAll(task);
-				return new List<CollaborateurDTO>();
+
+
+
+			
+
+			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
+			if (texte != null)
-								 where (c.Nom + " " + c.Prenom).ToLower().Contains(texte) || (c.Prenom + " " + c.Nom).ToLower().Contains(texte)
+				collaborateursDTO = TriTexte(collaborateursDTO, texte.ToLower());
-								 select GetCollaborateurDTO(c)).Skip(skip).Take(take);
 
-			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);
 		}
 
+
 		/// <summary>
-		///  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
 		/// </summary>
 		/// 
-		/// <param name="asc">Précise si la liste est trié dans l'ordre croissant ou décroissant</param>
+		/// <param name="roles">Liste des rôles auxquels les collaborateurs à récupérer appartiennent</param>
-		/// <param name="numPage">Numéro de la page qui est affiché du côté front</param>
+		/// <param name="idBUs">Liste des business units auxquelles sont rattachés les collaborateurs à récupérer</param>
-		/// <param name="parPage">Nombre de collaborateurs à renvoyer</param>
-		/// <param name="fonctions">Liste des fonctions</param>
-		/// <param name="idAgence">id de l'agence à laquelle appartient les collaborateurs à récupérer</param>
-		/// <param name="idBU"></param>
 		/// <param name="texte">permet de récupérer les collaborateurs dont le nom + prénom ou le prénom + nom contient le texte</param>
-		/// <param name="tri">Choisir l'attribut par lequel est trié la liste</param>
+		/// <param name="dateDebut">Date à partir de laquelle les collaborateurs sont arrivés</param>
-		/// <remarks>
+		/// <param name="dateFin">Date jusqu'à laquelle les collaborateurs sont arrivés</param>
-		/// <para> idBU est à prendre en compte avant l'idAgence</para>
-		/// <para> idAgence n'est à prendre en compte que si idBU est nul </para>
-		/// </remarks>
-		/// 
 		/// <returns>Renvoie la liste des collaborateurs en fonction des paramètres</returns>
-		public async Task<IEnumerable<CollaborateurDTO>> GetCollaborateursAsync(bool? asc, int? numPage, int? parPage, List<string> fonctions, long? idAgence, long? idBU, string texte, string tri)
+		/// <returns>Le nombre de collaborateur</returns>
+		public async Task<int> GetCollaborateursCountAsync(List<string> roles, List<long?> idBUs, string texte, DateTime? dateDebut, DateTime? dateFin)
 		{
-			if (texte == null)
-				texte = "";
-			else
-				texte = texte.ToLower();
 			IEnumerable<Collaborateur> collaborateurs;
 			IEnumerable<CollaborateurDTO> collaborateursDTO;
-			if (idBU != null)
-				collaborateurs = await collaborateurApi.ChercherCollabBUAsync(idBU);
-			else if (idAgence != null)
-				collaborateurs = await collaborateurApi.ChercherCollabAgenceAsync(idAgence);
-			else
-				collaborateurs = await collaborateurApi.ChercherCollabAsync();
-			if (collaborateurs == null)
-				return new List<CollaborateurDTO>();
-			int skip = (numPage.Value - 1) * parPage.Value;
-			int take = parPage.Value;
-			collaborateursDTO = (from c in collaborateurs
-								 where (c.Nom + " " + c.Prenom).ToLower().Contains(texte) || (c.Prenom + " " + c.Nom).ToLower().Contains(texte)
-								 select GetCollaborateurDTO(c)).Skip(skip).Take(take);
 
-			return collaborateursDTO;
+			collaborateurs = await collaborateurApi.ChercherCollabAsync(ancienCollaborateur: false, roles: roles, buIds: idBUs);
+			
+			var tasks = collaborateurs.Select(c => GetCollaborateurDTOAsync(c, false));
+			collaborateursDTO = await Task.WhenAll(tasks);
+			
+			if (texte != null)
+				collaborateursDTO = TriTexte(collaborateursDTO, texte.ToLower());
+
+			collaborateursDTO = TriDates(collaborateursDTO, dateDebut, dateFin);
+
+			return collaborateursDTO.Count();
 		}
 
 		/// <summary>
-		/// Récupérer les collaborateurs d'un référent
+		/// Récupérer les collaborateurs d'un référent de manière asynchrone
 		/// </summary>
 		/// <param name="idReferent">id du référent des collaborateurs à récupérer</param>
 		/// <param name="asc">Précise si la liste est trié dans l'ordre croissant ou décroissant</param>
@@ -182,79 +178,154 @@ namespace EPAServeur.Services
 		/// <param name="parPage">Nombre de collaborateurs à renvoyer</param>
 		/// <param name="texte">permet de récupérer les collaborateurs dont le nom + prénom ou le prénom + nom contient le texte</param>
 		/// <param name="tri">Choisir l'attribut par lequel est trié la liste</param>
-		/// <returns>Renvoyer les collaborateurs du référent dont l'id est passé en paramètre</returns>
+		/// <returns>Renvoyer les collaborateurs du référent en paramètre</returns>
-		public IEnumerable<CollaborateurDTO> GetCollaborateursByReferent(Guid? idReferent, bool? asc, int? numPage, int? parPage, string texte, string tri)
+		public async Task<IEnumerable<CollaborateurDTO>> GetCollaborateursByReferentAsync(Guid? idReferent, bool? asc, int? numPage, int? parPage, string texte, string tri)
 		{
-			/*
+			Collaborateur referent = await collaborateurApi.ChercherCollabIdAsync(idReferent);
-			Stopwatch stopwatch = new Stopwatch();
-			stopwatch.Start();
-			stopwatch.Stop();
-			Console.WriteLine("Durée d'exécution numéro 1: {0}", stopwatch.Elapsed.TotalSeconds);
-			stopwatch.Restart();
-			stopwatch.Stop();
-			Console.WriteLine("Durée d'exécution numéro 1: {0}", stopwatch.Elapsed.TotalSeconds);
-			*/
-			Collaborateur referent = collaborateurApi.ChercherCollabId(idReferent);
 			if (referent == null)
-				throw new ReferentNotFoundException();
+				throw new ReferentNotFoundException("Le référent recherché n'a pas été trouvé");
+
+			List<Guid?> collaborateursIds = (from r in context.ReferentEP
+											 where r.IdReferent.Value.Equals(idReferent)
+											 select (Guid?) r.IdCollaborateur).ToList();
 
-			if (texte == null)
+			IEnumerable<Collaborateur> collaborateurs = await collaborateurApi.ChercherCollabAsync(collabsId: collaborateursIds);
-				texte = "";
-			else
-				texte = texte.ToLower();
-			IEnumerable<Collaborateur> collaborateurs = collaborateurApi.ChercherCollabRef(idReferent);
 			int skip = (numPage.Value - 1) * parPage.Value;
 			int take = parPage.Value;
-			IEnumerable<CollaborateurDTO>  collaborateursDTO = (from c in collaborateurs
+			
-								 where (c.Nom + " " + c.Prenom).ToLower().Contains(texte) || (c.Prenom + " " + c.Nom).ToLower().Contains(texte)
+			var tasks = collaborateurs.Select(c => GetCollaborateurDTOAsync(c, false));
-								 select GetCollaborateurDTO(c)).Skip(skip).Take(take);
+			IEnumerable<CollaborateurDTO> collaborateursDTO = await Task.WhenAll(tasks);
-			return collaborateursDTO;
+			if (texte != null)
+				collaborateursDTO = TriTexte(collaborateursDTO, texte.ToLower());
+			return collaborateursDTO.Skip(skip).Take(take);
 		}
 
 		/// <summary>
-		/// 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
 		/// </summary>
 		/// <param name="idReferent">id du référent des collaborateurs à récupérer</param>
-		/// <param name="asc">Précise si la liste est trié dans l'ordre croissant ou décroissant</param>
-		/// <param name="numPage">Numéro de la page qui est affiché du côté front</param>
-		/// <param name="parPage">Nombre de collaborateurs à renvoyer</param>
 		/// <param name="texte">permet de récupérer les collaborateurs dont le nom + prénom ou le prénom + nom contient le texte</param>
-		/// <param name="tri">Choisir l'attribut par lequel est trié la liste</param>
+		/// <returns>Renvoyer le nombre collaborateurs du référent en fonction des paramètres</returns>
-		/// <returns>Renvoyer les collaborateurs du référent dont l'id est passé en paramètre</returns>
+		public async Task<int> GetCollaborateursCountByReferentAsync(Guid? idReferent, string texte)
-		public async Task<IEnumerable<CollaborateurDTO>> GetCollaborateursByReferentAsync(Guid? idReferent, bool? asc, int? numPage, int? parPage, string texte, string tri)
 		{
-			/*
-			Stopwatch stopwatch = new Stopwatch();
-			stopwatch.Start();
-			stopwatch.Stop();
-			Console.WriteLine("Durée d'exécution numéro 1: {0}", stopwatch.Elapsed.TotalSeconds);
-			stopwatch.Restart();
-			stopwatch.Stop();
-			Console.WriteLine("Durée d'exécution numéro 1: {0}", stopwatch.Elapsed.TotalSeconds);
-			*/
 			Collaborateur referent = await collaborateurApi.ChercherCollabIdAsync(idReferent);
 			if (referent == null)
-				throw new ReferentNotFoundException();
+				throw new ReferentNotFoundException("Le référent recherché n'a pas été trouvé");
 
-			if (texte == null)
+			List<Guid?> collaborateursIds = (from r in context.ReferentEP
-				texte = "";
+											 where r.IdReferent.Value.Equals(idReferent)
-			else
+											 select (Guid?)r.IdCollaborateur).ToList();
-				texte = texte.ToLower();
+			IEnumerable<Collaborateur> collaborateurs = await collaborateurApi.ChercherCollabAsync(collabsId: collaborateursIds);
-			IEnumerable<Collaborateur> collaborateurs = await collaborateurApi.ChercherCollabRefAsync(idReferent);
+
-			int skip = (numPage.Value - 1) * parPage.Value;
+
-			int take = parPage.Value;
+			var tasks = collaborateurs.Select(c => GetCollaborateurDTOAsync(c, false));
-			IEnumerable<CollaborateurDTO> collaborateursDTO = (from c in collaborateurs
+			IEnumerable<CollaborateurDTO> collaborateursDTO = await Task.WhenAll(tasks);
-															   where (c.Nom + " " + c.Prenom).ToLower().Contains(texte) || (c.Prenom + " " + c.Nom).ToLower().Contains(texte)
+			if (texte != null)
-															   select GetCollaborateurDTO(c)).Skip(skip).Take(take);
+				collaborateursDTO = TriTexte(collaborateursDTO, texte.ToLower());
+			return collaborateursDTO.Count();
+		}
+
+		/// <summary>
+		/// Récupérer la liste référents ayant fait passer des EP au collaborateur 
+		/// </summary>
+		/// <param name="idCollaborateur">id du collaborateur concerné</param>
+		/// <returns>Liste des référents</returns>
+		public Task<IEnumerable<CollaborateurDTO>> GetReferentsPrecedentsEPAsync(Guid? idCollaborateur)
+		{
+			throw new NotImplementedException();
+		}
+
+		
+
+		public async Task<IEnumerable<CollaborateurDTO>> GetCollaborateurDTOsAsync(List<Guid?> guids)
+		{
+
+			IEnumerable<Collaborateur> collaborateurs = await collaborateurApi.ChercherCollabAsync(collabsId: guids);
+			var tasks = collaborateurs.Select(c => GetCollaborateurDTOAsync(c, false));
+			IEnumerable<CollaborateurDTO> collaborateursDTO = await Task.WhenAll(tasks);
 			return collaborateursDTO;
 		}
 
 
 		#endregion
 
-		#region DTO To Object
+
+		#region Methode de tri
+		/// <summary>
+		/// Permettre de récupéer les collaborateurs en fonction de leur nom et/ou prénom
+		/// </summary>
+		/// <param name="collaborateurs">Liste des collaborateurs à trier</param>
+		/// <param name="texte">Texte permettant de trier par rapport aux noms et prénoms</param>
+		/// <returns>Une liste de collaborateurs</returns>
+		private IEnumerable<CollaborateurDTO> TriTexte(IEnumerable<CollaborateurDTO> collaborateurs, string texte)
+		{
+			return (from c in collaborateurs
+					where (c.Nom + " " + c.Prenom).ToLower().Contains(texte) || (c.Prenom + " " + c.Nom).ToLower().Contains(texte)
+					select c);
+		}
+
+		/// <summary>
+		/// Permettre de trier les données collaborateurs en fonction d'un attribut
+		/// </summary>
+		/// <param name="collaborateurs">La liste des collaborateurs à trier</param>
+		/// <param name="tri">L'attribut sur lequel les données sont triées</param>
+		/// <param name="asc">Indique si les données sont rangées dans l'ordre croissant ou non</param>
+		/// <returns>Une liste de collaborateur</returns>
+		private IEnumerable<CollaborateurDTO> TriAttribut(IEnumerable<CollaborateurDTO> collaborateurs, string tri)
+		{
+			switch(tri)
+			{
+				case "datearrivee":
+					collaborateurs = collaborateurs.OrderBy(c => c.DateArrivee);
+					break;
+				case "businessunit":
+					collaborateurs = collaborateurs.OrderBy(c => c.BusinessUnit.Nom);
+					break;
+				case "referent":
+					collaborateurs = collaborateurs.OrderBy(c => c.Referent.Nom	);
+					break;
+				default:
+					collaborateurs = collaborateurs.OrderBy(c => c.Nom);
+					break;
+			}
+			return collaborateurs;
+		}
+
+		/// <summary>
+		/// Cette fonction va permettre de récupérer les collaborteurs dont la date d'arrivée se situe dans un intervalle de dates
+		/// </summary>
+		/// <param name="collaborateurs">La liste des collaborateurs à trier</param>
+		/// <param name="dateDebut">La date à partir de laquelle les dates d'arrivées sont récupérées</param>
+		/// <param name="dateFin">La data limite d'arrivée du collaborateur</param>
+		/// <returns>Une liste de collaborateurs</returns>
+		private IEnumerable<CollaborateurDTO> TriDates(IEnumerable<CollaborateurDTO> collaborateurs, DateTime? dateDebut, DateTime? dateFin)
+		{
+			if(dateDebut.HasValue && dateFin.HasValue)
+			{
+				DateTime dateFinValue = dateFin.Value.AddDays(1);
+				return (from c in collaborateurs
+						where c.DateArrivee >= dateDebut.Value && c.DateArrivee < dateFinValue
+						select c);
+			}
+			if(dateDebut.HasValue)
+			{
+				return (from c in collaborateurs
+								  where c.DateArrivee >= dateDebut.Value
+								  select c);
+			}
+			if(dateFin.HasValue)
+			{
+				DateTime dateFinValue = dateFin.Value.AddDays(1);
+				return  (from c in collaborateurs
+								  where c.DateArrivee < dateFinValue
+						 select c);
+			}
+			return collaborateurs;
+		}
+		#endregion
 
 
+		#region DTO To Object
 
 		/// <summary>
 		/// Transformer une agence en agenceDTO
@@ -297,12 +368,14 @@ namespace EPAServeur.Services
 			return businessUnitDTO;
 		}
 
+
 		/// <summary>
-		/// Transforme un collaborateur en collaborateurDTO
+		/// Transforme un collaborateur en collaborateurDTO de manière asynchrone
 		/// </summary>
 		/// <param name="collaborateur">collaborateur à transformer en collaborateurDTO</param>
+		/// <param name="chercherReferent">Indiquer si le référent du collaborateur doit être récupéré ou non</param>
 		/// <returns>Renvoie la transformation DTO du collaborateur</returns>
-		private CollaborateurDTO GetCollaborateurDTO(Collaborateur collaborateur)
+		private async Task<CollaborateurDTO> 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;
 		}
 
+
+
+		/// <summary>
+		/// Récupérer le référent EP d'un collaborateur de manière asynchrone si il existe
+		/// </summary>
+		/// <param name="collaborateur">Le collaborateur dont on cherche le référent EP</param>
+		/// <returns>Le référent EP du collaborateur</returns>
+		private async Task<CollaborateurDTO> GetReferentAsync(CollaborateurDTO collaborateur)
+		{
+			ReferentEP referentEP = await context.ReferentEP.FindAsync(collaborateur.Id);
+			//vérifier que le collaorateur a un référent EP
+			if (referentEP == null || referentEP.IdReferent == null || !referentEP.IdReferent.HasValue || referentEP.IdReferent.Value == null)
+				return null;
+			Collaborateur referent = await collaborateurApi.ChercherCollabIdAsync(referentEP.IdReferent);
+			if (referent == null)
+				return null;
+			return await GetCollaborateurDTOAsync(referent, false);
+		}
 		#endregion
 	}
 }

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

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
-		/// <summary>
+		
-		/// API pour accéder aux données collaborateur en passant par le service collaborateur
+
-		/// </summary>
+		private readonly ICollaborateurApi collaborateurApi;
-		private readonly ICollaborateurService collaborateurService;
+
 		/// <summary>
 		/// Contexte pour interagir avec la base de données MySQL du serveur EP
 		/// </summary>
 		private readonly EpContext context;
+
+		/// <summary>
+		/// Service collaborateur pour récupérer les données collaborateurs au format DTO
+		/// </summary>
+		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
 		/// <summary>
-		/// Ajouter une nouvelle note dans la base de données
+		/// Ajouter une nouvelle note dans la base de données de manière async
 		/// </summary>
 		/// <param name="nouvelleNote">La nouvelle note a ajouté en base</param>
-		/// <returns></returns>
+		/// <returns>La nouvelle note ajouté</returns>
-		public DetailsNoteDTO AjouterNote(DetailsNoteDTO nouvelleNote)
+		public async Task<DetailsNoteDTO> AjouterNoteAsync(DetailsNoteDTO nouvelleNote)
 		{
-			if (!IsDetailsNoteValide(nouvelleNote))
+			//vérifier qu'il n'y a aucune valeur null
-				throw new NoteInvalideException();
+			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();
+			//ajouter la note et sauvegarder
-			return NoteToDetailSDTO(note);
+			await context.Note.AddAsync(note);
+			await context.SaveChangesAsync();
+			nouvelleNote.Id = note.IdNote;
+			return nouvelleNote;
 		}
 
-		#region Services
 		/// <summary>
-		/// 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
 		/// </summary>
-		/// <param name="idAuteur">Id de l'auteur des notes à récupérer</param>
+		/// <param name="idNote">Id de la note à supprimer</param>
-		/// <param name="idCollaborateur">Id du collaborateur pour lesquelles les notes ont été écrites</param>
+		public async Task<bool> SupprimerNoteAsync(long? idNote)
-		/// <param name="asc">Précise si la liste est trié dans l'ordre croissant ou décroissant</param>
-		/// <param name="numPage">Numéro de la page qui est affiché du côté front</param>
-		/// <param name="parPage">Nombre de notes à renvoyer</param>
-		/// <param name="texte">permet de récupérer les notes les informations du collaborateur ou le titre de la note contient le texte</param>
-		/// <param name="tri">Choisir l'attribut par lequel est trié la liste</param>
-		/// <returns>Retour la liste des notes à afficher</returns>
-		public IEnumerable<AffichageNoteDTO> GetNotesByCollaborateur(Guid? idAuteur, Guid? idCollaborateur, bool? asc, int? numPage, int? parPage, string texte, string tri)
 		{
-			//Stopwatch stopwatch = new Stopwatch();
+			Note note = await context.Note.FindAsync(idNote);
-			//stopwatch.Start();
+			if (note == null)
-			if (collaborateurService.GetCollaborateurById(idAuteur) == null)
+			{
-				throw new ReferentNotFoundException();
+				throw new NoteNotFoundException("Impossible de supprimer la note car elle n'a pas été trouvée");
-			//stopwatch.Stop();
+			}
-			//Console.WriteLine("Durée d'exécution GetProfil 1: {0}", stopwatch.Elapsed.TotalSeconds);
+			context.Remove(note);
-			//stopwatch.Restart();
+			await context.SaveChangesAsync();
-			if (collaborateurService.GetCollaborateurById(idAuteur) == null || collaborateurService.GetCollaborateurById(idCollaborateur) == null)
+			return true;
-			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> 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;
 		}
 		
+
 		/// <summary>
-		/// Récupérer une note en fonction de son id
+		/// Récupérer une note en fonction de son id de manière async
 		/// </summary>
 		/// <param name="idNote">Id de la note à récupérer</param>
 		/// <returns>L'objet DTO de la note correspondant à l'id passé en paramètre</returns>
-		public DetailsNoteDTO GetNoteById(long? idNote)
+		public async Task<DetailsNoteDTO> 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();
+				throw new NoteNotFoundException("La note cherchée n'a pas été trouvée");
-			return NoteToDetailSDTO(note);
+			//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<AffichageNoteDTO> GetNotes(bool? asc, int? numPage, int? parPage, string texte, string tri)
+			return await NoteToDetailSDTOAsync(note);
-		{
-			throw new NotImplementedException();
 		}
 
 		/// <summary>
@@ -119,107 +120,174 @@ namespace EPAServeur.Services
 		/// <param name="texte">permet de récupérer les notes les informations du collaborateur ou le titre de la note contient le texte</param>
 		/// <param name="tri">Choisir l'attribut par lequel est trié la liste</param>
 		/// <returns>Retour la liste des notes à afficher</returns>
-		public IEnumerable<AffichageNoteDTO> GetNotesByAuteur(Guid? idAuteur, bool? asc, int? numPage, int? parPage, string texte, string tri)
+		public async Task<IEnumerable<AffichageNoteDTO>> GetNotesByAuteurAsync(Guid? idAuteur, bool? asc, int? numPage, int? parPage, string texte, string tri)
 		{
-			if (collaborateurService.GetCollaborateurById(idAuteur) == null)
+			Collaborateur auteur = await collaborateurApi.ChercherCollabIdAsync(idAuteur);
-				throw new CollaborateurNotFoundException();
+			if (auteur == null)
-			if (texte == null)
+				throw new ReferentNotFoundException("L'auteur de la note n'existe pas");
-				texte = "";
+
-			else
-				texte = texte.ToLower();
 			int skip = (numPage.Value - 1) * parPage.Value;
 			int take = parPage.Value;
-			//Stopwatch stopwatch = new Stopwatch();
+
-			//stopwatch.Start();
+			IEnumerable<Note> notes = context.Note.Where(n => n.IdAuteur == idAuteur);
-			IEnumerable<AffichageNoteDTO> AffichageNoteDTO = (from n in context.Note
+
-													   where n.IdAuteur == idAuteur
+			var task = notes.Select(n => NoteToAffichageDTOAsync(n));
-													   select NoteToAffichageDTO(n, collaborateurService));
+			IEnumerable<AffichageNoteDTO> AffichageNoteDTO = await Task.WhenAll(task);
-			//stopwatch.Stop();
+
-			//Console.WriteLine("Durée d'exécution numéro 1: {0}", stopwatch.Elapsed.TotalSeconds);
+			if (texte != null)
-			//stopwatch.Restart();
+			{
+				texte = texte.ToLower();
 				AffichageNoteDTO = (from a in AffichageNoteDTO
 									where a.Collaborateur.ToLower().Contains(texte) || a.Titre.ToLower().Contains(texte)
-								select a).Skip(skip).Take(take);
+									select a);
-			//stopwatch.Stop();
+			}
-			//Console.WriteLine("Durée d'exécution numéro 2: {0}", stopwatch.Elapsed.TotalSeconds);
+			
-			return AffichageNoteDTO;
+			return AffichageNoteDTO.Skip(skip).Take(take);
 		}
 
 		/// <summary>
-		/// Supprimer une note en fonction de son Id
+		/// Récupérer le nombre de notes qu'un auteur a écrit
 		/// </summary>
-		/// <param name="idNote">Id de la note à supprimer</param>
+		/// <param name="idAuteur">Id de l'auteur des notes à récupérer</param>
-		/// <returns>Si oui ou non la notea bien été supprimé</returns>
+		/// <param name="texte">permet de récupérer les notes les informations du collaborateur ou le titre de la note contient le texte</param>
-		public void SupprimerNote(long? idNote)
+		/// <returns>Le nombre de notes</returns>
+		public async Task<int> GetNotesByAuteurCountAsync(Guid? idAuteur, string texte)
 		{
-			Note note = context.Note.Find(idNote);
+			Collaborateur auteur = await collaborateurApi.ChercherCollabIdAsync(idAuteur);
-			if (note == null)
+			if (auteur == null)
-				throw new NoteNotFoundException();
+				throw new ReferentNotFoundException("L'auteur de la note n'existe pas");
-			context.Remove(note);
+
-			context.SaveChanges();
+			IEnumerable<Note> notes = context.Note.Where(n => n.IdAuteur == idAuteur);
+
+			var task = notes.Select(n => NoteToAffichageDTOAsync(n));
+			IEnumerable<AffichageNoteDTO> 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();
 		}
 
+
 		/// <summary>
 		/// Mettre à jour une note
 		/// </summary>
 		/// <param name="idNote">Id de la note à modifier</param>
-		/// <param name="note"></param>
+		/// <param name="note">Note avec les informations à jour</param>
-		/// <returns></returns>
+		/// <returns>La note mise à jour</returns>
-		public DetailsNoteDTO UpdateNote(long? idNote, DetailsNoteDTO note)
+		public async Task<DetailsNoteDTO> UpdateNoteAsync(long? idNote, DetailsNoteDTO note)
 		{
 			if (idNote != note.Id)
-				throw new NoteIdImcompatibleException();
+				throw new NoteIdImcompatibleException("L'id de la note a mettre à jour et la note a mettre à jour sont incompatble");
-			if (!IsDetailsNoteValide(note))
+			CheckNoteValide(note);
-				throw new NoteInvalideException();
+			Note noteToUpdate = await context.Note.FindAsync(idNote);
-			Note noteToUpdate = context.Note.Find(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();
+			note.DateMiseAjour = DateTime.Now;
-			return NoteToDetailSDTO(noteToUpdate);
+			await context.SaveChangesAsync();
+			return await NoteToDetailSDTOAsync(noteToUpdate);
 		}
+		#endregion
 
+		#region fonctions privees
 		/// <summary>
-		/// Vérifier si un objet DetailsNoteDTO possède est valide pour ajout ou mise à jour
+		/// Vérfier si la note est valide
 		/// </summary>
-		/// <remarks> Un objet DetailsNoteDTO est valide si aucune de ses propriétés n'est à null</remarks>
+		/// <param name="note">La note a vérifié</param>
-		/// <param name="note"></param>
+		private void CheckNoteValide(DetailsNoteDTO note)
-		/// <returns>true si l'objet est valide, false sinon</returns>
-		private bool IsDetailsNoteValide(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");
+		}
+
+		/// <summary>
+		/// Vérifier que l'auteur de la note existe et est toujours présent dans l'entreprise
+		/// </summary>
+		/// <param name="referent">L'auteur de la note</param>
+		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
 
+		/// <summary>
+		/// Vérifier que le collaborateur concerné par la note existe et est toujorus présent dans l'entreprise
+		/// </summary>
+		/// <param name="collaborateur">Le collaborateur concerné</param>
+		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
+		
+
 		/// <summary>
 		/// Transformer un objet note en objet pour afficher un note dans dans un tableau
 		/// </summary>
 		/// <param name="note">Note à transformer</param>
 		/// <param name="collaborateurService">Service collaborateur pour récupérer les informations des collaborateurs</param>
 		/// <returns>La note transformée pour être affichée</returns>
-		private static AffichageNoteDTO NoteToAffichageDTO(Note note, ICollaborateurService collaborateurService)
+		private async Task<AffichageNoteDTO> 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;
 		}
 
+		
+
 		/// <summary>
-		/// Transformatino d'une note en DetailsNoteDTO
+		/// Transformatino d'une note en DetailsNoteDTO de manière asynchrone
 		/// </summary>
 		/// <param name="note">Note à transformer</param>
 		/// <returns>Note transformer en DetailsNoteDTO</returns>
-		private DetailsNoteDTO NoteToDetailSDTO(Note note)
+		private async Task<DetailsNoteDTO> 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,
+				DateCreation = detailsNoteDTO.DateCreation.Value,
-				DateMiseAJour = DateTime.Now
+				DateMiseAJour = detailsNoteDTO.DateMiseAjour.Value
 			};
 			return note;
 		}

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