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

   1 package OpenILS::Application::Actor::Container;
   2 use base 'OpenSRF::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
  10 my $apputils = "OpenILS::Application::AppUtils";
  11 my $logger = "OpenSRF::Utils::Logger";
  12
  13 sub initialize { return 1; }
  14
  15 my $svc = 'open-ils.storage';
  16 my $meth = 'open-ils.storage.direct.container';
  17 my %types;
  18 $types{'biblio'} = "$meth.biblio_record_entry_bucket";
  19 $types{'callnumber'} = "$meth.call_number_bucket";
  20 $types{'copy'} = "$meth.copy_bucket";
  21 $types{'user'} = "$meth.user_bucket";
  22 my $event;
  23
  24 sub _sort_buckets {
  25         my $buckets = shift;
  26         return $buckets unless ($buckets && $buckets->[0]);
  27         return [ sort { $a->name cmp $b->name } @$buckets ];
  28 }
  29
  30 __PACKAGE__->register_method(
  31         method  => "bucket_retrieve_all",
  32         api_name        => "open-ils.actor.container.all.retrieve_by_user",
  33         notes           => <<"  NOTES");
  34                 Retrieves all un-fleshed buckets assigned to given user
  35                 PARAMS(authtoken, bucketOwnerId)
  36                 If requestor ID is different than bucketOwnerId, requestor must have
  37                 VIEW_CONTAINER permissions.
  38         NOTES
  39
  40 sub bucket_retrieve_all {
  41         my($self, $client, $authtoken, $userid) = @_;
  42
  43         my( $staff, $evt ) = $apputils->checkses($authtoken);
  44         return $evt if $evt;
  45
  46         my( $user, $e ) = $apputils->checkrequestor( $staff, $userid, 'VIEW_CONTAINER');
  47         return $e if $e;
  48
  49         $logger->debug("User " . $staff->id .
  50                 " retrieving all buckets for user $userid");
  51
  52         my %buckets;
  53
  54         $buckets{$_} = $apputils->simplereq(
  55                 $svc, $types{$_} . ".search.owner.atomic", $userid ) for keys %types;
  56
  57         return \%buckets;
  58 }
  59
  60 __PACKAGE__->register_method(
  61         method  => "bucket_flesh",
  62         api_name        => "open-ils.actor.container.flesh",
  63         argc            => 3,
  64         notes           => <<"  NOTES");
  65                 Fleshes a bucket by id
  66                 PARAMS(authtoken, bucketClass, bucketId)
  67                 bucketclasss include biblio, callnumber, copy, and user.
  68                 bucketclass defaults to biblio.
  69                 If requestor ID is different than bucketOwnerId, requestor must have
  70                 VIEW_CONTAINER permissions.
  71         NOTES
  72
  73 sub bucket_flesh {
  74
  75         my($self, $client, $authtoken, $class, $bucket) = @_;
  76
  77         my( $staff, $evt ) = $apputils->checkses($authtoken);
  78         return $evt if $evt;
  79
  80         $logger->debug("User " . $staff->id . " retrieving bucket $bucket");
  81
  82         my $meth = $types{$class};
  83
  84         my $bkt = $apputils->simplereq( $svc, "$meth.retrieve", $bucket );
  85         if(!$bkt) {return undef};
  86
  87         my( $user, $e ) = $apputils->checkrequestor( $staff, $bkt->owner, 'VIEW_CONTAINER' );
  88         return $e if $e;
  89
  90         $bkt->items( $apputils->simplereq( $svc,
  91                 "$meth"."_item.search.bucket.atomic", $bucket ) );
  92
  93         return $bkt;
  94 }
  95
  96
  97 __PACKAGE__->register_method(
  98         method  => "bucket_flesh_public",
  99         api_name        => "open-ils.actor.container.public.flesh",
 100         argc            => 3,
 101         notes           => <<"  NOTES");
 102                 Fleshes a bucket by id
 103                 PARAMS(authtoken, bucketClass, bucketId)
 104                 bucketclasss include biblio, callnumber, copy, and user.
 105                 bucketclass defaults to biblio.
 106                 If requestor ID is different than bucketOwnerId, requestor must have
 107                 VIEW_CONTAINER permissions.
 108         NOTES
 109
 110 sub bucket_flesh_public {
 111
 112         my($self, $client, $class, $bucket) = @_;
 113
 114         my $meth = $types{$class};
 115         my $bkt = $apputils->simplereq( $svc, "$meth.retrieve", $bucket );
 116         return undef unless ($bkt and $bkt->public);
 117
 118         $bkt->items( $apputils->simplereq( $svc,
 119                 "$meth"."_item.search.bucket.atomic", $bucket ) );
 120
 121         return $bkt;
 122 }
 123
 124
 125 __PACKAGE__->register_method(
 126         method  => "bucket_retrieve_class",
 127         api_name        => "open-ils.actor.container.retrieve_by_class",
 128         argc            => 3,
 129         notes           => <<"  NOTES");
 130                 Retrieves all un-fleshed buckets by class assigned to given user
 131                 PARAMS(authtoken, bucketOwnerId, class [, type])
 132                 class can be one of "biblio", "callnumber", "copy", "user"
 133                 The optional "type" parameter allows you to limit the search by
 134                 bucket type.
 135                 If bucketOwnerId is not defined, the authtoken is used as the
 136                 bucket owner.
 137                 If requestor ID is different than bucketOwnerId, requestor must have
 138                 VIEW_CONTAINER permissions.
 139         NOTES
 140
 141 sub bucket_retrieve_class {
 142         my( $self, $client, $authtoken, $userid, $class, $type ) = @_;
 143
 144         my( $staff, $user, $evt ) =
 145                 $apputils->checkses_requestor( $authtoken, $userid, 'VIEW_CONTAINER' );
 146         return $evt if $evt;
 147
 148         $logger->debug("User " . $staff->id .
 149                 " retrieving buckets for user $userid [class=$class, type=$type]");
 150
 151         my $meth = $types{$class} . ".search_where.atomic";
 152         my $buckets;
 153
 154         if( $type ) {
 155                 $buckets = $apputils->simplereq( $svc,
 156                         $meth, { owner => $userid, btype => $type } );
 157         } else {
 158                 $logger->debug("Grabbing buckets by class $class: $svc : $meth :  {owner => $userid}");
 159                 $buckets = $apputils->simplereq( $svc, $meth, { owner => $userid } );
 160         }
 161
 162         return _sort_buckets($buckets);
 163 }
 164
 165 __PACKAGE__->register_method(
 166         method  => "bucket_create",
 167         api_name        => "open-ils.actor.container.create",
 168         notes           => <<"  NOTES");
 169                 Creates a new bucket object.  If requestor is different from
 170                 bucketOwner, requestor needs CREATE_CONTAINER permissions
 171                 PARAMS(authtoken, bucketObject);
 172                 Returns the new bucket object
 173         NOTES
 174
 175 sub bucket_create {
 176         my( $self, $client, $authtoken, $class, $bucket ) = @_;
 177
 178         my( $staff, $target, $evt ) =
 179                 $apputils->checkses_requestor(
 180                         $authtoken, $bucket->owner, 'CREATE_CONTAINER' );
 181         return $evt if $evt;
 182
 183         $logger->activity( "User " . $staff->id .
 184                 " creating a new continer for user " . $bucket->owner );
 185
 186         $bucket->clear_id;
 187         $logger->debug("Creating new container object: " . Dumper($bucket));
 188
 189         my $method = $types{$class} . ".create";
 190         my $id = $apputils->simplereq( $svc, $method, $bucket );
 191
 192         $logger->debug("Creatined new container with id $id");
 193
 194         if(!$id) { throw OpenSRF::EX
 195                 ("Unable to create new bucket object"); }
 196
 197         return $id;
 198 }
 199
 200
 201 __PACKAGE__->register_method(
 202         method  => "bucket_delete",
 203         api_name        => "open-ils.actor.container.delete",
 204         notes           => <<"  NOTES");
 205                 Deletes a bucket object.  If requestor is different from
 206                 bucketOwner, requestor needs DELETE_CONTAINER permissions
 207                 PARAMS(authtoken, class, bucketId);
 208                 Returns the new bucket object
 209         NOTES
 210
 211 sub bucket_delete {
 212         my( $self, $client, $authtoken, $class, $bucketid ) = @_;
 213
 214         my( $bucket, $staff, $target, $evt );
 215
 216         ( $bucket, $evt ) = $apputils->fetch_container($bucketid, $class);
 217         return $evt if $evt;
 218
 219         ( $staff, $target, $evt ) = $apputils->checkses_requestor(
 220                 $authtoken, $bucket->owner, 'DELETE_CONTAINER' );
 221         return $evt if $evt;
 222
 223         $logger->activity( "User " . $staff->id .
 224                 " deleting continer $bucketid for user " . $bucket->owner );
 225
 226         my $method = $types{$class} . ".delete";
 227         my $resp = $apputils->simplereq( $svc, $method, $bucketid );
 228
 229         throw OpenSRF::EX ("Unable to create new bucket object") unless $resp;
 230         return $resp;
 231 }
 232
 233
 234 __PACKAGE__->register_method(
 235         method  => "item_create",
 236         api_name        => "open-ils.actor.container.item.create",
 237         notes           => <<"  NOTES");
 238                 PARAMS(authtoken, class, item)
 239         NOTES
 240
 241 sub item_create {
 242         my( $self, $client, $authtoken, $class, $item ) = @_;
 243         my( $bucket, $staff, $target, $evt);
 244
 245         ( $bucket, $evt ) = $apputils->fetch_container($item->bucket, $class);
 246         return $evt if $evt;
 247
 248         ( $staff, $target, $evt ) = $apputils->checkses_requestor(
 249                 $authtoken, $bucket->owner, 'CREATE_CONTAINER_ITEM' );
 250         return $evt if $evt;
 251
 252         $logger->activity( "User " . $staff->id .
 253                 " creating continer item  " . Dumper($item) . " for user " . $bucket->owner );
 254
 255         my $method = $types{$class} . "_item.create";
 256         my $resp = $apputils->simplereq( $svc, $method, $item );
 257
 258         throw OpenSRF::EX ("Unable to create container item") unless $resp;
 259         return $resp;
 260 }
 261
 262
 263
 264 __PACKAGE__->register_method(
 265         method  => "item_delete",
 266         api_name        => "open-ils.actor.container.item.delete",
 267         notes           => <<"  NOTES");
 268                 PARAMS(authtoken, class, itemId)
 269         NOTES
 270
 271 sub item_delete {
 272         my( $self, $client, $authtoken, $class, $itemid ) = @_;
 273         my( $bucket, $item, $staff, $target, $evt);
 274
 275
 276         ( $item, $evt ) = $apputils->fetch_container_item( $itemid, $class );
 277         return $evt if $evt;
 278
 279         ( $bucket, $evt ) = $apputils->fetch_container($item->bucket, $class);
 280         return $evt if $evt;
 281
 282         ( $staff, $target, $evt ) = $apputils->checkses_requestor(
 283                 $authtoken, $bucket->owner, 'DELETE_CONTAINER_ITEM' );
 284         return $evt if $evt;
 285
 286         $logger->activity( "User " . $staff->id .
 287                 " deleting continer item  $itemid for user " . $bucket->owner );
 288
 289         my $method = $types{$class} . "_item.delete";
 290         my $resp = $apputils->simplereq( $svc, $method, $itemid );
 291
 292         throw OpenSRF::EX ("Unable to delete container item") unless $resp;
 293         return $resp;
 294 }
 295
 296 __PACKAGE__->register_method(
 297         method  => 'full_delete',
 298         api_name        => 'open-ils.actor.container.full_delete',
 299         notes           => "Complety removes a container including all attached items",
 300 );
 301
 302 sub full_delete {
 303         my( $self, $client, $authtoken, $class, $containerId ) = @_;
 304         my( $staff, $target, $container, $evt);
 305
 306         ( $container, $evt ) = $apputils->fetch_container($containerId, $class);
 307         return $evt if $evt;
 308
 309         ( $staff, $target, $evt ) = $apputils->checkses_requestor(
 310                 $authtoken, $container->owner, 'DELETE_CONTAINER' );
 311         return $evt if $evt;
 312
 313         $logger->activity("User " . $staff->id . " deleting full container $containerId");
 314
 315         my $meth = $types{$class};
 316         my $items = $apputils->simplereq( $svc, "$meth"."_item.search.bucket.atomic", $containerId );
 317
 318         $self->item_delete( $client, $authtoken, $class, $_->id ) for @$items;
 319
 320         $meth = $types{$class} . ".delete";
 321         return $apputils->simplereq( $svc, $meth, $containerId );
 322 }
 323
 324
 325
 326 1;
 327
 328