public async Task MakeTransfer(TransferInputModel inputModel, string userId)
{
var outWarehouseId = inputModel.OutWarehouseId;
var inWarehouseId = inputModel.InWarehouseId;
var transferGoods = inputModel.TransferGoods;
// foreach (var goods in transferGoods)
// {
// var outGoodsToChange = this.goodsRepository.All().FirstOrDefault(x => x.Id == goods.Id);
// if (outGoodsToChange != null)
// {
// outGoodsToChange.Quantity -= goods.Quantity;
// outGoodsToChange.WarehouseId = outWarehouseId;
// this.goodsRepository.Update(outGoodsToChange);
// }
// var inGoods = new Good
// {
// SKU = goods.SKU,
// Name = goods.Name,
// Barcode = goods.Barcode,
// MeasureId = goods.MeasureId,
// DeliveryPrice = goods.DeliveryPrice,
// SalePrice = goods.SalePrice,
// Quantity = goods.Quantity,
// WarehouseId = inWarehouseId,
// };
// await this.goodsRepository.AddAsync(inGoods);
// await this.goodsRepository.SaveChangesAsync();
// }
// var transfer = new Transfer
// {
// Date = inputModel.Date,
// InWarehouseId = inWarehouseId,
// OutWarehouseId = outWarehouseId,
// Number = 0,
// TransferGoods = transferGoods,
// UserId = userId,
// };
// await this.transfersRepository.AddAsync(transfer);
// await this.transfersRepository.SaveChangesAsync();
}
public void When_Accumulated_Between_0_And_100000_Should_Be_False(double transferAmount)
{
var transferInput = new TransferInputModel {
transfer_amount = transferAmount,
destination_account_id = "7581233661",
destination_bank = "KBANK",
destination_bank_area = "BKK01",
origin_account_id = "6320445476",
origin_account_balance = 50000,
origin_bank = "KBANK",
origin_bank_area = "BKK01",
origin_account_daily_accumulated_transfer = 95000
};
TransferService transferService = new TransferService();
TransferOutputModel actualResult = transferService.TransferMoney(transferInput);
Assert.Equal("400-03", actualResult.header.code);
}
public void When_TransferAmount_With_Fee_More_Than_Account_Balance_Should_Be_Cant_Transfer()
{
var transferInput = new TransferInputModel {
transfer_amount = 5000,
destination_account_id = "7581233661",
destination_bank = "SCB",
destination_bank_area = "",
origin_account_id = "6320445476",
origin_account_balance = 5000,
origin_bank = "KBANK",
origin_bank_area = "BKK01",
origin_account_daily_accumulated_transfer = 0
};
TransferService transferService = new TransferService();
TransferOutputModel actualResult = transferService.TransferMoney(transferInput);
Assert.Equal("400-04", actualResult.header.code);
}
public void When_TransferAmount_Difference_Bank__Should_Be_Fee_35THB()
{
var transferInput = new TransferInputModel {
transfer_amount = 100,
destination_account_id = "7581233661",
destination_bank = "SCB",
destination_bank_area = "",
origin_account_id = "6320445476",
origin_account_balance = 50000,
origin_bank = "KBANK",
origin_bank_area = "BKK01",
origin_account_daily_accumulated_transfer = 0
};
TransferService transferService = new TransferService();
TransferOutputModel actualResult = transferService.TransferMoney(transferInput);
Assert.Equal("200", actualResult.header.code);
Assert.Equal("35", actualResult.body.fee_amount);
}
public void When_TransferAmount_Between_1_And_20000_Should_Be_Can_Transfer(double transferAmount)
{
var transferInput = new TransferInputModel {
transfer_amount = transferAmount,
destination_account_id = "7581233661",
destination_bank = "KBANK",
destination_bank_area = "BKK01",
origin_account_id = "6320445476",
origin_account_balance = 50000,
origin_bank = "KBANK",
origin_bank_area = "BKK01",
origin_account_daily_accumulated_transfer = 0
};
TransferService transferService = new TransferService();
TransferOutputModel actualResult = transferService.TransferMoney(transferInput);
Assert.Equal("200", actualResult.header.code);
Assert.Equal(transferAmount.ToString(), actualResult.body.transfer_amount);
}
public JsonResult Post([FromBody] TransferInputModel transferDataInput)
{
var transferResult = _service.TransferMoney(transferDataInput);
return(Json(transferResult));
}
public async ValueTask <ActionResult <List <TransactionEntityOutputModel> > > TransferTransactionInsert(TransferInputModel transferInputModel)
{
string URItransfer = $"api/transaction/transfer";
string URIgetSenderBalance = $"api/transaction/balance/{transferInputModel.SenderAccount.Id}";
string URIgetRecipientAccount = $"api/transaction/balance/{transferInputModel.RecipientAccount.Id}";
var senderAccount = await _accountRepository.GetAccountById(transferInputModel.SenderAccount.Id);
var recipientAccount = await _accountRepository.GetAccountById(transferInputModel.RecipientAccount.Id);
if (!senderAccount.IsOkay && recipientAccount.IsOkay)
{
var message = "";
if (!senderAccount.IsOkay)
{
message = $"Transaction failed {senderAccount.ExMessage}";
}
if (!recipientAccount.IsOkay)
{
message += $"Transaction failed {recipientAccount.ExMessage}";
}
return(Problem(message, statusCode: 520));
}
if (senderAccount.RequestData == null)
{
return(NotFound($"SenderAccountId: {transferInputModel.SenderAccount.Id} not found"));
}
if (recipientAccount.RequestData == null)
{
return(NotFound($"RecipientAccountId: {transferInputModel.RecipientAccount.Id} not found"));
}
var senderBalance = await RequestSender.SendRequest <AccountBalanceOutputModel>(_urlOptions.Value.TransactionStoreApiUrl, URIgetSenderBalance, Method.GET);
if (senderBalance == null)
{
return(Problem($"Request failed:", statusCode: 520));
}
transferInputModel.SenderTimeStamp = senderBalance.Data.TimeStamp;
if (senderBalance.Data.Balance < transferInputModel.Amount)
{
return(BadRequest($"Not enough funds to complete the transaction"));
}
var recipientBalance = await RequestSender.SendRequest <AccountBalanceOutputModel>(_urlOptions.Value.TransactionStoreApiUrl, URIgetRecipientAccount, Method.GET);
if (recipientBalance == null)
{
return(Problem($"Request failed:", statusCode: 520));
}
transferInputModel.RecipientTimeStamp = recipientBalance.Data.TimeStamp;
var result = await RequestSender.SendRequest <List <TransactionEntityOutputModel> >(_urlOptions.Value.TransactionStoreApiUrl, URItransfer, Method.POST, transferInputModel);
if (result.StatusCode != System.Net.HttpStatusCode.OK)
{
return(Problem($"Transaction failed: {result.Content}", statusCode: (int)result.StatusCode));
}
return(result.Data);
}
public async ValueTask <ActionResult <TransactionEntityOutputModel> > Transfer(TransferInputModel inputModel)
{
if (inputModel.SenderTimeStamp == null && inputModel.RecipientTimeStamp == null)
{
return(BadRequest("TimeStamp should not be null!"));
}
if (inputModel.RecipientAccount.Id < 1 || inputModel.SenderAccount.Id < 1)
{
return(BadRequest("Incorrect AccountId"));
}
if (inputModel.Amount < 0)
{
return(BadRequest("Deposit amount must be more than zero!"));
}
var dataModels = _mapper.Map <TransferEntities>(inputModel);
var result = await _transactionRepository.Transfer(dataModels);
if (result.IsOkay)
{
return(Ok(_mapper.Map <List <TransactionEntityOutputModel> >(result.RequestData)));
}
if (result.exMessage == "A timestamp constraint violation occurred.")
{
return(Conflict($"Transaction failed: {result.exMessage}"));
}
return(Problem($"Transaction failed {result.exMessage}", statusCode: 520));
}
public async ValueTask <ActionResult <List <long> > > CreateTransferTransaction([FromBody] TransferInputModel transactionModel)
{
var checkingAccountId = await _repo.GetAccountById(transactionModel.AccountId);
if (checkingAccountId.Data is null)
{
return(BadRequest("The account is not found"));
}
var checkingAccountIdReceiver = await _repo.GetAccountById(transactionModel.AccountIdReceiver);
if (checkingAccountIdReceiver.Data is null)
{
return(BadRequest("The account of receiver is not found"));
}
if (transactionModel.Amount <= 0)
{
return(BadRequest("The amount is missing"));
}
var currencyId = await _repo.GetCurrencyByAccountId(transactionModel.AccountId);
transactionModel.CurrencyId = currencyId.Data;
var receiver = await _repo.GetCurrencyByAccountId(transactionModel.AccountIdReceiver);
transactionModel.ReceiverCurrencyId = receiver.Data;
var restRequest = new RestRequest("transaction/transfer", Method.POST, DataFormat.Json);
restRequest.AddJsonBody(transactionModel);
var result = await _restClient.ExecuteAsync <List <long> >(restRequest);
string code = Convert.ToString((CurrenciesCode)transactionModel.CurrencyId.Value);
_logger.Info($"Create new TransferTransaction from Account {transactionModel.AccountId} to Account {transactionModel.AccountIdReceiver}: " +
$"{transactionModel.Amount} {code}");
return(MakeResponse(result));
}
public async ValueTask <ActionResult <List <long> > > CreateTransferTransaction([FromBody] TransferInputModel transactionModel)
{
if (await _repo.GetById(transactionModel.AccountId) is null)
{
return(BadRequest("The account is not found"));
}
if (transactionModel.CurrencyId <= 0)
{
return(BadRequest("The currency is missing"));
}
string badRequest = await FormBadRequest(transactionModel.Amount, transactionModel.AccountId);
if (!string.IsNullOrWhiteSpace(badRequest))
{
return(Problem("Not enough money on the account", statusCode: 418));
}
var transfer = _mapper.Map <TransferTransactionDto>(transactionModel);
var dataWrapper = await _repo.AddTransfer(transfer);
_logger.Info($"Create Transfer Transaction with Amount = {transfer.Amount} {transfer.Currency} from AccountId [{transfer.AccountId}] for AccountId [{transfer.AccountIdReceiver}]");
return(MakeResponse(dataWrapper));
}
