001    /**
002     * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
003     *
004     * The contents of this file are subject to the terms of the Liferay Enterprise
005     * Subscription License ("License"). You may not use this file except in
006     * compliance with the License. You can obtain a copy of the License by
007     * contacting Liferay, Inc. See the License for the specific language governing
008     * permissions and limitations under the License, including but not limited to
009     * distribution rights of the Software.
010     *
011     *
012     *
013     */
014    
015    package com.liferay.portal.service.impl;
016    
017    import com.liferay.portal.kernel.exception.PortalException;
018    import com.liferay.portal.kernel.exception.SystemException;
019    import com.liferay.portal.kernel.messaging.DestinationNames;
020    import com.liferay.portal.kernel.scheduler.CronTrigger;
021    import com.liferay.portal.kernel.scheduler.SchedulerEngineUtil;
022    import com.liferay.portal.kernel.scheduler.Trigger;
023    import com.liferay.portal.kernel.util.LocaleUtil;
024    import com.liferay.portal.kernel.util.StringPool;
025    import com.liferay.portal.kernel.uuid.PortalUUIDUtil;
026    import com.liferay.portal.model.Group;
027    import com.liferay.portal.model.Layout;
028    import com.liferay.portal.model.LayoutReference;
029    import com.liferay.portal.model.Plugin;
030    import com.liferay.portal.security.auth.PrincipalException;
031    import com.liferay.portal.security.permission.ActionKeys;
032    import com.liferay.portal.security.permission.PermissionChecker;
033    import com.liferay.portal.service.ServiceContext;
034    import com.liferay.portal.service.base.LayoutServiceBaseImpl;
035    import com.liferay.portal.service.permission.GroupPermissionUtil;
036    import com.liferay.portal.service.permission.LayoutPermissionUtil;
037    import com.liferay.portlet.communities.messaging.LayoutsLocalPublisherRequest;
038    import com.liferay.portlet.communities.messaging.LayoutsRemotePublisherRequest;
039    
040    import java.io.File;
041    import java.io.InputStream;
042    
043    import java.util.Date;
044    import java.util.HashMap;
045    import java.util.Locale;
046    import java.util.Map;
047    
048    /**
049     * @author Brian Wing Shun Chan
050     * @author Wesley Gong
051     */
052    public class LayoutServiceImpl extends LayoutServiceBaseImpl {
053    
054            public Layout addLayout(
055                            long groupId, boolean privateLayout, long parentLayoutId,
056                            Map<Locale, String> localeNamesMap,
057                            Map<Locale, String> localeTitlesMap, String description,
058                            String type, boolean hidden, String friendlyURL,
059                            ServiceContext serviceContext)
060                    throws PortalException, SystemException {
061    
062                    GroupPermissionUtil.check(
063                            getPermissionChecker(), groupId, ActionKeys.MANAGE_LAYOUTS);
064    
065                    return layoutLocalService.addLayout(
066                            getUserId(), groupId, privateLayout, parentLayoutId, localeNamesMap,
067                            localeTitlesMap, description, type, hidden, friendlyURL,
068                            serviceContext);
069            }
070    
071            public Layout addLayout(
072                            long groupId, boolean privateLayout, long parentLayoutId,
073                            String name, String title, String description, String type,
074                            boolean hidden, String friendlyURL, ServiceContext serviceContext)
075                    throws PortalException, SystemException {
076    
077                    Map<Locale, String> localeNamesMap = new HashMap<Locale, String>();
078    
079                    Locale defaultLocale = LocaleUtil.getDefault();
080    
081                    localeNamesMap.put(defaultLocale, name);
082    
083                    return addLayout(
084                            groupId, privateLayout, parentLayoutId, localeNamesMap,
085                            new HashMap<Locale, String>(), description, type, hidden,
086                            friendlyURL, serviceContext);
087            }
088    
089            public void deleteLayout(long plid)
090                    throws PortalException, SystemException {
091    
092                    LayoutPermissionUtil.check(
093                            getPermissionChecker(), plid, ActionKeys.DELETE);
094    
095                    layoutLocalService.deleteLayout(plid);
096            }
097    
098            public void deleteLayout(long groupId, boolean privateLayout, long layoutId)
099                    throws PortalException, SystemException {
100    
101                    LayoutPermissionUtil.check(
102                            getPermissionChecker(), groupId, privateLayout, layoutId,
103                            ActionKeys.DELETE);
104    
105                    layoutLocalService.deleteLayout(groupId, privateLayout, layoutId);
106            }
107    
108            public byte[] exportLayouts(
109                            long groupId, boolean privateLayout, long[] layoutIds,
110                            Map<String, String[]> parameterMap, Date startDate, Date endDate)
111                    throws PortalException, SystemException {
112    
113                    GroupPermissionUtil.check(
114                            getPermissionChecker(), groupId, ActionKeys.MANAGE_LAYOUTS);
115    
116                    return layoutLocalService.exportLayouts(
117                            groupId, privateLayout, layoutIds, parameterMap, startDate,
118                            endDate);
119            }
120    
121            public byte[] exportLayouts(
122                            long groupId, boolean privateLayout,
123                            Map<String, String[]> parameterMap, Date startDate, Date endDate)
124                    throws PortalException, SystemException {
125    
126                    GroupPermissionUtil.check(
127                            getPermissionChecker(), groupId, ActionKeys.MANAGE_LAYOUTS);
128    
129                    return layoutLocalService.exportLayouts(
130                            groupId, privateLayout, parameterMap, startDate, endDate);
131            }
132    
133            public File exportLayoutsAsFile(
134                            long groupId, boolean privateLayout, long[] layoutIds,
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.exportLayoutsAsFile(
142                            groupId, privateLayout, layoutIds, parameterMap, startDate,
143                            endDate);
144            }
145    
146            public byte[] exportPortletInfo(
147                            long plid, long groupId, String portletId,
148                            Map<String, String[]> parameterMap, Date startDate, Date endDate)
149                    throws PortalException, SystemException {
150    
151                    Layout layout = layoutLocalService.getLayout(plid);
152    
153                    GroupPermissionUtil.check(
154                            getPermissionChecker(), layout.getGroupId(),
155                            ActionKeys.MANAGE_LAYOUTS);
156    
157                    return layoutLocalService.exportPortletInfo(
158                            plid, groupId, portletId, parameterMap, startDate, endDate);
159            }
160    
161            public File exportPortletInfoAsFile(
162                            long plid, long groupId, String portletId,
163                            Map<String, String[]> parameterMap, Date startDate, Date endDate)
164                    throws PortalException, SystemException {
165    
166                    Layout layout = layoutLocalService.getLayout(plid);
167    
168                    GroupPermissionUtil.check(
169                            getPermissionChecker(), layout.getGroupId(),
170                            ActionKeys.MANAGE_LAYOUTS);
171    
172                    return layoutLocalService.exportPortletInfoAsFile(
173                            plid, groupId, portletId, parameterMap, startDate, endDate);
174            }
175    
176            public String getLayoutName(
177                            long groupId, boolean privateLayout, long layoutId,
178                            String languageId)
179                    throws PortalException, SystemException {
180    
181                    Layout layout = layoutLocalService.getLayout(
182                            groupId, privateLayout, layoutId);
183    
184                    return layout.getName(languageId);
185            }
186    
187            public LayoutReference[] getLayoutReferences(
188                            long companyId, String portletId, String preferencesKey,
189                            String preferencesValue)
190                    throws SystemException {
191    
192                    return layoutLocalService.getLayouts(
193                            companyId, portletId, preferencesKey, preferencesValue);
194            }
195    
196            public void importLayouts(
197                            long groupId, boolean privateLayout,
198                            Map<String, String[]> parameterMap, byte[] bytes)
199                    throws PortalException, SystemException {
200    
201                    GroupPermissionUtil.check(
202                            getPermissionChecker(), groupId, ActionKeys.MANAGE_LAYOUTS);
203    
204                    layoutLocalService.importLayouts(
205                            getUserId(), groupId, privateLayout, parameterMap, bytes);
206            }
207    
208            public void importLayouts(
209                            long groupId, boolean privateLayout,
210                            Map<String, String[]> parameterMap, File file)
211                    throws PortalException, SystemException {
212    
213                    PermissionChecker permissionChecker = getPermissionChecker();
214    
215                    if (!GroupPermissionUtil.contains(
216                                    permissionChecker, groupId, ActionKeys.MANAGE_LAYOUTS) &&
217                            !GroupPermissionUtil.contains(
218                                    permissionChecker, groupId, ActionKeys.PUBLISH_STAGING)) {
219    
220                            throw new PrincipalException();
221                    }
222    
223                    layoutLocalService.importLayouts(
224                            getUserId(), groupId, privateLayout, parameterMap, file);
225            }
226    
227            public void importLayouts(
228                            long groupId, boolean privateLayout,
229                            Map<String, String[]> parameterMap, InputStream is)
230                    throws PortalException, SystemException {
231    
232                    GroupPermissionUtil.check(
233                            getPermissionChecker(), groupId, ActionKeys.MANAGE_LAYOUTS);
234    
235                    layoutLocalService.importLayouts(
236                            getUserId(), groupId, privateLayout, parameterMap, is);
237            }
238    
239            public void importPortletInfo(
240                            long plid, long groupId, String portletId,
241                            Map<String, String[]> parameterMap, File file)
242                    throws PortalException, SystemException {
243    
244                    Layout layout = layoutLocalService.getLayout(plid);
245    
246                    GroupPermissionUtil.check(
247                            getPermissionChecker(), layout.getGroupId(),
248                            ActionKeys.MANAGE_LAYOUTS);
249    
250                    layoutLocalService.importPortletInfo(
251                            getUserId(), plid, groupId, portletId, parameterMap, file);
252            }
253    
254            public void importPortletInfo(
255                            long plid, long groupId, String portletId,
256                            Map<String, String[]> parameterMap, InputStream is)
257                    throws PortalException, SystemException {
258    
259                    Layout layout = layoutLocalService.getLayout(plid);
260    
261                    GroupPermissionUtil.check(
262                            getPermissionChecker(), layout.getGroupId(),
263                            ActionKeys.MANAGE_LAYOUTS);
264    
265                    layoutLocalService.importPortletInfo(
266                            getUserId(), plid, groupId, portletId, parameterMap, is);
267            }
268    
269            public void schedulePublishToLive(
270                            long sourceGroupId, long targetGroupId, boolean privateLayout,
271                            Map<Long, Boolean> layoutIdMap, Map<String, String[]> parameterMap,
272                            String scope, Date startDate, Date endDate, String groupName,
273                            String cronText, Date schedulerStartDate, Date schedulerEndDate,
274                            String description)
275                    throws PortalException, SystemException {
276    
277                    PermissionChecker permissionChecker = getPermissionChecker();
278    
279                    if (!GroupPermissionUtil.contains(
280                                    permissionChecker, targetGroupId, ActionKeys.MANAGE_STAGING) &&
281                            !GroupPermissionUtil.contains(
282                                    permissionChecker, targetGroupId, ActionKeys.PUBLISH_STAGING)) {
283    
284                            throw new PrincipalException();
285                    }
286    
287                    String jobName = PortalUUIDUtil.generate();
288    
289                    Trigger trigger = new CronTrigger(
290                            jobName, groupName, schedulerStartDate, schedulerEndDate,
291                            cronText);
292    
293                    String command = StringPool.BLANK;
294    
295                    if (scope.equals("all-pages")) {
296                            command = LayoutsLocalPublisherRequest.COMMAND_ALL_PAGES;
297                    }
298                    else if (scope.equals("selected-pages")) {
299                            command = LayoutsLocalPublisherRequest.COMMAND_SELECTED_PAGES;
300                    }
301    
302                    LayoutsLocalPublisherRequest publisherRequest =
303                            new LayoutsLocalPublisherRequest(
304                                    command, getUserId(), sourceGroupId, targetGroupId,
305                                    privateLayout, layoutIdMap, parameterMap, startDate, endDate);
306    
307                    SchedulerEngineUtil.schedule(
308                            trigger, description, DestinationNames.LAYOUTS_LOCAL_PUBLISHER,
309                            publisherRequest);
310            }
311    
312            public void schedulePublishToRemote(
313                            long sourceGroupId, boolean privateLayout,
314                            Map<Long, Boolean> layoutIdMap,
315                            Map<String, String[]> parameterMap, String remoteAddress,
316                            int remotePort, boolean secureConnection, long remoteGroupId,
317                            boolean remotePrivateLayout, Date startDate, Date endDate,
318                            String groupName, String cronText, Date schedulerStartDate,
319                            Date schedulerEndDate, String description)
320                    throws PortalException, SystemException {
321    
322                    PermissionChecker permissionChecker = getPermissionChecker();
323    
324                    Group group = groupLocalService.getGroup(sourceGroupId);
325    
326                    if (group.isStagingGroup()) {
327                            group = group.getLiveGroup();
328                    }
329    
330                    if (group.isWorkflowEnabled() &&
331                            !GroupPermissionUtil.contains(
332                                    permissionChecker, sourceGroupId, ActionKeys.MANAGE_STAGING) &&
333                            !GroupPermissionUtil.contains(
334                                    permissionChecker, sourceGroupId, ActionKeys.PUBLISH_STAGING)) {
335    
336                            throw new PrincipalException();
337                    }
338                    else {
339                            GroupPermissionUtil.check(
340                                    permissionChecker, sourceGroupId, ActionKeys.PUBLISH_TO_REMOTE);
341                    }
342    
343                    LayoutsRemotePublisherRequest publisherRequest =
344                            new LayoutsRemotePublisherRequest(
345                                    getUserId(), sourceGroupId, privateLayout, layoutIdMap,
346                                    parameterMap, remoteAddress, remotePort, secureConnection,
347                                    remoteGroupId, remotePrivateLayout, startDate, endDate);
348    
349                    String jobName = PortalUUIDUtil.generate();
350    
351                    Trigger trigger =
352                            new CronTrigger(
353                                    jobName, groupName, schedulerStartDate, schedulerEndDate,
354                                    cronText);
355                    SchedulerEngineUtil.schedule(
356                            trigger, description, DestinationNames.LAYOUTS_REMOTE_PUBLISHER,
357                            publisherRequest);
358            }
359    
360            public void setLayouts(
361                            long groupId, boolean privateLayout, long parentLayoutId,
362                            long[] layoutIds)
363                    throws PortalException, SystemException {
364    
365                    GroupPermissionUtil.check(
366                            getPermissionChecker(), groupId, ActionKeys.MANAGE_LAYOUTS);
367    
368                    layoutLocalService.setLayouts(
369                            groupId, privateLayout, parentLayoutId, layoutIds);
370            }
371    
372            public void unschedulePublishToLive(
373                            long groupId, String jobName, String groupName)
374                    throws PortalException, SystemException {
375    
376                    PermissionChecker permissionChecker = getPermissionChecker();
377    
378                    if (!GroupPermissionUtil.contains(
379                                    permissionChecker, groupId, ActionKeys.MANAGE_STAGING) &&
380                            !GroupPermissionUtil.contains(
381                                    permissionChecker, groupId, ActionKeys.PUBLISH_STAGING)) {
382    
383                            throw new PrincipalException();
384                    }
385    
386                    SchedulerEngineUtil.unschedule(
387                            new CronTrigger(jobName, groupName, null));
388            }
389    
390            public void unschedulePublishToRemote(
391                            long groupId, String jobName, String groupName)
392                    throws PortalException, SystemException {
393    
394                    PermissionChecker permissionChecker = getPermissionChecker();
395    
396                    Group group = groupLocalService.getGroup(groupId);
397    
398                    if (group.isStagingGroup()) {
399                            group = group.getLiveGroup();
400                    }
401    
402                    if (group.isWorkflowEnabled() &&
403                            !GroupPermissionUtil.contains(
404                                    permissionChecker, groupId, ActionKeys.MANAGE_STAGING) &&
405                            !GroupPermissionUtil.contains(
406                                    permissionChecker, groupId, ActionKeys.PUBLISH_STAGING)) {
407    
408                            throw new PrincipalException();
409                    }
410                    else {
411                            GroupPermissionUtil.check(
412                                    permissionChecker, groupId, ActionKeys.MANAGE_LAYOUTS);
413                    }
414    
415                    SchedulerEngineUtil.unschedule(
416                            new CronTrigger(jobName, groupName, null));
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, ServiceContext serviceContext)
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, serviceContext);
435            }
436    
437            public Layout updateLayout(
438                            long groupId, boolean privateLayout, long layoutId,
439                            long parentLayoutId, Map<Locale, String> localeNamesMap,
440                            Map<Locale, String> localeTitlesMap, String description,
441                            String type, boolean hidden, String friendlyURL,
442                            ServiceContext serviceContext)
443                    throws PortalException, SystemException {
444    
445                    LayoutPermissionUtil.check(
446                            getPermissionChecker(), groupId, privateLayout, layoutId,
447                            ActionKeys.UPDATE);
448    
449                    return layoutLocalService.updateLayout(
450                            groupId, privateLayout, layoutId, parentLayoutId, localeNamesMap,
451                            localeTitlesMap, description, type, hidden, friendlyURL,
452                            serviceContext);
453            }
454    
455            public Layout updateLayout(
456                            long groupId, boolean privateLayout, long layoutId,
457                            String typeSettings)
458                    throws PortalException, SystemException {
459    
460                    LayoutPermissionUtil.check(
461                            getPermissionChecker(), groupId, privateLayout, layoutId,
462                            ActionKeys.UPDATE);
463    
464                    return layoutLocalService.updateLayout(
465                            groupId, privateLayout, layoutId, typeSettings);
466            }
467    
468            public Layout updateLookAndFeel(
469                            long groupId, boolean privateLayout, long layoutId, String themeId,
470                            String colorSchemeId, String css, boolean wapTheme)
471                    throws PortalException, SystemException {
472    
473                    LayoutPermissionUtil.check(
474                            getPermissionChecker(), groupId, privateLayout, layoutId,
475                            ActionKeys.UPDATE);
476    
477                    pluginSettingLocalService.checkPermission(
478                            getUserId(), themeId, Plugin.TYPE_THEME);
479    
480                    return layoutLocalService.updateLookAndFeel(
481                            groupId, privateLayout, layoutId, themeId, colorSchemeId, css,
482                            wapTheme);
483            }
484    
485            public Layout updateName(
486                            long groupId, boolean privateLayout, long layoutId, String name,
487                            String languageId)
488                    throws PortalException, SystemException {
489    
490                    LayoutPermissionUtil.check(
491                            getPermissionChecker(), groupId, privateLayout, layoutId,
492                            ActionKeys.UPDATE);
493    
494                    return layoutLocalService.updateName(
495                            groupId, privateLayout, layoutId, name, languageId);
496            }
497    
498            public Layout updateName(long plid, String name, String languageId)
499                    throws PortalException, SystemException {
500    
501                    LayoutPermissionUtil.check(
502                            getPermissionChecker(), plid, ActionKeys.UPDATE);
503    
504                    return layoutLocalService.updateName(plid, name, languageId);
505            }
506    
507            public Layout updateParentLayoutId(
508                            long groupId, boolean privateLayout, long layoutId,
509                            long parentLayoutId)
510                    throws PortalException, SystemException {
511    
512                    LayoutPermissionUtil.check(
513                            getPermissionChecker(), groupId, privateLayout, layoutId,
514                            ActionKeys.UPDATE);
515    
516                    return layoutLocalService.updateParentLayoutId(
517                            groupId, privateLayout, layoutId, parentLayoutId);
518            }
519    
520            public Layout updateParentLayoutId(long plid, long parentPlid)
521                    throws PortalException, SystemException {
522    
523                    LayoutPermissionUtil.check(
524                            getPermissionChecker(), plid, ActionKeys.UPDATE);
525    
526                    return layoutLocalService.updateParentLayoutId(plid, parentPlid);
527            }
528    
529            public Layout updatePriority(
530                            long groupId, boolean privateLayout, long layoutId, int priority)
531                    throws PortalException, SystemException {
532    
533                    LayoutPermissionUtil.check(
534                            getPermissionChecker(), groupId, privateLayout, layoutId,
535                            ActionKeys.UPDATE);
536    
537                    return layoutLocalService.updatePriority(
538                            groupId, privateLayout, layoutId, priority);
539            }
540    
541            public Layout updatePriority(long plid, int priority)
542                    throws PortalException, SystemException {
543    
544                    LayoutPermissionUtil.check(
545                            getPermissionChecker(), plid, ActionKeys.UPDATE);
546    
547                    return layoutLocalService.updatePriority(plid, priority);
548            }
549    
550    }