FS/FS/cust_bill.pm

   1 package FS::cust_bill;
   2
   3 use strict;
   4 use vars qw( @ISA $DEBUG $me
   5              $money_char $date_format $rdate_format $date_format_long );
   6              # but NOT $conf
   7 use vars qw( $invoice_lines @buf ); #yuck
   8 use Fcntl qw(:flock); #for spool_csv
   9 use Cwd;
  10 use List::Util qw(min max sum);
  11 use Date::Format;
  12 use Date::Language;
  13 use Text::Template 1.20;
  14 use File::Temp 0.14;
  15 use String::ShellQuote;
  16 use HTML::Entities;
  17 use Locale::Country;
  18 use Storable qw( freeze thaw );
  19 use GD::Barcode;
  20 use FS::UID qw( datasrc );
  21 use FS::Misc qw( send_email send_fax generate_ps generate_pdf do_print );
  22 use FS::Record qw( qsearch qsearchs dbh );
  23 use FS::cust_main_Mixin;
  24 use FS::cust_main;
  25 use FS::cust_statement;
  26 use FS::cust_bill_pkg;
  27 use FS::cust_bill_pkg_display;
  28 use FS::cust_bill_pkg_detail;
  29 use FS::cust_credit;
  30 use FS::cust_pay;
  31 use FS::cust_pkg;
  32 use FS::cust_credit_bill;
  33 use FS::pay_batch;
  34 use FS::cust_pay_batch;
  35 use FS::cust_bill_event;
  36 use FS::cust_event;
  37 use FS::part_pkg;
  38 use FS::cust_bill_pay;
  39 use FS::cust_bill_pay_batch;
  40 use FS::part_bill_event;
  41 use FS::payby;
  42 use FS::bill_batch;
  43 use FS::cust_bill_batch;
  44 use FS::cust_bill_pay_pkg;
  45 use FS::cust_credit_bill_pkg;
  46 use FS::discount_plan;
  47 use FS::L10N;
  48
  49 @ISA = qw( FS::cust_main_Mixin FS::Record );
  50
  51 $DEBUG = 0;
  52 $me = '[FS::cust_bill]';
  53
  54 #ask FS::UID to run this stuff for us later
  55 FS::UID->install_callback( sub {
  56   my $conf = new FS::Conf; #global
  57   $money_char       = $conf->config('money_char')       || '$';
  58   $date_format      = $conf->config('date_format')      || '%x'; #/YY
  59   $rdate_format     = $conf->config('date_format')      || '%m/%d/%Y';  #/YYYY
  60   $date_format_long = $conf->config('date_format_long') || '%b %o, %Y';
  61 } );
  62
  63 =head1 NAME
  64
  65 FS::cust_bill - Object methods for cust_bill records
  66
  67 =head1 SYNOPSIS
  68
  69   use FS::cust_bill;
  70
  71   $record = new FS::cust_bill \%hash;
  72   $record = new FS::cust_bill { 'column' => 'value' };
  73
  74   $error = $record->insert;
  75
  76   $error = $new_record->replace($old_record);
  77
  78   $error = $record->delete;
  79
  80   $error = $record->check;
  81
  82   ( $total_previous_balance, @previous_cust_bill ) = $record->previous;
  83
  84   @cust_bill_pkg_objects = $cust_bill->cust_bill_pkg;
  85
  86   ( $total_previous_credits, @previous_cust_credit ) = $record->cust_credit;
  87
  88   @cust_pay_objects = $cust_bill->cust_pay;
  89
  90   $tax_amount = $record->tax;
  91
  92   @lines = $cust_bill->print_text;
  93   @lines = $cust_bill->print_text $time;
  94
  95 =head1 DESCRIPTION
  96
  97 An FS::cust_bill object represents an invoice; a declaration that a customer
  98 owes you money.  The specific charges are itemized as B<cust_bill_pkg> records
  99 (see L<FS::cust_bill_pkg>).  FS::cust_bill inherits from FS::Record.  The
 100 following fields are currently supported:
 101
 102 Regular fields
 103
 104 =over 4
 105
 106 =item invnum - primary key (assigned automatically for new invoices)
 107
 108 =item custnum - customer (see L<FS::cust_main>)
 109
 110 =item _date - specified as a UNIX timestamp; see L<perlfunc/"time">.  Also see
 111 L<Time::Local> and L<Date::Parse> for conversion functions.
 112
 113 =item charged - amount of this invoice
 114
 115 =item invoice_terms - optional terms override for this specific invoice
 116
 117 =back
 118
 119 Customer info at invoice generation time
 120
 121 =over 4
 122
 123 =item previous_balance
 124
 125 =item billing_balance
 126
 127 =back
 128
 129 Deprecated
 130
 131 =over 4
 132
 133 =item printed - deprecated
 134
 135 =back
 136
 137 Specific use cases
 138
 139 =over 4
 140
 141 =item closed - books closed flag, empty or `Y'
 142
 143 =item statementnum - invoice aggregation (see L<FS::cust_statement>)
 144
 145 =item agent_invid - legacy invoice number
 146
 147 =item promised_date - customer promised payment date, for collection
 148
 149 =back
 150
 151 =head1 METHODS
 152
 153 =over 4
 154
 155 =item new HASHREF
 156
 157 Creates a new invoice.  To add the invoice to the database, see L<"insert">.
 158 Invoices are normally created by calling the bill method of a customer object
 159 (see L<FS::cust_main>).
 160
 161 =cut
 162
 163 sub table { 'cust_bill'; }
 164
 165 sub cust_linked { $_[0]->cust_main_custnum; }
 166 sub cust_unlinked_msg {
 167   my $self = shift;
 168   "WARNING: can't find cust_main.custnum ". $self->custnum.
 169   ' (cust_bill.invnum '. $self->invnum. ')';
 170 }
 171
 172 =item insert
 173
 174 Adds this invoice to the database ("Posts" the invoice).  If there is an error,
 175 returns the error, otherwise returns false.
 176
 177 =cut
 178
 179 sub insert {
 180   my $self = shift;
 181   warn "$me insert called\n" if $DEBUG;
 182
 183   local $SIG{HUP} = 'IGNORE';
 184   local $SIG{INT} = 'IGNORE';
 185   local $SIG{QUIT} = 'IGNORE';
 186   local $SIG{TERM} = 'IGNORE';
 187   local $SIG{TSTP} = 'IGNORE';
 188   local $SIG{PIPE} = 'IGNORE';
 189
 190   my $oldAutoCommit = $FS::UID::AutoCommit;
 191   local $FS::UID::AutoCommit = 0;
 192   my $dbh = dbh;
 193
 194   my $error = $self->SUPER::insert;
 195   if ( $error ) {
 196     $dbh->rollback if $oldAutoCommit;
 197     return $error;
 198   }
 199
 200   if ( $self->get('cust_bill_pkg') ) {
 201     foreach my $cust_bill_pkg ( @{$self->get('cust_bill_pkg')} ) {
 202       $cust_bill_pkg->invnum($self->invnum);
 203       my $error = $cust_bill_pkg->insert;
 204       if ( $error ) {
 205         $dbh->rollback if $oldAutoCommit;
 206         return "can't create invoice line item: $error";
 207       }
 208     }
 209   }
 210
 211   $dbh->commit or die $dbh->errstr if $oldAutoCommit;
 212   '';
 213
 214 }
 215
 216 =item delete
 217
 218 This method now works but you probably shouldn't use it.  Instead, apply a
 219 credit against the invoice.
 220
 221 Using this method to delete invoices outright is really, really bad.  There
 222 would be no record you ever posted this invoice, and there are no check to
 223 make sure charged = 0 or that there are no associated cust_bill_pkg records.
 224
 225 Really, don't use it.
 226
 227 =cut
 228
 229 sub delete {
 230   my $self = shift;
 231   return "Can't delete closed invoice" if $self->closed =~ /^Y/i;
 232
 233   local $SIG{HUP} = 'IGNORE';
 234   local $SIG{INT} = 'IGNORE';
 235   local $SIG{QUIT} = 'IGNORE';
 236   local $SIG{TERM} = 'IGNORE';
 237   local $SIG{TSTP} = 'IGNORE';
 238   local $SIG{PIPE} = 'IGNORE';
 239
 240   my $oldAutoCommit = $FS::UID::AutoCommit;
 241   local $FS::UID::AutoCommit = 0;
 242   my $dbh = dbh;
 243
 244   foreach my $table (qw(
 245     cust_bill_event
 246     cust_event
 247     cust_credit_bill
 248     cust_bill_pay
 249     cust_credit_bill
 250     cust_pay_batch
 251     cust_bill_pay_batch
 252     cust_bill_pkg
 253     cust_bill_batch
 254   )) {
 255
 256     foreach my $linked ( $self->$table() ) {
 257       my $error = $linked->delete;
 258       if ( $error ) {
 259         $dbh->rollback if $oldAutoCommit;
 260         return $error;
 261       }
 262     }
 263
 264   }
 265
 266   my $error = $self->SUPER::delete(@_);
 267   if ( $error ) {
 268     $dbh->rollback if $oldAutoCommit;
 269     return $error;
 270   }
 271
 272   $dbh->commit or die $dbh->errstr if $oldAutoCommit;
 273
 274   '';
 275
 276 }
 277
 278 =item replace [ OLD_RECORD ]
 279
 280 You can, but probably shouldn't modify invoices...
 281
 282 Replaces the OLD_RECORD with this one in the database, or, if OLD_RECORD is not
 283 supplied, replaces this record.  If there is an error, returns the error,
 284 otherwise returns false.
 285
 286 =cut
 287
 288 #replace can be inherited from Record.pm
 289
 290 # replace_check is now the preferred way to #implement replace data checks
 291 # (so $object->replace() works without an argument)
 292
 293 sub replace_check {
 294   my( $new, $old ) = ( shift, shift );
 295   return "Can't modify closed invoice" if $old->closed =~ /^Y/i;
 296   #return "Can't change _date!" unless $old->_date eq $new->_date;
 297   return "Can't change _date" unless $old->_date == $new->_date;
 298   return "Can't change charged" unless $old->charged == $new->charged
 299                                     || $old->charged == 0
 300                                     || $new->{'Hash'}{'cc_surcharge_replace_hack'};
 301
 302   '';
 303 }
 304
 305
 306 =item add_cc_surcharge
 307
 308 Giant hack
 309
 310 =cut
 311
 312 sub add_cc_surcharge {
 313     my ($self, $pkgnum, $amount) = (shift, shift, shift);
 314
 315     my $error;
 316     my $cust_bill_pkg = new FS::cust_bill_pkg({
 317                                     'invnum' => $self->invnum,
 318                                     'pkgnum' => $pkgnum,
 319                                     'setup' => $amount,
 320                         });
 321     $error = $cust_bill_pkg->insert;
 322     return $error if $error;
 323
 324     $self->{'Hash'}{'cc_surcharge_replace_hack'} = 1;
 325     $self->charged($self->charged+$amount);
 326     $error = $self->replace;
 327     return $error if $error;
 328
 329     $self->apply_payments_and_credits;
 330 }
 331
 332
 333 =item check
 334
 335 Checks all fields to make sure this is a valid invoice.  If there is an error,
 336 returns the error, otherwise returns false.  Called by the insert and replace
 337 methods.
 338
 339 =cut
 340
 341 sub check {
 342   my $self = shift;
 343
 344   my $error =
 345     $self->ut_numbern('invnum')
 346     || $self->ut_foreign_key('custnum', 'cust_main', 'custnum' )
 347     || $self->ut_numbern('_date')
 348     || $self->ut_money('charged')
 349     || $self->ut_numbern('printed')
 350     || $self->ut_enum('closed', [ '', 'Y' ])
 351     || $self->ut_foreign_keyn('statementnum', 'cust_statement', 'statementnum' )
 352     || $self->ut_numbern('agent_invid') #varchar?
 353   ;
 354   return $error if $error;
 355
 356   $self->_date(time) unless $self->_date;
 357
 358   $self->printed(0) if $self->printed eq '';
 359
 360   $self->SUPER::check;
 361 }
 362
 363 =item display_invnum
 364
 365 Returns the displayed invoice number for this invoice: agent_invid if
 366 cust_bill-default_agent_invid is set and it has a value, invnum otherwise.
 367
 368 =cut
 369
 370 sub display_invnum {
 371   my $self = shift;
 372   my $conf = $self->conf;
 373   if ( $conf->exists('cust_bill-default_agent_invid') && $self->agent_invid ){
 374     return $self->agent_invid;
 375   } else {
 376     return $self->invnum;
 377   }
 378 }
 379
 380 =item previous
 381
 382 Returns a list consisting of the total previous balance for this customer,
 383 followed by the previous outstanding invoices (as FS::cust_bill objects also).
 384
 385 =cut
 386
 387 sub previous {
 388   my $self = shift;
 389   my $total = 0;
 390   my @cust_bill = sort { $a->_date <=> $b->_date }
 391     grep { $_->owed != 0 && $_->_date < $self->_date }
 392       qsearch( 'cust_bill', { 'custnum' => $self->custnum } )
 393   ;
 394   foreach ( @cust_bill ) { $total += $_->owed; }
 395   $total, @cust_bill;
 396 }
 397
 398 =item cust_bill_pkg
 399
 400 Returns the line items (see L<FS::cust_bill_pkg>) for this invoice.
 401
 402 =cut
 403
 404 sub cust_bill_pkg {
 405   my $self = shift;
 406   qsearch(
 407     { 'table'    => 'cust_bill_pkg',
 408       'hashref'  => { 'invnum' => $self->invnum },
 409       'order_by' => 'ORDER BY billpkgnum',
 410     }
 411   );
 412 }
 413
 414 =item cust_bill_pkg_pkgnum PKGNUM
 415
 416 Returns the line items (see L<FS::cust_bill_pkg>) for this invoice and
 417 specified pkgnum.
 418
 419 =cut
 420
 421 sub cust_bill_pkg_pkgnum {
 422   my( $self, $pkgnum ) = @_;
 423   qsearch(
 424     { 'table'    => 'cust_bill_pkg',
 425       'hashref'  => { 'invnum' => $self->invnum,
 426                       'pkgnum' => $pkgnum,
 427                     },
 428       'order_by' => 'ORDER BY billpkgnum',
 429     }
 430   );
 431 }
 432
 433 =item cust_pkg
 434
 435 Returns the packages (see L<FS::cust_pkg>) corresponding to the line items for
 436 this invoice.
 437
 438 =cut
 439
 440 sub cust_pkg {
 441   my $self = shift;
 442   my @cust_pkg = map { $_->pkgnum > 0 ? $_->cust_pkg : () }
 443                      $self->cust_bill_pkg;
 444   my %saw = ();
 445   grep { ! $saw{$_->pkgnum}++ } @cust_pkg;
 446 }
 447
 448 =item no_auto
 449
 450 Returns true if any of the packages (or their definitions) corresponding to the
 451 line items for this invoice have the no_auto flag set.
 452
 453 =cut
 454
 455 sub no_auto {
 456   my $self = shift;
 457   grep { $_->no_auto || $_->part_pkg->no_auto } $self->cust_pkg;
 458 }
 459
 460 =item open_cust_bill_pkg
 461
 462 Returns the open line items for this invoice.
 463
 464 Note that cust_bill_pkg with both setup and recur fees are returned as two
 465 separate line items, each with only one fee.
 466
 467 =cut
 468
 469 # modeled after cust_main::open_cust_bill
 470 sub open_cust_bill_pkg {
 471   my $self = shift;
 472
 473   # grep { $_->owed > 0 } $self->cust_bill_pkg
 474
 475   my %other = ( 'recur' => 'setup',
 476                 'setup' => 'recur', );
 477   my @open = ();
 478   foreach my $field ( qw( recur setup )) {
 479     push @open, map  { $_->set( $other{$field}, 0 ); $_; }
 480                 grep { $_->owed($field) > 0 }
 481                 $self->cust_bill_pkg;
 482   }
 483
 484   @open;
 485 }
 486
 487 =item cust_bill_event
 488
 489 Returns the completed invoice events (deprecated, old-style events - see L<FS::cust_bill_event>) for this invoice.
 490
 491 =cut
 492
 493 sub cust_bill_event {
 494   my $self = shift;
 495   qsearch( 'cust_bill_event', { 'invnum' => $self->invnum } );
 496 }
 497
 498 =item num_cust_bill_event
 499
 500 Returns the number of completed invoice events (deprecated, old-style events - see L<FS::cust_bill_event>) for this invoice.
 501
 502 =cut
 503
 504 sub num_cust_bill_event {
 505   my $self = shift;
 506   my $sql =
 507     "SELECT COUNT(*) FROM cust_bill_event WHERE invnum = ?";
 508   my $sth = dbh->prepare($sql) or die  dbh->errstr. " preparing $sql";
 509   $sth->execute($self->invnum) or die $sth->errstr. " executing $sql";
 510   $sth->fetchrow_arrayref->[0];
 511 }
 512
 513 =item cust_event
 514
 515 Returns the new-style customer billing events (see L<FS::cust_event>) for this invoice.
 516
 517 =cut
 518
 519 #false laziness w/cust_pkg.pm
 520 sub cust_event {
 521   my $self = shift;
 522   qsearch({
 523     'table'     => 'cust_event',
 524     'addl_from' => 'JOIN part_event USING ( eventpart )',
 525     'hashref'   => { 'tablenum' => $self->invnum },
 526     'extra_sql' => " AND eventtable = 'cust_bill' ",
 527   });
 528 }
 529
 530 =item num_cust_event
 531
 532 Returns the number of new-style customer billing events (see L<FS::cust_event>) for this invoice.
 533
 534 =cut
 535
 536 #false laziness w/cust_pkg.pm
 537 sub num_cust_event {
 538   my $self = shift;
 539   my $sql =
 540     "SELECT COUNT(*) FROM cust_event JOIN part_event USING ( eventpart ) ".
 541     "  WHERE tablenum = ? AND eventtable = 'cust_bill'";
 542   my $sth = dbh->prepare($sql) or die  dbh->errstr. " preparing $sql";
 543   $sth->execute($self->invnum) or die $sth->errstr. " executing $sql";
 544   $sth->fetchrow_arrayref->[0];
 545 }
 546
 547 =item cust_main
 548
 549 Returns the customer (see L<FS::cust_main>) for this invoice.
 550
 551 =cut
 552
 553 sub cust_main {
 554   my $self = shift;
 555   qsearchs( 'cust_main', { 'custnum' => $self->custnum } );
 556 }
 557
 558 =item cust_suspend_if_balance_over AMOUNT
 559
 560 Suspends the customer associated with this invoice if the total amount owed on
 561 this invoice and all older invoices is greater than the specified amount.
 562
 563 Returns a list: an empty list on success or a list of errors.
 564
 565 =cut
 566
 567 sub cust_suspend_if_balance_over {
 568   my( $self, $amount ) = ( shift, shift );
 569   my $cust_main = $self->cust_main;
 570   if ( $cust_main->total_owed_date($self->_date) < $amount ) {
 571     return ();
 572   } else {
 573     $cust_main->suspend(@_);
 574   }
 575 }
 576
 577 =item cust_credit
 578
 579 Depreciated.  See the cust_credited method.
 580
 581  #Returns a list consisting of the total previous credited (see
 582  #L<FS::cust_credit>) and unapplied for this customer, followed by the previous
 583  #outstanding credits (FS::cust_credit objects).
 584
 585 =cut
 586
 587 sub cust_credit {
 588   use Carp;
 589   croak "FS::cust_bill->cust_credit depreciated; see ".
 590         "FS::cust_bill->cust_credit_bill";
 591   #my $self = shift;
 592   #my $total = 0;
 593   #my @cust_credit = sort { $a->_date <=> $b->_date }
 594   #  grep { $_->credited != 0 && $_->_date < $self->_date }
 595   #    qsearch('cust_credit', { 'custnum' => $self->custnum } )
 596   #;
 597   #foreach (@cust_credit) { $total += $_->credited; }
 598   #$total, @cust_credit;
 599 }
 600
 601 =item cust_pay
 602
 603 Depreciated.  See the cust_bill_pay method.
 604
 605 #Returns all payments (see L<FS::cust_pay>) for this invoice.
 606
 607 =cut
 608
 609 sub cust_pay {
 610   use Carp;
 611   croak "FS::cust_bill->cust_pay depreciated; see FS::cust_bill->cust_bill_pay";
 612   #my $self = shift;
 613   #sort { $a->_date <=> $b->_date }
 614   #  qsearch( 'cust_pay', { 'invnum' => $self->invnum } )
 615   #;
 616 }
 617
 618 sub cust_pay_batch {
 619   my $self = shift;
 620   qsearch('cust_pay_batch', { 'invnum' => $self->invnum } );
 621 }
 622
 623 sub cust_bill_pay_batch {
 624   my $self = shift;
 625   qsearch('cust_bill_pay_batch', { 'invnum' => $self->invnum } );
 626 }
 627
 628 =item cust_bill_pay
 629
 630 Returns all payment applications (see L<FS::cust_bill_pay>) for this invoice.
 631
 632 =cut
 633
 634 sub cust_bill_pay {
 635   my $self = shift;
 636   map { $_ } #return $self->num_cust_bill_pay unless wantarray;
 637   sort { $a->_date <=> $b->_date }
 638     qsearch( 'cust_bill_pay', { 'invnum' => $self->invnum } );
 639 }
 640
 641 =item cust_credited
 642
 643 =item cust_credit_bill
 644
 645 Returns all applied credits (see L<FS::cust_credit_bill>) for this invoice.
 646
 647 =cut
 648
 649 sub cust_credited {
 650   my $self = shift;
 651   map { $_ } #return $self->num_cust_credit_bill unless wantarray;
 652   sort { $a->_date <=> $b->_date }
 653     qsearch( 'cust_credit_bill', { 'invnum' => $self->invnum } )
 654   ;
 655 }
 656
 657 sub cust_credit_bill {
 658   shift->cust_credited(@_);
 659 }
 660
 661 #=item cust_bill_pay_pkgnum PKGNUM
 662 #
 663 #Returns all payment applications (see L<FS::cust_bill_pay>) for this invoice
 664 #with matching pkgnum.
 665 #
 666 #=cut
 667 #
 668 #sub cust_bill_pay_pkgnum {
 669 #  my( $self, $pkgnum ) = @_;
 670 #  map { $_ } #return $self->num_cust_bill_pay_pkgnum($pkgnum) unless wantarray;
 671 #  sort { $a->_date <=> $b->_date }
 672 #    qsearch( 'cust_bill_pay', { 'invnum' => $self->invnum,
 673 #                                'pkgnum' => $pkgnum,
 674 #                              }
 675 #           );
 676 #}
 677
 678 =item cust_bill_pay_pkg PKGNUM
 679
 680 Returns all payment applications (see L<FS::cust_bill_pay>) for this invoice
 681 applied against the matching pkgnum.
 682
 683 =cut
 684
 685 sub cust_bill_pay_pkg {
 686   my( $self, $pkgnum ) = @_;
 687
 688   qsearch({
 689     'select'    => 'cust_bill_pay_pkg.*',
 690     'table'     => 'cust_bill_pay_pkg',
 691     'addl_from' => ' LEFT JOIN cust_bill_pay USING ( billpaynum ) '.
 692                    ' LEFT JOIN cust_bill_pkg USING ( billpkgnum ) ',
 693     'extra_sql' => ' WHERE cust_bill_pkg.invnum = '. $self->invnum.
 694                    "   AND cust_bill_pkg.pkgnum = $pkgnum",
 695   });
 696
 697 }
 698
 699 #=item cust_credited_pkgnum PKGNUM
 700 #
 701 #=item cust_credit_bill_pkgnum PKGNUM
 702 #
 703 #Returns all applied credits (see L<FS::cust_credit_bill>) for this invoice
 704 #with matching pkgnum.
 705 #
 706 #=cut
 707 #
 708 #sub cust_credited_pkgnum {
 709 #  my( $self, $pkgnum ) = @_;
 710 #  map { $_ } #return $self->num_cust_credit_bill_pkgnum($pkgnum) unless wantarray;
 711 #  sort { $a->_date <=> $b->_date }
 712 #    qsearch( 'cust_credit_bill', { 'invnum' => $self->invnum,
 713 #                                   'pkgnum' => $pkgnum,
 714 #                                 }
 715 #           );
 716 #}
 717 #
 718 #sub cust_credit_bill_pkgnum {
 719 #  shift->cust_credited_pkgnum(@_);
 720 #}
 721
 722 =item cust_credit_bill_pkg PKGNUM
 723
 724 Returns all credit applications (see L<FS::cust_credit_bill>) for this invoice
 725 applied against the matching pkgnum.
 726
 727 =cut
 728
 729 sub cust_credit_bill_pkg {
 730   my( $self, $pkgnum ) = @_;
 731
 732   qsearch({
 733     'select'    => 'cust_credit_bill_pkg.*',
 734     'table'     => 'cust_credit_bill_pkg',
 735     'addl_from' => ' LEFT JOIN cust_credit_bill USING ( creditbillnum ) '.
 736                    ' LEFT JOIN cust_bill_pkg    USING ( billpkgnum    ) ',
 737     'extra_sql' => ' WHERE cust_bill_pkg.invnum = '. $self->invnum.
 738                    "   AND cust_bill_pkg.pkgnum = $pkgnum",
 739   });
 740
 741 }
 742
 743 =item cust_bill_batch
 744
 745 Returns all invoice batch records (L<FS::cust_bill_batch>) for this invoice.
 746
 747 =cut
 748
 749 sub cust_bill_batch {
 750   my $self = shift;
 751   qsearch('cust_bill_batch', { 'invnum' => $self->invnum });
 752 }
 753
 754 =item discount_plans
 755
 756 Returns all discount plans (L<FS::discount_plan>) for this invoice, as a
 757 hash keyed by term length.
 758
 759 =cut
 760
 761 sub discount_plans {
 762   my $self = shift;
 763   FS::discount_plan->all($self);
 764 }
 765
 766 =item tax
 767
 768 Returns the tax amount (see L<FS::cust_bill_pkg>) for this invoice.
 769
 770 =cut
 771
 772 sub tax {
 773   my $self = shift;
 774   my $total = 0;
 775   my @taxlines = qsearch( 'cust_bill_pkg', { 'invnum' => $self->invnum ,
 776                                              'pkgnum' => 0 } );
 777   foreach (@taxlines) { $total += $_->setup; }
 778   $total;
 779 }
 780
 781 =item owed
 782
 783 Returns the amount owed (still outstanding) on this invoice, which is charged
 784 minus all payment applications (see L<FS::cust_bill_pay>) and credit
 785 applications (see L<FS::cust_credit_bill>).
 786
 787 =cut
 788
 789 sub owed {
 790   my $self = shift;
 791   my $balance = $self->charged;
 792   $balance -= $_->amount foreach ( $self->cust_bill_pay );
 793   $balance -= $_->amount foreach ( $self->cust_credited );
 794   $balance = sprintf( "%.2f", $balance);
 795   $balance =~ s/^\-0\.00$/0.00/; #yay ieee fp
 796   $balance;
 797 }
 798
 799 sub owed_pkgnum {
 800   my( $self, $pkgnum ) = @_;
 801
 802   #my $balance = $self->charged;
 803   my $balance = 0;
 804   $balance += $_->setup + $_->recur for $self->cust_bill_pkg_pkgnum($pkgnum);
 805
 806   $balance -= $_->amount            for $self->cust_bill_pay_pkg($pkgnum);
 807   $balance -= $_->amount            for $self->cust_credit_bill_pkg($pkgnum);
 808
 809   $balance = sprintf( "%.2f", $balance);
 810   $balance =~ s/^\-0\.00$/0.00/; #yay ieee fp
 811   $balance;
 812 }
 813
 814 =item hide
 815
 816 Returns true if this invoice should be hidden.  See the
 817 selfservice-hide_invoices-taxclass configuraiton setting.
 818
 819 =cut
 820
 821 sub hide {
 822   my $self = shift;
 823   my $conf = $self->conf;
 824   my $hide_taxclass = $conf->config('selfservice-hide_invoices-taxclass')
 825     or return '';
 826   my @cust_bill_pkg = $self->cust_bill_pkg;
 827   my @part_pkg = grep $_, map $_->part_pkg, @cust_bill_pkg;
 828   ! grep { $_->taxclass ne $hide_taxclass } @part_pkg;
 829 }
 830
 831 =item apply_payments_and_credits [ OPTION => VALUE ... ]
 832
 833 Applies unapplied payments and credits to this invoice.
 834
 835 A hash of optional arguments may be passed.  Currently "manual" is supported.
 836 If true, a payment receipt is sent instead of a statement when
 837 'payment_receipt_email' configuration option is set.
 838
 839 If there is an error, returns the error, otherwise returns false.
 840
 841 =cut
 842
 843 sub apply_payments_and_credits {
 844   my( $self, %options ) = @_;
 845   my $conf = $self->conf;
 846
 847   local $SIG{HUP} = 'IGNORE';
 848   local $SIG{INT} = 'IGNORE';
 849   local $SIG{QUIT} = 'IGNORE';
 850   local $SIG{TERM} = 'IGNORE';
 851   local $SIG{TSTP} = 'IGNORE';
 852   local $SIG{PIPE} = 'IGNORE';
 853
 854   my $oldAutoCommit = $FS::UID::AutoCommit;
 855   local $FS::UID::AutoCommit = 0;
 856   my $dbh = dbh;
 857
 858   $self->select_for_update; #mutex
 859
 860   my @payments = grep { $_->unapplied > 0 } $self->cust_main->cust_pay;
 861   my @credits  = grep { $_->credited > 0 } $self->cust_main->cust_credit;
 862
 863   if ( $conf->exists('pkg-balances') ) {
 864     # limit @payments & @credits to those w/ a pkgnum grepped from $self
 865     my %pkgnums = map { $_ => 1 } map $_->pkgnum, $self->cust_bill_pkg;
 866     @payments = grep { ! $_->pkgnum || $pkgnums{$_->pkgnum} } @payments;
 867     @credits  = grep { ! $_->pkgnum || $pkgnums{$_->pkgnum} } @credits;
 868   }
 869
 870   while ( $self->owed > 0 and ( @payments || @credits ) ) {
 871
 872     my $app = '';
 873     if ( @payments && @credits ) {
 874
 875       #decide which goes first by weight of top (unapplied) line item
 876
 877       my @open_lineitems = $self->open_cust_bill_pkg;
 878
 879       my $max_pay_weight =
 880         max( map  { $_->part_pkg->pay_weight || 0 }
 881              grep { $_ }
 882              map  { $_->cust_pkg }
 883                   @open_lineitems
 884            );
 885       my $max_credit_weight =
 886         max( map  { $_->part_pkg->credit_weight || 0 }
 887              grep { $_ }
 888              map  { $_->cust_pkg }
 889                   @open_lineitems
 890            );
 891
 892       #if both are the same... payments first?  it has to be something
 893       if ( $max_pay_weight >= $max_credit_weight ) {
 894         $app = 'pay';
 895       } else {
 896         $app = 'credit';
 897       }
 898
 899     } elsif ( @payments ) {
 900       $app = 'pay';
 901     } elsif ( @credits ) {
 902       $app = 'credit';
 903     } else {
 904       die "guru meditation #12 and 35";
 905     }
 906
 907     my $unapp_amount;
 908     if ( $app eq 'pay' ) {
 909
 910       my $payment = shift @payments;
 911       $unapp_amount = $payment->unapplied;
 912       $app = new FS::cust_bill_pay { 'paynum'  => $payment->paynum };
 913       $app->pkgnum( $payment->pkgnum )
 914         if $conf->exists('pkg-balances') && $payment->pkgnum;
 915
 916     } elsif ( $app eq 'credit' ) {
 917
 918       my $credit = shift @credits;
 919       $unapp_amount = $credit->credited;
 920       $app = new FS::cust_credit_bill { 'crednum' => $credit->crednum };
 921       $app->pkgnum( $credit->pkgnum )
 922         if $conf->exists('pkg-balances') && $credit->pkgnum;
 923
 924     } else {
 925       die "guru meditation #12 and 35";
 926     }
 927
 928     my $owed;
 929     if ( $conf->exists('pkg-balances') && $app->pkgnum ) {
 930       warn "owed_pkgnum ". $app->pkgnum;
 931       $owed = $self->owed_pkgnum($app->pkgnum);
 932     } else {
 933       $owed = $self->owed;
 934     }
 935     next unless $owed > 0;
 936
 937     warn "min ( $unapp_amount, $owed )\n" if $DEBUG;
 938     $app->amount( sprintf('%.2f', min( $unapp_amount, $owed ) ) );
 939
 940     $app->invnum( $self->invnum );
 941
 942     my $error = $app->insert(%options);
 943     if ( $error ) {
 944       $dbh->rollback if $oldAutoCommit;
 945       return "Error inserting ". $app->table. " record: $error";
 946     }
 947     die $error if $error;
 948
 949   }
 950
 951   $dbh->commit or die $dbh->errstr if $oldAutoCommit;
 952   ''; #no error
 953
 954 }
 955
 956 =item generate_email OPTION => VALUE ...
 957
 958 Options:
 959
 960 =over 4
 961
 962 =item from
 963
 964 sender address, required
 965
 966 =item tempate
 967
 968 alternate template name, optional
 969
 970 =item print_text
 971
 972 text attachment arrayref, optional
 973
 974 =item subject
 975
 976 email subject, optional
 977
 978 =item notice_name
 979
 980 notice name instead of "Invoice", optional
 981
 982 =back
 983
 984 Returns an argument list to be passed to L<FS::Misc::send_email>.
 985
 986 =cut
 987
 988 use MIME::Entity;
 989
 990 sub generate_email {
 991
 992   my $self = shift;
 993   my %args = @_;
 994   my $conf = $self->conf;
 995
 996   my $me = '[FS::cust_bill::generate_email]';
 997
 998   my %return = (
 999     'from'      => $args{'from'},
1000     'subject'   => (($args{'subject'}) ? $args{'subject'} : 'Invoice'),
1001   );
1002
1003   my %opt = (
1004     'unsquelch_cdr' => $conf->exists('voip-cdr_email'),
1005     'template'      => $args{'template'},
1006     'notice_name'   => ( $args{'notice_name'} || 'Invoice' ),
1007     'no_coupon'     => $args{'no_coupon'},
1008   );
1009
1010   my $cust_main = $self->cust_main;
1011
1012   if (ref($args{'to'}) eq 'ARRAY') {
1013     $return{'to'} = $args{'to'};
1014   } else {
1015     $return{'to'} = [ grep { $_ !~ /^(POST|FAX)$/ }
1016                            $cust_main->invoicing_list
1017                     ];
1018   }
1019
1020   if ( $conf->exists('invoice_html') ) {
1021
1022     warn "$me creating HTML/text multipart message"
1023       if $DEBUG;
1024
1025     $return{'nobody'} = 1;
1026
1027     my $alternative = build MIME::Entity
1028       'Type'        => 'multipart/alternative',
1029       #'Encoding'    => '7bit',
1030       'Disposition' => 'inline'
1031     ;
1032
1033     my $data;
1034     if ( $conf->exists('invoice_email_pdf')
1035          and scalar($conf->config('invoice_email_pdf_note')) ) {
1036
1037       warn "$me using 'invoice_email_pdf_note' in multipart message"
1038         if $DEBUG;
1039       $data = [ map { $_ . "\n" }
1040                     $conf->config('invoice_email_pdf_note')
1041               ];
1042
1043     } else {
1044
1045       warn "$me not using 'invoice_email_pdf_note' in multipart message"
1046         if $DEBUG;
1047       if ( ref($args{'print_text'}) eq 'ARRAY' ) {
1048         $data = $args{'print_text'};
1049       } else {
1050         $data = [ $self->print_text(\%opt) ];
1051       }
1052
1053     }
1054
1055     $alternative->attach(
1056       'Type'        => 'text/plain',
1057       'Encoding'    => 'quoted-printable',
1058       #'Encoding'    => '7bit',
1059       'Data'        => $data,
1060       'Disposition' => 'inline',
1061     );
1062
1063
1064     my $htmldata;
1065     my $image = '';
1066     my $barcode = '';
1067     if ( $conf->exists('invoice_email_pdf')
1068          and scalar($conf->config('invoice_email_pdf_note')) ) {
1069
1070       $htmldata = join('<BR>', $conf->config('invoice_email_pdf_note') );
1071
1072     } else {
1073
1074       $args{'from'} =~ /\@([\w\.\-]+)/;
1075       my $from = $1 || 'example.com';
1076       my $content_id = join('.', rand()*(2**32), $$, time). "\@$from";
1077
1078       my $logo;
1079       my $agentnum = $cust_main->agentnum;
1080       if ( defined($args{'template'}) && length($args{'template'})
1081            && $conf->exists( 'logo_'. $args{'template'}. '.png', $agentnum )
1082          )
1083       {
1084         $logo = 'logo_'. $args{'template'}. '.png';
1085       } else {
1086         $logo = "logo.png";
1087       }
1088       my $image_data = $conf->config_binary( $logo, $agentnum);
1089
1090       $image = build MIME::Entity
1091         'Type'       => 'image/png',
1092         'Encoding'   => 'base64',
1093         'Data'       => $image_data,
1094         'Filename'   => 'logo.png',
1095         'Content-ID' => "<$content_id>",
1096       ;
1097
1098       if ($conf->exists('invoice-barcode')) {
1099         my $barcode_content_id = join('.', rand()*(2**32), $$, time). "\@$from";
1100         $barcode = build MIME::Entity
1101           'Type'       => 'image/png',
1102           'Encoding'   => 'base64',
1103           'Data'       => $self->invoice_barcode(0),
1104           'Filename'   => 'barcode.png',
1105           'Content-ID' => "<$barcode_content_id>",
1106         ;
1107         $opt{'barcode_cid'} = $barcode_content_id;
1108       }
1109
1110       $htmldata = $self->print_html({ 'cid'=>$content_id, %opt });
1111     }
1112
1113     $alternative->attach(
1114       'Type'        => 'text/html',
1115       'Encoding'    => 'quoted-printable',
1116       'Data'        => [ '<html>',
1117                          '  <head>',
1118                          '    <title>',
1119                          '      '. encode_entities($return{'subject'}),
1120                          '    </title>',
1121                          '  </head>',
1122                          '  <body bgcolor="#e8e8e8">',
1123                          $htmldata,
1124                          '  </body>',
1125                          '</html>',
1126                        ],
1127       'Disposition' => 'inline',
1128       #'Filename'    => 'invoice.pdf',
1129     );
1130
1131
1132     my @otherparts = ();
1133     if ( $cust_main->email_csv_cdr ) {
1134
1135       push @otherparts, build MIME::Entity
1136         'Type'        => 'text/csv',
1137         'Encoding'    => '7bit',
1138         'Data'        => [ map { "$_\n" }
1139                              $self->call_details('prepend_billed_number' => 1)
1140                          ],
1141         'Disposition' => 'attachment',
1142         'Filename'    => 'usage-'. $self->invnum. '.csv',
1143       ;
1144
1145     }
1146
1147     if ( $conf->exists('invoice_email_pdf') ) {
1148
1149       #attaching pdf too:
1150       # multipart/mixed
1151       #   multipart/related
1152       #     multipart/alternative
1153       #       text/plain
1154       #       text/html
1155       #     image/png
1156       #   application/pdf
1157
1158       my $related = build MIME::Entity 'Type'     => 'multipart/related',
1159                                        'Encoding' => '7bit';
1160
1161       #false laziness w/Misc::send_email
1162       $related->head->replace('Content-type',
1163         $related->mime_type.
1164         '; boundary="'. $related->head->multipart_boundary. '"'.
1165         '; type=multipart/alternative'
1166       );
1167
1168       $related->add_part($alternative);
1169
1170       $related->add_part($image) if $image;
1171
1172       my $pdf = build MIME::Entity $self->mimebuild_pdf(\%opt);
1173
1174       $return{'mimeparts'} = [ $related, $pdf, @otherparts ];
1175
1176     } else {
1177
1178       #no other attachment:
1179       # multipart/related
1180       #   multipart/alternative
1181       #     text/plain
1182       #     text/html
1183       #   image/png
1184
1185       $return{'content-type'} = 'multipart/related';
1186       if ($conf->exists('invoice-barcode') && $barcode) {
1187         $return{'mimeparts'} = [ $alternative, $image, $barcode, @otherparts ];
1188       } else {
1189         $return{'mimeparts'} = [ $alternative, $image, @otherparts ];
1190       }
1191       $return{'type'} = 'multipart/alternative'; #Content-Type of first part...
1192       #$return{'disposition'} = 'inline';
1193
1194     }
1195
1196   } else {
1197
1198     if ( $conf->exists('invoice_email_pdf') ) {
1199       warn "$me creating PDF attachment"
1200         if $DEBUG;
1201
1202       #mime parts arguments a la MIME::Entity->build().
1203       $return{'mimeparts'} = [
1204         { $self->mimebuild_pdf(\%opt) }
1205       ];
1206     }
1207
1208     if ( $conf->exists('invoice_email_pdf')
1209          and scalar($conf->config('invoice_email_pdf_note')) ) {
1210
1211       warn "$me using 'invoice_email_pdf_note'"
1212         if $DEBUG;
1213       $return{'body'} = [ map { $_ . "\n" }
1214                               $conf->config('invoice_email_pdf_note')
1215                         ];
1216
1217     } else {
1218
1219       warn "$me not using 'invoice_email_pdf_note'"
1220         if $DEBUG;
1221       if ( ref($args{'print_text'}) eq 'ARRAY' ) {
1222         $return{'body'} = $args{'print_text'};
1223       } else {
1224         $return{'body'} = [ $self->print_text(\%opt) ];
1225       }
1226
1227     }
1228
1229   }
1230
1231   %return;
1232
1233 }
1234
1235 =item mimebuild_pdf
1236
1237 Returns a list suitable for passing to MIME::Entity->build(), representing
1238 this invoice as PDF attachment.
1239
1240 =cut
1241
1242 sub mimebuild_pdf {
1243   my $self = shift;
1244   (
1245     'Type'        => 'application/pdf',
1246     'Encoding'    => 'base64',
1247     'Data'        => [ $self->print_pdf(@_) ],
1248     'Disposition' => 'attachment',
1249     'Filename'    => 'invoice-'. $self->invnum. '.pdf',
1250   );
1251 }
1252
1253 =item send HASHREF | [ TEMPLATE [ , AGENTNUM [ , INVOICE_FROM [ , AMOUNT ] ] ] ]
1254
1255 Sends this invoice to the destinations configured for this customer: sends
1256 email, prints and/or faxes.  See L<FS::cust_main_invoice>.
1257
1258 Options can be passed as a hashref (recommended) or as a list of up to
1259 four values for templatename, agentnum, invoice_from and amount.
1260
1261 I<template>, if specified, is the name of a suffix for alternate invoices.
1262
1263 I<agentnum>, if specified, means that this invoice will only be sent for customers
1264 of the specified agent or agent(s).  AGENTNUM can be a scalar agentnum (for a
1265 single agent) or an arrayref of agentnums.
1266
1267 I<invoice_from>, if specified, overrides the default email invoice From: address.
1268
1269 I<amount>, if specified, only sends the invoice if the total amount owed on this
1270 invoice and all older invoices is greater than the specified amount.
1271
1272 I<notice_name>, if specified, overrides "Invoice" as the name of the sent document (templates from 10/2009 or newer required)
1273
1274 =cut
1275
1276 sub queueable_send {
1277   my %opt = @_;
1278
1279   my $self = qsearchs('cust_bill', { 'invnum' => $opt{invnum} } )
1280     or die "invalid invoice number: " . $opt{invnum};
1281
1282   my @args = ( $opt{template}, $opt{agentnum} );
1283   push @args, $opt{invoice_from}
1284     if exists($opt{invoice_from}) && $opt{invoice_from};
1285
1286   my $error = $self->send( @args );
1287   die $error if $error;
1288
1289 }
1290
1291 sub send {
1292   my $self = shift;
1293   my $conf = $self->conf;
1294
1295   my( $template, $invoice_from, $notice_name );
1296   my $agentnums = '';
1297   my $balance_over = 0;
1298
1299   if ( ref($_[0]) ) {
1300     my $opt = shift;
1301     $template = $opt->{'template'} || '';
1302     if ( $agentnums = $opt->{'agentnum'} ) {
1303       $agentnums = [ $agentnums ] unless ref($agentnums);
1304     }
1305     $invoice_from = $opt->{'invoice_from'};
1306     $balance_over = $opt->{'balance_over'} if $opt->{'balance_over'};
1307     $notice_name = $opt->{'notice_name'};
1308   } else {
1309     $template = scalar(@_) ? shift : '';
1310     if ( scalar(@_) && $_[0]  ) {
1311       $agentnums = ref($_[0]) ? shift : [ shift ];
1312     }
1313     $invoice_from = shift if scalar(@_);
1314     $balance_over = shift if scalar(@_) && $_[0] !~ /^\s*$/;
1315   }
1316
1317   return 'N/A' unless ! $agentnums
1318                    or grep { $_ == $self->cust_main->agentnum } @$agentnums;
1319
1320   return ''
1321     unless $self->cust_main->total_owed_date($self->_date) > $balance_over;
1322
1323   $invoice_from ||= $self->_agent_invoice_from ||    #XXX should go away
1324                     $conf->config('invoice_from', $self->cust_main->agentnum );
1325
1326   my %opt = (
1327     'template'     => $template,
1328     'invoice_from' => $invoice_from,
1329     'notice_name'  => ( $notice_name || 'Invoice' ),
1330   );
1331
1332   my @invoicing_list = $self->cust_main->invoicing_list;
1333
1334   #$self->email_invoice(\%opt)
1335   $self->email(\%opt)
1336     if grep { $_ !~ /^(POST|FAX)$/ } @invoicing_list or !@invoicing_list;
1337
1338   #$self->print_invoice(\%opt)
1339   $self->print(\%opt)
1340     if grep { $_ eq 'POST' } @invoicing_list; #postal
1341
1342   $self->fax_invoice(\%opt)
1343     if grep { $_ eq 'FAX' } @invoicing_list; #fax
1344
1345   '';
1346
1347 }
1348
1349 =item email HASHREF | [ TEMPLATE [ , INVOICE_FROM ] ]
1350
1351 Emails this invoice.
1352
1353 Options can be passed as a hashref (recommended) or as a list of up to
1354 two values for templatename and invoice_from.
1355
1356 I<template>, if specified, is the name of a suffix for alternate invoices.
1357
1358 I<invoice_from>, if specified, overrides the default email invoice From: address.
1359
1360 I<notice_name>, if specified, overrides "Invoice" as the name of the sent document (templates from 10/2009 or newer required)
1361
1362 =cut
1363
1364 sub queueable_email {
1365   my %opt = @_;
1366
1367   my $self = qsearchs('cust_bill', { 'invnum' => $opt{invnum} } )
1368     or die "invalid invoice number: " . $opt{invnum};
1369
1370   my %args = ( 'template' => $opt{template} );
1371   $args{$_} = $opt{$_}
1372     foreach grep { exists($opt{$_}) && $opt{$_} }
1373               qw( invoice_from notice_name no_coupon );
1374
1375   my $error = $self->email( \%args );
1376   die $error if $error;
1377
1378 }
1379
1380 #sub email_invoice {
1381 sub email {
1382   my $self = shift;
1383   return if $self->hide;
1384   my $conf = $self->conf;
1385
1386   my( $template, $invoice_from, $notice_name, $no_coupon );
1387   if ( ref($_[0]) ) {
1388     my $opt = shift;
1389     $template = $opt->{'template'} || '';
1390     $invoice_from = $opt->{'invoice_from'};
1391     $notice_name = $opt->{'notice_name'} || 'Invoice';
1392     $no_coupon = $opt->{'no_coupon'} || 0;
1393   } else {
1394     $template = scalar(@_) ? shift : '';
1395     $invoice_from = shift if scalar(@_);
1396     $notice_name = 'Invoice';
1397     $no_coupon = 0;
1398   }
1399
1400   $invoice_from ||= $self->_agent_invoice_from ||    #XXX should go away
1401                     $conf->config('invoice_from', $self->cust_main->agentnum );
1402
1403   my @invoicing_list = grep { $_ !~ /^(POST|FAX)$/ }
1404                             $self->cust_main->invoicing_list;
1405
1406   if ( ! @invoicing_list ) { #no recipients
1407     if ( $conf->exists('cust_bill-no_recipients-error') ) {
1408       die 'No recipients for customer #'. $self->custnum;
1409     } else {
1410       #default: better to notify this person than silence
1411       @invoicing_list = ($invoice_from);
1412     }
1413   }
1414
1415   my $subject = $self->email_subject($template);
1416
1417   my $error = send_email(
1418     $self->generate_email(
1419       'from'        => $invoice_from,
1420       'to'          => [ grep { $_ !~ /^(POST|FAX)$/ } @invoicing_list ],
1421       'subject'     => $subject,
1422       'template'    => $template,
1423       'notice_name' => $notice_name,
1424       'no_coupon'   => $no_coupon,
1425     )
1426   );
1427   die "can't email invoice: $error\n" if $error;
1428   #die "$error\n" if $error;
1429
1430 }
1431
1432 sub email_subject {
1433   my $self = shift;
1434   my $conf = $self->conf;
1435
1436   #my $template = scalar(@_) ? shift : '';
1437   #per-template?
1438
1439   my $subject = $conf->config('invoice_subject', $self->cust_main->agentnum)
1440                 || 'Invoice';
1441
1442   my $cust_main = $self->cust_main;
1443   my $name = $cust_main->name;
1444   my $name_short = $cust_main->name_short;
1445   my $invoice_number = $self->invnum;
1446   my $invoice_date = $self->_date_pretty;
1447
1448   eval qq("$subject");
1449 }
1450
1451 =item lpr_data HASHREF | [ TEMPLATE ]
1452
1453 Returns the postscript or plaintext for this invoice as an arrayref.
1454
1455 Options can be passed as a hashref (recommended) or as a single optional value
1456 for template.
1457
1458 I<template>, if specified, is the name of a suffix for alternate invoices.
1459
1460 I<notice_name>, if specified, overrides "Invoice" as the name of the sent document (templates from 10/2009 or newer required)
1461
1462 =cut
1463
1464 sub lpr_data {
1465   my $self = shift;
1466   my $conf = $self->conf;
1467   my( $template, $notice_name );
1468   if ( ref($_[0]) ) {
1469     my $opt = shift;
1470     $template = $opt->{'template'} || '';
1471     $notice_name = $opt->{'notice_name'} || 'Invoice';
1472   } else {
1473     $template = scalar(@_) ? shift : '';
1474     $notice_name = 'Invoice';
1475   }
1476
1477   my %opt = (
1478     'template'    => $template,
1479     'notice_name' => $notice_name,
1480   );
1481
1482   my $method = $conf->exists('invoice_latex') ? 'print_ps' : 'print_text';
1483   [ $self->$method( \%opt ) ];
1484 }
1485
1486 =item print HASHREF | [ TEMPLATE ]
1487
1488 Prints this invoice.
1489
1490 Options can be passed as a hashref (recommended) or as a single optional
1491 value for template.
1492
1493 I<template>, if specified, is the name of a suffix for alternate invoices.
1494
1495 I<notice_name>, if specified, overrides "Invoice" as the name of the sent document (templates from 10/2009 or newer required)
1496
1497 =cut
1498
1499 #sub print_invoice {
1500 sub print {
1501   my $self = shift;
1502   return if $self->hide;
1503   my $conf = $self->conf;
1504
1505   my( $template, $notice_name );
1506   if ( ref($_[0]) ) {
1507     my $opt = shift;
1508     $template = $opt->{'template'} || '';
1509     $notice_name = $opt->{'notice_name'} || 'Invoice';
1510   } else {
1511     $template = scalar(@_) ? shift : '';
1512     $notice_name = 'Invoice';
1513   }
1514
1515   my %opt = (
1516     'template'    => $template,
1517     'notice_name' => $notice_name,
1518   );
1519
1520   if($conf->exists('invoice_print_pdf')) {
1521     # Add the invoice to the current batch.
1522     $self->batch_invoice(\%opt);
1523   }
1524   else {
1525     do_print $self->lpr_data(\%opt);
1526   }
1527 }
1528
1529 =item fax_invoice HASHREF | [ TEMPLATE ]
1530
1531 Faxes this invoice.
1532
1533 Options can be passed as a hashref (recommended) or as a single optional
1534 value for template.
1535
1536 I<template>, if specified, is the name of a suffix for alternate invoices.
1537
1538 I<notice_name>, if specified, overrides "Invoice" as the name of the sent document (templates from 10/2009 or newer required)
1539
1540 =cut
1541
1542 sub fax_invoice {
1543   my $self = shift;
1544   return if $self->hide;
1545   my $conf = $self->conf;
1546
1547   my( $template, $notice_name );
1548   if ( ref($_[0]) ) {
1549     my $opt = shift;
1550     $template = $opt->{'template'} || '';
1551     $notice_name = $opt->{'notice_name'} || 'Invoice';
1552   } else {
1553     $template = scalar(@_) ? shift : '';
1554     $notice_name = 'Invoice';
1555   }
1556
1557   die 'FAX invoice destination not (yet?) supported with plain text invoices.'
1558     unless $conf->exists('invoice_latex');
1559
1560   my $dialstring = $self->cust_main->getfield('fax');
1561   #Check $dialstring?
1562
1563   my %opt = (
1564     'template'    => $template,
1565     'notice_name' => $notice_name,
1566   );
1567
1568   my $error = send_fax( 'docdata'    => $self->lpr_data(\%opt),
1569                         'dialstring' => $dialstring,
1570                       );
1571   die $error if $error;
1572
1573 }
1574
1575 =item batch_invoice [ HASHREF ]
1576
1577 Place this invoice into the open batch (see C<FS::bill_batch>).  If there
1578 isn't an open batch, one will be created.
1579
1580 =cut
1581
1582 sub batch_invoice {
1583   my ($self, $opt) = @_;
1584   my $bill_batch = $self->get_open_bill_batch;
1585   my $cust_bill_batch = FS::cust_bill_batch->new({
1586       batchnum => $bill_batch->batchnum,
1587       invnum   => $self->invnum,
1588   });
1589   return $cust_bill_batch->insert($opt);
1590 }
1591
1592 =item get_open_batch
1593
1594 Returns the currently open batch as an FS::bill_batch object, creating a new
1595 one if necessary.  (A per-agent batch if invoice_print_pdf-spoolagent is
1596 enabled)
1597
1598 =cut
1599
1600 sub get_open_bill_batch {
1601   my $self = shift;
1602   my $conf = $self->conf;
1603   my $hashref = { status => 'O' };
1604   $hashref->{'agentnum'} = $conf->exists('invoice_print_pdf-spoolagent')
1605                              ? $self->cust_main->agentnum
1606                              : '';
1607   my $batch = qsearchs('bill_batch', $hashref);
1608   return $batch if $batch;
1609   $batch = FS::bill_batch->new($hashref);
1610   my $error = $batch->insert;
1611   die $error if $error;
1612   return $batch;
1613 }
1614
1615 =item ftp_invoice [ TEMPLATENAME ]
1616
1617 Sends this invoice data via FTP.
1618
1619 TEMPLATENAME is unused?
1620
1621 =cut
1622
1623 sub ftp_invoice {
1624   my $self = shift;
1625   my $conf = $self->conf;
1626   my $template = scalar(@_) ? shift : '';
1627
1628   $self->send_csv(
1629     'protocol'   => 'ftp',
1630     'server'     => $conf->config('cust_bill-ftpserver'),
1631     'username'   => $conf->config('cust_bill-ftpusername'),
1632     'password'   => $conf->config('cust_bill-ftppassword'),
1633     'dir'        => $conf->config('cust_bill-ftpdir'),
1634     'format'     => $conf->config('cust_bill-ftpformat'),
1635   );
1636 }
1637
1638 =item spool_invoice [ TEMPLATENAME ]
1639
1640 Spools this invoice data (see L<FS::spool_csv>)
1641
1642 TEMPLATENAME is unused?
1643
1644 =cut
1645
1646 sub spool_invoice {
1647   my $self = shift;
1648   my $conf = $self->conf;
1649   my $template = scalar(@_) ? shift : '';
1650
1651   $self->spool_csv(
1652     'format'       => $conf->config('cust_bill-spoolformat'),
1653     'agent_spools' => $conf->exists('cust_bill-spoolagent'),
1654   );
1655 }
1656
1657 =item send_if_newest [ TEMPLATENAME [ , AGENTNUM [ , INVOICE_FROM ] ] ]
1658
1659 Like B<send>, but only sends the invoice if it is the newest open invoice for
1660 this customer.
1661
1662 =cut
1663
1664 sub send_if_newest {
1665   my $self = shift;
1666
1667   return ''
1668     if scalar(
1669                grep { $_->owed > 0 }
1670                     qsearch('cust_bill', {
1671                       'custnum' => $self->custnum,
1672                       #'_date'   => { op=>'>', value=>$self->_date },
1673                       'invnum'  => { op=>'>', value=>$self->invnum },
1674                     } )
1675              );
1676
1677   $self->send(@_);
1678 }
1679
1680 =item send_csv OPTION => VALUE, ...
1681
1682 Sends invoice as a CSV data-file to a remote host with the specified protocol.
1683
1684 Options are:
1685
1686 protocol - currently only "ftp"
1687 server
1688 username
1689 password
1690 dir
1691
1692 The file will be named "N-YYYYMMDDHHMMSS.csv" where N is the invoice number
1693 and YYMMDDHHMMSS is a timestamp.
1694
1695 See L</print_csv> for a description of the output format.
1696
1697 =cut
1698
1699 sub send_csv {
1700   my($self, %opt) = @_;
1701
1702   #create file(s)
1703
1704   my $spooldir = "/usr/local/etc/freeside/export.". datasrc. "/cust_bill";
1705   mkdir $spooldir, 0700 unless -d $spooldir;
1706
1707   my $tracctnum = $self->invnum. time2str('-%Y%m%d%H%M%S', time);
1708   my $file = "$spooldir/$tracctnum.csv";
1709
1710   my ( $header, $detail ) = $self->print_csv(%opt, 'tracctnum' => $tracctnum );
1711
1712   open(CSV, ">$file") or die "can't open $file: $!";
1713   print CSV $header;
1714
1715   print CSV $detail;
1716
1717   close CSV;
1718
1719   my $net;
1720   if ( $opt{protocol} eq 'ftp' ) {
1721     eval "use Net::FTP;";
1722     die $@ if $@;
1723     $net = Net::FTP->new($opt{server}) or die @$;
1724   } else {
1725     die "unknown protocol: $opt{protocol}";
1726   }
1727
1728   $net->login( $opt{username}, $opt{password} )
1729     or die "can't FTP to $opt{username}\@$opt{server}: login error: $@";
1730
1731   $net->binary or die "can't set binary mode";
1732
1733   $net->cwd($opt{dir}) or die "can't cwd to $opt{dir}";
1734
1735   $net->put($file) or die "can't put $file: $!";
1736
1737   $net->quit;
1738
1739   unlink $file;
1740
1741 }
1742
1743 =item spool_csv
1744
1745 Spools CSV invoice data.
1746
1747 Options are:
1748
1749 =over 4
1750
1751 =item format - 'default' or 'billco'
1752
1753 =item dest - if set (to POST, EMAIL or FAX), only sends spools invoices if the customer has the corresponding invoice destinations set (see L<FS::cust_main_invoice>).
1754
1755 =item agent_spools - if set to a true value, will spool to per-agent files rather than a single global file
1756
1757 =item balanceover - if set, only spools the invoice if the total amount owed on this invoice and all older invoices is greater than the specified amount.
1758
1759 =back
1760
1761 =cut
1762
1763 sub spool_csv {
1764   my($self, %opt) = @_;
1765
1766   my $cust_main = $self->cust_main;
1767
1768   if ( $opt{'dest'} ) {
1769     my %invoicing_list = map { /^(POST|FAX)$/ or 'EMAIL' =~ /^(.*)$/; $1 => 1 }
1770                              $cust_main->invoicing_list;
1771     return 'N/A' unless $invoicing_list{$opt{'dest'}}
1772                      || ! keys %invoicing_list;
1773   }
1774
1775   if ( $opt{'balanceover'} ) {
1776     return 'N/A'
1777       if $cust_main->total_owed_date($self->_date) < $opt{'balanceover'};
1778   }
1779
1780   my $spooldir = "/usr/local/etc/freeside/export.". datasrc. "/cust_bill";
1781   mkdir $spooldir, 0700 unless -d $spooldir;
1782
1783   my $tracctnum = $self->invnum. time2str('-%Y%m%d%H%M%S', time);
1784
1785   my $file =
1786     "$spooldir/".
1787     ( $opt{'agent_spools'} ? 'agentnum'.$cust_main->agentnum : 'spool' ).
1788     ( lc($opt{'format'}) eq 'billco' ? '-header' : '' ) .
1789     '.csv';
1790
1791   my ( $header, $detail ) = $self->print_csv(%opt, 'tracctnum' => $tracctnum );
1792
1793   open(CSV, ">>$file") or die "can't open $file: $!";
1794   flock(CSV, LOCK_EX);
1795   seek(CSV, 0, 2);
1796
1797   print CSV $header;
1798
1799   if ( lc($opt{'format'}) eq 'billco' ) {
1800
1801     flock(CSV, LOCK_UN);
1802     close CSV;
1803
1804     $file =
1805       "$spooldir/".
1806       ( $opt{'agent_spools'} ? 'agentnum'.$cust_main->agentnum : 'spool' ).
1807       '-detail.csv';
1808
1809     open(CSV,">>$file") or die "can't open $file: $!";
1810     flock(CSV, LOCK_EX);
1811     seek(CSV, 0, 2);
1812   }
1813
1814   print CSV $detail;
1815
1816   flock(CSV, LOCK_UN);
1817   close CSV;
1818
1819   return '';
1820
1821 }
1822
1823 =item print_csv OPTION => VALUE, ...
1824
1825 Returns CSV data for this invoice.
1826
1827 Options are:
1828
1829 format - 'default' or 'billco'
1830
1831 Returns a list consisting of two scalars.  The first is a single line of CSV
1832 header information for this invoice.  The second is one or more lines of CSV
1833 detail information for this invoice.
1834
1835 If I<format> is not specified or "default", the fields of the CSV file are as
1836 follows:
1837
1838 record_type, invnum, custnum, _date, charged, first, last, company, address1, address2, city, state, zip, country, pkg, setup, recur, sdate, edate
1839
1840 =over 4
1841
1842 =item record type - B<record_type> is either C<cust_bill> or C<cust_bill_pkg>
1843
1844 B<record_type> is C<cust_bill> for the initial header line only.  The
1845 last five fields (B<pkg> through B<edate>) are irrelevant, and all other
1846 fields are filled in.
1847
1848 B<record_type> is C<cust_bill_pkg> for detail lines.  Only the first two fields
1849 (B<record_type> and B<invnum>) and the last five fields (B<pkg> through B<edate>)
1850 are filled in.
1851
1852 =item invnum - invoice number
1853
1854 =item custnum - customer number
1855
1856 =item _date - invoice date
1857
1858 =item charged - total invoice amount
1859
1860 =item first - customer first name
1861
1862 =item last - customer first name
1863
1864 =item company - company name
1865
1866 =item address1 - address line 1
1867
1868 =item address2 - address line 1
1869
1870 =item city
1871
1872 =item state
1873
1874 =item zip
1875
1876 =item country
1877
1878 =item pkg - line item description
1879
1880 =item setup - line item setup fee (one or both of B<setup> and B<recur> will be defined)
1881
1882 =item recur - line item recurring fee (one or both of B<setup> and B<recur> will be defined)
1883
1884 =item sdate - start date for recurring fee
1885
1886 =item edate - end date for recurring fee
1887
1888 =back
1889
1890 If I<format> is "billco", the fields of the header CSV file are as follows:
1891
1892   +-------------------------------------------------------------------+
1893   |                        FORMAT HEADER FILE                         |
1894   |-------------------------------------------------------------------|
1895   | Field | Description                   | Name       | Type | Width |
1896   | 1     | N/A-Leave Empty               | RC         | CHAR |     2 |
1897   | 2     | N/A-Leave Empty               | CUSTID     | CHAR |    15 |
1898   | 3     | Transaction Account No        | TRACCTNUM  | CHAR |    15 |
1899   | 4     | Transaction Invoice No        | TRINVOICE  | CHAR |    15 |
1900   | 5     | Transaction Zip Code          | TRZIP      | CHAR |     5 |
1901   | 6     | Transaction Company Bill To   | TRCOMPANY  | CHAR |    30 |
1902   | 7     | Transaction Contact Bill To   | TRNAME     | CHAR |    30 |
1903   | 8     | Additional Address Unit Info  | TRADDR1    | CHAR |    30 |
1904   | 9     | Bill To Street Address        | TRADDR2    | CHAR |    30 |
1905   | 10    | Ancillary Billing Information | TRADDR3    | CHAR |    30 |
1906   | 11    | Transaction City Bill To      | TRCITY     | CHAR |    20 |
1907   | 12    | Transaction State Bill To     | TRSTATE    | CHAR |     2 |
1908   | 13    | Bill Cycle Close Date         | CLOSEDATE  | CHAR |    10 |
1909   | 14    | Bill Due Date                 | DUEDATE    | CHAR |    10 |
1910   | 15    | Previous Balance              | BALFWD     | NUM* |     9 |
1911   | 16    | Pmt/CR Applied                | CREDAPPLY  | NUM* |     9 |
1912   | 17    | Total Current Charges         | CURRENTCHG | NUM* |     9 |
1913   | 18    | Total Amt Due                 | TOTALDUE   | NUM* |     9 |
1914   | 19    | Total Amt Due                 | AMTDUE     | NUM* |     9 |
1915   | 20    | 30 Day Aging                  | AMT30      | NUM* |     9 |
1916   | 21    | 60 Day Aging                  | AMT60      | NUM* |     9 |
1917   | 22    | 90 Day Aging                  | AMT90      | NUM* |     9 |
1918   | 23    | Y/N                           | AGESWITCH  | CHAR |     1 |
1919   | 24    | Remittance automation         | SCANLINE   | CHAR |   100 |
1920   | 25    | Total Taxes & Fees            | TAXTOT     | NUM* |     9 |
1921   | 26    | Customer Reference Number     | CUSTREF    | CHAR |    15 |
1922   | 27    | Federal Tax***                | FEDTAX     | NUM* |     9 |
1923   | 28    | State Tax***                  | STATETAX   | NUM* |     9 |
1924   | 29    | Other Taxes & Fees***         | OTHERTAX   | NUM* |     9 |
1925   +-------+-------------------------------+------------+------+-------+
1926
1927 If I<format> is "billco", the fields of the detail CSV file are as follows:
1928
1929                                   FORMAT FOR DETAIL FILE
1930         |                            |           |      |
1931   Field | Description                | Name      | Type | Width
1932   1     | N/A-Leave Empty            | RC        | CHAR |     2
1933   2     | N/A-Leave Empty            | CUSTID    | CHAR |    15
1934   3     | Account Number             | TRACCTNUM | CHAR |    15
1935   4     | Invoice Number             | TRINVOICE | CHAR |    15
1936   5     | Line Sequence (sort order) | LINESEQ   | NUM  |     6
1937   6     | Transaction Detail         | DETAILS   | CHAR |   100
1938   7     | Amount                     | AMT       | NUM* |     9
1939   8     | Line Format Control**      | LNCTRL    | CHAR |     2
1940   9     | Grouping Code              | GROUP     | CHAR |     2
1941   10    | User Defined               | ACCT CODE | CHAR |    15
1942
1943 =cut
1944
1945 sub print_csv {
1946   my($self, %opt) = @_;
1947
1948   eval "use Text::CSV_XS";
1949   die $@ if $@;
1950
1951   my $cust_main = $self->cust_main;
1952
1953   my $csv = Text::CSV_XS->new({'always_quote'=>1});
1954
1955   if ( lc($opt{'format'}) eq 'billco' ) {
1956
1957     my $taxtotal = 0;
1958     $taxtotal += $_->{'amount'} foreach $self->_items_tax;
1959
1960     my $duedate = $self->due_date2str('%m/%d/%Y'); #date_format?
1961
1962     my( $previous_balance, @unused ) = $self->previous; #previous balance
1963
1964     my $pmt_cr_applied = 0;
1965     $pmt_cr_applied += $_->{'amount'}
1966       foreach ( $self->_items_payments, $self->_items_credits ) ;
1967
1968     my $totaldue = sprintf('%.2f', $self->owed + $previous_balance);
1969
1970     $csv->combine(
1971       '',                         #  1 | N/A-Leave Empty               CHAR   2
1972       '',                         #  2 | N/A-Leave Empty               CHAR  15
1973       $opt{'tracctnum'},          #  3 | Transaction Account No        CHAR  15
1974       $self->invnum,              #  4 | Transaction Invoice No        CHAR  15
1975       $cust_main->zip,            #  5 | Transaction Zip Code          CHAR   5
1976       $cust_main->company,        #  6 | Transaction Company Bill To   CHAR  30
1977       #$cust_main->payname,        #  7 | Transaction Contact Bill To   CHAR  30
1978       $cust_main->contact,        #  7 | Transaction Contact Bill To   CHAR  30
1979       $cust_main->address2,       #  8 | Additional Address Unit Info  CHAR  30
1980       $cust_main->address1,       #  9 | Bill To Street Address        CHAR  30
1981       '',                         # 10 | Ancillary Billing Information CHAR  30
1982       $cust_main->city,           # 11 | Transaction City Bill To      CHAR  20
1983       $cust_main->state,          # 12 | Transaction State Bill To     CHAR   2
1984
1985       # XXX ?
1986       time2str("%m/%d/%Y", $self->_date), # 13 | Bill Cycle Close Date CHAR  10
1987
1988       # XXX ?
1989       $duedate,                   # 14 | Bill Due Date                 CHAR  10
1990
1991       $previous_balance,          # 15 | Previous Balance              NUM*   9
1992       $pmt_cr_applied,            # 16 | Pmt/CR Applied                NUM*   9
1993       sprintf("%.2f", $self->charged), # 17 | Total Current Charges    NUM*   9
1994       $totaldue,                  # 18 | Total Amt Due                 NUM*   9
1995       $totaldue,                  # 19 | Total Amt Due                 NUM*   9
1996       '',                         # 20 | 30 Day Aging                  NUM*   9
1997       '',                         # 21 | 60 Day Aging                  NUM*   9
1998       '',                         # 22 | 90 Day Aging                  NUM*   9
1999       'N',                        # 23 | Y/N                           CHAR   1
2000       '',                         # 24 | Remittance automation         CHAR 100
2001       $taxtotal,                  # 25 | Total Taxes & Fees            NUM*   9
2002       $self->custnum,             # 26 | Customer Reference Number     CHAR  15
2003       '0',                        # 27 | Federal Tax***                NUM*   9
2004       sprintf("%.2f", $taxtotal), # 28 | State Tax***                  NUM*   9
2005       '0',                        # 29 | Other Taxes & Fees***         NUM*   9
2006     );
2007
2008   } else {
2009
2010     $csv->combine(
2011       'cust_bill',
2012       $self->invnum,
2013       $self->custnum,
2014       time2str("%x", $self->_date),
2015       sprintf("%.2f", $self->charged),
2016       ( map { $cust_main->getfield($_) }
2017           qw( first last company address1 address2 city state zip country ) ),
2018       map { '' } (1..5),
2019     ) or die "can't create csv";
2020   }
2021
2022   my $header = $csv->string. "\n";
2023
2024   my $detail = '';
2025   if ( lc($opt{'format'}) eq 'billco' ) {
2026
2027     my $lineseq = 0;
2028     foreach my $item ( $self->_items_pkg ) {
2029
2030       $csv->combine(
2031         '',                     #  1 | N/A-Leave Empty            CHAR   2
2032         '',                     #  2 | N/A-Leave Empty            CHAR  15
2033         $opt{'tracctnum'},      #  3 | Account Number             CHAR  15
2034         $self->invnum,          #  4 | Invoice Number             CHAR  15
2035         $lineseq++,             #  5 | Line Sequence (sort order) NUM    6
2036         $item->{'description'}, #  6 | Transaction Detail         CHAR 100
2037         $item->{'amount'},      #  7 | Amount                     NUM*   9
2038         '',                     #  8 | Line Format Control**      CHAR   2
2039         '',                     #  9 | Grouping Code              CHAR   2
2040         '',                     # 10 | User Defined               CHAR  15
2041       );
2042
2043       $detail .= $csv->string. "\n";
2044
2045     }
2046
2047   } else {
2048
2049     foreach my $cust_bill_pkg ( $self->cust_bill_pkg ) {
2050
2051       my($pkg, $setup, $recur, $sdate, $edate);
2052       if ( $cust_bill_pkg->pkgnum ) {
2053
2054         ($pkg, $setup, $recur, $sdate, $edate) = (
2055           $cust_bill_pkg->part_pkg->pkg,
2056           ( $cust_bill_pkg->setup != 0
2057             ? sprintf("%.2f", $cust_bill_pkg->setup )
2058             : '' ),
2059           ( $cust_bill_pkg->recur != 0
2060             ? sprintf("%.2f", $cust_bill_pkg->recur )
2061             : '' ),
2062           ( $cust_bill_pkg->sdate
2063             ? time2str("%x", $cust_bill_pkg->sdate)
2064             : '' ),
2065           ($cust_bill_pkg->edate
2066             ?time2str("%x", $cust_bill_pkg->edate)
2067             : '' ),
2068         );
2069
2070       } else { #pkgnum tax
2071         next unless $cust_bill_pkg->setup != 0;
2072         $pkg = $cust_bill_pkg->desc;
2073         $setup = sprintf('%10.2f', $cust_bill_pkg->setup );
2074         ( $sdate, $edate ) = ( '', '' );
2075       }
2076
2077       $csv->combine(
2078         'cust_bill_pkg',
2079         $self->invnum,
2080         ( map { '' } (1..11) ),
2081         ($pkg, $setup, $recur, $sdate, $edate)
2082       ) or die "can't create csv";
2083
2084       $detail .= $csv->string. "\n";
2085
2086     }
2087
2088   }
2089
2090   ( $header, $detail );
2091
2092 }
2093
2094 =item comp
2095
2096 Pays this invoice with a compliemntary payment.  If there is an error,
2097 returns the error, otherwise returns false.
2098
2099 =cut
2100
2101 sub comp {
2102   my $self = shift;
2103   my $cust_pay = new FS::cust_pay ( {
2104     'invnum'   => $self->invnum,
2105     'paid'     => $self->owed,
2106     '_date'    => '',
2107     'payby'    => 'COMP',
2108     'payinfo'  => $self->cust_main->payinfo,
2109     'paybatch' => '',
2110   } );
2111   $cust_pay->insert;
2112 }
2113
2114 =item realtime_card
2115
2116 Attempts to pay this invoice with a credit card payment via a
2117 Business::OnlinePayment realtime gateway.  See
2118 http://search.cpan.org/search?mode=module&query=Business%3A%3AOnlinePayment
2119 for supported processors.
2120
2121 =cut
2122
2123 sub realtime_card {
2124   my $self = shift;
2125   $self->realtime_bop( 'CC', @_ );
2126 }
2127
2128 =item realtime_ach
2129
2130 Attempts to pay this invoice with an electronic check (ACH) payment via a
2131 Business::OnlinePayment realtime gateway.  See
2132 http://search.cpan.org/search?mode=module&query=Business%3A%3AOnlinePayment
2133 for supported processors.
2134
2135 =cut
2136
2137 sub realtime_ach {
2138   my $self = shift;
2139   $self->realtime_bop( 'ECHECK', @_ );
2140 }
2141
2142 =item realtime_lec
2143
2144 Attempts to pay this invoice with phone bill (LEC) payment via a
2145 Business::OnlinePayment realtime gateway.  See
2146 http://search.cpan.org/search?mode=module&query=Business%3A%3AOnlinePayment
2147 for supported processors.
2148
2149 =cut
2150
2151 sub realtime_lec {
2152   my $self = shift;
2153   $self->realtime_bop( 'LEC', @_ );
2154 }
2155
2156 sub realtime_bop {
2157   my( $self, $method ) = (shift,shift);
2158   my $conf = $self->conf;
2159   my %opt = @_;
2160
2161   my $cust_main = $self->cust_main;
2162   my $balance = $cust_main->balance;
2163   my $amount = ( $balance < $self->owed ) ? $balance : $self->owed;
2164   $amount = sprintf("%.2f", $amount);
2165   return "not run (balance $balance)" unless $amount > 0;
2166
2167   my $description = 'Internet Services';
2168   if ( $conf->exists('business-onlinepayment-description') ) {
2169     my $dtempl = $conf->config('business-onlinepayment-description');
2170
2171     my $agent_obj = $cust_main->agent
2172       or die "can't retreive agent for $cust_main (agentnum ".
2173              $cust_main->agentnum. ")";
2174     my $agent = $agent_obj->agent;
2175     my $pkgs = join(', ',
2176       map { $_->part_pkg->pkg }
2177         grep { $_->pkgnum } $self->cust_bill_pkg
2178     );
2179     $description = eval qq("$dtempl");
2180   }
2181
2182   $cust_main->realtime_bop($method, $amount,
2183     'description' => $description,
2184     'invnum'      => $self->invnum,
2185 #this didn't do what we want, it just calls apply_payments_and_credits
2186 #    'apply'       => 1,
2187     'apply_to_invoice' => 1,
2188     %opt,
2189  #what we want:
2190  #this changes application behavior: auto payments
2191                         #triggered against a specific invoice are now applied
2192                         #to that invoice instead of oldest open.
2193                         #seem okay to me...
2194   );
2195
2196 }
2197
2198 =item batch_card OPTION => VALUE...
2199
2200 Adds a payment for this invoice to the pending credit card batch (see
2201 L<FS::cust_pay_batch>), or, if the B<realtime> option is set to a true value,
2202 runs the payment using a realtime gateway.
2203
2204 =cut
2205
2206 sub batch_card {
2207   my ($self, %options) = @_;
2208   my $cust_main = $self->cust_main;
2209
2210   $options{invnum} = $self->invnum;
2211
2212   $cust_main->batch_card(%options);
2213 }
2214
2215 sub _agent_template {
2216   my $self = shift;
2217   $self->cust_main->agent_template;
2218 }
2219
2220 sub _agent_invoice_from {
2221   my $self = shift;
2222   $self->cust_main->agent_invoice_from;
2223 }
2224
2225 =item print_text HASHREF | [ TIME [ , TEMPLATE [ , OPTION => VALUE ... ] ] ]
2226
2227 Returns an text invoice, as a list of lines.
2228
2229 Options can be passed as a hashref (recommended) or as a list of time, template
2230 and then any key/value pairs for any other options.
2231
2232 I<time>, if specified, is used to control the printing of overdue messages.  The
2233 default is now.  It isn't the date of the invoice; that's the `_date' field.
2234 It is specified as a UNIX timestamp; see L<perlfunc/"time">.  Also see
2235 L<Time::Local> and L<Date::Parse> for conversion functions.
2236
2237 I<template>, if specified, is the name of a suffix for alternate invoices.
2238
2239 I<notice_name>, if specified, overrides "Invoice" as the name of the sent document (templates from 10/2009 or newer required)
2240
2241 =cut
2242
2243 sub print_text {
2244   my $self = shift;
2245   my( $today, $template, %opt );
2246   if ( ref($_[0]) ) {
2247     %opt = %{ shift() };
2248     $today = delete($opt{'time'}) || '';
2249     $template = delete($opt{template}) || '';
2250   } else {
2251     ( $today, $template, %opt ) = @_;
2252   }
2253
2254   my %params = ( 'format' => 'template' );
2255   $params{'time'} = $today if $today;
2256   $params{'template'} = $template if $template;
2257   $params{$_} = $opt{$_}
2258     foreach grep $opt{$_}, qw( unsquelch_cdr notice_name );
2259
2260   $self->print_generic( %params );
2261 }
2262
2263 =item print_latex HASHREF | [ TIME [ , TEMPLATE [ , OPTION => VALUE ... ] ] ]
2264
2265 Internal method - returns a filename of a filled-in LaTeX template for this
2266 invoice (Note: add ".tex" to get the actual filename), and a filename of
2267 an associated logo (with the .eps extension included).
2268
2269 See print_ps and print_pdf for methods that return PostScript and PDF output.
2270
2271 Options can be passed as a hashref (recommended) or as a list of time, template
2272 and then any key/value pairs for any other options.
2273
2274 I<time>, if specified, is used to control the printing of overdue messages.  The
2275 default is now.  It isn't the date of the invoice; that's the `_date' field.
2276 It is specified as a UNIX timestamp; see L<perlfunc/"time">.  Also see
2277 L<Time::Local> and L<Date::Parse> for conversion functions.
2278
2279 I<template>, if specified, is the name of a suffix for alternate invoices.
2280
2281 I<notice_name>, if specified, overrides "Invoice" as the name of the sent document (templates from 10/2009 or newer required)
2282
2283 =cut
2284
2285 sub print_latex {
2286   my $self = shift;
2287   my $conf = $self->conf;
2288   my( $today, $template, %opt );
2289   if ( ref($_[0]) ) {
2290     %opt = %{ shift() };
2291     $today = delete($opt{'time'}) || '';
2292     $template = delete($opt{template}) || '';
2293   } else {
2294     ( $today, $template, %opt ) = @_;
2295   }
2296
2297   my %params = ( 'format' => 'latex' );
2298   $params{'time'} = $today if $today;
2299   $params{'template'} = $template if $template;
2300   $params{$_} = $opt{$_}
2301     foreach grep $opt{$_}, qw( unsquelch_cdr notice_name );
2302
2303   $template ||= $self->_agent_template;
2304
2305   my $dir = $FS::UID::conf_dir. "/cache.". $FS::UID::datasrc;
2306   my $lh = new File::Temp( TEMPLATE => 'invoice.'. $self->invnum. '.XXXXXXXX',
2307                            DIR      => $dir,
2308                            SUFFIX   => '.eps',
2309                            UNLINK   => 0,
2310                          ) or die "can't open temp file: $!\n";
2311
2312   my $agentnum = $self->cust_main->agentnum;
2313
2314   if ( $template && $conf->exists("logo_${template}.eps", $agentnum) ) {
2315     print $lh $conf->config_binary("logo_${template}.eps", $agentnum)
2316       or die "can't write temp file: $!\n";
2317   } else {
2318     print $lh $conf->config_binary('logo.eps', $agentnum)
2319       or die "can't write temp file: $!\n";
2320   }
2321   close $lh;
2322   $params{'logo_file'} = $lh->filename;
2323
2324   if($conf->exists('invoice-barcode')){
2325       my $png_file = $self->invoice_barcode($dir);
2326       my $eps_file = $png_file;
2327       $eps_file =~ s/\.png$/.eps/g;
2328       $png_file =~ /(barcode.*png)/;
2329       $png_file = $1;
2330       $eps_file =~ /(barcode.*eps)/;
2331       $eps_file = $1;
2332
2333       my $curr_dir = cwd();
2334       chdir($dir);
2335       # after painfuly long experimentation, it was determined that sam2p won't
2336       # accept : and other chars in the path, no matter how hard I tried to
2337       # escape them, hence the chdir (and chdir back, just to be safe)
2338       system('sam2p', '-j:quiet', $png_file, 'EPS:', $eps_file ) == 0
2339         or die "sam2p failed: $!\n";
2340       unlink($png_file);
2341       chdir($curr_dir);
2342
2343       $params{'barcode_file'} = $eps_file;
2344   }
2345
2346   my @filled_in = $self->print_generic( %params );
2347
2348   my $fh = new File::Temp( TEMPLATE => 'invoice.'. $self->invnum. '.XXXXXXXX',
2349                            DIR      => $dir,
2350                            SUFFIX   => '.tex',
2351                            UNLINK   => 0,
2352                          ) or die "can't open temp file: $!\n";
2353   binmode($fh, ':utf8'); # language support
2354   print $fh join('', @filled_in );
2355   close $fh;
2356
2357   $fh->filename =~ /^(.*).tex$/ or die "unparsable filename: ". $fh->filename;
2358   return ($1, $params{'logo_file'}, $params{'barcode_file'});
2359
2360 }
2361
2362 =item invoice_barcode DIR_OR_FALSE
2363
2364 Generates an invoice barcode PNG. If DIR_OR_FALSE is a true value,
2365 it is taken as the temp directory where the PNG file will be generated and the
2366 PNG file name is returned. Otherwise, the PNG image itself is returned.
2367
2368 =cut
2369
2370 sub invoice_barcode {
2371     my ($self, $dir) = (shift,shift);
2372
2373     my $gdbar = new GD::Barcode('Code39',$self->invnum);
2374         die "can't create barcode: " . $GD::Barcode::errStr unless $gdbar;
2375     my $gd = $gdbar->plot(Height => 30);
2376
2377     if($dir) {
2378         my $bh = new File::Temp( TEMPLATE => 'barcode.'. $self->invnum. '.XXXXXXXX',
2379                            DIR      => $dir,
2380                            SUFFIX   => '.png',
2381                            UNLINK   => 0,
2382                          ) or die "can't open temp file: $!\n";
2383         print $bh $gd->png or die "cannot write barcode to file: $!\n";
2384         my $png_file = $bh->filename;
2385         close $bh;
2386         return $png_file;
2387     }
2388     return $gd->png;
2389 }
2390
2391 =item print_generic OPTION => VALUE ...
2392
2393 Internal method - returns a filled-in template for this invoice as a scalar.
2394
2395 See print_ps and print_pdf for methods that return PostScript and PDF output.
2396
2397 Non optional options include
2398   format - latex, html, template
2399
2400 Optional options include
2401
2402 template - a value used as a suffix for a configuration template
2403
2404 time - a value used to control the printing of overdue messages.  The
2405 default is now.  It isn't the date of the invoice; that's the `_date' field.
2406 It is specified as a UNIX timestamp; see L<perlfunc/"time">.  Also see
2407 L<Time::Local> and L<Date::Parse> for conversion functions.
2408
2409 cid -
2410
2411 unsquelch_cdr - overrides any per customer cdr squelching when true
2412
2413 notice_name - overrides "Invoice" as the name of the sent document (templates from 10/2009 or newer required)
2414
2415 locale - override customer's locale
2416
2417 =cut
2418
2419 #what's with all the sprintf('%10.2f')'s in here?  will it cause any
2420 # (alignment in text invoice?) problems to change them all to '%.2f' ?
2421 # yes: fixed width/plain text printing will be borked
2422 sub print_generic {
2423   my( $self, %params ) = @_;
2424   my $conf = $self->conf;
2425   my $today = $params{today} ? $params{today} : time;
2426   warn "$me print_generic called on $self with suffix $params{template}\n"
2427     if $DEBUG;
2428
2429   my $format = $params{format};
2430   die "Unknown format: $format"
2431     unless $format =~ /^(latex|html|template)$/;
2432
2433   my $cust_main = $self->cust_main;
2434   $cust_main->payname( $cust_main->first. ' '. $cust_main->getfield('last') )
2435     unless $cust_main->payname
2436         && $cust_main->payby !~ /^(CARD|DCRD|CHEK|DCHK)$/;
2437
2438   my %delimiters = ( 'latex'    => [ '[@--', '--@]' ],
2439                      'html'     => [ '<%=', '%>' ],
2440                      'template' => [ '{', '}' ],
2441                    );
2442
2443   warn "$me print_generic creating template\n"
2444     if $DEBUG > 1;
2445
2446   #create the template
2447   my $template = $params{template} ? $params{template} : $self->_agent_template;
2448   my $templatefile = "invoice_$format";
2449   $templatefile .= "_$template"
2450     if length($template) && $conf->exists($templatefile."_$template");
2451   my @invoice_template = map "$_\n", $conf->config($templatefile)
2452     or die "cannot load config data $templatefile";
2453
2454   my $old_latex = '';
2455   if ( $format eq 'latex' && grep { /^%%Detail/ } @invoice_template ) {
2456     #change this to a die when the old code is removed
2457     warn "old-style invoice template $templatefile; ".
2458          "patch with conf/invoice_latex.diff or use new conf/invoice_latex*\n";
2459     $old_latex = 'true';
2460     @invoice_template = _translate_old_latex_format(@invoice_template);
2461   }
2462
2463   warn "$me print_generic creating T:T object\n"
2464     if $DEBUG > 1;
2465
2466   my $text_template = new Text::Template(
2467     TYPE => 'ARRAY',
2468     SOURCE => \@invoice_template,
2469     DELIMITERS => $delimiters{$format},
2470   );
2471
2472   warn "$me print_generic compiling T:T object\n"
2473     if $DEBUG > 1;
2474
2475   $text_template->compile()
2476     or die "Can't compile $templatefile: $Text::Template::ERROR\n";
2477
2478
2479   # additional substitution could possibly cause breakage in existing templates
2480   my %convert_maps = (
2481     'latex' => {
2482                  'notes'         => sub { map "$_", @_ },
2483                  'footer'        => sub { map "$_", @_ },
2484                  'smallfooter'   => sub { map "$_", @_ },
2485                  'returnaddress' => sub { map "$_", @_ },
2486                  'coupon'        => sub { map "$_", @_ },
2487                  'summary'       => sub { map "$_", @_ },
2488                },
2489     'html'  => {
2490                  'notes' =>
2491                    sub {
2492                      map {
2493                        s/%%(.*)$/<!-- $1 -->/g;
2494                        s/\\section\*\{\\textsc\{(.)(.*)\}\}/<p><b><font size="+1">$1<\/font>\U$2<\/b>/g;
2495                        s/\\begin\{enumerate\}/<ol>/g;
2496                        s/\\item /  <li>/g;
2497                        s/\\end\{enumerate\}/<\/ol>/g;
2498                        s/\\textbf\{(.*)\}/<b>$1<\/b>/g;
2499                        s/\\\\\*/<br>/g;
2500                        s/\\dollar ?/\$/g;
2501                        s/\\#/#/g;
2502                        s/~/&nbsp;/g;
2503                        $_;
2504                      }  @_
2505                    },
2506                  'footer' =>
2507                    sub { map { s/~/&nbsp;/g; s/\\\\\*?\s*$/<BR>/; $_; } @_ },
2508                  'smallfooter' =>
2509                    sub { map { s/~/&nbsp;/g; s/\\\\\*?\s*$/<BR>/; $_; } @_ },
2510                  'returnaddress' =>
2511                    sub {
2512                      map {
2513                        s/~/&nbsp;/g;
2514                        s/\\\\\*?\s*$/<BR>/;
2515                        s/\\hyphenation\{[\w\s\-]+}//;
2516                        s/\\([&])/$1/g;
2517                        $_;
2518                      }  @_
2519                    },
2520                  'coupon'        => sub { "" },
2521                  'summary'       => sub { "" },
2522                },
2523     'template' => {
2524                  'notes' =>
2525                    sub {
2526                      map {
2527                        s/%%.*$//g;
2528                        s/\\section\*\{\\textsc\{(.*)\}\}/\U$1/g;
2529                        s/\\begin\{enumerate\}//g;
2530                        s/\\item /  * /g;
2531                        s/\\end\{enumerate\}//g;
2532                        s/\\textbf\{(.*)\}/$1/g;
2533                        s/\\\\\*/ /;
2534                        s/\\dollar ?/\$/g;
2535                        $_;
2536                      }  @_
2537                    },
2538                  'footer' =>
2539                    sub { map { s/~/ /g; s/\\\\\*?\s*$/\n/; $_; } @_ },
2540                  'smallfooter' =>
2541                    sub { map { s/~/ /g; s/\\\\\*?\s*$/\n/; $_; } @_ },
2542                  'returnaddress' =>
2543                    sub {
2544                      map {
2545                        s/~/ /g;
2546                        s/\\\\\*?\s*$/\n/;             # dubious
2547                        s/\\hyphenation\{[\w\s\-]+}//;
2548                        $_;
2549                      }  @_
2550                    },
2551                  'coupon'        => sub { "" },
2552                  'summary'       => sub { "" },
2553                },
2554   );
2555
2556
2557   # hashes for differing output formats
2558   my %nbsps = ( 'latex'    => '~',
2559                 'html'     => '',    # '&nbps;' would be nice
2560                 'template' => '',    # not used
2561               );
2562   my $nbsp = $nbsps{$format};
2563
2564   my %escape_functions = ( 'latex'    => \&_latex_escape,
2565                            'html'     => \&_html_escape_nbsp,#\&encode_entities,
2566                            'template' => sub { shift },
2567                          );
2568   my $escape_function = $escape_functions{$format};
2569   my $escape_function_nonbsp = ($format eq 'html')
2570                                  ? \&_html_escape : $escape_function;
2571
2572   my %date_formats = ( 'latex'    => $date_format_long,
2573                        'html'     => $date_format_long,
2574                        'template' => '%s',
2575                      );
2576   $date_formats{'html'} =~ s/ /&nbsp;/g;
2577
2578   my $date_format = $date_formats{$format};
2579
2580   my %embolden_functions = ( 'latex'    => sub { return '\textbf{'. shift(). '}'
2581                                                },
2582                              'html'     => sub { return '<b>'. shift(). '</b>'
2583                                                },
2584                              'template' => sub { shift },
2585                            );
2586   my $embolden_function = $embolden_functions{$format};
2587
2588   my %newline_tokens = (  'latex'     => '\\\\',
2589                           'html'      => '<br>',
2590                           'template'  => "\n",
2591                         );
2592   my $newline_token = $newline_tokens{$format};
2593
2594   warn "$me generating template variables\n"
2595     if $DEBUG > 1;
2596
2597   # generate template variables
2598   my $returnaddress;
2599   if (
2600          defined( $conf->config_orbase( "invoice_${format}returnaddress",
2601                                         $template
2602                                       )
2603                 )
2604        && length( $conf->config_orbase( "invoice_${format}returnaddress",
2605                                         $template
2606                                       )
2607                 )
2608   ) {
2609
2610     $returnaddress = join("\n",
2611       $conf->config_orbase("invoice_${format}returnaddress", $template)
2612     );
2613
2614   } elsif ( grep /\S/,
2615             $conf->config_orbase('invoice_latexreturnaddress', $template) ) {
2616
2617     my $convert_map = $convert_maps{$format}{'returnaddress'};
2618     $returnaddress =
2619       join( "\n",
2620             &$convert_map( $conf->config_orbase( "invoice_latexreturnaddress",
2621                                                  $template
2622                                                )
2623                          )
2624           );
2625   } elsif ( grep /\S/, $conf->config('company_address', $self->cust_main->agentnum) ) {
2626
2627     my $convert_map = $convert_maps{$format}{'returnaddress'};
2628     $returnaddress = join( "\n", &$convert_map(
2629                                    map { s/( {2,})/'~' x length($1)/eg;
2630                                          s/$/\\\\\*/;
2631                                          $_
2632                                        }
2633                                      ( $conf->config('company_name', $self->cust_main->agentnum),
2634                                        $conf->config('company_address', $self->cust_main->agentnum),
2635                                      )
2636                                  )
2637                      );
2638
2639   } else {
2640
2641     my $warning = "Couldn't find a return address; ".
2642                   "do you need to set the company_address configuration value?";
2643     warn "$warning\n";
2644     $returnaddress = $nbsp;
2645     #$returnaddress = $warning;
2646
2647   }
2648
2649   warn "$me generating invoice data\n"
2650     if $DEBUG > 1;
2651
2652   my $agentnum = $self->cust_main->agentnum;
2653
2654   my %invoice_data = (
2655
2656     #invoice from info
2657     'company_name'    => scalar( $conf->config('company_name', $agentnum) ),
2658     'company_address' => join("\n", $conf->config('company_address', $agentnum) ). "\n",
2659     'company_phonenum'=> scalar( $conf->config('company_phonenum', $agentnum) ),
2660     'returnaddress'   => $returnaddress,
2661     'agent'           => &$escape_function($cust_main->agent->agent),
2662
2663     #invoice info
2664     'invnum'          => $self->invnum,
2665     'date'            => time2str($date_format, $self->_date),
2666     'today'           => time2str($date_format_long, $today),
2667     'terms'           => $self->terms,
2668     'template'        => $template, #params{'template'},
2669     'notice_name'     => ($params{'notice_name'} || 'Invoice'),#escape_function?
2670     'current_charges' => sprintf("%.2f", $self->charged),
2671     'duedate'         => $self->due_date2str($rdate_format), #date_format?
2672
2673     #customer info
2674     'custnum'         => $cust_main->display_custnum,
2675     'agent_custid'    => &$escape_function($cust_main->agent_custid),
2676     ( map { $_ => &$escape_function($cust_main->$_()) } qw(
2677       payname company address1 address2 city state zip fax
2678     )),
2679
2680     #global config
2681     'ship_enable'     => $conf->exists('invoice-ship_address'),
2682     'unitprices'      => $conf->exists('invoice-unitprice'),
2683     'smallernotes'    => $conf->exists('invoice-smallernotes'),
2684     'smallerfooter'   => $conf->exists('invoice-smallerfooter'),
2685     'balance_due_below_line' => $conf->exists('balance_due_below_line'),
2686
2687     #layout info -- would be fancy to calc some of this and bury the template
2688     #               here in the code
2689     'topmargin'             => scalar($conf->config('invoice_latextopmargin', $agentnum)),
2690     'headsep'               => scalar($conf->config('invoice_latexheadsep', $agentnum)),
2691     'textheight'            => scalar($conf->config('invoice_latextextheight', $agentnum)),
2692     'extracouponspace'      => scalar($conf->config('invoice_latexextracouponspace', $agentnum)),
2693     'couponfootsep'         => scalar($conf->config('invoice_latexcouponfootsep', $agentnum)),
2694     'verticalreturnaddress' => $conf->exists('invoice_latexverticalreturnaddress', $agentnum),
2695     'addresssep'            => scalar($conf->config('invoice_latexaddresssep', $agentnum)),
2696     'amountenclosedsep'     => scalar($conf->config('invoice_latexcouponamountenclosedsep', $agentnum)),
2697     'coupontoaddresssep'    => scalar($conf->config('invoice_latexcoupontoaddresssep', $agentnum)),
2698     'addcompanytoaddress'   => $conf->exists('invoice_latexcouponaddcompanytoaddress', $agentnum),
2699
2700     # better hang on to conf_dir for a while (for old templates)
2701     'conf_dir'        => "$FS::UID::conf_dir/conf.$FS::UID::datasrc",
2702
2703     #these are only used when doing paged plaintext
2704     'page'            => 1,
2705     'total_pages'     => 1,
2706
2707   );
2708
2709   #localization
2710   my $lh = FS::L10N->get_handle( $params{'locale'} || $cust_main->locale );
2711   $invoice_data{'emt'} = sub { &$escape_function($self->mt(@_)) };
2712   my %info = FS::Locales->locale_info($cust_main->locale || 'en_US');
2713   # eval to avoid death for unimplemented languages
2714   my $dh = eval { Date::Language->new($info{'name'}) } ||
2715            Date::Language->new(); # fall back to English
2716   # prototype here to silence warnings
2717   $invoice_data{'time2str'} = sub ($;$$) { $dh->time2str(@_) };
2718   # eventually use this date handle everywhere in here, too
2719
2720   my $min_sdate = 999999999999;
2721   my $max_edate = 0;
2722   foreach my $cust_bill_pkg ( $self->cust_bill_pkg ) {
2723     next unless $cust_bill_pkg->pkgnum > 0;
2724     $min_sdate = $cust_bill_pkg->sdate
2725       if length($cust_bill_pkg->sdate) && $cust_bill_pkg->sdate < $min_sdate;
2726     $max_edate = $cust_bill_pkg->edate
2727       if length($cust_bill_pkg->edate) && $cust_bill_pkg->edate > $max_edate;
2728   }
2729
2730   $invoice_data{'bill_period'} = '';
2731   $invoice_data{'bill_period'} = time2str('%e %h', $min_sdate)
2732     . " to " . time2str('%e %h', $max_edate)
2733     if ($max_edate != 0 && $min_sdate != 999999999999);
2734
2735   $invoice_data{finance_section} = '';
2736   if ( $conf->config('finance_pkgclass') ) {
2737     my $pkg_class =
2738       qsearchs('pkg_class', { classnum => $conf->config('finance_pkgclass') });
2739     $invoice_data{finance_section} = $pkg_class->categoryname;
2740   }
2741   $invoice_data{finance_amount} = '0.00';
2742   $invoice_data{finance_section} ||= 'Finance Charges'; #avoid config confusion
2743
2744   my $countrydefault = $conf->config('countrydefault') || 'US';
2745   my $prefix = $cust_main->has_ship_address ? 'ship_' : '';
2746   foreach ( qw( contact company address1 address2 city state zip country fax) ){
2747     my $method = $prefix.$_;
2748     $invoice_data{"ship_$_"} = _latex_escape($cust_main->$method);
2749   }
2750   $invoice_data{'ship_country'} = ''
2751     if ( $invoice_data{'ship_country'} eq $countrydefault );
2752
2753   $invoice_data{'cid'} = $params{'cid'}
2754     if $params{'cid'};
2755
2756   if ( $cust_main->country eq $countrydefault ) {
2757     $invoice_data{'country'} = '';
2758   } else {
2759     $invoice_data{'country'} = &$escape_function(code2country($cust_main->country));
2760   }
2761
2762   my @address = ();
2763   $invoice_data{'address'} = \@address;
2764   push @address,
2765     $cust_main->payname.
2766       ( ( $cust_main->payby eq 'BILL' ) && $cust_main->payinfo
2767         ? " (P.O. #". $cust_main->payinfo. ")"
2768         : ''
2769       )
2770   ;
2771   push @address, $cust_main->company
2772     if $cust_main->company;
2773   push @address, $cust_main->address1;
2774   push @address, $cust_main->address2
2775     if $cust_main->address2;
2776   push @address,
2777     $cust_main->city. ", ". $cust_main->state. "  ".  $cust_main->zip;
2778   push @address, $invoice_data{'country'}
2779     if $invoice_data{'country'};
2780   push @address, ''
2781     while (scalar(@address) < 5);
2782
2783   $invoice_data{'logo_file'} = $params{'logo_file'}
2784     if $params{'logo_file'};
2785   $invoice_data{'barcode_file'} = $params{'barcode_file'}
2786     if $params{'barcode_file'};
2787   $invoice_data{'barcode_img'} = $params{'barcode_img'}
2788     if $params{'barcode_img'};
2789   $invoice_data{'barcode_cid'} = $params{'barcode_cid'}
2790     if $params{'barcode_cid'};
2791
2792   my( $pr_total, @pr_cust_bill ) = $self->previous; #previous balance
2793 #  my( $cr_total, @cr_cust_credit ) = $self->cust_credit; #credits
2794   #my $balance_due = $self->owed + $pr_total - $cr_total;
2795   my $balance_due = $self->owed + $pr_total;
2796
2797   # the customer's current balance as shown on the invoice before this one
2798   $invoice_data{'true_previous_balance'} = sprintf("%.2f", ($self->previous_balance || 0) );
2799
2800   # the change in balance from that invoice to this one
2801   $invoice_data{'balance_adjustments'} = sprintf("%.2f", ($self->previous_balance || 0) - ($self->billing_balance || 0) );
2802
2803   # the sum of amount owed on all previous invoices
2804   $invoice_data{'previous_balance'} = sprintf("%.2f", $pr_total);
2805
2806   # the sum of amount owed on all invoices
2807   $invoice_data{'balance'} = sprintf("%.2f", $balance_due);
2808
2809   # info from customer's last invoice before this one, for some
2810   # summary formats
2811   $invoice_data{'last_bill'} = {};
2812   my $last_bill = $pr_cust_bill[-1];
2813   if ( $last_bill ) {
2814     $invoice_data{'last_bill'} = {
2815       '_date'     => $last_bill->_date, #unformatted
2816       # all we need for now
2817     };
2818   }
2819
2820   my $summarypage = '';
2821   if ( $conf->exists('invoice_usesummary', $agentnum) ) {
2822     $summarypage = 1;
2823   }
2824   $invoice_data{'summarypage'} = $summarypage;
2825
2826   warn "$me substituting variables in notes, footer, smallfooter\n"
2827     if $DEBUG > 1;
2828
2829   my @include = (qw( notes footer smallfooter ));
2830   push @include, 'coupon' unless $params{'no_coupon'};
2831   foreach my $include (@include) {
2832
2833     my $inc_file = $conf->key_orbase("invoice_${format}$include", $template);
2834     my @inc_src;
2835
2836     if ( $conf->exists($inc_file, $agentnum)
2837          && length( $conf->config($inc_file, $agentnum) ) ) {
2838
2839       @inc_src = $conf->config($inc_file, $agentnum);
2840
2841     } else {
2842
2843       $inc_file = $conf->key_orbase("invoice_latex$include", $template);
2844
2845       my $convert_map = $convert_maps{$format}{$include};
2846
2847       @inc_src = map { s/\[\@--/$delimiters{$format}[0]/g;
2848                        s/--\@\]/$delimiters{$format}[1]/g;
2849                        $_;
2850                      }
2851                  &$convert_map( $conf->config($inc_file, $agentnum) );
2852
2853     }
2854
2855     my $inc_tt = new Text::Template (
2856       TYPE       => 'ARRAY',
2857       SOURCE     => [ map "$_\n", @inc_src ],
2858       DELIMITERS => $delimiters{$format},
2859     ) or die "Can't create new Text::Template object: $Text::Template::ERROR";
2860
2861     unless ( $inc_tt->compile() ) {
2862       my $error = "Can't compile $inc_file template: $Text::Template::ERROR\n";
2863       warn $error. "Template:\n". join('', map "$_\n", @inc_src);
2864       die $error;
2865     }
2866
2867     $invoice_data{$include} = $inc_tt->fill_in( HASH => \%invoice_data );
2868
2869     $invoice_data{$include} =~ s/\n+$//
2870       if ($format eq 'latex');
2871   }
2872
2873   # let invoices use either of these as needed
2874   $invoice_data{'po_num'} = ($cust_main->payby eq 'BILL')
2875     ? $cust_main->payinfo : '';
2876   $invoice_data{'po_line'} =
2877     (  $cust_main->payby eq 'BILL' && $cust_main->payinfo )
2878       ? &$escape_function($self->mt("Purchase Order #").$cust_main->payinfo)
2879       : $nbsp;
2880
2881   my %money_chars = ( 'latex'    => '',
2882                       'html'     => $conf->config('money_char') || '$',
2883                       'template' => '',
2884                     );
2885   my $money_char = $money_chars{$format};
2886
2887   my %other_money_chars = ( 'latex'    => '\dollar ',#XXX should be a config too
2888                             'html'     => $conf->config('money_char') || '$',
2889                             'template' => '',
2890                           );
2891   my $other_money_char = $other_money_chars{$format};
2892   $invoice_data{'dollar'} = $other_money_char;
2893
2894   my @detail_items = ();
2895   my @total_items = ();
2896   my @buf = ();
2897   my @sections = ();
2898
2899   $invoice_data{'detail_items'} = \@detail_items;
2900   $invoice_data{'total_items'} = \@total_items;
2901   $invoice_data{'buf'} = \@buf;
2902   $invoice_data{'sections'} = \@sections;
2903
2904   warn "$me generating sections\n"
2905     if $DEBUG > 1;
2906
2907   my $previous_section = { 'description' => $self->mt('Previous Charges'),
2908                            'subtotal'    => $other_money_char.
2909                                             sprintf('%.2f', $pr_total),
2910                            'summarized'  => '', #why? $summarypage ? 'Y' : '',
2911                          };
2912   $previous_section->{posttotal} = '0 / 30 / 60 / 90 days overdue '.
2913     join(' / ', map { $cust_main->balance_date_range(@$_) }
2914                 $self->_prior_month30s
2915         )
2916     if $conf->exists('invoice_include_aging');
2917
2918   my $taxtotal = 0;
2919   my $tax_section = { 'description' => $self->mt('Taxes, Surcharges, and Fees'),
2920                       'subtotal'    => $taxtotal,   # adjusted below
2921                     };
2922   my $tax_weight = _pkg_category($tax_section->{description})
2923                         ? _pkg_category($tax_section->{description})->weight
2924                         : 0;
2925   $tax_section->{'summarized'} = ''; #why? $summarypage && !$tax_weight ? 'Y' : '';
2926   $tax_section->{'sort_weight'} = $tax_weight;
2927
2928
2929   my $adjusttotal = 0;
2930   my $adjust_section = { 'description' =>
2931     $self->mt('Credits, Payments, and Adjustments'),
2932                          'subtotal'    => 0,   # adjusted below
2933                        };
2934   my $adjust_weight = _pkg_category($adjust_section->{description})
2935                         ? _pkg_category($adjust_section->{description})->weight
2936                         : 0;
2937   $adjust_section->{'summarized'} = ''; #why? $summarypage && !$adjust_weight ? 'Y' : '';
2938   $adjust_section->{'sort_weight'} = $adjust_weight;
2939
2940   my $unsquelched = $params{unsquelch_cdr} || $cust_main->squelch_cdr ne 'Y';
2941   my $multisection = $conf->exists('invoice_sections', $cust_main->agentnum);
2942   $invoice_data{'multisection'} = $multisection;
2943   my $late_sections = [];
2944   my $extra_sections = [];
2945   my $extra_lines = ();
2946   if ( $multisection ) {
2947     ($extra_sections, $extra_lines) =
2948       $self->_items_extra_usage_sections($escape_function_nonbsp, $format)
2949       if $conf->exists('usage_class_as_a_section', $cust_main->agentnum);
2950
2951     push @$extra_sections, $adjust_section if $adjust_section->{sort_weight};
2952
2953     push @detail_items, @$extra_lines if $extra_lines;
2954     push @sections,
2955       $self->_items_sections( $late_sections,      # this could stand a refactor
2956                               $summarypage,
2957                               $escape_function_nonbsp,
2958                               $extra_sections,
2959                               $format,             #bah
2960                             );
2961     if ($conf->exists('svc_phone_sections')) {
2962       my ($phone_sections, $phone_lines) =
2963         $self->_items_svc_phone_sections($escape_function_nonbsp, $format);
2964       push @{$late_sections}, @$phone_sections;
2965       push @detail_items, @$phone_lines;
2966     }
2967     if ($conf->exists('voip-cust_accountcode_cdr') && $cust_main->accountcode_cdr) {
2968       my ($accountcode_section, $accountcode_lines) =
2969         $self->_items_accountcode_cdr($escape_function_nonbsp,$format);
2970       if ( scalar(@$accountcode_lines) ) {
2971           push @{$late_sections}, $accountcode_section;
2972           push @detail_items, @$accountcode_lines;
2973       }
2974     }
2975   } else {# not multisection
2976     # make a default section
2977     push @sections, { 'description' => '', 'subtotal' => '',
2978       'no_subtotal' => 1 };
2979     # and calculate the finance charge total, since it won't get done otherwise.
2980     # XXX possibly other totals?
2981     # XXX possibly finance_pkgclass should not be used in this manner?
2982     if ( $conf->exists('finance_pkgclass') ) {
2983       my @finance_charges;
2984       foreach my $cust_bill_pkg ( $self->cust_bill_pkg ) {
2985         if ( grep { $_->section eq $invoice_data{finance_section} }
2986              $cust_bill_pkg->cust_bill_pkg_display ) {
2987           # I think these are always setup fees, but just to be sure...
2988           push @finance_charges, $cust_bill_pkg->recur + $cust_bill_pkg->setup;
2989         }
2990       }
2991       $invoice_data{finance_amount} =
2992         sprintf('%.2f', sum( @finance_charges ) || 0);
2993     }
2994   }
2995
2996   unless (    $conf->exists('disable_previous_balance')
2997            || $conf->exists('previous_balance-summary_only')
2998          )
2999   {
3000
3001     warn "$me adding previous balances\n"
3002       if $DEBUG > 1;
3003
3004     foreach my $line_item ( $self->_items_previous ) {
3005
3006       my $detail = {
3007         ext_description => [],
3008       };
3009       $detail->{'ref'} = $line_item->{'pkgnum'};
3010       $detail->{'quantity'} = 1;
3011       $detail->{'section'} = $previous_section;
3012       $detail->{'description'} = &$escape_function($line_item->{'description'});
3013       if ( exists $line_item->{'ext_description'} ) {
3014         @{$detail->{'ext_description'}} = map {
3015           &$escape_function($_);
3016         } @{$line_item->{'ext_description'}};
3017       }
3018       $detail->{'amount'} = ( $old_latex ? '' : $money_char).
3019                             $line_item->{'amount'};
3020       $detail->{'product_code'} = $line_item->{'pkgpart'} || 'N/A';
3021
3022       push @detail_items, $detail;
3023       push @buf, [ $detail->{'description'},
3024                    $money_char. sprintf("%10.2f", $line_item->{'amount'}),
3025                  ];
3026     }
3027
3028   }
3029
3030   if ( @pr_cust_bill && !$conf->exists('disable_previous_balance') ) {
3031     push @buf, ['','-----------'];
3032     push @buf, [ $self->mt('Total Previous Balance'),
3033                  $money_char. sprintf("%10.2f", $pr_total) ];
3034     push @buf, ['',''];
3035   }
3036
3037   if ( $conf->exists('svc_phone-did-summary') ) {
3038       warn "$me adding DID summary\n"
3039         if $DEBUG > 1;
3040
3041       my ($didsummary,$minutes) = $self->_did_summary;
3042       my $didsummary_desc = 'DID Activity Summary (since last invoice)';
3043       push @detail_items,
3044        { 'description' => $didsummary_desc,
3045            'ext_description' => [ $didsummary, $minutes ],
3046        };
3047   }
3048
3049   foreach my $section (@sections, @$late_sections) {
3050
3051     warn "$me adding section \n". Dumper($section)
3052       if $DEBUG > 1;
3053
3054     # begin some normalization
3055     $section->{'subtotal'} = $section->{'amount'}
3056       if $multisection
3057          && !exists($section->{subtotal})
3058          && exists($section->{amount});
3059
3060     $invoice_data{finance_amount} = sprintf('%.2f', $section->{'subtotal'} )
3061       if ( $invoice_data{finance_section} &&
3062            $section->{'description'} eq $invoice_data{finance_section} );
3063
3064     $section->{'subtotal'} = $other_money_char.
3065                              sprintf('%.2f', $section->{'subtotal'})
3066       if $multisection;
3067
3068     # continue some normalization
3069     $section->{'amount'}   = $section->{'subtotal'}
3070       if $multisection;
3071
3072
3073     if ( $section->{'description'} ) {
3074       push @buf, ( [ &$escape_function($section->{'description'}), '' ],
3075                    [ '', '' ],
3076                  );
3077     }
3078
3079     warn "$me   setting options\n"
3080       if $DEBUG > 1;
3081
3082     my $multilocation = scalar($cust_main->cust_location); #too expensive?
3083     my %options = ();
3084     $options{'section'} = $section if $multisection;
3085     $options{'format'} = $format;
3086     $options{'escape_function'} = $escape_function;
3087     $options{'no_usage'} = 1 unless $unsquelched;
3088     $options{'unsquelched'} = $unsquelched;
3089     $options{'summary_page'} = $summarypage;
3090     $options{'skip_usage'} =
3091       scalar(@$extra_sections) && !grep{$section == $_} @$extra_sections;
3092     $options{'multilocation'} = $multilocation;
3093     $options{'multisection'} = $multisection;
3094
3095     warn "$me   searching for line items\n"
3096       if $DEBUG > 1;
3097
3098     foreach my $line_item ( $self->_items_pkg(%options) ) {
3099
3100       warn "$me     adding line item $line_item\n"
3101         if $DEBUG > 1;
3102
3103       my $detail = {
3104         ext_description => [],
3105       };
3106       $detail->{'ref'} = $line_item->{'pkgnum'};
3107       $detail->{'quantity'} = $line_item->{'quantity'};
3108       $detail->{'section'} = $section;
3109       $detail->{'description'} = &$escape_function($line_item->{'description'});
3110       if ( exists $line_item->{'ext_description'} ) {
3111         @{$detail->{'ext_description'}} = @{$line_item->{'ext_description'}};
3112       }
3113       $detail->{'amount'} = ( $old_latex ? '' : $money_char ).
3114                               $line_item->{'amount'};
3115       $detail->{'unit_amount'} = ( $old_latex ? '' : $money_char ).
3116                                  $line_item->{'unit_amount'};
3117       $detail->{'product_code'} = $line_item->{'pkgpart'} || 'N/A';
3118
3119       $detail->{'sdate'} = $line_item->{'sdate'};
3120       $detail->{'edate'} = $line_item->{'edate'};
3121       $detail->{'seconds'} = $line_item->{'seconds'};
3122
3123       push @detail_items, $detail;
3124       push @buf, ( [ $detail->{'description'},
3125                      $money_char. sprintf("%10.2f", $line_item->{'amount'}),
3126                    ],
3127                    map { [ " ". $_, '' ] } @{$detail->{'ext_description'}},
3128                  );
3129     }
3130
3131     if ( $section->{'description'} ) {
3132       push @buf, ( ['','-----------'],
3133                    [ $section->{'description'}. ' sub-total',
3134                       $section->{'subtotal'} # already formatted this
3135                    ],
3136                    [ '', '' ],
3137                    [ '', '' ],
3138                  );
3139     }
3140
3141   }
3142
3143   $invoice_data{current_less_finance} =
3144     sprintf('%.2f', $self->charged - $invoice_data{finance_amount} );
3145
3146   if ( $multisection && !$conf->exists('disable_previous_balance')
3147     || $conf->exists('previous_balance-summary_only') )
3148   {
3149     unshift @sections, $previous_section if $pr_total;
3150   }
3151
3152   warn "$me adding taxes\n"
3153     if $DEBUG > 1;
3154
3155   foreach my $tax ( $self->_items_tax ) {
3156
3157     $taxtotal += $tax->{'amount'};
3158
3159     my $description = &$escape_function( $tax->{'description'} );
3160     my $amount      = sprintf( '%.2f', $tax->{'amount'} );
3161
3162     if ( $multisection ) {
3163
3164       my $money = $old_latex ? '' : $money_char;
3165       push @detail_items, {
3166         ext_description => [],
3167         ref          => '',
3168         quantity     => '',
3169         description  => $description,
3170         amount       => $money. $amount,
3171         product_code => '',
3172         section      => $tax_section,
3173       };
3174
3175     } else {
3176
3177       push @total_items, {
3178         'total_item'   => $description,
3179         'total_amount' => $other_money_char. $amount,
3180       };
3181
3182     }
3183
3184     push @buf,[ $description,
3185                 $money_char. $amount,
3186               ];
3187
3188   }
3189
3190   if ( $taxtotal ) {
3191     my $total = {};
3192     $total->{'total_item'} = $self->mt('Sub-total');
3193     $total->{'total_amount'} =
3194       $other_money_char. sprintf('%.2f', $self->charged - $taxtotal );
3195
3196     if ( $multisection ) {
3197       $tax_section->{'subtotal'} = $other_money_char.
3198                                    sprintf('%.2f', $taxtotal);
3199       $tax_section->{'pretotal'} = 'New charges sub-total '.
3200                                    $total->{'total_amount'};
3201       push @sections, $tax_section if $taxtotal;
3202     }else{
3203       unshift @total_items, $total;
3204     }
3205   }
3206   $invoice_data{'taxtotal'} = sprintf('%.2f', $taxtotal);
3207
3208   push @buf,['','-----------'];
3209   push @buf,[$self->mt(
3210               $conf->exists('disable_previous_balance')
3211                ? 'Total Charges'
3212                : 'Total New Charges'
3213              ),
3214              $money_char. sprintf("%10.2f",$self->charged) ];
3215   push @buf,['',''];
3216
3217   {
3218     my $total = {};
3219     my $item = 'Total';
3220     $item = $conf->config('previous_balance-exclude_from_total')
3221          || 'Total New Charges'
3222       if $conf->exists('previous_balance-exclude_from_total');
3223     my $amount = $self->charged +
3224                    ( $conf->exists('disable_previous_balance') ||
3225                      $conf->exists('previous_balance-exclude_from_total')
3226                      ? 0
3227                      : $pr_total
3228                    );
3229     $total->{'total_item'} = &$embolden_function($self->mt($item));
3230     $total->{'total_amount'} =
3231       &$embolden_function( $other_money_char.  sprintf( '%.2f', $amount ) );
3232     if ( $multisection ) {
3233       if ( $adjust_section->{'sort_weight'} ) {
3234         $adjust_section->{'posttotal'} = $self->mt('Balance Forward').' '.
3235           $other_money_char.  sprintf("%.2f", ($self->billing_balance || 0) );
3236       } else {
3237         $adjust_section->{'pretotal'} = $self->mt('New charges total').' '.
3238           $other_money_char.  sprintf('%.2f', $self->charged );
3239       }
3240     }else{
3241       push @total_items, $total;
3242     }
3243     push @buf,['','-----------'];
3244     push @buf,[$item,
3245                $money_char.
3246                sprintf( '%10.2f', $amount )
3247               ];
3248     push @buf,['',''];
3249   }
3250
3251   unless ( $conf->exists('disable_previous_balance') ) {
3252     #foreach my $thing ( sort { $a->_date <=> $b->_date } $self->_items_credits, $self->_items_payments
3253
3254     # credits
3255     my $credittotal = 0;
3256     foreach my $credit ( $self->_items_credits('trim_len'=>60) ) {
3257
3258       my $total;
3259       $total->{'total_item'} = &$escape_function($credit->{'description'});
3260       $credittotal += $credit->{'amount'};
3261       $total->{'total_amount'} = '-'. $other_money_char. $credit->{'amount'};
3262       $adjusttotal += $credit->{'amount'};
3263       if ( $multisection ) {
3264         my $money = $old_latex ? '' : $money_char;
3265         push @detail_items, {
3266           ext_description => [],
3267           ref          => '',
3268           quantity     => '',
3269           description  => &$escape_function($credit->{'description'}),
3270           amount       => $money. $credit->{'amount'},
3271           product_code => '',
3272           section      => $adjust_section,
3273         };
3274       } else {
3275         push @total_items, $total;
3276       }
3277
3278     }
3279     $invoice_data{'credittotal'} = sprintf('%.2f', $credittotal);
3280
3281     #credits (again)
3282     foreach my $credit ( $self->_items_credits('trim_len'=>32) ) {
3283       push @buf, [ $credit->{'description'}, $money_char.$credit->{'amount'} ];
3284     }
3285
3286     # payments
3287     my $paymenttotal = 0;
3288     foreach my $payment ( $self->_items_payments ) {
3289       my $total = {};
3290       $total->{'total_item'} = &$escape_function($payment->{'description'});
3291       $paymenttotal += $payment->{'amount'};
3292       $total->{'total_amount'} = '-'. $other_money_char. $payment->{'amount'};
3293       $adjusttotal += $payment->{'amount'};
3294       if ( $multisection ) {
3295         my $money = $old_latex ? '' : $money_char;
3296         push @detail_items, {
3297           ext_description => [],
3298           ref          => '',
3299           quantity     => '',
3300           description  => &$escape_function($payment->{'description'}),
3301           amount       => $money. $payment->{'amount'},
3302           product_code => '',
3303           section      => $adjust_section,
3304         };
3305       }else{
3306         push @total_items, $total;
3307       }
3308       push @buf, [ $payment->{'description'},
3309                    $money_char. sprintf("%10.2f", $payment->{'amount'}),
3310                  ];
3311     }
3312     $invoice_data{'paymenttotal'} = sprintf('%.2f', $paymenttotal);
3313
3314     if ( $multisection ) {
3315       $adjust_section->{'subtotal'} = $other_money_char.
3316                                       sprintf('%.2f', $adjusttotal);
3317       push @sections, $adjust_section
3318         unless $adjust_section->{sort_weight};
3319     }
3320
3321     # create Balance Due message
3322     {
3323       my $total;
3324       $total->{'total_item'} = &$embolden_function($self->balance_due_msg);
3325       $total->{'total_amount'} =
3326         &$embolden_function(
3327           $other_money_char. sprintf('%.2f', $summarypage
3328                                                ? $self->charged +
3329                                                  $self->billing_balance
3330                                                : $self->owed + $pr_total
3331                                     )
3332         );
3333       if ( $multisection && !$adjust_section->{sort_weight} ) {
3334         $adjust_section->{'posttotal'} = $total->{'total_item'}. ' '.
3335                                          $total->{'total_amount'};
3336       }else{
3337         push @total_items, $total;
3338       }
3339       push @buf,['','-----------'];
3340       push @buf,[$self->balance_due_msg, $money_char.
3341         sprintf("%10.2f", $balance_due ) ];
3342     }
3343
3344     if ( $conf->exists('previous_balance-show_credit')
3345         and $cust_main->balance < 0 ) {
3346       my $credit_total = {
3347         'total_item'    => &$embolden_function($self->credit_balance_msg),
3348         'total_amount'  => &$embolden_function(
3349           $other_money_char. sprintf('%.2f', -$cust_main->balance)
3350         ),
3351       };
3352       if ( $multisection ) {
3353         $adjust_section->{'posttotal'} .= $newline_token .
3354           $credit_total->{'total_item'} . ' ' . $credit_total->{'total_amount'};
3355       }
3356       else {
3357         push @total_items, $credit_total;
3358       }
3359       push @buf,['','-----------'];
3360       push @buf,[$self->credit_balance_msg, $money_char.
3361         sprintf("%10.2f", -$cust_main->balance ) ];
3362     }
3363   }
3364
3365   if ( $multisection ) {
3366     if ($conf->exists('svc_phone_sections')) {
3367       my $total;
3368       $total->{'total_item'} = &$embolden_function($self->balance_due_msg);
3369       $total->{'total_amount'} =
3370         &$embolden_function(
3371           $other_money_char. sprintf('%.2f', $self->owed + $pr_total)
3372         );
3373       my $last_section = pop @sections;
3374       $last_section->{'posttotal'} = $total->{'total_item'}. ' '.
3375                                      $total->{'total_amount'};
3376       push @sections, $last_section;
3377     }
3378     push @sections, @$late_sections
3379       if $unsquelched;
3380   }
3381
3382   # make a discounts-available section, even without multisection
3383   if ( $conf->exists('discount-show_available')
3384        and my @discounts_avail = $self->_items_discounts_avail ) {
3385     my $discount_section = {
3386       'description' => $self->mt('Discounts Available'),
3387       'subtotal'    => '',
3388       'no_subtotal' => 1,
3389     };
3390
3391     push @sections, $discount_section;
3392     push @detail_items, map { +{
3393         'ref'         => '', #should this be something else?
3394         'section'     => $discount_section,
3395         'description' => &$escape_function( $_->{description} ),
3396         'amount'      => $money_char . &$escape_function( $_->{amount} ),
3397         'ext_description' => [ &$escape_function($_->{ext_description}) || () ],
3398     } } @discounts_avail;
3399   }
3400
3401   # All sections and items are built; now fill in templates.
3402   my @includelist = ();
3403   push @includelist, 'summary' if $summarypage;
3404   foreach my $include ( @includelist ) {
3405
3406     my $inc_file = $conf->key_orbase("invoice_${format}$include", $template);
3407     my @inc_src;
3408
3409     if ( length( $conf->config($inc_file, $agentnum) ) ) {
3410
3411       @inc_src = $conf->config($inc_file, $agentnum);
3412
3413     } else {
3414
3415       $inc_file = $conf->key_orbase("invoice_latex$include", $template);
3416
3417       my $convert_map = $convert_maps{$format}{$include};
3418
3419       @inc_src = map { s/\[\@--/$delimiters{$format}[0]/g;
3420                        s/--\@\]/$delimiters{$format}[1]/g;
3421                        $_;
3422                      }
3423                  &$convert_map( $conf->config($inc_file, $agentnum) );
3424
3425     }
3426
3427     my $inc_tt = new Text::Template (
3428       TYPE       => 'ARRAY',
3429       SOURCE     => [ map "$_\n", @inc_src ],
3430       DELIMITERS => $delimiters{$format},
3431     ) or die "Can't create new Text::Template object: $Text::Template::ERROR";
3432
3433     unless ( $inc_tt->compile() ) {
3434       my $error = "Can't compile $inc_file template: $Text::Template::ERROR\n";
3435       warn $error. "Template:\n". join('', map "$_\n", @inc_src);
3436       die $error;
3437     }
3438
3439     $invoice_data{$include} = $inc_tt->fill_in( HASH => \%invoice_data );
3440
3441     $invoice_data{$include} =~ s/\n+$//
3442       if ($format eq 'latex');
3443   }
3444
3445   $invoice_lines = 0;
3446   my $wasfunc = 0;
3447   foreach ( grep /invoice_lines\(\d*\)/, @invoice_template ) { #kludgy
3448     /invoice_lines\((\d*)\)/;
3449     $invoice_lines += $1 || scalar(@buf);
3450     $wasfunc=1;
3451   }
3452   die "no invoice_lines() functions in template?"
3453     if ( $format eq 'template' && !$wasfunc );
3454
3455   if ($format eq 'template') {
3456
3457     if ( $invoice_lines ) {
3458       $invoice_data{'total_pages'} = int( scalar(@buf) / $invoice_lines );
3459       $invoice_data{'total_pages'}++
3460         if scalar(@buf) % $invoice_lines;
3461     }
3462
3463     #setup subroutine for the template
3464     $invoice_data{invoice_lines} = sub {
3465       my $lines = shift || scalar(@buf);
3466       map {
3467         scalar(@buf)
3468           ? shift @buf
3469           : [ '', '' ];
3470       }
3471       ( 1 .. $lines );
3472     };
3473
3474     my $lines;
3475     my @collect;
3476     while (@buf) {
3477       push @collect, split("\n",
3478         $text_template->fill_in( HASH => \%invoice_data )
3479       );
3480       $invoice_data{'page'}++;
3481     }
3482     map "$_\n", @collect;
3483   }else{
3484     # this is where we actually create the invoice
3485     warn "filling in template for invoice ". $self->invnum. "\n"
3486       if $DEBUG;
3487     warn join("\n", map " $_ => ". $invoice_data{$_}, keys %invoice_data). "\n"
3488       if $DEBUG > 1;
3489
3490     $text_template->fill_in(HASH => \%invoice_data);
3491   }
3492 }
3493
3494 # helper routine for generating date ranges
3495 sub _prior_month30s {
3496   my $self = shift;
3497   my @ranges = (
3498    [ 1,       2592000 ], # 0-30 days ago
3499    [ 2592000, 5184000 ], # 30-60 days ago
3500    [ 5184000, 7776000 ], # 60-90 days ago
3501    [ 7776000, 0       ], # 90+   days ago
3502   );
3503
3504   map { [ $_->[0] ? $self->_date - $_->[0] - 1 : '',
3505           $_->[1] ? $self->_date - $_->[1] - 1 : '',
3506       ] }
3507   @ranges;
3508 }
3509
3510 =item print_ps HASHREF | [ TIME [ , TEMPLATE ] ]
3511
3512 Returns an postscript invoice, as a scalar.
3513
3514 Options can be passed as a hashref (recommended) or as a list of time, template
3515 and then any key/value pairs for any other options.
3516
3517 I<time> an optional value used to control the printing of overdue messages.  The
3518 default is now.  It isn't the date of the invoice; that's the `_date' field.
3519 It is specified as a UNIX timestamp; see L<perlfunc/"time">.  Also see
3520 L<Time::Local> and L<Date::Parse> for conversion functions.
3521
3522 I<notice_name>, if specified, overrides "Invoice" as the name of the sent document (templates from 10/2009 or newer required)
3523
3524 =cut
3525
3526 sub print_ps {
3527   my $self = shift;
3528
3529   my ($file, $logofile, $barcodefile) = $self->print_latex(@_);
3530   my $ps = generate_ps($file);
3531   unlink($logofile);
3532   unlink($barcodefile) if $barcodefile;
3533
3534   $ps;
3535 }
3536
3537 =item print_pdf HASHREF | [ TIME [ , TEMPLATE ] ]
3538
3539 Returns an PDF invoice, as a scalar.
3540
3541 Options can be passed as a hashref (recommended) or as a list of time, template
3542 and then any key/value pairs for any other options.
3543
3544 I<time> an optional value used to control the printing of overdue messages.  The
3545 default is now.  It isn't the date of the invoice; that's the `_date' field.
3546 It is specified as a UNIX timestamp; see L<perlfunc/"time">.  Also see
3547 L<Time::Local> and L<Date::Parse> for conversion functions.
3548
3549 I<template>, if specified, is the name of a suffix for alternate invoices.
3550
3551 I<notice_name>, if specified, overrides "Invoice" as the name of the sent document (templates from 10/2009 or newer required)
3552
3553 =cut
3554
3555 sub print_pdf {
3556   my $self = shift;
3557
3558   my ($file, $logofile, $barcodefile) = $self->print_latex(@_);
3559   my $pdf = generate_pdf($file);
3560   unlink($logofile);
3561   unlink($barcodefile) if $barcodefile;
3562
3563   $pdf;
3564 }
3565
3566 =item print_html HASHREF | [ TIME [ , TEMPLATE [ , CID ] ] ]
3567
3568 Returns an HTML invoice, as a scalar.
3569
3570 I<time> an optional value used to control the printing of overdue messages.  The
3571 default is now.  It isn't the date of the invoice; that's the `_date' field.
3572 It is specified as a UNIX timestamp; see L<perlfunc/"time">.  Also see
3573 L<Time::Local> and L<Date::Parse> for conversion functions.
3574
3575 I<template>, if specified, is the name of a suffix for alternate invoices.
3576
3577 I<notice_name>, if specified, overrides "Invoice" as the name of the sent document (templates from 10/2009 or newer required)
3578
3579 I<cid> is a MIME Content-ID used to create a "cid:" URL for the logo image, used
3580 when emailing the invoice as part of a multipart/related MIME email.
3581
3582 =cut
3583
3584 sub print_html {
3585   my $self = shift;
3586   my %params;
3587   if ( ref($_[0]) ) {
3588     %params = %{ shift() };
3589   }else{
3590     $params{'time'} = shift;
3591     $params{'template'} = shift;
3592     $params{'cid'} = shift;
3593   }
3594
3595   $params{'format'} = 'html';
3596
3597   $self->print_generic( %params );
3598 }
3599
3600 # quick subroutine for print_latex
3601 #
3602 # There are ten characters that LaTeX treats as special characters, which
3603 # means that they do not simply typeset themselves:
3604 #      # $ % & ~ _ ^ \ { }
3605 #
3606 # TeX ignores blanks following an escaped character; if you want a blank (as
3607 # in "10% of ..."), you have to "escape" the blank as well ("10\%\ of ...").
3608
3609 sub _latex_escape {
3610   my $value = shift;
3611   $value =~ s/([#\$%&~_\^{}])( )?/"\\$1". ( ( defined($2) && length($2) ) ? "\\$2" : '' )/ge;
3612   $value =~ s/([<>])/\$$1\$/g;
3613   $value;
3614 }
3615
3616 sub _html_escape {
3617   my $value = shift;
3618   encode_entities($value);
3619   $value;
3620 }
3621
3622 sub _html_escape_nbsp {
3623   my $value = _html_escape(shift);
3624   $value =~ s/ +/&nbsp;/g;
3625   $value;
3626 }
3627
3628 #utility methods for print_*
3629
3630 sub _translate_old_latex_format {
3631   warn "_translate_old_latex_format called\n"
3632     if $DEBUG;
3633
3634   my @template = ();
3635   while ( @_ ) {
3636     my $line = shift;
3637
3638     if ( $line =~ /^%%Detail\s*$/ ) {
3639
3640       push @template, q![@--!,
3641                       q!  foreach my $_tr_line (@detail_items) {!,
3642                       q!    if ( scalar ($_tr_item->{'ext_description'} ) ) {!,
3643                       q!      $_tr_line->{'description'} .= !,
3644                       q!        "\\tabularnewline\n~~".!,
3645                       q!        join( "\\tabularnewline\n~~",!,
3646                       q!          @{$_tr_line->{'ext_description'}}!,
3647                       q!        );!,
3648                       q!    }!;
3649
3650       while ( ( my $line_item_line = shift )
3651               !~ /^%%EndDetail\s*$/                            ) {
3652         $line_item_line =~ s/'/\\'/g;    # nice LTS
3653         $line_item_line =~ s/\\/\\\\/g;  # escape quotes and backslashes
3654         $line_item_line =~ s/\$(\w+)/'. \$_tr_line->{$1}. '/g;
3655         push @template, "    \$OUT .= '$line_item_line';";
3656       }
3657
3658       push @template, '}',
3659                       '--@]';
3660       #' doh, gvim
3661     } elsif ( $line =~ /^%%TotalDetails\s*$/ ) {
3662
3663       push @template, '[@--',
3664                       '  foreach my $_tr_line (@total_items) {';
3665
3666       while ( ( my $total_item_line = shift )
3667               !~ /^%%EndTotalDetails\s*$/                      ) {
3668         $total_item_line =~ s/'/\\'/g;    # nice LTS
3669         $total_item_line =~ s/\\/\\\\/g;  # escape quotes and backslashes
3670         $total_item_line =~ s/\$(\w+)/'. \$_tr_line->{$1}. '/g;
3671         push @template, "    \$OUT .= '$total_item_line';";
3672       }
3673
3674       push @template, '}',
3675                       '--@]';
3676
3677     } else {
3678       $line =~ s/\$(\w+)/[\@-- \$$1 --\@]/g;
3679       push @template, $line;
3680     }
3681
3682   }
3683
3684   if ($DEBUG) {
3685     warn "$_\n" foreach @template;
3686   }
3687
3688   (@template);
3689 }
3690
3691 sub terms {
3692   my $self = shift;
3693   my $conf = $self->conf;
3694
3695   #check for an invoice-specific override
3696   return $self->invoice_terms if $self->invoice_terms;
3697
3698   #check for a customer- specific override
3699   my $cust_main = $self->cust_main;
3700   return $cust_main->invoice_terms if $cust_main->invoice_terms;
3701
3702   #use configured default
3703   $conf->config('invoice_default_terms') || '';
3704 }
3705
3706 sub due_date {
3707   my $self = shift;
3708   my $duedate = '';
3709   if ( $self->terms =~ /^\s*Net\s*(\d+)\s*$/ ) {
3710     $duedate = $self->_date() + ( $1 * 86400 );
3711   }
3712   $duedate;
3713 }
3714
3715 sub due_date2str {
3716   my $self = shift;
3717   $self->due_date ? time2str(shift, $self->due_date) : '';
3718 }
3719
3720 sub balance_due_msg {
3721   my $self = shift;
3722   my $msg = $self->mt('Balance Due');
3723   return $msg unless $self->terms;
3724   if ( $self->due_date ) {
3725     $msg .= ' - ' . $self->mt('Please pay by'). ' '.
3726       $self->due_date2str($date_format);
3727   } elsif ( $self->terms ) {
3728     $msg .= ' - '. $self->terms;
3729   }
3730   $msg;
3731 }
3732
3733 sub balance_due_date {
3734   my $self = shift;
3735   my $conf = $self->conf;
3736   my $duedate = '';
3737   if (    $conf->exists('invoice_default_terms')
3738        && $conf->config('invoice_default_terms')=~ /^\s*Net\s*(\d+)\s*$/ ) {
3739     $duedate = time2str($rdate_format, $self->_date + ($1*86400) );
3740   }
3741   $duedate;
3742 }
3743
3744 sub credit_balance_msg {
3745   my $self = shift;
3746   $self->mt('Credit Balance Remaining')
3747 }
3748
3749 =item invnum_date_pretty
3750
3751 Returns a string with the invoice number and date, for example:
3752 "Invoice #54 (3/20/2008)"
3753
3754 =cut
3755
3756 sub invnum_date_pretty {
3757   my $self = shift;
3758   $self->mt('Invoice #'). $self->invnum. ' ('. $self->_date_pretty. ')';
3759 }
3760
3761 =item _date_pretty
3762
3763 Returns a string with the date, for example: "3/20/2008"
3764
3765 =cut
3766
3767 sub _date_pretty {
3768   my $self = shift;
3769   time2str($date_format, $self->_date);
3770 }
3771
3772 =item _items_sections LATE SUMMARYPAGE ESCAPE EXTRA_SECTIONS FORMAT
3773
3774 Generate section information for all items appearing on this invoice.
3775 This will only be called for multi-section invoices.
3776
3777 For each line item (L<FS::cust_bill_pkg> record), this will fetch all
3778 related display records (L<FS::cust_bill_pkg_display>) and organize
3779 them into two groups ("early" and "late" according to whether they come
3780 before or after the total), then into sections.  A subtotal is calculated
3781 for each section.
3782
3783 Section descriptions are returned in sort weight order.  Each consists
3784 of a hash containing:
3785
3786 description: the package category name, escaped
3787 subtotal: the total charges in that section
3788 tax_section: a flag indicating that the section contains only tax charges
3789 summarized: same as tax_section, for some reason
3790 sort_weight: the package category's sort weight
3791
3792 If 'condense' is set on the display record, it also contains everything
3793 returned from C<_condense_section()>, i.e. C<_condensed_foo_generator>
3794 coderefs to generate parts of the invoice.  This is not advised.
3795
3796 Arguments:
3797
3798 LATE: an arrayref to push the "late" section hashes onto.  The "early"
3799 group is simply returned from the method.
3800
3801 SUMMARYPAGE: a flag indicating whether this is a summary-format invoice.
3802 Turning this on has the following effects:
3803 - Ignores display items with the 'summary' flag.
3804 - Combines all items into the "early" group.
3805 - Creates sections for all non-disabled package categories, even if they
3806 have no charges on this invoice, as well as a section with no name.
3807
3808 ESCAPE: an escape function to use for section titles.
3809
3810 EXTRA_SECTIONS: an arrayref of additional sections to return after the
3811 sorted list.  If there are any of these, section subtotals exclude
3812 usage charges.
3813
3814 FORMAT: 'latex', 'html', or 'template' (i.e. text).  Not used, but
3815 passed through to C<_condense_section()>.
3816
3817 =cut
3818
3819 use vars qw(%pkg_category_cache);
3820 sub _items_sections {
3821   my $self = shift;
3822   my $late = shift;
3823   my $summarypage = shift;
3824   my $escape = shift;
3825   my $extra_sections = shift;
3826   my $format = shift;
3827
3828   my %subtotal = ();
3829   my %late_subtotal = ();
3830   my %not_tax = ();
3831
3832   foreach my $cust_bill_pkg ( $self->cust_bill_pkg )
3833   {
3834
3835       my $usage = $cust_bill_pkg->usage;
3836
3837       foreach my $display ($cust_bill_pkg->cust_bill_pkg_display) {
3838         next if ( $display->summary && $summarypage );
3839
3840         my $section = $display->section;
3841         my $type    = $display->type;
3842
3843         $not_tax{$section} = 1
3844           unless $cust_bill_pkg->pkgnum == 0;
3845
3846         if ( $display->post_total && !$summarypage ) {
3847           if (! $type || $type eq 'S') {
3848             $late_subtotal{$section} += $cust_bill_pkg->setup
3849               if $cust_bill_pkg->setup != 0;
3850           }
3851
3852           if (! $type) {
3853             $late_subtotal{$section} += $cust_bill_pkg->recur
3854               if $cust_bill_pkg->recur != 0;
3855           }
3856
3857           if ($type && $type eq 'R') {
3858             $late_subtotal{$section} += $cust_bill_pkg->recur - $usage
3859               if $cust_bill_pkg->recur != 0;
3860           }
3861
3862           if ($type && $type eq 'U') {
3863             $late_subtotal{$section} += $usage
3864               unless scalar(@$extra_sections);
3865           }
3866
3867         } else {
3868
3869           next if $cust_bill_pkg->pkgnum == 0 && ! $section;
3870
3871           if (! $type || $type eq 'S') {
3872             $subtotal{$section} += $cust_bill_pkg->setup
3873               if $cust_bill_pkg->setup != 0;
3874           }
3875
3876           if (! $type) {
3877             $subtotal{$section} += $cust_bill_pkg->recur
3878               if $cust_bill_pkg->recur != 0;
3879           }
3880
3881           if ($type && $type eq 'R') {
3882             $subtotal{$section} += $cust_bill_pkg->recur - $usage
3883               if $cust_bill_pkg->recur != 0;
3884           }
3885
3886           if ($type && $type eq 'U') {
3887             $subtotal{$section} += $usage
3888               unless scalar(@$extra_sections);
3889           }
3890
3891         }
3892
3893       }
3894
3895   }
3896
3897   %pkg_category_cache = ();
3898
3899   push @$late, map { { 'description' => &{$escape}($_),
3900                        'subtotal'    => $late_subtotal{$_},
3901                        'post_total'  => 1,
3902                        'sort_weight' => ( _pkg_category($_)
3903                                             ? _pkg_category($_)->weight
3904                                             : 0
3905                                        ),
3906                        ((_pkg_category($_) && _pkg_category($_)->condense)
3907                                            ? $self->_condense_section($format)
3908                                            : ()
3909                        ),
3910                    } }
3911                  sort _sectionsort keys %late_subtotal;
3912
3913   my @sections;
3914   if ( $summarypage ) {
3915     @sections = grep { exists($subtotal{$_}) || ! _pkg_category($_)->disabled }
3916                 map { $_->categoryname } qsearch('pkg_category', {});
3917     push @sections, '' if exists($subtotal{''});
3918   } else {
3919     @sections = keys %subtotal;
3920   }
3921
3922   my @early = map { { 'description' => &{$escape}($_),
3923                       'subtotal'    => $subtotal{$_},
3924                       'summarized'  => $not_tax{$_} ? '' : 'Y',
3925                       'tax_section' => $not_tax{$_} ? '' : 'Y',
3926                       'sort_weight' => ( _pkg_category($_)
3927                                            ? _pkg_category($_)->weight
3928                                            : 0
3929                                        ),
3930                        ((_pkg_category($_) && _pkg_category($_)->condense)
3931                                            ? $self->_condense_section($format)
3932                                            : ()
3933                        ),
3934                     }
3935                   } @sections;
3936   push @early, @$extra_sections if $extra_sections;
3937
3938   sort { $a->{sort_weight} <=> $b->{sort_weight} } @early;
3939
3940 }
3941
3942 #helper subs for above
3943
3944 sub _sectionsort {
3945   _pkg_category($a)->weight <=> _pkg_category($b)->weight;
3946 }
3947
3948 sub _pkg_category {
3949   my $categoryname = shift;
3950   $pkg_category_cache{$categoryname} ||=
3951     qsearchs( 'pkg_category', { 'categoryname' => $categoryname } );
3952 }
3953
3954 my %condensed_format = (
3955   'label' => [ qw( Description Qty Amount ) ],
3956   'fields' => [
3957                 sub { shift->{description} },
3958                 sub { shift->{quantity} },
3959                 sub { my($href, %opt) = @_;
3960                       ($opt{dollar} || ''). $href->{amount};
3961                     },
3962               ],
3963   'align'  => [ qw( l r r ) ],
3964   'span'   => [ qw( 5 1 1 ) ],            # unitprices?
3965   'width'  => [ qw( 10.7cm 1.4cm 1.6cm ) ],   # don't like this
3966 );
3967
3968 sub _condense_section {
3969   my ( $self, $format ) = ( shift, shift );
3970   ( 'condensed' => 1,
3971     map { my $method = "_condensed_$_"; $_ => $self->$method($format) }
3972       qw( description_generator
3973           header_generator
3974           total_generator
3975           total_line_generator
3976         )
3977   );
3978 }
3979
3980 sub _condensed_generator_defaults {
3981   my ( $self, $format ) = ( shift, shift );
3982   return ( \%condensed_format, ' ', ' ', ' ', sub { shift } );
3983 }
3984
3985 my %html_align = (
3986   'c' => 'center',
3987   'l' => 'left',
3988   'r' => 'right',
3989 );
3990
3991 sub _condensed_header_generator {
3992   my ( $self, $format ) = ( shift, shift );
3993
3994   my ( $f, $prefix, $suffix, $separator, $column ) =
3995     _condensed_generator_defaults($format);
3996
3997   if ($format eq 'latex') {
3998     $prefix = "\\hline\n\\rule{0pt}{2.5ex}\n\\makebox[1.4cm]{}&\n";
3999     $suffix = "\\\\\n\\hline";
4000     $separator = "&\n";
4001     $column =
4002       sub { my ($d,$a,$s,$w) = @_;
4003             return "\\multicolumn{$s}{$a}{\\makebox[$w][$a]{\\textbf{$d}}}";
4004           };
4005   } elsif ( $format eq 'html' ) {
4006     $prefix = '<th></th>';
4007     $suffix = '';
4008     $separator = '';
4009     $column =
4010       sub { my ($d,$a,$s,$w) = @_;
4011             return qq!<th align="$html_align{$a}">$d</th>!;
4012       };
4013   }
4014
4015   sub {
4016     my @args = @_;
4017     my @result = ();
4018
4019     foreach  (my $i = 0; $f->{label}->[$i]; $i++) {
4020       push @result,
4021         &{$column}( map { $f->{$_}->[$i] } qw(label align span width) );
4022     }
4023
4024     $prefix. join($separator, @result). $suffix;
4025   };
4026
4027 }
4028
4029 sub _condensed_description_generator {
4030   my ( $self, $format ) = ( shift, shift );
4031
4032   my ( $f, $prefix, $suffix, $separator, $column ) =
4033     _condensed_generator_defaults($format);
4034
4035   my $money_char = '$';
4036   if ($format eq 'latex') {
4037     $prefix = "\\hline\n\\multicolumn{1}{c}{\\rule{0pt}{2.5ex}~} &\n";
4038     $suffix = '\\\\';
4039     $separator = " & \n";
4040     $column =
4041       sub { my ($d,$a,$s,$w) = @_;
4042             return "\\multicolumn{$s}{$a}{\\makebox[$w][$a]{\\textbf{$d}}}";
4043           };
4044     $money_char = '\\dollar';
4045   }elsif ( $format eq 'html' ) {
4046     $prefix = '"><td align="center"></td>';
4047     $suffix = '';
4048     $separator = '';
4049     $column =
4050       sub { my ($d,$a,$s,$w) = @_;
4051             return qq!<td align="$html_align{$a}">$d</td>!;
4052       };
4053     #$money_char = $conf->config('money_char') || '$';
4054     $money_char = '';  # this is madness
4055   }
4056
4057   sub {
4058     #my @args = @_;
4059     my $href = shift;
4060     my @result = ();
4061
4062     foreach  (my $i = 0; $f->{label}->[$i]; $i++) {
4063       my $dollar = '';
4064       $dollar = $money_char if $i == scalar(@{$f->{label}})-1;
4065       push @result,
4066         &{$column}( &{$f->{fields}->[$i]}($href, 'dollar' => $dollar),
4067                     map { $f->{$_}->[$i] } qw(align span width)
4068                   );
4069     }
4070
4071     $prefix. join( $separator, @result ). $suffix;
4072   };
4073
4074 }
4075
4076 sub _condensed_total_generator {
4077   my ( $self, $format ) = ( shift, shift );
4078
4079   my ( $f, $prefix, $suffix, $separator, $column ) =
4080     _condensed_generator_defaults($format);
4081   my $style = '';
4082
4083   if ($format eq 'latex') {
4084     $prefix = "& ";
4085     $suffix = "\\\\\n";
4086     $separator = " & \n";
4087     $column =
4088       sub { my ($d,$a,$s,$w) = @_;
4089             return "\\multicolumn{$s}{$a}{\\makebox[$w][$a]{$d}}";
4090           };
4091   }elsif ( $format eq 'html' ) {
4092     $prefix = '';
4093     $suffix = '';
4094     $separator = '';
4095     $style = 'border-top: 3px solid #000000;border-bottom: 3px solid #000000;';
4096     $column =
4097       sub { my ($d,$a,$s,$w) = @_;
4098             return qq!<td align="$html_align{$a}" style="$style">$d</td>!;
4099       };
4100   }
4101
4102
4103   sub {
4104     my @args = @_;
4105     my @result = ();
4106
4107     #  my $r = &{$f->{fields}->[$i]}(@args);
4108     #  $r .= ' Total' unless $i;
4109
4110     foreach  (my $i = 0; $f->{label}->[$i]; $i++) {
4111       push @result,
4112         &{$column}( &{$f->{fields}->[$i]}(@args). ($i ? '' : ' Total'),
4113                     map { $f->{$_}->[$i] } qw(align span width)
4114                   );
4115     }
4116
4117     $prefix. join( $separator, @result ). $suffix;
4118   };
4119
4120 }
4121
4122 =item total_line_generator FORMAT
4123
4124 Returns a coderef used for generation of invoice total line items for this
4125 usage_class.  FORMAT is either html or latex
4126
4127 =cut
4128
4129 # should not be used: will have issues with hash element names (description vs
4130 # total_item and amount vs total_amount -- another array of functions?
4131
4132 sub _condensed_total_line_generator {
4133   my ( $self, $format ) = ( shift, shift );
4134
4135   my ( $f, $prefix, $suffix, $separator, $column ) =
4136     _condensed_generator_defaults($format);
4137   my $style = '';
4138
4139   if ($format eq 'latex') {
4140     $prefix = "& ";
4141     $suffix = "\\\\\n";
4142     $separator = " & \n";
4143     $column =
4144       sub { my ($d,$a,$s,$w) = @_;
4145             return "\\multicolumn{$s}{$a}{\\makebox[$w][$a]{$d}}";
4146           };
4147   }elsif ( $format eq 'html' ) {
4148     $prefix = '';
4149     $suffix = '';
4150     $separator = '';
4151     $style = 'border-top: 3px solid #000000;border-bottom: 3px solid #000000;';
4152     $column =
4153       sub { my ($d,$a,$s,$w) = @_;
4154             return qq!<td align="$html_align{$a}" style="$style">$d</td>!;
4155       };
4156   }
4157
4158
4159   sub {
4160     my @args = @_;
4161     my @result = ();
4162
4163     foreach  (my $i = 0; $f->{label}->[$i]; $i++) {
4164       push @result,
4165         &{$column}( &{$f->{fields}->[$i]}(@args),
4166                     map { $f->{$_}->[$i] } qw(align span width)
4167                   );
4168     }
4169
4170     $prefix. join( $separator, @result ). $suffix;
4171   };
4172
4173 }
4174
4175 #sub _items_extra_usage_sections {
4176 #  my $self = shift;
4177 #  my $escape = shift;
4178 #
4179 #  my %sections = ();
4180 #
4181 #  my %usage_class =  map{ $_->classname, $_ } qsearch('usage_class', {});
4182 #  foreach my $cust_bill_pkg ( $self->cust_bill_pkg )
4183 #  {
4184 #    next unless $cust_bill_pkg->pkgnum > 0;
4185 #
4186 #    foreach my $section ( keys %usage_class ) {
4187 #
4188 #      my $usage = $cust_bill_pkg->usage($section);
4189 #
4190 #      next unless $usage && $usage > 0;
4191 #
4192 #      $sections{$section} ||= 0;
4193 #      $sections{$section} += $usage;
4194 #
4195 #    }
4196 #
4197 #  }
4198 #
4199 #  map { { 'description' => &{$escape}($_),
4200 #          'subtotal'    => $sections{$_},
4201 #          'summarized'  => '',
4202 #          'tax_section' => '',
4203 #        }
4204 #      }
4205 #    sort {$usage_class{$a}->weight <=> $usage_class{$b}->weight} keys %sections;
4206 #
4207 #}
4208
4209 sub _items_extra_usage_sections {
4210   my $self = shift;
4211   my $conf = $self->conf;
4212   my $escape = shift;
4213   my $format = shift;
4214
4215   my %sections = ();
4216   my %classnums = ();
4217   my %lines = ();
4218
4219   my $maxlength = $conf->config('cust_bill-latex_lineitem_maxlength') || 50;
4220
4221   my %usage_class =  map { $_->classnum => $_ } qsearch( 'usage_class', {} );
4222   foreach my $cust_bill_pkg ( $self->cust_bill_pkg ) {
4223     next unless $cust_bill_pkg->pkgnum > 0;
4224
4225     foreach my $classnum ( keys %usage_class ) {
4226       my $section = $usage_class{$classnum}->classname;
4227       $classnums{$section} = $classnum;
4228
4229       foreach my $detail ( $cust_bill_pkg->cust_bill_pkg_detail($classnum) ) {
4230         my $amount = $detail->amount;
4231         next unless $amount && $amount > 0;
4232
4233         $sections{$section} ||= { 'subtotal'=>0, 'calls'=>0, 'duration'=>0 };
4234         $sections{$section}{amount} += $amount;  #subtotal
4235         $sections{$section}{calls}++;
4236         $sections{$section}{duration} += $detail->duration;
4237
4238         my $desc = $detail->regionname;
4239         my $description = $desc;
4240         $description = substr($desc, 0, $maxlength). '...'
4241           if $format eq 'latex' && length($desc) > $maxlength;
4242
4243         $lines{$section}{$desc} ||= {
4244           description     => &{$escape}($description),
4245           #pkgpart         => $part_pkg->pkgpart,
4246           pkgnum          => $cust_bill_pkg->pkgnum,
4247           ref             => '',
4248           amount          => 0,
4249           calls           => 0,
4250           duration        => 0,
4251           #unit_amount     => $cust_bill_pkg->unitrecur,
4252           quantity        => $cust_bill_pkg->quantity,
4253           product_code    => 'N/A',
4254           ext_description => [],
4255         };
4256
4257         $lines{$section}{$desc}{amount} += $amount;
4258         $lines{$section}{$desc}{calls}++;
4259         $lines{$section}{$desc}{duration} += $detail->duration;
4260
4261       }
4262     }
4263   }
4264
4265   my %sectionmap = ();
4266   foreach (keys %sections) {
4267     my $usage_class = $usage_class{$classnums{$_}};
4268     $sectionmap{$_} = { 'description' => &{$escape}($_),
4269                         'amount'    => $sections{$_}{amount},    #subtotal
4270                         'calls'       => $sections{$_}{calls},
4271                         'duration'    => $sections{$_}{duration},
4272                         'summarized'  => '',
4273                         'tax_section' => '',
4274                         'sort_weight' => $usage_class->weight,
4275                         ( $usage_class->format
4276                           ? ( map { $_ => $usage_class->$_($format) }
4277                               qw( description_generator header_generator total_generator total_line_generator )
4278                             )
4279                           : ()
4280                         ),
4281                       };
4282   }
4283
4284   my @sections = sort { $a->{sort_weight} <=> $b->{sort_weight} }
4285                  values %sectionmap;
4286
4287   my @lines = ();
4288   foreach my $section ( keys %lines ) {
4289     foreach my $line ( keys %{$lines{$section}} ) {
4290       my $l = $lines{$section}{$line};
4291       $l->{section}     = $sectionmap{$section};
4292       $l->{amount}      = sprintf( "%.2f", $l->{amount} );
4293       #$l->{unit_amount} = sprintf( "%.2f", $l->{unit_amount} );
4294       push @lines, $l;
4295     }
4296   }
4297
4298   return(\@sections, \@lines);
4299
4300 }
4301
4302 sub _did_summary {
4303     my $self = shift;
4304     my $end = $self->_date;
4305
4306     # start at date of previous invoice + 1 second or 0 if no previous invoice
4307     my $start = $self->scalar_sql("SELECT max(_date) FROM cust_bill WHERE custnum = ? and invnum != ?",$self->custnum,$self->invnum);
4308     $start = 0 if !$start;
4309     $start++;
4310
4311     my $cust_main = $self->cust_main;
4312     my @pkgs = $cust_main->all_pkgs;
4313     my($num_activated,$num_deactivated,$num_portedin,$num_portedout,$minutes)
4314         = (0,0,0,0,0);
4315     my @seen = ();
4316     foreach my $pkg ( @pkgs ) {
4317         my @h_cust_svc = $pkg->h_cust_svc($end);
4318         foreach my $h_cust_svc ( @h_cust_svc ) {
4319             next if grep {$_ eq $h_cust_svc->svcnum} @seen;
4320             next unless $h_cust_svc->part_svc->svcdb eq 'svc_phone';
4321
4322             my $inserted = $h_cust_svc->date_inserted;
4323             my $deleted = $h_cust_svc->date_deleted;
4324             my $phone_inserted = $h_cust_svc->h_svc_x($inserted+5);
4325             my $phone_deleted;
4326             $phone_deleted =  $h_cust_svc->h_svc_x($deleted) if $deleted;
4327
4328 # DID either activated or ported in; cannot be both for same DID simultaneously
4329             if ($inserted >= $start && $inserted <= $end && $phone_inserted
4330                 && (!$phone_inserted->lnp_status
4331                     || $phone_inserted->lnp_status eq ''
4332                     || $phone_inserted->lnp_status eq 'native')) {
4333                 $num_activated++;
4334             }
4335             else { # this one not so clean, should probably move to (h_)svc_phone
4336                  my $phone_portedin = qsearchs( 'h_svc_phone',
4337                       { 'svcnum' => $h_cust_svc->svcnum,
4338                         'lnp_status' => 'portedin' },
4339                       FS::h_svc_phone->sql_h_searchs($end),
4340                     );
4341                  $num_portedin++ if $phone_portedin;
4342             }
4343
4344 # DID either deactivated or ported out; cannot be both for same DID simultaneously
4345             if($deleted >= $start && $deleted <= $end && $phone_deleted
4346                 && (!$phone_deleted->lnp_status
4347                     || $phone_deleted->lnp_status ne 'portingout')) {
4348                 $num_deactivated++;
4349             }
4350             elsif($deleted >= $start && $deleted <= $end && $phone_deleted
4351                 && $phone_deleted->lnp_status
4352                 && $phone_deleted->lnp_status eq 'portingout') {
4353                 $num_portedout++;
4354             }
4355
4356             # increment usage minutes
4357         if ( $phone_inserted ) {
4358             my @cdrs = $phone_inserted->get_cdrs('begin'=>$start,'end'=>$end,'billsec_sum'=>1);
4359             $minutes = $cdrs[0]->billsec_sum if scalar(@cdrs) == 1;
4360         }
4361         else {
4362             warn "WARNING: no matching h_svc_phone insert record for insert time $inserted, svcnum " . $h_cust_svc->svcnum;
4363         }
4364
4365             # don't look at this service again
4366             push @seen, $h_cust_svc->svcnum;
4367         }
4368     }
4369
4370     $minutes = sprintf("%d", $minutes);
4371     ("Activated: $num_activated  Ported-In: $num_portedin  Deactivated: "
4372         . "$num_deactivated  Ported-Out: $num_portedout ",
4373             "Total Minutes: $minutes");
4374 }
4375
4376 sub _items_accountcode_cdr {
4377     my $self = shift;
4378     my $escape = shift;
4379     my $format = shift;
4380
4381     my $section = { 'amount'        => 0,
4382                     'calls'         => 0,
4383                     'duration'      => 0,
4384                     'sort_weight'   => '',
4385                     'phonenum'      => '',
4386                     'description'   => 'Usage by Account Code',
4387                     'post_total'    => '',
4388                     'summarized'    => '',
4389                     'header'        => '',
4390                   };
4391     my @lines;
4392     my %accountcodes = ();
4393
4394     foreach my $cust_bill_pkg ( $self->cust_bill_pkg ) {
4395         next unless $cust_bill_pkg->pkgnum > 0;
4396
4397         my @header = $cust_bill_pkg->details_header;
4398         next unless scalar(@header);
4399         $section->{'header'} = join(',',@header);
4400
4401         foreach my $detail ( $cust_bill_pkg->cust_bill_pkg_detail ) {
4402
4403             $section->{'header'} = $detail->formatted('format' => $format)
4404                 if($detail->detail eq $section->{'header'});
4405
4406             my $accountcode = $detail->accountcode;
4407             next unless $accountcode;
4408
4409             my $amount = $detail->amount;
4410             next unless $amount && $amount > 0;
4411
4412             $accountcodes{$accountcode} ||= {
4413                     description => $accountcode,
4414                     pkgnum      => '',
4415                     ref         => '',
4416                     amount      => 0,
4417                     calls       => 0,
4418                     duration    => 0,
4419                     quantity    => '',
4420                     product_code => 'N/A',
4421                     section     => $section,
4422                     ext_description => [ $section->{'header'} ],
4423                     detail_temp => [],
4424             };
4425
4426             $section->{'amount'} += $amount;
4427             $accountcodes{$accountcode}{'amount'} += $amount;
4428             $accountcodes{$accountcode}{calls}++;
4429             $accountcodes{$accountcode}{duration} += $detail->duration;
4430             push @{$accountcodes{$accountcode}{detail_temp}}, $detail;
4431         }
4432     }
4433
4434     foreach my $l ( values %accountcodes ) {
4435         $l->{amount} = sprintf( "%.2f", $l->{amount} );
4436         my @sorted_detail = sort { $a->startdate <=> $b->startdate } @{$l->{detail_temp}};
4437         foreach my $sorted_detail ( @sorted_detail ) {
4438             push @{$l->{ext_description}}, $sorted_detail->formatted('format'=>$format);
4439         }
4440         delete $l->{detail_temp};
4441         push @lines, $l;
4442     }
4443
4444     my @sorted_lines = sort { $a->{'description'} <=> $b->{'description'} } @lines;
4445
4446     return ($section,\@sorted_lines);
4447 }
4448
4449 sub _items_svc_phone_sections {
4450   my $self = shift;
4451   my $conf = $self->conf;
4452   my $escape = shift;
4453   my $format = shift;
4454
4455   my %sections = ();
4456   my %classnums = ();
4457   my %lines = ();
4458
4459   my $maxlength = $conf->config('cust_bill-latex_lineitem_maxlength') || 50;
4460
4461   my %usage_class =  map { $_->classnum => $_ } qsearch( 'usage_class', {} );
4462   $usage_class{''} ||= new FS::usage_class { 'classname' => '', 'weight' => 0 };
4463
4464   foreach my $cust_bill_pkg ( $self->cust_bill_pkg ) {
4465     next unless $cust_bill_pkg->pkgnum > 0;
4466
4467     my @header = $cust_bill_pkg->details_header;
4468     next unless scalar(@header);
4469
4470     foreach my $detail ( $cust_bill_pkg->cust_bill_pkg_detail ) {
4471
4472       my $phonenum = $detail->phonenum;
4473       next unless $phonenum;
4474
4475       my $amount = $detail->amount;
4476       next unless $amount && $amount > 0;
4477
4478       $sections{$phonenum} ||= { 'amount'      => 0,
4479                                  'calls'       => 0,
4480                                  'duration'    => 0,
4481                                  'sort_weight' => -1,
4482                                  'phonenum'    => $phonenum,
4483                                 };
4484       $sections{$phonenum}{amount} += $amount;  #subtotal
4485       $sections{$phonenum}{calls}++;
4486       $sections{$phonenum}{duration} += $detail->duration;
4487
4488       my $desc = $detail->regionname;
4489       my $description = $desc;
4490       $description = substr($desc, 0, $maxlength). '...'
4491         if $format eq 'latex' && length($desc) > $maxlength;
4492
4493       $lines{$phonenum}{$desc} ||= {
4494         description     => &{$escape}($description),
4495         #pkgpart         => $part_pkg->pkgpart,
4496         pkgnum          => '',
4497         ref             => '',
4498         amount          => 0,
4499         calls           => 0,
4500         duration        => 0,
4501         #unit_amount     => '',
4502         quantity        => '',
4503         product_code    => 'N/A',
4504         ext_description => [],
4505       };
4506
4507       $lines{$phonenum}{$desc}{amount} += $amount;
4508       $lines{$phonenum}{$desc}{calls}++;
4509       $lines{$phonenum}{$desc}{duration} += $detail->duration;
4510
4511       my $line = $usage_class{$detail->classnum}->classname;
4512       $sections{"$phonenum $line"} ||=
4513         { 'amount' => 0,
4514           'calls' => 0,
4515           'duration' => 0,
4516           'sort_weight' => $usage_class{$detail->classnum}->weight,
4517           'phonenum' => $phonenum,
4518           'header'  => [ @header ],
4519         };
4520       $sections{"$phonenum $line"}{amount} += $amount;  #subtotal
4521       $sections{"$phonenum $line"}{calls}++;
4522       $sections{"$phonenum $line"}{duration} += $detail->duration;
4523
4524       $lines{"$phonenum $line"}{$desc} ||= {
4525         description     => &{$escape}($description),
4526         #pkgpart         => $part_pkg->pkgpart,
4527         pkgnum          => '',
4528         ref             => '',
4529         amount          => 0,
4530         calls           => 0,
4531         duration        => 0,
4532         #unit_amount     => '',
4533         quantity        => '',
4534         product_code    => 'N/A',
4535         ext_description => [],
4536       };
4537
4538       $lines{"$phonenum $line"}{$desc}{amount} += $amount;
4539       $lines{"$phonenum $line"}{$desc}{calls}++;
4540       $lines{"$phonenum $line"}{$desc}{duration} += $detail->duration;
4541       push @{$lines{"$phonenum $line"}{$desc}{ext_description}},
4542            $detail->formatted('format' => $format);
4543
4544     }
4545   }
4546
4547   my %sectionmap = ();
4548   my $simple = new FS::usage_class { format => 'simple' }; #bleh
4549   foreach ( keys %sections ) {
4550     my @header = @{ $sections{$_}{header} || [] };
4551     my $usage_simple =
4552       new FS::usage_class { format => 'usage_'. (scalar(@header) || 6). 'col' };
4553     my $summary = $sections{$_}{sort_weight} < 0 ? 1 : 0;
4554     my $usage_class = $summary ? $simple : $usage_simple;
4555     my $ending = $summary ? ' usage charges' : '';
4556     my %gen_opt = ();
4557     unless ($summary) {
4558       $gen_opt{label} = [ map{ &{$escape}($_) } @header ];
4559     }
4560     $sectionmap{$_} = { 'description' => &{$escape}($_. $ending),
4561                         'amount'    => $sections{$_}{amount},    #subtotal
4562                         'calls'       => $sections{$_}{calls},
4563                         'duration'    => $sections{$_}{duration},
4564                         'summarized'  => '',
4565                         'tax_section' => '',
4566                         'phonenum'    => $sections{$_}{phonenum},
4567                         'sort_weight' => $sections{$_}{sort_weight},
4568                         'post_total'  => $summary, #inspire pagebreak
4569                         (
4570                           ( map { $_ => $usage_class->$_($format, %gen_opt) }
4571                             qw( description_generator
4572                                 header_generator
4573                                 total_generator
4574                                 total_line_generator
4575                               )
4576                           )
4577                         ),
4578                       };
4579   }
4580
4581   my @sections = sort { $a->{phonenum} cmp $b->{phonenum} ||
4582                         $a->{sort_weight} <=> $b->{sort_weight}
4583                       }
4584                  values %sectionmap;
4585
4586   my @lines = ();
4587   foreach my $section ( keys %lines ) {
4588     foreach my $line ( keys %{$lines{$section}} ) {
4589       my $l = $lines{$section}{$line};
4590       $l->{section}     = $sectionmap{$section};
4591       $l->{amount}      = sprintf( "%.2f", $l->{amount} );
4592       #$l->{unit_amount} = sprintf( "%.2f", $l->{unit_amount} );
4593       push @lines, $l;
4594     }
4595   }
4596
4597   if($conf->exists('phone_usage_class_summary')) {
4598       # this only works with Latex
4599       my @newlines;
4600       my @newsections;
4601
4602       # after this, we'll have only two sections per DID:
4603       # Calls Summary and Calls Detail
4604       foreach my $section ( @sections ) {
4605         if($section->{'post_total'}) {
4606             $section->{'description'} = 'Calls Summary: '.$section->{'phonenum'};
4607             $section->{'total_line_generator'} = sub { '' };
4608             $section->{'total_generator'} = sub { '' };
4609             $section->{'header_generator'} = sub { '' };
4610             $section->{'description_generator'} = '';
4611             push @newsections, $section;
4612             my %calls_detail = %$section;
4613             $calls_detail{'post_total'} = '';
4614             $calls_detail{'sort_weight'} = '';
4615             $calls_detail{'description_generator'} = sub { '' };
4616             $calls_detail{'header_generator'} = sub {
4617                 return ' & Date/Time & Called Number & Duration & Price'
4618                     if $format eq 'latex';
4619                 '';
4620             };
4621             $calls_detail{'description'} = 'Calls Detail: '
4622                                                     . $section->{'phonenum'};
4623             push @newsections, \%calls_detail;
4624         }
4625       }
4626
4627       # after this, each usage class is collapsed/summarized into a single
4628       # line under the Calls Summary section
4629       foreach my $newsection ( @newsections ) {
4630         if($newsection->{'post_total'}) { # this means Calls Summary
4631             foreach my $section ( @sections ) {
4632                 next unless ($section->{'phonenum'} eq $newsection->{'phonenum'}
4633                                 && !$section->{'post_total'});
4634                 my $newdesc = $section->{'description'};
4635                 my $tn = $section->{'phonenum'};
4636                 $newdesc =~ s/$tn//g;
4637                 my $line = {  ext_description => [],
4638                               pkgnum => '',
4639                               ref => '',
4640                               quantity => '',
4641                               calls => $section->{'calls'},
4642                               section => $newsection,
4643                               duration => $section->{'duration'},
4644                               description => $newdesc,
4645                               amount => sprintf("%.2f",$section->{'amount'}),
4646                               product_code => 'N/A',
4647                             };
4648                 push @newlines, $line;
4649             }
4650         }
4651       }
4652
4653       # after this, Calls Details is populated with all CDRs
4654       foreach my $newsection ( @newsections ) {
4655         if(!$newsection->{'post_total'}) { # this means Calls Details
4656             foreach my $line ( @lines ) {
4657                 next unless (scalar(@{$line->{'ext_description'}}) &&
4658                         $line->{'section'}->{'phonenum'} eq $newsection->{'phonenum'}
4659                             );
4660                 my @extdesc = @{$line->{'ext_description'}};
4661                 my @newextdesc;
4662                 foreach my $extdesc ( @extdesc ) {
4663                     $extdesc =~ s/scriptsize/normalsize/g if $format eq 'latex';
4664                     push @newextdesc, $extdesc;
4665                 }
4666                 $line->{'ext_description'} = \@newextdesc;
4667                 $line->{'section'} = $newsection;
4668                 push @newlines, $line;
4669             }
4670         }
4671       }
4672
4673       return(\@newsections, \@newlines);
4674   }
4675
4676   return(\@sections, \@lines);
4677
4678 }
4679
4680 sub _items { # seems to be unused
4681   my $self = shift;
4682
4683   #my @display = scalar(@_)
4684   #              ? @_
4685   #              : qw( _items_previous _items_pkg );
4686   #              #: qw( _items_pkg );
4687   #              #: qw( _items_previous _items_pkg _items_tax _items_credits _items_payments );
4688   my @display = qw( _items_previous _items_pkg );
4689
4690   my @b = ();
4691   foreach my $display ( @display ) {
4692     push @b, $self->$display(@_);
4693   }
4694   @b;
4695 }
4696
4697 sub _items_previous {
4698   my $self = shift;
4699   my $conf = $self->conf;
4700   my $cust_main = $self->cust_main;
4701   my( $pr_total, @pr_cust_bill ) = $self->previous; #previous balance
4702   my @b = ();
4703   foreach ( @pr_cust_bill ) {
4704     my $date = $conf->exists('invoice_show_prior_due_date')
4705                ? 'due '. $_->due_date2str($date_format)
4706                : time2str($date_format, $_->_date);
4707     push @b, {
4708       'description' => $self->mt('Previous Balance, Invoice #'). $_->invnum. " ($date)",
4709       #'pkgpart'     => 'N/A',
4710       'pkgnum'      => 'N/A',
4711       'amount'      => sprintf("%.2f", $_->owed),
4712     };
4713   }
4714   @b;
4715
4716   #{
4717   #    'description'     => 'Previous Balance',
4718   #    #'pkgpart'         => 'N/A',
4719   #    'pkgnum'          => 'N/A',
4720   #    'amount'          => sprintf("%10.2f", $pr_total ),
4721   #    'ext_description' => [ map {
4722   #                                 "Invoice ". $_->invnum.
4723   #                                 " (". time2str("%x",$_->_date). ") ".
4724   #                                 sprintf("%10.2f", $_->owed)
4725   #                         } @pr_cust_bill ],
4726
4727   #};
4728 }
4729
4730 =item _items_pkg [ OPTIONS ]
4731
4732 Return line item hashes for each package item on this invoice. Nearly
4733 equivalent to
4734
4735 $self->_items_cust_bill_pkg([ $self->cust_bill_pkg ])
4736
4737 The only OPTIONS accepted is 'section', which may point to a hashref
4738 with a key named 'condensed', which may have a true value.  If it
4739 does, this method tries to merge identical items into items with
4740 'quantity' equal to the number of items (not the sum of their
4741 separate quantities, for some reason).
4742
4743 =cut
4744
4745 sub _items_pkg {
4746   my $self = shift;
4747   my %options = @_;
4748
4749   warn "$me _items_pkg searching for all package line items\n"
4750     if $DEBUG > 1;
4751
4752   my @cust_bill_pkg = grep { $_->pkgnum } $self->cust_bill_pkg;
4753
4754   warn "$me _items_pkg filtering line items\n"
4755     if $DEBUG > 1;
4756   my @items = $self->_items_cust_bill_pkg(\@cust_bill_pkg, @_);
4757
4758   if ($options{section} && $options{section}->{condensed}) {
4759
4760     warn "$me _items_pkg condensing section\n"
4761       if $DEBUG > 1;
4762
4763     my %itemshash = ();
4764     local $Storable::canonical = 1;
4765     foreach ( @items ) {
4766       my $item = { %$_ };
4767       delete $item->{ref};
4768       delete $item->{ext_description};
4769       my $key = freeze($item);
4770       $itemshash{$key} ||= 0;
4771       $itemshash{$key} ++; # += $item->{quantity};
4772     }
4773     @items = sort { $a->{description} cmp $b->{description} }
4774              map { my $i = thaw($_);
4775                    $i->{quantity} = $itemshash{$_};
4776                    $i->{amount} =
4777                      sprintf( "%.2f", $i->{quantity} * $i->{amount} );#unit_amount
4778                    $i;
4779                  }
4780              keys %itemshash;
4781   }
4782
4783   warn "$me _items_pkg returning ". scalar(@items). " items\n"
4784     if $DEBUG > 1;
4785
4786   @items;
4787 }
4788
4789 sub _taxsort {
4790   return 0 unless $a->itemdesc cmp $b->itemdesc;
4791   return -1 if $b->itemdesc eq 'Tax';
4792   return 1 if $a->itemdesc eq 'Tax';
4793   return -1 if $b->itemdesc eq 'Other surcharges';
4794   return 1 if $a->itemdesc eq 'Other surcharges';
4795   $a->itemdesc cmp $b->itemdesc;
4796 }
4797
4798 sub _items_tax {
4799   my $self = shift;
4800   my @cust_bill_pkg = sort _taxsort grep { ! $_->pkgnum } $self->cust_bill_pkg;
4801   $self->_items_cust_bill_pkg(\@cust_bill_pkg, @_);
4802 }
4803
4804 =item _items_cust_bill_pkg CUST_BILL_PKGS OPTIONS
4805
4806 Takes an arrayref of L<FS::cust_bill_pkg> objects, and returns a
4807 list of hashrefs describing the line items they generate on the invoice.
4808
4809 OPTIONS may include:
4810
4811 format: the invoice format.
4812
4813 escape_function: the function used to escape strings.
4814
4815 DEPRECATED? (expensive, mostly unused?)
4816 format_function: the function used to format CDRs.
4817
4818 section: a hashref containing 'description'; if this is present,
4819 cust_bill_pkg_display records not belonging to this section are
4820 ignored.
4821
4822 multisection: a flag indicating that this is a multisection invoice,
4823 which does something complicated.
4824
4825 multilocation: a flag to display the location label for the package.
4826
4827 Returns a list of hashrefs, each of which may contain:
4828
4829 pkgnum, description, amount, unit_amount, quantity, _is_setup, and
4830 ext_description, which is an arrayref of detail lines to show below
4831 the package line.
4832
4833 =cut
4834
4835 sub _items_cust_bill_pkg {
4836   my $self = shift;
4837   my $conf = $self->conf;
4838   my $cust_bill_pkgs = shift;
4839   my %opt = @_;
4840
4841   my $format = $opt{format} || '';
4842   my $escape_function = $opt{escape_function} || sub { shift };
4843   my $format_function = $opt{format_function} || '';
4844   my $no_usage = $opt{no_usage} || '';
4845   my $unsquelched = $opt{unsquelched} || ''; #unused
4846   my $section = $opt{section}->{description} if $opt{section};
4847   my $summary_page = $opt{summary_page} || ''; #unused
4848   my $multilocation = $opt{multilocation} || '';
4849   my $multisection = $opt{multisection} || '';
4850   my $discount_show_always = 0;
4851
4852   my $maxlength = $conf->config('cust_bill-latex_lineitem_maxlength') || 50;
4853
4854   my @b = ();
4855   my ($s, $r, $u) = ( undef, undef, undef );
4856   foreach my $cust_bill_pkg ( @$cust_bill_pkgs )
4857   {
4858
4859     foreach ( $s, $r, ($opt{skip_usage} ? () : $u ) ) {
4860       if ( $_ && !$cust_bill_pkg->hidden ) {
4861         $_->{amount}      = sprintf( "%.2f", $_->{amount} ),
4862         $_->{amount}      =~ s/^\-0\.00$/0.00/;
4863         $_->{unit_amount} = sprintf( "%.2f", $_->{unit_amount} ),
4864         push @b, { %$_ }
4865           if $_->{amount} != 0
4866           || $discount_show_always
4867           || ( ! $_->{_is_setup} && $_->{recur_show_zero} )
4868           || (   $_->{_is_setup} && $_->{setup_show_zero} )
4869         ;
4870         $_ = undef;
4871       }
4872     }
4873
4874     warn "$me _items_cust_bill_pkg considering cust_bill_pkg ".
4875          $cust_bill_pkg->billpkgnum. ", pkgnum ". $cust_bill_pkg->pkgnum. "\n"
4876       if $DEBUG > 1;
4877
4878     foreach my $display ( grep { defined($section)
4879                                  ? $_->section eq $section
4880                                  : 1
4881                                }
4882                           #grep { !$_->summary || !$summary_page } # bunk!
4883                           grep { !$_->summary || $multisection }
4884                           $cust_bill_pkg->cust_bill_pkg_display
4885                         )
4886     {
4887
4888       warn "$me _items_cust_bill_pkg considering cust_bill_pkg_display ".
4889            $display->billpkgdisplaynum. "\n"
4890         if $DEBUG > 1;
4891
4892       my $type = $display->type;
4893
4894       my $desc = $cust_bill_pkg->desc;
4895       $desc = substr($desc, 0, $maxlength). '...'
4896         if $format eq 'latex' && length($desc) > $maxlength;
4897
4898       my %details_opt = ( 'format'          => $format,
4899                           'escape_function' => $escape_function,
4900                           'format_function' => $format_function,
4901                           'no_usage'        => $opt{'no_usage'},
4902                         );
4903
4904       if ( $cust_bill_pkg->pkgnum > 0 ) {
4905
4906         warn "$me _items_cust_bill_pkg cust_bill_pkg is non-tax\n"
4907           if $DEBUG > 1;
4908
4909         my $cust_pkg = $cust_bill_pkg->cust_pkg;
4910
4911         # start/end dates for invoice formats that do nonstandard
4912         # things with them
4913         my %item_dates = map { $_ => $cust_bill_pkg->$_ } ('sdate', 'edate');
4914
4915         if (    (!$type || $type eq 'S')
4916              && (    $cust_bill_pkg->setup != 0
4917                   || $cust_bill_pkg->setup_show_zero
4918                 )
4919            )
4920          {
4921
4922           warn "$me _items_cust_bill_pkg adding setup\n"
4923             if $DEBUG > 1;
4924
4925           my $description = $desc;
4926           $description .= ' Setup'
4927             if $cust_bill_pkg->recur != 0
4928             || $discount_show_always
4929             || $cust_bill_pkg->recur_show_zero;
4930
4931           my @d = ();
4932           unless ( $cust_pkg->part_pkg->hide_svc_detail
4933                 || $cust_bill_pkg->hidden )
4934           {
4935
4936             push @d, map &{$escape_function}($_),
4937                          $cust_pkg->h_labels_short($self->_date, undef, 'I')
4938               unless $cust_bill_pkg->pkgpart_override; #don't redisplay services
4939
4940             if ( $multilocation ) {
4941               my $loc = $cust_pkg->location_label;
4942               $loc = substr($loc, 0, $maxlength). '...'
4943                 if $format eq 'latex' && length($loc) > $maxlength;
4944               push @d, &{$escape_function}($loc);
4945             }
4946
4947           } #unless hiding service details
4948
4949           push @d, $cust_bill_pkg->details(%details_opt)
4950             if $cust_bill_pkg->recur == 0;
4951
4952           if ( $cust_bill_pkg->hidden ) {
4953             $s->{amount}      += $cust_bill_pkg->setup;
4954             $s->{unit_amount} += $cust_bill_pkg->unitsetup;
4955             push @{ $s->{ext_description} }, @d;
4956           } else {
4957             $s = {
4958               _is_setup       => 1,
4959               description     => $description,
4960               #pkgpart         => $part_pkg->pkgpart,
4961               pkgnum          => $cust_bill_pkg->pkgnum,
4962               amount          => $cust_bill_pkg->setup,
4963               setup_show_zero => $cust_bill_pkg->setup_show_zero,
4964               unit_amount     => $cust_bill_pkg->unitsetup,
4965               quantity        => $cust_bill_pkg->quantity,
4966               ext_description => \@d,
4967             };
4968           };
4969
4970         }
4971
4972         if (    ( !$type || $type eq 'R' || $type eq 'U' )
4973              && (
4974                      $cust_bill_pkg->recur != 0
4975                   || $cust_bill_pkg->setup == 0
4976                   || $discount_show_always
4977                   || $cust_bill_pkg->recur_show_zero
4978                 )
4979            )
4980         {
4981
4982           warn "$me _items_cust_bill_pkg adding recur/usage\n"
4983             if $DEBUG > 1;
4984
4985           my $is_summary = $display->summary;
4986           my $description = ($is_summary && $type && $type eq 'U')
4987                             ? "Usage charges" : $desc;
4988
4989           unless (
4990             $conf->exists('disable_line_item_date_ranges')
4991               || $cust_pkg->part_pkg->option('disable_line_item_date_ranges',1)
4992           ) {
4993             my $time_period;
4994             my $date_style = $conf->config('cust_bill-line_item-date_style');
4995             if ( $date_style eq 'month_of' ) {
4996               $time_period = time2str('The month of %B', $cust_bill_pkg->sdate);
4997             } else {
4998               $time_period =      time2str($date_format, $cust_bill_pkg->sdate).
4999                            " - ". time2str($date_format, $cust_bill_pkg->edate);
5000             }
5001             $description .= " ($time_period)";
5002           }
5003
5004           my @d = ();
5005           my @seconds = (); # for display of usage info
5006
5007           #at least until cust_bill_pkg has "past" ranges in addition to
5008           #the "future" sdate/edate ones... see #3032
5009           my @dates = ( $self->_date );
5010           my $prev = $cust_bill_pkg->previous_cust_bill_pkg;
5011           push @dates, $prev->sdate if $prev;
5012           push @dates, undef if !$prev;
5013
5014           unless ( $cust_pkg->part_pkg->hide_svc_detail
5015                 || $cust_bill_pkg->itemdesc
5016                 || $cust_bill_pkg->hidden
5017                 || $is_summary && $type && $type eq 'U' )
5018           {
5019
5020             warn "$me _items_cust_bill_pkg adding service details\n"
5021               if $DEBUG > 1;
5022
5023             push @d, map &{$escape_function}($_),
5024                          $cust_pkg->h_labels_short(@dates, 'I')
5025                                                    #$cust_bill_pkg->edate,
5026                                                    #$cust_bill_pkg->sdate)
5027               unless $cust_bill_pkg->pkgpart_override; #don't redisplay services
5028
5029             warn "$me _items_cust_bill_pkg done adding service details\n"
5030               if $DEBUG > 1;
5031
5032             if ( $multilocation ) {
5033               my $loc = $cust_pkg->location_label;
5034               $loc = substr($loc, 0, $maxlength). '...'
5035                 if $format eq 'latex' && length($loc) > $maxlength;
5036               push @d, &{$escape_function}($loc);
5037             }
5038
5039             # Display of seconds_since_sqlradacct:
5040             # On the invoice, when processing @detail_items, look for a field
5041             # named 'seconds'.  This will contain total seconds for each
5042             # service, in the same order as @ext_description.  For services
5043             # that don't support this it will show undef.
5044             if ( $conf->exists('svc_acct-usage_seconds')
5045                  and ! $cust_bill_pkg->pkgpart_override ) {
5046               foreach my $cust_svc (
5047                   $cust_pkg->h_cust_svc(@dates, 'I')
5048                 ) {
5049
5050                 # eval because not having any part_export_usage exports
5051                 # is a fatal error, last_bill/_date because that's how
5052                 # sqlradius_hour billing does it
5053                 my $sec = eval {
5054                   $cust_svc->seconds_since_sqlradacct($dates[1] || 0, $dates[0]);
5055                 };
5056                 push @seconds, $sec;
5057               }
5058             } #if svc_acct-usage_seconds
5059
5060           }
5061
5062           unless ( $is_summary ) {
5063             warn "$me _items_cust_bill_pkg adding details\n"
5064               if $DEBUG > 1;
5065
5066             #instead of omitting details entirely in this case (unwanted side
5067             # effects), just omit CDRs
5068             $details_opt{'no_usage'} = 1
5069               if $type && $type eq 'R';
5070
5071             push @d, $cust_bill_pkg->details(%details_opt);
5072           }
5073
5074           warn "$me _items_cust_bill_pkg calculating amount\n"
5075             if $DEBUG > 1;
5076
5077           my $amount = 0;
5078           if (!$type) {
5079             $amount = $cust_bill_pkg->recur;
5080           } elsif ($type eq 'R') {
5081             $amount = $cust_bill_pkg->recur - $cust_bill_pkg->usage;
5082           } elsif ($type eq 'U') {
5083             $amount = $cust_bill_pkg->usage;
5084           }
5085
5086           if ( !$type || $type eq 'R' ) {
5087
5088             warn "$me _items_cust_bill_pkg adding recur\n"
5089               if $DEBUG > 1;
5090
5091             if ( $cust_bill_pkg->hidden ) {
5092               $r->{amount}      += $amount;
5093               $r->{unit_amount} += $cust_bill_pkg->unitrecur;
5094               push @{ $r->{ext_description} }, @d;
5095             } else {
5096               $r = {
5097                 description     => $description,
5098                 #pkgpart         => $part_pkg->pkgpart,
5099                 pkgnum          => $cust_bill_pkg->pkgnum,
5100                 amount          => $amount,
5101                 recur_show_zero => $cust_bill_pkg->recur_show_zero,
5102                 unit_amount     => $cust_bill_pkg->unitrecur,
5103                 quantity        => $cust_bill_pkg->quantity,
5104                 %item_dates,
5105                 ext_description => \@d,
5106               };
5107               $r->{'seconds'} = \@seconds if grep {defined $_} @seconds;
5108             }
5109
5110           } else {  # $type eq 'U'
5111
5112             warn "$me _items_cust_bill_pkg adding usage\n"
5113               if $DEBUG > 1;
5114
5115             if ( $cust_bill_pkg->hidden ) {
5116               $u->{amount}      += $amount;
5117               $u->{unit_amount} += $cust_bill_pkg->unitrecur;
5118               push @{ $u->{ext_description} }, @d;
5119             } else {
5120               $u = {
5121                 description     => $description,
5122                 #pkgpart         => $part_pkg->pkgpart,
5123                 pkgnum          => $cust_bill_pkg->pkgnum,
5124                 amount          => $amount,
5125                 recur_show_zero => $cust_bill_pkg->recur_show_zero,
5126                 unit_amount     => $cust_bill_pkg->unitrecur,
5127                 quantity        => $cust_bill_pkg->quantity,
5128                 %item_dates,
5129                 ext_description => \@d,
5130               };
5131             }
5132           }
5133
5134         } # recurring or usage with recurring charge
5135
5136       } else { #pkgnum tax or one-shot line item (??)
5137
5138         warn "$me _items_cust_bill_pkg cust_bill_pkg is tax\n"
5139           if $DEBUG > 1;
5140
5141         if ( $cust_bill_pkg->setup != 0 ) {
5142           push @b, {
5143             'description' => $desc,
5144             'amount'      => sprintf("%.2f", $cust_bill_pkg->setup),
5145           };
5146         }
5147         if ( $cust_bill_pkg->recur != 0 ) {
5148           push @b, {
5149             'description' => "$desc (".
5150                              time2str($date_format, $cust_bill_pkg->sdate). ' - '.
5151                              time2str($date_format, $cust_bill_pkg->edate). ')',
5152             'amount'      => sprintf("%.2f", $cust_bill_pkg->recur),
5153           };
5154         }
5155
5156       }
5157
5158     }
5159
5160     $discount_show_always = ($cust_bill_pkg->cust_bill_pkg_discount
5161                                 && $conf->exists('discount-show-always'));
5162
5163   }
5164
5165   foreach ( $s, $r, ($opt{skip_usage} ? () : $u ) ) {
5166     if ( $_  ) {
5167       $_->{amount}      = sprintf( "%.2f", $_->{amount} ),
5168       $_->{amount}      =~ s/^\-0\.00$/0.00/;
5169       $_->{unit_amount} = sprintf( "%.2f", $_->{unit_amount} ),
5170       push @b, { %$_ }
5171         if $_->{amount} != 0
5172         || $discount_show_always
5173         || ( ! $_->{_is_setup} && $_->{recur_show_zero} )
5174         || (   $_->{_is_setup} && $_->{setup_show_zero} )
5175     }
5176   }
5177
5178   warn "$me _items_cust_bill_pkg done considering cust_bill_pkgs\n"
5179     if $DEBUG > 1;
5180
5181   @b;
5182
5183 }
5184
5185 sub _items_credits {
5186   my( $self, %opt ) = @_;
5187   my $trim_len = $opt{'trim_len'} || 60;
5188
5189   my @b;
5190   #credits
5191   foreach ( $self->cust_credited ) {
5192
5193     #something more elaborate if $_->amount ne $_->cust_credit->credited ?
5194
5195     my $reason = substr($_->cust_credit->reason, 0, $trim_len);
5196     $reason .= '...' if length($reason) < length($_->cust_credit->reason);
5197     $reason = " ($reason) " if $reason;
5198
5199     push @b, {
5200       #'description' => 'Credit ref\#'. $_->crednum.
5201       #                 " (". time2str("%x",$_->cust_credit->_date) .")".
5202       #                 $reason,
5203       'description' => $self->mt('Credit applied').' '.
5204                        time2str($date_format,$_->cust_credit->_date). $reason,
5205       'amount'      => sprintf("%.2f",$_->amount),
5206     };
5207   }
5208
5209   @b;
5210
5211 }
5212
5213 sub _items_payments {
5214   my $self = shift;
5215
5216   my @b;
5217   #get & print payments
5218   foreach ( $self->cust_bill_pay ) {
5219
5220     #something more elaborate if $_->amount ne ->cust_pay->paid ?
5221
5222     push @b, {
5223       'description' => $self->mt('Payment received').' '.
5224                        time2str($date_format,$_->cust_pay->_date ),
5225       'amount'      => sprintf("%.2f", $_->amount )
5226     };
5227   }
5228
5229   @b;
5230
5231 }
5232
5233 =item _items_discounts_avail
5234
5235 Returns an array of line item hashrefs representing available term discounts
5236 for this invoice.  This makes the same assumptions that apply to term
5237 discounts in general: that the package is billed monthly, at a flat rate,
5238 with no usage charges.  A prorated first month will be handled, as will
5239 a setup fee if the discount is allowed to apply to setup fees.
5240
5241 =cut
5242
5243 sub _items_discounts_avail {
5244   my $self = shift;
5245   my $list_pkgnums = 0; # if any packages are not eligible for all discounts
5246
5247   my %plans = $self->discount_plans;
5248
5249   $list_pkgnums = grep { $_->list_pkgnums } values %plans;
5250
5251   map {
5252     my $months = $_;
5253     my $plan = $plans{$months};
5254
5255     my $term_total = sprintf('%.2f', $plan->discounted_total);
5256     my $percent = sprintf('%.0f',
5257                           100 * (1 - $term_total / $plan->base_total) );
5258     my $permonth = sprintf('%.2f', $term_total / $months);
5259     my $detail = $self->mt('discount on item'). ' '.
5260                  join(', ', map { "#$_" } $plan->pkgnums)
5261       if $list_pkgnums;
5262
5263     +{
5264       description => $self->mt('Save [_1]% by paying for [_2] months',
5265                                 $percent, $months),
5266       amount      => $self->mt('[_1] ([_2] per month)',
5267                                 $term_total, $money_char.$permonth),
5268       ext_description => ($detail || ''),
5269     }
5270   } #map
5271   sort { $b <=> $a } keys %plans;
5272
5273 }
5274
5275 =item call_details [ OPTION => VALUE ... ]
5276
5277 Returns an array of CSV strings representing the call details for this invoice
5278 The only option available is the boolean prepend_billed_number
5279
5280 =cut
5281
5282 sub call_details {
5283   my ($self, %opt) = @_;
5284
5285   my $format_function = sub { shift };
5286
5287   if ($opt{prepend_billed_number}) {
5288     $format_function = sub {
5289       my $detail = shift;
5290       my $row = shift;
5291
5292       $row->amount ? $row->phonenum. ",". $detail : '"Billed number",'. $detail;
5293
5294     };
5295   }
5296
5297   my @details = map { $_->details( 'format_function' => $format_function,
5298                                    'escape_function' => sub{ return() },
5299                                  )
5300                     }
5301                   grep { $_->pkgnum }
5302                   $self->cust_bill_pkg;
5303   my $header = $details[0];
5304   ( $header, grep { $_ ne $header } @details );
5305 }
5306
5307
5308 =back
5309
5310 =head1 SUBROUTINES
5311
5312 =over 4
5313
5314 =item process_reprint
5315
5316 =cut
5317
5318 sub process_reprint {
5319   process_re_X('print', @_);
5320 }
5321
5322 =item process_reemail
5323
5324 =cut
5325
5326 sub process_reemail {
5327   process_re_X('email', @_);
5328 }
5329
5330 =item process_refax
5331
5332 =cut
5333
5334 sub process_refax {
5335   process_re_X('fax', @_);
5336 }
5337
5338 =item process_reftp
5339
5340 =cut
5341
5342 sub process_reftp {
5343   process_re_X('ftp', @_);
5344 }
5345
5346 =item respool
5347
5348 =cut
5349
5350 sub process_respool {
5351   process_re_X('spool', @_);
5352 }
5353
5354 use Storable qw(thaw);
5355 use Data::Dumper;
5356 use MIME::Base64;
5357 sub process_re_X {
5358   my( $method, $job ) = ( shift, shift );
5359   warn "$me process_re_X $method for job $job\n" if $DEBUG;
5360
5361   my $param = thaw(decode_base64(shift));
5362   warn Dumper($param) if $DEBUG;
5363
5364   re_X(
5365     $method,
5366     $job,
5367     %$param,
5368   );
5369
5370 }
5371
5372 sub re_X {
5373   my($method, $job, %param ) = @_;
5374   if ( $DEBUG ) {
5375     warn "re_X $method for job $job with param:\n".
5376          join( '', map { "  $_ => ". $param{$_}. "\n" } keys %param );
5377   }
5378
5379   #some false laziness w/search/cust_bill.html
5380   my $distinct = '';
5381   my $orderby = 'ORDER BY cust_bill._date';
5382
5383   my $extra_sql = ' WHERE '. FS::cust_bill->search_sql_where(\%param);
5384
5385   my $addl_from = 'LEFT JOIN cust_main USING ( custnum )';
5386
5387   my @cust_bill = qsearch( {
5388     #'select'    => "cust_bill.*",
5389     'table'     => 'cust_bill',
5390     'addl_from' => $addl_from,
5391     'hashref'   => {},
5392     'extra_sql' => $extra_sql,
5393     'order_by'  => $orderby,
5394     'debug' => 1,
5395   } );
5396
5397   $method .= '_invoice' unless $method eq 'email' || $method eq 'print';
5398
5399   warn " $me re_X $method: ". scalar(@cust_bill). " invoices found\n"
5400     if $DEBUG;
5401
5402   my( $num, $last, $min_sec ) = (0, time, 5); #progresbar foo
5403   foreach my $cust_bill ( @cust_bill ) {
5404     $cust_bill->$method();
5405
5406     if ( $job ) { #progressbar foo
5407       $num++;
5408       if ( time - $min_sec > $last ) {
5409         my $error = $job->update_statustext(
5410           int( 100 * $num / scalar(@cust_bill) )
5411         );
5412         die $error if $error;
5413         $last = time;
5414       }
5415     }
5416
5417   }
5418
5419 }
5420
5421 =back
5422
5423 =head1 CLASS METHODS
5424
5425 =over 4
5426
5427 =item owed_sql
5428
5429 Returns an SQL fragment to retreive the amount owed (charged minus credited and paid).
5430
5431 =cut
5432
5433 sub owed_sql {
5434   my ($class, $start, $end) = @_;
5435   'charged - '.
5436     $class->paid_sql($start, $end). ' - '.
5437     $class->credited_sql($start, $end);
5438 }
5439
5440 =item net_sql
5441
5442 Returns an SQL fragment to retreive the net amount (charged minus credited).
5443
5444 =cut
5445
5446 sub net_sql {
5447   my ($class, $start, $end) = @_;
5448   'charged - '. $class->credited_sql($start, $end);
5449 }
5450
5451 =item paid_sql
5452
5453 Returns an SQL fragment to retreive the amount paid against this invoice.
5454
5455 =cut
5456
5457 sub paid_sql {
5458   my ($class, $start, $end) = @_;
5459   $start &&= "AND cust_bill_pay._date <= $start";
5460   $end   &&= "AND cust_bill_pay._date > $end";
5461   $start = '' unless defined($start);
5462   $end   = '' unless defined($end);
5463   "( SELECT COALESCE(SUM(amount),0) FROM cust_bill_pay
5464        WHERE cust_bill.invnum = cust_bill_pay.invnum $start $end  )";
5465 }
5466
5467 =item credited_sql
5468
5469 Returns an SQL fragment to retreive the amount credited against this invoice.
5470
5471 =cut
5472
5473 sub credited_sql {
5474   my ($class, $start, $end) = @_;
5475   $start &&= "AND cust_credit_bill._date <= $start";
5476   $end   &&= "AND cust_credit_bill._date >  $end";
5477   $start = '' unless defined($start);
5478   $end   = '' unless defined($end);
5479   "( SELECT COALESCE(SUM(amount),0) FROM cust_credit_bill
5480        WHERE cust_bill.invnum = cust_credit_bill.invnum $start $end  )";
5481 }
5482
5483 =item due_date_sql
5484
5485 Returns an SQL fragment to retrieve the due date of an invoice.
5486 Currently only supported on PostgreSQL.
5487
5488 =cut
5489
5490 sub due_date_sql {
5491   my $conf = new FS::Conf;
5492 'COALESCE(
5493   SUBSTRING(
5494     COALESCE(
5495       cust_bill.invoice_terms,
5496       cust_main.invoice_terms,
5497       \''.($conf->config('invoice_default_terms') || '').'\'
5498     ), E\'Net (\\\\d+)\'
5499   )::INTEGER, 0
5500 ) * 86400 + cust_bill._date'
5501 }
5502
5503 =item search_sql_where HASHREF
5504
5505 Class method which returns an SQL WHERE fragment to search for parameters
5506 specified in HASHREF.  Valid parameters are
5507
5508 =over 4
5509
5510 =item _date
5511
5512 List reference of start date, end date, as UNIX timestamps.
5513
5514 =item invnum_min
5515
5516 =item invnum_max
5517
5518 =item agentnum
5519
5520 =item charged
5521
5522 List reference of charged limits (exclusive).
5523
5524 =item owed
5525
5526 List reference of charged limits (exclusive).
5527
5528 =item open
5529
5530 flag, return open invoices only
5531
5532 =item net
5533
5534 flag, return net invoices only
5535
5536 =item days
5537
5538 =item newest_percust
5539
5540 =back
5541
5542 Note: validates all passed-in data; i.e. safe to use with unchecked CGI params.
5543
5544 =cut
5545
5546 sub search_sql_where {
5547   my($class, $param) = @_;
5548   if ( $DEBUG ) {
5549     warn "$me search_sql_where called with params: \n".
5550          join("\n", map { "  $_: ". $param->{$_} } keys %$param ). "\n";
5551   }
5552
5553   my @search = ();
5554
5555   #agentnum
5556   if ( $param->{'agentnum'} =~ /^(\d+)$/ ) {
5557     push @search, "cust_main.agentnum = $1";
5558   }
5559
5560   #agentnum
5561   if ( $param->{'custnum'} =~ /^(\d+)$/ ) {
5562     push @search, "cust_bill.custnum = $1";
5563   }
5564
5565   #_date
5566   if ( $param->{_date} ) {
5567     my($beginning, $ending) = @{$param->{_date}};
5568
5569     push @search, "cust_bill._date >= $beginning",
5570                   "cust_bill._date <  $ending";
5571   }
5572
5573   #invnum
5574   if ( $param->{'invnum_min'} =~ /^(\d+)$/ ) {
5575     push @search, "cust_bill.invnum >= $1";
5576   }
5577   if ( $param->{'invnum_max'} =~ /^(\d+)$/ ) {
5578     push @search, "cust_bill.invnum <= $1";
5579   }
5580
5581   #charged
5582   if ( $param->{charged} ) {
5583     my @charged = ref($param->{charged})
5584                     ? @{ $param->{charged} }
5585                     : ($param->{charged});
5586
5587     push @search, map { s/^charged/cust_bill.charged/; $_; }
5588                       @charged;
5589   }
5590
5591   my $owed_sql = FS::cust_bill->owed_sql;
5592
5593   #owed
5594   if ( $param->{owed} ) {
5595     my @owed = ref($param->{owed})
5596                  ? @{ $param->{owed} }
5597                  : ($param->{owed});
5598     push @search, map { s/^owed/$owed_sql/; $_; }
5599                       @owed;
5600   }
5601
5602   #open/net flags
5603   push @search, "0 != $owed_sql"
5604     if $param->{'open'};
5605   push @search, '0 != '. FS::cust_bill->net_sql
5606     if $param->{'net'};
5607
5608   #days
5609   push @search, "cust_bill._date < ". (time-86400*$param->{'days'})
5610     if $param->{'days'};
5611
5612   #newest_percust
5613   if ( $param->{'newest_percust'} ) {
5614
5615     #$distinct = 'DISTINCT ON ( cust_bill.custnum )';
5616     #$orderby = 'ORDER BY cust_bill.custnum ASC, cust_bill._date DESC';
5617
5618     my @newest_where = map { my $x = $_;
5619                              $x =~ s/\bcust_bill\./newest_cust_bill./g;
5620                              $x;
5621                            }
5622                            grep ! /^cust_main./, @search;
5623     my $newest_where = scalar(@newest_where)
5624                          ? ' AND '. join(' AND ', @newest_where)
5625                          : '';
5626
5627
5628     push @search, "cust_bill._date = (
5629       SELECT(MAX(newest_cust_bill._date)) FROM cust_bill AS newest_cust_bill
5630         WHERE newest_cust_bill.custnum = cust_bill.custnum
5631           $newest_where
5632     )";
5633
5634   }
5635
5636   #promised_date - also has an option to accept nulls
5637   if ( $param->{promised_date} ) {
5638     my($beginning, $ending, $null) = @{$param->{promised_date}};
5639
5640     push @search, "(( cust_bill.promised_date >= $beginning AND ".
5641                     "cust_bill.promised_date <  $ending )" .
5642                     ($null ? ' OR cust_bill.promised_date IS NULL ) ' : ')');
5643   }
5644
5645   #agent virtualization
5646   my $curuser = $FS::CurrentUser::CurrentUser;
5647   if ( $curuser->username eq 'fs_queue'
5648        && $param->{'CurrentUser'} =~ /^(\w+)$/ ) {
5649     my $username = $1;
5650     my $newuser = qsearchs('access_user', {
5651       'username' => $username,
5652       'disabled' => '',
5653     } );
5654     if ( $newuser ) {
5655       $curuser = $newuser;
5656     } else {
5657       warn "$me WARNING: (fs_queue) can't find CurrentUser $username\n";
5658     }
5659   }
5660   push @search, $curuser->agentnums_sql;
5661
5662   join(' AND ', @search );
5663
5664 }
5665
5666 =back
5667
5668 =head1 BUGS
5669
5670 The delete method.
5671
5672 =head1 SEE ALSO
5673
5674 L<FS::Record>, L<FS::cust_main>, L<FS::cust_bill_pay>, L<FS::cust_pay>,
5675 L<FS::cust_bill_pkg>, L<FS::cust_bill_credit>, schema.html from the base
5676 documentation.
5677
5678 =cut
5679
5680 1;
5681