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

   1 package OpenILS::Application::Search::Authority;
   2 use base qw/OpenSRF::Application/;
   3 use strict; use warnings;
   4
   5 use OpenILS::EX;
   6
   7 use OpenILS::Utils::Fieldmapper;
   8 use OpenILS::Application::AppUtils;
   9
  10 use JSON;
  11
  12 use Time::HiRes qw(time);
  13 use OpenSRF::EX qw(:try);
  14 use Digest::MD5 qw(md5_hex);
  15
  16 sub crossref_authority {
  17         my $self = shift;
  18         my $client = shift;
  19         my $class = shift;
  20         my $term = shift;
  21
  22         my $session = OpenSRF::AppSession->create("open-ils.storage");
  23         $session->connect;
  24
  25         my $freq = $session->request(
  26                 "open-ils.storage.authority.$class.see_from.controlled.atomic",$term, 10);
  27         my $areq = $session->request(
  28                 "open-ils.storage.authority.$class.see_also_from.controlled.atomic",$term, 10);
  29
  30         my $fr = $freq->gather(1);
  31         my $al = $areq->gather(1);
  32         $session->disconnect;
  33
  34         return _auth_flatten( $term, $fr, $al, 1 );
  35 }
  36
  37 sub _auth_flatten {
  38         my $term = shift;
  39         my $fr = shift;
  40         my $al = shift;
  41         my $limit = shift;
  42
  43         my %hash = ();
  44         for my $x (@$fr) {
  45                 my $string = $$x[0];
  46                 for my $i (1..10) {
  47                         last unless ($$x[$i]);
  48                         if ($string =~ /\W$/o) {
  49                                 $string .= ' '.$$x[$i];
  50                         } else {
  51                                 $string .= ' -- '.$$x[$i];
  52                         }
  53                 }
  54                 next if (lc($string) eq lc($term));
  55                 $hash{$string}++;
  56                 $hash{$string}++ if (lc($$x[0]) eq lc($term));
  57         }
  58         my $from = [ sort { $hash{$b} <=> $hash{$a} || $a cmp $b } keys %hash ];
  59
  60 #       $from = [ @$from[0..4] ] if $limit;
  61
  62         %hash = ();
  63         for my $x (@$al) {
  64                 my $string = $$x[0];
  65                 for my $i (1..10) {
  66                         last unless ($$x[$i]);
  67                         if ($string =~ /\W$/o) {
  68                                 $string .= ' '.$$x[$i];
  69                         } else {
  70                                 $string .= ' -- '.$$x[$i];
  71                         }
  72                 }
  73                 next if (lc($string) eq lc($term));
  74                 $hash{$string}++;
  75                 $hash{$string}++ if (lc($$x[0]) eq lc($term));
  76         }
  77         my $also = [ sort { $hash{$b} <=> $hash{$a} || $a cmp $b } keys %hash ];
  78
  79 #       $also = [ @$also[0..4] ] if $limit;
  80
  81
  82         return { from => $from, also => $also };
  83 }
  84
  85 __PACKAGE__->register_method(
  86         method          => "crossref_authority",
  87         api_name        => "open-ils.search.authority.crossref",
  88         argc            => 2,
  89         note            => "Searches authority data for existing controlled terms and crossrefs",
  90 );
  91
  92 __PACKAGE__->register_method(
  93         method          => "crossref_authority_batch",
  94    api_name     => "open-ils.search.authority.crossref.batch",
  95    argc         => 1,
  96    note         => <<"  NOTE");
  97         Takes an array of class,term pair sub-arrays and performs an authority lookup for each
  98
  99         PARAMS( [ ["subject", "earth"], ["author","shakespeare"] ] );
 100
 101         Returns an object like so:
 102         {
 103                 "classname" : {
 104                         "term" : { "from" : [ ...], "also" : [...] }
 105                         "term2" : { "from" : [ ...], "also" : [...] }
 106                 }
 107         }
 108         NOTE
 109
 110 sub crossref_authority_batch {
 111         my( $self, $client, $reqs ) = @_;
 112
 113         my $response = {};
 114         my $lastr = [];
 115         my $session = OpenSRF::AppSession->create("open-ils.storage");
 116
 117         for my $req (@$reqs) {
 118
 119                 my $class = $req->[0];
 120                 my $term = $req->[1];
 121                 next unless $class and $term;
 122                 warn "Sending authority request for $class : $term\n";
 123                 my $freq = $session->request("open-ils.storage.authority.$class.see_from.controlled.atomic",$term, 10);
 124                 my $areq = $session->request("open-ils.storage.authority.$class.see_also_from.controlled.atomic",$term, 10);
 125
 126                 if( $lastr->[0] ) { #process old data while waiting on new data
 127                         my $cls = $lastr->[0];
 128                         my $trm = $lastr->[1];
 129                         my $fr  = $lastr->[2];
 130                         my $al  = $lastr->[3];
 131                         warn "Flattening $class : $term\n";
 132                         $response->{$cls} = {} unless exists $response->{$cls};
 133                         $response->{$cls}->{$trm} = _auth_flatten( $trm, $fr, $al, 1 );
 134                 }
 135
 136                 $lastr->[0] = $class;
 137                 $lastr->[1] = $term;
 138                 $lastr->[2] = $freq->gather(1);
 139                 $lastr->[3] = $areq->gather(1);
 140         }
 141
 142         if( $lastr->[0] ) { #process old data while waiting on new data
 143                 my $cls = $lastr->[0];
 144                 my $trm = $lastr->[1];
 145                 my $fr  = $lastr->[2];
 146                 my $al  = $lastr->[3];
 147                 warn "Flattening $cls : $trm\n";
 148                 $response->{$cls} = {} unless exists $response->{$cls};
 149                 $response->{$cls}->{$trm} = _auth_flatten( $trm, $fr, $al, 1);
 150         }
 151
 152         return $response;
 153 }
 154
 155
 156 1;