public CheckoutOrderData Build(CheckoutOrderData checkoutOrderData, ICart cart, CheckoutConfiguration checkoutConfiguration)
{
if (checkoutConfiguration == null)
{
return(checkoutOrderData);
}
checkoutOrderData.ExternalPaymentMethods = new[]
{
new ExternalPaymentMethod {
Fee = 10, ImageUri = new Uri("https://klarna.geta.no/Styles/Images/paypalpng"), Name = "PayPal", RedirectUri = new Uri("https://klarna.geta.no")
}
};
if (checkoutConfiguration.PrefillAddress)
{
// Try to parse address into dutch address lines
if (checkoutOrderData.ShippingAddress != null && !string.IsNullOrEmpty(checkoutOrderData.ShippingAddress.Country) && checkoutOrderData.ShippingAddress.Country.Equals("NL"))
{
var dutchAddress = ConvertToDutchAddress(checkoutOrderData.ShippingAddress);
checkoutOrderData.ShippingAddress = dutchAddress;
}
}
UpdateOrderLines(checkoutOrderData.OrderLines, checkoutConfiguration);
return(checkoutOrderData);
}
/// <summary>
/// Updates the resource.
/// </summary>
/// <param name="checkoutOrderData">the order data</param>
/// <returns>the updated checkout order data</returns>
public CheckoutOrderData Update(CheckoutOrderData checkoutOrderData)
{
return(Post(this.Location.ToString(), checkoutOrderData)
.Status(HttpStatusCode.OK)
.ContentType("application/json")
.Response.Data <CheckoutOrderData>());
}
/// <summary>
/// Run the example code.
/// </summary>
public static void Main()
{
const string MerchantId = "0";
const string SharedSecret = "sharedSecret";
string orderID = "12345";
IConnector connector = ConnectorFactory.Create(MerchantId, SharedSecret, Client.EuTestBaseUrl);
Client client = new Client(connector);
ICheckoutOrder order = client.NewCheckoutOrder(orderID);
try
{
CheckoutOrderData orderData = order.Fetch();
}
catch (ApiException ex)
{
Console.WriteLine(ex.ErrorMessage.ErrorCode);
Console.WriteLine(ex.ErrorMessage.ErrorMessages);
Console.WriteLine(ex.ErrorMessage.CorrelationId);
}
catch (WebException ex)
{
Console.WriteLine(ex.Message);
}
}
public void TestFetch()
{
// Arrange
string orderId = "0003";
string expectedUrl = "https://dummytesturi.test/checkout/v3/orders/0003";
int orderAmount = 1234;
this.requestMock.Expect(x => x.CreateRequest(expectedUrl)).Return(this.httpWebRequest);
string json = "{\r\n \"order_id\": \"" + orderId + "\",\r\n \"order_amount\": " + orderAmount + ",\r\n }";
WebHeaderCollection headers = new WebHeaderCollection();
headers[HttpResponseHeader.ContentType] = "application/json";
IResponse response = new Response(HttpStatusCode.OK, headers, json);
this.requestMock.Expect(x => x.Send(this.httpWebRequest, string.Empty)).Return(response);
// Act
this.checkoutOrder = new Klarna.Rest.Checkout.CheckoutOrder(this.connector, orderId);
CheckoutOrderData checkoutOrderData = this.checkoutOrder.Fetch();
// Assert
this.requestMock.VerifyAllExpectations();
Assert.AreEqual(0, this.httpWebRequest.ContentLength);
Assert.AreEqual(orderId, checkoutOrderData.OrderId);
Assert.AreEqual(orderAmount, checkoutOrderData.OrderAmount);
TestsHelper.AssertRequest(this.merchantId, this.secret, this.httpWebRequest, HttpMethod.Get);
}
/// <summary>
/// Get checkout order.
/// </summary>
/// <returns>a checkout order</returns>
public static CheckoutOrderData GetCheckoutOrderData1()
{
CheckoutOrderData checkoutOrderData1 = new CheckoutOrderData()
{
PurchaseCountry = "SomeCountry",
PurchaseCurrency = "SomeCurrency"
};
return(checkoutOrderData1);
}
/// <summary>
/// Get checkout order.
/// </summary>
/// <returns>a checkout order</returns>
public static CheckoutOrderData GetCheckoutOrderData2()
{
CheckoutOrderData checkoutOrderData2 = new CheckoutOrderData()
{
PurchaseCountry = "SomeOtherCountry",
PurchaseCurrency = "SomeOtherCurrency"
};
return(checkoutOrderData2);
}
private ProcessPaymentResult NewCreateKlarnaOrder(KlarnaLocalization localization, ProcessPaymentEvaluationContext context)
{
var retVal = new ProcessPaymentResult();
var orderLineItems = GetOrderLineItems(context.Order);
MerchantUrls merchantUrls = new MerchantUrls
{
Terms = new System.Uri(
string.Format("{0}/{1}", context.Store.Url, TermsUrl)),
Checkout = new System.Uri(
string.Format("{0}/{1}", context.Store.Url, CheckoutUrl)),
Confirmation = new System.Uri(
string.Format("{0}/{1}?sid=123&orderId={2}&", context.Store.Url, ConfirmationUrl, context.Order.Id) + "klarna_order={checkout.order.uri}"),
Push = new System.Uri(
string.Format("{0}/{1}?sid=123&orderId={2}&", context.Store.Url, "admin/api/paymentcallback", context.Order.Id) + "klarna_order={checkout.order.uri}")
};
CheckoutOrderData orderData = new CheckoutOrderData()
{
PurchaseCountry = localization.CountryName,
PurchaseCurrency = localization.Currency,
Locale = localization.Locale,
OrderAmount = (int)(context.Order.Sum * 100),
OrderTaxAmount = (int)(context.Order.Tax * 100),
OrderLines = orderLineItems,
MerchantUrls = merchantUrls
};
var connector = ConnectorFactory.Create(
AppKey,
AppSecret,
Client.TestBaseUrl);
Client client = new Client(connector);
var checkout = client.NewCheckoutOrder();
checkout.Create(orderData);
orderData = checkout.Fetch();
retVal.IsSuccess = true;
retVal.NewPaymentStatus = PaymentStatus.Pending;
retVal.OuterId = orderData.OrderId;
retVal.HtmlForm = string.Format("<div>{0}</div>", orderData.HtmlSnippet);
return(retVal);
}
private ICart UpdateCartWithOrderData(ICart cart, CheckoutOrderData orderData)
{
var shipment = cart.GetFirstShipment();
if (shipment != null && orderData.ShippingAddress != null)
{
shipment.ShippingAddress = orderData.ShippingAddress.ToOrderAddress(cart);
_orderRepository.Save(cart);
}
// Store checkout order id on cart
cart.Properties[Constants.KlarnaCheckoutOrderIdCartField] = orderData.OrderId;
_orderRepository.Save(cart);
return(cart);
}
public void CheckoutOrder_Create_Basic()
{
// Arrange
CheckoutOrderData checkoutOrderData = TestsHelper.GetCheckoutOrderData1();
Uri newTestLocation = new Uri("https://newTestUrl.test");
var responseMock = TestsHelper.Mock(HttpMethod.Post, this.order.Path, checkoutOrderData.ConvertToJson(), HttpStatusCode.Created, this.connectorMock);
WebHeaderCollection headers = new WebHeaderCollection();
headers[HttpResponseHeader.Location] = newTestLocation.ToString();
responseMock.Stub(x => x.Headers).Return(headers);
// Act
this.order.Create(checkoutOrderData);
// Assert
Assert.AreEqual(newTestLocation, this.order.Location);
}
public void CheckoutOrder_Fetch_Basic()
{
// Arrange
CheckoutOrderData checkoutOrderData = TestsHelper.GetCheckoutOrderData1();
var responseMock = TestsHelper.Mock(HttpMethod.Get, this.order.Location.ToString(), string.Empty, HttpStatusCode.OK, this.connectorMock);
responseMock.Stub(x => x.Data <CheckoutOrderData>()).Return(checkoutOrderData);
WebHeaderCollection headers = new WebHeaderCollection();
headers[HttpResponseHeader.ContentType] = "application/json";
responseMock.Stub(x => x.Headers).Return(headers);
// Act
var returnedCheckoutOrderData = this.order.Fetch();
// Assert
Assert.AreEqual(checkoutOrderData.PurchaseCountry, returnedCheckoutOrderData.PurchaseCountry);
Assert.AreEqual(checkoutOrderData.PurchaseCurrency, returnedCheckoutOrderData.PurchaseCurrency);
}
public void TestUpdate()
{
// Arrange
CheckoutOrderData orderData1 = TestsHelper.GetCheckoutOrderData1();
CheckoutOrderData orderData2 = TestsHelper.GetCheckoutOrderData2();
this.requestMock.Expect(x => x.CreateRequest(this.baseUrl + this.path.TrimStart('/'))).Return(this.httpWebRequest);
WebHeaderCollection headers = new WebHeaderCollection();
headers[HttpResponseHeader.Location] = this.location;
IResponse response = new Response(HttpStatusCode.Created, headers, string.Empty);
this.requestMock.Expect(x => x.Send(this.httpWebRequest, orderData1.ConvertToJson())).Return(response);
this.httpWebRequest = (HttpWebRequest)WebRequest.Create(this.baseUrl);
this.requestMock.Expect(x => x.CreateRequest(this.baseUrl + this.location)).Return(this.httpWebRequest);
WebHeaderCollection headers2 = new WebHeaderCollection();
headers2[HttpResponseHeader.ContentType] = "application/json";
IResponse response2 = new Response(HttpStatusCode.OK, headers2, orderData2.ConvertToJson());
this.requestMock.Expect(x => x.Send(this.httpWebRequest, orderData2.ConvertToJson())).Return(response2);
// Act
this.checkoutOrder.Create(orderData1);
CheckoutOrderData updatedCheckoutOrderData = this.checkoutOrder.Update(orderData2);
// Assert
this.requestMock.VerifyAllExpectations();
Assert.AreEqual(this.location, this.checkoutOrder.Location.OriginalString);
Assert.AreEqual(orderData2.ConvertToJson().Length, this.httpWebRequest.ContentLength);
Assert.AreEqual(orderData2.PurchaseCountry, updatedCheckoutOrderData.PurchaseCountry);
Assert.AreEqual(orderData2.PurchaseCurrency, updatedCheckoutOrderData.PurchaseCurrency);
TestsHelper.AssertRequest(this.merchantId, this.secret, this.httpWebRequest, HttpMethod.Post);
}
public void TestCreate()
{
// Arrange
CheckoutOrderData orderData = TestsHelper.GetCheckoutOrderData1();
this.requestMock.Expect(x => x.CreateRequest(this.baseUrl + this.path.TrimStart('/'))).Return(this.httpWebRequest);
WebHeaderCollection headers = new WebHeaderCollection();
headers["Location"] = this.location;
HttpStatusCode status = HttpStatusCode.Created;
IResponse response = new Response(status, headers, string.Empty);
this.requestMock.Expect(x => x.Send(this.httpWebRequest, orderData.ConvertToJson())).Return(response);
// Act
this.checkoutOrder.Create(orderData);
// Assert
this.requestMock.VerifyAllExpectations();
Assert.AreEqual(this.location, this.checkoutOrder.Location.OriginalString);
Assert.AreEqual(orderData.ConvertToJson().Length, this.httpWebRequest.ContentLength);
TestsHelper.AssertRequest(this.merchantId, this.secret, this.httpWebRequest, HttpMethod.Post);
}
/// <summary>
/// Creates the resource.
/// </summary>
/// <param name="checkoutOrderData">the order data</param>
public void Create(CheckoutOrderData checkoutOrderData)
{
this.Location = Post(this.Path, checkoutOrderData)
.Status(HttpStatusCode.Created)
.Location;
}
/// <summary>
/// Run the example code.
/// </summary>
public static void Main()
{
const string MerchantId = "0";
const string SharedSecret = "sharedSecret";
IConnector connector = ConnectorFactory.Create(MerchantId, SharedSecret, Client.EuTestBaseUrl);
Client client = new Client(connector);
ICheckoutOrder checkout = client.NewCheckoutOrder();
OrderLine orderLine = new OrderLine
{
Type = OrderLineType.Physical,
Reference = "123050",
Name = "Tomatoes",
Quantity = 10,
QuantityUnit = "kg",
UnitPrice = 600,
TaxRate = 2500,
TotalAmount = 6000,
TotalTaxAmount = 1200
};
OrderLine orderLine2 = new OrderLine
{
Type = OrderLineType.Physical,
Reference = "543670",
Name = "Bananas",
Quantity = 1,
QuantityUnit = "bag",
UnitPrice = 5000,
TaxRate = 2500,
TotalAmount = 4000,
TotalDiscountAmount = 1000,
TotalTaxAmount = 800
};
MerchantUrls merchantUrls = new MerchantUrls
{
Terms = new Uri("http://www.merchant.com/toc"),
Checkout = new Uri("http://www.merchant.com/checkout?klarna_order_id={checkout.order.id}"),
Confirmation = new Uri("http://www.merchant.com/thank-you?klarna_order_id={checkout.order.id}"),
Push = new Uri("http://www.merchant.com/create_order?klarna_order_id={checkout.order.id}")
};
CheckoutOrderData orderData = new CheckoutOrderData()
{
PurchaseCountry = "gb",
PurchaseCurrency = "gbp",
Locale = "en-gb",
OrderAmount = 10000,
OrderTaxAmount = 2000,
OrderLines = new List <OrderLine> {
orderLine, orderLine2
},
MerchantUrls = merchantUrls
};
try
{
checkout.Create(orderData);
orderData = checkout.Fetch();
string orderID = orderData.OrderId;
}
catch (ApiException ex)
{
Console.WriteLine(ex.ErrorMessage.ErrorCode);
Console.WriteLine(ex.ErrorMessage.ErrorMessages);
Console.WriteLine(ex.ErrorMessage.CorrelationId);
}
catch (WebException ex)
{
Console.WriteLine(ex.Message);
}
}
/// <summary>
/// Run the example code.
/// </summary>
public static void Main()
{
const string MerchantId = "0";
const string SharedSecret = "sharedSecret";
string orderID = "12345";
IConnector connector = ConnectorFactory.Create(MerchantId, SharedSecret, Client.EuTestBaseUrl);
Client client = new Client(connector);
ICheckoutOrder checkout = client.NewCheckoutOrder(orderID);
CheckoutOrderData orderData = new CheckoutOrderData();
orderData.OrderAmount = 11000;
orderData.OrderTaxAmount = 2200;
List <OrderLine> lines = new List <OrderLine>();
lines.Add(new OrderLine()
{
Type = OrderLineType.Physical,
Reference = "123050",
Name = "Tomatoes",
Quantity = 10,
QuantityUnit = "kg",
UnitPrice = 600,
TaxRate = 2500,
TotalAmount = 6000,
TotalTaxAmount = 1200
});
lines.Add(new OrderLine()
{
Type = OrderLineType.Physical,
Reference = "543670",
Name = "Bananas",
Quantity = 1,
QuantityUnit = "bag",
UnitPrice = 5000,
TaxRate = 2500,
TotalAmount = 4000,
TotalDiscountAmount = 1000,
TotalTaxAmount = 800
});
lines.Add(new OrderLine()
{
Type = OrderLineType.ShippingFee,
Name = "Express delivery",
Quantity = 1,
UnitPrice = 1000,
TaxRate = 2500,
TotalAmount = 1000,
TotalTaxAmount = 200
});
orderData.OrderLines = lines;
try
{
orderData = checkout.Update(orderData);
}
catch (ApiException ex)
{
Console.WriteLine(ex.ErrorMessage.ErrorCode);
Console.WriteLine(ex.ErrorMessage.ErrorMessages);
Console.WriteLine(ex.ErrorMessage.CorrelationId);
}
catch (WebException ex)
{
Console.WriteLine(ex.Message);
}
}
public IPurchaseOrder CreatePurchaseOrderForKlarna(string klarnaOrderId, CheckoutOrderData order, ICart cart)
{
var paymentRow = PaymentManager.GetPaymentMethodBySystemName(Constants.KlarnaCheckoutSystemKeyword, ContentLanguage.PreferredCulture.Name).PaymentMethod.FirstOrDefault();
var payment = cart.CreatePayment(_orderGroupFactory);
payment.PaymentType = PaymentType.Other;
payment.PaymentMethodId = paymentRow.PaymentMethodId;
payment.PaymentMethodName = Constants.KlarnaCheckoutSystemKeyword;
payment.Amount = cart.GetTotal(_orderGroupCalculator).Amount;
payment.Status = PaymentStatus.Pending.ToString();
payment.TransactionType = TransactionType.Authorization.ToString();
cart.AddPayment(payment, _orderGroupFactory);
var billingAddress = new AddressModel
{
Name = $"{order.BillingAddress.StreetAddress}{order.BillingAddress.StreetAddress2}{order.BillingAddress.City}",
FirstName = order.BillingAddress.GivenName,
LastName = order.BillingAddress.FamilyName,
Email = order.BillingAddress.Email,
DaytimePhoneNumber = order.BillingAddress.Phone,
Line1 = order.BillingAddress.StreetAddress,
Line2 = order.BillingAddress.StreetAddress2,
PostalCode = order.BillingAddress.PostalCode,
City = order.BillingAddress.City,
CountryName = order.BillingAddress.Country
};
payment.BillingAddress = _addressBookService.ConvertToAddress(billingAddress, cart);
cart.ProcessPayments(_paymentProcessor, _orderGroupCalculator);
var totalProcessedAmount = cart.GetFirstForm().Payments.Where(x => x.Status.Equals(PaymentStatus.Processed.ToString())).Sum(x => x.Amount);
if (totalProcessedAmount != cart.GetTotal(_orderGroupCalculator).Amount)
{
throw new InvalidOperationException("Wrong amount");
}
if (payment.HasFraudStatus(FraudStatus.PENDING))
{
payment.Status = PaymentStatus.Pending.ToString();
}
var orderReference = _orderRepository.SaveAsPurchaseOrder(cart);
var purchaseOrder = _orderRepository.Load <IPurchaseOrder>(orderReference.OrderGroupId);
_orderRepository.Delete(cart.OrderLink);
if (purchaseOrder == null)
{
_klarnaCheckoutService.CancelOrder(cart);
return(null);
}
else
{
_klarnaCheckoutService.Complete(purchaseOrder);
purchaseOrder.Properties[Klarna.Common.Constants.KlarnaOrderIdField] = klarnaOrderId;
_orderRepository.Save(purchaseOrder);
return(purchaseOrder);
}
}
/// <summary>
/// Run the example code.
/// </summary>
public static void Main()
{
const string MerchantId = "0";
const string SharedSecret = "sharedSecret";
IConnector connector = ConnectorFactory.Create(MerchantId, SharedSecret, Client.EuTestBaseUrl);
Client client = new Client(connector);
ICheckoutOrder checkout = client.NewCheckoutOrder();
OrderLine orderLine = new OrderLine
{
Type = OrderLineType.Physical,
Reference = "123050",
Name = "Tomatoes",
Quantity = 10,
QuantityUnit = "kg",
UnitPrice = 600,
TaxRate = 2500,
TotalAmount = 6000,
TotalTaxAmount = 1200
};
OrderLine orderLine2 = new OrderLine
{
Type = OrderLineType.Physical,
Reference = "543670",
Name = "Bananas",
Quantity = 1,
QuantityUnit = "bag",
UnitPrice = 5000,
TaxRate = 2500,
TotalAmount = 4000,
TotalDiscountAmount = 1000,
TotalTaxAmount = 800
};
MerchantUrls merchantUrls = new MerchantUrls
{
Terms = new Uri("http://www.merchant.com/toc"),
Checkout = new Uri("http://www.merchant.com/checkout?klarna_order_id={checkout.order.id}"),
Confirmation = new Uri("http://www.merchant.com/thank-you?klarna_order_id={checkout.order.id}"),
Push = new Uri("http://www.merchant.com/create_order?klarna_order_id={checkout.order.id}")
};
List <PaymentHistoryFull> purchaseHistoryFull = new List <PaymentHistoryFull>
{
new PaymentHistoryFull
{
UniqueAccountIdentifier = "Test Testperson",
PaymentOption = "card",
NumberPaidPurchases = 1,
TotalAmountPaidPurchases = 10000,
DateOfLastPaidPurchase = DateTime.Now,
DateOfFirstPaidPurchase = DateTime.Now
}
};
ExtraMerchantData extraMerchantData = new ExtraMerchantData
{
Body = new ExtraMerchantDataBody
{
PaymentHistoryFull = purchaseHistoryFull
}
};
CheckoutOrderData orderData = new CheckoutOrderData()
{
PurchaseCountry = "gb",
PurchaseCurrency = "gbp",
Locale = "en-gb",
OrderAmount = 10000,
OrderTaxAmount = 2000,
OrderLines = new List <OrderLine> {
orderLine, orderLine2
},
MerchantUrls = merchantUrls,
Attachment = extraMerchantData
};
try
{
checkout.Create(orderData);
orderData = checkout.Fetch();
string orderID = orderData.OrderId;
ExtraMerchantData emd = orderData.Attachment;
}
catch (ApiException ex)
{
Console.WriteLine(ex.ErrorMessage.ErrorCode);
Console.WriteLine(ex.ErrorMessage.ErrorMessages);
Console.WriteLine(ex.ErrorMessage.CorrelationId);
}
catch (WebException ex)
{
Console.WriteLine(ex.Message);
}
}
private ProcessPaymentResult NewCreateKlarnaOrder(KlarnaLocalization localization, ProcessPaymentEvaluationContext context)
{
var retVal = new ProcessPaymentResult();
var orderLineItems = GetOrderLineItems(context.Order);
MerchantUrls merchantUrls = new MerchantUrls
{
Terms = new System.Uri(
string.Format("{0}/{1}", context.Store.Url, TermsUrl)),
Checkout = new System.Uri(
string.Format("{0}/{1}", context.Store.Url, CheckoutUrl)),
Confirmation = new System.Uri(
string.Format("{0}/{1}?sid=123&orderId={2}&", context.Store.Url, ConfirmationUrl, context.Order.Id) + "klarna_order={checkout.order.uri}"),
Push = new System.Uri(
string.Format("{0}/{1}?sid=123&orderId={2}&", context.Store.Url, "admin/api/paymentcallback", context.Order.Id) + "klarna_order={checkout.order.uri}")
};
CheckoutOrderData orderData = new CheckoutOrderData()
{
PurchaseCountry = localization.CountryName,
PurchaseCurrency = localization.Currency,
Locale = localization.Locale,
OrderAmount = (int)(context.Order.Sum * 100),
OrderTaxAmount = (int)(context.Order.Tax * 100),
OrderLines = orderLineItems,
MerchantUrls = merchantUrls
};
var connector = ConnectorFactory.Create(
AppKey,
AppSecret,
Client.TestBaseUrl);
Client client = new Client(connector);
var checkout = client.NewCheckoutOrder();
checkout.Create(orderData);
orderData = checkout.Fetch();
retVal.IsSuccess = true;
retVal.NewPaymentStatus = PaymentStatus.Pending;
retVal.OuterId = orderData.OrderId;
retVal.HtmlForm = string.Format("<div>{0}</div>", orderData.HtmlSnippet);
return retVal;
}
