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

   1 package OpenILS::Application::Actor::Container;
   2 use base 'OpenILS::Application';
   3 use strict; use warnings;
   4 use OpenILS::Application::AppUtils;
   5 use OpenILS::Perm;
   6 use Data::Dumper;
   7 use OpenSRF::EX qw(:try);
   8 use OpenILS::Utils::Fieldmapper;
   9 use OpenILS::Utils::CStoreEditor qw/:funcs/;
  10 use OpenSRF::Utils::SettingsClient;
  11 use OpenSRF::Utils::Cache;
  12 use Digest::MD5 qw(md5_hex);
  13 use OpenSRF::Utils::JSON;
  14
  15 my $apputils = "OpenILS::Application::AppUtils";
  16 my $U = $apputils;
  17 my $logger = "OpenSRF::Utils::Logger";
  18
  19 sub initialize { return 1; }
  20
  21 my $svc = 'open-ils.cstore';
  22 my $meth = 'open-ils.cstore.direct.container';
  23 my %types;
  24 my %ctypes;
  25 $types{'biblio'} = "$meth.biblio_record_entry_bucket";
  26 $types{'callnumber'} = "$meth.call_number_bucket";
  27 $types{'copy'} = "$meth.copy_bucket";
  28 $types{'user'} = "$meth.user_bucket";
  29 $ctypes{'biblio'} = "container_biblio_record_entry_bucket";
  30 $ctypes{'callnumber'} = "container_call_number_bucket";
  31 $ctypes{'copy'} = "container_copy_bucket";
  32 $ctypes{'user'} = "container_user_bucket";
  33 my $event;
  34
  35 sub _sort_buckets {
  36         my $buckets = shift;
  37         return $buckets unless ($buckets && $buckets->[0]);
  38         return [ sort { $a->name cmp $b->name } @$buckets ];
  39 }
  40
  41 __PACKAGE__->register_method(
  42         method  => "bucket_retrieve_all",
  43         api_name        => "open-ils.actor.container.all.retrieve_by_user",
  44     authoritative => 1,
  45         notes           => <<"  NOTES");
  46                 Retrieves all un-fleshed buckets assigned to given user
  47                 PARAMS(authtoken, bucketOwnerId)
  48                 If requestor ID is different than bucketOwnerId, requestor must have
  49                 VIEW_CONTAINER permissions.
  50         NOTES
  51
  52 sub bucket_retrieve_all {
  53         my($self, $client, $auth, $user_id) = @_;
  54     my $e = new_editor(authtoken => $auth);
  55     return $e->event unless $e->checkauth;
  56
  57     if($e->requestor->id ne $user_id) {
  58         return $e->event unless $e->allowed('VIEW_CONTAINER');
  59     }
  60
  61         my %buckets;
  62     for my $type (keys %ctypes) {
  63         my $meth = "search_" . $ctypes{$type};
  64             $buckets{$type} = $e->$meth({owner => $user_id});
  65     }
  66
  67         return \%buckets;
  68 }
  69
  70 __PACKAGE__->register_method(
  71         method  => "bucket_flesh",
  72         api_name        => "open-ils.actor.container.flesh",
  73     authoritative => 1,
  74         argc            => 3,
  75 );
  76
  77 __PACKAGE__->register_method(
  78         method  => "bucket_flesh_pub",
  79         api_name        => "open-ils.actor.container.public.flesh",
  80         argc            => 3,
  81 );
  82
  83 sub bucket_flesh {
  84         my($self, $conn, $auth, $class, $bucket_id) = @_;
  85     my $e = new_editor(authtoken => $auth);
  86     return $e->event unless $e->checkauth;
  87     return _bucket_flesh($self, $conn, $e, $class, $bucket_id);
  88 }
  89
  90 sub bucket_flesh_pub {
  91     my($self, $conn, $class, $bucket_id) = @_;
  92     my $e = new_editor();
  93     return _bucket_flesh($self, $conn, $e, $class, $bucket_id);
  94 }
  95
  96 sub _bucket_flesh {
  97         my($self, $conn, $e, $class, $bucket_id) = @_;
  98         my $meth = 'retrieve_' . $ctypes{$class};
  99     my $bkt = $e->$meth($bucket_id) or return $e->event;
 100
 101         unless($U->is_true($bkt->pub)) {
 102         return undef if $self->api_name =~ /public/;
 103         unless($bkt->owner eq $e->requestor->id) {
 104             my $owner = $e->retrieve_actor_user($bkt->owner)
 105                 or return $e->die_event;
 106             return $e->event unless $e->allowed('VIEW_CONTAINER', $owner->home_ou);
 107         }
 108         }
 109
 110     my $fmclass = $bkt->class_name . "i";
 111     $meth = 'search_' . $ctypes{$class} . '_item';
 112         $bkt->items(
 113         $e->$meth(
 114             {bucket => $bucket_id},
 115             {   order_by => {$fmclass => "pos"},
 116                 flesh => 1,
 117                 flesh_fields => {$fmclass => ['notes']}
 118             }
 119         )
 120     );
 121
 122         return $bkt;
 123 }
 124
 125
 126 __PACKAGE__->register_method(
 127         method  => "item_note_cud",
 128         api_name        => "open-ils.actor.container.item_note.cud",
 129 );
 130
 131
 132 sub item_note_cud {
 133     my($self, $conn, $auth, $class, $note) = @_;
 134
 135     return new OpenILS::Event("BAD_PARAMS") unless
 136         $note->class_name =~ /bucket_item_note$/;
 137
 138     my $e = new_editor(authtoken => $auth, xact => 1);
 139     return $e->die_event unless $e->checkauth;
 140
 141     my $meat = $ctypes{$class} . "_item_note";
 142     my $meth = "retrieve_$meat";
 143
 144     my $item_meat = $ctypes{$class} . "_item";
 145     my $item_meth = "retrieve_$item_meat";
 146
 147     my $nhint = $Fieldmapper::fieldmap->{$note->class_name}->{hint};
 148     (my $ihint = $nhint) =~ s/n$//og;
 149
 150     my ($db_note, $item);
 151
 152     if ($note->isnew) {
 153         $db_note = $note;
 154
 155         $item = $e->$item_meth([
 156             $note->item, {
 157                 flesh => 1, flesh_fields => {$ihint => ["bucket"]}
 158             }
 159         ]) or return $e->die_event;
 160     } else {
 161         $db_note = $e->$meth([
 162             $note->id, {
 163                 flesh => 2,
 164                 flesh_fields => {
 165                     $nhint => ['item'],
 166                     $ihint => ['bucket']
 167                 }
 168             }
 169         ]) or return $e->die_event;
 170
 171         $item = $db_note->item;
 172     }
 173
 174     if($item->bucket->owner ne $e->requestor->id) {
 175         return $e->die_event unless $e->allowed("UPDATE_CONTAINER");
 176     }
 177
 178     $meth = 'create_' . $meat if $note->isnew;
 179     $meth = 'update_' . $meat if $note->ischanged;
 180     $meth = 'delete_' . $meat if $note->isdeleted;
 181     return $e->die_event unless $e->$meth($note);
 182     $e->commit;
 183 }
 184
 185
 186 __PACKAGE__->register_method(
 187         method  => "bucket_retrieve_class",
 188         api_name        => "open-ils.actor.container.retrieve_by_class",
 189         argc            => 3,
 190         authoritative   => 1,
 191         notes           => <<"  NOTES");
 192                 Retrieves all un-fleshed buckets by class assigned to given user
 193                 PARAMS(authtoken, bucketOwnerId, class [, type])
 194                 class can be one of "biblio", "callnumber", "copy", "user"
 195                 The optional "type" parameter allows you to limit the search by
 196                 bucket type.
 197                 If bucketOwnerId is not defined, the authtoken is used as the
 198                 bucket owner.
 199                 If requestor ID is different than bucketOwnerId, requestor must have
 200                 VIEW_CONTAINER permissions.
 201         NOTES
 202
 203 sub bucket_retrieve_class {
 204         my( $self, $client, $authtoken, $userid, $class, $type ) = @_;
 205
 206         my( $staff, $user, $evt ) =
 207                 $apputils->checkses_requestor( $authtoken, $userid, 'VIEW_CONTAINER' );
 208         return $evt if $evt;
 209
 210         $logger->debug("User " . $staff->id .
 211                 " retrieving buckets for user $userid [class=$class, type=$type]");
 212
 213         my $meth = $types{$class} . ".search.atomic";
 214         my $buckets;
 215
 216         if( $type ) {
 217                 $buckets = $apputils->simplereq( $svc,
 218                         $meth, { owner => $userid, btype => $type } );
 219         } else {
 220                 $logger->debug("Grabbing buckets by class $class: $svc : $meth :  {owner => $userid}");
 221                 $buckets = $apputils->simplereq( $svc, $meth, { owner => $userid } );
 222         }
 223
 224         return _sort_buckets($buckets);
 225 }
 226
 227 __PACKAGE__->register_method(
 228         method  => "bucket_create",
 229         api_name        => "open-ils.actor.container.create",
 230         notes           => <<"  NOTES");
 231                 Creates a new bucket object.  If requestor is different from
 232                 bucketOwner, requestor needs CREATE_CONTAINER permissions
 233                 PARAMS(authtoken, bucketObject);
 234                 Returns the new bucket object
 235         NOTES
 236
 237 sub bucket_create {
 238         my( $self, $client, $authtoken, $class, $bucket ) = @_;
 239
 240         my $e = new_editor(xact=>1, authtoken=>$authtoken);
 241         return $e->event unless $e->checkauth;
 242
 243         if( $bucket->owner ne $e->requestor->id ) {
 244                 return $e->event unless
 245                         $e->allowed('CREATE_CONTAINER');
 246
 247         } else {
 248                 return $e->event unless
 249                         $e->allowed('CREATE_MY_CONTAINER');
 250         }
 251
 252         $bucket->clear_id;
 253
 254     my $evt = OpenILS::Event->new('CONTAINER_EXISTS',
 255         payload => [$class, $bucket->owner, $bucket->btype, $bucket->name]);
 256     my $search = {name => $bucket->name, owner => $bucket->owner, btype => $bucket->btype};
 257
 258         my $obj;
 259         if( $class eq 'copy' ) {
 260         return $evt if $e->search_container_copy_bucket($search)->[0];
 261                 return $e->event unless
 262                         $obj = $e->create_container_copy_bucket($bucket);
 263         }
 264
 265         if( $class eq 'callnumber' ) {
 266         return $evt if $e->search_container_call_number_bucket($search)->[0];
 267                 return $e->event unless
 268                         $obj = $e->create_container_call_number_bucket($bucket);
 269         }
 270
 271         if( $class eq 'biblio' ) {
 272         return $evt if $e->search_container_biblio_record_entry_bucket($search)->[0];
 273                 return $e->event unless
 274                         $obj = $e->create_container_biblio_record_entry_bucket($bucket);
 275         }
 276
 277         if( $class eq 'user') {
 278         return $evt if $e->search_container_user_bucket($search)->[0];
 279                 return $e->event unless
 280                         $obj = $e->create_container_user_bucket($bucket);
 281         }
 282
 283         $e->commit;
 284         return $obj->id;
 285 }
 286
 287
 288 __PACKAGE__->register_method(
 289         method  => "item_create",
 290         api_name        => "open-ils.actor.container.item.create",
 291     signature => {
 292         desc => q/
 293             Adds one or more items to an existing container
 294         /,
 295         params => [
 296                     {desc => 'Authentication token', type => 'string'},
 297                     {desc => 'Container class.  Can be "copy", "callnumber", "biblio", or "user"', type => 'string'},
 298                     {desc => 'Item or items.  Can either be a single container item object, or an array of them', type => 'object'},
 299         ],
 300         return => {
 301             desc => 'The ID of the newly created item(s).  In batch context, an array of IDs is returned'
 302         }
 303     }
 304 );
 305
 306
 307 sub item_create {
 308         my( $self, $client, $authtoken, $class, $item ) = @_;
 309
 310         my $e = new_editor(xact=>1, authtoken=>$authtoken);
 311         return $e->die_event unless $e->checkauth;
 312     my $items = (ref $item eq 'ARRAY') ? $item : [$item];
 313
 314         my ( $bucket, $evt ) = $apputils->fetch_container_e($e, $item->bucket, $class);
 315         return $evt if $evt;
 316
 317         if( $bucket->owner ne $e->requestor->id ) {
 318                 return $e->die_event unless
 319                         $e->allowed('CREATE_CONTAINER_ITEM');
 320
 321         } else {
 322 #               return $e->event unless
 323 #                       $e->allowed('CREATE_CONTAINER_ITEM'); # new perm here?
 324         }
 325
 326     for my $one_item (@$items) {
 327
 328         $one_item->clear_id;
 329
 330         my $stat;
 331         if( $class eq 'copy' ) {
 332             return $e->die_event unless
 333                 $stat = $e->create_container_copy_bucket_item($one_item);
 334         }
 335
 336         if( $class eq 'callnumber' ) {
 337             return $e->die_event unless
 338                 $stat = $e->create_container_call_number_bucket_item($one_item);
 339         }
 340
 341         if( $class eq 'biblio' ) {
 342             return $e->die_event unless
 343                 $stat = $e->create_container_biblio_record_entry_bucket_item($one_item);
 344         }
 345
 346         if( $class eq 'user') {
 347             return $e->die_event unless
 348                 $stat = $e->create_container_user_bucket_item($one_item);
 349         }
 350     }
 351
 352         $e->commit;
 353
 354     # CStoreEeditor inserts the id (pkey) on newly created objects
 355     return [ map { $_->id } @$items ] if ref $item eq 'ARRAY';
 356         return $item->id;
 357 }
 358
 359
 360
 361 __PACKAGE__->register_method(
 362         method  => "item_delete",
 363         api_name        => "open-ils.actor.container.item.delete",
 364         notes           => <<"  NOTES");
 365                 PARAMS(authtoken, class, itemId)
 366         NOTES
 367
 368 sub item_delete {
 369         my( $self, $client, $authtoken, $class, $itemid ) = @_;
 370
 371         my $e = new_editor(xact=>1, authtoken=>$authtoken);
 372         return $e->event unless $e->checkauth;
 373
 374         my $ret = __item_delete($e, $class, $itemid);
 375         $e->commit unless $U->event_code($ret);
 376         return $ret;
 377 }
 378
 379 sub __item_delete {
 380         my( $e, $class, $itemid ) = @_;
 381         my( $bucket, $item, $evt);
 382
 383         ( $item, $evt ) = $U->fetch_container_item_e( $e, $itemid, $class );
 384         return $evt if $evt;
 385
 386         ( $bucket, $evt ) = $U->fetch_container_e($e, $item->bucket, $class);
 387         return $evt if $evt;
 388
 389         if( $bucket->owner ne $e->requestor->id ) {
 390       my $owner = $e->retrieve_actor_user($bucket->owner)
 391          or return $e->die_event;
 392                 return $e->event unless $e->allowed('DELETE_CONTAINER_ITEM', $owner->home_ou);
 393         }
 394
 395         my $stat;
 396         if( $class eq 'copy' ) {
 397         for my $note (@{$e->search_container_copy_bucket_item_note({item => $item->id})}) {
 398             return $e->event unless
 399                 $e->delete_container_copy_bucket_item_note($note);
 400         }
 401                 return $e->event unless
 402                         $stat = $e->delete_container_copy_bucket_item($item);
 403         }
 404
 405         if( $class eq 'callnumber' ) {
 406         for my $note (@{$e->search_container_call_number_bucket_item_note({item => $item->id})}) {
 407             return $e->event unless
 408                 $e->delete_container_call_number_bucket_item_note($note);
 409         }
 410                 return $e->event unless
 411                         $stat = $e->delete_container_call_number_bucket_item($item);
 412         }
 413
 414         if( $class eq 'biblio' ) {
 415         for my $note (@{$e->search_container_biblio_record_entry_bucket_item_note({item => $item->id})}) {
 416             return $e->event unless
 417                 $e->delete_container_biblio_record_entry_bucket_item_note($note);
 418         }
 419                 return $e->event unless
 420                         $stat = $e->delete_container_biblio_record_entry_bucket_item($item);
 421         }
 422
 423         if( $class eq 'user') {
 424         for my $note (@{$e->search_container_user_bucket_item_note({item => $item->id})}) {
 425             return $e->event unless
 426                 $e->delete_container_user_bucket_item_note($note);
 427         }
 428                 return $e->event unless
 429                         $stat = $e->delete_container_user_bucket_item($item);
 430         }
 431
 432         return $stat;
 433 }
 434
 435
 436 __PACKAGE__->register_method(
 437         method  => 'full_delete',
 438         api_name        => 'open-ils.actor.container.full_delete',
 439         notes           => "Complety removes a container including all attached items",
 440 );
 441
 442 sub full_delete {
 443         my( $self, $client, $authtoken, $class, $containerId ) = @_;
 444         my( $container, $evt);
 445
 446         my $e = new_editor(xact=>1, authtoken=>$authtoken);
 447         return $e->event unless $e->checkauth;
 448
 449         ( $container, $evt ) = $apputils->fetch_container_e($e, $containerId, $class);
 450         return $evt if $evt;
 451
 452         if( $container->owner ne $e->requestor->id ) {
 453       my $owner = $e->retrieve_actor_user($container->owner)
 454          or return $e->die_event;
 455                 return $e->event unless $e->allowed('DELETE_CONTAINER', $owner->home_ou);
 456         }
 457
 458         my $items;
 459
 460         my @s = ({bucket => $containerId}, {idlist=>1});
 461
 462         if( $class eq 'copy' ) {
 463                 $items = $e->search_container_copy_bucket_item(@s);
 464         }
 465
 466         if( $class eq 'callnumber' ) {
 467                 $items = $e->search_container_call_number_bucket_item(@s);
 468         }
 469
 470         if( $class eq 'biblio' ) {
 471                 $items = $e->search_container_biblio_record_entry_bucket_item(@s);
 472         }
 473
 474         if( $class eq 'user') {
 475                 $items = $e->search_container_user_bucket_item(@s);
 476         }
 477
 478         __item_delete($e, $class, $_) for @$items;
 479
 480         my $stat;
 481         if( $class eq 'copy' ) {
 482                 return $e->event unless
 483                         $stat = $e->delete_container_copy_bucket($container);
 484         }
 485
 486         if( $class eq 'callnumber' ) {
 487                 return $e->event unless
 488                         $stat = $e->delete_container_call_number_bucket($container);
 489         }
 490
 491         if( $class eq 'biblio' ) {
 492                 return $e->event unless
 493                         $stat = $e->delete_container_biblio_record_entry_bucket($container);
 494         }
 495
 496         if( $class eq 'user') {
 497                 return $e->event unless
 498                         $stat = $e->delete_container_user_bucket($container);
 499         }
 500
 501         $e->commit;
 502         return $stat;
 503 }
 504
 505 __PACKAGE__->register_method(
 506         method          => 'container_update',
 507         api_name                => 'open-ils.actor.container.update',
 508         signature       => q/
 509                 Updates the given container item.
 510                 @param authtoken The login session key
 511                 @param class The container class
 512                 @param container The container item
 513                 @return true on success, 0 on no update, Event on error
 514                 /
 515 );
 516
 517 sub container_update {
 518         my( $self, $conn, $authtoken, $class, $container )  = @_;
 519
 520         my $e = new_editor(xact=>1, authtoken=>$authtoken);
 521         return $e->event unless $e->checkauth;
 522
 523         my ( $dbcontainer, $evt ) = $U->fetch_container_e($e, $container->id, $class);
 524         return $evt if $evt;
 525
 526         if( $e->requestor->id ne $container->owner ) {
 527                 return $e->event unless $e->allowed('UPDATE_CONTAINER');
 528         }
 529
 530         my $stat;
 531         if( $class eq 'copy' ) {
 532                 return $e->event unless
 533                         $stat = $e->update_container_copy_bucket($container);
 534         }
 535
 536         if( $class eq 'callnumber' ) {
 537                 return $e->event unless
 538                         $stat = $e->update_container_call_number_bucket($container);
 539         }
 540
 541         if( $class eq 'biblio' ) {
 542                 return $e->event unless
 543                         $stat = $e->update_container_biblio_record_entry_bucket($container);
 544         }
 545
 546         if( $class eq 'user') {
 547                 return $e->event unless
 548                         $stat = $e->update_container_user_bucket($container);
 549         }
 550
 551         $e->commit;
 552         return $stat;
 553 }
 554
 555
 556
 557 __PACKAGE__->register_method(
 558         method  => "anon_cache",
 559         api_name        => "open-ils.actor.anon_cache.set_value",
 560     signature => {
 561         desc => q/
 562             Sets a value in the anon web cache.  If the session key is
 563             undefined, one will be automatically generated.
 564         /,
 565         params => [
 566                     {desc => 'Session key', type => 'string'},
 567             {
 568                 desc => q/Field name.  The name of the field in this cache session whose value to set/,
 569                 type => 'string'
 570             },
 571             {
 572                 desc => q/The cached value.  This can be any type of object (hash, array, string, etc.)/,
 573                 type => 'any'
 574             },
 575         ],
 576         return => {
 577             desc => 'session key on success, undef on error',
 578             type => 'string'
 579         }
 580     }
 581 );
 582
 583 __PACKAGE__->register_method(
 584         method  => "anon_cache",
 585         api_name        => "open-ils.actor.anon_cache.get_value",
 586     signature => {
 587         desc => q/
 588             Returns the cached data at the specified field within the specified cache session.
 589         /,
 590         params => [
 591                     {desc => 'Session key', type => 'string'},
 592             {
 593                 desc => q/Field name.  The name of the field in this cache session whose value to set/,
 594                 type => 'string'
 595             },
 596         ],
 597         return => {
 598             desc => 'cached value on success, undef on error',
 599             type => 'any'
 600         }
 601     }
 602 );
 603
 604 __PACKAGE__->register_method(
 605         method  => "anon_cache",
 606         api_name        => "open-ils.actor.anon_cache.delete_session",
 607     signature => {
 608         desc => q/
 609             Deletes a cache session.
 610         /,
 611         params => [
 612                     {desc => 'Session key', type => 'string'},
 613         ],
 614         return => {
 615             desc => 'Session key',
 616             type => 'string'
 617         }
 618     }
 619 );
 620
 621 sub anon_cache {
 622     my($self, $conn, $ses_key, $field_key, $value) = @_;
 623
 624     my $sc = OpenSRF::Utils::SettingsClient->new;
 625         my $cache = OpenSRF::Utils::Cache->new('anon');
 626     my $cache_timeout = $sc->config_value(cache => anon => 'max_cache_time') || 1800; # 30 minutes
 627     my $cache_size = $sc->config_value(cache => anon => 'max_cache_size') || 102400; # 100k
 628
 629     if($self->api_name =~ /delete_session/) {
 630
 631        return $cache->delete_cache($ses_key);
 632
 633     }  elsif( $self->api_name =~ /set_value/ ) {
 634
 635         $ses_key = md5_hex(time . rand($$)) unless $ses_key;
 636         my $blob = $cache->get_cache($ses_key) || {};
 637         $blob->{$field_key} = $value;
 638         return undef if
 639             length(OpenSRF::Utils::JSON->perl2JSON($blob)) > $cache_size; # bytes, characters, whatever ;)
 640         $cache->put_cache($ses_key, $blob, $cache_timeout);
 641         return $ses_key;
 642
 643     } else {
 644
 645         my $blob = $cache->get_cache($ses_key) or return undef;
 646         return $blob if (!defined($field_key));
 647         return $blob->{$field_key};
 648     }
 649 }
 650
 651
 652
 653 1;
 654
 655