Java Invoice.getInvoiceItems方法代码示例

import org.killbill.billing.invoice.api.Invoice; //导入方法依赖的package包/类
private List<CustomField> fieldsRelatedTo(Invoice... invoices) {
    ImmutableSet.Builder<UUID> knownItemIdentifiers = ImmutableSet.builder();
    for (Invoice invoice : invoices) {
        for (InvoiceItem item : invoice.getInvoiceItems()) {
            knownItemIdentifiers.add(item.getId());
        }
    }
    final Set<UUID> knownItems = knownItemIdentifiers.build();
    List<CustomField> fieldsForInvoices = newArrayList(filter(taxFields, new Predicate<CustomField>() {
        @Override
        public boolean apply(CustomField field) {
            return knownItems.contains(field.getObjectId());
        }
    }));
    return fieldsForInvoices;
}
 

import org.killbill.billing.invoice.api.Invoice; //导入方法依赖的package包/类
@Nonnull
public List<InvoiceItem> findAllInvoiceItemsByInvoice(UUID invoiceId, TenantContext tenantContext) {
    Invoice invoice;
    try {
        invoice = invoiceApi.getInvoice(invoiceId, tenantContext);
    } catch (InvoiceApiException exc) {
        logService.log(LOG_ERROR, "while accessing invoice [" + invoiceId + "] in order to list its items", exc);
        return newArrayList();
    }
    return invoice.getInvoiceItems();
}
 

import org.killbill.billing.invoice.api.Invoice; //导入方法依赖的package包/类
@Override
public Invoice build() {
    Invoice invoice = buildInvoice(account);
    List<InvoiceItem> items = invoice.getInvoiceItems();
    for (InvoiceItemBuilder itemBuilder : itemsBuilders) {
        itemBuilder.withInvoice(invoice);
        items.add(itemBuilder.build());
    }
    return invoice;
}
 

import org.killbill.billing.invoice.api.Invoice; //导入方法依赖的package包/类
/**
 * Creates an lists the tax codes that are missing to the new invoice being
 * created.
 *
 * @param newInvoice
 *            The new invoice that is being created.
 * @param resolver
 *            The tax resolver to use.
 * @param taxCtx
 *            The context data to use when computing taxes.
 * @param callCtx
 *            The context in which this code is running.
 * @return A new immutable map of the tax codes to add, mapped from their
 *         related invoice item identifier. Never {@code null}, and
 *         guaranteed not having any {@code null} elements.
 */
private Map<UUID, TaxCode> addMissingTaxCodes(Invoice newInvoice, TaxResolver resolver,
        final TaxComputationContext taxCtx, CallContext callCtx) {
    // Obtain tax codes from products of invoice items
    TaxCodeService taxCodesService = taxCtx.getTaxCodeService();
    SetMultimap<UUID, TaxCode> configuredTaxCodesForInvoiceItems = taxCodesService
            .resolveTaxCodesFromConfig(newInvoice);

    SetMultimap<UUID, TaxCode> existingTaxCodesForInvoiceItems = taxCodesService.findExistingTaxCodes(newInvoice);

    ImmutableMap.Builder<UUID, TaxCode> newTaxCodes = ImmutableMap.builder();
    // Add product tax codes to custom field if null or empty
    for (InvoiceItem item : newInvoice.getInvoiceItems()) {
        if (!isTaxableItem(item)) {
            continue;
        }
        Set<TaxCode> expectedTaxCodes = configuredTaxCodesForInvoiceItems.get(item.getId());
        // Note: expectedTaxCodes != null as per the Multimap contract
        if (expectedTaxCodes.isEmpty()) {
            continue;
        }
        Set<TaxCode> existingTaxCodes = existingTaxCodesForInvoiceItems.get(item.getId());
        // Note: existingTaxCodes != null as per the Multimap contract
        if (!existingTaxCodes.isEmpty()) {
            // Don't override existing tax codes
            continue;
        }

        final String accountTaxCountry = taxCtx.getAccountTaxCountry() == null ? null : taxCtx
                .getAccountTaxCountry().getCode();
        Iterable<TaxCode> expectedInAccountCountry = filter(expectedTaxCodes, new Predicate<TaxCode>() {
            @Override
            public boolean apply(TaxCode taxCode) {
                Country restrict = taxCode.getCountry();
                return (restrict == null) || restrict.getCode().equals(accountTaxCountry);
            }
        });
        // resolve tax codes using regulation-specific logic
        TaxCode applicableCode = resolver.applicableCodeForItem(expectedInAccountCountry, item);
        if (applicableCode == null) {
            continue;
        }

        newTaxCodes.put(item.getId(), applicableCode);
    }
    return newTaxCodes.build();
}
 

import org.killbill.billing.invoice.api.Invoice; //导入方法依赖的package包/类
/**
 * Compute adjustment items on existing tax items in a <em>historical</em>
 * invoice.
 * <p>
 * Tax codes are allowed to change on historical invoice. They can be
 * removed, changed or added. Then taxes are adjusted or added accordingly.
 *
 * @param oldInvoice
 *            An historical invoice.
 * @param ctx
 *            The context data to use.
 * @return A new immutable list of new adjustment items to add to the
 *         invoice. Never {@code null}, and guaranteed not having any
 *         {@code null} elements.
 */
private List<InvoiceItem> computeTaxOrAdjustmentItemsForHistoricalInvoice(Invoice oldInvoice,
        TaxComputationContext ctx) {

    SetMultimap<UUID, InvoiceItem> currentTaxItems = taxItemsGroupedByRelatedTaxedItems(oldInvoice);

    SetMultimap<UUID, TaxCode> existingTaxCodes = ctx.getTaxCodeService().findExistingTaxCodes(oldInvoice);

    ImmutableList.Builder<InvoiceItem> newItems = ImmutableList.builder();
    for (InvoiceItem item : oldInvoice.getInvoiceItems()) {
        if (!isTaxableItem(item)) {
            continue;
        }

        Set<InvoiceItem> relatedTaxItems = currentTaxItems.get(item.getId());

        TaxCode tax = null;
        Set<TaxCode> taxes = existingTaxCodes.get(item.getId());
        // Note: taxes != null as per the Multimap contract
        if (!taxes.isEmpty()) {
            tax = taxes.iterator().next();
        }

        BigDecimal adjustedAmount = ctx.toAdjustedAmount().apply(item);
        BigDecimal expectedTaxAmount = computeTaxAmount(item, adjustedAmount, tax, ctx.getConfig());
        BigDecimal currentTaxAmount = sumAmounts(transform(relatedTaxItems, ctx.toAdjustedAmount()));

        if (currentTaxAmount.compareTo(expectedTaxAmount) != 0) {
            BigDecimal adjustmentAmount = expectedTaxAmount.subtract(currentTaxAmount);

            if (relatedTaxItems.isEmpty()) {
                // Here tax != null because with relatedTaxItem == null we
                // necessarily have a zero currentTaxAmount, so
                // expectedTaxAmount is not zero and necessarily results
                // from a tax code
                InvoiceItem taxItem = buildTaxItem(item, oldInvoice.getInvoiceDate(), adjustmentAmount,
                        tax.getTaxItemDescription());
                newItems.add(taxItem);
            } else {
                // here we have a tax item but the tax code might have been
                // removed, so it could be null
                InvoiceItem largestTaxItem = ctx.byAdjustedAmount().max(relatedTaxItems);
                String taxItemDescription = tax != null ? tax.getTaxItemDescription() : largestTaxItem
                        .getDescription();
                InvoiceItem adjItem = buildAdjustmentForTaxItem(largestTaxItem, oldInvoice.getInvoiceDate(),
                        adjustmentAmount, taxItemDescription);
                newItems.add(adjItem);
            }
        }
    }
    return newItems.build();
}
 

import org.killbill.billing.invoice.api.Invoice; //导入方法依赖的package包/类
/**
 * Groups the {@linkplain #isAdjustmentItem adjustment items} (found in a
 * given set of invoices) by the identifier of their
 * {@linkplain InvoiceItem#getLinkedItemId related} “adjusted” items.
 * <p>
 * The resulting collection is typically computed on all invoices of a given
 * account.
 *
 * @param allInvoices
 *            A list of invoices.
 * @return A new immutable multi-map of the adjustment items, grouped by the
 *         items they relate to. Never {@code null}, and guaranteed not
 *         having any {@code null} elements.
 */
private Multimap<UUID, InvoiceItem> allAjdustmentsGroupedByAdjustedItem(Set<Invoice> allInvoices) {
    ImmutableSetMultimap.Builder<UUID, InvoiceItem> builder = builder();
    for (Invoice invoice : allInvoices) {
        for (InvoiceItem item : invoice.getInvoiceItems()) {
            if (isAdjustmentItem(item)) {
                builder.put(item.getLinkedItemId(), item);
            }
        }
    }
    return builder.build();
}
 

import org.killbill.billing.invoice.api.Invoice; //导入方法依赖的package包/类
/**
 * Groups the {@linkplain #isTaxItem tax items} (found in a given invoice)
 * by the identifier of their {@linkplain InvoiceItem#getLinkedItemId
 * related} “taxable” items.
 *
 * @param invoice
 *            An invoice.
 * @return An immutable multi-map of the tax items for the given invoice,
 *         grouped by the identifier of their related (taxed) item. Never
 *         {@code null}, and guaranteed not having any {@code null}
 *         elements.
 */
private SetMultimap<UUID, InvoiceItem> taxItemsGroupedByRelatedTaxedItems(Invoice invoice) {
    ImmutableSetMultimap.Builder<UUID, InvoiceItem> currentTaxItemsBuilder = builder();
    for (InvoiceItem item : invoice.getInvoiceItems()) {
        if (isTaxItem(item)) {
            currentTaxItemsBuilder.put(item.getLinkedItemId(), item);
        }
    }
    return currentTaxItemsBuilder.build();
}