Implémantation de l'API RéférentEP avec le code pour mettre à jour le référent EP de plusieurs collaborateurs ensemble non testé

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 (ReferentIncompatibleException e)
+            {
+                ErreurDTO erreur = new ErreurDTO
+                {
+                    Code = 415,
+                    Message = e.Message,
+                };
+                return StatusCode(erreur.Code.Value, erreur);
+            }
+            catch (ReferentNotFoundException e)
+            {
+                ErreurDTO erreur = new ErreurDTO
                 {
+                    Code = 404,
+                    Message = e.Message,
+                };
+                return StatusCode(erreur.Code.Value, erreur);
+            }
+            catch (CollaborateurPartiException e)
+            {
+                ErreurDTO erreur = new ErreurDTO
+                {
+                    Code = 4,
+                    Message = e.Message,
+                };
+                return StatusCode(erreur.Code.Value, erreur);
+            }
+            catch (CollaborateurNotFoundException e)
+            {
+                ErreurDTO erreur = new ErreurDTO
+                {
+                    Code = 404,
+                    Message = e.Message,
+                };
+                return StatusCode(erreur.Code.Value, erreur);
+            }
+            catch (DbUpdateConcurrencyException)
+            {
+                ErreurDTO erreur = new ErreurDTO
+                {
+                    Code = 500,
+                    Message = "Les données n'ont pas pu être mise à jour car elles ont été modifiés avant votre mise à jour",
+                };
+                return StatusCode(erreur.Code.Value, erreur);
+            }
+            catch (DbUpdateException e)
+            {
+                logger.LogError("Une erreur est survenue avec la base de données" + e.Message);
+                ErreurDTO erreur = new ErreurDTO
+                {
+                    Code = 500,
+                    Message = "Une erreur est survenue sur le serveur",
+                };
+                return StatusCode(erreur.Code.Value, erreur);
+            }
+            catch (Exception e)
+            {
+                logger.LogError("Une erreur inconnue est survenue :" + e.Message);
+                ErreurDTO erreur = new ErreurDTO
+                {
+                    Code = 500,
+                    Message = "Une erreur incconue est survenue",
+                };
+                return StatusCode(erreur.Code.Value, erreur);
+            }
+            return Ok(body);
+
             //TODO: Uncomment the next line to return response 200 or use other options such as return this.NotFound(), return this.BadRequest(..), ...
             // return StatusCode(200, default(ReferentEPDTO));
 
@@ -120,13 +318,6 @@ namespace IO.Swagger.Controllers
 
             //TODO: Uncomment the next line to return response 500 or use other options such as return this.NotFound(), return this.BadRequest(..), ...
             // return StatusCode(500, default(ErreurDTO));
-            string exampleJson = null;
-            exampleJson = "{\n  \"idReferent\" : \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\",\n  \"idsCollaborateur\" : [ \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\", \"046b6c7f-0b8a-43b9-b35d-6489e6daee91\" ]\n}";
-            
-                        var example = exampleJson != null
-                        ? JsonConvert.DeserializeObject<ReferentEPDTO>(exampleJson)
-                        : default(ReferentEPDTO);            //TODO: Change the data returned
-            return new ObjectResult(example);
         }
     }
 }

EPAServeur/IServices/IReferentEPService.cs

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

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,339 @@ 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 Services Sync
+		public ReferentEPDTO UpdateCollaborateursReferent(ReferentEPDTO body, Guid? idReferent)
+		{
+			//Vérifier que l'id du référent et l'id référent dans l'objet body est le même
+			CheckReferentId(idReferent, body);
+
+
+			Collaborateur referent = collaborateurApi.ChercherCollabId(idReferent);
+			
+			//Vérifier que le référent est valide
+			CheckReferentValide(referent);
+			
+
+			IEnumerable<Collaborateur> collaborateurs = collaborateurApi.ChercherCollab(body.IdsCollaborateur);
+			
+
+			//Vérifier que la liste des collaborateurs est valide
+			CheckListesCollaborateurs(collaborateurs);
+
+
+			//Si il manque un collaborateur, c'est qu'il n'a pas été trouvé
+			if (collaborateurs.Count() < body.IdsCollaborateur.Count)
+				throw new CollaborateurNotFoundException("Un collaborateur n'a pas pu être récupéré");
+
+
+			//Si on se retrouve avec plus de collaborateur que demandé
+			if (collaborateurs.Count() > body.IdsCollaborateur.Count)
+				throw new ApiException(415, "Une erreur est survenu lors de la récupération des données avec le serveur");
+
+			this.SetReferentEP(body.IdsCollaborateur, idReferent);
+
+			return body;
+		}
+
+		public ReferentEPDTO UpdateReferentCollaborateur(ReferentEPDTO body, Guid? idCollaborateur)
+		{
+
+			CheckCollaborateurId(idCollaborateur, body);
+
+			
+			Collaborateur referent = collaborateurApi.ChercherCollabId(body.IdReferent);
+			CheckReferentValide(referent);
+			
+			Collaborateur collaborateur = collaborateurApi.ChercherCollabId(idCollaborateur);
+			CheckCollaborateurValide(collaborateur);
+	
+			ReferentEP referentEP = context.ReferentEP.Find(idCollaborateur);
+			if(referentEP == null)
+			{
+				referentEP = new ReferentEP
+				{
+					IdCollaborateur = idCollaborateur.Value
+				};
+			}
+
+			//Si le nouveau référent est déjà le référent actuel du collaborateur, il n'est pas nécessaire de faire quoique ce soit
+			if (referentEP.IdReferent != null && referentEP.IdReferent.HasValue && referentEP.IdReferent.Value.Equals(body.IdReferent.Value))
+				return body;
+
+
+			Guid? ancienReferent = referentEP.IdReferent; //Si non null, il faudra notifier le référent qu'il n'est plus le référent EP du collaborateur
+
+
+			referentEP.IdReferent = body.IdReferent;
+			context.SaveChanges();
+			
+			if (ancienReferent != null && ancienReferent.HasValue)
+			{
+				//notifier l'ancien référent 
+			}
+			//TODO : Notifier le référent et le collaborateur
+
+			return body;
+		}
+		#endregion
+
+		#region Service Async
+		public async Task<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);
+
+
+			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 données du collaborateur ne correspondent pas");
+			}
+		}
+		
+		/// <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("Le collaborateur n'a pas été retrouvé");
+			//Le collaborateur est toujours présent dans l'entreprise
+			if (collaborateur.DateDepart.HasValue)
+				throw new CollaborateurPartiException("Le collaborateur récupéré ne travaille plus pour l'entreprise");
+		}
+
+		
+		private void CheckListesCollaborateurs(IEnumerable<Collaborateur> collaborateurs) 
+		{
+			foreach(Collaborateur c in collaborateurs) {
+				//Aucune valeur nulle n'a été retrouvée
+				CheckCollaborateurValide(c);
+			}
+		}
+
+		
+		private void SetReferentEP(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 = context.ReferentEP.Find(idCollaborateur);
+				
+				//Eviter d'avoir un référent qui devient son propre référent
+				if(idCollaborateur.Value.Equals(idReferent.Value))
+					continue;
+
+				//Le collaborateur n'a jamais eu de référent donc on lui crée un référentEP et il en sera simplement notifié
+				if( referentEP == null) {
+					referentEP = new ReferentEP
+					{
+						IdReferent = idReferent,
+						IdCollaborateur = idCollaborateur.Value
+					};
+					context.ReferentEP.Add(referentEP);
+				}
+				else{
+					//Si le collaborateur a actuellement un référent
+					if(referentEP.IdReferent != null && referentEP.IdReferent.HasValue) {
+						//Si le nouveau référent est déjà le référent actuel du collaborateur, il n'y a rien à faire
+						if (referentEP.IdReferent.Value.Equals(referentEP.IdReferent.Value))
+							continue;
+
+						//Sauvegarder l'ancien référent et le collaborateur suite au changement
+						anciensReferentCollaborateurs.Add(idReferent, idCollaborateur);
+					}
+					referentEP.IdReferent = idReferent;
+				}
+
+				context.SaveChanges();
+				//ajouter le nouveau collaborateur à la liste des collaborateurs à notifier
+				nouveauxCollaborateurs.Add(idCollaborateur);
+			}
+
+
+
+			//TODO: notifier chaque collaborateur de leur nouveau référent
+
+			//TODO: notifier le référent suite à ses nouveaux collaborateurs
+
+			//TODO: notifer les anciens référents qu'ils ne sont plus référents des leurs collaborateurs
+
+
+		}
+
+		#endregion
+
+		#region Methodes privees Async
+		private async void SetReferentEPAsync(IEnumerable<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
 	}
 }