public async Task <IActionResult> FundWallet([FromBody] FundWalletDTO model, string Id)
{
if (!ModelState.IsValid)
{
return(BadRequest(ResponseMessage.Message("Bad request", errors: new { message = ModelState })));
}
var isValid = CurrencyConverter.ValidateCurrencyInput(model.TransactionCurrency);
if (!isValid)
{
return(BadRequest(ResponseMessage.Message("Error", errors: new { message = "Invalid currency input" })));
}
var wallet = await _walletRepository.GetWalletByWalletId(Id);
if (wallet == null)
{
return(NotFound(ResponseMessage.Message("Not found", new { message = $"Wallet with id {Id} was not found" })));
}
Transaction transaction = new Transaction
{
TransactionId = Guid.NewGuid().ToString(),
TransactionType = "Credit",
WalletId = wallet.WalletId,
Amount = model.Amount,
TransactionCurrency = model.TransactionCurrency
};
try
{
await _transactionRepository.AddTransaction(transaction);
}
catch (Exception e)
{
_logger.LogError(e.Message);
return(BadRequest(ResponseMessage.Message("Bad request", errors: new { message = "Failed to add transaction" })));
}
try
{
var walletOwner = await _userManager.FindByIdAsync(wallet.ApplicationUserId);
if (walletOwner == null)
{
return(NotFound(ResponseMessage.Message("Not found", new { message = $"User with id {wallet.ApplicationUserId} was not found" })));
}
UserMainCurrencyDetail mainCurrencyDetail;
try
{
mainCurrencyDetail = await _userMainCurrencyRepository.GetMainCurrencyByUserId(walletOwner.Id);
}
catch (Exception e)
{
await _transactionRepository.DeleteTransaction(transaction);
_logger.LogError(e.Message);
return(BadRequest(ResponseMessage.Message("Data access error", errors: new { message = "Could not access record from data source" })));
}
var mainCurrency = mainCurrencyDetail.MainCurrency;
decimal convertedAmount;
try
{
convertedAmount = await CurrencyConverter.ConvertCurrency(model.TransactionCurrency, mainCurrency, model.Amount);
}
catch (Exception e)
{
return(BadRequest(ResponseMessage.Message("Error", errors: new { message = e.Message })));
}
wallet.Balance += convertedAmount;
await _walletRepository.UpdateWallet(wallet);
return(Ok(ResponseMessage.Message("Success! Wallet funded")));
}
catch (Exception e)
{
await _transactionRepository.DeleteTransaction(transaction);
_logger.LogError(e.Message);
return(BadRequest(ResponseMessage.Message("Bad request", errors: new { message = "Failed to fund wallet" })));
}
}
public async Task <IActionResult> ChangeMainCurrency([FromBody] ChangeMainCurrencyDTO model, string Id)
{
if (!ModelState.IsValid)
{
return(BadRequest(ResponseMessage.Message("Bad request", errors: new { message = ModelState })));
}
if (string.IsNullOrWhiteSpace(Id))
{
return(BadRequest(ResponseMessage.Message("Bad request", errors: new { message = "Invalid Id" })));
}
var user = await _userManager.FindByIdAsync(Id);
if (user == null)
{
return(NotFound(ResponseMessage.Message("Not found", new { message = $"User with id {Id} was not found" })));
}
var userRoles = await _userManager.GetRolesAsync(user);
if (userRoles[0] == "Admin")
{
return(BadRequest(ResponseMessage.Message("Bad request", new { message = "User is an Admin and has no main currency" })));
}
var isValid = CurrencyConverter.ValidateCurrencyInput(model.NewMainCurrency);
if (!isValid)
{
return(BadRequest(ResponseMessage.Message("Error", errors: new { message = "Invalid currency input" })));
}
UserMainCurrencyDetail mainCurrencyDetails;
try
{
mainCurrencyDetails = await _userMainCurrencyRepository.GetMainCurrencyByUserId(user.Id);
}
catch (Exception e)
{
_logger.LogError(e.Message);
return(BadRequest(ResponseMessage.Message("Data access error", errors: new { message = "Could not access record from data source" })));
}
try
{
mainCurrencyDetails.MainCurrency = model.NewMainCurrency;
await _userMainCurrencyRepository.UpdateMainCurrency(mainCurrencyDetails);
}
catch (Exception e)
{
_logger.LogError(e.Message);
return(BadRequest(ResponseMessage.Message("Bad request", errors: new { message = "Failed to update main currency" })));
}
if (userRoles[0] == "Noob")
{
var wallets = await _walletRepository.GetWalletsByUserId(user.Id);
var wallet = wallets.ToList()[0];
var oldCurrency = wallet.WalletCurrency;
try
{
wallet.WalletCurrency = model.NewMainCurrency;
decimal amount;
try
{
amount = await CurrencyConverter.ConvertCurrency(oldCurrency, model.NewMainCurrency, wallet.Balance);
}
catch (Exception e)
{
return(BadRequest(ResponseMessage.Message("Error", errors: new { message = e.Message })));
}
wallet.Balance = amount;
await _walletRepository.UpdateWallet(wallet);
}
catch (Exception e)
{
mainCurrencyDetails.MainCurrency = oldCurrency;
await _userMainCurrencyRepository.UpdateMainCurrency(mainCurrencyDetails);
_logger.LogError(e.Message);
return(BadRequest(ResponseMessage.Message("Bad request", errors: new { message = "Failed to update wallet" })));
}
}
return(Ok(ResponseMessage.Message("Success", data: new { message = "Updated Successfully!" })));
}
public async Task <IActionResult> ApproveTransaction(string Id)
{
if (string.IsNullOrWhiteSpace(Id))
{
return(BadRequest(ResponseMessage.Message("Invalid input", errors: new { message = "Id should not be null or empty or whitespace" })));
}
Transaction transaction;
try
{
transaction = await _transactionRepository.GetTransactionByTransactionId(Id);
}
catch (Exception e)
{
_logger.LogError(e.Message);
return(BadRequest(ResponseMessage.Message("Data access error", errors: new { message = "Could not access record from data source" })));
}
if (transaction.TransactionStatus == "approved")
{
return(BadRequest(ResponseMessage.Message("Bad request", errors: new { message = "Transaction is already approved" })));
}
var isValid = CurrencyConverter.ValidateCurrencyInput(transaction.TransactionCurrency);
if (!isValid)
{
return(BadRequest(ResponseMessage.Message("Error", errors: new { message = "Invalid currency input" })));
}
Wallet wallet;
UserMainCurrencyDetail mainCurrencyDetail;
try
{
wallet = await _walletRepository.GetWalletByWalletId(transaction.WalletId);
mainCurrencyDetail = await _userMainCurrencyRepository.GetMainCurrencyByUserId(wallet.ApplicationUserId);
}
catch (Exception e)
{
_logger.LogError(e.Message);
return(BadRequest(ResponseMessage.Message("Data access error", errors: new { message = "Could not access record from data source" })));
}
try
{
var mainCurrency = mainCurrencyDetail.MainCurrency;
decimal convertedAmount;
try
{
convertedAmount = await CurrencyConverter.ConvertCurrency(transaction.TransactionCurrency, mainCurrency, transaction.Amount);
}
catch (Exception e)
{
return(BadRequest(ResponseMessage.Message("Error", errors: new { message = e.Message })));
}
if (transaction.TransactionType == "Credit")
{
wallet.Balance += convertedAmount;
}
else
{
if (wallet.Balance >= convertedAmount)
{
wallet.Balance -= convertedAmount;
}
else
{
return(BadRequest(ResponseMessage.Message("Bad request", errors: new { message = "Insufficient funds" })));
}
}
await _walletRepository.UpdateWallet(wallet);
try
{
transaction.TransactionStatus = "approved";
await _transactionRepository.UpdateTransaction(transaction);
}
catch (Exception)
{
if (transaction.TransactionType == "Credit")
{
wallet.Balance -= convertedAmount;
}
else
{
wallet.Balance += convertedAmount;
}
await _walletRepository.UpdateWallet(wallet);
return(BadRequest(ResponseMessage.Message("Bad request", errors: new { message = "Failed to approve transaction" })));
}
}
catch (Exception e)
{
await _transactionRepository.DeleteTransaction(transaction);
_logger.LogError(e.Message);
return(BadRequest(ResponseMessage.Message("Bad request", errors: new { message = "Failed to fund wallet" })));
}
return(Ok(ResponseMessage.Message("Success! Transaction approved")));
}
