Attachment #14863 for bug #9394

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

Lines 439-445 sub DelBiblio { Link Here

(-)a/C4/Biblio.pm (-1 / +1 lines)
439	require C4::Reserves;	439	require C4::Reserves;
440	my ($count, $reserves) = C4::Reserves::GetReservesFromBiblionumber($biblionumber);	440	my ($count, $reserves) = C4::Reserves::GetReservesFromBiblionumber($biblionumber);
441	foreach my $res ( @$reserves ) {	441	foreach my $res ( @$reserves ) {
442	C4::Reserves::CancelReserve( $res->{'biblionumber'}, $res->{'itemnumber'}, $res->{'borrowernumber'} );	442	C4::Reserves::CancelReserve({ reserve_id => $res->{'reserve_id'} });
443	}	443	}
444		444
445	# Delete in Zebra. Be careful NOT to move this line after _koha_delete_biblio	445	# Delete in Zebra. Be careful NOT to move this line after _koha_delete_biblio

Lines 762-768 sub CancelHold { Link Here

(-)a/C4/ILSDI/Services.pm (-1 / +1 lines)
762	return { code => 'NotCanceled' } unless any { $itemnumber eq $_ } @reserveditems;	762	return { code => 'NotCanceled' } unless any { $itemnumber eq $_ } @reserveditems;
763		763
764	# Cancel the reserve	764	# Cancel the reserve
765	CancelReserve( $itemnumber, undef, $borrowernumber );	765	CancelReserve({ itemnumber => $itemnumber, borrowernumber => $borrowernumber });
766		766
767	return { code => 'Canceled' };	767	return { code => 'Canceled' };
768	}	768	}




    @ISA = qw(Exporter);
    @EXPORT = qw(
        &AddReserve

        &GetReserve
        &GetReservesFromItemnumber
        &GetReservesFromBiblionumber
        &GetReservesFromBorrowernumber

    return;     # FIXME: why not have a useful return value?
}

=head2 GetReserve

    $res = GetReserve( $reserve_id );

=cut

sub GetReserve {
    my ($reserve_id) = @_;
    #warn "C4::Reserves::GetReserve( $reserve_id )";

    my $dbh = C4::Context->dbh;
    my $query = "SELECT * FROM reserves WHERE reserve_id = ?";
    my $sth = $dbh->prepare( $query );
    $sth->execute( $reserve_id );
    my $res = $sth->fetchrow_hashref();
    return $res;
}

=head2 GetReservesFromBiblionumber

  ($count, $title_reserves) = GetReservesFromBiblionumber($biblionumber);

This function gets the list of reservations for one C<$biblionumber>, returning a count
of the reserves and an arrayref pointing to the reserves for C<$biblionumber>.


    # Find the desired items in the reserves
    my $query = "
        SELECT  reserve_id,
                branchcode,
                timestamp AS rtimestamp,
                priority,
                biblionumber,


=head2 GetReservesFromItemnumber

 ( $reservedate, $borrowernumber, $branchcode, $reserve_id ) = GetReservesFromItemnumber($itemnumber);

TODO :: Description here


    my ( $itemnumber, $all_dates ) = @_;
    my $dbh   = C4::Context->dbh;
    my $query = "
    SELECT reservedate,borrowernumber,branchcode,reserve_id
    FROM   reserves
    WHERE  itemnumber=?
    ";

    }
    my $sth_res = $dbh->prepare($query);
    $sth_res->execute($itemnumber);
    my ( $reservedate, $borrowernumber, $branchcode, $reserve_id ) = $sth_res->fetchrow_array;
    return ( $reservedate, $borrowernumber, $branchcode, $reserve_id );
}

=head2 GetReservesFromBorrowernumber


    my $dbh = C4::Context->dbh;

    my $query = "
        SELECT COUNT(*) AS counter
        FROM reserves
        WHERE borrowernumber = ?
    ";
    my $sth = $dbh->prepare($query);
    $sth->execute($borrowernumber);
    my $row = $sth->fetchrow_hashref;

            #minus priorities of others reservs
            ModReserveMinusPriority(
                $itemnumber,
                $checkreserves->{'reserve_id'},
                $iteminfo->{'biblionumber'}
            );

            #launch the subroutine dotransfer

            $messages->{'waiting'} = 1;
            ModReserveMinusPriority(
                $itemnumber,
                $checkreserves->{'reserve_id'},
                $iteminfo->{'biblionumber'}
            );
            ModReserveStatus($itemnumber,'W');
        }

    my ( $frombranch ) = @_;
    my $dbh = C4::Context->dbh;
    my $sth = $dbh->prepare(
        "SELECT reserve_id,borrowernumber,reservedate,itemnumber,timestamp
         FROM reserves 
         WHERE priority='0' 
           AND branchcode=?"


sub GetReservesForBranch {
    my ($frombranch) = @_;
    my $dbh = C4::Context->dbh;

    my $query = "
        SELECT reserve_id,borrowernumber,reservedate,itemnumber,waitingdate
        FROM   reserves 
        WHERE   priority='0'
        AND found='W'
    ";
    $query .= " AND branchcode=? " if ( $frombranch );
	}
    $query .= "ORDER BY waitingdate" ;

    my $sth = $dbh->prepare($query);
    if ($frombranch){
     $sth->execute($frombranch);
    } else {
        $sth->execute();
    }

    my @transreserv;
    my $i = 0;
    while ( my $data = $sth->fetchrow_hashref ) {

    return (@transreserv);
}

## FIXME: I don't think this does what it thinks it does.
## It only ever checks the first reserve result, even though
## multiple reserves for that bib can have the itemnumber set
## the sub is only used once in the codebase.
sub GetReserveStatus {
    my ($itemnumber) = @_;
    

    $sth->execute();

    while ( my $res = $sth->fetchrow_hashref() ) {
        CancelReserve({ reserve_id => $res->{'reserve_id'} });
    }
  
    # Cancel reserves that have been waiting too long

                manualinvoice($res->{'borrowernumber'}, $res->{'itemnumber'}, 'Hold waiting too long', 'F', $charge);
            }

            CancelReserve({ reserve_id => $res->{'reserve_id'} });
        }
    }



=head2 CancelReserve

  CancelReserve({ reserve_id => $reserve_id, [ biblionumber => $biblionumber, borrowernumber => $borrrowernumber, itemnumber => $itemnumber ] });

Cancels a reserve.

=cut
cancel, but not both: if both are given, C<&CancelReserve> uses
C<$itemnumber>.

sub CancelReserve {
    my ( $params ) = @_;

    my $reserve_id = $params->{'reserve_id'};
    $reserve_id = GetReserveId( $params ) unless ( $reserve_id );

    return unless ( $reserve_id );

sub CancelReserve {
    my ( $biblio, $item, $borr ) = @_;
    my $dbh = C4::Context->dbh;
        if ( $item and $borr ) {
        # removing a waiting reserve record....
        # update the database...
        my $query = "
            UPDATE reserves
            SET    cancellationdate = now(),
                   found            = Null,
                   priority         = 0
            WHERE  itemnumber       = ?
             AND   borrowernumber   = ?
        ";
        my $sth = $dbh->prepare($query);
        $sth->execute( $item, $borr );
        $sth->finish;
        $query = "
            INSERT INTO old_reserves
            SELECT * FROM reserves
            WHERE  itemnumber       = ?
             AND   borrowernumber   = ?
        ";
        $sth = $dbh->prepare($query);
        $sth->execute( $item, $borr );
        $query = "
            DELETE FROM reserves
            WHERE  itemnumber       = ?
             AND   borrowernumber   = ?
        ";
        $sth = $dbh->prepare($query);
        $sth->execute( $item, $borr );
    }
    else {
        # removing a reserve record....
        # get the prioritiy on this record....
        my $priority;
        my $query = qq/
            SELECT priority FROM reserves
            WHERE biblionumber   = ?
              AND borrowernumber = ?
              AND cancellationdate IS NULL
              AND itemnumber IS NULL
        /;
        my $sth = $dbh->prepare($query);
        $sth->execute( $biblio, $borr );
        ($priority) = $sth->fetchrow_array;
        $sth->finish;
        $query = qq/
            UPDATE reserves
            SET    cancellationdate = now(),
                   found            = Null,
                   priority         = 0
            WHERE  biblionumber     = ?
              AND  borrowernumber   = ?
        /;

        # update the database, removing the record...
        $sth = $dbh->prepare($query);
        $sth->execute( $biblio, $borr );
        $sth->finish;

    my $query = "
        UPDATE reserves
        SET    cancellationdate = now(),
               found            = Null,
               priority         = 0
        WHERE  reserve_id = ?
    ";
    my $sth = $dbh->prepare($query);
    $sth->execute( $reserve_id );
    $sth->finish;

    $query = "
        INSERT INTO old_reserves
        SELECT * FROM reserves
        WHERE  reserve_id = ?
    ";
    $sth = $dbh->prepare($query);
    $sth->execute( $reserve_id );

    $query = "
        DELETE FROM reserves
        WHERE  reserve_id = ?
    ";
    $sth = $dbh->prepare($query);
    $sth->execute( $reserve_id );

    # now fix the priority on the others....
    _FixPriority( $reserve_id );
}

=head2 ModReserve

  ModReserve({ rank => $rank,
               reserve_id => $reserve_id,
               branchcode => $branchcode
               [, itemnumber => $itemnumber ]
               [, biblionumber => $biblionumber, $borrowernumber => $borrowernumber ]
              });

Change a hold request's priority or cancel it.


=cut

sub ModReserve {
    my ( $params ) = @_;

    my $rank = $params->{'rank'};
    my $reserve_id = $params->{'reserve_id'};
    my $branchcode = $params->{'branchcode'};
    my $itemnumber = $params->{'itemnumber'};
    my $suspend_until = $params->{'suspend_until'};
    my $borrowernumber = $params->{'borrowernumber'};
    my $biblionumber = $params->{'biblionumber'};

    return if $rank eq "W";
    return if $rank eq "n";

    return unless ( $reserve_id || ( $borrowernumber && ( $biblionumber || $itemnumber ) ) );
    $reserve_id = GetReserveId({ biblionumber => $biblionumber, borrowernumber => $borrowernumber, itemnumber => $itemnumber }) unless ( $reserve_id );

    my $dbh = C4::Context->dbh;
    if ( $rank eq "del" ) {
        my $query = "
            UPDATE reserves
            SET    cancellationdate=now()
            WHERE  reserve_id = ?
        ";
        /;
        my $sth = $dbh->prepare($query);
        $sth->execute( $reserve_id );
        $sth->finish;
        $query = "
            INSERT INTO old_reserves
            SELECT *
            FROM   reserves 
            WHERE  reserve_id = ?
        ";
        /;
        $sth = $dbh->prepare($query);
        $sth->execute( $reserve_id );
        $query = "
            DELETE FROM reserves 
            WHERE  reserve_id = ?
        ";
        /;
        $sth = $dbh->prepare($query);
        $sth->execute( $reserve_id );
        
    }
    elsif ($rank =~ /^\d+/ and $rank > 0) {
        my $query = "
            UPDATE reserves SET priority = ? ,branchcode = ?, itemnumber = ?, found = NULL, waitingdate = NULL
            WHERE reserve_id = ?
            AND borrowernumber = ?
        ";
        my $sth = $dbh->prepare($query);
        $sth->execute( $rank, $branchcode, $itemnumber, $reserve_id );
        $sth->finish;

        if ( defined( $suspend_until ) ) {
            if ( $suspend_until ) {
                $suspend_until = C4::Dates->new( $suspend_until )->output("iso");
                $dbh->do("UPDATE reserves SET suspend = 1, suspend_until = ? WHERE reserve_id = ?", undef, ( $suspend_until, $reserve_id ) );
            } else {
                $dbh->do("UPDATE reserves SET suspend_until = NULL WHERE reserve_id = ?", undef, ( $reserve_id ) );
            }
        }

        _FixPriority( $reserve_id, $rank );
    }
}


    my ($res) = @_;
    my $dbh = C4::Context->dbh;
    # fill in a reserve record....
    my $reserve_id = $res->{'reserve_id'};
    my $biblionumber = $res->{'biblionumber'};
    my $borrowernumber    = $res->{'borrowernumber'};
    my $resdate = $res->{'reservedate'};

    # now fix the priority on the others (if the priority wasn't
    # already sorted!)....
    unless ( $priority == 0 ) {
        _FixPriority( $reserve_id );
    }
}


    my ( $itemnumber, $borrowernumber ) = @_;

    #step 1 : cancel the reservation
    my $CancelReserve = CancelReserve({ itemnumber => $itemnumber, borrowernumber => $borrowernumber });

    #step 2 launch the subroutine of the others reserves
    ( $messages, $nextreservinfo ) = GetOtherReserves($itemnumber);


  &ModReserveMinusPriority($itemnumber,$borrowernumber,$biblionumber)

Reduce the values of queued list

=cut

sub ModReserveMinusPriority {
    my ( $itemnumber, $reserve_id ) = @_;

    #first step update the value of the first person on reserv
    my $dbh   = C4::Context->dbh;
    my $query = "
        UPDATE reserves
        SET    priority = 0 , itemnumber = ? 
        WHERE  reserve_id = ?
          AND  biblionumber=?
    ";
    my $sth_upd = $dbh->prepare($query);
    $sth_upd->execute( $itemnumber, $reserve_id );
    # second step update all others reservs
    _FixPriority( $reserve_id, '0');
}

=head2 GetReserveInfo

  &GetReserveInfo($reserve_id);

Get item and borrower details for a current hold.
Current implementation this query should have a single result.

=cut

sub GetReserveInfo {
    my ( $reserve_id ) = @_;
    my $dbh = C4::Context->dbh;
    my $strsth="SELECT
                   reserve_id,
                   reservedate, 
                   reservenotes, 
                   reserves.borrowernumber,
                   reserves.biblionumber, 
                   reserves.branchcode,
                   reserves.waitingdate,
                   notificationdate, 
                   reminderdate, 
                   priority, 
                   found,
                   firstname, 
                   surname, 
                   phone, 
                   email, 
                   address, 
                   address2,
                   cardnumber, 
                   city, 
                   zipcode,
                   biblio.title, 
                   biblio.author,
                   items.holdingbranch, 
                   items.itemcallnumber, 
                   items.itemnumber,
                   items.location, 
                   barcode, 
                   notes
                FROM reserves 
                LEFT JOIN items USING(itemnumber) 
                LEFT JOIN borrowers USING(borrowernumber)
                LEFT JOIN biblio ON  (reserves.biblionumber=biblio.biblionumber)
                WHERE reserves.reserve_id = ?";
    my $sth = $dbh->prepare($strsth);
    $sth->execute($reserve_id);
	$sth->execute($borrowernumber,$biblionumber);

	my $data = $sth->fetchrow_hashref;
	return $data;

    my $data = $sth->fetchrow_hashref;
    return $data;
}

=head2 IsAvailableForItemLevelRequest


=head2 AlterPriority

  AlterPriority( $where, $reserve_id );

This function changes a reserve's priority up, down, to the top, or to the bottom.
Input: $where is 'up', 'down', 'top' or 'bottom'. Biblionumber, Date reserve was placed

=cut

sub AlterPriority {
    my ( $where, $reserve_id ) = @_;

    my $dbh = C4::Context->dbh;

    my $reserve = GetReserve( $reserve_id );
    my $sth = $dbh->prepare('SELECT * FROM reserves WHERE biblionumber = ? AND borrowernumber = ? AND cancellationdate IS NULL');
    $sth->execute( $biblionumber, $borrowernumber );
    my $reserve = $sth->fetchrow_hashref();
    $sth->finish();

    if ( $where eq 'up' || $where eq 'down' ) {
    
      my $priority = $reserve->{'priority'};        
      $priority = $where eq 'up' ? $priority - 1 : $priority + 1;
      _FixPriority( $reserve_id, $priority )

    } elsif ( $where eq 'top' ) {

      _FixPriority( $reserve_id, '1' )

    } elsif ( $where eq 'bottom' ) {

      _FixPriority( $reserve_id, '999999' )

    }
}

=cut

sub ToggleLowestPriority {
    my ( $reserve_id ) = @_;

    my $dbh = C4::Context->dbh;

    my $sth = $dbh->prepare( "UPDATE reserves SET lowestPriority = NOT lowestPriority WHERE reserve_id = ?");
    $sth->execute( $reserve_id );
         WHERE biblionumber = ?
         AND borrowernumber = ?"
    );
    $sth->execute(
        $biblionumber,
        $borrowernumber,
    );
    $sth->finish;
    
    _FixPriority( $reserve_id, '999999' );
}

=head2 ToggleSuspend

  ToggleSuspend( $reserve_id );

This function sets the suspend field to true if is false, and false if it is true.
If the reserve is currently suspended with a suspend_until date, that date will

=cut

sub ToggleSuspend {
    my ( $reserve_id, $suspend_until ) = @_;

    $suspend_until = output_pref( dt_from_string( $suspend_until ), 'iso' ) if ( $suspend_until );


    my $sth = $dbh->prepare(
        "UPDATE reserves SET suspend = NOT suspend,
        suspend_until = CASE WHEN suspend = 0 THEN NULL ELSE $do_until END
        WHERE reserve_id = ?
        AND borrowernumber = ?
    ");

    my @params;
    push( @params, $suspend_until ) if ( $suspend_until );
    push( @params, $reserve_id );
    push( @params, $borrowernumber );

    $sth->execute( @params );
    $sth->finish;


=head2 _FixPriority

  &_FixPriority( $reserve_id, $rank, $ignoreSetLowestRank);

Only used internally (so don't export it)
Changed how this functions works #

=cut 

sub _FixPriority {
    my ( $reserve_id, $rank, $ignoreSetLowestRank ) = @_;
    my $dbh = C4::Context->dbh;

    my $res = GetReserve( $reserve_id );

    if ( $rank eq "del" ) {
         CancelReserve({ reserve_id => $reserve_id });
    }
    elsif ( $rank eq "W" || $rank eq "0" ) {

        # make sure priority for waiting or in-transit items is 0
        my $query = "
            UPDATE reserves
            SET    priority = 0
            WHERE reserve_id = ?
            AND found IN ('W', 'T')
        ";
        /;
        my $sth = $dbh->prepare($query);
        $sth->execute( $reserve_id );
    }
    my @priority;
    my @reservedates;

    # get whats left
    my $query = "
        SELECT reserve_id, borrowernumber, reservedate, constrainttype
	# This is wrong a waiting reserve has W set
	# The assumption that having an itemnumber set means waiting is wrong and should be corrected any place it occurs
    my $query = qq/
        SELECT borrowernumber, reservedate, constrainttype
        FROM   reserves
        WHERE  biblionumber   = ?
          AND  ((found <> 'W' AND found <> 'T') OR found IS NULL)
        ORDER BY priority ASC
    ";
    my $sth = $dbh->prepare($query);
    $sth->execute( $res->{'biblionumber'} );
    while ( my $line = $sth->fetchrow_hashref ) {
        push( @reservedates, $line );
        push( @priority,     $line );

    my $i;
    my $key = -1;    # to allow for 0 to be a valid result
    for ( $i = 0 ; $i < @priority ; $i++ ) {
        if ( $reserve_id == $priority[$i]->{'reserve_id'} ) {
            $key = $i;    # save the index
            last;
        }


    # now fix the priority on those that are left....
    $query = "
        UPDATE reserves
        SET    priority = ?
        WHERE  reserve_id = ?
                 AND borrowernumber   = ?
                 AND reservedate = ?
         AND found IS NULL
    ";
    $sth = $dbh->prepare($query);
    for ( my $j = 0 ; $j < @priority ; $j++ ) {
        $sth->execute(
            $j + 1,
            $priority[$j]->{'reserve_id'}
            $priority[$j]->{'reservedate'}
        );
        $sth->finish;
    }
    
    $sth = $dbh->prepare( "SELECT reserve_id FROM reserves WHERE lowestPriority = 1 ORDER BY priority" );
    $sth->execute();
    
    unless ( $ignoreSetLowestRank ) {
      while ( my $res = $sth->fetchrow_hashref() ) {
        _FixPriority( $res->{'reserve_id'}, '999999', 1 );
      }
    }
}

               reserves.priority            AS priority,
               reserves.timestamp           AS timestamp,
               biblioitems.biblioitemnumber AS biblioitemnumber,
               reserves.itemnumber          AS itemnumber,
               reserves.reserve_id          AS reserve_id,
        FROM reserves
        JOIN biblioitems USING (biblionumber)
        JOIN hold_fill_targets USING (biblionumber, borrowernumber, itemnumber)

            RevertWaitingStatus({ itemnumber => $itemnumber });
        }
        elsif ( $cancelreserve eq 'cancel' || $cancelreserve ) { # cancel reserves on this item
            CancelReserve({
                biblionumber   => $res->{'biblionumber'},
                itemnumber     => $res->{'itemnumber'},
                borrowernumber => $res->{'borrowernumber'}
            });
        }
    }
}

sub MergeHolds {
    my ( $dbh, $to_biblio, $from_biblio ) = @_;
    my $sth = $dbh->prepare(
        "SELECT count(*) as reserve_id FROM reserves WHERE biblionumber = ?"
    );
    $sth->execute($from_biblio);
    if ( my $data = $sth->fetchrow_hashref() ) {

    return $sth->execute( $reserve->{'reserve_id'} );
}

=head2 GetReserveId

  $reserve_id = GetReserveId({ biblionumber => $biblionumber, borrowernumber => $borrowernumber [, itemnumber => $itemnumber ] });

  Returnes the first reserve id that matches the given criteria

=cut

sub GetReserveId {
    my ( $params ) = @_;

    return unless ( ( $params->{'biblionumber'} || $params->{'itemnumber'} ) && $params->{'borrowernumber'} );

    my $dbh = C4::Context->dbh();

    my $sql = "SELECT reserve_id FROM reserves WHERE ";

    my @params;
    my @limits;
    foreach my $key ( keys %$params ) {
        if ( defined( $params->{$key} ) ) {
            push( @limits, "$key = ?" );
            push( @params, $params->{$key} );
        }
    }

    $sql .= join( " AND ", @limits );

    my $sth = $dbh->prepare( $sql );
    $sth->execute( @params );
    my $row = $sth->fetchrow_hashref();

    return $row->{'reserve_id'};
}

=head2 ReserveSlip

  ReserveSlip($branchcode, $borrowernumber, $biblionumber)




		return $self;
	}
	my $bib = GetBiblioFromItemNumber(undef, $self->{item}->id);

      CancelReserve({
            biblionumber   => $bib->{biblionumber},
        itemnumber     => $self->{item}->id,
           borrowernumber => $borrower->{borrowernumber}
      });

	$self->ok(1);
	return $self;
}

		return $self;
	}
	my $bibno = $bib->{biblionumber};
  ModReserve({ biblionumber => $bibno, borrowernumber => $borrower->{borrowernumber}, branchcode => $branch });

		# ModReserve needs to be fixed to maintain priority by iteself (Feb 2008)
	$self->ok(1);
	return $self;
}

1;
__END__

# 11 friggin arguments
AddReserve($branch,$borrowernumber,$biblionumber,$constraint,$bibitems,$priority,$startdate,$notes,$title,$checkitem,$found)

ModReserve($rank, $biblio, $borrower, $branch , $itemnumber)


Lines 80-86 my $ignoreRs = 0; Link Here

(-)a/circ/branchtransfers.pl (-2 / +8 lines)
80	# Deal with the requests....	80	# Deal with the requests....
81	if ( $request eq "KillWaiting" ) {	81	if ( $request eq "KillWaiting" ) {
82	my $item = $query->param('itemnumber');	82	my $item = $query->param('itemnumber');
83	CancelReserve( 0, $item, $borrowernumber );	83	CancelReserve({
		84	itemnumber => $item,
		85	borrowernumber => $borrowernumber
		86	});
84	$cancelled = 1;	87	$cancelled = 1;
85	$reqmessage = 1;	88	$reqmessage = 1;
86	}	89	}
Lines 93-99 elsif ( $request eq "SetWaiting" ) { Link Here
93	}	96	}
94	elsif ( $request eq 'KillReserved' ) {	97	elsif ( $request eq 'KillReserved' ) {
95	my $biblio = $query->param('biblionumber');	98	my $biblio = $query->param('biblionumber');
96	CancelReserve( $biblio, 0, $borrowernumber );	99	CancelReserve({
		100	biblionumber => $biblio,
		101	borrowernumber => $borrowernumber
		102	});
97	$cancelled = 1;	103	$cancelled = 1;
98	$reqmessage = 1;	104	$reqmessage = 1;
99	}	105	}

Lines 353-359 if ($borrowernumber) { Link Here

(-)a/circ/circulation.pl (-1 / +1 lines)
353	$getreserv{nottransfered} = 0;	353	$getreserv{nottransfered} = 0;
354		354
355	$getreserv{reservedate} = format_date( $num_res->{'reservedate'} );	355	$getreserv{reservedate} = format_date( $num_res->{'reservedate'} );
356	$getreserv{reservenumber} = $num_res->{'reservenumber'};	356	$getreserv{reserve_id} = $num_res->{'reserve_id'};
357	$getreserv{title} = $getiteminfo->{'title'};	357	$getreserv{title} = $getiteminfo->{'title'};
358	$getreserv{itemtype} = $itemtypeinfo->{'description'};	358	$getreserv{itemtype} = $itemtypeinfo->{'description'};
359	$getreserv{author} = $getiteminfo->{'author'};	359	$getreserv{author} = $getiteminfo->{'author'};




use C4::Reserves;
use C4::Auth;
my $query = new CGI;

my ( $template, $borrowernumber, $cookie ) = get_template_and_user(
    {   
        template_name   => "opac-account.tmpl",

    }
);

my $reserve_id = $query->param('reserve_id');

if ($reserve_id && $borrowernumber) {
  CancelReserve({ reserve_id => $reserve_id });
}

print $query->redirect("/cgi-bin/koha/opac-user.pl#opac-user-holds");




    }
);

my @reserve_id = $query->param('reserve_id');
my @rank = $query->param('rank-request');
my @biblionumber = $query->param('biblionumber');
my @borrower = $query->param('borrowernumber');
my @branch = $query->param('pickup');
my @itemnumber = $query->param('itemnumber');
my @suspend_until=$query->param('suspend_until');
my $multi_hold = $query->param('multi_hold');
my $biblionumbers = $query->param('biblionumbers');
my $count=@rank;

my $CancelBiblioNumber = $query->param('CancelBiblioNumber');
my $CancelBorrowerNumber = $query->param('CancelBorrowerNumber');
my $CancelItemnumber = $query->param('CancelItemnumber');

# 2 possibilitys : cancel an item reservation, or modify or cancel the queded list

# 1) cancel an item reservation by function ModReserveCancelAll (in reserves.pm)
if ($CancelBorrowerNumber) {
    ModReserveCancelAll($CancelItemnumber, $CancelBorrowerNumber);
    $biblionumber[0] = $CancelBiblioNumber,

else {
    for (my $i=0;$i<$count;$i++){
        undef $itemnumber[$i] unless $itemnumber[$i] ne '';
        ModReserve({
            rank => $rank[$i],
            reserve_id => $reserve_id[$i],
            branchcode => $branch[$i],
            itemnumber => $itemnumber[$i],
            suspend_until => $suspend_until[$i]
        });
    }
}

my $from=$query->param('from');
$from ||= q{};
if ( $from eq 'borrower'){





if ( $action eq 'move' ) {
  my $where = $input->param('where');
  my $reserve_id = $input->param('reserve_id');
  AlterPriority( $where, $reserve_id );
  AlterPriority( $where, $borrowernumber, $biblionumber );
} elsif ( $action eq 'cancel' ) {
  my $reserve_id = $input->param('reserve_id');
  CancelReserve({ reserve_id => $reserve_id });
  CancelReserve( $biblionumber, '', $borrowernumber );
} elsif ( $action eq 'setLowestPriority' ) {
  my $reserve_id = $input->param('reserve_id');
  ToggleLowestPriority( $reserve_id );
  ToggleLowestPriority( $borrowernumber, $biblionumber );
} elsif ( $action eq 'toggleSuspend' ) {
  my $reserve_id = $input->param('reserve_id');
  my $biblionumber   = $input->param('biblionumber');
  my $suspend_until  = $input->param('suspend_until');
  ToggleSuspend( $reserve_id, $suspend_until );
}

if ($findborrower) {

      GetReserveCount( $borrowerinfo->{'borrowernumber'} );

    if ( C4::Context->preference('maxreserves') && ($number_reserves >= C4::Context->preference('maxreserves')) ) {
       $warnings = 1;
        $maxreserves = 1;
    }



    # check if the borrower make the reserv in a different branch
    if ( $borrowerinfo->{'branchcode'} ne C4::Context->userenv->{'branch'} ) {
      $messages = 1;
        $diffbranch = 1;
    }


                maxreserves         => $maxreserves,
                expiry              => $expiry,
                diffbranch          => $diffbranch,
                messages            => $messages,
                warnings            => $warnings
    );
}



# FIXME launch another time GetMember perhaps until
my $borrowerinfo = GetMember( borrowernumber => $borrowernumber_hold );
my $max_holds_per_record = C4::Context->preference('MaxHoldsPerRecord');

my @biblionumbers = ();
my $biblionumbers = $input->param('biblionumbers');

foreach my $biblionumber (@biblionumbers) {

    my %biblioloopiter = ();
    my $maxreserves;

    my $dat = GetBiblioData($biblionumber);

    unless ( CanBookBeReserved($borrowerinfo->{borrowernumber}, $biblionumber) ) {
        $warnings = 1;
        $maxreserves = 1;
    }


    # get existing reserves .....
    my ( $count, $reserves ) = GetReservesFromBiblionumber($biblionumber,1);
    my $totalcount = $count;
    my $holds_count = 0;
    my $alreadyreserved = 0;

    foreach my $res (@$reserves) {
        if ( defined $res->{found} && $res->{found} eq 'W' ) {

        }

        if ( defined $borrowerinfo && ($borrowerinfo->{borrowernumber} eq $res->{borrowernumber}) ) {
            $holds_count++;
        }
    }

    if ( $holds_count >= $max_holds_per_record ) {
            $alreadyreserved = 1;
            $warnings = 1;
            $biblioloopiter{warn} = 1;
            $biblioloopiter{alreadyres} = 1;
        }
    }

    $template->param( alreadyreserved => $alreadyreserved,
        messages          => $messages,
        warnings          => $warnings,
        maxreserves       => $maxreserves,
        alreadypossession => $alreadypossession,
    );


    # FIXME think @optionloop, is maybe obsolete, or  must be switchable by a systeme preference fixed rank or not
    # make priorities options

    if (my $items = get_itemnumbers_of($biblionumber)->{$biblionumber}){
        @itemnumbers  = @$items;
    }
    my @hostitems = get_hostitemnumbers_of($biblionumber);
    if (@hostitems){
        $template->param('hostitemsflag' => 1);
        push(@itemnumbers, @hostitems);
    }

    if (!@itemnumbers) {
        $template->param('noitems' => 1);

            }

            # checking reserve
            my ($reservedate,$reservedfor,$expectedAt,$reserve_id) = GetReservesFromItemnumber($itemnumber);
            my $ItemBorrowerReserveInfo = GetMember( borrowernumber => $reservedfor );

            if ( defined $reservedate ) {

        $reserve{'optionloop'} = \@optionloop;
        $reserve{'suspend'} = $res->{'suspend'};
        $reserve{'suspend_until'} = $res->{'suspend_until'};
        $reserve{'reserve_id'} = $res->{'reserve_id'};

        push( @reserveloop, \%reserve );
    }


Lines 87-93 if($ok){ Link Here

(-)a/serials/routing-preview.pl (-1 / +6 lines)
87	my $reserve = $sth->fetchrow_hashref;	87	my $reserve = $sth->fetchrow_hashref;
88		88
89	if($routing->{borrowernumber} == $reserve->{borrowernumber}){	89	if($routing->{borrowernumber} == $reserve->{borrowernumber}){
90	ModReserve($routing->{ranking},$biblio,$routing->{borrowernumber},$branch);	90	ModReserve({
		91	rank => $routing->{ranking},
		92	biblionumber => $biblio,
		93	borrowernumber => $routing->{borrowernumber},
		94	branchcode => $branch
		95	});
91	} else {	96	} else {
92	AddReserve($branch,$routing->{borrowernumber},$biblio,$const,\@bibitems,$routing->{ranking}, undef, undef, $notes,$title);	97	AddReserve($branch,$routing->{borrowernumber},$biblio,$const,\@bibitems,$routing->{ranking}, undef, undef, $notes,$title);
93	}	98	}




#!/usr/bin/perl

use strict;
use warnings;
use C4::Branch;

use Test::More tests => 18;
use MARC::Record;
use C4::Biblio;
use C4::Items;

BEGIN {
	use FindBin;
	use lib $FindBin::Bin;
	use_ok('C4::Reserves');
}

my $borrowers_count = 5;

# Setup Test------------------------
# Helper biblio.
diag("Creating biblio instance for testing.");
my ($bibnum, $title, $bibitemnum) = create_helper_biblio();

# Helper item for that biblio.
diag("Creating item instance for testing.");
my ($item_bibnum, $item_bibitemnum, $itemnumber) = AddItem({ homebranch => 'CPL', holdingbranch => 'CPL' } , $bibnum);

# Get a borrower
my $dbh = C4::Context->dbh;
my $query = "SELECT borrowernumber FROM borrowers LIMIT $borrowers_count";
my $sth = $dbh->prepare($query);
$sth->execute;
my @borrowernumbers;
while ( my $row = $sth->fetchrow_hashref ) {
    push( @borrowernumbers, $row->{'borrowernumber'} );
}

my $biblionumber   = $bibnum;

my @branches = GetBranchesLoop();
my $branch = $branches[0][0]{value};

# Create five item level holds
foreach my $borrowernumber ( @borrowernumbers ) {
    AddReserve(
        $branch,
        $borrowernumber,
        $biblionumber,
        my $constraint = 'a',
        my $bibitems = q{},
        my $priority,
        my $resdate,
        my $expdate,
        my $notes = q{},
        $title,
        my $checkitem = $itemnumber,
        my $found,
    );
}
        

my ($count, $reserves) = GetReservesFromBiblionumber($biblionumber);
is( $count, $borrowers_count, "Test GetReserves()" );


my ( $reservedate, $borrowernumber, $branchcode, $reserve_id ) = GetReservesFromItemnumber($itemnumber);
ok($reserve_id, "Test GetReservesFromItemnumber()");


my ( $reserve ) = GetReservesFromBorrowernumber($borrowernumbers[0]);
ok( $reserve->{'borrowernumber'} eq $borrowernumbers[0], "Test GetReservesFromBorrowernumber()");


ok( GetReserveCount( $borrowernumbers[0] ), "Test GetReserveCount()" );


CancelReserve({ 'reserve_id' => $reserve_id });
($count, $reserves) = GetReservesFromBiblionumber($biblionumber);
ok( $count == $borrowers_count - 1, "Test CancelReserve()" );


( $reservedate, $borrowernumber, $branchcode, $reserve_id ) = GetReservesFromItemnumber($itemnumber);
ModReserve({
    reserve_id    => $reserve_id,
    rank          => '4',
    branchcode    => $branch,
    itemnumber    => $itemnumber,
    suspend_until => C4::Dates->new("2013-01-01","iso")->output(),
});
$reserve = GetReserve( $reserve_id );
ok( $reserve->{'priority'} eq '4', "Test GetReserve(), priority changed correctly" );
ok( $reserve->{'suspend'}, "Test GetReserve(), suspend hold" );
ok( $reserve->{'suspend_until'} eq '2013-01-01 00:00:00', "Test GetReserve(), suspend until date" );

ToggleSuspend( $reserve_id );
$reserve = GetReserve( $reserve_id );
ok( !$reserve->{'suspend'}, "Test ToggleSuspend(), no date" );

ToggleSuspend( $reserve_id, '2012-01-01' );
$reserve = GetReserve( $reserve_id );
ok( $reserve->{'suspend_until'} eq '2012-01-01 00:00:00', "Test ToggleSuspend(), with date" );

AutoUnsuspendReserves();
$reserve = GetReserve( $reserve_id );
ok( !$reserve->{'suspend'}, "Test AutoUnsuspendReserves()" );

# Add a new hold for the borrower whose hold we canceled earlier, this time at the bib level
AddReserve(
    $branch,
    $borrowernumber,
    $biblionumber,
    my $constraint = 'a',
    my $bibitems = q{},
    my $priority,
    my $resdate,
    my $expdate,
    my $notes = q{},
    $title,
    my $checkitem,
    my $found,
);
( $reserve ) = GetReservesFromBorrowernumber($borrowernumber);
ModReserveMinusPriority( $itemnumber, $reserve->{'reserve_id'} );
( $reserve ) = GetReservesFromBorrowernumber($borrowernumber);
ok( $reserve->{'itemnumber'} eq $itemnumber, "Test ModReserveMinusPriority()" );


my $reserve2 = GetReserveInfo( $reserve->{'reserve_id'} );
ok( $reserve->{'reserve_id'} eq $reserve2->{'reserve_id'}, "Test GetReserveInfo()" );


($count, $reserves) = GetReservesFromBiblionumber($biblionumber,1);
$reserve = $reserves->[1];
AlterPriority( 'top', $reserve->{'reserve_id'} );
$reserve = GetReserve( $reserve->{'reserve_id'} );
ok( $reserve->{'priority'} eq '1', "Test AlterPriority(), move to top" );

AlterPriority( 'down', $reserve->{'reserve_id'} );
$reserve = GetReserve( $reserve->{'reserve_id'} );
ok( $reserve->{'priority'} eq '2', "Test AlterPriority(), move down" );

AlterPriority( 'up', $reserve->{'reserve_id'} );
$reserve = GetReserve( $reserve->{'reserve_id'} );
ok( $reserve->{'priority'} eq '1', "Test AlterPriority(), move up" );

AlterPriority( 'bottom', $reserve->{'reserve_id'} );
$reserve = GetReserve( $reserve->{'reserve_id'} );
ok( $reserve->{'priority'} eq '5', "Test AlterPriority(), move to bottom" );

# Delete the reserves
diag("Deleting holds.");
$dbh->do("DELETE FROM reserves WHERE biblionumber = ?", undef, ( $biblionumber ) );

# Delete item.
diag("Deleting item testing instance.");
DelItem($dbh, $bibnum, $itemnumber);

# Delete helper Biblio.
diag("Deleting biblio testing instance.");
DelBiblio($bibnum);

# Helper method to set up a Biblio.
sub create_helper_biblio {
    my $bib = MARC::Record->new();
    my $title = 'Silence in the library';
    $bib->append_fields(
        MARC::Field->new('100', ' ', ' ', a => 'Moffat, Steven'),
        MARC::Field->new('245', ' ', ' ', a => $title),
    );
    return ($bibnum, $title, $bibitemnum) = AddBiblio($bib, '');
}

Return to bug 9394

Lines 99-120 $action \|\|= q{}; Link Here

(-)a/reserve/request.pl (-34 / +37 lines)
99		99
100	if ( $action eq 'move' ) {	100	if ( $action eq 'move' ) {
101	my $where = $input->param('where');	101	my $where = $input->param('where');
102	my $borrowernumber = $input->param('borrowernumber');	102	my $reserve_id = $input->param('reserve_id');
103	my $biblionumber = $input->param('biblionumber');	103	AlterPriority( $where, $reserve_id );
104	AlterPriority( $where, $borrowernumber, $biblionumber );
105	} elsif ( $action eq 'cancel' ) {	104	} elsif ( $action eq 'cancel' ) {
106	my $borrowernumber = $input->param('borrowernumber');	105	my $reserve_id = $input->param('reserve_id');
107	my $biblionumber = $input->param('biblionumber');	106	CancelReserve({ reserve_id => $reserve_id });
108	CancelReserve( $biblionumber, '', $borrowernumber );
109	} elsif ( $action eq 'setLowestPriority' ) {	107	} elsif ( $action eq 'setLowestPriority' ) {
110	my $borrowernumber = $input->param('borrowernumber');	108	my $reserve_id = $input->param('reserve_id');
111	my $biblionumber = $input->param('biblionumber');	109	ToggleLowestPriority( $reserve_id );
112	ToggleLowestPriority( $borrowernumber, $biblionumber );
113	} elsif ( $action eq 'toggleSuspend' ) {	110	} elsif ( $action eq 'toggleSuspend' ) {
114	my $borrowernumber = $input->param('borrowernumber');	111	my $reserve_id = $input->param('reserve_id');
115	my $biblionumber = $input->param('biblionumber');
116	my $suspend_until = $input->param('suspend_until');	112	my $suspend_until = $input->param('suspend_until');
117	ToggleSuspend( $borrowernumber, $biblionumber, $suspend_until );	113	ToggleSuspend( $reserve_id, $suspend_until );
118	}	114	}
119		115
120	if ($findborrower) {	116	if ($findborrower) {
Lines 148-154 if ($borrowernumber_hold && !$action) { Link Here
148	GetReserveCount( $borrowerinfo->{'borrowernumber'} );	144	GetReserveCount( $borrowerinfo->{'borrowernumber'} );
149		145
150	if ( C4::Context->preference('maxreserves') && ($number_reserves >= C4::Context->preference('maxreserves')) ) {	146	if ( C4::Context->preference('maxreserves') && ($number_reserves >= C4::Context->preference('maxreserves')) ) {
151	$warnings = 1;	147	$warnings = 1;
152	$maxreserves = 1;	148	$maxreserves = 1;
153	}	149	}
154		150
Lines 162-168 if ($borrowernumber_hold && !$action) { Link Here
162		158
163	# check if the borrower make the reserv in a different branch	159	# check if the borrower make the reserv in a different branch
164	if ( $borrowerinfo->{'branchcode'} ne C4::Context->userenv->{'branch'} ) {	160	if ( $borrowerinfo->{'branchcode'} ne C4::Context->userenv->{'branch'} ) {
165	$messages = 1;	161	$messages = 1;
166	$diffbranch = 1;	162	$diffbranch = 1;
167	}	163	}
168		164
Lines 184-191 if ($borrowernumber_hold && !$action) { Link Here
184	maxreserves => $maxreserves,	180	maxreserves => $maxreserves,
185	expiry => $expiry,	181	expiry => $expiry,
186	diffbranch => $diffbranch,	182	diffbranch => $diffbranch,
187	messages => $messages,	183	messages => $messages,
188	warnings => $warnings	184	warnings => $warnings
189	);	185	);
190	}	186	}
191		187
Lines 225-230 if ($borrowerslist) { Link Here
225		221
226	# FIXME launch another time GetMember perhaps until	222	# FIXME launch another time GetMember perhaps until
227	my $borrowerinfo = GetMember( borrowernumber => $borrowernumber_hold );	223	my $borrowerinfo = GetMember( borrowernumber => $borrowernumber_hold );
		224	my $max_holds_per_record = C4::Context->preference('MaxHoldsPerRecord');
228		225
229	my @biblionumbers = ();	226	my @biblionumbers = ();
230	my $biblionumbers = $input->param('biblionumbers');	227	my $biblionumbers = $input->param('biblionumbers');
Lines 239-250 my @biblioloop = (); Link Here
239	foreach my $biblionumber (@biblionumbers) {	236	foreach my $biblionumber (@biblionumbers) {
240		237
241	my %biblioloopiter = ();	238	my %biblioloopiter = ();
242	my $maxreserves;	239	my $maxreserves;
243		240
244	my $dat = GetBiblioData($biblionumber);	241	my $dat = GetBiblioData($biblionumber);
245		242
246	unless ( CanBookBeReserved($borrowerinfo->{borrowernumber}, $biblionumber) ) {	243	unless ( CanBookBeReserved($borrowerinfo->{borrowernumber}, $biblionumber) ) {
247	$warnings = 1;	244	$warnings = 1;
248	$maxreserves = 1;	245	$maxreserves = 1;
249	}	246	}
250		247
Lines 257-263 foreach my $biblionumber (@biblionumbers) { Link Here
257	# get existing reserves .....	254	# get existing reserves .....
258	my ( $count, $reserves ) = GetReservesFromBiblionumber($biblionumber,1);	255	my ( $count, $reserves ) = GetReservesFromBiblionumber($biblionumber,1);
259	my $totalcount = $count;	256	my $totalcount = $count;
260	my $alreadyreserved;	257	my $holds_count = 0;
		258	my $alreadyreserved = 0;
261		259
262	foreach my $res (@$reserves) {	260	foreach my $res (@$reserves) {
263	if ( defined $res->{found} && $res->{found} eq 'W' ) {	261	if ( defined $res->{found} && $res->{found} eq 'W' ) {
Lines 265-284 foreach my $biblionumber (@biblionumbers) { Link Here
265	}	263	}
266		264
267	if ( defined $borrowerinfo && ($borrowerinfo->{borrowernumber} eq $res->{borrowernumber}) ) {	265	if ( defined $borrowerinfo && ($borrowerinfo->{borrowernumber} eq $res->{borrowernumber}) ) {
268	$warnings = 1;	266	$holds_count++;
		267	}
		268	}
		269
		270	if ( $holds_count >= $max_holds_per_record ) {
269	$alreadyreserved = 1;	271	$alreadyreserved = 1;
		272	$warnings = 1;
270	$biblioloopiter{warn} = 1;	273	$biblioloopiter{warn} = 1;
271	$biblioloopiter{alreadyres} = 1;	274	$biblioloopiter{alreadyres} = 1;
272	}
273	}	275	}
274		276
275	$template->param( alreadyreserved => $alreadyreserved,	277	$template->param( alreadyreserved => $alreadyreserved,
276	messages => $messages,	278	messages => $messages,
277	warnings => $warnings,	279	warnings => $warnings,
278	maxreserves=>$maxreserves,	280	maxreserves => $maxreserves,
279	alreadypossession => $alreadypossession,	281	alreadypossession => $alreadypossession,
280	);	282	);
281
282		283
283	# FIXME think @optionloop, is maybe obsolete, or must be switchable by a systeme preference fixed rank or not	284	# FIXME think @optionloop, is maybe obsolete, or must be switchable by a systeme preference fixed rank or not
284	# make priorities options	285	# make priorities options
Lines 304-314 foreach my $biblionumber (@biblionumbers) { Link Here
304	if (my $items = get_itemnumbers_of($biblionumber)->{$biblionumber}){	305	if (my $items = get_itemnumbers_of($biblionumber)->{$biblionumber}){
305	@itemnumbers = @$items;	306	@itemnumbers = @$items;
306	}	307	}
307	my @hostitems = get_hostitemnumbers_of($biblionumber);	308	my @hostitems = get_hostitemnumbers_of($biblionumber);
308	if (@hostitems){	309	if (@hostitems){
309	$template->param('hostitemsflag' => 1);	310	$template->param('hostitemsflag' => 1);
310	push(@itemnumbers, @hostitems);	311	push(@itemnumbers, @hostitems);
311	}	312	}
312		313
313	if (!@itemnumbers) {	314	if (!@itemnumbers) {
314	$template->param('noitems' => 1);	315	$template->param('noitems' => 1);
Lines 386-392 foreach my $biblionumber (@biblionumbers) { Link Here
386	}	387	}
387		388
388	# checking reserve	389	# checking reserve
389	my ($reservedate,$reservedfor,$expectedAt) = GetReservesFromItemnumber($itemnumber);	390	my ($reservedate,$reservedfor,$expectedAt,$reserve_id) = GetReservesFromItemnumber($itemnumber);
390	my $ItemBorrowerReserveInfo = GetMember( borrowernumber => $reservedfor );	391	my $ItemBorrowerReserveInfo = GetMember( borrowernumber => $reservedfor );
391		392
392	if ( defined $reservedate ) {	393	if ( defined $reservedate ) {
Lines 583-588 foreach my $biblionumber (@biblionumbers) { Link Here
583	$reserve{'optionloop'} = \@optionloop;	584	$reserve{'optionloop'} = \@optionloop;
584	$reserve{'suspend'} = $res->{'suspend'};	585	$reserve{'suspend'} = $res->{'suspend'};
585	$reserve{'suspend_until'} = $res->{'suspend_until'};	586	$reserve{'suspend_until'} = $res->{'suspend_until'};
		587	$reserve{'reserve_id'} = $res->{'reserve_id'};
		588
586	push( @reserveloop, \%reserve );	589	push( @reserveloop, \%reserve );
587	}	590	}
588		591

Lines 85-94 sub drop_hold { Link Here

(-)a/C4/SIP/ILS/Transaction/Hold.pm (-13 / +10 lines)
85	return $self;	85	return $self;
86	}	86	}
87	my $bib = GetBiblioFromItemNumber(undef, $self->{item}->id);	87	my $bib = GetBiblioFromItemNumber(undef, $self->{item}->id);
88	# FIXME: figure out if it is a item or title hold. Till then, cancel both.	88
89	CancelReserve($bib->{biblionumber}, undef, $borrower->{borrowernumber});	89	CancelReserve({
90	CancelReserve(undef, $self->{item}->id, $borrower->{borrowernumber});	90	biblionumber => $bib->{biblionumber},
91	# unfortunately no meaningful return value here either	91	itemnumber => $self->{item}->id,
		92	borrowernumber => $borrower->{borrowernumber}
		93	});
		94
92	$self->ok(1);	95	$self->ok(1);
93	return $self;	96	return $self;
94	}	97	}
Lines 119-135 sub change_hold { Link Here
119	return $self;	122	return $self;
120	}	123	}
121	my $bibno = $bib->{biblionumber};	124	my $bibno = $bib->{biblionumber};
122	ModReserve($bibno, $borrower->{borrowernumber}, $branch, GetBiblioItemByBiblioNumber($bibno));	125	ModReserve({ biblionumber => $bibno, borrowernumber => $borrower->{borrowernumber}, branchcode => $branch });
123	# unfortunately no meaningful return value	126
124	# ModReserve needs to be fixed to maintain priority by iteself (Feb 2008)
125	$self->ok(1);	127	$self->ok(1);
126	return $self;	128	return $self;
127	}	129	}
		130
128	1;	131	1;
129	__END__	132	__END__
130
131	# 11 friggin arguments
132	AddReserve($branch,$borrowernumber,$biblionumber,$constraint,$bibitems,$priority,$startdate,$notes,$title,$checkitem,$found)
133
134	ModReserve($rank, $biblio, $borrower, $branch , $itemnumber)
135

Lines 30-35 use C4::Output; Link Here

(-)a/opac/opac-modrequest.pl (-3 / +6 lines)
30	use C4::Reserves;	30	use C4::Reserves;
31	use C4::Auth;	31	use C4::Auth;
32	my $query = new CGI;	32	my $query = new CGI;
		33
33	my ( $template, $borrowernumber, $cookie ) = get_template_and_user(	34	my ( $template, $borrowernumber, $cookie ) = get_template_and_user(
34	{	35	{
35	template_name => "opac-account.tmpl",	36	template_name => "opac-account.tmpl",
Lines 41-48 my ( $template, $borrowernumber, $cookie ) = get_template_and_user( Link Here
41	}	42	}
42	);	43	);
43		44
44	my $biblionumber = $query->param('biblionumber');	45	my $reserve_id = $query->param('reserve_id');
45	if ($biblionumber and $borrowernumber) {	46
46	CancelReserve($biblionumber, '', $borrowernumber);	47	if ($reserve_id && $borrowernumber) {
		48	CancelReserve({ reserve_id => $reserve_id });
47	}	49	}
		50
48	print $query->redirect("/cgi-bin/koha/opac-user.pl#opac-user-holds");	51	print $query->redirect("/cgi-bin/koha/opac-user.pl#opac-user-holds");

Lines 41-63 my ( $template, $loggedinuser, $cookie ) = get_template_and_user( Link Here

(-)a/reserve/modrequest.pl (-10 / +18 lines)
41	}	41	}
42	);	42	);
43		43
44	my @rank=$query->param('rank-request');	44	my @reserve_id = $query->param('reserve_id');
45	my @biblionumber=$query->param('biblionumber');	45	my @rank = $query->param('rank-request');
46	my @borrower=$query->param('borrowernumber');	46	my @biblionumber = $query->param('biblionumber');
47	my @branch=$query->param('pickup');	47	my @borrower = $query->param('borrowernumber');
48	my @itemnumber=$query->param('itemnumber');	48	my @branch = $query->param('pickup');
		49	my @itemnumber = $query->param('itemnumber');
49	my @suspend_until=$query->param('suspend_until');	50	my @suspend_until=$query->param('suspend_until');
50	my $multi_hold = $query->param('multi_hold');	51	my $multi_hold = $query->param('multi_hold');
51	my $biblionumbers = $query->param('biblionumbers');	52	my $biblionumbers = $query->param('biblionumbers');
52	my $count=@rank;	53	my $count=@rank;
53		54
54	my $CancelBiblioNumber=$query->param('CancelBiblioNumber');	55	my $CancelBiblioNumber = $query->param('CancelBiblioNumber');
55	my $CancelBorrowerNumber=$query->param('CancelBorrowerNumber');	56	my $CancelBorrowerNumber = $query->param('CancelBorrowerNumber');
56	my $CancelItemnumber=$query->param('CancelItemnumber');	57	my $CancelItemnumber = $query->param('CancelItemnumber');
57		58
58	# 2 possibilitys : cancel an item reservation, or modify or cancel the queded list	59	# 2 possibilitys : cancel an item reservation, or modify or cancel the queded list
59		60
60	# 1) cancel an item reservation by fonction ModReserveCancelAll (in reserves.pm)	61	# 1) cancel an item reservation by function ModReserveCancelAll (in reserves.pm)
61	if ($CancelBorrowerNumber) {	62	if ($CancelBorrowerNumber) {
62	ModReserveCancelAll($CancelItemnumber, $CancelBorrowerNumber);	63	ModReserveCancelAll($CancelItemnumber, $CancelBorrowerNumber);
63	$biblionumber[0] = $CancelBiblioNumber,	64	$biblionumber[0] = $CancelBiblioNumber,
Lines 67-75 if ($CancelBorrowerNumber) { Link Here
67	else {	68	else {
68	for (my $i=0;$i<$count;$i++){	69	for (my $i=0;$i<$count;$i++){
69	undef $itemnumber[$i] unless $itemnumber[$i] ne '';	70	undef $itemnumber[$i] unless $itemnumber[$i] ne '';
70	ModReserve($rank[$i],$biblionumber[$i],$borrower[$i],$branch[$i],$itemnumber[$i],$suspend_until[$i]); #from C4::Reserves	71	ModReserve({
		72	rank => $rank[$i],
		73	reserve_id => $reserve_id[$i],
		74	branchcode => $branch[$i],
		75	itemnumber => $itemnumber[$i],
		76	suspend_until => $suspend_until[$i]
		77	});
71	}	78	}
72	}	79	}
		80
73	my $from=$query->param('from');	81	my $from=$query->param('from');
74	$from \|\|= q{};	82	$from \|\|= q{};
75	if ( $from eq 'borrower'){	83	if ( $from eq 'borrower'){

Line 0 Link Here

(-)a/t/db_dependent/Holds.t (-1 / +172 lines)
0	-	1	#!/usr/bin/perl
		2
		3	use strict;
		4	use warnings;
		5	use C4::Branch;
		6
		7	use Test::More tests => 18;
		8	use MARC::Record;
		9	use C4::Biblio;
		10	use C4::Items;
		11
		12	BEGIN {
		13	use FindBin;
		14	use lib $FindBin::Bin;
		15	use_ok('C4::Reserves');
		16	}
		17
		18	my $borrowers_count = 5;
		19
		20	# Setup Test------------------------
		21	# Helper biblio.
		22	diag("Creating biblio instance for testing.");
		23	my ($bibnum, $title, $bibitemnum) = create_helper_biblio();
		24
		25	# Helper item for that biblio.
		26	diag("Creating item instance for testing.");
		27	my ($item_bibnum, $item_bibitemnum, $itemnumber) = AddItem({ homebranch => 'CPL', holdingbranch => 'CPL' } , $bibnum);
		28
		29	# Get a borrower
		30	my $dbh = C4::Context->dbh;
		31	my $query = "SELECT borrowernumber FROM borrowers LIMIT $borrowers_count";
		32	my $sth = $dbh->prepare($query);
		33	$sth->execute;
		34	my @borrowernumbers;
		35	while ( my $row = $sth->fetchrow_hashref ) {
		36	push( @borrowernumbers, $row->{'borrowernumber'} );
		37	}
		38
		39	my $biblionumber = $bibnum;
		40
		41	my @branches = GetBranchesLoop();
		42	my $branch = $branches[0][0]{value};
		43
		44	# Create five item level holds
		45	foreach my $borrowernumber ( @borrowernumbers ) {
		46	AddReserve(
		47	$branch,
		48	$borrowernumber,
		49	$biblionumber,
		50	my $constraint = 'a',
		51	my $bibitems = q{},
		52	my $priority,
		53	my $resdate,
		54	my $expdate,
		55	my $notes = q{},
		56	$title,
		57	my $checkitem = $itemnumber,
		58	my $found,
		59	);
		60	}
		61
		62
		63	my ($count, $reserves) = GetReservesFromBiblionumber($biblionumber);
		64	is( $count, $borrowers_count, "Test GetReserves()" );
		65
66
67	my ( $reservedate, $borrowernumber, $branchcode, $reserve_id ) = GetReservesFromItemnumber($itemnumber);
68	ok($reserve_id, "Test GetReservesFromItemnumber()");
69
70
71	my ( $reserve ) = GetReservesFromBorrowernumber($borrowernumbers[0]);
72	ok( $reserve->{'borrowernumber'} eq $borrowernumbers[0], "Test GetReservesFromBorrowernumber()");
73
74
75	ok( GetReserveCount( $borrowernumbers[0] ), "Test GetReserveCount()" );
76
77
78	CancelReserve({ 'reserve_id' => $reserve_id });
79	($count, $reserves) = GetReservesFromBiblionumber($biblionumber);
80	ok( $count == $borrowers_count - 1, "Test CancelReserve()" );
81
82
83	( $reservedate, $borrowernumber, $branchcode, $reserve_id ) = GetReservesFromItemnumber($itemnumber);
84	ModReserve({
85	reserve_id => $reserve_id,
86	rank => '4',
87	branchcode => $branch,
88	itemnumber => $itemnumber,
89	suspend_until => C4::Dates->new("2013-01-01","iso")->output(),
90	});
91	$reserve = GetReserve( $reserve_id );
92	ok( $reserve->{'priority'} eq '4', "Test GetReserve(), priority changed correctly" );
93	ok( $reserve->{'suspend'}, "Test GetReserve(), suspend hold" );
94	ok( $reserve->{'suspend_until'} eq '2013-01-01 00:00:00', "Test GetReserve(), suspend until date" );
95
96	ToggleSuspend( $reserve_id );
97	$reserve = GetReserve( $reserve_id );
98	ok( !$reserve->{'suspend'}, "Test ToggleSuspend(), no date" );
99
100	ToggleSuspend( $reserve_id, '2012-01-01' );
101	$reserve = GetReserve( $reserve_id );
102	ok( $reserve->{'suspend_until'} eq '2012-01-01 00:00:00', "Test ToggleSuspend(), with date" );
103
104	AutoUnsuspendReserves();
105	$reserve = GetReserve( $reserve_id );
106	ok( !$reserve->{'suspend'}, "Test AutoUnsuspendReserves()" );
107
108	# Add a new hold for the borrower whose hold we canceled earlier, this time at the bib level
109	AddReserve(
110	$branch,
111	$borrowernumber,
112	$biblionumber,
113	my $constraint = 'a',
114	my $bibitems = q{},
115	my $priority,
116	my $resdate,
117	my $expdate,
118	my $notes = q{},
119	$title,
120	my $checkitem,
121	my $found,
122	);
123	( $reserve ) = GetReservesFromBorrowernumber($borrowernumber);
124	ModReserveMinusPriority( $itemnumber, $reserve->{'reserve_id'} );
125	( $reserve ) = GetReservesFromBorrowernumber($borrowernumber);
126	ok( $reserve->{'itemnumber'} eq $itemnumber, "Test ModReserveMinusPriority()" );
127
128
129	my $reserve2 = GetReserveInfo( $reserve->{'reserve_id'} );
130	ok( $reserve->{'reserve_id'} eq $reserve2->{'reserve_id'}, "Test GetReserveInfo()" );
131
132
133	($count, $reserves) = GetReservesFromBiblionumber($biblionumber,1);
134	$reserve = $reserves->[1];
135	AlterPriority( 'top', $reserve->{'reserve_id'} );
136	$reserve = GetReserve( $reserve->{'reserve_id'} );
137	ok( $reserve->{'priority'} eq '1', "Test AlterPriority(), move to top" );
138
139	AlterPriority( 'down', $reserve->{'reserve_id'} );
140	$reserve = GetReserve( $reserve->{'reserve_id'} );
141	ok( $reserve->{'priority'} eq '2', "Test AlterPriority(), move down" );
142
143	AlterPriority( 'up', $reserve->{'reserve_id'} );
144	$reserve = GetReserve( $reserve->{'reserve_id'} );
145	ok( $reserve->{'priority'} eq '1', "Test AlterPriority(), move up" );
146
147	AlterPriority( 'bottom', $reserve->{'reserve_id'} );
148	$reserve = GetReserve( $reserve->{'reserve_id'} );
149	ok( $reserve->{'priority'} eq '5', "Test AlterPriority(), move to bottom" );
150
151	# Delete the reserves
152	diag("Deleting holds.");
153	$dbh->do("DELETE FROM reserves WHERE biblionumber = ?", undef, ( $biblionumber ) );
154
155	# Delete item.
156	diag("Deleting item testing instance.");
157	DelItem($dbh, $bibnum, $itemnumber);
158
159	# Delete helper Biblio.
160	diag("Deleting biblio testing instance.");
161	DelBiblio($bibnum);
162
163	# Helper method to set up a Biblio.
164	sub create_helper_biblio {
165	my $bib = MARC::Record->new();
166	my $title = 'Silence in the library';
167	$bib->append_fields(
168	MARC::Field->new('100', ' ', ' ', a => 'Moffat, Steven'),
169	MARC::Field->new('245', ' ', ' ', a => $title),
170	);
171	return ($bibnum, $title, $bibitemnum) = AddBiblio($bib, '');
172	}