Adding

2026-03-31 16:43:12 -05:00
parent 9be174da46
commit d639027028
198 changed files with 111474 additions and 0 deletions
@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="7.0.5" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="7.0.5">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="7.0.5" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="7.0.5" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\LCU.Library.Internal.MemberPreferencesApiModels\LCU.Library.Internal.MemberPreferencesApiModels.csproj" />
+  </ItemGroup>
+
+</Project>
@@ -0,0 +1,107 @@
+using LCU.Library.Internal.MemberPreferencesApiModels.Entities;
+using LCU.Library.Internal.MemberPreferencesApiModels.Enums;
+using LCU.Library.Internal.MemberPreferencesApiModels.Models;
+using Microsoft.EntityFrameworkCore;
+using System.Reflection;
+
+namespace LCU.API.Internal.MemberPreferencesApiLib.Persistence;
+
+public class ApplicationDbContext : DbContext, IApplicationDbContext
+{
+    private readonly IDictionary<Auditable, string> _systemModifiedAuditables = new Dictionary<Auditable, string>();
+
+    public ApplicationDbContext(DbContextOptions options) : base(options)
+    {
+    }
+
+    public DbSet<MemberPreference> MemberPreferences { get; set; }
+    public DbSet<MemberOptInSettings> MemberOptInSettings { get; set; }
+    public DbSet<DnaAuditProcess> DnaAuditProcesses { get; set; }
+    public DbSet<XdiBatchItem> XdiBatchItems { get; set; }
+
+    public override Task<int> SaveChangesAsync(CancellationToken cancellationToken = new CancellationToken())
+    {
+        foreach (var entry in ChangeTracker.Entries<Auditable>())
+        {
+            var auditableUser = _systemModifiedAuditables.TryGetValue(entry.Entity, out var systemUser);
+            var applicationUser = new ApplicationUser
+            {
+                UserName = systemUser,
+                UserType = UserType.System
+            };
+
+            var otherUser = new ApplicationUser
+            {
+                UserName = "Unknown",
+                UserType = UserType.System,
+            };
+
+            var currentUser = auditableUser ? applicationUser : otherUser;
+            switch (entry.State)
+            {
+                case EntityState.Added:
+                    entry.Entity.CreatedByType = currentUser.UserType;
+                    entry.Entity.CreatedBy = currentUser.UserName;
+                    entry.Entity.Created = DateTime.Now;
+                    entry.Entity.LastUpdatedByType = currentUser.UserType;
+                    entry.Entity.LastUpdatedBy = currentUser.UserName;
+                    entry.Entity.LastUpdated = DateTime.Now;
+                    break;
+                case EntityState.Modified:
+                    entry.Entity.LastUpdatedByType = currentUser.UserType;
+                    entry.Entity.LastUpdatedBy = currentUser.UserName;
+                    entry.Entity.LastUpdated = DateTime.Now;
+                    break;
+            }
+        }
+
+        return base.SaveChangesAsync(cancellationToken);
+    }
+
+    public Task<int> SaveChangesWithOperatorAsync(string operatorId, DateTime dateAdded, UserType userType, CancellationToken cancellationToken = new CancellationToken())
+    {
+        foreach (var entry in ChangeTracker.Entries<Auditable>())
+        {
+            switch (entry.State)
+            {
+                case EntityState.Added:
+                    entry.Entity.CreatedByType = userType;
+                    entry.Entity.CreatedBy = operatorId;
+                    entry.Entity.Created = dateAdded;
+                    entry.Entity.LastUpdatedByType = userType;
+                    entry.Entity.LastUpdatedBy = operatorId;
+                    entry.Entity.LastUpdated = dateAdded;
+                    break;
+                case EntityState.Modified:
+                    entry.Entity.LastUpdatedByType = userType;
+                    entry.Entity.LastUpdatedBy = operatorId;
+                    entry.Entity.LastUpdated = dateAdded;
+                    break;
+            }
+        }
+
+        return base.SaveChangesAsync(cancellationToken);
+    }
+
+    public void SystemModified(Auditable entity, string modifiedBy) => _systemModifiedAuditables[entity] = modifiedBy;
+
+    protected override void OnModelCreating(ModelBuilder builder)
+    {
+        builder.ApplyConfigurationsFromAssembly(Assembly.GetExecutingAssembly());
+        base.OnModelCreating(builder);
+
+        builder.Entity<MemberPreference>().ToTable("MemberPreference");
+        builder.Entity<MemberPreference>().HasKey(p => p.Id);
+
+        builder.Entity<XdiBatchItem>().ToTable("XdiBatchItems");
+        builder.Entity<XdiBatchItem>().HasKey(p => new { p.UserId, p.BatchState });
+
+        builder.Entity<MemberOptInSettings>().ToTable("MemberOptInSettings");
+        builder.Entity<MemberOptInSettings>().HasKey(p => p.Id);
+        builder.Entity<MemberOptInSettings>().HasIndex(p => new { p.UserId })
+            .IsUnique(true);
+
+        builder.Entity<DnaAuditProcess>().ToTable("DnaAuditProcess");
+        builder.Entity<DnaAuditProcess>().HasKey(p => p.ProcessId);
+    }
+}
@@ -0,0 +1,16 @@
+using LCU.Library.Internal.MemberPreferencesApiModels.Entities;
+using LCU.Library.Internal.MemberPreferencesApiModels.Enums;
+using LCU.Library.Internal.MemberPreferencesApiModels.Models;
+using Microsoft.EntityFrameworkCore;
+
+namespace LCU.API.Internal.MemberPreferencesApiLib.Persistence;
+
+public interface IApplicationDbContext : IAuditableChanges
+{
+    DbSet<MemberPreference> MemberPreferences { get; set; }
+    DbSet<MemberOptInSettings> MemberOptInSettings { get; set; }
+    public DbSet<XdiBatchItem> XdiBatchItems { get; set; }
+    public DbSet<DnaAuditProcess> DnaAuditProcesses { get; set; }
+    Task<int> SaveChangesAsync(CancellationToken cancellationToken = new CancellationToken());
+    Task<int> SaveChangesWithOperatorAsync(string operatorId, DateTime dateAdded, UserType userType, CancellationToken cancellationToken);
+}
@@ -0,0 +1,13 @@
+using LCU.API.Internal.MemberPreferencesApiLib.Persistence;
+
+namespace LCU.API.Internal.MemberPreferencesApiLib.Repositories;
+
+public abstract class BaseRepository
+{
+    protected readonly IApplicationDbContext _context;
+
+    public BaseRepository(IApplicationDbContext context)
+    {
+        _context = context;
+    }
+}
@@ -0,0 +1,23 @@
+using LCU.API.Internal.MemberPreferencesApiLib.Persistence;
+using LCU.Library.Internal.MemberPreferencesApiModels.Entities;
+using Microsoft.EntityFrameworkCore;
+
+namespace LCU.API.Internal.MemberPreferencesApiLib.Repositories;
+
+public class DnaAuditProcessRepository : BaseRepository, IDnaAuditProcessRepository
+{
+    public DnaAuditProcessRepository(IApplicationDbContext context) : base(context)
+    {
+    }
+
+    public async Task<IReadOnlyCollection<DnaAuditProcess>> GetAllDnaAuditProcesses()
+    {
+        return await _context.DnaAuditProcesses.ToListAsync();
+    }
+
+    public async Task Update(DnaAuditProcess existing)
+    {
+        _context.DnaAuditProcesses.Update(existing);
+        await _context.SaveChangesAsync();
+    }
+}
@@ -0,0 +1,9 @@
+using LCU.Library.Internal.MemberPreferencesApiModels.Entities;
+
+namespace LCU.API.Internal.MemberPreferencesApiLib.Repositories;
+
+public interface IDnaAuditProcessRepository
+{
+    Task<IReadOnlyCollection<DnaAuditProcess>> GetAllDnaAuditProcesses();
+    Task Update(DnaAuditProcess existing);
+}
@@ -0,0 +1,8 @@
+namespace LCU.API.Internal.MemberPreferencesApiLib.Repositories;
+
+public interface IMemberPreferenceRepository
+{
+    Task<int> SaveMemberPreferenceAsync(LCU.Library.Internal.MemberPreferencesApiModels.Entities.MemberPreference memberPreference);
+    Task BulkSaveMemberPreferenceAsync(List<LCU.Library.Internal.MemberPreferencesApiModels.Entities.MemberPreference> memberPreferences);
+    Task<IReadOnlyCollection<LCU.Library.Internal.MemberPreferencesApiModels.Entities.MemberPreference>> GetMemberPreferencesAsync(string userId);
+}
@@ -0,0 +1,11 @@
+using LCU.Library.Internal.MemberPreferencesApiModels.Entities;
+
+namespace LCU.API.Internal.MemberPreferencesApiLib.Repositories;
+
+public interface IUnifiedOptInRepository
+{
+    Task<MemberOptInSettings> GetMemberOptInSettings(string userId);
+    Task<MemberOptInSettings> GetMemberOptInSettingsNoTracking(string userId);
+    Task<MemberOptInSettings> GetOrCreateMemberOptinSettings(string userId);
+    Task<List<MemberOptInSettings>> GetAllMemberOptInSettings(List<string> memberNumbers);
+}
@@ -0,0 +1,9 @@
+using LCU.Library.Internal.MemberPreferencesApiModels.Enums;
+
+namespace LCU.API.Internal.MemberPreferencesApiLib.Repositories;
+
+public interface IUnitOfWork
+{
+    Task CompleteAsync();
+    Task CompleteAsync(string operatorId, DateTime dateAdded, UserType userType);
+}
@@ -0,0 +1,15 @@
+using LCU.Library.Internal.MemberPreferencesApiModels.Entities;
+using LCU.Library.Internal.MemberPreferencesApiModels.Enums;
+
+namespace LCU.API.Internal.MemberPreferencesApiLib.Repositories;
+
+public interface IXdiBatchItemsRepository
+{
+    Task<IReadOnlyCollection<XdiBatchItem>> GetXdiBatchItems();
+    Task<IReadOnlyCollection<XdiBatchItem>> GetNewXdiBatchItems();
+    Task<XdiBatchItem> SaveAsync(XdiBatchItem batchItem);
+    Task<XdiBatchItem> FindExistingItem(string memberId, BatchState batchState);
+    void Update(XdiBatchItem existing);
+    void Delete(XdiBatchItem item);
+    Task<bool> MarkPendingSuccessful(List<string> memberList);
+}
@@ -0,0 +1,53 @@
+using LCU.API.Internal.MemberPreferencesApiLib.Persistence;
+using LCU.Library.Internal.MemberPreferencesApiModels.Entities;
+using Microsoft.EntityFrameworkCore;
+
+namespace LCU.API.Internal.MemberPreferencesApiLib.Repositories;
+
+public class MemberPreferenceRepository : BaseRepository, IMemberPreferenceRepository, IMemberPreferences
+{
+    public MemberPreferenceRepository(IApplicationDbContext context) : base(context)
+    {
+    }
+
+    public async Task<int> SaveMemberPreferenceAsync(MemberPreference memberPreference)
+    {
+        await _context.MemberPreferences.AddAsync(memberPreference);
+        return memberPreference.Id;
+    }
+
+    public async Task BulkSaveMemberPreferenceAsync(List<MemberPreference> memberPreferences)
+    {
+        var relevantSettingsCache = await _context.MemberOptInSettings.Where(settings =>
+            memberPreferences.Select(x => x.UserId).Contains(settings.UserId)).ToListAsync();
+
+        foreach (var preference in memberPreferences)
+        {
+            var settings = relevantSettingsCache.FirstOrDefault(x => x.UserId == preference.UserId);
+
+            if (settings == null)
+            {
+                settings = new MemberOptInSettings()
+                {
+                    UserId = preference.UserId
+                };
+                relevantSettingsCache.Add(settings);
+            }
+
+            settings.Apply(preference);
+        }
+
+        await _context.MemberPreferences.AddRangeAsync(memberPreferences);
+        _context.MemberOptInSettings.UpdateRange(relevantSettingsCache);
+    }
+
+    public async Task<IReadOnlyCollection<MemberPreference>> GetMemberPreferencesAsync(string userId)
+    {
+        return await _context.MemberPreferences
+            .Where(x => x.UserId.ToLower() == userId.ToLower())
+            .OrderBy(t => t.Id)
+            .ToListAsync();
+    }
+
+    public Task Add(MemberPreference preferenceChange) => SaveMemberPreferenceAsync(preferenceChange);
+}
@@ -0,0 +1,43 @@
+using LCU.API.Internal.MemberPreferencesApiLib.Persistence;
+using LCU.Library.Internal.MemberPreferencesApiModels.Entities;
+using Microsoft.EntityFrameworkCore;
+
+namespace LCU.API.Internal.MemberPreferencesApiLib.Repositories;
+
+public class UnifiedOptInRepository : BaseRepository, IUnifiedOptInRepository
+{
+    public UnifiedOptInRepository(IApplicationDbContext context) : base(context)
+    {
+    }
+
+    public async Task<MemberOptInSettings> GetMemberOptInSettings(string userId)
+    {
+        return await _context.MemberOptInSettings.Where(x => x.UserId == userId).FirstOrDefaultAsync();
+    }
+
+    public async Task<MemberOptInSettings> GetMemberOptInSettingsNoTracking(string userId)
+    {
+        return await _context.MemberOptInSettings.Where(x => x.UserId.Equals(userId)).AsNoTracking().FirstOrDefaultAsync();
+    }
+
+    public async Task<MemberOptInSettings> GetOrCreateMemberOptinSettings(string userId)
+    {
+        var settings = await GetMemberOptInSettings(userId);
+
+        if (settings == null)
+        {
+            settings = new MemberOptInSettings
+            {
+                UserId = userId
+            };
+            await _context.MemberOptInSettings.AddAsync(settings);
+        }
+
+        return settings;
+    }
+
+    public async Task<List<MemberOptInSettings>> GetAllMemberOptInSettings(List<string> userNumbers)
+    {
+        return await _context.MemberOptInSettings.Where(entry => userNumbers.Contains(entry.UserId)).ToListAsync();
+    }
+}
@@ -0,0 +1,24 @@
+using LCU.API.Internal.MemberPreferencesApiLib.Persistence;
+using LCU.Library.Internal.MemberPreferencesApiModels.Enums;
+
+namespace LCU.API.Internal.MemberPreferencesApiLib.Repositories;
+
+public class UnitOfWork : IUnitOfWork
+{
+    private readonly ApplicationDbContext _context;
+
+    public UnitOfWork(ApplicationDbContext context)
+    {
+        _context = context;
+    }
+
+    public async Task CompleteAsync()
+    {
+        await _context.SaveChangesAsync();
+    }
+
+    public async Task CompleteAsync(string operatorId, DateTime dateAdded, UserType userType)
+    {
+        await _context.SaveChangesWithOperatorAsync(operatorId, dateAdded, userType);
+    }
+}
@@ -0,0 +1,54 @@
+using LCU.API.Internal.MemberPreferencesApiLib.Persistence;
+using LCU.Library.Internal.MemberPreferencesApiModels.Entities;
+using LCU.Library.Internal.MemberPreferencesApiModels.Enums;
+using Microsoft.EntityFrameworkCore;
+
+namespace LCU.API.Internal.MemberPreferencesApiLib.Repositories;
+
+public class XdiBatchItemsRepository : BaseRepository, IXdiBatchItemsRepository
+{
+    public XdiBatchItemsRepository(IApplicationDbContext context) : base(context)
+    {
+    }
+
+    public async Task<IReadOnlyCollection<XdiBatchItem>> GetXdiBatchItems()
+    {
+        return await _context.XdiBatchItems.ToListAsync();
+    }
+
+    public async Task<IReadOnlyCollection<XdiBatchItem>> GetNewXdiBatchItems()
+    {
+        return await _context.XdiBatchItems.Where(x => x.BatchState == BatchState.New).ToListAsync();
+    }
+
+    public async Task<XdiBatchItem> SaveAsync(XdiBatchItem batchItem)
+    {
+        await _context.XdiBatchItems.AddAsync(batchItem);
+        return batchItem;
+    }
+
+    public async Task<XdiBatchItem> FindExistingItem(string userId, BatchState batchState)
+    {
+        return await _context.XdiBatchItems.Where(p => p.UserId == userId && p.BatchState == batchState)
+            .FirstOrDefaultAsync();
+    }
+
+    public void Update(XdiBatchItem existing)
+    {
+        _context.XdiBatchItems.Update(existing);
+    }
+
+    public void Delete(XdiBatchItem item)
+    {
+        _context.XdiBatchItems.Remove(item);
+    }
+
+    public async Task<bool> MarkPendingSuccessful(List<string> memberList)
+    {
+        var items = await _context.XdiBatchItems
+            .Where(x => x.BatchState == BatchState.TransferPending && memberList.Contains(x.UserId))
+            .ToListAsync();
+        _context.XdiBatchItems.RemoveRange(items);
+        return true;
+    }
+}