Refactor: extract shared helpers, fix field drift, add assembly services

- IJobItemAssemblyService / IQuotePricingAssemblyService: centralize job item
  and quote pricing construction that was duplicated across create, rework copy,
  and quote-to-job conversion paths
- BlobFileHelper: single ValidateUpload/GetContentType/SanitizeFileName used by
  6 blob services (JobPhoto, QuotePhoto, ProfilePhoto, CompanyLogo, Equipment,
  Catalog) and BillsController + ExpensesController, removing 8 private copies
- PagedResult<T>.From(): static factory eliminates 6-line boilerplate in 11
  controllers (Appointments, Customers, Equipment, Inventory, Invoices, Jobs,
  Maintenance, CompanyUsers, PlatformUsers, Quotes, Vendors)
- AccountingDropdownHelper: single LoadAsync() call replaces duplicate
  vendor/account/job queries in BillsController and ExpensesController
- JobTemplateItem: add IsSalesItem + Sku fields with migration; propagate
  through JobTemplatesController snapshot copy and GetTemplatesJson projection,
  and JobsController template-application path
- Test assertions updated for standardized BlobFileHelper error messages

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

src/PowderCoating.Application/DTOs/Common/PagedResult.cs

@@ -3,6 +3,22 @@ namespace PowderCoating.Application.DTOs.Common;
 public class PagedResult<T>
 {
     public IEnumerable<T> Items { get; set; } = new List<T>();
+
+    /// <summary>
+    /// Creates a PagedResult populated from a GridRequest, avoiding repetitive property
+    /// assignments across every Index action. SortColumn, SortDirection, and SearchTerm
+    /// are copied from the grid so the model carries full state for view binding.
+    /// </summary>
+    public static PagedResult<T> From(GridRequest grid, IEnumerable<T> items, int totalCount) => new()
+    {
+        Items = items,
+        PageNumber = grid.PageNumber,
+        PageSize = grid.PageSize,
+        TotalCount = totalCount,
+        SortColumn = grid.SortColumn,
+        SortDirection = grid.SortDirection,
+        SearchTerm = grid.SearchTerm
+    };
     public int PageNumber { get; set; }
     public int PageSize { get; set; }
     public int TotalCount { get; set; }

src/PowderCoating.Application/Interfaces/IJobItemAssemblyService.cs

@@ -0,0 +1,19 @@
+using PowderCoating.Application.DTOs.Quote;
+using PowderCoating.Core.Entities;
+
+namespace PowderCoating.Application.Interfaces;
+
+public interface IJobItemAssemblyService
+{
+    JobItem CreateJobItem(CreateQuoteItemDto source, int jobId, int companyId, QuoteItemPricingResult pricing, DateTime createdAtUtc);
+    IReadOnlyList<JobItemCoat> CreateJobItemCoats(CreateQuoteItemDto source, int jobItemId, int companyId, DateTime createdAtUtc);
+    IReadOnlyList<JobItemPrepService> CreateJobItemPrepServices(CreateQuoteItemDto source, int jobItemId, int companyId, DateTime createdAtUtc);
+
+    JobItem CreateJobItem(QuoteItem source, int jobId, int companyId, DateTime createdAtUtc);
+    IReadOnlyList<JobItemCoat> CreateJobItemCoats(QuoteItem source, int jobItemId, int companyId, DateTime createdAtUtc);
+    IReadOnlyList<JobItemPrepService> CreateJobItemPrepServices(QuoteItem source, int jobItemId, int companyId, DateTime createdAtUtc);
+
+    JobItem CreateJobItem(JobItem source, int jobId, int companyId, DateTime createdAtUtc);
+    IReadOnlyList<JobItemCoat> CreateJobItemCoats(JobItem source, int jobItemId, int companyId, DateTime createdAtUtc);
+    IReadOnlyList<JobItemPrepService> CreateJobItemPrepServices(JobItem source, int jobItemId, int companyId, DateTime createdAtUtc);
+}

src/PowderCoating.Application/Interfaces/IQuotePricingAssemblyService.cs

@@ -0,0 +1,16 @@
+using PowderCoating.Application.DTOs.Quote;
+using PowderCoating.Core.Entities;
+
+namespace PowderCoating.Application.Interfaces;
+
+public interface IQuotePricingAssemblyService
+{
+    void ApplyPricingSnapshot(Quote quote, QuotePricingResult pricingResult);
+
+    Task<IReadOnlyList<QuoteItem>> CreateQuoteItemsAsync(
+        IEnumerable<CreateQuoteItemDto> itemDtos,
+        int quoteId,
+        int companyId,
+        decimal? ovenRateOverride,
+        DateTime createdAtUtc);
+}

src/PowderCoating.Application/Services/BlobFileHelper.cs

@@ -0,0 +1,59 @@
+using Microsoft.AspNetCore.Http;
+
+namespace PowderCoating.Application.Services;
+
+/// <summary>
+/// Shared file validation and content-type resolution used across all blob storage services.
+/// </summary>
+public static class BlobFileHelper
+{
+    /// <summary>
+    /// Validates an uploaded file against an extension allowlist and a maximum size.
+    /// Returns the normalized (lowercase) extension on success so callers do not re-derive it.
+    /// </summary>
+    public static (bool IsValid, string Extension, string Error) ValidateUpload(
+        IFormFile? file,
+        string[] allowedExtensions,
+        long maxBytes)
+    {
+        if (file == null || file.Length == 0)
+            return (false, string.Empty, "No file provided.");
+
+        if (file.Length > maxBytes)
+            return (false, string.Empty, $"File exceeds the {maxBytes / 1024 / 1024} MB limit.");
+
+        var extension = Path.GetExtension(file.FileName).ToLowerInvariant();
+        if (string.IsNullOrEmpty(extension) || !allowedExtensions.Contains(extension))
+            return (false, string.Empty, $"File type not allowed. Allowed: {string.Join(", ", allowedExtensions)}.");
+
+        return (true, extension, string.Empty);
+    }
+
+    /// <summary>
+    /// Maps a file extension to its MIME content type, covering common image formats and
+    /// document types. Falls back to <c>application/octet-stream</c>.
+    /// </summary>
+    public static string GetContentType(string extension) => extension switch
+    {
+        ".jpg" or ".jpeg" => "image/jpeg",
+        ".png"            => "image/png",
+        ".gif"            => "image/gif",
+        ".webp"           => "image/webp",
+        ".svg"            => "image/svg+xml",
+        ".pdf"            => "application/pdf",
+        ".doc"            => "application/msword",
+        ".docx"           => "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+        ".txt"            => "text/plain",
+        _                 => "application/octet-stream"
+    };
+
+    /// <summary>
+    /// Strips OS-invalid filename characters from a base filename (no extension), replacing
+    /// them with underscores to produce a safe blob path segment.
+    /// </summary>
+    public static string SanitizeFileName(string fileName)
+    {
+        var sanitized = string.Join("_", fileName.Split(Path.GetInvalidFileNameChars()));
+        return string.IsNullOrWhiteSpace(sanitized) ? "file" : sanitized;
+    }
+}

src/PowderCoating.Application/Services/CatalogImageService.cs

@@ -47,15 +47,9 @@ public class CatalogImageService : ICatalogImageService
         string? existingImagePath,
         string? existingThumbnailPath)
     {
-        if (file == null || file.Length == 0)
-            return (false, string.Empty, string.Empty, "No file provided.");
-
-        if (file.Length > MaxFileSizeBytes)
-            return (false, string.Empty, string.Empty, "File exceeds the 10 MB limit.");
-
-        var ext = Path.GetExtension(file.FileName).ToLowerInvariant();
-        if (!AllowedExtensions.Contains(ext))
-            return (false, string.Empty, string.Empty, $"File type '{ext}' is not allowed. Accepted types: jpg, jpeg, png, gif, webp.");
+        var (isValid, ext, validationError) = BlobFileHelper.ValidateUpload(file, AllowedExtensions, MaxFileSizeBytes);
+        if (!isValid)
+            return (false, string.Empty, string.Empty, validationError);
 
         var container = _settings.Containers.CatalogImages;
         var blobId = Guid.NewGuid().ToString("N");

src/PowderCoating.Application/Services/CompanyLogoService.cs

@@ -67,21 +67,15 @@ public class CompanyLogoService : ICompanyLogoService
     /// </returns>
     public async Task<(bool Success, string FilePath, string ErrorMessage)> SaveCompanyLogoAsync(IFormFile file, int companyId)
     {
-        if (file == null || file.Length == 0)
-            return (false, string.Empty, "No file provided");
-
-        if (file.Length > MaxFileSize)
-            return (false, string.Empty, $"File size exceeds maximum allowed size of {MaxFileSize / 1024 / 1024} MB");
-
-        var extension = Path.GetExtension(file.FileName).ToLowerInvariant();
-        if (!AllowedExtensions.Contains(extension))
-            return (false, string.Empty, $"File type not allowed. Allowed types: {string.Join(", ", AllowedExtensions)}");
+        var (isValid, extension, error) = BlobFileHelper.ValidateUpload(file, AllowedExtensions, MaxFileSize);
+        if (!isValid)
+            return (false, string.Empty, error);
 
         // Delete old logo (any extension) before saving new one
         await DeleteOldLogosAsync(companyId, extension);
 
         var blobName = GetCompanyLogoPath(companyId, extension);
-        var contentType = GetContentType(extension);
+        var contentType = BlobFileHelper.GetContentType(extension);
 
         using var stream = file.OpenReadStream();
         var result = await _blobService.UploadAsync(_settings.Containers.CompanyLogos, blobName, stream, contentType);
@@ -158,20 +152,4 @@ public class CompanyLogoService : ICompanyLogoService
         }
     }
 
-    /// <summary>
-    /// Maps a lowercase file extension to its canonical MIME content type.
-    /// The correct content type is required so that browsers render the image
-    /// inline rather than triggering a download.
-    /// </summary>
-    /// <param name="extension">Lowercase file extension including the leading dot.</param>
-    /// <returns>MIME type string, or <c>application/octet-stream</c> as a safe fallback.</returns>
-    private static string GetContentType(string extension) => extension switch
-    {
-        ".jpg" or ".jpeg" => "image/jpeg",
-        ".png" => "image/png",
-        ".gif" => "image/gif",
-        ".webp" => "image/webp",
-        ".svg" => "image/svg+xml",
-        _ => "application/octet-stream"
-    };
 }

src/PowderCoating.Application/Services/EquipmentManualService.cs

@@ -56,25 +56,16 @@ public class EquipmentManualService : IEquipmentManualService
     /// </returns>
     public async Task<(bool Success, string FilePath, string ErrorMessage)> SaveEquipmentManualAsync(IFormFile file, int companyId, int equipmentId)
     {
-        if (file == null || file.Length == 0)
-            return (false, string.Empty, "No file provided");
-
-        if (file.Length > MaxFileSize)
-            return (false, string.Empty, $"File size exceeds maximum allowed size of {MaxFileSize / 1024 / 1024} MB");
-
-        var extension = Path.GetExtension(file.FileName).ToLowerInvariant();
-        if (!AllowedExtensions.Contains(extension))
-            return (false, string.Empty, $"File type not allowed. Allowed types: {string.Join(", ", AllowedExtensions)}");
+        var (isValid, extension, error) = BlobFileHelper.ValidateUpload(file, AllowedExtensions, MaxFileSize);
+        if (!isValid)
+            return (false, string.Empty, error);
 
         // Sanitize filename — replace OS-invalid characters with underscores to
         // prevent path traversal and blob naming errors in Azure.
-        var fileName = Path.GetFileNameWithoutExtension(file.FileName);
-        fileName = string.Join("_", fileName.Split(Path.GetInvalidFileNameChars()));
-        if (string.IsNullOrWhiteSpace(fileName))
-            fileName = "manual";
+        var fileName = BlobFileHelper.SanitizeFileName(Path.GetFileNameWithoutExtension(file.FileName));
 
         var blobName = $"{companyId}/equipment-manuals/{equipmentId}/{fileName}{extension}";
-        var contentType = GetContentType(extension);
+        var contentType = BlobFileHelper.GetContentType(extension);
 
         using var stream = file.OpenReadStream();
         var result = await _blobService.UploadAsync(_settings.Containers.Manuals, blobName, stream, contentType);
@@ -130,19 +121,4 @@ public class EquipmentManualService : IEquipmentManualService
         return await _blobService.ExistsAsync(_settings.Containers.Manuals, filePath);
     }
 
-    /// <summary>
-    /// Maps a lowercase file extension to its canonical MIME content type.
-    /// Correct MIME types are required so browsers open PDFs inline and
-    /// Word documents prompt a compatible application rather than a raw download.
-    /// </summary>
-    /// <param name="extension">Lowercase file extension including the leading dot.</param>
-    /// <returns>MIME type string, or <c>application/octet-stream</c> as a safe fallback.</returns>
-    private static string GetContentType(string extension) => extension switch
-    {
-        ".pdf" => "application/pdf",
-        ".doc" => "application/msword",
-        ".docx" => "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-        ".txt" => "text/plain",
-        _ => "application/octet-stream"
-    };
 }

src/PowderCoating.Application/Services/JobItemAssemblyService.cs

@@ -0,0 +1,405 @@
+using PowderCoating.Application.DTOs.Quote;
+using PowderCoating.Application.Interfaces;
+using PowderCoating.Core.Entities;
+
+namespace PowderCoating.Application.Services;
+
+public class JobItemAssemblyService : IJobItemAssemblyService
+{
+    public JobItem CreateJobItem(CreateQuoteItemDto source, int jobId, int companyId, QuoteItemPricingResult pricing, DateTime createdAtUtc)
+    {
+        ArgumentNullException.ThrowIfNull(source);
+        ArgumentNullException.ThrowIfNull(pricing);
+
+        return BuildJobItem(
+            new JobItemSeed
+            {
+                Description = source.Description,
+                Quantity = source.Quantity,
+                SurfaceAreaSqFt = source.SurfaceAreaSqFt,
+                CatalogItemId = source.CatalogItemId,
+                IsGenericItem = source.IsGenericItem,
+                IsLaborItem = source.IsLaborItem,
+                IsSalesItem = source.IsSalesItem,
+                Sku = source.Sku,
+                ManualUnitPrice = source.ManualUnitPrice,
+                PowderCostOverride = source.PowderCostOverride,
+                UnitPrice = pricing.UnitPrice,
+                TotalPrice = pricing.TotalPrice,
+                LaborCost = pricing.TotalPrice * 0.4m,
+                RequiresSandblasting = source.RequiresSandblasting,
+                RequiresMasking = source.RequiresMasking,
+                EstimatedMinutes = source.EstimatedMinutes,
+                Notes = source.Notes,
+                IncludePrepCost = source.IncludePrepCost,
+                Complexity = source.Complexity,
+                AiTags = source.AiTags,
+                AiPredictionId = source.AiPredictionId
+            },
+            jobId,
+            companyId,
+            createdAtUtc);
+    }
+
+    public IReadOnlyList<JobItemCoat> CreateJobItemCoats(CreateQuoteItemDto source, int jobItemId, int companyId, DateTime createdAtUtc)
+    {
+        ArgumentNullException.ThrowIfNull(source);
+
+        return source.Coats?
+            .OrderBy(c => c.Sequence)
+            .Select(c => BuildJobItemCoat(
+                new JobItemCoatSeed
+                {
+                    CoatName = c.CoatName,
+                    Sequence = c.Sequence,
+                    InventoryItemId = c.InventoryItemId,
+                    ColorName = c.ColorName,
+                    VendorId = c.VendorId,
+                    ColorCode = c.ColorCode,
+                    Finish = c.Finish,
+                    CoverageSqFtPerLb = c.CoverageSqFtPerLb,
+                    TransferEfficiency = c.TransferEfficiency,
+                    PowderCostPerLb = c.PowderCostPerLb,
+                    PowderToOrder = CalculatePowderToOrder(c.PowderToOrder, source.SurfaceAreaSqFt, source.Quantity, c.CoverageSqFtPerLb, c.TransferEfficiency),
+                    Notes = c.Notes
+                },
+                jobItemId,
+                companyId,
+                createdAtUtc))
+            .ToList() ?? [];
+    }
+
+    public IReadOnlyList<JobItemPrepService> CreateJobItemPrepServices(CreateQuoteItemDto source, int jobItemId, int companyId, DateTime createdAtUtc)
+    {
+        ArgumentNullException.ThrowIfNull(source);
+        return BuildJobItemPrepServices(
+            source.PrepServices?.Select(p => new JobItemPrepServiceSeed
+            {
+                PrepServiceId = p.PrepServiceId,
+                EstimatedMinutes = p.EstimatedMinutes,
+                BlastSetupId = p.BlastSetupId
+            }),
+            jobItemId,
+            companyId,
+            createdAtUtc);
+    }
+
+    public JobItem CreateJobItem(QuoteItem source, int jobId, int companyId, DateTime createdAtUtc)
+    {
+        ArgumentNullException.ThrowIfNull(source);
+
+        var firstCoat = source.Coats?
+            .OrderBy(c => c.Sequence)
+            .FirstOrDefault();
+
+        return BuildJobItem(
+            new JobItemSeed
+            {
+                Description = source.Description,
+                Quantity = source.Quantity,
+                ColorName = firstCoat?.ColorName,
+                ColorCode = firstCoat?.ColorCode,
+                Finish = firstCoat?.Finish,
+                SurfaceArea = source.SurfaceAreaSqFt,
+                SurfaceAreaSqFt = source.SurfaceAreaSqFt,
+                CatalogItemId = source.CatalogItemId,
+                IsGenericItem = source.IsGenericItem,
+                IsLaborItem = source.IsLaborItem,
+                IsSalesItem = source.IsSalesItem,
+                Sku = source.Sku,
+                ManualUnitPrice = source.ManualUnitPrice,
+                PowderCostOverride = source.PowderCostOverride,
+                UnitPrice = source.UnitPrice,
+                TotalPrice = source.TotalPrice,
+                LaborCost = source.TotalPrice * 0.4m,
+                RequiresSandblasting = source.RequiresSandblasting,
+                RequiresMasking = source.RequiresMasking,
+                EstimatedMinutes = source.EstimatedMinutes,
+                Notes = source.Notes,
+                IncludePrepCost = source.IncludePrepCost,
+                Complexity = source.Complexity,
+                AiTags = source.AiTags,
+                AiPredictionId = source.AiPredictionId
+            },
+            jobId,
+            companyId,
+            createdAtUtc);
+    }
+
+    public IReadOnlyList<JobItemCoat> CreateJobItemCoats(QuoteItem source, int jobItemId, int companyId, DateTime createdAtUtc)
+    {
+        ArgumentNullException.ThrowIfNull(source);
+
+        return source.Coats?
+            .OrderBy(c => c.Sequence)
+            .Select(c =>
+            {
+                var appearance = ResolveCoatAppearance(c.ColorName, c.ColorCode, c.Finish, c.InventoryItem);
+                return BuildJobItemCoat(
+                    new JobItemCoatSeed
+                    {
+                        CoatName = c.CoatName,
+                        Sequence = c.Sequence,
+                        InventoryItemId = c.InventoryItemId,
+                        ColorName = appearance.ColorName,
+                        VendorId = c.VendorId,
+                        ColorCode = appearance.ColorCode,
+                        Finish = appearance.Finish,
+                        CoverageSqFtPerLb = c.CoverageSqFtPerLb,
+                        TransferEfficiency = c.TransferEfficiency,
+                        PowderCostPerLb = c.PowderCostPerLb,
+                        PowderToOrder = CalculatePowderToOrder(c.PowderToOrder, source.SurfaceAreaSqFt, source.Quantity, c.CoverageSqFtPerLb, c.TransferEfficiency),
+                        Notes = c.Notes
+                    },
+                    jobItemId,
+                    companyId,
+                    createdAtUtc);
+            })
+            .ToList() ?? [];
+    }
+
+    public IReadOnlyList<JobItemPrepService> CreateJobItemPrepServices(QuoteItem source, int jobItemId, int companyId, DateTime createdAtUtc)
+    {
+        ArgumentNullException.ThrowIfNull(source);
+        return BuildJobItemPrepServices(
+            source.PrepServices?.Select(p => new JobItemPrepServiceSeed
+            {
+                PrepServiceId = p.PrepServiceId,
+                EstimatedMinutes = p.EstimatedMinutes,
+                BlastSetupId = p.BlastSetupId
+            }),
+            jobItemId,
+            companyId,
+            createdAtUtc);
+    }
+
+    public JobItem CreateJobItem(JobItem source, int jobId, int companyId, DateTime createdAtUtc)
+    {
+        ArgumentNullException.ThrowIfNull(source);
+
+        return BuildJobItem(
+            new JobItemSeed
+            {
+                Description = source.Description,
+                Quantity = source.Quantity,
+                ColorName = source.ColorName,
+                ColorCode = source.ColorCode,
+                Finish = source.Finish,
+                SurfaceArea = source.SurfaceArea,
+                SurfaceAreaSqFt = source.SurfaceAreaSqFt,
+                CatalogItemId = source.CatalogItemId,
+                IsGenericItem = source.IsGenericItem,
+                IsLaborItem = source.IsLaborItem,
+                IsSalesItem = source.IsSalesItem,
+                Sku = source.Sku,
+                ManualUnitPrice = source.ManualUnitPrice,
+                PowderCostOverride = source.PowderCostOverride,
+                UnitPrice = source.UnitPrice,
+                TotalPrice = source.TotalPrice,
+                LaborCost = source.LaborCost,
+                RequiresSandblasting = source.RequiresSandblasting,
+                RequiresMasking = source.RequiresMasking,
+                EstimatedMinutes = source.EstimatedMinutes,
+                Notes = source.Notes,
+                IncludePrepCost = source.IncludePrepCost,
+                Complexity = source.Complexity,
+                AiTags = source.AiTags,
+                AiPredictionId = source.AiPredictionId
+            },
+            jobId,
+            companyId,
+            createdAtUtc);
+    }
+
+    public IReadOnlyList<JobItemCoat> CreateJobItemCoats(JobItem source, int jobItemId, int companyId, DateTime createdAtUtc)
+    {
+        ArgumentNullException.ThrowIfNull(source);
+
+        return source.Coats?
+            .OrderBy(c => c.Sequence)
+            .Select(c => BuildJobItemCoat(
+                new JobItemCoatSeed
+                {
+                    CoatName = c.CoatName,
+                    Sequence = c.Sequence,
+                    InventoryItemId = c.InventoryItemId,
+                    ColorName = c.ColorName,
+                    VendorId = c.VendorId,
+                    ColorCode = c.ColorCode,
+                    Finish = c.Finish,
+                    CoverageSqFtPerLb = c.CoverageSqFtPerLb,
+                    TransferEfficiency = c.TransferEfficiency,
+                    PowderCostPerLb = c.PowderCostPerLb,
+                    PowderToOrder = c.PowderToOrder,
+                    Notes = c.Notes
+                },
+                jobItemId,
+                companyId,
+                createdAtUtc))
+            .ToList() ?? [];
+    }
+
+    public IReadOnlyList<JobItemPrepService> CreateJobItemPrepServices(JobItem source, int jobItemId, int companyId, DateTime createdAtUtc)
+    {
+        ArgumentNullException.ThrowIfNull(source);
+        return BuildJobItemPrepServices(
+            source.PrepServices?.Select(p => new JobItemPrepServiceSeed
+            {
+                PrepServiceId = p.PrepServiceId,
+                EstimatedMinutes = p.EstimatedMinutes,
+                BlastSetupId = p.BlastSetupId
+            }),
+            jobItemId,
+            companyId,
+            createdAtUtc);
+    }
+
+    private static JobItem BuildJobItem(JobItemSeed seed, int jobId, int companyId, DateTime createdAtUtc)
+    {
+        return new JobItem
+        {
+            JobId = jobId,
+            Description = seed.Description,
+            Quantity = seed.Quantity,
+            ColorName = seed.ColorName,
+            ColorCode = seed.ColorCode,
+            Finish = seed.Finish,
+            SurfaceArea = seed.SurfaceArea,
+            SurfaceAreaSqFt = seed.SurfaceAreaSqFt,
+            CatalogItemId = seed.CatalogItemId,
+            IsGenericItem = seed.IsGenericItem,
+            IsLaborItem = seed.IsLaborItem,
+            IsSalesItem = seed.IsSalesItem,
+            Sku = seed.Sku,
+            ManualUnitPrice = seed.ManualUnitPrice,
+            PowderCostOverride = seed.PowderCostOverride,
+            UnitPrice = seed.UnitPrice,
+            TotalPrice = seed.TotalPrice,
+            LaborCost = seed.LaborCost,
+            RequiresSandblasting = seed.RequiresSandblasting,
+            RequiresMasking = seed.RequiresMasking,
+            EstimatedMinutes = seed.EstimatedMinutes,
+            Notes = seed.Notes,
+            IncludePrepCost = seed.IncludePrepCost,
+            Complexity = seed.Complexity,
+            AiTags = seed.AiTags,
+            AiPredictionId = seed.AiPredictionId,
+            CompanyId = companyId,
+            CreatedAt = createdAtUtc
+        };
+    }
+
+    private static JobItemCoat BuildJobItemCoat(JobItemCoatSeed seed, int jobItemId, int companyId, DateTime createdAtUtc)
+    {
+        return new JobItemCoat
+        {
+            JobItemId = jobItemId,
+            CoatName = seed.CoatName,
+            Sequence = seed.Sequence,
+            InventoryItemId = seed.InventoryItemId,
+            ColorName = seed.ColorName,
+            VendorId = seed.VendorId,
+            ColorCode = seed.ColorCode,
+            Finish = seed.Finish,
+            CoverageSqFtPerLb = seed.CoverageSqFtPerLb,
+            TransferEfficiency = seed.TransferEfficiency,
+            PowderCostPerLb = seed.PowderCostPerLb,
+            PowderToOrder = seed.PowderToOrder,
+            Notes = seed.Notes,
+            CompanyId = companyId,
+            CreatedAt = createdAtUtc
+        };
+    }
+
+    private static IReadOnlyList<JobItemPrepService> BuildJobItemPrepServices(IEnumerable<JobItemPrepServiceSeed>? seeds, int jobItemId, int companyId, DateTime createdAtUtc)
+    {
+        return seeds?
+            .Select(seed => new JobItemPrepService
+            {
+                JobItemId = jobItemId,
+                PrepServiceId = seed.PrepServiceId,
+                EstimatedMinutes = seed.EstimatedMinutes,
+                BlastSetupId = seed.BlastSetupId,
+                CompanyId = companyId,
+                CreatedAt = createdAtUtc
+            })
+            .ToList() ?? [];
+    }
+
+    private static decimal? CalculatePowderToOrder(decimal? storedPowderToOrder, decimal surfaceAreaSqFt, decimal quantity, decimal coverageSqFtPerLb, decimal transferEfficiency)
+    {
+        if (storedPowderToOrder.HasValue && storedPowderToOrder.Value > 0)
+            return storedPowderToOrder;
+
+        if (surfaceAreaSqFt <= 0)
+            return null;
+
+        var coverage = coverageSqFtPerLb > 0 ? coverageSqFtPerLb : 30m;
+        var efficiency = transferEfficiency > 0 ? transferEfficiency / 100m : 0.65m;
+        return Math.Round((surfaceAreaSqFt * quantity) / (coverage * efficiency), 2);
+    }
+
+    private static (string? ColorName, string? ColorCode, string? Finish) ResolveCoatAppearance(
+        string? colorName,
+        string? colorCode,
+        string? finish,
+        InventoryItem? inventoryItem)
+    {
+        if (inventoryItem == null)
+            return (colorName, colorCode, finish);
+
+        return (inventoryItem.Name, inventoryItem.ColorCode, inventoryItem.Finish);
+    }
+
+    private sealed class JobItemSeed
+    {
+        public string Description { get; init; } = string.Empty;
+        public decimal Quantity { get; init; }
+        public string? ColorName { get; init; }
+        public string? ColorCode { get; init; }
+        public string? Finish { get; init; }
+        public decimal? SurfaceArea { get; init; }
+        public decimal SurfaceAreaSqFt { get; init; }
+        public int? CatalogItemId { get; init; }
+        public bool IsGenericItem { get; init; }
+        public bool IsLaborItem { get; init; }
+        public bool IsSalesItem { get; init; }
+        public string? Sku { get; init; }
+        public decimal? ManualUnitPrice { get; init; }
+        public decimal? PowderCostOverride { get; init; }
+        public decimal UnitPrice { get; init; }
+        public decimal TotalPrice { get; init; }
+        public decimal LaborCost { get; init; }
+        public bool RequiresSandblasting { get; init; }
+        public bool RequiresMasking { get; init; }
+        public int EstimatedMinutes { get; init; }
+        public string? Notes { get; init; }
+        public bool IncludePrepCost { get; init; }
+        public string? Complexity { get; init; }
+        public string? AiTags { get; init; }
+        public int? AiPredictionId { get; init; }
+    }
+
+    private sealed class JobItemCoatSeed
+    {
+        public string CoatName { get; init; } = string.Empty;
+        public int Sequence { get; init; }
+        public int? InventoryItemId { get; init; }
+        public string? ColorName { get; init; }
+        public int? VendorId { get; init; }
+        public string? ColorCode { get; init; }
+        public string? Finish { get; init; }
+        public decimal CoverageSqFtPerLb { get; init; }
+        public decimal TransferEfficiency { get; init; }
+        public decimal? PowderCostPerLb { get; init; }
+        public decimal? PowderToOrder { get; init; }
+        public string? Notes { get; init; }
+    }
+
+    private sealed class JobItemPrepServiceSeed
+    {
+        public int PrepServiceId { get; init; }
+        public int EstimatedMinutes { get; init; }
+        public int? BlastSetupId { get; init; }
+    }
+}

src/PowderCoating.Application/Services/JobPhotoService.cs

@@ -69,19 +69,13 @@ public class JobPhotoService : IJobPhotoService
         string? caption = null,
         JobPhotoType photoType = JobPhotoType.Progress)
     {
-        if (file == null || file.Length == 0)
-            return (false, string.Empty, "No file was uploaded.");
-
-        if (file.Length > MaxPhotoSize)
-            return (false, string.Empty, "Photo must be smaller than 10 MB.");
-
-        var extension = Path.GetExtension(file.FileName).ToLowerInvariant();
-        if (string.IsNullOrEmpty(extension) || !AllowedImageTypes.Contains(extension))
-            return (false, string.Empty, "Only JPG, PNG, GIF, and WebP images are allowed.");
+        var (isValid, extension, error) = BlobFileHelper.ValidateUpload(file, AllowedImageTypes, MaxPhotoSize);
+        if (!isValid)
+            return (false, string.Empty, error);
 
         // SECURITY: Use GUID for blob name to prevent enumeration
         var blobName = $"{companyId}/job-photos/{jobId}/{Guid.NewGuid()}{extension}";
-        var contentType = GetContentType(extension);
+        var contentType = BlobFileHelper.GetContentType(extension);
 
         using var stream = file.OpenReadStream();
         var result = await _blobService.UploadAsync(_settings.Containers.JobImages, blobName, stream, contentType);
@@ -137,19 +131,4 @@ public class JobPhotoService : IJobPhotoService
         return await _blobService.ExistsAsync(_settings.Containers.JobImages, filePath);
     }
 
-    /// <summary>
-    /// Maps a lowercase file extension to its canonical MIME content type.
-    /// Falls back to <c>image/jpeg</c> (rather than octet-stream) because all
-    /// allowed extensions are image types and browsers will render them correctly.
-    /// </summary>
-    /// <param name="extension">Lowercase file extension including the leading dot.</param>
-    /// <returns>MIME type string.</returns>
-    private static string GetContentType(string extension) => extension switch
-    {
-        ".jpg" or ".jpeg" => "image/jpeg",
-        ".png" => "image/png",
-        ".gif" => "image/gif",
-        ".webp" => "image/webp",
-        _ => "image/jpeg"
-    };
 }

src/PowderCoating.Application/Services/ProfilePhotoService.cs

@@ -66,22 +66,16 @@ public class ProfilePhotoService : IProfilePhotoService
         string userId,
         int companyId)
     {
-        if (file == null || file.Length == 0)
-            return (false, string.Empty, "No file was uploaded.");
-
-        if (file.Length > MaxPhotoSize)
-            return (false, string.Empty, "Photo must be smaller than 10 MB.");
-
-        var extension = Path.GetExtension(file.FileName).ToLowerInvariant();
-        if (string.IsNullOrEmpty(extension) || !AllowedImageTypes.Contains(extension))
-            return (false, string.Empty, "Only JPG, PNG, GIF, and WebP images are allowed.");
+        var (isValid, extension, error) = BlobFileHelper.ValidateUpload(file, AllowedImageTypes, MaxPhotoSize);
+        if (!isValid)
+            return (false, string.Empty, error);
 
         // Delete old photos for this user with different extensions
         await DeleteOldPhotosForUserAsync(companyId, userId, extension);
 
         // Blob path mirrors former filesystem path
         var blobName = $"{companyId}/profile-photos/{userId}{extension}";
-        var contentType = GetContentType(extension);
+        var contentType = BlobFileHelper.GetContentType(extension);
 
         using var stream = file.OpenReadStream();
         var result = await _blobService.UploadAsync(_settings.Containers.ProfileImages, blobName, stream, contentType);
@@ -172,19 +166,4 @@ public class ProfilePhotoService : IProfilePhotoService
         }
     }
 
-    /// <summary>
-    /// Maps a lowercase file extension to its canonical MIME content type.
-    /// Falls back to <c>image/jpeg</c> (rather than octet-stream) because all
-    /// allowed extensions are image types and browsers will render them correctly.
-    /// </summary>
-    /// <param name="extension">Lowercase file extension including the leading dot.</param>
-    /// <returns>MIME type string.</returns>
-    private static string GetContentType(string extension) => extension switch
-    {
-        ".jpg" or ".jpeg" => "image/jpeg",
-        ".png" => "image/png",
-        ".gif" => "image/gif",
-        ".webp" => "image/webp",
-        _ => "image/jpeg"
-    };
 }

src/PowderCoating.Application/Services/QuotePhotoService.cs

@@ -50,19 +50,13 @@ public class QuotePhotoService : IQuotePhotoService
     public async Task<(bool Success, string TempId, string FilePath, string ErrorMessage)> SaveTempPhotoAsync(
         IFormFile file, int companyId)
     {
-        if (file == null || file.Length == 0)
-            return (false, string.Empty, string.Empty, "No file provided.");
-
-        if (file.Length > MaxFileSizeBytes)
-            return (false, string.Empty, string.Empty, "File exceeds the 10 MB limit.");
-
-        var ext = Path.GetExtension(file.FileName).ToLowerInvariant();
-        if (!AllowedExtensions.Contains(ext))
-            return (false, string.Empty, string.Empty, $"File type '{ext}' is not allowed.");
+        var (isValid, ext, validationError) = BlobFileHelper.ValidateUpload(file, AllowedExtensions, MaxFileSizeBytes);
+        if (!isValid)
+            return (false, string.Empty, string.Empty, validationError);
 
         var tempId = Guid.NewGuid().ToString("N");
         var blobName = $"temp/{tempId}/{Guid.NewGuid():N}{ext}";
-        var contentType = GetContentType(ext);
+        var contentType = BlobFileHelper.GetContentType(ext);
 
         using var stream = file.OpenReadStream();
         var result = await _blobService.UploadAsync(_settings.Containers.QuoteImages, blobName, stream, contentType);
@@ -100,7 +94,7 @@ public class QuotePhotoService : IQuotePhotoService
             return (false, string.Empty, "Failed to read temp photo.");
 
         using var ms = new MemoryStream(download.Content);
-        var upload = await _blobService.UploadAsync(_settings.Containers.QuoteImages, destBlob, ms, GetContentType(ext));
+        var upload = await _blobService.UploadAsync(_settings.Containers.QuoteImages, destBlob, ms, BlobFileHelper.GetContentType(ext));
         if (!upload.Success)
             return (false, string.Empty, "Failed to save permanent photo.");
 
@@ -173,12 +167,4 @@ public class QuotePhotoService : IQuotePhotoService
         }
     }
 
-    private static string GetContentType(string ext) => ext switch
-    {
-        ".jpg" or ".jpeg" => "image/jpeg",
-        ".png" => "image/png",
-        ".gif" => "image/gif",
-        ".webp" => "image/webp",
-        _ => "image/jpeg"
-    };
 }

src/PowderCoating.Application/Services/QuotePricingAssemblyService.cs

@@ -0,0 +1,369 @@
+using PowderCoating.Application.DTOs.Quote;
+using PowderCoating.Application.Interfaces;
+using PowderCoating.Core.Entities;
+using PowderCoating.Core.Interfaces;
+using Microsoft.Extensions.Logging;
+
+namespace PowderCoating.Application.Services;
+
+public class QuotePricingAssemblyService : IQuotePricingAssemblyService
+{
+    private readonly IUnitOfWork _unitOfWork;
+    private readonly IPricingCalculationService _pricingService;
+    private readonly IInventoryAiLookupService _aiLookupService;
+    private readonly ILogger<QuotePricingAssemblyService> _logger;
+
+    public QuotePricingAssemblyService(
+        IUnitOfWork unitOfWork,
+        IPricingCalculationService pricingService,
+        IInventoryAiLookupService aiLookupService,
+        ILogger<QuotePricingAssemblyService> logger)
+    {
+        _unitOfWork = unitOfWork;
+        _pricingService = pricingService;
+        _aiLookupService = aiLookupService;
+        _logger = logger;
+    }
+
+    public void ApplyPricingSnapshot(Quote quote, QuotePricingResult pricingResult)
+    {
+        ArgumentNullException.ThrowIfNull(quote);
+        ArgumentNullException.ThrowIfNull(pricingResult);
+
+        quote.MaterialCosts = pricingResult.MaterialCosts;
+        quote.LaborCosts = pricingResult.LaborCosts;
+        quote.EquipmentCosts = pricingResult.EquipmentCosts;
+        quote.ItemsSubtotal = pricingResult.ItemsSubtotal;
+        quote.OvenBatchCost = pricingResult.OvenBatchCost;
+        quote.ShopSuppliesAmount = pricingResult.ShopSuppliesAmount;
+        quote.ShopSuppliesPercent = pricingResult.ShopSuppliesPercent;
+        quote.OverheadAmount = pricingResult.OverheadCosts;
+        quote.OverheadPercent = pricingResult.OverheadPercent;
+        quote.ProfitMargin = pricingResult.ProfitMargin;
+        quote.ProfitPercent = pricingResult.ProfitPercent;
+        quote.SubTotal = pricingResult.SubtotalBeforeDiscount;
+        quote.DiscountPercent = pricingResult.DiscountPercent;
+        quote.DiscountAmount = pricingResult.DiscountAmount;
+        quote.RushFee = pricingResult.RushFee;
+        quote.TaxAmount = pricingResult.TaxAmount;
+        quote.Total = pricingResult.Total;
+    }
+
+    public async Task<IReadOnlyList<QuoteItem>> CreateQuoteItemsAsync(
+        IEnumerable<CreateQuoteItemDto> itemDtos,
+        int quoteId,
+        int companyId,
+        decimal? ovenRateOverride,
+        DateTime createdAtUtc)
+    {
+        ArgumentNullException.ThrowIfNull(itemDtos);
+
+        var items = new List<QuoteItem>();
+        foreach (var itemDto in itemDtos)
+        {
+            var item = BuildQuoteItem(itemDto, quoteId, companyId, createdAtUtc);
+            await ApplyPricingAsync(item, itemDto, companyId, ovenRateOverride);
+            await UpdateAiPredictionOverrideAsync(itemDto, item.UnitPrice);
+
+            item.Coats = await BuildQuoteItemCoatsAsync(itemDto, companyId, createdAtUtc);
+            item.PrepServices = BuildQuoteItemPrepServices(itemDto, companyId, createdAtUtc);
+            items.Add(item);
+        }
+
+        return items;
+    }
+
+    private async Task ApplyPricingAsync(QuoteItem item, CreateQuoteItemDto itemDto, int companyId, decimal? ovenRateOverride)
+    {
+        if (itemDto.IsAiItem && itemDto.ManualUnitPrice.HasValue && itemDto.ManualUnitPrice.Value > 0)
+        {
+            item.UnitPrice = itemDto.ManualUnitPrice.Value;
+            item.TotalPrice = itemDto.ManualUnitPrice.Value * itemDto.Quantity;
+            _logger.LogInformation("AI item price: UnitPrice={Unit}, TotalPrice={Total}", item.UnitPrice, item.TotalPrice);
+            return;
+        }
+
+        if (itemDto.IsSalesItem && itemDto.ManualUnitPrice.HasValue)
+        {
+            item.UnitPrice = itemDto.ManualUnitPrice.Value;
+            item.TotalPrice = itemDto.ManualUnitPrice.Value * itemDto.Quantity;
+            _logger.LogInformation("Sales item price: UnitPrice={Unit}, TotalPrice={Total}", item.UnitPrice, item.TotalPrice);
+            return;
+        }
+
+        if (itemDto.CatalogItemId.HasValue)
+        {
+            if (itemDto.Coats != null && itemDto.Coats.Any())
+            {
+                _logger.LogInformation("Calculating catalog item with {CoatCount} coats", itemDto.Coats.Count);
+                var itemPricing = await _pricingService.CalculateQuoteItemPriceAsync(itemDto, companyId, ovenRateOverride);
+                ApplyCalculatedPricing(item, itemPricing);
+                return;
+            }
+
+            var catalogItem = await _unitOfWork.CatalogItems.GetByIdAsync(itemDto.CatalogItemId.Value);
+            if (catalogItem != null)
+            {
+                item.UnitPrice = catalogItem.DefaultPrice;
+                item.TotalPrice = catalogItem.DefaultPrice * itemDto.Quantity;
+                _logger.LogInformation("Catalog item no coats: UnitPrice={Unit}, TotalPrice={Total}", item.UnitPrice, item.TotalPrice);
+            }
+
+            return;
+        }
+
+        _logger.LogInformation("Calculating custom item with {CoatCount} coats", itemDto.Coats?.Count ?? 0);
+        var pricing = await _pricingService.CalculateQuoteItemPriceAsync(itemDto, companyId, ovenRateOverride);
+        ApplyCalculatedPricing(item, pricing);
+    }
+
+    private async Task<List<QuoteItemCoat>> BuildQuoteItemCoatsAsync(CreateQuoteItemDto itemDto, int companyId, DateTime createdAtUtc)
+    {
+        if (itemDto.Coats == null || itemDto.Coats.Count == 0)
+            return [];
+
+        var coats = new List<QuoteItemCoat>();
+        for (var coatIndex = 0; coatIndex < itemDto.Coats.Count; coatIndex++)
+        {
+            var coatDto = itemDto.Coats[coatIndex];
+
+            if (coatDto.AddAsIncoming && coatDto.CatalogItemId.HasValue && !coatDto.InventoryItemId.HasValue)
+                coatDto.InventoryItemId = await CreateIncomingInventoryItemAsync(coatDto, companyId);
+
+            var coat = BuildQuoteItemCoat(coatDto, companyId, createdAtUtc);
+            var coatPricing = await _pricingService.CalculateCoatPriceAsync(
+                coatDto,
+                itemDto.SurfaceAreaSqFt,
+                itemDto.Quantity,
+                coatIndex,
+                itemDto.EstimatedMinutes,
+                companyId);
+
+            coat.CoatMaterialCost = coatPricing.CoatMaterialCost;
+            coat.CoatLaborCost = coatPricing.CoatLaborCost;
+            coat.CoatTotalCost = coatPricing.CoatTotalCost;
+            coats.Add(coat);
+        }
+
+        return coats;
+    }
+
+    private static List<QuoteItemPrepService> BuildQuoteItemPrepServices(CreateQuoteItemDto itemDto, int companyId, DateTime createdAtUtc)
+    {
+        if (itemDto.PrepServices == null || itemDto.PrepServices.Count == 0)
+            return [];
+
+        return itemDto.PrepServices
+            .Select(ps => new QuoteItemPrepService
+            {
+                PrepServiceId = ps.PrepServiceId,
+                EstimatedMinutes = ps.EstimatedMinutes,
+                BlastSetupId = ps.BlastSetupId,
+                CompanyId = companyId,
+                CreatedAt = createdAtUtc
+            })
+            .ToList();
+    }
+
+    private static QuoteItem BuildQuoteItem(CreateQuoteItemDto itemDto, int quoteId, int companyId, DateTime createdAtUtc)
+    {
+        return new QuoteItem
+        {
+            QuoteId = quoteId,
+            Description = itemDto.Description,
+            Quantity = itemDto.Quantity,
+            SurfaceAreaSqFt = itemDto.SurfaceAreaSqFt,
+            CatalogItemId = itemDto.CatalogItemId,
+            IsGenericItem = itemDto.IsGenericItem,
+            ManualUnitPrice = itemDto.ManualUnitPrice,
+            PowderCostOverride = itemDto.PowderCostOverride,
+            IsLaborItem = itemDto.IsLaborItem,
+            IsSalesItem = itemDto.IsSalesItem,
+            Sku = itemDto.Sku,
+            RequiresSandblasting = itemDto.RequiresSandblasting,
+            RequiresMasking = itemDto.RequiresMasking,
+            EstimatedMinutes = itemDto.EstimatedMinutes,
+            IncludePrepCost = itemDto.IncludePrepCost,
+            Notes = itemDto.Notes,
+            Complexity = itemDto.Complexity,
+            IsAiItem = itemDto.IsAiItem,
+            AiTags = itemDto.AiTags,
+            AiPredictionId = itemDto.AiPredictionId,
+            CompanyId = companyId,
+            CreatedAt = createdAtUtc
+        };
+    }
+
+    private static QuoteItemCoat BuildQuoteItemCoat(CreateQuoteItemCoatDto coatDto, int companyId, DateTime createdAtUtc)
+    {
+        return new QuoteItemCoat
+        {
+            CoatName = coatDto.CoatName,
+            Sequence = coatDto.Sequence,
+            InventoryItemId = coatDto.InventoryItemId,
+            ColorName = coatDto.ColorName,
+            VendorId = coatDto.VendorId,
+            ColorCode = coatDto.ColorCode,
+            Finish = coatDto.Finish,
+            CoverageSqFtPerLb = coatDto.CoverageSqFtPerLb,
+            TransferEfficiency = coatDto.TransferEfficiency,
+            PowderCostPerLb = coatDto.PowderCostPerLb,
+            PowderToOrder = coatDto.PowderToOrder,
+            Notes = coatDto.Notes,
+            CompanyId = companyId,
+            CreatedAt = createdAtUtc
+        };
+    }
+
+    private static void ApplyCalculatedPricing(QuoteItem item, QuoteItemPricingResult pricing)
+    {
+        item.UnitPrice = pricing.UnitPrice;
+        item.TotalPrice = pricing.TotalPrice;
+        item.ItemMaterialCost = pricing.MaterialCost;
+        item.ItemLaborCost = pricing.LaborCost;
+        item.ItemEquipmentCost = pricing.EquipmentCost;
+    }
+
+    private async Task UpdateAiPredictionOverrideAsync(CreateQuoteItemDto itemDto, decimal finalUnitPrice)
+    {
+        if (!itemDto.AiPredictionId.HasValue) return;
+
+        var prediction = await _unitOfWork.AiItemPredictions.GetByIdAsync(itemDto.AiPredictionId.Value);
+        if (prediction == null) return;
+
+        var sqftDiff = Math.Abs(prediction.PredictedSurfaceAreaSqFt - itemDto.SurfaceAreaSqFt);
+        var priceDiff = Math.Abs(prediction.PredictedUnitPrice - finalUnitPrice);
+        prediction.UserOverrodeEstimate = sqftDiff > 0.01m || priceDiff > 0.01m;
+        prediction.UpdatedAt = DateTime.UtcNow;
+    }
+
+    private async Task<int?> CreateIncomingInventoryItemAsync(CreateQuoteItemCoatDto coatDto, int companyId)
+    {
+        try
+        {
+            var catalogItem = await _unitOfWork.PowderCatalog.GetByIdAsync(coatDto.CatalogItemId!.Value);
+            if (catalogItem == null) return null;
+
+            var categories = await _unitOfWork.InventoryCategoryLookups.GetAllAsync();
+            var coatingCategory = categories
+                .Where(c => c.IsActive && c.IsCoating)
+                .OrderBy(c => c.DisplayOrder)
+                .FirstOrDefault();
+
+            var vendors = await _unitOfWork.Vendors.GetAllAsync();
+            var vendorNameLower = catalogItem.VendorName.ToLower();
+            var matchedVendor = vendors.FirstOrDefault(v =>
+                v.CompanyName.ToLower().Contains(vendorNameLower) ||
+                vendorNameLower.Contains(v.CompanyName.ToLower()));
+
+            var code = coatingCategory != null
+                ? (coatingCategory.CategoryCode.Length >= 4
+                    ? coatingCategory.CategoryCode[..4].ToUpperInvariant()
+                    : coatingCategory.CategoryCode.ToUpperInvariant().PadRight(4, 'X'))
+                : "POWD";
+            var prefix = $"{code}-{DateTime.Now:yyMM}-";
+            var allItems = await _unitOfWork.InventoryItems.GetAllAsync(ignoreQueryFilters: true);
+            var maxSeq = allItems
+                .Where(i => i.SKU.StartsWith(prefix))
+                .Select(i => int.TryParse(i.SKU[prefix.Length..], out var n) ? n : 0)
+                .DefaultIfEmpty(0)
+                .Max();
+            var sku = $"{prefix}{(maxSeq + 1):D4}";
+
+            var name = System.Globalization.CultureInfo.CurrentCulture.TextInfo
+                .ToTitleCase(catalogItem.ColorName.Trim().ToLower());
+
+            var description = catalogItem.Description;
+            var finish = catalogItem.Finish;
+            var colorFamilies = catalogItem.ColorFamilies;
+            var cureTemp = catalogItem.CureTemperatureF;
+            var cureTime = catalogItem.CureTimeMinutes;
+            var coverage = catalogItem.CoverageSqFtPerLb;
+            var transferEff = catalogItem.TransferEfficiency;
+            var specificGravity = catalogItem.SpecificGravity;
+            var imageUrl = catalogItem.ImageUrl;
+            var sdsUrl = catalogItem.SdsUrl;
+            var tdsUrl = catalogItem.TdsUrl;
+
+            var needsAugment = !string.IsNullOrWhiteSpace(catalogItem.ProductUrl) &&
+                               (string.IsNullOrWhiteSpace(description) ||
+                                string.IsNullOrWhiteSpace(colorFamilies) ||
+                                cureTemp == null || cureTime == null);
+            if (needsAugment)
+            {
+                try
+                {
+                    var augmented = await _aiLookupService.LookupByUrlAsync(catalogItem.ProductUrl!, catalogItem.ColorName, catalogItem.TdsUrl);
+                    if (augmented.Success)
+                    {
+                        description = string.IsNullOrWhiteSpace(description) ? augmented.Description : description;
+                        finish = string.IsNullOrWhiteSpace(finish) ? augmented.Finish : finish;
+                        colorFamilies = string.IsNullOrWhiteSpace(colorFamilies) ? augmented.ColorFamilies : colorFamilies;
+                        cureTemp ??= augmented.CureTemperatureF;
+                        cureTime ??= augmented.CureTimeMinutes;
+                        coverage ??= augmented.CoverageSqFtPerLb;
+                        transferEff ??= augmented.TransferEfficiency;
+                        specificGravity ??= augmented.SpecificGravity;
+                        imageUrl = string.IsNullOrWhiteSpace(imageUrl) ? augmented.ImageUrl : imageUrl;
+                        sdsUrl = string.IsNullOrWhiteSpace(sdsUrl) ? augmented.SdsUrl : sdsUrl;
+                        tdsUrl = string.IsNullOrWhiteSpace(tdsUrl) ? augmented.TdsUrl : tdsUrl;
+                        _logger.LogInformation("AI-augmented incoming inventory item for catalog {CatalogId}", catalogItem.Id);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogWarning(ex, "AI augment failed for catalog {CatalogId}, continuing with catalog data", catalogItem.Id);
+                }
+            }
+
+            var item = new InventoryItem
+            {
+                SKU = sku,
+                Name = name,
+                Description = description,
+                ColorName = catalogItem.ColorName,
+                Manufacturer = catalogItem.VendorName,
+                ManufacturerPartNumber = catalogItem.Sku,
+                Finish = finish,
+                ColorFamilies = colorFamilies,
+                RequiresClearCoat = catalogItem.RequiresClearCoat ?? false,
+                CoverageSqFtPerLb = coverage ?? 30m,
+                TransferEfficiency = transferEff ?? 65m,
+                CureTemperatureF = cureTemp,
+                CureTimeMinutes = cureTime,
+                SpecificGravity = specificGravity,
+                SpecPageUrl = catalogItem.ProductUrl,
+                ImageUrl = imageUrl,
+                SdsUrl = sdsUrl,
+                TdsUrl = tdsUrl,
+                UnitCost = catalogItem.UnitPrice,
+                AverageCost = catalogItem.UnitPrice,
+                LastPurchasePrice = catalogItem.UnitPrice,
+                QuantityOnHand = 0,
+                UnitOfMeasure = "lbs",
+                PrimaryVendorId = matchedVendor?.Id,
+                InventoryCategoryId = coatingCategory?.Id,
+                Category = coatingCategory?.DisplayName ?? "Powder Coating",
+                IsActive = true,
+                IsIncoming = true,
+                CompanyId = companyId,
+                CreatedAt = DateTime.UtcNow,
+            };
+
+            await _unitOfWork.InventoryItems.AddAsync(item);
+            await _unitOfWork.SaveChangesAsync();
+
+            coatDto.PowderCostPerLb = null;
+            _logger.LogInformation("Created incoming inventory item {Id} ({Name}) from catalog {CatalogId} via quote coat",
+                item.Id, item.Name, coatDto.CatalogItemId);
+
+            return item.Id;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Failed to create incoming inventory item from catalog {CatalogId}, continuing without inventory link",
+                coatDto.CatalogItemId);
+            return null;
+        }
+    }
+}

src/PowderCoating.Core/Entities/JobTemplateItem.cs

@@ -9,6 +9,8 @@ public class JobTemplateItem : BaseEntity
     public int? CatalogItemId { get; set; }
     public bool IsGenericItem { get; set; }
     public bool IsLaborItem { get; set; }
+    public bool IsSalesItem { get; set; }
+    public string? Sku { get; set; }
     public decimal? ManualUnitPrice { get; set; }
     public bool RequiresSandblasting { get; set; }
     public bool RequiresMasking { get; set; }

src/PowderCoating.Infrastructure/Migrations/20260510011252_AddJobTemplateItemSalesFields.cs

@@ -0,0 +1,82 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace PowderCoating.Infrastructure.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddJobTemplateItemSalesFields : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "IsSalesItem",
+                table: "JobTemplateItems",
+                type: "bit",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AddColumn<string>(
+                name: "Sku",
+                table: "JobTemplateItems",
+                type: "nvarchar(max)",
+                nullable: true);
+
+            migrationBuilder.UpdateData(
+                table: "PricingTiers",
+                keyColumn: "Id",
+                keyValue: 1,
+                column: "CreatedAt",
+                value: new DateTime(2026, 5, 10, 1, 12, 48, 386, DateTimeKind.Utc).AddTicks(2249));
+
+            migrationBuilder.UpdateData(
+                table: "PricingTiers",
+                keyColumn: "Id",
+                keyValue: 2,
+                column: "CreatedAt",
+                value: new DateTime(2026, 5, 10, 1, 12, 48, 386, DateTimeKind.Utc).AddTicks(2260));
+
+            migrationBuilder.UpdateData(
+                table: "PricingTiers",
+                keyColumn: "Id",
+                keyValue: 3,
+                column: "CreatedAt",
+                value: new DateTime(2026, 5, 10, 1, 12, 48, 386, DateTimeKind.Utc).AddTicks(2261));
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "IsSalesItem",
+                table: "JobTemplateItems");
+
+            migrationBuilder.DropColumn(
+                name: "Sku",
+                table: "JobTemplateItems");
+
+            migrationBuilder.UpdateData(
+                table: "PricingTiers",
+                keyColumn: "Id",
+                keyValue: 1,
+                column: "CreatedAt",
+                value: new DateTime(2026, 5, 8, 14, 21, 51, 589, DateTimeKind.Utc).AddTicks(4358));
+
+            migrationBuilder.UpdateData(
+                table: "PricingTiers",
+                keyColumn: "Id",
+                keyValue: 2,
+                column: "CreatedAt",
+                value: new DateTime(2026, 5, 8, 14, 21, 51, 589, DateTimeKind.Utc).AddTicks(4424));
+
+            migrationBuilder.UpdateData(
+                table: "PricingTiers",
+                keyColumn: "Id",
+                keyValue: 3,
+                column: "CreatedAt",
+                value: new DateTime(2026, 5, 8, 14, 21, 51, 589, DateTimeKind.Utc).AddTicks(4426));
+        }
+    }
+}

src/PowderCoating.Infrastructure/Migrations/ApplicationDbContextModelSnapshot.cs

@@ -4833,6 +4833,9 @@ namespace PowderCoating.Infrastructure.Migrations
                     b.Property<bool>("IsLaborItem")
                         .HasColumnType("bit");
 
+                    b.Property<bool>("IsSalesItem")
+                        .HasColumnType("bit");
+
                     b.Property<int>("JobTemplateId")
                         .HasColumnType("int");
 
@@ -4851,6 +4854,9 @@ namespace PowderCoating.Infrastructure.Migrations
                     b.Property<bool>("RequiresSandblasting")
                         .HasColumnType("bit");
 
+                    b.Property<string>("Sku")
+                        .HasColumnType("nvarchar(max)");
+
                     b.Property<decimal>("SurfaceAreaSqFt")
                         .HasColumnType("decimal(18,2)");
 
@@ -6071,7 +6077,7 @@ namespace PowderCoating.Infrastructure.Migrations
                         {
                             Id = 1,
                             CompanyId = 0,
-                            CreatedAt = new DateTime(2026, 5, 8, 14, 21, 51, 589, DateTimeKind.Utc).AddTicks(4358),
+                            CreatedAt = new DateTime(2026, 5, 10, 1, 12, 48, 386, DateTimeKind.Utc).AddTicks(2249),
                             Description = "Standard pricing for regular customers",
                             DiscountPercent = 0m,
                             IsActive = true,
@@ -6082,7 +6088,7 @@ namespace PowderCoating.Infrastructure.Migrations
                         {
                             Id = 2,
                             CompanyId = 0,
-                            CreatedAt = new DateTime(2026, 5, 8, 14, 21, 51, 589, DateTimeKind.Utc).AddTicks(4424),
+                            CreatedAt = new DateTime(2026, 5, 10, 1, 12, 48, 386, DateTimeKind.Utc).AddTicks(2260),
                             Description = "5% discount for preferred customers",
                             DiscountPercent = 5m,
                             IsActive = true,
@@ -6093,7 +6099,7 @@ namespace PowderCoating.Infrastructure.Migrations
                         {
                             Id = 3,
                             CompanyId = 0,
-                            CreatedAt = new DateTime(2026, 5, 8, 14, 21, 51, 589, DateTimeKind.Utc).AddTicks(4426),
+                            CreatedAt = new DateTime(2026, 5, 10, 1, 12, 48, 386, DateTimeKind.Utc).AddTicks(2261),
                             Description = "10% discount for premium customers",
                             DiscountPercent = 10m,
                             IsActive = true,

src/PowderCoating.Web/Controllers/AppointmentsController.cs

@@ -117,14 +117,7 @@ public class AppointmentsController : Controller
             // Map to DTOs
             var appointmentDtos = _mapper.Map<List<AppointmentListDto>>(items);
 
-            // Create paged result
-            var pagedResult = new PagedResult<AppointmentListDto>
-            {
-                Items = appointmentDtos,
-                PageNumber = gridRequest.PageNumber,
-                PageSize = gridRequest.PageSize,
-                TotalCount = totalCount
-            };
+            var pagedResult = PagedResult<AppointmentListDto>.From(gridRequest, appointmentDtos, totalCount);
 
             // Set ViewBag
             ViewBag.SearchTerm = searchTerm;

src/PowderCoating.Web/Controllers/BillsController.cs

@@ -8,6 +8,7 @@ using Microsoft.AspNetCore.Mvc.Rendering;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Options;
 using PowderCoating.Application.Configuration;
+using PowderCoating.Application.Services;
 using PowderCoating.Application.DTOs.Accounting;
 using PowderCoating.Application.DTOs.AI;
 using PowderCoating.Application.Interfaces;
@@ -15,6 +16,7 @@ using PowderCoating.Core.Entities;
 using PowderCoating.Core.Enums;
 using PowderCoating.Core.Interfaces;
 using PowderCoating.Application.DTOs.PurchaseOrder;
+using PowderCoating.Web.Helpers;
 
 namespace PowderCoating.Web.Controllers;
 
@@ -345,10 +347,11 @@ public class BillsController : Controller
             // Attach receipt file if provided
             if (receiptFile != null && receiptFile.Length > 0)
             {
-                if (IsValidReceiptFile(receiptFile, out var fileError))
+                var (receiptValid, _, receiptError) = BlobFileHelper.ValidateUpload(receiptFile, AllowedReceiptTypes, MaxReceiptBytes);
+                if (receiptValid)
                     bill.ReceiptFilePath = await UploadReceiptAsync(receiptFile, bill.Id, currentUser.CompanyId);
                 else
-                    TempData["Warning"] = $"Bill saved but receipt not uploaded: {fileError}";
+                    TempData["Warning"] = $"Bill saved but receipt not uploaded: {receiptError}";
                 await _unitOfWork.CompleteAsync();
             }
 
@@ -571,7 +574,8 @@ public class BillsController : Controller
             // Handle receipt file replacement
             if (receiptFile != null && receiptFile.Length > 0)
             {
-                if (IsValidReceiptFile(receiptFile, out var fileError))
+                var (receiptValid, _, receiptError) = BlobFileHelper.ValidateUpload(receiptFile, AllowedReceiptTypes, MaxReceiptBytes);
+                if (receiptValid)
                 {
                     if (!string.IsNullOrEmpty(bill.ReceiptFilePath))
                         await _blobStorage.DeleteAsync(_storageSettings.Containers.ReceiptImages, bill.ReceiptFilePath);
@@ -579,7 +583,7 @@ public class BillsController : Controller
                 }
                 else
                 {
-                    TempData["Warning"] = $"Bill saved but receipt not uploaded: {fileError}";
+                    TempData["Warning"] = $"Bill saved but receipt not uploaded: {receiptError}";
                 }
             }
 
@@ -927,48 +931,13 @@ public class BillsController : Controller
     /// </summary>
     private async Task PopulateDropdownsAsync()
     {
-        var vendors = await _unitOfWork.Vendors.FindAsync(s => s.IsActive);
-        ViewBag.Vendors = vendors
-            .OrderBy(s => s.CompanyName)
-            .Select(s => new SelectListItem(s.CompanyName, s.Id.ToString()))
-            .ToList();
-
-        var allAccounts = await _unitOfWork.Accounts.FindAsync(a => a.IsActive);
-
-        ViewBag.APAccounts = allAccounts
-            .Where(a => a.AccountSubType == AccountSubType.AccountsPayable)
-            .OrderBy(a => a.AccountNumber)
-            .Select(a => new SelectListItem($"{a.AccountNumber} – {a.Name}", a.Id.ToString()))
-            .ToList();
-
-        ViewBag.ExpenseAccounts = allAccounts
-            .Where(a => a.AccountType == AccountType.Expense ||
-                        a.AccountType == AccountType.CostOfGoods ||
-                        a.AccountType == AccountType.Asset)
-            .OrderBy(a => a.AccountNumber)
-            .Select(a => new SelectListItem($"{a.AccountNumber} – {a.Name}", a.Id.ToString()))
-            .ToList();
-
-        ViewBag.BankAccounts = allAccounts
-            .Where(a => a.AccountSubType == AccountSubType.Cash ||
-                        a.AccountSubType == AccountSubType.Checking ||
-                        a.AccountSubType == AccountSubType.Savings ||
-                        a.AccountSubType == AccountSubType.CreditCard)
-            .OrderBy(a => a.AccountNumber)
-            .Select(a => new SelectListItem($"{a.AccountNumber} – {a.Name}", a.Id.ToString()))
-            .ToList();
-
-        ViewBag.PaymentMethods = Enum.GetValues<PaymentMethod>()
-            .Select(m => new SelectListItem(m.ToString(), ((int)m).ToString()))
-            .ToList();
-
-        ViewBag.Jobs = (await _unitOfWork.Jobs.FindAsync(j =>
-                j.JobStatus.StatusCode != "COMPLETED" &&
-                j.JobStatus.StatusCode != "CANCELLED" &&
-                j.JobStatus.StatusCode != "DELIVERED"))
-            .OrderBy(j => j.JobNumber)
-            .Select(j => new SelectListItem($"{j.JobNumber} – {j.Description ?? "No description"}", j.Id.ToString()))
-            .ToList();
+        var dd = await AccountingDropdownHelper.LoadAsync(_unitOfWork);
+        ViewBag.Vendors = dd.Vendors;
+        ViewBag.APAccounts = dd.ApAccounts;
+        ViewBag.ExpenseAccounts = dd.ExpenseAndAssetAccounts;
+        ViewBag.BankAccounts = dd.BankAccounts;
+        ViewBag.PaymentMethods = dd.PaymentMethods;
+        ViewBag.Jobs = dd.ActiveJobs;
     }
 
     /// <summary>
@@ -1023,7 +992,7 @@ public class BillsController : Controller
         if (!result.Success) return NotFound();
 
         var ext = Path.GetExtension(bill.ReceiptFilePath).ToLowerInvariant();
-        var contentType = MimeFromExt(ext);
+        var contentType = BlobFileHelper.GetContentType(ext);
         var fileName = $"receipt-{bill.BillNumber}{ext}";
         return File(result.Content, contentType, fileName);
     }
@@ -1161,41 +1130,8 @@ public class BillsController : Controller
     {
         var ext = Path.GetExtension(file.FileName).ToLowerInvariant();
         var blobName = $"{companyId}/bill-receipts/{billId}/{Guid.NewGuid()}{ext}";
-        var contentType = MimeFromExt(ext);
         using var stream = file.OpenReadStream();
-        var result = await _blobStorage.UploadAsync(_storageSettings.Containers.ReceiptImages, blobName, stream, contentType);
+        var result = await _blobStorage.UploadAsync(_storageSettings.Containers.ReceiptImages, blobName, stream, BlobFileHelper.GetContentType(ext));
         return result.Success ? blobName : null;
     }
-
-    /// <summary>
-    /// Validates a receipt file upload against the allowed extension list and the 10 MB size cap.
-    /// Returns <c>false</c> and populates <paramref name="error"/> with a user-friendly message
-    /// when the file fails either check; returns <c>true</c> and sets <paramref name="error"/> to
-    /// an empty string when the file is acceptable.
-    /// </summary>
-    private static bool IsValidReceiptFile(IFormFile file, out string error)
-    {
-        var ext = Path.GetExtension(file.FileName).ToLowerInvariant();
-        if (!AllowedReceiptTypes.Contains(ext))
-        {
-            error = $"File type '{ext}' is not allowed. Accepted: {string.Join(", ", AllowedReceiptTypes)}";
-            return false;
-        }
-        if (file.Length > MaxReceiptBytes)
-        {
-            error = "Receipt file must be 10 MB or smaller.";
-            return false;
-        }
-        error = string.Empty;
-        return true;
-    }
-
-    private static string MimeFromExt(string ext) => ext switch
-    {
-        ".pdf"  => "application/pdf",
-        ".png"  => "image/png",
-        ".gif"  => "image/gif",
-        ".webp" => "image/webp",
-        _       => "image/jpeg"
-    };
 }

src/PowderCoating.Web/Controllers/CompanyUsersController.cs

@@ -174,14 +174,7 @@ public class CompanyUsersController : Controller
                 LastLoginDate = u.LastLoginDate
             }).ToList();
 
-            // Create paged result
-            var pagedResult = new PagedResult<CompanyUserListDto>
-            {
-                Items = userDtos,
-                PageNumber = gridRequest.PageNumber,
-                PageSize = gridRequest.PageSize,
-                TotalCount = totalCount
-            };
+            var pagedResult = PagedResult<CompanyUserListDto>.From(gridRequest, userDtos, totalCount);
 
             // Set ViewBag for sorting and filters
             ViewBag.SearchTerm = searchTerm;

src/PowderCoating.Web/Controllers/CustomersController.cs

@@ -123,14 +123,7 @@ public class CustomersController : Controller
                 LastContactDate = c.LastContactDate
             }).ToList();
 
-            // Create paged result
-            var pagedResult = new PagedResult<CustomerListDto>
-            {
-                Items = customerDtos,
-                PageNumber = gridRequest.PageNumber,
-                PageSize = gridRequest.PageSize,
-                TotalCount = totalCount
-            };
+            var pagedResult = PagedResult<CustomerListDto>.From(gridRequest, customerDtos, totalCount);
 
             // Set ViewBag for sorting
             ViewBag.SearchTerm = searchTerm;

src/PowderCoating.Web/Controllers/EquipmentController.cs

@@ -121,14 +121,7 @@ public class EquipmentController : Controller
             // Map to DTOs
             var equipmentDtos = _mapper.Map<List<EquipmentListDto>>(items);
 
-            // Create paged result
-            var pagedResult = new PagedResult<EquipmentListDto>
-            {
-                Items = equipmentDtos,
-                PageNumber = gridRequest.PageNumber,
-                PageSize = gridRequest.PageSize,
-                TotalCount = totalCount
-            };
+            var pagedResult = PagedResult<EquipmentListDto>.From(gridRequest, equipmentDtos, totalCount);
 
             // Set ViewBag for sorting and filters
             ViewBag.SearchTerm = searchTerm;

src/PowderCoating.Web/Controllers/ExpensesController.cs

@@ -8,12 +8,14 @@ using Microsoft.AspNetCore.Mvc.Rendering;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Options;
 using PowderCoating.Application.Configuration;
+using PowderCoating.Application.Services;
 using PowderCoating.Application.DTOs.Accounting;
 using PowderCoating.Application.DTOs.AI;
 using PowderCoating.Application.Interfaces;
 using PowderCoating.Core.Entities;
 using PowderCoating.Core.Enums;
 using PowderCoating.Core.Interfaces;
+using PowderCoating.Web.Helpers;
 
 namespace PowderCoating.Web.Controllers;
 
@@ -148,11 +150,15 @@ public class ExpensesController : Controller
             return View(dto);
         }
 
-        if (receiptFile != null && !IsValidReceiptFile(receiptFile, out var fileError))
+        if (receiptFile != null)
         {
-            ModelState.AddModelError(string.Empty, fileError);
-            await PopulateDropdownsAsync();
-            return View(dto);
+            var (receiptValid, _, receiptError) = BlobFileHelper.ValidateUpload(receiptFile, AllowedReceiptTypes, MaxReceiptBytes);
+            if (!receiptValid)
+            {
+                ModelState.AddModelError(string.Empty, receiptError);
+                await PopulateDropdownsAsync();
+                return View(dto);
+            }
         }
 
         try
@@ -228,11 +234,15 @@ public class ExpensesController : Controller
             return View(dto);
         }
 
-        if (receiptFile != null && !IsValidReceiptFile(receiptFile, out var fileError))
+        if (receiptFile != null)
         {
-            ModelState.AddModelError(string.Empty, fileError);
-            await PopulateDropdownsAsync();
-            return View(dto);
+            var (receiptValid, _, receiptError) = BlobFileHelper.ValidateUpload(receiptFile, AllowedReceiptTypes, MaxReceiptBytes);
+            if (!receiptValid)
+            {
+                ModelState.AddModelError(string.Empty, receiptError);
+                await PopulateDropdownsAsync();
+                return View(dto);
+            }
         }
 
         try
@@ -345,7 +355,7 @@ public class ExpensesController : Controller
 
         // Inline for images so the browser previews them; attachment for PDFs triggers download
         var ext = Path.GetExtension(expense.ReceiptFilePath).ToLowerInvariant();
-        var contentType = result.ContentType.Length > 0 ? result.ContentType : MimeFromExt(ext);
+        var contentType = result.ContentType.Length > 0 ? result.ContentType : BlobFileHelper.GetContentType(ext);
         var filename = $"Receipt-{expense.ExpenseNumber}{ext}";
 
         Response.Headers["Content-Disposition"] = ext == ".pdf"
@@ -392,39 +402,12 @@ public class ExpensesController : Controller
     /// </summary>
     private async Task PopulateDropdownsAsync()
     {
-        var allAccounts = await _unitOfWork.Accounts.FindAsync(a => a.IsActive);
-
-        ViewBag.ExpenseAccounts = allAccounts
-            .Where(a => a.AccountType == AccountType.Expense || a.AccountType == AccountType.CostOfGoods)
-            .OrderBy(a => a.AccountNumber)
-            .Select(a => new SelectListItem($"{a.AccountNumber} – {a.Name}", a.Id.ToString()))
-            .ToList();
-
-        ViewBag.PaymentAccounts = allAccounts
-            .Where(a => a.AccountSubType == AccountSubType.Cash ||
-                        a.AccountSubType == AccountSubType.Checking ||
-                        a.AccountSubType == AccountSubType.Savings ||
-                        a.AccountSubType == AccountSubType.CreditCard)
-            .OrderBy(a => a.AccountNumber)
-            .Select(a => new SelectListItem($"{a.AccountNumber} – {a.Name}", a.Id.ToString()))
-            .ToList();
-
-        ViewBag.Vendors = (await _unitOfWork.Vendors.FindAsync(s => s.IsActive))
-            .OrderBy(s => s.CompanyName)
-            .Select(s => new SelectListItem(s.CompanyName, s.Id.ToString()))
-            .ToList();
-
-        ViewBag.Jobs = (await _unitOfWork.Jobs.FindAsync(j =>
-                j.JobStatus.StatusCode != "COMPLETED" &&
-                j.JobStatus.StatusCode != "CANCELLED" &&
-                j.JobStatus.StatusCode != "DELIVERED"))
-            .OrderBy(j => j.JobNumber)
-            .Select(j => new SelectListItem($"{j.JobNumber} – {j.Description ?? "No description"}", j.Id.ToString()))
-            .ToList();
-
-        ViewBag.PaymentMethods = Enum.GetValues<PaymentMethod>()
-            .Select(m => new SelectListItem(m.ToString(), ((int)m).ToString()))
-            .ToList();
+        var dd = await AccountingDropdownHelper.LoadAsync(_unitOfWork);
+        ViewBag.ExpenseAccounts = dd.ExpenseAccounts;
+        ViewBag.PaymentAccounts = dd.BankAccounts;
+        ViewBag.Vendors = dd.Vendors;
+        ViewBag.Jobs = dd.ActiveJobs;
+        ViewBag.PaymentMethods = dd.PaymentMethods;
     }
 
     /// <summary>
@@ -458,10 +441,8 @@ public class ExpensesController : Controller
     {
         var ext = Path.GetExtension(file.FileName).ToLowerInvariant();
         var blobName = $"{companyId}/expense-receipts/{expenseId}{ext}";
-        var contentType = MimeFromExt(ext);
-
         using var stream = file.OpenReadStream();
-        var result = await _blobStorage.UploadAsync(_storageSettings.Containers.ReceiptImages, blobName, stream, contentType);
+        var result = await _blobStorage.UploadAsync(_storageSettings.Containers.ReceiptImages, blobName, stream, BlobFileHelper.GetContentType(ext));
         if (!result.Success)
         {
             _logger.LogError("Receipt upload failed for expense {Id}: {Error}", expenseId, result.ErrorMessage);
@@ -470,35 +451,7 @@ public class ExpensesController : Controller
         return blobName;
     }
 
-    /// <summary>
-    /// Validates a receipt file against the allowed extension whitelist and the 10 MB size cap.
-    /// Returns <c>false</c> and sets <paramref name="error"/> when validation fails.
-    /// </summary>
-    private static bool IsValidReceiptFile(IFormFile file, out string error)
-    {
-        var ext = Path.GetExtension(file.FileName).ToLowerInvariant();
-        if (!AllowedReceiptTypes.Contains(ext))
-        {
-            error = $"File type '{ext}' is not allowed. Accepted types: {string.Join(", ", AllowedReceiptTypes)}";
-            return false;
-        }
-        if (file.Length > MaxReceiptBytes)
-        {
-            error = "Receipt file must be 10 MB or smaller.";
-            return false;
-        }
-        error = string.Empty;
-        return true;
-    }
 
-    private static string MimeFromExt(string ext) => ext switch
-    {
-        ".pdf"  => "application/pdf",
-        ".png"  => "image/png",
-        ".gif"  => "image/gif",
-        ".webp" => "image/webp",
-        _       => "image/jpeg"
-    };
 
     // ── AI: Account Suggestion ────────────────────────────────────────────────
 

src/PowderCoating.Web/Controllers/InventoryController.cs

@@ -154,14 +154,7 @@ public class InventoryController : Controller
             // Map to DTOs using AutoMapper
             var itemDtos = _mapper.Map<List<InventoryListDto>>(items);
 
-            // Create paged result
-            var pagedResult = new PagedResult<InventoryListDto>
-            {
-                Items = itemDtos,
-                PageNumber = gridRequest.PageNumber,
-                PageSize = gridRequest.PageSize,
-                TotalCount = totalCount
-            };
+            var pagedResult = PagedResult<InventoryListDto>.From(gridRequest, itemDtos, totalCount);
 
             // Load all items once to compute sidebar stats and category list in memory
             var allItems = (await _unitOfWork.InventoryItems.GetAllAsync()).ToList();

src/PowderCoating.Web/Controllers/InvoicesController.cs

@@ -208,16 +208,8 @@ public class InvoicesController : Controller
 
             var dtos = _mapper.Map<List<InvoiceListDto>>(items);
 
-            var pagedResult = new PagedResult<InvoiceListDto>
-            {
-                Items = dtos,
-                PageNumber = gridRequest.PageNumber,
-                PageSize = gridRequest.PageSize,
-                TotalCount = totalCount,
-                SortColumn = gridRequest.SortColumn,
-                SortDirection = gridRequest.SortDirection,
-                SearchTerm = searchTerm
-            };
+            var pagedResult = PagedResult<InvoiceListDto>.From(gridRequest, dtos, totalCount);
+            pagedResult.SearchTerm = searchTerm;
 
             ViewBag.SearchTerm = searchTerm;
             ViewBag.StatusFilter = statusFilter;

src/PowderCoating.Web/Controllers/JobTemplatesController.cs

@@ -159,6 +159,8 @@ public class JobTemplatesController : Controller
                 CatalogItemId = item.CatalogItemId,
                 IsGenericItem = item.IsGenericItem,
                 IsLaborItem = item.IsLaborItem,
+                IsSalesItem = item.IsSalesItem,
+                Sku = item.Sku,
                 ManualUnitPrice = item.ManualUnitPrice,
                 RequiresSandblasting = item.RequiresSandblasting,
                 RequiresMasking = item.RequiresMasking,
@@ -248,6 +250,8 @@ public class JobTemplatesController : Controller
                 catalogItemId = i.CatalogItemId,
                 isGenericItem = i.IsGenericItem,
                 isLaborItem = i.IsLaborItem,
+                isSalesItem = i.IsSalesItem,
+                sku = i.Sku,
                 manualUnitPrice = i.ManualUnitPrice,
                 requiresSandblasting = i.RequiresSandblasting,
                 requiresMasking = i.RequiresMasking,

src/PowderCoating.Web/Controllers/JobsController.cs

@@ -34,6 +34,7 @@ public class JobsController : Controller
     private readonly INotificationService _notificationService;
     private readonly ISubscriptionService _subscriptionService;
     private readonly IPricingCalculationService _pricingService;
+    private readonly IJobItemAssemblyService _jobItemAssemblyService;
     private readonly IHubContext<NotificationHub> _hub;
     private readonly IHubContext<ShopHub> _shopHub;
 
@@ -49,6 +50,7 @@ public class JobsController : Controller
         INotificationService notificationService,
         ISubscriptionService subscriptionService,
         IPricingCalculationService pricingService,
+        IJobItemAssemblyService jobItemAssemblyService,
         IHubContext<NotificationHub> hub,
         IHubContext<ShopHub> shopHub)
     {
@@ -63,6 +65,7 @@ public class JobsController : Controller
         _notificationService = notificationService;
         _subscriptionService = subscriptionService;
         _pricingService = pricingService;
+        _jobItemAssemblyService = jobItemAssemblyService;
         _hub = hub;
         _shopHub = shopHub;
     }
@@ -185,14 +188,9 @@ public class JobsController : Controller
                           .Contains(tagLower)).ToList();
             }
 
-            // Create paged result
-            var pagedResult = new PagedResult<JobListDto>
-            {
-                Items = jobDtos,
-                PageNumber = gridRequest.PageNumber,
-                PageSize = gridRequest.PageSize,
-                TotalCount = string.IsNullOrWhiteSpace(tagFilter) ? totalCount : jobDtos.Count
-            };
+            var pagedResult = PagedResult<JobListDto>.From(
+                gridRequest, jobDtos,
+                string.IsNullOrWhiteSpace(tagFilter) ? totalCount : jobDtos.Count);
 
             // Set ViewBag for sorting
             ViewBag.SearchTerm = searchTerm;
@@ -1026,8 +1024,8 @@ public class JobsController : Controller
                         catalogItemId = i.CatalogItemId,
                         isGenericItem = i.IsGenericItem,
                         isLaborItem = i.IsLaborItem,
-                        isSalesItem = false, // JobTemplateItem doesn't have IsSalesItem — default false
-                        sku = (string?)null,
+                        isSalesItem = i.IsSalesItem,
+                        sku = i.Sku,
                         manualUnitPrice = i.ManualUnitPrice,
                         requiresSandblasting = i.RequiresSandblasting,
                         requiresMasking = i.RequiresMasking,
@@ -1147,82 +1145,20 @@ public class JobsController : Controller
                 {
                     var itemPricing = await _pricingService.CalculateQuoteItemPriceAsync(
                         itemDto, companyId, null);
-
-                    var jobItem = new JobItem
-                    {
-                        JobId               = job.Id,
-                        Description         = itemDto.Description,
-                        Quantity            = itemDto.Quantity,
-                        SurfaceAreaSqFt     = itemDto.SurfaceAreaSqFt,
-                        EstimatedMinutes    = itemDto.EstimatedMinutes,
-                        CatalogItemId       = itemDto.CatalogItemId,
-                        IsGenericItem       = itemDto.IsGenericItem,
-                        IsLaborItem         = itemDto.IsLaborItem,
-                        IsSalesItem         = itemDto.IsSalesItem,
-                        Sku                 = itemDto.Sku,
-                        ManualUnitPrice     = itemDto.ManualUnitPrice,
-                        PowderCostOverride  = itemDto.PowderCostOverride,
-                        RequiresSandblasting = itemDto.RequiresSandblasting,
-                        RequiresMasking     = itemDto.RequiresMasking,
-                        Notes               = itemDto.Notes,
-                        IncludePrepCost     = itemDto.IncludePrepCost,
-                        Complexity          = itemDto.Complexity,
-                        UnitPrice           = itemPricing.UnitPrice,
-                        TotalPrice          = itemPricing.TotalPrice,
-                        LaborCost           = itemPricing.TotalPrice * 0.4m,
-                        CompanyId           = companyId,
-                        CreatedAt           = DateTime.UtcNow
-                    };
+                    var createdAtUtc = DateTime.UtcNow;
+                    var jobItem = _jobItemAssemblyService.CreateJobItem(itemDto, job.Id, companyId, itemPricing, createdAtUtc);
 
                     await _unitOfWork.JobItems.AddAsync(jobItem);
                     await _unitOfWork.SaveChangesAsync();
 
-                    if (itemDto.Coats?.Any() == true)
+                    foreach (var coat in _jobItemAssemblyService.CreateJobItemCoats(itemDto, jobItem.Id, companyId, createdAtUtc))
                     {
-                        foreach (var coatDto in itemDto.Coats.OrderBy(c => c.Sequence))
-                        {
-                            decimal? powderToOrder = coatDto.PowderToOrder;
-                            if ((powderToOrder == null || powderToOrder == 0) && itemDto.SurfaceAreaSqFt > 0)
-                            {
-                                var cov = coatDto.CoverageSqFtPerLb > 0 ? coatDto.CoverageSqFtPerLb : 30m;
-                                var eff = coatDto.TransferEfficiency > 0 ? coatDto.TransferEfficiency / 100m : 0.65m;
-                                powderToOrder = Math.Round((itemDto.SurfaceAreaSqFt * itemDto.Quantity) / (cov * eff), 2);
-                            }
-                            await _unitOfWork.JobItemCoats.AddAsync(new JobItemCoat
-                            {
-                                JobItemId          = jobItem.Id,
-                                CoatName           = coatDto.CoatName,
-                                Sequence           = coatDto.Sequence,
-                                InventoryItemId    = coatDto.InventoryItemId,
-                                ColorName          = coatDto.ColorName,
-                                VendorId           = coatDto.VendorId,
-                                ColorCode          = coatDto.ColorCode,
-                                Finish             = coatDto.Finish,
-                                CoverageSqFtPerLb  = coatDto.CoverageSqFtPerLb,
-                                TransferEfficiency = coatDto.TransferEfficiency,
-                                PowderCostPerLb    = coatDto.PowderCostPerLb,
-                                PowderToOrder      = powderToOrder,
-                                Notes              = coatDto.Notes,
-                                CompanyId          = companyId,
-                                CreatedAt          = DateTime.UtcNow
-                            });
-                        }
+                        await _unitOfWork.JobItemCoats.AddAsync(coat);
                     }
 
-                    if (itemDto.PrepServices?.Any() == true)
+                    foreach (var prepService in _jobItemAssemblyService.CreateJobItemPrepServices(itemDto, jobItem.Id, companyId, createdAtUtc))
                     {
-                        foreach (var psDto in itemDto.PrepServices)
-                        {
-                            await _unitOfWork.JobItemPrepServices.AddAsync(new JobItemPrepService
-                            {
-                                JobItemId        = jobItem.Id,
-                                PrepServiceId    = psDto.PrepServiceId,
-                                EstimatedMinutes = psDto.EstimatedMinutes,
-                                BlastSetupId     = psDto.BlastSetupId,
-                                CompanyId        = companyId,
-                                CreatedAt        = DateTime.UtcNow
-                            });
-                        }
+                        await _unitOfWork.JobItemPrepServices.AddAsync(prepService);
                     }
                 }
 
@@ -1416,79 +1352,20 @@ public class JobsController : Controller
             {
                 var itemPricing = await _pricingService.CalculateQuoteItemPriceAsync(
                     itemDto, companyId, null);
-
-                var jobItem = new JobItem
-                {
-                    JobId               = id,
-                    Description         = itemDto.Description,
-                    Quantity            = itemDto.Quantity,
-                    SurfaceAreaSqFt     = itemDto.SurfaceAreaSqFt,
-                    EstimatedMinutes    = itemDto.EstimatedMinutes,
-                    CatalogItemId       = itemDto.CatalogItemId,
-                    IsGenericItem       = itemDto.IsGenericItem,
-                    IsLaborItem         = itemDto.IsLaborItem,
-                    ManualUnitPrice     = itemDto.ManualUnitPrice,
-                    PowderCostOverride  = itemDto.PowderCostOverride,
-                    RequiresSandblasting = itemDto.RequiresSandblasting,
-                    RequiresMasking     = itemDto.RequiresMasking,
-                    Notes               = itemDto.Notes,
-                    IncludePrepCost     = itemDto.IncludePrepCost,
-                    Complexity          = itemDto.Complexity,
-                    UnitPrice           = itemPricing.UnitPrice,
-                    TotalPrice          = itemPricing.TotalPrice,
-                    LaborCost           = itemPricing.TotalPrice * 0.4m,
-                    CompanyId           = companyId,
-                    CreatedAt           = DateTime.UtcNow
-                };
+                var createdAtUtc = DateTime.UtcNow;
+                var jobItem = _jobItemAssemblyService.CreateJobItem(itemDto, id, companyId, itemPricing, createdAtUtc);
 
                 await _unitOfWork.JobItems.AddAsync(jobItem);
                 await _unitOfWork.SaveChangesAsync();
 
-                if (itemDto.Coats?.Any() == true)
+                foreach (var coat in _jobItemAssemblyService.CreateJobItemCoats(itemDto, jobItem.Id, companyId, createdAtUtc))
                 {
-                    foreach (var coatDto in itemDto.Coats.OrderBy(c => c.Sequence))
-                    {
-                        decimal? powderToOrder = coatDto.PowderToOrder;
-                        if ((powderToOrder == null || powderToOrder == 0) && itemDto.SurfaceAreaSqFt > 0)
-                        {
-                            var cov = coatDto.CoverageSqFtPerLb > 0 ? coatDto.CoverageSqFtPerLb : 30m;
-                            var eff = coatDto.TransferEfficiency > 0 ? coatDto.TransferEfficiency / 100m : 0.65m;
-                            powderToOrder = Math.Round((itemDto.SurfaceAreaSqFt * itemDto.Quantity) / (cov * eff), 2);
-                        }
-                        await _unitOfWork.JobItemCoats.AddAsync(new JobItemCoat
-                        {
-                            JobItemId          = jobItem.Id,
-                            CoatName           = coatDto.CoatName,
-                            Sequence           = coatDto.Sequence,
-                            InventoryItemId    = coatDto.InventoryItemId,
-                            ColorName          = coatDto.ColorName,
-                            VendorId           = coatDto.VendorId,
-                            ColorCode          = coatDto.ColorCode,
-                            Finish             = coatDto.Finish,
-                            CoverageSqFtPerLb  = coatDto.CoverageSqFtPerLb,
-                            TransferEfficiency = coatDto.TransferEfficiency,
-                            PowderCostPerLb    = coatDto.PowderCostPerLb,
-                            PowderToOrder      = powderToOrder,
-                            Notes              = coatDto.Notes,
-                            CompanyId          = companyId,
-                            CreatedAt          = DateTime.UtcNow
-                        });
-                    }
+                    await _unitOfWork.JobItemCoats.AddAsync(coat);
                 }
 
-                if (itemDto.PrepServices?.Any() == true)
+                foreach (var prepService in _jobItemAssemblyService.CreateJobItemPrepServices(itemDto, jobItem.Id, companyId, createdAtUtc))
                 {
-                    foreach (var psDto in itemDto.PrepServices)
-                    {
-                        await _unitOfWork.JobItemPrepServices.AddAsync(new JobItemPrepService
-                        {
-                            JobItemId        = jobItem.Id,
-                            PrepServiceId    = psDto.PrepServiceId,
-                            EstimatedMinutes = psDto.EstimatedMinutes,
-                            CompanyId        = companyId,
-                            CreatedAt        = DateTime.UtcNow
-                        });
-                    }
+                    await _unitOfWork.JobItemPrepServices.AddAsync(prepService);
                 }
             }
 
@@ -3130,86 +3007,20 @@ public class JobsController : Controller
             {
                 var itemPricing = await _pricingService.CalculateQuoteItemPriceAsync(
                     itemDto, currentUser.CompanyId, null);
-
-                var jobItem = new JobItem
-                {
-                    JobId               = job.Id,
-                    Description         = itemDto.Description,
-                    Quantity            = itemDto.Quantity,
-                    SurfaceAreaSqFt     = itemDto.SurfaceAreaSqFt,
-                    EstimatedMinutes    = itemDto.EstimatedMinutes,
-                    CatalogItemId       = itemDto.CatalogItemId,
-                    IsGenericItem       = itemDto.IsGenericItem,
-                    IsLaborItem         = itemDto.IsLaborItem,
-                    ManualUnitPrice     = itemDto.ManualUnitPrice,
-                    PowderCostOverride  = itemDto.PowderCostOverride,
-                    RequiresSandblasting = itemDto.RequiresSandblasting,
-                    RequiresMasking     = itemDto.RequiresMasking,
-                    Notes               = itemDto.Notes,
-                    IncludePrepCost     = itemDto.IncludePrepCost,
-                    Complexity          = itemDto.Complexity,
-                    UnitPrice           = itemPricing.UnitPrice,
-                    TotalPrice          = itemPricing.TotalPrice,
-                    LaborCost           = itemPricing.TotalPrice * 0.4m,
-                    CompanyId           = currentUser.CompanyId,
-                    CreatedAt           = DateTime.UtcNow
-                };
+                var createdAtUtc = DateTime.UtcNow;
+                var jobItem = _jobItemAssemblyService.CreateJobItem(itemDto, job.Id, currentUser.CompanyId, itemPricing, createdAtUtc);
 
                 await _unitOfWork.JobItems.AddAsync(jobItem);
                 await _unitOfWork.SaveChangesAsync();
 
-                // Coats
-                if (itemDto.Coats?.Any() == true)
+                foreach (var coat in _jobItemAssemblyService.CreateJobItemCoats(itemDto, jobItem.Id, currentUser.CompanyId, createdAtUtc))
                 {
-                    foreach (var coatDto in itemDto.Coats.OrderBy(c => c.Sequence))
-                    {
-                        // Calculate PowderToOrder if not supplied by the client
-                        decimal? powderToOrder = coatDto.PowderToOrder;
-                        if ((powderToOrder == null || powderToOrder == 0) && itemDto.SurfaceAreaSqFt > 0)
-                        {
-                            var cov = coatDto.CoverageSqFtPerLb > 0 ? coatDto.CoverageSqFtPerLb : 30m;
-                            var eff = coatDto.TransferEfficiency > 0 ? coatDto.TransferEfficiency / 100m : 0.65m;
-                            powderToOrder = Math.Round((itemDto.SurfaceAreaSqFt * itemDto.Quantity) / (cov * eff), 2);
-                        }
-
-                        var coat = new JobItemCoat
-                        {
-                            JobItemId          = jobItem.Id,
-                            CoatName           = coatDto.CoatName,
-                            Sequence           = coatDto.Sequence,
-                            InventoryItemId    = coatDto.InventoryItemId,
-                            ColorName          = coatDto.ColorName,
-                            VendorId           = coatDto.VendorId,
-                            ColorCode          = coatDto.ColorCode,
-                            Finish             = coatDto.Finish,
-                            CoverageSqFtPerLb  = coatDto.CoverageSqFtPerLb,
-                            TransferEfficiency = coatDto.TransferEfficiency,
-                            PowderCostPerLb    = coatDto.PowderCostPerLb,
-                            PowderToOrder      = powderToOrder,
-                            Notes              = coatDto.Notes,
-                            CompanyId          = currentUser.CompanyId,
-                            CreatedAt          = DateTime.UtcNow
-                        };
-                        await _unitOfWork.JobItemCoats.AddAsync(coat);
-                    }
+                    await _unitOfWork.JobItemCoats.AddAsync(coat);
                 }
 
-                // Prep services
-                if (itemDto.PrepServices?.Any() == true)
+                foreach (var prepService in _jobItemAssemblyService.CreateJobItemPrepServices(itemDto, jobItem.Id, currentUser.CompanyId, createdAtUtc))
                 {
-                    foreach (var psDto in itemDto.PrepServices)
-                    {
-                        var ps = new JobItemPrepService
-                        {
-                            JobItemId        = jobItem.Id,
-                            PrepServiceId    = psDto.PrepServiceId,
-                            EstimatedMinutes = psDto.EstimatedMinutes,
-                            BlastSetupId     = psDto.BlastSetupId,
-                            CompanyId        = currentUser.CompanyId,
-                            CreatedAt        = DateTime.UtcNow
-                        };
-                        await _unitOfWork.JobItemPrepServices.AddAsync(ps);
-                    }
+                    await _unitOfWork.JobItemPrepServices.AddAsync(prepService);
                 }
             }
 
@@ -3638,60 +3449,20 @@ public class JobsController : Controller
 
             foreach (var item in itemsToCopy)
             {
-                var newItem = new JobItem
-                {
-                    JobId = reworkJob.Id,
-                    Description = item.Description,
-                    Quantity = item.Quantity,
-                    SurfaceAreaSqFt = item.SurfaceAreaSqFt,
-                    CatalogItemId = item.CatalogItemId,
-                    IsGenericItem = item.IsGenericItem,
-                    IsLaborItem = item.IsLaborItem,
-                    ManualUnitPrice = item.ManualUnitPrice,
-                    RequiresSandblasting = item.RequiresSandblasting,
-                    RequiresMasking = item.RequiresMasking,
-                    IncludePrepCost = item.IncludePrepCost,
-                    EstimatedMinutes = item.EstimatedMinutes,
-                    Complexity = item.Complexity,
-                    Notes = item.Notes,
-                    CompanyId = companyId,
-                    CreatedAt = DateTime.UtcNow
-                };
+                var createdAtUtc = DateTime.UtcNow;
+                var newItem = _jobItemAssemblyService.CreateJobItem(item, reworkJob.Id, companyId, createdAtUtc);
 
                 await _unitOfWork.JobItems.AddAsync(newItem);
                 await _unitOfWork.CompleteAsync();
 
-                foreach (var coat in item.Coats.OrderBy(c => c.Sequence))
+                foreach (var coat in _jobItemAssemblyService.CreateJobItemCoats(item, newItem.Id, companyId, createdAtUtc))
                 {
-                    await _unitOfWork.JobItemCoats.AddAsync(new JobItemCoat
-                    {
-                        JobItemId = newItem.Id,
-                        CoatName = coat.CoatName,
-                        Sequence = coat.Sequence,
-                        InventoryItemId = coat.InventoryItemId,
-                        ColorName = coat.ColorName,
-                        VendorId = coat.VendorId,
-                        ColorCode = coat.ColorCode,
-                        Finish = coat.Finish,
-                        CoverageSqFtPerLb = coat.CoverageSqFtPerLb,
-                        TransferEfficiency = coat.TransferEfficiency,
-                        PowderCostPerLb = coat.PowderCostPerLb,
-                        Notes = coat.Notes,
-                        CompanyId = companyId,
-                        CreatedAt = DateTime.UtcNow
-                    });
+                    await _unitOfWork.JobItemCoats.AddAsync(coat);
                 }
 
-                foreach (var prep in item.PrepServices)
+                foreach (var prepService in _jobItemAssemblyService.CreateJobItemPrepServices(item, newItem.Id, companyId, createdAtUtc))
                 {
-                    await _unitOfWork.JobItemPrepServices.AddAsync(new JobItemPrepService
-                    {
-                        JobItemId = newItem.Id,
-                        PrepServiceId = prep.PrepServiceId,
-                        EstimatedMinutes = prep.EstimatedMinutes,
-                        CompanyId = companyId,
-                        CreatedAt = DateTime.UtcNow
-                    });
+                    await _unitOfWork.JobItemPrepServices.AddAsync(prepService);
                 }
             }
 
@@ -3910,95 +3681,31 @@ public class JobsController : Controller
 
             foreach (var quoteItem in fullItems.Where(qi => !qi.IsDeleted))
             {
-                var firstCoat = quoteItem.Coats?.OrderBy(c => c.Sequence).FirstOrDefault();
-
-                var jobItem = new JobItem
-                {
-                    JobId = id,
-                    Description = quoteItem.Description,
-                    Quantity = quoteItem.Quantity,
-                    ColorName = firstCoat?.ColorName,
-                    ColorCode = firstCoat?.ColorCode,
-                    Finish = firstCoat?.Finish,
-                    SurfaceArea = quoteItem.SurfaceAreaSqFt,
-                    SurfaceAreaSqFt = quoteItem.SurfaceAreaSqFt,
-                    CatalogItemId = quoteItem.CatalogItemId,
-                    IsGenericItem = quoteItem.IsGenericItem,
-                    IsLaborItem = quoteItem.IsLaborItem,
-                    IsSalesItem = quoteItem.IsSalesItem,
-                    Sku = quoteItem.Sku,
-                    ManualUnitPrice = quoteItem.ManualUnitPrice,
-                    PowderCostOverride = quoteItem.PowderCostOverride,
-                    UnitPrice = quoteItem.UnitPrice,
-                    TotalPrice = quoteItem.TotalPrice,
-                    LaborCost = quoteItem.TotalPrice * 0.4m,
-                    RequiresSandblasting = quoteItem.RequiresSandblasting,
-                    RequiresMasking = quoteItem.RequiresMasking,
-                    EstimatedMinutes = quoteItem.EstimatedMinutes,
-                    Notes = quoteItem.Notes,
-                    Complexity = quoteItem.Complexity,
-                    AiTags = quoteItem.AiTags,
-                    AiPredictionId = quoteItem.AiPredictionId,
-                    IncludePrepCost = !quoteItem.CatalogItemId.HasValue,
-                    CompanyId = job.CompanyId,
-                    CreatedAt = DateTime.UtcNow
-                };
+                var createdAtUtc = DateTime.UtcNow;
+                var jobItem = _jobItemAssemblyService.CreateJobItem(quoteItem, id, job.CompanyId, createdAtUtc);
 
                 await _unitOfWork.JobItems.AddAsync(jobItem);
                 await _unitOfWork.SaveChangesAsync();
 
-                if (quoteItem.Coats != null)
+                foreach (var coat in _jobItemAssemblyService.CreateJobItemCoats(quoteItem, jobItem.Id, job.CompanyId, createdAtUtc))
                 {
-                    foreach (var quoteCoat in quoteItem.Coats.OrderBy(c => c.Sequence))
-                    {
-                        string colorName = quoteCoat.ColorName;
-                        string colorCode = quoteCoat.ColorCode;
-                        string finish = quoteCoat.Finish;
+                    await _unitOfWork.JobItemCoats.AddAsync(coat);
+                }
 
-                        if (quoteCoat.InventoryItemId.HasValue && quoteCoat.InventoryItem != null)
-                        {
-                            colorName = quoteCoat.InventoryItem.Name;
-                            colorCode = quoteCoat.InventoryItem.ColorCode;
-                            finish = quoteCoat.InventoryItem.Finish;
-                        }
-
-                        var cov = quoteCoat.CoverageSqFtPerLb > 0 ? quoteCoat.CoverageSqFtPerLb : 30m;
-                        var eff = quoteCoat.TransferEfficiency > 0 ? quoteCoat.TransferEfficiency / 100m : 0.65m;
-                        var powderToOrder = (quoteCoat.PowderToOrder > 0)
-                            ? quoteCoat.PowderToOrder
-                            : (quoteItem.SurfaceAreaSqFt > 0
-                                ? Math.Round((quoteItem.SurfaceAreaSqFt * quoteItem.Quantity) / (cov * eff), 2)
-                                : (decimal?)null);
-
-                        await _unitOfWork.JobItemCoats.AddAsync(new JobItemCoat
-                        {
-                            JobItemId = jobItem.Id,
-                            CoatName = quoteCoat.CoatName,
-                            Sequence = quoteCoat.Sequence,
-                            InventoryItemId = quoteCoat.InventoryItemId,
-                            ColorName = colorName,
-                            VendorId = quoteCoat.VendorId,
-                            ColorCode = colorCode,
-                            Finish = finish,
-                            CoverageSqFtPerLb = quoteCoat.CoverageSqFtPerLb,
-                            TransferEfficiency = quoteCoat.TransferEfficiency,
-                            PowderCostPerLb = quoteCoat.PowderCostPerLb,
-                            PowderToOrder = powderToOrder,
-                            Notes = quoteCoat.Notes,
-                            CompanyId = job.CompanyId,
-                            CreatedAt = DateTime.UtcNow
-                        });
-                    }
+                foreach (var prepService in _jobItemAssemblyService.CreateJobItemPrepServices(quoteItem, jobItem.Id, job.CompanyId, createdAtUtc))
+                {
+                    await _unitOfWork.JobItemPrepServices.AddAsync(prepService);
                 }
             }
 
             await _unitOfWork.SaveChangesAsync();
 
-            // Aggregate prep services from all quote items and copy to job
-            var quoteItemIds = fullItems.Select(qi => qi.Id).ToList();
-            var itemPrepServices = await _unitOfWork.QuoteItemPrepServices.FindAsync(
-                ps => quoteItemIds.Contains(ps.QuoteItemId));
-            foreach (var prepServiceId in itemPrepServices.Select(ps => ps.PrepServiceId).Distinct())
+            // Aggregate prep services from the fully-loaded quote items and copy to job
+            foreach (var prepServiceId in fullItems
+                .SelectMany(qi => qi.PrepServices)
+                .Where(ps => !ps.IsDeleted)
+                .Select(ps => ps.PrepServiceId)
+                .Distinct())
             {
                 await _unitOfWork.JobPrepServices.AddAsync(new JobPrepService
                 {

src/PowderCoating.Web/Controllers/MaintenanceController.cs

@@ -156,14 +156,7 @@ public class MaintenanceController : Controller
             // Map to DTOs
             var maintenanceDtos = _mapper.Map<List<MaintenanceListDto>>(items);
 
-            // Create paged result
-            var pagedResult = new PagedResult<MaintenanceListDto>
-            {
-                Items = maintenanceDtos,
-                PageNumber = gridRequest.PageNumber,
-                PageSize = gridRequest.PageSize,
-                TotalCount = totalCount
-            };
+            var pagedResult = PagedResult<MaintenanceListDto>.From(gridRequest, maintenanceDtos, totalCount);
 
             // Get equipment name if filtering by equipment
             if (equipmentId.HasValue)

src/PowderCoating.Web/Controllers/PlatformUsersController.cs

@@ -170,14 +170,7 @@ public class PlatformUsersController : Controller
                 totalCount = userDtos.Count; // Recalculate total for SuperAdmins
             }
 
-            // Create paged result
-            var pagedResult = new PagedResult<PlatformUserListDto>
-            {
-                Items = userDtos,
-                PageNumber = gridRequest.PageNumber,
-                PageSize = gridRequest.PageSize,
-                TotalCount = totalCount
-            };
+            var pagedResult = PagedResult<PlatformUserListDto>.From(gridRequest, userDtos, totalCount);
 
             // Set ViewBag for sorting and filters
             ViewBag.CurrentFilter = filter;

src/PowderCoating.Web/Controllers/QuotesController.cs

@@ -33,6 +33,8 @@ public class QuotesController : Controller
     private readonly ILookupCacheService _lookupCache;
     private readonly INotificationService _notificationService;
     private readonly ISubscriptionService _subscriptionService;
+    private readonly IJobItemAssemblyService _jobItemAssemblyService;
+    private readonly IQuotePricingAssemblyService _quotePricingAssemblyService;
     private readonly IConfiguration _configuration;
     private readonly IPlatformSettingsService _platformSettings;
     private readonly IQuotePhotoService _photoService;
@@ -55,6 +57,8 @@ public class QuotesController : Controller
         ILookupCacheService lookupCache,
         INotificationService notificationService,
         ISubscriptionService subscriptionService,
+        IJobItemAssemblyService jobItemAssemblyService,
+        IQuotePricingAssemblyService quotePricingAssemblyService,
         IConfiguration configuration,
         IPlatformSettingsService platformSettings,
         IQuotePhotoService photoService,
@@ -76,6 +80,8 @@ public class QuotesController : Controller
         _lookupCache = lookupCache;
         _notificationService = notificationService;
         _subscriptionService = subscriptionService;
+        _jobItemAssemblyService = jobItemAssemblyService;
+        _quotePricingAssemblyService = quotePricingAssemblyService;
         _configuration = configuration;
         _platformSettings = platformSettings;
         _photoService = photoService;
@@ -198,14 +204,9 @@ public class QuotesController : Controller
                           .Contains(tagLower)).ToList();
             }
 
-            // Create paged result
-            var pagedResult = new PagedResult<QuoteListDto>
-            {
-                Items = quoteDtos,
-                PageNumber = gridRequest.PageNumber,
-                PageSize = gridRequest.PageSize,
-                TotalCount = string.IsNullOrWhiteSpace(tagFilter) ? totalCount : quoteDtos.Count
-            };
+            var pagedResult = PagedResult<QuoteListDto>.From(
+                gridRequest, quoteDtos,
+                string.IsNullOrWhiteSpace(tagFilter) ? totalCount : quoteDtos.Count);
 
             // Set ViewBag for sorting and filters
             ViewBag.SearchTerm = searchTerm;
@@ -914,140 +915,19 @@ public class QuotesController : Controller
             }
 
             // Set calculated pricing — snapshot at save time; never recalculate on load
-            quote.MaterialCosts       = pricingResult.MaterialCosts;
-            quote.LaborCosts          = pricingResult.LaborCosts;
-            quote.EquipmentCosts      = pricingResult.EquipmentCosts;
-            quote.ItemsSubtotal       = pricingResult.ItemsSubtotal;
-            quote.OvenBatchCost       = pricingResult.OvenBatchCost;
-            quote.ShopSuppliesAmount  = pricingResult.ShopSuppliesAmount;
-            quote.ShopSuppliesPercent = pricingResult.ShopSuppliesPercent;
-            quote.OverheadAmount      = pricingResult.OverheadCosts;
-            quote.OverheadPercent     = pricingResult.OverheadPercent;
-            quote.ProfitMargin        = pricingResult.ProfitMargin;
-            quote.ProfitPercent       = pricingResult.ProfitPercent;
-            quote.SubTotal            = pricingResult.SubtotalBeforeDiscount;
-            quote.DiscountPercent     = pricingResult.DiscountPercent;
-            quote.DiscountAmount      = pricingResult.DiscountAmount;
-            quote.RushFee             = pricingResult.RushFee;
-            quote.TaxAmount           = pricingResult.TaxAmount;
-            quote.Total               = pricingResult.Total;
+            _quotePricingAssemblyService.ApplyPricingSnapshot(quote, pricingResult);
 
             // Add quote
             await _unitOfWork.Quotes.AddAsync(quote);
             await _unitOfWork.CompleteAsync();
 
             // Create quote items with calculated pricing
-            var itemResults = new List<QuoteItem>();
-            foreach (var itemDto in dto.QuoteItems)
-            {
-                var item = _mapper.Map<QuoteItem>(itemDto);
-                item.QuoteId = quote.Id;
-                item.CompanyId = currentUser.CompanyId;
-
-                // AI items: use stored price (AI estimate or user override) — skip the pricing engine
-                if (itemDto.IsAiItem && itemDto.ManualUnitPrice.HasValue && itemDto.ManualUnitPrice.Value > 0)
-                {
-                    item.UnitPrice = itemDto.ManualUnitPrice.Value;
-                    item.TotalPrice = itemDto.ManualUnitPrice.Value * itemDto.Quantity;
-                    _logger.LogInformation("AI item price: UnitPrice={Unit}, TotalPrice={Total}", item.UnitPrice, item.TotalPrice);
-                }
-                // Sales/merchandise items: use the manually entered price directly — no coating calculation
-                else if (itemDto.IsSalesItem && itemDto.ManualUnitPrice.HasValue)
-                {
-                    item.UnitPrice = itemDto.ManualUnitPrice.Value;
-                    item.TotalPrice = itemDto.ManualUnitPrice.Value * itemDto.Quantity;
-                    _logger.LogInformation("Sales item price: UnitPrice={Unit}, TotalPrice={Total}", item.UnitPrice, item.TotalPrice);
-                }
-                // Catalog items: if they have coats, calculate with coats; otherwise use default price
-                else if (itemDto.CatalogItemId.HasValue)
-                {
-                    // If catalog item has coats, calculate the full price with coat costs
-                    if (itemDto.Coats != null && itemDto.Coats.Any())
-                    {
-                        _logger.LogInformation("Calculating catalog item with {CoatCount} coats", itemDto.Coats.Count);
-                        var itemPricing = await _pricingService.CalculateQuoteItemPriceAsync(itemDto, currentUser.CompanyId, ovenRateOverride);
-                        item.UnitPrice         = itemPricing.UnitPrice;
-                        item.TotalPrice        = itemPricing.TotalPrice;
-                        item.ItemMaterialCost  = itemPricing.MaterialCost;
-                        item.ItemLaborCost     = itemPricing.LaborCost;
-                        item.ItemEquipmentCost = itemPricing.EquipmentCost;
-                        _logger.LogInformation("Set prices: UnitPrice={Unit}, TotalPrice={Total}", item.UnitPrice, item.TotalPrice);
-                    }
-                    else
-                    {
-                        // No coats - use catalog default price
-                        var catalogItem = await _unitOfWork.CatalogItems.GetByIdAsync(itemDto.CatalogItemId.Value);
-                        if (catalogItem != null)
-                        {
-                            item.UnitPrice = catalogItem.DefaultPrice;
-                            item.TotalPrice = catalogItem.DefaultPrice * itemDto.Quantity;
-                            _logger.LogInformation("Catalog item no coats: UnitPrice={Unit}, TotalPrice={Total}", item.UnitPrice, item.TotalPrice);
-                        }
-                    }
-                }
-                else
-                {
-                    // Calculated items use the pricing service
-                    _logger.LogInformation("Calculating custom item with {CoatCount} coats", itemDto.Coats?.Count ?? 0);
-                    var itemPricing = await _pricingService.CalculateQuoteItemPriceAsync(itemDto, currentUser.CompanyId, ovenRateOverride);
-                    item.UnitPrice         = itemPricing.UnitPrice;
-                    item.TotalPrice        = itemPricing.TotalPrice;
-                    item.ItemMaterialCost  = itemPricing.MaterialCost;
-                    item.ItemLaborCost     = itemPricing.LaborCost;
-                    item.ItemEquipmentCost = itemPricing.EquipmentCost;
-                    _logger.LogInformation("Set prices: UnitPrice={Unit}, TotalPrice={Total}", item.UnitPrice, item.TotalPrice);
-                }
-
-                // Flag whether the user overrode the AI's estimates before accepting
-                await UpdateAiPredictionOverrideAsync(itemDto, item.UnitPrice);
-
-                // Map coats for this item with calculated costs
-                if (itemDto.Coats != null && itemDto.Coats.Any())
-                {
-                    item.Coats = new List<QuoteItemCoat>();
-                    for (int coatIndex = 0; coatIndex < itemDto.Coats.Count; coatIndex++)
-                    {
-                        var coatDto = itemDto.Coats[coatIndex];
-
-                        // If "Add to inventory as Incoming" was checked on the custom tab,
-                        // create a 0-balance inventory record so QR codes work on the work order.
-                        if (coatDto.AddAsIncoming && coatDto.CatalogItemId.HasValue && !coatDto.InventoryItemId.HasValue)
-                            coatDto.InventoryItemId = await CreateIncomingInventoryItemAsync(coatDto, currentUser.CompanyId);
-
-                        var coat = _mapper.Map<QuoteItemCoat>(coatDto);
-                        coat.CompanyId = currentUser.CompanyId;
-
-                        // Calculate and store the coat costs
-                        var coatPricing = await _pricingService.CalculateCoatPriceAsync(
-                            coatDto,
-                            itemDto.SurfaceAreaSqFt,
-                            itemDto.Quantity,
-                            coatIndex,
-                            itemDto.EstimatedMinutes,
-                            currentUser.CompanyId);
-
-                        coat.CoatMaterialCost = coatPricing.CoatMaterialCost;
-                        coat.CoatLaborCost = coatPricing.CoatLaborCost;
-                        coat.CoatTotalCost = coatPricing.CoatTotalCost;
-
-                        item.Coats.Add(coat);
-                    }
-                }
-
-                // Map per-item prep services
-                if (itemDto.PrepServices != null && itemDto.PrepServices.Any())
-                {
-                    item.PrepServices = new List<QuoteItemPrepService>();
-                    foreach (var psDto in itemDto.PrepServices)
-                    {
-                        var prepService = _mapper.Map<QuoteItemPrepService>(psDto);
-                        prepService.CompanyId = currentUser.CompanyId;
-                        item.PrepServices.Add(prepService);
-                    }
-                }
-
-                itemResults.Add(item);
-            }
+            var itemResults = await _quotePricingAssemblyService.CreateQuoteItemsAsync(
+                dto.QuoteItems,
+                quote.Id,
+                currentUser.CompanyId,
+                ovenRateOverride,
+                DateTime.UtcNow);
 
             foreach (var item in itemResults)
             {
@@ -1444,23 +1324,7 @@ public class QuotesController : Controller
                 quote.ProspectSmsConsentedAt = null;
 
             // Set calculated pricing — snapshot at save time; never recalculate on load
-            quote.MaterialCosts       = pricingResult.MaterialCosts;
-            quote.LaborCosts          = pricingResult.LaborCosts;
-            quote.EquipmentCosts      = pricingResult.EquipmentCosts;
-            quote.ItemsSubtotal       = pricingResult.ItemsSubtotal;
-            quote.OvenBatchCost       = pricingResult.OvenBatchCost;
-            quote.ShopSuppliesAmount  = pricingResult.ShopSuppliesAmount;
-            quote.ShopSuppliesPercent = pricingResult.ShopSuppliesPercent;
-            quote.OverheadAmount      = pricingResult.OverheadCosts;
-            quote.OverheadPercent     = pricingResult.OverheadPercent;
-            quote.ProfitMargin        = pricingResult.ProfitMargin;
-            quote.ProfitPercent       = pricingResult.ProfitPercent;
-            quote.SubTotal            = pricingResult.SubtotalBeforeDiscount;
-            quote.DiscountPercent     = pricingResult.DiscountPercent;
-            quote.DiscountAmount      = pricingResult.DiscountAmount;
-            quote.RushFee             = pricingResult.RushFee;
-            quote.TaxAmount           = pricingResult.TaxAmount;
-            quote.Total               = pricingResult.Total;
+            _quotePricingAssemblyService.ApplyPricingSnapshot(quote, pricingResult);
 
             // Track changes
             var changeHistories = new List<QuoteChangeHistory>();
@@ -1704,121 +1568,25 @@ public class QuotesController : Controller
 
             // Create new quote items with calculated pricing
             var newItemsForComparison = new List<(string Description, decimal Quantity, decimal UnitPrice, decimal TotalPrice, bool Sandblasting, bool Masking, decimal? SurfaceArea, string? Notes)>();
-            foreach (var itemDto in dto.QuoteItems)
+            var assembledItems = await _quotePricingAssemblyService.CreateQuoteItemsAsync(
+                dto.QuoteItems,
+                quote.Id,
+                currentUser.CompanyId,
+                ovenRateOverride,
+                DateTime.UtcNow);
+
+            foreach (var item in assembledItems)
             {
-                var item = _mapper.Map<QuoteItem>(itemDto);
-                item.QuoteId = quote.Id;
-                item.CompanyId = currentUser.CompanyId;
-
-                _logger.LogInformation("Creating item: {Desc}, Sandblasting={Sand}, Masking={Mask} (from DTO: Sand={DtoSand}, Mask={DtoMask})",
-                    item.Description, item.RequiresSandblasting, item.RequiresMasking,
-                    itemDto.RequiresSandblasting, itemDto.RequiresMasking);
-
-                // AI items: use stored price (AI estimate or user override) — skip the pricing engine
-                if (itemDto.IsAiItem && itemDto.ManualUnitPrice.HasValue && itemDto.ManualUnitPrice.Value > 0)
-                {
-                    item.UnitPrice = itemDto.ManualUnitPrice.Value;
-                    item.TotalPrice = itemDto.ManualUnitPrice.Value * itemDto.Quantity;
-                    _logger.LogInformation("AI item price: UnitPrice={Unit}, TotalPrice={Total}", item.UnitPrice, item.TotalPrice);
-                }
-                // Sales/merchandise items: use the manually entered price directly — no coating calculation
-                else if (itemDto.IsSalesItem && itemDto.ManualUnitPrice.HasValue)
-                {
-                    item.UnitPrice = itemDto.ManualUnitPrice.Value;
-                    item.TotalPrice = itemDto.ManualUnitPrice.Value * itemDto.Quantity;
-                    _logger.LogInformation("Sales item price: UnitPrice={Unit}, TotalPrice={Total}", item.UnitPrice, item.TotalPrice);
-                }
-                // Catalog items: if they have coats, calculate with coats; otherwise use default price
-                else if (itemDto.CatalogItemId.HasValue)
-                {
-                    // If catalog item has coats, calculate the full price with coat costs
-                    if (itemDto.Coats != null && itemDto.Coats.Any())
-                    {
-                        _logger.LogInformation("Calculating catalog item with {CoatCount} coats", itemDto.Coats.Count);
-                        var itemPricing = await _pricingService.CalculateQuoteItemPriceAsync(itemDto, currentUser.CompanyId, ovenRateOverride);
-                        item.UnitPrice         = itemPricing.UnitPrice;
-                        item.TotalPrice        = itemPricing.TotalPrice;
-                        item.ItemMaterialCost  = itemPricing.MaterialCost;
-                        item.ItemLaborCost     = itemPricing.LaborCost;
-                        item.ItemEquipmentCost = itemPricing.EquipmentCost;
-                        _logger.LogInformation("Set prices: UnitPrice={Unit}, TotalPrice={Total}", item.UnitPrice, item.TotalPrice);
-                    }
-                    else
-                    {
-                        // No coats - use catalog default price
-                        var catalogItem = await _unitOfWork.CatalogItems.GetByIdAsync(itemDto.CatalogItemId.Value);
-                        if (catalogItem != null)
-                        {
-                            item.UnitPrice = catalogItem.DefaultPrice;
-                            item.TotalPrice = catalogItem.DefaultPrice * itemDto.Quantity;
-                            _logger.LogInformation("Catalog item no coats: UnitPrice={Unit}, TotalPrice={Total}", item.UnitPrice, item.TotalPrice);
-                        }
-                    }
-                }
-                else
-                {
-                    // Calculated items use the pricing service
-                    _logger.LogInformation("Calculating custom item with {CoatCount} coats", itemDto.Coats?.Count ?? 0);
-                    var itemPricing = await _pricingService.CalculateQuoteItemPriceAsync(itemDto, currentUser.CompanyId, ovenRateOverride);
-                    item.UnitPrice         = itemPricing.UnitPrice;
-                    item.TotalPrice        = itemPricing.TotalPrice;
-                    item.ItemMaterialCost  = itemPricing.MaterialCost;
-                    item.ItemLaborCost     = itemPricing.LaborCost;
-                    item.ItemEquipmentCost = itemPricing.EquipmentCost;
-                    _logger.LogInformation("Set prices: UnitPrice={Unit}, TotalPrice={Total}", item.UnitPrice, item.TotalPrice);
-                }
-
-                // Flag whether the user overrode the AI's estimates before accepting
-                await UpdateAiPredictionOverrideAsync(itemDto, item.UnitPrice);
+                _logger.LogInformation("Creating item: {Desc}, Sandblasting={Sand}, Masking={Mask}",
+                    item.Description, item.RequiresSandblasting, item.RequiresMasking);
 
                 await _unitOfWork.QuoteItems.AddAsync(item);
 
-                // Map coats for this item with calculated costs
-                if (itemDto.Coats != null && itemDto.Coats.Any())
+                if (item.Coats?.Any() == true)
                 {
-                    item.Coats = new List<QuoteItemCoat>();
-                    for (int coatIndex = 0; coatIndex < itemDto.Coats.Count; coatIndex++)
-                    {
-                        var coatDto = itemDto.Coats[coatIndex];
-
-                        if (coatDto.AddAsIncoming && coatDto.CatalogItemId.HasValue && !coatDto.InventoryItemId.HasValue)
-                            coatDto.InventoryItemId = await CreateIncomingInventoryItemAsync(coatDto, currentUser.CompanyId);
-
-                        var coat = _mapper.Map<QuoteItemCoat>(coatDto);
-                        coat.CompanyId = currentUser.CompanyId;
-
-                        // Calculate and store the coat costs
-                        var coatPricing = await _pricingService.CalculateCoatPriceAsync(
-                            coatDto,
-                            itemDto.SurfaceAreaSqFt,
-                            itemDto.Quantity,
-                            coatIndex,
-                            itemDto.EstimatedMinutes,
-                            currentUser.CompanyId);
-
-                        coat.CoatMaterialCost = coatPricing.CoatMaterialCost;
-                        coat.CoatLaborCost = coatPricing.CoatLaborCost;
-                        coat.CoatTotalCost = coatPricing.CoatTotalCost;
-
-                        item.Coats.Add(coat);
-                    }
-
                     _logger.LogInformation("Added {CoatCount} coats to item {Description}", item.Coats.Count, item.Description);
                 }
 
-                // Map per-item prep services
-                if (itemDto.PrepServices != null && itemDto.PrepServices.Any())
-                {
-                    item.PrepServices = new List<QuoteItemPrepService>();
-                    foreach (var psDto in itemDto.PrepServices)
-                    {
-                        var prepService = _mapper.Map<QuoteItemPrepService>(psDto);
-                        prepService.CompanyId = currentUser.CompanyId;
-                        item.PrepServices.Add(prepService);
-                    }
-                }
-
-                // Track new item for comparison
                 newItemsForComparison.Add((
                     item.Description ?? "",
                     item.Quantity,
@@ -3086,108 +2854,32 @@ public class QuotesController : Controller
         // Create job items from quote items
         foreach (var quoteItem in fullItems.Where(qi => !qi.IsDeleted))
         {
-            // Get first coat's color information if available
-            var firstCoat = quoteItem.Coats?.OrderBy(c => c.Sequence).FirstOrDefault();
-
-            var jobItem = new JobItem
-            {
-                JobId = job.Id,
-                Description = quoteItem.Description,
-                Quantity = quoteItem.Quantity,
-                ColorName = firstCoat?.ColorName,
-                ColorCode = firstCoat?.ColorCode,
-                Finish = firstCoat?.Finish,
-                SurfaceArea = quoteItem.SurfaceAreaSqFt,
-                SurfaceAreaSqFt = quoteItem.SurfaceAreaSqFt,
-                CatalogItemId = quoteItem.CatalogItemId,
-                IsGenericItem = quoteItem.IsGenericItem,
-                IsLaborItem = quoteItem.IsLaborItem,
-                IsSalesItem = quoteItem.IsSalesItem,
-                Sku = quoteItem.Sku,
-                ManualUnitPrice = quoteItem.ManualUnitPrice,
-                PowderCostOverride = quoteItem.PowderCostOverride,
-                UnitPrice = quoteItem.UnitPrice,
-                TotalPrice = quoteItem.TotalPrice,
-                LaborCost = quoteItem.TotalPrice * 0.4m, // Estimated 40% labor cost
-                RequiresSandblasting = quoteItem.RequiresSandblasting,
-                RequiresMasking = quoteItem.RequiresMasking,
-                EstimatedMinutes = quoteItem.EstimatedMinutes,
-                Notes = quoteItem.Notes,
-                Complexity = quoteItem.Complexity,
-                AiTags = quoteItem.AiTags,
-                AiPredictionId = quoteItem.AiPredictionId,  // Share the same prediction record — no duplication
-                // Catalog items are fixed-price — prep services must not add labor cost to them.
-                // Non-catalog items default to true so prep service labor is included in the calculated price.
-                IncludePrepCost = !quoteItem.CatalogItemId.HasValue,
-                CompanyId = quote.CompanyId,
-                CreatedAt = DateTime.UtcNow
-            };
+            var createdAtUtc = DateTime.UtcNow;
+            var jobItem = _jobItemAssemblyService.CreateJobItem(quoteItem, job.Id, quote.CompanyId, createdAtUtc);
 
 
             await _unitOfWork.JobItems.AddAsync(jobItem);
             await _unitOfWork.SaveChangesAsync(); // Save JobItem first to get its ID
 
-            // Create JobItemCoat records for all coats from quote
-            if (quoteItem.Coats != null && quoteItem.Coats.Any())
+            foreach (var coat in _jobItemAssemblyService.CreateJobItemCoats(quoteItem, jobItem.Id, quote.CompanyId, createdAtUtc))
             {
-                foreach (var quoteCoat in quoteItem.Coats.OrderBy(c => c.Sequence))
-                {
-                    // Get color info from inventory item if available, otherwise use coat fields
-                    string colorName = quoteCoat.ColorName;
-                    string colorCode = quoteCoat.ColorCode;
-                    string finish = quoteCoat.Finish;
+                await _unitOfWork.JobItemCoats.AddAsync(coat);
+                _logger.LogInformation("Created JobItemCoat '{CoatName}' (Sequence {Seq}) - Color: {Color} ({Code})",
+                    coat.CoatName, coat.Sequence, coat.ColorName ?? "N/A", coat.ColorCode ?? "N/A");
+            }
 
-                    if (quoteCoat.InventoryItemId.HasValue && quoteCoat.InventoryItem != null)
-                    {
-                        // Use inventory item information (takes precedence)
-                        colorName = quoteCoat.InventoryItem.Name;
-                        colorCode = quoteCoat.InventoryItem.ColorCode;
-                        finish = quoteCoat.InventoryItem.Finish;
-                    }
-
-                    // Calculate PowderToOrder if not already stored on the quote coat
-                    var cov = quoteCoat.CoverageSqFtPerLb > 0 ? quoteCoat.CoverageSqFtPerLb : 30m;
-                    var eff = quoteCoat.TransferEfficiency > 0 ? quoteCoat.TransferEfficiency / 100m : 0.65m;
-                    var powderToOrder = (quoteCoat.PowderToOrder > 0)
-                        ? quoteCoat.PowderToOrder
-                        : (quoteItem.SurfaceAreaSqFt > 0
-                            ? Math.Round((quoteItem.SurfaceAreaSqFt * quoteItem.Quantity) / (cov * eff), 2)
-                            : (decimal?)null);
-
-                    var jobCoat = new JobItemCoat
-                    {
-                        JobItemId = jobItem.Id,
-                        CoatName = quoteCoat.CoatName,
-                        Sequence = quoteCoat.Sequence,
-                        InventoryItemId = quoteCoat.InventoryItemId,
-                        ColorName = colorName,
-                        VendorId = quoteCoat.VendorId,
-                        ColorCode = colorCode,
-                        Finish = finish,
-                        CoverageSqFtPerLb = quoteCoat.CoverageSqFtPerLb,
-                        TransferEfficiency = quoteCoat.TransferEfficiency,
-                        PowderCostPerLb = quoteCoat.PowderCostPerLb,
-                        PowderToOrder = powderToOrder,
-                        Notes = quoteCoat.Notes,
-                        CompanyId = quote.CompanyId,
-                        CreatedAt = DateTime.UtcNow
-                    };
-
-                    await _unitOfWork.JobItemCoats.AddAsync(jobCoat);
-                    _logger.LogInformation("Created JobItemCoat '{CoatName}' (Sequence {Seq}) - Color: {Color} ({Code})",
-                        jobCoat.CoatName, jobCoat.Sequence, colorName ?? "N/A", colorCode ?? "N/A");
-                }
+            foreach (var prepService in _jobItemAssemblyService.CreateJobItemPrepServices(quoteItem, jobItem.Id, quote.CompanyId, createdAtUtc))
+            {
+                await _unitOfWork.JobItemPrepServices.AddAsync(prepService);
             }
         }
 
         await _unitOfWork.SaveChangesAsync();
 
-        // Aggregate unique prep services from all quote items and copy to job
-        // Load from DB directly to ensure prep services are available regardless of caller's includes
-        var quoteItemIds = fullItems.Select(qi => qi.Id).ToList();
-        var itemPrepServices = (await _unitOfWork.QuoteItemPrepServices.FindAsync(
-            ps => quoteItemIds.Contains(ps.QuoteItemId))).ToList();
-        var uniquePrepServiceIds = itemPrepServices
+        // Aggregate unique prep services from the fully-loaded quote items and copy to job
+        var uniquePrepServiceIds = fullItems
+            .SelectMany(qi => qi.PrepServices)
+            .Where(ps => !ps.IsDeleted)
             .Select(ps => ps.PrepServiceId)
             .Distinct()
             .ToList();
@@ -3795,160 +3487,6 @@ public class QuotesController : Controller
     /// Returns the new inventory item ID, or null if creation fails (non-fatal — the coat
     /// falls back to custom-powder pricing without an inventory link).
     /// </summary>
-    private async Task<int?> CreateIncomingInventoryItemAsync(CreateQuoteItemCoatDto coatDto, int companyId)
-    {
-        try
-        {
-            var catalogItem = await _unitOfWork.PowderCatalog.GetByIdAsync(coatDto.CatalogItemId!.Value);
-            if (catalogItem == null) return null;
-
-            var categories = await _unitOfWork.InventoryCategoryLookups.GetAllAsync();
-            var coatingCategory = categories
-                .Where(c => c.IsActive && c.IsCoating)
-                .OrderBy(c => c.DisplayOrder)
-                .FirstOrDefault();
-
-            // Match catalog vendor name to a company vendor record
-            var vendors = await _unitOfWork.Vendors.GetAllAsync();
-            var vendorNameLower = catalogItem.VendorName.ToLower();
-            var matchedVendor = vendors.FirstOrDefault(v =>
-                v.CompanyName.ToLower().Contains(vendorNameLower) ||
-                vendorNameLower.Contains(v.CompanyName.ToLower()));
-            // InventoryCategoryId is nullable — degrade gracefully rather than aborting if the
-            // company has not yet set up inventory categories (e.g., pre-seed).
-            var code = coatingCategory != null
-                ? (coatingCategory.CategoryCode.Length >= 4
-                    ? coatingCategory.CategoryCode[..4].ToUpperInvariant()
-                    : coatingCategory.CategoryCode.ToUpperInvariant().PadRight(4, 'X'))
-                : "POWD";
-            var prefix = $"{code}-{DateTime.Now:yyMM}-";
-            var allItems = await _unitOfWork.InventoryItems.GetAllAsync(ignoreQueryFilters: true);
-            var maxSeq = allItems
-                .Where(i => i.SKU.StartsWith(prefix))
-                .Select(i => int.TryParse(i.SKU[prefix.Length..], out var n) ? n : 0)
-                .DefaultIfEmpty(0)
-                .Max();
-            var sku = $"{prefix}{(maxSeq + 1):D4}";
-
-            var name = System.Globalization.CultureInfo.CurrentCulture.TextInfo
-                .ToTitleCase(catalogItem.ColorName.Trim().ToLower());
-
-            // Start with everything the catalog already has, then augment any null
-            // spec fields by fetching the product URL through the AI lookup service.
-            var description      = catalogItem.Description;
-            var finish           = catalogItem.Finish;
-            var colorFamilies    = catalogItem.ColorFamilies;
-            var cureTemp         = catalogItem.CureTemperatureF;
-            var cureTime         = catalogItem.CureTimeMinutes;
-            var coverage         = catalogItem.CoverageSqFtPerLb;
-            var transferEff      = catalogItem.TransferEfficiency;
-            var specificGravity  = catalogItem.SpecificGravity;
-            var imageUrl         = catalogItem.ImageUrl;
-            var sdsUrl           = catalogItem.SdsUrl;
-            var tdsUrl           = catalogItem.TdsUrl;
-
-            var needsAugment = !string.IsNullOrWhiteSpace(catalogItem.ProductUrl) &&
-                               (string.IsNullOrWhiteSpace(description) ||
-                                string.IsNullOrWhiteSpace(colorFamilies) ||
-                                cureTemp == null || cureTime == null);
-            if (needsAugment)
-            {
-                try
-                {
-                    var augmented = await _aiLookupService.LookupByUrlAsync(catalogItem.ProductUrl!, catalogItem.ColorName, catalogItem.TdsUrl);
-                    if (augmented.Success)
-                    {
-                        description   = string.IsNullOrWhiteSpace(description)   ? augmented.Description   : description;
-                        finish        = string.IsNullOrWhiteSpace(finish)        ? augmented.Finish        : finish;
-                        colorFamilies = string.IsNullOrWhiteSpace(colorFamilies) ? augmented.ColorFamilies : colorFamilies;
-                        cureTemp      ??= augmented.CureTemperatureF;
-                        cureTime      ??= augmented.CureTimeMinutes;
-                        coverage      ??= augmented.CoverageSqFtPerLb;
-                        transferEff   ??= augmented.TransferEfficiency;
-                        specificGravity ??= augmented.SpecificGravity;
-                        imageUrl      = string.IsNullOrWhiteSpace(imageUrl)      ? augmented.ImageUrl      : imageUrl;
-                        sdsUrl        = string.IsNullOrWhiteSpace(sdsUrl)        ? augmented.SdsUrl        : sdsUrl;
-                        tdsUrl        = string.IsNullOrWhiteSpace(tdsUrl)        ? augmented.TdsUrl        : tdsUrl;
-                        _logger.LogInformation("AI-augmented incoming inventory item for catalog {CatalogId}", catalogItem.Id);
-                    }
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogWarning(ex, "AI augment failed for catalog {CatalogId}, continuing with catalog data", catalogItem.Id);
-                }
-            }
-
-            var item = new PowderCoating.Core.Entities.InventoryItem
-            {
-                SKU                    = sku,
-                Name                   = name,
-                Description            = description,
-                ColorName              = catalogItem.ColorName,
-                Manufacturer           = catalogItem.VendorName,
-                ManufacturerPartNumber = catalogItem.Sku,
-                Finish                 = finish,
-                ColorFamilies          = colorFamilies,
-                RequiresClearCoat      = catalogItem.RequiresClearCoat ?? false,
-                CoverageSqFtPerLb      = coverage ?? 30m,
-                TransferEfficiency     = transferEff ?? 65m,
-                CureTemperatureF       = cureTemp,
-                CureTimeMinutes        = cureTime,
-                SpecificGravity        = specificGravity,
-                SpecPageUrl            = catalogItem.ProductUrl,
-                ImageUrl               = imageUrl,
-                SdsUrl                 = sdsUrl,
-                TdsUrl                 = tdsUrl,
-                UnitCost               = catalogItem.UnitPrice,
-                AverageCost            = catalogItem.UnitPrice,
-                LastPurchasePrice      = catalogItem.UnitPrice,
-                QuantityOnHand         = 0,
-                UnitOfMeasure          = "lbs",
-                PrimaryVendorId        = matchedVendor?.Id,
-                InventoryCategoryId    = coatingCategory?.Id,
-                Category               = coatingCategory?.DisplayName ?? "Powder Coating",
-                IsActive               = true,
-                IsIncoming             = true,
-                CompanyId              = companyId,
-                CreatedAt              = DateTime.UtcNow,
-            };
-
-            await _unitOfWork.InventoryItems.AddAsync(item);
-            await _unitOfWork.SaveChangesAsync();
-
-            // Also update the coat DTO so pricing uses the inventory unit cost
-            coatDto.PowderCostPerLb = null; // clear manual price; pricing service reads from inventory
-            _logger.LogInformation("Created incoming inventory item {Id} ({Name}) from catalog {CatalogId} via quote coat",
-                item.Id, item.Name, coatDto.CatalogItemId);
-
-            return item.Id;
-        }
-        catch (Exception ex)
-        {
-            _logger.LogWarning(ex, "Failed to create incoming inventory item from catalog {CatalogId}, continuing without inventory link",
-                coatDto.CatalogItemId);
-            return null;
-        }
-    }
-
-    /// <summary>
-    /// After pricing is determined for an AI item, update the prediction record to flag whether
-    /// the user changed the AI's estimated surface area or unit price before accepting.
-    /// This data powers the "AI accuracy" reporting queries.
-    /// </summary>
-    private async Task UpdateAiPredictionOverrideAsync(CreateQuoteItemDto itemDto, decimal finalUnitPrice)
-    {
-        if (!itemDto.AiPredictionId.HasValue) return;
-
-        var prediction = await _unitOfWork.AiItemPredictions.GetByIdAsync(itemDto.AiPredictionId.Value);
-        if (prediction == null) return;
-
-        var sqftDiff  = Math.Abs(prediction.PredictedSurfaceAreaSqFt - itemDto.SurfaceAreaSqFt);
-        var priceDiff = Math.Abs(prediction.PredictedUnitPrice - finalUnitPrice);
-        prediction.UserOverrodeEstimate = sqftDiff > 0.01m || priceDiff > 0.01m;
-        prediction.UpdatedAt = DateTime.UtcNow;
-        // Change is tracked by EF; will be persisted on the next CompleteAsync()
-    }
-
     /// <summary>
     /// Builds a benchmark summary comparing the AI's estimate to historical completed jobs of
     /// similar complexity and surface area (±60% sqft range). The benchmark is displayed

src/PowderCoating.Web/Controllers/VendorsController.cs

@@ -111,14 +111,7 @@ public class VendorsController : Controller
                 InventoryItemCount = s.InventoryItems.Count(i => !i.IsDeleted)
             }).ToList();
 
-            // Create paged result
-            var pagedResult = new PagedResult<VendorListDto>
-            {
-                Items = vendorDtos,
-                PageNumber = gridRequest.PageNumber,
-                PageSize = gridRequest.PageSize,
-                TotalCount = totalCount
-            };
+            var pagedResult = PagedResult<VendorListDto>.From(gridRequest, vendorDtos, totalCount);
 
             // Set ViewBag for sorting
             ViewBag.SearchTerm = searchTerm;

src/PowderCoating.Web/Helpers/AccountingDropdownHelper.cs

@@ -0,0 +1,99 @@
+using Microsoft.AspNetCore.Mvc.Rendering;
+using PowderCoating.Core.Enums;
+using PowderCoating.Core.Interfaces;
+
+namespace PowderCoating.Web.Helpers;
+
+/// <summary>
+/// Centralizes the repeated DB queries and SelectListItem projections used by the accounting
+/// controllers (Bills, Expenses). Each controller assigns only the properties it needs to ViewBag,
+/// so the naming mismatch between controllers (BankAccounts vs PaymentAccounts) is harmless.
+/// </summary>
+internal static class AccountingDropdownHelper
+{
+    /// <summary>
+    /// Loads vendors, accounts, payment methods, and active jobs in a single call.
+    /// Returns pre-projected SelectListItem collections so controllers avoid duplicating the
+    /// LINQ-to-SelectListItem transform.
+    /// </summary>
+    internal static async Task<AccountingDropdowns> LoadAsync(IUnitOfWork unitOfWork)
+    {
+        var vendors = await unitOfWork.Vendors.FindAsync(v => v.IsActive);
+        var allAccounts = await unitOfWork.Accounts.FindAsync(a => a.IsActive);
+        var jobs = await unitOfWork.Jobs.FindAsync(j =>
+            j.JobStatus.StatusCode != "COMPLETED" &&
+            j.JobStatus.StatusCode != "CANCELLED" &&
+            j.JobStatus.StatusCode != "DELIVERED");
+
+        var accountLabel = (Core.Entities.Account a) => $"{a.AccountNumber} – {a.Name}";
+
+        return new AccountingDropdowns
+        {
+            Vendors = vendors
+                .OrderBy(v => v.CompanyName)
+                .Select(v => new SelectListItem(v.CompanyName, v.Id.ToString()))
+                .ToList(),
+
+            ExpenseAccounts = allAccounts
+                .Where(a => a.AccountType == AccountType.Expense ||
+                            a.AccountType == AccountType.CostOfGoods)
+                .OrderBy(a => a.AccountNumber)
+                .Select(a => new SelectListItem(accountLabel(a), a.Id.ToString()))
+                .ToList(),
+
+            ExpenseAndAssetAccounts = allAccounts
+                .Where(a => a.AccountType == AccountType.Expense ||
+                            a.AccountType == AccountType.CostOfGoods ||
+                            a.AccountType == AccountType.Asset)
+                .OrderBy(a => a.AccountNumber)
+                .Select(a => new SelectListItem(accountLabel(a), a.Id.ToString()))
+                .ToList(),
+
+            ApAccounts = allAccounts
+                .Where(a => a.AccountSubType == AccountSubType.AccountsPayable)
+                .OrderBy(a => a.AccountNumber)
+                .Select(a => new SelectListItem(accountLabel(a), a.Id.ToString()))
+                .ToList(),
+
+            BankAccounts = allAccounts
+                .Where(a => a.AccountSubType == AccountSubType.Cash ||
+                            a.AccountSubType == AccountSubType.Checking ||
+                            a.AccountSubType == AccountSubType.Savings ||
+                            a.AccountSubType == AccountSubType.CreditCard)
+                .OrderBy(a => a.AccountNumber)
+                .Select(a => new SelectListItem(accountLabel(a), a.Id.ToString()))
+                .ToList(),
+
+            PaymentMethods = Enum.GetValues<PaymentMethod>()
+                .Select(m => new SelectListItem(m.ToString(), ((int)m).ToString()))
+                .ToList(),
+
+            ActiveJobs = jobs
+                .OrderBy(j => j.JobNumber)
+                .Select(j => new SelectListItem(
+                    $"{j.JobNumber} – {j.Description ?? "No description"}",
+                    j.Id.ToString()))
+                .ToList()
+        };
+    }
+}
+
+internal sealed class AccountingDropdowns
+{
+    public IReadOnlyList<SelectListItem> Vendors { get; init; } = [];
+
+    /// <summary>Expense + Cost of Goods accounts (used by Expenses controller).</summary>
+    public IReadOnlyList<SelectListItem> ExpenseAccounts { get; init; } = [];
+
+    /// <summary>Expense + Cost of Goods + Asset accounts (used by Bills controller).</summary>
+    public IReadOnlyList<SelectListItem> ExpenseAndAssetAccounts { get; init; } = [];
+
+    /// <summary>Accounts Payable accounts (used by Bills controller).</summary>
+    public IReadOnlyList<SelectListItem> ApAccounts { get; init; } = [];
+
+    /// <summary>Cash, Checking, Savings, and Credit Card accounts.</summary>
+    public IReadOnlyList<SelectListItem> BankAccounts { get; init; } = [];
+
+    public IReadOnlyList<SelectListItem> PaymentMethods { get; init; } = [];
+    public IReadOnlyList<SelectListItem> ActiveJobs { get; init; } = [];
+}

src/PowderCoating.Web/Program.cs

@@ -211,6 +211,8 @@ builder.Services.AddHttpClient();
 builder.Services.AddScoped<ICompanyLogoService, CompanyLogoService>();
 builder.Services.AddScoped<IEquipmentManualService, EquipmentManualService>();
 builder.Services.AddScoped<IPricingCalculationService, PricingCalculationService>();
+builder.Services.AddScoped<IJobItemAssemblyService, JobItemAssemblyService>();
+builder.Services.AddScoped<IQuotePricingAssemblyService, QuotePricingAssemblyService>();
 builder.Services.AddScoped<IPowderInsightsService, PowderInsightsService>();
 builder.Services.AddScoped<IAuditLogService, AuditLogService>();
 builder.Services.AddScoped<IAiUsageReportService, AiUsageReportService>();