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