Pulling Ef/db stuff out of accessor project

src/API/WesternStatesWater.WestDaat.Accessors/Assembly.cs

@@ -2,6 +2,7 @@
 global using System.Collections.Generic;
 global using System.Linq;
 global using System.Threading.Tasks;
+global using EF = WesternStatesWater.WestDaat.Database.EntityFramework;
 using System.Resources;
 
 [assembly: System.Runtime.CompilerServices.InternalsVisibleTo("WesternStatesWater.WestDaat.Tests.AccessorTests")]

src/API/WesternStatesWater.WestDaat.Accessors/Extensions/EntityExtensions.cs

@@ -1,11 +1,10 @@
 using Microsoft.EntityFrameworkCore;
-using WesternStatesWater.WestDaat.Accessors.EntityFramework;
 
 namespace WesternStatesWater.WestDaat.Accessors.Extensions;
 
 public static class EntityExtensions
 {
-    public static Task<string[]> GetControlledVocabularyNames<TCv>(this DbSet<TCv> table) where TCv : ControlledVocabularyBase
+    public static Task<string[]> GetControlledVocabularyNames<TCv>(this DbSet<TCv> table) where TCv : EF.ControlledVocabularyBase
     {
         return table
             .AsNoTracking()

src/API/WesternStatesWater.WestDaat.Accessors/Mapping/ApiProfile.cs

@@ -1,8 +1,6 @@
 using AutoMapper;
 using System.Runtime.CompilerServices;
-using WesternStatesWater.WestDaat.Accessors.EntityFramework;
 using WesternStatesWater.WestDaat.Common.DataContracts;
-using EF = WesternStatesWater.WestDaat.Accessors.EntityFramework;
 
 [assembly: InternalsVisibleTo("WesternStatesWater.WestDaat.Tests.AccessorTests")]
 
@@ -136,7 +134,7 @@ public ApiProfile()
                 .ForMember(dest => dest.WaDEDataMappingProcessUrl, opt => opt.MapFrom(source => source.WaDEDataMappingUrl))
                 .ForMember(dest => dest.MethodDescription, opt => opt.MapFrom(source => source.MethodDescription));
 
-            CreateMap<RegulatoryOverlayDim, OverlayTableEntry>()
+            CreateMap<EF.RegulatoryOverlayDim, OverlayTableEntry>()
                 .ForMember(dest => dest.WaDEOverlayUuid, opt => opt.MapFrom(source => source.RegulatoryOverlayUuid))
                 .ForMember(dest => dest.OverlayNativeID, opt => opt.MapFrom(source => source.RegulatoryOverlayNativeId))
                 .ForMember(dest => dest.OverlayName, opt => opt.MapFrom(source => source.RegulatoryName))

src/API/WesternStatesWater.WestDaat.Accessors/Mapping/CsvProfile.cs

@@ -1,7 +1,6 @@
 using AutoMapper;
 using System.Runtime.CompilerServices;
 using WesternStatesWater.WestDaat.Accessors.CsvModels;
-using EF = WesternStatesWater.WestDaat.Accessors.EntityFramework;
 
 [assembly: InternalsVisibleTo("WesternStatesWater.WestDaat.Tests.AccessorTests")]
 

src/API/WesternStatesWater.WestDaat.Accessors/SiteAccessor.cs

@@ -1,20 +1,19 @@
 using AutoMapper.QueryableExtensions;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
-using WesternStatesWater.WestDaat.Accessors.EntityFramework;
 using WesternStatesWater.WestDaat.Accessors.Mapping;
 using WesternStatesWater.WestDaat.Common.DataContracts;
 
 namespace WesternStatesWater.WestDaat.Accessors
 {
     internal class SiteAccessor : AccessorBase, ISiteAccessor
     {
-        public SiteAccessor(ILogger<SiteAccessor> logger, IDatabaseContextFactory databaseContextFactory) : base(logger)
+        public SiteAccessor(ILogger<SiteAccessor> logger, EF.IDatabaseContextFactory databaseContextFactory) : base(logger)
         {
             _databaseContextFactory = databaseContextFactory;
         }
 
-        private readonly IDatabaseContextFactory _databaseContextFactory;
+        private readonly EF.IDatabaseContextFactory _databaseContextFactory;
 
         async Task<Site> ISiteAccessor.GetSiteByUuid(string siteUuid)
         {

src/API/WesternStatesWater.WestDaat.Accessors/SystemAccessor.cs

@@ -1,19 +1,19 @@
 using AutoMapper.QueryableExtensions;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
-using WesternStatesWater.WestDaat.Accessors.EntityFramework;
 using WesternStatesWater.WestDaat.Accessors.Extensions;
 using WesternStatesWater.WestDaat.Accessors.Mapping;
 using WesternStatesWater.WestDaat.Common.Constants;
 using WesternStatesWater.WestDaat.Common.DataContracts;
+using WesternStatesWater.WestDaat.Database.EntityFramework.partials;
 
 namespace WesternStatesWater.WestDaat.Accessors
 {
     internal class SystemAccessor : AccessorBase, ISystemAccessor
     {
-        private readonly IDatabaseContextFactory _databaseContextFactory;
+        private readonly EF.IDatabaseContextFactory _databaseContextFactory;
 
-        public SystemAccessor(ILogger<SystemAccessor> logger, IDatabaseContextFactory databaseContextFactory)
+        public SystemAccessor(ILogger<SystemAccessor> logger, EF.IDatabaseContextFactory databaseContextFactory)
             : base(logger)
         {
             _databaseContextFactory = databaseContextFactory;

src/API/WesternStatesWater.WestDaat.Accessors/TestAccessor.cs

@@ -1,17 +1,16 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
-using WesternStatesWater.WestDaat.Accessors.EntityFramework;
 
 namespace WesternStatesWater.WestDaat.Accessors
 {
     internal class TestAccessor : AccessorBase, ITestAccessor
     {
-        public TestAccessor(ILogger<TestAccessor> logger, IDatabaseContextFactory databaseContextFactory) : base(logger)
+        public TestAccessor(ILogger<TestAccessor> logger, EF.IDatabaseContextFactory databaseContextFactory) : base(logger)
         {
             _databaseContextFactory = databaseContextFactory;
         }
 
-        private readonly IDatabaseContextFactory _databaseContextFactory;
+        private readonly EF.IDatabaseContextFactory _databaseContextFactory;
 
         public override string TestMe(string input)
         {

src/API/WesternStatesWater.WestDaat.Accessors/WaterAllocationAccessor.cs

@@ -8,11 +8,11 @@
 using System.Transactions;
 using NetTopologySuite.Geometries.Utilities;
 using WesternStatesWater.WestDaat.Accessors.CsvModels;
-using WesternStatesWater.WestDaat.Accessors.EntityFramework;
 using WesternStatesWater.WestDaat.Accessors.Extensions;
 using WesternStatesWater.WestDaat.Accessors.Mapping;
 using WesternStatesWater.WestDaat.Common.Configuration;
 using WesternStatesWater.WestDaat.Common.DataContracts;
+using WesternStatesWater.WestDaat.Database.EntityFramework.partials;
 using WesternStatesWater.WestDaat.Utilities;
 
 namespace WesternStatesWater.WestDaat.Accessors
@@ -21,13 +21,13 @@ internal class WaterAllocationAccessor : AccessorBase, IWaterAllocationAccessor
     {
         private readonly PerformanceConfiguration _performanceConfiguration;
 
-        public WaterAllocationAccessor(ILogger<WaterAllocationAccessor> logger, IDatabaseContextFactory databaseContextFactory, PerformanceConfiguration performanceConfiguration) : base(logger)
+        public WaterAllocationAccessor(ILogger<WaterAllocationAccessor> logger, EF.IDatabaseContextFactory databaseContextFactory, PerformanceConfiguration performanceConfiguration) : base(logger)
         {
             _databaseContextFactory = databaseContextFactory;
             _performanceConfiguration = performanceConfiguration;
         }
 
-        private readonly IDatabaseContextFactory _databaseContextFactory;
+        private readonly EF.IDatabaseContextFactory _databaseContextFactory;
 
         public async Task<AnalyticsSummaryInformation[]> GetAnalyticsSummaryInformation(WaterRightsSearchCriteria searchCriteria)
         {
@@ -117,9 +117,9 @@ public async Task<WaterRightsSearchResults> FindWaterRights(WaterRightsSearchCri
             };
         }
 
-        private static ExpressionStarter<AllocationAmountsFact> BuildWaterRightsSearchPredicate(WaterRightsSearchCriteria searchCriteria, DatabaseContext db)
+        private static ExpressionStarter<EF.AllocationAmountsFact> BuildWaterRightsSearchPredicate(WaterRightsSearchCriteria searchCriteria, DatabaseContext db)
         {
-            var predicate = PredicateBuilder.New<AllocationAmountsFact>();
+            var predicate = PredicateBuilder.New<EF.AllocationAmountsFact>();
 
             predicate.And(BuildBeneficialUsesPredicate(searchCriteria));
 
@@ -138,117 +138,117 @@ private static ExpressionStarter<AllocationAmountsFact> BuildWaterRightsSearchPr
             return predicate;
         }
 
-        private static ExpressionStarter<AllocationAmountsFact> BuildFromSiteUuids(WaterRightsSearchCriteria searchCriteria, DatabaseContext db)
+        private static ExpressionStarter<EF.AllocationAmountsFact> BuildFromSiteUuids(WaterRightsSearchCriteria searchCriteria, DatabaseContext db)
         {
-            var predicate = PredicateBuilder.New<AllocationAmountsFact>(true);
+            var predicate = PredicateBuilder.New<EF.AllocationAmountsFact>(true);
 
             if (searchCriteria?.WadeSitesUuids != null && searchCriteria.WadeSitesUuids.Any())
             {
                 db.Database.ExecuteSqlRaw(Scripts.Scripts.CreateTempUuidTable);
 
-                db.BulkInsert(searchCriteria.WadeSitesUuids.Select(a => new TempUuid { Uuid = a }).ToList());
+                db.BulkInsert(searchCriteria.WadeSitesUuids.Select(a => new EF.TempUuid { Uuid = a }).ToList());
 
                 db.Database.ExecuteSqlRaw(Scripts.Scripts.CreateTempIdTable);
                 db.Database.ExecuteSqlRaw(Scripts.Scripts.FindSiteIdsFromUuids);
 
-                predicate = predicate.And(AllocationAmountsFact.HasSitesUuids(db));
+                predicate = predicate.And(EF.AllocationAmountsFact.HasSitesUuids(db));
             }
 
             return predicate;
         }
 
-        private static ExpressionStarter<AllocationAmountsFact> BuildBeneficialUsesPredicate(WaterRightsSearchCriteria searchCriteria)
+        private static ExpressionStarter<EF.AllocationAmountsFact> BuildBeneficialUsesPredicate(WaterRightsSearchCriteria searchCriteria)
         {
-            var predicate = PredicateBuilder.New<AllocationAmountsFact>(true);
+            var predicate = PredicateBuilder.New<EF.AllocationAmountsFact>(true);
 
             if (searchCriteria?.BeneficialUses != null && searchCriteria.BeneficialUses.Any())
             {
-                predicate = predicate.And(AllocationAmountsFact.HasBeneficialUses(searchCriteria.BeneficialUses.ToList()));
+                predicate = predicate.And(EF.AllocationAmountsFact.HasBeneficialUses(searchCriteria.BeneficialUses.ToList()));
             }
 
             return predicate;
         }
 
-        private static ExpressionStarter<AllocationAmountsFact> BuildDatePredicate(WaterRightsSearchCriteria searchCriteria)
+        private static ExpressionStarter<EF.AllocationAmountsFact> BuildDatePredicate(WaterRightsSearchCriteria searchCriteria)
         {
-            var predicate = PredicateBuilder.New<AllocationAmountsFact>(true);
+            var predicate = PredicateBuilder.New<EF.AllocationAmountsFact>(true);
 
             if (searchCriteria?.MinimumPriorityDate != null || searchCriteria?.MaximumPriorityDate != null)
             {
-                predicate.And(AllocationAmountsFact.HasPriorityDateRange(searchCriteria.MinimumPriorityDate, searchCriteria.MaximumPriorityDate));
+                predicate.And(EF.AllocationAmountsFact.HasPriorityDateRange(searchCriteria.MinimumPriorityDate, searchCriteria.MaximumPriorityDate));
             }
 
             return predicate;
         }
 
-        private static ExpressionStarter<AllocationAmountsFact> BuildVolumeAndFlowPredicate(WaterRightsSearchCriteria searchCriteria)
+        private static ExpressionStarter<EF.AllocationAmountsFact> BuildVolumeAndFlowPredicate(WaterRightsSearchCriteria searchCriteria)
         {
-            var predicate = PredicateBuilder.New<AllocationAmountsFact>(true);
+            var predicate = PredicateBuilder.New<EF.AllocationAmountsFact>(true);
 
             if (searchCriteria?.ExemptOfVolumeFlowPriority != null)
             {
-                predicate.And(AllocationAmountsFact.IsExemptOfVolumeFlowPriority(searchCriteria.ExemptOfVolumeFlowPriority.Value));
+                predicate.And(EF.AllocationAmountsFact.IsExemptOfVolumeFlowPriority(searchCriteria.ExemptOfVolumeFlowPriority.Value));
             }
 
             if (searchCriteria?.MinimumFlow != null || searchCriteria?.MaximumFlow != null)
             {
-                predicate.And(AllocationAmountsFact.HasFlowRateRange(searchCriteria.MinimumFlow, searchCriteria.MaximumFlow));
+                predicate.And(EF.AllocationAmountsFact.HasFlowRateRange(searchCriteria.MinimumFlow, searchCriteria.MaximumFlow));
             }
 
             if (searchCriteria?.MinimumVolume != null || searchCriteria?.MaximumVolume != null)
             {
-                predicate.And(AllocationAmountsFact.HasVolumeRange(searchCriteria.MinimumVolume, searchCriteria.MaximumVolume));
+                predicate.And(EF.AllocationAmountsFact.HasVolumeRange(searchCriteria.MinimumVolume, searchCriteria.MaximumVolume));
             }
 
             return predicate;
         }
 
-        private static ExpressionStarter<AllocationAmountsFact> BuildOwnerSearchPredicate(WaterRightsSearchCriteria searchCriteria)
+        private static ExpressionStarter<EF.AllocationAmountsFact> BuildOwnerSearchPredicate(WaterRightsSearchCriteria searchCriteria)
         {
-            var predicate = PredicateBuilder.New<AllocationAmountsFact>(true);
+            var predicate = PredicateBuilder.New<EF.AllocationAmountsFact>(true);
 
             if (searchCriteria?.OwnerClassifications != null && searchCriteria.OwnerClassifications.Any())
             {
-                predicate.And(AllocationAmountsFact.HasOwnerClassification(searchCriteria.OwnerClassifications.ToList()));
+                predicate.And(EF.AllocationAmountsFact.HasOwnerClassification(searchCriteria.OwnerClassifications.ToList()));
             }
 
             if (!string.IsNullOrWhiteSpace(searchCriteria?.AllocationOwner))
             {
-                predicate.And(AllocationAmountsFact.HasAllocationOwner(searchCriteria.AllocationOwner));
+                predicate.And(EF.AllocationAmountsFact.HasAllocationOwner(searchCriteria.AllocationOwner));
             }
 
             return predicate;
         }
 
-        private static ExpressionStarter<AllocationAmountsFact> BuildSiteDetailsPredicate(WaterRightsSearchCriteria searchCriteria)
+        private static ExpressionStarter<EF.AllocationAmountsFact> BuildSiteDetailsPredicate(WaterRightsSearchCriteria searchCriteria)
         {
-            var predicate = PredicateBuilder.New<AllocationAmountsFact>(true);
+            var predicate = PredicateBuilder.New<EF.AllocationAmountsFact>(true);
 
             if (searchCriteria?.WaterSourceTypes != null && searchCriteria.WaterSourceTypes.Any())
             {
-                predicate.And(AllocationAmountsFact.HasWaterSourceTypes(searchCriteria.WaterSourceTypes.ToList()));
+                predicate.And(EF.AllocationAmountsFact.HasWaterSourceTypes(searchCriteria.WaterSourceTypes.ToList()));
             }
 
             if (searchCriteria?.States != null && searchCriteria.States.Any())
             {
-                predicate.And(AllocationAmountsFact.HasOrganizationStates(searchCriteria.States.ToList()));
+                predicate.And(EF.AllocationAmountsFact.HasOrganizationStates(searchCriteria.States.ToList()));
             }
 
             if (!string.IsNullOrWhiteSpace(searchCriteria?.PodOrPou))
             {
-                predicate.And(AllocationAmountsFact.IsPodOrPou(searchCriteria.PodOrPou));
+                predicate.And(EF.AllocationAmountsFact.IsPodOrPou(searchCriteria.PodOrPou));
             }
 
             return predicate;
         }
 
-        private static ExpressionStarter<AllocationAmountsFact> BuildGeometrySearchPredicate(WaterRightsSearchCriteria searchCriteria)
+        private static ExpressionStarter<EF.AllocationAmountsFact> BuildGeometrySearchPredicate(WaterRightsSearchCriteria searchCriteria)
         {
-            var predicate = PredicateBuilder.New<AllocationAmountsFact>(true);
+            var predicate = PredicateBuilder.New<EF.AllocationAmountsFact>(true);
 
             if (searchCriteria?.FilterGeometry != null)
             {
-                predicate.And(AllocationAmountsFact.IsWithinGeometry(searchCriteria.FilterGeometry));
+                predicate.And(EF.AllocationAmountsFact.IsWithinGeometry(searchCriteria.FilterGeometry));
             }
 
             return predicate;
@@ -470,7 +470,7 @@ internal IEnumerable<Variables> GetVariables(WaterRightsSearchCriteria searchCri
                 .AsEnumerable();
         }
 
-        private (DatabaseContext DB, IQueryable<AllocationAmountsFact> AllocationAmounts) GetFilteredWaterAllocations(WaterRightsSearchCriteria searchCriteria)
+        private (DatabaseContext DB, IQueryable<EF.AllocationAmountsFact> AllocationAmounts) GetFilteredWaterAllocations(WaterRightsSearchCriteria searchCriteria)
         {
             var db = _databaseContextFactory.Create();
 
@@ -486,7 +486,7 @@ internal IEnumerable<Variables> GetVariables(WaterRightsSearchCriteria searchCri
             return (db, waterRightDetails);
         }
 
-        private (DatabaseContext DB, IQueryable<SitesDim> FilteredSites) GetFilteredSites(WaterRightsSearchCriteria searchCriteria)
+        private (DatabaseContext DB, IQueryable<EF.SitesDim> FilteredSites) GetFilteredSites(WaterRightsSearchCriteria searchCriteria)
         {
             var (db, waterRightDetails) = GetFilteredWaterAllocations(searchCriteria);
 

src/API/WesternStatesWater.WestDaat.Accessors/WesternStatesWater.WestDaat.Accessors.csproj

@@ -37,11 +37,9 @@
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\WesternStatesWater.WestDaat.Common\WesternStatesWater.WestDaat.Common.csproj" />
+    <ProjectReference Include="..\WesternStatesWater.WestDaat.Database\WesternStatesWater.WestDaat.Database.csproj" />
     <ProjectReference Include="..\WesternStatesWater.WestDaat.Utilities\WesternStatesWater.WestDaat.Utilities.csproj" />
   </ItemGroup>
-  <ItemGroup>
-    <Folder Include="DataTransferObjects\" />
-  </ItemGroup>
   <ItemGroup>
     <Compile Update="Scripts\Scripts.Designer.cs">
       <DesignTime>True</DesignTime>

src/API/WesternStatesWater.WestDaat.Client.Functions/Program.cs

@@ -4,11 +4,11 @@
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 using WesternStatesWater.WestDaat.Accessors;
-using WesternStatesWater.WestDaat.Accessors.EntityFramework;
 using WesternStatesWater.WestDaat.Client.Functions;
 using WesternStatesWater.WestDaat.Common.Configuration;
 using WesternStatesWater.WestDaat.Managers;
 using WesternStatesWater.WestDaat.Contracts.Client;
+using WesternStatesWater.WestDaat.Database.EntityFramework;
 using WesternStatesWater.WestDaat.Engines;
 using WesternStatesWater.WestDaat.Utilities;
 
@@ -60,9 +60,10 @@
         services.AddTransient<ITestAccessor, TestAccessor>();
         services.AddTransient<IWaterAllocationAccessor, WaterAllocationAccessor>();
 
+        services.AddTransient<IDatabaseContextFactory, DatabaseContextFactory>();
+
         services.AddTransient<IEmailNotificationSdk, EmailNotificationSdk>();
         services.AddTransient<IUsgsNldiSdk, UsgsNldiSdk>();
-        services.AddTransient<IDatabaseContextFactory, DatabaseContextFactory>();
         services.AddTransient<IBlobStorageSdk, BlobStorageSdk>();
         services.AddTransient<ITemplateResourceSdk, TemplateResourceSdk>();
 

src/API/WesternStatesWater.WestDaat.Accessors/EntityFramework/AggBridgeBeneficialUsesFact.cs → src/API/WesternStatesWater.WestDaat.Database/EntityFramework/AggBridgeBeneficialUsesFact.cs

@@ -1,12 +1,12 @@
-namespace WesternStatesWater.WestDaat.Accessors.EntityFramework
+namespace WesternStatesWater.WestDaat.Database.EntityFramework
 {
     public partial class AggBridgeBeneficialUsesFact
     {
         public long AggBridgeId { get; set; }
         public string BeneficialUseCV { get; set; }
         public long AggregatedAmountId { get; set; }
 
         public virtual AggregatedAmountsFact AggregatedAmount { get; set; }
         public virtual BeneficialUsesCV BeneficialUse { get; set; }
     }
 }

src/API/WesternStatesWater.WestDaat.Accessors/EntityFramework/AggregatedAmountsFact.cs → src/API/WesternStatesWater.WestDaat.Database/EntityFramework/AggregatedAmountsFact.cs

@@ -1,8 +1,8 @@
-namespace WesternStatesWater.WestDaat.Accessors.EntityFramework
+namespace WesternStatesWater.WestDaat.Database.EntityFramework
 {
     public partial class AggregatedAmountsFact
     {
         public AggregatedAmountsFact()
         {
             AggBridgeBeneficialUsesFact = new HashSet<AggBridgeBeneficialUsesFact>();
         }

src/API/WesternStatesWater.WestDaat.Accessors/EntityFramework/AggregationStatistic.cs → src/API/WesternStatesWater.WestDaat.Database/EntityFramework/AggregationStatistic.cs

@@ -1,4 +1,4 @@
-namespace WesternStatesWater.WestDaat.Accessors.EntityFramework
+namespace WesternStatesWater.WestDaat.Database.EntityFramework
 {
     public partial class AggregationStatistic : ControlledVocabularyBase
     {

src/API/WesternStatesWater.WestDaat.Accessors/EntityFramework/AllocationAmountsFact.cs → src/API/WesternStatesWater.WestDaat.Database/EntityFramework/AllocationAmountsFact.cs

@@ -1,9 +1,10 @@
-using LinqKit;
+using System.ComponentModel.DataAnnotations;
+using LinqKit;
 using NetTopologySuite.Geometries;
 using NetTopologySuite.Geometries.Utilities;
-using System.ComponentModel.DataAnnotations;
+using WesternStatesWater.WestDaat.Database.EntityFramework.partials;
 
-namespace WesternStatesWater.WestDaat.Accessors.EntityFramework
+namespace WesternStatesWater.WestDaat.Database.EntityFramework
 {
     public partial class AllocationAmountsFact
     {