Kalana B. Thilakarathna
677 lines
25 KiB
C#
677 lines
25 KiB
C#
using Distribution.Models;
|
|
using Microsoft.EntityFrameworkCore;
|
|
|
|
namespace Distribution.Data;
|
|
|
|
public class AppDBContext(DbContextOptions<AppDBContext> options) : DbContext(options)
|
|
{
|
|
public DbSet<Region> Regions { get; set; }
|
|
public DbSet<Models.Route> Routes { get; set; }
|
|
public DbSet<Vehicle> Vehicles { get; set; }
|
|
public DbSet<Store> Stores { get; set; }
|
|
public DbSet<Warehouse> Warehouses { get; set; }
|
|
public DbSet<Category> Categories { get; set; }
|
|
public DbSet<SubCategory> SubCategories { get; set; }
|
|
public DbSet<Brand> Brands { get; set; }
|
|
public DbSet<Uom> Uoms { get; set; }
|
|
public DbSet<UomConversion> UomConversions { get; set; }
|
|
public DbSet<Item> Items { get; set; }
|
|
public DbSet<ItemBatch> ItemBatches { get; set; }
|
|
public DbSet<ItemSerialNumber> ItemSerialNumbers { get; set; }
|
|
public DbSet<SaleRoute> SaleRoutes { get; set; }
|
|
public DbSet<ShopPO> ShopPOs { get; set; }
|
|
public DbSet<ShopPOItem> ShopPOItems { get; set; }
|
|
public DbSet<Invoice> Invoices { get; set; }
|
|
public DbSet<LoadingSheetOrder> LoadingSheetOrders { get; set; }
|
|
public DbSet<DeliveryRun> DeliveryRuns { get; set; }
|
|
public DbSet<User> Users { get; set; }
|
|
public DbSet<Role> Roles { get; set; }
|
|
public DbSet<Permission> Permissions { get; set; }
|
|
public DbSet<RolePermission> RolePermissions { get; set; }
|
|
public DbSet<UserRegionScope> UserRegionScopes { get; set; }
|
|
public DbSet<UserRouteScope> UserRouteScopes { get; set; }
|
|
public DbSet<UserStoreScope> UserStoreScopes { get; set; }
|
|
public DbSet<StockBalance> StockBalances { get; set; }
|
|
public DbSet<StockMovement> StockMovements { get; set; }
|
|
public DbSet<PriceList> PriceLists { get; set; }
|
|
public DbSet<PriceListItem> PriceListItems { get; set; }
|
|
public DbSet<Supplier> Suppliers { get; set; }
|
|
public DbSet<DriverProfile> DriverProfiles { get; set; }
|
|
public DbSet<DriverComplianceConfig> DriverComplianceConfigs { get; set; }
|
|
public DbSet<Scheme> Schemes { get; set; }
|
|
public DbSet<SchemeRedemption> SchemeRedemptions { get; set; }
|
|
public DbSet<SchemeBundleComponent> SchemeBundleComponents { get; set; }
|
|
public DbSet<LoadingSheet> LoadingSheets { get; set; }
|
|
public DbSet<LoadingSheetItem> LoadingSheetItems { get; set; }
|
|
public DbSet<Payment> Payments { get; set; }
|
|
public DbSet<DeliveryTask> DeliveryTasks { get; set; }
|
|
public DbSet<PurchaseOrder> PurchaseOrders { get; set; }
|
|
public DbSet<PurchaseOrderItem> PurchaseOrderItems { get; set; }
|
|
public DbSet<GoodsReceipt> GoodsReceipts { get; set; }
|
|
public DbSet<GoodsReceiptItem> GoodsReceiptItems { get; set; }
|
|
public DbSet<GoodsReceiptItemBatch> GoodsReceiptItemBatches { get; set; }
|
|
public DbSet<GoodsReceiptItemSerial> GoodsReceiptItemSerials { get; set; }
|
|
public DbSet<PurchaseReturn> PurchaseReturns { get; set; }
|
|
public DbSet<PurchaseReturnItem> PurchaseReturnItems { get; set; }
|
|
public DbSet<SaleReturn> SaleReturns { get; set; }
|
|
public DbSet<SaleReturnItem> SaleReturnItems { get; set; }
|
|
public DbSet<CreditNote> CreditNotes { get; set; }
|
|
public DbSet<Claim> Claims { get; set; }
|
|
public DbSet<SupplierClaim> SupplierClaims { get; set; }
|
|
public DbSet<SupplierClaimItem> SupplierClaimItems { get; set; }
|
|
public DbSet<RegionalTarget> RegionalTargets { get; set; }
|
|
public DbSet<RegionalBudget> RegionalBudgets { get; set; }
|
|
public DbSet<RegionAgencyMap> RegionAgencyMaps { get; set; }
|
|
public DbSet<RegionalTaxRule> RegionalTaxRules { get; set; }
|
|
public DbSet<RouteVisitLog> RouteVisitLogs { get; set; }
|
|
public DbSet<SysConfig> SysConfigs { get; set; }
|
|
public DbSet<BankAccount> BankAccounts { get; set; }
|
|
public DbSet<ChequeBook> ChequeBooks { get; set; }
|
|
public DbSet<ChequePage> ChequePages { get; set; }
|
|
public DbSet<ReceivedCheque> ReceivedCheques { get; set; }
|
|
|
|
protected override void OnModelCreating(ModelBuilder modelBuilder)
|
|
{
|
|
// --- Composite PKs ---
|
|
|
|
modelBuilder.Entity<RolePermission>()
|
|
.HasKey(rp => new { rp.FK_RoleId, rp.FK_PermissionId });
|
|
|
|
modelBuilder.Entity<UserRegionScope>()
|
|
.HasKey(s => new { s.FK_UserId, s.FK_RegionId });
|
|
|
|
modelBuilder.Entity<UserRouteScope>()
|
|
.HasKey(s => new { s.FK_UserId, s.FK_RouteId });
|
|
|
|
modelBuilder.Entity<UserStoreScope>()
|
|
.HasKey(s => new { s.FK_UserId, s.FK_StoreId });
|
|
|
|
modelBuilder.Entity<LoadingSheetOrder>()
|
|
.HasKey(lo => new { lo.FK_LoadingSheetId, lo.FK_ShopPOId });
|
|
|
|
// --- Unique indexes ---
|
|
|
|
// NOTE: MySQL treats each NULL as distinct in a unique index, so this does not by itself
|
|
// prevent duplicate rows for untracked items (both FK columns null) — StockRepository's
|
|
// get-then-update pattern is what keeps those to one row per (Item, Location), same as before.
|
|
modelBuilder.Entity<StockBalance>()
|
|
.HasIndex(sb => new { sb.FK_ItemId, sb.LocationId, sb.FK_ItemBatchId, sb.FK_ItemSerialNumberId })
|
|
.IsUnique();
|
|
|
|
modelBuilder.Entity<ItemSerialNumber>()
|
|
.HasIndex(s => new { s.FK_ItemId, s.SerialNumber })
|
|
.IsUnique();
|
|
|
|
modelBuilder.Entity<PriceListItem>()
|
|
.HasIndex(pli => new { pli.FK_PriceListId, pli.FK_ItemId })
|
|
.IsUnique();
|
|
|
|
modelBuilder.Entity<DriverProfile>()
|
|
.HasIndex(dp => dp.FK_UserId)
|
|
.IsUnique();
|
|
|
|
// --- User ---
|
|
|
|
modelBuilder.Entity<User>()
|
|
.HasOne(u => u.ReportsTo)
|
|
.WithMany()
|
|
.HasForeignKey(u => u.FK_ReportsToUserId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
// --- Vehicle ---
|
|
|
|
modelBuilder.Entity<Vehicle>()
|
|
.HasOne<Warehouse>()
|
|
.WithMany()
|
|
.HasForeignKey(nameof(Vehicle.DefaultWarehouseId))
|
|
.OnDelete(DeleteBehavior.Restrict)
|
|
.IsRequired(false);
|
|
|
|
// --- DeliveryRun ---
|
|
|
|
modelBuilder.Entity<DeliveryRun>()
|
|
.HasOne(r => r.DriverProfile)
|
|
.WithMany()
|
|
.HasForeignKey(r => r.FK_DriverProfileId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
// --- ShopPO ---
|
|
|
|
modelBuilder.Entity<ShopPO>()
|
|
.HasOne(p => p.Store)
|
|
.WithMany()
|
|
.HasForeignKey(p => p.FK_StoreId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
// InvoiceId is a plain column — no FK constraint
|
|
modelBuilder.Entity<ShopPO>()
|
|
.Property(p => p.InvoiceId)
|
|
.HasColumnName("InvoiceId");
|
|
|
|
// --- ShopPOItem ---
|
|
|
|
modelBuilder.Entity<ShopPOItem>()
|
|
.HasOne(i => i.ShopPO)
|
|
.WithMany(p => p.Items)
|
|
.HasForeignKey(i => i.FK_ShopPOId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<ShopPOItem>()
|
|
.HasOne(i => i.Item)
|
|
.WithMany()
|
|
.HasForeignKey(i => i.FK_ItemId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
// --- Invoice ---
|
|
|
|
modelBuilder.Entity<Invoice>()
|
|
.HasOne(i => i.ShopPO)
|
|
.WithMany()
|
|
.HasForeignKey(i => i.FK_ShopPOId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<Invoice>()
|
|
.HasMany(i => i.Payments)
|
|
.WithOne(p => p.Invoice)
|
|
.HasForeignKey(p => p.FK_InvoiceId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
// --- LoadingSheet ---
|
|
|
|
modelBuilder.Entity<LoadingSheet>()
|
|
.HasOne(s => s.Ride)
|
|
.WithMany()
|
|
.HasForeignKey(s => s.FK_RideId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
// --- LoadingSheetOrder ---
|
|
|
|
modelBuilder.Entity<LoadingSheetOrder>()
|
|
.HasOne(lo => lo.LoadingSheet)
|
|
.WithMany(s => s.Orders)
|
|
.HasForeignKey(lo => lo.FK_LoadingSheetId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<LoadingSheetOrder>()
|
|
.HasOne(lo => lo.ShopPO)
|
|
.WithMany()
|
|
.HasForeignKey(lo => lo.FK_ShopPOId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
// --- LoadingSheetItem ---
|
|
|
|
modelBuilder.Entity<LoadingSheetItem>()
|
|
.HasOne(i => i.LoadingSheet)
|
|
.WithMany(s => s.Items)
|
|
.HasForeignKey(i => i.FK_LoadingSheetId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<LoadingSheetItem>()
|
|
.HasOne(i => i.Item)
|
|
.WithMany()
|
|
.HasForeignKey(i => i.FK_ItemId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<LoadingSheetItem>()
|
|
.HasOne(i => i.Warehouse)
|
|
.WithMany()
|
|
.HasForeignKey(i => i.FK_WarehouseId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<LoadingSheetItem>()
|
|
.HasOne(i => i.ShopPOItem)
|
|
.WithMany()
|
|
.HasForeignKey(i => i.FK_ShopPOItemId)
|
|
.OnDelete(DeleteBehavior.SetNull)
|
|
.IsRequired(false);
|
|
|
|
// --- SchemeRedemption ---
|
|
|
|
modelBuilder.Entity<SchemeRedemption>()
|
|
.HasOne(r => r.Scheme)
|
|
.WithMany(s => s.Redemptions)
|
|
.HasForeignKey(r => r.FK_SchemeId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<SchemeRedemption>()
|
|
.HasOne(r => r.ShopPO)
|
|
.WithMany()
|
|
.HasForeignKey(r => r.FK_ShopPOId)
|
|
.OnDelete(DeleteBehavior.Restrict)
|
|
.IsRequired(false);
|
|
|
|
modelBuilder.Entity<SchemeRedemption>()
|
|
.HasOne(r => r.FreeItem)
|
|
.WithMany()
|
|
.HasForeignKey(r => r.FK_FreeItemId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
// --- Scheme ---
|
|
|
|
modelBuilder.Entity<Scheme>()
|
|
.HasOne(s => s.TriggerItem)
|
|
.WithMany()
|
|
.HasForeignKey(s => s.FK_TriggerItemId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<Scheme>()
|
|
.HasOne(s => s.FreeItem)
|
|
.WithMany()
|
|
.HasForeignKey(s => s.FK_FreeItemId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<SchemeBundleComponent>()
|
|
.HasOne(c => c.Scheme)
|
|
.WithMany(s => s.BundleComponents)
|
|
.HasForeignKey(c => c.FK_SchemeId)
|
|
.OnDelete(DeleteBehavior.Cascade);
|
|
|
|
modelBuilder.Entity<SchemeBundleComponent>()
|
|
.HasOne(c => c.Item)
|
|
.WithMany()
|
|
.HasForeignKey(c => c.FK_ItemId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<SchemeBundleComponent>()
|
|
.HasIndex(c => new { c.FK_SchemeId, c.FK_ItemId })
|
|
.IsUnique();
|
|
|
|
// --- PurchaseOrder ---
|
|
|
|
modelBuilder.Entity<PurchaseOrder>()
|
|
.HasOne(po => po.Supplier)
|
|
.WithMany()
|
|
.HasForeignKey(po => po.FK_SupplierId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<PurchaseOrderItem>()
|
|
.HasOne(i => i.PurchaseOrder)
|
|
.WithMany(po => po.Items)
|
|
.HasForeignKey(i => i.FK_PurchaseOrderId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<PurchaseOrderItem>()
|
|
.HasOne(i => i.Item)
|
|
.WithMany()
|
|
.HasForeignKey(i => i.FK_ItemId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<PurchaseOrderItem>()
|
|
.HasIndex(i => i.FK_PurchaseOrderId);
|
|
|
|
// --- GoodsReceipt ---
|
|
|
|
modelBuilder.Entity<GoodsReceipt>()
|
|
.HasOne(gr => gr.PurchaseOrder)
|
|
.WithMany()
|
|
.HasForeignKey(gr => gr.FK_PurchaseOrderId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<GoodsReceipt>()
|
|
.HasOne(gr => gr.Supplier)
|
|
.WithMany()
|
|
.HasForeignKey(gr => gr.FK_SupplierId)
|
|
.OnDelete(DeleteBehavior.Restrict)
|
|
.IsRequired(false);
|
|
|
|
modelBuilder.Entity<GoodsReceipt>()
|
|
.HasOne(gr => gr.Warehouse)
|
|
.WithMany()
|
|
.HasForeignKey(gr => gr.FK_WarehouseId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<GoodsReceiptItem>()
|
|
.HasOne(i => i.GoodsReceipt)
|
|
.WithMany(gr => gr.Items)
|
|
.HasForeignKey(i => i.FK_GoodsReceiptId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<GoodsReceiptItem>()
|
|
.HasOne(i => i.PurchaseOrderItem)
|
|
.WithMany()
|
|
.HasForeignKey(i => i.FK_PurchaseOrderItemId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<GoodsReceiptItem>()
|
|
.HasOne(i => i.Item)
|
|
.WithMany()
|
|
.HasForeignKey(i => i.FK_ItemId)
|
|
.OnDelete(DeleteBehavior.Restrict)
|
|
.IsRequired(false);
|
|
|
|
modelBuilder.Entity<GoodsReceiptItem>()
|
|
.HasIndex(i => i.FK_GoodsReceiptId);
|
|
|
|
modelBuilder.Entity<GoodsReceiptItem>()
|
|
.HasIndex(i => i.FK_PurchaseOrderItemId);
|
|
|
|
// --- ItemBatch / ItemSerialNumber ---
|
|
|
|
modelBuilder.Entity<ItemBatch>()
|
|
.HasOne(b => b.Item)
|
|
.WithMany()
|
|
.HasForeignKey(b => b.FK_ItemId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<ItemBatch>()
|
|
.HasIndex(b => new { b.FK_ItemId, b.BatchNumber });
|
|
|
|
modelBuilder.Entity<ItemSerialNumber>()
|
|
.HasOne(s => s.Item)
|
|
.WithMany()
|
|
.HasForeignKey(s => s.FK_ItemId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
// --- StockBalance / StockMovement batch & serial links ---
|
|
|
|
modelBuilder.Entity<StockBalance>()
|
|
.HasOne(sb => sb.ItemBatch)
|
|
.WithMany()
|
|
.HasForeignKey(sb => sb.FK_ItemBatchId)
|
|
.OnDelete(DeleteBehavior.Restrict)
|
|
.IsRequired(false);
|
|
|
|
modelBuilder.Entity<StockBalance>()
|
|
.HasOne(sb => sb.ItemSerialNumber)
|
|
.WithMany()
|
|
.HasForeignKey(sb => sb.FK_ItemSerialNumberId)
|
|
.OnDelete(DeleteBehavior.Restrict)
|
|
.IsRequired(false);
|
|
|
|
modelBuilder.Entity<StockMovement>()
|
|
.HasOne(sm => sm.ItemBatch)
|
|
.WithMany()
|
|
.HasForeignKey(sm => sm.FK_ItemBatchId)
|
|
.OnDelete(DeleteBehavior.Restrict)
|
|
.IsRequired(false);
|
|
|
|
modelBuilder.Entity<StockMovement>()
|
|
.HasOne(sm => sm.ItemSerialNumber)
|
|
.WithMany()
|
|
.HasForeignKey(sm => sm.FK_ItemSerialNumberId)
|
|
.OnDelete(DeleteBehavior.Restrict)
|
|
.IsRequired(false);
|
|
|
|
// --- GoodsReceiptItemBatch / GoodsReceiptItemSerial ---
|
|
|
|
modelBuilder.Entity<GoodsReceiptItemBatch>()
|
|
.HasOne(b => b.GoodsReceiptItem)
|
|
.WithMany(i => i.Batches)
|
|
.HasForeignKey(b => b.FK_GoodsReceiptItemId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<GoodsReceiptItemBatch>()
|
|
.HasOne(b => b.ItemBatch)
|
|
.WithMany()
|
|
.HasForeignKey(b => b.FK_ItemBatchId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<GoodsReceiptItemSerial>()
|
|
.HasOne(s => s.GoodsReceiptItem)
|
|
.WithMany(i => i.Serials)
|
|
.HasForeignKey(s => s.FK_GoodsReceiptItemId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<GoodsReceiptItemSerial>()
|
|
.HasOne(s => s.ItemSerialNumber)
|
|
.WithMany()
|
|
.HasForeignKey(s => s.FK_ItemSerialNumberId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
// --- PurchaseReturn ---
|
|
|
|
modelBuilder.Entity<PurchaseReturn>()
|
|
.HasOne(pr => pr.PurchaseOrder)
|
|
.WithMany()
|
|
.HasForeignKey(pr => pr.FK_PurchaseOrderId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<PurchaseReturnItem>()
|
|
.HasOne(i => i.PurchaseReturn)
|
|
.WithMany(pr => pr.Items)
|
|
.HasForeignKey(i => i.FK_PurchaseReturnId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<PurchaseReturnItem>()
|
|
.HasOne(i => i.Item)
|
|
.WithMany()
|
|
.HasForeignKey(i => i.FK_ItemId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<PurchaseReturnItem>()
|
|
.HasIndex(i => i.FK_PurchaseReturnId);
|
|
|
|
// --- SaleReturn ---
|
|
|
|
modelBuilder.Entity<SaleReturn>()
|
|
.HasOne(r => r.ShopPO)
|
|
.WithMany()
|
|
.HasForeignKey(r => r.FK_ShopPOId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<SaleReturn>()
|
|
.HasOne(r => r.CreatedByUser)
|
|
.WithMany()
|
|
.HasForeignKey(r => r.CreatedByUserId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<SaleReturnItem>()
|
|
.HasOne(i => i.SaleReturn)
|
|
.WithMany(r => r.Items)
|
|
.HasForeignKey(i => i.FK_SaleReturnId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<SaleReturnItem>()
|
|
.HasOne(i => i.Item)
|
|
.WithMany()
|
|
.HasForeignKey(i => i.FK_ItemId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<SaleReturnItem>()
|
|
.HasIndex(i => i.FK_SaleReturnId);
|
|
|
|
// --- CreditNote ---
|
|
|
|
modelBuilder.Entity<CreditNote>()
|
|
.HasOne(n => n.SaleReturn)
|
|
.WithMany()
|
|
.HasForeignKey(n => n.FK_SaleReturnId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
// --- Claims ---
|
|
|
|
modelBuilder.Entity<Claim>()
|
|
.HasOne(c => c.AgencyUser)
|
|
.WithMany()
|
|
.HasForeignKey(c => c.FK_AgencyUserId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<Claim>()
|
|
.HasOne(c => c.SettledByUser)
|
|
.WithMany()
|
|
.HasForeignKey(c => c.SettledByUserId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<SupplierClaim>()
|
|
.HasOne(c => c.PurchaseOrder)
|
|
.WithMany()
|
|
.HasForeignKey(c => c.FK_PurchaseOrderId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<SupplierClaim>()
|
|
.HasOne(c => c.GoodsReceipt)
|
|
.WithMany()
|
|
.HasForeignKey(c => c.FK_GoodsReceiptId)
|
|
.OnDelete(DeleteBehavior.Restrict)
|
|
.IsRequired(false);
|
|
|
|
modelBuilder.Entity<SupplierClaim>()
|
|
.HasOne(c => c.RaisedByUser)
|
|
.WithMany()
|
|
.HasForeignKey(c => c.RaisedByUserId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<SupplierClaim>()
|
|
.HasOne(c => c.ResolvedByUser)
|
|
.WithMany()
|
|
.HasForeignKey(c => c.ResolvedByUserId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<SupplierClaimItem>()
|
|
.HasOne(i => i.SupplierClaim)
|
|
.WithMany(c => c.Items)
|
|
.HasForeignKey(i => i.FK_SupplierClaimId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<SupplierClaimItem>()
|
|
.HasOne(i => i.Item)
|
|
.WithMany()
|
|
.HasForeignKey(i => i.FK_ItemId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<SupplierClaimItem>()
|
|
.HasIndex(i => i.FK_SupplierClaimId);
|
|
|
|
// --- DeliveryTask ---
|
|
|
|
modelBuilder.Entity<DeliveryTask>()
|
|
.HasOne(t => t.Ride)
|
|
.WithMany()
|
|
.HasForeignKey(t => t.FK_RideId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<DeliveryTask>()
|
|
.HasOne(t => t.ShopPO)
|
|
.WithMany()
|
|
.HasForeignKey(t => t.FK_ShopPOId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
// --- Regional ---
|
|
|
|
modelBuilder.Entity<Region>()
|
|
.Property(r => r.Code)
|
|
.HasMaxLength(50);
|
|
|
|
modelBuilder.Entity<Region>()
|
|
.HasIndex(r => r.Code)
|
|
.IsUnique();
|
|
|
|
|
|
modelBuilder.Entity<RegionalTarget>()
|
|
.HasIndex(t => new { t.FK_RegionId, t.Period })
|
|
.IsUnique();
|
|
|
|
modelBuilder.Entity<RegionalBudget>()
|
|
.HasIndex(b => new { b.FK_RegionId, b.Period })
|
|
.IsUnique();
|
|
|
|
modelBuilder.Entity<RegionAgencyMap>()
|
|
.HasIndex(m => new { m.FK_RegionId, m.FK_AgencyUserId })
|
|
.IsUnique();
|
|
|
|
modelBuilder.Entity<RegionAgencyMap>()
|
|
.HasOne(m => m.AgencyUser)
|
|
.WithMany()
|
|
.HasForeignKey(m => m.FK_AgencyUserId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<RegionalTaxRule>()
|
|
.HasIndex(r => r.FK_RegionId)
|
|
.IsUnique();
|
|
|
|
// --- SysConfig ---
|
|
|
|
modelBuilder.Entity<SysConfig>()
|
|
.HasKey(c => c.Key);
|
|
|
|
modelBuilder.Entity<SysConfig>()
|
|
.Property(c => c.Key)
|
|
.HasMaxLength(100);
|
|
|
|
modelBuilder.Entity<SysConfig>().HasData(
|
|
new SysConfig { Key = "InvoiceCreationMode", Value = "ModeB", UpdatedAt = new DateTime(2026, 9, 17), UpdatedBy = null },
|
|
new SysConfig { Key = Distribution.Features.SysConfig.SysConfigService.KeySerialNumberTrackingEnabled, Value = "false", UpdatedAt = new DateTime(2026, 10, 1), UpdatedBy = null },
|
|
new SysConfig { Key = Distribution.Features.SysConfig.SysConfigService.KeyBatchTrackingEnabled, Value = "false", UpdatedAt = new DateTime(2026, 10, 1), UpdatedBy = null },
|
|
new SysConfig { Key = Distribution.Features.SysConfig.SysConfigService.KeyExpiryDateTrackingEnabled, Value = "false", UpdatedAt = new DateTime(2026, 10, 1), UpdatedBy = null },
|
|
new SysConfig { Key = Distribution.Features.SysConfig.SysConfigService.KeyWarrantyTrackingEnabled, Value = "false", UpdatedAt = new DateTime(2026, 10, 1), UpdatedBy = null },
|
|
new SysConfig { Key = Distribution.Features.SysConfig.SysConfigService.KeyCustomWarrantyOverrideEnabled, Value = "false", UpdatedAt = new DateTime(2026, 10, 1), UpdatedBy = null },
|
|
new SysConfig { Key = Distribution.Features.SysConfig.SysConfigService.KeyDefaultWarrantyPeriodDays, Value = "0", UpdatedAt = new DateTime(2026, 10, 1), UpdatedBy = null }
|
|
);
|
|
|
|
// --- Payment service: Bank Accounts & Cheques ---
|
|
|
|
modelBuilder.Entity<BankAccount>()
|
|
.Property(a => a.AccountName).HasMaxLength(200);
|
|
modelBuilder.Entity<BankAccount>()
|
|
.Property(a => a.BankName).HasMaxLength(200);
|
|
modelBuilder.Entity<BankAccount>()
|
|
.Property(a => a.CashAccountTypeName).HasMaxLength(100);
|
|
modelBuilder.Entity<BankAccount>()
|
|
.Property(a => a.AccountNumber).HasMaxLength(100);
|
|
modelBuilder.Entity<BankAccount>()
|
|
.Property(a => a.CurrencyCode).HasMaxLength(10);
|
|
modelBuilder.Entity<BankAccount>()
|
|
.HasIndex(a => new { a.AccountType, a.AccountName })
|
|
.IsUnique();
|
|
|
|
modelBuilder.Entity<BankAccount>().HasData(new BankAccount
|
|
{
|
|
Id = new Guid("11111111-1111-1111-1111-000000000001"),
|
|
CreatedAt = new DateTime(2026, 10, 19),
|
|
IsActive = true,
|
|
AccountType = BankAccountType.Cash,
|
|
AccountName = "Petty Cash",
|
|
CashAccountTypeName = "Petty Cash",
|
|
CurrencyCode = "LKR",
|
|
IsDefault = true
|
|
});
|
|
|
|
modelBuilder.Entity<ChequeBook>()
|
|
.Property(b => b.ChequeBookNo).HasMaxLength(100);
|
|
modelBuilder.Entity<ChequeBook>()
|
|
.Property(b => b.StartChequeNo).HasMaxLength(50);
|
|
modelBuilder.Entity<ChequeBook>()
|
|
.Property(b => b.EndChequeNo).HasMaxLength(50);
|
|
modelBuilder.Entity<ChequeBook>()
|
|
.HasIndex(b => b.ChequeBookNo).IsUnique();
|
|
modelBuilder.Entity<ChequeBook>()
|
|
.HasOne(b => b.BankAccount)
|
|
.WithMany()
|
|
.HasForeignKey(b => b.FK_BankAccountId)
|
|
.OnDelete(DeleteBehavior.Restrict);
|
|
|
|
modelBuilder.Entity<ChequePage>()
|
|
.Property(p => p.ChequeNo).HasMaxLength(50);
|
|
modelBuilder.Entity<ChequePage>()
|
|
.Property(p => p.CurrencyCode).HasMaxLength(10);
|
|
modelBuilder.Entity<ChequePage>()
|
|
.HasIndex(p => p.ChequeNo).IsUnique();
|
|
modelBuilder.Entity<ChequePage>()
|
|
.HasOne(p => p.ChequeBook)
|
|
.WithMany(b => b.Pages)
|
|
.HasForeignKey(p => p.FK_ChequeBookId)
|
|
.OnDelete(DeleteBehavior.Cascade);
|
|
|
|
modelBuilder.Entity<ReceivedCheque>()
|
|
.Property(c => c.ChequeNo).HasMaxLength(50);
|
|
modelBuilder.Entity<ReceivedCheque>()
|
|
.Property(c => c.ReceivedFromName).HasMaxLength(200);
|
|
modelBuilder.Entity<ReceivedCheque>()
|
|
.HasIndex(c => c.ChequeNo);
|
|
modelBuilder.Entity<ReceivedCheque>()
|
|
.HasOne(c => c.DepositBankAccount)
|
|
.WithMany()
|
|
.HasForeignKey(c => c.FK_DepositBankAccountId)
|
|
.OnDelete(DeleteBehavior.Restrict)
|
|
.IsRequired(false);
|
|
|
|
Seed.RoleAndPermissionSeed.Apply(modelBuilder);
|
|
Seed.MasterDataSeed.Apply(modelBuilder);
|
|
Seed.OperationsDataSeed.Apply(modelBuilder);
|
|
Seed.ProcurementSeed.Apply(modelBuilder);
|
|
Seed.CommerceSeed.Apply(modelBuilder);
|
|
Seed.OperationsExtrasSeed.Apply(modelBuilder);
|
|
Seed.AdminSeed.Apply(modelBuilder);
|
|
}
|
|
}
|