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