shoc-backend/SeaHaven.Services/Implementation/WorkOrderDetailService.cs

using SeaHaven.DataServices.Interfaces;
using SeaHaven.Services.DTOs;
using SeaHaven.Services.Helpers;
using SeaHaven.Services.Interfaces;

namespace SeaHaven.Services.Implementation
{
    public class WorkOrderDetailService : IWorkOrderDetailService
    {
        private readonly IWorkOrderBoardService _boardService;
        private readonly IWorkOrderDetailDataService _detailData;
        private readonly ICompletionDocTemplateDataService _templateData;

        public WorkOrderDetailService(
            IWorkOrderBoardService boardService,
            IWorkOrderDetailDataService detailData,
            ICompletionDocTemplateDataService templateData)
        {
            _boardService = boardService;
            _detailData = detailData;
            _templateData = templateData;
        }

        public async Task<WorkOrderDetailDto?> GetDetailAsync(int workOrderId)
        {
            if (!await _detailData.ExistsAsync(workOrderId))
                return null;

            var boardRow = await _boardService.GetBoardRowAsync(workOrderId);
            if (boardRow == null)
                return null;

            var extended = await _detailData.GetExtendedFieldsAsync(workOrderId);
            var comments = await _detailData.GetCommentsAsync(workOrderId);
            var audit = await _detailData.GetAuditLogsAsync(workOrderId);
            var attachments = await _detailData.GetAttachmentsAsync(workOrderId);
            var signoffs = await _detailData.GetDispatchSignoffsAsync(workOrderId);
            var workOrder = await _detailData.GetWorkOrderForMediaAsync(workOrderId);

            var template = await _templateData.ResolveForWorkOrderAsync(
                extended?.Trade ?? boardRow.Pm,
                boardRow.WorkOrderType);

            return new WorkOrderDetailDto
            {
                Info = MapInfo(boardRow, extended),
                Completion = MapCompletion(extended, boardRow.DocStatus, template, signoffs),
                Comments = WorkOrderCommentProjection.ToDtos(comments),
                Audit = WorkOrderAuditProjection.ToDtos(audit),
                Media = workOrder == null
                    ? new List<WorkOrderMediaFileDto>()
                    : WorkOrderMediaProjection.ProjectAll(workOrder, attachments)
            };
        }

        public async Task<IReadOnlyList<WorkOrderAuditEntryDto>> GetAuditAsync(int workOrderId, int limit = 50)
        {
            if (!await _detailData.ExistsAsync(workOrderId))
                return Array.Empty<WorkOrderAuditEntryDto>();

            var logs = await _detailData.GetAuditLogsAsync(workOrderId, limit);
            return WorkOrderAuditProjection.ToDtos(logs);
        }

        private static WorkOrderDetailInfoDto MapInfo(
            WorkOrderBoardRowDto row,
            WorkOrderDetailExtendedFields? extended)
        {
            return new WorkOrderDetailInfoDto
            {
                Id = row.Id,
                WoNumber = row.WoNumber,
                RescheduleCount = row.RescheduleCount,
                CarriedOver = row.CarriedOver,
                WorkOrderType = row.WorkOrderType,
                IsPastDue = row.IsPastDue,
                SiteCode = row.SiteCode,
                LocationName = row.LocationName,
                PocName = row.PocName,
                PocPhone = row.PocPhone,
                PocNotes = row.PocNotes,
                LifecycleStatus = row.LifecycleStatus,
                LifecycleStatusLabel = row.LifecycleStatusLabel,
                LegacyStatus = row.LegacyStatus,
                DispatcherId = row.DispatcherId,
                DispatcherName = row.DispatcherName,
                Initials = row.Initials,
                Color = row.Color,
                DueDate = row.DueDate,
                ScheduledDate = row.ScheduledDate,
                TargetWeek = row.TargetWeek,
                ScheduleWeekOnly = row.ScheduleWeekOnly,
                DayGroup = row.DayGroup,
                VendorId = row.VendorId,
                VendorName = row.VendorName,
                TechName = row.TechName,
                TechPhone = row.TechPhone,
                ApptDate = row.ApptDate,
                ApptTime = row.ApptTime,
                Pm = row.Pm,
                DocStatus = row.DocStatus,
                PrimaryDispatchId = row.PrimaryDispatchId,
                RowVersion = row.RowVersion,
                DispatchRowVersion = row.DispatchRowVersion,
                Description = extended?.Description,
                Trade = extended?.Trade,
                Problem = extended?.Problem,
                SubTrade = extended?.SubTrade,
                OriginalWeek = extended?.OriginalWeek,
                OriginalDate = extended?.OriginalDate,
                CompletedDate = extended?.CompletedDate
            };
        }

        private static WorkOrderCompletionDto MapCompletion(
            WorkOrderDetailExtendedFields? extended,
            Data.SeaHavenIndustries.Enums.DocStatus? docStatus,
            CompletionDocTemplateRow? template,
            IReadOnlyList<DispatchSignoffRow> signoffs)
        {
            return new WorkOrderCompletionDto
            {
                DocStatus = docStatus,
                Template = template == null ? null : MapTemplate(template),
                SignOffName = extended?.SignOffName,
                SignOffAttachment = extended?.SignOffAttachment,
                SignOffSignature = extended?.SignOffSignature,
                DispatchSignoffs = signoffs.Select(s => new DispatchSignoffDto
                {
                    DispatchId = s.DispatchId,
                    SignoffType = s.SignoffType,
                    Name = s.Name,
                    SignedAt = s.SignedAt?.ToUniversalTime().ToString("o")
                }).ToList()
            };
        }

        internal static CompletionDocTemplateDto MapTemplate(CompletionDocTemplateRow template)
            => new()
            {
                Id = template.Id,
                Name = template.Name,
                ServiceKey = template.ServiceKey,
                WorkOrderType = template.WorkOrderType,
                TemplateUrl = template.TemplateUrl,
                IsActive = template.IsActive
            };
    }
}