use FS::UID qw( dbh );
use FS::Record qw( qsearch qsearchs dbdef );
use FS::Misc::DateTime qw( day_end );
+use Tie::RefHash;
use FS::cust_bill;
use FS::cust_bill_pkg;
use FS::cust_bill_pkg_display;
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;
use FS::TaxEngine;
sub bill {
my( $self, %options ) = @_;
- return '' if $self->payby eq 'COMP';
+ return '' if $self->complimentary eq 'Y';
local($DEBUG) = $FS::cust_main::DEBUG if $FS::cust_main::DEBUG > $DEBUG;
my $log = FS::Log->new('FS::cust_main::Billing::bill');
push @{ $cust_bill_pkg{$pass} }, @transfer_items;
# treating this as recur, just because most charges are recur...
${$total_recur{$pass}} += $_->recur foreach @transfer_items;
+
+ # currently not considering separate_bill here, as it's for
+ # one-time charges only
}
foreach my $part_pkg ( @part_pkg ) {
$cust_pkg->set($_, $hash{$_}) foreach qw ( setup last_bill bill );
- my $pass = ($cust_pkg->no_auto || $part_pkg->no_auto) ? 'no_auto' : '';
+ my $pass = '';
+ if ( $cust_pkg->separate_bill ) {
+ # if no_auto is also set, that's fine. we just need to not have
+ # invoices that are both auto and no_auto, and since the package
+ # gets an invoice all to itself, it will only be one or the other.
+ $pass = $cust_pkg->pkgnum;
+ if (!exists $cust_bill_pkg{$pass}) { # it may not exist yet
+ push @passes, $pass;
+ $total_setup{$pass} = do { my $z = 0; \$z };
+ $total_recur{$pass} = do { my $z = 0; \$z };
+ # it also needs its own tax context
+ $tax_engines{$pass} = FS::TaxEngine->new(
+ cust_main => $self,
+ invoice_time => $invoice_time,
+ cancel => $options{cancel}
+ );
+ $cust_bill_pkg{$pass} = [];
+ }
+ } elsif ( ($cust_pkg->no_auto || $part_pkg->no_auto) ) {
+ $pass = 'no_auto';
+ }
my $next_bill = $cust_pkg->getfield('bill') || 0;
my $error;
} #foreach my $cust_pkg
- #if the customer isn't on an automatic payby, everything can go on a single
- #invoice anyway?
- #if ( $cust_main->payby !~ /^(CARD|CHEK)$/ ) {
- #merge everything into one list
- #}
-
- foreach my $pass (@passes) { # keys %cust_bill_pkg ) {
+ foreach my $pass (@passes) { # keys %cust_bill_pkg )
my @cust_bill_pkg = _omit_zero_value_bundles(@{ $cust_bill_pkg{$pass} });
# 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;
}
my $setup = 0;
my $unitsetup = 0;
my @setup_discounts = ();
- my %setup_param = ( 'discounts' => \@setup_discounts );
+ my %setup_param = ( 'discounts' => \@setup_discounts,
+ 'real_pkgpart' => $params{real_pkgpart}
+ );
my $setup_billed_currency = '';
my $setup_billed_amount = 0;
# Conditions for setting setup date and charging the setup fee:
cust_bill_pkg, and location from the pkgnum (or, for fees, the invnum and
the customer's default service location).
+This method will also calculate exemptions for any taxes that apply to the
+line item (using the C<set_exemptions> method of L<FS::cust_bill_pkg>) and
+attach them. This is the only place C<set_exemptions> is called in normal
+invoice processing.
+
=cut
sub _handle_taxes {
my %taxes = ();
my @classes;
- push @classes, $cust_bill_pkg->usage_classes if $cust_bill_pkg->usage;
+ my $usage = $cust_bill_pkg->usage || 0;
+ push @classes, $cust_bill_pkg->usage_classes if $usage;
push @classes, 'setup' if $cust_bill_pkg->setup and !$options{cancel};
- push @classes, 'recur' if $cust_bill_pkg->recur and !$options{cancel};
-
- my $exempt = $conf->exists('cust_class-tax_exempt')
- ? ( $self->cust_class ? $self->cust_class->tax : '' )
- : $self->tax;
+ push @classes, 'recur' if ($cust_bill_pkg->recur - $usage)
+ and !$options{cancel};
+ # that's better--probably don't even need $options{cancel} now
+ # but leave it for now, just to be safe
+ #
+ # About $options{cancel}: This protects against charging per-line or
+ # per-customer or other flat-rate surcharges on a package that's being
+ # billed on cancellation (which is an out-of-cycle bill and should only
+ # have usage charges). See RT#29443.
+
+ # customer exemption is now handled in the 'taxline' method
+ #my $exempt = $conf->exists('cust_class-tax_exempt')
+ # ? ( $self->cust_class ? $self->cust_class->tax : '' )
+ # : $self->tax;
# standardize this just to be sure
- $exempt = ($exempt eq 'Y') ? 'Y' : '';
-
- if ( !$exempt ) {
+ #$exempt = ($exempt eq 'Y') ? 'Y' : '';
+ #
+ #if ( !$exempt ) {
+
+ unless (exists $taxes{''}) {
+ # unsure what purpose this serves, but last time I deleted something
+ # from here just because I didn't see the point, it actually did
+ # something important.
+ my $err_or_ref = $self->_gather_taxes($part_item, '', $location);
+ return $err_or_ref unless ref($err_or_ref);
+ $taxes{''} = $err_or_ref;
+ }
- foreach my $class (@classes) {
- my $err_or_ref = $self->_gather_taxes($part_item, $class, $location);
- return $err_or_ref unless ref($err_or_ref);
- $taxes{$class} = $err_or_ref;
- }
+ # NO DISINTEGRATIONS.
+ # my %tax_cust_bill_pkg = $cust_bill_pkg->disintegrate;
+ #
+ # do not call taxline() with any argument except the entire set of
+ # cust_bill_pkgs on an invoice that are eligible for the tax.
- unless (exists $taxes{''}) {
- my $err_or_ref = $self->_gather_taxes($part_item, '', $location);
- return $err_or_ref unless ref($err_or_ref);
- $taxes{''} = $err_or_ref;
- }
+ # only calculate exemptions once for each tax rate, even if it's used
+ # for multiple classes
+ my %tax_seen = ();
+
+ foreach my $class (@classes) {
+ my $err_or_ref = $self->_gather_taxes($part_item, $class, $location);
+ return $err_or_ref unless ref($err_or_ref);
+ my @taxes = @$err_or_ref;
- }
+ next if !@taxes;
- my %tax_cust_bill_pkg = $cust_bill_pkg->disintegrate; # grrr
- foreach my $key (keys %tax_cust_bill_pkg) {
- # $key is "setup", "recur", or a usage class name. ('' is a usage class.)
- # $tax_cust_bill_pkg{$key} is a cust_bill_pkg for that component of
- # the line item.
- # $taxes{$key} is an arrayref of cust_main_county or tax_rate objects that
- # apply to $key-class charges.
- my @taxes = @{ $taxes{$key} || [] };
- my $tax_cust_bill_pkg = $tax_cust_bill_pkg{$key};
-
- my %localtaxlisthash = ();
foreach my $tax ( @taxes ) {
- # this is the tax identifier, not the taxname
- my $taxname = ref( $tax ). ' '. $tax->taxnum;
- # $taxlisthash: keys are "setup", "recur", and usage classes.
+ my $tax_id = ref( $tax ). ' '. $tax->taxnum;
+ # $taxlisthash: keys are tax identifiers ('FS::tax_rate 123456').
# Values are arrayrefs, first the tax object (cust_main_county
- # or tax_rate) and then any cust_bill_pkg objects that the
- # tax applies to.
- $taxlisthash->{ $taxname } ||= [ $tax ];
- push @{ $taxlisthash->{ $taxname } }, $tax_cust_bill_pkg;
-
- $localtaxlisthash{ $taxname } ||= [ $tax ];
- push @{ $localtaxlisthash{ $taxname } }, $tax_cust_bill_pkg;
-
- }
+ # or tax_rate), then the cust_bill_pkg object that the
+ # tax applies to, then the tax class (setup, recur, usage classnum).
+ $taxlisthash->{ $tax_id } ||= [ $tax ];
+ push @{ $taxlisthash->{ $tax_id } }, $cust_bill_pkg, $class;
+
+ # determine any exemptions that apply
+ if (!$tax_seen{$tax_id}) {
+ $cust_bill_pkg->set_exemptions( $tax, custnum => $self->custnum );
+ $tax_seen{$tax_id} = 1;
+ }
- warn "finding taxed taxes...\n" if $DEBUG > 2;
- foreach my $tax ( keys %localtaxlisthash ) {
- my $tax_object = shift @{ $localtaxlisthash{$tax} };
- warn "found possible taxed tax ". $tax_object->taxname. " we call $tax\n"
- if $DEBUG > 2;
- next unless $tax_object->can('tax_on_tax');
-
- foreach my $tot ( $tax_object->tax_on_tax( $location ) ) {
- my $totname = ref( $tot ). ' '. $tot->taxnum;
-
- warn "checking $totname which we call ". $tot->taxname. " as applicable\n"
- if $DEBUG > 2;
- next unless exists( $localtaxlisthash{ $totname } ); # only increase
- # existing taxes
- warn "adding $totname to taxed taxes\n" if $DEBUG > 2;
- # calculate the tax amount that the tax_on_tax will apply to
- my $hashref_or_error =
- $tax_object->taxline( $localtaxlisthash{$tax} );
- return $hashref_or_error
- unless ref($hashref_or_error);
-
- # and append it to the list of taxable items
- $taxlisthash->{ $totname } ||= [ $tot ];
- push @{ $taxlisthash->{ $totname } }, $hashref_or_error->{amount};
+ # tax on tax will be done later, when we actually create the tax
+ # line items
- }
}
}
foreach (@taxes) {
my $tax_id = 'cust_main_county '.$_->taxnum;
$taxlisthash->{$tax_id} ||= [ $_ ];
+ $cust_bill_pkg->set_exemptions($_, custnum => $self->custnum);
push @{ $taxlisthash->{$tax_id} }, $cust_bill_pkg;
}
projects / freeside.git / blobdiff