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