3 # Copyright ByWater Solutions 2014
5 # This file is part of Koha.
7 # Koha is free software; you can redistribute it and/or modify it under the
8 # terms of the GNU General Public License as published by the Free Software
9 # Foundation; either version 3 of the License, or (at your option) any later
12 # Koha is distributed in the hope that it will be useful, but WITHOUT ANY
13 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
14 # A PARTICULAR PURPOSE. See the GNU General Public License for more details.
16 # You should have received a copy of the GNU General Public License along
17 # with Koha; if not, write to the Free Software Foundation, Inc.,
18 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
23 use List::MoreUtils qw(any);
31 use Koha::DateUtils qw( dt_from_string );
33 use base qw(Koha::Object);
35 use Koha::Acquisition::Orders;
36 use Koha::ArticleRequest::Status;
37 use Koha::ArticleRequests;
38 use Koha::Biblio::Metadatas;
39 use Koha::Biblioitems;
40 use Koha::IssuingRules;
41 use Koha::Item::Transfer::Limits;
44 use Koha::Suggestions;
45 use Koha::Subscriptions;
49 Koha::Biblio - Koha Biblio Object class
59 Overloaded I<store> method to set default values
66 $self->datecreated( dt_from_string ) unless $self->datecreated;
68 return $self->SUPER::store;
73 my $metadata = $biblio->metadata();
75 Returns a Koha::Biblio::Metadata object
82 my $metadata = $self->_result->metadata;
83 return Koha::Biblio::Metadata->_new_from_dbic($metadata);
88 my $orders = $biblio->orders();
90 Returns a Koha::Acquisition::Orders object
97 my $orders = $self->_result->orders;
98 return Koha::Acquisition::Orders->_new_from_dbic($orders);
101 =head3 active_orders_count
103 my $orders_count = $biblio->active_orders_count();
105 Returns the number of active acquisition orders related to this biblio.
106 An order is considered active when it is not cancelled (i.e. when datecancellation
111 sub active_orders_count {
114 return $self->orders->search({ datecancellationprinted => undef })->count;
117 =head3 can_article_request
119 my $bool = $biblio->can_article_request( $borrower );
121 Returns true if article requests can be made for this record
123 $borrower must be a Koha::Patron object
127 sub can_article_request {
128 my ( $self, $borrower ) = @_;
130 my $rule = $self->article_request_type($borrower);
131 return q{} if $rule eq 'item_only' && !$self->items()->count();
132 return 1 if $rule && $rule ne 'no';
137 =head3 can_be_transferred
139 $biblio->can_be_transferred({ to => $to_library, from => $from_library })
141 Checks if at least one item of a biblio can be transferred to given library.
143 This feature is controlled by two system preferences:
144 UseBranchTransferLimits to enable / disable the feature
145 BranchTransferLimitsType to use either an itemnumber or ccode as an identifier
146 for setting the limitations
148 Performance-wise, it is recommended to use this method for a biblio instead of
149 iterating each item of a biblio with Koha::Item->can_be_transferred().
151 Takes HASHref that can have the following parameters:
152 MANDATORY PARAMETERS:
155 $from : Koha::Library # if given, only items from that
156 # holdingbranch are considered
158 Returns 1 if at least one of the item of a biblio can be transferred
159 to $to_library, otherwise 0.
163 sub can_be_transferred {
164 my ($self, $params) = @_;
166 my $to = $params->{to};
167 my $from = $params->{from};
169 return 1 unless C4::Context->preference('UseBranchTransferLimits');
170 my $limittype = C4::Context->preference('BranchTransferLimitsType');
173 foreach my $item_of_bib ($self->items->as_list) {
174 next unless $item_of_bib->holdingbranch;
175 next if $from && $from->branchcode ne $item_of_bib->holdingbranch;
176 return 1 if $item_of_bib->holdingbranch eq $to->branchcode;
177 my $code = $limittype eq 'itemtype'
178 ? $item_of_bib->effective_itemtype
179 : $item_of_bib->ccode;
180 return 1 unless $code;
181 $items->{$code}->{$item_of_bib->holdingbranch} = 1;
184 # At this point we will have a HASHref containing each itemtype/ccode that
185 # this biblio has, inside which are all of the holdingbranches where those
186 # items are located at. Then, we will query Koha::Item::Transfer::Limits to
187 # find out whether a transfer limits for such $limittype from any of the
188 # listed holdingbranches to the given $to library exist. If at least one
189 # holdingbranch for that $limittype does not have a transfer limit to given
190 # $to library, then we know that the transfer is possible.
191 foreach my $code (keys %{$items}) {
192 my @holdingbranches = keys %{$items->{$code}};
193 return 1 if Koha::Item::Transfer::Limits->search({
194 toBranch => $to->branchcode,
195 fromBranch => { 'in' => \@holdingbranches },
198 group_by => [qw/fromBranch/]
199 })->count == scalar(@holdingbranches) ? 0 : 1;
206 =head3 pickup_locations
208 @pickup_locations = $biblio->pickup_locations( {patron => $patron } )
210 Returns possible pickup locations for this biblio items, according to patron's home library (if patron is defined and holds are allowed only from hold groups)
211 and if item can be transferred to each pickup location.
215 sub pickup_locations {
216 my ($self, $params) = @_;
218 my $patron = $params->{patron};
220 my @pickup_locations;
221 foreach my $item_of_bib ($self->items->as_list) {
222 push @pickup_locations, $item_of_bib->pickup_locations( {patron => $patron} );
227 grep { !$seen{ $_->branchcode }++ } @pickup_locations;
229 return wantarray ? @pickup_locations : \@pickup_locations;
232 =head3 hidden_in_opac
234 my $bool = $biblio->hidden_in_opac({ [ rules => $rules ] })
236 Returns true if the biblio matches the hidding criteria defined in $rules.
237 Returns false otherwise.
239 Takes HASHref that can have the following parameters:
241 $rules : { <field> => [ value_1, ... ], ... }
243 Note: $rules inherits its structure from the parsed YAML from reading
244 the I<OpacHiddenItems> system preference.
249 my ( $self, $params ) = @_;
251 my $rules = $params->{rules} // {};
253 my @items = $self->items->as_list;
255 return 0 unless @items; # Do not hide if there is no item
257 return !(any { !$_->hidden_in_opac({ rules => $rules }) } @items);
260 =head3 article_request_type
262 my $type = $biblio->article_request_type( $borrower );
264 Returns the article request type based on items, or on the record
265 itself if there are no items.
267 $borrower must be a Koha::Patron object
271 sub article_request_type {
272 my ( $self, $borrower ) = @_;
274 return q{} unless $borrower;
276 my $rule = $self->article_request_type_for_items( $borrower );
277 return $rule if $rule;
279 # If the record has no items that are requestable, go by the record itemtype
280 $rule = $self->article_request_type_for_bib($borrower);
281 return $rule if $rule;
286 =head3 article_request_type_for_bib
288 my $type = $biblio->article_request_type_for_bib
290 Returns the article request type 'yes', 'no', 'item_only', 'bib_only', for the given record
294 sub article_request_type_for_bib {
295 my ( $self, $borrower ) = @_;
297 return q{} unless $borrower;
299 my $borrowertype = $borrower->categorycode;
300 my $itemtype = $self->itemtype();
302 my $issuing_rule = Koha::IssuingRules->get_effective_issuing_rule({ categorycode => $borrowertype, itemtype => $itemtype });
304 return q{} unless $issuing_rule;
305 return $issuing_rule->article_requests || q{}
308 =head3 article_request_type_for_items
310 my $type = $biblio->article_request_type_for_items
312 Returns the article request type 'yes', 'no', 'item_only', 'bib_only', for the given record's items
314 If there is a conflict where some items are 'bib_only' and some are 'item_only', 'bib_only' will be returned.
318 sub article_request_type_for_items {
319 my ( $self, $borrower ) = @_;
322 foreach my $item ( $self->items()->as_list() ) {
323 my $rule = $item->article_request_type($borrower);
324 return $rule if $rule eq 'bib_only'; # we don't need to go any further
328 return 'item_only' if $counts->{item_only};
329 return 'yes' if $counts->{yes};
330 return 'no' if $counts->{no};
334 =head3 article_requests
336 my @requests = $biblio->article_requests
338 Returns the article requests associated with this Biblio
342 sub article_requests {
343 my ( $self, $borrower ) = @_;
345 $self->{_article_requests} ||= Koha::ArticleRequests->search( { biblionumber => $self->biblionumber() } );
347 return wantarray ? $self->{_article_requests}->as_list : $self->{_article_requests};
350 =head3 article_requests_current
352 my @requests = $biblio->article_requests_current
354 Returns the article requests associated with this Biblio that are incomplete
358 sub article_requests_current {
359 my ( $self, $borrower ) = @_;
361 $self->{_article_requests_current} ||= Koha::ArticleRequests->search(
363 biblionumber => $self->biblionumber(),
365 { status => Koha::ArticleRequest::Status::Pending },
366 { status => Koha::ArticleRequest::Status::Processing }
371 return wantarray ? $self->{_article_requests_current}->as_list : $self->{_article_requests_current};
374 =head3 article_requests_finished
376 my @requests = $biblio->article_requests_finished
378 Returns the article requests associated with this Biblio that are completed
382 sub article_requests_finished {
383 my ( $self, $borrower ) = @_;
385 $self->{_article_requests_finished} ||= Koha::ArticleRequests->search(
387 biblionumber => $self->biblionumber(),
389 { status => Koha::ArticleRequest::Status::Completed },
390 { status => Koha::ArticleRequest::Status::Canceled }
395 return wantarray ? $self->{_article_requests_finished}->as_list : $self->{_article_requests_finished};
400 my $items = $biblio->items();
402 Returns the related Koha::Items object for this biblio
409 my $items_rs = $self->_result->items;
411 return Koha::Items->_new_from_dbic( $items_rs );
416 my $items_count = $biblio->items();
418 Returns the count of the the related Koha::Items object for this biblio
425 return $self->_result->items->count;
430 my $itemtype = $biblio->itemtype();
432 Returns the itemtype for this record.
439 return $self->biblioitem()->itemtype();
444 my $holds = $biblio->holds();
446 return the current holds placed on this record
451 my ( $self, $params, $attributes ) = @_;
452 $attributes->{order_by} = 'priority' unless exists $attributes->{order_by};
453 my $hold_rs = $self->_result->reserves->search( $params, $attributes );
454 return Koha::Holds->_new_from_dbic($hold_rs);
459 my $holds = $biblio->current_holds
461 Return the holds placed on this bibliographic record.
462 It does not include future holds.
468 my $dtf = Koha::Database->new->schema->storage->datetime_parser;
470 { reservedate => { '<=' => $dtf->format_date(dt_from_string) } } );
475 my $field = $self->biblioitem()->itemtype
477 Returns the related Koha::Biblioitem object for this Biblio object
484 $self->{_biblioitem} ||= Koha::Biblioitems->find( { biblionumber => $self->biblionumber() } );
486 return $self->{_biblioitem};
491 my $suggestions = $self->suggestions
493 Returns the related Koha::Suggestions object for this Biblio object
500 my $suggestions_rs = $self->_result->suggestions;
501 return Koha::Suggestions->_new_from_dbic( $suggestions_rs );
506 my $subscriptions = $self->subscriptions
508 Returns the related Koha::Subscriptions object for this Biblio object
515 $self->{_subscriptions} ||= Koha::Subscriptions->search( { biblionumber => $self->biblionumber } );
517 return $self->{_subscriptions};
520 =head3 subscriptions_count
522 my $subscriptions_count = $self->subscriptions_count
524 Returns the count of the the related Koha::Subscriptions object for this biblio
528 sub subscriptions_count {
531 return $self->subscriptions->count;
534 =head3 has_items_waiting_or_intransit
536 my $itemsWaitingOrInTransit = $biblio->has_items_waiting_or_intransit
538 Tells if this bibliographic record has items waiting or in transit.
542 sub has_items_waiting_or_intransit {
545 if ( Koha::Holds->search({ biblionumber => $self->id,
546 found => ['W', 'T'] })->count ) {
550 foreach my $item ( $self->items->as_list ) {
551 return 1 if $item->get_transfer;
559 my $coins = $biblio->get_coins;
561 Returns the COinS (a span) which can be included in a biblio record
568 my $record = $self->metadata->record;
570 my $pos7 = substr $record->leader(), 7, 1;
571 my $pos6 = substr $record->leader(), 6, 1;
574 my ( $aulast, $aufirst ) = ( '', '' );
585 # For the purposes of generating COinS metadata, LDR/06-07 can be
586 # considered the same for UNIMARC and MARC21
595 'i' => 'audioRecording',
596 'j' => 'audioRecording',
599 'm' => 'computerProgram',
604 'a' => 'journalArticle',
608 $genre = $fmts6->{$pos6} ? $fmts6->{$pos6} : 'book';
610 if ( $genre eq 'book' ) {
611 $genre = $fmts7->{$pos7} if $fmts7->{$pos7};
614 ##### We must transform mtx to a valable mtx and document type ####
615 if ( $genre eq 'book' ) {
618 } elsif ( $genre eq 'journal' ) {
621 } elsif ( $genre eq 'journalArticle' ) {
629 if ( C4::Context->preference("marcflavour") eq "UNIMARC" ) {
632 $aulast = $record->subfield( '700', 'a' ) || '';
633 $aufirst = $record->subfield( '700', 'b' ) || '';
634 push @authors, "$aufirst $aulast" if ($aufirst or $aulast);
637 if ( $record->field('200') ) {
638 for my $au ( $record->field('200')->subfield('g') ) {
643 $title = $record->subfield( '200', 'a' );
644 my $subfield_210d = $record->subfield('210', 'd');
645 if ($subfield_210d and $subfield_210d =~ /(\d{4})/) {
648 $publisher = $record->subfield( '210', 'c' ) || '';
649 $isbn = $record->subfield( '010', 'a' ) || '';
650 $issn = $record->subfield( '011', 'a' ) || '';
653 # MARC21 need some improve
656 if ( $record->field('100') ) {
657 push @authors, $record->subfield( '100', 'a' );
661 if ( $record->field('700') ) {
662 for my $au ( $record->field('700')->subfield('a') ) {
666 $title = $record->field('245')->as_string('ab');
667 if ($titletype eq 'a') {
668 $pubyear = $record->field('008') || '';
669 $pubyear = substr($pubyear->data(), 7, 4) if $pubyear;
670 $isbn = $record->subfield( '773', 'z' ) || '';
671 $issn = $record->subfield( '773', 'x' ) || '';
672 $hosttitle = $record->subfield( '773', 't' ) || $record->subfield( '773', 'a') || q{};
673 my @rels = $record->subfield( '773', 'g' );
674 $pages = join(', ', @rels);
676 $pubyear = $record->subfield( '260', 'c' ) || '';
677 $publisher = $record->subfield( '260', 'b' ) || '';
678 $isbn = $record->subfield( '020', 'a' ) || '';
679 $issn = $record->subfield( '022', 'a' ) || '';
685 [ 'ctx_ver', 'Z39.88-2004' ],
686 [ 'rft_val_fmt', "info:ofi/fmt:kev:mtx:$mtx" ],
687 [ ($mtx eq 'dc' ? 'rft.type' : 'rft.genre'), $genre ],
688 [ "rft.${titletype}title", $title ],
691 # rft.title is authorized only once, so by checking $titletype
692 # we ensure that rft.title is not already in the list.
693 if ($hosttitle and $titletype) {
694 push @params, [ 'rft.title', $hosttitle ];
698 [ 'rft.isbn', $isbn ],
699 [ 'rft.issn', $issn ],
702 # If it's a subscription, these informations have no meaning.
703 if ($genre ne 'journal') {
705 [ 'rft.aulast', $aulast ],
706 [ 'rft.aufirst', $aufirst ],
707 (map { [ 'rft.au', $_ ] } @authors),
708 [ 'rft.pub', $publisher ],
709 [ 'rft.date', $pubyear ],
710 [ 'rft.pages', $pages ],
714 my $coins_value = join( '&',
715 map { $$_[1] ? $$_[0] . '=' . uri_escape_utf8( $$_[1] ) : () } @params );
722 my $url = $biblio->get_openurl;
724 Returns url for OpenURL resolver set in OpenURLResolverURL system preference
731 my $OpenURLResolverURL = C4::Context->preference('OpenURLResolverURL');
733 if ($OpenURLResolverURL) {
734 my $uri = URI->new($OpenURLResolverURL);
736 if (not defined $uri->query) {
737 $OpenURLResolverURL .= '?';
739 $OpenURLResolverURL .= '&';
741 $OpenURLResolverURL .= $self->get_coins;
744 return $OpenURLResolverURL;
749 my $serial = $biblio->is_serial
751 Return boolean true if this bibbliographic record is continuing resource
758 return 1 if $self->serial;
760 my $record = $self->metadata->record;
761 return 1 if substr($record->leader, 7, 1) eq 's';
766 =head3 custom_cover_image_url
768 my $image_url = $biblio->custom_cover_image_url
770 Return the specific url of the cover image for this bibliographic record.
771 It is built regaring the value of the system preference CustomCoverImagesURL
775 sub custom_cover_image_url {
777 my $url = C4::Context->preference('CustomCoverImagesURL');
778 if ( $url =~ m|{isbn}| ) {
779 my $isbn = $self->biblioitem->isbn;
780 $url =~ s|{isbn}|$isbn|g;
782 if ( $url =~ m|{normalized_isbn}| ) {
783 my $normalized_isbn = C4::Koha::GetNormalizedISBN($self->biblioitem->isbn);
784 $url =~ s|{normalized_isbn}|$normalized_isbn|g;
786 if ( $url =~ m|{issn}| ) {
787 my $issn = $self->biblioitem->issn;
788 $url =~ s|{issn}|$issn|g;
791 my $re = qr|{(?<field>\d{3})\$(?<subfield>.)}|;
793 my $field = $+{field};
794 my $subfield = $+{subfield};
795 my $marc_record = $self->metadata->record;
796 my $value = $marc_record->subfield($field, $subfield);
797 $url =~ s|$re|$value|;
805 my $json = $biblio->to_api;
807 Overloaded method that returns a JSON representation of the Koha::Biblio object,
808 suitable for API output. The related Koha::Biblioitem object is merged as expected
814 my ($self, $args) = @_;
816 my @embeds = keys %{ $args->{embed} };
817 my $remaining_embeds = {};
819 foreach my $embed (@embeds) {
820 $remaining_embeds = delete $args->{embed}->{$embed}
821 unless $self->can($embed);
824 my $response = $self->SUPER::to_api( $args );
825 my $biblioitem = $self->biblioitem->to_api({ embed => $remaining_embeds });
827 return { %$response, %$biblioitem };
830 =head3 to_api_mapping
832 This method returns the mapping for representing a Koha::Biblio object
839 biblionumber => 'biblio_id',
840 frameworkcode => 'framework_id',
841 unititle => 'uniform_title',
842 seriestitle => 'series_title',
843 copyrightdate => 'copyright_date',
844 datecreated => 'creation_date'
848 =head2 Internal methods
860 Kyle M Hall <kyle@bywatersolutions.com>