A list reference on which the generated bill(s) will be returned.
+=item estimate
+
+Boolean value; indicates that this is an estimate rather than a "tax invoice".
+This will be passed through to the tax engine, as online tax services
+sometimes need to know it for reporting purposes. Otherwise it has no effect.
+
=item invoice_terms
Optional terms to be printed on this invoice. Otherwise, customer-specific
foreach (@passes) {
$tax_engines{$_} = FS::TaxEngine->new(cust_main => $self,
invoice_time => $invoice_time,
- cancel => $options{cancel}
+ cancel => $options{cancel},
+ estimate => $options{estimate},
);
$tax_is_batch ||= $tax_engines{$_}->info->{batch};
}
$tax_engines{$pass} = FS::TaxEngine->new(
cust_main => $self,
invoice_time => $invoice_time,
- cancel => $options{cancel}
+ cancel => $options{cancel},
+ estimate => $options{estimate},
);
$cust_bill_pkg{$pass} = [];
}
# calculate and append taxes
if ( ! $tax_is_batch) {
- my $arrayref_or_error = $tax_engines{$pass}->calculate_taxes($cust_bill);
+ local $@;
+ my $arrayref = eval { $tax_engines{$pass}->calculate_taxes($cust_bill) };
- unless ( ref( $arrayref_or_error ) ) {
+ if ( $@ ) {
$dbh->rollback if $oldAutoCommit && !$options{no_commit};
- return $arrayref_or_error;
+ return $@;
}
# or should this be in TaxEngine?
my $total_tax = 0;
- foreach my $taxline ( @$arrayref_or_error ) {
+ foreach my $taxline ( @$arrayref ) {
$total_tax += $taxline->setup;
$taxline->set('invnum' => $cust_bill->invnum); # just to be sure
push @cust_bill_pkg, $taxline; # for return_bill
}
#discard bundled packages of 0 value
+# XXX we should reconsider whether we even need this
sub _omit_zero_value_bundles {
my @in = @_;
- my @cust_bill_pkg = ();
- my @cust_bill_pkg_bundle = ();
- my $sum = 0;
- my $discount_show_always = 0;
-
+ my @out = ();
+ my @bundle = ();
+ my $discount_show_always = $conf->exists('discount-show-always');
+ my $show_this = 0;
+
+ # Sort @in the same way we do during invoice rendering, so we can identify
+ # bundles. See FS::Template_Mixin::_items_nontax.
+ @in = sort { $a->pkgnum <=> $b->pkgnum or
+ $a->sdate <=> $b->sdate or
+ ($a->pkgpart_override ? 0 : -1) or
+ ($b->pkgpart_override ? 0 : 1) or
+ $b->hidden cmp $a->hidden or
+ $a->pkgpart_override <=> $b->pkgpart_override
+ } @in;
+
+ # this is a pack-and-deliver pattern. every time there's a cust_bill_pkg
+ # _without_ pkgpart_override, that's the start of the new bundle. if there's
+ # an existing bundle, and it contains a nonzero amount (or a zero amount
+ # that's displayable anyway), push all line items in the bundle.
foreach my $cust_bill_pkg ( @in ) {
- $discount_show_always = ($cust_bill_pkg->get('discounts')
- && scalar(@{$cust_bill_pkg->get('discounts')})
- && $conf->exists('discount-show-always'));
-
- warn " pkgnum ". $cust_bill_pkg->pkgnum. " sum $sum, ".
- "setup_show_zero ". $cust_bill_pkg->setup_show_zero.
- "recur_show_zero ". $cust_bill_pkg->recur_show_zero. "\n"
- if $DEBUG > 0;
-
- if (scalar(@cust_bill_pkg_bundle) && !$cust_bill_pkg->pkgpart_override) {
- push @cust_bill_pkg, @cust_bill_pkg_bundle
- if $sum > 0
- || ($sum == 0 && ( $discount_show_always
- || grep {$_->recur_show_zero || $_->setup_show_zero}
- @cust_bill_pkg_bundle
- )
- );
- @cust_bill_pkg_bundle = ();
- $sum = 0;
+ if (scalar(@bundle) and !$cust_bill_pkg->pkgpart_override) {
+ # ship out this bundle and reset it
+ if ( $show_this ) {
+ push @out, @bundle;
+ }
+ @bundle = ();
+ $show_this = 0;
}
- $sum += $cust_bill_pkg->setup + $cust_bill_pkg->recur;
- push @cust_bill_pkg_bundle, $cust_bill_pkg;
+ # add this item to the current bundle
+ push @bundle, $cust_bill_pkg;
+ # determine if it makes the bundle displayable
+ if ( $cust_bill_pkg->setup > 0
+ or $cust_bill_pkg->recur > 0
+ or $cust_bill_pkg->setup_show_zero
+ or $cust_bill_pkg->recur_show_zero
+ or ($discount_show_always
+ and scalar(@{ $cust_bill_pkg->get('discounts')})
+ )
+ ) {
+ $show_this++;
+ }
}
- push @cust_bill_pkg, @cust_bill_pkg_bundle
- if $sum > 0
- || ($sum == 0 && ( $discount_show_always
- || grep {$_->recur_show_zero || $_->setup_show_zero}
- @cust_bill_pkg_bundle
- )
- );
+ # last bundle
+ if ( $show_this) {
+ push @out, @bundle;
+ }
warn " _omit_zero_value_bundles: ". scalar(@in).
- '->'. scalar(@cust_bill_pkg). "\n" #. Dumper(@cust_bill_pkg). "\n"
+ '->'. scalar(@out). "\n" #. Dumper(@out). "\n"
if $DEBUG > 2;
- (@cust_bill_pkg);
-
+ @out;
}
sub _make_lines {
# - it doesn't already HAVE a setup date
# - or a start date in the future
# - and it's not suspended
+ # - and it doesn't have an expire date in the past
#
- # The last condition used to check the "disable_setup_suspended" option but
- # that's obsolete. We now never set the setup date on a suspended package.
+ # The "disable_setup_suspended" option is now obsolete; we never set the
+ # setup date on a suspended package.
if ( ! $options{recurring_only}
and ! $options{cancel}
and ( $options{'resetup'}
&& ( ! $cust_pkg->getfield('susp') )
)
)
+ and ( ! $cust_pkg->expire
+ || $cust_pkg->expire > $cmp_time )
)
{
return "$@ running calc_setup for $cust_pkg\n"
if $@;
- $unitsetup = $cust_pkg->base_setup()
- || $setup; #XXX uuh
+ # Only increment unitsetup here if there IS a setup fee.
+ # prorate_defer_bill may cause calc_setup on a setup-stage package
+ # to return zero, and the setup fee to be charged later. (This happens
+ # when it's first billed on the prorate cutoff day. RT#31276.)
+ if ( $setup ) {
+ $unitsetup = $cust_pkg->base_setup()
+ || $setup; #XXX uuh
+ }
if ( $setup_param{'billed_currency'} ) {
$setup_billed_currency = delete $setup_param{'billed_currency'};
}
}
- $cust_pkg->setfield('setup', $time)
- unless $cust_pkg->setup;
- #do need it, but it won't get written to the db
- #|| $cust_pkg->pkgpart != $real_pkgpart;
+ if ( $cust_pkg->get('setup') ) {
+ # don't change it
+ } elsif ( $cust_pkg->get('start_date') ) {
+ # this allows start_date to be used to set the first bill date
+ $cust_pkg->set('setup', $cust_pkg->get('start_date'));
+ } else {
+ # if unspecified, start it right now
+ $cust_pkg->set('setup', $time);
+ }
$cust_pkg->setfield('start_date', '')
if $cust_pkg->start_date;
my $recur_billed_currency = '';
my $recur_billed_amount = 0;
my $sdate;
+ # Conditions for billing the recurring fee:
+ # - the package doesn't have a future start date
+ # - and it's not suspended
+ # - unless suspend_bill is enabled on the package or package def
+ # - but still not, if the package is on hold
+ # - or it's suspended for a delayed cancellation
+ # - and its next bill date is in the past
+ # - or it doesn't have a next bill date yet
+ # - or it's a one-time charge
+ # - or it's a CDR plan with the "bill_every_call" option
+ # - or it's being canceled
+ # - and it doesn't have an expire date in the past (this can happen with
+ # advance billing)
+ # - again, unless it's being canceled
if ( ! $cust_pkg->start_date
and
( ! $cust_pkg->susp
&& $part_pkg->option('bill_every_call')
)
|| $options{cancel}
+
+ and
+ ( ! $cust_pkg->expire
+ || $cust_pkg->expire > $cmp_time
+ || $options{cancel}
+ )
) {
# XXX should this be a package event? probably. events are called
return "$@ running $method for $cust_pkg\n"
if ( $@ );
+ if ($recur eq 'NOTHING') {
+ # then calc_cancel (or calc_recur but that's not used) has declined to
+ # generate a recurring lineitem at all. treat this as zero, but also
+ # try not to generate a lineitem.
+ $recur = 0;
+ $lineitems--;
+ }
+
#base_cancel???
$unitrecur = $cust_pkg->base_recur( \$sdate ) || $recur; #XXX uuh, better
# its frequency
my $main_pkg_freq = $main_pkg->part_pkg->freq;
my $supp_pkg_freq = $part_pkg->freq;
- my $ratio = $supp_pkg_freq / $main_pkg_freq;
- if ( $ratio != int($ratio) ) {
+ if ( $supp_pkg_freq == 0 or $main_pkg_freq == 0 ) {
# the UI should prevent setting up packages like this, but just
# in case
- return "supplemental package period is not an integer multiple of main package period";
+ return "unable to calculate supplemental package period ratio";
}
- $next_bill = $sdate;
- for (1..$ratio) {
- $next_bill = $part_pkg->add_freq( $next_bill, $main_pkg_freq );
+ my $ratio = $supp_pkg_freq / $main_pkg_freq;
+ if ( $ratio == int($ratio) ) {
+ # simple case: main package is X months, supp package is X*A months,
+ # advance supp package to where the main package will be in A cycles.
+ $next_bill = $sdate;
+ for (1..$ratio) {
+ $next_bill = $part_pkg->add_freq( $next_bill, $main_pkg_freq );
+ }
+ } else {
+ # harder case: main package is X months, supp package is Y months.
+ # advance supp package by Y months. then if they're within half a
+ # month of each other, resync them. this may result in the period
+ # not being exactly Y months.
+ $next_bill = $part_pkg->add_freq( $sdate, $supp_pkg_freq );
+ my $main_next_bill = $main_pkg->bill;
+ if ( $main_pkg->bill <= $time ) {
+ # then the main package has not yet been billed on this cycle;
+ # predict what its bill date will be.
+ $main_next_bill =
+ $part_pkg->add_freq( $main_next_bill, $main_pkg_freq );
+ }
+ if ( abs($main_next_bill - $next_bill) < 86400*15 ) {
+ $next_bill = $main_next_bill;
+ }
}
} else {
- # the normal case
+ # the normal case, not a supplemental package
$next_bill = $part_pkg->add_freq($sdate, $options{freq_override} || 0);
- return "unparsable frequency: ". $part_pkg->freq
+ return "unparsable frequency: ".
+ ($options{freq_override} || $part_pkg->freq)
if $next_bill == -1;
}
# Add an additional setup fee at the billing stage.
# Used for prorate_defer_bill.
$setup += $param{'setup_fee'};
- $unitsetup += $param{'setup_fee'};
+ $unitsetup = $cust_pkg->base_setup();
$lineitems++;
}
my $cust_bill_pkg = new FS::cust_bill_pkg {
'pkgnum' => $cust_pkg->pkgnum,
'setup' => $setup,
- 'unitsetup' => $unitsetup,
+ 'unitsetup' => sprintf('%.2f', $unitsetup),
'setup_billed_currency' => $setup_billed_currency,
'setup_billed_amount' => $setup_billed_amount,
'recur' => $recur,
- 'unitrecur' => $unitrecur,
+ 'unitrecur' => sprintf('%.2f', $unitrecur),
'recur_billed_currency' => $recur_billed_currency,
'recur_billed_amount' => $recur_billed_amount,
'quantity' => $cust_pkg->quantity,
return if ( $self->payby eq 'COMP' ); #dubious
- if ( $conf->exists('enable_taxproducts')
+ if ( $conf->config('enable_taxproducts')
&& ( scalar($part_item->part_pkg_taxoverride)
|| $part_item->has_taxproduct
)
=item apply_payments_and_credits [ OPTION => VALUE ... ]
Applies unapplied payments and credits.
+Payments with the no_auto_apply flag set will not be applied.
In most cases, this new method should be used in place of sequential
apply_payments and apply_credits methods.
Applies (see L<FS::cust_bill_pay>) unapplied payments (see L<FS::cust_pay>)
to outstanding invoice balances in chronological order.
+Payments with the no_auto_apply flag set will not be applied.
#and returns the value of any remaining unapplied payments.
#return 0 unless
- my @payments = $self->unapplied_cust_pay;
+ my @payments = grep { !$_->no_auto_apply } $self->unapplied_cust_pay;
my @invoices = $self->open_cust_bill;