Open-ILS/src/perlmods/OpenILS/Application/Search.pm

   1 package OpenILS::Application::Search;
   2 use base qw/OpenSRF::Application/;
   3 use strict; use warnings;
   4
   5 use OpenILS::Utils::Fieldmapper;
   6 use OpenILS::Utils::ModsParser;
   7
   8 use OpenILS::Application::Search::StaffClient;
   9 use OpenILS::Application::Search::Web;
  10
  11 use Time::HiRes qw(time);
  12 use OpenSRF::EX qw(:try);
  13
  14 # Houses generic search utilites
  15
  16
  17
  18 __PACKAGE__->register_method(
  19         method  => "biblio_search_marc",
  20         api_name        => "open-ils.search.biblio.marc",
  21         argc            => 1,
  22         note            => "Searches biblio information by marc tag",
  23 );
  24
  25 sub biblio_search_marc {
  26
  27         my( $self, $client, $search_hash, $string ) = @_;
  28
  29         warn "Building biblio marc session\n";
  30         my $session = OpenSRF::AppSession->create("open-ils.storage");
  31
  32         warn "Sending biblio marc request\n";
  33         my $request = $session->request(
  34                         "open-ils.storage.metabib.full_rec.search_fts.index_vector",
  35                         $search_hash, $string );
  36
  37         warn "Waiting complete\n";
  38         $request->wait_complete();
  39
  40         warn "Calling recv\n";
  41         my $response = $request->recv();
  42
  43         warn "out of recv\n";
  44         if($response and UNIVERSAL::isa($response,"OpenSRF::EX")) {
  45                 throw $response ($response->stringify);
  46         }
  47
  48
  49         my $data = [];
  50         if($response and UNIVERSAL::can($response,"content")) {
  51                 $data = $response->content;
  52         }
  53         warn "finishing request\n";
  54
  55         $request->finish();
  56         $session->finish();
  57         $session->disconnect();
  58
  59         return $data;
  60
  61 }
  62
  63
  64
  65 __PACKAGE__->register_method(
  66         method  => "get_org_tree",
  67         api_name        => "open-ils.search.actor.org_tree.retrieve",
  68         argc            => 1,
  69         note            => "Returns the entire org tree structure",
  70 );
  71
  72 sub get_org_tree {
  73
  74         my( $self, $client, $user_session ) = @_;
  75
  76         if( $user_session ) { # keep for now for backwards compatibility
  77
  78                 my $user_obj =
  79                         OpenILS::Application::AppUtils->check_user_session( $user_session ); #throws EX on error
  80
  81                 my $session = OpenSRF::AppSession->create("open-ils.storage");
  82                 my $request = $session->request(
  83                                 "open-ils.storage.actor.org_unit.retrieve", $user_obj->home_ou );
  84                 my $response = $request->recv();
  85
  86                 if(!$response) {
  87                         throw OpenSRF::EX::ERROR (
  88                                         "No response from storage for org_unit retrieve");
  89                 }
  90                 if(UNIVERSAL::isa($response,"Error")) {
  91                         throw $response ($response->stringify);
  92                 }
  93
  94                 my $home_ou = $response->content;
  95                 $request->finish();
  96                 $session->disconnect();
  97
  98                 return $home_ou;
  99         }
 100
 101         return OpenILS::Application::AppUtils->get_org_tree();
 102 }
 103
 104
 105
 106 __PACKAGE__->register_method(
 107         method  => "get_org_sub_tree",
 108         api_name        => "open-ils.search.actor.org_subtree.retrieve",
 109         argc            => 1,
 110         note            => "Returns the entire org tree structure",
 111 );
 112
 113 sub get_sub_org_tree {
 114
 115         my( $self, $client, $user_session ) = @_;
 116
 117         if(!$user_session) {
 118                 throw OpenSRF::EX::InvalidArg
 119                         ("No User session provided to org_subtree.retrieve");
 120         }
 121
 122         if( $user_session ) {
 123
 124                 my $user_obj =
 125                         OpenILS::Application::AppUtils->check_user_session( $user_session ); #throws EX on error
 126
 127
 128                 my $session = OpenSRF::AppSession->create("open-ils.storage");
 129                 my $request = $session->request(
 130                                 "open-ils.storage.actor.org_unit.retrieve", $user_obj->home_ou );
 131                 my $response = $request->recv();
 132
 133                 if(!$response) {
 134                         throw OpenSRF::EX::ERROR (
 135                                         "No response from storage for org_unit retrieve");
 136                 }
 137                 if(UNIVERSAL::isa($response,"Error")) {
 138                         throw $response ($response->stringify);
 139                 }
 140
 141                 my $home_ou = $response->content;
 142
 143                 # XXX grab descendants and build org tree from them
 144 =head comment
 145                 my $request = $session->request(
 146                                 "open-ils.storage.actor.org_unit_descendants" );
 147                 my $response = $request->recv();
 148                 if(!$response) {
 149                         throw OpenSRF::EX::ERROR (
 150                                         "No response from storage for org_unit retrieve");
 151                 }
 152                 if(UNIVERSAL::isa($response,"Error")) {
 153                         throw $response ($response->stringify);
 154                 }
 155
 156                 my $descendants = $response->content;
 157 =cut
 158
 159                 $request->finish();
 160                 $session->disconnect();
 161
 162                 return $home_ou;
 163         }
 164
 165         return undef;
 166
 167 }
 168
 169
 170
 171
 172 # ---------------------------------------------------------------------------
 173 # takes a list of record id's and turns the docs into friendly
 174 # mods structures. Creates one MODS structure for each doc id.
 175 # ---------------------------------------------------------------------------
 176 sub _records_to_mods {
 177         my @ids = @_;
 178
 179         my @results;
 180         my @marcxml_objs;
 181
 182         my $session = OpenSRF::AppSession->create("open-ils.storage");
 183         my $request = $session->request(
 184                         "open-ils.storage.biblio.record_marc.batch.retrieve",  @ids );
 185
 186         my $last_content = undef;
 187
 188         while( my $response = $request->recv() ) {
 189
 190                 if( $last_content ) {
 191                         my $u = OpenILS::Utils::ModsParser->new();
 192                         $u->start_mods_batch( $last_content->marc );
 193                         my $mods = $u->finish_mods_batch();
 194                         $mods->{doc_id} = $last_content->id();
 195                         warn "Turning doc " . $mods->{doc_id} . " into MODS\n";
 196                         $last_content = undef;
 197                         push @results, $mods;
 198                 }
 199
 200                 next unless $response;
 201
 202                 if($response->isa("OpenSRF::EX")) {
 203                         throw $response ($response->stringify);
 204                 }
 205
 206                 $last_content = $response->content;
 207
 208         }
 209
 210         if( $last_content ) {
 211                 my $u = OpenILS::Utils::ModsParser->new();
 212                 $u->start_mods_batch( $last_content->marc );
 213                 my $mods = $u->finish_mods_batch();
 214                 $mods->{doc_id} = $last_content->id();
 215                 push @results, $mods;
 216         }
 217
 218         $request->finish();
 219         $session->finish();
 220         $session->disconnect();
 221
 222         return \@results;
 223
 224 }
 225
 226 __PACKAGE__->register_method(
 227         method  => "record_id_to_mods",
 228         api_name        => "open-ils.search.biblio.record.mods.retrieve",
 229         argc            => 1,
 230         note            => "Provide ID, we provide the mods"
 231 );
 232
 233 # converts a record into a mods object with copy counts attached
 234 sub record_id_to_mods {
 235
 236         my( $self, $client, $org_id, $id ) = @_;
 237
 238         my $mods_list = _records_to_mods( $id );
 239         my $mods_obj = $mods_list->[0];
 240
 241         # --------------------------------------------------------------- # append copy count information to the mods objects
 242         my $session = OpenSRF::AppSession->create("open-ils.storage");
 243
 244         warn "mods retrieve $id\n";
 245
 246         my $request = $session->request(
 247                 "open-ils.storage.biblio.record_copy_count",  $org_id, $id );
 248         warn "mods retrieve wait $id\n";
 249         $request->wait_complete;
 250         warn "mods retrieve recv $id\n";
 251         my $response = $request->recv();
 252         return undef unless $response;
 253         warn "mods retrieve after recv $id\n";
 254
 255         if( $response and UNIVERSAL::isa($response, "Error")) {
 256                 throw $response ($response->stringify);
 257         }
 258
 259         my $count = $response->content;
 260         $mods_obj->{copy_count} = $count;
 261
 262         $request->finish();
 263         $session->finish();
 264         $session->disconnect();
 265
 266         return $mods_obj;
 267 }
 268
 269
 270
 271
 272 1;