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