Koha/REST/V1/ERM/EHoldings/Packages/Manual.pm

   1 package Koha::REST::V1::ERM::EHoldings::Packages::Manual;
   2
   3 use Modern::Perl;
   4
   5 use Mojo::Base 'Mojolicious::Controller';
   6
   7 use Koha::ERM::EHoldings::Packages;
   8
   9 use Scalar::Util qw( blessed );
  10 use Try::Tiny qw( catch try );
  11
  12 sub list {
  13     my $c = shift->openapi->valid_input or return;
  14     return try {
  15         my $packages_set = Koha::ERM::EHoldings::Packages->new;
  16         my $packages     = $c->objects->search($packages_set);
  17         return $c->render( status => 200, openapi => $packages );
  18     }
  19     catch {
  20         $c->unhandled_exception($_);
  21     };
  22 }
  23
  24 sub get {
  25     my $c = shift->openapi->valid_input or return;
  26
  27     return try {
  28         my $package_id = $c->validation->param('package_id');
  29         my $package = $c->objects->find( Koha::ERM::EHoldings::Packages->search,
  30             $package_id );
  31
  32         unless ($package) {
  33             return $c->render(
  34                 status  => 404,
  35                 openapi => { error => "Package not found" }
  36             );
  37         }
  38
  39         return $c->render(
  40             status  => 200,
  41             openapi => $package
  42         );
  43     }
  44     catch {
  45         $c->unhandled_exception($_);
  46     };
  47 }
  48
  49 =head3 add
  50
  51 Controller function that handles adding a new Koha::ERM::EHoldings::Package object
  52
  53 =cut
  54
  55 sub add {
  56     my $c = shift->openapi->valid_input or return;
  57
  58     return try {
  59         Koha::Database->new->schema->txn_do(
  60             sub {
  61
  62                 my $body = $c->validation->param('body');
  63
  64                 my $package_agreements = delete $body->{package_agreements} // [];
  65
  66                 my $package = Koha::ERM::EHoldings::Package->new_from_api($body)->store;
  67                 $package->package_agreements($package_agreements);
  68
  69                 $c->res->headers->location($c->req->url->to_string . '/' . $package->package_id);
  70                 return $c->render(
  71                     status  => 201,
  72                     openapi => $package->to_api
  73                 );
  74             }
  75         );
  76     }
  77     catch {
  78
  79         my $to_api_mapping = Koha::ERM::EHoldings::Package->new->to_api_mapping;
  80
  81         if ( blessed $_ ) {
  82             if ( $_->isa('Koha::Exceptions::Object::DuplicateID') ) {
  83                 return $c->render(
  84                     status  => 409,
  85                     openapi => { error => $_->error, conflict => $_->duplicate_id }
  86                 );
  87             }
  88             elsif ( $_->isa('Koha::Exceptions::Object::FKConstraint') ) {
  89                 return $c->render(
  90                     status  => 400,
  91                     openapi => {
  92                             error => "Given "
  93                             . $to_api_mapping->{ $_->broken_fk }
  94                             . " does not exist"
  95                     }
  96                 );
  97             }
  98             elsif ( $_->isa('Koha::Exceptions::BadParameter') ) {
  99                 return $c->render(
 100                     status  => 400,
 101                     openapi => {
 102                             error => "Given "
 103                             . $to_api_mapping->{ $_->parameter }
 104                             . " does not exist"
 105                     }
 106                 );
 107             }
 108         }
 109
 110         $c->unhandled_exception($_);
 111     };
 112 }
 113
 114 =head3 update
 115
 116 Controller function that handles updating a Koha::ERM::EHoldings::Package object
 117
 118 =cut
 119
 120 sub update {
 121     my $c = shift->openapi->valid_input or return;
 122
 123     my $package_id = $c->validation->param('package_id');
 124     my $package = Koha::ERM::EHoldings::Packages->find( $package_id );
 125
 126     unless ($package) {
 127         return $c->render(
 128             status  => 404,
 129             openapi => { error => "Package not found" }
 130         );
 131     }
 132
 133     return try {
 134         Koha::Database->new->schema->txn_do(
 135             sub {
 136
 137                 my $body = $c->validation->param('body');
 138
 139                 my $package_agreements = delete $body->{package_agreements} // [];
 140
 141                 $package->set_from_api($body)->store;
 142                 $package->package_agreements($package_agreements);
 143
 144                 $c->res->headers->location($c->req->url->to_string . '/' . $package->package_id);
 145                 return $c->render(
 146                     status  => 200,
 147                     openapi => $package->to_api
 148                 );
 149             }
 150         );
 151     }
 152     catch {
 153         my $to_api_mapping = Koha::ERM::EHoldings::Package->new->to_api_mapping;
 154
 155         if ( blessed $_ ) {
 156             if ( $_->isa('Koha::Exceptions::Object::FKConstraint') ) {
 157                 return $c->render(
 158                     status  => 400,
 159                     openapi => {
 160                             error => "Given "
 161                             . $to_api_mapping->{ $_->broken_fk }
 162                             . " does not exist"
 163                     }
 164                 );
 165             }
 166             elsif ( $_->isa('Koha::Exceptions::BadParameter') ) {
 167                 return $c->render(
 168                     status  => 400,
 169                     openapi => {
 170                             error => "Given "
 171                             . $to_api_mapping->{ $_->parameter }
 172                             . " does not exist"
 173                     }
 174                 );
 175             }
 176         }
 177
 178         $c->unhandled_exception($_);
 179     };
 180 };
 181
 182 =head3 delete
 183
 184 =cut
 185
 186 sub delete {
 187     my $c = shift->openapi->valid_input or return;
 188
 189     my $package = Koha::ERM::EHoldings::Packages->find( $c->validation->param('package_id') );
 190     unless ($package) {
 191         return $c->render(
 192             status  => 404,
 193             openapi => { error => "Package not found" }
 194         );
 195     }
 196
 197     return try {
 198         $package->delete;
 199         return $c->render(
 200             status  => 204,
 201             openapi => q{}
 202         );
 203     }
 204     catch {
 205         $c->unhandled_exception($_);
 206     };
 207 }
 208
 209
 210 1;