Examples with BillingEvent org.killbill.billing.junction.BillingEvent used on opensource projects

Example 1 with BillingEvent

use of org.killbill.billing.junction.BillingEvent in project killbill by killbill.

the class TestDefaultInvoiceGenerator method testAutoInvoiceOffAccount.

@Test(groups = "fast")
public void testAutoInvoiceOffAccount() throws Exception {
    final MockBillingEventSet events = new MockBillingEventSet();
    events.setAccountInvoiceOff(true);
    final SubscriptionBase sub = createSubscription();
    final LocalDate startDate = invoiceUtil.buildDate(2011, 9, 1);
    final Plan plan = new MockPlan();
    final BigDecimal rate1 = TEN;
    final PlanPhase phase = createMockMonthlyPlanPhase(rate1);
    final BillingEvent event = createBillingEvent(sub.getId(), sub.getBundleId(), startDate, plan, phase, 1);
    events.add(event);
    final LocalDate targetDate = invoiceUtil.buildDate(2011, 10, 3);
    final UUID accountId = UUID.randomUUID();
    final InvoiceWithMetadata invoiceWithMetadata = generator.generateInvoice(account, events, null, targetDate, Currency.USD, internalCallContext);
    assertNull(invoiceWithMetadata.getInvoice());
}

Example 2 with BillingEvent

use of org.killbill.billing.junction.BillingEvent in project killbill by killbill.

the class FixedAndRecurringInvoiceItemGenerator method processRecurringBillingEvents.

private void processRecurringBillingEvents(final UUID invoiceId, final UUID accountId, final BillingEventSet events, final LocalDate targetDate, final Currency currency, final List<InvoiceItem> proposedItems, final Map<UUID, SubscriptionFutureNotificationDates> perSubscriptionFutureNotificationDate, @Nullable final List<Invoice> existingInvoices, final InternalCallContext internalCallContext) throws InvoiceApiException {
    if (events.isEmpty()) {
        return;
    }
    // Pretty-print the generated invoice items from the junction events
    final InvoiceItemGeneratorLogger invoiceItemGeneratorLogger = new InvoiceItemGeneratorLogger(invoiceId, accountId, "recurring", log);
    final Iterator<BillingEvent> eventIt = events.iterator();
    BillingEvent nextEvent = eventIt.next();
    while (eventIt.hasNext()) {
        final BillingEvent thisEvent = nextEvent;
        nextEvent = eventIt.next();
        if (!events.getSubscriptionIdsWithAutoInvoiceOff().contains(thisEvent.getSubscription().getId())) {
            // don't consider events for subscriptions that have auto_invoice_off
            final BillingEvent adjustedNextEvent = (thisEvent.getSubscription().getId() == nextEvent.getSubscription().getId()) ? nextEvent : null;
            final List<InvoiceItem> newProposedItems = processRecurringEvent(invoiceId, accountId, thisEvent, adjustedNextEvent, targetDate, currency, invoiceItemGeneratorLogger, events.getRecurringBillingMode(), perSubscriptionFutureNotificationDate, internalCallContext);
            proposedItems.addAll(newProposedItems);
        }
    }
    final List<InvoiceItem> newProposedItems = processRecurringEvent(invoiceId, accountId, nextEvent, null, targetDate, currency, invoiceItemGeneratorLogger, events.getRecurringBillingMode(), perSubscriptionFutureNotificationDate, internalCallContext);
    proposedItems.addAll(newProposedItems);
    invoiceItemGeneratorLogger.logItems();
}

Example 3 with BillingEvent

use of org.killbill.billing.junction.BillingEvent in project killbill by killbill.

the class SubscriptionUsageInArrear method computeInArrearUsageInterval.

@VisibleForTesting
List<ContiguousIntervalUsageInArrear> computeInArrearUsageInterval() {
    final List<ContiguousIntervalUsageInArrear> usageIntervals = Lists.newLinkedList();
    final Map<String, ContiguousIntervalUsageInArrear> inFlightInArrearUsageIntervals = new HashMap<String, ContiguousIntervalUsageInArrear>();
    final Set<String> allSeenUsage = new HashSet<String>();
    for (final BillingEvent event : subscriptionBillingEvents) {
        // Extract all in arrear /consumable usage section for that billing event.
        final List<Usage> usages = findUsageInArrearUsages(event);
        allSeenUsage.addAll(Collections2.transform(usages, new Function<Usage, String>() {

            @Override
            public String apply(final Usage input) {
                return input.getName();
            }
        }));
        // All inflight usage interval are candidates to be closed unless we see that current billing event referencing the same usage section.
        final Set<String> toBeClosed = new HashSet<String>(allSeenUsage);
        for (final Usage usage : usages) {
            // Add inflight usage interval if non existent
            ContiguousIntervalUsageInArrear existingInterval = inFlightInArrearUsageIntervals.get(usage.getName());
            if (existingInterval == null) {
                existingInterval = new ContiguousIntervalUsageInArrear(usage, accountId, invoiceId, rawSubscriptionUsage, targetDate, rawUsageStartDate, internalTenantContext);
                inFlightInArrearUsageIntervals.put(usage.getName(), existingInterval);
            }
            // Add billing event for that usage interval
            existingInterval.addBillingEvent(event);
            // Remove usage interval for toBeClosed set
            toBeClosed.remove(usage.getName());
        }
        // Build the usage interval that are no longer referenced
        for (final String usageName : toBeClosed) {
            final ContiguousIntervalUsageInArrear interval = inFlightInArrearUsageIntervals.remove(usageName);
            if (interval != null) {
                interval.addBillingEvent(event);
                usageIntervals.add(interval.build(true));
            }
        }
    }
    for (final String usageName : inFlightInArrearUsageIntervals.keySet()) {
        usageIntervals.add(inFlightInArrearUsageIntervals.get(usageName).build(false));
    }
    inFlightInArrearUsageIntervals.clear();
    return usageIntervals;
}

Example 4 with BillingEvent

use of org.killbill.billing.junction.BillingEvent in project killbill by killbill.

the class BlockingCalculator method precedingBillingEventForSubscription.

protected BillingEvent precedingBillingEventForSubscription(final DateTime datetime, final SortedSet<BillingEvent> billingEvents, final SubscriptionBase subscription) {
    if (datetime == null) {
        //second of a pair can be null if there's no re-enabling
        return null;
    }
    final SortedSet<BillingEvent> filteredBillingEvents = filter(billingEvents, subscription);
    BillingEvent result = filteredBillingEvents.first();
    if (datetime.isBefore(result.getEffectiveDate())) {
        //This case can happen, for example, if we have an add on and the bundle goes into disabled before the add on is created
        return null;
    }
    for (final BillingEvent event : filteredBillingEvents) {
        if (!event.getEffectiveDate().isBefore(datetime)) {
            // found it its the previous event
            return result;
        } else {
            // still looking
            result = event;
        }
    }
    return result;
}

Example 5 with BillingEvent

use of org.killbill.billing.junction.BillingEvent in project killbill by killbill.

the class DefaultInternalBillingApi method addBillingEventsForSubscription.

private void addBillingEventsForSubscription(final ImmutableAccountData account, final List<SubscriptionBase> subscriptions, final SubscriptionBase baseSubscription, final boolean dryRunMode, final InternalCallContext context, final DefaultBillingEventSet result, final Set<UUID> skipSubscriptionsSet) throws AccountApiException, CatalogApiException, SubscriptionBaseApiException {
    // If dryRun is specified, we don't want to to update the account BCD value, so we initialize the flag updatedAccountBCD to true
    boolean updatedAccountBCD = dryRunMode;
    final Map<UUID, Integer> bcdCache = new HashMap<UUID, Integer>();
    int currentAccountBCD = accountApi.getBCD(account.getId(), context);
    for (final SubscriptionBase subscription : subscriptions) {
        // The subscription did not even start, so there is nothing to do yet, we can skip and avoid some NPE down the line when calculating the BCD
        if (subscription.getState() == EntitlementState.PENDING) {
            log.info("Skipping subscription id='{}', state = EntitlementState.PENDING", subscription.getId());
            continue;
        }
        final List<EffectiveSubscriptionInternalEvent> billingTransitions = subscriptionApi.getBillingTransitions(subscription, context);
        if (billingTransitions.isEmpty() || (billingTransitions.get(0).getTransitionType() != SubscriptionBaseTransitionType.CREATE && billingTransitions.get(0).getTransitionType() != SubscriptionBaseTransitionType.TRANSFER)) {
            log.warn("Skipping billing events for subscription " + subscription.getId() + ": Does not start with a valid CREATE transition");
            skipSubscriptionsSet.add(subscription.getId());
            return;
        }
        final Catalog catalog = catalogService.getFullCatalog(true, true, context);
        Integer overridenBCD = null;
        for (final EffectiveSubscriptionInternalEvent transition : billingTransitions) {
            //
            // A BCD_CHANGE transition defines a new billCycleDayLocal for the subscription and this overrides whatever computation
            // occurs below (which is based on billing alignment policy). Also multiple of those BCD_CHANGE transitions could occur,
            // to define different intervals with different billing cycle days.
            //
            overridenBCD = transition.getNextBillCycleDayLocal() != null ? transition.getNextBillCycleDayLocal() : overridenBCD;
            final int bcdLocal = overridenBCD != null ? overridenBCD : calculateBcdForTransition(catalog, bcdCache, baseSubscription, subscription, account, currentAccountBCD, transition);
            if (currentAccountBCD == 0 && !updatedAccountBCD) {
                log.info("Setting account BCD='{}', accountId='{}'", bcdLocal, account.getId());
                accountApi.updateBCD(account.getExternalKey(), bcdLocal, context);
                updatedAccountBCD = true;
            }
            final BillingEvent event = new DefaultBillingEvent(account, transition, subscription, bcdLocal, account.getCurrency(), catalog);
            result.add(event);
        }
    }
}