private void Handle(PaymentReceived evt)
{
var saga = this.repo.GetById <ShippingSaga>(evt.OrderId);
saga.ConfirmPayment(dispatcher);
this.repo.Save(saga);
}
public async Task DailyUsageAllowance_IsUpdated_EveryTime_A_New_PaymentReceived_Comes()
{
var initialLoan = _loansProvider.GetLoan(EXISTING_CUSTOMER_ID);
var payingHalfOfWhatsLeft = initialLoan.RemainingAmountToPay() / 2;
var firstPayment = new PaymentReceived()
{
CustomerId = EXISTING_CUSTOMER_ID,
PaymentAmount = payingHalfOfWhatsLeft,
};
var loanAfterFirstPayment = await _loansProvider.UpdateLoanAsync(firstPayment);
var dailyAllowance = loanAfterFirstPayment.DailyUsageAllowance();
dailyAllowance.Should().Be(loanAfterFirstPayment.TotalLoanPayed / loanAfterFirstPayment.DailyRate);
dailyAllowance.Should().BeGreaterThan(0);
var secondPayment = new PaymentReceived()
{
CustomerId = EXISTING_CUSTOMER_ID,
PaymentAmount = payingHalfOfWhatsLeft,
};
var loanAfterLastPayment = await _loansProvider.UpdateLoanAsync(secondPayment);
var updatedDailyAllowance = loanAfterLastPayment.DailyUsageAllowance();
updatedDailyAllowance.Should().BeGreaterThan(dailyAllowance);
updatedDailyAllowance.Should().Be(loanAfterFirstPayment.TotalLoanPayed / loanAfterFirstPayment.DailyRate);
updatedDailyAllowance.Should().BeGreaterThan(0);
loanAfterFirstPayment.State().Should().Be(LoanState.FINISHED);
}
public void Handle(PaymentReceived evt)
{
var process = this.repo.GetById <ShippingProcess>(evt.OrderId);
process.ConfirmPayment(dispatcher);
this.repo.Save(process);
}
/// Updates Loan
/// Assume deduplication of messages is handled somewhere else
/// ASK PM: What do we do with Payments received for loans that don't exists or are inactive / fully paid?
public async Task <Loan> UpdateLoanAsync(PaymentReceived paymentReceived)
{
if (ActiveLoanExists(paymentReceived.CustomerId))
{
var loan = GetLoan(paymentReceived.CustomerId);
loan.UpdateTotalLoanPayed(paymentReceived.PaymentAmount);
_loans[loan.CustomerId] = loan;
if (loan.State() == LoanState.FINISHED)
{
var loanFinished = new LoanFinished(loan.CustomerId, paymentReceived.CorrelationId);
await _eventSender.SendLoanFinishedAsync(loanFinished);
}
else
{
var loanUpdated = new LoanUpdated(paymentReceived.CustomerId, loan.DailyUsageAllowance(), paymentReceived.CorrelationId);
await _eventSender.SendLoanUpdatedAsync(loanUpdated);
}
return(loan);
}
return(null);
}
public void FromEmail()
{
string emailBody = File.ReadAllText(@"C:\Users\perscholas_student\Desktop\uipath\CaseStudy\EmailProcessing\SendMail\PaymentReceived\Payment Received - Pericles Comidas clásicas.txt");
MailMessage email = new MailMessage
{
Subject = "Payment Received",
Body = emailBody
};
PaymentReceived notice = PaymentReceived.FromEmail(email);
}
public void FromEmail()
{
foreach (string fpath in Directory.GetFiles("PaymentReceived", "*.txt"))
{
MailMessage email = new MailMessage
{
Subject = "Payment Received",
Body = File.ReadAllText(fpath)
};
PaymentReceived notice = PaymentReceived.FromEmail(email);
}
}
public string getTransactionType(string description)
{
description = description.ToUpper();
if (Deposit.Any(n => description.IndexOf(n) != -1))
{
return(Enumerators.TransactionType.Deposit.ToString());
}
else if (PaymentMade.Any(n => description.IndexOf(n) != -1))
{
return(Enumerators.TransactionType.PaymentMade.ToString());
}
else if (PaymentReceived.Any(n => description.IndexOf(n) != -1))
{
return(Enumerators.TransactionType.PaymentReceived.ToString());
}
else if (PointOfSale.Any(n => description.IndexOf(n) != -1))
{
return(Enumerators.TransactionType.PointOfSale.ToString());
}
else if (Withdrawal.Any(n => description.IndexOf(n) != -1))
{
return(Enumerators.TransactionType.Withdrawal.ToString());
}
else if (OverseePurchase.Any(n => description.IndexOf(n) != -1))
{
return(Enumerators.TransactionType.OverseePurchase.ToString());
}
else if (TransactionCharges.Any(n => description.IndexOf(n) != -1))
{
return(Enumerators.TransactionType.TransactionCharges.ToString());
}
else if (AdminCharges.Any(n => description.IndexOf(n) != -1))
{
return(Enumerators.TransactionType.AdminCharges.ToString());
}
else if (PrepaidAirtime.Any(n => description.IndexOf(n) != -1))
{
return(Enumerators.TransactionType.PrepaidAirtime.ToString());
}
else if (MonthlyAccountCharges.Any(n => description.IndexOf(n) != -1))
{
return(Enumerators.TransactionType.MonthlyAccountCharges.ToString());
}
// Extend transaction type here
else
{
return(Enumerators.TransactionType.Unknown.ToString());
}
}
public async Task UpdateLoan_Sends_LoanFinishedEvent_When_LoanIs_Finished()
{
var initialLoan = _loansProvider.GetLoan(EXISTING_CUSTOMER_ID);
var paymentReceived = new PaymentReceived()
{
CustomerId = EXISTING_CUSTOMER_ID,
PaymentAmount = initialLoan.RemainingAmountToPay(),
};
var expectedLoan = await _loansProvider.UpdateLoanAsync(paymentReceived);
_eventSender.Verify(y => y.SendLoanUpdatedAsync(It.IsAny <LoanUpdated>()), Times.Never);
_eventSender.Verify(y => y.SendLoanFinishedAsync(It.IsAny <LoanFinished>()), Times.Once);
}
public void Handle(PaymentReceived @event)
{
var repo = this.repositoryFactory.Invoke();
using (repo as IDisposable)
{
lock (lockObject)
{
var saga = repo.Find <RegistrationProcessSaga>(@event.OrderId);
saga.Handle(@event);
repo.Save(saga);
}
}
}
public bool CreatePaymentReceived(PaymentReceivedCreate model)
{
using (var context = new ApplicationDbContext())
{
var paymentReceivedEntity = new PaymentReceived()
{
SourceId = context.Sources.SingleOrDefault(c => c.Name == model.SourceName && c.UserId == _userId).Id,
MonthId = context.Months.SingleOrDefault(m => m.BeginDate.Month == DateTime.Now.Month && m.BeginDate.Year == DateTime.Now.Year && m.UserId == _userId).Id,
Amount = model.Amount,
PaymentDate = DateTime.Now,
UserId = _userId
};
context.PaymentsReceived.Add(paymentReceivedEntity);
return(context.SaveChanges() == 1);
}
}
public void SeedPaymentReceivedForTestUser(string sourceName, decimal amount, DateTime paymentDate)
{
using (var context = new ApplicationDbContext())
{
var paymentReceived = new PaymentReceived()
{
SourceId = context.Sources.SingleOrDefault(c => c.Name == sourceName && c.UserId == _userId).Id,
MonthId = context.Months.SingleOrDefault(m => m.BeginDate.Month == paymentDate.Month && m.BeginDate.Year == paymentDate.Year && m.UserId == _userId).Id,
Amount = amount,
PaymentDate = paymentDate,
UserId = _userId
};
context.PaymentsReceived.Add(paymentReceived);
context.SaveChanges();
}
}
public void Handle(PaymentReceived message)
{
if (this.State == SagaState.AwaitingPayment)
{
this.State = SagaState.Completed;
this.AddCommand(new CommitSeatReservation
{
ReservationId = this.ReservationId,
ConferenceId = message.ConferenceId
});
}
else
{
throw new InvalidOperationException();
}
}
public void FromEmail()
{
string emailBody = File.ReadAllText("PaymentReceived\\Payment Received - Reggiani Caseifici.txt");
MailMessage email = new MailMessage
{
Subject = "Payment Received",
Body = emailBody
};
DateTime myOrderDate = new DateTime(2019, 3, 10);
PaymentReceived notice = PaymentReceived.FromEmail(email);
Assert.AreEqual(462.48m, notice.Amount);
Assert.AreEqual(11062m, notice.OrderNumber);
Assert.AreEqual(myOrderDate, notice.OrderDate);
Assert.AreEqual(871m, notice.CheckNumber);
}
public void Handle(PaymentReceived @event)
{
var repo = this.repositoryFactory.Invoke();
using (repo as IDisposable)
{
lock (lockObject)
{
var saga = repo.Query <RegistrationProcessSaga>().FirstOrDefault(x => x.OrderId == @event.OrderId);
if (saga != null)
{
saga.Handle(@event);
repo.Save(saga);
}
}
}
}
public void FromEmail()
{
string emailBody = File.ReadAllText("PaymentReceived\\Payment Received - Bólido Comidas preparadas.txt");
MailMessage email = new MailMessage
{
Subject = "Payment Received",
Body = emailBody
};
DateTime myOrderDate = new DateTime(2019, 3, 12);
PaymentReceived notice = PaymentReceived.FromEmail(email);
Assert.AreEqual(545.98M, notice.Amount);
Assert.AreEqual(11078, notice.OrderNumber);
Assert.AreEqual(myOrderDate, notice.OrderDate);
Assert.AreEqual(495, notice.CheckNumber);
}
public void TestAllEmails()
{
foreach (string fpath in Directory.GetFiles("PaymentReceived", "*.txt"))
{
MailMessage msg = new MailMessage
{
Subject = "Payment Received",
Body = File.ReadAllText(fpath)
};
Console.WriteLine(fpath);
PaymentReceived notice = PaymentReceived.FromEmail(msg);
Assert.IsTrue(notice.Amount > 0);
Assert.IsTrue(notice.OrderNumber > 0);
Assert.IsNotNull(notice.CheckNumber);
Assert.IsNotNull(notice.OrderDate);
Assert.IsNotNull(notice.CheckNumber);
Assert.IsTrue(notice.CheckNumber > 0);
}
}
public async Task UpdateLoan_When_PaymentsComes_With_Not_AllRemainingAmount_Sets_Loan_As_Unfinished()
{
var initialLoan = _loansProvider.GetLoan(EXISTING_CUSTOMER_ID);
initialLoan.State().Should().Be(LoanState.UNFINISHED);
initialLoan.TotalLoanPayed.Should().BeLessThan(initialLoan.TotalLoanAmount);
var paymentReceived = new PaymentReceived()
{
CustomerId = EXISTING_CUSTOMER_ID,
PaymentAmount = initialLoan.RemainingAmountToPay() - 1,
};
var expectedLoan = await _loansProvider.UpdateLoanAsync(paymentReceived);
expectedLoan.State().Should().Be(LoanState.UNFINISHED);
expectedLoan.TotalLoanPayed.Should().BeLessThan(expectedLoan.TotalLoanAmount);
expectedLoan.CustomerId.Should().Be(paymentReceived.CustomerId);
}
private void GeneratePayments()
{
for (int i = 0; i < 5; i++)
{
var p = new Payment
{
Amount = $"{i}",
AssetCode = "B1",
AssetIssuer = "AssetIssuerId",
AssetType = "Native",
CreatedAt = DateTime.Now.ToString(),
PagingToken = $"{i}",
From = $"FromAccountId{i}",
To = $"ToAccountId{i}",
TransactionHash = $"TransactionHash{i}"
};
PaymentReceived?.Invoke(this, new PaymentEventArgs(p));
}
}
public Order When(PaymentReceived @event)
{
Payed = true;
return(this);
}
public void Handle(PaymentReceived message)
{
Assert.AreEqual(OrderState.Billed, Data.State);
Data.State = OrderState.Paid;
}
public async Task HandleAsync(PaymentReceived @event)
{
await ExecuteSaveAsync(@event.AggregateId, model => model.Pay());
}
public async Task HandleAsync(PaymentReceived @event)
{
await ExecuteAsync(@event.AggregateId, shippingSaga => shippingSaga.ConfirmPayment());
}
public void Apply(PaymentReceived evt)
{
this.paidFor = true;
}
public Order When(PaymentReceived @event) => this;
private void Apply(PaymentReceived e)
{
this.Payment = new Payment(e.PaymentId, e.PaymentDate, this.PayableId);
}
public static ICommand When(PaymentReceived @event, Order state) => Ship(state.When(@event));
