diff --git a/EPAServeur/Services/EngagementService.cs b/EPAServeur/Services/EngagementService.cs
index b5f6a69..ad750a5 100644
--- a/EPAServeur/Services/EngagementService.cs
+++ b/EPAServeur/Services/EngagementService.cs
@@ -2,15 +2,11 @@
 using EPAServeur.Exceptions;
 using EPAServeur.IServices;
 using EPAServeur.Models.EP;
-using EPAServeur.Models.Formation;
-using EPAServeur.Models.SaisieChamp;
 using IO.Swagger.DTO;
 using IO.Swagger.Enum;
-using IO.Swagger.ModelCollaborateur;
 using Microsoft.EntityFrameworkCore;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Linq;
 using System.Threading.Tasks;
 
@@ -20,9 +16,42 @@ namespace EPAServeur.Services
     {
         #region Variables
 
+
+        /// <summary>
+        /// Accès et gestion de la base de données
+        /// </summary>
         private readonly EpContext epContext;
+
+        /// <summary>
+        /// Accès et service collaborateur
+        /// </summary>
         private readonly ICollaborateurService collaborateurService;
-        private readonly IReferentEPService referentService;
+
+        /// <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>
+        /// Numéro de page min à afficher par défaut
+        /// </summary>
+        private readonly int defaultNumPage = 1;
+
+        /// <summary>
+        /// Ordonnancement par défaut
+        /// </summary>
+        private readonly bool defaultAsc = true;
+
         #endregion
 
         #region Contructeurs
@@ -31,260 +60,270 @@ namespace EPAServeur.Services
         /// Constructeur de la classe EngagementService
         /// </summary>
         /// <param name="_epContext"></param>
-        public EngagementService(EpContext _epContext, ICollaborateurService _collaborateurService, IReferentEPService _referentService)
+        public EngagementService(EpContext _epContext, ICollaborateurService _collaborateurService)
         {
             epContext = _epContext;
             collaborateurService = _collaborateurService;
-            referentService = _referentService;
         }
 
         #endregion
 
         #region Méthodes Service
 
-        public IEnumerable<EngagementDTO> GetEngagements(bool? asc, int? numPage, int? parPAge, string texte, string tri)
+        /// <summary>
+        /// Récupérer la liste des engagements de manière asynchrone
+        /// </summary>
+        /// <param name="etatsEngagement"></param>
+        /// <param name="idBUs"></param>
+        /// <param name="asc"></param>
+        /// <param name="numPage"></param>
+        /// <param name="parPage"></param>
+        /// <param name="texte"></param>
+        /// <param name="tri"></param>
+        /// <returns></returns>
+        public async Task<IEnumerable<EngagementDTO>> GetEngagementsAsync(List<long> idBUs, List<EtatEngagement> etatsEngagement, bool? asc, int? numPage, int? parPage, string texte, string tri)
         {
+            IQueryable<Engagement> query;
             IEnumerable<Engagement> engagements;
+            IEnumerable<EngagementDTO> engagementDTOs;
+            IEnumerable<CollaborateurDTO> collaborateurDTOs;
 
-            if (texte == null)
-                texte = "";
-            else
-                texte = texte.ToLower();
-
-            int skip = (numPage.Value - 1) * parPAge.Value;
-            int take = parPAge.Value;
+            query = epContext.Engagement.Include(engagement => engagement.Ep);
+            query = IdBUsFilter(query, idBUs);
+            query = EtatsEngagementFilter(query, etatsEngagement);
+            query = ActionFilter(query, texte);
+            query = OrderByColumn(query, asc, tri);
+            query = SkipAndTake(query, parPage, numPage);
 
-            engagements = epContext.Engagement.Include(engagement => engagement.Ep).Skip(skip).Take(take);
+            engagements = await query.ToListAsync();
 
-            if (engagements == null || engagements.Count() == 0)
-                return new List<EngagementDTO>();
+            collaborateurDTOs = await GetCollaborateurDTOs(engagements);
 
-            var engagementDTOs = engagements.Where(engagement => engagement.Modalite.ToLower().Contains(texte)).Select(engagement => GetEngagementDTO(engagement));
+            engagementDTOs = engagements.Select(engagement => GetEngagementDTO(engagement, collaborateurDTOs));
 
             return engagementDTOs;
         }
 
-        public async Task<IEnumerable<EngagementDTO>> GetEngagementsAsync(bool? asc, int? numPage, int? parPAge, string texte, string tri)
+        public async Task<long> GetEngagementsCountAsync(List<long> idBUs, List<EtatEngagement> etatsEngagement, bool? asc, int? numPage, int? parPage, string texte, string tri)
         {
-            IEnumerable<Engagement> engagements;
-
-            if (texte == null)
-                texte = "";
-            else
-                texte = texte.ToLower();
-
-            int skip = (numPage.Value - 1) * parPAge.Value;
-            int take = parPAge.Value;
-
-            engagements = await epContext.Engagement.Include(engagement => engagement.Ep).Skip(skip).Take(take).ToListAsync();
+            IQueryable<Engagement> query;
+            long count;
 
-            if (engagements == null || engagements.Count() == 0)
-                return new List<EngagementDTO>();
+            query = epContext.Engagement.Include(engagement => engagement.Ep);
+            query = IdBUsFilter(query, idBUs);
+            query = EtatsEngagementFilter(query, etatsEngagement);
+            query = ActionFilter(query, texte);
+            query = OrderByColumn(query, asc, tri);
+            query = SkipAndTake(query, parPage, numPage);
 
-            var engagementDTOs = engagements.Where(engagement => engagement.Modalite.ToLower().Contains(texte)).Select(engagement => GetEngagementDTOAsync(engagement));
-            var results = await Task.WhenAll(engagementDTOs);
+            count = await query.CountAsync();
 
-            return results;
+            return count;
         }
 
-        public IEnumerable<EngagementDTO> GetEngagementsEnAttente(bool? asc, int? numPage, int? parPAge, string texte, string tri)
+        /// <summary>
+        /// Donner une réponse à un engagement de manière asynchrone
+        /// </summary>
+        /// <param name="engagementDTO"></param>
+        /// <param name="idEngagement"></param>
+        /// <returns></returns>
+        public async Task<EngagementDTO> RepondreEngagementAsync(EngagementDTO engagementDTO, long idEngagement)
         {
-            IEnumerable<Engagement> engagements;
-
-            if (texte == null)
-                texte = "";
-            else
-                texte = texte.ToLower();
-
-            int skip = (numPage.Value - 1) * parPAge.Value;
-            int take = parPAge.Value;
+            IEnumerable<CollaborateurDTO> collaborateurDTOs;
+            Engagement engagement;
 
-            engagements = epContext.Engagement.Include(engagement => engagement.Ep).Where(engagement => engagement.EtatEngagement == EtatEngagement.EnAttente).Skip(skip).Take(take).ToList();
+            IsEngagementValide(engagementDTO);
 
-            if (engagements == null || engagements.Count() == 0)
-                return new List<EngagementDTO>();
+            if (!engagementDTO.Id.HasValue || engagementDTO.Id.Value != idEngagement)
+                throw new EngagementIncompatibleIdException("L'id de l'engagement à mettre à jour et l'engagement à mettre à jour sont incompatible.");
 
-            var engagementDTOs = engagements.Where(engagement => engagement.Modalite.ToLower().Contains(texte)).Select(engagement => GetEngagementDTO(engagement));
-
-            return engagementDTOs;
-        }
+            engagement = await epContext.Engagement.Include(engagement => engagement.Ep).FirstOrDefaultAsync(engagement => engagement.IdEngagement == idEngagement);
 
-        public async Task<IEnumerable<EngagementDTO>> GetEngagementsEnAttenteAsync(bool? asc, int? numPage, int? parPAge, string texte, string tri)
-        {
-            IEnumerable<Engagement> engagements;
-
-            if (texte == null)
-                texte = "";
-            else
-                texte = texte.ToLower();
-
-            int skip = (numPage.Value - 1) * parPAge.Value;
-            int take = parPAge.Value;
+            if (engagement == null)
+                throw new EngagementNotFoundException();
 
-            engagements = await epContext.Engagement.Include(engagement => engagement.Ep).Where(engagement => engagement.EtatEngagement == EtatEngagement.EnAttente).Skip(skip).Take(take).ToListAsync();
+            collaborateurDTOs = await GetCollaborateurDTOs(engagement);
 
-            if (engagements == null || engagements.Count() == 0)
-                return new List<EngagementDTO>();
+            engagement = SetReponseEngagement(engagement, engagementDTO);
 
-            var engagementDTOs = engagements.Where(engagement => engagement.Modalite.ToLower().Contains(texte)).Select(engagement => GetEngagementDTOAsync(engagement));
-            var results = await Task.WhenAll(engagementDTOs);
+            await epContext.SaveChangesAsync();
 
-            return results;
+            return GetEngagementDTO(engagement, collaborateurDTOs);
         }
 
-        public IEnumerable<EngagementDTO> GetEngagementsRepondus(bool? asc, int? numPage, int? parPAge, string texte, string tri)
-        {
-            IEnumerable<Engagement> engagements;
 
-            if (texte == null)
-                texte = "";
-            else
-                texte = texte.ToLower();
+        #endregion
 
-            int skip = (numPage.Value - 1) * parPAge.Value;
-            int take = parPAge.Value;
+        #region Méthodes Privée
+        /// <summary>
+        /// Vérifier si un objet EngagementDTO est valide pour ajout ou mise à jour
+        /// </summary>
+        /// <remarks> Un objet EngagementDTO est valide si l'action, le dispositif, la modalité et la date limite n'est pas null, si l'EP est signé, et si l'EP est présent dans la base de données.</remarks>
+        /// <param name="formation"></param>
+        /// <exception cref="EPAServeur.Exceptions.EngagementInvalidException"></exception>
+        private void IsEngagementValide(EngagementDTO engagementDTO)
+        {
+            // Vérifier que l'engagement n'est pas null
+            if (engagementDTO == null)
+                throw new EngagementInvalidException("Aucun engagement n'a été reçu.");
 
-            engagements = epContext.Engagement.Include(engagement => engagement.Ep).Where(engagement => engagement.EtatEngagement == EtatEngagement.Respecte && engagement.Modalite.ToLower().Contains(texte)).Skip(skip).Take(take);
+            // Vérfier que l'engagement a bien un EP
+            if (engagementDTO.Ep == null || !engagementDTO.Ep.Id.HasValue)
+                throw new EngagementInvalidException("Impossible de répondre à un engagement sans EP.");
 
-            if (engagements == null || engagements.Count() == 0)
-                return new List<EngagementDTO>();
+            // Vérfier que l'ep a bien été signé par le collaborateur
+            if (engagementDTO.Ep.Statut != StatutEp.Signe)
+                throw new EngagementInvalidException("Impossible de répondre à un engagement d'un EP qui n'est pas en cours et qui n'a pas été signé par le collaborateur.");
 
-            var engagementDTOs = engagements.Where(engagement => engagement.Modalite.ToLower().Contains(texte)).Select(engagement => GetEngagementDTO(engagement));
+            // Vérifier que l'engagement a bien une action
+            if (string.IsNullOrWhiteSpace(engagementDTO.Action))
+                throw new EngagementInvalidException("L'action de l'engagement doit contenir au moins 1 caractère.");
 
-            return engagementDTOs;
-        }
+            // Vérifier que l'engagement a bien un dispositif
+            if (string.IsNullOrWhiteSpace(engagementDTO.Dispositif))
+                throw new EngagementInvalidException("Le dispostif de l'engagement doit contenir au moins 1 caractère.");
 
-        public async Task<IEnumerable<EngagementDTO>> GetEngagementsRepondusAsync(bool? asc, int? numPage, int? parPAge, string texte, string tri)
-        {
-            IEnumerable<Engagement> engagements;
-
-            if (texte == null)
-                texte = "";
-            else
-                texte = texte.ToLower();
-
-            int skip = (numPage.Value - 1) * parPAge.Value;
-            int take = parPAge.Value;
+            // Vérifier que l'engagement a bien une modalité
+            if (string.IsNullOrWhiteSpace(engagementDTO.Modalite))
+                throw new EngagementInvalidException("La modalité de l'engagement doit contenir au moins 1 caractère.");
 
-            engagements = await epContext.Engagement.Include(engagement => engagement.Ep).Where(engagement => engagement.EtatEngagement == EtatEngagement.Respecte && engagement.Modalite.ToLower().Contains(texte)).Skip(skip).Take(take).ToListAsync();
+            // Vérifier que l'engagement a bien une date limite
+            if (!engagementDTO.DateLimite.HasValue)
+                throw new EngagementInvalidException("Impossible de répondre à l'engagement sans date limite.");
 
-            if (engagements == null || engagements.Count() == 0)
-                return new List<EngagementDTO>();
-
-            var engagementDTOs = engagements.Where(engagement => engagement.Modalite.ToLower().Contains(texte)).Select(engagement => GetEngagementDTOAsync(engagement));
-            var results = await Task.WhenAll(engagementDTOs);
+            // Vérifier que l'engagement a bien raison expliquant pourquoi l'engagement n'est pas réalisable lorsque l'état de l'engagement n'est pas réalisable
+            if (engagementDTO.EtatEngagement == EtatEngagement.NonRealisable && string.IsNullOrWhiteSpace(engagementDTO.RaisonNonRealisable))
+                throw new EngagementInvalidException("Impossible de répondre à l'engagement, une raison doit être rensignée lorsqu'un engagement n'est pas réalisé.");
 
-            return results;
+            // Vérfier que l'EP lié à l'engagement est présent dans la BDD
+            if (!epContext.Ep.Any(ep => ep.IdEP == engagementDTO.Ep.Id.Value))
+                throw new EngagementInvalidException("L'EP n'existe pas.");
         }
 
         /// <summary>
-        /// Donner une réponse à un engagement
+        /// Ajouter un ordonnancement croissant ou décroissant sur colonne
         /// </summary>
-        /// <param name="engagementDTO"></param>
-        /// <param name="idEngagement"></param>
+        /// <param name="query"></param>
+        /// <param name="idStatuts"></param>
         /// <returns></returns>
-        public EngagementDTO RepondreEngagement(EngagementDTO engagementDTO, long? idEngagement)
+        private IQueryable<Engagement> OrderByColumn(IQueryable<Engagement> query, bool? asc, string columnName)
         {
+            if (!asc.HasValue)
+                asc = defaultAsc;
 
-            if (!IsEngagementValide(engagementDTO))
-                throw new EngagementInvalidException("Impossible de répondre à l'engagement, des données sont manquants.");
-
-            if (engagementDTO.EtatEngagement == EtatEngagement.NonRealisable && string.IsNullOrWhiteSpace(engagementDTO.RaisonNonRealisable))
-                throw new EngagementInvalidException("Impossible de répondre à l'engagement, une raison doit être rensignée lorsqu'un engagement n'est pas réalisé.");
-
-            if (engagementDTO == null && !engagementDTO.Id.HasValue && engagementDTO.Id.Value != idEngagement)
-                throw new EngagementIncompatibleIdException();
-
-
-            Engagement engagement = epContext.Engagement.Include(engagement => engagement.Ep).FirstOrDefault(engagement => engagement.IdEngagement == idEngagement);
-
-            if (engagement == null)
-                throw new EngagementNotFoundException();
+            if (string.IsNullOrWhiteSpace(columnName))
+            {
+                if (asc.Value)
+                    return query.OrderBy(p => p.Action);
 
-            engagement.EtatEngagement = engagementDTO.EtatEngagement;
+                return query.OrderByDescending(p => p.Action);
+            }
 
-            switch (engagement.EtatEngagement)
+            switch (columnName.ToLower())
             {
-                case EtatEngagement.Respecte:
-                    engagement.EtatEngagement = engagementDTO.EtatEngagement;                    
-                    engagement.RaisonNonRealisable = null;
-                    break;
-                case EtatEngagement.NonRealisable:
-                    engagement.EtatEngagement = engagementDTO.EtatEngagement;
-                    engagement.RaisonNonRealisable = engagementDTO.RaisonNonRealisable;
-                    break;
+                case "action":
+                    if (asc.Value)
+                        return query.OrderBy(p => p.Action);
+
+                    return query.OrderByDescending(p => p.Action);
+                case "dispositif":
+                    if (asc.Value)
+                        return query.OrderBy(p => p.Dispositif);
+
+                    return query.OrderByDescending(p => p.Dispositif);
+                case "modalite":
+                    if (asc.Value)
+                        return query.OrderBy(p => p.Modalite);
+
+                    return query.OrderByDescending(p => p.Modalite);
+                case "date":
+                    if (asc.Value)
+                        return query.OrderBy(p => p.DateLimite);
+
+                    return query.OrderByDescending(p => p.DateLimite);
                 default:
-                    engagement.EtatEngagement = engagementDTO.EtatEngagement;
-                    engagement.RaisonNonRealisable = null;
-                    break;
+                    if (asc.Value)
+                        return query.OrderBy(p => p.Action);
+
+                    return query.OrderByDescending(p => p.Action);
             }
+        }
 
-            epContext.SaveChanges();
+        /// <summary>
+        /// Ajouter un filtre pour récupérer les engagements en fonction de plusieurs identifiants de Business Unit
+        /// </summary>
+        /// <param name="query"></param>
+        /// <param name="idBUs"></param>
+        /// <returns></returns>
+        /// <exception cref="EPAServeur.Exceptions.EngagementInvalidException"></exception>
+        private IQueryable<Engagement> IdBUsFilter(IQueryable<Engagement> query, List<long> idBUs)
+        {
+            if (idBUs == null || idBUs.Count == 0)
+                throw new EngagementInvalidException("Aucune Business Unit n'a été reçu.");
 
-            return GetEngagementDTO(engagement);
+            return query.Where(engagement => idBUs.Contains(engagement.Ep.IdBu));
         }
 
-
         /// <summary>
-        /// Donner une réponse à un engagement de manière asynchrone
+        /// Ajouter un filtre pour récupérer les engagements en fonction de plusieurs états d'engagement
         /// </summary>
-        /// <param name="engagementDTO"></param>
-        /// <param name="idEngagement"></param>
+        /// <param name="query"></param>
+        /// <param name="idBUs"></param>
         /// <returns></returns>
-        public async Task<EngagementDTO> RepondreEngagementAsync(EngagementDTO engagementDTO, long? idEngagement)
+        private IQueryable<Engagement> EtatsEngagementFilter(IQueryable<Engagement> query, List<EtatEngagement> etatsEngagement)
         {
+            if (etatsEngagement == null || etatsEngagement.Count <= 0)
+                return query;
 
-            if (!IsEngagementValide(engagementDTO))
-                throw new EngagementInvalidException("Impossible de répondre à l'engagement, des données sont manquants.");
+            return query.Where(engagement => etatsEngagement.Contains(engagement.EtatEngagement));
+        }
 
-            if (engagementDTO.EtatEngagement == EtatEngagement.NonRealisable && string.IsNullOrWhiteSpace(engagementDTO.RaisonNonRealisable))
-                throw new EngagementInvalidException("Impossible de répondre à l'engagement, une raison doit être rensignée lorsqu'un engagement n'est pas réalisé.");
+        /// <summary>
+        /// Ajouter un filtre pour récupérer les engagements en fonction d'une action 
+        /// </summary>
+        /// <param name="query"></param>
+        /// <param name="intitule"></param>
+        /// <returns></returns>
+        private IQueryable<Engagement> ActionFilter(IQueryable<Engagement> query, string action)
+        {
+            if (string.IsNullOrWhiteSpace(action))
+                return query;
 
+            return query.Where(engagement => engagement.Action.ToLower().Contains(action.ToLower()));
+        }
 
-            Engagement engagement = await epContext.Engagement.Include(engagement => engagement.Ep).FirstOrDefaultAsync(engagement => engagement.IdEngagement == idEngagement);
+        /// <summary>
+        /// Ajouter une pagination
+        /// </summary>
+        /// <param name="query"></param>
+        /// <param name="parPage"></param>
+        /// <param name="numPage"></param>
+        /// <returns></returns>
+        private IQueryable<Engagement> SkipAndTake(IQueryable<Engagement> query, int? parPage, int? numPage)
+        {
+            int skip, take;
 
-            if (engagement == null)
-                throw new EngagementNotFoundException();
+            if (!parPage.HasValue || parPage.Value < minParPage || parPage.Value > maxParPage)
+                parPage = defaultParPage;
 
-            engagement.EtatEngagement = engagementDTO.EtatEngagement;
+            if (!numPage.HasValue || numPage.Value <= 0)
+                numPage = defaultNumPage;
 
-            switch (engagement.EtatEngagement)
-            {
-                case EtatEngagement.Respecte:
-                    engagement.EtatEngagement = engagementDTO.EtatEngagement;
-                    engagement.RaisonNonRealisable = null;
-                    break;
-                case EtatEngagement.NonRealisable:
-                    engagement.EtatEngagement = engagementDTO.EtatEngagement;
-                    engagement.RaisonNonRealisable = engagementDTO.RaisonNonRealisable;
-                    break;
-                default:
-                    engagement.EtatEngagement = engagementDTO.EtatEngagement;
-                    engagement.RaisonNonRealisable = null;
-                    break;
-            }
-            await epContext.SaveChangesAsync();
+            skip = (numPage.Value - 1) * parPage.Value;
+            take = parPage.Value;
 
-            return await GetEngagementDTOAsync(engagement);
+            return query.Skip(skip).Take(take);
         }
 
 
-        #endregion
-
-        #region Méthodes Privée
-        private bool IsEngagementValide(EngagementDTO engagementDTO)
-        {
-                return !(engagementDTO == null || engagementDTO.Id == null || engagementDTO.Action == null || engagementDTO.DateLimite == null || engagementDTO.Dispositif == null || engagementDTO.Modalite == null);
-        }
-
         #region Object to DTO
 
         /// <summary>
-        /// Récupère un objet EngagementDTO en fonction d'un objet Engagement
+        /// Récupère un objet EngagementDTO en fonction d'un objet Engagement et d'une liste de CollaborateurDTO
         /// </summary>
         /// <param name="engagement"></param>
         /// <returns></returns>
-        private EngagementDTO GetEngagementDTO(Engagement engagement)
+        private EngagementDTO GetEngagementDTO(Engagement engagement, IEnumerable<CollaborateurDTO> collaborateurDTOs)
         {
             EngagementDTO engagementDTO = new EngagementDTO()
             {
@@ -295,80 +334,67 @@ namespace EPAServeur.Services
                 Modalite = engagement.Modalite,
                 RaisonNonRealisable = engagement.RaisonNonRealisable,
                 EtatEngagement = engagement.EtatEngagement,
-                Ep = GetEpInformationDTO(engagement.Ep)
+                Ep = GetEpInformationDTO(engagement.Ep, collaborateurDTOs)
             };
 
             return engagementDTO;
         }
 
+
         /// <summary>
-        /// Récupère un objet EngagementDTO en fonction d'un objet Engagement
+        /// Récuperer une liste de CollaborateurDTO contenant les collaborateurs et les référents. Retourne null si l'engagement est null.
         /// </summary>
-        /// <param name="engagement"></param>
+        /// <param name="typeFormation"></param>
         /// <returns></returns>
-        private async Task<EngagementDTO> GetEngagementDTOAsync(Engagement engagement)
+        private async Task<IEnumerable<CollaborateurDTO>> GetCollaborateurDTOs(Engagement engagement)
         {
-            EngagementDTO engagementDTO = new EngagementDTO()
-            {
-                Id = engagement.IdEngagement,
-                Action = engagement.Action,
-                DateLimite = engagement.DateLimite,
-                Dispositif = engagement.Dispositif,
-                Modalite = engagement.Modalite,
-                RaisonNonRealisable = engagement.RaisonNonRealisable,
-                EtatEngagement = engagement.EtatEngagement,
-                Ep = await GetEpInformationDTOAsync(engagement.Ep)
-            };
+            List<Guid?> guids = new List<Guid?>();
 
-            return engagementDTO;
+            guids.Add((Guid?)engagement.Ep.IdCollaborateur);
+            guids.Add(engagement.Ep.IdReferent);
+
+            return await collaborateurService.GetCollaborateurDTOsAsync(guids); ;
         }
 
         /// <summary>
-        /// Récupère un objet EpInformationDTO en fonction d'un objet Ep
+        /// Récuperer une liste de CollaborateurDTO contenant les collaborateurs et les référents. Retourne null s'il n'y a aucun engagement.
         /// </summary>
-        /// <param name="ep"></param>
+        /// <param name="typeFormation"></param>
         /// <returns></returns>
-        private EpInformationDTO GetEpInformationDTO(Ep ep)
+        private async Task<IEnumerable<CollaborateurDTO>> GetCollaborateurDTOs(IEnumerable<Engagement> engagements)
         {
-            EpInformationDTO epInformationDTO = new EpInformationDTO()
-            {
-                Id = ep.IdEP,
-                Type = ep.TypeEP,
-                Statut = ep.Statut,
-                DatePrevisionnelle = ep.DatePrevisionnelle,
-                Obligatoire = ep.Obligatoire,
-                //Collaborateur = collaborateurService.GetCollaborateurById(ep.IdCollaborateur),
-                //Referent = referentService.GetReferentById(ep.IdReferent)
-                //Ajouter la date de disponibilité
-            };
+            if (!engagements.Any())
+                return null;
 
-            return epInformationDTO;
+            List<Guid?> guids = engagements.SelectMany(engagement => new[] { (Guid?)engagement.Ep.IdCollaborateur, engagement.Ep.IdReferent }).ToList();
+
+            return await collaborateurService.GetCollaborateurDTOsAsync(guids);
         }
 
         /// <summary>
-        /// Récupère un objet EpInformationDTO en fonction d'un objet Ep
+        /// Récupère un objet EpInformationDTO en fonction d'un objet Ep et d'une liste de CollaborateurDTO
         /// </summary>
         /// <param name="ep"></param>
         /// <returns></returns>
-        private async Task<EpInformationDTO> GetEpInformationDTOAsync(Ep ep)
+        private EpInformationDTO GetEpInformationDTO(Ep ep, IEnumerable<CollaborateurDTO> collaborateurDTOs)
         {
+            CollaborateurDTO collaborateur;
+            CollaborateurDTO referent;
+
+            collaborateur = collaborateurDTOs.FirstOrDefault(collaborateurDTO => collaborateurDTO.Id == ep.IdCollaborateur);
+            referent = collaborateurDTOs.FirstOrDefault(collaborateurDTO => collaborateurDTO.Id == ep.IdReferent);
+
             EpInformationDTO epInformationDTO = new EpInformationDTO()
             {
                 Id = ep.IdEP,
                 Type = ep.TypeEP,
                 Statut = ep.Statut,
+                DateDisponibilite = ep.DateDisponibilite,
                 DatePrevisionnelle = ep.DatePrevisionnelle,
-                Obligatoire = ep.Obligatoire
-                //Ajouter la date de disponibilité
+                Obligatoire = ep.Obligatoire,
+                Collaborateur = collaborateur,
+                Referent = referent,
             };
-            var collaborateur = collaborateurService.GetCollaborateurByIdAsync(ep.IdCollaborateur);
-            var referent = collaborateurService.GetCollaborateurByIdAsync(ep.IdReferent);
-
-            await Task.WhenAll(collaborateur, referent);
-
-            epInformationDTO.Collaborateur = collaborateur.Result;
-            epInformationDTO.Referent = referent.Result;
-
 
             return epInformationDTO;
         }
@@ -378,51 +404,31 @@ namespace EPAServeur.Services
         #region DTO to Object
 
         /// <summary>
-        /// Modifie un objet Engagement en fonction d'un objet FormationDTO
+        /// Modifie la réponse d'un objet Engagement en fonction d'un objet EngagementDTO
         /// </summary>
         /// <param name="engagement"></param>
         /// <param name="engagementDTO"></param>
         /// <returns></returns>
-        private Engagement SetEngagement(Engagement engagement, EngagementDTO engagementDTO)
+        private Engagement SetReponseEngagement(Engagement engagement, EngagementDTO engagementDTO)
         {
-            engagement.Action = engagementDTO.Action;
-            engagement.DateLimite = engagementDTO.DateLimite.Value;
-            engagement.Dispositif = engagementDTO.Dispositif;
-            engagement.Modalite = engagementDTO.Modalite;
-            engagement.RaisonNonRealisable = engagementDTO.RaisonNonRealisable;
             engagement.EtatEngagement = engagementDTO.EtatEngagement;
-            engagement.Ep = GetEp(engagementDTO.Ep);
 
-
-            return engagement;
-        }
-
-        /// <summary>
-        /// Récupère un objet Ep en fonction d'un objet EpDTO
-        /// </summary>
-        /// <param name="origineFormationDTO"></param>
-        /// <returns></returns>
-        private Ep GetEp(EpInformationDTO epInformationDTO)
-        {
-            if (epInformationDTO == null)
-                return null;
-
-            Ep ep = new Ep()
+            switch (engagement.EtatEngagement)
             {
-                IdEP = epInformationDTO.Id.Value,
-                TypeEP = epInformationDTO.Type,
-                Statut = epInformationDTO.Statut,
-                DatePrevisionnelle = epInformationDTO.DatePrevisionnelle.Value,
-                Obligatoire = epInformationDTO.Obligatoire.Value,
-                IdReferent = epInformationDTO.Referent.Id.Value,
-                IdCollaborateur = epInformationDTO.Collaborateur.Id.Value,
-                // Ajouter la date de disponibilité
-            };
-
-            return ep;
+                case EtatEngagement.NonRealisable:
+                    engagement.RaisonNonRealisable = engagementDTO.RaisonNonRealisable;
+                    break;
+                case EtatEngagement.DateLimitePassee:
+                    engagement.RaisonNonRealisable = "La date limite pour respecter l'engagement est passée.";
+                    break;
+                default:
+                    engagement.RaisonNonRealisable = null;
+                    break;
+            }
+  
+            return engagement;
         }
 
-
         #endregion
 
         #endregion