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.
Digitalisation_EPA_Serveur/EPAServeur/Services/NoteService.cs

397 lines
15 KiB

using EPAServeur.Context;
using EPAServeur.Exceptions;
using EPAServeur.IServices;
using EPAServeur.Models.Notes;
using IO.Swagger.ApiCollaborateur;
using IO.Swagger.DTO;
using IO.Swagger.ModelCollaborateur;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading.Tasks;
namespace EPAServeur.Services
{
/// <summary>
/// Service permettant de gérer les notes (ajout, récupération, mise à jour, suppression)
/// </summary>
public class NoteService : INoteService
{
#region Variables
/*
/// <summary>
/// Service collaborateur pour récupérer les données collaborateurs
/// </summary>
private readonly ICollaborateurService collaborateurService;
*/
private readonly ICollaborateurApi collaborateurApi;
/// <summary>
/// Contexte pour interagir avec la base de données MySQL du serveur EP
/// </summary>
private readonly EpContext context;
#endregion
#region Constructeurs
public NoteService(ICollaborateurApi _collaborateurApi, EpContext _context)
{
//collaborateurService = _collaborateurService;
collaborateurApi = _collaborateurApi;
context = _context;
}
#endregion
#region Services Sync
/// <summary>
/// Ajouter une nouvelle note dans la base de données
/// </summary>
/// <param name="nouvelleNote">La nouvelle note a ajouté en base</param>
/// <returns>La nouvelle note ajouté</returns>
public DetailsNoteDTO AjouterNote(DetailsNoteDTO nouvelleNote)
{
//vérifier qu'il n'y a aucune valeur null
CheckNoteValide(nouvelleNote);
//vérifier que le référent existe
Collaborateur auteur = collaborateurApi.ChercherCollabId(nouvelleNote.IdAuteur);
CheckReferent(auteur);
//vérifier que le collaborateur existe
Collaborateur collaborateur = collaborateurApi.ChercherCollabId(nouvelleNote.Collaborateur.Id);
CheckCollaborateur(collaborateur);
//transformer la note DTO en Note
Note note = DetailsNoteDTOToNouvelleNote(nouvelleNote);
//ajouter la note et sauvegarder
context.Note.Add(note);
context.SaveChanges();
nouvelleNote.Id = note.IdNote;
return nouvelleNote;
}
// <summary>
/// Supprimer une note en fonction de son Id de manière async
/// </summary>
/// <param name="idNote">Id de la note à supprimer</param>
public void SupprimerNote(long? idNote)
{
Note note = context.Note.Find(idNote);
if (note != null)
{
context.Remove(note);
context.SaveChanges();
}
}
#endregion
#region Services Async
/// <summary>
/// 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>La nouvelle note ajouté</returns>
public async Task<DetailsNoteDTO> AjouterNoteAsync(DetailsNoteDTO nouvelleNote)
{
//vérifier qu'il n'y a aucune valeur null
CheckNoteValide(nouvelleNote);
//vérifier que le référent existe
Collaborateur auteur = await collaborateurApi.ChercherCollabIdAsync((Guid?)nouvelleNote.IdAuteur);
CheckReferent(auteur);
//vérifier que le collaborateur existe
Collaborateur collaborateur = await collaborateurApi.ChercherCollabIdAsync(nouvelleNote.Collaborateur.Id);
CheckCollaborateur(collaborateur);
//transformer la note DTO en Note
Note note = DetailsNoteDTOToNouvelleNote(nouvelleNote);
//ajouter la note et sauvegarder
await context.Note.AddAsync(note);
await context.SaveChangesAsync();
nouvelleNote.Id = note.IdNote;
return nouvelleNote;
}
/// <summary>
/// Supprimer une note en fonction de son Id de manière async
/// </summary>
/// <param name="idNote">Id de la note à supprimer</param>
public async void SupprimerNoteAsync(long? idNote)
{
Note note = await context.Note.FindAsync(idNote);
if (note != null)
{
context.Remove(note);
await context.SaveChangesAsync();
}
}
#endregion
/*
#region Services
/// <summary>
/// Récupérer la liste des notes qu'un auteur a écrit sur un collaborateur
/// </summary>
/// <param name="idAuteur">Id de l'auteur des notes à récupérer</param>
/// <param name="idCollaborateur">Id du collaborateur pour lesquelles les notes ont été écrites</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 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();
//stopwatch.Start();
if (collaborateurService.GetCollaborateurById(idAuteur) == null)
throw new ReferentNotFoundException();
//stopwatch.Stop();
//Console.WriteLine("Durée d'exécution GetProfil 1: {0}", stopwatch.Elapsed.TotalSeconds);
//stopwatch.Restart();
if (collaborateurService.GetCollaborateurById(idAuteur) == null || collaborateurService.GetCollaborateurById(idCollaborateur) == null)
throw new CollaborateurNotFoundException();
//stopwatch.Stop();
//Console.WriteLine("Durée d'exécution GetProfil 2: {0}", stopwatch.Elapsed.TotalSeconds);
if (texte == null)
texte = "";
else
texte = texte.ToLower();
int skip = (numPage.Value - 1) * parPage.Value;
int take = parPage.Value;
IEnumerable<AffichageNoteDTO> 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
/// </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)
{
Note note = context.Note.Find(idNote);
if (note == null)
throw new NoteNotFoundException();
return NoteToDetailSDTO(note);
}
public IEnumerable<AffichageNoteDTO> GetNotes(bool? asc, int? numPage, int? parPage, string texte, string tri)
{
throw new NotImplementedException();
}
/// <summary>
/// Récupérer la liste des notes qu'un auteur a écrit sur un collaborateur
/// </summary>
/// <param name="idAuteur">Id de l'auteur des notes à 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 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> GetNotesByAuteur(Guid? idAuteur, bool? asc, int? numPage, int? parPage, string texte, string tri)
{
if (collaborateurService.GetCollaborateurById(idAuteur) == null)
throw new CollaborateurNotFoundException();
if (texte == null)
texte = "";
else
texte = texte.ToLower();
int skip = (numPage.Value - 1) * parPage.Value;
int take = parPage.Value;
//Stopwatch stopwatch = new Stopwatch();
//stopwatch.Start();
IEnumerable<AffichageNoteDTO> AffichageNoteDTO = (from n in context.Note
where n.IdAuteur == idAuteur
select NoteToAffichageDTO(n, collaborateurService));
//stopwatch.Stop();
//Console.WriteLine("Durée d'exécution numéro 1: {0}", stopwatch.Elapsed.TotalSeconds);
//stopwatch.Restart();
AffichageNoteDTO = (from a in AffichageNoteDTO
where a.Collaborateur.ToLower().Contains(texte) || a.Titre.ToLower().Contains(texte)
select a).Skip(skip).Take(take);
//stopwatch.Stop();
//Console.WriteLine("Durée d'exécution numéro 2: {0}", stopwatch.Elapsed.TotalSeconds);
return AffichageNoteDTO;
}
/// <summary>
/// Supprimer une note en fonction de son Id
/// </summary>
/// <param name="idNote">Id de la note à supprimer</param>
/// <returns>Si oui ou non la notea bien été supprimé</returns>
public void SupprimerNote(long? idNote)
{
Note note = context.Note.Find(idNote);
if (note == null)
throw new NoteNotFoundException();
context.Remove(note);
context.SaveChanges();
}
/// <summary>
/// Mettre à jour une note
/// </summary>
/// <param name="idNote">Id de la note à modifier</param>
/// <param name="note"></param>
/// <returns></returns>
public DetailsNoteDTO UpdateNote(long? idNote, DetailsNoteDTO note)
{
if (idNote != note.Id)
throw new NoteIdImcompatibleException();
if (!CheckNoteValide(note))
throw new NoteInvalideException();
Note noteToUpdate = context.Note.Find(idNote);
noteToUpdate.Titre = note.Titre;
noteToUpdate.Texte = note.Texte;
noteToUpdate.DateMiseAJour = DateTime.Now;
context.SaveChanges();
return NoteToDetailSDTO(noteToUpdate);
}
/// <summary>
/// Vérifier si un objet DetailsNoteDTO possède est valide pour ajout ou mise à jour
/// </summary>
/// <remarks> Un objet DetailsNoteDTO est valide si aucune de ses propriétés n'est à null</remarks>
/// <param name="note"></param>
/// <returns>true si l'objet est valide, false sinon</returns>
private bool CheckNoteValide(DetailsNoteDTO note)
{
return !(note == null || note.IdAuteur == null || note.Collaborateur == null || note.Collaborateur.Id == null || note.Titre == null || note.Texte == null) ;
}
#endregion
*/
#region fonctions privees
/// <summary>
/// Vérfier si la note est valide
/// </summary>
/// <param name="note">La note a vérifié</param>
private void CheckNoteValide(DetailsNoteDTO note)
{
//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");
}
/// <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 note si vous avez 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 AffichageNoteDTO NoteToAffichageDTO(Note note)
{
//CollaborateurDTO collaborateur = collaborateurService.GetCollaborateurById(note.IdCollaborateur);
Collaborateur collaborateur = collaborateurApi.ChercherCollabId((Guid?)note.IdCollaborateur);
AffichageNoteDTO affichage = new AffichageNoteDTO()
{
Id = note.IdNote,
IdCollaborateur = note.IdCollaborateur,
Collaborateur = collaborateur.Prenom + collaborateur.Nom,
Titre = note.Titre,
DateMiseAJour = note.DateMiseAJour
};
return affichage;
}
/// <summary>
/// Transformatino d'une note en DetailsNoteDTO
/// </summary>
/// <param name="note">Note à transformer</param>
/// <returns>Note transformer en DetailsNoteDTO</returns>
private DetailsNoteDTO NoteToDetailSDTO(Note note)
{
DetailsNoteDTO details = new DetailsNoteDTO()
{
Id = note.IdNote,
DateCreation = note.DateCreation,
DateMiseAjour = note.DateMiseAJour,
Titre = note.Titre,
Texte = note.Texte,
IdAuteur = note.IdAuteur,
//Collaborateur = collaborateurService.GetCollaborateurById(note.IdCollaborateur)
};
return details;
}
#endregion
#region DTOToObject
/// <summary>
/// Transformer l'objet DTO d'une note en note
/// </summary>
/// <remarks>En général, de base, cette méthode est prévue pour être utilisée qu'à la création d'une nouvelle note, dateCreation et dateUpdate sont donc initialisée à ce moment là</remarks>
/// <param name="detailsNoteDTO">Objet DTO à transformer en note</param>
/// <returns>L'objet DTO transformé en note</returns>
private Note DetailsNoteDTOToNouvelleNote(DetailsNoteDTO detailsNoteDTO)
{
Note note = new Note()
{
IdAuteur = detailsNoteDTO.IdAuteur.Value,
IdCollaborateur = detailsNoteDTO.Collaborateur.Id.Value,
Texte = detailsNoteDTO.Texte,
Titre = detailsNoteDTO.Titre,
DateCreation = DateTime.Now,
DateMiseAJour = DateTime.Now
};
return note;
}
#endregion
}
}