public void Update(Domain.Models.Transaction entity)
{
Transaction entityToUpdate = this.context.Transactions.First(x => x.TransactionID == entity.TransactionID);
this.mapper.Map(entity, entityToUpdate);
this.context.SaveChanges();
}
public async Task SaveFinancialTransaction_DebitCreditSum_Validation(
Domain.Models.AccountingEntry.EntrySide side1,
int amount1,
Domain.Models.AccountingEntry.EntrySide side2,
int amount2,
bool isValid)
{
var ledgerId = 666;
var model = new Domain.Models.Transaction
{
Description = "Test",
TransactionDate = DateTime.UtcNow,
AccountingEntries = new List <Domain.Models.AccountingEntry>
{
new Domain.Models.AccountingEntry {
Amount = amount1, Side = side1, AccountId = 1
},
new Domain.Models.AccountingEntry {
Amount = amount2, Side = side2, AccountId = 2
}
}
};
var request = new SaveTransactionRequest(ledgerId, model);
var validator = new SaveTransactionValidator();
var validationResult = await validator.ValidateAsync(request);
Assert.AreEqual(isValid, validationResult.IsValid);
}
public int Insert(Domain.Models.Transaction entity)
{
Transaction entityToInsert = this.context.Transactions.Create();
this.mapper.Map(entity, entityToInsert);
this.context.Transactions.Add(entityToInsert);
this.context.SaveChanges();
return(entityToInsert.TransactionID);
}
public void Add(Domain.Models.Transaction transaction)
{
if (transaction == null)
{
return;
}
transaction.Date = DateTime.Now;
this.transactionRepository.Add(transaction);
}
public async Task <Result> PerformTransactionAsync(Domain.Models.Transaction newTransaction, IRepositoriesHandler repositoriesHandler, IResourcesProvider resourcesProvider)
{
var result = new Result();
result.Success = newTransaction.Amount > 0;
if (!result.Success)
{
result.Error = resourcesProvider.GetGeneralResource("IncAmount");
return(result);
}
var fromCreditCard = await repositoriesHandler.СreditCardRepository.GetByIdAsync(newTransaction.FromCreditCardID);
result.Success = fromCreditCard.Amount > newTransaction.Amount;
if (!result.Success)
{
result.Error = resourcesProvider.GetGeneralResource("TranOutOfFunds");
return(result);
}
var toCreditCard = await repositoriesHandler.СreditCardRepository.GetByIdAsync(newTransaction.ToCreditCardID);
if (fromCreditCard.CreditCardID == toCreditCard.CreditCardID)
{
result.Success = false;
result.Error = resourcesProvider.GetGeneralResource("SelectDifCards");
return(result);
}
try
{
using (var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
fromCreditCard.Amount -= newTransaction.Amount;
await repositoriesHandler.СreditCardRepository.UpdateAsync(fromCreditCard);
toCreditCard.Amount += newTransaction.Amount;
await repositoriesHandler.СreditCardRepository.UpdateAsync(toCreditCard);
newTransaction.Date = DateTime.Now;
await repositoriesHandler.TransactionRepository.InsertAsync(newTransaction);
scope.Complete();
}
result.Success = true;
result.SuccessMessage = resourcesProvider.GetGeneralResource("TranOk");
return(result);
}
catch (Exception ex)
{
result.Success = false;
result.Error = $"{resourcesProvider.GetGeneralResource("TranFail")} {ex.Message}.";
return(result);
}
}
public async Task <int> InsertAsync(Domain.Models.Transaction entity)
{
Transaction entityToInsert = this.context.Transactions.Create();
this.mapper.Map(entity, entityToInsert);
this.context.Transactions.Add(entityToInsert);
await this.context.SaveChangesAsync();
return(entityToInsert.TransactionID);
}
public async Task <Result> GenerateCardRandomTransactionsAsync(int toCardID, IRepositoriesHandler repositoriesHandler, IResourcesProvider resourcesProvider)
{
var result = new Result();
if (toCardID == 0)
{
result.Success = false;
result.Error = resourcesProvider.GetGeneralResource("CCIdNull");
return(result);
}
var cards = await repositoriesHandler.СreditCardRepository.GetCollectionForRandomTranAsync(toCardID);
if (cards.Count == 0)
{
result.Success = false;
result.Error = resourcesProvider.GetGeneralResource("NotEnCards");
return(result);
}
int counter = 0;
var transactionResult = new Result();
foreach (var card in cards)
{
Random rnd = new Random();
var transaction = new Domain.Models.Transaction();
transaction.Amount = rnd.Next(1, (int)card.Amount);
transaction.Comment = resourcesProvider.GetGeneralResource("RndTran");
transaction.Date = DateTime.Now;
transaction.FromCreditCardID = card.CreditCardID;
transaction.ToCreditCardID = toCardID;
transactionResult = await this.PerformTransactionAsync(transaction, repositoriesHandler, resourcesProvider);
if (transactionResult.Success)
{
counter++;
}
}
if (counter > 0)
{
result.Success = true;
result.SuccessMessage = resourcesProvider.GetGeneralResource("TransGenDone");
return(result);
}
else
{
result.Success = false;
result.Error = resourcesProvider.GetGeneralResource("TranAllCCOutOfFunds");
return(result);
}
}
public async Task SaveFinancialTransaction_Failure_NoParentLedger()
{
var ledgerId = 666;
var model = new Domain.Models.Transaction
{
Description = "Test",
TransactionDate = DateTime.UtcNow,
AccountingEntries = new List <Domain.Models.AccountingEntry>
{
new Domain.Models.AccountingEntry {
Amount = 100, Side = Domain.Models.AccountingEntry.EntrySide.Credit
},
new Domain.Models.AccountingEntry {
Amount = 100, Side = Domain.Models.AccountingEntry.EntrySide.Debit
}
}
};
var request = new SaveTransactionRequest(ledgerId, model);
var handler = new SaveTransactionRequestHandler(_trackingContext, Mapper.Instance);
var result = await handler.Handle(request, default(CancellationToken));
}
public async Task SaveTransaction_Success()
{
var expectedResultCount = 1;
var dataGenerationResult1 = _trackingContext.AddTestData <Domain.Entities.Ledger>(expectedResultCount);
var dataGenerationResult2 = _trackingContext.AddTestData <Domain.Entities.Transaction>(expectedResultCount);
Assert.IsTrue(dataGenerationResult1.Item1);
Assert.IsTrue(dataGenerationResult2.Item1);
var ledgerId = dataGenerationResult1.Item2[0];
var model = new Domain.Models.Transaction
{
Description = "Test",
TransactionDate = DateTime.UtcNow,
AccountingEntries = new List <Domain.Models.AccountingEntry>
{
new Domain.Models.AccountingEntry
{
Amount = 100,
Side = Domain.Models.AccountingEntry.EntrySide.Credit,
AccountId = 1
},
new Domain.Models.AccountingEntry
{
Amount = 100,
Side = Domain.Models.AccountingEntry.EntrySide.Debit,
AccountId = 1
}
}
};
var request = new SaveTransactionRequest(ledgerId, model);
var handler = new SaveTransactionRequestHandler(_trackingContext, Mapper.Instance);
var result = await handler.Handle(request, default(CancellationToken));
Assert.AreEqual(result, Unit.Value);
}
public void Update(Domain.Models.Transaction entity)
{
throw new NotImplementedException();
}
public async Task Create(int id, [FromBody] Domain.Models.Transaction model)
{
await _mediator.Send(new SaveTransactionRequest(id, model));
}
