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