public void TestFormatFixedDiscountRowsAmountExVatAndVatPercentWithDifferentVatRatesPresent()
{
CreateOrderBuilder order = WebpayConnection.CreateOrder(SveaConfig.GetDefaultConfig())
.AddOrderRow(Item.OrderRow()
.SetAmountExVat(100.00M)
.SetVatPercent(25)
.SetQuantity(2))
.AddOrderRow(Item.OrderRow()
.SetAmountExVat(100.00M)
.SetVatPercent(6)
.SetQuantity(1))
.AddDiscount(Item.FixedDiscount()
.SetDiscountId("42")
.SetName(".SetAmountIncVat(100)")
.SetDescription("testFormatFixedDiscountRowsWithDifferentVatRatesPresent")
.SetAmountExVat(111)
.SetVatPercent(25)
.SetUnit("st"));
List <OrderRow> newRows = new WebServiceRowFormatter <CreateOrderBuilder>(order).FormatRows();
// 100 @25% vat = -80 excl. vat
OrderRow newRow = newRows[2];
Assert.That(newRow.ArticleNumber, Is.EqualTo("42"));
Assert.That(newRow.Description, Is.EqualTo(".SetAmountIncVat(100): testFormatFixedDiscountRowsWithDifferentVatRatesPresent"));
Assert.That(newRow.PricePerUnit, Is.EqualTo(-111.00M));
Assert.That(newRow.VatPercent, Is.EqualTo(25));
Assert.That(newRow.DiscountPercent, Is.EqualTo(0));
Assert.That(newRow.NumberOfUnits, Is.EqualTo(1));
Assert.That(newRow.Unit, Is.EqualTo("st"));
}
public void Test_CreateOrder_NO_WithAllCustomerDetailsSet_ShouldNotSetIndividualIdentity()
{
CreateOrderBuilder createOrderBuilder = WebpayConnection.CreateOrder(SveaConfig.GetDefaultConfig())
.AddOrderRow(TestingTool.CreateExVatBasedOrderRow("1"))
.AddOrderRow(TestingTool.CreateExVatBasedOrderRow("2"))
.AddCustomerDetails(Item.IndividualCustomer()
.SetNationalIdNumber("17054512066") // NO test individual "Ola Norrmann"
// below taken from docs, not accurate
.SetBirthDate("19460509") //Required for individual customers in NL and DE
.SetName("Tess", "Testson") //Required for individual customers in NL and DE
.SetInitials("SB") //Required for individual customers in NL
.SetStreetAddress("Gatan", "23") //Required in NL and DE
.SetCoAddress("c/o Eriksson") //Optional
.SetZipCode("9999") //Required in NL and DE
.SetLocality("Stan") //Required in NL and DE
.SetPhoneNumber("999999") //Optional
.SetEmail("*****@*****.**") //Optional but desirable
.SetIpAddress("123.123.123") //Optional but desirable
)
.SetCountryCode(CountryCode.NO) // NO
.SetOrderDate(TestingTool.DefaultTestDate)
.SetClientOrderNumber("33308") // NO Invoice
.SetCurrency(TestingTool.DefaultTestCurrency)
;
CreateOrderEuRequest request = createOrderBuilder.UseInvoicePayment().PrepareRequest();
Assert.IsNull(request.CreateOrderInformation.CustomerIdentity.IndividualIdentity);
CreateOrderEuResponse order = createOrderBuilder.UseInvoicePayment().DoRequest();
Assert.IsTrue(order.Accepted);
}
private void ValidateCurrency(CreateOrderBuilder order)
{
if (order.GetCurrency() == null)
{
Errors += "MISSING VALUE - Currency is required. Use SetCurrency(...).\n";
}
}
public void TestAmountWithRelativeDiscountWithDifferentVatRatesPresent()
{
CreateOrderBuilder order = WebpayConnection.CreateOrder(SveaConfig.GetDefaultConfig())
.AddOrderRow(Item.OrderRow()
.SetAmountExVat(100.00M)
.SetVatPercent(25)
.SetQuantity(2))
.AddOrderRow(Item.OrderRow()
.SetAmountExVat(100.00M)
.SetVatPercent(6)
.SetQuantity(1))
.AddDiscount(Item.RelativeDiscount()
.SetDiscountPercent(25));
// follows HostedPayment calculateRequestValues() outline:
var formatter = new HostedRowFormatter <CreateOrderBuilder>();
List <HostedOrderRowBuilder> formatRowsList = formatter.FormatRows(order);
long formattedTotalAmount = formatter.GetTotalAmount();
long formattedTotalVat = formatter.GetTotalVat();
Assert.That(formatRowsList.Count, Is.EqualTo(3));
// 5000*.25 = 1250
// 600*.25 = 150
// matches 1400 discount
Assert.That(formattedTotalAmount, Is.EqualTo(26700)); // 35600 - 8900 discount
Assert.That(formattedTotalVat, Is.EqualTo(4200)); // 5600 - 1400 discount (= 10000/35600 *5600) discount
}
public void TestAmountWithFixedDiscountIncVatOnlyWithDifferentVatRatesPresent()
{
CreateOrderBuilder order = WebpayConnection.CreateOrder(SveaConfig.GetDefaultConfig())
.AddOrderRow(Item.OrderRow()
.SetAmountExVat(100.00M)
.SetVatPercent(25)
.SetQuantity(2))
.AddOrderRow(Item.OrderRow()
.SetAmountExVat(100.00M)
.SetVatPercent(6)
.SetQuantity(1))
.AddDiscount(Item.FixedDiscount()
.SetAmountIncVat(100.00M));
// follows HostedPayment calculateRequestValues() outline:
var formatter = new HostedRowFormatter <CreateOrderBuilder>();
List <HostedOrderRowBuilder> formatRowsList = formatter.FormatRows(order);
long formattedTotalAmount = formatter.GetTotalAmount();
long formattedTotalVat = formatter.GetTotalVat();
Assert.That(formatRowsList.Count, Is.EqualTo(3));
// 100*250/356 = 70.22 incl. 25% vat => 14.04 vat as amount
// 100*106/356 = 29.78 incl. 6% vat => 1.69 vat as amount
// matches 15,73 discount (= 100/356 *56) discount
Assert.That(formattedTotalAmount, Is.EqualTo(25600)); // 35600 - 10000 discount
Assert.That(formattedTotalVat, Is.EqualTo(4027)); // 5600 - 1573 discount (= 10000/35600 *5600) discount
}
public void TestFormatRelativeDiscountRowsWithSingleVatRatePresent()
{
CreateOrderBuilder order = WebpayConnection.CreateOrder(SveaConfig.GetDefaultConfig())
.AddOrderRow(Item.OrderRow()
.SetAmountExVat(100.00M)
.SetVatPercent(12)
.SetQuantity(1))
.AddDiscount(Item.RelativeDiscount()
.SetDiscountId("0")
.SetName(".SetDiscountPercent(20)")
.SetDescription("TestFormatRelativeDiscountRowsWithSingleVatRatePresent")
.SetDiscountPercent(20)
.SetUnit("st"));
List <OrderRow> newRows = new WebServiceRowFormatter <CreateOrderBuilder>(order).FormatRows();
OrderRow newRow = newRows[1];
Assert.That(newRow.ArticleNumber, Is.EqualTo("0"));
Assert.That(newRow.Description, Is.EqualTo(".SetDiscountPercent(20): TestFormatRelativeDiscountRowsWithSingleVatRatePresent"));
Assert.That(newRow.PricePerUnit, Is.EqualTo(-20.00M));
Assert.That(newRow.VatPercent, Is.EqualTo(12));
Assert.That(newRow.DiscountPercent, Is.EqualTo(0)); // not the same thing as in our WebPayItem...
Assert.That(newRow.NumberOfUnits, Is.EqualTo(1));
Assert.That(newRow.Unit, Is.EqualTo("st"));
}
public void ConvertOrderBuilderToOrder()
{
var orderBuilder = new CreateOrderBuilder(SveaConfig.GetDefaultConfig());
var order = WebServiceRowFormatter <CreateOrderBuilder> .ConvertToOrder(orderBuilder);
Assert.That(order.Original, Is.SameAs(orderBuilder));
}
public void TestXmlWithCompanyCustomer()
{
_order = WebpayConnection.CreateOrder(SveaConfig.GetDefaultConfig())
.AddOrderRow(Item.OrderRow()
.SetAmountExVat(4)
.SetVatPercent(25)
.SetQuantity(1))
.SetCurrency(TestingTool.DefaultTestCurrency)
.SetClientOrderNumber(TestingTool.DefaultTestClientOrderNumber)
.SetCountryCode(TestingTool.DefaultTestCountryCode)
.AddCustomerDetails(TestingTool.CreateCompanyCustomer());
var payment = new FakeHostedPayment(_order);
payment.SetReturnUrl("http://myurl.se")
.CalculateRequestValues();
_xml = _xmlBuilder.GetXml(payment);
const string expectedString =
"<customer><ssn>194608142222</ssn><firstname>Tess, T Persson</firstname>" +
"<phone>0811111111</phone><email>[email protected]</email>" +
"<address>Testgatan</address><housenumber>1</housenumber>" +
"<address2>c/o Eriksson, Erik</address2><zip>99999</zip>" +
"<city>Stan</city><country>SE</country></customer>";
Assert.That(_xml.Contains(expectedString), Is.True);
Assert.That(_xml.Contains("<ipaddress>123.123.123.123</ipaddress>"), Is.True);
}
public void TestOrderRowXml()
{
_order = WebpayConnection.CreateOrder(SveaConfig.GetDefaultConfig())
.AddOrderRow(Item.OrderRow()
.SetArticleNumber("0")
.SetName("Product")
.SetDescription("Good product")
.SetAmountExVat(4)
.SetVatPercent(25)
.SetQuantity(1)
.SetUnit("kg"))
.AddCustomerDetails(Item.CompanyCustomer())
.SetCountryCode(TestingTool.DefaultTestCountryCode)
.SetCurrency(TestingTool.DefaultTestCurrency)
.SetClientOrderNumber(TestingTool.DefaultTestClientOrderNumber);
var payment = new FakeHostedPayment(_order);
payment.SetPayPageLanguageCode(LanguageCode.sv)
.SetReturnUrl("http://myurl.se")
.CalculateRequestValues();
_xml = _xmlBuilder.GetXml(payment);
const string expectedString =
"<orderrows><row><sku>0</sku><name>Product</name>" +
"<description>Good product</description><amount>500</amount>" +
"<vat>100</vat><quantity>1</quantity><unit>kg</unit></row></orderrows>";
Assert.That(_xml.Contains(expectedString), Is.True);
}
public void TestBasicXml()
{
_order = WebpayConnection.CreateOrder(SveaConfig.GetDefaultConfig())
.SetClientOrderNumber(TestingTool.DefaultTestClientOrderNumber)
.SetCountryCode(TestingTool.DefaultTestCountryCode)
.SetCurrency(TestingTool.DefaultTestCurrency)
.AddCustomerDetails(Item.IndividualCustomer()
.SetNationalIdNumber(TestingTool.DefaultTestIndividualNationalIdNumber))
.AddOrderRow(Item.OrderRow()
.SetAmountExVat(4)
.SetVatPercent(25)
.SetQuantity(1));
var payment = new FakeHostedPayment(_order);
payment.SetReturnUrl("http://myurl.se")
.CalculateRequestValues();
_xml = _xmlBuilder.GetXml(payment);
const string expectedXml =
"<?xml version=\"1.0\" encoding=\"utf-8\"?><!--Message generated by Integration package C#-->" +
"<payment><customerrefno>33</customerrefno><currency>SEK</currency><amount>500</amount>" +
"<vat>100</vat><lang>en</lang><returnurl>http://myurl.se</returnurl><iscompany>false</iscompany>" +
"<customer><ssn>194605092222</ssn><country>SE</country></customer><orderrows><row><sku /><name />" +
"<description /><amount>500</amount><vat>100</vat><quantity>1</quantity></row></orderrows>" +
"<excludepaymentMethods /><addinvoicefee>false</addinvoicefee></payment>";
Assert.That(_xml, Is.EqualTo(expectedXml));
}
private void ValidateCurrency(CreateOrderBuilder order)
{
if (order.GetCurrency() == null)
{
Errors += "MISSING VALUE - Currency is required. Use SetCurrency(...).\n";
}
}
public void TestBuildCompanyDetails()
{
_order = CreateCompanyDetails(_order);
Assert.That(_order.GetCompanyCustomer().GetCompanyName(), Is.EqualTo("TestCompagniet"));
Assert.That(_order.GetCompanyCustomer().GetVatNumber(), Is.EqualTo("2345234"));
}
public void TestBuildCompanyDetails()
{
_order = CreateCompanyDetails(_order);
Assert.That(_order.GetCompanyCustomer().GetCompanyName(), Is.EqualTo("TestCompagniet"));
Assert.That(_order.GetCompanyCustomer().GetVatNumber(), Is.EqualTo("2345234"));
}
public void TestBasicXml()
{
_order = WebpayConnection.CreateOrder(SveaConfig.GetDefaultConfig())
.SetClientOrderNumber(TestingTool.DefaultTestClientOrderNumber)
.SetCountryCode(TestingTool.DefaultTestCountryCode)
.SetCurrency(TestingTool.DefaultTestCurrency)
.AddCustomerDetails(Item.IndividualCustomer()
.SetNationalIdNumber(TestingTool.DefaultTestIndividualNationalIdNumber))
.AddOrderRow(Item.OrderRow()
.SetAmountExVat(4)
.SetVatPercent(25)
.SetQuantity(1));
var payment = new FakeHostedPayment(_order);
payment.SetReturnUrl("http://myurl.se")
.CalculateRequestValues();
_xml = _xmlBuilder.GetXml(payment);
const string expectedXml =
"<?xml version=\"1.0\" encoding=\"utf-8\"?><!--Message generated by Integration package C#-->" +
"<payment><customerrefno>33</customerrefno><currency>SEK</currency><amount>500</amount>" +
"<vat>100</vat><lang>en</lang><returnurl>http://myurl.se</returnurl><iscompany>false</iscompany>" +
"<customer><ssn>194605092222</ssn><country>SE</country></customer><orderrows><row><sku /><name />" +
"<description /><amount>500</amount><vat>100</vat><quantity>1</quantity></row></orderrows>" +
"<excludepaymentMethods /><addinvoicefee>false</addinvoicefee></payment>";
Assert.That(_xml, Is.EqualTo(expectedXml));
}
public void TestFormatFixedDiscountRowsAmountExVatAndVatPercentWithSingleVatRatePresent()
{
CreateOrderBuilder order = WebpayConnection.CreateOrder(SveaConfig.GetDefaultConfig())
.AddOrderRow(Item.OrderRow()
.SetAmountExVat(4.0M)
.SetVatPercent(25)
.SetQuantity(1))
.AddDiscount(Item.FixedDiscount()
.SetDiscountId("0")
.SetName("Tess")
.SetDescription("Tester")
.SetAmountExVat(1.0M)
.SetVatPercent(25)
.SetUnit("st"));
List <OrderRow> newRows = new WebServiceRowFormatter <CreateOrderBuilder>(order).FormatRows();
OrderRow newRow = newRows[1];
Assert.That(newRow.ArticleNumber, Is.EqualTo("0"));
Assert.That(newRow.Description, Is.EqualTo("Tess: Tester"));
Assert.That(newRow.PricePerUnit, Is.EqualTo(-1.0M));
Assert.That(newRow.VatPercent, Is.EqualTo(25));
Assert.That(newRow.DiscountPercent, Is.EqualTo(0));
Assert.That(newRow.NumberOfUnits, Is.EqualTo(1));
Assert.That(newRow.Unit, Is.EqualTo("st"));
}
public string ValidateNlIdentity(CreateOrderBuilder order)
{
string errors = "";
//Individual
if (!order.GetIsCompanyIdentity())
{
if (order.GetIndividualCustomer().GetInitials() == null)
{
errors +=
"MISSING VALUE - Initials is required for individual customers when countrycode is NL. Use SetInitials().\n";
}
if (order.GetIndividualCustomer().GetBirthDate() == null)
{
errors +=
"MISSING VALUE - Birth date is required for individual customers when countrycode is NL. Use SetBirthDate().\n";
}
if (order.GetIndividualCustomer().GetFirstName() == null ||
order.GetIndividualCustomer().GetLastName() == null)
{
errors +=
"MISSING VALUE - Name is required for individual customers when countrycode is NL. Use SetName().\n";
}
}
//Company
if (order.GetIsCompanyIdentity())
{
if (order.GetCompanyCustomer().GetVatNumber() == null)
{
errors +=
"MISSING VALUE - Vat number is required for company customers when countrycode is NL. Use SetVatNumber().\n";
}
if (order.GetCompanyCustomer().GetCompanyName() == null)
{
errors +=
"MISSING VALUE - Company name is required for individual customers when countrycode is NL. Use SetName().\n";
}
}
//Individual and Company
if (order.GetCustomerIdentity().Street == null || order.GetCustomerIdentity().HouseNumber == null)
{
errors +=
"MISSING VALUE - Street address and house number is required for all customers when countrycode is NL. Use SetStreetAddress().\n";
}
if (order.GetCustomerIdentity().Locality == null)
{
errors +=
"MISSING VALUE - Locality is required for all customers when countrycode is NL. Use SetLocality().\n";
}
if (order.GetCustomerIdentity().ZipCode == null)
{
errors +=
"MISSING VALUE - Zip code is required for all customers when countrycode is NL. Use SetZipCode().\n";
}
return(errors);
}
public void CreateOrder(int userId, Order order, OrderLumberLineItem[] lumberLineItems, OrderMiscellaneousLineItem[] miscLineItems)
{
var builder = new CreateOrderBuilder(userId, order,
lumberLineItems, miscLineItems);
var transaction = new TransactionalCommand(builder.Commands);
transaction.Execute();
}
public HostedPayment(CreateOrderBuilder createOrderBuilder)
{
CrOrderBuilder = createOrderBuilder;
HrowBuilder = new List<HostedOrderRowBuilder>();
Excluded = new ExcludePayments();
ExcludedPaymentMethod = new List<string>();
ReturnUrl = "";
}
public HostedPayment(CreateOrderBuilder createOrderBuilder)
{
CrOrderBuilder = createOrderBuilder;
HrowBuilder = new List <HostedOrderRowBuilder>();
Excluded = new ExcludePayments();
ExcludedPaymentMethod = new List <string>();
ReturnUrl = "";
}
public string ValidateNlIdentity(CreateOrderBuilder order)
{
string errors = "";
//Individual
if (!order.GetIsCompanyIdentity())
{
if (order.GetIndividualCustomer().GetInitials() == null)
{
errors +=
"MISSING VALUE - Initials is required for individual customers when countrycode is NL. Use SetInitials().\n";
}
if (order.GetIndividualCustomer().GetBirthDate() == null)
{
errors +=
"MISSING VALUE - Birth date is required for individual customers when countrycode is NL. Use SetBirthDate().\n";
}
if (order.GetIndividualCustomer().GetFirstName() == null ||
order.GetIndividualCustomer().GetLastName() == null)
{
errors +=
"MISSING VALUE - Name is required for individual customers when countrycode is NL. Use SetName().\n";
}
}
//Company
if (order.GetIsCompanyIdentity())
{
if (order.GetCompanyCustomer().GetVatNumber() == null)
{
errors +=
"MISSING VALUE - Vat number is required for company customers when countrycode is NL. Use SetVatNumber().\n";
}
if (order.GetCompanyCustomer().GetCompanyName() == null)
{
errors +=
"MISSING VALUE - Company name is required for individual customers when countrycode is NL. Use SetName().\n";
}
}
//Individual and Company
if (order.GetCustomerIdentity().Street == null || order.GetCustomerIdentity().HouseNumber == null)
{
errors +=
"MISSING VALUE - Street address and house number is required for all customers when countrycode is NL. Use SetStreetAddress().\n";
}
if (order.GetCustomerIdentity().Locality == null)
{
errors +=
"MISSING VALUE - Locality is required for all customers when countrycode is NL. Use SetLocality().\n";
}
if (order.GetCustomerIdentity().ZipCode == null)
{
errors +=
"MISSING VALUE - Zip code is required for all customers when countrycode is NL. Use SetZipCode().\n";
}
return errors;
}
public void TestBuildEmptyOrder()
{
CreateOrderBuilder sveaRequest = _order
.SetCountryCode(CountryCode.NL)
.Build();
Assert.That(sveaRequest.GetOrderRows().Count, Is.EqualTo(0));
Assert.That(sveaRequest.GetFixedDiscountRows().Count, Is.EqualTo(0));
}
private void SerializeUnknownCustomer(CreateOrderBuilder order, XmlWriter xmlw)
{
Action <string, string> doWriteSimple = (name, value) => WriteSimpleElement(name, value, xmlw);
xmlw.WriteStartElement("customer");
doWriteSimple("unknowncustomer", "true");
doWriteSimple("country", order.GetCountryCode().ToString().ToUpper());
xmlw.WriteEndElement();
}
protected void ValidateRequiredFieldsForOrder(CreateOrderBuilder order)
{
if (order.GetOrderRows() != null && order.GetOrderRows().Count > 0)
{
return;
}
Errors +=
"MISSING VALUE - OrderRows are required. Use AddOrderRow(Item.OrderRow) to get orderrow setters.\n";
}
protected void ValidateRequiredFieldsForOrder(CreateOrderBuilder order)
{
if (order.GetOrderRows() != null && order.GetOrderRows().Count > 0)
{
return;
}
Errors +=
"MISSING VALUE - OrderRows are required. Use AddOrderRow(Item.OrderRow) to get orderrow setters.\n";
}
public void AllPricesAreSpecifiedIncVatForSingleRowIncVat()
{
var orderBuilder = new CreateOrderBuilder(SveaConfig.GetDefaultConfig());
orderBuilder.AddOrderRow(Item.OrderRow().SetAmountIncVat(12.23M));
var order = new WebServiceRowFormatter <CreateOrderBuilder> .Order(orderBuilder);
var resultOrder = WebServiceRowFormatter <CreateOrderBuilder> .CheckIfRowsIncVat(true)(order);
Assert.That(resultOrder.AllPricesAreSpecifiedIncVat, Is.True);
}
public void TestCheckOfIdentityClass()
{
const string expectedMessage = "MISSING VALUE - CountryCode is required. Use SetCountryCode().\n" +
"MISSING VALUE - OrderRows are required. Use AddOrderRow(Item.OrderRow) to get orderrow setters.\n" +
"MISSING VALUE - OrderDate is required. Use SetOrderDate().\n";
CreateOrderBuilder order = WebpayConnection.CreateOrder(SveaConfig.GetDefaultConfig())
.AddCustomerDetails(TestingTool.CreateCompanyCustomer());
Assert.That(_orderValidator.Validate(order), Is.EqualTo(expectedMessage));
}
public void TestFormatFixedDiscountRowsAmount()
{
CreateOrderBuilder order = WebpayConnection.CreateOrder(SveaConfig.GetDefaultConfig())
.AddDiscount(Item.FixedDiscount()
.SetAmountIncVat(4));
List <HostedOrderRowBuilder> newRows = new HostedRowFormatter <CreateOrderBuilder>().FormatRows(order);
HostedOrderRowBuilder newRow = newRows[0];
Assert.That(newRow.GetAmount(), Is.EqualTo(-400L));
}
public void TestSucceedOnGoodValuesSe()
{
CreateOrderBuilder order = WebpayConnection.CreateOrder(SveaConfig.GetDefaultConfig())
.AddOrderRow(TestingTool.CreateMiniOrderRow())
.AddCustomerDetails(Item.IndividualCustomer()
.SetNationalIdNumber(TestingTool.DefaultTestIndividualNationalIdNumber))
.SetCountryCode(TestingTool.DefaultTestCountryCode)
.SetOrderDate(new DateTime(2012, 05, 01))
.SetValidator(new VoidValidator());
Assert.That(_orderValidator.Validate(order), Is.EqualTo(""));
}
private void ValidateClientOrderNumber(CreateOrderBuilder order)
{
if (order.GetClientOrderNumber() == null)
{
Errors += "MISSING VALUE - ClientOrderNumber is required. Use SetClientOrderNumber(...).\n";
}
else if (order.GetClientOrderNumber().Trim().Length == 0)
{
Errors +=
"MISSING VALUE - ClientOrderNumber is required (has an empty value). Use SetClientOrderNumber(...).\n";
}
}
private void ValidateClientOrderNumber(CreateOrderBuilder order)
{
if (order.GetClientOrderNumber() == null)
{
Errors += "MISSING VALUE - ClientOrderNumber is required. Use SetClientOrderNumber(...).\n";
}
else if (order.GetClientOrderNumber().Trim().Length == 0)
{
Errors +=
"MISSING VALUE - ClientOrderNumber is required (has an empty value). Use SetClientOrderNumber(...).\n";
}
}
public string ValidateNordicIdentity(CreateOrderBuilder order)
{
//check Company identity
if (order.GetCustomerIdentity().NationalIdNumber == null)
{
return(order.GetIsCompanyIdentity()
? "MISSING VALUE - Organisation number is required for company customers when countrycode is SE, NO, DK or FI. Use SetNationalIdNumber(...).\n"
: "MISSING VALUE - National number(ssn) is required for individual customers when countrycode is SE, NO, DK or FI. Use SetNationalIdNumber(...).\n");
}
return("");
}
public void TestGetTotalVatNegative()
{
CreateOrderBuilder order = WebpayConnection.CreateOrder(SveaConfig.GetDefaultConfig())
.AddOrderRow(Item.OrderRow()
.SetAmountIncVat(-100L)
.SetVatPercent(25)
.SetQuantity(2));
var formatter = new HostedRowFormatter <CreateOrderBuilder>();
List <HostedOrderRowBuilder> formatRowsList = formatter.FormatRows(order);
Assert.That(formatter.GetTotalVat(), Is.EqualTo(-4000L));
}
public void TestFormatShippingFeeRowsVat()
{
CreateOrderBuilder order = WebpayConnection.CreateOrder(SveaConfig.GetDefaultConfig())
.AddFee(Item.ShippingFee()
.SetAmountExVat(4)
.SetVatPercent(25));
List <HostedOrderRowBuilder> newRows = new HostedRowFormatter <CreateOrderBuilder>().FormatRows(order);
HostedOrderRowBuilder newRow = newRows[0];
Assert.That(newRow.GetAmount(), Is.EqualTo(500L));
Assert.That(newRow.GetVat(), Is.EqualTo(100L));
}
public void TestFailOnMissingCountryCodeOnCreateOrder()
{
const string expectedMessage = "MISSING VALUE - CountryCode is required. Use SetCountryCode().\n" +
"MISSING VALUE - OrderRows are required. Use AddOrderRow(Item.OrderRow) to get orderrow setters.\n" +
"MISSING VALUE - OrderDate is required. Use SetOrderDate().\n";
CreateOrderBuilder order = WebpayConnection.CreateOrder(SveaConfig.GetDefaultConfig())
.SetValidator(new VoidValidator())
.SetClientOrderNumber(TestingTool.DefaultTestClientOrderNumber)
.AddCustomerDetails(Item.IndividualCustomer()
.SetNationalIdNumber(TestingTool.DefaultTestIndividualNationalIdNumber));
Assert.That(_orderValidator.Validate(order), Is.EqualTo(expectedMessage));
}
public void TestFailOnNullClientOrderNumber()
{
const string expectedMessage = "MISSING VALUE - CountryCode is required. Use SetCountryCode(...).\n" +
"MISSING VALUE - ClientOrderNumber is required. Use SetClientOrderNumber(...).\n" +
"MISSING VALUE - Currency is required. Use SetCurrency(...).\n" +
"MISSING VALUE - OrderRows are required. Use AddOrderRow(Item.OrderRow) to get orderrow setters.\n";
CreateOrderBuilder order = WebpayConnection.CreateOrder(SveaConfig.GetDefaultConfig())
.AddCustomerDetails(TestingTool.CreateMiniCompanyCustomer())
.SetValidator(new VoidValidator())
.Build();
Assert.That(_orderValidator.Validate(order), Is.EqualTo(expectedMessage));
}
public override string Validate(CreateOrderBuilder order)
{
if (order.GetCustomerIdentity() == null)
{
Errors += "MISSING VALUE - CustomerIdentity must be set.\n";
}
var identityValidator = new IdentityValidator();
switch (order.GetCountryCode())
{
case CountryCode.NONE:
Errors += "MISSING VALUE - CountryCode is required. Use SetCountryCode().\n";
break;
case CountryCode.FI:
case CountryCode.DK:
case CountryCode.NO:
case CountryCode.SE:
Errors += identityValidator.ValidateNordicIdentity(order);
break;
case CountryCode.DE:
Errors += identityValidator.ValidateDeIdentity(order);
break;
case CountryCode.NL:
Errors += identityValidator.ValidateNlIdentity(order);
break;
default:
Errors += "NOT VALID - Given countrycode does not exist in our system.\n";
break;
}
ValidateRequiredFieldsForOrder(order);
ValidateOrderRow(order);
if (order.GetOrderDate() == DateTime.MinValue)
{
Errors += "MISSING VALUE - OrderDate is required. Use SetOrderDate().\n";
}
if (!String.IsNullOrEmpty(order.GetPeppolId()))
{
Errors += ValidatePeppolId(order);
}
return(Errors);
}
public static async Task <CreateOrderEuResponse> CreateInvoiceOrderWithOneOrderRow()
{
CreateOrderBuilder createOrderBuilder = WebpayConnection.CreateOrder(SveaConfig.GetDefaultConfig())
.AddOrderRow(TestingTool.CreateExVatBasedOrderRow("1"))
.AddCustomerDetails(Item.IndividualCustomer()
.SetNationalIdNumber(TestingTool.DefaultTestIndividualNationalIdNumber))
.SetCountryCode(TestingTool.DefaultTestCountryCode)
.SetOrderDate(TestingTool.DefaultTestDate)
.SetClientOrderNumber(TestingTool.DefaultTestClientOrderNumber)
.SetCurrency(TestingTool.DefaultTestCurrency)
;
CreateOrderEuResponse order = await createOrderBuilder.UseInvoicePayment().DoRequest();
return(order);
}
public override string Validate(CreateOrderBuilder order)
{
Errors = "";
if (order.GetCountryCode() == CountryCode.NONE)
{
Errors += "MISSING VALUE - CountryCode is required. Use SetCountryCode(...).\n";
}
ValidateClientOrderNumber(order);
ValidateCurrency(order);
ValidateRequiredFieldsForOrder(order);
ValidateOrderRow(order);
return Errors;
}
protected void ValidateOrderRow(CreateOrderBuilder order)
{
foreach (OrderRowBuilder orderRow in order.GetOrderRows())
{
if (orderRow == null)
{
Errors +=
"MISSING VALUES - AmountExVat, Quantity and VatPercent are required for Orderrow. Use SetAmountExVat(), SetQuantity() and SetVatPercent().\n";
continue;
}
if (orderRow.GetQuantity() <= 0)
{
Errors += "MISSING VALUE - Quantity is required in Item object. Use Item.SetQuantity().\n";
}
if (orderRow.GetAmountExVat() == null && orderRow.GetVatPercent() == null &&
orderRow.GetAmountIncVat() == null)
{
Errors +=
"MISSING VALUE - Two of the values must be set: AmountExVat(not set), AmountIncVat(not set) or VatPercent(not set) for Orderrow. Use two of: SetAmountExVat(), SetAmountIncVat or SetVatPercent().\n";
}
else if (orderRow.GetAmountExVat() != null && orderRow.GetVatPercent() == null &&
orderRow.GetAmountIncVat() == null)
{
Errors +=
"MISSING VALUE - At least one of the values must be set in combination with AmountExVat: AmountIncVat or VatPercent for Orderrow. Use one of: SetAmountIncVat() or SetVatPercent().\n";
}
else if (orderRow.GetAmountExVat() == null && orderRow.GetVatPercent() == null &&
orderRow.GetAmountIncVat() != null)
{
Errors +=
"MISSING VALUE - At least one of the values must be set in combination with AmountIncVat: AmountExVat or VatPercent for Orderrow. Use one of: SetAmountExVat() or SetVatPercent().\n";
}
else if (orderRow.GetAmountExVat() == null && orderRow.GetVatPercent() != null &&
orderRow.GetAmountIncVat() == null)
{
Errors +=
"MISSING VALUE - At least one of the values must be set in combination with VatPercent: AmountIncVat or AmountExVat for Orderrow. Use one of: SetAmountExVat() or SetAmountIncVat().\n";
}
}
}
public override string Validate(CreateOrderBuilder order)
{
if (order.GetCustomerIdentity() == null)
{
Errors += "MISSING VALUE - CustomerIdentity must be set.\n";
}
var identityValidator = new IdentityValidator();
switch (order.GetCountryCode())
{
case CountryCode.NONE:
Errors += "MISSING VALUE - CountryCode is required. Use SetCountryCode().\n";
break;
case CountryCode.FI:
case CountryCode.DK:
case CountryCode.NO:
case CountryCode.SE:
Errors += identityValidator.ValidateNordicIdentity(order);
break;
case CountryCode.DE:
Errors += identityValidator.ValidateDeIdentity(order);
break;
case CountryCode.NL:
Errors += identityValidator.ValidateNlIdentity(order);
break;
default:
Errors += "NOT VALID - Given countrycode does not exist in our system.\n";
break;
}
ValidateRequiredFieldsForOrder(order);
ValidateOrderRow(order);
if (order.GetOrderDate() == DateTime.MinValue)
{
Errors += "MISSING VALUE - OrderDate is required. Use SetOrderDate().\n";
}
return Errors;
}
public WebServicePayment(CreateOrderBuilder orderBuilder)
{
CrOrderBuilder = orderBuilder;
}
public PaymentMethodPayment(CreateOrderBuilder createOrderBuilder, PaymentMethod paymentMethod)
: base(createOrderBuilder)
{
_paymentMethod = paymentMethod;
}
public abstract string Validate(CreateOrderBuilder order);
private void SerializeCustomer(CreateOrderBuilder order, XmlWriter xmlw)
{
if (order.GetCustomerIdentity() == null)
{
return;
}
CustomerIdentity customer;
Action<string, string> doWriteSimple = (name, value) => WriteSimpleElement(name, value, xmlw);
if (order.GetIsCompanyIdentity())
{
customer = order.GetCompanyCustomer();
}
else
{
customer = order.GetIndividualCustomer();
}
xmlw.WriteStartElement("customer");
if (customer.NationalIdNumber != null) //nordic country individual customer type
{
doWriteSimple("ssn", customer.NationalIdNumber);
}
else if (!order.GetIsCompanyIdentity()) //euro country individual
{
doWriteSimple("ssn", customer.IndividualIdentity.BirthDate);
}
else if (order.GetIsCompanyIdentity() && order.GetCountryCode() != CountryCode.SE)
//euro country, Company customer and nationalId not set
{
doWriteSimple("ssn", customer.CompanyIdentity.CompanyVatNumber);
}
//Individual customer
if (!order.GetIsCompanyIdentity())
{
var individualIdentity = customer.IndividualIdentity;
if (individualIdentity != null)
{
doWriteSimple("firstname", individualIdentity.FirstName);
doWriteSimple("lastname", individualIdentity.LastName);
doWriteSimple("initials", individualIdentity.Initials);
}
}
else //Company customer
{
doWriteSimple("firstname", customer.FullName);
}
//Address
doWriteSimple("phone", customer.PhoneNumber);
doWriteSimple("email", customer.Email);
doWriteSimple("address", customer.Street);
doWriteSimple("housenumber", customer.HouseNumber);
doWriteSimple("address2", customer.CoAddress);
doWriteSimple("zip", customer.ZipCode);
doWriteSimple("city", customer.Locality);
if (order.GetCountryCode() != CountryCode.NONE)
{
doWriteSimple("country", order.GetCountryCode().ToString().ToUpper());
}
xmlw.WriteEndElement();
doWriteSimple("ipaddress",
order.GetIsCompanyIdentity()
? order.GetCompanyCustomer().GetIpAddress()
: order.GetIndividualCustomer().GetIpAddress());
}
public void TestOrderRowXml()
{
_order = WebpayConnection.CreateOrder(SveaConfig.GetDefaultConfig())
.AddOrderRow(Item.OrderRow()
.SetArticleNumber("0")
.SetName("Product")
.SetDescription("Good product")
.SetAmountExVat(4)
.SetVatPercent(25)
.SetQuantity(1)
.SetUnit("kg"))
.AddCustomerDetails(Item.CompanyCustomer())
.SetCountryCode(TestingTool.DefaultTestCountryCode)
.SetCurrency(TestingTool.DefaultTestCurrency)
.SetClientOrderNumber(TestingTool.DefaultTestClientOrderNumber);
var payment = new FakeHostedPayment(_order);
payment.SetPayPageLanguageCode(LanguageCode.sv)
.SetReturnUrl("http://myurl.se")
.CalculateRequestValues();
_xml = _xmlBuilder.GetXml(payment);
const string expectedString =
"<orderrows><row><sku>0</sku><name>Product</name>" +
"<description>Good product</description><amount>500</amount>" +
"<vat>100</vat><quantity>1</quantity><unit>kg</unit></row></orderrows>";
Assert.That(_xml.Contains(expectedString), Is.True);
}
public string ValidateNordicIdentity(CreateOrderBuilder order)
{
//check Company identity
if (order.GetCustomerIdentity().NationalIdNumber == null)
{
return order.GetIsCompanyIdentity()
? "MISSING VALUE - Organisation number is required for company customers when countrycode is SE, NO, DK or FI. Use SetNationalIdNumber(...).\n"
: "MISSING VALUE - National number(ssn) is required for individual customers when countrycode is SE, NO, DK or FI. Use SetNationalIdNumber(...).\n";
}
return "";
}
public FakeHostedPayment(CreateOrderBuilder createOrderBuilder)
: base(createOrderBuilder)
{
}
public DirectPayment(CreateOrderBuilder orderBuilder)
: base(orderBuilder)
{
}
private CreateOrderBuilder CreateCompanyDetails(CreateOrderBuilder orderBuilder)
{
return orderBuilder.AddCustomerDetails(TestingTool.CreateMiniCompanyCustomer());
}
public PaymentPlanPayment(CreateOrderBuilder orderBuilder)
: base(orderBuilder)
{
PayType = PaymentType.PAYMENTPLAN;
}
private static CreateOrderBuilder CreateTestCustomerIdentity(CreateOrderBuilder orderBuilder)
{
return orderBuilder.AddCustomerDetails(TestingTool.CreateIndividualCustomer());
}
public void TestCustomerIdentity()
{
_order = CreateTestCustomerIdentity(_order);
Assert.That(_order.GetIndividualCustomer().GetInitials(), Is.EqualTo("SB"));
Assert.That(_order.GetIndividualCustomer().NationalIdNumber, Is.EqualTo("194605092222"));
Assert.That(_order.GetIndividualCustomer().GetFirstName(), Is.EqualTo("Tess"));
Assert.That(_order.GetIndividualCustomer().GetLastName(), Is.EqualTo("Persson"));
Assert.That(_order.GetIndividualCustomer().GetBirthDate(), Is.EqualTo("19231212"));
Assert.That(_order.GetIndividualCustomer().Email, Is.EqualTo("*****@*****.**"));
Assert.That(_order.GetIndividualCustomer().PhoneNumber, Is.EqualTo("0811111111"));
Assert.That(_order.GetIndividualCustomer().IpAddress, Is.EqualTo("123.123.123"));
Assert.That(_order.GetIndividualCustomer().Street, Is.EqualTo("Testgatan"));
Assert.That(_order.GetIndividualCustomer().HouseNumber, Is.EqualTo("1"));
Assert.That(_order.GetIndividualCustomer().CoAddress, Is.EqualTo("c/o Eriksson, Erik"));
Assert.That(_order.GetIndividualCustomer().ZipCode, Is.EqualTo("99999"));
Assert.That(_order.GetIndividualCustomer().Locality, Is.EqualTo("Stan"));
}
public InvoicePayment(CreateOrderBuilder orderBuilder)
: base(orderBuilder)
{
PayType = PaymentType.INVOICE;
}
public PayPagePayment(CreateOrderBuilder orderBuilder)
: base(orderBuilder)
{
_includedPaymentMethod = new List<string>();
}
public void TestXmlCancelUrl()
{
_order = WebpayConnection.CreateOrder(SveaConfig.GetDefaultConfig())
.SetCountryCode(TestingTool.DefaultTestCountryCode)
.SetCurrency(TestingTool.DefaultTestCurrency)
.SetClientOrderNumber(TestingTool.DefaultTestClientOrderNumber)
.AddOrderRow(TestingTool.CreateMiniOrderRow())
.AddCustomerDetails(Item.CompanyCustomer());
var payment = new FakeHostedPayment(_order);
payment.SetCancelUrl("http://www.cancel.com")
.SetReturnUrl("http://myurl.se")
.CalculateRequestValues();
_xml = _xmlBuilder.GetXml(payment);
Assert.That(_xml.Contains("<cancelurl>http://www.cancel.com</cancelurl>"), Is.True);
}
public void SetUp()
{
_order = WebpayConnection.CreateOrder(SveaConfig.GetDefaultConfig());
_order.SetValidator(new VoidValidator());
}
public void TestXmlWithIndividualCustomer()
{
_order = WebpayConnection.CreateOrder(SveaConfig.GetDefaultConfig())
.SetCountryCode(TestingTool.DefaultTestCountryCode)
.SetCurrency(TestingTool.DefaultTestCurrency)
.SetClientOrderNumber(TestingTool.DefaultTestClientOrderNumber)
.AddOrderRow(Item.OrderRow()
.SetAmountExVat(4)
.SetVatPercent(25)
.SetQuantity(1))
.AddCustomerDetails(Item.IndividualCustomer()
.SetName("Julius", "Caesar")
.SetInitials("JS")
.SetNationalIdNumber("666666")
.SetPhoneNumber("999999")
.SetEmail("*****@*****.**")
.SetIpAddress("123.123.123.123")
.SetStreetAddress("Gatan", "23")
.SetCoAddress("c/o Eriksson")
.SetZipCode("9999")
.SetLocality("Stan"));
var payment = new FakeHostedPayment(_order);
payment.SetReturnUrl("http://myurl.se")
.CalculateRequestValues();
_xml = _xmlBuilder.GetXml(payment);
const string expectedString =
"<customer><ssn>666666</ssn><firstname>Julius</firstname>" +
"<lastname>Caesar</lastname><initials>JS</initials>" +
"<phone>999999</phone><email>[email protected]</email>" +
"<address>Gatan</address><housenumber>23</housenumber>" +
"<address2>c/o Eriksson</address2><zip>9999</zip>" +
"<city>Stan</city><country>SE</country></customer>";
Assert.That(_xml.Contains(expectedString), Is.True);
Assert.That(_xml.Contains("<ipaddress>123.123.123.123</ipaddress>"), Is.True);
}
public CardPayment(CreateOrderBuilder orderBuilder)
: base(orderBuilder)
{
}
public void TestXmlWithCompanyCustomer()
{
_order = WebpayConnection.CreateOrder(SveaConfig.GetDefaultConfig())
.AddOrderRow(Item.OrderRow()
.SetAmountExVat(4)
.SetVatPercent(25)
.SetQuantity(1))
.SetCurrency(TestingTool.DefaultTestCurrency)
.SetClientOrderNumber(TestingTool.DefaultTestClientOrderNumber)
.SetCountryCode(TestingTool.DefaultTestCountryCode)
.AddCustomerDetails(TestingTool.CreateCompanyCustomer());
var payment = new FakeHostedPayment(_order);
payment.SetReturnUrl("http://myurl.se")
.CalculateRequestValues();
_xml = _xmlBuilder.GetXml(payment);
const string expectedString =
"<customer><ssn>164608142222</ssn><firstname>Tess, T Persson</firstname>" +
"<phone>0811111111</phone><email>[email protected]</email>" +
"<address>Testgatan</address><housenumber>1</housenumber>" +
"<address2>c/o Eriksson, Erik</address2><zip>99999</zip>" +
"<city>Stan</city><country>SE</country></customer>";
Assert.That(_xml.Contains(expectedString), Is.True);
Assert.That(_xml.Contains("<ipaddress>123.123.123.123</ipaddress>"), Is.True);
}
