FS/FS/cust_bill.pm

   1 package FS::cust_bill;
   2
   3 use strict;
   4 use vars qw( @ISA $DEBUG $me $conf $money_char );
   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 FS::UID qw( datasrc );
  15 use FS::Misc qw( send_email send_fax generate_ps generate_pdf do_print );
  16 use FS::Record qw( qsearch qsearchs dbh );
  17 use FS::cust_main_Mixin;
  18 use FS::cust_main;
  19 use FS::cust_bill_pkg;
  20 use FS::cust_bill_pkg_display;
  21 use FS::cust_credit;
  22 use FS::cust_pay;
  23 use FS::cust_pkg;
  24 use FS::cust_credit_bill;
  25 use FS::pay_batch;
  26 use FS::cust_pay_batch;
  27 use FS::cust_bill_event;
  28 use FS::cust_event;
  29 use FS::part_pkg;
  30 use FS::cust_bill_pay;
  31 use FS::cust_bill_pay_batch;
  32 use FS::part_bill_event;
  33 use FS::payby;
  34
  35 @ISA = qw( FS::cust_main_Mixin FS::Record );
  36
  37 $DEBUG = 0;
  38 $me = '[FS::cust_bill]';
  39
  40 #ask FS::UID to run this stuff for us later
  41 FS::UID->install_callback( sub {
  42   $conf = new FS::Conf;
  43   $money_char = $conf->config('money_char') || '$';
  44 } );
  45
  46 =head1 NAME
  47
  48 FS::cust_bill - Object methods for cust_bill records
  49
  50 =head1 SYNOPSIS
  51
  52   use FS::cust_bill;
  53
  54   $record = new FS::cust_bill \%hash;
  55   $record = new FS::cust_bill { 'column' => 'value' };
  56
  57   $error = $record->insert;
  58
  59   $error = $new_record->replace($old_record);
  60
  61   $error = $record->delete;
  62
  63   $error = $record->check;
  64
  65   ( $total_previous_balance, @previous_cust_bill ) = $record->previous;
  66
  67   @cust_bill_pkg_objects = $cust_bill->cust_bill_pkg;
  68
  69   ( $total_previous_credits, @previous_cust_credit ) = $record->cust_credit;
  70
  71   @cust_pay_objects = $cust_bill->cust_pay;
  72
  73   $tax_amount = $record->tax;
  74
  75   @lines = $cust_bill->print_text;
  76   @lines = $cust_bill->print_text $time;
  77
  78 =head1 DESCRIPTION
  79
  80 An FS::cust_bill object represents an invoice; a declaration that a customer
  81 owes you money.  The specific charges are itemized as B<cust_bill_pkg> records
  82 (see L<FS::cust_bill_pkg>).  FS::cust_bill inherits from FS::Record.  The
  83 following fields are currently supported:
  84
  85 =over 4
  86
  87 =item invnum - primary key (assigned automatically for new invoices)
  88
  89 =item custnum - customer (see L<FS::cust_main>)
  90
  91 =item _date - specified as a UNIX timestamp; see L<perlfunc/"time">.  Also see
  92 L<Time::Local> and L<Date::Parse> for conversion functions.
  93
  94 =item charged - amount of this invoice
  95
  96 =item printed - deprecated
  97
  98 =item closed - books closed flag, empty or `Y'
  99
 100 =back
 101
 102 =head1 METHODS
 103
 104 =over 4
 105
 106 =item new HASHREF
 107
 108 Creates a new invoice.  To add the invoice to the database, see L<"insert">.
 109 Invoices are normally created by calling the bill method of a customer object
 110 (see L<FS::cust_main>).
 111
 112 =cut
 113
 114 sub table { 'cust_bill'; }
 115
 116 sub cust_linked { $_[0]->cust_main_custnum; }
 117 sub cust_unlinked_msg {
 118   my $self = shift;
 119   "WARNING: can't find cust_main.custnum ". $self->custnum.
 120   ' (cust_bill.invnum '. $self->invnum. ')';
 121 }
 122
 123 =item insert
 124
 125 Adds this invoice to the database ("Posts" the invoice).  If there is an error,
 126 returns the error, otherwise returns false.
 127
 128 =item delete
 129
 130 This method now works but you probably shouldn't use it.  Instead, apply a
 131 credit against the invoice.
 132
 133 Using this method to delete invoices outright is really, really bad.  There
 134 would be no record you ever posted this invoice, and there are no check to
 135 make sure charged = 0 or that there are no associated cust_bill_pkg records.
 136
 137 Really, don't use it.
 138
 139 =cut
 140
 141 sub delete {
 142   my $self = shift;
 143   return "Can't delete closed invoice" if $self->closed =~ /^Y/i;
 144   $self->SUPER::delete(@_);
 145 }
 146
 147 =item replace OLD_RECORD
 148
 149 Replaces the OLD_RECORD with this one in the database.  If there is an error,
 150 returns the error, otherwise returns false.
 151
 152 Only printed may be changed.  printed is normally updated by calling the
 153 collect method of a customer object (see L<FS::cust_main>).
 154
 155 =cut
 156
 157 #replace can be inherited from Record.pm
 158
 159 # replace_check is now the preferred way to #implement replace data checks
 160 # (so $object->replace() works without an argument)
 161
 162 sub replace_check {
 163   my( $new, $old ) = ( shift, shift );
 164   return "Can't change custnum!" unless $old->custnum == $new->custnum;
 165   #return "Can't change _date!" unless $old->_date eq $new->_date;
 166   return "Can't change _date!" unless $old->_date == $new->_date;
 167   return "Can't change charged!" unless $old->charged == $new->charged
 168                                      || $old->charged == 0;
 169
 170   '';
 171 }
 172
 173 =item check
 174
 175 Checks all fields to make sure this is a valid invoice.  If there is an error,
 176 returns the error, otherwise returns false.  Called by the insert and replace
 177 methods.
 178
 179 =cut
 180
 181 sub check {
 182   my $self = shift;
 183
 184   my $error =
 185     $self->ut_numbern('invnum')
 186     || $self->ut_number('custnum')
 187     || $self->ut_numbern('_date')
 188     || $self->ut_money('charged')
 189     || $self->ut_numbern('printed')
 190     || $self->ut_enum('closed', [ '', 'Y' ])
 191   ;
 192   return $error if $error;
 193
 194   return "Unknown customer"
 195     unless qsearchs( 'cust_main', { 'custnum' => $self->custnum } );
 196
 197   $self->_date(time) unless $self->_date;
 198
 199   $self->printed(0) if $self->printed eq '';
 200
 201   $self->SUPER::check;
 202 }
 203
 204 =item previous
 205
 206 Returns a list consisting of the total previous balance for this customer,
 207 followed by the previous outstanding invoices (as FS::cust_bill objects also).
 208
 209 =cut
 210
 211 sub previous {
 212   my $self = shift;
 213   my $total = 0;
 214   my @cust_bill = sort { $a->_date <=> $b->_date }
 215     grep { $_->owed != 0 && $_->_date < $self->_date }
 216       qsearch( 'cust_bill', { 'custnum' => $self->custnum } )
 217   ;
 218   foreach ( @cust_bill ) { $total += $_->owed; }
 219   $total, @cust_bill;
 220 }
 221
 222 =item cust_bill_pkg
 223
 224 Returns the line items (see L<FS::cust_bill_pkg>) for this invoice.
 225
 226 =cut
 227
 228 sub cust_bill_pkg {
 229   my $self = shift;
 230   qsearch(
 231     { 'table'    => 'cust_bill_pkg',
 232       'hashref'  => { 'invnum' => $self->invnum },
 233       'order_by' => 'ORDER BY billpkgnum',
 234     }
 235   );
 236 }
 237
 238 =item cust_pkg
 239
 240 Returns the packages (see L<FS::cust_pkg>) corresponding to the line items for
 241 this invoice.
 242
 243 =cut
 244
 245 sub cust_pkg {
 246   my $self = shift;
 247   my @cust_pkg = map { $_->cust_pkg } $self->cust_bill_pkg;
 248   my %saw = ();
 249   grep { ! $saw{$_->pkgnum}++ } @cust_pkg;
 250 }
 251
 252 =item open_cust_bill_pkg
 253
 254 Returns the open line items for this invoice.
 255
 256 Note that cust_bill_pkg with both setup and recur fees are returned as two
 257 separate line items, each with only one fee.
 258
 259 =cut
 260
 261 # modeled after cust_main::open_cust_bill
 262 sub open_cust_bill_pkg {
 263   my $self = shift;
 264
 265   # grep { $_->owed > 0 } $self->cust_bill_pkg
 266
 267   my %other = ( 'recur' => 'setup',
 268                 'setup' => 'recur', );
 269   my @open = ();
 270   foreach my $field ( qw( recur setup )) {
 271     push @open, map  { $_->set( $other{$field}, 0 ); $_; }
 272                 grep { $_->owed($field) > 0 }
 273                 $self->cust_bill_pkg;
 274   }
 275
 276   @open;
 277 }
 278
 279 =item cust_bill_event
 280
 281 Returns the completed invoice events (deprecated, old-style events - see L<FS::cust_bill_event>) for this invoice.
 282
 283 =cut
 284
 285 sub cust_bill_event {
 286   my $self = shift;
 287   qsearch( 'cust_bill_event', { 'invnum' => $self->invnum } );
 288 }
 289
 290 =item num_cust_bill_event
 291
 292 Returns the number of completed invoice events (deprecated, old-style events - see L<FS::cust_bill_event>) for this invoice.
 293
 294 =cut
 295
 296 sub num_cust_bill_event {
 297   my $self = shift;
 298   my $sql =
 299     "SELECT COUNT(*) FROM cust_bill_event WHERE invnum = ?";
 300   my $sth = dbh->prepare($sql) or die  dbh->errstr. " preparing $sql";
 301   $sth->execute($self->invnum) or die $sth->errstr. " executing $sql";
 302   $sth->fetchrow_arrayref->[0];
 303 }
 304
 305 =item cust_event
 306
 307 Returns the new-style customer billing events (see L<FS::cust_event>) for this invoice.
 308
 309 =cut
 310
 311 #false laziness w/cust_pkg.pm
 312 sub cust_event {
 313   my $self = shift;
 314   qsearch({
 315     'table'     => 'cust_event',
 316     'addl_from' => 'JOIN part_event USING ( eventpart )',
 317     'hashref'   => { 'tablenum' => $self->invnum },
 318     'extra_sql' => " AND eventtable = 'cust_bill' ",
 319   });
 320 }
 321
 322 =item num_cust_event
 323
 324 Returns the number of new-style customer billing events (see L<FS::cust_event>) for this invoice.
 325
 326 =cut
 327
 328 #false laziness w/cust_pkg.pm
 329 sub num_cust_event {
 330   my $self = shift;
 331   my $sql =
 332     "SELECT COUNT(*) FROM cust_event JOIN part_event USING ( eventpart ) ".
 333     "  WHERE tablenum = ? AND eventtable = 'cust_bill'";
 334   my $sth = dbh->prepare($sql) or die  dbh->errstr. " preparing $sql";
 335   $sth->execute($self->invnum) or die $sth->errstr. " executing $sql";
 336   $sth->fetchrow_arrayref->[0];
 337 }
 338
 339 =item cust_main
 340
 341 Returns the customer (see L<FS::cust_main>) for this invoice.
 342
 343 =cut
 344
 345 sub cust_main {
 346   my $self = shift;
 347   qsearchs( 'cust_main', { 'custnum' => $self->custnum } );
 348 }
 349
 350 =item cust_suspend_if_balance_over AMOUNT
 351
 352 Suspends the customer associated with this invoice if the total amount owed on
 353 this invoice and all older invoices is greater than the specified amount.
 354
 355 Returns a list: an empty list on success or a list of errors.
 356
 357 =cut
 358
 359 sub cust_suspend_if_balance_over {
 360   my( $self, $amount ) = ( shift, shift );
 361   my $cust_main = $self->cust_main;
 362   if ( $cust_main->total_owed_date($self->_date) < $amount ) {
 363     return ();
 364   } else {
 365     $cust_main->suspend(@_);
 366   }
 367 }
 368
 369 =item cust_credit
 370
 371 Depreciated.  See the cust_credited method.
 372
 373  #Returns a list consisting of the total previous credited (see
 374  #L<FS::cust_credit>) and unapplied for this customer, followed by the previous
 375  #outstanding credits (FS::cust_credit objects).
 376
 377 =cut
 378
 379 sub cust_credit {
 380   use Carp;
 381   croak "FS::cust_bill->cust_credit depreciated; see ".
 382         "FS::cust_bill->cust_credit_bill";
 383   #my $self = shift;
 384   #my $total = 0;
 385   #my @cust_credit = sort { $a->_date <=> $b->_date }
 386   #  grep { $_->credited != 0 && $_->_date < $self->_date }
 387   #    qsearch('cust_credit', { 'custnum' => $self->custnum } )
 388   #;
 389   #foreach (@cust_credit) { $total += $_->credited; }
 390   #$total, @cust_credit;
 391 }
 392
 393 =item cust_pay
 394
 395 Depreciated.  See the cust_bill_pay method.
 396
 397 #Returns all payments (see L<FS::cust_pay>) for this invoice.
 398
 399 =cut
 400
 401 sub cust_pay {
 402   use Carp;
 403   croak "FS::cust_bill->cust_pay depreciated; see FS::cust_bill->cust_bill_pay";
 404   #my $self = shift;
 405   #sort { $a->_date <=> $b->_date }
 406   #  qsearch( 'cust_pay', { 'invnum' => $self->invnum } )
 407   #;
 408 }
 409
 410 =item cust_bill_pay
 411
 412 Returns all payment applications (see L<FS::cust_bill_pay>) for this invoice.
 413
 414 =cut
 415
 416 sub cust_bill_pay {
 417   my $self = shift;
 418   sort { $a->_date <=> $b->_date }
 419     qsearch( 'cust_bill_pay', { 'invnum' => $self->invnum } );
 420 }
 421
 422 =item cust_credited
 423
 424 Returns all applied credits (see L<FS::cust_credit_bill>) for this invoice.
 425
 426 =cut
 427
 428 sub cust_credited {
 429   my $self = shift;
 430   sort { $a->_date <=> $b->_date }
 431     qsearch( 'cust_credit_bill', { 'invnum' => $self->invnum } )
 432   ;
 433 }
 434
 435 =item tax
 436
 437 Returns the tax amount (see L<FS::cust_bill_pkg>) for this invoice.
 438
 439 =cut
 440
 441 sub tax {
 442   my $self = shift;
 443   my $total = 0;
 444   my @taxlines = qsearch( 'cust_bill_pkg', { 'invnum' => $self->invnum ,
 445                                              'pkgnum' => 0 } );
 446   foreach (@taxlines) { $total += $_->setup; }
 447   $total;
 448 }
 449
 450 =item owed
 451
 452 Returns the amount owed (still outstanding) on this invoice, which is charged
 453 minus all payment applications (see L<FS::cust_bill_pay>) and credit
 454 applications (see L<FS::cust_credit_bill>).
 455
 456 =cut
 457
 458 sub owed {
 459   my $self = shift;
 460   my $balance = $self->charged;
 461   $balance -= $_->amount foreach ( $self->cust_bill_pay );
 462   $balance -= $_->amount foreach ( $self->cust_credited );
 463   $balance = sprintf( "%.2f", $balance);
 464   $balance =~ s/^\-0\.00$/0.00/; #yay ieee fp
 465   $balance;
 466 }
 467
 468 =item apply_payments_and_credits
 469
 470 =cut
 471
 472 sub apply_payments_and_credits {
 473   my $self = shift;
 474
 475   local $SIG{HUP} = 'IGNORE';
 476   local $SIG{INT} = 'IGNORE';
 477   local $SIG{QUIT} = 'IGNORE';
 478   local $SIG{TERM} = 'IGNORE';
 479   local $SIG{TSTP} = 'IGNORE';
 480   local $SIG{PIPE} = 'IGNORE';
 481
 482   my $oldAutoCommit = $FS::UID::AutoCommit;
 483   local $FS::UID::AutoCommit = 0;
 484   my $dbh = dbh;
 485
 486   $self->select_for_update; #mutex
 487
 488   my @payments = grep { $_->unapplied > 0 } $self->cust_main->cust_pay;
 489   my @credits  = grep { $_->credited > 0 } $self->cust_main->cust_credit;
 490
 491   while ( $self->owed > 0 and ( @payments || @credits ) ) {
 492
 493     my $app = '';
 494     if ( @payments && @credits ) {
 495
 496       #decide which goes first by weight of top (unapplied) line item
 497
 498       my @open_lineitems = $self->open_cust_bill_pkg;
 499
 500       my $max_pay_weight =
 501         max( map  { $_->part_pkg->pay_weight || 0 }
 502              grep { $_ }
 503              map  { $_->cust_pkg }
 504                   @open_lineitems
 505            );
 506       my $max_credit_weight =
 507         max( map  { $_->part_pkg->credit_weight || 0 }
 508              grep { $_ }
 509              map  { $_->cust_pkg }
 510                   @open_lineitems
 511            );
 512
 513       #if both are the same... payments first?  it has to be something
 514       if ( $max_pay_weight >= $max_credit_weight ) {
 515         $app = 'pay';
 516       } else {
 517         $app = 'credit';
 518       }
 519
 520     } elsif ( @payments ) {
 521       $app = 'pay';
 522     } elsif ( @credits ) {
 523       $app = 'credit';
 524     } else {
 525       die "guru meditation #12 and 35";
 526     }
 527
 528     if ( $app eq 'pay' ) {
 529
 530       my $payment = shift @payments;
 531
 532       $app = new FS::cust_bill_pay {
 533         'paynum'  => $payment->paynum,
 534         'amount'  => sprintf('%.2f', min( $payment->unapplied, $self->owed ) ),
 535       };
 536
 537     } elsif ( $app eq 'credit' ) {
 538
 539       my $credit = shift @credits;
 540
 541       $app = new FS::cust_credit_bill {
 542         'crednum' => $credit->crednum,
 543         'amount'  => sprintf('%.2f', min( $credit->credited, $self->owed ) ),
 544       };
 545
 546     } else {
 547       die "guru meditation #12 and 35";
 548     }
 549
 550     $app->invnum( $self->invnum );
 551
 552     my $error = $app->insert;
 553     if ( $error ) {
 554       $dbh->rollback if $oldAutoCommit;
 555       return "Error inserting ". $app->table. " record: $error";
 556     }
 557     die $error if $error;
 558
 559   }
 560
 561   $dbh->commit or die $dbh->errstr if $oldAutoCommit;
 562   ''; #no error
 563
 564 }
 565
 566 =item generate_email OPTION => VALUE ...
 567
 568 Options:
 569
 570 =over 4
 571
 572 =item from
 573
 574 sender address, required
 575
 576 =item tempate
 577
 578 alternate template name, optional
 579
 580 =item print_text
 581
 582 text attachment arrayref, optional
 583
 584 =item subject
 585
 586 email subject, optional
 587
 588 =back
 589
 590 Returns an argument list to be passed to L<FS::Misc::send_email>.
 591
 592 =cut
 593
 594 use MIME::Entity;
 595
 596 sub generate_email {
 597
 598   my $self = shift;
 599   my %args = @_;
 600
 601   my $me = '[FS::cust_bill::generate_email]';
 602
 603   my %return = (
 604     'from'      => $args{'from'},
 605     'subject'   => (($args{'subject'}) ? $args{'subject'} : 'Invoice'),
 606   );
 607
 608   if (ref($args{'to'}) eq 'ARRAY') {
 609     $return{'to'} = $args{'to'};
 610   } else {
 611     $return{'to'} = [ grep { $_ !~ /^(POST|FAX)$/ }
 612                            $self->cust_main->invoicing_list
 613                     ];
 614   }
 615
 616   if ( $conf->exists('invoice_html') ) {
 617
 618     warn "$me creating HTML/text multipart message"
 619       if $DEBUG;
 620
 621     $return{'nobody'} = 1;
 622
 623     my $alternative = build MIME::Entity
 624       'Type'        => 'multipart/alternative',
 625       'Encoding'    => '7bit',
 626       'Disposition' => 'inline'
 627     ;
 628
 629     my $data;
 630     if ( $conf->exists('invoice_email_pdf')
 631          and scalar($conf->config('invoice_email_pdf_note')) ) {
 632
 633       warn "$me using 'invoice_email_pdf_note' in multipart message"
 634         if $DEBUG;
 635       $data = [ map { $_ . "\n" }
 636                     $conf->config('invoice_email_pdf_note')
 637               ];
 638
 639     } else {
 640
 641       warn "$me not using 'invoice_email_pdf_note' in multipart message"
 642         if $DEBUG;
 643       if ( ref($args{'print_text'}) eq 'ARRAY' ) {
 644         $data = $args{'print_text'};
 645       } else {
 646         $data = [ $self->print_text('', $args{'template'}) ];
 647       }
 648
 649     }
 650
 651     $alternative->attach(
 652       'Type'        => 'text/plain',
 653       #'Encoding'    => 'quoted-printable',
 654       'Encoding'    => '7bit',
 655       'Data'        => $data,
 656       'Disposition' => 'inline',
 657     );
 658
 659     $args{'from'} =~ /\@([\w\.\-]+)/;
 660     my $from = $1 || 'example.com';
 661     my $content_id = join('.', rand()*(2**32), $$, time). "\@$from";
 662
 663     my $logo;
 664     my $agentnum = $self->cust_main->agentnum;
 665     if ( defined($args{'template'}) && length($args{'template'})
 666          && $conf->exists( 'logo_'. $args{'template'}. '.png', $agentnum )
 667        )
 668     {
 669       $logo = 'logo_'. $args{'template'}. '.png';
 670     } else {
 671       $logo = "logo.png";
 672     }
 673     my $image_data = $conf->config_binary( $logo, $agentnum);
 674
 675     my $image = build MIME::Entity
 676       'Type'       => 'image/png',
 677       'Encoding'   => 'base64',
 678       'Data'       => $image_data,
 679       'Filename'   => 'logo.png',
 680       'Content-ID' => "<$content_id>",
 681     ;
 682
 683     $alternative->attach(
 684       'Type'        => 'text/html',
 685       'Encoding'    => 'quoted-printable',
 686       'Data'        => [ '<html>',
 687                          '  <head>',
 688                          '    <title>',
 689                          '      '. encode_entities($return{'subject'}),
 690                          '    </title>',
 691                          '  </head>',
 692                          '  <body bgcolor="#e8e8e8">',
 693                          $self->print_html('', $args{'template'}, $content_id),
 694                          '  </body>',
 695                          '</html>',
 696                        ],
 697       'Disposition' => 'inline',
 698       #'Filename'    => 'invoice.pdf',
 699     );
 700
 701     if ( $conf->exists('invoice_email_pdf') ) {
 702
 703       #attaching pdf too:
 704       # multipart/mixed
 705       #   multipart/related
 706       #     multipart/alternative
 707       #       text/plain
 708       #       text/html
 709       #     image/png
 710       #   application/pdf
 711
 712       my $related = build MIME::Entity 'Type'     => 'multipart/related',
 713                                        'Encoding' => '7bit';
 714
 715       #false laziness w/Misc::send_email
 716       $related->head->replace('Content-type',
 717         $related->mime_type.
 718         '; boundary="'. $related->head->multipart_boundary. '"'.
 719         '; type=multipart/alternative'
 720       );
 721
 722       $related->add_part($alternative);
 723
 724       $related->add_part($image);
 725
 726       my $pdf = build MIME::Entity $self->mimebuild_pdf('', $args{'template'});
 727
 728       $return{'mimeparts'} = [ $related, $pdf ];
 729
 730     } else {
 731
 732       #no other attachment:
 733       # multipart/related
 734       #   multipart/alternative
 735       #     text/plain
 736       #     text/html
 737       #   image/png
 738
 739       $return{'content-type'} = 'multipart/related';
 740       $return{'mimeparts'} = [ $alternative, $image ];
 741       $return{'type'} = 'multipart/alternative'; #Content-Type of first part...
 742       #$return{'disposition'} = 'inline';
 743
 744     }
 745
 746   } else {
 747
 748     if ( $conf->exists('invoice_email_pdf') ) {
 749       warn "$me creating PDF attachment"
 750         if $DEBUG;
 751
 752       #mime parts arguments a la MIME::Entity->build().
 753       $return{'mimeparts'} = [
 754         { $self->mimebuild_pdf('', $args{'template'}) }
 755       ];
 756     }
 757
 758     if ( $conf->exists('invoice_email_pdf')
 759          and scalar($conf->config('invoice_email_pdf_note')) ) {
 760
 761       warn "$me using 'invoice_email_pdf_note'"
 762         if $DEBUG;
 763       $return{'body'} = [ map { $_ . "\n" }
 764                               $conf->config('invoice_email_pdf_note')
 765                         ];
 766
 767     } else {
 768
 769       warn "$me not using 'invoice_email_pdf_note'"
 770         if $DEBUG;
 771       if ( ref($args{'print_text'}) eq 'ARRAY' ) {
 772         $return{'body'} = $args{'print_text'};
 773       } else {
 774         $return{'body'} = [ $self->print_text('', $args{'template'}) ];
 775       }
 776
 777     }
 778
 779   }
 780
 781   %return;
 782
 783 }
 784
 785 =item mimebuild_pdf
 786
 787 Returns a list suitable for passing to MIME::Entity->build(), representing
 788 this invoice as PDF attachment.
 789
 790 =cut
 791
 792 sub mimebuild_pdf {
 793   my $self = shift;
 794   (
 795     'Type'        => 'application/pdf',
 796     'Encoding'    => 'base64',
 797     'Data'        => [ $self->print_pdf(@_) ],
 798     'Disposition' => 'attachment',
 799     'Filename'    => 'invoice.pdf',
 800   );
 801 }
 802
 803 =item send [ TEMPLATENAME [ , AGENTNUM [ , INVOICE_FROM ] ] ]
 804
 805 Sends this invoice to the destinations configured for this customer: sends
 806 email, prints and/or faxes.  See L<FS::cust_main_invoice>.
 807
 808 TEMPLATENAME, if specified, is the name of a suffix for alternate invoices.
 809
 810 AGENTNUM, if specified, means that this invoice will only be sent for customers
 811 of the specified agent or agent(s).  AGENTNUM can be a scalar agentnum (for a
 812 single agent) or an arrayref of agentnums.
 813
 814 INVOICE_FROM, if specified, overrides the default email invoice From: address.
 815
 816 AMOUNT, if specified, only sends the invoice if the total amount owed on this
 817 invoice and all older invoices is greater than the specified amount.
 818
 819 =cut
 820
 821 sub queueable_send {
 822   my %opt = @_;
 823
 824   my $self = qsearchs('cust_bill', { 'invnum' => $opt{invnum} } )
 825     or die "invalid invoice number: " . $opt{invnum};
 826
 827   my @args = ( $opt{template}, $opt{agentnum} );
 828   push @args, $opt{invoice_from}
 829     if exists($opt{invoice_from}) && $opt{invoice_from};
 830
 831   my $error = $self->send( @args );
 832   die $error if $error;
 833
 834 }
 835
 836 sub send {
 837   my $self = shift;
 838   my $template = scalar(@_) ? shift : '';
 839   if ( scalar(@_) && $_[0]  ) {
 840     my $agentnums = ref($_[0]) ? shift : [ shift ];
 841     return 'N/A' unless grep { $_ == $self->cust_main->agentnum } @$agentnums;
 842   }
 843
 844   my $invoice_from =
 845     scalar(@_)
 846       ? shift
 847       : ( $self->_agent_invoice_from ||    #XXX should go away
 848           $conf->config('invoice_from', $self->cust_main->agentnum )
 849         );
 850
 851   my $balance_over = ( scalar(@_) && $_[0] !~ /^\s*$/ ) ? shift : 0;
 852
 853   return ''
 854     unless $self->cust_main->total_owed_date($self->_date) > $balance_over;
 855
 856   my @invoicing_list = $self->cust_main->invoicing_list;
 857
 858   #$self->email_invoice($template, $invoice_from)
 859   $self->email($template, $invoice_from)
 860     if grep { $_ !~ /^(POST|FAX)$/ } @invoicing_list or !@invoicing_list;
 861
 862   #$self->print_invoice($template)
 863   $self->print($template)
 864     if grep { $_ eq 'POST' } @invoicing_list; #postal
 865
 866   $self->fax_invoice($template)
 867     if grep { $_ eq 'FAX' } @invoicing_list; #fax
 868
 869   '';
 870
 871 }
 872
 873 =item email [ TEMPLATENAME  [ , INVOICE_FROM ] ]
 874
 875 Emails this invoice.
 876
 877 TEMPLATENAME, if specified, is the name of a suffix for alternate invoices.
 878
 879 INVOICE_FROM, if specified, overrides the default email invoice From: address.
 880
 881 =cut
 882
 883 sub queueable_email {
 884   my %opt = @_;
 885
 886   my $self = qsearchs('cust_bill', { 'invnum' => $opt{invnum} } )
 887     or die "invalid invoice number: " . $opt{invnum};
 888
 889   my @args = ( $opt{template} );
 890   push @args, $opt{invoice_from}
 891     if exists($opt{invoice_from}) && $opt{invoice_from};
 892
 893   my $error = $self->email( @args );
 894   die $error if $error;
 895
 896 }
 897
 898 #sub email_invoice {
 899 sub email {
 900   my $self = shift;
 901   my $template = scalar(@_) ? shift : '';
 902   my $invoice_from =
 903     scalar(@_)
 904       ? shift
 905       : ( $self->_agent_invoice_from ||    #XXX should go away
 906           $conf->config('invoice_from', $self->cust_main->agentnum )
 907         );
 908
 909
 910   my @invoicing_list = grep { $_ !~ /^(POST|FAX)$/ }
 911                             $self->cust_main->invoicing_list;
 912
 913   #better to notify this person than silence
 914   @invoicing_list = ($invoice_from) unless @invoicing_list;
 915
 916   my $subject = $self->email_subject($template);
 917
 918   my $error = send_email(
 919     $self->generate_email(
 920       'from'       => $invoice_from,
 921       'to'         => [ grep { $_ !~ /^(POST|FAX)$/ } @invoicing_list ],
 922       'subject'    => $subject,
 923       'template'   => $template,
 924     )
 925   );
 926   die "can't email invoice: $error\n" if $error;
 927   #die "$error\n" if $error;
 928
 929 }
 930
 931 sub email_subject {
 932   my $self = shift;
 933
 934   #my $template = scalar(@_) ? shift : '';
 935   #per-template?
 936
 937   my $subject = $conf->config('invoice_subject', $self->cust_main->agentnum)
 938                 || 'Invoice';
 939
 940   my $cust_main = $self->cust_main;
 941   my $name = $cust_main->name;
 942   my $name_short = $cust_main->name_short;
 943   my $invoice_number = $self->invnum;
 944   my $invoice_date = $self->_date_pretty;
 945
 946   eval qq("$subject");
 947 }
 948
 949 =item lpr_data [ TEMPLATENAME ]
 950
 951 Returns the postscript or plaintext for this invoice as an arrayref.
 952
 953 TEMPLATENAME, if specified, is the name of a suffix for alternate invoices.
 954
 955 =cut
 956
 957 sub lpr_data {
 958   my( $self, $template) = @_;
 959   $conf->exists('invoice_latex')
 960     ? [ $self->print_ps('', $template) ]
 961     : [ $self->print_text('', $template) ];
 962 }
 963
 964 =item print [ TEMPLATENAME ]
 965
 966 Prints this invoice.
 967
 968 TEMPLATENAME, if specified, is the name of a suffix for alternate invoices.
 969
 970 =cut
 971
 972 #sub print_invoice {
 973 sub print {
 974   my $self = shift;
 975   my $template = scalar(@_) ? shift : '';
 976
 977   do_print $self->lpr_data($template);
 978 }
 979
 980 =item fax_invoice [ TEMPLATENAME ]
 981
 982 Faxes this invoice.
 983
 984 TEMPLATENAME, if specified, is the name of a suffix for alternate invoices.
 985
 986 =cut
 987
 988 sub fax_invoice {
 989   my $self = shift;
 990   my $template = scalar(@_) ? shift : '';
 991
 992   die 'FAX invoice destination not (yet?) supported with plain text invoices.'
 993     unless $conf->exists('invoice_latex');
 994
 995   my $dialstring = $self->cust_main->getfield('fax');
 996   #Check $dialstring?
 997
 998   my $error = send_fax( 'docdata'    => $self->lpr_data($template),
 999                         'dialstring' => $dialstring,
1000                       );
1001   die $error if $error;
1002
1003 }
1004
1005 =item ftp_invoice [ TEMPLATENAME ]
1006
1007 Sends this invoice data via FTP.
1008
1009 TEMPLATENAME is unused?
1010
1011 =cut
1012
1013 sub ftp_invoice {
1014   my $self = shift;
1015   my $template = scalar(@_) ? shift : '';
1016
1017   $self->send_csv(
1018     'protocol'   => 'ftp',
1019     'server'     => $conf->config('cust_bill-ftpserver'),
1020     'username'   => $conf->config('cust_bill-ftpusername'),
1021     'password'   => $conf->config('cust_bill-ftppassword'),
1022     'dir'        => $conf->config('cust_bill-ftpdir'),
1023     'format'     => $conf->config('cust_bill-ftpformat'),
1024   );
1025 }
1026
1027 =item spool_invoice [ TEMPLATENAME ]
1028
1029 Spools this invoice data (see L<FS::spool_csv>)
1030
1031 TEMPLATENAME is unused?
1032
1033 =cut
1034
1035 sub spool_invoice {
1036   my $self = shift;
1037   my $template = scalar(@_) ? shift : '';
1038
1039   $self->spool_csv(
1040     'format'       => $conf->config('cust_bill-spoolformat'),
1041     'agent_spools' => $conf->exists('cust_bill-spoolagent'),
1042   );
1043 }
1044
1045 =item send_if_newest [ TEMPLATENAME [ , AGENTNUM [ , INVOICE_FROM ] ] ]
1046
1047 Like B<send>, but only sends the invoice if it is the newest open invoice for
1048 this customer.
1049
1050 =cut
1051
1052 sub send_if_newest {
1053   my $self = shift;
1054
1055   return ''
1056     if scalar(
1057                grep { $_->owed > 0 }
1058                     qsearch('cust_bill', {
1059                       'custnum' => $self->custnum,
1060                       #'_date'   => { op=>'>', value=>$self->_date },
1061                       'invnum'  => { op=>'>', value=>$self->invnum },
1062                     } )
1063              );
1064
1065   $self->send(@_);
1066 }
1067
1068 =item send_csv OPTION => VALUE, ...
1069
1070 Sends invoice as a CSV data-file to a remote host with the specified protocol.
1071
1072 Options are:
1073
1074 protocol - currently only "ftp"
1075 server
1076 username
1077 password
1078 dir
1079
1080 The file will be named "N-YYYYMMDDHHMMSS.csv" where N is the invoice number
1081 and YYMMDDHHMMSS is a timestamp.
1082
1083 See L</print_csv> for a description of the output format.
1084
1085 =cut
1086
1087 sub send_csv {
1088   my($self, %opt) = @_;
1089
1090   #create file(s)
1091
1092   my $spooldir = "/usr/local/etc/freeside/export.". datasrc. "/cust_bill";
1093   mkdir $spooldir, 0700 unless -d $spooldir;
1094
1095   my $tracctnum = $self->invnum. time2str('-%Y%m%d%H%M%S', time);
1096   my $file = "$spooldir/$tracctnum.csv";
1097
1098   my ( $header, $detail ) = $self->print_csv(%opt, 'tracctnum' => $tracctnum );
1099
1100   open(CSV, ">$file") or die "can't open $file: $!";
1101   print CSV $header;
1102
1103   print CSV $detail;
1104
1105   close CSV;
1106
1107   my $net;
1108   if ( $opt{protocol} eq 'ftp' ) {
1109     eval "use Net::FTP;";
1110     die $@ if $@;
1111     $net = Net::FTP->new($opt{server}) or die @$;
1112   } else {
1113     die "unknown protocol: $opt{protocol}";
1114   }
1115
1116   $net->login( $opt{username}, $opt{password} )
1117     or die "can't FTP to $opt{username}\@$opt{server}: login error: $@";
1118
1119   $net->binary or die "can't set binary mode";
1120
1121   $net->cwd($opt{dir}) or die "can't cwd to $opt{dir}";
1122
1123   $net->put($file) or die "can't put $file: $!";
1124
1125   $net->quit;
1126
1127   unlink $file;
1128
1129 }
1130
1131 =item spool_csv
1132
1133 Spools CSV invoice data.
1134
1135 Options are:
1136
1137 =over 4
1138
1139 =item format - 'default' or 'billco'
1140
1141 =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>).
1142
1143 =item agent_spools - if set to a true value, will spool to per-agent files rather than a single global file
1144
1145 =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.
1146
1147 =back
1148
1149 =cut
1150
1151 sub spool_csv {
1152   my($self, %opt) = @_;
1153
1154   my $cust_main = $self->cust_main;
1155
1156   if ( $opt{'dest'} ) {
1157     my %invoicing_list = map { /^(POST|FAX)$/ or 'EMAIL' =~ /^(.*)$/; $1 => 1 }
1158                              $cust_main->invoicing_list;
1159     return 'N/A' unless $invoicing_list{$opt{'dest'}}
1160                      || ! keys %invoicing_list;
1161   }
1162
1163   if ( $opt{'balanceover'} ) {
1164     return 'N/A'
1165       if $cust_main->total_owed_date($self->_date) < $opt{'balanceover'};
1166   }
1167
1168   my $spooldir = "/usr/local/etc/freeside/export.". datasrc. "/cust_bill";
1169   mkdir $spooldir, 0700 unless -d $spooldir;
1170
1171   my $tracctnum = $self->invnum. time2str('-%Y%m%d%H%M%S', time);
1172
1173   my $file =
1174     "$spooldir/".
1175     ( $opt{'agent_spools'} ? 'agentnum'.$cust_main->agentnum : 'spool' ).
1176     ( lc($opt{'format'}) eq 'billco' ? '-header' : '' ) .
1177     '.csv';
1178
1179   my ( $header, $detail ) = $self->print_csv(%opt, 'tracctnum' => $tracctnum );
1180
1181   open(CSV, ">>$file") or die "can't open $file: $!";
1182   flock(CSV, LOCK_EX);
1183   seek(CSV, 0, 2);
1184
1185   print CSV $header;
1186
1187   if ( lc($opt{'format'}) eq 'billco' ) {
1188
1189     flock(CSV, LOCK_UN);
1190     close CSV;
1191
1192     $file =
1193       "$spooldir/".
1194       ( $opt{'agent_spools'} ? 'agentnum'.$cust_main->agentnum : 'spool' ).
1195       '-detail.csv';
1196
1197     open(CSV,">>$file") or die "can't open $file: $!";
1198     flock(CSV, LOCK_EX);
1199     seek(CSV, 0, 2);
1200   }
1201
1202   print CSV $detail;
1203
1204   flock(CSV, LOCK_UN);
1205   close CSV;
1206
1207   return '';
1208
1209 }
1210
1211 =item print_csv OPTION => VALUE, ...
1212
1213 Returns CSV data for this invoice.
1214
1215 Options are:
1216
1217 format - 'default' or 'billco'
1218
1219 Returns a list consisting of two scalars.  The first is a single line of CSV
1220 header information for this invoice.  The second is one or more lines of CSV
1221 detail information for this invoice.
1222
1223 If I<format> is not specified or "default", the fields of the CSV file are as
1224 follows:
1225
1226 record_type, invnum, custnum, _date, charged, first, last, company, address1, address2, city, state, zip, country, pkg, setup, recur, sdate, edate
1227
1228 =over 4
1229
1230 =item record type - B<record_type> is either C<cust_bill> or C<cust_bill_pkg>
1231
1232 B<record_type> is C<cust_bill> for the initial header line only.  The
1233 last five fields (B<pkg> through B<edate>) are irrelevant, and all other
1234 fields are filled in.
1235
1236 B<record_type> is C<cust_bill_pkg> for detail lines.  Only the first two fields
1237 (B<record_type> and B<invnum>) and the last five fields (B<pkg> through B<edate>)
1238 are filled in.
1239
1240 =item invnum - invoice number
1241
1242 =item custnum - customer number
1243
1244 =item _date - invoice date
1245
1246 =item charged - total invoice amount
1247
1248 =item first - customer first name
1249
1250 =item last - customer first name
1251
1252 =item company - company name
1253
1254 =item address1 - address line 1
1255
1256 =item address2 - address line 1
1257
1258 =item city
1259
1260 =item state
1261
1262 =item zip
1263
1264 =item country
1265
1266 =item pkg - line item description
1267
1268 =item setup - line item setup fee (one or both of B<setup> and B<recur> will be defined)
1269
1270 =item recur - line item recurring fee (one or both of B<setup> and B<recur> will be defined)
1271
1272 =item sdate - start date for recurring fee
1273
1274 =item edate - end date for recurring fee
1275
1276 =back
1277
1278 If I<format> is "billco", the fields of the header CSV file are as follows:
1279
1280   +-------------------------------------------------------------------+
1281   |                        FORMAT HEADER FILE                         |
1282   |-------------------------------------------------------------------|
1283   | Field | Description                   | Name       | Type | Width |
1284   | 1     | N/A-Leave Empty               | RC         | CHAR |     2 |
1285   | 2     | N/A-Leave Empty               | CUSTID     | CHAR |    15 |
1286   | 3     | Transaction Account No        | TRACCTNUM  | CHAR |    15 |
1287   | 4     | Transaction Invoice No        | TRINVOICE  | CHAR |    15 |
1288   | 5     | Transaction Zip Code          | TRZIP      | CHAR |     5 |
1289   | 6     | Transaction Company Bill To   | TRCOMPANY  | CHAR |    30 |
1290   | 7     | Transaction Contact Bill To   | TRNAME     | CHAR |    30 |
1291   | 8     | Additional Address Unit Info  | TRADDR1    | CHAR |    30 |
1292   | 9     | Bill To Street Address        | TRADDR2    | CHAR |    30 |
1293   | 10    | Ancillary Billing Information | TRADDR3    | CHAR |    30 |
1294   | 11    | Transaction City Bill To      | TRCITY     | CHAR |    20 |
1295   | 12    | Transaction State Bill To     | TRSTATE    | CHAR |     2 |
1296   | 13    | Bill Cycle Close Date         | CLOSEDATE  | CHAR |    10 |
1297   | 14    | Bill Due Date                 | DUEDATE    | CHAR |    10 |
1298   | 15    | Previous Balance              | BALFWD     | NUM* |     9 |
1299   | 16    | Pmt/CR Applied                | CREDAPPLY  | NUM* |     9 |
1300   | 17    | Total Current Charges         | CURRENTCHG | NUM* |     9 |
1301   | 18    | Total Amt Due                 | TOTALDUE   | NUM* |     9 |
1302   | 19    | Total Amt Due                 | AMTDUE     | NUM* |     9 |
1303   | 20    | 30 Day Aging                  | AMT30      | NUM* |     9 |
1304   | 21    | 60 Day Aging                  | AMT60      | NUM* |     9 |
1305   | 22    | 90 Day Aging                  | AMT90      | NUM* |     9 |
1306   | 23    | Y/N                           | AGESWITCH  | CHAR |     1 |
1307   | 24    | Remittance automation         | SCANLINE   | CHAR |   100 |
1308   | 25    | Total Taxes & Fees            | TAXTOT     | NUM* |     9 |
1309   | 26    | Customer Reference Number     | CUSTREF    | CHAR |    15 |
1310   | 27    | Federal Tax***                | FEDTAX     | NUM* |     9 |
1311   | 28    | State Tax***                  | STATETAX   | NUM* |     9 |
1312   | 29    | Other Taxes & Fees***         | OTHERTAX   | NUM* |     9 |
1313   +-------+-------------------------------+------------+------+-------+
1314
1315 If I<format> is "billco", the fields of the detail CSV file are as follows:
1316
1317                                   FORMAT FOR DETAIL FILE
1318         |                            |           |      |
1319   Field | Description                | Name      | Type | Width
1320   1     | N/A-Leave Empty            | RC        | CHAR |     2
1321   2     | N/A-Leave Empty            | CUSTID    | CHAR |    15
1322   3     | Account Number             | TRACCTNUM | CHAR |    15
1323   4     | Invoice Number             | TRINVOICE | CHAR |    15
1324   5     | Line Sequence (sort order) | LINESEQ   | NUM  |     6
1325   6     | Transaction Detail         | DETAILS   | CHAR |   100
1326   7     | Amount                     | AMT       | NUM* |     9
1327   8     | Line Format Control**      | LNCTRL    | CHAR |     2
1328   9     | Grouping Code              | GROUP     | CHAR |     2
1329   10    | User Defined               | ACCT CODE | CHAR |    15
1330
1331 =cut
1332
1333 sub print_csv {
1334   my($self, %opt) = @_;
1335
1336   eval "use Text::CSV_XS";
1337   die $@ if $@;
1338
1339   my $cust_main = $self->cust_main;
1340
1341   my $csv = Text::CSV_XS->new({'always_quote'=>1});
1342
1343   if ( lc($opt{'format'}) eq 'billco' ) {
1344
1345     my $taxtotal = 0;
1346     $taxtotal += $_->{'amount'} foreach $self->_items_tax;
1347
1348     my $duedate = $self->due_date2str('%m/%d/%Y'); #date_format?
1349
1350     my( $previous_balance, @unused ) = $self->previous; #previous balance
1351
1352     my $pmt_cr_applied = 0;
1353     $pmt_cr_applied += $_->{'amount'}
1354       foreach ( $self->_items_payments, $self->_items_credits ) ;
1355
1356     my $totaldue = sprintf('%.2f', $self->owed + $previous_balance);
1357
1358     $csv->combine(
1359       '',                         #  1 | N/A-Leave Empty               CHAR   2
1360       '',                         #  2 | N/A-Leave Empty               CHAR  15
1361       $opt{'tracctnum'},          #  3 | Transaction Account No        CHAR  15
1362       $self->invnum,              #  4 | Transaction Invoice No        CHAR  15
1363       $cust_main->zip,            #  5 | Transaction Zip Code          CHAR   5
1364       $cust_main->company,        #  6 | Transaction Company Bill To   CHAR  30
1365       #$cust_main->payname,        #  7 | Transaction Contact Bill To   CHAR  30
1366       $cust_main->contact,        #  7 | Transaction Contact Bill To   CHAR  30
1367       $cust_main->address2,       #  8 | Additional Address Unit Info  CHAR  30
1368       $cust_main->address1,       #  9 | Bill To Street Address        CHAR  30
1369       '',                         # 10 | Ancillary Billing Information CHAR  30
1370       $cust_main->city,           # 11 | Transaction City Bill To      CHAR  20
1371       $cust_main->state,          # 12 | Transaction State Bill To     CHAR   2
1372
1373       # XXX ?
1374       time2str("%m/%d/%Y", $self->_date), # 13 | Bill Cycle Close Date CHAR  10
1375
1376       # XXX ?
1377       $duedate,                   # 14 | Bill Due Date                 CHAR  10
1378
1379       $previous_balance,          # 15 | Previous Balance              NUM*   9
1380       $pmt_cr_applied,            # 16 | Pmt/CR Applied                NUM*   9
1381       sprintf("%.2f", $self->charged), # 17 | Total Current Charges    NUM*   9
1382       $totaldue,                  # 18 | Total Amt Due                 NUM*   9
1383       $totaldue,                  # 19 | Total Amt Due                 NUM*   9
1384       '',                         # 20 | 30 Day Aging                  NUM*   9
1385       '',                         # 21 | 60 Day Aging                  NUM*   9
1386       '',                         # 22 | 90 Day Aging                  NUM*   9
1387       'N',                        # 23 | Y/N                           CHAR   1
1388       '',                         # 24 | Remittance automation         CHAR 100
1389       $taxtotal,                  # 25 | Total Taxes & Fees            NUM*   9
1390       $self->custnum,             # 26 | Customer Reference Number     CHAR  15
1391       '0',                        # 27 | Federal Tax***                NUM*   9
1392       sprintf("%.2f", $taxtotal), # 28 | State Tax***                  NUM*   9
1393       '0',                        # 29 | Other Taxes & Fees***         NUM*   9
1394     );
1395
1396   } else {
1397
1398     $csv->combine(
1399       'cust_bill',
1400       $self->invnum,
1401       $self->custnum,
1402       time2str("%x", $self->_date),
1403       sprintf("%.2f", $self->charged),
1404       ( map { $cust_main->getfield($_) }
1405           qw( first last company address1 address2 city state zip country ) ),
1406       map { '' } (1..5),
1407     ) or die "can't create csv";
1408   }
1409
1410   my $header = $csv->string. "\n";
1411
1412   my $detail = '';
1413   if ( lc($opt{'format'}) eq 'billco' ) {
1414
1415     my $lineseq = 0;
1416     foreach my $item ( $self->_items_pkg ) {
1417
1418       $csv->combine(
1419         '',                     #  1 | N/A-Leave Empty            CHAR   2
1420         '',                     #  2 | N/A-Leave Empty            CHAR  15
1421         $opt{'tracctnum'},      #  3 | Account Number             CHAR  15
1422         $self->invnum,          #  4 | Invoice Number             CHAR  15
1423         $lineseq++,             #  5 | Line Sequence (sort order) NUM    6
1424         $item->{'description'}, #  6 | Transaction Detail         CHAR 100
1425         $item->{'amount'},      #  7 | Amount                     NUM*   9
1426         '',                     #  8 | Line Format Control**      CHAR   2
1427         '',                     #  9 | Grouping Code              CHAR   2
1428         '',                     # 10 | User Defined               CHAR  15
1429       );
1430
1431       $detail .= $csv->string. "\n";
1432
1433     }
1434
1435   } else {
1436
1437     foreach my $cust_bill_pkg ( $self->cust_bill_pkg ) {
1438
1439       my($pkg, $setup, $recur, $sdate, $edate);
1440       if ( $cust_bill_pkg->pkgnum ) {
1441
1442         ($pkg, $setup, $recur, $sdate, $edate) = (
1443           $cust_bill_pkg->part_pkg->pkg,
1444           ( $cust_bill_pkg->setup != 0
1445             ? sprintf("%.2f", $cust_bill_pkg->setup )
1446             : '' ),
1447           ( $cust_bill_pkg->recur != 0
1448             ? sprintf("%.2f", $cust_bill_pkg->recur )
1449             : '' ),
1450           ( $cust_bill_pkg->sdate
1451             ? time2str("%x", $cust_bill_pkg->sdate)
1452             : '' ),
1453           ($cust_bill_pkg->edate
1454             ?time2str("%x", $cust_bill_pkg->edate)
1455             : '' ),
1456         );
1457
1458       } else { #pkgnum tax
1459         next unless $cust_bill_pkg->setup != 0;
1460         my $itemdesc = defined $cust_bill_pkg->dbdef_table->column('itemdesc')
1461                          ? ( $cust_bill_pkg->itemdesc || 'Tax' )
1462                          : 'Tax';
1463         ($pkg, $setup, $recur, $sdate, $edate) =
1464           ( $itemdesc, sprintf("%10.2f",$cust_bill_pkg->setup), '', '', '' );
1465       }
1466
1467       $csv->combine(
1468         'cust_bill_pkg',
1469         $self->invnum,
1470         ( map { '' } (1..11) ),
1471         ($pkg, $setup, $recur, $sdate, $edate)
1472       ) or die "can't create csv";
1473
1474       $detail .= $csv->string. "\n";
1475
1476     }
1477
1478   }
1479
1480   ( $header, $detail );
1481
1482 }
1483
1484 =item comp
1485
1486 Pays this invoice with a compliemntary payment.  If there is an error,
1487 returns the error, otherwise returns false.
1488
1489 =cut
1490
1491 sub comp {
1492   my $self = shift;
1493   my $cust_pay = new FS::cust_pay ( {
1494     'invnum'   => $self->invnum,
1495     'paid'     => $self->owed,
1496     '_date'    => '',
1497     'payby'    => 'COMP',
1498     'payinfo'  => $self->cust_main->payinfo,
1499     'paybatch' => '',
1500   } );
1501   $cust_pay->insert;
1502 }
1503
1504 =item realtime_card
1505
1506 Attempts to pay this invoice with a credit card payment via a
1507 Business::OnlinePayment realtime gateway.  See
1508 http://search.cpan.org/search?mode=module&query=Business%3A%3AOnlinePayment
1509 for supported processors.
1510
1511 =cut
1512
1513 sub realtime_card {
1514   my $self = shift;
1515   $self->realtime_bop( 'CC', @_ );
1516 }
1517
1518 =item realtime_ach
1519
1520 Attempts to pay this invoice with an electronic check (ACH) payment via a
1521 Business::OnlinePayment realtime gateway.  See
1522 http://search.cpan.org/search?mode=module&query=Business%3A%3AOnlinePayment
1523 for supported processors.
1524
1525 =cut
1526
1527 sub realtime_ach {
1528   my $self = shift;
1529   $self->realtime_bop( 'ECHECK', @_ );
1530 }
1531
1532 =item realtime_lec
1533
1534 Attempts to pay this invoice with phone bill (LEC) payment via a
1535 Business::OnlinePayment realtime gateway.  See
1536 http://search.cpan.org/search?mode=module&query=Business%3A%3AOnlinePayment
1537 for supported processors.
1538
1539 =cut
1540
1541 sub realtime_lec {
1542   my $self = shift;
1543   $self->realtime_bop( 'LEC', @_ );
1544 }
1545
1546 sub realtime_bop {
1547   my( $self, $method ) = @_;
1548
1549   my $cust_main = $self->cust_main;
1550   my $balance = $cust_main->balance;
1551   my $amount = ( $balance < $self->owed ) ? $balance : $self->owed;
1552   $amount = sprintf("%.2f", $amount);
1553   return "not run (balance $balance)" unless $amount > 0;
1554
1555   my $description = 'Internet Services';
1556   if ( $conf->exists('business-onlinepayment-description') ) {
1557     my $dtempl = $conf->config('business-onlinepayment-description');
1558
1559     my $agent_obj = $cust_main->agent
1560       or die "can't retreive agent for $cust_main (agentnum ".
1561              $cust_main->agentnum. ")";
1562     my $agent = $agent_obj->agent;
1563     my $pkgs = join(', ',
1564       map { $_->part_pkg->pkg }
1565         grep { $_->pkgnum } $self->cust_bill_pkg
1566     );
1567     $description = eval qq("$dtempl");
1568   }
1569
1570   $cust_main->realtime_bop($method, $amount,
1571     'description' => $description,
1572     'invnum'      => $self->invnum,
1573   );
1574
1575 }
1576
1577 =item batch_card OPTION => VALUE...
1578
1579 Adds a payment for this invoice to the pending credit card batch (see
1580 L<FS::cust_pay_batch>), or, if the B<realtime> option is set to a true value,
1581 runs the payment using a realtime gateway.
1582
1583 =cut
1584
1585 sub batch_card {
1586   my ($self, %options) = @_;
1587   my $cust_main = $self->cust_main;
1588
1589   $options{invnum} = $self->invnum;
1590
1591   $cust_main->batch_card(%options);
1592 }
1593
1594 sub _agent_template {
1595   my $self = shift;
1596   $self->cust_main->agent_template;
1597 }
1598
1599 sub _agent_invoice_from {
1600   my $self = shift;
1601   $self->cust_main->agent_invoice_from;
1602 }
1603
1604 =item print_text [ TIME [ , TEMPLATE ] ]
1605
1606 Returns an text invoice, as a list of lines.
1607
1608 TIME an optional value used to control the printing of overdue messages.  The
1609 default is now.  It isn't the date of the invoice; that's the `_date' field.
1610 It is specified as a UNIX timestamp; see L<perlfunc/"time">.  Also see
1611 L<Time::Local> and L<Date::Parse> for conversion functions.
1612
1613 =cut
1614
1615 sub print_text {
1616   my( $self, $today, $template ) = @_;
1617
1618   my %params = ( 'format' => 'template' );
1619   $params{'time'} = $today if $today;
1620   $params{'template'} = $template if $template;
1621
1622   $self->print_generic( %params );
1623 }
1624
1625 =item print_latex [ TIME [ , TEMPLATE ] ]
1626
1627 Internal method - returns a filename of a filled-in LaTeX template for this
1628 invoice (Note: add ".tex" to get the actual filename), and a filename of
1629 an associated logo (with the .eps extension included).
1630
1631 See print_ps and print_pdf for methods that return PostScript and PDF output.
1632
1633 TIME an optional value used to control the printing of overdue messages.  The
1634 default is now.  It isn't the date of the invoice; that's the `_date' field.
1635 It is specified as a UNIX timestamp; see L<perlfunc/"time">.  Also see
1636 L<Time::Local> and L<Date::Parse> for conversion functions.
1637
1638 =cut
1639
1640 sub print_latex {
1641   my( $self, $today, $template ) = @_;
1642
1643   my %params = ( 'format' => 'latex' );
1644   $params{'time'} = $today if $today;
1645   $params{'template'} = $template if $template;
1646
1647   $template ||= $self->_agent_template;
1648
1649   my $dir = $FS::UID::conf_dir. "/cache.". $FS::UID::datasrc;
1650   my $lh = new File::Temp( TEMPLATE => 'invoice.'. $self->invnum. '.XXXXXXXX',
1651                            DIR      => $dir,
1652                            SUFFIX   => '.eps',
1653                            UNLINK   => 0,
1654                          ) or die "can't open temp file: $!\n";
1655
1656   my $agentnum = $self->cust_main->agentnum;
1657
1658   if ( $template && $conf->exists("logo_${template}.eps", $agentnum) ) {
1659     print $lh $conf->config_binary("logo_${template}.eps", $agentnum)
1660       or die "can't write temp file: $!\n";
1661   } else {
1662     print $lh $conf->config_binary('logo.eps', $agentnum)
1663       or die "can't write temp file: $!\n";
1664   }
1665   close $lh;
1666   $params{'logo_file'} = $lh->filename;
1667
1668   my @filled_in = $self->print_generic( %params );
1669
1670   my $fh = new File::Temp( TEMPLATE => 'invoice.'. $self->invnum. '.XXXXXXXX',
1671                            DIR      => $dir,
1672                            SUFFIX   => '.tex',
1673                            UNLINK   => 0,
1674                          ) or die "can't open temp file: $!\n";
1675   print $fh join('', @filled_in );
1676   close $fh;
1677
1678   $fh->filename =~ /^(.*).tex$/ or die "unparsable filename: ". $fh->filename;
1679   return ($1, $params{'logo_file'});
1680
1681 }
1682
1683 =item print_generic OPTIONS_HASH
1684
1685 Internal method - returns a filled-in template for this invoice as a scalar.
1686
1687 See print_ps and print_pdf for methods that return PostScript and PDF output.
1688
1689 Non optional options include
1690   format - latex, html, template
1691
1692 Optional options include
1693
1694 template - a value used as a suffix for a configuration template
1695
1696 time - a value used to control the printing of overdue messages.  The
1697 default is now.  It isn't the date of the invoice; that's the `_date' field.
1698 It is specified as a UNIX timestamp; see L<perlfunc/"time">.  Also see
1699 L<Time::Local> and L<Date::Parse> for conversion functions.
1700
1701 cid -
1702
1703 unsquelch_cdr - overrides any per customer cdr squelching when true
1704
1705 =cut
1706
1707 #what's with all the sprintf('%10.2f')'s in here?  will it cause any
1708 # (alignment?) problems to change them all to '%.2f' ?
1709 sub print_generic {
1710
1711   my( $self, %params ) = @_;
1712   my $today = $params{today} ? $params{today} : time;
1713   warn "FS::cust_bill::print_generic called on $self with suffix $params{template}\n"
1714     if $DEBUG;
1715
1716   my $format = $params{format};
1717   die "Unknown format: $format"
1718     unless $format =~ /^(latex|html|template)$/;
1719
1720   my $cust_main = $self->cust_main;
1721   $cust_main->payname( $cust_main->first. ' '. $cust_main->getfield('last') )
1722     unless $cust_main->payname
1723         && $cust_main->payby !~ /^(CARD|DCRD|CHEK|DCHK)$/;
1724
1725   my %delimiters = ( 'latex'    => [ '[@--', '--@]' ],
1726                      'html'     => [ '<%=', '%>' ],
1727                      'template' => [ '{', '}' ],
1728                    );
1729
1730   #create the template
1731   my $template = $params{template} ? $params{template} : $self->_agent_template;
1732   my $templatefile = "invoice_$format";
1733   $templatefile .= "_$template"
1734     if length($template);
1735   my @invoice_template = map "$_\n", $conf->config($templatefile)
1736     or die "cannot load config data $templatefile";
1737
1738   my $old_latex = '';
1739   if ( $format eq 'latex' && grep { /^%%Detail/ } @invoice_template ) {
1740     #change this to a die when the old code is removed
1741     warn "old-style invoice template $templatefile; ".
1742          "patch with conf/invoice_latex.diff or use new conf/invoice_latex*\n";
1743     $old_latex = 'true';
1744     @invoice_template = _translate_old_latex_format(@invoice_template);
1745   }
1746
1747   my $text_template = new Text::Template(
1748     TYPE => 'ARRAY',
1749     SOURCE => \@invoice_template,
1750     DELIMITERS => $delimiters{$format},
1751   );
1752
1753   $text_template->compile()
1754     or die "Can't compile $templatefile: $Text::Template::ERROR\n";
1755
1756
1757   # additional substitution could possibly cause breakage in existing templates
1758   my %convert_maps = (
1759     'latex' => {
1760                  'notes'         => sub { map "$_", @_ },
1761                  'footer'        => sub { map "$_", @_ },
1762                  'smallfooter'   => sub { map "$_", @_ },
1763                  'returnaddress' => sub { map "$_", @_ },
1764                  'coupon'        => sub { map "$_", @_ },
1765                },
1766     'html'  => {
1767                  'notes' =>
1768                    sub {
1769                      map {
1770                        s/%%(.*)$/<!-- $1 -->/g;
1771                        s/\\section\*\{\\textsc\{(.)(.*)\}\}/<p><b><font size="+1">$1<\/font>\U$2<\/b>/g;
1772                        s/\\begin\{enumerate\}/<ol>/g;
1773                        s/\\item /  <li>/g;
1774                        s/\\end\{enumerate\}/<\/ol>/g;
1775                        s/\\textbf\{(.*)\}/<b>$1<\/b>/g;
1776                        s/\\\\\*/<br>/g;
1777                        s/\\dollar ?/\$/g;
1778                        s/\\#/#/g;
1779                        s/~/&nbsp;/g;
1780                        $_;
1781                      }  @_
1782                    },
1783                  'footer' =>
1784                    sub { map { s/~/&nbsp;/g; s/\\\\\*?\s*$/<BR>/; $_; } @_ },
1785                  'smallfooter' =>
1786                    sub { map { s/~/&nbsp;/g; s/\\\\\*?\s*$/<BR>/; $_; } @_ },
1787                  'returnaddress' =>
1788                    sub {
1789                      map {
1790                        s/~/&nbsp;/g;
1791                        s/\\\\\*?\s*$/<BR>/;
1792                        s/\\hyphenation\{[\w\s\-]+}//;
1793                        s/\\([&])/$1/g;
1794                        $_;
1795                      }  @_
1796                    },
1797                  'coupon'        => sub { "" },
1798                },
1799     'template' => {
1800                  'notes' =>
1801                    sub {
1802                      map {
1803                        s/%%.*$//g;
1804                        s/\\section\*\{\\textsc\{(.*)\}\}/\U$1/g;
1805                        s/\\begin\{enumerate\}//g;
1806                        s/\\item /  * /g;
1807                        s/\\end\{enumerate\}//g;
1808                        s/\\textbf\{(.*)\}/$1/g;
1809                        s/\\\\\*/ /;
1810                        s/\\dollar ?/\$/g;
1811                        $_;
1812                      }  @_
1813                    },
1814                  'footer' =>
1815                    sub { map { s/~/ /g; s/\\\\\*?\s*$/\n/; $_; } @_ },
1816                  'smallfooter' =>
1817                    sub { map { s/~/ /g; s/\\\\\*?\s*$/\n/; $_; } @_ },
1818                  'returnaddress' =>
1819                    sub {
1820                      map {
1821                        s/~/ /g;
1822                        s/\\\\\*?\s*$/\n/;             # dubious
1823                        s/\\hyphenation\{[\w\s\-]+}//;
1824                        $_;
1825                      }  @_
1826                    },
1827                  'coupon'        => sub { "" },
1828                },
1829   );
1830
1831
1832   # hashes for differing output formats
1833   my %nbsps = ( 'latex'    => '~',
1834                 'html'     => '',    # '&nbps;' would be nice
1835                 'template' => '',    # not used
1836               );
1837   my $nbsp = $nbsps{$format};
1838
1839   my %escape_functions = ( 'latex'    => \&_latex_escape,
1840                            'html'     => \&encode_entities,
1841                            'template' => sub { shift },
1842                          );
1843   my $escape_function = $escape_functions{$format};
1844
1845   my %date_formats = ( 'latex'    => '%b %o, %Y',
1846                        'html'     => '%b&nbsp;%o,&nbsp;%Y',
1847                        'template' => '%s',
1848                      );
1849   my $date_format = $date_formats{$format};
1850
1851   my %embolden_functions = ( 'latex'    => sub { return '\textbf{'. shift(). '}'
1852                                                },
1853                              'html'     => sub { return '<b>'. shift(). '</b>'
1854                                                },
1855                              'template' => sub { shift },
1856                            );
1857   my $embolden_function = $embolden_functions{$format};
1858
1859
1860   # generate template variables
1861   my $returnaddress;
1862   if (
1863          defined( $conf->config_orbase( "invoice_${format}returnaddress",
1864                                         $template
1865                                       )
1866                 )
1867        && length( $conf->config_orbase( "invoice_${format}returnaddress",
1868                                         $template
1869                                       )
1870                 )
1871   ) {
1872
1873     $returnaddress = join("\n",
1874       $conf->config_orbase("invoice_${format}returnaddress", $template)
1875     );
1876
1877   } elsif ( grep /\S/,
1878             $conf->config_orbase('invoice_latexreturnaddress', $template) ) {
1879
1880     my $convert_map = $convert_maps{$format}{'returnaddress'};
1881     $returnaddress =
1882       join( "\n",
1883             &$convert_map( $conf->config_orbase( "invoice_latexreturnaddress",
1884                                                  $template
1885                                                )
1886                          )
1887           );
1888   } elsif ( grep /\S/, $conf->config('company_address', $self->cust_main->agentnum) ) {
1889
1890     my $convert_map = $convert_maps{$format}{'returnaddress'};
1891     $returnaddress = join( "\n", &$convert_map(
1892                                    map { s/( {2,})/'~' x length($1)/eg;
1893                                          s/$/\\\\\*/;
1894                                          $_
1895                                        }
1896                                      ( $conf->config('company_name', $self->cust_main->agentnum),
1897                                        $conf->config('company_address', $self->cust_main->agentnum),
1898                                      )
1899                                  )
1900                      );
1901
1902   } else {
1903
1904     my $warning = "Couldn't find a return address; ".
1905                   "do you need to set the company_address configuration value?";
1906     warn "$warning\n";
1907     $returnaddress = $nbsp;
1908     #$returnaddress = $warning;
1909
1910   }
1911
1912   my %invoice_data = (
1913     'company_name'    => scalar( $conf->config('company_name', $self->cust_main->agentnum) ),
1914     'company_address' => join("\n", $conf->config('company_address', $self->cust_main->agentnum) ). "\n",
1915     'custnum'         => $cust_main->display_custnum,
1916     'invnum'          => $self->invnum,
1917     'date'            => time2str($date_format, $self->_date),
1918     'today'           => time2str('%b %o, %Y', $today),
1919     'agent'           => &$escape_function($cust_main->agent->agent),
1920     'agent_custid'    => &$escape_function($cust_main->agent_custid),
1921     'payname'         => &$escape_function($cust_main->payname),
1922     'company'         => &$escape_function($cust_main->company),
1923     'address1'        => &$escape_function($cust_main->address1),
1924     'address2'        => &$escape_function($cust_main->address2),
1925     'city'            => &$escape_function($cust_main->city),
1926     'state'           => &$escape_function($cust_main->state),
1927     'zip'             => &$escape_function($cust_main->zip),
1928     'fax'             => &$escape_function($cust_main->fax),
1929     'returnaddress'   => $returnaddress,
1930     #'quantity'        => 1,
1931     'terms'           => $self->terms,
1932     'template'        => $template, #params{'template'},
1933     #'notes'           => join("\n", $conf->config('invoice_latexnotes') ),
1934     # better hang on to conf_dir for a while
1935     'conf_dir'        => "$FS::UID::conf_dir/conf.$FS::UID::datasrc",
1936     'page'            => 1,
1937     'total_pages'     => 1,
1938     'current_charges' => sprintf("%.2f", $self->charged),
1939     'duedate'         => $self->due_date2str('%m/%d/%Y'), #date_format?
1940     'ship_enable'     => $conf->exists('invoice-ship_address'),
1941     'unitprices'      => $conf->exists('invoice-unitprice'),
1942   );
1943
1944   my $countrydefault = $conf->config('countrydefault') || 'US';
1945   my $prefix = $cust_main->has_ship_address ? 'ship_' : '';
1946   foreach ( qw( contact company address1 address2 city state zip country fax) ){
1947     my $method = $prefix.$_;
1948     $invoice_data{"ship_$_"} = _latex_escape($cust_main->$method);
1949   }
1950   $invoice_data{'ship_country'} = ''
1951     if ( $invoice_data{'ship_country'} eq $countrydefault );
1952
1953   $invoice_data{'cid'} = $params{'cid'}
1954     if $params{'cid'};
1955
1956   if ( $cust_main->country eq $countrydefault ) {
1957     $invoice_data{'country'} = '';
1958   } else {
1959     $invoice_data{'country'} = &$escape_function(code2country($cust_main->country));
1960   }
1961
1962   my @address = ();
1963   $invoice_data{'address'} = \@address;
1964   push @address,
1965     $cust_main->payname.
1966       ( ( $cust_main->payby eq 'BILL' ) && $cust_main->payinfo
1967         ? " (P.O. #". $cust_main->payinfo. ")"
1968         : ''
1969       )
1970   ;
1971   push @address, $cust_main->company
1972     if $cust_main->company;
1973   push @address, $cust_main->address1;
1974   push @address, $cust_main->address2
1975     if $cust_main->address2;
1976   push @address,
1977     $cust_main->city. ", ". $cust_main->state. "  ".  $cust_main->zip;
1978   push @address, $invoice_data{'country'}
1979     if $invoice_data{'country'};
1980   push @address, ''
1981     while (scalar(@address) < 5);
1982
1983   $invoice_data{'logo_file'} = $params{'logo_file'}
1984     if $params{'logo_file'};
1985
1986   my( $pr_total, @pr_cust_bill ) = $self->previous; #previous balance
1987 #  my( $cr_total, @cr_cust_credit ) = $self->cust_credit; #credits
1988   #my $balance_due = $self->owed + $pr_total - $cr_total;
1989   my $balance_due = $self->owed + $pr_total;
1990   $invoice_data{'previous_balance'} = sprintf("%.2f", $pr_total);
1991   $invoice_data{'balance'} = sprintf("%.2f", $balance_due);
1992
1993   my $agentnum = $self->cust_main->agentnum;
1994
1995   #do variable substitution in notes, footer, smallfooter
1996   foreach my $include (qw( notes footer smallfooter coupon )) {
1997
1998     my $inc_file = $conf->key_orbase("invoice_${format}$include", $template);
1999     my @inc_src;
2000
2001     if ( $conf->exists($inc_file, $agentnum)
2002          && length( $conf->config($inc_file, $agentnum) ) ) {
2003
2004       @inc_src = $conf->config($inc_file, $agentnum);
2005
2006     } else {
2007
2008       $inc_file = $conf->key_orbase("invoice_latex$include", $template);
2009
2010       my $convert_map = $convert_maps{$format}{$include};
2011
2012       @inc_src = map { s/\[\@--/$delimiters{$format}[0]/g;
2013                        s/--\@\]/$delimiters{$format}[1]/g;
2014                        $_;
2015                      }
2016                  &$convert_map( $conf->config($inc_file, $agentnum) );
2017
2018     }
2019
2020     my $inc_tt = new Text::Template (
2021       TYPE       => 'ARRAY',
2022       SOURCE     => [ map "$_\n", @inc_src ],
2023       DELIMITERS => $delimiters{$format},
2024     ) or die "Can't create new Text::Template object: $Text::Template::ERROR";
2025
2026     unless ( $inc_tt->compile() ) {
2027       my $error = "Can't compile $inc_file template: $Text::Template::ERROR\n";
2028       warn $error. "Template:\n". join('', map "$_\n", @inc_src);
2029       die $error;
2030     }
2031
2032     $invoice_data{$include} = $inc_tt->fill_in( HASH => \%invoice_data );
2033
2034     $invoice_data{$include} =~ s/\n+$//
2035       if ($format eq 'latex');
2036   }
2037
2038   $invoice_data{'po_line'} =
2039     (  $cust_main->payby eq 'BILL' && $cust_main->payinfo )
2040       ? &$escape_function("Purchase Order #". $cust_main->payinfo)
2041       : $nbsp;
2042
2043   my %money_chars = ( 'latex'    => '',
2044                       'html'     => $conf->config('money_char') || '$',
2045                       'template' => '',
2046                     );
2047   my $money_char = $money_chars{$format};
2048
2049   my %other_money_chars = ( 'latex'    => '\dollar ',#XXX should be a config too
2050                             'html'     => $conf->config('money_char') || '$',
2051                             'template' => '',
2052                           );
2053   my $other_money_char = $other_money_chars{$format};
2054
2055   my @detail_items = ();
2056   my @total_items = ();
2057   my @buf = ();
2058   my @sections = ();
2059
2060   $invoice_data{'detail_items'} = \@detail_items;
2061   $invoice_data{'total_items'} = \@total_items;
2062   $invoice_data{'buf'} = \@buf;
2063   $invoice_data{'sections'} = \@sections;
2064
2065   my $previous_section = { 'description' => 'Previous Charges',
2066                            'subtotal'    => $other_money_char.
2067                                             sprintf('%.2f', $pr_total),
2068                          };
2069
2070   my $taxtotal = 0;
2071   my $tax_section = { 'description' => 'Taxes, Surcharges, and Fees',
2072                       'subtotal'    => $taxtotal }; # adjusted below
2073
2074   my $adjusttotal = 0;
2075   my $adjust_section = { 'description' => 'Credits, Payments, and Adjustments',
2076                          'subtotal'    => 0 }; # adjusted below
2077
2078   my $unsquelched = $params{unsquelch_cdr} || $cust_main->squelch_cdr ne 'Y';
2079   my $multisection = $conf->exists('invoice_sections', $cust_main->agentnum);
2080   my $late_sections = [];
2081   if ( $multisection ) {
2082     push @sections, $self->_items_sections( $late_sections );
2083   }else{
2084     push @sections, { 'description' => '', 'subtotal' => '' };
2085   }
2086
2087   unless (    $conf->exists('disable_previous_balance')
2088            || $conf->exists('previous_balance-summary_only')
2089          )
2090   {
2091
2092     foreach my $line_item ( $self->_items_previous ) {
2093
2094       my $detail = {
2095         ext_description => [],
2096       };
2097       $detail->{'ref'} = $line_item->{'pkgnum'};
2098       $detail->{'quantity'} = 1;
2099       $detail->{'section'} = $previous_section;
2100       $detail->{'description'} = &$escape_function($line_item->{'description'});
2101       if ( exists $line_item->{'ext_description'} ) {
2102         @{$detail->{'ext_description'}} = map {
2103           &$escape_function($_);
2104         } @{$line_item->{'ext_description'}};
2105       }
2106       $detail->{'amount'} = ( $old_latex ? '' : $money_char).
2107                             $line_item->{'amount'};
2108       $detail->{'product_code'} = $line_item->{'pkgpart'} || 'N/A';
2109
2110       push @detail_items, $detail;
2111       push @buf, [ $detail->{'description'},
2112                    $money_char. sprintf("%10.2f", $line_item->{'amount'}),
2113                  ];
2114     }
2115
2116   }
2117
2118   if ( @pr_cust_bill && !$conf->exists('disable_previous_balance') ) {
2119     push @buf, ['','-----------'];
2120     push @buf, [ 'Total Previous Balance',
2121                  $money_char. sprintf("%10.2f", $pr_total) ];
2122     push @buf, ['',''];
2123   }
2124
2125   foreach my $section (@sections, @$late_sections) {
2126
2127     $section->{'subtotal'} = $other_money_char.
2128                              sprintf('%.2f', $section->{'subtotal'})
2129       if $multisection;
2130
2131     if ( $section->{'description'} ) {
2132       push @buf, ( [ &$escape_function($section->{'description'}), '' ],
2133                    [ '', '' ],
2134                  );
2135     }
2136
2137     my %options = ();
2138     $options{'section'} = $section if $multisection;
2139     $options{'format'} = $format;
2140     $options{'escape_function'} = $escape_function;
2141     $options{'format_function'} = sub { () } unless $unsquelched;
2142     $options{'unsquelched'} = $unsquelched;
2143
2144     foreach my $line_item ( $self->_items_pkg(%options) ) {
2145       my $detail = {
2146         ext_description => [],
2147       };
2148       $detail->{'ref'} = $line_item->{'pkgnum'};
2149       $detail->{'quantity'} = $line_item->{'quantity'};
2150       $detail->{'section'} = $section;
2151       $detail->{'description'} = &$escape_function($line_item->{'description'});
2152       if ( exists $line_item->{'ext_description'} ) {
2153         @{$detail->{'ext_description'}} = @{$line_item->{'ext_description'}};
2154       }
2155       $detail->{'amount'} = ( $old_latex ? '' : $money_char ).
2156                               $line_item->{'amount'};
2157       $detail->{'unit_amount'} = ( $old_latex ? '' : $money_char ).
2158                                  $line_item->{'unit_amount'};
2159       $detail->{'product_code'} = $line_item->{'pkgpart'} || 'N/A';
2160
2161       push @detail_items, $detail;
2162       push @buf, ( [ $detail->{'description'},
2163                      $money_char. sprintf("%10.2f", $line_item->{'amount'}),
2164                    ],
2165                    map { [ " ". $_, '' ] } @{$detail->{'ext_description'}},
2166                  );
2167     }
2168
2169     if ( $section->{'description'} ) {
2170       push @buf, ( ['','-----------'],
2171                    [ $section->{'description'}. ' sub-total',
2172                       $money_char. sprintf("%10.2f", $section->{'subtotal'})
2173                    ],
2174                    [ '', '' ],
2175                    [ '', '' ],
2176                  );
2177     }
2178
2179   }
2180
2181   if ( $multisection && !$conf->exists('disable_previous_balance') ) {
2182     unshift @sections, $previous_section if $pr_total;
2183   }
2184
2185   foreach my $tax ( $self->_items_tax ) {
2186
2187     $taxtotal += $tax->{'amount'};
2188
2189     my $description = &$escape_function( $tax->{'description'} );
2190     my $amount      = sprintf( '%.2f', $tax->{'amount'} );
2191
2192     if ( $multisection ) {
2193
2194       my $money = $old_latex ? '' : $money_char;
2195       push @detail_items, {
2196         ext_description => [],
2197         ref          => '',
2198         quantity     => '',
2199         description  => $description,
2200         amount       => $money. $amount,
2201         product_code => '',
2202         section      => $tax_section,
2203       };
2204
2205     } else {
2206
2207       push @total_items, {
2208         'total_item'   => $description,
2209         'total_amount' => $other_money_char. $amount,
2210       };
2211
2212     }
2213
2214     push @buf,[ $description,
2215                 $money_char. $amount,
2216               ];
2217
2218   }
2219
2220   if ( $taxtotal ) {
2221     my $total = {};
2222     $total->{'total_item'} = 'Sub-total';
2223     $total->{'total_amount'} =
2224       $other_money_char. sprintf('%.2f', $self->charged - $taxtotal );
2225
2226     if ( $multisection ) {
2227       $tax_section->{'subtotal'} = $other_money_char.
2228                                    sprintf('%.2f', $taxtotal);
2229       $tax_section->{'pretotal'} = 'New charges sub-total '.
2230                                    $total->{'total_amount'};
2231       push @sections, $tax_section if $taxtotal;
2232     }else{
2233       unshift @total_items, $total;
2234     }
2235   }
2236   $invoice_data{'taxtotal'} = sprintf('%.2f', $taxtotal);
2237
2238   push @buf,['','-----------'];
2239   push @buf,[( $conf->exists('disable_previous_balance')
2240                ? 'Total Charges'
2241                : 'Total New Charges'
2242              ),
2243              $money_char. sprintf("%10.2f",$self->charged) ];
2244   push @buf,['',''];
2245
2246   {
2247     my $total = {};
2248     $total->{'total_item'} = &$embolden_function('Total');
2249     $total->{'total_amount'} =
2250       &$embolden_function(
2251         $other_money_char.
2252         sprintf( '%.2f',
2253                  $self->charged + ( $conf->exists('disable_previous_balance')
2254                                     ? 0
2255                                     : $pr_total
2256                                   )
2257                )
2258       );
2259     if ( $multisection ) {
2260       $adjust_section->{'pretotal'} = 'New charges total '. $other_money_char.
2261                                       sprintf('%.2f', $self->charged );
2262     }else{
2263       push @total_items, $total;
2264     }
2265     push @buf,['','-----------'];
2266     push @buf,['Total Charges',
2267                $money_char.
2268                sprintf( '%10.2f', $self->charged +
2269                                     ( $conf->exists('disable_previous_balance')
2270                                         ? 0
2271                                         : $pr_total
2272                                     )
2273                       )
2274               ];
2275     push @buf,['',''];
2276   }
2277
2278   unless ( $conf->exists('disable_previous_balance') ) {
2279     #foreach my $thing ( sort { $a->_date <=> $b->_date } $self->_items_credits, $self->_items_payments
2280
2281     # credits
2282     my $credittotal = 0;
2283     foreach my $credit ( $self->_items_credits ) {
2284
2285       my $total;
2286       $total->{'total_item'} = &$escape_function($credit->{'description'});
2287       $credittotal += $credit->{'amount'};
2288       $total->{'total_amount'} = '-'. $other_money_char. $credit->{'amount'};
2289       $adjusttotal += $credit->{'amount'};
2290       if ( $multisection ) {
2291         my $money = $old_latex ? '' : $money_char;
2292         push @detail_items, {
2293           ext_description => [],
2294           ref          => '',
2295           quantity     => '',
2296           description  => &$escape_function($credit->{'description'}),
2297           amount       => $money. $credit->{'amount'},
2298           product_code => '',
2299           section      => $adjust_section,
2300         };
2301       } else {
2302         push @total_items, $total;
2303       }
2304
2305       push @buf, [ $credit->{'description'}, $money_char.$credit->{'amount'} ];
2306
2307     }
2308     $invoice_data{'credittotal'} = sprintf('%.2f', $credittotal);
2309
2310     # payments
2311     my $paymenttotal = 0;
2312     foreach my $payment ( $self->_items_payments ) {
2313       my $total = {};
2314       $total->{'total_item'} = &$escape_function($payment->{'description'});
2315       $paymenttotal += $payment->{'amount'};
2316       $total->{'total_amount'} = '-'. $other_money_char. $payment->{'amount'};
2317       $adjusttotal += $payment->{'amount'};
2318       if ( $multisection ) {
2319         my $money = $old_latex ? '' : $money_char;
2320         push @detail_items, {
2321           ext_description => [],
2322           ref          => '',
2323           quantity     => '',
2324           description  => &$escape_function($payment->{'description'}),
2325           amount       => $money. $payment->{'amount'},
2326           product_code => '',
2327           section      => $adjust_section,
2328         };
2329       }else{
2330         push @total_items, $total;
2331       }
2332       push @buf, [ $payment->{'description'},
2333                    $money_char. sprintf("%10.2f", $payment->{'amount'}),
2334                  ];
2335     }
2336     $invoice_data{'paymenttotal'} = sprintf('%.2f', $paymenttotal);
2337
2338     if ( $multisection ) {
2339       $adjust_section->{'subtotal'} = $other_money_char.
2340                                       sprintf('%.2f', $adjusttotal);
2341       push @sections, $adjust_section;
2342     }
2343
2344     {
2345       my $total;
2346       $total->{'total_item'} = &$embolden_function($self->balance_due_msg);
2347       $total->{'total_amount'} =
2348         &$embolden_function(
2349           $other_money_char. sprintf('%.2f', $self->owed + $pr_total )
2350         );
2351       if ( $multisection ) {
2352         $adjust_section->{'posttotal'} = $total->{'total_item'}. ' '.
2353                                          $total->{'total_amount'};
2354       }else{
2355         push @total_items, $total;
2356       }
2357       push @buf,['','-----------'];
2358       push @buf,[$self->balance_due_msg, $money_char.
2359         sprintf("%10.2f", $balance_due ) ];
2360     }
2361   }
2362
2363   if ( $multisection ) {
2364     push @sections, @$late_sections
2365       if $unsquelched;
2366   }
2367
2368   $invoice_lines = 0;
2369   my $wasfunc = 0;
2370   foreach ( grep /invoice_lines\(\d*\)/, @invoice_template ) { #kludgy
2371     /invoice_lines\((\d*)\)/;
2372     $invoice_lines += $1 || scalar(@buf);
2373     $wasfunc=1;
2374   }
2375   die "no invoice_lines() functions in template?"
2376     if ( $format eq 'template' && !$wasfunc );
2377
2378   if ($format eq 'template') {
2379
2380     if ( $invoice_lines ) {
2381       $invoice_data{'total_pages'} = int( scalar(@buf) / $invoice_lines );
2382       $invoice_data{'total_pages'}++
2383         if scalar(@buf) % $invoice_lines;
2384     }
2385
2386     #setup subroutine for the template
2387     sub FS::cust_bill::_template::invoice_lines {
2388       my $lines = shift || scalar(@FS::cust_bill::_template::buf);
2389       map {
2390         scalar(@FS::cust_bill::_template::buf)
2391           ? shift @FS::cust_bill::_template::buf
2392           : [ '', '' ];
2393       }
2394       ( 1 .. $lines );
2395     }
2396
2397     my $lines;
2398     my @collect;
2399     while (@buf) {
2400       push @collect, split("\n",
2401         $text_template->fill_in( HASH => \%invoice_data,
2402                                  PACKAGE => 'FS::cust_bill::_template'
2403                                )
2404       );
2405       $FS::cust_bill::_template::page++;
2406     }
2407     map "$_\n", @collect;
2408   }else{
2409     warn "filling in template for invoice ". $self->invnum. "\n"
2410       if $DEBUG;
2411     warn join("\n", map " $_ => ". $invoice_data{$_}, keys %invoice_data). "\n"
2412       if $DEBUG > 1;
2413
2414     $text_template->fill_in(HASH => \%invoice_data);
2415   }
2416 }
2417
2418 =item print_ps [ TIME [ , TEMPLATE ] ]
2419
2420 Returns an postscript invoice, as a scalar.
2421
2422 TIME an optional value used to control the printing of overdue messages.  The
2423 default is now.  It isn't the date of the invoice; that's the `_date' field.
2424 It is specified as a UNIX timestamp; see L<perlfunc/"time">.  Also see
2425 L<Time::Local> and L<Date::Parse> for conversion functions.
2426
2427 =cut
2428
2429 sub print_ps {
2430   my $self = shift;
2431
2432   my ($file, $lfile) = $self->print_latex(@_);
2433   my $ps = generate_ps($file);
2434   unlink($lfile);
2435
2436   $ps;
2437 }
2438
2439 =item print_pdf [ TIME [ , TEMPLATE ] ]
2440
2441 Returns an PDF invoice, as a scalar.
2442
2443 TIME an optional value used to control the printing of overdue messages.  The
2444 default is now.  It isn't the date of the invoice; that's the `_date' field.
2445 It is specified as a UNIX timestamp; see L<perlfunc/"time">.  Also see
2446 L<Time::Local> and L<Date::Parse> for conversion functions.
2447
2448 =cut
2449
2450 sub print_pdf {
2451   my $self = shift;
2452
2453   my ($file, $lfile) = $self->print_latex(@_);
2454   my $pdf = generate_pdf($file);
2455   unlink($lfile);
2456
2457   $pdf;
2458 }
2459
2460 =item print_html [ TIME [ , TEMPLATE [ , CID ] ] ]
2461
2462 Returns an HTML invoice, as a scalar.
2463
2464 TIME an optional value used to control the printing of overdue messages.  The
2465 default is now.  It isn't the date of the invoice; that's the `_date' field.
2466 It is specified as a UNIX timestamp; see L<perlfunc/"time">.  Also see
2467 L<Time::Local> and L<Date::Parse> for conversion functions.
2468
2469 CID is a MIME Content-ID used to create a "cid:" URL for the logo image, used
2470 when emailing the invoice as part of a multipart/related MIME email.
2471
2472 =cut
2473
2474 sub print_html {
2475   my $self = shift;
2476   my %params;
2477   if ( ref $_[0]  ) {
2478     %params = %{ shift() };
2479   }else{
2480     $params{'time'} = shift;
2481     $params{'template'} = shift;
2482     $params{'cid'} = shift;
2483   }
2484
2485   $params{'format'} = 'html';
2486
2487   $self->print_generic( %params );
2488 }
2489
2490 # quick subroutine for print_latex
2491 #
2492 # There are ten characters that LaTeX treats as special characters, which
2493 # means that they do not simply typeset themselves:
2494 #      # $ % & ~ _ ^ \ { }
2495 #
2496 # TeX ignores blanks following an escaped character; if you want a blank (as
2497 # in "10% of ..."), you have to "escape" the blank as well ("10\%\ of ...").
2498
2499 sub _latex_escape {
2500   my $value = shift;
2501   $value =~ s/([#\$%&~_\^{}])( )?/"\\$1". ( ( defined($2) && length($2) ) ? "\\$2" : '' )/ge;
2502   $value =~ s/([<>])/\$$1\$/g;
2503   $value;
2504 }
2505
2506 #utility methods for print_*
2507
2508 sub _translate_old_latex_format {
2509   warn "_translate_old_latex_format called\n"
2510     if $DEBUG;
2511
2512   my @template = ();
2513   while ( @_ ) {
2514     my $line = shift;
2515
2516     if ( $line =~ /^%%Detail\s*$/ ) {
2517
2518       push @template, q![@--!,
2519                       q!  foreach my $_tr_line (@detail_items) {!,
2520                       q!    if ( scalar ($_tr_item->{'ext_description'} ) ) {!,
2521                       q!      $_tr_line->{'description'} .= !,
2522                       q!        "\\tabularnewline\n~~".!,
2523                       q!        join( "\\tabularnewline\n~~",!,
2524                       q!          @{$_tr_line->{'ext_description'}}!,
2525                       q!        );!,
2526                       q!    }!;
2527
2528       while ( ( my $line_item_line = shift )
2529               !~ /^%%EndDetail\s*$/                            ) {
2530         $line_item_line =~ s/'/\\'/g;    # nice LTS
2531         $line_item_line =~ s/\\/\\\\/g;  # escape quotes and backslashes
2532         $line_item_line =~ s/\$(\w+)/'. \$_tr_line->{$1}. '/g;
2533         push @template, "    \$OUT .= '$line_item_line';";
2534       }
2535
2536       push @template, '}',
2537                       '--@]';
2538
2539     } elsif ( $line =~ /^%%TotalDetails\s*$/ ) {
2540
2541       push @template, '[@--',
2542                       '  foreach my $_tr_line (@total_items) {';
2543
2544       while ( ( my $total_item_line = shift )
2545               !~ /^%%EndTotalDetails\s*$/                      ) {
2546         $total_item_line =~ s/'/\\'/g;    # nice LTS
2547         $total_item_line =~ s/\\/\\\\/g;  # escape quotes and backslashes
2548         $total_item_line =~ s/\$(\w+)/'. \$_tr_line->{$1}. '/g;
2549         push @template, "    \$OUT .= '$total_item_line';";
2550       }
2551
2552       push @template, '}',
2553                       '--@]';
2554
2555     } else {
2556       $line =~ s/\$(\w+)/[\@-- \$$1 --\@]/g;
2557       push @template, $line;
2558     }
2559
2560   }
2561
2562   if ($DEBUG) {
2563     warn "$_\n" foreach @template;
2564   }
2565
2566   (@template);
2567 }
2568
2569 sub terms {
2570   my $self = shift;
2571
2572   #check for an invoice- specific override (eventually)
2573
2574   #check for a customer- specific override
2575   return $self->cust_main->invoice_terms
2576     if $self->cust_main->invoice_terms;
2577
2578   #use configured default or default default
2579   $conf->config('invoice_default_terms') || 'Payable upon receipt';
2580 }
2581
2582 sub due_date {
2583   my $self = shift;
2584   my $duedate = '';
2585   if ( $self->terms =~ /^\s*Net\s*(\d+)\s*$/ ) {
2586     $duedate = $self->_date() + ( $1 * 86400 );
2587   }
2588   $duedate;
2589 }
2590
2591 sub due_date2str {
2592   my $self = shift;
2593   $self->due_date ? time2str(shift, $self->due_date) : '';
2594 }
2595
2596 sub balance_due_msg {
2597   my $self = shift;
2598   my $msg = 'Balance Due';
2599   return $msg unless $self->terms;
2600   if ( $self->due_date ) {
2601     $msg .= ' - Please pay by '. $self->due_date2str('%x');
2602   } elsif ( $self->terms ) {
2603     $msg .= ' - '. $self->terms;
2604   }
2605   $msg;
2606 }
2607
2608 sub balance_due_date {
2609   my $self = shift;
2610   my $duedate = '';
2611   if (    $conf->exists('invoice_default_terms')
2612        && $conf->config('invoice_default_terms')=~ /^\s*Net\s*(\d+)\s*$/ ) {
2613     $duedate = time2str("%m/%d/%Y", $self->_date + ($1*86400) );
2614   }
2615   $duedate;
2616 }
2617
2618 =item invnum_date_pretty
2619
2620 Returns a string with the invoice number and date, for example:
2621 "Invoice #54 (3/20/2008)"
2622
2623 =cut
2624
2625 sub invnum_date_pretty {
2626   my $self = shift;
2627   'Invoice #'. $self->invnum. ' ('. $self->_date_pretty. ')';
2628 }
2629
2630 =item _date_pretty
2631
2632 Returns a string with the date, for example: "3/20/2008"
2633
2634 =cut
2635
2636 sub _date_pretty {
2637   my $self = shift;
2638   time2str('%x', $self->_date);
2639 }
2640
2641 sub _items_sections {
2642   my $self = shift;
2643   my $late = shift;
2644
2645   my %s = ();
2646   my %l = ();
2647
2648   foreach my $cust_bill_pkg ( $self->cust_bill_pkg )
2649   {
2650
2651     if ( $cust_bill_pkg->pkgnum > 0 ) {
2652       my $usage = $cust_bill_pkg->usage;
2653
2654       foreach my $display ($cust_bill_pkg->cust_bill_pkg_display) {
2655         my $desc = $display->section;
2656         my $type = $display->type;
2657
2658         if ( $display->post_total ) {
2659           if (! $type || $type eq 'S') {
2660             $l{$desc} += $cust_bill_pkg->setup
2661               if ( $cust_bill_pkg->setup != 0 );
2662           }
2663
2664           if (! $type) {
2665             $l{$desc} += $cust_bill_pkg->recur
2666               if ( $cust_bill_pkg->recur != 0 );
2667           }
2668
2669           if ($type && $type eq 'R') {
2670             $l{$desc} += $cust_bill_pkg->recur - $usage
2671               if ( $cust_bill_pkg->recur != 0 );
2672           }
2673
2674           if ($type && $type eq 'U') {
2675             $l{$desc} += $usage;
2676           }
2677
2678         } else {
2679           if (! $type || $type eq 'S') {
2680             $s{$desc} += $cust_bill_pkg->setup
2681               if ( $cust_bill_pkg->setup != 0 );
2682           }
2683
2684           if (! $type) {
2685             $s{$desc} += $cust_bill_pkg->recur
2686               if ( $cust_bill_pkg->recur != 0 );
2687           }
2688
2689           if ($type && $type eq 'R') {
2690             $s{$desc} += $cust_bill_pkg->recur - $usage
2691               if ( $cust_bill_pkg->recur != 0 );
2692           }
2693
2694           if ($type && $type eq 'U') {
2695             $s{$desc} += $usage;
2696           }
2697
2698         }
2699
2700       }
2701
2702     }
2703
2704   }
2705
2706   push @$late, map { { 'description' => $_,
2707                        'subtotal'    => $l{$_},
2708                        'post_total'  => 1,
2709                    } } sort keys %l;
2710
2711   map { {'description' => $_, 'subtotal' => $s{$_}} } sort keys %s;
2712
2713 }
2714
2715 sub _items {
2716   my $self = shift;
2717
2718   #my @display = scalar(@_)
2719   #              ? @_
2720   #              : qw( _items_previous _items_pkg );
2721   #              #: qw( _items_pkg );
2722   #              #: qw( _items_previous _items_pkg _items_tax _items_credits _items_payments );
2723   my @display = qw( _items_previous _items_pkg );
2724
2725   my @b = ();
2726   foreach my $display ( @display ) {
2727     push @b, $self->$display(@_);
2728   }
2729   @b;
2730 }
2731
2732 sub _items_previous {
2733   my $self = shift;
2734   my $cust_main = $self->cust_main;
2735   my( $pr_total, @pr_cust_bill ) = $self->previous; #previous balance
2736   my @b = ();
2737   foreach ( @pr_cust_bill ) {
2738     push @b, {
2739       'description' => 'Previous Balance, Invoice #'. $_->invnum.
2740                        ' ('. time2str('%x',$_->_date). ')',
2741       #'pkgpart'     => 'N/A',
2742       'pkgnum'      => 'N/A',
2743       'amount'      => sprintf("%.2f", $_->owed),
2744     };
2745   }
2746   @b;
2747
2748   #{
2749   #    'description'     => 'Previous Balance',
2750   #    #'pkgpart'         => 'N/A',
2751   #    'pkgnum'          => 'N/A',
2752   #    'amount'          => sprintf("%10.2f", $pr_total ),
2753   #    'ext_description' => [ map {
2754   #                                 "Invoice ". $_->invnum.
2755   #                                 " (". time2str("%x",$_->_date). ") ".
2756   #                                 sprintf("%10.2f", $_->owed)
2757   #                         } @pr_cust_bill ],
2758
2759   #};
2760 }
2761
2762 sub _items_pkg {
2763   my $self = shift;
2764   my @cust_bill_pkg = grep { $_->pkgnum } $self->cust_bill_pkg;
2765   $self->_items_cust_bill_pkg(\@cust_bill_pkg, @_);
2766 }
2767
2768 sub _taxsort {
2769   return 0 unless $a cmp $b;
2770   return -1 if $b eq 'Tax';
2771   return 1 if $a eq 'Tax';
2772   return -1 if $b eq 'Other surcharges';
2773   return 1 if $a eq 'Other surcharges';
2774   $a cmp $b;
2775 }
2776
2777 sub _items_tax {
2778   my $self = shift;
2779   my @cust_bill_pkg = sort _taxsort grep { ! $_->pkgnum } $self->cust_bill_pkg;
2780   $self->_items_cust_bill_pkg(\@cust_bill_pkg, @_);
2781 }
2782
2783 sub _items_cust_bill_pkg {
2784   my $self = shift;
2785   my $cust_bill_pkg = shift;
2786   my %opt = @_;
2787
2788   my $format = $opt{format} || '';
2789   my $escape_function = $opt{escape_function} || sub { shift };
2790   my $format_function = $opt{format_function} || '';
2791   my $unsquelched = $opt{unsquelched} || '';
2792   my $section = $opt{section}->{description} if $opt{section};
2793
2794   my @b = ();
2795   foreach my $cust_bill_pkg ( @$cust_bill_pkg )
2796   {
2797     foreach my $display ( grep { defined($section)
2798                                  ? $_->section eq $section
2799                                  : 1
2800                                }
2801                           $cust_bill_pkg->cust_bill_pkg_display
2802                         )
2803     {
2804
2805       my $type = $display->type;
2806
2807       my $cust_pkg = $cust_bill_pkg->cust_pkg;
2808
2809       my $desc = $cust_bill_pkg->desc;
2810       $desc = substr($desc, 0, 50). '...'
2811         if $format eq 'latex' && length($desc) > 50;
2812
2813       my %details_opt = ( 'format'          => $format,
2814                           'escape_function' => $escape_function,
2815                           'format_function' => $format_function,
2816                         );
2817
2818       if ( $cust_bill_pkg->pkgnum > 0 ) {
2819
2820         if ( $cust_bill_pkg->setup != 0 && (!$type || $type eq 'S') ) {
2821
2822           my $description = $desc;
2823           $description .= ' Setup' if $cust_bill_pkg->recur != 0;
2824
2825           my @d = ();
2826           push @d, map &{$escape_function}($_),
2827                        $cust_pkg->h_labels_short($self->_date)
2828             unless $cust_pkg->part_pkg->hide_svc_detail;
2829           push @d, $cust_bill_pkg->details(%details_opt)
2830             if $cust_bill_pkg->recur == 0;
2831
2832           push @b, {
2833             description     => $description,
2834             #pkgpart         => $part_pkg->pkgpart,
2835             pkgnum          => $cust_bill_pkg->pkgnum,
2836             amount          => sprintf("%.2f", $cust_bill_pkg->setup),
2837             unit_amount     => sprintf("%.2f", $cust_bill_pkg->unitsetup),
2838             quantity        => $cust_bill_pkg->quantity,
2839             ext_description => \@d,
2840           };
2841
2842         }
2843
2844         if ( $cust_bill_pkg->recur != 0 &&
2845              ( !$type || $type eq 'R' || $type eq 'U' )
2846            )
2847         {
2848
2849           my $is_summary = $display->summary;
2850           my $description = $is_summary ? "Usage charges" : $desc;
2851
2852           unless ( $conf->exists('disable_line_item_date_ranges') ) {
2853             $description .= " (" . time2str("%x", $cust_bill_pkg->sdate).
2854                             " - ". time2str("%x", $cust_bill_pkg->edate). ")";
2855           }
2856
2857           my @d = ();
2858
2859           #at least until cust_bill_pkg has "past" ranges in addition to
2860           #the "future" sdate/edate ones... see #3032
2861           push @d, map &{$escape_function}($_),
2862                        $cust_pkg->h_labels_short($self->_date)
2863                                                  #$cust_bill_pkg->edate,
2864                                                  #$cust_bill_pkg->sdate)
2865             unless $cust_pkg->part_pkg->hide_svc_detail
2866                 || $cust_bill_pkg->itemdesc
2867                 || $is_summary;
2868
2869           push @d, $cust_bill_pkg->details(%details_opt)
2870             unless ($is_summary || $type && $type eq 'R');
2871
2872           my $amount = 0;
2873           if (!$type) {
2874             $amount = $cust_bill_pkg->recur;
2875           }elsif($type eq 'R') {
2876             $amount = $cust_bill_pkg->recur - $cust_bill_pkg->usage;
2877           }elsif($type eq 'U') {
2878             $amount = $cust_bill_pkg->usage;
2879           }
2880
2881           push @b, {
2882             description     => $description,
2883             #pkgpart         => $part_pkg->pkgpart,
2884             pkgnum          => $cust_bill_pkg->pkgnum,
2885             amount          => sprintf("%.2f", $amount),
2886             unit_amount     => sprintf("%.2f", $cust_bill_pkg->unitrecur),
2887             quantity        => $cust_bill_pkg->quantity,
2888             ext_description => \@d,
2889           } unless ( $type eq 'U' && ! $amount );
2890
2891         }
2892
2893       } else { #pkgnum tax or one-shot line item (??)
2894
2895         if ( $cust_bill_pkg->setup != 0 ) {
2896           push @b, {
2897             'description' => $desc,
2898             'amount'      => sprintf("%.2f", $cust_bill_pkg->setup),
2899           };
2900         }
2901         if ( $cust_bill_pkg->recur != 0 ) {
2902           push @b, {
2903             'description' => "$desc (".
2904                              time2str("%x", $cust_bill_pkg->sdate). ' - '.
2905                              time2str("%x", $cust_bill_pkg->edate). ')',
2906             'amount'      => sprintf("%.2f", $cust_bill_pkg->recur),
2907           };
2908         }
2909
2910       }
2911
2912     }
2913
2914   }
2915
2916   @b;
2917
2918 }
2919
2920 sub _items_credits {
2921   my $self = shift;
2922
2923   my @b;
2924   #credits
2925   foreach ( $self->cust_credited ) {
2926
2927     #something more elaborate if $_->amount ne $_->cust_credit->credited ?
2928
2929     my $reason = substr($_->cust_credit->reason,0,32);
2930     $reason .= '...' if length($reason) < length($_->cust_credit->reason);
2931     $reason = " ($reason) " if $reason;
2932
2933     push @b, {
2934       #'description' => 'Credit ref\#'. $_->crednum.
2935       #                 " (". time2str("%x",$_->cust_credit->_date) .")".
2936       #                 $reason,
2937       'description' => 'Credit applied '.
2938                        time2str("%x",$_->cust_credit->_date). $reason,
2939       'amount'      => sprintf("%.2f",$_->amount),
2940     };
2941   }
2942
2943   @b;
2944
2945 }
2946
2947 sub _items_payments {
2948   my $self = shift;
2949
2950   my @b;
2951   #get & print payments
2952   foreach ( $self->cust_bill_pay ) {
2953
2954     #something more elaborate if $_->amount ne ->cust_pay->paid ?
2955
2956     push @b, {
2957       'description' => "Payment received ".
2958                        time2str("%x",$_->cust_pay->_date ),
2959       'amount'      => sprintf("%.2f", $_->amount )
2960     };
2961   }
2962
2963   @b;
2964
2965 }
2966
2967
2968 =back
2969
2970 =head1 SUBROUTINES
2971
2972 =over 4
2973
2974 =item process_reprint
2975
2976 =cut
2977
2978 sub process_reprint {
2979   process_re_X('print', @_);
2980 }
2981
2982 =item process_reemail
2983
2984 =cut
2985
2986 sub process_reemail {
2987   process_re_X('email', @_);
2988 }
2989
2990 =item process_refax
2991
2992 =cut
2993
2994 sub process_refax {
2995   process_re_X('fax', @_);
2996 }
2997
2998 =item process_reftp
2999
3000 =cut
3001
3002 sub process_reftp {
3003   process_re_X('ftp', @_);
3004 }
3005
3006 =item respool
3007
3008 =cut
3009
3010 sub process_respool {
3011   process_re_X('spool', @_);
3012 }
3013
3014 use Storable qw(thaw);
3015 use Data::Dumper;
3016 use MIME::Base64;
3017 sub process_re_X {
3018   my( $method, $job ) = ( shift, shift );
3019   warn "$me process_re_X $method for job $job\n" if $DEBUG;
3020
3021   my $param = thaw(decode_base64(shift));
3022   warn Dumper($param) if $DEBUG;
3023
3024   re_X(
3025     $method,
3026     $job,
3027     %$param,
3028   );
3029
3030 }
3031
3032 sub re_X {
3033   my($method, $job, %param ) = @_;
3034   if ( $DEBUG ) {
3035     warn "re_X $method for job $job with param:\n".
3036          join( '', map { "  $_ => ". $param{$_}. "\n" } keys %param );
3037   }
3038
3039   #some false laziness w/search/cust_bill.html
3040   my $distinct = '';
3041   my $orderby = 'ORDER BY cust_bill._date';
3042
3043   my $extra_sql = ' WHERE '. FS::cust_bill->search_sql(\%param);
3044
3045   my $addl_from = 'LEFT JOIN cust_main USING ( custnum )';
3046
3047   my @cust_bill = qsearch( {
3048     #'select'    => "cust_bill.*",
3049     'table'     => 'cust_bill',
3050     'addl_from' => $addl_from,
3051     'hashref'   => {},
3052     'extra_sql' => $extra_sql,
3053     'order_by'  => $orderby,
3054     'debug' => 1,
3055   } );
3056
3057   $method .= '_invoice' unless $method eq 'email' || $method eq 'print';
3058
3059   warn " $me re_X $method: ". scalar(@cust_bill). " invoices found\n"
3060     if $DEBUG;
3061
3062   my( $num, $last, $min_sec ) = (0, time, 5); #progresbar foo
3063   foreach my $cust_bill ( @cust_bill ) {
3064     $cust_bill->$method();
3065
3066     if ( $job ) { #progressbar foo
3067       $num++;
3068       if ( time - $min_sec > $last ) {
3069         my $error = $job->update_statustext(
3070           int( 100 * $num / scalar(@cust_bill) )
3071         );
3072         die $error if $error;
3073         $last = time;
3074       }
3075     }
3076
3077   }
3078
3079 }
3080
3081 =back
3082
3083 =head1 CLASS METHODS
3084
3085 =over 4
3086
3087 =item owed_sql
3088
3089 Returns an SQL fragment to retreive the amount owed (charged minus credited and paid).
3090
3091 =cut
3092
3093 sub owed_sql {
3094   my $class = shift;
3095   'charged - '. $class->paid_sql. ' - '. $class->credited_sql;
3096 }
3097
3098 =item net_sql
3099
3100 Returns an SQL fragment to retreive the net amount (charged minus credited).
3101
3102 =cut
3103
3104 sub net_sql {
3105   my $class = shift;
3106   'charged - '. $class->credited_sql;
3107 }
3108
3109 =item paid_sql
3110
3111 Returns an SQL fragment to retreive the amount paid against this invoice.
3112
3113 =cut
3114
3115 sub paid_sql {
3116   #my $class = shift;
3117   "( SELECT COALESCE(SUM(amount),0) FROM cust_bill_pay
3118        WHERE cust_bill.invnum = cust_bill_pay.invnum   )";
3119 }
3120
3121 =item credited_sql
3122
3123 Returns an SQL fragment to retreive the amount credited against this invoice.
3124
3125 =cut
3126
3127 sub credited_sql {
3128   #my $class = shift;
3129   "( SELECT COALESCE(SUM(amount),0) FROM cust_credit_bill
3130        WHERE cust_bill.invnum = cust_credit_bill.invnum   )";
3131 }
3132
3133 =item search_sql HASHREF
3134
3135 Class method which returns an SQL WHERE fragment to search for parameters
3136 specified in HASHREF.  Valid parameters are
3137
3138 =over 4
3139
3140 =item begin
3141
3142 Epoch date (UNIX timestamp) setting a lower bound for _date values
3143
3144 =item end
3145
3146 Epoch date (UNIX timestamp) setting an upper bound for _date values
3147
3148 =item invnum_min
3149
3150 =item invnum_max
3151
3152 =item agentnum
3153
3154 =item owed
3155
3156 =item net
3157
3158 =item days
3159
3160 =item newest_percust
3161
3162 =back
3163
3164 Note: validates all passed-in data; i.e. safe to use with unchecked CGI params.
3165
3166 =cut
3167
3168 sub search_sql {
3169   my($class, $param) = @_;
3170   if ( $DEBUG ) {
3171     warn "$me search_sql called with params: \n".
3172          join("\n", map { "  $_: ". $param->{$_} } keys %$param ). "\n";
3173   }
3174
3175   my @search = ();
3176
3177   if ( $param->{'begin'} =~ /^(\d+)$/ ) {
3178     push @search, "cust_bill._date >= $1";
3179   }
3180   if ( $param->{'end'} =~ /^(\d+)$/ ) {
3181     push @search, "cust_bill._date < $1";
3182   }
3183   if ( $param->{'invnum_min'} =~ /^(\d+)$/ ) {
3184     push @search, "cust_bill.invnum >= $1";
3185   }
3186   if ( $param->{'invnum_max'} =~ /^(\d+)$/ ) {
3187     push @search, "cust_bill.invnum <= $1";
3188   }
3189   if ( $param->{'agentnum'} =~ /^(\d+)$/ ) {
3190     push @search, "cust_main.agentnum = $1";
3191   }
3192
3193   push @search, '0 != '. FS::cust_bill->owed_sql
3194     if $param->{'open'};
3195
3196   push @search, '0 != '. FS::cust_bill->net_sql
3197     if $param->{'net'};
3198
3199   push @search, "cust_bill._date < ". (time-86400*$param->{'days'})
3200     if $param->{'days'};
3201
3202   if ( $param->{'newest_percust'} ) {
3203
3204     #$distinct = 'DISTINCT ON ( cust_bill.custnum )';
3205     #$orderby = 'ORDER BY cust_bill.custnum ASC, cust_bill._date DESC';
3206
3207     my @newest_where = map { my $x = $_;
3208                              $x =~ s/\bcust_bill\./newest_cust_bill./g;
3209                              $x;
3210                            }
3211                            grep ! /^cust_main./, @search;
3212     my $newest_where = scalar(@newest_where)
3213                          ? ' AND '. join(' AND ', @newest_where)
3214                          : '';
3215
3216
3217     push @search, "cust_bill._date = (
3218       SELECT(MAX(newest_cust_bill._date)) FROM cust_bill AS newest_cust_bill
3219         WHERE newest_cust_bill.custnum = cust_bill.custnum
3220           $newest_where
3221     )";
3222
3223   }
3224
3225   my $curuser = $FS::CurrentUser::CurrentUser;
3226   if ( $curuser->username eq 'fs_queue'
3227        && $param->{'CurrentUser'} =~ /^(\w+)$/ ) {
3228     my $username = $1;
3229     my $newuser = qsearchs('access_user', {
3230       'username' => $username,
3231       'disabled' => '',
3232     } );
3233     if ( $newuser ) {
3234       $curuser = $newuser;
3235     } else {
3236       warn "$me WARNING: (fs_queue) can't find CurrentUser $username\n";
3237     }
3238   }
3239
3240   push @search, $curuser->agentnums_sql;
3241
3242   join(' AND ', @search );
3243
3244 }
3245
3246 =back
3247
3248 =head1 BUGS
3249
3250 The delete method.
3251
3252 =head1 SEE ALSO
3253
3254 L<FS::Record>, L<FS::cust_main>, L<FS::cust_bill_pay>, L<FS::cust_pay>,
3255 L<FS::cust_bill_pkg>, L<FS::cust_bill_credit>, schema.html from the base
3256 documentation.
3257
3258 =cut
3259
3260 1;
3261