1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34 package fr.paris.lutece.plugins.mylutece.modules.database.authentication.service;
35
36 import java.sql.Timestamp;
37 import java.text.DateFormat;
38 import java.text.SimpleDateFormat;
39 import java.util.ArrayList;
40 import java.util.Collection;
41 import java.util.Date;
42 import java.util.HashMap;
43 import java.util.List;
44 import java.util.Locale;
45 import java.util.Map;
46
47 import javax.servlet.http.HttpServletRequest;
48
49 import org.apache.commons.lang3.StringUtils;
50
51 import fr.paris.lutece.api.user.User;
52 import fr.paris.lutece.plugins.mylutece.authentication.MultiLuteceAuthentication;
53 import fr.paris.lutece.plugins.mylutece.business.attribute.AttributeField;
54 import fr.paris.lutece.plugins.mylutece.business.attribute.AttributeFieldHome;
55 import fr.paris.lutece.plugins.mylutece.business.attribute.AttributeHome;
56 import fr.paris.lutece.plugins.mylutece.business.attribute.IAttribute;
57 import fr.paris.lutece.plugins.mylutece.business.attribute.MyLuteceUserField;
58 import fr.paris.lutece.plugins.mylutece.business.attribute.MyLuteceUserFieldFilter;
59 import fr.paris.lutece.plugins.mylutece.business.attribute.MyLuteceUserFieldHome;
60 import fr.paris.lutece.plugins.mylutece.modules.database.authentication.BaseAuthentication;
61 import fr.paris.lutece.plugins.mylutece.modules.database.authentication.BaseUser;
62 import fr.paris.lutece.plugins.mylutece.modules.database.authentication.business.DatabaseHome;
63 import fr.paris.lutece.plugins.mylutece.modules.database.authentication.business.DatabaseUser;
64 import fr.paris.lutece.plugins.mylutece.modules.database.authentication.business.DatabaseUserFieldListener;
65 import fr.paris.lutece.plugins.mylutece.modules.database.authentication.business.DatabaseUserFilter;
66 import fr.paris.lutece.plugins.mylutece.modules.database.authentication.business.DatabaseUserHome;
67 import fr.paris.lutece.plugins.mylutece.modules.database.authentication.business.DatabaseUserRoleRemovalListener;
68 import fr.paris.lutece.plugins.mylutece.modules.database.authentication.business.GroupRoleHome;
69 import fr.paris.lutece.plugins.mylutece.modules.database.authentication.service.parameter.DatabaseUserParameterService;
70 import fr.paris.lutece.plugins.mylutece.service.MyLutecePlugin;
71 import fr.paris.lutece.plugins.mylutece.util.SecurityUtils;
72 import fr.paris.lutece.portal.business.rbac.RBAC;
73 import fr.paris.lutece.portal.business.role.Role;
74 import fr.paris.lutece.portal.business.role.RoleHome;
75 import fr.paris.lutece.portal.business.user.AdminUser;
76 import fr.paris.lutece.portal.service.admin.AdminAuthenticationService;
77 import fr.paris.lutece.portal.service.mail.MailService;
78 import fr.paris.lutece.portal.service.plugin.Plugin;
79 import fr.paris.lutece.portal.service.plugin.PluginService;
80 import fr.paris.lutece.portal.service.rbac.RBACService;
81 import fr.paris.lutece.portal.service.role.RoleRemovalListenerService;
82 import fr.paris.lutece.portal.service.security.LuteceUser;
83 import fr.paris.lutece.portal.service.security.SecurityService;
84 import fr.paris.lutece.portal.service.spring.SpringContextService;
85 import fr.paris.lutece.portal.service.template.AppTemplateService;
86 import fr.paris.lutece.portal.service.template.DatabaseTemplateService;
87 import fr.paris.lutece.portal.service.util.AppLogService;
88 import fr.paris.lutece.portal.service.workgroup.AdminWorkgroupService;
89 import fr.paris.lutece.util.ReferenceItem;
90 import fr.paris.lutece.util.html.HtmlTemplate;
91 import fr.paris.lutece.util.password.IPasswordFactory;
92 import fr.paris.lutece.util.url.UrlItem;
93 import fr.paris.lutece.util.xml.XmlUtil;
94
95
96
97
98
99
100 public final class DatabaseService
101 {
102 private static final String BEAN_DATABASE_SERVICE = "mylutece-database.databaseService";
103 private static final String AUTHENTICATION_BEAN_NAME = "mylutece-database.authentication";
104
105
106 private static final String AMPERSAND = "&";
107 private static final String PLUGIN_JCAPTCHA = "jcaptcha";
108 private static final String CONSTANT_XML_USER = "user";
109 private static final String CONSTANT_XML_ACCESS_CODE = "access_code";
110 private static final String CONSTANT_XML_LAST_NAME = "last_name";
111 private static final String CONSTANT_XML_FIRST_NAME = "first_name";
112 private static final String CONSTANT_XML_EMAIL = "email";
113 private static final String CONSTANT_XML_STATUS = "status";
114 private static final String CONSTANT_XML_PASSWORD_MAX_VALID_DATE = "password_max_valid_date";
115 private static final String CONSTANT_XML_ACCOUNT_MAX_VALID_DATE = "account_max_valid_date";
116 private static final String CONSTANT_XML_ROLES = "roles";
117 private static final String CONSTANT_XML_GROUPS = "groups";
118 private static final String CONSTANT_XML_ROLE = "role";
119 private static final String CONSTANT_XML_GROUP = "group";
120 private static final String CONSTANT_XML_ATTRIBUTES = "attributes";
121 private static final String CONSTANT_XML_ATTRIBUTE = "attribute";
122 private static final String CONSTANT_XML_ATTRIBUTE_ID = "attribute-id";
123 private static final String CONSTANT_XML_ATTRIBUTE_FIELD_ID = "attribute-field-id";
124 private static final String CONSTANT_XML_ATTRIBUTE_VALUE = "attribute-value";
125
126
127 private static final String MARK_SEARCH_IS_SEARCH = "search_is_search";
128 private static final String MARK_SORT_SEARCH_ATTRIBUTE = "sort_search_attribute";
129 private static final String MARK_SEARCH_USER_FILTER = "search_user_filter";
130 private static final String MARK_SEARCH_MYLUTECE_USER_FIELD_FILTER = "search_mylutece_user_field_filter";
131 private static final String MARK_ATTRIBUTES_LIST = "attributes_list";
132 private static final String MARK_IS_PLUGIN_JCAPTCHA_ENABLE = "is_plugin_jcatpcha_enable";
133 private static final String MARK_LOGIN_URL = "login_url";
134 private static final String MARK_NEW_PASSWORD = "new_password";
135 private static final String MARK_ENABLE_JCAPTCHA = "enable_jcaptcha";
136 private static final String MARK_SITE_LINK = "site_link";
137 private static final String MARK_BANNED_DOMAIN_NAMES = "banned_domain_names";
138
139
140 private static final String PARAMETER_ACCOUNT_CREATION_VALIDATION_EMAIL = "account_creation_validation_email";
141 private static final String PARAMETER_ACCOUNT_REACTIVATED_MAIL_SENDER = "account_reactivated_mail_sender";
142 private static final String PARAMETER_ACCOUNT_REACTIVATED_MAIL_SUBJECT = "account_reactivated_mail_subject";
143 private static final String PARAMETER_ACCOUNT_REACTIVATED_MAIL_BODY = "mylutece_database_account_reactivated_mail";
144 private static final String PARAMETER_MAIL_PASSWORD_ENCRYPTION_CHANGED = "mylutece_database_mailPasswordEncryptionChanged";
145 private static final String PARAMETER_MAIL_PASSWORD_ENCRYPTION_CHANGED_SENDER = "mail_password_encryption_changed_sender";
146 private static final String PARAMETER_MAIL_PASSWORD_ENCRYPTION_CHANGED_SUBJECT = "mail_password_encryption_changed_subject";
147 private static final String PARAMETER_AUTO_LOGIN_AFTER_VALIDATION_EMAIL = "auto_login_after_validation_email";
148
149
150 private static DatabaseService _singleton;
151 private DatabaseUserParameterService _userParamService;
152 private BaseAuthentication _baseAuthentication;
153 private IPasswordFactory _passwordFactory;
154
155
156
157
158 private DatabaseService( )
159 {
160 }
161
162
163
164
165
166
167
168 public void setDatabaseUserParameterService( DatabaseUserParameterService userParamService )
169 {
170 _userParamService = userParamService;
171 }
172
173
174
175
176
177
178
179 public void setPasswordFactory( IPasswordFactory passwordFactory )
180 {
181 _passwordFactory = passwordFactory;
182 }
183
184
185
186
187
188 public void init( )
189 {
190 RoleRemovalListenerService.getService( ).registerListener( new DatabaseUserRoleRemovalListener( ) );
191 DatabaseMyLuteceUserFieldListenerService.getService( ).registerListener( new DatabaseUserFieldListener( ) );
192
193 _baseAuthentication = SpringContextService.getBean( AUTHENTICATION_BEAN_NAME );
194
195 if ( _baseAuthentication != null )
196 {
197 MultiLuteceAuthentication.registerAuthentication( _baseAuthentication );
198 }
199 else
200 {
201 AppLogService.error( "BaseAuthentication not found, please check your database_context.xml configuration" );
202 }
203 }
204
205
206
207
208
209
210 public static synchronized DatabaseService getService( )
211 {
212 if ( _singleton == null )
213 {
214 _singleton = SpringContextService.getBean( BEAN_DATABASE_SERVICE );
215 }
216
217 return _singleton;
218 }
219
220
221
222
223
224
225
226
227 public Map<String, Object> getManageAdvancedParameters( AdminUser user )
228 {
229 Map<String, Object> model = new HashMap<>( );
230 Plugin plugin = PluginService.getPlugin( DatabasePlugin.PLUGIN_NAME );
231
232 if ( RBACService.isAuthorized( DatabaseResourceIdService.RESOURCE_TYPE, RBAC.WILDCARD_RESOURCES_ID, DatabaseResourceIdService.PERMISSION_MANAGE,
233 (User) user ) )
234 {
235 model.put( MARK_IS_PLUGIN_JCAPTCHA_ENABLE, isPluginJcaptchaEnable( ) );
236
237 if ( isPluginJcaptchaEnable( ) )
238 {
239 model.put( MARK_ENABLE_JCAPTCHA, SecurityUtils.getBooleanSecurityParameter( _userParamService, plugin, MARK_ENABLE_JCAPTCHA ) );
240 }
241
242 model.put( PARAMETER_ACCOUNT_CREATION_VALIDATION_EMAIL,
243 SecurityUtils.getBooleanSecurityParameter( _userParamService, plugin, PARAMETER_ACCOUNT_CREATION_VALIDATION_EMAIL ) );
244
245 model.put( PARAMETER_AUTO_LOGIN_AFTER_VALIDATION_EMAIL,
246 SecurityUtils.getBooleanSecurityParameter( _userParamService, plugin, PARAMETER_AUTO_LOGIN_AFTER_VALIDATION_EMAIL ) );
247
248 model.put( MARK_BANNED_DOMAIN_NAMES, SecurityUtils.getLargeSecurityParameter( _userParamService, plugin, MARK_BANNED_DOMAIN_NAMES ) );
249
250 model = SecurityUtils.checkSecurityParameters( _userParamService, model, plugin );
251 }
252
253 return model;
254 }
255
256
257
258
259
260
261
262
263
264
265
266
267 public boolean isAuthorized( DatabaseUser user, AdminUser adminUser, Plugin plugin )
268 {
269 boolean bHasRole = false;
270 List<String> userRoleKeyList = DatabaseHome.findUserRolesFromLogin( user.getLogin( ), plugin );
271
272 for ( String userRoleKey : userRoleKeyList )
273 {
274 bHasRole = true;
275
276 Role role = RoleHome.findByPrimaryKey( userRoleKey );
277
278 if ( AdminWorkgroupService.isAuthorized( role, (User) adminUser ) )
279 {
280 return true;
281 }
282 }
283
284 List<String> userGroupKeyList = DatabaseHome.findUserGroupsFromLogin( user.getLogin( ), plugin );
285
286 for ( String userGroupKey : userGroupKeyList )
287 {
288 List<String> groupRoleKeyList = GroupRoleHome.findGroupRoles( userGroupKey, plugin );
289
290 for ( String groupRoleKey : groupRoleKeyList )
291 {
292 bHasRole = true;
293
294 Role role = RoleHome.findByPrimaryKey( groupRoleKey );
295
296 if ( AdminWorkgroupService.isAuthorized( role, (User) adminUser ) )
297 {
298 return true;
299 }
300 }
301 }
302
303 return !bHasRole;
304 }
305
306
307
308
309
310
311
312
313
314
315 public List<DatabaseUser> getAuthorizedUsers( AdminUser adminUser, Plugin plugin )
316 {
317 Collection<DatabaseUser> userList = DatabaseUserHome.findDatabaseUsersList( plugin );
318 List<DatabaseUser> authorizedUserList = new ArrayList<>( );
319
320 for ( DatabaseUser user : userList )
321 {
322 if ( isAuthorized( user, adminUser, plugin ) )
323 {
324 authorizedUserList.add( user );
325 }
326 }
327
328 return authorizedUserList;
329 }
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348 public List<DatabaseUser> getFilteredUsersInterface( DatabaseUserFilter duFilter, boolean bIsSearch, List<DatabaseUser> listUsers,
349 HttpServletRequest request, Map<String, Object> model, UrlItem url )
350 {
351 Plugin myLutecePlugin = PluginService.getPlugin( MyLutecePlugin.PLUGIN_NAME );
352 List<DatabaseUser> filteredUsers = getListFilteredUsers( request, duFilter, listUsers );
353 MyLuteceUserFieldFilter mlFieldFilter = new MyLuteceUserFieldFilter( );
354 mlFieldFilter.setMyLuteceUserFieldFilter( request, request.getLocale( ) );
355
356 List<IAttribute> listAttributes = AttributeHome.findAll( request.getLocale( ), myLutecePlugin );
357
358 for ( IAttribute attribute : listAttributes )
359 {
360 List<AttributeField> listAttributeFields = AttributeFieldHome.selectAttributeFieldsByIdAttribute( attribute.getIdAttribute( ), myLutecePlugin );
361 attribute.setListAttributeFields( listAttributeFields );
362 }
363
364 String strSortSearchAttribute = StringUtils.EMPTY;
365
366 if ( bIsSearch )
367 {
368 duFilter.setUrlAttributes( url );
369
370 if ( !StringUtils.EMPTY.equals( duFilter.getUrlAttributes( ) ) )
371 {
372 strSortSearchAttribute = AMPERSAND + duFilter.getUrlAttributes( );
373 }
374
375 mlFieldFilter.setUrlAttributes( url );
376
377 if ( !StringUtils.EMPTY.equals( mlFieldFilter.getUrlAttributes( ) ) )
378 {
379 strSortSearchAttribute += ( AMPERSAND + mlFieldFilter.getUrlAttributes( ) );
380 }
381 }
382
383 model.put( MARK_SEARCH_IS_SEARCH, bIsSearch );
384 model.put( MARK_SEARCH_USER_FILTER, duFilter );
385 model.put( MARK_SORT_SEARCH_ATTRIBUTE, strSortSearchAttribute );
386 model.put( MARK_SEARCH_MYLUTECE_USER_FIELD_FILTER, mlFieldFilter );
387 model.put( MARK_ATTRIBUTES_LIST, listAttributes );
388
389 return filteredUsers;
390 }
391
392
393
394
395
396
397
398
399
400
401
402
403 public List<DatabaseUser> getListFilteredUsers( HttpServletRequest request, DatabaseUserFilter duFilter, List<DatabaseUser> listUsers )
404 {
405 Plugin plugin = PluginService.getPlugin( DatabasePlugin.PLUGIN_NAME );
406
407 List<DatabaseUser> listFilteredUsers = DatabaseUserHome.findDatabaseUsersListByFilter( duFilter, plugin );
408 List<DatabaseUser> listAvailableUsers = new ArrayList<>( );
409
410 for ( DatabaseUser filteredUser : listFilteredUsers )
411 {
412 for ( DatabaseUser user : listUsers )
413 {
414 if ( filteredUser.getUserId( ) == user.getUserId( ) )
415 {
416 listAvailableUsers.add( user );
417 }
418 }
419 }
420
421 Plugin myLutecePlugin = PluginService.getPlugin( MyLutecePlugin.PLUGIN_NAME );
422 List<DatabaseUser> filteredUsers = new ArrayList<>( );
423
424 MyLuteceUserFieldFilter mlFieldFilter = new MyLuteceUserFieldFilter( );
425 mlFieldFilter.setMyLuteceUserFieldFilter( request, request.getLocale( ) );
426
427 List<Integer> listFilteredUserIdsByUserFields = MyLuteceUserFieldHome.findUsersByFilter( mlFieldFilter, myLutecePlugin );
428
429 if ( listFilteredUserIdsByUserFields != null )
430 {
431 for ( DatabaseUser filteredUser : listAvailableUsers )
432 {
433 for ( Integer nFilteredUserIdByUserField : listFilteredUserIdsByUserFields )
434 {
435 if ( filteredUser.getUserId( ) == nFilteredUserIdByUserField )
436 {
437 filteredUsers.add( filteredUser );
438 }
439 }
440 }
441 }
442 else
443 {
444 filteredUsers = listAvailableUsers;
445 }
446
447 return filteredUsers;
448 }
449
450
451
452
453
454
455
456
457
458
459
460
461 public DatabaseUser./../../../../../fr/paris/lutece/plugins/mylutece/modules/database/authentication/business/DatabaseUser.html#DatabaseUser">DatabaseUser doCreateUser( DatabaseUser user, String strPassword, Plugin plugin )
462 {
463 user.setPasswordMaxValidDate( SecurityUtils.getPasswordMaxValidDate( _userParamService, plugin ) );
464 user.setAccountMaxValidDate( SecurityUtils.getAccountMaxValidDate( _userParamService, plugin ) );
465
466 return DatabaseUserHome.create( user, _passwordFactory.getPasswordFromCleartext( strPassword ), plugin );
467 }
468
469
470
471
472
473
474
475
476
477
478
479 public void doModifyPassword( DatabaseUser user, String strPassword, Plugin plugin )
480 {
481
482 if ( StringUtils.isNotBlank( strPassword ) )
483 {
484 DatabaseUser userStored = DatabaseUserHome.findByPrimaryKey( user.getUserId( ), plugin );
485
486 if ( userStored != null )
487 {
488 userStored.setPasswordMaxValidDate( SecurityUtils.getPasswordMaxValidDate( _userParamService, plugin ) );
489 DatabaseUserHome.updatePassword( userStored, _passwordFactory.getPasswordFromCleartext( strPassword ), plugin );
490 }
491 }
492 }
493
494
495
496
497
498
499
500
501
502
503
504 public void doModifyResetPassword( DatabaseUser user, boolean bNewValue, Plugin plugin )
505 {
506 DatabaseUser userStored = DatabaseUserHome.findByPrimaryKey( user.getUserId( ), plugin );
507
508 if ( userStored != null )
509 {
510 DatabaseUserHome.updateResetPassword( userStored, bNewValue, plugin );
511 }
512 }
513
514
515
516
517
518
519
520
521
522 public void doUpdateUser( DatabaseUser user, Plugin plugin )
523 {
524 DatabaseUserHome.update( user, plugin );
525 }
526
527
528
529
530
531
532
533
534
535
536
537
538 public boolean checkPassword( String strUserGuid, String strPassword, Plugin plugin )
539 {
540 return DatabaseUserHome.checkPassword( strUserGuid, strPassword, plugin );
541 }
542
543
544
545
546
547
548
549
550
551
552 public boolean isUserActive( String strUserName, Plugin plugin )
553 {
554 boolean bIsActive = false;
555
556 List<DatabaseUser> listUsers = (List<DatabaseUser>) DatabaseUserHome.findDatabaseUsersListForLogin( strUserName, plugin );
557
558 if ( ( listUsers != null ) && !listUsers.isEmpty( ) )
559 {
560 DatabaseUser user = listUsers.get( 0 );
561 bIsActive = user.isActive( );
562 }
563
564 return bIsActive;
565 }
566
567
568
569
570
571
572 public boolean isPluginJcaptchaEnable( )
573 {
574 return PluginService.isPluginEnable( PLUGIN_JCAPTCHA );
575 }
576
577
578
579
580
581
582
583
584
585
586
587 public void changeUserPasswordAndNotify( String strBaseURL, Plugin plugin, Locale locale )
588 {
589
590 Collection<DatabaseUser> listUsers = DatabaseUserHome.findDatabaseUsersList( plugin );
591
592 for ( DatabaseUser user : listUsers )
593 {
594
595 String strPassword = SecurityUtils.makePassword( _userParamService, plugin );
596 doModifyPassword( user, strPassword, plugin );
597
598 if ( StringUtils.isNotBlank( user.getEmail( ) ) )
599 {
600
601 ReferenceItem referenceItem = _userParamService.findByKey( PARAMETER_MAIL_PASSWORD_ENCRYPTION_CHANGED_SENDER, plugin );
602 String strSenderEmail = ( referenceItem == null ) ? StringUtils.EMPTY : referenceItem.getName( );
603 referenceItem = _userParamService.findByKey( PARAMETER_MAIL_PASSWORD_ENCRYPTION_CHANGED_SUBJECT, plugin );
604
605 String strEmailSubject = ( referenceItem == null ) ? StringUtils.EMPTY : referenceItem.getName( );
606
607 Map<String, Object> model = new HashMap<>( );
608 model.put( MARK_NEW_PASSWORD, strPassword );
609 model.put( MARK_LOGIN_URL, strBaseURL + AdminAuthenticationService.getInstance( ).getLoginPageUrl( ) );
610 model.put( MARK_SITE_LINK, MailService.getSiteLink( strBaseURL, true ) );
611
612 String strTemplate = DatabaseTemplateService.getTemplateFromKey( PARAMETER_MAIL_PASSWORD_ENCRYPTION_CHANGED );
613
614 HtmlTemplate template = AppTemplateService.getTemplateFromStringFtl( strTemplate, locale, model );
615
616 MailService.sendMailHtml( user.getEmail( ), strSenderEmail, strSenderEmail, strEmailSubject, template.getHtml( ) );
617 }
618 }
619 }
620
621
622
623
624
625
626
627
628
629
630 public boolean mustUserChangePassword( LuteceUser databaseUser, Plugin plugin )
631 {
632 return DatabaseHome.findResetPasswordFromLogin( databaseUser.getName( ), plugin );
633 }
634
635
636
637
638
639
640
641
642
643
644
645 public void doInsertNewPasswordInHistory( String strPassword, int nUserId, Plugin plugin )
646 {
647 DatabaseUserHome.insertNewPasswordInHistory( _passwordFactory.getPasswordFromCleartext( strPassword ), nUserId, plugin );
648 }
649
650
651
652
653
654
655
656
657
658 @SuppressWarnings( "deprecation" )
659 public void updateUserExpirationDate( int nIdUser, Plugin plugin )
660 {
661
662 int nbMailSend = DatabaseUserHome.getNbAccountLifeTimeNotification( nIdUser, plugin );
663 Timestamp newExpirationDate = SecurityUtils.getAccountMaxValidDate( _userParamService, plugin );
664 DatabaseUserHome.updateUserExpirationDate( nIdUser, newExpirationDate, plugin );
665
666
667 DatabaseAccountLifeTimeServicehentication/service/DatabaseAccountLifeTimeService.html#DatabaseAccountLifeTimeService">DatabaseAccountLifeTimeService accountLifeTimeService = new DatabaseAccountLifeTimeService( );
668 String strUserMail = accountLifeTimeService.getUserMainEmail( nIdUser );
669
670 if ( ( nbMailSend > 0 ) && StringUtils.isNotBlank( strUserMail ) )
671 {
672 String strBody = DatabaseTemplateService.getTemplateFromKey( PARAMETER_ACCOUNT_REACTIVATED_MAIL_BODY );
673
674 ReferenceItem referenceItem = _userParamService.findByKey( PARAMETER_ACCOUNT_REACTIVATED_MAIL_SENDER, plugin );
675 String strSender = ( referenceItem == null ) ? StringUtils.EMPTY : referenceItem.getName( );
676
677 referenceItem = _userParamService.findByKey( PARAMETER_ACCOUNT_REACTIVATED_MAIL_SUBJECT, plugin );
678
679 String strSubject = ( referenceItem == null ) ? StringUtils.EMPTY : referenceItem.getName( );
680
681 Map<String, String> model = new HashMap<>( );
682 accountLifeTimeService.addParametersToModel( model, nIdUser );
683
684 HtmlTemplate template = AppTemplateService.getTemplateFromStringFtl( strBody, Locale.getDefault( ), model );
685 MailService.sendMailHtml( strUserMail, strSender, strSender, strSubject, template.getHtml( ) );
686 }
687 }
688
689
690
691
692
693
694
695
696
697 public void updateUserLastLoginDate( String strLogin, Plugin plugin )
698 {
699 DatabaseUserHome.updateUserLastLoginDate( strLogin, new Date( ), plugin );
700 }
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719 public String getXmlFromUser( DatabaseUser user, boolean bExportRoles, boolean bExportGroups, boolean bExportAttributes, List<IAttribute> listAttributes,
720 Locale locale )
721 {
722 Plugin databasePlugin = PluginService.getPlugin( DatabasePlugin.PLUGIN_NAME );
723 Plugin mylutecePlugin = PluginService.getPlugin( MyLutecePlugin.PLUGIN_NAME );
724 StringBuffer sbXml = new StringBuffer( );
725 DateFormat dateFormat = new SimpleDateFormat( );
726
727 XmlUtil.beginElement( sbXml, CONSTANT_XML_USER );
728 XmlUtil.addElement( sbXml, CONSTANT_XML_ACCESS_CODE, user.getLogin( ) );
729 XmlUtil.addElement( sbXml, CONSTANT_XML_LAST_NAME, user.getLastName( ) );
730 XmlUtil.addElement( sbXml, CONSTANT_XML_FIRST_NAME, user.getFirstName( ) );
731 XmlUtil.addElement( sbXml, CONSTANT_XML_EMAIL, user.getEmail( ) );
732 XmlUtil.addElement( sbXml, CONSTANT_XML_STATUS, Integer.toString( user.getStatus( ) ) );
733
734 String strPasswordMaxValidDate = StringUtils.EMPTY;
735
736 if ( user.getPasswordMaxValidDate( ) != null )
737 {
738 strPasswordMaxValidDate = dateFormat.format( user.getPasswordMaxValidDate( ) );
739 }
740
741 XmlUtil.addElement( sbXml, CONSTANT_XML_PASSWORD_MAX_VALID_DATE, strPasswordMaxValidDate );
742
743 String strAccountMaxValidDate = StringUtils.EMPTY;
744
745 if ( user.getAccountMaxValidDate( ) != null )
746 {
747 strAccountMaxValidDate = dateFormat.format( user.getAccountMaxValidDate( ) );
748 }
749
750 XmlUtil.addElement( sbXml, CONSTANT_XML_ACCOUNT_MAX_VALID_DATE, strAccountMaxValidDate );
751
752 if ( bExportRoles )
753 {
754 List<String> listRoles = DatabaseHome.findUserRolesFromLogin( user.getLogin( ), databasePlugin );
755 XmlUtil.beginElement( sbXml, CONSTANT_XML_ROLES );
756
757 for ( String strRole : listRoles )
758 {
759 XmlUtil.addElement( sbXml, CONSTANT_XML_ROLE, strRole );
760 }
761
762 XmlUtil.endElement( sbXml, CONSTANT_XML_ROLES );
763 }
764
765 if ( bExportGroups )
766 {
767 List<String> listGroups = DatabaseHome.findUserGroupsFromLogin( user.getLogin( ), databasePlugin );
768 XmlUtil.beginElement( sbXml, CONSTANT_XML_GROUPS );
769
770 for ( String strGoup : listGroups )
771 {
772 XmlUtil.addElement( sbXml, CONSTANT_XML_GROUP, strGoup );
773 }
774
775 XmlUtil.endElement( sbXml, CONSTANT_XML_GROUPS );
776 }
777
778 if ( bExportAttributes )
779 {
780 XmlUtil.beginElement( sbXml, CONSTANT_XML_ATTRIBUTES );
781
782 for ( IAttribute attribute : listAttributes )
783 {
784 List<MyLuteceUserField> listUserFields = MyLuteceUserFieldHome.selectUserFieldsByIdUserIdAttribute( user.getUserId( ),
785 attribute.getIdAttribute( ), mylutecePlugin );
786
787 for ( MyLuteceUserField userField : listUserFields )
788 {
789 XmlUtil.beginElement( sbXml, CONSTANT_XML_ATTRIBUTE );
790 XmlUtil.addElement( sbXml, CONSTANT_XML_ATTRIBUTE_ID, Integer.toString( attribute.getIdAttribute( ) ) );
791 XmlUtil.addElement( sbXml, CONSTANT_XML_ATTRIBUTE_FIELD_ID, userField.getAttributeField( ).getIdField( ) );
792 XmlUtil.addElement( sbXml, CONSTANT_XML_ATTRIBUTE_VALUE, userField.getValue( ) );
793 XmlUtil.endElement( sbXml, CONSTANT_XML_ATTRIBUTE );
794 }
795 }
796
797 XmlUtil.endElement( sbXml, CONSTANT_XML_ATTRIBUTES );
798 }
799
800 XmlUtil.endElement( sbXml, CONSTANT_XML_USER );
801
802 return sbXml.toString( );
803 }
804
805
806
807
808
809
810
811
812
813
814
815 public void doAutoLoginDatabaseUser( HttpServletRequest request, DatabaseUser databaseUser, Plugin plugin )
816 {
817 if ( _baseAuthentication != null )
818 {
819 BaseUser user = DatabaseHome.findLuteceUserByLogin( databaseUser.getLogin( ), plugin, _baseAuthentication );
820 SecurityService.getInstance( ).registerUser( request, user );
821 }
822 }
823 }