Open-ILS/src/perlmods/OpenILS/Application/Actor.pm

   1 package OpenILS::Application::Actor;
   2 use base qw/OpenSRF::Application/;
   3 use strict; use warnings;
   4 use Data::Dumper;
   5 $Data::Dumper::Indent = 0;
   6 use OpenILS::Event;
   7
   8 use Digest::MD5 qw(md5_hex);
   9
  10 use OpenSRF::EX qw(:try);
  11 use OpenILS::EX;
  12 use OpenILS::Perm;
  13
  14 use OpenILS::Application::AppUtils;
  15
  16 use OpenILS::Utils::Fieldmapper;
  17 use OpenILS::Application::Search::Actor;
  18 use OpenILS::Utils::ModsParser;
  19 use OpenSRF::Utils::Logger qw/$logger/;
  20
  21 use OpenSRF::Utils::Cache;
  22
  23
  24 use OpenILS::Application::Actor::Container;
  25 sub initialize {
  26         OpenILS::Application::Actor::Container->initialize();
  27 }
  28
  29 my $apputils = "OpenILS::Application::AppUtils";
  30 my $U = $apputils;
  31
  32 sub _d { warn "Patron:\n" . Dumper(shift()); }
  33
  34 my $cache_client;
  35
  36
  37 my $set_user_settings;
  38 my $set_ou_settings;
  39
  40 __PACKAGE__->register_method(
  41         method  => "set_user_settings",
  42         api_name        => "open-ils.actor.patron.settings.update",
  43 );
  44 sub set_user_settings {
  45         my( $self, $client, $user_session, $uid, $settings ) = @_;
  46
  47         $logger->debug("Setting user settings: $user_session, $uid, " . Dumper($settings));
  48
  49         my( $staff, $user, $evt ) =
  50                 $apputils->checkses_requestor( $user_session, $uid, 'UPDATE_USER' );
  51         return $evt if $evt;
  52
  53
  54         my ($params) = map {
  55                 [{ usr => $user->id, name => $_}, {value => $$settings{$_}}] } keys %$settings;
  56
  57         $logger->activity("User " . $staff->id . " updating user $uid settings with: " . Dumper($params));
  58
  59         return $apputils->simplereq(
  60                 'open-ils.storage',
  61                 'open-ils.storage.direct.actor.user_setting.batch.merge', $params );
  62
  63 }
  64
  65
  66
  67 __PACKAGE__->register_method(
  68         method  => "set_ou_settings",
  69         api_name        => "open-ils.actor.org_unit.settings.update",
  70 );
  71 sub set_ou_settings {
  72         my( $self, $client, $user_session, $ouid, $settings ) = @_;
  73
  74         my( $staff, $evt ) = $apputils->checkses( $user_session );
  75         return $evt if $evt;
  76         $evt = $apputils->check_perms( $staff->id, $ouid, 'UPDATE_ORG_UNIT' );
  77         return $evt if $evt;
  78
  79
  80         my ($params) =
  81                 map { [{ org_unit => $ouid, name => $_}, {value => $$settings{$_}}] } keys %$settings;
  82
  83         $logger->activity("Updating org unit [$ouid] settings with: " . Dumper($params));
  84
  85         return $apputils->simplereq(
  86                 'open-ils.storage',
  87                 'open-ils.storage.direct.actor.org_unit_setting.merge', @$params );
  88 }
  89
  90
  91 my $fetch_user_settings;
  92 my $fetch_ou_settings;
  93
  94 __PACKAGE__->register_method(
  95         method  => "user_settings",
  96         api_name        => "open-ils.actor.patron.settings.retrieve",
  97 );
  98 sub user_settings {
  99         my( $self, $client, $user_session, $uid ) = @_;
 100
 101         my( $staff, $user, $evt ) =
 102                 $apputils->checkses_requestor( $user_session, $uid, 'VIEW_USER' );
 103         return $evt if $evt;
 104
 105         $logger->debug("User " . $staff->id . " fetching user $uid\n");
 106         my $s = $apputils->simplereq(
 107                 'open-ils.storage',
 108                 'open-ils.storage.direct.actor.user_setting.search.usr.atomic',$uid );
 109
 110         return { map { ($_->name,$_->value) } @$s };
 111 }
 112
 113
 114
 115 __PACKAGE__->register_method(
 116         method  => "ou_settings",
 117         api_name        => "open-ils.actor.org_unit.settings.retrieve",
 118 );
 119 sub ou_settings {
 120         my( $self, $client, $ouid ) = @_;
 121
 122         my $s = $apputils->simplereq(
 123                 'open-ils.storage',
 124                 'open-ils.storage.direct.actor.org_unit_setting.search.org_unit.atomic', $ouid);
 125
 126         return { map { ($_->name,$_->value) } @$s };
 127 }
 128
 129
 130
 131 __PACKAGE__->register_method(
 132         method  => "update_patron",
 133         api_name        => "open-ils.actor.patron.update",);
 134
 135 sub update_patron {
 136         my( $self, $client, $user_session, $patron ) = @_;
 137
 138         my $session = $apputils->start_db_session();
 139         my $err = undef;
 140
 141         $logger->info("Creating new patron...") if $patron->isnew;
 142         $logger->info("Updating Patron: " . $patron->id) unless $patron->isnew;
 143
 144         my( $user_obj, $evt ) = $U->checkses($user_session);
 145         return $evt if $evt;
 146
 147         # XXX does this user have permission to add/create users.  Granularity?
 148         # $new_patron is the patron in progress.  $patron is the original patron
 149         # passed in with the method.  new_patron will change as the components
 150         # of patron are added/updated.
 151
 152         my $new_patron;
 153
 154         # unflesh the real items on the patron
 155         $patron->card( $patron->card->id ) if(ref($patron->card));
 156         $patron->billing_address( $patron->billing_address->id )
 157                 if(ref($patron->billing_address));
 158         $patron->mailing_address( $patron->mailing_address->id )
 159                 if(ref($patron->mailing_address));
 160
 161         # create/update the patron first so we can use his id
 162         if($patron->isnew()) {
 163                 ( $new_patron, $evt ) = _add_patron($session, _clone_patron($patron), $user_obj);
 164                 return $evt if $evt;
 165         } else { $new_patron = $patron; }
 166
 167         ( $new_patron, $evt ) = _add_update_addresses($session, $patron, $new_patron, $user_obj);
 168         return $evt if $evt;
 169
 170         ( $new_patron, $evt ) = _add_update_cards($session, $patron, $new_patron, $user_obj);
 171         return $evt if $evt;
 172
 173         ( $new_patron, $evt ) = _add_survey_responses($session, $patron, $new_patron, $user_obj);
 174         return $evt if $evt;
 175
 176         # re-update the patron if anything has happened to him during this process
 177         if($new_patron->ischanged()) {
 178                 ( $new_patron, $evt ) = _update_patron($session, $new_patron, $user_obj);
 179                 return $evt if $evt;
 180         }
 181
 182         #$session = OpenSRF::AppSession->create("open-ils.storage");  # why did i put this here?
 183
 184         ($new_patron, $evt) = _create_stat_maps($session, $user_session, $patron, $new_patron, $user_obj);
 185         return $evt if $evt;
 186
 187         ($new_patron, $evt) = _create_perm_maps($session, $user_session, $patron, $new_patron, $user_obj);
 188         return $evt if $evt;
 189
 190         ($new_patron, $evt) = _create_standing_penalties($session, $user_session, $patron, $new_patron, $user_obj);
 191         return $evt if $evt;
 192
 193         $apputils->commit_db_session($session);
 194
 195         #warn "Patron Update/Create complete\n";
 196         return flesh_user($new_patron->id());
 197 }
 198
 199
 200
 201
 202 __PACKAGE__->register_method(
 203         method  => "user_retrieve_fleshed_by_id",
 204         api_name        => "open-ils.actor.user.fleshed.retrieve",);
 205
 206 sub user_retrieve_fleshed_by_id {
 207         my( $self, $client, $user_session, $user_id ) = @_;
 208
 209         my( $requestor, $target, $evt ) = $apputils->
 210                 checkses_requestor( $user_session, $user_id, 'VIEW_USER' );
 211         return $evt if $evt;
 212
 213         return flesh_user($user_id);
 214 }
 215
 216
 217 sub flesh_user {
 218         my $id = shift;
 219         my $session = shift;
 220
 221         my $kill = 0;
 222
 223         if(!$session) {
 224                 $session = OpenSRF::AppSession->create("open-ils.storage");
 225                 $kill = 1;
 226         }
 227
 228         # grab the user with the given id
 229         my $ureq = $session->request(
 230                         "open-ils.storage.direct.actor.user.retrieve", $id);
 231         my $user = $ureq->gather(1);
 232
 233         if(!$user) { return undef; }
 234
 235         # grab the cards
 236         my $cards_req = $session->request(
 237                         "open-ils.storage.direct.actor.card.search.usr.atomic",
 238                         $user->id() );
 239         $user->cards( $cards_req->gather(1) );
 240
 241         for my $c(@{$user->cards}) {
 242                 if($c->id == $user->card || $c->id eq $user->card ) {
 243                         #warn "Setting my card to " . $c->id . "\n";
 244                         $user->card($c);
 245                 }
 246         }
 247
 248         my $add_req = $session->request(
 249                         "open-ils.storage.direct.actor.user_address.search.usr.atomic",
 250                         $user->id() );
 251         $user->addresses( $add_req->gather(1) );
 252
 253         for my $c(@{$user->addresses}) {
 254                 if($c->id eq $user->billing_address ) { $user->billing_address($c); }
 255                 if($c->id eq $user->mailing_address ) { $user->mailing_address($c); }
 256         }
 257
 258         my $stat_req = $session->request(
 259                 "open-ils.storage.direct.actor.stat_cat_entry_user_map.search.target_usr.atomic",
 260                 $user->id() );
 261         $user->stat_cat_entries($stat_req->gather(1));
 262
 263         my $standing_penalties_req = $session->request(
 264                 "open-ils.storage.direct.actor.user_standing_penalty.search.usr.atomic",
 265                 $user->id() );
 266         $user->standing_penalties($standing_penalties_req->gather(1));
 267
 268         if($kill) { $session->disconnect(); }
 269         $user->clear_passwd();
 270
 271         return $user;
 272 }
 273
 274
 275 # clone and clear stuff that would break the database
 276 sub _clone_patron {
 277         my $patron = shift;
 278
 279         my $new_patron = $patron->clone;
 280
 281         # Using the Fieldmapper clone method
 282         #my $new_patron = Fieldmapper::actor::user->new();
 283
 284         #my $fmap = $Fieldmapper::fieldmap;
 285         #no strict; # shallow clone, may be useful in the fieldmapper
 286         #for my $field
 287         #       (keys %{$fmap->{"Fieldmapper::actor::user"}->{'fields'}}) {
 288         #               $new_patron->$field( $patron->$field() );
 289         #}
 290         #use strict;
 291
 292         # clear these
 293         $new_patron->clear_billing_address();
 294         $new_patron->clear_mailing_address();
 295         $new_patron->clear_addresses();
 296         $new_patron->clear_card();
 297         $new_patron->clear_cards();
 298         $new_patron->clear_id();
 299         $new_patron->clear_isnew();
 300         $new_patron->clear_ischanged();
 301         $new_patron->clear_isdeleted();
 302         $new_patron->clear_stat_cat_entries();
 303         $new_patron->clear_permissions();
 304         $new_patron->clear_standing_penalties();
 305
 306         return $new_patron;
 307 }
 308
 309
 310 sub _add_patron {
 311
 312         my $session             = shift;
 313         my $patron              = shift;
 314         my $user_obj    = shift;
 315
 316         my $evt = $U->check_perms($user_obj->id, $patron->home_ou, 'CREATE_USER');
 317         return (undef, $evt) if $evt;
 318
 319         $logger->info("Creating new user in the DB with username: ".$patron->usrname());
 320
 321         my $id = $session->request(
 322                 "open-ils.storage.direct.actor.user.create", $patron)->gather(1);
 323         return (undef, $U->DB_UPDATE_FAILED($patron)) unless $id;
 324
 325         $logger->info("Successfully created new user [$id] in DB");
 326
 327         return ( $session->request(
 328                 "open-ils.storage.direct.actor.user.retrieve", $id)->gather(1), undef );
 329 }
 330
 331
 332 sub _update_patron {
 333         my( $session, $patron, $user_obj) = @_;
 334
 335         $logger->info("Updating patron ".$patron->id." in DB");
 336         my $evt = $U->check_perms($user_obj->id, $patron->home_ou, 'UPDATE_USER');
 337         return (undef, $evt) if $evt;
 338
 339         my $stat = $session->request(
 340                 "open-ils.storage.direct.actor.user.update",$patron )->gather(1);
 341         return (undef, $U->DB_UPDATE_FAILED($patron)) unless defined($stat);
 342
 343         return ($patron);
 344 }
 345
 346
 347 sub _add_update_addresses {
 348
 349         my $session = shift;
 350         my $patron = shift;
 351         my $new_patron = shift;
 352
 353         my $evt;
 354
 355         my $current_id; # id of the address before creation
 356
 357         for my $address (@{$patron->addresses()}) {
 358
 359                 $address->usr($new_patron->id());
 360
 361                 if(ref($address) and $address->isnew()) {
 362
 363                         $current_id = $address->id();
 364                         ($address, $evt) = _add_address($session,$address);
 365                         return (undef, $evt) if $evt;
 366
 367                         if( $patron->billing_address() and
 368                                         $patron->billing_address() == $current_id ) {
 369                                 $new_patron->billing_address($address->id());
 370                                 $new_patron->ischanged(1);
 371                         }
 372
 373                         if( $patron->mailing_address() and
 374                                         $patron->mailing_address() == $current_id ) {
 375                                 $new_patron->mailing_address($address->id());
 376                                 $new_patron->ischanged(1);
 377                         }
 378
 379                 } elsif( ref($address) and $address->ischanged() ) {
 380
 381                         $address->usr($new_patron->id());
 382                         ($address, $evt) = _update_address($session, $address);
 383                         return (undef, $evt) if $evt;
 384
 385                 } elsif( ref($address) and $address->isdeleted() ) {
 386
 387                         if( $address->id() == $new_patron->mailing_address() ) {
 388                                 $new_patron->clear_mailing_address();
 389                                 ($new_patron, $evt) = _update_patron($session, $new_patron);
 390                                 return (undef, $evt) if $evt;
 391                         }
 392
 393                         if( $address->id() == $new_patron->billing_address() ) {
 394                                 $new_patron->clear_billing_address();
 395                                 ($new_patron, $evt) = _update_patron($session, $new_patron);
 396                                 return (undef, $evt) if $evt;
 397                         }
 398
 399                         $evt = _delete_address($session, $address);
 400                         return (undef, $evt) if $evt;
 401                 }
 402         }
 403
 404         return ( $new_patron, undef );
 405 }
 406
 407
 408 # adds an address to the db and returns the address with new id
 409 sub _add_address {
 410         my($session, $address) = @_;
 411         $address->clear_id();
 412
 413         $logger->info("Creating new address at street ".$address->street1);
 414
 415         # put the address into the database
 416         my $id = $session->request(
 417                 "open-ils.storage.direct.actor.user_address.create", $address )->gather(1);
 418         return (undef, $U->DB_UPDATE_FAILED($address)) unless $id;
 419
 420         $address->id( $id );
 421         return ($address, undef);
 422 }
 423
 424
 425 sub _update_address {
 426         my( $session, $address ) = @_;
 427         $logger->info("Updating address ".$address->id." in the DB");
 428
 429         my $stat = $session->request(
 430                 "open-ils.storage.direct.actor.user_address.update", $address )->gather(1);
 431
 432         return (undef, $U->DB_UPDATE_FAILED($address)) unless defined($stat);
 433         return ($address, undef);
 434 }
 435
 436
 437
 438 sub _add_update_cards {
 439
 440         my $session = shift;
 441         my $patron = shift;
 442         my $new_patron = shift;
 443
 444         my $evt;
 445
 446         my $virtual_id; #id of the card before creation
 447         for my $card (@{$patron->cards()}) {
 448
 449                 $card->usr($new_patron->id());
 450
 451                 if(ref($card) and $card->isnew()) {
 452
 453                         $virtual_id = $card->id();
 454                         ( $card, $evt ) = _add_card($session,$card);
 455                         return (undef, $evt) if $evt;
 456
 457                         #if(ref($patron->card)) { $patron->card($patron->card->id); }
 458                         if($patron->card() == $virtual_id) {
 459                                 $new_patron->card($card->id());
 460                                 $new_patron->ischanged(1);
 461                         }
 462
 463                 } elsif( ref($card) and $card->ischanged() ) {
 464                         $card->usr($new_patron->id());
 465                         $evt = _update_card($session, $card);
 466                         return (undef, $evt) if $evt;
 467                 }
 468         }
 469
 470         return ( $new_patron, undef );
 471 }
 472
 473
 474 # adds an card to the db and returns the card with new id
 475 sub _add_card {
 476         my( $session, $card ) = @_;
 477         $card->clear_id();
 478         $logger->info("Adding new patron card ".$card->barcode);
 479
 480         my $id = $session->request(
 481                 "open-ils.storage.direct.actor.card.create", $card )->gather(1);
 482         return (undef, $U->DB_UPDATE_FAILED($card)) unless $id;
 483         $logger->info("Successfully created patron card $id");
 484
 485         $card->id($id);
 486         return ( $card, undef );
 487 }
 488
 489
 490 # returns event on error.  returns undef otherwise
 491 sub _update_card {
 492         my( $session, $card ) = @_;
 493         $logger->info("Updating patron card ".$card->id);
 494
 495         my $stat = $session->request(
 496                 "open-ils.storage.direct.actor.card.update", $card )->gather(1);
 497         return $U->DB_UPDATE_FAILED($card) unless defined($stat);
 498         return undef;
 499 }
 500
 501
 502
 503
 504 # returns event on error.  returns undef otherwise
 505 sub _delete_address {
 506         my( $session, $address ) = @_;
 507         $logger->info("Deleting address ".$address->id." from DB");
 508
 509         my $stat = $session->request(
 510                 "open-ils.storage.direct.actor.user_address.delete", $address )->gather(1);
 511
 512         return $U->DB_UPDATE_FAILED($address) unless defined($stat);
 513         return undef;
 514 }
 515
 516
 517
 518 sub _add_survey_responses {
 519         my ($session, $patron, $new_patron) = @_;
 520
 521         $logger->info( "Updating survey responses for patron ".$new_patron->id );
 522
 523         my $responses = $patron->survey_responses;
 524
 525         if($responses) {
 526
 527                 $_->usr($new_patron->id) for (@$responses);
 528
 529                 my $evt = $U->simplereq( "open-ils.circ",
 530                         "open-ils.circ.survey.submit.user_id", $responses );
 531
 532                 return (undef, $evt) if defined($U->event_code($evt));
 533
 534         }
 535
 536         return ( $new_patron, undef );
 537 }
 538
 539
 540 sub _create_stat_maps {
 541
 542         my($session, $user_session, $patron, $new_patron) = @_;
 543
 544         my $maps = $patron->stat_cat_entries();
 545
 546         for my $map (@$maps) {
 547
 548                 my $method = "open-ils.storage.direct.actor.stat_cat_entry_user_map.update";
 549
 550                 if ($map->isdeleted()) {
 551                         $method = "open-ils.storage.direct.actor.stat_cat_entry_user_map.delete";
 552
 553                 } elsif ($map->isnew()) {
 554                         $method = "open-ils.storage.direct.actor.stat_cat_entry_user_map.create";
 555                         $map->clear_id;
 556                 }
 557
 558
 559                 $map->target_usr($new_patron->id);
 560
 561                 #warn "
 562                 $logger->info("Updating stat entry with method $method and map $map");
 563
 564                 my $stat = $session->request($method, $map)->gather(1);
 565                 return (undef, $U->DB_UPDATE_FAILED($map)) unless defined($stat);
 566
 567         }
 568
 569         return ($new_patron, undef);
 570 }
 571
 572 sub _create_perm_maps {
 573
 574         my($session, $user_session, $patron, $new_patron) = @_;
 575
 576         my $maps = $patron->permissions;
 577
 578         for my $map (@$maps) {
 579
 580                 my $method = "open-ils.storage.direct.permission.usr_perm_map.update";
 581                 if ($map->isdeleted()) {
 582                         $method = "open-ils.storage.direct.permission.usr_perm_map.delete";
 583                 } elsif ($map->isnew()) {
 584                         $method = "open-ils.storage.direct.permission.usr_perm_map.create";
 585                         $map->clear_id;
 586                 }
 587
 588
 589                 $map->usr($new_patron->id);
 590
 591                 #warn( "Updating permissions with method $method and session $user_session and map $map" );
 592                 $logger->info( "Updating permissions with method $method and map $map" );
 593
 594                 my $stat = $session->request($method, $map)->gather(1);
 595                 return (undef, $U->DB_UPDATE_FAILED($map)) unless defined($stat);
 596
 597         }
 598
 599         return ($new_patron, undef);
 600 }
 601
 602
 603 sub _create_standing_penalties {
 604
 605         my($session, $user_session, $patron, $new_patron) = @_;
 606
 607         my $maps = $patron->standing_penalties;
 608         my $method;
 609
 610         for my $map (@$maps) {
 611
 612                 if ($map->isdeleted()) {
 613                         $method = "open-ils.storage.direct.actor.user_standing_penalty.delete";
 614                 } elsif ($map->isnew()) {
 615                         $method = "open-ils.storage.direct.actor.user_standing_penalty.create";
 616                         $map->clear_id;
 617                 } else {
 618                         next;
 619                 }
 620
 621                 $map->usr($new_patron->id);
 622
 623                 $logger->debug( "Updating standing penalty with method $method and session $user_session and map $map" );
 624
 625                 my $stat = $session->request($method, $map)->gather(1);
 626                 return (undef, $U->DB_UPDATE_FAILED($map)) unless $stat;
 627         }
 628
 629         return ($new_patron, undef);
 630 }
 631
 632
 633
 634 __PACKAGE__->register_method(
 635         method  => "search_username",
 636         api_name        => "open-ils.actor.user.search.username",
 637 );
 638
 639 sub search_username {
 640         my($self, $client, $username) = @_;
 641         my $users = OpenILS::Application::AppUtils->simple_scalar_request(
 642                         "open-ils.storage",
 643                         "open-ils.storage.direct.actor.user.search.usrname.atomic",
 644                         $username );
 645         return $users;
 646 }
 647
 648
 649
 650
 651 __PACKAGE__->register_method(
 652         method  => "user_retrieve_by_barcode",
 653         api_name        => "open-ils.actor.user.fleshed.retrieve_by_barcode",);
 654
 655 sub user_retrieve_by_barcode {
 656         my($self, $client, $user_session, $barcode) = @_;
 657
 658         $logger->debug("Searching for user with barcode $barcode");
 659         my ($user_obj, $evt) = $apputils->checkses($user_session);
 660         return $evt if $evt;
 661
 662         my $session = OpenSRF::AppSession->create("open-ils.storage");
 663
 664         # find the card with the given barcode
 665         my $creq        = $session->request(
 666                         "open-ils.storage.direct.actor.card.search.barcode.atomic",
 667                         $barcode );
 668         my $card = $creq->gather(1);
 669
 670         if(!$card || !$card->[0]) {
 671                 $session->disconnect();
 672                 return OpenILS::Event->new( 'USER_NOT_FOUND' );
 673         }
 674
 675         $card = $card->[0];
 676         my $user = flesh_user($card->usr(), $session);
 677         $session->disconnect();
 678         if(!$user) { return OpenILS::Event->new( 'USER_NOT_FOUND' ); }
 679         return $user;
 680
 681 }
 682
 683
 684
 685 __PACKAGE__->register_method(
 686         method  => "get_user_by_id",
 687         api_name        => "open-ils.actor.user.retrieve",);
 688
 689 sub get_user_by_id {
 690         my ($self, $client, $user_session, $id) = @_;
 691
 692         my $user_obj = $apputils->check_user_session( $user_session );
 693
 694         return $apputils->simple_scalar_request(
 695                 "open-ils.storage",
 696                 "open-ils.storage.direct.actor.user.retrieve",
 697                 $id );
 698 }
 699
 700
 701
 702 __PACKAGE__->register_method(
 703         method  => "get_org_types",
 704         api_name        => "open-ils.actor.org_types.retrieve",);
 705
 706 my $org_types;
 707 sub get_org_types {
 708         my($self, $client) = @_;
 709
 710         return $org_types if $org_types;
 711          return $org_types =
 712                  $apputils->simple_scalar_request(
 713                         "open-ils.storage",
 714                         "open-ils.storage.direct.actor.org_unit_type.retrieve.all.atomic" );
 715 }
 716
 717
 718
 719 __PACKAGE__->register_method(
 720         method  => "get_user_profiles",
 721         api_name        => "open-ils.actor.user.profiles.retrieve",
 722 );
 723
 724 my $user_profiles;
 725 sub get_user_profiles {
 726         return $user_profiles if $user_profiles;
 727
 728         return $user_profiles =
 729                 $apputils->simple_scalar_request(
 730                         "open-ils.storage",
 731                         "open-ils.storage.direct.actor.profile.retrieve.all.atomic");
 732 }
 733
 734
 735
 736 __PACKAGE__->register_method(
 737         method  => "get_user_ident_types",
 738         api_name        => "open-ils.actor.user.ident_types.retrieve",
 739 );
 740 my $ident_types;
 741 sub get_user_ident_types {
 742         return $ident_types if $ident_types;
 743         return $ident_types =
 744                 $apputils->simple_scalar_request(
 745                 "open-ils.storage",
 746                 "open-ils.storage.direct.config.identification_type.retrieve.all.atomic" );
 747 }
 748
 749
 750
 751
 752 __PACKAGE__->register_method(
 753         method  => "get_org_unit",
 754         api_name        => "open-ils.actor.org_unit.retrieve",
 755 );
 756
 757 sub get_org_unit {
 758
 759         my( $self, $client, $user_session, $org_id ) = @_;
 760
 761         if(defined($user_session) && !defined($org_id)) {
 762                 my $user_obj =
 763                         OpenILS::Application::AppUtils->check_user_session( $user_session ); #throws EX on error
 764                 if(!defined($org_id)) {
 765                         $org_id = $user_obj->home_ou;
 766                 }
 767         }
 768
 769
 770         my $home_ou = OpenILS::Application::AppUtils->simple_scalar_request(
 771                 "open-ils.storage",
 772                 "open-ils.storage.direct.actor.org_unit.retrieve",
 773                 $org_id );
 774
 775         return $home_ou;
 776 }
 777
 778
 779 # build the org tree
 780
 781 __PACKAGE__->register_method(
 782         method  => "get_org_tree",
 783         api_name        => "open-ils.actor.org_tree.retrieve",
 784         argc            => 0,
 785         note            => "Returns the entire org tree structure",
 786 );
 787
 788 sub get_org_tree {
 789         my( $self, $client) = @_;
 790
 791         if(!$cache_client) {
 792                 $cache_client = OpenSRF::Utils::Cache->new("global", 0);
 793         }
 794         # see if it's in the cache
 795         #warn "Getting ORG Tree\n";
 796         my $tree = $cache_client->get_cache('orgtree');
 797         if($tree) {
 798                 #warn "Found orgtree in cache. returning...\n";
 799                 return $tree;
 800         }
 801
 802         my $orglist = $apputils->simple_scalar_request(
 803                 "open-ils.storage",
 804                 "open-ils.storage.direct.actor.org_unit.retrieve.all.atomic" );
 805
 806         #if($orglist) {
 807                 #warn "found org list\n";
 808         #}
 809
 810         $tree = $self->build_org_tree($orglist);
 811         $cache_client->put_cache('orgtree', $tree);
 812
 813         return $tree;
 814
 815 }
 816
 817 # turns an org list into an org tree
 818 sub build_org_tree {
 819
 820         my( $self, $orglist) = @_;
 821
 822         return $orglist unless (
 823                         ref($orglist) and @$orglist > 1 );
 824
 825         my @list = sort {
 826                 $a->ou_type <=> $b->ou_type ||
 827                 $a->name cmp $b->name } @$orglist;
 828
 829         for my $org (@list) {
 830
 831                 next unless ($org and defined($org->parent_ou));
 832                 my ($parent) = grep { $_->id == $org->parent_ou } @list;
 833                 next unless $parent;
 834
 835                 $parent->children([]) unless defined($parent->children);
 836                 push( @{$parent->children}, $org );
 837         }
 838
 839         return $list[0];
 840
 841 }
 842
 843
 844 __PACKAGE__->register_method(
 845         method  => "get_org_descendants",
 846         api_name        => "open-ils.actor.org_tree.descendants.retrieve"
 847 );
 848
 849 # depth is optional.  org_unit is the id
 850 sub get_org_descendants {
 851         my( $self, $client, $org_unit, $depth ) = @_;
 852         my $orglist = $apputils->simple_scalar_request(
 853                         "open-ils.storage",
 854                         "open-ils.storage.actor.org_unit.descendants.atomic",
 855                         $org_unit, $depth );
 856         return $self->build_org_tree($orglist);
 857 }
 858
 859
 860 __PACKAGE__->register_method(
 861         method  => "get_org_ancestors",
 862         api_name        => "open-ils.actor.org_tree.ancestors.retrieve"
 863 );
 864
 865 # depth is optional.  org_unit is the id
 866 sub get_org_ancestors {
 867         my( $self, $client, $org_unit, $depth ) = @_;
 868         my $orglist = $apputils->simple_scalar_request(
 869                         "open-ils.storage",
 870                         "open-ils.storage.actor.org_unit.ancestors.atomic",
 871                         $org_unit, $depth );
 872         return $self->build_org_tree($orglist);
 873 }
 874
 875
 876 __PACKAGE__->register_method(
 877         method  => "get_standings",
 878         api_name        => "open-ils.actor.standings.retrieve"
 879 );
 880
 881 my $user_standings;
 882 sub get_standings {
 883         return $user_standings if $user_standings;
 884         return $user_standings =
 885                 $apputils->simple_scalar_request(
 886                         "open-ils.storage",
 887                         "open-ils.storage.direct.config.standing.retrieve.all.atomic" );
 888 }
 889
 890
 891
 892 __PACKAGE__->register_method(
 893         method  => "get_my_org_path",
 894         api_name        => "open-ils.actor.org_unit.full_path.retrieve"
 895 );
 896
 897 sub get_my_org_path {
 898         my( $self, $client, $user_session, $org_id ) = @_;
 899         my $user_obj = $apputils->check_user_session($user_session);
 900         if(!defined($org_id)) { $org_id = $user_obj->home_ou; }
 901
 902         return $apputils->simple_scalar_request(
 903                 "open-ils.storage",
 904                 "open-ils.storage.actor.org_unit.full_path.atomic",
 905                 $org_id );
 906 }
 907
 908
 909 __PACKAGE__->register_method(
 910         method  => "patron_adv_search",
 911         api_name        => "open-ils.actor.patron.search.advanced" );
 912
 913 sub patron_adv_search {
 914         my( $self, $client, $staff_login, $search_hash ) = @_;
 915
 916         #warn "patron adv with $staff_login and search " .
 917                 #Dumper($search_hash) . "\n";
 918
 919         my $session = OpenSRF::AppSession->create("open-ils.storage");
 920         my $req = $session->request(
 921                 "open-ils.storage.actor.user.crazy_search", $search_hash);
 922
 923         my $ans = $req->gather(1);
 924
 925         my %hash = map { ($_ =>1) } @$ans;
 926         $ans = [ keys %hash ];
 927
 928         #warn "Returning @$ans\n";
 929
 930         $session->disconnect();
 931         return $ans;
 932
 933 }
 934
 935
 936
 937 sub _verify_password {
 938         my($user_session, $password) = @_;
 939         my $user_obj = $apputils->check_user_session($user_session);
 940
 941         #grab the user with password
 942         $user_obj = $apputils->simple_scalar_request(
 943                 "open-ils.storage",
 944                 "open-ils.storage.direct.actor.user.retrieve",
 945                 $user_obj->id );
 946
 947         if($user_obj->passwd eq $password) {
 948                 return 1;
 949         }
 950
 951         return 0;
 952 }
 953
 954
 955 __PACKAGE__->register_method(
 956         method  => "update_password",
 957         api_name        => "open-ils.actor.user.password.update");
 958
 959 __PACKAGE__->register_method(
 960         method  => "update_password",
 961         api_name        => "open-ils.actor.user.username.update");
 962
 963 __PACKAGE__->register_method(
 964         method  => "update_password",
 965         api_name        => "open-ils.actor.user.email.update");
 966
 967 sub update_password {
 968         my( $self, $client, $user_session, $new_value, $current_password ) = @_;
 969
 970         my $evt;
 971
 972         #warn "Updating user with method " .$self->api_name . "\n";
 973         my $user_obj = $apputils->check_user_session($user_session);
 974
 975         if($self->api_name =~ /password/) {
 976
 977                 #make sure they know the current password
 978                 if(!_verify_password($user_session, md5_hex($current_password))) {
 979                         return OpenILS::EX->new("USER_WRONG_PASSWORD")->ex;
 980                 }
 981
 982                 $user_obj->passwd($new_value);
 983         }
 984         elsif($self->api_name =~ /username/) {
 985                 my $users = search_username(undef, undef, $new_value);
 986                 if( $users and $users->[0] ) {
 987                         return OpenILS::Event->new('USERNAME_EXISTS');
 988                 }
 989                 $user_obj->usrname($new_value);
 990         }
 991
 992         elsif($self->api_name =~ /email/) {
 993                 #warn "Updating email to $new_value\n";
 994                 $user_obj->email($new_value);
 995         }
 996
 997         my $session = $apputils->start_db_session();
 998
 999         ( $user_obj, $evt ) = _update_patron($session, $user_obj, $user_obj);
1000         return $evt if $evt;
1001
1002         $apputils->commit_db_session($session);
1003
1004         if($user_obj) { return 1; }
1005         return undef;
1006 }
1007
1008
1009 __PACKAGE__->register_method(
1010         method  => "check_user_perms",
1011         api_name        => "open-ils.actor.user.perm.check",
1012         notes           => <<"  NOTES");
1013         Takes a login session, user id, an org id, and an array of perm type strings.  For each
1014         perm type, if the user does *not* have the given permission it is added
1015         to a list which is returned from the method.  If all permissions
1016         are allowed, an empty list is returned
1017         if the logged in user does not match 'user_id', then the logged in user must
1018         have VIEW_PERMISSION priveleges.
1019         NOTES
1020
1021 sub check_user_perms {
1022         my( $self, $client, $login_session, $user_id, $org_id, $perm_types ) = @_;
1023
1024         my( $staff, $evt ) = $apputils->checkses($login_session);
1025         return $evt if $evt;
1026
1027         if($staff->id ne $user_id) {
1028                 if( my $evt = $apputils->check_perms(
1029                         $staff->id, $org_id, 'VIEW_PERMISSION') ) {
1030                         return $evt;
1031                 }
1032         }
1033
1034         my @not_allowed;
1035         for my $perm (@$perm_types) {
1036                 if($apputils->check_perms($user_id, $org_id, $perm)) {
1037                         push @not_allowed, $perm;
1038                 }
1039         }
1040
1041         return \@not_allowed
1042 }
1043
1044 __PACKAGE__->register_method(
1045         method  => "check_user_perms2",
1046         api_name        => "open-ils.actor.user.perm.check.multi_org",
1047         notes           => q/
1048                 Checks the permissions on a list of perms and orgs for a user
1049                 @param authtoken The login session key
1050                 @param user_id The id of the user to check
1051                 @param orgs The array of org ids
1052                 @param perms The array of permission names
1053                 @return An array of  [ orgId, permissionName ] arrays that FAILED the check
1054                 if the logged in user does not match 'user_id', then the logged in user must
1055                 have VIEW_PERMISSION priveleges.
1056         /);
1057
1058 sub check_user_perms2 {
1059         my( $self, $client, $authtoken, $user_id, $orgs, $perms ) = @_;
1060
1061         my( $staff, $target, $evt ) = $apputils->checkses_requestor(
1062                 $authtoken, $user_id, 'VIEW_PERMISSION' );
1063         return $evt if $evt;
1064
1065         my @not_allowed;
1066         for my $org (@$orgs) {
1067                 for my $perm (@$perms) {
1068                         if($apputils->check_perms($user_id, $org, $perm)) {
1069                                 push @not_allowed, [ $org, $perm ];
1070                         }
1071                 }
1072         }
1073
1074         return \@not_allowed
1075 }
1076
1077
1078 __PACKAGE__->register_method(
1079         method => 'check_user_perms3',
1080         api_name        => 'open-ils.actor.user.perm.highest_org',
1081         notes           => q/
1082                 Returns the highest org unit id at which a user has a given permission
1083                 If the requestor does not match the target user, the requestor must have
1084                 'VIEW_PERMISSION' rights at the home org unit of the target user
1085                 @param authtoken The login session key
1086                 @param userid The id of the user in question
1087                 @param perm The permission to check
1088                 @return The org unit highest in the org tree within which the user has
1089                 the requested permission
1090         /);
1091
1092 sub check_user_perms3 {
1093         my( $self, $client, $authtoken, $userid, $perm ) = @_;
1094
1095         my( $staff, $target, $org, $evt );
1096
1097         ( $staff, $target, $evt ) = $apputils->checkses_requestor(
1098                 $authtoken, $userid, 'VIEW_PERMISSION' );
1099         return $evt if $evt;
1100
1101         my $tree = $self->get_org_tree();
1102         return _find_highest_perm_org( $perm, $userid, $target->home_ou, $tree );
1103 }
1104
1105
1106 sub _find_highest_perm_org {
1107         my ( $perm, $userid, $start_org, $org_tree ) = @_;
1108         my $org = $apputils->find_org($org_tree, $start_org );
1109
1110         my $lastid = undef;
1111         while( $org ) {
1112                 last if ($apputils->check_perms( $userid, $org->id, $perm )); # perm failed
1113                 $lastid = $org->id;
1114                 $org = $apputils->find_org( $org_tree, $org->parent_ou() );
1115         }
1116
1117         return $lastid;
1118 }
1119
1120 __PACKAGE__->register_method(
1121         method => 'check_user_perms4',
1122         api_name        => 'open-ils.actor.user.perm.highest_org.batch',
1123         notes           => q/
1124                 Returns the highest org unit id at which a user has a given permission
1125                 If the requestor does not match the target user, the requestor must have
1126                 'VIEW_PERMISSION' rights at the home org unit of the target user
1127                 @param authtoken The login session key
1128                 @param userid The id of the user in question
1129                 @param perms An array of perm names to check
1130                 @return An array of orgId's  representing the org unit
1131                 highest in the org tree within which the user has the requested permission
1132                 The arrah of orgId's has matches the order of the perms array
1133         /);
1134
1135 sub check_user_perms4 {
1136         my( $self, $client, $authtoken, $userid, $perms ) = @_;
1137
1138         my( $staff, $target, $org, $evt );
1139
1140         ( $staff, $target, $evt ) = $apputils->checkses_requestor(
1141                 $authtoken, $userid, 'VIEW_PERMISSION' );
1142         return $evt if $evt;
1143
1144         my @arr;
1145         return [] unless ref($perms);
1146         my $tree = $self->get_org_tree();
1147
1148         for my $p (@$perms) {
1149                 push( @arr, _find_highest_perm_org( $p, $userid, $target->home_ou, $tree ) );
1150         }
1151         return \@arr;
1152 }
1153
1154
1155
1156
1157 __PACKAGE__->register_method(
1158         method  => "user_fines_summary",
1159         api_name        => "open-ils.actor.user.fines.summary",
1160         notes           => <<"  NOTES");
1161         Returns a short summary of the users total open fines, excluding voided fines
1162         Params are login_session, user_id
1163         Returns a 'mous' object.
1164         NOTES
1165
1166 sub user_fines_summary {
1167         my( $self, $client, $login_session, $user_id ) = @_;
1168
1169         my $user_obj = $apputils->check_user_session($login_session);
1170         if($user_obj->id ne $user_id) {
1171                 if($apputils->check_user_perms($user_obj->id, $user_obj->home_ou, "VIEW_USER_FINES_SUMMARY")) {
1172                         return OpenILS::Perm->new("VIEW_USER_FINES_SUMMARY");
1173                 }
1174         }
1175
1176         return $apputils->simple_scalar_request(
1177                 "open-ils.storage",
1178                 "open-ils.storage.direct.money.open_user_summary.search.usr",
1179                 $user_id );
1180
1181 }
1182
1183
1184
1185
1186 __PACKAGE__->register_method(
1187         method  => "user_transactions",
1188         api_name        => "open-ils.actor.user.transactions",
1189         notes           => <<"  NOTES");
1190         Returns a list of open user transactions (mbts objects);
1191         Params are login_session, user_id
1192         Optional third parameter is the transactions type.  defaults to all
1193         NOTES
1194
1195 __PACKAGE__->register_method(
1196         method  => "user_transactions",
1197         api_name        => "open-ils.actor.user.transactions.have_charge",
1198         notes           => <<"  NOTES");
1199         Returns a list of all open user transactions (mbts objects) that have an initial charge
1200         Params are login_session, user_id
1201         Optional third parameter is the transactions type.  defaults to all
1202         NOTES
1203
1204 __PACKAGE__->register_method(
1205         method  => "user_transactions",
1206         api_name        => "open-ils.actor.user.transactions.have_balance",
1207         notes           => <<"  NOTES");
1208         Returns a list of all open user transactions (mbts objects) that have a balance
1209         Params are login_session, user_id
1210         Optional third parameter is the transactions type.  defaults to all
1211         NOTES
1212
1213 __PACKAGE__->register_method(
1214         method  => "user_transactions",
1215         api_name        => "open-ils.actor.user.transactions.fleshed",
1216         notes           => <<"  NOTES");
1217         Returns an object/hash of transaction, circ, title where transaction = an open
1218         user transactions (mbts objects), circ is the attached circluation, and title
1219         is the title the circ points to
1220         Params are login_session, user_id
1221         Optional third parameter is the transactions type.  defaults to all
1222         NOTES
1223
1224 __PACKAGE__->register_method(
1225         method  => "user_transactions",
1226         api_name        => "open-ils.actor.user.transactions.have_charge.fleshed",
1227         notes           => <<"  NOTES");
1228         Returns an object/hash of transaction, circ, title where transaction = an open
1229         user transactions that has an initial charge (mbts objects), circ is the
1230         attached circluation, and title is the title the circ points to
1231         Params are login_session, user_id
1232         Optional third parameter is the transactions type.  defaults to all
1233         NOTES
1234
1235 __PACKAGE__->register_method(
1236         method  => "user_transactions",
1237         api_name        => "open-ils.actor.user.transactions.have_balance.fleshed",
1238         notes           => <<"  NOTES");
1239         Returns an object/hash of transaction, circ, title where transaction = an open
1240         user transaction that has a balance (mbts objects), circ is the attached
1241         circluation, and title is the title the circ points to
1242         Params are login_session, user_id
1243         Optional third parameter is the transaction type.  defaults to all
1244         NOTES
1245
1246
1247
1248 sub user_transactions {
1249         my( $self, $client, $login_session, $user_id, $type ) = @_;
1250
1251         my( $user_obj, $target, $evt ) = $apputils->checkses_requestor(
1252                 $login_session, $user_id, 'VIEW_USER_TRANSACTIONS' );
1253         return $evt if $evt;
1254
1255         my $api = $self->api_name();
1256         my $trans;
1257         my @xact;
1258
1259         if(defined($type)) { @xact = (xact_type =>  $type);
1260
1261         } else { @xact = (); }
1262
1263         if($api =~ /have_charge/) {
1264
1265                 $trans = $apputils->simple_scalar_request(
1266                         "open-ils.storage",
1267                         "open-ils.storage.direct.money.open_billable_transaction_summary.search_where.atomic",
1268                         { usr => $user_id, total_owed => { ">" => 0 }, @xact });
1269
1270         } elsif($api =~ /have_balance/) {
1271
1272                 $trans =  $apputils->simple_scalar_request(
1273                         "open-ils.storage",
1274                         "open-ils.storage.direct.money.open_billable_transaction_summary.search_where.atomic",
1275                         { usr => $user_id, balance_owed => { ">" => 0 }, @xact });
1276
1277         } else {
1278
1279                 $trans =  $apputils->simple_scalar_request(
1280                         "open-ils.storage",
1281                         "open-ils.storage.direct.money.open_billable_transaction_summary.search_where.atomic",
1282                         { usr => $user_id, @xact });
1283         }
1284
1285         if($api !~ /fleshed/) { return $trans; }
1286
1287         #warn "API: $api\n";
1288
1289         my @resp;
1290         for my $t (@$trans) {
1291
1292                 #warn $t->id . "\n";
1293
1294
1295                 if( $t->xact_type ne 'circulation' ) {
1296                         push @resp, {transaction => $t};
1297                         next;
1298                 }
1299
1300                 my $circ = $apputils->simple_scalar_request(
1301                                 "open-ils.storage",
1302                                 "open-ils.storage.direct.action.circulation.retrieve",
1303                                 $t->id );
1304
1305                 next unless $circ;
1306
1307                 my $title = $apputils->simple_scalar_request(
1308                         "open-ils.storage",
1309                         "open-ils.storage.fleshed.biblio.record_entry.retrieve_by_copy",
1310                         $circ->target_copy );
1311
1312                 next unless $title;
1313
1314                 my $u = OpenILS::Utils::ModsParser->new();
1315                 $u->start_mods_batch($title->marc());
1316                 my $mods = $u->finish_mods_batch();
1317
1318                 push @resp, {transaction => $t, circ => $circ, record => $mods };
1319
1320         }
1321
1322         return \@resp;
1323 }
1324
1325
1326
1327
1328 __PACKAGE__->register_method(
1329         method  => "user_perms",
1330         api_name        => "open-ils.actor.permissions.user_perms.retrieve",
1331         argc            => 1,
1332         notes           => <<"  NOTES");
1333         Returns a list of permissions
1334         NOTES
1335 sub user_perms {
1336         my( $self, $client, $authtoken, $user ) = @_;
1337
1338         my( $staff, $evt ) = $apputils->checkses($authtoken);
1339         return $evt if $evt;
1340
1341         $user ||= $staff->id;
1342
1343         if( $user != $staff->id and $evt = $apputils->check_perms( $staff->id, $staff->home_ou, 'VIEW_PERMISSION') ) {
1344                 return $evt;
1345         }
1346
1347         return $apputils->simple_scalar_request(
1348                 "open-ils.storage",
1349                 "open-ils.storage.permission.user_perms.atomic",
1350                 $user);
1351 }
1352
1353 __PACKAGE__->register_method(
1354         method  => "retrieve_perms",
1355         api_name        => "open-ils.actor.permissions.retrieve",
1356         notes           => <<"  NOTES");
1357         Returns a list of permissions
1358         NOTES
1359 sub retrieve_perms {
1360         my( $self, $client ) = @_;
1361         return $apputils->simple_scalar_request(
1362                 "open-ils.storage",
1363                 "open-ils.storage.direct.permission.perm_list.retrieve.all.atomic");
1364 }
1365
1366 __PACKAGE__->register_method(
1367         method  => "retrieve_groups",
1368         api_name        => "open-ils.actor.groups.retrieve",
1369         notes           => <<"  NOTES");
1370         Returns a list of user groupss
1371         NOTES
1372 sub retrieve_groups {
1373         my( $self, $client ) = @_;
1374         return $apputils->simple_scalar_request(
1375                 "open-ils.storage",
1376                 "open-ils.storage.direct.permission.grp_tree.retrieve.all.atomic");
1377 }
1378
1379 __PACKAGE__->register_method(
1380         method  => "retrieve_groups_tree",
1381         api_name        => "open-ils.actor.groups.tree.retrieve",
1382         notes           => <<"  NOTES");
1383         Returns a list of user groups
1384         NOTES
1385 sub retrieve_groups_tree {
1386         my( $self, $client ) = @_;
1387         my $groups = $apputils->simple_scalar_request(
1388                 "open-ils.storage",
1389                 "open-ils.storage.direct.permission.grp_tree.retrieve.all.atomic");
1390         return $self->build_group_tree($groups);
1391 }
1392
1393
1394 # turns an org list into an org tree
1395 sub build_group_tree {
1396
1397         my( $self, $grplist) = @_;
1398
1399         return $grplist unless (
1400                         ref($grplist) and @$grplist > 1 );
1401
1402         my @list = sort { $a->name cmp $b->name } @$grplist;
1403
1404         my $root;
1405         for my $grp (@list) {
1406
1407                 if ($grp and !defined($grp->parent)) {
1408                         $root = $grp;
1409                         next;
1410                 }
1411                 my ($parent) = grep { $_->id == $grp->parent} @list;
1412
1413                 $parent->children([]) unless defined($parent->children);
1414                 push( @{$parent->children}, $grp );
1415         }
1416
1417         return $root;
1418
1419 }
1420
1421
1422 __PACKAGE__->register_method(
1423         method  => "add_user_to_groups",
1424         api_name        => "open-ils.actor.user.set_groups",
1425         notes           => <<"  NOTES");
1426         Adds a user to one or more permission groups
1427         NOTES
1428
1429 sub add_user_to_groups {
1430         my( $self, $client, $authtoken, $userid, $groups ) = @_;
1431
1432         my( $requestor, $target, $evt ) = $apputils->checkses_requestor(
1433                 $authtoken, $userid, 'CREATE_USER_GROUP_LINK' );
1434         return $evt if $evt;
1435
1436         ( $requestor, $target, $evt ) = $apputils->checkses_requestor(
1437                 $authtoken, $userid, 'REMOVE_USER_GROUP_LINK' );
1438         return $evt if $evt;
1439
1440         $apputils->simplereq(
1441                 'open-ils.storage',
1442                 'open-ils.storage.direct.permission.usr_grp_map.mass_delete', { usr => $userid } );
1443
1444         for my $group (@$groups) {
1445                 my $link = Fieldmapper::permission::usr_grp_map->new;
1446                 $link->grp($group);
1447                 $link->usr($userid);
1448
1449                 my $id = $apputils->simplereq(
1450                         'open-ils.storage',
1451                         'open-ils.storage.direct.permission.usr_grp_map.create', $link );
1452         }
1453
1454         return 1;
1455 }
1456
1457 __PACKAGE__->register_method(
1458         method  => "get_user_perm_groups",
1459         api_name        => "open-ils.actor.user.get_groups",
1460         notes           => <<"  NOTES");
1461         Retrieve a user's permission groups.
1462         NOTES
1463
1464
1465 sub get_user_perm_groups {
1466         my( $self, $client, $authtoken, $userid ) = @_;
1467
1468         my( $requestor, $target, $evt ) = $apputils->checkses_requestor(
1469                 $authtoken, $userid, 'VIEW_PERM_GROUPS' );
1470         return $evt if $evt;
1471
1472         return $apputils->simplereq(
1473                 'open-ils.storage',
1474                 'open-ils.storage.direct.permission.usr_grp_map.search.usr.atomic', $userid );
1475 }
1476
1477
1478
1479
1480 1;
1481