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         my $paging = shift;
 937
 938     $paging = [-1,0] if (!$paging or !ref($paging) or @$paging == 0);
 939     my $limit = $$paging[0];
 940     my $offset = $$paging[1] || 0;
 941
 942         my $_storage = OpenSRF::AppSession->create( 'open-ils.cstore' );
 943
 944         my $o_search = { shortname => uc($ou) };
 945         if (!$ou || $ou eq '-') {
 946                 $o_search = { parent_ou => undef };
 947         }
 948
 949         my $orgs = $_storage->request(
 950                 "open-ils.cstore.direct.actor.org_unit.search",
 951                 $o_search,
 952                 { flesh         => 100,
 953                   flesh_fields  => { aou        => [qw/children/] }
 954                 }
 955         )->gather(1);
 956
 957         my @ou_ids = tree_walker($orgs, 'children', sub {shift->id}) if $orgs;
 958
 959         $logger->info("Searching for holdings at orgs [".join(',',@ou_ids)."], based on $ou");
 960
 961         my $cns = $_storage->request(
 962                 "open-ils.cstore.direct.asset.call_number.search.atomic",
 963                 { record  => $bib,
 964           deleted => 'f',
 965           '-or'   => [
 966             { owning_lib => \@ou_ids },
 967             { '-exists'  =>
 968                 { from  => 'acp',
 969                   where =>
 970                     { call_number => { '=' => {'+acn'=>'id'} },
 971                       deleted => 'f',
 972                       circ_lib => \@ou_ids
 973                   }
 974                 }
 975             }
 976           ]
 977         },
 978                 { flesh         => 5,
 979                   flesh_fields  => {
 980                                         acn     => [qw/copies owning_lib uri_maps/],
 981                                         auricnm => [qw/uri/],
 982                                         acp     => [qw/circ_lib location status stat_cat_entries notes/],
 983                                         asce    => [qw/stat_cat/],
 984                                 },
 985           ( $limit > -1 ? ( limit  => $limit  ) : () ),
 986           ( $offset     ? ( offset => $offset ) : () ),
 987           order_by  => { acn => { label => {} } }
 988                 }
 989         )->gather(1);
 990
 991         my ($year,$month,$day) = reverse( (localtime)[3,4,5] );
 992         $year += 1900;
 993         $month += 1;
 994
 995         $client->respond("<volumes xmlns='http://open-ils.org/spec/holdings/v1'>\n");
 996
 997         for my $cn (@$cns) {
 998                 next unless (@{$cn->copies} > 0 or (ref($cn->uri_maps) and @{$cn->uri_maps}));
 999
1000                 # We don't want O:A:S:unAPI::acn to return the record, we've got that already
1001                 # In the context of BibTemplate, copies aren't necessary because we pull those
1002                 # in a separate call
1003         $client->respond(
1004             OpenILS::Application::SuperCat::unAPI::acn
1005                 ->new( $cn )
1006                 ->as_xml( {no_record => 1, no_copies => $hide_copies} )
1007         );
1008         }
1009
1010         return "</volumes>\n";
1011 }
1012 __PACKAGE__->register_method(
1013         method    => 'new_record_holdings',
1014         api_name  => 'open-ils.supercat.record.holdings_xml.retrieve',
1015         api_level => 1,
1016         argc      => 1,
1017         stream    => 1,
1018         signature =>
1019                 { desc     => <<"                 DESC",
1020 Returns the XML representation of the requested bibliographic record's holdings
1021                   DESC
1022                   params   =>
1023                         [
1024                                 { name => 'bibId',
1025                                   desc => 'An OpenILS biblio::record_entry ID',
1026                                   type => 'number' },
1027                                 { name => 'orgUnit',
1028                                   desc => 'An OpenILS actor::org_unit short name that limits the scope of returned holdings',
1029                                   type => 'text' },
1030                                 { name => 'hideCopies',
1031                                   desc => 'Flag that prevents the inclusion of copies in the returned holdings',
1032                                   type => 'boolean' },
1033                                 { name => 'paging',
1034                                   desc => 'Arry of limit and offset for holdings paging',
1035                                   type => 'array' },
1036                         ],
1037                   'return' =>
1038                         { desc => 'Stream of bib record holdings hierarchy in XML',
1039                           type => 'string' }
1040                 }
1041 );
1042
1043 sub isbn_holdings {
1044         my $self = shift;
1045         my $client = shift;
1046         my $isbn = shift;
1047
1048         my $_storage = OpenSRF::AppSession->create( 'open-ils.cstore' );
1049
1050         my $recs = $_storage->request(
1051                         'open-ils.cstore.direct.metabib.full_rec.search.atomic',
1052                         { tag => { like => '02%'}, value => {like => "$isbn\%"}}
1053         )->gather(1);
1054
1055         return undef unless (@$recs);
1056
1057         return ($self->method_lookup( 'open-ils.supercat.record.holdings_xml.retrieve')->run( $recs->[0]->record ))[0];
1058 }
1059 __PACKAGE__->register_method(
1060         method    => 'isbn_holdings',
1061         api_name  => 'open-ils.supercat.isbn.holdings_xml.retrieve',
1062         api_level => 1,
1063         argc      => 1,
1064         signature =>
1065                 { desc     => <<"                 DESC",
1066 Returns the XML representation of the requested bibliographic record's holdings
1067                   DESC
1068                   params   =>
1069                         [
1070                                 { name => 'isbn',
1071                                   desc => 'An isbn',
1072                                   type => 'string' },
1073                         ],
1074                   'return' =>
1075                         { desc => 'The bib record holdings hierarchy in XML',
1076                           type => 'string' }
1077                 }
1078 );
1079
1080 sub escape {
1081         my $self = shift;
1082         my $text = shift;
1083     return '' unless $text;
1084         $text =~ s/&/&amp;/gsom;
1085         $text =~ s/</&lt;/gsom;
1086         $text =~ s/>/&gt;/gsom;
1087         $text =~ s/"/\\"/gsom;
1088         return $text;
1089 }
1090
1091 sub recent_changes {
1092         my $self = shift;
1093         my $client = shift;
1094         my $when = shift || '1-01-01';
1095         my $limit = shift;
1096
1097         my $type = 'biblio';
1098         $type = 'authority' if ($self->api_name =~ /authority/o);
1099
1100         my $axis = 'create_date';
1101         $axis = 'edit_date' if ($self->api_name =~ /edit/o);
1102
1103         my $_storage = OpenSRF::AppSession->create( 'open-ils.cstore' );
1104
1105         return $_storage->request(
1106                 "open-ils.cstore.direct.$type.record_entry.id_list.atomic",
1107                 { $axis => { ">" => $when }, id => { '>' => 0 } },
1108                 { order_by => { bre => "$axis desc" }, limit => $limit }
1109         )->gather(1);
1110 }
1111
1112 for my $t ( qw/biblio authority/ ) {
1113         for my $a ( qw/import edit/ ) {
1114
1115                 __PACKAGE__->register_method(
1116                         method    => 'recent_changes',
1117                         api_name  => "open-ils.supercat.$t.record.$a.recent",
1118                         api_level => 1,
1119                         argc      => 0,
1120                         signature =>
1121                                 { desc     => "Returns a list of recently ${a}ed $t records",
1122                                   params   =>
1123                                         [
1124                                                 { name => 'when',
1125                                                   desc => "Date to start looking for ${a}ed records",
1126                                                   default => '1-01-01',
1127                                                   type => 'string' },
1128
1129                                                 { name => 'limit',
1130                                                   desc => "Maximum count to retrieve",
1131                                                   type => 'number' },
1132                                         ],
1133                                   'return' =>
1134                                         { desc => "An id list of $t records",
1135                                           type => 'array' }
1136                                 },
1137                 );
1138         }
1139 }
1140
1141
1142 sub retrieve_record_marcxml {
1143         my $self = shift;
1144         my $client = shift;
1145         my $rid = shift;
1146
1147         my $_storage = OpenSRF::AppSession->create( 'open-ils.cstore' );
1148
1149         my $record = $_storage->request( 'open-ils.cstore.direct.biblio.record_entry.retrieve' => $rid )->gather(1);
1150         return $U->entityize( $record->marc ) if ($record);
1151         return undef;
1152 }
1153
1154 __PACKAGE__->register_method(
1155         method    => 'retrieve_record_marcxml',
1156         api_name  => 'open-ils.supercat.record.marcxml.retrieve',
1157         api_level => 1,
1158         argc      => 1,
1159         signature =>
1160                 { desc     => <<"                 DESC",
1161 Returns the MARCXML representation of the requested bibliographic record
1162                   DESC
1163                   params   =>
1164                         [
1165                                 { name => 'bibId',
1166                                   desc => 'An OpenILS biblio::record_entry id',
1167                                   type => 'number' },
1168                         ],
1169                   'return' =>
1170                         { desc => 'The bib record in MARCXML',
1171                           type => 'string' }
1172                 }
1173 );
1174
1175 sub retrieve_isbn_marcxml {
1176         my $self = shift;
1177         my $client = shift;
1178         my $isbn = shift;
1179
1180         my $_storage = OpenSRF::AppSession->create( 'open-ils.cstore' );
1181
1182         my $recs = $_storage->request(
1183                         'open-ils.cstore.direct.metabib.full_rec.search.atomic',
1184                         { tag => { like => '02%'}, value => {like => "$isbn\%"}}
1185         )->gather(1);
1186
1187         return undef unless (@$recs);
1188
1189         my $record = $_storage->request( 'open-ils.cstore.direct.biblio.record_entry.retrieve' => $recs->[0]->record )->gather(1);
1190         return $U->entityize( $record->marc ) if ($record);
1191         return undef;
1192 }
1193
1194 __PACKAGE__->register_method(
1195         method    => 'retrieve_isbn_marcxml',
1196         api_name  => 'open-ils.supercat.isbn.marcxml.retrieve',
1197         api_level => 1,
1198         argc      => 1,
1199         signature =>
1200                 { desc     => <<"                 DESC",
1201 Returns the MARCXML representation of the requested ISBN
1202                   DESC
1203                   params   =>
1204                         [
1205                                 { name => 'ISBN',
1206                                   desc => 'An ... um ... ISBN',
1207                                   type => 'string' },
1208                         ],
1209                   'return' =>
1210                         { desc => 'The bib record in MARCXML',
1211                           type => 'string' }
1212                 }
1213 );
1214
1215 sub retrieve_record_transform {
1216         my $self = shift;
1217         my $client = shift;
1218         my $rid = shift;
1219
1220         (my $transform = $self->api_name) =~ s/^.+record\.([^\.]+)\.retrieve$/$1/o;
1221
1222         my $_storage = OpenSRF::AppSession->create( 'open-ils.cstore' );
1223         #$_storage->connect;
1224
1225         my $record = $_storage->request(
1226                 'open-ils.cstore.direct.biblio.record_entry.retrieve',
1227                 $rid
1228         )->gather(1);
1229
1230         return undef unless ($record);
1231
1232         return $U->entityize($record_xslt{$transform}{xslt}->transform( $_parser->parse_string( $record->marc ) )->toString);
1233 }
1234
1235 sub retrieve_isbn_transform {
1236         my $self = shift;
1237         my $client = shift;
1238         my $isbn = shift;
1239
1240         my $_storage = OpenSRF::AppSession->create( 'open-ils.cstore' );
1241
1242         my $recs = $_storage->request(
1243                         'open-ils.cstore.direct.metabib.full_rec.search.atomic',
1244                         { tag => { like => '02%'}, value => {like => "$isbn\%"}}
1245         )->gather(1);
1246
1247         return undef unless (@$recs);
1248
1249         (my $transform = $self->api_name) =~ s/^.+isbn\.([^\.]+)\.retrieve$/$1/o;
1250
1251         my $record = $_storage->request( 'open-ils.cstore.direct.biblio.record_entry.retrieve' => $recs->[0]->record )->gather(1);
1252
1253         return undef unless ($record);
1254
1255         return $U->entityize($record_xslt{$transform}{xslt}->transform( $_parser->parse_string( $record->marc ) )->toString);
1256 }
1257
1258 sub retrieve_record_objects {
1259         my $self = shift;
1260         my $client = shift;
1261         my $ids = shift;
1262
1263         $ids = [$ids] unless (ref $ids);
1264         $ids = [grep {$_} @$ids];
1265
1266         return [] unless (@$ids);
1267
1268         my $_storage = OpenSRF::AppSession->create( 'open-ils.cstore' );
1269         return $_storage->request('open-ils.cstore.direct.biblio.record_entry.search.atomic' => { id => [grep {$_} @$ids] })->gather(1);
1270 }
1271 __PACKAGE__->register_method(
1272         method    => 'retrieve_record_objects',
1273         api_name  => 'open-ils.supercat.record.object.retrieve',
1274         api_level => 1,
1275         argc      => 1,
1276         signature =>
1277                 { desc     => <<"                 DESC",
1278 Returns the Fieldmapper object representation of the requested bibliographic records
1279                   DESC
1280                   params   =>
1281                         [
1282                                 { name => 'bibIds',
1283                                   desc => 'OpenILS biblio::record_entry ids',
1284                                   type => 'array' },
1285                         ],
1286                   'return' =>
1287                         { desc => 'The bib records',
1288                           type => 'array' }
1289                 }
1290 );
1291
1292
1293 sub retrieve_isbn_object {
1294         my $self = shift;
1295         my $client = shift;
1296         my $isbn = shift;
1297
1298         return undef unless ($isbn);
1299
1300         my $_storage = OpenSRF::AppSession->create( 'open-ils.cstore' );
1301         my $recs = $_storage->request(
1302                         'open-ils.cstore.direct.metabib.full_rec.search.atomic',
1303                         { tag => { like => '02%'}, value => {like => "$isbn\%"}}
1304         )->gather(1);
1305
1306         return undef unless (@$recs);
1307
1308         return $_storage->request(
1309                 'open-ils.cstore.direct.biblio.record_entry.search.atomic',
1310                 { id => $recs->[0]->record }
1311         )->gather(1);
1312 }
1313 __PACKAGE__->register_method(
1314         method    => 'retrieve_isbn_object',
1315         api_name  => 'open-ils.supercat.isbn.object.retrieve',
1316         api_level => 1,
1317         argc      => 1,
1318         signature =>
1319                 { desc     => <<"                 DESC",
1320 Returns the Fieldmapper object representation of the requested bibliographic record
1321                   DESC
1322                   params   =>
1323                         [
1324                                 { name => 'isbn',
1325                                   desc => 'an ISBN',
1326                                   type => 'string' },
1327                         ],
1328                   'return' =>
1329                         { desc => 'The bib record',
1330                           type => 'object' }
1331                 }
1332 );
1333
1334
1335
1336 sub retrieve_metarecord_mods {
1337         my $self = shift;
1338         my $client = shift;
1339         my $rid = shift;
1340
1341         my $_storage = OpenSRF::AppSession->connect( 'open-ils.cstore' );
1342
1343         # Get the metarecord in question
1344         my $mr =
1345         $_storage->request(
1346                 'open-ils.cstore.direct.metabib.metarecord.retrieve' => $rid
1347         )->gather(1);
1348
1349         # Now get the map of all bib records for the metarecord
1350         my $recs =
1351         $_storage->request(
1352                 'open-ils.cstore.direct.metabib.metarecord_source_map.search.atomic',
1353                 {metarecord => $rid}
1354         )->gather(1);
1355
1356         $logger->debug("Adding ".scalar(@$recs)." bib record to the MODS of the metarecord");
1357
1358         # and retrieve the lead (master) record as MODS
1359         my ($master) =
1360                 $self   ->method_lookup('open-ils.supercat.record.mods.retrieve')
1361                         ->run($mr->master_record);
1362         my $master_mods = $_parser->parse_string($master)->documentElement;
1363         $master_mods->setNamespace( "http://www.loc.gov/mods/", "mods", 1 );
1364
1365         # ... and a MODS clone to populate, with guts removed.
1366         my $mods = $_parser->parse_string($master)->documentElement;
1367         $mods->setNamespace( "http://www.loc.gov/mods/", "mods", 1 );
1368         ($mods) = $mods->findnodes('//mods:mods');
1369         $mods->removeChildNodes;
1370
1371         # Add the metarecord ID as a (locally defined) info URI
1372         my $recordInfo = $mods
1373                 ->ownerDocument
1374                 ->createElement("mods:recordInfo");
1375
1376         my $recordIdentifier = $mods
1377                 ->ownerDocument
1378                 ->createElement("mods:recordIdentifier");
1379
1380         my ($year,$month,$day) = reverse( (localtime)[3,4,5] );
1381         $year += 1900;
1382         $month += 1;
1383
1384         my $id = $mr->id;
1385         $recordIdentifier->appendTextNode(
1386                 sprintf("tag:open-ils.org,$year-\%0.2d-\%0.2d:metabib-metarecord/$id", $month, $day)
1387         );
1388
1389         $recordInfo->appendChild($recordIdentifier);
1390         $mods->appendChild($recordInfo);
1391
1392         # Grab the title, author and ISBN for the master record and populate the metarecord
1393         my ($title) = $master_mods->findnodes( './mods:titleInfo[not(@type)]' );
1394
1395         if ($title) {
1396                 $title->setNamespace( "http://www.loc.gov/mods/", "mods", 1 );
1397                 $title = $mods->ownerDocument->importNode($title);
1398                 $mods->appendChild($title);
1399         }
1400
1401         my ($author) = $master_mods->findnodes( './mods:name[mods:role/mods:text[text()="creator"]]' );
1402         if ($author) {
1403                 $author->setNamespace( "http://www.loc.gov/mods/", "mods", 1 );
1404                 $author = $mods->ownerDocument->importNode($author);
1405                 $mods->appendChild($author);
1406         }
1407
1408         my ($isbn) = $master_mods->findnodes( './mods:identifier[@type="isbn"]' );
1409         if ($isbn) {
1410                 $isbn->setNamespace( "http://www.loc.gov/mods/", "mods", 1 );
1411                 $isbn = $mods->ownerDocument->importNode($isbn);
1412                 $mods->appendChild($isbn);
1413         }
1414
1415         # ... and loop over the constituent records
1416         for my $map ( @$recs ) {
1417
1418                 # get the MODS
1419                 my ($rec) =
1420                         $self   ->method_lookup('open-ils.supercat.record.mods.retrieve')
1421                                 ->run($map->source);
1422
1423                 my $part_mods = $_parser->parse_string($rec);
1424                 $part_mods->documentElement->setNamespace( "http://www.loc.gov/mods/", "mods", 1 );
1425                 ($part_mods) = $part_mods->findnodes('//mods:mods');
1426
1427                 for my $node ( ($part_mods->findnodes( './mods:subject' )) ) {
1428                         $node->setNamespace( "http://www.loc.gov/mods/", "mods", 1 );
1429                         $node = $mods->ownerDocument->importNode($node);
1430                         $mods->appendChild( $node );
1431                 }
1432
1433                 my $relatedItem = $mods
1434                         ->ownerDocument
1435                         ->createElement("mods:relatedItem");
1436
1437                 $relatedItem->setAttribute( type => 'constituent' );
1438
1439                 my $identifier = $mods
1440                         ->ownerDocument
1441                         ->createElement("mods:identifier");
1442
1443                 $identifier->setAttribute( type => 'uri' );
1444
1445                 my $subRecordInfo = $mods
1446                         ->ownerDocument
1447                         ->createElement("mods:recordInfo");
1448
1449                 my $subRecordIdentifier = $mods
1450                         ->ownerDocument
1451                         ->createElement("mods:recordIdentifier");
1452
1453                 my $subid = $map->source;
1454                 $subRecordIdentifier->appendTextNode(
1455                         sprintf("tag:open-ils.org,$year-\%0.2d-\%0.2d:biblio-record_entry/$subid",
1456                                 $month,
1457                                 $day
1458                         )
1459                 );
1460                 $subRecordInfo->appendChild($subRecordIdentifier);
1461
1462                 $relatedItem->appendChild( $subRecordInfo );
1463
1464                 my ($tor) = $part_mods->findnodes( './mods:typeOfResource' );
1465                 $tor->setNamespace( "http://www.loc.gov/mods/", "mods", 1 ) if ($tor);
1466                 $tor = $mods->ownerDocument->importNode($tor) if ($tor);
1467                 $relatedItem->appendChild($tor) if ($tor);
1468
1469                 if ( my ($part_isbn) = $part_mods->findnodes( './mods:identifier[@type="isbn"]' ) ) {
1470                         $part_isbn->setNamespace( "http://www.loc.gov/mods/", "mods", 1 );
1471                         $part_isbn = $mods->ownerDocument->importNode($part_isbn);
1472                         $relatedItem->appendChild( $part_isbn );
1473
1474                         if (!$isbn) {
1475                                 $isbn = $mods->appendChild( $part_isbn->cloneNode(1) );
1476                         }
1477                 }
1478
1479                 $mods->appendChild( $relatedItem );
1480
1481         }
1482
1483         $_storage->disconnect;
1484
1485         return $U->entityize($mods->toString);
1486
1487 }
1488 __PACKAGE__->register_method(
1489         method    => 'retrieve_metarecord_mods',
1490         api_name  => 'open-ils.supercat.metarecord.mods.retrieve',
1491         api_level => 1,
1492         argc      => 1,
1493         signature =>
1494                 { desc     => <<"                 DESC",
1495 Returns the MODS representation of the requested metarecord
1496                   DESC
1497                   params   =>
1498                         [
1499                                 { name => 'metarecordId',
1500                                   desc => 'An OpenILS metabib::metarecord id',
1501                                   type => 'number' },
1502                         ],
1503                   'return' =>
1504                         { desc => 'The metarecord in MODS',
1505                           type => 'string' }
1506                 }
1507 );
1508
1509 sub list_metarecord_formats {
1510         my @list = (
1511                 { mods =>
1512                         { namespace_uri   => 'http://www.loc.gov/mods/',
1513                           docs            => 'http://www.loc.gov/mods/',
1514                           schema_location => 'http://www.loc.gov/standards/mods/mods.xsd',
1515                         }
1516                 }
1517         );
1518
1519         for my $type ( keys %metarecord_xslt ) {
1520                 push @list,
1521                         { $type =>
1522                                 { namespace_uri   => $metarecord_xslt{$type}{namespace_uri},
1523                                   docs            => $metarecord_xslt{$type}{docs},
1524                                   schema_location => $metarecord_xslt{$type}{schema_location},
1525                                 }
1526                         };
1527         }
1528
1529         return \@list;
1530 }
1531 __PACKAGE__->register_method(
1532         method    => 'list_metarecord_formats',
1533         api_name  => 'open-ils.supercat.metarecord.formats',
1534         api_level => 1,
1535         argc      => 0,
1536         signature =>
1537                 { desc     => <<"                 DESC",
1538 Returns the list of valid metarecord formats that supercat understands.
1539                   DESC
1540                   'return' =>
1541                         { desc => 'The format list',
1542                           type => 'array' }
1543                 }
1544 );
1545
1546
1547 sub list_record_formats {
1548         my @list = (
1549                 { marcxml =>
1550                         { namespace_uri   => 'http://www.loc.gov/MARC21/slim',
1551                           docs            => 'http://www.loc.gov/marcxml/',
1552                           schema_location => 'http://www.loc.gov/standards/marcxml/schema/MARC21slim.xsd',
1553                         }
1554                 }
1555         );
1556
1557         for my $type ( keys %record_xslt ) {
1558                 push @list,
1559                         { $type =>
1560                                 { namespace_uri   => $record_xslt{$type}{namespace_uri},
1561                                   docs            => $record_xslt{$type}{docs},
1562                                   schema_location => $record_xslt{$type}{schema_location},
1563                                 }
1564                         };
1565         }
1566
1567         return \@list;
1568 }
1569 __PACKAGE__->register_method(
1570         method    => 'list_record_formats',
1571         api_name  => 'open-ils.supercat.record.formats',
1572         api_level => 1,
1573         argc      => 0,
1574         signature =>
1575                 { desc     => <<"                 DESC",
1576 Returns the list of valid record formats that supercat understands.
1577                   DESC
1578                   'return' =>
1579                         { desc => 'The format list',
1580                           type => 'array' }
1581                 }
1582 );
1583 __PACKAGE__->register_method(
1584         method    => 'list_record_formats',
1585         api_name  => 'open-ils.supercat.isbn.formats',
1586         api_level => 1,
1587         argc      => 0,
1588         signature =>
1589                 { desc     => <<"                 DESC",
1590 Returns the list of valid record formats that supercat understands.
1591                   DESC
1592                   'return' =>
1593                         { desc => 'The format list',
1594                           type => 'array' }
1595                 }
1596 );
1597
1598
1599 sub oISBN {
1600         my $self = shift;
1601         my $client = shift;
1602         my $isbn = shift;
1603
1604         $isbn =~ s/-//gso;
1605
1606         throw OpenSRF::EX::InvalidArg ('I need an ISBN please')
1607                 unless (length($isbn) >= 10);
1608
1609         my $_storage = OpenSRF::AppSession->create( 'open-ils.cstore' );
1610
1611         # Create a storage session, since we'll be making muliple requests.
1612         $_storage->connect;
1613
1614         # Find the record that has that ISBN.
1615         my $bibrec = $_storage->request(
1616                 'open-ils.cstore.direct.metabib.full_rec.search.atomic',
1617                 { tag => '020', subfield => 'a', value => { like => lc($isbn).'%'} }
1618         )->gather(1);
1619
1620         # Go away if we don't have one.
1621         return {} unless (@$bibrec);
1622
1623         # Find the metarecord for that bib record.
1624         my $mr = $_storage->request(
1625                 'open-ils.cstore.direct.metabib.metarecord_source_map.search.atomic',
1626                 {source => $bibrec->[0]->record}
1627         )->gather(1);
1628
1629         # Find the other records for that metarecord.
1630         my $records = $_storage->request(
1631                 'open-ils.cstore.direct.metabib.metarecord_source_map.search.atomic',
1632                 {metarecord => $mr->[0]->metarecord}
1633         )->gather(1);
1634
1635         # Just to be safe.  There's currently no unique constraint on sources...
1636         my %unique_recs = map { ($_->source, 1) } @$records;
1637         my @rec_list = sort keys %unique_recs;
1638
1639         # And now fetch the ISBNs for thos records.
1640         my $recs = [];
1641         push @$recs,
1642                 $_storage->request(
1643                         'open-ils.cstore.direct.metabib.full_rec.search',
1644                         { tag => '020', subfield => 'a', record => $_ }
1645                 )->gather(1) for (@rec_list);
1646
1647         # We're done with the storage server session.
1648         $_storage->disconnect;
1649
1650         # Return the oISBN data structure.  This will be XMLized at a higher layer.
1651         return
1652                 { metarecord => $mr->[0]->metarecord,
1653                   record_list => { map { $_ ? ($_->record, $_->value) : () } @$recs } };
1654
1655 }
1656 __PACKAGE__->register_method(
1657         method    => 'oISBN',
1658         api_name  => 'open-ils.supercat.oisbn',
1659         api_level => 1,
1660         argc      => 1,
1661         signature =>
1662                 { desc     => <<"                 DESC",
1663 Returns the ISBN list for the metarecord of the requested isbn
1664                   DESC
1665                   params   =>
1666                         [
1667                                 { name => 'isbn',
1668                                   desc => 'An ISBN.  Duh.',
1669                                   type => 'string' },
1670                         ],
1671                   'return' =>
1672                         { desc => 'record to isbn map',
1673                           type => 'object' }
1674                 }
1675 );
1676
1677 package OpenILS::Application::SuperCat::unAPI;
1678 use base qw/OpenILS::Application::SuperCat/;
1679
1680 sub as_xml {
1681     die "dummy superclass, use a real class";
1682 }
1683
1684 sub new {
1685     my $class = shift;
1686     my $obj = shift;
1687     return unless ($obj);
1688
1689     $class = ref($class) || $class;
1690
1691     if ($class eq __PACKAGE__) {
1692         return unless (ref($obj));
1693         $class .= '::' . $obj->json_hint;
1694     }
1695
1696     return bless { obj => $obj } => $class;
1697 }
1698
1699 sub obj {
1700     my $self = shift;
1701     return $self->{obj};
1702 }
1703
1704 package OpenILS::Application::SuperCat::unAPI::auri;
1705 use base qw/OpenILS::Application::SuperCat::unAPI/;
1706
1707 sub as_xml {
1708     my $self = shift;
1709     my $args = shift;
1710
1711     my $xml = '      <uri xmlns="http://open-ils.org/spec/holdings/v1" ';
1712     $xml .= 'id="tag:open-ils.org:asset-uri/' . $self->obj->id . '" ';
1713     $xml .= 'use_restriction="' . $self->escape( $self->obj->use_restriction ) . '" ';
1714     $xml .= 'label="' . $self->escape( $self->obj->label ) . '" ';
1715     $xml .= 'href="' . $self->escape( $self->obj->href ) . '">';
1716
1717     if (!$args->{no_volumes}) {
1718         if (ref($self->obj->call_number_maps) && @{ $self->obj->call_number_maps }) {
1719             $xml .= "      <volumes>\n" . join(
1720                 '',
1721                 map {
1722                     OpenILS::Application::SuperCat::unAPI
1723                         ->new( $_->call_number )
1724                         ->as_xml({ %$args, no_uris=>1, no_copies=>1 })
1725                 } @{ $self->obj->call_number_maps }
1726             ) . "      </volumes>\n";
1727
1728         } else {
1729             $xml .= "      <volumes/>\n";
1730         }
1731     }
1732
1733     $xml .= "      </uri>\n";
1734
1735     return $xml;
1736 }
1737
1738 package OpenILS::Application::SuperCat::unAPI::acn;
1739 use base qw/OpenILS::Application::SuperCat::unAPI/;
1740
1741 sub as_xml {
1742     my $self = shift;
1743     my $args = shift;
1744
1745     my $xml = '    <volume xmlns="http://open-ils.org/spec/holdings/v1" ';
1746
1747     $xml .= 'id="tag:open-ils.org:asset-call_number/' . $self->obj->id . '" ';
1748     $xml .= 'lib="' . $self->escape( $self->obj->owning_lib->shortname ) . '" ';
1749     $xml .= 'label="' . $self->escape( $self->obj->label ) . '">';
1750     $xml .= "\n";
1751
1752     if (!$args->{no_copies}) {
1753         if (ref($self->obj->copies) && @{ $self->obj->copies }) {
1754             $xml .= "      <copies>\n" . join(
1755                 '',
1756                 map {
1757                     OpenILS::Application::SuperCat::unAPI
1758                         ->new( $_ )
1759                         ->as_xml({ %$args, no_volume=>1 })
1760                 } @{ $self->obj->copies }
1761             ) . "      </copies>\n";
1762
1763         } else {
1764             $xml .= "      <copies/>\n";
1765         }
1766     }
1767
1768     if (!$args->{no_uris}) {
1769         if (ref($self->obj->uri_maps) && @{ $self->obj->uri_maps }) {
1770             $xml .= "      <uris>\n" . join(
1771                 '',
1772                 map {
1773                     OpenILS::Application::SuperCat::unAPI
1774                         ->new( $_->uri )
1775                         ->as_xml({ %$args, no_volumes=>1 })
1776                 } @{ $self->obj->uri_maps }
1777             ) . "      </uris>\n";
1778
1779         } else {
1780             $xml .= "      <uris/>\n";
1781         }
1782     }
1783
1784
1785     $xml .= '      <owning_lib xmlns="http://open-ils.org/spec/actors/v1" ';
1786     $xml .= 'id="tag:open-ils.org:actor-org_unit/' . $self->obj->owning_lib->id . '" ';
1787     $xml .= 'shortname="'.$self->escape( $self->obj->owning_lib->shortname ) .'" ';
1788     $xml .= 'name="'.$self->escape( $self->obj->owning_lib->name ) .'"/>';
1789     $xml .= "\n";
1790
1791     unless ($args->{no_record}) {
1792         my $rec_tag = "tag:open-ils.org:biblio-record_entry/".$self->obj->record->id.'/'.$self->escape( $self->obj->owning_lib->shortname ) ;
1793
1794         my $r_doc = $parser->parse_string($self->obj->record->marc);
1795         $r_doc->documentElement->setAttribute( id => $rec_tag );
1796         $xml .= $U->entityize($r_doc->documentElement->toString);
1797     }
1798
1799     $xml .= "    </volume>\n";
1800
1801     return $xml;
1802 }
1803
1804 package OpenILS::Application::SuperCat::unAPI::acp;
1805 use base qw/OpenILS::Application::SuperCat::unAPI/;
1806
1807 sub as_xml {
1808     my $self = shift;
1809     my $args = shift;
1810
1811     my $xml = '      <copy xmlns="http://open-ils.org/spec/holdings/v1" '.
1812         'id="tag:open-ils.org:asset-copy/' . $self->obj->id . '" ';
1813
1814     $xml .= $_ . '="' . $self->escape( $self->obj->$_  ) . '" ' for (qw/
1815         create_date edit_date copy_number circulate deposit ref holdable deleted
1816         deposit_amount price barcode circ_modifier circ_as_type opac_visible
1817     /);
1818
1819     $xml .= ">\n";
1820
1821     $xml .= '        <status ident="' . $self->obj->status->id . '">' . $self->escape( $self->obj->status->name  ) . "</status>\n";
1822     $xml .= '        <location ident="' . $self->obj->location->id . '">' . $self->escape( $self->obj->location->name  ) . "</location>\n";
1823     $xml .= '        <circlib ident="' . $self->obj->circ_lib->id . '">' . $self->escape( $self->obj->circ_lib->name  ) . "</circlib>\n";
1824
1825     $xml .= '        <circ_lib xmlns="http://open-ils.org/spec/actors/v1" ';
1826     $xml .= 'id="tag:open-ils.org:actor-org_unit/' . $self->obj->circ_lib->id . '" ';
1827     $xml .= 'shortname="'.$self->escape( $self->obj->circ_lib->shortname ) .'" ';
1828     $xml .= 'name="'.$self->escape( $self->obj->circ_lib->name ) .'"/>';
1829     $xml .= "\n";
1830
1831         $xml .= "        <copy_notes>\n";
1832         if (ref($self->obj->notes) && $self->obj->notes) {
1833                 for my $note ( @{$self->obj->notes} ) {
1834                         next unless ( $note->pub eq 't' );
1835                         $xml .= sprintf('        <copy_note date="%s" title="%s">%s</copy_note>',$note->create_date, $self->escape($note->title), $self->escape($note->value));
1836                         $xml .= "\n";
1837                 }
1838         }
1839
1840         $xml .= "        </copy_notes>\n";
1841     $xml .= "        <statcats>\n";
1842
1843         if (ref($self->obj->stat_cat_entries) && $self->obj->stat_cat_entries) {
1844                 for my $sce ( @{$self->obj->stat_cat_entries} ) {
1845                         next unless ( $sce->stat_cat->opac_visible eq 't' );
1846                         $xml .= sprintf('          <statcat name="%s">%s</statcat>',$self->escape($sce->stat_cat->name) ,$self->escape($sce->value));
1847                         $xml .= "\n";
1848                 }
1849         }
1850         $xml .= "        </statcats>\n";
1851
1852     unless ($args->{no_volume}) {
1853         if (ref($self->obj->call_number)) {
1854             $xml .= OpenILS::Application::SuperCat::unAPI
1855                         ->new( $self->obj->call_number )
1856                         ->as_xml({ %$args, no_copies=>1 });
1857         } else {
1858             $xml .= "    <volume/>\n";
1859         }
1860     }
1861
1862     $xml .= "      </copy>\n";
1863
1864     return $xml;
1865 }
1866
1867
1868 1;
1869 # vim: noet:ts=4:sw=4