OptifitWebService/Server/Services/ExperienceServices.cs

using Infrastructure;
using Server.Dto.Request;
using Server.Dto.Response;
using Server.IServices;
using Shared.Criteria;
using Server.Mappers;

namespace Server.Services;

public class ExperienceServices(AlumniDbContext context) : IExperiencesService
{
    public Task<ResponseExperienceDto?> GetExperienceById(string id)
    {
        var result = context.Experiences.FirstOrDefault(exp => exp.Id == id);
        return Task.FromResult(result?.ToDto());
    }

    public Task<(long Count, IEnumerable<ResponseExperienceDto> Experiences)> GetExperiences(string? title, int page, int size,
        ExperienceOrderCriteria orderCriteria = ExperienceOrderCriteria.EndDate, bool ascending = true)
    {
        var query = context.Experiences
            .Skip((page-1) * size)
            .Take(size);
        if (title != null)
        {
            query = context.Experiences
                .Where(e => e.Title.Contains(title))
                .Skip((page-1) * size)
                .Take(size);
        }
        switch (orderCriteria)
        {
            case ExperienceOrderCriteria.StartDate:
                query = ascending ? query.OrderBy(e => e.StartDate) : query.OrderByDescending(e => e.StartDate);
                break;
            case ExperienceOrderCriteria.EndDate:
                query = ascending ? query.OrderBy(e => e.EndDate) : query.OrderByDescending(e => e.EndDate);
                break;
            case ExperienceOrderCriteria.Title:
                query = ascending ? query.OrderBy(e => e.Title) : query.OrderByDescending(e => e.Title);
                break;
        }
        var count = query.LongCount();
        return Task.FromResult((count, query.AsEnumerable().Select(e => e.ToDto())));
    }

    public Task<ResponseExperienceDto?> CreateExperience(RequestExperienceDto experience)
    {
        var result = context.Experiences.AddAsync(experience.ToEntity());
        var alica =   context.Alumni.FirstOrDefault(a => a.Id == experience.AlumniId);
        alica?.Experiences.Add(result.Result.Entity);
        context.SaveChangesAsync();
        return Task.FromResult(result.Result.Entity.ToDto());
    }

    public Task<ResponseExperienceDto?> UpdateExperience(string id, RequestExperienceDto experience)
    {
        var result = context.Experiences.FirstOrDefault(e => e.Id == id);
        if (result == null)
        {
            return Task.FromResult<ResponseExperienceDto?>(null);
        }
        result.Title = experience.Title;
        result.StartDate = experience.StartingDate;
        result.EndDate = experience.EndingDate;
        result.CompanyName = experience.CompanyName;
        result.IsCurrent = experience.CurrentJob;

        context.SaveChangesAsync();
        return Task.FromResult(result.ToDto());
    }

    public Task<bool> DeleteExperience(string id)
    {
        var result = context.Experiences.FirstOrDefault(e => e.Id == id);
        if (result == null) 
            return Task.FromResult(false);
        context.Experiences.Remove(result);
        context.SaveChangesAsync();
        return Task.FromResult(true);
    }
}