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