FS/FS/part_export/saisei.pm

   1 package FS::part_export::saisei;
   2
   3 use strict;
   4 use vars qw( @ISA %info );
   5 use base qw( FS::part_export );
   6 use Date::Format 'time2str';
   7 use Cpanel::JSON::XS;
   8 use Storable qw(thaw);
   9 use MIME::Base64;
  10 use REST::Client;
  11 use Data::Dumper;
  12 use FS::Conf;
  13
  14 =pod
  15
  16 =head1 NAME
  17
  18 FS::part_export::saisei
  19
  20 =head1 SYNOPSIS
  21
  22 Saisei integration for Freeside
  23
  24 =head1 DESCRIPTION
  25
  26 This export offers basic svc_broadband provisioning for Saisei.
  27
  28 This is a customer integration with Saisei.  This will set up a rate plan and tie
  29 the rate plan to a host and the access point via the Saisei API when the broadband service is provisioned.
  30 It will also untie the host from the rate plan, setting it to the default rate plan via the API upon unprovisioning of the broadband service.
  31
  32 This will create and modify the rate plans at Saisei as soon as the broadband service attached to this export is created or modified.
  33 This will also create and modify an access point at Saisei as soon as the tower is created or modified.
  34
  35 To use this export, follow the below instructions:
  36
  37 Create a new service definition and set the table to svc_broadband.  The service name will become the Saisei rate plan name.
  38 Set the upload and download speed for the service. This is required to be able to export the service to Saisei.
  39 Attach this Saisei export to this service.
  40
  41 Create a tower and add a sector to that tower.  The sector name will be the name of the access point,
  42 Make sure you have set the up and down rate limit for the tower and the sector.  This is required to be able to export the access point.
  43 The tower and sector will be set up as access points at Saisei upon the creation of the tower or sector.  They will be modified at Saisei when modified in freeside.
  44 Each sector will be attached to its tower access point using the Saisei uplink field.
  45
  46 Create a package for the above created service, and order this package for a customer.
  47
  48 Provision the service, making sure to enter the IP address associated with this service and select the tower and sector for it's access point.
  49 This provisioned service will then be exported as a host to Saisei.
  50
  51 Unprovisioning this service will set the host entry at Saisei to the default rate plan with the user and access point set to <none>.
  52
  53 After this export is set up and attached to a service, you can export the already provisioned services by clicking the link Export provisioned services attached to this export.
  54 Clicking on this link will export all services attached to this export not currently exported to Saisei.
  55
  56 This module also provides generic methods for working through the L</Saisei API>.
  57
  58 =cut
  59
  60 tie my %scripts, 'Tie::IxHash',
  61   'export_provisioned_services'  => { component => '/elements/popup_link.html',
  62                                       label     => 'Export provisioned services',
  63                                       description => 'will export provisioned services of part service with Saisei export attached.',
  64                                       html_label => '<b>Export provisioned services attached to this export.</b>',
  65                                     },
  66 ;
  67
  68 tie my %options, 'Tie::IxHash',
  69   'port'             => { label => 'Port',
  70                           default => 5000 },
  71   'username'         => { label => 'Saisei API User Name',
  72                           default => '' },
  73   'password'         => { label => 'Saisei API Password',
  74                           default => '' },
  75   'debug'            => { type => 'checkbox',
  76                           label => 'Enable debug warnings' },
  77 ;
  78
  79 %info = (
  80   'svc'             => 'svc_broadband',
  81   'desc'            => 'Export broadband service/account to Saisei',
  82   'options'         => \%options,
  83   'scripts'         => \%scripts,
  84   'notes'           => <<'END',
  85 This is a customer integration with Saisei.  This will set up a rate plan and tie
  86 the rate plan to a host and the access point via the Saisei API when the broadband service is provisioned.
  87 It will also untie the host from the rate plan, setting it to the default rate plan via the API upon unprovisioning of the broadband service.
  88 <P>
  89 This will create and modify the rate plans at Saisei as soon as the broadband service attached to this export is created or modified.
  90 This will also create and modify an access point at Saisei as soon as the tower is created or modified.
  91 <P>
  92 To use this export, follow the below instructions:
  93 <P>
  94 <OL>
  95 <LI>
  96 Create a new service definition and set the table to svc_broadband.  The service name will become the Saisei rate plan name.
  97 Set the upload and download speed for the service. This is required to be able to export the service to Saisei.
  98 Attach this Saisei export to this service.
  99 </LI>
 100 <P>
 101 <LI>
 102 Create a tower and add a sector to that tower.  The sector name will be the name of the access point,
 103 Make sure you have set the up and down rate limit for the tower and the sector.  This is required to be able to export the access point.
 104 The tower and sector will be set up as access points at Saisei upon the creation of the tower or sector.  They will be modified at Saisei when modified in freeside.
 105 Each sector will be attached to its tower access point using the Saisei uplink field.
 106 </LI>
 107 <P>
 108 <LI>
 109 Create a package for the above created service, and order this package for a customer.
 110 </LI>
 111 <P>
 112 <LI>
 113 Provision the service, making sure to enter the IP address associated with this service and select the tower and sector for it's access point.
 114 This provisioned service will then be exported as a host to Saisei.
 115 <P>
 116 Unprovisioning this service will set the host entry at Saisei to the default rate plan with the user and access point set to <i>none</i>.
 117 </LI>
 118 <P>
 119 <LI>
 120 After this export is set up and attached to a service, you can export the already provisioned services by clicking the link <b>Export provisioned services attached to this export</b>.
 121 Clicking on this link will export all services attached to this export not currently exported to Saisei.
 122 </LI>
 123 </OL>
 124 <P>
 125
 126 END
 127 );
 128
 129 sub _export_insert {
 130   my ($self, $svc_broadband) = @_;
 131
 132   my $rateplan_name = $self->get_rateplan_name($svc_broadband);
 133
 134   # check for existing rate plan
 135   my $existing_rateplan;
 136   $existing_rateplan = $self->api_get_rateplan($rateplan_name) unless $self->{'__saisei_error'};
 137
 138   # if no existing rate plan create one and modify it.
 139   $self->api_create_rateplan($svc_broadband, $rateplan_name) unless $existing_rateplan;
 140   $self->api_modify_rateplan($svc_broadband, $rateplan_name) unless ($self->{'__saisei_error'} || $existing_rateplan);
 141   return $self->api_error if $self->{'__saisei_error'};
 142
 143   # set rateplan to existing one or newly created one.
 144   my $rateplan = $existing_rateplan ? $existing_rateplan : $self->api_get_rateplan($rateplan_name);
 145
 146   my $username = $svc_broadband->{Hash}->{svcnum};
 147   my $description = $svc_broadband->{Hash}->{description};
 148
 149   if (!$username) {
 150     $self->{'__saisei_error'} = 'no username - can not export';
 151     return $self->api_error;
 152   }
 153   else {
 154     # check for existing user.
 155     my $existing_user;
 156     $existing_user = $self->api_get_user($username) unless $self->{'__saisei_error'};
 157
 158     # if no existing user create one.
 159     $self->api_create_user($username, $description) unless $existing_user;
 160     return $self->api_error if $self->{'__saisei_error'};
 161
 162     # set user to existing one or newly created one.
 163     my $user = $existing_user ? $existing_user : $self->api_get_user($username);
 164
 165     ## add access point
 166     my $tower_sector = FS::Record::qsearchs({
 167       'table'     => 'tower_sector',
 168       'select'    => 'tower.towername,
 169                       tower.up_rate_limit as tower_upratelimit,
 170                       tower.down_rate_limit as tower_downratelimit,
 171                       tower_sector.sectorname,
 172                       tower_sector.up_rate_limit as sector_upratelimit,
 173                       tower_sector.down_rate_limit as sector_downratelimit ',
 174       'addl_from' => 'LEFT JOIN tower USING ( towernum )',
 175       'hashref'   => {
 176                         'sectornum' => $svc_broadband->{Hash}->{sectornum},
 177                      },
 178     });
 179
 180     my $tower_name = $tower_sector->{Hash}->{towername};
 181     $tower_name =~ s/\s/_/g;
 182
 183     my $tower_opt = {
 184       'tower_name'           => $tower_name,
 185       'tower_uprate_limit'   => $tower_sector->{Hash}->{tower_upratelimit},
 186       'tower_downrate_limit' => $tower_sector->{Hash}->{tower_downratelimit},
 187     };
 188
 189     my $tower_ap = process_tower($self, $tower_opt);
 190     return $self->api_error if $self->{'__saisei_error'};
 191
 192     my $sector_name = $tower_sector->{Hash}->{sectorname};
 193     $sector_name =~ s/\s/_/g;
 194
 195     my $sector_opt = {
 196       'tower_name'            => $tower_name,
 197       'sector_name'           => $sector_name,
 198       'sector_uprate_limit'   => $tower_sector->{Hash}->{sector_upratelimit},
 199       'sector_downrate_limit' => $tower_sector->{Hash}->{sector_downratelimit},
 200     };
 201     my $accesspoint = process_sector($self, $sector_opt);
 202     return $self->api_error if $self->{'__saisei_error'};
 203
 204 ## get custnum and pkgpart from cust_pkg for virtual access point
 205     my $cust_pkg = FS::Record::qsearchs({
 206       'table'     => 'cust_pkg',
 207       'hashref'   => { 'pkgnum' => $svc_broadband->{Hash}->{pkgnum}, },
 208     });
 209     my $virtual_ap_name = $cust_pkg->{Hash}->{custnum}.'_'.$cust_pkg->{Hash}->{pkgpart}.'_'.$svc_broadband->{Hash}->{speed_down}.'_'.$svc_broadband->{Hash}->{speed_up};
 210
 211     my $virtual_ap_opt = {
 212       'virtual_name'           => $virtual_ap_name,
 213       'sector_name'            => $sector_name,
 214       'virtual_uprate_limit'   => $svc_broadband->{Hash}->{speed_up},
 215       'virtual_downrate_limit' => $svc_broadband->{Hash}->{speed_down},
 216     };
 217     my $virtual_ap = process_virtual_ap($self, $virtual_ap_opt);
 218     return $self->api_error if $self->{'__saisei_error'};
 219
 220     ## tie host to user add sector name as access point.
 221     $self->api_add_host_to_user(
 222       $user->{collection}->[0]->{name},
 223       $rateplan->{collection}->[0]->{name},
 224       $svc_broadband->{Hash}->{ip_addr},
 225       $virtual_ap->{collection}->[0]->{name},
 226     ) unless $self->{'__saisei_error'};
 227   }
 228
 229   return $self->api_error;
 230
 231 }
 232
 233 sub _export_replace {
 234   my ($self, $svc_broadband) = @_;
 235   my $error = $self->_export_insert($svc_broadband);
 236   return $error;
 237 }
 238
 239 sub _export_delete {
 240   my ($self, $svc_broadband) = @_;
 241
 242   my $rateplan_name = $self->get_rateplan_name($svc_broadband);
 243
 244   my $username = $svc_broadband->{Hash}->{svcnum};
 245
 246   ## untie host to user
 247   $self->api_delete_host_to_user($username, $rateplan_name, $svc_broadband->{Hash}->{ip_addr}) unless $self->{'__saisei_error'};
 248
 249   return '';
 250 }
 251
 252 sub _export_suspend {
 253   my ($self, $svc_broadband) = @_;
 254   return '';
 255 }
 256
 257 sub _export_unsuspend {
 258   my ($self, $svc_broadband) = @_;
 259   return '';
 260 }
 261
 262 sub export_partsvc {
 263   my ($self, $svc_part) = @_;
 264
 265   my $fcc_477_speeds;
 266   if ($svc_part->{Hash}->{svc_broadband__speed_down} eq "down" || $svc_part->{Hash}->{svc_broadband__speed_up} eq "up") {
 267     for my $type (qw( down up )) {
 268       my $speed_type = "broadband_".$type."stream";
 269       foreach my $pkg_svc (FS::Record::qsearch({
 270         'table'     => 'pkg_svc',
 271         'select'    => 'pkg_svc.*, part_pkg_fcc_option.fccoptionname, part_pkg_fcc_option.optionvalue',
 272         'addl_from' => ' LEFT JOIN part_pkg_fcc_option USING (pkgpart) ',
 273         'extra_sql' => " WHERE pkg_svc.svcpart = ".$svc_part->{Hash}->{svcpart}." AND pkg_svc.quantity > 0 AND part_pkg_fcc_option.fccoptionname = '".$speed_type."'",
 274       })) { $fcc_477_speeds->{
 275         $pkg_svc->{Hash}->{pkgpart}}->{$speed_type} = $pkg_svc->{Hash}->{optionvalue} * 1000 unless !$pkg_svc->{Hash}->{optionvalue}; }
 276     }
 277   }
 278   else {
 279     $fcc_477_speeds->{1}->{broadband_downstream} = $svc_part->{Hash}->{"svc_broadband__speed_down"};
 280     $fcc_477_speeds->{1}->{broadband_upstream} = $svc_part->{Hash}->{"svc_broadband__speed_up"};
 281   }
 282
 283   foreach my $key (keys %$fcc_477_speeds) {
 284
 285     $svc_part->{Hash}->{speed_down} = $fcc_477_speeds->{$key}->{broadband_downstream};
 286     $svc_part->{Hash}->{speed_up} = $fcc_477_speeds->{$key}->{broadband_upstream};
 287     $svc_part->{Hash}->{svc_broadband__speed_down} = $fcc_477_speeds->{$key}->{broadband_downstream};
 288     $svc_part->{Hash}->{svc_broadband__speed_up} = $fcc_477_speeds->{$key}->{broadband_upstream};
 289
 290     my $temp_svc = $svc_part->{Hash};
 291     my $svc_broadband = {};
 292     map { if ($_ =~ /^svc_broadband__(.*)$/) { $svc_broadband->{Hash}->{$1} = $temp_svc->{$_}; }  } keys %$temp_svc;
 293
 294     my $rateplan_name = $self->get_rateplan_name($svc_broadband, $svc_part->{Hash}->{svc});
 295
 296     # check for existing rate plan
 297     my $existing_rateplan;
 298     $existing_rateplan = $self->api_get_rateplan($rateplan_name) unless $self->{'__saisei_error'};
 299
 300     # Modify the existing rate plan with new service data.
 301     $self->api_modify_existing_rateplan($svc_broadband, $rateplan_name) unless ($self->{'__saisei_error'} || !$existing_rateplan);
 302
 303     # if no existing rate plan create one and modify it.
 304     $self->api_create_rateplan($svc_broadband, $rateplan_name) unless $existing_rateplan;
 305     $self->api_modify_rateplan($svc_part, $rateplan_name) unless ($self->{'__saisei_error'} || $existing_rateplan);
 306
 307   }
 308
 309   return $self->api_error;
 310
 311 }
 312
 313 sub export_tower_sector {
 314   my ($self, $tower) = @_;
 315
 316   #modify tower or create it.
 317   my $tower_name = $tower->{Hash}->{towername};
 318   $tower_name =~ s/\s/_/g;
 319   my $tower_opt = {
 320     'tower_name'           => $tower_name,
 321     'tower_uprate_limit'   => $tower->{Hash}->{up_rate_limit},
 322     'tower_downrate_limit' => $tower->{Hash}->{down_rate_limit},
 323     'modify_existing'      => '1', # modify an existing access point with this info
 324   };
 325
 326   my $tower_access_point = process_tower($self, $tower_opt);
 327     return $tower_access_point if $tower_access_point->{error};
 328
 329   #get list of all access points
 330   my $hash_opt = {
 331       'table'     => 'tower_sector',
 332       'select'    => '*',
 333       'hashref'   => { 'towernum' => $tower->{Hash}->{towernum}, },
 334   };
 335
 336   #for each one modify or create it.
 337   foreach my $tower_sector ( FS::Record::qsearch($hash_opt) ) {
 338     my $sector_name = $tower_sector->{Hash}->{sectorname};
 339     $sector_name =~ s/\s/_/g;
 340     my $sector_opt = {
 341       'tower_name'            => $tower_name,
 342       'sector_name'           => $sector_name,
 343       'sector_uprate_limit'   => $tower_sector->{Hash}->{up_rate_limit},
 344       'sector_downrate_limit' => $tower_sector->{Hash}->{down_rate_limit},
 345       'modify_existing'       => '1', # modify an existing access point with this info
 346     };
 347     my $sector_access_point = process_sector($self, $sector_opt) unless ($sector_name eq "_default");
 348       return $sector_access_point if $sector_access_point->{error};
 349   }
 350
 351   return { error => $self->api_error, };
 352 }
 353
 354 ## creates the rateplan name
 355 sub get_rateplan_name {
 356   my ($self, $svc_broadband, $svc_name) = @_;
 357
 358   my $service_part = FS::Record::qsearchs( 'part_svc', { 'svcpart' => $svc_broadband->{Hash}->{svcpart} } ) unless $svc_name;
 359   my $service_name = $svc_name ? $svc_name : $service_part->{Hash}->{svc};
 360
 361   my $rateplan_name = $service_name . " " . $svc_broadband->{Hash}->{speed_down} . "-" . $svc_broadband->{Hash}->{speed_up};
 362   $rateplan_name =~ s/\s/_/g;
 363
 364   return $rateplan_name;
 365 }
 366
 367 =head1 Saisei API
 368
 369 These methods allow access to the Saisei API using the credentials
 370 set in the export options.
 371
 372 =cut
 373
 374 =head2 api_call
 375
 376 Accepts I<$method>, I<$path>, I<$params> hashref and optional.
 377 Places an api call to the specified path and method with the specified params.
 378 Returns the decoded json object returned by the api call.
 379 Returns empty on failure;  retrieve error messages using L</api_error>.
 380
 381 =cut
 382
 383 sub api_call {
 384   my ($self,$method,$path,$params) = @_;
 385
 386   $self->{'__saisei_error'} = '';
 387   my $auth_info = $self->option('username') . ':' . $self->option('password');
 388   $params ||= {};
 389
 390   warn "Calling $method on http://"
 391     .$self->{Hash}->{machine}.':'.$self->option('port')
 392     ."/rest/top/configurations/running/$path\n" if $self->option('debug');
 393
 394   my $data = encode_json($params) if keys %{ $params };
 395
 396   my $client = REST::Client->new();
 397   $client->addHeader("Authorization", "Basic ".encode_base64($auth_info));
 398   $client->setHost('http://'.$self->{Hash}->{machine}.':'.$self->option('port'));
 399   $client->$method('/rest/top/configurations/running'.$path, $data, { "Content-type" => 'application/json'});
 400
 401   warn "Response Code is ".$client->responseCode()."\n" if $self->option('debug');
 402
 403   my $result;
 404
 405   if ($client->responseCode() eq '200' || $client->responseCode() eq '201') {
 406     eval { $result = decode_json($client->responseContent()) };
 407     unless ($result) {
 408       $self->{'__saisei_error'} = "Error decoding json: $@";
 409       return;
 410     }
 411   }
 412   elsif ($client->responseCode() eq '404') {
 413     eval { $result = decode_json($client->responseContent()) };
 414     unless ($result) {
 415       $self->{'__saisei_error'} = "Error decoding json: $@";
 416       return;
 417     }
 418     ## check if message is for empty hash.
 419     my($does_not_exist) = $result->{message} =~ /'(.*)' does not exist$/;
 420     $self->{'__saisei_error'} = "Error ".$result->{message} unless $does_not_exist;
 421     warn "Response Content is\n".$client->responseContent."\n" if ($self->option('debug') && !$does_not_exist);
 422     return;
 423   }
 424   elsif ($client->responseCode() eq '500') {
 425     $self->{'__saisei_error'} = "Can't connect to host during $method , received responce code: " . $client->responseCode() . " and message: " . $client->responseContent();
 426     warn "Response Content is\n".$client->responseContent."\n" if $self->option('debug');
 427     return;
 428   }
 429   else {
 430     $self->{'__saisei_error'} = "Bad response from server during $method , received responce code: " . $client->responseCode() . " and message: " . $client->responseContent();
 431     warn "Response Content is\n".$client->responseContent."\n" if $self->option('debug');
 432     return;
 433   }
 434
 435   return $result;
 436
 437 }
 438
 439 =head2 api_error
 440
 441 Returns the error string set by L</Saisei API> methods,
 442 or a blank string if most recent call produced no errors.
 443
 444 =cut
 445
 446 sub api_error {
 447   my $self = shift;
 448   return $self->{'__saisei_error'} || '';
 449 }
 450
 451 =head2 api_get_policies
 452
 453 Gets a list of global policies.
 454
 455 =cut
 456
 457 sub api_get_policies {
 458   my $self = shift;
 459
 460   my $get_policies = $self->api_call("GET", '/policies/?token=1&order=name&start=0&limit=20&select=name%2Cpercent_rate%2Cassured%2C');
 461   return if $self->api_error;
 462   $self->{'__saisei_error'} = "Did not receive any global policies"
 463     unless $get_policies;
 464
 465   return $get_policies->{collection};
 466 }
 467
 468 =head2 api_get_rateplan
 469
 470 Gets rateplan info for specific rateplan.
 471
 472 =cut
 473
 474 sub api_get_rateplan {
 475   my $self = shift;
 476   my $rateplan = shift;
 477
 478   my $get_rateplan = $self->api_call("GET", "/rate_plans/$rateplan");
 479   return if $self->api_error;
 480
 481   return $get_rateplan;
 482 }
 483
 484 =head2 api_get_user
 485
 486 Gets user info for specific user.
 487
 488 =cut
 489
 490 sub api_get_user {
 491   my $self = shift;
 492   my $user = shift;
 493
 494   my $get_user = $self->api_call("GET", "/users/$user");
 495   return if $self->api_error;
 496
 497   return $get_user;
 498 }
 499
 500 =head2 api_get_accesspoint
 501
 502 Gets user info for specific access point.
 503
 504 =cut
 505
 506 sub api_get_accesspoint {
 507   my $self = shift;
 508   my $accesspoint = shift;
 509
 510   my $get_accesspoint = $self->api_call("GET", "/access_points/$accesspoint");
 511   return if $self->api_error;
 512
 513   return $get_accesspoint;
 514 }
 515
 516 =head2 api_get_host
 517
 518 Gets user info for specific host.
 519
 520 =cut
 521
 522 sub api_get_host {
 523   my $self = shift;
 524   my $ip = shift;
 525
 526   my $get_host = $self->api_call("GET", "/hosts/$ip");
 527
 528   return { message => $self->api_error, } if $self->api_error;
 529
 530   return $get_host;
 531 }
 532
 533 =head2 api_create_rateplan
 534
 535 Creates a rateplan.
 536
 537 =cut
 538
 539 sub api_create_rateplan {
 540   my ($self, $svc, $rateplan) = @_;
 541
 542   $self->{'__saisei_error'} = "No downrate listed for service $rateplan" if !$svc->{Hash}->{speed_down};
 543   $self->{'__saisei_error'} = "No uprate listed for service $rateplan" if !$svc->{Hash}->{speed_up};
 544
 545   my $new_rateplan = $self->api_call(
 546       "PUT",
 547       "/rate_plans/$rateplan",
 548       {
 549         'downstream_rate' => $svc->{Hash}->{speed_down},
 550         'upstream_rate' => $svc->{Hash}->{speed_up},
 551       },
 552   ) unless $self->{'__saisei_error'};
 553
 554   $self->{'__saisei_error'} = "Rate Plan not created"
 555     unless ($new_rateplan || $self->{'__saisei_error'});
 556
 557   return $new_rateplan;
 558
 559 }
 560
 561 =head2 api_modify_rateplan
 562
 563 Modify a new rateplan.
 564
 565 =cut
 566
 567 sub api_modify_rateplan {
 568   my ($self,$svc,$rateplan_name) = @_;
 569
 570   # get policy list
 571   my $policies = $self->api_get_policies();
 572
 573   foreach my $policy (@$policies) {
 574     my $policyname = $policy->{name};
 575     my $rate_multiplier = '';
 576     if ($policy->{background}) { $rate_multiplier = ".01"; }
 577     my $modified_rateplan = $self->api_call(
 578       "PUT",
 579       "/rate_plans/$rateplan_name/partitions/$policyname",
 580       {
 581         'restricted'      =>  $policy->{assured},         # policy_assured_flag
 582         'rate_multiplier' => $rate_multiplier,           # policy_background 0.1
 583         'rate'            =>  $policy->{percent_rate}, # policy_percent_rate
 584       },
 585     );
 586
 587     $self->{'__saisei_error'} = "Rate Plan not modified after create"
 588       unless ($modified_rateplan || $self->{'__saisei_error'}); # should never happen
 589
 590   }
 591
 592   return;
 593
 594 }
 595
 596 =head2 api_modify_existing_rateplan
 597
 598 Modify a existing rateplan.
 599
 600 =cut
 601
 602 sub api_modify_existing_rateplan {
 603   my ($self,$svc,$rateplan_name) = @_;
 604
 605   my $modified_rateplan = $self->api_call(
 606     "PUT",
 607     "/rate_plans/$rateplan_name",
 608     {
 609       'downstream_rate' => $svc->{Hash}->{speed_down},
 610       'upstream_rate' => $svc->{Hash}->{speed_up},
 611     },
 612   );
 613
 614     $self->{'__saisei_error'} = "Rate Plan not modified"
 615       unless ($modified_rateplan || $self->{'__saisei_error'}); # should never happen
 616
 617   return;
 618
 619 }
 620
 621 =head2 api_create_user
 622
 623 Creates a user.
 624
 625 =cut
 626
 627 sub api_create_user {
 628   my ($self,$user, $description) = @_;
 629
 630   my $new_user = $self->api_call(
 631       "PUT",
 632       "/users/$user",
 633       {
 634         'description' => $description,
 635       },
 636   );
 637
 638   $self->{'__saisei_error'} = "User not created"
 639     unless ($new_user || $self->{'__saisei_error'}); # should never happen
 640
 641   return $new_user;
 642
 643 }
 644
 645 =head2 api_create_accesspoint
 646
 647 Creates a access point.
 648
 649 =cut
 650
 651 sub api_create_accesspoint {
 652   my ($self,$accesspoint, $upratelimit, $downratelimit) = @_;
 653
 654   my $new_accesspoint = $self->api_call(
 655       "PUT",
 656       "/access_points/$accesspoint",
 657       {
 658          'downstream_rate_limit' => $downratelimit,
 659          'upstream_rate_limit' => $upratelimit,
 660       },
 661   );
 662
 663   $self->{'__saisei_error'} = "Access point not created"
 664     unless ($new_accesspoint || $self->{'__saisei_error'}); # should never happen
 665   return;
 666
 667 }
 668
 669 =head2 api_modify_accesspoint
 670
 671 Modify a new access point.
 672
 673 =cut
 674
 675 sub api_modify_accesspoint {
 676   my ($self, $accesspoint, $uplink) = @_;
 677
 678   my $modified_accesspoint = $self->api_call(
 679     "PUT",
 680     "/access_points/$accesspoint",
 681     {
 682       'uplink' => $uplink, # name of attached access point
 683     },
 684   );
 685
 686   $self->{'__saisei_error'} = "Rate Plan not modified"
 687     unless ($modified_accesspoint || $self->{'__saisei_error'}); # should never happen
 688
 689   return;
 690
 691 }
 692
 693 =head2 api_modify_existing_accesspoint
 694
 695 Modify a existing accesspoint.
 696
 697 =cut
 698
 699 sub api_modify_existing_accesspoint {
 700   my ($self, $accesspoint, $uplink, $upratelimit, $downratelimit) = @_;
 701
 702   my $modified_accesspoint = $self->api_call(
 703     "PUT",
 704     "/access_points/$accesspoint",
 705     {
 706       'downstream_rate_limit' => $downratelimit,
 707       'upstream_rate_limit' => $upratelimit,
 708 #      'uplink' => $uplink, # name of attached access point
 709     },
 710   );
 711
 712     $self->{'__saisei_error'} = "Access point not modified"
 713       unless ($modified_accesspoint || $self->{'__saisei_error'}); # should never happen
 714
 715   return;
 716
 717 }
 718
 719 =head2 api_add_host_to_user
 720
 721 ties host to user, rateplan and default access point.
 722
 723 =cut
 724
 725 sub api_add_host_to_user {
 726   my ($self,$user, $rateplan, $ip, $accesspoint) = @_;
 727
 728   my $new_host = $self->api_call(
 729       "PUT",
 730       "/hosts/$ip",
 731       {
 732         'user'      => $user,
 733         'rate_plan' => $rateplan,
 734         'access_point' => $accesspoint,
 735       },
 736   );
 737
 738   $self->{'__saisei_error'} = "Host not created"
 739     unless ($new_host || $self->{'__saisei_error'}); # should never happen
 740
 741   return $new_host;
 742
 743 }
 744
 745 =head2 api_delete_host_to_user
 746
 747 unties host from user and rateplan.
 748 this will set the host entry at Saisei to the default rate plan with the user and access point set to <none>.
 749
 750 =cut
 751
 752 sub api_delete_host_to_user {
 753   my ($self,$user, $rateplan, $ip) = @_;
 754
 755   my $default_rate_plan = $self->api_call("GET", '?token=1&select=default_rate_plan');
 756     return if $self->api_error;
 757   $self->{'__saisei_error'} = "Did not receive a default rate plan"
 758     unless $default_rate_plan;
 759
 760   my $default_rateplan_name = $default_rate_plan->{collection}->[0]->{default_rate_plan}->{link}->{name};
 761
 762   my $delete_host = $self->api_call(
 763       "PUT",
 764       "/hosts/$ip",
 765       {
 766         'user'          => '<none>',
 767         'access_point'  => '<none>',
 768         'rate_plan'     => $default_rateplan_name,
 769       },
 770   );
 771
 772   $self->{'__saisei_error'} = "Host not created"
 773     unless ($delete_host || $self->{'__saisei_error'}); # should never happen
 774
 775   return $delete_host;
 776
 777 }
 778
 779 sub process_tower {
 780   my ($self, $opt) = @_;
 781
 782   if (!$opt->{tower_uprate_limit} || !$opt->{tower_downrate_limit}) {
 783     $self->{'__saisei_error'} = "Can not export tower, no up or down rates attached to tower";
 784     return { error => $self->api_error, };
 785   }
 786
 787   my $existing_tower_ap;
 788   my $tower_name = $opt->{tower_name};
 789
 790   #check if tower has been set up as an access point.
 791   $existing_tower_ap = $self->api_get_accesspoint($tower_name) unless $self->{'__saisei_error'};
 792
 793   # modify the existing accesspoint if changing tower .
 794   $self->api_modify_existing_accesspoint (
 795     $tower_name,
 796     '', # tower does not have a uplink on sectors.
 797     $opt->{tower_uprate_limit},
 798     $opt->{tower_downrate_limit},
 799   ) if $existing_tower_ap->{collection} && $opt->{modify_existing};
 800
 801   #if tower does not exist as an access point create it.
 802   $self->api_create_accesspoint(
 803       $tower_name,
 804       $opt->{tower_uprate_limit},
 805       $opt->{tower_downrate_limit},
 806   ) unless $existing_tower_ap->{collection};
 807
 808   my $accesspoint = $self->api_get_accesspoint($tower_name);
 809
 810   return { error => $self->api_error, } if $self->api_error;
 811   return $accesspoint;
 812 }
 813
 814 sub process_sector {
 815   my ($self, $opt) = @_;
 816
 817   if (!$opt->{sector_uprate_limit} || !$opt->{sector_downrate_limit}) {
 818     $self->{'__saisei_error'} = "Can not export sector, no up or down rates attached to sector";
 819     return { error => $self->api_error, };
 820   }
 821
 822   my $existing_sector_ap;
 823   my $sector_name = $opt->{sector_name};
 824
 825   #check if sector has been set up as an access point.
 826   $existing_sector_ap = $self->api_get_accesspoint($sector_name);
 827
 828   # modify the existing accesspoint if changing sector .
 829   $self->api_modify_existing_accesspoint (
 830     $sector_name,
 831     $opt->{tower_name},
 832     $opt->{sector_uprate_limit},
 833     $opt->{sector_downrate_limit},
 834   ) if $existing_sector_ap && $opt->{modify_existing};
 835
 836   #if sector does not exist as an access point create it.
 837   $self->api_create_accesspoint(
 838     $sector_name,
 839     $opt->{sector_uprate_limit},
 840     $opt->{sector_downrate_limit},
 841   ) unless $existing_sector_ap;
 842
 843   # Attach newly created sector to it's tower.
 844   $self->api_modify_accesspoint($sector_name, $opt->{tower_name}) unless ($self->{'__saisei_error'} || $existing_sector_ap);
 845
 846   # set access point to existing one or newly created one.
 847   my $accesspoint = $existing_sector_ap ? $existing_sector_ap : $self->api_get_accesspoint($sector_name);
 848
 849   return { error => $self->api_error, } if $self->api_error;
 850   return $accesspoint;
 851 }
 852
 853 sub process_virtual_ap {
 854   my ($self, $opt) = @_;
 855
 856   my $existing_virtual_ap;
 857   my $virtual_name = $opt->{virtual_name};
 858
 859   #check if virtual_ap has been set up as an access point.
 860   $existing_virtual_ap = $self->api_get_accesspoint($virtual_name);
 861
 862   # modify the existing virtual accesspoint if changing it. this should never happen
 863   $self->api_modify_existing_accesspoint (
 864     $virtual_name,
 865     $opt->{sector_name},
 866     $opt->{virtual_uprate_limit},
 867     $opt->{virtual_downrate_limit},
 868   ) if $existing_virtual_ap && $opt->{modify_existing};
 869
 870   #if virtual ap does not exist as an access point create it.
 871   $self->api_create_accesspoint(
 872     $virtual_name,
 873     $opt->{virtual_uprate_limit},
 874     $opt->{virtual_downrate_limit},
 875   ) unless $existing_virtual_ap;
 876
 877   my $update_sector;
 878   if ($existing_virtual_ap && (ref $existing_virtual_ap->{collection}->[0]->{uplink} eq "HASH") && ($existing_virtual_ap->{collection}->[0]->{uplink}->{link}->{name} ne $opt->{sector_name})) {
 879     $update_sector = 1;
 880   }
 881
 882   # Attach newly created virtual ap to tower sector ap or if sector has changed.
 883   $self->api_modify_accesspoint($virtual_name, $opt->{sector_name}) unless ($self->{'__saisei_error'} || ($existing_virtual_ap && !$update_sector));
 884
 885   # set access point to existing one or newly created one.
 886   my $accesspoint = $existing_virtual_ap ? $existing_virtual_ap : $self->api_get_accesspoint($virtual_name);
 887
 888   return $accesspoint;
 889 }
 890
 891 sub export_provisioned_services {
 892   my $job = shift;
 893   my $param = thaw(decode_base64(shift));
 894
 895   my $part_export = FS::Record::qsearchs('part_export', { 'exportnum' => $param->{export_provisioned_services_exportnum}, } )
 896   or die "unknown exportnum $param->{export_provisioned_services_exportnum}";
 897   bless $part_export;
 898
 899   my @svcparts = FS::Record::qsearch({
 900     'table' => 'export_svc',
 901     'addl_from' => 'LEFT JOIN part_svc USING ( svcpart  ) ',
 902     'hashref'   => { 'exportnum' => $param->{export_provisioned_services_exportnum}, },
 903   });
 904   my $part_count = scalar @svcparts;
 905
 906   my $parts = join "', '", map { $_->{Hash}->{svcpart} } @svcparts;
 907
 908   my @svcs = FS::Record::qsearch({
 909     'table' => 'cust_svc',
 910     'addl_from' => 'LEFT JOIN svc_broadband USING ( svcnum  ) ',
 911     'extra_sql' => " WHERE svcpart in ('".$parts."')",
 912   }) unless !$parts;
 913
 914   my $svc_count = scalar @svcs;
 915
 916   my %status = {};
 917   for (my $c=1; $c <=100; $c=$c+1) { $status{int($svc_count * ($c/100))} = $c; }
 918
 919   my $process_count=0;
 920   foreach my $svc (@svcs) {
 921     if ($status{$process_count}) { my $s = $status{$process_count}; $job->update_statustext($s); }
 922     ## check if service exists as host if not export it.
 923     my $host = api_get_host($part_export, $svc->{Hash}->{ip_addr});
 924     die $host->{message} if $host->{message};
 925     warn "Exporting service ".$svc->{Hash}->{ip_addr}."\n" if ($part_export->option('debug'));
 926     my $export_error = _export_insert($part_export,$svc) unless $host->{collection};
 927     die $export_error if $export_error;
 928     $process_count++;
 929   }
 930
 931   return;
 932
 933 }
 934
 935 =head1 SEE ALSO
 936
 937 L<FS::part_export>
 938
 939 =cut
 940
 941 1;