How to use

OverdueException

in

com.ning.billing.overdue.config.api

@SuppressWarnings("unchecked")
public OverdueWrapper createOverdueWrapperFor(final UUID id, final InternalTenantContext context) throws OverdueException {
  try {
    Account account = accountApi.getAccountById(id, context);
    return new OverdueWrapper(account, api, getOverdueStateSet(),
                 clock, billingStateCalculator, overdueStateApplicator);
  } catch (AccountApiException e) {
    throw new OverdueException(e);
  }
}

@SuppressWarnings("unchecked")
@Override
public OverdueState getOverdueStateFor(final Account overdueable, final TenantContext context) throws OverdueException {
  try {
    final String stateName = accessApi.getBlockingStateForService(overdueable.getId(), BlockingStateType.ACCOUNT, OverdueService.OVERDUE_SERVICE_NAME, internalCallContextFactory.createInternalTenantContext(context)).getStateName();
    final OverdueStateSet states = overdueConfig.getStateSet();
    return states.findState(stateName);
  } catch (OverdueApiException e) {
    throw new OverdueException(e, ErrorCode.OVERDUE_CAT_ERROR_ENCOUNTERED, overdueable.getId(), overdueable.getClass().getSimpleName());
  }
}

  private boolean isAccountTaggedWith_OVERDUE_ENFORCEMENT_OFF(final InternalCallContext context) throws OverdueException {

    try {
      final UUID accountId = accountApi.getByRecordId(context.getAccountRecordId(), context);

      final List<Tag> accountTags = tagApi.getTags(accountId, ObjectType.ACCOUNT, context);
      for (Tag cur : accountTags) {
        if (cur.getTagDefinitionId().equals(ControlTagType.OVERDUE_ENFORCEMENT_OFF.getId())) {
          return true;
        }
      }
      return false;
    } catch (AccountApiException e) {
      throw new OverdueException(e);
    }
  }
}

protected void storeNewState(final Account blockable, final OverdueState nextOverdueState, final InternalCallContext context) throws OverdueException {
  try {
    blockingApi.setBlockingState(new DefaultBlockingState(blockable.getId(),
                               BlockingStateType.ACCOUNT,
                               nextOverdueState.getName(),
                               OverdueService.OVERDUE_SERVICE_NAME,
                               blockChanges(nextOverdueState),
                               blockEntitlement(nextOverdueState),
                               blockBilling(nextOverdueState),
                               clock.getUTCNow()),
                   context);
  } catch (Exception e) {
    throw new OverdueException(e, ErrorCode.OVERDUE_CAT_ERROR_ENCOUNTERED, blockable.getId(), blockable.getClass().getName());
  }
}

      throw new OverdueException(e);
throw new OverdueException(e);

public void clear(final Account account, final OverdueState previousOverdueState, final OverdueState clearState, final InternalCallContext context) throws OverdueException {
  log.debug("OverdueStateApplicator:clear : time = " + clock.getUTCNow() + ", previousState = " + previousOverdueState.getName());
  storeNewState(account, clearState, context);
  clearFutureNotification(account, context);
  try {
    avoid_extra_credit_by_toggling_AUTO_INVOICE_OFF(account, previousOverdueState, clearState, context);
  } catch (OverdueApiException e) {
    throw new OverdueException(e);
  }
  try {
    bus.post(createOverdueEvent(account, previousOverdueState.getName(), clearState.getName(), isBlockBillingTransition(previousOverdueState, clearState),
                  isUnblockBillingTransition(previousOverdueState, clearState), context));
  } catch (Exception e) {
    log.error("Error posting overdue change event to bus", e);
  }
}

throw new OverdueException(e);