1   /**
2    * Copyright (c) 2000-2009 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   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
12   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
13   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
14   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
15   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
16   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
17   * SOFTWARE.
18   */
19  
20  package com.liferay.portal.service.impl;
21  
22  import com.liferay.portal.PortalException;
23  import com.liferay.portal.SystemException;
24  import com.liferay.portal.kernel.io.FileCacheOutputStream;
25  import com.liferay.portal.kernel.json.JSONFactoryUtil;
26  import com.liferay.portal.kernel.messaging.DestinationNames;
27  import com.liferay.portal.kernel.scheduler.SchedulerEngineUtil;
28  import com.liferay.portal.kernel.util.LocaleUtil;
29  import com.liferay.portal.kernel.util.StringPool;
30  import com.liferay.portal.model.Group;
31  import com.liferay.portal.model.Layout;
32  import com.liferay.portal.model.LayoutReference;
33  import com.liferay.portal.model.Plugin;
34  import com.liferay.portal.security.auth.PrincipalException;
35  import com.liferay.portal.security.permission.ActionKeys;
36  import com.liferay.portal.security.permission.PermissionChecker;
37  import com.liferay.portal.service.base.LayoutServiceBaseImpl;
38  import com.liferay.portal.service.permission.GroupPermissionUtil;
39  import com.liferay.portal.service.permission.LayoutPermissionUtil;
40  import com.liferay.portlet.communities.messaging.LayoutsLocalPublisherRequest;
41  import com.liferay.portlet.communities.messaging.LayoutsRemotePublisherRequest;
42  
43  import java.io.File;
44  import java.io.InputStream;
45  
46  import java.util.Date;
47  import java.util.HashMap;
48  import java.util.Locale;
49  import java.util.Map;
50  
51  /**
52   * <a href="LayoutServiceImpl.java.html"><b><i>View Source</i></b></a>
53   *
54   * @author Brian Wing Shun Chan
55   *
56   */
57  public class LayoutServiceImpl extends LayoutServiceBaseImpl {
58  
59      public Layout addLayout(
60              long groupId, boolean privateLayout, long parentLayoutId,
61              String name, String title, String description, String type,
62              boolean hidden, String friendlyURL)
63          throws PortalException, SystemException {
64  
65          Map<Locale, String> localeNamesMap = new HashMap<Locale, String>();
66  
67          Locale defaultLocale = LocaleUtil.getDefault();
68  
69          localeNamesMap.put(defaultLocale, name);
70  
71          return addLayout(
72              groupId, privateLayout, parentLayoutId, localeNamesMap,
73              new HashMap<Locale, String>(), description, type, hidden,
74              friendlyURL);
75      }
76  
77      public Layout addLayout(
78              long groupId, boolean privateLayout, long parentLayoutId,
79              Map<Locale, String> localeNamesMap,
80              Map<Locale, String> localeTitlesMap, String description,
81              String type, boolean hidden, String friendlyURL)
82          throws PortalException, SystemException {
83  
84          GroupPermissionUtil.check(
85              getPermissionChecker(), groupId, ActionKeys.MANAGE_LAYOUTS);
86  
87          return layoutLocalService.addLayout(
88              getUserId(), groupId, privateLayout, parentLayoutId, localeNamesMap,
89              localeTitlesMap, description, type, hidden, friendlyURL);
90      }
91  
92      public void deleteLayout(long plid)
93          throws PortalException, SystemException {
94  
95          LayoutPermissionUtil.check(
96              getPermissionChecker(), plid, ActionKeys.DELETE);
97  
98          layoutLocalService.deleteLayout(plid);
99      }
100 
101     public void deleteLayout(long groupId, boolean privateLayout, long layoutId)
102         throws PortalException, SystemException {
103 
104         LayoutPermissionUtil.check(
105             getPermissionChecker(), groupId, privateLayout, layoutId,
106             ActionKeys.DELETE);
107 
108         layoutLocalService.deleteLayout(groupId, privateLayout, layoutId);
109     }
110 
111     public String getLayoutName(
112             long groupId, boolean privateLayout, long layoutId,
113             String languageId)
114         throws PortalException, SystemException {
115 
116         Layout layout = layoutLocalService.getLayout(
117             groupId, privateLayout, layoutId);
118 
119         return layout.getName(languageId);
120     }
121 
122     public LayoutReference[] getLayoutReferences(
123             long companyId, String portletId, String preferencesKey,
124             String preferencesValue)
125         throws SystemException {
126 
127         return layoutLocalService.getLayouts(
128             companyId, portletId, preferencesKey, preferencesValue);
129     }
130 
131     public byte[] exportLayouts(
132             long groupId, boolean privateLayout,
133             Map<String, String[]> parameterMap, Date startDate, Date endDate)
134         throws PortalException, SystemException {
135 
136         GroupPermissionUtil.check(
137             getPermissionChecker(), groupId, ActionKeys.MANAGE_LAYOUTS);
138 
139         return layoutLocalService.exportLayouts(
140             groupId, privateLayout, parameterMap, startDate, endDate);
141     }
142 
143     public byte[] exportLayouts(
144             long groupId, boolean privateLayout, long[] layoutIds,
145             Map<String, String[]> parameterMap, Date startDate, Date endDate)
146         throws PortalException, SystemException {
147 
148         GroupPermissionUtil.check(
149             getPermissionChecker(), groupId, ActionKeys.MANAGE_LAYOUTS);
150 
151         return layoutLocalService.exportLayouts(
152             groupId, privateLayout, layoutIds, parameterMap, startDate,
153             endDate);
154     }
155 
156     public FileCacheOutputStream exportLayoutsAsStream(
157             long groupId, boolean privateLayout, long[] layoutIds,
158             Map<String, String[]> parameterMap, Date startDate, Date endDate)
159         throws PortalException, SystemException {
160 
161         GroupPermissionUtil.check(
162             getPermissionChecker(), groupId, ActionKeys.MANAGE_LAYOUTS);
163 
164         return layoutLocalService.exportLayoutsAsStream(
165             groupId, privateLayout, layoutIds, parameterMap, startDate,
166             endDate);
167     }
168 
169     public byte[] exportPortletInfo(
170             long plid, long groupId, String portletId,
171             Map<String, String[]> parameterMap, Date startDate, Date endDate)
172         throws PortalException, SystemException {
173 
174         Layout layout = layoutLocalService.getLayout(plid);
175 
176         GroupPermissionUtil.check(
177             getPermissionChecker(), layout.getGroupId(),
178             ActionKeys.MANAGE_LAYOUTS);
179 
180         return layoutLocalService.exportPortletInfo(
181             plid, groupId, portletId, parameterMap, startDate, endDate);
182     }
183 
184     public FileCacheOutputStream exportPortletInfoAsStream(
185             long plid, long groupId, String portletId,
186             Map<String, String[]> parameterMap, Date startDate, Date endDate)
187         throws PortalException, SystemException {
188 
189         Layout layout = layoutLocalService.getLayout(plid);
190 
191         GroupPermissionUtil.check(
192             getPermissionChecker(), layout.getGroupId(),
193             ActionKeys.MANAGE_LAYOUTS);
194 
195         return layoutLocalService.exportPortletInfoAsStream(
196             plid, groupId, portletId, parameterMap, startDate, endDate);
197     }
198 
199     public void importLayouts(
200             long groupId, boolean privateLayout,
201             Map<String, String[]> parameterMap, File file)
202         throws PortalException, SystemException {
203 
204         GroupPermissionUtil.check(
205             getPermissionChecker(), groupId, ActionKeys.MANAGE_LAYOUTS);
206 
207         layoutLocalService.importLayouts(
208             getUserId(), groupId, privateLayout, parameterMap, file);
209     }
210 
211     public void importLayouts(
212             long groupId, boolean privateLayout,
213             Map<String, String[]> parameterMap, byte[] bytes)
214         throws PortalException, SystemException {
215 
216         GroupPermissionUtil.check(
217             getPermissionChecker(), groupId, ActionKeys.MANAGE_LAYOUTS);
218 
219         layoutLocalService.importLayouts(
220             getUserId(), groupId, privateLayout, parameterMap, bytes);
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(long plid, String name, String languageId)
468         throws PortalException, SystemException {
469 
470         LayoutPermissionUtil.check(
471             getPermissionChecker(), plid, ActionKeys.UPDATE);
472 
473         return layoutLocalService.updateName(plid, name, languageId);
474     }
475 
476     public Layout updateName(
477             long groupId, boolean privateLayout, long layoutId, String name,
478             String languageId)
479         throws PortalException, SystemException {
480 
481         LayoutPermissionUtil.check(
482             getPermissionChecker(), groupId, privateLayout, layoutId,
483             ActionKeys.UPDATE);
484 
485         return layoutLocalService.updateName(
486             groupId, privateLayout, layoutId, name, languageId);
487     }
488 
489     public Layout updateParentLayoutId(long plid, long parentPlid)
490         throws PortalException, SystemException {
491 
492         LayoutPermissionUtil.check(
493             getPermissionChecker(), plid, ActionKeys.UPDATE);
494 
495         return layoutLocalService.updateParentLayoutId(plid, parentPlid);
496     }
497 
498     public Layout updateParentLayoutId(
499             long groupId, boolean privateLayout, long layoutId,
500             long parentLayoutId)
501         throws PortalException, SystemException {
502 
503         LayoutPermissionUtil.check(
504             getPermissionChecker(), groupId, privateLayout, layoutId,
505             ActionKeys.UPDATE);
506 
507         return layoutLocalService.updateParentLayoutId(
508             groupId, privateLayout, layoutId, parentLayoutId);
509     }
510 
511     public Layout updatePriority(long plid, int priority)
512         throws PortalException, SystemException {
513 
514         LayoutPermissionUtil.check(
515             getPermissionChecker(), plid, ActionKeys.UPDATE);
516 
517         return layoutLocalService.updatePriority(plid, priority);
518     }
519 
520     public Layout updatePriority(
521             long groupId, boolean privateLayout, long layoutId, int priority)
522         throws PortalException, SystemException {
523 
524         LayoutPermissionUtil.check(
525             getPermissionChecker(), groupId, privateLayout, layoutId,
526             ActionKeys.UPDATE);
527 
528         return layoutLocalService.updatePriority(
529             groupId, privateLayout, layoutId, priority);
530     }
531 
532 }