$needsconfirmation{resreserveid} = $res->{reserve_id};

                    $needsconfirmation{resreserveid} = $res->{reserve_id};

        my $now = dt_from_string();

        my $preventChechoutOnSameReservePeriod =

            C4::Context->preference("PreventChechoutOnSameReservePeriod");

        my $reserves_on_same_period =

            ReservesOnSamePeriod($item->{biblionumber}, $item->{itemnumber}, $now->ymd, $duedate->ymd);

        if ($preventChechoutOnSameReservePeriod && $reserves_on_same_period) {

            my $reserve = $reserves_on_same_period->[0];

            my $borrower = C4::Members::GetMember(borrowernumber => $reserve->{borrowernumber});

            my $branchname = GetBranchName( $reserve->{branchcode} );

            $needsconfirmation{RESERVED} = 1;

            $needsconfirmation{resfirstname} = $borrower->{firstname};

            $needsconfirmation{ressurname} = $borrower->{surname};

            $needsconfirmation{rescardnumber} = $borrower->{cardnumber};

            $needsconfirmation{resborrowernumber} = $borrower->{borrowernumber};

            $needsconfirmation{resbranchname} = $branchname;

            $needsconfirmation{resreservedate} = $reserve->{reservedate};

            $needsconfirmation{resreserveid} = $reserve->{reserve_id};

        }

		&ReservesOnSamePeriod

=head2 ReservesOnSamePeriod

    my $reserve = ReservesOnSamePeriod( $biblionumber, $itemnumber, $resdate, $expdate);

    Return the reserve that match the period ($resdate => $expdate),

    undef if no reserve match.

=cut

sub ReservesOnSamePeriod {

    my ($biblionumber, $itemnumber, $resdate, $expdate) = @_;

    unless ($resdate && $expdate) {

        return;

    }

    my $reserves = GetReservesFromBiblionumber({biblionumber => $biblionumber,

                                                all_dates => 1});

    $resdate = output_pref({ str => $resdate, dateonly => 1, dateformat => 'iso' });

    $expdate = output_pref({ str => $expdate, dateonly => 1, dateformat => 'iso' });

    my @reserves_overlaps;

    foreach my $reserve (@$reserves) {

        unless ($reserve->{reservedate} && $reserve->{expirationdate}) {

            next;

        }

        if (date_ranges_overlap($resdate, $expdate,

                                $reserve->{reservedate},

                                $reserve->{expirationdate})) {

            # If reserve is item level and the requested periods overlap.

            if ($itemnumber && $reserve->{itemnumber} == $itemnumber ) {

                return [$reserve];

            }

            push @reserves_overlaps, $reserve;

        }

    }

    if (@reserves_overlaps >= GetItemsCount($biblionumber)) {

        return \@reserves_overlaps;

    }

    return;

}

=head2 date_ranges_overlap

    $bool = date_ranges_overlap($start1, $end1, $start2, $end2);

    Tells if first range ($start1 => $end1) overlaps

    the second one ($start2 => $end2)

=cut

sub date_ranges_overlap {

    my ($start1, $end1, $start2, $end2) = @_;

    $start1 = dt_from_string( $start1, 'iso' );

    $end1 = dt_from_string( $end1, 'iso' );

    $start2 = dt_from_string( $start2, 'iso' );

    $end2 = dt_from_string( $end2, 'iso' );

    if (

        # Start of range 2 is in the range 1.

        (

            DateTime->compare($start2, $start1) >= 0

            && DateTime->compare($start2, $end1) <= 0

        )

        ||

        # End of range 2 is in the range 1.

        (

            DateTime->compare($end2, $start1) >= 0

            && DateTime->compare($end2, $end1) <= 0

        )

        ||

        # Range 2 start before and end after range 1.

        (

            DateTime->compare($start2, $start1) < 0

            && DateTime->compare($end2, $end1) > 0

        )

    ) {

        return 1;

    }

    return;

}

            if ( $cancelreserve eq 'cancel' ) {

                CancelReserve({ reserve_id => $query->param('reserveid') });

            }

            $cancelreserve = $cancelreserve eq 'revert' ? 'revert' : undef;

INSERT IGNORE INTO systempreferences (variable,value,explanation,options,type) VALUES ('PreventChechoutOnSameReservePeriod', '0', 'Prevent to checkout a document if a reserve on same period exists', NULL, 'YesNo');

INSERT IGNORE INTO systempreferences (variable,value,explanation,options,type) VALUES ('PreventReservesOnSamePeriod', '0', 'Prevent to hold a document if a reserve on same period exists', NULL, 'YesNo');

        -

            - pref: PreventChechoutOnSameReservePeriod

              choices:

                  yes: Do

                  no: "Don't"

            - If yes, checkouts periods can't overlap with a reserve period.

        -

            - pref: PreventReservesOnSamePeriod

              choices:

                  yes: Do

                  no: "Don't"

            - If yes, Reserves periods for the same document can't overlap.

    <input type="hidden" name="reserveid" value="[% resreserveid %]" />

    <input type="hidden" name="reserveid" value="[% resreserveid %]" />

[% INCLUDE 'doc-head-open.inc' %]

    <title>Koha &rsaquo; Circulation &rsaquo; Holds &rsaquo; Confirm holds</title>

[% INCLUDE 'doc-head-close.inc' %]

</head>

<body id="circ_placerequest" class="catalog">

[% INCLUDE 'header.inc' %]

[% INCLUDE 'circ-search.inc' %]

<div id="breadcrumbs">

  <a href="/cgi-bin/koha/mainpage.pl">Home</a>

  ›

  <a href="/cgi-bin/koha/catalogue/search.pl">Catalog</a>

  ›

  Confirm holds

</div>

<div id="doc3" class="yui-t2">

  <div id="bd">

    <div id="yui-main">

      <div class="yui-b">

        <h1>Confirm holds</h1>

        <div class="alert">

          <p>

            Some of the reserves you are trying to do overlaps with existing reserves.

            Please confirm you want to proceed.

          </p>

        </div>

        <form method="post">

          <input type="hidden" name="borrowernumber" value="[% borrowernumber %]">

          [% IF multi_hold %]

            <input type="hidden" name="biblionumbers" value="[% biblionumbers%]">

            <input type="hidden" name="multi_hold" value="1">

          [% ELSE %]

            <input type="hidden" name="biblionumber" value="[% biblionumber%]">

          [% END %]

          <input type="hidden" name="reserve_date" value="[% reserve_date %]">

          <input type="hidden" name="expiration_date" value="[% expiration_date %]">

          <input type="hidden" name="pickup" value="[% pickup%]">

          <input type="hidden" name="notes" value="[% notes %]">

          <input type="hidden" name="confirm" value="1">

          [% FOREACH biblionumber IN overlap_reserves.keys %]

            [% input_id = "confirm_$biblionumber" %]

            <div>

              <input type="hidden" name="rank_[% biblionumber %]" value="[% overlap_reserves.$biblionumber.rank %]">

              [% IF (overlap_reserves.$biblionumber.checkitem) %]

                <input type="hidden" name="checkitem" value="[% overlap_reserves.$biblionumber.checkitem%]">

              [% END %]

              <input type="checkbox" name="confirm_biblionumbers" id="[% input_id %]"

                     value="[% biblionumber %]">

              <label for="[% input_id %]">Confirm hold for [% overlap_reserves.$biblionumber.title %]</label>

            </div>

          [% END %]

          <input type="submit" value="Continue">

        </form>

      </div>

    </div>

  </div>

[% INCLUDE 'intranet-bottom.inc' %]

        if ($canreserve) {

            if (C4::Context->preference("PreventReservesOnSamePeriod") &&

                ReservesOnSamePeriod($biblioNum, $itemNum, $startdate, $expiration_date)) {

                $canreserve = 0;

                $failed_holds++;

            }

        }

my $borrower=GetMember('borrowernumber'=>$borrowernumber);

unless ($borrower) {

    print $input->header();

    print "Invalid borrower number please try again";

    exit;

}

    my ($reserve_title, $reserve_rank);

    if ($multi_hold) {

        my $bibinfo = $bibinfos{$biblionumber};

        $reserve_rank = $bibinfo->{rank};

        $reserve_title = $bibinfo->{title};

    } else {

        $reserve_rank = $rank[0];

        $reserve_title = $title;

    }

    if (!$confirm &&

        ReservesOnSamePeriod($biblionumber, $checkitem, $startdate, $expirationdate) &&

        C4::Context->preference("PreventReservesOnSamePeriod")) {

        $overlap_reserves->{$biblionumber} = {

            title => $reserve_title ,

            checkitem => $checkitem,

            rank => $reserve_rank

        };

        next;

    }

    AddReserve($branch, $borrower->{'borrowernumber'}, $biblionumber, undef,

        $reserve_rank, $startdate, $expirationdate, $notes, $reserve_title,

        $checkitem, $found);

}

if (scalar keys %$overlap_reserves) {

    $template->param(

        borrowernumber => $borrowernumber,

        biblionumbers => $biblionumbers,

        biblionumber => $biblionumber,

        overlap_reserves => $overlap_reserves,

        reserve_date => $startdate,

        expiration_date => $expirationdate,

        notes => $notes,

        rank_request => \@rank,

        pickup => $branch,

        multi_hold => $multi_hold,

    );

    output_html_with_http_headers $input, $cookie, $template->output;

} else {

#!/usr/bin/env perl

# 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 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, see <http://www.gnu.org/licenses>.

use Modern::Perl;

use Test::More tests => 1;

use C4::Members;

use C4::Reserves;

use C4::Circulation;

use C4::Branch;

use Koha::DateUtils;

use t::lib::TestBuilder;

my $schema  = Koha::Database->new->schema;

$schema->storage->txn_begin;

my $builder = t::lib::TestBuilder->new();

subtest 'Tests for CanBookBeIssued with overlap reserves' => sub {

    plan tests => 6;

    my $categorycode = $builder->build({ source => 'Category' })->{ categorycode };

    my $branchcode = $builder->build({ source => 'Branch' })->{ branchcode };

    my $borrower = $builder->build({

        source => 'Borrower',

        value => {

            branchcode   => $branchcode,

            categorycode => $categorycode,

        }

    });

    my $borrowernumber = $borrower->{borrowernumber};

    $borrower = GetMemberDetails($borrowernumber);

    my $biblio = $builder->build({source => 'Biblio'});

    my $biblioitem = $builder->build({

        source => 'Biblioitem',

        value => {

            biblionumber => $biblio->{biblionumber},

        },

    });

    my $item = $builder->build({

        source => 'Item',

        value => {

            biblionumber => $biblio->{biblionumber},

            biblioitemnumber => $biblioitem->{biblioitemnumber},

            withdrawn => 0,

            itemlost => 0,

            notforloan => 0,

        },

    });

    my $startdate = dt_from_string();

    $startdate->add_duration(DateTime::Duration->new(days => 4));

    my $expdate = $startdate->clone();

    $expdate->add_duration(DateTime::Duration->new(days => 10));

    my $reserveid = AddReserve($branchcode, $borrowernumber,

        $item->{biblionumber}, undef,  1, $startdate->ymd(), $expdate->ymd,

        undef, undef, undef, undef);

    my $non_overlap_duedate = dt_from_string();

    $non_overlap_duedate->add_duration(DateTime::Duration->new(days => 2));

    my ($error, $question, $alerts ) =

        CanBookBeIssued($borrower, $item->{barcode}, $non_overlap_duedate, 1, 0);

    is_deeply($error, {}, "");

    is_deeply($question, {}, "");

    is_deeply($alerts, {}, "");

    my $overlap_duedate = dt_from_string();

    $overlap_duedate->add_duration(DateTime::Duration->new(days => 5));

    ($error, $question, $alerts ) =

        CanBookBeIssued($borrower, $item->{barcode}, $overlap_duedate, 1, 0);

    is_deeply($error, {}, "");

    my $expected = {

        RESERVED => 1,

        resfirstname => $borrower->{firstname},

        ressurname => $borrower->{surname},

        rescardnumber => $borrower->{cardnumber},

        resborrowernumber => $borrower->{borrowernumber},

        resbranchname => GetBranchName($branchcode),

        resreservedate => $startdate->ymd,

        resreserveid => $reserveid,

    };

    is_deeply($question, $expected, "");

    is_deeply($alerts, {}, "");

};

$schema->storage->txn_rollback;