@Override public String getDescription() { final String entitlement = onOff(isBlockEntitlement()); final String billing = onOff(isBlockBilling()); final String change = onOff(isBlockChange()); return String.format("(Change: %s, Entitlement: %s, Billing: %s)", change, entitlement, billing); }
@Override public BlockingState getBlockingStateForService(final UUID blockableId, final BlockingStateType blockingStateType, final String serviceName, final InternalTenantContext context) { if (blockingState != null && blockingState.getBlockedId().equals(blockableId)) { return blockingState; } else { return new DefaultBlockingState(null, blockingStateType, OverdueWrapper.CLEAR_STATE_NAME, serviceName, false, false, false, null); } }
@Override public int compareTo(final BlockingState arg0) { // effective_date column NOT NULL final int comparison = effectiveDate.compareTo(arg0.getEffectiveDate()); if (comparison == 0) { // Keep a stable ordering for ties final int comparison2 = createdDate.compareTo(arg0.getCreatedDate()); if (comparison2 == 0 && arg0 instanceof DefaultBlockingState) { final DefaultBlockingState other = (DefaultBlockingState) arg0; // New element is last if (totalOrdering == null) { return 1; } else if (other.getTotalOrdering() == null) { return -1; } else { return totalOrdering.compareTo(other.getTotalOrdering()); } } else { return comparison2; } } else { return comparison; } }
protected void storeNewState(final DateTime effectiveDate, final ImmutableAccountData 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), effectiveDate), context); } catch (final Exception e) { throw new OverdueException(e, ErrorCode.OVERDUE_CAT_ERROR_ENCOUNTERED, blockable.getId(), blockable.getClass().getName()); } }
private void clearWithLock(final DateTime effectiveDate, final InternalCallContext context) throws OverdueException, OverdueApiException { final BlockingState blockingStateForService = api.getBlockingStateForService(overdueable.getId(), BlockingStateType.ACCOUNT, OverdueService.OVERDUE_SERVICE_NAME, context); final String previousOverdueStateName = blockingStateForService != null ? blockingStateForService.getStateName() : OverdueWrapper.CLEAR_STATE_NAME; final OverdueState previousOverdueState = overdueStateSet.findState(previousOverdueStateName); overdueStateApplicator.clear(effectiveDate, overdueable, previousOverdueState, overdueStateSet.getClearState(), context); }
@Override public UUID apply(final BillingEvent input) { return input.getSubscription().getId(); } });
protected BillingEvent precedingBillingEventForSubscription(final DateTime disabledDurationStart, final SortedSet<BillingEvent> subscriptionBillingEvents) { if (disabledDurationStart == null) { return null; } // We look for the first billingEvent strictly prior our disabledDurationStart or null if none BillingEvent prev = null; for (final BillingEvent event : subscriptionBillingEvents) { if (!event.getEffectiveDate().isBefore(disabledDurationStart)) { return prev; } else { prev = event; } } return prev; }
@Override public List<Usage> apply(final BillingEvent input) { return input.getUsages(); } }));
public Currency getCurrency() { return billingEvents.get(0).getCurrency(); }
@Override public UsageKey apply(final Usage input) { return new UsageKey(input.getName(), event.getCatalogEffectiveDate()); } }));
@Override public OverdueState getOverdueStateFor(final UUID accountId, final TenantContext tenantContext) throws OverdueApiException { final InternalTenantContext internalTenantContext = internalCallContextFactory.createInternalTenantContext(accountId, tenantContext); final BlockingState blockingStateForService = blockingInternalApi.getBlockingStateForService(accountId, BlockingStateType.ACCOUNT, OverdueService.OVERDUE_SERVICE_NAME, internalTenantContext); final String stateName = blockingStateForService != null ? blockingStateForService.getStateName() : OverdueWrapper.CLEAR_STATE_NAME; final OverdueConfig overdueConfig = overdueConfigCache.getOverdueConfig(internalTenantContext); final OverdueStateSet states = ((DefaultOverdueConfig) overdueConfig).getOverdueStatesAccount(); return states.findState(stateName); }
@Override public boolean apply(final BillingEvent input) { return input.getSubscription().getBundleId().equals(dryRunArguments.getBundleId()); } }), new Function<BillingEvent, UUID>() {
private LocalDate getMinBillingEventDate(final BillingEventSet eventSet, final InternalCallContext internalCallContext) { DateTime minDate = null; for (final BillingEvent cur : eventSet) { if (minDate == null || minDate.compareTo(cur.getEffectiveDate()) > 0) { minDate = cur.getEffectiveDate(); } } return internalCallContext.toLocalDate(minDate); }
@Override public String getDescription() { final String entitlement = onOff(isBlockEntitlement()); final String billing = onOff(isBlockBilling()); final String change = onOff(isBlockChange()); return String.format("(Change: %s, Entitlement: %s, Billing: %s)", change, entitlement, billing); }
private OverdueState refreshWithLock(final DateTime effectiveDate, final InternalCallContext context) throws OverdueException, OverdueApiException { final BillingState billingState = billingState(context); final BlockingState blockingStateForService = api.getBlockingStateForService(overdueable.getId(), BlockingStateType.ACCOUNT, OverdueService.OVERDUE_SERVICE_NAME, context); final String previousOverdueStateName = blockingStateForService != null ? blockingStateForService.getStateName() : OverdueWrapper.CLEAR_STATE_NAME; final OverdueState currentOverdueState = overdueStateSet.findState(previousOverdueStateName); final OverdueState nextOverdueState = overdueStateSet.calculateOverdueState(billingState, context.toLocalDate(context.getCreatedDate())); overdueStateApplicator.apply(effectiveDate, overdueStateSet, billingState, overdueable, currentOverdueState, nextOverdueState, context); return nextOverdueState; }
@Override public UUID apply(final BillingEvent billingEvent) { return billingEvent.getSubscription().getId(); } }));
protected ContiguousIntervalCapacityUsageInArrear createContiguousIntervalCapacityInArrear(final DefaultUsage usage, final List<RawUsage> rawUsages, final LocalDate targetDate, final boolean closedInterval, UsageDetailMode detailMode, final BillingEvent... events) { final ContiguousIntervalCapacityUsageInArrear intervalCapacityInArrear = new ContiguousIntervalCapacityUsageInArrear(usage, accountId, invoiceId, rawUsages, EMPTY_EXISTING_TRACKING_IDS, targetDate, new LocalDate(events[0].getEffectiveDate()), detailMode, internalCallContext); for (final BillingEvent event : events) { intervalCapacityInArrear.addBillingEvent(event); } intervalCapacityInArrear.build(closedInterval); return intervalCapacityInArrear; }
@Override public Boolean call() throws Exception { final BlockingState blockingStateForService = blockingApi.getBlockingStateForService(accountId, BlockingStateType.ACCOUNT, OverdueService.OVERDUE_SERVICE_NAME, internalCallContext); final String stateName = blockingStateForService != null ? blockingStateForService.getStateName() : OverdueWrapper.CLEAR_STATE_NAME; return expected.equals(stateName); } });
public UUID getBundleId() { return billingEvents.get(0).getSubscription().getBundleId(); }
protected ContiguousIntervalConsumableUsageInArrear createContiguousIntervalConsumableInArrear(final DefaultUsage usage, final List<RawUsage> rawUsages, final LocalDate targetDate, final boolean closedInterval, UsageDetailMode detailMode, final BillingEvent... events) { final ContiguousIntervalConsumableUsageInArrear intervalConsumableInArrear = new ContiguousIntervalConsumableUsageInArrear(usage, accountId, invoiceId, rawUsages, EMPTY_EXISTING_TRACKING_IDS, targetDate, new LocalDate(events[0].getEffectiveDate()), detailMode, internalCallContext); for (final BillingEvent event : events) { intervalConsumableInArrear.addBillingEvent(event); } intervalConsumableInArrear.build(closedInterval); return intervalConsumableInArrear; }