public OrderLineWS(
Integer id,
Integer itemId,
String description,
BigDecimal amount,
BigDecimal quantity,
BigDecimal price,
Date create,
Integer deleted,
Integer newTypeId,
Boolean editable,
Integer orderId,
Boolean useItem,
Integer version) {
setId(id);
setItemId(itemId);
setDescription(description);
setAmount(amount);
setQuantity(quantity);
setPrice(price);
setCreateDatetime(create);
setDeleted(deleted);
setTypeId(newTypeId);
setEditable(editable);
setOrderId(orderId);
setUseItem(useItem);
setVersionNum(version);
}
/**
* To add a line to an order
*
* @param order
* @param lineQty
* @param lineTypeId
* @param lineItemId
* @param linePrice
* @param description
* @return
*/
public static OrderWS addLine(
OrderWS order,
Integer lineQty,
Integer lineTypeId,
Integer lineItemId,
BigDecimal linePrice,
String description) {
// store the existing lines
OrderLineWS[] existingLines = order.getOrderLines();
List<OrderLineWS> finalLines = new ArrayList<OrderLineWS>();
// iterate over the array and add to the ArrayList
if (null != existingLines) {
for (OrderLineWS oneItem : existingLines) {
finalLines.add(oneItem);
}
}
// Now add some 1 line
OrderLineWS line;
line = new OrderLineWS();
line.setTypeId(lineTypeId);
line.setItemId(lineItemId);
if (null != linePrice) {
line.setPrice(linePrice);
}
line.setAmount(linePrice);
line.setQuantity(lineQty);
line.setDescription(description);
finalLines.add(line);
OrderLineWS[] simpleArray = new OrderLineWS[finalLines.size()];
finalLines.toArray(simpleArray);
order.setOrderLines(simpleArray);
return order;
}
public void testCreateInvoiceFromOrder() throws Exception {
JbillingAPI api = JbillingAPIFactory.getAPI();
final Integer USER_ID = 10730; // user has no orders
// setup orders
OrderWS order = new OrderWS();
order.setUserId(USER_ID);
order.setBillingTypeId(Constants.ORDER_BILLING_PRE_PAID);
order.setPeriod(1); // once
order.setCurrencyId(1);
order.setActiveSince(new Date());
OrderLineWS line = new OrderLineWS();
line.setTypeId(Constants.ORDER_LINE_TYPE_ITEM);
line.setDescription("Order line");
line.setItemId(1);
line.setQuantity(1);
line.setPrice(new BigDecimal("10.00"));
line.setAmount(new BigDecimal("10.00"));
order.setOrderLines(new OrderLineWS[] {line});
// create orders
Integer orderId1 = api.createOrder(order);
Integer orderId2 = api.createOrder(order);
// generate invoice using first order
Integer invoiceId = api.createInvoiceFromOrder(orderId1, null);
assertNotNull("Order 1 created", orderId1);
assertNotNull("Order 2 created", orderId2);
assertNotNull("Invoice created", invoiceId);
Integer[] invoiceIds = api.getLastInvoices(USER_ID, 2);
assertEquals("Only 1 invoice was generated", 1, invoiceIds.length);
InvoiceWS invoice = api.getInvoiceWS(invoiceId);
assertEquals("Invoice total is $10.00", new BigDecimal("10.00"), invoice.getTotalAsDecimal());
assertEquals("Only 1 order invoiced", 1, invoice.getOrders().length);
assertEquals("Invoice generated from 1st order", orderId1, invoice.getOrders()[0]);
// add second order to invoice
Integer invoiceId2 = api.createInvoiceFromOrder(orderId2, invoiceId);
assertEquals("Order added to the same invoice", invoiceId, invoiceId2);
invoiceIds = api.getLastInvoices(USER_ID, 2);
assertEquals("Still only 1 invoice generated", 1, invoiceIds.length);
invoice = api.getInvoiceWS(invoiceId);
assertEquals("Invoice total is $20.00", new BigDecimal("20.00"), invoice.getTotalAsDecimal());
assertEquals("2 orders invoiced", 2, invoice.getOrders().length);
// cleanup
api.deleteInvoice(invoiceId);
api.deleteOrder(orderId1);
api.deleteOrder(orderId2);
}
public OrderLineWS(
Integer id,
Integer itemId,
String description,
BigDecimal amount,
BigDecimal quantity,
BigDecimal price,
Date create,
Integer deleted,
Integer newTypeId,
Boolean editable,
Integer orderId,
Boolean useItem,
Integer version,
String productCode,
Integer[] assetIds,
MetaFieldValueWS[] metaFields,
String sipUri,
boolean isPercentage) {
setId(id);
setItemId(itemId);
setDescription(description);
setAmount(amount);
setQuantity(quantity);
setPrice(price);
setCreateDatetime(create);
setDeleted(deleted);
setTypeId(newTypeId);
setEditable(editable);
setOrderId(orderId);
setUseItem(useItem);
setVersionNum(version);
setAssetIds(assetIds);
setSipUri(sipUri);
setProductCode(productCode);
setMetaFields(metaFields);
objectId = UUID.randomUUID().toString();
setProductCode(productCode);
setPercentage(isPercentage);
}
public OrderWS buildOrder(int userId, List<Integer> itemIds, BigDecimal linePrice) {
OrderWS order = new OrderWS();
order.setUserId(userId);
order.setBillingTypeId(Constants.ORDER_BILLING_POST_PAID);
order.setPeriod(ORDER_PERIOD_ONCE); // once
order.setCurrencyId(CURRENCY_USD);
order.setActiveSince(new Date());
order.setProrateFlag(Boolean.FALSE);
ArrayList<OrderLineWS> lines = new ArrayList<OrderLineWS>(itemIds.size());
for (int i = 0; i < itemIds.size(); i++) {
OrderLineWS nextLine = new OrderLineWS();
nextLine.setTypeId(Constants.ORDER_LINE_TYPE_ITEM);
nextLine.setDescription("Order line: " + i);
nextLine.setItemId(itemIds.get(i));
nextLine.setQuantity(1);
nextLine.setPrice(linePrice);
nextLine.setAmount(nextLine.getQuantityAsDecimal().multiply(linePrice));
lines.add(nextLine);
}
order.setOrderLines(lines.toArray(new OrderLineWS[lines.size()]));
return order;
}
/**
* Tests that when a past due invoice is processed it will generate a new invoice for the current
* period that contains all previously un-paid balances as the carried balance.
*
* <p>Invoices that have been carried still show the original balance for reporting/paper-trail
* purposes, but will not be re-processed by the system as part of the normal billing process.
*
* @throws Exception
*/
public void testCreateWithCarryOver() throws Exception {
final Integer USER_ID = 10743; // user has one past-due invoice to be carried forward
final Integer OVERDUE_INVOICE_ID = 70; // holds a $20 balance
JbillingAPI api = JbillingAPIFactory.getAPI();
// new order witha single line item
OrderWS order = new OrderWS();
order.setUserId(USER_ID);
order.setBillingTypeId(Constants.ORDER_BILLING_PRE_PAID);
order.setPeriod(1); // once
order.setCurrencyId(1);
order.setActiveSince(new Date());
OrderLineWS line = new OrderLineWS();
line.setTypeId(Constants.ORDER_LINE_TYPE_ITEM);
line.setDescription("Order line");
line.setItemId(1);
line.setQuantity(1);
line.setPrice(new BigDecimal("10.00"));
line.setAmount(new BigDecimal("10.00"));
order.setOrderLines(new OrderLineWS[] {line});
// create order
Integer orderId = api.createOrder(order);
// create invoice
Integer invoiceId = api.createInvoice(USER_ID, false)[0];
// validate that the overdue invoice has been carried forward to the newly created invoice
InvoiceWS overdue = api.getInvoiceWS(OVERDUE_INVOICE_ID);
assertEquals(
"Status updated to 'unpaid and carried'",
Constants.INVOICE_STATUS_UNPAID_AND_CARRIED,
overdue.getStatusId());
assertEquals("Carried invoice will not be re-processed", 0, overdue.getToProcess().intValue());
assertEquals(
"Overdue invoice holds original balance",
new BigDecimal("20.00"),
overdue.getBalanceAsDecimal());
assertEquals(
"Overdue invoice delegated to the newly created invoice",
invoiceId,
overdue.getDelegatedInvoiceId());
// validate that the newly created invoice contains the carried balance
InvoiceWS invoice = api.getInvoiceWS(invoiceId);
assertEquals(
"New invoice balance is equal to the current period charges",
new BigDecimal("10.00"),
invoice.getBalanceAsDecimal());
assertEquals(
"New invoice holds the carried balance equal to the old invoice balance",
overdue.getBalanceAsDecimal(),
invoice.getCarriedBalanceAsDecimal());
assertEquals(
"New invoice total is equal to the current charges plus the carried total",
new BigDecimal("30.00"),
invoice.getTotalAsDecimal());
}
public void testCreateInvoice() {
try {
final Integer USER_ID = 10730; // user has no orders
JbillingAPI api = JbillingAPIFactory.getAPI();
// setup order
OrderWS order = new OrderWS();
order.setUserId(USER_ID);
order.setBillingTypeId(Constants.ORDER_BILLING_PRE_PAID);
order.setPeriod(1); // once
order.setCurrencyId(1);
order.setActiveSince(new Date());
OrderLineWS line = new OrderLineWS();
line.setTypeId(Constants.ORDER_LINE_TYPE_ITEM);
line.setDescription("Order line");
line.setItemId(1);
line.setQuantity(1);
line.setPrice(new BigDecimal("10.00"));
line.setAmount(new BigDecimal("10.00"));
order.setOrderLines(new OrderLineWS[] {line});
/*
* Test invoicing of one-time and recurring orders
*/
// create 1st order
Integer orderId1 = api.createOrder(order);
// create 2nd order
line.setPrice(new BigDecimal("20.00"));
line.setAmount(new BigDecimal("20.00"));
Integer orderId2 = api.createOrder(order);
// create invoice
Integer[] invoices = api.createInvoice(USER_ID, false);
assertEquals("Number of invoices returned", 1, invoices.length);
InvoiceWS invoice = api.getInvoiceWS(invoices[0]);
assertNull("Invoice is not delegated.", invoice.getDelegatedInvoiceId());
assertEquals(
"Invoice does not have a carried balance.",
BigDecimal.ZERO,
invoice.getCarriedBalanceAsDecimal());
Integer[] invoicedOrderIds = invoice.getOrders();
assertEquals("Number of orders invoiced", 2, invoicedOrderIds.length);
Arrays.sort(invoicedOrderIds);
assertEquals("Order 1 invoiced", orderId1, invoicedOrderIds[0]);
assertEquals("Order 2 invoiced", orderId2, invoicedOrderIds[1]);
assertEquals("Total is 30.0", new BigDecimal("30.00"), invoice.getTotalAsDecimal());
// clean up
api.deleteInvoice(invoices[0]);
api.deleteOrder(orderId1);
api.deleteOrder(orderId2);
/*
* Test only recurring order can generate invoice.
*/
// one-time order
line.setPrice(new BigDecimal("2.00"));
line.setAmount(new BigDecimal("2.00"));
orderId1 = api.createOrder(order);
// try to create invoice, but none should be returned
invoices = api.createInvoice(USER_ID, true);
// Note: CXF returns null for empty array
if (invoices != null) {
assertEquals("Number of invoices returned", 0, invoices.length);
}
// recurring order
order.setPeriod(2); // monthly
line.setPrice(new BigDecimal("3.00"));
line.setAmount(new BigDecimal("3.00"));
orderId2 = api.createOrder(order);
// create invoice
invoices = api.createInvoice(USER_ID, true);
assertEquals("Number of invoices returned", 1, invoices.length);
invoice = api.getInvoiceWS(invoices[0]);
invoicedOrderIds = invoice.getOrders();
assertEquals("Number of orders invoiced", 2, invoicedOrderIds.length);
Arrays.sort(invoicedOrderIds);
assertEquals("Order 1 invoiced", orderId1, invoicedOrderIds[0]);
assertEquals("Order 2 invoiced", orderId2, invoicedOrderIds[1]);
assertEquals("Total is 5.0", new BigDecimal("5.00"), invoice.getTotalAsDecimal());
// clean up
api.deleteInvoice(invoices[0]);
api.deleteOrder(orderId1);
api.deleteOrder(orderId2);
} catch (Exception e) {
e.printStackTrace();
fail("Exception caught:" + e);
}
}
public void setAmountAsDecimal(BigDecimal amount) {
setAmount(amount);
}