admin/classsources.pl

   1 #! /usr/bin/perl
   2 #
   3 # Copyright 2007 LibLime
   4 # Copyright 2018 Koha Development Team
   5 #
   6 # This file is part of Koha.
   7 #
   8 # Koha is free software; you can redistribute it and/or modify it
   9 # under the terms of the GNU General Public License as published by
  10 # the Free Software Foundation; either version 3 of the License, or
  11 # (at your option) any later version.
  12 #
  13 # Koha is distributed in the hope that it will be useful, but
  14 # WITHOUT ANY WARRANTY; without even the implied warranty of
  15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16 # GNU General Public License for more details.
  17 #
  18 # You should have received a copy of the GNU General Public License
  19 # along with Koha; if not, see <http://www.gnu.org/licenses>.
  20 #
  21
  22 use Modern::Perl;
  23 use CGI qw ( -utf8 );
  24 use C4::Auth qw( get_template_and_user );
  25 use C4::Context;
  26 use C4::Output qw( output_html_with_http_headers );
  27 use C4::ClassSortRoutine qw( GetSortRoutineNames );
  28 use C4::ClassSplitRoutine qw( GetSplitRoutineNames );
  29 use Koha::ClassSources;
  30 use Koha::ClassSortRules;
  31 use Koha::ClassSplitRules;
  32
  33 my $script_name = "/cgi-bin/koha/admin/classsources.pl";
  34
  35 my $input            = CGI->new;
  36 my $op               = $input->param('op') || 'list';
  37 my $cn_source        = $input->param('cn_source');
  38 my $class_sort_rule  = $input->param('class_sort_rule');
  39 my $class_split_rule = $input->param('class_split_rule');
  40 my $sort_routine     = $input->param('sort_routine');
  41 my $split_routine    = $input->param('split_routine');
  42 my @split_regex      = $input->multi_param('split_regex');
  43 my $description      = $input->param('description');
  44 my $used             = $input->param('used');
  45
  46 my ( $template, $loggedinuser, $cookie ) = get_template_and_user(
  47     {
  48         template_name   => "admin/classsources.tt",
  49         query           => $input,
  50         type            => "intranet",
  51         flagsrequired   => { parameters => 'manage_classifications' },
  52     }
  53 );
  54
  55 my @messages;
  56 $template->param( script_name => $script_name );
  57
  58 if ( $op eq "add_source" ) {
  59     my $class_source =
  60       $cn_source ? Koha::ClassSources->find($cn_source) : undef;
  61     $template->param(
  62         class_source => $class_source,
  63         sort_rules   => Koha::ClassSortRules->search,
  64         split_rules  => Koha::ClassSplitRules->search,
  65     );
  66 }
  67 elsif ( $op eq "add_source_validate" ) {
  68     my $class_source = Koha::ClassSources->find($cn_source);
  69     if ($class_source) {
  70         $class_source->set(
  71             {
  72                 description      => $description,
  73                 used             => ( $used eq 'used' ? 1 : 0 ),
  74                 class_sort_rule  => $class_sort_rule,
  75                 class_split_rule => $class_split_rule,
  76             }
  77         );
  78         eval { $class_source->store; };
  79         if ($@) {
  80             push @messages,
  81               { type => 'error', code => 'error_on_update_source' };
  82         }
  83         else {
  84             push @messages,
  85               { type => 'message', code => 'success_on_update_source' };
  86         }
  87
  88     }
  89     else {
  90         $class_source = Koha::ClassSource->new(
  91             {
  92                 cn_source        => $cn_source,
  93                 description      => $description,
  94                 used             => ( $used eq 'used' ? 1 : 0 ),
  95                 class_sort_rule  => $class_sort_rule,
  96                 class_split_rule => $class_split_rule,
  97             }
  98         );
  99         eval { $class_source->store; };
 100         if ($@) {
 101             push @messages,
 102               { type => 'error', code => 'error_on_insert_source' };
 103         }
 104         else {
 105             push @messages,
 106               { type => 'message', code => 'success_on_insert_source' };
 107         }
 108     }
 109
 110     $op = 'list';
 111 }
 112 elsif ( $op eq "delete_source_confirmed" ) {
 113     my $class_source = Koha::ClassSources->find($cn_source);
 114     my $deleted = eval { $class_source->delete };
 115     if ( $@ or not $deleted ) {
 116         push @messages, { type => 'error', code => 'error_on_delete_source' };
 117     }
 118     else {
 119         push @messages,
 120           { type => 'message', code => 'success_on_delete_source' };
 121     }
 122
 123     $op = 'list';
 124 }
 125 elsif ( $op eq "add_sort_rule" ) {
 126     my $sort_rule =
 127       $class_sort_rule ? Koha::ClassSortRules->find($class_sort_rule) : undef;
 128     $template->param(
 129         sort_rule     => $sort_rule,
 130         sort_routines => get_class_sort_routines(),
 131     );
 132 }
 133 elsif ( $op eq "add_sort_rule_validate" ) {
 134     my $sort_rule = Koha::ClassSortRules->find($class_sort_rule);
 135     if ($sort_rule) {
 136         $sort_rule->set(
 137             { description => $description, sort_routine => $sort_routine } );
 138         eval { $sort_rule->store; };
 139         if ($@) {
 140             push @messages,
 141               { type => 'error', code => 'error_on_update_sort_rule' };
 142         }
 143         else {
 144             push @messages,
 145               { type => 'message', code => 'success_on_update_sort_rule' };
 146         }
 147
 148     }
 149     else {
 150         $sort_rule = Koha::ClassSortRule->new(
 151             {
 152                 class_sort_rule => $class_sort_rule,
 153                 description     => $description,
 154                 sort_routine    => $sort_routine,
 155             }
 156         );
 157         eval { $sort_rule->store; };
 158         if ($@) {
 159             push @messages,
 160               { type => 'error', code => 'error_on_insert_sort_rule' };
 161         }
 162         else {
 163             push @messages,
 164               { type => 'message', code => 'success_on_insert_sort_rule' };
 165         }
 166     }
 167     $op = 'list';
 168 }
 169 elsif ( $op eq "delete_sort_rule" ) {
 170     my $sort_rule = Koha::ClassSortRules->find($class_sort_rule);
 171     my $deleted = eval { $sort_rule->delete };
 172     if ( $@ or not $deleted ) {
 173         push @messages,
 174           { type => 'error', code => 'error_on_delete_sort_rule' };
 175     }
 176     else {
 177         push @messages,
 178           { type => 'message', code => 'success_on_delete_sort_rule' };
 179     }
 180     $op = 'list';
 181 }
 182 elsif ( $op eq "add_split_rule" ) {
 183     my $split_rule =
 184       $class_split_rule
 185       ? Koha::ClassSplitRules->find($class_split_rule)
 186       : undef;
 187     $template->param(
 188         split_rule     => $split_rule,
 189         split_routines => get_class_split_routines(),
 190     );
 191 }
 192 elsif ( $op eq "add_split_rule_validate" ) {
 193     my $split_rule = Koha::ClassSplitRules->find($class_split_rule);
 194
 195     @split_regex =  grep {!/^$/} @split_regex; # Remove empty
 196     if ($split_rule) {
 197         $split_rule->set(
 198             {
 199                 description   => $description,
 200                 split_routine => $split_routine,
 201             }
 202         );
 203         eval {
 204             $split_rule->regexs(\@split_regex)
 205                 if $split_routine eq 'RegEx';
 206             $split_rule->store;
 207         };
 208         if ($@) {
 209             push @messages,
 210               { type => 'error', code => 'error_on_update_split_rule' };
 211         }
 212         else {
 213             push @messages,
 214               { type => 'message', code => 'success_on_update_split_rule' };
 215         }
 216
 217     }
 218     else {
 219         $split_rule = Koha::ClassSplitRule->new(
 220             {
 221                 class_split_rule => $class_split_rule,
 222                 description      => $description,
 223                 split_routine    => $split_routine,
 224                 regexs           => \@split_regex,
 225             }
 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         }
 237     }
 238     $op = 'list';
 239 }
 240 elsif ( $op eq "delete_split_rule" ) {
 241     my $split_rule = Koha::ClassSplitRules->find($class_split_rule);
 242     my $deleted = eval { $split_rule->delete };
 243     if ( $@ or not $deleted ) {
 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';
 252 }
 253
 254 if ( $op eq 'list' ) {
 255     my $class_sources = Koha::ClassSources->search;
 256     my $sort_rules    = Koha::ClassSortRules->search;
 257     my $split_rules   = Koha::ClassSplitRules->search;
 258     $template->param(
 259         class_sources => $class_sources,
 260         sort_rules    => $sort_rules,
 261         split_rules   => $split_rules,
 262     );
 263 }
 264
 265 $template->param( op => $op, messages => \@messages, );
 266 output_html_with_http_headers $input, $cookie, $template->output;
 267
 268 exit 0;
 269
 270 sub get_class_sort_routines {
 271     my @sort_routines = GetSortRoutineNames();
 272     return \@sort_routines;
 273 }
 274
 275 sub get_class_split_routines {
 276     my @split_routines = GetSplitRoutineNames();
 277     return \@split_routines;
 278 }