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;
  25 use C4::Context;
  26 use C4::Output;
  27 use C4::Koha;
  28 use C4::ClassSource;
  29 use C4::ClassSortRoutine;
  30 use C4::ClassSplitRoutine;
  31 use Koha::ClassSources;
  32 use Koha::ClassSortRules;
  33 use Koha::ClassSplitRules;
  34
  35 my $script_name = "/cgi-bin/koha/admin/classsources.pl";
  36
  37 my $input            = new CGI;
  38 my $op               = $input->param('op') || 'list';
  39 my $cn_source        = $input->param('cn_source');
  40 my $class_sort_rule  = $input->param('class_sort_rule');
  41 my $class_split_rule = $input->param('class_split_rule');
  42 my $sort_routine     = $input->param('sort_routine');
  43 my $split_routine    = $input->param('split_routine');
  44 my @split_regex      = $input->multi_param('split_regex');
  45 my $description      = $input->param('description');
  46 my $used             = $input->param('used');
  47
  48 my ( $template, $loggedinuser, $cookie ) = get_template_and_user(
  49     {
  50         template_name   => "admin/classsources.tt",
  51         query           => $input,
  52         type            => "intranet",
  53         authnotrequired => 0,
  54         flagsrequired   => { parameters => 'manage_classifications' },
  55         debug           => 1,
  56     }
  57 );
  58
  59 my @messages;
  60 $template->param( script_name => $script_name );
  61
  62 if ( $op eq "add_source" ) {
  63     my $class_source =
  64       $cn_source ? Koha::ClassSources->find($cn_source) : undef;
  65     $template->param(
  66         class_source => $class_source,
  67         sort_rules   => scalar Koha::ClassSortRules->search,
  68         split_rules  => scalar Koha::ClassSplitRules->search,
  69     );
  70 }
  71 elsif ( $op eq "add_source_validate" ) {
  72     my $class_source = Koha::ClassSources->find($cn_source);
  73     if ($class_source) {
  74         $class_source->set(
  75             {
  76                 description      => $description,
  77                 used             => ( $used eq 'used' ? 1 : 0 ),
  78                 class_sort_rule  => $class_sort_rule,
  79                 class_split_rule => $class_split_rule,
  80             }
  81         );
  82         eval { $class_source->store; };
  83         if ($@) {
  84             push @messages,
  85               { type => 'error', code => 'error_on_update_source' };
  86         }
  87         else {
  88             push @messages,
  89               { type => 'message', code => 'success_on_update_source' };
  90         }
  91
  92     }
  93     else {
  94         $class_source = Koha::ClassSource->new(
  95             {
  96                 cn_source        => $cn_source,
  97                 description      => $description,
  98                 used             => ( $used eq 'used' ? 1 : 0 ),
  99                 class_sort_rule  => $class_sort_rule,
 100                 class_split_rule => $class_split_rule,
 101             }
 102         );
 103         eval { $class_source->store; };
 104         if ($@) {
 105             push @messages,
 106               { type => 'error', code => 'error_on_insert_source' };
 107         }
 108         else {
 109             push @messages,
 110               { type => 'message', code => 'success_on_insert_source' };
 111         }
 112     }
 113
 114     $op = 'list';
 115 }
 116 elsif ( $op eq "delete_source_confirmed" ) {
 117     my $class_source = Koha::ClassSources->find($cn_source);
 118     my $deleted = eval { $class_source->delete };
 119     if ( $@ or not $deleted ) {
 120         push @messages, { type => 'error', code => 'error_on_delete_source' };
 121     }
 122     else {
 123         push @messages,
 124           { type => 'message', code => 'success_on_delete_source' };
 125     }
 126
 127     $op = 'list';
 128 }
 129 elsif ( $op eq "add_sort_rule" ) {
 130     my $sort_rule =
 131       $class_sort_rule ? Koha::ClassSortRules->find($class_sort_rule) : undef;
 132     $template->param(
 133         sort_rule     => $sort_rule,
 134         sort_routines => get_class_sort_routines(),
 135     );
 136 }
 137 elsif ( $op eq "add_sort_rule_validate" ) {
 138     my $sort_rule = Koha::ClassSortRules->find($class_sort_rule);
 139     if ($sort_rule) {
 140         $sort_rule->set(
 141             { description => $description, sort_routine => $sort_routine } );
 142         eval { $sort_rule->store; };
 143         if ($@) {
 144             push @messages,
 145               { type => 'error', code => 'error_on_update_sort_rule' };
 146         }
 147         else {
 148             push @messages,
 149               { type => 'message', code => 'success_on_update_sort_rule' };
 150         }
 151
 152     }
 153     else {
 154         $sort_rule = Koha::ClassSortRule->new(
 155             {
 156                 class_sort_rule => $class_sort_rule,
 157                 description     => $description,
 158                 sort_routine    => $sort_routine,
 159             }
 160         );
 161         eval { $sort_rule->store; };
 162         if ($@) {
 163             push @messages,
 164               { type => 'error', code => 'error_on_insert_sort_rule' };
 165         }
 166         else {
 167             push @messages,
 168               { type => 'message', code => 'success_on_insert_sort_rule' };
 169         }
 170     }
 171     $op = 'list';
 172 }
 173 elsif ( $op eq "delete_sort_rule" ) {
 174     my $sort_rule = Koha::ClassSortRules->find($class_sort_rule);
 175     my $deleted = eval { $sort_rule->delete };
 176     if ( $@ or not $deleted ) {
 177         push @messages,
 178           { type => 'error', code => 'error_on_delete_sort_rule' };
 179     }
 180     else {
 181         push @messages,
 182           { type => 'message', code => 'success_on_delete_sort_rule' };
 183     }
 184     $op = 'list';
 185 }
 186 elsif ( $op eq "add_split_rule" ) {
 187     my $split_rule =
 188       $class_split_rule
 189       ? Koha::ClassSplitRules->find($class_split_rule)
 190       : undef;
 191     $template->param(
 192         split_rule     => $split_rule,
 193         split_routines => get_class_split_routines(),
 194     );
 195 }
 196 elsif ( $op eq "add_split_rule_validate" ) {
 197     my $split_rule = Koha::ClassSplitRules->find($class_split_rule);
 198
 199     @split_regex =  grep {!/^$/} @split_regex; # Remove empty
 200     if ($split_rule) {
 201         $split_rule->set(
 202             {
 203                 description   => $description,
 204                 split_routine => $split_routine,
 205             }
 206         );
 207         eval {
 208             $split_rule->regexs(\@split_regex)
 209                 if $split_routine eq 'RegEx';
 210             $split_rule->store;
 211         };
 212         if ($@) {
 213             push @messages,
 214               { type => 'error', code => 'error_on_update_split_rule' };
 215         }
 216         else {
 217             push @messages,
 218               { type => 'message', code => 'success_on_update_split_rule' };
 219         }
 220
 221     }
 222     else {
 223         $split_rule = Koha::ClassSplitRule->new(
 224             {
 225                 class_split_rule => $class_split_rule,
 226                 description      => $description,
 227                 split_routine    => $split_routine,
 228                 regexs           => \@split_regex,
 229             }
 230         );
 231         eval { $split_rule->store; };
 232         if ($@) {
 233             warn $@;
 234             push @messages,
 235               { type => 'error', code => 'error_on_insert_split_rule' };
 236         }
 237         else {
 238             push @messages,
 239               { type => 'message', code => 'success_on_insert_split_rule' };
 240         }
 241     }
 242     $op = 'list';
 243 }
 244 elsif ( $op eq "delete_split_rule" ) {
 245     my $split_rule = Koha::ClassSplitRules->find($class_split_rule);
 246     my $deleted = eval { $split_rule->delete };
 247     if ( $@ or not $deleted ) {
 248         push @messages,
 249           { type => 'error', code => 'error_on_delete_split_rule' };
 250     }
 251     else {
 252         push @messages,
 253           { type => 'message', code => 'success_on_delete_split_rule' };
 254     }
 255     $op = 'list';
 256 }
 257
 258 if ( $op eq 'list' ) {
 259     my $class_sources = Koha::ClassSources->search;
 260     my $sort_rules    = Koha::ClassSortRules->search;
 261     my $split_rules   = Koha::ClassSplitRules->search;
 262     $template->param(
 263         class_sources => $class_sources,
 264         sort_rules    => $sort_rules,
 265         split_rules   => $split_rules,
 266     );
 267 }
 268
 269 $template->param( op => $op, messages => \@messages, );
 270 output_html_with_http_headers $input, $cookie, $template->output;
 271
 272 exit 0;
 273
 274 sub get_class_sort_routines {
 275     my @sort_routines = GetSortRoutineNames();
 276     return \@sort_routines;
 277 }
 278
 279 sub get_class_split_routines {
 280     my @split_routines = GetSplitRoutineNames();
 281     return \@split_routines;
 282 }