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.web;
35
36 import fr.paris.lutece.api.user.User;
37 import fr.paris.lutece.plugins.mylutece.business.attribute.AttributeField;
38 import fr.paris.lutece.plugins.mylutece.business.attribute.AttributeFieldHome;
39 import fr.paris.lutece.plugins.mylutece.business.attribute.AttributeHome;
40 import fr.paris.lutece.plugins.mylutece.business.attribute.IAttribute;
41 import fr.paris.lutece.plugins.mylutece.business.attribute.MyLuteceUserField;
42 import fr.paris.lutece.plugins.mylutece.business.attribute.MyLuteceUserFieldHome;
43 import fr.paris.lutece.plugins.mylutece.modules.database.authentication.business.DatabaseHome;
44 import fr.paris.lutece.plugins.mylutece.modules.database.authentication.business.DatabaseUser;
45 import fr.paris.lutece.plugins.mylutece.modules.database.authentication.business.DatabaseUserFactory;
46 import fr.paris.lutece.plugins.mylutece.modules.database.authentication.business.DatabaseUserFilter;
47 import fr.paris.lutece.plugins.mylutece.modules.database.authentication.business.DatabaseUserHome;
48 import fr.paris.lutece.plugins.mylutece.modules.database.authentication.business.Group;
49 import fr.paris.lutece.plugins.mylutece.modules.database.authentication.business.GroupHome;
50 import fr.paris.lutece.plugins.mylutece.modules.database.authentication.business.GroupRoleHome;
51 import fr.paris.lutece.plugins.mylutece.modules.database.authentication.service.DatabaseAnonymizationService;
52 import fr.paris.lutece.plugins.mylutece.modules.database.authentication.service.DatabasePlugin;
53 import fr.paris.lutece.plugins.mylutece.modules.database.authentication.service.DatabaseResourceIdService;
54 import fr.paris.lutece.plugins.mylutece.modules.database.authentication.service.DatabaseService;
55 import fr.paris.lutece.plugins.mylutece.modules.database.authentication.service.ImportDatabaseUserService;
56 import fr.paris.lutece.plugins.mylutece.modules.database.authentication.service.key.DatabaseUserKeyService;
57 import fr.paris.lutece.plugins.mylutece.modules.database.authentication.service.parameter.DatabaseUserParameterService;
58 import fr.paris.lutece.plugins.mylutece.service.MyLutecePlugin;
59 import fr.paris.lutece.plugins.mylutece.service.RoleResourceIdService;
60 import fr.paris.lutece.plugins.mylutece.service.attribute.MyLuteceUserFieldService;
61 import fr.paris.lutece.plugins.mylutece.util.SecurityUtils;
62 import fr.paris.lutece.portal.business.rbac.RBAC;
63 import fr.paris.lutece.portal.business.role.Role;
64 import fr.paris.lutece.portal.business.role.RoleHome;
65 import fr.paris.lutece.portal.business.user.AdminUser;
66 import fr.paris.lutece.portal.business.xsl.XslExport;
67 import fr.paris.lutece.portal.business.xsl.XslExportHome;
68 import fr.paris.lutece.portal.service.admin.AccessDeniedException;
69 import fr.paris.lutece.portal.service.admin.AdminUserService;
70 import fr.paris.lutece.portal.service.csv.CSVMessageDescriptor;
71 import fr.paris.lutece.portal.service.fileupload.FileUploadService;
72 import fr.paris.lutece.portal.service.i18n.I18nService;
73 import fr.paris.lutece.portal.service.message.AdminMessage;
74 import fr.paris.lutece.portal.service.message.AdminMessageService;
75 import fr.paris.lutece.portal.service.plugin.Plugin;
76 import fr.paris.lutece.portal.service.plugin.PluginService;
77 import fr.paris.lutece.portal.service.rbac.RBACService;
78 import fr.paris.lutece.portal.service.template.AppTemplateService;
79 import fr.paris.lutece.portal.service.template.DatabaseTemplateService;
80 import fr.paris.lutece.portal.service.util.AppPathService;
81 import fr.paris.lutece.portal.service.util.AppPropertiesService;
82 import fr.paris.lutece.portal.service.workgroup.AdminWorkgroupService;
83 import fr.paris.lutece.portal.service.xsl.XslExportService;
84 import fr.paris.lutece.portal.web.admin.PluginAdminPageJspBean;
85 import fr.paris.lutece.portal.web.constants.Messages;
86 import fr.paris.lutece.portal.web.constants.Parameters;
87 import fr.paris.lutece.portal.web.pluginaction.DefaultPluginActionResult;
88 import fr.paris.lutece.portal.web.upload.MultipartHttpServletRequest;
89 import fr.paris.lutece.portal.web.util.LocalizedPaginator;
90 import fr.paris.lutece.util.ReferenceItem;
91 import fr.paris.lutece.util.ReferenceList;
92 import fr.paris.lutece.util.filesystem.FileSystemUtil;
93 import fr.paris.lutece.util.html.AbstractPaginator;
94 import fr.paris.lutece.util.html.HtmlTemplate;
95 import fr.paris.lutece.util.html.ItemNavigator;
96 import fr.paris.lutece.util.sort.AttributeComparator;
97 import fr.paris.lutece.util.string.StringUtil;
98 import fr.paris.lutece.util.url.UrlItem;
99 import fr.paris.lutece.util.xml.XmlUtil;
100
101 import org.apache.commons.collections.CollectionUtils;
102 import org.apache.commons.fileupload.FileItem;
103 import org.apache.commons.lang3.StringUtils;
104
105 import java.io.IOException;
106 import java.io.PrintWriter;
107
108 import java.util.ArrayList;
109 import java.util.Collection;
110 import java.util.Collections;
111 import java.util.HashMap;
112 import java.util.List;
113 import java.util.Map;
114
115 import javax.servlet.http.HttpServletRequest;
116 import javax.servlet.http.HttpServletResponse;
117
118
119
120
121 public class DatabaseJspBean extends PluginAdminPageJspBean
122 {
123
124
125
126
127 public static final String RIGHT_MANAGE_DATABASE_USERS = "DATABASE_MANAGEMENT_USERS";
128
129
130
131
132 private static final long serialVersionUID = -8867524349892775919L;
133 private static final String ATTRIBUTE_IMPORT_USERS_LIST_MESSAGES = "importUsersListMessages";
134
135
136 private static final String MANAGE_USERS = "ManageUsers.jsp";
137 private static final String REGEX_DATABASE_USER_ID = "^[\\d]+$";
138 private static final String QUESTION_MARK = "?";
139 private static final String AMPERSAND = "&";
140 private static final String EQUAL = "=";
141
142
143 private static final String JSP_DO_REMOVE_USER = "jsp/admin/plugins/mylutece/modules/database/DoRemoveUser.jsp";
144 private static final String JSP_MANAGE_ADVANCED_PARAMETERS = "ManageAdvancedParameters.jsp";
145 private static final String JSP_URL_MODIFY_USER = "jsp/admin/plugins/mylutece/modules/database/ModifyUser.jsp";
146 private static final String JSP_URL_MANAGE_ROLES_USER = "jsp/admin/plugins/mylutece/modules/database/ManageRolesUser.jsp";
147 private static final String JSP_URL_MANAGE_GROUPS_USER = "jsp/admin/plugins/mylutece/modules/database/ManageGroupsUser.jsp";
148 private static final String JSP_MODIFY_USER = "ModifyUser.jsp";
149 private static final String JSP_MANAGE_ROLES_USER = "ManageRolesUser.jsp";
150 private static final String JSP_MANAGE_GROUPS_USER = "ManageGroupsUser.jsp";
151 private static final String JSP_MANAGE_USERS = "ManageUsers.jsp";
152 private static final String JSP_URL_USE_ADVANCED_SECUR_PARAM = "jsp/admin/plugins/mylutece/modules/database/DoUseAdvancedSecurityParameters.jsp";
153 private static final String JSP_URL_REMOVE_ADVANCED_SECUR_PARAM = "jsp/admin/plugins/mylutece/modules/database/DoRemoveAdvancedSecurityParameters.jsp";
154 private static final String JSP_URL_ANONYMIZE_USER = "jsp/admin/plugins/mylutece/modules/database/DoAnonymizeUser.jsp";
155
156
157 private static final String PROPERTY_PAGE_TITLE_MANAGE_USERS = "module.mylutece.database.manage_users.pageTitle";
158 private static final String PROPERTY_PAGE_TITLE_CREATE_USER = "module.mylutece.database.create_user.pageTitle";
159 private static final String PROPERTY_PAGE_TITLE_MODIFY_USER = "module.mylutece.database.modify_user.pageTitle";
160 private static final String PROPERTY_PAGE_TITLE_MANAGE_ROLES_USER = "module.mylutece.database.manage_roles_user.pageTitle";
161 private static final String PROPERTY_PAGE_TITLE_MANAGE_GROUPS_USER = "module.mylutece.database.manage_groups_user.pageTitle";
162 private static final String PROPERTY_MESSAGE_CONFIRM_USE_ASP = "module.mylutece.database.manage_advanced_parameters.message.confirmUseAdvancedSecurityParameters";
163 private static final String PROPERTY_MESSAGE_CONFIRM_REMOVE_ASP = "mylutece.manage_advanced_parameters.message.confirmRemoveAdvancedSecurityParameters";
164 private static final String PROPERTY_MESSAGE_TITLE_CHANGE_ANONYMIZE_USER = "mylutece.anonymize_user.titleAnonymizeUser";
165 private static final String PROPERTY_MESSAGE_NO_USER_SELECTED = "mylutece.message.noUserSelected";
166 private static final String PROPERTY_MESSAGE_CONFIRM_ANONYMIZE_USER = "mylutece.message.confirmAnonymizeUser";
167 private static final String PROPERTY_FIRST_EMAIL = "mylutece.accountLifeTime.labelFirstEmail";
168 private static final String PROPERTY_OTHER_EMAIL = "mylutece.accountLifeTime.labelOtherEmail";
169 private static final String PROPERTY_ACCOUNT_DEACTIVATES_EMAIL = "mylutece.accountLifeTime.labelAccountDeactivatedEmail";
170 private static final String PROPERTY_ACCOUNT_UPDATED_EMAIL = "mylutece.accountLifeTime.labelAccountUpdatedEmail";
171 private static final String PROPERTY_UNBLOCK_USER = "mylutece.ip.unblockUser";
172 private static final String PROPERTY_NOTIFY_PASSWORD_EXPIRED = "mylutece.accountLifeTime.labelPasswordExpired";
173 private static final String PROPERTY_MAIL_LOST_PASSWORD = "mylutece.accountLifeTime.labelLostPasswordMail";
174 private static final String PROPERTY_IMPORT_USERS_FROM_FILE_PAGETITLE = "module.mylutece.database.import_users_from_file.pageTitle";
175 private static final String PROPERTY_EXPORT_USERS_PAGETITLE = "module.mylutece.database.export_users.pageTitle";
176 private static final String PROPERTY_EXTERNAL_APPLICATION_EXISTS = "mylutece-database.externalApplicationExists";
177
178
179 private static final String MESSAGE_CONFIRM_REMOVE_USER = "module.mylutece.database.message.confirmRemoveUser";
180 private static final String MESSAGE_USER_EXIST = "module.mylutece.database.message.user_exist";
181 private static final String MESSAGE_DIFFERENT_PASSWORD = "module.mylutece.database.message.different_password";
182 private static final String MESSAGE_EMAIL_INVALID = "module.mylutece.database.message.email_invalid";
183 private static final String MESSAGE_ERROR_MODIFY_USER = "module.mylutece.database.message.modify.user";
184 private static final String MESSAGE_ERROR_REMOVE_USER = "module.mylutece.database.message.remove.user";
185 private static final String MESSAGE_ERROR_MANAGE_ROLES = "module.mylutece.database.message.manage.roles";
186 private static final String MESSAGE_ERROR_MANAGE_GROUPS = "module.mylutece.database.message.manage.groups";
187 private static final String MESSAGE_MANDATORY_FIELD = "portal.util.message.mandatoryField";
188 private static final String MESSAGE_ERROR_CSV_FILE_IMPORT = "module.mylutece.database.import_users_from_file.error_csv_file_import";
189
190
191 private static final String PARAMETER_PLUGIN_NAME = "plugin_name";
192 private static final String PARAMETER_MYLUTECE_DATABASE_USER_ID = "mylutece_database_user_id";
193 private static final String PARAMETER_MYLUTECE_DATABASE_ROLE_ID = "mylutece_database_role_id";
194 private static final String PARAMETER_MYLUTECE_DATABASE_GROUP_KEY = "mylutece_database_group_key";
195 private static final String PARAMETER_LOGIN = "login";
196 private static final String PARAMETER_FIRST_PASSWORD = "first_password";
197 private static final String PARAMETER_SECOND_PASSWORD = "second_password";
198 private static final String PARAMETER_LAST_NAME = "last_name";
199 private static final String PARAMETER_FIRST_NAME = "first_name";
200 private static final String PARAMETER_EMAIL = "email";
201 private static final String PARAMETER_CANCEL = "cancel";
202 private static final String PARAMETER_MODIFY_USER = "modify_user";
203 private static final String PARAMETER_ASSIGN_ROLE = "assign_role";
204 private static final String PARAMETER_ASSIGN_GROUP = "assign_group";
205 private static final String PARAMETER_ACCOUNT_CREATION_VALIDATION_EMAIL = "account_creation_validation_email";
206 private static final String PARAMETER_AUTO_LOGIN_AFTER_VALIDATION_EMAIL = "auto_login_after_validation_email";
207 private static final String PARAMETER_ENABLE_JCAPTCHA = "enable_jcaptcha";
208 private static final String PARAMETER_NAME_GIVEN = "name_given";
209 private static final String PARAMETER_NAME_FAMILY = "name_family";
210 private static final String PARAMETER_ATTRIBUTE = "attribute_";
211 private static final String PARAMETER_USER_ID = "user_id";
212 private static final String PARAMETER_EMAIL_TYPE = "email_type";
213 private static final String PARAMETER_FIRST_ALERT_MAIL_SENDER = "first_alert_mail_sender";
214 private static final String PARAMETER_OTHER_ALERT_MAIL_SENDER = "other_alert_mail_sender";
215 private static final String PARAMETER_EXPIRED_ALERT_MAIL_SENDER = "expired_alert_mail_sender";
216 private static final String PARAMETER_REACTIVATED_ALERT_MAIL_SENDER = "account_reactivated_mail_sender";
217 private static final String PARAMETER_FIRST_ALERT_MAIL_SUBJECT = "first_alert_mail_subject";
218 private static final String PARAMETER_OTHER_ALERT_MAIL_SUBJECT = "other_alert_mail_subject";
219 private static final String PARAMETER_EXPIRED_ALERT_MAIL_SUBJECT = "expired_alert_mail_subject";
220 private static final String PARAMETER_REACTIVATED_ALERT_MAIL_SUBJECT = "account_reactivated_mail_subject";
221 private static final String PARAMETER_FIRST_ALERT_MAIL = "mylutece_database_first_alert_mail";
222 private static final String PARAMETER_OTHER_ALERT_MAIL = "mylutece_database_other_alert_mail";
223 private static final String PARAMETER_EXPIRATION_MAIL = "mylutece_database_expiration_mail";
224 private static final String PARAMETER_ACCOUNT_REACTIVATED = "mylutece_database_account_reactivated_mail";
225 private static final String PARAMETER_BANNED_DOMAIN_NAMES = "banned_domain_names";
226 private static final String PARAMETER_UNBLOCK_USER_MAIL_SENDER = "unblock_user_mail_sender";
227 private static final String PARAMETER_UNBLOCK_USER_MAIL_SUBJECT = "unblock_user_mail_subject";
228 private static final String PARAMETER_UNBLOCK_USER = "mylutece_database_unblock_user";
229 private static final String PARAMETER_PASSWORD_EXPIRED_MAIL_SENDER = "password_expired_mail_sender";
230 private static final String PARAMETER_PASSWORD_EXPIRED_MAIL_SUBJECT = "password_expired_mail_subject";
231 private static final String PARAMETER_NOTIFY_PASSWORD_EXPIRED = "mylutece_database_password_expired";
232 private static final String PARAMETER_MAIL_LOST_PASSWORD = "mylutece_database_mailLostPassword";
233 private static final String PARAMETER_MAIL_LOST_PASSWORD_SENDER = "mail_lost_password_sender";
234 private static final String PARAMETER_MAIL_LOST_PASSWORD_SUBJECT = "mail_lost_password_subject";
235 private static final String PARAMETER_IMPORT_USERS_FILE = "import_file";
236 private static final String PARAMETER_SKIP_FIRST_LINE = "ignore_first_line";
237 private static final String PARAMETER_UPDATE_USERS = "update_existing_users";
238 private static final String PARAMETER_XSL_EXPORT_ID = "xsl_export_id";
239 private static final String PARAMETER_EXPORT_ATTRIBUTES = "export_attributes";
240 private static final String PARAMETER_EXPORT_ROLES = "export_roles";
241 private static final String PARAMETER_EXPORT_WORKGROUPS = "export_workgroups";
242
243
244 private static final String MARK_USERS_LIST = "user_list";
245 private static final String MARK_USER = "user";
246 private static final String MARK_PLUGIN_NAME = "plugin_name";
247 private static final String MARK_ROLES_LIST = "role_list";
248 private static final String MARK_ROLES_LIST_FOR_USER = "user_role_list";
249 private static final String MARK_GROUPS_LIST = "group_list";
250 private static final String MARK_GROUPS_LIST_FOR_USER = "user_group_list";
251 private static final String MARK_EXTERNAL_APPLICATION_EXIST = "external_application_exist";
252 private static final String MARK_PAGINATOR = "paginator";
253 private static final String MARK_NB_ITEMS_PER_PAGE = "nb_items_per_page";
254 private static final String MARK_PERMISSION_ADVANCED_PARAMETER = "permission_advanced_parameter";
255 private static final String MARK_ITEM_NAVIGATOR = "item_navigator";
256 private static final String MARK_ATTRIBUTES_LIST = "attributes_list";
257 private static final String MARK_LOCALE = "locale";
258 private static final String MARK_MAP_LIST_ATTRIBUTE_DEFAULT_VALUES = "map_list_attribute_default_values";
259 private static final String MARK_SHOW_INPUT_LOGIN = "show_input_login";
260 private static final String MARK_EMAIL_SENDER = "email_sender";
261 private static final String MARK_EMAIL_SUBJECT = "email_subject";
262 private static final String MARK_EMAIL_BODY = "email_body";
263 private static final String MARK_EMAIL_LABEL = "emailLabel";
264 private static final String MARK_WEBAPP_URL = "webapp_url";
265 private static final String MARK_LIST_MESSAGES = "messages";
266 private static final String MARK_CSV_SEPARATOR = "csv_separator";
267 private static final String MARK_CSV_ESCAPE = "csv_escape";
268 private static final String MARK_ATTRIBUTES_SEPARATOR = "attributes_separator";
269 private static final String MARK_LIST_XSL_EXPORT = "refListXsl";
270
271
272 private static final String TEMPLATE_CREATE_USER = "admin/plugins/mylutece/modules/database/create_user.html";
273 private static final String TEMPLATE_MODIFY_USER = "admin/plugins/mylutece/modules/database/modify_user.html";
274 private static final String TEMPLATE_MANAGE_USERS = "admin/plugins/mylutece/modules/database/manage_users.html";
275 private static final String TEMPLATE_MANAGE_ROLES_USER = "admin/plugins/mylutece/modules/database/manage_roles_user.html";
276 private static final String TEMPLATE_MANAGE_GROUPS_USER = "admin/plugins/mylutece/modules/database/manage_groups_user.html";
277 private static final String TEMPLATE_MANAGE_ADVANCED_PARAMETERS = "admin/plugins/mylutece/modules/database/manage_advanced_parameters.html";
278 private static final String TEMPLATE_FIELD_ANONYMIZE_USER = "admin/plugins/mylutece/modules/database/field_anonymize_user.html";
279 private static final String TEMPLATE_ACCOUNT_LIFE_TIME_EMAIL = "admin/plugins/mylutece/modules/database/account_life_time_email.html";
280 private static final String TEMPLATE_IMPORT_USERS_FROM_FILE = "admin/plugins/mylutece/modules/database/import_users_from_file.html";
281 private static final String TEMPLATE_EXPORT_USERS_FROM_FILE = "admin/plugins/mylutece/modules/database/export_users.html";
282 private static final String FIELD_IMPORT_USERS_FILE = "module.mylutece.database.import_users_from_file.labelImportFile";
283 private static final String FIELD_XSL_EXPORT = "module.mylutece.database.export_users.labelXslt";
284
285
286 private static final String PROPERTY_USERS_PER_PAGE = "paginator.users.itemsPerPage";
287
288
289 private static final String CONSTANT_EMAIL_TYPE_FIRST = "first";
290 private static final String CONSTANT_EMAIL_TYPE_OTHER = "other";
291 private static final String CONSTANT_EMAIL_TYPE_EXPIRED = "expired";
292 private static final String CONSTANT_EMAIL_TYPE_REACTIVATED = "reactivated";
293 private static final String CONSTANT_EMAIL_TYPE_IP_BLOCKED = "ip_blocked";
294 private static final String CONSTANT_EMAIL_PASSWORD_EXPIRED = "password_expired";
295 private static final String CONSTANT_EMAIL_TYPE_LOST_PASSWORD = "lost_password";
296 private static final String CONSTANT_EXTENSION_CSV_FILE = ".csv";
297 private static final String CONSTANT_EXTENSION_XML_FILE = ".xml";
298 private static final String CONSTANT_MIME_TYPE_CSV = "application/csv";
299 private static final String CONSTANT_MIME_TYPE_XML = "application/xml";
300 private static final String CONSTANT_MIME_TYPE_TEXT_CSV = "text/csv";
301 private static final String CONSTANT_MIME_TYPE_OCTETSTREAM = "application/octet-stream";
302 private static final String CONSTANT_EXPORT_USERS_FILE_NAME = "users";
303 private static final String CONSTANT_POINT = ".";
304 private static final String CONSTANT_QUOTE = "\"";
305 private static final String CONSTANT_ATTACHEMENT_FILE_NAME = "attachement; filename=\"";
306 private static final String CONSTANT_ATTACHEMENT_DISPOSITION = "Content-Disposition";
307 private static final String CONSTANT_XML_USERS = "users";
308
309
310 private static Plugin _plugin;
311 private int _nItemsPerPage;
312 private String _strCurrentPageIndex;
313 private Map<String, ItemNavigator> _itemNavigators = new HashMap<>( );
314 private DatabaseUserFilter _duFilter;
315 private String _strSortedAttributeName;
316 private boolean _bIsAscSort = true;
317 private DatabaseUserParameterService _userParamService = DatabaseUserParameterService.getService( );
318 private DatabaseService _databaseService = DatabaseService.getService( );
319 private DatabaseUserFactory _userFactory = DatabaseUserFactory.getFactory( );
320 private DatabaseAnonymizationService _anonymizationService = DatabaseAnonymizationService.getService( );
321 private ImportDatabaseUserServicethentication/service/ImportDatabaseUserService.html#ImportDatabaseUserService">ImportDatabaseUserService _importDatabaseUserService = new ImportDatabaseUserService( );
322
323
324
325
326
327
328
329
330 public String getManageUsers( HttpServletRequest request )
331 {
332 if ( _plugin == null )
333 {
334 _plugin = PluginService.getPlugin( DatabasePlugin.PLUGIN_NAME );
335 }
336
337 setPageTitleProperty( PROPERTY_PAGE_TITLE_MANAGE_USERS );
338
339
340 reinitItemNavigators( );
341
342 Map<String, Object> model = new HashMap<>( );
343 Boolean applicationsExist = AppPropertiesService.getPropertyBoolean( PROPERTY_EXTERNAL_APPLICATION_EXISTS, false );
344
345 String strURL = getHomeUrl( request );
346 UrlItem url = new UrlItem( strURL );
347
348 int defaultItemsPerPage = AppPropertiesService.getPropertyInt( PROPERTY_USERS_PER_PAGE, 50 );
349 _strCurrentPageIndex = AbstractPaginator.getPageIndex( request, AbstractPaginator.PARAMETER_PAGE_INDEX, _strCurrentPageIndex );
350 _nItemsPerPage = AbstractPaginator.getItemsPerPage( request, AbstractPaginator.PARAMETER_ITEMS_PER_PAGE, _nItemsPerPage, defaultItemsPerPage );
351
352
353 List<DatabaseUser> listUsers = _databaseService.getAuthorizedUsers( getUser( ), _plugin );
354
355 _duFilter = new DatabaseUserFilter( );
356
357 boolean bIsSearch = _duFilter.setDatabaseUserFilter( request );
358 List<DatabaseUser> listFilteredUsers = _databaseService.getFilteredUsersInterface( _duFilter, bIsSearch, listUsers, request, model, url );
359
360
361 _strSortedAttributeName = request.getParameter( Parameters.SORTED_ATTRIBUTE_NAME );
362
363 String strAscSort = null;
364
365 if ( _strSortedAttributeName != null )
366 {
367 strAscSort = request.getParameter( Parameters.SORTED_ASC );
368
369 _bIsAscSort = Boolean.parseBoolean( strAscSort );
370
371 Collections.sort( listFilteredUsers, new AttributeComparator( _strSortedAttributeName, _bIsAscSort ) );
372 }
373
374 if ( _strSortedAttributeName != null )
375 {
376 url.addParameter( Parameters.SORTED_ATTRIBUTE_NAME, _strSortedAttributeName );
377 }
378
379 if ( strAscSort != null )
380 {
381 url.addParameter( Parameters.SORTED_ASC, strAscSort );
382 }
383
384 LocalizedPaginator<DatabaseUser> paginator = new LocalizedPaginator<>( listFilteredUsers, _nItemsPerPage, url.getUrl( ),
385 AbstractPaginator.PARAMETER_PAGE_INDEX, _strCurrentPageIndex, getLocale( ) );
386
387 boolean bPermissionAdvancedParameter = RBACService.isAuthorized( DatabaseResourceIdService.RESOURCE_TYPE, RBAC.WILDCARD_RESOURCES_ID,
388 DatabaseResourceIdService.PERMISSION_MANAGE, (User) getUser( ) );
389
390 model.put( MARK_NB_ITEMS_PER_PAGE, Integer.toString( _nItemsPerPage ) );
391 model.put( MARK_PAGINATOR, paginator );
392 model.put( MARK_USERS_LIST, paginator.getPageItems( ) );
393 model.put( MARK_PLUGIN_NAME, _plugin.getName( ) );
394 model.put( MARK_EXTERNAL_APPLICATION_EXIST, applicationsExist );
395 model.put( MARK_PERMISSION_ADVANCED_PARAMETER, bPermissionAdvancedParameter );
396
397 HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_MANAGE_USERS, getLocale( ), model );
398
399 return getAdminPage( template.getHtml( ) );
400 }
401
402
403
404
405
406
407
408
409 public String getCreateUser( HttpServletRequest request )
410 {
411 setPageTitleProperty( PROPERTY_PAGE_TITLE_CREATE_USER );
412
413 Plugin myLutecePlugin = PluginService.getPlugin( MyLutecePlugin.PLUGIN_NAME );
414
415
416 List<IAttribute> listAttributes = AttributeHome.findAll( getLocale( ), myLutecePlugin );
417
418 for ( IAttribute attribute : listAttributes )
419 {
420 List<AttributeField> listAttributeFields = AttributeFieldHome.selectAttributeFieldsByIdAttribute( attribute.getIdAttribute( ), myLutecePlugin );
421 attribute.setListAttributeFields( listAttributeFields );
422 }
423
424 Map<String, Object> model = new HashMap<>( );
425
426 model.put( MARK_PLUGIN_NAME, _plugin.getName( ) );
427 model.put( MARK_ATTRIBUTES_LIST, listAttributes );
428 model.put( MARK_LOCALE, getLocale( ) );
429 model.put( MARK_SHOW_INPUT_LOGIN, !_userFactory.isEmailUsedAsLogin( ) );
430
431 HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_CREATE_USER, getLocale( ), model );
432
433 return getAdminPage( template.getHtml( ) );
434 }
435
436
437
438
439
440
441
442
443 public String doCreateUser( HttpServletRequest request )
444 {
445 if ( request.getParameter( PARAMETER_CANCEL ) != null )
446 {
447 return MANAGE_USERS + "?" + PARAMETER_PLUGIN_NAME + "=" + _plugin.getName( );
448 }
449
450 initPluginFromRequest( request );
451
452 String strError = StringUtils.EMPTY;
453 String strLogin;
454 String strFirstPassword = request.getParameter( PARAMETER_FIRST_PASSWORD );
455 String strSecondPassword = request.getParameter( PARAMETER_SECOND_PASSWORD );
456 String strLastName = request.getParameter( PARAMETER_LAST_NAME );
457 String strFirstName = request.getParameter( PARAMETER_FIRST_NAME );
458 String strEmail = request.getParameter( PARAMETER_EMAIL );
459
460 if ( _userFactory.isEmailUsedAsLogin( ) )
461 {
462 strLogin = strEmail;
463 }
464 else
465 {
466 strLogin = request.getParameter( PARAMETER_LOGIN );
467 }
468
469 if ( StringUtils.isBlank( strLogin ) || StringUtils.isBlank( strFirstPassword ) || StringUtils.isBlank( strLastName )
470 || StringUtils.isBlank( strFirstName ) || StringUtils.isBlank( strEmail ) )
471 {
472 strError = AdminMessageService.getMessageUrl( request, Messages.MANDATORY_FIELDS, AdminMessage.TYPE_STOP );
473 }
474
475 if ( StringUtils.isBlank( strError )
476 && !StringUtil.checkEmailAndDomainName( strEmail, SecurityUtils.getBannedDomainNames( _userParamService, _plugin ) ) )
477 {
478 strError = AdminMessageService.getMessageUrl( request, MESSAGE_EMAIL_INVALID, AdminMessage.TYPE_STOP );
479 }
480
481 if ( StringUtils.isBlank( strError ) && CollectionUtils.isNotEmpty( DatabaseUserHome.findDatabaseUsersListForLogin( strLogin, _plugin ) ) )
482 {
483 strError = AdminMessageService.getMessageUrl( request, MESSAGE_USER_EXIST, AdminMessage.TYPE_STOP );
484 }
485
486 if ( StringUtils.isBlank( strError ) && !strFirstPassword.equals( strSecondPassword ) )
487 {
488 strError = AdminMessageService.getMessageUrl( request, MESSAGE_DIFFERENT_PASSWORD, AdminMessage.TYPE_STOP );
489 }
490
491 if ( StringUtils.isBlank( strError ) )
492 {
493 strError = SecurityUtils.checkPasswordForBackOffice( _userParamService, _plugin, strFirstPassword, request );
494 }
495
496 if ( StringUtils.isBlank( strError ) )
497 {
498 strError = MyLuteceUserFieldService.checkUserFields( request, getLocale( ) );
499 }
500
501 if ( StringUtils.isNotBlank( strError ) )
502 {
503 return strError;
504 }
505
506 DatabaseUser databaseUser = _userFactory.newDatabaseUser( );
507 databaseUser.setEmail( strEmail );
508 databaseUser.setFirstName( strFirstName );
509 databaseUser.setLastName( strLastName );
510 databaseUser.setLogin( strLogin );
511 databaseUser.setStatus( DatabaseUser.STATUS_ACTIVATED );
512
513 _databaseService.doCreateUser( databaseUser, strFirstPassword, _plugin );
514 _databaseService.doModifyResetPassword( databaseUser, true, _plugin );
515 MyLuteceUserFieldService.doCreateUserFields( databaseUser.getUserId( ), request, getLocale( ) );
516
517 return MANAGE_USERS + "?" + PARAMETER_PLUGIN_NAME + "=" + _plugin.getName( );
518 }
519
520
521
522
523
524
525
526
527 public String getModifyUser( HttpServletRequest request )
528 {
529 setPageTitleProperty( PROPERTY_PAGE_TITLE_MODIFY_USER );
530
531 DatabaseUser selectedUser = getDatabaseUserFromRequest( request );
532
533 if ( selectedUser == null )
534 {
535 return getCreateUser( request );
536 }
537
538
539 setItemNavigator( PARAMETER_MODIFY_USER, selectedUser.getUserId( ), AppPathService.getBaseUrl( request ) + JSP_URL_MODIFY_USER, request );
540
541 Boolean applicationsExist = Boolean.FALSE;
542
543
544 Plugin myLutecePlugin = PluginService.getPlugin( MyLutecePlugin.PLUGIN_NAME );
545 List<IAttribute> listAttributes = AttributeHome.findAll( getLocale( ), myLutecePlugin );
546 Map<String, List<MyLuteceUserField>> map = new HashMap<>( );
547
548 for ( IAttribute attribute : listAttributes )
549 {
550 List<AttributeField> listAttributeFields = AttributeFieldHome.selectAttributeFieldsByIdAttribute( attribute.getIdAttribute( ), myLutecePlugin );
551 attribute.setListAttributeFields( listAttributeFields );
552
553 List<MyLuteceUserField> listUserFields = MyLuteceUserFieldHome.selectUserFieldsByIdUserIdAttribute( selectedUser.getUserId( ),
554 attribute.getIdAttribute( ), myLutecePlugin );
555
556 if ( CollectionUtils.isEmpty( listUserFields ) )
557 {
558 MyLuteceUserField userField = new MyLuteceUserField( );
559 userField.setValue( StringUtils.EMPTY );
560 listUserFields.add( userField );
561 }
562
563 map.put( String.valueOf( attribute.getIdAttribute( ) ), listUserFields );
564 }
565
566 Map<String, Object> model = new HashMap<>( );
567
568 model.put( MARK_PLUGIN_NAME, _plugin.getName( ) );
569 model.put( MARK_USER, selectedUser );
570 model.put( MARK_EXTERNAL_APPLICATION_EXIST, applicationsExist );
571 model.put( MARK_ITEM_NAVIGATOR, _itemNavigators.get( PARAMETER_MODIFY_USER ) );
572 model.put( MARK_ATTRIBUTES_LIST, listAttributes );
573 model.put( MARK_LOCALE, getLocale( ) );
574 model.put( MARK_MAP_LIST_ATTRIBUTE_DEFAULT_VALUES, map );
575 model.put( MARK_SHOW_INPUT_LOGIN, !_userFactory.isEmailUsedAsLogin( ) );
576
577 HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_MODIFY_USER, getLocale( ), model );
578
579 return getAdminPage( template.getHtml( ) );
580 }
581
582
583
584
585
586
587
588
589 public String doModifyUser( HttpServletRequest request )
590 {
591 initPluginFromRequest( request );
592
593 String strActionCancel = request.getParameter( PARAMETER_CANCEL );
594
595 if ( strActionCancel != null )
596 {
597 return JSP_MANAGE_USERS;
598 }
599
600 String strError;
601 String strLogin;
602 String strLastName = request.getParameter( PARAMETER_LAST_NAME );
603 String strFirstName = request.getParameter( PARAMETER_FIRST_NAME );
604 String strEmail = request.getParameter( PARAMETER_EMAIL );
605
606 if ( _userFactory.isEmailUsedAsLogin( ) )
607 {
608 strLogin = strEmail;
609 }
610 else
611 {
612 strLogin = request.getParameter( PARAMETER_LOGIN );
613 }
614
615 if ( StringUtils.isBlank( strLogin ) || StringUtils.isBlank( strLastName ) || StringUtils.isBlank( strFirstName ) || StringUtils.isBlank( strEmail ) )
616 {
617 return AdminMessageService.getMessageUrl( request, Messages.MANDATORY_FIELDS, AdminMessage.TYPE_STOP );
618 }
619
620 DatabaseUser databaseUser = getDatabaseUserFromRequest( request );
621
622 if ( databaseUser == null )
623 {
624 return AdminMessageService.getMessageUrl( request, MESSAGE_ERROR_MODIFY_USER, AdminMessage.TYPE_ERROR );
625 }
626 else
627 if ( !databaseUser.getLogin( ).equalsIgnoreCase( strLogin )
628 && CollectionUtils.isNotEmpty( DatabaseUserHome.findDatabaseUsersListForLogin( strLogin, _plugin ) ) )
629 {
630 strError = AdminMessageService.getMessageUrl( request, MESSAGE_USER_EXIST, AdminMessage.TYPE_STOP );
631 }
632 else
633 if ( !StringUtil.checkEmailAndDomainName( strEmail, SecurityUtils.getBannedDomainNames( _userParamService, _plugin ) ) )
634 {
635 strError = AdminMessageService.getMessageUrl( request, MESSAGE_EMAIL_INVALID, AdminMessage.TYPE_STOP );
636 }
637 else
638 {
639 strError = MyLuteceUserFieldService.checkUserFields( request, getLocale( ) );
640 }
641
642 if ( StringUtils.isNotBlank( strError ) )
643 {
644 return strError;
645 }
646
647 databaseUser.setEmail( strEmail );
648 databaseUser.setFirstName( strFirstName );
649 databaseUser.setLastName( strLastName );
650 databaseUser.setLogin( strLogin );
651
652 _databaseService.doUpdateUser( databaseUser, _plugin );
653 MyLuteceUserFieldService.doModifyUserFields( databaseUser.getUserId( ), request, getLocale( ), getUser( ) );
654
655 return JSP_MODIFY_USER + QUESTION_MARK + PARAMETER_PLUGIN_NAME + EQUAL + _plugin.getName( ) + AMPERSAND + PARAMETER_MYLUTECE_DATABASE_USER_ID + EQUAL
656 + databaseUser.getUserId( );
657 }
658
659
660
661
662
663
664
665
666 public String getRemoveUser( HttpServletRequest request )
667 {
668 initPluginFromRequest( request );
669
670 UrlItem url = new UrlItem( JSP_DO_REMOVE_USER );
671 url.addParameter( PARAMETER_PLUGIN_NAME, _plugin.getName( ) );
672 url.addParameter( PARAMETER_MYLUTECE_DATABASE_USER_ID, request.getParameter( PARAMETER_MYLUTECE_DATABASE_USER_ID ) );
673
674 return AdminMessageService.getMessageUrl( request, MESSAGE_CONFIRM_REMOVE_USER, url.getUrl( ), AdminMessage.TYPE_CONFIRMATION );
675 }
676
677
678
679
680
681
682
683
684 public String doRemoveUser( HttpServletRequest request )
685 {
686 if ( _plugin == null )
687 {
688 String strPluginName = request.getParameter( PARAMETER_PLUGIN_NAME );
689 _plugin = PluginService.getPlugin( strPluginName );
690 }
691
692 DatabaseUser user = getDatabaseUserFromRequest( request );
693
694 if ( user == null )
695 {
696 return AdminMessageService.getMessageUrl( request, MESSAGE_ERROR_REMOVE_USER, AdminMessage.TYPE_ERROR );
697 }
698
699 DatabaseUserHome.remove( user, _plugin );
700 DatabaseHome.removeGroupsForUser( user.getUserId( ), _plugin );
701 DatabaseHome.removeRolesForUser( user.getUserId( ), _plugin );
702 MyLuteceUserFieldService.doRemoveUserFields( user.getUserId( ), request, getLocale( ) );
703 DatabaseUserKeyService.getService( ).removeByIdUser( user.getUserId( ) );
704
705 return MANAGE_USERS + "?" + PARAMETER_PLUGIN_NAME + "=" + _plugin.getName( );
706 }
707
708
709
710
711
712
713
714
715 public String getManageRolesUser( HttpServletRequest request )
716 {
717 AdminUser adminUser = getUser( );
718 initPluginFromRequest( request );
719
720 setPageTitleProperty( PROPERTY_PAGE_TITLE_MANAGE_ROLES_USER );
721
722 DatabaseUser selectedUser = getDatabaseUserFromRequest( request );
723
724 if ( selectedUser == null )
725 {
726 return getManageUsers( request );
727 }
728
729 Collection<Role> allRoleList = RoleHome.findAll( );
730 allRoleList = RBACService.getAuthorizedCollection( allRoleList, RoleResourceIdService.PERMISSION_ASSIGN_ROLE, (User) adminUser );
731 allRoleList = AdminWorkgroupService.getAuthorizedCollection( allRoleList, (User) getUser( ) );
732
733 List<String> userRoleKeyList = DatabaseHome.findUserRolesFromLogin( selectedUser.getLogin( ), _plugin );
734 Collection<Role> userRoleList = new ArrayList<>( );
735
736 for ( String strRoleKey : userRoleKeyList )
737 {
738 for ( Role role : allRoleList )
739 {
740 if ( role.getRole( ).equals( strRoleKey ) )
741 {
742 userRoleList.add( RoleHome.findByPrimaryKey( strRoleKey ) );
743 }
744 }
745 }
746
747
748 setItemNavigator( PARAMETER_ASSIGN_ROLE, selectedUser.getUserId( ), AppPathService.getBaseUrl( request ) + JSP_URL_MANAGE_ROLES_USER, request );
749
750 Boolean applicationsExist = Boolean.FALSE;
751
752 Map<String, Object> model = new HashMap<>( );
753 model.put( MARK_ROLES_LIST, allRoleList );
754 model.put( MARK_ROLES_LIST_FOR_USER, userRoleList );
755 model.put( MARK_USER, selectedUser );
756 model.put( MARK_PLUGIN_NAME, _plugin.getName( ) );
757 model.put( MARK_EXTERNAL_APPLICATION_EXIST, applicationsExist );
758 model.put( MARK_ITEM_NAVIGATOR, _itemNavigators.get( PARAMETER_ASSIGN_ROLE ) );
759
760 HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_MANAGE_ROLES_USER, getLocale( ), model );
761
762 return getAdminPage( template.getHtml( ) );
763 }
764
765
766
767
768
769
770
771
772 public String doAssignRoleUser( HttpServletRequest request )
773 {
774 initPluginFromRequest( request );
775
776 String strReturn;
777
778 String strActionCancel = request.getParameter( PARAMETER_CANCEL );
779
780 if ( strActionCancel != null )
781 {
782 strReturn = JSP_MANAGE_USERS;
783 }
784 else
785 {
786
787 DatabaseUser user = getDatabaseUserFromRequest( request );
788
789 if ( user == null )
790 {
791 return AdminMessageService.getMessageUrl( request, MESSAGE_ERROR_MANAGE_ROLES, AdminMessage.TYPE_ERROR );
792 }
793
794 String [ ] roleArray = request.getParameterValues( PARAMETER_MYLUTECE_DATABASE_ROLE_ID );
795
796 DatabaseHome.removeRolesForUser( user.getUserId( ), _plugin );
797
798 if ( roleArray != null )
799 {
800 for ( int i = 0; i < roleArray.length; i++ )
801 {
802 DatabaseHome.addRoleForUser( user.getUserId( ), roleArray [i], _plugin );
803 }
804 }
805
806 strReturn = JSP_MANAGE_ROLES_USER + QUESTION_MARK + PARAMETER_PLUGIN_NAME + EQUAL + _plugin.getName( ) + AMPERSAND
807 + PARAMETER_MYLUTECE_DATABASE_USER_ID + EQUAL + user.getUserId( );
808 }
809
810 return strReturn;
811 }
812
813
814
815
816
817
818
819
820 public String getManageGroupsUser( HttpServletRequest request )
821 {
822 AdminUser adminUser = getUser( );
823 initPluginFromRequest( request );
824
825 setPageTitleProperty( PROPERTY_PAGE_TITLE_MANAGE_GROUPS_USER );
826
827 DatabaseUser selectedUser = getDatabaseUserFromRequest( request );
828
829 if ( selectedUser == null )
830 {
831 return getManageUsers( request );
832 }
833
834 Collection<Group> allGroupList = GroupHome.findAll( getPlugin( ) );
835 Collection<Group> groupList = new ArrayList<>( );
836
837 for ( Group group : allGroupList )
838 {
839 List<String> groupRoleKeyList = GroupRoleHome.findGroupRoles( group.getGroupKey( ), getPlugin( ) );
840
841 if ( CollectionUtils.isEmpty( groupRoleKeyList ) )
842 {
843 groupList.add( group );
844
845 continue;
846 }
847
848 for ( String groupRoleKey : groupRoleKeyList )
849 {
850 Role role = RoleHome.findByPrimaryKey( groupRoleKey );
851
852 if ( AdminWorkgroupService.isAuthorized( role, (User) adminUser ) )
853 {
854 groupList.add( group );
855
856 break;
857 }
858 }
859 }
860
861 List<String> userGroupKeyList = DatabaseHome.findUserGroupsFromLogin( selectedUser.getLogin( ), _plugin );
862 Collection<Group> userGroupList = new ArrayList<>( );
863
864 for ( String strGroupKey : userGroupKeyList )
865 {
866 for ( Group group : groupList )
867 {
868 if ( group.getGroupKey( ).equals( strGroupKey ) )
869 {
870 userGroupList.add( GroupHome.findByPrimaryKey( strGroupKey, getPlugin( ) ) );
871 }
872 }
873 }
874
875
876 setItemNavigator( PARAMETER_ASSIGN_GROUP, selectedUser.getUserId( ), AppPathService.getBaseUrl( request ) + JSP_URL_MANAGE_GROUPS_USER, request );
877
878 Boolean applicationsExist = Boolean.FALSE;
879
880 Map<String, Object> model = new HashMap<>( );
881 model.put( MARK_GROUPS_LIST, groupList );
882 model.put( MARK_GROUPS_LIST_FOR_USER, userGroupList );
883 model.put( MARK_USER, selectedUser );
884 model.put( MARK_PLUGIN_NAME, _plugin.getName( ) );
885 model.put( MARK_EXTERNAL_APPLICATION_EXIST, applicationsExist );
886 model.put( MARK_ITEM_NAVIGATOR, _itemNavigators.get( PARAMETER_ASSIGN_GROUP ) );
887
888 HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_MANAGE_GROUPS_USER, getLocale( ), model );
889
890 return getAdminPage( template.getHtml( ) );
891 }
892
893
894
895
896
897
898
899
900 public String doAssignGroupsUser( HttpServletRequest request )
901 {
902 initPluginFromRequest( request );
903
904 String strReturn;
905
906 String strActionCancel = request.getParameter( PARAMETER_CANCEL );
907
908 if ( strActionCancel != null )
909 {
910 strReturn = JSP_MANAGE_USERS;
911 }
912 else
913 {
914
915 DatabaseUser user = getDatabaseUserFromRequest( request );
916
917 if ( user == null )
918 {
919 return AdminMessageService.getMessageUrl( request, MESSAGE_ERROR_MANAGE_GROUPS, AdminMessage.TYPE_ERROR );
920 }
921
922 String [ ] groupArray = request.getParameterValues( PARAMETER_MYLUTECE_DATABASE_GROUP_KEY );
923
924 DatabaseHome.removeGroupsForUser( user.getUserId( ), _plugin );
925
926 if ( groupArray != null )
927 {
928 for ( int i = 0; i < groupArray.length; i++ )
929 {
930 DatabaseHome.addGroupForUser( user.getUserId( ), groupArray [i], _plugin );
931 }
932 }
933
934 strReturn = JSP_MANAGE_GROUPS_USER + QUESTION_MARK + PARAMETER_PLUGIN_NAME + EQUAL + _plugin.getName( ) + AMPERSAND
935 + PARAMETER_MYLUTECE_DATABASE_USER_ID + EQUAL + user.getUserId( );
936 }
937
938 return strReturn;
939 }
940
941
942
943
944
945
946
947 private DatabaseUser getDatabaseUserFromRequest( HttpServletRequest request )
948 {
949 String strUserId = request.getParameter( PARAMETER_MYLUTECE_DATABASE_USER_ID );
950
951 if ( ( strUserId == null ) || !strUserId.matches( REGEX_DATABASE_USER_ID ) )
952 {
953 return null;
954 }
955
956 int nUserId = Integer.parseInt( strUserId );
957
958 return DatabaseUserHome.findByPrimaryKey( nUserId, _plugin );
959 }
960
961
962
963
964
965
966
967
968 public String getManageAdvancedParameters( HttpServletRequest request )
969 {
970 if ( !RBACService.isAuthorized( DatabaseResourceIdService.RESOURCE_TYPE, RBAC.WILDCARD_RESOURCES_ID, DatabaseResourceIdService.PERMISSION_MANAGE,
971 (User) getUser( ) ) )
972 {
973 return getManageUsers( request );
974 }
975
976 Map<String, Object> model = _databaseService.getManageAdvancedParameters( getUser( ) );
977
978 HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_MANAGE_ADVANCED_PARAMETERS, getLocale( ), model );
979
980 return getAdminPage( template.getHtml( ) );
981 }
982
983
984
985
986
987
988
989
990 public String doActivateUser( HttpServletRequest request )
991 {
992 return doChangeUserStatus( request, true );
993 }
994
995
996
997
998
999
1000
1001
1002 public String doDeactivateUser( HttpServletRequest request )
1003 {
1004 return doChangeUserStatus( request, false );
1005 }
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016 public String doModifyDatabaseUserParameters( HttpServletRequest request ) throws AccessDeniedException
1017 {
1018 if ( !RBACService.isAuthorized( DatabaseResourceIdService.RESOURCE_TYPE, RBAC.WILDCARD_RESOURCES_ID, DatabaseResourceIdService.PERMISSION_MANAGE,
1019 (User) getUser( ) ) )
1020 {
1021 throw new AccessDeniedException( "Access Denied" );
1022 }
1023
1024 SecurityUtils.updateSecurityParameters( _userParamService, request, getPlugin( ) );
1025 SecurityUtils.updateLargeParameterValue( _userParamService, getPlugin( ), PARAMETER_BANNED_DOMAIN_NAMES,
1026 request.getParameter( PARAMETER_BANNED_DOMAIN_NAMES ) );
1027
1028 SecurityUtils.updateParameterValue( _userParamService, getPlugin( ), PARAMETER_ACCOUNT_CREATION_VALIDATION_EMAIL,
1029 request.getParameter( PARAMETER_ACCOUNT_CREATION_VALIDATION_EMAIL ) );
1030
1031 SecurityUtils.updateParameterValue( _userParamService, getPlugin( ), PARAMETER_AUTO_LOGIN_AFTER_VALIDATION_EMAIL,
1032 request.getParameter( PARAMETER_AUTO_LOGIN_AFTER_VALIDATION_EMAIL ) );
1033
1034 if ( _databaseService.isPluginJcaptchaEnable( ) )
1035 {
1036 SecurityUtils.updateParameterValue( _userParamService, _plugin, PARAMETER_ENABLE_JCAPTCHA, request.getParameter( PARAMETER_ENABLE_JCAPTCHA ) );
1037 }
1038
1039 return JSP_MANAGE_ADVANCED_PARAMETERS;
1040 }
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051 private String doChangeUserStatus( HttpServletRequest request, boolean bIsActive )
1052 {
1053 DatabaseUser databaseUser = getDatabaseUserFromRequest( request );
1054
1055 if ( databaseUser != null )
1056 {
1057 int nStatus = bIsActive ? DatabaseUser.STATUS_ACTIVATED : DatabaseUser.STATUS_NOT_ACTIVATED;
1058 databaseUser.setStatus( nStatus );
1059 _databaseService.doUpdateUser( databaseUser, _plugin );
1060 }
1061
1062 return MANAGE_USERS + "?" + PARAMETER_PLUGIN_NAME + "=" + _plugin.getName( );
1063 }
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077 private void setItemNavigator( String strItemNavigatorKey, int nIdDatabaseUser, String strUrl, HttpServletRequest request )
1078 {
1079 ItemNavigator itemNavigator = _itemNavigators.get( strItemNavigatorKey );
1080
1081 if ( itemNavigator == null )
1082 {
1083 if ( _duFilter == null )
1084 {
1085 _duFilter = new DatabaseUserFilter( );
1086 }
1087
1088 List<String> listIdsDatabaseUser = new ArrayList<>( );
1089 List<DatabaseUser> listUsers = _databaseService.getAuthorizedUsers( getUser( ), _plugin );
1090 List<DatabaseUser> listFilteredUsers = _databaseService.getListFilteredUsers( request, _duFilter, listUsers );
1091
1092
1093 if ( StringUtils.isNotBlank( _strSortedAttributeName ) )
1094 {
1095 Collections.sort( listFilteredUsers, new AttributeComparator( _strSortedAttributeName, _bIsAscSort ) );
1096 }
1097
1098 int nCurrentItemId = 0;
1099 int nIndex = 0;
1100
1101 for ( DatabaseUser databaseUser : listFilteredUsers )
1102 {
1103 if ( databaseUser != null )
1104 {
1105 listIdsDatabaseUser.add( Integer.toString( databaseUser.getUserId( ) ) );
1106
1107 if ( databaseUser.getUserId( ) == nIdDatabaseUser )
1108 {
1109 nCurrentItemId = nIndex;
1110 }
1111
1112 nIndex++;
1113 }
1114 }
1115
1116 itemNavigator = new ItemNavigator( listIdsDatabaseUser, nCurrentItemId, strUrl, PARAMETER_MYLUTECE_DATABASE_USER_ID );
1117 }
1118 else
1119 {
1120 itemNavigator.setCurrentItemId( Integer.toString( nIdDatabaseUser ) );
1121 }
1122
1123 _itemNavigators.put( strItemNavigatorKey, itemNavigator );
1124 }
1125
1126
1127
1128
1129 private void reinitItemNavigators( )
1130 {
1131 _itemNavigators = new HashMap<>( );
1132 _strSortedAttributeName = StringUtils.EMPTY;
1133 _bIsAscSort = true;
1134 }
1135
1136
1137
1138
1139
1140
1141
1142
1143 public String getChangeUseAdvancedSecurityParameters( HttpServletRequest request )
1144 {
1145 if ( SecurityUtils.isAdvancedSecurityParametersUsed( _userParamService, getPlugin( ) ) )
1146 {
1147 return AdminMessageService.getMessageUrl( request, PROPERTY_MESSAGE_CONFIRM_REMOVE_ASP, JSP_URL_REMOVE_ADVANCED_SECUR_PARAM,
1148 AdminMessage.TYPE_CONFIRMATION );
1149 }
1150
1151 return AdminMessageService.getMessageUrl( request, PROPERTY_MESSAGE_CONFIRM_USE_ASP, JSP_URL_USE_ADVANCED_SECUR_PARAM, AdminMessage.TYPE_CONFIRMATION );
1152 }
1153
1154
1155
1156
1157
1158
1159
1160
1161 public String doUseAdvancedSecurityParameters( HttpServletRequest request )
1162 {
1163 SecurityUtils.useAdvancedSecurityParameters( _userParamService, getPlugin( ) );
1164
1165 return JSP_MANAGE_ADVANCED_PARAMETERS;
1166 }
1167
1168
1169
1170
1171
1172
1173
1174
1175 public String doRemoveAdvancedSecurityParameters( HttpServletRequest request )
1176 {
1177 SecurityUtils.removeAdvancedSecurityParameters( _userParamService, getPlugin( ) );
1178
1179 return JSP_MANAGE_ADVANCED_PARAMETERS;
1180 }
1181
1182
1183
1184
1185
1186
1187
1188
1189 public String getChangeFieldAnonymizeAdminUsers( HttpServletRequest request )
1190 {
1191 Map<String, Object> model = new HashMap<>( );
1192
1193 List<IAttribute> listAllAttributes = AttributeHome.findAll( getLocale( ), getPlugin( ) );
1194 List<IAttribute> listAttributesText = new ArrayList<>( );
1195
1196 for ( IAttribute attribut : listAllAttributes )
1197 {
1198 if ( attribut.isAnonymizable( ) )
1199 {
1200 listAttributesText.add( attribut );
1201 }
1202 }
1203
1204 model.put( MARK_ATTRIBUTES_LIST, listAttributesText );
1205
1206 model.putAll( AttributeHome.getAnonymizationStatusUserStaticField( getPlugin( ) ) );
1207
1208 setPageTitleProperty( PROPERTY_MESSAGE_TITLE_CHANGE_ANONYMIZE_USER );
1209
1210 HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_FIELD_ANONYMIZE_USER, getLocale( ), model );
1211
1212 return getAdminPage( template.getHtml( ) );
1213 }
1214
1215
1216
1217
1218
1219
1220
1221
1222 public String doChangeFieldAnonymizeUsers( HttpServletRequest request )
1223 {
1224 if ( request.getParameter( PARAMETER_CANCEL ) != null )
1225 {
1226 return JSP_MANAGE_ADVANCED_PARAMETERS;
1227 }
1228
1229 Plugin pluginMyLutece = PluginService.getPlugin( MyLutecePlugin.PLUGIN_NAME );
1230 AttributeHome.updateAnonymizationStatusUserStaticField( PARAMETER_LOGIN, Boolean.valueOf( request.getParameter( PARAMETER_LOGIN ) ), pluginMyLutece );
1231 AttributeHome.updateAnonymizationStatusUserStaticField( PARAMETER_NAME_GIVEN, Boolean.valueOf( request.getParameter( PARAMETER_NAME_GIVEN ) ),
1232 pluginMyLutece );
1233 AttributeHome.updateAnonymizationStatusUserStaticField( PARAMETER_NAME_FAMILY, Boolean.valueOf( request.getParameter( PARAMETER_NAME_FAMILY ) ),
1234 pluginMyLutece );
1235 AttributeHome.updateAnonymizationStatusUserStaticField( PARAMETER_EMAIL, Boolean.valueOf( request.getParameter( PARAMETER_EMAIL ) ), pluginMyLutece );
1236
1237 List<IAttribute> listAllAttributes = AttributeHome.findAll( getLocale( ), pluginMyLutece );
1238 List<IAttribute> listAttributesText = new ArrayList<>( );
1239
1240 for ( IAttribute attribut : listAllAttributes )
1241 {
1242 if ( attribut.isAnonymizable( ) )
1243 {
1244 listAttributesText.add( attribut );
1245 }
1246 }
1247
1248 for ( IAttribute attribute : listAttributesText )
1249 {
1250 Boolean bNewValue = Boolean.valueOf( request.getParameter( PARAMETER_ATTRIBUTE + Integer.toString( attribute.getIdAttribute( ) ) ) );
1251 AttributeHome.updateAttributeAnonymization( attribute.getIdAttribute( ), bNewValue, pluginMyLutece );
1252 }
1253
1254 return JSP_MANAGE_ADVANCED_PARAMETERS;
1255 }
1256
1257
1258
1259
1260
1261
1262
1263
1264 public String getAnonymizeUser( HttpServletRequest request )
1265 {
1266 UrlItem url = new UrlItem( JSP_URL_ANONYMIZE_USER );
1267
1268 String strUserId = request.getParameter( PARAMETER_USER_ID );
1269
1270 if ( ( strUserId == null ) || strUserId.isEmpty( ) )
1271 {
1272 return AdminMessageService.getMessageUrl( request, PROPERTY_MESSAGE_NO_USER_SELECTED, AdminMessage.TYPE_STOP );
1273 }
1274
1275 url.addParameter( PARAMETER_USER_ID, strUserId );
1276
1277 return AdminMessageService.getMessageUrl( request, PROPERTY_MESSAGE_CONFIRM_ANONYMIZE_USER, url.getUrl( ), AdminMessage.TYPE_CONFIRMATION );
1278 }
1279
1280
1281
1282
1283
1284
1285
1286
1287 public String doAnonymizeUser( HttpServletRequest request )
1288 {
1289 String strUserId = request.getParameter( PARAMETER_USER_ID );
1290
1291 if ( ( strUserId == null ) || strUserId.isEmpty( ) )
1292 {
1293 return AdminMessageService.getMessageUrl( request, PROPERTY_MESSAGE_NO_USER_SELECTED, AdminMessage.TYPE_STOP );
1294 }
1295
1296 _anonymizationService.anonymizeUser( Integer.parseInt( strUserId ), getLocale( ) );
1297
1298 return JSP_MANAGE_USERS;
1299 }
1300
1301
1302
1303
1304
1305
1306
1307
1308 public String getModifyAccountLifeTimeEmails( HttpServletRequest request )
1309 {
1310 String strEmailType = request.getParameter( PARAMETER_EMAIL_TYPE );
1311
1312 Map<String, Object> model = new HashMap<>( );
1313 String strSenderKey = StringUtils.EMPTY;
1314 String strSubjectKey = StringUtils.EMPTY;
1315 String strBodyKey = StringUtils.EMPTY;
1316 String strTitle = StringUtils.EMPTY;
1317
1318 if ( CONSTANT_EMAIL_TYPE_FIRST.equalsIgnoreCase( strEmailType ) )
1319 {
1320 strSenderKey = PARAMETER_FIRST_ALERT_MAIL_SENDER;
1321 strSubjectKey = PARAMETER_FIRST_ALERT_MAIL_SUBJECT;
1322 strBodyKey = PARAMETER_FIRST_ALERT_MAIL;
1323 strTitle = PROPERTY_FIRST_EMAIL;
1324 }
1325 else
1326 if ( CONSTANT_EMAIL_TYPE_OTHER.equalsIgnoreCase( strEmailType ) )
1327 {
1328 strSenderKey = PARAMETER_OTHER_ALERT_MAIL_SENDER;
1329 strSubjectKey = PARAMETER_OTHER_ALERT_MAIL_SUBJECT;
1330 strBodyKey = PARAMETER_OTHER_ALERT_MAIL;
1331 strTitle = PROPERTY_OTHER_EMAIL;
1332 }
1333 else
1334 if ( CONSTANT_EMAIL_TYPE_EXPIRED.equalsIgnoreCase( strEmailType ) )
1335 {
1336 strSenderKey = PARAMETER_EXPIRED_ALERT_MAIL_SENDER;
1337 strSubjectKey = PARAMETER_EXPIRED_ALERT_MAIL_SUBJECT;
1338 strBodyKey = PARAMETER_EXPIRATION_MAIL;
1339 strTitle = PROPERTY_ACCOUNT_DEACTIVATES_EMAIL;
1340 }
1341 else
1342 if ( CONSTANT_EMAIL_TYPE_REACTIVATED.equalsIgnoreCase( strEmailType ) )
1343 {
1344 strSenderKey = PARAMETER_REACTIVATED_ALERT_MAIL_SENDER;
1345 strSubjectKey = PARAMETER_REACTIVATED_ALERT_MAIL_SUBJECT;
1346 strBodyKey = PARAMETER_ACCOUNT_REACTIVATED;
1347 strTitle = PROPERTY_ACCOUNT_UPDATED_EMAIL;
1348 }
1349 else
1350 if ( CONSTANT_EMAIL_TYPE_IP_BLOCKED.equalsIgnoreCase( strEmailType ) )
1351 {
1352 strSenderKey = PARAMETER_UNBLOCK_USER_MAIL_SENDER;
1353 strSubjectKey = PARAMETER_UNBLOCK_USER_MAIL_SUBJECT;
1354 strBodyKey = PARAMETER_UNBLOCK_USER;
1355 strTitle = PROPERTY_UNBLOCK_USER;
1356 }
1357 else
1358 if ( CONSTANT_EMAIL_PASSWORD_EXPIRED.equalsIgnoreCase( strEmailType ) )
1359 {
1360 strSenderKey = PARAMETER_PASSWORD_EXPIRED_MAIL_SENDER;
1361 strSubjectKey = PARAMETER_PASSWORD_EXPIRED_MAIL_SUBJECT;
1362 strBodyKey = PARAMETER_NOTIFY_PASSWORD_EXPIRED;
1363 strTitle = PROPERTY_NOTIFY_PASSWORD_EXPIRED;
1364 }
1365 else
1366 if ( CONSTANT_EMAIL_TYPE_LOST_PASSWORD.equalsIgnoreCase( strEmailType ) )
1367 {
1368 strSenderKey = PARAMETER_MAIL_LOST_PASSWORD_SENDER;
1369 strSubjectKey = PARAMETER_MAIL_LOST_PASSWORD_SUBJECT;
1370 strBodyKey = PARAMETER_MAIL_LOST_PASSWORD;
1371 strTitle = PROPERTY_MAIL_LOST_PASSWORD;
1372 }
1373
1374 ReferenceItem referenceItem = _userParamService.findByKey( strSenderKey, getPlugin( ) );
1375 String strSender = ( referenceItem == null ) ? StringUtils.EMPTY : referenceItem.getName( );
1376
1377 referenceItem = _userParamService.findByKey( strSubjectKey, getPlugin( ) );
1378
1379 String strSubject = ( referenceItem == null ) ? StringUtils.EMPTY : referenceItem.getName( );
1380
1381 model.put( PARAMETER_EMAIL_TYPE, strEmailType );
1382 model.put( MARK_EMAIL_SENDER, strSender );
1383 model.put( MARK_EMAIL_SUBJECT, strSubject );
1384 model.put( MARK_EMAIL_BODY, DatabaseTemplateService.getTemplateFromKey( strBodyKey ) );
1385 model.put( MARK_EMAIL_LABEL, strTitle );
1386 model.put( MARK_WEBAPP_URL, AppPathService.getBaseUrl( request ) );
1387 model.put( MARK_LOCALE, request.getLocale( ) );
1388
1389 HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_ACCOUNT_LIFE_TIME_EMAIL, getLocale( ), model );
1390
1391 return getAdminPage( template.getHtml( ) );
1392 }
1393
1394
1395
1396
1397
1398
1399
1400
1401 public String doModifyAccountLifeTimeEmails( HttpServletRequest request )
1402 {
1403 String strEmailType = request.getParameter( PARAMETER_EMAIL_TYPE );
1404
1405 String strSenderKey = StringUtils.EMPTY;
1406 String strSubjectKey = StringUtils.EMPTY;
1407 String strBodyKey = StringUtils.EMPTY;
1408
1409 if ( CONSTANT_EMAIL_TYPE_FIRST.equalsIgnoreCase( strEmailType ) )
1410 {
1411 strSenderKey = PARAMETER_FIRST_ALERT_MAIL_SENDER;
1412 strSubjectKey = PARAMETER_FIRST_ALERT_MAIL_SUBJECT;
1413 strBodyKey = PARAMETER_FIRST_ALERT_MAIL;
1414 }
1415 else
1416 if ( CONSTANT_EMAIL_TYPE_OTHER.equalsIgnoreCase( strEmailType ) )
1417 {
1418 strSenderKey = PARAMETER_OTHER_ALERT_MAIL_SENDER;
1419 strSubjectKey = PARAMETER_OTHER_ALERT_MAIL_SUBJECT;
1420 strBodyKey = PARAMETER_OTHER_ALERT_MAIL;
1421 }
1422 else
1423 if ( CONSTANT_EMAIL_TYPE_EXPIRED.equalsIgnoreCase( strEmailType ) )
1424 {
1425 strSenderKey = PARAMETER_EXPIRED_ALERT_MAIL_SENDER;
1426 strSubjectKey = PARAMETER_EXPIRED_ALERT_MAIL_SUBJECT;
1427 strBodyKey = PARAMETER_EXPIRATION_MAIL;
1428 }
1429 else
1430 if ( CONSTANT_EMAIL_TYPE_REACTIVATED.equalsIgnoreCase( strEmailType ) )
1431 {
1432 strSenderKey = PARAMETER_REACTIVATED_ALERT_MAIL_SENDER;
1433 strSubjectKey = PARAMETER_REACTIVATED_ALERT_MAIL_SUBJECT;
1434 strBodyKey = PARAMETER_ACCOUNT_REACTIVATED;
1435 }
1436 else
1437 if ( CONSTANT_EMAIL_TYPE_IP_BLOCKED.equalsIgnoreCase( strEmailType ) )
1438 {
1439 strSenderKey = PARAMETER_UNBLOCK_USER_MAIL_SENDER;
1440 strSubjectKey = PARAMETER_UNBLOCK_USER_MAIL_SUBJECT;
1441 strBodyKey = PARAMETER_UNBLOCK_USER;
1442 }
1443 else
1444 if ( CONSTANT_EMAIL_PASSWORD_EXPIRED.equalsIgnoreCase( strEmailType ) )
1445 {
1446 strSenderKey = PARAMETER_PASSWORD_EXPIRED_MAIL_SENDER;
1447 strSubjectKey = PARAMETER_PASSWORD_EXPIRED_MAIL_SUBJECT;
1448 strBodyKey = PARAMETER_NOTIFY_PASSWORD_EXPIRED;
1449 }
1450 else
1451 if ( CONSTANT_EMAIL_TYPE_LOST_PASSWORD.equalsIgnoreCase( strEmailType ) )
1452 {
1453 strSenderKey = PARAMETER_MAIL_LOST_PASSWORD_SENDER;
1454 strSubjectKey = PARAMETER_MAIL_LOST_PASSWORD_SUBJECT;
1455 strBodyKey = PARAMETER_MAIL_LOST_PASSWORD;
1456 }
1457
1458 SecurityUtils.updateParameterValue( _userParamService, getPlugin( ), strSenderKey, request.getParameter( MARK_EMAIL_SENDER ) );
1459 SecurityUtils.updateParameterValue( _userParamService, getPlugin( ), strSubjectKey, request.getParameter( MARK_EMAIL_SUBJECT ) );
1460 DatabaseTemplateService.updateTemplate( strBodyKey, request.getParameter( MARK_EMAIL_BODY ) );
1461
1462 return JSP_MANAGE_ADVANCED_PARAMETERS;
1463 }
1464
1465
1466
1467
1468
1469
1470
1471
1472 public String getImportUsersFromFile( HttpServletRequest request )
1473 {
1474 if ( !RBACService.isAuthorized( DatabaseResourceIdService.RESOURCE_TYPE, RBAC.WILDCARD_RESOURCES_ID,
1475 DatabaseResourceIdService.PERMISSION_IMPORT_EXPORT_DATABASE_USERS, (User) getUser( ) ) )
1476 {
1477 return getManageUsers( request );
1478 }
1479
1480 setPageTitleProperty( PROPERTY_IMPORT_USERS_FROM_FILE_PAGETITLE );
1481
1482 Map<String, Object> model = new HashMap<>( );
1483
1484 model.put( MARK_LIST_MESSAGES, request.getAttribute( ATTRIBUTE_IMPORT_USERS_LIST_MESSAGES ) );
1485
1486 String strCsvSeparator = StringUtils.EMPTY + _importDatabaseUserService.getCSVSeparator( );
1487 String strCsvEscapeCharacter = StringUtils.EMPTY + _importDatabaseUserService.getCSVEscapeCharacter( );
1488 String strAttributesSeparator = StringUtils.EMPTY + _importDatabaseUserService.getAttributesSeparator( );
1489 model.put( MARK_CSV_SEPARATOR, strCsvSeparator );
1490 model.put( MARK_CSV_ESCAPE, strCsvEscapeCharacter );
1491 model.put( MARK_ATTRIBUTES_SEPARATOR, strAttributesSeparator );
1492
1493 HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_IMPORT_USERS_FROM_FILE, AdminUserService.getLocale( request ), model );
1494
1495 return getAdminPage( template.getHtml( ) );
1496 }
1497
1498
1499
1500
1501
1502
1503
1504
1505 public DefaultPluginActionResult doImportUsersFromFile( HttpServletRequest request )
1506 {
1507 DefaultPluginActionResult result = new DefaultPluginActionResult( );
1508
1509 if ( !RBACService.isAuthorized( DatabaseResourceIdService.RESOURCE_TYPE, RBAC.WILDCARD_RESOURCES_ID,
1510 DatabaseResourceIdService.PERMISSION_IMPORT_EXPORT_DATABASE_USERS, (User) getUser( ) ) )
1511 {
1512 result.setHtmlContent( getManageUsers( request ) );
1513
1514 return result;
1515 }
1516
1517 if ( request instanceof MultipartHttpServletRequest )
1518 {
1519 MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
1520 FileItem fileItem = multipartRequest.getFile( PARAMETER_IMPORT_USERS_FILE );
1521 String strMimeType = FileSystemUtil.getMIMEType( FileUploadService.getFileNameOnly( fileItem ) );
1522
1523 if ( !( ( fileItem != null ) && !StringUtils.EMPTY.equals( fileItem.getName( ) ) ) )
1524 {
1525 Object [ ] tabRequiredFields = {
1526 I18nService.getLocalizedString( FIELD_IMPORT_USERS_FILE, getLocale( ) )
1527 };
1528 result.setRedirect( AdminMessageService.getMessageUrl( request, MESSAGE_MANDATORY_FIELD, tabRequiredFields, AdminMessage.TYPE_STOP ) );
1529
1530 return result;
1531 }
1532
1533 if ( ( !strMimeType.equals( CONSTANT_MIME_TYPE_CSV ) && !strMimeType.equals( CONSTANT_MIME_TYPE_OCTETSTREAM )
1534 && !strMimeType.equals( CONSTANT_MIME_TYPE_TEXT_CSV ) ) || !fileItem.getName( ).toLowerCase( ).endsWith( CONSTANT_EXTENSION_CSV_FILE ) )
1535 {
1536 result.setRedirect( AdminMessageService.getMessageUrl( request, MESSAGE_ERROR_CSV_FILE_IMPORT, AdminMessage.TYPE_STOP ) );
1537
1538 return result;
1539 }
1540
1541 String strSkipFirstLine = multipartRequest.getParameter( PARAMETER_SKIP_FIRST_LINE );
1542 boolean bSkipFirstLine = StringUtils.isNotEmpty( strSkipFirstLine );
1543 String strUpdateUsers = multipartRequest.getParameter( PARAMETER_UPDATE_USERS );
1544 boolean bUpdateUsers = StringUtils.isNotEmpty( strUpdateUsers );
1545 _importDatabaseUserService.setUpdateExistingUsers( bUpdateUsers );
1546
1547 List<CSVMessageDescriptor> listMessages = _importDatabaseUserService.readCSVFile( fileItem, 0, false, false, bSkipFirstLine,
1548 AdminUserService.getLocale( request ), AppPathService.getBaseUrl( request ) );
1549
1550 request.setAttribute( ATTRIBUTE_IMPORT_USERS_LIST_MESSAGES, listMessages );
1551
1552 String strHtmlResult = getImportUsersFromFile( request );
1553 result.setHtmlContent( strHtmlResult );
1554 }
1555 else
1556 {
1557 Object [ ] tabRequiredFields = {
1558 I18nService.getLocalizedString( FIELD_IMPORT_USERS_FILE, getLocale( ) )
1559 };
1560 result.setRedirect( AdminMessageService.getMessageUrl( request, MESSAGE_MANDATORY_FIELD, tabRequiredFields, AdminMessage.TYPE_STOP ) );
1561 }
1562
1563 return result;
1564 }
1565
1566
1567
1568
1569
1570
1571
1572
1573 public String getExportUsers( HttpServletRequest request )
1574 {
1575 if ( !RBACService.isAuthorized( DatabaseResourceIdService.RESOURCE_TYPE, RBAC.WILDCARD_RESOURCES_ID,
1576 DatabaseResourceIdService.PERMISSION_IMPORT_EXPORT_DATABASE_USERS, (User) getUser( ) ) )
1577 {
1578 return getManageUsers( request );
1579 }
1580
1581 setPageTitleProperty( PROPERTY_EXPORT_USERS_PAGETITLE );
1582
1583 Map<String, Object> model = new HashMap<>( );
1584
1585 ReferenceList refListXsl = XslExportHome.getRefListByPlugin( getPlugin( ) );
1586
1587 model.put( MARK_LIST_XSL_EXPORT, refListXsl );
1588
1589 HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_EXPORT_USERS_FROM_FILE, AdminUserService.getLocale( request ), model );
1590
1591 return getAdminPage( template.getHtml( ) );
1592 }
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605 public DefaultPluginActionResult doExportUsers( HttpServletRequest request, HttpServletResponse response ) throws IOException
1606 {
1607 Plugin plugin = getPlugin( );
1608
1609 DefaultPluginActionResult result = new DefaultPluginActionResult( );
1610
1611 if ( !RBACService.isAuthorized( DatabaseResourceIdService.RESOURCE_TYPE, RBAC.WILDCARD_RESOURCES_ID,
1612 DatabaseResourceIdService.PERMISSION_IMPORT_EXPORT_DATABASE_USERS, (User) getUser( ) ) )
1613 {
1614 result.setHtmlContent( getManageUsers( request ) );
1615
1616 return result;
1617 }
1618
1619 String strXslExportId = request.getParameter( PARAMETER_XSL_EXPORT_ID );
1620 String strExportAttributes = request.getParameter( PARAMETER_EXPORT_ATTRIBUTES );
1621 String strExportRoles = request.getParameter( PARAMETER_EXPORT_ROLES );
1622 String strExportWorkgroups = request.getParameter( PARAMETER_EXPORT_WORKGROUPS );
1623 boolean bExportAttributes = StringUtils.isNotEmpty( strExportAttributes );
1624 boolean bExportRoles = StringUtils.isNotEmpty( strExportRoles );
1625 boolean bExportWorkgroups = StringUtils.isNotEmpty( strExportWorkgroups );
1626
1627 if ( StringUtils.isBlank( strXslExportId ) )
1628 {
1629 Object [ ] tabRequiredFields = {
1630 I18nService.getLocalizedString( FIELD_XSL_EXPORT, getLocale( ) )
1631 };
1632 result.setRedirect( AdminMessageService.getMessageUrl( request, MESSAGE_MANDATORY_FIELD, tabRequiredFields, AdminMessage.TYPE_STOP ) );
1633
1634 return result;
1635 }
1636
1637 int nIdXslExport = Integer.parseInt( strXslExportId );
1638
1639 XslExport xslExport = XslExportHome.findByPrimaryKey( nIdXslExport );
1640
1641 Collection<DatabaseUser> listUsers = DatabaseUserHome.findDatabaseUsersList( plugin );
1642
1643 StringBuffer sbXml = new StringBuffer( XmlUtil.getXmlHeader( ) );
1644 XmlUtil.beginElement( sbXml, CONSTANT_XML_USERS );
1645
1646 List<IAttribute> listAttributes = AttributeHome.findAll( getLocale( ), PluginService.getPlugin( MyLutecePlugin.PLUGIN_NAME ) );
1647
1648 for ( DatabaseUser user : listUsers )
1649 {
1650 if ( user.getStatus( ) != DatabaseUser.STATUS_ANONYMIZED )
1651 {
1652 sbXml.append( _databaseService.getXmlFromUser( user, bExportRoles, bExportWorkgroups, bExportAttributes, listAttributes, getLocale( ) ) );
1653 }
1654 }
1655
1656 XmlUtil.endElement( sbXml, CONSTANT_XML_USERS );
1657
1658 String strXml = StringUtil.replaceAccent( sbXml.toString( ) );
1659 String strExportedUsers = XslExportService.exportXMLWithXSL( nIdXslExport, strXml );
1660
1661 if ( CONSTANT_MIME_TYPE_CSV.contains( xslExport.getExtension( ) ) )
1662 {
1663 response.setContentType( CONSTANT_MIME_TYPE_CSV );
1664 }
1665 else
1666 if ( CONSTANT_EXTENSION_XML_FILE.contains( xslExport.getExtension( ) ) )
1667 {
1668 response.setContentType( CONSTANT_MIME_TYPE_XML );
1669 }
1670 else
1671 {
1672 response.setContentType( CONSTANT_MIME_TYPE_OCTETSTREAM );
1673 }
1674
1675 String strFileName = CONSTANT_EXPORT_USERS_FILE_NAME + CONSTANT_POINT + xslExport.getExtension( );
1676 response.setHeader( CONSTANT_ATTACHEMENT_DISPOSITION, CONSTANT_ATTACHEMENT_FILE_NAME + strFileName + CONSTANT_QUOTE );
1677
1678 PrintWriter out = response.getWriter( );
1679 out.write( strExportedUsers );
1680 out.flush( );
1681 out.close( );
1682
1683 return null;
1684 }
1685
1686
1687
1688
1689
1690
1691 @Override
1692 public Plugin getPlugin( )
1693 {
1694 Plugin plugin = super.getPlugin( );
1695
1696 if ( plugin == null )
1697 {
1698 plugin = PluginService.getPlugin( DatabasePlugin.PLUGIN_NAME );
1699 }
1700
1701 return plugin;
1702 }
1703
1704 private static void initPluginFromRequest( HttpServletRequest request )
1705 {
1706 if ( _plugin == null )
1707 {
1708 String strPluginName = request.getParameter( PARAMETER_PLUGIN_NAME );
1709 _plugin = PluginService.getPlugin( strPluginName );
1710 }
1711 }
1712 }