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