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