shoc-backend/SeaHaven.DataServices/Implementation/UpliftDataService.cs

using System.Collections.Concurrent;
using Data.SeaHavenIndustries;
using Microsoft.EntityFrameworkCore;
using SeaHaven.DataServices.Interfaces;

namespace SeaHaven.DataServices.Implementation
{
    public class UpliftDataService : IUpliftDataService
    {
        private static readonly ConcurrentDictionary<int, SemaphoreSlim> WorkOrderGates = new();
        private readonly ApplicationDbContext _context;

        public UpliftDataService(ApplicationDbContext context)
        {
            _context = context;
        }

        public async Task<(int TotalCount, IReadOnlyList<UpliftListItemData> Items)> GetPagedAsync(
            string? status, int? tier, int page, int pageSize, CancellationToken cancellationToken)
        {
            var query = from u in _context.DispatchUpliftRequests
                        join d in _context.Dispatches on u.DispatchId equals d.Id
                        join v in _context.Vendors on d.VendorId equals v.Id into vendors
                        from v in vendors.DefaultIfEmpty()
                        join ev in _context.VendorCompletionDocuments on u.EvidenceDocumentId equals ev.Id into evidences
                        from ev in evidences.DefaultIfEmpty()
                        where (u.IsDeleted == null || u.IsDeleted == false)
                        select new { u, d, v, ev };

            if (!string.IsNullOrWhiteSpace(status))
                query = query.Where(x => x.u.Status == status);
            if (tier.HasValue)
                query = query.Where(x => x.u.RequiredTier == tier.Value);

            var total = await query.CountAsync(cancellationToken);

            var items = await query
                .OrderByDescending(x => x.u.CreatedDate)
                .Skip((Math.Max(page, 1) - 1) * pageSize)
                .Take(pageSize)
                .Select(x => new UpliftListItemData
                {
                    Id = x.u.Id,
                    DispatchId = x.d.Id,
                    DispatchNumber = x.d.DispatchNumber,
                    PONumber = x.d.PONumber,
                    WorkOrderId = x.d.WorkOrderId,
                    VendorCompanyName = x.v != null ? x.v.CompanyName : x.u.RequestedByVendorName,
                    CurrentNTE = x.u.CurrentNTE,
                    RequestedNTE = x.u.RequestedNTE,
                    VendorReason = x.u.VendorReason,
                    RequiredTier = x.u.RequiredTier,
                    Status = x.u.Status,
                    CreatedDate = x.u.CreatedDate,
                    DecidedAt = x.u.DecidedAt,
                    DecisionNote = x.u.DecisionNote,
                    EvidenceDocumentId = x.u.EvidenceDocumentId,
                    EvidenceFileName = x.ev != null ? x.ev.OriginalFileName : null,
                    EvidenceContentType = x.ev != null ? x.ev.ContentType : null,
                    EvidenceSizeBytes = x.ev != null ? x.ev.SizeBytes : null,
                    ExpiresAt = x.u.ExpiresAt,
                    NotificationStatus = x.u.NotificationStatus,
                    NotificationError = x.u.NotificationError
                })
                .ToListAsync(cancellationToken);

            return (total, items);
        }

        public async Task<IReadOnlyList<UpliftForDispatchData>> GetForDispatchAsync(int dispatchId, CancellationToken cancellationToken)
        {
            return await (from u in _context.DispatchUpliftRequests
                          where u.DispatchId == dispatchId && (u.IsDeleted == null || u.IsDeleted == false)
                          join dec in _context.Users on u.DecidedByUserId equals dec.Id into decs
                          from dec in decs.DefaultIfEmpty()
                          join ev in _context.VendorCompletionDocuments on u.EvidenceDocumentId equals ev.Id into evidences
                          from ev in evidences.DefaultIfEmpty()
                          orderby u.CreatedDate descending
                          select new UpliftForDispatchData
                          {
                              Id = u.Id,
                              DispatchId = u.DispatchId,
                              CurrentNTE = u.CurrentNTE,
                              RequestedNTE = u.RequestedNTE,
                              VendorReason = u.VendorReason,
                              Status = u.Status,
                              RequiredTier = u.RequiredTier,
                              RequestedByVendorName = u.RequestedByVendorName,
                              CreatedDate = u.CreatedDate,
                              DecidedAt = u.DecidedAt,
                              DecisionNote = u.DecisionNote,
                              DecidedByFirstName = dec != null ? dec.FirstName : null,
                              DecidedByLastName = dec != null ? dec.LastName : null,
                              EvidenceDocumentId = u.EvidenceDocumentId,
                              ExpiresAt = u.ExpiresAt,
                              NotificationStatus = u.NotificationStatus,
                              NotificationError = u.NotificationError,
                              EvidenceFileName = ev != null ? ev.OriginalFileName : null,
                              EvidenceContentType = ev != null ? ev.ContentType : null,
                              EvidenceSizeBytes = ev != null ? ev.SizeBytes : null,
                              EvidenceScanPassed = ev != null && ev.ScanStatus == "Passed"
                          }).ToListAsync(cancellationToken);
        }

        public async Task<IReadOnlyList<UpliftForWorkOrderData>> GetForWorkOrderAsync(int workOrderId, CancellationToken cancellationToken)
        {
            return await (from u in _context.DispatchUpliftRequests
                          where (u.IsDeleted == null || u.IsDeleted == false)
                          && u.Dispatch != null
                          && (u.Dispatch.IsDeleted == null || u.Dispatch.IsDeleted == false)
                          && (
                              u.Dispatch.WorkOrderId == workOrderId
                              || u.Dispatch.DispatchWorkOrders!.Any(link => link.WorkOrderId == workOrderId))
                          join dec in _context.Users on u.DecidedByUserId equals dec.Id into decs
                          from dec in decs.DefaultIfEmpty()
                          join ev in _context.VendorCompletionDocuments on u.EvidenceDocumentId equals ev.Id into evidences
                          from ev in evidences.DefaultIfEmpty()
                          orderby u.CreatedDate descending
                          select new UpliftForWorkOrderData
                          {
                              Id = u.Id,
                              DispatchId = u.DispatchId,
                              CurrentNTE = u.CurrentNTE,
                              RequestedNTE = u.RequestedNTE,
                              VendorReason = u.VendorReason,
                              Status = u.Status,
                              RequiredTier = u.RequiredTier,
                              RequestedByVendorName = u.RequestedByVendorName,
                              CreatedDate = u.CreatedDate,
                              DecidedAt = u.DecidedAt,
                              DecisionNote = u.DecisionNote,
                              DecidedByFirstName = dec != null ? dec.FirstName : null,
                              DecidedByLastName = dec != null ? dec.LastName : null,
                              EvidenceDocumentId = u.EvidenceDocumentId,
                              ExpiresAt = u.ExpiresAt,
                              NotificationStatus = u.NotificationStatus,
                              NotificationError = u.NotificationError,
                              EvidenceFileName = ev != null ? ev.OriginalFileName : null,
                              EvidenceContentType = ev != null ? ev.ContentType : null,
                              EvidenceSizeBytes = ev != null ? ev.SizeBytes : null,
                              EvidenceScanPassed = ev != null && ev.ScanStatus == "Passed",
                              CreatedByUserId = u.createdby
                          }).ToListAsync(cancellationToken);
        }

        public async Task<DispatchUpliftRequest?> GetByIdAndWorkOrderAsync(
            int requestId,
            int workOrderId,
            CancellationToken cancellationToken)
        {
            return await _context.DispatchUpliftRequests
                .FirstOrDefaultAsync(u =>
                    u.Id == requestId
                    && (u.IsDeleted == null || u.IsDeleted == false)
                    && u.Dispatch != null
                    && (u.Dispatch.IsDeleted == null || u.Dispatch.IsDeleted == false)
                    && (
                        u.Dispatch.WorkOrderId == workOrderId
                        || u.Dispatch.DispatchWorkOrders!.Any(link => link.WorkOrderId == workOrderId)),
                    cancellationToken);
        }

        public async Task<IReadOnlyList<PortalUpliftData>> GetForVendorDispatchAsync(int dispatchId, CancellationToken cancellationToken)
        {
            return await (from u in _context.DispatchUpliftRequests
                          where u.DispatchId == dispatchId && (u.IsDeleted == null || u.IsDeleted == false)
                          join dec in _context.Users on u.DecidedByUserId equals dec.Id into decs
                          from dec in decs.DefaultIfEmpty()
                          join ev in _context.VendorCompletionDocuments on u.EvidenceDocumentId equals ev.Id into evidences
                          from ev in evidences.DefaultIfEmpty()
                          orderby u.CreatedDate descending
                          select new PortalUpliftData
                          {
                              Id = u.Id,
                              CurrentNTE = u.CurrentNTE,
                              RequestedNTE = u.RequestedNTE,
                              VendorReason = u.VendorReason,
                              Status = u.Status,
                              RequiredTier = u.RequiredTier,
                              RequestedByVendorName = u.RequestedByVendorName,
                              CreatedDate = u.CreatedDate,
                              DecidedAt = u.DecidedAt,
                              DecisionNote = u.DecisionNote,
                              DecidedByFirstName = dec != null ? dec.FirstName : null,
                              DecidedByLastName = dec != null ? dec.LastName : null,
                              EvidenceDocumentId = u.EvidenceDocumentId,
                              ExpiresAt = u.ExpiresAt,
                              NotificationStatus = u.NotificationStatus,
                              NotificationError = u.NotificationError,
                              EvidenceFileName = ev != null ? ev.OriginalFileName : null,
                              EvidenceContentType = ev != null ? ev.ContentType : null,
                              EvidenceSizeBytes = ev != null ? ev.SizeBytes : null,
                              EvidenceScanPassed = ev != null && ev.ScanStatus == "Passed"
                          }).ToListAsync(cancellationToken);
        }

        public async Task<DispatchUpliftRequest?> GetByIdAsync(int id, CancellationToken cancellationToken)
        {
            return await _context.DispatchUpliftRequests
                .FirstOrDefaultAsync(u => u.Id == id, cancellationToken);
        }

        public async Task<DispatchUpliftRequest?> GetByIdAndDispatchAsync(int requestId, int dispatchId, CancellationToken cancellationToken)
        {
            return await _context.DispatchUpliftRequests
                .FirstOrDefaultAsync(u => u.Id == requestId && u.DispatchId == dispatchId, cancellationToken);
        }

        // SH-101: internal evidence download. The inner join on EvidenceDocumentId together
        // with the DispatchId equality filter enforces server-side request/document linkage:
        // a row is returned only when the document is the one linked to this exact request
        // and dispatch. Soft-deleted requests/documents never resolve.
        public async Task<UpliftEvidenceDownloadData?> GetEvidenceForInternalDownloadAsync(int upliftRequestId, CancellationToken cancellationToken)
        {
            return await (from u in _context.DispatchUpliftRequests
                          where u.Id == upliftRequestId && (u.IsDeleted == null || u.IsDeleted == false)
                          join ev in _context.VendorCompletionDocuments on u.EvidenceDocumentId equals ev.Id
                          where ev.DispatchId == u.DispatchId && (ev.IsDeleted == null || ev.IsDeleted == false)
                          select new UpliftEvidenceDownloadData
                          {
                              Id = u.Id,
                              DispatchId = u.DispatchId,
                              VendorId = ev.VendorId,
                              RequiredTier = u.RequiredTier,
                              EvidenceDocumentId = u.EvidenceDocumentId,
                              StoredFileName = ev.StoredFileName,
                              OriginalFileName = ev.OriginalFileName,
                              ContentType = ev.ContentType,
                              Purpose = ev.Purpose,
                              ScanStatus = ev.ScanStatus
                          }).FirstOrDefaultAsync(cancellationToken);
        }

        public async Task<bool> HasPendingAsync(int dispatchId, CancellationToken cancellationToken)
        {
            return await _context.DispatchUpliftRequests
                .AnyAsync(u => u.DispatchId == dispatchId
                    && u.Status == "Pending"
                    && (u.IsDeleted == null || u.IsDeleted == false), cancellationToken);
        }

        public Task<bool> HasPendingForWorkOrderAsync(int workOrderId, CancellationToken cancellationToken)
        {
            return ForWorkOrder(workOrderId)
                .AnyAsync(u => u.Status == "Pending" || u.Status == "ChangesRequested", cancellationToken);
        }

        public Task<decimal> SumAutoApprovedAmountForWorkOrderAsync(int workOrderId, CancellationToken cancellationToken)
        {
            return ForWorkOrder(workOrderId)
                .Where(u => u.Status == "NoApprovalRequired")
                .SumAsync(u => u.RequestedNTE, cancellationToken);
        }

        public Task<List<DispatchUpliftRequest>> GetPendingForWorkOrderAsync(
            int workOrderId,
            CancellationToken cancellationToken)
        {
            return ForWorkOrder(workOrderId)
                .Include(u => u.Dispatch)
                .Where(u => u.Status == "Pending" || u.Status == "ChangesRequested")
                .ToListAsync(cancellationToken);
        }

        public async Task<bool> HasActiveAsync(int dispatchId, CancellationToken cancellationToken)
        {
            return await _context.DispatchUpliftRequests
                .AnyAsync(u => u.DispatchId == dispatchId
                    && (u.Status == "Pending" || u.Status == "ChangesRequested")
                    && (u.IsDeleted == null || u.IsDeleted == false), cancellationToken);
        }

        public async Task<DispatchUpliftRequest?> GetActiveRequestAsync(int dispatchId, CancellationToken cancellationToken)
        {
            return await _context.DispatchUpliftRequests
                .FirstOrDefaultAsync(u => u.DispatchId == dispatchId
                    && (u.Status == "Pending" || u.Status == "ChangesRequested")
                    && (u.IsDeleted == null || u.IsDeleted == false), cancellationToken);
        }

        public async Task<DispatchUpliftRequest?> GetByRequestKeyAsync(int dispatchId, string requestKey, CancellationToken cancellationToken)
        {
            return await _context.DispatchUpliftRequests
                .FirstOrDefaultAsync(u => u.DispatchId == dispatchId
                    && u.RequestKey == requestKey
                    && (u.IsDeleted == null || u.IsDeleted == false), cancellationToken);
        }

        public async Task<List<DispatchUpliftRequest>> GetDueForExpiryAsync(DateTime utcNow, int count, CancellationToken cancellationToken)
        {
            return await _context.DispatchUpliftRequests
                .Where(u => (u.Status == "Pending" || u.Status == "ChangesRequested")
                    && u.ExpiresAt != null && u.ExpiresAt <= utcNow
                    && (u.IsDeleted == null || u.IsDeleted == false))
                .OrderBy(u => u.ExpiresAt)
                .Take(count)
                .ToListAsync(cancellationToken);
        }

        public async Task<List<DispatchUpliftRequest>> GetDueForInitialNotificationAsync(int count, CancellationToken cancellationToken)
        {
            return await _context.DispatchUpliftRequests
                .Where(u => (u.Status == "Pending" || u.Status == "ChangesRequested")
                    && u.InitialNotificationSentAt == null
                    && (u.IsDeleted == null || u.IsDeleted == false))
                .OrderBy(u => u.CreatedDate)
                .Take(count)
                .ToListAsync(cancellationToken);
        }

        public async Task<List<DispatchUpliftRequest>> GetDueForEscalationAsync(int count, CancellationToken cancellationToken)
        {
            return await _context.DispatchUpliftRequests
                .Where(u => (u.Status == "Pending" || u.Status == "ChangesRequested")
                    && u.InitialNotificationSentAt != null
                    && u.EscalatedAt == null
                    && (u.IsDeleted == null || u.IsDeleted == false))
                .OrderBy(u => u.InitialNotificationSentAt)
                .Take(count)
                .ToListAsync(cancellationToken);
        }

        private IQueryable<DispatchUpliftRequest> ForWorkOrder(int workOrderId)
        {
            return _context.DispatchUpliftRequests.Where(u =>
                (u.IsDeleted == null || u.IsDeleted == false)
                && u.Dispatch != null
                && (u.Dispatch.IsDeleted == null || u.Dispatch.IsDeleted == false)
                && (
                    u.Dispatch.WorkOrderId == workOrderId
                    || u.Dispatch.DispatchWorkOrders!.Any(link => link.WorkOrderId == workOrderId)));
        }

        public async Task StageAsync(DispatchUpliftRequest request, CancellationToken cancellationToken)
        {
            await _context.DispatchUpliftRequests.AddAsync(request, cancellationToken);
        }

        public async Task SaveChangesAsync(CancellationToken cancellationToken)
        {
            await _context.SaveChangesAsync(cancellationToken);
        }

        public async Task<T> ExecuteWorkOrderMutationAsync<T>(
            int workOrderId,
            Func<CancellationToken, Task<T>> work,
            CancellationToken cancellationToken)
        {
            var gate = WorkOrderGates.GetOrAdd(workOrderId, _ => new SemaphoreSlim(1, 1));
            await gate.WaitAsync(cancellationToken);
            await using var transaction = _context.Database.IsRelational()
                ? await _context.Database.BeginTransactionAsync(cancellationToken)
                : null;
            try
            {
                await LockWorkOrderRowAsync(workOrderId, cancellationToken);
                var result = await work(cancellationToken);
                if (transaction is not null)
                    await transaction.CommitAsync(cancellationToken);
                return result;
            }
            catch
            {
                if (transaction is not null)
                    await transaction.RollbackAsync(cancellationToken);
                throw;
            }
            finally
            {
                gate.Release();
            }
        }

        private async Task LockWorkOrderRowAsync(int workOrderId, CancellationToken cancellationToken)
        {
            if (_context.Database.ProviderName?.Contains("SqlServer", StringComparison.OrdinalIgnoreCase) != true)
                return;

            await _context.workOrders
                .FromSqlRaw(
                    "SELECT * FROM [workOrders] WITH (UPDLOCK, ROWLOCK, HOLDLOCK) WHERE [Id] = {0}",
                    workOrderId)
                .Select(workOrder => workOrder.Id)
                .FirstOrDefaultAsync(cancellationToken);
        }
    }
}