Koha/REST/V1/Holds.pm

   1 package Koha::REST::V1::Holds;
   2
   3 # This file is part of Koha.
   4 #
   5 # Koha is free software; you can redistribute it and/or modify it under the
   6 # terms of the GNU General Public License as published by the Free Software
   7 # Foundation; either version 3 of the License, or (at your option) any later
   8 # version.
   9 #
  10 # Koha is distributed in the hope that it will be useful, but WITHOUT ANY
  11 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  12 # A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU General Public License along
  15 # with Koha; if not, write to the Free Software Foundation, Inc.,
  16 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  17
  18 use Modern::Perl;
  19
  20 use Mojo::Base 'Mojolicious::Controller';
  21
  22 use C4::Biblio;
  23 use C4::Reserves;
  24
  25 use Koha::Items;
  26 use Koha::Patrons;
  27 use Koha::Holds;
  28 use Koha::DateUtils;
  29
  30 use Try::Tiny;
  31
  32 =head1 API
  33
  34 =head2 Class methods
  35
  36 =head3 list
  37
  38 Mehtod that handles listing Koha::Hold objects
  39
  40 =cut
  41
  42 sub list {
  43     my $c = shift->openapi->valid_input or return;
  44
  45     return try {
  46         my $holds_set = Koha::Holds->new;
  47         my $holds     = $c->objects->search( $holds_set, \&_to_model, \&_to_api );
  48         return $c->render( status => 200, openapi => $holds );
  49     }
  50     catch {
  51         if ( blessed $_ && $_->isa('Koha::Exceptions') ) {
  52             return $c->render(
  53                 status  => 500,
  54                 openapi => { error => "$_" }
  55             );
  56         }
  57         else {
  58             return $c->render(
  59                 status  => 500,
  60                 openapi => { error => "Something went wrong, check Koha logs for details." }
  61             );
  62         }
  63     };
  64 }
  65
  66 =head3 add
  67
  68 Method that handles adding a new Koha::Hold object
  69
  70 =cut
  71
  72 sub add {
  73     my $c = shift->openapi->valid_input or return;
  74
  75     return try {
  76         my $body = $c->validation->param('body');
  77
  78         my $biblio;
  79
  80         my $biblio_id         = $body->{biblio_id};
  81         my $pickup_library_id = $body->{pickup_library_id};
  82         my $item_id           = $body->{item_id};
  83         my $patron_id         = $body->{patron_id};
  84         my $item_type         = $body->{item_type};
  85         my $expiration_date   = $body->{expiration_date};
  86         my $notes             = $body->{notes};
  87         my $hold_date         = $body->{hold_date};
  88
  89         if(!C4::Context->preference( 'AllowHoldDateInFuture' ) && $hold_date) {
  90             return $c->render(
  91                 status  => 400,
  92                 openapi => { error => "Hold date in future not allowed" }
  93             );
  94         }
  95
  96         if ( $item_id and $biblio_id ) {
  97
  98             # check they are consistent
  99             unless ( Koha::Items->search( { itemnumber => $item_id, biblionumber => $biblio_id } )
 100                 ->count > 0 )
 101             {
 102                 return $c->render(
 103                     status  => 400,
 104                     openapi => { error => "Item $item_id doesn't belong to biblio $biblio_id" }
 105                 );
 106             }
 107             else {
 108                 $biblio = Koha::Biblios->find($biblio_id);
 109             }
 110         }
 111         elsif ($item_id) {
 112             my $item = Koha::Items->find($item_id);
 113
 114             unless ($item) {
 115                 return $c->render(
 116                     status  => 404,
 117                     openapi => { error => "item_id not found." }
 118                 );
 119             }
 120             else {
 121                 $biblio = $item->biblio;
 122             }
 123         }
 124         elsif ($biblio_id) {
 125             $biblio = Koha::Biblios->find($biblio_id);
 126         }
 127         else {
 128             return $c->render(
 129                 status  => 400,
 130                 openapi => { error => "At least one of biblio_id, item_id should be given" }
 131             );
 132         }
 133
 134         unless ($biblio) {
 135             return $c->render(
 136                 status  => 400,
 137                 openapi => "Biblio not found."
 138             );
 139         }
 140
 141         my $can_place_hold
 142             = $item_id
 143             ? C4::Reserves::CanItemBeReserved( $patron_id, $item_id )
 144             : C4::Reserves::CanBookBeReserved( $patron_id, $biblio_id );
 145
 146         my $can_override = C4::Context->preference('AllowHoldPolicyOverride');
 147
 148         unless ($can_override || $can_place_hold->{status} eq 'OK' ) {
 149             return $c->render(
 150                 status => 403,
 151                 openapi =>
 152                     { error => "Hold cannot be placed. Reason: " . $can_place_hold->{status} }
 153             );
 154         }
 155
 156         my $priority = C4::Reserves::CalculatePriority($biblio_id);
 157
 158         # AddReserve expects date to be in syspref format
 159         if ($expiration_date) {
 160             $expiration_date = output_pref( dt_from_string( $expiration_date, 'rfc3339' ) );
 161         }
 162
 163         my $hold_id = C4::Reserves::AddReserve(
 164             $pickup_library_id,
 165             $patron_id,
 166             $biblio_id,
 167             undef,    # $bibitems param is unused
 168             $priority,
 169             $hold_date,
 170             $expiration_date,
 171             $notes,
 172             $biblio->title,
 173             $item_id,
 174             undef,    # TODO: Why not?
 175             $item_type
 176         );
 177
 178         unless ($hold_id) {
 179             return $c->render(
 180                 status  => 500,
 181                 openapi => 'Error placing the hold. See Koha logs for details.'
 182             );
 183         }
 184
 185         my $hold = Koha::Holds->find($hold_id);
 186
 187         return $c->render( status => 201, openapi => _to_api($hold->TO_JSON) );
 188     }
 189     catch {
 190         if ( blessed $_ and $_->isa('Koha::Exceptions') ) {
 191             if ( $_->isa('Koha::Exceptions::Object::FKConstraint') ) {
 192                 my $broken_fk = $_->broken_fk;
 193
 194                 if ( grep { $_ eq $broken_fk } keys %{$Koha::REST::V1::Holds::to_api_mapping} ) {
 195                     $c->render(
 196                         status  => 404,
 197                         openapi => $Koha::REST::V1::Holds::to_api_mapping->{$broken_fk} . ' not found.'
 198                     );
 199                 }
 200                 else {
 201                     return $c->render(
 202                         status  => 500,
 203                         openapi => { error => "Uncaught exception: $_" }
 204                     );
 205                 }
 206             }
 207             else {
 208                 return $c->render(
 209                     status  => 500,
 210                     openapi => { error => "$_" }
 211                 );
 212             }
 213         }
 214         else {
 215             return $c->render(
 216                 status  => 500,
 217                 openapi => { error => "Something went wrong. check the logs." }
 218             );
 219         }
 220     };
 221 }
 222
 223 =head3 edit
 224
 225 Method that handles modifying a Koha::Hold object
 226
 227 =cut
 228
 229 sub edit {
 230     my $c = shift->openapi->valid_input or return;
 231
 232     my $hold_id = $c->validation->param('hold_id');
 233     my $hold = Koha::Holds->find( $hold_id );
 234
 235     unless ($hold) {
 236         return $c->render( status  => 404,
 237                            openapi => {error => "Hold not found"} );
 238     }
 239
 240     my $body = $c->req->json;
 241
 242     my $pickup_library_id = $body->{pickup_library_id};
 243     my $priority          = $body->{priority};
 244     my $suspended_until   = $body->{suspended_until};
 245
 246     if ($suspended_until) {
 247         $suspended_until = output_pref(dt_from_string($suspended_until, 'rfc3339'));
 248     }
 249
 250     my $params = {
 251         reserve_id    => $hold_id,
 252         branchcode    => $pickup_library_id,
 253         rank          => $priority,
 254         suspend_until => $suspended_until,
 255         itemnumber    => $hold->itemnumber
 256     };
 257
 258     C4::Reserves::ModReserve($params);
 259     $hold->discard_changes; # refresh
 260
 261     return $c->render( status => 200, openapi => _to_api( $hold->TO_JSON ) );
 262 }
 263
 264 =head3 delete
 265
 266 Method that handles deleting a Koha::Hold object
 267
 268 =cut
 269
 270 sub delete {
 271     my $c = shift->openapi->valid_input or return;
 272
 273     my $hold_id = $c->validation->param('hold_id');
 274     my $hold    = Koha::Holds->find($hold_id);
 275
 276     unless ($hold) {
 277         return $c->render( status => 404, openapi => { error => "Hold not found." } );
 278     }
 279
 280     $hold->cancel;
 281
 282     return $c->render( status => 200, openapi => {} );
 283 }
 284
 285 =head3 suspend
 286
 287 Method that handles suspending a hold
 288
 289 =cut
 290
 291 sub suspend {
 292     my $c = shift->openapi->valid_input or return;
 293
 294     my $hold_id  = $c->validation->param('hold_id');
 295     my $hold     = Koha::Holds->find($hold_id);
 296     my $body     = $c->req->json;
 297     my $end_date = ($body) ? $body->{end_date} : undef;
 298
 299     unless ($hold) {
 300         return $c->render( status => 404, openapi => { error => 'Hold not found.' } );
 301     }
 302
 303     return try {
 304         my $date = ($end_date) ? dt_from_string( $end_date, 'rfc3339' ) : undef;
 305         $hold->suspend_hold($date);
 306         $hold->discard_changes;
 307         $c->res->headers->location( $c->req->url->to_string );
 308         return $c->render(
 309             status  => 201,
 310             openapi => {
 311                 end_date => output_pref(
 312                     {   dt         => dt_from_string( $hold->suspend_until ),
 313                         dateformat => 'rfc3339',
 314                         dateonly   => 1
 315                     }
 316                 )
 317             }
 318         );
 319     }
 320     catch {
 321         if ( blessed $_ and $_->isa('Koha::Exceptions::Hold::CannotSuspendFound') ) {
 322             return $c->render( status => 400, openapi => { error => "$_" } );
 323         }
 324         else {
 325             return $c->render(
 326                 status  => 500,
 327                 openapi => { error => "Something went wrong. check the logs." }
 328             );
 329         }
 330     };
 331 }
 332
 333 =head3 resume
 334
 335 Method that handles resuming a hold
 336
 337 =cut
 338
 339 sub resume {
 340     my $c = shift->openapi->valid_input or return;
 341
 342     my $hold_id = $c->validation->param('hold_id');
 343     my $hold    = Koha::Holds->find($hold_id);
 344     my $body    = $c->req->json;
 345
 346     unless ($hold) {
 347         return $c->render( status => 404, openapi => { error => 'Hold not found.' } );
 348     }
 349
 350     return try {
 351         $hold->resume;
 352         return $c->render( status => 204, openapi => {} );
 353     }
 354     catch {
 355         return $c->render(
 356             status  => 500,
 357             openapi => { error => "Something went wrong. check the logs." }
 358         );
 359     };
 360 }
 361
 362 =head3 update_priority
 363
 364 Method that handles modifying a Koha::Hold object
 365
 366 =cut
 367
 368 sub update_priority {
 369     my $c = shift->openapi->valid_input or return;
 370
 371     my $hold_id = $c->validation->param('hold_id');
 372     my $hold = Koha::Holds->find($hold_id);
 373
 374     unless ($hold) {
 375         return $c->render(
 376             status  => 404,
 377             openapi => { error => "Hold not found" }
 378         );
 379     }
 380
 381     return try {
 382         my $priority = $c->req->json;
 383         C4::Reserves::_FixPriority(
 384             {
 385                 reserve_id => $hold_id,
 386                 rank       => $priority
 387             }
 388         );
 389
 390         return $c->render( status => 200, openapi => $priority );
 391     }
 392     catch {
 393         return $c->render(
 394             status  => 500,
 395             openapi => { error => "Something went wrong. check the logs." }
 396         );
 397     };
 398 }
 399
 400 =head2 Internal methods
 401
 402 =head3 _to_api
 403
 404 Helper function that maps unblessed Koha::Hold objects into REST api
 405 attribute names.
 406
 407 =cut
 408
 409 sub _to_api {
 410     my $hold = shift;
 411
 412     # Rename attributes
 413     foreach my $column ( keys %{ $Koha::REST::V1::Holds::to_api_mapping } ) {
 414         my $mapped_column = $Koha::REST::V1::Holds::to_api_mapping->{$column};
 415         if (    exists $hold->{ $column }
 416              && defined $mapped_column )
 417         {
 418             # key != undef
 419             $hold->{ $mapped_column } = delete $hold->{ $column };
 420         }
 421         elsif (    exists $hold->{ $column }
 422                 && !defined $mapped_column )
 423         {
 424             # key == undef
 425             delete $hold->{ $column };
 426         }
 427     }
 428
 429     return $hold;
 430 }
 431
 432 =head3 _to_model
 433
 434 Helper function that maps REST api objects into Koha::Hold
 435 attribute names.
 436
 437 =cut
 438
 439 sub _to_model {
 440     my $hold = shift;
 441
 442     foreach my $attribute ( keys %{ $Koha::REST::V1::Holds::to_model_mapping } ) {
 443         my $mapped_attribute = $Koha::REST::V1::Holds::to_model_mapping->{$attribute};
 444         if (    exists $hold->{ $attribute }
 445              && defined $mapped_attribute )
 446         {
 447             # key => !undef
 448             $hold->{ $mapped_attribute } = delete $hold->{ $attribute };
 449         }
 450         elsif (    exists $hold->{ $attribute }
 451                 && !defined $mapped_attribute )
 452         {
 453             # key => undef / to be deleted
 454             delete $hold->{ $attribute };
 455         }
 456     }
 457
 458     if ( exists $hold->{lowestPriority} ) {
 459         $hold->{lowestPriority} = ($hold->{lowestPriority}) ? 1 : 0;
 460     }
 461
 462     if ( exists $hold->{suspend} ) {
 463         $hold->{suspend} = ($hold->{suspend}) ? 1 : 0;
 464     }
 465
 466     if ( exists $hold->{reservedate} ) {
 467         $hold->{reservedate} = output_pref({ str => $hold->{reservedate}, dateformat => 'sql' });
 468     }
 469
 470     if ( exists $hold->{cancellationdate} ) {
 471         $hold->{cancellationdate} = output_pref({ str => $hold->{cancellationdate}, dateformat => 'sql' });
 472     }
 473
 474     if ( exists $hold->{timestamp} ) {
 475         $hold->{timestamp} = output_pref({ str => $hold->{timestamp}, dateformat => 'sql' });
 476     }
 477
 478     if ( exists $hold->{waitingdate} ) {
 479         $hold->{waitingdate} = output_pref({ str => $hold->{waitingdate}, dateformat => 'sql' });
 480     }
 481
 482     if ( exists $hold->{expirationdate} ) {
 483         $hold->{expirationdate} = output_pref({ str => $hold->{expirationdate}, dateformat => 'sql' });
 484     }
 485
 486     if ( exists $hold->{suspend_until} ) {
 487         $hold->{suspend_until} = output_pref({ str => $hold->{suspend_until}, dateformat => 'sql' });
 488     }
 489
 490     return $hold;
 491 }
 492
 493 =head2 Global variables
 494
 495 =head3 $to_api_mapping
 496
 497 =cut
 498
 499 our $to_api_mapping = {
 500     reserve_id       => 'hold_id',
 501     borrowernumber   => 'patron_id',
 502     reservedate      => 'hold_date',
 503     biblionumber     => 'biblio_id',
 504     branchcode       => 'pickup_library_id',
 505     notificationdate => undef,
 506     reminderdate     => undef,
 507     cancellationdate => 'cancelation_date',
 508     reservenotes     => 'notes',
 509     found            => 'status',
 510     itemnumber       => 'item_id',
 511     waitingdate      => 'waiting_date',
 512     expirationdate   => 'expiration_date',
 513     lowestPriority   => 'lowest_priority',
 514     suspend          => 'suspended',
 515     suspend_until    => 'suspended_until',
 516     itemtype         => 'item_type',
 517     item_level_hold  => 'item_level',
 518 };
 519
 520 =head3 $to_model_mapping
 521
 522 =cut
 523
 524 our $to_model_mapping = {
 525     hold_id           => 'reserve_id',
 526     patron_id         => 'borrowernumber',
 527     hold_date         => 'reservedate',
 528     biblio_id         => 'biblionumber',
 529     pickup_library_id => 'branchcode',
 530     cancelation_date  => 'cancellationdate',
 531     notes             => 'reservenotes',
 532     status            => 'found',
 533     item_id           => 'itemnumber',
 534     waiting_date      => 'waitingdate',
 535     expiration_date   => 'expirationdate',
 536     lowest_priority   => 'lowestPriority',
 537     suspended         => 'suspend',
 538     suspended_until   => 'suspend_until',
 539     item_type         => 'itemtype',
 540     item_level        => 'item_level_hold',
 541 };
 542
 543 1;