public virtual PaymentOrder CreateOrUpdatePaymentOrder(IOrderGroup orderGroup, string description,
string consumerProfileRef = null)
{
//return string.IsNullOrWhiteSpace(orderId) ? CreateOrder(orderGroup, userAgent, consumerProfileRef) : UpdateOrder(orderId, orderGroup, userAgent);
return
(CreatePaymentOrder(orderGroup, description, consumerProfileRef)); //TODO Change to UpdateOrder when SwedbankPay Api supports updating of orderitems
}
public override bool Process(IPayment payment, IOrderForm orderForm, IOrderGroup orderGroup, IShipment shipment, ref string message)
{
if (payment.TransactionType == TransactionType.Void.ToString())
{
try
{
var orderId = orderGroup.Properties[Common.Constants.KlarnaOrderIdField]?.ToString();
if (!string.IsNullOrEmpty(orderId))
{
KlarnaOrderService.CancelOrder(orderId);
payment.Status = PaymentStatus.Processed.ToString();
AddNoteAndSaveChanges(orderGroup, payment.TransactionType, "Order cancelled at Klarna");
return(true);
}
}
catch (Exception ex) when(ex is ApiException || ex is WebException)
{
var exceptionMessage = GetExceptionMessage(ex);
payment.Status = PaymentStatus.Failed.ToString();
message = exceptionMessage;
AddNoteAndSaveChanges(orderGroup, payment.TransactionType, $"Error occurred {exceptionMessage}");
Logger.Error(exceptionMessage, ex);
return(false);
}
}
else if (Successor != null)
{
return(Successor.Process(payment, orderForm, orderGroup, shipment, ref message));
}
return(false);
}
public virtual PaymentOrderRequest GetPaymentOrderRequest(
IOrderGroup orderGroup, IMarket market, PaymentMethodDto paymentMethodDto, string description, string consumerProfileRef = null)
{
if (orderGroup == null)
{
throw new ArgumentNullException(nameof(orderGroup));
}
if (market == null)
{
throw new ArgumentNullException(nameof(market));
}
var marketCountry = CountryCodeHelper.GetTwoLetterCountryCode(market.Countries.FirstOrDefault());
if (string.IsNullOrWhiteSpace(marketCountry))
{
throw new ConfigurationException($"Please select a country in Commerce Manager for market {orderGroup.MarketId}");
}
List <OrderItem> orderItems = new List <OrderItem>();
foreach (var orderGroupForm in orderGroup.Forms)
{
foreach (var shipment in orderGroupForm.Shipments)
{
orderItems.AddRange(GetOrderItems(market, orderGroup.Currency, shipment.ShippingAddress, shipment.LineItems));
orderItems.Add(GetShippingOrderItem(shipment, market));
}
}
return(CreatePaymentOrderRequest(orderGroup, market, consumerProfileRef, orderItems, description));
}
private Urls GetMerchantUrls(IOrderGroup orderGroup, IMarket market, string payeeReference)
{
var checkoutConfiguration = _checkoutConfigurationLoader.GetConfiguration(market.MarketId);
Uri ToFullSiteUrl(Func <CheckoutConfiguration, Uri> fieldSelector)
{
if (fieldSelector(checkoutConfiguration) == null)
{
return(null);
}
var url = fieldSelector(checkoutConfiguration).OriginalString
.Replace("{orderGroupId}", orderGroup.OrderLink.OrderGroupId.ToString())
.Replace("{payeeReference}", payeeReference);
var uriBuilder = new UriBuilder(url);
if (!uriBuilder.Uri.IsAbsoluteUri)
{
return(new Uri(SiteDefinition.Current.SiteUrl, uriBuilder.Uri.PathAndQuery));
}
return(uriBuilder.Uri);
}
var cancelUrl = checkoutConfiguration.PaymentUrl != null?ToFullSiteUrl(c => c.CancelUrl) : null;
return(new Urls(checkoutConfiguration.HostUrls, ToFullSiteUrl(c => c.CompleteUrl),
checkoutConfiguration.TermsOfServiceUrl, ToFullSiteUrl(c => c.CancelUrl), ToFullSiteUrl(c => c.PaymentUrl),
ToFullSiteUrl(c => c.CallbackUrl), checkoutConfiguration.LogoUrl));
}
private IPromotionResult PromotionResult(IOrderGroup orderGroup, BuyXFromCategoryGetProductForFree promotion,
FulfillmentStatus fulfillment)
{
BuyXFromCategoryGetProductForFreeResult result = null;
switch (fulfillment)
{
case FulfillmentStatus.NotFulfilled:
result = new BuyXFromCategoryGetProductForFreeResult(fulfillment,
"The promotion is not fulfilled.");
break;
case FulfillmentStatus.PartiallyFulfilled:
result = new BuyXFromCategoryGetProductForFreeResult(fulfillment,
"The promotion is somewhat fulfilled.");
break;
case FulfillmentStatus.Fulfilled:
{
VariationContent content = _contentLoader.Get <VariationContent>(promotion.FreeProduct);
result = new BuyXFromCategoryGetProductForFreeResult(fulfillment,
string.Format("The promotion is fulfilled and it has been applied to item {0}", content.Name),
content, orderGroup as OrderGroup);
break;
}
}
return(result);
}
/// <summary>
/// When an order needs to be captured the cartridge needs to make an API Call
/// POST /ordermanagement/v1/orders/{order_id}/captures for the amount which needs to be captured.
/// If it's a partial capture the API call will be the same just for the
/// amount that should be captured. Many captures can be made up to the whole amount authorized.
/// The shipment information can be added in this call or amended aftewards using the method
/// "Add shipping info to a capture".
/// The amount captured never can be greater than the authorized.
/// When an order is Partally Captured the status of the order in Klarna is PART_CAPTURED
/// </summary>
public override bool Process(IPayment payment, IOrderForm orderForm, IOrderGroup orderGroup, IShipment shipment, ref string message)
{
if (payment.TransactionType == TransactionType.Capture.ToString())
{
var amount = AmountHelper.GetAmount(payment.Amount);
var orderId = orderGroup.Properties[Common.Constants.KlarnaOrderIdField]?.ToString();
if (!string.IsNullOrEmpty(orderId))
{
try
{
var captureData = KlarnaOrderService.CaptureOrder(orderId, amount, "Capture the payment", orderGroup, orderForm, payment, shipment);
AddNoteAndSaveChanges(orderGroup, payment.TransactionType, $"Captured {payment.Amount}, id {captureData.CaptureId}");
}
catch (Exception ex) when(ex is ApiException || ex is WebException)
{
var exceptionMessage = GetExceptionMessage(ex);
payment.Status = PaymentStatus.Failed.ToString();
message = exceptionMessage;
AddNoteAndSaveChanges(orderGroup, payment.TransactionType, $"Error occurred {exceptionMessage}");
Logger.Error(exceptionMessage, ex);
return(false);
}
}
return(true);
}
else if (Successor != null)
{
return(Successor.Process(payment, orderForm, orderGroup, shipment, ref message));
}
return(false);
}
private PaymentStepResult ProcessFraudUpdate(IPayment payment, IOrderGroup orderGroup)
{
var paymentStepResult = new PaymentStepResult();
if (payment.HasFraudStatus(NotificationFraudStatus.FRAUD_RISK_ACCEPTED))
{
payment.Status = PaymentStatus.Processed.ToString();
OrderStatusManager.ReleaseHoldOnOrder((PurchaseOrder)orderGroup);
AddNoteAndSaveChanges(orderGroup, payment.TransactionType, "Klarna fraud risk accepted");
paymentStepResult.Status = true;
return(paymentStepResult);
}
if (payment.HasFraudStatus(NotificationFraudStatus.FRAUD_RISK_REJECTED))
{
payment.Status = PaymentStatus.Failed.ToString();
OrderStatusManager.HoldOrder((PurchaseOrder)orderGroup);
AddNoteAndSaveChanges(orderGroup, payment.TransactionType, "Klarna fraud risk rejected");
paymentStepResult.Status = true;
return(paymentStepResult);
}
if (payment.HasFraudStatus(NotificationFraudStatus.FRAUD_RISK_STOPPED))
{
payment.Status = PaymentStatus.Failed.ToString();
OrderStatusManager.HoldOrder((PurchaseOrder)orderGroup);
AddNoteAndSaveChanges(orderGroup, payment.TransactionType, "Klarna fraud risk stopped");
paymentStepResult.Status = true;
return(paymentStepResult);
}
paymentStepResult.Message = $"Can't process authorization. Unknown fraud notification: {payment.Properties[Common.Constants.FraudStatusPaymentField]} or no fraud notifications received so far.";
return(paymentStepResult);
}
/// <summary>
/// Processes the successful transaction, was called when Payoo Gateway redirect back.
/// </summary>
/// <param name="orderGroup">The order group that was processed.</param>
/// <param name="payment">The order payment.</param>
/// <param name="acceptUrl">The redirect url when finished.</param>
/// <param name="cancelUrl">The redirect url when error happens.</param>
/// <returns>The url redirection after process.</returns>
public string ProcessSuccessfulTransaction(IOrderGroup orderGroup, IPayment payment, string acceptUrl, string cancelUrl)
{
if (HttpContext.Current == null)
{
return(cancelUrl);
}
var cart = orderGroup as ICart;
if (cart == null)
{
// return to the shopping cart page immediately and show error messages
return(ProcessUnsuccessfulTransaction(cancelUrl, "Commit Tran Error Cart Null"));
}
// everything is fine
var errorMessages = new List <string>();
var cartCompleted = _payooCartService.DoCompletingCart(cart, errorMessages);
if (!cartCompleted)
{
return(UriUtil.AddQueryString(cancelUrl, "message", string.Join(";", errorMessages.Distinct().ToArray())));
}
// Place order
var purchaseOrder = _payooCartService.MakePurchaseOrder(cart, payment);
var redirectionUrl = CreateRedirectionUrl(purchaseOrder, acceptUrl);
_logger.Info($"Payoo transaction succeeds, redirect end user to {redirectionUrl}");
return(redirectionUrl);
}
public override PaymentStepResult ProcessAuthorization(IPayment payment, IOrderGroup orderGroup)
{
var paymentStepResult = new PaymentStepResult();
var orderId = orderGroup.Properties[Constants.SwedbankPayOrderIdField]?.ToString();
if (!string.IsNullOrEmpty(orderId))
{
try
{
var result = AsyncHelper.RunSync(() => SwedbankPayClient.PaymentOrders.Get(new Uri(orderId, UriKind.Relative), Sdk.PaymentOrders.PaymentOrderExpand.All));
var transaction = result.PaymentOrderResponse.CurrentPayment.Payment.Transactions.TransactionList?.FirstOrDefault();
if (transaction != null)
{
payment.ProviderTransactionID = transaction.Number;
AddNoteAndSaveChanges(orderGroup, payment.TransactionType, $"Authorize completed at SwedbankPay, Transaction number: {transaction.Number}");
paymentStepResult.Status = true;
}
}
catch (Exception ex)
{
payment.Status = PaymentStatus.Failed.ToString();
paymentStepResult.Message = ex.Message;
AddNoteAndSaveChanges(orderGroup, payment.TransactionType, $"Error occurred {ex.Message}");
Logger.Error(ex.Message, ex);
}
return(paymentStepResult);
}
return(paymentStepResult);
}
/// <summary>
/// Initialize a payment request from an <see cref="OrderGroup"/> instance. Adds order number, amount, timestamp, buyer information etc.
/// </summary>
/// <param name="payment">The <see cref="VerifonePaymentRequest"/> instance to initialize</param>
/// <param name="orderGroup"><see cref="OrderGroup"/></param>
public virtual void InitializePaymentRequest(VerifonePaymentRequest payment, IOrderGroup orderGroup)
{
IOrderAddress billingAddress = FindBillingAddress(payment, orderGroup);
IOrderAddress shipmentAddress = FindShippingAddress(payment, orderGroup);
payment.OrderTimestamp = orderGroup.Created.ToString("yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture);
payment.MerchantAgreementCode = GetMerchantAgreementCode(payment);
payment.PaymentLocale = GetPaymentLocale(ContentLanguage.PreferredCulture);
payment.OrderNumber = orderGroup.OrderLink.OrderGroupId.ToString(CultureInfo.InvariantCulture.NumberFormat);
payment.OrderCurrencyCode = IsProduction(payment)
? Iso4217Lookup.LookupByCode(CurrentMarket.DefaultCurrency.CurrencyCode).Number.ToString()
: "978";
var totals = OrderGroupCalculator.GetOrderGroupTotals(orderGroup);
payment.OrderGrossAmount = totals.Total.ToVerifoneAmountString();
var netAmount = orderGroup.PricesIncludeTax ? totals.Total : totals.Total - totals.TaxTotal;
payment.OrderNetAmount = netAmount.ToVerifoneAmountString();
payment.OrderVatAmount = totals.TaxTotal.ToVerifoneAmountString();
payment.BuyerFirstName = billingAddress?.FirstName;
payment.BuyerLastName = billingAddress?.LastName;
payment.OrderVatPercentage = "0";
payment.PaymentMethodCode = "";
payment.SavedPaymentMethodId = "";
payment.RecurringPayment = "0";
payment.DeferredPayment = "0";
payment.SavePaymentMethod = "0";
payment.SkipConfirmationPage = "0";
string phoneNumber = billingAddress?.DaytimePhoneNumber ?? billingAddress?.EveningPhoneNumber;
if (string.IsNullOrWhiteSpace(phoneNumber) == false)
{
payment.BuyerPhoneNumber = phoneNumber;
}
payment.BuyerEmailAddress = billingAddress?.Email ?? orderGroup.Name ?? string.Empty;
if (payment.BuyerEmailAddress.IndexOf('@') < 0)
{
payment.BuyerEmailAddress = null;
}
payment.DeliveryAddressLineOne = shipmentAddress?.Line1;
if (shipmentAddress != null && string.IsNullOrWhiteSpace(shipmentAddress.Line2) == false)
{
payment.DeliveryAddressLineTwo = shipmentAddress.Line2;
}
payment.DeliveryAddressPostalCode = shipmentAddress?.PostalCode;
payment.DeliveryAddressCity = shipmentAddress?.City;
payment.DeliveryAddressCountryCode = "246";
ApplyPaymentMethodConfiguration(payment);
}
public PaymentProcessingResult ProcessPayment(IOrderGroup orderGroup, IPayment payment)
{
var message = "message";
var redirectUrl = CreateRedirectUrl(orderGroup);
return(PaymentProcessingResult.CreateSuccessfulResult(message, redirectUrl));
}
public PaymentProcessingResult ProcessPayment(IOrderGroup orderGroup, IPayment payment)
{
if (payment.TransactionType != TransactionType.Authorization.ToString() ||
payment.Status != PaymentStatus.Pending.ToString())
{
return(PaymentProcessingResult.CreateSuccessfulResult(string.Empty));
}
var settings = ServiceLocator.Current.GetInstance <IVerifoneSettings>();
if (settings == null)
{
throw new ArgumentException($"Configure a default instance for {nameof(IVerifoneSettings)}", nameof(settings));
}
var urlResolver = ServiceLocator.Current.GetInstance <UrlResolver>();
var redirectUrl = urlResolver.GetUrl(settings.PaymentRedirectPage);
if (!string.IsNullOrEmpty(settings.PaymentRedirectAction))
{
redirectUrl = VirtualPathUtility.AppendTrailingSlash(redirectUrl);
redirectUrl += settings.PaymentRedirectAction;
}
return(PaymentProcessingResult.CreateSuccessfulResult("Redirection is required", redirectUrl));
}
// previously used, get it back in
protected virtual string CreateCustomRewardDescriptionText(
IEnumerable <RewardDescription> rewardDescriptions
, FulfillmentStatus fulfillmentStatus
, MyPercentagePromotion promotion
, IOrderGroup orderGroup)
{
/*var contentNames = GetContentNames(affectedItems); // local method*/
string contentNames = String.Empty;
IEnumerable <ILineItem> lineItems = orderGroup.GetAllLineItems();
if (fulfillmentStatus == FulfillmentStatus.Fulfilled)
{
return(String.Format(CultureInfo.InvariantCulture, "{0}% discount has been given for the items '{1}'!"
, promotion.PercentageDiscount, contentNames));
}
if (fulfillmentStatus == FulfillmentStatus.PartiallyFulfilled) // have 3 items in cart --> gets this
{
//var remainingQuantity = promotion.MinNumberOfItems - rewardDescriptions.Sum(x => x.or.Quantity);
var remainingQuantity = promotion.MinNumberOfItems.RequiredQuantity - lineItems.Count();
return(String.Format(CultureInfo.InvariantCulture, "Buy {0} more items and get a {1}% discount!"
, remainingQuantity, promotion.PercentageDiscount));
}
return("The promotion is not applicable for the current order.");
}
public IOrderAddress ConvertToAddress(AddressModel addressModel, IOrderGroup orderGroup)
{
var address = orderGroup.CreateOrderAddress(_orderGroupFactory, addressModel.Name);
MapToAddress(addressModel, address);
return(address);
}
public override IPayment CreatePayment(decimal amount, IOrderGroup orderGroup)
{
var payment = orderGroup.CreateCardPayment(OrderGroupFactory);
payment.CardType = "Credit card";
payment.PaymentMethodId = PaymentMethodId;
payment.PaymentMethodName = SystemKeyword;
payment.Amount = amount;
if (UseSelectedCreditCard && !string.IsNullOrEmpty(SelectedCreditCardId))
{
CreditCard creditCard = _creditCardService.GetCreditCard(SelectedCreditCardId);
payment.CreditCardNumber = creditCard.CreditCardNumber;
payment.CreditCardSecurityCode = creditCard.SecurityCode;
payment.ExpirationMonth = creditCard.ExpirationMonth ?? 1;
payment.ExpirationYear = creditCard.ExpirationYear ?? DateTime.Now.Year;
}
else
{
payment.CreditCardNumber = CreditCardNumber;
payment.CreditCardSecurityCode = CreditCardSecurityCode;
payment.ExpirationMonth = ExpirationMonth;
payment.ExpirationYear = ExpirationYear;
}
payment.Status = PaymentStatus.Pending.ToString();
payment.CustomerName = CreditCardName;
payment.TransactionType = TransactionType.Authorization.ToString();
return(payment);
}
private bool ProcessFraudUpdate(IPayment payment, IOrderGroup orderGroup, ref string message)
{
if (payment.Properties[Common.Constants.FraudStatusPaymentField]?.ToString() == NotificationFraudStatus.FRAUD_RISK_ACCEPTED.ToString())
{
payment.Status = PaymentStatus.Processed.ToString();
OrderStatusManager.ReleaseHoldOnOrder((PurchaseOrder)orderGroup);
AddNoteAndSaveChanges(orderGroup, payment.TransactionType, "Klarna fraud risk accepted");
return(true);
}
else if (payment.Properties[Common.Constants.FraudStatusPaymentField]?.ToString() == NotificationFraudStatus.FRAUD_RISK_REJECTED.ToString())
{
payment.Status = PaymentStatus.Failed.ToString();
AddNoteAndSaveChanges(orderGroup, payment.TransactionType, "Klarna fraud risk rejected");
return(false);
}
else if (payment.Properties[Common.Constants.FraudStatusPaymentField]?.ToString() == NotificationFraudStatus.FRAUD_RISK_STOPPED.ToString())
{
//TODO Fraud status stopped
payment.Status = PaymentStatus.Failed.ToString();
AddNoteAndSaveChanges(orderGroup, payment.TransactionType, "Klarna fraud risk stopped");
return(false);
}
message = $"Can't process authorization. Unknown fraud notitication: {payment.Properties[Common.Constants.FraudStatusPaymentField]} or no fraud notifications received so far.";
return(false);
}
private PaymentProcessingResult ProcessPaymentCapture(IOrderGroup orderGroup,
ICreditCardPayment creditCardPayment,
IOrderAddress billingAddress)
{
if (string.IsNullOrEmpty(creditCardPayment.ProviderPaymentId))
{
return(Charge(orderGroup, creditCardPayment, billingAddress));
}
try
{
var capture = _stripeChargeService.Capture(creditCardPayment.ProviderPaymentId, new StripeChargeCaptureOptions());
if (!string.IsNullOrEmpty(capture.FailureCode))
{
return(PaymentProcessingResult.CreateUnsuccessfulResult(Translate(capture.Outcome.Reason)));
}
creditCardPayment.ProviderPaymentId = capture.Id;
creditCardPayment.ProviderTransactionID = capture.BalanceTransactionId;
return(PaymentProcessingResult.CreateSuccessfulResult(""));
}
catch (StripeException e)
{
switch (e.StripeError.ErrorType)
{
case "card_error":
return(PaymentProcessingResult.CreateUnsuccessfulResult(Translate(e.StripeError.Code)));
default:
return(PaymentProcessingResult.CreateUnsuccessfulResult(e.StripeError.Message));
}
}
}
public ILineItem CreateLineItem(string code, IOrderGroup orderGroup)
{
return(new FakeLineItem()
{
Code = code
});
}
private PayooOrder CreatePayooOrder(IOrderGroup orderGroup, IPayment payment)
{
var orderNumberID = _orderNumberGenerator.GenerateOrderNumber(orderGroup);
var order = new PayooOrder();
order.Session = orderNumberID;
order.BusinessUsername = _paymentMethodConfiguration.BusinessUsername;
order.OrderCashAmount = (long)payment.Amount;
order.OrderNo = orderNumberID;
order.ShippingDays = 1;
order.ShopBackUrl = $"{HttpContext.Current.Request.Url.GetLeftPart(UriPartial.Authority)}{_cmsPaymentPropertyService.GetPayooPaymentProcessingPage()}";
order.ShopDomain = HttpContext.Current.Request.Url.GetLeftPart(UriPartial.Authority);
order.ShopID = long.Parse(_paymentMethodConfiguration.ShopID);
order.ShopTitle = _paymentMethodConfiguration.ShopTitle;
order.StartShippingDate = DateTime.Now.ToString("dd/MM/yyyy");
order.NotifyUrl = string.Empty;
order.ValidityTime = DateTime.Now.AddDays(1).ToString("yyyyMMddHHmmss");
var customer = CustomerContext.Current.GetContactById(orderGroup.CustomerId);
order.CustomerName = customer.FullName ?? $"{customer.FirstName} {customer.MiddleName} {customer.LastName}";
order.CustomerPhone = string.Empty;
order.CustomerEmail = customer.Email;
order.CustomerAddress = customer.PreferredShippingAddress?.Line1;
order.CustomerCity = customer.PreferredShippingAddress?.City;
order.OrderDescription = HttpUtility.UrlEncode(OrderDescriptionHTMLFactory.CreateOrderDescription(orderGroup));
order.Xml = PaymentXMLFactory.GetPaymentXML(order);
return(order);
}
private void AddNoteToOrder(IOrderGroup order, string noteDetails, OrderNoteTypes type, Guid customerId)
{
if (order == null)
{
throw new ArgumentNullException("purchaseOrder");
}
var orderNote = order.CreateOrderNote();
if (!orderNote.OrderNoteId.HasValue)
{
var newOrderNoteId = -1;
if (order.Notes.Count != 0)
{
newOrderNoteId = Math.Min(order.Notes.ToList().Min(n => n.OrderNoteId.Value), 0) - 1;
}
orderNote.OrderNoteId = newOrderNoteId;
}
orderNote.CustomerId = customerId;
orderNote.Type = type.ToString();
orderNote.Title = noteDetails.Substring(0, Math.Min(noteDetails.Length, 24)) + "...";
orderNote.Detail = noteDetails;
orderNote.Created = DateTime.UtcNow;
}
public void CancelOrder(IOrderGroup orderGroup)
{
var market = _marketService.GetMarket(orderGroup.MarketId);
var swedbankPayClient = _swedbankPayClientFactory.Create(market);
var orderId = orderGroup.Properties[Constants.SwedbankPayOrderIdField]?.ToString();
if (!string.IsNullOrWhiteSpace(orderId))
{
try
{
var cancelRequest = _requestFactory.GetCancelRequest();
var paymentOrder = AsyncHelper.RunSync(() => swedbankPayClient.PaymentOrders.Get(new Uri(orderId)));
if (paymentOrder.Operations.Cancel != null)
{
var cancelResponse = AsyncHelper.RunSync(() => paymentOrder.Operations.Cancel(cancelRequest));
if (cancelResponse.Cancellation.Transaction.Type == TransactionType.Cancellation &&
cancelResponse.Cancellation.Transaction.State.Equals(State.Completed))
{
orderGroup.Properties[Constants.SwedbankPayOrderIdField] = null;
_orderRepository.Save(orderGroup);
}
}
}
catch (Exception ex)
{
_logger.Error(ex.Message, ex);
throw;
}
}
}
public TransactionResponse Process(
IOrderGroup orderGroup,
TransactionRequest transactionRequest,
TransactionData transactionData,
decimal amount,
ITokenizedPayment payment)
{
switch (transactionData.type)
{
case TransactionType.Authorization:
return(ProcessAuthorizeRequest(orderGroup, transactionData, payment, amount));
case TransactionType.Capture:
return(ProcessPriorCaptureRequest(transactionRequest, transactionData, amount));
case TransactionType.Sale:
return(ProcessSaleRequest(orderGroup, transactionData, payment, amount));
case TransactionType.Credit:
return(ProcessCreditRequest(transactionRequest, transactionData, payment, amount));
case TransactionType.Void:
return(ProcessVoidRequest(transactionData, payment));
case TransactionType.CaptureOnly:
return(ProcessCaptureOnlyRequest(transactionRequest, transactionData, payment, amount));
default:
throw new NotImplementedException("Not implemented TransactionType: " + transactionData.type);
}
}
private IDictionary <int, decimal> GetPriceExcludingTax(IOrderGroup orderGroup)
{
var currency = orderGroup.Currency;
var market = _marketService.GetMarket(orderGroup.MarketId);
var itemPriceExcludingTaxMapping = new Dictionary <int, decimal>();
foreach (var form in orderGroup.Forms)
{
foreach (var shipment in form.Shipments)
{
var shippingAddress = shipment.ShippingAddress;
foreach (var lineItem in shipment.LineItems)
{
var priceExcludingTax = lineItem.GetExtendedPrice(currency).Amount;
if (orderGroup.PricesIncludeTax)
{
priceExcludingTax -= _lineItemCalculator.GetSalesTax(lineItem, market, currency, shippingAddress).Round().Amount;
}
itemPriceExcludingTaxMapping.Add(lineItem.LineItemId, priceExcludingTax);
}
}
}
return(itemPriceExcludingTaxMapping);
}
protected override void DoCommand(IOrderGroup order, CommandParameters cp)
{
Mediachase.Ibn.Web.UI.CHelper.RequireDataBind();
PurchaseOrder purchaseOrder = order as PurchaseOrder;
WorkflowResults workflowResults = OrderGroupWorkflowManager.RunWorkflow(purchaseOrder, "SaveChangesWorkflow",
false,
false,
new Dictionary <string, object>
{
{
"PreventProcessPayment",
!string.IsNullOrEmpty(order.Properties["QuoteStatus"] as string) &&
(order.Properties["QuoteStatus"].ToString() == Constants.Quote.RequestQuotation ||
order.Properties["QuoteStatus"].ToString() == Constants.Quote.RequestQuotationFinished)
}
});
if (workflowResults.Status != WorkflowStatus.Completed)
{
string msg = "Unknow error";
if (workflowResults.Exception != null)
{
msg = workflowResults.Exception.Message;
}
ErrorManager.GenerateError(msg);
}
else
{
WritePurchaseOrderChangeNotes(purchaseOrder);
SavePurchaseOrderChanges(purchaseOrder);
PurchaseOrderManager.UpdatePromotionUsage(purchaseOrder, purchaseOrder);
OrderHelper.ExitPurchaseOrderFromEditMode(purchaseOrder.OrderGroupId);
}
}
/// <summary>
/// Processes the payment. Can be used for both positive and negative transactions.
/// </summary>
/// <param name="orderGroup">The order group.</param>
/// <param name="payment">The payment.</param>
/// <returns>The payment processing result.</returns>
public PaymentProcessingResult ProcessPayment(IOrderGroup orderGroup, IPayment payment)
{
var creditCardPayment = (ICreditCardPayment)payment;
return(creditCardPayment.CreditCardNumber.EndsWith("4")
? PaymentProcessingResult.CreateSuccessfulResult(string.Empty)
: PaymentProcessingResult.CreateUnsuccessfulResult("Invalid credit card number."));
}
public static void SetOrderProcessing(this IOrderGroup orderGroup, bool value)
{
if (orderGroup == null)
{
return;
}
orderGroup.Properties[VippsConstants.VippsIsProcessingOrderField] = value;
}
protected override Money CalculateTotal(IOrderGroup orderGroup)
{
var result = GetSubTotal(orderGroup) - GetOrderDiscountTotal(orderGroup, orderGroup.Currency);
result +=
_shippingCalculator.GetShippingCost(orderGroup, orderGroup.Market, orderGroup.Currency) +
_taxCalculator.GetTaxTotal(orderGroup, orderGroup.Market, orderGroup.Currency);
return result;
}
private static IEnumerable <string> GetAffectedEntryCodes(IOrderGroup order)
{
if (HasOrderPromotionWithSavedAmount(order))
{
return(GetAllEntryCodesFromOrder(order));
}
return(GetAffectedEntryCodesFromEntryPromotions(order));
}
private PaymentStepResult HandlePaymentFailed(IOrderGroup orderGroup, IPayment payment, string title, string message)
{
payment.Status = PaymentStatus.Failed.ToString();
Logger.Error(message);
AddNoteAndSaveChanges(orderGroup, title, message);
return(Fail(message));
}
private void UpdatePaymentPropertiesFromPayooResponse(IOrderGroup orderGroup, IPayment payment, CreateOrderResponse response)
{
payment.Properties[Constant.PayooOrderIdPropertyName] = response.order.order_id;
payment.Properties[Constant.PayooOrderNumberPropertyName] = response.order.order_no;
payment.Properties[Constant.PayooAmountPropertyName] = response.order.amount;
payment.Properties[Constant.PayooExpiryDatePropertyName] = response.order.expiry_date;
payment.Properties[Constant.PayooPaymentCodePropertyName] = response.order.payment_code;
_orderRepository.Save(orderGroup);
}
public IOrderAddress ConvertToAddress(IOrderGroup orderGroup, AddressModel model)
{
var address = _orderGroupFactory.CreateOrderAddress(orderGroup);
address.Id = model.Name;
MapToAddress(model, address);
return(address);
}
public FakeCart(IOrderGroup orderGroup) : base(orderGroup)
{
}
private ILineItem GetFirstLineItem(IOrderGroup cart, string code)
{
return cart.GetAllLineItems().FirstOrDefault(x => x.Code == code);
}
private LineItem CreateLineItem(Entry entry, IOrderGroup g)
{
var priceService = ServiceLocator.Current.GetInstance<IPriceService>();
LineItem item = new LineItem();
if (entry.ParentEntry != null)
{
item.DisplayName = string.Format("{0}: {1}", entry.ParentEntry.Name, entry.Name);
item.ParentCatalogEntryId = entry.ParentEntry.ID;
}
else
{
item.DisplayName = entry.Name;
}
item[Constants.Metadata.LineItem.ImageUrl] =
"/globalassets/catalogs/photo/accessories/memory-card/sandisk-extreme-pro/824140.jpg?preset=listsmall";
MarketId marketId = g.Market.MarketId.Value;
IPriceValue value2 = priceService.GetDefaultPrice(marketId, FrameworkContext.Current.CurrentDateTime, new CatalogKey(entry), g.Currency);
item.Code = entry.ID;
item.Quantity = 1;
if (value2 != null)
{
item.ListPrice = value2.UnitPrice.Amount;
item.PlacedPrice = value2.UnitPrice.Amount;
item.ExtendedPrice = value2.UnitPrice.Amount;
}
else
{
item.ListPrice = item.PlacedPrice;
}
return item;
}
