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 __PACKAGE__->register_method(
  25         method  => "bucket_retrieve_all",
  26         api_name        => "open-ils.actor.container.all.retrieve_by_user",
  27         notes           => <<"  NOTES");
  28                 Retrieves all un-fleshed buckets assigned to given user
  29                 PARAMS(authtoken, bucketOwnerId)
  30                 If requestor ID is different than bucketOwnerId, requestor must have
  31                 VIEW_CONTAINER permissions.
  32         NOTES
  33
  34 sub bucket_retrieve_all {
  35         my($self, $client, $authtoken, $userid) = @_;
  36
  37         my( $staff, $evt ) = $apputils->checkses($authtoken);
  38         return $evt if $evt;
  39
  40         my( $user, $e ) = $apputils->checkrequestor( $staff, $userid, 'VIEW_CONTAINER');
  41         return $e if $e;
  42
  43         $logger->debug("User " . $staff->id .
  44                 " retrieving all buckets for user $userid");
  45
  46         my %buckets;
  47
  48         $buckets{$_} = $apputils->simplereq(
  49                 $svc, $types{$_} . ".search.owner.atomic", $userid ) for keys %types;
  50
  51         return \%buckets;
  52 }
  53
  54 __PACKAGE__->register_method(
  55         method  => "bucket_flesh",
  56         api_name        => "open-ils.actor.container.flesh",
  57         argc            => 3,
  58         notes           => <<"  NOTES");
  59                 Fleshes a bucket by id
  60                 PARAMS(authtoken, bucketClass, bucketId)
  61                 bucketclasss include biblio, callnumber, copy, and user.
  62                 bucketclass defaults to biblio.
  63                 If requestor ID is different than bucketOwnerId, requestor must have
  64                 VIEW_CONTAINER permissions.
  65         NOTES
  66
  67 sub bucket_flesh {
  68
  69         my($self, $client, $authtoken, $class, $bucket) = @_;
  70
  71         my( $staff, $evt ) = $apputils->checkses($authtoken);
  72         return $evt if $evt;
  73
  74         $logger->debug("User " . $staff->id . " retrieving bucket $bucket");
  75
  76         my $meth = $types{$class};
  77
  78         my $bkt = $apputils->simplereq( $svc, "$meth.retrieve", $bucket );
  79         if(!$bkt) {return undef};
  80
  81         my( $user, $e ) = $apputils->checkrequestor( $staff, $bkt->owner, 'VIEW_CONTAINER' );
  82         return $e if $e;
  83
  84         $bkt->items( $apputils->simplereq( $svc,
  85                 "$meth"."_item.search.bucket.atomic", $bucket ) );
  86
  87         return $bkt;
  88 }
  89
  90
  91 __PACKAGE__->register_method(
  92         method  => "bucket_retrieve_class",
  93         api_name        => "open-ils.actor.container.retrieve_by_class",
  94         argc            => 3,
  95         notes           => <<"  NOTES");
  96                 Retrieves all un-fleshed buckets by class assigned to given user
  97                 PARAMS(authtoken, bucketOwnerId, class [, type])
  98                 class can be one of "biblio", "callnumber", "copy", "user"
  99                 The optional "type" parameter allows you to limit the search by
 100                 bucket type.
 101                 If bucketOwnerId is not defined, the authtoken is used as the
 102                 bucket owner.
 103                 If requestor ID is different than bucketOwnerId, requestor must have
 104                 VIEW_CONTAINER permissions.
 105         NOTES
 106
 107 sub bucket_retrieve_class {
 108         my( $self, $client, $authtoken, $userid, $class, $type ) = @_;
 109
 110         my( $staff, $user, $evt );
 111         ($staff, $evt) = $apputils->checkses($authtoken);
 112         return $evt if $evt;
 113
 114         ($user, $evt) = $apputils->checkrequestor($staff, $userid, 'VIEW_CONTAINER');
 115         return $evt if $evt;
 116
 117         $logger->debug("User " . $staff->id .
 118                 " retrieving buckets for user $userid [class=$class, type=$type]");
 119
 120         my $meth = $types{$class} . ".search_where.atomic";
 121         my $buckets;
 122
 123         if( $type ) {
 124                 $buckets = $apputils->simplereq( $svc,
 125                         $meth, { owner => $userid, btype => $type } );
 126         } else {
 127                 $logger->debug("Grabbing buckets by class $class: $svc : $meth :  {owner => $userid}");
 128                 $buckets = $apputils->simplereq( $svc, $meth, { owner => $userid } );
 129         }
 130
 131         return $buckets;
 132 }
 133
 134 __PACKAGE__->register_method(
 135         method  => "bucket_create",
 136         api_name        => "open-ils.actor.container.create",
 137         notes           => <<"  NOTES");
 138                 Creates a new bucket object.  If requestor is different from
 139                 bucketOwner, requestor needs CREATE_CONTAINER permissions
 140                 PARAMS(authtoken, bucketObject);
 141                 Returns the new bucket object
 142         NOTES
 143
 144 sub bucket_create {
 145         my( $self, $client, $authtoken, $class, $bucket ) = @_;
 146
 147         my( $staff, $target, $evt ) =
 148                 $apputils->checkses_requestor(
 149                         $authtoken, $bucket->owner, 'CREATE_CONTAINER' );
 150         return $evt if $evt;
 151
 152         $logger->activity( "User " . $staff->id .
 153                 " creating a new continer for user " . $bucket->owner );
 154
 155         $logger->debug("Creating new container object: " . Dumper($bucket));
 156
 157         my $method = $types{$class} . ".create";
 158         my $id = $apputils->simplereq( $svc, $method, $bucket );
 159
 160         $logger->debug("Creatined new container with id $id");
 161
 162         if(!$id) { throw OpenSRF::EX
 163                 ("Unable to create new bucket object"); }
 164
 165         return $id;
 166 }
 167
 168
 169 __PACKAGE__->register_method(
 170         method  => "bucket_delete",
 171         api_name        => "open-ils.actor.container.delete",
 172         notes           => <<"  NOTES");
 173                 Deletes a bucket object.  If requestor is different from
 174                 bucketOwner, requestor needs DELETE_CONTAINER permissions
 175                 PARAMS(authtoken, class, bucketId);
 176                 Returns the new bucket object
 177         NOTES
 178
 179 sub bucket_delete {
 180         my( $self, $client, $authtoken, $class, $bucketid ) = @_;
 181
 182         my( $bucket, $staff, $target, $evt );
 183
 184         ( $bucket, $evt ) = $apputils->fetch_container($bucketid, $class);
 185         return $evt if $evt;
 186
 187         ( $staff, $target, $evt ) = $apputils->checkses_requestor(
 188                 $authtoken, $bucket->owner, 'DELETE_CONTAINER' );
 189         return $evt if $evt;
 190
 191         $logger->activity( "User " . $staff->id .
 192                 " deleting continer $bucketid for user " . $bucket->owner );
 193
 194         my $method = $types{$class} . ".delete";
 195         my $resp = $apputils->simplereq( $svc, $method, $bucketid );
 196
 197         throw OpenSRF::EX ("Unable to create new bucket object") unless $resp;
 198         return $resp;
 199 }
 200
 201
 202 __PACKAGE__->register_method(
 203         method  => "item_create",
 204         api_name        => "open-ils.actor.container.item.create",
 205         notes           => <<"  NOTES");
 206                 PARAMS(authtoken, class, item)
 207         NOTES
 208
 209 sub item_create {
 210         my( $self, $client, $authtoken, $class, $item ) = @_;
 211         my( $bucket, $staff, $target, $evt);
 212
 213         ( $bucket, $evt ) = $apputils->fetch_container($item->bucket, $class);
 214         return $evt if $evt;
 215
 216         ( $staff, $target, $evt ) = $apputils->checkses_requestor(
 217                 $authtoken, $bucket->owner, 'CREATE_CONTAINER_ITEM' );
 218         return $evt if $evt;
 219
 220         $logger->activity( "User " . $staff->id .
 221                 " creating continer item  " . Dumper($item) . " for user " . $bucket->owner );
 222
 223         my $method = $types{$class} . "_item.create";
 224         my $resp = $apputils->simplereq( $svc, $method, $item );
 225
 226         throw OpenSRF::EX ("Unable to create container item") unless $resp;
 227         return $resp;
 228 }
 229
 230
 231
 232 __PACKAGE__->register_method(
 233         method  => "item_delete",
 234         api_name        => "open-ils.actor.container.item.delete",
 235         notes           => <<"  NOTES");
 236                 PARAMS(authtoken, class, itemId)
 237         NOTES
 238
 239 sub item_delete {
 240         my( $self, $client, $authtoken, $class, $itemid ) = @_;
 241         my( $bucket, $item, $staff, $target, $evt);
 242
 243
 244         ( $item, $evt ) = $apputils->fetch_container_item( $itemid, $class );
 245         return $evt if $evt;
 246         ( $bucket, $evt ) = $apputils->fetch_container($item->bucket, $class);
 247         return $evt if $evt;
 248
 249         ( $staff, $target, $evt ) = $apputils->checkses_requestor(
 250                 $authtoken, $bucket->owner, 'DELETE_CONTAINER_ITEM' );
 251         return $evt if $evt;
 252
 253         $logger->activity( "User " . $staff->id .
 254                 " deleting continer item  $itemid for user " . $bucket->owner );
 255
 256         my $method = $types{$class} . "_item.delete";
 257         my $resp = $apputils->simplereq( $svc, $method, $itemid );
 258
 259         throw OpenSRF::EX ("Unable to delete container item") unless $resp;
 260         return $resp;
 261 }
 262
 263
 264
 265 1;
 266
 267