X-Git-Url: http://git.freeside.biz/gitweb/?p=freeside.git;a=blobdiff_plain;f=FS%2FFS%2Fcust_main%2FBilling.pm;h=6bd82d1337a5d06de6c4559de3207b76b9924701;hp=96ffe41f4ee935c895c6a4c2fee081aa2cb360fe;hb=c7bc6770f2f0b4413b788f8fc9abde6ad5548da3;hpb=5c9d03cf63378dbca8fc062ed25e781f9c7bb61b diff --git a/FS/FS/cust_main/Billing.pm b/FS/FS/cust_main/Billing.pm index 96ffe41f4..6bd82d133 100644 --- a/FS/FS/cust_main/Billing.pm +++ b/FS/FS/cust_main/Billing.pm @@ -7,12 +7,12 @@ use Data::Dumper; use List::Util qw( min ); use FS::UID qw( dbh ); use FS::Record qw( qsearch qsearchs dbdef ); +use FS::Misc::DateTime qw( day_end ); use FS::cust_bill; use FS::cust_bill_pkg; use FS::cust_bill_pkg_display; use FS::cust_bill_pay; use FS::cust_credit_bill; -use FS::cust_pkg; use FS::cust_tax_adjustment; use FS::tax_rate; use FS::tax_rate_location; @@ -20,6 +20,9 @@ use FS::cust_bill_pkg_tax_location; use FS::cust_bill_pkg_tax_rate_location; use FS::part_event; use FS::part_event_condition; +use FS::pkg_category; +use FS::cust_event_fee; +use FS::Log; # 1 is mostly method/subroutine entry and options # 2 traces progress of some operations @@ -103,6 +106,9 @@ options of those methods are also available. sub bill_and_collect { my( $self, %options ) = @_; + my $log = FS::Log->new('bill_and_collect'); + $log->debug('start', object => $self, agentnum => $self->agentnum); + my $error; #$options{actual_time} not $options{time} because freeside-daily -d is for @@ -111,8 +117,13 @@ sub bill_and_collect { $options{'actual_time'} ||= time; my $job = $options{'job'}; + my $actual_time = ( $conf->exists('next-bill-ignore-time') + ? day_end( $options{actual_time} ) + : $options{actual_time} + ); + $job->update_statustext('0,cleaning expired packages') if $job; - $error = $self->cancel_expired_pkgs( $options{actual_time} ); + $error = $self->cancel_expired_pkgs( $actual_time ); if ( $error ) { $error = "Error expiring custnum ". $self->custnum. ": $error"; if ( $options{fatal} && $options{fatal} eq 'return' ) { return $error; } @@ -120,7 +131,7 @@ sub bill_and_collect { else { warn $error; } } - $error = $self->suspend_adjourned_pkgs( $options{actual_time} ); + $error = $self->suspend_adjourned_pkgs( $actual_time ); if ( $error ) { $error = "Error adjourning custnum ". $self->custnum. ": $error"; if ( $options{fatal} && $options{fatal} eq 'return' ) { return $error; } @@ -128,6 +139,14 @@ sub bill_and_collect { else { warn $error; } } + $error = $self->unsuspend_resumed_pkgs( $actual_time ); + if ( $error ) { + $error = "Error resuming custnum ".$self->custnum. ": $error"; + if ( $options{fatal} && $options{fatal} eq 'return' ) { return $error; } + elsif ( $options{fatal} ) { die $error; } + else { warn $error; } + } + $job->update_statustext('20,billing packages') if $job; $error = $self->bill( %options ); if ( $error ) { @@ -159,6 +178,7 @@ sub bill_and_collect { } } $job->update_statustext('100,finished') if $job; + $log->debug('finish', object => $self, agentnum => $self->agentnum); ''; @@ -166,30 +186,47 @@ sub bill_and_collect { sub cancel_expired_pkgs { my ( $self, $time, %options ) = @_; - + my @cancel_pkgs = $self->ncancelled_pkgs( { 'extra_sql' => " AND expire IS NOT NULL AND expire > 0 AND expire <= $time " } ); my @errors = (); - foreach my $cust_pkg ( @cancel_pkgs ) { + CUST_PKG: foreach my $cust_pkg ( @cancel_pkgs ) { my $cpr = $cust_pkg->last_cust_pkg_reason('expire'); - my $error = $cust_pkg->cancel($cpr ? ( 'reason' => $cpr->reasonnum, - 'reason_otaker' => $cpr->otaker + my $error; + + if ( $cust_pkg->change_to_pkgnum ) { + + my $new_pkg = FS::cust_pkg->by_key($cust_pkg->change_to_pkgnum); + if ( !$new_pkg ) { + push @errors, 'can\'t change pkgnum '.$cust_pkg->pkgnum.' to pkgnum '. + $cust_pkg->change_to_pkgnum.'; not expiring'; + next CUST_PKG; + } + $error = $cust_pkg->change( 'cust_pkg' => $new_pkg, + 'unprotect_svcs' => 1 ); + $error = '' if ref $error eq 'FS::cust_pkg'; + + } else { # just cancel it + $error = $cust_pkg->cancel($cpr ? ( 'reason' => $cpr->reasonnum, + 'reason_otaker' => $cpr->otaker, + 'time' => $time, ) : () ); + } push @errors, 'pkgnum '.$cust_pkg->pkgnum.": $error" if $error; } - scalar(@errors) ? join(' / ', @errors) : ''; + join(' / ', @errors); } sub suspend_adjourned_pkgs { my ( $self, $time, %options ) = @_; - + my @susp_pkgs = $self->ncancelled_pkgs( { 'extra_sql' => " AND ( susp IS NULL OR susp = 0 ) @@ -225,7 +262,25 @@ sub suspend_adjourned_pkgs { push @errors, 'pkgnum '.$cust_pkg->pkgnum.": $error" if $error; } - scalar(@errors) ? join(' / ', @errors) : ''; + join(' / ', @errors); + +} + +sub unsuspend_resumed_pkgs { + my ( $self, $time, %options ) = @_; + + my @unsusp_pkgs = $self->ncancelled_pkgs( { + 'extra_sql' => " AND resume IS NOT NULL AND resume > 0 AND resume <= $time " + } ); + + my @errors = (); + + foreach my $cust_pkg ( @unsusp_pkgs ) { + my $error = $cust_pkg->unsuspend( 'time' => $time ); + push @errors, 'pkgnum '.$cust_pkg->pkgnum.": $error" if $error; + } + + join(' / ', @errors); } @@ -252,7 +307,9 @@ charges, etc. =item freq_override If set, then override the normal frequency and look for a part_pkg_discount -to take at that frequency. +to take at that frequency. This is appropriate only when the normal +frequency for all packages is monthly, and is an error otherwise. Use +C to limit the set of packages included in billing. =item time @@ -309,7 +366,7 @@ sub bill { return '' if $self->payby eq 'COMP'; - local($DEBUG) = $cust_main::DEBUG if $cust_main::DEBUG > $DEBUG; + local($DEBUG) = $FS::cust_main::DEBUG if $FS::cust_main::DEBUG > $DEBUG; warn "$me bill customer ". $self->custnum. "\n" if $DEBUG; @@ -317,6 +374,11 @@ sub bill { my $time = $options{'time'} || time; my $invoice_time = $options{'invoice_time'} || $time; + my $cmp_time = ( $conf->exists('next-bill-ignore-time') + ? day_end( $time ) + : $time + ); + $options{'not_pkgpart'} ||= {}; $options{'not_pkgpart'} = { map { $_ => 1 } split(/\s*,\s*/, $options{'not_pkgpart'}) @@ -375,11 +437,12 @@ sub bill { my @precommit_hooks = (); $options{'pkg_list'} ||= [ $self->ncancelled_pkgs ]; #param checks? + foreach my $cust_pkg ( @{ $options{'pkg_list'} } ) { next if $options{'not_pkgpart'}->{$cust_pkg->pkgpart}; - warn " bill package ". $cust_pkg->pkgnum. "\n" if $DEBUG > 1; + warn " bill package ". $cust_pkg->pkgnum. "\n" if $DEBUG; #? to avoid use of uninitialized value errors... ? $cust_pkg->setfield('bill', '') @@ -396,24 +459,61 @@ sub bill { my @part_pkg = $cust_pkg->part_pkg->self_and_bill_linked; $options{has_hidden} = 1 if ($part_pkg[1] && $part_pkg[1]->hidden); + # if this package was changed from another package, + # and it hasn't been billed since then, + # and package balances are enabled, + if ( $cust_pkg->change_pkgnum + and $cust_pkg->change_date >= ($cust_pkg->last_bill || 0) + and $cust_pkg->change_date < $invoice_time + and $conf->exists('pkg-balances') ) + { + # _transfer_balance will also create the appropriate credit + my @transfer_items = $self->_transfer_balance($cust_pkg); + # $part_pkg[0] is the "real" part_pkg + my $pass = ($cust_pkg->no_auto || $part_pkg[0]->no_auto) ? + 'no_auto' : ''; + push @{ $cust_bill_pkg{$pass} }, @transfer_items; + # treating this as recur, just because most charges are recur... + ${$total_recur{$pass}} += $_->recur foreach @transfer_items; + } + 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 $error = - $self->_make_lines( 'part_pkg' => $part_pkg, - 'cust_pkg' => $cust_pkg, - 'precommit_hooks' => \@precommit_hooks, - 'line_items' => $cust_bill_pkg{$pass}, - 'setup' => $total_setup{$pass}, - 'recur' => $total_recur{$pass}, - 'tax_matrix' => $taxlisthash{$pass}, - 'time' => $time, - 'real_pkgpart' => $real_pkgpart, - 'options' => \%options, - ); + my $next_bill = $cust_pkg->getfield('bill') || 0; + my $error; + # let this run once if this is the last bill upon cancellation + while ( $next_bill <= $cmp_time or $options{cancel} ) { + $error = + $self->_make_lines( 'part_pkg' => $part_pkg, + 'cust_pkg' => $cust_pkg, + 'precommit_hooks' => \@precommit_hooks, + 'line_items' => $cust_bill_pkg{$pass}, + 'setup' => $total_setup{$pass}, + 'recur' => $total_recur{$pass}, + 'tax_matrix' => $taxlisthash{$pass}, + 'time' => $time, + 'real_pkgpart' => $real_pkgpart, + 'options' => \%options, + ); + + # Stop if anything goes wrong + last if $error; + + # or if we're not incrementing the bill date. + last if ($cust_pkg->getfield('bill') || 0) == $next_bill; + + # or if we're letting it run only once + last if $options{cancel}; + + $next_bill = $cust_pkg->getfield('bill') || 0; + + #stop if -o was passed to freeside-daily + last if $options{'one_recur'}; + } if ($error) { $dbh->rollback if $oldAutoCommit && !$options{no_commit}; return $error; @@ -435,10 +535,79 @@ sub bill { next unless @cust_bill_pkg; #don't create an invoice w/o line items - warn "$me billing pass $pass\n". - Dumper(\@cust_bill_pkg)."\n" + warn "$me billing pass $pass\n" + #.Dumper(\@cust_bill_pkg)."\n" if $DEBUG > 2; + ### + # process fees + ### + + my @pending_event_fees = FS::cust_event_fee->by_cust($self->custnum, + hashref => { 'billpkgnum' => '' } + ); + warn "$me found pending fee events:\n".Dumper(\@pending_event_fees)."\n" + if @pending_event_fees; + + my @fee_items; + foreach my $event_fee (@pending_event_fees) { + my $object = $event_fee->cust_event->cust_X; + my $cust_bill; + if ( $object->isa('FS::cust_main') ) { + # 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} }, + }); + } elsif ( $object->isa('FS::cust_bill') ) { + # simple case: applying the fee to a previous invoice (late fee, + # etc.) + $cust_bill = $object; + } + my $part_fee = $event_fee->part_fee; + # 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. + if ( $part_fee->agentnum and $part_fee->agentnum != $self->agentnum ) { + warn "tried to charge fee#".$part_fee->feepart . + " on customer#".$self->custnum." from a different agent.\n"; + next; + } + # also skip if it's disabled + next if $part_fee->disabled eq 'Y'; + # calculate the fee + my $fee_item = $event_fee->part_fee->lineitem($cust_bill); + # link this so that we can clear the marker on inserting the line item + $fee_item->set('cust_event_fee', $event_fee); + push @fee_items, $fee_item; + } + foreach my $fee_item (@fee_items) { + + push @cust_bill_pkg, $fee_item; + ${ $total_setup{$pass} } += $fee_item->setup; + ${ $total_recur{$pass} } += $fee_item->recur; + + my $part_fee = $fee_item->part_fee; + my $fee_location = $self->ship_location; # I think? + + my $error = $self->_handle_taxes( + $part_fee, + $taxlisthash{$pass}, + $fee_item, + $fee_location, + $options{invoice_time}, + {} # no options + ); + return $error if $error; + + } + + # XXX implementation of fees is supposed to make this go away... if ( scalar( grep { $_->recur && $_->recur > 0 } @cust_bill_pkg) || !$conf->exists('postal_invoice-recurring_only') ) @@ -534,20 +703,18 @@ sub bill { my @cust_bill = $self->cust_bill; my $balance = $self->balance; - my $previous_balance = scalar(@cust_bill) - ? ( $cust_bill[$#cust_bill]->billing_balance || 0 ) - : 0; - - $previous_balance += $cust_bill[$#cust_bill]->charged - if scalar(@cust_bill); - #my $balance_adjustments = - # sprintf('%.2f', $balance - $prior_prior_balance - $prior_charged); + my $previous_bill = $cust_bill[-1] if @cust_bill; + my $previous_balance = 0; + if ( $previous_bill ) { + $previous_balance = $previous_bill->billing_balance + + $previous_bill->charged; + } warn "creating the new invoice\n" if $DEBUG; #create the new invoice my $cust_bill = new FS::cust_bill ( { 'custnum' => $self->custnum, - '_date' => ( $invoice_time ), + '_date' => $invoice_time, 'charged' => $charged, 'billing_balance' => $balance, 'previous_balance' => $previous_balance, @@ -580,21 +747,52 @@ sub bill { #discard bundled packages of 0 value sub _omit_zero_value_bundles { + my @in = @_; my @cust_bill_pkg = (); my @cust_bill_pkg_bundle = (); my $sum = 0; + my $discount_show_always = 0; + + 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; - foreach my $cust_bill_pkg ( @_ ) { if (scalar(@cust_bill_pkg_bundle) && !$cust_bill_pkg->pkgpart_override) { - push @cust_bill_pkg, @cust_bill_pkg_bundle if $sum > 0; + 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; } + $sum += $cust_bill_pkg->setup + $cust_bill_pkg->recur; push @cust_bill_pkg_bundle, $cust_bill_pkg; + } - push @cust_bill_pkg, @cust_bill_pkg_bundle if $sum > 0; + + 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 + ) + ); + + warn " _omit_zero_value_bundles: ". scalar(@in). + '->'. scalar(@cust_bill_pkg). "\n" #. Dumper(@cust_bill_pkg). "\n" + if $DEBUG > 2; (@cust_bill_pkg); @@ -602,8 +800,6 @@ sub _omit_zero_value_bundles { =item calculate_taxes LINEITEMREF TAXHASHREF INVOICE_TIME -This is a weird one. Perhaps it should not even be exposed. - Generates tax line items (see L) for this customer. Usually used internally by bill method B. @@ -641,66 +837,84 @@ jurisdictions (i.e. Texas) have tax exemptions which are date sensitive. sub calculate_taxes { my ($self, $cust_bill_pkg, $taxlisthash, $invoice_time) = @_; - local($DEBUG) = $cust_main::DEBUG if $cust_main::DEBUG > $DEBUG; + # $taxlisthash is a hashref + # keys are identifiers, values are arrayrefs + # each arrayref starts with a tax object (cust_main_county or tax_rate) + # then any cust_bill_pkg objects the tax applies to + + local($DEBUG) = $FS::cust_main::DEBUG if $FS::cust_main::DEBUG > $DEBUG; - warn "$me calculate_taxes\n". - Dumper($self, $cust_bill_pkg, $taxlisthash, $invoice_time). "\n" + warn "$me calculate_taxes\n" + #.Dumper($self, $cust_bill_pkg, $taxlisthash, $invoice_time). "\n" if $DEBUG > 2; my @tax_line_items = (); # keys are tax names (as printed on invoices / itemdesc ) - # values are listrefs of taxlisthash keys (internal identifiers) + # values are arrayrefs of taxlisthash keys (internal identifiers) my %taxname = (); # keys are taxlisthash keys (internal identifiers) # values are (cumulative) amounts - my %tax = (); + my %tax_amount = (); # keys are taxlisthash keys (internal identifiers) - # values are listrefs of cust_bill_pkg_tax_location hashrefs + # values are arrayrefs of cust_bill_pkg_tax_location hashrefs my %tax_location = (); # keys are taxlisthash keys (internal identifiers) - # values are listrefs of cust_bill_pkg_tax_rate_location hashrefs + # values are arrayrefs of cust_bill_pkg_tax_rate_location hashrefs my %tax_rate_location = (); + # keys are taxlisthash keys (internal identifiers!) + # values are arrayrefs of cust_tax_exempt_pkg objects + my %tax_exemption; + foreach my $tax ( keys %$taxlisthash ) { + # $tax is a tax identifier (intersection of a tax definition record + # and a cust_bill_pkg record) my $tax_object = shift @{ $taxlisthash->{$tax} }; + # $tax_object is a cust_main_county or tax_rate + # (with billpkgnum, pkgnum, locationnum set) + # the rest of @{ $taxlisthash->{$tax} } is cust_bill_pkg component objects + # (setup, recurring, usage classes) warn "found ". $tax_object->taxname. " as $tax\n" if $DEBUG > 2; warn " ". join('/', @{ $taxlisthash->{$tax} } ). "\n" if $DEBUG > 2; - my $hashref_or_error = - $tax_object->taxline( $taxlisthash->{$tax}, + # taxline calculates the tax on all cust_bill_pkgs in the + # first (arrayref) argument, and returns a hashref of 'name' + # (the line item description) and 'amount'. + # It also calculates exemptions and attaches them to the cust_bill_pkgs + # in the argument. + my $taxables = $taxlisthash->{$tax}; + my $exemptions = $tax_exemption{$tax} ||= []; + my $taxline = $tax_object->taxline( + $taxables, 'custnum' => $self->custnum, - 'invoice_time' => $invoice_time + 'invoice_time' => $invoice_time, + 'exemptions' => $exemptions, ); - return $hashref_or_error unless ref($hashref_or_error); + return $taxline unless ref($taxline); unshift @{ $taxlisthash->{$tax} }, $tax_object; - my $name = $hashref_or_error->{'name'}; - my $amount = $hashref_or_error->{'amount'}; + if ( $tax_object->isa('FS::cust_main_county') ) { + # then $taxline is a real line item + push @{ $taxname{ $taxline->itemdesc } }, $taxline; + + } else { + # leave this as is for now - #warn "adding $amount as $name\n"; - $taxname{ $name } ||= []; - push @{ $taxname{ $name } }, $tax; + my $name = $taxline->{'name'}; + my $amount = $taxline->{'amount'}; - $tax{ $tax } += $amount; + #warn "adding $amount as $name\n"; + $taxname{ $name } ||= []; + push @{ $taxname{ $name } }, $tax; - $tax_location{ $tax } ||= []; - if ( $tax_object->get('pkgnum') || $tax_object->get('locationnum') ) { - push @{ $tax_location{ $tax } }, - { - 'taxnum' => $tax_object->taxnum, - 'taxtype' => ref($tax_object), - 'pkgnum' => $tax_object->get('pkgnum'), - 'locationnum' => $tax_object->get('locationnum'), - 'amount' => sprintf('%.2f', $amount ), - }; - } + $tax_amount{ $tax } += $amount; - $tax_rate_location{ $tax } ||= []; - if ( ref($tax_object) eq 'FS::tax_rate' ) { + # link records between cust_main_county/tax_rate and cust_location + $tax_rate_location{ $tax } ||= []; my $taxratelocationnum = $tax_object->tax_rate_location->taxratelocationnum; push @{ $tax_rate_location{ $tax } }, @@ -711,43 +925,52 @@ sub calculate_taxes { 'locationtaxid' => $tax_object->location, 'taxratelocationnum' => $taxratelocationnum, }; - } - - } - - #move the cust_tax_exempt_pkg records to the cust_bill_pkgs we will commit - my %packagemap = map { $_->pkgnum => $_ } @$cust_bill_pkg; - foreach my $tax ( keys %$taxlisthash ) { - foreach ( @{ $taxlisthash->{$tax} }[1 ... scalar(@{ $taxlisthash->{$tax} })] ) { - next unless ref($_) eq 'FS::cust_bill_pkg'; - - push @{ $packagemap{$_->pkgnum}->_cust_tax_exempt_pkg }, - splice( @{ $_->_cust_tax_exempt_pkg } ); - } - } + } #if ref($tax_object)... + } #foreach keys %$taxlisthash #consolidate and create tax line items warn "consolidating and generating...\n" if $DEBUG > 2; foreach my $taxname ( keys %taxname ) { - my $tax = 0; + my @cust_bill_pkg_tax_location; + my @cust_bill_pkg_tax_rate_location; + my $tax_cust_bill_pkg = FS::cust_bill_pkg->new({ + 'pkgnum' => 0, + 'recur' => 0, + 'sdate' => '', + 'edate' => '', + 'itemdesc' => $taxname, + 'cust_bill_pkg_tax_location' => \@cust_bill_pkg_tax_location, + 'cust_bill_pkg_tax_rate_location' => \@cust_bill_pkg_tax_rate_location, + }); + + my $tax_total = 0; my %seen = (); - my @cust_bill_pkg_tax_location = (); - my @cust_bill_pkg_tax_rate_location = (); warn "adding $taxname\n" if $DEBUG > 1; foreach my $taxitem ( @{ $taxname{$taxname} } ) { - next if $seen{$taxitem}++; - warn "adding $tax{$taxitem}\n" if $DEBUG > 1; - $tax += $tax{$taxitem}; - push @cust_bill_pkg_tax_location, - map { new FS::cust_bill_pkg_tax_location $_ } - @{ $tax_location{ $taxitem } }; - push @cust_bill_pkg_tax_rate_location, - map { new FS::cust_bill_pkg_tax_rate_location $_ } - @{ $tax_rate_location{ $taxitem } }; + if ( ref($taxitem) eq 'FS::cust_bill_pkg' ) { + # then we need to transfer the amount and the links from the + # line item to the new one we're creating. + $tax_total += $taxitem->setup; + foreach my $link ( @{ $taxitem->get('cust_bill_pkg_tax_location') } ) { + $link->set('tax_cust_bill_pkg', $tax_cust_bill_pkg); + push @cust_bill_pkg_tax_location, $link; + } + } else { + # the tax_rate way + next if $seen{$taxitem}++; + warn "adding $tax_amount{$taxitem}\n" if $DEBUG > 1; + $tax_total += $tax_amount{$taxitem}; + push @cust_bill_pkg_tax_rate_location, + map { new FS::cust_bill_pkg_tax_rate_location $_ } + @{ $tax_rate_location{ $taxitem } }; + } } - next unless $tax; + next unless $tax_total; - $tax = sprintf('%.2f', $tax ); + # we should really neverround this up...I guess it's okay if taxline + # already returns amounts with 2 decimal places + $tax_total = sprintf('%.2f', $tax_total ); + $tax_cust_bill_pkg->set('setup', $tax_total); my $pkg_category = qsearchs( 'pkg_category', { 'categoryname' => $taxname, 'disabled' => '', @@ -765,19 +988,9 @@ sub calculate_taxes { push @display, new FS::cust_bill_pkg_display { type => 'S', %hash }; } + $tax_cust_bill_pkg->set('display', \@display); - push @tax_line_items, new FS::cust_bill_pkg { - 'pkgnum' => 0, - 'setup' => $tax, - 'recur' => 0, - 'sdate' => '', - 'edate' => '', - 'itemdesc' => $taxname, - 'display' => \@display, - 'cust_bill_pkg_tax_location' => \@cust_bill_pkg_tax_location, - 'cust_bill_pkg_tax_rate_location' => \@cust_bill_pkg_tax_rate_location, - }; - + push @tax_line_items, $tax_cust_bill_pkg; } \@tax_line_items; @@ -786,11 +999,12 @@ sub calculate_taxes { sub _make_lines { my ($self, %params) = @_; - local($DEBUG) = $cust_main::DEBUG if $cust_main::DEBUG > $DEBUG; + local($DEBUG) = $FS::cust_main::DEBUG if $FS::cust_main::DEBUG > $DEBUG; my $part_pkg = $params{part_pkg} or die "no part_pkg specified"; my $cust_pkg = $params{cust_pkg} or die "no cust_pkg specified"; - my $precommit_hooks = $params{precommit_hooks} or die "no package specified"; + my $cust_location = $cust_pkg->tax_location; + my $precommit_hooks = $params{precommit_hooks} or die "no precommit_hooks specified"; my $cust_bill_pkgs = $params{line_items} or die "no line buffer specified"; my $total_setup = $params{setup} or die "no setup accumulator specified"; my $total_recur = $params{recur} or die "no recur accumulator specified"; @@ -798,46 +1012,71 @@ sub _make_lines { my $time = $params{'time'} or die "no time specified"; my (%options) = %{$params{options}}; + if ( $part_pkg->freq ne '1' and ($options{'freq_override'} || 0) > 0 ) { + # this should never happen + die 'freq_override billing attempted on non-monthly package '. + $cust_pkg->pkgnum; + } + my $dbh = dbh; my $real_pkgpart = $params{real_pkgpart}; my %hash = $cust_pkg->hash; my $old_cust_pkg = new FS::cust_pkg \%hash; my @details = (); - my @discounts = (); my $lineitems = 0; $cust_pkg->pkgpart($part_pkg->pkgpart); + my $cmp_time = ( $conf->exists('next-bill-ignore-time') + ? day_end( $time ) + : $time + ); + ### # bill setup ### my $setup = 0; my $unitsetup = 0; - if ( $options{'resetup'} - || ( ! $cust_pkg->setup - && ( ! $cust_pkg->start_date - || $cust_pkg->start_date <= $time - ) - && ( ! $conf->exists('disable_setup_suspended_pkgs') - || ( $conf->exists('disable_setup_suspended_pkgs') && - ! $cust_pkg->getfield('susp') - ) - ) - ) - and !$options{recurring_only} - ) + my @setup_discounts = (); + my %setup_param = ( 'discounts' => \@setup_discounts ); + my $setup_billed_currency = ''; + my $setup_billed_amount = 0; + if ( ! $options{recurring_only} + and ! $options{cancel} + and ( $options{'resetup'} + || ( ! $cust_pkg->setup + && ( ! $cust_pkg->start_date + || $cust_pkg->start_date <= $cmp_time + ) + && ( ! $conf->exists('disable_setup_suspended_pkgs') + || ( $conf->exists('disable_setup_suspended_pkgs') && + ! $cust_pkg->getfield('susp') + ) + ) + ) + ) + ) { warn " bill setup\n" if $DEBUG > 1; - $lineitems++; - $setup = eval { $cust_pkg->calc_setup( $time, \@details ) }; - return "$@ running calc_setup for $cust_pkg\n" - if $@; + unless ( $cust_pkg->waive_setup ) { + $lineitems++; + + $setup = eval { $cust_pkg->calc_setup( $time, \@details, \%setup_param ) }; + return "$@ running calc_setup for $cust_pkg\n" + if $@; - $unitsetup = $cust_pkg->part_pkg->unit_setup || $setup; #XXX uuh + $unitsetup = $cust_pkg->base_setup() + || $setup; #XXX uuh + + if ( $setup_param{'billed_currency'} ) { + $setup_billed_currency = delete $setup_param{'billed_currency'}; + $setup_billed_amount = delete $setup_param{'billed_amount'}; + } + } $cust_pkg->setfield('setup', $time) unless $cust_pkg->setup; @@ -853,19 +1092,23 @@ sub _make_lines { # bill recurring fee ### - #XXX unit stuff here too my $recur = 0; my $unitrecur = 0; + my @recur_discounts = (); + my $recur_billed_currency = ''; + my $recur_billed_amount = 0; my $sdate; - if ( ! $cust_pkg->get('susp') - and ! $cust_pkg->get('start_date') - and ( $part_pkg->getfield('freq') ne '0' - && ( $cust_pkg->getfield('bill') || 0 ) <= $time - ) - || ( $part_pkg->plan eq 'voip_cdr' - && $part_pkg->option('bill_every_call') - ) - || ( $options{cancel} ) + if ( ! $cust_pkg->start_date + and ( ! $cust_pkg->susp || $cust_pkg->option('suspend_bill',1) + || ( $part_pkg->option('suspend_bill', 1) ) + && ! $cust_pkg->option('no_suspend_bill',1) + ) + and + ( $part_pkg->freq ne '0' && ( $cust_pkg->bill || 0 ) <= $cmp_time ) + || ( $part_pkg->plan eq 'voip_cdr' + && $part_pkg->option('bill_every_call') + ) + || $options{cancel} ) { # XXX should this be a package event? probably. events are called @@ -885,30 +1128,68 @@ sub _make_lines { #over two params! lets at least switch to a hashref for the rest... my $increment_next_bill = ( $part_pkg->freq ne '0' - && ( $cust_pkg->getfield('bill') || 0 ) <= $time + && ( $cust_pkg->getfield('bill') || 0 ) <= $cmp_time && !$options{cancel} ); - my %param = ( 'precommit_hooks' => $precommit_hooks, + my %param = ( %setup_param, + 'precommit_hooks' => $precommit_hooks, 'increment_next_bill' => $increment_next_bill, - 'discounts' => \@discounts, + 'discounts' => \@recur_discounts, 'real_pkgpart' => $real_pkgpart, 'freq_override' => $options{freq_override} || '', + 'setup_fee' => 0, ); my $method = $options{cancel} ? 'calc_cancel' : 'calc_recur'; # There may be some part_pkg for which this is wrong. Only those # which can_discount are supported. + # (the UI should prevent adding discounts to these at the moment) + warn "calling $method on cust_pkg ". $cust_pkg->pkgnum. + " for pkgpart ". $cust_pkg->pkgpart. + " with params ". join(' / ', map "$_=>$param{$_}", keys %param). "\n" + if $DEBUG > 2; + $recur = eval { $cust_pkg->$method( \$sdate, \@details, \%param ) }; return "$@ running $method for $cust_pkg\n" if ( $@ ); + #base_cancel??? + $unitrecur = $cust_pkg->base_recur( \$sdate ) || $recur; #XXX uuh, better + + if ( $param{'billed_currency'} ) { + $recur_billed_currency = delete $param{'billed_currency'}; + $recur_billed_amount = delete $param{'billed_amount'}; + } + if ( $increment_next_bill ) { - my $next_bill = $part_pkg->add_freq($sdate, $options{freq_override} || 0); + my $next_bill; + + if ( my $main_pkg = $cust_pkg->main_pkg ) { + # supplemental package + # to keep in sync with the main package, simulate billing at + # 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) ) { + # 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"; + } + $next_bill = $sdate; + for (1..$ratio) { + $next_bill = $part_pkg->add_freq( $next_bill, $main_pkg_freq ); + } + + } else { + # the normal case + $next_bill = $part_pkg->add_freq($sdate, $options{freq_override} || 0); return "unparsable frequency: ". $part_pkg->freq if $next_bill == -1; + } #pro-rating magic - if $recur_prog fiddled $sdate, want to use that # only for figuring next bill date, nothing else, so, reset $sdate again @@ -921,6 +1202,20 @@ sub _make_lines { } + if ( $param{'setup_fee'} ) { + # Add an additional setup fee at the billing stage. + # Used for prorate_defer_bill. + $setup += $param{'setup_fee'}; + $unitsetup += $param{'setup_fee'}; + $lineitems++; + } + + if ( defined $param{'discount_left_setup'} ) { + foreach my $discount_setup ( values %{$param{'discount_left_setup'}} ) { + $setup -= $discount_setup; + } + } + } warn "\$setup is undefined" unless defined($setup); @@ -932,7 +1227,7 @@ sub _make_lines { # If $cust_pkg has been modified, update it (if we're a real pkgpart) ### - if ( $lineitems || $options{has_hidden} ) { + if ( $lineitems ) { if ( $cust_pkg->modified && $cust_pkg->pkgpart == $real_pkgpart ) { # hmm.. and if just the options are modified in some weird price plan? @@ -941,6 +1236,7 @@ sub _make_lines { if $DEBUG >1; my $error = $cust_pkg->replace( $old_cust_pkg, + 'depend_jobnum'=>$options{depend_jobnum}, 'options' => { $cust_pkg->options }, ) unless $options{no_commit}; @@ -957,9 +1253,18 @@ sub _make_lines { return "negative recur $recur for pkgnum ". $cust_pkg->pkgnum; } - if ( $setup != 0 || - $recur != 0 || - !$part_pkg->hidden && $options{has_hidden} ) #include some $0 lines + my $discount_show_always = $conf->exists('discount-show-always') + && ( ($setup == 0 && scalar(@setup_discounts)) + || ($recur == 0 && scalar(@recur_discounts)) + ); + + if ( $setup != 0 + || $recur != 0 + || (!$part_pkg->hidden && $options{has_hidden}) #include some $0 lines + || $discount_show_always + || ($setup == 0 && $cust_pkg->_X_show_zero('setup')) + || ($recur == 0 && $cust_pkg->_X_show_zero('recur')) + ) { warn " charges (setup=$setup, recur=$recur); adding line items\n" @@ -973,23 +1278,32 @@ sub _make_lines { push @details, @cust_pkg_detail; my $cust_bill_pkg = new FS::cust_bill_pkg { - 'pkgnum' => $cust_pkg->pkgnum, - 'setup' => $setup, - 'unitsetup' => $unitsetup, - 'recur' => $recur, - 'unitrecur' => $unitrecur, - 'quantity' => $cust_pkg->quantity, - 'details' => \@details, - 'discounts' => \@discounts, - 'hidden' => $part_pkg->hidden, - 'freq' => $part_pkg->freq, + 'pkgnum' => $cust_pkg->pkgnum, + 'setup' => $setup, + 'unitsetup' => $unitsetup, + 'setup_billed_currency' => $setup_billed_currency, + 'setup_billed_amount' => $setup_billed_amount, + 'recur' => $recur, + 'unitrecur' => $unitrecur, + 'recur_billed_currency' => $recur_billed_currency, + 'recur_billed_amount' => $recur_billed_amount, + 'quantity' => $cust_pkg->quantity, + 'details' => \@details, + 'discounts' => [ @setup_discounts, @recur_discounts ], + 'hidden' => $part_pkg->hidden, + 'freq' => $part_pkg->freq, }; - if ( $part_pkg->option('recur_temporality', 1) eq 'preceding' ) { + if ( $part_pkg->option('prorate_defer_bill',1) + and !$hash{last_bill} ) { + # both preceding and upcoming, technically + $cust_bill_pkg->sdate( $cust_pkg->setup ); + $cust_bill_pkg->edate( $cust_pkg->bill ); + } elsif ( $part_pkg->recur_temporality eq 'preceding' ) { $cust_bill_pkg->sdate( $hash{last_bill} ); $cust_bill_pkg->edate( $sdate - 86399 ); #60s*60m*24h-1 $cust_bill_pkg->edate( $time ) if $options{cancel}; - } else { #if ( $part_pkg->option('recur_temporality', 1) eq 'upcoming' ) { + } else { #if ( $part_pkg->recur_temporality eq 'upcoming' ) $cust_bill_pkg->sdate( $sdate ); $cust_bill_pkg->edate( $cust_pkg->bill ); #$cust_bill_pkg->edate( $time ) if $options{cancel}; @@ -1005,10 +1319,21 @@ sub _make_lines { # handle taxes ### - my $error = - $self->_handle_taxes($part_pkg, $taxlisthash, $cust_bill_pkg, $cust_pkg, $options{invoice_time}, $real_pkgpart, \%options); + my $error = $self->_handle_taxes( + $part_pkg, + $taxlisthash, + $cust_bill_pkg, + $cust_location, + $options{invoice_time}, + \%options # I have serious objections to this + ); return $error if $error; + $cust_bill_pkg->set_display( + part_pkg => $part_pkg, + real_pkgpart => $real_pkgpart, + ); + push @$cust_bill_pkgs, $cust_bill_pkg; } #if $setup != 0 || $recur != 0 @@ -1019,246 +1344,285 @@ sub _make_lines { } +=item _transfer_balance TO_PKG [ FROM_PKGNUM ] + +Takes one argument, a cust_pkg object that is being billed. This will +be called only if the package was created by a package change, and has +not been billed since the package change, and package balance tracking +is enabled. The second argument can be an alternate package number to +transfer the balance from; this should not be used externally. + +Transfers the balance from the previous package (now canceled) to +this package, by crediting one package and creating an invoice item for +the other. Inserts the credit and returns the invoice item (so that it +can be added to an invoice that's being built). + +If the previous package was never billed, and was also created by a package +change, then this will also transfer the balance from I previous +package, and so on, until reaching a package that either has been billed +or was not created by a package change. + +=cut + +my $balance_transfer_reason; + +sub _transfer_balance { + my $self = shift; + my $cust_pkg = shift; + my $from_pkgnum = shift || $cust_pkg->change_pkgnum; + my $from_pkg = FS::cust_pkg->by_key($from_pkgnum); + + my @transfers; + + # if $from_pkg is not the first package in the chain, and it was never + # billed, walk back + if ( $from_pkg->change_pkgnum and scalar($from_pkg->cust_bill_pkg) == 0 ) { + @transfers = $self->_transfer_balance($cust_pkg, $from_pkg->change_pkgnum); + } + + my $prev_balance = $self->balance_pkgnum($from_pkgnum); + if ( $prev_balance != 0 ) { + $balance_transfer_reason ||= FS::reason->new_or_existing( + 'reason' => 'Package balance transfer', + 'type' => 'Internal adjustment', + 'class' => 'R' + ); + + my $credit = FS::cust_credit->new({ + 'custnum' => $self->custnum, + 'amount' => abs($prev_balance), + 'reasonnum' => $balance_transfer_reason->reasonnum, + '_date' => $cust_pkg->change_date, + }); + + my $cust_bill_pkg = FS::cust_bill_pkg->new({ + 'setup' => 0, + 'recur' => abs($prev_balance), + #'sdate' => $from_pkg->last_bill, # not sure about this + #'edate' => $cust_pkg->change_date, + 'itemdesc' => $self->mt('Previous Balance, [_1]', + $from_pkg->part_pkg->pkg), + }); + + if ( $prev_balance > 0 ) { + # credit the old package, charge the new one + $credit->set('pkgnum', $from_pkgnum); + $cust_bill_pkg->set('pkgnum', $cust_pkg->pkgnum); + } else { + # the reverse + $credit->set('pkgnum', $cust_pkg->pkgnum); + $cust_bill_pkg->set('pkgnum', $from_pkgnum); + } + my $error = $credit->insert; + die "error transferring package balance from #".$from_pkgnum. + " to #".$cust_pkg->pkgnum.": $error\n" if $error; + + push @transfers, $cust_bill_pkg; + } # $prev_balance != 0 + + return @transfers; +} + +=item _handle_taxes PART_ITEM TAXLISTHASH CUST_BILL_PKG CUST_LOCATION TIME [ OPTIONS ] + +This is _handle_taxes. It's called once for each cust_bill_pkg generated +from _make_lines, along with the part_pkg (or part_fee), cust_location, +invoice time, a flag indicating whether the package is being canceled, and a +partridge in a pear tree. + +The most important argument is 'taxlisthash'. This is shared across the +entire invoice. It looks like this: +{ + 'cust_main_county 1001' => [ [FS::cust_main_county], ... ], + 'cust_main_county 1002' => [ [FS::cust_main_county], ... ], +} + +'cust_main_county' can also be 'tax_rate'. The first object in the array +is always the cust_main_county or tax_rate identified by the key. + +That "..." is a list of FS::cust_bill_pkg objects that will be fed to +the 'taxline' method to calculate the amount of the tax. This doesn't +happen until calculate_taxes, though. + +=cut + sub _handle_taxes { my $self = shift; - my $part_pkg = shift; + my $part_item = shift; my $taxlisthash = shift; my $cust_bill_pkg = shift; - my $cust_pkg = shift; + my $location = shift; my $invoice_time = shift; - my $real_pkgpart = shift; my $options = shift; - local($DEBUG) = $cust_main::DEBUG if $cust_main::DEBUG > $DEBUG; - - my %cust_bill_pkg = (); - my %taxes = (); - - my @classes; - #push @classes, $cust_bill_pkg->usage_classes if $cust_bill_pkg->type eq 'U'; - push @classes, $cust_bill_pkg->usage_classes if $cust_bill_pkg->usage; - push @classes, 'setup' if ($cust_bill_pkg->setup && !$options->{cancel}); - push @classes, 'recur' if ($cust_bill_pkg->recur && !$options->{cancel}); + local($DEBUG) = $FS::cust_main::DEBUG if $FS::cust_main::DEBUG > $DEBUG; - if ( $self->tax !~ /Y/i && $self->payby ne 'COMP' ) { + return if ( $self->payby eq 'COMP' ); #dubious - if ( $conf->exists('enable_taxproducts') - && ( scalar($part_pkg->part_pkg_taxoverride) - || $part_pkg->has_taxproduct - ) - ) + if ( $conf->exists('enable_taxproducts') + && ( scalar($part_item->part_pkg_taxoverride) + || $part_item->has_taxproduct + ) + ) { - if ( $conf->exists('tax-pkg_address') && $cust_pkg->locationnum ) { - return "fatal: Can't (yet) use tax-pkg_address with taxproducts"; - } + # EXTERNAL TAX RATES (via tax_rate) + my %cust_bill_pkg = (); + my %taxes = (); + + my @classes; + #push @classes, $cust_bill_pkg->usage_classes if $cust_bill_pkg->type eq 'U'; + push @classes, $cust_bill_pkg->usage_classes if $cust_bill_pkg->usage; + # debatable + push @classes, 'setup' if ($cust_bill_pkg->setup && !$options->{cancel}); + push @classes, 'recur' if ($cust_bill_pkg->recur && !$options->{cancel}); + + 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 ) { foreach my $class (@classes) { - my $err_or_ref = $self->_gather_taxes( $part_pkg, $class ); + 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; } unless (exists $taxes{''}) { - my $err_or_ref = $self->_gather_taxes( $part_pkg, '' ); + my $err_or_ref = $self->_gather_taxes($part_item, '', $location); return $err_or_ref unless ref($err_or_ref); $taxes{''} = $err_or_ref; } - } else { - - my @loc_keys = qw( city county state country ); - my %taxhash; - if ( $conf->exists('tax-pkg_address') && $cust_pkg->locationnum ) { - my $cust_location = $cust_pkg->cust_location; - %taxhash = map { $_ => $cust_location->$_() } @loc_keys; - } else { - my $prefix = - ( $conf->exists('tax-ship_address') && length($self->ship_last) ) - ? 'ship_' - : ''; - %taxhash = map { $_ => $self->get("$prefix$_") } @loc_keys; - } - - $taxhash{'taxclass'} = $part_pkg->taxclass; - - my @taxes = (); - my %taxhash_elim = %taxhash; - my @elim = qw( city county state ); - do { - - #first try a match with taxclass - @taxes = qsearch( 'cust_main_county', \%taxhash_elim ); - - if ( !scalar(@taxes) && $taxhash_elim{'taxclass'} ) { - #then try a match without taxclass - my %no_taxclass = %taxhash_elim; - $no_taxclass{ 'taxclass' } = ''; - @taxes = qsearch( 'cust_main_county', \%no_taxclass ); - } + } - $taxhash_elim{ shift(@elim) } = ''; + 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. + # 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; - } while ( !scalar(@taxes) && scalar(@elim) ); + } - @taxes = grep { ! $_->taxname or ! $self->tax_exemption($_->taxname) } - @taxes - if $self->cust_main_exemption; #just to be safe + 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}, + 'custnum' => $self->custnum, + 'invoice_time' => $invoice_time, + ); + 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}; - if ( $conf->exists('tax-pkg_address') && $cust_pkg->locationnum ) { - foreach (@taxes) { - $_->set('pkgnum', $cust_pkg->pkgnum ); - $_->set('locationnum', $cust_pkg->locationnum ); } } - - $taxes{''} = [ @taxes ]; - $taxes{'setup'} = [ @taxes ]; - $taxes{'recur'} = [ @taxes ]; - $taxes{$_} = [ @taxes ] foreach (@classes); - - # # maybe eliminate this entirely, along with all the 0% records - # unless ( @taxes ) { - # return - # "fatal: can't find tax rate for state/county/country/taxclass ". - # join('/', map $taxhash{$_}, qw(state county country taxclass) ); - # } - - } #if $conf->exists('enable_taxproducts') ... - - } - - my @display = (); - my $separate = $conf->exists('separate_usage'); - my $temp_pkg = new FS::cust_pkg { pkgpart => $real_pkgpart }; - my $usage_mandate = $temp_pkg->part_pkg->option('usage_mandate', 'Hush!'); - my $section = $temp_pkg->part_pkg->categoryname; - if ( $separate || $section || $usage_mandate ) { - - my %hash = ( 'section' => $section ); - - $section = $temp_pkg->part_pkg->option('usage_section', 'Hush!'); - my $summary = $temp_pkg->part_pkg->option('summarize_usage', 'Hush!'); - if ( $separate ) { - push @display, new FS::cust_bill_pkg_display { type => 'S', %hash }; - push @display, new FS::cust_bill_pkg_display { type => 'R', %hash }; - } else { - push @display, new FS::cust_bill_pkg_display - { type => '', - %hash, - ( ( $usage_mandate ) ? ( 'summary' => 'Y' ) : () ), - }; - } - - if ($separate && $section && $summary) { - push @display, new FS::cust_bill_pkg_display { type => 'U', - summary => 'Y', - %hash, - }; - } - if ($usage_mandate || $section && $summary) { - $hash{post_total} = 'Y'; } - if ($separate || $usage_mandate) { - $hash{section} = $section if ($separate || $usage_mandate); - push @display, new FS::cust_bill_pkg_display { type => 'U', %hash }; - } + } else { - } - $cust_bill_pkg->set('display', \@display); + # INTERNAL TAX RATES (cust_main_county) - my %tax_cust_bill_pkg = $cust_bill_pkg->disintegrate; - foreach my $key (keys %tax_cust_bill_pkg) { - my @taxes = @{ $taxes{$key} || [] }; - my $tax_cust_bill_pkg = $tax_cust_bill_pkg{$key}; + # We fetch taxes even if the customer is completely exempt, + # because we need to record that fact. - my %localtaxlisthash = (); - foreach my $tax ( @taxes ) { + my @loc_keys = qw( district city county state country ); + my %taxhash = map { $_ => $location->$_ } @loc_keys; - my $taxname = ref( $tax ). ' '. $tax->taxnum; -# $taxname .= ' pkgnum'. $cust_pkg->pkgnum. -# ' locationnum'. $cust_pkg->locationnum -# if $conf->exists('tax-pkg_address') && $cust_pkg->locationnum; + $taxhash{'taxclass'} = $part_item->taxclass; - $taxlisthash->{ $taxname } ||= [ $tax ]; - push @{ $taxlisthash->{ $taxname } }, $tax_cust_bill_pkg; + warn "taxhash:\n". Dumper(\%taxhash) if $DEBUG > 2; - $localtaxlisthash{ $taxname } ||= [ $tax ]; - push @{ $localtaxlisthash{ $taxname } }, $tax_cust_bill_pkg; + my @taxes = (); # entries are cust_main_county objects + my %taxhash_elim = %taxhash; + my @elim = qw( district city county state ); + do { - } + #first try a match with taxclass + @taxes = qsearch( 'cust_main_county', \%taxhash_elim ); - 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'); + if ( !scalar(@taxes) && $taxhash_elim{'taxclass'} ) { + #then try a match without taxclass + my %no_taxclass = %taxhash_elim; + $no_taxclass{ 'taxclass' } = ''; + @taxes = qsearch( 'cust_main_county', \%no_taxclass ); + } - foreach my $tot ( $tax_object->tax_on_tax( $self ) ) { - my $totname = ref( $tot ). ' '. $tot->taxnum; + $taxhash_elim{ shift(@elim) } = ''; - 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; - my $hashref_or_error = - $tax_object->taxline( $localtaxlisthash{$tax}, - 'custnum' => $self->custnum, - 'invoice_time' => $invoice_time, - ); - return $hashref_or_error - unless ref($hashref_or_error); - - $taxlisthash->{ $totname } ||= [ $tot ]; - push @{ $taxlisthash->{ $totname } }, $hashref_or_error->{amount}; + } while ( !scalar(@taxes) && scalar(@elim) ); - } + foreach (@taxes) { + my $tax_id = 'cust_main_county '.$_->taxnum; + $taxlisthash->{$tax_id} ||= [ $_ ]; + push @{ $taxlisthash->{$tax_id} }, $cust_bill_pkg; } } - ''; } -sub _gather_taxes { - my $self = shift; - my $part_pkg = shift; - my $class = shift; - - local($DEBUG) = $cust_main::DEBUG if $cust_main::DEBUG > $DEBUG; +=item _gather_taxes PART_ITEM CLASS CUST_LOCATION - my @taxes = (); - my $geocode = $self->geocode('cch'); +Internal method used with vendor-provided tax tables. PART_ITEM is a part_pkg +or part_fee (which will define the tax eligibility of the product), CLASS is +'setup', 'recur', null, or a C number, and CUST_LOCATION is the +location where the service was provided (or billed, depending on +configuration). Returns an arrayref of L objects that +can apply to this line item. - my @taxclassnums = map { $_->taxclassnum } - $part_pkg->part_pkg_taxoverride($class); - - unless (@taxclassnums) { - @taxclassnums = map { $_->taxclassnum } - grep { $_->taxable eq 'Y' } - $part_pkg->part_pkg_taxrate('cch', $geocode, $class); - } - warn "Found taxclassnum values of ". join(',', @taxclassnums) - if $DEBUG; +=cut - my $extra_sql = - "AND (". - join(' OR ', map { "taxclassnum = $_" } @taxclassnums ). ")"; +sub _gather_taxes { + my $self = shift; + my $part_item = shift; + my $class = shift; + my $location = shift; - @taxes = qsearch({ 'table' => 'tax_rate', - 'hashref' => { 'geocode' => $geocode, }, - 'extra_sql' => $extra_sql, - }) - if scalar(@taxclassnums); + local($DEBUG) = $FS::cust_main::DEBUG if $FS::cust_main::DEBUG > $DEBUG; - warn "Found taxes ". - join(',', map{ ref($_). " ". $_->get($_->primary_key) } @taxes). "\n" - if $DEBUG; + my $geocode = $location->geocode('cch'); - [ @taxes ]; + [ $part_item->tax_rates('cch', $geocode, $class) ] } @@ -1310,7 +1674,7 @@ Debugging level. Default is 0 (no debugging), or can be set to 1 (passed-in opt sub collect { my( $self, %options ) = @_; - local($DEBUG) = $cust_main::DEBUG if $cust_main::DEBUG > $DEBUG; + local($DEBUG) = $FS::cust_main::DEBUG if $FS::cust_main::DEBUG > $DEBUG; my $invoice_time = $options{'invoice_time'} || time; @@ -1393,8 +1757,12 @@ sub retry_realtime { my $mine = '( ' . join ( ' OR ' , map { + my $cust_join = FS::part_event->eventtables_cust_join->{$_} || ''; + my $custnum = FS::part_event->eventtables_custnum->{$_}; "( part_event.eventtable = " . dbh->quote($_) - . " AND tablenum IN( SELECT " . dbdef->table($_)->primary_key . " from $_ where custnum = " . dbh->quote( $self->custnum ) . "))" ; + . " AND tablenum IN( SELECT " . dbdef->table($_)->primary_key + . " from $_ $cust_join" + . " where $custnum = " . dbh->quote( $self->custnum ) . "))" ; } FS::part_event->eventtables) . ') '; @@ -1410,17 +1778,23 @@ sub retry_realtime { cust_bill_batch ); - my $is_realtime_event = ' ( '. join(' OR ', map "part_event.action = '$_'", - @realtime_events - ). - ' ) '; + my $is_realtime_event = + ' part_event.action IN ( '. + join(',', map "'$_'", @realtime_events ). + ' ) '; + + my $batch_or_statustext = + "( part_event.action = 'cust_bill_batch' + OR ( statustext IS NOT NULL AND statustext != '' ) + )"; - my @cust_event = qsearchs({ + + my @cust_event = qsearch({ 'table' => 'cust_event', 'select' => 'cust_event.*', 'addl_from' => "LEFT JOIN part_event USING ( eventpart ) $join", 'hashref' => { 'status' => 'done' }, - 'extra_sql' => " AND statustext IS NOT NULL AND statustext != '' ". + 'extra_sql' => " AND $batch_or_statustext ". " AND $mine AND $is_realtime_event AND $agent_virt $order" # LIMIT 1" }); @@ -1496,7 +1870,7 @@ Debugging level. Default is 0 (no debugging), or can be set to 1 (passed-in opt sub do_cust_event { my( $self, %options ) = @_; - local($DEBUG) = $cust_main::DEBUG if $cust_main::DEBUG > $DEBUG; + local($DEBUG) = $FS::cust_main::DEBUG if $FS::cust_main::DEBUG > $DEBUG; my $time = $options{'time'} || time; @@ -1554,7 +1928,7 @@ sub do_cust_event { #XXX lock event #re-eval event conditions (a previous event could have changed things) - unless ( $cust_event->test_conditions( 'time' => $time ) ) { + unless ( $cust_event->test_conditions ) { #don't leave stray "new/locked" records around my $error = $cust_event->delete; return $error if $error; @@ -1568,7 +1942,7 @@ sub do_cust_event { if $DEBUG > 1; #if ( my $error = $cust_event->do_event(%options) ) { #XXX %options? - if ( my $error = $cust_event->do_event() ) { + if ( my $error = $cust_event->do_event( 'time' => $time ) ) { #XXX wtf is this? figure out a proper dealio with return value #from do_event return $error; @@ -1625,174 +1999,6 @@ Explicitly pass the objects to be tested (typically used with eventtable). Set to true to return the objects, but not actually insert them into the database. -=item discount_terms - -Returns a list of lengths for term discounts - -=cut - -sub _discount_pkgs_and_bill { -my $self = shift; - - my @cust_bill = $self->cust_bill; - my $cust_bill = pop @cust_bill; - return () unless $cust_bill && $cust_bill->owed; - - my @where = (); - push @where, "cust_bill_pkg.invnum = ". $cust_bill->invnum; - push @where, "cust_bill_pkg.pkgpart_override IS NULL"; - push @where, "part_pkg.freq = '1'"; - push @where, "(cust_pkg.cancel IS NULL OR cust_pkg.cancel = 0)"; - push @where, "(cust_pkg.susp IS NULL OR cust_pkg.susp = 0)"; - push @where, "0<(SELECT count(*) FROM part_pkg_discount - WHERE part_pkg.pkgpart = part_pkg_discount.pkgpart)"; - push @where, - "0=(SELECT count(*) FROM cust_bill_pkg_discount - WHERE cust_bill_pkg.billpkgnum = cust_bill_pkg_discount.billpkgnum)"; - - my $extra_sql = 'WHERE '. join(' AND ', @where); - - my @cust_pkg = - qsearch({ - 'table' => 'cust_pkg', - 'select' => "DISTINCT cust_pkg.*", - 'addl_from' => 'JOIN cust_bill_pkg USING(pkgnum) '. - 'JOIN part_pkg USING(pkgpart)', - 'hashref' => {}, - 'extra_sql' => $extra_sql, - }); - - ($cust_bill, @cust_pkg); -} - -sub _discountable_pkgs_at_term { - my ($term, @pkgs) = @_; - my $part_pkg = new FS::part_pkg { freq => $term - 1 }; - grep { ( !$_->adjourn || $_->adjourn > $part_pkg->add_freq($_->bill) ) && - ( !$_->expire || $_->expire > $part_pkg->add_freq($_->bill) ) - } - @pkgs; -} - -=item discount_terms - -Returns a list of lengths for term discounts - -=cut - -sub discount_terms { -my $self = shift; - - my %terms = (); - - my @discount_pkgs = $self->_discount_pkgs_and_bill; - shift @discount_pkgs; #discard bill; - - map { $terms{$_->months} = 1 } - grep { $_->months && $_->months > 1 } - map { $_->discount } - map { $_->part_pkg->part_pkg_discount } - @discount_pkgs; - - return sort { $a <=> $b } keys %terms; - -} - -=back - -=item discount_term_values MONTHS - -Returns a list with credit, dollar amount saved, and total bill acheived -by prepaying the most recent invoice for MONTHS. - -=cut - -sub discount_term_values { - my $self = shift; - my $term = shift; - - local($DEBUG) = $cust_main::DEBUG if $cust_main::DEBUG > $DEBUG; - - warn "$me discount_term_values called with $term\n" if $DEBUG; - - my %result = (); - - my @packages = $self->_discount_pkgs_and_bill; - my $cust_bill = shift(@packages); - @packages = _discountable_pkgs_at_term( $term, @packages ); - return () unless scalar(@packages); - - $_->bill($_->last_bill) foreach @packages; - my @final = map { new FS::cust_pkg { $_->hash } } @packages; - - my %options = ( - 'recurring_only' => 1, - 'no_usage_reset' => 1, - 'no_commit' => 1, - ); - - my %params = ( - 'return_bill' => [], - 'pkg_list' => \@packages, - 'time' => $cust_bill->_date, - ); - - my $error = $self->bill(%options, %params); - die $error if $error; # XXX think about this a bit more - - my $credit = 0; - $credit += $_->charged foreach @{$params{return_bill}}; - $credit = sprintf('%.2f', $credit); - warn "$me discount_term_values $term credit: $credit\n" if $DEBUG; - - %params = ( - 'return_bill' => [], - 'pkg_list' => \@packages, - 'time' => $packages[0]->part_pkg->add_freq($cust_bill->_date) - ); - - $error = $self->bill(%options, %params); - die $error if $error; # XXX think about this a bit more - - my $next = 0; - $next += $_->charged foreach @{$params{return_bill}}; - warn "$me discount_term_values $term next: $next\n" if $DEBUG; - - %params = ( - 'return_bill' => [], - 'pkg_list' => \@final, - 'time' => $cust_bill->_date, - 'freq_override' => $term, - ); - - $error = $self->bill(%options, %params); - die $error if $error; # XXX think about this a bit more - - my $final = $self->balance - $credit; - $final += $_->charged foreach @{$params{return_bill}}; - $final = sprintf('%.2f', $final); - warn "$me discount_term_values $term final: $final\n" if $DEBUG; - - my $savings = sprintf('%.2f', $self->balance + ($term - 1) * $next - $final); - - ( $credit, $savings, $final ); - -} - -sub discount_terms_hash { - my $self = shift; - - my %result = (); - my @terms = $self->discount_terms; - foreach my $term (@terms) { - my @result = $self->discount_term_values($term); - $result{$term} = [ @result ] if scalar(@result); - } - - return %result; - -} - =back =cut @@ -1803,9 +2009,10 @@ sub due_cust_event { #??? #my $DEBUG = $opt{'debug'} + $opt{'debug'} ||= 0; # silence some warnings local($DEBUG) = $opt{'debug'} - if defined($opt{'debug'}) && $opt{'debug'} > $DEBUG; - $DEBUG = $cust_main::DEBUG if $cust_main::DEBUG > $DEBUG; + if $opt{'debug'} > $DEBUG; + $DEBUG = $FS::cust_main::DEBUG if $FS::cust_main::DEBUG > $DEBUG; warn "$me due_cust_event called with options ". join(', ', map { "$_: $opt{$_}" } keys %opt). "\n" @@ -1846,45 +2053,45 @@ sub due_cust_event { @objects = @{ $opt{'objects'} }; - } else { + } elsif ( $eventtable eq 'cust_main' ) { - #my @objects = $self->$eventtable(); # sub cust_main { @{ [ $self ] }; } - if ( $eventtable eq 'cust_main' ) { - @objects = ( $self ); - } else { + @objects = ( $self ); - my $cm_join = - "LEFT JOIN cust_main USING ( custnum )"; - - #some false laziness w/Cron::bill bill_where - - my $join = FS::part_event_condition->join_conditions_sql( $eventtable); - my $where = FS::part_event_condition->where_conditions_sql($eventtable, - 'time'=>$opt{'time'}, - ); - $where = $where ? "AND $where" : ''; - - my $are_part_event = - "EXISTS ( SELECT 1 FROM part_event $join - WHERE check_freq = '$check_freq' - AND eventtable = '$eventtable' - AND ( disabled = '' OR disabled IS NULL ) - $where - ) - "; - #eofalse - - @objects = $self->$eventtable( - 'addl_from' => $cm_join, - 'extra_sql' => " AND $are_part_event", - ); - } + } else { - } + my $cm_join = " LEFT JOIN cust_main USING ( custnum )"; + # linkage not needed here because FS::cust_main->$eventtable will + # already supply it + + #some false laziness w/Cron::bill bill_where + + my $join = FS::part_event_condition->join_conditions_sql( $eventtable); + my $where = FS::part_event_condition->where_conditions_sql($eventtable, + 'time'=>$opt{'time'}, + ); + $where = $where ? "AND $where" : ''; + + my $are_part_event = + "EXISTS ( SELECT 1 FROM part_event $join + WHERE check_freq = '$check_freq' + AND eventtable = '$eventtable' + AND ( disabled = '' OR disabled IS NULL ) + $where + ) + "; + #eofalse + + @objects = $self->$eventtable( + 'addl_from' => $cm_join, + 'extra_sql' => " AND $are_part_event", + ); + } # if ( !$opt{objects} and $eventtable ne 'cust_main' ) my @e_cust_event = (); - my $cross = "CROSS JOIN $eventtable"; + my $linkage = FS::part_event->eventtables_cust_join->{$eventtable} || ''; + + my $cross = "CROSS JOIN $eventtable $linkage"; $cross .= ' LEFT JOIN cust_main USING ( custnum )' unless $eventtable eq 'cust_main'; @@ -1932,7 +2139,9 @@ sub due_cust_event { " possible events found for $eventtable ". $object->$pkey(). "\n"; } - push @e_cust_event, map { $_->new_cust_event($object) } @part_event; + push @e_cust_event, map { + $_->new_cust_event($object, 'time' => $opt{'time'}) + } @part_event; } @@ -1966,8 +2175,7 @@ sub due_cust_event { my %unsat = (); - @cust_event = grep $_->test_conditions( 'time' => $opt{'time'}, - 'stats_hashref' => \%unsat ), + @cust_event = grep $_->test_conditions( 'stats_hashref' => \%unsat ), @cust_event; warn " ". scalar(@cust_event). " cust events left satisfying conditions\n" @@ -2220,11 +2428,14 @@ sub apply_payments { my $amount = min( $payment->unapplied, $owed ); - my $cust_bill_pay = new FS::cust_bill_pay ( { + my $cbp = { 'paynum' => $payment->paynum, 'invnum' => $cust_bill->invnum, 'amount' => $amount, - } ); + }; + $cbp->{_date} = $payment->_date + if $options{'manual'} && $options{'backdate_application'}; + my $cust_bill_pay = new FS::cust_bill_pay($cbp); $cust_bill_pay->pkgnum( $payment->pkgnum ) if $conf->exists('pkg-balances') && $payment->pkgnum; my $error = $cust_bill_pay->insert(%options); @@ -2244,6 +2455,30 @@ sub apply_payments { return $total_unapplied_payments; } +=back + +=head1 FLOW + + bill_and_collect + + cancel_expired_pkgs + suspend_adjourned_pkgs + unsuspend_resumed_pkgs + + bill + (do_cust_event pre-bill) + _make_lines + _handle_taxes + (vendor-only) _gather_taxes + _omit_zero_value_bundles + _handle_taxes (for fees) + calculate_taxes + + apply_payments_and_credits + collect + do_cust_event + due_cust_event + =head1 BUGS =head1 SEE ALSO