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