#
# This file is part of Koha.
#
-# Koha is free software; you can redistribute it and/or modify it under the
-# terms of the GNU General Public License as published by the Free Software
-# Foundation; either version 3 of the License, or (at your option) any later
-# version.
+# Koha is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
#
-# Koha is distributed in the hope that it will be useful, but WITHOUT ANY
-# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
-# A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+# Koha is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
#
-# You should have received a copy of the GNU General Public License along
-# with Koha; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+# You should have received a copy of the GNU General Public License
+# along with Koha; if not, see <http://www.gnu.org/licenses>.
use Modern::Perl;
use Carp;
use List::MoreUtils qw(any);
+use Data::Dumper;
+use Try::Tiny;
use Koha::Database;
use Koha::DateUtils qw( dt_from_string );
use C4::Context;
use C4::Circulation;
use C4::Reserves;
+use C4::Biblio qw( ModZebra ); # FIXME This is terrible, we should move the indexation code outside of C4::Biblio
+use C4::ClassSource; # FIXME We would like to avoid that
+use C4::Log qw( logaction );
+
use Koha::Checkouts;
-use Koha::IssuingRules;
+use Koha::CirculationRules;
use Koha::Item::Transfer::Limits;
use Koha::Item::Transfers;
+use Koha::ItemTypes;
use Koha::Patrons;
+use Koha::Plugins;
use Koha::Libraries;
use Koha::StockRotationItem;
use Koha::StockRotationRotas;
=cut
+=head3 store
+
+ $item->store;
+
+$params can take an optional 'skip_modzebra_update' parameter.
+If set, the reindexation process will not happen (ModZebra not called)
+
+NOTE: This is a temporary fix to answer a performance issue when lot of items
+are added (or modified) at the same time.
+The correct way to fix this is to make the ES reindexation process async.
+You should not turn it on if you do not understand what it is doing exactly.
+
+=cut
+
+sub store {
+ my $self = shift;
+ my $params = @_ ? shift : {};
+
+ my $log_action = $params->{log_action} // 1;
+
+ # We do not want to oblige callers to pass this value
+ # Dev conveniences vs performance?
+ unless ( $self->biblioitemnumber ) {
+ $self->biblioitemnumber( $self->biblio->biblioitem->biblioitemnumber );
+ }
+
+ # See related changes from C4::Items::AddItem
+ unless ( $self->itype ) {
+ $self->itype($self->biblio->biblioitem->itemtype);
+ }
+
+ my $today = dt_from_string;
+ unless ( $self->in_storage ) { #AddItem
+ unless ( $self->permanent_location ) {
+ $self->permanent_location($self->location);
+ }
+ unless ( $self->replacementpricedate ) {
+ $self->replacementpricedate($today);
+ }
+ unless ( $self->datelastseen ) {
+ $self->datelastseen($today);
+ }
+
+ unless ( $self->dateaccessioned ) {
+ $self->dateaccessioned($today);
+ }
+
+ if ( $self->itemcallnumber
+ or $self->cn_source )
+ {
+ my $cn_sort = GetClassSort( $self->cn_source, $self->itemcallnumber, "" );
+ $self->cn_sort($cn_sort);
+ }
+
+ C4::Biblio::ModZebra( $self->biblionumber, "specialUpdate", "biblioserver" )
+ unless $params->{skip_modzebra_update};
+
+ logaction( "CATALOGUING", "ADD", $self->itemnumber, "item" )
+ if $log_action && C4::Context->preference("CataloguingLog");
+
+ $self->_after_item_action_hooks({ action => 'create' });
+
+ } else { # ModItem
+
+ my %updated_columns = $self->_result->get_dirty_columns;
+ return $self->SUPER::store unless %updated_columns;
+
+ # Retrieve the item for comparison if we need to
+ my $pre_mod_item = (
+ exists $updated_columns{itemlost}
+ or exists $updated_columns{withdrawn}
+ or exists $updated_columns{damaged}
+ ) ? $self->get_from_storage : undef;
+
+ # Update *_on fields if needed
+ # FIXME: Why not for AddItem as well?
+ my @fields = qw( itemlost withdrawn damaged );
+ for my $field (@fields) {
+
+ # If the field is defined but empty or 0, we are
+ # removing/unsetting and thus need to clear out
+ # the 'on' field
+ if ( exists $updated_columns{$field}
+ && defined( $self->$field )
+ && !$self->$field )
+ {
+ my $field_on = "${field}_on";
+ $self->$field_on(undef);
+ }
+ # If the field has changed otherwise, we much update
+ # the 'on' field
+ elsif (exists $updated_columns{$field}
+ && $updated_columns{$field}
+ && !$pre_mod_item->$field )
+ {
+ my $field_on = "${field}_on";
+ $self->$field_on(
+ DateTime::Format::MySQL->format_datetime(
+ dt_from_string()
+ )
+ );
+ }
+ }
+
+ if ( exists $updated_columns{itemcallnumber}
+ or exists $updated_columns{cn_source} )
+ {
+ my $cn_sort = GetClassSort( $self->cn_source, $self->itemcallnumber, "" );
+ $self->cn_sort($cn_sort);
+ }
+
+
+ if ( exists $updated_columns{location}
+ and $self->location ne 'CART'
+ and $self->location ne 'PROC'
+ and not exists $updated_columns{permanent_location} )
+ {
+ $self->permanent_location( $self->location );
+ }
+
+ # If item was lost and has now been found,
+ # reverse any list item charges if necessary.
+ if ( exists $updated_columns{itemlost}
+ and $updated_columns{itemlost} <= 0
+ and $pre_mod_item->itemlost > 0 )
+ {
+ $self->_set_found_trigger($pre_mod_item);
+ $self->paidfor('');
+ }
+
+ C4::Biblio::ModZebra( $self->biblionumber, "specialUpdate", "biblioserver" )
+ unless $params->{skip_modzebra_update};
+
+ $self->_after_item_action_hooks({ action => 'modify' });
+
+ logaction( "CATALOGUING", "MODIFY", $self->itemnumber, "item " . Dumper($self->unblessed) )
+ if $log_action && C4::Context->preference("CataloguingLog");
+ }
+
+ unless ( $self->dateaccessioned ) {
+ $self->dateaccessioned($today);
+ }
+
+ return $self->SUPER::store;
+}
+
+=head3 delete
+
+=cut
+
+sub delete {
+ my $self = shift;
+ my $params = @_ ? shift : {};
+
+ # FIXME check the item has no current issues
+ # i.e. raise the appropriate exception
+
+ C4::Biblio::ModZebra( $self->biblionumber, "specialUpdate", "biblioserver" )
+ unless $params->{skip_modzebra_update};
+
+ $self->_after_item_action_hooks({ action => 'delete' });
+
+ logaction( "CATALOGUING", "DELETE", $self->itemnumber, "item" )
+ if C4::Context->preference("CataloguingLog");
+
+ return $self->SUPER::delete;
+}
+
+=head3 safe_delete
+
+=cut
+
+sub safe_delete {
+ my $self = shift;
+ my $params = @_ ? shift : {};
+
+ my $safe_to_delete = $self->safe_to_delete;
+ return $safe_to_delete unless $safe_to_delete eq '1';
+
+ $self->move_to_deleted;
+
+ return $self->delete($params);
+}
+
+=head3 safe_to_delete
+
+returns 1 if the item is safe to delete,
+
+"book_on_loan" if the item is checked out,
+
+"not_same_branch" if the item is blocked by independent branches,
+
+"book_reserved" if the there are holds aganst the item, or
+
+"linked_analytics" if the item has linked analytic records.
+
+"last_item_for_hold" if the item is the last one on a record on which a biblio-level hold is placed
+
+=cut
+
+sub safe_to_delete {
+ my ($self) = @_;
+
+ return "book_on_loan" if $self->checkout;
+
+ return "not_same_branch"
+ if defined C4::Context->userenv
+ and !C4::Context->IsSuperLibrarian()
+ and C4::Context->preference("IndependentBranches")
+ and ( C4::Context->userenv->{branch} ne $self->homebranch );
+
+ # check it doesn't have a waiting reserve
+ return "book_reserved"
+ if $self->holds->search( { found => [ 'W', 'T' ] } )->count;
+
+ return "linked_analytics"
+ if C4::Items::GetAnalyticsCount( $self->itemnumber ) > 0;
+
+ return "last_item_for_hold"
+ if $self->biblio->items->count == 1
+ && $self->biblio->holds->search(
+ {
+ itemnumber => undef,
+ }
+ )->count;
+
+ return 1;
+}
+
+=head3 move_to_deleted
+
+my $is_moved = $item->move_to_deleted;
+
+Move an item to the deleteditems table.
+This can be done before deleting an item, to make sure the data are not completely deleted.
+
+=cut
+
+sub move_to_deleted {
+ my ($self) = @_;
+ my $item_infos = $self->unblessed;
+ delete $item_infos->{timestamp}; #This ensures the timestamp date in deleteditems will be set to the current timestamp
+ return Koha::Database->new->schema->resultset('Deleteditem')->create($item_infos);
+}
+
+
=head3 effective_itemtype
Returns the itemtype for the item based on whether item level itemtypes are set or not.
=head3 pickup_locations
-@pickup_locations = $item->pickup_locations( {patron => $patron } )
+$pickup_locations = $item->pickup_locations( {patron => $patron } )
Returns possible pickup locations for this item, according to patron's home library (if patron is defined and holds are allowed only from hold groups)
and if item can be transferred to each pickup location.
my @libs;
if(defined $patron) {
- return @libs if $branchitemrule->{holdallowed} == 3 && !$self->home_branch->validate_hold_sibling( {branchcode => $patron->branchcode} );
- return @libs if $branchitemrule->{holdallowed} == 1 && $self->home_branch->branchcode ne $patron->branchcode;
+ return \@libs if $branchitemrule->{holdallowed} == 3 && !$self->home_branch->validate_hold_sibling( {branchcode => $patron->branchcode} );
+ return \@libs if $branchitemrule->{holdallowed} == 1 && $self->home_branch->branchcode ne $patron->branchcode;
}
if ($branchitemrule->{hold_fulfillment_policy} eq 'holdgroup') {
}
}
- return wantarray ? @pickup_locations : \@pickup_locations;
+ return \@pickup_locations;
}
=head3 article_request_type
: undef;
my $borrowertype = $borrower->categorycode;
my $itemtype = $self->effective_itemtype();
- my $issuing_rule = Koha::IssuingRules->get_effective_issuing_rule({ categorycode => $borrowertype, itemtype => $itemtype, branchcode => $branchcode });
+ my $rule = Koha::CirculationRules->get_effective_rule(
+ {
+ rule_name => 'article_requests',
+ categorycode => $borrowertype,
+ itemtype => $itemtype,
+ branchcode => $branchcode
+ }
+ );
- return q{} unless $issuing_rule;
- return $issuing_rule->article_requests || q{}
+ return q{} unless $rule;
+ return $rule->rule_value || q{}
}
=head3 current_holds
next if !$tagfield; # TODO: Should we raise an exception instead?
# Feels like safe fallback is better
- push @subfields, $tagsubfield => $self->$item_field;
+ push @subfields, $tagsubfield => $self->$item_field
+ if defined $self->$item_field and $item_field ne '';
}
my $unlinked_item_subfields = C4::Items::_parse_unlinked_item_subfields_from_xml($self->more_subfields_xml);
return $field;
}
+=head3 renewal_branchcode
+
+Returns the branchcode to be recorded in statistics renewal of the item
+
+=cut
+
+sub renewal_branchcode {
+
+ my ($self, $params ) = @_;
+
+ my $interface = C4::Context->interface;
+ my $branchcode;
+ if ( $interface eq 'opac' ){
+ my $renewal_branchcode = C4::Context->preference('OpacRenewalBranch');
+ if( !defined $renewal_branchcode || $renewal_branchcode eq 'opacrenew' ){
+ $branchcode = 'OPACRenew';
+ }
+ elsif ( $renewal_branchcode eq 'itemhomebranch' ) {
+ $branchcode = $self->homebranch;
+ }
+ elsif ( $renewal_branchcode eq 'patronhomebranch' ) {
+ $branchcode = $self->checkout->patron->branchcode;
+ }
+ elsif ( $renewal_branchcode eq 'checkoutbranch' ) {
+ $branchcode = $self->checkout->branchcode;
+ }
+ else {
+ $branchcode = "";
+ }
+ } else {
+ $branchcode = ( C4::Context->userenv && defined C4::Context->userenv->{branch} )
+ ? C4::Context->userenv->{branch} : $params->{branch};
+ }
+ return $branchcode;
+}
+
+=head3 _set_found_trigger
+
+ $self->_set_found_trigger
+
+Finds the most recent lost item charge for this item and refunds the patron
+appropriately, taking into account any payments or writeoffs already applied
+against the charge.
+
+Internal function, not exported, called only by Koha::Item->store.
+
+=cut
+
+sub _set_found_trigger {
+ my ( $self, $pre_mod_item ) = @_;
+
+ ## If item was lost, it has now been found, reverse any list item charges if necessary.
+ my $no_refund_after_days =
+ C4::Context->preference('NoRefundOnLostReturnedItemsAge');
+ if ($no_refund_after_days) {
+ my $today = dt_from_string();
+ my $lost_age_in_days =
+ dt_from_string( $pre_mod_item->itemlost_on )->delta_days($today)
+ ->in_units('days');
+
+ return $self unless $lost_age_in_days < $no_refund_after_days;
+ }
+
+ return $self
+ unless Koha::CirculationRules->get_lostreturn_policy(
+ {
+ item => $self,
+ return_branch => C4::Context->userenv
+ ? C4::Context->userenv->{'branch'}
+ : undef,
+ }
+ );
+
+ # check for charge made for lost book
+ my $accountlines = Koha::Account::Lines->search(
+ {
+ itemnumber => $self->itemnumber,
+ debit_type_code => 'LOST',
+ status => [ undef, { '<>' => 'FOUND' } ]
+ },
+ {
+ order_by => { -desc => [ 'date', 'accountlines_id' ] }
+ }
+ );
+
+ return $self unless $accountlines->count > 0;
+
+ my $accountline = $accountlines->next;
+ my $total_to_refund = 0;
+
+ return $self unless $accountline->borrowernumber;
+
+ my $patron = Koha::Patrons->find( $accountline->borrowernumber );
+ return $self
+ unless $patron; # Patron has been deleted, nobody to credit the return to
+ # FIXME Should not we notify this somewhere
+
+ my $account = $patron->account;
+
+ # Use cases
+ if ( $accountline->amount > $accountline->amountoutstanding ) {
+
+ # some amount has been cancelled. collect the offsets that are not writeoffs
+ # this works because the only way to subtract from this kind of a debt is
+ # using the UI buttons 'Pay' and 'Write off'
+ my $credits_offsets = Koha::Account::Offsets->search(
+ {
+ debit_id => $accountline->id,
+ credit_id => { '!=' => undef }, # it is not the debit itself
+ type => { '!=' => 'Writeoff' },
+ amount => { '<' => 0 } # credits are negative on the DB
+ }
+ );
+
+ $total_to_refund = ( $credits_offsets->count > 0 )
+ ? $credits_offsets->total * -1 # credits are negative on the DB
+ : 0;
+ }
+
+ my $credit_total = $accountline->amountoutstanding + $total_to_refund;
+
+ my $credit;
+ if ( $credit_total > 0 ) {
+ my $branchcode =
+ C4::Context->userenv ? C4::Context->userenv->{'branch'} : undef;
+ $credit = $account->add_credit(
+ {
+ amount => $credit_total,
+ description => 'Item found ' . $self->itemnumber,
+ type => 'LOST_FOUND',
+ interface => C4::Context->interface,
+ library_id => $branchcode,
+ item_id => $self->itemnumber,
+ issue_id => $accountline->issue_id
+ }
+ );
+
+ $credit->apply( { debits => [$accountline] } );
+ $self->{_refunded} = 1;
+ }
+
+ # Update the account status
+ $accountline->status('FOUND');
+ $accountline->store();
+
+ if ( defined $account and C4::Context->preference('AccountAutoReconcile') ) {
+ $account->reconcile_balance;
+ }
+
+ return $self;
+}
+
=head3 to_api_mapping
This method returns the mapping for representing a Koha::Item object
};
}
+=head3 itemtype
+
+ my $itemtype = $item->itemtype;
+
+ Returns Koha object for effective itemtype
+
+=cut
+
+sub itemtype {
+ my ( $self ) = @_;
+ return Koha::ItemTypes->find( $self->effective_itemtype );
+}
+
=head2 Internal methods
+=head3 _after_item_action_hooks
+
+Helper method that takes care of calling all plugin hooks
+
+=cut
+
+sub _after_item_action_hooks {
+ my ( $self, $params ) = @_;
+
+ my $action = $params->{action};
+
+ Koha::Plugins->call(
+ 'after_item_action',
+ {
+ action => $action,
+ item => $self,
+ item_id => $self->itemnumber,
+ }
+ );
+}
+
=head3 _type
=cut
projects / koha-equinox.git / blobdiff