use strict;
#use warnings; FIXME - Bug 2505
use DateTime;
+use POSIX qw( floor );
use Koha::DateUtils;
use C4::Context;
use C4::Stats;
use Koha::Patron::Debarments;
use Koha::Database;
use Koha::Libraries;
+use Koha::Account::Lines;
use Koha::Holds;
use Koha::RefundLostItemFeeRule;
use Koha::RefundLostItemFeeRules;
use Koha::Account::Lines;
use Koha::Account::Offsets;
+use Koha::Config::SysPrefs;
use Carp;
-use List::MoreUtils qw( uniq );
+use List::MoreUtils qw( uniq any );
use Scalar::Util qw( looks_like_number );
use Date::Calc qw(
Today
# given branch, patron category, and item type, determine
# applicable issuing rule
- my $issuing_rule = Koha::IssuingRules->get_effective_issuing_rule(
- { categorycode => $cat_borrower,
+ my $maxissueqty_rule = Koha::CirculationRules->get_effective_rule(
+ {
+ categorycode => $cat_borrower,
itemtype => $type,
- branchcode => $branch
+ branchcode => $branch,
+ rule_name => 'maxissueqty',
+ }
+ );
+ my $maxonsiteissueqty_rule = Koha::CirculationRules->get_effective_rule(
+ {
+ categorycode => $cat_borrower,
+ itemtype => $type,
+ branchcode => $branch,
+ rule_name => 'maxonsiteissueqty',
}
);
# if a rule is found and has a loan limit set, count
# how many loans the patron already has that meet that
# rule
- if (defined($issuing_rule) and defined($issuing_rule->maxissueqty)) {
+ if (defined($maxissueqty_rule) and defined($maxissueqty_rule->rule_value)) {
my @bind_params;
my $count_query = q|
SELECT COUNT(*) AS total, COALESCE(SUM(onsite_checkout), 0) AS onsite_checkouts
JOIN items USING (itemnumber)
|;
- my $rule_itemtype = $issuing_rule->itemtype;
+ my $rule_itemtype = $maxissueqty_rule->itemtype;
if ($rule_itemtype eq "*") {
# matching rule has the default item type, so count only
# those existing loans that don't fall under a more
AND itemtype <> '*'
) ";
}
- push @bind_params, $issuing_rule->branchcode;
- push @bind_params, $issuing_rule->categorycode;
+ push @bind_params, $maxissueqty_rule->branchcode;
+ push @bind_params, $maxissueqty_rule->categorycode;
push @bind_params, $cat_borrower;
} else {
# rule has specific item type, so count loans of that
$count_query .= " AND borrowernumber = ? ";
push @bind_params, $borrower->{'borrowernumber'};
- my $rule_branch = $issuing_rule->branchcode;
+ my $rule_branch = $maxissueqty_rule->branchcode;
if ($rule_branch ne "*") {
if (C4::Context->preference('CircControl') eq 'PickupLibrary') {
$count_query .= " AND issues.branchcode = ? ";
my ( $checkout_count, $onsite_checkout_count ) = $dbh->selectrow_array( $count_query, {}, @bind_params );
- my $max_checkouts_allowed = $issuing_rule->maxissueqty;
- my $max_onsite_checkouts_allowed = $issuing_rule->maxonsiteissueqty;
+ my $max_checkouts_allowed = $maxissueqty_rule ? $maxissueqty_rule->rule_value : 0;
+ my $max_onsite_checkouts_allowed = $maxonsiteissueqty_rule ? $maxonsiteissueqty_rule->rule_value : 0;
if ( $onsite_checkout and defined $max_onsite_checkouts_allowed ) {
if ( $onsite_checkout_count >= $max_onsite_checkouts_allowed ) {
}
}
- if ( not defined( $issuing_rule ) and not defined($branch_borrower_circ_rule->{maxissueqty}) ) {
+ if ( not defined( $maxissueqty_rule ) and not defined($branch_borrower_circ_rule->{maxissueqty}) ) {
return { reason => 'NO_RULE_DEFINED', max_allowed => 0 };
}
my $onsite_checkout = $params->{onsite_checkout} || 0;
my $override_high_holds = $params->{override_high_holds} || 0;
- my $item = GetItem(undef, $barcode );
- my $issue = Koha::Checkouts->find( { itemnumber => $item->{itemnumber} } );
- my $biblioitem = GetBiblioItemData($item->{biblioitemnumber});
- $item->{'itemtype'}=$item->{'itype'};
- my $dbh = C4::Context->dbh;
- my $patron_unblessed = $patron->unblessed;
-
+ my $item = Koha::Items->find({barcode => $barcode });
# MANDATORY CHECKS - unless item exists, nothing else matters
- unless ( $item->{barcode} ) {
+ unless ( $item ) {
$issuingimpossible{UNKNOWN_BARCODE} = 1;
}
- return ( \%issuingimpossible, \%needsconfirmation ) if %issuingimpossible;
+ return ( \%issuingimpossible, \%needsconfirmation ) if %issuingimpossible;
+
+ my $item_unblessed = $item->unblessed; # Transition...
+ my $issue = $item->checkout;
+ my $biblio = $item->biblio;
+ my $biblioitem = $biblio->biblioitem;
+ my $effective_itemtype = $item->effective_itemtype;
+ my $dbh = C4::Context->dbh;
+ my $patron_unblessed = $patron->unblessed;
#
# DUE DATE is OK ? -- should already have checked.
unless ( $duedate ) {
my $issuedate = $now->clone();
- my $branch = _GetCircControlBranch($item, $patron_unblessed);
- my $itype = ( C4::Context->preference('item-level_itypes') ) ? $item->{'itype'} : $biblioitem->{'itemtype'};
- $duedate = CalcDateDue( $issuedate, $itype, $branch, $patron_unblessed );
+ my $branch = _GetCircControlBranch($item_unblessed, $patron_unblessed);
+ $duedate = CalcDateDue( $issuedate, $effective_itemtype, $branch, $patron_unblessed );
# Offline circ calls AddIssue directly, doesn't run through here
# So issuingimpossible should be ok.
#
# BORROWER STATUS
#
- if ( $patron->category->category_type eq 'X' && ( $item->{barcode} )) {
+ if ( $patron->category->category_type eq 'X' && ( $item->barcode )) {
# stats only borrower -- add entry to statistics table, and return issuingimpossible{STATS} = 1 .
&UpdateStats({
branch => C4::Context->userenv->{'branch'},
type => 'localuse',
- itemnumber => $item->{'itemnumber'},
- itemtype => $item->{'itype'},
+ itemnumber => $item->itemnumber,
+ itemtype => $effective_itemtype,
borrowernumber => $patron->borrowernumber,
- ccode => $item->{'ccode'}}
+ ccode => $item->ccode}
);
- ModDateLastSeen( $item->{'itemnumber'} );
+ ModDateLastSeen( $item->itemnumber ); # FIXME Move to Koha::Item
return( { STATS => 1 }, {});
}
- my $flags = C4::Members::patronflags( $patron_unblessed );
- if ( ref $flags ) {
- if ( $flags->{GNA} ) {
- $issuingimpossible{GNA} = 1;
- }
- if ( $flags->{'LOST'} ) {
- $issuingimpossible{CARD_LOST} = 1;
- }
- if ( $flags->{'DBARRED'} ) {
- $issuingimpossible{DEBARRED} = 1;
- }
+ if ( $patron->gonenoaddress == 1 ) {
+ $issuingimpossible{GNA} = 1;
+ }
+
+ if ( $patron->lost == 1 ) {
+ $issuingimpossible{CARD_LOST} = 1;
+ }
+ if ( $patron->is_debarred ) {
+ $issuingimpossible{DEBARRED} = 1;
}
if ( $patron->is_expired ) {
if ( C4::Context->preference("IssuingInProcess") ) {
if ( $non_issues_charges > $amountlimit && !$inprocess && !$allowfineoverride) {
- $issuingimpossible{DEBT} = sprintf( "%.2f", $non_issues_charges );
+ $issuingimpossible{DEBT} = $non_issues_charges;
} elsif ( $non_issues_charges > $amountlimit && !$inprocess && $allowfineoverride) {
- $needsconfirmation{DEBT} = sprintf( "%.2f", $non_issues_charges );
+ $needsconfirmation{DEBT} = $non_issues_charges;
} elsif ( $allfinesneedoverride && $non_issues_charges > 0 && $non_issues_charges <= $amountlimit && !$inprocess ) {
- $needsconfirmation{DEBT} = sprintf( "%.2f", $non_issues_charges );
+ $needsconfirmation{DEBT} = $non_issues_charges;
}
}
else {
if ( $non_issues_charges > $amountlimit && $allowfineoverride ) {
- $needsconfirmation{DEBT} = sprintf( "%.2f", $non_issues_charges );
+ $needsconfirmation{DEBT} = $non_issues_charges;
} elsif ( $non_issues_charges > $amountlimit && !$allowfineoverride) {
- $issuingimpossible{DEBT} = sprintf( "%.2f", $non_issues_charges );
+ $issuingimpossible{DEBT} = $non_issues_charges;
} elsif ( $non_issues_charges > 0 && $allfinesneedoverride ) {
- $needsconfirmation{DEBT} = sprintf( "%.2f", $non_issues_charges );
+ $needsconfirmation{DEBT} = $non_issues_charges;
}
}
} else {
my ($CanBookBeRenewed,$renewerror) = CanBookBeRenewed(
$patron->borrowernumber,
- $item->{'itemnumber'},
+ $item->itemnumber,
);
if ( $CanBookBeRenewed == 0 ) { # no more renewals allowed
if ( $renewerror eq 'onsite_checkout' ) {
my $patron = Koha::Patrons->find( $issue->borrowernumber );
- my ( $can_be_returned, $message ) = CanBookBeReturned( $item, C4::Context->userenv->{branch} );
+ my ( $can_be_returned, $message ) = CanBookBeReturned( $item_unblessed, C4::Context->userenv->{branch} );
unless ( $can_be_returned ) {
$issuingimpossible{RETURN_IMPOSSIBLE} = 1;
and $issue
and $issue->onsite_checkout
and $issue->borrowernumber == $patron->borrowernumber ? 1 : 0 );
- my $toomany = TooMany( $patron_unblessed, $item->{biblionumber}, $item, { onsite_checkout => $onsite_checkout, switch_onsite_checkout => $switch_onsite_checkout, } );
+ my $toomany = TooMany( $patron_unblessed, $item->biblionumber, $item_unblessed, { onsite_checkout => $onsite_checkout, switch_onsite_checkout => $switch_onsite_checkout, } );
# if TooMany max_allowed returns 0 the user doesn't have permission to check out this book
if ( $toomany && not exists $needsconfirmation{RENEW_ISSUE} ) {
if ( $toomany->{max_allowed} == 0 ) {
$patron = Koha::Patrons->find( $patron->borrowernumber ); # FIXME Refetch just in case, to avoid regressions. But must not be needed
my $wants_check = $patron->wants_check_for_previous_checkout;
$needsconfirmation{PREVISSUE} = 1
- if ($wants_check and $patron->do_check_for_previous_checkout($item));
+ if ($wants_check and $patron->do_check_for_previous_checkout($item_unblessed));
#
# ITEM CHECKING
#
- if ( $item->{'notforloan'} )
+ if ( $item->notforloan )
{
if(!C4::Context->preference("AllowNotForLoanOverride")){
$issuingimpossible{NOT_FOR_LOAN} = 1;
- $issuingimpossible{item_notforloan} = $item->{'notforloan'};
+ $issuingimpossible{item_notforloan} = $item->notforloan;
}else{
$needsconfirmation{NOT_FOR_LOAN_FORCING} = 1;
- $needsconfirmation{item_notforloan} = $item->{'notforloan'};
+ $needsconfirmation{item_notforloan} = $item->notforloan;
}
}
else {
if (C4::Context->preference('item-level_itypes')){
# this should probably be a subroutine
my $sth = $dbh->prepare("SELECT notforloan FROM itemtypes WHERE itemtype = ?");
- $sth->execute($item->{'itemtype'});
+ $sth->execute($effective_itemtype);
my $notforloan=$sth->fetchrow_hashref();
if ($notforloan->{'notforloan'}) {
if (!C4::Context->preference("AllowNotForLoanOverride")) {
$issuingimpossible{NOT_FOR_LOAN} = 1;
- $issuingimpossible{itemtype_notforloan} = $item->{'itype'};
+ $issuingimpossible{itemtype_notforloan} = $effective_itemtype;
} else {
$needsconfirmation{NOT_FOR_LOAN_FORCING} = 1;
- $needsconfirmation{itemtype_notforloan} = $item->{'itype'};
+ $needsconfirmation{itemtype_notforloan} = $effective_itemtype;
}
}
}
- elsif ($biblioitem->{'notforloan'} == 1){
- if (!C4::Context->preference("AllowNotForLoanOverride")) {
- $issuingimpossible{NOT_FOR_LOAN} = 1;
- $issuingimpossible{itemtype_notforloan} = $biblioitem->{'itemtype'};
- } else {
- $needsconfirmation{NOT_FOR_LOAN_FORCING} = 1;
- $needsconfirmation{itemtype_notforloan} = $biblioitem->{'itemtype'};
+ else {
+ my $itemtype = Koha::ItemTypes->find($biblioitem->itemtype);
+ if ( $itemtype and $itemtype->notforloan == 1){
+ if (!C4::Context->preference("AllowNotForLoanOverride")) {
+ $issuingimpossible{NOT_FOR_LOAN} = 1;
+ $issuingimpossible{itemtype_notforloan} = $effective_itemtype;
+ } else {
+ $needsconfirmation{NOT_FOR_LOAN_FORCING} = 1;
+ $needsconfirmation{itemtype_notforloan} = $effective_itemtype;
+ }
}
}
}
- if ( $item->{'withdrawn'} && $item->{'withdrawn'} > 0 )
+ if ( $item->withdrawn && $item->withdrawn > 0 )
{
$issuingimpossible{WTHDRAWN} = 1;
}
- if ( $item->{'restricted'}
- && $item->{'restricted'} == 1 )
+ if ( $item->restricted
+ && $item->restricted == 1 )
{
$issuingimpossible{RESTRICTED} = 1;
}
- if ( $item->{'itemlost'} && C4::Context->preference("IssueLostItem") ne 'nothing' ) {
- my $av = Koha::AuthorisedValues->search({ category => 'LOST', authorised_value => $item->{itemlost} });
+ if ( $item->itemlost && C4::Context->preference("IssueLostItem") ne 'nothing' ) {
+ my $av = Koha::AuthorisedValues->search({ category => 'LOST', authorised_value => $item->itemlost });
my $code = $av->count ? $av->next->lib : '';
$needsconfirmation{ITEM_LOST} = $code if ( C4::Context->preference("IssueLostItem") eq 'confirm' );
$alerts{ITEM_LOST} = $code if ( C4::Context->preference("IssueLostItem") eq 'alert' );
if ( C4::Context->preference("IndependentBranches") ) {
my $userenv = C4::Context->userenv;
unless ( C4::Context->IsSuperLibrarian() ) {
- if ( $item->{C4::Context->preference("HomeOrHoldingBranch")} ne $userenv->{branch} ){
+ my $HomeOrHoldingBranch = C4::Context->preference("HomeOrHoldingBranch");
+ if ( $item->$HomeOrHoldingBranch ne $userenv->{branch} ){
$issuingimpossible{ITEMNOTSAMEBRANCH} = 1;
- $issuingimpossible{'itemhomebranch'} = $item->{C4::Context->preference("HomeOrHoldingBranch")};
+ $issuingimpossible{'itemhomebranch'} = $item->$HomeOrHoldingBranch;
}
$needsconfirmation{BORRNOTSAMEBRANCH} = $patron->branchcode
if ( $patron->branchcode ne $userenv->{branch} );
my $rentalConfirmation = C4::Context->preference("RentalFeesCheckoutConfirmation");
if ( $rentalConfirmation ){
- my ($rentalCharge) = GetIssuingCharges( $item->{'itemnumber'}, $patron->borrowernumber );
+ my ($rentalCharge) = GetIssuingCharges( $item->itemnumber, $patron->borrowernumber );
if ( $rentalCharge > 0 ){
$needsconfirmation{RENTALCHARGE} = $rentalCharge;
}
unless ( $ignore_reserves ) {
# See if the item is on reserve.
- my ( $restype, $res ) = C4::Reserves::CheckReserves( $item->{'itemnumber'} );
+ my ( $restype, $res ) = C4::Reserves::CheckReserves( $item->itemnumber );
if ($restype) {
my $resbor = $res->{'borrowernumber'};
if ( $resbor ne $patron->borrowernumber ) {
}
## CHECK AGE RESTRICTION
- my $agerestriction = $biblioitem->{'agerestriction'};
+ my $agerestriction = $biblioitem->agerestriction;
my ($restriction_age, $daysToAgeRestriction) = GetAgeRestriction( $agerestriction, $patron->unblessed );
if ( $daysToAgeRestriction && $daysToAgeRestriction > 0 ) {
if ( C4::Context->preference('AgeRestrictionOverride') ) {
## check for high holds decreasing loan period
if ( C4::Context->preference('decreaseLoanHighHolds') ) {
- my $check = checkHighHolds( $item, $patron_unblessed );
+ my $check = checkHighHolds( $item_unblessed, $patron_unblessed );
if ( $check->{exceeded} ) {
if ($override_high_holds) {
$alerts{HIGHHOLDS} = {
num_holds => $check->{outstanding},
duration => $check->{duration},
- returndate => output_pref( $check->{due_date} ),
+ returndate => output_pref( { dt => dt_from_string($check->{due_date}), dateformat => 'iso', timeformat => '24hr' }),
};
}
else {
$needsconfirmation{HIGHHOLDS} = {
num_holds => $check->{outstanding},
duration => $check->{duration},
- returndate => output_pref( $check->{due_date} ),
+ returndate => output_pref( { dt => dt_from_string($check->{due_date}), dateformat => 'iso', timeformat => '24hr' }),
};
}
}
) {
# Check if borrower has already issued an item from the same biblio
# Only if it's not a subscription
- my $biblionumber = $item->{biblionumber};
+ my $biblionumber = $item->biblionumber;
require C4::Serials;
my $is_a_subscription = C4::Serials::CountSubscriptionFromBiblionumber($biblionumber);
unless ($is_a_subscription) {
=over 4
-=item C<$item> is a hash of item information as returned from GetItem
+=item C<$item> is a hash of item information as returned Koha::Items->find->unblessed (Temporary, should be a Koha::Item instead)
=item C<$branch> is the branchcode where the return is taking place
}
# Remove any items that are not holdable for this patron
- @items = grep { CanItemBeReserved( $borrower->{borrowernumber}, $_->itemnumber ) eq 'OK' } @items;
+ @items = grep { CanItemBeReserved( $borrower->{borrowernumber}, $_->itemnumber )->{status} eq 'OK' } @items;
my $items_count = scalar @items;
# Stop here if the patron or barcode doesn't exist
if ( $borrower && $barcode && $barcodecheck ) {
# find which item we issue
- my $item = GetItem( '', $barcode )
+ my $item = Koha::Items->find({ barcode => $barcode })
or return; # if we don't get an Item, abort.
- my $item_object = Koha::Items->find( { barcode => $barcode } );
+ my $item_unblessed = $item->unblessed;
- my $branch = _GetCircControlBranch( $item, $borrower );
+ my $branch = _GetCircControlBranch( $item_unblessed, $borrower );
# get actual issuing if there is one
- my $actualissue = Koha::Checkouts->find( { itemnumber => $item->{itemnumber} } );
+ my $actualissue = $item->checkout;
# check if we just renew the issue.
if ( $actualissue and $actualissue->borrowernumber eq $borrower->{'borrowernumber'}
and not $switch_onsite_checkout ) {
$datedue = AddRenewal(
$borrower->{'borrowernumber'},
- $item->{'itemnumber'},
+ $item->itemnumber,
$branch,
$datedue,
$issuedate, # here interpreted as the renewal date
if ( $actualissue and not $switch_onsite_checkout ) {
# This book is currently on loan, but not to the person
# who wants to borrow it now. mark it returned before issuing to the new borrower
- my ( $allowed, $message ) = CanBookBeReturned( $item, C4::Context->userenv->{branch} );
+ my ( $allowed, $message ) = CanBookBeReturned( $item_unblessed, C4::Context->userenv->{branch} );
return unless $allowed;
- AddReturn( $item->{'barcode'}, C4::Context->userenv->{'branch'} );
+ AddReturn( $item->barcode, C4::Context->userenv->{'branch'} );
}
- MoveReserve( $item->{'itemnumber'}, $borrower->{'borrowernumber'}, $cancelreserve );
+ C4::Reserves::MoveReserve( $item->itemnumber, $borrower->{'borrowernumber'}, $cancelreserve );
# Starting process for transfer job (checking transfert and validate it if we have one)
- my ($datesent) = GetTransfers( $item->{'itemnumber'} );
+ my ($datesent) = GetTransfers( $item->itemnumber );
if ($datesent) {
# updating line of branchtranfert to finish it, and changing the to branch value, implement a comment for visibility of this case (maybe for stats ....)
my $sth = $dbh->prepare(
WHERE itemnumber= ? AND datearrived IS NULL"
);
$sth->execute( C4::Context->userenv->{'branch'},
- $item->{'itemnumber'} );
+ $item->itemnumber );
}
# If automatic renewal wasn't selected while issuing, set the value according to the issuing rule.
unless ($auto_renew) {
my $issuing_rule = Koha::IssuingRules->get_effective_issuing_rule(
{ categorycode => $borrower->{categorycode},
- itemtype => $item->{itype},
+ itemtype => $item->effective_itemtype,
branchcode => $branch
}
);
# Record in the database the fact that the book was issued.
unless ($datedue) {
- my $itype = $item_object->effective_itemtype;
+ my $itype = $item->effective_itemtype;
$datedue = CalcDateDue( $issuedate, $itype, $branch, $borrower );
}
$datedue->truncate( to => 'minute' );
- $issue = Koha::Database->new()->schema()->resultset('Issue')->update_or_create(
- {
- borrowernumber => $borrower->{'borrowernumber'},
- itemnumber => $item->{'itemnumber'},
- issuedate => $issuedate->strftime('%Y-%m-%d %H:%M:%S'),
- date_due => $datedue->strftime('%Y-%m-%d %H:%M:%S'),
- branchcode => C4::Context->userenv->{'branch'},
- onsite_checkout => $onsite_checkout,
- auto_renew => $auto_renew ? 1 : 0
- }
- );
+ my $issue_attributes = {
+ borrowernumber => $borrower->{'borrowernumber'},
+ issuedate => $issuedate->strftime('%Y-%m-%d %H:%M:%S'),
+ date_due => $datedue->strftime('%Y-%m-%d %H:%M:%S'),
+ branchcode => C4::Context->userenv->{'branch'},
+ onsite_checkout => $onsite_checkout,
+ auto_renew => $auto_renew ? 1 : 0,
+ };
+
+ $issue = Koha::Checkouts->find( { itemnumber => $item->itemnumber } );
+ if ($issue) {
+ $issue->set($issue_attributes)->store;
+ }
+ else {
+ $issue = Koha::Checkout->new(
+ {
+ itemnumber => $item->itemnumber,
+ %$issue_attributes,
+ }
+ )->store;
+ }
if ( C4::Context->preference('ReturnToShelvingCart') ) {
# ReturnToShelvingCart is on, anything issued should be taken off the cart.
- CartToShelf( $item->{'itemnumber'} );
+ CartToShelf( $item->itemnumber );
}
- $item->{'issues'}++;
+
if ( C4::Context->preference('UpdateTotalIssuesOnCirc') ) {
- UpdateTotalIssues( $item->{'biblionumber'}, 1 );
+ UpdateTotalIssues( $item->biblionumber, 1 );
}
## If item was lost, it has now been found, reverse any list item charges if necessary.
- if ( $item->{'itemlost'} ) {
+ if ( $item->itemlost ) {
if (
Koha::RefundLostItemFeeRules->should_refund(
{
current_branch => C4::Context->userenv->{branch},
- item_home_branch => $item->{homebranch},
- item_holding_branch => $item->{holdingbranch}
+ item_home_branch => $item->homebranch,
+ item_holding_branch => $item->holdingbranch,
}
)
)
{
- _FixAccountForLostAndReturned( $item->{'itemnumber'}, undef,
- $item->{'barcode'} );
+ _FixAccountForLostAndReturned( $item->itemnumber, undef,
+ $item->barcode );
}
}
ModItem(
{
- issues => $item->{'issues'},
+ issues => $item->issues + 1,
holdingbranch => C4::Context->userenv->{'branch'},
itemlost => 0,
onloan => $datedue->ymd(),
datelastborrowed => DateTime->now( time_zone => C4::Context->tz() )->ymd(),
},
- $item->{'biblionumber'},
- $item->{'itemnumber'}
+ $item->biblionumber,
+ $item->itemnumber,
+ { log_action => 0 }
);
- ModDateLastSeen( $item->{'itemnumber'} );
+ ModDateLastSeen( $item->itemnumber );
# If it costs to borrow this book, charge it to the patron's account.
- my ( $charge, $itemtype ) = GetIssuingCharges( $item->{'itemnumber'}, $borrower->{'borrowernumber'} );
+ my ( $charge, $itemtype ) = GetIssuingCharges( $item->itemnumber, $borrower->{'borrowernumber'} );
if ( $charge > 0 ) {
- AddIssuingCharge( $item->{'itemnumber'}, $borrower->{'borrowernumber'}, $charge );
- $item->{'charge'} = $charge;
+ AddIssuingCharge( $issue, $charge );
}
# Record the fact that this book was issued.
type => ( $onsite_checkout ? 'onsite_checkout' : 'issue' ),
amount => $charge,
other => ( $sipmode ? "SIP-$sipmode" : '' ),
- itemnumber => $item->{'itemnumber'},
- itemtype => $item->{'itype'},
- location => $item->{location},
+ itemnumber => $item->itemnumber,
+ itemtype => $item->effective_itemtype,
+ location => $item->location,
borrowernumber => $borrower->{'borrowernumber'},
- ccode => $item->{'ccode'}
+ ccode => $item->ccode,
}
);
my %conditions = (
branchcode => $branch,
categorycode => $borrower->{categorycode},
- item_type => $item->{itype},
+ item_type => $item->effective_itemtype,
notification => 'CHECKOUT',
);
if ( $circulation_alert->is_enabled_for( \%conditions ) ) {
SendCirculationAlert(
{
type => 'CHECKOUT',
- item => $item,
+ item => $item->unblessed,
borrower => $borrower,
branch => $branch,
}
logaction(
"CIRCULATION", "ISSUE",
$borrower->{'borrowernumber'},
- $item->{'itemnumber'}
+ $item->itemnumber,
) if C4::Context->preference("IssueLog");
}
}
patron of the given category can have at the given
branch. If the value is undef, no limit.
-This will first check for a specific branch and
-category match from branch_borrower_circ_rules.
-
-If no rule is found, it will then check default_branch_circ_rules
-(same branch, default category). If no rule is found,
-it will then check default_borrower_circ_rules (default
-branch, same category), then failing that, default_circ_rules
-(default branch, default category).
+This will check for different branch/category combinations in the following order:
+branch and category
+branch only
+category only
+default branch and category
If no rule has been found in the database, it will default to
the buillt in rule:
sub GetBranchBorrowerCircRule {
my ( $branchcode, $categorycode ) = @_;
- my $rules;
- my $dbh = C4::Context->dbh();
- $rules = $dbh->selectrow_hashref( q|
- SELECT maxissueqty, maxonsiteissueqty
- FROM branch_borrower_circ_rules
- WHERE branchcode = ?
- AND categorycode = ?
- |, {}, $branchcode, $categorycode ) ;
- return $rules if $rules;
-
- # try same branch, default borrower category
- $rules = $dbh->selectrow_hashref( q|
- SELECT maxissueqty, maxonsiteissueqty
- FROM default_branch_circ_rules
- WHERE branchcode = ?
- |, {}, $branchcode ) ;
- return $rules if $rules;
-
- # try default branch, same borrower category
- $rules = $dbh->selectrow_hashref( q|
- SELECT maxissueqty, maxonsiteissueqty
- FROM default_borrower_circ_rules
- WHERE categorycode = ?
- |, {}, $categorycode ) ;
- return $rules if $rules;
-
- # try default branch, default borrower category
- $rules = $dbh->selectrow_hashref( q|
- SELECT maxissueqty, maxonsiteissueqty
- FROM default_circ_rules
- |, {} );
- return $rules if $rules;
+ # Set search prededences
+ my @params = (
+ {
+ branchcode => $branchcode,
+ categorycode => $categorycode,
+ itemtype => undef,
+ },
+ {
+ branchcode => $branchcode,
+ categorycode => undef,
+ itemtype => undef,
+ },
+ {
+ branchcode => undef,
+ categorycode => $categorycode,
+ itemtype => undef,
+ },
+ {
+ branchcode => undef,
+ categorycode => undef,
+ itemtype => undef,
+ },
+ );
- # built-in default circulation rule
- return {
- maxissueqty => undef,
+ # Initialize default values
+ my $rules = {
+ maxissueqty => undef,
maxonsiteissueqty => undef,
};
+
+ # Search for rules!
+ foreach my $rule_name (qw( maxissueqty maxonsiteissueqty )) {
+ foreach my $params (@params) {
+ my $rule = Koha::CirculationRules->search(
+ {
+ rule_name => $rule_name,
+ %$params,
+ }
+ )->next();
+
+ if ( $rule ) {
+ $rules->{$rule_name} = $rule->rule_value;
+ last;
+ }
+ }
+ }
+
+ return $rules;
}
=head2 GetBranchItemRule
my $stat_type = 'return';
# get information on item
- my $item = GetItem( undef, $barcode );
+ my $item = Koha::Items->find({ barcode => $barcode });
unless ($item) {
return ( 0, { BadBarcode => $barcode } ); # no barcode means no item or borrower. bail out.
}
- my $itemnumber = $item->{ itemnumber };
- my $itemtype = $item->{itype}; # GetItem called effective_itemtype
+ my $itemnumber = $item->itemnumber;
+ my $itemtype = $item->effective_itemtype;
- my $issue = Koha::Checkouts->find( { itemnumber => $itemnumber } );
+ my $issue = $item->checkout;
if ( $issue ) {
- $patron = Koha::Patrons->find( $issue->borrowernumber )
+ $patron = $issue->patron
or die "Data inconsistency: barcode $barcode (itemnumber:$itemnumber) claims to be issued to non-existent borrowernumber '" . $issue->borrowernumber . "'\n"
. Dumper($issue->unblessed) . "\n";
} else {
$messages->{'NotIssued'} = $barcode;
+ ModItem({ onloan => undef }, $item->biblionumber, $item->itemnumber) if defined $item->onloan;
# even though item is not on loan, it may still be transferred; therefore, get current branch info
$doreturn = 0;
# No issue, no borrowernumber. ONLY if $doreturn, *might* you have a $borrower later.
}
}
- if ( $item->{'location'} eq 'PROC' ) {
+ my $item_unblessed = $item->unblessed;
+ if ( $item->location eq 'PROC' ) {
if ( C4::Context->preference("InProcessingToShelvingCart") ) {
- $item->{'location'} = 'CART';
+ $item_unblessed->{location} = 'CART';
}
else {
- $item->{location} = $item->{permanent_location};
+ $item_unblessed->{location} = $item->permanent_location;
}
- ModItem( $item, $item->{'biblionumber'}, $item->{'itemnumber'} );
+ ModItem( $item_unblessed, $item->biblionumber, $item->itemnumber, { log_action => 0 } );
}
# full item data, but no borrowernumber or checkout info (no issue)
- my $hbr = GetBranchItemRule($item->{'homebranch'}, $item->{'itype'})->{'returnbranch'} || "homebranch";
+ my $hbr = GetBranchItemRule($item->homebranch, $itemtype)->{'returnbranch'} || "homebranch";
# get the proper branch to which to return the item
- my $returnbranch = $item->{$hbr} || $branch ;
+ my $returnbranch = $hbr ne 'noreturn' ? $item->$hbr : $branch;
# if $hbr was "noreturn" or any other non-item table value, then it should 'float' (i.e. stay at this branch)
my $borrowernumber = $patron ? $patron->borrowernumber : undef; # we don't know if we had a borrower or not
}
else {
foreach my $key ( keys %$rules ) {
- if ( $item->{notforloan} eq $key ) {
- $messages->{'NotForLoanStatusUpdated'} = { from => $item->{notforloan}, to => $rules->{$key} };
- ModItem( { notforloan => $rules->{$key} }, undef, $itemnumber );
+ if ( $item->notforloan eq $key ) {
+ $messages->{'NotForLoanStatusUpdated'} = { from => $item->notforloan, to => $rules->{$key} };
+ ModItem( { notforloan => $rules->{$key} }, undef, $itemnumber, { log_action => 0 } );
last;
}
}
}
# check if the return is allowed at this branch
- my ($returnallowed, $message) = CanBookBeReturned($item, $branch);
+ my ($returnallowed, $message) = CanBookBeReturned($item_unblessed, $branch);
unless ($returnallowed){
$messages->{'Wrongbranch'} = {
Wrongbranch => $branch,
return ( $doreturn, $messages, $issue, $patron_unblessed);
}
- if ( $item->{'withdrawn'} ) { # book has been cancelled
+ if ( $item->withdrawn ) { # book has been cancelled
$messages->{'withdrawn'} = 1;
$doreturn = 0 if C4::Context->preference("BlockReturnOfWithdrawnItems");
}
- if ( $item->{itemlost} and C4::Context->preference("BlockReturnOfLostItems") ) {
+ if ( $item->itemlost and C4::Context->preference("BlockReturnOfLostItems") ) {
$doreturn = 0;
}
my $is_overdue;
die "The item is not issed and cannot be returned" unless $issue; # Just in case...
$patron or warn "AddReturn without current borrower";
- my $circControlBranch;
if ($dropbox) {
- # define circControlBranch only if dropbox mode is set
- # don't allow dropbox mode to create an invalid entry in issues (issuedate > today)
- # FIXME: check issuedate > returndate, factoring in holidays
-
- $circControlBranch = _GetCircControlBranch($item,$patron_unblessed);
$is_overdue = $issue->is_overdue( $dropboxdate );
} else {
$is_overdue = $issue->is_overdue;
if ($patron) {
eval {
- MarkIssueReturned( $borrowernumber, $item->{'itemnumber'},
- $circControlBranch, $return_date, $patron->privacy );
+ if ( $dropbox ) {
+ MarkIssueReturned( $borrowernumber, $item->itemnumber,
+ $dropboxdate, $patron->privacy );
+ }
+ else {
+ MarkIssueReturned( $borrowernumber, $item->itemnumber,
+ $return_date, $patron->privacy );
+ }
};
unless ( $@ ) {
if ( ( C4::Context->preference('CalculateFinesOnReturn') && $is_overdue ) || $return_date ) {
- _CalculateAndUpdateFine( { issue => $issue, item => $item, borrower => $patron_unblessed, return_date => $return_date } );
+ _CalculateAndUpdateFine( { issue => $issue, item => $item_unblessed, borrower => $patron_unblessed, return_date => $return_date } );
}
} else {
carp "The checkin for the following issue failed, Please go to the about page, section 'data corrupted' to know how to fix this problem ($@)" . Dumper( $issue->unblessed );
}
- ModItem({ onloan => undef }, $item->{biblionumber}, $item->{'itemnumber'});
+ ModItem( { onloan => undef }, $item->biblionumber, $item->itemnumber, { log_action => 0 } );
}
# the holdingbranch is updated if the document is returned to another location.
# this is always done regardless of whether the item was on loan or not
- my $item_holding_branch = $item->{ holdingbranch };
- if ($item->{'holdingbranch'} ne $branch) {
- UpdateHoldingbranch($branch, $item->{'itemnumber'});
- $item->{'holdingbranch'} = $branch; # update item data holdingbranch too
+ my $item_holding_branch = $item->holdingbranch;
+ if ($item->holdingbranch ne $branch) {
+ UpdateHoldingbranch($branch, $item->itemnumber);
+ $item_unblessed->{'holdingbranch'} = $branch; # update item data holdingbranch too # FIXME I guess this is for the _debar_user_on_return call later
}
- ModDateLastSeen( $item->{'itemnumber'} );
+
+ my $leave_item_lost = C4::Context->preference("BlockReturnOfLostItems") ? 1 : 0;
+ ModDateLastSeen( $item->itemnumber, $leave_item_lost );
# check if we have a transfer for this document
- my ($datesent,$frombranch,$tobranch) = GetTransfers( $item->{'itemnumber'} );
+ my ($datesent,$frombranch,$tobranch) = GetTransfers( $item->itemnumber );
# if we have a transfer to do, we update the line of transfers with the datearrived
- my $is_in_rotating_collection = C4::RotatingCollections::isItemInAnyCollection( $item->{'itemnumber'} );
+ my $is_in_rotating_collection = C4::RotatingCollections::isItemInAnyCollection( $item->itemnumber );
if ($datesent) {
if ( $tobranch eq $branch ) {
my $sth = C4::Context->dbh->prepare(
"UPDATE branchtransfers SET datearrived = now() WHERE itemnumber= ? AND datearrived IS NULL"
);
- $sth->execute( $item->{'itemnumber'} );
+ $sth->execute( $item->itemnumber );
# if we have a reservation with valid transfer, we can set it's status to 'W'
- ShelfToCart( $item->{'itemnumber'} ) if ( C4::Context->preference("ReturnToShelvingCart") );
- C4::Reserves::ModReserveStatus($item->{'itemnumber'}, 'W');
+ ShelfToCart( $item->itemnumber ) if ( C4::Context->preference("ReturnToShelvingCart") );
+ C4::Reserves::ModReserveStatus($item->itemnumber, 'W');
} else {
$messages->{'WrongTransfer'} = $tobranch;
- $messages->{'WrongTransferItem'} = $item->{'itemnumber'};
+ $messages->{'WrongTransferItem'} = $item->itemnumber;
}
$validTransfert = 1;
} else {
- ShelfToCart( $item->{'itemnumber'} ) if ( C4::Context->preference("ReturnToShelvingCart") );
+ ShelfToCart( $item->itemnumber ) if ( C4::Context->preference("ReturnToShelvingCart") );
}
# fix up the accounts.....
- if ( $item->{'itemlost'} ) {
+ if ( $item->itemlost ) {
$messages->{'WasLost'} = 1;
unless ( C4::Context->preference("BlockReturnOfLostItems") ) {
if (
Koha::RefundLostItemFeeRules->should_refund(
{
current_branch => C4::Context->userenv->{branch},
- item_home_branch => $item->{homebranch},
+ item_home_branch => $item->homebranch,
item_holding_branch => $item_holding_branch
}
)
)
{
- _FixAccountForLostAndReturned( $item->{'itemnumber'},
+ _FixAccountForLostAndReturned( $item->itemnumber,
$borrowernumber, $barcode );
$messages->{'LostItemFeeRefunded'} = 1;
}
# fix up the overdues in accounts...
if ($borrowernumber) {
- my $fix = _FixOverduesOnReturn($borrowernumber, $item->{itemnumber}, $exemptfine, $dropbox);
- defined($fix) or warn "_FixOverduesOnReturn($borrowernumber, $item->{itemnumber}...) failed!"; # zero is OK, check defined
+ my $fix = _FixOverduesOnReturn($borrowernumber, $item->itemnumber, $exemptfine, $dropbox);
+ defined($fix) or warn "_FixOverduesOnReturn($borrowernumber, $item->itemnumber...) failed!"; # zero is OK, check defined
if ( $issue and $issue->is_overdue ) {
# fix fine days
+ $today = dt_from_string($return_date) if $return_date;
$today = $dropboxdate if $dropbox;
- my ($debardate,$reminder) = _debar_user_on_return( $patron_unblessed, $item, dt_from_string($issue->date_due), $today );
+ my ($debardate,$reminder) = _debar_user_on_return( $patron_unblessed, $item_unblessed, dt_from_string($issue->date_due), $today );
if ($reminder){
$messages->{'PrevDebarred'} = $debardate;
} else {
# if we don't have a reserve with the status W, we launch the Checkreserves routine
my ($resfound, $resrec);
my $lookahead= C4::Context->preference('ConfirmFutureHolds'); #number of days to look for future holds
- ($resfound, $resrec, undef) = C4::Reserves::CheckReserves( $item->{'itemnumber'}, undef, $lookahead ) unless ( $item->{'withdrawn'} );
+ ($resfound, $resrec, undef) = C4::Reserves::CheckReserves( $item->itemnumber, undef, $lookahead ) unless ( $item->withdrawn );
if ($resfound) {
$resrec->{'ResFound'} = $resfound;
$messages->{'ResFound'} = $resrec;
itemnumber => $itemnumber,
itemtype => $itemtype,
borrowernumber => $borrowernumber,
- ccode => $item->{ ccode }
+ ccode => $item->ccode,
});
# Send a check-in slip. # NOTE: borrower may be undef. Do not try to send messages then.
my %conditions = (
branchcode => $branch,
categorycode => $patron->categorycode,
- item_type => $item->{itype},
+ item_type => $itemtype,
notification => 'CHECKIN',
);
if ($doreturn && $circulation_alert->is_enabled_for(\%conditions)) {
SendCirculationAlert({
type => 'CHECKIN',
- item => $item,
+ item => $item_unblessed,
borrower => $patron->unblessed,
branch => $branch,
});
}
- logaction("CIRCULATION", "RETURN", $borrowernumber, $item->{'itemnumber'})
+ logaction("CIRCULATION", "RETURN", $borrowernumber, $item->itemnumber)
if C4::Context->preference("ReturnLog");
}
# Transfer to returnbranch if Automatic transfer set or append message NeedsTransfer
if (!$is_in_rotating_collection && ($doreturn or $messages->{'NotIssued'}) and !$resfound and ($branch ne $returnbranch) and not $messages->{'WrongTransfer'}){
+ my $BranchTransferLimitsType = C4::Context->preference("BranchTransferLimitsType");
if (C4::Context->preference("AutomaticItemReturn" ) or
(C4::Context->preference("UseBranchTransferLimits") and
- ! IsBranchTransferAllowed($branch, $returnbranch, $item->{C4::Context->preference("BranchTransferLimitsType")} )
+ ! IsBranchTransferAllowed($branch, $returnbranch, $item->$BranchTransferLimitsType )
)) {
- $debug and warn sprintf "about to call ModItemTransfer(%s, %s, %s)", $item->{'itemnumber'},$branch, $returnbranch;
- $debug and warn "item: " . Dumper($item);
- ModItemTransfer($item->{'itemnumber'}, $branch, $returnbranch);
+ $debug and warn sprintf "about to call ModItemTransfer(%s, %s, %s)", $item->itemnumber,$branch, $returnbranch;
+ $debug and warn "item: " . Dumper($item_unblessed);
+ ModItemTransfer($item->itemnumber, $branch, $returnbranch);
$messages->{'WasTransfered'} = 1;
} else {
$messages->{'NeedsTransfer'} = $returnbranch;
=head2 MarkIssueReturned
- MarkIssueReturned($borrowernumber, $itemnumber, $dropbox_branch, $returndate, $privacy);
+ MarkIssueReturned($borrowernumber, $itemnumber, $returndate, $privacy);
Unconditionally marks an issue as being returned by
moving the C<issues> row to C<old_issues> and
-setting C<returndate> to the current date, or
-the last non-holiday date of the branccode specified in
-C<dropbox_branch> . Assumes you've already checked that
-it's safe to do this, i.e. last non-holiday > issuedate.
+setting C<returndate> to the current date.
if C<$returndate> is specified (in iso format), it is used as the date
-of the return. It is ignored when a dropbox_branch is passed in.
+of the return.
C<$privacy> contains the privacy parameter. If the patron has set privacy to 2,
the old_issue is immediately anonymised
Ideally, this function would be internal to C<C4::Circulation>,
-not exported, but it is currently needed by one
-routine in C<C4::Accounts>.
+not exported, but it is currently used in misc/cronjobs/longoverdue.pl
+and offline_circ/process_koc.pl.
=cut
sub MarkIssueReturned {
- my ( $borrowernumber, $itemnumber, $dropbox_branch, $returndate, $privacy ) = @_;
-
+ my ( $borrowernumber, $itemnumber, $returndate, $privacy ) = @_;
# Retrieve the issue
my $issue = Koha::Checkouts->find( { itemnumber => $itemnumber } ) or return;
die "Fatal error: the patron ($borrowernumber) has requested their circulation history be anonymized on check-in, but the AnonymousPatron system preference is empty or not set correctly."
unless Koha::Patrons->find( $anonymouspatron );
}
- my $database = Koha::Database->new();
- my $schema = $database->schema;
- my $dbh = C4::Context->dbh;
- my $query = 'UPDATE issues SET returndate=';
- my @bind;
- if ($dropbox_branch) {
- my $calendar = Koha::Calendar->new( branchcode => $dropbox_branch );
- my $dropboxdate = $calendar->addDate( DateTime->now( time_zone => C4::Context->tz), -1 );
- $query .= ' ? ';
- push @bind, $dropboxdate->strftime('%Y-%m-%d %H:%M');
- } elsif ($returndate) {
- $query .= ' ? ';
- push @bind, $returndate;
- } else {
- $query .= ' now() ';
- }
- $query .= ' WHERE issue_id = ?';
- push @bind, $issue_id;
+ my $schema = Koha::Database->schema;
# FIXME Improve the return value and handle it from callers
$schema->txn_do(sub {
- # Update the returndate
- $dbh->do( $query, undef, @bind );
-
- # We just updated the returndate, so we need to refetch $issue
- $issue->discard_changes;
+ # Update the returndate value
+ if ( $returndate ) {
+ $issue->returndate( $returndate )->store->discard_changes; # update and refetch
+ }
+ else {
+ $issue->returndate( \'NOW()' )->store->discard_changes; # update and refetch
+ }
# Create the old_issues entry
my $old_checkout = Koha::Old::Checkout->new($issue->unblessed)->store;
# anonymise patron checkout immediately if $privacy set to 2 and AnonymousPatron is set to a valid borrowernumber
if ( $privacy == 2) {
- $dbh->do(q|UPDATE old_issues SET borrowernumber=? WHERE issue_id = ?|, undef, $anonymouspatron, $old_checkout->issue_id);
+ $old_checkout->borrowernumber($anonymouspatron)->store;
}
# And finally delete the issue
$issue->delete;
- ModItem( { 'onloan' => undef }, undef, $itemnumber );
+ ModItem( { 'onloan' => undef }, undef, $itemnumber, { log_action => 0 } );
if ( C4::Context->preference('StoreLastBorrower') ) {
my $item = Koha::Items->find( $itemnumber );
}
}
- my $new_debar_dt =
- $return_date->clone()->add_duration( $suspension_days );
+ if ( $issuing_rule->suspension_chargeperiod > 1 ) {
+ # No need to / 1 and do not consider / 0
+ $suspension_days = DateTime::Duration->new(
+ days => floor( $suspension_days->in_units('days') / $issuing_rule->suspension_chargeperiod )
+ );
+ }
+
+ my $new_debar_dt;
+ # Use the calendar or not to calculate the debarment date
+ if ( C4::Context->preference('finesCalendar') eq 'noFinesWhenClosed' ) {
+ my $calendar = Koha::Calendar->new(
+ branchcode => $branchcode,
+ days_mode => 'Calendar'
+ );
+ $new_debar_dt = $calendar->addDate( $return_date, $suspension_days );
+ }
+ else {
+ $new_debar_dt = $return_date->clone()->add_duration($suspension_days);
+ }
Koha::Patron::Debarments::AddUniqueDebarment({
borrowernumber => $borrower->{borrowernumber},
C<$exemptfine> BOOL -- remove overdue charge associated with this issue.
C<$dropboxmode> BOOL -- remove lastincrement on overdue charge associated with this issue.
-Internal function, called only by AddReturn
+Internal function
=cut
sub _FixOverduesOnReturn {
- my ($borrowernumber, $item);
- unless ($borrowernumber = shift) {
+ my ($borrowernumber, $item, $exemptfine, $dropbox ) = @_;
+ unless( $borrowernumber ) {
warn "_FixOverduesOnReturn() not supplied valid borrowernumber";
return;
}
- unless ($item = shift) {
+ unless( $item ) {
warn "_FixOverduesOnReturn() not supplied valid itemnumber";
return;
}
- my ($exemptfine, $dropbox) = @_;
- my $dbh = C4::Context->dbh;
# check for overdue fine
my $accountline = Koha::Account::Lines->search(
)->next();
return 0 unless $accountline; # no warning, there's just nothing to fix
- my $uquery;
if ($exemptfine) {
my $amountoutstanding = $accountline->amountoutstanding;
type => 'Forgiven',
amount => $amountoutstanding * -1,
}
- );
+ )->store();
if (C4::Context->preference("FinesLog")) {
&logaction("FINES", 'MODIFY',$borrowernumber,"Overdue forgiven: item $item");
type => 'Dropbox',
amount => $accountline->lastincrement * -1,
}
- );
+ )->store();
if ( C4::Context->preference("FinesLog") ) {
&logaction( "FINES", 'MODIFY', $borrowernumber,
my $borrowernumber = @_ ? shift : undef;
my $item_id = @_ ? shift : $itemnumber; # Send the barcode if you want that logged in the description
+ my $credit;
+
# check for charge made for lost book
- my $accountline = Koha::Account::Lines->search(
+ my $accountlines = Koha::Account::Lines->search(
{
itemnumber => $itemnumber,
accounttype => { -in => [ 'L', 'Rep', 'W' ] },
{
order_by => { -desc => [ 'date', 'accountno' ] }
}
- )->next();
+ );
- return unless $accountline;
- return if $accountline->accounttype eq 'W'; # Written off
+ return unless $accountlines->count > 0;
+ my $accountline = $accountlines->next;
+ my $total_to_refund = 0;
+ my $account = Koha::Patrons->find( $accountline->borrowernumber )->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;
+ }
- $accountline->accounttype('LR');
- $accountline->store();
+ my $credit_total = $accountline->amountoutstanding + $total_to_refund;
- my $account = Koha::Account->new( { patron_id => $accountline->borrowernumber } );
- my $credit_id = $account->pay(
- {
- amount => $accountline->amount,
- description => "Item Returned " . $item_id,
- account_type => 'CR',
- offset_type => 'Lost Item Return',
- accounlines => [$accountline],
+ if ( $credit_total > 0 ) {
+ my $branchcode = C4::Context->userenv ? C4::Context->userenv->{'branch'} : undef;
+ $credit = $account->add_credit(
+ { amount => $credit_total,
+ description => 'Item Returned ' . $item_id,
+ type => 'lost_item_return',
+ library_id => $branchcode
+ }
+ );
- }
- );
+ # TODO: ->apply should just accept the accountline
+ $credit->apply( { debits => $accountlines->reset } );
+ }
- ModItem( { paidfor => '' }, undef, $itemnumber );
+ # Manually set the accounttype
+ $accountline->discard_changes->accounttype('LR');
+ $accountline->store;
- return $credit_id;
+ ModItem( { paidfor => '' }, undef, $itemnumber, { log_action => 0 } );
+
+ if ( defined $account and C4::Context->preference('AccountAutoReconcile') ) {
+ $account->reconcile_balance;
+ }
+
+ return ($credit) ? $credit->id : undef;
}
=head2 _GetCircControlBranch
my $dbh = C4::Context->dbh;
my $renews = 1;
- my $item = GetItem($itemnumber) or return ( 0, 'no_item' );
- my $issue = Koha::Checkouts->find( { itemnumber => $itemnumber } ) or return ( 0, 'no_checkout' );
+ my $item = Koha::Items->find($itemnumber) or return ( 0, 'no_item' );
+ my $issue = $item->checkout or return ( 0, 'no_checkout' );
return ( 0, 'onsite_checkout' ) if $issue->onsite_checkout;
+ return ( 0, 'item_denied_renewal') if _item_denied_renewal({ item => $item });
- $borrowernumber ||= $issue->borrowernumber;
- my $patron = Koha::Patrons->find( $borrowernumber )
- or return;
+ my $patron = $issue->patron or return;
my ( $resfound, $resrec, undef ) = C4::Reserves::CheckReserves($itemnumber);
my @reservable;
my %borrowers;
ITEM: foreach my $i (@itemnumbers) {
- my $item = GetItem($i);
+ my $item = Koha::Items->find($i)->unblessed;
next if IsItemOnHoldAndFound($i);
for my $b (@borrowernumbers) {
my $borr = $borrowers{$b} //= Koha::Patrons->find( $b )->unblessed;
return ( 1, undef ) if $override_limit;
- my $branchcode = _GetCircControlBranch( $item, $patron->unblessed );
+ my $branchcode = _GetCircControlBranch( $item->unblessed, $patron->unblessed );
my $issuing_rule = Koha::IssuingRules->get_effective_issuing_rule(
{ categorycode => $patron->categorycode,
- itemtype => $item->{itype},
+ itemtype => $item->effective_itemtype,
branchcode => $branchcode
}
);
my $itemnumber = shift or return;
my $branch = shift;
my $datedue = shift;
- my $lastreneweddate = shift || DateTime->now(time_zone => C4::Context->tz)->ymd();
+ my $lastreneweddate = shift || DateTime->now(time_zone => C4::Context->tz);
- my $item = GetItem($itemnumber) or return;
- my $item_object = Koha::Items->find( $itemnumber ); # Should replace $item
- my $biblio = $item_object->biblio;
+ my $item = Koha::Items->find($itemnumber) or return;
+ my $biblio = $item->biblio;
+ my $issue = $item->checkout;
+ my $item_unblessed = $item->unblessed;
my $dbh = C4::Context->dbh;
- # Find the issues record for this book
- my $issue = Koha::Checkouts->find( { itemnumber => $itemnumber } );
-
return unless $issue;
$borrowernumber ||= $issue->borrowernumber;
my $patron_unblessed = $patron->unblessed;
if ( C4::Context->preference('CalculateFinesOnReturn') && $issue->is_overdue ) {
- _CalculateAndUpdateFine( { issue => $issue, item => $item, borrower => $patron_unblessed } );
+ _CalculateAndUpdateFine( { issue => $issue, item => $item_unblessed, borrower => $patron_unblessed } );
}
_FixOverduesOnReturn( $borrowernumber, $itemnumber );
# based on the value of the RenewalPeriodBase syspref.
unless ($datedue) {
- my $itemtype = $item_object->effective_itemtype;
+ my $itemtype = $item->effective_itemtype;
$datedue = (C4::Context->preference('RenewalPeriodBase') eq 'date_due') ?
dt_from_string( $issue->date_due, 'sql' ) :
DateTime->now( time_zone => C4::Context->tz());
- $datedue = CalcDateDue($datedue, $itemtype, _GetCircControlBranch($item, $patron_unblessed), $patron_unblessed, 'is a renewal');
+ $datedue = CalcDateDue($datedue, $itemtype, _GetCircControlBranch($item_unblessed, $patron_unblessed), $patron_unblessed, 'is a renewal');
}
# Update the issues record to have the new due date, and a new count
$sth->execute( $datedue->strftime('%Y-%m-%d %H:%M'), $renews, $lastreneweddate, $borrowernumber, $itemnumber );
# Update the renewal count on the item, and tell zebra to reindex
- $renews = $item->{renewals} + 1;
- ModItem({ renewals => $renews, onloan => $datedue->strftime('%Y-%m-%d %H:%M')}, $item->{biblionumber}, $itemnumber);
+ $renews = $item->renewals + 1;
+ ModItem( { renewals => $renews, onloan => $datedue->strftime('%Y-%m-%d %H:%M')}, $item->biblionumber, $itemnumber, { log_action => 0 } );
# Charge a new rental fee, if applicable?
my ( $charge, $type ) = GetIssuingCharges( $itemnumber, $borrowernumber );
if ( $charge > 0 ) {
- my $accountno = getnextacctno( $borrowernumber );
+ my $accountno = C4::Accounts::getnextacctno( $borrowernumber );
my $manager_id = 0;
- $manager_id = C4::Context->userenv->{'number'} if C4::Context->userenv;
- $sth = $dbh->prepare(
- "INSERT INTO accountlines
- (date, borrowernumber, accountno, amount, manager_id,
- description,accounttype, amountoutstanding, itemnumber)
- VALUES (now(),?,?,?,?,?,?,?,?)"
- );
- $sth->execute( $borrowernumber, $accountno, $charge, $manager_id,
- "Renewal of Rental Item " . $biblio->title . " $item->{'barcode'}",
- 'Rent', $charge, $itemnumber );
+ $manager_id = C4::Context->userenv->{'number'} if C4::Context->userenv;
+ my $branchcode = C4::Context->userenv ? C4::Context->userenv->{'branch'} : undef;
+ Koha::Account::Line->new(
+ {
+ date => dt_from_string(),
+ borrowernumber => $borrowernumber,
+ accountno => $accountno,
+ amount => $charge,
+ manager_id => $manager_id,
+ accounttype => 'Rent',
+ amountoutstanding => $charge,
+ itemnumber => $itemnumber,
+ branchcode => $branchcode,
+ description => 'Renewal of Rental Item '
+ . $biblio->title
+ . " " . $item->barcode,
+ }
+ )->store();
}
# Send a renewal slip according to checkout alert preferencei
my %conditions = (
branchcode => $branch,
categorycode => $patron->categorycode,
- item_type => $item->{itype},
+ item_type => $item->effective_itemtype,
notification => 'CHECKOUT',
);
if ( $circulation_alert->is_enabled_for( \%conditions ) ) {
SendCirculationAlert(
{
type => 'RENEWAL',
- item => $item,
+ item => $item_unblessed,
borrower => $patron->unblessed,
branch => $branch,
}
type => 'renew',
amount => $charge,
itemnumber => $itemnumber,
- itemtype => $item->{itype},
- location => $item->{location},
+ itemtype => $item->effective_itemtype,
+ location => $item->location,
borrowernumber => $borrowernumber,
- ccode => $item->{'ccode'}
+ ccode => $item->ccode,
}
);
my $renewsleft = 0;
my $patron = Koha::Patrons->find( $bornum );
- my $item = GetItem($itemno);
+ my $item = Koha::Items->find($itemno);
return (0, 0, 0) unless $patron or $item; # Wrong call, no renewal allowed
my $data = $sth->fetchrow_hashref;
$renewcount = $data->{'renewals'} if $data->{'renewals'};
# $item and $borrower should be calculated
- my $branchcode = _GetCircControlBranch($item, $patron->unblessed);
+ my $branchcode = _GetCircControlBranch($item->unblessed, $patron->unblessed);
my $issuing_rule = Koha::IssuingRules->get_effective_issuing_rule(
{ categorycode => $patron->categorycode,
- itemtype => $item->{itype},
+ itemtype => $item->effective_itemtype,
branchcode => $branchcode
}
);
my $dbh = C4::Context->dbh;
- my $item = GetItem($itemnumber) or return;
- my $itemissue = Koha::Checkouts->find( { itemnumber => $itemnumber } ) or return;
+ my $item = Koha::Items->find($itemnumber) or return;
+ my $itemissue = $item->checkout or return;
$borrowernumber ||= $itemissue->borrowernumber;
my $patron = Koha::Patrons->find( $borrowernumber )
or return;
- my $branchcode = _GetCircControlBranch( $item, $patron->unblessed );
+ my $branchcode = _GetCircControlBranch( $item->unblessed, $patron->unblessed );
my $issuing_rule = Koha::IssuingRules->get_effective_issuing_rule(
{ categorycode => $patron->categorycode,
- itemtype => $item->{itype},
+ itemtype => $item->effective_itemtype,
branchcode => $branchcode
}
);
my $dbh = C4::Context->dbh;
- my $item = GetItem($itemnumber) or return;
- my $itemissue = Koha::Checkouts->find( { itemnumber => $itemnumber } ) or return;
+ my $item = Koha::Items->find($itemnumber) or return;
+ my $itemissue = $item->checkout or return;
$borrowernumber ||= $itemissue->borrowernumber;
my $patron = Koha::Patrons->find( $borrowernumber )
or return;
- my $branchcode = _GetCircControlBranch( $item, $patron->unblessed );
+ my $branchcode = _GetCircControlBranch( $item->unblessed, $patron->unblessed );
my $issuing_rule = Koha::IssuingRules->get_effective_issuing_rule(
{ categorycode => $patron->categorycode,
- itemtype => $item->{itype},
+ itemtype => $item->effective_itemtype,
branchcode => $branchcode
}
);
=head2 AddIssuingCharge
- &AddIssuingCharge( $itemno, $borrowernumber, $charge )
+ &AddIssuingCharge( $checkout, $charge )
=cut
sub AddIssuingCharge {
- my ( $itemnumber, $borrowernumber, $charge ) = @_;
-
- my $nextaccntno = getnextacctno($borrowernumber);
+ my ( $checkout, $charge ) = @_;
- my $manager_id = 0;
- $manager_id = C4::Context->userenv->{'number'} if C4::Context->userenv;
+ # FIXME What if checkout does not exist?
- my $accountline = Koha::Account::Line->new(
+ my $account = Koha::Account->new({ patron_id => $checkout->borrowernumber });
+ my $accountline = $account->add_debit(
{
- borrowernumber => $borrowernumber,
- itemnumber => $itemnumber,
- accountno => $nextaccntno,
- amount => $charge,
- amountoutstanding => $charge,
- manager_id => $manager_id,
- description => 'Rental',
- accounttype => 'Rent',
- date => \'NOW()',
- }
- )->store();
-
- Koha::Account::Offset->new(
- {
- debit_id => $accountline->id,
- type => 'Rental Fee',
- amount => $charge,
+ amount => $charge,
+ description => 'Rental',
+ note => undef,
+ user_id => C4::Context->userenv ? C4::Context->userenv->{'number'} : 0,
+ library_id => C4::Context->userenv ? C4::Context->userenv->{'branch'} : undef,
+ type => 'rent',
+ item_id => $checkout->itemnumber,
+ issue_id => $checkout->issue_id,
}
- )->store();
+ );
}
=head2 GetTransfers
Code is either an itemtype or collection doe depending on the pref BranchTransferLimitsType
+Deprecated in favor of Koha::Item::Transfer::Limits->find/search and
+Koha::Item->can_be_transferred.
+
=cut
sub IsBranchTransferAllowed {
$code is either itemtype or collection code depending on what the pref BranchTransferLimitsType is set to.
+Deprecated in favor of Koha::Item::Transfer::Limit->new.
+
=cut
sub CreateBranchTransferLimit {
number of limits deleted, 0e0 if no limits were deleted, or undef if
no arguments are supplied.
+Deprecated in favor of Koha::Item::Transfer::Limits->search({
+ fromBranch => $fromBranch
+ })->delete.
+
=cut
sub DeleteBranchTransferLimits {
MarkIssueReturned( $borrowernumber, $itemnum );
my $patron = Koha::Patrons->find( $borrowernumber );
- my $item = C4::Items::GetItem( $itemnum );
- my $old_note = ($item->{'paidfor'} && ($item->{'paidfor'} ne q{})) ? $item->{'paidfor'}.' / ' : q{};
+ my $item = Koha::Items->find($itemnum);
+ my $old_note = ($item->paidfor && ($item->paidfor ne q{})) ? $item->paidfor.' / ' : q{};
my @datearr = localtime(time);
my $date = ( 1900 + $datearr[5] ) . "-" . ( $datearr[4] + 1 ) . "-" . $datearr[3];
my $bor = $patron->firstname . ' ' . $patron->surname . ' ' . $patron->cardnumber;
sub LostItem{
- my ($itemnumber, $mark_returned) = @_;
+ my ($itemnumber, $mark_lost_from, $force_mark_returned) = @_;
- $mark_returned //= C4::Context->preference('MarkLostItemsAsReturned');
+ unless ( $mark_lost_from ) {
+ # Temporary check to avoid regressions
+ die q|LostItem called without $mark_lost_from, check the API.|;
+ }
+
+ my $mark_returned;
+ if ( $force_mark_returned ) {
+ $mark_returned = 1;
+ } else {
+ my $pref = C4::Context->preference('MarkLostItemsAsReturned') // q{};
+ $mark_returned = ( $pref =~ m|$mark_lost_from| );
+ }
my $dbh = C4::Context->dbh();
my $sth=$dbh->prepare("SELECT issues.*,items.*,biblio.title
if ( my $borrowernumber = $issues->{borrowernumber} ){
my $patron = Koha::Patrons->find( $borrowernumber );
- if (C4::Context->preference('WhenLostForgiveFine')){
- my $fix = _FixOverduesOnReturn($borrowernumber, $itemnumber, 1, 0); # 1, 0 = exemptfine, no-dropbox
- defined($fix) or warn "_FixOverduesOnReturn($borrowernumber, $itemnumber...) failed!"; # zero is OK, check defined
- }
+ my $fix = _FixOverduesOnReturn($borrowernumber, $itemnumber, C4::Context->preference('WhenLostForgiveFine'), 0); # 1, 0 = exemptfine, no-dropbox
+ defined($fix) or warn "_FixOverduesOnReturn($borrowernumber, $itemnumber...) failed!"; # zero is OK, check defined
+
if (C4::Context->preference('WhenLostChargeReplacementFee')){
- C4::Accounts::chargelostitem($borrowernumber, $itemnumber, $issues->{'replacementprice'}, "Lost Item $issues->{'title'} $issues->{'barcode'}");
+ C4::Accounts::chargelostitem($borrowernumber, $itemnumber, $issues->{'replacementprice'}, "Lost Item $issues->{'title'} $issues->{'barcode'} $issues->{'itemcallnumber'}");
#FIXME : Should probably have a way to distinguish this from an item that really was returned.
#warn " $issues->{'borrowernumber'} / $itemnumber ";
}
- MarkIssueReturned($borrowernumber,$itemnumber,undef,undef,$patron->privacy) if $mark_returned;
+ MarkIssueReturned($borrowernumber,$itemnumber,undef,$patron->privacy) if $mark_returned;
}
+
+ #When item is marked lost automatically cancel its outstanding transfers and set items holdingbranch to the transfer source branch (frombranch)
+ if (my ( $datesent,$frombranch,$tobranch ) = GetTransfers($itemnumber)) {
+ ModItem({holdingbranch => $frombranch}, undef, $itemnumber);
+ }
+ my $transferdeleted = DeleteTransfer($itemnumber);
}
sub GetOfflineOperations {
MarkIssueReturned(
$issue->{borrowernumber},
$itemnumber,
- undef,
$operation->{timestamp},
);
ModItem(
{ renewals => 0, onloan => undef },
$issue->{'biblionumber'},
- $itemnumber
+ $itemnumber,
+ { log_action => 0 }
);
return "Success.";
} else {
MarkIssueReturned(
$issue->{borrowernumber},
$itemnumber,
- undef,
$operation->{timestamp},
);
}
sub ProcessOfflinePayment {
my $operation = shift;
- my $patron = Koha::Patrons->find( { cardnumber => $operation->{cardnumber} });
- my $amount = $operation->{amount};
+ my $patron = Koha::Patrons->find({ cardnumber => $operation->{cardnumber} });
- Koha::Account->new( { patron_id => $patron->id } )->pay( { amount => $amount } );
+ $patron->account->pay({ amount => $operation->{amount}, library_id => $operation->{branchcode} });
- return "Success."
+ return "Success.";
}
-
=head2 TransferSlip
TransferSlip($user_branch, $itemnumber, $barcode, $to_branch)
sub TransferSlip {
my ($branch, $itemnumber, $barcode, $to_branch) = @_;
- my $item = GetItem( $itemnumber, $barcode )
- or return;
+ my $item =
+ $itemnumber
+ ? Koha::Items->find($itemnumber)
+ : Koha::Items->find( { barcode => $barcode } );
+
+ $item or return;
return C4::Letters::GetPreparedLetter (
module => 'circulation',
branchcode => $branch,
tables => {
'branches' => $to_branch,
- 'biblio' => $item->{biblionumber},
- 'items' => $item,
+ 'biblio' => $item->biblionumber,
+ 'items' => $item->unblessed,
},
);
}
my $date_returned = $return_date ? dt_from_string($return_date) : dt_from_string();
- my ( $amount, $type, $unitcounttotal ) =
+ my ( $amount, $unitcounttotal, $unitcount ) =
C4::Overdues::CalcFine( $item, $borrower->{categorycode}, $control_branchcode, $datedue, $date_returned );
- $type ||= q{};
-
if ( C4::Context->preference('finesMode') eq 'production' ) {
if ( $amount > 0 ) {
C4::Overdues::UpdateFine({
itemnumber => $issue->itemnumber,
borrowernumber => $issue->borrowernumber,
amount => $amount,
- type => $type,
due => output_pref($datedue),
});
}
itemnumber => $issue->itemnumber,
borrowernumber => $issue->borrowernumber,
amount => 0,
- type => $type,
due => output_pref($datedue),
});
}
}
}
+sub _item_denied_renewal {
+ my ($params) = @_;
+
+ my $item = $params->{item};
+ return unless $item;
+
+ my $denyingrules = Koha::Config::SysPrefs->find('ItemsDeniedRenewal')->get_yaml_pref_hash();
+ return unless $denyingrules;
+ foreach my $field (keys %$denyingrules) {
+ my $val = $item->$field;
+ if( !defined $val) {
+ if ( any { !defined $_ } @{$denyingrules->{$field}} ){
+ return 1;
+ }
+ } elsif (any { defined($_) && $val eq $_ } @{$denyingrules->{$field}}) {
+ # If the results matches the values in the syspref
+ # We return true if match found
+ return 1;
+ }
+ }
+ return 0;
+}
+
+
1;
__END__