Open-ILS/src/perlmods/OpenILS/Application/Storage/Publisher/asset.pm

   1 package OpenILS::Application::Storage::Publisher::asset;
   2 use base qw/OpenILS::Application::Storage/;
   3 #use OpenILS::Application::Storage::CDBI::asset;
   4 #use OpenSRF::Utils::Logger qw/:level/;
   5 #use OpenILS::Utils::Fieldmapper;
   6 #
   7 #my $log = 'OpenSRF::Utils::Logger';
   8
   9 sub copy_proximity {
  10         my $self = shift;
  11         my $client = shift;
  12
  13         my $cp = shift;
  14         my $org = shift;
  15
  16         return unless ($cp && $org);
  17
  18         $cp = $cp->id if (ref $cp);
  19         $cp = asset::copy->retrieve($cp);
  20         return 999 unless $copy;
  21         my $ol = $cp->call_number->owning_lib;
  22
  23         return asset::copy->db_Main->selectcol_arrayref('SELECT actor.org_unit_proximity(?,?)',{},"$ol","$org")->[0];
  24 }
  25 __PACKAGE__->register_method(
  26         method          => 'copy_proximity',
  27         api_name        => 'open-ils.storage.asset.copy.proximity',
  28         argc            => 0,
  29         stream          => 1,
  30 );
  31
  32 sub asset_copy_location_all {
  33         my $self = shift;
  34         my $client = shift;
  35
  36         for my $rec ( asset::copy_location->retrieve_all ) {
  37                 $client->respond( $rec->to_fieldmapper );
  38         }
  39
  40         return undef;
  41 }
  42 __PACKAGE__->register_method(
  43         method          => 'asset_copy_location_all',
  44         api_name        => 'open-ils.storage.direct.asset.copy_location.retrieve.all',
  45         argc            => 0,
  46         stream          => 1,
  47 );
  48
  49 sub fleshed_copy {
  50         my $self = shift;
  51         my $client = shift;
  52         my @ids = @_;
  53
  54         return undef unless (@ids);
  55
  56         @ids = ($ids[0]) unless ($self->api_name =~ /batch/o);
  57
  58         for my $id ( @ids ) {
  59                 next unless $id;
  60                 my $cp = asset::copy->retrieve($id);
  61
  62                 my $cp_fm = $cp->to_fieldmapper;
  63                 $cp_fm->circ_lib( $cp->circ_lib->to_fieldmapper );
  64                 $cp_fm->location( $cp->location->to_fieldmapper );
  65                 $cp_fm->status( $cp->status->to_fieldmapper );
  66                 $cp_fm->stat_cat_entries( [ map { $_->to_fieldmapper } $cp->stat_cat_entries ] );
  67
  68                 $client->respond( $cp_fm );
  69         }
  70
  71         return undef;
  72 }
  73 __PACKAGE__->register_method(
  74         api_name        => 'open-ils.storage.fleshed.asset.copy.batch.retrieve',
  75         method          => 'fleshed_copy',
  76         argc            => 1,
  77         stream          => 1,
  78 );
  79 __PACKAGE__->register_method(
  80         api_name        => 'open-ils.storage.fleshed.asset.copy.retrieve',
  81         method          => 'fleshed_copy',
  82         argc            => 1,
  83 );
  84
  85 sub fleshed_copy_by_barcode {
  86         my $self = shift;
  87         my $client = shift;
  88         my $bc = ''.shift;
  89
  90         my ($cp) = asset::copy->search( { barcode => $bc } );
  91
  92         return undef unless ($cp);
  93
  94         my $cp_fm = $cp->to_fieldmapper;
  95         $cp_fm->circ_lib( $cp->circ_lib->to_fieldmapper );
  96         $cp_fm->location( $cp->location->to_fieldmapper );
  97         $cp_fm->status( $cp->status->to_fieldmapper );
  98
  99         return $cp_fm;
 100 }
 101 __PACKAGE__->register_method(
 102         api_name        => 'open-ils.storage.fleshed.asset.copy.search.barcode',
 103         method          => 'fleshed_copy_by_barcode',
 104         argc            => 1,
 105         stream          => 1,
 106 );
 107
 108 #XXX Fix stored proc calls
 109 sub ranged_asset_stat_cat {
 110         my $self = shift;
 111         my $client = shift;
 112         my $ou = ''.shift();
 113
 114         return undef unless ($ou);
 115         my $s_table = asset::stat_cat->table;
 116
 117         my $select = <<"        SQL";
 118                 SELECT  s.*
 119                   FROM  $s_table s
 120                         JOIN actor.org_unit_full_path(?) p ON (p.id = s.owner)
 121                   ORDER BY name
 122         SQL
 123
 124         $fleshed = 0;
 125         $fleshed = 1 if ($self->api_name =~ /fleshed/o);
 126
 127         my $sth = asset::stat_cat->db_Main->prepare_cached($select);
 128         $sth->execute($ou);
 129
 130         for my $sc ( map { asset::stat_cat->construct($_) } $sth->fetchall_hash ) {
 131                 my $sc_fm = $sc->to_fieldmapper;
 132                 $sc_fm->entries(
 133                         [ $self->method_lookup( 'open-ils.storage.ranged.asset.stat_cat_entry.search.stat_cat' )->run($ou,$sc->id) ]
 134                 ) if ($fleshed);
 135                 $client->respond( $sc_fm );
 136         }
 137
 138         return undef;
 139 }
 140 __PACKAGE__->register_method(
 141         api_name        => 'open-ils.storage.ranged.fleshed.asset.stat_cat.all',
 142         api_level       => 1,
 143         stream          => 1,
 144         method          => 'ranged_asset_stat_cat',
 145 );
 146
 147 __PACKAGE__->register_method(
 148         api_name        => 'open-ils.storage.ranged.asset.stat_cat.all',
 149         api_level       => 1,
 150         stream          => 1,
 151         method          => 'ranged_asset_stat_cat',
 152 );
 153
 154
 155 #XXX Fix stored proc calls
 156 sub multiranged_asset_stat_cat {
 157         my $self = shift;
 158         my $client = shift;
 159         my $ous = shift;
 160
 161         return undef unless (defined($ous) and @$ous);
 162         my $s_table = asset::stat_cat->table;
 163
 164         my $select = <<"        SQL";
 165                 SELECT  s.*
 166                   FROM  $s_table s
 167                   WHERE s.owner IN ( XXX )
 168                   ORDER BY name
 169         SQL
 170
 171         my $collector = ' INTERSECT ';
 172         my $entry_method = 'open-ils.storage.multiranged.intersect.asset.stat_cat_entry.search.stat_cat';
 173         if ($self->api_name =~ /union/o) {
 174                 $collector = ' UNION ';
 175                 $entry_method = 'open-ils.storage.multiranged.union.asset.stat_cat_entry.search.stat_cat';
 176         }
 177
 178         my $binds = join($collector, map { 'SELECT id FROM actor.org_unit_full_path(?)' } grep {defined} @$ous);
 179         $select =~ s/XXX/$binds/so;
 180
 181         $fleshed = 0;
 182         $fleshed = 1 if ($self->api_name =~ /fleshed/o);
 183
 184         my $sth = asset::stat_cat->db_Main->prepare_cached($select);
 185         $sth->execute(map { "$_" } grep {defined} @$ous);
 186
 187         for my $sc ( map { asset::stat_cat->construct($_) } $sth->fetchall_hash ) {
 188                 my $sc_fm = $sc->to_fieldmapper;
 189                 $sc_fm->entries(
 190                         [ $self->method_lookup( $entry_method )->run($ous, $sc->id) ]
 191                 ) if ($fleshed);
 192                 $client->respond( $sc_fm );
 193         }
 194
 195         return undef;
 196 }
 197 __PACKAGE__->register_method(
 198         api_name        => 'open-ils.storage.multiranged.intersect.fleshed.asset.stat_cat.all',
 199         api_level       => 1,
 200         stream          => 1,
 201         method          => 'multiranged_asset_stat_cat',
 202 );
 203 __PACKAGE__->register_method(
 204         api_name        => 'open-ils.storage.multiranged.union.fleshed.asset.stat_cat.all',
 205         api_level       => 1,
 206         stream          => 1,
 207         method          => 'multiranged_asset_stat_cat',
 208 );
 209
 210 #XXX Fix stored proc calls
 211 sub ranged_asset_stat_cat_entry {
 212         my $self = shift;
 213         my $client = shift;
 214         my $ou = ''.shift();
 215         my $sc = ''.shift();
 216
 217         return undef unless ($ou);
 218         my $s_table = asset::stat_cat_entry->table;
 219
 220         my $select = <<"        SQL";
 221                 SELECT  s.*
 222                   FROM  $s_table s
 223                         JOIN actor.org_unit_full_path(?) p ON (p.id = s.owner)
 224                   WHERE stat_cat = ?
 225                   ORDER BY name
 226         SQL
 227
 228         my $sth = asset::stat_cat->db_Main->prepare_cached($select);
 229         $sth->execute($ou,$sc);
 230
 231         for my $sce ( map { asset::stat_cat_entry->construct($_) } $sth->fetchall_hash ) {
 232                 $client->respond( $sce->to_fieldmapper );
 233         }
 234
 235         return undef;
 236 }
 237 __PACKAGE__->register_method(
 238         api_name        => 'open-ils.storage.ranged.asset.stat_cat_entry.search.stat_cat',
 239         api_level       => 1,
 240         stream          => 1,
 241         method          => 'ranged_asset_stat_cat_entry',
 242 );
 243
 244 #XXX Fix stored proc calls
 245 sub multiranged_asset_stat_cat_entry {
 246         my $self = shift;
 247         my $client = shift;
 248         my $ous = shift;
 249         my $sc = ''.shift();
 250
 251         return undef unless (defined($ous) and @$ous);
 252         my $s_table = asset::stat_cat_entry->table;
 253
 254         my $collector = ' INTERSECT ';
 255         $collector = ' UNION ' if ($self->api_name =~ /union/o);
 256
 257         my $select = <<"        SQL";
 258                 SELECT  s.*
 259                   FROM  $s_table s
 260                   WHERE s.owner IN ( XXX ) and s.stat_cat = ?
 261                   ORDER BY value
 262         SQL
 263
 264         my $binds = join($collector, map { 'SELECT id FROM actor.org_unit_full_path(?)' } grep {defined} @$ous);
 265         $select =~ s/XXX/$binds/so;
 266
 267         my $sth = asset::stat_cat->db_Main->prepare_cached($select);
 268         $sth->execute(map {"$_"} @$ous,$sc);
 269
 270         for my $sce ( map { asset::stat_cat_entry->construct($_) } $sth->fetchall_hash ) {
 271                 $client->respond( $sce->to_fieldmapper );
 272         }
 273
 274         return undef;
 275 }
 276 __PACKAGE__->register_method(
 277         api_name        => 'open-ils.storage.multiranged.intersect.asset.stat_cat_entry.search.stat_cat',
 278         api_level       => 1,
 279         stream          => 1,
 280         method          => 'multiranged_asset_stat_cat_entry',
 281 );
 282 __PACKAGE__->register_method(
 283         api_name        => 'open-ils.storage.multiranged.union.asset.stat_cat_entry.search.stat_cat',
 284         api_level       => 1,
 285         stream          => 1,
 286         method          => 'multiranged_asset_stat_cat_entry',
 287 );
 288
 289
 290
 291 1;