Attachment #173846 for bug #31391

View | Details | Raw Unified | Return to bug 31391
Collapse All | Expand All




    my $original = C4::Context->preference('HoldsLog') ? $hold->unblessed : undef;

    if ( $rank eq "del" ) {
        $hold->cancel( { cancellation_reason => $cancellation_reason } );
    } elsif ( $rank eq "recall" ) {
    elsif ( $rank eq "recall" ) {
        if ( !$biblionumber ) {
            $biblionumber = $hold->biblionumber;
        }
        my $biblio = Koha::Biblios->find($biblionumber);
        if ( !$borrowernumber ) {
            $borrowernumber = $hold->borrowernumber;
        }
        my $patron = Koha::Patrons->find($borrowernumber);
        if ( $hold->item_level_hold ) {
            if ( $hold->item->can_be_recalled( { patron => $patron, hold_convert => 1 } ) ) {
                my ( $recall, $due_interval, $due_date ) = Koha::Recalls->add_recall(
                    {
                        patron         => $patron,
                        biblio         => $biblio,
                        branchcode     => $branchcode,
                        expirationdate => $date,
                        interface      => 'intranet',
                        item           => $hold->item,
                    }
                );
                $hold->cancel( { cancellation_reason => 'RECALLED' } );
            }
        } else {
            if ( $biblio->can_be_recalled( { patron => $patron, hold_convert => 1 } ) ) {
                my ( $recall, $due_interval, $due_date ) = Koha::Recalls->add_recall(
                    {
                        patron         => $patron,
                        biblio         => $biblio,
                        branchcode     => $branchcode,
                        expirationdate => $date,
                        interface      => 'intranet',
                    }
                );
                $hold->cancel( { cancellation_reason => 'RECALLED' } );
            }
        }
    }

Lines 1-13 Link Here

(-)a/installer/data/mysql/atomicupdate/bug_31391_-_add_HOLD_CANCELLATION-RECALLED_authorised_value.pl (-4 / +6 lines)
1	use Modern::Perl;	1	use Modern::Perl;
2		2
3	return {	3	return {
4	bug_number => "31391",	4	bug_number => "31391",
5	description => "Staff-side recalls",	5	description => "Staff-side recalls",
6	up => sub {	6	up => sub {
7	my ($args) = @_;	7	my ($args) = @_;
8	my ($dbh, $out) = @$args{qw(dbh out)};	8	my ( $dbh, $out ) = @$args{qw(dbh out)};
9		9
10	$dbh->do(q{ INSERT IGNORE INTO authorised_values (category, authorised_value, lib) VALUES ('HOLD_CANCELLATION','RECALLED','Hold was converted to a recall') });	10	$dbh->do(
		11	q{ INSERT IGNORE INTO authorised_values (category, authorised_value, lib) VALUES ('HOLD_CANCELLATION','RECALLED','Hold was converted to a recall') }
		12	);
11		13
12	say $out "Added RECALLED value to HOLD_CANCELLATION authorised value category";	14	say $out "Added RECALLED value to HOLD_CANCELLATION authorised value category";
13	},	15	},

Lines 1-13 Link Here

(-)a/installer/data/mysql/atomicupdate/bug_31391_-_add_RecallsInterface_syspref.pl (-4 / +6 lines)
1	use Modern::Perl;	1	use Modern::Perl;
2		2
3	return {	3	return {
4	bug_number => "31391",	4	bug_number => "31391",
5	description => "Staff-side recalls",	5	description => "Staff-side recalls",
6	up => sub {	6	up => sub {
7	my ($args) = @_;	7	my ($args) = @_;
8	my ($dbh, $out) = @$args{qw(dbh out)};	8	my ( $dbh, $out ) = @$args{qw(dbh out)};
9		9
10	$dbh->do(q{INSERT IGNORE INTO systempreferences (variable,value,options,explanation,type) VALUES ('RecallsInterface','opac','opac\|staff\|both','The interface that recalls can be placed through','Choice') });	10	$dbh->do(
		11	q{INSERT IGNORE INTO systempreferences (variable,value,options,explanation,type) VALUES ('RecallsInterface','opac','opac\|staff\|both','The interface that recalls can be placed through','Choice') }
		12	);
11		13
12	say $out "Added system preference 'RecallsInterface'";	14	say $out "Added system preference 'RecallsInterface'";
13	},	15	},

Lines 60-66 Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/en/modules/recalls/request.tt (-1 / +1 lines)
60		60
61	[% IF patron_holds_count %]	61	[% IF patron_holds_count %]
62	<div class="dialog alert alert-info">	62	<div class="dialog alert alert-info">
63	Patron has placed one or more record-level holds. <a href="/cgi-bin/koha/reserve/request.pl?biblionumber=[% biblio.biblionumber \| html %]">Convert a hold to a recall</a>.	63	Patron has placed one or more record-level holds. <a href="/cgi-bin/koha/reserve/request.pl?biblionumber=[% biblio.biblionumber \| uri %]">Convert a hold to a recall</a>.
64	</div>	64	</div>
65	[% END %]	65	[% END %]
66		66




    }
);

my $op             = $input->param('op') || 'list';
my @recall_ids     = $input->multi_param('recall_ids');
my $biblionumber   = $input->param('biblionumber');
my $biblio         = Koha::Biblios->find($biblionumber);
my $borrowernumber = $input->param('borrowernumber');
my $error          = $input->param('error');

if ( $op eq 'cud-cancel_multiple_recalls' ) {
    foreach my $id (@recall_ids) {
        Koha::Recalls->find($id)->set_cancelled;
    }
    print $input->redirect( '/cgi-bin/koha/recalls/request.pl?biblionumber=' . $biblionumber );
} elsif ( $op eq 'cud-request' ) {
elsif ( $op eq 'cud-request' ) {

    if (    C4::Context->preference('UseRecalls')
        and C4::Context->preference('RecallsInterface') ne 'opac'
        and $borrowernumber )
    {
        my $patron = Koha::Patrons->find($borrowernumber);

        unless ( $biblio->can_be_recalled( { patron => $patron } ) ) { $error = 'unavailable'; }
        my $items = Koha::Items->search( { biblionumber => $biblionumber } )->as_list;

        # check if already recalled
        my $recalled = $biblio->recalls->filter_by_current->search( { patron_id => $borrowernumber } )->count;
        if ( defined $recalled and $recalled > 0 ) {
            my $recalls_per_record = Koha::CirculationRules->get_effective_rule(
                {
                    categorycode => $patron->categorycode,
                    branchcode   => undef,
                    itemtype     => undef,
                    rule_name    => 'recalls_per_record'
                }
            );
            if (    defined $recalls_per_record
                and $recalls_per_record->rule_value
                and $recalled >= $recalls_per_record->rule_value )
            {
                $error = 'duplicate';
            }
        }

        if ( !defined $error ) {
            my $pickuploc  = $input->param('pickup');
            my $expdate    = $input->param('expirationdate');
            my $level      = $input->param('type');
            my $itemnumber = $input->param('itemnumber');

            my ( $recall, $due_interval, $due_date );

            if ( !defined $level and defined $itemnumber ) {
                my $item = Koha::Items->find($itemnumber);
                if ( $item->can_be_recalled( { patron => $patron } ) ) {
                    ( $recall, $due_interval, $due_date ) = Koha::Recalls->add_recall(
                        {
                            patron         => $patron,
                            biblio         => $biblio,
                            branchcode     => $pickuploc,
                            item           => $item,
                            expirationdate => $expdate,
                            interface      => 'staff',
                        }
                    );
                } else {
                    $error = 'cannot';
                }
            } else {
                if ( $biblio->can_be_recalled( { patron => $patron } ) ) {
                    ( $recall, $due_interval, $due_date ) = Koha::Recalls->add_recall(
                        {
                            patron         => $patron,
                            biblio         => $biblio,
                            branchcode     => $pickuploc,
                            expirationdate => $expdate,
                            interface      => 'staff',
                        }
                    );
                } else {
                    $error = 'cannot';
                }

            if ( !defined $recall ) {
                $error = 'failed';
            } else {

                # successful recall, go back to Recalls tab
                print $input->redirect("/cgi-bin/koha/recalls/request.pl?biblionumber=$biblionumber");
            }

    }
}

if ($borrowernumber) {
    my $patron = Koha::Patrons->find($borrowernumber);

    if (    C4::Context->preference('UseRecalls')
        and C4::Context->preference('RecallsInterface') ne 'opac'
        and $patron
        and $patron->borrowernumber )
    {
        if ( !$biblio->can_be_recalled( { patron => $patron } ) ) {
            $error = 1;
        }
        my $patron_holds_count = Koha::Holds->search(
            { borrowernumber => $borrowernumber, biblionumber => $biblio->biblionumber, item_level_hold => 0 } )->count;

        $template->param(
            patron             => $patron,
            patron_holds_count => $patron_holds_count,
        );
    }
}

my $recalls            = Koha::Recalls->search( { biblio_id => $biblionumber, completed => 0 } );
my $branches           = Koha::Libraries->search;
my $single_branch_mode = $branches->count == 1;
my $items              = Koha::Items->search( { biblionumber => $biblionumber } );

$template->param(
    recalls            => $recalls,
    recallsview        => 1,
    biblio             => $biblio,
    checkboxes         => 1,
    branches           => $branches,
    items              => $items,
    error              => $error,
    single_branch_mode => $single_branch_mode,
    C4::Search::enabled_staff_search_views,
    attribute_type_codes => (
        C4::Context->preference('ExtendedPatronAttributes')
        ? [ Koha::Patron::Attribute::Types->search( { staff_searchable => 1 } )->get_column('code') ]
        : []
    ),





        if ( $rank[$i] eq 'recall' and !$recallerror ) {
            my $hold = Koha::Holds->find( $reserve_id[$i] );
            if ( !$hold->biblio->can_be_recalled( { patron => $hold->patron } ) ) {
                $recallerror = 1;
            }
        }

} elsif ( $from eq 'circ'){
    print $query->redirect("/cgi-bin/koha/circ/circulation.pl?borrowernumber=$borrower[0]");
} else {
    my $url = URI->new("/cgi-bin/koha/reserve/request.pl");
    if ($recallerror) {
        $url->query_form( biblionumber => [@biblionumber], recallerror => 1 );
    } else {
        $url->query_form( biblionumber => [@biblionumber] );
    }
    print $query->redirect($url);
}

Lines 731-737 $template->param(borrowernumber => $borrowernumber_hold); Link Here

(-)a/reserve/request.pl (-1 / +1 lines)
731	$template->param( failed_holds => \@failed_holds );	731	$template->param( failed_holds => \@failed_holds );
732		732
733	my $recallerror = $input->param('recallerror');	733	my $recallerror = $input->param('recallerror');
734	if ( $recallerror ) {	734	if ($recallerror) {
735	$template->param( recallerror => 1 );	735	$template->param( recallerror => 1 );
736	}	736	}
737		737

Lines 7-13 use t::lib::TestBuilder; Link Here

(-)a/t/db_dependent/Holds.t (-31 / +35 lines)
7		7
8	use C4::Context;	8	use C4::Context;
9		9
10	use Test::More tests => 72;	10	use Test::More tests => 73;
11	use Test::Exception;	11	use Test::Exception;
12		12
13	use MARC::Record;	13	use MARC::Record;
Lines 1885-1895 subtest 'ModReserve to convert a hold to a recall' => sub { Link Here
1885		1885
1886	$schema->storage->txn_begin;	1886	$schema->storage->txn_begin;
1887		1887
1888	my $category = $builder->build({ source => 'Category' });	1888	my $category = $builder->build( { source => 'Category' } );
1889	my $branch = $builder->build({ source => 'Branch' })->{ branchcode };	1889	my $branch = $builder->build( { source => 'Branch' } )->{branchcode};
1890	my $biblio = $builder->build_sample_biblio( { itemtype => 'DUMMY' } );	1890	my $biblio = $builder->build_sample_biblio( { itemtype => 'DUMMY' } );
1891	my $item = $builder->build_sample_item(	1891	my $itype = $builder->build( { source => 'Itemtype' } );
1892	{ library => $branch, biblionumber => $biblio->biblionumber } );	1892	my $item =
		1893	$builder->build_sample_item(
		1894	{ library => $branch, biblionumber => $biblio->biblionumber, itype => $itype->{itemtype} } );
1893		1895
1894	my $patron = Koha::Patron->new(	1896	my $patron = Koha::Patron->new(
1895	{	1897	{
Lines 1912-1955 subtest 'ModReserve to convert a hold to a recall' => sub { Link Here
1912	}	1914	}
1913	)->store;	1915	)->store;
1914		1916
1915	t::lib::Mocks::mock_preference("UseRecalls", 1);	1917	t::lib::Mocks::mock_preference( "UseRecalls", 1 );
1916	t::lib::Mocks::mock_userenv( { branchcode => $branch } );	1918	t::lib::Mocks::mock_userenv( { branchcode => $branch } );
1917		1919
1918	C4::Circulation::AddIssue( $patron2->unblessed, $item->barcode );	1920	C4::Circulation::AddIssue( $patron2, $item->barcode );
1919		1921
1920	Koha::CirculationRules->set_rules({	1922	Koha::CirculationRules->set_rules(
1921	branchcode => undef,	1923	{
1922	categorycode => undef,	1924	branchcode => undef,
1923	itemtype => undef,	1925	categorycode => undef,
1924	rules => {	1926	itemtype => undef,
1925	recalls_allowed => 5,	1927	rules => {
1926	recalls_per_record => 1,	1928	recalls_allowed => 5,
1927	on_shelf_recalls => 'any',	1929	recalls_per_record => 1,
1928	},	1930	on_shelf_recalls => 'any',
1929	});	1931	},
		1932	}
		1933	);
1930		1934
1931	my $notice = Koha::Notice::Template->new({	1935	my $notice = Koha::Notice::Template->new(
1932	name => 'Hold cancellation',	1936	{
1933	module => 'reserves',	1937	name => 'Hold cancellation',
1934	code => 'HOLD_CANCELLATION',	1938	module => 'reserves',
1935	title => 'Hold cancelled',	1939	code => 'HOLD_CANCELLATION',
1936	content => 'Your hold was cancelled.',	1940	title => 'Hold cancelled',
1937	message_transport_type => 'email',	1941	content => 'Your hold was cancelled.',
1938	branchcode => q{},	1942	message_transport_type => 'email',
1939	})->store();	1943	branchcode => q{},
		1944	}
		1945	)->store();
1940		1946
1941	my $reserve_id = AddReserve(	1947	my $reserve_id = AddReserve(
1942	{	1948	{
1943	branchcode => $branch,	1949	branchcode => $branch,
1944	borrowernumber => $borrowernumber,	1950	borrowernumber => $borrowernumber,
1945	biblionumber => $biblio->biblionumber,	1951	biblionumber => $biblio->biblionumber,
1946	priority =>	1952	priority => C4::Reserves::CalculatePriority( $biblio->biblionumber ),
1947	C4::Reserves::CalculatePriority( $biblio->biblionumber ),	1953	itemnumber => $item->id,
1948	itemnumber => $item->id,
1949	}	1954	}
1950	);	1955	);
1951		1956
1952	my $hold = Koha::Holds->find($reserve_id);	1957	my $hold = Koha::Holds->find($reserve_id);
1953	my $before_recalls = Koha::Recalls->search->filter_by_current->count;	1958	my $before_recalls = Koha::Recalls->search->filter_by_current->count;
1954		1959
1955	ModReserve(	1960	ModReserve(
1956	-

Return to bug 31391

Lines 1052-1090 sub ModReserve { Link Here

(-)a/C4/Reserves.pm (-24 / +27 lines)
1052	my $original = C4::Context->preference('HoldsLog') ? $hold->unblessed : undef;	1052	my $original = C4::Context->preference('HoldsLog') ? $hold->unblessed : undef;
1053		1053
1054	if ( $rank eq "del" ) {	1054	if ( $rank eq "del" ) {
1055	$hold->cancel({ cancellation_reason => $cancellation_reason });	1055	$hold->cancel( { cancellation_reason => $cancellation_reason } );
1056	}	1056	} elsif ( $rank eq "recall" ) {
1057	elsif ( $rank eq "recall" ) {
1058	if ( !$biblionumber ) {	1057	if ( !$biblionumber ) {
1059	$biblionumber = $hold->biblionumber;	1058	$biblionumber = $hold->biblionumber;
1060	}	1059	}
1061	my $biblio = Koha::Biblios->find( $biblionumber );	1060	my $biblio = Koha::Biblios->find($biblionumber);
1062	if ( !$borrowernumber ) {	1061	if ( !$borrowernumber ) {
1063	$borrowernumber = $hold->borrowernumber;	1062	$borrowernumber = $hold->borrowernumber;
1064	}	1063	}
1065	my $patron = Koha::Patrons->find( $borrowernumber );	1064	my $patron = Koha::Patrons->find($borrowernumber);
1066	if ( $hold->item_level_hold ) {	1065	if ( $hold->item_level_hold ) {
1067	if ( $hold->item->can_be_recalled({ patron => $patron, hold_convert => 1 }) ) {	1066	if ( $hold->item->can_be_recalled( { patron => $patron, hold_convert => 1 } ) ) {
1068	my ( $recall, $due_interval, $due_date ) = Koha::Recalls->add_recall({	1067	my ( $recall, $due_interval, $due_date ) = Koha::Recalls->add_recall(
1069	patron => $patron,	1068	{
1070	biblio => $biblio,	1069	patron => $patron,
1071	branchcode => $branchcode,	1070	biblio => $biblio,
1072	expirationdate => $date,	1071	branchcode => $branchcode,
1073	interface => 'intranet',	1072	expirationdate => $date,
1074	item => $hold->item,	1073	interface => 'intranet',
1075	});	1074	item => $hold->item,
1076	$hold->cancel({ cancellation_reason => 'RECALLED' });	1075	}
		1076	);
		1077	$hold->cancel( { cancellation_reason => 'RECALLED' } );
1077	}	1078	}
1078	} else {	1079	} else {
1079	if ( $biblio->can_be_recalled({ patron => $patron, hold_convert => 1 }) ) {	1080	if ( $biblio->can_be_recalled( { patron => $patron, hold_convert => 1 } ) ) {
1080	my ( $recall, $due_interval, $due_date ) = Koha::Recalls->add_recall({	1081	my ( $recall, $due_interval, $due_date ) = Koha::Recalls->add_recall(
1081	patron => $patron,	1082	{
1082	biblio => $biblio,	1083	patron => $patron,
1083	branchcode => $branchcode,	1084	biblio => $biblio,
1084	expirationdate => $date,	1085	branchcode => $branchcode,
1085	interface => 'intranet',	1086	expirationdate => $date,
1086	});	1087	interface => 'intranet',
1087	$hold->cancel({ cancellation_reason => 'RECALLED' });	1088	}
		1089	);
		1090	$hold->cancel( { cancellation_reason => 'RECALLED' } );
1088	}	1091	}
1089	}	1092	}
1090	}	1093	}

Lines 72-78 if( $op eq 'cud-cancelall' \|\| $op eq 'cud-modifyall' ) { Link Here

(-)a/reserve/modrequest.pl (-8 / +8 lines)
72		72
73	if ( $rank[$i] eq 'recall' and !$recallerror ) {	73	if ( $rank[$i] eq 'recall' and !$recallerror ) {
74	my $hold = Koha::Holds->find( $reserve_id[$i] );	74	my $hold = Koha::Holds->find( $reserve_id[$i] );
75	if ( !$hold->biblio->can_be_recalled({ patron => $hold->patron }) ) {	75	if ( !$hold->biblio->can_be_recalled( { patron => $hold->patron } ) ) {
76	$recallerror = 1;	76	$recallerror = 1;
77	}	77	}
78	}	78	}
Lines 116-126 if ( $from eq 'borrower'){ Link Here
116	} elsif ( $from eq 'circ'){	116	} elsif ( $from eq 'circ'){
117	print $query->redirect("/cgi-bin/koha/circ/circulation.pl?borrowernumber=$borrower[0]");	117	print $query->redirect("/cgi-bin/koha/circ/circulation.pl?borrowernumber=$borrower[0]");
118	} else {	118	} else {
119	my $url = URI->new("/cgi-bin/koha/reserve/request.pl");	119	my $url = URI->new("/cgi-bin/koha/reserve/request.pl");
120	if ( $recallerror ) {	120	if ($recallerror) {
121	$url->query_form( biblionumber => [@biblionumber], recallerror => 1 );	121	$url->query_form( biblionumber => [@biblionumber], recallerror => 1 );
122	} else {	122	} else {
123	$url->query_form( biblionumber => [@biblionumber] );	123	$url->query_form( biblionumber => [@biblionumber] );
124	}	124	}
125	print $query->redirect($url);	125	print $query->redirect($url);
126	}	126	}

Lines 35-106 my ($template, $loggedinuser, $cookie)= get_template_and_user( Link Here

(-)a/recalls/request.pl (-61 / +79 lines)
35	}	35	}
36	);	36	);
37		37
38	my $op = $input->param('op') \|\| 'list';	38	my $op = $input->param('op') \|\| 'list';
39	my @recall_ids = $input->multi_param('recall_ids');	39	my @recall_ids = $input->multi_param('recall_ids');
40	my $biblionumber = $input->param('biblionumber');	40	my $biblionumber = $input->param('biblionumber');
41	my $biblio = Koha::Biblios->find( $biblionumber );	41	my $biblio = Koha::Biblios->find($biblionumber);
42	my $borrowernumber = $input->param('borrowernumber');	42	my $borrowernumber = $input->param('borrowernumber');
43	my $error = $input->param('error');	43	my $error = $input->param('error');
44		44
45	if ( $op eq 'cud-cancel_multiple_recalls' ) {	45	if ( $op eq 'cud-cancel_multiple_recalls' ) {
46	foreach my $id ( @recall_ids ) {	46	foreach my $id (@recall_ids) {
47	Koha::Recalls->find( $id )->set_cancelled;	47	Koha::Recalls->find($id)->set_cancelled;
48	}	48	}
49	print $input->redirect('/cgi-bin/koha/recalls/request.pl?biblionumber='.$biblionumber);	49	print $input->redirect( '/cgi-bin/koha/recalls/request.pl?biblionumber=' . $biblionumber );
50	}	50	} elsif ( $op eq 'cud-request' ) {
51	elsif ( $op eq 'cud-request' ) {
52		51
53	if ( C4::Context->preference('UseRecalls') and C4::Context->preference('RecallsInterface') ne 'opac' and $borrowernumber ) {	52	if ( C4::Context->preference('UseRecalls')
54	my $patron = Koha::Patrons->find( $borrowernumber );	53	and C4::Context->preference('RecallsInterface') ne 'opac'
		54	and $borrowernumber )
		55	{
		56	my $patron = Koha::Patrons->find($borrowernumber);
55		57
56	unless ( $biblio->can_be_recalled({ patron => $patron }) ) { $error = 'unavailable'; }	58	unless ( $biblio->can_be_recalled( { patron => $patron } ) ) { $error = 'unavailable'; }
57	my $items = Koha::Items->search({ biblionumber => $biblionumber })->as_list;	59	my $items = Koha::Items->search( { biblionumber => $biblionumber } )->as_list;
58		60
59	# check if already recalled	61	# check if already recalled
60	my $recalled = $biblio->recalls->filter_by_current->search({ patron_id => $borrowernumber })->count;	62	my $recalled = $biblio->recalls->filter_by_current->search( { patron_id => $borrowernumber } )->count;
61	if ( defined $recalled and $recalled > 0 ) {	63	if ( defined $recalled and $recalled > 0 ) {
62	my $recalls_per_record = Koha::CirculationRules->get_effective_rule({	64	my $recalls_per_record = Koha::CirculationRules->get_effective_rule(
63	categorycode => $patron->categorycode,	65	{
64	branchcode => undef,	66	categorycode => $patron->categorycode,
65	itemtype => undef,	67	branchcode => undef,
66	rule_name => 'recalls_per_record'	68	itemtype => undef,
67	});	69	rule_name => 'recalls_per_record'
68	if ( defined $recalls_per_record and $recalls_per_record->rule_value and $recalled >= $recalls_per_record->rule_value ){	70	}
		71	);
		72	if ( defined $recalls_per_record
		73	and $recalls_per_record->rule_value
		74	and $recalled >= $recalls_per_record->rule_value )
		75	{
69	$error = 'duplicate';	76	$error = 'duplicate';
70	}	77	}
71	}	78	}
72		79
73	if ( !defined $error ){	80	if ( !defined $error ) {
74	my $pickuploc = $input->param('pickup');	81	my $pickuploc = $input->param('pickup');
75	my $expdate = $input->param('expirationdate');	82	my $expdate = $input->param('expirationdate');
76	my $level = $input->param('type');	83	my $level = $input->param('type');
77	my $itemnumber = $input->param('itemnumber');	84	my $itemnumber = $input->param('itemnumber');
78		85
79	my ( $recall, $due_interval, $due_date );	86	my ( $recall, $due_interval, $due_date );
80		87
81	if ( !defined $level and defined $itemnumber ) {	88	if ( !defined $level and defined $itemnumber ) {
82	my $item = Koha::Items->find( $itemnumber );	89	my $item = Koha::Items->find($itemnumber);
83	if ( $item->can_be_recalled({ patron => $patron }) ) {	90	if ( $item->can_be_recalled( { patron => $patron } ) ) {
84	( $recall, $due_interval, $due_date ) = Koha::Recalls->add_recall({	91	( $recall, $due_interval, $due_date ) = Koha::Recalls->add_recall(
85	patron => $patron,	92	{
86	biblio => $biblio,	93	patron => $patron,
87	branchcode => $pickuploc,	94	biblio => $biblio,
88	item => $item,	95	branchcode => $pickuploc,
89	expirationdate => $expdate,	96	item => $item,
90	interface => 'staff',	97	expirationdate => $expdate,
91	});	98	interface => 'staff',
		99	}
		100	);
92	} else {	101	} else {
93	$error = 'cannot';	102	$error = 'cannot';
94	}	103	}
95	} else {	104	} else {
96	if ( $biblio->can_be_recalled({ patron => $patron }) ) {	105	if ( $biblio->can_be_recalled( { patron => $patron } ) ) {
97	( $recall, $due_interval, $due_date ) = Koha::Recalls->add_recall({	106	( $recall, $due_interval, $due_date ) = Koha::Recalls->add_recall(
98	patron => $patron,	107	{
99	biblio => $biblio,	108	patron => $patron,
100	branchcode => $pickuploc,	109	biblio => $biblio,
101	expirationdate => $expdate,	110	branchcode => $pickuploc,
102	interface => 'staff',	111	expirationdate => $expdate,
103	});	112	interface => 'staff',
		113	}
		114	);
104	} else {	115	} else {
105	$error = 'cannot';	116	$error = 'cannot';
106	}	117	}
Lines 108-113 elsif ( $op eq 'cud-request' ) { Link Here
108	if ( !defined $recall ) {	119	if ( !defined $recall ) {
109	$error = 'failed';	120	$error = 'failed';
110	} else {	121	} else {
		122
111	# successful recall, go back to Recalls tab	123	# successful recall, go back to Recalls tab
112	print $input->redirect("/cgi-bin/koha/recalls/request.pl?biblionumber=$biblionumber");	124	print $input->redirect("/cgi-bin/koha/recalls/request.pl?biblionumber=$biblionumber");
113	}	125	}
Lines 115-152 elsif ( $op eq 'cud-request' ) { Link Here
115	}	127	}
116	}	128	}
117		129
118	if ( $borrowernumber ) {	130	if ($borrowernumber) {
119	my $patron = Koha::Patrons->find( $borrowernumber );	131	my $patron = Koha::Patrons->find($borrowernumber);
120		132
121	if ( C4::Context->preference('UseRecalls') and C4::Context->preference('RecallsInterface') ne 'opac' and $patron and $patron->borrowernumber ) {	133	if ( C4::Context->preference('UseRecalls')
122	if ( !$biblio->can_be_recalled({ patron => $patron }) ) {	134	and C4::Context->preference('RecallsInterface') ne 'opac'
		135	and $patron
		136	and $patron->borrowernumber )
		137	{
		138	if ( !$biblio->can_be_recalled( { patron => $patron } ) ) {
123	$error = 1;	139	$error = 1;
124	}	140	}
125	my $patron_holds_count = Koha::Holds->search({ borrowernumber => $borrowernumber, biblionumber => $biblio->biblionumber, item_level_hold => 0 })->count;	141	my $patron_holds_count = Koha::Holds->search(
		142	{ borrowernumber => $borrowernumber, biblionumber => $biblio->biblionumber, item_level_hold => 0 } )->count;
126		143
127	$template->param(	144	$template->param(
128	patron => $patron,	145	patron => $patron,
129	patron_holds_count => $patron_holds_count,	146	patron_holds_count => $patron_holds_count,
130	);	147	);
131	}	148	}
132	}	149	}
133		150
134	my $recalls = Koha::Recalls->search({ biblio_id => $biblionumber, completed => 0 });	151	my $recalls = Koha::Recalls->search( { biblio_id => $biblionumber, completed => 0 } );
135	my $branches = Koha::Libraries->search;	152	my $branches = Koha::Libraries->search;
136	my $single_branch_mode = $branches->count == 1;	153	my $single_branch_mode = $branches->count == 1;
137	my $items = Koha::Items->search({ biblionumber => $biblionumber });	154	my $items = Koha::Items->search( { biblionumber => $biblionumber } );
138		155
139	$template->param(	156	$template->param(
140	recalls => $recalls,	157	recalls => $recalls,
141	recallsview => 1,	158	recallsview => 1,
142	biblio => $biblio,	159	biblio => $biblio,
143	checkboxes => 1,	160	checkboxes => 1,
144	branches => $branches,	161	branches => $branches,
145	items => $items,	162	items => $items,
146	error => $error,	163	error => $error,
147	single_branch_mode => $single_branch_mode,	164	single_branch_mode => $single_branch_mode,
148	C4::Search::enabled_staff_search_views,	165	C4::Search::enabled_staff_search_views,
149	attribute_type_codes => ( C4::Context->preference('ExtendedPatronAttributes')	166	attribute_type_codes => (
		167	C4::Context->preference('ExtendedPatronAttributes')
150	? [ Koha::Patron::Attribute::Types->search( { staff_searchable => 1 } )->get_column('code') ]	168	? [ Koha::Patron::Attribute::Types->search( { staff_searchable => 1 } )->get_column('code') ]
151	: []	169	: []
152	),	170	),