private async Task <bool> ValidateInput(Transaction transaction)
{
if (transaction.WalletName == null)
{
transaction.AddError(nameof(TransactionValidator), nameof(transaction.WalletName), ErrorCode.WalletNameInvalid);
return(false);
}
if (transaction.CategoryName == null)
{
transaction.AddError(nameof(TransactionValidator), nameof(transaction.CategoryName), ErrorCode.CategoryNameInvalid);
return(false);
}
if (transaction.Amount.ToString() == null)
{
transaction.AddError(nameof(TransactionValidator), nameof(transaction.Amount), ErrorCode.AmountEmpty);
return(false);
}
if (transaction.Amount <= 0)
{
transaction.AddError(nameof(TransactionValidator), nameof(transaction.Amount), ErrorCode.AmountInvalid);
return(false);
}
if (transaction.Date == null)
{
transaction.AddError(nameof(TransactionValidator), nameof(transaction.Date), ErrorCode.DateInvalid);
return(false);
}
return(true);
}
public async Task <Transaction> Update(Transaction transaction)
{
if (transaction == null)
{
return(null);
}
if (!await TransactionValidator.Update(transaction))
{
return(transaction);
}
using (UnitOfWork.Begin())
{
try
{
await UnitOfWork.TransactionRepository.Update(transaction);
await UnitOfWork.Commit();
return(await this.UnitOfWork.TransactionRepository.Get(transaction.Id));
}
catch (Exception ex)
{
await UnitOfWork.Rollback();
transaction.AddError(nameof(TransactionService), nameof(transaction.Id), CommonEnum.ErrorCode.SystemError);
return(transaction);
}
}
}
public async Task <Transaction> Delete(Transaction transaction)
{
if (!await TransactionValidator.Delete(transaction))
{
return(transaction);
}
using (UnitOfWork.Begin())
{
try
{
//var transactionB = await UnitOfWork.TransactionRepository.Get(transaction.Id);
await UnitOfWork.TransactionRepository.Delete(transaction);
await UnitOfWork.Commit();
}
catch (Exception ex)
{
await UnitOfWork.Rollback();
transaction.AddError(nameof(TransactionService), nameof(Transaction.Id), CommonEnum.ErrorCode.SystemError);
}
}
return(transaction);
}
public async Task <Transaction> Create(Transaction transaction)
{
if (!await TransactionValidator.Create(transaction))
{
return(transaction);
}
using (UnitOfWork.Begin())
{
try
{
CategoryFilter categoryFilter = new CategoryFilter
{
Name = new StringFilter {
Equal = transaction.CategoryName
}
};
Category category = await UnitOfWork.CategoryRepository.Get(categoryFilter);
WalletFilter walletFilter = new WalletFilter
{
Name = new StringFilter {
Equal = transaction.WalletName
},
UserId = new GuidFilter {
Equal = transaction.UserId
}
};
Wallet wallet = await UnitOfWork.WalletRepository.Get(walletFilter);
transaction.Id = Guid.NewGuid();
transaction.WalletId = wallet.Id;
transaction.CategoryId = category.Id;
if (category.Type == CategoryType.Inflow)
{
wallet.Balance += transaction.Amount;
}
else
{
wallet.Balance -= transaction.Amount;
}
await UnitOfWork.WalletRepository.Update(wallet);
await UnitOfWork.TransactionRepository.Create(transaction);
await UnitOfWork.Commit();
}
catch (Exception ex)
{
await UnitOfWork.Rollback();
transaction.AddError(nameof(TransactionService), nameof(Transaction.Id), CommonEnum.ErrorCode.SystemError);
}
}
return(transaction);
}
private async Task <bool> ValidateId(Transaction transaction)
{
TransactionFilter transactionFilter = new TransactionFilter
{
Skip = 0,
Take = int.MaxValue,
Id = new GuidFilter {
Equal = transaction.Id
},
OrderBy = TransactionOrder.Id,
OrderType = OrderType.ASC
};
int count = await unitOfWork.TransactionRepository.Count(transactionFilter);
if (count == 0)
{
transaction.AddError(nameof(TransactionValidator), nameof(transaction.Id), ErrorCode.IdNotFound);
}
return(count == 1);
}
