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

   1 # We'll be working with XML, so...
   2 use XML::LibXML;
   3 use XML::LibXSLT;
   4 use Unicode::Normalize;
   5
   6 # ... and this has some handy common methods
   7 use OpenILS::Application::AppUtils;
   8
   9 my $parser = new XML::LibXML;
  10 my $U = 'OpenILS::Application::AppUtils';
  11
  12
  13 package OpenILS::Application::SuperCat;
  14
  15 use strict;
  16 use warnings;
  17
  18 # All OpenSRF applications must be based on OpenSRF::Application or
  19 # a subclass thereof.  Makes sense, eh?
  20 use OpenILS::Application;
  21 use base qw/OpenILS::Application/;
  22
  23 # This is the client class, used for connecting to open-ils.storage
  24 use OpenSRF::AppSession;
  25
  26 # This is an extention of Error.pm that supplies some error types to throw
  27 use OpenSRF::EX qw(:try);
  28
  29 # This is a helper class for querying the OpenSRF Settings application ...
  30 use OpenSRF::Utils::SettingsClient;
  31
  32 # ... and here we have the built in logging helper ...
  33 use OpenSRF::Utils::Logger qw($logger);
  34
  35 # ... and this is our OpenILS object (en|de)coder and psuedo-ORM package.
  36 use OpenILS::Utils::Fieldmapper;
  37
  38 our (
  39   $_parser,
  40   $_xslt,
  41   %record_xslt,
  42   %metarecord_xslt,
  43   %holdings_data_cache,
  44 );
  45
  46 sub child_init {
  47         # we need an XML parser
  48         $_parser = new XML::LibXML;
  49
  50         # and an xslt parser
  51         $_xslt = new XML::LibXSLT;
  52
  53         # parse the MODS xslt ...
  54         my $mods33_xslt = $_parser->parse_file(
  55                 OpenSRF::Utils::SettingsClient
  56                         ->new
  57                         ->config_value( dirs => 'xsl' ).
  58                 "/MARC21slim2MODS33.xsl"
  59         );
  60         # and stash a transformer
  61         $record_xslt{mods33}{xslt} = $_xslt->parse_stylesheet( $mods33_xslt );
  62         $record_xslt{mods33}{namespace_uri} = 'http://www.loc.gov/mods/v3';
  63         $record_xslt{mods33}{docs} = 'http://www.loc.gov/mods/';
  64         $record_xslt{mods33}{schema_location} = 'http://www.loc.gov/standards/mods/v3/mods-3-3.xsd';
  65
  66         # parse the MODS xslt ...
  67         my $mods32_xslt = $_parser->parse_file(
  68                 OpenSRF::Utils::SettingsClient
  69                         ->new
  70                         ->config_value( dirs => 'xsl' ).
  71                 "/MARC21slim2MODS32.xsl"
  72         );
  73         # and stash a transformer
  74         $record_xslt{mods32}{xslt} = $_xslt->parse_stylesheet( $mods32_xslt );
  75         $record_xslt{mods32}{namespace_uri} = 'http://www.loc.gov/mods/v3';
  76         $record_xslt{mods32}{docs} = 'http://www.loc.gov/mods/';
  77         $record_xslt{mods32}{schema_location} = 'http://www.loc.gov/standards/mods/v3/mods-3-2.xsd';
  78
  79         # parse the MODS xslt ...
  80         my $mods3_xslt = $_parser->parse_file(
  81                 OpenSRF::Utils::SettingsClient
  82                         ->new
  83                         ->config_value( dirs => 'xsl' ).
  84                 "/MARC21slim2MODS3.xsl"
  85         );
  86         # and stash a transformer
  87         $record_xslt{mods3}{xslt} = $_xslt->parse_stylesheet( $mods3_xslt );
  88         $record_xslt{mods3}{namespace_uri} = 'http://www.loc.gov/mods/v3';
  89         $record_xslt{mods3}{docs} = 'http://www.loc.gov/mods/';
  90         $record_xslt{mods3}{schema_location} = 'http://www.loc.gov/standards/mods/v3/mods-3-1.xsd';
  91
  92         # parse the MODS xslt ...
  93         my $mods_xslt = $_parser->parse_file(
  94                 OpenSRF::Utils::SettingsClient
  95                         ->new
  96                         ->config_value( dirs => 'xsl' ).
  97                 "/MARC21slim2MODS.xsl"
  98         );
  99         # and stash a transformer
 100         $record_xslt{mods}{xslt} = $_xslt->parse_stylesheet( $mods_xslt );
 101         $record_xslt{mods}{namespace_uri} = 'http://www.loc.gov/mods/';
 102         $record_xslt{mods}{docs} = 'http://www.loc.gov/mods/';
 103         $record_xslt{mods}{schema_location} = 'http://www.loc.gov/standards/mods/mods.xsd';
 104
 105         # parse the ATOM entry xslt ...
 106         my $atom_xslt = $_parser->parse_file(
 107                 OpenSRF::Utils::SettingsClient
 108                         ->new
 109                         ->config_value( dirs => 'xsl' ).
 110                 "/MARC21slim2ATOM.xsl"
 111         );
 112         # and stash a transformer
 113         $record_xslt{atom}{xslt} = $_xslt->parse_stylesheet( $atom_xslt );
 114         $record_xslt{atom}{namespace_uri} = 'http://www.w3.org/2005/Atom';
 115         $record_xslt{atom}{docs} = 'http://www.ietf.org/rfc/rfc4287.txt';
 116
 117         # parse the RDFDC xslt ...
 118         my $rdf_dc_xslt = $_parser->parse_file(
 119                 OpenSRF::Utils::SettingsClient
 120                         ->new
 121                         ->config_value( dirs => 'xsl' ).
 122                 "/MARC21slim2RDFDC.xsl"
 123         );
 124         # and stash a transformer
 125         $record_xslt{rdf_dc}{xslt} = $_xslt->parse_stylesheet( $rdf_dc_xslt );
 126         $record_xslt{rdf_dc}{namespace_uri} = 'http://purl.org/dc/elements/1.1/';
 127         $record_xslt{rdf_dc}{schema_location} = 'http://purl.org/dc/elements/1.1/';
 128
 129         # parse the SRWDC xslt ...
 130         my $srw_dc_xslt = $_parser->parse_file(
 131                 OpenSRF::Utils::SettingsClient
 132                         ->new
 133                         ->config_value( dirs => 'xsl' ).
 134                 "/MARC21slim2SRWDC.xsl"
 135         );
 136         # and stash a transformer
 137         $record_xslt{srw_dc}{xslt} = $_xslt->parse_stylesheet( $srw_dc_xslt );
 138         $record_xslt{srw_dc}{namespace_uri} = 'info:srw/schema/1/dc-schema';
 139         $record_xslt{srw_dc}{schema_location} = 'http://www.loc.gov/z3950/agency/zing/srw/dc-schema.xsd';
 140
 141         # parse the OAIDC xslt ...
 142         my $oai_dc_xslt = $_parser->parse_file(
 143                 OpenSRF::Utils::SettingsClient
 144                         ->new
 145                         ->config_value( dirs => 'xsl' ).
 146                 "/MARC21slim2OAIDC.xsl"
 147         );
 148         # and stash a transformer
 149         $record_xslt{oai_dc}{xslt} = $_xslt->parse_stylesheet( $oai_dc_xslt );
 150         $record_xslt{oai_dc}{namespace_uri} = 'http://www.openarchives.org/OAI/2.0/oai_dc/';
 151         $record_xslt{oai_dc}{schema_location} = 'http://www.openarchives.org/OAI/2.0/oai_dc.xsd';
 152
 153         # parse the RSS xslt ...
 154         my $rss_xslt = $_parser->parse_file(
 155                 OpenSRF::Utils::SettingsClient
 156                         ->new
 157                         ->config_value( dirs => 'xsl' ).
 158                 "/MARC21slim2RSS2.xsl"
 159         );
 160         # and stash a transformer
 161         $record_xslt{rss2}{xslt} = $_xslt->parse_stylesheet( $rss_xslt );
 162
 163         # parse the FGDC xslt ...
 164         my $fgdc_xslt = $_parser->parse_file(
 165                 OpenSRF::Utils::SettingsClient
 166                         ->new
 167                         ->config_value( dirs => 'xsl' ).
 168                 "/MARC21slim2FGDC.xsl"
 169         );
 170         # and stash a transformer
 171         $record_xslt{fgdc}{xslt} = $_xslt->parse_stylesheet( $fgdc_xslt );
 172         $record_xslt{fgdc}{docs} = 'http://www.fgdc.gov/metadata/csdgm/index_html';
 173         $record_xslt{fgdc}{schema_location} = 'http://www.fgdc.gov/metadata/fgdc-std-001-1998.xsd';
 174
 175         register_record_transforms();
 176
 177         return 1;
 178 }
 179
 180 sub register_record_transforms {
 181         for my $type ( keys %record_xslt ) {
 182                 __PACKAGE__->register_method(
 183                         method    => 'retrieve_record_transform',
 184                         api_name  => "open-ils.supercat.record.$type.retrieve",
 185                         api_level => 1,
 186                         argc      => 1,
 187                         signature =>
 188                                 { desc     => "Returns the \U$type\E representation ".
 189                                               "of the requested bibliographic record",
 190                                   params   =>
 191                                         [
 192                                                 { name => 'bibId',
 193                                                   desc => 'An OpenILS biblio::record_entry id',
 194                                                   type => 'number' },
 195                                         ],
 196                                 'return' =>
 197                                         { desc => "The bib record in \U$type\E",
 198                                           type => 'string' }
 199                                 }
 200                 );
 201
 202                 __PACKAGE__->register_method(
 203                         method    => 'retrieve_isbn_transform',
 204                         api_name  => "open-ils.supercat.isbn.$type.retrieve",
 205                         api_level => 1,
 206                         argc      => 1,
 207                         signature =>
 208                                 { desc     => "Returns the \U$type\E representation ".
 209                                               "of the requested bibliographic record",
 210                                   params   =>
 211                                         [
 212                                                 { name => 'isbn',
 213                                                   desc => 'An ISBN',
 214                                                   type => 'string' },
 215                                         ],
 216                                 'return' =>
 217                                         { desc => "The bib record in \U$type\E",
 218                                           type => 'string' }
 219                                 }
 220                 );
 221         }
 222 }
 223
 224 sub tree_walker {
 225         my $tree = shift;
 226         my $field = shift;
 227         my $filter = shift;
 228
 229         return unless ($tree && ref($tree->$field));
 230
 231         my @things = $filter->($tree);
 232         for my $v ( @{$tree->$field} ){
 233                 push @things, $filter->($v);
 234                 push @things, tree_walker($v, $field, $filter);
 235         }
 236         return @things
 237 }
 238
 239 sub cn_browse {
 240         my $self = shift;
 241         my $client = shift;
 242
 243         my $label = shift;
 244         my $ou = shift;
 245         my $page_size = shift || 9;
 246         my $page = shift || 0;
 247
 248         my ($before_limit,$after_limit) = (0,0);
 249         my ($before_offset,$after_offset) = (0,0);
 250
 251         if (!$page) {
 252                 $before_limit = $after_limit = int($page_size / 2);
 253                 $after_limit += 1 if ($page_size % 2);
 254         } else {
 255                 $before_offset = $after_offset = int($page_size / 2);
 256                 $before_offset += 1 if ($page_size % 2);
 257                 $before_limit = $after_limit = $page_size;
 258         }
 259
 260         my $_storage = OpenSRF::AppSession->create( 'open-ils.cstore' );
 261
 262         my $o_search = { shortname => $ou };
 263         if (!$ou || $ou eq '-') {
 264                 $o_search = { parent_ou => undef };
 265         }
 266
 267         my $orgs = $_storage->request(
 268                 "open-ils.cstore.direct.actor.org_unit.search",
 269                 $o_search,
 270                 { flesh         => 100,
 271                   flesh_fields  => { aou        => [qw/children/] }
 272                 }
 273         )->gather(1);
 274
 275         my @ou_ids = tree_walker($orgs, 'children', sub {shift->id}) if $orgs;
 276
 277         $logger->debug("Searching for CNs at orgs [".join(',',@ou_ids)."], based on $ou");
 278
 279         my @list = ();
 280
 281         if ($page <= 0) {
 282                 my $before = $_storage->request(
 283                         "open-ils.cstore.direct.asset.call_number.search.atomic",
 284                         { label         => { "<" => { transform => "upper", value => ["upper", $label] } },
 285                           owning_lib    => \@ou_ids,
 286               deleted => 'f',
 287                         },
 288                         { flesh         => 1,
 289                           flesh_fields  => { acn => [qw/record owning_lib/] },
 290                           order_by      => { acn => "upper(label) desc, id desc, owning_lib desc" },
 291                           limit         => $before_limit,
 292                           offset        => abs($page) * $page_size - $before_offset,
 293                         }
 294                 )->gather(1);
 295                 push @list, reverse(@$before);
 296         }
 297
 298         if ($page >= 0) {
 299                 my $after = $_storage->request(
 300                         "open-ils.cstore.direct.asset.call_number.search.atomic",
 301                         { label         => { ">=" => { transform => "upper", value => ["upper", $label] } },
 302                           owning_lib    => \@ou_ids,
 303               deleted => 'f',
 304                         },
 305                         { flesh         => 1,
 306                           flesh_fields  => { acn => [qw/record owning_lib/] },
 307                           order_by      => { acn => "upper(label), id, owning_lib" },
 308                           limit         => $after_limit,
 309                           offset        => abs($page) * $page_size - $after_offset,
 310                         }
 311                 )->gather(1);
 312                 push @list, @$after;
 313         }
 314
 315         return \@list;
 316 }
 317 __PACKAGE__->register_method(
 318         method    => 'cn_browse',
 319         api_name  => 'open-ils.supercat.call_number.browse',
 320         api_level => 1,
 321         argc      => 1,
 322         signature =>
 323                 { desc     => <<"                 DESC",
 324 Returns the XML representation of the requested bibliographic record's holdings
 325                   DESC
 326                   params   =>
 327                         [
 328                                 { name => 'label',
 329                                   desc => 'The target call number lable',
 330                                   type => 'string' },
 331                                 { name => 'org_unit',
 332                                   desc => 'The org unit shortname (or "-" or undef for global) to browse',
 333                                   type => 'string' },
 334                                 { name => 'page_size',
 335                                   desc => 'Count of call numbers to retrieve, default is 9',
 336                                   type => 'number' },
 337                                 { name => 'page',
 338                                   desc => 'The page of call numbers to retrieve, calculated based on page_size.  Can be positive, negative or 0.',
 339                                   type => 'number' },
 340                         ],
 341                   'return' =>
 342                         { desc => 'Call numbers with owning_lib and record fleshed',
 343                           type => 'array' }
 344                 }
 345 );
 346
 347
 348 sub new_books_by_item {
 349         my $self = shift;
 350         my $client = shift;
 351
 352         my $ou = shift;
 353         my $page_size = shift || 10;
 354         my $page = shift || 1;
 355
 356     my $offset = $page_size * ($page - 1);
 357
 358         my $_storage = OpenSRF::AppSession->create( 'open-ils.cstore' );
 359
 360         my @ou_ids;
 361         if ($ou && $ou ne '-') {
 362                 my $orgs = $_storage->request(
 363                         "open-ils.cstore.direct.actor.org_unit.search",
 364                         { shortname => $ou },
 365                         { flesh         => 100,
 366                           flesh_fields  => { aou        => [qw/children/] }
 367                         }
 368                 )->gather(1);
 369                 @ou_ids = tree_walker($orgs, 'children', sub {shift->id}) if $orgs;
 370         }
 371
 372         $logger->debug("Searching for records with new copies at orgs [".join(',',@ou_ids)."], based on $ou");
 373         my $cns = $_storage->request(
 374                 "open-ils.cstore.json_query.atomic",
 375                 { select        => { acn => ['record'],
 376                          acp => [{ aggregate => 1 => transform => max => column => create_date => alias => 'create_date'}]
 377                        },
 378                   from          => { 'acn' => { 'acp' => { field => call_number => fkey => 'id' } } },
 379                   where         =>
 380                         { '+acp' => { deleted => 'f', (@ou_ids) ? ( circ_lib => \@ou_ids) : () },
 381                           '+acn' => { record => { '>' => 0 } },
 382                         },
 383                   order_by      => { acp => { create_date => { transform => 'max', direction => 'desc' } } },
 384                   limit         => $page_size,
 385                   offset        => $offset
 386                 }
 387         )->gather(1);
 388
 389         return [ map { $_->{record} } @$cns ];
 390 }
 391 __PACKAGE__->register_method(
 392         method    => 'new_books_by_item',
 393         api_name  => 'open-ils.supercat.new_book_list',
 394         api_level => 1,
 395         argc      => 1,
 396         signature =>
 397                 { desc     => <<"                 DESC",
 398 Returns the XML representation of the requested bibliographic record's holdings
 399                   DESC
 400                   params   =>
 401                         [
 402                                 { name => 'org_unit',
 403                                   desc => 'The org unit shortname (or "-" or undef for global) to list',
 404                                   type => 'string' },
 405                                 { name => 'page_size',
 406                                   desc => 'Count of records to retrieve, default is 10',
 407                                   type => 'number' },
 408                                 { name => 'page',
 409                                   desc => 'The page of records to retrieve, calculated based on page_size.  Starts at 1.',
 410                                   type => 'number' },
 411                         ],
 412                   'return' =>
 413                         { desc => 'Record IDs',
 414                           type => 'array' }
 415                 }
 416 );
 417
 418
 419 sub general_browse {
 420         my $self = shift;
 421         my $client = shift;
 422     return tag_sf_browse($self, $client, $self->{tag}, $self->{subfield}, @_);
 423 }
 424 __PACKAGE__->register_method(
 425         method    => 'general_browse',
 426         api_name  => 'open-ils.supercat.title.browse',
 427         tag       => 'tnf', subfield => 'a',
 428         api_level => 1,
 429         argc      => 1,
 430         signature =>
 431                 { desc     => "Returns a list of the requested org-scoped record ids held",
 432                   params   =>
 433                         [ { name => 'value', desc => 'The target title', type => 'string' },
 434                           { name => 'org_unit', desc => 'The org unit shortname (or "-" or undef for global) to browse', type => 'string' },
 435                           { name => 'page_size', desc => 'Count of records to retrieve, default is 9', type => 'number' },
 436                           { name => 'page', desc => 'The page of records retrieve, calculated based on page_size.  Can be positive, negative or 0.', type => 'number' }, ],
 437                   'return' => { desc => 'Record IDs that have copies at the relevant org units', type => 'array' }
 438                 }
 439 );
 440 __PACKAGE__->register_method(
 441         method    => 'general_browse',
 442         api_name  => 'open-ils.supercat.author.browse',
 443         tag       => [qw/100 110 111/], subfield => 'a',
 444         api_level => 1,
 445         argc      => 1,
 446         signature =>
 447                 { desc     => "Returns a list of the requested org-scoped record ids held",
 448                   params   =>
 449                         [ { name => 'value', desc => 'The target author', type => 'string' },
 450                           { name => 'org_unit', desc => 'The org unit shortname (or "-" or undef for global) to browse', type => 'string' },
 451                           { name => 'page_size', desc => 'Count of records to retrieve, default is 9', type => 'number' },
 452                           { name => 'page', desc => 'The page of records retrieve, calculated based on page_size.  Can be positive, negative or 0.', type => 'number' }, ],
 453                   'return' => { desc => 'Record IDs that have copies at the relevant org units', type => 'array' }
 454                 }
 455 );
 456 __PACKAGE__->register_method(
 457         method    => 'general_browse',
 458         api_name  => 'open-ils.supercat.subject.browse',
 459         tag       => [qw/600 610 611 630 648 650 651 653 655 656 662 690 691 696 697 698 699/], subfield => 'a',
 460         api_level => 1,
 461         argc      => 1,
 462         signature =>
 463                 { desc     => "Returns a list of the requested org-scoped record ids held",
 464                   params   =>
 465                         [ { name => 'value', desc => 'The target subject', type => 'string' },
 466                           { name => 'org_unit', desc => 'The org unit shortname (or "-" or undef for global) to browse', type => 'string' },
 467                           { name => 'page_size', desc => 'Count of records to retrieve, default is 9', type => 'number' },
 468                           { name => 'page', desc => 'The page of records retrieve, calculated based on page_size.  Can be positive, negative or 0.', type => 'number' }, ],
 469                   'return' => { desc => 'Record IDs that have copies at the relevant org units', type => 'array' }
 470                 }
 471 );
 472 __PACKAGE__->register_method(
 473         method    => 'general_browse',
 474         api_name  => 'open-ils.supercat.topic.browse',
 475         tag       => [qw/650 690/], subfield => 'a',
 476         api_level => 1,
 477         argc      => 1,
 478         signature =>
 479                 { desc     => "Returns a list of the requested org-scoped record ids held",
 480                   params   =>
 481                         [ { name => 'value', desc => 'The target topical subject', type => 'string' },
 482                           { name => 'org_unit', desc => 'The org unit shortname (or "-" or undef for global) to browse', type => 'string' },
 483                           { name => 'page_size', desc => 'Count of records to retrieve, default is 9', type => 'number' },
 484                           { name => 'page', desc => 'The page of records retrieve, calculated based on page_size.  Can be positive, negative or 0.', type => 'number' }, ],
 485                   'return' => { desc => 'Record IDs that have copies at the relevant org units', type => 'array' }
 486                 }
 487 );
 488 __PACKAGE__->register_method(
 489         method    => 'general_browse',
 490         api_name  => 'open-ils.supercat.series.browse',
 491         tag       => [qw/440 490 800 810 811 830/], subfield => 'a',
 492         api_level => 1,
 493         argc      => 1,
 494         signature =>
 495                 { desc     => "Returns a list of the requested org-scoped record ids held",
 496                   params   =>
 497                         [ { name => 'value', desc => 'The target series', type => 'string' },
 498                           { name => 'org_unit', desc => 'The org unit shortname (or "-" or undef for global) to browse', type => 'string' },
 499                           { name => 'page_size', desc => 'Count of records to retrieve, default is 9', type => 'number' },
 500                           { name => 'page', desc => 'The page of records retrieve, calculated based on page_size.  Can be positive, negative or 0.', type => 'number' }, ],
 501                   'return' => { desc => 'Record IDs that have copies at the relevant org units', type => 'array' }
 502                 }
 503 );
 504
 505
 506 sub tag_sf_browse {
 507         my $self = shift;
 508         my $client = shift;
 509
 510         my $tag = shift;
 511         my $subfield = shift;
 512         my $value = shift;
 513         my $ou = shift;
 514         my $page_size = shift || 9;
 515         my $page = shift || 0;
 516
 517         my ($before_limit,$after_limit) = (0,0);
 518         my ($before_offset,$after_offset) = (0,0);
 519
 520         if (!$page) {
 521                 $before_limit = $after_limit = int($page_size / 2);
 522                 $after_limit += 1 if ($page_size % 2);
 523         } else {
 524                 $before_offset = $after_offset = int($page_size / 2);
 525                 $before_offset += 1 if ($page_size % 2);
 526                 $before_limit = $after_limit = $page_size;
 527         }
 528
 529         my $_storage = OpenSRF::AppSession->create( 'open-ils.cstore' );
 530
 531         my @ou_ids;
 532         if ($ou && $ou ne '-') {
 533                 my $orgs = $_storage->request(
 534                         "open-ils.cstore.direct.actor.org_unit.search",
 535                         { shortname => $ou },
 536                         { flesh         => 100,
 537                           flesh_fields  => { aou        => [qw/children/] }
 538                         }
 539                 )->gather(1);
 540                 @ou_ids = tree_walker($orgs, 'children', sub {shift->id}) if $orgs;
 541         }
 542
 543         $logger->debug("Searching for records at orgs [".join(',',@ou_ids)."], based on $ou");
 544
 545         my @list = ();
 546
 547         if ($page <= 0) {
 548                 my $before = $_storage->request(
 549                         "open-ils.cstore.json_query.atomic",
 550                         { select        => { mfr => [qw/record value/] },
 551                           from          => 'mfr',
 552                           where         =>
 553                                 { '+mfr'        =>
 554                                         { tag   => $tag,
 555                                           subfield => $subfield,
 556                                           value => { '<' => lc($value) }
 557                                         },
 558                   '-or' => [
 559                                 { '-exists'     =>
 560                                         { select=> { acp => [ 'id' ] },
 561                                           from  => { acn => { acp => { field => 'call_number', fkey => 'id' } } },
 562                                               where     =>
 563                                                 { '+acn' => { record => { '=' => { '+mfr' => 'record' } } },
 564                                                   '+acp' => { deleted => 'f', (@ou_ids) ? ( circ_lib => \@ou_ids) : () }
 565                                                 },
 566                                           limit => 1
 567                                         }
 568                     },
 569                     { '-exists' =>
 570                                         { select=> { auri => [ 'id' ] },
 571                                           from  => { acn => { auricnm => { field => 'call_number', fkey => 'id', join => { auri => { field => 'id', fkey => 'uri' } } } } },
 572                                           where =>
 573                                                 { '+acn' => { record => { '=' => { '+mfr' => 'record' } }, (@ou_ids) ? ( owning_lib => \@ou_ids) : () },
 574                                                   '+auri' => { active => 't' }
 575                                                 },
 576                                           limit => 1
 577                                         }
 578                     }
 579                   ]
 580                                 },
 581                           order_by      => { mfr => { value => 'desc' } },
 582                           limit         => $before_limit,
 583                           offset        => abs($page) * $page_size - $before_offset,
 584                         }
 585                 )->gather(1);
 586                 push @list, map { $_->{record} } reverse(@$before);
 587         }
 588
 589         if ($page >= 0) {
 590                 my $after = $_storage->request(
 591                         "open-ils.cstore.json_query.atomic",
 592                         { select        => { mfr => [qw/record value/] },
 593                           from          => 'mfr',
 594                           where         =>
 595                                 { '+mfr'        =>
 596                                         { tag   => $tag,
 597                                           subfield => $subfield,
 598                                           value => { '>=' => lc($value) }
 599                                         },
 600                                   '-or' => [
 601                     { '-exists' =>
 602                                         { select=> { acp => [ 'id' ] },
 603                                           from  => { acn => { acp => { field => 'call_number', fkey => 'id' } } },
 604                                           where =>
 605                                                 { '+acn' => { record => { '=' => { '+mfr' => 'record' } } },
 606                                                   '+acp' => { deleted => 'f', (@ou_ids) ? ( circ_lib => \@ou_ids) : () }
 607                                                 },
 608                                           limit => 1
 609                                         }
 610                     },
 611                     { '-exists' =>
 612                                         { select=> { auri => [ 'id' ] },
 613                                           from  => { acn => { auricnm => { field => 'call_number', fkey => 'id', join => { auri => { field => 'id', fkey => 'uri' } } } } },
 614                                           where =>
 615                                                 { '+acn' => { record => { '=' => { '+mfr' => 'record' } }, (@ou_ids) ? ( owning_lib => \@ou_ids) : () },
 616                                                   '+auri' => { active => 't' }
 617                                                 },
 618                                           limit => 1
 619                                         },
 620                     }
 621                   ]
 622                                 },
 623                           order_by      => { mfr => { value => 'asc' } },
 624                           limit         => $after_limit,
 625                           offset        => abs($page) * $page_size - $after_offset,
 626                         }
 627                 )->gather(1);
 628                 push @list, map { $_->{record} } @$after;
 629         }
 630
 631         return \@list;
 632 }
 633 __PACKAGE__->register_method(
 634         method    => 'tag_sf_browse',
 635         api_name  => 'open-ils.supercat.tag.browse',
 636         api_level => 1,
 637         argc      => 1,
 638         signature =>
 639                 { desc     => <<"                 DESC",
 640 Returns a list of the requested org-scoped record ids held
 641                   DESC
 642                   params   =>
 643                         [
 644                                 { name => 'tag',
 645                                   desc => 'The target MARC tag',
 646                                   type => 'string' },
 647                                 { name => 'subfield',
 648                                   desc => 'The target MARC subfield',
 649                                   type => 'string' },
 650                                 { name => 'value',
 651                                   desc => 'The target string',
 652                                   type => 'string' },
 653                                 { name => 'org_unit',
 654                                   desc => 'The org unit shortname (or "-" or undef for global) to browse',
 655                                   type => 'string' },
 656                                 { name => 'page_size',
 657                                   desc => 'Count of call numbers to retrieve, default is 9',
 658                                   type => 'number' },
 659                                 { name => 'page',
 660                                   desc => 'The page of call numbers to retrieve, calculated based on page_size.  Can be positive, negative or 0.',
 661                                   type => 'number' },
 662                         ],
 663                   'return' =>
 664                         { desc => 'Record IDs that have copies at the relevant org units',
 665                           type => 'array' }
 666                 }
 667 );
 668
 669 sub holding_data_formats {
 670     return [{
 671         marcxml => {
 672             namespace_uri         => 'http://www.loc.gov/MARC21/slim',
 673                         docs              => 'http://www.loc.gov/marcxml/',
 674                         schema_location => 'http://www.loc.gov/standards/marcxml/schema/MARC21slim.xsd',
 675                 }
 676         }];
 677 }
 678 __PACKAGE__->register_method( method => 'holding_data_formats', api_name => 'open-ils.supercat.acn.formats', api_level => 1 );
 679 __PACKAGE__->register_method( method => 'holding_data_formats', api_name => 'open-ils.supercat.acp.formats', api_level => 1 );
 680 __PACKAGE__->register_method( method => 'holding_data_formats', api_name => 'open-ils.supercat.auri.formats', api_level => 1 );
 681
 682
 683 __PACKAGE__->register_method(
 684         method    => 'retrieve_uri',
 685         api_name  => 'open-ils.supercat.auri.marcxml.retrieve',
 686         api_level => 1,
 687         argc      => 1,
 688         signature =>
 689                 { desc     => <<"                 DESC",
 690 Returns a fleshed call number object
 691                   DESC
 692                   params   =>
 693                         [
 694                                 { name => 'uri_id',
 695                                   desc => 'An OpenILS asset::uri id',
 696                                   type => 'number' },
 697                         ],
 698                   'return' =>
 699                         { desc => 'fleshed uri',
 700                           type => 'object' }
 701                 }
 702 );
 703 sub retrieve_uri {
 704         my $self = shift;
 705         my $client = shift;
 706         my $cpid = shift;
 707         my $args = shift;
 708
 709     return OpenILS::Application::SuperCat::unAPI
 710         ->new(OpenSRF::AppSession
 711             ->create( 'open-ils.cstore' )
 712             ->request(
 713                 "open-ils.cstore.direct.asset.uri.retrieve",
 714                     $cpid,
 715                     { flesh             => 10,
 716                           flesh_fields  => {
 717                                                 auri    => [qw/call_number_maps/],
 718                                                 auricnm => [qw/call_number/],
 719                                                 acn         => [qw/owning_lib record/],
 720                                 }
 721                     })
 722             ->gather(1))
 723         ->as_xml($args);
 724 }
 725
 726 __PACKAGE__->register_method(
 727         method    => 'retrieve_copy',
 728         api_name  => 'open-ils.supercat.acp.marcxml.retrieve',
 729         api_level => 1,
 730         argc      => 1,
 731         signature =>
 732                 { desc     => <<"                 DESC",
 733 Returns a fleshed call number object
 734                   DESC
 735                   params   =>
 736                         [
 737                                 { name => 'cn_id',
 738                                   desc => 'An OpenILS asset::copy id',
 739                                   type => 'number' },
 740                         ],
 741                   'return' =>
 742                         { desc => 'fleshed copy',
 743                           type => 'object' }
 744                 }
 745 );
 746 sub retrieve_copy {
 747         my $self = shift;
 748         my $client = shift;
 749         my $cpid = shift;
 750         my $args = shift;
 751
 752     return OpenILS::Application::SuperCat::unAPI
 753         ->new(OpenSRF::AppSession
 754             ->create( 'open-ils.cstore' )
 755             ->request(
 756                 "open-ils.cstore.direct.asset.copy.retrieve",
 757                     $cpid,
 758                     { flesh             => 2,
 759                           flesh_fields  => {
 760                                                 acn     => [qw/owning_lib record/],
 761                                                 acp     => [qw/call_number location status circ_lib stat_cat_entries notes/],
 762                                 }
 763                     })
 764             ->gather(1))
 765         ->as_xml($args);
 766 }
 767
 768 __PACKAGE__->register_method(
 769         method    => 'retrieve_callnumber',
 770         api_name  => 'open-ils.supercat.acn.marcxml.retrieve',
 771         api_level => 1,
 772         argc      => 1,
 773         stream    => 1,
 774         signature =>
 775                 { desc     => <<"                 DESC",
 776 Returns a fleshed call number object
 777                   DESC
 778                   params   =>
 779                         [
 780                                 { name => 'cn_id',
 781                                   desc => 'An OpenILS asset::call_number id',
 782                                   type => 'number' },
 783                         ],
 784                   'return' =>
 785                         { desc => 'call number with copies',
 786                           type => 'object' }
 787                 }
 788 );
 789 sub retrieve_callnumber {
 790         my $self = shift;
 791         my $client = shift;
 792         my $cnid = shift;
 793         my $args = shift;
 794
 795     return OpenILS::Application::SuperCat::unAPI
 796         ->new(OpenSRF::AppSession
 797             ->create( 'open-ils.cstore' )
 798             ->request(
 799                 "open-ils.cstore.direct.asset.call_number.retrieve",
 800                     $cnid,
 801                     { flesh             => 5,
 802                           flesh_fields  => {
 803                                                 acn     => [qw/owning_lib record copies uri_maps/],
 804                                                 auricnm => [qw/uri/],
 805                                                 acp     => [qw/location status circ_lib stat_cat_entries notes/],
 806                                 }
 807                     })
 808             ->gather(1))
 809         ->as_xml($args);
 810
 811 }
 812
 813 __PACKAGE__->register_method(
 814         method    => 'basic_record_holdings',
 815         api_name  => 'open-ils.supercat.record.basic_holdings.retrieve',
 816         api_level => 1,
 817         argc      => 1,
 818         stream    => 1,
 819         signature =>
 820                 { desc     => <<"                 DESC",
 821 Returns a basic hash representation of the requested bibliographic record's holdings
 822                   DESC
 823                   params   =>
 824                         [
 825                                 { name => 'bibId',
 826                                   desc => 'An OpenILS biblio::record_entry id',
 827                                   type => 'number' },
 828                         ],
 829                   'return' =>
 830                         { desc => 'Hash of bib record holdings hierarchy (call numbers and copies)',
 831                           type => 'string' }
 832                 }
 833 );
 834 sub basic_record_holdings {
 835         my $self = shift;
 836         my $client = shift;
 837         my $bib = shift;
 838         my $ou = shift;
 839
 840         #  holdings hold an array of call numbers, which hold an array of copies
 841         #  holdings => [ label: { library, [ copies: { barcode, location, status, circ_lib } ] } ]
 842         my %holdings;
 843
 844         my $_storage = OpenSRF::AppSession->create( 'open-ils.cstore' );
 845
 846         my $tree = $_storage->request(
 847                 "open-ils.cstore.direct.biblio.record_entry.retrieve",
 848                 $bib,
 849                 { flesh         => 5,
 850                   flesh_fields  => {
 851                                         bre     => [qw/call_numbers/],
 852                                         acn     => [qw/copies owning_lib/],
 853                                         acp     => [qw/location status circ_lib/],
 854                                 }
 855                 }
 856         )->gather(1);
 857
 858         my $o_search = { shortname => uc($ou) };
 859         if (!$ou || $ou eq '-') {
 860                 $o_search = { parent_ou => undef };
 861         }
 862
 863         my $orgs = $_storage->request(
 864                 "open-ils.cstore.direct.actor.org_unit.search",
 865                 $o_search,
 866                 { flesh         => 100,
 867                   flesh_fields  => { aou        => [qw/children/] }
 868                 }
 869         )->gather(1);
 870
 871         my @ou_ids = tree_walker($orgs, 'children', sub {shift->id}) if $orgs;
 872
 873         $logger->debug("Searching for holdings at orgs [".join(',',@ou_ids)."], based on $ou");
 874
 875         for my $cn (@{$tree->call_numbers}) {
 876         next unless ( $cn->deleted eq 'f' || $cn->deleted == 0 );
 877
 878                 my $found = 0;
 879                 for my $c (@{$cn->copies}) {
 880                         next unless grep {$c->circ_lib->id == $_} @ou_ids;
 881                         next unless ( $c->deleted eq 'f' || $c->deleted == 0 );
 882                         $found = 1;
 883                         last;
 884                 }
 885                 next unless $found;
 886
 887                 $holdings{$cn->label}{'owning_lib'} = $cn->owning_lib->shortname;
 888
 889                 for my $cp (@{$cn->copies}) {
 890
 891                         next unless grep { $cp->circ_lib->id == $_ } @ou_ids;
 892                         next unless ( $cp->deleted eq 'f' || $cp->deleted == 0 );
 893
 894                         push @{$holdings{$cn->label}{'copies'}}, {
 895                 barcode => $cp->barcode,
 896                 status => $cp->status->name,
 897                 location => $cp->location->name,
 898                 circlib => $cp->circ_lib->shortname
 899             };
 900
 901                 }
 902         }
 903
 904         return \%holdings;
 905 }
 906
 907 __PACKAGE__->register_method(
 908         method    => 'new_record_holdings',
 909         api_name  => 'open-ils.supercat.record.holdings_xml.retrieve',
 910         api_level => 1,
 911         argc      => 1,
 912         stream    => 1,
 913         signature =>
 914                 { desc     => <<"                 DESC",
 915 Returns the XML representation of the requested bibliographic record's holdings
 916                   DESC
 917                   params   =>
 918                         [
 919                                 { name => 'bibId',
 920                                   desc => 'An OpenILS biblio::record_entry id',
 921                                   type => 'number' },
 922                         ],
 923                   'return' =>
 924                         { desc => 'Stream of bib record holdings hierarchy in XML',
 925                           type => 'string' }
 926                 }
 927 );
 928
 929
 930 sub new_record_holdings {
 931         my $self = shift;
 932         my $client = shift;
 933         my $bib = shift;
 934         my $ou = shift;
 935         my $hide_copies = shift;
 936
 937         my $_storage = OpenSRF::AppSession->create( 'open-ils.cstore' );
 938
 939         my $tree = $_storage->request(
 940                 "open-ils.cstore.direct.biblio.record_entry.retrieve",
 941                 $bib,
 942                 { flesh         => 5,
 943                   flesh_fields  => {
 944                                         bre     => [qw/call_numbers/],
 945                                         acn     => [qw/copies owning_lib uri_maps/],
 946                                         auricnm => [qw/uri/],
 947                                         acp     => [qw/location status circ_lib stat_cat_entries notes/],
 948                                         asce    => [qw/stat_cat/],
 949                                 }
 950                 }
 951         )->gather(1);
 952
 953         my $o_search = { shortname => uc($ou) };
 954         if (!$ou || $ou eq '-') {
 955                 $o_search = { parent_ou => undef };
 956         }
 957
 958         my $orgs = $_storage->request(
 959                 "open-ils.cstore.direct.actor.org_unit.search",
 960                 $o_search,
 961                 { flesh         => 100,
 962                   flesh_fields  => { aou        => [qw/children/] }
 963                 }
 964         )->gather(1);
 965
 966         my @ou_ids = tree_walker($orgs, 'children', sub {shift->id}) if $orgs;
 967
 968         $logger->debug("Searching for holdings at orgs [".join(',',@ou_ids)."], based on $ou");
 969
 970         my ($year,$month,$day) = reverse( (localtime)[3,4,5] );
 971         $year += 1900;
 972         $month += 1;
 973
 974         $client->respond("<volumes xmlns='http://open-ils.org/spec/holdings/v1'>\n");
 975
 976         for my $cn (@{$tree->call_numbers}) {
 977                 next unless ( $cn->deleted eq 'f' || $cn->deleted == 0 );
 978
 979                 my $found = 0;
 980                 for my $c (@{$cn->copies}) {
 981                         next unless grep {$c->circ_lib->id == $_} @ou_ids;
 982                         next unless ( $c->deleted eq 'f' || $c->deleted == 0 );
 983                         $found = 1;
 984                         last;
 985                 }
 986
 987                 if (!$found && ref($cn->uri_maps) && @{$cn->uri_maps}) {
 988                         $found = 1 if (grep {$cn->owning_lib->id == $_} @ou_ids);
 989                 }
 990                 next unless $found;
 991
 992                 # We don't want O:A:S:unAPI::acn to return the record, we've got that already
 993                 my $holdings_args = { no_record => 1 };
 994                 # In the context of BibTemplate, copies aren't necessary because we pull those
 995                 # in a separate call
 996                 if ($hide_copies) {
 997                         $holdings_args->{no_copies} = 1;
 998                 }
 999
1000         $client->respond(
1001             OpenILS::Application::SuperCat::unAPI::acn
1002                 ->new( $cn )
1003                 ->as_xml( $holdings_args )
1004         );
1005         }
1006
1007         return "</volumes>\n";
1008 }
1009 __PACKAGE__->register_method(
1010         method    => 'new_record_holdings',
1011         api_name  => 'open-ils.supercat.record.holdings_xml.retrieve',
1012         api_level => 1,
1013         argc      => 1,
1014         stream    => 1,
1015         signature =>
1016                 { desc     => <<"                 DESC",
1017 Returns the XML representation of the requested bibliographic record's holdings
1018                   DESC
1019                   params   =>
1020                         [
1021                                 { name => 'bibId',
1022                                   desc => 'An OpenILS biblio::record_entry ID',
1023                                   type => 'number' },
1024                                 { name => 'orgUnit',
1025                                   desc => 'An OpenILS actor::org_unit short name that limits the scope of returned holdings',
1026                                   type => 'text' },
1027                                 { name => 'hideCopies',
1028                                   desc => 'Flag that prevents the inclusion of copies in the returned holdings',
1029                                   type => 'boolean' },
1030                         ],
1031                   'return' =>
1032                         { desc => 'Stream of bib record holdings hierarchy in XML',
1033                           type => 'string' }
1034                 }
1035 );
1036
1037 sub isbn_holdings {
1038         my $self = shift;
1039         my $client = shift;
1040         my $isbn = shift;
1041
1042         my $_storage = OpenSRF::AppSession->create( 'open-ils.cstore' );
1043
1044         my $recs = $_storage->request(
1045                         'open-ils.cstore.direct.metabib.full_rec.search.atomic',
1046                         { tag => { like => '02%'}, value => {like => "$isbn\%"}}
1047         )->gather(1);
1048
1049         return undef unless (@$recs);
1050
1051         return ($self->method_lookup( 'open-ils.supercat.record.holdings_xml.retrieve')->run( $recs->[0]->record ))[0];
1052 }
1053 __PACKAGE__->register_method(
1054         method    => 'isbn_holdings',
1055         api_name  => 'open-ils.supercat.isbn.holdings_xml.retrieve',
1056         api_level => 1,
1057         argc      => 1,
1058         signature =>
1059                 { desc     => <<"                 DESC",
1060 Returns the XML representation of the requested bibliographic record's holdings
1061                   DESC
1062                   params   =>
1063                         [
1064                                 { name => 'isbn',
1065                                   desc => 'An isbn',
1066                                   type => 'string' },
1067                         ],
1068                   'return' =>
1069                         { desc => 'The bib record holdings hierarchy in XML',
1070                           type => 'string' }
1071                 }
1072 );
1073
1074 sub escape {
1075         my $self = shift;
1076         my $text = shift;
1077     return '' unless $text;
1078         $text =~ s/&/&amp;/gsom;
1079         $text =~ s/</&lt;/gsom;
1080         $text =~ s/>/&gt;/gsom;
1081         $text =~ s/"/\\"/gsom;
1082         return $text;
1083 }
1084
1085 sub recent_changes {
1086         my $self = shift;
1087         my $client = shift;
1088         my $when = shift || '1-01-01';
1089         my $limit = shift;
1090
1091         my $type = 'biblio';
1092         $type = 'authority' if ($self->api_name =~ /authority/o);
1093
1094         my $axis = 'create_date';
1095         $axis = 'edit_date' if ($self->api_name =~ /edit/o);
1096
1097         my $_storage = OpenSRF::AppSession->create( 'open-ils.cstore' );
1098
1099         return $_storage->request(
1100                 "open-ils.cstore.direct.$type.record_entry.id_list.atomic",
1101                 { $axis => { ">" => $when }, id => { '>' => 0 } },
1102                 { order_by => { bre => "$axis desc" }, limit => $limit }
1103         )->gather(1);
1104 }
1105
1106 for my $t ( qw/biblio authority/ ) {
1107         for my $a ( qw/import edit/ ) {
1108
1109                 __PACKAGE__->register_method(
1110                         method    => 'recent_changes',
1111                         api_name  => "open-ils.supercat.$t.record.$a.recent",
1112                         api_level => 1,
1113                         argc      => 0,
1114                         signature =>
1115                                 { desc     => "Returns a list of recently ${a}ed $t records",
1116                                   params   =>
1117                                         [
1118                                                 { name => 'when',
1119                                                   desc => "Date to start looking for ${a}ed records",
1120                                                   default => '1-01-01',
1121                                                   type => 'string' },
1122
1123                                                 { name => 'limit',
1124                                                   desc => "Maximum count to retrieve",
1125                                                   type => 'number' },
1126                                         ],
1127                                   'return' =>
1128                                         { desc => "An id list of $t records",
1129                                           type => 'array' }
1130                                 },
1131                 );
1132         }
1133 }
1134
1135
1136 sub retrieve_record_marcxml {
1137         my $self = shift;
1138         my $client = shift;
1139         my $rid = shift;
1140
1141         my $_storage = OpenSRF::AppSession->create( 'open-ils.cstore' );
1142
1143         my $record = $_storage->request( 'open-ils.cstore.direct.biblio.record_entry.retrieve' => $rid )->gather(1);
1144         return $U->entityize( $record->marc ) if ($record);
1145         return undef;
1146 }
1147
1148 __PACKAGE__->register_method(
1149         method    => 'retrieve_record_marcxml',
1150         api_name  => 'open-ils.supercat.record.marcxml.retrieve',
1151         api_level => 1,
1152         argc      => 1,
1153         signature =>
1154                 { desc     => <<"                 DESC",
1155 Returns the MARCXML representation of the requested bibliographic record
1156                   DESC
1157                   params   =>
1158                         [
1159                                 { name => 'bibId',
1160                                   desc => 'An OpenILS biblio::record_entry id',
1161                                   type => 'number' },
1162                         ],
1163                   'return' =>
1164                         { desc => 'The bib record in MARCXML',
1165                           type => 'string' }
1166                 }
1167 );
1168
1169 sub retrieve_isbn_marcxml {
1170         my $self = shift;
1171         my $client = shift;
1172         my $isbn = shift;
1173
1174         my $_storage = OpenSRF::AppSession->create( 'open-ils.cstore' );
1175
1176         my $recs = $_storage->request(
1177                         'open-ils.cstore.direct.metabib.full_rec.search.atomic',
1178                         { tag => { like => '02%'}, value => {like => "$isbn\%"}}
1179         )->gather(1);
1180
1181         return undef unless (@$recs);
1182
1183         my $record = $_storage->request( 'open-ils.cstore.direct.biblio.record_entry.retrieve' => $recs->[0]->record )->gather(1);
1184         return $U->entityize( $record->marc ) if ($record);
1185         return undef;
1186 }
1187
1188 __PACKAGE__->register_method(
1189         method    => 'retrieve_isbn_marcxml',
1190         api_name  => 'open-ils.supercat.isbn.marcxml.retrieve',
1191         api_level => 1,
1192         argc      => 1,
1193         signature =>
1194                 { desc     => <<"                 DESC",
1195 Returns the MARCXML representation of the requested ISBN
1196                   DESC
1197                   params   =>
1198                         [
1199                                 { name => 'ISBN',
1200                                   desc => 'An ... um ... ISBN',
1201                                   type => 'string' },
1202                         ],
1203                   'return' =>
1204                         { desc => 'The bib record in MARCXML',
1205                           type => 'string' }
1206                 }
1207 );
1208
1209 sub retrieve_record_transform {
1210         my $self = shift;
1211         my $client = shift;
1212         my $rid = shift;
1213
1214         (my $transform = $self->api_name) =~ s/^.+record\.([^\.]+)\.retrieve$/$1/o;
1215
1216         my $_storage = OpenSRF::AppSession->create( 'open-ils.cstore' );
1217         #$_storage->connect;
1218
1219         my $record = $_storage->request(
1220                 'open-ils.cstore.direct.biblio.record_entry.retrieve',
1221                 $rid
1222         )->gather(1);
1223
1224         return undef unless ($record);
1225
1226         return $U->entityize($record_xslt{$transform}{xslt}->transform( $_parser->parse_string( $record->marc ) )->toString);
1227 }
1228
1229 sub retrieve_isbn_transform {
1230         my $self = shift;
1231         my $client = shift;
1232         my $isbn = shift;
1233
1234         my $_storage = OpenSRF::AppSession->create( 'open-ils.cstore' );
1235
1236         my $recs = $_storage->request(
1237                         'open-ils.cstore.direct.metabib.full_rec.search.atomic',
1238                         { tag => { like => '02%'}, value => {like => "$isbn\%"}}
1239         )->gather(1);
1240
1241         return undef unless (@$recs);
1242
1243         (my $transform = $self->api_name) =~ s/^.+isbn\.([^\.]+)\.retrieve$/$1/o;
1244
1245         my $record = $_storage->request( 'open-ils.cstore.direct.biblio.record_entry.retrieve' => $recs->[0]->record )->gather(1);
1246
1247         return undef unless ($record);
1248
1249         return $U->entityize($record_xslt{$transform}{xslt}->transform( $_parser->parse_string( $record->marc ) )->toString);
1250 }
1251
1252 sub retrieve_record_objects {
1253         my $self = shift;
1254         my $client = shift;
1255         my $ids = shift;
1256
1257         $ids = [$ids] unless (ref $ids);
1258         $ids = [grep {$_} @$ids];
1259
1260         return [] unless (@$ids);
1261
1262         my $_storage = OpenSRF::AppSession->create( 'open-ils.cstore' );
1263         return $_storage->request('open-ils.cstore.direct.biblio.record_entry.search.atomic' => { id => [grep {$_} @$ids] })->gather(1);
1264 }
1265 __PACKAGE__->register_method(
1266         method    => 'retrieve_record_objects',
1267         api_name  => 'open-ils.supercat.record.object.retrieve',
1268         api_level => 1,
1269         argc      => 1,
1270         signature =>
1271                 { desc     => <<"                 DESC",
1272 Returns the Fieldmapper object representation of the requested bibliographic records
1273                   DESC
1274                   params   =>
1275                         [
1276                                 { name => 'bibIds',
1277                                   desc => 'OpenILS biblio::record_entry ids',
1278                                   type => 'array' },
1279                         ],
1280                   'return' =>
1281                         { desc => 'The bib records',
1282                           type => 'array' }
1283                 }
1284 );
1285
1286
1287 sub retrieve_isbn_object {
1288         my $self = shift;
1289         my $client = shift;
1290         my $isbn = shift;
1291
1292         return undef unless ($isbn);
1293
1294         my $_storage = OpenSRF::AppSession->create( 'open-ils.cstore' );
1295         my $recs = $_storage->request(
1296                         'open-ils.cstore.direct.metabib.full_rec.search.atomic',
1297                         { tag => { like => '02%'}, value => {like => "$isbn\%"}}
1298         )->gather(1);
1299
1300         return undef unless (@$recs);
1301
1302         return $_storage->request(
1303                 'open-ils.cstore.direct.biblio.record_entry.search.atomic',
1304                 { id => $recs->[0]->record }
1305         )->gather(1);
1306 }
1307 __PACKAGE__->register_method(
1308         method    => 'retrieve_isbn_object',
1309         api_name  => 'open-ils.supercat.isbn.object.retrieve',
1310         api_level => 1,
1311         argc      => 1,
1312         signature =>
1313                 { desc     => <<"                 DESC",
1314 Returns the Fieldmapper object representation of the requested bibliographic record
1315                   DESC
1316                   params   =>
1317                         [
1318                                 { name => 'isbn',
1319                                   desc => 'an ISBN',
1320                                   type => 'string' },
1321                         ],
1322                   'return' =>
1323                         { desc => 'The bib record',
1324                           type => 'object' }
1325                 }
1326 );
1327
1328
1329
1330 sub retrieve_metarecord_mods {
1331         my $self = shift;
1332         my $client = shift;
1333         my $rid = shift;
1334
1335         my $_storage = OpenSRF::AppSession->connect( 'open-ils.cstore' );
1336
1337         # Get the metarecord in question
1338         my $mr =
1339         $_storage->request(
1340                 'open-ils.cstore.direct.metabib.metarecord.retrieve' => $rid
1341         )->gather(1);
1342
1343         # Now get the map of all bib records for the metarecord
1344         my $recs =
1345         $_storage->request(
1346                 'open-ils.cstore.direct.metabib.metarecord_source_map.search.atomic',
1347                 {metarecord => $rid}
1348         )->gather(1);
1349
1350         $logger->debug("Adding ".scalar(@$recs)." bib record to the MODS of the metarecord");
1351
1352         # and retrieve the lead (master) record as MODS
1353         my ($master) =
1354                 $self   ->method_lookup('open-ils.supercat.record.mods.retrieve')
1355                         ->run($mr->master_record);
1356         my $master_mods = $_parser->parse_string($master)->documentElement;
1357         $master_mods->setNamespace( "http://www.loc.gov/mods/", "mods", 1 );
1358
1359         # ... and a MODS clone to populate, with guts removed.
1360         my $mods = $_parser->parse_string($master)->documentElement;
1361         $mods->setNamespace( "http://www.loc.gov/mods/", "mods", 1 );
1362         ($mods) = $mods->findnodes('//mods:mods');
1363         $mods->removeChildNodes;
1364
1365         # Add the metarecord ID as a (locally defined) info URI
1366         my $recordInfo = $mods
1367                 ->ownerDocument
1368                 ->createElement("mods:recordInfo");
1369
1370         my $recordIdentifier = $mods
1371                 ->ownerDocument
1372                 ->createElement("mods:recordIdentifier");
1373
1374         my ($year,$month,$day) = reverse( (localtime)[3,4,5] );
1375         $year += 1900;
1376         $month += 1;
1377
1378         my $id = $mr->id;
1379         $recordIdentifier->appendTextNode(
1380                 sprintf("tag:open-ils.org,$year-\%0.2d-\%0.2d:metabib-metarecord/$id", $month, $day)
1381         );
1382
1383         $recordInfo->appendChild($recordIdentifier);
1384         $mods->appendChild($recordInfo);
1385
1386         # Grab the title, author and ISBN for the master record and populate the metarecord
1387         my ($title) = $master_mods->findnodes( './mods:titleInfo[not(@type)]' );
1388
1389         if ($title) {
1390                 $title->setNamespace( "http://www.loc.gov/mods/", "mods", 1 );
1391                 $title = $mods->ownerDocument->importNode($title);
1392                 $mods->appendChild($title);
1393         }
1394
1395         my ($author) = $master_mods->findnodes( './mods:name[mods:role/mods:text[text()="creator"]]' );
1396         if ($author) {
1397                 $author->setNamespace( "http://www.loc.gov/mods/", "mods", 1 );
1398                 $author = $mods->ownerDocument->importNode($author);
1399                 $mods->appendChild($author);
1400         }
1401
1402         my ($isbn) = $master_mods->findnodes( './mods:identifier[@type="isbn"]' );
1403         if ($isbn) {
1404                 $isbn->setNamespace( "http://www.loc.gov/mods/", "mods", 1 );
1405                 $isbn = $mods->ownerDocument->importNode($isbn);
1406                 $mods->appendChild($isbn);
1407         }
1408
1409         # ... and loop over the constituent records
1410         for my $map ( @$recs ) {
1411
1412                 # get the MODS
1413                 my ($rec) =
1414                         $self   ->method_lookup('open-ils.supercat.record.mods.retrieve')
1415                                 ->run($map->source);
1416
1417                 my $part_mods = $_parser->parse_string($rec);
1418                 $part_mods->documentElement->setNamespace( "http://www.loc.gov/mods/", "mods", 1 );
1419                 ($part_mods) = $part_mods->findnodes('//mods:mods');
1420
1421                 for my $node ( ($part_mods->findnodes( './mods:subject' )) ) {
1422                         $node->setNamespace( "http://www.loc.gov/mods/", "mods", 1 );
1423                         $node = $mods->ownerDocument->importNode($node);
1424                         $mods->appendChild( $node );
1425                 }
1426
1427                 my $relatedItem = $mods
1428                         ->ownerDocument
1429                         ->createElement("mods:relatedItem");
1430
1431                 $relatedItem->setAttribute( type => 'constituent' );
1432
1433                 my $identifier = $mods
1434                         ->ownerDocument
1435                         ->createElement("mods:identifier");
1436
1437                 $identifier->setAttribute( type => 'uri' );
1438
1439                 my $subRecordInfo = $mods
1440                         ->ownerDocument
1441                         ->createElement("mods:recordInfo");
1442
1443                 my $subRecordIdentifier = $mods
1444                         ->ownerDocument
1445                         ->createElement("mods:recordIdentifier");
1446
1447                 my $subid = $map->source;
1448                 $subRecordIdentifier->appendTextNode(
1449                         sprintf("tag:open-ils.org,$year-\%0.2d-\%0.2d:biblio-record_entry/$subid",
1450                                 $month,
1451                                 $day
1452                         )
1453                 );
1454                 $subRecordInfo->appendChild($subRecordIdentifier);
1455
1456                 $relatedItem->appendChild( $subRecordInfo );
1457
1458                 my ($tor) = $part_mods->findnodes( './mods:typeOfResource' );
1459                 $tor->setNamespace( "http://www.loc.gov/mods/", "mods", 1 ) if ($tor);
1460                 $tor = $mods->ownerDocument->importNode($tor) if ($tor);
1461                 $relatedItem->appendChild($tor) if ($tor);
1462
1463                 if ( my ($part_isbn) = $part_mods->findnodes( './mods:identifier[@type="isbn"]' ) ) {
1464                         $part_isbn->setNamespace( "http://www.loc.gov/mods/", "mods", 1 );
1465                         $part_isbn = $mods->ownerDocument->importNode($part_isbn);
1466                         $relatedItem->appendChild( $part_isbn );
1467
1468                         if (!$isbn) {
1469                                 $isbn = $mods->appendChild( $part_isbn->cloneNode(1) );
1470                         }
1471                 }
1472
1473                 $mods->appendChild( $relatedItem );
1474
1475         }
1476
1477         $_storage->disconnect;
1478
1479         return $U->entityize($mods->toString);
1480
1481 }
1482 __PACKAGE__->register_method(
1483         method    => 'retrieve_metarecord_mods',
1484         api_name  => 'open-ils.supercat.metarecord.mods.retrieve',
1485         api_level => 1,
1486         argc      => 1,
1487         signature =>
1488                 { desc     => <<"                 DESC",
1489 Returns the MODS representation of the requested metarecord
1490                   DESC
1491                   params   =>
1492                         [
1493                                 { name => 'metarecordId',
1494                                   desc => 'An OpenILS metabib::metarecord id',
1495                                   type => 'number' },
1496                         ],
1497                   'return' =>
1498                         { desc => 'The metarecord in MODS',
1499                           type => 'string' }
1500                 }
1501 );
1502
1503 sub list_metarecord_formats {
1504         my @list = (
1505                 { mods =>
1506                         { namespace_uri   => 'http://www.loc.gov/mods/',
1507                           docs            => 'http://www.loc.gov/mods/',
1508                           schema_location => 'http://www.loc.gov/standards/mods/mods.xsd',
1509                         }
1510                 }
1511         );
1512
1513         for my $type ( keys %metarecord_xslt ) {
1514                 push @list,
1515                         { $type =>
1516                                 { namespace_uri   => $metarecord_xslt{$type}{namespace_uri},
1517                                   docs            => $metarecord_xslt{$type}{docs},
1518                                   schema_location => $metarecord_xslt{$type}{schema_location},
1519                                 }
1520                         };
1521         }
1522
1523         return \@list;
1524 }
1525 __PACKAGE__->register_method(
1526         method    => 'list_metarecord_formats',
1527         api_name  => 'open-ils.supercat.metarecord.formats',
1528         api_level => 1,
1529         argc      => 0,
1530         signature =>
1531                 { desc     => <<"                 DESC",
1532 Returns the list of valid metarecord formats that supercat understands.
1533                   DESC
1534                   'return' =>
1535                         { desc => 'The format list',
1536                           type => 'array' }
1537                 }
1538 );
1539
1540
1541 sub list_record_formats {
1542         my @list = (
1543                 { marcxml =>
1544                         { namespace_uri   => 'http://www.loc.gov/MARC21/slim',
1545                           docs            => 'http://www.loc.gov/marcxml/',
1546                           schema_location => 'http://www.loc.gov/standards/marcxml/schema/MARC21slim.xsd',
1547                         }
1548                 }
1549         );
1550
1551         for my $type ( keys %record_xslt ) {
1552                 push @list,
1553                         { $type =>
1554                                 { namespace_uri   => $record_xslt{$type}{namespace_uri},
1555                                   docs            => $record_xslt{$type}{docs},
1556                                   schema_location => $record_xslt{$type}{schema_location},
1557                                 }
1558                         };
1559         }
1560
1561         return \@list;
1562 }
1563 __PACKAGE__->register_method(
1564         method    => 'list_record_formats',
1565         api_name  => 'open-ils.supercat.record.formats',
1566         api_level => 1,
1567         argc      => 0,
1568         signature =>
1569                 { desc     => <<"                 DESC",
1570 Returns the list of valid record formats that supercat understands.
1571                   DESC
1572                   'return' =>
1573                         { desc => 'The format list',
1574                           type => 'array' }
1575                 }
1576 );
1577 __PACKAGE__->register_method(
1578         method    => 'list_record_formats',
1579         api_name  => 'open-ils.supercat.isbn.formats',
1580         api_level => 1,
1581         argc      => 0,
1582         signature =>
1583                 { desc     => <<"                 DESC",
1584 Returns the list of valid record formats that supercat understands.
1585                   DESC
1586                   'return' =>
1587                         { desc => 'The format list',
1588                           type => 'array' }
1589                 }
1590 );
1591
1592
1593 sub oISBN {
1594         my $self = shift;
1595         my $client = shift;
1596         my $isbn = shift;
1597
1598         $isbn =~ s/-//gso;
1599
1600         throw OpenSRF::EX::InvalidArg ('I need an ISBN please')
1601                 unless (length($isbn) >= 10);
1602
1603         my $_storage = OpenSRF::AppSession->create( 'open-ils.cstore' );
1604
1605         # Create a storage session, since we'll be making muliple requests.
1606         $_storage->connect;
1607
1608         # Find the record that has that ISBN.
1609         my $bibrec = $_storage->request(
1610                 'open-ils.cstore.direct.metabib.full_rec.search.atomic',
1611                 { tag => '020', subfield => 'a', value => { like => lc($isbn).'%'} }
1612         )->gather(1);
1613
1614         # Go away if we don't have one.
1615         return {} unless (@$bibrec);
1616
1617         # Find the metarecord for that bib record.
1618         my $mr = $_storage->request(
1619                 'open-ils.cstore.direct.metabib.metarecord_source_map.search.atomic',
1620                 {source => $bibrec->[0]->record}
1621         )->gather(1);
1622
1623         # Find the other records for that metarecord.
1624         my $records = $_storage->request(
1625                 'open-ils.cstore.direct.metabib.metarecord_source_map.search.atomic',
1626                 {metarecord => $mr->[0]->metarecord}
1627         )->gather(1);
1628
1629         # Just to be safe.  There's currently no unique constraint on sources...
1630         my %unique_recs = map { ($_->source, 1) } @$records;
1631         my @rec_list = sort keys %unique_recs;
1632
1633         # And now fetch the ISBNs for thos records.
1634         my $recs = [];
1635         push @$recs,
1636                 $_storage->request(
1637                         'open-ils.cstore.direct.metabib.full_rec.search',
1638                         { tag => '020', subfield => 'a', record => $_ }
1639                 )->gather(1) for (@rec_list);
1640
1641         # We're done with the storage server session.
1642         $_storage->disconnect;
1643
1644         # Return the oISBN data structure.  This will be XMLized at a higher layer.
1645         return
1646                 { metarecord => $mr->[0]->metarecord,
1647                   record_list => { map { $_ ? ($_->record, $_->value) : () } @$recs } };
1648
1649 }
1650 __PACKAGE__->register_method(
1651         method    => 'oISBN',
1652         api_name  => 'open-ils.supercat.oisbn',
1653         api_level => 1,
1654         argc      => 1,
1655         signature =>
1656                 { desc     => <<"                 DESC",
1657 Returns the ISBN list for the metarecord of the requested isbn
1658                   DESC
1659                   params   =>
1660                         [
1661                                 { name => 'isbn',
1662                                   desc => 'An ISBN.  Duh.',
1663                                   type => 'string' },
1664                         ],
1665                   'return' =>
1666                         { desc => 'record to isbn map',
1667                           type => 'object' }
1668                 }
1669 );
1670
1671 package OpenILS::Application::SuperCat::unAPI;
1672 use base qw/OpenILS::Application::SuperCat/;
1673
1674 sub as_xml {
1675     die "dummy superclass, use a real class";
1676 }
1677
1678 sub new {
1679     my $class = shift;
1680     my $obj = shift;
1681     return unless ($obj);
1682
1683     $class = ref($class) || $class;
1684
1685     if ($class eq __PACKAGE__) {
1686         return unless (ref($obj));
1687         $class .= '::' . $obj->json_hint;
1688     }
1689
1690     return bless { obj => $obj } => $class;
1691 }
1692
1693 sub obj {
1694     my $self = shift;
1695     return $self->{obj};
1696 }
1697
1698 package OpenILS::Application::SuperCat::unAPI::auri;
1699 use base qw/OpenILS::Application::SuperCat::unAPI/;
1700
1701 sub as_xml {
1702     my $self = shift;
1703     my $args = shift;
1704
1705     my $xml = '      <uri xmlns="http://open-ils.org/spec/holdings/v1" ';
1706     $xml .= 'id="tag:open-ils.org:asset-uri/' . $self->obj->id . '" ';
1707     $xml .= 'use_restriction="' . $self->escape( $self->obj->use_restriction ) . '" ';
1708     $xml .= 'label="' . $self->escape( $self->obj->label ) . '" ';
1709     $xml .= 'href="' . $self->escape( $self->obj->href ) . '">';
1710
1711     if (!$args->{no_volumes}) {
1712         if (ref($self->obj->call_number_maps) && @{ $self->obj->call_number_maps }) {
1713             $xml .= "      <volumes>\n" . join(
1714                 '',
1715                 map {
1716                     OpenILS::Application::SuperCat::unAPI
1717                         ->new( $_->call_number )
1718                         ->as_xml({ %$args, no_uris=>1, no_copies=>1 })
1719                 } @{ $self->obj->call_number_maps }
1720             ) . "      </volumes>\n";
1721
1722         } else {
1723             $xml .= "      <volumes/>\n";
1724         }
1725     }
1726
1727     $xml .= "      </uri>\n";
1728
1729     return $xml;
1730 }
1731
1732 package OpenILS::Application::SuperCat::unAPI::acn;
1733 use base qw/OpenILS::Application::SuperCat::unAPI/;
1734
1735 sub as_xml {
1736     my $self = shift;
1737     my $args = shift;
1738
1739     my $xml = '    <volume xmlns="http://open-ils.org/spec/holdings/v1" ';
1740
1741     $xml .= 'id="tag:open-ils.org:asset-call_number/' . $self->obj->id . '" ';
1742     $xml .= 'lib="' . $self->escape( $self->obj->owning_lib->shortname ) . '" ';
1743     $xml .= 'label="' . $self->escape( $self->obj->label ) . '">';
1744     $xml .= "\n";
1745
1746     if (!$args->{no_copies}) {
1747         if (ref($self->obj->copies) && @{ $self->obj->copies }) {
1748             $xml .= "      <copies>\n" . join(
1749                 '',
1750                 map {
1751                     OpenILS::Application::SuperCat::unAPI
1752                         ->new( $_ )
1753                         ->as_xml({ %$args, no_volume=>1 })
1754                 } @{ $self->obj->copies }
1755             ) . "      </copies>\n";
1756
1757         } else {
1758             $xml .= "      <copies/>\n";
1759         }
1760     }
1761
1762     if (!$args->{no_uris}) {
1763         if (ref($self->obj->uri_maps) && @{ $self->obj->uri_maps }) {
1764             $xml .= "      <uris>\n" . join(
1765                 '',
1766                 map {
1767                     OpenILS::Application::SuperCat::unAPI
1768                         ->new( $_->uri )
1769                         ->as_xml({ %$args, no_volumes=>1 })
1770                 } @{ $self->obj->uri_maps }
1771             ) . "      </uris>\n";
1772
1773         } else {
1774             $xml .= "      <uris/>\n";
1775         }
1776     }
1777
1778
1779     $xml .= '      <owning_lib xmlns="http://open-ils.org/spec/actors/v1" ';
1780     $xml .= 'id="tag:open-ils.org:actor-org_unit/' . $self->obj->owning_lib->id . '" ';
1781     $xml .= 'shortname="'.$self->escape( $self->obj->owning_lib->shortname ) .'" ';
1782     $xml .= 'name="'.$self->escape( $self->obj->owning_lib->name ) .'"/>';
1783     $xml .= "\n";
1784
1785     unless ($args->{no_record}) {
1786         my $rec_tag = "tag:open-ils.org:biblio-record_entry/".$self->obj->record->id.'/'.$self->escape( $self->obj->owning_lib->shortname ) ;
1787
1788         my $r_doc = $parser->parse_string($self->obj->record->marc);
1789         $r_doc->documentElement->setAttribute( id => $rec_tag );
1790         $xml .= $U->entityize($r_doc->documentElement->toString);
1791     }
1792
1793     $xml .= "    </volume>\n";
1794
1795     return $xml;
1796 }
1797
1798 package OpenILS::Application::SuperCat::unAPI::acp;
1799 use base qw/OpenILS::Application::SuperCat::unAPI/;
1800
1801 sub as_xml {
1802     my $self = shift;
1803     my $args = shift;
1804
1805     my $xml = '      <copy xmlns="http://open-ils.org/spec/holdings/v1" '.
1806         'id="tag:open-ils.org:asset-copy/' . $self->obj->id . '" ';
1807
1808     $xml .= $_ . '="' . $self->escape( $self->obj->$_  ) . '" ' for (qw/
1809         create_date edit_date copy_number circulate deposit ref holdable deleted
1810         deposit_amount price barcode circ_modifier circ_as_type opac_visible
1811     /);
1812
1813     $xml .= ">\n";
1814
1815     $xml .= '        <status ident="' . $self->obj->status->id . '">' . $self->escape( $self->obj->status->name  ) . "</status>\n";
1816     $xml .= '        <location ident="' . $self->obj->location->id . '">' . $self->escape( $self->obj->location->name  ) . "</location>\n";
1817     $xml .= '        <circlib ident="' . $self->obj->circ_lib->id . '">' . $self->escape( $self->obj->circ_lib->name  ) . "</circlib>\n";
1818
1819     $xml .= '        <circ_lib xmlns="http://open-ils.org/spec/actors/v1" ';
1820     $xml .= 'id="tag:open-ils.org:actor-org_unit/' . $self->obj->circ_lib->id . '" ';
1821     $xml .= 'shortname="'.$self->escape( $self->obj->circ_lib->shortname ) .'" ';
1822     $xml .= 'name="'.$self->escape( $self->obj->circ_lib->name ) .'"/>';
1823     $xml .= "\n";
1824
1825         $xml .= "        <copy_notes>\n";
1826         if (ref($self->obj->notes) && $self->obj->notes) {
1827                 for my $note ( @{$self->obj->notes} ) {
1828                         next unless ( $note->pub eq 't' );
1829                         $xml .= sprintf('        <copy_note date="%s" title="%s">%s</copy_note>',$note->create_date, $self->escape($note->title), $self->escape($note->value));
1830                         $xml .= "\n";
1831                 }
1832         }
1833
1834         $xml .= "        </copy_notes>\n";
1835     $xml .= "        <statcats>\n";
1836
1837         if (ref($self->obj->stat_cat_entries) && $self->obj->stat_cat_entries) {
1838                 for my $sce ( @{$self->obj->stat_cat_entries} ) {
1839                         next unless ( $sce->stat_cat->opac_visible eq 't' );
1840                         $xml .= sprintf('          <statcat name="%s">%s</statcat>',$self->escape($sce->stat_cat->name) ,$self->escape($sce->value));
1841                         $xml .= "\n";
1842                 }
1843         }
1844         $xml .= "        </statcats>\n";
1845
1846     unless ($args->{no_volume}) {
1847         if (ref($self->obj->call_number)) {
1848             $xml .= OpenILS::Application::SuperCat::unAPI
1849                         ->new( $self->obj->call_number )
1850                         ->as_xml({ %$args, no_copies=>1 });
1851         } else {
1852             $xml .= "    <volume/>\n";
1853         }
1854     }
1855
1856     $xml .= "      </copy>\n";
1857
1858     return $xml;
1859 }
1860
1861
1862 1;
1863 # vim: noet:ts=4:sw=4