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