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.json.JSONFactoryUtil;
28  import com.liferay.portal.kernel.messaging.DestinationNames;
29  import com.liferay.portal.kernel.scheduler.SchedulerEngineUtil;
30  import com.liferay.portal.kernel.util.LocaleUtil;
31  import com.liferay.portal.kernel.util.StringPool;
32  import com.liferay.portal.model.Group;
33  import com.liferay.portal.model.Layout;
34  import com.liferay.portal.model.LayoutReference;
35  import com.liferay.portal.model.Plugin;
36  import com.liferay.portal.security.auth.PrincipalException;
37  import com.liferay.portal.security.permission.ActionKeys;
38  import com.liferay.portal.security.permission.PermissionChecker;
39  import com.liferay.portal.service.base.LayoutServiceBaseImpl;
40  import com.liferay.portal.service.permission.GroupPermissionUtil;
41  import com.liferay.portal.service.permission.LayoutPermissionUtil;
42  import com.liferay.portlet.communities.messaging.LayoutsLocalPublisherRequest;
43  import com.liferay.portlet.communities.messaging.LayoutsRemotePublisherRequest;
44  
45  import java.io.File;
46  import java.io.InputStream;
47  
48  import java.util.Date;
49  import java.util.HashMap;
50  import java.util.Locale;
51  import java.util.Map;
52  
53  /**
54   * <a href="LayoutServiceImpl.java.html"><b><i>View Source</i></b></a>
55   *
56   * @author Brian Wing Shun Chan
57   */
58  public class LayoutServiceImpl extends LayoutServiceBaseImpl {
59  
60      public Layout addLayout(
61              long groupId, boolean privateLayout, long parentLayoutId,
62              Map<Locale, String> localeNamesMap,
63              Map<Locale, String> localeTitlesMap, String description,
64              String type, boolean hidden, String friendlyURL)
65          throws PortalException, SystemException {
66  
67          GroupPermissionUtil.check(
68              getPermissionChecker(), groupId, ActionKeys.MANAGE_LAYOUTS);
69  
70          return layoutLocalService.addLayout(
71              getUserId(), groupId, privateLayout, parentLayoutId, localeNamesMap,
72              localeTitlesMap, description, type, hidden, friendlyURL);
73      }
74  
75      public Layout addLayout(
76              long groupId, boolean privateLayout, long parentLayoutId,
77              String name, String title, String description, String type,
78              boolean hidden, String friendlyURL)
79          throws PortalException, SystemException {
80  
81          Map<Locale, String> localeNamesMap = new HashMap<Locale, String>();
82  
83          Locale defaultLocale = LocaleUtil.getDefault();
84  
85          localeNamesMap.put(defaultLocale, name);
86  
87          return addLayout(
88              groupId, privateLayout, parentLayoutId, localeNamesMap,
89              new HashMap<Locale, String>(), description, type, hidden,
90              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 byte[] exportLayouts(
113             long groupId, boolean privateLayout, long[] layoutIds,
114             Map<String, String[]> parameterMap, Date startDate, Date endDate)
115         throws PortalException, SystemException {
116 
117         GroupPermissionUtil.check(
118             getPermissionChecker(), groupId, ActionKeys.MANAGE_LAYOUTS);
119 
120         return layoutLocalService.exportLayouts(
121             groupId, privateLayout, layoutIds, parameterMap, startDate,
122             endDate);
123     }
124 
125     public byte[] exportLayouts(
126             long groupId, boolean privateLayout,
127             Map<String, String[]> parameterMap, Date startDate, Date endDate)
128         throws PortalException, SystemException {
129 
130         GroupPermissionUtil.check(
131             getPermissionChecker(), groupId, ActionKeys.MANAGE_LAYOUTS);
132 
133         return layoutLocalService.exportLayouts(
134             groupId, privateLayout, parameterMap, startDate, endDate);
135     }
136 
137     public File exportLayoutsAsFile(
138             long groupId, boolean privateLayout, long[] layoutIds,
139             Map<String, String[]> parameterMap, Date startDate, Date endDate)
140         throws PortalException, SystemException {
141 
142         GroupPermissionUtil.check(
143             getPermissionChecker(), groupId, ActionKeys.MANAGE_LAYOUTS);
144 
145         return layoutLocalService.exportLayoutsAsFile(
146             groupId, privateLayout, layoutIds, parameterMap, startDate,
147             endDate);
148     }
149 
150     public byte[] exportPortletInfo(
151             long plid, long groupId, String portletId,
152             Map<String, String[]> parameterMap, Date startDate, Date endDate)
153         throws PortalException, SystemException {
154 
155         Layout layout = layoutLocalService.getLayout(plid);
156 
157         GroupPermissionUtil.check(
158             getPermissionChecker(), layout.getGroupId(),
159             ActionKeys.MANAGE_LAYOUTS);
160 
161         return layoutLocalService.exportPortletInfo(
162             plid, groupId, portletId, parameterMap, startDate, endDate);
163     }
164 
165     public File exportPortletInfoAsFile(
166             long plid, long groupId, String portletId,
167             Map<String, String[]> parameterMap, Date startDate, Date endDate)
168         throws PortalException, SystemException {
169 
170         Layout layout = layoutLocalService.getLayout(plid);
171 
172         GroupPermissionUtil.check(
173             getPermissionChecker(), layout.getGroupId(),
174             ActionKeys.MANAGE_LAYOUTS);
175 
176         return layoutLocalService.exportPortletInfoAsFile(
177             plid, groupId, portletId, parameterMap, startDate, endDate);
178     }
179 
180     public String getLayoutName(
181             long groupId, boolean privateLayout, long layoutId,
182             String languageId)
183         throws PortalException, SystemException {
184 
185         Layout layout = layoutLocalService.getLayout(
186             groupId, privateLayout, layoutId);
187 
188         return layout.getName(languageId);
189     }
190 
191     public LayoutReference[] getLayoutReferences(
192             long companyId, String portletId, String preferencesKey,
193             String preferencesValue)
194         throws SystemException {
195 
196         return layoutLocalService.getLayouts(
197             companyId, portletId, preferencesKey, preferencesValue);
198     }
199 
200     public void importLayouts(
201             long groupId, boolean privateLayout,
202             Map<String, String[]> parameterMap, byte[] bytes)
203         throws PortalException, SystemException {
204 
205         GroupPermissionUtil.check(
206             getPermissionChecker(), groupId, ActionKeys.MANAGE_LAYOUTS);
207 
208         layoutLocalService.importLayouts(
209             getUserId(), groupId, privateLayout, parameterMap, bytes);
210     }
211 
212     public void importLayouts(
213             long groupId, boolean privateLayout,
214             Map<String, String[]> parameterMap, File file)
215         throws PortalException, SystemException {
216 
217         GroupPermissionUtil.check(
218             getPermissionChecker(), groupId, ActionKeys.MANAGE_LAYOUTS);
219 
220         layoutLocalService.importLayouts(
221             getUserId(), groupId, privateLayout, parameterMap, file);
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, long groupId, String portletId,
238             Map<String, String[]> parameterMap, 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, groupId, portletId, parameterMap, file);
249     }
250 
251     public void importPortletInfo(
252             long plid, long groupId, String portletId,
253             Map<String, String[]> parameterMap, 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, groupId, 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 = groupLocalService.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 = groupLocalService.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(
469             long groupId, boolean privateLayout, long layoutId, String name,
470             String languageId)
471         throws PortalException, SystemException {
472 
473         LayoutPermissionUtil.check(
474             getPermissionChecker(), groupId, privateLayout, layoutId,
475             ActionKeys.UPDATE);
476 
477         return layoutLocalService.updateName(
478             groupId, privateLayout, layoutId, name, languageId);
479     }
480 
481     public Layout updateName(long plid, String name, String languageId)
482         throws PortalException, SystemException {
483 
484         LayoutPermissionUtil.check(
485             getPermissionChecker(), plid, ActionKeys.UPDATE);
486 
487         return layoutLocalService.updateName(plid, name, languageId);
488     }
489 
490     public Layout updateParentLayoutId(
491             long groupId, boolean privateLayout, long layoutId,
492             long parentLayoutId)
493         throws PortalException, SystemException {
494 
495         LayoutPermissionUtil.check(
496             getPermissionChecker(), groupId, privateLayout, layoutId,
497             ActionKeys.UPDATE);
498 
499         return layoutLocalService.updateParentLayoutId(
500             groupId, privateLayout, layoutId, parentLayoutId);
501     }
502 
503     public Layout updateParentLayoutId(long plid, long parentPlid)
504         throws PortalException, SystemException {
505 
506         LayoutPermissionUtil.check(
507             getPermissionChecker(), plid, ActionKeys.UPDATE);
508 
509         return layoutLocalService.updateParentLayoutId(plid, parentPlid);
510     }
511 
512     public Layout updatePriority(
513             long groupId, boolean privateLayout, long layoutId, int priority)
514         throws PortalException, SystemException {
515 
516         LayoutPermissionUtil.check(
517             getPermissionChecker(), groupId, privateLayout, layoutId,
518             ActionKeys.UPDATE);
519 
520         return layoutLocalService.updatePriority(
521             groupId, privateLayout, layoutId, priority);
522     }
523 
524     public Layout updatePriority(long plid, int priority)
525         throws PortalException, SystemException {
526 
527         LayoutPermissionUtil.check(
528             getPermissionChecker(), plid, ActionKeys.UPDATE);
529 
530         return layoutLocalService.updatePriority(plid, priority);
531     }
532 
533 }