FS/FS/cust_location.pm

   1 package FS::cust_location;
   2 use base qw( FS::geocode_Mixin FS::Record );
   3
   4 use strict;
   5 use vars qw( $import $DEBUG $conf $label_prefix );
   6 use Data::Dumper;
   7 use Date::Format qw( time2str );
   8 use FS::UID qw( dbh driver_name );
   9 use FS::Record qw( qsearch qsearchs );
  10 use FS::Conf;
  11 use FS::prospect_main;
  12 use FS::cust_main;
  13 use FS::cust_main_county;
  14 use FS::part_export;
  15 use FS::GeocodeCache;
  16
  17 $import = 0;
  18
  19 $DEBUG = 0;
  20
  21 FS::UID->install_callback( sub {
  22   $conf = FS::Conf->new;
  23   $label_prefix = $conf->config('cust_location-label_prefix') || '';
  24 });
  25
  26 =head1 NAME
  27
  28 FS::cust_location - Object methods for cust_location records
  29
  30 =head1 SYNOPSIS
  31
  32   use FS::cust_location;
  33
  34   $record = new FS::cust_location \%hash;
  35   $record = new FS::cust_location { 'column' => 'value' };
  36
  37   $error = $record->insert;
  38
  39   $error = $new_record->replace($old_record);
  40
  41   $error = $record->delete;
  42
  43   $error = $record->check;
  44
  45 =head1 DESCRIPTION
  46
  47 An FS::cust_location object represents a customer location.  FS::cust_location
  48 inherits from FS::Record.  The following fields are currently supported:
  49
  50 =over 4
  51
  52 =item locationnum
  53
  54 primary key
  55
  56 =item custnum
  57
  58 custnum
  59
  60 =item address1
  61
  62 Address line one (required)
  63
  64 =item address2
  65
  66 Address line two (optional)
  67
  68 =item city
  69
  70 City (if cust_main-no_city_in_address config is set when inserting, this will be forced blank)
  71
  72 =item county
  73
  74 County (optional, see L<FS::cust_main_county>)
  75
  76 =item state
  77
  78 State (see L<FS::cust_main_county>)
  79
  80 =item zip
  81
  82 Zip
  83
  84 =item country
  85
  86 Country (see L<FS::cust_main_county>)
  87
  88 =item geocode
  89
  90 Geocode
  91
  92 =item district
  93
  94 Tax district code (optional)
  95
  96 =item disabled
  97
  98 Disabled flag; set to 'Y' to disable the location.
  99
 100 =back
 101
 102 =head1 METHODS
 103
 104 =over 4
 105
 106 =item new HASHREF
 107
 108 Creates a new location.  To add the location to the database, see L<"insert">.
 109
 110 Note that this stores the hash reference, not a distinct copy of the hash it
 111 points to.  You can ask the object for a copy with the I<hash> method.
 112
 113 =cut
 114
 115 sub table { 'cust_location'; }
 116
 117 =item find_or_insert
 118
 119 Finds an existing location matching the customer and address values in this
 120 location, if one exists, and sets the contents of this location equal to that
 121 one (including its locationnum).
 122
 123 If an existing location is not found, this one I<will> be inserted.  (This is a
 124 change from the "new_or_existing" method that this replaces.)
 125
 126 The following fields are considered "essential" and I<must> match: custnum,
 127 address1, address2, city, county, state, zip, country, location_number,
 128 location_type, location_kind.  Disabled locations will be found only if this
 129 location is set to disabled.
 130
 131 All other fields are considered "non-essential" and will be ignored in
 132 finding a matching location.  If the existing location doesn't match
 133 in these fields, it will be updated in-place to match.
 134
 135 Returns an error string if inserting or updating a location failed.
 136
 137 It is unfortunately hard to determine if this created a new location or not.
 138
 139 =cut
 140
 141 sub find_or_insert {
 142   my $self = shift;
 143
 144   warn "find_or_insert:\n".Dumper($self) if $DEBUG;
 145
 146   my @essential = (qw(custnum address1 address2 city county state zip country
 147     location_number location_type location_kind disabled));
 148
 149   if ($conf->exists('cust_main-no_city_in_address')) {
 150     warn "Warning: passed city to find_or_insert when cust_main-no_city_in_address is configured, ignoring it"
 151       if $self->get('city');
 152     $self->set('city','');
 153   }
 154
 155   # I don't think this is necessary
 156   #if ( !$self->coord_auto and $self->latitude and $self->longitude ) {
 157   #  push @essential, qw(latitude longitude);
 158   #  # but NOT coord_auto; if the latitude and longitude match the geocoded
 159   #  # values then that's good enough
 160   #}
 161
 162   # put nonempty, nonessential fields/values into this hash
 163   my %nonempty = map { $_ => $self->get($_) }
 164                  grep {$self->get($_)} $self->fields;
 165   delete @nonempty{@essential};
 166   delete $nonempty{'locationnum'};
 167
 168   my %hash = map { $_ => $self->get($_) } @essential;
 169   my @matches = qsearch('cust_location', \%hash);
 170
 171   # we no longer reject matches for having different values in nonessential
 172   # fields; we just alter the record to match
 173   if ( @matches ) {
 174     my $old = $matches[0];
 175     warn "found existing location #".$old->locationnum."\n" if $DEBUG;
 176     foreach my $field (keys %nonempty) {
 177       if ($old->get($field) ne $nonempty{$field}) {
 178         warn "altering $field to match requested location" if $DEBUG;
 179         $old->set($field, $nonempty{$field});
 180       }
 181     } # foreach $field
 182
 183     if ( $old->modified ) {
 184       warn "updating non-essential fields\n" if $DEBUG;
 185       my $error = $old->replace;
 186       return $error if $error;
 187     }
 188     # set $self equal to $old
 189     foreach ($self->fields) {
 190       $self->set($_, $old->get($_));
 191     }
 192     return "";
 193   }
 194
 195   # didn't find a match
 196   warn "not found; inserting new location\n" if $DEBUG;
 197   return $self->insert;
 198 }
 199
 200 =item insert
 201
 202 Adds this record to the database.  If there is an error, returns the error,
 203 otherwise returns false.
 204
 205 =cut
 206
 207 sub insert {
 208   my $self = shift;
 209
 210   if ($conf->exists('cust_main-no_city_in_address')) {
 211     warn "Warning: passed city to insert when cust_main-no_city_in_address is configured, ignoring it"
 212       if $self->get('city');
 213     $self->set('city','');
 214   }
 215
 216   if ( $self->censustract ) {
 217     $self->set('censusyear' => $conf->config('census_year') || 2012);
 218   }
 219
 220   my $oldAutoCommit = $FS::UID::AutoCommit;
 221   local $FS::UID::AutoCommit = 0;
 222   my $dbh = dbh;
 223
 224   my $error = $self->SUPER::insert(@_);
 225   if ( $error ) {
 226     $dbh->rollback if $oldAutoCommit;
 227     return $error;
 228   }
 229
 230   #false laziness with cust_main, will go away eventually
 231   if ( !$import and $conf->config('tax_district_method') ) {
 232
 233     my $queue = new FS::queue {
 234       'job' => 'FS::geocode_Mixin::process_district_update'
 235     };
 236     $error = $queue->insert( ref($self), $self->locationnum );
 237     if ( $error ) {
 238       $dbh->rollback if $oldAutoCommit;
 239       return $error;
 240     }
 241
 242   }
 243
 244   # cust_location exports
 245   #my $export_args = $options{'export_args'} || [];
 246
 247   # don't export custnum_pending cases, let follow-up replace handle that
 248   if ($self->custnum || $self->prospectnum) {
 249     my @part_export =
 250       map qsearch( 'part_export', {exportnum=>$_} ),
 251         $conf->config('cust_location-exports'); #, $agentnum
 252
 253     foreach my $part_export ( @part_export ) {
 254       my $error = $part_export->export_insert($self); #, @$export_args);
 255       if ( $error ) {
 256         $dbh->rollback if $oldAutoCommit;
 257         return "exporting to ". $part_export->exporttype.
 258                " (transaction rolled back): $error";
 259       }
 260     }
 261   }
 262
 263   $dbh->commit or die $dbh->errstr if $oldAutoCommit;
 264   '';
 265 }
 266
 267 =item delete
 268
 269 Delete this record from the database.
 270
 271 =item replace OLD_RECORD
 272
 273 Replaces the OLD_RECORD with this one in the database.  If there is an error,
 274 returns the error, otherwise returns false.
 275
 276 =cut
 277
 278 sub replace {
 279   my $self = shift;
 280   my $old = shift;
 281   $old ||= $self->replace_old;
 282
 283   warn "Warning: passed city to replace when cust_main-no_city_in_address is configured"
 284     if $conf->exists('cust_main-no_city_in_address') && $self->get('city');
 285
 286   # the following fields are immutable if this is a customer location. if
 287   # it's a prospect location, then there are no active packages, no billing
 288   # history, no taxes, and in general no reason to keep the old location
 289   # around.
 290   if ( $self->custnum ) {
 291     foreach (qw(address1 address2 city state zip country)) {
 292       if ( $self->$_ ne $old->$_ ) {
 293         return "can't change cust_location field $_";
 294       }
 295     }
 296   }
 297
 298   my $oldAutoCommit = $FS::UID::AutoCommit;
 299   local $FS::UID::AutoCommit = 0;
 300   my $dbh = dbh;
 301
 302   my $error = $self->SUPER::replace($old);
 303   if ( $error ) {
 304     $dbh->rollback if $oldAutoCommit;
 305     return $error;
 306   }
 307
 308   # cust_location exports
 309   #my $export_args = $options{'export_args'} || [];
 310
 311   # don't export custnum_pending cases, let follow-up replace handle that
 312   if ($self->custnum || $self->prospectnum) {
 313     my @part_export =
 314       map qsearch( 'part_export', {exportnum=>$_} ),
 315         $conf->config('cust_location-exports'); #, $agentnum
 316
 317     foreach my $part_export ( @part_export ) {
 318       my $error = $part_export->export_replace($self, $old); #, @$export_args);
 319       if ( $error ) {
 320         $dbh->rollback if $oldAutoCommit;
 321         return "exporting to ". $part_export->exporttype.
 322                " (transaction rolled back): $error";
 323       }
 324     }
 325   }
 326
 327   $dbh->commit or die $dbh->errstr if $oldAutoCommit;
 328   '';
 329 }
 330
 331
 332 =item check
 333
 334 Checks all fields to make sure this is a valid location.  If there is
 335 an error, returns the error, otherwise returns false.  Called by the insert
 336 and replace methods.
 337
 338 =cut
 339
 340 sub check {
 341   my $self = shift;
 342
 343   return '' if $self->disabled; # so that disabling locations never fails
 344
 345   my $error =
 346     $self->ut_numbern('locationnum')
 347     || $self->ut_foreign_keyn('prospectnum', 'prospect_main', 'prospectnum')
 348     || $self->ut_foreign_keyn('custnum', 'cust_main', 'custnum')
 349     || $self->ut_textn('locationname')
 350     || $self->ut_text('address1')
 351     || $self->ut_textn('address2')
 352     || ($conf->exists('cust_main-no_city_in_address')
 353         ? $self->ut_textn('city')
 354         : $self->ut_text('city'))
 355     || $self->ut_textn('county')
 356     || $self->ut_textn('state')
 357     || $self->ut_country('country')
 358     || (!$import && $self->ut_zip('zip', $self->country))
 359     || $self->ut_coordn('latitude')
 360     || $self->ut_coordn('longitude')
 361     || $self->ut_enum('coord_auto', [ '', 'Y' ])
 362     || $self->ut_enum('addr_clean', [ '', 'Y' ])
 363     || $self->ut_alphan('location_type')
 364     || $self->ut_textn('location_number')
 365     || $self->ut_enum('location_kind', [ '', 'R', 'B' ] )
 366     || $self->ut_alphan('geocode')
 367     || $self->ut_alphan('district')
 368     || $self->ut_numbern('censusyear')
 369   ;
 370   return $error if $error;
 371   if ( $self->censustract ne '' ) {
 372     $self->censustract =~ /^\s*(\d{9})\.?(\d{2})\s*$/
 373       or return "Illegal census tract: ". $self->censustract;
 374
 375     $self->censustract("$1.$2");
 376   }
 377
 378   #yikes... this is ancient, pre-dates cust_location and will be harder to
 379   # implement now... how do we know this location is a service location from
 380   # here and not a billing? we can't just check locationnums, we might be new :/
 381   return "Unit # is required"
 382     if $conf->exists('cust_main-require_address2')
 383     && ! $self->address2 =~ /\S/;
 384
 385   # tricky...we have to allow for the customer to not be inserted yet
 386   return "No prospect or customer!" unless $self->prospectnum
 387                                         || $self->custnum
 388                                         || $self->get('custnum_pending');
 389   return "Prospect and customer!"       if $self->prospectnum && $self->custnum;
 390
 391   return 'Location kind is required'
 392     if $self->prospectnum
 393     && $conf->exists('prospect_main-alt_address_format')
 394     && ! $self->location_kind;
 395
 396   unless ( $import or qsearch('cust_main_county', {
 397     'country' => $self->country,
 398     'state'   => '',
 399    } ) ) {
 400     return "Unknown state/county/country: ".
 401       $self->state. "/". $self->county. "/". $self->country
 402       unless qsearch('cust_main_county',{
 403         'state'   => $self->state,
 404         'county'  => $self->county,
 405         'country' => $self->country,
 406       } );
 407   }
 408
 409   # set coordinates, unless we already have them
 410   if (!$import and !$self->latitude and !$self->longitude) {
 411     $self->set_coord;
 412   }
 413
 414   $self->SUPER::check;
 415 }
 416
 417 =item country_full
 418
 419 Returns this location's full country name
 420
 421 =cut
 422
 423 #moved to geocode_Mixin.pm
 424
 425 =item line
 426
 427 Synonym for location_label
 428
 429 =cut
 430
 431 sub line {
 432   my $self = shift;
 433   $self->location_label(@_);
 434 }
 435
 436 =item has_ship_address
 437
 438 Returns false since cust_location objects do not have a separate shipping
 439 address.
 440
 441 =cut
 442
 443 sub has_ship_address {
 444   '';
 445 }
 446
 447 =item location_hash
 448
 449 Returns a list of key/value pairs, with the following keys: address1, address2,
 450 city, county, state, zip, country, geocode, location_type, location_number,
 451 location_kind.
 452
 453 =cut
 454
 455 =item disable_if_unused
 456
 457 Sets the "disabled" flag on the location if it is no longer in use as a
 458 prospect location, package location, or a customer's billing or default
 459 service address.
 460
 461 =cut
 462
 463 sub disable_if_unused {
 464
 465   my $self = shift;
 466   my $locationnum = $self->locationnum;
 467   return '' if FS::cust_main->count('bill_locationnum = '.$locationnum.' OR
 468                                      ship_locationnum = '.$locationnum)
 469             or FS::contact->count(      'locationnum  = '.$locationnum)
 470             or FS::cust_pkg->count('cancel IS NULL AND
 471                                          locationnum  = '.$locationnum)
 472           ;
 473   $self->disabled('Y');
 474   $self->replace;
 475
 476 }
 477
 478 =item move_to
 479
 480 Takes a new L<FS::cust_location> object.  Moves all packages that use the
 481 existing location to the new one, then sets the "disabled" flag on the old
 482 location.  Returns nothing on success, an error message on error.
 483
 484 =cut
 485
 486 sub move_to {
 487   my $old = shift;
 488   my $new = shift;
 489
 490   warn "move_to:\nFROM:".Dumper($old)."\nTO:".Dumper($new) if $DEBUG;
 491
 492   local $SIG{HUP} = 'IGNORE';
 493   local $SIG{INT} = 'IGNORE';
 494   local $SIG{QUIT} = 'IGNORE';
 495   local $SIG{TERM} = 'IGNORE';
 496   local $SIG{TSTP} = 'IGNORE';
 497   local $SIG{PIPE} = 'IGNORE';
 498
 499   my $oldAutoCommit = $FS::UID::AutoCommit;
 500   local $FS::UID::AutoCommit = 0;
 501   my $dbh = dbh;
 502   my $error = '';
 503
 504   # prevent this from failing because of pkg_svc quantity limits
 505   local( $FS::cust_svc::ignore_quantity ) = 1;
 506
 507   if ( !$new->locationnum ) {
 508     $error = $new->insert;
 509     if ( $error ) {
 510       $dbh->rollback if $oldAutoCommit;
 511       return "Error creating location: $error";
 512     }
 513   } elsif ( $new->locationnum == $old->locationnum ) {
 514     # then they're the same location; the normal result of doing a minor
 515     # location edit
 516     $dbh->commit if $oldAutoCommit;
 517     return '';
 518   }
 519
 520   # find all packages that have the old location as their service address,
 521   # and aren't canceled,
 522   # and aren't supplemental to another package.
 523   my @pkgs = qsearch('cust_pkg', {
 524       'locationnum' => $old->locationnum,
 525       'cancel'      => '',
 526       'main_pkgnum' => '',
 527     });
 528   foreach my $cust_pkg (@pkgs) {
 529     # don't move one-time charges that have already been charged
 530     next if $cust_pkg->part_pkg->freq eq '0'
 531             and ($cust_pkg->setup || 0) > 0;
 532
 533     $error = $cust_pkg->change(
 534       'locationnum' => $new->locationnum,
 535       'keep_dates'  => 1
 536     );
 537     if ( $error and not ref($error) ) {
 538       $dbh->rollback if $oldAutoCommit;
 539       return "Error moving pkgnum ".$cust_pkg->pkgnum.": $error";
 540     }
 541   }
 542
 543   $error = $old->disable_if_unused;
 544   if ( $error ) {
 545     $dbh->rollback if $oldAutoCommit;
 546     return "Error disabling old location: $error";
 547   }
 548
 549   $dbh->commit if $oldAutoCommit;
 550   '';
 551 }
 552
 553 =item alternize
 554
 555 Attempts to parse data for location_type and location_number from address1
 556 and address2.
 557
 558 =cut
 559
 560 sub alternize {
 561   my $self = shift;
 562
 563   return '' if $self->get('location_type')
 564             || $self->get('location_number');
 565
 566   my %parse;
 567   if ( 1 ) { #ikano, switch on via config
 568     { no warnings 'void';
 569       eval { 'use FS::part_export::ikano;' };
 570       die $@ if $@;
 571     }
 572     %parse = FS::part_export::ikano->location_types_parse;
 573   } else {
 574     %parse = (); #?
 575   }
 576
 577   foreach my $from ('address1', 'address2') {
 578     foreach my $parse ( keys %parse ) {
 579       my $value = $self->get($from);
 580       if ( $value =~ s/(^|\W+)$parse\W+(\w+)\W*$//i ) {
 581         $self->set('location_type', $parse{$parse});
 582         $self->set('location_number', $2);
 583         $self->set($from, $value);
 584         return '';
 585       }
 586     }
 587   }
 588
 589   #nothing matched, no changes
 590   $self->get('address2')
 591     ? "Can't parse unit type and number from address2"
 592     : '';
 593 }
 594
 595 =item dealternize
 596
 597 Moves data from location_type and location_number to the end of address1.
 598
 599 =cut
 600
 601 sub dealternize {
 602   my $self = shift;
 603
 604   #false laziness w/geocode_Mixin.pm::line
 605   my $lt = $self->get('location_type');
 606   if ( $lt ) {
 607
 608     my %location_type;
 609     if ( 1 ) { #ikano, switch on via config
 610       { no warnings 'void';
 611         eval { 'use FS::part_export::ikano;' };
 612         die $@ if $@;
 613       }
 614       %location_type = FS::part_export::ikano->location_types;
 615     } else {
 616       %location_type = (); #?
 617     }
 618
 619     $self->address1( $self->address1. ' '. $location_type{$lt} || $lt );
 620     $self->location_type('');
 621   }
 622
 623   if ( length($self->location_number) ) {
 624     $self->address1( $self->address1. ' '. $self->location_number );
 625     $self->location_number('');
 626   }
 627
 628   '';
 629 }
 630
 631 =item location_label
 632
 633 Returns the label of the location object.
 634
 635 Options:
 636
 637 =over 4
 638
 639 =item cust_main
 640
 641 Customer object (see L<FS::cust_main>)
 642
 643 =item prospect_main
 644
 645 Prospect object (see L<FS::prospect_main>)
 646
 647 =item join_string
 648
 649 String used to join location elements
 650
 651 =item no_prefix
 652
 653 Don't label the default service location as "Default service location".
 654 May become the default at some point.
 655
 656 =back
 657
 658 =cut
 659
 660 sub location_label {
 661   my( $self, %opt ) = @_;
 662
 663   my $prefix = $self->label_prefix;
 664   $prefix .= ($opt{join_string} ||  ': ') if $prefix;
 665   $prefix = '' if $opt{'no_prefix'};
 666
 667   $prefix . $self->SUPER::location_label(%opt);
 668 }
 669
 670 =item label_prefix
 671
 672 Returns the optional site ID string (based on the cust_location-label_prefix
 673 config option), "Default service location", or the empty string.
 674
 675 Options:
 676
 677 =over 4
 678
 679 =item cust_main
 680
 681 Customer object (see L<FS::cust_main>)
 682
 683 =item prospect_main
 684
 685 Prospect object (see L<FS::prospect_main>)
 686
 687 =back
 688
 689 =cut
 690
 691 sub label_prefix {
 692   my( $self, %opt ) = @_;
 693
 694   my $cust_or_prospect = $opt{cust_main} || $opt{prospect_main};
 695   unless ( $cust_or_prospect ) {
 696     if ( $self->custnum ) {
 697       $cust_or_prospect = FS::cust_main->by_key($self->custnum);
 698     } elsif ( $self->prospectnum ) {
 699       $cust_or_prospect = FS::prospect_main->by_key($self->prospectnum);
 700     }
 701   }
 702
 703   my $prefix = '';
 704   if ( $label_prefix eq 'CoStAg' ) {
 705     my $agent = $conf->config('cust_main-custnum-display_prefix',
 706                   $cust_or_prospect->agentnum)
 707                 || $cust_or_prospect->agent->agent;
 708     # else this location is invalid
 709     $prefix = uc( join('',
 710         $self->country,
 711         ($self->state =~ /^(..)/),
 712         ($agent =~ /^(..)/),
 713         sprintf('%05d', $self->locationnum)
 714     ) );
 715
 716   } elsif ( $label_prefix eq '_location' && $self->locationname ) {
 717     $prefix = $self->locationname;
 718
 719   } elsif (    ( $opt{'cust_main'} || $self->custnum )
 720           && $self->locationnum == $cust_or_prospect->ship_locationnum ) {
 721     $prefix = 'Default service location';
 722   }
 723
 724   $prefix;
 725 }
 726
 727 =item county_state_country
 728
 729 Returns a string consisting of just the county, state and country.
 730
 731 =cut
 732
 733 sub county_state_country {
 734   my $self = shift;
 735   my $label = $self->country;
 736   $label = $self->state.", $label" if $self->state;
 737   $label = $self->county." County, $label" if $self->county;
 738   $label;
 739 }
 740
 741 =item cust_main
 742
 743 =cut
 744
 745 sub cust_main {
 746   my $self = shift;
 747   return '' unless $self->custnum;
 748   qsearchs('cust_main', { 'custnum' => $self->custnum } );
 749 }
 750
 751 =back
 752
 753 =head2 SUBROUTINES
 754
 755 =over 4
 756
 757 =item process_censustract_update LOCATIONNUM
 758
 759 Queueable function to update the census tract to the current year (as set in
 760 the 'census_year' configuration variable) and retrieve the new tract code.
 761
 762 =cut
 763
 764 sub process_censustract_update {
 765   eval "use FS::GeocodeCache";
 766   die $@ if $@;
 767   my $locationnum = shift;
 768   my $cust_location =
 769     qsearchs( 'cust_location', { locationnum => $locationnum })
 770       or die "locationnum '$locationnum' not found!\n";
 771
 772   my $new_year = $conf->config('census_year') or return;
 773   my $loc = FS::GeocodeCache->new( $cust_location->location_hash );
 774   $loc->set_censustract;
 775   my $error = $loc->get('censustract_error');
 776   die $error if $error;
 777   $cust_location->set('censustract', $loc->get('censustract'));
 778   $cust_location->set('censusyear',  $new_year);
 779   $error = $cust_location->replace;
 780   die $error if $error;
 781   return;
 782 }
 783
 784 =item process_set_coord
 785
 786 Queueable function to find and fill in coordinates for all locations that
 787 lack them.  Because this uses the Google Maps API, it's internally rate
 788 limited and must run in a single process.
 789
 790 =cut
 791
 792 sub process_set_coord {
 793   my $job = shift;
 794   # avoid starting multiple instances of this job
 795   my @others = qsearch('queue', {
 796       'status'  => 'locked',
 797       'job'     => $job->job,
 798       'jobnum'  => {op=>'!=', value=>$job->jobnum},
 799   });
 800   return if @others;
 801
 802   $job->update_statustext('finding locations to update');
 803   my @missing_coords = qsearch('cust_location', {
 804       'disabled'  => '',
 805       'latitude'  => '',
 806       'longitude' => '',
 807   });
 808   my $i = 0;
 809   my $n = scalar @missing_coords;
 810   for my $cust_location (@missing_coords) {
 811     $cust_location->set_coord;
 812     my $error = $cust_location->replace;
 813     if ( $error ) {
 814       warn "error geocoding location#".$cust_location->locationnum.": $error\n";
 815     } else {
 816       $i++;
 817       $job->update_statustext("updated $i / $n locations");
 818       dbh->commit; # so that we don't have to wait for the whole thing to finish
 819       # Rate-limit to stay under the Google Maps usage limit (2500/day).
 820       # 86,400 / 35 = 2,468 lookups per day.
 821     }
 822     sleep 35;
 823   }
 824   if ( $i < $n ) {
 825     die "failed to update ".$n-$i." locations\n";
 826   }
 827   return;
 828 }
 829
 830 =item process_standardize [ LOCATIONNUMS ]
 831
 832 Performs address standardization on locations with unclean addresses,
 833 using whatever method you have configured.  If the standardize_* method
 834 returns a I<clean> address match, the location will be updated.  This is
 835 always an in-place update (because the physical location is the same,
 836 and is just being referred to by a more accurate name).
 837
 838 Disabled locations will be skipped, as nobody cares.
 839
 840 If any LOCATIONNUMS are provided, only those locations will be updated.
 841
 842 =cut
 843
 844 sub process_standardize {
 845   my $job = shift;
 846   my @others = qsearch('queue', {
 847       'status'  => 'locked',
 848       'job'     => $job->job,
 849       'jobnum'  => {op=>'!=', value=>$job->jobnum},
 850   });
 851   return if @others;
 852   my @locationnums = grep /^\d+$/, @_;
 853   my $where = "AND locationnum IN(".join(',',@locationnums).")"
 854     if scalar(@locationnums);
 855   my @locations = qsearch({
 856       table     => 'cust_location',
 857       hashref   => { addr_clean => '', disabled => '' },
 858       extra_sql => $where,
 859   });
 860   my $n_todo = scalar(@locations);
 861   my $n_done = 0;
 862
 863   # special: log this
 864   my $log;
 865   eval "use Text::CSV";
 866   open $log, '>', "$FS::UID::cache_dir/process_standardize-" .
 867                   time2str('%Y%m%d',time) .
 868                   ".csv";
 869   my $csv = Text::CSV->new({binary => 1, eol => "\n"});
 870
 871   foreach my $cust_location (@locations) {
 872     $job->update_statustext( int(100 * $n_done/$n_todo) . ",$n_done / $n_todo locations" ) if $job;
 873     my $result = FS::GeocodeCache->standardize($cust_location);
 874     if ( $result->{addr_clean} and !$result->{error} ) {
 875       my @cols = ($cust_location->locationnum);
 876       foreach (keys %$result) {
 877         push @cols, $cust_location->get($_), $result->{$_};
 878         $cust_location->set($_, $result->{$_});
 879       }
 880       # bypass immutable field restrictions
 881       my $error = $cust_location->FS::Record::replace;
 882       warn "location ".$cust_location->locationnum.": $error\n" if $error;
 883       $csv->print($log, \@cols);
 884     }
 885     $n_done++;
 886     dbh->commit; # so that we can resume if interrupted
 887   }
 888   close $log;
 889 }
 890
 891 =head1 BUGS
 892
 893 =head1 SEE ALSO
 894
 895 L<FS::cust_main_county>, L<FS::cust_pkg>, L<FS::Record>,
 896 schema.html from the base documentation.
 897
 898 =cut
 899
 900 1;
 901