Merge de master
continuous-integration/drone/push Build is passing Details

pull/40/head
Johnny RATTON 1 year ago
commit 96e3a131c3

@ -1,50 +1,51 @@
using Dto;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Dto;
using Model.OrderCriteria;
using Shared;
using Asp.Versioning;
namespace API.Controllers
{
[Route("api/[controller]")]
[Route("api/v{version:apiVersion}/[controller]")]
[Authorize]
[ApiVersion("1.0")]
[ApiController]
public class InquiriesController()
: ControllerBase
public class InquiriesController : Controller
{
private readonly IInquiryService<InquiryDTO> _inquiryService;
private readonly ILogger<InquiriesController> _logger;
private IInquiryDataService _inquiryDataService;
public InquiriesController(IInquiryService<InquiryDTO> inquiryService, ILogger<InquiriesController> logger) : this()
private readonly ILogger<InquiriesController> _logger;
public InquiriesController(IInquiryDataService inquiryDataService, ILogger<InquiriesController> logger)
{
_inquiryService = inquiryService;
_inquiryDataService = inquiryDataService;
_logger = logger;
}
[HttpGet("inquiries/{page}/{number}")]
[HttpGet("inquiries/{page}/{number}/{orderCriteria}")]
[ProducesResponseType(typeof(InquiryDTO), 200)]
[ProducesResponseType(typeof(string), 204)]
public IActionResult GetInquiries(int page, int number)
public IActionResult GetInquiries(int page, int number, InquiryOrderCriteria orderCriteria)
{
var nbInquiry = _inquiryService.GetInquiries(page, number).Count();
var nbInquiry = _inquiryDataService.GetInquiries(page, number, orderCriteria).Count();
if (nbInquiry == 0)
{
_logger.LogError("[ERREUR] Aucune enquête trouvé.");
_logger.LogError("[ERREUR] Aucune enquête trouvée.");
return StatusCode(204);
}
_logger.LogInformation("[INFORMATION] {nb} Enquête(s) trouvée(s)", nbInquiry);
return Ok(_inquiryService.GetInquiries(page, number));
return Ok(_inquiryDataService.GetInquiries(page, number, orderCriteria));
}
[HttpGet("inquiry/id/{id}")]
[HttpGet("inquiry/{id}")]
[ProducesResponseType(typeof(InquiryDTO), 200)]
[ProducesResponseType(typeof(string), 404)]
public IActionResult GetInquiryById(int id)
{
try
{
_logger.LogInformation("[INFORMATION] Enquête avec l'id {id} a été trouvé.", id);
return Ok(_inquiryService.GetInquiryById(id));
_logger.LogInformation("[INFORMATION] L'enquête avec l'id {id} a été trouvé.", id);
return Ok(_inquiryDataService.GetInquiryById(id));
}
catch (ArgumentException)
{
@ -53,15 +54,15 @@ namespace API.Controllers
}
}
[HttpGet("inquiry/title/{title}")]
[HttpGet("inquiry/{title}")]
[ProducesResponseType(typeof(InquiryDTO), 200)]
[ProducesResponseType(typeof(string), 404)]
public IActionResult GetInquiryByTitle(string title)
{
try
{
_logger.LogInformation("[INFORMATION] Enquête avec le titre {title} a été trouvé.", title);
return Ok(_inquiryService.GetInquiryByTitle(title));
_logger.LogInformation("[INFORMATION] L'enquête avec le titre {title} a été trouvé.", title);
return Ok(_inquiryDataService.GetInquiryByTitle(title));
}
catch (ArgumentException)
{
@ -69,5 +70,62 @@ namespace API.Controllers
return NotFound();
}
}
[HttpDelete("inquiry/{id}")]
[ProducesResponseType(typeof(InquiryDTO), 200)]
[ProducesResponseType(typeof(string), 404)]
public IActionResult DeleteInquiry(int id)
{
var success = _inquiryDataService.DeleteInquiry(id);
if (success)
{
_logger.LogInformation("[INFORMATION] L'enquête avec l'id {id} a été supprimé.", id);
return Ok(_inquiryDataService.DeleteInquiry(id));
}
else
{
_logger.LogError("[ERREUR] Aucune enquête trouvée avec l'id {id}.", id);
return NotFound();
}
}
[HttpPost]
[ProducesResponseType(typeof(InquiryDTO), 201)]
[ProducesResponseType(typeof(string), 400)]
public IActionResult CreateInquiry([FromBody] InquiryDTO dto)
{
if (dto.Title == null || dto.Description == null || dto.Database == null || dto.InquiryTable == null)
{
return BadRequest();
}
_logger.LogInformation("[INFORMATION] Une enquête a été créé : title - {title}, description - {description}, isUser - {isUser}, database - {database}, inquiryTable - {inquiryTable}", dto.Title, dto.Description, dto.IsUser, dto.Database, dto.InquiryTable);
return Created(nameof(GetInquiries), _inquiryDataService.CreateInquiry(dto.Title, dto.Description, dto.IsUser, dto.Database, dto.InquiryTable));
}
[HttpPut("inquiry/{id}")]
[ProducesResponseType(typeof(InquiryDTO), 200)]
[ProducesResponseType(typeof(string), 400)]
[ProducesResponseType(typeof(string), 404)]
public IActionResult UpdateInquiry(int id, [FromBody] InquiryDTO inquiryDTO)
{
if (id != inquiryDTO.Id)
{
_logger.LogError("[ERREUR] Problème ID - La mise à jour de l'enquête avec l'id {id} a échouée.", id);
return BadRequest();
}
if (!ModelState.IsValid)
{
_logger.LogError("[ERREUR] Problème controlleur - La mise à jour de l'enquête avec l'id {id} a échouée.", id);
return BadRequest();
}
if (inquiryDTO != null)
{
_logger.LogInformation("[INFORMATION] La mise à jour de l'enquête avec l'id {id} a été effectuée", id);
return Ok(_inquiryDataService.UpdateInquiry(id, inquiryDTO));
}
_logger.LogError("[ERREUR] Aucune enquête trouvée avec l'id {id}.", id);
return NotFound();
}
}
}

@ -0,0 +1,132 @@
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Dto;
using Model.OrderCriteria;
using Shared;
using Asp.Versioning;
namespace API.Controllers
{
[Route("api/v{version:apiVersion}/[controller]")]
[Authorize]
[ApiVersion("1.0")]
[ApiController]
public class LessonsController : Controller
{
private ILessonDataService _lessonDataService;
private readonly ILogger<LessonsController> _logger;
public LessonsController(ILessonDataService lessonDataService, ILogger<LessonsController> logger)
{
_lessonDataService = lessonDataService;
_logger = logger;
}
[HttpGet("lessons/{page}/{number}/{orderCriteria}")]
[ProducesResponseType(typeof(LessonDTO), 200)]
[ProducesResponseType(typeof(string), 204)]
public IActionResult GetLessons(int page, int number, LessonOrderCriteria orderCriteria)
{
var nbLesson = _lessonDataService.GetLessons(page, number, orderCriteria).Count();
if (nbLesson == 0)
{
_logger.LogError("[ERREUR] Aucune leçon trouvée.");
return StatusCode(204);
}
_logger.LogInformation("[INFORMATION] {nb} Leçon(s) trouvée(s)", nbLesson);
return Ok(_lessonDataService.GetLessons(page, number, orderCriteria));
}
[HttpGet("lesson/{id}")]
[ProducesResponseType(typeof(LessonDTO), 200)]
[ProducesResponseType(typeof(string), 404)]
public IActionResult GetLessonById(int id)
{
try
{
_logger.LogInformation("[INFORMATION] La leçon avec l'id {id} a été trouvé.", id);
return Ok(_lessonDataService.GetLessonById(id));
}
catch (ArgumentException)
{
_logger.LogError("[ERREUR] Aucune leçon trouvée avec l'id {id}.", id);
return NotFound();
}
}
[HttpGet("lesson/{title}")]
[ProducesResponseType(typeof(LessonDTO), 200)]
[ProducesResponseType(typeof(string), 404)]
public IActionResult GetLessonByTitle(string title)
{
try
{
_logger.LogInformation("[INFORMATION] La leçon avec le titre {title} a été trouvé.", title);
return Ok(_lessonDataService.GetLessonByTitle(title));
}
catch (ArgumentException)
{
_logger.LogError("[ERREUR] Aucune leçon trouvée avec le titre {title}.", title);
return NotFound();
}
}
[HttpDelete("lesson/{id}")]
[ProducesResponseType(typeof(LessonDTO), 200)]
[ProducesResponseType(typeof(string), 404)]
public IActionResult DeleteLesson(int id)
{
var success = _lessonDataService.DeleteLesson(id);
if (success)
{
_logger.LogInformation("[INFORMATION] La leçon avec l'id {id} a été supprimé.", id);
return Ok(_lessonDataService.DeleteLesson(id));
}
else
{
_logger.LogError("[ERREUR] Aucune leçon trouvée avec l'id {id}.", id);
return NotFound();
}
}
[HttpPost]
[ProducesResponseType(typeof(LessonDTO), 201)]
[ProducesResponseType(typeof(string), 400)]
public IActionResult CreateLesson([FromBody] LessonDTO dto)
{
if (dto.Title == null || dto.LastPublisher == null)
{
return BadRequest();
}
_logger.LogInformation("[INFORMATION] Une leçon a été créé : title - {title}, lastPublisher - {publisher}, lastEdit - {lastEdit}", dto.Title, dto.LastPublisher, dto.LastEdit);
return Created(nameof(GetLessons), _lessonDataService.CreateLesson(dto.Title, dto.LastPublisher, dto.LastEdit));
}
[HttpPut("lesson/{id}")]
[ProducesResponseType(typeof(LessonDTO), 200)]
[ProducesResponseType(typeof(string), 400)]
[ProducesResponseType(typeof(string), 404)]
public IActionResult UpdateLesson(int id, [FromBody] LessonDTO lessonDTO)
{
if (id != lessonDTO.Id)
{
_logger.LogError("[ERREUR] Problème ID - La mise à jour de la leçon avec l'id {id} a échouée.", id);
return BadRequest();
}
if (!ModelState.IsValid)
{
_logger.LogError("[ERREUR] Problème controlleur - La mise à jour de la leçon avec l'id {id} a échouée.", id);
return BadRequest();
}
if (lessonDTO != null)
{
_logger.LogInformation("[INFORMATION] La mise à jour de la leçon avec l'id {id} a été effectuée", id);
return Ok(_lessonDataService.UpdateLesson(id, lessonDTO));
}
_logger.LogError("[ERREUR] Aucune leçon trouvée avec l'id {id}.", id);
return NotFound();
}
}
}

@ -0,0 +1,130 @@
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Dto;
using Model.OrderCriteria;
using Shared;
using Asp.Versioning;
namespace API.Controllers
{
[Route("api/v{version:apiVersion}/[controller]")]
[Authorize]
[ApiVersion("1.0")]
[ApiController]
public class ParagraphsController : Controller
{
private IParagraphDataService _paragraphDataService;
private readonly ILogger<ParagraphsController> _logger;
public ParagraphsController(IParagraphDataService paragraphDataService, ILogger<ParagraphsController> logger)
{
_paragraphDataService = paragraphDataService;
_logger = logger;
}
[HttpGet("paragraphs/{page}/{number}/{orderCriteria}")]
[ProducesResponseType(typeof(ParagraphDTO), 200)]
[ProducesResponseType(typeof(string), 204)]
public IActionResult GetParagraphs(int page, int number, ParagraphOrderCriteria orderCriteria)
{
var nbParagraph = ( _paragraphDataService.GetParagraphs(page, number, orderCriteria)).ToList().Count();
if(nbParagraph == 0)
{
_logger.LogError("[ERREUR] Aucun paragraphe trouvé.");
return StatusCode(204);
}
_logger.LogInformation("[INFORMATION] {nb} Paragraphe(s) trouvé(s)", nbParagraph);
return Ok(_paragraphDataService.GetParagraphs(page, number, orderCriteria));
}
[HttpGet("paragraph/{id}")]
[ProducesResponseType(typeof(ParagraphDTO), 200)]
[ProducesResponseType(typeof(string), 404)]
public IActionResult GetParagraphById(int id)
{
try
{
_logger.LogInformation("[INFORMATION] Le paragraphe avec l'id {id} a été trouvé.", id);
return Ok(_paragraphDataService.GetParagraphById(id));
} catch (ArgumentException)
{
_logger.LogError("[ERREUR] Aucun paragraphe trouvé avec l'id {id}.", id);
return NotFound();
}
}
[HttpGet("paragraph/{title}")]
[ProducesResponseType(typeof(ParagraphDTO), 200)]
[ProducesResponseType(typeof(string), 404)]
public IActionResult GetParagraphByTitle(string title)
{
try
{
_logger.LogInformation("[INFORMATION] Le paragraphe avec le titre {title} a été trouvé.", title);
return Ok(_paragraphDataService.GetParagraphByTitle(title));
}catch (ArgumentException)
{
_logger.LogError("[ERREUR] Aucun paragraphe trouvé avec le titre {title}.", title);
return NotFound();
}
}
[HttpDelete("paragraph/{id}")]
[ProducesResponseType(typeof(ParagraphDTO), 200)]
[ProducesResponseType(typeof(string), 404)]
public IActionResult DeleteParagraph(int id)
{
var success = _paragraphDataService.DeleteParagraph(id);
if(success)
{
_logger.LogInformation("[INFORMATION] Le paragraphe avec l'id {id} a été supprimé.", id);
return Ok(_paragraphDataService.DeleteParagraph(id));
} else
{
_logger.LogError("[ERREUR] Aucun paragraphe trouvé avec l'id {id}.", id);
return NotFound();
}
}
[HttpPost]
[ProducesResponseType(typeof(ParagraphDTO), 201)]
[ProducesResponseType(typeof(string), 400)]
public IActionResult CreateParagraph([FromBody] ParagraphDTO dto)
{
if (dto.Title == null || dto.Content == null || dto.Info == null || dto.Query == null || dto.Comment == null)
{
return BadRequest();
}
_logger.LogInformation("[INFORMATION] Un paragraphe a été créé : title - {title}, content - {content}, info - {info}, query - {query}, comment - {comment}", dto.Title, dto.Content, dto.Info, dto.Query, dto.Comment);
return Created(nameof(GetParagraphs), _paragraphDataService.CreateParagraph(dto.Title, dto.Content, dto.Info, dto.Query, dto.Comment, dto.LessonId));
}
[HttpPut("paragraph/{id}")]
[ProducesResponseType(typeof(ParagraphDTO), 200)]
[ProducesResponseType(typeof(string), 400)]
[ProducesResponseType(typeof(string), 404)]
public IActionResult UpdateParagraph(int id, [FromBody] ParagraphDTO paragraphDTO)
{
if(id != paragraphDTO.Id)
{
_logger.LogError("[ERREUR] Problème ID - La mise à jour du paragraphe avec l'id {id} a échouée.", id);
return BadRequest();
}
if(!ModelState.IsValid)
{
_logger.LogError("[ERREUR] Problème controlleur - La mise à jour du paragraphe avec l'id {id} a échouée.", id);
return BadRequest();
}
if(paragraphDTO != null)
{
_logger.LogInformation("[INFORMATION] La mise à jour du paragraphe avec l'id {id} a été effectuée", id);
return Ok(_paragraphDataService.UpdateParagraph(id, paragraphDTO));
}
_logger.LogError("[ERREUR] Aucun paragraphe trouvé avec l'id {id}.", id);
return NotFound();
}
}
}

@ -0,0 +1,130 @@
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Dto;
using Model.OrderCriteria;
using Shared;
using Asp.Versioning;
namespace API.Controllers
{
[Route("api/v{version:apiVersion}/[controller]")]
[Authorize]
[ApiVersion("1.0")]
[ApiController]
public class SuccessesController : Controller
{
private ISuccessDataService _successDataService;
private readonly ILogger<SuccessesController> _logger;
public SuccessesController(ISuccessDataService successDataService, ILogger<SuccessesController> logger)
{
_successDataService = successDataService;
_logger = logger;
}
[HttpGet("successes/{page}/{number}/{orderCriteria}")]
[ProducesResponseType(typeof(SuccessDTO), 200)]
[ProducesResponseType(typeof(string), 204)]
public IActionResult GetSuccesses(int page, int number, SuccessOrderCriteria orderCriteria)
{
var nbUser = (_successDataService.GetSuccesses(page, number, orderCriteria)).ToList().Count();
if(nbUser == 0)
{
_logger.LogError("[ERREUR] Aucun utilisateur trouvé.");
return StatusCode(204);
}
_logger.LogInformation("[INFORMATION] {nb} Utilisateur(s) trouvé(s)", nbUser);
return Ok(_successDataService.GetSuccesses(page, number, orderCriteria));
}
[HttpGet("success/{id}")]
[ProducesResponseType(typeof(SuccessDTO), 200)]
[ProducesResponseType(typeof(string), 404)]
public IActionResult GetSuccessByUserId(int userId)
{
try
{
_logger.LogInformation("[INFORMATION] Le succès avec l'id de l'utilisateur {id} a été trouvé.", userId);
return Ok(_successDataService.GetSuccessByUserId(userId));
} catch (ArgumentException)
{
_logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'id de l'utilisateur {id}.", userId);
return NotFound();
}
}
[HttpGet("success/{inquiryId}")]
[ProducesResponseType(typeof(SuccessDTO), 200)]
[ProducesResponseType(typeof(string), 404)]
public IActionResult GetSuccessByInquiryId(int inquiryId)
{
try
{
_logger.LogInformation("[INFORMATION] Utilisateur avec l'id de l'enquête {inquiryId} a été trouvé.", inquiryId);
return Ok(_successDataService.GetSuccessByInquiryId(inquiryId));
}catch (ArgumentException)
{
_logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'id de l'enquête {inquiryId}.", inquiryId);
return NotFound();
}
}
[HttpDelete("success/{id}")]
[ProducesResponseType(typeof(SuccessDTO), 200)]
[ProducesResponseType(typeof(string), 404)]
public IActionResult DeleteSuccess(int id)
{
var success = _successDataService.DeleteSuccess(id);
if(success)
{
_logger.LogInformation("[INFORMATION] Le succès avec l'id {id} a été supprimé.", id);
return Ok(_successDataService.DeleteSuccess(id));
} else
{
_logger.LogError("[ERREUR] Aucun succès trouvé avec l'id {id}.", id);
return NotFound();
}
}
[HttpPost]
[ProducesResponseType(typeof(SuccessDTO), 201)]
[ProducesResponseType(typeof(string), 400)]
public IActionResult CreateSuccess([FromBody] SuccessDTO dto)
{
/*if (dto.UserId == null || dto.InquiryId == null)
{
return BadRequest();
}*/
_logger.LogInformation("[INFORMATION] Un succès a été créé : userId - {userId}, inquiryId - {inquiryId}, isFinished - {isFinished}", dto.UserId, dto.InquiryId, dto.IsFinished);
return Created(nameof(GetSuccesses), _successDataService.CreateSuccess(dto.UserId, dto.InquiryId, dto.IsFinished));
}
[HttpPut("success/{id}")]
[ProducesResponseType(typeof(SuccessDTO), 200)]
[ProducesResponseType(typeof(string), 400)]
[ProducesResponseType(typeof(string), 404)]
public IActionResult UpdateSuccess(int id, [FromBody] SuccessDTO successDTO)
{
if(id != successDTO.UserId)
{
_logger.LogError("[ERREUR] Problème ID - La mise à jour du succès avec l'id de l'utilisateur {id} a échouée.", id);
return BadRequest();
}
if(!ModelState.IsValid)
{
_logger.LogError("[ERREUR] Problème controlleur - La mise à jour du succès avec l'id de l'utilisateur {id} a échouée.", id);
return BadRequest();
}
if(successDTO != null)
{
_logger.LogInformation("[INFORMATION] La mise à jour du succès avec l'id de l'utilisateur {id} a été effectuée", id);
return Ok(_successDataService.UpdateSuccess(id, successDTO));
}
_logger.LogError("[ERREUR] Aucun succès trouvé avec l'id de l'utilisateur {id}.", id);
return NotFound();
}
}
}

@ -3,6 +3,7 @@ using Asp.Versioning;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Shared;
using Model.OrderCriteria;
namespace API.Controllers
{
@ -10,14 +11,14 @@ namespace API.Controllers
[Authorize]
[ApiVersion("1.0")]
[ApiController]
public class UserController(ILogger<UserController> logger, IUserService<UserDTO> userService) : ControllerBase
public class UsersController(ILogger<UsersController> logger, IUserDataService userService) : ControllerBase
{
[HttpGet("users/{page}/{number}")]
[ProducesResponseType(typeof(UserDTO), 200)]
[ProducesResponseType(typeof(string), 204)]
public IActionResult GetUsers(int page, int number)
public IActionResult GetUsers(int page, int number, UserOrderCriteria orderCriteria)
{
var users = userService.GetUsers(page, number).ToList();
var users = userService.GetUsers(page, number, orderCriteria).ToList();
if (users.Count == 0)
{
logger.LogError("[ERREUR] Aucun utilisateur trouvé.");
@ -28,7 +29,7 @@ namespace API.Controllers
return Ok(users);
}
[HttpGet("user/id/{id}")]
[HttpGet("user/{id}")]
[ProducesResponseType(typeof(UserDTO), 200)]
[ProducesResponseType(typeof(string), 404)]
public IActionResult GetUserById(int id)
@ -45,7 +46,7 @@ namespace API.Controllers
}
}
[HttpGet("user/username/{username}")]
[HttpGet("user/{username}")]
[ProducesResponseType(typeof(UserDTO), 200)]
[ProducesResponseType(typeof(string), 404)]
public IActionResult GetUserByUsername(string username)
@ -62,7 +63,7 @@ namespace API.Controllers
}
}
[HttpDelete]
[HttpDelete("user/{id}")]
[ProducesResponseType(typeof(UserDTO), 200)]
[ProducesResponseType(typeof(string), 404)]
public IActionResult DeleteUser(int id)
@ -98,7 +99,7 @@ namespace API.Controllers
userService.CreateUser(dto.Username, dto.Password, dto.Email, dto.IsAdmin));
}
[HttpPut]
[HttpPut("user/{id}")]
[ProducesResponseType(typeof(UserDTO), 200)]
[ProducesResponseType(typeof(string), 400)]
[ProducesResponseType(typeof(string), 404)]

@ -20,10 +20,22 @@ builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
builder.Services.AddScoped<IUserService<UserEntity>, UserDataService>();
builder.Services.AddScoped<IUserService<UserDTO>, UserDataServiceApi>();
builder.Services.AddScoped<IInquiryService<InquiryEntity>, InquiryDataService>();
builder.Services.AddScoped<IInquiryService<InquiryDTO>, InquiryDataServiceApi>();
builder.Services.AddScoped<IUserService<UserEntity>, DbDataManager.Service.UserDataService>();
builder.Services.AddScoped<IUserService<UserDTO>, Shared.UserDataService>();
builder.Services.AddScoped<IInquiryService<InquiryEntity>, DbDataManager.Service.InquiryDataService>();
builder.Services.AddScoped<IInquiryService<InquiryDTO>, Shared.InquiryDataService>();
builder.Services.AddScoped<IParagraphService<ParagraphEntity>, DbDataManager.Service.ParagraphDataService>();
builder.Services.AddScoped<IParagraphService<ParagraphDTO>, Shared.ParagraphDataService>();
builder.Services.AddScoped<ISuccessService<SuccessEntity>, DbDataManager.Service.SuccessDataService>();
builder.Services.AddScoped<ISuccessService<SuccessDTO>, Shared.SuccessDataService>();
builder.Services.AddScoped<ILessonService<LessonEntity>, DbDataManager.Service.LessonDataService>();
builder.Services.AddScoped<ILessonService<LessonDTO>, Shared.LessonDataService>();
builder.Services.AddDbContext<DbContext, UserDbContext>();
builder.Services.AddDbContext<WebAPIDbContext>(options => options.UseInMemoryDatabase("appDb"));
builder.Services.AddIdentityApiEndpoints<IdentityUser>().AddEntityFrameworkStores<WebAPIDbContext>();

@ -1,19 +1,33 @@
using Dto;
using Entities;
using Entities;
using Model.OrderCriteria;
using Shared;
using Shared.Mapper;
namespace API.Service;
public class InquiryDataServiceApi(IInquiryService<InquiryEntity> inquiryService) : IInquiryService<InquiryDTO>
public class InquiryDataServiceApi(IInquiryService<InquiryEntity> inquiryService) : IInquiryService<InquiryEntity>
{
public IEnumerable<InquiryDTO> GetInquiries(int page, int number)
public InquiryEntity CreateInquiry(string title, string description, bool isUser, int tableId, int solutionId)
{
var inquiries = inquiryService.GetInquiries(page, number);
return inquiries.Select(i => i.FromEntityToDTO()).ToList();
return inquiryService.CreateInquiry(title, description, isUser, tableId, solutionId);
}
public InquiryDTO GetInquiryById(int id) => inquiryService.GetInquiryById(id).FromEntityToDTO();
public bool DeleteInquiry(int id)
{
return inquiryService.DeleteInquiry(id);
}
public IEnumerable<InquiryEntity> GetInquiries(int page, int number, InquiryOrderCriteria orderCriteria)
{
var inquiries = inquiryService.GetInquiries(page, number, orderCriteria);
return inquiries.Select(i => i).ToList();
}
public InquiryDTO GetInquiryByTitle(string title) => inquiryService.GetInquiryByTitle(title).FromEntityToDTO();
public InquiryEntity GetInquiryById(int id) => inquiryService.GetInquiryById(id);
public InquiryEntity GetInquiryByTitle(string title) => inquiryService.GetInquiryByTitle(title);
public InquiryEntity UpdateInquiry(int id, InquiryEntity inquiry)
{
return inquiryService.UpdateInquiry(id, inquiry);
}
}

@ -0,0 +1,26 @@
using Entities;
using Model.OrderCriteria;
using Shared;
namespace API.Service;
public class LessonDataServiceApi(ILessonService<LessonEntity> lessonService) : ILessonService<LessonEntity>
{
public IEnumerable<LessonEntity> GetLessons(int page, int number, LessonOrderCriteria orderCriteria)
{
var lessonsEntities = lessonService.GetLessons(page, number, orderCriteria);
return lessonsEntities.Select(e => e).ToList();
}
public LessonEntity GetLessonById(int id) => lessonService.GetLessonById(id);
public LessonEntity GetLessonByTitle(string title) => lessonService.GetLessonByTitle(title);
public bool DeleteLesson(int id) => lessonService.DeleteLesson(id);
public LessonEntity UpdateLesson(int id, LessonEntity lesson) =>
lessonService.UpdateLesson(id, lesson);
public LessonEntity CreateLesson(string title, string lastPublisher, DateOnly? lastEdit) =>
lessonService.CreateLesson(title, lastPublisher, lastEdit);
}

@ -0,0 +1,26 @@
using Entities;
using Model.OrderCriteria;
using Shared;
namespace API.Service;
public class ParagraphDataServiceApi(IParagraphService<ParagraphEntity> paragraphService) : IParagraphService<ParagraphEntity>
{
public IEnumerable<ParagraphEntity> GetParagraphs(int page, int number, ParagraphOrderCriteria orderCriteria)
{
var paragraphsEntities = paragraphService.GetParagraphs(page, number, orderCriteria);
return paragraphsEntities.Select(e => e).ToList();
}
public ParagraphEntity GetParagraphById(int id) => paragraphService.GetParagraphById(id);
public ParagraphEntity GetParagraphByTitle(string title) => paragraphService.GetParagraphByTitle(title);
public bool DeleteParagraph(int id) => paragraphService.DeleteParagraph(id);
public ParagraphEntity UpdateParagraph(int id, ParagraphEntity paragraph) =>
paragraphService.UpdateParagraph(id, paragraph);
public ParagraphEntity CreateParagraph(string title, string content, string info, string query, string comment, int lessonId) =>
paragraphService.CreateParagraph(title, content, info, query, comment, lessonId);
}

@ -0,0 +1,26 @@
using Entities;
using Model.OrderCriteria;
using Shared;
namespace API.Service;
public class SuccessDataServiceApi(ISuccessService<SuccessEntity> sucessService) : ISuccessService<SuccessEntity>
{
public IEnumerable<SuccessEntity> GetSuccesses(int page, int number, SuccessOrderCriteria orderCriteria)
{
var successesEntities = sucessService.GetSuccesses(page, number, orderCriteria);
return successesEntities.Select(e => e).ToList();
}
public SuccessEntity GetSuccessByUserId(int id) => sucessService.GetSuccessByUserId(id);
public SuccessEntity GetSuccessByInquiryId(int id) => sucessService.GetSuccessByInquiryId(id);
public bool DeleteSuccess(int id) => sucessService.DeleteSuccess(id);
public SuccessEntity UpdateSuccess(int id, SuccessEntity success) =>
sucessService.UpdateSuccess(id, success);
public SuccessEntity CreateSuccess(int userId, int inquiryId, bool isFinished) =>
sucessService.CreateSuccess(userId, inquiryId, isFinished);
}

@ -1,27 +1,26 @@
using Dto;
using Entities;
using Entities;
using Model.OrderCriteria;
using Shared;
using Shared.Mapper;
namespace API.Service;
public class UserDataServiceApi(IUserService<UserEntity> userService) : IUserService<UserDTO>
public class UserDataServiceApi(IUserService<UserEntity> userService) : IUserService<UserEntity>
{
public IEnumerable<UserDTO> GetUsers(int page, int number)
public IEnumerable<UserEntity> GetUsers(int page, int number, UserOrderCriteria orderCriteria)
{
var usersEntities = userService.GetUsers(page, number);
return usersEntities.Select(e => e.FromEntityToDTO()).ToList();
var usersEntities = userService.GetUsers(page, number, orderCriteria);
return usersEntities.Select(e => e).ToList();
}
public UserDTO GetUserById(int id) => userService.GetUserById(id).FromEntityToDTO();
public UserEntity GetUserById(int id) => userService.GetUserById(id);
public UserDTO GetUserByUsername(string username) => userService.GetUserByUsername(username).FromEntityToDTO();
public UserEntity GetUserByUsername(string username) => userService.GetUserByUsername(username);
public bool DeleteUser(int id) => userService.DeleteUser(id);
public UserDTO UpdateUser(int id, UserDTO user) =>
userService.UpdateUser(id, user.FromDTOToEntity()).FromEntityToDTO();
public UserEntity UpdateUser(int id, UserEntity user) =>
userService.UpdateUser(id, user);
public UserDTO CreateUser(string username, string password, string email, bool isAdmin) =>
userService.CreateUser(username, password, email, isAdmin).FromEntityToDTO();
public UserEntity CreateUser(string username, string password, string email, bool isAdmin) =>
userService.CreateUser(username, password, email, isAdmin);
}

@ -8,15 +8,15 @@ namespace DbContextLib
public class UserDbContext : IdentityDbContext<IdentityUser>
{
public DbSet<UserEntity> Users { get; set; }
public DbSet<BlackListEntity> BlackList { get; set; }
public DbSet<InquiryEntity> Inquiry { get; set; }
public DbSet<InquiryTableEntity> InquiryTable { get; set; }
public DbSet<LessonEntity> Lesson { get; set; }
public DbSet<BlackListEntity> BlackLists { get; set; }
public DbSet<InquiryEntity> Inquiries { get; set; }
public DbSet<InquiryTableEntity> InquiryTables { get; set; }
public DbSet<LessonEntity> Lessons { get; set; }
public DbSet<ContentLessonEntity> ContentLessons { get; set; }
public DbSet<ParagraphEntity> Paragraph { get; set; }
public DbSet<ParagraphEntity> Paragraphs { get; set; }
public DbSet<SolutionEntity> Solutions { get; set; }
public DbSet<SuccessEntity> Success { get; set; }
public DbSet<NotepadEntity> Notepad { get; set; }
public DbSet<SuccessEntity> Successes { get; set; }
public DbSet<NotepadEntity> Notepads { get; set; }
public UserDbContext(DbContextOptions<UserDbContext> options) : base(options) { }
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
@ -30,7 +30,6 @@ namespace DbContextLib
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.Entity<ContentLessonEntity>().HasKey(c => c.LessonId);
modelBuilder.Entity<ContentLessonEntity>().HasKey(c => c.LessonPartId);
modelBuilder.Entity<SuccessEntity>().HasKey(s => s.UserId);
modelBuilder.Entity<SuccessEntity>().HasKey(s => s.InquiryId);
modelBuilder.Entity<InquiryEntity>().HasKey(s => s.Id);

@ -1,23 +1,93 @@
using Dto;
using DbContextLib;
using Entities;
using Microsoft.EntityFrameworkCore;
using Model.OrderCriteria;
using Shared;
namespace DbDataManager.Service;
public class InquiryDataService : IInquiryService<InquiryEntity>
{
public IEnumerable<InquiryEntity> GetInquiries(int page, int number)
private UserDbContext DbContext { get; set; }
public InquiryDataService(UserDbContext context)
{
throw new NotImplementedException();
DbContext = context;
context.Database.EnsureCreated();
}
public InquiryEntity GetInquiryById(int id)
{
throw new NotImplementedException();
var inquiryEntity = DbContext.Inquiries.FirstOrDefault(u => u.Id == id);
if (inquiryEntity == null)
{
throw new ArgumentException("Impossible de trouver l'enquête", nameof(id));
}
return inquiryEntity;
}
public InquiryEntity GetInquiryByTitle(string title)
{
throw new NotImplementedException();
var inquiryEntity = DbContext.Inquiries.FirstOrDefault(u => u.Title == title);
if (inquiryEntity == null)
{
throw new ArgumentException("Impossible de trouver l'enquête", nameof(title));
}
return inquiryEntity;
}
public IEnumerable<InquiryEntity> GetInquiries(int page, int number, InquiryOrderCriteria orderCriteria)
{
return DbContext.Inquiries.Skip((page - 1) * number).Take(number).ToList()
.Select(u => u);
}
public bool DeleteInquiry(int id)
{
var inquiryEntity = DbContext.Inquiries.FirstOrDefault(u => u.Id == id);
if (inquiryEntity == null)
{
return false;
}
DbContext.Inquiries.Remove(inquiryEntity);
DbContext.SaveChangesAsync();
return true;
}
public InquiryEntity UpdateInquiry(int id, InquiryEntity inquiry)
{
var updatingInquiry = DbContext.Inquiries.FirstOrDefault(u => u.Id == id);
if (updatingInquiry == null)
{
throw new ArgumentException("Impossible de trouver l'enquête", nameof(id));
}
updatingInquiry.Title = inquiry.Title;
updatingInquiry.Description = inquiry.Description;
updatingInquiry.IsUser = inquiry.IsUser;
updatingInquiry.IdSolution = inquiry.IdSolution;
updatingInquiry.IdDatabase = inquiry.IdDatabase;
// Permet d'indiquer en Db que l'entité a été modifiée.
DbContext.Entry(updatingInquiry).State = EntityState.Modified;
DbContext.SaveChangesAsync();
return updatingInquiry;
}
public InquiryEntity CreateInquiry(string title, string description, bool isUser, int tableId, int solutionId)
{
var newInquiryEntity = new InquiryEntity()
{
Title = title,
Description = description,
IsUser = isUser,
IdDatabase = tableId,
IdSolution = solutionId,
};
DbContext.Inquiries.Add(newInquiryEntity);
DbContext.SaveChangesAsync();
return newInquiryEntity;
}
}

@ -0,0 +1,89 @@
using DbContextLib;
using Entities;
using Microsoft.EntityFrameworkCore;
using Model.OrderCriteria;
using Shared;
namespace DbDataManager.Service;
public class LessonDataService : ILessonService<LessonEntity>
{
private UserDbContext DbContext { get; set; }
public LessonDataService(UserDbContext context)
{
DbContext = context;
context.Database.EnsureCreated();
}
public LessonEntity GetLessonById(int id)
{
var lessonEntity = DbContext.Lessons.FirstOrDefault(u => u.Id == id);
if (lessonEntity == null)
{
throw new ArgumentException("Impossible de trouver la leçon", nameof(id));
}
return lessonEntity;
}
public LessonEntity GetLessonByTitle(string title)
{
var lessonEntity = DbContext.Lessons.FirstOrDefault(u => u.Title == title);
if (lessonEntity == null)
{
throw new ArgumentException("Impossible de trouver la leçon", nameof(title));
}
return lessonEntity;
}
public IEnumerable<LessonEntity> GetLessons(int page, int number, LessonOrderCriteria orderCriteria)
{
return DbContext.Lessons.Skip((page - 1) * number).Take(number).ToList()
.Select(u => u);
}
public bool DeleteLesson(int id)
{
var lessonEntity = DbContext.Lessons.FirstOrDefault(u => u.Id == id);
if (lessonEntity == null)
{
return false;
}
DbContext.Lessons.Remove(lessonEntity);
DbContext.SaveChangesAsync();
return true;
}
public LessonEntity UpdateLesson(int id, LessonEntity lesson)
{
var updatingLesson = DbContext.Lessons.FirstOrDefault(u => u.Id == id);
if (updatingLesson == null)
{
throw new ArgumentException("Impossible de trouver la leçon", nameof(id));
}
updatingLesson.Title = lesson.Title;
updatingLesson.LastPublisher = lesson.LastPublisher;
updatingLesson.LastEdit = lesson.LastEdit;
// Permet d'indiquer en Db que l'entité a été modifiée.
DbContext.Entry(updatingLesson).State = EntityState.Modified;
DbContext.SaveChangesAsync();
return updatingLesson;
}
public LessonEntity CreateLesson(string title, string lastPublisher, DateOnly? lastEdit)
{
var newLessonEntity = new LessonEntity()
{
Title = title,
LastPublisher = lastPublisher,
LastEdit = lastEdit,
};
DbContext.Lessons.Add(newLessonEntity);
DbContext.SaveChangesAsync();
return newLessonEntity;
}
}

@ -0,0 +1,95 @@
using DbContextLib;
using Entities;
using Microsoft.EntityFrameworkCore;
using Model.OrderCriteria;
using Shared;
namespace DbDataManager.Service;
public class ParagraphDataService : IParagraphService<ParagraphEntity>
{
private UserDbContext DbContext { get; set; }
public ParagraphDataService(UserDbContext context)
{
DbContext = context;
context.Database.EnsureCreated();
}
public ParagraphEntity GetParagraphById(int id)
{
var paragraphEntity = DbContext.Paragraphs.FirstOrDefault(u => u.Id == id);
if (paragraphEntity == null)
{
throw new ArgumentException("Impossible de trouver le paragraphe", nameof(id));
}
return paragraphEntity;
}
public ParagraphEntity GetParagraphByTitle(string title)
{
var paragraphEntity = DbContext.Paragraphs.FirstOrDefault(u => u.Title == title);
if (paragraphEntity == null)
{
throw new ArgumentException("Impossible de trouver le paragraphe", nameof(title));
}
return paragraphEntity;
}
public IEnumerable<ParagraphEntity> GetParagraphs(int page, int number, ParagraphOrderCriteria orderCriteria)
{
return DbContext.Paragraphs.Skip((page - 1) * number).Take(number).ToList()
.Select(u => u);
}
public bool DeleteParagraph(int id)
{
var paragraphEntity = DbContext.Paragraphs.FirstOrDefault(u => u.Id == id);
if (paragraphEntity == null)
{
return false;
}
DbContext.Paragraphs.Remove(paragraphEntity);
DbContext.SaveChangesAsync();
return true;
}
public ParagraphEntity UpdateParagraph(int id, ParagraphEntity paragraph)
{
var updatingParagraph = DbContext.Paragraphs.FirstOrDefault(u => u.Id == id);
if (updatingParagraph == null)
{
throw new ArgumentException("Impossible de trouver le paragraphe", nameof(id));
}
updatingParagraph.Title = paragraph.Title;
updatingParagraph.Content = paragraph.Content;
updatingParagraph.Info = paragraph.Info;
updatingParagraph.Query = paragraph.Query;
updatingParagraph.Comment = paragraph.Comment;
updatingParagraph.LessonId = paragraph.LessonId;
// Permet d'indiquer en Db que l'entité a été modifiée.
DbContext.Entry(updatingParagraph).State = EntityState.Modified;
DbContext.SaveChangesAsync();
return updatingParagraph;
}
public ParagraphEntity CreateParagraph(string title, string content, string info, string query, string comment, int lessonId)
{
var newParagraphEntity = new ParagraphEntity()
{
Title = title,
Content = content,
Info = info,
Query = query,
Comment = comment,
LessonId = lessonId
};
DbContext.Paragraphs.Add(newParagraphEntity);
DbContext.SaveChangesAsync();
return newParagraphEntity;
}
}

@ -0,0 +1,89 @@
using DbContextLib;
using Entities;
using Microsoft.EntityFrameworkCore;
using Model.OrderCriteria;
using Shared;
namespace DbDataManager.Service;
public class SuccessDataService : ISuccessService<SuccessEntity>
{
private UserDbContext DbContext { get; set; }
public SuccessDataService(UserDbContext context)
{
DbContext = context;
context.Database.EnsureCreated();
}
public SuccessEntity GetSuccessByUserId(int id)
{
var successEntity = DbContext.Successes.FirstOrDefault(u => u.UserId == id);
if (successEntity == null)
{
throw new ArgumentException("Impossible de trouver le succès avec l'user id", nameof(id));
}
return successEntity;
}
public SuccessEntity GetSuccessByInquiryId(int id)
{
var successEntity = DbContext.Successes.FirstOrDefault(u => u.InquiryId == id);
if (successEntity == null)
{
throw new ArgumentException("Impossible de trouver le succès avec l'inquiry id", nameof(id));
}
return successEntity;
}
public IEnumerable<SuccessEntity> GetSuccesses(int page, int number, SuccessOrderCriteria orderCriteria)
{
return DbContext.Successes.Skip((page - 1) * number).Take(number).ToList()
.Select(u => u);
}
public bool DeleteSuccess(int id)
{
var userEntity = DbContext.Successes.FirstOrDefault(u => u.UserId == id);
if (userEntity == null)
{
return false;
}
DbContext.Successes.Remove(userEntity);
DbContext.SaveChangesAsync();
return true;
}
public SuccessEntity UpdateSuccess(int id, SuccessEntity success)
{
var updatingSuccess = DbContext.Successes.FirstOrDefault(u => u.UserId == id);
if (updatingSuccess == null)
{
throw new ArgumentException("Impossible de trouver le succès avec l'user id", nameof(id));
}
updatingSuccess.UserId = success.UserId;
updatingSuccess.InquiryId = success.InquiryId;
updatingSuccess.IsFinished = success.IsFinished;
// Permet d'indiquer en Db que l'entité a été modifiée.
DbContext.Entry(updatingSuccess).State = EntityState.Modified;
DbContext.SaveChangesAsync();
return updatingSuccess;
}
public SuccessEntity CreateSuccess(int userId, int inquiryId, bool isFinished)
{
var newSuccessEntity = new SuccessEntity()
{
UserId = userId,
InquiryId = inquiryId,
IsFinished = isFinished,
};
DbContext.Successes.Add(newSuccessEntity);
DbContext.SaveChangesAsync();
return newSuccessEntity;
}
}

@ -1,12 +1,14 @@
using DbContextLib;
using Entities;
using Microsoft.EntityFrameworkCore;
using Model.OrderCriteria;
using Shared;
namespace DbDataManager.Service;
public class UserDataService : IUserService<UserEntity>
{
private UserDbContext DbContext { get; set; }
public UserDataService(UserDbContext context)
@ -37,7 +39,7 @@ public class UserDataService : IUserService<UserEntity>
return userEntity;
}
public IEnumerable<UserEntity> GetUsers(int page, int number)
public IEnumerable<UserEntity> GetUsers(int page, int number, UserOrderCriteria orderCriteria)
{
return DbContext.Users.Skip((page - 1) * number).Take(number).ToList()
.Select(u => u);

@ -1,5 +1,5 @@
namespace Dto
{
namespace Dto;
public class BlackListDTO
{
public string Email { get; set; }
@ -11,4 +11,3 @@
ExpirationDate = expirationDate;
}
}
}

@ -1,14 +1,28 @@
namespace Dto
{
public class ContentLessonDTO
namespace Dto;
public abstract class ContentLessonDTO
{
public int Id { get; set; }
public string ContentContent { get; set; }
public string ContentTitle { get; set; }
public int LessonId { get; set; }
public int LessonPartId { get; set; }
public ContentLessonDTO(int lessonId, int lessonPartId)
protected ContentLessonDTO(int id, string contentContent, string contentTitle, int lessonId)
{
Id = id;
ContentContent = contentContent;
ContentTitle = contentTitle;
LessonId = lessonId;
}
protected ContentLessonDTO(string contentContent, string contentTitle, int lessonId)
{
ContentContent = contentContent;
ContentTitle = contentTitle;
LessonId = lessonId;
LessonPartId = lessonPartId;
}
protected ContentLessonDTO()
{
}
}

@ -1,5 +1,5 @@
namespace Dto
{
namespace Dto;
public class InquiryDTO
{
public int Id { get;}
@ -22,5 +22,13 @@
Database = database;
InquiryTable = inquiryTable;
}
public InquiryDTO(string title, string description, bool isUser, int database, int inquiryTable)
{
Title = title;
Description = description;
IsUser = isUser;
Database = database;
InquiryTable = inquiryTable;
}
}

@ -1,5 +1,5 @@
namespace Dto
{
namespace Dto;
public class InquiryTableDTO
{
@ -16,4 +16,3 @@
ConnectionInfo = connectionInfo;
}
}
}

@ -1,11 +1,12 @@
namespace Dto
{
namespace Dto;
public class LessonDTO
{
public int Id { get; }
public string? Title { get; set; }
public string? LastPublisher { get; set; }
public DateOnly? LastEdit { get; set; }
public ICollection<ContentLessonDTO> Content { get; set; } = new List<ContentLessonDTO>();
public LessonDTO() { }
public LessonDTO(int id, string title, string lastPublisher, DateOnly? lastEdit)
@ -23,4 +24,3 @@
LastEdit = lastEdit;
}
}
}

@ -1,5 +1,5 @@
namespace Dto
{
namespace Dto;
public class NotepadDTO
{
public int Id { get; set; }
@ -23,4 +23,3 @@
Notes = notes;
}
}
}

@ -1,32 +1,37 @@
namespace Dto
{
public class ParagraphDTO
namespace Dto;
public class ParagraphDTO : ContentLessonDTO
{
public int Id { get; }
public string Title { get; set; }
public string Content { get; set; }
public string Info { get; set; }
public string Query { get; set; }
public string Comment { get; set; }
public ParagraphDTO() { }
public ParagraphDTO(int id, string title, string content, string info, string query, string comment)
public ParagraphDTO(string title, string content, string info, string query, string comment, int lessonId) :
base(content,
title, lessonId)
{
Id = id;
Title = title;
Content = content;
Info = info;
Query = query;
Comment = comment;
}
public ParagraphDTO(string title, string content, string info, string query, string comment)
public ParagraphDTO(int id, string title, string content, string info, string query, string comment, int lessonId) :
base(id, content,
title, lessonId)
{
Id = id;
Title = title;
Content = content;
Info = info;
Query = query;
Comment = comment;
}
public ParagraphDTO() : base()
{
}
}

@ -1,5 +1,5 @@
namespace Dto
{
namespace Dto;
public class SolutionDTO
{
public int OwnerId { get; set; }
@ -27,4 +27,3 @@
Explanation = explanation;
}
}
}

@ -1,5 +1,5 @@
namespace Dto
{
namespace Dto;
public class SuccessDTO
{
public int UserId { get; set; }
@ -15,4 +15,3 @@
IsFinished = isFinished;
}
}
}

@ -1,5 +1,5 @@
namespace Dto
{
namespace Dto;
public class UserDTO
{
public int Id { get; set; }
@ -31,4 +31,3 @@
return $"{Id}\t{Username}\t{Email}\t{IsAdmin}";
}
}
}

@ -3,22 +3,37 @@
namespace Entities;
[Table("ContentLesson")]
public class ContentLessonEntity
public abstract class ContentLessonEntity
{
[ForeignKey(nameof(Lesson))]
public int LessonId { get; set; }
public LessonEntity Lesson { get; set; }
public int Id { get; set; }
public string ContentContent { get; set; }
public string ContentTitle { get; set; }
[ForeignKey(nameof(Lesson))] public int LessonId { get; set; }
public LessonEntity Lesson { get; set; } = null!;
[ForeignKey(nameof(Paragraph))]
public int LessonPartId { get; set; }
public ParagraphEntity Paragraph { get; set; }
protected ContentLessonEntity()
{
}
public ContentLessonEntity(){}
public ContentLessonEntity(int lessonId, LessonEntity lesson, int lessonPartId, ParagraphEntity paragraph)
protected ContentLessonEntity(int id, string contentContent, string contentTitle)
{
Id = id;
ContentContent = contentContent;
ContentTitle = contentTitle;
}
protected ContentLessonEntity(int id, int lessonId, string contentContent, string contentTitle)
{
Id = id;
LessonId = lessonId;
Lesson = lesson;
LessonPartId = lessonPartId;
Paragraph = paragraph;
ContentContent = contentContent;
ContentTitle = contentTitle;
}
protected ContentLessonEntity(string contentContent, string contentTitle)
{
ContentContent = contentContent;
ContentTitle = contentTitle;
}
}

@ -1,39 +1,52 @@
using System.ComponentModel.DataAnnotations;
namespace Entities;
namespace Entities
{
public class InquiryEntity
{
public int Id { get; }
public string Title { get; set; }
public string Description { get; set; }
public bool IsUser { get; set; }
public int IdDatabase { get; set; }
public InquiryTableEntity Database { get; set; }
public int IdSolution { get; set; }
public SolutionEntity Solution { get; set; }
public InquiryEntity() { }
public InquiryEntity() {}
public InquiryEntity(int id)
{
Id = id;
}
public InquiryEntity(int id, string title, string description, bool isUser, InquiryTableEntity database, SolutionEntity solution)
public InquiryEntity(int id, string title, string description, bool isUser, InquiryTableEntity database,
SolutionEntity inquiryTable)
{
Id = id;
Title = title;
Description = description;
IsUser = isUser;
Database = database;
Solution = solution;
Solution = inquiryTable;
}
public InquiryEntity(string title, string description, bool isUser, InquiryTableEntity database, SolutionEntity solution)
public InquiryEntity(string title, string description, bool isUser, InquiryTableEntity database,
SolutionEntity inquiryTable)
{
Id = 0;
Title = title;
Description = description;
IsUser = isUser;
Database = database;
Solution = solution;
Solution = inquiryTable;
}
public InquiryEntity(int id, string title, string description, bool isUser, int database,
int inquiryTable)
{
Id = id;
Title = title;
Description = description;
IsUser = isUser;
IdDatabase = database;
IdSolution = inquiryTable;
}
}

@ -9,13 +9,10 @@ public class LessonEntity
public string? Title { get; set; }
public string? LastPublisher { get; set; }
public DateOnly? LastEdit { get; set; }
public ICollection<ContentLessonEntity> Content { get; set; } = new List<ContentLessonEntity>();
public LessonEntity() { }
public LessonEntity(int id)
{
Id = id;
}
public LessonEntity(int id, string title, string lastPublisher, DateOnly? lastEdit)
{
Id = id;

@ -3,33 +3,34 @@
namespace Entities;
[Table("Paragraph")]
public class ParagraphEntity
public class ParagraphEntity : ContentLessonEntity
{
public int Id { get; set; }
// ID
// ContentContent
// ContentTitle
// LessonId
public string Title { get; set; }
public string Content { get; set; }
public string Info { get; set; }
public string Query { get; set; }
public string Comment { get; set; }
public ParagraphEntity() { }
public ParagraphEntity(int id)
public ParagraphEntity()
{
Id = id;
}
public ParagraphEntity(int id, string title, string content, string info, string query, string comment)
public ParagraphEntity(int id, string title, string content, string info, string query,
string comment, int idLesson) : base(id, idLesson, content, title)
{
Id = id;
Title = title;
Content = content;
Info = info;
Query = query;
Comment = comment;
}
public ParagraphEntity(string title, string content, string info, string query, string comment)
public ParagraphEntity(string title, string content, string info, string query, string comment) : base(content,
title)
{
Title = title;
Content = content;
@ -37,4 +38,9 @@ public class ParagraphEntity
Query = query;
Comment = comment;
}
public object FromEntityToModel()
{
throw new NotImplementedException();
}
}

@ -41,4 +41,13 @@ public class SolutionEntity
MurderWeapon = murderWeapon;
Explaination = explaination;
}
public SolutionEntity(int ownerId, string murdererFirstName, string murdererLastName, string murderPlace, string murderWeapon, string explanation)
{
OwnerId = ownerId;
MurdererFirstName = murdererFirstName;
MurdererLastName = murdererLastName;
MurderPlace = murderPlace;
MurderWeapon = murderWeapon;
Explaination = explanation;
}
}

@ -1,5 +1,5 @@
namespace ModelToEntities.Business
{
namespace Model;
public class BlackList
{
public string Email { get; set; }
@ -11,4 +11,3 @@
ExpirationDate = expirationDate;
}
}
}

@ -1,14 +1,24 @@
namespace ModelToEntities.Business
{
public class ContentLesson
namespace Model;
public abstract class ContentLesson
{
public ContentLesson(int lessonId, int lessonPartId)
public int Id { get; set; }
public string ContentContent { get; set; }
public string ContentTitle { get; set; }
public int LessonId { get; set; }
protected ContentLesson(string contentContent, string contentTitle)
{
LessonId = lessonId;
LessonPartId = lessonPartId;
ContentContent = contentContent;
ContentTitle = contentTitle;
}
public int LessonId { get; set; }
public int LessonPartId { get; set; }
protected ContentLesson(int id, string contentContent, string contentTitle, int lessonId)
{
Id = id;
ContentContent = contentContent;
ContentTitle = contentTitle;
LessonId = lessonId;
}
}

@ -1,5 +1,5 @@
namespace ModelToEntities.Business
{
namespace Model;
public class Inquiry
{
public int Id { get; set; }
@ -21,4 +21,3 @@
InquiryTable = inquiryTable;
}
}
}

@ -1,5 +1,5 @@
namespace ModelToEntities.Business
{
namespace Model;
public class InquiryTable
{
public int OwnerId { get; set; }
@ -15,4 +15,3 @@
}
}
}

@ -1,18 +1,13 @@
namespace ModelToEntities.Business
{
namespace Model;
public class Lesson
{
public int Id { get; }
public string? Title { get; set; }
public string? LastPublisher { get; set; }
public DateOnly? LastEdit { get; set; }
public ICollection<ContentLesson> Content { get; set; } = new List<ContentLesson>();
public Lesson() { }
public Lesson(int id)
{
Id = id;
}
public Lesson(int id, string title, string lastPublisher, DateOnly? lastEdit)
{
Id = id;
@ -28,4 +23,3 @@
LastEdit = lastEdit;
}
}
}

@ -1,5 +1,5 @@
namespace ModelToEntities.Business
{
namespace Model;
public class Notepad
{
public int Id { get; set; }
@ -23,4 +23,3 @@
Notes = notes;
}
}
}

@ -0,0 +1,6 @@
namespace Model.OrderCriteria;
public enum InquiryOrderCriteria
{
None, ByTitle, ByDescription, ByIsUser
}

@ -0,0 +1,6 @@
namespace Model.OrderCriteria;
public enum LessonOrderCriteria
{
None, ByTitle, ByLastPublisher, ByLastEdit
}

@ -0,0 +1,6 @@
namespace Model.OrderCriteria;
public enum ParagraphOrderCriteria
{
None, ByTitle, ByContent, ByInfo, ByQuery, ByComment
}

@ -0,0 +1,6 @@
namespace Model.OrderCriteria;
public enum SuccessOrderCriteria
{
None, ByUserId, ByInquiryId, ByIsFinished
}

@ -0,0 +1,6 @@
namespace Model.OrderCriteria;
public enum UserOrderCriteria
{
None, ById, ByUsername, ByEmail, ByIsAdmin
}

@ -1,37 +1,24 @@
namespace ModelToEntities.Business
{
public class Paragraph
{
public int Id { get; }
public string? Title { get; set; }
public string? Content { get; set; }
public string? Info { get; set; }
public string? Query { get; set; }
public string? Comment { get; set; }
public Paragraph() { }
namespace Model;
public Paragraph(int id)
public class Paragraph : ContentLesson
{
Id = id;
}
public string Info { get; set; }
public string Query { get; set; }
public string Comment { get; set; }
public Paragraph(int id, string title, string content, string info, string query, string comment)
public Paragraph(string title, string content, string info, string query, string comment) : base(content,
title)
{
Id = id;
Title = title;
Content = content;
Info = info;
Query = query;
Comment = comment;
}
public Paragraph(string title, string content, string info, string query, string comment)
public Paragraph(int id, string title, string content, string info, string query, string comment, int lessonId) :
base(id, content, title, lessonId)
{
Title = title;
Content = content;
Info = info;
Query = query;
Comment = comment;
}
}
}

@ -1,5 +1,5 @@
namespace ModelToEntities.Business
{
namespace Model;
public class Solution
{
public int OwnerId { get; set; }
@ -27,4 +27,3 @@
Explanation = explanation;
}
}
}

@ -1,5 +1,5 @@
namespace ModelToEntities.Business
{
namespace Model;
public class Success
{
public int UserId { get; set; }
@ -15,4 +15,3 @@
IsFinished = isFinished;
}
}
}

@ -1,5 +1,5 @@
namespace ModelToEntities.Business
{
namespace Model;
public class User
{
public int Id { get; set; }
@ -18,4 +18,3 @@
IsAdmin = isAdmin;
}
}
}

@ -0,0 +1,14 @@
using Dto;
using Model.OrderCriteria;
namespace Shared;
public interface IInquiryDataService : IInquiryService<InquiryDTO>
{
public IEnumerable<InquiryDTO> GetInquiries(int page, int number, InquiryOrderCriteria orderCriteria);
public InquiryDTO GetInquiryById(int id);
public InquiryDTO GetInquiryByTitle(string title);
public bool DeleteInquiry(int id);
public InquiryDTO UpdateInquiry(int id, InquiryDTO inquiry);
public InquiryDTO CreateInquiry(string title, string description, bool isUser, int tableId, int solutionId);
}

@ -1,8 +1,13 @@
namespace Shared;
using Model.OrderCriteria;
namespace Shared;
public interface IInquiryService<TInquiry>
{
public IEnumerable<TInquiry> GetInquiries(int page, int number);
public IEnumerable<TInquiry> GetInquiries(int page, int number, InquiryOrderCriteria orderCriteria);
public TInquiry GetInquiryById(int id);
public TInquiry GetInquiryByTitle(string title);
public bool DeleteInquiry(int id);
public TInquiry UpdateInquiry(int id, TInquiry inquiry);
public TInquiry CreateInquiry(string title, string description, bool isUser, int tableId, int solutionId);
}

@ -0,0 +1,15 @@
using Dto;
using Model.OrderCriteria;
namespace Shared;
public interface ILessonDataService : ILessonService<LessonDTO>
{
public IEnumerable<LessonDTO> GetLessons(int page, int number, LessonOrderCriteria orderCriteria);
public LessonDTO GetLessonById(int id);
public LessonDTO GetLessonByTitle(string title);
public bool DeleteLesson(int id);
public LessonDTO UpdateLesson(int id, LessonDTO lesson);
public LessonDTO CreateLesson(string title, string lastPublisher, DateOnly? lastEdit);
}

@ -0,0 +1,13 @@
using Model.OrderCriteria;
namespace Shared;
public interface ILessonService<TLesson>
{
public IEnumerable<TLesson> GetLessons(int page, int number, LessonOrderCriteria orderCriteria);
public TLesson GetLessonById(int id);
public TLesson GetLessonByTitle(string title);
public bool DeleteLesson(int id);
public TLesson UpdateLesson(int id, TLesson lesson);
public TLesson CreateLesson(string title, string lastPublisher, DateOnly? lastEdit);
}

@ -0,0 +1,14 @@
using Dto;
using Model.OrderCriteria;
namespace Shared;
public interface IParagraphDataService : IParagraphService<ParagraphDTO>
{
public IEnumerable<ParagraphDTO> GetParagraphs(int page, int number, ParagraphOrderCriteria orderCriteria);
public ParagraphDTO GetParagraphById(int id);
public ParagraphDTO GetParagraphByTitle(string title);
public bool DeleteParagraph(int id);
public ParagraphDTO UpdateParagraph(int id, ParagraphDTO paragraph);
public ParagraphDTO CreateParagraph(string title, string content, string info, string query, string comment, int lessonId);
}

@ -0,0 +1,14 @@
using Model.OrderCriteria;
namespace Shared
{
public interface IParagraphService<TParagraph>
{
public IEnumerable<TParagraph> GetParagraphs(int page, int number, ParagraphOrderCriteria orderCriteria);
public TParagraph GetParagraphById(int id);
public TParagraph GetParagraphByTitle(string title);
public bool DeleteParagraph(int id);
public TParagraph UpdateParagraph(int id, TParagraph paragraph);
public TParagraph CreateParagraph(string title, string content, string info, string query, string comment, int lessonId);
}
}

@ -0,0 +1,14 @@
using Dto;
using Model.OrderCriteria;
namespace Shared;
public interface ISuccessDataService : ISuccessService<SuccessDTO>
{
public IEnumerable<SuccessDTO> GetSuccesses(int page, int number, SuccessOrderCriteria orderCriteria);
public SuccessDTO GetSuccessByUserId(int id);
public SuccessDTO GetSuccessByInquiryId(int id);
public bool DeleteSuccess(int id);
public SuccessDTO UpdateSuccess(int id, SuccessDTO success);
public SuccessDTO CreateSuccess(int userId, int inquiryId, bool isFinished);
}

@ -0,0 +1,14 @@
using Model.OrderCriteria;
namespace Shared
{
public interface ISuccessService<TSuccess>
{
public IEnumerable<TSuccess> GetSuccesses(int page, int number, SuccessOrderCriteria orderCriteria);
public TSuccess GetSuccessByUserId(int id);
public TSuccess GetSuccessByInquiryId(int id);
public bool DeleteSuccess(int id);
public TSuccess UpdateSuccess(int id, TSuccess success);
public TSuccess CreateSuccess(int userId, int inquiryId, bool isFinished);
}
}

@ -0,0 +1,14 @@
using Dto;
using Model.OrderCriteria;
namespace Shared;
public interface IUserDataService : IUserService<UserDTO>
{
public IEnumerable<UserDTO> GetUsers(int page, int number, UserOrderCriteria orderCriteria);
public UserDTO GetUserById(int id);
public UserDTO GetUserByUsername(string username);
public bool DeleteUser(int id);
public UserDTO UpdateUser(int id, UserDTO user);
public UserDTO CreateUser(string username, string password, string email, bool isAdmin);
}

@ -1,8 +1,10 @@
namespace Shared
using Model.OrderCriteria;
namespace Shared
{
public interface IUserService<TUser>
{
public IEnumerable<TUser> GetUsers(int page, int number);
public IEnumerable<TUser> GetUsers(int page, int number, UserOrderCriteria orderCriteria);
public TUser GetUserById(int id);
public TUser GetUserByUsername(string username);
public bool DeleteUser(int id);

@ -0,0 +1,98 @@
using Entities;
using Microsoft.EntityFrameworkCore;
using Dto;
using Model.OrderCriteria;
using DbContextLib;
using Shared.Mapper;
namespace Shared;
public class InquiryDataService : IInquiryDataService
{
private UserDbContext DbContext { get; set; }
public InquiryDataService(UserDbContext context)
{
DbContext = context;
context.Database.EnsureCreated();
}
public IEnumerable<InquiryDTO> GetInquiries(int page, int number, InquiryOrderCriteria orderCriteria)
{
IQueryable<InquiryEntity> query = DbContext.Inquiries.Skip((page - 1) * number).Take(number);
switch (orderCriteria)
{
case InquiryOrderCriteria.None:
break;
case InquiryOrderCriteria.ByTitle:
query = query.OrderBy(s => s.Title);
break;
case InquiryOrderCriteria.ByDescription:
query = query.OrderBy(s => s.Description);
break;
case InquiryOrderCriteria.ByIsUser:
query = query.OrderBy(s => s.IsUser);
break;
default:
break;
}
var inquiries = query.ToList();
return inquiries.Select(s => s.FromEntityToDTO());
}
public InquiryDTO GetInquiryById(int id)
{
var inquiryEntity = DbContext.Inquiries.FirstOrDefault(i => i.Id == id);
if (inquiryEntity == null)
{
throw new ArgumentException("Impossible de trouver l'enquête", nameof(id));
}
return inquiryEntity.FromEntityToDTO();
}
public InquiryDTO GetInquiryByTitle(string title)
{
var inquiryEntity = DbContext.Inquiries.FirstOrDefault(i => i.Title == title);
if (inquiryEntity == null)
{
throw new ArgumentException("Impossible de trouver l'enquête", nameof(title));
}
return inquiryEntity.FromEntityToDTO();
}
public InquiryDTO CreateInquiry(string title, string description, bool isUser, int tableId, int solutionId)
{
var newInquiryEntity = new InquiryDTO(title, description, isUser, tableId, solutionId);
DbContext.Inquiries.Add(newInquiryEntity.FromDTOToEntity());
DbContext.SaveChangesAsync();
return newInquiryEntity;
}
public bool DeleteInquiry(int id)
{
var inquiryEntity = DbContext.Inquiries.FirstOrDefault(u => u.Id == id);
if (inquiryEntity == null)
{
return false;
}
DbContext.Inquiries.Remove(inquiryEntity);
DbContext.SaveChangesAsync();
return true;
}
public InquiryDTO UpdateInquiry(int id, InquiryDTO inquiry)
{
var updatingInquiry = DbContext.Inquiries.FirstOrDefault(u => u.Id == id);
if (updatingInquiry == null)
{
throw new ArgumentException("Impossible de trouver l'enquête", nameof(id));
}
updatingInquiry.Title = inquiry.Title;
updatingInquiry.Description = inquiry.Description;
updatingInquiry.IsUser = inquiry.IsUser;
updatingInquiry.IdDatabase = inquiry.Database;
updatingInquiry.IdSolution = inquiry.InquiryTable;
DbContext.SaveChangesAsync();
return updatingInquiry.FromEntityToDTO();
}
}

@ -0,0 +1,103 @@
using DbContextLib;
using Entities;
using Microsoft.EntityFrameworkCore;
using Dto;
using Model.OrderCriteria;
using Shared.Mapper;
namespace Shared;
public class LessonDataService : ILessonDataService
{
private UserDbContext DbContext { get; set; }
public LessonDataService(UserDbContext context)
{
DbContext = context;
context.Database.EnsureCreated();
}
public IEnumerable<LessonDTO> GetLessons(int page, int number, LessonOrderCriteria orderCriteria)
{
IQueryable<LessonEntity> query = DbContext.Lessons.Skip((page - 1) * number).Take(number);
switch (orderCriteria)
{
case LessonOrderCriteria.None:
break;
case LessonOrderCriteria.ByTitle:
query = query.OrderBy(s => s.Title);
break;
case LessonOrderCriteria.ByLastPublisher:
query = query.OrderBy(s => s.LastPublisher);
break;
case LessonOrderCriteria.ByLastEdit:
query = query.OrderBy(s => s.LastEdit);
break;
default:
break;
}
var lessons = query.ToList();
return lessons.Select(s => s.FromEntityToDTO());
}
public LessonDTO GetLessonById(int id)
{
var lessonEntity = DbContext.Lessons.FirstOrDefault(u => u.Id == id);
if (lessonEntity == null)
{
throw new ArgumentException("Impossible de trouver la leçon", nameof(id));
}
return lessonEntity.FromEntityToDTO();
}
public LessonDTO GetLessonByTitle(string title)
{
var lessonEntity = DbContext.Lessons.FirstOrDefault(u => u.Title == title);
if (lessonEntity == null)
{
throw new ArgumentException("Impossible de trouver la leçon", nameof(title));
}
return lessonEntity.FromEntityToDTO();
}
public bool DeleteLesson(int id)
{
var lessonEntity = DbContext.Lessons.FirstOrDefault(l => l.Id == id);
if (lessonEntity == null)
{
return false;
}
DbContext.Lessons.Remove(lessonEntity);
DbContext.SaveChangesAsync();
return true;
}
public LessonDTO UpdateLesson(int id, LessonDTO lesson)
{
var updatingLesson = DbContext.Lessons.FirstOrDefault(l => l.Id == id);
if (updatingLesson == null)
{
throw new ArgumentException("Impossible de trouver la leçon", nameof(id));
}
updatingLesson.Title = lesson.Title;
updatingLesson.LastPublisher = lesson.LastPublisher;
updatingLesson.LastEdit = lesson.LastEdit;
DbContext.SaveChangesAsync();
return updatingLesson.FromEntityToDTO();
}
public LessonDTO CreateLesson(string title, string lastPublisher, DateOnly? lastEdit)
{
var newLessonEntity = new LessonDTO()
{
Title = title,
LastPublisher = lastPublisher,
LastEdit = lastEdit,
};
DbContext.Lessons.Add(newLessonEntity.FromDTOToEntity());
DbContext.SaveChangesAsync();
return newLessonEntity;
}
}

@ -1,37 +1,37 @@
using Dto;
using Entities;
using ModelToEntities.Business;
using Model;
namespace Shared.Mapper;
public static class BlackListMapper
{
public static BlackListDTO FromModelToDTO(BlackList model)
public static BlackListDTO FromModelToDTO(this BlackList model)
{
return new BlackListDTO(model.Email, model.ExpirationDate);
}
public static BlackListDTO FromEntityToDTO(BlackListEntity ent)
public static BlackListDTO FromEntityToDTO(this BlackListEntity ent)
{
return new BlackListDTO(ent.Email, ent.ExpirationDate);
}
public static BlackList FromDTOToModel(BlackListDTO dto)
public static BlackList FromDTOToModel(this BlackListDTO dto)
{
return new BlackList(dto.Email, dto.ExpirationDate);
}
public static BlackList FromEntityToModel(BlackListEntity ent)
public static BlackList FromEntityToModel(this BlackListEntity ent)
{
return new BlackList(ent.Email, ent.ExpirationDate);
}
public static BlackListEntity FromDTOToEntity(BlackListDTO dto)
public static BlackListEntity FromDTOToEntity(this BlackListDTO dto)
{
return new BlackListEntity(dto.Email, dto.ExpirationDate);
}
public static BlackListEntity FromModelToEntity(BlackList model)
public static BlackListEntity FromModelToEntity(this BlackList model)
{
return new BlackListEntity(model.Email, model.ExpirationDate);
}

@ -1,34 +0,0 @@
using Dto;
using Entities;
using ModelToEntities.Business;
namespace Shared.Mapper;
public static class ContentLessonMapper
{
public static ContentLesson FromDTOToModel(this ContentLessonDTO dto)
{
return new ContentLesson(dto.LessonId, dto.LessonPartId);
}
public static ContentLesson FromEntityToModel(this ContentLessonEntity ent)
{
return new ContentLesson(ent.LessonId, ent.LessonPartId);
}
public static ContentLessonDTO FromModelToDTO(this ContentLesson les)
{
return new ContentLessonDTO(les.LessonId, les.LessonPartId);
}
public static ContentLessonDTO FromEntityToDTO(this ContentLessonEntity ent)
{
return new ContentLessonDTO(ent.LessonId, ent.LessonPartId);
}
public static ContentLessonEntity FromModelToEntity(this ContentLesson les)
{
return new ContentLessonEntity(les.LessonId, new LessonEntity(les.LessonId), les.LessonPartId,
new ParagraphEntity(les.LessonPartId));
}
}

@ -1,6 +1,6 @@
using Dto;
using Entities;
using ModelToEntities.Business;
using Model;
namespace Shared.Mapper;

@ -1,6 +1,6 @@
using Dto;
using Entities;
using ModelToEntities.Business;
using Model;
namespace Shared.Mapper;

@ -1,37 +1,37 @@
using Dto;
using Entities;
using ModelToEntities.Business;
using Model;
namespace Shared.Mapper;
public static class LessonMapper
{
public static LessonDTO FromModelToDTO(Lesson model)
public static LessonDTO FromModelToDTO(this Lesson model)
{
return new LessonDTO(model.Id, model.Title, model.LastPublisher, model.LastEdit);
}
public static LessonDTO FromEntityToDTO(LessonEntity model)
public static LessonDTO FromEntityToDTO(this LessonEntity model)
{
return new LessonDTO(model.Id, model.Title, model.LastPublisher, model.LastEdit);
}
public static LessonEntity FromModelToEntity(Lesson model)
public static LessonEntity FromModelToEntity(this Lesson model)
{
return new LessonEntity(model.Id, model.Title, model.LastPublisher, model.LastEdit);
}
public static LessonEntity FromDTOToEntity(LessonDTO dto)
public static LessonEntity FromDTOToEntity(this LessonDTO dto)
{
return new LessonEntity(dto.Id, dto.Title, dto.LastPublisher, dto.LastEdit);
}
public static Lesson FromDTOToModel(LessonDTO dto)
public static Lesson FromDTOToModel(this LessonDTO dto)
{
return new Lesson(dto.Id, dto.Title, dto.LastPublisher, dto.LastEdit);
}
public static Lesson FromEntityToModel(LessonEntity entity)
public static Lesson FromEntityToModel(this LessonEntity entity)
{
return new Lesson(entity.Id, entity.Title, entity.LastPublisher, entity.LastEdit);
}

@ -1,6 +1,6 @@
using Dto;
using Entities;
using ModelToEntities.Business;
using Model;
namespace Shared.Mapper;

@ -1,38 +1,42 @@
using Dto;
using Entities;
using ModelToEntities.Business;
using Model;
namespace Shared.Mapper;
public static class ParagraphMapper
{
public static Paragraph FromDTOToModel(ParagraphDTO dto)
public static Paragraph FromDTOToModel(this ParagraphDTO dto)
{
return new Paragraph(dto.Id, dto.Title, dto.Content, dto.Info, dto.Query, dto.Comment);
return new Paragraph(dto.ContentTitle, dto.ContentContent, dto.Info, dto.Query, dto.Comment);
}
public static Paragraph FromEntityToModel(ParagraphEntity model)
public static Paragraph FromEntityToModel(this ParagraphEntity model)
{
return new Paragraph(model.Id, model.Title, model.Content, model.Info, model.Query, model.Comment);
return new Paragraph(model.ContentTitle, model.ContentContent, model.Info, model.Query, model.Comment);
}
public static ParagraphDTO FromEntityToDTO(ParagraphEntity model)
public static ParagraphDTO FromEntityToDTO(this ParagraphEntity model)
{
return new ParagraphDTO(model.Id, model.Title, model.Content, model.Info, model.Query, model.Comment);
return new ParagraphDTO(model.Id, model.ContentTitle, model.ContentContent, model.Info, model.Query,
model.Comment, model.LessonId);
}
public static ParagraphDTO FromModelToDTO(Paragraph model)
public static ParagraphDTO FromModelToDTO(this Paragraph model)
{
return new ParagraphDTO(model.Id, model.Title, model.Content, model.Info, model.Query, model.Comment);
return new ParagraphDTO(model.Id, model.ContentTitle, model.ContentContent, model.Info, model.Query,
model.Comment, model.LessonId);
}
public static ParagraphEntity FromDTOToEntity(ParagraphDTO dto)
public static ParagraphEntity FromDTOToEntity(this ParagraphDTO dto)
{
return new ParagraphEntity(dto.Id, dto.Title, dto.Content, dto.Info, dto.Query, dto.Comment);
return new ParagraphEntity(dto.Id, dto.ContentTitle, dto.ContentContent, dto.Info, dto.Query, dto.Comment,
dto.LessonId);
}
public static Paragraph FromModelToEntity(Paragraph model)
public static ParagraphEntity FromModelToEntity(this Paragraph model)
{
return new Paragraph(model.Id, model.Title, model.Content, model.Info, model.Query, model.Comment);
return new ParagraphEntity(model.Id, model.ContentTitle, model.ContentContent, model.Info, model.Query,
model.Comment, model.LessonId);
}
}

@ -1,6 +1,6 @@
using Dto;
using Entities;
using ModelToEntities.Business;
using Model;
namespace Shared.Mapper;

@ -1,6 +1,6 @@
using Dto;
using Entities;
using ModelToEntities.Business;
using Model;
namespace Shared.Mapper;

@ -1,6 +1,6 @@
using Dto;
using Entities;
using ModelToEntities.Business;
using Model;
namespace Shared.Mapper;

@ -0,0 +1,116 @@
using Entities;
using Microsoft.EntityFrameworkCore;
using Dto;
using DbContextLib;
using Model.OrderCriteria;
using Shared;
using Shared.Mapper;
namespace Shared;
public class ParagraphDataService : IParagraphDataService
{
private UserDbContext DbContext { get; set; }
public ParagraphDataService(UserDbContext context)
{
DbContext = context;
context.Database.EnsureCreated();
}
public IEnumerable<ParagraphDTO> GetParagraphs(int page, int number, ParagraphOrderCriteria orderCriteria)
{
IQueryable<ParagraphEntity> query = DbContext.Paragraphs.Skip((page - 1) * number).Take(number);
switch (orderCriteria)
{
case ParagraphOrderCriteria.None:
break;
case ParagraphOrderCriteria.ByTitle:
query = query.OrderBy(s => s.Title);
break;
case ParagraphOrderCriteria.ByContent:
query = query.OrderBy(s => s.Content);
break;
case ParagraphOrderCriteria.ByInfo:
query = query.OrderBy(s => s.Info);
break;
case ParagraphOrderCriteria.ByQuery:
query = query.OrderBy(s => s.Query);
break;
case ParagraphOrderCriteria.ByComment:
query = query.OrderBy(s => s.Comment);
break;
default:
break;
}
var paragraphs = query.ToList();
return paragraphs.Select(s => s.FromEntityToDTO());
}
public ParagraphDTO GetParagraphById(int id)
{
var paragraphEntity = DbContext.Paragraphs.FirstOrDefault(u => u.Id == id);
if (paragraphEntity == null)
{
throw new ArgumentException("Impossible de trouver le paragraphe", nameof(id));
}
return paragraphEntity.FromEntityToDTO();
}
public ParagraphDTO GetParagraphByTitle(string title)
{
var paragraphEntity = DbContext.Paragraphs.FirstOrDefault(u => u.Title == title);
if (paragraphEntity == null)
{
throw new ArgumentException("Impossible de trouver le paragraphe", nameof(title));
}
return paragraphEntity.FromEntityToDTO();
}
public bool DeleteParagraph(int id)
{
var paragraphEntity = DbContext.Paragraphs.FirstOrDefault(p => p.Id == id);
if (paragraphEntity == null)
{
return false;
}
DbContext.Paragraphs.Remove(paragraphEntity);
DbContext.SaveChangesAsync();
return true;
}
public ParagraphDTO UpdateParagraph(int id, ParagraphDTO paragraphDTO)
{
var updatingParagraph = DbContext.Paragraphs.FirstOrDefault(p => p.Id == id);
if (updatingParagraph == null)
{
throw new ArgumentException("Impossible de trouver le paragraphe", nameof(id));
}
updatingParagraph.Title = paragraphDTO.Title;
updatingParagraph.Content = paragraphDTO.Content;
updatingParagraph.Info = paragraphDTO.Info;
updatingParagraph.Query = paragraphDTO.Query;
updatingParagraph.Comment = paragraphDTO.Comment;
DbContext.SaveChangesAsync();
return updatingParagraph.FromEntityToDTO();
}
public ParagraphDTO CreateParagraph(string title, string content, string info, string query, string comment, int lessonId)
{
var newParagraphEntity = new ParagraphDTO()
{
Title = title,
Content = content,
Info = info,
Query = query,
Comment = comment,
LessonId = lessonId
};
DbContext.Paragraphs.Add(newParagraphEntity.FromDTOToEntity());
DbContext.SaveChangesAsync();
return newParagraphEntity;
}
}

@ -7,6 +7,7 @@
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="..\DbContextLib\DbContextLib.csproj" />
<ProjectReference Include="..\Dto\Dto.csproj" />
<ProjectReference Include="..\EntityFramework\Entities.csproj" />
<ProjectReference Include="..\Model\Model.csproj" />

@ -0,0 +1,103 @@
using Entities;
using Microsoft.EntityFrameworkCore;
using Dto;
using DbContextLib;
using Model.OrderCriteria;
using Shared.Mapper;
namespace Shared;
public class SuccessDataService : ISuccessDataService
{
private UserDbContext DbContext { get; set; }
public SuccessDataService(UserDbContext context)
{
DbContext = context;
context.Database.EnsureCreated();
}
public IEnumerable<SuccessDTO> GetSuccesses(int page, int number, SuccessOrderCriteria orderCriteria)
{
IQueryable<SuccessEntity> query = DbContext.Successes.Skip((page - 1) * number).Take(number);
switch (orderCriteria)
{
case SuccessOrderCriteria.None:
break;
case SuccessOrderCriteria.ByUserId:
query = query.OrderBy(s => s.UserId);
break;
case SuccessOrderCriteria.ByInquiryId:
query = query.OrderBy(s => s.InquiryId);
break;
case SuccessOrderCriteria.ByIsFinished:
query = query.OrderBy(s => s.IsFinished);
break;
default:
break;
}
var successes = query.ToList();
return successes.Select(s => s.FromEntityToDTO());
}
public SuccessDTO GetSuccessByUserId(int id)
{
var userEntity = DbContext.Successes.FirstOrDefault(u => u.UserId == id);
if (userEntity == null)
{
throw new ArgumentException("Impossible de trouver le succès", nameof(id));
}
return userEntity.FromEntityToDTO();
}
public SuccessDTO GetSuccessByInquiryId(int id)
{
var userEntity = DbContext.Successes.FirstOrDefault(u => u.InquiryId == id);
if (userEntity == null)
{
throw new ArgumentException("Impossible de trouver le succès", nameof(id));
}
return userEntity.FromEntityToDTO();
}
public bool DeleteSuccess(int id)
{
var successEntity = DbContext.Successes.FirstOrDefault(u => u.UserId == id);
if (successEntity == null)
{
return false;
}
DbContext.Successes.Remove(successEntity);
DbContext.SaveChangesAsync();
return true;
}
public SuccessDTO UpdateSuccess(int id, SuccessDTO success)
{
var updatingSuccess = DbContext.Successes.FirstOrDefault(u => u.UserId == id);
if (updatingSuccess == null)
{
throw new ArgumentException("Impossible de trouver le succès", nameof(id));
}
updatingSuccess.UserId = success.UserId;
updatingSuccess.InquiryId = success.InquiryId;
updatingSuccess.IsFinished = success.IsFinished;
DbContext.SaveChangesAsync();
return updatingSuccess.FromEntityToDTO();
}
public SuccessDTO CreateSuccess(int userId, int inquiryId, bool isFinished)
{
var newSuccessEntity = new SuccessDTO()
{
UserId = userId,
InquiryId = inquiryId,
IsFinished = isFinished,
};
DbContext.Successes.Add(newSuccessEntity.FromDTOToEntity());
DbContext.SaveChangesAsync();
return newSuccessEntity;
}
}

@ -0,0 +1,121 @@
using Dto;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using Entities;
using Shared.Mapper;
using DbContextLib;
using Model.OrderCriteria;
namespace Shared
{
public class UserDataService : IUserDataService
{
private UserDbContext DbContext { get; set; }
public UserDataService(UserDbContext context)
{
DbContext = context;
context.Database.EnsureCreated();
}
public UserDTO GetUserById(int id)
{
var userEntity = DbContext.Users.FirstOrDefault(u => u.Id == id);
if (userEntity == null)
{
throw new ArgumentException("Impossible de trouver l'utilisateur", nameof(id));
}
return userEntity.FromEntityToDTO();
}
public UserDTO GetUserByUsername(string username)
{
var userEntity = DbContext.Users.FirstOrDefault(u => u.Username == username);
if (userEntity == null)
{
throw new ArgumentException("Impossible de trouver l'utilisateur", nameof(username));
}
return userEntity.FromEntityToDTO();
}
public IEnumerable<UserDTO> GetUsers(int page, int number, UserOrderCriteria orderCriteria)
{
IQueryable<UserEntity> query = DbContext.Users.Skip((page - 1) * number).Take(number);
switch (orderCriteria)
{
case UserOrderCriteria.None:
break;
case UserOrderCriteria.ById:
query = query.OrderBy(s => s.Id);
break;
case UserOrderCriteria.ByUsername:
query = query.OrderBy(s => s.Username);
break;
case UserOrderCriteria.ByEmail:
query = query.OrderBy(s => s.Email);
break;
case UserOrderCriteria.ByIsAdmin:
query = query.OrderBy(s => s.IsAdmin);
break;
default:
break;
}
var users = query.ToList();
return users.Select(s => s.FromEntityToDTO());
}
public bool DeleteUser(int id)
{
var userEntity = DbContext.Users.FirstOrDefault(u => u.Id == id);
if (userEntity == null)
{
return false;
}
DbContext.Users.Remove(userEntity);
DbContext.SaveChangesAsync();
return true;
}
public UserDTO UpdateUser(int id, UserDTO user)
{
var updatingUser = DbContext.Users.FirstOrDefault(u => u.Id == id);
if (updatingUser == null)
{
throw new ArgumentException("Impossible de trouver l'utilisateur", nameof(id));
}
updatingUser.Username = user.Username;
updatingUser.Password = user.Password;
updatingUser.Email = user.Email;
updatingUser.IsAdmin = user.IsAdmin;
DbContext.SaveChangesAsync();
return updatingUser.FromEntityToDTO();
}
public UserDTO CreateUser(string username, string password, string email, bool isAdmin)
{
var newUserEntity = new UserDTO
{
Username = username,
Password = password,
Email = email,
IsAdmin = isAdmin
};
DbContext.Users.Add(newUserEntity.FromDTOToEntity());
DbContext.SaveChangesAsync();
return newUserEntity;
}
}
}

@ -1,4 +1,5 @@
using System.Security.Cryptography;
using System.Runtime.CompilerServices;
using System.Security.Cryptography;
using DbContextLib;
using Entities;
using Microsoft.AspNetCore.Cryptography.KeyDerivation;
@ -46,5 +47,23 @@ public class StubbedContext : UserDbContext
prf: KeyDerivationPrf.HMACSHA256,
iterationCount: 100000,
numBytesRequested: 256 / 8)), "Victor.GABORIT@etu.uca.fr", true));
modelBuilder.Entity<InquiryEntity>().HasData(
new InquiryEntity(1, "L'enquête de la carotte", "La description de l'inquiry1", true, 1, 1),
new InquiryEntity(2, "L'enquête sur les orang outan", "The new description", false, 2, 2),
new InquiryEntity(3, "L'enquête sur les parapluies", "Il pleuvait", false, 3, 3));
modelBuilder.Entity<InquiryTableEntity>().HasData(
new InquiryTableEntity(1, "Inquiry1",
"Server=localhost;Database=Inquiry1;Trusted_Connection=True;MultipleActiveResultSets=true"),
new InquiryTableEntity(2, "Inquiry2",
"Server=localhost;Database=Inquiry2;Trusted_Connection=True;MultipleActiveResultSets=true"),
new InquiryTableEntity(3, "Inquiry3",
"Server=localhost;Database=Inquiry3;Trusted_Connection=True;MultipleActiveResultSets=true"));
modelBuilder.Entity<SolutionEntity>().HasData(
new SolutionEntity(1, "Maxime", "Sapountzis", "La cuisine", "Le couteau", "Parce que c'est Maxime"),
new SolutionEntity(2, "Johnny", "Ratton", "La cuisine", "Le couteau", "Parce que il est ra****"),
new SolutionEntity(3, "Erwan", "Menager", "La salle de bain", "L'arachide", "Parce que c'est Erwan"));
}
}

@ -1,14 +1,14 @@
// See https://aka.ms/new-console-template for more information
using API.Controllers;
using API.Service;
using DbContextLib;
using DbDataManager.Service;
using Dto;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Data.Sqlite;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using Model.OrderCriteria;
using Shared;
var connection = new SqliteConnection("DataSource=:memory:");
connection.Open();
@ -16,46 +16,207 @@ var options = new DbContextOptionsBuilder<UserDbContext>()
.UseSqlite(connection)
.Options;
using ILoggerFactory factory = new LoggerFactory();
ILogger<UserController> logger = factory.CreateLogger<UserController>();
ILogger<UsersController> userLogger = factory.CreateLogger<UsersController>();
ILogger<InquiriesController> inquiryLogger = factory.CreateLogger<InquiriesController>();
ILogger<ParagraphsController> paragraphLogger = factory.CreateLogger<ParagraphsController>();
ILogger<LessonsController> lessonLogger = factory.CreateLogger<LessonsController>();
ILogger<SuccessesController> successLogger = factory.CreateLogger<SuccessesController>();
using (var context = new UserDbContext(options))
{
var controller = new UserController(logger, new UserDataServiceApi(new UserDataService(context)));
var userController = new UsersController(userLogger, new UserDataService(context));
var inquiryController = new InquiriesController(new InquiryDataService(context), inquiryLogger);
var paragraphController = new ParagraphsController(new ParagraphDataService(context), paragraphLogger);
var lessonController = new LessonsController(new LessonDataService(context), lessonLogger);
var successController = new SuccessesController(new SuccessDataService(context), successLogger);
void PrintUsers()
{
Console.WriteLine();
var users = controller.GetUsers(1, 10) as OkObjectResult;
var users = userController.GetUsers(1, 10, UserOrderCriteria.None) as OkObjectResult;
foreach (var item in users.Value as IEnumerable<UserDTO>)
{
Console.WriteLine(item);
}
}
void PrintInquiries()
{
Console.WriteLine();
var inquiries = inquiryController.GetInquiries(1, 10, InquiryOrderCriteria.None) as OkObjectResult;
foreach (var item in inquiries.Value as IEnumerable<InquiryDTO>)
{
Console.WriteLine(item);
}
}
void PrintParagraphs()
{
Console.WriteLine();
var paragraphs = paragraphController.GetParagraphs(1, 10, ParagraphOrderCriteria.None) as OkObjectResult;
foreach (var item in paragraphs.Value as IEnumerable<ParagraphDTO>)
{
Console.WriteLine(item);
}
}
void PrintLessons()
{
Console.WriteLine();
var lessons = lessonController.GetLessons(1, 10, LessonOrderCriteria.None) as OkObjectResult;
foreach (var item in lessons.Value as IEnumerable<LessonDTO>)
{
Console.WriteLine(item);
}
}
void PrintSuccesses()
{
Console.WriteLine();
var successes = successController.GetSuccesses(1, 10, SuccessOrderCriteria.None) as OkObjectResult;
foreach (var item in successes.Value as IEnumerable<SuccessDTO>)
{
Console.WriteLine(item);
}
}
void SearchUserByUsername()
{
Console.WriteLine("\nVeuillez saisir le pseudonyme de l'utilisateur recherché : ");
var username = Console.ReadLine();
var user = controller.GetUserByUsername(username) as OkObjectResult;
var user = userController.GetUserByUsername(username) as OkObjectResult;
if (user == null)
{
Console.WriteLine("Erreur, la requête n'a rien donné.");
return;
}
Console.WriteLine(user.Value as UserDTO);
}
void SearchInquiryByTitle()
{
Console.WriteLine("\nVeuillez saisir le titre de l'enquête recherchée : ");
var title = Console.ReadLine();
var inquiry = inquiryController.GetInquiryByTitle(title) as OkObjectResult;
if (inquiry == null)
{
Console.WriteLine("Erreur, la requête n'a rien donné.");
return;
}
Console.WriteLine(inquiry.Value as InquiryDTO);
}
void SearchParagraphByTitle()
{
Console.WriteLine("\nVeuillez saisir le titre du paragraphe recherché : ");
var title = Console.ReadLine();
var paragraph = paragraphController.GetParagraphByTitle(title) as OkObjectResult;
if (paragraph == null)
{
Console.WriteLine("Erreur, la requête n'a rien donné.");
return;
}
Console.WriteLine(paragraph.Value as ParagraphDTO);
}
void SearchLessonByTitle()
{
Console.WriteLine("\nVeuillez saisir le titre de la leçon recherchée : ");
var title = Console.ReadLine();
var lesson = lessonController.GetLessonByTitle(title) as OkObjectResult;
if (lesson == null)
{
Console.WriteLine("Erreur, la requête n'a rien donné.");
return;
}
Console.WriteLine(lesson.Value as LessonDTO);
}
void SearchSuccessByUserId()
{
Console.WriteLine("\nVeuillez saisir l'identifiant de l'utilisateur du succès recherché : ");
var id = Console.ReadLine();
var success = successController.GetSuccessByUserId(int.Parse(id)) as OkObjectResult;
if (success == null)
{
Console.WriteLine("Erreur, la requête n'a rien donné.");
return;
}
Console.WriteLine(success.Value as SuccessDTO);
}
void SearchUserById()
{
Console.WriteLine("\nVeuillez saisir l'identifiant de l'utilisateur recherché : ");
var id = Console.ReadLine();
var user = controller.GetUserById(int.Parse(id)) as OkObjectResult;
var user = userController.GetUserById(int.Parse(id)) as OkObjectResult;
if (user == null)
{
Console.WriteLine("Erreur, la requête n'a rien donné.");
return;
}
Console.WriteLine(user.Value as UserDTO);
}
void SearchInquiryById()
{
Console.WriteLine("\nVeuillez saisir l'identifiant de l'enquête recherchée : ");
var id = Console.ReadLine();
var inquiry = inquiryController.GetInquiryById(int.Parse(id)) as OkObjectResult;
if (inquiry == null)
{
Console.WriteLine("Erreur, la requête n'a rien donné.");
return;
}
Console.WriteLine(inquiry.Value as InquiryDTO);
}
void SearchParagraphById()
{
Console.WriteLine("\nVeuillez saisir l'identifiant du paragraphe recherché : ");
var id = Console.ReadLine();
var paragraph = paragraphController.GetParagraphById(int.Parse(id)) as OkObjectResult;
if (paragraph == null)
{
Console.WriteLine("Erreur, la requête n'a rien donné.");
return;
}
Console.WriteLine(paragraph.Value as ParagraphDTO);
}
void SearchSuccessByInquiryId()
{
Console.WriteLine("\nVeuillez saisir l'identifiant de l'enquête du succès recherché : ");
var id = Console.ReadLine();
var success = successController.GetSuccessByInquiryId(int.Parse(id)) as OkObjectResult;
if (success == null)
{
Console.WriteLine("Erreur, la requête n'a rien donné.");
return;
}
Console.WriteLine(success.Value as SuccessDTO);
}
void SearchLessonById()
{
Console.WriteLine("\nVeuillez saisir l'identifiant de la leçon recherchée : ");
var id = Console.ReadLine();
var lesson = lessonController.GetLessonById(int.Parse(id)) as OkObjectResult;
if (lesson == null)
{
Console.WriteLine("Erreur, la requête n'a rien donné.");
return;
}
Console.WriteLine(lesson.Value as LessonDTO);
}
void AddUser()
@ -66,23 +227,115 @@ using (var context = new UserDbContext(options))
var email = Console.ReadLine();
Console.WriteLine("Veuillez saisir un mot de passe :");
var mdp = Console.ReadLine();
var res = controller.CreateUser(new UserDTO(username, mdp, email, false));
if(res.GetType() == typeof(CreatedResult)) {
var res = userController.CreateUser(new UserDTO(username, mdp, email, false));
if (res.GetType() == typeof(CreatedResult))
{
Console.WriteLine("\nUtilisateur créé avec succès");
} else
}
else
{
Console.WriteLine("\nErreur lors de la création de l'utilisateur !");
}
}
void AddInquiry()
{
Console.WriteLine("Veuillez saisir le titre :");
var title = Console.ReadLine();
Console.WriteLine("Veuillez saisir une description :");
var description = Console.ReadLine();
Console.WriteLine("Veuillez saisir un isUser (false / true) :");
var isUser = Convert.ToBoolean(Console.ReadLine());
Console.WriteLine("Veuillez saisir l'id de la database :");
var database = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("Veuillez saisir l'id de la solution :");
var solution = Convert.ToInt32(Console.ReadLine());
var res = inquiryController.CreateInquiry(new InquiryDTO(title, description, false, database, solution));
if (res.GetType() == typeof(CreatedResult))
{
Console.WriteLine("\nEnquête créée avec succès");
}
else
{
Console.WriteLine("\nErreur lors de la création de l'enquête !");
}
}
void AddParagraph()
{
Console.WriteLine("Veuillez saisir le titre :");
var title = Console.ReadLine();
Console.WriteLine("Veuillez saisir un contenu :");
var content = Console.ReadLine();
Console.WriteLine("Veuillez saisir une information :");
var info = Console.ReadLine();
Console.WriteLine("Veuillez saisir une query :");
var query = Console.ReadLine();
Console.WriteLine("Veuillez saisir un commentaire :");
var comment = Console.ReadLine();
Console.WriteLine("Veuillez saisir l'id de la leçon :");
var lesson = Convert.ToInt32(Console.ReadLine());
var res = paragraphController.CreateParagraph(new ParagraphDTO(title, content, info, query, comment, lesson));
if (res.GetType() == typeof(CreatedResult))
{
Console.WriteLine("\nParagraphe créé avec succès");
}
else
{
Console.WriteLine("\nErreur lors de la création du paragraphe !");
}
}
void AddLesson()
{
Console.WriteLine("Veuillez saisir le titre :");
var title = Console.ReadLine();
Console.WriteLine("Veuillez saisir votre nom :");
var lastPublisher = Console.ReadLine();
var res = lessonController.CreateLesson(new LessonDTO(title, lastPublisher, DateOnly.FromDateTime(DateTime.Now)));
if (res.GetType() == typeof(CreatedResult))
{
Console.WriteLine("\nLeçon créée avec succès");
}
else
{
Console.WriteLine("\nErreur lors de la création de la leçon !");
}
}
void AddSuccess()
{
Console.WriteLine("Veuillez saisir l'identifiant de l'utilisateur lié au succès :");
var userId = Console.ReadLine();
Console.WriteLine("Veuillez saisir l'identifiant de l'enquête lié au succès :");
var inquiryId = Console.ReadLine();
Console.WriteLine("Veuillez indiquer si l'enquête a été complété (true/false) :");
var isFinished = Console.ReadLine();
var res = successController.CreateSuccess(new SuccessDTO(int.Parse(userId), int.Parse(inquiryId), bool.Parse(isFinished)));
if (res.GetType() == typeof(CreatedResult))
{
Console.WriteLine("\nSuccès créé avec succès");
}
else
{
Console.WriteLine("\nErreur lors de la création du succès !");
}
}
void UpdateUser()
{
Console.WriteLine("Quel est l'identifiant de l'utilisateur à mettre à jour ?");
var id = int.Parse(Console.ReadLine());
var res = (controller.GetUserById(id));
if (res.GetType() == typeof(OkObjectResult)) {
var res = (userController.GetUserById(id));
if (res.GetType() == typeof(OkObjectResult))
{
var user = (res as OkObjectResult).Value as UserDTO;
if (user == null) {
if (user == null)
{
Console.WriteLine("Erreur, un problème est survenu");
return;
}
@ -93,26 +346,228 @@ using (var context = new UserDbContext(options))
var username = Console.ReadLine();
Console.WriteLine("Veuillez saisir l'email :");
var email = Console.ReadLine();
var retour = controller.UpdateUser(id, new UserDTO(id, username, user.Password, email, user.IsAdmin));
var retour = userController.UpdateUser(id, new UserDTO(id, username, user.Password, email, user.IsAdmin));
if (retour.GetType() == typeof(OkObjectResult))
{
Console.WriteLine("Mise à jour effectué avec succès !");
}
else
{
Console.WriteLine("Une erreur est survenue lors de la mise à jour.");
}
}
}
else
{
Console.WriteLine("Une erreur est survenue lors de la mise à jour !");
}
}
void UpdateInquiry()
{
Console.WriteLine("Quel est l'identifiant de l'enquête à mettre à jour ?");
var id = int.Parse(Console.ReadLine());
var res = (inquiryController.GetInquiryById(id));
if (res.GetType() == typeof(OkObjectResult))
{
var user = (res as OkObjectResult).Value as InquiryDTO;
if (user == null)
{
Console.WriteLine("Erreur, un problème est survenu");
return;
}
else
{
Console.WriteLine("Enquête trouvée !\n");
Console.WriteLine("Veuillez saisir le titre :");
var title = Console.ReadLine();
Console.WriteLine("Veuillez saisir la description :");
var description = Console.ReadLine();
Console.WriteLine("Veuillez indiquer si l'enquête est accessible aux visiteurs (0/1) :");
var isUser = Console.ReadLine();
Console.WriteLine("Veuillez saisir un commentaire :");
var database = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("Veuillez saisir un commentaire :");
var inquiryTable = Convert.ToInt32(Console.ReadLine());
var retour = inquiryController.UpdateInquiry(id, new InquiryDTO(id, title, description, bool.Parse(isUser), database, inquiryTable));
if (retour.GetType() == typeof(OkObjectResult))
{
Console.WriteLine("Mise à jour effectué avec succès !");
}
else
{
Console.WriteLine("Une erreur est survenue lors de la mise à jour.");
}
}
}
else
{
Console.WriteLine("Une erreur est survenue lors de la mise à jour !");
}
}
void UpdateParagraph()
{
Console.WriteLine("Quel est l'identifiant du paragraphe à mettre à jour ?");
var id = int.Parse(Console.ReadLine());
var res = (paragraphController.GetParagraphById(id));
if (res.GetType() == typeof(OkObjectResult))
{
var paragraph = (res as OkObjectResult).Value as ParagraphDTO;
if (paragraph == null)
{
Console.WriteLine("Erreur, un problème est survenu");
return;
}
else
{
Console.WriteLine("Paragraphe trouvé !\n");
Console.WriteLine("Veuillez saisir le titre :");
var title = Console.ReadLine();
Console.WriteLine("Veuillez saisir un contenu :");
var content = Console.ReadLine();
Console.WriteLine("Veuillez saisir une information :");
var info = Console.ReadLine();
Console.WriteLine("Veuillez saisir une query :");
var query = Console.ReadLine();
Console.WriteLine("Veuillez saisir un commentaire :");
var comment = Console.ReadLine();
Console.WriteLine("Veuillez saisir l'id de la leçon :");
var lesson = Convert.ToInt32(Console.ReadLine());
var retour = paragraphController.UpdateParagraph(id, new ParagraphDTO(id, title, content, info, query, comment, lesson));
if (retour.GetType() == typeof(OkObjectResult))
{
Console.WriteLine("Mise à jour effectué avec succès !");
} else
}
else
{
Console.WriteLine("Une erreur est survenue lors de la mise à jour.");
}
}
}
else {
else
{
Console.WriteLine("Une erreur est survenue lors de la mise à jour !");
}
}
void UpdateLesson()
{
Console.WriteLine("Quel est l'identifiant de la leçon à mettre à jour ?");
var id = int.Parse(Console.ReadLine());
var res = (lessonController.GetLessonById(id));
if (res.GetType() == typeof(OkObjectResult))
{
var lesson = (res as OkObjectResult).Value as LessonDTO;
if (lesson == null)
{
Console.WriteLine("Erreur, un problème est survenu");
return;
}
else
{
Console.WriteLine("Leçon trouvée !\n");
Console.WriteLine("Veuillez saisir le titre :");
var title = Console.ReadLine();
Console.WriteLine("Veuillez saisir votre nom :");
var lastPublisher = Console.ReadLine();
var retour = lessonController.UpdateLesson(id, new LessonDTO(id, title, lastPublisher, DateOnly.FromDateTime(DateTime.Now)));
if (retour.GetType() == typeof(OkObjectResult))
{
Console.WriteLine("Mise à jour effectué avec succès !");
}
else
{
Console.WriteLine("Une erreur est survenue lors de la mise à jour.");
}
}
}
else
{
Console.WriteLine("Une erreur est survenue lors de la mise à jour !");
}
}
void UpdateSuccess()
{
Console.WriteLine("Quel est l'identifiant de l'utilisateur lié au succès à mettre à jour ?");
var id = int.Parse(Console.ReadLine());
var res = (successController.GetSuccessByUserId(id));
if (res.GetType() == typeof(OkObjectResult))
{
var lesson = (res as OkObjectResult).Value as SuccessDTO;
if (lesson == null)
{
Console.WriteLine("Erreur, un problème est survenu");
return;
}
else
{
Console.WriteLine("Succès trouvé !\n");
Console.WriteLine("Veuillez saisir l'identifiant de l'utilisateur lié au succès :");
var userId = Console.ReadLine();
Console.WriteLine("Veuillez saisir l'identifiant de l'enquête lié au succès :");
var inquiryId = Console.ReadLine();
Console.WriteLine("Veuillez saisir si l'enquête est terminée (0/1) :");
var isFinished = Console.ReadLine();
var retour = successController.UpdateSuccess(id, new SuccessDTO(int.Parse(userId), int.Parse(inquiryId), bool.Parse(isFinished)));
if (retour.GetType() == typeof(OkObjectResult))
{
Console.WriteLine("Mise à jour effectué avec succès !");
}
else
{
Console.WriteLine("Une erreur est survenue lors de la mise à jour.");
}
}
}
else
{
Console.WriteLine("Une erreur est survenue lors de la mise à jour !");
}
}
void DeleteUser()
{
Console.WriteLine("Quel est l'identifiant de lutilisateur à supprimer ?");
var id = int.Parse(Console.ReadLine());
var res = controller.DeleteUser(id);
var res = userController.DeleteUser(id);
if (res.GetType() == typeof(OkObjectResult))
{
Console.WriteLine("La suppression a été effectuée avec succès !");
}
else
{
Console.WriteLine("Erreur lors de la suppression !");
}
}
void DeleteInquiry()
{
Console.WriteLine("Quel est l'identifiant de l'enquête à supprimer ?");
var id = int.Parse(Console.ReadLine());
var res = inquiryController.DeleteInquiry(id);
if (res.GetType() == typeof(OkObjectResult))
{
Console.WriteLine("La suppression a été effectuée avec succès !");
}
else
{
Console.WriteLine("Erreur lors de la suppression !");
}
}
void DeleteParagraph()
{
Console.WriteLine("Quel est l'identifiant du paragraphe à supprimer ?");
var id = int.Parse(Console.ReadLine());
var res = paragraphController.DeleteParagraph(id);
if (res.GetType() == typeof(OkObjectResult))
{
Console.WriteLine("La suppression a été effectuée avec succès !");
@ -121,13 +576,45 @@ using (var context = new UserDbContext(options))
{
Console.WriteLine("Erreur lors de la suppression !");
}
}
void DeleteLesson()
{
Console.WriteLine("Quel est l'identifiant de la leçon à supprimer ?");
var id = int.Parse(Console.ReadLine());
var res = lessonController.DeleteLesson(id);
if (res.GetType() == typeof(OkObjectResult))
{
Console.WriteLine("La suppression a été effectuée avec succès !");
}
else
{
Console.WriteLine("Erreur lors de la suppression !");
}
}
void Menu()
void DeleteSuccess()
{
Console.WriteLine("Quel est l'identifiant de l'utilisateur lié au succès à supprimer ?");
var id = int.Parse(Console.ReadLine());
var res = successController.DeleteSuccess(id);
if (res.GetType() == typeof(OkObjectResult))
{
Console.WriteLine("La suppression a été effectuée avec succès !");
}
else
{
Console.WriteLine("Erreur lors de la suppression !");
}
}
void MenuUsers()
{
Console.WriteLine("|------------------------------------------------|");
Console.WriteLine("| Menu |");
Console.WriteLine("| MenuUsers |");
Console.WriteLine("|------------------------------------------------|");
Console.WriteLine("| t - Effectuer des tests automatiques |");
Console.WriteLine("| 1 - Afficher les utilisateurs |");
@ -140,33 +627,122 @@ using (var context = new UserDbContext(options))
Console.WriteLine("|------------------------------------------------|");
}
Menu();
void MenuInquiries()
{
Console.WriteLine("|------------------------------------------------|");
Console.WriteLine("| MenuInquiries |");
Console.WriteLine("|------------------------------------------------|");
Console.WriteLine("| 1 - Afficher les enquêtes |");
Console.WriteLine("| 2 - Rechercher une enquête avec son titre |");
Console.WriteLine("| 3 - Rechercher une enquête avec son ID |");
Console.WriteLine("| 4 - Ajouter une enquête |");
Console.WriteLine("| 5 - Mettre à jour une enquête |");
Console.WriteLine("| 6 - Supprimer une enquête |");
Console.WriteLine("| q - Quitter |");
Console.WriteLine("|------------------------------------------------|");
}
void MenuParagraphs()
{
Console.WriteLine("|------------------------------------------------|");
Console.WriteLine("| MenuParagraphs |");
Console.WriteLine("|------------------------------------------------|");
Console.WriteLine("| 1 - Afficher les paragraphes |");
Console.WriteLine("| 2 - Rechercher un paragraphe avec son titre |");
Console.WriteLine("| 3 - Rechercher un paragraphe avec son ID |");
Console.WriteLine("| 4 - Ajouter un paragraphe |");
Console.WriteLine("| 5 - Mettre à jour un paragraphe |");
Console.WriteLine("| 6 - Supprimer un paragraphe |");
Console.WriteLine("| q - Quitter |");
Console.WriteLine("|------------------------------------------------|");
}
void MenuLessons()
{
Console.WriteLine("|------------------------------------------------|");
Console.WriteLine("| MenuLessons |");
Console.WriteLine("|------------------------------------------------|");
Console.WriteLine("| 1 - Afficher les leçons |");
Console.WriteLine("| 2 - Rechercher une leçon avec son titre |");
Console.WriteLine("| 3 - Rechercher une leçon avec son ID |");
Console.WriteLine("| 4 - Ajouter une leçon |");
Console.WriteLine("| 5 - Mettre à jour une leçon |");
Console.WriteLine("| 6 - Supprimer une leçon |");
Console.WriteLine("| q - Quitter |");
Console.WriteLine("|------------------------------------------------|");
}
void MenuSuccesses()
{
Console.WriteLine("|------------------------------------------------|");
Console.WriteLine("| MenuSuccesses |");
Console.WriteLine("|------------------------------------------------|");
Console.WriteLine("| 1 - Afficher les succès |");
Console.WriteLine("| 2 - Rechercher un succès avec son userId |");
Console.WriteLine("| 3 - Rechercher un succès avec son inquiryId |");
Console.WriteLine("| 4 - Ajouter un succès |");
Console.WriteLine("| 5 - Mettre à jour un succès |");
Console.WriteLine("| 6 - Supprimer un succès |");
Console.WriteLine("| q - Quitter |");
Console.WriteLine("|------------------------------------------------|");
}
MenuUsers();
//MenuInquiries();
//MenuParagraphs();
//MenuLessons();
//MenuSuccesses();
Console.WriteLine("\nSaisie :");
var saisie = Console.ReadLine();
while (saisie != "q") {
while (saisie != "q")
{
switch (saisie)
{
case "1":
PrintUsers();
//PrintInquiries();
//PrintParagraphs();
//PrintLessons();
//PrintSuccesses();
break;
case "2":
SearchUserByUsername();
//SearchInquiryByTitle();
//SearchParagraphByTitle();
//SearchLessonByTitle();
//SearchSuccessByUserId();
break;
case "3":
SearchUserById();
//SearchInquiryById();
//SearchParagraphById();
//SearchLessonById();
//SearchSuccessByInquiryId();
break;
case "4":
AddUser();
//AddInquiry();
//AddParagraph();
//AddLesson();
//AddSuccess();
break;
case "5":
UpdateUser();
//UpdateInquiry();
//UpdateParagraph();
//UpdateLesson();
//UpdateSuccess();
break;
case "6":
DeleteUser();
//DeleteInquiry();
//DeleteParagraph();
//DeleteLesson();
//UpdateSuccess();
break;
case "t":
AutoTests();
AutoTestsUsers();
break;
default:
break;
@ -174,25 +750,30 @@ using (var context = new UserDbContext(options))
Console.WriteLine("\nAppuyez sur n'importe quelle touche pour continuer...");
Console.ReadKey();
Console.Clear();
Menu();
MenuUsers();
//MenuInquiries();
//MenuParagraphs();
//MenuLessons();
//MenuSuccesses();
Console.WriteLine("\nSaisie :");
saisie = Console.ReadLine();
}
void AutoTests()
void AutoTestsUsers()
{
// Affichage des utilisateurs
Console.WriteLine("\n##########################################################\n");
Console.WriteLine("Affichages des utilisateurs stubbés dans le contexte :\n");
var res = controller.GetUsers(1, 10) as OkObjectResult;
var res = userController.GetUsers(1, 10, UserOrderCriteria.None);
if (res == null)
{
Console.WriteLine("\nErreur lors de l'acquisition de la liste des utilisateurs");
}
else
{
var users = res.Value as IEnumerable<UserDTO>;
if(users == null) {
var users = res as IEnumerable<UserDTO>;
if (users == null)
{
Console.WriteLine("\nErreur, les ustilisateurs n'ont pas été trouvés !");
}
else
@ -204,14 +785,14 @@ using (var context = new UserDbContext(options))
// Recherche d'utilisateur par ID
Console.WriteLine("\n##########################################################\n");
Console.WriteLine("Affichage de l'utilisateur ayant pour identifiant 1 :\n");
var res1 = controller.GetUserById(1) as OkObjectResult;
var res1 = userController.GetUserById(1);
if (res1 == null)
{
Console.WriteLine("\nErreur lors de l'acquisition de l'utilisateur !");
}
else
{
var user = res1.Value as UserDTO;
var user = res1;
if (user == null)
{
Console.WriteLine("\nErreur, l'utilisateur n'existe pas !");
@ -225,14 +806,14 @@ using (var context = new UserDbContext(options))
// Recherche d'utilisateur par pseudonyme
Console.WriteLine("\n##########################################################\n");
Console.WriteLine("Affichage de l'utilisateur ayant pour username johnny :\n");
var res2 = controller.GetUserByUsername("johnny") as OkObjectResult;
var res2 = userController.GetUserByUsername("johnny");
if (res2 == null)
{
Console.WriteLine("\nErreur lors de l'acquisition de l'utilisateur !");
}
else
{
var user1 = res2.Value as UserDTO;
var user1 = res2;
if (user1 == null)
{
Console.WriteLine("\nErreur, l'utilisateur n'existe pas !");
@ -248,7 +829,7 @@ using (var context = new UserDbContext(options))
Console.WriteLine("Création de l'utilisateur :\n");
var user2 = new UserDTO("JohnDoe", "motdepasse", "johndoe@gmail.com", false);
Console.WriteLine(user2);
var res3 = controller.CreateUser(user2) as CreatedResult;
var res3 = userController.CreateUser(user2);
if (res3 == null)
{
Console.WriteLine("\nErreur lors de la création de l'utilisateur !");
@ -265,8 +846,7 @@ using (var context = new UserDbContext(options))
// Mise à jour d'un utilisateur
Console.WriteLine("\n##########################################################\n");
Console.WriteLine("Mise à jour de l'adresse email de l'utilisateur :\n");
user2 = ((controller.GetUserByUsername("JohnDoe") as OkObjectResult).Value as UserDTO);
if (user2 == null)
if (userController.GetUserByUsername("JohnDoe") == null)
{
Console.WriteLine("\nErreur lors de la récupération de l'utilisateur !");
}
@ -275,7 +855,7 @@ using (var context = new UserDbContext(options))
Console.WriteLine(user2);
Console.WriteLine("\nNouvelle adresse : John.DOE@etu.uca.fr");
var user3 = new UserDTO(user2.Id, user2.Username, user2.Password, "John.DOE@etu.uca.fr", user2.IsAdmin);
var res4 = controller.UpdateUser(user2.Id, user3) as OkObjectResult;
var res4 = userController.UpdateUser(1, user3);
if (res4 == null)
{
Console.WriteLine("\nErreur lors de la mise à jour de l'utilisateur !");
@ -293,15 +873,14 @@ using (var context = new UserDbContext(options))
// Suppression d'un utilisateur
Console.WriteLine("\n##########################################################\n");
Console.WriteLine("Suppression de l'utilisateur JohnDoe:\n");
user2 = ((controller.GetUserByUsername("JohnDoe") as OkObjectResult).Value as UserDTO);
if (user2 == null)
if (userController.GetUserByUsername("JohnDoe") == null)
{
Console.WriteLine("\nErreur lors de la récupération de l'utilisateur !");
}
else
{
Console.WriteLine(user2);
var res5 = controller.DeleteUser(user2.Id) as OkObjectResult;
var res5 = userController.DeleteUser(user2.Id);
if (res5 == null)
{
Console.WriteLine("\nErreur lors de la suppression de l'utilisateur !");

@ -4,7 +4,6 @@ using Entities;
using Microsoft.AspNetCore.Cryptography.KeyDerivation;
using Microsoft.Data.Sqlite;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using StubbedContextLib;
var connection = new SqliteConnection("DataSource=:memory:");
@ -13,23 +12,23 @@ var options = new DbContextOptionsBuilder<UserDbContext>()
.UseSqlite(connection)
.Options;
using ILoggerFactory factory = new LoggerFactory();
// Partie sur les utilisateurs
using (var db = new StubbedContext(options))
{
await db.Database.EnsureCreatedAsync();
// Test sur les users
// Test sur les utilisateurs
var users = db.Users;
// Affichage de tous les users
// Affichage de tous les utilisateurs
Console.WriteLine("Affichage des noms des utilisateurs");
foreach (var user in users)
{
Console.WriteLine(user.Username);
}
// Affichage des users filtrés
// Affichage des utilisateurs filtrés
Console.WriteLine("\nAffichage des utilisateurs contenant e");
var filteredUsers = users.Where(u => u.Username.Contains("e"));
foreach (var user in filteredUsers)
@ -37,7 +36,7 @@ using (var db = new StubbedContext(options))
Console.WriteLine(user.Username);
}
// Affichage des users triés
// Affichage des utilisateurs triés
Console.WriteLine("\nAffichage des utilisateurs triés selon leur nom");
var orderedUsers = users.OrderBy(u => u.Username);
foreach (var user in orderedUsers)
@ -62,11 +61,13 @@ using (var db = new StubbedContext(options))
using (var db = new StubbedContext(options))
{
await db.Database.EnsureCreatedAsync();
var users = db.Users;
// Affichage du nouvel utilisateur
Console.WriteLine("\nAffichage du nouvel utilisateur");
var u = await users.FirstOrDefaultAsync(u => u.Username == "le nouveau du groupe");
foreach (var pptt in typeof(UserEntity).GetProperties().Where((p => p.CanWrite && p.Name != nameof(UserEntity.Id))))
foreach (var pptt in typeof(UserEntity).GetProperties().Where(p => p.CanWrite && p.Name != nameof(UserEntity.Id)))
{
Console.WriteLine(pptt.GetValue(u));
}
@ -82,6 +83,8 @@ using (var db = new StubbedContext(options))
using (var db = new StubbedContext(options))
{
await db.Database.EnsureCreatedAsync();
var users = db.Users;
// Affichage des utilisateurs après suppression
Console.WriteLine("\nAffichage des utilisateurs après suppression");
@ -102,6 +105,8 @@ using (var db = new StubbedContext(options))
using (var db = new StubbedContext(options))
{
await db.Database.EnsureCreatedAsync();
var users = db.Users;
// Affichage des utilisateurs après modification
var userToModify = await users.FirstOrDefaultAsync(u => u.Username == "clement modifié");
@ -118,3 +123,131 @@ using (var db = new StubbedContext(options))
}
}
}
// Partie sur les enquetes
using (var db = new StubbedContext(options))
{
await db.Database.EnsureCreatedAsync();
// Test sur les enquetes
var inquiries = db.Inquiries;
// Affichage de toutes les enquetes
Console.WriteLine("\nAffichage des noms des enquetes");
foreach (var inquiry in inquiries)
{
Console.WriteLine(inquiry.Title);
}
// Affichage des enquetes filtrées
Console.WriteLine("\nAffichage des enquetes contenant o");
var filteredInquiries = inquiries.Where(i => i.Title.Contains("o"));
foreach (var inquiry in filteredInquiries)
{
Console.WriteLine(inquiry.Title);
}
// Affichage des enquetes triées
Console.WriteLine("\nAffichage des enquetes triées selon leur nom");
var orderedInquiries = inquiries.OrderBy(i => i.Title);
foreach (var inquiry in orderedInquiries)
{
Console.WriteLine(inquiry.Title);
}
var solutions = db.Solutions;
// Affichage de la solution de l'enquete sur les orang outan
Console.WriteLine("\nAffichage de la solution de l'enquete sur les orang outan");
var sol = await solutions.FirstOrDefaultAsync(s => s.Owner.Title == "L'enquête sur les orang outan");
Console.WriteLine(sol.MurdererFirstName);
var inquirySolution = await inquiries.FirstOrDefaultAsync(i => i.Title == "L'enquête sur les orang outan");
var i = inquirySolution.Solution;
foreach (var pptt in typeof(SolutionEntity).GetProperties()
.Where(p => p.CanWrite && p.Name != nameof(SolutionEntity.Owner)))
{
Console.WriteLine(pptt.GetValue(i));
}
// Ajout d'une enquete
Console.WriteLine("\nAjout de la nouvelle enquete");
var newInquiry = new InquiryEntity(
"La nouvelle enquete",
"La description de la nouvelle enquete",
true,
null,
null);
if (!inquiries.Any(inquiry => inquiry.Title == newInquiry.Title))
{
inquiries.Add(newInquiry);
await db.SaveChangesAsync();
}
}
using (var db = new StubbedContext(options))
{
await db.Database.EnsureCreatedAsync();
var inquiries = db.Inquiries;
// Affichage de la nouvelle enquete
Console.WriteLine("\nAffichage de la nouvelle enquete");
var i = await inquiries.FirstOrDefaultAsync(i => i.Title == "La nouvelle enquete");
foreach (var pptt in typeof(InquiryEntity).GetProperties()
.Where(p => p.CanWrite && p.Name != nameof(InquiryEntity.Id)))
{
Console.WriteLine(pptt.GetValue(i));
}
if (i != null)
{
// Suppression de la nouvelle enquete
Console.WriteLine("\nSuppression de la nouvelle enquete");
db.Inquiries.Remove(i);
await db.SaveChangesAsync();
}
}
using (var db = new StubbedContext(options))
{
await db.Database.EnsureCreatedAsync();
var inquiries = db.Inquiries;
// Affichage des utilisateurs après suppression
Console.WriteLine("\nAffichage des utilisateurs après suppression");
foreach (var inquiry in inquiries)
{
Console.WriteLine(inquiry.Title);
}
// Modification d'une enquete
Console.WriteLine("\nModification de l'enquete L'enquête de la carotte");
var inquiryToModify = await inquiries.FirstOrDefaultAsync(i => i.Title == "L'enquête de la carotte");
if (inquiryToModify != null)
{
inquiryToModify.Title = "L'enquête de la carotte modifiée";
await db.SaveChangesAsync();
}
}
using (var db = new StubbedContext(options))
{
await db.Database.EnsureCreatedAsync();
var inquiries = db.Inquiries;
// Affichage des enquetes après modification
var inquiryToModify = await inquiries.FirstOrDefaultAsync(i => i.Title == "L'enquête de la carotte modifiée");
if (inquiryToModify != null)
{
Console.WriteLine("\nAffichage de l'enquete après modification");
Console.WriteLine(inquiryToModify.Title);
// Rollback
inquiryToModify = await inquiries.FirstOrDefaultAsync(i => i.Title == "L'enquête de la carotte modifiée");
if (inquiryToModify != null)
{
inquiryToModify.Title = "L'enquête de la carotte";
await db.SaveChangesAsync();
}
}
}

@ -20,16 +20,6 @@ public class TestLessonEntity
Assert.Null(lesson.LastEdit);
}
[Fact]
public void TestConstructorWithOnlyId()
{
LessonEntity lesson = new LessonEntity(_id);
Assert.Equal(_id, lesson.Id);
Assert.Null(lesson.Title);
Assert.Null(lesson.LastPublisher);
Assert.Null(lesson.LastEdit);
}
[Fact]
public void TestConstructorWithoutId()
{

@ -23,18 +23,6 @@ public class TestParagraphEntity
Assert.Null(paragraph.Comment);
}
[Fact]
public void TestConstructorWithOnlyId()
{
ParagraphEntity paragraph = new ParagraphEntity(_id);
Assert.Equal(_id, paragraph.Id);
Assert.Null(paragraph.Title);
Assert.Null(paragraph.Info);
Assert.Null(paragraph.Content);
Assert.Null(paragraph.Query);
Assert.Null(paragraph.Comment);
}
[Fact]
public void TestConstructorWithoutId()
{
@ -50,12 +38,13 @@ public class TestParagraphEntity
[Fact]
public void TestConstructorWithAllAttributes()
{
ParagraphEntity paragraph = new ParagraphEntity(_id,_title,_content,_info,_query,_comment);
ParagraphEntity paragraph = new ParagraphEntity(_id,_title,_content,_info,_query,_comment,10);
Assert.Equal(_id, paragraph.Id);
Assert.Equal(_title,paragraph.Title);
Assert.Equal(_info,paragraph.Info);
Assert.Equal(_content,paragraph.Content);
Assert.Equal(_query,paragraph.Query);
Assert.Equal(_comment,paragraph.Comment);
Assert.Equal(10, paragraph.LessonId);
}
}

@ -1,5 +1,4 @@
using Entities;
using ModelToEntities.Business;
namespace TestEF;

Loading…
Cancel
Save