add route visit management

2026-08-31 13:00:13 +05:30
parent 75b5035354
commit 5c4e1b590a
12 changed files with 3357 additions and 10 deletions
@@ -1,20 +1,50 @@
+using Distribution.Infra.Authorization;
 using Distribution.Infra.UoW;

 namespace Distribution.Features.Route;

-public class RouteService(IRouteRepository repo, Region.IRegionRepository regionRepo, IUnitOfWork uow)
+public class RouteService(IRouteRepository repo, Region.IRegionRepository regionRepo, IUnitOfWork uow, ICurrentUserService currentUser, IScopeAccessService scopeAccess)
 {
+    private const int RouteManagerRoleLevel = 20;
+    private const double DeviationThresholdMeters = 500;
+
+    private async Task<bool> CanManageRouteAsync(Guid routeId)
+    {
+        if (currentUser.RoleLevel < RouteManagerRoleLevel || currentUser.UserId is null) return false;
+        return await scopeAccess.HasRouteScopeAsync(currentUser.UserId.Value, routeId);
+    }
+
+    private static double DistanceMeters(decimal lat1, decimal lon1, decimal lat2, decimal lon2)
+    {
+        const double earthRadiusMeters = 6371000;
+        var dLat = ToRadians((double)(lat2 - lat1));
+        var dLon = ToRadians((double)(lon2 - lon1));
+        var a = Math.Sin(dLat / 2) * Math.Sin(dLat / 2) +
+                Math.Cos(ToRadians((double)lat1)) * Math.Cos(ToRadians((double)lat2)) *
+                Math.Sin(dLon / 2) * Math.Sin(dLon / 2);
+        var c = 2 * Math.Atan2(Math.Sqrt(a), Math.Sqrt(1 - a));
+        return earthRadiusMeters * c;
+    }
+
+    private static double ToRadians(double degrees) => degrees * Math.PI / 180;
+
+    private static RouteResponse ToResponse(Models.Route route) =>
+        new(route.Id, route.FK_RegionId, route.RouteName, route.StartPoint, route.EndPoint, route.Length, route.FK_OwnerUserId, route.IsActive, route.CreatedAt);
+
+    private static RouteVisitResponse ToVisitResponse(Models.RouteVisitLog log) =>
+        new(log.Id, log.FK_RouteId, log.FK_StoreId, log.FK_UserId, log.CheckInAt, log.IsDeviationFlagged, log.CheckOutAt);
+
    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))
+            .Select(r => new RouteResponse(r.Id, r.FK_RegionId, r.RouteName, r.StartPoint, r.EndPoint, r.Length, r.FK_OwnerUserId, 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);
+        return new RouteResponse(route.Id, route.FK_RegionId, route.RouteName, route.StartPoint, route.EndPoint, route.Length, route.FK_OwnerUserId, route.IsActive, route.CreatedAt);
    }

    public async Task<RouteResponse> CreateAsync(CreateRouteRequest request, CancellationToken ct = default)
@@ -38,7 +68,7 @@ public class RouteService(IRouteRepository repo, Region.IRegionRepository region
            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);
+        return ToResponse(route);
    }

    public async Task<RouteResponse?> UpdateAsync(Guid id, UpdateRouteRequest request, CancellationToken ct = default)
@@ -61,7 +91,7 @@ public class RouteService(IRouteRepository repo, Region.IRegionRepository region
            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);
+        return ToResponse(route);
    }

    public async Task<RouteResponse?> AssignToRegionAsync(Guid id, AssignRouteToRegionRequest request, CancellationToken ct = default)
@@ -84,7 +114,7 @@ public class RouteService(IRouteRepository repo, Region.IRegionRepository region
            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);
+        return ToResponse(route);
    }

    public async Task<bool> DeleteAsync(Guid id, CancellationToken ct = default)
@@ -104,4 +134,119 @@ public class RouteService(IRouteRepository repo, Region.IRegionRepository region
        }
        return true;
    }
+
+    public async Task<RouteResponse?> AssignStoresToRouteAsync(Guid id, AssignStoresToRouteRequest request, CancellationToken ct = default)
+    {
+        var route = await repo.GetByIdAsync(id);
+        if (route is null || !route.IsActive) return null;
+        if (!await CanManageRouteAsync(id)) return null;
+
+        var stores = await repo.GetStoresByIdsAsync(request.StoreIds);
+        if (stores.Count != request.StoreIds.Distinct().Count()) return null;
+
+        await uow.BeginAsync(ct);
+        try
+        {
+            foreach (var store in stores)
+            {
+                store.FK_RouteId = id;
+                repo.UpdateStore(store);
+            }
+            await uow.CommitAsync(ct);
+        }
+        catch
+        {
+            await uow.RollbackAsync(ct);
+            throw;
+        }
+        return ToResponse(route);
+    }
+
+    public async Task<RouteResponse?> AssignOwnerAsync(Guid id, AssignRouteOwnerRequest request, CancellationToken ct = default)
+    {
+        var route = await repo.GetByIdAsync(id);
+        if (route is null || !route.IsActive) return null;
+        if (!await CanManageRouteAsync(id)) return null;
+
+        var salesRep = await repo.GetActiveUserAsync(request.SalesRepId);
+        if (salesRep is null) return null;
+
+        route.FK_OwnerUserId = request.SalesRepId;
+        await uow.BeginAsync(ct);
+        try
+        {
+            repo.Update(route);
+            await uow.CommitAsync(ct);
+        }
+        catch
+        {
+            await uow.RollbackAsync(ct);
+            throw;
+        }
+        return ToResponse(route);
+    }
+
+    public async Task<RouteVisitResponse?> RecordCheckInAsync(Guid id, RecordCheckInRequest request, CancellationToken ct = default)
+    {
+        if (currentUser.UserId is null) return null;
+
+        var route = await repo.GetByIdAsync(id);
+        if (route is null || !route.IsActive) return null;
+        if (!await scopeAccess.HasRouteScopeAsync(currentUser.UserId.Value, id)) return null;
+
+        var store = await repo.GetStoreByIdAsync(request.StoreId);
+        if (store is null || !store.IsActive || store.FK_RouteId != id) return null;
+
+        var distance = DistanceMeters(request.Latitude, request.Longitude, store.Latitude, store.Longitude);
+
+        var log = new Models.RouteVisitLog
+        {
+            FK_RouteId = id,
+            FK_StoreId = request.StoreId,
+            FK_UserId = currentUser.UserId.Value,
+            CheckInAt = request.Timestamp ?? DateTime.Now,
+            CheckInLatitude = request.Latitude,
+            CheckInLongitude = request.Longitude,
+            IsDeviationFlagged = distance > DeviationThresholdMeters
+        };
+        await uow.BeginAsync(ct);
+        try
+        {
+            await repo.AddVisitLogAsync(log);
+            await uow.CommitAsync(ct);
+        }
+        catch
+        {
+            await uow.RollbackAsync(ct);
+            throw;
+        }
+        return ToVisitResponse(log);
+    }
+
+    public async Task<RouteVisitResponse?> RecordCheckOutAsync(Guid id, RecordCheckOutRequest request, CancellationToken ct = default)
+    {
+        if (currentUser.UserId is null) return null;
+
+        var route = await repo.GetByIdAsync(id);
+        if (route is null || !route.IsActive) return null;
+        if (!await scopeAccess.HasRouteScopeAsync(currentUser.UserId.Value, id)) return null;
+
+        var log = await repo.GetOpenVisitAsync(id, request.StoreId);
+        if (log is null) return null;
+
+        log.CheckOutAt = request.Timestamp ?? DateTime.Now;
+        await uow.BeginAsync(ct);
+        try
+        {
+            repo.UpdateVisitLog(log);
+            await uow.CommitAsync(ct);
+        }
+        catch
+        {
+            await uow.RollbackAsync(ct);
+            throw;
+        }
+        return ToVisitResponse(log);
+    }
 }
+