You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
853 lines
36 KiB
853 lines
36 KiB
using EPAServeur.Context;
|
|
using EPAServeur.Exceptions;
|
|
using EPAServeur.IServices;
|
|
using EPAServeur.Models.EP;
|
|
using EPAServeur.Models.Formation;
|
|
using IO.Swagger.DTO;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
|
|
namespace EPAServeur.Services
|
|
{
|
|
public class FormationService : IFormationService
|
|
{
|
|
#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;
|
|
|
|
/// <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
|
|
|
|
/// <summary>
|
|
/// Constructeur de la classe FormationService
|
|
/// </summary>
|
|
/// <param name="_epContext"></param>
|
|
public FormationService(EpContext _epContext, ICollaborateurService _collaborateurService)
|
|
{
|
|
epContext = _epContext;
|
|
collaborateurService = _collaborateurService;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Méthodes Service
|
|
|
|
/// <summary>
|
|
/// Récupérer une formation par son id de manière asynchrone
|
|
/// </summary>
|
|
/// <param name="idFormation"></param>
|
|
/// <returns></returns>
|
|
public async Task<FormationDTO> GetFormationByIdAsync(long idFormation)
|
|
{
|
|
Formation formation = await epContext.Formation.Include(formation => formation.Statut)
|
|
.Include(formation => formation.ModeFormation)
|
|
.Include(formation => formation.Origine)
|
|
.Include(formation => formation.TypeFormation)
|
|
.Include(formation => formation.ParticipationsFormation)
|
|
.ThenInclude(participation => participation.DemandeFormation)
|
|
.ThenInclude(demande => demande.Ep)
|
|
.FirstOrDefaultAsync(formation => formation.IdFormation == idFormation);
|
|
|
|
if (formation == null)
|
|
throw new FormationNotFoundException(string.Format("Aucune formation trouvée avec l'id suivant: {0}.", idFormation));
|
|
|
|
|
|
IEnumerable<CollaborateurDTO> collaborateurDTOs = await GetCollaborateurDTOs(formation.ParticipationsFormation);
|
|
|
|
return GetFormationDTO(formation, collaborateurDTOs);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Récupérer la liste des formations de manière asynchrone
|
|
/// </summary>
|
|
/// <param name="asc">Préciser si les données sont dans l'ordre (true) ou dans l'ordre inverse (false)</param>
|
|
/// <param name="numPage">Numéro de la page du tableau qui affiche les données</param>
|
|
/// <param name="parPage">Nombre d'éléments affiché sur chaque page du tableau</param>
|
|
/// <param name="idAgence">id de l'agence à laquelle sont rattachées les données à récupérer</param>
|
|
/// <param name="texte">Texte permettant d'identifier l'objet rechercher</param>
|
|
/// <param name="tri">Colonne du tableau sur lequel le tri s'effectue</param>
|
|
/// <returns></returns>
|
|
public async Task<IEnumerable<FormationDetailsDTO>> GetFormationsAsync(long? idAgence, List<int?> idStatuts, bool? asc, int? numPage, int? parPage, string texte, string tri, DateTime? dateDebut, DateTime? dateFin)
|
|
{
|
|
IQueryable<Formation> query;
|
|
IEnumerable<Formation> formations;
|
|
IEnumerable<FormationDetailsDTO> formationDTOs;
|
|
|
|
query = epContext.Formation
|
|
.Include(formation => formation.Statut)
|
|
.Include(formation => formation.ModeFormation)
|
|
.Include(formation => formation.Origine)
|
|
.Include(formation => formation.TypeFormation)
|
|
.Include(formation => formation.ParticipationsFormation);
|
|
|
|
query = IdStatutsFilter(query, idStatuts);
|
|
|
|
query = IdAgenceFilter(query, idAgence);
|
|
|
|
query = IntituleFilter(query, texte);
|
|
|
|
query = DateFilter(query, dateDebut, dateFin);
|
|
|
|
query = OrderByColumn(query, asc, tri);
|
|
|
|
query = SkipAndTake(query, parPage, numPage);
|
|
|
|
formations = await query.ToListAsync();
|
|
|
|
formationDTOs = formations.Select(formation => GetFormationDetailsDTO(formation));
|
|
|
|
return formationDTOs;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Récupérer le nombre total de formations de manière asynchrone
|
|
/// </summary>
|
|
/// <param name="numPage">Numéro de la page du tableau qui affiche les données</param>
|
|
/// <param name="parPage">Nombre d'éléments affiché sur chaque page du tableau</param>
|
|
/// <param name="idAgence">id de l'agence à laquelle sont rattachées les données à récupérer</param>
|
|
/// <param name="texte">Texte permettant d'identifier l'objet rechercher</param>
|
|
/// <returns></returns>
|
|
public async Task<long> GetFormationsCountAsync(long? idAgence, List<int?> idStatuts, string texte, DateTime? dateDebut, DateTime? dateFin)
|
|
{
|
|
IQueryable<Formation> query;
|
|
long count;
|
|
|
|
|
|
query = epContext.Formation
|
|
.Include(formation => formation.Statut)
|
|
.Include(formation => formation.ModeFormation)
|
|
.Include(formation => formation.Origine)
|
|
.Include(formation => formation.TypeFormation)
|
|
.Include(formation => formation.ParticipationsFormation);
|
|
|
|
query = IntituleFilter(query, texte);
|
|
|
|
query = IdStatutsFilter(query, idStatuts);
|
|
|
|
query = IdAgenceFilter(query, idAgence);
|
|
|
|
query = DateFilter(query, dateDebut, dateFin);
|
|
|
|
count = await query.CountAsync();
|
|
|
|
return count;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Récupérer les modes de formation de manière asynchrone
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public async Task<IEnumerable<ModeFormationDTO>> GetModesFormationAsync()
|
|
{
|
|
IEnumerable<ModeFormation> modeFormations;
|
|
IEnumerable<ModeFormationDTO> modeFormationDTOs;
|
|
|
|
modeFormations = await epContext.ModeFormation.ToListAsync();
|
|
|
|
modeFormationDTOs = modeFormations.Select(modeFormation => GetModeFormationDTO(modeFormation));
|
|
|
|
return modeFormationDTOs;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Récupérer les origines de formation de manière asynchrone
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public async Task<IEnumerable<OrigineFormationDTO>> GetOriginesFormationAsync()
|
|
{
|
|
IEnumerable<OrigineFormation> origineFormations;
|
|
IEnumerable<OrigineFormationDTO> origineFormationDTOs;
|
|
|
|
origineFormations = await epContext.OrigineFormation.ToListAsync();
|
|
|
|
origineFormationDTOs = origineFormations.Select(origineFormation => GetOrigineFormationDTO(origineFormation));
|
|
|
|
return origineFormationDTOs;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Récupérer les statuts de formation de manière asynchrone
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public async Task<IEnumerable<StatutFormationDTO>> GetStatutsFormationAsync()
|
|
{
|
|
IEnumerable<StatutFormation> statutFormations;
|
|
IEnumerable<StatutFormationDTO> statutFormationDTOs;
|
|
|
|
statutFormations = await epContext.StatutFormation.ToListAsync();
|
|
|
|
statutFormationDTOs = statutFormations.Select(statutFormation => GetStatutFormationDTO(statutFormation));
|
|
|
|
return statutFormationDTOs;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Récupérer les types de formation de manière asynchrone
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public async Task<IEnumerable<TypeFormationDTO>> GetTypesFormationAsync()
|
|
{
|
|
IEnumerable<TypeFormation> typeFormations;
|
|
IEnumerable<TypeFormationDTO> typeFormationDTOs;
|
|
|
|
typeFormations = await epContext.TypeFormation.ToListAsync();
|
|
|
|
typeFormationDTOs = typeFormations.Select(typeFormation => GetTypeFormationDTO(typeFormation));
|
|
|
|
return typeFormationDTOs;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Ajouter une formation de manière asynchrone
|
|
/// </summary>
|
|
/// <param name="formationDTO"></param>
|
|
/// <returns></returns>
|
|
public async Task<FormationDTO> AddFormationAsync(FormationDTO formationDTO)
|
|
{
|
|
IsFormationValide(formationDTO);
|
|
|
|
Formation formation = new Formation();
|
|
formation = SetFormation(formation, formationDTO);
|
|
|
|
epContext.StatutFormation.Attach(formation.Statut);
|
|
epContext.OrigineFormation.Attach(formation.Origine);
|
|
epContext.ModeFormation.Attach(formation.ModeFormation);
|
|
epContext.TypeFormation.Attach(formation.TypeFormation);
|
|
epContext.Add(formation);
|
|
|
|
await epContext.SaveChangesAsync();
|
|
|
|
return GetFormationDTO(formation);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Modifier une formation de manière asynchrone
|
|
/// </summary>
|
|
/// <param name="idFormation"></param>
|
|
/// <param name="formationDTO"></param>
|
|
/// <returns></returns>
|
|
public async Task<FormationDTO> UpdateFormationAsync(long idFormation, FormationDTO formationDTO)
|
|
{
|
|
if (!formationDTO.Id.HasValue || formationDTO.Id.Value != idFormation)
|
|
throw new FormationIncompatibleIdException("L'id de la formation a mettre à jour et la formation a mettre à jour sont incompatble.");
|
|
|
|
IsFormationValide(formationDTO);
|
|
|
|
Formation formation = await epContext.Formation.FindAsync(idFormation);
|
|
|
|
if (formation == null)
|
|
throw new FormationNotFoundException(string.Format("Aucune formation trouvée avec l'id suivant: {0}.", idFormation));
|
|
|
|
|
|
formation = SetFormation(formation, formationDTO);
|
|
await epContext.SaveChangesAsync();
|
|
|
|
return GetFormationDTO(formation);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Supprimer une formation de manière asynchrone
|
|
/// </summary>
|
|
/// <param name="idFormation"></param>
|
|
/// <returns></returns>
|
|
public async Task<FormationDTO> DeleteFormationByIdAsync(long idFormation)
|
|
{
|
|
Formation formation = await epContext.Formation.FindAsync(idFormation);
|
|
|
|
if (formation == null)
|
|
throw new FormationNotFoundException(string.Format("Aucune formation trouvée avec l'id suivant: {0}.", idFormation));
|
|
|
|
epContext.Remove(formation);
|
|
|
|
await epContext.SaveChangesAsync();
|
|
|
|
return GetFormationDTO(formation);
|
|
}
|
|
#endregion
|
|
|
|
#region Méthodes Privée
|
|
/// <summary>
|
|
/// Vérifier si un objet FormationDTO est valide pour ajout ou mise à jour
|
|
/// </summary>
|
|
/// <remarks> Un objet FormationDTO est valide si aucune de ses propriétés n'est à null,si la date de début de la formation est inférieur à la date de fin et si le statut, l'origine,le mode et le type sont présents dans la base de données</remarks>
|
|
/// <param name="formation"></param>
|
|
/// <returns>true si l'objet est valide, false sinon</returns>
|
|
private void IsFormationValide(FormationDTO formation)
|
|
{
|
|
// Vérifier que la formation n'est pas null
|
|
if (formation == null)
|
|
throw new FormationInvalidException("Aucune formation n'a été reçue");
|
|
|
|
// Vérfier que la formation a bien un statut de formation
|
|
if (formation.Statut == null || !formation.Statut.Id.HasValue)
|
|
throw new FormationInvalidException("Impossible d'enregistrer une formation sans statut de formation.");
|
|
|
|
// Vérfier que la formation a bien un mode de formation
|
|
if (formation.Mode == null || !formation.Mode.Id.HasValue)
|
|
throw new FormationInvalidException("Impossible d'enregistrer une formation sans mode de formation.");
|
|
|
|
// Vérfier que la formation a bien une origine de formation
|
|
if (formation.Origine == null || !formation.Origine.Id.HasValue)
|
|
throw new FormationInvalidException("Impossible d'enregistrer une formation sans origine de formation.");
|
|
|
|
// Vérfier que la formation a bien un type de formation
|
|
if (formation.Type == null || !formation.Type.Id.HasValue)
|
|
throw new FormationInvalidException("Impossible d'enregistrer une formation sans type de formation.");
|
|
|
|
// Vérfier que la formation a bien une agence
|
|
if (!formation.IdAgence.HasValue || formation.IdAgence == 0)
|
|
throw new FormationInvalidException("Impossible d'enregistrer une formation sans mode de formation.");
|
|
|
|
// Vérifier que la formation a bien un intitulé
|
|
if (string.IsNullOrWhiteSpace(formation.Intitule))
|
|
throw new FormationInvalidException("L'intitulé de la formation doit contenir au moins 1 caractère.");
|
|
|
|
// Vérifier que la formation a bien un organisme
|
|
if (string.IsNullOrWhiteSpace(formation.Organisme))
|
|
throw new FormationInvalidException("L'organisme de la formation doit contenir au moins 1 caractère.");
|
|
|
|
// Vérifier que la formation a bien une date de début
|
|
if (!formation.DateDebut.HasValue)
|
|
throw new FormationInvalidException("Impossible d'enregistrer une formation sans date de début de formation.");
|
|
|
|
// Vérifier que la formation a bien une date de fin
|
|
if (!formation.DateFin.HasValue)
|
|
throw new FormationInvalidException("Impossible d'enregistrer une formation sans date de fin de formation.");
|
|
|
|
// Vérifier que la formation a bien une date de début inférieure à la date de fin
|
|
if (formation.DateDebut.Value > formation.DateFin.Value)
|
|
throw new FormationInvalidException("La date de début de la formation est supérieure à la date de fin.");
|
|
|
|
// Vérfier que le statut de la formation est présent dans la BDD
|
|
if (!epContext.StatutFormation.Any(statut => statut.IdStatutFormation == formation.Statut.Id.Value && statut.Libelle == formation.Statut.Libelle))
|
|
throw new FormationInvalidException("Le statut de la formation n'existe pas.");
|
|
|
|
// Vérfier que le mode de la formation est présent dans la BDD
|
|
if (!epContext.ModeFormation.Any(mode => mode.IdModeFormation == formation.Mode.Id.Value && mode.Libelle == formation.Mode.Libelle))
|
|
throw new FormationInvalidException("Le mode de la formation n'existe pas.");
|
|
|
|
// Vérfier que l'orgine de la formation est présente dans la BDD
|
|
if (!epContext.OrigineFormation.Any(origine => origine.IdOrigineFormation == formation.Origine.Id.Value && origine.Libelle == formation.Origine.Libelle))
|
|
throw new FormationInvalidException("L'origine de la formation n'existe pas.");
|
|
|
|
// Vérfier que le type de la formation est présent dans la BDD
|
|
if (!epContext.TypeFormation.Any(type => type.IdTypeFormation == formation.Type.Id.Value && type.Libelle == formation.Type.Libelle))
|
|
throw new FormationInvalidException("Le type de la formation n'existe pas.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Ajouter un ordonnancement croissant ou décroissant sur colonne
|
|
/// </summary>
|
|
/// <param name="query"></param>
|
|
/// <param name="idStatuts"></param>
|
|
/// <returns></returns>
|
|
private IQueryable<Formation> OrderByColumn(IQueryable<Formation> query, bool? asc, string columnName)
|
|
{
|
|
if (!asc.HasValue)
|
|
asc = defaultAsc;
|
|
|
|
if (string.IsNullOrWhiteSpace(columnName))
|
|
{
|
|
if (asc.Value)
|
|
return query.OrderBy(p => p.Intitule);
|
|
else
|
|
return query.OrderByDescending(p => p.Intitule);
|
|
}
|
|
|
|
switch (columnName.ToLower())
|
|
{
|
|
case "intitule":
|
|
if (asc.Value)
|
|
return query.OrderBy(p => p.Intitule);
|
|
else
|
|
return query.OrderByDescending(p => p.Intitule);
|
|
case "statut":
|
|
if (asc.Value)
|
|
return query.OrderBy(p => p.Statut.Libelle);
|
|
else
|
|
return query.OrderByDescending(p => p.Statut.Libelle);
|
|
case "origine":
|
|
if (asc.Value)
|
|
return query.OrderBy(p => p.Origine.Libelle);
|
|
else
|
|
return query.OrderByDescending(p => p.Origine.Libelle);
|
|
case "date":
|
|
if (asc.Value)
|
|
return query.OrderBy(p => p.DateDebut);
|
|
else
|
|
return query.OrderByDescending(p => p.DateDebut);
|
|
case "certification":
|
|
if (asc.Value)
|
|
return query.OrderBy(p => p.EstCertifiee);
|
|
else
|
|
return query.OrderByDescending(p => p.EstCertifiee);
|
|
default:
|
|
if (asc.Value)
|
|
return query.OrderBy(p => p.Intitule);
|
|
else
|
|
return query.OrderByDescending(p => p.Intitule);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Ajouter un filtre pour récupérer les formations en fonction de plusieurs identifiants de statut de formation
|
|
/// </summary>
|
|
/// <param name="query"></param>
|
|
/// <param name="idStatuts"></param>
|
|
/// <returns></returns>
|
|
private IQueryable<Formation> IdStatutsFilter(IQueryable<Formation> query, List<int?> idStatuts)
|
|
{
|
|
if (idStatuts != null && idStatuts.Count > 0 && idStatuts.First().HasValue)
|
|
return query.Where(formation => idStatuts.Contains(formation.Statut.IdStatutFormation));
|
|
else
|
|
return query;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Ajouter un filtre pour récupérer les formations en fonction de l'identifiant d'une agence
|
|
/// </summary>
|
|
/// <param name="query"></param>
|
|
/// <param name="idAgence"></param>
|
|
/// <returns></returns>
|
|
private IQueryable<Formation> IdAgenceFilter(IQueryable<Formation> query, long? idAgence)
|
|
{
|
|
if (idAgence != null)
|
|
return query.Where(formation => formation.IdAgence == idAgence);
|
|
else
|
|
return query;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Ajouter un filtre pour récupérer les formations en fonction d'un intitulé
|
|
/// </summary>
|
|
/// <param name="query"></param>
|
|
/// <param name="intitule"></param>
|
|
/// <returns></returns>
|
|
private IQueryable<Formation> IntituleFilter(IQueryable<Formation> query, string intitule)
|
|
{
|
|
if (!string.IsNullOrWhiteSpace(intitule))
|
|
return query.Where(formation => formation.Intitule.ToLower().Contains(intitule.ToLower()));
|
|
else
|
|
return query;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Ajouter un filtre pour récupérer les formations en fonction d'un intervalle de date
|
|
/// </summary>
|
|
/// <param name="query"></param>
|
|
/// <param name="dateDebut"></param>
|
|
/// <param name="dateFin"></param>
|
|
/// <returns></returns>
|
|
private IQueryable<Formation> DateFilter(IQueryable<Formation> query, DateTime? dateDebut, DateTime? dateFin)
|
|
{
|
|
if (dateDebut.HasValue && dateFin.HasValue)
|
|
return query.Where(formation => formation.DateDebut >= dateDebut.Value && formation.DateFin <= dateFin.Value.AddDays(1));
|
|
else if (!dateDebut.HasValue && dateFin.HasValue)
|
|
return query.Where(formation => formation.DateFin <= dateFin.Value.AddDays(1));
|
|
else if (dateDebut.HasValue && !dateFin.HasValue)
|
|
return query.Where(formation => formation.DateDebut >= dateDebut.Value);
|
|
else
|
|
return query;
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Ajouter une pagination
|
|
/// </summary>
|
|
/// <param name="query"></param>
|
|
/// <param name="parPage"></param>
|
|
/// <param name="numPage"></param>
|
|
/// <returns></returns>
|
|
private IQueryable<Formation> SkipAndTake(IQueryable<Formation> query, int? parPage, int? numPage)
|
|
{
|
|
int skip, take;
|
|
|
|
if (!parPage.HasValue || parPage.Value < minParPage || parPage.Value > maxParPage)
|
|
parPage = defaultParPage;
|
|
|
|
if (!numPage.HasValue || numPage.Value <= 0)
|
|
numPage = defaultNumPage;
|
|
|
|
|
|
skip = (numPage.Value - 1) * parPage.Value;
|
|
take = parPage.Value;
|
|
|
|
return query.Skip(skip).Take(take);
|
|
}
|
|
|
|
|
|
#region Object to DTO
|
|
/// <summary>
|
|
/// Récuperer un objet FormationDTO en fonction d'un objet Formation
|
|
/// </summary>
|
|
/// <param name="formation"></param>
|
|
/// <returns></returns>
|
|
private FormationDTO GetFormationDTO(Formation formation)
|
|
{
|
|
FormationDTO formationDTO = new FormationDTO()
|
|
{
|
|
Id = formation.IdFormation,
|
|
Intitule = formation.Intitule,
|
|
IdAgence = formation.IdAgence,
|
|
DateDebut = formation.DateDebut,
|
|
DateFin = formation.DateFin,
|
|
Heure = formation.Heure,
|
|
Jour = formation.Jour,
|
|
Organisme = formation.Organisme,
|
|
EstCertifiee = formation.EstCertifiee,
|
|
Origine = GetOrigineFormationDTO(formation.Origine),
|
|
Statut = GetStatutFormationDTO(formation.Statut),
|
|
Mode = GetModeFormationDTO(formation.ModeFormation),
|
|
Type = GetTypeFormationDTO(formation.TypeFormation),
|
|
};
|
|
|
|
return formationDTO;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Récuperer un objet FormationDTO avec des participations en fonction d'un objet Formation et d'une liste de CollaborateurDTO
|
|
/// </summary>
|
|
/// <param name="formation"></param>
|
|
/// <returns></returns>
|
|
private FormationDTO GetFormationDTO(Formation formation, IEnumerable<CollaborateurDTO> collaborateurDTOs)
|
|
{
|
|
FormationDTO formationDTO = new FormationDTO()
|
|
{
|
|
Id = formation.IdFormation,
|
|
Intitule = formation.Intitule,
|
|
IdAgence = formation.IdAgence,
|
|
DateDebut = formation.DateDebut,
|
|
DateFin = formation.DateFin,
|
|
Heure = formation.Heure,
|
|
Jour = formation.Jour,
|
|
Organisme = formation.Organisme,
|
|
EstCertifiee = formation.EstCertifiee,
|
|
EstRealisee = formation.EstRealisee,
|
|
Origine = GetOrigineFormationDTO(formation.Origine),
|
|
Statut = GetStatutFormationDTO(formation.Statut),
|
|
Mode = GetModeFormationDTO(formation.ModeFormation),
|
|
Type = GetTypeFormationDTO(formation.TypeFormation),
|
|
Participations = GetParticipationsFormationDTO(formation.ParticipationsFormation, collaborateurDTOs)
|
|
};
|
|
|
|
return formationDTO;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Récuperer un objet FormationDetailsDTO en fonction d'un objet Formation
|
|
/// </summary>
|
|
/// <param name="formation"></param>
|
|
/// <returns></returns>
|
|
private FormationDetailsDTO GetFormationDetailsDTO(Formation formation)
|
|
{
|
|
FormationDetailsDTO formationDTO = new FormationDetailsDTO()
|
|
{
|
|
Id = formation.IdFormation,
|
|
Intitule = formation.Intitule,
|
|
DateDebut = formation.DateDebut,
|
|
DateFin = formation.DateFin,
|
|
Organisme = formation.Organisme,
|
|
EstCertifiee = formation.EstCertifiee,
|
|
NbParticipations = formation.ParticipationsFormation.Count,
|
|
Origine = GetOrigineFormationDTO(formation.Origine),
|
|
Statut = GetStatutFormationDTO(formation.Statut),
|
|
};
|
|
|
|
return formationDTO;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Récuperer un objet OrigineFormationDTO en fonction d'un objet OrigineFormation
|
|
/// </summary>
|
|
/// <param name="origineFormation"></param>
|
|
/// <returns></returns>
|
|
private OrigineFormationDTO GetOrigineFormationDTO(OrigineFormation origineFormation)
|
|
{
|
|
if (origineFormation == null)
|
|
return null;
|
|
OrigineFormationDTO origineFormationDTO = new OrigineFormationDTO()
|
|
{
|
|
Id = origineFormation.IdOrigineFormation,
|
|
Libelle = origineFormation.Libelle
|
|
};
|
|
return origineFormationDTO;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Récuperer un objet StatutFormationDTO en fonction d'un objet StatutFormation
|
|
/// </summary>
|
|
/// <param name="statutFormation"></param>
|
|
/// <returns></returns>
|
|
private StatutFormationDTO GetStatutFormationDTO(StatutFormation statutFormation)
|
|
{
|
|
if (statutFormation == null)
|
|
return null;
|
|
StatutFormationDTO statutFormationDTO = new StatutFormationDTO()
|
|
{
|
|
Id = statutFormation.IdStatutFormation,
|
|
Libelle = statutFormation.Libelle
|
|
};
|
|
return statutFormationDTO;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Récuperer un objet ModeFormationDTO en fonction d'un objet ModeFormation
|
|
/// </summary>
|
|
/// <param name="modeFormation"></param>
|
|
/// <returns></returns>
|
|
private ModeFormationDTO GetModeFormationDTO(ModeFormation modeFormation)
|
|
{
|
|
if (modeFormation == null)
|
|
return null;
|
|
ModeFormationDTO modeFormationDTO = new ModeFormationDTO()
|
|
{
|
|
Id = modeFormation.IdModeFormation,
|
|
Libelle = modeFormation.Libelle
|
|
};
|
|
return modeFormationDTO;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Récuperer un objet TypeFormationDTO en fonction d'un objet TypeFormation
|
|
/// </summary>
|
|
/// <param name="typeFormation"></param>
|
|
/// <returns></returns>
|
|
private TypeFormationDTO GetTypeFormationDTO(TypeFormation typeFormation)
|
|
{
|
|
if (typeFormation == null)
|
|
return null;
|
|
TypeFormationDTO typeFormationDTO = new TypeFormationDTO()
|
|
{
|
|
Id = typeFormation.IdTypeFormation,
|
|
Libelle = typeFormation.Libelle
|
|
};
|
|
return typeFormationDTO;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Récuperer une liste de CollaborateurDTO contenant les collaborateurs et les référents. Retourne null s'il n'y a aucune participation.
|
|
/// </summary>
|
|
/// <param name="typeFormation"></param>
|
|
/// <returns></returns>
|
|
private async Task<IEnumerable<CollaborateurDTO>> GetCollaborateurDTOs(List<ParticipationFormation> participationsFormation)
|
|
{
|
|
if (participationsFormation.Count == 0)
|
|
return null;
|
|
|
|
List<Guid?> guids = participationsFormation.SelectMany(participationFormation => new[] { (Guid?)participationFormation.DemandeFormation.Ep.IdCollaborateur, participationFormation.DemandeFormation.Ep.IdReferent }).ToList();
|
|
|
|
return await collaborateurService.GetCollaborateurDTOsAsync(guids); ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Récuperer une liste de ParticipationFormationDTO en fonction d'une liste de ParticipationFormation et d'une liste de CollaborateurDTO. Retourne null s'il n'y a aucune participation ou aucun collaborateur.
|
|
/// </summary>
|
|
/// <param name="typeFormation"></param>
|
|
/// <returns></returns>
|
|
private List<ParticipationFormationDTO> GetParticipationsFormationDTO(List<ParticipationFormation> participationsFormation, IEnumerable<CollaborateurDTO> collaborateurDTOs)
|
|
{
|
|
List<ParticipationFormationDTO> participationFormationDTOs;
|
|
|
|
if (participationsFormation == null || participationsFormation.Count == 0 || collaborateurDTOs == null || !collaborateurDTOs.Any())
|
|
return null;
|
|
|
|
participationFormationDTOs = participationsFormation.Select(participationFormation => GetParticipationFormationDTO(participationFormation, collaborateurDTOs))
|
|
.OrderBy(participationFormation => participationFormation.Collaborateur.Nom)
|
|
.ThenBy(participationFormation => participationFormation.Collaborateur.Prenom).ToList();
|
|
|
|
return participationFormationDTOs;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Récuperer un objet ParticipationFormationDTO en fonction d'un objet ParticipationFormation et d'une liste de CollaborateurDTO
|
|
/// </summary>
|
|
/// <param name="participationFormation"></param>
|
|
/// <returns></returns>
|
|
private ParticipationFormationDTO GetParticipationFormationDTO(ParticipationFormation participationFormation, IEnumerable<CollaborateurDTO> collaborateurDTOs)
|
|
{
|
|
ParticipationFormationDTO participationFormationDTO = new ParticipationFormationDTO()
|
|
{
|
|
Id = participationFormation.IdParticipationFormation,
|
|
DateCreation = participationFormation.DateCreation,
|
|
Intitule = participationFormation.Formation.Intitule,
|
|
DateDebut = participationFormation.Formation.DateDebut,
|
|
Statut = GetStatutFormationDTO(participationFormation.Formation.Statut),
|
|
Collaborateur = GetCollaborateurDTO(participationFormation, collaborateurDTOs),
|
|
Ep = GetEpInformationDTO(participationFormation.DemandeFormation.Ep, collaborateurDTOs)
|
|
};
|
|
|
|
return participationFormationDTO;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Récupère un objet CollaborateurDTO en fonction d'un objet ParticipationFormation et d'une liste de CollaborateurDTO
|
|
/// </summary>
|
|
/// <param name="participationFormation"></param>
|
|
/// <returns></returns>
|
|
private CollaborateurDTO GetCollaborateurDTO(ParticipationFormation participationFormation, IEnumerable<CollaborateurDTO> collaborateurDTOs)
|
|
{
|
|
return collaborateurDTOs.FirstOrDefault(collaborateurDTO => collaborateurDTO.Id == participationFormation.DemandeFormation.Ep.IdCollaborateur);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 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 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,
|
|
Collaborateur = collaborateur,
|
|
Referent = referent,
|
|
};
|
|
|
|
return epInformationDTO;
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
#region DTO to Object
|
|
|
|
/// <summary>
|
|
/// Modifier un objet Formation en fonction d'un objet FormationDTO
|
|
/// </summary>
|
|
/// <param name="formation"></param>
|
|
/// <param name="formationDTO"></param>
|
|
/// <returns></returns>
|
|
private Formation SetFormation(Formation formation, FormationDTO formationDTO)
|
|
{
|
|
formation.Intitule = formationDTO.Intitule;
|
|
formation.IdAgence = formationDTO.IdAgence.Value;
|
|
formation.DateDebut = formationDTO.DateDebut.Value;
|
|
formation.DateFin = formationDTO.DateFin.Value;
|
|
formation.Heure = Convert.ToInt32(formationDTO.Heure.Value);
|
|
formation.Jour = Convert.ToInt32(formationDTO.Jour.Value);
|
|
formation.Organisme = formationDTO.Organisme;
|
|
formation.EstCertifiee = formationDTO.EstCertifiee.Value;
|
|
//formation.EstRealisee = formationDTO.EstRealisee.Value;
|
|
formation.Origine = GetOrigineFormation(formationDTO.Origine);
|
|
formation.Statut = GetStatutFormation(formationDTO.Statut);
|
|
formation.ModeFormation = GetModeFormation(formationDTO.Mode);
|
|
formation.TypeFormation = GetTypeFormation(formationDTO.Type);
|
|
|
|
return formation;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Récuperer un objet OrigineFormation en fonction d'un objet OrigineFormationDTO
|
|
/// </summary>
|
|
/// <param name="origineFormationDTO"></param>
|
|
/// <returns></returns>
|
|
private OrigineFormation GetOrigineFormation(OrigineFormationDTO origineFormationDTO)
|
|
{
|
|
OrigineFormation origineFormation = new OrigineFormation()
|
|
{
|
|
IdOrigineFormation = origineFormationDTO.Id.Value,
|
|
Libelle = origineFormationDTO.Libelle
|
|
};
|
|
return origineFormation;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Récuperer un objet StatutFormation en fonction d'un objet StatutFormationDTO
|
|
/// </summary>
|
|
/// <param name="statutFormationDTO"></param>
|
|
/// <returns></returns>
|
|
private StatutFormation GetStatutFormation(StatutFormationDTO statutFormationDTO)
|
|
{
|
|
StatutFormation statutFormation = new StatutFormation()
|
|
{
|
|
IdStatutFormation = statutFormationDTO.Id.Value,
|
|
Libelle = statutFormationDTO.Libelle
|
|
};
|
|
return statutFormation;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Récuperer un objet ModeFormation en fonction d'un objet ModeFormationDTO
|
|
/// </summary>
|
|
/// <param name="modeFormationDTO"></param>
|
|
/// <returns></returns>
|
|
private ModeFormation GetModeFormation(ModeFormationDTO modeFormationDTO)
|
|
{
|
|
ModeFormation modeFormation = new ModeFormation()
|
|
{
|
|
IdModeFormation = modeFormationDTO.Id.Value,
|
|
Libelle = modeFormationDTO.Libelle
|
|
};
|
|
return modeFormation;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Récuperer un objet TypeFormation en fonction d'un objet TypeFormationDTO
|
|
/// </summary>
|
|
/// <param name="typeFormationDTO"></param>
|
|
/// <returns></returns>
|
|
private TypeFormation GetTypeFormation(TypeFormationDTO typeFormationDTO)
|
|
{
|
|
TypeFormation typeFormation = new TypeFormation()
|
|
{
|
|
IdTypeFormation = typeFormationDTO.Id.Value,
|
|
Libelle = typeFormationDTO.Libelle
|
|
};
|
|
return typeFormation;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
}
|
|
}
|
|
|