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-'. $self->invnum. '.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('trim_len'=>60) ) {
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     }
2306     $invoice_data{'credittotal'} = sprintf('%.2f', $credittotal);
2307
2308     #credits (again)
2309     foreach my $credit ( $self->_items_credits('trim_len'=>32) ) {
2310       push @buf, [ $credit->{'description'}, $money_char.$credit->{'amount'} ];
2311     }
2312
2313     # payments
2314     my $paymenttotal = 0;
2315     foreach my $payment ( $self->_items_payments ) {
2316       my $total = {};
2317       $total->{'total_item'} = &$escape_function($payment->{'description'});
2318       $paymenttotal += $payment->{'amount'};
2319       $total->{'total_amount'} = '-'. $other_money_char. $payment->{'amount'};
2320       $adjusttotal += $payment->{'amount'};
2321       if ( $multisection ) {
2322         my $money = $old_latex ? '' : $money_char;
2323         push @detail_items, {
2324           ext_description => [],
2325           ref          => '',
2326           quantity     => '',
2327           description  => &$escape_function($payment->{'description'}),
2328           amount       => $money. $payment->{'amount'},
2329           product_code => '',
2330           section      => $adjust_section,
2331         };
2332       }else{
2333         push @total_items, $total;
2334       }
2335       push @buf, [ $payment->{'description'},
2336                    $money_char. sprintf("%10.2f", $payment->{'amount'}),
2337                  ];
2338     }
2339     $invoice_data{'paymenttotal'} = sprintf('%.2f', $paymenttotal);
2340
2341     if ( $multisection ) {
2342       $adjust_section->{'subtotal'} = $other_money_char.
2343                                       sprintf('%.2f', $adjusttotal);
2344       push @sections, $adjust_section;
2345     }
2346
2347     {
2348       my $total;
2349       $total->{'total_item'} = &$embolden_function($self->balance_due_msg);
2350       $total->{'total_amount'} =
2351         &$embolden_function(
2352           $other_money_char. sprintf('%.2f', $self->owed + $pr_total )
2353         );
2354       if ( $multisection ) {
2355         $adjust_section->{'posttotal'} = $total->{'total_item'}. ' '.
2356                                          $total->{'total_amount'};
2357       }else{
2358         push @total_items, $total;
2359       }
2360       push @buf,['','-----------'];
2361       push @buf,[$self->balance_due_msg, $money_char.
2362         sprintf("%10.2f", $balance_due ) ];
2363     }
2364   }
2365
2366   if ( $multisection ) {
2367     push @sections, @$late_sections
2368       if $unsquelched;
2369   }
2370
2371   $invoice_lines = 0;
2372   my $wasfunc = 0;
2373   foreach ( grep /invoice_lines\(\d*\)/, @invoice_template ) { #kludgy
2374     /invoice_lines\((\d*)\)/;
2375     $invoice_lines += $1 || scalar(@buf);
2376     $wasfunc=1;
2377   }
2378   die "no invoice_lines() functions in template?"
2379     if ( $format eq 'template' && !$wasfunc );
2380
2381   if ($format eq 'template') {
2382
2383     if ( $invoice_lines ) {
2384       $invoice_data{'total_pages'} = int( scalar(@buf) / $invoice_lines );
2385       $invoice_data{'total_pages'}++
2386         if scalar(@buf) % $invoice_lines;
2387     }
2388
2389     #setup subroutine for the template
2390     sub FS::cust_bill::_template::invoice_lines {
2391       my $lines = shift || scalar(@FS::cust_bill::_template::buf);
2392       map {
2393         scalar(@FS::cust_bill::_template::buf)
2394           ? shift @FS::cust_bill::_template::buf
2395           : [ '', '' ];
2396       }
2397       ( 1 .. $lines );
2398     }
2399
2400     my $lines;
2401     my @collect;
2402     while (@buf) {
2403       push @collect, split("\n",
2404         $text_template->fill_in( HASH => \%invoice_data,
2405                                  PACKAGE => 'FS::cust_bill::_template'
2406                                )
2407       );
2408       $FS::cust_bill::_template::page++;
2409     }
2410     map "$_\n", @collect;
2411   }else{
2412     warn "filling in template for invoice ". $self->invnum. "\n"
2413       if $DEBUG;
2414     warn join("\n", map " $_ => ". $invoice_data{$_}, keys %invoice_data). "\n"
2415       if $DEBUG > 1;
2416
2417     $text_template->fill_in(HASH => \%invoice_data);
2418   }
2419 }
2420
2421 =item print_ps [ TIME [ , TEMPLATE ] ]
2422
2423 Returns an postscript invoice, as a scalar.
2424
2425 TIME an optional value used to control the printing of overdue messages.  The
2426 default is now.  It isn't the date of the invoice; that's the `_date' field.
2427 It is specified as a UNIX timestamp; see L<perlfunc/"time">.  Also see
2428 L<Time::Local> and L<Date::Parse> for conversion functions.
2429
2430 =cut
2431
2432 sub print_ps {
2433   my $self = shift;
2434
2435   my ($file, $lfile) = $self->print_latex(@_);
2436   my $ps = generate_ps($file);
2437   unlink($lfile);
2438
2439   $ps;
2440 }
2441
2442 =item print_pdf [ TIME [ , TEMPLATE ] ]
2443
2444 Returns an PDF invoice, as a scalar.
2445
2446 TIME an optional value used to control the printing of overdue messages.  The
2447 default is now.  It isn't the date of the invoice; that's the `_date' field.
2448 It is specified as a UNIX timestamp; see L<perlfunc/"time">.  Also see
2449 L<Time::Local> and L<Date::Parse> for conversion functions.
2450
2451 =cut
2452
2453 sub print_pdf {
2454   my $self = shift;
2455
2456   my ($file, $lfile) = $self->print_latex(@_);
2457   my $pdf = generate_pdf($file);
2458   unlink($lfile);
2459
2460   $pdf;
2461 }
2462
2463 =item print_html [ TIME [ , TEMPLATE [ , CID ] ] ]
2464
2465 Returns an HTML invoice, as a scalar.
2466
2467 TIME an optional value used to control the printing of overdue messages.  The
2468 default is now.  It isn't the date of the invoice; that's the `_date' field.
2469 It is specified as a UNIX timestamp; see L<perlfunc/"time">.  Also see
2470 L<Time::Local> and L<Date::Parse> for conversion functions.
2471
2472 CID is a MIME Content-ID used to create a "cid:" URL for the logo image, used
2473 when emailing the invoice as part of a multipart/related MIME email.
2474
2475 =cut
2476
2477 sub print_html {
2478   my $self = shift;
2479   my %params;
2480   if ( ref $_[0]  ) {
2481     %params = %{ shift() };
2482   }else{
2483     $params{'time'} = shift;
2484     $params{'template'} = shift;
2485     $params{'cid'} = shift;
2486   }
2487
2488   $params{'format'} = 'html';
2489
2490   $self->print_generic( %params );
2491 }
2492
2493 # quick subroutine for print_latex
2494 #
2495 # There are ten characters that LaTeX treats as special characters, which
2496 # means that they do not simply typeset themselves:
2497 #      # $ % & ~ _ ^ \ { }
2498 #
2499 # TeX ignores blanks following an escaped character; if you want a blank (as
2500 # in "10% of ..."), you have to "escape" the blank as well ("10\%\ of ...").
2501
2502 sub _latex_escape {
2503   my $value = shift;
2504   $value =~ s/([#\$%&~_\^{}])( )?/"\\$1". ( ( defined($2) && length($2) ) ? "\\$2" : '' )/ge;
2505   $value =~ s/([<>])/\$$1\$/g;
2506   $value;
2507 }
2508
2509 #utility methods for print_*
2510
2511 sub _translate_old_latex_format {
2512   warn "_translate_old_latex_format called\n"
2513     if $DEBUG;
2514
2515   my @template = ();
2516   while ( @_ ) {
2517     my $line = shift;
2518
2519     if ( $line =~ /^%%Detail\s*$/ ) {
2520
2521       push @template, q![@--!,
2522                       q!  foreach my $_tr_line (@detail_items) {!,
2523                       q!    if ( scalar ($_tr_item->{'ext_description'} ) ) {!,
2524                       q!      $_tr_line->{'description'} .= !,
2525                       q!        "\\tabularnewline\n~~".!,
2526                       q!        join( "\\tabularnewline\n~~",!,
2527                       q!          @{$_tr_line->{'ext_description'}}!,
2528                       q!        );!,
2529                       q!    }!;
2530
2531       while ( ( my $line_item_line = shift )
2532               !~ /^%%EndDetail\s*$/                            ) {
2533         $line_item_line =~ s/'/\\'/g;    # nice LTS
2534         $line_item_line =~ s/\\/\\\\/g;  # escape quotes and backslashes
2535         $line_item_line =~ s/\$(\w+)/'. \$_tr_line->{$1}. '/g;
2536         push @template, "    \$OUT .= '$line_item_line';";
2537       }
2538
2539       push @template, '}',
2540                       '--@]';
2541
2542     } elsif ( $line =~ /^%%TotalDetails\s*$/ ) {
2543
2544       push @template, '[@--',
2545                       '  foreach my $_tr_line (@total_items) {';
2546
2547       while ( ( my $total_item_line = shift )
2548               !~ /^%%EndTotalDetails\s*$/                      ) {
2549         $total_item_line =~ s/'/\\'/g;    # nice LTS
2550         $total_item_line =~ s/\\/\\\\/g;  # escape quotes and backslashes
2551         $total_item_line =~ s/\$(\w+)/'. \$_tr_line->{$1}. '/g;
2552         push @template, "    \$OUT .= '$total_item_line';";
2553       }
2554
2555       push @template, '}',
2556                       '--@]';
2557
2558     } else {
2559       $line =~ s/\$(\w+)/[\@-- \$$1 --\@]/g;
2560       push @template, $line;
2561     }
2562
2563   }
2564
2565   if ($DEBUG) {
2566     warn "$_\n" foreach @template;
2567   }
2568
2569   (@template);
2570 }
2571
2572 sub terms {
2573   my $self = shift;
2574
2575   #check for an invoice- specific override (eventually)
2576
2577   #check for a customer- specific override
2578   return $self->cust_main->invoice_terms
2579     if $self->cust_main->invoice_terms;
2580
2581   #use configured default
2582   $conf->config('invoice_default_terms');
2583 }
2584
2585 sub due_date {
2586   my $self = shift;
2587   my $duedate = '';
2588   if ( $self->terms =~ /^\s*Net\s*(\d+)\s*$/ ) {
2589     $duedate = $self->_date() + ( $1 * 86400 );
2590   }
2591   $duedate;
2592 }
2593
2594 sub due_date2str {
2595   my $self = shift;
2596   $self->due_date ? time2str(shift, $self->due_date) : '';
2597 }
2598
2599 sub balance_due_msg {
2600   my $self = shift;
2601   my $msg = 'Balance Due';
2602   return $msg unless $self->terms;
2603   if ( $self->due_date ) {
2604     $msg .= ' - Please pay by '. $self->due_date2str('%x');
2605   } elsif ( $self->terms ) {
2606     $msg .= ' - '. $self->terms;
2607   }
2608   $msg;
2609 }
2610
2611 sub balance_due_date {
2612   my $self = shift;
2613   my $duedate = '';
2614   if (    $conf->exists('invoice_default_terms')
2615        && $conf->config('invoice_default_terms')=~ /^\s*Net\s*(\d+)\s*$/ ) {
2616     $duedate = time2str("%m/%d/%Y", $self->_date + ($1*86400) );
2617   }
2618   $duedate;
2619 }
2620
2621 =item invnum_date_pretty
2622
2623 Returns a string with the invoice number and date, for example:
2624 "Invoice #54 (3/20/2008)"
2625
2626 =cut
2627
2628 sub invnum_date_pretty {
2629   my $self = shift;
2630   'Invoice #'. $self->invnum. ' ('. $self->_date_pretty. ')';
2631 }
2632
2633 =item _date_pretty
2634
2635 Returns a string with the date, for example: "3/20/2008"
2636
2637 =cut
2638
2639 sub _date_pretty {
2640   my $self = shift;
2641   time2str('%x', $self->_date);
2642 }
2643
2644 sub _items_sections {
2645   my $self = shift;
2646   my $late = shift;
2647
2648   my %s = ();
2649   my %l = ();
2650
2651   foreach my $cust_bill_pkg ( $self->cust_bill_pkg )
2652   {
2653
2654     if ( $cust_bill_pkg->pkgnum > 0 ) {
2655       my $usage = $cust_bill_pkg->usage;
2656
2657       foreach my $display ($cust_bill_pkg->cust_bill_pkg_display) {
2658         my $desc = $display->section;
2659         my $type = $display->type;
2660
2661         if ( $display->post_total ) {
2662           if (! $type || $type eq 'S') {
2663             $l{$desc} += $cust_bill_pkg->setup
2664               if ( $cust_bill_pkg->setup != 0 );
2665           }
2666
2667           if (! $type) {
2668             $l{$desc} += $cust_bill_pkg->recur
2669               if ( $cust_bill_pkg->recur != 0 );
2670           }
2671
2672           if ($type && $type eq 'R') {
2673             $l{$desc} += $cust_bill_pkg->recur - $usage
2674               if ( $cust_bill_pkg->recur != 0 );
2675           }
2676
2677           if ($type && $type eq 'U') {
2678             $l{$desc} += $usage;
2679           }
2680
2681         } else {
2682           if (! $type || $type eq 'S') {
2683             $s{$desc} += $cust_bill_pkg->setup
2684               if ( $cust_bill_pkg->setup != 0 );
2685           }
2686
2687           if (! $type) {
2688             $s{$desc} += $cust_bill_pkg->recur
2689               if ( $cust_bill_pkg->recur != 0 );
2690           }
2691
2692           if ($type && $type eq 'R') {
2693             $s{$desc} += $cust_bill_pkg->recur - $usage
2694               if ( $cust_bill_pkg->recur != 0 );
2695           }
2696
2697           if ($type && $type eq 'U') {
2698             $s{$desc} += $usage;
2699           }
2700
2701         }
2702
2703       }
2704
2705     }
2706
2707   }
2708
2709   push @$late, map { { 'description' => $_,
2710                        'subtotal'    => $l{$_},
2711                        'post_total'  => 1,
2712                    } } sort keys %l;
2713
2714   map { {'description' => $_, 'subtotal' => $s{$_}} } sort keys %s;
2715
2716 }
2717
2718 sub _items {
2719   my $self = shift;
2720
2721   #my @display = scalar(@_)
2722   #              ? @_
2723   #              : qw( _items_previous _items_pkg );
2724   #              #: qw( _items_pkg );
2725   #              #: qw( _items_previous _items_pkg _items_tax _items_credits _items_payments );
2726   my @display = qw( _items_previous _items_pkg );
2727
2728   my @b = ();
2729   foreach my $display ( @display ) {
2730     push @b, $self->$display(@_);
2731   }
2732   @b;
2733 }
2734
2735 sub _items_previous {
2736   my $self = shift;
2737   my $cust_main = $self->cust_main;
2738   my( $pr_total, @pr_cust_bill ) = $self->previous; #previous balance
2739   my @b = ();
2740   foreach ( @pr_cust_bill ) {
2741     push @b, {
2742       'description' => 'Previous Balance, Invoice #'. $_->invnum.
2743                        ' ('. time2str('%x',$_->_date). ')',
2744       #'pkgpart'     => 'N/A',
2745       'pkgnum'      => 'N/A',
2746       'amount'      => sprintf("%.2f", $_->owed),
2747     };
2748   }
2749   @b;
2750
2751   #{
2752   #    'description'     => 'Previous Balance',
2753   #    #'pkgpart'         => 'N/A',
2754   #    'pkgnum'          => 'N/A',
2755   #    'amount'          => sprintf("%10.2f", $pr_total ),
2756   #    'ext_description' => [ map {
2757   #                                 "Invoice ". $_->invnum.
2758   #                                 " (". time2str("%x",$_->_date). ") ".
2759   #                                 sprintf("%10.2f", $_->owed)
2760   #                         } @pr_cust_bill ],
2761
2762   #};
2763 }
2764
2765 sub _items_pkg {
2766   my $self = shift;
2767   my @cust_bill_pkg = grep { $_->pkgnum } $self->cust_bill_pkg;
2768   $self->_items_cust_bill_pkg(\@cust_bill_pkg, @_);
2769 }
2770
2771 sub _taxsort {
2772   return 0 unless $a cmp $b;
2773   return -1 if $b eq 'Tax';
2774   return 1 if $a eq 'Tax';
2775   return -1 if $b eq 'Other surcharges';
2776   return 1 if $a eq 'Other surcharges';
2777   $a cmp $b;
2778 }
2779
2780 sub _items_tax {
2781   my $self = shift;
2782   my @cust_bill_pkg = sort _taxsort grep { ! $_->pkgnum } $self->cust_bill_pkg;
2783   $self->_items_cust_bill_pkg(\@cust_bill_pkg, @_);
2784 }
2785
2786 sub _items_cust_bill_pkg {
2787   my $self = shift;
2788   my $cust_bill_pkg = shift;
2789   my %opt = @_;
2790
2791   my $format = $opt{format} || '';
2792   my $escape_function = $opt{escape_function} || sub { shift };
2793   my $format_function = $opt{format_function} || '';
2794   my $unsquelched = $opt{unsquelched} || '';
2795   my $section = $opt{section}->{description} if $opt{section};
2796
2797   my @b = ();
2798   foreach my $cust_bill_pkg ( @$cust_bill_pkg )
2799   {
2800     foreach my $display ( grep { defined($section)
2801                                  ? $_->section eq $section
2802                                  : 1
2803                                }
2804                           $cust_bill_pkg->cust_bill_pkg_display
2805                         )
2806     {
2807
2808       my $type = $display->type;
2809
2810       my $cust_pkg = $cust_bill_pkg->cust_pkg;
2811
2812       my $desc = $cust_bill_pkg->desc;
2813       $desc = substr($desc, 0, 50). '...'
2814         if $format eq 'latex' && length($desc) > 50;
2815
2816       my %details_opt = ( 'format'          => $format,
2817                           'escape_function' => $escape_function,
2818                           'format_function' => $format_function,
2819                         );
2820
2821       if ( $cust_bill_pkg->pkgnum > 0 ) {
2822
2823         if ( $cust_bill_pkg->setup != 0 && (!$type || $type eq 'S') ) {
2824
2825           my $description = $desc;
2826           $description .= ' Setup' if $cust_bill_pkg->recur != 0;
2827
2828           my @d = ();
2829           push @d, map &{$escape_function}($_),
2830                        $cust_pkg->h_labels_short($self->_date)
2831             unless $cust_pkg->part_pkg->hide_svc_detail;
2832           push @d, $cust_bill_pkg->details(%details_opt)
2833             if $cust_bill_pkg->recur == 0;
2834
2835           push @b, {
2836             description     => $description,
2837             #pkgpart         => $part_pkg->pkgpart,
2838             pkgnum          => $cust_bill_pkg->pkgnum,
2839             amount          => sprintf("%.2f", $cust_bill_pkg->setup),
2840             unit_amount     => sprintf("%.2f", $cust_bill_pkg->unitsetup),
2841             quantity        => $cust_bill_pkg->quantity,
2842             ext_description => \@d,
2843           };
2844
2845         }
2846
2847         if ( $cust_bill_pkg->recur != 0 &&
2848              ( !$type || $type eq 'R' || $type eq 'U' )
2849            )
2850         {
2851
2852           my $is_summary = $display->summary;
2853           my $description = $is_summary ? "Usage charges" : $desc;
2854
2855           unless ( $conf->exists('disable_line_item_date_ranges') ) {
2856             $description .= " (" . time2str("%x", $cust_bill_pkg->sdate).
2857                             " - ". time2str("%x", $cust_bill_pkg->edate). ")";
2858           }
2859
2860           my @d = ();
2861
2862           #at least until cust_bill_pkg has "past" ranges in addition to
2863           #the "future" sdate/edate ones... see #3032
2864           push @d, map &{$escape_function}($_),
2865                        $cust_pkg->h_labels_short($self->_date)
2866                                                  #$cust_bill_pkg->edate,
2867                                                  #$cust_bill_pkg->sdate)
2868             unless $cust_pkg->part_pkg->hide_svc_detail
2869                 || $cust_bill_pkg->itemdesc
2870                 || $is_summary;
2871
2872           push @d, $cust_bill_pkg->details(%details_opt)
2873             unless ($is_summary || $type && $type eq 'R');
2874
2875           my $amount = 0;
2876           if (!$type) {
2877             $amount = $cust_bill_pkg->recur;
2878           }elsif($type eq 'R') {
2879             $amount = $cust_bill_pkg->recur - $cust_bill_pkg->usage;
2880           }elsif($type eq 'U') {
2881             $amount = $cust_bill_pkg->usage;
2882           }
2883
2884           push @b, {
2885             description     => $description,
2886             #pkgpart         => $part_pkg->pkgpart,
2887             pkgnum          => $cust_bill_pkg->pkgnum,
2888             amount          => sprintf("%.2f", $amount),
2889             unit_amount     => sprintf("%.2f", $cust_bill_pkg->unitrecur),
2890             quantity        => $cust_bill_pkg->quantity,
2891             ext_description => \@d,
2892           } unless ( $type eq 'U' && ! $amount );
2893
2894         }
2895
2896       } else { #pkgnum tax or one-shot line item (??)
2897
2898         if ( $cust_bill_pkg->setup != 0 ) {
2899           push @b, {
2900             'description' => $desc,
2901             'amount'      => sprintf("%.2f", $cust_bill_pkg->setup),
2902           };
2903         }
2904         if ( $cust_bill_pkg->recur != 0 ) {
2905           push @b, {
2906             'description' => "$desc (".
2907                              time2str("%x", $cust_bill_pkg->sdate). ' - '.
2908                              time2str("%x", $cust_bill_pkg->edate). ')',
2909             'amount'      => sprintf("%.2f", $cust_bill_pkg->recur),
2910           };
2911         }
2912
2913       }
2914
2915     }
2916
2917   }
2918
2919   @b;
2920
2921 }
2922
2923 sub _items_credits {
2924   my( $self, %opt ) = @_;
2925   my $trim_len = $opt{'trim_len'} || 60;
2926
2927   my @b;
2928   #credits
2929   foreach ( $self->cust_credited ) {
2930
2931     #something more elaborate if $_->amount ne $_->cust_credit->credited ?
2932
2933     my $reason = substr($_->cust_credit->reason, 0, $trim_len);
2934     $reason .= '...' if length($reason) < length($_->cust_credit->reason);
2935     $reason = " ($reason) " if $reason;
2936
2937     push @b, {
2938       #'description' => 'Credit ref\#'. $_->crednum.
2939       #                 " (". time2str("%x",$_->cust_credit->_date) .")".
2940       #                 $reason,
2941       'description' => 'Credit applied '.
2942                        time2str("%x",$_->cust_credit->_date). $reason,
2943       'amount'      => sprintf("%.2f",$_->amount),
2944     };
2945   }
2946
2947   @b;
2948
2949 }
2950
2951 sub _items_payments {
2952   my $self = shift;
2953
2954   my @b;
2955   #get & print payments
2956   foreach ( $self->cust_bill_pay ) {
2957
2958     #something more elaborate if $_->amount ne ->cust_pay->paid ?
2959
2960     push @b, {
2961       'description' => "Payment received ".
2962                        time2str("%x",$_->cust_pay->_date ),
2963       'amount'      => sprintf("%.2f", $_->amount )
2964     };
2965   }
2966
2967   @b;
2968
2969 }
2970
2971
2972 =back
2973
2974 =head1 SUBROUTINES
2975
2976 =over 4
2977
2978 =item process_reprint
2979
2980 =cut
2981
2982 sub process_reprint {
2983   process_re_X('print', @_);
2984 }
2985
2986 =item process_reemail
2987
2988 =cut
2989
2990 sub process_reemail {
2991   process_re_X('email', @_);
2992 }
2993
2994 =item process_refax
2995
2996 =cut
2997
2998 sub process_refax {
2999   process_re_X('fax', @_);
3000 }
3001
3002 =item process_reftp
3003
3004 =cut
3005
3006 sub process_reftp {
3007   process_re_X('ftp', @_);
3008 }
3009
3010 =item respool
3011
3012 =cut
3013
3014 sub process_respool {
3015   process_re_X('spool', @_);
3016 }
3017
3018 use Storable qw(thaw);
3019 use Data::Dumper;
3020 use MIME::Base64;
3021 sub process_re_X {
3022   my( $method, $job ) = ( shift, shift );
3023   warn "$me process_re_X $method for job $job\n" if $DEBUG;
3024
3025   my $param = thaw(decode_base64(shift));
3026   warn Dumper($param) if $DEBUG;
3027
3028   re_X(
3029     $method,
3030     $job,
3031     %$param,
3032   );
3033
3034 }
3035
3036 sub re_X {
3037   my($method, $job, %param ) = @_;
3038   if ( $DEBUG ) {
3039     warn "re_X $method for job $job with param:\n".
3040          join( '', map { "  $_ => ". $param{$_}. "\n" } keys %param );
3041   }
3042
3043   #some false laziness w/search/cust_bill.html
3044   my $distinct = '';
3045   my $orderby = 'ORDER BY cust_bill._date';
3046
3047   my $extra_sql = ' WHERE '. FS::cust_bill->search_sql(\%param);
3048
3049   my $addl_from = 'LEFT JOIN cust_main USING ( custnum )';
3050
3051   my @cust_bill = qsearch( {
3052     #'select'    => "cust_bill.*",
3053     'table'     => 'cust_bill',
3054     'addl_from' => $addl_from,
3055     'hashref'   => {},
3056     'extra_sql' => $extra_sql,
3057     'order_by'  => $orderby,
3058     'debug' => 1,
3059   } );
3060
3061   $method .= '_invoice' unless $method eq 'email' || $method eq 'print';
3062
3063   warn " $me re_X $method: ". scalar(@cust_bill). " invoices found\n"
3064     if $DEBUG;
3065
3066   my( $num, $last, $min_sec ) = (0, time, 5); #progresbar foo
3067   foreach my $cust_bill ( @cust_bill ) {
3068     $cust_bill->$method();
3069
3070     if ( $job ) { #progressbar foo
3071       $num++;
3072       if ( time - $min_sec > $last ) {
3073         my $error = $job->update_statustext(
3074           int( 100 * $num / scalar(@cust_bill) )
3075         );
3076         die $error if $error;
3077         $last = time;
3078       }
3079     }
3080
3081   }
3082
3083 }
3084
3085 =back
3086
3087 =head1 CLASS METHODS
3088
3089 =over 4
3090
3091 =item owed_sql
3092
3093 Returns an SQL fragment to retreive the amount owed (charged minus credited and paid).
3094
3095 =cut
3096
3097 sub owed_sql {
3098   my $class = shift;
3099   'charged - '. $class->paid_sql. ' - '. $class->credited_sql;
3100 }
3101
3102 =item net_sql
3103
3104 Returns an SQL fragment to retreive the net amount (charged minus credited).
3105
3106 =cut
3107
3108 sub net_sql {
3109   my $class = shift;
3110   'charged - '. $class->credited_sql;
3111 }
3112
3113 =item paid_sql
3114
3115 Returns an SQL fragment to retreive the amount paid against this invoice.
3116
3117 =cut
3118
3119 sub paid_sql {
3120   #my $class = shift;
3121   "( SELECT COALESCE(SUM(amount),0) FROM cust_bill_pay
3122        WHERE cust_bill.invnum = cust_bill_pay.invnum   )";
3123 }
3124
3125 =item credited_sql
3126
3127 Returns an SQL fragment to retreive the amount credited against this invoice.
3128
3129 =cut
3130
3131 sub credited_sql {
3132   #my $class = shift;
3133   "( SELECT COALESCE(SUM(amount),0) FROM cust_credit_bill
3134        WHERE cust_bill.invnum = cust_credit_bill.invnum   )";
3135 }
3136
3137 =item search_sql HASHREF
3138
3139 Class method which returns an SQL WHERE fragment to search for parameters
3140 specified in HASHREF.  Valid parameters are
3141
3142 =over 4
3143
3144 =item begin
3145
3146 Epoch date (UNIX timestamp) setting a lower bound for _date values
3147
3148 =item end
3149
3150 Epoch date (UNIX timestamp) setting an upper bound for _date values
3151
3152 =item invnum_min
3153
3154 =item invnum_max
3155
3156 =item agentnum
3157
3158 =item owed
3159
3160 =item net
3161
3162 =item days
3163
3164 =item newest_percust
3165
3166 =back
3167
3168 Note: validates all passed-in data; i.e. safe to use with unchecked CGI params.
3169
3170 =cut
3171
3172 sub search_sql {
3173   my($class, $param) = @_;
3174   if ( $DEBUG ) {
3175     warn "$me search_sql called with params: \n".
3176          join("\n", map { "  $_: ". $param->{$_} } keys %$param ). "\n";
3177   }
3178
3179   my @search = ();
3180
3181   if ( $param->{'begin'} =~ /^(\d+)$/ ) {
3182     push @search, "cust_bill._date >= $1";
3183   }
3184   if ( $param->{'end'} =~ /^(\d+)$/ ) {
3185     push @search, "cust_bill._date < $1";
3186   }
3187   if ( $param->{'invnum_min'} =~ /^(\d+)$/ ) {
3188     push @search, "cust_bill.invnum >= $1";
3189   }
3190   if ( $param->{'invnum_max'} =~ /^(\d+)$/ ) {
3191     push @search, "cust_bill.invnum <= $1";
3192   }
3193   if ( $param->{'agentnum'} =~ /^(\d+)$/ ) {
3194     push @search, "cust_main.agentnum = $1";
3195   }
3196
3197   push @search, '0 != '. FS::cust_bill->owed_sql
3198     if $param->{'open'};
3199
3200   push @search, '0 != '. FS::cust_bill->net_sql
3201     if $param->{'net'};
3202
3203   push @search, "cust_bill._date < ". (time-86400*$param->{'days'})
3204     if $param->{'days'};
3205
3206   if ( $param->{'newest_percust'} ) {
3207
3208     #$distinct = 'DISTINCT ON ( cust_bill.custnum )';
3209     #$orderby = 'ORDER BY cust_bill.custnum ASC, cust_bill._date DESC';
3210
3211     my @newest_where = map { my $x = $_;
3212                              $x =~ s/\bcust_bill\./newest_cust_bill./g;
3213                              $x;
3214                            }
3215                            grep ! /^cust_main./, @search;
3216     my $newest_where = scalar(@newest_where)
3217                          ? ' AND '. join(' AND ', @newest_where)
3218                          : '';
3219
3220
3221     push @search, "cust_bill._date = (
3222       SELECT(MAX(newest_cust_bill._date)) FROM cust_bill AS newest_cust_bill
3223         WHERE newest_cust_bill.custnum = cust_bill.custnum
3224           $newest_where
3225     )";
3226
3227   }
3228
3229   my $curuser = $FS::CurrentUser::CurrentUser;
3230   if ( $curuser->username eq 'fs_queue'
3231        && $param->{'CurrentUser'} =~ /^(\w+)$/ ) {
3232     my $username = $1;
3233     my $newuser = qsearchs('access_user', {
3234       'username' => $username,
3235       'disabled' => '',
3236     } );
3237     if ( $newuser ) {
3238       $curuser = $newuser;
3239     } else {
3240       warn "$me WARNING: (fs_queue) can't find CurrentUser $username\n";
3241     }
3242   }
3243
3244   push @search, $curuser->agentnums_sql;
3245
3246   join(' AND ', @search );
3247
3248 }
3249
3250 =back
3251
3252 =head1 BUGS
3253
3254 The delete method.
3255
3256 =head1 SEE ALSO
3257
3258 L<FS::Record>, L<FS::cust_main>, L<FS::cust_bill_pay>, L<FS::cust_pay>,
3259 L<FS::cust_bill_pkg>, L<FS::cust_bill_credit>, schema.html from the base
3260 documentation.
3261
3262 =cut
3263
3264 1;
3265