use Koha::Stockrotationitem;

use Koha::Stockrotationrotas;

use Koha::Stockrotationstages;

=head3 stockrotationstages

  my $stages = Koha::Library->stockrotationstages;

Returns the stockrotation stages associated with this Library.

=cut

sub stockrotationstages {

    my ( $self ) = @_;

    my $rs = $self->_result->stockrotationstages;

    return Koha::Stockrotationstages->_new_from_dbic( $rs );

}

package Koha::Stockrotationitem;

# Copyright PTFS Europe 2016

#

# 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, write to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

use Modern::Perl;

use DateTime;

use DateTime::Duration;

use Koha::Database;

use Koha::DateUtils qw/dt_from_string/;

use Koha::Item::Transfer;

use Koha::Item;

use Koha::Stockrotationstage;

use base qw(Koha::Object);

=head1 NAME

Stockrotationitem - Koha Stockrotationitem Object class

=head1 SYNOPSIS

Stockrotationitem class used primarily by stockrotation .pls and the stock

rotation cron script.

=head1 DESCRIPTION

Standard Koha::Objects definitions, and additional methods.

=head1 API

=head2 Class Methods

=cut

=head3 _type

=cut

sub _type {

    return 'Stockrotationitem';

}

=head3 itemnumber

  my $item = Koha::Stockrotationitem->itemnumber;

Returns the item associated with the current stock rotation item.

=cut

sub itemnumber {

    my ( $self ) = @_;

    my $rs = $self->_result->itemnumber;

    return Koha::Item->_new_from_dbic( $rs );

}

=head3 stage

  my $stage = Koha::Stockrotationitem->stage;

Returns the stage associated with the current stock rotation item.

=cut

sub stage {

    my ( $self ) = @_;

    my $rs = $self->_result->stage;

    return Koha::Stockrotationstage->_new_from_dbic( $rs );

}

sub needs_initiating {

    my ( $self ) = @_;

    my $completed = $self->itemnumber->_result->branchtransfers->search;

    if ( !$completed->count ) {

        return 1;

    } else {

        my $stage_branch = $self->stage->branchcode_id;

        my $home_branch = $self->itemnumber->homebranch;

        return !( $stage_branch eq $home_branch );

    }

}

=head3 needs_repatriating

  my $status = $item->needs_repatriating;

Return 1 if this item is currently not at the library it should be at

according to our stockrotation plan.

=cut

# Check following things:

#

# Homebranch == stockrotationstage.branch

#   If not, check if Homebranch == stockrotationstage.stageafter.branch

#     If so, presumably in transit :=> 0

#     Else, :=> 1

#

# Holdingbranch == Homebranch

#   If not, :=> 1

sub needs_repatriating {

    my ( $self ) = @_;

    my ( $item, $stage ) = ( $self->itemnumber, $self->stage );

    if ( $item->homebranch ne $stage->branchcode_id ) {

        # We're either in transit to new branch or we got corrupted.

        my $next_stage = $stage->next_sibling;

        ( $next_stage && $item->homebranch eq $next_stage->branchcode_id )

            ? return 0          # We seem to be in transit.

            : return 1;         # We got corrupted, gotta be repatriated!

    }

    # Check if we are where we should be…

    if ( $item->holdingbranch eq $item->homebranch

             || $self->itemnumber->get_transfer ) {

        return 0;               # Yup, all good

    } else {

        return 1;               # Nope, gotta be repatriated

    }

}

=head3 needs_advancing

  my $status = $item->needs_advancing;

Return 1 if this item is ready to be moved on to the next stage in its rota.

=cut

sub needs_advancing {

    my ( $self ) = @_;

    my $intransfers = $self->itemnumber->get_transfer;

    # Check whether we are in transfer

    if ( !$intransfers ) {

        my $completed = $self->itemnumber->_result->branchtransfers->search(

            {},

            {

                order_by => { -desc => 'datearrived' }

            }

        );

        # Do maths on whether we need to be moved on.

        if ( $completed->count ) {

            my $arrival = dt_from_string(

                $completed->next->datearrived, 'iso'

            );

            my $duration = DateTime::Duration

                ->new( days => $self->stage->duration );

            if ( $arrival + $duration le DateTime->now ) {

                return 1;

            } else {

                return 0;

            }

        } else {

            die "We have no historical branch transfer; this should not have happened!";

        }

    }

    # Currently in transfer, do not advance.

    return 0;

}

sub initiate {

    my ( $self ) = @_;

    my $stage_branch = $self->stage->branchcode_id;

    my $home_branch = $self->itemnumber->homebranch;

    my $holding_branch = $self->itemnumber->holdingbranch;

    if ( !( ( $stage_branch eq $home_branch )

             && ( $holding_branch eq $home_branch ) ) ) {

        return $self->repatriate("StockrotationInit");

    } else {

        $self->itemnumber->homebranch($self->stage->branchcode_id)->store;

        return Koha::Item::Transfer->new({

            'itemnumber'  => $self->itemnumber_id,

            'frombranch'  => $self->stage->branchcode_id,

            'tobranch'    => $self->stage->branchcode_id,

            'datesent'    => DateTime->now,

            'datearrived' => DateTime->now,

            'comments'    => "StockrotationInit"

        })->store;

    }

}

=head3 repatriate

  $sritem = $sritem->repatriate

Put this item into branch transfer with 'StockrotationCorrection' comment, so

that it may return to it's stage.branch to continue its rota as normal.

=cut

sub repatriate {

    my ( $self, $msg ) = @_;

    # Create the transfer.

    my $transfer_stored = Koha::Item::Transfer->new({

        'itemnumber' => $self->itemnumber_id,

        'frombranch' => $self->itemnumber->holdingbranch,

        'tobranch'   => $self->stage->branchcode_id,

        'datesent'   => DateTime->now,

        'comments'   => $msg || "StockrotationRepatriation",

    })->store;

    $self->itemnumber->homebranch($self->stage->branchcode_id)->store;

    return $transfer_stored;

}

=head3 advance

  $sritem = $sritem->advance

Put this item into branch transfer with 'StockrotationAdvance' comment, to

transfer it to the next stage in its rota.

If this is the last stage in the rota and this rota is cyclical, we return to

the first stage.  If it is not cyclical, then we delete this

Stockrotationitem.

If this item is 'indemand', and advance is invoked, we disable 'indemand' and

advance the item as per usual.

=cut

sub advance {

    my ( $self ) = @_;

    my $transfer = Koha::Item::Transfer->new({

        'itemnumber' => $self->itemnumber_id,

        'frombranch' => $self->itemnumber->holdingbranch,

        'datesent'   => DateTime->now,

        'comments'   => "StockrotationAdvance"

    });

    if ( $self->indemand ) {

        $self->indemand(0)->store;  # De-activate indemand

        $transfer->tobranch($self->stage->branchcode_id);

        $transfer->datearrived(DateTime->now);

    } else {

        # Find and update our stage.

        my $current_stage = $self->stage;

        my $new_stage;

        # Last stage in rota?

        if ( !$current_stage->last_sibling ) {

            # Special rules: Cyclical rota?

            if ( $current_stage->rota->cyclical ) {

                # Revert to first stage.

                my $xstg = $current_stage->first_sibling;

                # Is this the first (as well as last) stage?

                if ( $xstg ) {

                    # ... No, so return to first stage.

                    $new_stage = $xstg;

                } else {

                    # ... Yes, so we create a dummy transfer (for statistics)

                    my $transfer_stored = Koha::Item::Transfer->new({

                        'itemnumber'  => $self->itemnumber_id,

                        'frombranch'  => $self->itemnumber->holdingbranch,

                        'tobranch'    => $self->itemnumber->holdingbranch,

                        'datesent'    => DateTime->now,

                        'datearrived' => DateTime->now,

                        'comments'    => "StockrotationAdvance"

                    })->store;

                    # and return.

                    return 1;

                }

                $new_stage = ( $xstg ) ? $xstg : $current_stage;

            } else {

                # Stockrotationitem no longer needs to exist.

                $self->delete;

                return 1;

            }

        } else {

            # Just advance.

            $new_stage = $self->stage->next_sibling;

        }

        # Update our stage.

        $self->stage_id($new_stage->stage_id)->store;

        # Update our homebranch.

        $self->itemnumber->homebranch($self->stage->branchcode_id)->store;

        #Update the transfer

        $transfer->tobranch($new_stage->branchcode_id);

    }

    return $transfer->store;

}

1;

=head1 AUTHOR

Alex Sassmannshausen <alex.sassmannshausen@ptfs-europe.com>

=cut

package Koha::Stockrotationitems;

# Copyright PTFS Europe 2016

#

# 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, write to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

use Modern::Perl;

use Koha::Database;

use Koha::Stockrotationitem;

use base qw(Koha::Objects);

=head1 NAME

Stockrotationitems - Koha Stockrotationitems Object class

=head1 SYNOPSIS

Stockrotationitems class used primarily by stockrotation .pls and the stock

rotation cron script.

=head1 DESCRIPTION

Standard Koha::Objects definitions, and additional methods.

=head1 API

=head2 Class Methods

=cut

=head3 _type

=cut

sub _type {

    return 'Stockrotationitem';

}

sub object_class {

    return 'Koha::Stockrotationitem';

}

1;

=head1 AUTHOR

Alex Sassmannshausen <alex.sassmannshausen@ptfs-europe.com>

=cut

package Koha::Stockrotationrota;

# Copyright PTFS Europe 2016

#

# 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, write to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

use Modern::Perl;

use Koha::Database;

use Koha::Stockrotationstages;

use Koha::Stockrotationitem;

use Koha::Stockrotationitems;

use base qw(Koha::Object);

=head1 NAME

Stockrotationrota - Koha Stockrotationrota Object class

=head1 SYNOPSIS

Stockrotationrota class used primarily by stockrotation .pls and the stock

rotation cron script.

=head1 DESCRIPTION

Standard Koha::Objects definitions, and additional methods.

=head1 API

=head2 Class Methods

=cut

=head3 stockrotationstages

  my $stages = Koha::Stockrotationrota->stockrotationstages;

Returns the stages associated with the current rota.

=cut

sub stockrotationstages {

    my ( $self ) = @_;

    my $rs = $self->_result->stockrotationstages;

    return Koha::Stockrotationstages->_new_from_dbic( $rs );

}

=head3 add_item

  my $rota = $rota->add_item($itemnumber);

Add item identified by $ITEMNUMBER to this rota, which means we associate it

with the first stage of this rota.  Should the item already be associated with

a rota, move it from that rota to this rota.

=cut

sub add_item {

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

    my $sritem = Koha::Stockrotationitems->find($itemnumber);

    my $stages = $self->stockrotationstages;

    die "Rota is missing stages." unless ( $stages->count > 0 );

    if ($sritem) {

        $sritem->stage_id($stages->next->stage_id)->store;

    } else {

        $sritem = Koha::Stockrotationitem->new({

            itemnumber_id => $itemnumber,

            stage_id      => $stages->next->stage_id,

            indemand      => 0,

        })->store;

    }

    return $self;

}

=head3 first_stage

  my $stage = $rota->first_stage;

Return the first stage attached to this rota (the one that has an undefined

`stagebefore`).

=cut

sub first_stage {

    my ( $self ) = @_;

    my $guess = $self->stockrotationstages->next;

    my $stage = $guess->first_sibling;

    return ( $stage ) ? $stage : $guess;

}

=head3 items

  my $items = $rota->items;

Return all items associated with this rota via its stages.

=cut

sub stockrotationitems {

    my ( $self ) = @_;

    my $rs = Koha::Stockrotationitems->search(

        { 'stage.rota_id' => $self->rota_id }, { join =>  [ qw/stage/ ] }

    );

    return $rs;

}

=head3 _type

=cut

sub _type {

    return 'Stockrotationrota';

}

1;

=head1 AUTHOR

Alex Sassmannshausen <alex.sassmannshausen@ptfs-europe.com>

=cut

package Koha::Stockrotationrotas;

# Copyright PTFS Europe 2016

#

# 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, write to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

use Modern::Perl;

use Koha::Database;

use Koha::Stockrotationrota;

use base qw(Koha::Objects);

=head1 NAME

Stockrotationrotas - Koha Stockrotationrotas Object class

=head1 SYNOPSIS

Stockrotationrotas class used primarily by stockrotation .pls and the stock

rotation cron script.

=head1 DESCRIPTION

Standard Koha::Objects definitions, and additional methods.

=head1 API

=head2 Class Methods

=cut

=head3 _type

=cut

sub _type {

    return 'Stockrotationrota';

}

sub object_class {

    return 'Koha::Stockrotationrota';

}

1;

=head1 AUTHOR

Alex Sassmannshausen <alex.sassmannshausen@ptfs-europe.com>

=cut

package Koha::Stockrotationstage;

# Copyright PTFS Europe 2016

#

# 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, write to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

use Modern::Perl;

use Koha::Database;

use Koha::Library;

use Koha::Stockrotationitems;

use Koha::Stockrotationrota;

use base qw(Koha::Object);

=head1 NAME

Stockrotationstage - Koha Stockrotationstage Object class

=head1 SYNOPSIS

Stockrotationstage class used primarily by stockrotation .pls and the stock

rotation cron script.

=head1 DESCRIPTION

Standard Koha::Objects definitions, and additional methods.

=head1 API

=head2 Class Methods

=cut

=head3 _type

=cut

sub _type {

    return 'Stockrotationstage';

}

sub _relation {

    my ( $self, $method, $type ) = @_;

    return sub {

        my $rs = $self->_result->$method;

        return 0 if !$rs;

        my $namespace = 'Koha::' . $type;

        return $namespace->_new_from_dbic( $rs );

    }

}

=head3 stockrotationitems

  my $stages = Koha::Stockrotationstage->stockrotationitems;

Returns the items associated with the current stage.

=cut

sub stockrotationitems {

    my ( $self ) = @_;

    return &{$self->_relation(qw/ stockrotationitems Stockrotationitems /)};

}

=head3 branchcode

  my $branch = Koha::Stockrotationstage->branchcode;

Returns the branch associated with the current stage.

=cut

sub branchcode {

    my ( $self ) = @_;

    return &{$self->_relation(qw/ branchcode Library /)};

}

=head3 rota

  my $rota = Koha::Stockrotationstage->rota;

Returns the rota associated with the current stage.

=cut

sub rota {

    my ( $self ) = @_;

    return &{$self->_relation(qw/ rota Stockrotationrota /)};

}

=head3 siblings

  my $siblings = $stage->siblings;

Koha::Object wrapper around DBIx::Class::Ordered.

=cut

sub siblings {

    my ( $self ) = @_;

    return &{$self->_relation(qw/ siblings Stockrotationstages /)};

}

=head3 next_siblings

  my $next_siblings = $stage->next_siblings;

Koha::Object wrapper around DBIx::Class::Ordered.

=cut

sub next_siblings {

    my ( $self ) = @_;

    return &{$self->_relation(qw/ next_siblings Stockrotationstages /)};

}

=head3 previous_siblings

  my $previous_siblings = $stage->previous_siblings;

Koha::Object wrapper around DBIx::Class::Ordered.

=cut

sub previous_siblings {

    my ( $self ) = @_;

    return &{$self->_relation(qw/ previous_siblings Stockrotationstages /)};

}

=head3 next_sibling

  my $next = $stage->next_sibling;

Koha::Object wrapper around DBIx::Class::Ordered.

=cut

sub next_sibling {

    my ( $self ) = @_;

    return &{$self->_relation(qw/ next_sibling Stockrotationstage /)};

}

=head3 previous_sibling

  my $previous = $stage->previous_sibling;

Koha::Object Wrapper around DBIx::Class::Ordered.

=cut

sub previous_sibling {

    my ( $self ) = @_;

    return &{$self->_relation(qw/ previous_sibling Stockrotationstage /)};

}

=head3 first_sibling

  my $first = $stage->first_sibling;

Koha::Object Wrapper around DBIx::Class::Ordered.

=cut

sub first_sibling {

    my ( $self ) = @_;

    return &{$self->_relation(qw/ first_sibling Stockrotationstage /)};

}

=head3 last_sibling

  my $last = $stage->last_sibling;

Koha::Object Wrapper around DBIx::Class::Ordered.

=cut

sub last_sibling {

    my ( $self ) = @_;

    return &{$self->_relation(qw/ last_sibling Stockrotationstage /)};

}

=head3 move_previous

  1|0 = $stage->move_previous;

Koha::Object Wrapper around DBIx::Class::Ordered.

=cut

sub move_previous {

    my ( $self ) = @_;

    return $self->_result->move_previous;

}

=head3 move_next

  1|0 = $stage->move_next;

Koha::Object Wrapper around DBIx::Class::Ordered.

=cut

sub move_next {

    my ( $self ) = @_;

    return $self->_result->move_next;

}

=head3 move_first

  1|0 = $stage->move_first;

Koha::Object Wrapper around DBIx::Class::Ordered.

=cut

sub move_first {

    my ( $self ) = @_;

    return $self->_result->move_first;

}

=head3 move_last

  1|0 = $stage->move_last;

Koha::Object Wrapper around DBIx::Class::Ordered.

=cut

sub move_last {

    my ( $self ) = @_;

    return $self->_result->move_last;

}

=head3 move_to

  1|0 = $stage->move_to($position);

Koha::Object Wrapper around DBIx::Class::Ordered.

=cut

sub move_to {

    my ( $self, $position ) = @_;

    return $self->_result->move_to($position)

        if ( $position le $self->rota->stockrotationstages->count );

    return 0;

}

=head3 move_to_group

  1|0 = $stage->move_to_group($rota_id, [$position]);

Koha::Object Wrapper around DBIx::Class::Ordered.

=cut

sub move_to_group {

    my ( $self, $rota_id, $position ) = @_;

    return $self->_result->move_to_group($rota_id, $position);

}

=head3 delete

  1|0 = $stage->delete;

Koha::Object Wrapper around DBIx::Class::Ordered.

=cut

sub delete {

    my ( $self ) = @_;

    return $self->_result->delete;

}

1;

=head1 AUTHOR

Alex Sassmannshausen <alex.sassmannshausen@ptfs-europe.com>

=cut

package Koha::Stockrotationstages;

# Copyright PTFS Europe 2016

#

# 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, write to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

use Modern::Perl;

use Koha::Database;

use Koha::Stockrotationstage;

use base qw(Koha::Objects);

=head1 NAME

Stockrotationstages - Koha Stockrotationstages Object class

=head1 SYNOPSIS

Stockrotationstages class used primarily by stockrotation .pls and the stock

rotation cron script.

=head1 DESCRIPTION

Standard Koha::Objects definitions, and additional methods.

=head1 API

=head2 Class Methods

=cut

=head3 _type

=cut

sub _type {

    return 'Stockrotationstage';

}

sub object_class {

    return 'Koha::Stockrotationstage';

}

1;

=head1 AUTHOR

Alex Sassmannshausen <alex.sassmannshausen@ptfs-europe.com>

=cut

subtest 'Check stockrotationitem relationship' => sub {

    plan tests => 1;

    $schema->storage->txn_begin();

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

    my $item = $builder->build({ source => 'Item' });

    $builder->build({

        source => 'Stockrotationitem',

        value  => { itemnumber_id => $item->{itemnumber} }

    });

    my $sritem = Koha::Items->find($item->{itemnumber})->stockrotationitem;

    isa_ok( $sritem, 'Koha::Stockrotationitem', "Relationship works and correctly creates Koha::Object." );

    $schema->storage->txn_rollback;

};

subtest 'Check add_to_rota method' => sub {

    plan tests => 2;

    $schema->storage->txn_begin();

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

    my $item = $builder->build({ source => 'Item' });

    my $rota = $builder->build({ source => 'Stockrotationrota' });

    my $srrota = Koha::Stockrotationrotas->find($rota->{rota_id});

    $builder->build({

        source => 'Stockrotationstage',

        value  => { rota_id => $rota->{rota_id} },

    });

    my $sritem = Koha::Items->find($item->{itemnumber});

    $sritem->add_to_rota($rota->{rota_id});

    is(

        Koha::Stockrotationitems->find($item->{itemnumber})->stage_id,

        $srrota->stockrotationstages->next->stage_id,

        "Adding to a rota a new sritem item being assigned to its first stage."

    );

    my $newrota = $builder->build({ source => 'Stockrotationrota' });

    my $srnewrota = Koha::Stockrotationrotas->find($newrota->{rota_id});

    $builder->build({

        source => 'Stockrotationstage',

        value  => { rota_id => $newrota->{rota_id} },

    });

    $sritem->add_to_rota($newrota->{rota_id});

    is(

        Koha::Stockrotationitems->find($item->{itemnumber})->stage_id,

        $srnewrota->stockrotationstages->next->stage_id,

        "Moving an item results in that sritem being assigned to the new first stage."

    );

    $schema->storage->txn_rollback;

};

# Stockrotation relationship testing

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

$builder->build({

    source => 'Stockrotationstage',

    value  => { branchcode_id => $new_library_sr->{branchcode} },

});

$builder->build({

    source => 'Stockrotationstage',

    value  => { branchcode_id => $new_library_sr->{branchcode} },

});

$builder->build({

    source => 'Stockrotationstage',

    value  => { branchcode_id => $new_library_sr->{branchcode} },

});

my $srstages = Koha::Libraries->find($new_library_sr->{branchcode})

    ->stockrotationstages;

is( $srstages->count, 3, 'Correctly fetched stockrotationstages associated with this branch');

isa_ok( $srstages->next, 'Koha::Stockrotationstage', "Relationship correctly creates Koha::Objects." );

#!/usr/bin/perl

# Copyright PTFS Europe 2016

#

# 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, write to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

use Modern::Perl;

use DateTime;

use Koha::Database;

use Koha::Item::Transfer;

use t::lib::TestBuilder;

use Test::More tests => 7;

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

use_ok('Koha::Stockrotationitems');

use_ok('Koha::Stockrotationitem');

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

subtest 'Basic object tests' => sub {

    plan tests => 5;

    $schema->storage->txn_begin;

    my $itm = $builder->build({ source => 'Item' });

    my $stage = $builder->build({ source => 'Stockrotationstage' });

    my $item = $builder->build({

        source => 'Stockrotationitem',

        value  => {

            itemnumber_id => $itm->{itemnumber},

            stage_id      => $stage->{stage_id},

        },

    });

    my $sritem = Koha::Stockrotationitems->find($item->{itemnumber_id});

    isa_ok(

        $sritem,

        'Koha::Stockrotationitem',

        "Correctly create and load a stock rotation item."

    );

    # Relationship to rota

    isa_ok( $sritem->itemnumber, 'Koha::Item', "Fetched related item." );

    is( $sritem->itemnumber->itemnumber, $itm->{itemnumber}, "Related rota OK." );

    # Relationship to stage

    isa_ok( $sritem->stage, 'Koha::Stockrotationstage', "Fetched related stage." );

    is( $sritem->stage->stage_id, $stage->{stage_id}, "Related stage OK." );

    $schema->storage->txn_rollback;

};

subtest 'Tests for needs_repatriating' => sub {

    plan tests => 4;

    $schema->storage->txn_begin;

    # Setup a pristine stockrotation context.

    my $sritem = $builder->build({ source => 'Stockrotationitem' });

    my $dbitem = Koha::Stockrotationitems->find($sritem->{itemnumber_id});

    $dbitem->itemnumber->homebranch($dbitem->stage->branchcode_id);

    $dbitem->itemnumber->holdingbranch($dbitem->stage->branchcode_id);

    $dbitem->stage->position(1);

    my $dbrota = $dbitem->stage->rota;

    my $newstage = $builder->build({

        source => 'Stockrotationstage',

        values => {

            rota_id => $dbrota->rota_id,

            position => 2,

        }

    });

    # - homebranch == holdingbranch [0]

    is(

        $dbitem->needs_repatriating, 0,

        "Homebranch == Holdingbranch."

    );

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

    $dbitem->itemnumber->holdingbranch($branch->{branchcode});

    # - homebranch != holdingbranch [1]

    is(

        $dbitem->needs_repatriating, 1,

        "Homebranch != holdingbranch."

    );

    # Set to incorrect homebranch.

    $dbitem->itemnumber->holdingbranch($dbitem->stage->branchcode_id);

    $dbitem->itemnumber->homebranch($branch->{branchcode});

    # - homebranch != stockrotationstage.branch & not in transit [1]

    is(

        $dbitem->needs_repatriating, 1,

        "Homebranch != Stockrotationstage.Branchcode_id & not in transit."

    );

    # Set to in transit (by implication).

    $dbitem->stage($newstage->{stage_id});

    # - homebranch != stockrotaitonstage.branch & in transit [0]

    is(

        $dbitem->needs_repatriating, 1,

        "homebranch != stockrotaitonstage.branch & in transit."

    );

    $schema->storage->txn_rollback;

};

subtest "Tests for repatriate." => sub {

    plan tests => 3;

    $schema->storage->txn_begin;

    my $sritem = $builder->build({ source => 'Stockrotationitem' });

    my $dbitem = Koha::Stockrotationitems->find($sritem->{itemnumber_id});

    $dbitem->stage->position(1);

    $dbitem->stage->duration(50);

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

    $dbitem->itemnumber->holdingbranch($branch->{branchcode});

    # Test a straight up repatriate

    ok($dbitem->repatriate, "Repatriation done.");

    my $intransfer = $dbitem->itemnumber->get_transfer;

    is($intransfer->frombranch, $branch->{branchcode}, "Origin correct.");

    is($intransfer->tobranch, $dbitem->stage->branchcode_id, "Target Correct.");

    $schema->storage->txn_rollback;

};

subtest "Tests for needs_advancing." => sub {

    plan tests => 3;

    $schema->storage->txn_begin;

    # Setup a pristine stockrotation context.

    my $sritem = $builder->build({ source => 'Stockrotationitem' });

    my $dbitem = Koha::Stockrotationitems->find($sritem->{itemnumber_id});

    $dbitem->itemnumber->homebranch($dbitem->stage->branchcode_id);

    $dbitem->itemnumber->holdingbranch($dbitem->stage->branchcode_id);

    $dbitem->stage->position(1);

    $dbitem->stage->duration(50);

    my $dbtransfer = Koha::Item::Transfer->new({

        'itemnumber'  => $dbitem->itemnumber_id,

        'frombranch'  => $dbitem->stage->branchcode_id,

        'tobranch'    => $dbitem->stage->branchcode_id,

        'datesent'    => DateTime->now,

        'datearrived' => undef,

        'comments'    => "Test item",

    })->store;

    # Test item will not be advanced if in transit.

    is($dbitem->needs_advancing, 0, "Not ready to advance: in transfer.");

    # Test item will not be advanced if it has not spent enough time.

    $dbtransfer->datearrived(DateTime->now)->store;

    is($dbitem->needs_advancing, 0, "Not ready to advance: Not spent enough time.");

    # Test item will be advanced if it has spent enough time.

    $dbtransfer->datesent(      # Item was sent 100 days ago...

        DateTime->now - DateTime::Duration->new( days => 100 )

    )->store;

    $dbtransfer->datearrived(   # And arrived 75 days ago.

        DateTime->now - DateTime::Duration->new( days => 75 )

    )->store;

    is($dbitem->needs_advancing, 1, "Ready to be advanced.");

    $schema->storage->txn_rollback;

};

subtest "Tests for advance." => sub {

    plan tests => 12;

    $schema->storage->txn_begin;

    my $sritem = $builder->build({ source => 'Stockrotationitem' });

    my $dbitem = Koha::Stockrotationitems->find($sritem->{itemnumber_id});

    $dbitem->itemnumber->holdingbranch($dbitem->stage->branchcode_id);

    my $dbstage = $dbitem->stage;

    $dbstage->position(1)->duration(50)->store; # Configure stage.

    # Configure item

    $dbitem->itemnumber->holdingbranch($dbstage->branchcode_id)->store;

    $dbitem->itemnumber->homebranch($dbstage->branchcode_id)->store;

    # Sanity check

    is($dbitem->stage->stage_id, $dbstage->stage_id, "Stage sanity check.");

    # Test cases of single stage

    $dbstage->rota->cyclical(1)->store;         # Set Rota to cyclical.

    ok($dbitem->advance, "Single stage cyclical advance done.");

    ## Refetch dbitem

    $dbitem = Koha::Stockrotationitems->find($sritem->{itemnumber_id});

    is($dbitem->stage->stage_id, $dbstage->stage_id, "Single stage cyclical stage OK.");

    # Test with indemand advance

    $dbitem->indemand(1)->store;

    ok($dbitem->advance, "Indemand item advance done.");

    ## Refetch dbitem

    $dbitem = Koha::Stockrotationitems->find($sritem->{itemnumber_id});

    is($dbitem->indemand, 0, "Indemand OK.");

    is($dbitem->stage->stage_id, $dbstage->stage_id, "Indemand item advance stage OK.");

    # Multi stages

    my $srstage = $builder->build({

        source => 'Stockrotationstage',

        values => { duration => 50 }

    });

    my $dbstage2 = Koha::Stockrotationstages->find($srstage->{stage_id});

    $dbstage2->move_to_group($dbitem->stage->rota_id);

    $dbstage2->move_last;

    # Test a straight up advance

    ok($dbitem->advance, "Advancement done.");

    ## Refetch dbitem

    $dbitem = Koha::Stockrotationitems->find($sritem->{itemnumber_id});

    ## Test results

    is($dbitem->stage->stage_id, $dbstage2->stage_id, "Stage updated.");

    my $intransfer = $dbitem->itemnumber->get_transfer;

    is($intransfer->frombranch, $dbstage->branchcode_id, "Origin correct.");

    is($intransfer->tobranch, $dbstage2->branchcode_id, "Target Correct.");

    $dbstage->rota->cyclical(0)->store;         # Set Rota to non-cyclical.

    # Arrive at new branch

    $intransfer->datearrived(DateTime->now)->store;

    $dbitem->itemnumber->holdingbranch($srstage->{branchcode_id})->store;

    $dbitem->itemnumber->homebranch($srstage->{branchcode_id})->store;

    # Advance again, Remove from rota.

    ok($dbitem->advance, "Non-cyclical advance.");

    ## Refetch dbitem

    $dbitem = Koha::Stockrotationitems->find($sritem->{itemnumber_id});

    is($dbitem, undef, "Stockrotationitem has been removed.");

    $schema->storage->txn_rollback;

};

1;

#!/usr/bin/perl

# Copyright PTFS Europe 2016

#

# 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, write to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

use Modern::Perl;

use Koha::Database;

use t::lib::TestBuilder;

use Test::More tests => 5;

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

use_ok('Koha::Stockrotationrotas');

use_ok('Koha::Stockrotationrota');

subtest 'Basic object tests' => sub {

    plan tests => 5;

    $schema->storage->txn_begin;

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

    my $rota = $builder->build({ source => 'Stockrotationrota' });

    my $srrota = Koha::Stockrotationrotas->find($rota->{rota_id});

    isa_ok(

        $srrota,

        'Koha::Stockrotationrota',

        "Correctly create and load a stock rotation rota."

    );

    $builder->build({

        source => 'Stockrotationstage',

        value  => { rota_id => $rota->{rota_id} },

    });

    $builder->build({

        source => 'Stockrotationstage',

        value  => { rota_id => $rota->{rota_id} },

    });

    $builder->build({

        source => 'Stockrotationstage',

        value  => { rota_id => $rota->{rota_id} },

    });

    my $srstages = $srrota->stockrotationstages;

    is( $srstages->count, 3, 'Correctly fetched stockrotationstages associated with this rota');

    isa_ok( $srstages->next, 'Koha::Stockrotationstage', "Relationship correctly creates Koha::Objects." );

    #### Test add_item

    my $item = $builder->build({ source => 'Item' });

    $srrota->add_item($item->{itemnumber});

    is(

        Koha::Stockrotationitems->find($item->{itemnumber})->stage_id,

        $srrota->stockrotationstages->next->stage_id,

        "Adding an item results in a new sritem item being assigned to the first stage."

    );

    my $newrota = $builder->build({ source => 'Stockrotationrota' });

    my $srnewrota = Koha::Stockrotationrotas->find($newrota->{rota_id});

    $builder->build({

        source => 'Stockrotationstage',

        value  => { rota_id => $newrota->{rota_id} },

    });

    $srnewrota->add_item($item->{itemnumber});

    is(

        Koha::Stockrotationitems->find($item->{itemnumber})->stage_id,

        $srnewrota->stockrotationstages->next->stage_id,

        "Moving an item results in that sritem being assigned to the new first stage."

    );

    $schema->storage->txn_rollback;

};

subtest '->first_stage test' => sub {

    plan tests => 2;

    $schema->storage->txn_begin;

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

    my $rota = $builder->build({ source => 'Stockrotationrota' });

    my $stage1 = $builder->build({

        source => 'Stockrotationstage',

        value  => { rota_id => $rota->{rota_id} },

    });

    my $stage2 = $builder->build({

        source => 'Stockrotationstage',

        value  => { rota_id => $rota->{rota_id} },

    });

    my $stage3 = $builder->build({

        source => 'Stockrotationstage',

        value  => { rota_id => $rota->{rota_id} },

    });

    my $srrota = Koha::Stockrotationrotas->find($rota->{rota_id});

    my $srstage2 = Koha::Stockrotationstages->find($stage2->{stage_id});

    my $firststage = $srstage2->first_sibling || $srstage2;

    is( $srrota->first_stage->stage_id, $firststage->stage_id, "First stage works" );

    $srstage2->move_first;

    is( Koha::Stockrotationrotas->find($rota->{rota_id})->first_stage->stage_id, $stage2->{stage_id}, "Stage re-organized" );

    $schema->storage->txn_rollback;

};

subtest '->items test' => sub {

    plan tests => 1;

    $schema->storage->txn_begin;

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

    my $rota = $builder->build({ source => 'Stockrotationrota' });

    my $stage1 = $builder->build({

        source => 'Stockrotationstage',

        value  => { rota_id => $rota->{rota_id} },

    });

    my $stage2 = $builder->build({

        source => 'Stockrotationstage',

        value  => { rota_id => $rota->{rota_id} },

    });

    my $stage3 = $builder->build({

        source => 'Stockrotationstage',

        value  => { rota_id => $rota->{rota_id} },

    });

    map { $builder->build({

        source => 'Stockrotationitem',

        value => { stage_id => $_ },

    }) } (

        $stage1->{stage_id}, $stage1->{stage_id},

        $stage2->{stage_id}, $stage2->{stage_id},

        $stage3->{stage_id}, $stage3->{stage_id},

    );

    my $srrota = Koha::Stockrotationrotas->find($rota->{rota_id});

    is(

        $srrota->stockrotationitems->count,

        6, "Correct number of items"

    );

    $schema->storage->txn_rollback;

};

1;