API_SQLuedo/API_SQLuedo/DbDataManager/Service/LessonDataService.cs

using DbContextLib;
using Entities;
using Microsoft.EntityFrameworkCore;
using Model.OrderCriteria;
using Shared;
using Shared.ModelToEntities;

namespace DbDataManager.Service;
public class LessonDataService : ILessonService<LessonEntity>
{
    private UserDbContext DbContext { get; set; }

    public LessonDataService(UserDbContext context)
    {
        DbContext = context;
        context.Database.EnsureCreated();
    }

    public IEnumerable<LessonEntity> 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;
    }

    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 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 LessonEntity UpdateLesson(int id, LessonEntity lesson)
    {
        var updatingLesson = DbContext.Lessons.FirstOrDefault(l => l.Id == id);
        if (updatingLesson == null)
        {
            throw new ArgumentException("Impossible de trouver la leçon", nameof(id));
        }

        foreach (var pptt in typeof(LessonEntity).GetProperties()
                     .Where(p => p.CanWrite && p.Name != nameof(LessonEntity.Id)))
        {
            pptt.SetValue(updatingLesson, pptt.GetValue(lesson));
        }

        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;
    }

    public async Task<LessonEntity?> AddItem(LessonEntity? item)
    {
        using (var context = DbContext = new UserDbContext()) 
        {
            var lesson = await context.CreateItemAsync<LessonEntity>(item);
            return item;
        }
    }

    public async Task<bool> DeleteItem(int id)
    {
        using (var context = DbContext = new UserDbContext())
        {
            var succes = await context.DeleteItemAsync<LessonEntity>(id);
            return succes;
        }
    }

    public async Task<LessonEntity> UpdateItem<TDto>(int? id, TDto? newItem) where TDto : class
    {
        using (var context = DbContext = new UserDbContext())
        {
            var lesson = await context.UpdateItemAsync<LessonEntity, TDto>(id, newItem);
            return lesson;
        }
    }

    public async Task<IEnumerable<LessonEntity>> GetItems(int page, int count, object? orderCriteria = null, string? filter = null, object? valueFilter = null)
    {
        using (var context = DbContext = new UserDbContext())
        {
            var lessons = await context.GetItemsWithFilter<LessonEntity>(page, count, orderCriteria, filter, valueFilter);
            return lessons;
        }
    }
}