Bug 19915: (QA follow-up) Tidy up GetItemsForInventory.t
[koha.git] / installer / onboarding.pl
1 #!/usr/bin/perl
2
3 # This file is part of Koha.
4 #
5 # Copyright (C) 2017 Catalyst IT
6 #
7 # Koha is free software; you can redistribute it and/or modify it
8 # under the terms of the GNU General Public License as published by
9 # the Free Software Foundation; either version 3 of the License, or
10 # (at your option) any later version.
11 #
12 # Koha is distributed in the hope that it will be useful, but
13 # WITHOUT ANY WARRANTY; without even the implied warranty of
14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 # GNU General Public License for more details.
16 #
17 # You should have received a copy of the GNU General Public License
18 # along with Koha; if not, see <http://www.gnu.org/licenses>.
19
20 use Modern::Perl;
21 use C4::Context;
22 use C4::InstallAuth;
23 use CGI qw ( -utf8 );
24 use C4::Output;
25 use C4::Members qw(checkcardnumber);
26 use Koha::Patrons;
27 use Koha::Libraries;
28 use Koha::Database;
29 use Koha::DateUtils;
30 use Koha::Patrons;
31 use Koha::Patron::Categories;
32 use Koha::ItemTypes;
33 use Koha::IssuingRules;
34
35 #Setting variables
36 my $input = new CGI;
37
38 unless ( C4::Context->preference('Version') ) {
39     print $input->redirect("/cgi-bin/koha/installer/install.pl");
40     exit;
41 }
42
43 my ( $user, $cookie, $sessionID, $flags ) =
44   C4::InstallAuth::checkauth( $input, 0, undef, 'intranet' );
45 die "Not logged in"
46   unless $user
47   ; # Should not happen, we should be redirect if the user is not logged in. But do not trust authentication...
48
49 my $step = $input->param('step') || 1;
50 my $op   = $input->param('op')   || '';
51
52 my $template_params = {};
53 $template_params->{op} = $op;
54
55 my $schema = Koha::Database->new()->schema();
56
57 my @messages;
58
59 if ( $step == 1 ) {
60
61     if ( $op eq 'add_validate_library' ) {
62
63         my $branchcode = $input->param('branchcode');
64         $branchcode = uc($branchcode);
65
66         $branchcode =~ s|\s||g
67           ; # Use a regular expression to check the value of the inputted branchcode
68
69         my $library = Koha::Library->new(
70             {
71                 branchcode => $branchcode,
72                 branchname => scalar $input->param('branchname'),
73             }
74         );
75
76         eval { $library->store; };
77         unless ($@) {
78             push @messages, { code => 'success_on_insert_library' };
79         }
80         else {
81             push @messages, { code => 'error_on_insert_library' };
82         }
83     }
84
85     $step++ if Koha::Libraries->count;
86 }
87 if ( $step == 2 ) {
88     if ( $op eq "add_validate_category" ) {
89
90         my $searchfield = $input->param('description') // q||;
91         my $categorycode = $input->param('categorycode');
92         my $category;
93         $template_params->{categorycode} = $categorycode;
94
95         $categorycode = $input->param('categorycode');
96         my $description           = $input->param('description');
97         my $overduenoticerequired = $input->param('overduenoticerequired');
98         my $category_type         = $input->param('category_type');
99         my $default_privacy       = $input->param('default_privacy');
100         my $enrolmentperiod       = $input->param('enrolmentperiod');
101         my $enrolmentperioddate = $input->param('enrolmentperioddate') || undef;
102
103         #Converts the string into a date format
104         if ($enrolmentperioddate) {
105             $enrolmentperioddate = output_pref(
106                 {
107                     dt         => dt_from_string($enrolmentperioddate),
108                     dateformat => 'DateTime',
109                     dateonly   => 1,
110                 }
111             );
112         }
113
114         #Adds a new patron category to the database
115         $category = Koha::Patron::Category->new(
116             {
117                 categorycode          => $categorycode,
118                 description           => $description,
119                 overduenoticerequired => $overduenoticerequired,
120                 category_type         => $category_type,
121                 default_privacy       => $default_privacy,
122                 enrolmentperiod       => $enrolmentperiod,
123                 enrolmentperioddate   => $enrolmentperioddate
124             }
125         );
126
127         eval { $category->store; };
128
129         unless ($@) {
130             push @messages, { code => 'success_on_insert_category' };
131         }
132         else {
133             push @messages, { code => 'error_on_insert_category' };
134         }
135     }
136
137     $step++ if Koha::Patron::Categories->count;
138 }
139 if ( $step == 3 ) {
140     if ( $op eq 'add_validate_patron' ) {
141
142         #Create a patron
143         my $firstpassword  = $input->param('password')  || '';
144         my $secondpassword = $input->param('password2') || '';
145         my $cardnumber     = $input->param('cardnumber');
146         my $userid         = $input->param('userid');
147
148         my ( $is_valid, $passworderror) = Koha::AuthUtils::is_password_valid( $firstpassword );
149
150         if ( my $error_code = checkcardnumber($cardnumber) ) {
151             if ( $error_code == 1 ) {
152                 push @messages, { code => 'ERROR_cardnumber_already_exists' };
153             }
154             elsif ( $error_code == 2 ) {
155                 push @messages, { code => 'ERROR_cardnumber_length' };
156             }
157         }
158         elsif ( $firstpassword ne $secondpassword ) {
159
160             push @messages, { code => 'ERROR_password_mismatch' };
161         }
162         elsif ( $passworderror) {
163                 push @messages, { code => 'ERROR_password_too_short'} if $passworderror eq 'too_short';
164                 push @messages, { code => 'ERROR_password_too_weak'} if $passworderror eq 'too_weak';
165                 push @messages, { code => 'ERROR_password_has_whitespaces'} if $passworderror eq 'has_whitespaces';
166
167         }
168         else {
169             my $patron_data = {
170                 surname      => scalar $input->param('surname'),
171                 firstname    => scalar $input->param('firstname'),
172                 cardnumber   => scalar $input->param('cardnumber'),
173                 branchcode   => scalar $input->param('libraries'),
174                 categorycode => scalar $input->param('categorycode_entry'),
175                 userid       => scalar $input->param('userid'),
176                 privacy      => "default",
177                 address      => "",
178                 city         => "",
179                 flags        => 1,    # Will be superlibrarian
180             };
181
182             my $patron_category =
183               Koha::Patron::Categories->find( $patron_data->{categorycode} );
184             $patron_data->{dateexpiry} =
185               $patron_category->get_expiry_date( $patron_data->{dateenrolled} );
186
187             eval {
188                 my $patron = Koha::Patron->new($patron_data)->store;
189                 $patron->set_password({ password =>  $firstpassword });
190             };
191
192             #Error handling checking if the patron was created successfully
193             unless ($@) {
194                 push @messages, { code => 'success_on_insert_patron' };
195             }
196             else {
197                 warn $@;
198                 push @messages, { code => 'error_on_insert_patron' };
199             }
200         }
201     }
202
203     $step++ if Koha::Patrons->search( { flags => 1 } )->count;
204 }
205 if ( $step == 4 ) {
206     if ( $op eq 'add_validate_itemtype' ) {
207         my $description   = $input->param('description');
208         my $itemtype_code = $input->param('itemtype');
209         $itemtype_code = uc($itemtype_code);
210
211         my $itemtype = Koha::ItemType->new(
212             {
213                 itemtype    => $itemtype_code,
214                 description => $description,
215             }
216         );
217         eval { $itemtype->store; };
218
219         unless ($@) {
220             push @messages, { code => 'success_on_insert_itemtype' };
221         }
222         else {
223             push @messages, { code => 'error_on_insert_itemtype' };
224         }
225     }
226
227     $step++ if Koha::ItemTypes->count;
228 }
229 if ( $step == 5 ) {
230
231     if ( $op eq 'add_validate_circ_rule' ) {
232
233         #If no libraries exist then set the $branch value to *
234         my $branch = $input->param('branch') || '*';
235
236         my $type            = $input->param('type');
237         my $branchcode      = $input->param('branch');
238         my $categorycode    = $input->param('categorycode');
239         my $itemtype        = $input->param('itemtype');
240         my $maxissueqty     = $input->param('maxissueqty');
241         my $issuelength     = $input->param('issuelength');
242         my $lengthunit      = $input->param('lengthunit');
243         my $renewalsallowed = $input->param('renewalsallowed');
244         my $renewalperiod   = $input->param('renewalperiod');
245         my $onshelfholds    = $input->param('onshelfholds') || 0;
246         $maxissueqty =~ s/\s//g;
247         $maxissueqty = undef if $maxissueqty !~ /^\d+/;
248         $issuelength = $issuelength eq q{} ? undef : $issuelength;
249
250         my $params = {
251             branchcode      => $branchcode,
252             categorycode    => $categorycode,
253             itemtype        => $itemtype,
254             maxissueqty     => $maxissueqty,
255             renewalsallowed => $renewalsallowed,
256             renewalperiod   => $renewalperiod,
257             issuelength     => $issuelength,
258             lengthunit      => $lengthunit,
259             onshelfholds    => $onshelfholds,
260         };
261
262         my $issuingrule = Koha::IssuingRule->new($params);
263         eval { $issuingrule->store; };
264
265         unless ($@) {
266             push @messages, { code => 'success_on_insert_circ_rule' };
267         }
268         else {
269             push @messages, { code => 'error_on_insert_circ_rule' };
270         }
271     }
272
273     $step++ if Koha::IssuingRules->count;
274 }
275
276 my $libraries = Koha::Libraries->search( {}, { order_by => ['branchcode'] }, );
277 $template_params->{libraries}   = $libraries;
278
279 if ( $step > 5 ) {
280     $template_params->{all_done} = 1;    # If step 5 is complete, we are done!
281     $step = 5;
282 }
283
284 #Getting the appropriate template to display to the user
285 my ( $template, $loggedinuser );
286 ( $template, $loggedinuser, $cookie ) = C4::InstallAuth::get_template_and_user(
287     {
288         template_name   => "onboarding/onboardingstep${step}.tt",
289         query           => $input,
290         type            => "intranet",
291         authnotrequired => 0,
292         debug           => 1,
293     }
294 );
295
296 $template_params->{messages} = \@messages;
297 my $categories = Koha::Patron::Categories->search();
298 $template_params->{categories} = $categories;
299
300 my $itemtypes = Koha::ItemTypes->search();
301 $template_params->{itemtypes} = $itemtypes;
302
303 $template->param(%$template_params);
304
305 output_html_with_http_headers $input, $cookie, $template->output;