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