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