FS/FS/cust_bill.pm

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