private static Transaction MapTransactionFromInput(TransactionInputModel inputTransaction)
{
var transaction = new Transaction();
transaction.ConfirmationDate = DateTime.Now;
transaction.Customer = new Customer();
transaction.Customer.IdentificationNumber = inputTransaction.CustomerId;
transaction.Customer.Email = inputTransaction.Email;
transaction.Customer.Name = inputTransaction.CustomerName;
transaction.Customer.PhoneNumber = inputTransaction.CustomerPhoneNumber;
transaction.StartDate = DateTime.Now;
var transactionDetails = new List <TransactionTicketDetail>();
foreach (var detail in inputTransaction.Tickets)
{
transactionDetails.Add(new TransactionTicketDetail()
{
TicketTypeCode = detail.TicketCode,
Quantity = detail.Quantity
});
}
transaction.Details = transactionDetails;
return(transaction);
}
public async Task <PaymentProviderForm> SaveInitialTransaction(TransactionInputModel inputTransaction)
{
await ValidateTransaction(inputTransaction);
Transaction transaction = MapTransactionFromInput(inputTransaction);
context.Transactions.Add(transaction);
await context.SaveChangesAsync();
context.Entry(transaction).State = EntityState.Detached;
var savedTransaction = await context.Transactions
.Include(transac => transac.Customer)
.Include(transac => transac.Details)
.ThenInclude(detail => detail.TicketType)
.AsNoTracking()
.SingleOrDefaultAsync(m => m.Id == transaction.Id);
savedTransaction.TotalValue = savedTransaction.GetTotalValue();
var form = this.paymentProvider.GetPaymentForm(savedTransaction);
savedTransaction.Signature = form.Signature;
savedTransaction.IsTestTransaction = form.Test.Equals("1");
context.Entry(savedTransaction).State = EntityState.Modified;
await context.SaveChangesAsync();
return(form);
}
public async Task <ActionResult <string> > ExecutePayPalPayment([FromBody] ExecuteInputModel executeInputModel, long accountId)
{
var token = GetPayPalToken().Value;
_payPalClient.AddDefaultHeader("Authorization", $"Bearer {token}");
var restRequest = new RestRequest($"{PaypalOptions.paymentUrl}/{PaypalOptions.paymentId}/execute/", Method.POST, DataFormat.Json);
restRequest.AddJsonBody(new { payer_id = executeInputModel.payerId });
var executeOutputModel = _payPalClient.Execute <ExecuteOutputModel>(restRequest);
if ((int)executeOutputModel.StatusCode == 200)
{
var totalAmount = Decimal.Parse(executeOutputModel.Data.transactions[0].amount.total, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture);
var transactionModel = new TransactionInputModel();
transactionModel.AccountId = accountId;
transactionModel.Amount = totalAmount;
var result = await _transaction.CreateDepositTransaction(transactionModel);
if (result.Value == 0)
{
return(Ok("Операция выполнена"));
}
else
{
var refund = new RestRequest($"payments/sale/{executeOutputModel.Data.transactions[0].related_resources[0].sale.id}/refund", Method.POST, DataFormat.Json);
var refundId = _payPalClient.Execute <RefundOutputModel>(refund).Data.id;
_logger.Info($"Payment was refund with RefundId [{refundId}]");
return(BadRequest($"Payment was refund, refundId: {refundId}"));
}
}
_logger.Info($"418.все печально(((");
return(BadRequest("418.все печально((("));
}
public async Task <IActionResult> Create([FromBody] TransactionInputModel model)
{
var result = await this.transactions.Create(model, this.currentUser.Id);
if (!result.Succeeded)
{
return(this.BadRequest(result.Errors));
}
return(this.Ok(Messages.TransactionCreated));
}
public async Task <IActionResult> DoWithdraw(int customerId, [FromBody] TransactionInputModel transactionInputModel)
{
var result = await _webService.BalanceActor.Ask <DoWithdrawResponseMessage>(new DoWithdraw(customerId, transactionInputModel.Amount), TimeSpan.FromSeconds(60));
if (result is WithdrawAdded a)
{
return(Created($"/api/balance/{customerId}", a.Balance));
}
else
{
return(StatusCode((int)HttpStatusCode.BadGateway));
}
}
private async Task ValidateAvailableTickets(TransactionInputModel inputTransaction)
{
var availableTickets = await this.eventService.GetAvailableTicketsSummary();
var notAvaliableTickets = from ticket in availableTickets
join currentPurchaseTicket in inputTransaction.Tickets
on ticket.Code equals currentPurchaseTicket.TicketCode
where ticket.AvailableTickets < currentPurchaseTicket.Quantity
select ticket;
if (notAvaliableTickets.Any())
{
var notAvailableTicketNames = string.Join(", ", notAvaliableTickets.Select(ticket => ticket.Name));
throw new CheckoutUnavailableException($"There are no available tickets for {notAvailableTicketNames}");
}
}
private void ValidateCustomerAlready(TransactionInputModel inputTransaction)
{
var ticketsToBuy = inputTransaction.Tickets.Select(ticket => ticket.TicketCode);
var alreadyApprobedTickets = context.TicketTypes
.Include(ticket => ticket.Details)
.ThenInclude(detail => detail.Transaction)
.Where(ticket => ticket.Details.Where(detail =>
detail.Transaction.Approved &&
detail.Transaction.Customer.IdentificationNumber.Equals(inputTransaction.CustomerId)).Any());
if (alreadyApprobedTickets.Any())
{
var acquiredTickets = string.Join(", ", alreadyApprobedTickets.Select(ticket => ticket.Name).ToArray());
throw new CheckoutUnavailableException($"The customer {inputTransaction.CustomerId} has already bought tickets for {acquiredTickets}, there is a limit of 1 per participant, please checkout the pending events separatelly");
}
}
public ActionResult AddTransaction(TransactionInputModel model)
{
if (ModelState.IsValid)
{
dynamic from = null;
switch (model.FromType)
{
case TransactionItemType.Wallet:
from = _service.GetWallet(model.FromId);
break;
case TransactionItemType.Income:
from = _service.GetIncome(model.FromId);
break;
}
dynamic to = null;
switch (model.ToType)
{
case TransactionItemType.Wallet:
to = _service.GetWallet(model.ToId);
break;
case TransactionItemType.Category:
to = _service.GetCategory(model.ToId);
break;
}
if (from == null)
{
throw new ArgumentException($"Cannot find {model.FromType} with id={model.FromId}");
}
if (to == null)
{
throw new ArgumentException($"Cannot find {model.ToType} with id={model.ToId}");
}
var transaction = new Transaction(from, to, model.Amount, CurrencyTools.GetCurrency(model.Currency), model.Date, model.Comment);
var newItem = _service.AddTransaction(transaction).MapToTransactionOutputModel();
return(PartialView("_transaction", newItem));
}
return(new HttpStatusCodeResult(422));
}
public async Task <IActionResult> AddBalance(int customerId, [FromBody] TransactionInputModel transactionInputModel)
{
var result = await _webService.BalanceActor.Ask <BalanceCreationResponseMessage>(new AddBalance(customerId, transactionInputModel.Amount), TimeSpan.FromSeconds(10));
if (result is BalanceAdded a)
{
return(Created($"/api/balance/{customerId}", a.Balance));
}
else if (result is BalanceAlreadyAdded)
{
return(Conflict("Balance for this customer already added"));
}
else
{
return(StatusCode((int)HttpStatusCode.BadGateway));
}
}
public async ValueTask <ActionResult <long> > CreateDepositTransaction([FromBody] TransactionInputModel transactionModel)
{
if (await _repo.GetByAccountId(transactionModel.AccountId) is null)
{
_logger.Info($"The Account [{transactionModel.AccountId}] is not found");
return(BadRequest("The account is not found"));
}
if (transactionModel.Amount <= 0)
{
_logger.Info($"The amount is missing for AccountId [{transactionModel.AccountId}]");
return(BadRequest("The amount is missing"));
}
var transactionDto = _mapper.Map <TransactionDto>(transactionModel);
var dataWrapper = await _transactionService.AddTransaction(1, transactionDto);
_logger.Info($"Create Deposit Transaction with Amount = {transactionDto.Amount} {transactionDto.Currency} for AccountId [{transactionDto.AccountId}]");
return(MakeResponse(dataWrapper));
}
public async ValueTask <ActionResult <long> > CreateWithdrawTransaction([FromBody] TransactionInputModel transactionModel)
{
if (await _repo.GetByAccountId(transactionModel.AccountId) is null)
{
return(BadRequest("The account is not found"));
}
string badRequest = await FormBadRequest(transactionModel.Amount, transactionModel.AccountId);
if (!string.IsNullOrWhiteSpace(badRequest))
{
return(Problem("Not enough money on the account", statusCode: 418));
}
var transactionDto = _mapper.Map <TransactionDto>(transactionModel);
var dataWrapper = await _transactionService.AddTransaction(2, transactionDto);
_logger.Info($"Create Withdraw Transaction with Amount = {transactionDto.Amount} {transactionDto.Currency} for AccountId [{transactionDto.AccountId}]");
return(MakeResponse(dataWrapper));
}
public async Task <ObjectResult> Post([FromBody] TransactionInputModel model)
{
try
{
var result = await service.SaveInitialTransaction(model);
return(Ok(result));
}
catch (CheckoutUnavailableException ex)
{
var transactionResult = new TransactionResult()
{
Success = false,
Message = ex.Message
};
return(BadRequest(transactionResult));
}
}
public async Task <Transaction> AddTransactionAsync(int walletId, TransactionInputModel inputModel)
{
if (inputModel.Type == TransactionType.Unknown)
{
throw new ArgumentException("Type must be defined");
}
if (!inputModel.CategoryId.HasValue && string.IsNullOrWhiteSpace(inputModel.CategoryName))
{
throw new ArgumentNullException("Category must be defined");
}
var transaction = Mapper.Map <Transaction>(inputModel);
transaction.Category = await GetCategoryAsync(inputModel.CategoryId, inputModel.CategoryName, inputModel.Type) ?? throw new NotFoundException("Category not found");
transaction.Wallet = await _walletsService.GetAsync(walletId) ?? throw new NotFoundException("Wallet not found");
return(await _transactionsService.AddAsync(transaction));
}
public async Task <ActionResult <TransactionModel> > PostTransaction(TransactionInputModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var command = new CreateTransactionCommand
{
Input = model
};
var result = await Mediator.Send(command, HttpContext.RequestAborted)
.ConfigureAwait(false);
if (result.IsFailure)
{
return(result.AsActionResult());
}
return(CreatedAtAction(nameof(GetTransaction), new { id = result.Value.Id }, result.Value));
}
public async Task CreateWithdrawTest()
{
var transactionInputModel = new TransactionInputModel()
{
AccountId = 256,
CurrencyId = 1,
Amount = 10
};
var jsonContent = new StringContent(JsonConvert.SerializeObject(transactionInputModel), Encoding.UTF8, "application/json");
var response = await client.PostAsync(Configuration.LocalHost + "transaction/withdraw", jsonContent);
long id = Convert.ToInt64(await response.Content.ReadAsStringAsync());
string result = await client.GetStringAsync(Configuration.LocalHost + $"transaction/{id}");
var actual = JsonConvert.DeserializeObject <List <TransactionOutputModel> >(result)[0];
Assert.AreEqual(actual.AccountId, 256);
Assert.AreEqual(actual.Amount, -10);
Assert.AreEqual(actual.Type, "Withdraw");
}
public async ValueTask <ActionResult <long> > CreateDepositTransaction([FromBody] TransactionInputModel transactionModel)
{
var checkingAccountId = await _repo.GetAccountById(transactionModel.AccountId);
if (checkingAccountId.Data is null)
{
return(BadRequest("The account 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 restRequest = new RestRequest("transaction/deposit", Method.POST, DataFormat.Json);
restRequest.AddJsonBody(transactionModel);
var result = await _restClient.ExecuteAsync <long>(restRequest);
return(MakeResponse(result));
}
public ActionResult Create(TransactionInputModel model)
{
var rnd = new Random();
var shopslast = this.Data.Shops.All().ToArray();
var rndNumber = rnd.Next(shopslast[0].Id, shopslast.Last().Id);
if (model != null && this.ModelState.IsValid)
{
var trans = Mapper.Map<Transaction>(model);
trans.DateTime = DateTime.Now;
trans.UserId = this.User.Identity.GetUserId();
trans.ShopId = rndNumber;
var shop = this.Data.Shops.All()
.FirstOrDefault(x=>x.Id == trans.ShopId);
if (shop != null && (shop.DiscountType == DiscountType.Percentage && trans.Amount >= shop.TargetAmount))
{
trans.SavedAmount = trans.Amount * shop.Discount/100;
}
if (shop != null && (shop.DiscountType == DiscountType.Amount && trans.Amount >= shop.TargetAmount))
{
var save = trans.Amount - shop.Discount;
trans.SavedAmount = trans.Amount - save;
}
this.Data.Transactions.Add(trans);
this.Data.SaveChanges();
}
return RedirectToAction("Index", "Customer");
}
public async ValueTask <ActionResult <AuthOutputModel> > CreateWithdrawTransactionStepOne([FromBody] TransactionInputModel transactionModel)
{
var checkingAccountId = await _repo.GetAccountById(transactionModel.AccountId);
if (checkingAccountId.Data is null)
{
return(BadRequest("The account is not found"));
}
if (transactionModel.Amount <= 0)
{
return(BadRequest("The amount is missing"));
}
_authentication.GenerateTwoFactorAuthentication(transactionModel.AccountId);
AuthOutputModel auth = new AuthOutputModel();
var tmp = await _operation.AddOperation(_mapper.Map <OperationDto>(transactionModel));
auth.Id = tmp.Data;
auth.AuthenticationManualCode = _authentication.AuthenticationManualCode;
return(auth);
}
private async Task ValidateTransaction(TransactionInputModel inputTransaction)
{
await ValidateAvailableTickets(inputTransaction);
ValidateCustomerAlready(inputTransaction);
}
public async Task <IHttpActionResult> PostTransactionAsync(int id, [FromBody] TransactionInputModel inputModel)
{
await _service.AddTransactionAsync(id, inputModel);
return(Ok());
}
public IActionResult New([FromBody] TransactionInputModel transaction)
{
var index = _service.Add(transaction.sender, transaction.recipient, transaction.amount);
return(new JsonResult(new { message = string.Format("Transaction will be added to Block {0}", index) }));
}
public async Task <Result> Create(TransactionInputModel model, string userId)
{
var client = this.dbContext.Clients.FirstOrDefault(c => c.UserId == userId);
if (client == null)
{
return(Result.Failure(Messages.TransactionFailure));
}
var senderAccount = await this.dbContext.ExchangeAccounts.FirstOrDefaultAsync(sa =>
sa.IdentityNumber == model.SenderAccount && sa.OwnerId == client.Id);
var errors = new List <string>();
if (senderAccount == null)
{
errors.Add(Messages.SenderAccountDoesNotExist);
}
if (senderAccount != null && !senderAccount.IsActive)
{
errors.Add(Messages.SenderAccountIsNotActive);
}
if (senderAccount != null && senderAccount.Balance < model.Amount)
{
errors.Add(Messages.InsufficientAmount);
}
var receiverAccount =
await this.dbContext.ExchangeAccounts.FirstOrDefaultAsync(ra =>
ra.IdentityNumber == model.ReceiverAccount);
if (receiverAccount == null)
{
errors.Add(Messages.ReceiverAccountDoesNotExist);
}
if (receiverAccount != null && !receiverAccount.IsActive)
{
errors.Add(Messages.ReceiverAccountDoesNotExist);
}
if (senderAccount != null && receiverAccount != null &&
senderAccount.IdentityNumber == receiverAccount.IdentityNumber)
{
errors.Add(Messages.TransactionBetweenSameAccounts);
}
if (errors.Any())
{
return(Result.Failure(errors));
}
var transaction = new Transaction()
{
SenderAccountId = senderAccount.Id,
ReceiverAccountId = receiverAccount.Id,
Amount = model.Amount,
Description = model.Description,
IssuedAt = DateTime.UtcNow
};
senderAccount.Balance -= model.Amount;
receiverAccount.Balance += model.Amount;
this.dbContext.Transactions.Add(transaction);
await this.dbContext.SaveChangesAsync();
return(Result.Success);
}
