1   /**
2    * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
3    *
4    * This library is free software; you can redistribute it and/or modify it under
5    * the terms of the GNU Lesser General Public License as published by the Free
6    * Software Foundation; either version 2.1 of the License, or (at your option)
7    * any later version.
8    *
9    * This library is distributed in the hope that it will be useful, but WITHOUT
10   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11   * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
12   * details.
13   */
14  
15  package com.liferay.portal.service.impl;
16  
17  import com.liferay.portal.kernel.exception.PortalException;
18  import com.liferay.portal.kernel.exception.SystemException;
19  import com.liferay.portal.kernel.messaging.DestinationNames;
20  import com.liferay.portal.kernel.scheduler.CronTrigger;
21  import com.liferay.portal.kernel.scheduler.SchedulerEngineUtil;
22  import com.liferay.portal.kernel.scheduler.Trigger;
23  import com.liferay.portal.kernel.util.LocaleUtil;
24  import com.liferay.portal.kernel.util.StringPool;
25  import com.liferay.portal.kernel.uuid.PortalUUIDUtil;
26  import com.liferay.portal.model.Group;
27  import com.liferay.portal.model.Layout;
28  import com.liferay.portal.model.LayoutReference;
29  import com.liferay.portal.model.Plugin;
30  import com.liferay.portal.security.auth.PrincipalException;
31  import com.liferay.portal.security.permission.ActionKeys;
32  import com.liferay.portal.security.permission.PermissionChecker;
33  import com.liferay.portal.service.ServiceContext;
34  import com.liferay.portal.service.base.LayoutServiceBaseImpl;
35  import com.liferay.portal.service.permission.GroupPermissionUtil;
36  import com.liferay.portal.service.permission.LayoutPermissionUtil;
37  import com.liferay.portlet.communities.messaging.LayoutsLocalPublisherRequest;
38  import com.liferay.portlet.communities.messaging.LayoutsRemotePublisherRequest;
39  
40  import java.io.File;
41  import java.io.InputStream;
42  
43  import java.util.Date;
44  import java.util.HashMap;
45  import java.util.Locale;
46  import java.util.Map;
47  
48  /**
49   * <a href="LayoutServiceImpl.java.html"><b><i>View Source</i></b></a>
50   *
51   * @author Brian Wing Shun Chan
52   * @author Wesley Gong
53   */
54  public class LayoutServiceImpl extends LayoutServiceBaseImpl {
55  
56      public Layout addLayout(
57              long groupId, boolean privateLayout, long parentLayoutId,
58              Map<Locale, String> localeNamesMap,
59              Map<Locale, String> localeTitlesMap, String description,
60              String type, boolean hidden, String friendlyURL,
61              ServiceContext serviceContext)
62          throws PortalException, SystemException {
63  
64          GroupPermissionUtil.check(
65              getPermissionChecker(), groupId, ActionKeys.MANAGE_LAYOUTS);
66  
67          return layoutLocalService.addLayout(
68              getUserId(), groupId, privateLayout, parentLayoutId, localeNamesMap,
69              localeTitlesMap, description, type, hidden, friendlyURL,
70              serviceContext);
71      }
72  
73      public Layout addLayout(
74              long groupId, boolean privateLayout, long parentLayoutId,
75              String name, String title, String description, String type,
76              boolean hidden, String friendlyURL, ServiceContext serviceContext)
77          throws PortalException, SystemException {
78  
79          Map<Locale, String> localeNamesMap = new HashMap<Locale, String>();
80  
81          Locale defaultLocale = LocaleUtil.getDefault();
82  
83          localeNamesMap.put(defaultLocale, name);
84  
85          return addLayout(
86              groupId, privateLayout, parentLayoutId, localeNamesMap,
87              new HashMap<Locale, String>(), description, type, hidden,
88              friendlyURL, serviceContext);
89      }
90  
91      public void deleteLayout(long plid)
92          throws PortalException, SystemException {
93  
94          LayoutPermissionUtil.check(
95              getPermissionChecker(), plid, ActionKeys.DELETE);
96  
97          layoutLocalService.deleteLayout(plid);
98      }
99  
100     public void deleteLayout(long groupId, boolean privateLayout, long layoutId)
101         throws PortalException, SystemException {
102 
103         LayoutPermissionUtil.check(
104             getPermissionChecker(), groupId, privateLayout, layoutId,
105             ActionKeys.DELETE);
106 
107         layoutLocalService.deleteLayout(groupId, privateLayout, layoutId);
108     }
109 
110     public byte[] exportLayouts(
111             long groupId, boolean privateLayout, long[] layoutIds,
112             Map<String, String[]> parameterMap, Date startDate, Date endDate)
113         throws PortalException, SystemException {
114 
115         GroupPermissionUtil.check(
116             getPermissionChecker(), groupId, ActionKeys.MANAGE_LAYOUTS);
117 
118         return layoutLocalService.exportLayouts(
119             groupId, privateLayout, layoutIds, parameterMap, startDate,
120             endDate);
121     }
122 
123     public byte[] exportLayouts(
124             long groupId, boolean privateLayout,
125             Map<String, String[]> parameterMap, Date startDate, Date endDate)
126         throws PortalException, SystemException {
127 
128         GroupPermissionUtil.check(
129             getPermissionChecker(), groupId, ActionKeys.MANAGE_LAYOUTS);
130 
131         return layoutLocalService.exportLayouts(
132             groupId, privateLayout, parameterMap, startDate, endDate);
133     }
134 
135     public File exportLayoutsAsFile(
136             long groupId, boolean privateLayout, long[] layoutIds,
137             Map<String, String[]> parameterMap, Date startDate, Date endDate)
138         throws PortalException, SystemException {
139 
140         GroupPermissionUtil.check(
141             getPermissionChecker(), groupId, ActionKeys.MANAGE_LAYOUTS);
142 
143         return layoutLocalService.exportLayoutsAsFile(
144             groupId, privateLayout, layoutIds, parameterMap, startDate,
145             endDate);
146     }
147 
148     public byte[] exportPortletInfo(
149             long plid, long groupId, String portletId,
150             Map<String, String[]> parameterMap, Date startDate, Date endDate)
151         throws PortalException, SystemException {
152 
153         Layout layout = layoutLocalService.getLayout(plid);
154 
155         GroupPermissionUtil.check(
156             getPermissionChecker(), layout.getGroupId(),
157             ActionKeys.MANAGE_LAYOUTS);
158 
159         return layoutLocalService.exportPortletInfo(
160             plid, groupId, portletId, parameterMap, startDate, endDate);
161     }
162 
163     public File exportPortletInfoAsFile(
164             long plid, long groupId, String portletId,
165             Map<String, String[]> parameterMap, Date startDate, Date endDate)
166         throws PortalException, SystemException {
167 
168         Layout layout = layoutLocalService.getLayout(plid);
169 
170         GroupPermissionUtil.check(
171             getPermissionChecker(), layout.getGroupId(),
172             ActionKeys.MANAGE_LAYOUTS);
173 
174         return layoutLocalService.exportPortletInfoAsFile(
175             plid, groupId, portletId, parameterMap, startDate, endDate);
176     }
177 
178     public String getLayoutName(
179             long groupId, boolean privateLayout, long layoutId,
180             String languageId)
181         throws PortalException, SystemException {
182 
183         Layout layout = layoutLocalService.getLayout(
184             groupId, privateLayout, layoutId);
185 
186         return layout.getName(languageId);
187     }
188 
189     public LayoutReference[] getLayoutReferences(
190             long companyId, String portletId, String preferencesKey,
191             String preferencesValue)
192         throws SystemException {
193 
194         return layoutLocalService.getLayouts(
195             companyId, portletId, preferencesKey, preferencesValue);
196     }
197 
198     public void importLayouts(
199             long groupId, boolean privateLayout,
200             Map<String, String[]> parameterMap, byte[] bytes)
201         throws PortalException, SystemException {
202 
203         GroupPermissionUtil.check(
204             getPermissionChecker(), groupId, ActionKeys.MANAGE_LAYOUTS);
205 
206         layoutLocalService.importLayouts(
207             getUserId(), groupId, privateLayout, parameterMap, bytes);
208     }
209 
210     public void importLayouts(
211             long groupId, boolean privateLayout,
212             Map<String, String[]> parameterMap, File file)
213         throws PortalException, SystemException {
214 
215         PermissionChecker permissionChecker = getPermissionChecker();
216 
217         if (!GroupPermissionUtil.contains(
218                 permissionChecker, groupId, ActionKeys.MANAGE_LAYOUTS) &&
219             !GroupPermissionUtil.contains(
220                 permissionChecker, groupId, ActionKeys.PUBLISH_STAGING)) {
221 
222             throw new PrincipalException();
223         }
224 
225         layoutLocalService.importLayouts(
226             getUserId(), groupId, privateLayout, parameterMap, file);
227     }
228 
229     public void importLayouts(
230             long groupId, boolean privateLayout,
231             Map<String, String[]> parameterMap, InputStream is)
232         throws PortalException, SystemException {
233 
234         GroupPermissionUtil.check(
235             getPermissionChecker(), groupId, ActionKeys.MANAGE_LAYOUTS);
236 
237         layoutLocalService.importLayouts(
238             getUserId(), groupId, privateLayout, parameterMap, is);
239     }
240 
241     public void importPortletInfo(
242             long plid, long groupId, String portletId,
243             Map<String, String[]> parameterMap, File file)
244         throws PortalException, SystemException {
245 
246         Layout layout = layoutLocalService.getLayout(plid);
247 
248         GroupPermissionUtil.check(
249             getPermissionChecker(), layout.getGroupId(),
250             ActionKeys.MANAGE_LAYOUTS);
251 
252         layoutLocalService.importPortletInfo(
253             getUserId(), plid, groupId, portletId, parameterMap, file);
254     }
255 
256     public void importPortletInfo(
257             long plid, long groupId, String portletId,
258             Map<String, String[]> parameterMap, InputStream is)
259         throws PortalException, SystemException {
260 
261         Layout layout = layoutLocalService.getLayout(plid);
262 
263         GroupPermissionUtil.check(
264             getPermissionChecker(), layout.getGroupId(),
265             ActionKeys.MANAGE_LAYOUTS);
266 
267         layoutLocalService.importPortletInfo(
268             getUserId(), plid, groupId, portletId, parameterMap, is);
269     }
270 
271     public void schedulePublishToLive(
272             long sourceGroupId, long targetGroupId, boolean privateLayout,
273             Map<Long, Boolean> layoutIdMap, Map<String, String[]> parameterMap,
274             String scope, Date startDate, Date endDate, String groupName,
275             String cronText, Date schedulerStartDate, Date schedulerEndDate,
276             String description)
277         throws PortalException, SystemException {
278 
279         PermissionChecker permissionChecker = getPermissionChecker();
280 
281         if (!GroupPermissionUtil.contains(
282                 permissionChecker, targetGroupId, ActionKeys.MANAGE_STAGING) &&
283             !GroupPermissionUtil.contains(
284                 permissionChecker, targetGroupId, ActionKeys.PUBLISH_STAGING)) {
285 
286             throw new PrincipalException();
287         }
288 
289         String jobName = PortalUUIDUtil.generate();
290 
291         Trigger trigger = new CronTrigger(
292             jobName, groupName, schedulerStartDate, schedulerEndDate,
293             cronText);
294 
295         String command = StringPool.BLANK;
296 
297         if (scope.equals("all-pages")) {
298             command = LayoutsLocalPublisherRequest.COMMAND_ALL_PAGES;
299         }
300         else if (scope.equals("selected-pages")) {
301             command = LayoutsLocalPublisherRequest.COMMAND_SELECTED_PAGES;
302         }
303 
304         LayoutsLocalPublisherRequest publisherRequest =
305             new LayoutsLocalPublisherRequest(
306                 command, getUserId(), sourceGroupId, targetGroupId,
307                 privateLayout, layoutIdMap, parameterMap, startDate, endDate);
308 
309         SchedulerEngineUtil.schedule(
310             trigger, description, DestinationNames.LAYOUTS_LOCAL_PUBLISHER,
311             publisherRequest);
312     }
313 
314     public void schedulePublishToRemote(
315             long sourceGroupId, boolean privateLayout,
316             Map<Long, Boolean> layoutIdMap,
317             Map<String, String[]> parameterMap, String remoteAddress,
318             int remotePort, boolean secureConnection, long remoteGroupId,
319             boolean remotePrivateLayout, Date startDate, Date endDate,
320             String groupName, String cronText, Date schedulerStartDate,
321             Date schedulerEndDate, String description)
322         throws PortalException, SystemException {
323 
324         PermissionChecker permissionChecker = getPermissionChecker();
325 
326         Group group = groupLocalService.getGroup(sourceGroupId);
327 
328         if (group.isStagingGroup()) {
329             group = group.getLiveGroup();
330         }
331 
332         if (group.isWorkflowEnabled() &&
333             !GroupPermissionUtil.contains(
334                 permissionChecker, sourceGroupId, ActionKeys.MANAGE_STAGING) &&
335             !GroupPermissionUtil.contains(
336                 permissionChecker, sourceGroupId, ActionKeys.PUBLISH_STAGING)) {
337 
338             throw new PrincipalException();
339         }
340         else {
341             GroupPermissionUtil.check(
342                 permissionChecker, sourceGroupId, ActionKeys.PUBLISH_TO_REMOTE);
343         }
344 
345         LayoutsRemotePublisherRequest publisherRequest =
346             new LayoutsRemotePublisherRequest(
347                 getUserId(), sourceGroupId, privateLayout, layoutIdMap,
348                 parameterMap, remoteAddress, remotePort, secureConnection,
349                 remoteGroupId, remotePrivateLayout, startDate, endDate);
350 
351         String jobName = PortalUUIDUtil.generate();
352 
353         Trigger trigger =
354             new CronTrigger(
355                 jobName, groupName, schedulerStartDate, schedulerEndDate,
356                 cronText);
357         SchedulerEngineUtil.schedule(
358             trigger, description, DestinationNames.LAYOUTS_REMOTE_PUBLISHER,
359             publisherRequest);
360     }
361 
362     public void setLayouts(
363             long groupId, boolean privateLayout, long parentLayoutId,
364             long[] layoutIds)
365         throws PortalException, SystemException {
366 
367         GroupPermissionUtil.check(
368             getPermissionChecker(), groupId, ActionKeys.MANAGE_LAYOUTS);
369 
370         layoutLocalService.setLayouts(
371             groupId, privateLayout, parentLayoutId, layoutIds);
372     }
373 
374     public void unschedulePublishToLive(
375             long groupId, String jobName, String groupName)
376         throws PortalException, SystemException {
377 
378         PermissionChecker permissionChecker = getPermissionChecker();
379 
380         if (!GroupPermissionUtil.contains(
381                 permissionChecker, groupId, ActionKeys.MANAGE_STAGING) &&
382             !GroupPermissionUtil.contains(
383                 permissionChecker, groupId, ActionKeys.PUBLISH_STAGING)) {
384 
385             throw new PrincipalException();
386         }
387 
388         SchedulerEngineUtil.unschedule(
389             new CronTrigger(jobName, groupName, null));
390     }
391 
392     public void unschedulePublishToRemote(
393             long groupId, String jobName, String groupName)
394         throws PortalException, SystemException {
395 
396         PermissionChecker permissionChecker = getPermissionChecker();
397 
398         Group group = groupLocalService.getGroup(groupId);
399 
400         if (group.isStagingGroup()) {
401             group = group.getLiveGroup();
402         }
403 
404         if (group.isWorkflowEnabled() &&
405             !GroupPermissionUtil.contains(
406                 permissionChecker, groupId, ActionKeys.MANAGE_STAGING) &&
407             !GroupPermissionUtil.contains(
408                 permissionChecker, groupId, ActionKeys.PUBLISH_STAGING)) {
409 
410             throw new PrincipalException();
411         }
412         else {
413             GroupPermissionUtil.check(
414                 permissionChecker, groupId, ActionKeys.MANAGE_LAYOUTS);
415         }
416 
417         SchedulerEngineUtil.unschedule(
418             new CronTrigger(jobName, groupName, null));
419     }
420 
421     public Layout updateLayout(
422             long groupId, boolean privateLayout, long layoutId,
423             long parentLayoutId, Map<Locale, String> localeNamesMap,
424             Map<Locale, String> localeTitlesMap, String description,
425             String type, boolean hidden, String friendlyURL, Boolean iconImage,
426             byte[] iconBytes, ServiceContext serviceContext)
427         throws PortalException, SystemException {
428 
429         LayoutPermissionUtil.check(
430             getPermissionChecker(), groupId, privateLayout, layoutId,
431             ActionKeys.UPDATE);
432 
433         return layoutLocalService.updateLayout(
434             groupId, privateLayout, layoutId, parentLayoutId, localeNamesMap,
435             localeTitlesMap, description, type, hidden, friendlyURL, iconImage,
436             iconBytes, serviceContext);
437     }
438 
439     public Layout updateLayout(
440             long groupId, boolean privateLayout, long layoutId,
441             long parentLayoutId, Map<Locale, String> localeNamesMap,
442             Map<Locale, String> localeTitlesMap, String description,
443             String type, boolean hidden, String friendlyURL,
444             ServiceContext serviceContext)
445         throws PortalException, SystemException {
446 
447         LayoutPermissionUtil.check(
448             getPermissionChecker(), groupId, privateLayout, layoutId,
449             ActionKeys.UPDATE);
450 
451         return layoutLocalService.updateLayout(
452             groupId, privateLayout, layoutId, parentLayoutId, localeNamesMap,
453             localeTitlesMap, description, type, hidden, friendlyURL,
454             serviceContext);
455     }
456 
457     public Layout updateLayout(
458             long groupId, boolean privateLayout, long layoutId,
459             String typeSettings)
460         throws PortalException, SystemException {
461 
462         LayoutPermissionUtil.check(
463             getPermissionChecker(), groupId, privateLayout, layoutId,
464             ActionKeys.UPDATE);
465 
466         return layoutLocalService.updateLayout(
467             groupId, privateLayout, layoutId, typeSettings);
468     }
469 
470     public Layout updateLookAndFeel(
471             long groupId, boolean privateLayout, long layoutId, String themeId,
472             String colorSchemeId, String css, boolean wapTheme)
473         throws PortalException, SystemException {
474 
475         LayoutPermissionUtil.check(
476             getPermissionChecker(), groupId, privateLayout, layoutId,
477             ActionKeys.UPDATE);
478 
479         pluginSettingLocalService.checkPermission(
480             getUserId(), themeId, Plugin.TYPE_THEME);
481 
482         return layoutLocalService.updateLookAndFeel(
483             groupId, privateLayout, layoutId, themeId, colorSchemeId, css,
484             wapTheme);
485     }
486 
487     public Layout updateName(
488             long groupId, boolean privateLayout, long layoutId, String name,
489             String languageId)
490         throws PortalException, SystemException {
491 
492         LayoutPermissionUtil.check(
493             getPermissionChecker(), groupId, privateLayout, layoutId,
494             ActionKeys.UPDATE);
495 
496         return layoutLocalService.updateName(
497             groupId, privateLayout, layoutId, name, languageId);
498     }
499 
500     public Layout updateName(long plid, String name, String languageId)
501         throws PortalException, SystemException {
502 
503         LayoutPermissionUtil.check(
504             getPermissionChecker(), plid, ActionKeys.UPDATE);
505 
506         return layoutLocalService.updateName(plid, name, languageId);
507     }
508 
509     public Layout updateParentLayoutId(
510             long groupId, boolean privateLayout, long layoutId,
511             long parentLayoutId)
512         throws PortalException, SystemException {
513 
514         LayoutPermissionUtil.check(
515             getPermissionChecker(), groupId, privateLayout, layoutId,
516             ActionKeys.UPDATE);
517 
518         return layoutLocalService.updateParentLayoutId(
519             groupId, privateLayout, layoutId, parentLayoutId);
520     }
521 
522     public Layout updateParentLayoutId(long plid, long parentPlid)
523         throws PortalException, SystemException {
524 
525         LayoutPermissionUtil.check(
526             getPermissionChecker(), plid, ActionKeys.UPDATE);
527 
528         return layoutLocalService.updateParentLayoutId(plid, parentPlid);
529     }
530 
531     public Layout updatePriority(
532             long groupId, boolean privateLayout, long layoutId, int priority)
533         throws PortalException, SystemException {
534 
535         LayoutPermissionUtil.check(
536             getPermissionChecker(), groupId, privateLayout, layoutId,
537             ActionKeys.UPDATE);
538 
539         return layoutLocalService.updatePriority(
540             groupId, privateLayout, layoutId, priority);
541     }
542 
543     public Layout updatePriority(long plid, int priority)
544         throws PortalException, SystemException {
545 
546         LayoutPermissionUtil.check(
547             getPermissionChecker(), plid, ActionKeys.UPDATE);
548 
549         return layoutLocalService.updatePriority(plid, priority);
550     }
551 
552 }