Attachment #82290 for bug #15836

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




#! /usr/bin/perl
#
# Copyright 2007 LibLime
# Copyright 2018 Koha Development Team
#
# This file is part of Koha.
#

use C4::Koha;
use C4::ClassSource;
use C4::ClassSortRoutine;
use Koha::ClassSources;
use Koha::ClassSortRules;
use Koha::ClassSplitRules;

my $script_name = "/cgi-bin/koha/admin/classsources.pl";

my $input            = new CGI;
my $op               = $input->param('op') || 'list';
my $cn_source        = $input->param('cn_source');
my $class_sort_rule  = $input->param('class_sort_rule');
my $class_split_rule = $input->param('class_split_rule');
my $sort_routine     = $input->param('sort_routine');
my $split_routine    = $input->param('split_routine');
my $split_regex      = $input->param('split_regex');
my $description      = $input->param('description');
my $used             = $input->param('used');

my ( $template, $loggedinuser, $cookie ) = get_template_and_user(
    {
        template_name   => "admin/classsources.tt",
        query           => $input,
        type            => "intranet",
        authnotrequired => 0,
        flagsrequired   => { parameters => 'manage_classifications' },
        debug           => 1,
    }
);
} elsif ($op eq "add_source_confirmed") {
    add_class_source($template,
                     $source_code,
                     $description,
                     $used eq "used" ? 1 : 0,
                     $rule_code);
    $display_lists = 1;
} elsif ($op eq "delete_source") {
    delete_class_source_form($template, $source_code);
} elsif ($op eq "delete_source_confirmed") {
    delete_class_source($template, $source_code);
    $display_lists = 1;
} elsif ($op eq "edit_source") {
    edit_class_source_form($template, $source_code);
} elsif ($op eq "edit_source_confirmed") {
    edit_class_source($template,
                     $source_code,
                     $description,
                     $used eq "used" ? 1 : 0,
                     $rule_code);
    $display_lists = 1;
} elsif ($op eq "add_sort_rule") {
    add_class_sort_rule_form($template);
} elsif ($op eq "add_sort_rule_confirmed") {
    add_class_sort_rule($template,
                        $rule_code,
                        $description,
                        $sort_routine);
    $display_lists = 1;
} elsif ($op eq "delete_sort_rule") {
    delete_sort_rule_form($template, $rule_code);
} elsif ($op eq "delete_sort_rule_confirmed") { 
    delete_sort_rule($template, $rule_code);
    $display_lists = 1;
} elsif ($op eq "edit_sort_rule") { 
    edit_class_sort_rule_form($template, $rule_code);
} elsif ($op eq "edit_sort_rule_confirmed") {
    edit_class_sort_rule($template,
                         $rule_code,
                         $description,
                         $sort_routine);
    $display_lists = 1;
} else {
    $display_lists = 1;
}

if ($display_lists) {
    $template->param(display_lists => 1);
    class_source_list($template);
    class_sort_rule_list($template);
}

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

my @messages;
$template->param( script_name => $script_name );

if ( $op eq "add_source" ) {
    my $class_source =
      $cn_source ? Koha::ClassSources->find($cn_source) : undef;
    $template->param(
        class_source => $class_source,
        sort_rules   => scalar Koha::ClassSortRules->search,
        split_rules  => scalar Koha::ClassSplitRules->search,
    );
    get_sort_rule_codes($template, '');
}
elsif ( $op eq "add_source_validate" ) {
    my $class_source = Koha::ClassSources->find($cn_source);
    if ($class_source) {
        $class_source->set(
            {
                description      => $description,
                used             => ( $used eq 'used' ? 1 : 0 ),
                class_sort_rule  => $class_sort_rule,
                class_split_rule => $class_split_rule,
            }
        );
        eval { $class_source->store; };
        if ($@) {
            push @messages,
              { type => 'error', code => 'error_on_update_source' };
        }
        else {
            push @messages,
              { type => 'message', code => 'success_on_update_source' };
        }

sub add_class_source {
    my ($template, $source_code, $description, $used, $sort_rule) = @_;
    my $success = AddClassSource($source_code, $description, $used, $sort_rule);
    if ($success > 0) {
        $template->param(added_source => $source_code);
    } else {
        $template->param(failed_add_source => $source_code);
    }
    else {
        $class_source = Koha::ClassSource->new(
            {
                cn_source        => $cn_source,
                description      => $description,
                used             => ( $used eq 'used' ? 1 : 0 ),
                class_sort_rule  => $class_sort_rule,
                class_split_rule => $class_split_rule,
            }
        );
        eval { $class_source->store; };
        if ($@) {
            push @messages,
              { type => 'error', code => 'error_on_insert_source' };
        }
        else {
            push @messages,
              { type => 'message', code => 'success_on_insert_source' };
        }
    }

    $op = 'list';
}
elsif ( $op eq "delete_source_confirmed" ) {
    my $class_source = Koha::ClassSources->find($cn_source);
    my $deleted = eval { $class_source->delete };
    if ( $@ or not $deleted ) {
        push @messages, { type => 'error', code => 'error_on_delete_source' };
    }
    else {
        push @messages,
          { type => 'message', code => 'success_on_delete_source' };
    }

    $op = 'list';
    my ($template, $source_code, $description, $used, $sort_rule) = @_;
    ModClassSource($source_code, $description, $used, $sort_rule);
    $template->param(edited_source => $source_code);
}
elsif ( $op eq "add_sort_rule" ) {
    my $sort_rule =
      $class_sort_rule ? Koha::ClassSortRules->find($class_sort_rule) : undef;
    my ($template, $source_code) = @_;
    $template->param(
        sort_rule     => $sort_rule,
        sort_routines => get_class_sort_routines(),
        class_source => $source_code,
    );
}
elsif ( $op eq "add_sort_rule_validate" ) {
    my $sort_rule = Koha::ClassSortRules->find($class_sort_rule);
    if ($sort_rule) {
        $sort_rule->set(
            { description => $description, sort_routine => $sort_routine } );
        eval { $sort_rule->store; };
        if ($@) {
            push @messages,
              { type => 'error', code => 'error_on_update_sort_rule' };
        }
        else {
            push @messages,
              { type => 'message', code => 'success_on_update_sort_rule' };
        }

    }
    else {
        $sort_rule = Koha::ClassSortRule->new(
            {
                class_sort_rule => $class_sort_rule,
                description     => $description,
                sort_routine    => $sort_routine,
            }
        );
        eval { $sort_rule->store; };
        if ($@) {
            push @messages,
              { type => 'error', code => 'error_on_insert_sort_rule' };
        }
        else {
            push @messages,
              { type => 'message', code => 'success_on_insert_sort_rule' };
        }
    }
    $op = 'list';
}
elsif ( $op eq "delete_sort_rule" ) {
    my $sort_rule = Koha::ClassSortRules->find($class_sort_rule);
    my $deleted = eval { $sort_rule->delete };
    if ( $@ or not $deleted ) {
        push @messages,
          { type => 'error', code => 'error_on_delete_sort_rule' };
    }
    else {
        push @messages,
          { type => 'message', code => 'success_on_delete_sort_rule' };
            rule        => $sort_rule->{'class_sort_rule'},
            description => $sort_rule->{'description'},
            selected    => $sort_rule->{'class_sort_rule'} eq $current_rule ? 1 : 0
        };
    }
    $op = 'list';
 
}
elsif ( $op eq "add_split_rule" ) {
    my $split_rule =
      $class_split_rule
      ? Koha::ClassSplitRules->find($class_split_rule)
      : undef;
    $template->param(
        split_rule     => $split_rule,
        split_routines => get_class_split_routines(),
    );
    get_class_sort_routines($template, "");
}
elsif ( $op eq "add_split_rule_validate" ) {
    my $split_rule = Koha::ClassSplitRules->find($class_split_rule);
    if ($split_rule) {
        $split_rule->set(
            {
                description   => $description,
                split_routine => $split_routine,
                split_regex =>
                  ( $split_routine eq 'RegEx' ? $split_regex : '' ),
            }
        );
        eval { $split_rule->store; };
        if ($@) {
            push @messages,
              { type => 'error', code => 'error_on_update_split_rule' };
        }
        else {
            push @messages,
              { type => 'message', code => 'success_on_update_split_rule' };
        }

sub add_class_sort_rule {
    my ($template, $rule_code, $description, $sort_routine) = @_;
    my $success = AddClassSortRule($rule_code, $description, $sort_routine);
    if ($success > 0) {
        $template->param(added_rule => $rule_code);
    } else {
        $template->param(failed_add_rule => $rule_code);
    }
    else {
        $split_rule = Koha::ClassSplitRule->new(
            {
                class_split_rule => $class_split_rule,
                description      => $description,
                split_routine    => $split_routine,
                split_regex =>
                  ( $split_routine eq 'RegEx' ? $split_regex : '' ),
            }
            confirm_op => "delete_sort_rule_confirmed",
            sort_rule  => $rule_code,
        );
    } else {
        $template->param(
            delete_sort_rule_impossible => 1,
            sort_rule => $rule_code
        );
        eval { $split_rule->store; };
        if ($@) {
            warn $@;
            push @messages,
              { type => 'error', code => 'error_on_insert_split_rule' };
        }
        else {
            push @messages,
              { type => 'message', code => 'success_on_insert_split_rule' };
        }
    }
    $op = 'list';
}
elsif ( $op eq "delete_split_rule" ) {
    my $split_rule = Koha::ClassSplitRules->find($class_split_rule);
    my $deleted = eval { $split_rule->delete };
    if ( $@ or not $deleted ) {
        push @messages,
          { type => 'error', code => 'error_on_delete_split_rule' };
    }
    else {
        push @messages,
          { type => 'message', code => 'success_on_delete_split_rule' };
    }
    $op = 'list';
}

if ( $op eq 'list' ) {
    my $class_sources = Koha::ClassSources->search;
    my $sort_rules    = Koha::ClassSortRules->search;
    my $split_rules   = Koha::ClassSplitRules->search;
    $template->param(
        class_sources => $class_sources,
        sort_rules    => $sort_rules,
        split_rules   => $split_rules,
        sort_rule    => $rule_code,
        description  => $rule->{'description'},
        sort_routine => $rule->{'sort_routine'}
    );
}

$template->param( op => $op, messages => \@messages, );
output_html_with_http_headers $input, $cookie, $template->output;

exit 0;

sub get_class_sort_routines {
    my ($template, $current_routine) = @_;

    my @sort_routines = GetSortRoutineNames();
    return \@sort_routines;

    foreach my $sort_routine (sort @sort_routines) {    
        push @sort_form, {
            routine  => $sort_routine,
            selected => $sort_routine eq $current_routine ? 1 : 0
        };
    }
    $template->param(routines_dropdown => \@sort_form);

}

sub get_class_split_routines {
    my @split_routines = qw(
      Dewey
      Generic
      LCC
      RegEx
    );
    return \@split_routines;
    my $sources = GetClassSources();

    my @sources = ();
    foreach my $cn_source (sort keys %$sources) {
        my $source = $sources->{$cn_source};
        push @sources, {
            code        => $source->{'cn_source'},
            description => $source->{'description'},
            used        => $source->{'used'},
            sortrule    => $source->{'class_sort_rule'}
        };
    }
    $template->param(class_sources => \@sources);
}

sub class_sort_rule_list {

    my ($template) = @_;
    my $sort_rules = GetClassSortRules();

    my @sort_rules = ();
    foreach my $sort_rule (sort keys %$sort_rules) {
        my $sort_rule = $sort_rules->{$sort_rule};
        push @sort_rules, {
            rule        => $sort_rule->{'class_sort_rule'},
            description => $sort_rule->{'description'},
            sort_routine    => $sort_rule->{'sort_routine'}
        }; 
    }
    $template->param(class_sort_rules => \@sort_rules);
}

Lines 25-31 if( CheckVersion( $DBversion ) ) { Link Here

(-)a/installer/data/mysql/atomicupdate/bug_15836.perl (-1 / +1 lines)
25	$dbh->do(q\|	25	$dbh->do(q\|
26	INSERT INTO class_split_rules(class_split_rule, description, split_routine)	26	INSERT INTO class_split_rules(class_split_rule, description, split_routine)
27	VALUES	27	VALUES
28	('dewey', 'Default sorting rules for DDC', 'dewey'),	28	('dewey', 'Default sorting rules for DDC', 'Dewey'),
29	('lcc', 'Default sorting rules for LCC', 'LCC'),	29	('lcc', 'Default sorting rules for LCC', 'LCC'),
30	('generic', 'Generic call number sorting rules', 'Generic')	30	('generic', 'Generic call number sorting rules', 'Generic')
31	\|);	31	\|);




[% SET footerjs = 1 %]
[% INCLUDE 'doc-head-open.inc' %]
<title>Koha &rsaquo; Administration &rsaquo; Classification sources
[% IF op == 'add_source' %]
&rsaquo; 
    [% IF ( edit_class_source ) %]Modify classification source[% ELSE %]Add classification source[% END %]
[% END %]
[% IF ( sort_rule_form ) %]
&rsaquo;
    [% IF class_source %]Modify classification source[% ELSE %]Add classification source[% END %]
[% ELSIF op == 'add_sort_rule' %]
&rsaquo;
    [% IF sort_rule %]Modify filing rule[% ELSE %]Add filing rule[% END %]
[% ELSIF op == 'add_split_rule' %]
&rsaquo;
    [% IF split_rule %]Modify splitting rule[% ELSE %]Add splitting rule[% END %]
  &rsaquo; Cannot delete filing rule [% sort_rule | html %]
[% END %]

</title>
[% INCLUDE 'doc-head-close.inc' %]
</head>

         <a href="/cgi-bin/koha/mainpage.pl">Home</a>
&rsaquo; <a href="/cgi-bin/koha/admin/admin-home.pl">Administration</a>
&rsaquo; <a href="/cgi-bin/koha/admin/classsources.pl">Classification sources</a>
[% IF op == 'add_source' %]
&rsaquo; [% IF class_source %]Modify classification source[% ELSE %]Add classification source[% END %]
[% ELSIF op == 'add_sort_rule' %]
&rsaquo; [% IF sort_rule %]Modify filing rule[% ELSE %]Add filing rule[% END %]
[% ELSIF op == 'add_split_rule' %]
&rsaquo; [% IF split_rule %]Modify splitting rule[% ELSE %]Add splitting rule[% END %]
[% IF ( delete_class_source_form ) %]
&rsaquo; Confirm deletion of classification source <span class="ex">'[% class_source | html %]'</span>
[% ELSIF ( delete_sort_rule_form ) %]
&rsaquo; Confirm deletion of filing rule <span class="ex">'[% sort_rule | html %]'</span>
[% ELSIF ( delete_sort_rule_impossible ) %]
&rsaquo; Cannot delete filing rule <span class="ex">'[% sort_rule | html %]'</span>
[% END %]
</div>


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

[% FOR m IN messages %]
    <div class="dialog [% m.type %]">
        [% SWITCH m.code %]
        [% CASE 'error_on_update_source' %]
            An error occurred when updating this classification source.
        [% CASE 'success_on_update_source' %]
            Classification source updated successfully.
        [% CASE 'error_on_insert_source' %]
            An error occurred when adding this classification source. Perhaps the code already exists?
        [% CASE 'success_on_insert_source' %]
            Classification source added successfully.
        [% CASE 'error_on_delete_source' %]
            An error occurred when deleting this classification source.
        [% CASE 'success_on_delete_source' %]
            Classification source deleted successfully.
        [% CASE 'error_on_update_sort_rule' %]
            An error occurred when adding this filing rule. Perhaps the code already exists?
        [% CASE 'success_on_update_sort_rule' %]
            Filing rule updated successfully.
        [% CASE 'error_on_insert_sort_rule' %]
            An error occurred when adding this filing rule. Perhaps the code already exists?
        [% CASE 'success_on_insert_sort_rule' %]
            Filing rule added successfully.
        [% CASE 'error_on_delete_sort_rule' %]
            An error occurred when deleting this filing rule. Perhaps it is used by at least one classification source?
        [% CASE 'success_on_delete_sort_rule' %]
            Filing rule deleted successfully.
        [% CASE 'error_on_update_split_rule' %]
            An error occurred when adding this splitting rule. Perhaps the code already exists?
        [% CASE 'success_on_update_split_rule' %]
            Splitting rule updated successfully.
        [% CASE 'error_on_insert_split_rule' %]
            An error occurred when adding this splitting rule. Perhaps the code already exists?
        [% CASE 'success_on_insert_split_rule' %]
            Splitting rule added successfully.
        [% CASE 'error_on_delete_split_rule' %]
            An error occurred when deleting this splitting rule. Perhaps it is used by at least one classification source?
        [% CASE 'success_on_delete_split_rule' %]
            Splitting rule deleted successfully.
        [% CASE %]
            [% m.code %]
        [% END %]
    </div>
[% END %]


[% IF op == 'add_source' %]
  [% IF class_source %]
<h2>Modify classification source</h2>
  [% ELSE %]
<h2>Add classification source</h2>
  [% END %]
<form action="[% script_name | html %]" name="Aform" class="validated" method="post">
  <input type="hidden" name="op" value="add_source_validate" />
  <fieldset class="rows">
    <ol>
      <li>
          [% IF class_source %]
		  <span class="label">Classification source code: </span>
            <input type="hidden" name="cn_source" value="[% class_source.cn_source | html %]" />
            [% class_source.cn_source | html %]
          [% ELSE %]
              <label class="required" for="class_source">Classification source code: </label>
              <input class="required" required="required" type="text" id="class_source" name="cn_source"  size="10" maxlength="10" />
              <span class="required">Required</span>
          [% END %]
       </li>
       <li><label class="required" for="description">Description: </label>
           <input class="required" required="required" type="text" id="description" name="description" size="50" maxlength="250" value="[% class_source.description | html %]" />
           <span class="required">Required</span>
       </li>
       <li><label for="used">Source in use?</label>
           [% IF ( class_source.used ) %]<input type="checkbox" id="used" name="used" value="used" checked="checked" />[% ELSE %]
		  <input type="checkbox" id="used" name="used" value="used" />[% END %]
       </li>
        <li>
            <label class="required" for="class_sort_rule">Filing rule: </label>
            <select class="required" required="required" id="class_sort_rule" name="class_sort_rule">
                [% FOREACH r IN sort_rules %]
                    [% IF class_source.class_sort_rule == r.class_sort_rule %]
                        <option value="[% r.class_sort_rule | html %]" selected="selected">[% r.description | html %] ([% r.class_sort_rule | html %])</option>
                    [% ELSE %]
                        <option value="[% r.class_sort_rule | html %]">[% r.description | html %] ([% r.class_sort_rule | html %])</option>
                    [% END %]
                [% END %]
            </select>
            <span class="required">Required</span>
        </li>
        <li>
            <label class="required" for="class_split_rule">Splitting rule: </label>
            <select class="required" required="required" id="split_rule" name="class_split_rule">
                [% FOREACH r IN split_rules %]
                    [% IF class_source.class_split_rule == r.class_split_rule %]
                        <option value="[% r.class_split_rule | html %]" selected="selected">[% r.description | html %] ([% r.class_split_rule | html %])</option>
                    [% ELSE %]
                        <option value="[% r.class_split_rule | html %]">[% r.description | html %] ([% r.class_split_rule | html %])</option>
                    [% END %]
                [% END %]
            </select>
            <span class="required">Required</span>
        </li>
    </ol>
  </fieldset>
  <fieldset class="action">

</form>
[% END %]

[% IF op == 'add_sort_rule' %]
  [% IF sort_rule %]
<h2>Modify filing rule</h2>
  [% ELSE %]
<h2>Add filing rule</h2>
  [% END %]
<form action="[% script_name | html %]" name="Aform" class="validated" method="post">
  <input type="hidden" name="op" value="add_sort_rule_validate" />
  <fieldset class="rows">
    <ol>
      <li>
          [% IF sort_rule %]
		  <span class="label">Filing rule code: </span>
            <input type="hidden" name="class_sort_rule" value="[% sort_rule.class_sort_rule | html %]" />
            [% sort_rule.class_sort_rule | html %]
          [% ELSE %]
              <label for="class_sort_rule" class="required">Filing rule code: </label>
              <input class="required" required="required" type="text" id="class_sort_rule" name="class_sort_rule"  size="10" maxlength="10" />
              <span class="required">Required</span>
          [% END %]
       </li>
       <li><label for="description" class="required">Description: </label>
           <input class="required" required="required" type="text" id="description" name="description" size="50" maxlength="250" value="[% sort_rule.description | html %]" />
           <span class="required">Required</span>
       </li>
       <li><label for="sort_routine" class="required">Filing routine: </label>
           <select class="required" required="required" id="sort_routine" name="sort_routine">
           [% FOREACH routine_name IN sort_routines %]
             [% IF routine_name == sort_rule.sort_routine %]
                 <option value="[% routine_name | html %]" selected="selected">[% routine_name | html %]</option>
             [% ELSE %]
                 <option value="[% routine_name | html %]">[% routine_name %]</option>
             [% END %]
           [% END %]
           </select>

</form>
[% END %]

[% IF op == 'add_split_rule' %]
  [% IF split_rule %]
<h2>Modify splitting rule</h2>
  [% ELSE %]
<h2>Add splitting rule</h2>
  [% END %]
<form action="[% script_name | html %]" name="Aform" class="validated" method="post">
  <input type="hidden" name="op" value="add_split_rule_validate" />
  <fieldset class="rows">
    <ol>
      <li>
          [% IF split_rule %]
            <span class="label">Splitting rule code: </span>
            <input type="hidden" name="class_split_rule" value="[% split_rule.class_split_rule | html %]" />
            [% split_rule.class_split_rule | html %]
          [% ELSE %]
              <label for="class_split_rule" class="required">Splitting rule code: </label>
              <input class="required" required="required" type="text" id="class_split_rule" name="class_split_rule"  size="10" maxlength="10" />
              <span class="required">Required</span>
          [% END %]
       </li>
       <li><label for="description" class="required">Description: </label>
           <input class="required" required="required" type="text" id="description" name="description" size="50" maxlength="250" value="[% split_rule.description | html %]" />
           <span class="required">Required</span>
       </li>
       <li><label for="split_routine" class="required">Splitting routine: </label>
           <select class="required" required="required" id="split_routine" name="split_routine">
            [% FOREACH routine_name IN split_routines %]
                [% IF routine_name == split_rule.split_routine %]
                    <option value="[% routine_name | html %]" selected="selected">[% routine_name | html %]</option>
                [% ELSE %]
                    <option value="[% routine_name | html %]">[% routine_name | html %]</option>
                [% END %]
            [% END %]
           </select>
           <span class="required">Required</span>
       </li>
       <li id="regex_block">
           <label for="split_regex" class="required">Regular expression: </label>
           <input type="text" name="split_regex" id="split_regex" value="[% split_rule.split_regex | html %]" />
           <span class="required">Required</span>
       </li>

    </ol>
  </fieldset>
    <fieldset class="action">
        <input type="submit" value="Save" />
        <a class="cancel" href="/cgi-bin/koha/admin/classsources.pl">Cancel</a>
    </fieldset>
</form>
    </form>
</div>
[% END %]

[% IF op == 'list' %]

<div id="toolbar" class="btn-toolbar">
    <a class="btn btn-default btn-sm" id="newsource" href="[% script_name | url %]?op=add_source"><i class="fa fa-plus"></i> New classification source</a>
    <a class="btn btn-default btn-sm" id="newrule" href="[% script_name | url %]?op=add_sort_rule"><i class="fa fa-plus"></i> New filing rule</a>
    <a class="btn btn-default btn-sm" id="newrule" href="[% script_name | url %]?op=add_split_rule"><i class="fa fa-plus"></i> New splitting rule</a>
</div>

<h2>Classification sources</h2>
[% IF ( added_source ) %]
<div class="dialog message">Added classification source [% added_source | html %]</div>
[% END %]
[% IF ( edited_source ) %]
<div class="dialog message">Modified classification source [% edited_source | html %]</div>
[% END %]
[% IF ( deleted_source ) %]
<div class="dialog message">Deleted classification source [% deleted_source | html %]</div>
[% END %]
[% IF ( failed_add_source ) %]
<div class="dialog message">Failed to add classification source [% failed_add_source | html %]. Perhaps the code already exists?</div>
[% END %]
<table>
  <tr>
    <th>Code</th>
    <th>Description</th>
    <th>In use</th>
    <th>Filing rule</th>
    <th>Splitting rule</th>
    <th>Actions</th>
  </tr>
  [% FOREACH class_source IN class_sources %]
  <tr>
    <td>[% class_source.cn_source | html %]</td>
    <td>[% class_source.description |html | html %]</td>
    <td>[% IF ( class_source.used ) %]Yes[% ELSE %]No[% END %]</td>
    <td>[% class_source.class_sort_rule | html %]</td>
    <td>[% class_source.class_split_rule | html %]</td>
    <td class="actions">
      <a class="btn btn-default btn-xs" href="[% script_name | url %]?op=add_source&amp;cn_source=[% class_source.cn_source | uri %]"><i class="fa fa-pencil"></i> Edit</a>
      <a class="btn btn-default btn-xs delete_class_source" href="[% script_name | url %]?op=delete_source&amp;cn_source=[% class_source.cn_source | uri%]"><i class="fa fa-trash"></i> Delete</a>
    </td>
  </tr>
  [% END %]
</table>

<h2>Classification filing rules</h2>
[% IF ( added_rule ) %]
<div class="dialog message">Added filing rule [% added_rule | html %]</div>
[% END %]
[% IF ( edited_rule ) %]
<div class="dialog message">Modified filing rule [% edited_rule | html %]</div>
[% END %]
[% IF ( deleted_rule ) %]
<div class="dialog message">Deleted filing rule [% deleted_rule | html %]</div>
[% END %]
[% IF ( failed_add_rule ) %]
<div class="dialog message">Failed to add filing rule [% failed_add_rule | html %]. Perhaps the code already exists?</div>
[% END %]
<table>
  <tr>
    <th>Code</th>

    <th>Sorting routine</th>
    <th>Actions</th>
  </tr>
  [% FOREACH rule IN sort_rules %]
  <tr>
    <td>[% rule.class_sort_rule | html %]</td>
    <td>[% rule.description |html | html %]</td>
    <td>[% rule.sort_routine | html %]</td>
    <td class="actions">
      <a class="btn btn-default btn-xs" href="[% script_name | html %]?op=add_sort_rule&amp;class_sort_rule=[% rule.class_sort_rule |url %]"><i class="fa fa-pencil"></i> Edit</a>
      <a class="btn btn-default btn-xs delete_sort_rule" href="[% script_name | html %]?op=delete_sort_rule&amp;class_sort_rule=[% rule.class_sort_rule |url %]"><i class="fa fa-trash"></i> Delete</a>
    </td>
  </tr>
  [% END %]
</table>

<h2>Classification splitting rules</h2>
<table>
  <tr>
    <th>Code</th>
    <th>Description</th>
    <th>Splitting routine</th>
    <th>Actions</th>
  </tr>
  [% FOREACH rule IN split_rules %]
  <tr>
    <td>[% rule.class_split_rule | html %]</td>
    <td>[% rule.description | html %]</td>
    <td>[% rule.split_routine | html %]</td>
    <td class="actions">
      <a class="btn btn-default btn-xs" href="[% script_name | url %]?op=add_split_rule&amp;class_split_rule=[% rule.class_split_rule | uri %]"><i class="fa fa-pencil"></i> Edit</a>
      <a class="btn btn-default btn-xs delete_split_rule" href="[% script_name | url %]?op=delete_split_rule&amp;class_split_rule=[% rule.class_split_rule | uri %]"><i class="fa fa-trash"></i> Delete</a>
    </td>
  </tr>
  [% END %]
</table>


[% END %]

            </main>


[% MACRO jsinclude BLOCK %]
    [% Asset.js("js/admin-menu.js") | $raw %]

    <script>
        function update_regex_block(){
            if ( $("#split_routine option:selected").val() == 'RegEx' ) {
                $("#regex_block").show();
                $("#split_regex").attr('required', 'required');
            } else {
                $("#regex_block").hide();
                $("#split_regex").removeAttr('required');
            }
        };
        $(document).ready(function(){
            update_regex_block();
            $("#split_routine").on("change", function(){
                update_regex_block();
            });

            $(".delete_class_source").on("click", function(e){
                return confirm(_("Are you sure you want to delete this class source?"));
            });
            $(".delete_sort_rule").on("click", function(e){
                return confirm(_("Are you sure you want to delete this filing rule?"));
            });
            $(".delete_split_rule").on("click", function(e){
                return confirm(_("Are you sure you want to delete this splitting rule?"));
            });
        });

    </script>
[% END %]
[% INCLUDE 'intranet-bottom.inc' %]
- 

Return to bug 15836

Lines 1-6 Link Here

(-)a/admin/classsources.pl (-230 / +214 lines)
1	#! /usr/bin/perl	1	#! /usr/bin/perl
2	#	2	#
3	# Copyright 2007 LibLime	3	# Copyright 2007 LibLime
		4	# Copyright 2018 Koha Development Team
4	#	5	#
5	# This file is part of Koha.	6	# This file is part of Koha.
6	#	7	#
Lines 26-299 use C4::Output; Link Here
26	use C4::Koha;	27	use C4::Koha;
27	use C4::ClassSource;	28	use C4::ClassSource;
28	use C4::ClassSortRoutine;	29	use C4::ClassSortRoutine;
		30	use Koha::ClassSources;
		31	use Koha::ClassSortRules;
		32	use Koha::ClassSplitRules;
29		33
30	my $script_name = "/cgi-bin/koha/admin/classsources.pl";	34	my $script_name = "/cgi-bin/koha/admin/classsources.pl";
31		35
32	my $input = new CGI;	36	my $input = new CGI;
33	my $op = $input->param('op') \|\| '';	37	my $op = $input->param('op') \|\| 'list';
34	my $source_code = $input->param('class_source');	38	my $cn_source = $input->param('cn_source');
35	my $rule_code = $input->param('sort_rule');	39	my $class_sort_rule = $input->param('class_sort_rule');
36	my $sort_routine = $input->param('sort_routine');	40	my $class_split_rule = $input->param('class_split_rule');
37	my ($template, $loggedinuser, $cookie)	41	my $sort_routine = $input->param('sort_routine');
38	= get_template_and_user({template_name => "admin/classsources.tt",	42	my $split_routine = $input->param('split_routine');
39	query => $input,	43	my $split_regex = $input->param('split_regex');
40	type => "intranet",	44	my $description = $input->param('description');
41	authnotrequired => 0,	45	my $used = $input->param('used');
42	flagsrequired => {parameters => 'manage_classifications'},	46
43	debug => 1,	47	my ( $template, $loggedinuser, $cookie ) = get_template_and_user(
44	});	48	{
45		49	template_name => "admin/classsources.tt",
46	$template->param(script_name => $script_name);	50	query => $input,
47	$template->param($op => 1) if $op;	51	type => "intranet",
48	my $description = $input->param('description');	52	authnotrequired => 0,
49	my $used = $input->param('used');	53	flagsrequired => { parameters => 'manage_classifications' },
50	my $display_lists = 0;	54	debug => 1,
51	if ($op eq "add_source") {	55	}
52	add_class_source_form($template);	56	);
53	} elsif ($op eq "add_source_confirmed") {
54	add_class_source($template,
55	$source_code,
56	$description,
57	$used eq "used" ? 1 : 0,
58	$rule_code);
59	$display_lists = 1;
60	} elsif ($op eq "delete_source") {
61	delete_class_source_form($template, $source_code);
62	} elsif ($op eq "delete_source_confirmed") {
63	delete_class_source($template, $source_code);
64	$display_lists = 1;
65	} elsif ($op eq "edit_source") {
66	edit_class_source_form($template, $source_code);
67	} elsif ($op eq "edit_source_confirmed") {
68	edit_class_source($template,
69	$source_code,
70	$description,
71	$used eq "used" ? 1 : 0,
72	$rule_code);
73	$display_lists = 1;
74	} elsif ($op eq "add_sort_rule") {
75	add_class_sort_rule_form($template);
76	} elsif ($op eq "add_sort_rule_confirmed") {
77	add_class_sort_rule($template,
78	$rule_code,
79	$description,
80	$sort_routine);
81	$display_lists = 1;
82	} elsif ($op eq "delete_sort_rule") {
83	delete_sort_rule_form($template, $rule_code);
84	} elsif ($op eq "delete_sort_rule_confirmed") {
85	delete_sort_rule($template, $rule_code);
86	$display_lists = 1;
87	} elsif ($op eq "edit_sort_rule") {
88	edit_class_sort_rule_form($template, $rule_code);
89	} elsif ($op eq "edit_sort_rule_confirmed") {
90	edit_class_sort_rule($template,
91	$rule_code,
92	$description,
93	$sort_routine);
94	$display_lists = 1;
95	} else {
96	$display_lists = 1;
97	}
98
99	if ($display_lists) {
100	$template->param(display_lists => 1);
101	class_source_list($template);
102	class_sort_rule_list($template);
103	}
104
105	output_html_with_http_headers $input, $cookie, $template->output;
106		57
107	exit 0;	58	my @messages;
		59	$template->param( script_name => $script_name );
108		60
109	sub add_class_source_form {	61	if ( $op eq "add_source" ) {
110	my ($template) = @_;	62	my $class_source =
		63	$cn_source ? Koha::ClassSources->find($cn_source) : undef;
111	$template->param(	64	$template->param(
112	class_source_form => 1,	65	class_source => $class_source,
113	confirm_op => "add_source_confirmed",	66	sort_rules => scalar Koha::ClassSortRules->search,
114	used => 0	67	split_rules => scalar Koha::ClassSplitRules->search,
115	);	68	);
116	get_sort_rule_codes($template, '');
117	}	69	}
		70	elsif ( $op eq "add_source_validate" ) {
		71	my $class_source = Koha::ClassSources->find($cn_source);
		72	if ($class_source) {
		73	$class_source->set(
		74	{
		75	description => $description,
		76	used => ( $used eq 'used' ? 1 : 0 ),
		77	class_sort_rule => $class_sort_rule,
		78	class_split_rule => $class_split_rule,
		79	}
		80	);
		81	eval { $class_source->store; };
		82	if ($@) {
		83	push @messages,
		84	{ type => 'error', code => 'error_on_update_source' };
		85	}
		86	else {
		87	push @messages,
		88	{ type => 'message', code => 'success_on_update_source' };
		89	}
118		90
119	sub add_class_source {
120	my ($template, $source_code, $description, $used, $sort_rule) = @_;
121	my $success = AddClassSource($source_code, $description, $used, $sort_rule);
122	if ($success > 0) {
123	$template->param(added_source => $source_code);
124	} else {
125	$template->param(failed_add_source => $source_code);
126	}	91	}
127	}	92	else {
128		93	$class_source = Koha::ClassSource->new(
129	sub edit_class_source_form {	94	{
130	my ($template, $source_code) = @_;	95	cn_source => $cn_source,
131		96	description => $description,
132	my $source = GetClassSource($source_code);	97	used => ( $used eq 'used' ? 1 : 0 ),
133	$template->param(	98	class_sort_rule => $class_sort_rule,
134	class_source_form => 1,	99	class_split_rule => $class_split_rule,
135	edit_class_source => 1,	100	}
136	class_source => $source_code,	101	);
137	confirm_op => "edit_source_confirmed",	102	eval { $class_source->store; };
138	description => $source->{'description'},	103	if ($@) {
139	used => $source->{'used'},	104	push @messages,
140	);	105	{ type => 'error', code => 'error_on_insert_source' };
		106	}
		107	else {
		108	push @messages,
		109	{ type => 'message', code => 'success_on_insert_source' };
		110	}
		111	}
141		112
142	get_sort_rule_codes($template, $source->{'class_sort_rule'});	113	$op = 'list';
143	}	114	}
		115	elsif ( $op eq "delete_source_confirmed" ) {
		116	my $class_source = Koha::ClassSources->find($cn_source);
		117	my $deleted = eval { $class_source->delete };
		118	if ( $@ or not $deleted ) {
		119	push @messages, { type => 'error', code => 'error_on_delete_source' };
		120	}
		121	else {
		122	push @messages,
		123	{ type => 'message', code => 'success_on_delete_source' };
		124	}
144		125
145	sub edit_class_source {	126	$op = 'list';
146	my ($template, $source_code, $description, $used, $sort_rule) = @_;
147	ModClassSource($source_code, $description, $used, $sort_rule);
148	$template->param(edited_source => $source_code);
149	}	127	}
150		128	elsif ( $op eq "add_sort_rule" ) {
151		129	my $sort_rule =
152	sub delete_class_source_form {	130	$class_sort_rule ? Koha::ClassSortRules->find($class_sort_rule) : undef;
153	my ($template, $source_code) = @_;
154	$template->param(	131	$template->param(
155	delete_class_source_form => 1,	132	sort_rule => $sort_rule,
156	confirm_op => "delete_source_confirmed",	133	sort_routines => get_class_sort_routines(),
157	class_source => $source_code,
158	);	134	);
159	}	135	}
		136	elsif ( $op eq "add_sort_rule_validate" ) {
		137	my $sort_rule = Koha::ClassSortRules->find($class_sort_rule);
		138	if ($sort_rule) {
		139	$sort_rule->set(
		140	{ description => $description, sort_routine => $sort_routine } );
		141	eval { $sort_rule->store; };
		142	if ($@) {
		143	push @messages,
		144	{ type => 'error', code => 'error_on_update_sort_rule' };
		145	}
		146	else {
		147	push @messages,
		148	{ type => 'message', code => 'success_on_update_sort_rule' };
		149	}
160		150
161	sub delete_class_source {	151	}
162	my ($template, $source_code) = @_;	152	else {
163	DelClassSource($source_code);	153	$sort_rule = Koha::ClassSortRule->new(
164	$template->param(deleted_source => $source_code);	154	{
		155	class_sort_rule => $class_sort_rule,
		156	description => $description,
		157	sort_routine => $sort_routine,
		158	}
		159	);
		160	eval { $sort_rule->store; };
		161	if ($@) {
		162	push @messages,
		163	{ type => 'error', code => 'error_on_insert_sort_rule' };
		164	}
		165	else {
		166	push @messages,
		167	{ type => 'message', code => 'success_on_insert_sort_rule' };
		168	}
		169	}
		170	$op = 'list';
165	}	171	}
166		172	elsif ( $op eq "delete_sort_rule" ) {
167	sub get_sort_rule_codes {	173	my $sort_rule = Koha::ClassSortRules->find($class_sort_rule);
168	my ($template, $current_rule) = @_;	174	my $deleted = eval { $sort_rule->delete };
169		175	if ( $@ or not $deleted ) {
170	my $sort_rules = GetClassSortRules();	176	push @messages,
171		177	{ type => 'error', code => 'error_on_delete_sort_rule' };
172	my @sort_rules = ();	178	}
173	foreach my $sort_rule (sort keys %$sort_rules) {	179	else {
174	my $sort_rule = $sort_rules->{$sort_rule};	180	push @messages,
175	push @sort_rules, {	181	{ type => 'message', code => 'success_on_delete_sort_rule' };
176	rule => $sort_rule->{'class_sort_rule'},
177	description => $sort_rule->{'description'},
178	selected => $sort_rule->{'class_sort_rule'} eq $current_rule ? 1 : 0
179	};
180	}	182	}
181	$template->param(rules_dropdown => \@sort_rules);	183	$op = 'list';
182
183	}	184	}
184		185	elsif ( $op eq "add_split_rule" ) {
185	sub add_class_sort_rule_form {	186	my $split_rule =
186	my ($template) = @_;	187	$class_split_rule
		188	? Koha::ClassSplitRules->find($class_split_rule)
		189	: undef;
187	$template->param(	190	$template->param(
188	sort_rule_form => 1,	191	split_rule => $split_rule,
189	confirm_op => "add_sort_rule_confirmed"	192	split_routines => get_class_split_routines(),
190	);	193	);
191	get_class_sort_routines($template, "");
192	}	194	}
		195	elsif ( $op eq "add_split_rule_validate" ) {
		196	my $split_rule = Koha::ClassSplitRules->find($class_split_rule);
		197	if ($split_rule) {
		198	$split_rule->set(
		199	{
		200	description => $description,
		201	split_routine => $split_routine,
		202	split_regex =>
		203	( $split_routine eq 'RegEx' ? $split_regex : '' ),
		204	}
		205	);
		206	eval { $split_rule->store; };
		207	if ($@) {
		208	push @messages,
		209	{ type => 'error', code => 'error_on_update_split_rule' };
		210	}
		211	else {
		212	push @messages,
		213	{ type => 'message', code => 'success_on_update_split_rule' };
		214	}
193		215
194	sub add_class_sort_rule {
195	my ($template, $rule_code, $description, $sort_routine) = @_;
196	my $success = AddClassSortRule($rule_code, $description, $sort_routine);
197	if ($success > 0) {
198	$template->param(added_rule => $rule_code);
199	} else {
200	$template->param(failed_add_rule => $rule_code);
201	}	216	}
202	}	217	else {
203		218	$split_rule = Koha::ClassSplitRule->new(
204	sub delete_sort_rule_form {	219	{
205	my ($template, $rule_code) = @_;	220	class_split_rule => $class_split_rule,
206		221	description => $description,
207	my @sources = GetSourcesForSortRule($rule_code);	222	split_routine => $split_routine,
208	if ($#sources == -1) {	223	split_regex =>
209	$template->param(	224	( $split_routine eq 'RegEx' ? $split_regex : '' ),
210	delete_sort_rule_form => 1,	225	}
211	confirm_op => "delete_sort_rule_confirmed",
212	sort_rule => $rule_code,
213	);
214	} else {
215	$template->param(
216	delete_sort_rule_impossible => 1,
217	sort_rule => $rule_code
218	);	226	);
		227	eval { $split_rule->store; };
		228	if ($@) {
		229	warn $@;
		230	push @messages,
		231	{ type => 'error', code => 'error_on_insert_split_rule' };
		232	}
		233	else {
		234	push @messages,
		235	{ type => 'message', code => 'success_on_insert_split_rule' };
		236	}
219	}	237	}
		238	$op = 'list';
220	}	239	}
221		240	elsif ( $op eq "delete_split_rule" ) {
222	sub delete_sort_rule {	241	my $split_rule = Koha::ClassSplitRules->find($class_split_rule);
223	my ($template, $rule_code) = @_;	242	my $deleted = eval { $split_rule->delete };
224	DelClassSortRule($rule_code);	243	if ( $@ or not $deleted ) {
225	$template->param(deleted_rule => $rule_code);	244	push @messages,
		245	{ type => 'error', code => 'error_on_delete_split_rule' };
		246	}
		247	else {
		248	push @messages,
		249	{ type => 'message', code => 'success_on_delete_split_rule' };
		250	}
		251	$op = 'list';
226	}	252	}
227		253
228	sub edit_class_sort_rule_form {	254	if ( $op eq 'list' ) {
229	my ($template, $rule_code) = @_;	255	my $class_sources = Koha::ClassSources->search;
230		256	my $sort_rules = Koha::ClassSortRules->search;
231	my $rule = GetClassSortRule($rule_code);	257	my $split_rules = Koha::ClassSplitRules->search;
232	$template->param(	258	$template->param(
233	sort_rule_form => 1,	259	class_sources => $class_sources,
234	edit_sort_rule => 1,	260	sort_rules => $sort_rules,
235	confirm_op => "edit_sort_rule_confirmed",	261	split_rules => $split_rules,
236	sort_rule => $rule_code,
237	description => $rule->{'description'},
238	sort_routine => $rule->{'sort_routine'}
239	);	262	);
		263	}
240		264
241	get_class_sort_routines($template, $rule->{'sort_routine'});	265	$template->param( op => $op, messages => \@messages, );
		266	output_html_with_http_headers $input, $cookie, $template->output;
242		267
243	}	268	exit 0;
244		269
245	sub get_class_sort_routines {	270	sub get_class_sort_routines {
246	my ($template, $current_routine) = @_;
247
248	my @sort_routines = GetSortRoutineNames();	271	my @sort_routines = GetSortRoutineNames();
249	my @sort_form = ();	272	return \@sort_routines;
250
251	foreach my $sort_routine (sort @sort_routines) {
252	push @sort_form, {
253	routine => $sort_routine,
254	selected => $sort_routine eq $current_routine ? 1 : 0
255	};
256	}
257	$template->param(routines_dropdown => \@sort_form);
258
259	}	273	}
260		274
261	sub edit_class_sort_rule {	275	sub get_class_split_routines {
262	my ($template, $rule_code, $description, $sort_routine) = @_;	276	my @split_routines = qw(
263	ModClassSortRule($rule_code, $description, $sort_routine);	277	Dewey
264	$template->param(edited_rule => $rule_code);	278	Generic
265	}	279	LCC
266		280	RegEx
267	sub class_source_list {	281	);
268	my ($template) = @_;	282	return \@split_routines;
269	my $sources = GetClassSources();
270
271	my @sources = ();
272	foreach my $cn_source (sort keys %$sources) {
273	my $source = $sources->{$cn_source};
274	push @sources, {
275	code => $source->{'cn_source'},
276	description => $source->{'description'},
277	used => $source->{'used'},
278	sortrule => $source->{'class_sort_rule'}
279	};
280	}
281	$template->param(class_sources => \@sources);
282	}
283
284	sub class_sort_rule_list {
285
286	my ($template) = @_;
287	my $sort_rules = GetClassSortRules();
288
289	my @sort_rules = ();
290	foreach my $sort_rule (sort keys %$sort_rules) {
291	my $sort_rule = $sort_rules->{$sort_rule};
292	push @sort_rules, {
293	rule => $sort_rule->{'class_sort_rule'},
294	description => $sort_rule->{'description'},
295	sort_routine => $sort_rule->{'sort_routine'}
296	};
297	}
298	$template->param(class_sort_rules => \@sort_rules);
299	}	283	}