2 use base qw( FS::part_pkg::API
3 FS::m2m_Common FS::o2m_Common FS::option_Common
7 use vars qw( %plans $DEBUG $setup_hack $skip_pkg_svc_hack
8 $cache_enabled %cache_link %cache_pkg_svc
10 use Carp qw(carp cluck confess);
11 use Scalar::Util qw( blessed );
13 use Time::Local qw( timelocal timelocal_nocheck ); # eventually replace with DateTime
16 use FS::Record qw( qsearch qsearchs dbh dbdef );
17 use FS::Cursor; # for upgrade
23 use FS::part_pkg_option;
24 use FS::part_pkg_fcc_option;
27 use FS::part_pkg_msgcat;
28 use FS::part_pkg_taxrate;
29 use FS::part_pkg_taxoverride;
30 use FS::part_pkg_taxproduct;
31 use FS::part_pkg_link;
32 use FS::part_pkg_discount;
33 use FS::part_pkg_vendor;
34 use FS::part_pkg_currency;
35 use FS::part_svc_link;
40 $skip_pkg_svc_hack = 0;
48 FS::part_pkg - Object methods for part_pkg objects
54 $record = new FS::part_pkg \%hash
55 $record = new FS::part_pkg { 'column' => 'value' };
57 $custom_record = $template_record->clone;
59 $error = $record->insert;
61 $error = $new_record->replace($old_record);
63 $error = $record->delete;
65 $error = $record->check;
67 @pkg_svc = $record->pkg_svc;
69 $svcnum = $record->svcpart;
70 $svcnum = $record->svcpart( 'svc_acct' );
74 An FS::part_pkg object represents a package definition. FS::part_pkg
75 inherits from FS::Record. The following fields are currently supported:
79 =item pkgpart - primary key (assigned automatically for new package definitions)
81 =item pkg - Text name of this package definition (customer-viewable)
83 =item comment - Text name of this package definition (non-customer-viewable)
85 =item classnum - Optional package class (see L<FS::pkg_class>)
87 =item promo_code - Promotional code
89 =item setup - Setup fee expression (deprecated)
91 =item freq - Frequency of recurring fee
93 =item recur - Recurring fee expression (deprecated)
95 =item setuptax - Setup fee tax exempt flag, empty or `Y'
97 =item recurtax - Recurring fee tax exempt flag, empty or `Y'
99 =item taxclass - Tax class
101 =item plan - Price plan
103 =item plandata - Price plan data (deprecated - see L<FS::part_pkg_option> instead)
105 =item disabled - Disabled flag, empty or `Y'
107 =item custom - Custom flag, empty or `Y'
109 =item setup_cost - for cost tracking
111 =item recur_cost - for cost tracking
113 =item pay_weight - Weight (relative to credit_weight and other package definitions) that controls payment application to specific line items.
115 =item credit_weight - Weight (relative to other package definitions) that controls credit application to specific line items.
117 =item agentnum - Optional agentnum (see L<FS::agent>)
119 =item fcc_ds0s - Optional DS0 equivalency number for FCC form 477
121 =item fcc_voip_class - Which column of FCC form 477 part II.B this package
124 =item successor - Foreign key for the part_pkg that replaced this record.
125 If this record is not obsolete, will be null.
127 =item family_pkgpart - Foreign key for the part_pkg that was the earliest
128 ancestor of this record. If this record is not a successor to another
129 part_pkg, will be equal to pkgpart.
131 =item delay_start - Number of days to delay package start, by default
133 =item start_on_hold - 'Y' to suspend this package immediately when it is
134 ordered. The package will not start billing or have a setup fee charged
135 until it is manually unsuspended.
137 =item change_to_pkgpart - When this package is ordered, schedule a future
138 package change. The 'expire_months' field will determine when the package
141 =item expire_months - Number of months until this package expires (or changes
144 =item adjourn_months - Number of months until this package becomes suspended.
146 =item contract_end_months - Number of months until the package's contract
157 Creates a new package definition. To add the package definition to
158 the database, see L<"insert">.
162 sub table { 'part_pkg'; }
166 An alternate constructor. Creates a new package definition by duplicating
167 an existing definition. A new pkgpart is assigned and the custom flag is
168 set to Y. To add the package definition to the database, see L<"insert">.
174 my $class = ref($self);
175 my %hash = $self->hash;
176 $hash{'pkgpart'} = '';
177 $hash{'custom'} = 'Y';
178 #new FS::part_pkg ( \%hash ); # ?
179 new $class ( \%hash ); # ?
182 =item insert [ , OPTION => VALUE ... ]
184 Adds this package definition to the database. If there is an error,
185 returns the error, otherwise returns false.
187 Currently available options are: I<pkg_svc>, I<primary_svc>, I<cust_pkg>,
188 I<custnum_ref> and I<options>.
190 If I<pkg_svc> is set to a hashref with svcparts as keys and quantities as
191 values, appropriate FS::pkg_svc records will be inserted. I<hidden_svc> can
192 be set to a hashref of svcparts and flag values ('Y' or '') to set the
193 'hidden' field in these records, and I<provision_hold> can be set similarly
194 for the 'provision_hold' field in these records.
196 If I<primary_svc> is set to the svcpart of the primary service, the appropriate
197 FS::pkg_svc record will be updated.
199 If I<cust_pkg> is set to a pkgnum of a FS::cust_pkg record (or the FS::cust_pkg
200 record itself), the object will be updated to point to this package definition.
202 In conjunction with I<cust_pkg>, if I<custnum_ref> is set to a scalar reference,
203 the scalar will be updated with the custnum value from the cust_pkg record.
205 If I<tax_overrides> is set to a hashref with usage classes as keys and comma
206 separated tax class numbers as values, appropriate FS::part_pkg_taxoverride
207 records will be inserted.
209 If I<options> is set to a hashref of options, appropriate FS::part_pkg_option
210 records will be inserted.
212 If I<part_pkg_currency> is set to a hashref of options (with the keys as
213 option_CURRENCY), appropriate FS::part_pkg::currency records will be inserted.
220 warn "FS::part_pkg::insert called on $self with options ".
221 join(', ', map "$_=>$options{$_}", keys %options)
224 local $SIG{HUP} = 'IGNORE';
225 local $SIG{INT} = 'IGNORE';
226 local $SIG{QUIT} = 'IGNORE';
227 local $SIG{TERM} = 'IGNORE';
228 local $SIG{TSTP} = 'IGNORE';
229 local $SIG{PIPE} = 'IGNORE';
231 my $oldAutoCommit = $FS::UID::AutoCommit;
232 local $FS::UID::AutoCommit = 0;
235 if ( length($self->classnum) && $self->classnum !~ /^(\d+)$/ ) {
236 my $pkg_class = qsearchs('pkg_class', { 'classname' => $self->classnum } )
237 || new FS::pkg_class { classname => $self->classnum };
238 unless ( $pkg_class->classnum ) {
239 my $error = $pkg_class->insert;
241 $dbh->rollback if $oldAutoCommit;
245 $self->classnum( $pkg_class->classnum );
248 warn " inserting part_pkg record" if $DEBUG;
249 my $error = $self->SUPER::insert( $options{options} );
251 $dbh->rollback if $oldAutoCommit;
256 if ( $self->get('family_pkgpart') eq '' ) {
257 $self->set('family_pkgpart' => $self->pkgpart);
258 $error = $self->SUPER::replace;
260 $dbh->rollback if $oldAutoCommit;
265 warn " inserting part_pkg_taxoverride records" if $DEBUG;
266 my %overrides = %{ $options{'tax_overrides'} || {} };
267 foreach my $usage_class ( keys %overrides ) {
269 ( exists($overrides{$usage_class}) && defined($overrides{$usage_class}) )
270 ? $overrides{$usage_class}
272 my @overrides = (grep "$_", split(',', $override) );
273 my $error = $self->process_m2m (
274 'link_table' => 'part_pkg_taxoverride',
275 'target_table' => 'tax_class',
276 'hashref' => { 'usage_class' => $usage_class },
277 'params' => \@overrides,
280 $dbh->rollback if $oldAutoCommit;
285 warn " inserting part_pkg_currency records" if $DEBUG;
286 my %part_pkg_currency = %{ $options{'part_pkg_currency'} || {} };
287 foreach my $key ( keys %part_pkg_currency ) {
288 $key =~ /^(.+)_([A-Z]{3})$/ or next;
289 my( $optionname, $currency ) = ( $1, $2 );
290 if ( $part_pkg_currency{$key} =~ /^\s*$/ ) {
291 if ( $self->option($optionname) == 0 ) {
292 $part_pkg_currency{$key} = '0';
294 $dbh->rollback if $oldAutoCommit;
295 ( my $thing = $optionname ) =~ s/_/ /g;
296 return ucfirst($thing). " $currency is required";
299 my $part_pkg_currency = new FS::part_pkg_currency {
300 'pkgpart' => $self->pkgpart,
301 'optionname' => $optionname,
302 'currency' => $currency,
303 'optionvalue' => $part_pkg_currency{$key},
305 my $error = $part_pkg_currency->insert;
307 $dbh->rollback if $oldAutoCommit;
312 unless ( $skip_pkg_svc_hack ) {
314 warn " inserting pkg_svc records" if $DEBUG;
315 my $pkg_svc = $options{'pkg_svc'} || {};
316 my $hidden_svc = $options{'hidden_svc'} || {};
317 my $provision_hold = $options{'provision_hold'} || {};
318 foreach my $part_svc ( qsearch('part_svc', {} ) ) {
319 my $quantity = $pkg_svc->{$part_svc->svcpart} || 0;
321 ( $options{'primary_svc'} && $options{'primary_svc'}==$part_svc->svcpart )
325 my $pkg_svc = new FS::pkg_svc( {
326 'pkgpart' => $self->pkgpart,
327 'svcpart' => $part_svc->svcpart,
328 'quantity' => $quantity,
329 'primary_svc' => $primary_svc,
330 'hidden' => $hidden_svc->{$part_svc->svcpart},
331 'provision_hold' => $provision_hold->{$part_svc->svcpart},
333 my $error = $pkg_svc->insert;
335 $dbh->rollback if $oldAutoCommit;
340 my $error = $self->check_pkg_svc(%options);
342 $dbh->rollback if $oldAutoCommit;
348 if ( $options{'cust_pkg'} ) {
349 warn " updating cust_pkg record " if $DEBUG;
351 ref($options{'cust_pkg'})
352 ? $options{'cust_pkg'}
353 : qsearchs('cust_pkg', { pkgnum => $options{'cust_pkg'} } );
354 ${ $options{'custnum_ref'} } = $old_cust_pkg->custnum
355 if $options{'custnum_ref'};
356 my %hash = $old_cust_pkg->hash;
357 $hash{'pkgpart'} = $self->pkgpart,
358 my $new_cust_pkg = new FS::cust_pkg \%hash;
359 local($FS::cust_pkg::disable_agentcheck) = 1;
360 my $error = $new_cust_pkg->replace($old_cust_pkg);
362 $dbh->rollback if $oldAutoCommit;
363 return "Error modifying cust_pkg record: $error";
367 if ( $options{'part_pkg_vendor'} ) {
368 while ( my ($exportnum, $vendor_pkg_id) =
369 each %{ $options{part_pkg_vendor} }
372 my $ppv = new FS::part_pkg_vendor( {
373 'pkgpart' => $self->pkgpart,
374 'exportnum' => $exportnum,
375 'vendor_pkg_id' => $vendor_pkg_id,
377 my $error = $ppv->insert;
379 $dbh->rollback if $oldAutoCommit;
380 return "Error inserting part_pkg_vendor record: $error";
385 if ( $options{fcc_options} ) {
386 warn " updating fcc options " if $DEBUG;
387 $self->set_fcc_options( $options{fcc_options} );
390 warn " committing transaction" if $DEBUG and $oldAutoCommit;
391 $dbh->commit or die $dbh->errstr if $oldAutoCommit;
398 Currently unimplemented.
403 return "Can't (yet?) delete package definitions.";
404 # check & make sure the pkgpart isn't in cust_pkg or type_pkgs?
407 =item replace OLD_RECORD [ , OPTION => VALUE ... ]
409 Replaces OLD_RECORD with this one in the database. If there is an error,
410 returns the error, otherwise returns false.
412 Currently available options are: I<pkg_svc>, I<hidden_svc>, I<primary_svc>,
413 I<bulk_skip>, I<provision_hold> and I<options>
415 If I<pkg_svc> is set to a hashref with svcparts as keys and quantities as
416 values, the appropriate FS::pkg_svc records will be replaced. I<hidden_svc>
417 can be set to a hashref of svcparts and flag values ('Y' or '') to set the
418 'hidden' field in these records. I<bulk_skip> and I<provision_hold> can be
419 set to a hashref of svcparts and flag values ('Y' or '') to set the
420 respective field in those records.
422 If I<primary_svc> is set to the svcpart of the primary service, the
423 appropriate FS::pkg_svc record will be updated.
425 If I<options> is set to a hashref, the appropriate FS::part_pkg_option
426 records will be replaced.
428 If I<part_pkg_currency> is set to a hashref of options (with the keys as
429 option_CURRENCY), appropriate FS::part_pkg::currency records will be
437 my $old = ( blessed($_[0]) && $_[0]->isa('FS::Record') )
442 ( ref($_[0]) eq 'HASH' )
446 $options->{options} = { $old->options } unless defined($options->{options});
448 warn "FS::part_pkg::replace called on $new to replace $old with options".
449 join(', ', map "$_ => ". $options->{$_}, keys %$options)
452 local $SIG{HUP} = 'IGNORE';
453 local $SIG{INT} = 'IGNORE';
454 local $SIG{QUIT} = 'IGNORE';
455 local $SIG{TERM} = 'IGNORE';
456 local $SIG{TSTP} = 'IGNORE';
457 local $SIG{PIPE} = 'IGNORE';
459 my $oldAutoCommit = $FS::UID::AutoCommit;
460 local $FS::UID::AutoCommit = 0;
463 my $conf = new FS::Conf;
464 if ( $conf->exists('part_pkg-lineage') ) {
465 if ( grep { $options->{options}->{$_} ne $old->option($_, 1) }
466 qw(setup_fee recur_fee) #others? config?
469 warn " superseding package" if $DEBUG;
471 my $error = $new->supersede($old, %$options);
473 $dbh->rollback if $oldAutoCommit;
477 warn " committing transaction" if $DEBUG and $oldAutoCommit;
478 $dbh->commit if $oldAutoCommit;
485 #plandata shit stays in replace for upgrades until after 2.0 (or edit
487 warn " saving legacy plandata" if $DEBUG;
488 my $plandata = $new->get('plandata');
489 $new->set('plandata', '');
491 warn " deleting old part_pkg_option records" if $DEBUG;
492 foreach my $part_pkg_option ( $old->part_pkg_option ) {
493 my $error = $part_pkg_option->delete;
495 $dbh->rollback if $oldAutoCommit;
500 warn " replacing part_pkg record" if $DEBUG;
501 my $error = $new->SUPER::replace($old, $options->{options} );
503 $dbh->rollback if $oldAutoCommit;
507 warn " inserting part_pkg_option records for plandata: $plandata|" if $DEBUG;
508 foreach my $part_pkg_option (
509 map { /^(\w+)=(.*)$/ or do { $dbh->rollback if $oldAutoCommit;
510 return "illegal plandata: $plandata";
512 new FS::part_pkg_option {
513 'pkgpart' => $new->pkgpart,
518 split("\n", $plandata)
520 my $error = $part_pkg_option->insert;
522 $dbh->rollback if $oldAutoCommit;
527 #trivial nit: not the most efficient to delete and reinsert
528 warn " deleting old part_pkg_currency records" if $DEBUG;
529 foreach my $part_pkg_currency ( $old->part_pkg_currency ) {
530 my $error = $part_pkg_currency->delete;
532 $dbh->rollback if $oldAutoCommit;
533 return "error deleting part_pkg_currency record: $error";
537 warn " inserting new part_pkg_currency records" if $DEBUG;
538 my %part_pkg_currency = %{ $options->{'part_pkg_currency'} || {} };
539 foreach my $key ( keys %part_pkg_currency ) {
540 $key =~ /^(.+)_([A-Z]{3})$/ or next;
541 my $part_pkg_currency = new FS::part_pkg_currency {
542 'pkgpart' => $new->pkgpart,
545 'optionvalue' => $part_pkg_currency{$key},
547 my $error = $part_pkg_currency->insert;
549 $dbh->rollback if $oldAutoCommit;
550 return "error inserting part_pkg_currency record: $error";
555 warn " replacing pkg_svc records" if $DEBUG;
556 my $pkg_svc = $options->{'pkg_svc'};
557 my $hidden_svc = $options->{'hidden_svc'} || {};
558 my $bulk_skip = $options->{'bulk_skip'} || {};
559 my $provision_hold = $options->{'provision_hold'} || {};
560 if ( $pkg_svc ) { # if it wasn't passed, don't change existing pkg_svcs
562 foreach my $part_svc ( qsearch('part_svc', {} ) ) {
563 my $quantity = $pkg_svc->{$part_svc->svcpart} || 0;
564 my $hidden = $hidden_svc->{$part_svc->svcpart} || '';
565 my $bulk_skip = $bulk_skip->{$part_svc->svcpart} || '';
566 my $provision_hold = $provision_hold->{$part_svc->svcpart} || '';
568 ( defined($options->{'primary_svc'}) && $options->{'primary_svc'}
569 && $options->{'primary_svc'} == $part_svc->svcpart
574 my $old_pkg_svc = qsearchs('pkg_svc', {
575 'pkgpart' => $old->pkgpart,
576 'svcpart' => $part_svc->svcpart,
579 my $old_quantity = 0;
580 my $old_primary_svc = '';
582 my $old_bulk_skip = '';
583 my $old_provision_hold = '';
584 if ( $old_pkg_svc ) {
585 $old_quantity = $old_pkg_svc->quantity;
586 $old_primary_svc = $old_pkg_svc->primary_svc
587 if $old_pkg_svc->dbdef_table->column('primary_svc'); # is this needed?
588 $old_hidden = $old_pkg_svc->hidden;
589 $old_bulk_skip = $old_pkg_svc->old_bulk_skip; # should this just be bulk_skip?
590 $old_provision_hold = $old_pkg_svc->provision_hold;
593 next unless $old_quantity != $quantity
594 || $old_primary_svc ne $primary_svc
595 || $old_hidden ne $hidden
596 || $old_bulk_skip ne $bulk_skip
597 || $old_provision_hold ne $provision_hold;
599 my $new_pkg_svc = new FS::pkg_svc( {
600 'pkgsvcnum' => ( $old_pkg_svc ? $old_pkg_svc->pkgsvcnum : '' ),
601 'pkgpart' => $new->pkgpart,
602 'svcpart' => $part_svc->svcpart,
603 'quantity' => $quantity,
604 'primary_svc' => $primary_svc,
606 'bulk_skip' => $bulk_skip,
607 'provision_hold' => $provision_hold,
609 my $error = $old_pkg_svc
610 ? $new_pkg_svc->replace($old_pkg_svc)
611 : $new_pkg_svc->insert;
613 $dbh->rollback if $oldAutoCommit;
618 my $error = $new->check_pkg_svc(%$options);
620 $dbh->rollback if $oldAutoCommit;
624 } #if $options->{pkg_svc}
626 my @part_pkg_vendor = $old->part_pkg_vendor;
627 my @current_exportnum = ();
628 if ( $options->{'part_pkg_vendor'} ) {
629 my($exportnum,$vendor_pkg_id);
630 while ( ($exportnum,$vendor_pkg_id)
631 = each %{$options->{'part_pkg_vendor'}} ) {
633 foreach my $part_pkg_vendor ( @part_pkg_vendor ) {
634 if($exportnum == $part_pkg_vendor->exportnum
635 && $vendor_pkg_id ne $part_pkg_vendor->vendor_pkg_id) {
636 $part_pkg_vendor->vendor_pkg_id($vendor_pkg_id);
637 my $error = $part_pkg_vendor->replace;
639 $dbh->rollback if $oldAutoCommit;
640 return "Error replacing part_pkg_vendor record: $error";
645 elsif($exportnum == $part_pkg_vendor->exportnum
646 && $vendor_pkg_id eq $part_pkg_vendor->vendor_pkg_id) {
651 unless ( $noinsert ) {
652 my $ppv = new FS::part_pkg_vendor( {
653 'pkgpart' => $new->pkgpart,
654 'exportnum' => $exportnum,
655 'vendor_pkg_id' => $vendor_pkg_id,
657 my $error = $ppv->insert;
659 $dbh->rollback if $oldAutoCommit;
660 return "Error inserting part_pkg_vendor record: $error";
663 push @current_exportnum, $exportnum;
666 foreach my $part_pkg_vendor ( @part_pkg_vendor ) {
667 unless ( grep($_ eq $part_pkg_vendor->exportnum, @current_exportnum) ) {
668 my $error = $part_pkg_vendor->delete;
670 $dbh->rollback if $oldAutoCommit;
671 return "Error deleting part_pkg_vendor record: $error";
676 # propagate changes to certain core fields
677 if ( $conf->exists('part_pkg-lineage') ) {
678 warn " propagating changes to family" if $DEBUG;
679 my $error = $new->propagate($old);
681 $dbh->rollback if $oldAutoCommit;
686 if ( $options->{fcc_options} ) {
687 warn " updating fcc options " if $DEBUG;
688 $new->set_fcc_options( $options->{fcc_options} );
691 warn " committing transaction" if $DEBUG and $oldAutoCommit;
692 $dbh->commit or die $dbh->errstr if $oldAutoCommit;
696 sub validate_number {
697 my ($option, $valref) = @_;
698 $$valref = 0 unless $$valref;
699 return "Invalid $option"
700 unless ($$valref) = ($$valref =~ /^\s*(\d+)\s*$/);
706 Checks all fields to make sure this is a valid package definition. If
707 there is an error, returns the error, otherwise returns false. Called by the
708 insert and replace methods.
714 warn "FS::part_pkg::check called on $self" if $DEBUG;
716 for (qw(setup recur plandata)) {
717 #$self->set($_=>0) if $self->get($_) =~ /^\s*$/; }
718 return "Use of $_ field is deprecated; set a plan and options: ".
720 if length($self->get($_));
724 if ( $self->dbdef_table->column('freq')->type =~ /(int)/i ) {
725 my $error = $self->ut_number('freq');
726 return $error if $error;
728 $self->freq =~ /^(\d+[hdw]?)$/
729 or return "Illegal or empty freq: ". $self->freq;
733 my @null_agentnum_right = ( 'Edit global package definitions' );
734 push @null_agentnum_right, 'One-time charge'
735 if $self->freq =~ /^0/;
736 push @null_agentnum_right, 'Customize customer package'
737 if $self->disabled eq 'Y'; #good enough
739 my $error = $self->ut_numbern('pkgpart')
740 || $self->ut_text('pkg')
741 || $self->ut_textn('comment')
742 || $self->ut_textn('promo_code')
743 || $self->ut_alphan('plan')
744 || $self->ut_flag('setuptax')
745 || $self->ut_flag('recurtax')
746 || $self->ut_textn('taxclass')
747 || $self->ut_flag('disabled')
748 || $self->ut_flag('custom')
749 || $self->ut_flag('no_auto')
750 || $self->ut_flag('recur_show_zero')
751 || $self->ut_flag('setup_show_zero')
752 || $self->ut_flag('start_on_hold')
753 #|| $self->ut_moneyn('setup_cost')
754 #|| $self->ut_moneyn('recur_cost')
755 || $self->ut_floatn('setup_cost')
756 || $self->ut_floatn('recur_cost')
757 || $self->ut_floatn('pay_weight')
758 || $self->ut_floatn('credit_weight')
759 || $self->ut_numbern('taxproductnum')
760 || $self->ut_numbern('units_taxproductnum')
761 || $self->ut_foreign_keyn('classnum', 'pkg_class', 'classnum')
762 || $self->ut_foreign_keyn('addon_classnum', 'pkg_class', 'classnum')
763 || $self->ut_foreign_keyn('taxproductnum',
764 'part_pkg_taxproduct',
768 ? $self->ut_foreign_keyn('agentnum', 'agent', 'agentnum' )
769 : $self->ut_agentnum_acl('agentnum', \@null_agentnum_right)
771 || $self->ut_numbern('fcc_ds0s')
772 || $self->ut_numbern('fcc_voip_class')
773 || $self->ut_numbern('delay_start')
774 || $self->ut_foreign_keyn('successor', 'part_pkg', 'pkgpart')
775 || $self->ut_foreign_keyn('family_pkgpart', 'part_pkg', 'pkgpart')
776 || $self->ut_numbern('expire_months')
777 || $self->ut_numbern('adjourn_months')
778 || $self->ut_numbern('contract_end_months')
779 || $self->ut_numbern('change_to_pkgpart')
780 || $self->ut_foreign_keyn('change_to_pkgpart', 'part_pkg', 'pkgpart')
781 || $self->ut_alphan('agent_pkgpartid')
782 || $self->SUPER::check
784 return $error if $error;
786 return 'Unknown plan '. $self->plan
787 unless exists($plans{$self->plan});
789 my $conf = new FS::Conf;
790 return 'Taxclass is required'
791 if ! $self->taxclass && $conf->exists('require_taxclasses');
798 Pass an I<$options> hashref that contains the values to be
799 inserted or updated for any FS::part_pkg::MODULE.pm.
801 For each key in I<$options>, validates the value by calling
802 the 'validate' subroutine defined for that option e.g.
803 FS::part_pkg::MODULE::plan_info()->{$KEY}->{validate}. The
804 option validation function is only called when the hashkey for
805 that option exists in I<$options>.
807 Then the module validation function is called, from
808 FS::part_pkg::MODULE::plan_info()->{validate}
810 Returns error message, or empty string if valid.
812 Invoked by L</insert> and L</replace> via the equivalent
813 methods in L<FS::option_Common>.
818 my ($self,$options) = @_;
819 foreach my $option (keys %$options) {
820 if (exists $plans{ $self->plan }->{fields}->{$option}) {
821 if (exists($plans{$self->plan}->{fields}->{$option}->{'validate'})) {
822 # pass option name for use in error message
823 # pass a reference to the $options value, so it can be cleaned up
824 my $error = &{$plans{$self->plan}->{fields}->{$option}->{'validate'}}($option,\($options->{$option}));
825 return $error if $error;
827 } # else "option does not exist" error?
829 if (exists($plans{$self->plan}->{'validate'})) {
830 my $error = &{$plans{$self->plan}->{'validate'}}($options);
831 return $error if $error;
838 Checks pkg_svc records as a whole (for part_svc_link dependencies).
840 If there is an error, returns the error, otherwise returns false.
845 my( $self, %opt ) = @_;
847 my $agentnum = $self->agentnum;
849 my %pkg_svc = map { $_->svcpart => $_ } $self->pkg_svc;
851 foreach my $svcpart ( keys %pkg_svc ) {
853 foreach my $part_svc_link ( $self->part_svc_link(
854 'src_svcpart' => $svcpart,
855 'link_type' => 'part_pkg_restrict',
859 return $part_svc_link->dst_svc. ' must be included with '.
860 $part_svc_link->src_svc
861 unless $pkg_svc{ $part_svc_link->dst_svcpart };
866 return '' if $opt{part_pkg_restrict_soft_override};
868 foreach my $svcpart ( keys %pkg_svc ) {
870 foreach my $part_svc_link ( $self->part_svc_link(
871 'src_svcpart' => $svcpart,
872 'link_type' => 'part_pkg_restrict_soft',
875 return $part_svc_link->dst_svc. ' is suggested with '.
876 $part_svc_link->src_svc
877 unless $pkg_svc{ $part_svc_link->dst_svcpart };
885 =item part_svc_link OPTION => VALUE ...
887 Returns the service dependencies (see L<FS::part_svc_link>) for the given
888 search options, taking into account this package definition's agent.
890 Available options are any field in part_svc_link. Typically used options are
891 src_svcpart and link_type.
896 FS::part_svc_link->by_agentnum( shift->agentnum, @_ );
899 =item supersede OLD [, OPTION => VALUE ... ]
901 Inserts this package as a successor to the package OLD. All options are as
902 for C<insert>. After inserting, disables OLD and sets the new package as its
908 my ($new, $old, %options) = @_;
911 $new->set('pkgpart' => '');
912 $new->set('family_pkgpart' => $old->family_pkgpart);
913 warn " inserting successor package\n" if $DEBUG;
914 $error = $new->insert(%options);
915 return $error if $error;
917 warn " disabling superseded package\n" if $DEBUG;
918 $old->set('successor' => $new->pkgpart);
919 $old->set('disabled' => 'Y');
920 $error = $old->SUPER::replace; # don't change its options/pkg_svc records
921 return $error if $error;
923 warn " propagating changes to family" if $DEBUG;
924 $new->propagate($old);
929 If any of certain fields have changed from OLD to this package, then,
930 for all packages in the same lineage as this one, sets those fields
931 to their values in this package.
935 my @propagate_fields = (
936 qw( pkg classnum setup_cost recur_cost taxclass
937 setuptax recurtax pay_weight credit_weight
945 map { $_ => $new->get($_) }
946 grep { $new->get($_) ne $old->get($_) }
950 my @part_pkg = qsearch('part_pkg', {
951 'family_pkgpart' => $new->family_pkgpart
954 foreach my $part_pkg ( @part_pkg ) {
955 my $pkgpart = $part_pkg->pkgpart;
956 next if $pkgpart == $new->pkgpart; # don't modify $new
957 warn " propagating to pkgpart $pkgpart\n" if $DEBUG;
958 foreach ( keys %fields ) {
959 $part_pkg->set($_, $fields{$_});
961 # SUPER::replace to avoid changing non-core fields
962 my $error = $part_pkg->SUPER::replace;
963 push @error, "pkgpart $pkgpart: $error"
969 =item set_fcc_options HASHREF
971 Sets the FCC options on this package definition to the values specified
976 sub set_fcc_options {
978 my $pkgpart = $self->pkgpart;
986 my %existing_num = map { $_->fccoptionname => $_->num }
987 qsearch('part_pkg_fcc_option', { pkgpart => $pkgpart });
989 local $FS::Record::nowarn_identical = 1;
990 # set up params for process_o2m
993 foreach my $name (keys %$options ) {
994 $params->{ "num$i" } = $existing_num{$name} || '';
995 $params->{ "num$i".'_fccoptionname' } = $name;
996 $params->{ "num$i".'_optionvalue' } = $options->{$name};
1001 table => 'part_pkg_fcc_option',
1002 fields => [qw( fccoptionname optionvalue )],
1007 =item pkg_locale LOCALE
1009 Returns a customer-viewable string representing this package for the given
1010 locale, from the part_pkg_msgcat table. If the given locale is empty or no
1011 localized string is found, returns the base pkg field.
1016 my( $self, $locale ) = @_;
1017 return $self->pkg unless $locale;
1018 my $part_pkg_msgcat = $self->part_pkg_msgcat($locale) or return $self->pkg;
1019 $part_pkg_msgcat->pkg;
1022 =item part_pkg_msgcat LOCALE
1024 Like pkg_locale, but returns the FS::part_pkg_msgcat object itself.
1028 sub part_pkg_msgcat {
1029 my( $self, $locale ) = @_;
1030 qsearchs( 'part_pkg_msgcat', {
1031 pkgpart => $self->pkgpart,
1036 =item pkg_comment [ OPTION => VALUE... ]
1038 Returns an (internal) string representing this package. Currently,
1039 "pkgpart: pkg - comment", is returned. "pkg - comment" may be returned in the
1040 future, omitting pkgpart. The comment will have '(CUSTOM) ' prepended if
1043 If the option nopkgpart is true then the "pkgpart: ' is omitted.
1051 #$self->pkg. ' - '. $self->comment;
1052 #$self->pkg. ' ('. $self->comment. ')';
1053 my $pre = $opt{nopkgpart} ? '' : $self->pkgpart. ': ';
1054 my $custom_comment = $self->custom_comment(%opt);
1055 $pre. $self->pkg. ( $custom_comment ? " - $custom_comment" : '' );
1058 #without price info (so without hitting the DB again)
1059 sub pkg_comment_only {
1063 my $pre = $opt{nopkgpart} ? '' : $self->pkgpart. ': ';
1064 my $comment = $self->comment;
1065 $pre. $self->pkg. ( $comment ? " - $comment" : '' );
1068 sub price_info { # safety, in case a part_pkg hasn't defined price_info
1072 sub custom_comment {
1074 my $price_info = $self->price_info(@_);
1075 ( $self->custom ? '(CUSTOM) ' : '' ).
1077 ( ($self->custom || $self->comment) ? ' - ' : '' ).
1078 ($price_info || 'No charge');
1081 sub pkg_price_info {
1083 $self->pkg. ' - '. ($self->price_info || 'No charge');
1088 Returns the package class, as an FS::pkg_class object, or the empty string
1089 if there is no package class.
1091 =item addon_pkg_class
1093 Returns the add-on package class, as an FS::pkg_class object, or the empty
1094 string if there is no add-on package class.
1098 sub addon_pkg_class {
1100 if ( $self->addon_classnum ) {
1101 qsearchs('pkg_class', { 'classnum' => $self->addon_classnum } );
1109 Returns the package category name, or the empty string if there is no package
1116 my $pkg_class = $self->pkg_class;
1118 ? $pkg_class->categoryname
1124 Returns the package class name, or the empty string if there is no package
1131 my $pkg_class = $self->pkg_class;
1133 ? $pkg_class->classname
1137 =item addon_classname
1139 Returns the add-on package class name, or the empty string if there is no
1140 add-on package class.
1144 sub addon_classname {
1146 my $pkg_class = $self->addon_pkg_class;
1148 ? $pkg_class->classname
1154 Returns the associated agent for this event, if any, as an FS::agent object.
1156 =item pkg_svc [ HASHREF | OPTION => VALUE ]
1158 Returns all FS::pkg_svc objects (see L<FS::pkg_svc>) for this package
1159 definition (with non-zero quantity).
1161 One option is available, I<disable_linked>. If set true it will return the
1162 services for this package definition alone, omitting services from any add-on
1169 Returns all FS::type_pkgs objects (see L<FS::type_pkgs>) for this package
1177 return @{ $cache_pkg_svc{$self->pkgpart} }
1178 if $cache_enabled && $cache_pkg_svc{$self->pkgpart};
1180 # #sort { $b->primary cmp $a->primary }
1181 # grep { $_->quantity }
1182 # qsearch( 'pkg_svc', { 'pkgpart' => $self->pkgpart } );
1184 my $opt = ref($_[0]) ? $_[0] : { @_ };
1185 my %pkg_svc = map { $_->svcpart => $_ } $self->_pkg_svc;
1187 unless ( $opt->{disable_linked} ) {
1188 foreach my $dst_pkg ( map $_->dst_pkg, $self->svc_part_pkg_link ) {
1189 my @pkg_svc = $dst_pkg->_pkg_svc;
1190 foreach my $pkg_svc ( @pkg_svc ) {
1191 if ( $pkg_svc{$pkg_svc->svcpart} ) {
1192 my $quantity = $pkg_svc{$pkg_svc->svcpart}->quantity;
1193 $pkg_svc{$pkg_svc->svcpart}->quantity($quantity + $pkg_svc->quantity);
1195 $pkg_svc{$pkg_svc->svcpart} = $pkg_svc;
1201 my @pkg_svc = values(%pkg_svc);
1203 $cache_pkg_svc{$self->pkgpart} = \@pkg_svc if $cache_enabled;
1211 grep { $_->quantity }
1213 'select' => 'pkg_svc.*, part_svc.*',
1214 'table' => 'pkg_svc',
1215 'addl_from' => 'LEFT JOIN part_svc USING ( svcpart )',
1216 'hashref' => { 'pkgpart' => $self->pkgpart },
1220 =item svcpart [ SVCDB ]
1222 Returns the svcpart of the primary service definition (see L<FS::part_svc>)
1223 associated with this package definition (see L<FS::pkg_svc>). Returns
1224 false if there not a primary service definition or exactly one service
1225 definition with quantity 1, or if SVCDB is specified and does not match the
1226 svcdb of the service definition. SVCDB can be specified as a scalar table
1227 name, such as 'svc_acct', or as an arrayref of possible table names.
1232 my $pkg_svc = shift->_primary_pkg_svc(@_);
1233 $pkg_svc ? $pkg_svc->svcpart : '';
1236 =item part_svc [ SVCDB ]
1238 Like the B<svcpart> method, but returns the FS::part_svc object (see
1244 my $pkg_svc = shift->_primary_pkg_svc(@_);
1245 $pkg_svc ? $pkg_svc->part_svc : '';
1248 sub _primary_pkg_svc {
1251 my $svcdb = scalar(@_) ? shift : [];
1252 $svcdb = ref($svcdb) ? $svcdb : [ $svcdb ];
1253 my %svcdb = map { $_=>1 } @$svcdb;
1256 grep { !scalar(@$svcdb) || $svcdb{ $_->part_svc->svcdb } }
1259 my @pkg_svc = grep { $_->primary_svc =~ /^Y/i } @svcdb_pkg_svc;
1260 @pkg_svc = grep {$_->quantity == 1 } @svcdb_pkg_svc
1262 return '' if scalar(@pkg_svc) != 1;
1266 =item svcpart_unique_svcdb SVCDB
1268 Returns the svcpart of a service definition (see L<FS::part_svc>) matching
1269 SVCDB associated with this package definition (see L<FS::pkg_svc>). Returns
1270 false if there not a primary service definition for SVCDB or there are multiple
1271 service definitions for SVCDB.
1275 sub svcpart_unique_svcdb {
1276 my( $self, $svcdb ) = @_;
1277 my @svcdb_pkg_svc = grep { ( $svcdb eq $_->part_svc->svcdb ) } $self->pkg_svc;
1278 return '' if scalar(@svcdb_pkg_svc) != 1;
1279 $svcdb_pkg_svc[0]->svcpart;
1284 Returns a list of the acceptable payment types for this package. Eventually
1285 this should come out of a database table and be editable, but currently has the
1286 following logic instead:
1288 If the package is free, the single item B<BILL> is
1289 returned, otherwise, the single item B<CARD> is returned.
1291 (CHEK? LEC? Probably shouldn't accept those by default, prone to abuse)
1297 if ( $self->is_free ) {
1306 Returns true if this package is free.
1312 if ( $self->can('is_free_options') ) {
1313 not grep { $_ !~ /^\s*0*(\.0*)?\s*$/ }
1314 map { $self->option($_) }
1315 $self->is_free_options;
1317 warn "FS::part_pkg::is_free: FS::part_pkg::". $self->plan. " subclass ".
1318 "provides neither is_free_options nor is_free method; returning false";
1323 # whether the plan allows discounts to be applied to this package
1324 sub can_discount { 0; }
1326 # whether the plan allows changing the start date
1327 sub can_start_date {
1329 $self->start_on_hold ? 0 : 1;
1332 # whether the plan supports part_pkg_usageprice add-ons (a specific kind of
1333 # pre-selectable usage pricing, there's others this doesn't refer to)
1334 sub can_usageprice { 0; }
1336 # the delay start date if present
1337 sub delay_start_date {
1340 my $delay = $self->delay_start or return '';
1342 # avoid timelocal silliness
1343 my $dt = DateTime->today(time_zone => 'local');
1344 $dt->add(days => $delay);
1348 sub can_currency_exchange { 0; }
1351 # moved to FS::Misc to make this accessible to other packages
1353 FS::Misc::pkg_freqs();
1358 Returns an english representation of the I<freq> field, such as "monthly",
1359 "weekly", "semi-annually", etc.
1365 my $freq = $self->freq;
1367 #my $freqs_href = $self->freqs_href;
1368 my $freqs_href = freqs_href();
1370 if ( exists($freqs_href->{$freq}) ) {
1371 $freqs_href->{$freq};
1373 my $interval = 'month';
1374 if ( $freq =~ /^(\d+)([hdw])$/ ) {
1375 my %interval = ( 'h' => 'hour', 'd'=>'day', 'w'=>'week' );
1376 $interval = $interval{$2};
1381 "every $freq ${interval}s";
1386 =item add_freq TIMESTAMP [ FREQ ]
1388 Adds a billing period of some frequency to the provided timestamp and
1389 returns the resulting timestamp, or -1 if the frequency could not be
1390 parsed (shouldn't happen). By default, the frequency of this package
1391 will be used; to override this, pass a different frequency as a second
1397 my( $self, $date, $freq ) = @_;
1398 $freq = $self->freq unless $freq;
1400 #change this bit to use Date::Manip? CAREFUL with timezones (see
1401 # mailing list archive)
1402 my ($sec,$min,$hour,$mday,$mon,$year) = (localtime($date) )[0,1,2,3,4,5];
1404 if ( $freq =~ /^\d+$/ ) {
1406 until ( $mon < 12 ) { $mon -= 12; $year++; }
1408 $mday = 28 if $mday > 28 && FS::Conf->new->exists('anniversary-rollback');
1410 } elsif ( $freq =~ /^(\d+)w$/ ) {
1412 $mday += $weeks * 7;
1413 } elsif ( $freq =~ /^(\d+)d$/ ) {
1416 } elsif ( $freq =~ /^(\d+)h$/ ) {
1423 timelocal_nocheck($sec,$min,$hour,$mday,$mon,$year);
1428 For backwards compatibility, returns the plandata field as well as all options
1429 from FS::part_pkg_option.
1435 carp "plandata is deprecated";
1437 $self->SUPER::plandata(@_);
1439 my $plandata = $self->get('plandata');
1440 my %options = $self->options;
1441 $plandata .= join('', map { "$_=$options{$_}\n" } keys %options );
1446 =item part_pkg_vendor
1448 Returns all vendor/external package ids as FS::part_pkg_vendor objects (see
1449 L<FS::part_pkg_vendor>).
1451 =item vendor_pkg_ids
1453 Returns a list of vendor/external package ids by exportnum
1457 sub vendor_pkg_ids {
1459 map { $_->exportnum => $_->vendor_pkg_id } $self->part_pkg_vendor;
1462 =item part_pkg_option
1464 Returns all options as FS::part_pkg_option objects (see
1465 L<FS::part_pkg_option>).
1469 Returns a list of option names and values suitable for assigning to a hash.
1475 map { $_->optionname => $_->optionvalue } $self->part_pkg_option;
1478 =item option OPTIONNAME [ QUIET ]
1480 Returns the option value for the given name, or the empty string. If a true
1481 value is passed as the second argument, warnings about missing the option
1487 my( $self, $opt, $ornull ) = @_;
1489 #cache: was pulled up in the original part_pkg query
1490 return $self->hashref->{"_opt_$opt"}
1491 if exists $self->hashref->{"_opt_$opt"};
1493 cluck "$self -> option: searching for $opt" if $DEBUG;
1494 my $part_pkg_option =
1495 qsearchs('part_pkg_option', {
1496 pkgpart => $self->pkgpart,
1499 return $part_pkg_option->optionvalue if $part_pkg_option;
1501 my %plandata = map { /^(\w+)=(.*)$/; ( $1 => $2 ); }
1502 split("\n", $self->get('plandata') );
1503 return $plandata{$opt} if exists $plandata{$opt};
1505 # check whether the option is defined in plan info (if so, don't warn)
1506 if (exists $plans{ $self->plan }->{fields}->{$opt}) {
1509 cluck "WARNING: (pkgpart ". $self->pkgpart. ") Package def option $opt ".
1510 "not found in options or plandata!\n"
1516 =item part_pkg_currency [ CURRENCY ]
1518 Returns all currency options as FS::part_pkg_currency objects (see
1519 L<FS::part_pkg_currency>), or, if a currency is specified, only return the
1520 objects for that currency.
1524 sub part_pkg_currency {
1526 my %hash = ( 'pkgpart' => $self->pkgpart );
1527 $hash{'currency'} = shift if @_;
1528 qsearch('part_pkg_currency', \%hash );
1531 =item part_pkg_currency_options CURRENCY
1533 Returns a list of option names and values from FS::part_pkg_currency for the
1538 sub part_pkg_currency_options {
1540 map { $_->optionname => $_->optionvalue } $self->part_pkg_currency(shift);
1543 =item part_pkg_currency_option CURRENCY OPTIONNAME
1545 Returns the option value for the given name and currency.
1549 sub part_pkg_currency_option {
1550 my( $self, $currency, $optionname ) = @_;
1551 my $part_pkg_currency =
1552 qsearchs('part_pkg_currency', { 'pkgpart' => $self->pkgpart,
1553 'currency' => $currency,
1554 'optionname' => $optionname,
1557 #fatal if not found? that works for our use cases from
1558 #part_pkg/currency_fixed, but isn't how we would typically/expect the method
1559 #to behave. have to catch it there if we change it here...
1560 or die "Unknown price for ". $self->pkg_comment. " in $currency\n";
1562 $part_pkg_currency->optionvalue;
1565 =item fcc_option OPTIONNAME
1567 Returns the FCC 477 report option value for the given name, or the empty
1573 my ($self, $name) = @_;
1574 my $part_pkg_fcc_option =
1575 qsearchs('part_pkg_fcc_option', {
1576 pkgpart => $self->pkgpart,
1577 fccoptionname => $name,
1579 $part_pkg_fcc_option ? $part_pkg_fcc_option->optionvalue : '';
1584 Returns all FCC 477 report options for this package, as a hash-like list.
1590 map { $_->fccoptionname => $_->optionvalue }
1591 qsearch('part_pkg_fcc_option', { pkgpart => $self->pkgpart });
1594 =item bill_part_pkg_link
1596 Returns the associated part_pkg_link records (see L<FS::part_pkg_link>).
1600 sub bill_part_pkg_link {
1601 shift->_part_pkg_link('bill', @_);
1604 =item svc_part_pkg_link
1606 Returns the associated part_pkg_link records (see L<FS::part_pkg_link>).
1610 sub svc_part_pkg_link {
1611 shift->_part_pkg_link('svc', @_);
1614 =item supp_part_pkg_link
1616 Returns the associated part_pkg_link records of type 'supp' (supplemental
1621 sub supp_part_pkg_link {
1622 shift->_part_pkg_link('supp', @_);
1625 sub _part_pkg_link {
1626 my( $self, $type ) = @_;
1628 return @{ $cache_link{$type}->{$self->pkgpart} }
1629 if $cache_enabled && $cache_link{$type}->{$self->pkgpart};
1631 cluck $type.'_part_pkg_link called' if $DEBUG;
1634 qsearch({ table => 'part_pkg_link',
1635 hashref => { src_pkgpart => $self->pkgpart,
1637 #protection against infinite recursive links
1638 dst_pkgpart => { op=>'!=', value=> $self->pkgpart },
1640 order_by => "ORDER BY hidden",
1643 $cache_link{$type}->{$self->pkgpart} = \@ppl if $cache_enabled;
1648 sub self_and_bill_linked {
1649 shift->_self_and_linked('bill', @_);
1652 sub self_and_svc_linked {
1653 shift->_self_and_linked('svc', @_);
1656 sub _self_and_linked {
1657 my( $self, $type, $hidden ) = @_;
1661 foreach ( ( $self, map { $_->dst_pkg->_self_and_linked($type, $_->hidden) }
1662 $self->_part_pkg_link($type) ) )
1664 $_->hidden($hidden) if $hidden;
1671 =item part_pkg_taxoverride [ CLASS ]
1673 Returns all associated FS::part_pkg_taxoverride objects (see
1674 L<FS::part_pkg_taxoverride>). Limits the returned set to those
1675 of class CLASS if defined. Class may be one of 'setup', 'recur',
1676 the empty string (default), or a usage class number (see L<FS::usage_class>).
1677 When a class is specified, the empty string class (default) is returned
1678 if no more specific values exist.
1682 sub part_pkg_taxoverride {
1686 my $hashref = { 'pkgpart' => $self->pkgpart };
1687 $hashref->{'usage_class'} = $class if defined($class);
1688 my @overrides = qsearch('part_pkg_taxoverride', $hashref );
1690 unless ( scalar(@overrides) || !defined($class) || !$class ){
1691 $hashref->{'usage_class'} = '';
1692 @overrides = qsearch('part_pkg_taxoverride', $hashref );
1698 =item has_taxproduct
1700 Returns true if this package has any taxproduct associated with it.
1704 sub has_taxproduct {
1707 $self->taxproductnum ||
1708 scalar( grep { $_ =~/^usage_taxproductnum_/ && $self->option($_) }
1709 keys %{ {$self->options} }
1715 =item taxproduct [ CLASS ]
1717 Returns the associated tax product for this package definition (see
1718 L<FS::part_pkg_taxproduct>). CLASS may be one of 'setup', 'recur' or
1719 the usage classnum (see L<FS::usage_class>). Returns the default
1720 tax product for this record if the more specific CLASS value does
1729 my $part_pkg_taxproduct;
1731 my $taxproductnum = $self->taxproductnum;
1733 my $class_taxproductnum = $self->option("usage_taxproductnum_$class", 1);
1734 $taxproductnum = $class_taxproductnum
1735 if $class_taxproductnum
1738 $part_pkg_taxproduct =
1739 qsearchs( 'part_pkg_taxproduct', { 'taxproductnum' => $taxproductnum } );
1741 unless ($part_pkg_taxproduct || $taxproductnum eq $self->taxproductnum ) {
1742 $taxproductnum = $self->taxproductnum;
1743 $part_pkg_taxproduct =
1744 qsearchs( 'part_pkg_taxproduct', { 'taxproductnum' => $taxproductnum } );
1747 $part_pkg_taxproduct;
1750 =item taxproduct_description [ CLASS ]
1752 Returns the description of the associated tax product for this package
1753 definition (see L<FS::part_pkg_taxproduct>).
1757 sub taxproduct_description {
1759 my $part_pkg_taxproduct = $self->taxproduct(@_);
1760 $part_pkg_taxproduct ? $part_pkg_taxproduct->description : '';
1763 =item units_taxproduct
1765 Returns the L<FS::part_pkg_taxproduct> record used to report the taxable
1766 service units (usually phone lines) on this package.
1770 sub units_taxproduct {
1772 $self->units_taxproductnum
1773 ? FS::part_pkg_taxproduct->by_key($self->units_taxproductnum)
1777 =item tax_rates DATA_PROVIDER, GEOCODE, [ CLASS ]
1779 Returns the tax table entries (L<FS::tax_rate> objects) that apply to this
1780 package in the location specified by GEOCODE, for usage class CLASS (one of
1781 'setup', 'recur', null, or a C<usage_class> number).
1787 my ($vendor, $geocode, $class) = @_;
1788 # if this part_pkg is overridden into a specific taxclass, get that class
1789 my @taxclassnums = map { $_->taxclassnum }
1790 $self->part_pkg_taxoverride($class);
1791 # otherwise, get its tax product category
1792 if (!@taxclassnums) {
1793 my $part_pkg_taxproduct = $self->taxproduct($class);
1794 # If this isn't defined, then the class has no taxproduct designation,
1795 # so return no tax rates.
1796 return () if !$part_pkg_taxproduct;
1798 # convert the taxproduct to the tax classes that might apply to it in
1800 @taxclassnums = map { $_->taxclassnum }
1801 grep { $_->taxable eq 'Y' } # why do we need this?
1802 $part_pkg_taxproduct->part_pkg_taxrate($geocode);
1804 return unless @taxclassnums;
1806 # then look up the actual tax_rate entries
1807 warn "Found taxclassnum values of ". join(',', @taxclassnums) ."\n"
1809 my $extra_sql = "AND taxclassnum IN (". join(',', @taxclassnums) . ")";
1810 my @taxes = qsearch({ 'table' => 'tax_rate',
1811 'hashref' => { 'geocode' => $geocode,
1812 'data_vendor' => $vendor,
1814 'extra_sql' => $extra_sql,
1816 warn "Found taxes ". join(',', map {$_->taxnum} @taxes) ."\n"
1822 =item part_pkg_discount
1824 Returns the package to discount m2m records (see L<FS::part_pkg_discount>)
1827 =item part_pkg_usage
1829 Returns the voice usage pools (see L<FS::part_pkg_usage>) defined for
1834 Returns the automatic transfer target for this package, or an empty string
1841 my $pkgpart = $self->change_to_pkgpart or return '';
1842 FS::part_pkg->by_key($pkgpart);
1847 Reblesses the object into the FS::part_pkg::PLAN class (if available), where
1848 PLAN is the object's I<plan> field. There should be better docs
1849 on how to create new price plans, but until then, see L</NEW PLAN CLASSES>.
1855 my $plan = $self->plan;
1857 cluck "no price plan found for pkgpart ". $self->pkgpart. "\n"
1861 return $self if ref($self) =~ /::$plan$/; #already blessed into plan subclass
1862 my $class = ref($self). "::$plan";
1863 warn "reblessing $self into $class" if $DEBUG > 1;
1866 bless($self, $class) unless $@;
1870 =item calc_setup CUST_PKG START_DATE DETAILS_ARRAYREF OPTIONS_HASHREF
1872 =item calc_recur CUST_PKG START_DATE DETAILS_ARRAYREF OPTIONS_HASHREF
1874 Calculates and returns the setup or recurring fees, respectively, for this
1875 package. Implementation is in the FS::part_pkg:* module specific to this price
1878 Adds invoicing details to the passed-in DETAILS_ARRAYREF
1880 Options are passed as a hashref. Available options:
1886 Frequency override (for calc_recur)
1890 This option is filled in by the method rather than controlling its operation.
1891 It is an arrayref. Applicable discounts will be added to the arrayref, as
1892 L<FS::cust_bill_pkg_discount|FS::cust_bill_pkg_discount records>.
1896 For package add-ons, is the base L<FS::part_pkg|package definition>, otherwise
1897 no different than pkgpart.
1899 =item precommit_hooks
1901 This option is filled in by the method rather than controlling its operation.
1902 It is an arrayref. Anonymous coderefs will be added to the arrayref. They
1903 need to be called before completing the billing operation. For calc_recur
1906 =item increment_next_bill
1908 Increment the next bill date (boolean, for calc_recur). Typically true except
1909 for particular situations.
1913 This option is filled in by the method rather than controlling its operation.
1914 It indicates a deferred setup fee that is billed at calc_recur time (see price
1915 plan option prorate_defer_bill).
1919 Note: Don't calculate prices when not actually billing the package. For that,
1920 see the L</base_setup|base_setup> and L</base_recur|base_recur> methods.
1925 sub calc_setup { die 'no calc_setup for '. shift->plan. "\n"; }
1926 sub calc_recur { die 'no calc_recur for '. shift->plan. "\n"; }
1928 =item calc_remain CUST_PKG [ OPTION => VALUE ... ]
1930 Calculates and returns the remaining value to be credited upon package
1931 suspension, change, or cancellation, if enabled.
1933 Options are passed as a list of keys and values. Available options:
1939 Override for the current time
1941 =item cust_credit_source_bill_pkg
1943 This option is filled in by the method rather than controlling its operation.
1945 L<FS::cust_credit_source_bill_pkg|FS::cust_credit_source_bill_pkg> records will
1946 be added to the arrayref indicating the specific line items and amounts which
1947 are the source of this remaining credit.
1951 Note: Don't calculate prices when not actually suspending or cancelling the
1956 #fallback that returns 0 for old legacy packages with no plan
1957 sub calc_remain { 0; }
1959 =item calc_units CUST_PKG
1961 This returns the number of provisioned svc_phone records, or, of the package
1962 count_available_phones option is set, the number available to be provisioned
1968 my($self, $cust_pkg ) = @_;
1970 if ( $self->option('count_available_phones', 1)) {
1971 foreach my $pkg_svc ($cust_pkg->part_pkg->pkg_svc) {
1972 if ($pkg_svc->part_svc->svcdb eq 'svc_phone') { # svc_pbx?
1973 $count += $pkg_svc->quantity || 0;
1976 $count *= $cust_pkg->quantity;
1979 scalar(grep { $_->part_svc->svcdb eq 'svc_phone' } $cust_pkg->cust_svc);
1984 #fallback for everything not based on flat.pm
1985 sub recur_temporality { 'upcoming'; }
1987 =item calc_cancel START_DATE DETAILS_ARRAYREF OPTIONS_HASHREF
1989 Runs any necessary billing on cancellation: another recurring cycle for
1990 recur_temporailty 'preceding' pacakges with the bill_recur_on_cancel option
1991 set (calc_recur), or, any outstanding usage for pacakges with the
1992 bill_usage_on_cancel option set (calc_usage).
1996 #fallback for everything not based on flat.pm, doesn't do this yet (which is
1997 #okay, nothing of ours not based on flat.pm does usage-on-cancel billing
1998 sub calc_cancel { 0; }
2000 #fallback for everything except bulk.pm
2001 sub hide_svc_detail { 0; }
2003 #fallback for packages that can't/won't summarize usage
2004 sub sum_usage { 0; }
2006 =item recur_cost_permonth CUST_PKG
2008 recur_cost divided by freq (only supported for monthly and longer frequencies)
2012 sub recur_cost_permonth {
2013 my($self, $cust_pkg) = @_;
2014 return 0 unless $self->freq =~ /^\d+$/ && $self->freq > 0;
2015 sprintf('%.2f', ($self->recur_cost || 0) / $self->freq );
2018 =item cust_bill_pkg_recur CUST_PKG
2020 Actual recurring charge for the specified customer package from customer's most
2025 sub cust_bill_pkg_recur {
2026 my($self, $cust_pkg) = @_;
2027 my $cust_bill_pkg = qsearchs({
2028 'table' => 'cust_bill_pkg',
2029 'addl_from' => 'LEFT JOIN cust_bill USING ( invnum )',
2030 'hashref' => { 'pkgnum' => $cust_pkg->pkgnum,
2031 'recur' => { op=>'>', value=>'0' },
2033 'order_by' => 'ORDER BY cust_bill._date DESC,
2034 cust_bill_pkg.sdate DESC
2037 }) or return 0; #die "use cust_bill_pkg_recur credits with once_perinv condition";
2038 $cust_bill_pkg->recur;
2041 =item unit_setup CUST_PKG
2043 Returns the setup fee for one unit of the package.
2048 my ($self, $cust_pkg) = @_;
2049 $self->option('setup_fee') || 0;
2054 unit_setup minus setup_cost
2060 $self->unit_setup(@_) - ($self->setup_cost || 0);
2063 =item recur_margin_permonth
2065 base_recur_permonth minus recur_cost_permonth
2069 sub recur_margin_permonth {
2071 $self->base_recur_permonth(@_) - $self->recur_cost_permonth(@_);
2074 =item intro_end PACKAGE
2076 Takes an L<FS::cust_pkg> object. If this plan has an introductory rate,
2077 returns the expected date the intro period will end. If there is no intro
2086 =item format OPTION DATA
2088 Returns data formatted according to the function 'format' described
2089 in the plan info. Returns DATA if no such function exists.
2094 my ($self, $option, $data) = (shift, shift, shift);
2095 if (exists($plans{$self->plan}->{fields}->{$option}{format})) {
2096 &{$plans{$self->plan}->{fields}->{$option}{format}}($data);
2102 =item parse OPTION DATA
2104 Returns data parsed according to the function 'parse' described
2105 in the plan info. Returns DATA if no such function exists.
2110 my ($self, $option, $data) = (shift, shift, shift);
2111 if (exists($plans{$self->plan}->{fields}->{$option}{parse})) {
2112 &{$plans{$self->plan}->{fields}->{$option}{parse}}($data);
2122 =head1 CLASS METHODS
2130 # Used by FS::Upgrade to migrate to a new database.
2132 sub _upgrade_data { # class method
2133 my($class, %opts) = @_;
2135 warn "[FS::part_pkg] upgrading $class\n" if $DEBUG;
2137 my @part_pkg = qsearch({
2138 'table' => 'part_pkg',
2139 'extra_sql' => "WHERE ". join(' OR ',
2140 'plan IS NULL', "plan = '' ",
2144 foreach my $part_pkg (@part_pkg) {
2146 unless ( $part_pkg->plan ) {
2147 $part_pkg->plan('flat');
2154 # Convert RADIUS accounting usage metrics from megabytes to gigabytes
2156 my $upgrade = 'part_pkg_gigabyte_usage';
2157 if (!FS::upgrade_journal->is_done($upgrade)) {
2158 foreach my $part_pkg (qsearch('part_pkg',
2159 { plan => 'sqlradacct_hour' })
2162 my $pkgpart = $part_pkg->pkgpart;
2164 foreach my $opt (qsearch('part_pkg_option',
2165 { 'optionname' => { op => 'LIKE',
2166 value => 'recur_included_%',
2168 pkgpart => $pkgpart,
2171 next if $opt->optionname eq 'recur_included_hours'; # unfortunately named field
2172 next if $opt->optionvalue == 0;
2174 $opt->optionvalue($opt->optionvalue / 1024);
2176 my $error = $opt->replace;
2177 die $error if $error;
2180 foreach my $opt (qsearch('part_pkg_option',
2181 { 'optionname' => { op => 'LIKE',
2182 value => 'recur_%_charge',
2184 pkgpart => $pkgpart,
2186 $opt->optionvalue($opt->optionvalue * 1024);
2188 my $error = $opt->replace;
2189 die $error if $error;
2193 FS::upgrade_journal->set_done($upgrade);
2196 # the rest can be done asynchronously
2199 sub queueable_upgrade {
2200 # now upgrade to the explicit custom flag
2202 my $search = FS::Cursor->new({
2203 'table' => 'part_pkg',
2204 'hashref' => { disabled => 'Y', custom => '' },
2205 'extra_sql' => "AND comment LIKE '(CUSTOM) %'",
2209 while (my $part_pkg = $search->fetch) {
2210 my $new = new FS::part_pkg { $part_pkg->hash };
2212 my $comment = $part_pkg->comment;
2213 $comment =~ s/^\(CUSTOM\) //;
2214 $comment = '(none)' unless $comment =~ /\S/;
2215 $new->comment($comment);
2217 my $pkg_svc = { map { $_->svcpart => $_->quantity } $part_pkg->pkg_svc };
2218 my $primary = $part_pkg->svcpart;
2219 my $options = { $part_pkg->options };
2221 my $error = $new->replace( $part_pkg,
2222 'pkg_svc' => $pkg_svc,
2223 'primary_svc' => $primary,
2224 'options' => $options,
2227 warn "pkgpart#".$part_pkg->pkgpart.": $error\n";
2234 # set family_pkgpart on any packages that don't have it
2235 $search = FS::Cursor->new('part_pkg', { 'family_pkgpart' => '' });
2236 while (my $part_pkg = $search->fetch) {
2237 $part_pkg->set('family_pkgpart' => $part_pkg->pkgpart);
2238 my $error = $part_pkg->SUPER::replace;
2240 warn "pkgpart#".$part_pkg->pkgpart.": $error\n";
2247 my @part_pkg_option = qsearch('part_pkg_option',
2248 { 'optionname' => 'unused_credit',
2251 foreach my $old_opt (@part_pkg_option) {
2252 my $pkgpart = $old_opt->pkgpart;
2253 my $error = $old_opt->delete;
2254 die $error if $error;
2256 foreach (qw(unused_credit_cancel unused_credit_change)) {
2257 my $new_opt = new FS::part_pkg_option {
2258 'pkgpart' => $pkgpart,
2262 $error = $new_opt->insert;
2263 die $error if $error;
2267 # migrate use_disposition_taqua and use_disposition to disposition_in
2268 @part_pkg_option = qsearch('part_pkg_option',
2269 { 'optionname' => { op => 'LIKE',
2270 value => 'use_disposition%',
2274 my %newopts = map { $_->pkgpart => $_ }
2275 qsearch('part_pkg_option', { 'optionname' => 'disposition_in', } );
2276 foreach my $old_opt (@part_pkg_option) {
2277 my $pkgpart = $old_opt->pkgpart;
2278 my $newval = $old_opt->optionname eq 'use_disposition_taqua' ? '100'
2280 my $error = $old_opt->delete;
2281 die $error if $error;
2283 if ( exists($newopts{$pkgpart}) ) {
2284 my $opt = $newopts{$pkgpart};
2285 $opt->optionvalue($opt->optionvalue.",$newval");
2286 $error = $opt->replace;
2287 die $error if $error;
2289 my $new_opt = new FS::part_pkg_option {
2290 'pkgpart' => $pkgpart,
2291 'optionname' => 'disposition_in',
2292 'optionvalue' => $newval,
2294 $error = $new_opt->insert;
2295 die $error if $error;
2296 $newopts{$pkgpart} = $new_opt;
2300 # set any package with FCC voice lines to the "VoIP with broadband" category
2301 # for backward compatibility
2303 # recover from a bad upgrade bug
2304 my $upgrade = 'part_pkg_fcc_voip_class_FIX';
2305 if (!FS::upgrade_journal->is_done($upgrade)) {
2306 my $bad_upgrade = qsearchs('upgrade_journal',
2307 { upgrade => 'part_pkg_fcc_voip_class' }
2309 if ( $bad_upgrade ) {
2310 my $where = 'WHERE history_date <= '.$bad_upgrade->_date.
2311 ' AND history_date > '.($bad_upgrade->_date - 3600);
2312 my @h_part_pkg_option = map { FS::part_pkg_option->new($_->hashref) }
2315 'table' => 'h_part_pkg_option',
2317 'extra_sql' => "$where AND history_action = 'delete'",
2318 'order_by' => 'ORDER BY history_date ASC',
2320 my @h_pkg_svc = map { FS::pkg_svc->new($_->hashref) }
2323 'table' => 'h_pkg_svc',
2325 'extra_sql' => "$where AND history_action = 'replace_old'",
2326 'order_by' => 'ORDER BY history_date ASC',
2329 foreach my $deleted (@h_part_pkg_option, @h_pkg_svc) {
2330 my $pkgpart ||= $deleted->pkgpart;
2331 $opt{$pkgpart} ||= {
2337 if ( $deleted->isa('FS::part_pkg_option') ) {
2338 $opt{$pkgpart}{options}{ $deleted->optionname } = $deleted->optionvalue;
2340 my $svcpart = $deleted->svcpart;
2341 $opt{$pkgpart}{pkg_svc}{$svcpart} = $deleted->quantity;
2342 $opt{$pkgpart}{hidden_svc}{$svcpart} ||= $deleted->hidden;
2343 $opt{$pkgpart}{primary_svc} = $svcpart if $deleted->primary_svc;
2346 foreach my $pkgpart (keys %opt) {
2347 my $part_pkg = FS::part_pkg->by_key($pkgpart);
2348 my $error = $part_pkg->replace( $part_pkg->replace_old, $opt{$pkgpart} );
2350 die "error recovering damaged pkgpart $pkgpart:\n$error\n";
2353 } # $bad_upgrade exists
2354 else { # do the original upgrade, but correctly this time
2355 my @part_pkg = qsearch('part_pkg', {
2356 fcc_ds0s => { op => '>', value => 0 },
2357 fcc_voip_class => ''
2359 foreach my $part_pkg (@part_pkg) {
2360 $part_pkg->set(fcc_voip_class => 2);
2361 my @pkg_svc = $part_pkg->pkg_svc;
2362 my %quantity = map {$_->svcpart, $_->quantity} @pkg_svc;
2363 my %hidden = map {$_->svcpart, $_->hidden } @pkg_svc;
2364 my $error = $part_pkg->replace(
2365 $part_pkg->replace_old,
2366 options => { $part_pkg->options },
2367 pkg_svc => \%quantity,
2368 hidden_svc => \%hidden,
2369 primary_svc => ($part_pkg->svcpart || ''),
2371 die $error if $error;
2374 FS::upgrade_journal->set_done($upgrade);
2377 # migrate adjourn_months, expire_months, and contract_end_months to
2379 foreach my $field (qw(adjourn_months expire_months contract_end_months)) {
2380 foreach my $option (qsearch('part_pkg_option', { optionname => $field })) {
2381 my $part_pkg = $option->part_pkg;
2382 my $error = $option->delete;
2383 if ( $option->optionvalue and $part_pkg->get($field) eq '' ) {
2384 $part_pkg->set($field, $option->optionvalue);
2385 $error ||= $part_pkg->replace;
2387 die $error if $error;
2391 # remove custom flag from one-time charge packages that were accidentally
2393 $search = FS::Cursor->new({
2394 'table' => 'part_pkg',
2395 'hashref' => { 'freq' => '0',
2397 'family_pkgpart' => { op => '!=', value => '' },
2399 'addl_from' => ' JOIN
2400 (select pkgpart from cust_pkg group by pkgpart having count(*) = 1)
2401 AS singular_pkg USING (pkgpart)',
2403 my @fields = grep { $_ ne 'pkgpart'
2405 and $_ ne 'disabled' } FS::part_pkg->fields;
2406 PKGPART: while (my $part_pkg = $search->fetch) {
2407 # can't merge the package back into its parent (too late for that)
2408 # but we can remove the custom flag if it's not actually customized,
2409 # i.e. nothing has been changed.
2411 my $family_pkgpart = $part_pkg->family_pkgpart;
2412 next PKGPART if $family_pkgpart == $part_pkg->pkgpart;
2413 my $parent_pkg = FS::part_pkg->by_key($family_pkgpart);
2414 foreach my $field (@fields) {
2415 if ($part_pkg->get($field) ne $parent_pkg->get($field)) {
2419 # options have to be identical too
2420 # but links, FCC options, discount plans, and usage packages can't be
2421 # changed through the "modify charge" UI, so skip them
2422 my %newopt = $part_pkg->options;
2423 my %oldopt = $parent_pkg->options;
2424 OPTION: foreach my $option (keys %newopt) {
2425 if (delete $newopt{$option} ne delete $oldopt{$option}) {
2429 if (keys(%newopt) or keys(%oldopt)) {
2432 # okay, now replace it
2433 warn "Removing custom flag from part_pkg#".$part_pkg->pkgpart."\n";
2434 $part_pkg->set('custom', '');
2435 my $error = $part_pkg->replace;
2436 die $error if $error;
2442 =item curuser_pkgs_sql
2444 Returns an SQL fragment for searching for packages the current user can
2445 use, either via part_pkg.agentnum directly, or via agent type (see
2450 sub curuser_pkgs_sql {
2453 $class->_pkgs_sql( $FS::CurrentUser::CurrentUser->agentnums );
2457 =item agent_pkgs_sql AGENT | AGENTNUM, ...
2459 Returns an SQL fragment for searching for packages the provided agent or agents
2460 can use, either via part_pkg.agentnum directly, or via agent type (see
2465 sub agent_pkgs_sql {
2466 my $class = shift; #i'm a class method, not a sub (the question is... why??)
2467 my @agentnums = map { ref($_) ? $_->agentnum : $_ } @_;
2469 $class->_pkgs_sql(@agentnums); #is this why
2474 my( $class, @agentnums ) = @_;
2475 my $agentnums = join(',', @agentnums);
2479 ( agentnum IS NOT NULL AND agentnum IN ($agentnums) )
2480 OR ( agentnum IS NULL
2481 AND EXISTS ( SELECT 1
2483 LEFT JOIN agent_type USING ( typenum )
2484 LEFT JOIN agent AS typeagent USING ( typenum )
2485 WHERE type_pkgs.pkgpart = part_pkg.pkgpart
2486 AND typeagent.agentnum IN ($agentnums)
2494 =item join_options_sql
2496 Returns an SQL fragment for JOINing the part_pkg_option records for this
2497 package's setup_fee and recur_fee (as setup_option and recur_option,
2498 respectively). Useful for optimization.
2502 sub join_options_sql {
2505 LEFT JOIN part_pkg_option AS setup_option
2506 ON ( part_pkg.pkgpart = setup_option.pkgpart
2507 AND setup_option.optionname = 'setup_fee' )
2508 LEFT JOIN part_pkg_option AS recur_option
2509 ON ( part_pkg.pkgpart = recur_option.pkgpart
2510 AND recur_option.optionname = 'recur_fee' )
2524 #false laziness w/part_export & cdr
2526 foreach my $INC ( @INC ) {
2527 warn "globbing $INC/FS/part_pkg/[a-z]*.pm\n" if $DEBUG;
2528 foreach my $file ( glob("$INC/FS/part_pkg/[a-z]*.pm") ) {
2529 warn "attempting to load plan info from $file\n" if $DEBUG;
2530 $file =~ /\/(\w+)\.pm$/ or do {
2531 warn "unrecognized file in $INC/FS/part_pkg/: $file\n";
2535 my $info = eval "use FS::part_pkg::$mod; ".
2536 "\\%FS::part_pkg::$mod\::info;";
2538 die "error using FS::part_pkg::$mod (skipping): $@\n" if $@;
2541 unless ( keys %$info ) {
2542 warn "no %info hash found in FS::part_pkg::$mod, skipping\n";
2545 warn "got plan info from FS::part_pkg::$mod: $info\n" if $DEBUG;
2546 #if ( exists($info->{'disabled'}) && $info->{'disabled'} ) {
2547 # warn "skipping disabled plan FS::part_pkg::$mod" if $DEBUG;
2550 $info{$mod} = $info;
2551 $info->{'weight'} ||= 0; # quiet warnings
2555 # copy one level deep to allow replacement of fields and fieldorder
2556 tie %plans, 'Tie::IxHash',
2557 map { my %infohash = %{ $info{$_} };
2559 sort { $info{$a}->{'weight'} <=> $info{$b}->{'weight'} }
2562 # inheritance of plan options
2563 foreach my $name (keys(%info)) {
2564 if (exists($info{$name}->{'disabled'}) and $info{$name}->{'disabled'}) {
2565 warn "skipping disabled plan FS::part_pkg::$name" if $DEBUG;
2566 delete $plans{$name};
2569 my $parents = $info{$name}->{'inherit_fields'} || [];
2570 my (%fields, %field_exists, @fieldorder);
2571 foreach my $parent ($name, @$parents) {
2572 if ( !exists($info{$parent}) ) {
2573 warn "$name tried to inherit from nonexistent '$parent'\n";
2576 %fields = ( # avoid replacing existing fields
2577 %{ $info{$parent}->{'fields'} || {} },
2580 foreach (@{ $info{$parent}->{'fieldorder'} || [] }) {
2582 next if $field_exists{$_};
2583 $field_exists{$_} = 1;
2584 # allow inheritors to remove inherited fields from the fieldorder
2585 push @fieldorder, $_ if !exists($fields{$_}) or
2586 !exists($fields{$_}->{'disabled'});
2589 $plans{$name}->{'fields'} = \%fields;
2590 $plans{$name}->{'fieldorder'} = \@fieldorder;
2600 =head1 NEW PLAN CLASSES
2602 A module should be added in FS/FS/part_pkg/ Eventually, an example may be
2603 found in eg/plan_template.pm. Until then, it is suggested that you use the
2604 other modules in FS/FS/part_pkg/ as a guide.
2608 The delete method is unimplemented.
2610 setup and recur semantics are not yet defined (and are implemented in
2611 FS::cust_bill. hmm.). now they're deprecated and need to go.
2615 part_pkg_taxrate is Pg specific
2617 replace should be smarter about managing the related tables (options, pkg_svc)
2621 L<FS::Record>, L<FS::cust_pkg>, L<FS::type_pkgs>, L<FS::pkg_svc>, L<Safe>.
2622 schema.html from the base documentation.