CRUD para um Aggregate com Child Enity

[victorlpb92]

Gostaria de enternder melhor como dentro do padrão DDD ao atulizar um Aggrefate como gerenciar o CRUD dos Children.

A inserir tudo ocorre perfeitamente. O que eu não é o UPDATE ao remover o filho nada aconte e quando adicionamos um o EF Core retorna um erro.

[victorlpb92]

public class PaymentTerm : Entity, IAggregateRoot
{
    public PaymentTerm(short payTermCode, string payTermName, short instNum, bool active, List paymentTermInstallmentLayouts)
    {
        PayTermCode = payTermCode;
        PayTermName = payTermName;
        InstNum = instNum;
        Active = active;
        _paymentTermInstallmentLayouts = paymentTermInstallmentLayouts;
    }

    //Construtor vazio para o EF Core
    public PaymentTerm() { }

    /// <summary>
    /// Código da condição de pagamento
    /// </summary>
    public short PayTermCode { get; set; }

    /// <summary>
    /// Descrição da condição de pagamento
    /// </summary>
    public string PayTermName { get; set; }

    /// <summary>
    /// Parcelas totais
    /// </summary>
    public short InstNum { get; set; }

    /// <summary>
    /// Ativa
    /// </summary>
    public bool Active { get; set; }

    /// <summary>
    /// 
    /// </summary>
    private readonly List<PaymentTermInstallmentLayout> _paymentTermInstallmentLayouts = new List<PaymentTermInstallmentLayout>();

    /// <summary>
    /// 
    /// </summary>
    public IReadOnlyCollection<PaymentTermInstallmentLayout> PaymentTermInstallmentLayouts => _paymentTermInstallmentLayouts.AsReadOnly();
}

public class PaymentTermInstallmentLayout
{
    public PaymentTermInstallmentLayout(short payTermCode, short intsNo, short instMonth, short instDays, decimal instPrcnt)
    {
        PayTermCode = payTermCode;
        IntsNo = intsNo;
        InstMonth = instMonth;
        InstDays = instDays;
        InstPrcnt = instPrcnt;
    }

    //Construtor vazio para o EF Core
    public PaymentTermInstallmentLayout() { }

    /// <summary>
    /// Código da codição de pagamento
    /// </summary>
    public short PayTermCode { get; set; }

    /// <summary>
    /// N° da parcela
    /// </summary>
    public short IntsNo { get; set; }

    /// <summary>
    /// Meses a contar da data do documento
    /// </summary>
    public short InstMonth { get; set; }

    /// <summary>
    /// Dias a conta da data do documento
    /// </summary>
    public short InstDays { get; set; }

    /// <summary>
    /// Percentual da parcela
    /// </summary>
    public decimal InstPrcnt { get; set; }
}

public class PaymentTermMap : IEntityTypeConfiguration
{
    public void Configure(EntityTypeBuilder builder)
    {
        builder.ToTable("PaymentTerms");

        builder.Ignore(p => p.Id);

        builder.Property(p => p.PayTermCode)
            .HasColumnType("smallint")
            .HasColumnName("PayTermCode")
            .ValueGeneratedNever()
            .IsRequired();

        builder.Property(p => p.PayTermName)
            .HasColumnType("nvarchar(100)")
            .HasColumnName("PayTermName")
            .HasMaxLength(100)
            .IsRequired();

        builder.Property(p => p.Active)
            .HasColumnType("bit")
            .HasColumnName("Active")
            .IsRequired();

        builder.Property(p => p.InstNum)
            .HasColumnType("smallint")
            .HasColumnName("InstNum")
            .IsRequired();            

        builder.HasKey(p => p.PayTermCode);

        builder.HasMany(p => p.PaymentTermInstallmentLayouts)
            .WithOne()
            .HasForeignKey(p => p.PayTermCode)
            .Metadata.PrincipalToDependent.SetPropertyAccessMode(PropertyAccessMode.Field);
    }
}

public class PaymentTermInstallmentLayoutMap : IEntityTypeConfiguration
{
    public void Configure(EntityTypeBuilder builder)
    {
        builder.Property(p => p.PayTermCode)
            .HasColumnType("smallint")
            .HasColumnName("PayTermCode")
            .ValueGeneratedNever()
            .IsRequired();

        builder.Property(p => p.IntsNo)
            .HasColumnType("smallint")
            .HasColumnName("IntsNo")
            .ValueGeneratedNever()
            .IsRequired();

        builder.Property(p => p.InstMonth)
            .HasColumnType("smallint")
            .HasColumnName("InstMonth")
            .IsRequired();

        builder.Property(p => p.InstDays)
            .HasColumnType("smallint")
            .HasColumnName("InstDays")
            .IsRequired();

        builder.Property(p => p.InstPrcnt)
            .HasColumnType("numeric(19,6)")
            .HasColumnName("InstPrcnt")
            .HasPrecision(19, 6)
            .IsRequired();

        builder.HasKey(p => new { p.PayTermCode, p.IntsNo });
    }
}

public class PaymentTermRepository : IPaymentTermRepository
{
    protected readonly HammerSysContext Db;
    protected readonly DbSet DbSet;

    public PaymentTermRepository(HammerSysContext context)
    {
        Db = context;
        DbSet = Db.Set<PaymentTerm>();
    }

    public IUnitOfWork UnitOfWork => Db;

    public async Task<PaymentTerm> GetByKey(short payTermCode)
    {
        return await DbSet.Include(p => p.PaymentTermInstallmentLayouts)
            .FirstAsync(w => w.PayTermCode == payTermCode);
    }
    public void Add(PaymentTerm paymentTerm)
    {
        DbSet.Add(paymentTerm);
    }

    public void Update(PaymentTerm paymentTerm)
    {
        DbSet.Update(paymentTerm);
    }

    public void Remove(PaymentTerm paymentTerm)
    {
        DbSet.Remove(paymentTerm);
    }

    public void Dispose()
    {
        Db.Dispose();
    }
}

[rafaelfgx]

@victorlpb92, DDD não diz "como deve ser feito", mas sim "o que deve ser feito", ele é livre de tecnologias, frameworks e detalhes técnicos.

DDD diz que cada agregado deve ter apenas um único repositório para todas as suas entidades, mas não diz que tecnologia ou framework você vai utilizar, ou como você vai fazer tecnicamente. Exemplo:

Se você tiver duas entidades em um agregado, NotaFiscal (raíz do agregado) e NotaFiscalItem, você vai ter apenas o repositório da raíz do agregado NotaFiscalRepository. Através desse repositório que você vai gerenciar todas as entidades do agregado.

Você que vai decidir qual a melhor lógica interna de cada método:

public interface INotaFiscalRepository
{
    /// 1) Dá pra inserir a nota fiscal com os itens direto pelo Entity Framework
    // context.NotasFiscais.Add(notaFiscal); // Se o EF estiver bem configurado vai funcionar

    /// 2) Dá pra inserir a nota fiscal e depois os itens com o AddRange (menos performático que o anterior)
    // context.NotasFiscais.Add(notaFiscal);
    // context.NotasFiscaisItens.AddRange(notaFiscal.Itens);

    /// 3) Dá pra inserir a nota fiscal e depois cada item usando um for (pouco performático)
    // context.NotasFiscais.Add(notaFiscal);
    // foreach(var item in notaFiscal.Itens)
    // {
    //     context.NotasFiscaisItens.Add(item);
    // }
    void Adicionar(NotaFiscal notaFiscal);

    /// Aqui você consegue fazer qualquer lógica também, você que vai decidir a melhor e mais performática
    void Atualizar(NotaFiscal notaFiscal);

    NotaFiscal Obter(NotaFiscalId notaFiscalId);

    IEnumerable<NotaFiscal> Listar();

    void Excluir(NotaFiscalItemId notaFiscalItemId);
}

Portanto a sua dúvida não tem relação com DDD, mas sim com Entity Framework. Verifique os links abaixo para tentar resolver:

https://stackoverflow.com/questions/27176014/how-to-add-update-child-entities-when-updating-a-parent-entity-in-ef https://stackoverflow.com/questions/33056482/is-it-really-impossible-to-update-child-collection-in-ef-out-of-the-box-aka-non https://stackoverflow.com/questions/25831959/how-to-update-child-list-in-entity-framework