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