FS/FS/cust_bill.pm

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