FS/FS/cust_bill.pm

   1 package FS::cust_bill;
   2 use base qw( FS::Template_Mixin FS::cust_main_Mixin FS::Record );
   3
   4 use strict;
   5 use vars qw( $DEBUG $me );
   6              # but NOT $conf
   7 use Fcntl qw(:flock); #for spool_csv
   8 use Cwd;
   9 use List::Util qw(min max sum);
  10 use Date::Format;
  11 use File::Temp 0.14;
  12 use HTML::Entities;
  13 use Storable qw( freeze thaw );
  14 use GD::Barcode;
  15 use FS::UID qw( datasrc );
  16 use FS::Misc qw( send_email send_fax do_print );
  17 use FS::Record qw( qsearch qsearchs dbh );
  18 use FS::cust_statement;
  19 use FS::cust_bill_pkg;
  20 use FS::cust_bill_pkg_display;
  21 use FS::cust_bill_pkg_detail;
  22 use FS::cust_credit;
  23 use FS::cust_pay;
  24 use FS::cust_pkg;
  25 use FS::cust_credit_bill;
  26 use FS::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::part_bill_event;
  32 use FS::payby;
  33 use FS::bill_batch;
  34 use FS::cust_bill_batch;
  35 use FS::cust_bill_pay_pkg;
  36 use FS::cust_credit_bill_pkg;
  37 use FS::discount_plan;
  38 use FS::cust_bill_void;
  39 use FS::L10N;
  40
  41 $DEBUG = 0;
  42 $me = '[FS::cust_bill]';
  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' => $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 Regular fields
  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 invoice_terms - optional terms override for this specific invoice
  97
  98 =back
  99
 100 Customer info at invoice generation time
 101
 102 =over 4
 103
 104 =item billing_balance - the customer's balance at the time the invoice was
 105 generated (not including charges on this invoice)
 106
 107 =item previous_balance - the billing_balance of this customer's previous
 108 invoice plus the charges on that invoice
 109
 110 =back
 111
 112 Deprecated
 113
 114 =over 4
 115
 116 =item printed - deprecated
 117
 118 =back
 119
 120 Specific use cases
 121
 122 =over 4
 123
 124 =item closed - books closed flag, empty or `Y'
 125
 126 =item statementnum - invoice aggregation (see L<FS::cust_statement>)
 127
 128 =item agent_invid - legacy invoice number
 129
 130 =item promised_date - customer promised payment date, for collection
 131
 132 =back
 133
 134 =head1 METHODS
 135
 136 =over 4
 137
 138 =item new HASHREF
 139
 140 Creates a new invoice.  To add the invoice to the database, see L<"insert">.
 141 Invoices are normally created by calling the bill method of a customer object
 142 (see L<FS::cust_main>).
 143
 144 =cut
 145
 146 sub table { 'cust_bill'; }
 147
 148 # should be the ONLY occurrence of "Invoice" in invoice rendering code.
 149 # (except email_subject and invnum_date_pretty)
 150 sub notice_name {
 151   my $self = shift;
 152   $self->conf->config('notice_name') || 'Invoice'
 153 }
 154
 155 sub cust_linked { $_[0]->cust_main_custnum || $_[0]->custnum }
 156 sub cust_unlinked_msg {
 157   my $self = shift;
 158   "WARNING: can't find cust_main.custnum ". $self->custnum.
 159   ' (cust_bill.invnum '. $self->invnum. ')';
 160 }
 161
 162 =item insert
 163
 164 Adds this invoice to the database ("Posts" the invoice).  If there is an error,
 165 returns the error, otherwise returns false.
 166
 167 =cut
 168
 169 sub insert {
 170   my $self = shift;
 171   warn "$me insert called\n" if $DEBUG;
 172
 173   local $SIG{HUP} = 'IGNORE';
 174   local $SIG{INT} = 'IGNORE';
 175   local $SIG{QUIT} = 'IGNORE';
 176   local $SIG{TERM} = 'IGNORE';
 177   local $SIG{TSTP} = 'IGNORE';
 178   local $SIG{PIPE} = 'IGNORE';
 179
 180   my $oldAutoCommit = $FS::UID::AutoCommit;
 181   local $FS::UID::AutoCommit = 0;
 182   my $dbh = dbh;
 183
 184   my $error = $self->SUPER::insert;
 185   if ( $error ) {
 186     $dbh->rollback if $oldAutoCommit;
 187     return $error;
 188   }
 189
 190   if ( $self->get('cust_bill_pkg') ) {
 191     foreach my $cust_bill_pkg ( @{$self->get('cust_bill_pkg')} ) {
 192       $cust_bill_pkg->invnum($self->invnum);
 193       my $error = $cust_bill_pkg->insert;
 194       if ( $error ) {
 195         $dbh->rollback if $oldAutoCommit;
 196         return "can't create invoice line item: $error";
 197       }
 198     }
 199   }
 200
 201   $dbh->commit or die $dbh->errstr if $oldAutoCommit;
 202   '';
 203
 204 }
 205
 206 =item void
 207
 208 Voids this invoice: deletes the invoice and adds a record of the voided invoice
 209 to the FS::cust_bill_void table (and related tables starting from
 210 FS::cust_bill_pkg_void).
 211
 212 =cut
 213
 214 sub void {
 215   my $self = shift;
 216   my $reason = scalar(@_) ? shift : '';
 217
 218   local $SIG{HUP} = 'IGNORE';
 219   local $SIG{INT} = 'IGNORE';
 220   local $SIG{QUIT} = 'IGNORE';
 221   local $SIG{TERM} = 'IGNORE';
 222   local $SIG{TSTP} = 'IGNORE';
 223   local $SIG{PIPE} = 'IGNORE';
 224
 225   my $oldAutoCommit = $FS::UID::AutoCommit;
 226   local $FS::UID::AutoCommit = 0;
 227   my $dbh = dbh;
 228
 229   my $cust_bill_void = new FS::cust_bill_void ( {
 230     map { $_ => $self->get($_) } $self->fields
 231   } );
 232   $cust_bill_void->reason($reason);
 233   my $error = $cust_bill_void->insert;
 234   if ( $error ) {
 235     $dbh->rollback if $oldAutoCommit;
 236     return $error;
 237   }
 238
 239   foreach my $cust_bill_pkg ( $self->cust_bill_pkg ) {
 240     my $error = $cust_bill_pkg->void($reason);
 241     if ( $error ) {
 242       $dbh->rollback if $oldAutoCommit;
 243       return $error;
 244     }
 245   }
 246
 247   $error = $self->delete;
 248   if ( $error ) {
 249     $dbh->rollback if $oldAutoCommit;
 250     return $error;
 251   }
 252
 253   $dbh->commit or die $dbh->errstr if $oldAutoCommit;
 254
 255   '';
 256
 257 }
 258
 259 =item delete
 260
 261 This method now works but you probably shouldn't use it.  Instead, apply a
 262 credit against the invoice, or use the new void method.
 263
 264 Using this method to delete invoices outright is really, really bad.  There
 265 would be no record you ever posted this invoice, and there are no check to
 266 make sure charged = 0 or that there are no associated cust_bill_pkg records.
 267
 268 Really, don't use it.
 269
 270 =cut
 271
 272 sub delete {
 273   my $self = shift;
 274   return "Can't delete closed invoice" if $self->closed =~ /^Y/i;
 275
 276   local $SIG{HUP} = 'IGNORE';
 277   local $SIG{INT} = 'IGNORE';
 278   local $SIG{QUIT} = 'IGNORE';
 279   local $SIG{TERM} = 'IGNORE';
 280   local $SIG{TSTP} = 'IGNORE';
 281   local $SIG{PIPE} = 'IGNORE';
 282
 283   my $oldAutoCommit = $FS::UID::AutoCommit;
 284   local $FS::UID::AutoCommit = 0;
 285   my $dbh = dbh;
 286
 287   foreach my $table (qw(
 288     cust_bill_event
 289     cust_event
 290     cust_credit_bill
 291     cust_bill_pay
 292     cust_pay_batch
 293     cust_bill_pay_batch
 294     cust_bill_batch
 295     cust_bill_pkg
 296   )) {
 297
 298     foreach my $linked ( $self->$table() ) {
 299       my $error = $linked->delete;
 300       if ( $error ) {
 301         $dbh->rollback if $oldAutoCommit;
 302         return $error;
 303       }
 304     }
 305
 306   }
 307
 308   my $error = $self->SUPER::delete(@_);
 309   if ( $error ) {
 310     $dbh->rollback if $oldAutoCommit;
 311     return $error;
 312   }
 313
 314   $dbh->commit or die $dbh->errstr if $oldAutoCommit;
 315
 316   '';
 317
 318 }
 319
 320 =item replace [ OLD_RECORD ]
 321
 322 You can, but probably shouldn't modify invoices...
 323
 324 Replaces the OLD_RECORD with this one in the database, or, if OLD_RECORD is not
 325 supplied, replaces this record.  If there is an error, returns the error,
 326 otherwise returns false.
 327
 328 =cut
 329
 330 #replace can be inherited from Record.pm
 331
 332 # replace_check is now the preferred way to #implement replace data checks
 333 # (so $object->replace() works without an argument)
 334
 335 sub replace_check {
 336   my( $new, $old ) = ( shift, shift );
 337   return "Can't modify closed invoice" if $old->closed =~ /^Y/i;
 338   #return "Can't change _date!" unless $old->_date eq $new->_date;
 339   return "Can't change _date" unless $old->_date == $new->_date;
 340   return "Can't change charged" unless $old->charged == $new->charged
 341                                     || $old->charged == 0
 342                                     || $new->{'Hash'}{'cc_surcharge_replace_hack'};
 343
 344   '';
 345 }
 346
 347
 348 =item add_cc_surcharge
 349
 350 Giant hack
 351
 352 =cut
 353
 354 sub add_cc_surcharge {
 355     my ($self, $pkgnum, $amount) = (shift, shift, shift);
 356
 357     my $error;
 358     my $cust_bill_pkg = new FS::cust_bill_pkg({
 359                                     'invnum' => $self->invnum,
 360                                     'pkgnum' => $pkgnum,
 361                                     'setup' => $amount,
 362                         });
 363     $error = $cust_bill_pkg->insert;
 364     return $error if $error;
 365
 366     $self->{'Hash'}{'cc_surcharge_replace_hack'} = 1;
 367     $self->charged($self->charged+$amount);
 368     $error = $self->replace;
 369     return $error if $error;
 370
 371     $self->apply_payments_and_credits;
 372 }
 373
 374
 375 =item check
 376
 377 Checks all fields to make sure this is a valid invoice.  If there is an error,
 378 returns the error, otherwise returns false.  Called by the insert and replace
 379 methods.
 380
 381 =cut
 382
 383 sub check {
 384   my $self = shift;
 385
 386   my $error =
 387     $self->ut_numbern('invnum')
 388     || $self->ut_foreign_key('custnum', 'cust_main', 'custnum' )
 389     || $self->ut_numbern('_date')
 390     || $self->ut_money('charged')
 391     || $self->ut_numbern('printed')
 392     || $self->ut_enum('closed', [ '', 'Y' ])
 393     || $self->ut_foreign_keyn('statementnum', 'cust_statement', 'statementnum' )
 394     || $self->ut_numbern('agent_invid') #varchar?
 395   ;
 396   return $error if $error;
 397
 398   $self->_date(time) unless $self->_date;
 399
 400   $self->printed(0) if $self->printed eq '';
 401
 402   $self->SUPER::check;
 403 }
 404
 405 =item display_invnum
 406
 407 Returns the displayed invoice number for this invoice: agent_invid if
 408 cust_bill-default_agent_invid is set and it has a value, invnum otherwise.
 409
 410 =cut
 411
 412 sub display_invnum {
 413   my $self = shift;
 414   if ( $self->agent_invid
 415          && FS::Conf->new->exists('cust_bill-default_agent_invid') ) {
 416     return $self->agent_invid;
 417   } else {
 418     return $self->invnum;
 419   }
 420 }
 421
 422 =item previous_bill
 423
 424 Returns the customer's last invoice before this one.
 425
 426 =cut
 427
 428 sub previous_bill {
 429   my $self = shift;
 430   if ( !$self->get('previous_bill') ) {
 431     $self->set('previous_bill', qsearchs({
 432           'table'     => 'cust_bill',
 433           'hashref'   => { 'custnum'  => $self->custnum,
 434                            '_date'    => { op=>'<', value=>$self->_date } },
 435           'order_by'  => 'ORDER BY _date DESC LIMIT 1',
 436     }) );
 437   }
 438   $self->get('previous_bill');
 439 }
 440
 441 =item previous
 442
 443 Returns a list consisting of the total previous balance for this customer,
 444 followed by the previous outstanding invoices (as FS::cust_bill objects also).
 445
 446 =cut
 447
 448 sub previous {
 449   my $self = shift;
 450   my $total = 0;
 451   my @cust_bill = sort { $a->_date <=> $b->_date }
 452     grep { $_->owed != 0 }
 453       qsearch( 'cust_bill', { 'custnum' => $self->custnum,
 454                               #'_date'   => { op=>'<', value=>$self->_date },
 455                               'invnum'   => { op=>'<', value=>$self->invnum },
 456                             } )
 457   ;
 458   foreach ( @cust_bill ) { $total += $_->owed; }
 459   $total, @cust_bill;
 460 }
 461
 462 =item enable_previous
 463
 464 Whether to show the 'Previous Charges' section when printing this invoice.
 465 The negation of the 'disable_previous_balance' config setting.
 466
 467 =cut
 468
 469 sub enable_previous {
 470   my $self = shift;
 471   my $agentnum = $self->cust_main->agentnum;
 472   !$self->conf->exists('disable_previous_balance', $agentnum);
 473 }
 474
 475 =item cust_bill_pkg
 476
 477 Returns the line items (see L<FS::cust_bill_pkg>) for this invoice.
 478
 479 =cut
 480
 481 sub cust_bill_pkg {
 482   my $self = shift;
 483   qsearch(
 484     { 'table'    => 'cust_bill_pkg',
 485       'hashref'  => { 'invnum' => $self->invnum },
 486       'order_by' => 'ORDER BY billpkgnum', #important?  otherwise we could use
 487                                            # the AUTLOADED FK search.  or should
 488                                            # that default to ORDER by the pkey?
 489     }
 490   );
 491 }
 492
 493 =item cust_bill_pkg_pkgnum PKGNUM
 494
 495 Returns the line items (see L<FS::cust_bill_pkg>) for this invoice and
 496 specified pkgnum.
 497
 498 =cut
 499
 500 sub cust_bill_pkg_pkgnum {
 501   my( $self, $pkgnum ) = @_;
 502   qsearch(
 503     { 'table'    => 'cust_bill_pkg',
 504       'hashref'  => { 'invnum' => $self->invnum,
 505                       'pkgnum' => $pkgnum,
 506                     },
 507       'order_by' => 'ORDER BY billpkgnum',
 508     }
 509   );
 510 }
 511
 512 =item cust_pkg
 513
 514 Returns the packages (see L<FS::cust_pkg>) corresponding to the line items for
 515 this invoice.
 516
 517 =cut
 518
 519 sub cust_pkg {
 520   my $self = shift;
 521   my @cust_pkg = map { $_->pkgnum > 0 ? $_->cust_pkg : () }
 522                      $self->cust_bill_pkg;
 523   my %saw = ();
 524   grep { ! $saw{$_->pkgnum}++ } @cust_pkg;
 525 }
 526
 527 =item no_auto
 528
 529 Returns true if any of the packages (or their definitions) corresponding to the
 530 line items for this invoice have the no_auto flag set.
 531
 532 =cut
 533
 534 sub no_auto {
 535   my $self = shift;
 536   grep { $_->no_auto || $_->part_pkg->no_auto } $self->cust_pkg;
 537 }
 538
 539 =item open_cust_bill_pkg
 540
 541 Returns the open line items for this invoice.
 542
 543 Note that cust_bill_pkg with both setup and recur fees are returned as two
 544 separate line items, each with only one fee.
 545
 546 =cut
 547
 548 # modeled after cust_main::open_cust_bill
 549 sub open_cust_bill_pkg {
 550   my $self = shift;
 551
 552   # grep { $_->owed > 0 } $self->cust_bill_pkg
 553
 554   my %other = ( 'recur' => 'setup',
 555                 'setup' => 'recur', );
 556   my @open = ();
 557   foreach my $field ( qw( recur setup )) {
 558     push @open, map  { $_->set( $other{$field}, 0 ); $_; }
 559                 grep { $_->owed($field) > 0 }
 560                 $self->cust_bill_pkg;
 561   }
 562
 563   @open;
 564 }
 565
 566 =item cust_bill_event
 567
 568 Returns the completed invoice events (deprecated, old-style events - see L<FS::cust_bill_event>) for this invoice.
 569
 570 =cut
 571
 572 sub cust_bill_event {
 573   my $self = shift;
 574   qsearch( 'cust_bill_event', { 'invnum' => $self->invnum } );
 575 }
 576
 577 =item num_cust_bill_event
 578
 579 Returns the number of completed invoice events (deprecated, old-style events - see L<FS::cust_bill_event>) for this invoice.
 580
 581 =cut
 582
 583 sub num_cust_bill_event {
 584   my $self = shift;
 585   my $sql =
 586     "SELECT COUNT(*) FROM cust_bill_event WHERE invnum = ?";
 587   my $sth = dbh->prepare($sql) or die  dbh->errstr. " preparing $sql";
 588   $sth->execute($self->invnum) or die $sth->errstr. " executing $sql";
 589   $sth->fetchrow_arrayref->[0];
 590 }
 591
 592 =item cust_event
 593
 594 Returns the new-style customer billing events (see L<FS::cust_event>) for this invoice.
 595
 596 =cut
 597
 598 #false laziness w/cust_pkg.pm
 599 sub cust_event {
 600   my $self = shift;
 601   qsearch({
 602     'table'     => 'cust_event',
 603     'addl_from' => 'JOIN part_event USING ( eventpart )',
 604     'hashref'   => { 'tablenum' => $self->invnum },
 605     'extra_sql' => " AND eventtable = 'cust_bill' ",
 606   });
 607 }
 608
 609 =item num_cust_event
 610
 611 Returns the number of new-style customer billing events (see L<FS::cust_event>) for this invoice.
 612
 613 =cut
 614
 615 #false laziness w/cust_pkg.pm
 616 sub num_cust_event {
 617   my $self = shift;
 618   my $sql =
 619     "SELECT COUNT(*) FROM cust_event JOIN part_event USING ( eventpart ) ".
 620     "  WHERE tablenum = ? AND eventtable = 'cust_bill'";
 621   my $sth = dbh->prepare($sql) or die  dbh->errstr. " preparing $sql";
 622   $sth->execute($self->invnum) or die $sth->errstr. " executing $sql";
 623   $sth->fetchrow_arrayref->[0];
 624 }
 625
 626 =item cust_main
 627
 628 Returns the customer (see L<FS::cust_main>) for this invoice.
 629
 630 =item cust_suspend_if_balance_over AMOUNT
 631
 632 Suspends the customer associated with this invoice if the total amount owed on
 633 this invoice and all older invoices is greater than the specified amount.
 634
 635 Returns a list: an empty list on success or a list of errors.
 636
 637 =cut
 638
 639 sub cust_suspend_if_balance_over {
 640   my( $self, $amount ) = ( shift, shift );
 641   my $cust_main = $self->cust_main;
 642   if ( $cust_main->total_owed_date($self->_date) < $amount ) {
 643     return ();
 644   } else {
 645     $cust_main->suspend(@_);
 646   }
 647 }
 648
 649 =item cust_bill_pay
 650
 651 Returns all payment applications (see L<FS::cust_bill_pay>) for this invoice.
 652
 653 =cut
 654
 655 sub cust_bill_pay {
 656   my $self = shift;
 657   map { $_ } #return $self->num_cust_bill_pay unless wantarray;
 658   sort { $a->_date <=> $b->_date }
 659     qsearch( 'cust_bill_pay', { 'invnum' => $self->invnum } );
 660 }
 661
 662 =item cust_credited
 663
 664 =item cust_credit_bill
 665
 666 Returns all applied credits (see L<FS::cust_credit_bill>) for this invoice.
 667
 668 =cut
 669
 670 sub cust_credited {
 671   my $self = shift;
 672   map { $_ } #return $self->num_cust_credit_bill unless wantarray;
 673   sort { $a->_date <=> $b->_date }
 674     qsearch( 'cust_credit_bill', { 'invnum' => $self->invnum } )
 675   ;
 676 }
 677
 678 sub cust_credit_bill {
 679   shift->cust_credited(@_);
 680 }
 681
 682 #=item cust_bill_pay_pkgnum PKGNUM
 683 #
 684 #Returns all payment applications (see L<FS::cust_bill_pay>) for this invoice
 685 #with matching pkgnum.
 686 #
 687 #=cut
 688 #
 689 #sub cust_bill_pay_pkgnum {
 690 #  my( $self, $pkgnum ) = @_;
 691 #  map { $_ } #return $self->num_cust_bill_pay_pkgnum($pkgnum) unless wantarray;
 692 #  sort { $a->_date <=> $b->_date }
 693 #    qsearch( 'cust_bill_pay', { 'invnum' => $self->invnum,
 694 #                                'pkgnum' => $pkgnum,
 695 #                              }
 696 #           );
 697 #}
 698
 699 =item cust_bill_pay_pkg PKGNUM
 700
 701 Returns all payment applications (see L<FS::cust_bill_pay>) for this invoice
 702 applied against the matching pkgnum.
 703
 704 =cut
 705
 706 sub cust_bill_pay_pkg {
 707   my( $self, $pkgnum ) = @_;
 708
 709   qsearch({
 710     'select'    => 'cust_bill_pay_pkg.*',
 711     'table'     => 'cust_bill_pay_pkg',
 712     'addl_from' => ' LEFT JOIN cust_bill_pay USING ( billpaynum ) '.
 713                    ' LEFT JOIN cust_bill_pkg USING ( billpkgnum ) ',
 714     'extra_sql' => ' WHERE cust_bill_pkg.invnum = '. $self->invnum.
 715                    "   AND cust_bill_pkg.pkgnum = $pkgnum",
 716   });
 717
 718 }
 719
 720 #=item cust_credited_pkgnum PKGNUM
 721 #
 722 #=item cust_credit_bill_pkgnum PKGNUM
 723 #
 724 #Returns all applied credits (see L<FS::cust_credit_bill>) for this invoice
 725 #with matching pkgnum.
 726 #
 727 #=cut
 728 #
 729 #sub cust_credited_pkgnum {
 730 #  my( $self, $pkgnum ) = @_;
 731 #  map { $_ } #return $self->num_cust_credit_bill_pkgnum($pkgnum) unless wantarray;
 732 #  sort { $a->_date <=> $b->_date }
 733 #    qsearch( 'cust_credit_bill', { 'invnum' => $self->invnum,
 734 #                                   'pkgnum' => $pkgnum,
 735 #                                 }
 736 #           );
 737 #}
 738 #
 739 #sub cust_credit_bill_pkgnum {
 740 #  shift->cust_credited_pkgnum(@_);
 741 #}
 742
 743 =item cust_credit_bill_pkg PKGNUM
 744
 745 Returns all credit applications (see L<FS::cust_credit_bill>) for this invoice
 746 applied against the matching pkgnum.
 747
 748 =cut
 749
 750 sub cust_credit_bill_pkg {
 751   my( $self, $pkgnum ) = @_;
 752
 753   qsearch({
 754     'select'    => 'cust_credit_bill_pkg.*',
 755     'table'     => 'cust_credit_bill_pkg',
 756     'addl_from' => ' LEFT JOIN cust_credit_bill USING ( creditbillnum ) '.
 757                    ' LEFT JOIN cust_bill_pkg    USING ( billpkgnum    ) ',
 758     'extra_sql' => ' WHERE cust_bill_pkg.invnum = '. $self->invnum.
 759                    "   AND cust_bill_pkg.pkgnum = $pkgnum",
 760   });
 761
 762 }
 763
 764 =item cust_bill_batch
 765
 766 Returns all invoice batch records (L<FS::cust_bill_batch>) for this invoice.
 767
 768 =cut
 769
 770 sub cust_bill_batch {
 771   my $self = shift;
 772   qsearch('cust_bill_batch', { 'invnum' => $self->invnum });
 773 }
 774
 775 =item discount_plans
 776
 777 Returns all discount plans (L<FS::discount_plan>) for this invoice, as a
 778 hash keyed by term length.
 779
 780 =cut
 781
 782 sub discount_plans {
 783   my $self = shift;
 784   FS::discount_plan->all($self);
 785 }
 786
 787 =item tax
 788
 789 Returns the tax amount (see L<FS::cust_bill_pkg>) for this invoice.
 790
 791 =cut
 792
 793 sub tax {
 794   my $self = shift;
 795   my $total = 0;
 796   my @taxlines = qsearch( 'cust_bill_pkg', { 'invnum' => $self->invnum ,
 797                                              'pkgnum' => 0 } );
 798   foreach (@taxlines) { $total += $_->setup; }
 799   $total;
 800 }
 801
 802 =item owed
 803
 804 Returns the amount owed (still outstanding) on this invoice, which is charged
 805 minus all payment applications (see L<FS::cust_bill_pay>) and credit
 806 applications (see L<FS::cust_credit_bill>).
 807
 808 =cut
 809
 810 sub owed {
 811   my $self = shift;
 812   my $balance = $self->charged;
 813   $balance -= $_->amount foreach ( $self->cust_bill_pay );
 814   $balance -= $_->amount foreach ( $self->cust_credited );
 815   $balance = sprintf( "%.2f", $balance);
 816   $balance =~ s/^\-0\.00$/0.00/; #yay ieee fp
 817   $balance;
 818 }
 819
 820 sub owed_pkgnum {
 821   my( $self, $pkgnum ) = @_;
 822
 823   #my $balance = $self->charged;
 824   my $balance = 0;
 825   $balance += $_->setup + $_->recur for $self->cust_bill_pkg_pkgnum($pkgnum);
 826
 827   $balance -= $_->amount            for $self->cust_bill_pay_pkg($pkgnum);
 828   $balance -= $_->amount            for $self->cust_credit_bill_pkg($pkgnum);
 829
 830   $balance = sprintf( "%.2f", $balance);
 831   $balance =~ s/^\-0\.00$/0.00/; #yay ieee fp
 832   $balance;
 833 }
 834
 835 =item hide
 836
 837 Returns true if this invoice should be hidden.  See the
 838 selfservice-hide_invoices-taxclass configuraiton setting.
 839
 840 =cut
 841
 842 sub hide {
 843   my $self = shift;
 844   my $conf = $self->conf;
 845   my $hide_taxclass = $conf->config('selfservice-hide_invoices-taxclass')
 846     or return '';
 847   my @cust_bill_pkg = $self->cust_bill_pkg;
 848   my @part_pkg = grep $_, map $_->part_pkg, @cust_bill_pkg;
 849   ! grep { $_->taxclass ne $hide_taxclass } @part_pkg;
 850 }
 851
 852 =item apply_payments_and_credits [ OPTION => VALUE ... ]
 853
 854 Applies unapplied payments and credits to this invoice.
 855
 856 A hash of optional arguments may be passed.  Currently "manual" is supported.
 857 If true, a payment receipt is sent instead of a statement when
 858 'payment_receipt_email' configuration option is set.
 859
 860 If there is an error, returns the error, otherwise returns false.
 861
 862 =cut
 863
 864 sub apply_payments_and_credits {
 865   my( $self, %options ) = @_;
 866   my $conf = $self->conf;
 867
 868   local $SIG{HUP} = 'IGNORE';
 869   local $SIG{INT} = 'IGNORE';
 870   local $SIG{QUIT} = 'IGNORE';
 871   local $SIG{TERM} = 'IGNORE';
 872   local $SIG{TSTP} = 'IGNORE';
 873   local $SIG{PIPE} = 'IGNORE';
 874
 875   my $oldAutoCommit = $FS::UID::AutoCommit;
 876   local $FS::UID::AutoCommit = 0;
 877   my $dbh = dbh;
 878
 879   $self->select_for_update; #mutex
 880
 881   my @payments = grep { $_->unapplied > 0 } $self->cust_main->cust_pay;
 882   my @credits  = grep { $_->credited > 0 } $self->cust_main->cust_credit;
 883
 884   if ( $conf->exists('pkg-balances') ) {
 885     # limit @payments & @credits to those w/ a pkgnum grepped from $self
 886     my %pkgnums = map { $_ => 1 } map $_->pkgnum, $self->cust_bill_pkg;
 887     @payments = grep { ! $_->pkgnum || $pkgnums{$_->pkgnum} } @payments;
 888     @credits  = grep { ! $_->pkgnum || $pkgnums{$_->pkgnum} } @credits;
 889   }
 890
 891   while ( $self->owed > 0 and ( @payments || @credits ) ) {
 892
 893     my $app = '';
 894     if ( @payments && @credits ) {
 895
 896       #decide which goes first by weight of top (unapplied) line item
 897
 898       my @open_lineitems = $self->open_cust_bill_pkg;
 899
 900       my $max_pay_weight =
 901         max( map  { $_->part_pkg->pay_weight || 0 }
 902              grep { $_ }
 903              map  { $_->cust_pkg }
 904                   @open_lineitems
 905            );
 906       my $max_credit_weight =
 907         max( map  { $_->part_pkg->credit_weight || 0 }
 908              grep { $_ }
 909              map  { $_->cust_pkg }
 910                   @open_lineitems
 911            );
 912
 913       #if both are the same... payments first?  it has to be something
 914       if ( $max_pay_weight >= $max_credit_weight ) {
 915         $app = 'pay';
 916       } else {
 917         $app = 'credit';
 918       }
 919
 920     } elsif ( @payments ) {
 921       $app = 'pay';
 922     } elsif ( @credits ) {
 923       $app = 'credit';
 924     } else {
 925       die "guru meditation #12 and 35";
 926     }
 927
 928     my $unapp_amount;
 929     if ( $app eq 'pay' ) {
 930
 931       my $payment = shift @payments;
 932       $unapp_amount = $payment->unapplied;
 933       $app = new FS::cust_bill_pay { 'paynum'  => $payment->paynum };
 934       $app->pkgnum( $payment->pkgnum )
 935         if $conf->exists('pkg-balances') && $payment->pkgnum;
 936
 937     } elsif ( $app eq 'credit' ) {
 938
 939       my $credit = shift @credits;
 940       $unapp_amount = $credit->credited;
 941       $app = new FS::cust_credit_bill { 'crednum' => $credit->crednum };
 942       $app->pkgnum( $credit->pkgnum )
 943         if $conf->exists('pkg-balances') && $credit->pkgnum;
 944
 945     } else {
 946       die "guru meditation #12 and 35";
 947     }
 948
 949     my $owed;
 950     if ( $conf->exists('pkg-balances') && $app->pkgnum ) {
 951       warn "owed_pkgnum ". $app->pkgnum;
 952       $owed = $self->owed_pkgnum($app->pkgnum);
 953     } else {
 954       $owed = $self->owed;
 955     }
 956     next unless $owed > 0;
 957
 958     warn "min ( $unapp_amount, $owed )\n" if $DEBUG;
 959     $app->amount( sprintf('%.2f', min( $unapp_amount, $owed ) ) );
 960
 961     $app->invnum( $self->invnum );
 962
 963     my $error = $app->insert(%options);
 964     if ( $error ) {
 965       $dbh->rollback if $oldAutoCommit;
 966       return "Error inserting ". $app->table. " record: $error";
 967     }
 968     die $error if $error;
 969
 970   }
 971
 972   $dbh->commit or die $dbh->errstr if $oldAutoCommit;
 973   ''; #no error
 974
 975 }
 976
 977 =item generate_email OPTION => VALUE ...
 978
 979 Options:
 980
 981 =over 4
 982
 983 =item from
 984
 985 sender address, required
 986
 987 =item template
 988
 989 alternate template name, optional
 990
 991 =item print_text
 992
 993 text attachment arrayref, optional
 994
 995 =item subject
 996
 997 email subject, optional
 998
 999 =item notice_name
1000
1001 notice name instead of "Invoice", optional
1002
1003 =back
1004
1005 Returns an argument list to be passed to L<FS::Misc::send_email>.
1006
1007 =cut
1008
1009 use MIME::Entity;
1010
1011 sub generate_email {
1012
1013   my $self = shift;
1014   my %args = @_;
1015   my $conf = $self->conf;
1016
1017   my $me = '[FS::cust_bill::generate_email]';
1018
1019   my %return = (
1020     'from'      => $args{'from'},
1021     'subject'   => ($args{'subject'} || $self->email_subject),
1022     'custnum'   => $self->custnum,
1023     'msgtype'   => 'invoice',
1024   );
1025
1026   $args{'unsquelch_cdr'} = $conf->exists('voip-cdr_email');
1027
1028   my $cust_main = $self->cust_main;
1029
1030   if (ref($args{'to'}) eq 'ARRAY') {
1031     $return{'to'} = $args{'to'};
1032   } else {
1033     $return{'to'} = [ grep { $_ !~ /^(POST|FAX)$/ }
1034                            $cust_main->invoicing_list
1035                     ];
1036   }
1037
1038   if ( $conf->exists('invoice_html') ) {
1039
1040     warn "$me creating HTML/text multipart message"
1041       if $DEBUG;
1042
1043     $return{'nobody'} = 1;
1044
1045     my $alternative = build MIME::Entity
1046       'Type'        => 'multipart/alternative',
1047       #'Encoding'    => '7bit',
1048       'Disposition' => 'inline'
1049     ;
1050
1051     my $data;
1052     if ( $conf->exists('invoice_email_pdf')
1053          and scalar($conf->config('invoice_email_pdf_note')) ) {
1054
1055       warn "$me using 'invoice_email_pdf_note' in multipart message"
1056         if $DEBUG;
1057       $data = [ map { $_ . "\n" }
1058                     $conf->config('invoice_email_pdf_note')
1059               ];
1060
1061     } else {
1062
1063       warn "$me not using 'invoice_email_pdf_note' in multipart message"
1064         if $DEBUG;
1065       if ( ref($args{'print_text'}) eq 'ARRAY' ) {
1066         $data = $args{'print_text'};
1067       } else {
1068         $data = [ $self->print_text(\%args) ];
1069       }
1070
1071     }
1072
1073     $alternative->attach(
1074       'Type'        => 'text/plain',
1075       'Encoding'    => 'quoted-printable',
1076       'Charset'     => 'UTF-8',
1077       #'Encoding'    => '7bit',
1078       'Data'        => $data,
1079       'Disposition' => 'inline',
1080     );
1081
1082
1083     my $htmldata;
1084     my $image = '';
1085     my $barcode = '';
1086     if ( $conf->exists('invoice_email_pdf')
1087          and scalar($conf->config('invoice_email_pdf_note')) ) {
1088
1089       $htmldata = join('<BR>', $conf->config('invoice_email_pdf_note') );
1090
1091     } else {
1092
1093       $args{'from'} =~ /\@([\w\.\-]+)/;
1094       my $from = $1 || 'example.com';
1095       my $content_id = join('.', rand()*(2**32), $$, time). "\@$from";
1096
1097       my $logo;
1098       my $agentnum = $cust_main->agentnum;
1099       if ( defined($args{'template'}) && length($args{'template'})
1100            && $conf->exists( 'logo_'. $args{'template'}. '.png', $agentnum )
1101          )
1102       {
1103         $logo = 'logo_'. $args{'template'}. '.png';
1104       } else {
1105         $logo = "logo.png";
1106       }
1107       my $image_data = $conf->config_binary( $logo, $agentnum);
1108
1109       $image = build MIME::Entity
1110         'Type'       => 'image/png',
1111         'Encoding'   => 'base64',
1112         'Data'       => $image_data,
1113         'Filename'   => 'logo.png',
1114         'Content-ID' => "<$content_id>",
1115       ;
1116
1117       if ($conf->exists('invoice-barcode')) {
1118         my $barcode_content_id = join('.', rand()*(2**32), $$, time). "\@$from";
1119         $barcode = build MIME::Entity
1120           'Type'       => 'image/png',
1121           'Encoding'   => 'base64',
1122           'Data'       => $self->invoice_barcode(0),
1123           'Filename'   => 'barcode.png',
1124           'Content-ID' => "<$barcode_content_id>",
1125         ;
1126         $args{'barcode_cid'} = $barcode_content_id;
1127       }
1128
1129       $htmldata = $self->print_html({ 'cid'=>$content_id, %args });
1130     }
1131
1132     $alternative->attach(
1133       'Type'        => 'text/html',
1134       'Encoding'    => 'quoted-printable',
1135       'Data'        => [ '<html>',
1136                          '  <head>',
1137                          '    <title>',
1138                          '      '. encode_entities($return{'subject'}),
1139                          '    </title>',
1140                          '  </head>',
1141                          '  <body bgcolor="#e8e8e8">',
1142                          $htmldata,
1143                          '  </body>',
1144                          '</html>',
1145                        ],
1146       'Disposition' => 'inline',
1147       #'Filename'    => 'invoice.pdf',
1148     );
1149
1150
1151     my @otherparts = ();
1152     if ( $cust_main->email_csv_cdr ) {
1153
1154       push @otherparts, build MIME::Entity
1155         'Type'        => 'text/csv',
1156         'Encoding'    => '7bit',
1157         'Data'        => [ map { "$_\n" }
1158                              $self->call_details('prepend_billed_number' => 1)
1159                          ],
1160         'Disposition' => 'attachment',
1161         'Filename'    => 'usage-'. $self->invnum. '.csv',
1162       ;
1163
1164     }
1165
1166     if ( $conf->exists('invoice_email_pdf') ) {
1167
1168       #attaching pdf too:
1169       # multipart/mixed
1170       #   multipart/related
1171       #     multipart/alternative
1172       #       text/plain
1173       #       text/html
1174       #     image/png
1175       #   application/pdf
1176
1177       my $related = build MIME::Entity 'Type'     => 'multipart/related',
1178                                        'Encoding' => '7bit';
1179
1180       #false laziness w/Misc::send_email
1181       $related->head->replace('Content-type',
1182         $related->mime_type.
1183         '; boundary="'. $related->head->multipart_boundary. '"'.
1184         '; type=multipart/alternative'
1185       );
1186
1187       $related->add_part($alternative);
1188
1189       $related->add_part($image) if $image;
1190
1191       my $pdf = build MIME::Entity $self->mimebuild_pdf(\%args);
1192
1193       $return{'mimeparts'} = [ $related, $pdf, @otherparts ];
1194
1195     } else {
1196
1197       #no other attachment:
1198       # multipart/related
1199       #   multipart/alternative
1200       #     text/plain
1201       #     text/html
1202       #   image/png
1203
1204       $return{'content-type'} = 'multipart/related';
1205       if ($conf->exists('invoice-barcode') && $barcode) {
1206         $return{'mimeparts'} = [ $alternative, $image, $barcode, @otherparts ];
1207       } else {
1208         $return{'mimeparts'} = [ $alternative, $image, @otherparts ];
1209       }
1210       $return{'type'} = 'multipart/alternative'; #Content-Type of first part...
1211       #$return{'disposition'} = 'inline';
1212
1213     }
1214
1215   } else {
1216
1217     if ( $conf->exists('invoice_email_pdf') ) {
1218       warn "$me creating PDF attachment"
1219         if $DEBUG;
1220
1221       #mime parts arguments a la MIME::Entity->build().
1222       $return{'mimeparts'} = [
1223         { $self->mimebuild_pdf(\%args) }
1224       ];
1225     }
1226
1227     if ( $conf->exists('invoice_email_pdf')
1228          and scalar($conf->config('invoice_email_pdf_note')) ) {
1229
1230       warn "$me using 'invoice_email_pdf_note'"
1231         if $DEBUG;
1232       $return{'body'} = [ map { $_ . "\n" }
1233                               $conf->config('invoice_email_pdf_note')
1234                         ];
1235
1236     } else {
1237
1238       warn "$me not using 'invoice_email_pdf_note'"
1239         if $DEBUG;
1240       if ( ref($args{'print_text'}) eq 'ARRAY' ) {
1241         $return{'body'} = $args{'print_text'};
1242       } else {
1243         $return{'body'} = [ $self->print_text(\%args) ];
1244       }
1245
1246     }
1247
1248   }
1249
1250   %return;
1251
1252 }
1253
1254 =item mimebuild_pdf
1255
1256 Returns a list suitable for passing to MIME::Entity->build(), representing
1257 this invoice as PDF attachment.
1258
1259 =cut
1260
1261 sub mimebuild_pdf {
1262   my $self = shift;
1263   (
1264     'Type'        => 'application/pdf',
1265     'Encoding'    => 'base64',
1266     'Data'        => [ $self->print_pdf(@_) ],
1267     'Disposition' => 'attachment',
1268     'Filename'    => 'invoice-'. $self->invnum. '.pdf',
1269   );
1270 }
1271
1272 =item send HASHREF
1273
1274 Sends this invoice to the destinations configured for this customer: sends
1275 email, prints and/or faxes.  See L<FS::cust_main_invoice>.
1276
1277 Options can be passed as a hashref.  Positional parameters are no longer
1278 allowed.
1279
1280 I<template>: a suffix for alternate invoices
1281
1282 I<agentnum>: obsolete, now does nothing.
1283
1284 I<invoice_from> overrides the default email invoice From: address.
1285
1286 I<amount>: obsolete, does nothing
1287
1288 I<notice_name> overrides "Invoice" as the name of the sent document
1289 (templates from 10/2009 or newer required).
1290
1291 I<lpr> overrides the system 'lpr' option as the command to print a document
1292 from standard input.
1293
1294 =cut
1295
1296 sub send {
1297   my $self = shift;
1298   my $opt = ref($_[0]) ? $_[0] : +{ @_ };
1299   my $conf = $self->conf;
1300
1301   my $cust_main = $self->cust_main;
1302
1303   my @invoicing_list = $cust_main->invoicing_list;
1304
1305   $self->email($opt)
1306     if ( grep { $_ !~ /^(POST|FAX)$/ } @invoicing_list or !@invoicing_list )
1307     && ! $self->invoice_noemail;
1308
1309   $self->print($opt)
1310     if grep { $_ eq 'POST' } @invoicing_list; #postal
1311
1312   #this has never been used post-$ORIGINAL_ISP afaik
1313   $self->fax_invoice($opt)
1314     if grep { $_ eq 'FAX' } @invoicing_list; #fax
1315
1316   '';
1317
1318 }
1319
1320 =item email HASHREF | [ TEMPLATE [ , INVOICE_FROM ] ]
1321
1322 Sends this invoice to the customer's email destination(s).
1323
1324 Options must be passed as a hashref.  Positional parameters are no longer
1325 allowed.
1326
1327 I<template>, if specified, is the name of a suffix for alternate invoices.
1328
1329 I<invoice_from>, if specified, overrides the default email invoice From:
1330 address.
1331
1332 I<notice_name> is the name of the sent document.
1333
1334 =cut
1335
1336 sub queueable_email {
1337   my %opt = @_;
1338
1339   my $self = qsearchs('cust_bill', { 'invnum' => $opt{invnum} } )
1340     or die "invalid invoice number: " . $opt{invnum};
1341
1342   my %args = map {$_ => $opt{$_}}
1343              grep { $opt{$_} }
1344               qw( invoice_from notice_name no_coupon template );
1345
1346   my $error = $self->email( \%args );
1347   die $error if $error;
1348
1349 }
1350
1351 sub email {
1352   my $self = shift;
1353   return if $self->hide;
1354   my $conf = $self->conf;
1355   my $opt = shift || {};
1356   if ($opt and !ref($opt)) {
1357     die "FS::cust_bill::email called with positional parameters";
1358   }
1359
1360   my $template = $opt->{template};
1361   my $from = delete $opt->{invoice_from};
1362
1363   # this is where we set the From: address
1364   $from ||= $self->_agent_invoice_from ||    #XXX should go away
1365             $conf->config('invoice_from', $self->cust_main->agentnum );
1366
1367   my @invoicing_list = grep { $_ !~ /^(POST|FAX)$/ }
1368                             $self->cust_main->invoicing_list;
1369
1370   if ( ! @invoicing_list ) { #no recipients
1371     if ( $conf->exists('cust_bill-no_recipients-error') ) {
1372       die 'No recipients for customer #'. $self->custnum;
1373     } else {
1374       #default: better to notify this person than silence
1375       @invoicing_list = ($from);
1376     }
1377   }
1378
1379   # this is where we set the Subject:
1380   my $subject = $self->email_subject($template);
1381
1382   my $error = send_email(
1383     $self->generate_email(
1384       'from'        => $from,
1385       'to'          => [ grep { $_ !~ /^(POST|FAX)$/ } @invoicing_list ],
1386       'subject'     => $subject,
1387       %$opt, # template, etc.
1388     )
1389   );
1390   die "can't email invoice: $error\n" if $error;
1391   #die "$error\n" if $error;
1392
1393 }
1394
1395 sub email_subject {
1396   my $self = shift;
1397   my $conf = $self->conf;
1398
1399   #my $template = scalar(@_) ? shift : '';
1400   #per-template?
1401
1402   my $subject = $conf->config('invoice_subject', $self->cust_main->agentnum)
1403                 || 'Invoice';
1404
1405   my $cust_main = $self->cust_main;
1406   my $name = $cust_main->name;
1407   my $name_short = $cust_main->name_short;
1408   my $invoice_number = $self->invnum;
1409   my $invoice_date = $self->_date_pretty;
1410
1411   eval qq("$subject");
1412 }
1413
1414 =item lpr_data HASHREF
1415
1416 Returns the postscript or plaintext for this invoice as an arrayref.
1417
1418 Options must be passed as a hashref.  Positional parameters are no longer
1419 allowed.
1420
1421 I<template>, if specified, is the name of a suffix for alternate invoices.
1422
1423 I<notice_name>, if specified, overrides "Invoice" as the name of the sent document (templates from 10/2009 or newer required)
1424
1425 =cut
1426
1427 sub lpr_data {
1428   my $self = shift;
1429   my $conf = $self->conf;
1430   my $opt = shift || {};
1431   if ($opt and !ref($opt)) {
1432     # nobody does this anyway
1433     die "FS::cust_bill::lpr_data called with positional parameters";
1434   }
1435
1436   my $method = $conf->exists('invoice_latex') ? 'print_ps' : 'print_text';
1437   [ $self->$method( $opt ) ];
1438 }
1439
1440 =item print HASHREF
1441
1442 Prints this invoice.
1443
1444 Options must be passed as a hashref.
1445
1446 I<template>, if specified, is the name of a suffix for alternate invoices.
1447
1448 I<notice_name>, if specified, overrides "Invoice" as the name of the sent document (templates from 10/2009 or newer required)
1449
1450 =cut
1451
1452 sub print {
1453   my $self = shift;
1454   return if $self->hide;
1455   my $conf = $self->conf;
1456   my $opt = shift || {};
1457   if ($opt and !ref($opt)) {
1458     die "FS::cust_bill::print called with positional parameters";
1459   }
1460
1461   my $lpr = delete $opt->{lpr};
1462   if($conf->exists('invoice_print_pdf')) {
1463     # Add the invoice to the current batch.
1464     $self->batch_invoice($opt);
1465   }
1466   else {
1467     do_print(
1468       $self->lpr_data($opt),
1469       'agentnum' => $self->cust_main->agentnum,
1470       'lpr'      => $lpr,
1471     );
1472   }
1473 }
1474
1475 =item fax_invoice HASHREF
1476
1477 Faxes this invoice.
1478
1479 Options must be passed as a hashref.
1480
1481 I<template>, if specified, is the name of a suffix for alternate invoices.
1482
1483 I<notice_name>, if specified, overrides "Invoice" as the name of the sent document (templates from 10/2009 or newer required)
1484
1485 =cut
1486
1487 sub fax_invoice {
1488   my $self = shift;
1489   return if $self->hide;
1490   my $conf = $self->conf;
1491   my $opt = shift || {};
1492   if ($opt and !ref($opt)) {
1493     die "FS::cust_bill::fax_invoice called with positional parameters";
1494   }
1495
1496   die 'FAX invoice destination not (yet?) supported with plain text invoices.'
1497     unless $conf->exists('invoice_latex');
1498
1499   my $dialstring = $self->cust_main->getfield('fax');
1500   #Check $dialstring?
1501
1502   my $error = send_fax( 'docdata'    => $self->lpr_data($opt),
1503                         'dialstring' => $dialstring,
1504                       );
1505   die $error if $error;
1506
1507 }
1508
1509 =item batch_invoice [ HASHREF ]
1510
1511 Place this invoice into the open batch (see C<FS::bill_batch>).  If there
1512 isn't an open batch, one will be created.
1513
1514 =cut
1515
1516 sub batch_invoice {
1517   my ($self, $opt) = @_;
1518   my $bill_batch = $self->get_open_bill_batch;
1519   my $cust_bill_batch = FS::cust_bill_batch->new({
1520       batchnum => $bill_batch->batchnum,
1521       invnum   => $self->invnum,
1522   });
1523   return $cust_bill_batch->insert($opt);
1524 }
1525
1526 =item get_open_batch
1527
1528 Returns the currently open batch as an FS::bill_batch object, creating a new
1529 one if necessary.  (A per-agent batch if invoice_print_pdf-spoolagent is
1530 enabled)
1531
1532 =cut
1533
1534 sub get_open_bill_batch {
1535   my $self = shift;
1536   my $conf = $self->conf;
1537   my $hashref = { status => 'O' };
1538   $hashref->{'agentnum'} = $conf->exists('invoice_print_pdf-spoolagent')
1539                              ? $self->cust_main->agentnum
1540                              : '';
1541   my $batch = qsearchs('bill_batch', $hashref);
1542   return $batch if $batch;
1543   $batch = FS::bill_batch->new($hashref);
1544   my $error = $batch->insert;
1545   die $error if $error;
1546   return $batch;
1547 }
1548
1549 =item ftp_invoice [ TEMPLATENAME ]
1550
1551 Sends this invoice data via FTP.
1552
1553 TEMPLATENAME is unused?
1554
1555 =cut
1556
1557 sub ftp_invoice {
1558   my $self = shift;
1559   my $conf = $self->conf;
1560   my $template = scalar(@_) ? shift : '';
1561
1562   $self->send_csv(
1563     'protocol'   => 'ftp',
1564     'server'     => $conf->config('cust_bill-ftpserver'),
1565     'username'   => $conf->config('cust_bill-ftpusername'),
1566     'password'   => $conf->config('cust_bill-ftppassword'),
1567     'dir'        => $conf->config('cust_bill-ftpdir'),
1568     'format'     => $conf->config('cust_bill-ftpformat'),
1569   );
1570 }
1571
1572 =item spool_invoice [ TEMPLATENAME ]
1573
1574 Spools this invoice data (see L<FS::spool_csv>)
1575
1576 TEMPLATENAME is unused?
1577
1578 =cut
1579
1580 sub spool_invoice {
1581   my $self = shift;
1582   my $conf = $self->conf;
1583   my $template = scalar(@_) ? shift : '';
1584
1585   $self->spool_csv(
1586     'format'       => $conf->config('cust_bill-spoolformat'),
1587     'agent_spools' => $conf->exists('cust_bill-spoolagent'),
1588   );
1589 }
1590
1591 =item send_csv OPTION => VALUE, ...
1592
1593 Sends invoice as a CSV data-file to a remote host with the specified protocol.
1594
1595 Options are:
1596
1597 protocol - currently only "ftp"
1598 server
1599 username
1600 password
1601 dir
1602
1603 The file will be named "N-YYYYMMDDHHMMSS.csv" where N is the invoice number
1604 and YYMMDDHHMMSS is a timestamp.
1605
1606 See L</print_csv> for a description of the output format.
1607
1608 =cut
1609
1610 sub send_csv {
1611   my($self, %opt) = @_;
1612
1613   #create file(s)
1614
1615   my $spooldir = "/usr/local/etc/freeside/export.". datasrc. "/cust_bill";
1616   mkdir $spooldir, 0700 unless -d $spooldir;
1617
1618   # don't localize dates here, they're a defined format
1619   my $tracctnum = $self->invnum. time2str('-%Y%m%d%H%M%S', time);
1620   my $file = "$spooldir/$tracctnum.csv";
1621
1622   my ( $header, $detail ) = $self->print_csv(%opt, 'tracctnum' => $tracctnum );
1623
1624   open(CSV, ">$file") or die "can't open $file: $!";
1625   print CSV $header;
1626
1627   print CSV $detail;
1628
1629   close CSV;
1630
1631   my $net;
1632   if ( $opt{protocol} eq 'ftp' ) {
1633     eval "use Net::FTP;";
1634     die $@ if $@;
1635     $net = Net::FTP->new($opt{server}) or die @$;
1636   } else {
1637     die "unknown protocol: $opt{protocol}";
1638   }
1639
1640   $net->login( $opt{username}, $opt{password} )
1641     or die "can't FTP to $opt{username}\@$opt{server}: login error: $@";
1642
1643   $net->binary or die "can't set binary mode";
1644
1645   $net->cwd($opt{dir}) or die "can't cwd to $opt{dir}";
1646
1647   $net->put($file) or die "can't put $file: $!";
1648
1649   $net->quit;
1650
1651   unlink $file;
1652
1653 }
1654
1655 =item spool_csv
1656
1657 Spools CSV invoice data.
1658
1659 Options are:
1660
1661 =over 4
1662
1663 =item format - any of FS::Misc::::Invoicing::spool_formats
1664
1665 =item dest - if set (to POST, EMAIL or FAX), only sends spools invoices if the
1666 customer has the corresponding invoice destinations set (see
1667 L<FS::cust_main_invoice>).
1668
1669 =item agent_spools - if set to a true value, will spool to per-agent files
1670 rather than a single global file
1671
1672 =item upload_targetnum - if set to a target (see L<FS::upload_target>), will
1673 append to that spool.  L<FS::Cron::upload> will then send the spool file to
1674 that destination.
1675
1676 =item balanceover - if set, only spools the invoice if the total amount owed on
1677 this invoice and all older invoices is greater than the specified amount.
1678
1679 =item time - the "current time".  Controls the printing of past due messages
1680 in the ICS format.
1681
1682 =back
1683
1684 =cut
1685
1686 sub spool_csv {
1687   my($self, %opt) = @_;
1688
1689   my $time = $opt{'time'} || time;
1690   my $cust_main = $self->cust_main;
1691
1692   if ( $opt{'dest'} ) {
1693     my %invoicing_list = map { /^(POST|FAX)$/ or 'EMAIL' =~ /^(.*)$/; $1 => 1 }
1694                              $cust_main->invoicing_list;
1695     return 'N/A' unless $invoicing_list{$opt{'dest'}}
1696                      || ! keys %invoicing_list;
1697   }
1698
1699   if ( $opt{'balanceover'} ) {
1700     return 'N/A'
1701       if $cust_main->total_owed_date($self->_date) < $opt{'balanceover'};
1702   }
1703
1704   my $spooldir = "/usr/local/etc/freeside/export.". datasrc. "/cust_bill";
1705   mkdir $spooldir, 0700 unless -d $spooldir;
1706
1707   my $tracctnum = $self->invnum. time2str('-%Y%m%d%H%M%S', $time);
1708
1709   my $file;
1710   if ( $opt{'agent_spools'} ) {
1711     $file = 'agentnum'.$cust_main->agentnum;
1712   } else {
1713     $file = 'spool';
1714   }
1715
1716   if ( $opt{'upload_targetnum'} ) {
1717     $spooldir .= '/target'.$opt{'upload_targetnum'};
1718     mkdir $spooldir, 0700 unless -d $spooldir;
1719   } # otherwise it just goes into export.xxx/cust_bill
1720
1721   if ( lc($opt{'format'}) eq 'billco' ) {
1722     $file .= '-header';
1723   }
1724
1725   $file = "$spooldir/$file.csv";
1726
1727   my ( $header, $detail ) = $self->print_csv(%opt, 'tracctnum' => $tracctnum);
1728
1729   open(CSV, ">>$file") or die "can't open $file: $!";
1730   flock(CSV, LOCK_EX);
1731   seek(CSV, 0, 2);
1732
1733   print CSV $header;
1734
1735   if ( lc($opt{'format'}) eq 'billco' ) {
1736
1737     flock(CSV, LOCK_UN);
1738     close CSV;
1739
1740     $file =~ s/-header.csv$/-detail.csv/;
1741
1742     open(CSV,">>$file") or die "can't open $file: $!";
1743     flock(CSV, LOCK_EX);
1744     seek(CSV, 0, 2);
1745   }
1746
1747   print CSV $detail if defined($detail);
1748
1749   flock(CSV, LOCK_UN);
1750   close CSV;
1751
1752   return '';
1753
1754 }
1755
1756 =item print_csv OPTION => VALUE, ...
1757
1758 Returns CSV data for this invoice.
1759
1760 Options are:
1761
1762 format - 'default', 'billco', 'oneline', 'bridgestone'
1763
1764 Returns a list consisting of two scalars.  The first is a single line of CSV
1765 header information for this invoice.  The second is one or more lines of CSV
1766 detail information for this invoice.
1767
1768 If I<format> is not specified or "default", the fields of the CSV file are as
1769 follows:
1770
1771 record_type, invnum, custnum, _date, charged, first, last, company, address1,
1772 address2, city, state, zip, country, pkg, setup, recur, sdate, edate
1773
1774 =over 4
1775
1776 =item record type - B<record_type> is either C<cust_bill> or C<cust_bill_pkg>
1777
1778 B<record_type> is C<cust_bill> for the initial header line only.  The
1779 last five fields (B<pkg> through B<edate>) are irrelevant, and all other
1780 fields are filled in.
1781
1782 B<record_type> is C<cust_bill_pkg> for detail lines.  Only the first two fields
1783 (B<record_type> and B<invnum>) and the last five fields (B<pkg> through B<edate>)
1784 are filled in.
1785
1786 =item invnum - invoice number
1787
1788 =item custnum - customer number
1789
1790 =item _date - invoice date
1791
1792 =item charged - total invoice amount
1793
1794 =item first - customer first name
1795
1796 =item last - customer first name
1797
1798 =item company - company name
1799
1800 =item address1 - address line 1
1801
1802 =item address2 - address line 1
1803
1804 =item city
1805
1806 =item state
1807
1808 =item zip
1809
1810 =item country
1811
1812 =item pkg - line item description
1813
1814 =item setup - line item setup fee (one or both of B<setup> and B<recur> will be defined)
1815
1816 =item recur - line item recurring fee (one or both of B<setup> and B<recur> will be defined)
1817
1818 =item sdate - start date for recurring fee
1819
1820 =item edate - end date for recurring fee
1821
1822 =back
1823
1824 If I<format> is "billco", the fields of the header CSV file are as follows:
1825
1826   +-------------------------------------------------------------------+
1827   |                        FORMAT HEADER FILE                         |
1828   |-------------------------------------------------------------------|
1829   | Field | Description                   | Name       | Type | Width |
1830   | 1     | N/A-Leave Empty               | RC         | CHAR |     2 |
1831   | 2     | N/A-Leave Empty               | CUSTID     | CHAR |    15 |
1832   | 3     | Transaction Account No        | TRACCTNUM  | CHAR |    15 |
1833   | 4     | Transaction Invoice No        | TRINVOICE  | CHAR |    15 |
1834   | 5     | Transaction Zip Code          | TRZIP      | CHAR |     5 |
1835   | 6     | Transaction Company Bill To   | TRCOMPANY  | CHAR |    30 |
1836   | 7     | Transaction Contact Bill To   | TRNAME     | CHAR |    30 |
1837   | 8     | Additional Address Unit Info  | TRADDR1    | CHAR |    30 |
1838   | 9     | Bill To Street Address        | TRADDR2    | CHAR |    30 |
1839   | 10    | Ancillary Billing Information | TRADDR3    | CHAR |    30 |
1840   | 11    | Transaction City Bill To      | TRCITY     | CHAR |    20 |
1841   | 12    | Transaction State Bill To     | TRSTATE    | CHAR |     2 |
1842   | 13    | Bill Cycle Close Date         | CLOSEDATE  | CHAR |    10 |
1843   | 14    | Bill Due Date                 | DUEDATE    | CHAR |    10 |
1844   | 15    | Previous Balance              | BALFWD     | NUM* |     9 |
1845   | 16    | Pmt/CR Applied                | CREDAPPLY  | NUM* |     9 |
1846   | 17    | Total Current Charges         | CURRENTCHG | NUM* |     9 |
1847   | 18    | Total Amt Due                 | TOTALDUE   | NUM* |     9 |
1848   | 19    | Total Amt Due                 | AMTDUE     | NUM* |     9 |
1849   | 20    | 30 Day Aging                  | AMT30      | NUM* |     9 |
1850   | 21    | 60 Day Aging                  | AMT60      | NUM* |     9 |
1851   | 22    | 90 Day Aging                  | AMT90      | NUM* |     9 |
1852   | 23    | Y/N                           | AGESWITCH  | CHAR |     1 |
1853   | 24    | Remittance automation         | SCANLINE   | CHAR |   100 |
1854   | 25    | Total Taxes & Fees            | TAXTOT     | NUM* |     9 |
1855   | 26    | Customer Reference Number     | CUSTREF    | CHAR |    15 |
1856   | 27    | Federal Tax***                | FEDTAX     | NUM* |     9 |
1857   | 28    | State Tax***                  | STATETAX   | NUM* |     9 |
1858   | 29    | Other Taxes & Fees***         | OTHERTAX   | NUM* |     9 |
1859   +-------+-------------------------------+------------+------+-------+
1860
1861 If I<format> is "billco", the fields of the detail CSV file are as follows:
1862
1863                                   FORMAT FOR DETAIL FILE
1864         |                            |           |      |
1865   Field | Description                | Name      | Type | Width
1866   1     | N/A-Leave Empty            | RC        | CHAR |     2
1867   2     | N/A-Leave Empty            | CUSTID    | CHAR |    15
1868   3     | Account Number             | TRACCTNUM | CHAR |    15
1869   4     | Invoice Number             | TRINVOICE | CHAR |    15
1870   5     | Line Sequence (sort order) | LINESEQ   | NUM  |     6
1871   6     | Transaction Detail         | DETAILS   | CHAR |   100
1872   7     | Amount                     | AMT       | NUM* |     9
1873   8     | Line Format Control**      | LNCTRL    | CHAR |     2
1874   9     | Grouping Code              | GROUP     | CHAR |     2
1875   10    | User Defined               | ACCT CODE | CHAR |    15
1876
1877 If format is 'oneline', there is no detail file.  Each invoice has a
1878 header line only, with the fields:
1879
1880 Agent number, agent name, customer number, first name, last name, address
1881 line 1, address line 2, city, state, zip, invoice date, invoice number,
1882 amount charged, amount due, previous balance, due date.
1883
1884 and then, for each line item, three columns containing the package number,
1885 description, and amount.
1886
1887 If format is 'bridgestone', there is no detail file.  Each invoice has a
1888 header line with the following fields in a fixed-width format:
1889
1890 Customer number (in display format), date, name (first last), company,
1891 address 1, address 2, city, state, zip.
1892
1893 This is a mailing list format, and has no per-invoice fields.  To avoid
1894 sending redundant notices, the spooling event should have a "once" or
1895 "once_percust_every" condition.
1896
1897 =cut
1898
1899 sub print_csv {
1900   my($self, %opt) = @_;
1901
1902   eval "use Text::CSV_XS";
1903   die $@ if $@;
1904
1905   my $cust_main = $self->cust_main;
1906
1907   my $csv = Text::CSV_XS->new({'always_quote'=>1});
1908   my $format = lc($opt{'format'});
1909
1910   my $time = $opt{'time'} || time;
1911
1912   my $tracctnum = ''; #leaking out from billco-specific sections :/
1913   if ( $format eq 'billco' ) {
1914
1915     my $account_num =
1916       $self->conf->config('billco-account_num', $cust_main->agentnum);
1917
1918     $tracctnum = $account_num eq 'display_custnum'
1919                    ? $cust_main->display_custnum
1920                    : $opt{'tracctnum'};
1921
1922     my $taxtotal = 0;
1923     $taxtotal += $_->{'amount'} foreach $self->_items_tax;
1924
1925     my $duedate = $self->due_date2str('%m/%d/%Y'); # hardcoded, NOT date_format
1926
1927     my( $previous_balance, @unused ) = $self->previous; #previous balance
1928
1929     my $pmt_cr_applied = 0;
1930     $pmt_cr_applied += $_->{'amount'}
1931       foreach ( $self->_items_payments(%opt), $self->_items_credits(%opt) ) ;
1932
1933     my $totaldue = sprintf('%.2f', $self->owed + $previous_balance);
1934
1935     $csv->combine(
1936       '',                         #  1 | N/A-Leave Empty               CHAR   2
1937       '',                         #  2 | N/A-Leave Empty               CHAR  15
1938       $tracctnum,                 #  3 | Transaction Account No        CHAR  15
1939       $self->invnum,              #  4 | Transaction Invoice No        CHAR  15
1940       $cust_main->zip,            #  5 | Transaction Zip Code          CHAR   5
1941       $cust_main->company,        #  6 | Transaction Company Bill To   CHAR  30
1942       #$cust_main->payname,        #  7 | Transaction Contact Bill To   CHAR  30
1943       $cust_main->contact,        #  7 | Transaction Contact Bill To   CHAR  30
1944       $cust_main->address2,       #  8 | Additional Address Unit Info  CHAR  30
1945       $cust_main->address1,       #  9 | Bill To Street Address        CHAR  30
1946       '',                         # 10 | Ancillary Billing Information CHAR  30
1947       $cust_main->city,           # 11 | Transaction City Bill To      CHAR  20
1948       $cust_main->state,          # 12 | Transaction State Bill To     CHAR   2
1949
1950       # XXX ?
1951       time2str("%m/%d/%Y", $self->_date), # 13 | Bill Cycle Close Date CHAR  10
1952
1953       # XXX ?
1954       $duedate,                   # 14 | Bill Due Date                 CHAR  10
1955
1956       $previous_balance,          # 15 | Previous Balance              NUM*   9
1957       $pmt_cr_applied,            # 16 | Pmt/CR Applied                NUM*   9
1958       sprintf("%.2f", $self->charged), # 17 | Total Current Charges    NUM*   9
1959       $totaldue,                  # 18 | Total Amt Due                 NUM*   9
1960       $totaldue,                  # 19 | Total Amt Due                 NUM*   9
1961       '',                         # 20 | 30 Day Aging                  NUM*   9
1962       '',                         # 21 | 60 Day Aging                  NUM*   9
1963       '',                         # 22 | 90 Day Aging                  NUM*   9
1964       'N',                        # 23 | Y/N                           CHAR   1
1965       '',                         # 24 | Remittance automation         CHAR 100
1966       $taxtotal,                  # 25 | Total Taxes & Fees            NUM*   9
1967       $self->custnum,             # 26 | Customer Reference Number     CHAR  15
1968       '0',                        # 27 | Federal Tax***                NUM*   9
1969       sprintf("%.2f", $taxtotal), # 28 | State Tax***                  NUM*   9
1970       '0',                        # 29 | Other Taxes & Fees***         NUM*   9
1971     );
1972
1973   } elsif ( $format eq 'oneline' ) { #name
1974
1975     my ($previous_balance) = $self->previous;
1976     $previous_balance = sprintf('%.2f', $previous_balance);
1977     my $totaldue = sprintf('%.2f', $self->owed + $previous_balance);
1978     my @items = map {
1979                       $_->{pkgnum},
1980                       $_->{description},
1981                       $_->{amount}
1982                     }
1983                   $self->_items_pkg, #_items_nontax?  no sections or anything
1984                                      # with this format
1985                   $self->_items_tax;
1986
1987     $csv->combine(
1988       $cust_main->agentnum,
1989       $cust_main->agent->agent,
1990       $self->custnum,
1991       $cust_main->first,
1992       $cust_main->last,
1993       $cust_main->company,
1994       $cust_main->address1,
1995       $cust_main->address2,
1996       $cust_main->city,
1997       $cust_main->state,
1998       $cust_main->zip,
1999
2000       # invoice fields
2001       time2str("%x", $self->_date),
2002       $self->invnum,
2003       $self->charged,
2004       $totaldue,
2005       $previous_balance,
2006       $self->due_date2str("%x"),
2007
2008       @items,
2009     );
2010
2011   } elsif ( $format eq 'bridgestone' ) {
2012
2013     # bypass the CSV stuff and just return this
2014     my $longdate = time2str('%B %d, %Y', $time); #current time, right?
2015     my $zip = $cust_main->zip;
2016     $zip =~ s/\D//;
2017     my $prefix = $self->conf->config('bridgestone-prefix', $cust_main->agentnum)
2018       || '';
2019     return (
2020       sprintf(
2021         "%-5s%-15s%-20s%-30s%-30s%-30s%-30s%-20s%-2s%-9s\n",
2022         $prefix,
2023         $cust_main->display_custnum,
2024         $longdate,
2025         uc(substr($cust_main->contact_firstlast,0,30)),
2026         uc(substr($cust_main->company          ,0,30)),
2027         uc(substr($cust_main->address1         ,0,30)),
2028         uc(substr($cust_main->address2         ,0,30)),
2029         uc(substr($cust_main->city             ,0,20)),
2030         uc($cust_main->state),
2031         $zip
2032       ),
2033       '' #detail
2034       );
2035
2036   } elsif ( $format eq 'ics' ) {
2037
2038     my $bill = $cust_main->bill_location;
2039     my $zip = $bill->zip;
2040     my $zip4 = '';
2041
2042     $zip =~ s/\D//;
2043     if ( $zip =~ /^(\d{5})(\d{4})$/ ) {
2044       $zip = $1;
2045       $zip4 = $2;
2046     }
2047
2048     # minor false laziness with print_generic
2049     my ($previous_balance) = $self->previous;
2050     my $balance_due = $self->owed + $previous_balance;
2051     my $payment_total = sum(0, map { $_->{'amount'} } $self->_items_payments);
2052     my $credit_total  = sum(0, map { $_->{'amount'} } $self->_items_credits);
2053
2054     my $past_due = '';
2055     if ( $self->due_date and $time >= $self->due_date ) {
2056       $past_due = sprintf('Past due:$%0.2f Due Immediately', $balance_due);
2057     }
2058
2059     # again, bypass CSV
2060     my $header = sprintf(
2061       '%-10s%-30s%-48s%-2s%-50s%-30s%-30s%-25s%-2s%-5s%-4s%-8s%-8s%-10s%-10s%-10s%-10s%-10s%-10s%-480s%-35s',
2062       $cust_main->display_custnum, #BID
2063       uc($cust_main->first), #FNAME
2064       uc($cust_main->last), #LNAME
2065       '00', #BATCH, should this ever be anything else?
2066       uc($cust_main->company), #COMP
2067       uc($bill->address1), #STREET1
2068       uc($bill->address2), #STREET2
2069       uc($bill->city), #CITY
2070       uc($bill->state), #STATE
2071       $zip,
2072       $zip4,
2073       time2str('%Y%m%d', $self->_date), #BILL_DATE
2074       $self->due_date2str('%Y%m%d'), #DUE_DATE,
2075       ( map {sprintf('%0.2f', $_)}
2076         $balance_due, #AMNT_DUE
2077         $previous_balance, #PREV_BAL
2078         $payment_total, #PYMT_RCVD
2079         $credit_total, #CREDITS
2080         $previous_balance, #BEG_BAL--is this correct?
2081         $self->charged, #NEW_CHRG
2082       ),
2083       'img01', #MRKT_MSG?
2084       $past_due, #PAST_MSG
2085     );
2086
2087     my @details;
2088     my %svc_class = ('' => ''); # maybe cache this more persistently?
2089
2090     foreach my $cust_bill_pkg ( $self->cust_bill_pkg ) {
2091
2092       my $show_pkgnum = $cust_bill_pkg->pkgnum || '';
2093       my $cust_pkg = $cust_bill_pkg->cust_pkg if $show_pkgnum;
2094
2095       if ( $cust_pkg ) {
2096
2097         my @dates = ( $self->_date, undef );
2098         if ( my $prev = $cust_bill_pkg->previous_cust_bill_pkg ) {
2099           $dates[1] = $prev->sdate; #questionable
2100         }
2101
2102         # generate an 01 detail for each service
2103         my @svcs = $cust_pkg->h_cust_svc(@dates, 'I');
2104         foreach my $cust_svc ( @svcs ) {
2105           $show_pkgnum = ''; # hide it if we're showing svcnums
2106
2107           my $svcpart = $cust_svc->svcpart;
2108           if (!exists($svc_class{$svcpart})) {
2109             my $classnum = $cust_svc->part_svc->classnum;
2110             my $part_svc_class = FS::part_svc_class->by_key($classnum)
2111               if $classnum;
2112             $svc_class{$svcpart} = $part_svc_class ?
2113                                    $part_svc_class->classname :
2114                                    '';
2115           }
2116
2117           my @h_label = $cust_svc->label(@dates, 'I');
2118           push @details, sprintf('01%-9s%-20s%-47s',
2119             $cust_svc->svcnum,
2120             $svc_class{$svcpart},
2121             $h_label[1],
2122           );
2123         } #foreach $cust_svc
2124       } #if $cust_pkg
2125
2126       my $desc = $cust_bill_pkg->desc; # itemdesc or part_pkg.pkg
2127       if ($cust_bill_pkg->recur > 0) {
2128         $desc .= ' '.time2str('%d-%b-%Y', $cust_bill_pkg->sdate).' to '.
2129                      time2str('%d-%b-%Y', $cust_bill_pkg->edate - 86400);
2130       }
2131       push @details, sprintf('02%-6s%-60s%-10s',
2132         $show_pkgnum,
2133         $desc,
2134         sprintf('%0.2f', $cust_bill_pkg->setup + $cust_bill_pkg->recur),
2135       );
2136     } #foreach $cust_bill_pkg
2137
2138     # Tag this row so that we know whether this is one page (1), two pages
2139     # (2), # or "big" (B).  The tag will be stripped off before uploading.
2140     if ( scalar(@details) < 12 ) {
2141       push @details, '1';
2142     } elsif ( scalar(@details) < 58 ) {
2143       push @details, '2';
2144     } else {
2145       push @details, 'B';
2146     }
2147
2148     return join('', $header, @details, "\n");
2149
2150   } else { # default
2151
2152     $csv->combine(
2153       'cust_bill',
2154       $self->invnum,
2155       $self->custnum,
2156       time2str("%x", $self->_date),
2157       sprintf("%.2f", $self->charged),
2158       ( map { $cust_main->getfield($_) }
2159           qw( first last company address1 address2 city state zip country ) ),
2160       map { '' } (1..5),
2161     ) or die "can't create csv";
2162   }
2163
2164   my $header = $csv->string. "\n";
2165
2166   my $detail = '';
2167   if ( lc($opt{'format'}) eq 'billco' ) {
2168
2169     my $lineseq = 0;
2170     foreach my $item ( $self->_items_pkg ) {
2171
2172       $csv->combine(
2173         '',                     #  1 | N/A-Leave Empty            CHAR   2
2174         '',                     #  2 | N/A-Leave Empty            CHAR  15
2175         $tracctnum,             #  3 | Account Number             CHAR  15
2176         $self->invnum,          #  4 | Invoice Number             CHAR  15
2177         $lineseq++,             #  5 | Line Sequence (sort order) NUM    6
2178         $item->{'description'}, #  6 | Transaction Detail         CHAR 100
2179         $item->{'amount'},      #  7 | Amount                     NUM*   9
2180         '',                     #  8 | Line Format Control**      CHAR   2
2181         '',                     #  9 | Grouping Code              CHAR   2
2182         '',                     # 10 | User Defined               CHAR  15
2183       );
2184
2185       $detail .= $csv->string. "\n";
2186
2187     }
2188
2189   } elsif ( lc($opt{'format'}) eq 'oneline' ) {
2190
2191     #do nothing
2192
2193   } else {
2194
2195     foreach my $cust_bill_pkg ( $self->cust_bill_pkg ) {
2196
2197       my($pkg, $setup, $recur, $sdate, $edate);
2198       if ( $cust_bill_pkg->pkgnum ) {
2199
2200         ($pkg, $setup, $recur, $sdate, $edate) = (
2201           $cust_bill_pkg->part_pkg->pkg,
2202           ( $cust_bill_pkg->setup != 0
2203             ? sprintf("%.2f", $cust_bill_pkg->setup )
2204             : '' ),
2205           ( $cust_bill_pkg->recur != 0
2206             ? sprintf("%.2f", $cust_bill_pkg->recur )
2207             : '' ),
2208           ( $cust_bill_pkg->sdate
2209             ? time2str("%x", $cust_bill_pkg->sdate)
2210             : '' ),
2211           ($cust_bill_pkg->edate
2212             ? time2str("%x", $cust_bill_pkg->edate)
2213             : '' ),
2214         );
2215
2216       } else { #pkgnum tax
2217         next unless $cust_bill_pkg->setup != 0;
2218         $pkg = $cust_bill_pkg->desc;
2219         $setup = sprintf('%10.2f', $cust_bill_pkg->setup );
2220         ( $sdate, $edate ) = ( '', '' );
2221       }
2222
2223       $csv->combine(
2224         'cust_bill_pkg',
2225         $self->invnum,
2226         ( map { '' } (1..11) ),
2227         ($pkg, $setup, $recur, $sdate, $edate)
2228       ) or die "can't create csv";
2229
2230       $detail .= $csv->string. "\n";
2231
2232     }
2233
2234   }
2235
2236   ( $header, $detail );
2237
2238 }
2239
2240 =item comp
2241
2242 Pays this invoice with a compliemntary payment.  If there is an error,
2243 returns the error, otherwise returns false.
2244
2245 =cut
2246
2247 sub comp {
2248   my $self = shift;
2249   my $cust_pay = new FS::cust_pay ( {
2250     'invnum'   => $self->invnum,
2251     'paid'     => $self->owed,
2252     '_date'    => '',
2253     'payby'    => 'COMP',
2254     'payinfo'  => $self->cust_main->payinfo,
2255     'paybatch' => '',
2256   } );
2257   $cust_pay->insert;
2258 }
2259
2260 =item realtime_card
2261
2262 Attempts to pay this invoice with a credit card payment via a
2263 Business::OnlinePayment realtime gateway.  See
2264 http://search.cpan.org/search?mode=module&query=Business%3A%3AOnlinePayment
2265 for supported processors.
2266
2267 =cut
2268
2269 sub realtime_card {
2270   my $self = shift;
2271   $self->realtime_bop( 'CC', @_ );
2272 }
2273
2274 =item realtime_ach
2275
2276 Attempts to pay this invoice with an electronic check (ACH) payment via a
2277 Business::OnlinePayment realtime gateway.  See
2278 http://search.cpan.org/search?mode=module&query=Business%3A%3AOnlinePayment
2279 for supported processors.
2280
2281 =cut
2282
2283 sub realtime_ach {
2284   my $self = shift;
2285   $self->realtime_bop( 'ECHECK', @_ );
2286 }
2287
2288 =item realtime_lec
2289
2290 Attempts to pay this invoice with phone bill (LEC) payment via a
2291 Business::OnlinePayment realtime gateway.  See
2292 http://search.cpan.org/search?mode=module&query=Business%3A%3AOnlinePayment
2293 for supported processors.
2294
2295 =cut
2296
2297 sub realtime_lec {
2298   my $self = shift;
2299   $self->realtime_bop( 'LEC', @_ );
2300 }
2301
2302 sub realtime_bop {
2303   my( $self, $method ) = (shift,shift);
2304   my $conf = $self->conf;
2305   my %opt = @_;
2306
2307   my $cust_main = $self->cust_main;
2308   my $balance = $cust_main->balance;
2309   my $amount = ( $balance < $self->owed ) ? $balance : $self->owed;
2310   $amount = sprintf("%.2f", $amount);
2311   return "not run (balance $balance)" unless $amount > 0;
2312
2313   my $description = 'Internet Services';
2314   if ( $conf->exists('business-onlinepayment-description') ) {
2315     my $dtempl = $conf->config('business-onlinepayment-description');
2316
2317     my $agent_obj = $cust_main->agent
2318       or die "can't retreive agent for $cust_main (agentnum ".
2319              $cust_main->agentnum. ")";
2320     my $agent = $agent_obj->agent;
2321     my $pkgs = join(', ',
2322       map { $_->part_pkg->pkg }
2323         grep { $_->pkgnum } $self->cust_bill_pkg
2324     );
2325     $description = eval qq("$dtempl");
2326   }
2327
2328   $cust_main->realtime_bop($method, $amount,
2329     'description' => $description,
2330     'invnum'      => $self->invnum,
2331 #this didn't do what we want, it just calls apply_payments_and_credits
2332 #    'apply'       => 1,
2333     'apply_to_invoice' => 1,
2334     %opt,
2335  #what we want:
2336  #this changes application behavior: auto payments
2337                         #triggered against a specific invoice are now applied
2338                         #to that invoice instead of oldest open.
2339                         #seem okay to me...
2340   );
2341
2342 }
2343
2344 =item batch_card OPTION => VALUE...
2345
2346 Adds a payment for this invoice to the pending credit card batch (see
2347 L<FS::cust_pay_batch>), or, if the B<realtime> option is set to a true value,
2348 runs the payment using a realtime gateway.
2349
2350 =cut
2351
2352 sub batch_card {
2353   my ($self, %options) = @_;
2354   my $cust_main = $self->cust_main;
2355
2356   $options{invnum} = $self->invnum;
2357
2358   $cust_main->batch_card(%options);
2359 }
2360
2361 sub _agent_template {
2362   my $self = shift;
2363   $self->cust_main->agent_template;
2364 }
2365
2366 sub _agent_invoice_from {
2367   my $self = shift;
2368   $self->cust_main->agent_invoice_from;
2369 }
2370
2371 =item invoice_barcode DIR_OR_FALSE
2372
2373 Generates an invoice barcode PNG. If DIR_OR_FALSE is a true value,
2374 it is taken as the temp directory where the PNG file will be generated and the
2375 PNG file name is returned. Otherwise, the PNG image itself is returned.
2376
2377 =cut
2378
2379 sub invoice_barcode {
2380     my ($self, $dir) = (shift,shift);
2381
2382     my $gdbar = new GD::Barcode('Code39',$self->invnum);
2383         die "can't create barcode: " . $GD::Barcode::errStr unless $gdbar;
2384     my $gd = $gdbar->plot(Height => 30);
2385
2386     if($dir) {
2387         my $bh = new File::Temp( TEMPLATE => 'barcode.'. $self->invnum. '.XXXXXXXX',
2388                            DIR      => $dir,
2389                            SUFFIX   => '.png',
2390                            UNLINK   => 0,
2391                          ) or die "can't open temp file: $!\n";
2392         print $bh $gd->png or die "cannot write barcode to file: $!\n";
2393         my $png_file = $bh->filename;
2394         close $bh;
2395         return $png_file;
2396     }
2397     return $gd->png;
2398 }
2399
2400 =item invnum_date_pretty
2401
2402 Returns a string with the invoice number and date, for example:
2403 "Invoice #54 (3/20/2008)"
2404
2405 =cut
2406
2407 #note: this uses _date_pretty_unlocalized because _date_pretty is too expensive
2408 # for backend use (and also does the wrong thing, localizing for end customer
2409 # instead of backoffice configured date format)
2410 sub invnum_date_pretty {
2411   my $self = shift;
2412   $self->mt('Invoice #'). $self->invnum. ' ('. $self->_date_pretty_unlocalized. ')';
2413 }
2414
2415 #sub _items_extra_usage_sections {
2416 #  my $self = shift;
2417 #  my $escape = shift;
2418 #
2419 #  my %sections = ();
2420 #
2421 #  my %usage_class =  map{ $_->classname, $_ } qsearch('usage_class', {});
2422 #  foreach my $cust_bill_pkg ( $self->cust_bill_pkg )
2423 #  {
2424 #    next unless $cust_bill_pkg->pkgnum > 0;
2425 #
2426 #    foreach my $section ( keys %usage_class ) {
2427 #
2428 #      my $usage = $cust_bill_pkg->usage($section);
2429 #
2430 #      next unless $usage && $usage > 0;
2431 #
2432 #      $sections{$section} ||= 0;
2433 #      $sections{$section} += $usage;
2434 #
2435 #    }
2436 #
2437 #  }
2438 #
2439 #  map { { 'description' => &{$escape}($_),
2440 #          'subtotal'    => $sections{$_},
2441 #          'summarized'  => '',
2442 #          'tax_section' => '',
2443 #        }
2444 #      }
2445 #    sort {$usage_class{$a}->weight <=> $usage_class{$b}->weight} keys %sections;
2446 #
2447 #}
2448
2449 sub _items_extra_usage_sections {
2450   my $self = shift;
2451   my $conf = $self->conf;
2452   my $escape = shift;
2453   my $format = shift;
2454
2455   my %sections = ();
2456   my %classnums = ();
2457   my %lines = ();
2458
2459   my $maxlength = $conf->config('cust_bill-latex_lineitem_maxlength') || 50;
2460
2461   my %usage_class =  map { $_->classnum => $_ } qsearch( 'usage_class', {} );
2462   foreach my $cust_bill_pkg ( $self->cust_bill_pkg ) {
2463     next unless $cust_bill_pkg->pkgnum > 0;
2464
2465     foreach my $classnum ( keys %usage_class ) {
2466       my $section = $usage_class{$classnum}->classname;
2467       $classnums{$section} = $classnum;
2468
2469       foreach my $detail ( $cust_bill_pkg->cust_bill_pkg_detail($classnum) ) {
2470         my $amount = $detail->amount;
2471         next unless $amount && $amount > 0;
2472
2473         $sections{$section} ||= { 'subtotal'=>0, 'calls'=>0, 'duration'=>0 };
2474         $sections{$section}{amount} += $amount;  #subtotal
2475         $sections{$section}{calls}++;
2476         $sections{$section}{duration} += $detail->duration;
2477
2478         my $desc = $detail->regionname;
2479         my $description = $desc;
2480         $description = substr($desc, 0, $maxlength). '...'
2481           if $format eq 'latex' && length($desc) > $maxlength;
2482
2483         $lines{$section}{$desc} ||= {
2484           description     => &{$escape}($description),
2485           #pkgpart         => $part_pkg->pkgpart,
2486           pkgnum          => $cust_bill_pkg->pkgnum,
2487           ref             => '',
2488           amount          => 0,
2489           calls           => 0,
2490           duration        => 0,
2491           #unit_amount     => $cust_bill_pkg->unitrecur,
2492           quantity        => $cust_bill_pkg->quantity,
2493           product_code    => 'N/A',
2494           ext_description => [],
2495         };
2496
2497         $lines{$section}{$desc}{amount} += $amount;
2498         $lines{$section}{$desc}{calls}++;
2499         $lines{$section}{$desc}{duration} += $detail->duration;
2500
2501       }
2502     }
2503   }
2504
2505   my %sectionmap = ();
2506   foreach (keys %sections) {
2507     my $usage_class = $usage_class{$classnums{$_}};
2508     $sectionmap{$_} = { 'description' => &{$escape}($_),
2509                         'amount'    => $sections{$_}{amount},    #subtotal
2510                         'calls'       => $sections{$_}{calls},
2511                         'duration'    => $sections{$_}{duration},
2512                         'summarized'  => '',
2513                         'tax_section' => '',
2514                         'sort_weight' => $usage_class->weight,
2515                         ( $usage_class->format
2516                           ? ( map { $_ => $usage_class->$_($format) }
2517                               qw( description_generator header_generator total_generator total_line_generator )
2518                             )
2519                           : ()
2520                         ),
2521                       };
2522   }
2523
2524   my @sections = sort { $a->{sort_weight} <=> $b->{sort_weight} }
2525                  values %sectionmap;
2526
2527   my @lines = ();
2528   foreach my $section ( keys %lines ) {
2529     foreach my $line ( keys %{$lines{$section}} ) {
2530       my $l = $lines{$section}{$line};
2531       $l->{section}     = $sectionmap{$section};
2532       $l->{amount}      = sprintf( "%.2f", $l->{amount} );
2533       #$l->{unit_amount} = sprintf( "%.2f", $l->{unit_amount} );
2534       push @lines, $l;
2535     }
2536   }
2537
2538   return(\@sections, \@lines);
2539
2540 }
2541
2542 sub _did_summary {
2543     my $self = shift;
2544     my $end = $self->_date;
2545
2546     # start at date of previous invoice + 1 second or 0 if no previous invoice
2547     my $start = $self->scalar_sql("SELECT max(_date) FROM cust_bill WHERE custnum = ? and invnum != ?",$self->custnum,$self->invnum);
2548     $start = 0 if !$start;
2549     $start++;
2550
2551     my $cust_main = $self->cust_main;
2552     my @pkgs = $cust_main->all_pkgs;
2553     my($num_activated,$num_deactivated,$num_portedin,$num_portedout,$minutes)
2554         = (0,0,0,0,0);
2555     my @seen = ();
2556     foreach my $pkg ( @pkgs ) {
2557         my @h_cust_svc = $pkg->h_cust_svc($end);
2558         foreach my $h_cust_svc ( @h_cust_svc ) {
2559             next if grep {$_ eq $h_cust_svc->svcnum} @seen;
2560             next unless $h_cust_svc->part_svc->svcdb eq 'svc_phone';
2561
2562             my $inserted = $h_cust_svc->date_inserted;
2563             my $deleted = $h_cust_svc->date_deleted;
2564             my $phone_inserted = $h_cust_svc->h_svc_x($inserted+5);
2565             my $phone_deleted;
2566             $phone_deleted =  $h_cust_svc->h_svc_x($deleted) if $deleted;
2567
2568 # DID either activated or ported in; cannot be both for same DID simultaneously
2569             if ($inserted >= $start && $inserted <= $end && $phone_inserted
2570                 && (!$phone_inserted->lnp_status
2571                     || $phone_inserted->lnp_status eq ''
2572                     || $phone_inserted->lnp_status eq 'native')) {
2573                 $num_activated++;
2574             }
2575             else { # this one not so clean, should probably move to (h_)svc_phone
2576                  my $phone_portedin = qsearchs( 'h_svc_phone',
2577                       { 'svcnum' => $h_cust_svc->svcnum,
2578                         'lnp_status' => 'portedin' },
2579                       FS::h_svc_phone->sql_h_searchs($end),
2580                     );
2581                  $num_portedin++ if $phone_portedin;
2582             }
2583
2584 # DID either deactivated or ported out; cannot be both for same DID simultaneously
2585             if($deleted >= $start && $deleted <= $end && $phone_deleted
2586                 && (!$phone_deleted->lnp_status
2587                     || $phone_deleted->lnp_status ne 'portingout')) {
2588                 $num_deactivated++;
2589             }
2590             elsif($deleted >= $start && $deleted <= $end && $phone_deleted
2591                 && $phone_deleted->lnp_status
2592                 && $phone_deleted->lnp_status eq 'portingout') {
2593                 $num_portedout++;
2594             }
2595
2596             # increment usage minutes
2597         if ( $phone_inserted ) {
2598             my @cdrs = $phone_inserted->get_cdrs('begin'=>$start,'end'=>$end,'billsec_sum'=>1);
2599             $minutes = $cdrs[0]->billsec_sum if scalar(@cdrs) == 1;
2600         }
2601         else {
2602             warn "WARNING: no matching h_svc_phone insert record for insert time $inserted, svcnum " . $h_cust_svc->svcnum;
2603         }
2604
2605             # don't look at this service again
2606             push @seen, $h_cust_svc->svcnum;
2607         }
2608     }
2609
2610     $minutes = sprintf("%d", $minutes);
2611     ("Activated: $num_activated  Ported-In: $num_portedin  Deactivated: "
2612         . "$num_deactivated  Ported-Out: $num_portedout ",
2613             "Total Minutes: $minutes");
2614 }
2615
2616 sub _items_accountcode_cdr {
2617     my $self = shift;
2618     my $escape = shift;
2619     my $format = shift;
2620
2621     my $section = { 'amount'        => 0,
2622                     'calls'         => 0,
2623                     'duration'      => 0,
2624                     'sort_weight'   => '',
2625                     'phonenum'      => '',
2626                     'description'   => 'Usage by Account Code',
2627                     'post_total'    => '',
2628                     'summarized'    => '',
2629                     'header'        => '',
2630                   };
2631     my @lines;
2632     my %accountcodes = ();
2633
2634     foreach my $cust_bill_pkg ( $self->cust_bill_pkg ) {
2635         next unless $cust_bill_pkg->pkgnum > 0;
2636
2637         my @header = $cust_bill_pkg->details_header;
2638         next unless scalar(@header);
2639         $section->{'header'} = join(',',@header);
2640
2641         foreach my $detail ( $cust_bill_pkg->cust_bill_pkg_detail ) {
2642
2643             $section->{'header'} = $detail->formatted('format' => $format)
2644                 if($detail->detail eq $section->{'header'});
2645
2646             my $accountcode = $detail->accountcode;
2647             next unless $accountcode;
2648
2649             my $amount = $detail->amount;
2650             next unless $amount && $amount > 0;
2651
2652             $accountcodes{$accountcode} ||= {
2653                     description => $accountcode,
2654                     pkgnum      => '',
2655                     ref         => '',
2656                     amount      => 0,
2657                     calls       => 0,
2658                     duration    => 0,
2659                     quantity    => '',
2660                     product_code => 'N/A',
2661                     section     => $section,
2662                     ext_description => [ $section->{'header'} ],
2663                     detail_temp => [],
2664             };
2665
2666             $section->{'amount'} += $amount;
2667             $accountcodes{$accountcode}{'amount'} += $amount;
2668             $accountcodes{$accountcode}{calls}++;
2669             $accountcodes{$accountcode}{duration} += $detail->duration;
2670             push @{$accountcodes{$accountcode}{detail_temp}}, $detail;
2671         }
2672     }
2673
2674     foreach my $l ( values %accountcodes ) {
2675         $l->{amount} = sprintf( "%.2f", $l->{amount} );
2676         my @sorted_detail = sort { $a->startdate <=> $b->startdate } @{$l->{detail_temp}};
2677         foreach my $sorted_detail ( @sorted_detail ) {
2678             push @{$l->{ext_description}}, $sorted_detail->formatted('format'=>$format);
2679         }
2680         delete $l->{detail_temp};
2681         push @lines, $l;
2682     }
2683
2684     my @sorted_lines = sort { $a->{'description'} <=> $b->{'description'} } @lines;
2685
2686     return ($section,\@sorted_lines);
2687 }
2688
2689 sub _items_svc_phone_sections {
2690   my $self = shift;
2691   my $conf = $self->conf;
2692   my $escape = shift;
2693   my $format = shift;
2694
2695   my %sections = ();
2696   my %classnums = ();
2697   my %lines = ();
2698
2699   my $maxlength = $conf->config('cust_bill-latex_lineitem_maxlength') || 50;
2700
2701   my %usage_class =  map { $_->classnum => $_ } qsearch( 'usage_class', {} );
2702   $usage_class{''} ||= new FS::usage_class { 'classname' => '', 'weight' => 0 };
2703
2704   foreach my $cust_bill_pkg ( $self->cust_bill_pkg ) {
2705     next unless $cust_bill_pkg->pkgnum > 0;
2706
2707     my @header = $cust_bill_pkg->details_header;
2708     next unless scalar(@header);
2709
2710     foreach my $detail ( $cust_bill_pkg->cust_bill_pkg_detail ) {
2711
2712       my $phonenum = $detail->phonenum;
2713       next unless $phonenum;
2714
2715       my $amount = $detail->amount;
2716       next unless $amount && $amount > 0;
2717
2718       $sections{$phonenum} ||= { 'amount'      => 0,
2719                                  'calls'       => 0,
2720                                  'duration'    => 0,
2721                                  'sort_weight' => -1,
2722                                  'phonenum'    => $phonenum,
2723                                 };
2724       $sections{$phonenum}{amount} += $amount;  #subtotal
2725       $sections{$phonenum}{calls}++;
2726       $sections{$phonenum}{duration} += $detail->duration;
2727
2728       my $desc = $detail->regionname;
2729       my $description = $desc;
2730       $description = substr($desc, 0, $maxlength). '...'
2731         if $format eq 'latex' && length($desc) > $maxlength;
2732
2733       $lines{$phonenum}{$desc} ||= {
2734         description     => &{$escape}($description),
2735         #pkgpart         => $part_pkg->pkgpart,
2736         pkgnum          => '',
2737         ref             => '',
2738         amount          => 0,
2739         calls           => 0,
2740         duration        => 0,
2741         #unit_amount     => '',
2742         quantity        => '',
2743         product_code    => 'N/A',
2744         ext_description => [],
2745       };
2746
2747       $lines{$phonenum}{$desc}{amount} += $amount;
2748       $lines{$phonenum}{$desc}{calls}++;
2749       $lines{$phonenum}{$desc}{duration} += $detail->duration;
2750
2751       my $line = $usage_class{$detail->classnum}->classname;
2752       $sections{"$phonenum $line"} ||=
2753         { 'amount' => 0,
2754           'calls' => 0,
2755           'duration' => 0,
2756           'sort_weight' => $usage_class{$detail->classnum}->weight,
2757           'phonenum' => $phonenum,
2758           'header'  => [ @header ],
2759         };
2760       $sections{"$phonenum $line"}{amount} += $amount;  #subtotal
2761       $sections{"$phonenum $line"}{calls}++;
2762       $sections{"$phonenum $line"}{duration} += $detail->duration;
2763
2764       $lines{"$phonenum $line"}{$desc} ||= {
2765         description     => &{$escape}($description),
2766         #pkgpart         => $part_pkg->pkgpart,
2767         pkgnum          => '',
2768         ref             => '',
2769         amount          => 0,
2770         calls           => 0,
2771         duration        => 0,
2772         #unit_amount     => '',
2773         quantity        => '',
2774         product_code    => 'N/A',
2775         ext_description => [],
2776       };
2777
2778       $lines{"$phonenum $line"}{$desc}{amount} += $amount;
2779       $lines{"$phonenum $line"}{$desc}{calls}++;
2780       $lines{"$phonenum $line"}{$desc}{duration} += $detail->duration;
2781       push @{$lines{"$phonenum $line"}{$desc}{ext_description}},
2782            $detail->formatted('format' => $format);
2783
2784     }
2785   }
2786
2787   my %sectionmap = ();
2788   my $simple = new FS::usage_class { format => 'simple' }; #bleh
2789   foreach ( keys %sections ) {
2790     my @header = @{ $sections{$_}{header} || [] };
2791     my $usage_simple =
2792       new FS::usage_class { format => 'usage_'. (scalar(@header) || 6). 'col' };
2793     my $summary = $sections{$_}{sort_weight} < 0 ? 1 : 0;
2794     my $usage_class = $summary ? $simple : $usage_simple;
2795     my $ending = $summary ? ' usage charges' : '';
2796     my %gen_opt = ();
2797     unless ($summary) {
2798       $gen_opt{label} = [ map{ &{$escape}($_) } @header ];
2799     }
2800     $sectionmap{$_} = { 'description' => &{$escape}($_. $ending),
2801                         'amount'    => $sections{$_}{amount},    #subtotal
2802                         'calls'       => $sections{$_}{calls},
2803                         'duration'    => $sections{$_}{duration},
2804                         'summarized'  => '',
2805                         'tax_section' => '',
2806                         'phonenum'    => $sections{$_}{phonenum},
2807                         'sort_weight' => $sections{$_}{sort_weight},
2808                         'post_total'  => $summary, #inspire pagebreak
2809                         (
2810                           ( map { $_ => $usage_class->$_($format, %gen_opt) }
2811                             qw( description_generator
2812                                 header_generator
2813                                 total_generator
2814                                 total_line_generator
2815                               )
2816                           )
2817                         ),
2818                       };
2819   }
2820
2821   my @sections = sort { $a->{phonenum} cmp $b->{phonenum} ||
2822                         $a->{sort_weight} <=> $b->{sort_weight}
2823                       }
2824                  values %sectionmap;
2825
2826   my @lines = ();
2827   foreach my $section ( keys %lines ) {
2828     foreach my $line ( keys %{$lines{$section}} ) {
2829       my $l = $lines{$section}{$line};
2830       $l->{section}     = $sectionmap{$section};
2831       $l->{amount}      = sprintf( "%.2f", $l->{amount} );
2832       #$l->{unit_amount} = sprintf( "%.2f", $l->{unit_amount} );
2833       push @lines, $l;
2834     }
2835   }
2836
2837   if($conf->exists('phone_usage_class_summary')) {
2838       # this only works with Latex
2839       my @newlines;
2840       my @newsections;
2841
2842       # after this, we'll have only two sections per DID:
2843       # Calls Summary and Calls Detail
2844       foreach my $section ( @sections ) {
2845         if($section->{'post_total'}) {
2846             $section->{'description'} = 'Calls Summary: '.$section->{'phonenum'};
2847             $section->{'total_line_generator'} = sub { '' };
2848             $section->{'total_generator'} = sub { '' };
2849             $section->{'header_generator'} = sub { '' };
2850             $section->{'description_generator'} = '';
2851             push @newsections, $section;
2852             my %calls_detail = %$section;
2853             $calls_detail{'post_total'} = '';
2854             $calls_detail{'sort_weight'} = '';
2855             $calls_detail{'description_generator'} = sub { '' };
2856             $calls_detail{'header_generator'} = sub {
2857                 return ' & Date/Time & Called Number & Duration & Price'
2858                     if $format eq 'latex';
2859                 '';
2860             };
2861             $calls_detail{'description'} = 'Calls Detail: '
2862                                                     . $section->{'phonenum'};
2863             push @newsections, \%calls_detail;
2864         }
2865       }
2866
2867       # after this, each usage class is collapsed/summarized into a single
2868       # line under the Calls Summary section
2869       foreach my $newsection ( @newsections ) {
2870         if($newsection->{'post_total'}) { # this means Calls Summary
2871             foreach my $section ( @sections ) {
2872                 next unless ($section->{'phonenum'} eq $newsection->{'phonenum'}
2873                                 && !$section->{'post_total'});
2874                 my $newdesc = $section->{'description'};
2875                 my $tn = $section->{'phonenum'};
2876                 $newdesc =~ s/$tn//g;
2877                 my $line = {  ext_description => [],
2878                               pkgnum => '',
2879                               ref => '',
2880                               quantity => '',
2881                               calls => $section->{'calls'},
2882                               section => $newsection,
2883                               duration => $section->{'duration'},
2884                               description => $newdesc,
2885                               amount => sprintf("%.2f",$section->{'amount'}),
2886                               product_code => 'N/A',
2887                             };
2888                 push @newlines, $line;
2889             }
2890         }
2891       }
2892
2893       # after this, Calls Details is populated with all CDRs
2894       foreach my $newsection ( @newsections ) {
2895         if(!$newsection->{'post_total'}) { # this means Calls Details
2896             foreach my $line ( @lines ) {
2897                 next unless (scalar(@{$line->{'ext_description'}}) &&
2898                         $line->{'section'}->{'phonenum'} eq $newsection->{'phonenum'}
2899                             );
2900                 my @extdesc = @{$line->{'ext_description'}};
2901                 my @newextdesc;
2902                 foreach my $extdesc ( @extdesc ) {
2903                     $extdesc =~ s/scriptsize/normalsize/g if $format eq 'latex';
2904                     push @newextdesc, $extdesc;
2905                 }
2906                 $line->{'ext_description'} = \@newextdesc;
2907                 $line->{'section'} = $newsection;
2908                 push @newlines, $line;
2909             }
2910         }
2911       }
2912
2913       return(\@newsections, \@newlines);
2914   }
2915
2916   return(\@sections, \@lines);
2917
2918 }
2919
2920 =sub _items_usage_class_summary OPTIONS
2921
2922 Returns a list of detail items summarizing the usage charges on this
2923 invoice.  Each one will have 'amount', 'description' (the usage charge name),
2924 and 'usage_classnum'.
2925
2926 OPTIONS can include 'escape' (a function to escape the descriptions).
2927
2928 =cut
2929
2930 sub _items_usage_class_summary {
2931   my $self = shift;
2932   my %opt = @_;
2933
2934   my $escape = $opt{escape} || sub { $_[0] };
2935   my $invnum = $self->invnum;
2936   my @classes = qsearch({
2937       'table'     => 'usage_class',
2938       'select'    => 'classnum, classname, SUM(amount) AS amount',
2939       'addl_from' => ' LEFT JOIN cust_bill_pkg_detail USING (classnum)' .
2940                      ' LEFT JOIN cust_bill_pkg USING (billpkgnum)',
2941       'extra_sql' => " WHERE cust_bill_pkg.invnum = $invnum".
2942                      ' GROUP BY classnum, classname, weight'.
2943                      ' HAVING (usage_class.disabled IS NULL OR SUM(amount) > 0)'.
2944                      ' ORDER BY weight ASC',
2945   });
2946   my @l;
2947   my $section = {
2948     description   => &{$escape}($self->mt('Usage Summary')),
2949     no_subtotal   => 1,
2950     usage_section => 1,
2951   };
2952   foreach my $class (@classes) {
2953     push @l, {
2954       'description'     => &{$escape}($class->classname),
2955       'amount'          => sprintf('%.2f', $class->amount),
2956       'usage_classnum'  => $class->classnum,
2957       'section'         => $section,
2958     };
2959   }
2960   return @l;
2961 }
2962
2963 sub _items_previous {
2964   my $self = shift;
2965   my $conf = $self->conf;
2966   my $cust_main = $self->cust_main;
2967   my( $pr_total, @pr_cust_bill ) = $self->previous; #previous balance
2968   my @b = ();
2969   foreach ( @pr_cust_bill ) {
2970     my $date = $conf->exists('invoice_show_prior_due_date')
2971                ? 'due '. $_->due_date2str('short')
2972                : $self->time2str_local('short', $_->_date);
2973     push @b, {
2974       'description' => $self->mt('Previous Balance, Invoice #'). $_->invnum. " ($date)",
2975       #'pkgpart'     => 'N/A',
2976       'pkgnum'      => 'N/A',
2977       'amount'      => sprintf("%.2f", $_->owed),
2978     };
2979   }
2980   @b;
2981
2982   #{
2983   #    'description'     => 'Previous Balance',
2984   #    #'pkgpart'         => 'N/A',
2985   #    'pkgnum'          => 'N/A',
2986   #    'amount'          => sprintf("%10.2f", $pr_total ),
2987   #    'ext_description' => [ map {
2988   #                                 "Invoice ". $_->invnum.
2989   #                                 " (". time2str("%x",$_->_date). ") ".
2990   #                                 sprintf("%10.2f", $_->owed)
2991   #                         } @pr_cust_bill ],
2992
2993   #};
2994 }
2995
2996 sub _items_credits {
2997   my( $self, %opt ) = @_;
2998   my $trim_len = $opt{'trim_len'} || 60;
2999
3000   my @b;
3001   #credits
3002   my @objects;
3003   if ( $self->conf->exists('previous_balance-payments_since') ) {
3004     if ( $opt{'template'} eq 'statement' ) {
3005       # then the current bill is a "statement" (i.e. an invoice sent as
3006       # a payment receipt)
3007       # and in that case we want to see payments on or after THIS invoice
3008       @objects = qsearch('cust_credit', {
3009           'custnum' => $self->custnum,
3010           '_date'   => {op => '>=', value => $self->_date},
3011       });
3012     } else {
3013       my $date = 0;
3014       $date = $self->previous_bill->_date if $self->previous_bill;
3015       @objects = qsearch('cust_credit', {
3016           'custnum' => $self->custnum,
3017           '_date'   => {op => '>=', value => $date},
3018       });
3019     }
3020   } else {
3021     @objects = $self->cust_credited;
3022   }
3023
3024   foreach my $obj ( @objects ) {
3025     my $cust_credit = $obj->isa('FS::cust_credit') ? $obj : $obj->cust_credit;
3026
3027     my $reason = substr($cust_credit->reason, 0, $trim_len);
3028     $reason .= '...' if length($reason) < length($cust_credit->reason);
3029     $reason = " ($reason) " if $reason;
3030
3031     push @b, {
3032       #'description' => 'Credit ref\#'. $_->crednum.
3033       #                 " (". time2str("%x",$_->cust_credit->_date) .")".
3034       #                 $reason,
3035       'description' => $self->mt('Credit applied').' '.
3036                        $self->time2str_local('short', $obj->_date). $reason,
3037       'amount'      => sprintf("%.2f",$obj->amount),
3038     };
3039   }
3040
3041   @b;
3042
3043 }
3044
3045 sub _items_payments {
3046   my $self = shift;
3047   my %opt = @_;
3048
3049   my @b;
3050   my $detailed = $self->conf->exists('invoice_payment_details');
3051   my @objects;
3052   if ( $self->conf->exists('previous_balance-payments_since') ) {
3053     # then show payments dated on/after the previous bill...
3054     if ( $opt{'template'} eq 'statement' ) {
3055       # then the current bill is a "statement" (i.e. an invoice sent as
3056       # a payment receipt)
3057       # and in that case we want to see payments on or after THIS invoice
3058       @objects = qsearch('cust_pay', {
3059           'custnum' => $self->custnum,
3060           '_date'   => {op => '>=', value => $self->_date},
3061       });
3062     } else {
3063       # the normal case: payments on or after the previous invoice
3064       my $date = 0;
3065       $date = $self->previous_bill->_date if $self->previous_bill;
3066       @objects = qsearch('cust_pay', {
3067         'custnum' => $self->custnum,
3068         '_date'   => {op => '>=', value => $date},
3069       });
3070       # and before the current bill...
3071       @objects = grep { $_->_date < $self->_date } @objects;
3072     }
3073   } else {
3074     @objects = $self->cust_bill_pay;
3075   }
3076
3077   foreach my $obj (@objects) {
3078     my $cust_pay = $obj->isa('FS::cust_pay') ? $obj : $obj->cust_pay;
3079     my $desc = $self->mt('Payment received').' '.
3080                $self->time2str_local('short', $cust_pay->_date );
3081     $desc .= $self->mt(' via ') .
3082              $cust_pay->payby_payinfo_pretty( $self->cust_main->locale )
3083       if $detailed;
3084
3085     push @b, {
3086       'description' => $desc,
3087       'amount'      => sprintf("%.2f", $obj->amount )
3088     };
3089   }
3090
3091   @b;
3092
3093 }
3094
3095 =item call_details [ OPTION => VALUE ... ]
3096
3097 Returns an array of CSV strings representing the call details for this invoice
3098 The only option available is the boolean prepend_billed_number
3099
3100 =cut
3101
3102 sub call_details {
3103   my ($self, %opt) = @_;
3104
3105   my $format_function = sub { shift };
3106
3107   if ($opt{prepend_billed_number}) {
3108     $format_function = sub {
3109       my $detail = shift;
3110       my $row = shift;
3111
3112       $row->amount ? $row->phonenum. ",". $detail : '"Billed number",'. $detail;
3113
3114     };
3115   }
3116
3117   my @details = map { $_->details( 'format_function' => $format_function,
3118                                    'escape_function' => sub{ return() },
3119                                  )
3120                     }
3121                   grep { $_->pkgnum }
3122                   $self->cust_bill_pkg;
3123   my $header = $details[0];
3124   ( $header, grep { $_ ne $header } @details );
3125 }
3126
3127
3128 =back
3129
3130 =head1 SUBROUTINES
3131
3132 =over 4
3133
3134 =item process_reprint
3135
3136 =cut
3137
3138 sub process_reprint {
3139   process_re_X('print', @_);
3140 }
3141
3142 =item process_reemail
3143
3144 =cut
3145
3146 sub process_reemail {
3147   process_re_X('email', @_);
3148 }
3149
3150 =item process_refax
3151
3152 =cut
3153
3154 sub process_refax {
3155   process_re_X('fax', @_);
3156 }
3157
3158 =item process_reftp
3159
3160 =cut
3161
3162 sub process_reftp {
3163   process_re_X('ftp', @_);
3164 }
3165
3166 =item respool
3167
3168 =cut
3169
3170 sub process_respool {
3171   process_re_X('spool', @_);
3172 }
3173
3174 use Storable qw(thaw);
3175 use Data::Dumper;
3176 use MIME::Base64;
3177 sub process_re_X {
3178   my( $method, $job ) = ( shift, shift );
3179   warn "$me process_re_X $method for job $job\n" if $DEBUG;
3180
3181   my $param = thaw(decode_base64(shift));
3182   warn Dumper($param) if $DEBUG;
3183
3184   re_X(
3185     $method,
3186     $job,
3187     %$param,
3188   );
3189
3190 }
3191
3192 sub re_X {
3193   # spool_invoice ftp_invoice fax_invoice print_invoice
3194   my($method, $job, %param ) = @_;
3195   if ( $DEBUG ) {
3196     warn "re_X $method for job $job with param:\n".
3197          join( '', map { "  $_ => ". $param{$_}. "\n" } keys %param );
3198   }
3199
3200   #some false laziness w/search/cust_bill.html
3201   my $distinct = '';
3202   my $orderby = 'ORDER BY cust_bill._date';
3203
3204   my $extra_sql = ' WHERE '. FS::cust_bill->search_sql_where(\%param);
3205
3206   my $addl_from = 'LEFT JOIN cust_main USING ( custnum )';
3207
3208   my @cust_bill = qsearch( {
3209     #'select'    => "cust_bill.*",
3210     'table'     => 'cust_bill',
3211     'addl_from' => $addl_from,
3212     'hashref'   => {},
3213     'extra_sql' => $extra_sql,
3214     'order_by'  => $orderby,
3215     'debug' => 1,
3216   } );
3217
3218   $method .= '_invoice' unless $method eq 'email' || $method eq 'print';
3219
3220   warn " $me re_X $method: ". scalar(@cust_bill). " invoices found\n"
3221     if $DEBUG;
3222
3223   my( $num, $last, $min_sec ) = (0, time, 5); #progresbar foo
3224   foreach my $cust_bill ( @cust_bill ) {
3225     $cust_bill->$method();
3226
3227     if ( $job ) { #progressbar foo
3228       $num++;
3229       if ( time - $min_sec > $last ) {
3230         my $error = $job->update_statustext(
3231           int( 100 * $num / scalar(@cust_bill) )
3232         );
3233         die $error if $error;
3234         $last = time;
3235       }
3236     }
3237
3238   }
3239
3240 }
3241
3242 =back
3243
3244 =head1 CLASS METHODS
3245
3246 =over 4
3247
3248 =item owed_sql
3249
3250 Returns an SQL fragment to retreive the amount owed (charged minus credited and paid).
3251
3252 =cut
3253
3254 sub owed_sql {
3255   my ($class, $start, $end) = @_;
3256   'charged - '.
3257     $class->paid_sql($start, $end). ' - '.
3258     $class->credited_sql($start, $end);
3259 }
3260
3261 =item net_sql
3262
3263 Returns an SQL fragment to retreive the net amount (charged minus credited).
3264
3265 =cut
3266
3267 sub net_sql {
3268   my ($class, $start, $end) = @_;
3269   'charged - '. $class->credited_sql($start, $end);
3270 }
3271
3272 =item paid_sql
3273
3274 Returns an SQL fragment to retreive the amount paid against this invoice.
3275
3276 =cut
3277
3278 sub paid_sql {
3279   my ($class, $start, $end) = @_;
3280   $start &&= "AND cust_bill_pay._date <= $start";
3281   $end   &&= "AND cust_bill_pay._date > $end";
3282   $start = '' unless defined($start);
3283   $end   = '' unless defined($end);
3284   "( SELECT COALESCE(SUM(amount),0) FROM cust_bill_pay
3285        WHERE cust_bill.invnum = cust_bill_pay.invnum $start $end  )";
3286 }
3287
3288 =item credited_sql
3289
3290 Returns an SQL fragment to retreive the amount credited against this invoice.
3291
3292 =cut
3293
3294 sub credited_sql {
3295   my ($class, $start, $end) = @_;
3296   $start &&= "AND cust_credit_bill._date <= $start";
3297   $end   &&= "AND cust_credit_bill._date >  $end";
3298   $start = '' unless defined($start);
3299   $end   = '' unless defined($end);
3300   "( SELECT COALESCE(SUM(amount),0) FROM cust_credit_bill
3301        WHERE cust_bill.invnum = cust_credit_bill.invnum $start $end  )";
3302 }
3303
3304 =item due_date_sql
3305
3306 Returns an SQL fragment to retrieve the due date of an invoice.
3307 Currently only supported on PostgreSQL.
3308
3309 =cut
3310
3311 sub due_date_sql {
3312   my $conf = new FS::Conf;
3313 'COALESCE(
3314   SUBSTRING(
3315     COALESCE(
3316       cust_bill.invoice_terms,
3317       cust_main.invoice_terms,
3318       \''.($conf->config('invoice_default_terms') || '').'\'
3319     ), E\'Net (\\\\d+)\'
3320   )::INTEGER, 0
3321 ) * 86400 + cust_bill._date'
3322 }
3323
3324 =item search_sql_where HASHREF
3325
3326 Class method which returns an SQL WHERE fragment to search for parameters
3327 specified in HASHREF.  Valid parameters are
3328
3329 =over 4
3330
3331 =item _date
3332
3333 List reference of start date, end date, as UNIX timestamps.
3334
3335 =item invnum_min
3336
3337 =item invnum_max
3338
3339 =item agentnum
3340
3341 =item charged
3342
3343 List reference of charged limits (exclusive).
3344
3345 =item owed
3346
3347 List reference of charged limits (exclusive).
3348
3349 =item open
3350
3351 flag, return open invoices only
3352
3353 =item net
3354
3355 flag, return net invoices only
3356
3357 =item days
3358
3359 =item newest_percust
3360
3361 =item custnum
3362
3363 Return only invoices belonging to that customer.
3364
3365 =item cust_classnum
3366
3367 Limit to that customer class (single value or arrayref).
3368
3369 =item payby
3370
3371 Limit to customers with that payment method (single value or arrayref).
3372
3373 =item refnum
3374
3375 Limit to customers with that advertising source.
3376
3377 =back
3378
3379 Note: validates all passed-in data; i.e. safe to use with unchecked CGI params.
3380
3381 =cut
3382
3383 sub search_sql_where {
3384   my($class, $param) = @_;
3385   if ( $DEBUG ) {
3386     warn "$me search_sql_where called with params: \n".
3387          join("\n", map { "  $_: ". $param->{$_} } keys %$param ). "\n";
3388   }
3389
3390   my @search = ();
3391
3392   #agentnum
3393   if ( $param->{'agentnum'} =~ /^(\d+)$/ ) {
3394     push @search, "cust_main.agentnum = $1";
3395   }
3396
3397   #refnum
3398   if ( $param->{'refnum'} =~ /^(\d+)$/ ) {
3399     push @search, "cust_main.refnum = $1";
3400   }
3401
3402   #custnum
3403   if ( $param->{'custnum'} =~ /^(\d+)$/ ) {
3404     push @search, "cust_bill.custnum = $1";
3405   }
3406
3407   #customer classnum (false laziness w/ cust_main/Search.pm)
3408   if ( $param->{'cust_classnum'} ) {
3409
3410     my @classnum = ref( $param->{'cust_classnum'} )
3411                      ? @{ $param->{'cust_classnum'} }
3412                      :  ( $param->{'cust_classnum'} );
3413
3414     @classnum = grep /^(\d*)$/, @classnum;
3415
3416     if ( @classnum ) {
3417       push @search, '( '. join(' OR ', map {
3418                                              $_ ? "cust_main.classnum = $_"
3419                                                 : "cust_main.classnum IS NULL"
3420                                            }
3421                                            @classnum
3422                               ).
3423                     ' )';
3424     }
3425
3426   }
3427
3428   #payby
3429   if ( $param->{payby} ) {
3430     my $payby = $param->{payby};
3431     $payby = [ $payby ] unless ref $payby;
3432     my $payby_in = join(',', map {dbh->quote($_)} @$payby);
3433     push @search, "cust_main.payby IN($payby_in)" if length($payby_in);
3434   }
3435
3436   #_date
3437   if ( $param->{_date} ) {
3438     my($beginning, $ending) = @{$param->{_date}};
3439
3440     push @search, "cust_bill._date >= $beginning",
3441                   "cust_bill._date <  $ending";
3442   }
3443
3444   #invnum
3445   if ( $param->{'invnum_min'} =~ /^(\d+)$/ ) {
3446     push @search, "cust_bill.invnum >= $1";
3447   }
3448   if ( $param->{'invnum_max'} =~ /^(\d+)$/ ) {
3449     push @search, "cust_bill.invnum <= $1";
3450   }
3451
3452   #charged
3453   if ( $param->{charged} ) {
3454     my @charged = ref($param->{charged})
3455                     ? @{ $param->{charged} }
3456                     : ($param->{charged});
3457
3458     push @search, map { s/^charged/cust_bill.charged/; $_; }
3459                       @charged;
3460   }
3461
3462   my $owed_sql = FS::cust_bill->owed_sql;
3463
3464   #owed
3465   if ( $param->{owed} ) {
3466     my @owed = ref($param->{owed})
3467                  ? @{ $param->{owed} }
3468                  : ($param->{owed});
3469     push @search, map { s/^owed/$owed_sql/; $_; }
3470                       @owed;
3471   }
3472
3473   #open/net flags
3474   push @search, "0 != $owed_sql"
3475     if $param->{'open'};
3476   push @search, '0 != '. FS::cust_bill->net_sql
3477     if $param->{'net'};
3478
3479   #days
3480   push @search, "cust_bill._date < ". (time-86400*$param->{'days'})
3481     if $param->{'days'};
3482
3483   #newest_percust
3484   if ( $param->{'newest_percust'} ) {
3485
3486     #$distinct = 'DISTINCT ON ( cust_bill.custnum )';
3487     #$orderby = 'ORDER BY cust_bill.custnum ASC, cust_bill._date DESC';
3488
3489     my @newest_where = map { my $x = $_;
3490                              $x =~ s/\bcust_bill\./newest_cust_bill./g;
3491                              $x;
3492                            }
3493                            grep ! /^cust_main./, @search;
3494     my $newest_where = scalar(@newest_where)
3495                          ? ' AND '. join(' AND ', @newest_where)
3496                          : '';
3497
3498
3499     push @search, "cust_bill._date = (
3500       SELECT(MAX(newest_cust_bill._date)) FROM cust_bill AS newest_cust_bill
3501         WHERE newest_cust_bill.custnum = cust_bill.custnum
3502           $newest_where
3503     )";
3504
3505   }
3506
3507   #promised_date - also has an option to accept nulls
3508   if ( $param->{promised_date} ) {
3509     my($beginning, $ending, $null) = @{$param->{promised_date}};
3510
3511     push @search, "(( cust_bill.promised_date >= $beginning AND ".
3512                     "cust_bill.promised_date <  $ending )" .
3513                     ($null ? ' OR cust_bill.promised_date IS NULL ) ' : ')');
3514   }
3515
3516   #agent virtualization
3517   my $curuser = $FS::CurrentUser::CurrentUser;
3518   if ( $curuser->username eq 'fs_queue'
3519        && $param->{'CurrentUser'} =~ /^(\w+)$/ ) {
3520     my $username = $1;
3521     my $newuser = qsearchs('access_user', {
3522       'username' => $username,
3523       'disabled' => '',
3524     } );
3525     if ( $newuser ) {
3526       $curuser = $newuser;
3527     } else {
3528       warn "$me WARNING: (fs_queue) can't find CurrentUser $username\n";
3529     }
3530   }
3531   push @search, $curuser->agentnums_sql;
3532
3533   join(' AND ', @search );
3534
3535 }
3536
3537 =back
3538
3539 =head1 BUGS
3540
3541 The delete method.
3542
3543 =head1 SEE ALSO
3544
3545 L<FS::Record>, L<FS::cust_main>, L<FS::cust_bill_pay>, L<FS::cust_pay>,
3546 L<FS::cust_bill_pkg>, L<FS::cust_bill_credit>, schema.html from the base
3547 documentation.
3548
3549 =cut
3550
3551 1;
3552