Files
EnvelopeGenerator/EnvelopeGenerator.Infrastructure/EGDbContext.cs
TekH 621f9333a4 Refactor: Replace EnvelopeType with EnvelopeTypeDefaults
Replaced the `EnvelopeType` class with `EnvelopeTypeDefaults` across the codebase to standardize the data model. Updated DTOs, repositories, services, mappings, and database contexts to reflect this change.

Key updates include:
- Updated `EnvelopeDto` to use `EnvelopeTypeDefaults`.
- Modified `IEnvelopeTypeRepository` and `IEnvelopeTypeService` interfaces.
- Adjusted mappings in `MappingProfile.cs` for `EnvelopeTypeDefaults`.
- Updated `ReadEnvelopeTypesQueryHandler` and `CreateEnvelopeCommandHandler` to use `EnvelopeTypeDefaults`.
- Replaced `EnvelopeType` with `EnvelopeTypeDefaults` in `EnvelopeTypeModel.vb`, `frmEnvelopeMainData.vb`, and `EGDbContextBase`.
- Introduced the `EnvelopeTypeDefaults` class with updated schema mappings.
- Updated `EnvelopeTypeRepository` and `TestEnvelopeTypeController` to use `EnvelopeTypeDefaults`.

These changes ensure consistency and improve maintainability across the application.
2026-11-12 16:42:27 +01:00

255 lines
7.7 KiB
C#

using DigitalData.UserManager.Domain.Entities;
using EnvelopeGenerator.Domain.Entities;
using Microsoft.EntityFrameworkCore;
using Group = DigitalData.UserManager.Domain.Entities.Group;
using Module = DigitalData.UserManager.Domain.Entities.Module;
using Microsoft.Extensions.Options;
using Microsoft.Extensions.Logging;
#if NET
using DigitalData.EmailProfilerDispatcher;
using DigitalData.EmailProfilerDispatcher.Abstraction.Entities;
using DigitalData.UserManager.Infrastructure;
using DigitalData.UserManager.Infrastructure.Contracts;
using DigitalData.Core.Client;
#elif NETFRAMEWORK
using System.Linq;
#endif
namespace EnvelopeGenerator.Infrastructure
#if NET
;
#elif NETFRAMEWORK
{
#endif
public class EGDbContext : EGDbContextBase
{
public EGDbContext(DbContextOptions<EGDbContext> options, IOptions<DbTriggerParams> triggerParamOptions, ILogger<EGDbContext>
#if NET
?
#endif
logger = null) : base(options, triggerParamOptions, logger)
{
}
}
//TODO: Adding EmailOut instead of EmailOut.Abst is not correct for the arch. Re-design EmailPut consedering this. IMailDbContext shoud move to Abstraction layer (hint: in this case using DBSet in abst. will be problem because entity framework will have to be added.
public abstract class EGDbContextBase : DbContext
#if NET
, IUserManagerDbContext, IMailDbContext
#endif
{
public DbSet<Config> Configs { get; set; }
public DbSet<EnvelopeReceiver> EnvelopeReceivers { get; set; }
public DbSet<Envelope> Envelopes { get; set; }
public DbSet<DocReceiverElement> DocumentReceiverElements { get; set; }
public DbSet<ElementAnnotation> DocumentReceiverElementAnnotations { get; set; }
public DbSet<DocumentStatus> DocumentStatus { get; set; }
public DbSet<EmailTemplate> EmailTemplate { get; set; }
public DbSet<Document> EnvelopeDocument { get; set; }
public DbSet<History> EnvelopeHistories { get; set; }
public DbSet<EnvelopeTypeDefaults> EnvelopeTypes { get; set; }
public DbSet<Receiver> Receivers { get; set; }
public DbSet<GroupOfUser> GroupOfUsers { get; set; }
public DbSet<Group> Groups { get; set; }
public DbSet<ModuleOfUser> ModuleOfUsers { get; set; }
public DbSet<Module> Modules { get; set; }
public DbSet<User> Users { get; set; }
public DbSet<UserRep> UserReps { get; set; }
#if NET
public DbSet<EmailOut> EMailOuts { get; set; }
#endif
public DbSet<EnvelopeReceiverReadOnly> EnvelopeReceiverReadOnlys { get; set; }
public DbSet<ClientUser> ClientUsers { get; set; }
private readonly DbTriggerParams _triggers;
private readonly ILogger
#if NET
?
#endif
_logger;
public bool IsMigration { get; set; } = false;
public EGDbContextBase(DbContextOptions options, IOptions<DbTriggerParams> triggerParamOptions, ILogger
#if NET
?
#endif
logger = null) : base(options)
{
_triggers = triggerParamOptions.Value;
_logger = logger;
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.Entity<Config>().HasNoKey();
#region EnvelopeReceiver
modelBuilder.Entity<EnvelopeReceiver>()
.HasKey(er => new { er.EnvelopeId, er.ReceiverId });
modelBuilder.Entity<EnvelopeReceiver>()
.HasOne(er => er.Envelope)
.WithMany(e => e.EnvelopeReceivers)
.HasForeignKey(er => er.EnvelopeId);
modelBuilder.Entity<EnvelopeReceiver>()
.HasOne(er => er.Receiver)
.WithMany(r => r.EnvelopeReceivers)
.HasForeignKey(er => er.ReceiverId);
#endregion EnvelopeReceiver
#region Envelope
modelBuilder.Entity<Envelope>()
.HasIndex(e => e.Uuid)
.IsUnique();
modelBuilder.Entity<Envelope>()
.HasMany(e => e.Documents)
.WithOne(d => d.Envelope)
.HasForeignKey(ed => ed.EnvelopeId);
modelBuilder.Entity<Envelope>()
.HasMany(e => e.Histories)
.WithOne(h => h.Envelope)
.HasForeignKey(hist => hist.EnvelopeId);
#endregion Envelope
#region Receiver
modelBuilder.Entity<Receiver>()
.HasIndex(e => e.Signature)
.IsUnique();
modelBuilder.Entity<Receiver>()
.HasIndex(e => e.EmailAddress)
.IsUnique();
#endregion Receiver
#region EnvelopeDocument
modelBuilder.Entity<Document>()
.HasMany(ed => ed.Elements)
.WithOne(e => e.Document)
.HasForeignKey(e => e.DocumentId);
#endregion EnvelopeDocument
#region DocumentReceiverElement
modelBuilder.Entity<DocReceiverElement>()
.HasOne(dre => dre.Document)
.WithMany(ed => ed.Elements)
.HasForeignKey(dre => dre.DocumentId);
#endregion DocumentReceiverElement
if (!IsMigration)
{
modelBuilder.Entity<History>()
.HasOne(eh => eh.Receiver)
.WithMany()
.HasForeignKey(eh => eh.UserReference)
.HasPrincipalKey(e => e.EmailAddress);
modelBuilder.Entity<History>()
.HasOne(eh => eh.Sender)
.WithMany()
.HasForeignKey(eh => eh.UserReference)
.HasPrincipalKey(e => e.Email);
}
#region EnvelopeReceiverReadOnly
modelBuilder.Entity<EnvelopeReceiverReadOnly>()
.HasOne(erro => erro.Receiver)
.WithMany()
.HasForeignKey(erro => erro.AddedWho)
.HasPrincipalKey(r => r.EmailAddress);
#endregion EnvelopeReceiverReadOnly
#region DocumentStatus
modelBuilder.Entity<DocumentStatus>()
.HasOne(ds => ds.Envelope)
.WithMany()
.HasForeignKey(ds => ds.EnvelopeId);
modelBuilder.Entity<DocumentStatus>()
.HasOne(ds => ds.Receiver)
.WithMany()
.HasForeignKey(ds => ds.ReceiverId);
#endregion DocumentStatus
#region Annotation
modelBuilder.Entity<DocReceiverElement>()
.HasMany(signature => signature.Annotations)
.WithOne(annot => annot.Element)
.HasForeignKey(annot => annot.ElementId);
#endregion
#region Trigger
// Configure entities to handle database triggers
void AddTrigger<T>() where T : class
{
var entityName = typeof(T).Name;
var configuredTriggerNames = _triggers
.Where(t => t.Key == entityName)
.SelectMany(t => t.Value)
.Distinct()
.ToList();
foreach (var triggerName in configuredTriggerNames)
{
#if NET
modelBuilder.Entity<T>().ToTable(tb => tb.HasTrigger(triggerName));
#endif
_logger?.LogInformation("Trigger '{triggerName}' has been added to the '{entityName}' entity.", triggerName, entityName);
}
}
// TODO: call add trigger methods with attributes and reflection
AddTrigger<Config>();
AddTrigger<DocReceiverElement>();
AddTrigger<DocumentStatus>();
AddTrigger<EmailTemplate>();
AddTrigger<Envelope>();
AddTrigger<Document>();
AddTrigger<History>();
AddTrigger<EnvelopeReceiver>();
AddTrigger<EnvelopeReceiverReadOnly>();
AddTrigger<EnvelopeTypeDefaults>();
AddTrigger<Receiver>();
#if NET
AddTrigger<EmailOut>();
#endif
#endregion Trigger
//configure model builder for user manager tables
#if NET
modelBuilder.ConfigureUserManager();
#endif
base.OnModelCreating(modelBuilder);
}
}
#if NETFRAMEWORK
}
#endif