RT#31594: Unapplied payment issues

[freeside.git] / FS / FS / cust_main / Billing.pm
diff --git a/FS/FS/cust_main/Billing.pm b/FS/FS/cust_main/Billing.pm

index e004788..908f486 100644 (file)
--- a/FS/FS/cust_main/Billing.pm
+++ b/FS/FS/cust_main/Billing.pm
@@ -7,12 +7,13 @@ use Data::Dumper;
  use List::Util qw( min );
  use FS::UID qw( dbh );
  use FS::Record qw( qsearch qsearchs dbdef );
  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 Tie::RefHash;
  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_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;
  use FS::cust_tax_adjustment;
  use FS::tax_rate;
  use FS::tax_rate_location;
@@ -20,6 +21,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::cust_bill_pkg_tax_rate_location;
  use FS::part_event;
  use FS::part_event_condition;
+use FS::pkg_category;
+use FS::FeeOrigin_Mixin;
+use FS::Log;
  
  # 1 is mostly method/subroutine entry and options
  # 2 traces progress of some operations
  
  # 1 is mostly method/subroutine entry and options
  # 2 traces progress of some operations
@@ -103,6 +107,10 @@ options of those methods are also available.
  sub bill_and_collect {
    my( $self, %options ) = @_;
  
  sub bill_and_collect {
    my( $self, %options ) = @_;
  
+  my $log = FS::Log->new('FS::cust_main::Billing::bill_and_collect');
+  my %logopt = (object => $self);
+  $log->debug('start', %logopt);
+
    my $error;
  
    #$options{actual_time} not $options{time} because freeside-daily -d is for
    my $error;
  
    #$options{actual_time} not $options{time} because freeside-daily -d is for
@@ -111,8 +119,14 @@ sub bill_and_collect {
    $options{'actual_time'} ||= time;
    my $job = $options{'job'};
  
    $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;
    $job->update_statustext('0,cleaning expired packages') if $job;
-  $error = $self->cancel_expired_pkgs( $options{actual_time} );
+  $log->debug('canceling expired packages', %logopt);
+  $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; }
    if ( $error ) {
      $error = "Error expiring custnum ". $self->custnum. ": $error";
      if    ( $options{fatal} && $options{fatal} eq 'return' ) { return $error; }
@@ -120,7 +134,8 @@ sub bill_and_collect {
      else                                                     { warn   $error; }
    }
  
      else                                                     { warn   $error; }
    }
  
-  $error = $self->suspend_adjourned_pkgs( $options{actual_time} );
+  $log->debug('suspending adjourned packages', %logopt);
+  $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; }
    if ( $error ) {
      $error = "Error adjourning custnum ". $self->custnum. ": $error";
      if    ( $options{fatal} && $options{fatal} eq 'return' ) { return $error; }
@@ -128,7 +143,17 @@ sub bill_and_collect {
      else                                                     { warn   $error; }
    }
  
      else                                                     { warn   $error; }
    }
  
+  $log->debug('unsuspending resumed packages', %logopt);
+  $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;
    $job->update_statustext('20,billing packages') if $job;
+  $log->debug('billing packages', %logopt);
    $error = $self->bill( %options );
    if ( $error ) {
      $error = "Error billing custnum ". $self->custnum. ": $error";
    $error = $self->bill( %options );
    if ( $error ) {
      $error = "Error billing custnum ". $self->custnum. ": $error";
@@ -138,6 +163,7 @@ sub bill_and_collect {
    }
  
    $job->update_statustext('50,applying payments and credits') if $job;
    }
  
    $job->update_statustext('50,applying payments and credits') if $job;
+  $log->debug('applying payments and credits', %logopt);
    $error = $self->apply_payments_and_credits;
    if ( $error ) {
      $error = "Error applying custnum ". $self->custnum. ": $error";
    $error = $self->apply_payments_and_credits;
    if ( $error ) {
      $error = "Error applying custnum ". $self->custnum. ": $error";
@@ -146,10 +172,11 @@ sub bill_and_collect {
      else                                                     { warn   $error; }
    }
  
      else                                                     { warn   $error; }
    }
  
-  $job->update_statustext('70,running collection events') if $job;
    unless ( $conf->exists('cancelled_cust-noevents')
             && ! $self->num_ncancelled_pkgs
    ) {
    unless ( $conf->exists('cancelled_cust-noevents')
             && ! $self->num_ncancelled_pkgs
    ) {
+    $job->update_statustext('70,running collection events') if $job;
+    $log->debug('running collection events', %logopt);
      $error = $self->collect( %options );
      if ( $error ) {
        $error = "Error collecting custnum ". $self->custnum. ": $error";
      $error = $self->collect( %options );
      if ( $error ) {
        $error = "Error collecting custnum ". $self->custnum. ": $error";
@@ -158,7 +185,9 @@ sub bill_and_collect {
        else                                                   { warn   $error; }
      }
    }
        else                                                   { warn   $error; }
      }
    }
+
    $job->update_statustext('100,finished') if $job;
    $job->update_statustext('100,finished') if $job;
+  $log->debug('finish', %logopt);
  
    '';
  
  
    '';
  
@@ -166,30 +195,47 @@ sub bill_and_collect {
  
  sub cancel_expired_pkgs {
    my ( $self, $time, %options ) = @_;
  
  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 = ();
  
    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 $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;
    }
  
      push @errors, 'pkgnum '.$cust_pkg->pkgnum.": $error" if $error;
    }
  
-  scalar(@errors) ? join(' / ', @errors) : '';
+  join(' / ', @errors);
  
  }
  
  sub suspend_adjourned_pkgs {
    my ( $self, $time, %options ) = @_;
  
  }
  
  sub suspend_adjourned_pkgs {
    my ( $self, $time, %options ) = @_;
-
+  
    my @susp_pkgs = $self->ncancelled_pkgs( {
      'extra_sql' =>
        " AND ( susp IS NULL OR susp = 0 )
    my @susp_pkgs = $self->ncancelled_pkgs( {
      'extra_sql' =>
        " AND ( susp IS NULL OR susp = 0 )
@@ -225,7 +271,25 @@ sub suspend_adjourned_pkgs {
      push @errors, 'pkgnum '.$cust_pkg->pkgnum.": $error" if $error;
    }
  
      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 +316,9 @@ charges, etc.
  =item freq_override
  
  If set, then override the normal frequency and look for a part_pkg_discount
  =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<pkg_list> to limit the set of packages included in billing.
  
  =item time
  
  
  =item time
  
@@ -272,6 +338,10 @@ An array ref of specific packages (objects) to attempt billing, instead trying a
  
  A hashref of pkgparts to exclude from this billing run (can also be specified as a comma-separated scalar).
  
  
  A hashref of pkgparts to exclude from this billing run (can also be specified as a comma-separated scalar).
  
+=item no_prepaid
+
+Do not bill prepaid packages.  Used by freeside-daily.
+
  =item invoice_time
  
  Used in conjunction with the I<time> option, this option specifies the date of for the generated invoices.  Other calculations, such as whether or not to generate the invoice in the first place, are not affected.
  =item invoice_time
  
  Used in conjunction with the I<time> option, this option specifies the date of for the generated invoices.  Other calculations, such as whether or not to generate the invoice in the first place, are not affected.
@@ -310,13 +380,21 @@ sub bill {
    return '' if $self->payby eq 'COMP';
  
    local($DEBUG) = $FS::cust_main::DEBUG if $FS::cust_main::DEBUG > $DEBUG;
    return '' if $self->payby eq 'COMP';
  
    local($DEBUG) = $FS::cust_main::DEBUG if $FS::cust_main::DEBUG > $DEBUG;
+  my $log = FS::Log->new('FS::cust_main::Billing::bill');
+  my %logopt = (object => $self);
  
  
+  $log->debug('start', %logopt);
    warn "$me bill customer ". $self->custnum. "\n"
      if $DEBUG;
  
    my $time = $options{'time'} || time;
    my $invoice_time = $options{'invoice_time'} || $time;
  
    warn "$me bill customer ". $self->custnum. "\n"
      if $DEBUG;
  
    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'})
    $options{'not_pkgpart'} ||= {};
    $options{'not_pkgpart'} = { map { $_ => 1 }
                                    split(/\s*,\s*/, $options{'not_pkgpart'})
@@ -334,11 +412,13 @@ sub bill {
    local $FS::UID::AutoCommit = 0;
    my $dbh = dbh;
  
    local $FS::UID::AutoCommit = 0;
    my $dbh = dbh;
  
+  $log->debug('acquiring lock', %logopt);
    warn "$me acquiring lock on customer ". $self->custnum. "\n"
      if $DEBUG;
  
    $self->select_for_update; #mutex
  
    warn "$me acquiring lock on customer ". $self->custnum. "\n"
      if $DEBUG;
  
    $self->select_for_update; #mutex
  
+  $log->debug('running pre-bill events', %logopt);
    warn "$me running pre-bill events for customer ". $self->custnum. "\n"
      if $DEBUG;
  
    warn "$me running pre-bill events for customer ". $self->custnum. "\n"
      if $DEBUG;
  
@@ -354,6 +434,7 @@ sub bill {
      return $error;
    }
  
      return $error;
    }
  
+  $log->debug('done running pre-bill events', %logopt);
    warn "$me done running pre-bill events for customer ". $self->custnum. "\n"
      if $DEBUG;
  
    warn "$me done running pre-bill events for customer ". $self->custnum. "\n"
      if $DEBUG;
  
@@ -375,45 +456,104 @@ sub bill {
    my @precommit_hooks = ();
  
    $options{'pkg_list'} ||= [ $self->ncancelled_pkgs ];  #param checks?
    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};
  
    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;
+    my $part_pkg = $cust_pkg->part_pkg;
+
+    next if $options{'no_prepaid'} && $part_pkg->is_prepaid;
+
+    $log->debug('bill package '. $cust_pkg->pkgnum, %logopt);
+    warn "  bill package ". $cust_pkg->pkgnum. "\n" if $DEBUG;
  
      #? to avoid use of uninitialized value errors... ?
      $cust_pkg->setfield('bill', '')
        unless defined($cust_pkg->bill);
   
  
      #? to avoid use of uninitialized value errors... ?
      $cust_pkg->setfield('bill', '')
        unless defined($cust_pkg->bill);
   
-    #my $part_pkg = $cust_pkg->part_pkg;
-
      my $real_pkgpart = $cust_pkg->pkgpart;
      my %hash = $cust_pkg->hash;
  
      # we could implement this bit as FS::part_pkg::has_hidden, but we already
      # suffer from performance issues
      $options{has_hidden} = 0;
      my $real_pkgpart = $cust_pkg->pkgpart;
      my %hash = $cust_pkg->hash;
  
      # we could implement this bit as FS::part_pkg::has_hidden, but we already
      # suffer from performance issues
      $options{has_hidden} = 0;
-    my @part_pkg = $cust_pkg->part_pkg->self_and_bill_linked;
+    my @part_pkg = $part_pkg->self_and_bill_linked;
      $options{has_hidden} = 1 if ($part_pkg[1] && $part_pkg[1]->hidden);
   
      $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;
+
+      # 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 );
  
      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 $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 };
+          $taxlisthash{$pass} = {};
+          $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;
+      # 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;
        if ($error) {
          $dbh->rollback if $oldAutoCommit && !$options{no_commit};
          return $error;
@@ -423,22 +563,112 @@ sub bill {
  
    } #foreach my $cust_pkg
  
  
    } #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} });
  
  
      my @cust_bill_pkg = _omit_zero_value_bundles(@{ $cust_bill_pkg{$pass} });
  
-    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"
        if $DEBUG > 2;
  
      warn "$me billing pass $pass\n"
             #.Dumper(\@cust_bill_pkg)."\n"
        if $DEBUG > 2;
  
+    ###
+    # process fees
+    ###
+
+    my @pending_fees = FS::FeeOrigin_Mixin->by_cust($self->custnum,
+      hashref => { 'billpkgnum' => '' }
+    );
+    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 $fee (@pending_fees) {
+      $generate_bill = 1 unless $fee->nextbill;
+    }
+    
+    # don't create an invoice with no line items, or where the only line 
+    # items are fees that are supposed to be held until the next invoice
+    next if !$generate_bill;
+
+    # calculate fees...
+    my @fee_items;
+    foreach my $fee_origin (@pending_fees) {
+      my $part_fee = $fee_origin->part_fee;
+
+      # 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.
+      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';
+
+      # 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('fee_origin', $fee_origin);
+      push @fee_items, $fee_item;
+
+    }
+    
+    # add fees to the invoice
+    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(
+        $taxlisthash{$pass},
+        $fee_item,
+        location => $fee_location
+        # probably not right to pass cancel => 1 for fees
+      );
+      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')
         )
      if ( scalar( grep { $_->recur && $_->recur > 0 } @cust_bill_pkg) ||
             !$conf->exists('postal_invoice-recurring_only')
         )
@@ -532,22 +762,23 @@ sub bill {
  
      my $charged = sprintf('%.2f', ${ $total_setup{$pass} } + ${ $total_recur{$pass} } );
  
  
      my $charged = sprintf('%.2f', ${ $total_setup{$pass} } + ${ $total_recur{$pass} } );
  
-    my @cust_bill = $self->cust_bill;
      my $balance = $self->balance;
      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 = qsearchs({ 'table'     => 'cust_bill',
+                                   'hashref'   => { custnum=>$self->custnum },
+                                   'extra_sql' => 'ORDER BY _date DESC LIMIT 1',
+                                });
+    my $previous_balance =
+      $previous_bill
+        ? ( $previous_bill->billing_balance + $previous_bill->charged )
+        : 0;
  
  
+    $log->debug('creating the new invoice', %logopt);
      warn "creating the new invoice\n" if $DEBUG;
      #create the new invoice
      my $cust_bill = new FS::cust_bill ( {
        'custnum'             => $self->custnum,
      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,
        'charged'             => $charged,
        'billing_balance'     => $balance,
        'previous_balance'    => $previous_balance,
@@ -580,21 +811,52 @@ sub bill {
  
  #discard bundled packages of 0 value
  sub _omit_zero_value_bundles {
  
  #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 @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) {
      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;
      }
        @cust_bill_pkg_bundle = ();
        $sum = 0;
      }
+
      $sum += $cust_bill_pkg->setup + $cust_bill_pkg->recur;
      push @cust_bill_pkg_bundle, $cust_bill_pkg;
      $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);
  
  
    (@cust_bill_pkg);
  
@@ -602,8 +864,6 @@ sub _omit_zero_value_bundles {
  
  =item calculate_taxes LINEITEMREF TAXHASHREF INVOICE_TIME
  
  
  =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<FS::cust_bill_pkg>) for this customer.
  Usually used internally by bill method B<bill>.
  
  Generates tax line items (see L<FS::cust_bill_pkg>) for this customer.
  Usually used internally by bill method B<bill>.
  
@@ -641,112 +901,210 @@ jurisdictions (i.e. Texas) have tax exemptions which are date sensitive.
  sub calculate_taxes {
    my ($self, $cust_bill_pkg, $taxlisthash, $invoice_time) = @_;
  
  sub calculate_taxes {
    my ($self, $cust_bill_pkg, $taxlisthash, $invoice_time) = @_;
  
+  # $taxlisthash is a hashref
+  # keys are identifiers, values are arrayrefs
+  # each arrayref starts with a tax object (cust_main_county or tax_rate)
+  # then a cust_bill_pkg object the tax applies to, then the charge class
+  # on that object (setup, recur, a usage class number, or '')
+  # For internal taxes the charge class is always undef.
+
    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"
      if $DEBUG > 2;
  
    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"
      if $DEBUG > 2;
  
-  my @tax_line_items = ();
-
-  # keys are tax names (as printed on invoices / itemdesc )
-  # values are listrefs of taxlisthash keys (internal identifiers)
+  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.
+  # keys are tax names
+  # values are arrayrefs of tax lines
    my %taxname = ();
  
    # keys are taxlisthash keys (internal identifiers)
    # values are (cumulative) amounts
    my %taxname = ();
  
    # keys are taxlisthash keys (internal identifiers)
    # values are (cumulative) amounts
-  my %tax = ();
-
-  # keys are taxlisthash keys (internal identifiers)
-  # values are listrefs of cust_bill_pkg_tax_location hashrefs
-  my %tax_location = ();
+  my %tax_amount = ();
+
+  # keys are taxlisthash keys
+  # 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 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;
+
+  foreach my $tax_id ( keys %$taxlisthash ) {
+    # $tax_id: the identifier of the tax we are calculating in this pass
+
+    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,
+    # optionally followed by their charge classes.
+    warn "found ". $tax_object->taxname. " as $tax_id\n" if $DEBUG > 2;
+
+    # taxline calculates the tax on all cust_bill_pkgs in the 
+    # first (arrayref) argument.
+    #
+    # Note that non-monthly exemptions have already been calculated and 
+    # attached to the items.  Monthly exemptions will be attached in this
+    # step.
+    my $exemptions = $tax_exemption{$tax_id} ||= [];
+    if ( $tax_object->isa('FS::tax_rate') ) { # EXTERNAL TAXES
+      # STILL have tax_rate-specific crap in here...
+      my @taxlines = $tax_object->taxline( $taxables,
+                              '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 $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}{$taxline->_class}{$taxnum} = $taxline;
+      }
  
  
-  # keys are taxlisthash keys (internal identifiers)
-  # values are listrefs of cust_bill_pkg_tax_rate_location hashrefs
-  my %tax_rate_location = ();
-
-  foreach my $tax ( keys %$taxlisthash ) {
-    my $tax_object = shift @{ $taxlisthash->{$tax} };
-    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},
-                            'custnum'      => $self->custnum,
-                            'invoice_time' => $invoice_time
-                          );
-    return $hashref_or_error unless ref($hashref_or_error);
-
-    unshift @{ $taxlisthash->{$tax} }, $tax_object;
-
-    my $name   = $hashref_or_error->{'name'};
-    my $amount = $hashref_or_error->{'amount'};
-
-    #warn "adding $amount as $name\n";
-    $taxname{ $name } ||= [];
-    push @{ $taxname{ $name } }, $tax;
-
-    $tax{ $tax } += $amount;
-
-    $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 ),
-        };
+    } else { # INTERNAL TAXES
+      # we can do this in a single taxline, because it's not stupid
+
+      my $taxline =  $tax_object->taxline( $taxables,
+                        '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 $custnum\n";
+        return $taxline;
+      }
+      # if the calculated tax is zero, don't even keep it
+      next if $taxline->setup < 0.001;
+      push @{ $taxname{ $taxline->itemdesc } }, $taxline;
      }
      }
+  }
+  $DB::single = 1; # XXX
  
  
-    $tax_rate_location{ $tax } ||= [];
-    if ( ref($tax_object) eq 'FS::tax_rate' ) {
-      my $taxratelocationnum =
-        $tax_object->tax_rate_location->taxratelocationnum;
-      push @{ $tax_rate_location{ $tax }  },
-        {
-          'taxnum'             => $tax_object->taxnum, 
-          'taxtype'            => ref($tax_object),
-          'amount'             => sprintf('%.2f', $amount ),
-          'locationtaxid'      => $tax_object->location,
-          'taxratelocationnum' => $taxratelocationnum,
-        };
-    }
+  # all first-tier taxes are calculated.  now for tax on tax:
  
  
-  }
+  foreach my $taxable_item ( @$cust_bill_pkg ) {
+    # taxes that apply to this item
+    my $this_has_tax = $item_has_tax{$taxable_item};
  
  
-  #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 } );
-    }
-  }
+    my $location = $taxable_item->tax_location;
+
+    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;
+        # 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
    warn "consolidating and generating...\n" if $DEBUG > 2;
  
    #consolidate and create tax line items
    warn "consolidating and generating...\n" if $DEBUG > 2;
+  my %final_tax_items; # taxname => item
    foreach my $taxname ( keys %taxname ) {
    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 %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} } ) {
      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 } };
+      next if $taxitem->get('setup') == 0;
+      # if ( ref($taxitem) eq 'FS::cust_bill_pkg' )  # always true
+      # 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;
+      my @links = @{
+        $taxitem->get('cust_bill_pkg_tax_location') ||
+        $taxitem->get('cust_bill_pkg_tax_rate_location') ||
+        []
+      };
+      foreach my $link ( @links ) {
+        $link->set('tax_cust_bill_pkg', $tax_cust_bill_pkg);
+        if ($link->isa('FS::cust_bill_pkg_tax_location')) {
+          push @cust_bill_pkg_tax_location, $link;
+        } elsif ($link->isa('FS::cust_bill_pkg_tax_rate_location')) {
+          push @cust_bill_pkg_tax_rate_location, $link;
+        }
+      }
      }
      }
-    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'     => '',
    
      my $pkg_category = qsearchs( 'pkg_category', { 'categoryname' => $taxname,
                                                     'disabled'     => '',
@@ -764,22 +1122,23 @@ sub calculate_taxes {
        push @display, new FS::cust_bill_pkg_display { type => 'S', %hash };
  
      }
        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,
-    };
-
+    $final_tax_items{$taxname} = $tax_cust_bill_pkg;
+  } # foreach $taxname
+  
+  # fix ToT backlinks for taxes that have been consolidated
+  # (has to be done in a separate pass)
+  foreach my $tax_item (values %final_tax_items) {
+    foreach my $taxable_link (@{ $tax_item->cust_bill_pkg_tax_rate_location }) {
+      my $taxed_item = $taxable_link->taxable_cust_bill_pkg;
+      next if $taxed_item->pkgnum > 0; # primary taxes
+      my $taxname = $taxed_item->itemdesc;
+      $taxable_link->set('taxable_cust_bill_pkg', $final_tax_items{ $taxname });
+    }
    }
  
    }
  
-  \@tax_line_items;
+  [ values %final_tax_items ]
  }
  
  sub _make_lines {
  }
  
  sub _make_lines {
@@ -789,7 +1148,8 @@ sub _make_lines {
  
    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 $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";
    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";
@@ -797,46 +1157,71 @@ sub _make_lines {
    my $time = $params{'time'} or die "no time specified";
    my (%options) = %{$params{options}};
  
    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 $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 $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;
    ###
    # 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,
+                      'real_pkgpart' => $params{real_pkgpart}
+                    );
+  # Conditions for setting setup date and charging the setup fee:
+  # - this is not a recurring-only billing run
+  # - and the package is not currently being canceled
+  # - and, unless we're specifically told otherwise via 'resetup':
+  #   - it doesn't already HAVE a setup date
+  #   - or a start date in the future
+  #   - and it's not suspended
+  #
+  # 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.
+  if (     ! $options{recurring_only}
+       and ! $options{cancel}
+       and ( $options{'resetup'}
+             || ( ! $cust_pkg->setup
+                  && ( ! $cust_pkg->start_date
+                       || $cust_pkg->start_date <= $cmp_time
+                     )
+                  && ( ! $cust_pkg->getfield('susp') )
+              )
+           )
+     )
    {
      
      warn "    bill setup\n" if $DEBUG > 1;
    {
      
      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->part_pkg->unit_setup || $setup; #XXX uuh
+    }
  
      $cust_pkg->setfield('setup', $time)
        unless $cust_pkg->setup;
  
      $cust_pkg->setfield('setup', $time)
        unless $cust_pkg->setup;
@@ -852,14 +1237,24 @@ sub _make_lines {
    # bill recurring fee
    ### 
  
    # bill recurring fee
    ### 
  
-  #XXX unit stuff here too
    my $recur = 0;
    my $unitrecur = 0;
    my $recur = 0;
    my $unitrecur = 0;
+  my @recur_discounts = ();
    my $sdate;
    if (     ! $cust_pkg->start_date
    my $sdate;
    if (     ! $cust_pkg->start_date
-       and ( ! $cust_pkg->susp || $part_pkg->option('suspend_bill') )
+       and 
+           ( ! $cust_pkg->susp
+               || ( $cust_pkg->susp != $cust_pkg->order_date
+                      && (    $cust_pkg->option('suspend_bill',1)
+                           || ( $part_pkg->option('suspend_bill', 1)
+                                 && ! $cust_pkg->option('no_suspend_bill',1)
+                              )
+                         )
+                  )
+               || $cust_pkg->is_status_delay_cancel
+           )
         and
         and
-            ( $part_pkg->freq ne '0' && ( $cust_pkg->bill || 0 ) <= $time )
+            ( $part_pkg->freq ne '0' && ( $cust_pkg->bill || 0 ) <= $cmp_time )
           || ( $part_pkg->plan eq 'voip_cdr'
                 && $part_pkg->option('bill_every_call')
              )
           || ( $part_pkg->plan eq 'voip_cdr'
                 && $part_pkg->option('bill_every_call')
              )
@@ -883,30 +1278,71 @@ 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'
  
      #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}
                                );
                                  && !$options{cancel}
                                );
-    my %param = ( 'precommit_hooks'     => $precommit_hooks,
+    my %param = ( %setup_param,
+                  'precommit_hooks'     => $precommit_hooks,
                    'increment_next_bill' => $increment_next_bill,
                    'increment_next_bill' => $increment_next_bill,
-                  'discounts'           => \@discounts,
+                  'discounts'           => \@recur_discounts,
                    'real_pkgpart'        => $real_pkgpart,
                    'freq_override'      => $options{freq_override} || '',
                    '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.
                  );
  
      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 ( $@ );
  
      $recur = eval { $cust_pkg->$method( \$sdate, \@details, \%param ) };
      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 ( $increment_next_bill ) {
  
      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;
        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
    
        #pro-rating magic - if $recur_prog fiddled $sdate, want to use that
        # only for figuring next bill date, nothing else, so, reset $sdate again
@@ -919,6 +1355,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);
    }
  
    warn "\$setup is undefined" unless defined($setup);
@@ -939,6 +1389,7 @@ sub _make_lines {
          if $DEBUG >1;
    
        my $error = $cust_pkg->replace( $old_cust_pkg,
          if $DEBUG >1;
    
        my $error = $cust_pkg->replace( $old_cust_pkg,
+                                      'depend_jobnum'=>$options{depend_jobnum},
                                        'options' => { $cust_pkg->options },
                                      )
          unless $options{no_commit};
                                        'options' => { $cust_pkg->options },
                                      )
          unless $options{no_commit};
@@ -955,9 +1406,18 @@ sub _make_lines {
        return "negative recur $recur for pkgnum ". $cust_pkg->pkgnum;
      }
  
        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"
      {
  
        warn "    charges (setup=$setup, recur=$recur); adding line items\n"
@@ -978,16 +1438,21 @@ sub _make_lines {
          'unitrecur' => $unitrecur,
          'quantity'  => $cust_pkg->quantity,
          'details'   => \@details,
          'unitrecur' => $unitrecur,
          'quantity'  => $cust_pkg->quantity,
          'details'   => \@details,
-        'discounts' => \@discounts,
+        'discounts' => [ @setup_discounts, @recur_discounts ],
          'hidden'    => $part_pkg->hidden,
          'freq'      => $part_pkg->freq,
        };
  
          '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};
          $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};
          $cust_bill_pkg->sdate( $sdate );
          $cust_bill_pkg->edate( $cust_pkg->bill );
          #$cust_bill_pkg->edate( $time ) if $options{cancel};
@@ -1003,10 +1468,15 @@ sub _make_lines {
        # handle taxes
        ###
  
        # 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( $taxlisthash, $cust_bill_pkg,
+        cancel => $options{cancel} );
        return $error if $error;
  
        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
        push @$cust_bill_pkgs, $cust_bill_pkg;
  
      } #if $setup != 0 || $recur != 0
@@ -1017,249 +1487,285 @@ sub _make_lines {
  
  }
  
  
  }
  
-sub _handle_taxes {
+=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<its> 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 $self = shift;
-  my $part_pkg = shift;
-  my $taxlisthash = shift;
-  my $cust_bill_pkg = shift;
    my $cust_pkg = shift;
    my $cust_pkg = shift;
-  my $invoice_time = shift;
-  my $real_pkgpart = shift;
-  my $options = shift;
+  my $from_pkgnum = shift || $cust_pkg->change_pkgnum;
+  my $from_pkg = FS::cust_pkg->by_key($from_pkgnum);
  
  
-  local($DEBUG) = $FS::cust_main::DEBUG if $FS::cust_main::DEBUG > $DEBUG;
+  my @transfers;
  
  
-  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});
+  # 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;
  
  
-  if ( $self->tax !~ /Y/i && $self->payby ne 'COMP' ) {
+    push @transfers, $cust_bill_pkg;
+  } # $prev_balance != 0
  
  
-    if ( $conf->exists('enable_taxproducts')
-         && ( scalar($part_pkg->part_pkg_taxoverride)
-              || $part_pkg->has_taxproduct
-            )
-       )
-    {
+  return @transfers;
+}
  
  
-      foreach my $class (@classes) {
-        my $err_or_ref = $self->_gather_taxes( $part_pkg, $class, $cust_pkg );
-        return $err_or_ref unless ref($err_or_ref);
-        $taxes{$class} = $err_or_ref;
-      }
+=item handle_taxes TAXLISTHASH CUST_BILL_PKG [ OPTIONS ]
  
  
-      unless (exists $taxes{''}) {
-        my $err_or_ref = $self->_gather_taxes( $part_pkg, '', $cust_pkg );
-        return $err_or_ref unless ref($err_or_ref);
-        $taxes{''} = $err_or_ref;
-      }
+This is _handle_taxes.  It's called once for each cust_bill_pkg generated
+from _make_lines.
  
  
-    } else {
+TAXLISTHASH is a hashref 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], ... ],
+}
  
  
-      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;
-      }
+'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.
  
  
-      $taxhash{'taxclass'} = $part_pkg->taxclass;
+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.
  
  
-      my @taxes = ();
-      my %taxhash_elim = %taxhash;
-      my @elim = qw( city county state );
-      do { 
+OPTIONS may include:
+- part_item: a part_pkg or part_fee object to be used as the package/fee 
+  definition.
+- location: a cust_location to be used as the billing location.
+- cancel: true if this package is being billed on cancellation.  This 
+  allows tax to be calculated on usage charges only.
  
  
-        #first try a match with taxclass
-        @taxes = qsearch( 'cust_main_county', \%taxhash_elim );
+If not supplied, part_item will be inferred from the pkgnum or feepart of the
+cust_bill_pkg, and location from the pkgnum (or, for fees, the invnum and 
+the customer's default service location).
  
  
-        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 );
-        }
+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.
  
  
-        $taxhash_elim{ shift(@elim) } = '';
+=cut
+
+sub _handle_taxes {
+  my $self = shift;
+  my $taxlisthash = shift;
+  my $cust_bill_pkg = shift;
+  my %options = @_;
  
  
-      } while ( !scalar(@taxes) && scalar(@elim) );
+  # at this point I realize that we have enough information to infer all this
+  # stuff, instead of passing around giant honking argument lists
+  my $location = $options{location} || $cust_bill_pkg->tax_location;
+  my $part_item = $options{part_item} || $cust_bill_pkg->part_X;
  
  
-      @taxes = grep { ! $_->taxname or ! $self->tax_exemption($_->taxname) }
-                    @taxes
-        if $self->cust_main_exemption; #just to be safe
+  local($DEBUG) = $FS::cust_main::DEBUG if $FS::cust_main::DEBUG > $DEBUG;
  
  
-      if ( $conf->exists('tax-pkg_address') && $cust_pkg->locationnum ) {
-        foreach (@taxes) {
-          $_->set('pkgnum',      $cust_pkg->pkgnum );
-          $_->set('locationnum', $cust_pkg->locationnum );
-        }
-      }
+  return if ( $self->payby eq 'COMP' ); #dubious
  
  
-      $taxes{''} = [ @taxes ];
-      $taxes{'setup'} = [ @taxes ];
-      $taxes{'recur'} = [ @taxes ];
-      $taxes{$_} = [ @taxes ] foreach (@classes);
+  if ( $conf->exists('enable_taxproducts')
+       && ( scalar($part_item->part_pkg_taxoverride)
+            || $part_item->has_taxproduct
+          )
+     )
+    {
  
  
-      # # 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) );
-      # }
+    # EXTERNAL TAX RATES (via tax_rate)
+    my %cust_bill_pkg = ();
+    my %taxes = ();
+
+    my @classes;
+    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 - $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 ) {
+
+    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;
+    }
  
  
-    } #if $conf->exists('enable_taxproducts') ...
+    # 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.
  
  
-  }
+    # only calculate exemptions once for each tax rate, even if it's used
+    # for multiple classes
+    my %tax_seen = ();
   
   
-  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' ) : () ),
-                       };
-    }
+    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;
+
+      foreach my $tax ( @taxes ) {
+
+        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), 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;
+        }
  
  
-    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';
-    }
+        # tax on tax will be done later, when we actually create the tax
+        # line items
  
  
-    if ($separate || $usage_mandate) {
-      $hash{section} = $section if ($separate || $usage_mandate);
-      push @display, new FS::cust_bill_pkg_display { type => 'U', %hash };
+      }
      }
  
      }
  
-  }
-  $cust_bill_pkg->set('display', \@display);
+  } else {
  
  
-  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};
+    # INTERNAL TAX RATES (cust_main_county)
  
  
-    my %localtaxlisthash = ();
-    foreach my $tax ( @taxes ) {
+    # We fetch taxes even if the customer is completely exempt,
+    # because we need to record that fact.
  
  
-      my $taxname = ref( $tax ). ' '. $tax->taxnum;
-#      $taxname .= ' pkgnum'. $cust_pkg->pkgnum.
-#                  ' locationnum'. $cust_pkg->locationnum
-#        if $conf->exists('tax-pkg_address') && $cust_pkg->locationnum;
+    my @loc_keys = qw( district city county state country );
+    my %taxhash = map { $_ => $location->$_ } @loc_keys;
  
  
-      $taxlisthash->{ $taxname } ||= [ $tax ];
-      push @{ $taxlisthash->{ $taxname  } }, $tax_cust_bill_pkg;
+    $taxhash{'taxclass'} = $part_item->taxclass;
  
  
-      $localtaxlisthash{ $taxname } ||= [ $tax ];
-      push @{ $localtaxlisthash{ $taxname  } }, $tax_cust_bill_pkg;
+    warn "taxhash:\n". Dumper(\%taxhash) if $DEBUG > 2;
  
  
-    }
+    my @taxes = (); # entries are cust_main_county objects
+    my %taxhash_elim = %taxhash;
+    my @elim = qw( district city county state );
+    do { 
  
  
-    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');
+      #first try a match with taxclass
+      @taxes = qsearch( 'cust_main_county', \%taxhash_elim );
  
  
-      foreach my $tot ( $tax_object->tax_on_tax( $self ) ) {
-        my $totname = ref( $tot ). ' '. $tot->taxnum;
+      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 );
+      }
  
  
-        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};
+      $taxhash_elim{ shift(@elim) } = '';
  
  
-      }
+    } while ( !scalar(@taxes) && scalar(@elim) );
+
+    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;
      }
  
    }
      }
  
    }
-
    '';
  }
  
    '';
  }
  
+=item _gather_taxes PART_ITEM CLASS CUST_LOCATION
+
+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<usage_class> number, and CUST_LOCATION is the 
+location where the service was provided (or billed, depending on 
+configuration).  Returns an arrayref of L<FS::tax_rate> objects that 
+can apply to this line item.
+
+=cut
+
  sub _gather_taxes {
    my $self = shift;
  sub _gather_taxes {
    my $self = shift;
-  my $part_pkg = shift;
+  my $part_item = shift;
    my $class = shift;
    my $class = shift;
-  my $cust_pkg = shift;
+  my $location = shift;
  
    local($DEBUG) = $FS::cust_main::DEBUG if $FS::cust_main::DEBUG > $DEBUG;
  
  
    local($DEBUG) = $FS::cust_main::DEBUG if $FS::cust_main::DEBUG > $DEBUG;
  
-  my $geocode;
-  if ( $cust_pkg->locationnum && $conf->exists('tax-pkg_address') ) {
-    $geocode = $cust_pkg->cust_location->geocode('cch');
-  } else {
-    $geocode = $self->geocode('cch');
-  }
-
-  my @taxes = ();
-
-  my @taxclassnums = map { $_->taxclassnum }
-                     $part_pkg->part_pkg_taxoverride($class);
+  my $geocode = $location->geocode('cch');
  
  
-  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;
-
-  my $extra_sql =
-    "AND (".
-    join(' OR ', map { "taxclassnum = $_" } @taxclassnums ). ")";
-
-  @taxes = qsearch({ 'table' => 'tax_rate',
-                     'hashref' => { 'geocode' => $geocode, },
-                     'extra_sql' => $extra_sql,
-                  })
-    if scalar(@taxclassnums);
-
-  warn "Found taxes ".
-       join(',', map{ ref($_). " ". $_->get($_->primary_key) } @taxes). "\n" 
-   if $DEBUG;
-
-  [ @taxes ];
+  [ $part_item->tax_rates('cch', $geocode, $class) ]
  
  }
  
  
  }
  
@@ -1389,13 +1895,18 @@ sub retry_realtime {
  
    #a little false laziness w/due_cust_event (not too bad, really)
  
  
    #a little false laziness w/due_cust_event (not too bad, really)
  
-  my $join = FS::part_event_condition->join_conditions_sql;
+  # I guess this is always as of now?
+  my $join = FS::part_event_condition->join_conditions_sql('', 'time' => time);
    my $order = FS::part_event_condition->order_conditions_sql;
    my $mine = 
    '( '
     . join ( ' OR ' , map { 
    my $order = FS::part_event_condition->order_conditions_sql;
    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($_) 
      "( 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)
     . ') ';
  
     } FS::part_event->eventtables)
     . ') ';
  
@@ -1411,17 +1922,23 @@ sub retry_realtime {
      cust_bill_batch
    );
  
      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' },
      '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"
    });
  
                     " AND $mine AND $is_realtime_event AND $agent_virt $order" # LIMIT 1"
    });
  
@@ -1555,7 +2072,7 @@ sub do_cust_event {
      #XXX lock event
      
      #re-eval event conditions (a previous event could have changed things)
      #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;
        #don't leave stray "new/locked" records around
        my $error = $cust_event->delete;
        return $error if $error;
@@ -1569,7 +2086,7 @@ sub do_cust_event {
          if $DEBUG > 1;
  
        #if ( my $error = $cust_event->do_event(%options) ) { #XXX %options?
          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;
          #XXX wtf is this?  figure out a proper dealio with return value
          #from do_event
          return $error;
@@ -1626,174 +2143,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.
  
  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) = $FS::cust_main::DEBUG if $FS::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
  =back
  
  =cut
@@ -1804,8 +2153,9 @@ sub due_cust_event {
  
    #???
    #my $DEBUG = $opt{'debug'}
  
    #???
    #my $DEBUG = $opt{'debug'}
+  $opt{'debug'} ||= 0; # silence some warnings
    local($DEBUG) = $opt{'debug'}
    local($DEBUG) = $opt{'debug'}
-    if defined($opt{'debug'}) && $opt{'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 ".
    $DEBUG = $FS::cust_main::DEBUG if $FS::cust_main::DEBUG > $DEBUG;
  
    warn "$me due_cust_event called with options ".
@@ -1847,45 +2197,46 @@ sub due_cust_event {
  
        @objects = @{ $opt{'objects'} };
  
  
        @objects = @{ $opt{'objects'} };
  
-    } else {
-
-      #my @objects = $self->$eventtable(); # sub cust_main { @{ [ $self ] }; }
-      if ( $eventtable eq 'cust_main' ) {
-        @objects = ( $self );
-      } else {
-
-        my $cm_join =
-          "LEFT JOIN cust_main USING ( custnum )";
+    } elsif ( $eventtable eq 'cust_main' ) {
  
  
-        #some false laziness w/Cron::bill bill_where
+      @objects = ( $self );
  
  
-        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" : '';
+    } else {
  
  
-        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",
-                   );
-      }
-
-    }
+      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,
+        'time' => $opt{'time'});
+      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 @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';
  
      $cross .= ' LEFT JOIN cust_main USING ( custnum )'
        unless $eventtable eq 'cust_main';
  
@@ -1898,7 +2249,8 @@ sub due_cust_event {
        my $pkey = $object->primary_key;
        $cross_where = "$eventtable.$pkey = ". $object->$pkey();
  
        my $pkey = $object->primary_key;
        $cross_where = "$eventtable.$pkey = ". $object->$pkey();
  
-      my $join = FS::part_event_condition->join_conditions_sql( $eventtable );
+      my $join = FS::part_event_condition->join_conditions_sql( $eventtable,
+        'time' => $opt{'time'});
        my $extra_sql =
          FS::part_event_condition->where_conditions_sql( $eventtable,
                                                          'time'=>$opt{'time'}
        my $extra_sql =
          FS::part_event_condition->where_conditions_sql( $eventtable,
                                                          'time'=>$opt{'time'}
@@ -1933,7 +2285,9 @@ sub due_cust_event {
               " possible events found for $eventtable ". $object->$pkey(). "\n";
        }
  
               " 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;
  
      }
  
  
      }
  
@@ -1967,8 +2321,7 @@ sub due_cust_event {
    
    my %unsat = ();
  
    
    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"
                       @cust_event;
  
    warn "  ". scalar(@cust_event). " cust events left satisfying conditions\n"
@@ -2010,6 +2363,7 @@ sub due_cust_event {
  =item apply_payments_and_credits [ OPTION => VALUE ... ]
  
  Applies unapplied payments and credits.
  =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.
  
  In most cases, this new method should be used in place of sequential
  apply_payments and apply_credits methods.
@@ -2152,6 +2506,7 @@ sub apply_credits {
  
  Applies (see L<FS::cust_bill_pay>) unapplied payments (see L<FS::cust_pay>)
  to outstanding invoice balances in chronological order.
  
  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.
  
  
   #and returns the value of any remaining unapplied payments.
  
@@ -2181,13 +2536,9 @@ sub apply_payments {
  
    #return 0 unless
  
  
    #return 0 unless
  
-  my @payments = sort { $b->_date <=> $a->_date }
-                 grep { $_->unapplied > 0 }
-                 $self->cust_pay;
+  my @payments = grep { !$_->no_auto_apply } $self->unapplied_cust_pay;
  
  
-  my @invoices = sort { $a->_date <=> $b->_date}
-                 grep { $_->owed > 0 }
-                 $self->cust_bill;
+  my @invoices = $self->open_cust_bill;
  
    if ( $conf->exists('pkg-balances') ) {
      # limit @payments to those w/ a pkgnum grepped from $self
  
    if ( $conf->exists('pkg-balances') ) {
      # limit @payments to those w/ a pkgnum grepped from $self
@@ -2221,11 +2572,14 @@ sub apply_payments {
  
      my $amount = min( $payment->unapplied, $owed );
  
  
      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,
        '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);
      $cust_bill_pay->pkgnum( $payment->pkgnum )
        if $conf->exists('pkg-balances') && $payment->pkgnum;
      my $error = $cust_bill_pay->insert(%options);
@@ -2245,6 +2599,30 @@ sub apply_payments {
    return $total_unapplied_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
  =head1 BUGS
  
  =head1 SEE ALSO