How to use

BillingState

in

com.ning.billing.overdue.config.api

  @Test(groups = "fast")
  public void testBalanceFormatting() throws Exception {
    final BillingState billingState = new BillingState(UUID.randomUUID(), 2, BigDecimal.TEN,
                              new LocalDate(), DateTimeZone.UTC, UUID.randomUUID(),
                              null, null);
    final DefaultBillingStateFormatter formatter = new DefaultBillingStateFormatter(billingState);
    Assert.assertEquals(formatter.getFormattedBalanceOfUnpaidInvoices(), "10.00");
  }
}

@Override
public boolean evaluate(final BillingState state, final LocalDate date) {
  LocalDate unpaidInvoiceTriggerDate = null;
  if (timeSinceEarliestUnpaidInvoiceEqualsOrExceeds != null && state.getDateOfEarliestUnpaidInvoice() != null) {  // no date => no unpaid invoices
    unpaidInvoiceTriggerDate = state.getDateOfEarliestUnpaidInvoice().plus(timeSinceEarliestUnpaidInvoiceEqualsOrExceeds.toJodaPeriod());
  }
  return
      (numberOfUnpaidInvoicesEqualsOrExceeds == null || state.getNumberOfUnpaidInvoices() >= numberOfUnpaidInvoicesEqualsOrExceeds) &&
      (totalUnpaidInvoiceBalanceEqualsOrExceeds == null || totalUnpaidInvoiceBalanceEqualsOrExceeds.compareTo(state.getBalanceOfUnpaidInvoices()) <= 0) &&
      (timeSinceEarliestUnpaidInvoiceEqualsOrExceeds == null ||
       (unpaidInvoiceTriggerDate != null && !unpaidInvoiceTriggerDate.isAfter(date))) &&
      (responseForLastFailedPayment == null || responseIsIn(state.getResponseForLastFailedPayment(), responseForLastFailedPayment)) &&
      (controlTag == null || isTagIn(controlTag, state.getTags()));
}

public OverdueState refresh(final InternalCallContext context) throws OverdueException, OverdueApiException {
  if (overdueStateSet.size() < 1) { // No configuration available
    return overdueStateSet.getClearState();
  }
  final BillingState billingState = billingState(context);
  final String previousOverdueStateName = api.getBlockingStateForService(overdueable.getId(), BlockingStateType.ACCOUNT, OverdueService.OVERDUE_SERVICE_NAME, context).getStateName();
  final OverdueState currentOverdueState = overdueStateSet.findState(previousOverdueStateName);
  final OverdueState nextOverdueState = overdueStateSet.calculateOverdueState(billingState, clock.getToday(billingState.getAccountTimeZone()));
  overdueStateApplicator.apply(overdueStateSet, billingState, overdueable, currentOverdueState, nextOverdueState, context);
  return nextOverdueState;
}

final boolean conditionForNextNotfication = !nextOverdueState.isClearState() ||
                      (firstOverdueState != null && billingState != null && billingState.getDateOfEarliestUnpaidInvoice() != null);

@Test(groups = "fast")
public void testTotalUnpaidInvoiceBalanceEqualsOrExceeds() throws Exception {
  final String xml =
      "<condition>" +
      "	<totalUnpaidInvoiceBalanceEqualsOrExceeds>100.00</totalUnpaidInvoiceBalanceEqualsOrExceeds>" +
      "</condition>";
  final InputStream is = new ByteArrayInputStream(xml.getBytes());
  final MockCondition c = XMLLoader.getObjectFromStreamNoValidation(is, MockCondition.class);
  final UUID unpaidInvoiceId = UUID.randomUUID();
  final BillingState state0 = new BillingState(new UUID(0L, 1L), 0, BigDecimal.ZERO, new LocalDate(),
                         DateTimeZone.UTC, unpaidInvoiceId, PaymentResponse.INSUFFICIENT_FUNDS, new Tag[]{});
  final BillingState state1 = new BillingState(new UUID(0L, 1L), 1, new BigDecimal("100.00"), new LocalDate(),
                         DateTimeZone.UTC, unpaidInvoiceId, PaymentResponse.INSUFFICIENT_FUNDS, new Tag[]{});
  final BillingState state2 = new BillingState(new UUID(0L, 1L), 1, new BigDecimal("200.00"), new LocalDate(),
                         DateTimeZone.UTC, unpaidInvoiceId, PaymentResponse.INSUFFICIENT_FUNDS, new Tag[]{});
  Assert.assertTrue(!c.evaluate(state0, new LocalDate()));
  Assert.assertTrue(c.evaluate(state1, new LocalDate()));
  Assert.assertTrue(c.evaluate(state2, new LocalDate()));
}

@Test(groups = "fast")
public void testNumberOfUnpaidInvoicesEqualsOrExceeds() throws Exception {
  final String xml =
      "<condition>" +
      "	<numberOfUnpaidInvoicesEqualsOrExceeds>1</numberOfUnpaidInvoicesEqualsOrExceeds>" +
      "</condition>";
  final InputStream is = new ByteArrayInputStream(xml.getBytes());
  final MockCondition c = XMLLoader.getObjectFromStreamNoValidation(is, MockCondition.class);
  final UUID unpaidInvoiceId = UUID.randomUUID();
  final BillingState state0 = new BillingState(new UUID(0L, 1L), 0, BigDecimal.ZERO, new LocalDate(),
                         DateTimeZone.UTC, unpaidInvoiceId, PaymentResponse.INSUFFICIENT_FUNDS, new Tag[]{});
  final BillingState state1 = new BillingState(new UUID(0L, 1L), 1, BigDecimal.ZERO, new LocalDate(),
                         DateTimeZone.UTC, unpaidInvoiceId, PaymentResponse.INSUFFICIENT_FUNDS, new Tag[]{});
  final BillingState state2 = new BillingState(new UUID(0L, 1L), 2, BigDecimal.ZERO, new LocalDate(),
                         DateTimeZone.UTC, unpaidInvoiceId, PaymentResponse.INSUFFICIENT_FUNDS, new Tag[]{});
  Assert.assertTrue(!c.evaluate(state0, new LocalDate()));
  Assert.assertTrue(c.evaluate(state1, new LocalDate()));
  Assert.assertTrue(c.evaluate(state2, new LocalDate()));
}

@Test(groups = "fast")
public void testTimeSinceEarliestUnpaidInvoiceEqualsOrExceeds() throws Exception {
  final String xml =
      "<condition>" +
      "	<timeSinceEarliestUnpaidInvoiceEqualsOrExceeds><unit>DAYS</unit><number>10</number></timeSinceEarliestUnpaidInvoiceEqualsOrExceeds>" +
      "</condition>";
  final InputStream is = new ByteArrayInputStream(xml.getBytes());
  final MockCondition c = XMLLoader.getObjectFromStreamNoValidation(is, MockCondition.class);
  final UUID unpaidInvoiceId = UUID.randomUUID();
  final LocalDate now = new LocalDate();
  final BillingState state0 = new BillingState(new UUID(0L, 1L), 0, BigDecimal.ZERO, null,
                         DateTimeZone.UTC, unpaidInvoiceId, PaymentResponse.INSUFFICIENT_FUNDS, new Tag[]{});
  final BillingState state1 = new BillingState(new UUID(0L, 1L), 1, new BigDecimal("100.00"), now.minusDays(10),
                         DateTimeZone.UTC, unpaidInvoiceId, PaymentResponse.INSUFFICIENT_FUNDS, new Tag[]{});
  final BillingState state2 = new BillingState(new UUID(0L, 1L), 1, new BigDecimal("200.00"), now.minusDays(20),
                         DateTimeZone.UTC, unpaidInvoiceId, PaymentResponse.INSUFFICIENT_FUNDS, new Tag[]{});
  Assert.assertTrue(!c.evaluate(state0, now));
  Assert.assertTrue(c.evaluate(state1, now));
  Assert.assertTrue(c.evaluate(state2, now));
}

@Test(groups = "fast")
public void testResponseForLastFailedPaymentIn() throws Exception {
  final String xml =
      "<condition>" +
      "	<responseForLastFailedPaymentIn><response>INSUFFICIENT_FUNDS</response><response>DO_NOT_HONOR</response></responseForLastFailedPaymentIn>" +
      "</condition>";
  final InputStream is = new ByteArrayInputStream(xml.getBytes());
  final MockCondition c = XMLLoader.getObjectFromStreamNoValidation(is, MockCondition.class);
  final UUID unpaidInvoiceId = UUID.randomUUID();
  final LocalDate now = new LocalDate();
  final BillingState state0 = new BillingState(new UUID(0L, 1L), 0, BigDecimal.ZERO, null,
                         DateTimeZone.UTC, unpaidInvoiceId, PaymentResponse.LOST_OR_STOLEN_CARD, new Tag[]{});
  final BillingState state1 = new BillingState(new UUID(0L, 1L), 1, new BigDecimal("100.00"), now.minusDays(10),
                         DateTimeZone.UTC, unpaidInvoiceId, PaymentResponse.INSUFFICIENT_FUNDS, new Tag[]{});
  final BillingState state2 = new BillingState(new UUID(0L, 1L), 1, new BigDecimal("200.00"), now.minusDays(20),
                         DateTimeZone.UTC, unpaidInvoiceId, PaymentResponse.DO_NOT_HONOR, new Tag[]{});
  Assert.assertTrue(!c.evaluate(state0, now));
  Assert.assertTrue(c.evaluate(state1, now));
  Assert.assertTrue(c.evaluate(state2, now));
}

public BillingState calculateBillingState(final Account account, final InternalTenantContext context) throws OverdueException {
  final SortedSet<Invoice> unpaidInvoices = unpaidInvoicesForAccount(account.getId(), account.getTimeZone(), context);
  final int numberOfUnpaidInvoices = unpaidInvoices.size();
  final BigDecimal unpaidInvoiceBalance = sumBalance(unpaidInvoices);
  LocalDate dateOfEarliestUnpaidInvoice = null;
  UUID idOfEarliestUnpaidInvoice = null;
  final Invoice invoice = earliest(unpaidInvoices);
  if (invoice != null) {
    dateOfEarliestUnpaidInvoice = invoice.getInvoiceDate();
    idOfEarliestUnpaidInvoice = invoice.getId();
  }
  final PaymentResponse responseForLastFailedPayment = PaymentResponse.INSUFFICIENT_FUNDS; //TODO MDW
  final Tag[] tags = new Tag[]{}; //TODO MDW
  return new BillingState(account.getId(), numberOfUnpaidInvoices, unpaidInvoiceBalance, dateOfEarliestUnpaidInvoice, account.getTimeZone(), idOfEarliestUnpaidInvoice, responseForLastFailedPayment, tags);
}

final BillingState state0 = new BillingState(objectId, 0, BigDecimal.ZERO, null,
                       DateTimeZone.UTC, unpaidInvoiceId, PaymentResponse.LOST_OR_STOLEN_CARD,
                       new Tag[]{new DefaultControlTag(ControlTagType.AUTO_INVOICING_OFF, objectType, objectId, clock.getUTCNow()),
                           new DescriptiveTag(UUID.randomUUID(), objectType, objectId, clock.getUTCNow())});
final BillingState state1 = new BillingState(objectId, 1, new BigDecimal("100.00"), now.minusDays(10),
                       DateTimeZone.UTC, unpaidInvoiceId, PaymentResponse.INSUFFICIENT_FUNDS,
                       new Tag[]{new DefaultControlTag(ControlTagType.OVERDUE_ENFORCEMENT_OFF, objectType, objectId, clock.getUTCNow())});
final BillingState state2 = new BillingState(objectId, 1, new BigDecimal("200.00"), now.minusDays(20),
                       DateTimeZone.UTC, unpaidInvoiceId,
                       PaymentResponse.DO_NOT_HONOR,