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.newsletter.web;
35
36 import java.io.BufferedReader;
37 import java.io.FileNotFoundException;
38 import java.io.FileReader;
39 import java.io.IOException;
40 import java.io.InputStreamReader;
41 import java.io.OutputStream;
42 import java.io.Reader;
43 import java.sql.Timestamp;
44 import java.util.ArrayList;
45 import java.util.Collection;
46 import java.util.Collections;
47 import java.util.HashMap;
48 import java.util.List;
49 import java.util.Locale;
50 import java.util.Map;
51
52 import javax.servlet.http.HttpServletRequest;
53 import javax.servlet.http.HttpServletResponse;
54
55 import org.apache.commons.fileupload.FileItem;
56 import org.apache.commons.io.IOUtils;
57 import org.apache.commons.lang3.ArrayUtils;
58 import org.apache.commons.lang3.StringUtils;
59
60 import au.com.bytecode.opencsv.CSVReader;
61 import fr.paris.lutece.plugins.newsletter.business.NewsLetter;
62 import fr.paris.lutece.plugins.newsletter.business.NewsLetterHome;
63 import fr.paris.lutece.plugins.newsletter.business.NewsLetterProperties;
64 import fr.paris.lutece.plugins.newsletter.business.NewsLetterTemplate;
65 import fr.paris.lutece.plugins.newsletter.business.NewsLetterTemplateHome;
66 import fr.paris.lutece.plugins.newsletter.business.NewsletterPropertiesHome;
67 import fr.paris.lutece.plugins.newsletter.business.SendingNewsLetter;
68 import fr.paris.lutece.plugins.newsletter.business.SendingNewsLetterHome;
69 import fr.paris.lutece.plugins.newsletter.business.Subscriber;
70 import fr.paris.lutece.plugins.newsletter.business.SubscriberHome;
71 import fr.paris.lutece.plugins.newsletter.business.topic.NewsletterTopic;
72 import fr.paris.lutece.plugins.newsletter.business.topic.NewsletterTopicHome;
73 import fr.paris.lutece.plugins.newsletter.service.NewsLetterRegistrationService;
74 import fr.paris.lutece.plugins.newsletter.service.NewsletterPlugin;
75 import fr.paris.lutece.plugins.newsletter.service.NewsletterResourceIdService;
76 import fr.paris.lutece.plugins.newsletter.service.NewsletterService;
77 import fr.paris.lutece.plugins.newsletter.service.topic.NewsletterTopicService;
78 import fr.paris.lutece.plugins.newsletter.util.NewsLetterConstants;
79 import fr.paris.lutece.plugins.newsletter.util.NewsletterUtils;
80 import fr.paris.lutece.portal.business.rbac.RBAC;
81 import fr.paris.lutece.portal.business.user.AdminUser;
82 import fr.paris.lutece.portal.business.workgroup.AdminWorkgroupHome;
83 import fr.paris.lutece.portal.service.admin.AccessDeniedException;
84 import fr.paris.lutece.portal.service.admin.AdminUserService;
85 import fr.paris.lutece.portal.service.i18n.I18nService;
86 import fr.paris.lutece.portal.service.message.AdminMessage;
87 import fr.paris.lutece.portal.service.message.AdminMessageService;
88 import fr.paris.lutece.portal.service.plugin.Plugin;
89 import fr.paris.lutece.portal.service.plugin.PluginService;
90 import fr.paris.lutece.portal.service.rbac.RBACService;
91 import fr.paris.lutece.portal.service.template.AppTemplateService;
92 import fr.paris.lutece.portal.service.util.AppLogService;
93 import fr.paris.lutece.portal.service.util.AppPathService;
94 import fr.paris.lutece.portal.service.util.AppPropertiesService;
95 import fr.paris.lutece.portal.service.workgroup.AdminWorkgroupService;
96 import fr.paris.lutece.portal.web.admin.PluginAdminPageJspBean;
97 import fr.paris.lutece.portal.web.constants.Messages;
98 import fr.paris.lutece.portal.web.constants.Parameters;
99 import fr.paris.lutece.portal.web.upload.MultipartHttpServletRequest;
100 import fr.paris.lutece.portal.web.util.LocalizedPaginator;
101 import fr.paris.lutece.util.ReferenceList;
102 import fr.paris.lutece.util.datatable.DataTableManager;
103 import fr.paris.lutece.util.date.DateUtil;
104 import fr.paris.lutece.util.filesystem.UploadUtil;
105 import fr.paris.lutece.util.html.HtmlTemplate;
106 import fr.paris.lutece.util.html.IPaginator;
107 import fr.paris.lutece.util.html.Paginator;
108 import fr.paris.lutece.util.sort.AttributeComparator;
109 import fr.paris.lutece.util.string.StringUtil;
110 import fr.paris.lutece.util.url.UrlItem;
111
112
113
114
115 public class NewsletterJspBean extends PluginAdminPageJspBean
116 {
117
118
119
120 public static final String RIGHT_NEWSLETTER_MANAGEMENT = "NEWSLETTER_MANAGEMENT";
121
122
123
124
125 private static final long serialVersionUID = 5581671308419705321L;
126
127 private static final String CONSTANT_CSV_FILE_EXTENSION = ".csv";
128 private static final String CONSTANT_EMAIL_COLUMN_INDEX = "newsletter.csv.import.columnindex";
129 private static final String PROPERTY_LIMIT_MAX_SUSCRIBER = "newsletter.limit.max";
130 private static final String PROPERTY_LIMIT_MIN_SUSCRIBER = "newsletter.limit.min";
131
132 private static final String PROPERTY_REGISTER_ACTION = "newsletter.compose_newsletter.buttonRegister";
133 private static final String PROPERTY_PREPARE_SENDING_ACTION = "newsletter.compose_newsletter.buttonPrepareSending";
134 private static final String PROPERTY_CANCEL_ACTION = "newsletter.compose_newsletter.buttonCancel";
135 private static final String PROPERTY_TEST_SENDING_ACTION = "newsletter.compose_newsletter.buttonTestSending";
136 private static final String PROPERTY_LIMIT_CONFIRM_DAYS = "newsletter.confirm.limit";
137 private static final String PROPERTY_SELECT_MANDATORY = "newsletter.manage_archive.multiSelectError";
138
139
140 private static final String PROPERTY_CSS_FILES = "newsletter.css.files";
141 private static final String SEPARATOR_PROPERTY_CSS_FILES = ";";
142 private static final String SEPARATOR_CSS_FILES_CONTENT = "\n";
143
144
145 private static final String PROPERTY_IMPORT_DELIMITER = "newsletter.csv.import.delimiter";
146
147
148 private static final String TEMPLATE_MANAGE_NEWSLETTERS = "admin/plugins/newsletter/manage_newsletters.html";
149 private static final String TEMPLATE_MANAGE_NEWSLETTERS_PROPERTIES = "admin/plugins/newsletter/manage_newsletters_properties.html";
150 private static final String TEMPLATE_MODIFY_NEWSLETTER = "admin/plugins/newsletter/modify_newsletter.html";
151 private static final String TEMPLATE_CREATE_NEWSLETTER = "admin/plugins/newsletter/create_newsletter.html";
152 private static final String TEMPLATE_COMPOSE_NEWSLETTER = "admin/plugins/newsletter/compose_newsletter.html";
153 private static final String TEMPLATE_PREPARE_NEWSLETTER = "admin/plugins/newsletter/prepare_newsletter.html";
154 private static final String TEMPLATE_SEND_NEWSLETTER = "admin/plugins/newsletter/send_newsletter.html";
155 private static final String TEMPLATE_MANAGE_SUBSCRIBERS = "admin/plugins/newsletter/manage_subscribers.html";
156 private static final String TEMPLATE_IMPORT_SUBSCRIBERS = "admin/plugins/newsletter/import_subscribers.html";
157 private static final String TEMPLATE_MANAGE_OLD_NEWSLETTERS = "admin/plugins/newsletter/manage_old_newsletters.html";
158 private static final String TEMPLATE_MANAGE_NEWSLETTER_TOPICS = "admin/plugins/newsletter/manage_newsletter_topics.html";
159 private static final String TEMPLATE_MODIFY_TOPIC_CONFIG = "admin/plugins/newsletter/modify_topic_config.html";
160
161
162 private static final String MARK_LIST_NEWSLETTER_TEMPLATES = "newsletter_templates";
163 private static final String MARK_NEWSLETTER = "newsletter";
164 private static final String MARK_NEWSLETTER_DESCRIPTION = "newsletter_description";
165 private static final String MARK_DATE_LAST_SENDING = "date_last_sending";
166 private static final String MARK_NEWSLETTER_ALLOW_CREATION = "newsletter_allow_creation";
167 private static final String MARK_NEWSLETTER_ALLOW_MANAGE_ARCHIVE = "newsletter_allow_manage_archive";
168 private static final String MARK_NEWSLETTER_ALLOW_DELETION = "newsletter_allow_deletion";
169 private static final String MARK_NEWSLETTER_ALLOW_MODIFICATION = "newsletter_allow_modification";
170 private static final String MARK_NEWSLETTER_ALLOW_MANAGE_SUBSCRIBERS = "newsletter_allow_manage_subscribers";
171 private static final String MARK_NEWSLETTER_ALLOW_EXPORT_SUBSCRIBERS = "newsletter_allow_export_subscribers";
172 private static final String MARK_NEWSLETTER_ALLOW_SENDING = "newsletter_allow_sending";
173 private static final String MARK_NEWSLETTER_WORKGROUP_DESCRIPTION = "newsletter_workgroup_description";
174 private static final String MARK_NEWSLETTER_COUNT_SUBSCRIBERS = "newsletter_count_subscribers";
175 private static final String MARK_NEWSLETTER_ID = "newsletter_id";
176 private static final String MARK_IMPORT_DELETE = "import_delete";
177 private static final String MARK_NEWSLETTER_CONTENT = "newsletter_content";
178 private static final String MARK_HTML_CONTENT = "html_content";
179 private static final String MARK_WEBAPP_URL = "webapp_url";
180 private static final String MARK_NEWSLETTER_TEMPLATE_ID = "newsletter_template_id";
181 private static final String MARK_PREVIEW = "newsletter_preview";
182 private static final String MARK_NEWSLETTER_OBJECT = "newsletter_object";
183 private static final String MARK_REGISTER_ACTION = "register_action";
184 private static final String MARK_PREPARE_SENDING_ACTION = "prepare_sending_action";
185 private static final String MARK_CANCEL_ACTION = "cancel_action";
186 private static final String MARK_DATE_LAST_SEND = "newsletter_last_sent";
187 private static final String MARK_IMG_PATH = "img_path";
188 private static final String MARK_LOCALE = "locale";
189 private static final String MARK_PROPERTIES = "properties";
190 private static final String MARK_NEWSLETTER_LIST = "newsletters_list";
191 private static final String MARK_ALLOW_CREATION = "creation_allowed";
192 private static final String MARK_LIST_TOPIC_TYPES = "list_topic_types";
193 private static final String MARK_NEWSLETTER_TABLE_MANAGER = "table_manager";
194 private static final String MARK_SECTION_SIZES = "section_size";
195 private static final String MARK_SUBSCRIBERS_LIST = "subscribers_list";
196 private static final String MARK_WORKGROUP_LIST = "workgroup_list";
197 private static final String MARK_PAGINATOR = "paginator";
198 private static final String MARK_NB_ITEMS_PER_PAGE = "nb_items_per_page";
199 private static final String MARK_CSS = "newsletter_css";
200 private static final String MARK_UNSUBSCRIBE = "unsubscribe";
201 private static final String MARK_UNSUBSCRIBE_LIST = "unsubscribe_list";
202 private static final String MARK_DISPLAY_STATUS = "display_status";
203 private static final String MARK_IS_ACTIVE_CAPTCHA = "is_active_captcha";
204 private static final String MARK_ADD_SUBSCRIBER_RIGHT = "is_add_subscriber_right";
205 private static final String MARK_IMPORT_SUBSCRIBER_RIGHT = "is_import_subscriber_right";
206 private static final String MARK_EXPORT_SUBSCRIBER_RIGTH = "is_export_subscriber_right";
207 private static final String MARK_CLEAN_RIGHT = "is_clean_subscriber_right";
208 private static final String MARK_NEWSLETTER_TOPIC_TITLE = "title";
209 private static final String MARK_NEWSLETTER_TOPIC_TYPE = "topicTypeName";
210 private static final String MARK_NEWSLETTER_TOPIC_ORDER = "order";
211 private static final String MARK_CONTENT = "content";
212 private static final String MARK_TOPIC = "topic";
213 private static final String MARK_SEARCH_STRING = "search_string";
214 private static final String MARK_RIGHT_MANAGE_NEWSLETTER_PROPERTIES = "right_manage_newsletter_properties";
215
216
217 private static final String PARAMETER_ACTION = "action";
218 private static final String PARAMETER_NEWSLETTER_ID = "newsletter_id";
219 private static final String PARAMETER_TOPIC_TYPE = "topic_type";
220 private static final String PARAMETER_SENDING_NEWSLETTER_ID = "sending_newsletter_id";
221 private static final String PARAMETER_TOPIC_SECTION_NUMBER = "topic_section_number";
222 private static final String PARAMETER_CANCEL = "cancel";
223 private static final String PARAMETER_NEWSLETTER_NAME = "newsletter_name";
224 private static final String PARAMETER_NEWSLETTER_DESCRIPTION = "newsletter_description";
225 private static final String PARAMETER_NEWSLETTER_SENDER_MAIL = "newsletter_sender_mail";
226 private static final String PARAMETER_NEWSLETTER_SENDER_NAME = "newsletter_sender_name";
227 private static final String PARAMETER_DATE_FIRST_SEND = "date_first_send";
228 private static final String PARAMETER_DATE_LAST_SEND = "date_last_send";
229 private static final String PARAMETER_SUBSCRIBER_ID = "subscriber_id";
230 private static final String PARAMETER_NEWSLETTER_OBJECT = "newsletter_object";
231 private static final String PARAMETER_GENERATE = "generate";
232 private static final String PARAMETER_HTML_CONTENT = "html_content";
233 private static final String PARAMETER_SUBSCRIBERS_FILE = "newsletter_import_path";
234 private static final String PARAMETER_NEWSLETTER_WORKGROUP = "newsletter_workgroup";
235 private static final String PARAMETER_TERM_OF_SERVICE = "tos";
236 private static final String PARAMETER_NEWSLETTER_UNSUBSCRIBE = "newsletter_unsubscribe";
237 private static final String PARAMETER_PAGE_INDEX = "page_index";
238 private static final String PARAMETER_TEST_RECIPIENTS = "newsletter_test_recipients";
239 private static final String PARAMETER_TEST_SUBJECT = "newsletter_test_subject";
240 private static final String PARAMETER_ACTIVE_CAPTCHA = "active_captcha";
241 private static final String PARAMETER_ACTIVE_VALIDATION = "active_validation";
242 private static final String PARAMETER_SUBSCRIBERS_SELECTION = "subscriber_selection";
243 private static final String PARAMETER_TOPIC_ID = "topic_id";
244 private static final String PARAMETER_NEWSLETTER_TOPICS_TABLE_MANAGER = "newsletter_topics_table_manager";
245 private static final String PARAMETER_MOVE_UP = "move_up";
246 private static final String PARAMETER_TITLE = "title";
247 private static final String PARAMETER_UPDATE_TEMPLATE = "update_template";
248 private static final String PARAMETER_NEWSLETTER_SELECTION = "newsletter_selection";
249
250
251 private static final String JSP_URL_DO_COMPOSE_NEWSLETTER = "ComposeNewsLetter.jsp";
252 private static final String JSP_URL_DO_PREPARE_NEWSLETTER = "DoPrepareNewsLetter.jsp";
253 private static final String JSP_URL_CONFIRM_TEST_NEWSLETTER = "ConfirmTestNewsLetter.jsp";
254 private static final String JSP_URL_DO_REMOVE_NEWSLETTER = "jsp/admin/plugins/newsletter/DoRemoveNewsLetter.jsp";
255 private static final String JSP_URL_DO_REMOVE_SENDING_NEWSLETTER = "jsp/admin/plugins/newsletter/DoRemoveSendingNewsLetter.jsp";
256 private static final String JSP_URL_DO_REMOVE_MULTI_NEWSLETTER = "jsp/admin/plugins/newsletter/DoRemoveMultiNewsLetter.jsp";
257 private static final String JSP_URL_DO_REMOVE_SUBSCRIBER = "jsp/admin/plugins/newsletter/DoUnsubscribeNewsLetterAdmin.jsp";
258 private static final String JSP_URL_DO_REMOVE_SELECTION = "jsp/admin/plugins/newsletter/DoRemoveSelection.jsp";
259 private static final String JSP_URL_MANAGE_NEWSLETTER = "ManageNewsLetter.jsp";
260 private static final String JSP_URL_MANAGE_SUBSCRIBERS = "ManageSubscribers.jsp";
261 private static final String JSP_URL_MANAGE_ARCHIVE = "ManageArchive.jsp";
262 private static final String JSP_URL_PREPARE_NEWSLETTER = "PrepareNewsLetter.jsp";
263 private static final String JSP_URL_SEND_NEWSLETTER = "jsp/admin/plugins/newsletter/DoSendNewsLetter.jsp";
264 private static final String JSP_URL_TEST_NEWSLETTER = "jsp/admin/plugins/newsletter/DoTestNewsLetter.jsp";
265 private static final String JSP_URL_MANAGE_NEWSLETTER_TOPIC = "jsp/admin/plugins/newsletter/GetManageNewsletterTopics.jsp";
266 private static final String JSP_URL_MODIFY_TOPIC_CONFIG = "GetModifyTopicConfig.jsp";
267 private static final String JSP_URL_DO_REMOVE_TOPIC = "jsp/admin/plugins/newsletter/DoRemoveNewsletterTopic.jsp";
268 private static final String JSP_URL_MANAGE_TOPICS = "GetManageNewsletterTopics.jsp";
269 private static final String JSP_URL_MODIFY_NEWSLETTER = "ModifyNewsLetter.jsp";
270
271
272 private static final String MESSAGE_CONFIRM_TEST_NEWSLETTER = "newsletter.message.confirmTestNewsletter";
273 private static final String MESSAGE_LINKED_TO_NEWSLETTER = "newsletter.message.linkedPortlet";
274 private static final String MESSAGE_CONFIRM_CANCEL_COMPOSE = "newsletter.message.confirmCancelComposeNewsletter";
275 private static final String MESSAGE_CONFIRM_REMOVE_NEWSLETTER = "newsletter.message.confirmRemoveNewsletter";
276 private static final String MESSAGE_CONFIRM_REMOVE_SENDING_NEWSLETTER = "newsletter.message.confirmRemoveSendingNewsletter";
277 private static final String MESSAGE_CONFIRM_REMOVE_MULTI_SENDING_NEWSLETTER = "newsletter.message.confirmRemoveMultiSendingNewsletter";
278 private static final String MESSAGE_CONFIRM_REMOVE_SUBSCRIBER = "newsletter.message.confirmRemoveSubscriber";
279 private static final String MESSAGE_CONFIRM_REMOVE_SELECTION = "newsletter.message.confirmRemoveSelection";
280 private static final String MESSAGE_CONFIRM_SEND_NEWSLETTER = "newsletter.message.confirmSendNewsletter";
281 private static final String MESSAGE_CSV_FILE_EMPTY_OR_NOT_VALID_EMAILS = "newsletter.message.csvFileEmptyOrNotValidEmails";
282 private static final String MESSAGE_COLUMN_INDEX_NOT_EXIST = "newsletter.message.csvColumnIndexNotExist";
283 private static final String MESSAGE_CSV_FILE_EXTENSION = "newsletter.message.csvFileExtension";
284 private static final String MESSAGE_EMAIL_EXISTS = "newsletter.message.emailExists";
285 private static final String MESSAGE_FIELD_EMAIL_VALID = "newsletter.message.fieldEmailValid";
286 private static final String MESSAGE_NO_SUBSCRIBER = "newsletter.message.noSubscriber";
287 private static final String MESSAGE_NO_SUBSCRIBER_EXPORT = "newsletter.message.noSubscriberExport";
288 private static final String MESSAGE_WRONG_EMAIL = "newsletter.message.wrongEmail";
289 private static final String MESSAGE_WRONG_EMAIL_SENDER = "newsletter.message.wrongEmailSender";
290 private static final String MESSAGE_WRONG_DATE_LAST_SEND = "newsletter.message.wrongDateLastSend";
291 private static final String MESSAGE_SENDING_EMPTY_NOT_ALLOWED = "newsletter.message.sendingEmptyNotAllowed";
292 private static final String MESSAGE_NO_TEMPLATE = "newsletter.message.noTemplate";
293 private static final String MESSAGE_OBJECT_NOT_SPECIFIED = "newsletter.message.noObjectSpecified";
294 private static final String MESSAGE_SUBSCRIBERS_CLEANED = "newsletter.message.subscribersCleaned";
295 private static final String MESSAGE_PAGE_TITLE_MANAGE_TOPICS = "newsletter.manage_topics.pageTitle";
296 private static final String MESSAGE_CONFIRM_REMOVE_TOPIC = "newsletter.manage_topics.confirmRemoveTopic";
297 private static final String MESSAGE_FRAGMENT_NO_CHANGE = "newsletter.message.fragment_no_change";
298 private static final String MESSAGE_USER_NOT_ALLOWED_NEWSLETTER_PROPERTIES = "Newsletter properties : user not allowed to access this feature : ";
299
300 private static final String PROPERTY_PAGE_TITLE_IMPORT = "newsletter.import_subscribers.pageTitle";
301 private static final String PROPERTY_PAGE_TITLE_IMPORT_DELETE = "newsletter.import_delete_subscribers.pageTitle";
302 private static final String PROPERTY_PAGE_TITLE_NEWSLETTERS = "newsletter.manage_newsletters.pageTitle";
303 private static final String PROPERTY_PAGE_TITLE_ARCHIVE = "newsletter.manage_archive.pageTitle";
304 private static final String PROPERTY_PAGE_TITLE_NEWSLETTERS_PROPERTIES = "newsletter.manage_newsletters_properties.pageTitle";
305 private static final String PROPERTY_PAGE_TITLE_CREATE = "newsletter.create_newsletter.pageTitle";
306 private static final String PROPERTY_PAGE_TITLE_MODIFY_TOPIC_CONFIGURATION = "newsletter.modify_topic_config.pageTitle";
307
308 private static final String LABEL_NEWSLETTER_TOPIC_TITLE = "newsletter.manage_topics.labelTopicTitle";
309 private static final String LABEL_NEWSLETTER_TOPIC_TYPE = "newsletter.manage_topics.labelTopicType";
310 private static final String LABEL_NEWSLETTER_TOPIC_ORDER = "newsletter.manage_topics.labelTopicOrder";
311 private static final String LABEL_NEWSLETTER_TOPIC_SECTION = "newsletter.manage_topics.labelTopicSection";
312 private static final String LABEL_NEWSLETTER_ACTION = "newsletter.manage_topics.labelActions";
313 private static final String LABLE_COPY_NEWSLETTER_TITLE = "newsletter.manage_newsletters.copy.title";
314
315 private static final String PROPERTY_PAGE_TITLE_COMPOSE = "newsletter.compose_newsletter.pageTitle";
316 private static final String PROPERTY_PAGE_TITLE_MODIFY = "newsletter.modify_newsletter.pageTitle";
317 private static final String PROPERTY_PAGE_TITLE_MANAGE_SUBSCRIBERS = "newsletter.manage_subscribers.pageTitle";
318 private static final String PROPERTY_PAGE_TITLE_PREPARE = "newsletter.prepare_newsletter.pageTitle";
319 private static final String PROPERTY_USERS_PER_PAGE = "paginator.user.itemsPerPage";
320 private static final String PROPERTY_NEWSLETTERS_PER_PAGE = "newsletter.newslettersPerPage";
321 private static final String PROPERTY_LABEL_UNSUBSCRIBE_TRUE = "newsletter.unsubscribe.true";
322 private static final String PROPERTY_LABEL_UNSUBSCRIBE_FALSE = "newsletter.unsubscribe.false";
323 private static final String PROPERTY_TEST_SUBJECT = "newsletter.test.subject";
324 private static final String PROPERTY_ITEMS_PER_PAGE = "newsletter.itemsPerPage";
325
326 private static final int CONSTANT_DEFAULT_ITEM_PER_PAGE = 50;
327 private static final String CONSTANT_FREEMARKER_MACRO_COLUMN_SECTION = "getSectionColumn";
328
329
330 private static final String JCAPTCHA_PLUGIN = "jcaptcha";
331 private static final int DEFAULT_LIMIT = 7;
332 private int _nItemsPerPage;
333 private int _nDefaultItemsPerPage;
334 private String _strCurrentPageIndex;
335 private String [ ] _multiSelectionValues;
336 private NewsletterService _newsletterService = NewsletterService.getService( );
337 private NewsletterTopicService _newsletterTopicService = NewsletterTopicService.getService( );
338
339
340
341
342 public NewsletterJspBean( )
343 {
344 _nDefaultItemsPerPage = AppPropertiesService.getPropertyInt( PROPERTY_NEWSLETTERS_PER_PAGE, 10 );
345 }
346
347
348
349
350
351
352
353
354 public String getManageNewsLetters( HttpServletRequest request )
355 {
356 setPageTitleProperty( PROPERTY_PAGE_TITLE_NEWSLETTERS );
357 _strCurrentPageIndex = Paginator.getPageIndex( request, Paginator.PARAMETER_PAGE_INDEX, _strCurrentPageIndex );
358 _nItemsPerPage = Paginator.getItemsPerPage( request, Paginator.PARAMETER_ITEMS_PER_PAGE, _nItemsPerPage, _nDefaultItemsPerPage );
359
360 Map<String, Object> model = new HashMap<String, Object>( );
361 Collection<NewsLetter> listNewsletter = NewsLetterHome.findAll( getPlugin( ) );
362 listNewsletter = AdminWorkgroupService.getAuthorizedCollection( listNewsletter, getUser( ) );
363
364 Collection<Map<String, Object>> listNewsletterDisplay = new ArrayList<Map<String, Object>>( );
365
366 for ( NewsLetter newsletter : listNewsletter )
367 {
368 Map<String, Object> newsletterDisplay = new HashMap<String, Object>( );
369 newsletterDisplay.put( MARK_NEWSLETTER, newsletter );
370 newsletterDisplay.put( MARK_NEWSLETTER_ALLOW_CREATION,
371 RBACService.isAuthorized( newsletter, NewsletterResourceIdService.PERMISSION_CREATE, getUser( ) ) );
372
373 newsletterDisplay.put( MARK_NEWSLETTER_ALLOW_MANAGE_ARCHIVE,
374 RBACService.isAuthorized( newsletter, NewsletterResourceIdService.PERMISSION_ARCHIVE, getUser( ) ) );
375
376 newsletterDisplay.put( MARK_NEWSLETTER_ALLOW_DELETION,
377 RBACService.isAuthorized( newsletter, NewsletterResourceIdService.PERMISSION_DELETE, getUser( ) ) );
378 newsletterDisplay.put( MARK_NEWSLETTER_ALLOW_MANAGE_SUBSCRIBERS,
379 RBACService.isAuthorized( newsletter, NewsletterResourceIdService.PERMISSION_MANAGE_SUBSCRIBERS, getUser( ) ) );
380 newsletterDisplay.put( MARK_NEWSLETTER_ALLOW_EXPORT_SUBSCRIBERS,
381 RBACService.isAuthorized( newsletter, NewsletterResourceIdService.PERMISSION_EXPORT_SUBSCRIBERS, getUser( ) ) );
382 newsletterDisplay.put( MARK_NEWSLETTER_ALLOW_MODIFICATION,
383 RBACService.isAuthorized( newsletter, NewsletterResourceIdService.PERMISSION_MODIFY, getUser( ) ) );
384 newsletterDisplay.put( MARK_NEWSLETTER_ALLOW_SENDING,
385 RBACService.isAuthorized( newsletter, NewsletterResourceIdService.PERMISSION_SEND, getUser( ) ) );
386
387
388 if ( newsletter.getWorkgroup( ).equals( NewsLetterConstants.ALL_GROUPS ) )
389 {
390 newsletterDisplay.put( MARK_NEWSLETTER_WORKGROUP_DESCRIPTION,
391 I18nService.getLocalizedString( NewsLetterConstants.PROPERTY_LABEL_ALL_GROUPS, getLocale( ) ) );
392 }
393 else
394 {
395 newsletterDisplay.put( MARK_NEWSLETTER_WORKGROUP_DESCRIPTION,
396 AdminWorkgroupHome.findByPrimaryKey( newsletter.getWorkgroup( ) ).getDescription( ) );
397 }
398
399 newsletterDisplay.put( MARK_NEWSLETTER_COUNT_SUBSCRIBERS, NewsLetterHome.findNbrSubscribers( newsletter.getId( ), getPlugin( ) ) );
400 listNewsletterDisplay.add( newsletterDisplay );
401 }
402
403 IPaginator<Map<String, Object>> paginator = new Paginator<Map<String, Object>>( (List<Map<String, Object>>) listNewsletterDisplay, _nItemsPerPage,
404 getHomeUrl( request ), PARAMETER_PAGE_INDEX, _strCurrentPageIndex );
405
406 model.put( MARK_NEWSLETTER_LIST, paginator.getPageItems( ) );
407 model.put( MARK_PAGINATOR, paginator );
408 model.put( MARK_ALLOW_CREATION, isNewsletterCreationAllowed( request ) );
409 model.put( MARK_NB_ITEMS_PER_PAGE, StringUtils.EMPTY + _nItemsPerPage );
410 model.put( MARK_RIGHT_MANAGE_NEWSLETTER_PROPERTIES, RBACService.isAuthorized( NewsLetter.RESOURCE_TYPE, RBAC.WILDCARD_RESOURCES_ID,
411 NewsletterResourceIdService.PERMISSION_NEWSLETTER_ADVANCED_SETTINGS, getUser( ) ) );
412
413
414 HtmlTemplate templateList = AppTemplateService.getTemplate( TEMPLATE_MANAGE_NEWSLETTERS, getLocale( ), model );
415
416 return getAdminPage( templateList.getHtml( ) );
417 }
418
419
420
421
422
423
424
425
426 public String getManageArchive( HttpServletRequest request )
427 {
428 setPageTitleProperty( PROPERTY_PAGE_TITLE_ARCHIVE );
429 _strCurrentPageIndex = Paginator.getPageIndex( request, Paginator.PARAMETER_PAGE_INDEX, _strCurrentPageIndex );
430 _nItemsPerPage = Paginator.getItemsPerPage( request, Paginator.PARAMETER_ITEMS_PER_PAGE, _nItemsPerPage, _nDefaultItemsPerPage );
431
432 int nIdNewsletter = Integer.parseInt( request.getParameter( PARAMETER_NEWSLETTER_ID ) );
433 Map<String, Object> model = new HashMap<String, Object>( );
434 List<SendingNewsLetter> listNewsletter = SendingNewsLetterHome.findAllLastSendingForNewsletterId( nIdNewsletter, getPlugin( ) );
435
436 UrlItem url = new UrlItem( request.getRequestURI( ) );
437 url.addParameter( PARAMETER_NEWSLETTER_ID, nIdNewsletter );
438
439 IPaginator<SendingNewsLetter> paginator = new Paginator<SendingNewsLetter>( listNewsletter, _nItemsPerPage, url.getUrl( ), PARAMETER_PAGE_INDEX,
440 _strCurrentPageIndex );
441
442 model.put( MARK_NEWSLETTER_LIST, paginator.getPageItems( ) );
443 model.put( MARK_PAGINATOR, paginator );
444 model.put( MARK_NEWSLETTER_ID, nIdNewsletter );
445 model.put( MARK_NB_ITEMS_PER_PAGE, StringUtils.EMPTY + _nItemsPerPage );
446
447 HtmlTemplate templateList = AppTemplateService.getTemplate( TEMPLATE_MANAGE_OLD_NEWSLETTERS, getLocale( ), model );
448
449 return getAdminPage( templateList.getHtml( ) );
450 }
451
452
453
454
455
456
457
458
459
460
461 public String getManageNewsLettersProperties( HttpServletRequest request ) throws AccessDeniedException
462 {
463 if ( !RBACService.isAuthorized( NewsLetter.RESOURCE_TYPE, RBAC.WILDCARD_RESOURCES_ID,
464 NewsletterResourceIdService.PERMISSION_NEWSLETTER_ADVANCED_SETTINGS, getUser( ) ) )
465 {
466 throw new AccessDeniedException( MESSAGE_USER_NOT_ALLOWED_NEWSLETTER_PROPERTIES + AdminUserService.getAdminUser( request ).getAccessCode( ) );
467 }
468
469 setPageTitleProperty( PROPERTY_PAGE_TITLE_NEWSLETTERS_PROPERTIES );
470
471 Map<String, Object> model = new HashMap<String, Object>( );
472
473 NewsLetterProperties properties = NewsletterPropertiesHome.find( getPlugin( ) );
474
475 model.put( MARK_IS_ACTIVE_CAPTCHA, PluginService.isPluginEnable( JCAPTCHA_PLUGIN ) );
476 model.put( MARK_WEBAPP_URL, AppPathService.getBaseUrl( request ) );
477 model.put( MARK_LOCALE, getLocale( ).getLanguage( ) );
478 model.put( MARK_PROPERTIES, properties );
479 model.put( MARK_CLEAN_RIGHT,
480 RBACService.isAuthorized( NewsLetter.RESOURCE_TYPE, null, NewsletterResourceIdService.PERMISSION_CLEAN_SUBSCRIBERS, getUser( ) ) );
481
482 HtmlTemplate templateList = AppTemplateService.getTemplate( TEMPLATE_MANAGE_NEWSLETTERS_PROPERTIES, getLocale( ), model );
483
484 return getAdminPage( templateList.getHtml( ) );
485 }
486
487
488
489
490
491
492
493
494
495
496 public String doManageNewsLetterProperties( HttpServletRequest request ) throws AccessDeniedException
497 {
498 if ( !RBACService.isAuthorized( NewsLetter.RESOURCE_TYPE, RBAC.WILDCARD_RESOURCES_ID,
499 NewsletterResourceIdService.PERMISSION_NEWSLETTER_ADVANCED_SETTINGS, getUser( ) ) )
500 {
501 throw new AccessDeniedException( MESSAGE_USER_NOT_ALLOWED_NEWSLETTER_PROPERTIES + AdminUserService.getAdminUser( request ).getAccessCode( ) );
502 }
503 String strBaseUrl = AppPathService.getBaseUrl( request );
504 String strActiveCaptcha = request.getParameter( PARAMETER_ACTIVE_CAPTCHA );
505 String strActiveValidation = request.getParameter( PARAMETER_ACTIVE_VALIDATION );
506
507 NewsLetterPropertiesess/NewsLetterProperties.html#NewsLetterProperties">NewsLetterProperties properties = new NewsLetterProperties( );
508
509 properties.setTOS( doClean( request.getParameter( PARAMETER_TERM_OF_SERVICE ), strBaseUrl ) );
510
511 if ( strActiveCaptcha != null )
512 {
513 properties.setCaptchaActive( true );
514 }
515 else
516 {
517 properties.setCaptchaActive( false );
518 }
519
520 if ( strActiveValidation != null )
521 {
522 properties.setValidationActive( true );
523 }
524 else
525 {
526 properties.setValidationActive( false );
527 }
528
529 NewsletterPropertiesHome.update( properties, getPlugin( ) );
530
531 UrlItem url = new UrlItem( JSP_URL_MANAGE_NEWSLETTER );
532
533 return url.getUrl( );
534 }
535
536
537
538
539
540
541
542
543 public String getCreateNewsLetter( HttpServletRequest request )
544 {
545
546 if ( !isNewsletterCreationAllowed( request ) )
547 {
548 return getManageNewsLetters( request );
549 }
550
551 setPageTitleProperty( PROPERTY_PAGE_TITLE_CREATE );
552
553 Map<String, Object> model = new HashMap<String, Object>( );
554
555
556 ReferenceList listUnsubscribe = new ReferenceList( );
557 listUnsubscribe.addItem( NewsLetterConstants.PROPERTY_UNSUBSCRIBE_TRUE,
558 I18nService.getLocalizedString( PROPERTY_LABEL_UNSUBSCRIBE_TRUE, getLocale( ) ) );
559 listUnsubscribe.addItem( NewsLetterConstants.PROPERTY_UNSUBSCRIBE_FALSE,
560 I18nService.getLocalizedString( PROPERTY_LABEL_UNSUBSCRIBE_FALSE, getLocale( ) ) );
561
562 String strBaseUrl = AppPathService.getProdUrl( request );
563
564 model.put( MARK_DATE_LAST_SEND, DateUtil.getCurrentDateString( getLocale( ) ) );
565 model.put( MARK_WORKGROUP_LIST, AdminWorkgroupService.getUserWorkgroups( getUser( ), getLocale( ) ) );
566 model.put( MARK_UNSUBSCRIBE_LIST, listUnsubscribe );
567 model.put( MARK_LOCALE, getLocale( ) );
568 model.put( MARK_WEBAPP_URL, strBaseUrl );
569
570 HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_CREATE_NEWSLETTER, getLocale( ), model );
571
572 return getAdminPage( template.getHtml( ) );
573 }
574
575
576
577
578
579
580
581
582 public String getComposeNewsLetter( HttpServletRequest request )
583 {
584 String strNewsletterId = request.getParameter( PARAMETER_NEWSLETTER_ID );
585 int nNewsLetterId = Integer.parseInt( strNewsletterId );
586 NewsLetter newsletter = NewsLetterHome.findByPrimaryKey( nNewsLetterId, getPlugin( ) );
587 AdminUser user = getUser( );
588
589
590 if ( !AdminWorkgroupService.isAuthorized( newsletter, getUser( ) )
591 || !RBACService.isAuthorized( NewsLetter.RESOURCE_TYPE, strNewsletterId, NewsletterResourceIdService.PERMISSION_MODIFY, getUser( ) ) )
592 {
593 return getManageNewsLetters( request );
594 }
595
596 setPageTitleProperty( PROPERTY_PAGE_TITLE_COMPOSE );
597
598 String strBaseUrl = AppPathService.getProdUrl( request );
599
600 String strPathImageTemplate = _newsletterService.getImageFolderPath( AppPathService.getBaseUrl( request ) );
601
602 Map<String, Object> model = new HashMap<String, Object>( );
603
604
605 String strGenerate = request.getParameter( PARAMETER_GENERATE );
606
607 int nTemplateNewsLetterId = newsletter.getNewsLetterTemplateId( );
608 String strHtmlContent = null;
609
610 if ( ( strGenerate == null ) )
611 {
612
613 strHtmlContent = ( newsletter.getHtml( ) == null ) ? NewsLetterConstants.CONSTANT_EMPTY_STRING : newsletter.getHtml( );
614 }
615 else
616 {
617 if ( nTemplateNewsLetterId == 0 )
618 {
619 Collection<NewsLetterTemplate> newsletterTemplatesList = NewsLetterTemplateHome.getTemplatesCollectionByType( NewsLetterTemplate.RESOURCE_TYPE,
620 getPlugin( ) );
621 newsletterTemplatesList = AdminWorkgroupService.getAuthorizedCollection( newsletterTemplatesList, getUser( ) );
622
623 for ( NewsLetterTemplate template : newsletterTemplatesList )
624 {
625 if ( StringUtils.equals( template.getResourceTypeCode( ), NewsLetter.RESOURCE_TYPE ) )
626 {
627 nTemplateNewsLetterId = template.getId( );
628 break;
629 }
630 }
631 }
632 if ( nTemplateNewsLetterId > 0 )
633 {
634 strHtmlContent = _newsletterService.generateNewsletterHtmlCode( newsletter, nTemplateNewsLetterId, strBaseUrl, user, getLocale( ) );
635 }
636 if ( strHtmlContent == null )
637 {
638 strHtmlContent = NewsLetterConstants.CONSTANT_EMPTY_STRING;
639
640 }
641 }
642
643 strHtmlContent = strHtmlContent.replaceAll( NewsLetterConstants.MARK_BASE_URL, strBaseUrl );
644
645 strHtmlContent = strHtmlContent.replaceAll( NewsLetterConstants.WEBAPP_PATH_FOR_LINKSERVICE, strBaseUrl );
646
647 model.put( MARK_HTML_CONTENT, strHtmlContent );
648
649 model.put( MARK_NEWSLETTER, newsletter );
650 model.put( MARK_NEWSLETTER_TEMPLATE_ID, nTemplateNewsLetterId );
651 model.put( MARK_REGISTER_ACTION, AppPropertiesService.getProperty( PROPERTY_REGISTER_ACTION ) );
652 model.put( MARK_PREPARE_SENDING_ACTION, AppPropertiesService.getProperty( PROPERTY_PREPARE_SENDING_ACTION ) );
653 model.put( MARK_CANCEL_ACTION, AppPropertiesService.getProperty( PROPERTY_CANCEL_ACTION ) );
654
655 model.put( MARK_WEBAPP_URL, AppPathService.getBaseUrl( request ) );
656 model.put( MARK_LOCALE, getLocale( ).getLanguage( ) );
657 model.put( MARK_IMG_PATH, strPathImageTemplate );
658
659 HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_COMPOSE_NEWSLETTER, getLocale( ), model );
660
661 return getAdminPage( template.getHtml( ) );
662 }
663
664
665
666
667
668
669
670
671 public String doComposeNewsLetter( HttpServletRequest request )
672 {
673 String strNewsletterId = request.getParameter( PARAMETER_NEWSLETTER_ID );
674 int nNewsLetterId = Integer.parseInt( strNewsletterId );
675 NewsLetter newsletter = NewsLetterHome.findByPrimaryKey( nNewsLetterId, getPlugin( ) );
676
677
678 if ( !AdminWorkgroupService.isAuthorized( newsletter, getUser( ) )
679 || !RBACService.isAuthorized( NewsLetter.RESOURCE_TYPE, strNewsletterId, NewsletterResourceIdService.PERMISSION_MODIFY, getUser( ) ) )
680 {
681 return AdminMessageService.getMessageUrl( request, Messages.USER_ACCESS_DENIED, AdminMessage.TYPE_ERROR );
682 }
683
684 Collection<NewsLetterTemplate> newsletterTemplatesList = NewsLetterTemplateHome.getTemplatesCollectionByType( NewsLetterTemplate.RESOURCE_TYPE,
685 getPlugin( ) );
686
687
688 if ( ( newsletterTemplatesList.size( ) == 0 ) )
689 {
690 return AdminMessageService.getMessageUrl( request, MESSAGE_NO_TEMPLATE, AdminMessage.TYPE_STOP );
691 }
692
693 UrlItem url = new UrlItem( JSP_URL_DO_COMPOSE_NEWSLETTER );
694 url.addParameter( PARAMETER_NEWSLETTER_ID, strNewsletterId );
695
696 return url.getUrl( );
697 }
698
699
700
701
702
703
704
705
706 public String doCleanSubscribers( HttpServletRequest request )
707 {
708
709 if ( !RBACService.isAuthorized( NewsLetter.RESOURCE_TYPE, null, NewsletterResourceIdService.PERMISSION_CLEAN_SUBSCRIBERS, getUser( ) ) )
710 {
711 return AdminMessageService.getMessageUrl( request, Messages.USER_ACCESS_DENIED, AdminMessage.TYPE_ERROR );
712 }
713
714 NewsLetterRegistrationService.getInstance( ).doRemoveOldUnconfirmed( );
715
716 int nConfirmLimit = AppPropertiesService.getPropertyInt( PROPERTY_LIMIT_CONFIRM_DAYS, DEFAULT_LIMIT );
717 Object [ ] messages = new String [ 1];
718 messages [0] = Integer.toString( nConfirmLimit );
719
720 return AdminMessageService.getMessageUrl( request, MESSAGE_SUBSCRIBERS_CLEANED, messages, AdminMessage.TYPE_INFO );
721 }
722
723
724
725
726
727
728
729
730 public String doCreateNewsLetter( HttpServletRequest request )
731 {
732
733 String strNewsletterName = request.getParameter( PARAMETER_NEWSLETTER_NAME );
734 String strNewsletterDescription = request.getParameter( PARAMETER_NEWSLETTER_DESCRIPTION );
735 String strDateFirstSend = request.getParameter( PARAMETER_DATE_FIRST_SEND );
736 String strWorkGroup = request.getParameter( PARAMETER_NEWSLETTER_WORKGROUP );
737 String strSenderName = request.getParameter( PARAMETER_NEWSLETTER_SENDER_NAME );
738 String strSenderMail = request.getParameter( PARAMETER_NEWSLETTER_SENDER_MAIL );
739 String strTestRecipients = request.getParameter( PARAMETER_TEST_RECIPIENTS );
740 String strTestSubject = request.getParameter( PARAMETER_TEST_SUBJECT );
741
742
743 if ( !isNewsletterCreationAllowed( request ) )
744 {
745 return getManageNewsLetters( request );
746 }
747
748
749 if ( StringUtils.isEmpty( strSenderMail ) || StringUtils.isEmpty( strTestRecipients ) || StringUtils.isEmpty( strNewsletterName )
750 || StringUtils.isEmpty( strDateFirstSend ) || StringUtils.isEmpty( strWorkGroup ) || StringUtils.isEmpty( strSenderName ) )
751 {
752 return AdminMessageService.getMessageUrl( request, Messages.MANDATORY_FIELDS, AdminMessage.TYPE_STOP );
753 }
754
755 String strMessageParam = null;
756 String strMessage = null;
757
758 String strWrongEmail = isWrongEmail( strTestRecipients );
759 if ( StringUtils.isNotEmpty( strWrongEmail ) )
760 {
761 strMessageParam = strWrongEmail;
762 strMessage = MESSAGE_WRONG_EMAIL;
763 }
764
765 if ( strMessageParam == null && strMessage == null && !StringUtil.checkEmail( strSenderMail ) )
766 {
767 strMessageParam = strSenderMail;
768 strMessage = MESSAGE_WRONG_EMAIL_SENDER;
769 }
770
771 if ( strMessageParam != null && strMessage != null )
772 {
773 Object [ ] messageArgs = {
774 strMessageParam
775 };
776 return AdminMessageService.getMessageUrl( request, strMessage, messageArgs, AdminMessage.TYPE_STOP );
777 }
778
779 NewsLettertter/business/NewsLetter.html#NewsLetter">NewsLetter newsletter = new NewsLetter( );
780 newsletter.setName( strNewsletterName );
781
782 Timestamp dateFirstSend = DateUtil.formatTimestamp( strDateFirstSend, getLocale( ) );
783
784 if ( dateFirstSend != null )
785 {
786 newsletter.setDateLastSending( dateFirstSend );
787 }
788 else
789 {
790 return AdminMessageService.getMessageUrl( request, MESSAGE_WRONG_DATE_LAST_SEND, AdminMessage.TYPE_STOP );
791 }
792
793 newsletter.setDescription( strNewsletterDescription );
794 newsletter.setWorkgroup( strWorkGroup );
795 newsletter.setTestRecipients( strTestRecipients );
796 newsletter.setTestSubject( strTestSubject );
797 newsletter.setNewsletterSenderMail( strSenderMail );
798 newsletter.setNewsletterSenderName( strSenderName );
799 newsletter.setNbSections( 1 );
800 newsletter.setUnsubscribe( request.getParameter( PARAMETER_NEWSLETTER_UNSUBSCRIBE ) );
801
802 NewsLetterHome.create( newsletter, getPlugin( ) );
803
804 return getHomeUrl( request );
805 }
806
807
808
809
810
811
812
813
814 public String getModifyNewsLetter( HttpServletRequest request )
815 {
816 setPageTitleProperty( PROPERTY_PAGE_TITLE_MODIFY );
817
818 Map<String, Object> model = new HashMap<String, Object>( );
819 String strNewsletterId = request.getParameter( PARAMETER_NEWSLETTER_ID );
820 int nNewsletterId = Integer.parseInt( strNewsletterId );
821 NewsLetter newsletter = NewsLetterHome.findByPrimaryKey( nNewsletterId, getPlugin( ) );
822
823 if ( !AdminWorkgroupService.isAuthorized( newsletter, getUser( ) )
824 || !RBACService.isAuthorized( NewsLetter.RESOURCE_TYPE, strNewsletterId, NewsletterResourceIdService.PERMISSION_MODIFY, getUser( ) ) )
825 {
826 return getManageNewsLetters( request );
827 }
828
829 ReferenceList listUnsubscribe = new ReferenceList( );
830 listUnsubscribe.addItem( "TRUE", I18nService.getLocalizedString( PROPERTY_LABEL_UNSUBSCRIBE_TRUE, getLocale( ) ) );
831 listUnsubscribe.addItem( "FALSE", I18nService.getLocalizedString( PROPERTY_LABEL_UNSUBSCRIBE_FALSE, getLocale( ) ) );
832
833 String strBaseUrl = AppPathService.getProdUrl( request );
834
835 model.put( MARK_NEWSLETTER, newsletter );
836 model.put( MARK_NEWSLETTER_DESCRIPTION, newsletter.getDescription( ) );
837 model.put( MARK_DATE_LAST_SENDING, DateUtil.getDateString( newsletter.getDateLastSending( ), getLocale( ) ) );
838 model.put( MARK_WORKGROUP_LIST, AdminWorkgroupService.getUserWorkgroups( getUser( ), getLocale( ) ) );
839 model.put( MARK_UNSUBSCRIBE_LIST, listUnsubscribe );
840 model.put( MARK_LOCALE, getLocale( ) );
841 model.put( MARK_WEBAPP_URL, strBaseUrl );
842
843 HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_MODIFY_NEWSLETTER, getLocale( ), model );
844
845 return getAdminPage( template.getHtml( ) );
846 }
847
848
849
850
851
852
853
854
855 public String doModifyNewsLetter( HttpServletRequest request )
856 {
857
858 String strSenderName = request.getParameter( PARAMETER_NEWSLETTER_SENDER_NAME );
859 String strSenderMail = request.getParameter( PARAMETER_NEWSLETTER_SENDER_MAIL );
860 String strNewsletterName = request.getParameter( PARAMETER_NEWSLETTER_NAME );
861 String strNewsletterDescription = request.getParameter( PARAMETER_NEWSLETTER_DESCRIPTION );
862 String strWorkGroup = request.getParameter( PARAMETER_NEWSLETTER_WORKGROUP );
863 String strDateLastSend = request.getParameter( PARAMETER_DATE_LAST_SEND );
864 String strTestRecipients = request.getParameter( PARAMETER_TEST_RECIPIENTS );
865 String strNewsletterId = request.getParameter( PARAMETER_NEWSLETTER_ID );
866 int nNewsletterId = Integer.parseInt( strNewsletterId );
867 NewsLetter newsletter = NewsLetterHome.findByPrimaryKey( nNewsletterId, getPlugin( ) );
868 String strTestSubject = request.getParameter( PARAMETER_TEST_SUBJECT );
869
870
871 if ( !AdminWorkgroupService.isAuthorized( newsletter, getUser( ) )
872 || !RBACService.isAuthorized( NewsLetter.RESOURCE_TYPE, strNewsletterId, NewsletterResourceIdService.PERMISSION_MODIFY, getUser( ) ) )
873 {
874 return AdminMessageService.getMessageUrl( request, Messages.USER_ACCESS_DENIED, AdminMessage.TYPE_ERROR );
875 }
876
877
878 if ( StringUtils.isEmpty( strSenderMail ) || StringUtils.isEmpty( strTestRecipients ) || StringUtils.isEmpty( strNewsletterName )
879 || StringUtils.isEmpty( strDateLastSend ) || StringUtils.isEmpty( strWorkGroup ) || StringUtils.isEmpty( strSenderName ) )
880 {
881 return AdminMessageService.getMessageUrl( request, Messages.MANDATORY_FIELDS, AdminMessage.TYPE_STOP );
882 }
883
884 strTestRecipients = cleanEmails( strTestRecipients );
885
886 String strWrongMail = isWrongEmail( strTestRecipients );
887 if ( StringUtils.isNotEmpty( strWrongMail ) )
888 {
889 Object [ ] messageArgs = {
890 strWrongMail
891 };
892
893 return AdminMessageService.getMessageUrl( request, MESSAGE_WRONG_EMAIL, messageArgs, AdminMessage.TYPE_STOP );
894 }
895
896 if ( !StringUtil.checkEmail( strSenderMail ) )
897 {
898 Object [ ] messageArgs = {
899 strSenderMail
900 };
901
902 return AdminMessageService.getMessageUrl( request, MESSAGE_WRONG_EMAIL_SENDER, messageArgs, AdminMessage.TYPE_STOP );
903 }
904
905 newsletter.setName( strNewsletterName );
906 newsletter.setDescription( strNewsletterDescription );
907 newsletter.setWorkgroup( strWorkGroup );
908 newsletter.setTestRecipients( strTestRecipients );
909 newsletter.setTestSubject( strTestSubject );
910 newsletter.setNewsletterSenderMail( strSenderMail );
911 newsletter.setNewsletterSenderName( strSenderName );
912
913 Timestamp dateLastSend = DateUtil.formatTimestamp( strDateLastSend, getLocale( ) );
914
915 if ( dateLastSend != null )
916 {
917 newsletter.setDateLastSending( dateLastSend );
918 }
919
920 newsletter.setUnsubscribe( request.getParameter( PARAMETER_NEWSLETTER_UNSUBSCRIBE ) );
921 newsletter.setWorkgroup( request.getParameter( PARAMETER_NEWSLETTER_WORKGROUP ) );
922
923
924 NewsLetterHome.update( newsletter, getPlugin( ) );
925
926 String strId = Integer.toString( nNewsletterId );
927 UrlItem url = new UrlItem( JSP_URL_MODIFY_NEWSLETTER );
928 url.addParameter( PARAMETER_NEWSLETTER_ID, strId );
929
930 return url.getUrl( );
931 }
932
933
934
935
936
937
938
939
940 private String cleanEmails( String strRecipientLists )
941 {
942 StringBuffer strCleanTestRecipients = new StringBuffer( );
943 String strDelimiter = AppPropertiesService.getProperty( PROPERTY_IMPORT_DELIMITER );
944
945 String [ ] strEmails = strRecipientLists.split( strDelimiter );
946
947 for ( String email : strEmails )
948 {
949 strCleanTestRecipients.append( email.trim( ) );
950 strCleanTestRecipients.append( strDelimiter );
951 }
952
953 return strCleanTestRecipients.toString( );
954 }
955
956
957
958
959
960
961
962
963 public String getConfirmRemoveSubscriber( HttpServletRequest request )
964 {
965 UrlItem urlItem = new UrlItem( JSP_URL_DO_REMOVE_SUBSCRIBER );
966 int nNewsletterId = Integer.parseInt( request.getParameter( PARAMETER_NEWSLETTER_ID ) );
967 int nSubscriberId = Integer.parseInt( request.getParameter( PARAMETER_SUBSCRIBER_ID ) );
968 urlItem.addParameter( PARAMETER_NEWSLETTER_ID, nNewsletterId );
969 urlItem.addParameter( PARAMETER_SUBSCRIBER_ID, nSubscriberId );
970
971 return AdminMessageService.getMessageUrl( request, MESSAGE_CONFIRM_REMOVE_SUBSCRIBER, urlItem.getUrl( ), AdminMessage.TYPE_CONFIRMATION );
972 }
973
974
975
976
977
978
979
980
981 public String getConfirmRemoveSelectedSubscribers( HttpServletRequest request )
982 {
983 String [ ] strIdSubscribers = (String [ ]) request.getParameterMap( ).get( PARAMETER_SUBSCRIBERS_SELECTION );
984 _multiSelectionValues = strIdSubscribers;
985
986 UrlItem urlItem = new UrlItem( JSP_URL_DO_REMOVE_SELECTION );
987 int nNewsletterId = Integer.parseInt( request.getParameter( PARAMETER_NEWSLETTER_ID ) );
988 urlItem.addParameter( PARAMETER_NEWSLETTER_ID, nNewsletterId );
989
990 return AdminMessageService.getMessageUrl( request, MESSAGE_CONFIRM_REMOVE_SELECTION, urlItem.getUrl( ), AdminMessage.TYPE_CONFIRMATION );
991 }
992
993
994
995
996
997
998
999
1000 public String doUnregistrationAdmin( HttpServletRequest request )
1001 {
1002
1003 String strNewsletterId = request.getParameter( PARAMETER_NEWSLETTER_ID );
1004 int nNewsletterId = Integer.parseInt( strNewsletterId );
1005 int nSubscriberId = Integer.parseInt( request.getParameter( PARAMETER_SUBSCRIBER_ID ) );
1006 NewsLetter newsletter = NewsLetterHome.findByPrimaryKey( nNewsletterId, getPlugin( ) );
1007
1008
1009 if ( !AdminWorkgroupService.isAuthorized( newsletter, getUser( ) ) || !RBACService.isAuthorized( NewsLetter.RESOURCE_TYPE, strNewsletterId,
1010 NewsletterResourceIdService.PERMISSION_MANAGE_SUBSCRIBERS, getUser( ) ) )
1011 {
1012 return AdminMessageService.getMessageUrl( request, Messages.USER_ACCESS_DENIED, AdminMessage.TYPE_ERROR );
1013 }
1014
1015 Subscriber subscriber = SubscriberHome.findByPrimaryKey( nSubscriberId, getPlugin( ) );
1016
1017 if ( subscriber != null )
1018 {
1019 _newsletterService.removeSubscriberFromNewsletter( subscriber, nNewsletterId, getPlugin( ) );
1020 }
1021
1022 UrlItem urlItem = new UrlItem( JSP_URL_MANAGE_SUBSCRIBERS );
1023 urlItem.addParameter( NewsLetterConstants.PARAMETER_NEWSLETTER_ID, nNewsletterId );
1024
1025 return urlItem.getUrl( );
1026 }
1027
1028
1029
1030
1031
1032
1033
1034
1035 public String doRemoveSelection( HttpServletRequest request )
1036 {
1037
1038 String strNewsletterId = request.getParameter( PARAMETER_NEWSLETTER_ID );
1039 int nNewsletterId = Integer.parseInt( strNewsletterId );
1040 NewsLetter newsletter = NewsLetterHome.findByPrimaryKey( nNewsletterId, getPlugin( ) );
1041
1042
1043 if ( !AdminWorkgroupService.isAuthorized( newsletter, getUser( ) ) || !RBACService.isAuthorized( NewsLetter.RESOURCE_TYPE, strNewsletterId,
1044 NewsletterResourceIdService.PERMISSION_MANAGE_SUBSCRIBERS, getUser( ) ) )
1045 {
1046 return AdminMessageService.getMessageUrl( request, Messages.USER_ACCESS_DENIED, AdminMessage.TYPE_ERROR );
1047 }
1048
1049 if ( ( _multiSelectionValues != null ) && ( _multiSelectionValues.length > 0 ) )
1050 {
1051 for ( String strId : _multiSelectionValues )
1052 {
1053 Subscriber subscriber = SubscriberHome.findByPrimaryKey( Integer.parseInt( strId ), getPlugin( ) );
1054
1055 if ( subscriber != null )
1056 {
1057 _newsletterService.removeSubscriberFromNewsletter( subscriber, nNewsletterId, getPlugin( ) );
1058 }
1059 }
1060 }
1061
1062 UrlItem urlItem = new UrlItem( JSP_URL_MANAGE_SUBSCRIBERS );
1063 urlItem.addParameter( NewsLetterConstants.PARAMETER_NEWSLETTER_ID, nNewsletterId );
1064
1065 return urlItem.getUrl( );
1066 }
1067
1068
1069
1070
1071
1072
1073
1074
1075 public String getRemoveNewsLetter( HttpServletRequest request )
1076 {
1077
1078 String strNewsletterId = request.getParameter( PARAMETER_NEWSLETTER_ID );
1079 int nNewsletterId = Integer.parseInt( strNewsletterId );
1080 NewsLetter newsletter = NewsLetterHome.findByPrimaryKey( nNewsletterId, getPlugin( ) );
1081
1082
1083 if ( !AdminWorkgroupService.isAuthorized( newsletter, getUser( ) )
1084 || !RBACService.isAuthorized( NewsLetter.RESOURCE_TYPE, strNewsletterId, NewsletterResourceIdService.PERMISSION_DELETE, getUser( ) ) )
1085 {
1086 return AdminMessageService.getMessageUrl( request, Messages.USER_ACCESS_DENIED, AdminMessage.TYPE_ERROR );
1087 }
1088
1089 if ( NewsLetterHome.checkLinkedPortlets( nNewsletterId ) )
1090 {
1091 return AdminMessageService.getMessageUrl( request, MESSAGE_LINKED_TO_NEWSLETTER, AdminMessage.TYPE_STOP );
1092 }
1093
1094 UrlItem urlItem = new UrlItem( JSP_URL_DO_REMOVE_NEWSLETTER );
1095 urlItem.addParameter( PARAMETER_NEWSLETTER_ID, nNewsletterId );
1096
1097 return AdminMessageService.getMessageUrl( request, MESSAGE_CONFIRM_REMOVE_NEWSLETTER, urlItem.getUrl( ), AdminMessage.TYPE_CONFIRMATION );
1098 }
1099
1100
1101
1102
1103
1104
1105
1106
1107 public String getRemoveSendingNewsLetter( HttpServletRequest request )
1108 {
1109
1110 String strSendingNewsletterId = request.getParameter( PARAMETER_SENDING_NEWSLETTER_ID );
1111 int nSendingNewsletterId = Integer.parseInt( strSendingNewsletterId );
1112
1113 String strNewsletterId = request.getParameter( PARAMETER_NEWSLETTER_ID );
1114 int nNewsletterId = Integer.parseInt( strNewsletterId );
1115
1116
1117 if ( !RBACService.isAuthorized( NewsLetter.RESOURCE_TYPE, Integer.toString( nNewsletterId ), NewsletterResourceIdService.PERMISSION_ARCHIVE,
1118 getUser( ) ) )
1119 {
1120 return AdminMessageService.getMessageUrl( request, Messages.USER_ACCESS_DENIED, AdminMessage.TYPE_ERROR );
1121 }
1122
1123 UrlItem urlItem = new UrlItem( JSP_URL_DO_REMOVE_SENDING_NEWSLETTER );
1124 urlItem.addParameter( PARAMETER_NEWSLETTER_ID, nNewsletterId );
1125 urlItem.addParameter( PARAMETER_SENDING_NEWSLETTER_ID, nSendingNewsletterId );
1126
1127 return AdminMessageService.getMessageUrl( request, MESSAGE_CONFIRM_REMOVE_SENDING_NEWSLETTER, urlItem.getUrl( ), AdminMessage.TYPE_CONFIRMATION );
1128 }
1129
1130
1131
1132
1133
1134
1135
1136
1137 public String getRemoveMultiNewsLetter( HttpServletRequest request )
1138 {
1139
1140 String strNewsletterId = request.getParameter( PARAMETER_NEWSLETTER_ID );
1141 int nNewsletterId = Integer.parseInt( strNewsletterId );
1142
1143 String [ ] strSendingNewsletterId = request.getParameterValues( PARAMETER_NEWSLETTER_SELECTION );
1144
1145
1146 if ( !RBACService.isAuthorized( NewsLetter.RESOURCE_TYPE, Integer.toString( nNewsletterId ), NewsletterResourceIdService.PERMISSION_ARCHIVE,
1147 getUser( ) ) )
1148 {
1149 return AdminMessageService.getMessageUrl( request, Messages.USER_ACCESS_DENIED, AdminMessage.TYPE_ERROR );
1150 }
1151 else
1152 if ( ArrayUtils.isEmpty( strSendingNewsletterId ) )
1153 {
1154 return AdminMessageService.getMessageUrl( request, PROPERTY_SELECT_MANDATORY, AdminMessage.TYPE_ERROR );
1155 }
1156
1157 StringBuilder sb = new StringBuilder( );
1158 int count = 1;
1159
1160 for ( String s : strSendingNewsletterId )
1161 {
1162 sb.append( s );
1163
1164 if ( count != strSendingNewsletterId.length )
1165 {
1166 count++;
1167 sb.append( "_" );
1168 }
1169 }
1170
1171 UrlItem urlItem = new UrlItem( JSP_URL_DO_REMOVE_MULTI_NEWSLETTER );
1172 urlItem.addParameter( PARAMETER_NEWSLETTER_ID, nNewsletterId );
1173 urlItem.addParameter( PARAMETER_SENDING_NEWSLETTER_ID, sb.toString( ) );
1174
1175 return AdminMessageService.getMessageUrl( request, MESSAGE_CONFIRM_REMOVE_MULTI_SENDING_NEWSLETTER, urlItem.getUrl( ), AdminMessage.TYPE_CONFIRMATION );
1176 }
1177
1178
1179
1180
1181
1182
1183
1184
1185 public String doRemoveNewsLetter( HttpServletRequest request )
1186 {
1187 int nNewsletterId = Integer.parseInt( request.getParameter( PARAMETER_NEWSLETTER_ID ) );
1188
1189 NewsLetter newsletter = NewsLetterHome.findByPrimaryKey( nNewsletterId, getPlugin( ) );
1190
1191
1192 if ( !AdminWorkgroupService.isAuthorized( newsletter, getUser( ) ) || !RBACService.isAuthorized( NewsLetter.RESOURCE_TYPE,
1193 Integer.toString( newsletter.getId( ) ), NewsletterResourceIdService.PERMISSION_MODIFY, getUser( ) ) )
1194 {
1195 return AdminMessageService.getMessageUrl( request, Messages.USER_ACCESS_DENIED, AdminMessage.TYPE_ERROR );
1196 }
1197
1198
1199 Collection<Subscriber> list = SubscriberHome.findSubscribers( nNewsletterId, NewsLetterConstants.CONSTANT_EMPTY_STRING,
1200 Integer.parseInt( AppPropertiesService.getProperty( PROPERTY_LIMIT_MIN_SUSCRIBER ) ),
1201 Integer.parseInt( AppPropertiesService.getProperty( PROPERTY_LIMIT_MAX_SUSCRIBER ) ), getPlugin( ) );
1202
1203 for ( Subscriber subscriber : list )
1204 {
1205 NewsLetterHome.removeSubscriber( newsletter.getId( ), subscriber.getId( ), getPlugin( ) );
1206 }
1207
1208
1209 NewsletterTopicHome.removeAllByIdNewsletter( nNewsletterId, getPlugin( ) );
1210 NewsLetterHome.remove( nNewsletterId, getPlugin( ) );
1211
1212 return getHomeUrl( request );
1213 }
1214
1215
1216
1217
1218
1219
1220
1221
1222 public String doRemoveSendingNewsLetter( HttpServletRequest request )
1223 {
1224 int nNewsletterId = Integer.parseInt( request.getParameter( PARAMETER_NEWSLETTER_ID ) );
1225 int nSendingNewsletterId = Integer.parseInt( request.getParameter( PARAMETER_SENDING_NEWSLETTER_ID ) );
1226
1227 if ( !RBACService.isAuthorized( NewsLetter.RESOURCE_TYPE, Integer.toString( nNewsletterId ), NewsletterResourceIdService.PERMISSION_ARCHIVE,
1228 getUser( ) ) )
1229 {
1230 return AdminMessageService.getMessageUrl( request, Messages.USER_ACCESS_DENIED, AdminMessage.TYPE_ERROR );
1231 }
1232
1233 SendingNewsLetterHome.remove( nSendingNewsletterId, getPlugin( ) );
1234
1235 UrlItem url = new UrlItem( JSP_URL_MANAGE_ARCHIVE );
1236 url.addParameter( PARAMETER_NEWSLETTER_ID, nNewsletterId );
1237
1238 return url.getUrl( );
1239 }
1240
1241
1242
1243
1244
1245
1246
1247
1248 public String doRemoveMultiNewsLetter( HttpServletRequest request )
1249 {
1250 int nNewsletterId = Integer.parseInt( request.getParameter( PARAMETER_NEWSLETTER_ID ) );
1251 String strSendingNewsletterId = request.getParameter( PARAMETER_SENDING_NEWSLETTER_ID );
1252
1253 if ( !RBACService.isAuthorized( NewsLetter.RESOURCE_TYPE, Integer.toString( nNewsletterId ), NewsletterResourceIdService.PERMISSION_ARCHIVE,
1254 getUser( ) ) )
1255 {
1256 return AdminMessageService.getMessageUrl( request, Messages.USER_ACCESS_DENIED, AdminMessage.TYPE_ERROR );
1257 }
1258
1259 String [ ] ids = strSendingNewsletterId.split( "_" );
1260
1261 for ( String id : ids )
1262 {
1263 SendingNewsLetterHome.remove( Integer.parseInt( id ), getPlugin( ) );
1264 }
1265
1266 UrlItem url = new UrlItem( JSP_URL_MANAGE_ARCHIVE );
1267 url.addParameter( PARAMETER_NEWSLETTER_ID, nNewsletterId );
1268
1269 return url.getUrl( );
1270 }
1271
1272
1273
1274
1275
1276
1277
1278
1279 public String getManageSubscribers( HttpServletRequest request )
1280 {
1281 String strNewsletterId = request.getParameter( PARAMETER_NEWSLETTER_ID );
1282 int nNewsLetterId = Integer.parseInt( strNewsletterId );
1283 NewsLetter newsletter = NewsLetterHome.findByPrimaryKey( nNewsLetterId, getPlugin( ) );
1284 NewsLetterProperties properties = NewsletterPropertiesHome.find( getPlugin( ) );
1285
1286
1287 if ( !AdminWorkgroupService.isAuthorized( newsletter, getUser( ) ) || !RBACService.isAuthorized( NewsLetter.RESOURCE_TYPE, strNewsletterId,
1288 NewsletterResourceIdService.PERMISSION_MANAGE_SUBSCRIBERS, getUser( ) ) )
1289 {
1290 return getManageNewsLetters( request );
1291 }
1292
1293 setPageTitleProperty( PROPERTY_PAGE_TITLE_MANAGE_SUBSCRIBERS );
1294
1295 String strSearchString = request.getParameter( NewsLetterConstants.PARAMETER_SUBSCRIBER_SEARCH );
1296
1297 if ( StringUtils.isBlank( strSearchString ) )
1298 {
1299 strSearchString = StringUtils.EMPTY;
1300 }
1301
1302 _strCurrentPageIndex = Paginator.getPageIndex( request, Paginator.PARAMETER_PAGE_INDEX, _strCurrentPageIndex );
1303 _nDefaultItemsPerPage = AppPropertiesService.getPropertyInt( PROPERTY_USERS_PER_PAGE, 10 );
1304 _nItemsPerPage = Paginator.getItemsPerPage( request, Paginator.PARAMETER_ITEMS_PER_PAGE, _nItemsPerPage, _nDefaultItemsPerPage );
1305
1306
1307 List<Subscriber> refListSubscribers = (List<Subscriber>) SubscriberHome.findSubscribers( nNewsLetterId, strSearchString,
1308 Integer.parseInt( AppPropertiesService.getProperty( PROPERTY_LIMIT_MIN_SUSCRIBER ) ),
1309 Integer.parseInt( AppPropertiesService.getProperty( PROPERTY_LIMIT_MAX_SUSCRIBER ) ), getPlugin( ) );
1310 UrlItem url = new UrlItem( request.getRequestURI( ) );
1311 url.addParameter( PARAMETER_NEWSLETTER_ID, nNewsLetterId );
1312 url.addParameter( NewsLetterConstants.PARAMETER_SUBSCRIBER_SEARCH, strSearchString );
1313
1314 String strSortedAttributeName = request.getParameter( Parameters.SORTED_ATTRIBUTE_NAME );
1315 String strAscSort = null;
1316
1317 if ( StringUtils.isNotBlank( strSortedAttributeName ) )
1318 {
1319 strAscSort = request.getParameter( Parameters.SORTED_ASC );
1320 url.addParameter( Parameters.SORTED_ATTRIBUTE_NAME, strSortedAttributeName );
1321 url.addParameter( Parameters.SORTED_ASC, strAscSort );
1322
1323 boolean bIsAscSort = Boolean.parseBoolean( strAscSort );
1324
1325 Collections.sort( refListSubscribers, new AttributeComparator( strSortedAttributeName, bIsAscSort ) );
1326 }
1327
1328 IPaginator<Subscriber> paginator = new LocalizedPaginator<Subscriber>( refListSubscribers, _nItemsPerPage, url.getUrl( ),
1329 Paginator.PARAMETER_PAGE_INDEX, _strCurrentPageIndex, getLocale( ) );
1330
1331 Map<String, Object> model = new HashMap<String, Object>( );
1332 model.put( MARK_NEWSLETTER, newsletter );
1333 model.put( MARK_NB_ITEMS_PER_PAGE, Integer.toString( _nItemsPerPage ) );
1334 model.put( MARK_SEARCH_STRING, strSearchString );
1335 model.put( MARK_PAGINATOR, paginator );
1336 model.put( MARK_SUBSCRIBERS_LIST, paginator.getPageItems( ) );
1337 model.put( MARK_DISPLAY_STATUS, properties.isValidationActive( ) );
1338 model.put( MARK_ADD_SUBSCRIBER_RIGHT,
1339 RBACService.isAuthorized( NewsLetter.RESOURCE_TYPE, strNewsletterId, NewsletterResourceIdService.PERMISSION_ADD_SUBSCRIBER, getUser( ) ) );
1340 model.put( MARK_IMPORT_SUBSCRIBER_RIGHT,
1341 RBACService.isAuthorized( NewsLetter.RESOURCE_TYPE, strNewsletterId, NewsletterResourceIdService.PERMISSION_IMPORT_SUBSCRIBERS, getUser( ) ) );
1342 model.put( MARK_EXPORT_SUBSCRIBER_RIGTH,
1343 RBACService.isAuthorized( newsletter, NewsletterResourceIdService.PERMISSION_EXPORT_SUBSCRIBERS, getUser( ) ) );
1344
1345 HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_MANAGE_SUBSCRIBERS, getLocale( ), model );
1346
1347 return getAdminPage( template.getHtml( ) );
1348 }
1349
1350
1351
1352
1353
1354
1355
1356
1357 public String doAddSubscriber( HttpServletRequest request )
1358 {
1359 String strNewsletterId = request.getParameter( PARAMETER_NEWSLETTER_ID );
1360 int nNewsLetterId = Integer.parseInt( strNewsletterId );
1361 NewsLetter newsletter = NewsLetterHome.findByPrimaryKey( nNewsLetterId, getPlugin( ) );
1362
1363
1364 if ( !AdminWorkgroupService.isAuthorized( newsletter, getUser( ) )
1365 || !RBACService.isAuthorized( NewsLetter.RESOURCE_TYPE, strNewsletterId, NewsletterResourceIdService.PERMISSION_ADD_SUBSCRIBER, getUser( ) ) )
1366 {
1367 return AdminMessageService.getMessageUrl( request, Messages.USER_ACCESS_DENIED, AdminMessage.TYPE_ERROR );
1368 }
1369
1370 String strEmail = request.getParameter( NewsLetterConstants.PARAMETER_EMAIL );
1371
1372
1373 if ( ( strEmail == null ) || strEmail.equals( NewsLetterConstants.CONSTANT_EMPTY_STRING ) || !StringUtil.checkEmail( strEmail.trim( ) ) )
1374 {
1375 return AdminMessageService.getMessageUrl( request, MESSAGE_FIELD_EMAIL_VALID, AdminMessage.TYPE_STOP );
1376 }
1377
1378
1379 Subscriber subscriber = SubscriberHome.findByEmail( strEmail, getPlugin( ) );
1380
1381 if ( subscriber == null )
1382 {
1383
1384 subscriber = new Subscriber( );
1385 subscriber.setEmail( strEmail.trim( ) );
1386 SubscriberHome.create( subscriber, getPlugin( ) );
1387 }
1388
1389
1390 if ( NewsLetterHome.findRegistration( nNewsLetterId, subscriber.getId( ), getPlugin( ) ) )
1391 {
1392 return AdminMessageService.getMessageUrl( request, MESSAGE_EMAIL_EXISTS, AdminMessage.TYPE_STOP );
1393 }
1394
1395
1396 Timestamp tToday = new java.sql.Timestamp( new java.util.Date( ).getTime( ) );
1397 NewsLetterHome.addSubscriber( newsletter.getId( ), subscriber.getId( ), tToday, getPlugin( ) );
1398
1399
1400
1401 UrlItem urlItem = new UrlItem( JSP_URL_MANAGE_SUBSCRIBERS );
1402 urlItem.addParameter( PARAMETER_NEWSLETTER_ID, nNewsLetterId );
1403
1404 return urlItem.getUrl( );
1405 }
1406
1407
1408
1409
1410
1411
1412
1413
1414 public String getPrepareNewsLetter( HttpServletRequest request )
1415 {
1416 String strNewsletterId = request.getParameter( PARAMETER_NEWSLETTER_ID );
1417 int nNewsletterId = Integer.parseInt( strNewsletterId );
1418 NewsLetter newsletter = NewsLetterHome.findByPrimaryKey( nNewsletterId, getPlugin( ) );
1419
1420
1421 if ( !AdminWorkgroupService.isAuthorized( newsletter, getUser( ) )
1422 || !RBACService.isAuthorized( NewsLetter.RESOURCE_TYPE, strNewsletterId, NewsletterResourceIdService.PERMISSION_SEND, getUser( ) ) )
1423 {
1424 return getManageNewsLetters( request );
1425 }
1426
1427 setPageTitleProperty( PROPERTY_PAGE_TITLE_PREPARE );
1428
1429 String strBaseUrl = AppPathService.getBaseUrl( request );
1430 Map<String, Object> model = new HashMap<String, Object>( );
1431 String strObject = request.getParameter( PARAMETER_NEWSLETTER_OBJECT );
1432
1433 if ( strObject != null )
1434 {
1435 model.put( MARK_NEWSLETTER_OBJECT, strObject );
1436 }
1437 else
1438 {
1439 model.put( MARK_NEWSLETTER_OBJECT, StringUtils.EMPTY );
1440 }
1441
1442 model.put( MARK_PREVIEW, newsletter.getHtml( ) );
1443 model.put( MARK_UNSUBSCRIBE, newsletter.getUnsubscribe( ) );
1444 model.put( MARK_NEWSLETTER, newsletter );
1445 model.put( NewsLetterConstants.MARK_BASE_URL, strBaseUrl );
1446 model.put( NewsLetterConstants.MARK_SUBSCRIBER_EMAIL, NewsLetterConstants.MARK_SUBSCRIBER_EMAIL_EACH );
1447
1448 HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_PREPARE_NEWSLETTER, getLocale( ), model );
1449
1450 return getAdminPage( template.getHtml( ) );
1451 }
1452
1453
1454
1455
1456
1457
1458
1459
1460 public String doPrepareNewsLetter( HttpServletRequest request )
1461 {
1462 String strNewsletterId = request.getParameter( PARAMETER_NEWSLETTER_ID );
1463 int nNewsletterId = Integer.parseInt( strNewsletterId );
1464 NewsLetter newsletter = NewsLetterHome.findByPrimaryKey( nNewsletterId, getPlugin( ) );
1465
1466
1467 if ( !AdminWorkgroupService.isAuthorized( newsletter, getUser( ) )
1468 || !RBACService.isAuthorized( NewsLetter.RESOURCE_TYPE, strNewsletterId, NewsletterResourceIdService.PERMISSION_SEND, getUser( ) ) )
1469 {
1470 return AdminMessageService.getMessageUrl( request, Messages.USER_ACCESS_DENIED, AdminMessage.TYPE_ERROR );
1471 }
1472
1473
1474 if ( StringUtils.isEmpty( newsletter.getHtml( ) ) )
1475 {
1476 return AdminMessageService.getMessageUrl( request, MESSAGE_SENDING_EMPTY_NOT_ALLOWED, AdminMessage.TYPE_STOP );
1477 }
1478
1479 UrlItem urlItem = new UrlItem( JSP_URL_PREPARE_NEWSLETTER );
1480 urlItem.addParameter( PARAMETER_NEWSLETTER_ID, nNewsletterId );
1481
1482 return urlItem.getUrl( );
1483 }
1484
1485
1486
1487
1488
1489
1490
1491
1492 public String getPreviewNewsLetter( HttpServletRequest request )
1493 {
1494 String strNewsletterId = request.getParameter( PARAMETER_NEWSLETTER_ID );
1495 int nNewsletterId = Integer.parseInt( strNewsletterId );
1496 NewsLetter newsletter = NewsLetterHome.findByPrimaryKey( nNewsletterId, getPlugin( ) );
1497
1498
1499 if ( !AdminWorkgroupService.isAuthorized( newsletter, getUser( ) )
1500 || !RBACService.isAuthorized( NewsLetter.RESOURCE_TYPE, strNewsletterId, NewsletterResourceIdService.PERMISSION_SEND, getUser( ) ) )
1501 {
1502 return getManageNewsLetters( request );
1503 }
1504
1505 String strBaseUrl = AppPathService.getBaseUrl( request );
1506
1507 if ( !strBaseUrl.endsWith( NewsLetterConstants.CONSTANT_SLASH ) )
1508 {
1509 strBaseUrl += NewsLetterConstants.CONSTANT_SLASH;
1510 }
1511
1512 HtmlTemplate templateNewsLetter = setHtmlTemplateEmail( newsletter, strBaseUrl, newsletter.getUnsubscribe( ) );
1513
1514 return templateNewsLetter.getHtml( );
1515 }
1516
1517
1518
1519
1520
1521
1522
1523
1524 public String doConfirmSendNewsLetter( HttpServletRequest request )
1525 {
1526 String strNewsletterId = request.getParameter( PARAMETER_NEWSLETTER_ID );
1527 int nNewsletterId = Integer.parseInt( strNewsletterId );
1528 NewsLetter newsletter = NewsLetterHome.findByPrimaryKey( nNewsletterId, getPlugin( ) );
1529
1530
1531 if ( !AdminWorkgroupService.isAuthorized( newsletter, getUser( ) )
1532 || !RBACService.isAuthorized( NewsLetter.RESOURCE_TYPE, strNewsletterId, NewsletterResourceIdService.PERMISSION_SEND, getUser( ) ) )
1533 {
1534 return AdminMessageService.getMessageUrl( request, Messages.USER_ACCESS_DENIED, AdminMessage.TYPE_ERROR );
1535 }
1536
1537 String strErrorMessage = null;
1538
1539
1540 if ( StringUtils.isEmpty( newsletter.getHtml( ) ) )
1541 {
1542 strErrorMessage = MESSAGE_SENDING_EMPTY_NOT_ALLOWED;
1543 }
1544
1545
1546 int nNbrSubscribers = NewsLetterHome.findNbrActiveSubscribers( nNewsletterId, getPlugin( ) );
1547
1548 if ( strErrorMessage == null && nNbrSubscribers == 0 )
1549 {
1550 strErrorMessage = MESSAGE_NO_SUBSCRIBER;
1551 }
1552
1553 String strObject = request.getParameter( PARAMETER_NEWSLETTER_OBJECT );
1554
1555
1556 if ( strErrorMessage == null && StringUtils.isEmpty( strObject ) )
1557 {
1558 strErrorMessage = MESSAGE_OBJECT_NOT_SPECIFIED;
1559 }
1560
1561 if ( strErrorMessage != null )
1562 {
1563 return AdminMessageService.getMessageUrl( request, strErrorMessage, AdminMessage.TYPE_STOP );
1564 }
1565
1566 UrlItem urlItem = new UrlItem( JSP_URL_SEND_NEWSLETTER );
1567 HashMap<String, String> requestedParameters = new HashMap<String, String>( );
1568 requestedParameters.put( PARAMETER_NEWSLETTER_OBJECT, strObject );
1569 requestedParameters.put( PARAMETER_NEWSLETTER_ID, strNewsletterId );
1570
1571
1572
1573 SendingNewsLetter lastSending = SendingNewsLetterHome.findLastSendingForNewsletterId( nNewsletterId, getPlugin( ) );
1574
1575 String strMessage = MESSAGE_CONFIRM_SEND_NEWSLETTER;
1576 if ( ( lastSending != null ) && lastSending.getHtml( ).equals( newsletter.getHtml( ) ) )
1577 {
1578 strMessage = MESSAGE_FRAGMENT_NO_CHANGE;
1579 }
1580 return AdminMessageService.getMessageUrl( request, strMessage, urlItem.getUrl( ), AdminMessage.TYPE_CONFIRMATION, requestedParameters );
1581 }
1582
1583
1584
1585
1586
1587
1588
1589
1590 public String doConfirmTestNewsLetter( HttpServletRequest request )
1591 {
1592 String strNewsletterId = request.getParameter( PARAMETER_NEWSLETTER_ID );
1593 int nNewsletterId = Integer.parseInt( strNewsletterId );
1594 NewsLetter newsletter = NewsLetterHome.findByPrimaryKey( nNewsletterId, getPlugin( ) );
1595
1596
1597 if ( !AdminWorkgroupService.isAuthorized( newsletter, getUser( ) )
1598 || !RBACService.isAuthorized( NewsLetter.RESOURCE_TYPE, strNewsletterId, NewsletterResourceIdService.PERMISSION_MODIFY, getUser( ) ) )
1599 {
1600 return AdminMessageService.getMessageUrl( request, Messages.USER_ACCESS_DENIED, AdminMessage.TYPE_ERROR );
1601 }
1602
1603
1604 if ( StringUtils.isEmpty( newsletter.getHtml( ) ) )
1605 {
1606 return AdminMessageService.getMessageUrl( request, MESSAGE_SENDING_EMPTY_NOT_ALLOWED, AdminMessage.TYPE_STOP );
1607 }
1608
1609 String strObject = request.getParameter( PARAMETER_NEWSLETTER_OBJECT );
1610
1611 UrlItem urlItem = new UrlItem( JSP_URL_TEST_NEWSLETTER );
1612 urlItem.addParameter( PARAMETER_NEWSLETTER_OBJECT, strObject );
1613 urlItem.addParameter( PARAMETER_NEWSLETTER_ID, nNewsletterId );
1614
1615 return AdminMessageService.getMessageUrl( request, MESSAGE_CONFIRM_TEST_NEWSLETTER, urlItem.getUrl( ), AdminMessage.TYPE_CONFIRMATION );
1616 }
1617
1618
1619
1620
1621
1622
1623
1624
1625 public String doTestNewsLetter( HttpServletRequest request )
1626 {
1627 String strNewsletterId = request.getParameter( PARAMETER_NEWSLETTER_ID );
1628 int nNewsletterId = Integer.parseInt( strNewsletterId );
1629 NewsLetter newsletter = NewsLetterHome.findByPrimaryKey( nNewsletterId, getPlugin( ) );
1630
1631
1632 if ( !AdminWorkgroupService.isAuthorized( newsletter, getUser( ) )
1633 || !RBACService.isAuthorized( NewsLetter.RESOURCE_TYPE, strNewsletterId, NewsletterResourceIdService.PERMISSION_MODIFY, getUser( ) ) )
1634 {
1635 return AdminMessageService.getMessageUrl( request, Messages.USER_ACCESS_DENIED, AdminMessage.TYPE_ERROR );
1636 }
1637
1638
1639 String strTestRecipients = newsletter.getTestRecipients( );
1640
1641 String strWrongEmail = isWrongEmail( strTestRecipients );
1642 if ( StringUtils.isNotEmpty( strWrongEmail ) )
1643 {
1644 Object [ ] messageArgs = {
1645 strWrongEmail
1646 };
1647
1648 return AdminMessageService.getMessageUrl( request, MESSAGE_WRONG_EMAIL, messageArgs, AdminMessage.TYPE_STOP );
1649 }
1650
1651 SendingNewsLetter/business/SendingNewsLetter.html#SendingNewsLetter">SendingNewsLetter sending = new SendingNewsLetter( );
1652 sending.setNewsLetterId( nNewsletterId );
1653 sending.setDate( new Timestamp( new java.util.Date( ).getTime( ) ) );
1654
1655 String strObject = I18nService.getLocalizedString( PROPERTY_TEST_SUBJECT, getLocale( ) ) + newsletter.getName( ) + "]" + newsletter.getTestSubject( );
1656
1657
1658 String strBaseUrl = AppPathService.getProdUrl( request );
1659
1660 HtmlTemplate templateNewsLetter = setHtmlTemplateEmail( newsletter, strBaseUrl, newsletter.getUnsubscribe( ) );
1661
1662 _newsletterService.sendMail( newsletter, strObject, strBaseUrl, templateNewsLetter, convertToList( newsletter.getTestRecipients( ) ) );
1663
1664 return getHomeUrl( request );
1665 }
1666
1667
1668
1669
1670
1671
1672
1673
1674 public String doSendNewsLetter( HttpServletRequest request )
1675 {
1676 String strNewsletterId = request.getParameter( PARAMETER_NEWSLETTER_ID );
1677 String strObject = request.getParameter( PARAMETER_NEWSLETTER_OBJECT );
1678 int nNewsletterId = Integer.parseInt( strNewsletterId );
1679 NewsLetter newsletter = NewsLetterHome.findByPrimaryKey( nNewsletterId, getPlugin( ) );
1680
1681
1682 if ( !AdminWorkgroupService.isAuthorized( newsletter, getUser( ) )
1683 || !RBACService.isAuthorized( NewsLetter.RESOURCE_TYPE, strNewsletterId, NewsletterResourceIdService.PERMISSION_SEND, getUser( ) ) )
1684 {
1685 return AdminMessageService.getMessageUrl( request, Messages.USER_ACCESS_DENIED, AdminMessage.TYPE_ERROR );
1686 }
1687
1688
1689 int nNbrSubscribers = NewsLetterHome.findNbrSubscribers( nNewsletterId, getPlugin( ) );
1690
1691 if ( nNbrSubscribers == 0 )
1692 {
1693 return AdminMessageService.getMessageUrl( request, MESSAGE_NO_SUBSCRIBER, AdminMessage.TYPE_STOP );
1694 }
1695
1696 if ( StringUtils.isEmpty( strObject ) )
1697 {
1698 strObject = newsletter.getName( );
1699 }
1700
1701
1702 String strBaseUrl = AppPathService.getProdUrl( request );
1703
1704
1705 Collection<Subscriber> list = SubscriberHome.findSubscribersForSending( nNewsletterId,
1706 Integer.parseInt( AppPropertiesService.getProperty( PROPERTY_LIMIT_MIN_SUSCRIBER ) ),
1707 Integer.parseInt( AppPropertiesService.getProperty( PROPERTY_LIMIT_MAX_SUSCRIBER ) ), getPlugin( ) );
1708
1709
1710 HtmlTemplate templateNewsLetter = setHtmlTemplateEmail( newsletter, strBaseUrl, newsletter.getUnsubscribe( ) );
1711
1712 _newsletterService.sendMail( newsletter, strObject, strBaseUrl, templateNewsLetter, list );
1713
1714 SendingNewsLetter/business/SendingNewsLetter.html#SendingNewsLetter">SendingNewsLetter sending = new SendingNewsLetter( );
1715 sending.setNewsLetterId( nNewsletterId );
1716 sending.setDate( new Timestamp( new java.util.Date( ).getTime( ) ) );
1717 sending.setCountSubscribers( nNbrSubscribers );
1718
1719 if ( Boolean.parseBoolean( newsletter.getUnsubscribe( ) ) )
1720 {
1721 templateNewsLetter = setHtmlTemplateEmail( newsletter, strBaseUrl, Boolean.toString( false ) );
1722 }
1723 sending.setHtml( templateNewsLetter.getHtml( ) );
1724 sending.setEmailSubject( strObject );
1725 SendingNewsLetterHome.create( sending, getPlugin( ) );
1726
1727
1728 newsletter.setDateLastSending( sending.getDate( ) );
1729 NewsLetterHome.update( newsletter, getPlugin( ) );
1730
1731 return getHomeUrl( request );
1732 }
1733
1734
1735
1736
1737
1738
1739
1740
1741 public String doRegisterNewsLetter( HttpServletRequest request )
1742 {
1743 String strAction = request.getParameter( PARAMETER_ACTION );
1744 String strReturn = null;
1745
1746 String strNewsletterId = request.getParameter( PARAMETER_NEWSLETTER_ID );
1747 int nNewsletterId = Integer.parseInt( strNewsletterId );
1748 NewsLetter newsletter = NewsLetterHome.findByPrimaryKey( nNewsletterId, getPlugin( ) );
1749
1750
1751 if ( !AdminWorkgroupService.isAuthorized( newsletter, getUser( ) )
1752 || !RBACService.isAuthorized( NewsLetter.RESOURCE_TYPE, strNewsletterId, NewsletterResourceIdService.PERMISSION_MODIFY, getUser( ) ) )
1753 {
1754 return AdminMessageService.getMessageUrl( request, Messages.USER_ACCESS_DENIED, AdminMessage.TYPE_ERROR );
1755 }
1756
1757 if ( !strAction.equals( I18nService.getLocalizedString( PROPERTY_CANCEL_ACTION, getLocale( ) ) ) )
1758 {
1759 String strBaseUrl = AppPathService.getBaseUrl( request );
1760
1761 newsletter.setHtml( doClean( request.getParameter( PARAMETER_HTML_CONTENT ), strBaseUrl ) );
1762
1763 NewsLetterHome.update( newsletter, getPlugin( ) );
1764
1765 if ( strAction.equals( I18nService.getLocalizedString( PROPERTY_REGISTER_ACTION, getLocale( ) ) ) )
1766 {
1767 UrlItem url = new UrlItem( JSP_URL_DO_COMPOSE_NEWSLETTER );
1768 url.addParameter( PARAMETER_NEWSLETTER_ID, nNewsletterId );
1769 strReturn = url.getUrl( );
1770 }
1771 else
1772 if ( strAction.equals( I18nService.getLocalizedString( PROPERTY_PREPARE_SENDING_ACTION, getLocale( ) ) ) )
1773 {
1774 UrlItem url = new UrlItem( JSP_URL_DO_PREPARE_NEWSLETTER );
1775 url.addParameter( PARAMETER_NEWSLETTER_ID, nNewsletterId );
1776 strReturn = url.getUrl( );
1777 }
1778 else
1779 if ( strAction.equals( I18nService.getLocalizedString( PROPERTY_TEST_SENDING_ACTION, getLocale( ) ) ) )
1780 {
1781 UrlItem url = new UrlItem( JSP_URL_CONFIRM_TEST_NEWSLETTER );
1782 url.addParameter( PARAMETER_NEWSLETTER_ID, nNewsletterId );
1783 strReturn = url.getUrl( );
1784 }
1785 }
1786 else
1787 {
1788 String strUrl = getHomeUrl( request );
1789 strReturn = AdminMessageService.getMessageUrl( request, MESSAGE_CONFIRM_CANCEL_COMPOSE, strUrl, AdminMessage.TYPE_CONFIRMATION );
1790 }
1791
1792 return strReturn;
1793 }
1794
1795
1796
1797
1798
1799
1800
1801
1802 public String getImportSubscribers( HttpServletRequest request )
1803 {
1804 String strNewsletterId = request.getParameter( PARAMETER_NEWSLETTER_ID );
1805 int nNewsletterId = Integer.parseInt( strNewsletterId );
1806 NewsLetter newsletter = NewsLetterHome.findByPrimaryKey( nNewsletterId, getPlugin( ) );
1807
1808
1809 if ( !AdminWorkgroupService.isAuthorized( newsletter, getUser( ) ) || !RBACService.isAuthorized( NewsLetter.RESOURCE_TYPE, strNewsletterId,
1810 NewsletterResourceIdService.PERMISSION_MANAGE_SUBSCRIBERS, getUser( ) ) )
1811 {
1812 return getManageNewsLetters( request );
1813 }
1814
1815 setPageTitleProperty( PROPERTY_PAGE_TITLE_IMPORT );
1816
1817 Map<String, Object> model = new HashMap<String, Object>( );
1818 model.put( MARK_NEWSLETTER_ID, nNewsletterId );
1819 model.put( MARK_IMPORT_DELETE, false );
1820
1821 HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_IMPORT_SUBSCRIBERS, getLocale( ), model );
1822
1823 return getAdminPage( template.getHtml( ) );
1824 }
1825
1826
1827
1828
1829
1830
1831
1832
1833 public String getImportDeleteSubscribers( HttpServletRequest request )
1834 {
1835 String strNewsletterId = request.getParameter( PARAMETER_NEWSLETTER_ID );
1836 int nNewsletterId = Integer.parseInt( strNewsletterId );
1837 NewsLetter newsletter = NewsLetterHome.findByPrimaryKey( nNewsletterId, getPlugin( ) );
1838
1839
1840 if ( !AdminWorkgroupService.isAuthorized( newsletter, getUser( ) ) || !RBACService.isAuthorized( NewsLetter.RESOURCE_TYPE, strNewsletterId,
1841 NewsletterResourceIdService.PERMISSION_MANAGE_SUBSCRIBERS, getUser( ) ) )
1842 {
1843 return getManageNewsLetters( request );
1844 }
1845
1846 setPageTitleProperty( PROPERTY_PAGE_TITLE_IMPORT_DELETE );
1847
1848 Map<String, Object> model = new HashMap<String, Object>( );
1849 model.put( MARK_NEWSLETTER_ID, nNewsletterId );
1850 model.put( MARK_IMPORT_DELETE, true );
1851
1852 HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_IMPORT_SUBSCRIBERS, getLocale( ), model );
1853
1854 return getAdminPage( template.getHtml( ) );
1855 }
1856
1857
1858
1859
1860
1861
1862
1863
1864 public String doImportSubscribers( HttpServletRequest request )
1865 {
1866 String strNewsletterId = request.getParameter( PARAMETER_NEWSLETTER_ID );
1867 int nNewsletterId = Integer.parseInt( strNewsletterId );
1868 NewsLetter newsletter = NewsLetterHome.findByPrimaryKey( nNewsletterId, getPlugin( ) );
1869 String strImportDelete = request.getParameter( MARK_IMPORT_DELETE );
1870 Boolean bImportDelete = Boolean.valueOf( strImportDelete );
1871
1872
1873 if ( !AdminWorkgroupService.isAuthorized( newsletter, getUser( ) ) || !RBACService.isAuthorized( NewsLetter.RESOURCE_TYPE, strNewsletterId,
1874 NewsletterResourceIdService.PERMISSION_IMPORT_SUBSCRIBERS, getUser( ) ) )
1875 {
1876 return AdminMessageService.getMessageUrl( request, Messages.USER_ACCESS_DENIED, AdminMessage.TYPE_ERROR );
1877 }
1878
1879 try
1880 {
1881 if ( request instanceof MultipartHttpServletRequest )
1882 {
1883
1884 MultipartHttpServletRequest multi = (MultipartHttpServletRequest) request;
1885
1886 FileItem csvItem = multi.getFile( PARAMETER_SUBSCRIBERS_FILE );
1887 String strMultiFileName = csvItem == null ? StringUtils.EMPTY : UploadUtil.cleanFileName( csvItem.getName( ) );
1888 if ( csvItem == null || StringUtils.isEmpty( strMultiFileName ) )
1889 {
1890 return AdminMessageService.getMessageUrl( request, Messages.MANDATORY_FIELDS, AdminMessage.TYPE_STOP );
1891 }
1892
1893
1894 String strExtension = strMultiFileName.substring( strMultiFileName.length( ) - 4, strMultiFileName.length( ) );
1895
1896 if ( !strExtension.equals( CONSTANT_CSV_FILE_EXTENSION ) )
1897 {
1898 return AdminMessageService.getMessageUrl( request, MESSAGE_CSV_FILE_EXTENSION, AdminMessage.TYPE_STOP );
1899 }
1900
1901 Reader fileReader = new InputStreamReader( csvItem.getInputStream( ) );
1902 CSVReader csvReader = new CSVReader( fileReader, AppPropertiesService.getProperty( PROPERTY_IMPORT_DELIMITER ).charAt( 0 ) );
1903
1904 @SuppressWarnings( "unchecked" )
1905 List<String [ ]> tabUsers = csvReader.readAll( );
1906
1907
1908 if ( ( tabUsers == null ) || ( tabUsers.size( ) == 0 ) )
1909 {
1910 return AdminMessageService.getMessageUrl( request, MESSAGE_CSV_FILE_EMPTY_OR_NOT_VALID_EMAILS, AdminMessage.TYPE_STOP );
1911 }
1912 int nColumnIndex = Integer.parseInt( AppPropertiesService.getProperty( CONSTANT_EMAIL_COLUMN_INDEX ) );
1913
1914 Timestamp tToday = new java.sql.Timestamp( new java.util.Date( ).getTime( ) );
1915
1916
1917 for ( String [ ] strEmailTemp : tabUsers )
1918 {
1919 if ( strEmailTemp.length < nColumnIndex )
1920 {
1921 return AdminMessageService.getMessageUrl( request, MESSAGE_COLUMN_INDEX_NOT_EXIST, AdminMessage.TYPE_ERROR );
1922 }
1923
1924 String strEmail = strEmailTemp [nColumnIndex];
1925
1926
1927 if ( ( strEmail != null ) && StringUtil.checkEmail( strEmail.trim( ) ) )
1928 {
1929
1930 Subscriber subscriber = SubscriberHome.findByEmail( strEmail, getPlugin( ) );
1931
1932 if ( !bImportDelete )
1933 {
1934 if ( subscriber == null )
1935 {
1936
1937 subscriber = new Subscriber( );
1938 subscriber.setEmail( strEmail );
1939 SubscriberHome.create( subscriber, getPlugin( ) );
1940 }
1941
1942
1943 NewsLetterHome.addSubscriber( nNewsletterId, subscriber.getId( ), tToday, getPlugin( ) );
1944 }
1945 else
1946 {
1947 if ( subscriber != null )
1948 {
1949 NewsLetterHome.removeSubscriber( nNewsletterId, subscriber.getId( ), getPlugin( ) );
1950 }
1951 }
1952 }
1953 }
1954 }
1955 UrlItem urlItem = new UrlItem( JSP_URL_MANAGE_SUBSCRIBERS );
1956 urlItem.addParameter( PARAMETER_NEWSLETTER_ID, nNewsletterId );
1957
1958 return urlItem.getUrl( );
1959 }
1960 catch( IOException e )
1961 {
1962 throw new RuntimeException( e.getMessage( ) );
1963 }
1964 }
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975 public String doExportCsv( HttpServletRequest request, HttpServletResponse response )
1976 {
1977 String strNewsletterId = request.getParameter( PARAMETER_NEWSLETTER_ID );
1978 int nNewsletterId = Integer.parseInt( strNewsletterId );
1979 NewsLetter newsletter = NewsLetterHome.findByPrimaryKey( nNewsletterId, getPlugin( ) );
1980
1981
1982 int nNbrSubscribers = NewsLetterHome.findNbrActiveSubscribers( nNewsletterId, getPlugin( ) );
1983
1984 if ( nNbrSubscribers == 0 )
1985 {
1986 return AdminMessageService.getMessageUrl( request, MESSAGE_NO_SUBSCRIBER_EXPORT, AdminMessage.TYPE_STOP );
1987 }
1988
1989 String strFileName = newsletter.getName( ) + CONSTANT_CSV_FILE_EXTENSION;
1990 byte [ ] byteSubscribersList = _newsletterService.getSubscribersCsvExport( nNewsletterId );
1991 NewsletterUtils.addHeaderResponse( request, response, strFileName, CONSTANT_CSV_FILE_EXTENSION );
1992 response.setContentLength( byteSubscribersList.length );
1993
1994 OutputStream os = null;
1995 try
1996 {
1997 os = response.getOutputStream( );
1998 os.write( byteSubscribersList );
1999 os.close( );
2000 }
2001 catch( IOException e )
2002 {
2003 AppLogService.error( e );
2004 IOUtils.closeQuietly( os );
2005 }
2006
2007 return getHomeUrl( request );
2008 }
2009
2010
2011
2012
2013
2014
2015
2016
2017 @SuppressWarnings( "unchecked" )
2018 public String getManageNewsletterTopics( HttpServletRequest request )
2019 {
2020 String strNewsletterId = request.getParameter( PARAMETER_NEWSLETTER_ID );
2021
2022 if ( !StringUtils.isNumeric( strNewsletterId ) )
2023 {
2024 return getManageNewsLetters( request );
2025 }
2026 int nNewsletterId = Integer.parseInt( strNewsletterId );
2027 NewsLetter newsletter = NewsLetterHome.findByPrimaryKey( nNewsletterId, getPlugin( ) );
2028
2029 if ( !AdminWorkgroupService.isAuthorized( newsletter, getUser( ) )
2030 || !RBACService.isAuthorized( NewsLetter.RESOURCE_TYPE, strNewsletterId, NewsletterResourceIdService.PERMISSION_MODIFY, getUser( ) ) )
2031 {
2032 return getManageNewsLetters( request );
2033 }
2034 setPageTitleProperty( MESSAGE_PAGE_TITLE_MANAGE_TOPICS );
2035
2036 List<NewsletterTopic> listTopics = NewsletterTopicHome.findAllByIdNewsletter( nNewsletterId, getPlugin( ) );
2037
2038
2039 if ( Boolean.parseBoolean( request.getParameter( PARAMETER_UPDATE_TEMPLATE ) ) )
2040 {
2041 String strTemplateId = request.getParameter( MARK_NEWSLETTER_TEMPLATE_ID );
2042 if ( StringUtils.isNumeric( strTemplateId ) )
2043 {
2044 int nTemplateId = Integer.parseInt( strTemplateId );
2045 NewsLetterTemplate newsletterTemplate = NewsLetterTemplateHome.findByPrimaryKey( nTemplateId, getPlugin( ) );
2046 newsletter.setNbSections( newsletterTemplate.getSectionNumber( ) );
2047 newsletter.setNewsLetterTemplateId( nTemplateId );
2048 NewsLetterHome.update( newsletter, getPlugin( ) );
2049 int nNewOrder = NewsletterTopicHome.getNewOrder( nNewsletterId, newsletterTemplate.getSectionNumber( ), getPlugin( ) );
2050 for ( NewsletterTopic topic : listTopics )
2051 {
2052 if ( topic.getSection( ) > newsletterTemplate.getSectionNumber( ) )
2053 {
2054 topic.setSection( newsletterTemplate.getSectionNumber( ) );
2055 topic.setOrder( nNewOrder );
2056 nNewOrder++;
2057 NewsletterTopicHome.updateNewsletterTopic( topic, getPlugin( ) );
2058 }
2059 }
2060 }
2061 }
2062
2063 Map<String, Object> model = new HashMap<String, Object>( );
2064
2065
2066 Integer [ ] tblSectionSize = new Integer [ newsletter.getNbSections( )];
2067 for ( int i = 0; i < newsletter.getNbSections( ); i++ )
2068 {
2069
2070 tblSectionSize [i] = NewsletterTopicHome.getLastOrder( nNewsletterId, i + 1, getPlugin( ) );
2071 }
2072
2073 ReferenceList refListTopicType = _newsletterTopicService.getNewsletterTopicTypeRefList( AdminUserService.getLocale( request ) );
2074
2075 UrlItem url = new UrlItem( JSP_URL_MANAGE_NEWSLETTER_TOPIC );
2076 url.addParameter( PARAMETER_NEWSLETTER_ID, strNewsletterId );
2077 Object object = request.getSession( ).getAttribute( PARAMETER_NEWSLETTER_TOPICS_TABLE_MANAGER );
2078 DataTableManager<NewsletterTopic> tableManager = null;
2079 if ( object instanceof DataTableManager<?> )
2080 {
2081 tableManager = (DataTableManager<NewsletterTopic>) object;
2082
2083 if ( !StringUtils.equals( tableManager.getSortUrl( ), url.getUrl( ) ) )
2084 {
2085 tableManager = null;
2086 }
2087 }
2088 if ( tableManager == null )
2089 {
2090 tableManager = new DataTableManager<NewsletterTopic>( url.getUrl( ), url.getUrl( ),
2091 AppPropertiesService.getPropertyInt( PROPERTY_ITEMS_PER_PAGE, CONSTANT_DEFAULT_ITEM_PER_PAGE ), true );
2092 tableManager.addFreeColumn( LABEL_NEWSLETTER_TOPIC_SECTION, CONSTANT_FREEMARKER_MACRO_COLUMN_SECTION );
2093 tableManager.addColumn( LABEL_NEWSLETTER_TOPIC_ORDER, MARK_NEWSLETTER_TOPIC_ORDER, false );
2094 tableManager.addColumn( LABEL_NEWSLETTER_TOPIC_TITLE, MARK_NEWSLETTER_TOPIC_TITLE, false );
2095 tableManager.addColumn( LABEL_NEWSLETTER_TOPIC_TYPE, MARK_NEWSLETTER_TOPIC_TYPE, false );
2096 tableManager.addActionColumn( LABEL_NEWSLETTER_ACTION );
2097 }
2098
2099 tableManager.filterSortAndPaginate( request, listTopics );
2100
2101 AdminUser user = AdminUserService.getAdminUser( request );
2102 Locale locale = AdminUserService.getLocale( request );
2103 String strBaseUrl = AppPathService.getBaseUrl( request );
2104
2105 Collection<NewsLetterTemplate> newsletterTemplatesList = NewsLetterTemplateHome.getTemplatesCollectionByType( NewsLetterTemplate.RESOURCE_TYPE,
2106 getPlugin( ) );
2107 newsletterTemplatesList = AdminWorkgroupService.getAuthorizedCollection( newsletterTemplatesList, user );
2108
2109 String strPathImageTemplate = _newsletterService.getImageFolderPath( AppPathService.getBaseUrl( request ) );
2110
2111 model.put( MARK_NEWSLETTER, newsletter );
2112 model.put( MARK_NEWSLETTER_TABLE_MANAGER, tableManager );
2113 model.put( MARK_LIST_TOPIC_TYPES, refListTopicType );
2114 model.put( MARK_SECTION_SIZES, tblSectionSize );
2115 model.put( MARK_HTML_CONTENT,
2116 _newsletterService.generateNewsletterHtmlCode( newsletter, newsletter.getNewsLetterTemplateId( ), strBaseUrl, user, locale ) );
2117 model.put( MARK_WEBAPP_URL, strBaseUrl );
2118 model.put( MARK_LOCALE, getLocale( ) );
2119 model.put( MARK_LIST_NEWSLETTER_TEMPLATES, newsletterTemplatesList );
2120 model.put( MARK_NEWSLETTER_TEMPLATE_ID, newsletter.getNewsLetterTemplateId( ) );
2121 model.put( MARK_IMG_PATH, strPathImageTemplate );
2122
2123 HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_MANAGE_NEWSLETTER_TOPICS, AdminUserService.getLocale( request ), model );
2124 String strContent = template.getHtml( );
2125 tableManager.clearItems( );
2126 request.getSession( ).setAttribute( PARAMETER_NEWSLETTER_TOPICS_TABLE_MANAGER, tableManager );
2127
2128 return getAdminPage( strContent );
2129 }
2130
2131
2132
2133
2134
2135
2136
2137
2138 public String doAddNewsletterTopic( HttpServletRequest request )
2139 {
2140 String strNewsletterId = request.getParameter( PARAMETER_NEWSLETTER_ID );
2141 String strTopicType = request.getParameter( PARAMETER_TOPIC_TYPE );
2142 int nNewsletterId = Integer.parseInt( strNewsletterId );
2143
2144 NewsletterTopicess/topic/NewsletterTopic.html#NewsletterTopic">NewsletterTopic newsletterTopic = new NewsletterTopic( );
2145 newsletterTopic.setIdNewsletter( nNewsletterId );
2146 newsletterTopic.setTopicTypeCode( strTopicType );
2147 String strSectionNumber = request.getParameter( PARAMETER_TOPIC_SECTION_NUMBER );
2148 if ( StringUtils.isNumeric( strSectionNumber ) )
2149 {
2150 newsletterTopic.setSection( Integer.parseInt( strSectionNumber ) );
2151 }
2152 else
2153 {
2154 newsletterTopic.setSection( 1 );
2155 }
2156 _newsletterTopicService.createNewsletterTopic( newsletterTopic, getUser( ), AdminUserService.getLocale( request ) );
2157
2158 UrlItem urlItem = new UrlItem( JSP_URL_MODIFY_TOPIC_CONFIG );
2159 urlItem.addParameter( PARAMETER_NEWSLETTER_ID, strNewsletterId );
2160 urlItem.addParameter( PARAMETER_TOPIC_ID, newsletterTopic.getId( ) );
2161 return urlItem.getUrl( );
2162 }
2163
2164
2165
2166
2167
2168
2169
2170
2171 public String confirmRemoveNewsletterTopic( HttpServletRequest request )
2172 {
2173 String strNewsletterId = request.getParameter( PARAMETER_NEWSLETTER_ID );
2174 if ( !StringUtils.isNumeric( strNewsletterId ) )
2175 {
2176 return JSP_URL_MANAGE_NEWSLETTER;
2177 }
2178 int nNewsletterId = Integer.parseInt( strNewsletterId );
2179 NewsLetter newsletter = NewsLetterHome.findByPrimaryKey( nNewsletterId, getPlugin( ) );
2180
2181 if ( !AdminWorkgroupService.isAuthorized( newsletter, getUser( ) )
2182 || !RBACService.isAuthorized( NewsLetter.RESOURCE_TYPE, strNewsletterId, NewsletterResourceIdService.PERMISSION_MODIFY, getUser( ) ) )
2183 {
2184 return JSP_URL_MANAGE_NEWSLETTER;
2185 }
2186 UrlItem urlItem = new UrlItem( JSP_URL_DO_REMOVE_TOPIC );
2187 urlItem.addParameter( PARAMETER_NEWSLETTER_ID, strNewsletterId );
2188 urlItem.addParameter( PARAMETER_TOPIC_ID, request.getParameter( PARAMETER_TOPIC_ID ) );
2189 urlItem.addParameter( PARAMETER_TOPIC_TYPE, request.getParameter( PARAMETER_TOPIC_TYPE ) );
2190 return AdminMessageService.getMessageUrl( request, MESSAGE_CONFIRM_REMOVE_TOPIC, urlItem.getUrl( ), AdminMessage.TYPE_CONFIRMATION );
2191 }
2192
2193
2194
2195
2196
2197
2198
2199
2200 public String doRemoveNewsletterTopic( HttpServletRequest request )
2201 {
2202 String strNewsletterId = request.getParameter( PARAMETER_NEWSLETTER_ID );
2203 if ( !StringUtils.isNumeric( strNewsletterId ) )
2204 {
2205 return JSP_URL_MANAGE_NEWSLETTER;
2206 }
2207 int nNewsletterId = Integer.parseInt( strNewsletterId );
2208 NewsLetter newsletter = NewsLetterHome.findByPrimaryKey( nNewsletterId, getPlugin( ) );
2209
2210 if ( !AdminWorkgroupService.isAuthorized( newsletter, getUser( ) )
2211 || !RBACService.isAuthorized( NewsLetter.RESOURCE_TYPE, strNewsletterId, NewsletterResourceIdService.PERMISSION_MODIFY, getUser( ) ) )
2212 {
2213 return JSP_URL_MANAGE_NEWSLETTER;
2214 }
2215 String strTopicId = request.getParameter( PARAMETER_TOPIC_ID );
2216 if ( !StringUtils.isNumeric( strTopicId ) )
2217 {
2218 return JSP_URL_MANAGE_NEWSLETTER;
2219 }
2220 int nIdTopic = Integer.parseInt( strTopicId );
2221 NewsletterTopic newsletterTopic = NewsletterTopicHome.findByPrimaryKey( nIdTopic, getPlugin( ) );
2222 _newsletterTopicService.removeNewsletterTopic( newsletterTopic, AdminUserService.getAdminUser( request ) );
2223
2224 UrlItem urlItem = new UrlItem( JSP_URL_MANAGE_TOPICS );
2225 urlItem.addParameter( PARAMETER_NEWSLETTER_ID, strNewsletterId );
2226 return urlItem.getUrl( );
2227
2228 }
2229
2230
2231
2232
2233
2234
2235
2236
2237 public String getMoveNewsletterTopic( HttpServletRequest request )
2238 {
2239 String strTopicId = request.getParameter( PARAMETER_TOPIC_ID );
2240
2241 if ( !StringUtils.isNumeric( strTopicId ) )
2242 {
2243 return getManageNewsletterTopics( request );
2244 }
2245 int nIdTopic = Integer.parseInt( strTopicId );
2246 String strMoveUp = request.getParameter( PARAMETER_MOVE_UP );
2247 NewsletterTopic newsletterTopic = NewsletterTopicHome.findByPrimaryKey( nIdTopic, getPlugin( ) );
2248 _newsletterTopicService.modifyNewsletterTopicOrder( newsletterTopic, Boolean.parseBoolean( strMoveUp ) );
2249
2250 return getManageNewsletterTopics( request );
2251 }
2252
2253
2254
2255
2256
2257
2258
2259
2260 public String getModifyTopicConfig( HttpServletRequest request )
2261 {
2262 String strTopicId = request.getParameter( PARAMETER_TOPIC_ID );
2263
2264 if ( !StringUtils.isNumeric( strTopicId ) )
2265 {
2266 return getManageNewsletterTopics( request );
2267 }
2268 int nIdTopic = Integer.parseInt( strTopicId );
2269
2270 setPageTitleProperty( PROPERTY_PAGE_TITLE_MODIFY_TOPIC_CONFIGURATION );
2271 NewsletterTopic newsletterTopic = NewsletterTopicHome.findByPrimaryKey( nIdTopic, getPlugin( ) );
2272 Locale locale = AdminUserService.getLocale( request );
2273 String strContent = _newsletterTopicService.getConfigurationPage( newsletterTopic, AppPathService.getBaseUrl( request ),
2274 AdminUserService.getAdminUser( request ), locale );
2275
2276 Map<String, Object> model = new HashMap<String, Object>( );
2277 model.put( MARK_CONTENT, strContent );
2278 model.put( MARK_TOPIC, newsletterTopic );
2279 HtmlTemplate template = AppTemplateService.getTemplate( TEMPLATE_MODIFY_TOPIC_CONFIG, locale, model );
2280 return getAdminPage( template.getHtml( ) );
2281 }
2282
2283
2284
2285
2286
2287
2288
2289
2290 public String doModifyTopicConfig( HttpServletRequest request )
2291 {
2292 String strTopicId = request.getParameter( PARAMETER_TOPIC_ID );
2293
2294 if ( !StringUtils.isNumeric( strTopicId ) )
2295 {
2296 return JSP_URL_MANAGE_NEWSLETTER;
2297 }
2298 int nIdTopic = Integer.parseInt( strTopicId );
2299
2300 NewsletterTopic newsletterTopic = NewsletterTopicHome.findByPrimaryKey( nIdTopic, getPlugin( ) );
2301
2302 UrlItem url = new UrlItem( JSP_URL_MANAGE_NEWSLETTER_TOPIC );
2303 url.addParameter( PARAMETER_NEWSLETTER_ID, Integer.toString( newsletterTopic.getIdNewsletter( ) ) );
2304
2305
2306 if ( request.getParameter( PARAMETER_CANCEL ) == null )
2307 {
2308 String strTitle = request.getParameter( PARAMETER_TITLE );
2309 if ( StringUtils.isNotEmpty( strTitle ) )
2310 {
2311 newsletterTopic.setTitle( strTitle );
2312 NewsletterTopicHome.updateNewsletterTopic( newsletterTopic, getPlugin( ) );
2313 }
2314
2315 @SuppressWarnings( "unchecked" )
2316 Map<String, String [ ]> mapParameters = request.getParameterMap( );
2317 _newsletterTopicService.saveConfiguration( mapParameters, newsletterTopic, AdminUserService.getAdminUser( request ),
2318 AdminUserService.getLocale( request ) );
2319 }
2320 return AppPathService.getBaseUrl( request ) + url.getUrl( );
2321 }
2322
2323
2324
2325
2326
2327
2328
2329
2330 public String doChangeNewsletterTopicSection( HttpServletRequest request )
2331 {
2332 String strTopicId = request.getParameter( PARAMETER_TOPIC_ID );
2333 String strSection = request.getParameter( PARAMETER_TOPIC_SECTION_NUMBER );
2334
2335 if ( !StringUtils.isNumeric( strTopicId ) || !StringUtils.isNumeric( strSection ) )
2336 {
2337 return getManageNewsletterTopics( request );
2338 }
2339 int nIdTopic = Integer.parseInt( strTopicId );
2340 int nSection = Integer.parseInt( strSection );
2341
2342 NewsletterTopic newsletterTopic = NewsletterTopicHome.findByPrimaryKey( nIdTopic, getPlugin( ) );
2343
2344 _newsletterTopicService.modifyNewsletterTopicSection( newsletterTopic, nSection );
2345
2346 return getManageNewsletterTopics( request );
2347 }
2348
2349
2350
2351
2352 @Override
2353 public Plugin getPlugin( )
2354 {
2355 return PluginService.getPlugin( NewsletterPlugin.PLUGIN_NAME );
2356 }
2357
2358
2359
2360
2361
2362
2363
2364
2365
2366
2367
2368
2369
2370 private String doClean( String strContent, String strBaseUrl )
2371 {
2372 String strNewContent = strContent;
2373 strNewContent = StringUtil.substitute( strNewContent, NewsLetterConstants.WEBAPP_PATH_FOR_LINKSERVICE, strBaseUrl );
2374
2375 return strNewContent;
2376 }
2377
2378
2379
2380
2381
2382
2383
2384
2385 private String isWrongEmail( String strRecipientLists )
2386 {
2387 String strWrongEmail = StringUtils.EMPTY;
2388
2389 String strDelimiter = AppPropertiesService.getProperty( PROPERTY_IMPORT_DELIMITER );
2390
2391 String [ ] strEmails = strRecipientLists.split( strDelimiter );
2392
2393 for ( int j = 0; j < strEmails.length; j++ )
2394 {
2395 if ( !StringUtil.checkEmail( strEmails [j] ) )
2396 {
2397 strWrongEmail = strEmails [j];
2398 }
2399 }
2400
2401 return strWrongEmail;
2402 }
2403
2404
2405
2406
2407
2408
2409
2410
2411 private boolean isNewsletterCreationAllowed( HttpServletRequest request )
2412 {
2413
2414 AdminUser user = AdminUserService.getAdminUser( request );
2415 if ( RBACService.isAuthorized( NewsLetter.RESOURCE_TYPE, RBAC.WILDCARD_RESOURCES_ID, NewsletterResourceIdService.PERMISSION_CREATE, user ) )
2416 {
2417 return true;
2418 }
2419
2420 Collection<NewsLetter> listNewsletter = NewsLetterHome.findAll( getPlugin( ) );
2421 listNewsletter = AdminWorkgroupService.getAuthorizedCollection( listNewsletter, user );
2422
2423 for ( NewsLetter newsletter : listNewsletter )
2424 {
2425 if ( RBACService.isAuthorized( newsletter, NewsletterResourceIdService.PERMISSION_CREATE, user ) )
2426 {
2427 return true;
2428 }
2429 }
2430
2431 return false;
2432 }
2433
2434
2435
2436
2437
2438
2439
2440
2441 private Collection<Subscriber> convertToList( String strRecipients )
2442 {
2443 Collection<Subscriber> listRecipients = new ArrayList<Subscriber>( );
2444
2445 if ( StringUtils.isNotEmpty( strRecipients ) )
2446 {
2447 String strDelimiter = AppPropertiesService.getProperty( PROPERTY_IMPORT_DELIMITER );
2448
2449 String [ ] strEmails = strRecipients.split( strDelimiter );
2450
2451 for ( int j = 0; j < strEmails.length; j++ )
2452 {
2453 if ( StringUtil.checkEmail( strEmails [j] ) )
2454 {
2455 Subscribertter/business/Subscriber.html#Subscriber">Subscriber subscriber = new Subscriber( );
2456 subscriber.setEmail( strEmails [j] );
2457 listRecipients.add( subscriber );
2458 }
2459 }
2460 }
2461
2462 return listRecipients;
2463 }
2464
2465
2466
2467
2468
2469
2470 private String getCssContent( )
2471 {
2472 StringBuilder sbContent = new StringBuilder( StringUtils.EMPTY );
2473 String strListCssFileName = AppPropertiesService.getProperty( PROPERTY_CSS_FILES );
2474 String strWebappPath = AppPathService.getWebAppPath( ) + NewsLetterConstants.CONSTANT_SLASH;
2475 if ( StringUtils.isNotEmpty( strListCssFileName ) )
2476 {
2477 for ( String strName : strListCssFileName.split( SEPARATOR_PROPERTY_CSS_FILES ) )
2478 {
2479 sbContent.append( getTextFileContent( strWebappPath + strName ) );
2480 sbContent.append( SEPARATOR_CSS_FILES_CONTENT );
2481 }
2482 }
2483
2484 return sbContent.toString( );
2485 }
2486
2487
2488
2489
2490
2491
2492
2493
2494 private String getTextFileContent( String strFileName )
2495 {
2496 BufferedReader fileReader = null;
2497 StringBuilder sbSource = new StringBuilder( StringUtils.EMPTY );
2498
2499 try
2500 {
2501 fileReader = new BufferedReader( new FileReader( strFileName ) );
2502
2503 String line;
2504
2505 line = fileReader.readLine( );
2506
2507 while ( line != null )
2508 {
2509 sbSource.append( line + SEPARATOR_CSS_FILES_CONTENT );
2510 line = fileReader.readLine( );
2511 }
2512
2513 fileReader.close( );
2514 }
2515 catch( FileNotFoundException e )
2516 {
2517 AppLogService.error( "plugin-newsletter - CSS '" + strFileName + "' not found ! " + e.getMessage( ) );
2518 }
2519 catch( IOException e )
2520 {
2521 AppLogService.error( "plugin-newsletter - error when reading CSS '" + strFileName + "' ! " + e.getMessage( ) );
2522 }
2523 finally
2524 {
2525 IOUtils.closeQuietly( fileReader );
2526 }
2527
2528 return sbSource.toString( );
2529 }
2530
2531
2532
2533
2534
2535
2536
2537
2538
2539
2540
2541
2542 private HtmlTemplate setHtmlTemplateEmail( NewsLetter newsletter, String strBaseUrl, String strUnsubscribe )
2543 {
2544 Map<String, Object> sendingModel = new HashMap<String, Object>( );
2545 sendingModel.put( MARK_CSS, getCssContent( ) );
2546 sendingModel.put( MARK_UNSUBSCRIBE, strUnsubscribe );
2547 sendingModel.put( MARK_NEWSLETTER_ID, newsletter.getId( ) );
2548 sendingModel.put( MARK_NEWSLETTER_CONTENT, newsletter.getHtml( ) );
2549 sendingModel.put( NewsLetterConstants.MARK_BASE_URL, strBaseUrl );
2550 sendingModel.put( NewsLetterConstants.MARK_SUBSCRIBER_EMAIL, NewsLetterConstants.MARK_SUBSCRIBER_EMAIL_EACH );
2551 sendingModel.put( NewsLetterConstants.MARK_UNSUBSCRIBE_KEY, NewsLetterConstants.MARK_UNSUBSCRIBE_KEY_EACH );
2552
2553 HtmlTemplate templateNewsLetter = AppTemplateService.getTemplate( TEMPLATE_SEND_NEWSLETTER, getLocale( ), sendingModel );
2554
2555 templateNewsLetter.substitute( NewsLetterConstants.WEBAPP_PATH_FOR_LINKSERVICE, strBaseUrl );
2556
2557 return templateNewsLetter;
2558 }
2559
2560
2561
2562
2563
2564
2565
2566
2567 public String doCopyNewsLetter( HttpServletRequest request )
2568 {
2569 AdminUser user = AdminUserService.getAdminUser( request );
2570 Locale locale = AdminUserService.getLocale( request );
2571 int nNewsletterId = Integer.parseInt( request.getParameter( PARAMETER_NEWSLETTER_ID ) );
2572
2573 NewsLetter newsletter = NewsLetterHome.findByPrimaryKey( nNewsletterId, getPlugin( ) );
2574
2575
2576 if ( !AdminWorkgroupService.isAuthorized( newsletter, getUser( ) ) || !RBACService.isAuthorized( NewsLetter.RESOURCE_TYPE,
2577 Integer.toString( newsletter.getId( ) ), NewsletterResourceIdService.PERMISSION_CREATE, getUser( ) ) )
2578 {
2579 return AdminMessageService.getMessageUrl( request, Messages.USER_ACCESS_DENIED, AdminMessage.TYPE_ERROR );
2580 }
2581
2582 Object [ ] tabNewsLetterTileCopy = {
2583 newsletter.getName( )
2584 };
2585 String strTitleCopySuggest = I18nService.getLocalizedString( LABLE_COPY_NEWSLETTER_TITLE, tabNewsLetterTileCopy, getLocale( ) );
2586
2587 if ( strTitleCopySuggest != null )
2588 {
2589 newsletter.setName( strTitleCopySuggest );
2590 }
2591
2592
2593 _newsletterService.copyExistingNewsletter( newsletter, user, locale );
2594 return getHomeUrl( request );
2595 }
2596 }