blib/lib/Lemonldap/NG/Portal/Plugins/Register.pm untested

filter: Statementstmt 0.0% 0 / 159 Branchbran 0.0% 0 / 80 Conditioncond 0.0% 0 / 62 MC/DCmcdc 0.0% 0 / 34 Subroutinesub 0.0% 0 / 11 Podpod 0.0% 0 / 5 totaltotal 0.0% 0 / 351 CC 41 SCAR 58.7
CC
41
Cov
0%
_register
600.0
display
240.0
setSecurity
12.0
CRAP 354.2
1 package Lemonldap::NG::Portal::Plugins::Register;
2  
3 use strict;
4 use Encode;
5 use Mouse;
6 use POSIX qw(strftime);
7 use Lemonldap::NG::Common::FormEncode;
8 use Lemonldap::NG::Portal::Main::Constants qw(
9 PE_OK
10 PE_MAILOK
11 PE_NOTOKEN
12 PE_MAILERROR
13 PE_BADMAILTOKEN
14 PE_CAPTCHAEMPTY
15 PE_CAPTCHAERROR
16 PE_TOKENEXPIRED
17 PE_MAILCONFIRMOK
18 PE_MALFORMEDUSER
19 PE_REGISTERFORMEMPTY
20 PE_REGISTERFIRSTACCESS
21 PE_REGISTERALREADYEXISTS
22 PE_MAILCONFIRMATION_ALREADY_SENT
23 );
24  
25 our $VERSION = '2.19.0';
26  
27 extends qw(
28 Lemonldap::NG::Portal::Lib::SMTP
29 Lemonldap::NG::Portal::Main::Plugin
30 Lemonldap::NG::Portal::Lib::_tokenRule
31 );
32  
33 # PROPERTIES
34  
35 # Sub module (Demo, LDAP,...)
36 has registerModule => ( is => 'rw' );
37  
38 # Mail timeout token generator
39 has mailott => (
40 is => 'rw',
41 lazy => 1,
42 default => sub {
43 my $ott =
44 $_[0]->{p}->loadModule('Lemonldap::NG::Portal::Lib::OneTimeToken');
45 $ott->cache(0);
46 $ott->timeout( $_[0]->conf->{registerTimeout}
47 || $_[0]->conf->{timeout} );
48 return $ott;
49 }
50 );
51  
52 # Form timout token generator (used if requireToken is set)
53 has ott => ( is => 'rw' );
54  
55 # Captcha generator
56 has captcha => ( is => 'rw' );
57  
58 # INITIALIZATION
59  
60 sub init {
61 my ($self) = @_;
62  
63 # Declare REST route
64 $self->addUnauthRoute( register => 'register', [ 'POST', 'GET' ] );
65  
66 # Initialize Captcha if needed
67 $self->captcha(
68 $self->p->buildRule(
69 $self->conf->{captcha_register_enabled},
70 'captchaRegister'
71 )
72 );
73  
74 # Initialize form token if needed (captcha provides also a token)
75 unless ( $self->conf->{captcha_register_enabled} ) {
76 $_[0]->ott(
77 $_[0]->p->loadModule('Lemonldap::NG::Portal::Lib::OneTimeToken') )
78 or return 0;
79 $_[0]->ott->timeout( $_[0]->conf->{formTimeout} );
80 }
81  
82 # Load registered module
83 $self->registerModule(
84 $self->p->loadPlugin( '::Register::' . $self->conf->{registerDB} ) )
85 or return 0;
86  
87 return 1;
88 }
89  
90 # RUNNIG METHODS
91  
92 # Handle register requests
93 sub register {
94 my ( $self, $req ) = @_;
95  
96 $self->p->controlUrl($req);
97  
98 # Check parameters
99 $req->error( $self->_register($req) );
100  
101 # Display form
102 my ( $tpl, $prms ) = $self->display($req);
103 return $self->p->sendHtml( $req, $tpl, params => $prms );
104 }
105  
106 # Parameters check
107 sub _register {
108 my ( $self, $req ) = @_;
109  
110 # Check if it's a first access
111 unless ( ( $req->method =~ /^POST$/i and $req->param('mail') )
112 or $req->param('register_token') )
113 {
114  
115 # Set captcha or token
116 $self->setSecurity($req);
117 $self->logger->debug('First access to register form');
118 return PE_REGISTERFIRSTACCESS if ( $req->method eq 'GET' );
119 return PE_REGISTERFORMEMPTY;
120 }
121  
122 # Get register token (mail link)
123 $req->data->{register_token} = $req->param('register_token');
124  
125 # If a register token is present, find the corresponding info
126 if ( $req->data->{register_token} ) {
127  
128 $self->logger->debug(
129 "Token provided for register: " . $req->data->{register_token} );
130  
131 # Get the corresponding session
132 if ( my $data =
133 $self->mailott->getToken( $req->data->{register_token} ) )
134 {
135 $self->logger->debug(
136 'Token ' . $req->data->{register_token} . ' found' );
137 foreach (qw(mail firstname lastname ipAddr)) {
138 $req->data->{registerInfo}->{$_} = $data->{$_};
139 }
140 $self->logger->debug( "User associated to token: "
141 . $req->data->{registerInfo}->{mail} );
142 }
143 else {
144 return PE_BADMAILTOKEN;
145 }
146 }
147  
148 # Case else: user tries to register
149 else {
150  
151 # Use submitted value
152 $req->data->{registerInfo}->{mail} = $req->param('mail');
153 $req->data->{registerInfo}->{firstname} = $req->param('firstname');
154 $req->data->{registerInfo}->{lastname} = $req->param('lastname');
155 $req->data->{registerInfo}->{ipAddr} = $req->address;
156  
157 # Check captcha/token only if register session does not already exist
158 if ( $req->data->{registerInfo}->{mail}
159 and
160 !$self->getRegisterSession( $req->data->{registerInfo}->{mail} ) )
161 {
162  
163 # Captcha for register form
164 if ( $self->captcha->( $req, {} ) ) {
165 my $result =
166 $self->p->getService('captcha')->check_captcha($req);
167 if ($result) {
168 $self->logger->debug("Captcha code verified");
169 }
170 else {
171 $self->setSecurity($req);
172 $self->userLogger->warn("Captcha failed");
173 return PE_CAPTCHAERROR;
174 }
175 }
176 elsif ( $self->ottRule->( $req, {} ) ) {
177 my $token = $req->param('token');
178 unless ($token) {
179 $self->setSecurity($req);
180 $self->userLogger->warn('Register try without token');
181 return PE_NOTOKEN;
182 }
183 unless ( $self->ott->getToken($token) ) {
184 $self->setSecurity($req);
185 $self->userLogger->warn(
186 'Register try with expired/bad token');
187 return PE_TOKENEXPIRED;
188 }
189 }
190 }
191 }
192  
193 # Check mail
194 return PE_MALFORMEDUSER
195 unless (
196 $req->data->{registerInfo}->{mail} =~ m/$self->{conf}->{userControl}/ );
197  
198 # Search for user using UserDB module
199 # If the user already exists, register is forbidden
200 $req->user( $req->data->{registerInfo}->{mail} );
201 if ( $self->p->_userDB->getUser( $req, useMail => 1 ) == PE_OK ) {
202 $self->userLogger->error(
203 "Register: refuse mail $req->{data}->{registerInfo}->{mail} because already exists in UserDB"
204 );
205 return PE_REGISTERALREADYEXISTS;
206 }
207 my $register_session =
208 $self->getRegisterSession( $req->data->{registerInfo}->{mail} );
209 $req->data->{mail_already_sent} =
210 ( $register_session and !$req->id ) ? 1 : 0;
211  
212 # Skip this step if confirmation was already sent
213 unless ( $req->data->{register_token} or $register_session ) {
214  
215 # Create mail token
216 $register_session = $self->mailott->createToken( {
217 mail => $req->data->{registerInfo}->{mail},
218 firstname => $req->data->{registerInfo}->{firstname},
219 lastname => $req->data->{registerInfo}->{lastname},
220 ipAddr => $req->data->{registerInfo}->{ipAddr},
221 _type => 'register',
222 }
223 );
224 $self->logger->debug("Token $register_session created");
225 }
226  
227 # Send confirmation mail
228  
229 # Skip this step if user clicked on the confirmation link
230 unless ( $req->data->{register_token} ) {
231  
232 # Check if confirmation mail has already been sent
233 $self->logger->debug('No register_token');
234  
235 # Read session to get creation and expiration dates
236 $req->id($register_session) unless $req->id;
237  
238 $self->logger->debug("Register session found: $register_session");
239  
240 # Mail session expiration date
241 my $expTimestamp =
242 ( $self->conf->{registerTimeout} || $self->conf->{timeout} ) + time;
243  
244 $self->logger->debug("Register expiration timestamp: $expTimestamp");
245  
246 $req->data->{expMailDate} =
247 strftime( "%d/%m/%Y", localtime $expTimestamp );
248 $req->data->{expMailTime} =
249 strftime( "%H:%M", localtime $expTimestamp );
250  
251 # Mail session start date
252 my $startTimestamp = time;
253  
254 $self->logger->debug("Register start timestamp: $startTimestamp");
255  
256 $req->data->{startMailDate} =
257 strftime( "%d/%m/%Y", localtime $startTimestamp );
258 $req->data->{startMailTime} =
259 strftime( "%H:%M", localtime $startTimestamp );
260  
261 # Ask if user want another confirmation email
262 if ( $req->data->{mail_already_sent}
263 and !$req->param('resendconfirmation') )
264 {
265 return PE_MAILCONFIRMATION_ALREADY_SENT;
266 }
267  
268 # Build confirmation url
269 my $req_url = $req->data->{_url};
270 my $skin = $self->p->getSkin($req);
271 my $url = $self->p->buildUrl(
272 ( $self->conf->{registerUrl} || ( $req->portal, "register" ) ),
273 {
274 register_token => $req->{id},
275 skin => $skin,
276 ( $req_url ? ( url => $req_url ) : () ),
277 }
278 );
279  
280 # Send mail
281 return PE_MAILERROR
282 unless $self->sendEmail(
283 $req,
284 subject => $self->conf->{registerConfirmSubject},
285 subject_trmsg => 'registerConfirmSubject',
286 body => $self->conf->{registerConfirmBody},
287 body_template => 'mail_register_confirm',
288 dest => $req->data->{registerInfo}->{mail},
289 params => {
290 expMailDate => $req->data->{expMailDate},
291 expMailTime => $req->data->{expMailTime},
292 url => $url,
293 %{ $req->data->{registerInfo} || {} },
294 },
295 );
296  
297 $self->logger->debug('Register message sent');
298 return PE_MAILCONFIRMOK;
299 }
300  
301 # Generate a complex password
302 my $password = $self->gen_password( $self->conf->{randomPasswordRegexp} );
303  
304 $self->logger->debug( "Generated password: " . $password );
305  
306 $req->data->{registerInfo}->{password} = $password;
307 $req->data->{forceReset} = 1;
308  
309 # Find a login
310 my $result = $self->registerModule->computeLogin($req);
311 unless ( $result == PE_OK ) {
312 $self->logger->error( "Could not compute login for "
313 . $req->data->{registerInfo}->{mail} );
314 return $result;
315 }
316  
317 # Create user
318 $self->logger->debug(
319 'Create new user ' . $req->data->{registerInfo}->{login} );
320 $result = $self->registerModule->createUser($req);
321 unless ( $result == PE_OK ) {
322 $self->logger->error(
323 "Could not create user " . $req->data->{registerInfo}->{login} );
324 return $result;
325 }
326  
327 # Build portal url
328 my $req_url = $req->data->{_url};
329 my $skin = $self->p->getSkin($req);
330 my $url = $self->p->buildUrl(
331 $req->portal,
332 {
333 skin => $skin,
334 ( $req_url ? ( url => $req_url ) : () ),
335 }
336 );
337  
338 # Send mail
339 return PE_MAILERROR
340 unless $self->sendEmail(
341 $req,
342 subject => $self->conf->{registerDoneSubject},
343 subject_trmsg => 'registerDoneSubject',
344 body => $self->conf->{registerDoneBody},
345 body_template => 'mail_register_done',
346 dest => $req->data->{registerInfo}->{mail},
347 params => {
348 url => $url,
349 %{ $req->data->{registerInfo} || {} },
350 }
351 );
352  
353 return PE_MAILOK;
354 }
355  
356 sub display {
357 my ( $self, $req ) = @_;
358 my %templateParams = (
359 $self->p->getErrorTplParams($req),
360 SKIN_PATH => $self->conf->{staticPrefix},
361 SKIN => $self->p->getSkin($req),
362 SKIN_BG => $self->conf->{portalSkinBackground},
363 MAIN_LOGO => $self->conf->{portalMainLogo},
364 AUTH_URL => $req->data->{_url},
365 CHOICE_PARAM => $self->conf->{authChoiceParam},
366 CHOICE_VALUE => $req->data->{_authChoice},
367 EXPMAILDATE => $req->data->{expMailDate},
368 EXPMAILTIME => $req->data->{expMailTime},
369 STARTMAILDATE => $req->data->{startMailDate},
370 STARTMAILTIME => $req->data->{startMailTime},
371 MAILALREADYSENT => $req->data->{mail_already_sent},
372 (
373 $req->data->{customScript}
374 ? ( CUSTOM_SCRIPT => $req->data->{customScript} )
375 : ()
376 ),
377 MAIL => $self->p->checkXSSAttack(
378 'mail', $req->data->{registerInfo}->{mail}
379 ) ? ""
380 : $req->data->{registerInfo}->{mail},
381 FIRSTNAME => $self->p->checkXSSAttack( 'firstname',
382 $req->data->{registerInfo}->{firstname} ) ? ""
383 : $req->data->{registerInfo}->{firstname},
384 LASTNAME => $self->p->checkXSSAttack( 'lastname',
385 $req->data->{registerInfo}->{lastname} ) ? ""
386 : $req->data->{registerInfo}->{lastname},
387 REGISTER_TOKEN => $self->p->checkXSSAttack( 'register_token',
388 $req->data->{register_token} ) ? ""
389 : $req->data->{register_token},
390 );
391  
392 # Display form the first time
393 if ( (
394 $req->error == PE_REGISTERFORMEMPTY
395 or $req->error == PE_REGISTERFIRSTACCESS
396 or $req->error == PE_CAPTCHAERROR
397 or $req->error == PE_CAPTCHAEMPTY
398 or $req->error == PE_NOTOKEN
399 or $req->error == PE_TOKENEXPIRED
400 )
401 and !$req->param('mail_token')
402 )
403 {
404 %templateParams = (
405 %templateParams,
406 DISPLAY_FORM => 1,
407 DISPLAY_RESEND_FORM => 0,
408 DISPLAY_CONFIRMMAILSENT => 0,
409 DISPLAY_MAILSENT => 0,
410 DISPLAY_PASSWORD_FORM => 0,
411 );
412 }
413  
414 # Display captcha if it's enabled
415 if ( $req->captchaHtml ) {
416 $templateParams{CAPTCHA_HTML} = $req->captchaHtml;
417 }
418 if ( $req->token ) {
419 $templateParams{TOKEN} = $req->token;
420 }
421  
422 # DEPRECATED: This is only used for compatibility with existing templates
423 if ( $req->captcha ) {
424 $templateParams{CAPTCHA_SRC} = $req->captcha;
425 $templateParams{CAPTCHA_SIZE} = $self->conf->{captcha_size};
426 }
427  
428 if ( $req->error == PE_REGISTERALREADYEXISTS ) {
429 %templateParams = (
430 %templateParams,
431 DISPLAY_FORM => 0,
432 DISPLAY_RESEND_FORM => 0,
433 DISPLAY_CONFIRMMAILSENT => 0,
434 DISPLAY_MAILSENT => 0,
435 DISPLAY_PASSWORD_FORM => 0,
436 );
437 }
438  
439 # Display mail confirmation resent form
440 if ( $req->{error} == PE_MAILCONFIRMATION_ALREADY_SENT ) {
441 %templateParams = (
442 %templateParams,
443 DISPLAY_FORM => 0,
444 DISPLAY_RESEND_FORM => 1,
445 DISPLAY_CONFIRMMAILSENT => 0,
446 DISPLAY_MAILSENT => 0,
447 DISPLAY_PASSWORD_FORM => 0,
448 );
449 }
450  
451 # Display confirmation mail sent
452 if ( $req->{error} == PE_MAILCONFIRMOK ) {
453 %templateParams = (
454 %templateParams,
455 DISPLAY_FORM => 0,
456 DISPLAY_RESEND_FORM => 0,
457 DISPLAY_CONFIRMMAILSENT => 1,
458 DISPLAY_MAILSENT => 0,
459 DISPLAY_PASSWORD_FORM => 0,
460 );
461 }
462  
463 # Display mail sent
464 if ( $req->{error} == PE_MAILOK ) {
465 %templateParams = (
466 %templateParams,
467 DISPLAY_FORM => 0,
468 DISPLAY_RESEND_FORM => 0,
469 DISPLAY_CONFIRMMAILSENT => 0,
470 DISPLAY_MAILSENT => 1,
471 DISPLAY_PASSWORD_FORM => 0,
472 );
473 }
474  
475 # Display password change form
476 if ( $req->param('mail_token')
477 and $req->{error} != PE_MAILERROR
478 and $req->{error} != PE_BADMAILTOKEN
479 and $req->{error} != PE_MAILOK )
480 {
481 %templateParams = (
482 %templateParams,
483 DISPLAY_FORM => 0,
484 DISPLAY_RESEND_FORM => 0,
485 DISPLAY_CONFIRMMAILSENT => 0,
486 DISPLAY_MAILSENT => 0,
487 DISPLAY_PASSWORD_FORM => 1,
488 );
489 }
490  
491 return ( 'register', \%templateParams );
492 }
493  
494 sub setSecurity {
495 my ( $self, $req ) = @_;
496 if ( $self->captcha ) {
497 $self->p->getService('captcha')->init_captcha($req);
498 }
499 elsif ( $self->ottRule->( $req, {} ) ) {
500 $self->ott->setToken($req);
501 }
502 }
503  
504 1;