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.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 preferencesKey,
127             String preferencesValue)
128         throws SystemException {
129 
130         return layoutLocalService.getLayouts(
131             companyId, portletId, preferencesKey, preferencesValue);
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 FileCacheOutputStream exportLayoutsAsStream(
160             long groupId, boolean privateLayout, long[] layoutIds,
161             Map<String, String[]> parameterMap, Date startDate, Date endDate)
162         throws PortalException, SystemException {
163 
164         GroupPermissionUtil.check(
165             getPermissionChecker(), groupId, ActionKeys.MANAGE_LAYOUTS);
166 
167         return layoutLocalService.exportLayoutsAsStream(
168             groupId, privateLayout, layoutIds, parameterMap, startDate,
169             endDate);
170     }
171 
172     public byte[] exportPortletInfo(
173             long plid, long groupId, String portletId,
174             Map<String, String[]> parameterMap, Date startDate, Date endDate)
175         throws PortalException, SystemException {
176 
177         Layout layout = layoutLocalService.getLayout(plid);
178 
179         GroupPermissionUtil.check(
180             getPermissionChecker(), layout.getGroupId(),
181             ActionKeys.MANAGE_LAYOUTS);
182 
183         return layoutLocalService.exportPortletInfo(
184             plid, groupId, portletId, parameterMap, startDate, endDate);
185     }
186 
187     public FileCacheOutputStream exportPortletInfoAsStream(
188             long plid, long groupId, String portletId,
189             Map<String, String[]> parameterMap, Date startDate, Date endDate)
190         throws PortalException, SystemException {
191 
192         Layout layout = layoutLocalService.getLayout(plid);
193 
194         GroupPermissionUtil.check(
195             getPermissionChecker(), layout.getGroupId(),
196             ActionKeys.MANAGE_LAYOUTS);
197 
198         return layoutLocalService.exportPortletInfoAsStream(
199             plid, groupId, portletId, parameterMap, startDate, endDate);
200     }
201 
202     public void importLayouts(
203             long groupId, boolean privateLayout,
204             Map<String, String[]> parameterMap, File file)
205         throws PortalException, SystemException {
206 
207         GroupPermissionUtil.check(
208             getPermissionChecker(), groupId, ActionKeys.MANAGE_LAYOUTS);
209 
210         layoutLocalService.importLayouts(
211             getUserId(), groupId, privateLayout, parameterMap, file);
212     }
213 
214     public void importLayouts(
215             long groupId, boolean privateLayout,
216             Map<String, String[]> parameterMap, byte[] bytes)
217         throws PortalException, SystemException {
218 
219         GroupPermissionUtil.check(
220             getPermissionChecker(), groupId, ActionKeys.MANAGE_LAYOUTS);
221 
222         layoutLocalService.importLayouts(
223             getUserId(), groupId, privateLayout, parameterMap, bytes);
224     }
225 
226     public void importLayouts(
227             long groupId, boolean privateLayout,
228             Map<String, String[]> parameterMap, InputStream is)
229         throws PortalException, SystemException {
230 
231         GroupPermissionUtil.check(
232             getPermissionChecker(), groupId, ActionKeys.MANAGE_LAYOUTS);
233 
234         layoutLocalService.importLayouts(
235             getUserId(), groupId, privateLayout, parameterMap, is);
236     }
237 
238     public void importPortletInfo(
239             long plid, long groupId, String portletId,
240             Map<String, String[]> parameterMap, File file)
241         throws PortalException, SystemException {
242 
243         Layout layout = layoutLocalService.getLayout(plid);
244 
245         GroupPermissionUtil.check(
246             getPermissionChecker(), layout.getGroupId(),
247             ActionKeys.MANAGE_LAYOUTS);
248 
249         layoutLocalService.importPortletInfo(
250             getUserId(), plid, groupId, portletId, parameterMap, file);
251     }
252 
253     public void importPortletInfo(
254             long plid, long groupId, String portletId,
255             Map<String, String[]> parameterMap, InputStream is)
256         throws PortalException, SystemException {
257 
258         Layout layout = layoutLocalService.getLayout(plid);
259 
260         GroupPermissionUtil.check(
261             getPermissionChecker(), layout.getGroupId(),
262             ActionKeys.MANAGE_LAYOUTS);
263 
264         layoutLocalService.importPortletInfo(
265             getUserId(), plid, groupId, portletId, parameterMap, is);
266     }
267 
268     public void schedulePublishToLive(
269             long sourceGroupId, long targetGroupId, boolean privateLayout,
270             Map<Long, Boolean> layoutIdMap, Map<String, String[]> parameterMap,
271             String scope, Date startDate, Date endDate, String groupName,
272             String cronText, Date schedulerStartDate, Date schedulerEndDate,
273             String description)
274         throws PortalException, SystemException {
275 
276         PermissionChecker permissionChecker = getPermissionChecker();
277 
278         if (!GroupPermissionUtil.contains(
279                 permissionChecker, targetGroupId, ActionKeys.MANAGE_STAGING) &&
280             !GroupPermissionUtil.contains(
281                 permissionChecker, targetGroupId, ActionKeys.PUBLISH_STAGING)) {
282 
283             throw new PrincipalException();
284         }
285 
286         String command = StringPool.BLANK;
287 
288         if (scope.equals("all-pages")) {
289             command = LayoutsLocalPublisherRequest.COMMAND_ALL_PAGES;
290         }
291         else if (scope.equals("selected-pages")) {
292             command = LayoutsLocalPublisherRequest.COMMAND_SELECTED_PAGES;
293         }
294 
295         LayoutsLocalPublisherRequest publisherRequest =
296             new LayoutsLocalPublisherRequest(
297                 command, getUserId(), sourceGroupId, targetGroupId,
298                 privateLayout, layoutIdMap, parameterMap, startDate, endDate);
299 
300         SchedulerEngineUtil.schedule(
301             groupName, cronText, schedulerStartDate, schedulerEndDate,
302             description, DestinationNames.LAYOUTS_LOCAL_PUBLISHER,
303             JSONFactoryUtil.serialize(publisherRequest));
304     }
305 
306     public void schedulePublishToRemote(
307             long sourceGroupId, boolean privateLayout,
308             Map<Long, Boolean> layoutIdMap,
309             Map<String, String[]> parameterMap, String remoteAddress,
310             int remotePort, boolean secureConnection, long remoteGroupId,
311             boolean remotePrivateLayout, Date startDate, Date endDate,
312             String groupName, String cronText, Date schedulerStartDate,
313             Date schedulerEndDate, String description)
314         throws PortalException, SystemException {
315 
316         PermissionChecker permissionChecker = getPermissionChecker();
317 
318         Group group = groupLocalService.getGroup(sourceGroupId);
319 
320         if (group.isStagingGroup()) {
321             group = group.getLiveGroup();
322         }
323 
324         if (group.isWorkflowEnabled() &&
325             !GroupPermissionUtil.contains(
326                 permissionChecker, sourceGroupId, ActionKeys.MANAGE_STAGING) &&
327             !GroupPermissionUtil.contains(
328                 permissionChecker, sourceGroupId, ActionKeys.PUBLISH_STAGING)) {
329 
330             throw new PrincipalException();
331         }
332         else {
333             GroupPermissionUtil.check(
334                 permissionChecker, sourceGroupId, ActionKeys.MANAGE_LAYOUTS);
335         }
336 
337         LayoutsRemotePublisherRequest publisherRequest =
338             new LayoutsRemotePublisherRequest(
339                 getUserId(), sourceGroupId, privateLayout, layoutIdMap,
340                 parameterMap, remoteAddress, remotePort, secureConnection,
341                 remoteGroupId, remotePrivateLayout, startDate, endDate);
342 
343         SchedulerEngineUtil.schedule(
344             groupName, cronText, schedulerStartDate, schedulerEndDate,
345             description, DestinationNames.LAYOUTS_REMOTE_PUBLISHER,
346             JSONFactoryUtil.serialize(publisherRequest));
347     }
348 
349     public void setLayouts(
350             long groupId, boolean privateLayout, long parentLayoutId,
351             long[] layoutIds)
352         throws PortalException, SystemException {
353 
354         GroupPermissionUtil.check(
355             getPermissionChecker(), groupId, ActionKeys.MANAGE_LAYOUTS);
356 
357         layoutLocalService.setLayouts(
358             groupId, privateLayout, parentLayoutId, layoutIds);
359     }
360 
361     public void unschedulePublishToLive(
362             long groupId, String jobName, String groupName)
363         throws PortalException, SystemException {
364 
365         PermissionChecker permissionChecker = getPermissionChecker();
366 
367         if (!GroupPermissionUtil.contains(
368                 permissionChecker, groupId, ActionKeys.MANAGE_STAGING) &&
369             !GroupPermissionUtil.contains(
370                 permissionChecker, groupId, ActionKeys.PUBLISH_STAGING)) {
371 
372             throw new PrincipalException();
373         }
374 
375         SchedulerEngineUtil.unschedule(jobName, groupName);
376     }
377 
378     public void unschedulePublishToRemote(
379             long groupId, String jobName, String groupName)
380         throws PortalException, SystemException {
381 
382         PermissionChecker permissionChecker = getPermissionChecker();
383 
384         Group group = groupLocalService.getGroup(groupId);
385 
386         if (group.isStagingGroup()) {
387             group = group.getLiveGroup();
388         }
389 
390         if (group.isWorkflowEnabled() &&
391             !GroupPermissionUtil.contains(
392                 permissionChecker, groupId, ActionKeys.MANAGE_STAGING) &&
393             !GroupPermissionUtil.contains(
394                 permissionChecker, groupId, ActionKeys.PUBLISH_STAGING)) {
395 
396             throw new PrincipalException();
397         }
398         else {
399             GroupPermissionUtil.check(
400                 permissionChecker, groupId, ActionKeys.MANAGE_LAYOUTS);
401         }
402 
403         SchedulerEngineUtil.unschedule(jobName, groupName);
404     }
405 
406     public Layout updateLayout(
407             long groupId, boolean privateLayout, long layoutId,
408             long parentLayoutId, Map<Locale, String> localeNamesMap,
409             Map<Locale, String> localeTitlesMap, String description,
410             String type, boolean hidden, String friendlyURL)
411         throws PortalException, SystemException {
412 
413         LayoutPermissionUtil.check(
414             getPermissionChecker(), groupId, privateLayout, layoutId,
415             ActionKeys.UPDATE);
416 
417         return layoutLocalService.updateLayout(
418             groupId, privateLayout, layoutId, parentLayoutId, localeNamesMap,
419             localeTitlesMap, description, type, hidden, friendlyURL);
420     }
421 
422     public Layout updateLayout(
423             long groupId, boolean privateLayout, long layoutId,
424             long parentLayoutId, Map<Locale, String> localeNamesMap,
425             Map<Locale, String> localeTitlesMap, String description,
426             String type, boolean hidden, String friendlyURL, Boolean iconImage,
427             byte[] iconBytes)
428         throws PortalException, SystemException {
429 
430         LayoutPermissionUtil.check(
431             getPermissionChecker(), groupId, privateLayout, layoutId,
432             ActionKeys.UPDATE);
433 
434         return layoutLocalService.updateLayout(
435             groupId, privateLayout, layoutId, parentLayoutId, localeNamesMap,
436             localeTitlesMap, description, type, hidden, friendlyURL, iconImage,
437             iconBytes);
438     }
439 
440     public Layout updateLayout(
441             long groupId, boolean privateLayout, long layoutId,
442             String typeSettings)
443         throws PortalException, SystemException {
444 
445         LayoutPermissionUtil.check(
446             getPermissionChecker(), groupId, privateLayout, layoutId,
447             ActionKeys.UPDATE);
448 
449         return layoutLocalService.updateLayout(
450             groupId, privateLayout, layoutId, typeSettings);
451     }
452 
453     public Layout updateLookAndFeel(
454             long groupId, boolean privateLayout, long layoutId, String themeId,
455             String colorSchemeId, String css, boolean wapTheme)
456         throws PortalException, SystemException {
457 
458         LayoutPermissionUtil.check(
459             getPermissionChecker(), groupId, privateLayout, layoutId,
460             ActionKeys.UPDATE);
461 
462         pluginSettingLocalService.checkPermission(
463             getUserId(), themeId, Plugin.TYPE_THEME);
464 
465         return layoutLocalService.updateLookAndFeel(
466             groupId, privateLayout, layoutId, themeId, colorSchemeId, css,
467             wapTheme);
468     }
469 
470     public Layout updateName(long plid, String name, String languageId)
471         throws PortalException, SystemException {
472 
473         LayoutPermissionUtil.check(
474             getPermissionChecker(), plid, ActionKeys.UPDATE);
475 
476         return layoutLocalService.updateName(plid, name, languageId);
477     }
478 
479     public Layout updateName(
480             long groupId, boolean privateLayout, long layoutId, String name,
481             String languageId)
482         throws PortalException, SystemException {
483 
484         LayoutPermissionUtil.check(
485             getPermissionChecker(), groupId, privateLayout, layoutId,
486             ActionKeys.UPDATE);
487 
488         return layoutLocalService.updateName(
489             groupId, privateLayout, layoutId, name, languageId);
490     }
491 
492     public Layout updateParentLayoutId(long plid, long parentPlid)
493         throws PortalException, SystemException {
494 
495         LayoutPermissionUtil.check(
496             getPermissionChecker(), plid, ActionKeys.UPDATE);
497 
498         return layoutLocalService.updateParentLayoutId(plid, parentPlid);
499     }
500 
501     public Layout updateParentLayoutId(
502             long groupId, boolean privateLayout, long layoutId,
503             long parentLayoutId)
504         throws PortalException, SystemException {
505 
506         LayoutPermissionUtil.check(
507             getPermissionChecker(), groupId, privateLayout, layoutId,
508             ActionKeys.UPDATE);
509 
510         return layoutLocalService.updateParentLayoutId(
511             groupId, privateLayout, layoutId, parentLayoutId);
512     }
513 
514     public Layout updatePriority(long plid, int priority)
515         throws PortalException, SystemException {
516 
517         LayoutPermissionUtil.check(
518             getPermissionChecker(), plid, ActionKeys.UPDATE);
519 
520         return layoutLocalService.updatePriority(plid, priority);
521     }
522 
523     public Layout updatePriority(
524             long groupId, boolean privateLayout, long layoutId, int priority)
525         throws PortalException, SystemException {
526 
527         LayoutPermissionUtil.check(
528             getPermissionChecker(), groupId, privateLayout, layoutId,
529             ActionKeys.UPDATE);
530 
531         return layoutLocalService.updatePriority(
532             groupId, privateLayout, layoutId, priority);
533     }
534 
535 }