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