001    /**
002     * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.service.impl;
016    
017    import com.liferay.counter.service.CounterLocalServiceUtil;
018    import com.liferay.portal.kernel.bean.BeanReference;
019    import com.liferay.portal.kernel.exception.PortalException;
020    import com.liferay.portal.kernel.exception.SystemException;
021    import com.liferay.portal.kernel.log.Log;
022    import com.liferay.portal.kernel.log.LogFactoryUtil;
023    import com.liferay.portal.kernel.staging.LayoutStagingUtil;
024    import com.liferay.portal.kernel.staging.MergeLayoutPrototypesThreadLocal;
025    import com.liferay.portal.kernel.staging.StagingUtil;
026    import com.liferay.portal.kernel.systemevent.SystemEventHierarchyEntry;
027    import com.liferay.portal.kernel.systemevent.SystemEventHierarchyEntryThreadLocal;
028    import com.liferay.portal.kernel.util.ArrayUtil;
029    import com.liferay.portal.kernel.util.GetterUtil;
030    import com.liferay.portal.kernel.util.LocaleUtil;
031    import com.liferay.portal.kernel.util.ParamUtil;
032    import com.liferay.portal.kernel.util.ProxyUtil;
033    import com.liferay.portal.kernel.util.StringPool;
034    import com.liferay.portal.kernel.workflow.WorkflowConstants;
035    import com.liferay.portal.model.Layout;
036    import com.liferay.portal.model.LayoutRevision;
037    import com.liferay.portal.model.LayoutSet;
038    import com.liferay.portal.model.LayoutStagingHandler;
039    import com.liferay.portal.model.SystemEventConstants;
040    import com.liferay.portal.model.User;
041    import com.liferay.portal.security.auth.PrincipalThreadLocal;
042    import com.liferay.portal.service.ImageLocalServiceUtil;
043    import com.liferay.portal.service.LayoutFriendlyURLLocalServiceUtil;
044    import com.liferay.portal.service.LayoutLocalService;
045    import com.liferay.portal.service.LayoutRevisionLocalServiceUtil;
046    import com.liferay.portal.service.ServiceContext;
047    import com.liferay.portal.service.ServiceContextThreadLocal;
048    import com.liferay.portal.service.SystemEventLocalServiceUtil;
049    import com.liferay.portal.service.UserLocalServiceUtil;
050    import com.liferay.portal.service.persistence.LayoutRevisionUtil;
051    import com.liferay.portal.service.persistence.LayoutUtil;
052    import com.liferay.portal.staging.ProxiedLayoutsThreadLocal;
053    import com.liferay.portal.staging.StagingAdvicesThreadLocal;
054    import com.liferay.portal.util.ClassLoaderUtil;
055    
056    import java.lang.reflect.InvocationTargetException;
057    import java.lang.reflect.Method;
058    
059    import java.util.ArrayList;
060    import java.util.Arrays;
061    import java.util.HashMap;
062    import java.util.HashSet;
063    import java.util.List;
064    import java.util.Locale;
065    import java.util.Map;
066    import java.util.Set;
067    
068    import org.aopalliance.intercept.MethodInterceptor;
069    import org.aopalliance.intercept.MethodInvocation;
070    
071    import org.springframework.core.annotation.Order;
072    
073    /**
074     * @author Raymond Aug??
075     * @author Brian Wing Shun Chan
076     */
077    @Order(1)
078    public class LayoutLocalServiceStagingAdvice implements MethodInterceptor {
079    
080            public LayoutLocalServiceStagingAdvice() {
081                    if (_log.isDebugEnabled()) {
082                            _log.debug("Instantiating " + hashCode());
083                    }
084            }
085    
086            public void deleteLayout(
087                            LayoutLocalService layoutLocalService, Layout layout,
088                            boolean updateLayoutSet, ServiceContext serviceContext)
089                    throws PortalException, SystemException {
090    
091                    long layoutSetBranchId = ParamUtil.getLong(
092                            serviceContext, "layoutSetBranchId");
093    
094                    if (layoutSetBranchId > 0) {
095                            LayoutRevisionLocalServiceUtil.deleteLayoutRevisions(
096                                    layoutSetBranchId, layout.getPlid());
097    
098                            List<LayoutRevision> notIncompleteLayoutRevisions =
099                                    LayoutRevisionUtil.findByP_NotS(
100                                            layout.getPlid(), WorkflowConstants.STATUS_INCOMPLETE);
101    
102                            if (notIncompleteLayoutRevisions.isEmpty()) {
103                                    LayoutRevisionLocalServiceUtil.deleteLayoutLayoutRevisions(
104                                            layout.getPlid());
105    
106                                    doDeleteLayout(
107                                            layoutLocalService, layout, updateLayoutSet,
108                                            serviceContext);
109                            }
110                    }
111                    else {
112                            doDeleteLayout(
113                                    layoutLocalService, layout, updateLayoutSet, serviceContext);
114                    }
115            }
116    
117            public void deleteLayout(
118                            LayoutLocalService layoutLocalService, long groupId,
119                            boolean privateLayout, long layoutId, ServiceContext serviceContext)
120                    throws PortalException, SystemException {
121    
122                    Layout layout = layoutLocalService.getLayout(
123                            groupId, privateLayout, layoutId);
124    
125                    deleteLayout(layoutLocalService, layout, true, serviceContext);
126            }
127    
128            @Override
129            public Object invoke(MethodInvocation methodInvocation) throws Throwable {
130                    if (!StagingAdvicesThreadLocal.isEnabled()) {
131                            return methodInvocation.proceed();
132                    }
133    
134                    Method method = methodInvocation.getMethod();
135    
136                    String methodName = method.getName();
137    
138                    boolean showIncomplete = false;
139    
140                    if (!_layoutLocalServiceStagingAdviceMethodNames.contains(methodName)) {
141                            return wrapReturnValue(methodInvocation.proceed(), showIncomplete);
142                    }
143    
144                    Object returnValue = null;
145    
146                    Class<?>[] parameterTypes = method.getParameterTypes();
147    
148                    Object thisObject = methodInvocation.getThis();
149                    Object[] arguments = methodInvocation.getArguments();
150    
151                    if (methodName.equals("createLayout")) {
152                            return methodInvocation.proceed();
153                    }
154                    else if (methodName.equals("deleteLayout")) {
155                            if (arguments.length == 3) {
156                                    deleteLayout(
157                                            (LayoutLocalService)thisObject, (Layout)arguments[0],
158                                            (Boolean)arguments[1], (ServiceContext)arguments[2]);
159                            }
160                            else if (arguments.length == 4) {
161                                    deleteLayout(
162                                            (LayoutLocalService)thisObject, (Long)arguments[0],
163                                            (Boolean)arguments[1], (Long)arguments[2],
164                                            (ServiceContext)arguments[3]);
165                            }
166                            else {
167                                    return wrapReturnValue(
168                                            methodInvocation.proceed(), showIncomplete);
169                            }
170                    }
171                    else if (methodName.equals("getLayouts")) {
172                            if (arguments.length == 6) {
173                                    showIncomplete = (Boolean)arguments[3];
174                            }
175                            else if (Arrays.equals(parameterTypes, _GET_LAYOUTS_TYPES)) {
176                                    showIncomplete = true;
177                            }
178    
179                            return wrapReturnValue(methodInvocation.proceed(), showIncomplete);
180                    }
181                    else if (methodName.equals("updateLayout") &&
182                                     (arguments.length == 15)) {
183    
184                            Map<Locale, String> friendlyURLMap = null;
185    
186                            if (Arrays.equals(parameterTypes, _UPDATE_LAYOUT_PARAMETER_TYPES)) {
187                                    friendlyURLMap = new HashMap<Locale, String>();
188    
189                                    friendlyURLMap.put(
190                                            LocaleUtil.getSiteDefault(), (String)arguments[11]);
191                            }
192                            else {
193                                    friendlyURLMap = (Map<Locale, String>)arguments[11];
194                            }
195    
196                            returnValue = updateLayout(
197                                    (LayoutLocalService)thisObject, (Long)arguments[0],
198                                    (Boolean)arguments[1], (Long)arguments[2], (Long)arguments[3],
199                                    (Map<Locale, String>)arguments[4],
200                                    (Map<Locale, String>)arguments[5],
201                                    (Map<Locale, String>)arguments[6],
202                                    (Map<Locale, String>)arguments[7],
203                                    (Map<Locale, String>)arguments[8], (String)arguments[9],
204                                    (Boolean)arguments[10], friendlyURLMap, (Boolean)arguments[12],
205                                    (byte[])arguments[13], (ServiceContext)arguments[14]);
206                    }
207                    else {
208                            try {
209                                    Class<?> clazz = getClass();
210    
211                                    parameterTypes = ArrayUtil.append(
212                                            new Class<?>[] {LayoutLocalService.class}, parameterTypes);
213    
214                                    Method layoutLocalServiceStagingAdviceMethod = clazz.getMethod(
215                                            methodName, parameterTypes);
216    
217                                    arguments = ArrayUtil.append(
218                                            new Object[] {thisObject}, arguments);
219    
220                                    returnValue = layoutLocalServiceStagingAdviceMethod.invoke(
221                                            this, arguments);
222                            }
223                            catch (InvocationTargetException ite) {
224                                    throw ite.getTargetException();
225                            }
226                            catch (NoSuchMethodException nsme) {
227                                    returnValue = methodInvocation.proceed();
228                            }
229                    }
230    
231                    returnValue = wrapReturnValue(returnValue, showIncomplete);
232    
233                    return returnValue;
234            }
235    
236            public Layout updateLayout(
237                            LayoutLocalService layoutLocalService, long groupId,
238                            boolean privateLayout, long layoutId, long parentLayoutId,
239                            Map<Locale, String> nameMap, Map<Locale, String> titleMap,
240                            Map<Locale, String> descriptionMap, Map<Locale, String> keywordsMap,
241                            Map<Locale, String> robotsMap, String type, boolean hidden,
242                            Map<Locale, String> friendlyURLMap, Boolean iconImage,
243                            byte[] iconBytes, ServiceContext serviceContext)
244                    throws PortalException, SystemException {
245    
246                    // Layout
247    
248                    parentLayoutId = layoutLocalServiceHelper.getParentLayoutId(
249                            groupId, privateLayout, parentLayoutId);
250                    String name = nameMap.get(LocaleUtil.getSiteDefault());
251                    friendlyURLMap = layoutLocalServiceHelper.getFriendlyURLMap(
252                            groupId, privateLayout, layoutId, StringPool.BLANK, friendlyURLMap);
253                    String friendlyURL = friendlyURLMap.get(LocaleUtil.getSiteDefault());
254    
255                    layoutLocalServiceHelper.validate(
256                            groupId, privateLayout, layoutId, parentLayoutId, name, type,
257                            hidden, friendlyURLMap);
258    
259                    layoutLocalServiceHelper.validateParentLayoutId(
260                            groupId, privateLayout, layoutId, parentLayoutId);
261    
262                    Layout originalLayout = LayoutUtil.findByG_P_L(
263                            groupId, privateLayout, layoutId);
264    
265                    Layout layout = wrapLayout(originalLayout);
266    
267                    LayoutRevision layoutRevision = LayoutStagingUtil.getLayoutRevision(
268                            layout);
269    
270                    if (layoutRevision == null) {
271                            return layoutLocalService.updateLayout(
272                                    groupId, privateLayout, layoutId, parentLayoutId, nameMap,
273                                    titleMap, descriptionMap, keywordsMap, robotsMap, type, hidden,
274                                    friendlyURLMap, iconImage, iconBytes, serviceContext);
275                    }
276    
277                    if (parentLayoutId != originalLayout.getParentLayoutId()) {
278                            int priority = layoutLocalServiceHelper.getNextPriority(
279                                    groupId, privateLayout, parentLayoutId,
280                                    originalLayout.getSourcePrototypeLayoutUuid(), -1);
281    
282                            originalLayout.setPriority(priority);
283                    }
284    
285                    originalLayout.setParentLayoutId(parentLayoutId);
286                    layoutRevision.setNameMap(nameMap);
287                    layoutRevision.setTitleMap(titleMap);
288                    layoutRevision.setDescriptionMap(descriptionMap);
289                    layoutRevision.setKeywordsMap(keywordsMap);
290                    layoutRevision.setRobotsMap(robotsMap);
291                    originalLayout.setType(type);
292                    originalLayout.setHidden(hidden);
293                    originalLayout.setFriendlyURL(friendlyURL);
294    
295                    if (iconImage != null) {
296                            layoutRevision.setIconImage(iconImage.booleanValue());
297    
298                            if (iconImage.booleanValue()) {
299                                    long iconImageId = layoutRevision.getIconImageId();
300    
301                                    if (iconImageId <= 0) {
302                                            iconImageId = CounterLocalServiceUtil.increment();
303    
304                                            layoutRevision.setIconImageId(iconImageId);
305                                    }
306                            }
307                    }
308    
309                    boolean layoutPrototypeLinkEnabled = ParamUtil.getBoolean(
310                            serviceContext, "layoutPrototypeLinkEnabled");
311    
312                    originalLayout.setLayoutPrototypeLinkEnabled(
313                            layoutPrototypeLinkEnabled);
314    
315                    originalLayout.setExpandoBridgeAttributes(serviceContext);
316    
317                    LayoutUtil.update(originalLayout);
318    
319                    LayoutFriendlyURLLocalServiceUtil.updateLayoutFriendlyURLs(
320                            originalLayout.getUserId(), originalLayout.getCompanyId(),
321                            originalLayout.getGroupId(), originalLayout.getPlid(),
322                            originalLayout.isPrivateLayout(), friendlyURLMap, serviceContext);
323    
324                    boolean hasWorkflowTask = StagingUtil.hasWorkflowTask(
325                            serviceContext.getUserId(), layoutRevision);
326    
327                    serviceContext.setAttribute("revisionInProgress", hasWorkflowTask);
328    
329                    serviceContext.setWorkflowAction(WorkflowConstants.ACTION_SAVE_DRAFT);
330    
331                    LayoutRevisionLocalServiceUtil.updateLayoutRevision(
332                            serviceContext.getUserId(), layoutRevision.getLayoutRevisionId(),
333                            layoutRevision.getLayoutBranchId(), layoutRevision.getName(),
334                            layoutRevision.getTitle(), layoutRevision.getDescription(),
335                            layoutRevision.getKeywords(), layoutRevision.getRobots(),
336                            layoutRevision.getTypeSettings(), layoutRevision.getIconImage(),
337                            layoutRevision.getIconImageId(), layoutRevision.getThemeId(),
338                            layoutRevision.getColorSchemeId(), layoutRevision.getWapThemeId(),
339                            layoutRevision.getWapColorSchemeId(), layoutRevision.getCss(),
340                            serviceContext);
341    
342                    // Icon
343    
344                    if (iconImage != null) {
345                            if (ArrayUtil.isNotEmpty(iconBytes)) {
346                                    ImageLocalServiceUtil.updateImage(
347                                            layoutRevision.getIconImageId(), iconBytes);
348                            }
349                    }
350    
351                    return layout;
352            }
353    
354            public Layout updateLayout(
355                            LayoutLocalService layoutLocalService, long groupId,
356                            boolean privateLayout, long layoutId, String typeSettings)
357                    throws PortalException, SystemException {
358    
359                    Layout layout = LayoutUtil.findByG_P_L(
360                            groupId, privateLayout, layoutId);
361    
362                    layout = wrapLayout(layout);
363    
364                    LayoutRevision layoutRevision = LayoutStagingUtil.getLayoutRevision(
365                            layout);
366    
367                    if (layoutRevision == null) {
368                            return layoutLocalService.updateLayout(
369                                    groupId, privateLayout, layoutId, typeSettings);
370                    }
371    
372                    layout.setTypeSettings(typeSettings);
373    
374                    ServiceContext serviceContext =
375                            ServiceContextThreadLocal.getServiceContext();
376    
377                    boolean hasWorkflowTask = StagingUtil.hasWorkflowTask(
378                            serviceContext.getUserId(), layoutRevision);
379    
380                    serviceContext.setAttribute("revisionInProgress", hasWorkflowTask);
381    
382                    if (!MergeLayoutPrototypesThreadLocal.isInProgress()) {
383                            serviceContext.setWorkflowAction(
384                                    WorkflowConstants.ACTION_SAVE_DRAFT);
385                    }
386    
387                    LayoutRevisionLocalServiceUtil.updateLayoutRevision(
388                            serviceContext.getUserId(), layoutRevision.getLayoutRevisionId(),
389                            layoutRevision.getLayoutBranchId(), layoutRevision.getName(),
390                            layoutRevision.getTitle(), layoutRevision.getDescription(),
391                            layoutRevision.getKeywords(), layoutRevision.getRobots(),
392                            layoutRevision.getTypeSettings(), layoutRevision.getIconImage(),
393                            layoutRevision.getIconImageId(), layoutRevision.getThemeId(),
394                            layoutRevision.getColorSchemeId(), layoutRevision.getWapThemeId(),
395                            layoutRevision.getWapColorSchemeId(), layoutRevision.getCss(),
396                            serviceContext);
397    
398                    return layout;
399            }
400    
401            public Layout updateLookAndFeel(
402                            LayoutLocalService layoutLocalService, long groupId,
403                            boolean privateLayout, long layoutId, String themeId,
404                            String colorSchemeId, String css, boolean wapTheme)
405                    throws PortalException, SystemException {
406    
407                    Layout layout = LayoutUtil.findByG_P_L(
408                            groupId, privateLayout, layoutId);
409    
410                    layout = wrapLayout(layout);
411    
412                    LayoutRevision layoutRevision = LayoutStagingUtil.getLayoutRevision(
413                            layout);
414    
415                    if (layoutRevision == null) {
416                            return layoutLocalService.updateLookAndFeel(
417                                    groupId, privateLayout, layoutId, themeId, colorSchemeId, css,
418                                    wapTheme);
419                    }
420    
421                    if (wapTheme) {
422                            layout.setWapThemeId(themeId);
423                            layout.setWapColorSchemeId(colorSchemeId);
424                    }
425                    else {
426                            layout.setThemeId(themeId);
427                            layout.setColorSchemeId(colorSchemeId);
428                            layout.setCss(css);
429                    }
430    
431                    ServiceContext serviceContext =
432                            ServiceContextThreadLocal.getServiceContext();
433    
434                    boolean hasWorkflowTask = StagingUtil.hasWorkflowTask(
435                            serviceContext.getUserId(), layoutRevision);
436    
437                    serviceContext.setAttribute("revisionInProgress", hasWorkflowTask);
438    
439                    if (!MergeLayoutPrototypesThreadLocal.isInProgress()) {
440                            serviceContext.setWorkflowAction(
441                                    WorkflowConstants.ACTION_SAVE_DRAFT);
442                    }
443    
444                    LayoutRevisionLocalServiceUtil.updateLayoutRevision(
445                            serviceContext.getUserId(), layoutRevision.getLayoutRevisionId(),
446                            layoutRevision.getLayoutBranchId(), layoutRevision.getName(),
447                            layoutRevision.getTitle(), layoutRevision.getDescription(),
448                            layoutRevision.getKeywords(), layoutRevision.getRobots(),
449                            layoutRevision.getTypeSettings(), layoutRevision.getIconImage(),
450                            layoutRevision.getIconImageId(), layoutRevision.getThemeId(),
451                            layoutRevision.getColorSchemeId(), layoutRevision.getWapThemeId(),
452                            layoutRevision.getWapColorSchemeId(), layoutRevision.getCss(),
453                            serviceContext);
454    
455                    return layout;
456            }
457    
458            public Layout updateName(
459                            LayoutLocalService layoutLocalService, Layout layout, String name,
460                            String languageId)
461                    throws PortalException, SystemException {
462    
463                    layout = wrapLayout(layout);
464    
465                    LayoutRevision layoutRevision = LayoutStagingUtil.getLayoutRevision(
466                            layout);
467    
468                    if (layoutRevision == null) {
469                            return layoutLocalService.updateName(layout, name, languageId);
470                    }
471    
472                    layoutLocalServiceHelper.validateName(name, languageId);
473    
474                    layout.setName(name, LocaleUtil.fromLanguageId(languageId));
475    
476                    ServiceContext serviceContext =
477                            ServiceContextThreadLocal.getServiceContext();
478    
479                    boolean hasWorkflowTask = StagingUtil.hasWorkflowTask(
480                            serviceContext.getUserId(), layoutRevision);
481    
482                    serviceContext.setAttribute("revisionInProgress", hasWorkflowTask);
483    
484                    serviceContext.setWorkflowAction(WorkflowConstants.ACTION_SAVE_DRAFT);
485    
486                    LayoutRevisionLocalServiceUtil.updateLayoutRevision(
487                            serviceContext.getUserId(), layoutRevision.getLayoutRevisionId(),
488                            layoutRevision.getLayoutBranchId(), layoutRevision.getName(),
489                            layoutRevision.getTitle(), layoutRevision.getDescription(),
490                            layoutRevision.getKeywords(), layoutRevision.getRobots(),
491                            layoutRevision.getTypeSettings(), layoutRevision.getIconImage(),
492                            layoutRevision.getIconImageId(), layoutRevision.getThemeId(),
493                            layoutRevision.getColorSchemeId(), layoutRevision.getWapThemeId(),
494                            layoutRevision.getWapColorSchemeId(), layoutRevision.getCss(),
495                            serviceContext);
496    
497                    return layout;
498            }
499    
500            protected void doDeleteLayout(
501                            LayoutLocalService layoutLocalService, Layout layout,
502                            boolean updateLayoutSet, ServiceContext serviceContext)
503                    throws PortalException, SystemException {
504    
505                    if (SystemEventHierarchyEntryThreadLocal.push(
506                                    Layout.class, layout.getPlid()) == null) {
507    
508                            layoutLocalService.deleteLayout(
509                                    layout, updateLayoutSet, serviceContext);
510                    }
511                    else {
512                            try {
513                                    layoutLocalService.deleteLayout(
514                                            layout, updateLayoutSet, serviceContext);
515    
516                                    SystemEventHierarchyEntry systemEventHierarchyEntry =
517                                            SystemEventHierarchyEntryThreadLocal.peek();
518    
519                                    SystemEventLocalServiceUtil.addSystemEvent(
520                                            0, layout.getGroupId(), Layout.class.getName(),
521                                            layout.getPlid(), layout.getUuid(), null,
522                                            SystemEventConstants.TYPE_DELETE,
523                                            systemEventHierarchyEntry.getExtraData());
524                            }
525                            finally {
526                                    SystemEventHierarchyEntryThreadLocal.pop(
527                                            Layout.class, layout.getPlid());
528                            }
529                    }
530            }
531    
532            protected Layout getProxiedLayout(Layout layout) {
533                    Map<Layout, Object> proxiedLayouts =
534                            ProxiedLayoutsThreadLocal.getProxiedLayouts();
535    
536                    Object proxiedLayout = proxiedLayouts.get(layout);
537    
538                    if (proxiedLayout != null) {
539                            return (Layout)proxiedLayout;
540                    }
541    
542                    proxiedLayout = ProxyUtil.newProxyInstance(
543                            ClassLoaderUtil.getPortalClassLoader(), new Class[] {Layout.class},
544                            new LayoutStagingHandler(layout));
545    
546                    proxiedLayouts.put(layout, proxiedLayout);
547    
548                    return (Layout)proxiedLayout;
549            }
550    
551            protected Layout unwrapLayout(Layout layout) {
552                    LayoutStagingHandler layoutStagingHandler =
553                            LayoutStagingUtil.getLayoutStagingHandler(layout);
554    
555                    if (layoutStagingHandler == null) {
556                            return layout;
557                    }
558    
559                    return layoutStagingHandler.getLayout();
560            }
561    
562            protected Layout wrapLayout(Layout layout) {
563                    LayoutStagingHandler layoutStagingHandler =
564                            LayoutStagingUtil.getLayoutStagingHandler(layout);
565    
566                    if (layoutStagingHandler != null) {
567                            return layout;
568                    }
569    
570                    if (!LayoutStagingUtil.isBranchingLayout(layout)) {
571                            return layout;
572                    }
573    
574                    return getProxiedLayout(layout);
575            }
576    
577            protected List<Layout> wrapLayouts(
578                    List<Layout> layouts, boolean showIncomplete) {
579    
580                    if (layouts.isEmpty()) {
581                            return layouts;
582                    }
583    
584                    Layout firstLayout = layouts.get(0);
585    
586                    Layout wrappedFirstLayout = wrapLayout(firstLayout);
587    
588                    if (wrappedFirstLayout == firstLayout) {
589                            return layouts;
590                    }
591    
592                    long layoutSetBranchId = 0;
593    
594                    if (!showIncomplete) {
595                            long userId = 0;
596    
597                            try {
598                                    userId = GetterUtil.getLong(PrincipalThreadLocal.getName());
599    
600                                    if (userId > 0) {
601                                            User user = UserLocalServiceUtil.getUser(userId);
602    
603                                            LayoutSet layoutSet = firstLayout.getLayoutSet();
604    
605                                            layoutSetBranchId = StagingUtil.getRecentLayoutSetBranchId(
606                                                    user, layoutSet.getLayoutSetId());
607                                    }
608                            }
609                            catch (Exception e) {
610                                    if (_log.isDebugEnabled()) {
611                                            _log.debug("No layout set branch found for user " + userId);
612                                    }
613                            }
614                    }
615    
616                    List<Layout> wrappedLayouts = new ArrayList<Layout>(layouts.size());
617    
618                    for (int i = 0; i < layouts.size(); i++) {
619                            Layout wrappedLayout = wrapLayout(layouts.get(i));
620    
621                            if (showIncomplete ||
622                                    !StagingUtil.isIncomplete(wrappedLayout, layoutSetBranchId)) {
623    
624                                    wrappedLayouts.add(wrappedLayout);
625                            }
626                    }
627    
628                    return wrappedLayouts;
629            }
630    
631            protected Object wrapReturnValue(
632                    Object returnValue, boolean showIncomplete) {
633    
634                    if (returnValue instanceof Layout) {
635                            returnValue = wrapLayout((Layout)returnValue);
636                    }
637                    else if (returnValue instanceof List<?>) {
638                            List<?> list = (List<?>)returnValue;
639    
640                            if (!list.isEmpty()) {
641                                    Object object = list.get(0);
642    
643                                    if (object instanceof Layout) {
644                                            returnValue = wrapLayouts(
645                                                    (List<Layout>)returnValue, showIncomplete);
646                                    }
647                            }
648                    }
649    
650                    return returnValue;
651            }
652    
653            @BeanReference(type = LayoutLocalServiceHelper.class)
654            protected LayoutLocalServiceHelper layoutLocalServiceHelper;
655    
656            private static final Class<?>[] _GET_LAYOUTS_TYPES = {
657                    Long.TYPE, Boolean.TYPE, Long.TYPE
658            };
659    
660            private static final Class<?>[] _UPDATE_LAYOUT_PARAMETER_TYPES = {
661                    long.class, boolean.class, long.class, long.class, Map.class, Map.class,
662                    Map.class, Map.class, Map.class, String.class, boolean.class,
663                    String.class, Boolean.class, byte[].class, ServiceContext.class
664            };
665    
666            private static Log _log = LogFactoryUtil.getLog(
667                    LayoutLocalServiceStagingAdvice.class);
668    
669            private static Set<String> _layoutLocalServiceStagingAdviceMethodNames =
670                    new HashSet<String>();
671    
672            static {
673                    _layoutLocalServiceStagingAdviceMethodNames.add("createLayout");
674                    _layoutLocalServiceStagingAdviceMethodNames.add("deleteLayout");
675                    _layoutLocalServiceStagingAdviceMethodNames.add("getLayouts");
676                    _layoutLocalServiceStagingAdviceMethodNames.add("updateLayout");
677                    _layoutLocalServiceStagingAdviceMethodNames.add("updateLookAndFeel");
678                    _layoutLocalServiceStagingAdviceMethodNames.add("updateName");
679            }
680    
681    }