ERP_Distribution/Distribution/Features/Route/RouteService.cs

using Distribution.Infra.UoW;

namespace Distribution.Features.Route;

public class RouteService(IRouteRepository repo, Region.IRegionRepository regionRepo, IUnitOfWork uow)
{
    public async Task<List<RouteResponse>> GetAllAsync() =>
        (await repo.GetAllAsync())
            .Where(r => r.IsActive)
            .Select(r => new RouteResponse(r.Id, r.FK_RegionId, r.RouteName, r.StartPoint, r.EndPoint, r.Length, r.IsActive, r.CreatedAt))
            .ToList();

    public async Task<RouteResponse?> GetByIdAsync(Guid id)
    {
        var route = await repo.GetByIdAsync(id);
        if (route is null || !route.IsActive) return null;
        return new RouteResponse(route.Id, route.FK_RegionId, route.RouteName, route.StartPoint, route.EndPoint, route.Length, route.IsActive, route.CreatedAt);
    }

    public async Task<RouteResponse> CreateAsync(CreateRouteRequest request, CancellationToken ct = default)
    {
        var route = new Models.Route
        {
            FK_RegionId = request.RegionId,
            RouteName = request.RouteName,
            StartPoint = request.StartPoint,
            EndPoint = request.EndPoint,
            Length = request.Length
        };
        await uow.BeginAsync(ct);
        try
        {
            await repo.AddAsync(route);
            await uow.CommitAsync(ct);
        }
        catch
        {
            await uow.RollbackAsync(ct);
            throw;
        }
        return new RouteResponse(route.Id, route.FK_RegionId, route.RouteName, route.StartPoint, route.EndPoint, route.Length, route.IsActive, route.CreatedAt);
    }

    public async Task<RouteResponse?> UpdateAsync(Guid id, UpdateRouteRequest request, CancellationToken ct = default)
    {
        var route = await repo.GetByIdAsync(id);
        if (route is null || !route.IsActive) return null;
        route.FK_RegionId = request.RegionId;
        route.RouteName = request.RouteName;
        route.StartPoint = request.StartPoint;
        route.EndPoint = request.EndPoint;
        route.Length = request.Length;
        await uow.BeginAsync(ct);
        try
        {
            repo.Update(route);
            await uow.CommitAsync(ct);
        }
        catch
        {
            await uow.RollbackAsync(ct);
            throw;
        }
        return new RouteResponse(route.Id, route.FK_RegionId, route.RouteName, route.StartPoint, route.EndPoint, route.Length, route.IsActive, route.CreatedAt);
    }

    public async Task<RouteResponse?> AssignToRegionAsync(Guid id, AssignRouteToRegionRequest request, CancellationToken ct = default)
    {
        var route = await repo.GetByIdAsync(id);
        if (route is null || !route.IsActive) return null;

        var region = await regionRepo.GetByIdAsync(request.RegionId);
        if (region is null || !region.IsActive) return null;

        route.FK_RegionId = request.RegionId;
        await uow.BeginAsync(ct);
        try
        {
            repo.Update(route);
            await uow.CommitAsync(ct);
        }
        catch
        {
            await uow.RollbackAsync(ct);
            throw;
        }
        return new RouteResponse(route.Id, route.FK_RegionId, route.RouteName, route.StartPoint, route.EndPoint, route.Length, route.IsActive, route.CreatedAt);
    }

    public async Task<bool> DeleteAsync(Guid id, CancellationToken ct = default)
    {
        var route = await repo.GetByIdAsync(id);
        if (route is null || !route.IsActive) return false;
        await uow.BeginAsync(ct);
        try
        {
            repo.Remove(route);
            await uow.CommitAsync(ct);
        }
        catch
        {
            await uow.RollbackAsync(ct);
            throw;
        }
        return true;
    }
}