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.calendar.web;
35
36 import fr.paris.lutece.plugins.calendar.business.CalendarHome;
37 import fr.paris.lutece.plugins.calendar.business.CalendarSubscriber;
38 import fr.paris.lutece.plugins.calendar.business.CalendarSubscriberHome;
39 import fr.paris.lutece.plugins.calendar.business.Event;
40 import fr.paris.lutece.plugins.calendar.business.OccurrenceEvent;
41 import fr.paris.lutece.plugins.calendar.business.SimpleEvent;
42 import fr.paris.lutece.plugins.calendar.business.category.Category;
43 import fr.paris.lutece.plugins.calendar.business.category.CategoryHome;
44 import fr.paris.lutece.plugins.calendar.business.parameter.CalendarParameterHome;
45 import fr.paris.lutece.plugins.calendar.service.AgendaResource;
46 import fr.paris.lutece.plugins.calendar.service.AgendaSubscriberService;
47 import fr.paris.lutece.plugins.calendar.service.CalendarResourceIdService;
48 import fr.paris.lutece.plugins.calendar.service.CalendarService;
49 import fr.paris.lutece.plugins.calendar.service.CategoryService;
50 import fr.paris.lutece.plugins.calendar.service.EventImageResourceService;
51 import fr.paris.lutece.plugins.calendar.service.EventListService;
52 import fr.paris.lutece.plugins.calendar.service.Utils;
53 import fr.paris.lutece.plugins.calendar.service.search.CalendarIndexer;
54 import fr.paris.lutece.plugins.calendar.utils.CalendarIndexerUtils;
55 import fr.paris.lutece.portal.business.indexeraction.IndexerAction;
56 import fr.paris.lutece.portal.business.rbac.RBAC;
57 import fr.paris.lutece.portal.business.role.RoleHome;
58 import fr.paris.lutece.portal.business.user.AdminUser;
59 import fr.paris.lutece.portal.service.admin.AccessDeniedException;
60 import fr.paris.lutece.portal.service.i18n.I18nService;
61 import fr.paris.lutece.portal.service.image.ImageResource;
62 import fr.paris.lutece.portal.service.message.AdminMessage;
63 import fr.paris.lutece.portal.service.message.AdminMessageService;
64 import fr.paris.lutece.portal.service.plugin.Plugin;
65 import fr.paris.lutece.portal.service.plugin.PluginService;
66 import fr.paris.lutece.portal.service.rbac.RBACService;
67 import fr.paris.lutece.portal.service.search.IndexationService;
68 import fr.paris.lutece.portal.service.spring.SpringContextService;
69 import fr.paris.lutece.portal.service.template.AppTemplateService;
70 import fr.paris.lutece.portal.service.util.AppException;
71 import fr.paris.lutece.portal.service.util.AppPathService;
72 import fr.paris.lutece.portal.service.util.AppPropertiesService;
73 import fr.paris.lutece.portal.service.workgroup.AdminWorkgroupService;
74 import fr.paris.lutece.portal.web.admin.PluginAdminPageJspBean;
75 import fr.paris.lutece.portal.web.constants.Messages;
76 import fr.paris.lutece.portal.web.constants.Parameters;
77 import fr.paris.lutece.portal.web.upload.MultipartHttpServletRequest;
78 import fr.paris.lutece.portal.web.util.LocalizedPaginator;
79 import fr.paris.lutece.util.ReferenceItem;
80 import fr.paris.lutece.util.ReferenceList;
81 import fr.paris.lutece.util.date.DateUtil;
82 import fr.paris.lutece.util.filesystem.DirectoryNotFoundException;
83 import fr.paris.lutece.util.filesystem.FileSystemUtil;
84 import fr.paris.lutece.util.html.HtmlTemplate;
85 import fr.paris.lutece.util.html.Paginator;
86 import fr.paris.lutece.util.sort.AttributeComparator;
87 import fr.paris.lutece.util.string.StringUtil;
88 import fr.paris.lutece.util.url.UrlItem;
89
90 import java.io.File;
91 import java.util.ArrayList;
92 import java.util.Collection;
93 import java.util.Collections;
94 import java.util.Date;
95 import java.util.HashMap;
96 import java.util.List;
97 import java.util.Locale;
98 import java.util.Map;
99 import java.util.StringTokenizer;
100 import java.util.regex.Pattern;
101
102 import javax.servlet.http.HttpServletRequest;
103 import javax.servlet.http.HttpSession;
104
105 import org.apache.commons.fileupload.FileItem;
106 import org.apache.commons.lang.StringUtils;
107
108
109
110
111
112
113 public class CalendarJspBean extends PluginAdminPageJspBean
114 {
115
116
117
118 public static final String PROPERTY_TIME_INTERVAL_LIST = "calendar.interval.time";
119 public static final String PROPERTY_TOP_EVENT_LIST = "calendar.topevent.values";
120 public static final String PROPERTY_EVENT_STATUS_LIST = "calendar.event.status.list";
121 public static final String PROPERTY_EVENT_STATUS_VALUES = "calendar.event.status.values";
122 public static final String PROPERTY_TOP_EVENT_DEFAULT = "calendar.topevent.default";
123 public static final String PROPERTY_EMAIL_NOTIFY = "calendar.email.notify";
124 public static final String PROPERTY_TAGS_REGEXP = "[0-9\\p{L}\\p{M}\\s\\-\\_]*";
125
126
127 public static final String RIGHT_MANAGE_CALENDAR = "CALENDAR_MANAGEMENT";
128
129
130 public static final String ATTRIBUTE_MODULE_DOCUMENT_TO_CALENDAR_CONTENT_FILE = "lutece_document_calendar_content_file";
131 public static final String ATTRIBUTE_MODULE_DOCUMENT_TO_CALENDAR_MIME_TYPE_FILE = "lutece_document_calendar_mime_type_file";
132
133
134
135
136 private static final long serialVersionUID = 7168759278389663673L;
137
138 private static final String PROPERTY_LIMIT_MAX_SUSCRIBER = "calendar.limit.max";
139 private static final String PROPERTY_LIMIT_MIN_SUSCRIBER = "calendar.limit.min";
140
141
142 private static final String TEMPLATE_MANAGE_CALENDARS = "admin/plugins/calendar/manage_calendars.html";
143 private static final String TEMPLATE_MANAGE_ADVANCED_PARAMETERS = "admin/plugins/calendar/manage_advanced_parameters.html";
144 private static final String TEMPLATE_CREATE_CALENDAR = "admin/plugins/calendar/create_calendar.html";
145 private static final String TEMPLATE_MODIFY_CALENDAR = "admin/plugins/calendar/modify_calendar.html";
146 private static final String TEMPLATE_CREATE_EVENT = "admin/plugins/calendar/create_event.html";
147 private static final String TEMPLATE_MODIFY_EVENT = "admin/plugins/calendar/modify_event.html";
148 private static final String TEMPLATE_MODIFY_OCCURRENCE = "admin/plugins/calendar/modify_occurrence.html";
149 private static final String TEMPLATE_MANAGE_SUBSCRIBERS = "admin/plugins/calendar/manage_subscribers.html";
150 private static final String TEMPLATE_EVENT_LIST = "admin/plugins/calendar/event_list.html";
151 private static final String TEMPLATE_OCCURRENCE_LIST = "admin/plugins/calendar/occurrence_list.html";
152 private static final String MARK_INTERVAL_LIST = "interval_list";
153 private static final String MARK_NUMBER_DAYS = "number_days";
154 private static final String MARK_INTERVAL_TIME_SPAN = "time_span";
155 private static final String MARK_TOP_EVENT_LIST = "top_event_list";
156 private static final String MARK_TOP_EVENT_DEFAULT = "top_event_default";
157 private static final String MARK_EVENT_STATUS_LIST = "event_status_list";
158 private static final String MARK_DEFAULT_STATUS = "default_status";
159 private static final String MARK_EMAIL_NOTIFY = "notify";
160 private static final String MARK_INSERT_SERVICE_PAGE = "insert_service_page";
161 private static final String MARK_INSERT_SERVICE_LINK_PAGE = "insert_service_link_page";
162 private static final String MARK_WEBAPP_URL = "webapp_url";
163
164
165 private static final String JSP_DO_REMOVE_CALENDAR = "jsp/admin/plugins/calendar/DoRemoveCalendar.jsp";
166 private static final String JSP_DO_REMOVE_EVENT = "jsp/admin/plugins/calendar/DoRemoveEvent.jsp";
167 private static final String JSP_DO_REMOVE_OCCURRENCE = "jsp/admin/plugins/calendar/DoRemoveOccurrence.jsp";
168 private static final String DO_MODIFY_EVENT = "DoModifyEvent.jsp?plugin_name=calendar&calendar_id=";
169 private static final String JSP_MODIFY_CALENDAR = "jsp/admin/plugins/calendar/ModifyCalendar.jsp";
170 private static final String JSP_EVENT_LIST = "EventList.jsp?plugin_name=calendar&calendar_id=";
171 private static final String JSP_EVENT_LIST2 = "jsp/admin/plugins/calendar/EventList.jsp?plugin_name=calendar&calendar_id=";
172 private static final String JSP_OCCURRENCE_LIST = "jsp/admin/plugins/calendar/OccurrenceList.jsp?plugin_name=calendar&calendar_id=";
173 private static final String JSP_OCCURRENCE_LIST2 = "OccurrenceList.jsp?plugin_name=calendar&calendar_id=";
174 private static final String JSP_URL_DO_REMOVE_SUBSCRIBER = "jsp/admin/plugins/calendar/DoUnsubscribeCalendarAdmin.jsp";
175 private static final String JSP_MANAGE_SUBSCRIBERS_LIST = "ManageSubscribers.jsp?calendar_id=";
176 private static final String JSP_GET_DOCUMENT_INSERT_SERVICE = "modules/document/SelectDocument.jsp";
177 private static final String JSP_GET_DOCUMENT_INSERT_LINK_SERVICE = "jsp/admin/insert/GetAvailableInsertServices.jsp";
178 private static final String JSP_GET_INSERT_SERVICE = "jsp/admin/plugins/calendar/GetInsertService.jsp";
179 private static final String JSP_GET_INSERT_LINK_SERVICE = "jsp/admin/plugins/calendar/GetInsertLinkService.jsp";
180 private static final String JSP_MANAGE_CALENDAR = "jsp/admin/plugins/calendar/ManageCalendars.jsp";
181 private static final String JSP_DO_MODIFY_OCCURRENCE_STATUS = "jsp/admin/plugins/calendar/DoModifyOccurrenceStatus.jsp";
182 private static final String JSP_URL_MANAGE_ADVANCED_PARAMETERS = "jsp/admin/plugins/calendar/ManageAdvancedParameters.jsp?plugin_name=calendar";
183
184
185 private static final String MESSAGE_CONFIRM_REMOVE_CALENDAR = "calendar.message.confirmRemoveCalendar";
186 private static final String MESSAGE_CONFIRM_REMOVE_EVENT = "calendar.message.confirmRemoveEvent";
187 private static final String MESSAGE_CONFIRM_REMOVE_OCCURRENCE = "calendar.message.confirmRemoveOccurrence";
188 private static final String MESSAGE_CONFIRM_REMOVE_ALL_OCCURRENCE = "calendar.message.confirmRemoveAllOccurrence";
189 private static final String EXT_IMAGE_FILES = ".png";
190 private static final String MESSAGE_INVALID_OCCURRENCE_NUMBER = "calendar.message.invalidOccurrenceNumber";
191 private static final String MESSAGE_INVALID_TAG = "calendar.message.invalidTagsInput";
192 private static final String MESSAGE_CONFIRM_REMOVE_SUBSCRIBER = "calendar.message.confirmRemoveSubscriber";
193 private static final String MESSAGE_PLUGIN_DOCUMENT_UNINSTALLED = "calendar.message.plugin-document.uninstalled";
194 private static final String MESSAGE_CONFIRM_MODIFY_OCCURRENCES_STATUS = "calendar.message.confirmModifyOccurrenceStatus";
195 private static final String MESSAGE_INVALID_NUMBER_FORMAT = "calendar.message.invalidNumBerFormat";
196
197 private String _strCurrentPageIndex;
198 private int _nItemsPerPage;
199 private int _nDefaultItemsPerPage;
200 private FileItem _EventItem;
201 private String[] _EventCategories;
202 private String _EventDescription;
203 private Map<String, Object> _mapParameters;
204 private CategoryService _categoryService = CategoryService.getInstance( );
205 private AgendaSubscriberService _agendaSubscriberService = AgendaSubscriberService.getInstance( );
206 private EventListService _eventListService = SpringContextService
207 .getBean( Constants.BEAN_CALENDAR_EVENTLISTSERVICE );
208 private CalendarService _calendarService = SpringContextService.getBean( Constants.BEAN_CALENDAR_CALENDARSERVICE );
209
210
211
212
213
214 public CalendarJspBean( )
215 {
216 _nDefaultItemsPerPage = AppPropertiesService.getPropertyInt( Constants.PROPERTY_EVENTS_PER_PAGE, 5 );
217 }
218
219
220
221
222
223
224
225 public String getManageCalendars( HttpServletRequest request )
226 {
227 setPageTitleProperty( Constants.PROPERTY_PAGE_TITLE_MANAGE_CALENDARS );
228 _strCurrentPageIndex = Paginator.getPageIndex( request, Paginator.PARAMETER_PAGE_INDEX, _strCurrentPageIndex );
229 _nItemsPerPage = Paginator.getItemsPerPage( request, Paginator.PARAMETER_ITEMS_PER_PAGE, _nItemsPerPage,
230 _nDefaultItemsPerPage );
231
232 Map<String, Object> model = new HashMap<String, Object>( );
233 List<AgendaResource> listCalendar = _calendarService.getAgendaResources( getUser( ), getPlugin( ) );
234
235 LocalizedPaginator<AgendaResource> paginator = new LocalizedPaginator<AgendaResource>( listCalendar,
236 _nItemsPerPage, getHomeUrl( request ), Constants.PARAMETER_PAGE_INDEX, _strCurrentPageIndex,
237 getLocale( ) );
238
239 boolean bPermissionAdvancedParameter = RBACService.isAuthorized( CalendarResourceIdService.RESOURCE_TYPE,
240 RBAC.WILDCARD_RESOURCES_ID, CalendarResourceIdService.PERMISSION_MANAGE, getUser( ) );
241
242 model.put( Constants.MARK_CALENDARS_LIST, listCalendar );
243 model.put( Constants.MARK_PAGINATOR, paginator );
244 model.put( Constants.MARK_NB_ITEMS_PER_PAGE, "" + _nItemsPerPage );
245 model.put( Constants.MARK_PERMISSION_ADVANCED_PARAMETER, bPermissionAdvancedParameter );
246
247 HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_MANAGE_CALENDARS, getLocale( ), model );
248
249 return getAdminPage( template.getHtml( ) );
250 }
251
252
253
254
255
256
257
258
259 public String getManageAdvancedParameters( HttpServletRequest request ) throws AccessDeniedException
260 {
261 if ( !RBACService.isAuthorized( CalendarResourceIdService.RESOURCE_TYPE, RBAC.WILDCARD_RESOURCES_ID,
262 CalendarResourceIdService.PERMISSION_MANAGE, getUser( ) ) )
263 {
264 throw new AccessDeniedException( );
265 }
266 Map<String, Object> model = new HashMap<String, Object>( );
267 model.put( Constants.MARK_CALENDAR_PARAMETERS, _calendarService.getCalendarParameters( getPlugin( ) ) );
268 HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_MANAGE_ADVANCED_PARAMETERS, getLocale( ),
269 model );
270
271 return getAdminPage( template.getHtml( ) );
272 }
273
274
275
276
277
278
279
280 public String getCreateCalendar( HttpServletRequest request )
281 {
282 setPageTitleProperty( Constants.PROPERTY_PAGE_TITLE_CREATE_CALENDAR );
283
284 Map<String, Object> model = new HashMap<String, Object>( );
285 ReferenceList ref = null;
286
287 try
288 {
289 AdminUser adminUser = getUser( );
290 Locale locale = getLocale( );
291 ref = AdminWorkgroupService.getUserWorkgroups( adminUser, locale );
292 }
293 catch ( RuntimeException e )
294 {
295 throw new AppException( e.getMessage( ), e );
296 }
297
298 model.put( Constants.MARK_DOTS_LIST, getDotsList( ) );
299 model.put( Constants.MARK_WORKGROUPS_LIST, ref );
300 model.put( Constants.MARK_ROLES_LIST, RoleHome.getRolesList( ) );
301
302 HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_CREATE_CALENDAR, getLocale( ), model );
303
304 return getAdminPage( template.getHtml( ) );
305 }
306
307
308
309
310
311
312
313 public String doCreateCalendar( HttpServletRequest request )
314 {
315 String strJspReturn = StringUtils.EMPTY;
316 String strName = request.getParameter( Constants.PARAMETER_CALENDAR_NAME );
317 String strImage = request.getParameter( Constants.PARAMETER_CALENDAR_IMAGE );
318 String strWorkgroup = request.getParameter( Constants.PARAMETER_WORKGROUP );
319 String strIsNotify = request.getParameter( Constants.PARAMETER_CALENDAR_NOTIFICATION );
320 boolean bIsNotify = ( strIsNotify != null );
321 String strPeriodValidity = request.getParameter( Constants.PARAMETER_CALENDAR_PERIOD );
322
323
324 if ( StringUtils.isNotBlank( strName ) && StringUtils.isNotBlank( strImage )
325 && !( bIsNotify && StringUtils.isBlank( strPeriodValidity ) ) )
326 {
327 int nPeriodValidity = -1;
328 if ( bIsNotify )
329 {
330 if ( strPeriodValidity.matches( Constants.REG_NUMBER ) )
331 {
332 nPeriodValidity = StringUtil.getIntValue( strPeriodValidity, -1 );
333 }
334 else
335 {
336 return AdminMessageService.getMessageUrl( request, MESSAGE_INVALID_NUMBER_FORMAT,
337 AdminMessage.TYPE_STOP );
338 }
339 }
340
341 AgendaResource calendar = new AgendaResource( );
342 calendar.setName( strName );
343 calendar.setEventImage( strImage );
344 calendar.setEventPrefix( request.getParameter( Constants.PARAMETER_CALENDAR_PREFIX ) );
345 calendar.setRole( request.getParameter( Constants.PARAMETER_CALENDAR_ROLE ) );
346 calendar.setWorkgroup( strWorkgroup );
347 calendar.setRoleManager( request.getParameter( Constants.PARAMETER_CALENDAR_ROLE_MANAGER ) );
348 calendar.setNotify( bIsNotify );
349 calendar.setPeriodValidity( bIsNotify ? nPeriodValidity : -1 );
350 _calendarService.doCreateAgenda( calendar, getPlugin( ) );
351
352 strJspReturn = AppPathService.getBaseUrl( request ) + JSP_MANAGE_CALENDAR;
353 }
354 else
355 {
356 strJspReturn = AdminMessageService.getMessageUrl( request, Messages.MANDATORY_FIELDS,
357 AdminMessage.TYPE_STOP );
358 }
359 return strJspReturn;
360 }
361
362
363
364
365
366
367
368 public String getModifyCalendar( HttpServletRequest request )
369 {
370 String strHtml = StringUtils.EMPTY;
371 setPageTitleProperty( Constants.PROPERTY_PAGE_TITLE_MODIFY_CALENDAR );
372
373 String strCalendarId = request.getParameter( Constants.PARAMETER_CALENDAR_ID );
374 if ( StringUtils.isNotBlank( strCalendarId ) && StringUtils.isNumeric( strCalendarId ) )
375 {
376 int nCalendarId = Integer.parseInt( strCalendarId );
377 String strSortEvents = request.getParameter( Constants.PARAMETER_SORT_EVENTS );
378 int nSortEvents = Constants.SORT_ASC;
379 if ( StringUtils.isNotBlank( strSortEvents ) && StringUtils.isNumeric( strSortEvents ) )
380 {
381 nSortEvents = Integer.parseInt( strSortEvents );
382 }
383
384 Map<String, Object> model = new HashMap<String, Object>( );
385 model.put( Constants.MARK_CALENDAR, _calendarService.getAgendaResource( nCalendarId ) );
386 model.put( Constants.MARK_WORKGROUPS_LIST,
387 AdminWorkgroupService.getUserWorkgroups( getUser( ), getLocale( ) ) );
388 model.put( Constants.MARK_DOTS_LIST, getDotsList( ) );
389
390 List<SimpleEvent> listEvents = _eventListService.getSimpleEvents( nCalendarId, nSortEvents );
391
392
393 _strCurrentPageIndex = Paginator.getPageIndex( request, Paginator.PARAMETER_PAGE_INDEX,
394 _strCurrentPageIndex );
395 _nItemsPerPage = Paginator.getItemsPerPage( request, Paginator.PARAMETER_ITEMS_PER_PAGE, _nItemsPerPage,
396 _nDefaultItemsPerPage );
397
398 UrlItem url = new UrlItem( JSP_MODIFY_CALENDAR );
399 url.addParameter( Constants.PARAMETER_CALENDAR_ID, nCalendarId );
400 url.addParameter( Constants.PARAMETER_SORT_EVENTS, nSortEvents );
401
402 LocalizedPaginator<SimpleEvent> paginator = new LocalizedPaginator<SimpleEvent>( listEvents,
403 _nItemsPerPage, url.getUrl( ), Paginator.PARAMETER_PAGE_INDEX, _strCurrentPageIndex, getLocale( ) );
404
405 model.put( Constants.MARK_PAGINATOR, paginator );
406 model.put( Constants.MARK_NB_ITEMS_PER_PAGE, Integer.toString( _nItemsPerPage ) );
407 model.put( Constants.MARK_EVENTS_LIST, paginator.getPageItems( ) );
408 model.put( Constants.MARK_EVENTS_SORT_LIST, getSortEventList( ) );
409 model.put( Constants.MARK_DEFAULT_SORT_EVENT, nSortEvents );
410 model.put( Constants.MARK_ROLES_LIST, RoleHome.getRolesList( ) );
411
412 HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_MODIFY_CALENDAR, getLocale( ), model );
413
414 strHtml = getAdminPage( template.getHtml( ) );
415 }
416 else
417 {
418 strHtml = getManageCalendars( request );
419 }
420 return strHtml;
421 }
422
423
424
425
426
427
428
429 public String doModifyCalendar( HttpServletRequest request )
430 {
431 String strJspReturn = StringUtils.EMPTY;
432
433 String strName = request.getParameter( Constants.PARAMETER_CALENDAR_NAME );
434 String strWorkgroup = request.getParameter( Constants.PARAMETER_WORKGROUP );
435 String strImage = request.getParameter( Constants.PARAMETER_CALENDAR_IMAGE );
436 String strIsNotify = request.getParameter( Constants.PARAMETER_CALENDAR_NOTIFICATION );
437 String strCalendarId = request.getParameter( Constants.PARAMETER_CALENDAR_ID );
438 boolean bIsNotify = ( strIsNotify != null );
439 String strPeriodValidity = request.getParameter( Constants.PARAMETER_CALENDAR_PERIOD );
440 int nPeriodValidity = -1;
441
442
443 if ( StringUtils.isNotBlank( strName ) && StringUtils.isNotBlank( strImage )
444 && StringUtils.isNotBlank( strCalendarId ) && StringUtils.isNumeric( strCalendarId )
445 && !( bIsNotify && StringUtils.isBlank( strPeriodValidity ) ) )
446 {
447 if ( bIsNotify )
448 {
449 if ( strPeriodValidity.matches( Constants.REG_NUMBER ) )
450 {
451 nPeriodValidity = StringUtil.getIntValue( strPeriodValidity, -1 );
452 }
453 else
454 {
455 return AdminMessageService.getMessageUrl( request, MESSAGE_INVALID_NUMBER_FORMAT,
456 AdminMessage.TYPE_STOP );
457 }
458 }
459
460 int nCalendarId = Integer.parseInt( strCalendarId );
461
462 AgendaResource calendar = _calendarService.getAgendaResource( nCalendarId );
463
464 calendar.setName( strName );
465 calendar.setEventImage( strImage );
466 calendar.setEventPrefix( request.getParameter( Constants.PARAMETER_CALENDAR_PREFIX ) );
467 calendar.setRole( request.getParameter( Constants.PARAMETER_CALENDAR_ROLE ) );
468 calendar.setRoleManager( request.getParameter( Constants.PARAMETER_CALENDAR_ROLE_MANAGER ) );
469 calendar.setWorkgroup( strWorkgroup );
470 calendar.setNotify( bIsNotify );
471 calendar.setPeriodValidity( nPeriodValidity );
472 _calendarService.doModifyAgenda( calendar, getPlugin( ) );
473
474 strJspReturn = AppPathService.getBaseUrl( request ) + JSP_MANAGE_CALENDAR;
475 }
476 else
477 {
478 strJspReturn = AdminMessageService.getMessageUrl( request, Messages.MANDATORY_FIELDS,
479 AdminMessage.TYPE_STOP );
480 }
481
482 return strJspReturn;
483 }
484
485
486
487
488
489
490
491 public String getConfirmRemoveCalendar( HttpServletRequest request )
492 {
493 UrlItem url = new UrlItem( JSP_DO_REMOVE_CALENDAR );
494 url.addParameter( Constants.PARAMETER_CALENDAR_ID,
495 Integer.parseInt( request.getParameter( Constants.PARAMETER_CALENDAR_ID ) ) );
496
497 return AdminMessageService.getMessageUrl( request, MESSAGE_CONFIRM_REMOVE_CALENDAR, url.getUrl( ),
498 AdminMessage.TYPE_CONFIRMATION );
499 }
500
501
502
503
504
505
506
507 public String doRemoveCalendar( HttpServletRequest request )
508 {
509 String strJspReturn = StringUtils.EMPTY;
510 String strCalendarId = request.getParameter( Constants.PARAMETER_CALENDAR_ID );
511 if ( StringUtils.isNotBlank( strCalendarId ) && StringUtils.isNumeric( strCalendarId ) )
512 {
513 int nCalendarId = Integer.parseInt( strCalendarId );
514 List<SimpleEvent> listEvents = _eventListService.getSimpleEvents( nCalendarId, Constants.SORT_ASC );
515
516 for ( SimpleEvent event : listEvents )
517 {
518 List<OccurrenceEvent> listOccurencesEvent = _eventListService.getOccurrenceEvents( nCalendarId,
519 event.getId( ), Constants.SORT_ASC, getPlugin( ) );
520
521 for ( OccurrenceEvent occ : listOccurencesEvent )
522 {
523 IndexationService.addIndexerAction( Integer.toString( occ.getId( ) ),
524 AppPropertiesService.getProperty( CalendarIndexer.PROPERTY_INDEXER_NAME ),
525 IndexerAction.TASK_DELETE );
526 CalendarIndexerUtils.addIndexerAction( occ.getId( ), IndexerAction.TASK_DELETE );
527 }
528 _eventListService.doRemoveEvent( nCalendarId, event.getId( ), null, getPlugin( ) );
529 }
530
531 _calendarService.doRemoveAgenda( nCalendarId, getPlugin( ) );
532
533
534 strJspReturn = AppPathService.getBaseUrl( request ) + JSP_MANAGE_CALENDAR;
535 }
536 else
537 {
538 strJspReturn = AdminMessageService.getMessageUrl( request, MESSAGE_INVALID_NUMBER_FORMAT,
539 AdminMessage.TYPE_STOP );
540 }
541
542 return strJspReturn;
543 }
544
545
546
547
548
549
550
551 public String getCreateEvent( HttpServletRequest request )
552 {
553 String strHtml = StringUtils.EMPTY;
554 String strCalendarId = request.getParameter( Constants.PARAMETER_CALENDAR_ID );
555 if ( StringUtils.isNotBlank( strCalendarId ) && StringUtils.isNumeric( strCalendarId ) )
556 {
557 int nCalendarId = Integer.parseInt( strCalendarId );
558 setPageTitleProperty( Constants.PROPERTY_PAGE_TITLE_CREATE_EVENT );
559
560
561 int nDays = 1;
562
563
564 Collection<Category> categoryList = _categoryService.getCategories( getPlugin( ) );
565
566 Map<String, Object> model = new HashMap<String, Object>( );
567
568 String strBooleanTimeSpan = Constants.TRUE;
569 model.put( MARK_INTERVAL_TIME_SPAN, strBooleanTimeSpan );
570 model.put( Constants.MARK_CALENDAR_ID, nCalendarId );
571 model.put( Constants.MARK_LOCALE, getLocale( ).getLanguage( ) );
572 model.put( MARK_INTERVAL_LIST, getIntervalList( request ) );
573 model.put( MARK_NUMBER_DAYS, nDays );
574 model.put( MARK_INTERVAL_LIST, getIntervalList( request ) );
575 model.put( MARK_TOP_EVENT_LIST, getTopEventList( ) );
576 model.put( MARK_EMAIL_NOTIFY, AppPropertiesService.getProperty( PROPERTY_EMAIL_NOTIFY ) );
577 model.put( MARK_TOP_EVENT_DEFAULT, AppPropertiesService.getProperty( PROPERTY_TOP_EVENT_DEFAULT ) );
578 model.put( MARK_TOP_EVENT_DEFAULT, AppPropertiesService.getProperty( PROPERTY_TOP_EVENT_DEFAULT ) );
579 model.put( MARK_INSERT_SERVICE_PAGE, JSP_GET_INSERT_SERVICE );
580 model.put( MARK_INSERT_SERVICE_LINK_PAGE, JSP_GET_INSERT_LINK_SERVICE );
581 model.put( MARK_WEBAPP_URL, AppPathService.getBaseUrl( request ) );
582 model.put( Constants.MARK_CATEGORY_LIST, new HashMap<String, Object>( ) );
583 model.put( Constants.MARK_CATEGORY_DEFAULT_LIST, categoryList );
584
585 HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_CREATE_EVENT, getLocale( ), model );
586
587 strHtml = getAdminPage( template.getHtml( ) );
588 }
589 else
590 {
591 strHtml = getManageCalendars( request );
592 }
593 return strHtml;
594 }
595
596
597
598
599
600
601 public String getEventList( HttpServletRequest request )
602 {
603 String strHtml = StringUtils.EMPTY;
604 String strCalendarId = request.getParameter( Constants.PARAMETER_CALENDAR_ID );
605 if ( StringUtils.isNotBlank( strCalendarId ) && StringUtils.isNumeric( strCalendarId ) )
606 {
607 int nCalendarId = Integer.parseInt( strCalendarId );
608
609 Map<String, Object> model = new HashMap<String, Object>( );
610 model.put( Constants.MARK_CALENDAR_ID, nCalendarId );
611
612 List<SimpleEvent> listEvents = null;
613
614
615 String strSortedAttributeName = request.getParameter( Parameters.SORTED_ATTRIBUTE_NAME );
616 String strAscSort = request.getParameter( Parameters.SORTED_ASC );
617 if ( StringUtils.isNotBlank( strSortedAttributeName ) )
618 {
619 boolean bIsAscSort = Boolean.parseBoolean( strAscSort );
620 int nIsAscSort = bIsAscSort ? Constants.SORT_ASC : Constants.SORT_DESC;
621 listEvents = _eventListService.getSimpleEvents( nCalendarId, nIsAscSort );
622 if ( !Constants.PARAMETER_DATE.equals( strSortedAttributeName ) )
623 {
624 Collections.sort( listEvents, new AttributeComparator( strSortedAttributeName, bIsAscSort ) );
625 }
626 }
627 else
628 {
629 listEvents = _eventListService.getSimpleEvents( nCalendarId, Constants.SORT_ASC );
630 }
631
632
633 _strCurrentPageIndex = Paginator.getPageIndex( request, Paginator.PARAMETER_PAGE_INDEX,
634 _strCurrentPageIndex );
635 _nItemsPerPage = Paginator.getItemsPerPage( request, Paginator.PARAMETER_ITEMS_PER_PAGE, _nItemsPerPage,
636 _nDefaultItemsPerPage );
637
638 String strURL = AppPathService.getBaseUrl( request ) + JSP_EVENT_LIST2 + nCalendarId;
639 UrlItem url = new UrlItem( strURL );
640 url.addParameter( Constants.PARAMETER_CALENDAR_ID, nCalendarId );
641 if ( StringUtils.isNotBlank( strSortedAttributeName ) )
642 {
643 url.addParameter( Parameters.SORTED_ATTRIBUTE_NAME, strSortedAttributeName );
644 }
645
646 if ( StringUtils.isNotBlank( strAscSort ) )
647 {
648 url.addParameter( Parameters.SORTED_ASC, strAscSort );
649 }
650
651 LocalizedPaginator<SimpleEvent> paginator = new LocalizedPaginator<SimpleEvent>( listEvents,
652 _nItemsPerPage, url.getUrl( ), Paginator.PARAMETER_PAGE_INDEX, _strCurrentPageIndex, getLocale( ) );
653
654 model.put( Constants.MARK_CALENDAR, CalendarHome.findAgendaResource( nCalendarId, getPlugin( ) ) );
655 model.put( Constants.MARK_PAGINATOR, paginator );
656 model.put( Constants.MARK_NB_ITEMS_PER_PAGE, Integer.toString( _nItemsPerPage ) );
657 model.put( Constants.MARK_EVENTS_LIST, paginator.getPageItems( ) );
658 model.put( Constants.MARK_EVENTS_SORT_LIST, getSortEventList( ) );
659 model.put( Constants.MARK_ROLES_LIST, RoleHome.getRolesList( ) );
660
661 HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_EVENT_LIST, getLocale( ), model );
662
663 strHtml = getAdminPage( template.getHtml( ) );
664 }
665 else
666 {
667 strHtml = getManageCalendars( request );
668 }
669 return strHtml;
670 }
671
672
673
674
675
676
677 public String getOccurrenceList( HttpServletRequest request )
678 {
679 String strCalendarId = request.getParameter( Constants.PARAMETER_CALENDAR_ID );
680 String strEventId = request.getParameter( Constants.PARAMETER_EVENT_ID );
681 if ( StringUtils.isNotBlank( strCalendarId ) && StringUtils.isNumeric( strCalendarId )
682 && StringUtils.isNotBlank( strEventId ) && StringUtils.isNumeric( strEventId ) )
683 {
684 int nCalendarId = Integer.parseInt( strCalendarId );
685 int nEventId = Integer.parseInt( strEventId );
686
687 SimpleEvent event = _eventListService.getEvent( nEventId, getPlugin( ) );
688 int nDays = _eventListService.getRepititionDays( nEventId, getPlugin( ) );
689 Map<String, Object> model = new HashMap<String, Object>( );
690 List<OccurrenceEvent> listOccurrences = null;
691
692
693 String strSortedAttributeName = request.getParameter( Parameters.SORTED_ATTRIBUTE_NAME );
694 String strAscSort = request.getParameter( Parameters.SORTED_ASC );
695 if ( StringUtils.isNotBlank( strSortedAttributeName ) )
696 {
697 boolean bIsAscSort = Boolean.parseBoolean( strAscSort );
698 int nIsAscSort = bIsAscSort ? Constants.SORT_ASC : Constants.SORT_DESC;
699 listOccurrences = _eventListService
700 .getOccurrenceEvents( nCalendarId, nEventId, nIsAscSort, getPlugin( ) );
701 if ( !Constants.PARAMETER_DATE.equals( strSortedAttributeName ) )
702 {
703 Collections.sort( listOccurrences, new AttributeComparator( strSortedAttributeName, bIsAscSort ) );
704 }
705 }
706 else
707 {
708 listOccurrences = _eventListService.getOccurrenceEvents( nCalendarId, nEventId, Constants.SORT_ASC,
709 getPlugin( ) );
710 }
711
712
713 _strCurrentPageIndex = Paginator.getPageIndex( request, Paginator.PARAMETER_PAGE_INDEX,
714 _strCurrentPageIndex );
715 _nItemsPerPage = Paginator.getItemsPerPage( request, Paginator.PARAMETER_ITEMS_PER_PAGE, _nItemsPerPage,
716 _nDefaultItemsPerPage );
717
718 String strURL = AppPathService.getBaseUrl( request ) + JSP_OCCURRENCE_LIST + nCalendarId;
719 UrlItem url = new UrlItem( strURL );
720 url.addParameter( Constants.PARAMETER_EVENT_ID, event.getId( ) );
721 if ( StringUtils.isNotBlank( strSortedAttributeName ) )
722 {
723 url.addParameter( Parameters.SORTED_ATTRIBUTE_NAME, strSortedAttributeName );
724 }
725
726 if ( StringUtils.isNotBlank( strAscSort ) )
727 {
728 url.addParameter( Parameters.SORTED_ASC, strAscSort );
729 }
730
731 LocalizedPaginator<OccurrenceEvent> paginator = new LocalizedPaginator<OccurrenceEvent>( listOccurrences,
732 _nItemsPerPage, url.getUrl( ), Paginator.PARAMETER_PAGE_INDEX, _strCurrentPageIndex, getLocale( ) );
733
734 model.put( Constants.MARK_EVENT, event );
735 model.put( Constants.MARK_CALENDAR_ID, nCalendarId );
736 model.put( Constants.MARK_PAGINATOR, paginator );
737 model.put( Constants.MARK_NB_ITEMS_PER_PAGE, "" + _nItemsPerPage );
738 model.put( Constants.MARK_OCCURRENCES_LIST, paginator.getPageItems( ) );
739 model.put( Constants.MARK_EVENTS_SORT_LIST, getSortEventList( ) );
740 model.put( MARK_INTERVAL_LIST, getIntervalList( request ) );
741 model.put( MARK_NUMBER_DAYS, nDays );
742 model.put( MARK_EVENT_STATUS_LIST, getStatusList( request ) );
743 model.put( MARK_DEFAULT_STATUS, AppPropertiesService.getProperty( Constants.PROPERTY_EVENT_STATUS_DEFAULT ) );
744
745 HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_OCCURRENCE_LIST, getLocale( ), model );
746
747 return getAdminPage( template.getHtml( ) );
748 }
749 return getManageCalendars( request );
750 }
751
752
753
754
755
756
757
758 public String doCreateEvent( HttpServletRequest request )
759 {
760 String strJspReturn = StringUtils.EMPTY;
761 String strCalendarId = request.getParameter( Constants.PARAMETER_CALENDAR_ID );
762 String strPeriodicity = request.getParameter( Constants.PARAMETER_PERIODICITY );
763 if ( StringUtils.isNotBlank( strCalendarId ) && StringUtils.isNumeric( strCalendarId )
764 && StringUtils.isNotBlank( strPeriodicity ) && StringUtils.isNumeric( strPeriodicity ) )
765 {
766
767 int nCalendarId = Integer.parseInt( strCalendarId );
768 int nPeriodicity = Integer.parseInt( strPeriodicity );
769 String strEventDateEnd = request.getParameter( Constants.PARAMETER_EVENT_DATE_END );
770 String strTimeStart = request.getParameter( Constants.PARAMETER_EVENT_TIME_START );
771 String strTimeEnd = request.getParameter( Constants.PARAMETER_EVENT_TIME_END );
772 String strOccurrence = request.getParameter( Constants.PARAMETER_OCCURRENCE );
773 String strEventTitle = request.getParameter( Constants.PARAMETER_EVENT_TITLE );
774 String strDate = request.getParameter( Constants.PARAMETER_EVENT_DATE );
775 String strNotify = request.getParameter( Constants.PARAMETER_NOTIFY );
776
777
778 String strDescription = request.getParameter( Constants.PARAMETER_DESCRIPTION );
779 String strEventTags = request.getParameter( Constants.PARAMETER_EVENT_TAGS ).trim( );
780 String strLocationAddress = request.getParameter( Constants.PARAMETER_EVENT_LOCATION_ADDRESS ).trim( );
781 String strLocationTown = request.getParameter( Constants.PARAMETER_LOCATION_TOWN ).trim( );
782 String strLocation = request.getParameter( Constants.PARAMETER_LOCATION ).trim( );
783 String strLocationZip = request.getParameter( Constants.PARAMETER_LOCATION_ZIP ).trim( );
784 String strLinkUrl = request.getParameter( Constants.PARAMETER_EVENT_LINK_URL ).trim( );
785 String strDocumentId = request.getParameter( Constants.PARAMETER_EVENT_DOCUMENT_ID ).trim( );
786 String strPageUrl = request.getParameter( Constants.PARAMETER_EVENT_PAGE_URL ).trim( );
787 String strTopEvent = request.getParameter( Constants.PARAMETER_EVENT_TOP_EVENT ).trim( );
788 String strMapUrl = request.getParameter( Constants.PARAMETER_EVENT_MAP_URL ).trim( );
789
790
791 String[] arrayExcludedDays = request.getParameterValues( Constants.PARAMETER_EXCLUDED_DAYS );
792
793 MultipartHttpServletRequest mRequest = (MultipartHttpServletRequest) request;
794 FileItem item = mRequest.getFile( Constants.PARAMETER_EVENT_IMAGE );
795
796 String[] arrayCategory = request.getParameterValues( Constants.PARAMETER_CATEGORY );
797
798
799 List<Category> listCategories = new ArrayList<Category>( );
800
801 if ( arrayCategory != null )
802 {
803 for ( String strIdCategory : arrayCategory )
804 {
805 Category category = CategoryHome.find( Integer.parseInt( strIdCategory ), getPlugin( ) );
806
807 if ( category != null )
808 {
809 listCategories.add( category );
810 }
811 }
812 }
813
814 String[] strTabEventTags = null;
815
816
817 if ( StringUtils.isBlank( strDate ) || StringUtils.isBlank( strEventTitle )
818 || StringUtils.isBlank( strDescription ) )
819 {
820 return AdminMessageService.getMessageUrl( request, Messages.MANDATORY_FIELDS, AdminMessage.TYPE_STOP );
821 }
822
823 if ( StringUtils.isNotBlank( strEventTags ) && strEventTags.length( ) > 0 )
824 {
825
826 boolean isAllowedExp = Pattern.matches( PROPERTY_TAGS_REGEXP, strEventTags );
827
828 if ( !isAllowedExp )
829 {
830 return AdminMessageService.getMessageUrl( request, MESSAGE_INVALID_TAG, AdminMessage.TYPE_STOP );
831 }
832
833 strTabEventTags = strEventTags.split( "\\s" );
834 }
835
836
837 Date dateEvent = DateUtil.formatDate( strDate, getLocale( ) );
838
839 if ( ( dateEvent == null ) || !Utils.isValidDate( dateEvent ) )
840 {
841 return AdminMessageService.getMessageUrl( request, Constants.PROPERTY_MESSAGE_DATEFORMAT,
842 AdminMessage.TYPE_STOP );
843 }
844
845 Date dateEndEvent = null;
846
847 if ( StringUtils.isNotBlank( strEventDateEnd ) )
848 {
849 dateEndEvent = DateUtil.formatDate( strEventDateEnd, getLocale( ) );
850
851 if ( ( dateEndEvent == null ) || !Utils.isValidDate( dateEndEvent ) )
852 {
853 return AdminMessageService.getMessageUrl( request, Constants.PROPERTY_MESSAGE_DATEFORMAT,
854 AdminMessage.TYPE_STOP );
855 }
856 }
857
858
859 int nOccurrence = 1;
860
861 if ( ( strOccurrence.length( ) > 0 ) && !strOccurrence.equals( "" ) )
862 {
863 try
864 {
865 nOccurrence = Integer.parseInt( strOccurrence );
866 }
867 catch ( NumberFormatException e )
868 {
869 return AdminMessageService.getMessageUrl( request, MESSAGE_INVALID_OCCURRENCE_NUMBER,
870 AdminMessage.TYPE_STOP );
871 }
872 }
873
874 int nDocumentId = -1;
875
876 if ( ( strDocumentId.length( ) > 0 ) && !strDocumentId.equals( "" ) )
877 {
878 try
879 {
880 nDocumentId = Integer.parseInt( strDocumentId );
881 }
882 catch ( NumberFormatException e )
883 {
884 return AdminMessageService.getMessageUrl( request, MESSAGE_INVALID_OCCURRENCE_NUMBER,
885 AdminMessage.TYPE_STOP );
886 }
887 }
888
889 if ( !Utils.checkTime( strTimeStart ) || !Utils.checkTime( strTimeEnd ) )
890 {
891 return AdminMessageService.getMessageUrl( request, Constants.PROPERTY_MESSAGE_TIMEFORMAT,
892 AdminMessage.TYPE_STOP );
893 }
894
895
896 if ( ( Integer.parseInt( request.getParameter( Constants.PARAMETER_RADIO_PERIODICITY ) ) == 1 )
897 && StringUtils.isNotBlank( strEventDateEnd ) )
898 {
899 if ( dateEndEvent.before( dateEvent ) )
900 {
901 return AdminMessageService.getMessageUrl( request, Constants.PROPERTY_MESSAGE_DATE_END_BEFORE,
902 AdminMessage.TYPE_STOP );
903 }
904 nPeriodicity = 0;
905 nOccurrence = Utils.getOccurrenceWithinTwoDates( dateEvent, dateEndEvent, arrayExcludedDays );
906 }
907 else if ( ( Integer.parseInt( request.getParameter( Constants.PARAMETER_RADIO_PERIODICITY ) ) == 1 )
908 && StringUtils.isBlank( strEventDateEnd ) )
909 {
910 return AdminMessageService.getMessageUrl( request, Constants.PROPERTY_MESSAGE_DATEFORMAT,
911 AdminMessage.TYPE_STOP );
912 }
913
914
915 if ( ( Integer.parseInt( request.getParameter( Constants.PARAMETER_RADIO_PERIODICITY ) ) == 0 )
916 && StringUtils.isBlank( strEventDateEnd ) )
917 {
918 dateEndEvent = Utils.getDateForward( dateEvent, nPeriodicity, nOccurrence, arrayExcludedDays );
919 if ( dateEndEvent.before( dateEvent ) )
920 {
921 nOccurrence = 0;
922 dateEndEvent = dateEvent;
923 }
924 }
925
926 SimpleEvent event = new SimpleEvent( );
927 event.setDate( dateEvent );
928 event.setDateEnd( dateEndEvent );
929 event.setDateTimeStart( strTimeStart );
930 event.setDateTimeEnd( strTimeEnd );
931 event.setTitle( strEventTitle );
932 event.setOccurrence( nOccurrence );
933 event.setPeriodicity( nPeriodicity );
934 event.setDescription( strDescription );
935
936 if ( item.getSize( ) == 0 )
937 {
938 HttpSession session = request.getSession( true );
939 if ( session.getAttribute( ATTRIBUTE_MODULE_DOCUMENT_TO_CALENDAR_CONTENT_FILE ) != null
940 && session.getAttribute( ATTRIBUTE_MODULE_DOCUMENT_TO_CALENDAR_MIME_TYPE_FILE ) != null )
941 {
942 ImageResource imageResource = new ImageResource( );
943 imageResource.setImage( (byte[]) session
944 .getAttribute( ATTRIBUTE_MODULE_DOCUMENT_TO_CALENDAR_CONTENT_FILE ) );
945 imageResource.setMimeType( (String) session
946 .getAttribute( ATTRIBUTE_MODULE_DOCUMENT_TO_CALENDAR_MIME_TYPE_FILE ) );
947 event.setImageResource( imageResource );
948 session.removeAttribute( ATTRIBUTE_MODULE_DOCUMENT_TO_CALENDAR_CONTENT_FILE );
949 session.removeAttribute( ATTRIBUTE_MODULE_DOCUMENT_TO_CALENDAR_MIME_TYPE_FILE );
950 }
951 }
952
953 if ( item.getSize( ) >= 1 )
954 {
955 ImageResource imageResource = new ImageResource( );
956 imageResource.setImage( item.get( ) );
957 imageResource.setMimeType( item.getContentType( ) );
958 event.setImageResource( imageResource );
959 }
960
961 event.setTags( strTabEventTags );
962 event.setLocationAddress( strLocationAddress );
963 event.setLocation( strLocation );
964 event.setLocationTown( strLocationTown );
965 event.setLocationZip( strLocationZip );
966 event.setLinkUrl( strLinkUrl );
967 event.setPageUrl( strPageUrl );
968 event.setTopEvent( Integer.parseInt( strTopEvent ) );
969 event.setMapUrl( strMapUrl );
970 event.setDocumentId( nDocumentId );
971 event.setListCategories( listCategories );
972 event.setExcludedDays( arrayExcludedDays );
973 event.setIdCalendar( nCalendarId );
974
975 _eventListService.doAddEvent( event, null, getPlugin( ) );
976
977 List<OccurrenceEvent> listOccurencesEvent = _eventListService.getOccurrenceEvents( nCalendarId,
978 event.getId( ), Constants.SORT_ASC, getPlugin( ) );
979
980 for ( OccurrenceEvent occ : listOccurencesEvent )
981 {
982 IndexationService.addIndexerAction( Integer.toString( occ.getId( ) ),
983 AppPropertiesService.getProperty( CalendarIndexer.PROPERTY_INDEXER_NAME ),
984 IndexerAction.TASK_CREATE );
985 CalendarIndexerUtils.addIndexerAction( occ.getId( ), IndexerAction.TASK_CREATE );
986 }
987
988
989
990
991
992
993
994
995 boolean isNotify = Boolean.parseBoolean( strNotify );
996
997 if ( isNotify )
998 {
999 int nSubscriber = _agendaSubscriberService.getSubscriberNumber( nCalendarId, getPlugin( ) );
1000
1001 if ( nSubscriber > 0 )
1002 {
1003 Collection<CalendarSubscriber> calendarSubscribers = _agendaSubscriberService.getSubscribers(
1004 nCalendarId, getPlugin( ) );
1005 _agendaSubscriberService.sendSubscriberMail( request, calendarSubscribers, event, nCalendarId );
1006 }
1007 }
1008
1009 strJspReturn = AppPathService.getBaseUrl( request ) + JSP_EVENT_LIST2 + nCalendarId;
1010 }
1011 else
1012 {
1013 strJspReturn = AdminMessageService.getMessageUrl( request, MESSAGE_INVALID_NUMBER_FORMAT,
1014 AdminMessage.TYPE_STOP );
1015 }
1016 return strJspReturn;
1017
1018 }
1019
1020
1021
1022
1023
1024
1025
1026 public String getModifyEvent( HttpServletRequest request )
1027 {
1028 setPageTitleProperty( Constants.PROPERTY_PAGE_TITLE_MODIFY_EVENT );
1029
1030
1031
1032 int nCalendarId = Integer.parseInt( request.getParameter( Constants.PARAMETER_CALENDAR_ID ) );
1033 String strEventId = request.getParameter( Constants.PARAMETER_EVENT_ID );
1034 int nIdEvent = Integer.parseInt( strEventId );
1035
1036 int nDays = CalendarHome.getRepetitionDays( nIdEvent, getPlugin( ) );
1037
1038 SimpleEvent event = CalendarHome.findEvent( nIdEvent, getPlugin( ) );
1039 event.setImageUrl( EventImageResourceService.getInstance( ).getResourceImageEvent( event.getId( ) ) );
1040
1041 Map<String, Object> model = new HashMap<String, Object>( );
1042
1043 String strBooleanTimeSpan = "TRUE";
1044
1045 if ( nDays <= 0 )
1046 {
1047 strBooleanTimeSpan = "FALSE";
1048 }
1049
1050
1051 String strSortEvents = request.getParameter( Constants.PARAMETER_SORT_EVENTS );
1052 strSortEvents = ( strSortEvents != null ) ? strSortEvents : "1";
1053
1054 Collection<Category> categoryDefaultList = CategoryHome.findAll( getPlugin( ) );
1055 Collection<Category> categoryList = event.getListCategories( );
1056 HashMap<String, Object> mapCategorySelected = new HashMap<String, Object>( );
1057
1058 for ( Category catSelected : categoryList )
1059 {
1060 mapCategorySelected.put( Constants.EMPTY_STRING + catSelected.getId( ), catSelected.getName( ) );
1061 }
1062
1063
1064 model.put( Constants.MARK_CATEGORY_DEFAULT_LIST, categoryDefaultList );
1065
1066 model.put( Constants.MARK_CATEGORY_LIST, mapCategorySelected );
1067
1068 model.put( MARK_INTERVAL_TIME_SPAN, strBooleanTimeSpan );
1069
1070
1071
1072
1073
1074
1075 model.put( Constants.MARK_EVENT_DATE_END, event.getDateEnd( ) );
1076 model.put( Constants.MARK_EVENT, event );
1077 model.put( Constants.MARK_CALENDAR_ID, nCalendarId );
1078 model.put( Constants.MARK_DEFAULT_SORT_EVENT, request.getParameter( Constants.PARAMETER_SORT_EVENTS ) );
1079 model.put( Constants.MARK_LOCALE, getLocale( ).getLanguage( ) );
1080 model.put( MARK_INTERVAL_LIST, getIntervalList( request ) );
1081 model.put( MARK_NUMBER_DAYS, nDays );
1082 model.put( Constants.MARK_EVENTS_SORT_LIST, getSortEventList( ) );
1083 model.put( Constants.MARK_DEFAULT_SORT_EVENT, Integer.parseInt( strSortEvents ) );
1084 model.put( MARK_TOP_EVENT_LIST, getTopEventList( ) );
1085 model.put( MARK_TOP_EVENT_DEFAULT, event.getTopEvent( ) );
1086 model.put( MARK_INSERT_SERVICE_PAGE, JSP_GET_INSERT_SERVICE );
1087 model.put( MARK_INSERT_SERVICE_LINK_PAGE, JSP_GET_INSERT_LINK_SERVICE );
1088 model.put( MARK_WEBAPP_URL, AppPathService.getBaseUrl( request ) );
1089
1090 HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_MODIFY_EVENT, getLocale( ), model );
1091
1092 return getAdminPage( template.getHtml( ) );
1093 }
1094
1095
1096
1097
1098
1099
1100
1101 public String doModifyEvent( HttpServletRequest request )
1102 {
1103
1104 SimpleEvent event = CalendarHome.findEvent(
1105 Integer.parseInt( request.getParameter( Constants.PARAMETER_EVENT_ID ) ), getPlugin( ) );
1106
1107
1108 int nCalendarId = Integer.parseInt( request.getParameter( Constants.PARAMETER_CALENDAR_ID ) );
1109
1110 String strEventTitle = (String) _mapParameters.get( Constants.PARAMETER_EVENT_TITLE );
1111 String strTopEvent = (String) _mapParameters.get( Constants.PARAMETER_EVENT_TOP_EVENT );
1112 String strEventDate = (String) _mapParameters.get( Constants.PARAMETER_EVENT_DATE );
1113
1114 boolean bPeriociteModify = false;
1115
1116
1117 if ( strEventDate.equals( "" ) || strEventTitle.equals( "" ) || _EventDescription.equals( "" ) )
1118 {
1119 return AdminMessageService.getMessageUrl( request, Messages.MANDATORY_FIELDS, AdminMessage.TYPE_STOP );
1120 }
1121
1122
1123 Date dateEvent = DateUtil.formatDate( strEventDate, getLocale( ) );
1124 Date dateEventOld = event.getDate( );
1125
1126
1127 if ( dateEvent.getTime( ) != dateEventOld.getTime( ) )
1128 {
1129 bPeriociteModify = true;
1130 }
1131
1132 if ( !Utils.isValidDate( dateEvent ) )
1133 {
1134 return AdminMessageService.getMessageUrl( request, Constants.PROPERTY_MESSAGE_DATEFORMAT,
1135 AdminMessage.TYPE_STOP );
1136 }
1137
1138
1139 event.setDate( dateEvent );
1140 event.setTitle( strEventTitle );
1141 event.setTopEvent( Integer.parseInt( strTopEvent ) );
1142 event.setDescription( _EventDescription );
1143
1144
1145 String strEventDateEnd = (String) _mapParameters.get( Constants.PARAMETER_EVENT_DATE_END );
1146
1147 int nPeriodicity = event.getPeriodicity( );
1148
1149 Date dateEndEvent = null;
1150
1151 if ( StringUtils.isNotEmpty( strEventDateEnd ) )
1152 {
1153 dateEndEvent = DateUtil.formatDate( strEventDateEnd, getLocale( ) );
1154
1155 if ( ( dateEndEvent == null ) || !Utils.isValidDate( dateEndEvent ) )
1156 {
1157 return AdminMessageService.getMessageUrl( request, Constants.PROPERTY_MESSAGE_DATEFORMAT,
1158 AdminMessage.TYPE_STOP );
1159 }
1160 }
1161
1162
1163 int nOccurrence = -1;
1164
1165 String[] arrayExcludedDays = (String[]) _mapParameters.get( Constants.PARAMETER_EXCLUDED_DAYS );
1166 boolean bExcludedDaysModified = false;
1167 if ( arrayExcludedDays == null && event.getExcludedDays( ) != null && event.getExcludedDays( ).length != 0 )
1168 {
1169 bExcludedDaysModified = true;
1170 }
1171 else if ( arrayExcludedDays != null
1172 && ( event.getExcludedDays( ) == null || ( event.getExcludedDays( ) != null && event.getExcludedDays( ).length == 0 ) ) )
1173 {
1174 bExcludedDaysModified = true;
1175 }
1176 else if ( arrayExcludedDays != null && event.getExcludedDays( ) != null
1177 && arrayExcludedDays.length != event.getExcludedDays( ).length )
1178 {
1179 bExcludedDaysModified = true;
1180 }
1181 else if ( arrayExcludedDays != null && event.getExcludedDays( ) != null && event.getExcludedDays( ).length != 0
1182 && arrayExcludedDays.length == event.getExcludedDays( ).length )
1183 {
1184 for ( int i = 0; i < arrayExcludedDays.length; i++ )
1185 {
1186 if ( !arrayExcludedDays[i].equals( event.getExcludedDays( )[i] ) )
1187 {
1188 bExcludedDaysModified = true;
1189 break;
1190 }
1191 }
1192 }
1193
1194
1195
1196 if ( dateEndEvent != null
1197 && ( StringUtils.isNotEmpty( strEventDateEnd )
1198 && ( event.getDateEnd( ).getTime( ) != dateEndEvent.getTime( ) ) || bExcludedDaysModified ) )
1199 {
1200 if ( dateEndEvent.before( dateEvent ) )
1201 {
1202 return AdminMessageService.getMessageUrl( request, Constants.PROPERTY_MESSAGE_DATE_END_BEFORE,
1203 AdminMessage.TYPE_STOP );
1204 }
1205 nPeriodicity = 0;
1206 nOccurrence = Utils.getOccurrenceWithinTwoDates( dateEvent, dateEndEvent, arrayExcludedDays );
1207 bPeriociteModify = true;
1208 }
1209 else if ( StringUtils.isEmpty( strEventDateEnd ) )
1210 {
1211 return AdminMessageService.getMessageUrl( request, Constants.PROPERTY_MESSAGE_DATEFORMAT,
1212 AdminMessage.TYPE_STOP );
1213 }
1214
1215
1216 if ( nOccurrence > 0 )
1217 {
1218 event.setOccurrence( nOccurrence );
1219 }
1220
1221 event.setDateEnd( dateEndEvent );
1222 event.setPeriodicity( nPeriodicity );
1223
1224 String strTimeStart = (String) _mapParameters.get( Constants.PARAMETER_EVENT_TIME_START );
1225 String strTimeEnd = (String) _mapParameters.get( Constants.PARAMETER_EVENT_TIME_END );
1226 String strEventTags = ( (String) _mapParameters.get( Constants.PARAMETER_EVENT_TAGS ) ).trim( );
1227 String strLocationAddress = ( (String) _mapParameters.get( Constants.PARAMETER_EVENT_LOCATION_ADDRESS ) )
1228 .trim( );
1229 String strLocation = ( (String) _mapParameters.get( Constants.PARAMETER_LOCATION ) ).trim( );
1230 String strLocationTown = ( (String) _mapParameters.get( Constants.PARAMETER_LOCATION_TOWN ) ).trim( );
1231 String strLocationZip = ( (String) _mapParameters.get( Constants.PARAMETER_LOCATION_ZIP ) ).trim( );
1232 String strLinkUrl = ( (String) _mapParameters.get( Constants.PARAMETER_EVENT_LINK_URL ) ).trim( );
1233 String strDocumentId = ( (String) _mapParameters.get( Constants.PARAMETER_EVENT_DOCUMENT_ID ) ).trim( );
1234 String strPageUrl = ( (String) _mapParameters.get( Constants.PARAMETER_EVENT_PAGE_URL ) ).trim( );
1235 String strMapUrl = ( (String) _mapParameters.get( Constants.PARAMETER_EVENT_MAP_URL ) ).trim( );
1236
1237
1238 String[] strTabEventTags = null;
1239
1240 if ( ( strEventTags.length( ) > 0 ) && !strEventTags.equals( "" ) )
1241 {
1242
1243 boolean isAllowedExp = Pattern.matches( PROPERTY_TAGS_REGEXP, strEventTags );
1244
1245 if ( !isAllowedExp )
1246 {
1247 return AdminMessageService.getMessageUrl( request, MESSAGE_INVALID_TAG, AdminMessage.TYPE_STOP );
1248 }
1249
1250 strTabEventTags = strEventTags.split( "\\s" );
1251 }
1252
1253
1254 List<Category> listCategories = new ArrayList<Category>( );
1255
1256 if ( _EventCategories != null )
1257 {
1258 for ( String strIdCategory : _EventCategories )
1259 {
1260 Category category = CategoryHome.find( Integer.parseInt( strIdCategory ), getPlugin( ) );
1261
1262 if ( category != null )
1263 {
1264 listCategories.add( category );
1265 }
1266 }
1267 }
1268
1269
1270 if ( !Utils.checkTime( strTimeStart ) || !Utils.checkTime( strTimeEnd ) )
1271 {
1272 return AdminMessageService.getMessageUrl( request, Constants.PROPERTY_MESSAGE_TIMEFORMAT,
1273 AdminMessage.TYPE_STOP );
1274 }
1275
1276
1277 int nDocumentId = -1;
1278
1279 if ( ( strDocumentId.length( ) > 0 ) && !strDocumentId.equals( "" ) )
1280 {
1281 try
1282 {
1283 nDocumentId = Integer.parseInt( strDocumentId );
1284 }
1285 catch ( NumberFormatException e )
1286 {
1287 return AdminMessageService.getMessageUrl( request, MESSAGE_INVALID_OCCURRENCE_NUMBER,
1288 AdminMessage.TYPE_STOP );
1289 }
1290 }
1291
1292 event.setTags( strTabEventTags );
1293 event.setDocumentId( nDocumentId );
1294 event.setListCategories( listCategories );
1295 event.setDateTimeStart( strTimeStart );
1296 event.setDateTimeEnd( strTimeEnd );
1297 event.setLocation( strLocation );
1298 event.setLocationAddress( strLocationAddress );
1299 event.setLocationTown( strLocationTown );
1300 event.setLocationZip( strLocationZip );
1301 event.setLinkUrl( strLinkUrl );
1302 event.setPageUrl( strPageUrl );
1303 event.setMapUrl( strMapUrl );
1304 event.setExcludedDays( arrayExcludedDays );
1305
1306 if ( _EventItem.getSize( ) >= 1 )
1307 {
1308 ImageResource imageResource = new ImageResource( );
1309 imageResource.setImage( _EventItem.get( ) );
1310 imageResource.setMimeType( _EventItem.getContentType( ) );
1311 event.setImageResource( imageResource );
1312 }
1313
1314 _eventListService.doModifySimpleEvent( event, bPeriociteModify, null, getPlugin( ) );
1315
1316 List<OccurrenceEvent> listOccurencesEvent = _eventListService.getOccurrenceEvents( nCalendarId, event.getId( ),
1317 Constants.SORT_ASC, getPlugin( ) );
1318
1319 for ( OccurrenceEvent occ : listOccurencesEvent )
1320 {
1321
1322 if ( StringUtils.isBlank( occ.getDateTimeStart( ) ) )
1323 {
1324 occ.setDateTimeStart( event.getDateTimeStart( ) );
1325 }
1326
1327 if ( StringUtils.isBlank( occ.getDateTimeEnd( ) ) )
1328 {
1329 occ.setDateTimeEnd( event.getDateTimeEnd( ) );
1330 }
1331
1332
1333
1334
1335
1336 IndexationService.addIndexerAction( Integer.toString( occ.getId( ) ),
1337 AppPropertiesService.getProperty( CalendarIndexer.PROPERTY_INDEXER_NAME ),
1338 IndexerAction.TASK_MODIFY );
1339 CalendarIndexerUtils.addIndexerAction( occ.getId( ), IndexerAction.TASK_MODIFY );
1340 }
1341
1342 _mapParameters = null;
1343
1344 return JSP_EVENT_LIST + nCalendarId + "&" + Constants.PARAMETER_SORT_EVENTS + "="
1345 + request.getParameter( Constants.PARAMETER_SORT_EVENTS );
1346 }
1347
1348
1349
1350
1351
1352
1353
1354 public String doModifyOccurrence( HttpServletRequest request )
1355 {
1356
1357 int nCalendarId = Integer.parseInt( request.getParameter( Constants.PARAMETER_CALENDAR_ID ) );
1358 String strEventDate = request.getParameter( Constants.PARAMETER_EVENT_DATE );
1359 String strStatus = request.getParameter( Constants.PARAMETER_EVENT_STATUS ).trim( );
1360 String strTimeStart = request.getParameter( Constants.PARAMETER_EVENT_TIME_START );
1361 String strTimeEnd = request.getParameter( Constants.PARAMETER_EVENT_TIME_END );
1362
1363
1364 if ( strEventDate.equals( "" ) || request.getParameter( Constants.PARAMETER_EVENT_TITLE ).equals( "" ) )
1365 {
1366 return AdminMessageService.getMessageUrl( request, Messages.MANDATORY_FIELDS, AdminMessage.TYPE_STOP );
1367 }
1368
1369
1370 Date dateEvent = DateUtil.formatDate( strEventDate, getLocale( ) );
1371
1372 if ( ( dateEvent == null ) || !Utils.isValidDate( dateEvent ) )
1373 {
1374 return AdminMessageService.getMessageUrl( request, Constants.PROPERTY_MESSAGE_DATEFORMAT,
1375 AdminMessage.TYPE_STOP );
1376 }
1377
1378 if ( !Utils.checkTime( strTimeStart ) || !Utils.checkTime( strTimeEnd ) )
1379 {
1380 return AdminMessageService.getMessageUrl( request, Constants.PROPERTY_MESSAGE_TIMEFORMAT,
1381 AdminMessage.TYPE_STOP );
1382 }
1383
1384 OccurrenceEvent occurrence = CalendarHome.findOccurrence(
1385 Integer.parseInt( request.getParameter( Constants.PARAMETER_OCCURRENCE_ID ) ), getPlugin( ) );
1386
1387 occurrence.setDate( dateEvent );
1388 occurrence.setStatus( strStatus );
1389 occurrence.setDateTimeStart( strTimeStart );
1390 occurrence.setDateTimeEnd( strTimeEnd );
1391 occurrence.setTitle( request.getParameter( Constants.PARAMETER_EVENT_TITLE ) );
1392
1393 _eventListService.doModifyOccurrenceEvent( occurrence, getPlugin( ) );
1394
1395 SimpleEvent event = CalendarHome.findEvent( occurrence.getEventId( ), getPlugin( ) );
1396 List<OccurrenceEvent> listOccurrenceEvent = CalendarHome.findOccurrencesList( event.getIdCalendar( ),
1397 event.getId( ), 1, getPlugin( ) );
1398
1399
1400 if ( listOccurrenceEvent.size( ) == 1 )
1401 {
1402 event.setDate( occurrence.getDate( ) );
1403 event.setDateEnd( occurrence.getDate( ) );
1404 }
1405
1406
1407 else if ( listOccurrenceEvent.get( 0 ).getId( ) == occurrence.getId( ) )
1408 {
1409 event.setDate( occurrence.getDate( ) );
1410 }
1411
1412
1413 else if ( listOccurrenceEvent.get( listOccurrenceEvent.size( ) - 1 ).getId( ) == occurrence.getId( ) )
1414 {
1415 event.setDateEnd( occurrence.getDate( ) );
1416 }
1417
1418 _eventListService.doModifySimpleEvent( event, false, null, getPlugin( ) );
1419
1420
1421 IndexationService.addIndexerAction( Integer.toString( occurrence.getId( ) ),
1422 AppPropertiesService.getProperty( CalendarIndexer.PROPERTY_INDEXER_NAME ), IndexerAction.TASK_MODIFY );
1423
1424 CalendarIndexerUtils.addIndexerAction( occurrence.getId( ), IndexerAction.TASK_MODIFY );
1425
1426 return JSP_OCCURRENCE_LIST2 + nCalendarId + "&" + Constants.PARAMETER_SORT_EVENTS + "="
1427 + request.getParameter( Constants.PARAMETER_SORT_EVENTS ) + "&" + Constants.PARAMETER_EVENT_ID + "="
1428 + occurrence.getEventId( );
1429 }
1430
1431
1432
1433
1434
1435
1436 public String doModifyOccurrencePeriodicity( HttpServletRequest request )
1437 {
1438 int nCalendarId = Integer.parseInt( request.getParameter( Constants.PARAMETER_CALENDAR_ID ) );
1439 String strOccurrence = request.getParameter( Constants.PARAMETER_OCCURRENCE );
1440 int nPeriodicity = Integer.parseInt( request.getParameter( Constants.PARAMETER_PERIODICITY ) );
1441 String strIdEvent = request.getParameter( Constants.PARAMETER_EVENT_ID );
1442 int nIdEvent = Integer.parseInt( strIdEvent );
1443 String strSortEvents = request.getParameter( Constants.PARAMETER_SORT_EVENTS );
1444 strSortEvents = ( strSortEvents != null ) ? strSortEvents : "1";
1445 String[] arrayExcludedDays = request.getParameterValues( Constants.PARAMETER_EXCLUDED_DAYS );
1446
1447 SimpleEvent event = CalendarHome.findEvent( nIdEvent, PluginService.getPlugin( Constants.PLUGIN_NAME ) );
1448
1449
1450 int nOccurrence = 1;
1451
1452
1453 if ( ( strOccurrence.length( ) > 0 ) && !strOccurrence.equals( "" ) )
1454 {
1455 try
1456 {
1457 nOccurrence = Integer.parseInt( strOccurrence );
1458 }
1459 catch ( NumberFormatException e )
1460 {
1461 return AdminMessageService.getMessageUrl( request, MESSAGE_INVALID_OCCURRENCE_NUMBER,
1462 AdminMessage.TYPE_STOP );
1463 }
1464 }
1465 event.setExcludedDays( arrayExcludedDays );
1466
1467 Date dateEndEvent = Utils
1468 .getDateForward( event.getDate( ), nPeriodicity, nOccurrence, event.getExcludedDays( ) );
1469
1470
1471 event.setOccurrence( nOccurrence );
1472 event.setDateEnd( dateEndEvent );
1473 event.setPeriodicity( nPeriodicity );
1474 _eventListService.doModifySimpleEvent( event, true, null, getPlugin( ) );
1475
1476 List<OccurrenceEvent> listOccurencesEvent = CalendarHome.findOccurrencesList( nCalendarId, event.getId( ), 1,
1477 getPlugin( ) );
1478
1479 for ( OccurrenceEvent occ : listOccurencesEvent )
1480 {
1481
1482 IndexationService.addIndexerAction( Integer.toString( occ.getId( ) ),
1483 AppPropertiesService.getProperty( CalendarIndexer.PROPERTY_INDEXER_NAME ),
1484 IndexerAction.TASK_CREATE );
1485 CalendarIndexerUtils.addIndexerAction( occ.getId( ), IndexerAction.TASK_CREATE );
1486 }
1487
1488 return JSP_OCCURRENCE_LIST2 + nCalendarId + "&" + Constants.PARAMETER_SORT_EVENTS + "=" + strSortEvents + "&"
1489 + Constants.PARAMETER_EVENT_ID + "=" + strIdEvent;
1490 }
1491
1492
1493
1494
1495
1496
1497
1498 public String getModifyOccurrence( HttpServletRequest request )
1499 {
1500 setPageTitleProperty( Constants.PROPERTY_PAGE_TITLE_MODIFY_OCCURRENCE );
1501
1502 int nCalendarId = Integer.parseInt( request.getParameter( Constants.PARAMETER_CALENDAR_ID ) );
1503 String strEventId = request.getParameter( Constants.PARAMETER_OCCURRENCE_ID );
1504 int nIdOccurrence = Integer.parseInt( strEventId.trim( ) );
1505
1506 OccurrenceEvent occurrence = CalendarHome.findOccurrence( nIdOccurrence, getPlugin( ) );
1507
1508 Map<String, Object> model = new HashMap<String, Object>( );
1509 model.put( Constants.MARK_OCCURRENCE, occurrence );
1510 model.put( Constants.MARK_CALENDAR_ID, nCalendarId );
1511 model.put( MARK_EVENT_STATUS_LIST, getStatusList( request ) );
1512 model.put( MARK_DEFAULT_STATUS, occurrence.getStatus( ) );
1513 model.put( Constants.MARK_DEFAULT_SORT_EVENT, request.getParameter( Constants.PARAMETER_SORT_EVENTS ) );
1514 model.put( Constants.MARK_LOCALE, getLocale( ).getLanguage( ) );
1515
1516 HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_MODIFY_OCCURRENCE, getLocale( ), model );
1517
1518 return getAdminPage( template.getHtml( ) );
1519 }
1520
1521
1522
1523
1524
1525
1526
1527 public String getConfirmRemoveEvent( HttpServletRequest request )
1528 {
1529 UrlItem url = new UrlItem( JSP_DO_REMOVE_EVENT );
1530
1531 url.addParameter( Constants.PARAMETER_CALENDAR_ID,
1532 Integer.parseInt( request.getParameter( Constants.PARAMETER_CALENDAR_ID ) ) );
1533 url.addParameter( Constants.PARAMETER_EVENT_ID,
1534 Integer.parseInt( request.getParameter( Constants.PARAMETER_EVENT_ID ) ) );
1535
1536 return AdminMessageService.getMessageUrl( request, MESSAGE_CONFIRM_REMOVE_EVENT, url.getUrl( ),
1537 AdminMessage.TYPE_CONFIRMATION );
1538 }
1539
1540
1541
1542
1543
1544
1545
1546 public String doRemoveEvent( HttpServletRequest request )
1547 {
1548
1549 int nCalendarId = Integer.parseInt( request.getParameter( Constants.PARAMETER_CALENDAR_ID ) );
1550 Event event = CalendarHome.findEvent( Integer.parseInt( request.getParameter( Constants.PARAMETER_EVENT_ID ) ),
1551 getPlugin( ) );
1552 List<OccurrenceEvent> listOccurencesEvent = CalendarHome.findOccurrencesList( nCalendarId, event.getId( ), 1,
1553 getPlugin( ) );
1554
1555 for ( OccurrenceEvent occ : listOccurencesEvent )
1556 {
1557 IndexationService.addIndexerAction( Integer.toString( occ.getId( ) ),
1558 AppPropertiesService.getProperty( CalendarIndexer.PROPERTY_INDEXER_NAME ),
1559 IndexerAction.TASK_DELETE );
1560 CalendarIndexerUtils.addIndexerAction( occ.getId( ), IndexerAction.TASK_DELETE );
1561 }
1562
1563 CalendarHome.removeEvent( nCalendarId,
1564 Integer.parseInt( request.getParameter( Constants.PARAMETER_EVENT_ID ) ), getPlugin( ) );
1565
1566
1567 return JSP_EVENT_LIST + nCalendarId;
1568 }
1569
1570
1571
1572
1573
1574
1575 private ReferenceList getDotsList( )
1576 {
1577 String strDotsPath = AppPropertiesService.getProperty( Constants.PROPERTY_CALENDAR_DOTS_PATH );
1578 String strRootDirectory = AppPathService.getWebAppPath( );
1579 ReferenceList listDots = new ReferenceList( );
1580
1581 try
1582 {
1583 List<File> listFiles = FileSystemUtil.getFiles( strRootDirectory, "/" + strDotsPath );
1584
1585 for ( File file : listFiles )
1586 {
1587 String strFileName = file.getName( );
1588
1589 if ( strFileName.endsWith( EXT_IMAGE_FILES ) )
1590 {
1591 String strPathFile = strDotsPath + strFileName;
1592 listDots.addItem( strPathFile, strPathFile );
1593 }
1594 }
1595 }
1596 catch ( DirectoryNotFoundException e )
1597 {
1598 throw new AppException( e.getMessage( ), e );
1599 }
1600
1601 return listDots;
1602 }
1603
1604
1605
1606
1607
1608
1609
1610 private ReferenceList getSortEventList( )
1611 {
1612 ReferenceList list = new ReferenceList( );
1613 list.addItem( 1, I18nService.getLocalizedString( Constants.PROPERTY_SORT_EVENTS + 1, getLocale( ) ) );
1614 list.addItem( 2, I18nService.getLocalizedString( Constants.PROPERTY_SORT_EVENTS + 2, getLocale( ) ) );
1615
1616 return list;
1617 }
1618
1619
1620
1621
1622
1623
1624 public ReferenceList getIntervalList( HttpServletRequest request )
1625 {
1626 StringTokenizer st = new StringTokenizer( AppPropertiesService.getProperty( PROPERTY_TIME_INTERVAL_LIST ), "," );
1627 ReferenceList timeIntervalList = new ReferenceList( );
1628
1629 while ( st.hasMoreElements( ) )
1630 {
1631 String strIntervalName = st.nextToken( ).trim( );
1632 String strDescription = I18nService.getLocalizedString( "calendar.interval.periodicity." + strIntervalName
1633 + ".description", getLocale( ) );
1634 int nDays = AppPropertiesService.getPropertyInt( "calendar.interval." + strIntervalName + ".value", 7 );
1635 timeIntervalList.addItem( nDays, strDescription );
1636 }
1637
1638 return timeIntervalList;
1639 }
1640
1641
1642
1643
1644
1645
1646 private ReferenceList getTopEventList( )
1647 {
1648 ReferenceList list = new ReferenceList( );
1649 StringTokenizer st = new StringTokenizer(
1650 I18nService.getLocalizedString( PROPERTY_TOP_EVENT_LIST, getLocale( ) ), "," );
1651 int i = 0;
1652
1653 while ( st.hasMoreElements( ) )
1654 {
1655 list.addItem( i++, st.nextToken( ).trim( ) );
1656 }
1657
1658 return list;
1659 }
1660
1661
1662
1663
1664
1665
1666 private ReferenceList getStatusList( HttpServletRequest request )
1667 {
1668 ReferenceList list = new ReferenceList( );
1669 StringTokenizer stStatus = new StringTokenizer( AppPropertiesService.getProperty( PROPERTY_EVENT_STATUS_LIST ),
1670 Constants.COMMA );
1671
1672 while ( stStatus.hasMoreElements( ) )
1673 {
1674 String strStatus = stStatus.nextToken( ).trim( );
1675 String strStatusValue = I18nService.getLocalizedString( "calendar.event.status." + strStatus + ".value",
1676 getLocale( ) );
1677
1678 list.addItem( strStatus, strStatusValue );
1679 }
1680
1681 return list;
1682 }
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717 public String getConfirmModifyEvent( HttpServletRequest request )
1718 {
1719 HashMap<String, Object> mapParameters = new HashMap<String, Object>( );
1720 Date dateEvent = null;
1721 Date dateEndEvent = null;
1722
1723 mapParameters.put( Constants.PARAMETER_EVENT_ID, request.getParameter( Constants.PARAMETER_EVENT_ID ) );
1724 mapParameters.put( Constants.PARAMETER_CALENDAR_ID, request.getParameter( Constants.PARAMETER_CALENDAR_ID ) );
1725 mapParameters.put( Constants.PARAMETER_TYPE_BOX, request.getParameter( Constants.PARAMETER_TYPE_BOX ) );
1726
1727 if ( request.getParameter( Constants.PARAMETER_EVENT_TITLE ) != null )
1728 {
1729 mapParameters
1730 .put( Constants.PARAMETER_EVENT_TITLE, request.getParameter( Constants.PARAMETER_EVENT_TITLE ) );
1731 }
1732
1733 if ( request.getParameter( Constants.PARAMETER_EVENT_DATE ) != null )
1734 {
1735 mapParameters.put( Constants.PARAMETER_EVENT_DATE, request.getParameter( Constants.PARAMETER_EVENT_DATE ) );
1736 dateEvent = DateUtil.formatDate( request.getParameter( Constants.PARAMETER_EVENT_DATE ), getLocale( ) );
1737
1738 if ( ( dateEvent == null ) || !Utils.isValidDate( dateEvent ) )
1739 {
1740 return AdminMessageService.getMessageUrl( request, Constants.PROPERTY_MESSAGE_DATEFORMAT,
1741 AdminMessage.TYPE_STOP );
1742 }
1743 }
1744
1745 if ( request.getParameter( Constants.PARAMETER_EVENT_DATE_END ) != null )
1746 {
1747 mapParameters.put( Constants.PARAMETER_EVENT_DATE_END,
1748 request.getParameter( Constants.PARAMETER_EVENT_DATE_END ) );
1749 dateEndEvent = DateUtil
1750 .formatDate( request.getParameter( Constants.PARAMETER_EVENT_DATE_END ), getLocale( ) );
1751 if ( ( dateEndEvent == null ) || !Utils.isValidDate( dateEndEvent ) )
1752 {
1753 return AdminMessageService.getMessageUrl( request, Constants.PROPERTY_MESSAGE_DATEFORMAT,
1754 AdminMessage.TYPE_STOP );
1755 }
1756 }
1757
1758 if ( request.getParameter( Constants.PARAMETER_EVENT_TIME_START ) != null )
1759 {
1760 mapParameters.put( Constants.PARAMETER_EVENT_TIME_START,
1761 request.getParameter( Constants.PARAMETER_EVENT_TIME_START ) );
1762 }
1763
1764 if ( request.getParameter( Constants.PARAMETER_EVENT_TIME_END ) != null )
1765 {
1766 mapParameters.put( Constants.PARAMETER_EVENT_TIME_END,
1767 request.getParameter( Constants.PARAMETER_EVENT_TIME_END ) );
1768 }
1769
1770 if ( request.getParameter( Constants.PARAMETER_RADIO_PERIODICITY ) != null )
1771 {
1772 mapParameters.put( Constants.PARAMETER_RADIO_PERIODICITY,
1773 request.getParameter( Constants.PARAMETER_RADIO_PERIODICITY ) );
1774 }
1775
1776 if ( request.getParameter( Constants.PARAMETER_PERIODICITY ) != null )
1777 {
1778 mapParameters
1779 .put( Constants.PARAMETER_PERIODICITY, request.getParameter( Constants.PARAMETER_PERIODICITY ) );
1780 }
1781
1782 if ( request.getParameter( Constants.PARAMETER_EVENT_LOCATION_ADDRESS ) != null )
1783 {
1784 mapParameters.put( Constants.PARAMETER_EVENT_LOCATION_ADDRESS,
1785 request.getParameter( Constants.PARAMETER_EVENT_LOCATION_ADDRESS ) );
1786 }
1787
1788 if ( request.getParameter( Constants.PARAMETER_LOCATION ) != null )
1789 {
1790 mapParameters.put( Constants.PARAMETER_LOCATION, request.getParameter( Constants.PARAMETER_LOCATION ) );
1791 }
1792
1793 if ( request.getParameter( Constants.PARAMETER_LOCATION_TOWN ) != null )
1794 {
1795 mapParameters.put( Constants.PARAMETER_LOCATION_TOWN,
1796 request.getParameter( Constants.PARAMETER_LOCATION_TOWN ) );
1797 }
1798
1799 if ( request.getParameter( Constants.PARAMETER_LOCATION_ZIP ) != null )
1800 {
1801 mapParameters.put( Constants.PARAMETER_LOCATION_ZIP,
1802 request.getParameter( Constants.PARAMETER_LOCATION_ZIP ) );
1803 }
1804
1805 if ( request.getParameter( Constants.PARAMETER_EVENT_LINK_URL ) != null )
1806 {
1807 mapParameters.put( Constants.PARAMETER_EVENT_LINK_URL,
1808 request.getParameter( Constants.PARAMETER_EVENT_LINK_URL ) );
1809 }
1810
1811 if ( request.getParameter( Constants.PARAMETER_EVENT_DOCUMENT_ID ) != null )
1812 {
1813 mapParameters.put( Constants.PARAMETER_EVENT_DOCUMENT_ID,
1814 request.getParameter( Constants.PARAMETER_EVENT_DOCUMENT_ID ) );
1815 }
1816
1817 if ( request.getParameter( Constants.PARAMETER_EVENT_PAGE_URL ) != null )
1818 {
1819 mapParameters.put( Constants.PARAMETER_EVENT_PAGE_URL,
1820 request.getParameter( Constants.PARAMETER_EVENT_PAGE_URL ) );
1821 }
1822
1823 if ( request.getParameter( Constants.PARAMETER_EVENT_TOP_EVENT ) != null )
1824 {
1825 mapParameters.put( Constants.PARAMETER_EVENT_TOP_EVENT,
1826 request.getParameter( Constants.PARAMETER_EVENT_TOP_EVENT ) );
1827 }
1828
1829 if ( request.getParameter( Constants.PARAMETER_EVENT_MAP_URL ) != null )
1830 {
1831 mapParameters.put( Constants.PARAMETER_EVENT_MAP_URL,
1832 request.getParameter( Constants.PARAMETER_EVENT_MAP_URL ) );
1833 }
1834
1835 if ( request.getParameter( Constants.PARAMETER_OCCURRENCE ) != null )
1836 {
1837 mapParameters.put( Constants.PARAMETER_OCCURRENCE, request.getParameter( Constants.PARAMETER_OCCURRENCE ) );
1838 }
1839
1840 if ( request.getParameter( Constants.PARAMETER_EVENT_TAGS ) != null )
1841 {
1842 mapParameters.put( Constants.PARAMETER_EVENT_TAGS, request.getParameter( Constants.PARAMETER_EVENT_TAGS ) );
1843 }
1844
1845 if ( request.getParameter( Constants.PARAMETER_SORT_EVENTS ) != null )
1846 {
1847 mapParameters
1848 .put( Constants.PARAMETER_SORT_EVENTS, request.getParameter( Constants.PARAMETER_SORT_EVENTS ) );
1849 }
1850
1851 if ( request.getParameterValues( Constants.PARAMETER_EXCLUDED_DAYS ) != null )
1852 {
1853 mapParameters.put( Constants.PARAMETER_EXCLUDED_DAYS,
1854 request.getParameterValues( Constants.PARAMETER_EXCLUDED_DAYS ) );
1855 }
1856
1857 MultipartHttpServletRequest mRequest = (MultipartHttpServletRequest) request;
1858
1859 if ( mRequest.getFile( Constants.PARAMETER_EVENT_IMAGE ) != null )
1860 {
1861 _EventItem = mRequest.getFile( Constants.PARAMETER_EVENT_IMAGE );
1862 }
1863
1864 if ( request.getParameterValues( Constants.PARAMETER_CATEGORY ) != null )
1865 {
1866 _EventCategories = request.getParameterValues( Constants.PARAMETER_CATEGORY );
1867 }
1868
1869 if ( request.getParameter( Constants.PARAMETER_DESCRIPTION ) != null )
1870 {
1871 _EventDescription = request.getParameter( Constants.PARAMETER_DESCRIPTION );
1872 }
1873
1874 _mapParameters = mapParameters;
1875
1876 return DO_MODIFY_EVENT + request.getParameter( Constants.PARAMETER_CALENDAR_ID ) + "&"
1877 + Constants.PARAMETER_EVENT_ID + "=" + request.getParameter( Constants.PARAMETER_EVENT_ID ) + "&"
1878 + Constants.PARAMETER_SORT_EVENTS + "=" + request.getParameter( Constants.PARAMETER_SORT_EVENTS ) + "&"
1879 + Constants.PARAMETER_TYPE_BOX + "=" + request.getParameter( Constants.PARAMETER_TYPE_BOX );
1880 }
1881
1882
1883
1884
1885
1886
1887
1888 public String getConfirmRemoveOccurrence( HttpServletRequest request )
1889 {
1890 UrlItem url = new UrlItem( JSP_DO_REMOVE_OCCURRENCE );
1891 url.addParameter( Constants.PARAMETER_CALENDAR_ID,
1892 Integer.parseInt( request.getParameter( Constants.PARAMETER_CALENDAR_ID ) ) );
1893 url.addParameter( Constants.PARAMETER_EVENT_ID, request.getParameter( Constants.PARAMETER_EVENT_ID ) );
1894 url.addParameter( Constants.PARAMETER_SORT_EVENTS, request.getParameter( Constants.PARAMETER_SORT_EVENTS ) );
1895 url.addParameter( Constants.PARAMETER_OCCURRENCE_ID, request.getParameter( Constants.PARAMETER_OCCURRENCE_ID ) );
1896
1897 String[] tableCBXOccurrence = request.getParameterValues( Constants.PARAMETER_CBX_OCCURRENCE );
1898 String strCBXOccurrence = "";
1899
1900
1901
1902 if ( tableCBXOccurrence != null )
1903 {
1904 for ( int i = 0; i < tableCBXOccurrence.length; i++ )
1905 {
1906 strCBXOccurrence += ( tableCBXOccurrence[i] + Constants.COMMA );
1907 }
1908
1909 url.addParameter( Constants.PARAMETER_CBX_OCCURRENCE, strCBXOccurrence );
1910 }
1911
1912 if ( tableCBXOccurrence == null )
1913 {
1914 tableCBXOccurrence = new String[0];
1915 }
1916
1917 return AdminMessageService.getMessageUrl( request,
1918 ( tableCBXOccurrence.length > 1 ) ? MESSAGE_CONFIRM_REMOVE_ALL_OCCURRENCE
1919 : MESSAGE_CONFIRM_REMOVE_OCCURRENCE, url.getUrl( ), AdminMessage.TYPE_CONFIRMATION );
1920 }
1921
1922
1923
1924
1925
1926
1927
1928 public String doRemoveOccurrence( HttpServletRequest request )
1929 {
1930 int nOccurrenceId;
1931 String strOccurrenceId = request.getParameter( Constants.PARAMETER_OCCURRENCE_ID );
1932 String strCBXOccurrence = request.getParameter( Constants.PARAMETER_CBX_OCCURRENCE );
1933 int nCalendarId = Integer.parseInt( request.getParameter( Constants.PARAMETER_CALENDAR_ID ) );
1934 int nEventId = Integer.parseInt( request.getParameter( Constants.PARAMETER_EVENT_ID ) );
1935 SimpleEvent event = CalendarHome.findEvent( nEventId, PluginService.getPlugin( Constants.PLUGIN_NAME ) );
1936 int nOccurrence = event.getOccurrence( );
1937
1938 String[] tableCBXOccurrence = new String[0];
1939
1940 if ( ( strCBXOccurrence != null ) && !strCBXOccurrence.equals( "null" )
1941 && !strCBXOccurrence.equals( Constants.EMPTY_STRING ) )
1942 {
1943 tableCBXOccurrence = strCBXOccurrence.split( Constants.COMMA );
1944 }
1945
1946 if ( ( strOccurrenceId != null ) && !strOccurrenceId.equals( "null" )
1947 && !strOccurrenceId.equals( Constants.EMPTY_STRING ) )
1948 {
1949 nOccurrenceId = Integer.parseInt( strOccurrenceId );
1950 CalendarHome.removeOccurrence( nOccurrenceId, nEventId, nCalendarId, getPlugin( ) );
1951 nOccurrence--;
1952
1953
1954 IndexationService.addIndexerAction( Integer.toString( nOccurrenceId ),
1955 AppPropertiesService.getProperty( CalendarIndexer.PROPERTY_INDEXER_NAME ),
1956 IndexerAction.TASK_DELETE );
1957 CalendarIndexerUtils.addIndexerAction( nOccurrenceId, IndexerAction.TASK_DELETE );
1958 }
1959 else if ( tableCBXOccurrence.length > 0 )
1960 {
1961 for ( int i = 0; tableCBXOccurrence.length > i; i++ )
1962 {
1963 int nOccId = Integer.parseInt( tableCBXOccurrence[i] );
1964 CalendarHome.removeOccurrence( nOccId, nEventId, nCalendarId, getPlugin( ) );
1965 nOccurrence--;
1966
1967 IndexationService.addIndexerAction( tableCBXOccurrence[i],
1968 AppPropertiesService.getProperty( CalendarIndexer.PROPERTY_INDEXER_NAME ),
1969 IndexerAction.TASK_DELETE );
1970 CalendarIndexerUtils.addIndexerAction( nOccId, IndexerAction.TASK_DELETE );
1971 }
1972 }
1973
1974 List<OccurrenceEvent> listOccurrence = CalendarHome.findOccurrencesList( nCalendarId, nEventId, 1,
1975 PluginService.getPlugin( Constants.PLUGIN_NAME ) );
1976
1977 if ( !listOccurrence.isEmpty( ) )
1978 {
1979 OccurrenceEvent firstOccurrenceEvent = listOccurrence.get( 0 );
1980 OccurrenceEvent lastOccurrenceEvent = listOccurrence.get( listOccurrence.size( ) - 1 );
1981
1982 event.setDate( firstOccurrenceEvent.getDate( ) );
1983 event.setDateEnd( lastOccurrenceEvent.getDate( ) );
1984 }
1985
1986 event.setOccurrence( nOccurrence );
1987 _eventListService.doModifySimpleEvent( event, false, null, getPlugin( ) );
1988
1989
1990 return JSP_OCCURRENCE_LIST2 + nCalendarId + "&" + Constants.PARAMETER_SORT_EVENTS + "="
1991 + request.getParameter( Constants.PARAMETER_SORT_EVENTS ) + "&" + Constants.PARAMETER_EVENT_ID + "="
1992 + request.getParameter( Constants.PARAMETER_EVENT_ID );
1993 }
1994
1995
1996
1997
1998
1999
2000
2001 public String getManageSubscribers( HttpServletRequest request )
2002 {
2003 int nCalendarId = Integer.parseInt( request.getParameter( Constants.PARAMETER_CALENDAR_ID ) );
2004
2005 setPageTitleProperty( Constants.PROPERTY_PAGE_TITLE_MANAGE_SUBSCRIBERS );
2006
2007 Map<String, Object> model = new HashMap<String, Object>( );
2008
2009 model.put( Constants.MARK_CALENDAR_ID, nCalendarId );
2010
2011 _strCurrentPageIndex = Paginator.getPageIndex( request, Paginator.PARAMETER_PAGE_INDEX, _strCurrentPageIndex );
2012 _nItemsPerPage = Paginator.getItemsPerPage( request, Paginator.PARAMETER_ITEMS_PER_PAGE, _nItemsPerPage,
2013 _nDefaultItemsPerPage );
2014
2015 String strSearchString = request.getParameter( Constants.PARAMETER_SUBSCRIBER_SEARCH );
2016
2017 if ( strSearchString == null )
2018 {
2019 strSearchString = Constants.EMPTY_STRING;
2020 }
2021
2022
2023 List<CalendarSubscriber> calendarSubscribers = CalendarSubscriberHome.findSubscribers( nCalendarId,
2024 strSearchString, Integer.parseInt( AppPropertiesService.getProperty( PROPERTY_LIMIT_MIN_SUSCRIBER ) ),
2025 Integer.parseInt( AppPropertiesService.getProperty( PROPERTY_LIMIT_MAX_SUSCRIBER ) ), getPlugin( ) );
2026
2027 UrlItem url = new UrlItem( request.getRequestURI( ) );
2028 url.addParameter( Constants.PARAMETER_CALENDAR_ID, Integer.toString( nCalendarId ) );
2029
2030 LocalizedPaginator<CalendarSubscriber> paginator = new LocalizedPaginator<CalendarSubscriber>(
2031 calendarSubscribers, _nItemsPerPage, url.getUrl( ), Paginator.PARAMETER_PAGE_INDEX,
2032 _strCurrentPageIndex, getLocale( ) );
2033
2034 model.put( Constants.MARK_NB_ITEMS_PER_PAGE, "" + _nItemsPerPage );
2035 model.put( Constants.MARK_PAGINATOR, paginator );
2036 model.put( Constants.MARK_SUBSCRIBERS_LIST, paginator.getPageItems( ) );
2037 model.put( Constants.MARK_SEARCH_STRING, strSearchString );
2038
2039 HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_MANAGE_SUBSCRIBERS, getLocale( ), model );
2040
2041 return getAdminPage( template.getHtml( ) );
2042 }
2043
2044
2045
2046
2047
2048
2049
2050
2051 public String getConfirmRemoveSubscriber( HttpServletRequest request )
2052 {
2053 UrlItem urlItem = new UrlItem( JSP_URL_DO_REMOVE_SUBSCRIBER );
2054 int nCalendarId = Integer.parseInt( request.getParameter( Constants.PARAMETER_CALENDAR_ID ) );
2055 int nSubscriberId = Integer.parseInt( request.getParameter( Constants.PARAMETER_SUBSCRIBER_ID ) );
2056 urlItem.addParameter( Constants.PARAMETER_CALENDAR_ID, Integer.toString( nCalendarId ) );
2057 urlItem.addParameter( Constants.PARAMETER_SUBSCRIBER_ID, Integer.toString( nSubscriberId ) );
2058
2059 return AdminMessageService.getMessageUrl( request, MESSAGE_CONFIRM_REMOVE_SUBSCRIBER, urlItem.getUrl( ),
2060 AdminMessage.TYPE_CONFIRMATION );
2061 }
2062
2063
2064
2065
2066
2067
2068
2069 public String doUnregistration( HttpServletRequest request )
2070 {
2071
2072 int nCalendarId = Integer.parseInt( request.getParameter( Constants.PARAMETER_CALENDAR_ID ) );
2073 int nSubscriberId = Integer.parseInt( request.getParameter( Constants.PARAMETER_SUBSCRIBER_ID ) );
2074
2075
2076 CalendarSubscriber subscriber = CalendarSubscriberHome.findByPrimaryKey( nSubscriberId, getPlugin( ) );
2077
2078 if ( subscriber != null )
2079 {
2080 CalendarSubscriberHome.removeSubscriber( nCalendarId, nSubscriberId, getPlugin( ) );
2081 if ( !CalendarSubscriberHome.isUserSubscribed( nSubscriberId, getPlugin( ) ) )
2082 {
2083 CalendarSubscriberHome.remove( nSubscriberId, getPlugin( ) );
2084 }
2085 }
2086
2087 return JSP_MANAGE_SUBSCRIBERS_LIST + nCalendarId;
2088 }
2089
2090
2091
2092
2093
2094
2095
2096
2097 public String getInsertService( HttpServletRequest request )
2098 {
2099 Plugin module = PluginService.getPlugin( Constants.PROPERTY_MODULE_CALENDAR );
2100
2101 if ( ( module != null ) && module.isInstalled( ) )
2102 {
2103 UrlItem url = new UrlItem( JSP_GET_DOCUMENT_INSERT_SERVICE );
2104 url.addParameter( Constants.PARAMETER_INPUT, Constants.PARAMETER_EVENT_DOCUMENT_ID );
2105
2106 return url.getUrl( );
2107 }
2108 return AdminMessageService.getMessageUrl( request, MESSAGE_PLUGIN_DOCUMENT_UNINSTALLED, AdminMessage.TYPE_STOP );
2109 }
2110
2111
2112
2113
2114
2115
2116
2117 public String getInsertLinkService( HttpServletRequest request )
2118 {
2119 return AppPathService.getBaseUrl( request ) + JSP_GET_DOCUMENT_INSERT_LINK_SERVICE + "?"
2120 + Constants.PARAMETER_INPUT + "=" + Constants.PARAMETER_EVENT_PAGE_URL + "&"
2121 + Constants.PARAMETER_SELECTED_TEXT + "=" + Constants.EMPTY_STRING;
2122 }
2123
2124
2125
2126
2127
2128
2129
2130 public String getModifyOccurrenceList( HttpServletRequest request )
2131 {
2132 String strRemove = request.getParameter( Constants.PARAMETER_REMOVE_OCCURRENCES );
2133 if ( strRemove != null )
2134 {
2135 return getConfirmRemoveOccurrence( request );
2136 }
2137
2138 return getConfirmModifyOccurrenceStatus( request );
2139 }
2140
2141
2142
2143
2144
2145
2146
2147 public String getConfirmModifyOccurrenceStatus( HttpServletRequest request )
2148 {
2149 UrlItem url = new UrlItem( JSP_DO_MODIFY_OCCURRENCE_STATUS );
2150 url.addParameter( Constants.PARAMETER_CALENDAR_ID,
2151 Integer.parseInt( request.getParameter( Constants.PARAMETER_CALENDAR_ID ) ) );
2152 url.addParameter( Constants.PARAMETER_SORT_EVENTS, request.getParameter( Constants.PARAMETER_SORT_EVENTS ) );
2153 url.addParameter( Constants.PARAMETER_EVENT_ID, request.getParameter( Constants.PARAMETER_EVENT_ID ) );
2154 url.addParameter( Constants.PARAMETER_EVENT_STATUS, request.getParameter( Constants.PARAMETER_EVENT_STATUS ) );
2155
2156 String[] tableCBXOccurrence = request.getParameterValues( Constants.PARAMETER_CBX_OCCURRENCE );
2157 String strCBXOccurrence = Constants.EMPTY_STRING;
2158
2159 if ( tableCBXOccurrence != null )
2160 {
2161 for ( int i = 0; i < tableCBXOccurrence.length; i++ )
2162 {
2163 strCBXOccurrence += ( tableCBXOccurrence[i] + Constants.COMMA );
2164 }
2165
2166 url.addParameter( Constants.PARAMETER_CBX_OCCURRENCE, strCBXOccurrence );
2167 }
2168
2169 if ( tableCBXOccurrence == null )
2170 {
2171 tableCBXOccurrence = new String[0];
2172 }
2173
2174 return AdminMessageService.getMessageUrl( request, MESSAGE_CONFIRM_MODIFY_OCCURRENCES_STATUS, url.getUrl( ),
2175 AdminMessage.TYPE_CONFIRMATION );
2176 }
2177
2178
2179
2180
2181
2182
2183 public String doModifyOccurrenceStatus( HttpServletRequest request )
2184 {
2185 String strCBXOccurrence = request.getParameter( Constants.PARAMETER_CBX_OCCURRENCE );
2186 int nCalendarId = Integer.parseInt( request.getParameter( Constants.PARAMETER_CALENDAR_ID ) );
2187 String strEventStatus = request.getParameter( Constants.PARAMETER_EVENT_STATUS );
2188
2189 String[] tableCBXOccurrence = new String[0];
2190
2191 if ( ( strCBXOccurrence != null ) && !strCBXOccurrence.equals( Constants.NULL )
2192 && !strCBXOccurrence.equals( Constants.EMPTY_STRING ) )
2193 {
2194 tableCBXOccurrence = strCBXOccurrence.split( Constants.COMMA );
2195 }
2196 for ( int i = 0; i < tableCBXOccurrence.length; i++ )
2197 {
2198 int nIdOccurrenceEvent = Integer.parseInt( tableCBXOccurrence[i] );
2199 OccurrenceEvent occurrence = CalendarHome.findOccurrence( nIdOccurrenceEvent, getPlugin( ) );
2200 occurrence.setStatus( strEventStatus );
2201 _eventListService.doModifyOccurrenceEvent( occurrence, getPlugin( ) );
2202
2203 IndexationService.addIndexerAction( tableCBXOccurrence[i],
2204 AppPropertiesService.getProperty( CalendarIndexer.PROPERTY_INDEXER_NAME ),
2205 IndexerAction.TASK_MODIFY );
2206 CalendarIndexerUtils.addIndexerAction( nIdOccurrenceEvent, IndexerAction.TASK_MODIFY );
2207 }
2208
2209
2210 return JSP_OCCURRENCE_LIST2 + nCalendarId + Constants.AMPERSAND + Constants.PARAMETER_SORT_EVENTS
2211 + Constants.EQUAL + request.getParameter( Constants.PARAMETER_SORT_EVENTS ) + Constants.AMPERSAND
2212 + Constants.PARAMETER_EVENT_ID + Constants.EQUAL + request.getParameter( Constants.PARAMETER_EVENT_ID );
2213 }
2214
2215
2216
2217
2218
2219
2220
2221 public String doModifyCalendarParameterValues( HttpServletRequest request ) throws AccessDeniedException
2222 {
2223 if ( !RBACService.isAuthorized( CalendarResourceIdService.RESOURCE_TYPE, RBAC.WILDCARD_RESOURCES_ID,
2224 CalendarResourceIdService.PERMISSION_MANAGE, getUser( ) ) )
2225 {
2226 throw new AccessDeniedException( );
2227 }
2228
2229 ReferenceList listParams = CalendarParameterHome.findParametersList( getPlugin( ) );
2230 for ( ReferenceItem param : listParams )
2231 {
2232 String strParamValue = request.getParameter( param.getCode( ) );
2233 if ( strParamValue == null || strParamValue.equals( Constants.EMPTY_STRING ) )
2234 {
2235 strParamValue = Constants.ZERO;
2236 }
2237 if ( !strParamValue.matches( Constants.REG_NUMBER ) )
2238 {
2239 return AdminMessageService.getMessageUrl( request, MESSAGE_INVALID_NUMBER_FORMAT,
2240 AdminMessage.TYPE_STOP );
2241 }
2242 param.setName( strParamValue );
2243 CalendarParameterHome.update( param, getPlugin( ) );
2244 }
2245
2246 return AppPathService.getBaseUrl( request ) + JSP_URL_MANAGE_ADVANCED_PARAMETERS;
2247 }
2248 }