آموزش Event Sourcing بخش پنجم، سلام دنیا به روش Event Sourcing- بخش اول

public class OpenANewBankAccountCommand
{

    public decimal InitialBalance { get; set; }

}

public class BankAccountId : IsAnIdentity<BankAccountId>

{

    public readonly string Id;

    public static BankAccountId New(string id) => new(id);

    private BankAccountId(string id) => Id = id;

    public override IEnumerable<object> GetEqualityComponents()

    {

        yield return Id;

    }

}

public class BankAccount : IsAnAggregateRoot<BankAccountId>
{

    public BankAccount(BankAccountId identity, OpenANewBankAccountCommand cmd) : base(identity)

    {

    }

}

public class ANewBankAccountIsOpened : IsADomainEvent

{

    public decimal InitialBalance { get; }

    public ANewBankAccountIsOpened(string aggregateId, decimal initialBalance) : base(aggregateId)

    {

        InitialBalance = initialBalance;

    }

    public override IEnumerable<object> GetEqualityComponents()

    {

        yield return AggregateId;

    }

}

public class TheBankAccountIsDepositedDueToBankFees : IsADomainEvent

{

    public decimal Fees { get; }

    public TheBankAccountIsDepositedDueToBankFees(string aggregateId, decimal fees) : base(aggregateId)

    {

        Fees = fees;

    }

    public override IEnumerable<object> GetEqualityComponents()

    {

        yield return AggregateId;

    }

}

public class TheBankAccountIsDepositedDueToSMSFees : IsADomainEvent

{

    public decimal Fees { get; }

    public TheBankAccountIsDepositedDueToSMSFees(string aggregateId, decimal fees) : base(aggregateId)

    {

        Fees = fees;

    }

    public override IEnumerable<object> GetEqualityComponents()

    {

        yield return AggregateId;

    }

}

public class BankAccount : IsAnAggregateRoot<BankAccountId>
{
    private readonly Queue<IsADomainEvent> _eventQueue;

    public BankAccount(BankAccountId identity, OpenANewBankAccountCommand cmd
    , InitialBalanceThresholdService service) : base(identity)
    {
        service.Check(cmd.InitialBalance);

        var aNewBankAccountIsOpened = new ANewBankAccountIsOpened(identity.Id, cmd.InitialBalance);
        var theBankAccountIsDepositedDueToBankFees = new TheBankAccountIsDepositedDueToBankFees(identity.Id, 20000);
        var theBankAccountIsDepositedDueToSmsFees = new TheBankAccountIsDepositedDueToSMSFees(identity.Id, 80000);

        Queue(aNewBankAccountIsOpened, theBankAccountIsDepositedDueToBankFees, theBankAccountIsDepositedDueToSmsFees);
    }

    public void Queue(params IsADomainEvent[] events)
    {
        foreach (var e in events)
            _eventQueue.Enqueue(e);
    }
}

[Fact]
    public void move_to_valid_state_after_being_opened()
    {
        // Context
        var command = new OpenANewBankAccountCommand
        {
            InitialBalance = 10000000
        };

        var initialBalanceThresholdService = new InitialBalanceThresholdService();
        var bankAccountId = BankAccountId.New(Guid.NewGuid().ToString());

        const decimal BankFees = 20000;
        const decimal SmsFees = 80000;

        // Action and Outcome
        InTermsOfAggregateRoot<BankAccount, BankAccountId>
            .IfICreate(() => new BankAccount(bankAccountId, command, initialBalanceThresholdService))
            .ThenIWillExpect(bankAccount=> bankAccount.Balance == command.InitialBalance - (BankFees + SmsFees));
    }

public class BankAccount : IsAnAggregateRoot<BankAccountId>
{
    private readonly Queue<IsADomainEvent> _eventQueue;
    public decimal Balance { get; set; }

    public BankAccount(BankAccountId identity, OpenANewBankAccountCommand cmd
    , InitialBalanceThresholdService service) : base(identity)
    {
        service.Check(cmd.InitialBalance);

        var aNewBankAccountIsOpened = new ANewBankAccountIsOpened(identity.Id, cmd.InitialBalance);
        var theBankAccountIsDepositedDueToBankFees = new TheBankAccountIsDepositedDueToBankFees(identity.Id, 20000);
        var theBankAccountIsDepositedDueToSmsFees = new TheBankAccountIsDepositedDueToSMSFees(identity.Id, 80000);

        Queue(aNewBankAccountIsOpened, theBankAccountIsDepositedDueToBankFees, theBankAccountIsDepositedDueToSmsFees);
    }


    public void Queue(params IsADomainEvent[] events)
    {
        foreach (var e in events)
        {
            _eventQueue.Enqueue(e);
            On((dynamic)e);
        }
    }

    private void On(ANewBankAccountIsOpened @event)
        => Balance = @event.InitialBalance;

    private void On(TheBankAccountIsDepositedDueToBankFees @event)
        => Balance -= @event.Fees;

    private void On(TheBankAccountIsDepositedDueToSMSFees @event)
        => Balance -= @event.Fees;
}

[Fact]
    public void move_to_last_state_after_applying_all_previews_domain_events()
    {
        // Context
        const int InitialBalance = 10000000;
        const decimal BankFees = 20000;
        const decimal SmsFees = 80000;
        
        var bankAccountId = BankAccountId.New(Guid.NewGuid().ToString());
        
        var aNewBankAccountIsOpened = new ANewBankAccountIsOpened(bankAccountId.Id, InitialBalance);
        var theBankAccountIsDepositedDueToBankFees = new TheBankAccountIsDepositedDueToBankFees(bankAccountId.Id, BankFees);
        var theBankAccountIsDepositedDueToSmsFees = new TheBankAccountIsDepositedDueToSMSFees(bankAccountId.Id, SmsFees);
        
        // Action and Outcome
        InTermsOfAggregateRoot<BankAccount, BankAccountId>
            .IfIApplied(aNewBankAccountIsOpened, 
                theBankAccountIsDepositedDueToBankFees, 
                theBankAccountIsDepositedDueToSmsFees)
            .ThenIWillExpect(bankAccount => bankAccount.Balance == InitialBalance - (BankFees + SmsFees));
    }

public BankAccount(Queue<IsADomainEvent> @events)
    {
        foreach (var e in @events)
        {
            On((dynamic)e);
        }
    }