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