1   /**
2    * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
3    *
4    * The contents of this file are subject to the terms of the Liferay Enterprise
5    * Subscription License ("License"). You may not use this file except in
6    * compliance with the License. You can obtain a copy of the License by
7    * contacting Liferay, Inc. See the License for the specific language governing
8    * permissions and limitations under the License, including but not limited to
9    * distribution rights of the Software.
10   *
11   *
12   * 
13   */
14  
15  package com.liferay.portlet.announcements.service.impl;
16  
17  import com.liferay.portal.PortalException;
18  import com.liferay.portal.SystemException;
19  import com.liferay.portal.kernel.dao.orm.QueryUtil;
20  import com.liferay.portal.kernel.language.LanguageUtil;
21  import com.liferay.portal.kernel.log.Log;
22  import com.liferay.portal.kernel.log.LogFactoryUtil;
23  import com.liferay.portal.kernel.mail.MailMessage;
24  import com.liferay.portal.kernel.util.StringUtil;
25  import com.liferay.portal.kernel.util.Validator;
26  import com.liferay.portal.model.Company;
27  import com.liferay.portal.model.Group;
28  import com.liferay.portal.model.Organization;
29  import com.liferay.portal.model.ResourceConstants;
30  import com.liferay.portal.model.Role;
31  import com.liferay.portal.model.User;
32  import com.liferay.portal.model.UserGroup;
33  import com.liferay.portal.util.ContentUtil;
34  import com.liferay.portal.util.PortalUtil;
35  import com.liferay.portal.util.PropsValues;
36  import com.liferay.portlet.announcements.EntryContentException;
37  import com.liferay.portlet.announcements.EntryDisplayDateException;
38  import com.liferay.portlet.announcements.EntryExpirationDateException;
39  import com.liferay.portlet.announcements.EntryTitleException;
40  import com.liferay.portlet.announcements.job.CheckEntryJob;
41  import com.liferay.portlet.announcements.model.AnnouncementsDelivery;
42  import com.liferay.portlet.announcements.model.AnnouncementsEntry;
43  import com.liferay.portlet.announcements.service.base.AnnouncementsEntryLocalServiceBaseImpl;
44  
45  import java.io.IOException;
46  
47  import java.util.ArrayList;
48  import java.util.Date;
49  import java.util.LinkedHashMap;
50  import java.util.List;
51  
52  import javax.mail.internet.InternetAddress;
53  
54  /**
55   * <a href="AnnouncementsEntryLocalServiceImpl.java.html"><b><i>View Source</i>
56   * </b></a>
57   *
58   * @author Brian Wing Shun Chan
59   * @author Raymond Augé
60   */
61  public class AnnouncementsEntryLocalServiceImpl
62      extends AnnouncementsEntryLocalServiceBaseImpl {
63  
64      public AnnouncementsEntry addEntry(
65              long userId, long classNameId, long classPK, String title,
66              String content, String url, String type, int displayDateMonth,
67              int displayDateDay, int displayDateYear, int displayDateHour,
68              int displayDateMinute, int expirationDateMonth,
69              int expirationDateDay, int expirationDateYear,
70              int expirationDateHour, int expirationDateMinute, int priority,
71              boolean alert)
72          throws PortalException, SystemException {
73  
74          // Entry
75  
76          User user = userPersistence.findByPrimaryKey(userId);
77  
78          Date displayDate = PortalUtil.getDate(
79              displayDateMonth, displayDateDay, displayDateYear, displayDateHour,
80              displayDateMinute, user.getTimeZone(),
81              new EntryDisplayDateException());
82  
83          Date expirationDate = PortalUtil.getDate(
84              expirationDateMonth, expirationDateDay, expirationDateYear,
85              expirationDateHour, expirationDateMinute, user.getTimeZone(),
86              new EntryExpirationDateException());
87  
88          Date now = new Date();
89  
90          validate(title, content);
91  
92          long entryId = counterLocalService.increment();
93  
94          AnnouncementsEntry entry = announcementsEntryPersistence.create(
95              entryId);
96  
97          entry.setCompanyId(user.getCompanyId());
98          entry.setUserId(user.getUserId());
99          entry.setUserName(user.getFullName());
100         entry.setCreateDate(now);
101         entry.setModifiedDate(now);
102         entry.setClassNameId(classNameId);
103         entry.setClassPK(classPK);
104         entry.setTitle(title);
105         entry.setContent(content);
106         entry.setUrl(url);
107         entry.setType(type);
108         entry.setDisplayDate(displayDate);
109         entry.setExpirationDate(expirationDate);
110         entry.setPriority(priority);
111         entry.setAlert(alert);
112 
113         announcementsEntryPersistence.update(entry, false);
114 
115         // Resources
116 
117         resourceLocalService.addResources(
118             user.getCompanyId(), 0, user.getUserId(),
119             AnnouncementsEntry.class.getName(), entry.getEntryId(), false,
120             false, false);
121 
122         return entry;
123     }
124 
125     public void checkEntries() throws PortalException, SystemException {
126         Date now = new Date();
127 
128         List<AnnouncementsEntry> entries =
129             announcementsEntryFinder.findByDisplayDate(
130                 now, new Date(now.getTime() - CheckEntryJob.INTERVAL));
131 
132         if (_log.isDebugEnabled()) {
133             _log.debug("Processing " + entries.size() + " entries");
134         }
135 
136         for (AnnouncementsEntry entry : entries) {
137             try {
138                 notifyUsers(entry);
139             }
140             catch (IOException ioe) {
141                 throw new SystemException(ioe);
142             }
143         }
144     }
145 
146     public void deleteEntry(AnnouncementsEntry entry)
147         throws PortalException, SystemException {
148 
149         // Entry
150 
151         announcementsEntryPersistence.remove(entry);
152 
153         // Resources
154 
155         resourceLocalService.deleteResource(
156             entry.getCompanyId(), AnnouncementsEntry.class.getName(),
157             ResourceConstants.SCOPE_INDIVIDUAL, entry.getEntryId());
158 
159         // Flags
160 
161         announcementsFlagLocalService.deleteFlags(entry.getEntryId());
162     }
163 
164     public void deleteEntry(long entryId)
165         throws PortalException, SystemException {
166 
167         AnnouncementsEntry entry =
168             announcementsEntryPersistence.findByPrimaryKey(entryId);
169 
170         deleteEntry(entry);
171     }
172 
173     public List<AnnouncementsEntry> getEntries(
174             long userId, LinkedHashMap<Long, long[]> scopes, boolean alert,
175             int flagValue, int start, int end)
176         throws SystemException {
177 
178         return getEntries(
179             userId, scopes, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, alert, flagValue,
180             start, end);
181     }
182 
183     public List<AnnouncementsEntry> getEntries(
184             long userId, LinkedHashMap<Long, long[]> scopes,
185             int displayDateMonth, int displayDateDay, int displayDateYear,
186             int displayDateHour, int displayDateMinute, int expirationDateMonth,
187             int expirationDateDay, int expirationDateYear,
188             int expirationDateHour, int expirationDateMinute, boolean alert,
189             int flagValue, int start, int end)
190         throws SystemException {
191 
192         return announcementsEntryFinder.findByScopes(
193             userId, scopes, displayDateMonth, displayDateDay, displayDateYear,
194             displayDateHour, displayDateMinute, expirationDateMonth,
195             expirationDateDay, expirationDateYear, expirationDateHour,
196             expirationDateMinute, alert, flagValue, start, end);
197     }
198 
199     public List<AnnouncementsEntry> getEntries(
200             long classNameId, long classPK, boolean alert, int start, int end)
201         throws SystemException {
202 
203         return announcementsEntryPersistence.findByC_C_A(
204             classNameId, classPK, alert, start, end);
205     }
206 
207     public List<AnnouncementsEntry> getEntries(
208             long userId, long classNameId, long[] classPKs,
209             int displayDateMonth, int displayDateDay, int displayDateYear,
210             int displayDateHour, int displayDateMinute, int expirationDateMonth,
211             int expirationDateDay, int expirationDateYear,
212             int expirationDateHour, int expirationDateMinute, boolean alert,
213             int flagValue, int start, int end)
214         throws SystemException {
215 
216         return announcementsEntryFinder.findByScope(
217             userId, classNameId, classPKs, displayDateMonth, displayDateDay,
218             displayDateYear, displayDateHour, displayDateMinute,
219             expirationDateMonth, expirationDateDay, expirationDateYear,
220             expirationDateHour, expirationDateMinute, alert, flagValue, start,
221             end);
222     }
223 
224     public int getEntriesCount(
225             long userId, LinkedHashMap<Long, long[]> scopes, boolean alert,
226             int flagValue)
227         throws SystemException {
228 
229         return getEntriesCount(
230             userId, scopes, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, alert, flagValue);
231     }
232 
233     public int getEntriesCount(
234             long userId, LinkedHashMap<Long, long[]> scopes,
235             int displayDateMonth, int displayDateDay, int displayDateYear,
236             int displayDateHour, int displayDateMinute, int expirationDateMonth,
237             int expirationDateDay, int expirationDateYear,
238             int expirationDateHour, int expirationDateMinute, boolean alert,
239             int flagValue)
240         throws SystemException {
241 
242         return announcementsEntryFinder.countByScopes(
243             userId, scopes, displayDateMonth, displayDateDay, displayDateYear,
244             displayDateHour, displayDateMinute, expirationDateMonth,
245             expirationDateDay, expirationDateYear, expirationDateHour,
246             expirationDateMinute, alert, flagValue);
247     }
248 
249     public int getEntriesCount(long classNameId, long classPK, boolean alert)
250         throws SystemException {
251 
252         return announcementsEntryPersistence.countByC_C_A(
253             classNameId, classPK, alert);
254     }
255 
256     public int getEntriesCount(
257             long userId, long classNameId, long[] classPKs, boolean alert,
258             int flagValue)
259         throws SystemException {
260 
261         return getEntriesCount(
262             userId, classNameId, classPKs, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, alert,
263             flagValue);
264     }
265 
266     public int getEntriesCount(
267             long userId, long classNameId, long[] classPKs,
268             int displayDateMonth, int displayDateDay, int displayDateYear,
269             int displayDateHour, int displayDateMinute, int expirationDateMonth,
270             int expirationDateDay, int expirationDateYear,
271             int expirationDateHour, int expirationDateMinute, boolean alert,
272             int flagValue)
273         throws SystemException {
274 
275         return announcementsEntryFinder.countByScope(
276             userId, classNameId, classPKs, displayDateMonth, displayDateDay,
277             displayDateYear, displayDateHour, displayDateMinute,
278             expirationDateMonth, expirationDateDay, expirationDateYear,
279             expirationDateHour, expirationDateMinute, alert, flagValue);
280     }
281 
282     public AnnouncementsEntry getEntry(long entryId)
283         throws PortalException, SystemException {
284 
285         return announcementsEntryPersistence.findByPrimaryKey(entryId);
286     }
287 
288     public List<AnnouncementsEntry> getUserEntries(
289             long userId, int start, int end)
290         throws SystemException {
291 
292         return announcementsEntryPersistence.findByUserId(userId, start, end);
293     }
294 
295     public int getUserEntriesCount(long userId) throws SystemException {
296         return announcementsEntryPersistence.countByUserId(userId);
297     }
298 
299     public AnnouncementsEntry updateEntry(
300             long userId, long entryId, String title, String content, String url,
301             String type, int displayDateMonth, int displayDateDay,
302             int displayDateYear, int displayDateHour, int displayDateMinute,
303             int expirationDateMonth, int expirationDateDay,
304             int expirationDateYear, int expirationDateHour,
305             int expirationDateMinute, int priority)
306         throws PortalException, SystemException {
307 
308         // Entry
309 
310         User user = userPersistence.findByPrimaryKey(userId);
311 
312         Date displayDate = PortalUtil.getDate(
313             displayDateMonth, displayDateDay, displayDateYear, displayDateHour,
314             displayDateMinute, user.getTimeZone(),
315             new EntryDisplayDateException());
316 
317         Date expirationDate = PortalUtil.getDate(
318             expirationDateMonth, expirationDateDay, expirationDateYear,
319             expirationDateHour, expirationDateMinute, user.getTimeZone(),
320             new EntryExpirationDateException());
321 
322         validate(title, content);
323 
324         AnnouncementsEntry entry =
325             announcementsEntryPersistence.findByPrimaryKey(entryId);
326 
327         entry.setModifiedDate(new Date());
328         entry.setTitle(title);
329         entry.setContent(content);
330         entry.setUrl(url);
331         entry.setType(type);
332         entry.setDisplayDate(displayDate);
333         entry.setExpirationDate(expirationDate);
334         entry.setPriority(priority);
335 
336         announcementsEntryPersistence.update(entry, false);
337 
338         // Flags
339 
340         announcementsFlagLocalService.deleteFlags(entry.getEntryId());
341 
342         return entry;
343     }
344 
345     protected void notifyUsers(AnnouncementsEntry entry)
346         throws IOException, PortalException, SystemException {
347 
348         Company company = companyPersistence.findByPrimaryKey(
349             entry.getCompanyId());
350 
351         String className = entry.getClassName();
352         long classPK = entry.getClassPK();
353 
354         String fromName = PropsValues.ANNOUNCEMENTS_EMAIL_FROM_NAME;
355         String fromAddress = PropsValues.ANNOUNCEMENTS_EMAIL_FROM_ADDRESS;
356 
357         String toName = PropsValues.ANNOUNCEMENTS_EMAIL_TO_NAME;
358         String toAddress = PropsValues.ANNOUNCEMENTS_EMAIL_TO_ADDRESS;
359 
360         LinkedHashMap<String, Object> params =
361             new LinkedHashMap<String, Object>();
362 
363         params.put("announcementsDeliveryEmailOrSms", entry.getType());
364 
365         if (classPK > 0) {
366             if (className.equals(Group.class.getName())) {
367                 Group group = groupPersistence.findByPrimaryKey(classPK);
368 
369                 toName = group.getName();
370 
371                 params.put("usersGroups", classPK);
372             }
373             else if (className.equals(Organization.class.getName())) {
374                 Organization organization =
375                     organizationPersistence.findByPrimaryKey(classPK);
376 
377                 toName = organization.getName();
378 
379                 params.put("usersOrgs", classPK);
380             }
381             else if (className.equals(Role.class.getName())) {
382                 Role role = rolePersistence.findByPrimaryKey(classPK);
383 
384                 toName = role.getName();
385 
386                 params.put("usersRoles", classPK);
387             }
388             else if (className.equals(UserGroup.class.getName())) {
389                 UserGroup userGroup = userGroupPersistence.findByPrimaryKey(
390                     classPK);
391 
392                 toName = userGroup.getName();
393 
394                 params.put("usersUserGroups", classPK);
395             }
396         }
397 
398         List<User> users = null;
399 
400         if (className.equals(User.class.getName())) {
401             User user = userLocalService.getUserById(classPK);
402 
403             toName = user.getFullName();
404             toAddress = user.getEmailAddress();
405 
406             users = new ArrayList<User>();
407 
408             users.add(user);
409         }
410         else {
411             users = userLocalService.search(
412                 company.getCompanyId(), null, Boolean.TRUE, params,
413                 QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
414         }
415 
416         if (_log.isDebugEnabled()) {
417             _log.debug("Notifying " + users.size() + " users");
418         }
419 
420         List<InternetAddress> bulkAddresses = new ArrayList<InternetAddress>();
421 
422         for (User user : users) {
423             AnnouncementsDelivery announcementsDelivery =
424                 announcementsDeliveryLocalService.getUserDelivery(
425                     user.getUserId(), entry.getType());
426 
427             if (announcementsDelivery.isEmail()) {
428                 InternetAddress address = new InternetAddress(
429                     user.getEmailAddress(), user.getFullName());
430 
431                 bulkAddresses.add(address);
432             }
433 
434             if (announcementsDelivery.isSms()) {
435                 String smsSn = user.getContact().getSmsSn();
436 
437                 InternetAddress address = new InternetAddress(
438                     smsSn, user.getFullName());
439 
440                 bulkAddresses.add(address);
441             }
442         }
443 
444         if (bulkAddresses.size() == 0) {
445             return;
446         }
447 
448         String subject = ContentUtil.get(
449             PropsValues.ANNOUNCEMENTS_EMAIL_SUBJECT);
450         String body = ContentUtil.get(PropsValues.ANNOUNCEMENTS_EMAIL_BODY);
451 
452         subject = StringUtil.replace(
453             subject,
454             new String[] {
455                 "[$ENTRY_CONTENT$]",
456                 "[$ENTRY_ID$]",
457                 "[$ENTRY_TITLE$]",
458                 "[$ENTRY_TYPE$]",
459                 "[$ENTRY_URL$]",
460                 "[$FROM_ADDRESS$]",
461                 "[$FROM_NAME$]",
462                 "[$PORTAL_URL$]",
463                 "[$PORTLET_NAME$]",
464                 "[$TO_ADDRESS$]",
465                 "[$TO_NAME$]"
466             },
467             new String[] {
468                 entry.getContent(),
469                 String.valueOf(entry.getEntryId()),
470                 entry.getTitle(),
471                 LanguageUtil.get(company.getLocale(), entry.getType()),
472                 entry.getUrl(),
473                 fromAddress,
474                 fromName,
475                 company.getVirtualHost(),
476                 LanguageUtil.get(
477                     company.getLocale(),
478                     (entry.isAlert() ? "alert" : "announcement")),
479                 toAddress,
480                 toName
481             });
482 
483         body = StringUtil.replace(
484             body,
485             new String[] {
486                 "[$ENTRY_CONTENT$]",
487                 "[$ENTRY_ID$]",
488                 "[$ENTRY_TITLE$]",
489                 "[$ENTRY_TYPE$]",
490                 "[$ENTRY_URL$]",
491                 "[$FROM_ADDRESS$]",
492                 "[$FROM_NAME$]",
493                 "[$PORTAL_URL$]",
494                 "[$PORTLET_NAME$]",
495                 "[$TO_ADDRESS$]",
496                 "[$TO_NAME$]"
497             },
498             new String[] {
499                 entry.getContent(),
500                 String.valueOf(entry.getEntryId()),
501                 entry.getTitle(),
502                 LanguageUtil.get(company.getLocale(), entry.getType()),
503                 entry.getUrl(),
504                 fromAddress,
505                 fromName,
506                 company.getVirtualHost(),
507                 LanguageUtil.get(
508                     company.getLocale(),
509                     (entry.isAlert() ? "alert" : "announcement")),
510                 toAddress,
511                 toName
512             });
513 
514         InternetAddress from = new InternetAddress(fromAddress, fromName);
515 
516         InternetAddress to = new InternetAddress(toAddress, toName);
517 
518         InternetAddress[] bulkAddressesArray = bulkAddresses.toArray(
519             new InternetAddress[bulkAddresses.size()]);
520 
521         MailMessage message = new MailMessage(
522             from, to, subject, body, true);
523 
524         message.setBulkAddresses(bulkAddressesArray);
525 
526         mailService.sendEmail(message);
527     }
528 
529     protected void validate(String title, String content)
530         throws PortalException {
531 
532         if (Validator.isNull(title)) {
533             throw new EntryTitleException();
534         }
535 
536         if (Validator.isNull(content)) {
537             throw new EntryContentException();
538         }
539     }
540 
541     private static Log _log = LogFactoryUtil.getLog(
542         AnnouncementsEntryLocalServiceImpl.class);
543 
544 }