public string UpdateInvoiceAndPayment(string invoiceNo, DateTime invoiceDate, DateTime date, List <InvoiceDetailViewModel> invoiceDetail, List <PaymentDetailViewModel> paymentDetail)
{
PaymentProvider payment = new PaymentProvider(ctx);
InvoiceHeader invoice = ctx.InvoiceHeaders.SingleOrDefault(inv => inv.InvoiceNo == invoiceNo);
invoice.Date = invoiceDate;
string paymentNo = String.Empty;
if (invoice != null)
{
ctx.InvoiceDetails.DeleteAllOnSubmit(invoice.InvoiceDetails.AsEnumerable());
foreach (var model in invoiceDetail)
{
InvoiceDetail d = new InvoiceDetail();
d.InvoiceID = invoice.ID;
d.ItemID = model.ItemID;
d.Quantity = model.Quantity;
d.UnitPrice = model.UnitPrice;
d.Discount = model.Discount;
d.IsTaxable = model.IsTaxable;
invoice.InvoiceDetails.Add(d);
ctx.InvoiceDetails.InsertOnSubmit(d);
}
paymentNo = payment.Create(date, invoiceNo, paymentDetail);
ctx.SubmitChanges();
}
return(paymentNo);
}
public PurchaseRequest(string userId, string bakerId, IEnumerable <OrderLineDto> orderItems, PaymentProvider paymentProvider)
{
UserId = userId;
BakerId = bakerId;
OrderItems = orderItems;
PaymentProvider = paymentProvider;
}
/// <summary>
/// Processes the specified order.
/// </summary>
/// <typeparam name="T">The order type.</typeparam>
/// <param name="order">The order instance.</param>
/// <exception cref="InvalidTypeException">The provider doesn't implement IReservable interface.</exception>
protected override void Process <T>(T order)
{
bool cancelSuccess = false;
ReservationTicket reservationTicket = new ReservationTicket(order);
PaymentArgs paymentArgs = new PaymentArgs();
PaymentProvider paymentProvider = Context.Entity.Resolve <PaymentProvider>(order.PaymentSystem.Code);
IReservable reservableProvider = paymentProvider as IReservable;
if (reservableProvider != null)
{
reservableProvider.CancelReservation(order.PaymentSystem, paymentArgs, reservationTicket);
ITransactionData transactionDataProvider = Context.Entity.Resolve <ITransactionData>();
string result = transactionDataProvider.GetPersistentValue(order.OrderNumber) as string;
if (string.Compare(result, "Canceled", StringComparison.OrdinalIgnoreCase) == 0)
{
cancelSuccess = true;
}
}
if (!cancelSuccess)
{
order.Status = Context.Entity.Resolve <OrderStatus>("Processing");
IOrderManager <Order> orderManager = Context.Entity.Resolve <IOrderManager <Order> >();
orderManager.SaveOrder(order);
}
if (reservableProvider == null)
{
throw new InvalidTypeException("The provider doesn't implement IReservable interface.");
}
}
// GET: /ShoppingCart/PaymentSuccess
public ActionResult PaymentSuccess([FromQuery] string result)
{
var paymentProvider = new PaymentProvider(_optionsAccessor);
var response = paymentProvider.GetPaymentExpressResponse(result);
return(View(response));
}
public int CreateOrder([FromBody] Order order)
{
if (ModelState.IsValid && order.TicketIDs != "")
{
Response.StatusCode = 200;
PaymentProvider paymentProvider = new PaymentProvider();
var payment = paymentProvider.Pay(150, "SEK", order.TransactionID.ToString());
if (payment.PaymentStatus == PaymentStatus.PaymentApproved)
{
// TODO: maybe catch parse error here and give appropriate error, if ticket IDs are bad?
try
{
int[] ticketIDs = order.TicketIDs.Split(",").Select(int.Parse).ToArray();
return(ticketDB.AddCustomerOrder(order.BuyerFirstName, order.BuyerLastName, order.BuyerAddress, order.BuyerCity, payment.PaymentStatus, payment.PaymentReference, ticketIDs, order.BuyerEmailAddress));
}
catch (FormatException)
{
Response.StatusCode = 400;
return(0);
}
}
else
{
Response.StatusCode = 403;
return(-(int)payment.PaymentStatus);
}
}
else
{
Response.StatusCode = 400;
return(0);
}
}
/// <summary>
/// Initializes the wizard
/// </summary>
/// <param name="merchantId">The merchant id (DB Table RDN_Merchants)</param>
/// <param name="currency"></param>
/// <param name="paymentProvider"></param>
/// <returns></returns>
public InvoiceFactory Initalize(Guid merchantId, string currency, PaymentProvider paymentProvider, PaymentMode mode, ChargeTypeEnum chargeType)
{
invoice = Invoice.CreateNewInvoice();
try
{
invoice.FinancialData.BasePriceForItems = 0;
invoice.FinancialData.TotalBeforeTax = 0;
invoice.FinancialData.ShippingCost = 0.0M;
invoice.FinancialData.TaxRate = 0;
invoice.FinancialData.Tax = 0;
invoice.FinancialData.TotalIncludingTax = 0;
invoice.ChargeType = chargeType;
invoice.Mode = mode;
invoice.Currency = currency;
invoice.ShippingType = ShippingType.None;
invoice.InvoiceId = Guid.NewGuid();
invoice.PaymentProvider = paymentProvider;
invoice.InvoiceStatus = InvoiceStatus.Not_Started;
invoice.MerchantId = merchantId;
RecalculateTotalAfterTax();
}
catch (Exception exception)
{
ErrorDatabaseManager.AddException(exception, exception.GetType());
}
return this;
}
/// <summary>
/// Processes the specified arguments.
/// </summary>
/// <param name="args">The arguments.</param>
public virtual void Process(PipelineArgs args)
{
Assert.ArgumentNotNull(args, "args");
ShoppingCart shoppingCart = Context.Entity.GetInstance <ShoppingCart>();
PaymentProvider paymentProvider = Context.Entity.Resolve <PaymentProvider>(shoppingCart.PaymentSystem.Code);
PaymentUrlResolver paymentUrlResolver = new PaymentUrlResolver();
PaymentArgs paymentArgs = new PaymentArgs
{
ShoppingCart = shoppingCart,
PaymentUrls = paymentUrlResolver.Resolve(),
};
StringBuilder description = new StringBuilder();
foreach (ShoppingCartLine shoppingCartLine in shoppingCart.ShoppingCartLines)
{
description.Append(shoppingCartLine.Product.Title);
description.Append(", ");
}
paymentArgs.Description = description.ToString().Trim().TrimEnd(',');
paymentProvider.Invoke(shoppingCart.PaymentSystem, paymentArgs);
args.AbortPipeline();
}
public async Task <DoPaymentResponse> DoPaymentAsync(DoPaymentRequest request)
{
DoPaymentResponse response = new DoPaymentResponse();
using (var unitOfWork = unitOfWorkFactory.Create())
{
unitOfWork.Begin();
BankBin bankBin = await bankDomainService.GetValidBankBinByCardNumberAsync(unitOfWork, request.CardNumber);
BankProvider bankProvider = await bankDomainService.GetValidBankProviderByBankIdAsync(unitOfWork, bankBin.BankId);
Provider provider = await providerDomainService.GetValidProviderByIdAsync(unitOfWork, bankProvider.ProviderId);
PaymentProvider paymentProvider = providerDomainService.GetValidPaymentProviderByType(provider.ProviderType);
PaymentRequest paymentRequest = classMapper.Map <DoPaymentRequest, PaymentRequest>(request);
paymentRequest.SetConfiguration(bankProvider.Configuration);
paymentProvider.DoPaymentAsync(paymentRequest);
unitOfWork.Commit();
}
return(response);
}
public async Task <IActionResult> Edit(long id, [Bind("Id,ProviderCode,NameRu,PaymentInfoId,CatalogCode,CategoryId,Deleted,Mrlist,MultiCheck,NoSavePt,Check,IsSupportRequestRSTEP,Order,ChequeName,RegionString")] PaymentProvider paymentProvider)
{
if (id != paymentProvider.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(paymentProvider);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PaymentProviderExists(paymentProvider.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["CategoryId"] = new SelectList(_context.Categories, "Id", "Id", paymentProvider.CategoryId);
return(View(paymentProvider));
}
public void Capture(PaymentProvider provider, decimal totalAmount, decimal meterAmount, decimal tipAmount, decimal taxAmount,
decimal tollAmount, decimal surchargeAmount, string authorizationCode, string transactionId, Guid?promotionUsed,
decimal amountSavedByPromotion, string newCardToken, Guid accountId, bool isSettlingOverduePayment, bool isForPrepaidOrder, FeeTypes feeType, decimal bookingFees)
{
if (_isCaptured)
{
throw new InvalidOperationException("Payment is already captured");
}
Update(new CreditCardPaymentCaptured_V2
{
OrderId = _orderId,
TransactionId = transactionId.HasValue() ? transactionId : _transactionId,
AuthorizationCode = authorizationCode,
Amount = totalAmount,
Meter = meterAmount,
Tip = tipAmount,
Tax = taxAmount,
Toll = tollAmount,
Surcharge = surchargeAmount,
Provider = provider,
IsSettlingOverduePayment = isSettlingOverduePayment,
PromotionUsed = promotionUsed,
AmountSavedByPromotion = amountSavedByPromotion,
AccountId = accountId,
NewCardToken = newCardToken,
IsForPrepaidOrder = isForPrepaidOrder,
FeeType = feeType,
BookingFees = bookingFees
});
}
/// <summary>
/// Gets appropriate provider for given provider ID. Check Settings.settings file to see the mapping.
/// In fact the ID of the provider is the base URL.
/// Different default provider is returned depending on the action origin i.e. for user initiated
/// action it is Billbank.IEPlugin.Provider.ProviderListOpener whilst for any other event it is
/// Billbank.IEPlugin.Provider.NullProvider.
/// </summary>
/// <param name="providerId">payment provider's ID</param>
/// <param name="userAction">sets the user initiated action flag</param>
/// <returns>provider object</returns>
public static PaymentProvider GetProvider(String providerId, bool userAction)
{
if (providerId == null)
{
return(GetDefaultProvider(userAction));
}
PaymentProvider result = null;
if (providers.ContainsKey(providerId))
{
return(providers[providerId]);
}
int idx = Settings.Default.ProviderId.IndexOf(providerId);
if (idx >= 0)
{
try {
Type type = Type.GetType(Settings.Default.ProviderClass[idx]);
result = (PaymentProvider)Activator.CreateInstance(type);
providers[providerId] = result;
return(result);
} catch {
return(GetDefaultProvider(userAction));
}
}
return(GetDefaultProvider(userAction));
}
/// <summary>
/// Adds the cash on delivery external payment method., by using Litium default "DirectPay" as the payment method.
/// Note: To use, Klarna has to configure the "Cash on delivery" external payment method for the merchant account.
/// </summary>
private void AddCashOnDeliveryExternalPaymentMethod(UrlHelper urlHelper, OrderCarrier orderCarrier, CheckoutOrder klarnaCheckoutOrder)
{
var checkoutPage = _websiteService.Get(orderCarrier.WebSiteID)?.Fields.GetValue <PointerPageItem>(AcceleratorWebsiteFieldNameConstants.CheckouPage)?.EntitySystemId.MapTo <Page>();
var channel = _channelService.Get(orderCarrier.ChannelID);
if (checkoutPage == null || channel == null)
{
return;
}
var redirectUrl = urlHelper.Action(checkoutPage, routeValues: new { action = nameof(CheckoutController.PlaceOrderDirect) }, channel: channel);
var routeValues = new
{
PaymentProvider = "DirectPay",
PaymentMethod = "DirectPayment",
RedirectUrl = redirectUrl
};
var changePaymentProviderUrl = new Uri(urlHelper.Action("ChangePaymentMethod", "KlarnaPayment", routeValues, Uri.UriSchemeHttps)).AbsoluteUri;
var cashOnDeliveryExternalPayment = new PaymentProvider
{
Name = "Cash on delivery",
RedirectUrl = changePaymentProviderUrl,
Fee = 0
};
klarnaCheckoutOrder.ExternalPaymentMethods = new List <PaymentProvider>
{
cashOnDeliveryExternalPayment
};
}
public PaymentRequest CreatePaymentRequest(OrderInfo orderInfo)
{
var paymentProvider = PaymentProvider.GetPaymentProvider(orderInfo.PaymentInfo.Id, orderInfo.StoreInfo.Alias);
var partnerId = paymentProvider.GetSetting("PartnerId");
var returnUrl = paymentProvider.SuccessUrl();
var reportUrl = paymentProvider.ReportUrl();
var testMode = paymentProvider.TestMode;
var idealFetch = new IdealFetch(partnerId, testMode, orderInfo.OrderNumber, reportUrl, returnUrl, orderInfo.PaymentInfo.MethodId, orderInfo.ChargedAmount);
if (idealFetch.Error)
{
Log.Instance.LogError("Mollie PaymentRequestHandler.CreatePaymentRequest: idealFetch.Error: " + idealFetch.ErrorMessage);
return(null);
}
var transactionId = idealFetch.TransactionId;
orderInfo.PaymentInfo.Url = idealFetch.Url;
PaymentProviderHelper.SetTransactionId(orderInfo, transactionId);
return(new PaymentRequest());
}
/// <summary>
/// Processes the order.
/// </summary>
/// <param name="order">The order.</param>
/// <param name="parameters">The parameters.</param>
/// <returns>
/// The result.
/// </returns>
public override string ProcessOrder([NotNull] Order order, [NotNull] IDictionary <string, object> parameters)
{
Assert.ArgumentNotNull(order, "order");
Assert.ArgumentNotNull(parameters, "parameters");
Assert.IsNotNull(order.PaymentMeans, "Order payment means cannot be null.");
string paymentSystemCode = order.PaymentMeans.PaymentChannelCode;
Assert.IsNotNullOrEmpty(paymentSystemCode, "Order payment channel code cannot be null or empty.");
Assert.IsNotNull(order.ReservationTicket, "Order reservation ticket cannot be null");
PaymentProvider paymentProvider = this.paymentProviderFactory.GetProvider(paymentSystemCode);
Assert.IsTrue(paymentProvider is IReservable, "Unable to cancel amount reservation. Reservable payment provider is expected.");
IReservable reservablePaymentProvider = (IReservable)paymentProvider;
this.merchantOrderManager.Save(order);
reservablePaymentProvider.CancelReservation(paymentProvider.PaymentOption, new PaymentArgs(), order.GetReservationTicket());
ITransactionData transactionDataProvider = Context.Entity.Resolve <ITransactionData>();
string result = transactionDataProvider.GetPersistentValue(order.OrderId).ToString();
if (result == "Canceled")
{
result = SuccessfulResult;
}
return(result);
}
public void GetDetailsOfPayment_IdFound_ReturnsTransactionQueryResult()
{
var bankClientMoq = new Mock <IBankClientService>();
var repositoryMoq = new Mock <ITransactionResultRepository>();
repositoryMoq
.Setup(moq => moq.GetTransactionByID(It.IsAny <string>()))
.Returns(Task.FromResult <TransactionResult>(new TransactionResult()));
var resultMapperMoq = new Mock <ITransactionResultMapper>();
resultMapperMoq
.Setup(moq => moq.Map(It.IsAny <TransactionResult>()))
.Returns(new TransactionResultQuery());
var mapperMoq = new Mock <ITransactionMapper>();
var provider = new PaymentProvider(
bankClientMoq.Object,
repositoryMoq.Object,
resultMapperMoq.Object,
mapperMoq.Object);
var result = provider.GetDetailsOfPayment(Guid.Empty.ToString()).Result;
Assert.IsNotNull(result);
}
public JsonResult Crear(EDPaymentProvider Payment)
{
bool Probar = true;
string Mensaje = "";
EDPaymentProvider EDPaymentProvider = new EDPaymentProvider();
EDPaymentProvider.Id_Pago = Payment.Id_Pago;
EDPaymentProvider.Valor_Pago = Payment.Valor_Pago;
EDPaymentProvider.Fecha_Pago = Payment.Fecha_Pago;
EDPaymentProvider.Observacion = Payment.Observacion;
EDPaymentProvider.TerceroId = Payment.TerceroId;
try
{
PaymentProvider PaymentProvider = new PaymentProvider();
PaymentProvider.Valor_Pago = EDPaymentProvider.Valor_Pago;
PaymentProvider.Valor_Pago = EDPaymentProvider.Valor_Pago;
PaymentProvider.Fecha_Pago = DateTime.Parse(EDPaymentProvider.Fecha_Pago);
PaymentProvider.Observacion = EDPaymentProvider.Observacion;
PaymentProvider.TerceroId = EDPaymentProvider.TerceroId;
db.PaymentProviders.Add(PaymentProvider);
db.SaveChanges();
Mensaje = " Registro Agregado con exito.";
}
catch (Exception)
{
Probar = false;
Mensaje = " Se produjo un error al agregar el registro.";
}
return(Json(new { Probar, Mensaje }, JsonRequestBehavior.AllowGet));
}
public void Pay_ValidTransaction_ReturnsGuid()
{
var bankClientMoq = new Mock <IBankClientService>();
var repositoryMoq = new Mock <ITransactionResultRepository>();
repositoryMoq
.Setup(moq => moq.InsertTransaction(It.IsAny <TransactionResult>()));
var resultMapperMoq = new Mock <ITransactionResultMapper>();
resultMapperMoq
.Setup(moq => moq.Map(It.IsAny <PaymentState>(), It.IsAny <Transaction>()))
.Returns(new TransactionResult());
var mapperMoq = new Mock <ITransactionMapper>();
var provider = new PaymentProvider(
bankClientMoq.Object,
repositoryMoq.Object,
resultMapperMoq.Object,
mapperMoq.Object);
var result = provider.Pay(new Transaction()).Result;
Assert.IsTrue(!string.IsNullOrWhiteSpace(result));
Guid guid = Guid.Parse(result);
repositoryMoq
.Verify(
moq => moq.InsertTransaction(It.IsAny <TransactionResult>()),
Times.Once);
}
public void GetDetailsOfPayment_IdNotGuid_ThrowsArgumentException()
{
var bankClientMoq = new Mock <IBankClientService>();
var repositoryMoq = new Mock <ITransactionResultRepository>();
var resultMapperMoq = new Mock <ITransactionResultMapper>();
var mapperMoq = new Mock <ITransactionMapper>();
var provider = new PaymentProvider(
bankClientMoq.Object,
repositoryMoq.Object,
resultMapperMoq.Object,
mapperMoq.Object);
bool thrown = false;
try
{
var result = provider.GetDetailsOfPayment(null).Result;
}
catch (AggregateException ex)
{
if (ex.InnerException is ArgumentException)
{
thrown = true;
}
}
Assert.IsTrue(thrown);
}
public JsonResult Borrar(int ID)
{
bool Probar = true;
string Mensaje = "";
PaymentProvider PaymentProvider = db.PaymentProviders.Find(ID);
if (PaymentProvider == null)
{
Probar = false;
Mensaje = " No se encuntra el registro: " + PaymentProvider.Id_Pago;
}
else
{
try
{
db.PaymentProviders.Remove(PaymentProvider);
db.SaveChanges();
Mensaje = " Registro eliminado con exito.";
}
catch (Exception)
{
Probar = false;
Mensaje = " Se produjo un error al borrar el registro.";
}
}
return(Json(new { Probar, Mensaje }, JsonRequestBehavior.AllowGet));
}
private void frmOrder_Load(object sender, System.EventArgs e)
{
this.Text += " - " + this.CompanyID;
oPayment = new PaymentProvider(this.CompanyID);
oVendor = new Vendor(this.CompanyID);
txtDate.Value = DateTime.Now;
this.txtPurchaseID.Focus();
}
public PaymentConfiguration CreateInstance(PaymentProvider paymentProvider, BehaviorModel behaviorModel)
{
if (!this.HasData)
{
return(null);
}
return(new PaymentConfiguration(this.PaymentConfigurationID, new PaymentCredentials(this.PaymentCredentialsID), new PaymentInterface(this.PaymentInterfaceID), paymentProvider ?? new PaymentProvider(this.PaymentProviderID), behaviorModel ?? new BehaviorModel(this.BehaviorModelID), this.Name, this.Updated, this.Created));
}
// **** Helper Methods ****
public static string GetValue(string key)
{
var basket = API.Basket.GetBasket();
var paymentProvider = new PaymentProvider(basket.Payment.Providers.FirstOrDefault().Id);
return(paymentProvider.GetSetting(key));
}
public ActionResult DeleteConfirmed(int id)
{
PaymentProvider paymentProvider = db.PaymentProviders.Find(id);
db.PaymentProviders.Remove(paymentProvider);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void ShouldReturnProvider()
{
PaymentProvider provider = ProviderFactory.GetProvider(Settings.Default.ProviderId[0]);
Assert.AreEqual(Settings.Default.ProviderClass[0], provider.GetType().FullName);
Assert.AreSame(provider, ProviderFactory.GetProvider(Settings.Default.ProviderId[0]));
}
private static PaymentProviderQueueItem GetQueueItem(DataContext dbContext, PaymentProvider paymentProvider)
{
var connection = (OracleConnection)dbContext.Database.Connection;
using (var command = new OracleCommand())
{
try
{
if (connection.State != ConnectionState.Open)
{
connection.Open();
}
command.Parameters.Add("P_PAYMENT_PROVIDER_ID", OracleDbType.Int32).Value = paymentProvider;
command.Parameters.Add("O_QUEUED_DATA", OracleDbType.RefCursor).Direction = ParameterDirection.Output;
ExcecuteNonQuery(command, "finance.PAYMENT_PROVIDER_REQUEST_INFO.GET_NEXT_QUEUED_ENTRY", connection);
if ((command.Parameters["O_QUEUED_DATA"].Value == null) || (command.Parameters["O_QUEUED_DATA"].Value is DBNull))
{
return(null);
}
var refCursor = (OracleRefCursor)command.Parameters["O_QUEUED_DATA"].Value;
using (var dataReader = refCursor.GetDataReader())
{
while (dataReader.Read())
{
var paymentProviderQueueItem = new PaymentProviderQueueItem();
paymentProviderQueueItem.ID = long.Parse(dataReader["ID"].ToString());
paymentProviderQueueItem.CreatedTimestamp = DateTime.Parse(dataReader["CREATED_DATE"].ToString());
paymentProviderQueueItem.QueueStatus = (QueueStatus)int.Parse(dataReader["QUEUE_STATUS_ID"].ToString());
paymentProviderQueueItem.Arguments = dataReader["ARGUMENTS"].ToString();
paymentProviderQueueItem.TransactionToken = dataReader["TRANSACTION_TOKEN"].ToString();
paymentProviderQueueItem.OperationName = dataReader["OPERATION_NAME"].ToString();
paymentProviderQueueItem.PaymentProvider = (PaymentProvider)int.Parse(dataReader["PAYMENT_PROVIDER_ID"].ToString());
return(paymentProviderQueueItem);
}
}
}
finally
{
foreach (OracleParameter parameter in command.Parameters)
{
if (parameter.Value is IDisposable)
{
((IDisposable)(parameter.Value)).Dispose();
}
parameter.Dispose();
}
}
}
return(null);
}
public OrderInfo HandlePaymentResponse(PaymentProvider paymentProvider, OrderInfo orderInfo)
{
var orderId = HttpContext.Current.Request.QueryString["orderid"] ?? "";
if (paymentProvider == null || string.IsNullOrEmpty(orderId))
{
return(null);
}
orderInfo = OrderHelper.GetOrder(orderId);
if (orderInfo != null)
{
var localizedPaymentProvider = PaymentProvider.GetPaymentProvider(orderInfo.PaymentInfo.Id, orderInfo.StoreInfo.Alias);
var secret = paymentProvider.GetSetting("secret");
var amount = HttpContext.Current.Request.QueryString["amount"] ?? "0";
var validated = true;
if (secret != string.Empty)
{
var sb = new StringBuilder();
foreach (var key in HttpContext.Current.Request.QueryString.AllKeys)
{
if (key != "hash")
{
sb.Append(HttpContext.Current.Request.QueryString[key]);
}
}
var calculated = ePayPaymentBase.MD5(sb.ToString() + secret).ToUpperInvariant();
var incoming = (HttpContext.Current.Request.QueryString["hash"] ?? "").ToUpperInvariant();
validated = calculated == incoming;
if (!validated)
{
//checksum error
Log.Instance.LogError("Payment provider (ePay) error : Orderid " + orderId + " - incoming hash " + incoming + " - calculated hash " + calculated);
}
}
if (validated && (amount == orderInfo.ChargedAmountInCents.ToString()))
{
orderInfo.Paid = true;
orderInfo.Status = OrderStatus.ReadyForDispatch;
orderInfo.Save();
}
else
{
orderInfo.Paid = false;
orderInfo.Status = OrderStatus.PaymentFailed;
orderInfo.Save();
if (validated)
{
//checksum already logged, must be problem with amount
Log.Instance.LogError("Payment provider (ePay) error : Orderid " + orderId + " - incoming amount " + amount.ToString() + " - order amount " + orderInfo.ChargedAmountInCents.ToString());
}
}
}
HttpContext.Current.Response.Clear();
HttpContext.Current.Response.Write("OK");
HttpContext.Current.Response.Flush();
return(orderInfo);
}
/// <summary>
/// Creates a payment request for this payment provider
/// </summary>
/// <param name="orderInfo"> </param>
/// <returns>Payment request</returns>
public PaymentRequest CreatePaymentRequest(OrderInfo orderInfo)
{
var paymentProvider = PaymentProvider.GetPaymentProvider(orderInfo.PaymentInfo.Id, orderInfo.StoreInfo.Alias);
#region build urls
var returnUrl = paymentProvider.SuccessUrl();
var reportUrl = paymentProvider.ReportUrl();
var testMode = paymentProvider.TestMode; //currently we don't have a testmode for easy-ideal this var is unused
#endregion
#region config helper
var merchantId = paymentProvider.GetSetting("merchantId");
var merchantKey = paymentProvider.GetSetting("merchantKey");
var merchantSecret = paymentProvider.GetSetting("merchantSecret");
var url = paymentProvider.GetSetting("url");
#endregion
var args = new SortedList <string, string>();
var ci = new CultureInfo("en-US");
args.Add("Amount", orderInfo.ChargedAmount.ToString("G", ci));
args.Add("Currency", "EUR");
args.Add("Bank", orderInfo.PaymentInfo.MethodId);
args.Add("Description", orderInfo.OrderNumber);
args.Add("Return", reportUrl);
var xmlRequest = GetXml(IDEAL_EXECUTE, args, merchantId, merchantKey, merchantSecret);
XDocument xmlResponse = XDocument.Parse(PostXml(xmlRequest, url));
var responseStatus = xmlResponse.Element("Response").Element("Status").FirstNode.ToString();
var transactionId = xmlResponse.Element("Response").Element("Response").Element("TransactionID").FirstNode.ToString();
var transactionCode = xmlResponse.Element("Response").Element("Response").Element("Code").FirstNode.ToString();
var bankUrl = HttpUtility.HtmlDecode(xmlResponse.Element("Response").Element("Response").Element("BankURL").FirstNode.ToString());
orderInfo.PaymentInfo.Url = bankUrl;
PaymentProviderHelper.SetTransactionId(orderInfo, transactionId); //transactionCode hierin verwerken??
//IO.Container.Resolve<IOrderUpdatingService>().AddCustomerFields(order, new Dictionary<string, string>({ "extraBilling", value }), CustomerDatatypes.Extra);
orderInfo.AddCustomerFields(new Dictionary <string, string> {
{ "extraTransactionCode", transactionCode }
}, Common.CustomerDatatypes.Extra);
orderInfo.Save();
return(new PaymentRequest());
}
public IPaymentServices GetPaymentReference(PaymentProvider paymentProvider)
{
if (paymentServiceReferences.TryGetValue(paymentProvider, out var reference))
{
return(reference);
}
throw new KeyNotFoundException($"This payment reference does not exist, {paymentProvider}");
}
public async Task <PaymentResponseModel> Pay(
int type,
[FromBody] PaymentModel paymentModel
)
{
PaymentProvider paymentProvider = new PaymentProvider(type);
return(await paymentProvider.PaymentService.Payment(paymentModel));
}
public OrderInfo HandlePaymentResponse(PaymentProvider paymentProvider, OrderInfo orderInfo)
{
var orderId = HttpContext.Current.Request.QueryString["orderid"] ?? "";
if (paymentProvider == null || string.IsNullOrEmpty(orderId))
{
return null;
}
orderInfo = OrderHelper.GetOrder(orderId);
if (orderInfo != null)
{
var localizedPaymentProvider = PaymentProvider.GetPaymentProvider(orderInfo.PaymentInfo.Id, orderInfo.StoreInfo.Alias);
var secret = paymentProvider.GetSetting("secret");
var amount = HttpContext.Current.Request.QueryString["amount"] ?? "0";
var validated = true;
if (secret != string.Empty)
{
var sb = new StringBuilder();
foreach (var key in HttpContext.Current.Request.QueryString.AllKeys)
{
if (key != "hash")
{
sb.Append(HttpContext.Current.Request.QueryString[key]);
}
}
var calculated = ePayPaymentBase.MD5(sb.ToString() + secret).ToUpperInvariant();
var incoming = (HttpContext.Current.Request.QueryString["hash"] ?? "").ToUpperInvariant();
validated = calculated == incoming;
if (!validated)
{
//checksum error
Log.Instance.LogError("Payment provider (ePay) error : Orderid " + orderId + " - incoming hash " + incoming + " - calculated hash " + calculated);
}
}
if (validated && (amount == orderInfo.ChargedAmountInCents.ToString()))
{
orderInfo.Paid = true;
orderInfo.Status = OrderStatus.ReadyForDispatch;
orderInfo.Save();
}
else
{
orderInfo.Paid = false;
orderInfo.Status = OrderStatus.PaymentFailed;
orderInfo.Save();
if (validated)
{
//checksum already logged, must be problem with amount
Log.Instance.LogError("Payment provider (ePay) error : Orderid " + orderId + " - incoming amount " + amount.ToString() + " - order amount " + orderInfo.ChargedAmountInCents.ToString());
}
}
}
HttpContext.Current.Response.Clear();
HttpContext.Current.Response.Write("OK");
HttpContext.Current.Response.Flush();
return orderInfo;
}
public void LoadData_ShouldCallReloadDataOnRepository()
{
IOC.UnitTest();
var mock = IOC.PaymentProviderRepository.SetupNewMock();
var paymentProvider = new PaymentProvider(1234);
IOC.PaymentProviderService.Actual().Resolve().LoadData(paymentProvider, Stubs.StubLocalization.Default);
mock.Verify(m => m.ReloadData(paymentProvider, It.IsAny <ILocalization>()));
}
public void ShouldReturnAllProvidersOneByOne()
{
for (int i = 0; i < Settings.Default.ProviderId.Count; i++)
{
PaymentProvider provider = ProviderFactory.GetProvider(Settings.Default.ProviderId[i]);
Assert.AreEqual(Settings.Default.ProviderClass[i], provider.GetType().FullName);
Assert.AreSame(provider, ProviderFactory.GetProvider(Settings.Default.ProviderId[i]));
}
}
public void LoadData_ShouldCallReloadDataOnRepository()
{
IOC.UnitTest();
var mock = IOC.PaymentProviderRepository.SetupNewMock();
var paymentProvider = new PaymentProvider(1234);
IOC.PaymentProviderService.Actual().Resolve().LoadData(paymentProvider, Stubs.StubLocalization.Default);
mock.Verify(m => m.ReloadData(paymentProvider, It.IsAny<ILocalization>()));
}
public BillingFulfillmentAdaptor(PaymentProvider paymentProvider, bool pricesIncludingVat, ILocalization localization)
{
_paymentProvider = paymentProvider;
Id = paymentProvider.Id;
Title = paymentProvider.Title;
Description = paymentProvider.Description;
Methods = new List<IBillingProviderMethod>(paymentProvider.PaymentProviderMethods.Select(m => new BillingMethodFulfillmentAdaptor(m, pricesIncludingVat, localization)));
Type = paymentProvider.Type;
Zones = paymentProvider.Zones;
Disabled = paymentProvider.Disabled;
}
public OrderInfo HandlePaymentResponse(PaymentProvider paymentProvider, OrderInfo order)
{
order.Paid = true;
order.Status = OrderStatus.ReadyForDispatch;
order.Save();
// if success then succes, otherwise error (todo)
order.RedirectUrl = paymentProvider.SuccessUrl();
return order;
}
public OrderInfo HandlePaymentResponse(PaymentProvider paymentProvider, OrderInfo orderInfo)
{
// Check for match
if (orderInfo != null && orderInfo.Paid == false)
{
if (!string.IsNullOrEmpty(orderInfo.PaymentInfo.Parameters))
{
var status = orderInfo.PaymentInfo.Parameters.Split('&')[0];
var message = orderInfo.PaymentInfo.Parameters.Split('&')[1];
// Get statusses from payment provider Response
switch (status.ToUpperInvariant())
{
case "OK":
orderInfo.Paid = true;
orderInfo.Status = OrderStatus.ReadyForDispatch;
break;
case "MALFORMED":
orderInfo.Paid = false;
orderInfo.Status = OrderStatus.PaymentFailed;
orderInfo.PaymentInfo.ErrorMessage = message;
Log.Instance.LogError("SagePay Payment Error: " + message);
break;
case "INVALID":
orderInfo.Paid = false;
orderInfo.Status = OrderStatus.PaymentFailed;
orderInfo.PaymentInfo.ErrorMessage = message;
Log.Instance.LogError("SagePay Payment Error: " + message);
break;
case "ERROR":
orderInfo.Paid = false;
orderInfo.Status = OrderStatus.Incomplete;
orderInfo.PaymentInfo.ErrorMessage = message;
Log.Instance.LogError("SagePay Payment Error: " + message);
break;
}
}
orderInfo.Save();
}
return orderInfo;
}
public OrderInfo HandlePaymentResponse(PaymentProvider paymentProvider, OrderInfo order)
{
var transactionId = HttpContext.Current.Request["trxid"];
if (string.IsNullOrEmpty(transactionId))
{
Log.Instance.LogDebug("IngAdvanced IPaymentResponseHandler transactionId == null");
return null;
}
if (order == null)
{
order = OrderHelper.GetOrder(transactionId);
}
if (order != null)
{
var status = RequestTransactionStatus(transactionId, order);
switch (status)
{
case Transaction.TransactionStatus.Success:
order.Paid = true;
order.Status = OrderStatus.ReadyForDispatch;
break;
case Transaction.TransactionStatus.Open:
order.Status = OrderStatus.WaitingForPaymentProvider;
break;
case Transaction.TransactionStatus.Failure:
case Transaction.TransactionStatus.Expired:
case Transaction.TransactionStatus.Cancelled:
order.Paid = false;
order.Status = OrderStatus.PaymentFailed;
order.PaymentInfo.ErrorMessage = status.ToString();
break;
default:
order.Paid = false;
order.Status = OrderStatus.PaymentFailed;
order.PaymentInfo.ErrorMessage = status.ToString();
break;
}
order.Save();
}
return order;
}
public OrderInfo HandleuWebshopPaymentResponse(PaymentProvider paymentProvider, OrderInfo order)
{
if (paymentProvider.Name == null)
{
Log.Instance.LogError("HandleuWebshopPaymentRequest paymentProvider.Name == null paymentProviderNodeId: " + paymentProvider.Id);
throw new Exception("HandleuWebshopPaymentRequest paymentProvider.Name == null");
}
var responsehandler = PaymentProviderHelper.GetAllPaymentResponseHandlers().FirstOrDefault(paymentResponseHandler => paymentResponseHandler.GetName().ToLower() == paymentProvider.Name.ToLower());
if (responsehandler == null)
{
Log.Instance.LogError("HandleuWebshopPaymentRequest responsehandler == null paymentProvider.Name: " + paymentProvider.Name);
throw new Exception("HandleuWebshopPaymentRequest responsehandler == null: " + paymentProvider.Name);
}
return responsehandler.HandlePaymentResponse(paymentProvider, order);
}
public OrderInfo HandlePaymentResponse(PaymentProvider paymentProvider, OrderInfo orderInfo)
{
var orderId = library.Request("ec");
var transactionId = library.Request("trxid");
var status = library.Request("status");
orderInfo = OrderHelper.GetOrder(transactionId);
if (orderInfo != null && orderInfo.Paid == false)
{
switch (status)
{
case "Success":
orderInfo.Paid = true;
orderInfo.Status = OrderStatus.ReadyForDispatch;
break;
case "Cancelled":
case "Expired":
case "Failure":
case "Reversed":
orderInfo.Paid = false;
orderInfo.Status = OrderStatus.PaymentFailed;
orderInfo.PaymentInfo.ErrorMessage = status;
break;
case "Open":
case "Pending":
orderInfo.Paid = false;
orderInfo.Status = OrderStatus.WaitingForPaymentProvider;
break;
}
orderInfo.Save();
}
else
{
Log.Instance.LogDebug("SISOW ORDERINFO == NULL!!!!");
}
return null;
}
/// <summary>
/// Initializes a new instance of the <see cref="PaymentConfigHelper"/> class.
/// </summary>
/// <param name="paymentProvider">The payment provider.</param>
public PaymentConfigHelper(PaymentProvider paymentProvider)
{
Provider = paymentProvider;
Settings = new ConfigSettings(Provider);
}
public OrderInfo HandlePaymentResponse(PaymentProvider paymentProvider, OrderInfo orderInfo)
{
try
{
var transactionId = HttpContext.Current.Request["transaction_id"];
Log.Instance.LogDebug("Mollie Transaction Id: " + transactionId);
if (string.IsNullOrEmpty(transactionId))
{
Log.Instance.LogError("Mollie: TransactionId IsNullOrEmpty");
return null;
}
orderInfo = OrderHelper.GetOrder(transactionId);
if (orderInfo == null)
{
Log.Instance.LogError("Mollie: Order Not Found For TransactionId: " + transactionId);
return null;
}
if (orderInfo.Paid != false)
{
Log.Instance.LogDebug("Mollie: Order already paid! TransactionId: " + transactionId);
return null;
}
var partnerId = paymentProvider.GetSetting("PartnerId");
var testMode = paymentProvider.TestMode;
var idealCheck = new IdealCheck(partnerId, testMode, transactionId);
if (idealCheck.Error)
{
if (idealCheck.Message != null)
{
Log.Instance.LogError(string.Format("Mollie idealCheck.Error Error! idealCheck.Message: {0}", idealCheck.Message));
}
if (idealCheck.ErrorMessage != null)
{
Log.Instance.LogError(string.Format("Mollie idealCheck.Error Error! idealCheck.ErrorMessage: {0}", idealCheck.ErrorMessage));
}
if (orderInfo.Status == OrderStatus.ReadyForDispatch)
{
return null;
}
orderInfo.Paid = false;
orderInfo.Status = OrderStatus.PaymentFailed;
if (idealCheck.ErrorMessage != null)
{
orderInfo.PaymentInfo.ErrorMessage = idealCheck.ErrorMessage;
}
}
if (idealCheck.Payed)
{
orderInfo.Paid = true;
orderInfo.Status = OrderStatus.ReadyForDispatch;
}
else
{
if (idealCheck.Message != null)
{
Log.Instance.LogError(string.Format("Mollie idealCheck.Payed Error! idealCheck.Message: {0}", idealCheck.Message));
}
if (idealCheck.ErrorMessage != null)
{
Log.Instance.LogError(string.Format("Mollie idealCheck.Payed Error! idealCheck.ErrorMessage: {0}", idealCheck.ErrorMessage));
}
orderInfo.Paid = false;
orderInfo.Status = OrderStatus.PaymentFailed;
orderInfo.PaymentInfo.ErrorMessage = idealCheck.ErrorMessage;
}
orderInfo.Save();
}
catch (Exception ex)
{
Log.Instance.LogError("MolliePaymentResponseHandler.HandlePaymentResponse: " + ex);
}
return null;
}
private PaymentProvider GetPaymentProvider([NotNull] Order order)
{
Assert.ArgumentNotNull(order, "order");
Assert.IsNotNull(order.PaymentMeans, "Order payment means cannot be null.");
if (this.paymentProvider == null)
{
string paymentSystemCode = order.PaymentMeans.PaymentChannelCode;
Assert.IsNotNullOrEmpty(paymentSystemCode, "Order payment channel code cannot be null or empty.");
this.paymentProvider = this.paymentProviderFactory.GetProvider(paymentSystemCode);
}
return this.paymentProvider;
}
/// <summary>
/// Handles the response
/// </summary>
public OrderInfo HandlePaymentResponse(PaymentProvider paymentProvider, OrderInfo orderInfo)
{
#region config helper
var merchantId = paymentProvider.GetSetting("merchantId");
var merchantKey = paymentProvider.GetSetting("merchantKey");
var merchantSecret = paymentProvider.GetSetting("merchantSecret");
var url = paymentProvider.GetSetting("url");
var transactionId = HttpContext.Current.Request["id"];
if (orderInfo == null)
{
orderInfo = OrderHelper.GetOrder(transactionId);
}
if (orderInfo == null)
{
Log.Instance.LogError("Easy iDeal response: Order Not Found For TransactionId: " + transactionId);
HttpContext.Current.Response.Redirect(paymentProvider.ErrorUrl());
return null;
}
// get the localized (for the right store) payment provider to get the right success/return urls
var localizedPaymentProvider = PaymentProvider.GetPaymentProvider(paymentProvider.Id, orderInfo.StoreInfo.Alias);
var redirectUrl = localizedPaymentProvider.ErrorUrl();
var successUrl = localizedPaymentProvider.SuccessUrl();
#endregion
try
{
var paymentStatus = HttpContext.Current.Request["status"];
var salt = HttpContext.Current.Request["salt"];
var checksum = HttpContext.Current.Request["checksum"];
if (string.IsNullOrEmpty(transactionId))
{
Log.Instance.LogError("Easy iDeal response: TransactionId IsNullOrEmpty");
HttpContext.Current.Response.Redirect(paymentProvider.ErrorUrl());
return null;
}
if (orderInfo.Paid != false)
{
Log.Instance.LogDebug("Easy iDeal response: Order already paid! TransactionId: " + transactionId);
HttpContext.Current.Response.Redirect(paymentProvider.ErrorUrl());
return null;
}
var transactionCode = OrderHelper.ExtraInformationValue(orderInfo, "extraTransactionCode");
if (string.IsNullOrEmpty(transactionCode))
{
Log.Instance.LogDebug("Easy iDeal response: OrderTransactionCode IsNullOrEmpty ");
HttpContext.Current.Response.Redirect(paymentProvider.ErrorUrl());
return null;
}
//check validity of request
if (CheckChecksumPaymentStatus(transactionId, transactionCode, paymentStatus, salt, checksum)) //only check for payment status if request is valid.
//This is a bit redundant, since you allready now the paymentStatus. But we could choose to do something with the extra info you get from this request e.g. IBAN
{
var args = new SortedList<string, string>
{
{"TransactionID", transactionId},
{"TransactionCode", transactionCode}
};
var xmlRequest = GetXml(TRANSACTIONSTATUS, args, merchantId, merchantKey, merchantSecret);
XDocument xmlResponse = XDocument.Parse(PostXml(xmlRequest, url));
var responseStatus = xmlResponse.Element("Response").Element("Status").FirstNode.ToString();
if (responseStatus == "OK")
{
if (xmlResponse.Element("Response").Element("Transaction").Element("Paid").FirstNode.ToString() == "Y")
{
orderInfo.Paid = true;
orderInfo.Status = OrderStatus.ReadyForDispatch;
redirectUrl = successUrl;
}
else
{
orderInfo.Paid = false;
orderInfo.Status = OrderStatus.PaymentFailed;
}
}
}
}
catch (Exception ex)
{
Log.Instance.LogError("EasyIdealPaymentResponseHandler.HandlePaymentResponse: " + ex);
}
HttpContext.Current.Response.Redirect(redirectUrl);
return orderInfo;
}
public OrderInfo HandlePaymentResponse(PaymentProvider paymentProvider, OrderInfo orderInfo)
{
var httpRequest = HttpContext.Current.Request;
var requestParams = new Dictionary<string, string>();
NameValueCollection httpRequestParams = httpRequest.HttpMethod == "POST" ? httpRequest.Form : httpRequest.QueryString;
foreach (string key in httpRequestParams)
{
requestParams.Add(key, httpRequest[key]);
}
var buckarooParams = new BuckarooResponseParameters(paymentProvider.GetSetting("SecretKey"), requestParams);
if (buckarooParams.IsValid())
{
HttpContext.Current.Response.Redirect(paymentProvider.ErrorUrl());
}
orderInfo = OrderHelper.GetOrder(buckarooParams.TransactionId);
if (orderInfo == null)
{
throw new ApplicationException("Buckaroo payment handler: no order found with transactionId " + buckarooParams.TransactionId);
}
var signatureFromBuckaroo = buckarooParams.Signature;
var calculatedSignature = buckarooParams.GetSignature();
if (string.Compare(signatureFromBuckaroo, calculatedSignature) != 0)
{
HttpContext.Current.Response.Redirect(paymentProvider.ErrorUrl());
}
Log.Instance.LogError("Buckaroo returned transactionId: " + buckarooParams.TransactionId + " resultCode: " + buckarooParams.StatusCode + " currency:" + buckarooParams.Currency + " amount: " + buckarooParams.Amount);
if (string.IsNullOrEmpty(buckarooParams.TransactionId))
{
HttpContext.Current.Response.Redirect(paymentProvider.ErrorUrl());
}
var localizedPaymentProvider = PaymentProvider.GetPaymentProvider(paymentProvider.Id, orderInfo.StoreInfo.Alias);
var succesUrl = localizedPaymentProvider.SuccessUrl();
var failUrl = localizedPaymentProvider.ErrorUrl();
var redirectUrl = succesUrl;
if (orderInfo.Paid == true)
{
Log.Instance.LogError("Buckaroo Already PAID returned transactionId: " + buckarooParams.TransactionId + " resultCode: " + buckarooParams.StatusCode + " currency:" + buckarooParams.Currency + " amount: " + buckarooParams.Amount);
HttpContext.Current.Response.Redirect(succesUrl);
HttpContext.Current.Response.End();
}
else
{
redirectUrl = failUrl;
}
//190 Succes: De transactie is geslaagd en de betaling is ontvangen / goedgekeurd. Definitief Ja
//490 Mislukt: De transactie is mislukt. Definitief Nee
//491 Validatie mislukt: De transactie verzoek bevatte fouten en kon niet goed verwerkt worden Definitief Nee
//492 Technische storing: Door een technische storing kon de transactie niet worden afgerond
//Definitief Nee
//690 Afgekeurd: De transactie is afgewezen door de (derde) payment provider. Definitief Nee
//790 In afwachting van invoer: De transactie is in de wacht, terwijl de payment enginge staat te wachten
//op de inbreng van de consument. Tijdelijk Nee
//791 In afwachting van verwerking: De transactie wordt verwerkt. Tijdelijk Nee
//792 In afwachting van de consument: de betaling Engine wacht voor de consument om terug te keren van
//een website van derden, die nodig is om de transactie te voltooien. Tijdelijk Nee
//793 De transactie is onhold.
//Tijdelijk Nee
//890 Geannuleerd door Gebruiker: De transactie is geannuleerd door de klant.
//Definitief Nee
//891 Geannuleerd door Merchant: De merchant heeft de transactie geannuleerd. Definitief Nee
switch (buckarooParams.StatusCode)
{
case "190":
orderInfo.Paid = true;
orderInfo.Status = OrderStatus.ReadyForDispatch;
redirectUrl = succesUrl;
break;
case "490":
orderInfo.Paid = false;
orderInfo.Status = OrderStatus.PaymentFailed;
redirectUrl = failUrl;
Log.Instance.LogError("Buckaroo ResponseHandler Transaction Failed (490) for transactionId: " + buckarooParams.TransactionId + " Ordernumber: " + orderInfo.OrderNumber);
break;
case "491":
orderInfo.Paid = false;
orderInfo.Status = OrderStatus.PaymentFailed;
redirectUrl = failUrl;
Log.Instance.LogError("Buckaroo ResponseHandler Validation Failed (491) for transactionId: " + buckarooParams.TransactionId + " Ordernumber: " + orderInfo.OrderNumber);
break;
case "492":
orderInfo.Paid = false;
orderInfo.Status = OrderStatus.PaymentFailed;
redirectUrl = failUrl;
Log.Instance.LogError("Buckaroo ResponseHandler Technical Failure (492) for transactionId: " + buckarooParams.TransactionId + " Ordernumber: " + orderInfo.OrderNumber);
break;
case "690":
orderInfo.Paid = false;
orderInfo.Status = OrderStatus.PaymentFailed;
redirectUrl = failUrl;
Log.Instance.LogError("Buckaroo ResponseHandler Payment Denied by 3rd Party (690) for transactionId: " + buckarooParams.TransactionId + " Ordernumber: " + orderInfo.OrderNumber);
break;
case "790":
orderInfo.Paid = false;
orderInfo.Status = OrderStatus.WaitingForPayment;
redirectUrl = failUrl;
Log.Instance.LogError("Buckaroo ResponseHandler Waiting for customer input (790) for transactionId: " + buckarooParams.TransactionId + " Ordernumber: " + orderInfo.OrderNumber);
break;
case "791":
orderInfo.Paid = false;
orderInfo.Status = OrderStatus.WaitingForPayment;
redirectUrl = failUrl;
Log.Instance.LogError("Buckaroo ResponseHandler Waiting for transaction handling (791) for transactionId: " + buckarooParams.TransactionId + " Ordernumber: " + orderInfo.OrderNumber);
break;
case "792":
orderInfo.Paid = false;
orderInfo.Status = OrderStatus.WaitingForPayment;
redirectUrl = failUrl;
Log.Instance.LogError("Buckaroo ResponseHandler Waiting for customer to return from 3rd party website (792) for transactionId: " + buckarooParams.TransactionId + " Ordernumber: " + orderInfo.OrderNumber);
break;
case "793":
orderInfo.Paid = false;
orderInfo.Status = OrderStatus.WaitingForPayment;
redirectUrl = failUrl;
Log.Instance.LogError("Buckaroo ResponseHandler Transaction is On Hold (793) for transactionId: " + buckarooParams.TransactionId + " Ordernumber: " + orderInfo.OrderNumber);
break;
case "890":
orderInfo.Paid = false;
orderInfo.Status = OrderStatus.WaitingForPayment;
redirectUrl = failUrl;
Log.Instance.LogError("Buckaroo ResponseHandler Transaction Cancelled by Customer (890) for transactionId: " + buckarooParams.TransactionId + " Ordernumber: " + orderInfo.OrderNumber);
break;
case "891":
orderInfo.Paid = false;
orderInfo.Status = OrderStatus.WaitingForPayment;
redirectUrl = failUrl;
Log.Instance.LogError("Buckaroo ResponseHandler Transaction Cancelled by Merchant (891) for transactionId: " + buckarooParams.TransactionId + " Ordernumber: " + orderInfo.OrderNumber);
break;
}
orderInfo.Save();
HttpContext.Current.Response.Redirect(redirectUrl);
return orderInfo;
}
// **** Helper Methods ****
public static string GetValue(string key)
{
var basket = API.Basket.GetBasket();
var paymentProvider = new PaymentProvider(basket.Payment.Providers.FirstOrDefault().Id);
return paymentProvider.GetSetting(key);
}
public OrderInfo HandlePaymentResponse(PaymentProvider paymentProvider, OrderInfo orderInfo)
{
var data = HttpContext.Current.Request["Data"];
var seal = HttpContext.Current.Request["Seal"];
Log.Instance.LogDebug("Omnikassa data: " + data + " Omnikassa seal: " + seal);
var securityKey = paymentProvider.GetSetting("SecurityKey");
// Verifieer de Seal
var sha256 = SHA256.Create();
var hashValue = sha256.ComputeHash(new UTF8Encoding().GetBytes(data + securityKey));
if (seal.ToLower() == ByteArrayToHexString(hashValue).ToLower()) // Seal is goed
{
// Lees de gewenste waarden uit de server response
var dataItems = ParseData(data);
var transactionCode = dataItems.First(i => i.Key == "transactionReference").Value;
var responseCode = dataItems.First(i => i.Key == "responseCode").Value;
Log.Instance.LogDebug("Omnikassa transactionCode: " + transactionCode + " responseCode: " + responseCode);
orderInfo = OrderHelper.GetOrder(transactionCode);
Log.Instance.LogDebug("Omnikassa orderInfo: " + orderInfo.OrderNumber);
var successUrl = paymentProvider.SuccessUrl();
var cancelUrl = paymentProvider.ErrorUrl();
var redirectUrl = successUrl;
//Code Beschrijving
//00 Transaction success, authorization accepted (transactie gelukt, autorisatie geaccepteerd).
//02 Please call the bank because the authorization limit on the card has been exceeded (neem contact op met de bank; de autorisatielimiet op de kaart is overschreden)
//03 Invalid merchant contract (ongeldig contract webwinkel)
//05 Do not honor, authorization refused (niet inwilligen, autorisatie geweigerd)
//12 Invalid transaction, check the parameters sent in the request (ongeldige transactie, controleer de in het verzoek verzonden parameters).
//14 Invalid card number or invalid Card Security Code or Card (for
//MasterCard) or invalid Card Verification Value (for Visa/MAESTRO) (ongeldig kaartnummer of ongeldige beveiligingscode of kaart (voor MasterCard) of ongeldige waarde kaartverificatie (voor Visa/MAESTRO))
//17 Cancellation of payment by the end user (betaling geannuleerd door eindgebruiker/klant)
//24 Invalid status (ongeldige status).
//25 Transaction not found in database (transactie niet gevonden in database)
//30 Invalid format (ongeldig formaat)
//34 Fraud suspicion (vermoeden van fraude)
//40 Operation not allowed to this Merchant (handeling niet toegestaan voor deze webwinkel)
//60 Pending transaction (transactie in behandeling)
//63 Security breach detected, transaction stopped (beveiligingsprobleem gedetecteerd, transactie gestopt).
//75 The number of attempts to enter the card number has been exceeded (three tries exhausted) (het aantal beschikbare pogingen om het card‐nummer in te geven is overschreden (max. drie))
//90 Acquirer server temporarily unavailable (server acquirer tijdelijk onbeschikbaar)
//94 Duplicate transaction (duplicaattransactie). (transactiereferentie al gereserveerd)
//97 Request time‐out; transaction refused (time‐out voor verzoek; transactie geweigerd)
//99 Payment page temporarily unavailable (betaalpagina tijdelijk niet beschikbaar)
if (orderInfo.Paid == false)
{
switch (responseCode)
{
case "00":
orderInfo.Paid = true;
orderInfo.Status = OrderStatus.ReadyForDispatch;
break;
case "60":
case "90":
orderInfo.Paid = false;
orderInfo.Status = OrderStatus.WaitingForPaymentProvider;
break;
case "17":
orderInfo.Paid = false;
orderInfo.Status = OrderStatus.PaymentFailed;
orderInfo.PaymentInfo.ErrorMessage = "CANCELLED";
redirectUrl = cancelUrl;
break;
case "EXPIRED":
orderInfo.Paid = false;
orderInfo.Status = OrderStatus.PaymentFailed;
orderInfo.PaymentInfo.ErrorMessage = "EXPIRED";
redirectUrl = cancelUrl;
break;
default:
orderInfo.Paid = false;
orderInfo.Status = OrderStatus.WaitingForPaymentProvider;
redirectUrl = cancelUrl;
break;
}
orderInfo.Save();
}
HttpContext.Current.Response.Redirect(redirectUrl);
}
else
{
throw new Exception("SEAL BROKEN");
}
return orderInfo;
}
public void LoadData(PaymentProvider paymentProvider, ILocalization localization)
{
_paymentProviderRepository.ReloadData(paymentProvider, localization);
}
/// <summary>
/// Handles the response
/// </summary>
public OrderInfo HandlePaymentResponse(PaymentProvider paymentProvider, OrderInfo orderInfo)
{
var payPalTestMode = paymentProvider != null && paymentProvider.TestMode;
var liveUrl = "https://www.paypal.com/cgi-bin/webscr";
var testUrl = "https://www.sandbox.paypal.com/us/cgi-bin/webscr";
var configLiveUrl = paymentProvider.GetSetting("Url");
var configTestUrl = paymentProvider.GetSetting("testUrl");
if (!string.IsNullOrEmpty(configLiveUrl))
{
liveUrl = configLiveUrl;
}
if (!string.IsNullOrEmpty(configTestUrl))
{
testUrl = configTestUrl;
}
var req = payPalTestMode ? (HttpWebRequest)WebRequest.Create(testUrl) : (HttpWebRequest)WebRequest.Create(liveUrl);
//Set values for the request back
req.Method = "POST";
req.ContentType = "application/x-www-form-urlencoded";
var param = HttpContext.Current.Request.BinaryRead(HttpContext.Current.Request.ContentLength);
var strRequest = Encoding.ASCII.GetString(param);
strRequest += "&cmd=_notify-validate";
req.ContentLength = strRequest.Length;
//for proxy
//WebProxy proxy = new WebProxy(new Uri("http://url:port#"));
//req.Proxy = proxy;
//Send the request to PayPal and get the response
var streamOut = new StreamWriter(req.GetRequestStream(), Encoding.ASCII);
streamOut.Write(strRequest);
streamOut.Close();
var streamIn = new StreamReader(req.GetResponse().GetResponseStream());
var strResponse = streamIn.ReadToEnd();
streamIn.Close();
Log.Instance.LogDebug("PAYPAL RETURN strResponse: " + strResponse);
switch (strResponse)
{
case "VERIFIED":
{
// PayPal POSTS some values
var paymentStatus = HttpContext.Current.Request["payment_status"];
Log.Instance.LogDebug("PAYPAL RETURN paymentStatus: " + paymentStatus);
// Get identifier created with the RequestHandler
var transactionId = HttpContext.Current.Request["custom"];
Log.Instance.LogDebug("PAYPAL RETURN transactionId: " + transactionId);
// Match identifier to order
var order = OrderHelper.GetOrder(transactionId);
// Check for match
if (order != null && order.Paid == false)
{
Log.Instance.LogDebug("PAYPAL RETURN STATUS: " + paymentStatus);
// Get statusses from payment provider Response
switch (paymentStatus)
{
case "Completed":
order.Paid = true;
order.Status = OrderStatus.ReadyForDispatch;
break;
case "Failed":
order.Paid = false;
order.Status = OrderStatus.PaymentFailed;
break;
case "Denied":
order.Paid = false;
order.Status = OrderStatus.PaymentFailed;
break;
case "Pending":
order.Status = OrderStatus.WaitingForPaymentProvider;
break;
}
order.Save();
orderInfo = order;
}
}
break;
case "INVALID":
break;
}
return orderInfo;
}
public OrderInfo HandlePaymentResponse(PaymentProvider paymentProvider, OrderInfo orderInfo)
{
var transactionId = HttpContext.Current.Request["transactionid"];
if (string.IsNullOrEmpty(transactionId))
{
Log.Instance.LogDebug("MultiSafePay IPaymentResponseHandler transactionId == null");
return null;
}
orderInfo = OrderHelper.GetOrder(transactionId);
if (orderInfo.Paid != false)
{
Log.Instance.LogDebug("MultiSafePay IPaymentResponseHandler Order Already Paid for transactionId: " + transactionId);
return null;
}
var accountId = paymentProvider.GetSetting("accountId");
var siteId = paymentProvider.GetSetting("siteId");
var siteSecureId = paymentProvider.GetSetting("siteSecureId");
var testURL = paymentProvider.GetSetting("testURL");
var liveUrl = paymentProvider.GetSetting("url");
var statusRequest = new StatusRequest
{
AccountId = long.Parse(accountId),
TransactionId = transactionId,
SiteId = long.Parse(siteId),
SiteSecureId = long.Parse(siteSecureId)
};
var apiURL = paymentProvider.TestMode ? testURL : liveUrl;
try
{
var httpWebRequest = (HttpWebRequest) WebRequest.Create(apiURL);
httpWebRequest.Method = "POST";
httpWebRequest.ContentLength = Encoding.UTF8.GetByteCount(statusRequest.GetXml());
httpWebRequest.ContentType = "application/x-www-form-urlencoded";
var streamWriter = new StreamWriter(httpWebRequest.GetRequestStream());
streamWriter.Write(statusRequest.GetXml());
streamWriter.Close();
var httpWebResponse = (HttpWebResponse) httpWebRequest.GetResponse();
var streamReader = new StreamReader(httpWebResponse.GetResponseStream());
var xmlDoc = XDocument.Parse(streamReader.ReadToEnd());
Log.Instance.LogDebug("MultiSafePay IPaymentResponseHandler XML Answer: " + HttpUtility.HtmlEncode(xmlDoc.ToString(SaveOptions.None)));
var ewallet = xmlDoc.Root.Element("ewallet");
var status = ewallet.Element("status").Value;
orderInfo.Status = OrderStatus.WaitingForPayment;
//– completed: succesvol voltooid
//– initialized: aangemaakt, maar nog niet voltooid
//– uncleared: aangemaakt, maar nog niet vrijgesteld (credit cards)
//– void: geannuleerd
//– declined: afgewezen
//– refunded: terugbetaald
//– expired: verlopen
switch (status)
{
case "completed":
orderInfo.Paid = true;
orderInfo.Status = OrderStatus.ReadyForDispatch;
break;
case "uncleared":
orderInfo.Status = OrderStatus.WaitingForPaymentProvider;
break;
case "declined":
orderInfo.Paid = false;
orderInfo.Status = OrderStatus.PaymentFailed;
orderInfo.PaymentInfo.ErrorMessage = status;
break;
case "expired":
orderInfo.Paid = false;
orderInfo.Status = OrderStatus.PaymentFailed;
orderInfo.PaymentInfo.ErrorMessage = status;
break;
case "void":
orderInfo.Paid = false;
orderInfo.Status = OrderStatus.PaymentFailed;
orderInfo.PaymentInfo.ErrorMessage = status;
break;
}
orderInfo.Save();
}
catch (Exception ex)
{
Log.Instance.LogError("MultiSafePayPaymentResponseHandler.HandlePaymentResponse: " + ex);
}
return orderInfo;
}
internal ConfigSettings(PaymentProvider provider)
{
_provider = provider;
LoadProviderSettings();
}
public OrderInfo HandlePaymentResponse(PaymentProvider paymentProvider, OrderInfo orderInfo)
{
// Ogone POSTS some values
var transactionId = HttpContext.Current.Request["TransactionId"];
var status = HttpContext.Current.Request["STATUS"];
if (string.IsNullOrEmpty(transactionId))
{
Log.Instance.LogError("Ogone TransactionId not Found!");
return null;
}
orderInfo = OrderHelper.GetOrder(transactionId);
Log.Instance.LogDebug("OGONE OrderNumber: " + orderInfo.OrderNumber + " TransactionID: " + transactionId + " Status: " + status);
var localizedPaymentProvider = PaymentProvider.GetPaymentProvider(orderInfo.PaymentInfo.Id, orderInfo.StoreInfo.Alias);
var returnUrl = localizedPaymentProvider.SuccessUrl();
var errorUrl = localizedPaymentProvider.ErrorUrl();
var cancelUrl = localizedPaymentProvider.CancelUrl();
var redirectUrl = returnUrl;
//0 Ongeldig of onvolledig
//1 Geannuleerd door de klant
//2 Autorisatie geweigerd
//4 Opgeslagen bestelling
//40
//41 Wachten op klantbetaling
//5 Geautoriseerd
//50
//51 Autorisatie pending
//52 Autorisatie onzeker
//55 Stand-by
//56 OK met geplande betalingen
//57
//59 Manueel te bekomen autorisatie
//6 Geautoriseerd en geannuleerd
//61 Annul. autor. pending
//62 Annul. autor. onzeker
//63 Annul. autor. geweigerd
//64 Geautoriseerd en geannuleerd
//7 Betaling geannuleerd
//71 Annul.betaling pending
//72 Annul. betaling onzeker
//73 Annul betaling geweigerd
//74 Betaling geannuleerd
//75 Annul. betaling verwerkt door merch
//8 Terugbetaald
//81 Terugbetaling pending
//82 Terugbetaling onzeker
//83 Terugbetaling geweigerd
//84 Betaling geweigerd door de bank
//85 Terugbet. verwerkt door merchant
//9 Betaling aangevraagd
//91 Betaling pending
//92 Betaling onzeker
//93 Betaling geweigerd
//94 Terubetaling geweigerd door de bank
//95 Betaling verwerkt door merchant
//99 Wordt verwerkt
if (orderInfo.Paid == false)
{
switch (status)
{
case "1":
orderInfo.Paid = false;
orderInfo.Status = OrderStatus.PaymentFailed;
orderInfo.PaymentInfo.ErrorMessage = status;
redirectUrl = cancelUrl;
break;
case "5":
case "9":
orderInfo.Paid = true;
orderInfo.Status = OrderStatus.ReadyForDispatch;
break;
case "0":
case "2":
case "61":
case "62":
case "63":
case "71":
case "72":
case "73":
case "74":
case "75":
case "93":
orderInfo.Paid = false;
orderInfo.Status = OrderStatus.PaymentFailed;
orderInfo.PaymentInfo.ErrorMessage = status;
redirectUrl = errorUrl;
break;
default:
orderInfo.Status = OrderStatus.WaitingForPaymentProvider;
break;
}
orderInfo.Save();
}
HttpContext.Current.Response.Redirect(redirectUrl);
return orderInfo;
}
