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 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            = new CGI;
  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->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         authnotrequired => 0,
  53         flagsrequired   => { parameters => 'manage_classifications' },
  54         debug           => 1,
  55     }
  56 );
  57
  58 my @messages;
  59 $template->param( script_name => $script_name );
  60
  61 if ( $op eq "add_source" ) {
  62     my $class_source =
  63       $cn_source ? Koha::ClassSources->find($cn_source) : undef;
  64     $template->param(
  65         class_source => $class_source,
  66         sort_rules   => scalar Koha::ClassSortRules->search,
  67         split_rules  => scalar Koha::ClassSplitRules->search,
  68     );
  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         }
  90
  91     }
  92     else {
  93         $class_source = Koha::ClassSource->new(
  94             {
  95                 cn_source        => $cn_source,
  96                 description      => $description,
  97                 used             => ( $used eq 'used' ? 1 : 0 ),
  98                 class_sort_rule  => $class_sort_rule,
  99                 class_split_rule => $class_split_rule,
 100             }
 101         );
 102         eval { $class_source->store; };
 103         if ($@) {
 104             push @messages,
 105               { type => 'error', code => 'error_on_insert_source' };
 106         }
 107         else {
 108             push @messages,
 109               { type => 'message', code => 'success_on_insert_source' };
 110         }
 111     }
 112
 113     $op = 'list';
 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     }
 125
 126     $op = 'list';
 127 }
 128 elsif ( $op eq "add_sort_rule" ) {
 129     my $sort_rule =
 130       $class_sort_rule ? Koha::ClassSortRules->find($class_sort_rule) : undef;
 131     $template->param(
 132         sort_rule     => $sort_rule,
 133         sort_routines => get_class_sort_routines(),
 134     );
 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         }
 150
 151     }
 152     else {
 153         $sort_rule = Koha::ClassSortRule->new(
 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';
 171 }
 172 elsif ( $op eq "delete_sort_rule" ) {
 173     my $sort_rule = Koha::ClassSortRules->find($class_sort_rule);
 174     my $deleted = eval { $sort_rule->delete };
 175     if ( $@ or not $deleted ) {
 176         push @messages,
 177           { type => 'error', code => 'error_on_delete_sort_rule' };
 178     }
 179     else {
 180         push @messages,
 181           { type => 'message', code => 'success_on_delete_sort_rule' };
 182     }
 183     $op = 'list';
 184 }
 185 elsif ( $op eq "add_split_rule" ) {
 186     my $split_rule =
 187       $class_split_rule
 188       ? Koha::ClassSplitRules->find($class_split_rule)
 189       : undef;
 190     $template->param(
 191         split_rule     => $split_rule,
 192         split_routines => get_class_split_routines(),
 193     );
 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         }
 215
 216     }
 217     else {
 218         $split_rule = Koha::ClassSplitRule->new(
 219             {
 220                 class_split_rule => $class_split_rule,
 221                 description      => $description,
 222                 split_routine    => $split_routine,
 223                 split_regex =>
 224                   ( $split_routine eq 'RegEx' ? $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 = qw(
 277       Dewey
 278       Generic
 279       LCC
 280       RegEx
 281     );
 282     return \@split_routines;
 283 }