use FS::part_event;
use FS::part_event_condition;
use FS::pkg_category;
-use FS::cust_event_fee;
+use FS::FeeOrigin_Mixin;
use FS::Log;
# 1 is mostly method/subroutine entry and options
# process fees
###
- my @pending_event_fees = FS::cust_event_fee->by_cust($self->custnum,
+ my @pending_fees = FS::FeeOrigin_Mixin->by_cust($self->custnum,
hashref => { 'billpkgnum' => '' }
);
- warn "$me found pending fee events:\n".Dumper(\@pending_event_fees)."\n"
- if @pending_event_fees and $DEBUG > 1;
+ warn "$me found pending fees:\n".Dumper(\@pending_fees)."\n"
+ if @pending_fees and $DEBUG > 1;
# determine whether to generate an invoice
my $generate_bill = scalar(@cust_bill_pkg) > 0;
- foreach my $event_fee (@pending_event_fees) {
- $generate_bill = 1 unless $event_fee->nextbill;
+ foreach my $fee (@pending_fees) {
+ $generate_bill = 1 unless $fee->nextbill;
}
# don't create an invoice with no line items, or where the only line
# calculate fees...
my @fee_items;
- foreach my $event_fee (@pending_event_fees) {
- my $object = $event_fee->cust_event->cust_X;
- my $part_fee = $event_fee->part_fee;
- my $cust_bill;
- if ( $object->isa('FS::cust_main')
- or $object->isa('FS::cust_pkg')
- or $object->isa('FS::cust_pay_batch') )
- {
- # Not the real cust_bill object that will be inserted--in particular
- # there are no taxes yet. If you want to charge a fee on the total
- # invoice amount including taxes, you have to put the fee on the next
- # invoice.
- $cust_bill = FS::cust_bill->new({
- 'custnum' => $self->custnum,
- 'cust_bill_pkg' => \@cust_bill_pkg,
- 'charged' => ${ $total_setup{$pass} } +
- ${ $total_recur{$pass} },
- });
+ foreach my $fee_origin (@pending_fees) {
+ my $part_fee = $fee_origin->part_fee;
- # If this is a package event, only apply the fee to line items
- # from that package.
- if ($object->isa('FS::cust_pkg')) {
- $cust_bill->set('cust_bill_pkg',
- [ grep { $_->pkgnum == $object->pkgnum } @cust_bill_pkg ]
- );
- }
-
- } elsif ( $object->isa('FS::cust_bill') ) {
- # simple case: applying the fee to a previous invoice (late fee,
- # etc.)
- $cust_bill = $object;
- }
+ # check whether the fee is applicable before doing anything expensive:
+ #
# if the fee def belongs to a different agent, don't charge the fee.
# event conditions should prevent this, but just in case they don't,
# skip the fee.
}
# also skip if it's disabled
next if $part_fee->disabled eq 'Y';
+
+ # Decide which invoice to base the fee on.
+ my $cust_bill = $fee_origin->cust_bill;
+ if (!$cust_bill) {
+ # Then link it to the current invoice. This isn't the real cust_bill
+ # object that will be inserted--in particular there are no taxes yet.
+ # If you want to charge a fee on the total invoice amount including
+ # taxes, you have to put the fee on the next invoice.
+ $cust_bill = FS::cust_bill->new({
+ 'custnum' => $self->custnum,
+ 'cust_bill_pkg' => \@cust_bill_pkg,
+ 'charged' => ${ $total_setup{$pass} } +
+ ${ $total_recur{$pass} },
+ });
+
+ # If the origin is for a specific package, then only apply the fee to
+ # line items from that package.
+ if ( my $cust_pkg = $fee_origin->cust_pkg ) {
+ my @charge_fee_on_item;
+ my $charge_fee_on_amount = 0;
+ foreach (@cust_bill_pkg) {
+ if ($_->pkgnum == $cust_pkg->pkgnum) {
+ push @charge_fee_on_item, $_;
+ $charge_fee_on_amount += $_->setup + $_->recur;
+ }
+ }
+ $cust_bill->set('cust_bill_pkg', \@charge_fee_on_item);
+ $cust_bill->set('charged', $charge_fee_on_amount);
+ }
+
+ } # $cust_bill is now set
# calculate the fee
my $fee_item = $part_fee->lineitem($cust_bill) or next;
# link this so that we can clear the marker on inserting the line item
- $fee_item->set('cust_event_fee', $event_fee);
+ $fee_item->set('fee_origin', $fee_origin);
push @fee_items, $fee_item;
}
}
#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;
}
=item calculate_taxes LINEITEMREF TAXHASHREF INVOICE_TIME
#.Dumper($self, $cust_bill_pkg, $taxlisthash, $invoice_time). "\n"
if $DEBUG > 2;
+ my $custnum = $self->custnum;
# The main tax accumulator. One bin for each tax name (itemdesc).
# For each subdivision of tax under this name, push a cust_bill_pkg item
# for the calculated tax into the arrayref.
# values are arrayrefs of cust_tax_exempt_pkg objects
my %tax_exemption;
+ # For tax on tax calculation, we need to remember which taxable items
+ # (and charge classes) had which taxes applied to them.
+ #
# keys are cust_bill_pkg objects (taxable items)
# values are hashrefs
- # keys are taxlisthash keys
- # values are the taxlines generated for those taxes
+ # keys are charge classes
+ # values are hashrefs
+ # keys are taxnums (in tax_rate only; cust_main_county doesn't use this)
+ # values are the taxlines generated for those taxes
tie my %item_has_tax, 'Tie::RefHash',
map { $_ => {} } @$cust_bill_pkg;
my $taxables = $taxlisthash->{$tax_id};
my $tax_object = shift @$taxables;
+ my $taxnum = $tax_object->taxnum;
# $tax_object is a cust_main_county or tax_rate
# (with billpkgnum, pkgnum, locationnum set)
# the rest of @{ $taxlisthash->{$tax_id} } is cust_bill_pkg objects,
if ( $tax_object->isa('FS::tax_rate') ) { # EXTERNAL TAXES
# STILL have tax_rate-specific crap in here...
my @taxlines = $tax_object->taxline( $taxables,
- 'custnum' => $self->custnum,
+ 'custnum' => $custnum,
'invoice_time' => $invoice_time,
'exemptions' => $exemptions,
);
next if !@taxlines;
if (!ref $taxlines[0]) {
# it's an error string
- warn "error evaluating $tax_id on custnum ".$self->custnum."\n";
+ warn "error evaluating $tax_id on custnum $custnum\n";
return $taxlines[0];
}
foreach my $taxline (@taxlines) {
push @{ $taxname{ $taxline->itemdesc } }, $taxline;
my $link = $taxline->get('cust_bill_pkg_tax_rate_location')->[0];
my $taxable_item = $link->taxable_cust_bill_pkg;
- $item_has_tax{$taxable_item}->{$tax_id} = $taxline;
+ $item_has_tax{$taxable_item}{$taxline->_class}{$taxnum} = $taxline;
}
+
} else { # INTERNAL TAXES
# we can do this in a single taxline, because it's not stupid
my $taxline = $tax_object->taxline( $taxables,
- 'custnum' => $self->custnum,
+ 'custnum' => $custnum,
'invoice_time' => $invoice_time,
'exemptions' => $exemptions,
);
next if !$taxline;
if (!ref $taxline) {
# it's an error string
- warn "error evaluating $tax_id on custnum ".$self->custnum."\n";
+ warn "error evaluating $tax_id on custnum $custnum\n";
return $taxline;
}
# if the calculated tax is zero, don't even keep it
my $this_has_tax = $item_has_tax{$taxable_item};
my $location = $taxable_item->tax_location;
- foreach my $tax_id (keys %$this_has_tax) {
- my ($class, $taxnum) = split(' ', $tax_id);
- # internal taxes don't support tax_on_tax, so we don't bother with
- # them here.
- next unless $class eq 'FS::tax_rate';
-
- # for each tax item that was calculated in phase 1, get the
- # tax definition
- my $tax_object = FS::tax_rate->by_key($taxnum);
- # and find all taxes that apply to it in this location
- my @tot = $tax_object->tax_on_tax( $location );
- next if !@tot;
- warn "found possible taxed taxnum $taxnum\n"
- if $DEBUG > 2;
- # Calculate ToT separately for each taxable item, and only if _that
- # item_ is already taxed under the ToT. This is counterintuitive.
- # See RT#5243.
- foreach my $tot (@tot) {
- my $tot_id = ref($tot) . ' ' . $tot->taxnum;
- warn "checking taxnum ".$tot->taxnum.
- " which we call ". $tot->taxname ."\n"
+
+ foreach my $charge_class (keys %$this_has_tax) {
+ # taxes that apply to this item and charge class
+ my $this_class_has_tax = $this_has_tax->{$charge_class};
+ foreach my $taxnum (keys %$this_class_has_tax) {
+
+ # for each tax item that was calculated in phase 1, get the
+ # tax definition
+ my $tax_object = FS::tax_rate->by_key($taxnum);
+ # and find all taxes that apply to it in this location
+ my @tot = $tax_object->tax_on_tax( $location );
+ next if !@tot;
+ warn "found possible taxed taxnum $taxnum\n"
if $DEBUG > 2;
- if ( exists $this_has_tax->{ $tot_id } ) {
- warn "calculating tax on tax: taxnum ".$tot->taxnum." on $taxnum\n"
- if $DEBUG;
- my @taxlines = $tot->taxline(
- $this_has_tax->{ $tax_id }, # the first-stage tax
- 'custnum' => $self->custnum,
- 'invoice_time' => $invoice_time,
- );
- next if (!@taxlines); # it didn't apply after all
- if (!ref($taxlines[0])) {
- warn "error evaluating $tot_id TOT on custnum ".
- $self->custnum."\n";
- return $taxlines[0];
- }
- foreach my $taxline (@taxlines) {
- push @{ $taxname{ $taxline->itemdesc } }, $taxline;
- }
- } # if $has_tax
- } # foreach my $tot (tax-on-tax rate definition)
- } # foreach $taxnum (first-tier rate definition)
+ # Calculate ToT separately for each taxable item and class, and only
+ # if _that class on the item_ is already taxed under the ToT. This is
+ # counterintuitive.
+ # See RT#5243 and RT#36380.
+ foreach my $tot (@tot) {
+ my $totnum = $tot->taxnum;
+ warn "checking taxnum $totnum which we call ". $tot->taxname ."\n"
+ if $DEBUG > 2;
+ # note: if the _null class_ on this item is taxed under the ToT,
+ # then this specific class is taxed also (because null class
+ # includes all classes) and so ToT is applicable.
+ if (
+ exists $this_class_has_tax->{ $totnum }
+ or exists $this_has_tax->{''}{ $totnum }
+ ) {
+
+ warn "calculating tax on tax: taxnum $totnum on $taxnum\n"
+ if $DEBUG;
+ my @taxlines = $tot->taxline(
+ $this_class_has_tax->{ $taxnum }, # the first-stage tax
+ 'custnum' => $custnum,
+ 'invoice_time' => $invoice_time,
+ );
+ next if (!@taxlines); # it didn't apply after all
+ if (!ref($taxlines[0])) {
+ warn "error evaluating taxnum $totnum TOT on custnum $custnum\n";
+ return $taxlines[0];
+ }
+ foreach my $taxline (@taxlines) {
+ push @{ $taxname{ $taxline->itemdesc } }, $taxline;
+ }
+ } # if $has_tax
+ } # foreach my $tot (tax-on-tax rate definition)
+ } # foreach $taxnum (first-tier rate definition)
+ } # foreach $charge_class
} # foreach $taxable_item
#consolidate and create tax line items
# - 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->part_pkg->unit_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
+ }
}
$cust_pkg->setfield('setup', $time)
my $unitrecur = 0;
my @recur_discounts = ();
my $sdate;
+
+ my $override_quantity;
+
+ # 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
)
)
)
+ || $cust_pkg->is_status_delay_cancel
)
and
( $part_pkg->freq ne '0' && ( $cust_pkg->bill || 0 ) <= $cmp_time )
&& $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
+ if ( $param{'override_quantity'} ) {
+ $override_quantity = $param{'override_quantity'};
+ $unitrecur = $recur / $override_quantity;
+ }
+
if ( $increment_next_bill ) {
my $next_bill;
} else {
# the normal case
$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++;
}
}
}
- }
+ } # end of recurring fee
warn "\$setup is undefined" unless defined($setup);
warn "\$recur is undefined" unless defined($recur);
my $cust_bill_pkg = new FS::cust_bill_pkg {
'pkgnum' => $cust_pkg->pkgnum,
'setup' => $setup,
- 'unitsetup' => $unitsetup,
+ 'unitsetup' => sprintf('%.2f', $unitsetup),
'recur' => $recur,
- 'unitrecur' => $unitrecur,
- 'quantity' => $cust_pkg->quantity,
+ 'unitrecur' => sprintf('%.2f', $unitrecur),
+ 'quantity' => $override_quantity || $cust_pkg->quantity,
'details' => \@details,
'discounts' => [ @setup_discounts, @recur_discounts ],
'hidden' => $part_pkg->hidden,
=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;
projects / freeside.git / blobdiff