3 # Copyright 2007 LibLime, Inc.
4 # Parts Copyright Biblibre 2010
6 # This file is part of Koha.
8 # Koha is free software; you can redistribute it and/or modify it
9 # under the terms of the GNU General Public License as published by
10 # the Free Software Foundation; either version 3 of the License, or
11 # (at your option) any later version.
13 # Koha is distributed in the hope that it will be useful, but
14 # WITHOUT ANY WARRANTY; without even the implied warranty of
15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 # GNU General Public License for more details.
18 # You should have received a copy of the GNU General Public License
19 # along with Koha; if not, see <http://www.gnu.org/licenses>.
22 #use warnings; FIXME - Bug 2505
32 use List::MoreUtils qw/any/;
34 use DateTime::Format::MySQL;
35 use Data::Dumper; # used as part of logging item record changes, not just for
36 # debugging; so please don't remove this
38 use Koha::AuthorisedValues;
39 use Koha::DateUtils qw/dt_from_string/;
42 use Koha::Biblioitems;
44 use Koha::SearchEngine;
45 use Koha::SearchEngine::Search;
48 use vars qw(@ISA @EXPORT);
53 @ISA = qw( Exporter );
76 GetItemsByBiblioitemnumber
80 GetItemnumbersForBiblio
82 get_hostitemnumbers_of
83 GetItemnumberFromBarcode
84 GetBarcodeFromItemnumber
100 PrepareItemrecordDisplay
107 C4::Items - item management functions
111 This module contains an API for manipulating item
112 records in Koha, and is used by cataloguing, circulation,
113 acquisitions, and serials management.
115 # FIXME This POD is not up-to-date
116 A Koha item record is stored in two places: the
117 items table and embedded in a MARC tag in the XML
118 version of the associated bib record in C<biblioitems.marcxml>.
119 This is done to allow the item information to be readily
120 indexed (e.g., by Zebra), but means that each item
121 modification transaction must keep the items table
122 and the MARC XML in sync at all times.
124 Consequently, all code that creates, modifies, or deletes
125 item records B<must> use an appropriate function from
126 C<C4::Items>. If no existing function is suitable, it is
127 better to add one to C<C4::Items> than to use add
128 one-off SQL statements to add or modify items.
130 The items table will be considered authoritative. In other
131 words, if there is ever a discrepancy between the items
132 table and the MARC XML, the items table should be considered
135 =head1 HISTORICAL NOTE
137 Most of the functions in C<C4::Items> were originally in
138 the C<C4::Biblio> module.
140 =head1 CORE EXPORTED FUNCTIONS
142 The following functions are meant for use by users
149 $item = GetItem($itemnumber,$barcode,$serial);
151 Return item information, for a given itemnumber or barcode.
152 The return value is a hashref mapping item column
153 names to values. If C<$serial> is true, include serial publication data.
158 my ($itemnumber,$barcode, $serial) = @_;
159 my $dbh = C4::Context->dbh;
163 $item = Koha::Items->find( $itemnumber );
165 $item = Koha::Items->find( { barcode => $barcode } );
168 return unless ( $item );
170 my $data = $item->unblessed();
171 $data->{itype} = $item->effective_itemtype(); # set the correct itype
174 my $ssth = $dbh->prepare("SELECT serialseq,publisheddate from serialitems left join serial on serialitems.serialid=serial.serialid where serialitems.itemnumber=?");
175 $ssth->execute( $data->{'itemnumber'} );
176 ( $data->{'serialseq'}, $data->{'publisheddate'} ) = $ssth->fetchrow_array();
184 CartToShelf($itemnumber);
186 Set the current shelving location of the item record
187 to its stored permanent shelving location. This is
188 primarily used to indicate when an item whose current
189 location is a special processing ('PROC') or shelving cart
190 ('CART') location is back in the stacks.
195 my ( $itemnumber ) = @_;
197 unless ( $itemnumber ) {
198 croak "FAILED CartToShelf() - no itemnumber supplied";
201 my $item = GetItem($itemnumber);
202 if ( $item->{location} eq 'CART' ) {
203 $item->{location} = $item->{permanent_location};
204 ModItem($item, undef, $itemnumber);
210 ShelfToCart($itemnumber);
212 Set the current shelving location of the item
213 to shelving cart ('CART').
218 my ( $itemnumber ) = @_;
220 unless ( $itemnumber ) {
221 croak "FAILED ShelfToCart() - no itemnumber supplied";
224 my $item = GetItem($itemnumber);
225 $item->{'location'} = 'CART';
226 ModItem($item, undef, $itemnumber);
229 =head2 AddItemFromMarc
231 my ($biblionumber, $biblioitemnumber, $itemnumber)
232 = AddItemFromMarc($source_item_marc, $biblionumber);
234 Given a MARC::Record object containing an embedded item
235 record and a biblionumber, create a new item record.
239 sub AddItemFromMarc {
240 my ( $source_item_marc, $biblionumber ) = @_;
241 my $dbh = C4::Context->dbh;
243 # parse item hash from MARC
244 my $frameworkcode = GetFrameworkCode( $biblionumber );
245 my ($itemtag,$itemsubfield)=GetMarcFromKohaField("items.itemnumber",$frameworkcode);
247 my $localitemmarc=MARC::Record->new;
248 $localitemmarc->append_fields($source_item_marc->field($itemtag));
249 my $item = &TransformMarcToKoha( $localitemmarc, $frameworkcode ,'items');
250 my $unlinked_item_subfields = _get_unlinked_item_subfields($localitemmarc, $frameworkcode);
251 return AddItem($item, $biblionumber, $dbh, $frameworkcode, $unlinked_item_subfields);
256 my ($biblionumber, $biblioitemnumber, $itemnumber)
257 = AddItem($item, $biblionumber[, $dbh, $frameworkcode, $unlinked_item_subfields]);
259 Given a hash containing item column names as keys,
260 create a new Koha item record.
262 The first two optional parameters (C<$dbh> and C<$frameworkcode>)
263 do not need to be supplied for general use; they exist
264 simply to allow them to be picked up from AddItemFromMarc.
266 The final optional parameter, C<$unlinked_item_subfields>, contains
267 an arrayref containing subfields present in the original MARC
268 representation of the item (e.g., from the item editor) that are
269 not mapped to C<items> columns directly but should instead
270 be stored in C<items.more_subfields_xml> and included in
271 the biblio items tag for display and indexing.
277 my $biblionumber = shift;
279 my $dbh = @_ ? shift : C4::Context->dbh;
280 my $frameworkcode = @_ ? shift : GetFrameworkCode($biblionumber);
281 my $unlinked_item_subfields;
283 $unlinked_item_subfields = shift;
286 # needs old biblionumber and biblioitemnumber
287 $item->{'biblionumber'} = $biblionumber;
288 my $sth = $dbh->prepare("SELECT biblioitemnumber FROM biblioitems WHERE biblionumber=?");
289 $sth->execute( $item->{'biblionumber'} );
290 ( $item->{'biblioitemnumber'} ) = $sth->fetchrow;
292 _set_defaults_for_add($item);
293 _set_derived_columns_for_add($item);
294 $item->{'more_subfields_xml'} = _get_unlinked_subfields_xml($unlinked_item_subfields);
296 # FIXME - checks here
297 unless ( $item->{itype} ) { # default to biblioitem.itemtype if no itype
298 my $itype_sth = $dbh->prepare("SELECT itemtype FROM biblioitems WHERE biblionumber = ?");
299 $itype_sth->execute( $item->{'biblionumber'} );
300 ( $item->{'itype'} ) = $itype_sth->fetchrow_array;
303 my ( $itemnumber, $error ) = _koha_new_item( $item, $item->{barcode} );
306 $item->{'itemnumber'} = $itemnumber;
308 ModZebra( $item->{biblionumber}, "specialUpdate", "biblioserver" );
310 logaction( "CATALOGUING", "ADD", $itemnumber, "item" )
311 if C4::Context->preference("CataloguingLog");
313 return ( $item->{biblionumber}, $item->{biblioitemnumber}, $itemnumber );
316 =head2 AddItemBatchFromMarc
318 ($itemnumber_ref, $error_ref) = AddItemBatchFromMarc($record,
319 $biblionumber, $biblioitemnumber, $frameworkcode);
321 Efficiently create item records from a MARC biblio record with
322 embedded item fields. This routine is suitable for batch jobs.
324 This API assumes that the bib record has already been
325 saved to the C<biblio> and C<biblioitems> tables. It does
326 not expect that C<biblio_metadata.metadata> is populated, but it
327 will do so via a call to ModBibiloMarc.
329 The goal of this API is to have a similar effect to using AddBiblio
330 and AddItems in succession, but without inefficient repeated
331 parsing of the MARC XML bib record.
333 This function returns an arrayref of new itemsnumbers and an arrayref of item
334 errors encountered during the processing. Each entry in the errors
335 list is a hashref containing the following keys:
341 Sequence number of original item tag in the MARC record.
345 Item barcode, provide to assist in the construction of
346 useful error messages.
350 Code representing the error condition. Can be 'duplicate_barcode',
351 'invalid_homebranch', or 'invalid_holdingbranch'.
353 =item error_information
355 Additional information appropriate to the error condition.
361 sub AddItemBatchFromMarc {
362 my ($record, $biblionumber, $biblioitemnumber, $frameworkcode) = @_;
364 my @itemnumbers = ();
366 my $dbh = C4::Context->dbh;
368 # We modify the record, so lets work on a clone so we don't change the
370 $record = $record->clone();
371 # loop through the item tags and start creating items
372 my @bad_item_fields = ();
373 my ($itemtag, $itemsubfield) = &GetMarcFromKohaField("items.itemnumber",'');
374 my $item_sequence_num = 0;
375 ITEMFIELD: foreach my $item_field ($record->field($itemtag)) {
376 $item_sequence_num++;
377 # we take the item field and stick it into a new
378 # MARC record -- this is required so far because (FIXME)
379 # TransformMarcToKoha requires a MARC::Record, not a MARC::Field
380 # and there is no TransformMarcFieldToKoha
381 my $temp_item_marc = MARC::Record->new();
382 $temp_item_marc->append_fields($item_field);
384 # add biblionumber and biblioitemnumber
385 my $item = TransformMarcToKoha( $temp_item_marc, $frameworkcode, 'items' );
386 my $unlinked_item_subfields = _get_unlinked_item_subfields($temp_item_marc, $frameworkcode);
387 $item->{'more_subfields_xml'} = _get_unlinked_subfields_xml($unlinked_item_subfields);
388 $item->{'biblionumber'} = $biblionumber;
389 $item->{'biblioitemnumber'} = $biblioitemnumber;
391 # check for duplicate barcode
392 my %item_errors = CheckItemPreSave($item);
394 push @errors, _repack_item_errors($item_sequence_num, $item, \%item_errors);
395 push @bad_item_fields, $item_field;
399 _set_defaults_for_add($item);
400 _set_derived_columns_for_add($item);
401 my ( $itemnumber, $error ) = _koha_new_item( $item, $item->{barcode} );
402 warn $error if $error;
403 push @itemnumbers, $itemnumber; # FIXME not checking error
404 $item->{'itemnumber'} = $itemnumber;
406 logaction("CATALOGUING", "ADD", $itemnumber, "item") if C4::Context->preference("CataloguingLog");
408 my $new_item_marc = _marc_from_item_hash($item, $frameworkcode, $unlinked_item_subfields);
409 $item_field->replace_with($new_item_marc->field($itemtag));
412 # remove any MARC item fields for rejected items
413 foreach my $item_field (@bad_item_fields) {
414 $record->delete_field($item_field);
417 # update the MARC biblio
418 # $biblionumber = ModBiblioMarc( $record, $biblionumber, $frameworkcode );
420 return (\@itemnumbers, \@errors);
423 =head2 ModItemFromMarc
425 ModItemFromMarc($item_marc, $biblionumber, $itemnumber);
427 This function updates an item record based on a supplied
428 C<MARC::Record> object containing an embedded item field.
429 This API is meant for the use of C<additem.pl>; for
430 other purposes, C<ModItem> should be used.
432 This function uses the hash %default_values_for_mod_from_marc,
433 which contains default values for item fields to
434 apply when modifying an item. This is needed because
435 if an item field's value is cleared, TransformMarcToKoha
436 does not include the column in the
437 hash that's passed to ModItem, which without
438 use of this hash makes it impossible to clear
439 an item field's value. See bug 2466.
441 Note that only columns that can be directly
442 changed from the cataloging and serials
443 item editors are included in this hash.
449 sub _build_default_values_for_mod_marc {
450 my ($frameworkcode) = @_;
452 my $cache = Koha::Caches->get_instance();
453 my $cache_key = "default_value_for_mod_marc-$frameworkcode";
454 my $cached = $cache->get_from_cache($cache_key);
455 return $cached if $cached;
457 my $default_values = {
459 booksellerid => undef,
461 'items.cn_source' => undef,
462 coded_location_qualifier => undef,
466 holdingbranch => undef,
468 itemcallnumber => undef,
471 itemnotes_nonpublic => undef,
474 permanent_location => undef,
478 # paidfor => undef, # commented, see bug 12817
480 replacementprice => undef,
481 replacementpricedate => undef,
484 stocknumber => undef,
488 my %default_values_for_mod_from_marc;
489 while ( my ( $field, $default_value ) = each %$default_values ) {
490 my $kohafield = $field;
491 $kohafield =~ s|^([^\.]+)$|items.$1|;
492 $default_values_for_mod_from_marc{$field} =
494 if C4::Koha::IsKohaFieldLinked(
495 { kohafield => $kohafield, frameworkcode => $frameworkcode } );
498 $cache->set_in_cache($cache_key, \%default_values_for_mod_from_marc);
499 return \%default_values_for_mod_from_marc;
502 sub ModItemFromMarc {
503 my $item_marc = shift;
504 my $biblionumber = shift;
505 my $itemnumber = shift;
507 my $dbh = C4::Context->dbh;
508 my $frameworkcode = GetFrameworkCode($biblionumber);
509 my ( $itemtag, $itemsubfield ) = GetMarcFromKohaField( "items.itemnumber", $frameworkcode );
511 my $localitemmarc = MARC::Record->new;
512 $localitemmarc->append_fields( $item_marc->field($itemtag) );
513 my $item = &TransformMarcToKoha( $localitemmarc, $frameworkcode, 'items' );
514 my $default_values = _build_default_values_for_mod_marc($frameworkcode);
515 foreach my $item_field ( keys %$default_values ) {
516 $item->{$item_field} = $default_values->{$item_field}
517 unless exists $item->{$item_field};
519 my $unlinked_item_subfields = _get_unlinked_item_subfields( $localitemmarc, $frameworkcode );
521 ModItem($item, $biblionumber, $itemnumber, $dbh, $frameworkcode, $unlinked_item_subfields);
527 ModItem({ column => $newvalue }, $biblionumber, $itemnumber);
529 Change one or more columns in an item record and update
530 the MARC representation of the item.
532 The first argument is a hashref mapping from item column
533 names to the new values. The second and third arguments
534 are the biblionumber and itemnumber, respectively.
536 The fourth, optional parameter, C<$unlinked_item_subfields>, contains
537 an arrayref containing subfields present in the original MARC
538 representation of the item (e.g., from the item editor) that are
539 not mapped to C<items> columns directly but should instead
540 be stored in C<items.more_subfields_xml> and included in
541 the biblio items tag for display and indexing.
543 If one of the changed columns is used to calculate
544 the derived value of a column such as C<items.cn_sort>,
545 this routine will perform the necessary calculation
552 my $biblionumber = shift;
553 my $itemnumber = shift;
555 # if $biblionumber is undefined, get it from the current item
556 unless (defined $biblionumber) {
557 $biblionumber = _get_single_item_column('biblionumber', $itemnumber);
560 my $dbh = @_ ? shift : C4::Context->dbh;
561 my $frameworkcode = @_ ? shift : GetFrameworkCode( $biblionumber );
563 my $unlinked_item_subfields;
565 $unlinked_item_subfields = shift;
566 $item->{'more_subfields_xml'} = _get_unlinked_subfields_xml($unlinked_item_subfields);
569 $item->{'itemnumber'} = $itemnumber or return;
571 my @fields = qw( itemlost withdrawn );
573 # Only call GetItem if we need to set an "on" date field
574 if ( $item->{itemlost} || $item->{withdrawn} ) {
575 my $pre_mod_item = GetItem( $item->{'itemnumber'} );
576 for my $field (@fields) {
577 if ( defined( $item->{$field} )
578 and not $pre_mod_item->{$field}
579 and $item->{$field} )
581 $item->{ $field . '_on' } =
582 DateTime::Format::MySQL->format_datetime( dt_from_string() );
587 # If the field is defined but empty, we are removing and,
588 # and thus need to clear out the 'on' field as well
589 for my $field (@fields) {
590 if ( defined( $item->{$field} ) && !$item->{$field} ) {
591 $item->{ $field . '_on' } = undef;
596 _set_derived_columns_for_mod($item);
597 _do_column_fixes_for_mod($item);
600 # attempt to change itemnumber
601 # attempt to change biblionumber (if we want
602 # an API to relink an item to a different bib,
603 # it should be a separate function)
606 _koha_modify_item($item);
608 # request that bib be reindexed so that searching on current
609 # item status is possible
610 ModZebra( $biblionumber, "specialUpdate", "biblioserver" );
612 logaction("CATALOGUING", "MODIFY", $itemnumber, "item ".Dumper($item)) if C4::Context->preference("CataloguingLog");
615 =head2 ModItemTransfer
617 ModItemTransfer($itenumber, $frombranch, $tobranch);
619 Marks an item as being transferred from one branch
624 sub ModItemTransfer {
625 my ( $itemnumber, $frombranch, $tobranch ) = @_;
627 my $dbh = C4::Context->dbh;
629 # Remove the 'shelving cart' location status if it is being used.
630 CartToShelf( $itemnumber ) if ( C4::Context->preference("ReturnToShelvingCart") );
632 #new entry in branchtransfers....
633 my $sth = $dbh->prepare(
634 "INSERT INTO branchtransfers (itemnumber, frombranch, datesent, tobranch)
635 VALUES (?, ?, NOW(), ?)");
636 $sth->execute($itemnumber, $frombranch, $tobranch);
638 ModItem({ holdingbranch => $tobranch }, undef, $itemnumber);
639 ModDateLastSeen($itemnumber);
643 =head2 ModDateLastSeen
645 ModDateLastSeen($itemnum);
647 Mark item as seen. Is called when an item is issued, returned or manually marked during inventory/stocktaking.
648 C<$itemnum> is the item number
652 sub ModDateLastSeen {
653 my ($itemnumber) = @_;
655 my $today = output_pref({ dt => dt_from_string, dateformat => 'iso', dateonly => 1 });
656 ModItem({ itemlost => 0, datelastseen => $today }, undef, $itemnumber);
661 DelItem({ itemnumber => $itemnumber, [ biblionumber => $biblionumber ] } );
663 Exported function (core API) for deleting an item record in Koha.
670 my $itemnumber = $params->{itemnumber};
671 my $biblionumber = $params->{biblionumber};
673 unless ($biblionumber) {
674 $biblionumber = C4::Biblio::GetBiblionumberFromItemnumber($itemnumber);
677 # If there is no biblionumber for the given itemnumber, there is nothing to delete
678 return 0 unless $biblionumber;
680 # FIXME check the item has no current issues
681 my $deleted = _koha_delete_item( $itemnumber );
683 # get the MARC record
684 my $record = GetMarcBiblio($biblionumber);
685 ModZebra( $biblionumber, "specialUpdate", "biblioserver" );
687 #search item field code
688 logaction("CATALOGUING", "DELETE", $itemnumber, "item") if C4::Context->preference("CataloguingLog");
692 =head2 CheckItemPreSave
694 my $item_ref = TransformMarcToKoha($marc, 'items');
696 my %errors = CheckItemPreSave($item_ref);
697 if (exists $errors{'duplicate_barcode'}) {
698 print "item has duplicate barcode: ", $errors{'duplicate_barcode'}, "\n";
699 } elsif (exists $errors{'invalid_homebranch'}) {
700 print "item has invalid home branch: ", $errors{'invalid_homebranch'}, "\n";
701 } elsif (exists $errors{'invalid_holdingbranch'}) {
702 print "item has invalid holding branch: ", $errors{'invalid_holdingbranch'}, "\n";
707 Given a hashref containing item fields, determine if it can be
708 inserted or updated in the database. Specifically, checks for
709 database integrity issues, and returns a hash containing any
710 of the following keys, if applicable.
714 =item duplicate_barcode
716 Barcode, if it duplicates one already found in the database.
718 =item invalid_homebranch
720 Home branch, if not defined in branches table.
722 =item invalid_holdingbranch
724 Holding branch, if not defined in branches table.
728 This function does NOT implement any policy-related checks,
729 e.g., whether current operator is allowed to save an
730 item that has a given branch code.
734 sub CheckItemPreSave {
735 my $item_ref = shift;
739 # check for duplicate barcode
740 if (exists $item_ref->{'barcode'} and defined $item_ref->{'barcode'}) {
741 my $existing_itemnumber = GetItemnumberFromBarcode($item_ref->{'barcode'});
742 if ($existing_itemnumber) {
743 if (!exists $item_ref->{'itemnumber'} # new item
744 or $item_ref->{'itemnumber'} != $existing_itemnumber) { # existing item
745 $errors{'duplicate_barcode'} = $item_ref->{'barcode'};
750 # check for valid home branch
751 if (exists $item_ref->{'homebranch'} and defined $item_ref->{'homebranch'}) {
752 my $home_library = Koha::Libraries->find( $item_ref->{homebranch} );
753 unless (defined $home_library) {
754 $errors{'invalid_homebranch'} = $item_ref->{'homebranch'};
758 # check for valid holding branch
759 if (exists $item_ref->{'holdingbranch'} and defined $item_ref->{'holdingbranch'}) {
760 my $holding_library = Koha::Libraries->find( $item_ref->{holdingbranch} );
761 unless (defined $holding_library) {
762 $errors{'invalid_holdingbranch'} = $item_ref->{'holdingbranch'};
770 =head1 EXPORTED SPECIAL ACCESSOR FUNCTIONS
772 The following functions provide various ways of
773 getting an item record, a set of item records, or
774 lists of authorized values for certain item fields.
776 Some of the functions in this group are candidates
777 for refactoring -- for example, some of the code
778 in C<GetItemsByBiblioitemnumber> and C<GetItemsInfo>
779 has copy-and-paste work.
785 $itemstatushash = GetItemStatus($fwkcode);
787 Returns a list of valid values for the
788 C<items.notforloan> field.
790 NOTE: does B<not> return an individual item's
793 Can be MARC dependent.
795 But basically could be can be loan or not
796 Create a status selector with the following code
798 =head3 in PERL SCRIPT
800 my $itemstatushash = getitemstatus;
802 foreach my $thisstatus (keys %$itemstatushash) {
803 my %row =(value => $thisstatus,
804 statusname => $itemstatushash->{$thisstatus}->{'statusname'},
806 push @itemstatusloop, \%row;
808 $template->param(statusloop=>\@itemstatusloop);
812 <select name="statusloop" id="statusloop">
813 <option value="">Default</option>
814 [% FOREACH statusloo IN statusloop %]
815 [% IF ( statusloo.selected ) %]
816 <option value="[% statusloo.value %]" selected="selected">[% statusloo.statusname %]</option>
818 <option value="[% statusloo.value %]">[% statusloo.statusname %]</option>
827 # returns a reference to a hash of references to status...
830 my $dbh = C4::Context->dbh;
832 $fwk = '' unless ($fwk);
833 my ( $tag, $subfield ) =
834 GetMarcFromKohaField( "items.notforloan", $fwk );
835 if ( $tag and $subfield ) {
838 "SELECT authorised_value
839 FROM marc_subfield_structure
845 $sth->execute( $tag, $subfield, $fwk );
846 if ( my ($authorisedvaluecat) = $sth->fetchrow ) {
849 "SELECT authorised_value,lib
850 FROM authorised_values
855 $authvalsth->execute($authorisedvaluecat);
856 while ( my ( $authorisedvalue, $lib ) = $authvalsth->fetchrow ) {
857 $itemstatus{$authorisedvalue} = $lib;
870 $itemstatus{"1"} = "Not For Loan";
874 =head2 GetItemLocation
876 $itemlochash = GetItemLocation($fwk);
878 Returns a list of valid values for the
879 C<items.location> field.
881 NOTE: does B<not> return an individual item's
884 where fwk stands for an optional framework code.
885 Create a location selector with the following code
887 =head3 in PERL SCRIPT
889 my $itemlochash = getitemlocation;
891 foreach my $thisloc (keys %$itemlochash) {
892 my $selected = 1 if $thisbranch eq $branch;
893 my %row =(locval => $thisloc,
894 selected => $selected,
895 locname => $itemlochash->{$thisloc},
897 push @itemlocloop, \%row;
899 $template->param(itemlocationloop => \@itemlocloop);
903 <select name="location">
904 <option value="">Default</option>
905 <!-- TMPL_LOOP name="itemlocationloop" -->
906 <option value="<!-- TMPL_VAR name="locval" -->" <!-- TMPL_IF name="selected" -->selected<!-- /TMPL_IF -->><!-- TMPL_VAR name="locname" --></option>
912 sub GetItemLocation {
914 # returns a reference to a hash of references to location...
917 my $dbh = C4::Context->dbh;
919 $fwk = '' unless ($fwk);
920 my ( $tag, $subfield ) =
921 GetMarcFromKohaField( "items.location", $fwk );
922 if ( $tag and $subfield ) {
925 "SELECT authorised_value
926 FROM marc_subfield_structure
931 $sth->execute( $tag, $subfield, $fwk );
932 if ( my ($authorisedvaluecat) = $sth->fetchrow ) {
935 "SELECT authorised_value,lib
936 FROM authorised_values
940 $authvalsth->execute($authorisedvaluecat);
941 while ( my ( $authorisedvalue, $lib ) = $authvalsth->fetchrow ) {
942 $itemlocation{$authorisedvalue} = $lib;
944 return \%itemlocation;
955 $itemlocation{"1"} = "Not For Loan";
956 return \%itemlocation;
961 $items = GetLostItems( $where );
963 This function gets a list of lost items.
969 C<$where> is a hashref. it containts a field of the items table as key
970 and the value to match as value. For example:
972 { barcode => 'abc123',
973 homebranch => 'CPL', }
977 C<$items> is a reference to an array full of hashrefs with columns
978 from the "items" table as keys.
980 =item usage in the perl script:
982 my $where = { barcode => '0001548' };
983 my $items = GetLostItems( $where );
984 $template->param( itemsloop => $items );
991 # Getting input args.
993 my $dbh = C4::Context->dbh;
996 SELECT title, author, lib, itemlost, authorised_value, barcode, datelastseen, price, replacementprice, homebranch,
997 itype, itemtype, holdingbranch, location, itemnotes, items.biblionumber as biblionumber, itemcallnumber
999 LEFT JOIN biblio ON (items.biblionumber = biblio.biblionumber)
1000 LEFT JOIN biblioitems ON (items.biblionumber = biblioitems.biblionumber)
1001 LEFT JOIN authorised_values ON (items.itemlost = authorised_values.authorised_value)
1003 authorised_values.category = 'LOST'
1004 AND itemlost IS NOT NULL
1007 my @query_parameters;
1008 foreach my $key (keys %$where) {
1009 $query .= " AND $key LIKE ?";
1010 push @query_parameters, "%$where->{$key}%";
1013 my $sth = $dbh->prepare($query);
1014 $sth->execute( @query_parameters );
1016 while ( my $row = $sth->fetchrow_hashref ){
1022 =head2 GetItemsForInventory
1024 ($itemlist, $iTotalRecords) = GetItemsForInventory( {
1025 minlocation => $minlocation,
1026 maxlocation => $maxlocation,
1027 location => $location,
1028 itemtype => $itemtype,
1029 ignoreissued => $ignoreissued,
1030 datelastseen => $datelastseen,
1031 branchcode => $branchcode,
1035 statushash => $statushash,
1038 Retrieve a list of title/authors/barcode/callnumber, for biblio inventory.
1040 The sub returns a reference to a list of hashes, each containing
1041 itemnumber, author, title, barcode, item callnumber, and date last
1042 seen. It is ordered by callnumber then title.
1044 The required minlocation & maxlocation parameters are used to specify a range of item callnumbers
1045 the datelastseen can be used to specify that you want to see items not seen since a past date only.
1046 offset & size can be used to retrieve only a part of the whole listing (defaut behaviour)
1047 $statushash requires a hashref that has the authorized values fieldname (intems.notforloan, etc...) as keys, and an arrayref of statuscodes we are searching for as values.
1049 $iTotalRecords is the number of rows that would have been returned without the $offset, $size limit clause
1053 sub GetItemsForInventory {
1054 my ( $parameters ) = @_;
1055 my $minlocation = $parameters->{'minlocation'} // '';
1056 my $maxlocation = $parameters->{'maxlocation'} // '';
1057 my $location = $parameters->{'location'} // '';
1058 my $itemtype = $parameters->{'itemtype'} // '';
1059 my $ignoreissued = $parameters->{'ignoreissued'} // '';
1060 my $datelastseen = $parameters->{'datelastseen'} // '';
1061 my $branchcode = $parameters->{'branchcode'} // '';
1062 my $branch = $parameters->{'branch'} // '';
1063 my $offset = $parameters->{'offset'} // '';
1064 my $size = $parameters->{'size'} // '';
1065 my $statushash = $parameters->{'statushash'} // '';
1067 my $dbh = C4::Context->dbh;
1068 my ( @bind_params, @where_strings );
1070 my $select_columns = q{
1071 SELECT items.itemnumber, barcode, itemcallnumber, title, author, biblio.biblionumber, biblio.frameworkcode, datelastseen, homebranch, location, notforloan, damaged, itemlost, withdrawn, stocknumber
1073 my $select_count = q{SELECT COUNT(*)};
1076 LEFT JOIN biblio ON items.biblionumber = biblio.biblionumber
1077 LEFT JOIN biblioitems on items.biblionumber = biblioitems.biblionumber
1080 for my $authvfield (keys %$statushash){
1081 if ( scalar @{$statushash->{$authvfield}} > 0 ){
1082 my $joinedvals = join ',', @{$statushash->{$authvfield}};
1083 push @where_strings, "$authvfield in (" . $joinedvals . ")";
1089 push @where_strings, 'itemcallnumber >= ?';
1090 push @bind_params, $minlocation;
1094 push @where_strings, 'itemcallnumber <= ?';
1095 push @bind_params, $maxlocation;
1098 if ($datelastseen) {
1099 $datelastseen = output_pref({ str => $datelastseen, dateformat => 'iso', dateonly => 1 });
1100 push @where_strings, '(datelastseen < ? OR datelastseen IS NULL)';
1101 push @bind_params, $datelastseen;
1105 push @where_strings, 'items.location = ?';
1106 push @bind_params, $location;
1109 if ( $branchcode ) {
1110 if($branch eq "homebranch"){
1111 push @where_strings, 'items.homebranch = ?';
1113 push @where_strings, 'items.holdingbranch = ?';
1115 push @bind_params, $branchcode;
1119 push @where_strings, 'biblioitems.itemtype = ?';
1120 push @bind_params, $itemtype;
1123 if ( $ignoreissued) {
1124 $query .= "LEFT JOIN issues ON items.itemnumber = issues.itemnumber ";
1125 push @where_strings, 'issues.date_due IS NULL';
1128 if ( @where_strings ) {
1130 $query .= join ' AND ', @where_strings;
1132 $query .= ' ORDER BY items.cn_sort, itemcallnumber, title';
1133 my $count_query = $select_count . $query;
1134 $query .= " LIMIT $offset, $size" if ($offset and $size);
1135 $query = $select_columns . $query;
1136 my $sth = $dbh->prepare($query);
1137 $sth->execute( @bind_params );
1140 my $tmpresults = $sth->fetchall_arrayref({});
1141 $sth = $dbh->prepare( $count_query );
1142 $sth->execute( @bind_params );
1143 my ($iTotalRecords) = $sth->fetchrow_array();
1145 my @avs = Koha::AuthorisedValues->search(
1146 { 'marc_subfield_structures.kohafield' => { '>' => '' },
1147 'me.authorised_value' => { '>' => '' },
1149 { join => { category => 'marc_subfield_structures' },
1150 distinct => ['marc_subfield_structures.kohafield, me.category, frameworkcode, me.authorised_value'],
1151 '+select' => [ 'marc_subfield_structures.kohafield', 'marc_subfield_structures.frameworkcode', 'me.authorised_value', 'me.lib' ],
1152 '+as' => [ 'kohafield', 'frameworkcode', 'authorised_value', 'lib' ],
1156 my $avmapping = { map { $_->get_column('kohafield') . ',' . $_->get_column('frameworkcode') . ',' . $_->get_column('authorised_value') => $_->get_column('lib') } @avs };
1158 foreach my $row (@$tmpresults) {
1161 foreach (keys %$row) {
1162 if (defined($avmapping->{"items.$_,".$row->{'frameworkcode'}.",".$row->{$_}})) {
1163 $row->{$_} = $avmapping->{"items.$_,".$row->{'frameworkcode'}.",".$row->{$_}};
1166 push @results, $row;
1169 return (\@results, $iTotalRecords);
1172 =head2 GetItemsCount
1174 $count = &GetItemsCount( $biblionumber);
1176 This function return count of item with $biblionumber
1181 my ( $biblionumber ) = @_;
1182 my $dbh = C4::Context->dbh;
1183 my $query = "SELECT count(*)
1185 WHERE biblionumber=?";
1186 my $sth = $dbh->prepare($query);
1187 $sth->execute($biblionumber);
1188 my $count = $sth->fetchrow;
1192 =head2 GetItemInfosOf
1194 GetItemInfosOf(@itemnumbers);
1198 sub GetItemInfosOf {
1199 my @itemnumbers = @_;
1201 my $itemnumber_values = @itemnumbers ? join( ',', @itemnumbers ) : "''";
1203 my $dbh = C4::Context->dbh;
1207 WHERE itemnumber IN ($itemnumber_values)
1209 return $dbh->selectall_hashref($query, 'itemnumber');
1212 =head2 GetItemsByBiblioitemnumber
1214 GetItemsByBiblioitemnumber($biblioitemnumber);
1216 Returns an arrayref of hashrefs suitable for use in a TMPL_LOOP
1217 Called by C<C4::XISBN>
1221 sub GetItemsByBiblioitemnumber {
1222 my ( $bibitem ) = @_;
1223 my $dbh = C4::Context->dbh;
1224 my $sth = $dbh->prepare("SELECT * FROM items WHERE items.biblioitemnumber = ?") || die $dbh->errstr;
1225 # Get all items attached to a biblioitem
1228 $sth->execute($bibitem) || die $sth->errstr;
1229 while ( my $data = $sth->fetchrow_hashref ) {
1230 # Foreach item, get circulation information
1231 my $sth2 = $dbh->prepare( "SELECT * FROM issues,borrowers
1232 WHERE itemnumber = ?
1233 AND issues.borrowernumber = borrowers.borrowernumber"
1235 $sth2->execute( $data->{'itemnumber'} );
1236 if ( my $data2 = $sth2->fetchrow_hashref ) {
1237 # if item is out, set the due date and who it is out too
1238 $data->{'date_due'} = $data2->{'date_due'};
1239 $data->{'cardnumber'} = $data2->{'cardnumber'};
1240 $data->{'borrowernumber'} = $data2->{'borrowernumber'};
1243 # set date_due to blank, so in the template we check itemlost, and withdrawn
1244 $data->{'date_due'} = '';
1246 # Find the last 3 people who borrowed this item.
1247 my $query2 = "SELECT * FROM old_issues, borrowers WHERE itemnumber = ?
1248 AND old_issues.borrowernumber = borrowers.borrowernumber
1249 ORDER BY returndate desc,timestamp desc LIMIT 3";
1250 $sth2 = $dbh->prepare($query2) || die $dbh->errstr;
1251 $sth2->execute( $data->{'itemnumber'} ) || die $sth2->errstr;
1253 while ( my $data2 = $sth2->fetchrow_hashref ) {
1254 $data->{"timestamp$i2"} = $data2->{'timestamp'};
1255 $data->{"card$i2"} = $data2->{'cardnumber'};
1256 $data->{"borrower$i2"} = $data2->{'borrowernumber'};
1259 push(@results,$data);
1266 @results = GetItemsInfo($biblionumber);
1268 Returns information about items with the given biblionumber.
1270 C<GetItemsInfo> returns a list of references-to-hash. Each element
1271 contains a number of keys. Most of them are attributes from the
1272 C<biblio>, C<biblioitems>, C<items>, and C<itemtypes> tables in the
1273 Koha database. Other keys include:
1277 =item C<$data-E<gt>{branchname}>
1279 The name (not the code) of the branch to which the book belongs.
1281 =item C<$data-E<gt>{datelastseen}>
1283 This is simply C<items.datelastseen>, except that while the date is
1284 stored in YYYY-MM-DD format in the database, here it is converted to
1285 DD/MM/YYYY format. A NULL date is returned as C<//>.
1287 =item C<$data-E<gt>{datedue}>
1289 =item C<$data-E<gt>{class}>
1291 This is the concatenation of C<biblioitems.classification>, the book's
1292 Dewey code, and C<biblioitems.subclass>.
1294 =item C<$data-E<gt>{ocount}>
1296 I think this is the number of copies of the book available.
1298 =item C<$data-E<gt>{order}>
1300 If this is set, it is set to C<One Order>.
1307 my ( $biblionumber ) = @_;
1308 my $dbh = C4::Context->dbh;
1309 require C4::Languages;
1310 my $language = C4::Languages::getlanguage();
1316 biblioitems.itemtype,
1319 biblioitems.publicationyear,
1320 biblioitems.publishercode,
1321 biblioitems.volumedate,
1322 biblioitems.volumedesc,
1325 items.notforloan as itemnotforloan,
1326 issues.borrowernumber,
1327 issues.date_due as datedue,
1328 issues.onsite_checkout,
1329 borrowers.cardnumber,
1331 borrowers.firstname,
1332 borrowers.branchcode as bcode,
1334 serial.publisheddate,
1335 itemtypes.description,
1336 COALESCE( localization.translation, itemtypes.description ) AS translated_description,
1337 itemtypes.notforloan as notforloan_per_itemtype,
1341 holding.opac_info as holding_branch_opac_info,
1342 home.opac_info as home_branch_opac_info
1346 LEFT JOIN branches AS holding ON items.holdingbranch = holding.branchcode
1347 LEFT JOIN branches AS home ON items.homebranch=home.branchcode
1348 LEFT JOIN biblio ON biblio.biblionumber = items.biblionumber
1349 LEFT JOIN biblioitems ON biblioitems.biblioitemnumber = items.biblioitemnumber
1350 LEFT JOIN issues USING (itemnumber)
1351 LEFT JOIN borrowers USING (borrowernumber)
1352 LEFT JOIN serialitems USING (itemnumber)
1353 LEFT JOIN serial USING (serialid)
1354 LEFT JOIN itemtypes ON itemtypes.itemtype = "
1355 . (C4::Context->preference('item-level_itypes') ? 'items.itype' : 'biblioitems.itemtype');
1357 LEFT JOIN localization ON itemtypes.itemtype = localization.code
1358 AND localization.entity = 'itemtypes'
1359 AND localization.lang = ?
1362 $query .= " WHERE items.biblionumber = ? ORDER BY home.branchname, items.enumchron, LPAD( items.copynumber, 8, '0' ), items.dateaccessioned DESC" ;
1363 my $sth = $dbh->prepare($query);
1364 $sth->execute($language, $biblionumber);
1369 my $userenv = C4::Context->userenv;
1370 my $want_not_same_branch = C4::Context->preference("IndependentBranches") && !C4::Context->IsSuperLibrarian();
1371 while ( my $data = $sth->fetchrow_hashref ) {
1372 if ( $data->{borrowernumber} && $want_not_same_branch) {
1373 $data->{'NOTSAMEBRANCH'} = $data->{'bcode'} ne $userenv->{branch};
1376 $serial ||= $data->{'serial'};
1379 # get notforloan complete status if applicable
1380 $descriptions = Koha::AuthorisedValues->get_description_by_koha_field({frameworkcode => $data->{frameworkcode}, kohafield => 'items.notforloan', authorised_value => $data->{itemnotforloan} });
1381 $data->{notforloanvalue} = $descriptions->{lib} // '';
1382 $data->{notforloanvalueopac} = $descriptions->{opac_description} // '';
1384 # get restricted status and description if applicable
1385 $descriptions = Koha::AuthorisedValues->get_description_by_koha_field({frameworkcode => $data->{frameworkcode}, kohafield => 'items.restricted', authorised_value => $data->{restricted} });
1386 $data->{restricted} = $descriptions->{lib} // '';
1387 $data->{restrictedopac} = $descriptions->{opac_description} // '';
1389 # my stack procedures
1390 $descriptions = Koha::AuthorisedValues->get_description_by_koha_field({frameworkcode => $data->{frameworkcode}, kohafield => 'items.stack', authorised_value => $data->{stack} });
1391 $data->{stack} = $descriptions->{lib} // '';
1393 # Find the last 3 people who borrowed this item.
1394 my $sth2 = $dbh->prepare("SELECT * FROM old_issues,borrowers
1395 WHERE itemnumber = ?
1396 AND old_issues.borrowernumber = borrowers.borrowernumber
1397 ORDER BY returndate DESC
1399 $sth2->execute($data->{'itemnumber'});
1401 while (my $data2 = $sth2->fetchrow_hashref()) {
1402 $data->{"timestamp$ii"} = $data2->{'timestamp'} if $data2->{'timestamp'};
1403 $data->{"card$ii"} = $data2->{'cardnumber'} if $data2->{'cardnumber'};
1404 $data->{"borrower$ii"} = $data2->{'borrowernumber'} if $data2->{'borrowernumber'};
1408 $results[$i] = $data;
1413 ? sort { ($b->{'publisheddate'} || $b->{'enumchron'}) cmp ($a->{'publisheddate'} || $a->{'enumchron'}) } @results
1417 =head2 GetItemsLocationInfo
1419 my @itemlocinfo = GetItemsLocationInfo($biblionumber);
1421 Returns the branch names, shelving location and itemcallnumber for each item attached to the biblio in question
1423 C<GetItemsInfo> returns a list of references-to-hash. Data returned:
1427 =item C<$data-E<gt>{homebranch}>
1429 Branch Name of the item's homebranch
1431 =item C<$data-E<gt>{holdingbranch}>
1433 Branch Name of the item's holdingbranch
1435 =item C<$data-E<gt>{location}>
1437 Item's shelving location code
1439 =item C<$data-E<gt>{location_intranet}>
1441 The intranet description for the Shelving Location as set in authorised_values 'LOC'
1443 =item C<$data-E<gt>{location_opac}>
1445 The OPAC description for the Shelving Location as set in authorised_values 'LOC'. Falls back to intranet description if no OPAC
1448 =item C<$data-E<gt>{itemcallnumber}>
1450 Item's itemcallnumber
1452 =item C<$data-E<gt>{cn_sort}>
1454 Item's call number normalized for sorting
1460 sub GetItemsLocationInfo {
1461 my $biblionumber = shift;
1464 my $dbh = C4::Context->dbh;
1465 my $query = "SELECT a.branchname as homebranch, b.branchname as holdingbranch,
1466 location, itemcallnumber, cn_sort
1467 FROM items, branches as a, branches as b
1468 WHERE homebranch = a.branchcode AND holdingbranch = b.branchcode
1469 AND biblionumber = ?
1470 ORDER BY cn_sort ASC";
1471 my $sth = $dbh->prepare($query);
1472 $sth->execute($biblionumber);
1474 while ( my $data = $sth->fetchrow_hashref ) {
1475 my $av = Koha::AuthorisedValues->search({ category => 'LOC', authorised_value => $data->{location} });
1476 $av = $av->count ? $av->next : undef;
1477 $data->{location_intranet} = $av ? $av->lib : '';
1478 $data->{location_opac} = $av ? $av->opac_description : '';
1479 push @results, $data;
1484 =head2 GetHostItemsInfo
1486 $hostiteminfo = GetHostItemsInfo($hostfield);
1487 Returns the iteminfo for items linked to records via a host field
1491 sub GetHostItemsInfo {
1493 my @returnitemsInfo;
1495 if (C4::Context->preference('marcflavour') eq 'MARC21' ||
1496 C4::Context->preference('marcflavour') eq 'NORMARC'){
1497 foreach my $hostfield ( $record->field('773') ) {
1498 my $hostbiblionumber = $hostfield->subfield("0");
1499 my $linkeditemnumber = $hostfield->subfield("9");
1500 my @hostitemInfos = GetItemsInfo($hostbiblionumber);
1501 foreach my $hostitemInfo (@hostitemInfos){
1502 if ($hostitemInfo->{itemnumber} eq $linkeditemnumber){
1503 push (@returnitemsInfo,$hostitemInfo);
1508 } elsif ( C4::Context->preference('marcflavour') eq 'UNIMARC'){
1509 foreach my $hostfield ( $record->field('461') ) {
1510 my $hostbiblionumber = $hostfield->subfield("0");
1511 my $linkeditemnumber = $hostfield->subfield("9");
1512 my @hostitemInfos = GetItemsInfo($hostbiblionumber);
1513 foreach my $hostitemInfo (@hostitemInfos){
1514 if ($hostitemInfo->{itemnumber} eq $linkeditemnumber){
1515 push (@returnitemsInfo,$hostitemInfo);
1521 return @returnitemsInfo;
1525 =head2 GetLastAcquisitions
1527 my $lastacq = GetLastAcquisitions({'branches' => ('branch1','branch2'),
1528 'itemtypes' => ('BK','BD')}, 10);
1532 sub GetLastAcquisitions {
1533 my ($data,$max) = @_;
1535 my $itemtype = C4::Context->preference('item-level_itypes') ? 'itype' : 'itemtype';
1537 my $number_of_branches = @{$data->{branches}};
1538 my $number_of_itemtypes = @{$data->{itemtypes}};
1541 my @where = ('WHERE 1 ');
1542 $number_of_branches and push @where
1543 , 'AND holdingbranch IN ('
1544 , join(',', ('?') x $number_of_branches )
1548 $number_of_itemtypes and push @where
1549 , "AND $itemtype IN ("
1550 , join(',', ('?') x $number_of_itemtypes )
1554 my $query = "SELECT biblio.biblionumber as biblionumber, title, dateaccessioned
1555 FROM items RIGHT JOIN biblio ON (items.biblionumber=biblio.biblionumber)
1556 RIGHT JOIN biblioitems ON (items.biblioitemnumber=biblioitems.biblioitemnumber)
1558 GROUP BY biblio.biblionumber
1559 ORDER BY dateaccessioned DESC LIMIT $max";
1561 my $dbh = C4::Context->dbh;
1562 my $sth = $dbh->prepare($query);
1564 $sth->execute((@{$data->{branches}}, @{$data->{itemtypes}}));
1567 while( my $row = $sth->fetchrow_hashref){
1568 push @results, {date => $row->{dateaccessioned}
1569 , biblionumber => $row->{biblionumber}
1570 , title => $row->{title}};
1576 =head2 GetItemnumbersForBiblio
1578 my $itemnumbers = GetItemnumbersForBiblio($biblionumber);
1580 Given a single biblionumber, return an arrayref of all the corresponding itemnumbers
1584 sub GetItemnumbersForBiblio {
1585 my $biblionumber = shift;
1587 my $dbh = C4::Context->dbh;
1588 my $sth = $dbh->prepare("SELECT itemnumber FROM items WHERE biblionumber = ?");
1589 $sth->execute($biblionumber);
1590 while (my $result = $sth->fetchrow_hashref) {
1591 push @items, $result->{'itemnumber'};
1596 =head2 get_itemnumbers_of
1598 my @itemnumbers_of = get_itemnumbers_of(@biblionumbers);
1600 Given a list of biblionumbers, return the list of corresponding itemnumbers
1601 for each biblionumber.
1603 Return a reference on a hash where keys are biblionumbers and values are
1604 references on array of itemnumbers.
1608 sub get_itemnumbers_of {
1609 my @biblionumbers = @_;
1611 my $dbh = C4::Context->dbh;
1617 WHERE biblionumber IN (?' . ( ',?' x scalar @biblionumbers - 1 ) . ')
1619 my $sth = $dbh->prepare($query);
1620 $sth->execute(@biblionumbers);
1624 while ( my ( $itemnumber, $biblionumber ) = $sth->fetchrow_array ) {
1625 push @{ $itemnumbers_of{$biblionumber} }, $itemnumber;
1628 return \%itemnumbers_of;
1631 =head2 get_hostitemnumbers_of
1633 my @itemnumbers_of = get_hostitemnumbers_of($biblionumber);
1635 Given a biblionumber, return the list of corresponding itemnumbers that are linked to it via host fields
1637 Return a reference on a hash where key is a biblionumber and values are
1638 references on array of itemnumbers.
1643 sub get_hostitemnumbers_of {
1644 my ($biblionumber) = @_;
1645 my $marcrecord = GetMarcBiblio($biblionumber);
1647 return unless $marcrecord;
1649 my ( @returnhostitemnumbers, $tag, $biblio_s, $item_s );
1651 my $marcflavor = C4::Context->preference('marcflavour');
1652 if ( $marcflavor eq 'MARC21' || $marcflavor eq 'NORMARC' ) {
1657 elsif ( $marcflavor eq 'UNIMARC' ) {
1663 foreach my $hostfield ( $marcrecord->field($tag) ) {
1664 my $hostbiblionumber = $hostfield->subfield($biblio_s);
1665 my $linkeditemnumber = $hostfield->subfield($item_s);
1667 if ( my $itemnumbers =
1668 get_itemnumbers_of($hostbiblionumber)->{$hostbiblionumber} )
1670 @itemnumbers = @$itemnumbers;
1672 foreach my $itemnumber (@itemnumbers) {
1673 if ( $itemnumber eq $linkeditemnumber ) {
1674 push( @returnhostitemnumbers, $itemnumber );
1680 return @returnhostitemnumbers;
1684 =head2 GetItemnumberFromBarcode
1686 $result = GetItemnumberFromBarcode($barcode);
1690 sub GetItemnumberFromBarcode {
1692 my $dbh = C4::Context->dbh;
1695 $dbh->prepare("SELECT itemnumber FROM items WHERE items.barcode=?");
1696 $rq->execute($barcode);
1697 my ($result) = $rq->fetchrow;
1701 =head2 GetBarcodeFromItemnumber
1703 $result = GetBarcodeFromItemnumber($itemnumber);
1707 sub GetBarcodeFromItemnumber {
1708 my ($itemnumber) = @_;
1709 my $dbh = C4::Context->dbh;
1712 $dbh->prepare("SELECT barcode FROM items WHERE items.itemnumber=?");
1713 $rq->execute($itemnumber);
1714 my ($result) = $rq->fetchrow;
1718 =head2 GetHiddenItemnumbers
1720 my @itemnumbers_to_hide = GetHiddenItemnumbers(@items);
1722 Given a list of items it checks which should be hidden from the OPAC given
1723 the current configuration. Returns a list of itemnumbers corresponding to
1724 those that should be hidden.
1728 sub GetHiddenItemnumbers {
1732 my $yaml = C4::Context->preference('OpacHiddenItems');
1733 return () if (! $yaml =~ /\S/ );
1734 $yaml = "$yaml\n\n"; # YAML is anal on ending \n. Surplus does not hurt
1737 $hidingrules = YAML::Load($yaml);
1740 warn "Unable to parse OpacHiddenItems syspref : $@";
1743 my $dbh = C4::Context->dbh;
1746 foreach my $item (@items) {
1748 # We check each rule
1749 foreach my $field (keys %$hidingrules) {
1751 if (exists $item->{$field}) {
1752 $val = $item->{$field};
1755 my $query = "SELECT $field from items where itemnumber = ?";
1756 $val = $dbh->selectrow_array($query, undef, $item->{'itemnumber'});
1758 $val = '' unless defined $val;
1760 # If the results matches the values in the yaml file
1761 if (any { $val eq $_ } @{$hidingrules->{$field}}) {
1763 # We add the itemnumber to the list
1764 push @resultitems, $item->{'itemnumber'};
1766 # If at least one rule matched for an item, no need to test the others
1771 return @resultitems;
1774 =head1 LIMITED USE FUNCTIONS
1776 The following functions, while part of the public API,
1777 are not exported. This is generally because they are
1778 meant to be used by only one script for a specific
1779 purpose, and should not be used in any other context
1780 without careful thought.
1786 my $item_marc = GetMarcItem($biblionumber, $itemnumber);
1788 Returns MARC::Record of the item passed in parameter.
1789 This function is meant for use only in C<cataloguing/additem.pl>,
1790 where it is needed to support that script's MARC-like
1796 my ( $biblionumber, $itemnumber ) = @_;
1798 # GetMarcItem has been revised so that it does the following:
1799 # 1. Gets the item information from the items table.
1800 # 2. Converts it to a MARC field for storage in the bib record.
1802 # The previous behavior was:
1803 # 1. Get the bib record.
1804 # 2. Return the MARC tag corresponding to the item record.
1806 # The difference is that one treats the items row as authoritative,
1807 # while the other treats the MARC representation as authoritative
1808 # under certain circumstances.
1810 my $itemrecord = GetItem($itemnumber);
1812 # Tack on 'items.' prefix to column names so that TransformKohaToMarc will work.
1813 # Also, don't emit a subfield if the underlying field is blank.
1816 return Item2Marc($itemrecord,$biblionumber);
1820 my ($itemrecord,$biblionumber)=@_;
1823 defined($itemrecord->{$_}) && $itemrecord->{$_} ne '' ? ("items.$_" => $itemrecord->{$_}) : ()
1824 } keys %{ $itemrecord }
1826 my $itemmarc = TransformKohaToMarc($mungeditem);
1827 my ( $itemtag, $itemsubfield ) = GetMarcFromKohaField("items.itemnumber",GetFrameworkCode($biblionumber)||'');
1829 my $unlinked_item_subfields = _parse_unlinked_item_subfields_from_xml($mungeditem->{'items.more_subfields_xml'});
1830 if (defined $unlinked_item_subfields and $#$unlinked_item_subfields > -1) {
1831 foreach my $field ($itemmarc->field($itemtag)){
1832 $field->add_subfields(@$unlinked_item_subfields);
1838 =head1 PRIVATE FUNCTIONS AND VARIABLES
1840 The following functions are not meant to be called
1841 directly, but are documented in order to explain
1842 the inner workings of C<C4::Items>.
1846 =head2 %derived_columns
1848 This hash keeps track of item columns that
1849 are strictly derived from other columns in
1850 the item record and are not meant to be set
1853 Each key in the hash should be the name of a
1854 column (as named by TransformMarcToKoha). Each
1855 value should be hashref whose keys are the
1856 columns on which the derived column depends. The
1857 hashref should also contain a 'BUILDER' key
1858 that is a reference to a sub that calculates
1863 my %derived_columns = (
1864 'items.cn_sort' => {
1865 'itemcallnumber' => 1,
1866 'items.cn_source' => 1,
1867 'BUILDER' => \&_calc_items_cn_sort,
1871 =head2 _set_derived_columns_for_add
1873 _set_derived_column_for_add($item);
1875 Given an item hash representing a new item to be added,
1876 calculate any derived columns. Currently the only
1877 such column is C<items.cn_sort>.
1881 sub _set_derived_columns_for_add {
1884 foreach my $column (keys %derived_columns) {
1885 my $builder = $derived_columns{$column}->{'BUILDER'};
1886 my $source_values = {};
1887 foreach my $source_column (keys %{ $derived_columns{$column} }) {
1888 next if $source_column eq 'BUILDER';
1889 $source_values->{$source_column} = $item->{$source_column};
1891 $builder->($item, $source_values);
1895 =head2 _set_derived_columns_for_mod
1897 _set_derived_column_for_mod($item);
1899 Given an item hash representing a new item to be modified.
1900 calculate any derived columns. Currently the only
1901 such column is C<items.cn_sort>.
1903 This routine differs from C<_set_derived_columns_for_add>
1904 in that it needs to handle partial item records. In other
1905 words, the caller of C<ModItem> may have supplied only one
1906 or two columns to be changed, so this function needs to
1907 determine whether any of the columns to be changed affect
1908 any of the derived columns. Also, if a derived column
1909 depends on more than one column, but the caller is not
1910 changing all of then, this routine retrieves the unchanged
1911 values from the database in order to ensure a correct
1916 sub _set_derived_columns_for_mod {
1919 foreach my $column (keys %derived_columns) {
1920 my $builder = $derived_columns{$column}->{'BUILDER'};
1921 my $source_values = {};
1922 my %missing_sources = ();
1923 my $must_recalc = 0;
1924 foreach my $source_column (keys %{ $derived_columns{$column} }) {
1925 next if $source_column eq 'BUILDER';
1926 if (exists $item->{$source_column}) {
1928 $source_values->{$source_column} = $item->{$source_column};
1930 $missing_sources{$source_column} = 1;
1934 foreach my $source_column (keys %missing_sources) {
1935 $source_values->{$source_column} = _get_single_item_column($source_column, $item->{'itemnumber'});
1937 $builder->($item, $source_values);
1942 =head2 _do_column_fixes_for_mod
1944 _do_column_fixes_for_mod($item);
1946 Given an item hashref containing one or more
1947 columns to modify, fix up certain values.
1948 Specifically, set to 0 any passed value
1949 of C<notforloan>, C<damaged>, C<itemlost>, or
1950 C<withdrawn> that is either undefined or
1951 contains the empty string.
1955 sub _do_column_fixes_for_mod {
1958 if (exists $item->{'notforloan'} and
1959 (not defined $item->{'notforloan'} or $item->{'notforloan'} eq '')) {
1960 $item->{'notforloan'} = 0;
1962 if (exists $item->{'damaged'} and
1963 (not defined $item->{'damaged'} or $item->{'damaged'} eq '')) {
1964 $item->{'damaged'} = 0;
1966 if (exists $item->{'itemlost'} and
1967 (not defined $item->{'itemlost'} or $item->{'itemlost'} eq '')) {
1968 $item->{'itemlost'} = 0;
1970 if (exists $item->{'withdrawn'} and
1971 (not defined $item->{'withdrawn'} or $item->{'withdrawn'} eq '')) {
1972 $item->{'withdrawn'} = 0;
1974 if (exists $item->{location}
1975 and $item->{location} ne 'CART'
1976 and $item->{location} ne 'PROC'
1977 and not $item->{permanent_location}
1979 $item->{'permanent_location'} = $item->{'location'};
1981 if (exists $item->{'timestamp'}) {
1982 delete $item->{'timestamp'};
1986 =head2 _get_single_item_column
1988 _get_single_item_column($column, $itemnumber);
1990 Retrieves the value of a single column from an C<items>
1991 row specified by C<$itemnumber>.
1995 sub _get_single_item_column {
1997 my $itemnumber = shift;
1999 my $dbh = C4::Context->dbh;
2000 my $sth = $dbh->prepare("SELECT $column FROM items WHERE itemnumber = ?");
2001 $sth->execute($itemnumber);
2002 my ($value) = $sth->fetchrow();
2006 =head2 _calc_items_cn_sort
2008 _calc_items_cn_sort($item, $source_values);
2010 Helper routine to calculate C<items.cn_sort>.
2014 sub _calc_items_cn_sort {
2016 my $source_values = shift;
2018 $item->{'items.cn_sort'} = GetClassSort($source_values->{'items.cn_source'}, $source_values->{'itemcallnumber'}, "");
2021 =head2 _set_defaults_for_add
2023 _set_defaults_for_add($item_hash);
2025 Given an item hash representing an item to be added, set
2026 correct default values for columns whose default value
2027 is not handled by the DBMS. This includes the following
2034 C<items.dateaccessioned>
2056 sub _set_defaults_for_add {
2058 $item->{dateaccessioned} ||= output_pref({ dt => dt_from_string, dateformat => 'iso', dateonly => 1 });
2059 $item->{$_} ||= 0 for (qw( notforloan damaged itemlost withdrawn));
2062 =head2 _koha_new_item
2064 my ($itemnumber,$error) = _koha_new_item( $item, $barcode );
2066 Perform the actual insert into the C<items> table.
2070 sub _koha_new_item {
2071 my ( $item, $barcode ) = @_;
2072 my $dbh=C4::Context->dbh;
2074 $item->{permanent_location} //= $item->{location};
2075 _mod_item_dates( $item );
2077 "INSERT INTO items SET
2079 biblioitemnumber = ?,
2081 dateaccessioned = ?,
2085 replacementprice = ?,
2086 replacementpricedate = ?,
2087 datelastborrowed = ?,
2095 coded_location_qualifier = ?,
2098 itemnotes_nonpublic = ?,
2102 permanent_location = ?,
2114 more_subfields_xml = ?,
2119 my $sth = $dbh->prepare($query);
2120 my $today = output_pref({ dt => dt_from_string, dateformat => 'iso', dateonly => 1 });
2122 $item->{'biblionumber'},
2123 $item->{'biblioitemnumber'},
2125 $item->{'dateaccessioned'},
2126 $item->{'booksellerid'},
2127 $item->{'homebranch'},
2129 $item->{'replacementprice'},
2130 $item->{'replacementpricedate'} || $today,
2131 $item->{datelastborrowed},
2132 $item->{datelastseen} || $today,
2134 $item->{'notforloan'},
2136 $item->{'itemlost'},
2137 $item->{'withdrawn'},
2138 $item->{'itemcallnumber'},
2139 $item->{'coded_location_qualifier'},
2140 $item->{'restricted'},
2141 $item->{'itemnotes'},
2142 $item->{'itemnotes_nonpublic'},
2143 $item->{'holdingbranch'},
2145 $item->{'location'},
2146 $item->{'permanent_location'},
2149 $item->{'renewals'},
2150 $item->{'reserves'},
2151 $item->{'items.cn_source'},
2152 $item->{'items.cn_sort'},
2155 $item->{'materials'},
2157 $item->{'enumchron'},
2158 $item->{'more_subfields_xml'},
2159 $item->{'copynumber'},
2160 $item->{'stocknumber'},
2161 $item->{'new_status'},
2165 if ( defined $sth->errstr ) {
2166 $error.="ERROR in _koha_new_item $query".$sth->errstr;
2169 $itemnumber = $dbh->{'mysql_insertid'};
2172 return ( $itemnumber, $error );
2175 =head2 MoveItemFromBiblio
2177 MoveItemFromBiblio($itenumber, $frombiblio, $tobiblio);
2179 Moves an item from a biblio to another
2181 Returns undef if the move failed or the biblionumber of the destination record otherwise
2185 sub MoveItemFromBiblio {
2186 my ($itemnumber, $frombiblio, $tobiblio) = @_;
2187 my $dbh = C4::Context->dbh;
2188 my ( $tobiblioitem ) = $dbh->selectrow_array(q|
2189 SELECT biblioitemnumber
2191 WHERE biblionumber = ?
2192 |, undef, $tobiblio );
2193 my $return = $dbh->do(q|
2195 SET biblioitemnumber = ?,
2197 WHERE itemnumber = ?
2198 AND biblionumber = ?
2199 |, undef, $tobiblioitem, $tobiblio, $itemnumber, $frombiblio );
2201 ModZebra( $tobiblio, "specialUpdate", "biblioserver" );
2202 ModZebra( $frombiblio, "specialUpdate", "biblioserver" );
2203 # Checking if the item we want to move is in an order
2204 require C4::Acquisition;
2205 my $order = C4::Acquisition::GetOrderFromItemnumber($itemnumber);
2207 # Replacing the biblionumber within the order if necessary
2208 $order->{'biblionumber'} = $tobiblio;
2209 C4::Acquisition::ModOrder($order);
2212 # Update reserves, hold_fill_targets, tmp_holdsqueue and linktracker tables
2213 for my $table_name ( qw( reserves hold_fill_targets tmp_holdsqueue linktracker ) ) {
2216 SET biblionumber = ?
2217 WHERE itemnumber = ?
2218 |, undef, $tobiblio, $itemnumber );
2225 =head2 ItemSafeToDelete
2227 ItemSafeToDelete( $biblionumber, $itemnumber);
2229 Exported function (core API) for checking whether an item record is safe to delete.
2231 returns 1 if the item is safe to delete,
2233 "book_on_loan" if the item is checked out,
2235 "not_same_branch" if the item is blocked by independent branches,
2237 "book_reserved" if the there are holds aganst the item, or
2239 "linked_analytics" if the item has linked analytic records.
2243 sub ItemSafeToDelete {
2244 my ( $biblionumber, $itemnumber ) = @_;
2246 my $dbh = C4::Context->dbh;
2250 my $countanalytics = GetAnalyticsCount($itemnumber);
2252 # check that there is no issue on this item before deletion.
2253 my $sth = $dbh->prepare(
2255 SELECT COUNT(*) FROM issues
2256 WHERE itemnumber = ?
2259 $sth->execute($itemnumber);
2260 my ($onloan) = $sth->fetchrow;
2262 my $item = GetItem($itemnumber);
2265 $status = "book_on_loan";
2267 elsif ( defined C4::Context->userenv
2268 and !C4::Context->IsSuperLibrarian()
2269 and C4::Context->preference("IndependentBranches")
2270 and ( C4::Context->userenv->{branch} ne $item->{'homebranch'} ) )
2272 $status = "not_same_branch";
2275 # check it doesn't have a waiting reserve
2276 $sth = $dbh->prepare(
2278 SELECT COUNT(*) FROM reserves
2279 WHERE (found = 'W' OR found = 'T')
2283 $sth->execute($itemnumber);
2284 my ($reserve) = $sth->fetchrow;
2286 $status = "book_reserved";
2288 elsif ( $countanalytics > 0 ) {
2289 $status = "linked_analytics";
2300 DelItemCheck( $biblionumber, $itemnumber);
2302 Exported function (core API) for deleting an item record in Koha if there no current issue.
2304 DelItemCheck wraps ItemSafeToDelete around DelItem.
2309 my ( $biblionumber, $itemnumber ) = @_;
2310 my $status = ItemSafeToDelete( $biblionumber, $itemnumber );
2312 if ( $status == 1 ) {
2315 biblionumber => $biblionumber,
2316 itemnumber => $itemnumber
2323 =head2 _koha_modify_item
2325 my ($itemnumber,$error) =_koha_modify_item( $item );
2327 Perform the actual update of the C<items> row. Note that this
2328 routine accepts a hashref specifying the columns to update.
2332 sub _koha_modify_item {
2334 my $dbh=C4::Context->dbh;
2337 my $query = "UPDATE items SET ";
2339 _mod_item_dates( $item );
2340 for my $key ( keys %$item ) {
2341 next if ( $key eq 'itemnumber' );
2343 push @bind, $item->{$key};
2346 $query .= " WHERE itemnumber=?";
2347 push @bind, $item->{'itemnumber'};
2348 my $sth = $dbh->prepare($query);
2349 $sth->execute(@bind);
2351 $error.="ERROR in _koha_modify_item $query: ".$sth->errstr;
2354 return ($item->{'itemnumber'},$error);
2357 sub _mod_item_dates { # date formatting for date fields in item hash
2359 return if !$item || ref($item) ne 'HASH';
2362 { $_ =~ /^onloan$|^date|date$|datetime$/ }
2364 # Incl. dateaccessioned,replacementpricedate,datelastborrowed,datelastseen
2365 # NOTE: We do not (yet) have items fields ending with datetime
2366 # Fields with _on$ have been handled already
2368 foreach my $key ( @keys ) {
2369 next if !defined $item->{$key}; # skip undefs
2370 my $dt = eval { dt_from_string( $item->{$key} ) };
2371 # eval: dt_from_string will die on us if we pass illegal dates
2374 if( defined $dt && ref($dt) eq 'DateTime' ) {
2375 if( $key =~ /datetime/ ) {
2376 $newstr = DateTime::Format::MySQL->format_datetime($dt);
2378 $newstr = DateTime::Format::MySQL->format_date($dt);
2381 $item->{$key} = $newstr; # might be undef to clear garbage
2385 =head2 _koha_delete_item
2387 _koha_delete_item( $itemnum );
2389 Internal function to delete an item record from the koha tables
2393 sub _koha_delete_item {
2394 my ( $itemnum ) = @_;
2396 my $dbh = C4::Context->dbh;
2397 # save the deleted item to deleteditems table
2398 my $sth = $dbh->prepare("SELECT * FROM items WHERE itemnumber=?");
2399 $sth->execute($itemnum);
2400 my $data = $sth->fetchrow_hashref();
2402 # There is no item to delete
2403 return 0 unless $data;
2405 my $query = "INSERT INTO deleteditems SET ";
2407 foreach my $key ( keys %$data ) {
2408 next if ( $key eq 'timestamp' ); # timestamp will be set by db
2409 $query .= "$key = ?,";
2410 push( @bind, $data->{$key} );
2413 $sth = $dbh->prepare($query);
2414 $sth->execute(@bind);
2416 # delete from items table
2417 $sth = $dbh->prepare("DELETE FROM items WHERE itemnumber=?");
2418 my $deleted = $sth->execute($itemnum);
2419 return ( $deleted == 1 ) ? 1 : 0;
2422 =head2 _marc_from_item_hash
2424 my $item_marc = _marc_from_item_hash($item, $frameworkcode[, $unlinked_item_subfields]);
2426 Given an item hash representing a complete item record,
2427 create a C<MARC::Record> object containing an embedded
2428 tag representing that item.
2430 The third, optional parameter C<$unlinked_item_subfields> is
2431 an arrayref of subfields (not mapped to C<items> fields per the
2432 framework) to be added to the MARC representation
2437 sub _marc_from_item_hash {
2439 my $frameworkcode = shift;
2440 my $unlinked_item_subfields;
2442 $unlinked_item_subfields = shift;
2445 # Tack on 'items.' prefix to column names so lookup from MARC frameworks will work
2446 # Also, don't emit a subfield if the underlying field is blank.
2447 my $mungeditem = { map { (defined($item->{$_}) and $item->{$_} ne '') ?
2448 (/^items\./ ? ($_ => $item->{$_}) : ("items.$_" => $item->{$_}))
2449 : () } keys %{ $item } };
2451 my $item_marc = MARC::Record->new();
2452 foreach my $item_field ( keys %{$mungeditem} ) {
2453 my ( $tag, $subfield ) = GetMarcFromKohaField( $item_field, $frameworkcode );
2454 next unless defined $tag and defined $subfield; # skip if not mapped to MARC field
2455 my @values = split(/\s?\|\s?/, $mungeditem->{$item_field}, -1);
2456 foreach my $value (@values){
2457 if ( my $field = $item_marc->field($tag) ) {
2458 $field->add_subfields( $subfield => $value );
2460 my $add_subfields = [];
2461 if (defined $unlinked_item_subfields and ref($unlinked_item_subfields) eq 'ARRAY' and $#$unlinked_item_subfields > -1) {
2462 $add_subfields = $unlinked_item_subfields;
2464 $item_marc->add_fields( $tag, " ", " ", $subfield => $value, @$add_subfields );
2472 =head2 _repack_item_errors
2474 Add an error message hash generated by C<CheckItemPreSave>
2475 to a list of errors.
2479 sub _repack_item_errors {
2480 my $item_sequence_num = shift;
2481 my $item_ref = shift;
2482 my $error_ref = shift;
2484 my @repacked_errors = ();
2486 foreach my $error_code (sort keys %{ $error_ref }) {
2487 my $repacked_error = {};
2488 $repacked_error->{'item_sequence'} = $item_sequence_num;
2489 $repacked_error->{'item_barcode'} = exists($item_ref->{'barcode'}) ? $item_ref->{'barcode'} : '';
2490 $repacked_error->{'error_code'} = $error_code;
2491 $repacked_error->{'error_information'} = $error_ref->{$error_code};
2492 push @repacked_errors, $repacked_error;
2495 return @repacked_errors;
2498 =head2 _get_unlinked_item_subfields
2500 my $unlinked_item_subfields = _get_unlinked_item_subfields($original_item_marc, $frameworkcode);
2504 sub _get_unlinked_item_subfields {
2505 my $original_item_marc = shift;
2506 my $frameworkcode = shift;
2508 my $marcstructure = GetMarcStructure(1, $frameworkcode, { unsafe => 1 });
2510 # assume that this record has only one field, and that that
2511 # field contains only the item information
2513 my @fields = $original_item_marc->fields();
2514 if ($#fields > -1) {
2515 my $field = $fields[0];
2516 my $tag = $field->tag();
2517 foreach my $subfield ($field->subfields()) {
2518 if (defined $subfield->[1] and
2519 $subfield->[1] ne '' and
2520 !$marcstructure->{$tag}->{$subfield->[0]}->{'kohafield'}) {
2521 push @$subfields, $subfield->[0] => $subfield->[1];
2528 =head2 _get_unlinked_subfields_xml
2530 my $unlinked_subfields_xml = _get_unlinked_subfields_xml($unlinked_item_subfields);
2534 sub _get_unlinked_subfields_xml {
2535 my $unlinked_item_subfields = shift;
2538 if (defined $unlinked_item_subfields and ref($unlinked_item_subfields) eq 'ARRAY' and $#$unlinked_item_subfields > -1) {
2539 my $marc = MARC::Record->new();
2540 # use of tag 999 is arbitrary, and doesn't need to match the item tag
2541 # used in the framework
2542 $marc->append_fields(MARC::Field->new('999', ' ', ' ', @$unlinked_item_subfields));
2543 $marc->encoding("UTF-8");
2544 $xml = $marc->as_xml("USMARC");
2550 =head2 _parse_unlinked_item_subfields_from_xml
2552 my $unlinked_item_subfields = _parse_unlinked_item_subfields_from_xml($whole_item->{'more_subfields_xml'}):
2556 sub _parse_unlinked_item_subfields_from_xml {
2558 require C4::Charset;
2559 return unless defined $xml and $xml ne "";
2560 my $marc = MARC::Record->new_from_xml(C4::Charset::StripNonXmlChars($xml),'UTF-8');
2561 my $unlinked_subfields = [];
2562 my @fields = $marc->fields();
2563 if ($#fields > -1) {
2564 foreach my $subfield ($fields[0]->subfields()) {
2565 push @$unlinked_subfields, $subfield->[0] => $subfield->[1];
2568 return $unlinked_subfields;
2571 =head2 GetAnalyticsCount
2573 $count= &GetAnalyticsCount($itemnumber)
2575 counts Usage of itemnumber in Analytical bibliorecords.
2579 sub GetAnalyticsCount {
2580 my ($itemnumber) = @_;
2582 ### ZOOM search here
2584 $query= "hi=".$itemnumber;
2585 my $searcher = Koha::SearchEngine::Search->new({index => $Koha::SearchEngine::BIBLIOS_INDEX});
2586 my ($err,$res,$result) = $searcher->simple_search_compat($query,0,10);
2592 $holds = &GetItemHolds($biblionumber, $itemnumber);
2594 This function return the count of holds with $biblionumber and $itemnumber
2599 my ($biblionumber, $itemnumber) = @_;
2601 my $dbh = C4::Context->dbh;
2602 my $query = "SELECT count(*)
2604 WHERE biblionumber=? AND itemnumber=?";
2605 my $sth = $dbh->prepare($query);
2606 $sth->execute($biblionumber, $itemnumber);
2607 $holds = $sth->fetchrow;
2611 =head2 SearchItemsByField
2613 my $items = SearchItemsByField($field, $value);
2615 SearchItemsByField will search for items on a specific given field.
2616 For instance you can search all items with a specific stocknumber like this:
2618 my $items = SearchItemsByField('stocknumber', $stocknumber);
2622 sub SearchItemsByField {
2623 my ($field, $value) = @_;
2630 my ($results) = SearchItems($filters);
2634 sub _SearchItems_build_where_fragment {
2637 my $dbh = C4::Context->dbh;
2640 if (exists($filter->{conjunction})) {
2641 my (@where_strs, @where_args);
2642 foreach my $f (@{ $filter->{filters} }) {
2643 my $fragment = _SearchItems_build_where_fragment($f);
2645 push @where_strs, $fragment->{str};
2646 push @where_args, @{ $fragment->{args} };
2651 $where_str = '(' . join (' ' . $filter->{conjunction} . ' ', @where_strs) . ')';
2654 args => \@where_args,
2658 my @columns = Koha::Database->new()->schema()->resultset('Item')->result_source->columns;
2659 push @columns, Koha::Database->new()->schema()->resultset('Biblio')->result_source->columns;
2660 push @columns, Koha::Database->new()->schema()->resultset('Biblioitem')->result_source->columns;
2661 my @operators = qw(= != > < >= <= like);
2662 my $field = $filter->{field};
2663 if ( (0 < grep /^$field$/, @columns) or (substr($field, 0, 5) eq 'marc:') ) {
2664 my $op = $filter->{operator};
2665 my $query = $filter->{query};
2667 if (!$op or (0 == grep /^$op$/, @operators)) {
2668 $op = '='; # default operator
2672 if ($field =~ /^marc:(\d{3})(?:\$(\w))?$/) {
2674 my $marcsubfield = $2;
2675 my ($kohafield) = $dbh->selectrow_array(q|
2676 SELECT kohafield FROM marc_subfield_structure
2677 WHERE tagfield=? AND tagsubfield=? AND frameworkcode=''
2678 |, undef, $marcfield, $marcsubfield);
2681 $column = $kohafield;
2683 # MARC field is not linked to a DB field so we need to use
2684 # ExtractValue on marcxml from biblio_metadata or
2685 # items.more_subfields_xml, depending on the MARC field.
2688 my ($itemfield) = GetMarcFromKohaField('items.itemnumber');
2689 if ($marcfield eq $itemfield) {
2690 $sqlfield = 'more_subfields_xml';
2691 $xpath = '//record/datafield/subfield[@code="' . $marcsubfield . '"]';
2693 $sqlfield = 'metadata'; # From biblio_metadata
2694 if ($marcfield < 10) {
2695 $xpath = "//record/controlfield[\@tag=\"$marcfield\"]";
2697 $xpath = "//record/datafield[\@tag=\"$marcfield\"]/subfield[\@code=\"$marcsubfield\"]";
2700 $column = "ExtractValue($sqlfield, '$xpath')";
2706 if (ref $query eq 'ARRAY') {
2709 } elsif ($op eq '!=') {
2713 str => "$column $op (" . join (',', ('?') x @$query) . ")",
2718 str => "$column $op ?",
2725 return $where_fragment;
2730 my ($items, $total) = SearchItems($filter, $params);
2732 Perform a search among items
2734 $filter is a reference to a hash which can be a filter, or a combination of filters.
2736 A filter has the following keys:
2740 =item * field: the name of a SQL column in table items
2742 =item * query: the value to search in this column
2744 =item * operator: comparison operator. Can be one of = != > < >= <= like
2748 A combination of filters hash the following keys:
2752 =item * conjunction: 'AND' or 'OR'
2754 =item * filters: array ref of filters
2758 $params is a reference to a hash that can contain the following parameters:
2762 =item * rows: Number of items to return. 0 returns everything (default: 0)
2764 =item * page: Page to return (return items from (page-1)*rows to (page*rows)-1)
2767 =item * sortby: A SQL column name in items table to sort on
2769 =item * sortorder: 'ASC' or 'DESC'
2776 my ($filter, $params) = @_;
2780 return unless ref $filter eq 'HASH';
2781 return unless ref $params eq 'HASH';
2783 # Default parameters
2784 $params->{rows} ||= 0;
2785 $params->{page} ||= 1;
2786 $params->{sortby} ||= 'itemnumber';
2787 $params->{sortorder} ||= 'ASC';
2789 my ($where_str, @where_args);
2790 my $where_fragment = _SearchItems_build_where_fragment($filter);
2791 if ($where_fragment) {
2792 $where_str = $where_fragment->{str};
2793 @where_args = @{ $where_fragment->{args} };
2796 my $dbh = C4::Context->dbh;
2798 SELECT SQL_CALC_FOUND_ROWS items.*
2800 LEFT JOIN biblio ON biblio.biblionumber = items.biblionumber
2801 LEFT JOIN biblioitems ON biblioitems.biblioitemnumber = items.biblioitemnumber
2802 LEFT JOIN biblio_metadata ON biblio_metadata.biblionumber = biblio.biblionumber
2805 if (defined $where_str and $where_str ne '') {
2806 $query .= qq{ AND $where_str };
2809 $query .= q{ AND biblio_metadata.format = 'marcxml' AND biblio_metadata.marcflavour = ? };
2810 push @where_args, C4::Context->preference('marcflavour');
2812 my @columns = Koha::Database->new()->schema()->resultset('Item')->result_source->columns;
2813 push @columns, Koha::Database->new()->schema()->resultset('Biblio')->result_source->columns;
2814 push @columns, Koha::Database->new()->schema()->resultset('Biblioitem')->result_source->columns;
2815 my $sortby = (0 < grep {$params->{sortby} eq $_} @columns)
2816 ? $params->{sortby} : 'itemnumber';
2817 my $sortorder = (uc($params->{sortorder}) eq 'ASC') ? 'ASC' : 'DESC';
2818 $query .= qq{ ORDER BY $sortby $sortorder };
2820 my $rows = $params->{rows};
2823 my $offset = $rows * ($params->{page}-1);
2824 $query .= qq { LIMIT ?, ? };
2825 push @limit_args, $offset, $rows;
2828 my $sth = $dbh->prepare($query);
2829 my $rv = $sth->execute(@where_args, @limit_args);
2831 return unless ($rv);
2832 my ($total_rows) = $dbh->selectrow_array(q{ SELECT FOUND_ROWS() });
2834 return ($sth->fetchall_arrayref({}), $total_rows);
2838 =head1 OTHER FUNCTIONS
2842 ($indicators, $value) = _find_value($tag, $subfield, $record,$encoding);
2844 Find the given $subfield in the given $tag in the given
2845 MARC::Record $record. If the subfield is found, returns
2846 the (indicators, value) pair; otherwise, (undef, undef) is
2850 Such a function is used in addbiblio AND additem and serial-edit and maybe could be used in Authorities.
2851 I suggest we export it from this module.
2856 my ( $tagfield, $insubfield, $record, $encoding ) = @_;
2859 if ( $tagfield < 10 ) {
2860 if ( $record->field($tagfield) ) {
2861 push @result, $record->field($tagfield)->data();
2866 foreach my $field ( $record->field($tagfield) ) {
2867 my @subfields = $field->subfields();
2868 foreach my $subfield (@subfields) {
2869 if ( @$subfield[0] eq $insubfield ) {
2870 push @result, @$subfield[1];
2871 $indicator = $field->indicator(1) . $field->indicator(2);
2876 return ( $indicator, @result );
2880 =head2 PrepareItemrecordDisplay
2882 PrepareItemrecordDisplay($itemrecord,$bibnum,$itemumber,$frameworkcode);
2884 Returns a hash with all the fields for Display a given item data in a template
2886 The $frameworkcode returns the item for the given frameworkcode, ONLY if bibnum is not provided
2890 sub PrepareItemrecordDisplay {
2892 my ( $bibnum, $itemnum, $defaultvalues, $frameworkcode ) = @_;
2894 my $dbh = C4::Context->dbh;
2895 $frameworkcode = &GetFrameworkCode($bibnum) if $bibnum;
2896 my ( $itemtagfield, $itemtagsubfield ) = &GetMarcFromKohaField( "items.itemnumber", $frameworkcode );
2898 # Note: $tagslib obtained from GetMarcStructure() in 'unsafe' mode is
2899 # a shared data structure. No plugin (including custom ones) should change
2900 # its contents. See also GetMarcStructure.
2901 my $tagslib = &GetMarcStructure( 1, $frameworkcode, { unsafe => 1 } );
2903 # return nothing if we don't have found an existing framework.
2904 return q{} unless $tagslib;
2907 $itemrecord = C4::Items::GetMarcItem( $bibnum, $itemnum );
2911 my $branch_limit = C4::Context->userenv ? C4::Context->userenv->{"branch"} : "";
2913 SELECT authorised_value,lib FROM authorised_values
2916 LEFT JOIN authorised_values_branches ON ( id = av_id )
2921 $query .= qq{ AND ( branchcode = ? OR branchcode IS NULL )} if $branch_limit;
2922 $query .= qq{ ORDER BY lib};
2923 my $authorised_values_sth = $dbh->prepare( $query );
2924 foreach my $tag ( sort keys %{$tagslib} ) {
2927 # loop through each subfield
2929 foreach my $subfield ( sort keys %{ $tagslib->{$tag} } ) {
2930 next if IsMarcStructureInternal($tagslib->{$tag}{$subfield});
2931 next unless ( $tagslib->{$tag}->{$subfield}->{'tab'} );
2932 next if ( $tagslib->{$tag}->{$subfield}->{'tab'} ne "10" );
2934 $subfield_data{tag} = $tag;
2935 $subfield_data{subfield} = $subfield;
2936 $subfield_data{countsubfield} = $cntsubf++;
2937 $subfield_data{kohafield} = $tagslib->{$tag}->{$subfield}->{'kohafield'};
2938 $subfield_data{id} = "tag_".$tag."_subfield_".$subfield."_".int(rand(1000000));
2940 # $subfield_data{marc_lib}=$tagslib->{$tag}->{$subfield}->{lib};
2941 $subfield_data{marc_lib} = $tagslib->{$tag}->{$subfield}->{lib};
2942 $subfield_data{mandatory} = $tagslib->{$tag}->{$subfield}->{mandatory};
2943 $subfield_data{repeatable} = $tagslib->{$tag}->{$subfield}->{repeatable};
2944 $subfield_data{hidden} = "display:none"
2945 if ( ( $tagslib->{$tag}->{$subfield}->{hidden} > 4 )
2946 || ( $tagslib->{$tag}->{$subfield}->{hidden} < -4 ) );
2947 my ( $x, $defaultvalue );
2949 ( $x, $defaultvalue ) = _find_value( $tag, $subfield, $itemrecord );
2951 $defaultvalue = $tagslib->{$tag}->{$subfield}->{defaultvalue} unless $defaultvalue;
2952 if ( !defined $defaultvalue ) {
2953 $defaultvalue = q||;
2955 $defaultvalue =~ s/"/"/g;
2958 # search for itemcallnumber if applicable
2959 if ( $tagslib->{$tag}->{$subfield}->{kohafield} eq 'items.itemcallnumber'
2960 && C4::Context->preference('itemcallnumber') ) {
2961 my $CNtag = substr( C4::Context->preference('itemcallnumber'), 0, 3 );
2962 my $CNsubfield = substr( C4::Context->preference('itemcallnumber'), 3, 1 );
2963 if ( $itemrecord and my $field = $itemrecord->field($CNtag) ) {
2964 $defaultvalue = $field->subfield($CNsubfield);
2967 if ( $tagslib->{$tag}->{$subfield}->{kohafield} eq 'items.itemcallnumber'
2969 && $defaultvalues->{'callnumber'} ) {
2970 if( $itemrecord and $defaultvalues and not $itemrecord->subfield($tag,$subfield) ){
2971 # if the item record exists, only use default value if the item has no callnumber
2972 $defaultvalue = $defaultvalues->{callnumber};
2973 } elsif ( !$itemrecord and $defaultvalues ) {
2974 # if the item record *doesn't* exists, always use the default value
2975 $defaultvalue = $defaultvalues->{callnumber};
2978 if ( ( $tagslib->{$tag}->{$subfield}->{kohafield} eq 'items.holdingbranch' || $tagslib->{$tag}->{$subfield}->{kohafield} eq 'items.homebranch' )
2980 && $defaultvalues->{'branchcode'} ) {
2981 if ( $itemrecord and $defaultvalues and not $itemrecord->subfield($tag,$subfield) ) {
2982 $defaultvalue = $defaultvalues->{branchcode};
2985 if ( ( $tagslib->{$tag}->{$subfield}->{kohafield} eq 'items.location' )
2987 && $defaultvalues->{'location'} ) {
2989 if ( $itemrecord and $defaultvalues and not $itemrecord->subfield($tag,$subfield) ) {
2990 # if the item record exists, only use default value if the item has no locationr
2991 $defaultvalue = $defaultvalues->{location};
2992 } elsif ( !$itemrecord and $defaultvalues ) {
2993 # if the item record *doesn't* exists, always use the default value
2994 $defaultvalue = $defaultvalues->{location};
2997 if ( $tagslib->{$tag}->{$subfield}->{authorised_value} ) {
2998 my @authorised_values;
3001 # builds list, depending on authorised value...
3003 if ( $tagslib->{$tag}->{$subfield}->{'authorised_value'} eq "branches" ) {
3004 if ( ( C4::Context->preference("IndependentBranches") )
3005 && !C4::Context->IsSuperLibrarian() ) {
3006 my $sth = $dbh->prepare( "SELECT branchcode,branchname FROM branches WHERE branchcode = ? ORDER BY branchname" );
3007 $sth->execute( C4::Context->userenv->{branch} );
3008 push @authorised_values, ""
3009 unless ( $tagslib->{$tag}->{$subfield}->{mandatory} );
3010 while ( my ( $branchcode, $branchname ) = $sth->fetchrow_array ) {
3011 push @authorised_values, $branchcode;
3012 $authorised_lib{$branchcode} = $branchname;
3015 my $sth = $dbh->prepare( "SELECT branchcode,branchname FROM branches ORDER BY branchname" );
3017 push @authorised_values, ""
3018 unless ( $tagslib->{$tag}->{$subfield}->{mandatory} );
3019 while ( my ( $branchcode, $branchname ) = $sth->fetchrow_array ) {
3020 push @authorised_values, $branchcode;
3021 $authorised_lib{$branchcode} = $branchname;
3025 $defaultvalue = C4::Context->userenv ? C4::Context->userenv->{branch} : undef;
3026 if ( $defaultvalues and $defaultvalues->{branchcode} ) {
3027 $defaultvalue = $defaultvalues->{branchcode};
3031 } elsif ( $tagslib->{$tag}->{$subfield}->{authorised_value} eq "itemtypes" ) {
3032 my $itemtypes = GetItemTypes( style => 'array' );
3033 push @authorised_values, ""
3034 unless ( $tagslib->{$tag}->{$subfield}->{mandatory} );
3035 for my $itemtype ( @$itemtypes ) {
3036 push @authorised_values, $itemtype->{itemtype};
3037 $authorised_lib{$itemtype->{itemtype}} = $itemtype->{translated_description};
3039 if ($defaultvalues && $defaultvalues->{'itemtype'}) {
3040 $defaultvalue = $defaultvalues->{'itemtype'};
3044 } elsif ( $tagslib->{$tag}->{$subfield}->{authorised_value} eq "cn_source" ) {
3045 push @authorised_values, "" unless ( $tagslib->{$tag}->{$subfield}->{mandatory} );
3047 my $class_sources = GetClassSources();
3048 my $default_source = C4::Context->preference("DefaultClassificationSource");
3050 foreach my $class_source (sort keys %$class_sources) {
3051 next unless $class_sources->{$class_source}->{'used'} or
3052 ($class_source eq $default_source);
3053 push @authorised_values, $class_source;
3054 $authorised_lib{$class_source} = $class_sources->{$class_source}->{'description'};
3057 $defaultvalue = $default_source;
3059 #---- "true" authorised value
3061 $authorised_values_sth->execute(
3062 $tagslib->{$tag}->{$subfield}->{authorised_value},
3063 $branch_limit ? $branch_limit : ()
3065 push @authorised_values, ""
3066 unless ( $tagslib->{$tag}->{$subfield}->{mandatory} );
3067 while ( my ( $value, $lib ) = $authorised_values_sth->fetchrow_array ) {
3068 push @authorised_values, $value;
3069 $authorised_lib{$value} = $lib;
3072 $subfield_data{marc_value} = {
3074 values => \@authorised_values,
3075 default => "$defaultvalue",
3076 labels => \%authorised_lib,
3078 } elsif ( $tagslib->{$tag}->{$subfield}->{value_builder} ) {
3080 require Koha::FrameworkPlugin;
3081 my $plugin = Koha::FrameworkPlugin->new({
3082 name => $tagslib->{$tag}->{$subfield}->{value_builder},
3085 my $pars = { dbh => $dbh, record => undef, tagslib =>$tagslib, id => $subfield_data{id}, tabloop => undef };
3086 $plugin->build( $pars );
3087 if ( $itemrecord and my $field = $itemrecord->field($tag) ) {
3088 $defaultvalue = $field->subfield($subfield);
3090 if( !$plugin->errstr ) {
3091 #TODO Move html to template; see report 12176/13397
3092 my $tab= $plugin->noclick? '-1': '';
3093 my $class= $plugin->noclick? ' disabled': '';
3094 my $title= $plugin->noclick? 'No popup': 'Tag editor';
3095 $subfield_data{marc_value} = qq[<input type="text" id="$subfield_data{id}" name="field_value" class="input_marceditor" size="50" maxlength="255" value="$defaultvalue" /><a href="#" id="buttonDot_$subfield_data{id}" tabindex="$tab" class="buttonDot $class" title="$title">...</a>\n].$plugin->javascript;
3097 warn $plugin->errstr;
3098 $subfield_data{marc_value} = qq(<input type="text" id="$subfield_data{id}" name="field_value" class="input_marceditor" size="50" maxlength="255" value="$defaultvalue" />); # supply default input form
3101 elsif ( $tag eq '' ) { # it's an hidden field
3102 $subfield_data{marc_value} = qq(<input type="hidden" tabindex="1" id="$subfield_data{id}" name="field_value" class="input_marceditor" size="50" maxlength="255" value="$defaultvalue" />);
3104 elsif ( $tagslib->{$tag}->{$subfield}->{'hidden'} ) { # FIXME: shouldn't input type be "hidden" ?
3105 $subfield_data{marc_value} = qq(<input type="text" tabindex="1" id="$subfield_data{id}" name="field_value" class="input_marceditor" size="50" maxlength="255" value="$defaultvalue" />);
3107 elsif ( length($defaultvalue) > 100
3108 or (C4::Context->preference("marcflavour") eq "UNIMARC" and
3109 300 <= $tag && $tag < 400 && $subfield eq 'a' )
3110 or (C4::Context->preference("marcflavour") eq "MARC21" and
3111 500 <= $tag && $tag < 600 )
3113 # oversize field (textarea)
3114 $subfield_data{marc_value} = qq(<textarea tabindex="1" id="$subfield_data{id}" name="field_value" class="input_marceditor" size="50" maxlength="255">$defaultvalue</textarea>\n");
3116 $subfield_data{marc_value} = "<input type=\"text\" name=\"field_value\" value=\"$defaultvalue\" size=\"50\" maxlength=\"255\" />";
3118 push( @loop_data, \%subfield_data );
3123 if ( $itemrecord && $itemrecord->field($itemtagfield) ) {
3124 $itemnumber = $itemrecord->subfield( $itemtagfield, $itemtagsubfield );
3127 'itemtagfield' => $itemtagfield,
3128 'itemtagsubfield' => $itemtagsubfield,
3129 'itemnumber' => $itemnumber,
3130 'iteminformation' => \@loop_data
3134 sub ToggleNewStatus {
3135 my ( $params ) = @_;
3136 my @rules = @{ $params->{rules} };
3137 my $report_only = $params->{report_only};
3139 my $dbh = C4::Context->dbh;
3141 my @item_columns = map { "items.$_" } Koha::Items->columns;
3142 my @biblioitem_columns = map { "biblioitems.$_" } Koha::Biblioitems->columns;
3144 for my $rule ( @rules ) {
3145 my $age = $rule->{age};
3146 my $conditions = $rule->{conditions};
3147 my $substitutions = $rule->{substitutions};
3151 SELECT items.biblionumber, items.itemnumber
3153 LEFT JOIN biblioitems ON biblioitems.biblionumber = items.biblionumber
3156 for my $condition ( @$conditions ) {
3158 grep {/^$condition->{field}$/} @item_columns
3159 or grep {/^$condition->{field}$/} @biblioitem_columns
3161 if ( $condition->{value} =~ /\|/ ) {
3162 my @values = split /\|/, $condition->{value};
3163 $query .= qq| AND $condition->{field} IN (|
3164 . join( ',', ('?') x scalar @values )
3166 push @params, @values;
3168 $query .= qq| AND $condition->{field} = ?|;
3169 push @params, $condition->{value};
3173 if ( defined $age ) {
3174 $query .= q| AND TO_DAYS(NOW()) - TO_DAYS(dateaccessioned) >= ? |;
3177 my $sth = $dbh->prepare($query);
3178 $sth->execute( @params );
3179 while ( my $values = $sth->fetchrow_hashref ) {
3180 my $biblionumber = $values->{biblionumber};
3181 my $itemnumber = $values->{itemnumber};
3182 my $item = C4::Items::GetItem( $itemnumber );
3183 for my $substitution ( @$substitutions ) {
3184 next unless $substitution->{field};
3185 C4::Items::ModItem( {$substitution->{field} => $substitution->{value}}, $biblionumber, $itemnumber )
3186 unless $report_only;
3187 push @{ $report->{$itemnumber} }, $substitution;