public void Test()
{
var brand = new Brand
{
Title = "Brand 1"
};
var clockType = new ClockType
{
Title = "Clock Type 1"
};
var payment = new Payment
{
Title = "Payment 1"
};
var delivery = new Delivery
{
Title = "Delivery 1"
};
_brandRepository.Add(brand);
_clockTypeRepository.Add(clockType);
_paymentRepository.Add(payment);
_deliveryRepository.Add(delivery);
}
public async Task <Payment> ProcessPayment(Payment payment)
{
if (payment is null)
{
throw new ArgumentNullException(nameof(payment));
}
var isCurrencySupported = await _currencyService.IsCurrencySupported(payment.Currency).ConfigureAwait(false);
if (!isCurrencySupported)
{
throw new PaymentAggregateException($"Currency {payment.Currency} is not supported");
}
var paymentStatus = await _paymentSenderService.SendPayment(payment).ConfigureAwait(false);
if (paymentStatus == PaymentStatus.ServiceError)
{
throw new PaymentAggregateException("There was in issue with the calling bank");
}
var updatedPayment = payment.UpdateStatus(paymentStatus);
updatedPayment = _paymentRepository.Add(updatedPayment);
await _paymentRepository.UnitOfWork.SaveChangesAsync().ConfigureAwait(false);
return(updatedPayment);
}
public int SaveCreditCardDetailModel(CreditCardDetailModel model)
{
var ccDetail = Mapper.DynamicMap <tblCreditCardDetail>(model);
_paymentRepository.Add(ccDetail);
return(_paymentRepository.SaveChanges());
}
public async Task <bool> ProcessPayment(Payment model)
{
model.Id = Guid.NewGuid().ToString();
await _paymentRepository.Add(model);
return(await ProcessTransaction(model.Id));
}
public async Task <Models.Payment> AddPayment(PaymentRequest paymentRequest)
{
Models.Payment payment = null;
payment = new Models.Payment
{
Amount = paymentRequest.Amount,
Currency = paymentRequest.Currency,
RequestedOn = DateTime.Now,
Status = PaymentStatus.Requested,
CardNumber = paymentRequest.CardNumber,
Cvv = paymentRequest.Cvv,
ExpiryDate = paymentRequest.ExpiryDate,
IdempotencyUniqueId = UniqueIdempotencyId(paymentRequest)
};
if (await _paymentRepository.Add(payment) == StoreNewPaymentResult.DuplicateUniqueIdempotencyId)
{
return(await _paymentRepository.GetByIdempotencyKey(payment.IdempotencyUniqueId));
}
var response = await _bankClient.InitiatePayment(payment);
payment.Status = response.PaymentStatus;
payment.BankIdentifier = response.BankIdentifier;
await _paymentRepository.Update(payment);
return(payment);
}
public async Task <PaymentDTO> MakePayment(AddPaymentDTO addPaymentDTO)
{
var invoice = await _invoicesRepository.ByID(addPaymentDTO.InvoiceID);
if (invoice != null && invoice?.Total == addPaymentDTO.PaymentAmount)
{
Payment invoicePayment = await _paymentRepository.ByInvoiceID(invoice.InvoiceID);
//если оплата по счету уже сделана то повторно она не проводится
if (invoicePayment != null)
{
return(_mapper.Map <PaymentDTO>(invoicePayment));
}
Payment newPayment = new Payment()
{
InvoiceID = invoice.InvoiceID,
PaymentAmount = invoice.Total,
PaidAt = DateTime.Now
};
Payment addedPayment = await _paymentRepository.Add(newPayment);
_rmqProducer.PaymentSuccessful(invoice.ShoppingCartID);
return(_mapper.Map <PaymentDTO>(addedPayment));
}
return(new PaymentDTO());
}
public void Vend(VendDTO vend)
{
if (vend == null)
{
throw new ArgumentNullException("vend");
}
if (vend.payment == null)
{
throw new ArgumentNullException("payment");
}
if (vend.flavour == 0)
{
throw new ArgumentException("flavour");
}
//if we have db then we should perfrm all actions in this function under transaction
Payment payment = PaymentMapper.Map(vend.payment);
_paymentRepository.Add(payment);
var criteria = new DrinkCanFindCriteria();
criteria.Flavour = vend.flavour;
DrinkCan can = _drinkCanRepository.FindByCriteria(criteria).FirstOrDefault();
_drinkCanRepository.Delete(can);
}
public async Task <ActionResult> Create([FromBody] CreatePaymentRequestModel requestModel)
{
if (!EnsureMerchantValidity(out var merchant))
{
return(BadRequest(new ErrorResponseModel("missing or invalid merchant header")));
}
var creditCardInformation = new CreditCardInformation(requestModel.CreditCardNumber,
new ExpiryDate(requestModel.CreditCardExpiryMonth, requestModel.CreditCardExpiryYear),
requestModel.CreditCardCcv);
var paymentAmount = new PaymentAmount(requestModel.Amount, requestModel.CurrencyCode);
var payment = Payment.Create(paymentAmount, creditCardInformation, merchant.MerchantId, requestModel.ExternalShopperIdentifier);
bool wasPaymentSuccessful = await payment.AttemptPayment(merchant.CreditCardInformation, _bankConnectorDS);
_paymentRepository.Add(payment);
await _paymentRepository.PersistAsync();
_logger.LogInformation($"New payment was created with PaymentId: {payment.PaymentId}");
var responseModel = new CreatePaymentResponseModel
{
WasPaymentSuccessful = wasPaymentSuccessful,
PaymentId = payment.PaymentId
};
return(Accepted(responseModel));
}
public async Task <PaymentData> ProcessPayment(PaymentRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var paymentData = BuildPaymentData(request);
_paymentRepository.Add(paymentData);
CustomMetrics.PaymentStarted.Inc();
_logger.LogInformation($"Payment request for {request.Amount} {request.Currency} recieved and given id {paymentData.Id}");
var bankResponse = await _bankService.ProcessPayment(request);
var newStatus = bankResponse.Success ? PaymentStatus.Accepted : PaymentStatus.Rejected;
var statusString = bankResponse.Success ? "accepted" : "rejected";
_paymentRepository.Update(paymentData.Id, bankResponse.TransactionId, newStatus);
_logger.LogInformation($"Transaction {bankResponse.TransactionId} {statusString}");
CustomMetrics.PaymentCompleted.WithLabels(statusString).Inc();
return(paymentData);
}
public async Task <Payment> AddPayment(Payment payment)
{
var saved = paymentRepository.Add(payment);
await paymentRepository.Save();
return(saved);
}
public ActionResult ProceedToPayment(FormCollection data)
{
RegistrationViewModel obj = new RegistrationViewModel();
TryUpdateModel(obj);
GotoPayment(obj);
Payment payment = new Payment();
payment.ApplicationNumber = obj.ApplicationNumber;
payment.Name = obj.Name;
payment.Email = obj.Email;
payment.Mobile1 = obj.MobileNo;
payment.Category = obj.Category;
payment.TechCat1 = obj.TechCat1;
payment.TechCat2 = obj.TechCat2;
payment.TechCat3 = obj.TechCat3;
payment.TechCat4 = obj.TechCat4;
payment.NonTechCat1 = obj.NonTechCat1;
payment.NonTechCat2 = obj.NonTechCat2;
payment.NonTechCat3 = obj.NonTechCat3;
payment.NonTechCat4 = obj.NonTechCat4;
payment.RegistrationFee = obj.RegistrationFee;
payment.ServiceTax = obj.ServiceTax;
payment.Total = obj.Total;
payment.AmountReceived = 0;
payment.ReferenceNumber = "";
_paymentRepository.Add(payment);
unitOfWork.SaveChanges();
return(View(obj));
}
public async Task <PaymentResponse> ProcessPaymentRequest(PaymentRequest paymentRequest)
{
if (paymentRequest == null)
{
throw new ArgumentNullException("paymentRequest");
}
var validationErrors = _paymentRequestValidator.Validate(paymentRequest);
var merchant = _merchantRepository.GetMerchantById(paymentRequest.MerchantId);
var payment = _autoMapper.Map <Payment>(paymentRequest);
payment.Merchant = await merchant;
if (merchant == null)
{
throw new NullReferenceException("Merchant cannot be null");
}
payment.PaymentStatuses.Add(new PaymentStatus
{
StatusKey = validationErrors.Any() ? PaymentStatuses.InternalValidationError : PaymentStatuses.PendingSubmission,
StatusDateTime = _dateTimeProvider.UtcNow
});
payment = await _paymentRepository.Add(payment);
if (validationErrors.Any())
{
return(GenerateNewPaymentResponse(payment, validationErrors));
}
var bankResponse = await _acquiringBankClient.SubmitPaymentToBank(paymentRequest);
if (bankResponse == null)
{
payment.PaymentStatuses.Add(new PaymentStatus
{
StatusKey = PaymentStatuses.SubmissionError,
StatusDateTime = _dateTimeProvider.UtcNow
});
await _paymentRepository.Update(payment);
return(GenerateNewPaymentResponse(payment));
}
payment.BankId = bankResponse.BankId;
payment.PaymentStatuses.Add(new PaymentStatus
{
StatusKey = bankResponse.PaymentStatus,
StatusDateTime = bankResponse.StatusDateTime
});
payment = await _paymentRepository.Update(payment);
return(GenerateNewPaymentResponse(payment));
}
public async Task <Payment> Create(Payment payment)
{
await _paymentRepository.Add(payment);
await _paymentRepository.Commit();
return(payment);
}
public void AddPayment(string nameMethod)
{
var payment = new PaymentType {
NameMethod = nameMethod
};
_paymentRepository.Add(payment);
_unitOfWork.Commit();
}
public async Task <IActionResult> PayStandard(Provider provider, int paymentSum, PaymentCard paymentCard, Intent intent)
{
TempData["actionInitiated"] = true;
if (intent == Intent.NoIntent)
{
setError(InvalidIntent);
return(redirectToLandingPage());
}
// Let's assume payment sum and payment card gets validated on the client side, so no need to do it here.
PayResponse response = await rcpgClient.PayStandard(provider, paymentSum, DEFAULT_CURRENCY, paymentCard, intent);
if (response.PaymentErrors.Any())
{
TempData["hasErrors"] = true;
TempData["notificationText"] = $"Notikusi kļūda. Kļūdas avots: \"{response.PaymentErrors.First().Source}\", kļūdas kods: \"{response.PaymentErrors.First().ErrorCode}\"";
return(redirectToLandingPage());
}
Payment payment = new Payment()
{
Token = response.PaymentId,
Sum = paymentSum,
Currency = DEFAULT_CURRENCY,
Provider = provider.ToString(),
Intent = intent.ToString(),
TransactionId = response.PaymentId,
InitiatedOn = DateTime.Parse(response.ExecutedOn)
};
if (intent == Intent.Purchase)
{
payment.Status = PaymentStatus.Captured.ToString();
payment.CapturedOn = DateTime.Parse(response.ExecutedOn);
}
else
{
payment.Status = PaymentStatus.Authorized.ToString();
}
await paymentRepository.Add(payment);
return(redirectToAllPayments());
}
private Payment CreateNewPayment()
{
var payment = new Payment
{
Date = DateTime.Today
};
_paymentRepository.Add(payment);
return(payment);
}
public string MakePayment(int RouteId)
{
//var routeToMakePayment = _routeService.getRouteDetail(RouteId);
//var customerInfor = _customerService.FindCustomerById(routeToMakePayment.CutomerId);
//var creditCardToMakePayment = _creditCardService.GetCardToPayment(routeToMakePayment.CustomerId);
var routeToMakePayment = _routeRepository.Get(x => x.Id == RouteId);
var customerInfor = _customerRepository.Get(x => x.Id == routeToMakePayment.CustomerId);
var creditCardToMakePayment = _creditCardRepository.Get(x => x.Deleted == false && x.CustomerId == routeToMakePayment.CustomerId && x.Isdefault == true);
//Stripe charge money
StripeConfiguration.SetApiKey(SETTING.Value.SecretStripe);
var options = new ChargeCreateOptions
{
Amount = Convert.ToInt64(routeToMakePayment.TotalAmount * 100),
Currency = "usd",
Description = customerInfor.FullName.ToUpper() + "-" + customerInfor.Email + "-" + customerInfor.PhoneNumber +
" buy Route Code: " + routeToMakePayment.Code,
SourceId = creditCardToMakePayment.CardId, // obtained with Stripe.js,
CustomerId = customerInfor.StripeId,
};
var service = new ChargeService();
service.ExpandBalanceTransaction = true;
Charge charge = service.Create(options);
PaymentCreateViewModel model = new PaymentCreateViewModel();
model.RouteId = routeToMakePayment.Id;
model.CreditCartId = creditCardToMakePayment.Id;
model.Description = "You bought route " + routeToMakePayment.Code + ". Thank you for using our service.";
model.Amount = routeToMakePayment.TotalAmount;
model.Status = PaymentStatus.Success;
model.StripeChargeId = charge.Id;
model.FeeAmount = Convert.ToDecimal(charge.BalanceTransaction.Fee) / 100;
var payment = _mapper.Map <PaymentCreateViewModel, Payment>(model); //map từ ViewModel qua Model
_paymentRepository.Add(payment);
_unitOfWork.CommitChanges();
return("");
}
public void Add(PaymentDTO recDTO)
{
if (recDTO == null)
{
throw new ArgumentNullException(string.Format(ValidationConstants.SDataNotFoundWithValue, "Payment"));
}
Payment rec = PaymentMapper.Map(recDTO);
_paymentRepository.Add(rec);
}
private void SaveOrUpdatePayment(Payment payment)
{
if (payment.Data.Id == 0)
{
paymentRepository.Add(payment.Data);
}
else
{
paymentRepository.Update(payment.Data);
}
}
public async Task <Models.PaymentResultModel> Handle(
ProcessPaymentRequestCommand command,
CancellationToken cancellationToken = default)
{
var merchant = await _merchantRepository.GetAsync(command.MerchantId);
if (merchant == null)
{
_logger.LogWarning("Merchant with {id} was not found", command.MerchantId);
throw new Exception("Merchant was not found");
}
var shopperCard = new PaymentCard(
command.CardNumber,
command.CardHolderName,
command.ExpiryMonth,
command.ExpiryYear);
var payment = new Payment(
shopperCard,
command.MerchantId,
command.ChargeTotal,
command.CurrencyCode);
_paymentRepository.Add(payment);
await _unitOfWork.CommitAsync();
try
{
var transactionResult = await ProcessPaymentByAcquiringBank(command, merchant.Iban);
if (transactionResult.Status == TransactionStatus.Accepted)
{
payment.Succeed();
}
else
{
payment.Fail();
}
}
catch (Exception ex)
{
_logger.LogError(ex, "Payment transaction with {id} failed to processed by acquiring bank", payment.Id);
payment.Fail();
}
await _unitOfWork.CommitAsync();
return(new PaymentResultModel
{
PaymentId = payment.Id,
Status = payment.Status
});
}
public PaymentDto AddPayment(PaymentDto payment, int userId)
{
payment.Id = _paymentReposirotry.Add(new Payment()
{
Amount = payment.Amount,
PaymentDate = payment.PaymentDate,
PaymentTypeId = payment.PaymentTypeId,
PlaceName = payment.PlaceName,
UserId = userId
}).Id;
return(payment);
}
public async Task <Result> Handle(CreatePaymentCommand request, CancellationToken cancellationToken)
{
// Check if currency is supported for given merchant
var isCurrencySupported = await _merchantQuery.IsCurrencySupported(request.MerchantId, request.Currency);
if (!isCurrencySupported)
{
return(Result.Fail(ExternalErrorReason.CurrencyNotSupported));
}
// Check if card if valid
var isCardValid = await _cardQuery.IsCardValid(request.CardToken, request.Cvv);
if (!isCardValid)
{
return(Result.Fail <string>(ExternalErrorReason.InvalidCard));
}
// Perform risk analysis
if (!string.IsNullOrEmpty(request.OriginIp) && IPAddress.TryParse(request.OriginIp, out IPAddress ipAddress))
{
var riskAnalysisResult = await _riskAnalysisService.GetRiskAnalysis(ipAddress);
if (!riskAnalysisResult.IsSuccess)
{
return(Result.Fail <string>(riskAnalysisResult.Error));
}
}
var payment = new Payment(request.MerchantId, request.Currency, request.Amount, request.Reference, request.OriginIp,
request.Description);
payment.SetCardPaymentSource(request.CardToken, request.Cvv);
if (request.Shipping != null)
{
payment.AddBillingAddress(request.Shipping.AddressLine1, request.Shipping.AddressLine2, request.Shipping.City,
request.Shipping.Zip, request.Shipping.State, request.Shipping.Country);
}
if (request.Recipient != null)
{
payment.SetPaymentRecipient(DateTime.Parse(request.Recipient.DateOfBirth), request.Recipient.AccountNumber, request.Recipient.FirstName,
request.Recipient.LastName, request.Recipient.Zip);
}
payment.SetNotificationsForMerchant(request.SuccessUrl, request.ErrorUrl);
payment.InitiatePayment();
_paymentRepository.Add(payment);
var persistenceResult = await _paymentRepository.UnitOfWork.SaveEntitiesAsync(cancellationToken);
return(persistenceResult.IsSuccess
? Result.Ok(payment.PaymentId)
: Result.Fail <string>(persistenceResult.Error));
}
public async Task <IActionResult> Post(CreatingPaymentModel model)
{
if (ModelState.IsValid)
{
var client = await clientRepository.Read(model.ClientId);
if (client == null)
{
return(NotFound($"Cliente com Id {model.ClientId} não foi encontrado."));
}
var clerk = await userManager.FindByIdAsync(model.ClerkId);
if (clerk == null)
{
return(NotFound(ErrorResponse.From($"Atendent com o Id {model.ClerkId} não foi encontrado.")));
}
if (model.Value <= 0 || model.Value > client.Debt)
{
return(BadRequest($"O valor precisa ser maior que R$ 0 e menor que R$ {client.Debt}"));
}
client.Debt -= model.Value;
client.LastPurchase = DateTime.Now;
if (client.Debt == 0)
{
var pendings = await orderRepository.Pending(client.Id);
foreach (var order in pendings)
{
order.Status = Models.OrderModels.Status.Pago;
}
}
var p = new Payment
{
Client = client,
Clerk = clerk,
Amount = model.Value,
Date = DateTime.Now,
};
await paymentRepository.Add(p);
var url = Url.Action("Get", new { id = p.Id });
var created = Created(url, p);
return(created);
}
return(BadRequest(ErrorResponse.FromModelState(ModelState)));
}
public IActionResult Post([FromBody] PaymentRequest payReq)
{
var payment = _paymentFactory.Create(payReq.Client.Id
, payReq.Type, payReq.Amount
, payReq.Buyer.Name, payReq.Buyer.Email, payReq.Buyer.Cpf
, payReq.Card?.ExpirationDate, payReq.Card?.Cvv, payReq.Card?.HolderName, payReq.Card?.Number);
var result = payment.Process();
_paymentRepository.Add(payment);
return(CreatedAtRoute("GetPayment", new { id = payment.Id }, result));
}
private void AddPaymentToChangeSet(Payment payment)
{
payment.ClearPayment();
PaymentAmountHelper.AddPaymentAmount(payment);
if (payment.Data.Id == 0)
{
paymentRepository.Add(payment.Data);
}
else
{
paymentRepository.Update(payment.Data);
}
}
// [Route("api/payment/{id}")]
public IHttpActionResult Post([FromBody] PaymentDTO value)
{
try
{
if (value == null)
{
return(BadRequest());
}
string userName = null;
if (HttpContext.Current != null && HttpContext.Current.User != null &&
HttpContext.Current.User.Identity.Name != null)
{
userName = HttpContext.Current.User.Identity.Name;
}
if (value.Amount != value.PaymentItems.Sum(it => it.Amount))
{
return(BadRequest("Invocie Amount Miss Match with total Invoice Item Amount"));
}
foreach (var item in value.PaymentItems)
{
var invoice = _InvoiceRepo.Get().FirstOrDefault <Invoice>(i => i.InvoiceNo == item.InvoiceNo);
if (invoice == null)
{
return(BadRequest(item.InvoiceNo + "InvoiceNo not found"));
}
item.InvoiceID = invoice.ID;
}
var payment = value.ToDomain();
payment.CreateUser = userName;
payment.ChangeUser = userName;
payment.Concurrency = Guid.NewGuid();
_PaymentRepo.Add(payment);
_uow.SaveChanges();
if (payment.ID > 0)
{
return(Created <PaymentDTO>(Request.RequestUri + "/" + payment.ID, payment.ToDTO()));
}
return(BadRequest());
}
catch (Exception ex)
{
return(InternalServerError());
}
}
public async Task <CreatePaymentResponse> CreatePayment(CreatePaymentRequest request, Merchant merchant)
{
try
{
if (merchant == null)
{
return(null);
}
_log.LogInformation($"Requesting bank for merchant {merchant.Id} : {request.Amount:C2}");
var bankResponse = await _bankGateway.SubmitPayment(PaymentMapper.MapGatewayRequest(request));
_log.LogInformation($"Bank response for merchant {merchant.Id} : {bankResponse.Status} ");
var payment = await _paymentRepository.Add(PaymentMapper.MapPayment(bankResponse, merchant, _encryptionProvier));
var isPaymentSuccessfull = bankResponse.Status == BankGatewayPaymentStatus.Successfull;
var result = new CreatePaymentResponse {
IsSuccessfull = isPaymentSuccessfull
};
if (isPaymentSuccessfull)
{
result.PaymentId = payment.Id;
}
else
{
result.ErrorMessage = "Unable to process payment with Bank";
}
_log.LogInformation($"Created Payment for merchant {merchant.Id} : {result.PaymentId} ");
return(result);
}
catch (Exception ex)
{
_log.LogError("Unabl to process paument", ex);
return(new CreatePaymentResponse
{
IsSuccessfull = false,
ErrorMessage = "An unexpected error occured, please try again later or contact support"
});
}
}
public IActionResult Create([FromBody] Payment item)
{
if (item == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_paymentRepository.Add(item);
return(CreatedAtRoute("GetPayment", new { id = item.Id, aid = item.AddressId }, item));
}
public async Task <ResultModel> Add(Payment payment)
{
var result = new ResultModel();
var validatorResult = new PaymentValidator(_paymentRepository, _creditCardRepository).Validate(payment);
if (!validatorResult.IsValid)
{
result.AddNotification(validatorResult.Errors);
return(result);
}
await _paymentRepository.Add(payment);
return(result);
}
public int AddPaymentRecord(DLModel.Payment modelPayment)
{
// var PaymentSum = _paymentRepository.GetAll(Pay => Pay.InvoiceId == modelPayment.InvoiceId).ToList().Select(Pay => Pay.PaymentAmount == null ? 0 : Pay.PaymentAmount).Sum();
//PaymentSum = PaymentSum + modelPayment.PaymentAmount;
DLModel.Invoice InvoiceDetail = _IInvoiceImpl.GetInvoiceDetailsById(modelPayment.InvoiceId);
//if (modelPayment.PaymentAmount <= InvoiceDetail.InvoiceBalanceAmt)
//{
InvoiceDetail.InvoiceBalanceAmt = (InvoiceDetail.InvoiceBalanceAmt - modelPayment.PaymentAmount).Value;
var updInvoiceBalAmt = _invoiceRepository.Update(InvoiceDetail, inv => inv.InvoiceBalanceAmt);
return(_paymentRepository.Add((DLModel.Payment) new DLModel.Payment().InjectFrom(modelPayment)).PaymentId);
//}
//else
// return -1; // Payment Sum amout can't be greater then invoice amount
}