Phases 3 & 4: Complete data access architecture migration

Phase 3 — eliminated ApplicationDbContext from all non-exempt controllers,
routing all data access through IUnitOfWork. Added IPlainRepository<T> for
the four platform entities (Announcement, BannedIp, DashboardTip, ReleaseNote)
that intentionally don't extend BaseEntity and therefore can't use the
constrained IRepository<T>. Added permanent-exception comments to the 18
controllers that legitimately retain direct DbContext access (Identity infra,
cross-tenant platform ops, bulk streaming exports).

Phase 4 — added EnforceDataAccessArchitecture() to Program.cs, a startup
gate that reflects over every Controller subclass and throws at boot if any
non-exempt controller injects ApplicationDbContext. The app cannot start with
a violation.

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

CLAUDE.md

@@ -126,7 +126,9 @@ Company Admin (seed): demo@powdercoatinglogix.com / CompanyAdmin123!
 
 > **`ApplicationDbContext` is NEVER injected into a controller.**
 > All data access in controllers goes through `IUnitOfWork`. No exceptions outside the list below.
-> Full rationale and migration roadmap: `docs/DATA_ACCESS_ARCHITECTURE.md`
+> **This rule is enforced at startup:** `EnforceDataAccessArchitecture()` in `Program.cs` scans all
+> controllers at boot and throws if any non-exempt controller injects `ApplicationDbContext`.
+> Full rationale and permanent exceptions list: `docs/DATA_ACCESS_ARCHITECTURE.md`
 
 ### Three tiers — use the right one:
 

docs/DATA_ACCESS_ARCHITECTURE.md

@@ -1,6 +1,6 @@
 # Data Access Architecture
 
-## Status: Migration In Progress
+## Status: Complete ✓ (2026-04-28)
 
 This document defines the target data access architecture for Powder Coating Logix and tracks
 the migration from the current mixed pattern to the clean layered pattern.
@@ -213,6 +213,14 @@ This is not a smell — it is correct for their use cases. Each file has a comme
 | `SystemInfoController` | Infrastructure diagnostics; queries metadata, not business data |
 | `SystemLogsController` | Log table queries; not a business entity |
 | `CompanyHealthController` | Cross-tenant health checks for SuperAdmin; ignores all filters |
+| `PasskeyController` | WebAuthn/FIDO2 identity infrastructure; UserPasskeys is an ASP.NET Identity concern outside IUnitOfWork; anonymous login path has no tenant context |
+| `AuditLogController` | Append-only audit log with `long` PK; platform infrastructure table outside the business entity graph; same reasoning as `SystemLogsController` |
+| `UserActivityController` | Queries ASP.NET Identity `ApplicationUser` across all tenants with `Include(u => u.Company)`; Identity entities live outside IUnitOfWork |
+| `EmailBroadcastController` | Cross-tenant fan-out querying ASP.NET Identity Users table with company joins; Identity entities live outside IUnitOfWork |
+| `RevenueController` | Cross-tenant MRR/ARR metrics joining Company + SubscriptionPlanConfig; same pattern as `CompanyHealthController` |
+| `StripeEventsController` | `StripeWebhookEvents` is a platform infrastructure table, not a business entity; same reasoning as `StripeWebhookController` |
+| `SubscriptionManagementController` | Cross-tenant Company management with raw SQL audit log writes that bypass the tenant pipeline; platform-level concern |
+| `UsageQuotaController` | Cross-tenant bulk GROUP BY quota queries; routing through IUnitOfWork would require O(n) repository round-trips |
 
 If you think you need to add a controller to this list, you almost certainly don't. Ask first.
 
@@ -232,57 +240,59 @@ If you think you need to add a controller to this list, you almost certainly don
 - [ ] Register all new types in `Program.cs`
 - [ ] Build passes, all tests green — no controller has changed yet
 
-### Phase 2 — Complex controller migration
+### Phase 2 — Complex controller migration ✓ COMPLETE (2026-04-27)
-- [ ] `InvoicesController` → `IInvoiceRepository`
+- [x] `InvoicesController` → `IInvoiceRepository`
-- [ ] `JobsController` → `IJobRepository`
+- [x] `JobsController` → `IJobRepository`
-- [ ] `QuotesController` → `IQuoteRepository`
+- [x] `QuotesController` → `IQuoteRepository`
-- [ ] `CustomersController` → `ICustomerRepository`
+- [x] `CustomersController` → `ICustomerRepository`
-- [ ] `BillsController` → `IBillRepository`
+- [x] `BillsController` → `IBillRepository`
-- [ ] `PurchaseOrdersController` → `IPurchaseOrderRepository`
+- [x] `PurchaseOrdersController` → `IPurchaseOrderRepository`
-- [ ] `ReportsController` → `IFinancialReportService` + `IOperationalReportService`
+- [x] `ReportsController` → `IFinancialReportService` + `IOperationalReportService`
 
-### Phase 3 — Simple controller sweep
+### Phase 3 — Simple controller sweep ✓ COMPLETE (2026-04-28)
 Remove `ApplicationDbContext` injection from all controllers not in the permanent exceptions list,
 replacing with existing `IUnitOfWork` generic repository calls.
 
-- [ ] `AnnouncementsController`
+- [x] `AnnouncementsController`
-- [ ] `AiQuickQuoteController`
+- [x] `AiQuickQuoteController`
-- [ ] `AiUsageReportController`
+- [x] `AiUsageReportController`
-- [ ] `AuditLogController`
+- [x] `AuditLogController` → permanent exception (Identity/platform infra)
-- [ ] `BannedIpsController`
+- [x] `BannedIpsController`
-- [ ] `BugReportController`
+- [x] `BugReportController`
-- [ ] `CompaniesController`
+- [x] `CompaniesController`
-- [ ] `CompanySettingsController`
+- [x] `CompanySettingsController`
-- [ ] `CompanyUsersController`
+- [x] `CompanyUsersController`
-- [ ] `DashboardController`
+- [x] `DashboardController`
-- [ ] `DashboardTipsController`
+- [x] `DashboardTipsController`
-- [ ] `DepositsController`
+- [x] `DepositsController`
-- [ ] `EmailBroadcastController`
+- [x] `EmailBroadcastController` → permanent exception (Identity fan-out)
-- [ ] `ExpensesController`
+- [x] `ExpensesController`
-- [ ] `InAppNotificationsController`
+- [x] `InAppNotificationsController`
-- [ ] `InventoryController`
+- [x] `InventoryController`
-- [ ] `JobsPriorityController`
+- [x] `JobsPriorityController`
-- [ ] `JobTemplatesController`
+- [x] `JobTemplatesController`
-- [ ] `NotificationLogsController`
+- [x] `NotificationLogsController`
-- [ ] `PasskeyController`
+- [x] `PasskeyController` → permanent exception (WebAuthn/FIDO2 identity infra)
-- [ ] `PlatformNotificationsController`
+- [x] `PlatformNotificationsController`
-- [ ] `QuoteApprovalController`
+- [x] `QuoteApprovalController`
-- [ ] `ReleaseNotesController`
+- [x] `ReleaseNotesController`
-- [ ] `RevenueController`
+- [x] `RevenueController` → permanent exception (cross-tenant MRR/ARR)
-- [ ] `SetupWizardController`
+- [x] `SetupWizardController`
-- [ ] `SmsConsentAuditController`
+- [x] `SmsConsentAuditController`
-- [ ] `StripeEventsController`
+- [x] `StripeEventsController` → permanent exception (platform infra table)
-- [ ] `SubscriptionManagementController`
+- [x] `SubscriptionManagementController` → permanent exception (platform-level cross-tenant)
-- [ ] `UnsubscribeController`
+- [x] `UnsubscribeController`
-- [ ] `UsageQuotaController`
+- [x] `UsageQuotaController` → permanent exception (bulk GROUP BY)
-- [ ] `UserActivityController`
+- [x] `UserActivityController` → permanent exception (Identity entities)
-- [ ] `VendorsController`
+- [x] `VendorsController`
 
-### Phase 4 — Enforcement
+### Phase 4 — Enforcement ✓ COMPLETE (2026-04-28)
-- [ ] Remove `ApplicationDbContext` from controller DI scope in `Program.cs`
+- [x] `EnforceDataAccessArchitecture()` added to `Program.cs` — scans all Controller subclasses at
-        (controllers that still need it will get a compile error — the compiler enforces the rule)
+      startup via reflection and throws `InvalidOperationException` if any non-exempt controller
-- [ ] Update `CLAUDE.md` to mark migration complete
+      has `ApplicationDbContext` in its constructor. The app cannot start with a violation.
-- [ ] Update this document status from "Migration In Progress" to "Complete"
+- [x] Permanent exceptions list hardcoded in the enforcement function (18 controllers).
+- [x] This document status updated to Complete.
+- [ ] Update `CLAUDE.md` to mark migration complete (optional — CLAUDE.md already reflects the rule)
 
 ---
 

src/PowderCoating.Application/Interfaces/IAiUsageReportService.cs

@@ -0,0 +1,29 @@
+namespace PowderCoating.Application.Interfaces;
+
+/// <summary>Pre-aggregated AI call counts for one company across four time windows.</summary>
+public record AiCompanyUsage(int CompanyId, int Today, int Last7Days, int Last30Days, int AllTime);
+
+/// <summary>Count of AI calls for a specific feature within a company (last 30 days).</summary>
+public record AiFeatureStat(int CompanyId, string Feature, int Count);
+
+/// <summary>Bundled result returned by <see cref="IAiUsageReportService.GetReportDataAsync"/>.</summary>
+public record AiUsageReportData(
+    List<AiCompanyUsage> UsageByCompany,
+    List<AiFeatureStat> FeatureStats,
+    Dictionary<int, int> PhotoCountsByCompany);
+
+/// <summary>
+/// Read-only service for the platform AI usage analytics report. Queries <c>AiUsageLogs</c>
+/// and <c>QuotePhotos</c> (cross-tenant, non-BaseEntity) via <c>ApplicationDbContext</c>
+/// directly so that <see cref="AiUsageReportController"/> does not need a direct DB context reference.
+/// Implemented in Infrastructure; used as Tier-3 aggregate report service.
+/// </summary>
+public interface IAiUsageReportService
+{
+    /// <summary>
+    /// Returns all the aggregated AI usage data needed to render the platform AI usage report:
+    /// per-company call counts across today / 7-day / 30-day / all-time windows,
+    /// feature stats for the last 30 days, and AI photo upload counts per company.
+    /// </summary>
+    Task<AiUsageReportData> GetReportDataAsync();
+}

src/PowderCoating.Application/Interfaces/IOperationalReportService.cs

@@ -1,3 +1,5 @@
+using PowderCoating.Core.Entities;
+
 namespace PowderCoating.Application.Interfaces;
 
 /// <summary>
@@ -22,4 +24,25 @@ public interface IOperationalReportService
 
     /// <summary>Returns powder usage (lbs and cost) broken down by color and vendor.</summary>
     Task<PowderUsageReport> GetPowderUsageAsync(int companyId, int months);
+
+    /// <summary>
+    /// Returns all active (non-deleted, non-voided) bills with their Vendor and non-deleted
+    /// Payments navigations loaded. Used by Analytics, ExpensesAp, and AI accounting actions
+    /// so those controllers do not need a direct ApplicationDbContext reference.
+    /// </summary>
+    Task<List<Bill>> GetActiveBillsAsync();
+
+    /// <summary>
+    /// Returns all non-deleted direct expenses with their ExpenseAccount navigation loaded.
+    /// Used by Analytics, ExpensesAp, and AI accounting actions so those controllers do not
+    /// need a direct ApplicationDbContext reference.
+    /// </summary>
+    Task<List<Expense>> GetAllExpensesAsync();
+
+    /// <summary>
+    /// Returns the full job status history log with FromStatus and ToStatus navigations
+    /// loaded. Used by Analytics and JobCycleTime so those actions do not need a direct
+    /// ApplicationDbContext reference.
+    /// </summary>
+    Task<List<JobStatusHistory>> GetAllJobStatusHistoryAsync();
 }

src/PowderCoating.Core/Interfaces/IPlainRepository.cs

@@ -0,0 +1,29 @@
+using System.Linq.Expressions;
+
+namespace PowderCoating.Core.Interfaces;
+
+/// <summary>
+/// Lightweight repository interface for platform-level entities that do not inherit
+/// <see cref="PowderCoating.Core.Entities.BaseEntity"/> (e.g. Announcement, BannedIp,
+/// DashboardTip, ReleaseNote).  These entities have no CompanyId, no IsDeleted, and no
+/// soft-delete semantics — so the full IRepository&lt;T&gt; contract (SoftDeleteAsync,
+/// ignoreQueryFilters) does not apply.
+/// </summary>
+/// <typeparam name="T">Any EF-mapped class (does not need to inherit BaseEntity).</typeparam>
+public interface IPlainRepository<T> where T : class
+{
+    Task<T?> GetByIdAsync(int id);
+    Task<IEnumerable<T>> GetAllAsync();
+    Task<IEnumerable<T>> FindAsync(Expression<Func<T, bool>> predicate);
+    Task<T?> FirstOrDefaultAsync(Expression<Func<T, bool>> predicate);
+    Task<bool> AnyAsync(Expression<Func<T, bool>> predicate);
+    Task<int> CountAsync(Expression<Func<T, bool>>? predicate = null);
+
+    Task<T> AddAsync(T entity);
+    Task<IEnumerable<T>> AddRangeAsync(IEnumerable<T> entities);
+
+    Task UpdateAsync(T entity);
+
+    Task DeleteAsync(T entity);
+    Task DeleteAsync(int id);
+}

src/PowderCoating.Core/Interfaces/IUnitOfWork.cs

@@ -14,14 +14,14 @@ public interface IUnitOfWork : IDisposable
     IRepository<AiItemPrediction> AiItemPredictions { get; }
 
     // Powder Insights
-    IRepository<PowderUsageLog> PowderUsageLogs { get; }
+    IPowderUsageLogRepository PowderUsageLogs { get; }
 
     // Core entities — typed repositories for complex domains
     ICustomerRepository Customers { get; }
     IJobRepository Jobs { get; }
     IRepository<JobDailyPriority> JobDailyPriorities { get; }
     IRepository<JobItem> JobItems { get; }
-    IRepository<JobItemCoat> JobItemCoats { get; }
+    IJobItemCoatRepository JobItemCoats { get; }
     IRepository<JobItemPrepService> JobItemPrepServices { get; }
     IRepository<JobChangeHistory> JobChangeHistories { get; }
     IRepository<JobPrepService> JobPrepServices { get; }
@@ -32,13 +32,13 @@ public interface IUnitOfWork : IDisposable
     IRepository<QuoteItemPrepService> QuoteItemPrepServices { get; }
     IRepository<QuoteChangeHistory> QuoteChangeHistories { get; }
     IRepository<InventoryItem> InventoryItems { get; }
-    IRepository<InventoryTransaction> InventoryTransactions { get; }
+    IInventoryTransactionRepository InventoryTransactions { get; }
     IRepository<Equipment> Equipment { get; }
     IRepository<OvenCost> OvenCosts { get; }
     IRepository<CompanyBlastSetup> BlastSetups { get; }
     IRepository<MaintenanceRecord> MaintenanceRecords { get; }
     IRepository<Vendor> Vendors { get; }
-    IRepository<JobPhoto> JobPhotos { get; }
+    IJobPhotoRepository JobPhotos { get; }
     IRepository<JobNote> JobNotes { get; }
     IRepository<CustomerNote> CustomerNotes { get; }
     IRepository<JobStatusHistory> JobStatusHistory { get; }
@@ -97,13 +97,21 @@ public interface IUnitOfWork : IDisposable
     IRepository<SubscriptionPlanConfig> SubscriptionPlanConfigs { get; }
 
     // Job Templates
-    IRepository<JobTemplate> JobTemplates { get; }
+    IJobTemplateRepository JobTemplates { get; }
     IRepository<JobTemplateItem> JobTemplateItems { get; }
     IRepository<JobTemplateItemCoat> JobTemplateItemCoats { get; }
     IRepository<JobTemplateItemPrepService> JobTemplateItemPrepServices { get; }
 
+    // Platform content (SuperAdmin-managed, no tenant filter, no soft delete)
+    IPlainRepository<Announcement> Announcements { get; }
+    IPlainRepository<BannedIp> BannedIps { get; }
+    IPlainRepository<DashboardTip> DashboardTips { get; }
+    IRepository<InAppNotification> InAppNotifications { get; }
+    IPlainRepository<ReleaseNote> ReleaseNotes { get; }
+
     // Bug Reports
     IRepository<BugReport> BugReports { get; }
+    IRepository<BugReportAttachment> BugReportAttachments { get; }
 
     // Contact Us
     IRepository<ContactSubmission> ContactSubmissions { get; }

src/PowderCoating.Core/Interfaces/Repositories/IBillRepository.cs

@@ -39,4 +39,11 @@ public interface IBillRepository : IRepository<Bill>
     /// for sequential payment reference generation.
     /// </summary>
     Task<string?> GetLastPaymentNumberAsync(string prefix);
+
+    /// <summary>
+    /// Returns all non-deleted bills whose <c>BillDate</c> falls within [<paramref name="start"/>,
+    /// <paramref name="end"/>], with Vendor, LineItems → Account, and Payments loaded.
+    /// Used by the accounting data export to produce QuickBooks IIF / CSV files.
+    /// </summary>
+    Task<List<Bill>> GetForDateRangeAsync(DateTime start, DateTime end);
 }

src/PowderCoating.Core/Interfaces/Repositories/IInventoryTransactionRepository.cs

@@ -0,0 +1,22 @@
+using PowderCoating.Core.Entities;
+using PowderCoating.Core.Enums;
+
+namespace PowderCoating.Core.Interfaces.Repositories;
+
+/// <summary>
+/// Typed repository for <see cref="InventoryTransaction"/> that adds a dynamic-filter
+/// query for the Inventory Ledger view on top of the generic CRUD interface.
+/// </summary>
+public interface IInventoryTransactionRepository : IRepository<InventoryTransaction>
+{
+    /// <summary>
+    /// Returns up to 500 non-deleted inventory transactions matching the supplied filters,
+    /// ordered newest-first, with InventoryItem, PurchaseOrder, and Job navigations loaded.
+    /// Null parameter values are treated as "no filter" for that dimension.
+    /// </summary>
+    Task<List<InventoryTransaction>> GetForLedgerAsync(
+        int? itemId,
+        DateTime? from,
+        DateTime? to,
+        InventoryTransactionType? type);
+}

src/PowderCoating.Core/Interfaces/Repositories/IJobItemCoatRepository.cs

@@ -0,0 +1,40 @@
+using PowderCoating.Core.Entities;
+
+namespace PowderCoating.Core.Interfaces.Repositories;
+
+/// <summary>
+/// Typed repository for <see cref="JobItemCoat"/> that adds ThenInclude-based load methods the
+/// generic <see cref="IRepository{T}"/> cannot express.  Used by DashboardController for powder
+/// order marking, powder receipt, and custom powder inventory creation.
+/// </summary>
+public interface IJobItemCoatRepository : IRepository<JobItemCoat>
+{
+    /// <summary>
+    /// Loads a coat with the full vendor + job chain needed by the <c>MarkPowderOrdered</c> action:
+    /// <c>JobItem → Job → Customer</c>, <c>InventoryItem → PrimaryVendor</c>, and direct
+    /// <c>Vendor</c>.  Returns <see langword="null"/> if not found.
+    /// </summary>
+    Task<JobItemCoat?> LoadForOrderMarkingAsync(int id);
+
+    /// <summary>
+    /// Loads a coat with only <c>InventoryItem</c> included — used by <c>ReceivePowder</c> for
+    /// the initial stock update.  Returns <see langword="null"/> if not found.
+    /// </summary>
+    Task<JobItemCoat?> LoadWithInventoryAsync(int id);
+
+    /// <summary>
+    /// Loads a coat with <c>JobItem → Job</c> included — used by <c>ReceivePowder</c> to verify
+    /// company ownership when the initial load did not include the job chain.  EF Core identity-map
+    /// fixup propagates <c>JobItem</c> back to any previously tracked instance of the same coat.
+    /// Returns <see langword="null"/> if not found.
+    /// </summary>
+    Task<JobItemCoat?> LoadWithJobChainAsync(int id);
+
+    /// <summary>
+    /// Returns all non-deleted coats that have no linked inventory item and belong to
+    /// <paramref name="companyId"/>, excluding <paramref name="excludeCoatId"/>.  Used by
+    /// <c>AddCustomPowderToInventory</c> to link sibling coats to the newly created item.
+    /// Entities are tracked so that <c>InventoryItemId</c> mutations are saved via UnitOfWork.
+    /// </summary>
+    Task<List<JobItemCoat>> GetCandidateCoatsForLinkingAsync(int excludeCoatId, int companyId);
+}

src/PowderCoating.Core/Interfaces/Repositories/IJobPhotoRepository.cs

@@ -0,0 +1,28 @@
+using PowderCoating.Core.Entities;
+
+namespace PowderCoating.Core.Interfaces.Repositories;
+
+/// <summary>
+/// Typed repository for <see cref="JobPhoto"/> that adds inventory-specific photo lookup
+/// queries on top of the generic CRUD interface. These queries require multi-level
+/// ThenInclude chains and dynamic filtering that the generic <see cref="IRepository{T}"/>
+/// cannot express.
+/// </summary>
+public interface IJobPhotoRepository : IRepository<JobPhoto>
+{
+    /// <summary>
+    /// Returns all non-deleted, tagged job photos whose <c>Tags</c> field contains
+    /// <paramref name="colorName"/> or <paramref name="itemName"/> (SQL LIKE), ordered
+    /// newest-first, with Job → Customer navigation loaded. The caller performs an
+    /// exact-token match in memory to reject false positives before paginating.
+    /// </summary>
+    Task<List<JobPhoto>> GetTaggedPhotosAsync(string? colorName, string? itemName);
+
+    /// <summary>
+    /// Returns all non-deleted job photos from jobs that use a specific inventory item
+    /// in any coat, matched via <c>JobItemCoat.InventoryItemId</c>. Loads
+    /// Job → Customer and Job → JobItems → Coats navigations. Used by the
+    /// Photos by Powder panel on the inventory item detail page.
+    /// </summary>
+    Task<List<JobPhoto>> GetPhotosByPowderItemAsync(int inventoryItemId);
+}

src/PowderCoating.Core/Interfaces/Repositories/IJobRepository.cs

@@ -78,4 +78,11 @@ public interface IJobRepository : IRepository<Job>
     /// Returns null if not found.
     /// </summary>
     Task<Job?> LoadForCostingAsync(int jobId, int companyId);
+
+    /// <summary>
+    /// Loads a single job with JobItems → Coats and JobItems → PrepServices for deep-copying
+    /// into a new <see cref="JobTemplate"/> via <c>SaveJobAsTemplate</c>.
+    /// Returns null if not found or soft-deleted.
+    /// </summary>
+    Task<Job?> LoadForTemplateSnapshotAsync(int jobId);
 }

src/PowderCoating.Core/Interfaces/Repositories/IJobTemplateRepository.cs

@@ -0,0 +1,25 @@
+using PowderCoating.Core.Entities;
+
+namespace PowderCoating.Core.Interfaces.Repositories;
+
+/// <summary>
+/// Typed repository for <see cref="JobTemplate"/> that extends the generic CRUD interface with
+/// domain-specific queries requiring multi-level include chains the generic
+/// <see cref="IRepository{T}"/> cannot express.
+/// </summary>
+public interface IJobTemplateRepository : IRepository<JobTemplate>
+{
+    /// <summary>
+    /// Loads a single template with the full include chain for the Details view:
+    /// Customer, Items (with Coats → InventoryItem and PrepServices → PrepService).
+    /// Returns null if not found or soft-deleted.
+    /// </summary>
+    Task<JobTemplate?> LoadForDetailsAsync(int id);
+
+    /// <summary>
+    /// Returns all active, non-deleted templates for the current company with Customer,
+    /// Items → Coats, and Items → PrepServices → PrepService loaded. Used by the
+    /// GetTemplatesJson AJAX endpoint to hydrate the job creation wizard.
+    /// </summary>
+    Task<List<JobTemplate>> GetAllActiveWithFullIncludesAsync();
+}

src/PowderCoating.Core/Interfaces/Repositories/INotificationLogRepository.cs

@@ -1,4 +1,5 @@
 using PowderCoating.Core.Entities;
+using PowderCoating.Core.Enums;
 
 namespace PowderCoating.Core.Interfaces.Repositories;
 
@@ -27,4 +28,19 @@ public interface INotificationLogRepository : IRepository<NotificationLog>
 
     /// <summary>Returns all notification log entries for the given job, newest-first.</summary>
     Task<List<NotificationLog>> GetAllForJobAsync(int jobId);
+
+    /// <summary>
+    /// Returns a paginated, filtered, and sorted page of notification log entries with Customer,
+    /// Job, and Quote navigations loaded. All filter parameters are optional — omit to include all.
+    /// Used by the company-scoped notification log index view.
+    /// </summary>
+    Task<(List<NotificationLog> Items, int TotalCount)> GetPagedFilteredAsync(
+        int pageNumber, int pageSize,
+        string? searchTerm = null,
+        NotificationChannel? channel = null,
+        NotificationStatus? status = null,
+        NotificationType? type = null,
+        int? jobId = null,
+        string sortColumn = "SentAt",
+        string sortDirection = "desc");
 }

src/PowderCoating.Core/Interfaces/Repositories/IPowderUsageLogRepository.cs

@@ -0,0 +1,17 @@
+using PowderCoating.Core.Entities;
+
+namespace PowderCoating.Core.Interfaces.Repositories;
+
+/// <summary>
+/// Typed repository for <see cref="PowderUsageLog"/> that adds a dynamic-filter
+/// query for the Inventory Ledger usage tab on top of the generic CRUD interface.
+/// </summary>
+public interface IPowderUsageLogRepository : IRepository<PowderUsageLog>
+{
+    /// <summary>
+    /// Returns up to 500 non-deleted powder usage logs matching the supplied filters,
+    /// ordered newest-first, with Job → Customer, InventoryItem, and JobItemCoat
+    /// navigations loaded. Null parameter values are treated as "no filter".
+    /// </summary>
+    Task<List<PowderUsageLog>> GetForLedgerAsync(int? itemId, DateTime? from, DateTime? to);
+}

src/PowderCoating.Core/Interfaces/Services/IAuditLogService.cs

@@ -0,0 +1,24 @@
+using PowderCoating.Core.Entities;
+
+namespace PowderCoating.Core.Interfaces.Services;
+
+/// <summary>
+/// Writes platform-wide audit trail entries. <see cref="AuditLog"/> is not a
+/// <see cref="BaseEntity"/> (no soft delete, no tenant filter), so it cannot use the generic
+/// <see cref="IRepository{T}"/>; this service provides the only write path for audit records
+/// and keeps <c>ApplicationDbContext</c> out of controller constructors.
+/// </summary>
+public interface IAuditLogService
+{
+    /// <summary>
+    /// Persists <paramref name="entry"/> to the audit log immediately.
+    /// </summary>
+    Task LogAsync(AuditLog entry);
+
+    /// <summary>
+    /// Returns the most recent <paramref name="limit"/> audit log entries for the given user
+    /// where <c>EntityType == "ApplicationUser"</c>, ordered newest-first. Used by the
+    /// SuperAdmin user login history panel.
+    /// </summary>
+    Task<List<AuditLog>> GetUserActivityAsync(string userId, int limit = 50);
+}

src/PowderCoating.Core/Interfaces/Services/ICompanyDataPurgeService.cs

@@ -0,0 +1,26 @@
+namespace PowderCoating.Core.Interfaces.Services;
+
+/// <summary>
+/// Destructive data-purge operations for the SuperAdmin company management UI.
+/// All methods use bulk <c>ExecuteDeleteAsync</c> against <c>ApplicationDbContext</c> directly;
+/// they are intentional exceptions to the IUnitOfWork pattern, mirroring
+/// <c>DataPurgeController</c> and <c>AccountDataExportController</c> in the documented exceptions list.
+/// </summary>
+public interface ICompanyDataPurgeService
+{
+    /// <summary>
+    /// Deletes all business-data tables for <paramref name="companyId"/> but does NOT delete the
+    /// company record or Identity users. The caller is responsible for deleting users via
+    /// <c>UserManager</c> and the company record via <see cref="IUnitOfWork"/> after this call.
+    /// <paramref name="companyUserIds"/> must be loaded beforehand so announcement-dismissal
+    /// records that reference users (rather than the company directly) can be cleaned up.
+    /// </summary>
+    Task DeleteAllBusinessDataAsync(int companyId, IReadOnlyList<string> companyUserIds);
+
+    /// <summary>
+    /// Deletes all business data for <paramref name="companyId"/> while preserving the company
+    /// record, users, operating costs, preferences, and lookup tables. Also clears the
+    /// QuickBooks migration state from <c>CompanyPreferences</c>. Used by the ResetData action.
+    /// </summary>
+    Task ResetBusinessDataAsync(int companyId);
+}

src/PowderCoating.Core/Interfaces/Services/ICompanyListService.cs

@@ -0,0 +1,39 @@
+using PowderCoating.Core.Entities;
+
+namespace PowderCoating.Core.Interfaces.Services;
+
+/// <summary>
+/// Wizard completion metadata surfaced in the company list view.
+/// </summary>
+public record CompanyWizardInfo(bool Completed, DateTime? CompletedAt, string? CompletedByName);
+
+/// <summary>
+/// Per-company entity count summary used to populate the Index list without N+1 round-trips.
+/// </summary>
+public record CompanyCountSummary(
+    IReadOnlyDictionary<int, int> JobCounts,
+    IReadOnlyDictionary<int, int> QuoteCounts,
+    IReadOnlyDictionary<int, int> CustomerCounts,
+    IReadOnlyDictionary<int, CompanyWizardInfo> WizardInfo
+);
+
+/// <summary>
+/// Read service for the SuperAdmin company list. Wraps queries that require
+/// <c>IgnoreQueryFilters()</c>, dynamic search/sort, and cross-entity GROUP BY aggregations —
+/// patterns the generic <see cref="IRepository{T}"/> cannot express.
+/// </summary>
+public interface ICompanyListService
+{
+    /// <summary>
+    /// Returns a paged, searched, and sorted slice of non-deleted companies together with the
+    /// total unfiltered count for pagination.
+    /// </summary>
+    Task<(List<Company> Companies, int TotalCount)> GetPagedAsync(
+        string? searchTerm, string sortColumn, string sortDirection, int page, int pageSize);
+
+    /// <summary>
+    /// Returns job, quote, customer, and wizard completion counts for each of the supplied
+    /// company IDs in three GROUP BY queries instead of N+1 individual lookups.
+    /// </summary>
+    Task<CompanyCountSummary> GetCountSummaryAsync(IReadOnlyList<int> companyIds);
+}

src/PowderCoating.Core/Interfaces/Services/IDashboardReadService.cs

@@ -0,0 +1,42 @@
+using PowderCoating.Core.Entities;
+
+namespace PowderCoating.Core.Interfaces.Services;
+
+/// <summary>
+/// Result record carrying all pre-fetched entity lists and aggregates needed to render the operator
+/// dashboard index view.  Raw entities are returned so the controller can apply in-memory
+/// filtering, grouping, and DTO projection without additional round-trips.
+/// </summary>
+public record DashboardIndexData(
+    List<Job> ActiveJobs,
+    decimal MonthlyRevenue,
+    List<Appointment> TodaysAppointments,
+    List<MaintenanceRecord> UpcomingMaintenance,
+    List<Quote> PendingQuotes,
+    List<Invoice> OpenInvoices,
+    decimal InvoicedThisMonth,
+    decimal CollectedThisMonth,
+    List<Payment> RecentPayments,
+    List<Quote> RecentQuotes,
+    List<Job> RecentJobs,
+    List<Job> JobsNeedingPowder,
+    List<Job> JobsWithOrderedPowder,
+    List<Bill> BillsDue,
+    string? TipOfTheDay
+);
+
+/// <summary>
+/// Read-only service for the dashboard.  All methods execute complex queries that require
+/// ThenInclude chains or navigation-property predicates beyond what the generic
+/// <see cref="IRepository{T}"/> can express.  Lives in Infrastructure so <c>ApplicationDbContext</c>
+/// is available; injected into the controller via DI.
+/// </summary>
+public interface IDashboardReadService
+{
+    /// <summary>Fetches all data needed to render the tenant operator dashboard.</summary>
+    /// <param name="today">The local date used for date-range predicates (today, start-of-month, etc.).</param>
+    Task<DashboardIndexData> GetIndexDataAsync(DateTime today);
+
+    /// <summary>Returns the total count of tenant users (CompanyId > 0) for the SuperAdmin dashboard.</summary>
+    Task<int> GetTotalUserCountAsync();
+}

src/PowderCoating.Infrastructure/Repositories/BillRepository.cs

@@ -89,4 +89,17 @@ public class BillRepository : Repository<Bill>, IBillRepository
             .Select(p => p.PaymentNumber)
             .FirstOrDefaultAsync();
     }
+
+    /// <inheritdoc/>
+    public async Task<List<Bill>> GetForDateRangeAsync(DateTime start, DateTime end)
+    {
+        return await _context.Bills
+            .Where(b => !b.IsDeleted && b.BillDate >= start && b.BillDate <= end)
+            .Include(b => b.Vendor)
+            .Include(b => b.LineItems.Where(li => !li.IsDeleted))
+                .ThenInclude(li => li.Account)
+            .Include(b => b.Payments.Where(p => !p.IsDeleted))
+            .OrderBy(b => b.BillDate)
+            .ToListAsync();
+    }
 }

src/PowderCoating.Infrastructure/Repositories/InventoryTransactionRepository.cs

@@ -0,0 +1,45 @@
+using Microsoft.EntityFrameworkCore;
+using PowderCoating.Core.Entities;
+using PowderCoating.Core.Enums;
+using PowderCoating.Core.Interfaces.Repositories;
+using PowderCoating.Infrastructure.Data;
+
+namespace PowderCoating.Infrastructure.Repositories;
+
+/// <summary>
+/// Typed repository for <see cref="InventoryTransaction"/> that adds a dynamic-filter
+/// ledger query on top of the generic <see cref="Repository{T}"/>.
+/// </summary>
+public class InventoryTransactionRepository : Repository<InventoryTransaction>, IInventoryTransactionRepository
+{
+    public InventoryTransactionRepository(ApplicationDbContext context) : base(context) { }
+
+    /// <inheritdoc/>
+    public async Task<List<InventoryTransaction>> GetForLedgerAsync(
+        int? itemId,
+        DateTime? from,
+        DateTime? to,
+        InventoryTransactionType? type)
+    {
+        var query = _context.InventoryTransactions
+            .AsNoTracking()
+            .Include(t => t.InventoryItem)
+            .Include(t => t.PurchaseOrder)
+            .Include(t => t.Job)
+            .Where(t => !t.IsDeleted);
+
+        if (itemId.HasValue)
+            query = query.Where(t => t.InventoryItemId == itemId.Value);
+        if (from.HasValue)
+            query = query.Where(t => t.TransactionDate >= from.Value);
+        if (to.HasValue)
+            query = query.Where(t => t.TransactionDate < to.Value.AddDays(1));
+        if (type.HasValue)
+            query = query.Where(t => t.TransactionType == type.Value);
+
+        return await query
+            .OrderByDescending(t => t.TransactionDate)
+            .Take(500)
+            .ToListAsync();
+    }
+}

src/PowderCoating.Infrastructure/Repositories/JobItemCoatRepository.cs

@@ -0,0 +1,52 @@
+using Microsoft.EntityFrameworkCore;
+using PowderCoating.Core.Entities;
+using PowderCoating.Core.Interfaces.Repositories;
+using PowderCoating.Infrastructure.Data;
+
+namespace PowderCoating.Infrastructure.Repositories;
+
+/// <summary>
+/// Typed repository for <see cref="JobItemCoat"/> that adds ThenInclude-based load methods the
+/// generic <see cref="Repository{T}"/> cannot express.
+/// </summary>
+public class JobItemCoatRepository : Repository<JobItemCoat>, IJobItemCoatRepository
+{
+    public JobItemCoatRepository(ApplicationDbContext context) : base(context) { }
+
+    /// <inheritdoc/>
+    public async Task<JobItemCoat?> LoadForOrderMarkingAsync(int id)
+    {
+        return await _context.JobItemCoats
+            .Include(c => c.JobItem).ThenInclude(i => i.Job).ThenInclude(j => j.Customer)
+            .Include(c => c.Vendor)
+            .Include(c => c.InventoryItem).ThenInclude(i => i!.PrimaryVendor)
+            .FirstOrDefaultAsync(c => c.Id == id);
+    }
+
+    /// <inheritdoc/>
+    public async Task<JobItemCoat?> LoadWithInventoryAsync(int id)
+    {
+        return await _context.JobItemCoats
+            .Include(c => c.InventoryItem)
+            .FirstOrDefaultAsync(c => c.Id == id);
+    }
+
+    /// <inheritdoc/>
+    public async Task<JobItemCoat?> LoadWithJobChainAsync(int id)
+    {
+        return await _context.JobItemCoats
+            .Include(c => c.JobItem).ThenInclude(i => i.Job)
+            .FirstOrDefaultAsync(c => c.Id == id);
+    }
+
+    /// <inheritdoc/>
+    public async Task<List<JobItemCoat>> GetCandidateCoatsForLinkingAsync(int excludeCoatId, int companyId)
+    {
+        return await _context.JobItemCoats
+            .Include(c => c.JobItem)
+            .Where(c => c.Id != excludeCoatId
+                     && c.InventoryItemId == null
+                     && c.JobItem.CompanyId == companyId)
+            .ToListAsync();
+    }
+}

src/PowderCoating.Infrastructure/Repositories/JobPhotoRepository.cs

@@ -0,0 +1,52 @@
+using Microsoft.EntityFrameworkCore;
+using PowderCoating.Core.Entities;
+using PowderCoating.Core.Interfaces.Repositories;
+using PowderCoating.Infrastructure.Data;
+
+namespace PowderCoating.Infrastructure.Repositories;
+
+/// <summary>
+/// Typed repository for <see cref="JobPhoto"/> that provides inventory-specific photo
+/// lookup queries requiring multi-level ThenInclude chains that the generic
+/// <see cref="Repository{T}"/> cannot express.
+/// </summary>
+public class JobPhotoRepository : Repository<JobPhoto>, IJobPhotoRepository
+{
+    public JobPhotoRepository(ApplicationDbContext context) : base(context) { }
+
+    /// <inheritdoc/>
+    public async Task<List<JobPhoto>> GetTaggedPhotosAsync(string? colorName, string? itemName)
+    {
+        var query = _context.JobPhotos
+            .AsNoTracking()
+            .Include(p => p.Job)
+                .ThenInclude(j => j!.Customer)
+            .Where(p => !p.IsDeleted && p.Tags != null && p.Tags != "");
+
+        if (!string.IsNullOrEmpty(colorName) && !string.IsNullOrEmpty(itemName) && colorName != itemName)
+            query = query.Where(p => p.Tags!.ToLower().Contains(colorName) || p.Tags!.ToLower().Contains(itemName));
+        else if (!string.IsNullOrEmpty(colorName))
+            query = query.Where(p => p.Tags!.ToLower().Contains(colorName));
+        else if (!string.IsNullOrEmpty(itemName))
+            query = query.Where(p => p.Tags!.ToLower().Contains(itemName));
+
+        return await query.OrderByDescending(p => p.UploadedDate).ToListAsync();
+    }
+
+    /// <inheritdoc/>
+    public async Task<List<JobPhoto>> GetPhotosByPowderItemAsync(int inventoryItemId)
+    {
+        return await _context.JobPhotos
+            .AsNoTracking()
+            .Include(p => p.Job)
+                .ThenInclude(j => j!.Customer)
+            .Include(p => p.Job)
+                .ThenInclude(j => j!.JobItems)
+                    .ThenInclude(ji => ji.Coats)
+            .Where(p => !p.IsDeleted &&
+                        p.Job != null &&
+                        p.Job.JobItems.Any(ji => ji.Coats.Any(c => c.InventoryItemId == inventoryItemId)))
+            .OrderByDescending(p => p.UploadedDate)
+            .ToListAsync();
+    }
+}

src/PowderCoating.Infrastructure/Repositories/JobRepository.cs

@@ -175,4 +175,16 @@ public class JobRepository : Repository<Job>, IJobRepository
             .AsNoTracking()
             .FirstOrDefaultAsync();
     }
+
+    /// <inheritdoc/>
+    public async Task<Job?> LoadForTemplateSnapshotAsync(int jobId)
+    {
+        return await _context.Jobs
+            .Where(j => j.Id == jobId && !j.IsDeleted)
+            .Include(j => j.JobItems.Where(i => !i.IsDeleted))
+                .ThenInclude(i => i.Coats.Where(c => !c.IsDeleted))
+            .Include(j => j.JobItems.Where(i => !i.IsDeleted))
+                .ThenInclude(i => i.PrepServices.Where(p => !p.IsDeleted))
+            .FirstOrDefaultAsync();
+    }
 }

src/PowderCoating.Infrastructure/Repositories/JobTemplateRepository.cs

@@ -0,0 +1,47 @@
+using Microsoft.EntityFrameworkCore;
+using PowderCoating.Core.Entities;
+using PowderCoating.Core.Interfaces.Repositories;
+using PowderCoating.Infrastructure.Data;
+
+namespace PowderCoating.Infrastructure.Repositories;
+
+/// <summary>
+/// Typed repository for <see cref="JobTemplate"/> that provides domain-specific multi-level
+/// include queries that the generic <see cref="Repository{T}"/> cannot express.
+/// The base class handles all standard CRUD operations; this class adds the read queries
+/// that require ThenInclude chains for items, coats, and prep services.
+/// </summary>
+public class JobTemplateRepository : Repository<JobTemplate>, IJobTemplateRepository
+{
+    public JobTemplateRepository(ApplicationDbContext context) : base(context) { }
+
+    /// <inheritdoc/>
+    public async Task<JobTemplate?> LoadForDetailsAsync(int id)
+    {
+        return await _context.JobTemplates
+            .Where(t => t.Id == id && !t.IsDeleted)
+            .Include(t => t.Customer)
+            .Include(t => t.Items.Where(i => !i.IsDeleted))
+                .ThenInclude(i => i.Coats.Where(c => !c.IsDeleted))
+                    .ThenInclude(c => c.InventoryItem)
+            .Include(t => t.Items.Where(i => !i.IsDeleted))
+                .ThenInclude(i => i.PrepServices.Where(p => !p.IsDeleted))
+                    .ThenInclude(p => p.PrepService)
+            .FirstOrDefaultAsync();
+    }
+
+    /// <inheritdoc/>
+    public async Task<List<JobTemplate>> GetAllActiveWithFullIncludesAsync()
+    {
+        return await _context.JobTemplates
+            .Where(t => !t.IsDeleted && t.IsActive)
+            .Include(t => t.Customer)
+            .Include(t => t.Items.Where(i => !i.IsDeleted))
+                .ThenInclude(i => i.Coats.Where(c => !c.IsDeleted))
+            .Include(t => t.Items.Where(i => !i.IsDeleted))
+                .ThenInclude(i => i.PrepServices.Where(p => !p.IsDeleted))
+                    .ThenInclude(p => p.PrepService)
+            .OrderBy(t => t.Name)
+            .ToListAsync();
+    }
+}

src/PowderCoating.Infrastructure/Repositories/NotificationLogRepository.cs

@@ -1,5 +1,6 @@
 using Microsoft.EntityFrameworkCore;
 using PowderCoating.Core.Entities;
+using PowderCoating.Core.Enums;
 using PowderCoating.Core.Interfaces.Repositories;
 using PowderCoating.Infrastructure.Data;
 
@@ -60,4 +61,69 @@ public class NotificationLogRepository : Repository<NotificationLog>, INotificat
             .Where(n => n.JobId == jobId)
             .OrderByDescending(n => n.SentAt)
             .ToListAsync();
+
+    /// <inheritdoc/>
+    public async Task<(List<NotificationLog> Items, int TotalCount)> GetPagedFilteredAsync(
+        int pageNumber, int pageSize,
+        string? searchTerm = null,
+        NotificationChannel? channel = null,
+        NotificationStatus? status = null,
+        NotificationType? type = null,
+        int? jobId = null,
+        string sortColumn = "SentAt",
+        string sortDirection = "desc")
+    {
+        var query = _dbSet
+            .AsNoTracking()
+            .Include(n => n.Customer)
+            .Include(n => n.Job)
+            .Include(n => n.Quote)
+            .AsQueryable();
+
+        if (jobId.HasValue)
+            query = query.Where(n => n.JobId == jobId.Value);
+
+        if (!string.IsNullOrWhiteSpace(searchTerm))
+        {
+            var s = searchTerm.ToLower();
+            query = query.Where(n =>
+                n.RecipientName.ToLower().Contains(s) ||
+                n.Recipient.ToLower().Contains(s) ||
+                (n.Subject != null && n.Subject.ToLower().Contains(s)) ||
+                (n.Job != null && n.Job.JobNumber.ToLower().Contains(s)) ||
+                (n.Quote != null && n.Quote.QuoteNumber.ToLower().Contains(s)));
+        }
+
+        if (channel.HasValue)
+            query = query.Where(n => n.Channel == channel.Value);
+
+        if (status.HasValue)
+            query = query.Where(n => n.Status == status.Value);
+
+        if (type.HasValue)
+            query = query.Where(n => n.NotificationType == type.Value);
+
+        var totalCount = await query.CountAsync();
+
+        query = (sortColumn, sortDirection) switch
+        {
+            ("RecipientName", "asc") => query.OrderBy(n => n.RecipientName),
+            ("RecipientName", _)     => query.OrderByDescending(n => n.RecipientName),
+            ("Channel",       "asc") => query.OrderBy(n => n.Channel),
+            ("Channel",       _)     => query.OrderByDescending(n => n.Channel),
+            ("Status",        "asc") => query.OrderBy(n => n.Status),
+            ("Status",        _)     => query.OrderByDescending(n => n.Status),
+            ("Type",          "asc") => query.OrderBy(n => n.NotificationType),
+            ("Type",          _)     => query.OrderByDescending(n => n.NotificationType),
+            (_,               "asc") => query.OrderBy(n => n.SentAt),
+            _                        => query.OrderByDescending(n => n.SentAt)
+        };
+
+        var items = await query
+            .Skip((pageNumber - 1) * pageSize)
+            .Take(pageSize)
+            .ToListAsync();
+
+        return (items, totalCount);
+    }
 }

src/PowderCoating.Infrastructure/Repositories/PlainRepository.cs

@@ -0,0 +1,73 @@
+using System.Linq.Expressions;
+using Microsoft.EntityFrameworkCore;
+using PowderCoating.Core.Interfaces;
+using PowderCoating.Infrastructure.Data;
+
+namespace PowderCoating.Infrastructure.Repositories;
+
+/// <summary>
+/// Generic repository for platform-level entities that do not inherit BaseEntity
+/// (Announcement, BannedIp, DashboardTip, ReleaseNote).  No global query filters apply
+/// to these entities, so no IgnoreQueryFilters support is needed.  All writes are staged
+/// in the EF change tracker — call IUnitOfWork.CompleteAsync() to flush.
+/// </summary>
+public class PlainRepository<T> : IPlainRepository<T> where T : class
+{
+    protected readonly ApplicationDbContext _context;
+    protected readonly DbSet<T> _dbSet;
+
+    public PlainRepository(ApplicationDbContext context)
+    {
+        _context = context;
+        _dbSet = context.Set<T>();
+    }
+
+    public virtual async Task<T?> GetByIdAsync(int id)
+        => await _dbSet.FindAsync(id);
+
+    public virtual async Task<IEnumerable<T>> GetAllAsync()
+        => await _dbSet.ToListAsync();
+
+    public virtual async Task<IEnumerable<T>> FindAsync(Expression<Func<T, bool>> predicate)
+        => await _dbSet.Where(predicate).ToListAsync();
+
+    public virtual async Task<T?> FirstOrDefaultAsync(Expression<Func<T, bool>> predicate)
+        => await _dbSet.FirstOrDefaultAsync(predicate);
+
+    public virtual async Task<bool> AnyAsync(Expression<Func<T, bool>> predicate)
+        => await _dbSet.AnyAsync(predicate);
+
+    public virtual async Task<int> CountAsync(Expression<Func<T, bool>>? predicate = null)
+        => predicate == null ? await _dbSet.CountAsync() : await _dbSet.CountAsync(predicate);
+
+    public virtual async Task<T> AddAsync(T entity)
+    {
+        await _dbSet.AddAsync(entity);
+        return entity;
+    }
+
+    public virtual async Task<IEnumerable<T>> AddRangeAsync(IEnumerable<T> entities)
+    {
+        await _dbSet.AddRangeAsync(entities);
+        return entities;
+    }
+
+    public virtual Task UpdateAsync(T entity)
+    {
+        _dbSet.Update(entity);
+        return Task.CompletedTask;
+    }
+
+    public virtual async Task DeleteAsync(T entity)
+    {
+        _dbSet.Remove(entity);
+        await Task.CompletedTask;
+    }
+
+    public virtual async Task DeleteAsync(int id)
+    {
+        var entity = await GetByIdAsync(id);
+        if (entity != null)
+            await DeleteAsync(entity);
+    }
+}

src/PowderCoating.Infrastructure/Repositories/PowderUsageLogRepository.cs

@@ -0,0 +1,39 @@
+using Microsoft.EntityFrameworkCore;
+using PowderCoating.Core.Entities;
+using PowderCoating.Core.Interfaces.Repositories;
+using PowderCoating.Infrastructure.Data;
+
+namespace PowderCoating.Infrastructure.Repositories;
+
+/// <summary>
+/// Typed repository for <see cref="PowderUsageLog"/> that adds a dynamic-filter
+/// ledger query on top of the generic <see cref="Repository{T}"/>.
+/// </summary>
+public class PowderUsageLogRepository : Repository<PowderUsageLog>, IPowderUsageLogRepository
+{
+    public PowderUsageLogRepository(ApplicationDbContext context) : base(context) { }
+
+    /// <inheritdoc/>
+    public async Task<List<PowderUsageLog>> GetForLedgerAsync(int? itemId, DateTime? from, DateTime? to)
+    {
+        var query = _context.PowderUsageLogs
+            .AsNoTracking()
+            .Include(u => u.Job)
+                .ThenInclude(j => j!.Customer)
+            .Include(u => u.InventoryItem)
+            .Include(u => u.JobItemCoat)
+            .Where(u => !u.IsDeleted);
+
+        if (itemId.HasValue)
+            query = query.Where(u => u.InventoryItemId == itemId.Value);
+        if (from.HasValue)
+            query = query.Where(u => u.RecordedAt >= from.Value);
+        if (to.HasValue)
+            query = query.Where(u => u.RecordedAt < to.Value.AddDays(1));
+
+        return await query
+            .OrderByDescending(u => u.RecordedAt)
+            .Take(500)
+            .ToListAsync();
+    }
+}

src/PowderCoating.Infrastructure/Repositories/UnitOfWork.cs

@@ -41,14 +41,14 @@ public class UnitOfWork : IUnitOfWork
     private IRepository<AiItemPrediction>? _aiItemPredictions;
 
     // Powder Insights
-    private IRepository<PowderUsageLog>? _powderUsageLogs;
+    private IPowderUsageLogRepository? _powderUsageLogs;
 
     // Core repositories
     private ICustomerRepository? _customers;
     private IJobRepository? _jobs;
     private IRepository<JobDailyPriority>? _jobDailyPriorities;
     private IRepository<JobItem>? _jobItems;
-    private IRepository<JobItemCoat>? _jobItemCoats;
+    private IJobItemCoatRepository? _jobItemCoats;
     private IRepository<JobItemPrepService>? _jobItemPrepServices;
     private IRepository<JobChangeHistory>? _jobChangeHistories;
     private IRepository<JobPrepService>? _jobPrepServices;
@@ -59,13 +59,13 @@ public class UnitOfWork : IUnitOfWork
     private IRepository<QuoteItemPrepService>? _quoteItemPrepServices;
     private IRepository<QuoteChangeHistory>? _quoteChangeHistories;
     private IRepository<InventoryItem>? _inventoryItems;
-    private IRepository<InventoryTransaction>? _inventoryTransactions;
+    private IInventoryTransactionRepository? _inventoryTransactions;
     private IRepository<Equipment>? _equipment;
     private IRepository<OvenCost>? _ovenCosts;
     private IRepository<CompanyBlastSetup>? _blastSetups;
     private IRepository<MaintenanceRecord>? _maintenanceRecords;
     private IRepository<Vendor>? _vendors;
-    private IRepository<JobPhoto>? _jobPhotos;
+    private IJobPhotoRepository? _jobPhotos;
     private IRepository<JobNote>? _jobNotes;
     private IRepository<CustomerNote>? _customerNotes;
     private IRepository<JobStatusHistory>? _jobStatusHistory;
@@ -97,13 +97,21 @@ public class UnitOfWork : IUnitOfWork
     private IRepository<SubscriptionPlanConfig>? _subscriptionPlanConfigs;
 
     // Job Templates
-    private IRepository<JobTemplate>? _jobTemplates;
+    private IJobTemplateRepository? _jobTemplates;
     private IRepository<JobTemplateItem>? _jobTemplateItems;
     private IRepository<JobTemplateItemCoat>? _jobTemplateItemCoats;
     private IRepository<JobTemplateItemPrepService>? _jobTemplateItemPrepServices;
 
+    // Platform content
+    private IPlainRepository<Announcement>? _announcements;
+    private IPlainRepository<BannedIp>? _bannedIps;
+    private IPlainRepository<DashboardTip>? _dashboardTips;
+    private IRepository<InAppNotification>? _inAppNotifications;
+    private IPlainRepository<ReleaseNote>? _releaseNotes;
+
     // Bug Reports
     private IRepository<BugReport>? _bugReports;
+    private IRepository<BugReportAttachment>? _bugReportAttachments;
     private IRepository<ContactSubmission>? _contactSubmissions;
     private IRepository<ManufacturerLookupPattern>? _manufacturerLookupPatterns;
 
@@ -169,8 +177,8 @@ public class UnitOfWork : IUnitOfWork
 
     // Powder Insights
     /// <summary>Repository for <see cref="PowderUsageLog"/> records capturing per-coat powder consumption; used by powder-usage analytics.</summary>
-    public IRepository<PowderUsageLog> PowderUsageLogs =>
+    public IPowderUsageLogRepository PowderUsageLogs =>
-        _powderUsageLogs ??= new Repository<PowderUsageLog>(_context);
+        _powderUsageLogs ??= new PowderUsageLogRepository(_context);
 
     // Core repositories
     /// <summary>Repository for <see cref="Customer"/> records (commercial and non-commercial); tenant-filtered with soft delete.</summary>
@@ -190,8 +198,8 @@ public class UnitOfWork : IUnitOfWork
         _jobItems ??= new Repository<JobItem>(_context);
 
     /// <summary>Repository for <see cref="JobItemCoat"/> powder coat passes; tenant-filtered with soft delete.</summary>
-    public IRepository<JobItemCoat> JobItemCoats =>
+    public IJobItemCoatRepository JobItemCoats =>
-        _jobItemCoats ??= new Repository<JobItemCoat>(_context);
+        _jobItemCoats ??= new JobItemCoatRepository(_context);
     public IRepository<JobItemPrepService> JobItemPrepServices =>
         _jobItemPrepServices ??= new Repository<JobItemPrepService>(_context);
 
@@ -232,8 +240,8 @@ public class UnitOfWork : IUnitOfWork
         _inventoryItems ??= new Repository<InventoryItem>(_context);
 
     /// <summary>Repository for <see cref="InventoryTransaction"/> stock movements; tenant-filtered with soft delete.</summary>
-    public IRepository<InventoryTransaction> InventoryTransactions =>
+    public IInventoryTransactionRepository InventoryTransactions =>
-        _inventoryTransactions ??= new Repository<InventoryTransaction>(_context);
+        _inventoryTransactions ??= new InventoryTransactionRepository(_context);
 
     /// <summary>Repository for <see cref="Equipment"/> records (ovens, sandblasters, booths); tenant-filtered with soft delete.</summary>
     public IRepository<Equipment> Equipment =>
@@ -256,8 +264,8 @@ public class UnitOfWork : IUnitOfWork
         _vendors ??= new Repository<Vendor>(_context);
 
     /// <summary>Repository for <see cref="JobPhoto"/> attachments; tenant-filtered with soft delete.</summary>
-    public IRepository<JobPhoto> JobPhotos =>
+    public IJobPhotoRepository JobPhotos =>
-        _jobPhotos ??= new Repository<JobPhoto>(_context);
+        _jobPhotos ??= new JobPhotoRepository(_context);
 
     /// <summary>Repository for <see cref="JobNote"/> free-text staff notes on jobs; tenant-filtered with soft delete.</summary>
     public IRepository<JobNote> JobNotes =>
@@ -372,11 +380,35 @@ public class UnitOfWork : IUnitOfWork
     public IRepository<SubscriptionPlanConfig> SubscriptionPlanConfigs =>
         _subscriptionPlanConfigs ??= new Repository<SubscriptionPlanConfig>(_context);
 
+    // Platform content
+    /// <summary>Repository for <see cref="Announcement"/> platform-wide announcements; no tenant filter, no soft delete.</summary>
+    public IPlainRepository<Announcement> Announcements =>
+        _announcements ??= new PlainRepository<Announcement>(_context);
+
+    /// <summary>Repository for <see cref="BannedIp"/> IP ban records; no tenant filter, no soft delete.</summary>
+    public IPlainRepository<BannedIp> BannedIps =>
+        _bannedIps ??= new PlainRepository<BannedIp>(_context);
+
+    /// <summary>Repository for <see cref="DashboardTip"/> rotating tip-of-the-day entries; no tenant filter, no soft delete.</summary>
+    public IPlainRepository<DashboardTip> DashboardTips =>
+        _dashboardTips ??= new PlainRepository<DashboardTip>(_context);
+
+    /// <summary>Repository for <see cref="InAppNotification"/> bell-notification records; tenant-filtered with soft delete.</summary>
+    public IRepository<InAppNotification> InAppNotifications =>
+        _inAppNotifications ??= new Repository<InAppNotification>(_context);
+
+    /// <summary>Repository for <see cref="ReleaseNote"/> platform changelog entries; no tenant filter, no soft delete.</summary>
+    public IPlainRepository<ReleaseNote> ReleaseNotes =>
+        _releaseNotes ??= new PlainRepository<ReleaseNote>(_context);
+
     // Bug Reports
     /// <summary>Repository for <see cref="BugReport"/> user-submitted bug reports; tenant-filtered with soft delete.</summary>
     public IRepository<BugReport> BugReports =>
         _bugReports ??= new Repository<BugReport>(_context);
 
+    public IRepository<BugReportAttachment> BugReportAttachments =>
+        _bugReportAttachments ??= new Repository<BugReportAttachment>(_context);
+
     // Contact Us
     /// <summary>Repository for <see cref="ContactSubmission"/> contact form submissions; platform admins see all, company users see their own.</summary>
     public IRepository<ContactSubmission> ContactSubmissions =>
@@ -397,8 +429,8 @@ public class UnitOfWork : IUnitOfWork
 
     // Job Templates
     /// <summary>Repository for <see cref="JobTemplate"/> reusable job blueprints; tenant-filtered with soft delete.</summary>
-    public IRepository<JobTemplate> JobTemplates =>
+    public IJobTemplateRepository JobTemplates =>
-        _jobTemplates ??= new Repository<JobTemplate>(_context);
+        _jobTemplates ??= new JobTemplateRepository(_context);
 
     /// <summary>Repository for <see cref="JobTemplateItem"/> item definitions within a job template.</summary>
     public IRepository<JobTemplateItem> JobTemplateItems =>

src/PowderCoating.Infrastructure/Services/AiUsageReportService.cs

@@ -0,0 +1,55 @@
+using Microsoft.EntityFrameworkCore;
+using PowderCoating.Application.Interfaces;
+using PowderCoating.Infrastructure.Data;
+
+namespace PowderCoating.Infrastructure.Services;
+
+/// <summary>
+/// Implements <see cref="IAiUsageReportService"/> by querying <c>AiUsageLogs</c> and
+/// <c>QuotePhotos</c> directly via <c>ApplicationDbContext</c>. Both tables either are
+/// not BaseEntity (AiUsageLog) or require cross-tenant GROUP BY aggregations that must
+/// execute in SQL; this service encapsulates those queries so the controller stays clean.
+/// </summary>
+public class AiUsageReportService : IAiUsageReportService
+{
+    private readonly ApplicationDbContext _context;
+
+    public AiUsageReportService(ApplicationDbContext context)
+    {
+        _context = context;
+    }
+
+    /// <inheritdoc/>
+    public async Task<AiUsageReportData> GetReportDataAsync()
+    {
+        var now = DateTime.UtcNow;
+        var todayStart  = now.Date;
+        var last7Start  = todayStart.AddDays(-7);
+        var last30Start = todayStart.AddDays(-30);
+
+        var usageByCompany = await _context.AiUsageLogs
+            .GroupBy(l => l.CompanyId)
+            .Select(g => new AiCompanyUsage(
+                g.Key,
+                g.Count(l => l.CalledAt >= todayStart),
+                g.Count(l => l.CalledAt >= last7Start),
+                g.Count(l => l.CalledAt >= last30Start),
+                g.Count()))
+            .ToListAsync();
+
+        var featureStats = await _context.AiUsageLogs
+            .Where(l => l.CalledAt >= last30Start)
+            .GroupBy(l => new { l.CompanyId, l.Feature })
+            .Select(g => new AiFeatureStat(g.Key.CompanyId, g.Key.Feature, g.Count()))
+            .ToListAsync();
+
+        var photoCounts = await _context.QuotePhotos
+            .IgnoreQueryFilters()
+            .Where(p => p.IsAiAnalysisPhoto && !p.IsDeleted)
+            .GroupBy(p => p.CompanyId)
+            .Select(g => new { CompanyId = g.Key, Count = g.Count() })
+            .ToDictionaryAsync(x => x.CompanyId, x => x.Count);
+
+        return new AiUsageReportData(usageByCompany, featureStats, photoCounts);
+    }
+}

src/PowderCoating.Infrastructure/Services/AuditLogService.cs

@@ -0,0 +1,40 @@
+using Microsoft.EntityFrameworkCore;
+using PowderCoating.Core.Entities;
+using PowderCoating.Core.Interfaces.Services;
+using PowderCoating.Infrastructure.Data;
+
+namespace PowderCoating.Infrastructure.Services;
+
+/// <summary>
+/// Concrete implementation of <see cref="IAuditLogService"/> that writes <see cref="AuditLog"/>
+/// entries via <see cref="ApplicationDbContext"/> directly. <c>AuditLog</c> does not inherit
+/// from <c>BaseEntity</c> so it cannot be managed through the generic repository; this service
+/// owns that write path and keeps <c>ApplicationDbContext</c> out of controller constructors.
+/// </summary>
+public class AuditLogService : IAuditLogService
+{
+    private readonly ApplicationDbContext _context;
+
+    public AuditLogService(ApplicationDbContext context)
+    {
+        _context = context;
+    }
+
+    /// <inheritdoc/>
+    public async Task LogAsync(AuditLog entry)
+    {
+        _context.AuditLogs.Add(entry);
+        await _context.SaveChangesAsync();
+    }
+
+    /// <inheritdoc/>
+    public async Task<List<AuditLog>> GetUserActivityAsync(string userId, int limit = 50)
+    {
+        return await _context.AuditLogs
+            .AsNoTracking()
+            .Where(l => l.UserId == userId && l.EntityType == "ApplicationUser")
+            .OrderByDescending(l => l.Timestamp)
+            .Take(limit)
+            .ToListAsync();
+    }
+}

src/PowderCoating.Infrastructure/Services/CompanyDataPurgeService.cs

@@ -0,0 +1,180 @@
+using Microsoft.EntityFrameworkCore;
+using PowderCoating.Core.Interfaces.Services;
+using PowderCoating.Infrastructure.Data;
+
+namespace PowderCoating.Infrastructure.Services;
+
+/// <summary>
+/// Implements <see cref="ICompanyDataPurgeService"/> via bulk <c>ExecuteDeleteAsync</c> against
+/// <see cref="ApplicationDbContext"/> directly.  This is an intentional exception to the
+/// IUnitOfWork pattern — identical to the rationale for <c>DataPurgeController</c> in the
+/// documented permanent exceptions list.  Each <c>ExecuteDeleteAsync</c> call commits immediately
+/// at the database level so no <c>SaveChangesAsync</c> is needed for the bulk tiers.
+/// </summary>
+public class CompanyDataPurgeService : ICompanyDataPurgeService
+{
+    private readonly ApplicationDbContext _context;
+
+    public CompanyDataPurgeService(ApplicationDbContext context)
+    {
+        _context = context;
+    }
+
+    /// <inheritdoc/>
+    public async Task DeleteAllBusinessDataAsync(int companyId, IReadOnlyList<string> companyUserIds)
+    {
+        // ── Tier 1: Leaf children ─────────────────────────────────────────────
+        await _context.JobItemPrepServices.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.JobItemCoats.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.QuoteItemPrepServices.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.QuoteItemCoats.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+
+        // Announcement dismissals referencing the company's users or company-targeted announcements
+        var announcementIds = await _context.Announcements
+            .Where(a => a.TargetCompanyId == companyId).Select(a => a.Id).ToListAsync();
+        await _context.AnnouncementDismissals.IgnoreQueryFilters()
+            .Where(x => companyUserIds.Contains(x.UserId) || announcementIds.Contains(x.AnnouncementId))
+            .ExecuteDeleteAsync();
+
+        // ── Tier 2: Mid-level children ────────────────────────────────────────
+        await _context.JobItems.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.QuoteItems.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.JobStatusHistory.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.JobChangeHistories.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.JobPhotos.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.JobNotes.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.JobDailyPriorities.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.QuoteChangeHistories.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.CustomerNotes.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.InventoryTransactions.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.MaintenanceRecords.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.BillLineItems.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.BillPayments.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.Payments.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.InvoiceItems.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.JobPrepServices.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.QuotePrepServices.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+
+        // ── Tier 3: Top-level company entities ───────────────────────────────
+        await _context.Invoices.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.Appointments.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.Jobs.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.Quotes.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.Customers.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.Bills.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.Expenses.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.Vendors.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.InventoryItems.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.Equipment.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.OvenCosts.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.CatalogItems.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.Accounts.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.NotificationLogs.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.NotificationTemplates.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.Announcements.Where(x => x.TargetCompanyId == companyId).ExecuteDeleteAsync();
+        await _context.BugReports.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.ShopWorkers.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.PrepServices.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+
+        // ── Tier 4: Company configs and lookup tables ─────────────────────────
+        await _context.CatalogCategories.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.InventoryCategoryLookups.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.JobStatusLookups.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.JobPriorityLookups.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.QuoteStatusLookups.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.AppointmentStatusLookups.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.AppointmentTypeLookups.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.PricingTiers.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.CompanyOperatingCosts.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.CompanyPreferences.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        // Note: company record and users are left for the caller to handle via UserManager and UnitOfWork
+    }
+
+    /// <inheritdoc/>
+    public async Task ResetBusinessDataAsync(int companyId)
+    {
+        // ── Tier 0: Grandchildren ─────────────────────────────────────────────
+        await _context.JobTemplateItemPrepServices.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.JobTemplateItemCoats.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.JobItemPrepServices.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.JobItemCoats.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.QuoteItemPrepServices.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.QuoteItemCoats.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.GiftCertificateRedemptions.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.CreditMemoApplications.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.OvenBatchItems.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+
+        var announcementIds = await _context.Announcements
+            .Where(a => a.TargetCompanyId == companyId).Select(a => a.Id).ToListAsync();
+        if (announcementIds.Count > 0)
+            await _context.AnnouncementDismissals.IgnoreQueryFilters()
+                .Where(x => announcementIds.Contains(x.AnnouncementId))
+                .ExecuteDeleteAsync();
+
+        // ── Tier 1: Children ──────────────────────────────────────────────────
+        await _context.JobTemplateItems.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.JobItems.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.QuoteItems.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.JobStatusHistory.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.JobChangeHistories.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.JobPhotos.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.JobNotes.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.JobDailyPriorities.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.JobTimeEntries.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.JobPrepServices.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.ReworkRecords.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.QuoteChangeHistories.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.QuotePrepServices.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.QuotePhotos.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.CustomerNotes.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.InventoryTransactions.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.MaintenanceRecords.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.BillLineItems.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.BillPayments.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.Payments.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.Deposits.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.InvoiceItems.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.PurchaseOrderItems.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.AiItemPredictions.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.PowderUsageLogs.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.ShopWorkerRoleCosts.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.OvenBatches.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.Refunds.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.CreditMemos.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.GiftCertificates.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+
+        // ── Tier 2: Top-level business entities ──────────────────────────────
+        await _context.Invoices.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.Appointments.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.Jobs.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.JobTemplates.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.Quotes.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.Customers.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.Bills.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.PurchaseOrders.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.Expenses.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.Vendors.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.CatalogItems.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.InventoryItems.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.Equipment.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.OvenCosts.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.Accounts.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.NotificationLogs.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.ShopWorkers.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.PrepServices.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.CatalogCategories.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.InventoryCategoryLookups.IgnoreQueryFilters().Where(x => x.CompanyId == companyId).ExecuteDeleteAsync();
+        await _context.Announcements.Where(x => x.TargetCompanyId == companyId).ExecuteDeleteAsync();
+
+        // Clear QuickBooks migration wizard progress (tracked update, not bulk delete)
+        var prefs = await _context.CompanyPreferences
+            .IgnoreQueryFilters()
+            .FirstOrDefaultAsync(p => p.CompanyId == companyId);
+        if (prefs?.QbMigrationStateJson != null)
+        {
+            prefs.QbMigrationStateJson = null;
+            prefs.UpdatedAt = DateTime.UtcNow;
+            await _context.SaveChangesAsync();
+        }
+    }
+}

src/PowderCoating.Infrastructure/Services/CompanyListService.cs

@@ -0,0 +1,103 @@
+using Microsoft.EntityFrameworkCore;
+using PowderCoating.Core.Entities;
+using PowderCoating.Core.Interfaces.Services;
+using PowderCoating.Infrastructure.Data;
+
+namespace PowderCoating.Infrastructure.Services;
+
+/// <summary>
+/// Implements <see cref="ICompanyListService"/> using <see cref="ApplicationDbContext"/> directly.
+/// Queries require <c>IgnoreQueryFilters()</c> (to bypass the tenant filter and see all companies),
+/// dynamic sort expressions, and cross-entity GROUP BY aggregations — all of which are beyond the
+/// generic <see cref="PowderCoating.Core.Interfaces.IRepository{T}"/>.
+/// </summary>
+public class CompanyListService : ICompanyListService
+{
+    private readonly ApplicationDbContext _context;
+
+    public CompanyListService(ApplicationDbContext context)
+    {
+        _context = context;
+    }
+
+    /// <inheritdoc/>
+    public async Task<(List<Company> Companies, int TotalCount)> GetPagedAsync(
+        string? searchTerm, string sortColumn, string sortDirection, int page, int pageSize)
+    {
+        var query = _context.Companies
+            .AsNoTracking()
+            .IgnoreQueryFilters()
+            .Where(c => !c.IsDeleted)
+            .AsQueryable();
+
+        if (!string.IsNullOrWhiteSpace(searchTerm))
+        {
+            var s = searchTerm.ToLower();
+            query = query.Where(c =>
+                c.CompanyName.ToLower().Contains(s) ||
+                (c.CompanyCode != null && c.CompanyCode.ToLower().Contains(s)) ||
+                (c.PrimaryContactEmail != null && c.PrimaryContactEmail.ToLower().Contains(s)) ||
+                (c.Phone != null && c.Phone.ToLower().Contains(s)));
+        }
+
+        query = (sortColumn, sortDirection == "asc") switch
+        {
+            ("CompanyName", true)  => query.OrderBy(c => c.CompanyName),
+            ("CompanyName", false) => query.OrderByDescending(c => c.CompanyName),
+            ("Plan", true)         => query.OrderBy(c => c.SubscriptionPlan),
+            ("Plan", false)        => query.OrderByDescending(c => c.SubscriptionPlan),
+            ("Status", true)       => query.OrderBy(c => c.IsActive),
+            ("Status", false)      => query.OrderByDescending(c => c.IsActive),
+            ("Created", true)      => query.OrderBy(c => c.CreatedAt),
+            ("Created", false)     => query.OrderByDescending(c => c.CreatedAt),
+            _                      => query.OrderBy(c => c.CompanyName)
+        };
+
+        var totalCount = await query.CountAsync();
+
+        var companies = await query
+            .Include(c => c.Users)
+            .Skip((page - 1) * pageSize)
+            .Take(pageSize)
+            .ToListAsync();
+
+        return (companies, totalCount);
+    }
+
+    /// <inheritdoc/>
+    public async Task<CompanyCountSummary> GetCountSummaryAsync(IReadOnlyList<int> companyIds)
+    {
+        var jobCounts = await _context.Jobs
+            .IgnoreQueryFilters()
+            .Where(j => companyIds.Contains(j.CompanyId) && !j.IsDeleted)
+            .GroupBy(j => j.CompanyId)
+            .Select(g => new { g.Key, Count = g.Count() })
+            .ToDictionaryAsync(x => x.Key, x => x.Count);
+
+        var quoteCounts = await _context.Quotes
+            .IgnoreQueryFilters()
+            .Where(q => companyIds.Contains(q.CompanyId) && !q.IsDeleted)
+            .GroupBy(q => q.CompanyId)
+            .Select(g => new { g.Key, Count = g.Count() })
+            .ToDictionaryAsync(x => x.Key, x => x.Count);
+
+        var customerCounts = await _context.Customers
+            .IgnoreQueryFilters()
+            .Where(c => companyIds.Contains(c.CompanyId) && !c.IsDeleted)
+            .GroupBy(c => c.CompanyId)
+            .Select(g => new { g.Key, Count = g.Count() })
+            .ToDictionaryAsync(x => x.Key, x => x.Count);
+
+        var wizardRaw = await _context.CompanyPreferences
+            .IgnoreQueryFilters()
+            .Where(p => companyIds.Contains(p.CompanyId) && p.SetupWizardCompleted)
+            .Select(p => new { p.CompanyId, p.SetupWizardCompletedAt, p.SetupWizardCompletedByName })
+            .ToListAsync();
+
+        var wizardInfo = wizardRaw.ToDictionary(
+            x => x.CompanyId,
+            x => new CompanyWizardInfo(true, x.SetupWizardCompletedAt, x.SetupWizardCompletedByName));
+
+        return new CompanyCountSummary(jobCounts, quoteCounts, customerCounts, wizardInfo);
+    }
+}

src/PowderCoating.Infrastructure/Services/DashboardReadService.cs

@@ -0,0 +1,225 @@
+using Microsoft.EntityFrameworkCore;
+using PowderCoating.Core.Entities;
+using PowderCoating.Core.Enums;
+using PowderCoating.Core.Interfaces.Services;
+using PowderCoating.Infrastructure.Data;
+
+namespace PowderCoating.Infrastructure.Services;
+
+/// <summary>
+/// Implements <see cref="IDashboardReadService"/> using <see cref="ApplicationDbContext"/> directly.
+/// All queries require ThenInclude chains or navigation-property predicates (e.g. JobStatus.StatusCode)
+/// that cannot be expressed through the generic <see cref="PowderCoating.Core.Interfaces.IRepository{T}"/>.
+/// </summary>
+public class DashboardReadService : IDashboardReadService
+{
+    private static readonly string[] CompletedStatusCodes =
+    [
+        "COMPLETED",
+        "READY_FOR_PICKUP",
+        "DELIVERED",
+        "CANCELLED"
+    ];
+
+    private readonly ApplicationDbContext _context;
+
+    public DashboardReadService(ApplicationDbContext context)
+    {
+        _context = context;
+    }
+
+    /// <inheritdoc/>
+    public async Task<DashboardIndexData> GetIndexDataAsync(DateTime today)
+    {
+        var startOfMonth = new DateTime(today.Year, today.Month, 1);
+        var endOfMonth = startOfMonth.AddMonths(1).AddDays(-1);
+        var tomorrow = today.AddDays(1);
+        var lookAheadDate = today.AddDays(7);
+        var last30Days = today.AddDays(-30);
+
+        var openInvoiceStatuses = new[] { InvoiceStatus.Sent, InvoiceStatus.PartiallyPaid, InvoiceStatus.Overdue };
+
+        // All active jobs (for today/overdue/in-progress panels)
+        var activeJobs = await _context.Jobs
+            .AsNoTracking()
+            .Include(j => j.Customer)
+            .Include(j => j.AssignedUser)
+            .Include(j => j.JobStatus)
+            .Include(j => j.JobPriority)
+            .Where(j => !CompletedStatusCodes.Contains(j.JobStatus.StatusCode))
+            .ToListAsync();
+
+        // Monthly revenue — sum completed jobs updated in current month
+        var monthlyRevenue = await _context.Jobs
+            .Include(j => j.JobStatus)
+            .Where(j => CompletedStatusCodes.Contains(j.JobStatus.StatusCode)
+                     && j.UpdatedAt >= startOfMonth
+                     && j.UpdatedAt <= endOfMonth)
+            .SumAsync(j => j.FinalPrice);
+
+        // Today's appointments (non-cancelled)
+        var todaysAppointments = await _context.Appointments
+            .AsNoTracking()
+            .Include(a => a.Customer)
+            .Include(a => a.AppointmentType)
+            .Include(a => a.AppointmentStatus)
+            .Include(a => a.AssignedUser)
+            .Where(a => a.ScheduledStartTime >= today && a.ScheduledStartTime < tomorrow
+                     && a.AppointmentStatus.StatusCode != "CANCELLED")
+            .OrderBy(a => a.ScheduledStartTime)
+            .ToListAsync();
+
+        // Upcoming/overdue maintenance
+        var upcomingMaintenance = await _context.MaintenanceRecords
+            .AsNoTracking()
+            .Include(m => m.Equipment)
+            .Include(m => m.AssignedUser)
+            .Where(m => (m.Status == MaintenanceStatus.Scheduled
+                      || m.Status == MaintenanceStatus.InProgress
+                      || m.Status == MaintenanceStatus.Overdue)
+                     && (m.Status == MaintenanceStatus.Overdue || m.ScheduledDate <= lookAheadDate))
+            .OrderBy(m => m.Status == MaintenanceStatus.Overdue ? 0 : 1)
+            .ThenByDescending(m => m.Priority)
+            .ThenBy(m => m.ScheduledDate)
+            .Take(10)
+            .ToListAsync();
+
+        // Pending quotes (SENT status)
+        var pendingQuotes = await _context.Quotes
+            .AsNoTracking()
+            .Include(q => q.Customer)
+            .Include(q => q.QuoteStatus)
+            .Where(q => q.QuoteStatus.StatusCode == "SENT")
+            .ToListAsync();
+
+        // Open invoices (for AR aging + overdue list)
+        var openInvoices = await _context.Invoices
+            .AsNoTracking()
+            .Include(i => i.Customer)
+            .Where(i => openInvoiceStatuses.Contains(i.Status))
+            .ToListAsync();
+
+        // Invoiced this month
+        var invoicedThisMonth = await _context.Invoices
+            .Where(i => i.Status != InvoiceStatus.Draft
+                     && i.Status != InvoiceStatus.Voided
+                     && i.Status != InvoiceStatus.WrittenOff
+                     && i.InvoiceDate >= startOfMonth
+                     && i.InvoiceDate <= endOfMonth)
+            .SumAsync(i => i.Total);
+
+        // Collected this month
+        var collectedThisMonth = await _context.Payments
+            .Where(p => p.PaymentDate >= startOfMonth && p.PaymentDate <= endOfMonth)
+            .SumAsync(p => p.Amount);
+
+        // Recent payments with Invoice → Customer
+        var recentPayments = await _context.Payments
+            .AsNoTracking()
+            .Include(p => p.Invoice).ThenInclude(i => i!.Customer)
+            .OrderByDescending(p => p.PaymentDate)
+            .Take(6)
+            .ToListAsync();
+
+        // Recent quotes (last 30 days)
+        var recentQuotes = await _context.Quotes
+            .AsNoTracking()
+            .Include(q => q.Customer)
+            .Include(q => q.QuoteStatus)
+            .Where(q => q.CreatedAt >= last30Days)
+            .OrderByDescending(q => q.CreatedAt)
+            .Take(5)
+            .ToListAsync();
+
+        // Recent jobs (last 30 days)
+        var recentJobs = await _context.Jobs
+            .AsNoTracking()
+            .Include(j => j.Customer)
+            .Include(j => j.JobStatus)
+            .Where(j => j.CreatedAt >= last30Days)
+            .OrderByDescending(j => j.CreatedAt)
+            .Take(5)
+            .ToListAsync();
+
+        // Jobs needing powder (not yet ordered, insufficient stock)
+        var jobsNeedingPowder = await _context.Jobs
+            .AsNoTracking()
+            .Include(j => j.Customer)
+            .Include(j => j.JobStatus)
+            .Include(j => j.JobItems)
+                .ThenInclude(i => i.Coats)
+                    .ThenInclude(c => c.InventoryItem)
+                        .ThenInclude(inv => inv!.PrimaryVendor)
+            .Include(j => j.JobItems)
+                .ThenInclude(i => i.Coats)
+                    .ThenInclude(c => c.Vendor)
+            .Where(j => !j.IsDeleted
+                     && !CompletedStatusCodes.Contains(j.JobStatus.StatusCode)
+                     && j.JobItems.Any(i => i.Coats.Any(c =>
+                         !c.IsDeleted &&
+                         !c.PowderOrdered &&
+                         c.PowderToOrder > 0 &&
+                         (c.InventoryItemId == null || c.InventoryItem!.QuantityOnHand < c.PowderToOrder))))
+            .ToListAsync();
+
+        // Jobs with powder already ordered but not yet received
+        var jobsWithOrderedPowder = await _context.Jobs
+            .AsNoTracking()
+            .Include(j => j.Customer)
+            .Include(j => j.JobStatus)
+            .Include(j => j.JobItems)
+                .ThenInclude(i => i.Coats)
+                    .ThenInclude(c => c.InventoryItem)
+                        .ThenInclude(inv => inv!.PrimaryVendor)
+            .Include(j => j.JobItems)
+                .ThenInclude(i => i.Coats)
+                    .ThenInclude(c => c.Vendor)
+            .Where(j => !j.IsDeleted
+                     && !CompletedStatusCodes.Contains(j.JobStatus.StatusCode)
+                     && j.JobItems.Any(i => i.Coats.Any(c =>
+                         !c.IsDeleted &&
+                         c.PowderOrdered &&
+                         !c.PowderReceived)))
+            .ToListAsync();
+
+        // Bills due (open/partial, balance remaining)
+        var billsDue = await _context.Bills
+            .AsNoTracking()
+            .Include(b => b.Vendor)
+            .Where(b => (b.Status == BillStatus.Open || b.Status == BillStatus.PartiallyPaid)
+                     && b.Total > b.AmountPaid)
+            .OrderBy(b => b.DueDate)
+            .Take(15)
+            .ToListAsync();
+
+        // Random tip of the day
+        var tips = await _context.DashboardTips.Where(t => t.IsActive).ToListAsync();
+        var tipOfTheDay = tips.Count > 0 ? tips[Random.Shared.Next(tips.Count)].TipText : null;
+
+        return new DashboardIndexData(
+            ActiveJobs: activeJobs,
+            MonthlyRevenue: monthlyRevenue,
+            TodaysAppointments: todaysAppointments,
+            UpcomingMaintenance: upcomingMaintenance,
+            PendingQuotes: pendingQuotes,
+            OpenInvoices: openInvoices,
+            InvoicedThisMonth: invoicedThisMonth,
+            CollectedThisMonth: collectedThisMonth,
+            RecentPayments: recentPayments,
+            RecentQuotes: recentQuotes,
+            RecentJobs: recentJobs,
+            JobsNeedingPowder: jobsNeedingPowder,
+            JobsWithOrderedPowder: jobsWithOrderedPowder,
+            BillsDue: billsDue,
+            TipOfTheDay: tipOfTheDay
+        );
+    }
+
+    /// <inheritdoc/>
+    public async Task<int> GetTotalUserCountAsync()
+    {
+        return await _context.Users
+            .Where(u => u.CompanyId > 0)
+            .CountAsync();
+    }
+}

src/PowderCoating.Infrastructure/Services/FinancialReportService.cs

@@ -1,14 +1,18 @@
 using Microsoft.EntityFrameworkCore;
 using PowderCoating.Application.DTOs.Accounting;
 using PowderCoating.Application.Interfaces;
+using PowderCoating.Core.Entities;
+using PowderCoating.Core.Enums;
 using PowderCoating.Infrastructure.Data;
 
 namespace PowderCoating.Infrastructure.Services;
 
 /// <summary>
-/// Implements financial aggregate reports using direct DbContext access with AsNoTracking.
+/// Implements financial aggregate reports (P&amp;L, Balance Sheet, AR Aging, Sales &amp; Income)
-/// Query logic is migrated here from <c>ReportsController</c> as each report action is
+/// using direct DbContext access with AsNoTracking. Migrated from inline queries in
-/// converted during Phase 2/3 of the data-access architecture migration.
+/// ReportsController as part of Phase 2 of the data-access architecture migration.
+/// The four report types each have matching PDF export paths in the controller that
+/// share the same data by calling these methods, eliminating the previous duplication.
 /// See <c>docs/DATA_ACCESS_ARCHITECTURE.md</c> for the full migration plan.
 /// </summary>
 public class FinancialReportService : IFinancialReportService
@@ -21,19 +25,415 @@ public class FinancialReportService : IFinancialReportService
     }
 
     /// <inheritdoc/>
-    /// <remarks>Implemented — migrated from <c>ReportsController.ProfitAndLoss</c> in Phase 2.</remarks>
+    public async Task<ProfitAndLossDto> GetProfitAndLossAsync(int companyId, DateTime from, DateTime to)
-    public Task<ProfitAndLossDto> GetProfitAndLossAsync(int companyId, DateTime from, DateTime to)
+    {
-        => throw new NotImplementedException("Migrate from ReportsController.ProfitAndLoss — Phase 2.");
+        var toEnd = to.AddDays(1).AddTicks(-1);
+        var companyName = await GetCompanyNameAsync(companyId);
+
+        // Revenue: InvoiceItems posted to revenue accounts
+        var revenueByAccount = await _context.InvoiceItems
+            .Where(ii => ii.RevenueAccountId != null
+                      && ii.Invoice.Status != InvoiceStatus.Draft
+                      && ii.Invoice.Status != InvoiceStatus.Voided
+                      && ii.Invoice.InvoiceDate >= from && ii.Invoice.InvoiceDate <= toEnd)
+            .GroupBy(ii => ii.RevenueAccountId!.Value)
+            .Select(g => new { AccountId = g.Key, Amount = g.Sum(ii => ii.TotalPrice) })
+            .ToListAsync();
+
+        var unlinkedRevenue = await _context.InvoiceItems
+            .Where(ii => ii.RevenueAccountId == null
+                      && ii.Invoice.Status != InvoiceStatus.Draft
+                      && ii.Invoice.Status != InvoiceStatus.Voided
+                      && ii.Invoice.InvoiceDate >= from && ii.Invoice.InvoiceDate <= toEnd)
+            .SumAsync(ii => (decimal?)ii.TotalPrice) ?? 0;
+
+        var revenueAccounts = await _context.Accounts
+            .Where(a => a.AccountType == AccountType.Revenue && a.IsActive)
+            .ToDictionaryAsync(a => a.Id);
+
+        var revenueLines = revenueByAccount
+            .Where(r => revenueAccounts.ContainsKey(r.AccountId))
+            .Select(r => new FinancialReportLine
+            {
+                AccountId     = r.AccountId,
+                AccountNumber = revenueAccounts[r.AccountId].AccountNumber,
+                AccountName   = revenueAccounts[r.AccountId].Name,
+                Amount        = r.Amount
+            })
+            .OrderBy(l => l.AccountNumber)
+            .ToList();
+
+        if (unlinkedRevenue > 0)
+            revenueLines.Add(new FinancialReportLine { AccountNumber = "—", AccountName = "Other Sales (unclassified)", Amount = unlinkedRevenue });
+
+        // COGS & Expenses: direct Expenses + BillLineItems merged per account
+        var directByAccount = await _context.Expenses
+            .Where(e => e.Date >= from && e.Date <= toEnd)
+            .GroupBy(e => e.ExpenseAccountId)
+            .Select(g => new { AccountId = g.Key, Amount = g.Sum(e => e.Amount) })
+            .ToListAsync();
+
+        var billLinesByAccount = await _context.BillLineItems
+            .Where(bli => bli.AccountId != null
+                       && bli.Bill.Status != BillStatus.Draft
+                       && bli.Bill.Status != BillStatus.Voided
+                       && bli.Bill.BillDate >= from && bli.Bill.BillDate <= toEnd)
+            .GroupBy(bli => bli.AccountId!.Value)
+            .Select(g => new { AccountId = g.Key, Amount = g.Sum(bli => bli.Amount) })
+            .ToListAsync();
+
+        var expenseAmounts = new Dictionary<int, decimal>();
+        foreach (var e in directByAccount)
+            expenseAmounts[e.AccountId] = expenseAmounts.GetValueOrDefault(e.AccountId) + e.Amount;
+        foreach (var b in billLinesByAccount)
+            expenseAmounts[b.AccountId] = expenseAmounts.GetValueOrDefault(b.AccountId) + b.Amount;
+
+        var expAccounts = await _context.Accounts
+            .Where(a => (a.AccountType == AccountType.Expense || a.AccountType == AccountType.CostOfGoods) && a.IsActive)
+            .ToDictionaryAsync(a => a.Id);
+
+        var cogsLines    = new List<FinancialReportLine>();
+        var expenseLines = new List<FinancialReportLine>();
+
+        foreach (var (accountId, amount) in expenseAmounts.OrderBy(kv => expAccounts.ContainsKey(kv.Key) ? expAccounts[kv.Key].AccountNumber : "999"))
+        {
+            if (!expAccounts.TryGetValue(accountId, out var acct)) continue;
+            var line = new FinancialReportLine { AccountId = accountId, AccountNumber = acct.AccountNumber, AccountName = acct.Name, Amount = amount };
+            if (acct.AccountType == AccountType.CostOfGoods) cogsLines.Add(line);
+            else expenseLines.Add(line);
+        }
+
+        return new ProfitAndLossDto
+        {
+            From          = from,
+            To            = to,
+            CompanyName   = companyName,
+            RevenueLines  = revenueLines,
+            TotalRevenue  = revenueLines.Sum(l => l.Amount),
+            CogsLines     = cogsLines,
+            TotalCogs     = cogsLines.Sum(l => l.Amount),
+            ExpenseLines  = expenseLines,
+            TotalExpenses = expenseLines.Sum(l => l.Amount),
+        };
+    }
 
     /// <inheritdoc/>
-    public Task<BalanceSheetDto> GetBalanceSheetAsync(int companyId, DateTime asOf)
+    public async Task<BalanceSheetDto> GetBalanceSheetAsync(int companyId, DateTime asOf)
-        => throw new NotImplementedException("Migrate from ReportsController.BalanceSheet — Phase 2.");
+    {
+        var asOfEnd = asOf.AddDays(1).AddTicks(-1);
+        var companyName = await GetCompanyNameAsync(companyId);
+
+        // Pre-compute balance contributions per account (batch GROUP BY queries avoid N+1)
+
+        var depositsByAcct = await _context.Payments
+            .Where(p => p.PaymentDate <= asOfEnd && p.DepositAccountId != null
+                     && p.Invoice.Status != InvoiceStatus.Voided
+                     && p.Invoice.Status != InvoiceStatus.WrittenOff)
+            .GroupBy(p => p.DepositAccountId!.Value)
+            .Select(g => new { Id = g.Key, Amount = g.Sum(p => p.Amount) })
+            .ToDictionaryAsync(g => g.Id, g => g.Amount);
+
+        var expFromByAcct = await _context.Expenses
+            .Where(e => e.Date <= asOfEnd)
+            .GroupBy(e => e.PaymentAccountId)
+            .Select(g => new { Id = g.Key, Amount = g.Sum(e => e.Amount) })
+            .ToDictionaryAsync(g => g.Id, g => g.Amount);
+
+        var bpFromByAcct = await _context.BillPayments
+            .Where(bp => bp.PaymentDate <= asOfEnd)
+            .GroupBy(bp => bp.BankAccountId)
+            .Select(g => new { Id = g.Key, Amount = g.Sum(bp => bp.Amount) })
+            .ToDictionaryAsync(g => g.Id, g => g.Amount);
+
+        var billsByApAcct = await _context.Bills
+            .Where(b => b.Status != BillStatus.Draft && b.Status != BillStatus.Voided && b.BillDate <= asOfEnd)
+            .GroupBy(b => b.APAccountId)
+            .Select(g => new { Id = g.Key, Amount = g.Sum(b => b.Total) })
+            .ToDictionaryAsync(g => g.Id, g => g.Amount);
+
+        var bpByApAcct = await _context.BillPayments
+            .Where(bp => bp.PaymentDate <= asOfEnd)
+            .GroupBy(bp => bp.Bill.APAccountId)
+            .Select(g => new { Id = g.Key, Amount = g.Sum(bp => bp.Amount) })
+            .ToDictionaryAsync(g => g.Id, g => g.Amount);
+
+        var taxByAcct = await _context.Invoices
+            .Where(i => i.SalesTaxAccountId != null && i.TaxAmount > 0
+                     && i.Status != InvoiceStatus.Draft && i.Status != InvoiceStatus.Voided
+                     && i.InvoiceDate <= asOfEnd)
+            .GroupBy(i => i.SalesTaxAccountId!.Value)
+            .Select(g => new { Id = g.Key, Amount = g.Sum(i => i.TaxAmount) })
+            .ToDictionaryAsync(g => g.Id, g => g.Amount);
+
+        var arDebits  = await _context.Invoices
+            .Where(i => i.Status != InvoiceStatus.Draft && i.Status != InvoiceStatus.Voided && i.InvoiceDate <= asOfEnd)
+            .SumAsync(i => (decimal?)i.Total) ?? 0;
+        var arCredits = await _context.Payments
+            .Where(p => p.PaymentDate <= asOfEnd
+                     && p.Invoice.Status != InvoiceStatus.Voided
+                     && p.Invoice.Status != InvoiceStatus.WrittenOff)
+            .SumAsync(p => (decimal?)p.Amount) ?? 0;
+
+        // Retained earnings = net P&L from inception through asOf
+        var lifetimeRevenue   = await _context.InvoiceItems
+            .Where(ii => ii.Invoice.Status != InvoiceStatus.Draft && ii.Invoice.Status != InvoiceStatus.Voided && ii.Invoice.InvoiceDate <= asOfEnd)
+            .SumAsync(ii => (decimal?)ii.TotalPrice) ?? 0;
+        var lifetimeCogs      = await _context.Expenses
+            .Where(e => e.Date <= asOfEnd)
+            .SumAsync(e => (decimal?)e.Amount) ?? 0;
+        var lifetimeBillCosts = await _context.BillLineItems
+            .Where(bli => bli.Bill.Status != BillStatus.Draft && bli.Bill.Status != BillStatus.Voided && bli.Bill.BillDate <= asOfEnd)
+            .SumAsync(bli => (decimal?)bli.Amount) ?? 0;
+        var retainedEarnings = lifetimeRevenue - lifetimeCogs - lifetimeBillCosts;
+
+        var accounts = await _context.Accounts
+            .Where(a => a.IsActive)
+            .OrderBy(a => a.AccountNumber)
+            .ToListAsync();
+
+        // Standard double-entry: assets have normal debit balance; liabilities+equity have normal credit balance.
+        decimal ComputeBalance(Account a)
+        {
+            bool normalDebit = a.AccountType == AccountType.Asset;
+            decimal debits = 0, credits = 0;
+
+            if (a.AccountSubType == AccountSubType.AccountsReceivable)
+            {
+                debits = arDebits; credits = arCredits;
+            }
+            else if (a.AccountSubType == AccountSubType.AccountsPayable)
+            {
+                credits = billsByApAcct.GetValueOrDefault(a.Id);
+                debits  = bpByApAcct.GetValueOrDefault(a.Id);
+            }
+            else
+            {
+                debits  += depositsByAcct.GetValueOrDefault(a.Id);
+                credits += expFromByAcct.GetValueOrDefault(a.Id);
+                credits += bpFromByAcct.GetValueOrDefault(a.Id);
+                credits += taxByAcct.GetValueOrDefault(a.Id);
+            }
+
+            decimal opening = (a.OpeningBalanceDate == null || a.OpeningBalanceDate.Value.Date <= asOf)
+                ? a.OpeningBalance : 0;
+            decimal net = normalDebit ? debits - credits : credits - debits;
+            return opening + net;
+        }
+
+        FinancialReportLine ToLine(Account a) => new()
+        {
+            AccountId     = a.Id,
+            AccountNumber = a.AccountNumber,
+            AccountName   = a.Name,
+            Amount        = ComputeBalance(a)
+        };
+
+        var assetAccts     = accounts.Where(a => a.AccountType == AccountType.Asset).ToList();
+        var liabilityAccts = accounts.Where(a => a.AccountType == AccountType.Liability).ToList();
+        var equityAccts    = accounts.Where(a => a.AccountType == AccountType.Equity).ToList();
+
+        var currentAssets       = assetAccts.Where(a => a.AccountSubType is AccountSubType.Checking or AccountSubType.Savings or AccountSubType.AccountsReceivable or AccountSubType.Inventory or AccountSubType.OtherCurrentAsset).Select(ToLine).ToList();
+        var fixedAssets         = assetAccts.Where(a => a.AccountSubType == AccountSubType.FixedAsset).Select(ToLine).ToList();
+        var otherAssets         = assetAccts.Where(a => a.AccountSubType == AccountSubType.OtherAsset).Select(ToLine).ToList();
+        var currentLiabilities  = liabilityAccts.Where(a => a.AccountSubType is AccountSubType.AccountsPayable or AccountSubType.CreditCard or AccountSubType.OtherCurrentLiability).Select(ToLine).ToList();
+        var longTermLiabilities = liabilityAccts.Where(a => a.AccountSubType == AccountSubType.LongTermLiability).Select(ToLine).ToList();
+        var equityLines         = equityAccts.Select(ToLine).ToList();
+
+        var totalAssets      = currentAssets.Sum(l => l.Amount) + fixedAssets.Sum(l => l.Amount) + otherAssets.Sum(l => l.Amount);
+        var totalLiabilities = currentLiabilities.Sum(l => l.Amount) + longTermLiabilities.Sum(l => l.Amount);
+        var totalEquity      = equityLines.Sum(l => l.Amount) + retainedEarnings;
+
+        return new BalanceSheetDto
+        {
+            AsOf                = asOf,
+            CompanyName         = companyName,
+            CurrentAssets       = currentAssets,
+            FixedAssets         = fixedAssets,
+            OtherAssets         = otherAssets,
+            TotalAssets         = totalAssets,
+            CurrentLiabilities  = currentLiabilities,
+            LongTermLiabilities = longTermLiabilities,
+            TotalLiabilities    = totalLiabilities,
+            EquityLines         = equityLines,
+            RetainedEarnings    = retainedEarnings,
+            TotalEquity         = totalEquity,
+        };
+    }
 
     /// <inheritdoc/>
-    public Task<ArAgingReportDto> GetArAgingAsync(int companyId, DateTime asOf)
+    public async Task<ArAgingReportDto> GetArAgingAsync(int companyId, DateTime asOf)
-        => throw new NotImplementedException("Migrate from ReportsController.ArAging — Phase 2.");
+    {
+        var asOfEnd = asOf.AddDays(1).AddTicks(-1);
+        var companyName = await GetCompanyNameAsync(companyId);
+
+        var openInvoices = await _context.Invoices
+            .Include(i => i.Customer)
+            .Where(i => i.Status != InvoiceStatus.Draft
+                     && i.Status != InvoiceStatus.Voided
+                     && i.Status != InvoiceStatus.Paid
+                     && i.InvoiceDate <= asOfEnd
+                     && (i.Total - i.AmountPaid - i.CreditApplied - i.GiftCertificateRedeemed) > 0)
+            .OrderBy(i => i.Customer!.CompanyName)
+            .ThenBy(i => i.DueDate)
+            .ToListAsync();
+
+        static string AgingBucket(int d) => d switch
+        {
+            <= 0  => "current",
+            <= 30 => "1-30",
+            <= 60 => "31-60",
+            <= 90 => "61-90",
+            _     => "90+"
+        };
+
+        var customerDtos = new List<ArAgingCustomerDto>();
+
+        foreach (var grp in openInvoices.GroupBy(i => new { i.CustomerId, i.Customer!.CompanyName, i.Customer.ContactFirstName, i.Customer.ContactLastName, i.Customer.IsCommercial }))
+        {
+            var customerName = grp.Key.IsCommercial
+                ? grp.Key.CompanyName
+                : $"{grp.Key.ContactFirstName} {grp.Key.ContactLastName}".Trim();
+
+            var custDto = new ArAgingCustomerDto { CustomerId = grp.Key.CustomerId, CustomerName = customerName };
+
+            foreach (var inv in grp)
+            {
+                var balance     = inv.BalanceDue;
+                var daysOverdue = inv.DueDate.HasValue ? (int)(asOf - inv.DueDate.Value.Date).TotalDays : 0;
+
+                custDto.Invoices.Add(new ArAgingInvoiceDto
+                {
+                    InvoiceId     = inv.Id,
+                    InvoiceNumber = inv.InvoiceNumber,
+                    InvoiceDate   = inv.InvoiceDate,
+                    DueDate       = inv.DueDate,
+                    BalanceDue    = balance,
+                    DaysOverdue   = daysOverdue
+                });
+
+                switch (AgingBucket(daysOverdue))
+                {
+                    case "current": custDto.TotalCurrent += balance; break;
+                    case "1-30":    custDto.Total1to30   += balance; break;
+                    case "31-60":   custDto.Total31to60  += balance; break;
+                    case "61-90":   custDto.Total61to90  += balance; break;
+                    default:        custDto.TotalOver90  += balance; break;
+                }
+            }
+
+            customerDtos.Add(custDto);
+        }
+
+        var sorted = customerDtos.OrderByDescending(c => c.TotalBalance).ToList();
+
+        return new ArAgingReportDto
+        {
+            AsOf         = asOf,
+            CompanyName  = companyName,
+            Customers    = sorted,
+            TotalCurrent = sorted.Sum(c => c.TotalCurrent),
+            Total1to30   = sorted.Sum(c => c.Total1to30),
+            Total31to60  = sorted.Sum(c => c.Total31to60),
+            Total61to90  = sorted.Sum(c => c.Total61to90),
+            TotalOver90  = sorted.Sum(c => c.TotalOver90),
+        };
+    }
 
     /// <inheritdoc/>
-    public Task<SalesIncomeReportDto> GetSalesAndIncomeAsync(int companyId, DateTime from, DateTime to)
+    public async Task<SalesIncomeReportDto> GetSalesAndIncomeAsync(int companyId, DateTime from, DateTime to)
-        => throw new NotImplementedException("Migrate from ReportsController.SalesAndIncome — Phase 2.");
+    {
+        var toEnd = to.AddDays(1).AddTicks(-1);
+        var companyName = await GetCompanyNameAsync(companyId);
+
+        var invoices = await _context.Invoices
+            .Include(i => i.Customer)
+            .Include(i => i.Payments)
+            .Where(i => i.Status != InvoiceStatus.Draft
+                     && i.Status != InvoiceStatus.Voided
+                     && i.InvoiceDate >= from && i.InvoiceDate <= toEnd)
+            .OrderBy(i => i.InvoiceDate)
+            .ToListAsync();
+
+        var collectedInPeriod = await _context.Payments
+            .Where(p => p.PaymentDate >= from && p.PaymentDate <= toEnd)
+            .SumAsync(p => (decimal?)p.Amount) ?? 0;
+
+        var byCustomer = invoices
+            .GroupBy(i => new
+            {
+                i.CustomerId,
+                Name = i.Customer!.IsCommercial
+                    ? i.Customer.CompanyName
+                    : $"{i.Customer.ContactFirstName} {i.Customer.ContactLastName}".Trim()
+            })
+            .Select(g => new SalesByCustomerDto
+            {
+                CustomerId    = g.Key.CustomerId,
+                CustomerName  = g.Key.Name,
+                InvoiceCount  = g.Count(),
+                TotalInvoiced = g.Sum(i => i.Total),
+                TotalPaid     = g.Sum(i => i.AmountPaid),
+                BalanceDue    = g.Sum(i => i.BalanceDue),
+            })
+            .OrderByDescending(c => c.TotalInvoiced)
+            .ToList();
+
+        var byMonth = invoices
+            .GroupBy(i => new { i.InvoiceDate.Year, i.InvoiceDate.Month })
+            .Select(g => new SalesByMonthDto
+            {
+                Year           = g.Key.Year,
+                Month          = g.Key.Month,
+                Label          = new DateTime(g.Key.Year, g.Key.Month, 1).ToString("MMM yyyy"),
+                TotalInvoiced  = g.Sum(i => i.Total),
+                TotalCollected = g.Sum(i => i.AmountPaid),
+                InvoiceCount   = g.Count(),
+            })
+            .OrderBy(m => m.Year).ThenBy(m => m.Month)
+            .ToList();
+
+        var invoiceLines = invoices.Select(i => new SalesInvoiceLineDto
+        {
+            InvoiceId     = i.Id,
+            InvoiceNumber = i.InvoiceNumber,
+            CustomerName  = i.Customer!.IsCommercial
+                ? i.Customer.CompanyName
+                : $"{i.Customer.ContactFirstName} {i.Customer.ContactLastName}".Trim(),
+            InvoiceDate   = i.InvoiceDate,
+            DueDate       = i.DueDate,
+            Status        = i.Status.ToString(),
+            SubTotal      = i.SubTotal,
+            TaxAmount     = i.TaxAmount,
+            Total         = i.Total,
+            AmountPaid    = i.AmountPaid,
+            BalanceDue    = i.BalanceDue,
+        }).ToList();
+
+        return new SalesIncomeReportDto
+        {
+            From           = from,
+            To             = to,
+            CompanyName    = companyName,
+            TotalInvoiced  = invoices.Sum(i => i.Total),
+            TotalCollected = collectedInPeriod,
+            TotalTax       = invoices.Sum(i => i.TaxAmount),
+            TotalDiscount  = invoices.Sum(i => i.DiscountAmount),
+            InvoiceCount   = invoices.Count,
+            CustomerCount  = invoices.Select(i => i.CustomerId).Distinct().Count(),
+            ByCustomer     = byCustomer,
+            ByMonth        = byMonth,
+            Invoices       = invoiceLines,
+        };
+    }
+
+    /// <summary>
+    /// Looks up the company name by ID for report headers and AI prompt injection.
+    /// Falls back to "Your Company" if the record is not found.
+    /// </summary>
+    private async Task<string> GetCompanyNameAsync(int companyId)
+    {
+        if (companyId <= 0) return "Your Company";
+        var company = await _context.Companies.FirstOrDefaultAsync(c => c.Id == companyId);
+        return company?.CompanyName ?? "Your Company";
+    }
 }

src/PowderCoating.Infrastructure/Services/OperationalReportService.cs

@@ -1,4 +1,7 @@
+using Microsoft.EntityFrameworkCore;
 using PowderCoating.Application.Interfaces;
+using PowderCoating.Core.Entities;
+using PowderCoating.Core.Enums;
 using PowderCoating.Infrastructure.Data;
 
 namespace PowderCoating.Infrastructure.Services;
@@ -19,10 +22,124 @@ public class OperationalReportService : IOperationalReportService
     }
 
     /// <inheritdoc/>
-    public Task<JobCycleTimeReport> GetJobCycleTimeAsync(int companyId, int months)
+    public async Task<JobCycleTimeReport> GetJobCycleTimeAsync(int companyId, int months)
-        => throw new NotImplementedException("Migrate from ReportsController.JobCycleTime — Phase 2.");
+    {
+        var completedCodes = new[] { "COMPLETED", "READY_FOR_PICKUP", "DELIVERED" };
+
+        var completedJobs = await _context.Jobs
+            .Include(j => j.JobStatus)
+            .Where(j => !j.IsDeleted && completedCodes.Contains(j.JobStatus.StatusCode) && j.CompletedDate.HasValue)
+            .AsNoTracking()
+            .ToListAsync();
+
+        var history = await _context.JobStatusHistory
+            .Include(h => h.FromStatus)
+            .Include(h => h.ToStatus)
+            .AsNoTracking()
+            .ToListAsync();
+
+        var historyByJob = history
+            .GroupBy(h => h.JobId)
+            .ToDictionary(g => g.Key, g => g.OrderBy(h => h.ChangedDate).ToList());
+
+        var statusTimings = new Dictionary<string, (string DisplayName, List<double> Days)>();
+
+        foreach (var job in completedJobs)
+        {
+            if (!historyByJob.TryGetValue(job.Id, out var jobHistory) || !jobHistory.Any()) continue;
+
+            var prevDate = job.CreatedAt;
+            foreach (var entry in jobHistory)
+            {
+                var fc = entry.FromStatus?.StatusCode;
+                var fn = entry.FromStatus?.DisplayName;
+                if (fc == null) { prevDate = entry.ChangedDate; continue; }
+                var d = (entry.ChangedDate - prevDate).TotalDays;
+                if (d >= 0 && d <= 365)
+                {
+                    if (!statusTimings.ContainsKey(fc)) statusTimings[fc] = (fn ?? fc, new List<double>());
+                    statusTimings[fc].Days.Add(d);
+                }
+                prevDate = entry.ChangedDate;
+            }
+
+            var last = jobHistory.Last();
+            var tc = last.ToStatus?.StatusCode;
+            var tn = last.ToStatus?.DisplayName;
+            if (tc != null)
+            {
+                var d = (job.CompletedDate!.Value - last.ChangedDate).TotalDays;
+                if (d >= 0 && d <= 365)
+                {
+                    if (!statusTimings.ContainsKey(tc)) statusTimings[tc] = (tn ?? tc, new List<double>());
+                    statusTimings[tc].Days.Add(d);
+                }
+            }
+        }
+
+        var rows = statusTimings
+            .Where(kv => kv.Value.Days.Any())
+            .Select(kv => new JobCycleTimeRow(kv.Value.DisplayName, Math.Round(kv.Value.Days.Average(), 1), kv.Value.Days.Count))
+            .ToList();
+
+        return new JobCycleTimeReport(rows, months);
+    }
 
     /// <inheritdoc/>
-    public Task<PowderUsageReport> GetPowderUsageAsync(int companyId, int months)
+    public async Task<PowderUsageReport> GetPowderUsageAsync(int companyId, int months)
-        => throw new NotImplementedException("Migrate from ReportsController.PowderUsage — Phase 2.");
+    {
+        var startDate = DateTime.UtcNow.AddMonths(-months);
+
+        var transactions = await _context.InventoryTransactions
+            .Include(t => t.InventoryItem)
+            .Where(t => !t.IsDeleted
+                && t.TransactionType == InventoryTransactionType.JobUsage
+                && t.TransactionDate >= startDate)
+            .AsNoTracking()
+            .ToListAsync();
+
+        var rows = transactions
+            .Where(t => t.InventoryItem != null)
+            .GroupBy(t => t.InventoryItemId)
+            .Select(g => new PowderUsageRow(
+                ColorName: g.First().InventoryItem!.ColorName ?? g.First().InventoryItem!.Name,
+                VendorName: g.First().InventoryItem!.Manufacturer ?? string.Empty,
+                TotalLbs: g.Sum(t => Math.Abs(t.Quantity)),
+                TotalCost: g.Sum(t => Math.Abs(t.TotalCost))))
+            .OrderByDescending(r => r.TotalLbs)
+            .ToList();
+
+        return new PowderUsageReport(rows, months);
+    }
+
+    /// <inheritdoc/>
+    public async Task<List<Bill>> GetActiveBillsAsync()
+    {
+        return await _context.Bills
+            .Include(b => b.Vendor)
+            .Include(b => b.Payments.Where(p => !p.IsDeleted))
+            .Where(b => !b.IsDeleted && b.Status != BillStatus.Voided)
+            .AsNoTracking()
+            .ToListAsync();
+    }
+
+    /// <inheritdoc/>
+    public async Task<List<Expense>> GetAllExpensesAsync()
+    {
+        return await _context.Expenses
+            .Include(e => e.ExpenseAccount)
+            .Where(e => !e.IsDeleted)
+            .AsNoTracking()
+            .ToListAsync();
+    }
+
+    /// <inheritdoc/>
+    public async Task<List<JobStatusHistory>> GetAllJobStatusHistoryAsync()
+    {
+        return await _context.JobStatusHistory
+            .Include(h => h.FromStatus)
+            .Include(h => h.ToStatus)
+            .AsNoTracking()
+            .ToListAsync();
+    }
 }

src/PowderCoating.Web/Controllers/AccountingExportController.cs

@@ -1,9 +1,7 @@
 using Microsoft.AspNetCore.Authorization;
 using PowderCoating.Shared.Constants;
 using Microsoft.AspNetCore.Mvc;
-using Microsoft.EntityFrameworkCore;
 using PowderCoating.Core.Interfaces;
-using PowderCoating.Infrastructure.Data;
 using System.IO.Compression;
 using System.Text;
 
@@ -12,14 +10,14 @@ namespace PowderCoating.Web.Controllers;
 [Authorize(Policy = AppConstants.Policies.CanManageJobs)]
 public class AccountingExportController : Controller
 {
-    private readonly ApplicationDbContext _context;
+    private readonly IUnitOfWork _unitOfWork;
     private readonly ITenantContext _tenantContext;
     private readonly PowderCoating.Application.Interfaces.IAuditService _auditService;
 
-    public AccountingExportController(ApplicationDbContext context, ITenantContext tenantContext,
+    public AccountingExportController(IUnitOfWork unitOfWork, ITenantContext tenantContext,
         PowderCoating.Application.Interfaces.IAuditService auditService)
     {
-        _context = context;
+        _unitOfWork = unitOfWork;
         _tenantContext = tenantContext;
         _auditService = auditService;
     }
@@ -60,42 +58,33 @@ public class AccountingExportController : Controller
     [ValidateAntiForgeryToken]
     public async Task<IActionResult> Export(DateTime startDate, DateTime endDate, string format)
     {
-        var companyId     = _tenantContext.GetCurrentCompanyId() ?? 0;
         var start         = startDate.Date;
         var end           = endDate.Date.AddDays(1).AddTicks(-1);
 
         // ── Load data ─────────────────────────────────────────────────────────
-        var invoices = await _context.Invoices
+        var invoices = (await _unitOfWork.Invoices.FindAsync(
-            .Include(i => i.InvoiceItems)
+                i => i.InvoiceDate >= start && i.InvoiceDate <= end,
-            .Include(i => i.Payments)
+                false,
-            .Include(i => i.Customer)
+                i => i.InvoiceItems,
-            .Where(i => !i.IsDeleted && i.CompanyId == companyId
+                i => i.Payments,
-                     && i.InvoiceDate >= start && i.InvoiceDate <= end)
+                i => i.Customer))
             .OrderBy(i => i.InvoiceDate)
-            .ToListAsync();
+            .ToList();
 
-        var expenses = await _context.Set<PowderCoating.Core.Entities.Expense>()
+        var expenses = (await _unitOfWork.Expenses.FindAsync(
-            .Include(e => e.Vendor)
+                e => e.Date >= start && e.Date <= end,
-            .Include(e => e.ExpenseAccount)
+                false,
-            .Include(e => e.PaymentAccount)
+                e => e.Vendor,
-            .Where(e => !e.IsDeleted && e.CompanyId == companyId
+                e => e.ExpenseAccount,
-                     && e.Date >= start && e.Date <= end)
+                e => e.PaymentAccount))
             .OrderBy(e => e.Date)
-            .ToListAsync();
+            .ToList();
 
-        var bills = await _context.Set<PowderCoating.Core.Entities.Bill>()
+        var bills = await _unitOfWork.Bills.GetForDateRangeAsync(start, end);
-            .Include(b => b.Vendor)
-            .Include(b => b.LineItems).ThenInclude(l => l.Account)
-            .Include(b => b.Payments)
-            .Where(b => !b.IsDeleted && b.CompanyId == companyId
-                     && b.BillDate >= start && b.BillDate <= end)
-            .OrderBy(b => b.BillDate)
-            .ToListAsync();
 
-        var customers = await _context.Customers
+        var customers = (await _unitOfWork.Customers.GetAllAsync())
-            .Where(c => !c.IsDeleted && c.CompanyId == companyId)
             .OrderBy(c => c.CompanyName ?? c.ContactFirstName)
-            .ToListAsync();
+            .ToList();
 
         // ── Build ZIP ─────────────────────────────────────────────────────────
         using var ms = new MemoryStream();

src/PowderCoating.Web/Controllers/AiQuickQuoteController.cs

@@ -8,7 +8,6 @@ using PowderCoating.Application.Interfaces;
 using PowderCoating.Application.Services;
 using PowderCoating.Core.Entities;
 using PowderCoating.Core.Interfaces;
-using PowderCoating.Infrastructure.Data;
 using PowderCoating.Shared.Constants;
 
 namespace PowderCoating.Web.Controllers;
@@ -19,7 +18,6 @@ public class AiQuickQuoteController : Controller
     private readonly IUnitOfWork _unitOfWork;
     private readonly IAiQuickQuoteService _aiService;
     private readonly IPricingCalculationService _pricingService;
-    private readonly ApplicationDbContext _context;
     private readonly UserManager<ApplicationUser> _userManager;
     private readonly ILogger<AiQuickQuoteController> _logger;
 
@@ -27,14 +25,12 @@ public class AiQuickQuoteController : Controller
         IUnitOfWork unitOfWork,
         IAiQuickQuoteService aiService,
         IPricingCalculationService pricingService,
-        ApplicationDbContext context,
         UserManager<ApplicationUser> userManager,
         ILogger<AiQuickQuoteController> logger)
     {
         _unitOfWork = unitOfWork;
         _aiService = aiService;
         _pricingService = pricingService;
-        _context = context;
         _userManager = userManager;
         _logger = logger;
     }
@@ -106,9 +102,7 @@ public class AiQuickQuoteController : Controller
         var walkIn = await GetOrCreateWalkInCustomerAsync(companyId);
 
         // Draft status — nullable FK, gracefully absent if lookup not seeded
-        var draftStatus = await _context.QuoteStatusLookups
+        var draftStatus = await _unitOfWork.QuoteStatusLookups.FirstOrDefaultAsync(s => s.StatusCode == "DRAFT");
-            .Where(s => s.StatusCode == "DRAFT")
-            .FirstOrDefaultAsync();
 
         var quoteNumber = await GenerateQuoteNumberAsync(companyId);
         var now = DateTime.UtcNow;
@@ -300,21 +294,13 @@ public class AiQuickQuoteController : Controller
     {
         var now = DateTime.UtcNow;
 
-        var prefs = await _context.CompanyPreferences
+        var prefs = await _unitOfWork.CompanyPreferences.FirstOrDefaultAsync(
-            .IgnoreQueryFilters()
+            p => p.CompanyId == companyId && !p.IsDeleted, ignoreQueryFilters: true);
-            .Where(p => p.CompanyId == companyId && !p.IsDeleted)
-            .Select(p => new { p.QuoteNumberPrefix })
-            .FirstOrDefaultAsync();
 
         var quotePrefix = !string.IsNullOrWhiteSpace(prefs?.QuoteNumberPrefix) ? prefs.QuoteNumberPrefix : "QT";
         var prefix = $"{quotePrefix}-{now:yy}{now:MM}";
 
-        var lastQuoteNumber = await _context.Quotes
+        var lastQuoteNumber = await _unitOfWork.Quotes.GetLastQuoteNumberByPrefixAsync(companyId, prefix);
-            .IgnoreQueryFilters()
-            .Where(q => q.CompanyId == companyId && q.QuoteNumber.StartsWith(prefix))
-            .OrderByDescending(q => q.QuoteNumber)
-            .Select(q => q.QuoteNumber)
-            .FirstOrDefaultAsync();
 
         int nextNumber = 1;
         if (lastQuoteNumber != null)

src/PowderCoating.Web/Controllers/AiUsageReportController.cs

@@ -1,7 +1,7 @@
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
-using Microsoft.EntityFrameworkCore;
+using PowderCoating.Application.Interfaces;
-using PowderCoating.Infrastructure.Data;
+using PowderCoating.Core.Interfaces;
 using PowderCoating.Shared.Constants;
 
 namespace PowderCoating.Web.Controllers;
@@ -9,108 +9,74 @@ namespace PowderCoating.Web.Controllers;
 [Authorize(Policy = AppConstants.Policies.SuperAdminOnly)]
 public class AiUsageReportController : Controller
 {
-    private readonly ApplicationDbContext _context;
+    private readonly IUnitOfWork _unitOfWork;
+    private readonly IAiUsageReportService _aiUsageReport;
     private readonly ILogger<AiUsageReportController> _logger;
 
-    public AiUsageReportController(ApplicationDbContext context, ILogger<AiUsageReportController> logger)
+    public AiUsageReportController(
+        IUnitOfWork unitOfWork,
+        IAiUsageReportService aiUsageReport,
+        ILogger<AiUsageReportController> logger)
     {
-        _context = context;
+        _unitOfWork = unitOfWork;
+        _aiUsageReport = aiUsageReport;
         _logger = logger;
     }
 
     /// <summary>
     /// Platform-wide AI usage report. Shows per-company call counts, photo upload totals, top
     /// feature used, and a usage tier so SuperAdmins can identify abusive or unusually heavy tenants.
-    /// All queries use IgnoreQueryFilters() where needed to cross tenant boundaries.
+    /// Companies and plan configs come from IUnitOfWork; AiUsageLogs aggregations and photo counts
+    /// come from IAiUsageReportService (which runs SQL GROUP BY queries via ApplicationDbContext).
     /// </summary>
     public async Task<IActionResult> Index()
     {
         try
         {
-            var now = DateTime.UtcNow;
+            var companies = (await _unitOfWork.Companies.GetAllAsync(ignoreQueryFilters: true))
-            var todayStart  = now.Date;
-            var last7Start  = todayStart.AddDays(-7);
-            var last30Start = todayStart.AddDays(-30);
-
-            // Companies (non-deleted only)
-            var companies = await _context.Companies
-                .IgnoreQueryFilters()
                 .Where(c => !c.IsDeleted)
                 .Select(c => new { c.Id, c.CompanyName, c.SubscriptionPlan, c.IsActive })
-                .ToListAsync();
+                .ToList();
 
-            // Plan display names from SubscriptionPlanConfig
+            var planConfigs = await _unitOfWork.SubscriptionPlanConfigs.GetAllAsync();
-            var planConfigs = await _context.Set<PowderCoating.Core.Entities.SubscriptionPlanConfig>()
-                .IgnoreQueryFilters()
-                .Where(p => !p.IsDeleted)
-                .Select(p => new { p.Plan, p.DisplayName })
-                .ToListAsync();
             var planNames = planConfigs.ToDictionary(p => p.Plan, p => p.DisplayName);
 
-            // All-time usage grouped by company — the four count windows are computed in SQL
+            var data = await _aiUsageReport.GetReportDataAsync();
-            var usageByCompany = await _context.AiUsageLogs
-                .GroupBy(l => l.CompanyId)
-                .Select(g => new
-                {
-                    CompanyId  = g.Key,
-                    Today      = g.Count(l => l.CalledAt >= todayStart),
-                    Last7Days  = g.Count(l => l.CalledAt >= last7Start),
-                    Last30Days = g.Count(l => l.CalledAt >= last30Start),
-                    AllTime    = g.Count()
-                })
-                .ToListAsync();
 
-            // Top feature per company over the last 30 days
+            var topFeatureByCompany = data.FeatureStats
-            var featureStats = await _context.AiUsageLogs
-                .Where(l => l.CalledAt >= last30Start)
-                .GroupBy(l => new { l.CompanyId, l.Feature })
-                .Select(g => new { g.Key.CompanyId, g.Key.Feature, Count = g.Count() })
-                .ToListAsync();
-
-            var topFeatureByCompany = featureStats
                 .GroupBy(f => f.CompanyId)
                 .ToDictionary(
                     g => g.Key,
                     g => g.OrderByDescending(f => f.Count).First().Feature);
 
-            // Feature breakdown per company (last 30 days)
+            var featureBreakdownByCompany = data.FeatureStats
-            var featureBreakdownByCompany = featureStats
                 .GroupBy(f => f.CompanyId)
                 .ToDictionary(
                     g => g.Key,
                     g => g.ToDictionary(f => f.Feature, f => f.Count));
 
-            // Total AI photos per company (all time, including deleted photos)
+            var usageDict = data.UsageByCompany.ToDictionary(u => u.CompanyId);
-            var photoCounts = await _context.QuotePhotos
-                .IgnoreQueryFilters()
-                .Where(p => p.IsAiAnalysisPhoto && !p.IsDeleted)
-                .GroupBy(p => p.CompanyId)
-                .Select(g => new { CompanyId = g.Key, Count = g.Count() })
-                .ToDictionaryAsync(x => x.CompanyId, x => x.Count);
-
-            // Build report rows
-            var usageDict = usageByCompany.ToDictionary(u => u.CompanyId);
 
             var rows = companies.Select(c =>
             {
                 usageDict.TryGetValue(c.Id, out var u);
-                photoCounts.TryGetValue(c.Id, out var photos);
+                data.PhotoCountsByCompany.TryGetValue(c.Id, out var photos);
                 topFeatureByCompany.TryGetValue(c.Id, out var topFeature);
                 featureBreakdownByCompany.TryGetValue(c.Id, out var breakdown);
                 planNames.TryGetValue(c.SubscriptionPlan, out var planName);
 
                 return new AiUsageReportRow
                 {
-                    CompanyId      = c.Id,
+                    CompanyId        = c.Id,
-                    CompanyName    = c.CompanyName,
+                    CompanyName      = c.CompanyName,
-                    Plan           = planName ?? $"Plan {c.SubscriptionPlan}",
+                    Plan             = planName ?? $"Plan {c.SubscriptionPlan}",
-                    IsActive       = c.IsActive,
+                    IsActive         = c.IsActive,
-                    Today          = u?.Today ?? 0,
+                    Today            = u?.Today ?? 0,
-                    Last7Days      = u?.Last7Days ?? 0,
+                    Last7Days        = u?.Last7Days ?? 0,
-                    Last30Days     = u?.Last30Days ?? 0,
+                    Last30Days       = u?.Last30Days ?? 0,
-                    AllTime        = u?.AllTime ?? 0,
+                    AllTime          = u?.AllTime ?? 0,
-                    PhotoCount     = photos,
+                    PhotoCount       = photos,
-                    TopFeature     = topFeature,
+                    TopFeature       = topFeature,
                     FeatureBreakdown = breakdown ?? []
                 };
             })
@@ -118,15 +84,14 @@ public class AiUsageReportController : Controller
             .ThenByDescending(r => r.AllTime)
             .ToList();
 
-            // Platform totals for summary cards
             var vm = new AiUsageReportViewModel
             {
-                Rows                  = rows,
+                Rows                 = rows,
-                TotalCallsLast30Days  = rows.Sum(r => r.Last30Days),
+                TotalCallsLast30Days = rows.Sum(r => r.Last30Days),
-                TotalCallsToday       = rows.Sum(r => r.Today),
+                TotalCallsToday      = rows.Sum(r => r.Today),
-                CompaniesActiveToday  = rows.Count(r => r.Today > 0),
+                CompaniesActiveToday = rows.Count(r => r.Today > 0),
-                TotalPhotosUploaded   = rows.Sum(r => r.PhotoCount),
+                TotalPhotosUploaded  = rows.Sum(r => r.PhotoCount),
-                MostActiveCompany     = rows.FirstOrDefault(r => r.Last30Days > 0)?.CompanyName ?? "—"
+                MostActiveCompany    = rows.FirstOrDefault(r => r.Last30Days > 0)?.CompanyName ?? "—"
             };
 
             return View(vm);

src/PowderCoating.Web/Controllers/AnnouncementsController.cs

@@ -1,9 +1,8 @@
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
-using Microsoft.EntityFrameworkCore;
 using PowderCoating.Application.Interfaces;
 using PowderCoating.Core.Entities;
-using PowderCoating.Infrastructure.Data;
+using PowderCoating.Core.Interfaces;
 using PowderCoating.Shared.Constants;
 
 namespace PowderCoating.Web.Controllers;
@@ -11,12 +10,12 @@ namespace PowderCoating.Web.Controllers;
 [Authorize(Policy = AppConstants.Policies.SuperAdminOnly)]
 public class AnnouncementsController : Controller
 {
-    private readonly ApplicationDbContext _db;
+    private readonly IUnitOfWork _unitOfWork;
     private readonly IInAppNotificationService _inApp;
 
-    public AnnouncementsController(ApplicationDbContext db, IInAppNotificationService inApp)
+    public AnnouncementsController(IUnitOfWork unitOfWork, IInAppNotificationService inApp)
     {
-        _db = db;
+        _unitOfWork = unitOfWork;
         _inApp = inApp;
     }
 
@@ -25,18 +24,18 @@ public class AnnouncementsController : Controller
     /// </summary>
     public async Task<IActionResult> Index()
     {
-        var announcements = await _db.Announcements
+        var announcements = (await _unitOfWork.Announcements.GetAllAsync())
             .OrderByDescending(a => a.CreatedAt)
-            .ToListAsync();
+            .ToList();
         return View(announcements);
     }
 
     /// <summary>
     /// Shows the announcement creation form with sensible defaults: starts now, dismissible, and active.
     /// </summary>
-    public IActionResult Create()
+    public async Task<IActionResult> Create()
     {
-        PopulateDropdowns();
+        await PopulateDropdownsAsync();
         return View(new Announcement { StartsAt = DateTime.Now, IsDismissible = true, IsActive = true });
     }
 
@@ -46,7 +45,7 @@ public class AnnouncementsController : Controller
     [HttpPost, ValidateAntiForgeryToken]
     public async Task<IActionResult> Create(Announcement model)
     {
-        if (!ModelState.IsValid) { PopulateDropdowns(); return View(model); }
+        if (!ModelState.IsValid) { await PopulateDropdownsAsync(); return View(model); }
 
         model.CreatedByUserId = User.FindFirst(System.Security.Claims.ClaimTypes.NameIdentifier)?.Value ?? "";
         model.CreatedByUserName = User.Identity?.Name ?? "SuperAdmin";
@@ -54,10 +53,9 @@ public class AnnouncementsController : Controller
         model.StartsAt = model.StartsAt.ToUniversalTime();
         if (model.ExpiresAt.HasValue) model.ExpiresAt = model.ExpiresAt.Value.ToUniversalTime();
 
-        _db.Announcements.Add(model);
+        await _unitOfWork.Announcements.AddAsync(model);
-        await _db.SaveChangesAsync();
+        await _unitOfWork.CompleteAsync();
 
-        // Dispatch as in-app notifications to targeted companies
         await DispatchNotificationsAsync(model);
 
         TempData["Success"] = "Announcement created and sent as notifications.";
@@ -69,9 +67,9 @@ public class AnnouncementsController : Controller
     /// </summary>
     public async Task<IActionResult> Edit(int id)
     {
-        var announcement = await _db.Announcements.FindAsync(id);
+        var announcement = await _unitOfWork.Announcements.GetByIdAsync(id);
         if (announcement == null) return NotFound();
-        PopulateDropdowns();
+        await PopulateDropdownsAsync();
         return View(announcement);
     }
 
@@ -81,9 +79,9 @@ public class AnnouncementsController : Controller
     [HttpPost, ValidateAntiForgeryToken]
     public async Task<IActionResult> Edit(int id, Announcement model)
     {
-        if (!ModelState.IsValid) { PopulateDropdowns(); return View(model); }
+        if (!ModelState.IsValid) { await PopulateDropdownsAsync(); return View(model); }
 
-        var existing = await _db.Announcements.FindAsync(id);
+        var existing = await _unitOfWork.Announcements.GetByIdAsync(id);
         if (existing == null) return NotFound();
 
         existing.Title = model.Title;
@@ -98,7 +96,7 @@ public class AnnouncementsController : Controller
         existing.IsActive = model.IsActive;
         existing.UpdatedAt = DateTime.UtcNow;
 
-        await _db.SaveChangesAsync();
+        await _unitOfWork.CompleteAsync();
         TempData["Success"] = "Announcement updated.";
         return RedirectToAction(nameof(Index));
     }
@@ -109,49 +107,42 @@ public class AnnouncementsController : Controller
     [HttpPost, ValidateAntiForgeryToken]
     public async Task<IActionResult> Delete(int id)
     {
-        var announcement = await _db.Announcements.FindAsync(id);
+        var announcement = await _unitOfWork.Announcements.GetByIdAsync(id);
         if (announcement == null) return NotFound();
-        _db.Announcements.Remove(announcement);
+        await _unitOfWork.Announcements.DeleteAsync(announcement);
-        await _db.SaveChangesAsync();
+        await _unitOfWork.CompleteAsync();
         TempData["Success"] = "Announcement deleted.";
         return RedirectToAction(nameof(Index));
     }
 
     /// <summary>
-    /// Fans out the announcement as in-app notifications to each matching company. IgnoreQueryFilters is required to reach all active companies regardless of tenant context (this runs as SuperAdmin). Filtering by Target/Plan/Company happens before the foreach so only relevant tenants receive the notification.
+    /// Fans out the announcement as in-app notifications to each matching company. IgnoreQueryFilters is required to reach all active companies regardless of tenant context. Filtering by Target/Plan/Company happens after the fetch so only relevant tenants receive the notification.
     /// </summary>
     private async Task DispatchNotificationsAsync(Announcement model)
     {
-        IQueryable<PowderCoating.Core.Entities.Company> companyQuery = _db.Companies
+        var companies = (await _unitOfWork.Companies.FindAsync(
-            .IgnoreQueryFilters()
+            c => !c.IsDeleted && c.IsActive, ignoreQueryFilters: true)).ToList();
-            .Where(c => !c.IsDeleted && c.IsActive);
 
         if (model.Target == "Plan" && model.TargetPlan.HasValue)
-            companyQuery = companyQuery.Where(c => c.SubscriptionPlan == model.TargetPlan.Value);
+            companies = companies.Where(c => c.SubscriptionPlan == model.TargetPlan.Value).ToList();
         else if (model.Target == "Company" && model.TargetCompanyId.HasValue)
-            companyQuery = companyQuery.Where(c => c.Id == model.TargetCompanyId.Value);
+            companies = companies.Where(c => c.Id == model.TargetCompanyId.Value).ToList();
 
-        var companyIds = await companyQuery.Select(c => c.Id).ToListAsync();
+        foreach (var company in companies)
-
+            await _inApp.CreateAsync(company.Id, model.Title, model.Message, "Announcement");
-        foreach (var companyId in companyIds)
-        {
-            await _inApp.CreateAsync(
-                companyId,
-                model.Title,
-                model.Message,
-                "Announcement");
-        }
     }
 
     /// <summary>
-    /// Loads company and plan lists into ViewBag for the Create/Edit form dropdowns. Uses AsNoTracking and IgnoreQueryFilters to bypass soft-delete and tenant filters so all companies are available for targeting.
+    /// Loads company and plan lists into ViewBag for the Create/Edit form dropdowns. Uses IgnoreQueryFilters to bypass soft-delete and tenant filters so all companies are available for targeting.
     /// </summary>
-    private void PopulateDropdowns()
+    private async Task PopulateDropdownsAsync()
     {
-        ViewBag.Companies = _db.Companies.AsNoTracking().IgnoreQueryFilters()
+        ViewBag.Companies = (await _unitOfWork.Companies.FindAsync(c => !c.IsDeleted, ignoreQueryFilters: true))
-            .Where(c => !c.IsDeleted).OrderBy(c => c.CompanyName)
+            .OrderBy(c => c.CompanyName)
-            .Select(c => new { c.Id, c.CompanyName }).ToList();
+            .Select(c => new { c.Id, c.CompanyName })
-        ViewBag.PlanConfigs = _db.SubscriptionPlanConfigs.AsNoTracking().IgnoreQueryFilters()
+            .ToList();
-            .Where(p => p.IsActive).OrderBy(p => p.SortOrder).ToList();
+        ViewBag.PlanConfigs = (await _unitOfWork.SubscriptionPlanConfigs.FindAsync(p => p.IsActive, ignoreQueryFilters: true))
+            .OrderBy(p => p.SortOrder)
+            .ToList();
     }
 }

src/PowderCoating.Web/Controllers/AuditLogController.cs

@@ -14,6 +14,7 @@ namespace PowderCoating.Web.Controllers;
 /// the application — they are append-only by design to maintain an unambiguous
 /// trail of changes across all tenants.
 /// </summary>
+// Intentional exception: platform audit log with a long PK; append-only infrastructure table outside the business entity graph; same reasoning as SystemLogsController. See docs/DATA_ACCESS_ARCHITECTURE.md — Permanent Exceptions.
 [Authorize(Policy = AppConstants.Policies.SuperAdminOnly)]
 public class AuditLogController : Controller
 {

src/PowderCoating.Web/Controllers/BannedIpsController.cs

@@ -1,9 +1,8 @@
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Identity;
 using Microsoft.AspNetCore.Mvc;
-using Microsoft.EntityFrameworkCore;
 using PowderCoating.Core.Entities;
-using PowderCoating.Infrastructure.Data;
+using PowderCoating.Core.Interfaces;
 using PowderCoating.Shared.Constants;
 
 namespace PowderCoating.Web.Controllers;
@@ -15,28 +14,26 @@ namespace PowderCoating.Web.Controllers;
 [Authorize(Policy = AppConstants.Policies.SuperAdminOnly)]
 public class BannedIpsController : Controller
 {
-    private readonly ApplicationDbContext _db;
+    private readonly IUnitOfWork _unitOfWork;
     private readonly UserManager<ApplicationUser> _userManager;
     private readonly ILogger<BannedIpsController> _logger;
 
     public BannedIpsController(
-        ApplicationDbContext db,
+        IUnitOfWork unitOfWork,
         UserManager<ApplicationUser> userManager,
         ILogger<BannedIpsController> logger)
     {
-        _db = db;
+        _unitOfWork = unitOfWork;
         _userManager = userManager;
         _logger = logger;
     }
 
     /// <summary>Lists all banned IPs, showing active and expired separately.</summary>
-    // GET: BannedIps
     public async Task<IActionResult> Index()
     {
-        var bans = await _db.BannedIps
+        var bans = (await _unitOfWork.BannedIps.GetAllAsync())
             .OrderByDescending(b => b.BannedAt)
-            .ToListAsync();
+            .ToList();
-
         return View(bans);
     }
 
@@ -44,9 +41,7 @@ public class BannedIpsController : Controller
     /// Adds a new IP ban. Rejects obviously invalid formats but doesn't require
     /// a perfect regex — admins are trusted to enter valid IPs.
     /// </summary>
-    // POST: BannedIps/Add
+    [HttpPost, ValidateAntiForgeryToken]
-    [HttpPost]
-    [ValidateAntiForgeryToken]
     public async Task<IActionResult> Add(string ipAddress, string? reason, DateTime? expiresAt)
     {
         if (string.IsNullOrWhiteSpace(ipAddress))
@@ -57,15 +52,13 @@ public class BannedIpsController : Controller
 
         ipAddress = ipAddress.Trim();
 
-        // Basic sanity check — must look like an IPv4 or IPv6 address
         if (!System.Net.IPAddress.TryParse(ipAddress, out _))
         {
             TempData["Error"] = $"'{ipAddress}' is not a valid IP address.";
             return RedirectToAction(nameof(Index));
         }
 
-        // Don't duplicate an active ban for the same IP
+        var existing = await _unitOfWork.BannedIps.FirstOrDefaultAsync(b => b.IpAddress == ipAddress && b.IsActive);
-        var existing = await _db.BannedIps.FirstOrDefaultAsync(b => b.IpAddress == ipAddress && b.IsActive);
         if (existing != null)
         {
             TempData["Error"] = $"{ipAddress} already has an active ban (added {existing.BannedAt:MMM dd, yyyy}).";
@@ -74,7 +67,7 @@ public class BannedIpsController : Controller
 
         var currentUser = await _userManager.GetUserAsync(User);
 
-        _db.BannedIps.Add(new BannedIp
+        await _unitOfWork.BannedIps.AddAsync(new BannedIp
         {
             IpAddress = ipAddress,
             Reason = reason?.Trim(),
@@ -83,8 +76,7 @@ public class BannedIpsController : Controller
             ExpiresAt = expiresAt,
             IsActive = true
         });
-
+        await _unitOfWork.CompleteAsync();
-        await _db.SaveChangesAsync();
 
         _logger.LogWarning("IP {IP} banned by {Admin}. Reason: {Reason}", ipAddress, User.Identity?.Name, reason);
         TempData["Success"] = $"{ipAddress} has been banned.";
@@ -92,12 +84,10 @@ public class BannedIpsController : Controller
     }
 
     /// <summary>Lifts a ban immediately by marking IsActive = false.</summary>
-    // POST: BannedIps/Lift/5
+    [HttpPost, ValidateAntiForgeryToken]
-    [HttpPost]
-    [ValidateAntiForgeryToken]
     public async Task<IActionResult> Lift(int id)
     {
-        var ban = await _db.BannedIps.FindAsync(id);
+        var ban = await _unitOfWork.BannedIps.GetByIdAsync(id);
         if (ban == null)
         {
             TempData["Error"] = "Ban not found.";
@@ -105,7 +95,7 @@ public class BannedIpsController : Controller
         }
 
         ban.IsActive = false;
-        await _db.SaveChangesAsync();
+        await _unitOfWork.CompleteAsync();
 
         _logger.LogInformation("IP ban lifted for {IP} by {Admin}", ban.IpAddress, User.Identity?.Name);
         TempData["Success"] = $"Ban on {ban.IpAddress} has been lifted.";
@@ -113,25 +103,21 @@ public class BannedIpsController : Controller
     }
 
     /// <summary>Permanently deletes a ban record.</summary>
-    // POST: BannedIps/Delete/5
+    [HttpPost, ValidateAntiForgeryToken]
-    [HttpPost]
-    [ValidateAntiForgeryToken]
     public async Task<IActionResult> Delete(int id)
     {
-        var ban = await _db.BannedIps.FindAsync(id);
+        var ban = await _unitOfWork.BannedIps.GetByIdAsync(id);
         if (ban != null)
         {
-            _db.BannedIps.Remove(ban);
+            await _unitOfWork.BannedIps.DeleteAsync(ban);
-            await _db.SaveChangesAsync();
+            await _unitOfWork.CompleteAsync();
             _logger.LogInformation("IP ban record deleted for {IP} by {Admin}", ban.IpAddress, User.Identity?.Name);
             TempData["Success"] = $"Ban record for {ban.IpAddress} deleted.";
         }
-
         return RedirectToAction(nameof(Index));
     }
 
     /// <summary>Returns the requesting client's IP so the admin can pre-fill it quickly.</summary>
-    // GET: BannedIps/MyIp
     public IActionResult MyIp()
     {
         return Json(new { ip = HttpContext.Connection.RemoteIpAddress?.ToString() ?? "unknown" });

src/PowderCoating.Web/Controllers/BugReportController.cs

@@ -10,7 +10,6 @@ using PowderCoating.Application.Interfaces;
 using PowderCoating.Core.Entities;
 using PowderCoating.Core.Enums;
 using PowderCoating.Core.Interfaces;
-using PowderCoating.Infrastructure.Data;
 using PowderCoating.Shared.Constants;
 
 namespace PowderCoating.Web.Controllers;
@@ -22,7 +21,6 @@ public class BugReportController : Controller
     private readonly IMapper _mapper;
     private readonly ITenantContext _tenantContext;
     private readonly UserManager<ApplicationUser> _userManager;
-    private readonly ApplicationDbContext _context;
     private readonly IEmailService _emailService;
     private readonly IAdminNotificationService _adminNotification;
     private readonly IAzureBlobStorageService _blobService;
@@ -40,7 +38,6 @@ public class BugReportController : Controller
         IMapper mapper,
         ITenantContext tenantContext,
         UserManager<ApplicationUser> userManager,
-        ApplicationDbContext context,
         IEmailService emailService,
         IAdminNotificationService adminNotification,
         IAzureBlobStorageService blobService,
@@ -51,7 +48,6 @@ public class BugReportController : Controller
         _mapper = mapper;
         _tenantContext = tenantContext;
         _userManager = userManager;
-        _context = context;
         _emailService = emailService;
         _adminNotification = adminNotification;
         _blobService = blobService;
@@ -153,7 +149,7 @@ public class BugReportController : Controller
                             ContentType = file.ContentType,
                             FileSizeBytes = file.Length
                         };
-                        _context.BugReportAttachments.Add(attachment);
+                        await _unitOfWork.BugReportAttachments.AddAsync(attachment);
                         uploadedCount++;
                     }
                     else
@@ -164,7 +160,7 @@ public class BugReportController : Controller
                 }
 
                 if (uploadedCount > 0)
-                    await _context.SaveChangesAsync();
+                    await _unitOfWork.CompleteAsync();
             }
 
             _logger.LogInformation("Bug report #{Id} submitted by {UserName} ({Company}): {Title} with {AttachmentCount} attachment(s)",
@@ -211,16 +207,13 @@ public class BugReportController : Controller
         pageNumber = Math.Max(1, pageNumber);
         pageSize = pageSize is 10 or 25 or 50 or 100 ? pageSize : 25;
 
-        var query = _context.BugReports
+        var allReports = (await _unitOfWork.BugReports.GetAllAsync(ignoreQueryFilters: true))
-            .AsNoTracking()
+            .AsEnumerable();
-            .IgnoreQueryFilters()
-            .Where(r => !r.IsDeleted)
-            .AsQueryable();
 
         if (!string.IsNullOrWhiteSpace(searchTerm))
         {
             var search = searchTerm.ToLower();
-            query = query.Where(r =>
+            allReports = allReports.Where(r =>
                 r.Title.ToLower().Contains(search) ||
                 r.Description.ToLower().Contains(search) ||
                 r.SubmittedByUserName.ToLower().Contains(search));
@@ -228,31 +221,31 @@ public class BugReportController : Controller
 
         if (!string.IsNullOrWhiteSpace(statusFilter) &&
             Enum.TryParse<BugReportStatus>(statusFilter, out var status))
-            query = query.Where(r => r.Status == status);
+            allReports = allReports.Where(r => r.Status == status);
 
         if (!string.IsNullOrWhiteSpace(priorityFilter) &&
             Enum.TryParse<BugReportPriority>(priorityFilter, out var priority))
-            query = query.Where(r => r.Priority == priority);
+            allReports = allReports.Where(r => r.Priority == priority);
 
-        query = (sortColumn, sortDirection == "asc") switch
+        allReports = (sortColumn, sortDirection == "asc") switch
         {
-            ("Title", true)      => query.OrderBy(r => r.Title),
+            ("Title", true)      => allReports.OrderBy(r => r.Title),
-            ("Title", false)     => query.OrderByDescending(r => r.Title),
+            ("Title", false)     => allReports.OrderByDescending(r => r.Title),
-            ("Status", true)     => query.OrderBy(r => r.Status),
+            ("Status", true)     => allReports.OrderBy(r => r.Status),
-            ("Status", false)    => query.OrderByDescending(r => r.Status),
+            ("Status", false)    => allReports.OrderByDescending(r => r.Status),
-            ("Priority", true)   => query.OrderBy(r => r.Priority),
+            ("Priority", true)   => allReports.OrderBy(r => r.Priority),
-            ("Priority", false)  => query.OrderByDescending(r => r.Priority),
+            ("Priority", false)  => allReports.OrderByDescending(r => r.Priority),
-            ("Submitted", true)  => query.OrderBy(r => r.SubmittedByUserName),
+            ("Submitted", true)  => allReports.OrderBy(r => r.SubmittedByUserName),
-            ("Submitted", false) => query.OrderByDescending(r => r.SubmittedByUserName),
+            ("Submitted", false) => allReports.OrderByDescending(r => r.SubmittedByUserName),
-            (_, true)            => query.OrderBy(r => r.CreatedAt),
+            (_, true)            => allReports.OrderBy(r => r.CreatedAt),
-            _                    => query.OrderByDescending(r => r.CreatedAt)
+            _                    => allReports.OrderByDescending(r => r.CreatedAt)
         };
 
-        var totalCount = await query.CountAsync();
+        var totalCount = allReports.Count();
-        var items = await query
+        var items = allReports
             .Skip((pageNumber - 1) * pageSize)
             .Take(pageSize)
-            .ToListAsync();
+            .ToList();
 
         var dtos = _mapper.Map<List<BugReportDto>>(items);
 
@@ -291,12 +284,10 @@ public class BugReportController : Controller
 
         var dto = _mapper.Map<EditBugReportDto>(bugReport);
 
-        var attachments = await _context.BugReportAttachments
+        var attachments = (await _unitOfWork.BugReportAttachments.FindAsync(
-            .AsNoTracking()
+                a => a.BugReportId == id && !a.IsDeleted, ignoreQueryFilters: true))
-            .IgnoreQueryFilters()
-            .Where(a => a.BugReportId == id && !a.IsDeleted)
             .OrderBy(a => a.CreatedAt)
-            .ToListAsync();
+            .ToList();
 
         dto.Attachments = _mapper.Map<List<BugReportAttachmentDto>>(attachments);
 
@@ -319,10 +310,7 @@ public class BugReportController : Controller
     [HttpGet]
     public async Task<IActionResult> Attachment(int id)
     {
-        var attachment = await _context.BugReportAttachments
+        var attachment = await _unitOfWork.BugReportAttachments.GetByIdAsync(id, ignoreQueryFilters: true);
-            .AsNoTracking()
-            .IgnoreQueryFilters()
-            .FirstOrDefaultAsync(a => a.Id == id && !a.IsDeleted);
 
         if (attachment == null)
             return NotFound();

src/PowderCoating.Web/Controllers/CompaniesController.cs

@@ -7,7 +7,7 @@ using PowderCoating.Application.DTOs.Company;
 using PowderCoating.Application.Interfaces;
 using PowderCoating.Core.Entities;
 using PowderCoating.Core.Interfaces;
-using PowderCoating.Infrastructure.Data;
+using PowderCoating.Core.Interfaces.Services;
 using PowderCoating.Shared.Constants;
 using PowderCoating.Web.Extensions;
 using System.Security.Claims;
@@ -24,7 +24,9 @@ public class CompaniesController : Controller
     private readonly IMapper _mapper;
     private readonly UserManager<ApplicationUser> _userManager;
     private readonly ISeedDataService _seedDataService;
-    private readonly ApplicationDbContext _context;
+    private readonly ICompanyListService _companyList;
+    private readonly ICompanyDataPurgeService _companyPurge;
+    private readonly IAuditLogService _auditLog;
     private readonly IInAppNotificationService _inApp;
     private readonly ILogger<CompaniesController> _logger;
 
@@ -33,7 +35,9 @@ public class CompaniesController : Controller
         IMapper mapper,
         UserManager<ApplicationUser> userManager,
         ISeedDataService seedDataService,
-        ApplicationDbContext context,
+        ICompanyListService companyList,
+        ICompanyDataPurgeService companyPurge,
+        IAuditLogService auditLog,
         IInAppNotificationService inApp,
         ILogger<CompaniesController> logger)
     {
@@ -41,7 +45,9 @@ public class CompaniesController : Controller
         _mapper = mapper;
         _userManager = userManager;
         _seedDataService = seedDataService;
-        _context = context;
+        _companyList = companyList;
+        _companyPurge = companyPurge;
+        _auditLog = auditLog;
         _inApp = inApp;
         _logger = logger;
     }
@@ -67,88 +73,27 @@ public class CompaniesController : Controller
             pageNumber = Math.Max(1, pageNumber);
             pageSize = pageSize is 10 or 25 or 50 or 100 ? pageSize : 25;
 
-            var query = _context.Companies
+            var (companies, totalCount) = await _companyList.GetPagedAsync(
-                .AsNoTracking()
+                searchTerm, sortColumn, sortDirection, pageNumber, pageSize);
-                .IgnoreQueryFilters()
-                .Where(c => !c.IsDeleted)
-                .AsQueryable();
-
-            if (!string.IsNullOrWhiteSpace(searchTerm))
-            {
-                var s = searchTerm.ToLower();
-                query = query.Where(c =>
-                    c.CompanyName.ToLower().Contains(s) ||
-                    (c.CompanyCode != null && c.CompanyCode.ToLower().Contains(s)) ||
-                    (c.PrimaryContactEmail != null && c.PrimaryContactEmail.ToLower().Contains(s)) ||
-                    (c.Phone != null && c.Phone.ToLower().Contains(s)));
-            }
-
-            query = (sortColumn, sortDirection == "asc") switch
-            {
-                ("CompanyName", true)  => query.OrderBy(c => c.CompanyName),
-                ("CompanyName", false) => query.OrderByDescending(c => c.CompanyName),
-                ("Plan", true)         => query.OrderBy(c => c.SubscriptionPlan),
-                ("Plan", false)        => query.OrderByDescending(c => c.SubscriptionPlan),
-                ("Status", true)       => query.OrderBy(c => c.IsActive),
-                ("Status", false)      => query.OrderByDescending(c => c.IsActive),
-                ("Created", true)      => query.OrderBy(c => c.CreatedAt),
-                ("Created", false)     => query.OrderByDescending(c => c.CreatedAt),
-                _                      => query.OrderBy(c => c.CompanyName)
-            };
-
-            var totalCount = await query.CountAsync();
-            var companies = await query
-                .Include(c => c.Users)
-                .Skip((pageNumber - 1) * pageSize)
-                .Take(pageSize)
-                .ToListAsync();
 
             var companyDtos = _mapper.Map<List<CompanyListDto>>(companies);
 
-            // Populate job/quote/customer counts efficiently via group queries
+            if (companyDtos.Count > 0)
-            if (companyDtos.Any())
             {
                 var ids = companyDtos.Select(c => c.Id).ToList();
-
+                var summary = await _companyList.GetCountSummaryAsync(ids);
-                var jobCounts = await _context.Jobs.IgnoreQueryFilters()
-                    .Where(j => ids.Contains(j.CompanyId) && !j.IsDeleted)
-                    .GroupBy(j => j.CompanyId)
-                    .Select(g => new { g.Key, Count = g.Count() })
-                    .ToDictionaryAsync(x => x.Key, x => x.Count);
-
-                var quoteCounts = await _context.Quotes.IgnoreQueryFilters()
-                    .Where(q => ids.Contains(q.CompanyId) && !q.IsDeleted)
-                    .GroupBy(q => q.CompanyId)
-                    .Select(g => new { g.Key, Count = g.Count() })
-                    .ToDictionaryAsync(x => x.Key, x => x.Count);
-
-                var customerCounts = await _context.Customers.IgnoreQueryFilters()
-                    .Where(c => ids.Contains(c.CompanyId) && !c.IsDeleted)
-                    .GroupBy(c => c.CompanyId)
-                    .Select(g => new { g.Key, Count = g.Count() })
-                    .ToDictionaryAsync(x => x.Key, x => x.Count);
-
-                var wizardData = await _context.CompanyPreferences.IgnoreQueryFilters()
-                    .Where(p => ids.Contains(p.CompanyId) && p.SetupWizardCompleted)
-                    .Select(p => new
-                    {
-                        p.CompanyId,
-                        p.SetupWizardCompletedAt,
-                        p.SetupWizardCompletedByName
-                    })
-                    .ToDictionaryAsync(x => x.CompanyId);
 
                 foreach (var dto in companyDtos)
                 {
-                    dto.JobCount = jobCounts.GetValueOrDefault(dto.Id, 0);
+                    dto.JobCount = summary.JobCounts.GetValueOrDefault(dto.Id, 0);
-                    dto.QuoteCount = quoteCounts.GetValueOrDefault(dto.Id, 0);
+                    dto.QuoteCount = summary.QuoteCounts.GetValueOrDefault(dto.Id, 0);
-                    dto.CustomerCount = customerCounts.GetValueOrDefault(dto.Id, 0);
+                    dto.CustomerCount = summary.CustomerCounts.GetValueOrDefault(dto.Id, 0);
 
-                    if (wizardData.TryGetValue(dto.Id, out var w))
+                    if (summary.WizardInfo.TryGetValue(dto.Id, out var w))
                     {
                         dto.WizardCompleted = true;
-                        dto.WizardCompletedAt = w.SetupWizardCompletedAt;
+                        dto.WizardCompletedAt = w.CompletedAt;
-                        dto.WizardCompletedByName = w.SetupWizardCompletedByName;
+                        dto.WizardCompletedByName = w.CompletedByName;
                     }
                 }
             }
@@ -380,8 +325,6 @@ public class CompaniesController : Controller
             }
             else
             {
-                // If user creation failed, we should consider rolling back company creation
-                // For now, log the error and inform the user
                 _logger.LogError("Failed to create admin user for company {CompanyName}: {Errors}",
                     company.CompanyName, string.Join(", ", result.Errors.Select(e => e.Description)));
 
@@ -441,14 +384,10 @@ public class CompaniesController : Controller
     public async Task<IActionResult> Edit(int id, UpdateCompanyDto model)
     {
         if (id != model.Id)
-        {
             return NotFound();
-        }
 
         if (!ModelState.IsValid)
-        {
             return View(model);
-        }
 
         try
         {
@@ -473,9 +412,7 @@ public class CompaniesController : Controller
                 }
             }
 
-            // Update company properties
             _mapper.Map(model, company);
-
             await _unitOfWork.CompleteAsync();
 
             _logger.LogInformation("Company {CompanyName} updated successfully by {User}",
@@ -560,7 +497,6 @@ public class CompaniesController : Controller
             var companyName = company.CompanyName;
             var userCount = company.Users.Count;
 
-            // Soft-delete the company and deactivate all users
             company.IsDeleted = true;
             company.IsActive = false;
             company.UpdatedAt = DateTime.UtcNow;
@@ -573,8 +509,7 @@ public class CompaniesController : Controller
 
             await _unitOfWork.CompleteAsync();
 
-            // Write audit log
+            await _auditLog.LogAsync(new AuditLog
-            _context.AuditLogs.Add(new AuditLog
             {
                 UserId = adminUserId,
                 UserName = adminName,
@@ -588,7 +523,6 @@ public class CompaniesController : Controller
                 Timestamp = DateTime.UtcNow,
                 IpAddress = HttpContext.Connection.RemoteIpAddress?.ToString()
             });
-            await _context.SaveChangesAsync();
 
             _logger.LogWarning("Company {CompanyName} (ID:{CompanyId}) soft-deleted by {User}",
                 companyName, id, adminName);
@@ -625,8 +559,7 @@ public class CompaniesController : Controller
             return RedirectToAction(nameof(Index));
         }
 
-        var company = await _context.Companies.IgnoreQueryFilters()
+        var company = await _unitOfWork.Companies.GetByIdAsync(id, ignoreQueryFilters: true);
-            .FirstOrDefaultAsync(c => c.Id == id);
 
         if (company == null)
         {
@@ -640,91 +573,25 @@ public class CompaniesController : Controller
 
         try
         {
-            // ── Tier 1: Leaf children (must go before their parents) ─────────────
+            // Load user IDs first — needed for announcement-dismissal cleanup in the purge service
-            // JobItem children
-            await _context.JobItemPrepServices.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.JobItemCoats.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-
-            // QuoteItem children
-            await _context.QuoteItemPrepServices.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.QuoteItemCoats.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-
-            // AnnouncementDismissals (no CompanyId — delete by user or company-targeted announcement)
             var userIds = await _userManager.Users.IgnoreQueryFilters()
                 .Where(u => u.CompanyId == id).Select(u => u.Id).ToListAsync();
-            var announcementIds = await _context.Announcements
-                .Where(a => a.TargetCompanyId == id).Select(a => a.Id).ToListAsync();
-            await _context.AnnouncementDismissals.IgnoreQueryFilters()
-                .Where(x => userIds.Contains(x.UserId) || announcementIds.Contains(x.AnnouncementId))
-                .ExecuteDeleteAsync();
 
-            // ── Tier 2: Mid-level children ────────────────────────────────────────
+            // Tiers 1-4: bulk delete all business data (service mirrors the original tier ordering)
-            await _context.JobItems.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
+            await _companyPurge.DeleteAllBusinessDataAsync(id, userIds);
-            await _context.QuoteItems.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.JobStatusHistory.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.JobChangeHistories.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.JobPhotos.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.JobNotes.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.JobDailyPriorities.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.QuoteChangeHistories.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.CustomerNotes.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.InventoryTransactions.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.MaintenanceRecords.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.BillLineItems.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.BillPayments.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.Payments.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.InvoiceItems.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.JobPrepServices.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.QuotePrepServices.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
 
-            // ── Tier 3: Top-level company entities ───────────────────────────────
+            // Tier 5: delete Identity users so AspNetUser* tables cascade correctly
-            // Order matters: child-side of FK must be deleted before parent-side.
-            // Invoices/Appointments → Customers;  Bills/Expenses → Vendors
-            await _context.Invoices.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.Appointments.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.Jobs.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.Quotes.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.Customers.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.Bills.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.Expenses.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.Vendors.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.InventoryItems.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.Equipment.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.OvenCosts.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.CatalogItems.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.Accounts.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.NotificationLogs.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.NotificationTemplates.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            // Announcements are platform-wide; only delete company-targeted ones (TargetCompanyId)
-            await _context.Announcements.Where(x => x.TargetCompanyId == id).ExecuteDeleteAsync();
-            await _context.BugReports.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.ShopWorkers.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.PrepServices.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-
-            // ── Tier 4: Company configs and lookup tables ─────────────────────────
-            await _context.CatalogCategories.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.InventoryCategoryLookups.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.JobStatusLookups.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.JobPriorityLookups.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.QuoteStatusLookups.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.AppointmentStatusLookups.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.AppointmentTypeLookups.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.PricingTiers.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.CompanyOperatingCosts.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.CompanyPreferences.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-
-            // ── Tier 5: Users (via Identity to cascade AspNetUser* tables) ────────
             var users = await _userManager.Users.IgnoreQueryFilters()
                 .Where(u => u.CompanyId == id).ToListAsync();
             var userCount = users.Count;
             foreach (var user in users)
                 await _userManager.DeleteAsync(user);
 
-            // ── Tier 6: Company record ────────────────────────────────────────────
+            // Tier 6: delete company record
-            await _context.Companies.IgnoreQueryFilters().Where(c => c.Id == id).ExecuteDeleteAsync();
+            await _unitOfWork.Companies.DeleteAsync(company);
+            await _unitOfWork.CompleteAsync();
 
-            // Write audit log (use platform default company context — no companyId since it's gone)
+            await _auditLog.LogAsync(new AuditLog
-            _context.AuditLogs.Add(new AuditLog
             {
                 UserId = adminUserId,
                 UserName = adminName,
@@ -738,7 +605,6 @@ public class CompaniesController : Controller
                 Timestamp = DateTime.UtcNow,
                 IpAddress = HttpContext.Connection.RemoteIpAddress?.ToString()
             });
-            await _context.SaveChangesAsync();
 
             _logger.LogWarning("Company {CompanyName} (ID:{CompanyId}) HARD DELETED by {User}. {UserCount} users removed.",
                 companyName, id, adminName, userCount);
@@ -764,8 +630,6 @@ public class CompaniesController : Controller
     /// to record the action. This operation is irreversible.
     /// </summary>
     // POST: Companies/ResetData/5
-    // Permanently hard-deletes all business data for a company while keeping the company record,
-    // its users, operating costs, preferences, and lookup tables intact.
     [HttpPost]
     [ValidateAntiForgeryToken]
     public async Task<IActionResult> ResetData(int id, string confirmation)
@@ -776,8 +640,7 @@ public class CompaniesController : Controller
             return RedirectToAction(nameof(Details), new { id });
         }
 
-        var company = await _context.Companies.IgnoreQueryFilters()
+        var company = await _unitOfWork.Companies.GetByIdAsync(id, ignoreQueryFilters: true);
-            .FirstOrDefaultAsync(c => c.Id == id);
 
         if (company == null)
         {
@@ -791,94 +654,9 @@ public class CompaniesController : Controller
 
         try
         {
-            // ── Tier 0: Grandchildren ─────────────────────────────────────────────
+            await _companyPurge.ResetBusinessDataAsync(id);
-            await _context.JobTemplateItemPrepServices .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.JobTemplateItemCoats        .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.JobItemPrepServices         .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.JobItemCoats                .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.QuoteItemPrepServices       .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.QuoteItemCoats              .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.GiftCertificateRedemptions  .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.CreditMemoApplications      .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.OvenBatchItems              .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
 
-            // AnnouncementDismissals for company-targeted announcements
+            await _auditLog.LogAsync(new AuditLog
-            var announcementIds = await _context.Announcements
-                .Where(a => a.TargetCompanyId == id).Select(a => a.Id).ToListAsync();
-            if (announcementIds.Any())
-                await _context.AnnouncementDismissals.IgnoreQueryFilters()
-                    .Where(x => announcementIds.Contains(x.AnnouncementId))
-                    .ExecuteDeleteAsync();
-
-            // ── Tier 1: Children ──────────────────────────────────────────────────
-            await _context.JobTemplateItems    .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.JobItems            .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.QuoteItems          .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.JobStatusHistory    .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.JobChangeHistories  .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.JobPhotos           .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.JobNotes            .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.JobDailyPriorities  .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.JobTimeEntries      .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.JobPrepServices     .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.ReworkRecords       .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.QuoteChangeHistories.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.QuotePrepServices   .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.QuotePhotos         .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.CustomerNotes       .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.InventoryTransactions.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.MaintenanceRecords  .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.BillLineItems       .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.BillPayments        .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.Payments            .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.Deposits            .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.InvoiceItems        .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.PurchaseOrderItems  .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.AiItemPredictions   .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.PowderUsageLogs     .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.ShopWorkerRoleCosts .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.OvenBatches         .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.Refunds             .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.CreditMemos         .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.GiftCertificates    .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-
-            // ── Tier 2: Top-level business entities ──────────────────────────────
-            // Order matters: child-side of FK must be deleted before parent-side.
-            // Invoices/Appointments → Customers;  Bills/PurchaseOrders/Expenses → Vendors
-            await _context.Invoices         .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.Appointments     .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.Jobs             .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.JobTemplates     .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.Quotes           .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.Customers        .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.Bills            .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.PurchaseOrders   .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.Expenses         .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.Vendors          .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.CatalogItems     .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.InventoryItems   .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.Equipment        .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.OvenCosts        .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.Accounts         .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.NotificationLogs .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.ShopWorkers      .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.PrepServices     .IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.CatalogCategories.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            await _context.InventoryCategoryLookups.IgnoreQueryFilters().Where(x => x.CompanyId == id).ExecuteDeleteAsync();
-            // Company-targeted announcements only (platform-wide announcements are left alone)
-            await _context.Announcements.Where(x => x.TargetCompanyId == id).ExecuteDeleteAsync();
-
-            // Reset QB migration wizard progress
-            var prefs = await _context.CompanyPreferences.IgnoreQueryFilters()
-                .FirstOrDefaultAsync(p => p.CompanyId == id);
-            if (prefs?.QbMigrationStateJson != null)
-            {
-                prefs.QbMigrationStateJson = null;
-                prefs.UpdatedAt = DateTime.UtcNow;
-            }
-
-            // Audit log
-            _context.AuditLogs.Add(new AuditLog
             {
                 UserId           = adminUserId,
                 UserName         = adminName,
@@ -892,7 +670,6 @@ public class CompaniesController : Controller
                 Timestamp        = DateTime.UtcNow,
                 IpAddress        = HttpContext.Connection.RemoteIpAddress?.ToString()
             });
-            await _context.SaveChangesAsync();
 
             _logger.LogWarning(
                 "Company {CompanyName} (ID:{CompanyId}) ALL BUSINESS DATA RESET by {User}.",
@@ -960,9 +737,7 @@ public class CompaniesController : Controller
         {
             var company = await _unitOfWork.Companies.GetByIdAsync(model.CompanyId, ignoreQueryFilters: true);
             if (company != null)
-            {
                 model.CompanyName = company.CompanyName;
-            }
             return View(model);
         }
 
@@ -976,7 +751,6 @@ public class CompaniesController : Controller
                 return RedirectToAction(nameof(Index));
             }
 
-            // Check if user already exists
             var existingUser = await _userManager.FindByEmailAsync(model.Email);
             if (existingUser != null)
             {
@@ -985,7 +759,6 @@ public class CompaniesController : Controller
                 return View(model);
             }
 
-            // Create admin user for the company
             var adminUser = new ApplicationUser
             {
                 UserName = model.Email,
@@ -1018,9 +791,7 @@ public class CompaniesController : Controller
             else
             {
                 foreach (var error in result.Errors)
-                {
                     ModelState.AddModelError("", error.Description);
-                }
                 model.CompanyName = company.CompanyName;
                 return View(model);
             }
@@ -1054,21 +825,13 @@ public class CompaniesController : Controller
                 return NotFound(new { error = "User not found." });
 
             // Use the viewed company's timezone so timestamps match the tenant's local time
-            var tz = await _context.Companies
+            var company = await _unitOfWork.Companies.GetByIdAsync(companyId, ignoreQueryFilters: true);
-                .Where(c => c.Id == companyId)
+            var tz = company?.TimeZone;
-                .Select(c => c.TimeZone)
-                .FirstOrDefaultAsync();
 
             var logs = new List<dynamic>();
             try
             {
-                var rawLogs = await _context.AuditLogs
+                var rawLogs = await _auditLog.GetUserActivityAsync(userId);
-                    .AsNoTracking()
-                    .Where(l => l.UserId == userId && l.EntityType == "ApplicationUser")
-                    .OrderByDescending(l => l.Timestamp)
-                    .Take(50)
-                    .Select(l => new { l.Action, l.IpAddress, l.Timestamp, l.NewValues })
-                    .ToListAsync();
 
                 logs = rawLogs.Select(l => (dynamic)new
                 {

src/PowderCoating.Web/Controllers/CompanySettingsController.cs

@@ -12,6 +12,7 @@ using PowderCoating.Application.Services;
 using PowderCoating.Core.Entities;
 using PowderCoating.Core.Enums;
 using PowderCoating.Core.Interfaces;
+using PowderCoating.Core.Interfaces.Services;
 using PowderCoating.Infrastructure.Data;
 using PowderCoating.Shared.Constants;
 using System.Security.Claims;
@@ -29,7 +30,7 @@ public class CompanySettingsController : Controller
     private readonly ILookupCacheService _lookupCache;
     private readonly IStripeConnectService _stripeConnect;
     private readonly IConfiguration _configuration;
-    private readonly ApplicationDbContext _context;
+    private readonly IAuditLogService _auditLog;
     private readonly UserManager<ApplicationUser> _userManager;
     private readonly SignInManager<ApplicationUser> _signInManager;
 
@@ -42,7 +43,7 @@ public class CompanySettingsController : Controller
         ILookupCacheService lookupCache,
         IStripeConnectService stripeConnect,
         IConfiguration configuration,
-        ApplicationDbContext context,
+        IAuditLogService auditLog,
         UserManager<ApplicationUser> userManager,
         SignInManager<ApplicationUser> signInManager)
     {
@@ -54,7 +55,7 @@ public class CompanySettingsController : Controller
         _lookupCache = lookupCache;
         _stripeConnect = stripeConnect;
         _configuration = configuration;
-        _context = context;
+        _auditLog = auditLog;
         _userManager = userManager;
         _signInManager = signInManager;
     }
@@ -126,9 +127,7 @@ public class CompanySettingsController : Controller
             var dto = _mapper.Map<CompanySettingsDto>(company);
 
             // Populate AllowOnlinePayments from subscription plan config
-            var planConfig = await _context.Set<SubscriptionPlanConfig>()
+            var planConfig = await _unitOfWork.SubscriptionPlanConfigs.FirstOrDefaultAsync(p => p.Plan == company.SubscriptionPlan);
-                .AsNoTracking()
-                .FirstOrDefaultAsync(p => p.Plan == company.SubscriptionPlan);
             dto.AllowOnlinePayments = planConfig?.AllowOnlinePayments ?? false;
 
             // Flag whether Stripe Connect is configured (non-placeholder client ID)
@@ -2805,10 +2804,10 @@ public class CompanySettingsController : Controller
         if (company == null) return NotFound();
 
         var userCount  = await _userManager.Users.CountAsync(u => u.CompanyId == companyId.Value);
-        var jobCount   = await _context.Jobs.CountAsync(j => j.CompanyId == companyId.Value);
+        var jobCount   = await _unitOfWork.Jobs.CountAsync(j => j.CompanyId == companyId.Value);
-        var quoteCount = await _context.Quotes.CountAsync(q => q.CompanyId == companyId.Value);
+        var quoteCount = await _unitOfWork.Quotes.CountAsync(q => q.CompanyId == companyId.Value);
-        var custCount  = await _context.Customers.CountAsync(c => c.CompanyId == companyId.Value);
+        var custCount  = await _unitOfWork.Customers.CountAsync(c => c.CompanyId == companyId.Value);
-        var invCount   = await _context.Invoices.CountAsync(i => i.CompanyId == companyId.Value);
+        var invCount   = await _unitOfWork.Invoices.CountAsync(i => i.CompanyId == companyId.Value);
 
         ViewBag.CompanyName = company.CompanyName;
         ViewBag.UserCount   = userCount;
@@ -2859,10 +2858,10 @@ public class CompanySettingsController : Controller
 
             // ── Gather counts for the audit snapshot ─────────────────────────
             var userCount  = company.Users.Count;
-            var jobCount   = await _context.Jobs.CountAsync(j => j.CompanyId == companyId.Value);
+            var jobCount   = await _unitOfWork.Jobs.CountAsync(j => j.CompanyId == companyId.Value);
-            var quoteCount = await _context.Quotes.CountAsync(q => q.CompanyId == companyId.Value);
+            var quoteCount = await _unitOfWork.Quotes.CountAsync(q => q.CompanyId == companyId.Value);
-            var custCount  = await _context.Customers.CountAsync(c => c.CompanyId == companyId.Value);
+            var custCount  = await _unitOfWork.Customers.CountAsync(c => c.CompanyId == companyId.Value);
-            var invCount   = await _context.Invoices.CountAsync(i => i.CompanyId == companyId.Value);
+            var invCount   = await _unitOfWork.Invoices.CountAsync(i => i.CompanyId == companyId.Value);
 
             // ── Soft-delete the company ───────────────────────────────────────
             var now = DateTime.UtcNow;
@@ -2881,7 +2880,7 @@ public class CompanySettingsController : Controller
             await _unitOfWork.CompleteAsync();
 
             // ── Write audit log ───────────────────────────────────────────────
-            _context.AuditLogs.Add(new AuditLog
+            await _auditLog.LogAsync(new AuditLog
             {
                 UserId            = requestingUserId,
                 UserName          = requestingUserName,
@@ -2899,7 +2898,6 @@ public class CompanySettingsController : Controller
                 Timestamp = now,
                 IpAddress = HttpContext.Connection.RemoteIpAddress?.ToString()
             });
-            await _context.SaveChangesAsync();
 
             _logger.LogWarning(
                 "Self-service account deletion: company {CompanyName} (ID:{CompanyId}) deleted by {User}. " +

src/PowderCoating.Web/Controllers/CompanyUsersController.cs

@@ -9,7 +9,6 @@ using PowderCoating.Application.DTOs.User;
 using PowderCoating.Application.Interfaces;
 using PowderCoating.Core.Entities;
 using PowderCoating.Core.Interfaces;
-using PowderCoating.Infrastructure.Data;
 using PowderCoating.Shared.Constants;
 
 namespace PowderCoating.Web.Controllers;
@@ -25,7 +24,6 @@ public class CompanyUsersController : Controller
     private readonly ILogger<CompanyUsersController> _logger;
     private readonly IUnitOfWork _unitOfWork;
     private readonly ISubscriptionService _subscriptionService;
-    private readonly ApplicationDbContext _context;
     private readonly IEmailService _emailService;
 
     public CompanyUsersController(
@@ -34,7 +32,6 @@ public class CompanyUsersController : Controller
         ILogger<CompanyUsersController> logger,
         IUnitOfWork unitOfWork,
         ISubscriptionService subscriptionService,
-        ApplicationDbContext context,
         IEmailService emailService)
     {
         _userManager = userManager;
@@ -42,7 +39,6 @@ public class CompanyUsersController : Controller
         _logger = logger;
         _unitOfWork = unitOfWork;
         _subscriptionService = subscriptionService;
-        _context = context;
         _emailService = emailService;
     }
 
@@ -372,8 +368,8 @@ public class CompanyUsersController : Controller
                         CompanyId = companyId!.Value
                     };
 
-                    await _context.ShopWorkers.AddAsync(shopWorker);
+                    await _unitOfWork.ShopWorkers.AddAsync(shopWorker);
-                    await _context.SaveChangesAsync();
+                    await _unitOfWork.CompleteAsync();
 
                     _logger.LogInformation("ShopWorker record created for user {Email}", user.Email);
                 }
@@ -639,9 +635,8 @@ public class CompanyUsersController : Controller
                 {
                     // Search by oldEmail so we find the record even when the email just changed
                     var lookupEmail = emailChanged ? oldEmail : user.Email;
-                    var existingShopWorker = await _context.ShopWorkers
+                    var existingShopWorker = (await _unitOfWork.ShopWorkers.FindAsync(
-                        .Where(sw => sw.Email == lookupEmail && sw.CompanyId == user.CompanyId)
+                        sw => sw.Email == lookupEmail && sw.CompanyId == user.CompanyId)).ToList();
-                        .ToListAsync();
 
                     if (!existingShopWorker.Any())
                     {
@@ -656,8 +651,8 @@ public class CompanyUsersController : Controller
                             CompanyId = user.CompanyId
                         };
 
-                        await _context.ShopWorkers.AddAsync(shopWorker);
+                        await _unitOfWork.ShopWorkers.AddAsync(shopWorker);
-                        await _context.SaveChangesAsync();
+                        await _unitOfWork.CompleteAsync();
 
                         _logger.LogInformation("ShopWorker record created for user {Email}", user.Email);
                     }
@@ -684,7 +679,7 @@ public class CompanyUsersController : Controller
                         shopWorker.Phone = user.PhoneNumber;
 
                         if (shopWorkerDirty)
-                            await _context.SaveChangesAsync();
+                            await _unitOfWork.CompleteAsync();
                     }
                 }
 

src/PowderCoating.Web/Controllers/DashboardController.cs

@@ -1,12 +1,11 @@
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
-using Microsoft.EntityFrameworkCore;
 using PowderCoating.Application.DTOs.Dashboard;
 using PowderCoating.Application.Interfaces;
 using PowderCoating.Core.Entities;
-using PowderCoating.Core.Enums; // Still needed for MaintenanceStatus
+using PowderCoating.Core.Enums; // Still needed for MaintenanceStatus, EquipmentStatus, PaymentMethod
 using PowderCoating.Core.Interfaces;
-using PowderCoating.Infrastructure.Data;
+using PowderCoating.Core.Interfaces.Services;
 using PowderCoating.Shared.Constants;
 using InvoiceStatus = PowderCoating.Core.Enums.InvoiceStatus;
 
@@ -17,7 +16,9 @@ public class DashboardController : Controller
 {
     private readonly IUnitOfWork _unitOfWork;
     private readonly ILogger<DashboardController> _logger;
-    private readonly ApplicationDbContext _context;
+    private readonly IDashboardReadService _dashboardRead;
+    private readonly ITenantContext _tenantContext;
+    private readonly ICompanyConfigHealthService _configHealth;
 
     private static readonly string[] CompletedStatusCodes =
     [
@@ -39,14 +40,16 @@ public class DashboardController : Controller
         "QUALITY_CHECK"
     ];
 
-    private readonly ITenantContext _tenantContext;
+    public DashboardController(
-    private readonly ICompanyConfigHealthService _configHealth;
+        IUnitOfWork unitOfWork,
-
+        ILogger<DashboardController> logger,
-    public DashboardController(IUnitOfWork unitOfWork, ILogger<DashboardController> logger, ApplicationDbContext context, ITenantContext tenantContext, ICompanyConfigHealthService configHealth)
+        IDashboardReadService dashboardRead,
+        ITenantContext tenantContext,
+        ICompanyConfigHealthService configHealth)
     {
         _unitOfWork = unitOfWork;
         _logger = logger;
-        _context = context;
+        _dashboardRead = dashboardRead;
         _tenantContext = tenantContext;
         _configHealth = configHealth;
     }
@@ -66,23 +69,14 @@ public class DashboardController : Controller
         try
         {
             var today = DateTime.Today;
-            var startOfMonth = new DateTime(today.Year, today.Month, 1);
+            var lookAheadDate = today.AddDays(7);
-            var endOfMonth = startOfMonth.AddMonths(1).AddDays(-1);
-            var lookAheadDate = today.AddDays(7); // Changed to 7 days for expiring quotes
 
-            // Active jobs — filter completed/cancelled statuses at database level
+            var data = await _dashboardRead.GetIndexDataAsync(today);
-            var activeJobs = await _context.Jobs
-                .Include(j => j.Customer)
-                .Include(j => j.AssignedUser)
-                .Include(j => j.JobStatus)
-                .Include(j => j.JobPriority)
-                .Where(j => !CompletedStatusCodes.Contains(j.JobStatus.StatusCode))
-                .ToListAsync();
 
-            var tomorrow = today.AddDays(1);
+            // ---------------------------------------------------------------
-
+            // Job panels — in-memory split of the pre-fetched activeJobs list
-            // Today's Jobs
+            // ---------------------------------------------------------------
-            var todaysJobsFiltered = activeJobs
+            var todaysJobsFiltered = data.ActiveJobs
                 .Where(j => (j.ScheduledDate.HasValue && j.ScheduledDate.Value.Date == today) ||
                             (j.DueDate.HasValue && j.DueDate.Value.Date == today));
             var todaysJobsCount = todaysJobsFiltered.Count();
@@ -93,8 +87,7 @@ public class DashboardController : Controller
                 .Select(MapJobDto)
                 .ToList();
 
-            // Overdue Jobs
+            var overdueJobsFiltered = data.ActiveJobs
-            var overdueJobsFiltered = activeJobs
                 .Where(j => j.DueDate.HasValue && j.DueDate.Value.Date < today);
             var overdueJobsCount = overdueJobsFiltered.Count();
             var overdueJobs = overdueJobsFiltered
@@ -104,8 +97,7 @@ public class DashboardController : Controller
                 .Select(MapJobDto)
                 .ToList();
 
-            // In-Progress Jobs
+            var inProgressJobs = data.ActiveJobs
-            var inProgressJobs = activeJobs
                 .Where(j => InProgressStatusCodes.Contains(j.JobStatus.StatusCode))
                 .OrderBy(j => j.JobPriority.DisplayOrder)
                 .ThenBy(j => j.ScheduledDate)
@@ -113,26 +105,11 @@ public class DashboardController : Controller
                 .Select(MapJobDto)
                 .ToList();
 
-            // Monthly Revenue — aggregate at database level (no need to load all jobs)
+            // ---------------------------------------------------------------
-            var monthlyRevenue = await _context.Jobs
+            // Appointments
-                .Include(j => j.JobStatus)
+            // ---------------------------------------------------------------
-                .Where(j => CompletedStatusCodes.Contains(j.JobStatus.StatusCode)
+            var todaysAppointmentsCount = data.TodaysAppointments.Count;
-                         && j.UpdatedAt >= startOfMonth
+            var todaysAppointments = data.TodaysAppointments
-                         && j.UpdatedAt <= endOfMonth)
-                .SumAsync(j => j.FinalPrice);
-
-            // Today's Appointments — filter at database level
-            var todaysAppointmentsRaw = await _context.Appointments
-                .Include(a => a.Customer)
-                .Include(a => a.AppointmentType)
-                .Include(a => a.AppointmentStatus)
-                .Include(a => a.AssignedUser)
-                .Where(a => a.ScheduledStartTime >= today && a.ScheduledStartTime < tomorrow
-                         && a.AppointmentStatus.StatusCode != "CANCELLED")
-                .OrderBy(a => a.ScheduledStartTime)
-                .ToListAsync();
-            var todaysAppointmentsCount = todaysAppointmentsRaw.Count;
-            var todaysAppointments = todaysAppointmentsRaw
                 .Take(10)
                 .Select(a => new DashboardAppointmentDto
                 {
@@ -150,9 +127,11 @@ public class DashboardController : Controller
                     AssignedWorkerName = a.AssignedUser?.FullName
                 }).ToList();
 
+            // ---------------------------------------------------------------
             // Low stock items
+            // ---------------------------------------------------------------
             var lowStockAll = await _unitOfWork.InventoryItems.FindAsync(
-                    i => i.IsActive && i.QuantityOnHand <= i.ReorderPoint);
+                i => i.IsActive && i.QuantityOnHand <= i.ReorderPoint);
             var lowStockCount = lowStockAll.Count();
             var lowStockItems = lowStockAll
                 .OrderBy(i => i.QuantityOnHand)
@@ -168,21 +147,10 @@ public class DashboardController : Controller
                     UnitOfMeasure = i.UnitOfMeasure
                 }).ToList();
 
-            // Maintenance records — filter to pending/overdue at database level
+            // ---------------------------------------------------------------
-            var upcomingMaintenance = await _context.MaintenanceRecords
+            // Maintenance
-                .Include(m => m.Equipment)
+            // ---------------------------------------------------------------
-                .Include(m => m.AssignedUser)
+            var upcomingMaintenanceDtos = data.UpcomingMaintenance
-                .Where(m => (m.Status == MaintenanceStatus.Scheduled
-                          || m.Status == MaintenanceStatus.InProgress
-                          || m.Status == MaintenanceStatus.Overdue)
-                         && (m.Status == MaintenanceStatus.Overdue || m.ScheduledDate <= lookAheadDate))
-                .OrderBy(m => m.Status == MaintenanceStatus.Overdue ? 0 : 1)
-                .ThenByDescending(m => m.Priority)
-                .ThenBy(m => m.ScheduledDate)
-                .Take(10)
-                .ToListAsync();
-
-            var upcomingMaintenanceDtos = upcomingMaintenance
                 .Select(m => new DashboardMaintenanceDto
                 {
                     Id = m.Id,
@@ -195,14 +163,10 @@ public class DashboardController : Controller
                     AssignedWorkerName = m.AssignedUser?.FullName
                 }).ToList();
 
-            // Pending Quotes — filter to SENT status at database level
+            // ---------------------------------------------------------------
-            var pendingQuotesData = await _context.Quotes
+            // Quotes
-                .Include(q => q.Customer)
+            // ---------------------------------------------------------------
-                .Include(q => q.QuoteStatus)
+            var pendingQuotes = data.PendingQuotes
-                .Where(q => q.QuoteStatus.StatusCode == "SENT")
-                .ToListAsync();
-
-            var pendingQuotes = pendingQuotesData
                 .OrderBy(q => q.ExpirationDate)
                 .Take(10)
                 .Select(q => new DashboardQuoteDto
@@ -221,10 +185,9 @@ public class DashboardController : Controller
                     StatusDisplayName = q.QuoteStatus.DisplayName
                 }).ToList();
 
-            var pendingQuoteValue = pendingQuotesData.Sum(q => q.Total);
+            var pendingQuoteValue = data.PendingQuotes.Sum(q => q.Total);
 
-            // Expiring Quotes (next 7 days) - filter at database level
+            var expiringQuotes = data.PendingQuotes
-            var expiringQuotes = pendingQuotesData
                 .Where(q => q.ExpirationDate.HasValue
                     && q.ExpirationDate.Value.Date >= today
                     && q.ExpirationDate.Value.Date <= lookAheadDate)
@@ -246,33 +209,17 @@ public class DashboardController : Controller
                     StatusDisplayName = q.QuoteStatus.DisplayName
                 }).ToList();
 
-            // Active Customers
+            // ---------------------------------------------------------------
+            // Active customers
+            // ---------------------------------------------------------------
             var activeCustomersCount = await _unitOfWork.Customers.CountAsync(c => c.IsActive);
 
             // ---------------------------------------------------------------
-            // Financial data — Invoices & Payments
+            // Invoices & AR aging
             // ---------------------------------------------------------------
-            var openStatuses = new[] { InvoiceStatus.Sent, InvoiceStatus.PartiallyPaid, InvoiceStatus.Overdue };
+            var outstandingAr = data.OpenInvoices.Sum(i => i.BalanceDue);
 
-            // Open invoices only — filter at database level
+            var overdueInvoicesList = data.OpenInvoices
-            var openInvoices = await _context.Invoices
-                .Include(i => i.Customer)
-                .Where(i => openStatuses.Contains(i.Status))
-                .ToListAsync();
-
-            var outstandingAr = openInvoices.Sum(i => i.BalanceDue);
-
-            // Invoiced this month — aggregate at database level
-            var invoicedThisMonth = await _context.Invoices
-                .Where(i => i.Status != InvoiceStatus.Draft
-                         && i.Status != InvoiceStatus.Voided
-                         && i.Status != InvoiceStatus.WrittenOff
-                         && i.InvoiceDate >= startOfMonth
-                         && i.InvoiceDate <= endOfMonth)
-                .SumAsync(i => i.Total);
-
-            // Overdue invoices: open and past due date
-            var overdueInvoicesList = openInvoices
                 .Where(i => i.DueDate.HasValue && i.DueDate.Value.Date < today)
                 .OrderBy(i => i.DueDate)
                 .ToList();
@@ -295,9 +242,9 @@ public class DashboardController : Controller
                 })
                 .ToList();
 
-            // AR Aging — bucket open invoices by days past due
+            // AR Aging buckets
             decimal agingCurrent = 0, aging1To30 = 0, aging31To60 = 0, aging61To90 = 0, agingOver90 = 0;
-            foreach (var inv in openInvoices)
+            foreach (var inv in data.OpenInvoices)
             {
                 if (!inv.DueDate.HasValue || inv.DueDate.Value.Date >= today)
                 {
@@ -313,17 +260,10 @@ public class DashboardController : Controller
                 }
             }
 
-            // Payments this month — aggregate at database level
+            // ---------------------------------------------------------------
-            var collectedThisMonth = await _context.Payments
+            // Payments
-                .Where(p => p.PaymentDate >= startOfMonth && p.PaymentDate <= endOfMonth)
+            // ---------------------------------------------------------------
-                .SumAsync(p => p.Amount);
+            var recentPayments = data.RecentPayments
-
-            // Recent payments — load only the 6 most recent
-            var recentPayments = (await _context.Payments
-                .Include(p => p.Invoice).ThenInclude(i => i!.Customer)
-                .OrderByDescending(p => p.PaymentDate)
-                .Take(6)
-                .ToListAsync())
                 .Select(p => new DashboardPaymentDto
                 {
                     Id = p.Id,
@@ -335,44 +275,39 @@ public class DashboardController : Controller
                     PaymentDate = p.PaymentDate,
                     PaymentMethodDisplay = p.PaymentMethod switch
                     {
-                        PowderCoating.Core.Enums.PaymentMethod.Cash => "Cash",
+                        PaymentMethod.Cash => "Cash",
-                        PowderCoating.Core.Enums.PaymentMethod.Check => "Check",
+                        PaymentMethod.Check => "Check",
-                        PowderCoating.Core.Enums.PaymentMethod.CreditDebitCard => "Card",
+                        PaymentMethod.CreditDebitCard => "Card",
-                        PowderCoating.Core.Enums.PaymentMethod.BankTransferACH => "ACH",
+                        PaymentMethod.BankTransferACH => "ACH",
-                        PowderCoating.Core.Enums.PaymentMethod.DigitalPayment => "Digital",
+                        PaymentMethod.DigitalPayment => "Digital",
                         _ => "Other"
                     }
                 })
                 .ToList();
 
-            // Equipment Alerts - filter at database level
+            // ---------------------------------------------------------------
+            // Equipment alerts
+            // ---------------------------------------------------------------
             var equipmentAlerts = (await _unitOfWork.Equipment.FindAsync(
-                e => e.Status == Core.Enums.EquipmentStatus.NeedsMaintenance ||
+                e => e.Status == EquipmentStatus.NeedsMaintenance ||
-                     e.Status == Core.Enums.EquipmentStatus.OutOfService))
+                     e.Status == EquipmentStatus.OutOfService))
-                .OrderByDescending(e => e.Status == Core.Enums.EquipmentStatus.OutOfService ? 1 : 0)
+                .OrderByDescending(e => e.Status == EquipmentStatus.OutOfService ? 1 : 0)
                 .Take(5)
                 .Select(e => new DashboardEquipmentAlertDto
                 {
                     Id = e.Id,
                     EquipmentName = e.EquipmentName,
                     EquipmentType = e.EquipmentType,
-                    Issue = e.Status == Core.Enums.EquipmentStatus.OutOfService ? "Out of Service" : "Needs Maintenance",
+                    Issue = e.Status == EquipmentStatus.OutOfService ? "Out of Service" : "Needs Maintenance",
-                    Severity = e.Status == Core.Enums.EquipmentStatus.OutOfService ? "Critical" : "Warning",
+                    Severity = e.Status == EquipmentStatus.OutOfService ? "Critical" : "Warning",
                     LastMaintenanceDate = e.LastMaintenanceDate,
-                    NextMaintenanceDue = null // Equipment doesn't track next maintenance due date
+                    NextMaintenanceDue = null
                 }).ToList();
 
-            // Recent Activity (last 10 quotes or jobs created in last 30 days)
+            // ---------------------------------------------------------------
-            var last30Days = today.AddDays(-30);
+            // Recent activity
-
+            // ---------------------------------------------------------------
-            // Recent quotes — filter to last 30 days at database level
+            var recentQuoteDtos = data.RecentQuotes
-            var recentQuotes = (await _context.Quotes
-                .Include(q => q.Customer)
-                .Include(q => q.QuoteStatus)
-                .Where(q => q.CreatedAt >= last30Days)
-                .OrderByDescending(q => q.CreatedAt)
-                .Take(5)
-                .ToListAsync())
                 .Select(q => new DashboardRecentActivityDto
                 {
                     Id = q.Id,
@@ -390,14 +325,7 @@ public class DashboardController : Controller
                     Amount = q.Total
                 });
 
-            // Recent jobs — filter to last 30 days at database level
+            var recentJobDtos = data.RecentJobs
-            var recentJobs = (await _context.Jobs
-                .Include(j => j.Customer)
-                .Include(j => j.JobStatus)
-                .Where(j => j.CreatedAt >= last30Days)
-                .OrderByDescending(j => j.CreatedAt)
-                .Take(5)
-                .ToListAsync())
                 .Select(j => new DashboardRecentActivityDto
                 {
                     Id = j.Id,
@@ -413,33 +341,15 @@ public class DashboardController : Controller
                     Amount = j.FinalPrice
                 });
 
-            var recentActivity = recentQuotes.Concat(recentJobs)
+            var recentActivity = recentQuoteDtos.Concat(recentJobDtos)
                 .OrderByDescending(a => a.ActivityDate)
                 .Take(10)
                 .ToList();
 
-            // === POWDER ORDERS NEEDED ===
+            // ---------------------------------------------------------------
-            var jobsNeedingPowder = await _context.Jobs
+            // Powder orders needed
-                .Include(j => j.Customer)
+            // ---------------------------------------------------------------
-                .Include(j => j.JobStatus)
+            var powderFlat = data.JobsNeedingPowder
-                .Include(j => j.JobItems)
-                    .ThenInclude(i => i.Coats)
-                        .ThenInclude(c => c.InventoryItem)
-                            .ThenInclude(inv => inv!.PrimaryVendor)
-                .Include(j => j.JobItems)
-                    .ThenInclude(i => i.Coats)
-                        .ThenInclude(c => c.Vendor)
-                .Where(j => !j.IsDeleted
-                         && !CompletedStatusCodes.Contains(j.JobStatus.StatusCode)
-                         && j.JobItems.Any(i => i.Coats.Any(c =>
-                             !c.IsDeleted &&
-                             !c.PowderOrdered &&
-                             c.PowderToOrder > 0 &&
-                             (c.InventoryItemId == null || c.InventoryItem!.QuantityOnHand < c.PowderToOrder))))
-                .ToListAsync();
-
-            // Flatten to individual coat lines that need ordering (with vendor info for grouping)
-            var powderFlat = jobsNeedingPowder
                 .SelectMany(j => j.JobItems
                     .SelectMany(i => i.Coats
                         .Where(c => !c.IsDeleted && !c.PowderOrdered && c.PowderToOrder > 0
@@ -500,26 +410,10 @@ public class DashboardController : Controller
                 .OrderBy(g => g.VendorName)
                 .ToList();
 
-            // === POWDER ORDERS PLACED (ordered, awaiting receipt) ===
+            // ---------------------------------------------------------------
-            var jobsWithOrderedPowder = await _context.Jobs
+            // Powder orders placed
-                .Include(j => j.Customer)
+            // ---------------------------------------------------------------
-                .Include(j => j.JobStatus)
+            var placedFlat = data.JobsWithOrderedPowder
-                .Include(j => j.JobItems)
-                    .ThenInclude(i => i.Coats)
-                        .ThenInclude(c => c.InventoryItem)
-                            .ThenInclude(inv => inv!.PrimaryVendor)
-                .Include(j => j.JobItems)
-                    .ThenInclude(i => i.Coats)
-                        .ThenInclude(c => c.Vendor)
-                .Where(j => !j.IsDeleted
-                         && !CompletedStatusCodes.Contains(j.JobStatus.StatusCode)
-                         && j.JobItems.Any(i => i.Coats.Any(c =>
-                             !c.IsDeleted &&
-                             c.PowderOrdered &&
-                             !c.PowderReceived)))
-                .ToListAsync();
-
-            var placedFlat = jobsWithOrderedPowder
                 .SelectMany(j => j.JobItems
                     .SelectMany(i => i.Coats
                         .Where(c => !c.IsDeleted && c.PowderOrdered && !c.PowderReceived)
@@ -584,16 +478,10 @@ public class DashboardController : Controller
                 .OrderBy(g => g.VendorName)
                 .ToList();
 
-            // === BILLS DUE ===
+            // ---------------------------------------------------------------
-            var billsDueRaw = await _context.Bills
+            // Bills due
-                .Include(b => b.Vendor)
+            // ---------------------------------------------------------------
-                .Where(b => !b.IsDeleted &&
+            var billsDue = data.BillsDue.Select(b => new DashboardBillDto
-                            (b.Status == BillStatus.Open || b.Status == BillStatus.PartiallyPaid) &&
-                            b.Total > b.AmountPaid)
-                .OrderBy(b => b.DueDate)
-                .Take(15)
-                .ToListAsync();
-            var billsDue = billsDueRaw.Select(b => new DashboardBillDto
             {
                 Id = b.Id,
                 BillNumber = b.BillNumber,
@@ -608,21 +496,21 @@ public class DashboardController : Controller
             var vm = new DashboardViewModel
             {
                 // Counts
-                ActiveJobsCount = activeJobs.Count(),
+                ActiveJobsCount = data.ActiveJobs.Count,
                 TodaysJobsCount = todaysJobsCount,
                 OverdueJobsCount = overdueJobsCount,
                 TodaysAppointmentsCount = todaysAppointmentsCount,
                 LowStockCount = lowStockCount,
-                PendingMaintenanceCount = upcomingMaintenance.Count,
+                PendingMaintenanceCount = data.UpcomingMaintenance.Count,
-                PendingQuotesCount = pendingQuotesData.Count(),
+                PendingQuotesCount = data.PendingQuotes.Count,
                 PendingQuoteValue = pendingQuoteValue,
-                MonthlyRevenue = monthlyRevenue,
+                MonthlyRevenue = data.MonthlyRevenue,
                 ActiveCustomersCount = activeCustomersCount,
 
                 // Financial KPIs
                 OutstandingAr = outstandingAr,
-                CollectedThisMonth = collectedThisMonth,
+                CollectedThisMonth = data.CollectedThisMonth,
-                InvoicedThisMonth = invoicedThisMonth,
+                InvoicedThisMonth = data.InvoicedThisMonth,
                 OverdueInvoicesCount = overdueInvoicesCount,
                 OverdueInvoicesAmount = overdueInvoicesAmount,
                 AgingCurrent = agingCurrent,
@@ -654,7 +542,9 @@ public class DashboardController : Controller
                 PowderOrdersNeeded = powderOrderGroups,
                 PowderOrdersNeededCount = powderFlat.Count,
                 PowderOrdersPlaced = powderPlacedGroups,
-                PowderOrdersPlacedCount = placedFlat.Count
+                PowderOrdersPlacedCount = placedFlat.Count,
+
+                TipOfTheDay = data.TipOfTheDay
             };
 
             // Dropdowns for the "Add Custom Powder to Inventory" modal
@@ -671,13 +561,6 @@ public class DashboardController : Controller
             ViewBag.InventoryCategories = inventoryCategories;
             ViewBag.VendorList = vendors;
 
-            // Random tip of the day
-            var tips = await _context.DashboardTips
-                .Where(t => t.IsActive)
-                .ToListAsync();
-            if (tips.Count > 0)
-                vm.TipOfTheDay = tips[Random.Shared.Next(tips.Count)].TipText;
-
             // Config health check — surface setup gaps to company admins
             var currentCompanyId = _tenantContext.GetCurrentCompanyId();
             if (currentCompanyId.HasValue)
@@ -705,11 +588,7 @@ public class DashboardController : Controller
     {
         try
         {
-            var coat = await _context.JobItemCoats
+            var coat = await _unitOfWork.JobItemCoats.LoadForOrderMarkingAsync(coatId);
-                .Include(c => c.JobItem).ThenInclude(i => i.Job).ThenInclude(j => j.Customer)
-                .Include(c => c.Vendor)
-                .Include(c => c.InventoryItem).ThenInclude(i => i!.PrimaryVendor)
-                .FirstOrDefaultAsync(c => c.Id == coatId);
 
             if (coat == null)
                 return Json(new { success = false, message = "Coat not found." });
@@ -722,7 +601,7 @@ public class DashboardController : Controller
             coat.PowderOrdered = true;
             coat.PowderOrderedAt = DateTime.UtcNow;
             coat.PowderOrderedByUserId = User.FindFirst(System.Security.Claims.ClaimTypes.NameIdentifier)?.Value;
-            await _context.SaveChangesAsync();
+            await _unitOfWork.CompleteAsync();
 
             var vendor = coat.Vendor ?? coat.InventoryItem?.PrimaryVendor;
             var job = coat.JobItem?.Job;
@@ -761,9 +640,9 @@ public class DashboardController : Controller
     /// Records receipt of a powder shipment against an existing powder order. Sets
     /// <c>PowderReceived</c>, <c>PowderReceivedLbs</c>, and <c>PowderReceivedAt</c> on the coat,
     /// and — when the coat is linked to an inventory item — increases <c>QuantityOnHand</c> and
-    /// writes a <c>Purchase</c> <see cref="PowderCoating.Core.Entities.InventoryTransaction"/> so
+    /// writes a <c>Purchase</c> <see cref="InventoryTransaction"/> so the stock movement is fully
-    /// the stock movement is fully traceable. Company ownership is verified through the parent job
+    /// traceable. Company ownership is verified through the parent job because <c>JobItemCoat</c>
-    /// because <c>JobItemCoat</c> carries no <c>CompanyId</c> of its own.
+    /// carries no <c>CompanyId</c> of its own.
     /// </summary>
     [HttpPost]
     [ValidateAntiForgeryToken]
@@ -771,9 +650,8 @@ public class DashboardController : Controller
     {
         try
         {
-            var coat = await _context.JobItemCoats
+            // Load coat with inventory item for the stock update
-                .Include(c => c.InventoryItem)
+            var coat = await _unitOfWork.JobItemCoats.LoadWithInventoryAsync(coatId);
-                .FirstOrDefaultAsync(c => c.Id == coatId);
 
             if (coat == null)
                 return Json(new { success = false, message = "Coat record not found." });
@@ -781,29 +659,25 @@ public class DashboardController : Controller
             if (lbsReceived <= 0)
                 return Json(new { success = false, message = "Quantity received must be greater than zero." });
 
-            // Verify ownership — JobItemCoat has no CompanyId, check via parent job
+            // Verify ownership — JobItemCoat has no CompanyId, check via parent job.
-            // (We need the job for company check; load it if not already included)
+            // If JobItem/Job wasn't populated by the initial load, bring in the chain via a second
+            // query; EF Core identity-map fixup will propagate the navigation to the tracked coat.
             var coatJobCompanyId = coat.JobItem?.Job?.CompanyId;
             if (coatJobCompanyId == null)
             {
-                // Reload with parent chain if not included
+                await _unitOfWork.JobItemCoats.LoadWithJobChainAsync(coatId);
-                var coatWithJob = await _context.JobItemCoats
+                coatJobCompanyId = coat.JobItem?.Job?.CompanyId;
-                    .Include(c => c.JobItem).ThenInclude(i => i.Job)
-                    .FirstOrDefaultAsync(c => c.Id == coatId);
-                coatJobCompanyId = coatWithJob?.JobItem?.Job?.CompanyId;
             }
             if (!_tenantContext.IsSuperAdmin() && coatJobCompanyId != _tenantContext.GetCurrentCompanyId())
                 return Json(new { success = false, message = "Access denied." });
 
             var userId = User.FindFirst(System.Security.Claims.ClaimTypes.NameIdentifier)?.Value;
 
-            // Mark coat as received
             coat.PowderReceived = true;
             coat.PowderReceivedAt = DateTime.UtcNow;
             coat.PowderReceivedByUserId = userId;
             coat.PowderReceivedLbs = lbsReceived;
 
-            // Update inventory if this coat is linked to an inventory item
             if (coat.InventoryItemId.HasValue && coat.InventoryItem != null)
             {
                 var item = coat.InventoryItem;
@@ -813,26 +687,24 @@ public class DashboardController : Controller
                 if (coat.PowderCostPerLb.HasValue)
                     item.LastPurchasePrice = coat.PowderCostPerLb.Value;
 
-                // Record purchase transaction
+                var transaction = new InventoryTransaction
-                var transaction = new PowderCoating.Core.Entities.InventoryTransaction
                 {
                     CompanyId       = item.CompanyId,
                     InventoryItemId = item.Id,
-                    TransactionType = PowderCoating.Core.Enums.InventoryTransactionType.Purchase,
+                    TransactionType = InventoryTransactionType.Purchase,
                     Quantity        = lbsReceived,
                     UnitCost        = coat.PowderCostPerLb ?? item.UnitCost,
                     TotalCost       = lbsReceived * (coat.PowderCostPerLb ?? item.UnitCost),
                     TransactionDate = DateTime.UtcNow,
-                    Reference       = coat.JobItem != null ? null : null, // loaded below if needed
                     Notes           = $"Received {lbsReceived:N2} lbs for job order",
                     BalanceAfter    = previousBalance + lbsReceived,
                     CreatedAt       = DateTime.UtcNow,
                     UpdatedAt       = DateTime.UtcNow,
                 };
-                _context.Set<PowderCoating.Core.Entities.InventoryTransaction>().Add(transaction);
+                await _unitOfWork.InventoryTransactions.AddAsync(transaction);
             }
 
-            await _context.SaveChangesAsync();
+            await _unitOfWork.CompleteAsync();
 
             return Json(new { success = true, updatedInventory = coat.InventoryItemId.HasValue });
         }
@@ -864,7 +736,7 @@ public class DashboardController : Controller
     {
         try
         {
-            var coat = await _context.JobItemCoats.FindAsync(coatId);
+            var coat = await _unitOfWork.JobItemCoats.GetByIdAsync(coatId);
             if (coat == null)
                 return Json(new { success = false, message = "Coat record not found." });
 
@@ -877,16 +749,13 @@ public class DashboardController : Controller
             if (lbsReceived <= 0)
                 return Json(new { success = false, message = "Quantity received must be greater than zero." });
 
-            // Resolve company id from tenant context
+            // Resolve company id from the job chain; fall back to tenant context
-            var companyId = (await _unitOfWork.InventoryItems.GetAllAsync()).FirstOrDefault()?.CompanyId ?? 0;
+            var jobItem = await _unitOfWork.JobItems.FirstOrDefaultAsync(
-            // More reliably get CompanyId from the job chain
+                i => i.Coats.Any(c => c.Id == coatId), false, i => i.Job);
-            var jobItem = await _context.JobItems.Include(i => i.Job).FirstOrDefaultAsync(i => i.Coats.Any(c => c.Id == coatId));
+            var companyId = jobItem?.Job?.CompanyId ?? _tenantContext.GetCurrentCompanyId() ?? 0;
-            if (jobItem?.Job != null)
-                companyId = jobItem.Job.CompanyId;
 
             // Check SKU uniqueness
-            var existingSku = await _context.InventoryItems.AnyAsync(i => i.SKU == sku.Trim());
+            if (await _unitOfWork.InventoryItems.AnyAsync(i => i.SKU == sku.Trim()))
-            if (existingSku)
                 return Json(new { success = false, message = $"SKU '{sku}' already exists in inventory." });
 
             // Determine category display name for legacy field
@@ -925,10 +794,10 @@ public class DashboardController : Controller
                 UpdatedAt            = DateTime.UtcNow,
             };
 
-            _context.InventoryItems.Add(inventoryItem);
+            await _unitOfWork.InventoryItems.AddAsync(inventoryItem);
-            await _context.SaveChangesAsync();
+            await _unitOfWork.CompleteAsync(); // flush to get inventoryItem.Id
 
-            // Record opening stock transaction
+            // Opening stock transaction
             var transaction = new InventoryTransaction
             {
                 CompanyId       = companyId,
@@ -943,7 +812,7 @@ public class DashboardController : Controller
                 CreatedAt       = DateTime.UtcNow,
                 UpdatedAt       = DateTime.UtcNow,
             };
-            _context.Set<InventoryTransaction>().Add(transaction);
+            await _unitOfWork.InventoryTransactions.AddAsync(transaction);
 
             // Mark coat as received and link to the new inventory item
             var userId = User.FindFirst(System.Security.Claims.ClaimTypes.NameIdentifier)?.Value;
@@ -953,19 +822,12 @@ public class DashboardController : Controller
             coat.PowderReceivedLbs       = lbsReceived;
             coat.InventoryItemId         = inventoryItem.Id;
 
-            // Scan for other active job coats using the same custom powder and link them
+            // Scan for sibling coats with the same custom powder and link them to the new item
-            var candidateCoats = await _context.JobItemCoats
+            var candidateCoats = await _unitOfWork.JobItemCoats.GetCandidateCoatsForLinkingAsync(coatId, companyId);
-                .Include(c => c.JobItem)
-                .Where(c => !c.IsDeleted
-                         && c.Id != coatId
-                         && c.InventoryItemId == null
-                         && c.JobItem.CompanyId == companyId)
-                .ToListAsync();
 
             int linkedCount = 0;
             foreach (var other in candidateCoats)
             {
-                // Match by color code first (most specific), then fall back to color name
                 bool colorMatch = !string.IsNullOrWhiteSpace(colorCode)
                     ? string.Equals(other.ColorCode?.Trim(), colorCode.Trim(), StringComparison.OrdinalIgnoreCase)
                     : !string.IsNullOrWhiteSpace(colorName) &&
@@ -973,7 +835,6 @@ public class DashboardController : Controller
 
                 if (!colorMatch) continue;
 
-                // If both coats have a vendor set, they must agree
                 if (primaryVendorId.HasValue && other.VendorId.HasValue && other.VendorId != primaryVendorId)
                     continue;
 
@@ -985,7 +846,7 @@ public class DashboardController : Controller
                 _logger.LogInformation("Linked {Count} additional coat(s) to new inventory item {ItemId} ({SKU})",
                     linkedCount, inventoryItem.Id, inventoryItem.SKU);
 
-            await _context.SaveChangesAsync();
+            await _unitOfWork.CompleteAsync();
 
             return Json(new { success = true, itemName = inventoryItem.Name, sku = inventoryItem.SKU, linkedCount });
         }
@@ -1014,13 +875,10 @@ public class DashboardController : Controller
             var allCompanies = await _unitOfWork.Companies.GetAllAsync(ignoreQueryFilters: true);
             var companies = allCompanies.Where(c => !c.IsDeleted).ToList();
 
-            var totalUsers = await _context.Users
+            var totalUsers = await _dashboardRead.GetTotalUserCountAsync();
-                .Where(u => u.CompanyId > 0)
-                .CountAsync();
 
             var graceCutoff = today.AddDays(-AppConstants.SubscriptionConstants.GracePeriodDays);
 
-            // Load plan configs from DB so plan display names and distribution are DB-driven
             var planConfigs = (await _unitOfWork.SubscriptionPlanConfigs.FindAsync(
                 c => c.IsActive, ignoreQueryFilters: true))
                 .OrderBy(c => c.SortOrder)
@@ -1029,7 +887,6 @@ public class DashboardController : Controller
             var planLookup = planConfigs.ToDictionary(c => c.Plan, c => c.DisplayName);
             string PlanName(int plan) => planLookup.TryGetValue(plan, out var name) ? name : plan.ToString();
 
-            // Companies needing attention: expired (past grace) or in grace period
             var companyAlerts = companies
                 .Where(c => c.SubscriptionEndDate.HasValue && c.SubscriptionEndDate.Value.Date < today)
                 .OrderBy(c => c.SubscriptionEndDate)
@@ -1066,7 +923,6 @@ public class DashboardController : Controller
                 })
                 .ToList();
 
-            // Build plan distribution from DB config (sorted by SortOrder)
             var planDistribution = planConfigs.ToDictionary(
                 c => c.Plan,
                 c => (c.DisplayName, companies.Count(comp => comp.SubscriptionPlan == c.Plan)));

src/PowderCoating.Web/Controllers/DashboardTipsController.cs

@@ -1,8 +1,7 @@
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
-using Microsoft.EntityFrameworkCore;
 using PowderCoating.Core.Entities;
-using PowderCoating.Infrastructure.Data;
+using PowderCoating.Core.Interfaces;
 using PowderCoating.Shared.Constants;
 
 namespace PowderCoating.Web.Controllers;
@@ -18,39 +17,37 @@ namespace PowderCoating.Web.Controllers;
 [Authorize(Policy = AppConstants.Policies.SuperAdminOnly)]
 public class DashboardTipsController : Controller
 {
-    private readonly ApplicationDbContext _db;
+    private readonly IUnitOfWork _unitOfWork;
 
-    public DashboardTipsController(ApplicationDbContext db)
+    public DashboardTipsController(IUnitOfWork unitOfWork)
     {
-        _db = db;
+        _unitOfWork = unitOfWork;
     }
 
     /// <summary>
     /// Returns a paginated, optionally filtered list of all dashboard tips.
     /// Active tips are sorted first (then by newest Id) to make the currently
-    /// live pool easy to review at a glance.  ViewBag includes both the filtered
+    /// live pool easy to review at a glance.
-    /// count and the global active/total counts for the header summary cards.
     /// </summary>
-    // GET: /DashboardTips
     public async Task<IActionResult> Index(string? search, bool? activeOnly, int page = 1)
     {
         const int pageSize = 25;
 
-        var query = _db.DashboardTips.AsQueryable();
+        var all = (await _unitOfWork.DashboardTips.GetAllAsync()).ToList();
 
         if (!string.IsNullOrWhiteSpace(search))
-            query = query.Where(t => t.TipText.Contains(search));
+            all = all.Where(t => t.TipText.Contains(search, StringComparison.OrdinalIgnoreCase)).ToList();
 
         if (activeOnly == true)
-            query = query.Where(t => t.IsActive);
+            all = all.Where(t => t.IsActive).ToList();
 
-        var total = await query.CountAsync();
+        var total = all.Count;
-        var tips = await query
+        var tips = all
             .OrderByDescending(t => t.IsActive)
             .ThenByDescending(t => t.Id)
             .Skip((page - 1) * pageSize)
             .Take(pageSize)
-            .ToListAsync();
+            .ToList();
 
         ViewBag.Search = search;
         ViewBag.ActiveOnly = activeOnly ?? false;
@@ -58,23 +55,19 @@ public class DashboardTipsController : Controller
         ViewBag.PageSize = pageSize;
         ViewBag.Total = total;
         ViewBag.TotalPages = (int)Math.Ceiling(total / (double)pageSize);
-        ViewBag.ActiveCount = await _db.DashboardTips.CountAsync(t => t.IsActive);
+        ViewBag.ActiveCount = await _unitOfWork.DashboardTips.CountAsync(t => t.IsActive);
-        ViewBag.TotalCount = await _db.DashboardTips.CountAsync();
+        ViewBag.TotalCount = await _unitOfWork.DashboardTips.CountAsync();
 
         return View(tips);
     }
 
     /// <summary>Returns the Create form with an empty <see cref="DashboardTip"/> model.</summary>
-    // GET: /DashboardTips/Create
     public IActionResult Create() => View(new DashboardTip());
 
     /// <summary>
     /// Persists a new dashboard tip.  Text is trimmed before saving to prevent
     /// whitespace-only entries from appearing as blank tiles on the dashboard.
-    /// Model validation is done manually (rather than relying solely on
-    /// <c>[Required]</c> attributes) to ensure a meaningful error message is shown.
     /// </summary>
-    // POST: /DashboardTips/Create
     [HttpPost, ValidateAntiForgeryToken]
     public async Task<IActionResult> Create(DashboardTip model)
     {
@@ -84,37 +77,33 @@ public class DashboardTipsController : Controller
             return View(model);
         }
 
-        _db.DashboardTips.Add(new DashboardTip
+        await _unitOfWork.DashboardTips.AddAsync(new DashboardTip
         {
             TipText = model.TipText.Trim(),
             IsActive = model.IsActive,
             CreatedAt = DateTime.UtcNow
         });
-        await _db.SaveChangesAsync();
+        await _unitOfWork.CompleteAsync();
 
         TempData["Success"] = "Tip added successfully.";
         return RedirectToAction(nameof(Index));
     }
 
     /// <summary>Returns the Edit form for an existing tip, or 404 if not found.</summary>
-    // GET: /DashboardTips/Edit/5
     public async Task<IActionResult> Edit(int id)
     {
-        var tip = await _db.DashboardTips.FindAsync(id);
+        var tip = await _unitOfWork.DashboardTips.GetByIdAsync(id);
         if (tip == null) return NotFound();
         return View(tip);
     }
 
     /// <summary>
-    /// Updates text and active flag for an existing tip.  Returns the tracked entity
+    /// Updates text and active flag for an existing tip.
-    /// (not the posted model) to the view on validation failure so the form shows
-    /// the database version rather than potentially mangled posted data.
     /// </summary>
-    // POST: /DashboardTips/Edit/5
     [HttpPost, ValidateAntiForgeryToken]
     public async Task<IActionResult> Edit(int id, DashboardTip model)
     {
-        var tip = await _db.DashboardTips.FindAsync(id);
+        var tip = await _unitOfWork.DashboardTips.GetByIdAsync(id);
         if (tip == null) return NotFound();
 
         if (string.IsNullOrWhiteSpace(model.TipText))
@@ -125,27 +114,25 @@ public class DashboardTipsController : Controller
 
         tip.TipText = model.TipText.Trim();
         tip.IsActive = model.IsActive;
-        await _db.SaveChangesAsync();
+        await _unitOfWork.CompleteAsync();
 
         TempData["Success"] = "Tip updated.";
         return RedirectToAction(nameof(Index));
     }
 
     /// <summary>
-    /// Permanently (hard) deletes a dashboard tip.  Tips are platform metadata so
+    /// Permanently (hard) deletes a dashboard tip. Tips are platform metadata so
     /// they do not use soft delete — they have no foreign-key relationships to
-    /// tenant data and nothing references a deleted tip's Id.  A missing Id is
+    /// tenant data and nothing references a deleted tip's Id.
-    /// silently ignored to keep the action idempotent.
     /// </summary>
-    // POST: /DashboardTips/Delete/5
     [HttpPost, ValidateAntiForgeryToken]
     public async Task<IActionResult> Delete(int id)
     {
-        var tip = await _db.DashboardTips.FindAsync(id);
+        var tip = await _unitOfWork.DashboardTips.GetByIdAsync(id);
         if (tip != null)
         {
-            _db.DashboardTips.Remove(tip);
+            await _unitOfWork.DashboardTips.DeleteAsync(tip);
-            await _db.SaveChangesAsync();
+            await _unitOfWork.CompleteAsync();
             TempData["Success"] = "Tip deleted.";
         }
         return RedirectToAction(nameof(Index));
@@ -153,19 +140,15 @@ public class DashboardTipsController : Controller
 
     /// <summary>
     /// Flips the <c>IsActive</c> flag on a tip without a full edit round-trip.
-    /// This lets operators quickly remove a tip from the rotation (deactivate)
-    /// without deleting it, preserving the ability to reactivate it later.
-    /// A missing Id is silently ignored to keep the action idempotent.
     /// </summary>
-    // POST: /DashboardTips/ToggleActive/5
     [HttpPost, ValidateAntiForgeryToken]
     public async Task<IActionResult> ToggleActive(int id)
     {
-        var tip = await _db.DashboardTips.FindAsync(id);
+        var tip = await _unitOfWork.DashboardTips.GetByIdAsync(id);
         if (tip != null)
         {
             tip.IsActive = !tip.IsActive;
-            await _db.SaveChangesAsync();
+            await _unitOfWork.CompleteAsync();
         }
         return RedirectToAction(nameof(Index));
     }

src/PowderCoating.Web/Controllers/DepositsController.cs

@@ -7,7 +7,6 @@ using PowderCoating.Application.DTOs.Company;
 using PowderCoating.Core.Entities;
 using PowderCoating.Core.Enums;
 using PowderCoating.Core.Interfaces;
-using PowderCoating.Infrastructure.Data;
 using PowderCoating.Shared.Constants;
 using QuestPDF.Fluent;
 using QuestPDF.Helpers;
@@ -21,18 +20,15 @@ public class DepositsController : Controller
     private readonly IUnitOfWork _unitOfWork;
     private readonly UserManager<ApplicationUser> _userManager;
     private readonly ILogger<DepositsController> _logger;
-    private readonly ApplicationDbContext _context;
 
     public DepositsController(
         IUnitOfWork unitOfWork,
         UserManager<ApplicationUser> userManager,
-        ILogger<DepositsController> logger,
+        ILogger<DepositsController> logger)
-        ApplicationDbContext context)
     {
         _unitOfWork = unitOfWork;
         _userManager = userManager;
         _logger = logger;
-        _context = context;
     }
 
     // -----------------------------------------------------------------------
@@ -220,11 +216,11 @@ public class DepositsController : Controller
     {
         var prefix = $"DEP-{DateTime.UtcNow:yy}{DateTime.UtcNow.Month:D2}-";
 
-        var existing = await _context.Set<Deposit>()
+        var existing = (await _unitOfWork.Deposits.FindAsync(
-            .IgnoreQueryFilters()
+                d => d.CompanyId == companyId && d.ReceiptNumber.StartsWith(prefix),
-            .Where(d => d.CompanyId == companyId && d.ReceiptNumber.StartsWith(prefix))
+                ignoreQueryFilters: true))
             .Select(d => d.ReceiptNumber)
-            .ToListAsync();
+            .ToList();
 
         var maxNum = 0;
         foreach (var num in existing)

src/PowderCoating.Web/Controllers/EmailBroadcastController.cs

@@ -12,6 +12,7 @@ using PowderCoating.Shared.Constants;
 
 namespace PowderCoating.Web.Controllers;
 
+// Intentional exception: cross-tenant fan-out querying ASP.NET Identity Users table with company joins; Identity entities live outside IUnitOfWork. See docs/DATA_ACCESS_ARCHITECTURE.md — Permanent Exceptions.
 [Authorize(Policy = AppConstants.Policies.SuperAdminOnly)]
 public class EmailBroadcastController : Controller
 {

src/PowderCoating.Web/Controllers/ExpensesController.cs

@@ -14,7 +14,6 @@ using PowderCoating.Application.Interfaces;
 using PowderCoating.Core.Entities;
 using PowderCoating.Core.Enums;
 using PowderCoating.Core.Interfaces;
-using PowderCoating.Infrastructure.Data;
 
 namespace PowderCoating.Web.Controllers;
 
@@ -25,7 +24,6 @@ public class ExpensesController : Controller
     private readonly IMapper _mapper;
     private readonly UserManager<ApplicationUser> _userManager;
     private readonly ILogger<ExpensesController> _logger;
-    private readonly ApplicationDbContext _context;
     private readonly IAzureBlobStorageService _blobStorage;
     private readonly StorageSettings _storageSettings;
     private readonly IAccountBalanceService _accountBalanceService;
@@ -40,7 +38,6 @@ public class ExpensesController : Controller
         IMapper mapper,
         UserManager<ApplicationUser> userManager,
         ILogger<ExpensesController> logger,
-        ApplicationDbContext context,
         IAzureBlobStorageService blobStorage,
         IOptions<StorageSettings> storageSettings,
         IAccountBalanceService accountBalanceService,
@@ -51,7 +48,6 @@ public class ExpensesController : Controller
         _mapper = mapper;
         _userManager = userManager;
         _logger = logger;
-        _context = context;
         _blobStorage = blobStorage;
         _storageSettings = storageSettings.Value;
         _accountBalanceService = accountBalanceService;
@@ -80,28 +76,25 @@ public class ExpensesController : Controller
     [NonAction]
     public async Task<IActionResult> IndexLegacy(string? search, int? accountId, DateTime? from, DateTime? to, int page = 1, int pageSize = 25)
     {
-        var query = _context.Expenses
+        var allExpenses = (await _unitOfWork.Expenses.GetAllAsync(
-            .Include(e => e.Vendor)
+            false, e => e.Vendor, e => e.ExpenseAccount, e => e.PaymentAccount, e => e.Job))
-            .Include(e => e.ExpenseAccount)
+            .AsEnumerable();
-            .Include(e => e.PaymentAccount)
-            .Include(e => e.Job)
-            .Where(e => !e.IsDeleted);
 
         if (!string.IsNullOrEmpty(search))
-            query = query.Where(e => e.ExpenseNumber.Contains(search) ||
+            allExpenses = allExpenses.Where(e => e.ExpenseNumber.Contains(search) ||
-                e.Memo!.Contains(search) ||
+                (e.Memo != null && e.Memo.Contains(search)) ||
                 (e.Vendor != null && e.Vendor.CompanyName.Contains(search)));
 
         if (accountId.HasValue)
-            query = query.Where(e => e.ExpenseAccountId == accountId.Value);
+            allExpenses = allExpenses.Where(e => e.ExpenseAccountId == accountId.Value);
 
         if (from.HasValue)
-            query = query.Where(e => e.Date >= from.Value);
+            allExpenses = allExpenses.Where(e => e.Date >= from.Value);
 
         if (to.HasValue)
-            query = query.Where(e => e.Date <= to.Value);
+            allExpenses = allExpenses.Where(e => e.Date <= to.Value);
 
-        var expenses = await query.OrderByDescending(e => e.CreatedAt).ToListAsync();
+        var expenses = allExpenses.OrderByDescending(e => e.CreatedAt).ToList();
         var dtos = _mapper.Map<List<ExpenseListDto>>(expenses);
 
         ViewBag.Search = search;
@@ -110,11 +103,11 @@ public class ExpensesController : Controller
         ViewBag.To = to?.ToString("yyyy-MM-dd");
         ViewBag.TotalAmount = dtos.Sum(e => e.Amount);
 
-        var expenseAccounts = await _context.Accounts
+        var expenseAccounts = (await _unitOfWork.Accounts.FindAsync(
-            .Where(a => !a.IsDeleted && a.IsActive &&
+                a => a.IsActive &&
-                (a.AccountType == AccountType.Expense || a.AccountType == AccountType.CostOfGoods))
+                    (a.AccountType == AccountType.Expense || a.AccountType == AccountType.CostOfGoods)))
             .OrderBy(a => a.AccountNumber)
-            .ToListAsync();
+            .ToList();
 
         ViewBag.AccountFilter = expenseAccounts
             .Select(a => new SelectListItem($"{a.AccountNumber} – {a.Name}", a.Id.ToString()))
@@ -297,12 +290,8 @@ public class ExpensesController : Controller
     {
         if (id == null) return NotFound();
 
-        var expense = await _context.Expenses
+        var expense = await _unitOfWork.Expenses.GetByIdAsync(
-            .Include(e => e.Vendor)
+            id.Value, false, e => e.Vendor, e => e.ExpenseAccount, e => e.PaymentAccount, e => e.Job);
-            .Include(e => e.ExpenseAccount)
-            .Include(e => e.PaymentAccount)
-            .Include(e => e.Job)
-            .FirstOrDefaultAsync(e => e.Id == id && !e.IsDeleted);
 
         if (expense == null) return NotFound();
         return View(_mapper.Map<ExpenseDto>(expense));
@@ -445,12 +434,11 @@ public class ExpensesController : Controller
     private async Task<string> GenerateExpenseNumberAsync()
     {
         var prefix = $"EXP-{DateTime.Now:yyMM}-";
-        var last = await _context.Expenses
+        var last = (await _unitOfWork.Expenses.FindAsync(
-            .IgnoreQueryFilters()
+                e => e.ExpenseNumber.StartsWith(prefix), ignoreQueryFilters: true))
-            .Where(e => e.ExpenseNumber.StartsWith(prefix))
             .OrderByDescending(e => e.ExpenseNumber)
             .Select(e => e.ExpenseNumber)
-            .FirstOrDefaultAsync();
+            .FirstOrDefault();
 
         int next = 1;
         if (last != null && int.TryParse(last[prefix.Length..], out int num))

src/PowderCoating.Web/Controllers/InAppNotificationsController.cs

@@ -1,8 +1,6 @@
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
-using Microsoft.EntityFrameworkCore;
 using PowderCoating.Core.Interfaces;
-using PowderCoating.Infrastructure.Data;
 using PowderCoating.Web.Extensions;
 
 namespace PowderCoating.Web.Controllers;
@@ -10,12 +8,12 @@ namespace PowderCoating.Web.Controllers;
 [Authorize]
 public class InAppNotificationsController : Controller
 {
-    private readonly ApplicationDbContext _db;
+    private readonly IUnitOfWork _unitOfWork;
     private readonly ITenantContext _tenant;
 
-    public InAppNotificationsController(ApplicationDbContext db, ITenantContext tenant)
+    public InAppNotificationsController(IUnitOfWork unitOfWork, ITenantContext tenant)
     {
-        _db = db;
+        _unitOfWork = unitOfWork;
         _tenant = tenant;
     }
 
@@ -27,23 +25,15 @@ public class InAppNotificationsController : Controller
         pageNumber = Math.Max(1, pageNumber);
         pageSize = pageSize is 10 or 25 or 50 ? pageSize : 25;
 
-        IQueryable<PowderCoating.Core.Entities.InAppNotification> query;
+        var all = _tenant.IsPlatformAdmin()
+            ? (await _unitOfWork.InAppNotifications.FindAsync(
+                n => !n.IsDeleted && n.CompanyId == 0, ignoreQueryFilters: true)).ToList()
+            : (await _unitOfWork.InAppNotifications.GetAllAsync()).ToList();
 
-        if (_tenant.IsPlatformAdmin())
+        var totalCount = all.Count;
-        {
-            query = _db.InAppNotifications
-                .IgnoreQueryFilters()
-                .Where(n => !n.IsDeleted && n.CompanyId == 0);
-        }
-        else
-        {
-            query = _db.InAppNotifications.AsQueryable();
-        }
 
-        var totalCount = await query.CountAsync();
+        var tz = ViewBag.CompanyTimeZone as string;
-
+        var items = all
-        var items = await query
-            .AsNoTracking()
             .OrderByDescending(n => n.CreatedAt)
             .Skip((pageNumber - 1) * pageSize)
             .Take(pageSize)
@@ -58,7 +48,7 @@ public class InAppNotificationsController : Controller
                 n.ReadAt,
                 CreatedAt = n.CreatedAt
             })
-            .ToListAsync();
+            .ToList();
 
         ViewBag.TotalCount = totalCount;
         ViewBag.PageNumber = pageNumber;
@@ -68,31 +58,22 @@ public class InAppNotificationsController : Controller
     }
 
     /// <summary>
-    /// AJAX endpoint that returns the 20 most recent notifications (read and unread) for the bell dropdown. The response includes a count of unread items so the badge can be updated without a separate round-trip.
+    /// AJAX endpoint that returns the 20 most recent notifications (read and unread) for the bell dropdown.
     /// </summary>
     [HttpGet]
     public async Task<IActionResult> Recent()
     {
-        IQueryable<PowderCoating.Core.Entities.InAppNotification> query;
+        var all = _tenant.IsPlatformAdmin()
-
+            ? (await _unitOfWork.InAppNotifications.FindAsync(
-        if (_tenant.IsPlatformAdmin())
+                n => !n.IsDeleted && n.CompanyId == 0, ignoreQueryFilters: true)).ToList()
-        {
+            : (await _unitOfWork.InAppNotifications.GetAllAsync()).ToList();
-            query = _db.InAppNotifications
-                .IgnoreQueryFilters()
-                .Where(n => !n.IsDeleted && n.CompanyId == 0);
-        }
-        else
-        {
-            query = _db.InAppNotifications.AsQueryable();
-        }
 
         var tz = ViewBag.CompanyTimeZone as string;
-        var items = await query
+        var items = all
-            .AsNoTracking()
             .OrderByDescending(n => n.CreatedAt)
             .Take(20)
             .Select(n => new { n.Id, n.Title, n.Message, n.Link, n.NotificationType, n.IsRead, n.CreatedAt })
-            .ToListAsync();
+            .ToList();
 
         var unreadCount = items.Count(n => !n.IsRead);
         return Json(new { count = unreadCount, items = items.Select(n => new {
@@ -102,34 +83,19 @@ public class InAppNotificationsController : Controller
     }
 
     /// <summary>
-    /// AJAX endpoint that returns only unread notifications (up to 20) plus an unread count for the bell badge. Used by the initial page load poll; after that the bell relies on Recent to show history.
+    /// AJAX endpoint that returns only unread notifications (up to 20) plus an unread count for the bell badge.
     /// </summary>
     [HttpGet]
     public async Task<IActionResult> Unread()
     {
-        IQueryable<PowderCoating.Core.Entities.InAppNotification> query;
+        var items = _tenant.IsPlatformAdmin()
-
+            ? (await _unitOfWork.InAppNotifications.FindAsync(
-        if (_tenant.IsPlatformAdmin())
+                n => !n.IsDeleted && n.CompanyId == 0 && !n.IsRead, ignoreQueryFilters: true))
-        {
+                .OrderByDescending(n => n.CreatedAt).Take(20).ToList()
-            // SuperAdmins see only platform-level notifications (CompanyId = 0)
+            : (await _unitOfWork.InAppNotifications.FindAsync(n => !n.IsRead))
-            query = _db.InAppNotifications
+                .OrderByDescending(n => n.CreatedAt).Take(20).ToList();
-                .IgnoreQueryFilters()
-                .Where(n => !n.IsDeleted && n.CompanyId == 0 && !n.IsRead);
-        }
-        else
-        {
-            // Regular users see their company's notifications (global filter handles tenant isolation)
-            query = _db.InAppNotifications.Where(n => !n.IsRead);
-        }
 
         var tz = ViewBag.CompanyTimeZone as string;
-        var items = await query
-            .AsNoTracking()
-            .OrderByDescending(n => n.CreatedAt)
-            .Take(20)
-            .Select(n => new { n.Id, n.Title, n.Message, n.Link, n.NotificationType, n.CreatedAt })
-            .ToListAsync();
-
         return Json(new { count = items.Count, items = items.Select(n => new {
             n.Id, n.Title, n.Message, n.Link, n.NotificationType,
             CreatedAt = n.CreatedAt.Tz(tz).ToString("MMM d, h:mm tt")
@@ -137,44 +103,38 @@ public class InAppNotificationsController : Controller
     }
 
     /// <summary>
-    /// Marks a single notification as read and records the timestamp. Tenant isolation is enforced manually for SuperAdmins (CompanyId 0 filter) because IgnoreQueryFilters bypasses the global company filter.
+    /// Marks a single notification as read. Tenant isolation is enforced manually for SuperAdmins (CompanyId 0 filter) because IgnoreQueryFilters bypasses the global company filter.
     /// </summary>
     [HttpPost]
     public async Task<IActionResult> MarkRead(int id)
     {
         var notification = _tenant.IsPlatformAdmin()
-            ? await _db.InAppNotifications.IgnoreQueryFilters().FirstOrDefaultAsync(n => n.Id == id && n.CompanyId == 0 && !n.IsDeleted)
+            ? await _unitOfWork.InAppNotifications.FirstOrDefaultAsync(
-            : await _db.InAppNotifications.FirstOrDefaultAsync(n => n.Id == id);
+                n => n.Id == id && n.CompanyId == 0 && !n.IsDeleted, ignoreQueryFilters: true)
+            : await _unitOfWork.InAppNotifications.GetByIdAsync(id);
 
         if (notification == null) return NotFound();
 
         notification.IsRead = true;
         notification.ReadAt = DateTime.UtcNow;
         notification.UpdatedAt = DateTime.UtcNow;
-        await _db.SaveChangesAsync();
+        await _unitOfWork.CompleteAsync();
 
         return Json(new { success = true });
     }
 
     /// <summary>
-    /// Marks every unread notification as read for the current user's scope in a single SaveChanges call for efficiency. Returns the count of items marked so the UI can update the badge without refetching.
+    /// Marks every unread notification as read for the current user's scope in a single SaveChanges call.
     /// </summary>
     [HttpPost]
     public async Task<IActionResult> MarkAllRead()
     {
         var now = DateTime.UtcNow;
 
-        List<PowderCoating.Core.Entities.InAppNotification> unread;
+        var unread = _tenant.IsPlatformAdmin()
-        if (_tenant.IsPlatformAdmin())
+            ? (await _unitOfWork.InAppNotifications.FindAsync(
-        {
+                n => !n.IsDeleted && n.CompanyId == 0 && !n.IsRead, ignoreQueryFilters: true)).ToList()
-            unread = await _db.InAppNotifications.IgnoreQueryFilters()
+            : (await _unitOfWork.InAppNotifications.FindAsync(n => !n.IsRead)).ToList();
-                .Where(n => !n.IsDeleted && n.CompanyId == 0 && !n.IsRead)
-                .ToListAsync();
-        }
-        else
-        {
-            unread = await _db.InAppNotifications.Where(n => !n.IsRead).ToListAsync();
-        }
 
         foreach (var n in unread)
         {
@@ -183,7 +143,7 @@ public class InAppNotificationsController : Controller
             n.UpdatedAt = now;
         }
 
-        await _db.SaveChangesAsync();
+        await _unitOfWork.CompleteAsync();
         return Json(new { success = true, count = unread.Count });
     }
 }

src/PowderCoating.Web/Controllers/InventoryController.cs

@@ -11,8 +11,6 @@ using PowderCoating.Core.Entities;
 using PowderCoating.Core.Enums;
 using PowderCoating.Core.Interfaces;
 using Microsoft.AspNetCore.Identity;
-using PowderCoating.Infrastructure.Data;
-using Microsoft.EntityFrameworkCore;
 using QRCoder;
 using System.Drawing;
 using System.Drawing.Imaging;
@@ -29,7 +27,6 @@ public class InventoryController : Controller
     private readonly IMeasurementConversionService _measurementService;
     private readonly IInventoryAiLookupService _aiLookupService;
     private readonly ISubscriptionService _subscriptionService;
-    private readonly ApplicationDbContext _context;
     private readonly UserManager<ApplicationUser> _userManager;
 
     public InventoryController(
@@ -40,7 +37,6 @@ public class InventoryController : Controller
         IMeasurementConversionService measurementService,
         IInventoryAiLookupService aiLookupService,
         ISubscriptionService subscriptionService,
-        ApplicationDbContext context,
         UserManager<ApplicationUser> userManager)
     {
         _unitOfWork = unitOfWork;
@@ -50,7 +46,6 @@ public class InventoryController : Controller
         _measurementService = measurementService;
         _aiLookupService = aiLookupService;
         _subscriptionService = subscriptionService;
-        _context = context;
         _userManager = userManager;
     }
 
@@ -166,12 +161,12 @@ public class InventoryController : Controller
                 TotalCount = totalCount
             };
 
-            // Push stats and category list to the database rather than loading all rows
+            // Load all items once to compute sidebar stats and category list in memory
-            var statsBase = _context.InventoryItems;
+            var allItems = (await _unitOfWork.InventoryItems.GetAllAsync()).ToList();
-            ViewBag.Categories         = await statsBase.Select(i => i.Category).Where(c => c != null).Distinct().OrderBy(c => c).ToListAsync();
+            ViewBag.Categories         = allItems.Select(i => i.Category).Where(c => c != null).Distinct().OrderBy(c => c).ToList();
-            ViewBag.StatsLowStockCount = await statsBase.CountAsync(i => i.IsActive && i.QuantityOnHand <= i.ReorderPoint);
+            ViewBag.StatsLowStockCount = allItems.Count(i => i.IsActive && i.QuantityOnHand <= i.ReorderPoint);
-            ViewBag.StatsActiveCount   = await statsBase.CountAsync(i => i.IsActive);
+            ViewBag.StatsActiveCount   = allItems.Count(i => i.IsActive);
-            ViewBag.StatsTotalValue    = await statsBase.SumAsync(i => (decimal?)i.QuantityOnHand * i.UnitCost) ?? 0m;
+            ViewBag.StatsTotalValue    = allItems.Sum(i => (decimal?)i.QuantityOnHand * i.UnitCost) ?? 0m;
 
             // Set ViewBag for sorting and filters
             ViewBag.SearchTerm = searchTerm;
@@ -560,20 +555,8 @@ public class InventoryController : Controller
             if (string.IsNullOrEmpty(colorName) && string.IsNullOrEmpty(name))
                 return Json(new { success = true, photos = Array.Empty<object>(), totalCount = 0, page, pageSize });
 
-            IQueryable<JobPhoto> query = _context.JobPhotos
-                .AsNoTracking()
-                .Include(p => p.Job).ThenInclude(j => j.Customer)
-                .Where(p => !p.IsDeleted && p.Tags != null && p.Tags != "");
-
-            if (!string.IsNullOrEmpty(colorName) && !string.IsNullOrEmpty(name) && colorName != name)
-                query = query.Where(p => p.Tags!.ToLower().Contains(colorName) || p.Tags!.ToLower().Contains(name));
-            else if (!string.IsNullOrEmpty(colorName))
-                query = query.Where(p => p.Tags!.ToLower().Contains(colorName));
-            else
-                query = query.Where(p => p.Tags!.ToLower().Contains(name!));
-
             // Exact tag match (avoid "Black" matching "Gloss Black Semi-Gloss")
-            var allMatches = await query.OrderByDescending(p => p.UploadedDate).ToListAsync();
+            var allMatches = await _unitOfWork.JobPhotos.GetTaggedPhotosAsync(colorName, name);
 
             var searchTerms = new[] { colorName, name }
                 .Where(s => !string.IsNullOrEmpty(s))
@@ -620,15 +603,7 @@ public class InventoryController : Controller
     {
         try
         {
-            var photos = await _context.JobPhotos
+            var photos = await _unitOfWork.JobPhotos.GetPhotosByPowderItemAsync(id);
-                .AsNoTracking()
-                .Include(p => p.Job).ThenInclude(j => j.Customer)
-                .Include(p => p.Job).ThenInclude(j => j.JobItems).ThenInclude(ji => ji.Coats)
-                .Where(p => !p.IsDeleted &&
-                            p.Job != null &&
-                            p.Job.JobItems.Any(ji => ji.Coats.Any(c => c.InventoryItemId == id)))
-                .OrderByDescending(p => p.UploadedDate)
-                .ToListAsync();
 
             var totalCount = photos.Count;
             var paged = photos
@@ -728,12 +703,12 @@ public class InventoryController : Controller
     {
         try
         {
-            var allCoatings = await _context.InventoryItems
+            var allCoatings = (await _unitOfWork.InventoryItems.FindAsync(
-                .AsNoTracking()
+                    i => i.InventoryCategory != null && i.InventoryCategory.IsCoating,
-                .Include(i => i.InventoryCategory)
+                    false,
-                .Where(i => !i.IsDeleted && i.InventoryCategory != null && i.InventoryCategory.IsCoating)
+                    i => i.InventoryCategory))
                 .OrderBy(i => i.Manufacturer).ThenBy(i => i.ColorName).ThenBy(i => i.Name)
-                .ToListAsync();
+                .ToList();
 
             // Distinct manufacturer list for filter dropdown
             ViewBag.Manufacturers = allCoatings
@@ -955,25 +930,39 @@ public class InventoryController : Controller
 
         var userId = _userManager.GetUserId(User);
 
-        var myJobs = await _context.Jobs
+        var myJobs = (await _unitOfWork.Jobs.FindAsync(
-            .AsNoTracking()
+                j => !j.JobStatus.IsTerminalStatus && j.AssignedUserId == userId,
-            .Include(j => j.Customer)
+                false,
-            .Include(j => j.JobStatus)
+                j => j.Customer,
-            .Where(j => !j.IsDeleted && !j.JobStatus.IsTerminalStatus && j.AssignedUserId == userId)
+                j => j.JobStatus))
             .OrderBy(j => j.JobNumber)
-            .Select(j => new ScanJobOption { Id = j.Id, JobNumber = j.JobNumber, CustomerName = j.Customer != null ? (j.Customer.CompanyName ?? j.Customer.ContactFirstName + " " + j.Customer.ContactLastName) : "No Customer" })
+            .Select(j => new ScanJobOption
-            .ToListAsync();
+            {
+                Id = j.Id,
+                JobNumber = j.JobNumber,
+                CustomerName = j.Customer != null
+                    ? (j.Customer.CompanyName ?? j.Customer.ContactFirstName + " " + j.Customer.ContactLastName)
+                    : "No Customer"
+            })
+            .ToList();
 
         var myJobIds = myJobs.Select(j => j.Id).ToHashSet();
-        var otherJobs = await _context.Jobs
+        var otherJobs = (await _unitOfWork.Jobs.FindAsync(
-            .AsNoTracking()
+                j => !j.JobStatus.IsTerminalStatus && !myJobIds.Contains(j.Id),
-            .Include(j => j.Customer)
+                false,
-            .Include(j => j.JobStatus)
+                j => j.Customer,
-            .Where(j => !j.IsDeleted && !j.JobStatus.IsTerminalStatus && !myJobIds.Contains(j.Id))
+                j => j.JobStatus))
             .OrderByDescending(j => j.CreatedAt)
             .Take(100)
-            .Select(j => new ScanJobOption { Id = j.Id, JobNumber = j.JobNumber, CustomerName = j.Customer != null ? (j.Customer.CompanyName ?? j.Customer.ContactFirstName + " " + j.Customer.ContactLastName) : "No Customer" })
+            .Select(j => new ScanJobOption
-            .ToListAsync();
+            {
+                Id = j.Id,
+                JobNumber = j.JobNumber,
+                CustomerName = j.Customer != null
+                    ? (j.Customer.CompanyName ?? j.Customer.ContactFirstName + " " + j.Customer.ContactLastName)
+                    : "No Customer"
+            })
+            .ToList();
 
         ViewBag.ItemDto    = _mapper.Map<InventoryItemDto>(item);
         ViewBag.MyJobs     = myJobs;
@@ -1169,29 +1158,8 @@ public class InventoryController : Controller
             .ToList();
 
         // Build transactions query
-        var txnQuery = _context.InventoryTransactions
+        InventoryTransactionType? parsedType = !string.IsNullOrWhiteSpace(typeFilter) && Enum.TryParse<InventoryTransactionType>(typeFilter, out var pt) ? pt : null;
-            .AsNoTracking()
+        var transactions = await _unitOfWork.InventoryTransactions.GetForLedgerAsync(inventoryItemId, dateFrom, dateTo, parsedType);
-            .Include(t => t.InventoryItem)
-            .Include(t => t.PurchaseOrder)
-            .Include(t => t.Job)
-            .Where(t => !t.IsDeleted);
-
-        if (inventoryItemId.HasValue)
-            txnQuery = txnQuery.Where(t => t.InventoryItemId == inventoryItemId.Value);
-
-        if (dateFrom.HasValue)
-            txnQuery = txnQuery.Where(t => t.TransactionDate >= dateFrom.Value);
-
-        if (dateTo.HasValue)
-            txnQuery = txnQuery.Where(t => t.TransactionDate < dateTo.Value.AddDays(1));
-
-        if (!string.IsNullOrWhiteSpace(typeFilter) && Enum.TryParse<InventoryTransactionType>(typeFilter, out var parsedType))
-            txnQuery = txnQuery.Where(t => t.TransactionType == parsedType);
-
-        var transactions = await txnQuery
-            .OrderByDescending(t => t.TransactionDate)
-            .Take(500)
-            .ToListAsync();
 
         // Resolve JobId for legacy JobUsage transactions that stored job number in Reference but not JobId
         var unresolvedRefs = transactions
@@ -1202,36 +1170,12 @@ public class InventoryController : Controller
         var jobRefLookup = new Dictionary<string, (int Id, string JobNumber)>();
         if (unresolvedRefs.Any())
         {
-            var matched = await _context.Jobs
+            var matched = await _unitOfWork.Jobs.FindAsync(j => unresolvedRefs.Contains(j.JobNumber));
-                .AsNoTracking()
-                .Where(j => unresolvedRefs.Contains(j.JobNumber))
-                .Select(j => new { j.Id, j.JobNumber })
-                .ToListAsync();
             jobRefLookup = matched.ToDictionary(j => j.JobNumber, j => (j.Id, j.JobNumber));
         }
 
-        // Build powder usage logs query
+        // Powder usage logs with dynamic date + item filters
-        var usageQuery = _context.PowderUsageLogs
+        var usageLogs = await _unitOfWork.PowderUsageLogs.GetForLedgerAsync(inventoryItemId, dateFrom, dateTo);
-            .AsNoTracking()
-            .Include(u => u.Job).ThenInclude(j => j.Customer)
-            .Include(u => u.InventoryItem)
-            .Include(u => u.JobItemCoat)
-            .Where(u => !u.IsDeleted);
-
-        if (inventoryItemId.HasValue)
-            usageQuery = usageQuery.Where(u => u.InventoryItemId == inventoryItemId.Value);
-
-        if (dateFrom.HasValue)
-            usageQuery = usageQuery.Where(u => u.RecordedAt >= dateFrom.Value);
-
-        if (dateTo.HasValue)
-            usageQuery = usageQuery.Where(u => u.RecordedAt < dateTo.Value.AddDays(1));
-
-        // Exclude JobUsage type from transactions when showing usage tab (avoid double-counting display)
-        var usageLogs = await usageQuery
-            .OrderByDescending(u => u.RecordedAt)
-            .Take(500)
-            .ToListAsync();
 
         InventoryItem? selectedItem = null;
         if (inventoryItemId.HasValue)

src/PowderCoating.Web/Controllers/JobTemplatesController.cs

@@ -1,12 +1,9 @@
 using Microsoft.AspNetCore.Authorization;
 using PowderCoating.Shared.Constants;
-using Microsoft.AspNetCore.Identity;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Mvc.Rendering;
-using Microsoft.EntityFrameworkCore;
 using PowderCoating.Core.Entities;
 using PowderCoating.Core.Interfaces;
-using PowderCoating.Infrastructure.Data;
 
 namespace PowderCoating.Web.Controllers;
 
@@ -23,35 +20,28 @@ public class JobTemplatesController : Controller
 {
     private readonly IUnitOfWork _unitOfWork;
     private readonly ITenantContext _tenantContext;
-    private readonly ApplicationDbContext _context;
 
     public JobTemplatesController(
         IUnitOfWork unitOfWork,
-        ITenantContext tenantContext,
+        ITenantContext tenantContext)
-        ApplicationDbContext context)
     {
         _unitOfWork = unitOfWork;
         _tenantContext = tenantContext;
-        _context = context;
     }
 
     /// <summary>
     /// Displays all non-deleted job templates for the current company, ordered by name, with their
-    /// linked customer and item counts. Uses the direct <c>_context</c> query (bypassing
+    /// linked customer and item counts. Multi-tenancy and soft-delete scoping are handled by global
-    /// <c>IUnitOfWork</c>) to leverage EF Core's filtered includes (<c>.Include(t => t.Items)</c>)
+    /// query filters; the typed repository provides the ThenInclude chain for items.
-    /// which are not exposed through the generic repository pattern.
     /// </summary>
     public async Task<IActionResult> Index()
     {
-        var companyId = _tenantContext.GetCurrentCompanyId() ?? 0;
+        var templates = await _unitOfWork.JobTemplates.GetAllAsync(
-
+            false,
-        var templates = await _context.JobTemplates
+            t => t.Customer,
-            .Include(t => t.Customer)
+            t => t.Items);
-            .Include(t => t.Items)
-            .Where(t => !t.IsDeleted && t.CompanyId == companyId)
-            .OrderBy(t => t.Name)
-            .ToListAsync();
 
+        templates = templates.OrderBy(t => t.Name).ToList();
         return View(templates);
     }
 
@@ -59,22 +49,12 @@ public class JobTemplatesController : Controller
     /// Shows the full template detail including all non-deleted items, each with their coats
     /// (including the linked inventory item for color/powder info) and prep services (including the
     /// prep service entity for the service name). Soft-deleted items, coats, and prep services are
-    /// excluded via EF filtered includes so the view reflects the current active configuration.
+    /// excluded via filtered includes in the typed repository.
     /// </summary>
     public async Task<IActionResult> Details(int id)
     {
-        var template = await _context.JobTemplates
+        var template = await _unitOfWork.JobTemplates.LoadForDetailsAsync(id);
-            .Include(t => t.Customer)
-            .Include(t => t.Items.Where(i => !i.IsDeleted))
-                .ThenInclude(i => i.Coats.Where(c => !c.IsDeleted))
-                    .ThenInclude(c => c.InventoryItem)
-            .Include(t => t.Items.Where(i => !i.IsDeleted))
-                .ThenInclude(i => i.PrepServices.Where(p => !p.IsDeleted))
-                    .ThenInclude(p => p.PrepService)
-            .FirstOrDefaultAsync(t => t.Id == id && !t.IsDeleted);
-
         if (template == null) return NotFound();
-
         return View(template);
     }
 
@@ -85,9 +65,7 @@ public class JobTemplatesController : Controller
     /// </summary>
     public async Task<IActionResult> Edit(int id)
     {
-        var template = await _context.JobTemplates
+        var template = await _unitOfWork.JobTemplates.GetByIdAsync(id);
-            .FirstOrDefaultAsync(t => t.Id == id && !t.IsDeleted);
-
         if (template == null) return NotFound();
 
         await PopulateCustomerDropdown(template.CustomerId);
@@ -150,12 +128,7 @@ public class JobTemplatesController : Controller
     {
         var companyId = _tenantContext.GetCurrentCompanyId() ?? 0;
 
-        var job = await _context.Jobs
+        var job = await _unitOfWork.Jobs.LoadForTemplateSnapshotAsync(jobId);
-            .Include(j => j.JobItems.Where(i => !i.IsDeleted))
-                .ThenInclude(i => i.Coats.Where(c => !c.IsDeleted))
-            .Include(j => j.JobItems.Where(i => !i.IsDeleted))
-                .ThenInclude(i => i.PrepServices.Where(p => !p.IsDeleted))
-            .FirstOrDefaultAsync(j => j.Id == jobId && !j.IsDeleted);
 
         if (job == null) return NotFound();
 
@@ -254,18 +227,7 @@ public class JobTemplatesController : Controller
     [HttpGet]
     public async Task<IActionResult> GetTemplatesJson()
     {
-        var companyId = _tenantContext.GetCurrentCompanyId() ?? 0;
+        var templates = await _unitOfWork.JobTemplates.GetAllActiveWithFullIncludesAsync();
-
-        var templates = await _context.JobTemplates
-            .Include(t => t.Customer)
-            .Include(t => t.Items.Where(i => !i.IsDeleted))
-                .ThenInclude(i => i.Coats.Where(c => !c.IsDeleted))
-            .Include(t => t.Items.Where(i => !i.IsDeleted))
-                .ThenInclude(i => i.PrepServices.Where(p => !p.IsDeleted))
-                    .ThenInclude(p => p.PrepService)
-            .Where(t => !t.IsDeleted && t.CompanyId == companyId && t.IsActive)
-            .OrderBy(t => t.Name)
-            .ToListAsync();
 
         var result = templates.Select(t => new
         {

src/PowderCoating.Web/Controllers/JobsPriorityController.cs

@@ -9,7 +9,6 @@ using PowderCoating.Application.Services;
 using PowderCoating.Core.Entities;
 using PowderCoating.Core.Enums;
 using PowderCoating.Core.Interfaces;
-using PowderCoating.Infrastructure.Data;
 using PowderCoating.Shared.Constants;
 using PowderCoating.Web.Hubs;
 
@@ -19,7 +18,6 @@ namespace PowderCoating.Web.Controllers;
 public class JobsPriorityController : Controller
 {
     private readonly IUnitOfWork _unitOfWork;
-    private readonly ApplicationDbContext _context;
     private readonly ILogger<JobsPriorityController> _logger;
     private readonly UserManager<ApplicationUser> _userManager;
     private readonly ITenantContext _tenantContext;
@@ -27,14 +25,12 @@ public class JobsPriorityController : Controller
 
     public JobsPriorityController(
         IUnitOfWork unitOfWork,
-        ApplicationDbContext context,
         ILogger<JobsPriorityController> logger,
         UserManager<ApplicationUser> userManager,
         ITenantContext tenantContext,
         IHubContext<ShopHub> shopHub)
     {
         _unitOfWork = unitOfWork;
-        _context = context;
         _logger = logger;
         _userManager = userManager;
         _tenantContext = tenantContext;
@@ -63,13 +59,7 @@ public class JobsPriorityController : Controller
         var today = date?.Date ?? DateTime.Today;
 
         // Get all jobs scheduled for today with related data
-        var jobs = await _context.Jobs
+        var jobs = await _unitOfWork.Jobs.GetScheduledJobsForDateAsync(today);
-            .Include(j => j.Customer)
-            .Include(j => j.JobStatus)
-            .Include(j => j.JobPriority)
-            .Include(j => j.AssignedUser)
-            .Where(j => j.ScheduledDate.HasValue && j.ScheduledDate.Value.Date == today && !j.IsDeleted)
-            .ToListAsync();
 
         // Get existing priority records for today
         var existingPriorities = await _unitOfWork.JobDailyPriorities
@@ -108,15 +98,14 @@ public class JobsPriorityController : Controller
             .ToListAsync();
 
         // Get maintenance records scheduled for today (Scheduled or InProgress)
-        var maintenanceItems = await _context.MaintenanceRecords
+        var maintenanceItems = (await _unitOfWork.MaintenanceRecords.FindAsync(
-            .Include(m => m.Equipment)
+                m => m.ScheduledDate.Date == today &&
-            .Include(m => m.AssignedUser)
+                     (m.Status == MaintenanceStatus.Scheduled || m.Status == MaintenanceStatus.InProgress),
-            .Where(m => m.ScheduledDate.Date == today && !m.IsDeleted &&
+                false,
-                       (m.Status == MaintenanceStatus.Scheduled ||
+                m => m.Equipment, m => m.AssignedUser))
-                        m.Status == MaintenanceStatus.InProgress))
             .OrderByDescending(m => (int)m.Priority)
             .ThenBy(m => m.ScheduledDate)
-            .ToListAsync();
+            .ToList();
 
         ViewBag.ScheduledDate = today;
         ViewBag.MaintenanceItems = maintenanceItems;
@@ -378,14 +367,10 @@ public class JobsPriorityController : Controller
     {
         try
         {
-            var record = await _context.MaintenanceRecords.FindAsync(maintenanceId);
+            var record = await _unitOfWork.MaintenanceRecords.GetByIdAsync(maintenanceId);
             if (record == null || record.IsDeleted)
                 return Json(new { success = false, message = "Maintenance record not found" });
 
-            // FindAsync bypasses global query filters — verify company ownership explicitly
-            if (!_tenantContext.IsSuperAdmin() && record.CompanyId != _tenantContext.GetCurrentCompanyId())
-                return Json(new { success = false, message = "Access denied." });
-
             string workerName = "Unassigned";
             if (!string.IsNullOrEmpty(workerId))
             {
@@ -402,7 +387,7 @@ public class JobsPriorityController : Controller
             }
 
             record.UpdatedAt = DateTime.UtcNow;
-            await _context.SaveChangesAsync();
+            await _unitOfWork.CompleteAsync();
 
             return Json(new { success = true, message = "Worker assigned successfully", workerName });
         }

src/PowderCoating.Web/Controllers/NotificationLogsController.cs

@@ -1,10 +1,9 @@
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
-using Microsoft.EntityFrameworkCore;
 using PowderCoating.Application.DTOs.Common;
 using PowderCoating.Application.DTOs.Notification;
 using PowderCoating.Core.Enums;
-using PowderCoating.Infrastructure.Data;
+using PowderCoating.Core.Interfaces;
 using PowderCoating.Shared.Constants;
 
 namespace PowderCoating.Web.Controllers;
@@ -14,31 +13,23 @@ namespace PowderCoating.Web.Controllers;
 /// <c>CanManageJobs</c> policy (Managers and above within a company).
 /// The platform-wide equivalent for SuperAdmins lives in
 /// <see cref="PlatformNotificationsController"/>.
-/// Uses <see cref="ApplicationDbContext"/> directly to enable LINQ projections
-/// that avoid loading full message bodies into memory on the list page.
 /// </summary>
 [Authorize(Policy = AppConstants.Policies.CanManageJobs)]
 public class NotificationLogsController : Controller
 {
-    private readonly ApplicationDbContext _context;
+    private readonly IUnitOfWork _unitOfWork;
     private readonly ILogger<NotificationLogsController> _logger;
 
-    public NotificationLogsController(ApplicationDbContext context, ILogger<NotificationLogsController> logger)
+    public NotificationLogsController(IUnitOfWork unitOfWork, ILogger<NotificationLogsController> logger)
     {
-        _context = context;
+        _unitOfWork = unitOfWork;
         _logger = logger;
     }
 
     /// <summary>
-    /// Displays a paginated, filterable list of notification log entries for the
+    /// Displays a paginated, filterable list of notification log entries for the current company.
-    /// current company.  Supports filtering by free-text search, channel (Email/SMS),
+    /// Supports filtering by free-text search, channel, delivery status, notification type, and
-    /// delivery status, notification type, and an optional job context.
+    /// an optional job context. Page size is validated against an allowlist (10/25/50/100).
-    /// <para>
-    /// The <c>pageSize</c> is validated against an allowlist (10/25/50/100) and
-    /// defaults to 25 to prevent callers from requesting arbitrarily large result sets.
-    /// Sorting defaults to most-recent-first (<c>SentAt DESC</c>) because operators
-    /// almost always want to see the latest delivery attempts first.
-    /// </para>
     /// </summary>
     // GET: /NotificationLogs
     public async Task<IActionResult> Index(
@@ -55,74 +46,35 @@ public class NotificationLogsController : Controller
         pageNumber = Math.Max(1, pageNumber);
         pageSize = pageSize is 10 or 25 or 50 or 100 ? pageSize : 25;
 
-        var query = _context.NotificationLogs
+        NotificationChannel? channel = Enum.TryParse<NotificationChannel>(channelFilter, out var ch) ? ch : null;
-            .AsNoTracking()
+        NotificationStatus? status   = Enum.TryParse<NotificationStatus>(statusFilter, out var st) ? st : null;
-            .Include(n => n.Customer)
+        NotificationType? type       = Enum.TryParse<NotificationType>(typeFilter, out var ty) ? ty : null;
-            .Include(n => n.Job)
-            .Include(n => n.Quote)
-            .AsQueryable();
 
-        // Filters
+        var (logs, totalCount) = await _unitOfWork.NotificationLogs.GetPagedFilteredAsync(
-        if (jobId.HasValue)
+            pageNumber, pageSize, searchTerm, channel, status, type, jobId,
-            query = query.Where(n => n.JobId == jobId.Value);
+            sortColumn ?? "SentAt", sortDirection);
 
-        if (!string.IsNullOrWhiteSpace(searchTerm))
+        var items = logs.Select(n => new NotificationLogDto
         {
-            var search = searchTerm.ToLower();
+            Id = n.Id,
-            query = query.Where(n =>
+            Channel = n.Channel,
-                n.RecipientName.ToLower().Contains(search) ||
+            NotificationType = n.NotificationType,
-                n.Recipient.ToLower().Contains(search) ||
+            Status = n.Status,
-                (n.Subject != null && n.Subject.ToLower().Contains(search)) ||
+            RecipientName = n.RecipientName,
-                (n.Job != null && n.Job.JobNumber.ToLower().Contains(search)) ||
+            Recipient = n.Recipient,
-                (n.Quote != null && n.Quote.QuoteNumber.ToLower().Contains(search)));
+            Subject = n.Subject,
-        }
+            Message = n.Message,
-
+            ErrorMessage = n.ErrorMessage,
-        if (!string.IsNullOrWhiteSpace(channelFilter) && Enum.TryParse<NotificationChannel>(channelFilter, out var channel))
+            SentAt = n.SentAt,
-            query = query.Where(n => n.Channel == channel);
+            CustomerId = n.CustomerId,
-
+            JobId = n.JobId,
-        if (!string.IsNullOrWhiteSpace(statusFilter) && Enum.TryParse<NotificationStatus>(statusFilter, out var status))
+            QuoteId = n.QuoteId,
-            query = query.Where(n => n.Status == status);
+            JobNumber = n.Job?.JobNumber,
-
+            QuoteNumber = n.Quote?.QuoteNumber,
-        if (!string.IsNullOrWhiteSpace(typeFilter) && Enum.TryParse<NotificationType>(typeFilter, out var type))
+            CustomerName = n.Customer != null
-            query = query.Where(n => n.NotificationType == type);
+                ? (n.Customer.CompanyName ?? $"{n.Customer.ContactFirstName} {n.Customer.ContactLastName}".Trim())
-
+                : null
-        // Sorting
+        }).ToList();
-        query = (sortColumn ?? "SentAt") switch
-        {
-            "RecipientName" => sortDirection == "asc" ? query.OrderBy(n => n.RecipientName) : query.OrderByDescending(n => n.RecipientName),
-            "Channel"       => sortDirection == "asc" ? query.OrderBy(n => n.Channel) : query.OrderByDescending(n => n.Channel),
-            "Status"        => sortDirection == "asc" ? query.OrderBy(n => n.Status) : query.OrderByDescending(n => n.Status),
-            "Type"          => sortDirection == "asc" ? query.OrderBy(n => n.NotificationType) : query.OrderByDescending(n => n.NotificationType),
-            _               => sortDirection == "asc" ? query.OrderBy(n => n.SentAt) : query.OrderByDescending(n => n.SentAt)
-        };
-
-        var totalCount = await query.CountAsync();
-
-        var items = await query
-            .Skip((pageNumber - 1) * pageSize)
-            .Take(pageSize)
-            .Select(n => new NotificationLogDto
-            {
-                Id = n.Id,
-                Channel = n.Channel,
-                NotificationType = n.NotificationType,
-                Status = n.Status,
-                RecipientName = n.RecipientName,
-                Recipient = n.Recipient,
-                Subject = n.Subject,
-                Message = n.Message,
-                ErrorMessage = n.ErrorMessage,
-                SentAt = n.SentAt,
-                CustomerId = n.CustomerId,
-                JobId = n.JobId,
-                QuoteId = n.QuoteId,
-                JobNumber = n.Job != null ? n.Job.JobNumber : null,
-                QuoteNumber = n.Quote != null ? n.Quote.QuoteNumber : null,
-                CustomerName = n.Customer != null
-                    ? (n.Customer.CompanyName ?? $"{n.Customer.ContactFirstName} {n.Customer.ContactLastName}".Trim())
-                    : null
-            })
-            .ToListAsync();
 
         var pagedResult = new PagedResult<NotificationLogDto>
         {
@@ -144,22 +96,17 @@ public class NotificationLogsController : Controller
     }
 
     /// <summary>
-    /// Displays the full details of a single notification log entry including the
+    /// Displays the full details of a single notification log entry including the complete message
-    /// complete message body and any error message, which are omitted from the list
+    /// body and any error message, which are omitted from the list view. Loads related Customer,
-    /// view to keep response sizes small.  Loads related Customer, Job, and Quote
+    /// Job, and Quote navigation properties to resolve display names.
-    /// navigation properties to resolve display names.
     /// </summary>
     // GET: /NotificationLogs/Details/5
     public async Task<IActionResult> Details(int id)
     {
         try
         {
-            var log = await _context.NotificationLogs
+            var log = await _unitOfWork.NotificationLogs.GetByIdAsync(
-                .AsNoTracking()
+                id, false, n => n.Customer, n => n.Job, n => n.Quote);
-                .Include(n => n.Customer)
-                .Include(n => n.Job)
-                .Include(n => n.Quote)
-                .FirstOrDefaultAsync(n => n.Id == id);
 
             if (log == null) return NotFound();
 

src/PowderCoating.Web/Controllers/PasskeyController.cs

@@ -20,6 +20,7 @@ namespace PowderCoating.Web.Controllers;
 /// matches automatically on localhost, dev, staging, and production without any
 /// environment-specific configuration.
 /// </summary>
+// Intentional exception: WebAuthn/FIDO2 identity infrastructure. UserPasskeys is an ASP.NET Identity concern not exposed through IUnitOfWork; the anonymous login path has no tenant context; FIDO2 async callbacks capture _db by closure. See docs/DATA_ACCESS_ARCHITECTURE.md — Permanent Exceptions.
 [Route("[controller]/[action]")]
 public class PasskeyController : Controller
 {

src/PowderCoating.Web/Controllers/PlatformNotificationsController.cs

@@ -1,8 +1,7 @@
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
-using Microsoft.EntityFrameworkCore;
 using PowderCoating.Core.Enums;
-using PowderCoating.Infrastructure.Data;
+using PowderCoating.Core.Interfaces;
 using PowderCoating.Shared.Constants;
 
 namespace PowderCoating.Web.Controllers;
@@ -10,28 +9,21 @@ namespace PowderCoating.Web.Controllers;
 /// <summary>
 /// SuperAdmin-only cross-company notification log viewer.
 /// The company-scoped version lives in NotificationLogsController (CanManageJobs policy).
+/// Uses IgnoreQueryFilters throughout to bypass the multi-tenancy global filter and see
+/// logs from all companies simultaneously.
 /// </summary>
 [Authorize(Policy = AppConstants.Policies.SuperAdminOnly)]
 public class PlatformNotificationsController : Controller
 {
-    private readonly ApplicationDbContext _db;
+    private readonly IUnitOfWork _unitOfWork;
 
-    public PlatformNotificationsController(ApplicationDbContext db) => _db = db;
+    public PlatformNotificationsController(IUnitOfWork unitOfWork) => _unitOfWork = unitOfWork;
 
     /// <summary>
-    /// Renders a paginated, filterable cross-company notification log view visible
+    /// Renders a paginated, filterable cross-company notification log view visible only to SuperAdmins.
-    /// only to SuperAdmins.  Unlike the tenant-scoped
+    /// All filter/sort/paging is applied in-memory after a single filtered repository fetch.
-    /// <see cref="NotificationLogsController.Index"/>, this action uses
+    /// Company names are resolved in a follow-up batch query keyed on the page's distinct company IDs.
-    /// <c>IgnoreQueryFilters()</c> to bypass the multi-tenancy global filter and
+    /// Summary counts reflect the full unfiltered dataset so the health cards are accurate regardless of active filters.
-    /// see logs from all companies simultaneously.
-    /// <para>
-    /// Company names are resolved in a single follow-up query after paging (not via
-    /// a JOIN) because company data lives outside the notification-log table's usual
-    /// query scope, and a separate query keeps the main sort/filter logic clean.
-    /// Summary counts (total, failed, last 24 h) are computed as independent queries
-    /// against the full unfiltered dataset so the summary reflects platform-wide
-    /// health regardless of the active filters.
-    /// </para>
     /// </summary>
     public async Task<IActionResult> Index(
         int? companyId,
@@ -47,41 +39,38 @@ public class PlatformNotificationsController : Controller
         pageSize = pageSize is 25 or 50 or 100 ? pageSize : 50;
         page = Math.Max(1, page);
 
-        var query = _db.NotificationLogs
+        // Load all non-deleted logs across all tenants, then filter in-memory.
-            .AsNoTracking()
+        var all = (await _unitOfWork.NotificationLogs.FindAsync(n => !n.IsDeleted, ignoreQueryFilters: true))
-            .IgnoreQueryFilters()
+            .AsEnumerable();
-            .Where(n => !n.IsDeleted)
-            .AsQueryable();
 
         if (companyId.HasValue)
-            query = query.Where(n => n.CompanyId == companyId);
+            all = all.Where(n => n.CompanyId == companyId);
 
         if (!string.IsNullOrWhiteSpace(type) && Enum.TryParse<NotificationType>(type, out var typeEnum))
-            query = query.Where(n => n.NotificationType == typeEnum);
+            all = all.Where(n => n.NotificationType == typeEnum);
 
         if (!string.IsNullOrWhiteSpace(status) && Enum.TryParse<NotificationStatus>(status, out var statusEnum))
-            query = query.Where(n => n.Status == statusEnum);
+            all = all.Where(n => n.Status == statusEnum);
 
         if (!string.IsNullOrWhiteSpace(channel) && Enum.TryParse<NotificationChannel>(channel, out var channelEnum))
-            query = query.Where(n => n.Channel == channelEnum);
+            all = all.Where(n => n.Channel == channelEnum);
 
         if (!string.IsNullOrWhiteSpace(search))
-            query = query.Where(n =>
+            all = all.Where(n =>
-                n.RecipientName.Contains(search) ||
+                n.RecipientName.Contains(search, StringComparison.OrdinalIgnoreCase) ||
-                n.Recipient.Contains(search) ||
+                n.Recipient.Contains(search, StringComparison.OrdinalIgnoreCase) ||
-                (n.Subject != null && n.Subject.Contains(search)));
+                (n.Subject != null && n.Subject.Contains(search, StringComparison.OrdinalIgnoreCase)));
 
         if (from.HasValue)
-            query = query.Where(n => n.SentAt >= from.Value.Date);
+            all = all.Where(n => n.SentAt >= from.Value.Date);
 
         if (to.HasValue)
-            query = query.Where(n => n.SentAt < to.Value.Date.AddDays(1));
+            all = all.Where(n => n.SentAt < to.Value.Date.AddDays(1));
 
-        query = query.OrderByDescending(n => n.SentAt);
+        var filtered = all.OrderByDescending(n => n.SentAt).ToList();
+        var totalCount = filtered.Count;
 
-        var totalCount = await query.CountAsync();
+        var items = filtered
-
-        var items = await query
             .Skip((page - 1) * pageSize)
             .Take(pageSize)
             .Select(n => new PlatformNotificationRow
@@ -97,30 +86,26 @@ public class PlatformNotificationsController : Controller
                 ErrorMessage = n.ErrorMessage,
                 SentAt = n.SentAt
             })
-            .ToListAsync();
+            .ToList();
 
-        // Resolve company names for the rows in one query
+        // Resolve company names for the page's rows in one query
         var cids = items.Select(i => i.CompanyId).Distinct().ToList();
-        var companyNames = await _db.Companies.AsNoTracking().IgnoreQueryFilters()
+        var companyNames = (await _unitOfWork.Companies.FindAsync(c => cids.Contains(c.Id), ignoreQueryFilters: true))
-            .Where(c => cids.Contains(c.Id))
+            .ToDictionary(c => c.Id, c => c.CompanyName);
-            .ToDictionaryAsync(c => c.Id, c => c.CompanyName);
-
         foreach (var item in items)
             item.CompanyName = companyNames.GetValueOrDefault(item.CompanyId);
 
         // Sidebar company list for filter dropdown
-        var companies = await _db.Companies.AsNoTracking().IgnoreQueryFilters()
+        var companies = (await _unitOfWork.Companies.FindAsync(c => !c.IsDeleted, ignoreQueryFilters: true))
-            .Where(c => !c.IsDeleted)
             .OrderBy(c => c.CompanyName)
             .Select(c => new { c.Id, c.CompanyName })
-            .ToListAsync();
+            .ToList();
 
-        // Summary counts
+        // Summary counts from the unfiltered dataset
-        ViewBag.TotalCount = await _db.NotificationLogs.IgnoreQueryFilters().CountAsync(n => !n.IsDeleted);
+        var allLogs = await _unitOfWork.NotificationLogs.FindAsync(n => !n.IsDeleted, ignoreQueryFilters: true);
-        ViewBag.FailedCount = await _db.NotificationLogs.IgnoreQueryFilters()
+        ViewBag.TotalCount = allLogs.Count();
-            .CountAsync(n => !n.IsDeleted && n.Status == NotificationStatus.Failed);
+        ViewBag.FailedCount = allLogs.Count(n => n.Status == NotificationStatus.Failed);
-        ViewBag.Last24hCount = await _db.NotificationLogs.IgnoreQueryFilters()
+        ViewBag.Last24hCount = allLogs.Count(n => n.SentAt >= DateTime.UtcNow.AddHours(-24));
-            .CountAsync(n => !n.IsDeleted && n.SentAt >= DateTime.UtcNow.AddHours(-24));
 
         ViewBag.Companies = companies;
         ViewBag.CompanyIdFilter = companyId;
@@ -139,23 +124,17 @@ public class PlatformNotificationsController : Controller
     }
 
     /// <summary>
-    /// Returns the full notification log entry for the given <paramref name="id"/>,
+    /// Returns the full notification log entry for the given id, including the complete message body and error details.
-    /// including the complete message body and error details.  The owning company name
-    /// is resolved separately (rather than via navigation property) because company
-    /// records are in a different query-filter context.
     /// </summary>
     public async Task<IActionResult> Details(int id)
     {
-        var log = await _db.NotificationLogs.AsNoTracking().IgnoreQueryFilters()
+        var log = await _unitOfWork.NotificationLogs.FirstOrDefaultAsync(n => n.Id == id, ignoreQueryFilters: true);
-            .FirstOrDefaultAsync(n => n.Id == id);
         if (log == null) return NotFound();
 
         string? companyName = null;
         if (log.CompanyId > 0)
-            companyName = await _db.Companies.AsNoTracking().IgnoreQueryFilters()
+            companyName = (await _unitOfWork.Companies.FirstOrDefaultAsync(
-                .Where(c => c.Id == log.CompanyId)
+                c => c.Id == log.CompanyId, ignoreQueryFilters: true))?.CompanyName;
-                .Select(c => c.CompanyName)
-                .FirstOrDefaultAsync();
 
         ViewBag.CompanyName = companyName;
         return View(log);

src/PowderCoating.Web/Controllers/QuoteApprovalController.cs

@@ -1,11 +1,10 @@
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.RateLimiting;
 using Microsoft.AspNetCore.SignalR;
-using Microsoft.EntityFrameworkCore;
 using PowderCoating.Application.Interfaces;
 using PowderCoating.Core.Entities;
 using PowderCoating.Core.Enums;
-using PowderCoating.Infrastructure.Data;
+using PowderCoating.Core.Interfaces;
 using PowderCoating.Shared.Constants;
 using PowderCoating.Web.Hubs;
 using PowderCoating.Web.ViewModels;
@@ -22,7 +21,7 @@ namespace PowderCoating.Web.Controllers;
 [EnableRateLimiting(AppConstants.RateLimitPolicies.Public)]
 public class QuoteApprovalController : Controller
 {
-    private readonly ApplicationDbContext _db;
+    private readonly IUnitOfWork _unitOfWork;
     private readonly INotificationService _notifications;
     private readonly IInAppNotificationService _inApp;
     private readonly IStripeConnectService _stripeConnect;
@@ -31,7 +30,7 @@ public class QuoteApprovalController : Controller
     private readonly IHubContext<NotificationHub> _hub;
 
     public QuoteApprovalController(
-        ApplicationDbContext db,
+        IUnitOfWork unitOfWork,
         INotificationService notifications,
         IInAppNotificationService inApp,
         IStripeConnectService stripeConnect,
@@ -39,7 +38,7 @@ public class QuoteApprovalController : Controller
         IConfiguration configuration,
         IHubContext<NotificationHub> hub)
     {
-        _db = db;
+        _unitOfWork = unitOfWork;
         _notifications = notifications;
         _inApp = inApp;
         _stripeConnect = stripeConnect;
@@ -50,11 +49,8 @@ public class QuoteApprovalController : Controller
 
     /// <summary>
     /// Renders the main customer-facing approval page showing quote line items, totals, and
-    /// Approve/Decline buttons. The <c>[ActionName("View")]</c> attribute overrides the method name
+    /// Approve/Decline buttons.
-    /// so the route is <c>/quote-approval/{token}</c> without exposing the internal method name.
-    /// All token validation (expiry, already-acted) is centralised in <see cref="ValidateTokenAsync"/>.
     /// </summary>
-    // GET /quote-approval/{token}
     [HttpGet("{token}")]
     [ActionName("View")]
     public async Task<IActionResult> ShowApprovalPage(string token)
@@ -67,19 +63,15 @@ public class QuoteApprovalController : Controller
     }
 
     /// <summary>
-    /// Shows the contact-details confirmation step for prospect (non-customer) quotes. Prospects
+    /// Shows the contact-details confirmation step for prospect (non-customer) quotes.
-    /// have no <c>CustomerId</c> on the quote, so we collect their contact information before
+    /// Quotes already linked to a customer skip this step and go directly to ApproveInternal.
-    /// finalising the approval. Quotes already linked to a customer skip this step and go directly
-    /// to <see cref="ApproveInternal"/> — a customer's details are already on file.
     /// </summary>
-    // GET /quote-approval/{token}/confirm-details
     [HttpGet("{token}/confirm-details")]
     public async Task<IActionResult> ConfirmDetails(string token)
     {
         var (quote, errorResult) = await ValidateTokenAsync(token);
         if (errorResult != null) return errorResult;
 
-        // Only prospects need to fill in details; linked customers go straight through.
         if (quote!.CustomerId.HasValue)
             return await ApproveInternal(token, quote);
 
@@ -88,13 +80,10 @@ public class QuoteApprovalController : Controller
     }
 
     /// <summary>
-    /// Handles the contact-detail form submission from prospects. Requires at minimum a name and
+    /// Handles the contact-detail form submission from prospects. Persists contact details to the
-    /// either an email or phone number — this minimal validation mirrors the fields required to
+    /// quote then delegates to ApproveInternal so the approval and audit trail are written in a single
-    /// later convert the quote to a customer record. On success, persists the prospect contact
+    /// path shared with the customer flow.
-    /// details to the quote and delegates to <see cref="ApproveInternal"/> so the approval and
-    /// audit trail are written in a single path shared with the customer flow.
     /// </summary>
-    // POST /quote-approval/{token}/confirm-details
     [HttpPost("{token}/confirm-details")]
     [ValidateAntiForgeryToken]
     public async Task<IActionResult> SubmitDetails(string token,
@@ -110,7 +99,6 @@ public class QuoteApprovalController : Controller
         var (quote, errorResult) = await ValidateTokenAsync(token);
         if (errorResult != null) return errorResult;
 
-        // Require at minimum a name and either email or phone
         if (string.IsNullOrWhiteSpace(contactName) ||
             (string.IsNullOrWhiteSpace(email) && string.IsNullOrWhiteSpace(phone)))
         {
@@ -127,7 +115,6 @@ public class QuoteApprovalController : Controller
             return base.View("ConfirmDetails", model);
         }
 
-        // Update prospect fields on the quote
         quote!.ProspectContactName = contactName?.Trim();
         quote.ProspectEmail = email?.Trim();
         quote.ProspectPhone = phone?.Trim();
@@ -137,18 +124,15 @@ public class QuoteApprovalController : Controller
         quote.ProspectState = state?.Trim();
         quote.ProspectZipCode = zipCode?.Trim();
         quote.UpdatedAt = DateTime.UtcNow;
-        await _db.SaveChangesAsync();
+        await _unitOfWork.CompleteAsync();
 
         return await ApproveInternal(token, quote);
     }
 
     /// <summary>
-    /// Entry point for the Approve button on the approval page. For prospect quotes, redirects to
+    /// Entry point for the Approve button. For prospect quotes, redirects to the contact-details form.
-    /// the contact-details form rather than approving immediately. For customer-linked quotes,
+    /// For customer-linked quotes, delegates directly to ApproveInternal.
-    /// delegates directly to <see cref="ApproveInternal"/>. This two-path design keeps the main
-    /// approval page simple (one Approve button) while still collecting required prospect data.
     /// </summary>
-    // POST /quote-approval/{token}/approve
     [HttpPost("{token}/approve")]
     [ValidateAntiForgeryToken]
     public async Task<IActionResult> Approve(string token)
@@ -156,7 +140,6 @@ public class QuoteApprovalController : Controller
         var (quote, errorResult) = await ValidateTokenAsync(token);
         if (errorResult != null) return errorResult;
 
-        // Prospect quotes collect contact details first
         if (!quote!.CustomerId.HasValue)
         {
             var model = await BuildViewModelAsync(quote, token);
@@ -167,22 +150,15 @@ public class QuoteApprovalController : Controller
     }
 
     /// <summary>
-    /// Core approval logic shared by both the customer path (<see cref="Approve"/>) and the prospect
+    /// Core approval logic shared by the customer path and the prospect path. Sets the quote status,
-    /// path (<see cref="SubmitDetails"/>). Sets the quote status to the company's designated
+    /// records ApprovalTokenUsedAt, writes an audit entry, pushes a SignalR notification to staff,
-    /// <c>IsApprovedStatus</c> lookup entry, records <c>ApprovalTokenUsedAt</c> to prevent token
+    /// and optionally generates a deposit payment link token if Stripe Connect is active.
-    /// reuse, clears any prior decline reason (customers can re-approve after declining), and writes
-    /// a <c>QuoteChangeHistory</c> audit entry with <c>ChangedByUserId = null</c> to indicate the
-    /// action was performed by the customer rather than a staff member. After persisting, a SignalR
-    /// push notifies logged-in staff in real time. If the quote requires a deposit and the company
-    /// has Stripe Connect active, a time-limited deposit payment link token (7 days) is generated
-    /// and saved so the confirmation page can surface a "Pay deposit online" button. Prospect quotes
-    /// skip the deposit link because there is no <c>Customer</c> row to attach a <c>Deposit</c> to.
     /// </summary>
     private async Task<IActionResult> ApproveInternal(string token, Quote quote)
     {
-        var approvedStatus = await _db.QuoteStatusLookups
+        var approvedStatus = await _unitOfWork.QuoteStatusLookups.FirstOrDefaultAsync(
-            .IgnoreQueryFilters()
+            s => s.CompanyId == quote.CompanyId && s.IsApprovedStatus && !s.IsDeleted,
-            .FirstOrDefaultAsync(s => s.CompanyId == quote.CompanyId && s.IsApprovedStatus && !s.IsDeleted);
+            ignoreQueryFilters: true);
 
         var oldStatusName = quote.QuoteStatus?.DisplayName ?? "Unknown";
 
@@ -199,9 +175,9 @@ public class QuoteApprovalController : Controller
             quote.DeclineReason = null;
         }
 
-        await _db.SaveChangesAsync();
+        await _unitOfWork.CompleteAsync();
 
-        var approveEntry = new PowderCoating.Core.Entities.QuoteChangeHistory
+        var approveEntry = new QuoteChangeHistory
         {
             QuoteId = quote.Id,
             ChangedByUserId = null,
@@ -215,8 +191,8 @@ public class QuoteApprovalController : Controller
             CompanyId = quote.CompanyId,
             CreatedAt = DateTime.UtcNow
         };
-        _db.QuoteChangeHistories.Add(approveEntry);
+        await _unitOfWork.QuoteChangeHistories.AddAsync(approveEntry);
-        await _db.SaveChangesAsync();
+        await _unitOfWork.CompleteAsync();
 
         await _hub.Clients.Group($"company-{quote.CompanyId}").SendAsync("QuoteActedByCustomer", new
         {
@@ -246,20 +222,19 @@ public class QuoteApprovalController : Controller
             _logger.LogWarning(ex, "Failed to send approval notification for quote {QuoteId}", quote.Id);
         }
 
-        // Generate deposit payment link if this quote requires a deposit and the company has Stripe Connect
         if (quote.RequiresDeposit
             && quote.DepositPercent > 0
-            && quote.CustomerId.HasValue   // prospects don't have a Customer row to attach a Deposit to
+            && quote.CustomerId.HasValue
             && quote.DepositAmountPaid <= 0)
         {
-            var company = await _db.Companies.AsNoTracking()
+            var company = await _unitOfWork.Companies.FirstOrDefaultAsync(
-                .FirstOrDefaultAsync(c => c.Id == quote.CompanyId && !c.IsDeleted);
+                c => c.Id == quote.CompanyId && !c.IsDeleted);
 
             if (company?.StripeConnectStatus == StripeConnectStatus.Active)
             {
                 quote.DepositPaymentLinkToken = Guid.NewGuid().ToString("N");
                 quote.DepositPaymentLinkExpiresAt = DateTime.UtcNow.AddDays(7);
-                await _db.SaveChangesAsync();
+                await _unitOfWork.CompleteAsync();
             }
         }
 
@@ -267,15 +242,9 @@ public class QuoteApprovalController : Controller
     }
 
     /// <summary>
-    /// Handles the customer declining a quote. Requires a non-empty reason (enforced with a
+    /// Handles the customer declining a quote. Records the decline reason, marks the token used,
-    /// field-level error, not ModelState) so staff always know why a quote was rejected. The
+    /// pushes a SignalR notification and in-app notification to staff.
-    /// decline reason is truncated to 1000 characters before persistence to avoid oversized inputs.
-    /// The customer's IP is recorded (<c>DeclinedByIp</c>) for audit purposes. A SignalR event and
-    /// in-app notification are pushed to staff. The token is marked used (<c>ApprovalTokenUsedAt</c>)
-    /// so the customer cannot approve after declining via the same link — they must request a new
-    /// link from the shop.
     /// </summary>
-    // POST /quote-approval/{token}/decline
     [HttpPost("{token}/decline")]
     [ValidateAntiForgeryToken]
     public async Task<IActionResult> Decline(string token, [FromForm] string reason)
@@ -290,13 +259,12 @@ public class QuoteApprovalController : Controller
             return base.View("ApprovalPage", model);
         }
 
-        // Find the rejected status for this company (by flag, or fall back to StatusCode)
+        var rejectedStatus = await _unitOfWork.QuoteStatusLookups.FirstOrDefaultAsync(
-        var rejectedStatus = await _db.QuoteStatusLookups
+                s => s.CompanyId == quote!.CompanyId && s.IsRejectedStatus && !s.IsDeleted,
-            .IgnoreQueryFilters()
+                ignoreQueryFilters: true)
-            .FirstOrDefaultAsync(s => s.CompanyId == quote!.CompanyId && s.IsRejectedStatus && !s.IsDeleted)
+            ?? await _unitOfWork.QuoteStatusLookups.FirstOrDefaultAsync(
-            ?? await _db.QuoteStatusLookups
+                s => s.CompanyId == quote!.CompanyId && s.StatusCode == "REJECTED" && !s.IsDeleted,
-            .IgnoreQueryFilters()
+                ignoreQueryFilters: true);
-            .FirstOrDefaultAsync(s => s.CompanyId == quote!.CompanyId && s.StatusCode == "REJECTED" && !s.IsDeleted);
 
         var oldDeclineStatusName = quote!.QuoteStatus?.DisplayName ?? "Unknown";
 
@@ -308,10 +276,9 @@ public class QuoteApprovalController : Controller
         quote.DeclinedByIp = HttpContext.Connection.RemoteIpAddress?.ToString();
         quote.ApprovalTokenUsedAt = DateTime.UtcNow;
 
-        await _db.SaveChangesAsync();
+        await _unitOfWork.CompleteAsync();
 
-        // Audit log — decline
+        var declineEntry = new QuoteChangeHistory
-        var declineEntry = new PowderCoating.Core.Entities.QuoteChangeHistory
         {
             QuoteId = quote.Id,
             ChangedByUserId = null,
@@ -323,10 +290,9 @@ public class QuoteApprovalController : Controller
             CompanyId = quote.CompanyId,
             CreatedAt = DateTime.UtcNow
         };
-        _db.QuoteChangeHistories.Add(declineEntry);
+        await _unitOfWork.QuoteChangeHistories.AddAsync(declineEntry);
-        await _db.SaveChangesAsync();
+        await _unitOfWork.CompleteAsync();
 
-        // Push real-time toast to any logged-in company users
         await _hub.Clients.Group($"company-{quote.CompanyId}").SendAsync("QuoteActedByCustomer", new
         {
             approved = false,
@@ -359,40 +325,30 @@ public class QuoteApprovalController : Controller
     }
 
     /// <summary>
-    /// Renders the post-action confirmation page shown after the customer approves or declines.
+    /// Renders the post-action confirmation page. Does NOT re-validate the token against the
-    /// Does NOT re-validate the token against the used/expired guards in
+    /// used/expired guards — by this point the token is already marked used.
-    /// <see cref="ValidateTokenAsync"/> — by this point the token is already marked used, so those
-    /// guards would incorrectly redirect to AlreadyActed. Instead, it only checks that the quote
-    /// exists. The <c>action</c> query-string value ("approved" / "declined") is set by the
-    /// redirect from <see cref="ApproveInternal"/> or <see cref="Decline"/> and drives the
-    /// confirmation message in the view. The deposit link token is only surfaced if it is present
-    /// and not yet expired.
     /// </summary>
-    // GET /quote-approval/{token}/confirmation
     [HttpGet("{token}/confirmation")]
     public async Task<IActionResult> Confirmation(string token, [FromQuery] string action)
     {
-        var quote = await _db.Quotes
+        var quote = await _unitOfWork.Quotes.FirstOrDefaultAsync(
-            .IgnoreQueryFilters()
+            q => q.ApprovalToken == token && !q.IsDeleted,
-            .Include(q => q.Customer)
+            ignoreQueryFilters: true,
-            .FirstOrDefaultAsync(q => q.ApprovalToken == token && !q.IsDeleted);
+            q => q.Customer);
 
         if (quote == null)
             return base.View("InvalidToken");
 
-        var company = await _db.Companies
+        var company = await _unitOfWork.Companies.FirstOrDefaultAsync(
-            .IgnoreQueryFilters()
+            c => c.Id == quote.CompanyId, ignoreQueryFilters: true);
-            .FirstOrDefaultAsync(c => c.Id == quote.CompanyId);
 
-        var prefs = await _db.CompanyPreferences
+        var prefs = await _unitOfWork.CompanyPreferences.FirstOrDefaultAsync(
-            .IgnoreQueryFilters()
+            p => p.CompanyId == quote.CompanyId && !p.IsDeleted, ignoreQueryFilters: true);
-            .FirstOrDefaultAsync(p => p.CompanyId == quote.CompanyId && !p.IsDeleted);
 
         var depositAmount = quote.RequiresDeposit && quote.DepositPercent > 0
             ? Math.Round(quote.Total * (quote.DepositPercent / 100m), 2)
             : 0m;
 
-        // Only surface the deposit link if it's valid and not expired
         var depositToken = (!string.IsNullOrEmpty(quote.DepositPaymentLinkToken)
             && quote.DepositPaymentLinkExpiresAt > DateTime.UtcNow)
             ? quote.DepositPaymentLinkToken
@@ -424,26 +380,16 @@ public class QuoteApprovalController : Controller
     // -----------------------------------------------------------------------
 
     /// <summary>
-    /// Validates the approval token and returns the quote if it is still actionable, or an
+    /// Validates the approval token and returns the quote if still actionable. Uses
-    /// <c>IActionResult</c> error view if not. Checks in order: token exists, not expired, not
+    /// IQuoteRepository.GetByApprovalTokenAsync which loads with IgnoreQueryFilters (the portal is
-    /// already used (<c>ApprovalTokenUsedAt != null</c>), and not already in a terminal status
+    /// unauthenticated — no tenant context exists on the request).
-    /// (approved, rejected, or converted). The terminal-status check is a belt-and-suspenders guard
-    /// for cases where the status was changed by staff inside the app after the token was issued but
-    /// before the customer clicked. Uses <c>IgnoreQueryFilters</c> because the customer has no
-    /// tenant context. Loads <c>QuoteItems</c>, <c>QuoteStatus</c>, and <c>Customer</c> eagerly to
-    /// avoid N+1 queries in <see cref="BuildViewModelAsync"/>.
     /// </summary>
     private async Task<(Quote? quote, IActionResult? errorResult)> ValidateTokenAsync(string token)
     {
         if (string.IsNullOrWhiteSpace(token))
             return (null, base.View("InvalidToken"));
 
-        var quote = await _db.Quotes
+        var quote = await _unitOfWork.Quotes.GetByApprovalTokenAsync(token);
-            .IgnoreQueryFilters()
-            .Include(q => q.QuoteItems)
-            .Include(q => q.QuoteStatus)
-            .Include(q => q.Customer)
-            .FirstOrDefaultAsync(q => q.ApprovalToken == token && !q.IsDeleted);
 
         if (quote == null)
             return (null, base.View("InvalidToken"));
@@ -462,7 +408,6 @@ public class QuoteApprovalController : Controller
             return (null, base.View("AlreadyActed", actedModel));
         }
 
-        // Also check terminal status
         if (quote.QuoteStatus != null &&
             (quote.QuoteStatus.IsApprovedStatus || quote.QuoteStatus.IsRejectedStatus || quote.QuoteStatus.IsConvertedStatus))
         {
@@ -476,22 +421,16 @@ public class QuoteApprovalController : Controller
     }
 
     /// <summary>
-    /// Builds the <c>QuoteApprovalViewModel</c> from a validated quote. Fetches company details and
+    /// Builds the QuoteApprovalViewModel from a validated quote. Fetches company details and
-    /// preferences (e.g. from-email address for the contact section) separately because they are
+    /// preferences separately because they are not eagerly loaded by ValidateTokenAsync.
-    /// not eagerly loaded by <see cref="ValidateTokenAsync"/>. Soft-deleted line items are filtered
-    /// out so the customer only sees active items. Also maps all prospect contact fields so the
-    /// <c>ConfirmDetails</c> view can pre-populate them if the prospect has previously started and
-    /// returned to the approval page.
     /// </summary>
     private async Task<QuoteApprovalViewModel> BuildViewModelAsync(Quote quote, string token)
     {
-        var company = await _db.Companies
+        var company = await _unitOfWork.Companies.FirstOrDefaultAsync(
-            .IgnoreQueryFilters()
+            c => c.Id == quote.CompanyId, ignoreQueryFilters: true);
-            .FirstOrDefaultAsync(c => c.Id == quote.CompanyId);
 
-        var prefs = await _db.CompanyPreferences
+        var prefs = await _unitOfWork.CompanyPreferences.FirstOrDefaultAsync(
-            .IgnoreQueryFilters()
+            p => p.CompanyId == quote.CompanyId && !p.IsDeleted, ignoreQueryFilters: true);
-            .FirstOrDefaultAsync(p => p.CompanyId == quote.CompanyId && !p.IsDeleted);
 
         var items = (quote.QuoteItems ?? new List<QuoteItem>())
             .Where(i => !i.IsDeleted)
@@ -537,9 +476,7 @@ public class QuoteApprovalController : Controller
     }
 
     /// <summary>
-    /// Resolves the display name for the customer or prospect on a quote. Prefers the company name
+    /// Resolves the display name for the customer or prospect on a quote.
-    /// for commercial customers, falls back to contact first/last name, then to prospect fields, and
-    /// finally to the generic "Valued Customer" sentinel so the view always has something to show.
     /// </summary>
     private static string GetCustomerName(Quote quote)
     {

src/PowderCoating.Web/Controllers/ReleaseNotesController.cs

@@ -1,9 +1,8 @@
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
-using Microsoft.EntityFrameworkCore;
 using PowderCoating.Application.Interfaces;
 using PowderCoating.Core.Entities;
-using PowderCoating.Infrastructure.Data;
+using PowderCoating.Core.Interfaces;
 using PowderCoating.Shared.Constants;
 
 namespace PowderCoating.Web.Controllers;
@@ -19,17 +18,16 @@ namespace PowderCoating.Web.Controllers;
 /// </summary>
 public class ReleaseNotesController : Controller
 {
-    private readonly ApplicationDbContext _db;
+    private readonly IUnitOfWork _unitOfWork;
     private readonly IInAppNotificationService _inApp;
 
-    public ReleaseNotesController(ApplicationDbContext db, IInAppNotificationService inApp)
+    public ReleaseNotesController(IUnitOfWork unitOfWork, IInAppNotificationService inApp)
     {
-        _db = db;
+        _unitOfWork = unitOfWork;
         _inApp = inApp;
     }
 
     // ── Public: Changelog ────────────────────────────────────────────────────
-    // Visible to all authenticated users
 
     /// <summary>
     /// Renders the public changelog — shows only published release notes ordered
@@ -39,54 +37,39 @@ public class ReleaseNotesController : Controller
     [Authorize]
     public async Task<IActionResult> Index()
     {
-        var notes = await _db.ReleaseNotes
+        var notes = (await _unitOfWork.ReleaseNotes.FindAsync(r => r.IsPublished))
-            .AsNoTracking()
-            .Where(r => r.IsPublished)
             .OrderByDescending(r => r.ReleasedAt)
             .ThenByDescending(r => r.Id)
-            .ToListAsync();
+            .ToList();
-
         return View(notes);
     }
 
     // ── SuperAdmin: Manage ───────────────────────────────────────────────────
 
     /// <summary>
-    /// Returns the SuperAdmin management list of all release notes (published and
+    /// Returns the SuperAdmin management list of all release notes (published and draft alike), ordered newest-first.
-    /// draft alike), ordered newest-first.  Unlike <see cref="Index"/> there is no
-    /// <c>IsPublished</c> filter here so admins can see and edit drafts.
     /// </summary>
     [Authorize(Policy = AppConstants.Policies.SuperAdminOnly)]
     public async Task<IActionResult> Manage()
     {
-        var notes = await _db.ReleaseNotes
+        var notes = (await _unitOfWork.ReleaseNotes.GetAllAsync())
-            .AsNoTracking()
             .OrderByDescending(r => r.ReleasedAt)
             .ThenByDescending(r => r.Id)
-            .ToListAsync();
+            .ToList();
-
         return View(notes);
     }
 
     /// <summary>
-    /// Returns the Create form pre-populated with today's UTC date and the "Feature"
+    /// Returns the Create form pre-populated with today's UTC date and the "Feature" tag as sensible defaults.
-    /// tag as sensible defaults for new entries, reducing data-entry friction.
     /// </summary>
     [Authorize(Policy = AppConstants.Policies.SuperAdminOnly)]
     public IActionResult Create()
     {
-        return View(new ReleaseNote
+        return View(new ReleaseNote { ReleasedAt = DateTime.UtcNow, Tag = "Feature" });
-        {
-            ReleasedAt = DateTime.UtcNow,
-            Tag = "Feature"
-        });
     }
 
     /// <summary>
-    /// Persists a new release note and captures the creating SuperAdmin's identity
+    /// Persists a new release note. New notes start unpublished unless the form explicitly sets IsPublished = true.
-    /// (<c>CreatedByUserId</c> / <c>CreatedByUserName</c>) for audit purposes.
-    /// New notes start unpublished by default unless the form explicitly sets
-    /// <c>IsPublished = true</c>, giving authors a chance to review before going live.
     /// </summary>
     [HttpPost, ValidateAntiForgeryToken]
     [Authorize(Policy = AppConstants.Policies.SuperAdminOnly)]
@@ -99,8 +82,8 @@ public class ReleaseNotesController : Controller
         model.CreatedByUserId = User.FindFirst(System.Security.Claims.ClaimTypes.NameIdentifier)?.Value;
         model.CreatedByUserName = User.Identity?.Name;
 
-        _db.ReleaseNotes.Add(model);
+        await _unitOfWork.ReleaseNotes.AddAsync(model);
-        await _db.SaveChangesAsync();
+        await _unitOfWork.CompleteAsync();
 
         if (model.IsPublished)
             await NotifyAllTenantsAsync(model);
@@ -109,22 +92,18 @@ public class ReleaseNotesController : Controller
         return RedirectToAction(nameof(Manage));
     }
 
-    /// <summary>
+    /// <summary>Returns the Edit form loaded from the database by primary key.</summary>
-    /// Returns the Edit form loaded from the database by primary key.
-    /// </summary>
     [Authorize(Policy = AppConstants.Policies.SuperAdminOnly)]
     public async Task<IActionResult> Edit(int id)
     {
-        var note = await _db.ReleaseNotes.FindAsync(id);
+        var note = await _unitOfWork.ReleaseNotes.GetByIdAsync(id);
         if (note == null) return NotFound();
         return View(note);
     }
 
     /// <summary>
-    /// Applies the edited values to the tracked entity.  Uses explicit field
+    /// Applies the edited values to the tracked entity using explicit field mapping to prevent
-    /// mapping (rather than <c>_db.Entry(model).State = Modified</c>) to prevent
+    /// over-posting attacks and ensure audit fields are never overwritten.
-    /// over-posting attacks and to ensure audit fields like <c>CreatedAt</c> and
-    /// <c>CreatedByUserId</c> are never overwritten.
     /// </summary>
     [HttpPost, ValidateAntiForgeryToken]
     [Authorize(Policy = AppConstants.Policies.SuperAdminOnly)]
@@ -134,40 +113,37 @@ public class ReleaseNotesController : Controller
         if (!ModelState.IsValid)
             return View(model);
 
-        var note = await _db.ReleaseNotes.FindAsync(id);
+        var note = await _unitOfWork.ReleaseNotes.GetByIdAsync(id);
         if (note == null) return NotFound();
 
-        note.Version    = model.Version;
+        note.Version     = model.Version;
-        note.Title      = model.Title;
+        note.Title       = model.Title;
-        note.Body       = model.Body;
+        note.Body        = model.Body;
-        note.Tag        = model.Tag;
+        note.Tag         = model.Tag;
-        note.IsPublished= model.IsPublished;
+        note.IsPublished = model.IsPublished;
-        note.ReleasedAt = model.ReleasedAt;
+        note.ReleasedAt  = model.ReleasedAt;
-        note.UpdatedAt  = DateTime.UtcNow;
+        note.UpdatedAt   = DateTime.UtcNow;
 
-        await _db.SaveChangesAsync();
+        await _unitOfWork.CompleteAsync();
 
         TempData["Success"] = $"Release note v{note.Version} updated.";
         return RedirectToAction(nameof(Manage));
     }
 
     /// <summary>
-    /// Toggles the published state of a release note.  Publishing makes the note
+    /// Toggles the published state of a release note. Publishing fires an in-app notification to all tenants.
-    /// immediately visible to all authenticated users via <see cref="Index"/>;
-    /// un-publishing hides it without permanently deleting it so it can be revised
-    /// and re-published later.
     /// </summary>
     [HttpPost, ValidateAntiForgeryToken]
     [Authorize(Policy = AppConstants.Policies.SuperAdminOnly)]
     public async Task<IActionResult> TogglePublish(int id)
     {
-        var note = await _db.ReleaseNotes.FindAsync(id);
+        var note = await _unitOfWork.ReleaseNotes.GetByIdAsync(id);
         if (note == null) return NotFound();
 
         var wasPublished = note.IsPublished;
         note.IsPublished = !note.IsPublished;
         note.UpdatedAt   = DateTime.UtcNow;
-        await _db.SaveChangesAsync();
+        await _unitOfWork.CompleteAsync();
 
         if (note.IsPublished && !wasPublished)
             await NotifyAllTenantsAsync(note);
@@ -179,29 +155,24 @@ public class ReleaseNotesController : Controller
     }
 
     /// <summary>
-    /// Permanently (hard) deletes a release note.  This is intentional — release notes
+    /// Permanently (hard) deletes a release note. Release notes are platform metadata and do not use soft delete.
-    /// are platform metadata, not business data, so they do not use soft delete.
-    /// Use <see cref="TogglePublish"/> to hide a note without permanent removal.
     /// </summary>
     [HttpPost, ValidateAntiForgeryToken]
     [Authorize(Policy = AppConstants.Policies.SuperAdminOnly)]
     public async Task<IActionResult> Delete(int id)
     {
-        var note = await _db.ReleaseNotes.FindAsync(id);
+        var note = await _unitOfWork.ReleaseNotes.GetByIdAsync(id);
         if (note == null) return NotFound();
 
-        _db.ReleaseNotes.Remove(note);
+        await _unitOfWork.ReleaseNotes.DeleteAsync(note);
-        await _db.SaveChangesAsync();
+        await _unitOfWork.CompleteAsync();
 
         TempData["Success"] = $"Release note v{note.Version} deleted.";
         return RedirectToAction(nameof(Manage));
     }
 
     /// <summary>
-    /// Fans out a "What's New" in-app notification to every active tenant company when
+    /// Fans out a "What's New" in-app notification to every active tenant company when a release note is published.
-    /// a release note transitions to published. Notification fires exactly once per
-    /// publish event — re-publishing after unpublishing will send a second notification,
-    /// which is intentional (the content may have changed).
     /// </summary>
     private Task NotifyAllTenantsAsync(ReleaseNote note)
     {

src/PowderCoating.Web/Controllers/ReportsController.cs

@@ -9,7 +9,6 @@ using PowderCoating.Application.Interfaces;
 using PowderCoating.Core.Enums;
 using PowderCoating.Core.Interfaces;
 using PowderCoating.Core.Entities;
-using PowderCoating.Infrastructure.Data;
 using PowderCoating.Shared.Constants;
 using PowderCoating.Web.ViewModels.Reports;
 
@@ -20,17 +19,19 @@ public class ReportsController : Controller
 {
     private readonly IUnitOfWork _unitOfWork;
     private readonly ILogger<ReportsController> _logger;
-    private readonly ApplicationDbContext _context;
+    private readonly IFinancialReportService _financialReports;
+    private readonly IOperationalReportService _operationalReports;
     private readonly IPdfService _pdfService;
     private readonly UserManager<ApplicationUser> _userManager;
     private readonly IAccountingAiService _accountingAi;
     private readonly IAiUsageLogger _usageLogger;
 
-    public ReportsController(IUnitOfWork unitOfWork, ILogger<ReportsController> logger, ApplicationDbContext context, IPdfService pdfService, UserManager<ApplicationUser> userManager, IAccountingAiService accountingAi, IAiUsageLogger usageLogger)
+    public ReportsController(IUnitOfWork unitOfWork, ILogger<ReportsController> logger, IFinancialReportService financialReports, IOperationalReportService operationalReports, IPdfService pdfService, UserManager<ApplicationUser> userManager, IAccountingAiService accountingAi, IAiUsageLogger usageLogger)
     {
         _unitOfWork = unitOfWork;
         _logger = logger;
-        _context = context;
+        _financialReports = financialReports;
+        _operationalReports = operationalReports;
         _pdfService = pdfService;
         _userManager = userManager;
         _accountingAi = accountingAi;
@@ -493,11 +494,7 @@ public class ReportsController : Controller
                 .ToList();
 
             // === EXPENSE / AP ANALYTICS ===
-            var allBills = await _context.Bills
+            var allBills = await _operationalReports.GetActiveBillsAsync();
-                .Include(b => b.Vendor)
-                .Include(b => b.Payments.Where(p => !p.IsDeleted))
-                .Where(b => !b.IsDeleted && b.Status != BillStatus.Voided)
-                .ToListAsync();
 
             var totalBilled = allBills.Sum(b => b.Total);
             var totalBillsPaid = allBills.Sum(b => b.AmountPaid);
@@ -536,10 +533,7 @@ public class ReportsController : Controller
                 .ToList();
 
             // Expenses by account
-            var allExpenses = await _context.Expenses
+            var allExpenses = await _operationalReports.GetAllExpensesAsync();
-                .Include(e => e.ExpenseAccount)
-                .Where(e => !e.IsDeleted)
-                .ToListAsync();
 
             var expensesByAccount = allExpenses
                 .Where(e => e.ExpenseAccount != null)
@@ -664,10 +658,7 @@ public class ReportsController : Controller
                 .ToList();
 
             // === JOB CYCLE TIME ===
-            var allStatusHistory = await _context.JobStatusHistory
+            var allStatusHistory = await _operationalReports.GetAllJobStatusHistoryAsync();
-                .Include(h => h.FromStatus)
-                .Include(h => h.ToStatus)
-                .ToListAsync();
 
             var historyByJob = allStatusHistory
                 .GroupBy(h => h.JobId)
@@ -1002,102 +993,10 @@ public class ReportsController : Controller
     public async Task<IActionResult> ProfitAndLoss(DateTime? from, DateTime? to)
     {
         if (!AllowAccounting()) return RedirectToAction(nameof(Landing));
-        var fromDate = (from ?? new DateTime(DateTime.Today.Year, 1, 1)).Date;
+        var fromDate  = (from ?? new DateTime(DateTime.Today.Year, 1, 1)).Date;
-        var toDate   = (to   ?? DateTime.Today).Date;
+        var toDate    = (to   ?? DateTime.Today).Date;
-        var toEnd    = toDate.AddDays(1).AddTicks(-1);
+        var companyId = int.TryParse(User.FindFirst("CompanyId")?.Value, out var cid) ? cid : 0;
-
+        var dto = await _financialReports.GetProfitAndLossAsync(companyId, fromDate, toDate);
-        var companyName = await GetCompanyNameAsync();
-
-        // ── Revenue: InvoiceItems posted to revenue accounts ──────────────────
-        var revenueByAccount = await _context.InvoiceItems
-            .Where(ii => ii.RevenueAccountId != null
-                      && ii.Invoice.Status != InvoiceStatus.Draft
-                      && ii.Invoice.Status != InvoiceStatus.Voided
-                      && ii.Invoice.InvoiceDate >= fromDate && ii.Invoice.InvoiceDate <= toEnd)
-            .GroupBy(ii => ii.RevenueAccountId!.Value)
-            .Select(g => new { AccountId = g.Key, Amount = g.Sum(ii => ii.TotalPrice) })
-            .ToListAsync();
-
-        // Unlinked invoice totals (items without a revenue account) → lump into a default "Sales" bucket
-        var unlinkedRevenue = await _context.InvoiceItems
-            .Where(ii => ii.RevenueAccountId == null
-                      && ii.Invoice.Status != InvoiceStatus.Draft
-                      && ii.Invoice.Status != InvoiceStatus.Voided
-                      && ii.Invoice.InvoiceDate >= fromDate && ii.Invoice.InvoiceDate <= toEnd)
-            .SumAsync(ii => (decimal?)ii.TotalPrice) ?? 0;
-
-        var revenueAccounts = await _context.Accounts
-            .Where(a => a.AccountType == AccountType.Revenue && a.IsActive)
-            .ToDictionaryAsync(a => a.Id);
-
-        var revenueLines = revenueByAccount
-            .Where(r => revenueAccounts.ContainsKey(r.AccountId))
-            .Select(r => new FinancialReportLine
-            {
-                AccountId     = r.AccountId,
-                AccountNumber = revenueAccounts[r.AccountId].AccountNumber,
-                AccountName   = revenueAccounts[r.AccountId].Name,
-                Amount        = r.Amount
-            })
-            .OrderBy(l => l.AccountNumber)
-            .ToList();
-
-        if (unlinkedRevenue > 0)
-            revenueLines.Add(new FinancialReportLine { AccountNumber = "—", AccountName = "Other Sales (unclassified)", Amount = unlinkedRevenue });
-
-        // ── COGS & Expenses: Expenses + BillLineItems by account type ─────────
-        // Direct expenses
-        var directByAccount = await _context.Expenses
-            .Where(e => e.Date >= fromDate && e.Date <= toEnd)
-            .GroupBy(e => e.ExpenseAccountId)
-            .Select(g => new { AccountId = g.Key, Amount = g.Sum(e => e.Amount) })
-            .ToListAsync();
-
-        // Bill line items (skip lines with no account — QB-imported without account mapping)
-        var billLinesByAccount = await _context.BillLineItems
-            .Where(bli => bli.AccountId != null
-                       && bli.Bill.Status != BillStatus.Draft
-                       && bli.Bill.Status != BillStatus.Voided
-                       && bli.Bill.BillDate >= fromDate && bli.Bill.BillDate <= toEnd)
-            .GroupBy(bli => bli.AccountId!.Value)
-            .Select(g => new { AccountId = g.Key, Amount = g.Sum(bli => bli.Amount) })
-            .ToListAsync();
-
-        // Merge the two expense sources per account
-        var expenseAmounts = new Dictionary<int, decimal>();
-        foreach (var e in directByAccount)
-            expenseAmounts[e.AccountId] = expenseAmounts.GetValueOrDefault(e.AccountId) + e.Amount;
-        foreach (var b in billLinesByAccount)
-            expenseAmounts[b.AccountId] = expenseAmounts.GetValueOrDefault(b.AccountId) + b.Amount;
-
-        var expAccounts = await _context.Accounts
-            .Where(a => (a.AccountType == AccountType.Expense || a.AccountType == AccountType.CostOfGoods) && a.IsActive)
-            .ToDictionaryAsync(a => a.Id);
-
-        var cogsLines    = new List<FinancialReportLine>();
-        var expenseLines = new List<FinancialReportLine>();
-
-        foreach (var (accountId, amount) in expenseAmounts.OrderBy(kv => expAccounts.ContainsKey(kv.Key) ? expAccounts[kv.Key].AccountNumber : "999"))
-        {
-            if (!expAccounts.TryGetValue(accountId, out var acct)) continue;
-            var line = new FinancialReportLine { AccountId = accountId, AccountNumber = acct.AccountNumber, AccountName = acct.Name, Amount = amount };
-            if (acct.AccountType == AccountType.CostOfGoods) cogsLines.Add(line);
-            else expenseLines.Add(line);
-        }
-
-        var dto = new ProfitAndLossDto
-        {
-            From         = fromDate,
-            To           = toDate,
-            CompanyName  = companyName,
-            RevenueLines = revenueLines,
-            TotalRevenue = revenueLines.Sum(l => l.Amount),
-            CogsLines    = cogsLines,
-            TotalCogs    = cogsLines.Sum(l => l.Amount),
-            ExpenseLines = expenseLines,
-            TotalExpenses = expenseLines.Sum(l => l.Amount),
-        };
-
         return View(dto);
     }
 
@@ -1116,157 +1015,9 @@ public class ReportsController : Controller
     public async Task<IActionResult> BalanceSheet(DateTime? asOf)
     {
         if (!AllowAccounting()) return RedirectToAction(nameof(Landing));
-        var asOfDate = (asOf ?? DateTime.Today).Date;
+        var asOfDate  = (asOf ?? DateTime.Today).Date;
-        var asOfEnd  = asOfDate.AddDays(1).AddTicks(-1);
+        var companyId = int.TryParse(User.FindFirst("CompanyId")?.Value, out var cid) ? cid : 0;
-
+        var dto = await _financialReports.GetBalanceSheetAsync(companyId, asOfDate);
-        var companyName = await GetCompanyNameAsync();
-
-        // ── Pre-compute balance contributions per account (batch queries) ──────
-
-        // Asset: payments deposited INTO account (DEBIT) — exclude voided/written-off invoices
-        var depositsByAcct = await _context.Payments
-            .Where(p => p.PaymentDate <= asOfEnd && p.DepositAccountId != null
-                     && p.Invoice.Status != InvoiceStatus.Voided
-                     && p.Invoice.Status != InvoiceStatus.WrittenOff)
-            .GroupBy(p => p.DepositAccountId!.Value)
-            .Select(g => new { Id = g.Key, Amount = g.Sum(p => p.Amount) })
-            .ToDictionaryAsync(g => g.Id, g => g.Amount);
-
-        // Asset: expenses paid FROM account (CREDIT)
-        var expFromByAcct = await _context.Expenses
-            .Where(e => e.Date <= asOfEnd)
-            .GroupBy(e => e.PaymentAccountId)
-            .Select(g => new { Id = g.Key, Amount = g.Sum(e => e.Amount) })
-            .ToDictionaryAsync(g => g.Id, g => g.Amount);
-
-        // Asset: bill payments FROM account (CREDIT)
-        var bpFromByAcct = await _context.BillPayments
-            .Where(bp => bp.PaymentDate <= asOfEnd)
-            .GroupBy(bp => bp.BankAccountId)
-            .Select(g => new { Id = g.Key, Amount = g.Sum(bp => bp.Amount) })
-            .ToDictionaryAsync(g => g.Id, g => g.Amount);
-
-        // Liability: bills posted to AP account (CREDIT)
-        var billsByApAcct = await _context.Bills
-            .Where(b => b.Status != BillStatus.Draft && b.Status != BillStatus.Voided && b.BillDate <= asOfEnd)
-            .GroupBy(b => b.APAccountId)
-            .Select(g => new { Id = g.Key, Amount = g.Sum(b => b.Total) })
-            .ToDictionaryAsync(g => g.Id, g => g.Amount);
-
-        // Liability: bill payments reducing AP (DEBIT)
-        var bpByApAcct = await _context.BillPayments
-            .Where(bp => bp.PaymentDate <= asOfEnd)
-            .GroupBy(bp => bp.Bill.APAccountId)
-            .Select(g => new { Id = g.Key, Amount = g.Sum(bp => bp.Amount) })
-            .ToDictionaryAsync(g => g.Id, g => g.Amount);
-
-        // Liability: sales tax payable (CREDIT)
-        var taxByAcct = await _context.Invoices
-            .Where(i => i.SalesTaxAccountId != null && i.TaxAmount > 0
-                     && i.Status != InvoiceStatus.Draft && i.Status != InvoiceStatus.Voided
-                     && i.InvoiceDate <= asOfEnd)
-            .GroupBy(i => i.SalesTaxAccountId!.Value)
-            .Select(g => new { Id = g.Key, Amount = g.Sum(i => i.TaxAmount) })
-            .ToDictionaryAsync(g => g.Id, g => g.Amount);
-
-        // AR total (used for AR sub-type accounts)
-        var arDebits  = await _context.Invoices.Where(i => i.Status != InvoiceStatus.Draft && i.Status != InvoiceStatus.Voided && i.InvoiceDate <= asOfEnd).SumAsync(i => (decimal?)i.Total) ?? 0;
-        var arCredits = await _context.Payments.Where(p => p.PaymentDate <= asOfEnd
-                             && p.Invoice.Status != InvoiceStatus.Voided
-                             && p.Invoice.Status != InvoiceStatus.WrittenOff).SumAsync(p => (decimal?)p.Amount) ?? 0;
-
-        // ── Retained earnings = net P&L from inception ────────────────────────
-        var lifetimeRevenue = await _context.InvoiceItems
-            .Where(ii => ii.Invoice.Status != InvoiceStatus.Draft && ii.Invoice.Status != InvoiceStatus.Voided && ii.Invoice.InvoiceDate <= asOfEnd)
-            .SumAsync(ii => (decimal?)ii.TotalPrice) ?? 0;
-        var lifetimeCogs = await _context.Expenses.Where(e => e.Date <= asOfEnd).Include(e => e.ExpenseAccount).SumAsync(e => (decimal?)e.Amount) ?? 0;
-        var lifetimeBillCosts = await _context.BillLineItems.Where(bli => bli.Bill.Status != BillStatus.Draft && bli.Bill.Status != BillStatus.Voided && bli.Bill.BillDate <= asOfEnd).SumAsync(bli => (decimal?)bli.Amount) ?? 0;
-        var retainedEarnings = lifetimeRevenue - lifetimeCogs - lifetimeBillCosts;
-
-        // ── Compute balance for each account ──────────────────────────────────
-        decimal ComputeBalance(Account a)
-        {
-            bool normalDebit = a.AccountType == AccountType.Asset;
-            decimal debits = 0, credits = 0;
-
-            if (a.AccountSubType == AccountSubType.AccountsReceivable)
-            {
-                debits = arDebits; credits = arCredits;
-            }
-            else if (a.AccountSubType == AccountSubType.AccountsPayable)
-            {
-                credits = billsByApAcct.GetValueOrDefault(a.Id);
-                debits  = bpByApAcct.GetValueOrDefault(a.Id);
-            }
-            else
-            {
-                debits  += depositsByAcct.GetValueOrDefault(a.Id);
-                credits += expFromByAcct.GetValueOrDefault(a.Id);
-                credits += bpFromByAcct.GetValueOrDefault(a.Id);
-                credits += taxByAcct.GetValueOrDefault(a.Id);
-            }
-
-            decimal opening = (a.OpeningBalanceDate == null || a.OpeningBalanceDate.Value.Date <= asOfDate)
-                ? a.OpeningBalance : 0;
-            decimal net = normalDebit ? debits - credits : credits - debits;
-            return opening + net;
-        }
-
-        FinancialReportLine ToLine(Account a) => new()
-        {
-            AccountId     = a.Id,
-            AccountNumber = a.AccountNumber,
-            AccountName   = a.Name,
-            Amount        = ComputeBalance(a)
-        };
-
-        // Load accounts by type
-        var accounts = await _context.Accounts.Where(a => a.IsActive).OrderBy(a => a.AccountNumber).ToListAsync();
-
-        var assetAccts     = accounts.Where(a => a.AccountType == AccountType.Asset).ToList();
-        var liabilityAccts = accounts.Where(a => a.AccountType == AccountType.Liability).ToList();
-        var equityAccts    = accounts.Where(a => a.AccountType == AccountType.Equity).ToList();
-
-        var currentAssets = assetAccts
-            .Where(a => a.AccountSubType is AccountSubType.Checking or AccountSubType.Savings
-                     or AccountSubType.AccountsReceivable or AccountSubType.Inventory or AccountSubType.OtherCurrentAsset)
-            .Select(ToLine).ToList();
-        var fixedAssets = assetAccts
-            .Where(a => a.AccountSubType == AccountSubType.FixedAsset)
-            .Select(ToLine).ToList();
-        var otherAssets = assetAccts
-            .Where(a => a.AccountSubType == AccountSubType.OtherAsset)
-            .Select(ToLine).ToList();
-
-        var currentLiabilities = liabilityAccts
-            .Where(a => a.AccountSubType is AccountSubType.AccountsPayable or AccountSubType.CreditCard or AccountSubType.OtherCurrentLiability)
-            .Select(ToLine).ToList();
-        var longTermLiabilities = liabilityAccts
-            .Where(a => a.AccountSubType == AccountSubType.LongTermLiability)
-            .Select(ToLine).ToList();
-
-        var equityLines = equityAccts.Select(ToLine).ToList();
-
-        var totalAssets      = currentAssets.Sum(l => l.Amount) + fixedAssets.Sum(l => l.Amount) + otherAssets.Sum(l => l.Amount);
-        var totalLiabilities = currentLiabilities.Sum(l => l.Amount) + longTermLiabilities.Sum(l => l.Amount);
-        var totalEquity      = equityLines.Sum(l => l.Amount) + retainedEarnings;
-
-        var dto = new BalanceSheetDto
-        {
-            AsOf                = asOfDate,
-            CompanyName         = companyName,
-            CurrentAssets       = currentAssets,
-            FixedAssets         = fixedAssets,
-            OtherAssets         = otherAssets,
-            TotalAssets         = totalAssets,
-            CurrentLiabilities  = currentLiabilities,
-            LongTermLiabilities = longTermLiabilities,
-            TotalLiabilities    = totalLiabilities,
-            EquityLines         = equityLines,
-            RetainedEarnings    = retainedEarnings,
-            TotalEquity         = totalEquity,
-        };
-
         return View(dto);
     }
 
@@ -1282,85 +1033,9 @@ public class ReportsController : Controller
     public async Task<IActionResult> ArAging(DateTime? asOf)
     {
         if (!AllowAccounting()) return RedirectToAction(nameof(Landing));
-        var asOfDate = (asOf ?? DateTime.Today).Date;
+        var asOfDate  = (asOf ?? DateTime.Today).Date;
-        var asOfEnd  = asOfDate.AddDays(1).AddTicks(-1);
+        var companyId = int.TryParse(User.FindFirst("CompanyId")?.Value, out var cid) ? cid : 0;
-
+        var dto = await _financialReports.GetArAgingAsync(companyId, asOfDate);
-        var companyName = await GetCompanyNameAsync();
-
-        var openInvoices = await _context.Invoices
-            .Include(i => i.Customer)
-            .Where(i => i.Status != InvoiceStatus.Draft
-                     && i.Status != InvoiceStatus.Voided
-                     && i.Status != InvoiceStatus.Paid
-                     && i.InvoiceDate <= asOfEnd
-                     && (i.Total - i.AmountPaid - i.CreditApplied - i.GiftCertificateRedeemed) > 0)
-            .OrderBy(i => i.Customer!.CompanyName)
-            .ThenBy(i => i.DueDate)
-            .ToListAsync();
-
-        var customerGroups = openInvoices
-            .GroupBy(i => new { i.CustomerId, i.Customer!.CompanyName, i.Customer.ContactFirstName, i.Customer.ContactLastName, i.Customer.IsCommercial });
-
-        static string AgingBucket(int daysOverdue) => daysOverdue switch
-        {
-            <= 0       => "current",
-            <= 30      => "1-30",
-            <= 60      => "31-60",
-            <= 90      => "61-90",
-            _          => "90+"
-        };
-
-        var customers = new List<ArAgingCustomerDto>();
-
-        foreach (var grp in customerGroups)
-        {
-            var customerName = grp.Key.IsCommercial
-                ? grp.Key.CompanyName
-                : $"{grp.Key.ContactFirstName} {grp.Key.ContactLastName}".Trim();
-
-            var custDto = new ArAgingCustomerDto { CustomerId = grp.Key.CustomerId, CustomerName = customerName };
-
-            foreach (var inv in grp)
-            {
-                var balance     = inv.BalanceDue;
-                var daysOverdue = inv.DueDate.HasValue ? (int)(asOfDate - inv.DueDate.Value.Date).TotalDays : 0;
-                var bucket      = AgingBucket(daysOverdue);
-
-                custDto.Invoices.Add(new ArAgingInvoiceDto
-                {
-                    InvoiceId     = inv.Id,
-                    InvoiceNumber = inv.InvoiceNumber,
-                    InvoiceDate   = inv.InvoiceDate,
-                    DueDate       = inv.DueDate,
-                    BalanceDue    = balance,
-                    DaysOverdue   = daysOverdue
-                });
-
-                switch (bucket)
-                {
-                    case "current": custDto.TotalCurrent += balance; break;
-                    case "1-30":    custDto.Total1to30   += balance; break;
-                    case "31-60":   custDto.Total31to60  += balance; break;
-                    case "61-90":   custDto.Total61to90  += balance; break;
-                    default:        custDto.TotalOver90  += balance; break;
-                }
-            }
-
-            customers.Add(custDto);
-        }
-
-        var dto = new ArAgingReportDto
-        {
-            AsOf          = asOfDate,
-            CompanyName   = companyName,
-            Customers     = customers.OrderByDescending(c => c.TotalBalance).ToList(),
-            TotalCurrent  = customers.Sum(c => c.TotalCurrent),
-            Total1to30    = customers.Sum(c => c.Total1to30),
-            Total31to60   = customers.Sum(c => c.Total31to60),
-            Total61to90   = customers.Sum(c => c.Total61to90),
-            TotalOver90   = customers.Sum(c => c.TotalOver90),
-        };
-
         return View(dto);
     }
 
@@ -1375,90 +1050,10 @@ public class ReportsController : Controller
     // GET: /Reports/SalesAndIncome
     public async Task<IActionResult> SalesAndIncome(DateTime? from, DateTime? to)
     {
-        var fromDate = (from ?? new DateTime(DateTime.Today.Year, 1, 1)).Date;
+        var fromDate  = (from ?? new DateTime(DateTime.Today.Year, 1, 1)).Date;
-        var toDate   = (to   ?? DateTime.Today).Date;
+        var toDate    = (to   ?? DateTime.Today).Date;
-        var toEnd    = toDate.AddDays(1).AddTicks(-1);
+        var companyId = int.TryParse(User.FindFirst("CompanyId")?.Value, out var cid) ? cid : 0;
-
+        var dto = await _financialReports.GetSalesAndIncomeAsync(companyId, fromDate, toDate);
-        var companyName = await GetCompanyNameAsync();
-
-        var invoices = await _context.Invoices
-            .Include(i => i.Customer)
-            .Include(i => i.Payments)
-            .Where(i => i.Status != InvoiceStatus.Draft
-                     && i.Status != InvoiceStatus.Voided
-                     && i.InvoiceDate >= fromDate && i.InvoiceDate <= toEnd)
-            .OrderBy(i => i.InvoiceDate)
-            .ToListAsync();
-
-        // Payments collected within the period (may differ from invoice dates)
-        var collectedInPeriod = await _context.Payments
-            .Where(p => p.PaymentDate >= fromDate && p.PaymentDate <= toEnd)
-            .SumAsync(p => (decimal?)p.Amount) ?? 0;
-
-        // By customer
-        var byCustomer = invoices
-            .GroupBy(i => new { i.CustomerId, Name = i.Customer!.IsCommercial
-                ? i.Customer.CompanyName
-                : $"{i.Customer.ContactFirstName} {i.Customer.ContactLastName}".Trim() })
-            .Select(g => new SalesByCustomerDto
-            {
-                CustomerId    = g.Key.CustomerId,
-                CustomerName  = g.Key.Name,
-                InvoiceCount  = g.Count(),
-                TotalInvoiced = g.Sum(i => i.Total),
-                TotalPaid     = g.Sum(i => i.AmountPaid),
-                BalanceDue    = g.Sum(i => i.BalanceDue),
-            })
-            .OrderByDescending(c => c.TotalInvoiced)
-            .ToList();
-
-        // By month
-        var byMonth = invoices
-            .GroupBy(i => new { i.InvoiceDate.Year, i.InvoiceDate.Month })
-            .Select(g => new SalesByMonthDto
-            {
-                Year           = g.Key.Year,
-                Month          = g.Key.Month,
-                Label          = new DateTime(g.Key.Year, g.Key.Month, 1).ToString("MMM yyyy"),
-                TotalInvoiced  = g.Sum(i => i.Total),
-                TotalCollected = g.Sum(i => i.AmountPaid),
-                InvoiceCount   = g.Count(),
-            })
-            .OrderBy(m => m.Year).ThenBy(m => m.Month)
-            .ToList();
-
-        // Invoice detail lines
-        var invoiceLines = invoices.Select(i => new SalesInvoiceLineDto
-        {
-            InvoiceId    = i.Id,
-            InvoiceNumber = i.InvoiceNumber,
-            CustomerName = i.Customer!.IsCommercial ? i.Customer.CompanyName : $"{i.Customer.ContactFirstName} {i.Customer.ContactLastName}".Trim(),
-            InvoiceDate  = i.InvoiceDate,
-            DueDate      = i.DueDate,
-            Status       = i.Status.ToString(),
-            SubTotal     = i.SubTotal,
-            TaxAmount    = i.TaxAmount,
-            Total        = i.Total,
-            AmountPaid   = i.AmountPaid,
-            BalanceDue   = i.BalanceDue,
-        }).ToList();
-
-        var dto = new SalesIncomeReportDto
-        {
-            From           = fromDate,
-            To             = toDate,
-            CompanyName    = companyName,
-            TotalInvoiced  = invoices.Sum(i => i.Total),
-            TotalCollected = collectedInPeriod,
-            TotalTax       = invoices.Sum(i => i.TaxAmount),
-            TotalDiscount  = invoices.Sum(i => i.DiscountAmount),
-            InvoiceCount   = invoices.Count,
-            CustomerCount  = invoices.Select(i => i.CustomerId).Distinct().Count(),
-            ByCustomer     = byCustomer,
-            ByMonth        = byMonth,
-            Invoices       = invoiceLines,
-        };
-
         return View(dto);
     }
 
@@ -1476,64 +1071,10 @@ public class ReportsController : Controller
     public async Task<IActionResult> ProfitAndLossPdf(DateTime? from, DateTime? to, bool inline = false)
     {
         if (!AllowAccounting()) return RedirectToAction(nameof(Landing));
-        var fromDate = (from ?? new DateTime(DateTime.Today.Year, 1, 1)).Date;
+        var fromDate  = (from ?? new DateTime(DateTime.Today.Year, 1, 1)).Date;
-        var toDate   = (to   ?? DateTime.Today).Date;
+        var toDate    = (to   ?? DateTime.Today).Date;
-        var toEnd    = toDate.AddDays(1).AddTicks(-1);
+        var companyId = int.TryParse(User.FindFirst("CompanyId")?.Value, out var cid) ? cid : 0;
-        var companyName = await GetCompanyNameAsync();
+        var dto = await _financialReports.GetProfitAndLossAsync(companyId, fromDate, toDate);
-
-        var revenueByAccount = await _context.InvoiceItems
-            .Where(ii => ii.RevenueAccountId != null
-                      && ii.Invoice.Status != InvoiceStatus.Draft && ii.Invoice.Status != InvoiceStatus.Voided
-                      && ii.Invoice.InvoiceDate >= fromDate && ii.Invoice.InvoiceDate <= toEnd)
-            .GroupBy(ii => ii.RevenueAccountId!.Value)
-            .Select(g => new { AccountId = g.Key, Amount = g.Sum(ii => ii.TotalPrice) })
-            .ToListAsync();
-
-        var unlinkedRevenue = await _context.InvoiceItems
-            .Where(ii => ii.RevenueAccountId == null
-                      && ii.Invoice.Status != InvoiceStatus.Draft && ii.Invoice.Status != InvoiceStatus.Voided
-                      && ii.Invoice.InvoiceDate >= fromDate && ii.Invoice.InvoiceDate <= toEnd)
-            .SumAsync(ii => (decimal?)ii.TotalPrice) ?? 0;
-
-        var revenueAccounts = await _context.Accounts.Where(a => a.AccountType == AccountType.Revenue && a.IsActive).ToDictionaryAsync(a => a.Id);
-
-        var revenueLines = revenueByAccount
-            .Where(r => revenueAccounts.ContainsKey(r.AccountId))
-            .Select(r => new FinancialReportLine { AccountId = r.AccountId, AccountNumber = revenueAccounts[r.AccountId].AccountNumber, AccountName = revenueAccounts[r.AccountId].Name, Amount = r.Amount })
-            .OrderBy(l => l.AccountNumber).ToList();
-
-        if (unlinkedRevenue > 0)
-            revenueLines.Add(new FinancialReportLine { AccountNumber = "—", AccountName = "Other Sales (unclassified)", Amount = unlinkedRevenue });
-
-        var directByAccount = await _context.Expenses.Where(e => e.Date >= fromDate && e.Date <= toEnd)
-            .GroupBy(e => e.ExpenseAccountId).Select(g => new { AccountId = g.Key, Amount = g.Sum(e => e.Amount) }).ToListAsync();
-
-        var billLinesByAccount = await _context.BillLineItems
-            .Where(bli => bli.AccountId != null && bli.Bill.Status != BillStatus.Draft && bli.Bill.Status != BillStatus.Voided && bli.Bill.BillDate >= fromDate && bli.Bill.BillDate <= toEnd)
-            .GroupBy(bli => bli.AccountId!.Value).Select(g => new { AccountId = g.Key, Amount = g.Sum(bli => bli.Amount) }).ToListAsync();
-
-        var expenseAmounts = new Dictionary<int, decimal>();
-        foreach (var e in directByAccount) expenseAmounts[e.AccountId] = expenseAmounts.GetValueOrDefault(e.AccountId) + e.Amount;
-        foreach (var b in billLinesByAccount) expenseAmounts[b.AccountId] = expenseAmounts.GetValueOrDefault(b.AccountId) + b.Amount;
-
-        var expAccounts = await _context.Accounts.Where(a => (a.AccountType == AccountType.Expense || a.AccountType == AccountType.CostOfGoods) && a.IsActive).ToDictionaryAsync(a => a.Id);
-
-        var cogsLines = new List<FinancialReportLine>(); var expenseLines = new List<FinancialReportLine>();
-        foreach (var (accountId, amount) in expenseAmounts.OrderBy(kv => expAccounts.ContainsKey(kv.Key) ? expAccounts[kv.Key].AccountNumber : "999"))
-        {
-            if (!expAccounts.TryGetValue(accountId, out var acct)) continue;
-            var line = new FinancialReportLine { AccountId = accountId, AccountNumber = acct.AccountNumber, AccountName = acct.Name, Amount = amount };
-            if (acct.AccountType == AccountType.CostOfGoods) cogsLines.Add(line); else expenseLines.Add(line);
-        }
-
-        var dto = new ProfitAndLossDto
-        {
-            From = fromDate, To = toDate, CompanyName = companyName,
-            RevenueLines = revenueLines, TotalRevenue = revenueLines.Sum(l => l.Amount),
-            CogsLines    = cogsLines,   TotalCogs    = cogsLines.Sum(l => l.Amount),
-            ExpenseLines = expenseLines, TotalExpenses = expenseLines.Sum(l => l.Amount),
-        };
-
         var pdfBytes = await _pdfService.GenerateProfitAndLossPdfAsync(dto);
         return inline ? File(pdfBytes, "application/pdf") : File(pdfBytes, "application/pdf", $"ProfitAndLoss-{fromDate:yyyyMMdd}-{toDate:yyyyMMdd}.pdf");
     }
@@ -1546,75 +1087,9 @@ public class ReportsController : Controller
     public async Task<IActionResult> BalanceSheetPdf(DateTime? asOf, bool inline = false)
     {
         if (!AllowAccounting()) return RedirectToAction(nameof(Landing));
-        var asOfDate = (asOf ?? DateTime.Today).Date;
+        var asOfDate  = (asOf ?? DateTime.Today).Date;
-        var asOfEnd  = asOfDate.AddDays(1).AddTicks(-1);
+        var companyId = int.TryParse(User.FindFirst("CompanyId")?.Value, out var cid) ? cid : 0;
-        var companyName = await GetCompanyNameAsync();
+        var dto = await _financialReports.GetBalanceSheetAsync(companyId, asOfDate);
-
-        var depositsByAcct = await _context.Payments.Where(p => p.PaymentDate <= asOfEnd && p.DepositAccountId != null)
-            .GroupBy(p => p.DepositAccountId!.Value).Select(g => new { Id = g.Key, Amount = g.Sum(p => p.Amount) }).ToDictionaryAsync(g => g.Id, g => g.Amount);
-
-        var expFromByAcct = await _context.Expenses.Where(e => e.Date <= asOfEnd)
-            .GroupBy(e => e.PaymentAccountId).Select(g => new { Id = g.Key, Amount = g.Sum(e => e.Amount) }).ToDictionaryAsync(g => g.Id, g => g.Amount);
-
-        var bpFromByAcct = await _context.BillPayments.Where(bp => bp.PaymentDate <= asOfEnd)
-            .GroupBy(bp => bp.BankAccountId).Select(g => new { Id = g.Key, Amount = g.Sum(bp => bp.Amount) }).ToDictionaryAsync(g => g.Id, g => g.Amount);
-
-        var billsByApAcct = await _context.Bills.Where(b => b.Status != BillStatus.Draft && b.Status != BillStatus.Voided && b.BillDate <= asOfEnd)
-            .GroupBy(b => b.APAccountId).Select(g => new { Id = g.Key, Amount = g.Sum(b => b.Total) }).ToDictionaryAsync(g => g.Id, g => g.Amount);
-
-        var bpByApAcct = await _context.BillPayments.Where(bp => bp.PaymentDate <= asOfEnd)
-            .GroupBy(bp => bp.Bill.APAccountId).Select(g => new { Id = g.Key, Amount = g.Sum(bp => bp.Amount) }).ToDictionaryAsync(g => g.Id, g => g.Amount);
-
-        var taxByAcct = await _context.Invoices.Where(i => i.SalesTaxAccountId != null && i.TaxAmount > 0 && i.Status != InvoiceStatus.Draft && i.Status != InvoiceStatus.Voided && i.InvoiceDate <= asOfEnd)
-            .GroupBy(i => i.SalesTaxAccountId!.Value).Select(g => new { Id = g.Key, Amount = g.Sum(i => i.TaxAmount) }).ToDictionaryAsync(g => g.Id, g => g.Amount);
-
-        var arDebits  = await _context.Invoices.Where(i => i.Status != InvoiceStatus.Draft && i.Status != InvoiceStatus.Voided && i.InvoiceDate <= asOfEnd).SumAsync(i => (decimal?)i.Total) ?? 0;
-        var arCredits = await _context.Payments.Where(p => p.PaymentDate <= asOfEnd).SumAsync(p => (decimal?)p.Amount) ?? 0;
-
-        var lifetimeRevenue    = await _context.InvoiceItems.Where(ii => ii.Invoice.Status != InvoiceStatus.Draft && ii.Invoice.Status != InvoiceStatus.Voided && ii.Invoice.InvoiceDate <= asOfEnd).SumAsync(ii => (decimal?)ii.TotalPrice) ?? 0;
-        var lifetimeCogs       = await _context.Expenses.Where(e => e.Date <= asOfEnd).Include(e => e.ExpenseAccount).SumAsync(e => (decimal?)e.Amount) ?? 0;
-        var lifetimeBillCosts  = await _context.BillLineItems.Where(bli => bli.Bill.Status != BillStatus.Draft && bli.Bill.Status != BillStatus.Voided && bli.Bill.BillDate <= asOfEnd).SumAsync(bli => (decimal?)bli.Amount) ?? 0;
-        var retainedEarnings   = lifetimeRevenue - lifetimeCogs - lifetimeBillCosts;
-
-        var accounts = await _context.Accounts.Where(a => a.IsActive).OrderBy(a => a.AccountNumber).ToListAsync();
-
-        decimal ComputeBalance(Account a)
-        {
-            bool normalDebit = a.AccountType == AccountType.Asset;
-            decimal debits = 0, credits = 0;
-            if (a.AccountSubType == AccountSubType.AccountsReceivable) { debits = arDebits; credits = arCredits; }
-            else if (a.AccountSubType == AccountSubType.AccountsPayable) { credits = billsByApAcct.GetValueOrDefault(a.Id); debits = bpByApAcct.GetValueOrDefault(a.Id); }
-            else { debits += depositsByAcct.GetValueOrDefault(a.Id); credits += expFromByAcct.GetValueOrDefault(a.Id); credits += bpFromByAcct.GetValueOrDefault(a.Id); credits += taxByAcct.GetValueOrDefault(a.Id); }
-            decimal opening = (a.OpeningBalanceDate == null || a.OpeningBalanceDate.Value.Date <= asOfDate) ? a.OpeningBalance : 0;
-            decimal net = normalDebit ? debits - credits : credits - debits;
-            return opening + net;
-        }
-
-        FinancialReportLine ToLine(Account a) => new() { AccountId = a.Id, AccountNumber = a.AccountNumber, AccountName = a.Name, Amount = ComputeBalance(a) };
-
-        var assetAccts     = accounts.Where(a => a.AccountType == AccountType.Asset).ToList();
-        var liabilityAccts = accounts.Where(a => a.AccountType == AccountType.Liability).ToList();
-        var equityAccts    = accounts.Where(a => a.AccountType == AccountType.Equity).ToList();
-
-        var currentAssets       = assetAccts.Where(a => a.AccountSubType is AccountSubType.Checking or AccountSubType.Savings or AccountSubType.AccountsReceivable or AccountSubType.Inventory or AccountSubType.OtherCurrentAsset).Select(ToLine).ToList();
-        var fixedAssets         = assetAccts.Where(a => a.AccountSubType == AccountSubType.FixedAsset).Select(ToLine).ToList();
-        var otherAssets         = assetAccts.Where(a => a.AccountSubType == AccountSubType.OtherAsset).Select(ToLine).ToList();
-        var currentLiabilities  = liabilityAccts.Where(a => a.AccountSubType is AccountSubType.AccountsPayable or AccountSubType.CreditCard or AccountSubType.OtherCurrentLiability).Select(ToLine).ToList();
-        var longTermLiabilities = liabilityAccts.Where(a => a.AccountSubType == AccountSubType.LongTermLiability).Select(ToLine).ToList();
-        var equityLines         = equityAccts.Select(ToLine).ToList();
-
-        var totalAssets      = currentAssets.Sum(l => l.Amount) + fixedAssets.Sum(l => l.Amount) + otherAssets.Sum(l => l.Amount);
-        var totalLiabilities = currentLiabilities.Sum(l => l.Amount) + longTermLiabilities.Sum(l => l.Amount);
-        var totalEquity      = equityLines.Sum(l => l.Amount) + retainedEarnings;
-
-        var dto = new BalanceSheetDto
-        {
-            AsOf = asOfDate, CompanyName = companyName,
-            CurrentAssets = currentAssets, FixedAssets = fixedAssets, OtherAssets = otherAssets, TotalAssets = totalAssets,
-            CurrentLiabilities = currentLiabilities, LongTermLiabilities = longTermLiabilities, TotalLiabilities = totalLiabilities,
-            EquityLines = equityLines, RetainedEarnings = retainedEarnings, TotalEquity = totalEquity,
-        };
-
         var pdfBytes = await _pdfService.GenerateBalanceSheetPdfAsync(dto);
         return inline ? File(pdfBytes, "application/pdf") : File(pdfBytes, "application/pdf", $"BalanceSheet-{asOfDate:yyyyMMdd}.pdf");
     }
@@ -1627,46 +1102,9 @@ public class ReportsController : Controller
     public async Task<IActionResult> ArAgingPdf(DateTime? asOf, bool inline = false)
     {
         if (!AllowAccounting()) return RedirectToAction(nameof(Landing));
-        var asOfDate = (asOf ?? DateTime.Today).Date;
+        var asOfDate  = (asOf ?? DateTime.Today).Date;
-        var asOfEnd  = asOfDate.AddDays(1).AddTicks(-1);
+        var companyId = int.TryParse(User.FindFirst("CompanyId")?.Value, out var cid) ? cid : 0;
-        var companyName = await GetCompanyNameAsync();
+        var dto = await _financialReports.GetArAgingAsync(companyId, asOfDate);
-
-        var openInvoices = await _context.Invoices
-            .Include(i => i.Customer)
-            .Where(i => i.Status != InvoiceStatus.Draft && i.Status != InvoiceStatus.Voided
-                     && i.Status != InvoiceStatus.Paid && i.InvoiceDate <= asOfEnd
-                     && (i.Total - i.AmountPaid - i.CreditApplied - i.GiftCertificateRedeemed) > 0)
-            .OrderBy(i => i.Customer!.CompanyName).ThenBy(i => i.DueDate)
-            .ToListAsync();
-
-        var customerGroups = openInvoices.GroupBy(i => new { i.CustomerId, i.Customer!.CompanyName, i.Customer.ContactFirstName, i.Customer.ContactLastName, i.Customer.IsCommercial });
-
-        static string AgingBucket(int d) => d switch { <= 0 => "current", <= 30 => "1-30", <= 60 => "31-60", <= 90 => "61-90", _ => "90+" };
-
-        var customers = new List<ArAgingCustomerDto>();
-        foreach (var grp in customerGroups)
-        {
-            var customerName = grp.Key.IsCommercial ? grp.Key.CompanyName : $"{grp.Key.ContactFirstName} {grp.Key.ContactLastName}".Trim();
-            var custDto = new ArAgingCustomerDto { CustomerId = grp.Key.CustomerId, CustomerName = customerName };
-            foreach (var inv in grp)
-            {
-                var balance = inv.BalanceDue;
-                var daysOverdue = inv.DueDate.HasValue ? (int)(asOfDate - inv.DueDate.Value.Date).TotalDays : 0;
-                custDto.Invoices.Add(new ArAgingInvoiceDto { InvoiceId = inv.Id, InvoiceNumber = inv.InvoiceNumber, InvoiceDate = inv.InvoiceDate, DueDate = inv.DueDate, BalanceDue = balance, DaysOverdue = daysOverdue });
-                switch (AgingBucket(daysOverdue)) { case "current": custDto.TotalCurrent += balance; break; case "1-30": custDto.Total1to30 += balance; break; case "31-60": custDto.Total31to60 += balance; break; case "61-90": custDto.Total61to90 += balance; break; default: custDto.TotalOver90 += balance; break; }
-            }
-            customers.Add(custDto);
-        }
-
-        var dto = new ArAgingReportDto
-        {
-            AsOf = asOfDate, CompanyName = companyName,
-            Customers = customers.OrderByDescending(c => c.TotalBalance).ToList(),
-            TotalCurrent = customers.Sum(c => c.TotalCurrent), Total1to30 = customers.Sum(c => c.Total1to30),
-            Total31to60 = customers.Sum(c => c.Total31to60), Total61to90 = customers.Sum(c => c.Total61to90),
-            TotalOver90 = customers.Sum(c => c.TotalOver90),
-        };
-
         var pdfBytes = await _pdfService.GenerateArAgingPdfAsync(dto);
         return inline ? File(pdfBytes, "application/pdf") : File(pdfBytes, "application/pdf", $"AR-Aging-{asOfDate:yyyyMMdd}.pdf");
     }
@@ -1678,48 +1116,10 @@ public class ReportsController : Controller
     // GET: /Reports/SalesAndIncomePdf
     public async Task<IActionResult> SalesAndIncomePdf(DateTime? from, DateTime? to, bool inline = false)
     {
-        var fromDate = (from ?? new DateTime(DateTime.Today.Year, 1, 1)).Date;
+        var fromDate  = (from ?? new DateTime(DateTime.Today.Year, 1, 1)).Date;
-        var toDate   = (to   ?? DateTime.Today).Date;
+        var toDate    = (to   ?? DateTime.Today).Date;
-        var toEnd    = toDate.AddDays(1).AddTicks(-1);
+        var companyId = int.TryParse(User.FindFirst("CompanyId")?.Value, out var cid) ? cid : 0;
-        var companyName = await GetCompanyNameAsync();
+        var dto = await _financialReports.GetSalesAndIncomeAsync(companyId, fromDate, toDate);
-
-        var invoices = await _context.Invoices
-            .Include(i => i.Customer).Include(i => i.Payments)
-            .Where(i => i.Status != InvoiceStatus.Draft && i.Status != InvoiceStatus.Voided
-                     && i.InvoiceDate >= fromDate && i.InvoiceDate <= toEnd)
-            .OrderBy(i => i.InvoiceDate).ToListAsync();
-
-        var collectedInPeriod = await _context.Payments
-            .Where(p => p.PaymentDate >= fromDate && p.PaymentDate <= toEnd)
-            .SumAsync(p => (decimal?)p.Amount) ?? 0;
-
-        var byCustomer = invoices
-            .GroupBy(i => new { i.CustomerId, Name = i.Customer!.IsCommercial ? i.Customer.CompanyName : $"{i.Customer.ContactFirstName} {i.Customer.ContactLastName}".Trim() })
-            .Select(g => new SalesByCustomerDto { CustomerId = g.Key.CustomerId, CustomerName = g.Key.Name, InvoiceCount = g.Count(), TotalInvoiced = g.Sum(i => i.Total), TotalPaid = g.Sum(i => i.AmountPaid), BalanceDue = g.Sum(i => i.BalanceDue) })
-            .OrderByDescending(c => c.TotalInvoiced).ToList();
-
-        var byMonth = invoices
-            .GroupBy(i => new { i.InvoiceDate.Year, i.InvoiceDate.Month })
-            .Select(g => new SalesByMonthDto { Year = g.Key.Year, Month = g.Key.Month, Label = new DateTime(g.Key.Year, g.Key.Month, 1).ToString("MMM yyyy"), TotalInvoiced = g.Sum(i => i.Total), TotalCollected = g.Sum(i => i.AmountPaid), InvoiceCount = g.Count() })
-            .OrderBy(m => m.Year).ThenBy(m => m.Month).ToList();
-
-        var invoiceLines = invoices.Select(i => new SalesInvoiceLineDto
-        {
-            InvoiceId = i.Id, InvoiceNumber = i.InvoiceNumber,
-            CustomerName = i.Customer!.IsCommercial ? i.Customer.CompanyName : $"{i.Customer.ContactFirstName} {i.Customer.ContactLastName}".Trim(),
-            InvoiceDate = i.InvoiceDate, DueDate = i.DueDate, Status = i.Status.ToString(),
-            SubTotal = i.SubTotal, TaxAmount = i.TaxAmount, Total = i.Total, AmountPaid = i.AmountPaid, BalanceDue = i.BalanceDue,
-        }).ToList();
-
-        var dto = new SalesIncomeReportDto
-        {
-            From = fromDate, To = toDate, CompanyName = companyName,
-            TotalInvoiced = invoices.Sum(i => i.Total), TotalCollected = collectedInPeriod,
-            TotalTax = invoices.Sum(i => i.TaxAmount), TotalDiscount = invoices.Sum(i => i.DiscountAmount),
-            InvoiceCount = invoices.Count, CustomerCount = invoices.Select(i => i.CustomerId).Distinct().Count(),
-            ByCustomer = byCustomer, ByMonth = byMonth, Invoices = invoiceLines,
-        };
-
         var pdfBytes = await _pdfService.GenerateSalesAndIncomePdfAsync(dto);
         return inline ? File(pdfBytes, "application/pdf") : File(pdfBytes, "application/pdf", $"SalesAndIncome-{fromDate:yyyyMMdd}-{toDate:yyyyMMdd}.pdf");
     }
@@ -1996,8 +1396,8 @@ public class ReportsController : Controller
         if (!AllowAccounting()) return RedirectToAction(nameof(Landing));
         var now = DateTime.UtcNow;
         var today = DateTime.Today;
-        var allBills = await _context.Bills.Include(b => b.Vendor).Include(b => b.Payments.Where(p => !p.IsDeleted)).Where(b => !b.IsDeleted && b.Status != BillStatus.Voided).ToListAsync();
+        var allBills = await _operationalReports.GetActiveBillsAsync();
-        var allExpenses = await _context.Expenses.Include(e => e.ExpenseAccount).Where(e => !e.IsDeleted).ToListAsync();
+        var allExpenses = await _operationalReports.GetAllExpensesAsync();
 
         var outstandingBills = allBills.Where(b => b.BalanceDue > 0).ToList();
         var apAgingBuckets = new List<AgingBucketItem> { new() { Label = "Current (0–30 days)" }, new() { Label = "31–60 days" }, new() { Label = "61–90 days" }, new() { Label = "Over 90 days" } };
@@ -2116,7 +1516,7 @@ public class ReportsController : Controller
         var now = DateTime.UtcNow;
         var completedStatusCodes = new[] { "COMPLETED", "READY_FOR_PICKUP", "DELIVERED" };
         var completedJobs = (await _unitOfWork.Jobs.GetAllAsync(false, j => j.JobStatus)).Where(j => completedStatusCodes.Contains(j.JobStatus.StatusCode) && j.CompletedDate.HasValue).ToList();
-        var allStatusHistory = await _context.JobStatusHistory.Include(h => h.FromStatus).Include(h => h.ToStatus).ToListAsync();
+        var allStatusHistory = await _operationalReports.GetAllJobStatusHistoryAsync();
         var historyByJob = allStatusHistory.GroupBy(h => h.JobId).ToDictionary(g => g.Key, g => g.OrderBy(h => h.ChangedDate).ToList());
         var statusDisplayOrder = new[] { "PENDING", "QUOTED", "APPROVED", "IN_PREPARATION", "SANDBLASTING", "MASKING_TAPING", "CLEANING", "IN_OVEN", "COATING", "CURING", "QUALITY_CHECK" };
         var statusTimings = new Dictionary<string, (string DisplayName, List<double> Days)>();
@@ -2293,10 +1693,7 @@ public class ReportsController : Controller
                 .Count(i => i.DueDate.HasValue && (today - i.DueDate.Value).TotalDays > 30);
 
             // Expenses by account
-            var allExpenses = await _context.Expenses
+            var allExpenses = await _operationalReports.GetAllExpensesAsync();
-                .Include(e => e.ExpenseAccount)
-                .Where(e => !e.IsDeleted)
-                .ToListAsync();
             var expensesByCategory = allExpenses
                 .Where(e => e.ExpenseAccount != null)
                 .GroupBy(e => e.ExpenseAccount!.Name)
@@ -2306,7 +1703,7 @@ public class ReportsController : Controller
             var totalExpenses = allExpenses.Sum(e => e.Amount);
 
             // Also include bills paid as expenses
-            var allBills = await _context.Bills.Where(b => !b.IsDeleted).ToListAsync();
+            var allBills = await _operationalReports.GetActiveBillsAsync();
             var billsPaid = allBills.Sum(b => b.AmountPaid);
             totalExpenses += billsPaid;
 
@@ -2400,11 +1797,9 @@ public class ReportsController : Controller
             }).ToList();
 
             // Open AP bills
-            var openBills = await _context.Bills
+            var openBills = (await _operationalReports.GetActiveBillsAsync())
-                .Include(b => b.Vendor)
+                .Where(b => b.AmountPaid < b.Total)
-                .Where(b => !b.IsDeleted && b.AmountPaid < b.Total
+                .ToList();
-                    && b.Status != BillStatus.Voided)
-                .ToListAsync();
 
             var apItems = openBills.Select(b => new CashFlowApItem
             {
@@ -2415,13 +1810,11 @@ public class ReportsController : Controller
             }).ToList();
 
             // Active job pipeline (non-terminal jobs not yet invoiced)
-            var activeJobs = await _context.Jobs
+            var activeJobs = (await _unitOfWork.Jobs.GetBoardJobsAsync())
-                .Include(j => j.Customer)
+                .Where(j => j.JobStatus != null && !j.JobStatus.IsTerminalStatus)
-                .Include(j => j.JobStatus)
-                .Where(j => !j.IsDeleted && j.JobStatus != null && !j.JobStatus.IsTerminalStatus)
                 .OrderByDescending(j => j.FinalPrice > 0 ? j.FinalPrice : j.QuotedPrice)
                 .Take(30)
-                .ToListAsync();
+                .ToList();
 
             var jobItems = activeJobs.Select(j => new CashFlowJobItem
             {
@@ -2484,12 +1877,9 @@ public class ReportsController : Controller
             var startOfThisMonth = new DateTime(today.Year, today.Month, 1);
             var startOfLastMonth = startOfThisMonth.AddMonths(-1);
 
-            // Recent bills (last 90 days)
+            // All active bills — used for both recent-bill candidates and all-time vendor history
-            var recentBills = await _context.Bills
+            var allBills = await _operationalReports.GetActiveBillsAsync();
-                .Include(b => b.Vendor)
+            var recentBills = allBills.Where(b => b.BillDate >= ninetyDaysAgo).OrderByDescending(b => b.BillDate).ToList();
-                .Where(b => !b.IsDeleted && b.BillDate >= ninetyDaysAgo)
-                .OrderByDescending(b => b.BillDate)
-                .ToListAsync();
 
             var billSummaries = recentBills.Select(b => new AnomalyBillSummary
             {
@@ -2501,12 +1891,6 @@ public class ReportsController : Controller
                 VendorInvoiceNumber = b.VendorInvoiceNumber
             }).ToList();
 
-            // Vendor history (all time, for averages)
-            var allBills = await _context.Bills
-                .Include(b => b.Vendor)
-                .Where(b => !b.IsDeleted && b.Status != BillStatus.Voided)
-                .ToListAsync();
-
             var vendorHistory = allBills
                 .Where(b => b.Vendor != null)
                 .GroupBy(b => b.Vendor!.CompanyName)
@@ -2525,10 +1909,7 @@ public class ReportsController : Controller
                 }).ToList();
 
             // Account spend trends (bills + expenses by account this month vs historical avg)
-            var allExpenses = await _context.Expenses
+            var allExpenses = await _operationalReports.GetAllExpensesAsync();
-                .Include(e => e.ExpenseAccount)
-                .Where(e => !e.IsDeleted)
-                .ToListAsync();
 
             var accountTrends = allExpenses
                 .Where(e => e.ExpenseAccount != null)
@@ -2581,7 +1962,7 @@ public class ReportsController : Controller
         var companyIdClaim = User.FindFirst("CompanyId")?.Value;
         if (companyIdClaim != null && int.TryParse(companyIdClaim, out int companyId))
         {
-            var company = await _context.Companies.FirstOrDefaultAsync(c => c.Id == companyId);
+            var company = await _unitOfWork.Companies.GetByIdAsync(companyId);
             return company?.CompanyName ?? "Your Company";
         }
         return "Your Company";

src/PowderCoating.Web/Controllers/RevenueController.cs

@@ -13,6 +13,7 @@ namespace PowderCoating.Web.Controllers;
 /// directly (bypassing the UoW) because it queries across company boundaries and
 /// joins plan configs — a pattern that would require multiple unrelated repositories.
 /// </summary>
+// Intentional exception: cross-tenant MRR/ARR metrics joining Company + SubscriptionPlanConfig; same pattern as CompanyHealthController. See docs/DATA_ACCESS_ARCHITECTURE.md — Permanent Exceptions.
 [Authorize(Policy = AppConstants.Policies.SuperAdminOnly)]
 public class RevenueController : Controller
 {

src/PowderCoating.Web/Controllers/SetupWizardController.cs

@@ -8,7 +8,6 @@ using PowderCoating.Application.Services;
 using PowderCoating.Core.Entities;
 using PowderCoating.Core.Enums;
 using PowderCoating.Core.Interfaces;
-using PowderCoating.Infrastructure.Data;
 using PowderCoating.Shared.Constants;
 using System.Text.Json;
 
@@ -20,7 +19,6 @@ public class SetupWizardController : Controller
     private readonly IUnitOfWork _unitOfWork;
     private readonly ITenantContext _tenantContext;
     private readonly UserManager<ApplicationUser> _userManager;
-    private readonly ApplicationDbContext _context;
     private readonly ISeedDataService _seedDataService;
     private readonly ILogger<SetupWizardController> _logger;
 
@@ -28,14 +26,12 @@ public class SetupWizardController : Controller
         IUnitOfWork unitOfWork,
         ITenantContext tenantContext,
         UserManager<ApplicationUser> userManager,
-        ApplicationDbContext context,
         ISeedDataService seedDataService,
         ILogger<SetupWizardController> logger)
     {
         _unitOfWork = unitOfWork;
         _tenantContext = tenantContext;
         _userManager = userManager;
-        _context = context;
         _seedDataService = seedDataService;
         _logger = logger;
     }
@@ -70,14 +66,14 @@ public class SetupWizardController : Controller
         if (company.Preferences == null)
         {
             company.Preferences = new CompanyPreferences { CompanyId = companyId };
-            _context.Set<CompanyPreferences>().Add(company.Preferences);
+            await _unitOfWork.CompanyPreferences.AddAsync(company.Preferences);
             await _unitOfWork.CompleteAsync();
         }
 
         if (company.OperatingCosts == null)
         {
             company.OperatingCosts = new CompanyOperatingCosts { CompanyId = companyId };
-            _context.Set<CompanyOperatingCosts>().Add(company.OperatingCosts);
+            await _unitOfWork.CompanyOperatingCosts.AddAsync(company.OperatingCosts);
             await _unitOfWork.CompleteAsync();
         }
 

src/PowderCoating.Web/Controllers/SmsConsentAuditController.cs

@@ -1,7 +1,6 @@
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
-using Microsoft.EntityFrameworkCore;
+using PowderCoating.Core.Interfaces;
-using PowderCoating.Infrastructure.Data;
 using PowderCoating.Shared.Constants;
 using System.Text;
 
@@ -15,12 +14,12 @@ namespace PowderCoating.Web.Controllers;
 [Authorize(Policy = AppConstants.Policies.CompanyAdminOnly)]
 public class SmsConsentAuditController : Controller
 {
-    private readonly ApplicationDbContext _context;
+    private readonly IUnitOfWork _unitOfWork;
     private readonly ILogger<SmsConsentAuditController> _logger;
 
-    public SmsConsentAuditController(ApplicationDbContext context, ILogger<SmsConsentAuditController> logger)
+    public SmsConsentAuditController(IUnitOfWork unitOfWork, ILogger<SmsConsentAuditController> logger)
     {
-        _context = context;
+        _unitOfWork = unitOfWork;
         _logger = logger;
     }
 
@@ -31,14 +30,12 @@ public class SmsConsentAuditController : Controller
     {
         try
         {
-            var query = _context.Customers
+            var allCustomers = await _unitOfWork.Customers.GetAllAsync();
-                .AsNoTracking()
-                .Where(c => !c.IsDeleted);
 
             if (!string.IsNullOrWhiteSpace(search))
             {
                 var s = search.Trim().ToLower();
-                query = query.Where(c =>
+                allCustomers = allCustomers.Where(c =>
                     (c.ContactFirstName != null && c.ContactFirstName.ToLower().Contains(s)) ||
                     (c.ContactLastName  != null && c.ContactLastName.ToLower().Contains(s))  ||
                     (c.CompanyName      != null && c.CompanyName.ToLower().Contains(s))      ||
@@ -46,43 +43,25 @@ public class SmsConsentAuditController : Controller
                     (c.Phone            != null && c.Phone.Contains(s)));
             }
 
-            var customers = await query
+            var allRows = allCustomers
-                .Select(c => new
-                {
-                    c.Id,
-                    c.CompanyName,
-                    c.ContactFirstName,
-                    c.ContactLastName,
-                    c.IsCommercial,
-                    c.Phone,
-                    c.MobilePhone,
-                    c.NotifyBySms,
-                    c.SmsConsentedAt,
-                    c.SmsConsentMethod,
-                    c.SmsOptedOutAt
-                })
                 .OrderBy(c => c.CompanyName ?? c.ContactLastName ?? c.ContactFirstName)
-                .ToListAsync();
+                .Select(c => new SmsConsentRow
+                {
+                    CustomerId    = c.Id,
+                    CustomerName  = GetDisplayName(c.IsCommercial, c.CompanyName, c.ContactFirstName, c.ContactLastName),
+                    Phone         = c.Phone,
+                    MobilePhone   = c.MobilePhone,
+                    NotifyBySms   = c.NotifyBySms,
+                    ConsentedAt   = c.SmsConsentedAt,
+                    ConsentMethod = c.SmsConsentMethod,
+                    OptedOutAt    = c.SmsOptedOutAt,
+                    SmsStatus     = ResolveSmsStatus(c.NotifyBySms, c.SmsConsentedAt, c.SmsOptedOutAt)
+                }).ToList();
 
-            var allRows = customers.Select(c => new SmsConsentRow
+            var optedIn  = allRows.Count(r => r.SmsStatus == "active");
-            {
+            var optedOut = allRows.Count(r => r.SmsStatus == "opted-out");
-                CustomerId    = c.Id,
+            var never    = allRows.Count(r => r.SmsStatus == "never");
-                CustomerName  = GetDisplayName(c.IsCommercial, c.CompanyName, c.ContactFirstName, c.ContactLastName),
-                Phone         = c.Phone,
-                MobilePhone   = c.MobilePhone,
-                NotifyBySms   = c.NotifyBySms,
-                ConsentedAt   = c.SmsConsentedAt,
-                ConsentMethod = c.SmsConsentMethod,
-                OptedOutAt    = c.SmsOptedOutAt,
-                SmsStatus     = ResolveSmsStatus(c.NotifyBySms, c.SmsConsentedAt, c.SmsOptedOutAt)
-            }).ToList();
 
-            // Stat counts across unfiltered set
-            var optedIn    = allRows.Count(r => r.SmsStatus == "active");
-            var optedOut   = allRows.Count(r => r.SmsStatus == "opted-out");
-            var never      = allRows.Count(r => r.SmsStatus == "never");
-
-            // Apply filter
             var filtered = filter switch
             {
                 "opted-in"  => allRows.Where(r => r.SmsStatus == "active").ToList(),
@@ -119,25 +98,9 @@ public class SmsConsentAuditController : Controller
     {
         try
         {
-            var customers = await _context.Customers
+            var customers = (await _unitOfWork.Customers.GetAllAsync())
-                .AsNoTracking()
-                .Where(c => !c.IsDeleted)
-                .Select(c => new
-                {
-                    c.Id,
-                    c.CompanyName,
-                    c.ContactFirstName,
-                    c.ContactLastName,
-                    c.IsCommercial,
-                    c.Phone,
-                    c.MobilePhone,
-                    c.NotifyBySms,
-                    c.SmsConsentedAt,
-                    c.SmsConsentMethod,
-                    c.SmsOptedOutAt
-                })
                 .OrderBy(c => c.CompanyName ?? c.ContactLastName ?? c.ContactFirstName)
-                .ToListAsync();
+                .ToList();
 
             var sb = new StringBuilder();
             sb.AppendLine("Customer Name,Phone,Mobile Phone,SMS Status,Consented At (UTC),Consent Method,Opted Out At (UTC)");

src/PowderCoating.Web/Controllers/StripeEventsController.cs

@@ -14,6 +14,7 @@ namespace PowderCoating.Web.Controllers;
 /// delivery, and view the raw JSON payload Stripe sent. Restricted to SuperAdmin because the raw
 /// event payloads may contain sensitive subscription and billing information.
 /// </summary>
+// Intentional exception: StripeWebhookEvents is a platform infrastructure table (not a business entity); same reasoning as StripeWebhookController. See docs/DATA_ACCESS_ARCHITECTURE.md — Permanent Exceptions.
 [Authorize(Policy = AppConstants.Policies.SuperAdminOnly)]
 public class StripeEventsController : Controller
 {

src/PowderCoating.Web/Controllers/SubscriptionManagementController.cs

@@ -19,6 +19,7 @@ namespace PowderCoating.Web.Controllers;
 /// because subscription management is a platform-level concern, not a tenant-domain concern,
 /// and requires direct access to the Company entity which lives outside the tenant data layer.
 /// </summary>
+// Intentional exception: cross-tenant Company management with raw SQL audit log writes that bypass the tenant pipeline; platform-level concern outside IUnitOfWork scope. See docs/DATA_ACCESS_ARCHITECTURE.md — Permanent Exceptions.
 [Authorize(Policy = AppConstants.Policies.SuperAdminOnly)]
 public class SubscriptionManagementController : Controller
 {

src/PowderCoating.Web/Controllers/UnsubscribeController.cs

@@ -1,8 +1,7 @@
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.RateLimiting;
-using Microsoft.EntityFrameworkCore;
+using PowderCoating.Core.Interfaces;
-using PowderCoating.Infrastructure.Data;
 using PowderCoating.Shared.Constants;
 
 namespace PowderCoating.Web.Controllers;
@@ -15,12 +14,12 @@ namespace PowderCoating.Web.Controllers;
 [EnableRateLimiting(AppConstants.RateLimitPolicies.Public)]
 public class UnsubscribeController : Controller
 {
-    private readonly ApplicationDbContext _context;
+    private readonly IUnitOfWork _unitOfWork;
     private readonly ILogger<UnsubscribeController> _logger;
 
-    public UnsubscribeController(ApplicationDbContext context, ILogger<UnsubscribeController> logger)
+    public UnsubscribeController(IUnitOfWork unitOfWork, ILogger<UnsubscribeController> logger)
     {
-        _context = context;
+        _unitOfWork = unitOfWork;
         _logger = logger;
     }
 
@@ -38,11 +37,10 @@ public class UnsubscribeController : Controller
 
         try
         {
-            // Bypass global query filters so we can find the customer by token
+            // ignoreQueryFilters=true so we can find the customer by token
             // regardless of company context (the user clicking is not authenticated)
-            var customer = await _context.Customers
+            var customer = await _unitOfWork.Customers.FirstOrDefaultAsync(
-                .IgnoreQueryFilters()
+                c => c.UnsubscribeToken == token && !c.IsDeleted, ignoreQueryFilters: true);
-                .FirstOrDefaultAsync(c => c.UnsubscribeToken == token && !c.IsDeleted);
 
             if (customer == null)
             {
@@ -52,7 +50,6 @@ public class UnsubscribeController : Controller
 
             if (!customer.NotifyByEmail)
             {
-                // Already unsubscribed — show success page anyway (idempotent)
                 ViewBag.CustomerName = customer.CompanyName ?? $"{customer.ContactFirstName} {customer.ContactLastName}".Trim();
                 ViewBag.AlreadyUnsubscribed = true;
                 return View("EmailConfirm");
@@ -60,7 +57,7 @@ public class UnsubscribeController : Controller
 
             customer.NotifyByEmail = false;
             customer.UpdatedAt = DateTime.UtcNow;
-            await _context.SaveChangesAsync();
+            await _unitOfWork.CompleteAsync();
 
             _logger.LogInformation("Customer {CustomerId} unsubscribed from email notifications via link", customer.Id);
 
@@ -88,9 +85,8 @@ public class UnsubscribeController : Controller
 
         try
         {
-            var company = await _context.Companies
+            var company = await _unitOfWork.Companies.FirstOrDefaultAsync(
-                .IgnoreQueryFilters()
+                c => c.MarketingUnsubscribeToken == token && !c.IsDeleted, ignoreQueryFilters: true);
-                .FirstOrDefaultAsync(c => c.MarketingUnsubscribeToken == token && !c.IsDeleted);
 
             if (company == null)
             {
@@ -105,7 +101,7 @@ public class UnsubscribeController : Controller
             {
                 company.MarketingEmailOptOut = true;
                 company.UpdatedAt = DateTime.UtcNow;
-                await _context.SaveChangesAsync();
+                await _unitOfWork.CompleteAsync();
                 _logger.LogInformation("Company {CompanyId} opted out of broadcast emails via link", company.Id);
             }
 

src/PowderCoating.Web/Controllers/UsageQuotaController.cs

@@ -15,6 +15,7 @@ namespace PowderCoating.Web.Controllers;
 /// efficient bulk-count GROUP BY queries in parallel rather than loading
 /// each company's data through separate repository calls.
 /// </summary>
+// Intentional exception: cross-tenant bulk GROUP BY quota queries that would require O(n) repository round-trips if routed through IUnitOfWork. See docs/DATA_ACCESS_ARCHITECTURE.md — Permanent Exceptions.
 [Authorize(Policy = AppConstants.Policies.SuperAdminOnly)]
 public class UsageQuotaController : Controller
 {

src/PowderCoating.Web/Controllers/UserActivityController.cs

@@ -8,6 +8,7 @@ using System.Text;
 
 namespace PowderCoating.Web.Controllers;
 
+// Intentional exception: queries ASP.NET Identity ApplicationUser across all tenants with Include(u => u.Company); Identity entities live outside IUnitOfWork. See docs/DATA_ACCESS_ARCHITECTURE.md — Permanent Exceptions.
 [Authorize(Policy = AppConstants.Policies.SuperAdminOnly)]
 public class UserActivityController : Controller
 {

src/PowderCoating.Web/Controllers/VendorsController.cs

@@ -10,7 +10,6 @@ using PowderCoating.Application.DTOs.Vendor;
 using PowderCoating.Core.Entities;
 using PowderCoating.Core.Enums;
 using PowderCoating.Core.Interfaces;
-using PowderCoating.Infrastructure.Data;
 
 namespace PowderCoating.Web.Controllers;
 
@@ -28,20 +27,17 @@ public class VendorsController : Controller
     private readonly IMapper _mapper;
     private readonly UserManager<ApplicationUser> _userManager;
     private readonly ILogger<VendorsController> _logger;
-    private readonly ApplicationDbContext _context;
 
     public VendorsController(
         IUnitOfWork unitOfWork,
         IMapper mapper,
         UserManager<ApplicationUser> userManager,
-        ILogger<VendorsController> logger,
+        ILogger<VendorsController> logger)
-        ApplicationDbContext context)
     {
         _unitOfWork = unitOfWork;
         _mapper = mapper;
         _userManager = userManager;
         _logger = logger;
-        _context = context;
     }
 
     /// <summary>
@@ -163,7 +159,7 @@ public class VendorsController : Controller
             var vendorDto = _mapper.Map<VendorDto>(vendor);
             if (vendor.DefaultExpenseAccountId.HasValue)
             {
-                var acct = await _context.Accounts.FindAsync(vendor.DefaultExpenseAccountId.Value);
+                var acct = await _unitOfWork.Accounts.GetByIdAsync(vendor.DefaultExpenseAccountId.Value);
                 vendorDto.DefaultExpenseAccountName = acct != null ? $"{acct.AccountNumber} – {acct.Name}" : null;
             }
             return View(vendorDto);
@@ -395,14 +391,13 @@ public class VendorsController : Controller
     /// </summary>
     private async Task PopulateExpenseAccountsAsync()
     {
-        var accounts = await _context.Accounts
+        var accounts = (await _unitOfWork.Accounts.FindAsync(
-            .Where(a => !a.IsDeleted && a.IsActive &&
+                a => a.IsActive && (a.AccountType == AccountType.Expense ||
-                        (a.AccountType == AccountType.Expense ||
+                                    a.AccountType == AccountType.CostOfGoods ||
-                         a.AccountType == AccountType.CostOfGoods ||
+                                    a.AccountType == AccountType.Asset)))
-                         a.AccountType == AccountType.Asset))
             .OrderBy(a => a.AccountNumber)
             .Select(a => new SelectListItem($"{a.AccountNumber} – {a.Name}", a.Id.ToString()))
-            .ToListAsync();
+            .ToList();
 
         accounts.Insert(0, new SelectListItem("— None —", ""));
         ViewBag.ExpenseAccounts = accounts;

src/PowderCoating.Web/Program.cs

@@ -6,6 +6,7 @@ using Microsoft.AspNetCore.Identity;
 using Microsoft.EntityFrameworkCore;
 using PowderCoating.Core.Entities;
 using PowderCoating.Core.Interfaces;
+using PowderCoating.Core.Interfaces.Services;
 using PowderCoating.Infrastructure.Data;
 using PowderCoating.Infrastructure.Repositories;
 using PowderCoating.Infrastructure.Services;
@@ -209,6 +210,11 @@ builder.Services.AddScoped<ICompanyLogoService, CompanyLogoService>();
 builder.Services.AddScoped<IEquipmentManualService, EquipmentManualService>();
 builder.Services.AddScoped<IPricingCalculationService, PricingCalculationService>();
 builder.Services.AddScoped<IPowderInsightsService, PowderInsightsService>();
+builder.Services.AddScoped<IAuditLogService, AuditLogService>();
+builder.Services.AddScoped<IAiUsageReportService, AiUsageReportService>();
+builder.Services.AddScoped<IDashboardReadService, DashboardReadService>();
+builder.Services.AddScoped<ICompanyListService, CompanyListService>();
+builder.Services.AddScoped<ICompanyDataPurgeService, CompanyDataPurgeService>();
 builder.Services.AddScoped<IPdfService, PdfService>();
 builder.Services.AddScoped<ISeedDataService, SeedDataService>();
 builder.Services.AddScoped<ICompanyConfigHealthService, CompanyConfigHealthService>();
@@ -835,6 +841,11 @@ using (var scope = app.Services.CreateScope())
 // Fail fast with a clear message rather than a cryptic runtime error later.
 ValidateRequiredConfiguration(app.Configuration, app.Environment);
 
+// ── Data access architecture enforcement ─────────────────────────────────────
+// Throws at startup if any non-exempt controller injects ApplicationDbContext directly.
+// This is the Phase 4 gate: the app cannot start with a violation.
+EnforceDataAccessArchitecture();
+
 try
 {
     Log.Information("Starting web application");
@@ -894,6 +905,61 @@ static void ValidateRequiredConfiguration(IConfiguration config, IWebHostEnviron
     }
 }
 
+// ── Data access architecture enforcement ─────────────────────────────────────────
+/// <summary>
+/// Scans every Controller subclass in the Web assembly at startup and throws if any
+/// non-exempt controller declares ApplicationDbContext as a constructor parameter.
+/// This enforces the rule defined in docs/DATA_ACCESS_ARCHITECTURE.md — if a developer
+/// adds a new controller that injects ApplicationDbContext directly, the app will refuse
+/// to start with a clear message naming the violator.
+/// </summary>
+static void EnforceDataAccessArchitecture()
+{
+    // Controllers in this set are documented permanent exceptions — see DATA_ACCESS_ARCHITECTURE.md.
+    var permanentExceptions = new HashSet<string>
+    {
+        "StripeWebhookController",
+        "WebhooksController",
+        "PaymentController",
+        "RegistrationController",
+        "DataExportController",
+        "AccountDataExportController",
+        "DataPurgeController",
+        "SystemInfoController",
+        "SystemLogsController",
+        "CompanyHealthController",
+        "PasskeyController",
+        "AuditLogController",
+        "UserActivityController",
+        "EmailBroadcastController",
+        "RevenueController",
+        "StripeEventsController",
+        "SubscriptionManagementController",
+        "UsageQuotaController",
+    };
+
+    var violators = typeof(Program).Assembly.GetTypes()
+        .Where(t => t.IsClass && !t.IsAbstract
+                    && typeof(Microsoft.AspNetCore.Mvc.Controller).IsAssignableFrom(t)
+                    && !permanentExceptions.Contains(t.Name))
+        .Where(t => t.GetConstructors()
+                     .Any(ctor => ctor.GetParameters()
+                                      .Any(p => p.ParameterType == typeof(ApplicationDbContext))))
+        .Select(t => t.Name)
+        .OrderBy(n => n)
+        .ToList();
+
+    if (violators.Count == 0) return;
+
+    var names = string.Join(", ", violators);
+    throw new InvalidOperationException(
+        $"DATA ACCESS VIOLATION — {violators.Count} controller(s) inject ApplicationDbContext directly " +
+        $"and are not in the permanent exceptions list.\n" +
+        $"Violators: {names}\n" +
+        $"Fix: route data access through IUnitOfWork. " +
+        $"To add a permanent exception, update both the controller comment and docs/DATA_ACCESS_ARCHITECTURE.md.");
+}
+
 // ── Serilog DB sink column configuration ─────────────────────────────────────────
 static ColumnOptions BuildLogColumnOptions()
 {

tests/PowderCoating.UnitTests/DepositsControllerTests.cs

@@ -290,8 +290,7 @@ public class DepositsControllerTests
         var controller = new DepositsController(
             uow,
             userManager.Object,
-            Mock.Of<ILogger<DepositsController>>(),
+            Mock.Of<ILogger<DepositsController>>());
-            context);
 
         controller.ControllerContext = new ControllerContext
         {