use Koha::FloatingMatrix;

    my $floatingType = Koha::FloatingMatrix::CheckFloating($item, $branch, $returnbranch);

    #This elsif-clause copypastes the upper if-clause. This is horrible and I cry, but cannot refactor this mess now :( due to Koha upstream master stuff looming.

    elsif (!$is_in_rotating_collection && ($doreturn or $messages->{'NotIssued'})

        and !$resfound and ($branch ne $returnbranch)

        and not($messages->{'WrongTransfer'})

        && $floatingType){ #So if we would otherwise transfer, but we have a floating rule overriding it.

                           #We can infer that the transfer was averted because of a floating rule.

        #Make sure we dont log the same floating denial multiple times

        #So first check if we already logged this operation.

        my $logs = C4::Log::GetLogs(DateTime->now(time_zone => C4::Context->tz),

                                    DateTime->now(time_zone => C4::Context->tz),

                                    undef, ['FLOATING'], undef, $item->{'itemnumber'}, "$branch -> $returnbranch denied");

        if (not($logs) || (ref($logs) eq 'ARRAY' && scalar(@$logs) == 0)) {

            C4::Log::logaction("FLOATING", $floatingType, $item->{'itemnumber'}, "$branch -> $returnbranch denied");

        }

    }

package Koha::FloatingMatrix;

# Copyright 2015 Vaara-kirjastot

#

# 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 2 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.

=head1 FloatingMatrix

Koha::FloatingMatrix - Object to control accessing and modifying floating matrix rules.

=cut

use Modern::Perl;

use Carp qw(carp croak confess longmess);

use Scalar::Util qw(blessed refaddr);

use C4::Context qw(dbh);

use Koha::Caches;

use Koha::Database;

use Koha::FloatingMatrix::BranchRule;

use Koha::Exceptions::BadParameter;

my $cacheExpiryTime = 1200;

=head new

    my $fm = Koha::FloatingMatrix->new();

Finds a FloatingMatrix from Koha::Caches or instantiates a new one.

=cut

sub new {

    my ($class) = @_;

    my $cache = Koha::Caches->get_instance();

    my $fm = $cache->get_from_cache('floatingMatrix');

    unless ($fm) {

        $fm = {};

        bless $fm, $class;

        $fm->_getFloatingMatrix();

        $fm->_createModificationBuffer();

        $cache->set_in_cache('floatingMatrix', $fm, {expiry => $cacheExpiryTime});

    }

    return $fm if blessed($fm) && $fm->isa('Koha::FloatingMatrix');

    return undef;

}

sub _getFloatingMatrix {

    my ($fm) = @_;

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

    my @rules = $schema->resultset('FloatingMatrix')->search({});

    my %map;

    $fm->_setBranchRules( \%map );

    foreach my $rule (@rules) {

        my $branchRule = Koha::FloatingMatrix::BranchRule->newFromDBIx($rule);

        $fm->_linkBranchRule($branchRule);

    }

}

=head GetFloatingTypes

Static Method

    my $floatingTypes = Koha::FloatingMatrix::GetFloatingTypes();

@RETURNS Reference to ARRAY, of koha.floating_matrix.floating enumerations.

            These are all the available ways Items can float in Koha.

=cut

sub GetFloatingTypes {

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

    my $source = $schema->source('FloatingMatrix');

    my $info = $source->column_info('floating');

    my $floatingTypeEnumerations =  $info->{extra}->{list};

    return $floatingTypeEnumerations;

}

=head getFloatingTypes

    $fm->getFloatingTypes();

See. GetFloatingTypes()

=cut

sub getFloatingTypes {

    my ($fm) = @_;

    return $fm->{floatingTypes} if $fm->{floatingTypes};

    $fm->{floatingTypes} = Koha::FloatingMatrix::GetFloatingTypes();

    return $fm->{floatingTypes};

}

=head upsertBranchRule

    my ($branchRule, $error) = $fm->upsertBranchRule( $params );

    if ($error) {

        #I must have given some bad object properties

    }

    else {

        $fm->store();

    }

Adds or modifies an existing overduerule. Take note that this is only a local modification

for this instance of OverdueRulesMap-object.

If changes need to persists, call the $orm->store() method to save changes to DB.

@PARAM1, HASH, See Koha::Overdues::OverdueRule->new() for parameter descriptions.

@RETURN, Koha::Overdues::OverdueRule-object if success and

         String errorCode, if something bad hapened.

@THROWS Koha::Exceptions::BadParameter from Koha::FloatingMatrix::BranchRule->new().

=cut

sub upsertBranchRule {

    my ($fm, $params) = @_;

    my $branchRule = Koha::FloatingMatrix::BranchRule->new($params); #While creating this object we sanitate the parameters.

    my $existingBranchRule = $fm->_findBranchRule($branchRule);

    my $operation;

    if ($existingBranchRule) { #We are modifying an existing rule

        #Should we somehow tell that we are updating an existing rule?

        $existingBranchRule->replace($branchRule); #Replace with the new sanitated values, we preserve the internal data structure position.

        #Replacing might be less costly than recursively unlinking a large internal mapping.

        $branchRule = $existingBranchRule;

        $operation = 'MOD';

    }

    else { #Just adding more rules

        $fm->_linkBranchRule($branchRule);

        $operation = 'ADD';

    }

    $fm->_pushToModificationBuffer([$branchRule, $operation]);

    return $branchRule;

}

=head getBranchRule

    my $branchRule = $fm->getBranchRule( $fromBranch, $toBranch );

@PARAM1 String, koha.floating_matrix.from_branch, must give @PARAM2 as well

@PARAM2 String, koha.floating_matrix.to_branch, must give @PARAM1 as well

@RETURNS Koha::FloatingMatrix::BranchRule-object matching the params or undef.

=cut

sub getBranchRule {

    my ($fm, $fromBranch, $toBranch) = @_;

    my $branchRule = $fm->_findBranchRule(undef, $fromBranch, $toBranch);

    return $branchRule;

}

=head getBranchRules

    my $branchRules = $fm->getBranchRules();

@RETURNS Reference to a HASH of Koha::FloatingMatrix::BranchRule-objects

         Hash keys are <fromBranch>-<toBranch>, eg. FFL-CPL

=cut

sub getBranchRules {

    my ($fm) = @_;

    return $fm->{branchRules};

}

=head _setBranchRules

Needs to be called only from the _getFloatingMatrix() to bind the branchRules-map to this object.

@PARAM1, Reference to HASH.

=cut

sub _setBranchRules {

    my ($fm, $hash) = @_;

    $fm->{branchRules} = $hash;

}

sub checkFloating {

    my ($fm, $item, $checkinBranch, $transferTargetBranch) = @_;

    unless ($transferTargetBranch) { #If no transfer branch is given, then we try our best to figure it out.

        my $branchItemRule = C4::Circulation::GetBranchItemRule($item->{'homebranch'}, $item->{'itype'});

        my $returnBranchRule = $branchItemRule->{'returnbranch'} || "homebranch";

        # get the proper branch to which to return the item

        $transferTargetBranch = $item->{$returnBranchRule} || C4::Context->userenv->{'branch'};

    }

    #If the check-in branch and transfer branch are the same, then no point in transferring.

    if ($checkinBranch eq $transferTargetBranch) {

        return undef;

    }

    my $branchRule = $fm->getBranchRule($checkinBranch, $transferTargetBranch);

    if ($branchRule) {

        my $floating = $branchRule->getFloating();

        if ($floating eq 'ALWAYS') {

            return 'ALWAYS';

        }

        elsif ($floating eq 'POSSIBLE') {

            return 'POSSIBLE';

        }

        elsif ($floating eq 'CONDITIONAL') {

            if(_CheckConditionalFloat($item, $branchRule)) {

                return 'ALWAYS';

            }

        }

        else {

            warn "FloatingMatrix->checkFloating():> Bad floating type for route from '$checkinBranch' to '$transferTargetBranch'. Not floating.\n";

        }

    }

    return undef;

}

=head _CheckConditionalFloat

Static method

@PARAM1, HASH of koha.items-row

@PARAM2, Koha::FloatingMatrix::BranchRule-object

@RETURNS 1 if floats, undef if not.

=cut

sub _CheckConditionalFloat {

    my ($item, $branchRule) = @_;

    my $conditionRules = $branchRule->getConditionRules();

    my $evalCondition = '';

    if (my @conds = $conditionRules =~ /(\w+)\s+(ne|eq|gt|lt|<|>|==|!=)\s+(\w+)\s*(and|or|xor|&&|\|\|)?/ig) {

        #Iterate the condition quads, with the fourth index being the logical join operator.

        for (my $i=0 ; $i<scalar(@conds) ; $i+=4) {

            my $column = $conds[$i];

            my $operator = $conds[$i+1];

            my $value = $conds[$i+2];

            my $join = $conds[$i+3] || '';

            $evalCondition .= join(' ',"\$item->{'$column'}",$operator,"'$value'",$join,'');

        }

    }

    else {

        warn "Koha::FloatingMatrix::_CheckConditionalFloat():> Bad condition rules '$conditionRules' couldn't be parsed\n";

        return undef;

    }

    my $ok = eval("return 1 if($evalCondition);");

    if ($@) {

        warn "Koha::FloatingMatrix::_CheckConditionalFloat():> Something bad hapened when trying to evaluate the dynamic conditional:\n$@\n";

        return undef;

    }

    return $ok;

}

=head CheckFloating

Static Subroutine

A convenience Subroutine to checkFloating without intantiating a new Koha::FloatingMatrix-object

=cut

sub CheckFloating {

    my ($item, $checkinBranch, $transferTargetBranch) = @_;

    my $fm = Koha::FloatingMatrix->new();

    return $fm->checkFloating($item, $checkinBranch, $transferTargetBranch);

}

=head _findBranchRule

    my $branchRule = $fm->_findBranchRule( undef, $fromBranch, $toBranch );

    my $existingBranchRule = $fm->_findBranchRule( $branchRule );

Finds a branch rule from the internal floating matrix map.

This abstracts the retrieval of branch rules, so we can later change the internal mapping.

@PARAM1, Koha::FloatingMatrix::BranchRule-object, to see if a BranchRule with same targeting rules is present.

         or undef, if you are only interested in retrieving.

@PARAM2-3, MANDATORY if no @PARAM1 given, Targeting rules to find a BranchRule.

@RETURNS Koha::FloatingMatrix::BranchRule-object, of the object occupying the given position.

         or undef if nothing is found.

=cut

sub _findBranchRule {

    my ($fm, $branchRule, $fromBranch, $toBranch) = @_;

    if (blessed($branchRule) && $branchRule->isa('Koha::FloatingMatrix::BranchRule')) {

        $fromBranch = $branchRule->getFromBranch();

        $toBranch   = $branchRule->getToBranch();

    }

    my $existingBranchRule = $fm->getBranchRules()->{  $fromBranch  }->{  $toBranch  };

    return $existingBranchRule;

}

=head _linkBranchRule

    my $existingBranchRule = $fm->_linkBranchRule( $branchRule );

Links the new branchrule to the internal floating matrix map, overwriting a possible existing

reference to a BranchRule, and losing that into the binary limbo.

This abstracts the retrieval of floating matrix routes, so we can later change the internal mapping.

@PARAM1, Koha::FloatingMatrix::BranchRule-object, to link to the internal mapping

=cut

sub _linkBranchRule {

    my ($fm, $branchRule) = @_;

    $fm->{branchRules}->{  $branchRule->getFromBranch()  }->{  $branchRule->getToBranch()  } = $branchRule;

}

=head _unlinkBranchRule

    my $existingBranchRule = $fm->_unlinkBranchRule( $branchRule );

Unlinks the branchRule from the internal floating matrix map and releasing it into the binary limbo.

This abstracts the internal mapping of branch rules, so we can later change it.

@PARAM1, Koha::FloatingMatrix::BranchRule-object

=cut

sub _unlinkBranchRule {

    my ($fm, $branchRule) = @_;

    #Delete the BranchRule

    my $branchRules = $fm->getBranchRules();

    my $fromBranch = $branchRule->getFromBranch();

    my $toBranch = $branchRule->getToBranch();

    eval{ delete( $branchRules->{  $fromBranch  }->{  $toBranch  } ); };

    if ($@) {

        carp "Unlinking BranchRule failed because of '".$@."'. Something wrong with this BranchRule\n".$branchRule->toString()."\n";

        return $@;

    }

    unless (scalar(%{$branchRules->{  $fromBranch  }})) {

        #Delete the branchLevel

        delete( $branchRules->{  $fromBranch  } );

    }

}

=head deleteBranchRule

    $fm->deleteBranchRule($branchRule);

    $fm->deleteBranchRule($fromBranch, $toBranch);

Deletes the BranchRule from the internal mapping, but not from the DB.

Call $fm->store() to persist the removal.

The given $branchRule must be the same object gained using $fm->getBranchRule(),

or you are misusing the FloatingMatrix-object and bad things might happen.

@PARAM1, Koha::FloatingMatrix::BranchRule-object to delete from DB.

or

@PARAM1 {String, koha.floating_matrix.from_branch}

@PARAM1 {String, koha.floating_matrix.to_branch}

@THROWS Koha::Exceptions::BadParameter if no branchRule, with the given parameters, is found,

                or the given BranchRule doesn't match the one in the internal mapping.

=cut

sub deleteBranchRule {

    my ($fm, $fromBranch, $toBranch) = @_;

    my ($branchRule, $branchRuleLocal);

    #Process given parameters, see if we use parameter group1 (BranchRule-object) or group2 (branchcodes)?

    if (blessed $fromBranch && $fromBranch->isa('Koha::FloatingMatrix::BranchRule')) {

        $branchRule = $fromBranch;

        $fromBranch = $branchRule->getFromBranch();

        $toBranch = $branchRule->getToBranch();

    }

    $branchRuleLocal = $fm->getBranchRule($fromBranch, $toBranch);

    Koha::Exceptions::BadParameter->throw(error => "Koha::FloatingMatrix->deleteBranchRule($fromBranch, $toBranch):> No BranchRule exists for the given fromBranch '$fromBranch' and toBranch '$toBranch'")

                unless $branchRuleLocal;

    $fm->_unlinkBranchRule(  $branchRuleLocal  );

    $fm->_pushToModificationBuffer([$branchRuleLocal, 'DEL']);

}

=head $fm->deleteAllFloatingMatrixRules()

Deletes all Floating matrix rules in the DB, shows no pity.

Invalidates $fm in the Koha::Caches

=cut

sub deleteAllFloatingMatrixRules {

    my ($fm) = @_;

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

    $schema->resultset('FloatingMatrix')->search({})->delete_all;

    $fm = undef;

    my $cache = Koha::Caches->get_instance();

    $cache->clear_from_cache('floatingMatrix');

}

=head store

    $fm->store();

Saves all pending transactions to DB, by calling the Koha::FloatingMatrix::BranchRule->store() || delete();

=cut

sub store {

    my $fm = shift;

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

    my $pendingModifications = $fm->_consumeModificationBuffer();

    foreach my $modRequest (@$pendingModifications) {

        my $branchRule = $modRequest->[0];

        my $operation = $modRequest->[1];

        if ($operation eq 'MOD' || $operation eq 'ADD') {

            $branchRule->store();

        }

        elsif ($operation eq 'DEL') {

            $branchRule->delete();

        }

        else {

            carp "Unsupported database access operation '$operation'!";

        }

    }

    my $cache = Koha::Caches->get_instance();

    $cache->set_in_cache('floatingMatrix', $fm, {expiry => $cacheExpiryTime});

}

=head _pushToModificationBuffer

    $fm->_pushToModificationBuffer([$branchRule, $operation]);

To be able to more effectively service DB write operations, especially when using

FloatingMatrix with an REST(ful?) API giving lots of write operations, it is useful

to be able to know which BranchRules need changing and which do not.

Thus we don't need to either

DELETE all BranchRules from DB and re-add them (what if the rewrite request dies?)

  or

check each rule for possible changes.

The modification buffer tells what information needs changing.

To write the changes to DB, use $fm->store().

@PARAM1, Tuple (Two-index ARRAY reference). [0] = $branchRule (see. upsertBranchRule())

                                            [1] = The operation, either 'ADD', 'MOD' or 'DEL'

@RETURN, always nothing.

=cut

sub _pushToModificationBuffer {

    my ($fm, $tuple) = @_;

    push @{$fm->{modBuffer}}, $tuple;

    return undef;

}

=head _consumeModificationBuffer

Detaches the modification buffer from the FloatingMatrix (parent) and returns it.

Fm now has an empty modification buffer ready for new modifications.

=cut

sub _consumeModificationBuffer {

    my ($fm) = @_;

    my $modBuffer = $fm->{modBuffer};

    $fm->{modBuffer} = [];

    return $modBuffer;

}

sub _createModificationBuffer {

    my ($fm) = @_;

    $fm->{modBuffer} = [];

    return undef;

}

1; #Satisfy the compiler

package Koha::FloatingMatrix::BranchRule;

# Copyright 2015 Vaara-kirjastot

#

# 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 2 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.

=head1 Rule

Koha::FloatingMatrix::BranchRule - Object representing floating rules for one branch

=head1 DESCRIPTION

=cut

use Modern::Perl;

use Carp qw(carp croak confess longmess);

use Scalar::Util 'blessed';

use Data::Dumper;

use C4::Context qw(dbh);

use Koha::Cache;

use Koha::Database;

use Koha::Exceptions::BadParameter;

=head new

    my ($branchRule, $error) = Koha::FloatingMatrix::BranchRule->new({

                                    fromBranch => 'CPL',

                                    toBranch => 'FFL',

                                    floating => ['ALWAYS'|'POSSIBLE'|'CONDITIONAL'],

                                    conditionRules => "items->{itype} eq 'BK' && $items->{permanent_location} eq 'CART'"

                                });

BranchRule defines the floating rule for one transfer route.

Eg. If you check-in an Item to CFL and based on your library policies tha Item is transferred to IPT,

We check if there is a floating rule for that fromBranch-toBranch -combination and apply that if applicable.

@PARAM1, HASH

@RETURN, Koha::FloatingMatrix::BranchRule-object,

@THROWS Koha::Exceptions::BadParameter if given parameters don't validate properly.

=cut

sub new {

    my ($class, $params) = @_;

    ValidateParams($params);

    bless $params, $class;

    return $params;

}

=head newFromDBIx

    Koha::FloatingMatrix::BranchRule->newFromDBIx(  $Koha::Schema::Result::FloatingMatrix  );

Creates a BranchRule-object from DBIx.

See new() for more info.

=cut

sub newFromDBIx {

    my ($class, $dbix) = @_;

    my $params = {

                id => $dbix->id(),

                fromBranch => $dbix->get_column('from_branch'),

                toBranch => $dbix->get_column('to_branch'),

                floating => $dbix->get_column('floating'),

                conditionRules => $dbix->get_column('condition_rules'),

            };

    return $class->new($params);

}

=head ValidateParams, Static subroutine

    my $error = Koha::Overdues::OverdueRule::ValidateParams($params);

@PARAM1, HASH, see new() for valid values.

@THROWS Koha::Exceptions::BadParameter if given parameters don't validate properly.

=cut

my $maximumConditionRulesDatabaseLength = 100;

sub ValidateParams {

    my ($params) = @_;

    my $errorMsg;

    if (not($params->{fromBranch}) || length $params->{fromBranch} < 1) {

        $errorMsg = "No 'fromBranch'";

    }

    elsif (not($params->{toBranch}) || length $params->{toBranch} < 1) {

        $errorMsg = "No 'toBranch'";

    }

    elsif (not($params->{floating}) || length $params->{floating} < 1) {

        $errorMsg = "No 'floating'";

    }

    elsif ($params->{floating} &&  ($params->{floating} ne 'CONDITIONAL' &&

                                    $params->{floating} ne 'ALWAYS' &&

                                    $params->{floating} ne 'POSSIBLE')

                                   ) {

        $errorMsg = "Bad enum '".$params->{floating}."' for 'floating'";

    }

    elsif (not($params->{conditionRules}) && $params->{floating} eq 'CONDITIONAL') {

        $errorMsg = "No 'conditionRules' when floating = 'CONDITIONAL'";

    }

    elsif ($params->{conditionRules} && $params->{conditionRules} =~ /[};{]/gsmi) {

        $errorMsg = "Not allowed 'conditionRules' characters '};{' present";

    }

    elsif ($params->{conditionRules} && length($params->{conditionRules}) > $maximumConditionRulesDatabaseLength) {

        $errorMsg = "'conditionRules' text is too long. Maximum length is '$maximumConditionRulesDatabaseLength' characters";

    }

    elsif ($params->{conditionRules}) {

        ParseConditionRules(undef, $params->{conditionRules});

    }

    if ($errorMsg) {

        my $fb = $params->{fromBranch} || '';

        my $tb = $params->{toBranch} || '';

        my $id = $params->{id} || '';

        Koha::Exceptions::BadParameter->throw(error => "Koha::FloatingMatrix::BranchRule::ValidateParams():> $errorMsg. For branch rule id '$id', fromBranch '$fb', toBranch '$tb'.");

    }

    #Now that we have sanitated the input, we can rest assured that bad input won't crash this Object :)

}

=head parseConditionRules, Static method

    my $evalCondition = ParseConditionRules($item, $conditionRules);

    my $evalCondition = ParseConditionRules(undef, $conditionRules);

Parses the given Perl boolean expression into an eval()-able expression.

If Item is given, uses the Item's columns to create a executable expression to check for

conditional floating for this specific Item.

@PARAM1 {Reference to HASH of koha.items-row} Item to check for conditional floating.

@PARAM2 {String koha.floating_matrix.condition_rules} The boolean expression to turn

                    into a Perl code to check the floating condition.

@THROWS Koha::Exceptions::BadParameter, if the conditionRules couldn't be parsed.

=cut

sub ParseConditionRules {

    my ($item, $conditionRulesString) = @_;

    my $evalCondition = '';

    if (my @conds = $conditionRulesString =~ /(\w+)\s+(ne|eq|gt|lt|<|>|==|!=)\s+(\w+)\s*(and|or|xor|&&|\|\|)?/ig) {

        #If we haven't got no Item, simply stop here to aknowledge that the given condition logic is valid (atleast parseable)

        return undef unless $item;

        #If we have an Item, then prepare and return an eval-expression to test if the Item should float.

        #Iterate the condition quads, with the fourth index being the logical join operator.

        for (my $i=0 ; $i<scalar(@conds) ; $i+=4) {

            my $column = $conds[$i];

            my $operator = $conds[$i+1];

            my $value = $conds[$i+2];

            my $join = $conds[$i+3] || '';

            $evalCondition .= join(' ',"\$item->{'$column'}",$operator,"'$value'",$join,'');

        }

        return $evalCondition;

    }

    else {

        Koha::Exceptions::BadParameter->throw(error =>

                    "Koha::FloatingMatrix::parseConditionRules():> Bad condition rules '$conditionRulesString' couldn't be parsed\n".

                    "See 'Help' for more info");

    }

}

=head replace

    my $fmBranchRule->replace( $replacementBranchRule );

Replaces the calling branch rule's keys with the given parameters'.

=cut

sub replace {

    my ($branchRule, $replacementBranchRule) = @_;

    foreach my $key (keys %$replacementBranchRule) {

        $branchRule->{$key} = $replacementBranchRule->{$key};

    }

}

=head clone

    $fmBranchCode->clone();

Returns a duplicate of self

=cut

sub clone {

    my ($branchRule) = @_;

    my %newBranchRuleParams;

    foreach my $key (keys %$branchRule) {

        $newBranchRuleParams{$key} = $branchRule->{$key};

    }

    return Koha::FloatingMatrix::BranchRule->new(\%newBranchRuleParams);

}

=head store

Saves the BranchRule into the floating_matrix-table

@THROWS Koha::Exceptions::BadParameter if id given but no object exists with that id.

=cut

sub store {

    my $branchRule = shift;

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

    my $params = $branchRule->_buildBranchRuleColumns();

    my $id = $branchRule->getId();

    my $oldBranchRule;

    if ($id) {

        $oldBranchRule = $schema->resultset( 'FloatingMatrix' )->find( $id );

    }

    if ($id && not($oldBranchRule)) {

        Koha::Exceptions::BadParameter->throw(error => "Koha::FloatingMatrix::BranchRule->store():> floating_matrix.id given, but no matching row exist in DB");

    }

    if ($oldBranchRule) {

        $oldBranchRule->update( $params );

    }

    else {

        my $newBranchRule = $schema->resultset( 'FloatingMatrix' )->create( $params );

        $branchRule->setId( $newBranchRule->id() );

    }

}

=head _buildBranchRuleColumns

Transforms the BranchRule into a DBIx $parameters HASH which can be UPDATED to DB.

DBIx is crazy about excess parameters with no mapped DB column, so we cannot just pass the

BranchRule-object to the DBIx.

=cut

sub _buildBranchRuleColumns {

    my ($branchRule) = @_;

    my $columns = {};

    $columns->{"from_branch"} = $branchRule->getFromBranch();

    $columns->{"to_branch"} = $branchRule->getToBranch();

    $columns->{"floating"} = $branchRule->getFloating();

    $columns->{"condition_rules"} = $branchRule->getConditionRules();

    return $columns;

}

sub delete {

    my ($branchRule) = @_;

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

    $schema->resultset('FloatingMatrix')->find($branchRule->getId())->delete();

}

sub setId {

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

    if ($val) {

        $self->{id} = $val;

    }

    else {

        delete $self->{id};

    }

}

sub getId {

    my ($self) = @_;

    return $self->{id};

}

sub setFromBranch {

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

    $self->{fromBranch} = $fromBranch;

}

sub getFromBranch {

    my ($self) = @_;

    return $self->{fromBranch};

}

sub setToBranch {

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

    $self->{toBranch} = $toBranch;

}

sub getToBranch {

    my ($self) = @_;

    return $self->{toBranch};

}

sub setFloating {

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

    $self->{floating} = $val;

}

sub getFloating {

    my ($self) = @_;

    return $self->{floating};

}

=head setConditionRules

See parseConditionRules()

@THROWS Koha::Exceptions::BadParameter, if the conditionRules couldn't be parsed.

=cut

sub setConditionRules {

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

    #Validate the conditinal rules.

    ParseConditionRules(undef, $val);

    $self->{conditionRules} = $val;

}

sub getConditionRules {

    my ($self) = @_;

    return $self->{conditionRules};

}

=head toString

    my $stringRepresentationOfThisObject = $branchRule->toString();

    print $stringRepresentationOfThisObject."\n";

=cut

sub toString {

    my ($self) = @_;

    return Data::Dumper::Dump($self);

}

=head TO_JSON

    my $json = JSON::XS->new->utf8->convert_blessed->encode( $branchRule );

    or

    my $json = $branchRule->TO_JSON();

Used to serialize this object as JSON.

=cut

sub TO_JSON {

    my ($branchRule) = @_;

    my $json = {};

    while (my ($key, $val) = each(%$branchRule)) {

        $json->{$key} = $val;

    }

    return $json;

}

1; #Satisfy the compiler

=head2 floating_matrixes_from_branch

Type: has_many

Related object: L<Koha::Schema::Result::FloatingMatrix>

=cut

__PACKAGE__->has_many(

  "floating_matrixes_from_branch",

  "Koha::Schema::Result::FloatingMatrix",

  { "foreign.from_branch" => "self.branchcode" },

  { cascade_copy => 0, cascade_delete => 0 },

);

=head2 floating_matrixes_to_branch

Type: has_many

Related object: L<Koha::Schema::Result::FloatingMatrix>

=cut

__PACKAGE__->has_many(

  "floating_matrixes_to_branch",

  "Koha::Schema::Result::FloatingMatrix",

  { "foreign.to_branch" => "self.branchcode" },

  { cascade_copy => 0, cascade_delete => 0 },

);

use utf8;

package Koha::Schema::Result::FloatingMatrix;

# Created by DBIx::Class::Schema::Loader

# DO NOT MODIFY THE FIRST PART OF THIS FILE

=head1 NAME

Koha::Schema::Result::FloatingMatrix

=cut

use strict;

use warnings;

use base 'DBIx::Class::Core';

=head1 TABLE: C<floating_matrix>

=cut

__PACKAGE__->table("floating_matrix");

=head1 ACCESSORS

=head2 id

  data_type: 'integer'

  is_auto_increment: 1

  is_nullable: 0

=head2 from_branch

  data_type: 'varchar'

  is_foreign_key: 1

  is_nullable: 0

  size: 10

=head2 to_branch

  data_type: 'varchar'

  is_foreign_key: 1

  is_nullable: 0

  size: 10

=head2 floating

  data_type: 'enum'

  default_value: 'ALWAYS'

  extra: {list => ["ALWAYS","POSSIBLE","CONDITIONAL"]}

  is_nullable: 0

=head2 condition_rules

  data_type: 'varchar'

  is_nullable: 1

  size: 100

=cut

__PACKAGE__->add_columns(

  "id",

  { data_type => "integer", is_auto_increment => 1, is_nullable => 0 },

  "from_branch",

  { data_type => "varchar", is_foreign_key => 1, is_nullable => 0, size => 10 },

  "to_branch",

  { data_type => "varchar", is_foreign_key => 1, is_nullable => 0, size => 10 },

  "floating",

  {

    data_type => "enum",

    default_value => "ALWAYS",

    extra => { list => ["ALWAYS", "POSSIBLE", "CONDITIONAL"] },

    is_nullable => 0,

  },

  "condition_rules",

  { data_type => "varchar", is_nullable => 1, size => 100 },

);

=head1 PRIMARY KEY

=over 4

=item * L</id>

=back

=cut

__PACKAGE__->set_primary_key("id");

=head1 UNIQUE CONSTRAINTS

=head2 C<floating_matrix_uniq_branches>

=over 4

=item * L</from_branch>

=item * L</to_branch>

=back

=cut

__PACKAGE__->add_unique_constraint("floating_matrix_uniq_branches", ["from_branch", "to_branch"]);

=head1 RELATIONS

=head2 from_branch

Type: belongs_to

Related object: L<Koha::Schema::Result::Branch>

=cut

__PACKAGE__->belongs_to(

  "from_branch",

  "Koha::Schema::Result::Branch",

  { branchcode => "from_branch" },

  { is_deferrable => 1, on_delete => "CASCADE", on_update => "CASCADE" },

);

=head2 to_branch

Type: belongs_to

Related object: L<Koha::Schema::Result::Branch>

=cut

__PACKAGE__->belongs_to(

  "to_branch",

  "Koha::Schema::Result::Branch",

  { branchcode => "to_branch" },

  { is_deferrable => 1, on_delete => "CASCADE", on_update => "CASCADE" },

);

# Created by DBIx::Class::Schema::Loader v0.07049 @ 2020-03-10 09:28:20

# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:jOVU1Wag0o96NkjrnPjsvg

# You can replace this text with custom code or comments, and it will be preserved on regeneration

1;

#!/usr/bin/perl

# Copyright 2015 Vaara-kirjastot

#

# 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 2 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 CGI qw ( -utf8 );

use Try::Tiny;

use Scalar::Util qw(blessed);

use JSON::XS;

use C4::Context;

use C4::Output;

use C4::Auth qw(check_cookie_auth);

use C4::Items;

use Koha::FloatingMatrix;

my $input = new CGI;

#my ( $auth_status, $sessionID ) =

#  check_cookie_auth( $input->cookie('CGISESSID'),

#    { circulate => 'circulate_remaining_permissions' } );

my ( $auth_status, $sessionID ) =

  check_cookie_auth( $input->cookie('CGISESSID'),

                    {

                        parameters => 1,

                    } );

binmode STDOUT, ":encoding(UTF-8)";

my $fm = Koha::FloatingMatrix->new();

my $data = $input->Vars();

if ($data) {

    try {

        ##If we are getting a DELETE-request, we DELETE (CGI doesn't know what DELETE is :(((

        if ($data->{delete}) {

            $fm->deleteBranchRule($data->{fromBranch}, $data->{toBranch});

            $fm->store();

        }

        elsif ($data->{test}) {

            my $item = C4::Items::GetItem(undef, $data->{barcode});

            if ($data->{barcode} && $item) {

                $data->{testResult} = $fm->checkFloating($item, $data->{fromBranch}, $data->{toBranch});

            }

            else {

                Koha::Exceptions::BadParameter->throw(error => "No Item found using barcode '".$data->{barcode}."'");

            }

        }

        ##If we are getting a POST-request, we UPSERT

        else {

            $fm->upsertBranchRule($data);

            $fm->store();

        }

    } catch {

        if (blessed $_ && $_->isa('Koha::Exceptions::BadParameter')) {

            respondBadParameterException($_);

        }

        else {

            die $_;

        }

    };

    print $input->header( -type => 'text/json',

                          -charset => 'UTF-8',

                          -status => "200 OK");

    print JSON::XS->new->utf8->convert_blessed->encode($data);

}

else {

    print $input->header( -type => 'text/plain',

                          -charset => 'UTF-8',

                          -status => "405 Method Not Allowed");

}

sub respondBadParameterException {

    my ($e) = @_;

    print $input->header( -type => 'text/json',

                          -charset => 'UTF-8',

                          -status => "400 Bad Request");

    print JSON::XS->new->utf8->encode({error => $e->as_string()});

    exit 1;

}

#!/usr/bin/perl

# Copyright 2015 Vaara-kirjastot

#

# 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 2 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 CGI qw ( -utf8 );

use C4::Context;

use C4::Output;

use C4::Auth;

use Koha::FloatingMatrix;

my $input = new CGI;

my ($template, $loggedinuser, $cookie)

    = get_template_and_user({template_name => "admin/floating-matrix.tt",

                            query => $input,

                            type => "intranet",

                            authnotrequired => 0,

                            flagsrequired => {parameters => 1},

                            debug => 1,

                            });

my $operation = 'showMatrix'; #Default op is show.

my $fm = Koha::FloatingMatrix->new();

my $branches = Koha::Libraries->search();

$template->param(

    fm => $fm,

    branches => $branches,

);

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

exit 0;

=head

my $update = $input->param('op') eq 'set-cost-matrix';

my ($cost_matrix, $have_matrix);

unless ($update) {

    $cost_matrix = TransportCostMatrix();

    $have_matrix = keys %$cost_matrix if $cost_matrix;

}

my $branches = GetBranches();

my @branchloop = map { code => $_,

                       name => $branches->{$_}->{'branchname'} },

                 sort { $branches->{$a}->{branchname} cmp $branches->{$b}->{branchname} }

                 keys %$branches;

my (@branchfromloop, @cost, @errors);

foreach my $branchfrom ( @branchloop ) {

    my $fromcode = $branchfrom->{code};

    my %from_row = ( code => $fromcode, name => $branchfrom->{name} );

    foreach my $branchto ( @branchloop ) {

        my $tocode = $branchto->{code};

        my %from_to_input_def = ( code => $tocode, name => $branchto->{name} );

        push @{ $from_row{branchtoloop} }, \%from_to_input_def;

        if ($fromcode eq $tocode) {

            $from_to_input_def{skip} = 1;

            next;

        }

        (my $from_to = "${fromcode}_${tocode}") =~ s/\W//go;

         $from_to_input_def{id} = $from_to;

        my $input_name   = "cost_$from_to";

        my $disable_name = "disable_$from_to";

        if ($update) {

            my $value = $from_to_input_def{value} = $input->param($input_name);

            if ( $input->param($disable_name) ) {

                $from_to_input_def{disabled} = 1;

            }

            else {

                push @errors, "$from_row{name} -> $from_to_input_def{name}"

                  unless $value =~ /\d/o && $value >= 0.0;

            }

        }

        else {

            if ($have_matrix) {

                if ( my $cell = $cost_matrix->{$tocode}{$fromcode} ) {

                    $from_to_input_def{value} = $cell->{cost};

                    $from_to_input_def{disabled} = 1 if $cell->{disable_transfer};

                } else {

                    # matrix has been previously initialized, but a branch referenced here was created afterward.

                    $from_to_input_def{disabled} = 1;

                }

            } else {

                # First time initializing the matrix

                $from_to_input_def{disabled} = 1;

            }

        }

    }

#              die Dumper(\%from_row);

    push @branchfromloop, \%from_row;

}

if ($update && !@errors) {

    my @update_recs = map {

        my $from = $_->{code};

        map { frombranch => $from, tobranch => $_->{code}, cost => $_->{value}, disable_transfer => $_->{disabled} || 0 },

            grep { $_->{code} ne $from }

            @{ $_->{branchtoloop} };

    } @branchfromloop;

    UpdateTransportCostMatrix(\@update_recs);

}

$template->param(

    branchloop => \@branchloop,

    branchfromloop => \@branchfromloop,

    errors => \@errors,

);

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

exit 0;

=cut

$DBversion = 'XXX';  # will be replaced by the RM

if( CheckVersion( $DBversion ) ) {

    #Check if the table has already been CREATEd and possibly CREATE it

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

    my $sth = $dbh->table_info( '', '', 'floating_matrix', 'TABLE' );

    my $table = $sth->fetchrow_hashref();

    unless ($table) {

        $dbh->do("

        CREATE TABLE floating_matrix ( -- Controls should we automatically transfer Items checked in to one branch to the Item's configured normal destination

            id int(11) NOT NULL AUTO_INCREMENT, -- unique id

            from_branch varchar(10) NOT NULL, -- branch where the Item has been checked in

            to_branch varchar(10) NOT NULL, -- where the Item would normally be transferred to

            floating enum('ALWAYS','POSSIBLE','CONDITIONAL') NOT NULL DEFAULT 'ALWAYS', -- type of floating; ALWAYS just skips any transports, POSSIBLE prompts if a transport is needed, CONDITIONAL is like ALWAYS if condition is met

            condition_rules varchar(100), -- if floating = CONDITIONAL, then the special condition to trigger floating.

            CHECK ( from_branch <> to_branch ), -- a dud check, mysql does not support that

            PRIMARY KEY (`id`),

            UNIQUE KEY `floating_matrix_uniq_branches` (`from_branch`,`to_branch`),

            CONSTRAINT floating_matrix_ibfk_1 FOREIGN KEY (from_branch) REFERENCES branches (`branchcode`) ON DELETE CASCADE ON UPDATE CASCADE,

            CONSTRAINT floating_matrix_ibfk_2 FOREIGN KEY (to_branch) REFERENCES branches (`branchcode`) ON DELETE CASCADE ON UPDATE CASCADE

        ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;

        ");

        SetVersion( $DBversion );

        print "Upgrade to $DBversion done (Bug 9525 - group floating rules)\n";

    }

}

--

-- Table structure for table `floating_matrix`

--

DROP TABLE IF EXISTS floating_matrix;

CREATE TABLE floating_matrix ( -- Controls should we automatically transfer Items checked in to one branch to the Item's configured normal destination

    id int(11) NOT NULL AUTO_INCREMENT, -- unique id

    from_branch varchar(10) NOT NULL, -- branch where the Item has been checked in

    to_branch varchar(10) NOT NULL, -- where the Item would normally be transferred to

    floating enum('ALWAYS','POSSIBLE','CONDITIONAL') NOT NULL DEFAULT 'ALWAYS', -- type of floating; ALWAYS just skips any transports, POSSIBLE prompts if a transport is needed, CONDITIONAL is like ALWAYS if condition is met

    condition_rules varchar(100), -- if floating = CONDITIONAL, then the special condition to trigger floating.

    CHECK ( from_branch <> to_branch ), -- a dud check, mysql does not support that

    PRIMARY KEY (`id`),

    UNIQUE KEY `floating_matrix_uniq_branches` (`from_branch`,`to_branch`),

    CONSTRAINT floating_matrix_ibfk_1 FOREIGN KEY (from_branch) REFERENCES branches (`branchcode`) ON DELETE CASCADE ON UPDATE CASCADE,

    CONSTRAINT floating_matrix_ibfk_2 FOREIGN KEY (to_branch) REFERENCES branches (`branchcode`) ON DELETE CASCADE ON UPDATE CASCADE

) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;

.cssload-loader {

	position: relative;

	left: calc(50% - 8px);

	width: 16px;

	height: 16px;

	border-radius: 50%;

		-moz-border-radius: 50%;

	perspective: 200px;

    margin-top: 3px;

    visibility: hidden;

}

.cssload-inner {

	position: absolute;

	width: 100%;

	height: 100%;

	box-sizing: border-box;

		-moz-box-sizing: border-box;

	border-radius: 50%;

		-moz-border-radius: 50%;

}

.cssload-inner.cssload-one {

	left: 0%;

	top: 0%;

	animation: cssload-rotate-one 1.3s linear infinite;

		-moz-animation: cssload-rotate-one 1.3s linear infinite;

	border-bottom: 2px solid rgb(0,0,0);

}

.cssload-inner.cssload-two {

	right: 0%;

	top: 0%;

	animation: cssload-rotate-two 1.3s linear infinite;

		-moz-animation: cssload-rotate-two 1.3s linear infinite;

	border-right: 2px solid rgb(0,0,0);

}

.cssload-inner.cssload-three {

	right: 0%;

	bottom: 0%;

	animation: cssload-rotate-three 1.3s linear infinite;

		-moz-animation: cssload-rotate-three 1.3s linear infinite;

	border-top: 2px solid rgba(0,0,0,0.99);

}

@keyframes cssload-rotate-one {

	0% {

		transform: rotateX(35deg) rotateY(-45deg) rotateZ(0deg);

	}

	100% {

		transform: rotateX(35deg) rotateY(-45deg) rotateZ(360deg);

	}

}

@keyframes cssload-rotate-two {

	0% {

		transform: rotateX(50deg) rotateY(10deg) rotateZ(0deg);

	}

	100% {

		transform: rotateX(50deg) rotateY(10deg) rotateZ(360deg);

	}

}

@keyframes cssload-rotate-three {

	0% {

		transform: rotateX(35deg) rotateY(55deg) rotateZ(0deg);

	}

	100% {

		transform: rotateX(35deg) rotateY(55deg) rotateZ(360deg);

	}

}

.disabled-transfer {

    background-color: #FF8888;

}

#testResulDisplay { width: 20px;

                    height: 22px;

                    background-color: #B9D8D9;

                    vertical-align: middle;

                    display: inline-block;

}

.branchRule select { width: 100%; }

.branchRule select {padding: 0px; margin: 5px 0px;}

.branchRule input {padding: 0px; margin: 0px;}

.branchRule input[type="text"]  { width: 100%; display: none; }

.branchRule input[type="submit"] {display:none}

.branchRule.selected {color: #1b93d3; box-shadow:0px 0px 10px;}

.branchRule.selected input[type="submit"] {display:initial;}

.branchRule.selected input[type="text"] {display:initial;  border: 0px none;}

.failedAjax {box-shadow:0px 0px 30px 20px #ff0000}

.TEMPLATE {display: none; visibility: hidden;}

[%# Summon this block to the template by INCLUDEing it like this in the header:

        % INCLUDE 'admin/floating-matrix-floatingType.inc' %

    You must have the required parameters in the template toolkit parameter-space.

%]

[%#REQUIRES branchRule (Koha::FloatingMatrix::BranchRule), fm (Koha::FloatingMatrix) %]

[% preselectedFloatingType = branchRule.getFloating() %]

    <select name="floating">

        <option value="DISABLED"[% IF ! preselectedFloatingType %] selected="selected"[% END %]>

            Disabled

        </option>

        [% FOR floatingType IN fm.getFloatingTypes() %]

            <option value="[% floatingType %]"[% IF floatingType == preselectedFloatingType %] selected="selected"[% END %]>

                [% SWITCH floatingType %]

                [% CASE 'ALWAYS' %]

                    Always

                [% CASE 'POSSIBLE' %]

                    Possible

                [% CASE 'CONDITIONAL' %]

                    Conditional

                [% CASE %]

                    Unknown floating type '[% floatingType %]'

                [% END #SWITCH floatingType %]

            </option>

        [% END #FOR fm.getFloatingTypes() %]

    </select>

                    <dt><a href="/cgi-bin/koha/admin/floating-matrix.pl">Floating matrix</a></dt>

                    <dd>Define floating rules between branches</dd>

[% USE raw %]

[% USE Asset %]

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

<title>Koha &rsaquo; Administration &rsaquo; Floating matrix</title>

[% Asset.css("css/floating-matrix.css") | $raw %]

[% Asset.css("css/floating-matrix-loader.css") | $raw %]

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

</head>

<body>

[% INCLUDE 'header.inc' %]

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

<div id="breadcrumbs"><a href="/cgi-bin/koha/mainpage.pl">Home</a> &rsaquo; <a href="/cgi-bin/koha/admin/admin-home.pl">Administration</a> &rsaquo; Floating matrix</div>

<div class="main container-fluid">

    <div class="row">

        <div class="col-sm-10 col-sm-push-2">

            <main>

                <h1 class="parameters">

                        Defining floating rules between libraries

                </h1>

                <fieldset>

                    <div class="help">

                        <p>There are four types of floating:</p>

                        <ul>

                            <li>Disabled, denoted by red cells</li>

                            <li>Always, denoted by green cells. This means that Items checked-in to 'From' branch, which would normally be transfered to 'To' branch, stay in the checked-in branch.</li>

                            <li>Possible, denoted by blue cells. This is like always, except the librarian is prompted if he/she wants to initiate a transfer or not. Default behaviour is not to transfer.</li>

                            <li>Conditional, denoted by purple cells. This is like always, but only when the given condition matches.

                                <p class="example">

                                    itype eq BK - this will always float all Items with item type 'BK'<br/>

                                    itype eq BK or itype eq CR - this will always float all Items with item type 'BK' or 'CR'<br/>

                                    ccode eq FLOAT - this will float all Items with a collection code 'FLOAT'<br/>

                                    itype ne CR and permanent_location eq CART  - this will float all Items not of item type CR and whose permanent location (set when the Item's location is set) is 'CART'<br/>

                                    <i>These boolean statements are actually evaluable Perl boolean expressions and target the columns in the koha.items-table. See <a href="http://schema.koha-community.org/tables/items.html">here</a> for available data columns.</i>

                                </p>

                            </li>

                        </ul>

                    </div>

                    <fieldset>

                    <legend>Floating rule tester</legend>

                    <div id="floatingRuleTester">

                        <label for="testerFromBranch">Choose the origin library:</label>

                        <select id="testerFromBranch">

                        [% FOREACH branch IN branches %]

                            <option value="[% branch.branchcode %]">[% branch.branchcode %]</option>

                        [% END %]

                        </select>

                        <label for="testerToBranch">Choose the destination library:</label>

                        <select id="testerToBranch">

                        [% FOREACH branch IN branches%]

                            <option value="[% branch.branchcode %]">[% branch.branchcode %]</option>

                        [% END %]

                        </select>

                        <input id="testerBarcode" type="test" width="12"/>

                        <input id="tester" type="submit" value="Test"/>

                        <span id="testResulDisplay"/>

                        <div class="cssload-loader">

                            <div class="cssload-inner cssload-one"></div>

                            <div class="cssload-inner cssload-two"></div>

                            <div class="cssload-inner cssload-three"></div>

                        </div>

                    </div>

                    </fieldset>

                    <table id="floatingMatrix">

                        <tr id="fmHeaderRow">

                            <th>From \ To</th>

                            [% FOREACH branch IN branches %]

                                <th title="[% branch.branchname %]">[% branch.branchcode %]</th>

                            [% END %]

                        </tr>

                        [% FOREACH fromBranchCode IN branches %]

                        <tr>

                            <th title="[% fromBranchCode.branchname %]">[% fromBranchCode.branchcode %]</th>

                            [% FOREACH toBranchCode IN branches; branchRule = fm.getBranchRule(fromBranchCode.branchcode, toBranchCode.branchcode) %]

                            <td>

                                [% IF toBranchCode.branchcode == fromBranchCode.branchcode %]

                                     

                                [% ELSE %]

                                    <div class="branchRule"[% IF branchRule.getId %] id="br_[% branchRule.getId %]"[% END %]>

                                        [% INCLUDE 'admin/floating-matrix-floatingTypes.inc' %]

                                        <input name="conditionRules" type="text" value="[% branchRule.getConditionRules() %]" class="hidden"/>

                                        <div>

                                            <input name="submit" type="submit" value="%"/>

                                            <input name="cancel" type="submit" value="V"/>

                                        </div>

                                    </div>

                                [% END %]

                            </td>

                            [% END %]

                        </tr>

                        [% END %]

                    </table>

                </fieldset>

            </main>

        </div>

        <div class="col-sm-2 col-sm-pull-10">

            <aside>

                [% INCLUDE 'admin-menu.inc' %]

            </aside>

        </div>

    </div>

</div>

<!-- HTML Templates -->

<div class="branchRule TEMPLATE" id="br_TEMPLATE">

    [% INCLUDE 'admin/floating-matrix-floatingTypes.inc' %]

    <input name="conditionRules" type="text" value="" class="hidden"/>

    <div>

        <input name="submit" type="submit" value="%"/>

        <input name="cancel" type="submit" value="V"/>

    </div>

</div>

[% Asset.js("js/floating-matrix.js") | $raw %]

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