001    /**
002     * Copyright (c) 2000-2013 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;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    /**
020     * Provides a wrapper for {@link LayoutLocalService}.
021     *
022     * @author Brian Wing Shun Chan
023     * @see LayoutLocalService
024     * @generated
025     */
026    @ProviderType
027    public class LayoutLocalServiceWrapper implements LayoutLocalService,
028            ServiceWrapper<LayoutLocalService> {
029            public LayoutLocalServiceWrapper(LayoutLocalService layoutLocalService) {
030                    _layoutLocalService = layoutLocalService;
031            }
032    
033            /**
034            * Adds the layout to the database. Also notifies the appropriate model listeners.
035            *
036            * @param layout the layout
037            * @return the layout that was added
038            * @throws SystemException if a system exception occurred
039            */
040            @Override
041            public com.liferay.portal.model.Layout addLayout(
042                    com.liferay.portal.model.Layout layout)
043                    throws com.liferay.portal.kernel.exception.SystemException {
044                    return _layoutLocalService.addLayout(layout);
045            }
046    
047            /**
048            * Creates a new layout with the primary key. Does not add the layout to the database.
049            *
050            * @param plid the primary key for the new layout
051            * @return the new layout
052            */
053            @Override
054            public com.liferay.portal.model.Layout createLayout(long plid) {
055                    return _layoutLocalService.createLayout(plid);
056            }
057    
058            /**
059            * Deletes the layout with the primary key from the database. Also notifies the appropriate model listeners.
060            *
061            * @param plid the primary key of the layout
062            * @return the layout that was removed
063            * @throws PortalException if a layout with the primary key could not be found
064            * @throws SystemException if a system exception occurred
065            */
066            @Override
067            public com.liferay.portal.model.Layout deleteLayout(long plid)
068                    throws com.liferay.portal.kernel.exception.PortalException,
069                            com.liferay.portal.kernel.exception.SystemException {
070                    return _layoutLocalService.deleteLayout(plid);
071            }
072    
073            /**
074            * Deletes the layout from the database. Also notifies the appropriate model listeners.
075            *
076            * @param layout the layout
077            * @return the layout that was removed
078            * @throws SystemException if a system exception occurred
079            */
080            @Override
081            public com.liferay.portal.model.Layout deleteLayout(
082                    com.liferay.portal.model.Layout layout)
083                    throws com.liferay.portal.kernel.exception.SystemException {
084                    return _layoutLocalService.deleteLayout(layout);
085            }
086    
087            @Override
088            public com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery() {
089                    return _layoutLocalService.dynamicQuery();
090            }
091    
092            /**
093            * Performs a dynamic query on the database and returns the matching rows.
094            *
095            * @param dynamicQuery the dynamic query
096            * @return the matching rows
097            * @throws SystemException if a system exception occurred
098            */
099            @Override
100            @SuppressWarnings("rawtypes")
101            public java.util.List dynamicQuery(
102                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery)
103                    throws com.liferay.portal.kernel.exception.SystemException {
104                    return _layoutLocalService.dynamicQuery(dynamicQuery);
105            }
106    
107            /**
108            * Performs a dynamic query on the database and returns a range of the matching rows.
109            *
110            * <p>
111            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.LayoutModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
112            * </p>
113            *
114            * @param dynamicQuery the dynamic query
115            * @param start the lower bound of the range of model instances
116            * @param end the upper bound of the range of model instances (not inclusive)
117            * @return the range of matching rows
118            * @throws SystemException if a system exception occurred
119            */
120            @Override
121            @SuppressWarnings("rawtypes")
122            public java.util.List dynamicQuery(
123                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start,
124                    int end) throws com.liferay.portal.kernel.exception.SystemException {
125                    return _layoutLocalService.dynamicQuery(dynamicQuery, start, end);
126            }
127    
128            /**
129            * Performs a dynamic query on the database and returns an ordered range of the matching rows.
130            *
131            * <p>
132            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.LayoutModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
133            * </p>
134            *
135            * @param dynamicQuery the dynamic query
136            * @param start the lower bound of the range of model instances
137            * @param end the upper bound of the range of model instances (not inclusive)
138            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
139            * @return the ordered range of matching rows
140            * @throws SystemException if a system exception occurred
141            */
142            @Override
143            @SuppressWarnings("rawtypes")
144            public java.util.List dynamicQuery(
145                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start,
146                    int end,
147                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
148                    throws com.liferay.portal.kernel.exception.SystemException {
149                    return _layoutLocalService.dynamicQuery(dynamicQuery, start, end,
150                            orderByComparator);
151            }
152    
153            /**
154            * Returns the number of rows that match the dynamic query.
155            *
156            * @param dynamicQuery the dynamic query
157            * @return the number of rows that match the dynamic query
158            * @throws SystemException if a system exception occurred
159            */
160            @Override
161            public long dynamicQueryCount(
162                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery)
163                    throws com.liferay.portal.kernel.exception.SystemException {
164                    return _layoutLocalService.dynamicQueryCount(dynamicQuery);
165            }
166    
167            /**
168            * Returns the number of rows that match the dynamic query.
169            *
170            * @param dynamicQuery the dynamic query
171            * @param projection the projection to apply to the query
172            * @return the number of rows that match the dynamic query
173            * @throws SystemException if a system exception occurred
174            */
175            @Override
176            public long dynamicQueryCount(
177                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery,
178                    com.liferay.portal.kernel.dao.orm.Projection projection)
179                    throws com.liferay.portal.kernel.exception.SystemException {
180                    return _layoutLocalService.dynamicQueryCount(dynamicQuery, projection);
181            }
182    
183            @Override
184            public com.liferay.portal.model.Layout fetchLayout(long plid)
185                    throws com.liferay.portal.kernel.exception.SystemException {
186                    return _layoutLocalService.fetchLayout(plid);
187            }
188    
189            /**
190            * Returns the layout with the matching UUID and company.
191            *
192            * @param uuid the layout's UUID
193            * @param companyId the primary key of the company
194            * @return the matching layout, or <code>null</code> if a matching layout could not be found
195            * @throws SystemException if a system exception occurred
196            */
197            @Override
198            public com.liferay.portal.model.Layout fetchLayoutByUuidAndCompanyId(
199                    java.lang.String uuid, long companyId)
200                    throws com.liferay.portal.kernel.exception.SystemException {
201                    return _layoutLocalService.fetchLayoutByUuidAndCompanyId(uuid, companyId);
202            }
203    
204            /**
205            * Returns the layout matching the UUID, group, and privacy.
206            *
207            * @param uuid the layout's UUID
208            * @param groupId the primary key of the group
209            * @param privateLayout whether the layout is private to the group
210            * @return the matching layout, or <code>null</code> if a matching layout could not be found
211            * @throws SystemException if a system exception occurred
212            */
213            @Override
214            public com.liferay.portal.model.Layout fetchLayoutByUuidAndGroupId(
215                    java.lang.String uuid, long groupId, boolean privateLayout)
216                    throws com.liferay.portal.kernel.exception.SystemException {
217                    return _layoutLocalService.fetchLayoutByUuidAndGroupId(uuid, groupId,
218                            privateLayout);
219            }
220    
221            /**
222            * Returns the layout with the primary key.
223            *
224            * @param plid the primary key of the layout
225            * @return the layout
226            * @throws PortalException if a layout with the primary key could not be found
227            * @throws SystemException if a system exception occurred
228            */
229            @Override
230            public com.liferay.portal.model.Layout getLayout(long plid)
231                    throws com.liferay.portal.kernel.exception.PortalException,
232                            com.liferay.portal.kernel.exception.SystemException {
233                    return _layoutLocalService.getLayout(plid);
234            }
235    
236            @Override
237            public com.liferay.portal.model.PersistedModel getPersistedModel(
238                    java.io.Serializable primaryKeyObj)
239                    throws com.liferay.portal.kernel.exception.PortalException,
240                            com.liferay.portal.kernel.exception.SystemException {
241                    return _layoutLocalService.getPersistedModel(primaryKeyObj);
242            }
243    
244            /**
245            * Returns the layout with the matching UUID and company.
246            *
247            * @param uuid the layout's UUID
248            * @param companyId the primary key of the company
249            * @return the matching layout
250            * @throws PortalException if a matching layout could not be found
251            * @throws SystemException if a system exception occurred
252            */
253            @Override
254            public com.liferay.portal.model.Layout getLayoutByUuidAndCompanyId(
255                    java.lang.String uuid, long companyId)
256                    throws com.liferay.portal.kernel.exception.PortalException,
257                            com.liferay.portal.kernel.exception.SystemException {
258                    return _layoutLocalService.getLayoutByUuidAndCompanyId(uuid, companyId);
259            }
260    
261            /**
262            * Returns the layout matching the UUID, group, and privacy.
263            *
264            * @param uuid the layout's UUID
265            * @param groupId the primary key of the group
266            * @param privateLayout whether the layout is private to the group
267            * @return the matching layout
268            * @throws PortalException if a matching layout could not be found
269            * @throws SystemException if a system exception occurred
270            */
271            @Override
272            public com.liferay.portal.model.Layout getLayoutByUuidAndGroupId(
273                    java.lang.String uuid, long groupId, boolean privateLayout)
274                    throws com.liferay.portal.kernel.exception.PortalException,
275                            com.liferay.portal.kernel.exception.SystemException {
276                    return _layoutLocalService.getLayoutByUuidAndGroupId(uuid, groupId,
277                            privateLayout);
278            }
279    
280            /**
281            * Returns a range of all the layouts.
282            *
283            * <p>
284            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.LayoutModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
285            * </p>
286            *
287            * @param start the lower bound of the range of layouts
288            * @param end the upper bound of the range of layouts (not inclusive)
289            * @return the range of layouts
290            * @throws SystemException if a system exception occurred
291            */
292            @Override
293            public java.util.List<com.liferay.portal.model.Layout> getLayouts(
294                    int start, int end)
295                    throws com.liferay.portal.kernel.exception.SystemException {
296                    return _layoutLocalService.getLayouts(start, end);
297            }
298    
299            /**
300            * Returns the number of layouts.
301            *
302            * @return the number of layouts
303            * @throws SystemException if a system exception occurred
304            */
305            @Override
306            public int getLayoutsCount()
307                    throws com.liferay.portal.kernel.exception.SystemException {
308                    return _layoutLocalService.getLayoutsCount();
309            }
310    
311            /**
312            * Updates the layout in the database or adds it if it does not yet exist. Also notifies the appropriate model listeners.
313            *
314            * @param layout the layout
315            * @return the layout that was updated
316            * @throws SystemException if a system exception occurred
317            */
318            @Override
319            public com.liferay.portal.model.Layout updateLayout(
320                    com.liferay.portal.model.Layout layout)
321                    throws com.liferay.portal.kernel.exception.SystemException {
322                    return _layoutLocalService.updateLayout(layout);
323            }
324    
325            /**
326            * Returns the Spring bean ID for this bean.
327            *
328            * @return the Spring bean ID for this bean
329            */
330            @Override
331            public java.lang.String getBeanIdentifier() {
332                    return _layoutLocalService.getBeanIdentifier();
333            }
334    
335            /**
336            * Sets the Spring bean ID for this bean.
337            *
338            * @param beanIdentifier the Spring bean ID for this bean
339            */
340            @Override
341            public void setBeanIdentifier(java.lang.String beanIdentifier) {
342                    _layoutLocalService.setBeanIdentifier(beanIdentifier);
343            }
344    
345            /**
346            * Adds a layout.
347            *
348            * <p>
349            * This method handles the creation of the layout including its resources,
350            * metadata, and internal data structures. It is not necessary to make
351            * subsequent calls to any methods to setup default groups, resources, ...
352            * etc.
353            * </p>
354            *
355            * @param userId the primary key of the user
356            * @param groupId the primary key of the group
357            * @param privateLayout whether the layout is private to the group
358            * @param parentLayoutId the primary key of the parent layout
359            (optionally {@link
360            com.liferay.portal.model.LayoutConstants#DEFAULT_PARENT_LAYOUT_ID})
361            * @param nameMap the layout's locales and localized names
362            * @param titleMap the layout's locales and localized titles
363            * @param descriptionMap the layout's locales and localized
364            descriptions
365            * @param keywordsMap the layout's locales and localized keywords
366            * @param robotsMap the layout's locales and localized robots
367            * @param type the layout's type (optionally {@link
368            com.liferay.portal.model.LayoutConstants#TYPE_PORTLET}). The
369            possible types can be found in {@link
370            com.liferay.portal.model.LayoutConstants}.
371            * @param hidden whether the layout is hidden
372            * @param friendlyURL the layout's friendly URL (optionally {@link
373            com.liferay.portal.util.PropsValues#DEFAULT_USER_PRIVATE_LAYOUT_FRIENDLY_URL}
374            or {@link
375            com.liferay.portal.util.PropsValues#DEFAULT_USER_PUBLIC_LAYOUT_FRIENDLY_URL}).
376            The default values can be overridden in
377            <code>portal-ext.properties</code> by specifying new values
378            for the corresponding properties defined in {@link
379            com.liferay.portal.util.PropsValues}. To see how the URL is
380            normalized when accessed, see {@link
381            com.liferay.portal.kernel.util.FriendlyURLNormalizerUtil#normalize(
382            String)}.
383            * @param serviceContext the service context to be applied. Must set
384            the UUID for the layout. Can set the creation date,
385            modification date and the expando bridge attributes for the
386            layout. For layouts that belong to a layout set prototype, an
387            attribute named <code>layoutUpdateable</code> can be set to
388            specify whether site administrators can modify this page
389            within their site. For layouts that are created from a layout
390            prototype, attributes named <code>layoutPrototypeUuid</code>
391            and <code>layoutPrototypeLinkedEnabled</code> can be
392            specified to provide the unique identifier of the source
393            prototype and a boolean to determine whether a link to it
394            should be enabled to activate propagation of changes made to
395            the linked page in the prototype.
396            * @return the layout
397            * @throws PortalException if a group or user with the primary key could
398            not be found, if layout values were invalid, or if a portal
399            exception occurred
400            * @throws SystemException if a system exception occurred
401            * @deprecated As of 6.2.0, replaced by {@link #addLayout(long, long,
402            boolean, long, Map, Map, Map, Map, Map, String, String,
403            boolean, Map, ServiceContext)}
404            */
405            @Override
406            public com.liferay.portal.model.Layout addLayout(long userId, long groupId,
407                    boolean privateLayout, long parentLayoutId,
408                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
409                    java.util.Map<java.util.Locale, java.lang.String> titleMap,
410                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
411                    java.util.Map<java.util.Locale, java.lang.String> keywordsMap,
412                    java.util.Map<java.util.Locale, java.lang.String> robotsMap,
413                    java.lang.String type, boolean hidden, java.lang.String friendlyURL,
414                    com.liferay.portal.service.ServiceContext serviceContext)
415                    throws com.liferay.portal.kernel.exception.PortalException,
416                            com.liferay.portal.kernel.exception.SystemException {
417                    return _layoutLocalService.addLayout(userId, groupId, privateLayout,
418                            parentLayoutId, nameMap, titleMap, descriptionMap, keywordsMap,
419                            robotsMap, type, hidden, friendlyURL, serviceContext);
420            }
421    
422            /**
423            * Adds a layout with additional parameters.
424            *
425            * <p>
426            * This method handles the creation of the layout including its resources,
427            * metadata, and internal data structures. It is not necessary to make
428            * subsequent calls to any methods to setup default groups, resources, ...
429            * etc.
430            * </p>
431            *
432            * @param userId the primary key of the user
433            * @param groupId the primary key of the group
434            * @param privateLayout whether the layout is private to the group
435            * @param parentLayoutId the primary key of the parent layout (optionally
436            {@link
437            com.liferay.portal.model.LayoutConstants#DEFAULT_PARENT_LAYOUT_ID})
438            * @param nameMap the layout's locales and localized names
439            * @param titleMap the layout's locales and localized titles
440            * @param descriptionMap the layout's locales and localized descriptions
441            * @param keywordsMap the layout's locales and localized keywords
442            * @param robotsMap the layout's locales and localized robots
443            * @param type the layout's type (optionally {@link
444            com.liferay.portal.model.LayoutConstants#TYPE_PORTLET}). The
445            possible types can be found in {@link
446            com.liferay.portal.model.LayoutConstants}.
447            * @param typeSettings the settings to load the unicode properties object.
448            See {@link com.liferay.portal.kernel.util.UnicodeProperties
449            #fastLoad(String)}.
450            * @param hidden whether the layout is hidden
451            * @param friendlyURLMap the layout's locales and localized friendly URLs.
452            To see how the URL is normalized when accessed, see {@link
453            com.liferay.portal.kernel.util.FriendlyURLNormalizerUtil#normalize(
454            String)}.
455            * @param serviceContext the service context to be applied. Must set the
456            UUID for the layout. Can set the creation date, modification
457            date, and expando bridge attributes for the layout. For layouts
458            that belong to a layout set prototype, an attribute named
459            <code>layoutUpdateable</code> can be set to specify whether site
460            administrators can modify this page within their site. For
461            layouts that are created from a layout prototype, attributes
462            named <code>layoutPrototypeUuid</code> and
463            <code>layoutPrototypeLinkedEnabled</code> can be specified to
464            provide the unique identifier of the source prototype and a
465            boolean to determine whether a link to it should be enabled to
466            activate propagation of changes made to the linked page in the
467            prototype.
468            * @return the layout
469            * @throws PortalException if a group or user with the primary key could not
470            be found, if layout values were invalid, or if a portal exception
471            occurred
472            * @throws SystemException if a system exception occurred
473            */
474            @Override
475            public com.liferay.portal.model.Layout addLayout(long userId, long groupId,
476                    boolean privateLayout, long parentLayoutId,
477                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
478                    java.util.Map<java.util.Locale, java.lang.String> titleMap,
479                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
480                    java.util.Map<java.util.Locale, java.lang.String> keywordsMap,
481                    java.util.Map<java.util.Locale, java.lang.String> robotsMap,
482                    java.lang.String type, java.lang.String typeSettings, boolean hidden,
483                    java.util.Map<java.util.Locale, java.lang.String> friendlyURLMap,
484                    com.liferay.portal.service.ServiceContext serviceContext)
485                    throws com.liferay.portal.kernel.exception.PortalException,
486                            com.liferay.portal.kernel.exception.SystemException {
487                    return _layoutLocalService.addLayout(userId, groupId, privateLayout,
488                            parentLayoutId, nameMap, titleMap, descriptionMap, keywordsMap,
489                            robotsMap, type, typeSettings, hidden, friendlyURLMap,
490                            serviceContext);
491            }
492    
493            /**
494            * Adds a layout with single entry maps for name, title, and description to
495            * the default locale.
496            *
497            * <p>
498            * This method handles the creation of the layout including its resources,
499            * metadata, and internal data structures. It is not necessary to make
500            * subsequent calls to any methods to setup default groups, resources, ...
501            * etc.
502            * </p>
503            *
504            * @param userId the primary key of the user
505            * @param groupId the primary key of the group
506            * @param privateLayout whether the layout is private to the group
507            * @param parentLayoutId the primary key of the parent layout (optionally
508            {@link
509            com.liferay.portal.model.LayoutConstants#DEFAULT_PARENT_LAYOUT_ID}).
510            The possible values can be found in {@link
511            com.liferay.portal.model.LayoutConstants}.
512            * @param name the layout's name (optionally {@link
513            com.liferay.portal.util.PropsValues#DEFAULT_USER_PRIVATE_LAYOUT_NAME}
514            or {@link
515            com.liferay.portal.util.PropsValues#DEFAULT_USER_PUBLIC_LAYOUT_NAME}).
516            The default values can be overridden in
517            <code>portal-ext.properties</code> by specifying new values for
518            the corresponding properties defined in {@link
519            com.liferay.portal.util.PropsValues}
520            * @param title the layout's title
521            * @param description the layout's description
522            * @param type the layout's type (optionally {@link
523            com.liferay.portal.model.LayoutConstants#TYPE_PORTLET}). The
524            possible types can be found in {@link
525            com.liferay.portal.model.LayoutConstants}.
526            * @param hidden whether the layout is hidden
527            * @param friendlyURL the friendly URL of the layout (optionally {@link
528            com.liferay.portal.util.PropsValues#DEFAULT_USER_PRIVATE_LAYOUT_FRIENDLY_URL}
529            or {@link
530            com.liferay.portal.util.PropsValues#DEFAULT_USER_PUBLIC_LAYOUT_FRIENDLY_URL}).
531            The default values can be overridden in
532            <code>portal-ext.properties</code> by specifying new values for
533            the corresponding properties defined in {@link
534            com.liferay.portal.util.PropsValues}. To see how the URL is
535            normalized when accessed, see {@link
536            com.liferay.portal.kernel.util.FriendlyURLNormalizerUtil#normalize(
537            String)}.
538            * @param serviceContext the service context to be applied. Must set the
539            UUID for the layout. Can set the creation date and modification
540            date for the layout. For layouts that belong to a layout set
541            prototype, an attribute named <code>layoutUpdateable</code> can
542            be set to specify whether site administrators can modify this
543            page within their site.
544            * @return the layout
545            * @throws PortalException if a group or user with the primary key could not
546            be found, or if a portal exception occurred
547            * @throws SystemException if a system exception occurred
548            */
549            @Override
550            public com.liferay.portal.model.Layout addLayout(long userId, long groupId,
551                    boolean privateLayout, long parentLayoutId, java.lang.String name,
552                    java.lang.String title, java.lang.String description,
553                    java.lang.String type, boolean hidden, java.lang.String friendlyURL,
554                    com.liferay.portal.service.ServiceContext serviceContext)
555                    throws com.liferay.portal.kernel.exception.PortalException,
556                            com.liferay.portal.kernel.exception.SystemException {
557                    return _layoutLocalService.addLayout(userId, groupId, privateLayout,
558                            parentLayoutId, name, title, description, type, hidden,
559                            friendlyURL, serviceContext);
560            }
561    
562            /**
563            * Deletes the layout, its child layouts, and its associated resources.
564            *
565            * @param layout the layout
566            * @param updateLayoutSet whether the layout set's page counter needs to be
567            updated
568            * @param serviceContext the service context to be applied
569            * @throws PortalException if a portal exception occurred
570            * @throws SystemException if a system exception occurred
571            */
572            @Override
573            public void deleteLayout(com.liferay.portal.model.Layout layout,
574                    boolean updateLayoutSet,
575                    com.liferay.portal.service.ServiceContext serviceContext)
576                    throws com.liferay.portal.kernel.exception.PortalException,
577                            com.liferay.portal.kernel.exception.SystemException {
578                    _layoutLocalService.deleteLayout(layout, updateLayoutSet, serviceContext);
579            }
580    
581            /**
582            * Deletes the layout with the primary key, also deleting the layout's child
583            * layouts, and associated resources.
584            *
585            * @param groupId the primary key of the group
586            * @param privateLayout whether the layout is private to the group
587            * @param layoutId the primary key of the layout
588            * @param serviceContext the service context to be applied
589            * @throws PortalException if a matching layout could not be found , or if
590            some other portal exception occurred
591            * @throws SystemException if a system exception occurred
592            */
593            @Override
594            public void deleteLayout(long groupId, boolean privateLayout,
595                    long layoutId, com.liferay.portal.service.ServiceContext serviceContext)
596                    throws com.liferay.portal.kernel.exception.PortalException,
597                            com.liferay.portal.kernel.exception.SystemException {
598                    _layoutLocalService.deleteLayout(groupId, privateLayout, layoutId,
599                            serviceContext);
600            }
601    
602            /**
603            * Deletes the layout with the plid, also deleting the layout's child
604            * layouts, and associated resources.
605            *
606            * @param plid the primary key of the layout
607            * @param serviceContext the service context to be applied
608            * @throws PortalException if a layout with the primary key could not be
609            found , or if some other portal exception occurred
610            * @throws SystemException if a system exception occurred
611            */
612            @Override
613            public void deleteLayout(long plid,
614                    com.liferay.portal.service.ServiceContext serviceContext)
615                    throws com.liferay.portal.kernel.exception.PortalException,
616                            com.liferay.portal.kernel.exception.SystemException {
617                    _layoutLocalService.deleteLayout(plid, serviceContext);
618            }
619    
620            /**
621            * Deletes the group's private or non-private layouts, also deleting the
622            * layouts' child layouts, and associated resources.
623            *
624            * @param groupId the primary key of the group
625            * @param privateLayout whether the layout is private to the group
626            * @param serviceContext the service context to be applied. The parent
627            layout set's page count will be updated by default, unless an
628            attribute named <code>updatePageCount</code> is set to
629            <code>false</code>.
630            * @throws PortalException if a group with the primary key could not be
631            found or if a layout set for the group and privacy could not be
632            found
633            * @throws SystemException if a system exception occurred
634            */
635            @Override
636            public void deleteLayouts(long groupId, boolean privateLayout,
637                    com.liferay.portal.service.ServiceContext serviceContext)
638                    throws com.liferay.portal.kernel.exception.PortalException,
639                            com.liferay.portal.kernel.exception.SystemException {
640                    _layoutLocalService.deleteLayouts(groupId, privateLayout, serviceContext);
641            }
642    
643            /**
644            * Exports layouts with the primary keys and criteria as a byte array.
645            *
646            * @param groupId the primary key of the group
647            * @param privateLayout whether the layout is private to the group
648            * @param layoutIds the primary keys of the layouts to be exported
649            * @param parameterMap the mapping of parameters indicating which
650            information to export. For information on the keys used in the
651            map see {@link
652            com.liferay.portal.kernel.lar.PortletDataHandlerKeys}.
653            * @param startDate the export's start date
654            * @param endDate the export's end date
655            * @return the layouts as a byte array
656            * @throws PortalException if a group or any layout with the primary key
657            could not be found, or if some other portal exception occurred
658            * @throws SystemException if a system exception occurred
659            */
660            @Override
661            public byte[] exportLayouts(long groupId, boolean privateLayout,
662                    long[] layoutIds,
663                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
664                    java.util.Date startDate, java.util.Date endDate)
665                    throws com.liferay.portal.kernel.exception.PortalException,
666                            com.liferay.portal.kernel.exception.SystemException {
667                    return _layoutLocalService.exportLayouts(groupId, privateLayout,
668                            layoutIds, parameterMap, startDate, endDate);
669            }
670    
671            /**
672            * Exports all layouts that match the criteria as a byte array.
673            *
674            * @param groupId the primary key of the group
675            * @param privateLayout whether the layout is private to the group
676            * @param parameterMap the mapping of parameters indicating which
677            information to export. For information on the keys used in the
678            map see {@link
679            com.liferay.portal.kernel.lar.PortletDataHandlerKeys}.
680            * @param startDate the export's start date
681            * @param endDate the export's end date
682            * @return the layout as a byte array
683            * @throws PortalException if a group with the primary key could not be
684            found or if some other portal exception occurred
685            * @throws SystemException if a system exception occurred
686            */
687            @Override
688            public byte[] exportLayouts(long groupId, boolean privateLayout,
689                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
690                    java.util.Date startDate, java.util.Date endDate)
691                    throws com.liferay.portal.kernel.exception.PortalException,
692                            com.liferay.portal.kernel.exception.SystemException {
693                    return _layoutLocalService.exportLayouts(groupId, privateLayout,
694                            parameterMap, startDate, endDate);
695            }
696    
697            /**
698            * Exports the layouts that match the primary keys and criteria as a file.
699            *
700            * @param groupId the primary key of the group
701            * @param privateLayout whether the layout is private to the group
702            * @param layoutIds the primary keys of the layouts to be exported
703            (optionally <code>null</code>)
704            * @param parameterMap the mapping of parameters indicating which
705            information to export. For information on the keys used in the
706            map see {@link
707            com.liferay.portal.kernel.lar.PortletDataHandlerKeys}.
708            * @param startDate the export's start date
709            * @param endDate the export's end date
710            * @return the layouts as a File
711            * @throws PortalException if a group or any layout with the primary key
712            could not be found, or if some other portal exception occurred
713            * @throws SystemException if a system exception occurred
714            */
715            @Override
716            public java.io.File exportLayoutsAsFile(long groupId,
717                    boolean privateLayout, long[] layoutIds,
718                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
719                    java.util.Date startDate, java.util.Date endDate)
720                    throws com.liferay.portal.kernel.exception.PortalException,
721                            com.liferay.portal.kernel.exception.SystemException {
722                    return _layoutLocalService.exportLayoutsAsFile(groupId, privateLayout,
723                            layoutIds, parameterMap, startDate, endDate);
724            }
725    
726            @Override
727            public long exportLayoutsAsFileInBackground(long userId,
728                    java.lang.String taskName, long groupId, boolean privateLayout,
729                    long[] layoutIds,
730                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
731                    java.util.Date startDate, java.util.Date endDate,
732                    java.lang.String fileName)
733                    throws com.liferay.portal.kernel.exception.PortalException,
734                            com.liferay.portal.kernel.exception.SystemException {
735                    return _layoutLocalService.exportLayoutsAsFileInBackground(userId,
736                            taskName, groupId, privateLayout, layoutIds, parameterMap,
737                            startDate, endDate, fileName);
738            }
739    
740            /**
741            * Exports the portlet information (categories, permissions, ... etc.) as a
742            * byte array.
743            *
744            * @param plid the primary key of the layout
745            * @param groupId the primary key of the group
746            * @param portletId the primary key of the portlet
747            * @param parameterMap the mapping of parameters indicating which
748            information to export. For information on the keys used in the
749            map see {@link
750            com.liferay.portal.kernel.lar.PortletDataHandlerKeys}.
751            * @param startDate the export's start date
752            * @param endDate the export's end date
753            * @return the portlet information as a byte array
754            * @throws PortalException if a group or portlet with the primary key could
755            not be found, or if some other portal exception occurred
756            * @throws SystemException if a system exception occurred
757            */
758            @Override
759            public byte[] exportPortletInfo(long plid, long groupId,
760                    java.lang.String portletId,
761                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
762                    java.util.Date startDate, java.util.Date endDate)
763                    throws com.liferay.portal.kernel.exception.PortalException,
764                            com.liferay.portal.kernel.exception.SystemException {
765                    return _layoutLocalService.exportPortletInfo(plid, groupId, portletId,
766                            parameterMap, startDate, endDate);
767            }
768    
769            @Override
770            public byte[] exportPortletInfo(long companyId, java.lang.String portletId,
771                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
772                    java.util.Date startDate, java.util.Date endDate)
773                    throws com.liferay.portal.kernel.exception.PortalException,
774                            com.liferay.portal.kernel.exception.SystemException {
775                    return _layoutLocalService.exportPortletInfo(companyId, portletId,
776                            parameterMap, startDate, endDate);
777            }
778    
779            /**
780            * Exports the portlet information (categories, permissions, ... etc.) as a
781            * file.
782            *
783            * @param plid the primary key of the layout
784            * @param groupId the primary key of the group
785            * @param portletId the primary key of the portlet
786            * @param parameterMap the mapping of parameters indicating which
787            information to export. For information on the keys used in the
788            map see {@link
789            com.liferay.portal.kernel.lar.PortletDataHandlerKeys}.
790            * @param startDate the export's start date
791            * @param endDate the export's end date
792            * @return the portlet information as a file
793            * @throws PortalException if a group or portlet with the primary key could
794            not be found, or if some other portal exception occurred
795            * @throws SystemException if a system exception occurred
796            */
797            @Override
798            public java.io.File exportPortletInfoAsFile(long plid, long groupId,
799                    java.lang.String portletId,
800                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
801                    java.util.Date startDate, java.util.Date endDate)
802                    throws com.liferay.portal.kernel.exception.PortalException,
803                            com.liferay.portal.kernel.exception.SystemException {
804                    return _layoutLocalService.exportPortletInfoAsFile(plid, groupId,
805                            portletId, parameterMap, startDate, endDate);
806            }
807    
808            @Override
809            public java.io.File exportPortletInfoAsFile(long companyId,
810                    java.lang.String portletId,
811                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
812                    java.util.Date startDate, java.util.Date endDate)
813                    throws com.liferay.portal.kernel.exception.PortalException,
814                            com.liferay.portal.kernel.exception.SystemException {
815                    return _layoutLocalService.exportPortletInfoAsFile(companyId,
816                            portletId, parameterMap, startDate, endDate);
817            }
818    
819            @Override
820            public long exportPortletInfoAsFileInBackground(long userId,
821                    java.lang.String taskName, long plid, long groupId,
822                    java.lang.String portletId,
823                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
824                    java.util.Date startDate, java.util.Date endDate,
825                    java.lang.String fileName)
826                    throws com.liferay.portal.kernel.exception.PortalException,
827                            com.liferay.portal.kernel.exception.SystemException {
828                    return _layoutLocalService.exportPortletInfoAsFileInBackground(userId,
829                            taskName, plid, groupId, portletId, parameterMap, startDate,
830                            endDate, fileName);
831            }
832    
833            @Override
834            public long exportPortletInfoAsFileInBackground(long userId,
835                    java.lang.String taskName, java.lang.String portletId,
836                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
837                    java.util.Date startDate, java.util.Date endDate,
838                    java.lang.String fileName)
839                    throws com.liferay.portal.kernel.exception.PortalException,
840                            com.liferay.portal.kernel.exception.SystemException {
841                    return _layoutLocalService.exportPortletInfoAsFileInBackground(userId,
842                            taskName, portletId, parameterMap, startDate, endDate, fileName);
843            }
844    
845            @Override
846            public com.liferay.portal.model.Layout fetchFirstLayout(long groupId,
847                    boolean privateLayout, long parentLayoutId)
848                    throws com.liferay.portal.kernel.exception.SystemException {
849                    return _layoutLocalService.fetchFirstLayout(groupId, privateLayout,
850                            parentLayoutId);
851            }
852    
853            @Override
854            public com.liferay.portal.model.Layout fetchLayout(long groupId,
855                    boolean privateLayout, long layoutId)
856                    throws com.liferay.portal.kernel.exception.SystemException {
857                    return _layoutLocalService.fetchLayout(groupId, privateLayout, layoutId);
858            }
859    
860            @Override
861            public com.liferay.portal.model.Layout fetchLayoutByFriendlyURL(
862                    long groupId, boolean privateLayout, java.lang.String friendlyURL)
863                    throws com.liferay.portal.kernel.exception.SystemException {
864                    return _layoutLocalService.fetchLayoutByFriendlyURL(groupId,
865                            privateLayout, friendlyURL);
866            }
867    
868            @Override
869            public com.liferay.portal.model.Layout fetchLayoutByIconImageId(
870                    boolean privateLayout, long iconImageId)
871                    throws com.liferay.portal.kernel.exception.SystemException {
872                    return _layoutLocalService.fetchLayoutByIconImageId(privateLayout,
873                            iconImageId);
874            }
875    
876            /**
877            * Returns the primary key of the default layout for the group
878            *
879            * @param groupId the primary key of the group
880            * @return the primary key of the default layout for the group (optionally
881            {@link com.liferay.portal.model.LayoutConstants#DEFAULT_PLID})
882            * @throws SystemException if a system exception occurred
883            */
884            @Override
885            public long getDefaultPlid(long groupId)
886                    throws com.liferay.portal.kernel.exception.SystemException {
887                    return _layoutLocalService.getDefaultPlid(groupId);
888            }
889    
890            /**
891            * Returns primary key of the matching default layout for the group
892            *
893            * @param groupId the primary key of the group
894            * @param privateLayout whether the layout is private to the group
895            * @return the primary key of the default layout for the group; {@link
896            com.liferay.portal.model.LayoutConstants#DEFAULT_PLID}) otherwise
897            * @throws SystemException if a system exception occurred
898            */
899            @Override
900            public long getDefaultPlid(long groupId, boolean privateLayout)
901                    throws com.liferay.portal.kernel.exception.SystemException {
902                    return _layoutLocalService.getDefaultPlid(groupId, privateLayout);
903            }
904    
905            /**
906            * Returns primary key of the default portlet layout for the group
907            *
908            * @param groupId the primary key of the group
909            * @param privateLayout whether the layout is private to the group
910            * @param portletId the primary key of the portlet
911            * @return the primary key of the default portlet layout for the group;
912            {@link com.liferay.portal.model.LayoutConstants#DEFAULT_PLID}
913            otherwise
914            * @throws PortalException if a portlet with the primary key could not be
915            found
916            * @throws SystemException if a system exception occurred
917            */
918            @Override
919            public long getDefaultPlid(long groupId, boolean privateLayout,
920                    java.lang.String portletId)
921                    throws com.liferay.portal.kernel.exception.PortalException,
922                            com.liferay.portal.kernel.exception.SystemException {
923                    return _layoutLocalService.getDefaultPlid(groupId, privateLayout,
924                            portletId);
925            }
926    
927            /**
928            * Returns the layout for the friendly URL
929            *
930            * @param groupId the primary key of the group
931            * @param privateLayout whether the layout is private to the group
932            * @param friendlyURL the friendly URL of the layout
933            * @return the layout for the friendly URL
934            * @throws PortalException if the friendly URL is <code>null</code> or a
935            matching layout could not be found
936            * @throws SystemException if a system exception occurred
937            */
938            @Override
939            public com.liferay.portal.model.Layout getFriendlyURLLayout(long groupId,
940                    boolean privateLayout, java.lang.String friendlyURL)
941                    throws com.liferay.portal.kernel.exception.PortalException,
942                            com.liferay.portal.kernel.exception.SystemException {
943                    return _layoutLocalService.getFriendlyURLLayout(groupId, privateLayout,
944                            friendlyURL);
945            }
946    
947            /**
948            * Returns the layout matching the primary key, group, and privacy; throws a
949            * {@link com.liferay.portal.NoSuchLayoutException} otherwise.
950            *
951            * @param groupId the primary key of the group
952            * @param privateLayout whether the layout is private to the group
953            * @param layoutId the primary key of the layout
954            * @return the matching layout
955            * @throws PortalException if a matching layout could not be found
956            * @throws SystemException if a system exception occurred
957            */
958            @Override
959            public com.liferay.portal.model.Layout getLayout(long groupId,
960                    boolean privateLayout, long layoutId)
961                    throws com.liferay.portal.kernel.exception.PortalException,
962                            com.liferay.portal.kernel.exception.SystemException {
963                    return _layoutLocalService.getLayout(groupId, privateLayout, layoutId);
964            }
965    
966            /**
967            * Returns the layout for the icon image; throws a {@link
968            * com.liferay.portal.NoSuchLayoutException} otherwise.
969            *
970            * @param iconImageId the primary key of the icon image
971            * @return Returns the layout for the icon image
972            * @throws PortalException if an icon image with the primary key could not
973            be found
974            * @throws SystemException if a system exception occurred
975            */
976            @Override
977            public com.liferay.portal.model.Layout getLayoutByIconImageId(
978                    long iconImageId)
979                    throws com.liferay.portal.kernel.exception.PortalException,
980                            com.liferay.portal.kernel.exception.SystemException {
981                    return _layoutLocalService.getLayoutByIconImageId(iconImageId);
982            }
983    
984            /**
985            * Returns all the layouts belonging to the group.
986            *
987            * @param groupId the primary key of the group
988            * @param privateLayout whether the layout is private to the group
989            * @return the matching layouts, or <code>null</code> if no matches were
990            found
991            * @throws SystemException if a system exception occurred
992            */
993            @Override
994            public java.util.List<com.liferay.portal.model.Layout> getLayouts(
995                    long groupId, boolean privateLayout)
996                    throws com.liferay.portal.kernel.exception.SystemException {
997                    return _layoutLocalService.getLayouts(groupId, privateLayout);
998            }
999    
1000            /**
1001            * Returns all the layouts belonging to the group that are children of the
1002            * parent layout.
1003            *
1004            * @param groupId the primary key of the group
1005            * @param privateLayout whether the layout is private to the group
1006            * @param parentLayoutId the primary key of the parent layout
1007            * @return the matching layouts, or <code>null</code> if no matches were
1008            found
1009            * @throws SystemException if a system exception occurred
1010            */
1011            @Override
1012            public java.util.List<com.liferay.portal.model.Layout> getLayouts(
1013                    long groupId, boolean privateLayout, long parentLayoutId)
1014                    throws com.liferay.portal.kernel.exception.SystemException {
1015                    return _layoutLocalService.getLayouts(groupId, privateLayout,
1016                            parentLayoutId);
1017            }
1018    
1019            /**
1020            * Returns a range of all the layouts belonging to the group that are
1021            * children of the parent layout.
1022            *
1023            * <p>
1024            * Useful when paginating results. Returns a maximum of <code>end -
1025            * start</code> instances. <code>start</code> and <code>end</code> are not
1026            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1027            * refers to the first result in the set. Setting both <code>start</code>
1028            * and <code>end</code> to {@link
1029            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1030            * result set.
1031            * </p>
1032            *
1033            * @param groupId the primary key of the group
1034            * @param privateLayout whether the layout is private to the group
1035            * @param parentLayoutId the primary key of the parent layout
1036            * @param incomplete whether the layout is incomplete
1037            * @param start the lower bound of the range of layouts
1038            * @param end the upper bound of the range of layouts (not inclusive)
1039            * @return the matching layouts, or <code>null</code> if no matches were
1040            found
1041            * @throws SystemException if a system exception occurred
1042            */
1043            @Override
1044            public java.util.List<com.liferay.portal.model.Layout> getLayouts(
1045                    long groupId, boolean privateLayout, long parentLayoutId,
1046                    boolean incomplete, int start, int end)
1047                    throws com.liferay.portal.kernel.exception.SystemException {
1048                    return _layoutLocalService.getLayouts(groupId, privateLayout,
1049                            parentLayoutId, incomplete, start, end);
1050            }
1051    
1052            /**
1053            * Returns all the layouts that match the layout IDs and belong to the
1054            * group.
1055            *
1056            * @param groupId the primary key of the group
1057            * @param privateLayout whether the layout is private to the group
1058            * @param layoutIds the primary keys of the layouts
1059            * @return the matching layouts, or an empty list if no matches were found
1060            * @throws PortalException if a group or layout with the primary key could
1061            not be found
1062            * @throws SystemException if a system exception occurred
1063            */
1064            @Override
1065            public java.util.List<com.liferay.portal.model.Layout> getLayouts(
1066                    long groupId, boolean privateLayout, long[] layoutIds)
1067                    throws com.liferay.portal.kernel.exception.PortalException,
1068                            com.liferay.portal.kernel.exception.SystemException {
1069                    return _layoutLocalService.getLayouts(groupId, privateLayout, layoutIds);
1070            }
1071    
1072            /**
1073            * Returns all the layouts that match the type and belong to the group.
1074            *
1075            * @param groupId the primary key of the group
1076            * @param privateLayout whether the layout is private to the group
1077            * @param type the type of the layouts (optionally {@link
1078            com.liferay.portal.model.LayoutConstants#TYPE_PORTLET})
1079            * @return the matching layouts, or <code>null</code> if no matches were
1080            found
1081            * @throws SystemException if a system exception occurred
1082            */
1083            @Override
1084            public java.util.List<com.liferay.portal.model.Layout> getLayouts(
1085                    long groupId, boolean privateLayout, java.lang.String type)
1086                    throws com.liferay.portal.kernel.exception.SystemException {
1087                    return _layoutLocalService.getLayouts(groupId, privateLayout, type);
1088            }
1089    
1090            /**
1091            * Returns the layout references for all the layouts that belong to the
1092            * company and belong to the portlet that matches the preferences.
1093            *
1094            * @param companyId the primary key of the company
1095            * @param portletId the primary key of the portlet
1096            * @param preferencesKey the portlet's preference key
1097            * @param preferencesValue the portlet's preference value
1098            * @return the layout references of the matching layouts
1099            * @throws SystemException if a system exception occurred
1100            */
1101            @Override
1102            public com.liferay.portal.model.LayoutReference[] getLayouts(
1103                    long companyId, java.lang.String portletId,
1104                    java.lang.String preferencesKey, java.lang.String preferencesValue)
1105                    throws com.liferay.portal.kernel.exception.SystemException {
1106                    return _layoutLocalService.getLayouts(companyId, portletId,
1107                            preferencesKey, preferencesValue);
1108            }
1109    
1110            @Override
1111            public java.util.List<com.liferay.portal.model.Layout> getLayoutsByLayoutPrototypeUuid(
1112                    java.lang.String layoutPrototypeUuid)
1113                    throws com.liferay.portal.kernel.exception.SystemException {
1114                    return _layoutLocalService.getLayoutsByLayoutPrototypeUuid(layoutPrototypeUuid);
1115            }
1116    
1117            @Override
1118            public int getLayoutsByLayoutPrototypeUuidCount(
1119                    java.lang.String layoutPrototypeUuid)
1120                    throws com.liferay.portal.kernel.exception.SystemException {
1121                    return _layoutLocalService.getLayoutsByLayoutPrototypeUuidCount(layoutPrototypeUuid);
1122            }
1123    
1124            @Override
1125            public int getLayoutsCount(com.liferay.portal.model.Group group,
1126                    boolean privateLayout)
1127                    throws com.liferay.portal.kernel.exception.PortalException,
1128                            com.liferay.portal.kernel.exception.SystemException {
1129                    return _layoutLocalService.getLayoutsCount(group, privateLayout);
1130            }
1131    
1132            @Override
1133            public int getLayoutsCount(com.liferay.portal.model.Group group,
1134                    boolean privateLayout, boolean includeUserGroups)
1135                    throws com.liferay.portal.kernel.exception.PortalException,
1136                            com.liferay.portal.kernel.exception.SystemException {
1137                    return _layoutLocalService.getLayoutsCount(group, privateLayout,
1138                            includeUserGroups);
1139            }
1140    
1141            @Override
1142            public int getLayoutsCount(com.liferay.portal.model.User user,
1143                    boolean privateLayout)
1144                    throws com.liferay.portal.kernel.exception.PortalException,
1145                            com.liferay.portal.kernel.exception.SystemException {
1146                    return _layoutLocalService.getLayoutsCount(user, privateLayout);
1147            }
1148    
1149            @Override
1150            public int getLayoutsCount(com.liferay.portal.model.User user,
1151                    boolean privateLayout, boolean includeUserGroups)
1152                    throws com.liferay.portal.kernel.exception.PortalException,
1153                            com.liferay.portal.kernel.exception.SystemException {
1154                    return _layoutLocalService.getLayoutsCount(user, privateLayout,
1155                            includeUserGroups);
1156            }
1157    
1158            /**
1159            * Returns the primary key to use for the next layout.
1160            *
1161            * @param groupId the primary key of the group
1162            * @param privateLayout whether the layout is private to the group
1163            * @return the primary key to use for the next layout
1164            * @throws SystemException if a system exception occurred
1165            */
1166            @Override
1167            public long getNextLayoutId(long groupId, boolean privateLayout)
1168                    throws com.liferay.portal.kernel.exception.SystemException {
1169                    return _layoutLocalService.getNextLayoutId(groupId, privateLayout);
1170            }
1171    
1172            /**
1173            * Returns all the layouts without resource permissions
1174            *
1175            * @param roleId the primary key of the role
1176            * @return all the layouts without resource permissions
1177            * @throws SystemException if a system exception occurred
1178            */
1179            @Override
1180            public java.util.List<com.liferay.portal.model.Layout> getNoPermissionLayouts(
1181                    long roleId) throws com.liferay.portal.kernel.exception.SystemException {
1182                    return _layoutLocalService.getNoPermissionLayouts(roleId);
1183            }
1184    
1185            /**
1186            * Returns all the layouts whose friendly URLs are <code>null</code>
1187            *
1188            * @return all the layouts whose friendly URLs are <code>null</code>
1189            * @throws SystemException if a system exception occurred
1190            */
1191            @Override
1192            public java.util.List<com.liferay.portal.model.Layout> getNullFriendlyURLLayouts()
1193                    throws com.liferay.portal.kernel.exception.SystemException {
1194                    return _layoutLocalService.getNullFriendlyURLLayouts();
1195            }
1196    
1197            @Override
1198            public com.liferay.portal.model.Layout getParentLayout(
1199                    com.liferay.portal.model.Layout layout)
1200                    throws com.liferay.portal.kernel.exception.PortalException,
1201                            com.liferay.portal.kernel.exception.SystemException {
1202                    return _layoutLocalService.getParentLayout(layout);
1203            }
1204    
1205            /**
1206            * Returns all the layouts within scope of the group
1207            *
1208            * @param groupId the primary key of the group
1209            * @param privateLayout whether the layout is private to the group
1210            * @return the layouts within scope of the group
1211            * @throws SystemException if a system exception occurred
1212            */
1213            @Override
1214            public java.util.List<com.liferay.portal.model.Layout> getScopeGroupLayouts(
1215                    long groupId, boolean privateLayout)
1216                    throws com.liferay.portal.kernel.exception.SystemException {
1217                    return _layoutLocalService.getScopeGroupLayouts(groupId, privateLayout);
1218            }
1219    
1220            @Override
1221            public boolean hasLayouts(com.liferay.portal.model.Group group,
1222                    boolean privateLayout)
1223                    throws com.liferay.portal.kernel.exception.PortalException,
1224                            com.liferay.portal.kernel.exception.SystemException {
1225                    return _layoutLocalService.hasLayouts(group, privateLayout);
1226            }
1227    
1228            @Override
1229            public boolean hasLayouts(com.liferay.portal.model.Group group,
1230                    boolean privateLayout, boolean includeUserGroups)
1231                    throws com.liferay.portal.kernel.exception.PortalException,
1232                            com.liferay.portal.kernel.exception.SystemException {
1233                    return _layoutLocalService.hasLayouts(group, privateLayout,
1234                            includeUserGroups);
1235            }
1236    
1237            /**
1238            * Returns <code>true</code> if the group has any layouts;
1239            * <code>false</code> otherwise.
1240            *
1241            * @param groupId the primary key of the group
1242            * @param privateLayout whether the layout is private to the group
1243            * @param parentLayoutId the primary key of the parent layout
1244            * @return <code>true</code> if the group has any layouts;
1245            <code>false</code> otherwise
1246            * @throws SystemException if a system exception occurred
1247            */
1248            @Override
1249            public boolean hasLayouts(long groupId, boolean privateLayout,
1250                    long parentLayoutId)
1251                    throws com.liferay.portal.kernel.exception.SystemException {
1252                    return _layoutLocalService.hasLayouts(groupId, privateLayout,
1253                            parentLayoutId);
1254            }
1255    
1256            @Override
1257            public boolean hasLayouts(com.liferay.portal.model.User user,
1258                    boolean privateLayout)
1259                    throws com.liferay.portal.kernel.exception.PortalException,
1260                            com.liferay.portal.kernel.exception.SystemException {
1261                    return _layoutLocalService.hasLayouts(user, privateLayout);
1262            }
1263    
1264            @Override
1265            public boolean hasLayouts(com.liferay.portal.model.User user,
1266                    boolean privateLayout, boolean includeUserGroups)
1267                    throws com.liferay.portal.kernel.exception.PortalException,
1268                            com.liferay.portal.kernel.exception.SystemException {
1269                    return _layoutLocalService.hasLayouts(user, privateLayout,
1270                            includeUserGroups);
1271            }
1272    
1273            @Override
1274            public boolean hasLayoutSetPrototypeLayout(long layoutSetPrototypeId,
1275                    java.lang.String layoutUuid)
1276                    throws com.liferay.portal.kernel.exception.PortalException,
1277                            com.liferay.portal.kernel.exception.SystemException {
1278                    return _layoutLocalService.hasLayoutSetPrototypeLayout(layoutSetPrototypeId,
1279                            layoutUuid);
1280            }
1281    
1282            @Override
1283            public boolean hasLayoutSetPrototypeLayout(
1284                    java.lang.String layoutSetPrototypeUuid, long companyId,
1285                    java.lang.String layoutUuid)
1286                    throws com.liferay.portal.kernel.exception.PortalException,
1287                            com.liferay.portal.kernel.exception.SystemException {
1288                    return _layoutLocalService.hasLayoutSetPrototypeLayout(layoutSetPrototypeUuid,
1289                            companyId, layoutUuid);
1290            }
1291    
1292            /**
1293            * Imports the layouts from the byte array.
1294            *
1295            * @param userId the primary key of the user
1296            * @param groupId the primary key of the group
1297            * @param privateLayout whether the layout is private to the group
1298            * @param parameterMap the mapping of parameters indicating which
1299            information will be imported. For information on the keys used in
1300            the map see {@link
1301            com.liferay.portal.kernel.lar.PortletDataHandlerKeys}.
1302            * @param bytes the byte array with the data
1303            * @throws PortalException if a group or user with the primary key could not
1304            be found, or if some other portal exception occurred
1305            * @throws SystemException if a system exception occurred
1306            * @see com.liferay.portal.lar.LayoutImporter
1307            */
1308            @Override
1309            public void importLayouts(long userId, long groupId, boolean privateLayout,
1310                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1311                    byte[] bytes)
1312                    throws com.liferay.portal.kernel.exception.PortalException,
1313                            com.liferay.portal.kernel.exception.SystemException {
1314                    _layoutLocalService.importLayouts(userId, groupId, privateLayout,
1315                            parameterMap, bytes);
1316            }
1317    
1318            /**
1319            * Imports the layouts from the file.
1320            *
1321            * @param userId the primary key of the user
1322            * @param groupId the primary key of the group
1323            * @param privateLayout whether the layout is private to the group
1324            * @param parameterMap the mapping of parameters indicating which
1325            information will be imported. For information on the keys used in
1326            the map see {@link
1327            com.liferay.portal.kernel.lar.PortletDataHandlerKeys}.
1328            * @param file the LAR file with the data
1329            * @throws PortalException if a group or user with the primary key could not
1330            be found, or if some other portal exception occurred
1331            * @throws SystemException if a system exception occurred
1332            * @see com.liferay.portal.lar.LayoutImporter
1333            */
1334            @Override
1335            public void importLayouts(long userId, long groupId, boolean privateLayout,
1336                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1337                    java.io.File file)
1338                    throws com.liferay.portal.kernel.exception.PortalException,
1339                            com.liferay.portal.kernel.exception.SystemException {
1340                    _layoutLocalService.importLayouts(userId, groupId, privateLayout,
1341                            parameterMap, file);
1342            }
1343    
1344            /**
1345            * Imports the layouts from the input stream.
1346            *
1347            * @param userId the primary key of the user
1348            * @param groupId the primary key of the group
1349            * @param privateLayout whether the layout is private to the group
1350            * @param parameterMap the mapping of parameters indicating which
1351            information will be imported. For information on the keys used in
1352            the map see {@link
1353            com.liferay.portal.kernel.lar.PortletDataHandlerKeys}.
1354            * @param is the input stream
1355            * @throws PortalException if a group or user with the primary key could not
1356            be found, or if some other portal exception occurred
1357            * @throws SystemException if a system exception occurred
1358            * @see com.liferay.portal.lar.LayoutImporter
1359            */
1360            @Override
1361            public void importLayouts(long userId, long groupId, boolean privateLayout,
1362                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1363                    java.io.InputStream is)
1364                    throws com.liferay.portal.kernel.exception.PortalException,
1365                            com.liferay.portal.kernel.exception.SystemException {
1366                    _layoutLocalService.importLayouts(userId, groupId, privateLayout,
1367                            parameterMap, is);
1368            }
1369    
1370            @Override
1371            public long importLayoutsInBackground(long userId,
1372                    java.lang.String taskName, long groupId, boolean privateLayout,
1373                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1374                    java.io.File file)
1375                    throws com.liferay.portal.kernel.exception.PortalException,
1376                            com.liferay.portal.kernel.exception.SystemException {
1377                    return _layoutLocalService.importLayoutsInBackground(userId, taskName,
1378                            groupId, privateLayout, parameterMap, file);
1379            }
1380    
1381            @Override
1382            public long importLayoutsInBackground(long userId,
1383                    java.lang.String taskName, long groupId, boolean privateLayout,
1384                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1385                    java.io.InputStream is)
1386                    throws com.liferay.portal.kernel.exception.PortalException,
1387                            com.liferay.portal.kernel.exception.SystemException {
1388                    return _layoutLocalService.importLayoutsInBackground(userId, taskName,
1389                            groupId, privateLayout, parameterMap, is);
1390            }
1391    
1392            /**
1393            * Imports the portlet information (categories, permissions, ... etc.) from
1394            * the file.
1395            *
1396            * @param userId the primary key of the user
1397            * @param plid the primary key of the target layout
1398            * @param groupId the primary key of the target group
1399            * @param portletId the primary key of the portlet
1400            * @param parameterMap the mapping of parameters indicating which
1401            information will be imported. For information on the keys used in
1402            the map see {@link
1403            com.liferay.portal.kernel.lar.PortletDataHandlerKeys}.
1404            * @param file the LAR file with the data
1405            * @throws PortalException if a group, layout, portlet or user with the
1406            primary key could not be found
1407            * @throws SystemException if a system exception occurred
1408            */
1409            @Override
1410            public void importPortletInfo(long userId, long plid, long groupId,
1411                    java.lang.String portletId,
1412                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1413                    java.io.File file)
1414                    throws com.liferay.portal.kernel.exception.PortalException,
1415                            com.liferay.portal.kernel.exception.SystemException {
1416                    _layoutLocalService.importPortletInfo(userId, plid, groupId, portletId,
1417                            parameterMap, file);
1418            }
1419    
1420            /**
1421            * Imports the portlet information (categories, permissions, ... etc.) from
1422            * the input stream.
1423            *
1424            * @param userId the primary key of the user
1425            * @param plid the primary key of the layout
1426            * @param groupId the primary key of the group
1427            * @param portletId the primary key of the portlet
1428            * @param parameterMap the mapping of parameters indicating which
1429            information will be imported. For information on the keys used in
1430            the map see {@link
1431            com.liferay.portal.kernel.lar.PortletDataHandlerKeys}.
1432            * @param is the input stream
1433            * @throws PortalException if a group, portlet, layout or user with the
1434            primary key could not be found
1435            * @throws SystemException if a system exception occurred
1436            */
1437            @Override
1438            public void importPortletInfo(long userId, long plid, long groupId,
1439                    java.lang.String portletId,
1440                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1441                    java.io.InputStream is)
1442                    throws com.liferay.portal.kernel.exception.PortalException,
1443                            com.liferay.portal.kernel.exception.SystemException {
1444                    _layoutLocalService.importPortletInfo(userId, plid, groupId, portletId,
1445                            parameterMap, is);
1446            }
1447    
1448            @Override
1449            public void importPortletInfo(long userId, java.lang.String portletId,
1450                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1451                    java.io.File file)
1452                    throws com.liferay.portal.kernel.exception.PortalException,
1453                            com.liferay.portal.kernel.exception.SystemException {
1454                    _layoutLocalService.importPortletInfo(userId, portletId, parameterMap,
1455                            file);
1456            }
1457    
1458            @Override
1459            public void importPortletInfo(long userId, java.lang.String portletId,
1460                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1461                    java.io.InputStream is)
1462                    throws com.liferay.portal.kernel.exception.PortalException,
1463                            com.liferay.portal.kernel.exception.SystemException {
1464                    _layoutLocalService.importPortletInfo(userId, portletId, parameterMap,
1465                            is);
1466            }
1467    
1468            @Override
1469            public long importPortletInfoInBackground(long userId,
1470                    java.lang.String taskName, long plid, long groupId,
1471                    java.lang.String portletId,
1472                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1473                    java.io.File file)
1474                    throws com.liferay.portal.kernel.exception.PortalException,
1475                            com.liferay.portal.kernel.exception.SystemException {
1476                    return _layoutLocalService.importPortletInfoInBackground(userId,
1477                            taskName, plid, groupId, portletId, parameterMap, file);
1478            }
1479    
1480            @Override
1481            public long importPortletInfoInBackground(long userId,
1482                    java.lang.String taskName, long plid, long groupId,
1483                    java.lang.String portletId,
1484                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1485                    java.io.InputStream is)
1486                    throws com.liferay.portal.kernel.exception.PortalException,
1487                            com.liferay.portal.kernel.exception.SystemException {
1488                    return _layoutLocalService.importPortletInfoInBackground(userId,
1489                            taskName, plid, groupId, portletId, parameterMap, is);
1490            }
1491    
1492            @Override
1493            public long importPortletInfoInBackground(long userId,
1494                    java.lang.String taskName, java.lang.String portletId,
1495                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1496                    java.io.File file)
1497                    throws com.liferay.portal.kernel.exception.PortalException,
1498                            com.liferay.portal.kernel.exception.SystemException {
1499                    return _layoutLocalService.importPortletInfoInBackground(userId,
1500                            taskName, portletId, parameterMap, file);
1501            }
1502    
1503            @Override
1504            public long importPortletInfoInBackground(long userId,
1505                    java.lang.String taskName, java.lang.String portletId,
1506                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1507                    java.io.InputStream is)
1508                    throws com.liferay.portal.kernel.exception.PortalException,
1509                            com.liferay.portal.kernel.exception.SystemException {
1510                    return _layoutLocalService.importPortletInfoInBackground(userId,
1511                            taskName, portletId, parameterMap, is);
1512            }
1513    
1514            /**
1515            * Sets the layouts for the group, replacing and prioritizing all layouts of
1516            * the parent layout.
1517            *
1518            * @param groupId the primary key of the group
1519            * @param privateLayout whether the layout is private to the group
1520            * @param parentLayoutId the primary key of the parent layout
1521            * @param layoutIds the primary keys of the layouts
1522            * @param serviceContext the service context to be applied
1523            * @throws PortalException if a group or layout with the primary key could
1524            not be found, if no layouts were specified, if the first layout
1525            was not page-able, if the first layout was hidden, or if some
1526            other portal exception occurred
1527            * @throws SystemException if a system exception occurred
1528            */
1529            @Override
1530            public void setLayouts(long groupId, boolean privateLayout,
1531                    long parentLayoutId, long[] layoutIds,
1532                    com.liferay.portal.service.ServiceContext serviceContext)
1533                    throws com.liferay.portal.kernel.exception.PortalException,
1534                            com.liferay.portal.kernel.exception.SystemException {
1535                    _layoutLocalService.setLayouts(groupId, privateLayout, parentLayoutId,
1536                            layoutIds, serviceContext);
1537            }
1538    
1539            /**
1540            * Updates the friendly URL of the layout.
1541            *
1542            * @param plid the primary key of the layout
1543            * @param friendlyURL the friendly URL to be assigned
1544            * @param languageId the primary key of the language
1545            * @return the updated layout
1546            * @throws PortalException if a group or layout with the primary key could
1547            not be found
1548            * @throws SystemException if a system exception occurred
1549            */
1550            @Override
1551            public com.liferay.portal.model.Layout updateFriendlyURL(long plid,
1552                    java.lang.String friendlyURL, java.lang.String languageId)
1553                    throws com.liferay.portal.kernel.exception.PortalException,
1554                            com.liferay.portal.kernel.exception.SystemException {
1555                    return _layoutLocalService.updateFriendlyURL(plid, friendlyURL,
1556                            languageId);
1557            }
1558    
1559            /**
1560            * Updates the layout.
1561            *
1562            * @param groupId the primary key of the group
1563            * @param privateLayout whether the layout is private to the group
1564            * @param layoutId the primary key of the layout
1565            * @param parentLayoutId the primary key of the layout's new parent layout
1566            * @param nameMap the locales and localized names to merge (optionally
1567            <code>null</code>)
1568            * @param titleMap the locales and localized titles to merge (optionally
1569            <code>null</code>)
1570            * @param descriptionMap the locales and localized descriptions to merge
1571            (optionally <code>null</code>)
1572            * @param keywordsMap the locales and localized keywords to merge
1573            (optionally <code>null</code>)
1574            * @param robotsMap the locales and localized robots to merge (optionally
1575            <code>null</code>)
1576            * @param type the layout's new type (optionally {@link
1577            com.liferay.portal.model.LayoutConstants#TYPE_PORTLET})
1578            * @param hidden whether the layout is hidden
1579            * @param friendlyURLMap the layout's locales and localized friendly URLs.
1580            To see how the URL is normalized when accessed, see {@link
1581            com.liferay.portal.kernel.util.FriendlyURLNormalizerUtil#normalize(
1582            String)}.
1583            * @param iconImage whether the icon image will be updated
1584            * @param iconBytes the byte array of the layout's new icon image
1585            * @param serviceContext the service context to be applied. Can set the
1586            modification date and expando bridge attributes for the layout.
1587            For layouts that are linked to a layout prototype, attributes
1588            named <code>layoutPrototypeUuid</code> and
1589            <code>layoutPrototypeLinkedEnabled</code> can be specified to
1590            provide the unique identifier of the source prototype and a
1591            boolean to determine whether a link to it should be enabled to
1592            activate propagation of changes made to the linked page in the
1593            prototype.
1594            * @return the updated layout
1595            * @throws PortalException if a group or layout with the primary key could
1596            not be found, if a unique friendly URL could not be generated, if
1597            a valid parent layout ID to use could not be found, if the layout
1598            parameters were invalid, or if a portal exception occurred
1599            * @throws SystemException if a system exception occurred
1600            */
1601            @Override
1602            public com.liferay.portal.model.Layout updateLayout(long groupId,
1603                    boolean privateLayout, long layoutId, long parentLayoutId,
1604                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
1605                    java.util.Map<java.util.Locale, java.lang.String> titleMap,
1606                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
1607                    java.util.Map<java.util.Locale, java.lang.String> keywordsMap,
1608                    java.util.Map<java.util.Locale, java.lang.String> robotsMap,
1609                    java.lang.String type, boolean hidden,
1610                    java.util.Map<java.util.Locale, java.lang.String> friendlyURLMap,
1611                    java.lang.Boolean iconImage, byte[] iconBytes,
1612                    com.liferay.portal.service.ServiceContext serviceContext)
1613                    throws com.liferay.portal.kernel.exception.PortalException,
1614                            com.liferay.portal.kernel.exception.SystemException {
1615                    return _layoutLocalService.updateLayout(groupId, privateLayout,
1616                            layoutId, parentLayoutId, nameMap, titleMap, descriptionMap,
1617                            keywordsMap, robotsMap, type, hidden, friendlyURLMap, iconImage,
1618                            iconBytes, serviceContext);
1619            }
1620    
1621            /**
1622            * Updates the layout.
1623            *
1624            * @param groupId the primary key of the group
1625            * @param privateLayout whether the layout is private to the group
1626            * @param layoutId the primary key of the layout
1627            * @param parentLayoutId the primary key of the layout's new parent
1628            layout
1629            * @param nameMap the locales and localized names to merge (optionally
1630            <code>null</code>)
1631            * @param titleMap the locales and localized titles to merge
1632            (optionally <code>null</code>)
1633            * @param descriptionMap the locales and localized descriptions to
1634            merge (optionally <code>null</code>)
1635            * @param keywordsMap the locales and localized keywords to merge
1636            (optionally <code>null</code>)
1637            * @param robotsMap the locales and localized robots to merge
1638            (optionally <code>null</code>)
1639            * @param type the layout's new type (optionally {@link
1640            com.liferay.portal.model.LayoutConstants#TYPE_PORTLET})
1641            * @param hidden whether the layout is hidden
1642            * @param friendlyURL the layout's new friendly URL (optionally {@link
1643            com.liferay.portal.util.PropsValues#DEFAULT_USER_PRIVATE_LAYOUT_FRIENDLY_URL}
1644            or {@link
1645            com.liferay.portal.util.PropsValues#DEFAULT_USER_PRIVATE_LAYOUT_FRIENDLY_URL}).
1646            The default values can be overridden in
1647            <code>portal-ext.properties</code> by specifying new values
1648            for the corresponding properties defined in {@link
1649            com.liferay.portal.util.PropsValues}. To see how the URL is
1650            normalized when accessed, see {@link
1651            com.liferay.portal.kernel.util.FriendlyURLNormalizerUtil#normalize(
1652            String)}.
1653            * @param iconImage whether the icon image will be updated
1654            * @param iconBytes the byte array of the layout's new icon image
1655            * @param serviceContext the service context to be applied. Can set the
1656            modification date and expando bridge attributes for the
1657            layout. For layouts that are linked to a layout prototype,
1658            attributes named <code>layoutPrototypeUuid</code> and
1659            <code>layoutPrototypeLinkedEnabled</code> can be specified to
1660            provide the unique identifier of the source prototype and a
1661            boolean to determine whether a link to it should be enabled
1662            to activate propagation of changes made to the linked page in
1663            the prototype.
1664            * @return the updated layout
1665            * @throws PortalException if a group or layout with the primary key
1666            could not be found, if a unique friendly URL could not be
1667            generated, if a valid parent layout ID to use could not be
1668            found, if the layout parameters were invalid, or if a portal
1669            exception occurred
1670            * @throws SystemException if a system exception occurred
1671            * @deprecated As of 6.2.0, replaced by {@link #updateLayout(long, boolean,
1672            long, long, Map, Map, Map, Map, Map, String, boolean, Map,
1673            Boolean, byte[], ServiceContext)}
1674            */
1675            @Override
1676            public com.liferay.portal.model.Layout updateLayout(long groupId,
1677                    boolean privateLayout, long layoutId, long parentLayoutId,
1678                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
1679                    java.util.Map<java.util.Locale, java.lang.String> titleMap,
1680                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
1681                    java.util.Map<java.util.Locale, java.lang.String> keywordsMap,
1682                    java.util.Map<java.util.Locale, java.lang.String> robotsMap,
1683                    java.lang.String type, boolean hidden, java.lang.String friendlyURL,
1684                    java.lang.Boolean iconImage, byte[] iconBytes,
1685                    com.liferay.portal.service.ServiceContext serviceContext)
1686                    throws com.liferay.portal.kernel.exception.PortalException,
1687                            com.liferay.portal.kernel.exception.SystemException {
1688                    return _layoutLocalService.updateLayout(groupId, privateLayout,
1689                            layoutId, parentLayoutId, nameMap, titleMap, descriptionMap,
1690                            keywordsMap, robotsMap, type, hidden, friendlyURL, iconImage,
1691                            iconBytes, serviceContext);
1692            }
1693    
1694            /**
1695            * Updates the layout replacing its type settings.
1696            *
1697            * @param groupId the primary key of the group
1698            * @param privateLayout whether the layout is private to the group
1699            * @param layoutId the primary key of the layout
1700            * @param typeSettings the settings to load the unicode properties object.
1701            See {@link com.liferay.portal.kernel.util.UnicodeProperties
1702            #fastLoad(String)}.
1703            * @return the updated layout
1704            * @throws PortalException if a matching layout could not be found or if a
1705            portal exception occurred
1706            * @throws SystemException if a system exception occurred
1707            */
1708            @Override
1709            public com.liferay.portal.model.Layout updateLayout(long groupId,
1710                    boolean privateLayout, long layoutId, java.lang.String typeSettings)
1711                    throws com.liferay.portal.kernel.exception.PortalException,
1712                            com.liferay.portal.kernel.exception.SystemException {
1713                    return _layoutLocalService.updateLayout(groupId, privateLayout,
1714                            layoutId, typeSettings);
1715            }
1716    
1717            /**
1718            * Updates the look and feel of the layout.
1719            *
1720            * @param groupId the primary key of the group
1721            * @param privateLayout whether the layout is private to the group
1722            * @param layoutId the primary key of the layout
1723            * @param themeId the primary key of the layout's new theme
1724            * @param colorSchemeId the primary key of the layout's new color scheme
1725            * @param css the layout's new CSS
1726            * @param wapTheme whether the theme is for WAP browsers
1727            * @return the updated layout
1728            * @throws PortalException if a matching layout could not be found
1729            * @throws SystemException if a system exception occurred
1730            */
1731            @Override
1732            public com.liferay.portal.model.Layout updateLookAndFeel(long groupId,
1733                    boolean privateLayout, long layoutId, java.lang.String themeId,
1734                    java.lang.String colorSchemeId, java.lang.String css, boolean wapTheme)
1735                    throws com.liferay.portal.kernel.exception.PortalException,
1736                            com.liferay.portal.kernel.exception.SystemException {
1737                    return _layoutLocalService.updateLookAndFeel(groupId, privateLayout,
1738                            layoutId, themeId, colorSchemeId, css, wapTheme);
1739            }
1740    
1741            /**
1742            * Updates the name of the layout.
1743            *
1744            * @param layout the layout to be updated
1745            * @param name the layout's new name
1746            * @param languageId the primary key of the language. For more information
1747            see {@link java.util.Locale}.
1748            * @return the updated layout
1749            * @throws PortalException if the new name was <code>null</code>
1750            * @throws SystemException if a system exception occurred
1751            */
1752            @Override
1753            public com.liferay.portal.model.Layout updateName(
1754                    com.liferay.portal.model.Layout layout, java.lang.String name,
1755                    java.lang.String languageId)
1756                    throws com.liferay.portal.kernel.exception.PortalException,
1757                            com.liferay.portal.kernel.exception.SystemException {
1758                    return _layoutLocalService.updateName(layout, name, languageId);
1759            }
1760    
1761            /**
1762            * Updates the name of the layout matching the group, layout ID, and
1763            * privacy.
1764            *
1765            * @param groupId the primary key of the group
1766            * @param privateLayout whether the layout is private to the group
1767            * @param layoutId the primary key of the layout
1768            * @param name the layout's new name
1769            * @param languageId the primary key of the language. For more information
1770            see {@link java.util.Locale}.
1771            * @return the updated layout
1772            * @throws PortalException if a matching layout could not be found or if the
1773            new name was <code>null</code>
1774            * @throws SystemException if a system exception occurred
1775            */
1776            @Override
1777            public com.liferay.portal.model.Layout updateName(long groupId,
1778                    boolean privateLayout, long layoutId, java.lang.String name,
1779                    java.lang.String languageId)
1780                    throws com.liferay.portal.kernel.exception.PortalException,
1781                            com.liferay.portal.kernel.exception.SystemException {
1782                    return _layoutLocalService.updateName(groupId, privateLayout, layoutId,
1783                            name, languageId);
1784            }
1785    
1786            /**
1787            * Updates the name of the layout matching the primary key.
1788            *
1789            * @param plid the primary key of the layout
1790            * @param name the name to be assigned
1791            * @param languageId the primary key of the language. For more information
1792            see {@link java.util.Locale}.
1793            * @return the updated layout
1794            * @throws PortalException if a layout with the primary key could not be
1795            found or if the name was <code>null</code>
1796            * @throws SystemException if a system exception occurred
1797            */
1798            @Override
1799            public com.liferay.portal.model.Layout updateName(long plid,
1800                    java.lang.String name, java.lang.String languageId)
1801                    throws com.liferay.portal.kernel.exception.PortalException,
1802                            com.liferay.portal.kernel.exception.SystemException {
1803                    return _layoutLocalService.updateName(plid, name, languageId);
1804            }
1805    
1806            /**
1807            * Updates the parent layout ID of the layout matching the group, layout ID,
1808            * and privacy.
1809            *
1810            * @param groupId the primary key of the group
1811            * @param privateLayout whether the layout is private to the group
1812            * @param layoutId the primary key of the layout
1813            * @param parentLayoutId the primary key to be assigned to the parent
1814            layout
1815            * @return the matching layout
1816            * @throws PortalException if a valid parent layout ID to use could not be
1817            found or if a matching layout could not be found
1818            * @throws SystemException if a system exception occurred
1819            */
1820            @Override
1821            public com.liferay.portal.model.Layout updateParentLayoutId(long groupId,
1822                    boolean privateLayout, long layoutId, long parentLayoutId)
1823                    throws com.liferay.portal.kernel.exception.PortalException,
1824                            com.liferay.portal.kernel.exception.SystemException {
1825                    return _layoutLocalService.updateParentLayoutId(groupId, privateLayout,
1826                            layoutId, parentLayoutId);
1827            }
1828    
1829            /**
1830            * Updates the parent layout ID of the layout matching the primary key. If a
1831            * layout matching the parent primary key is found, the layout ID of that
1832            * layout is assigned, otherwise {@link
1833            * com.liferay.portal.model.LayoutConstants#DEFAULT_PARENT_LAYOUT_ID} is
1834            * assigned.
1835            *
1836            * @param plid the primary key of the layout
1837            * @param parentPlid the primary key of the parent layout
1838            * @return the layout matching the primary key
1839            * @throws PortalException if a layout with the primary key could not be
1840            found or if a valid parent layout ID to use could not be found
1841            * @throws SystemException if a system exception occurred
1842            */
1843            @Override
1844            public com.liferay.portal.model.Layout updateParentLayoutId(long plid,
1845                    long parentPlid)
1846                    throws com.liferay.portal.kernel.exception.PortalException,
1847                            com.liferay.portal.kernel.exception.SystemException {
1848                    return _layoutLocalService.updateParentLayoutId(plid, parentPlid);
1849            }
1850    
1851            @Override
1852            public com.liferay.portal.model.Layout updateParentLayoutIdAndPriority(
1853                    long plid, long parentPlid, int priority)
1854                    throws com.liferay.portal.kernel.exception.PortalException,
1855                            com.liferay.portal.kernel.exception.SystemException {
1856                    return _layoutLocalService.updateParentLayoutIdAndPriority(plid,
1857                            parentPlid, priority);
1858            }
1859    
1860            /**
1861            * Updates the priorities of the layouts.
1862            *
1863            * @param groupId the primary key of the group
1864            * @param privateLayout whether the layout is private to the group
1865            * @throws PortalException if a matching layout could not be found
1866            * @throws SystemException if a system exception occurred
1867            */
1868            @Override
1869            public void updatePriorities(long groupId, boolean privateLayout)
1870                    throws com.liferay.portal.kernel.exception.PortalException,
1871                            com.liferay.portal.kernel.exception.SystemException {
1872                    _layoutLocalService.updatePriorities(groupId, privateLayout);
1873            }
1874    
1875            /**
1876            * Updates the priority of the layout.
1877            *
1878            * @param layout the layout to be updated
1879            * @param priority the layout's new priority
1880            * @return the updated layout
1881            * @throws PortalException if a portal exception occurred
1882            * @throws SystemException if a system exception occurred
1883            */
1884            @Override
1885            public com.liferay.portal.model.Layout updatePriority(
1886                    com.liferay.portal.model.Layout layout, int priority)
1887                    throws com.liferay.portal.kernel.exception.PortalException,
1888                            com.liferay.portal.kernel.exception.SystemException {
1889                    return _layoutLocalService.updatePriority(layout, priority);
1890            }
1891    
1892            /**
1893            * Updates the priority of the layout matching the group, layout ID, and
1894            * privacy.
1895            *
1896            * @param groupId the primary key of the group
1897            * @param privateLayout whether the layout is private to the group
1898            * @param layoutId the primary key of the layout
1899            * @param priority the layout's new priority
1900            * @return the updated layout
1901            * @throws PortalException if a matching layout could not be found
1902            * @throws SystemException if a system exception occurred
1903            */
1904            @Override
1905            public com.liferay.portal.model.Layout updatePriority(long groupId,
1906                    boolean privateLayout, long layoutId, int priority)
1907                    throws com.liferay.portal.kernel.exception.PortalException,
1908                            com.liferay.portal.kernel.exception.SystemException {
1909                    return _layoutLocalService.updatePriority(groupId, privateLayout,
1910                            layoutId, priority);
1911            }
1912    
1913            /**
1914            * Updates the priority of the layout matching the group, layout ID, and
1915            * privacy, setting the layout's priority based on the priorities of the
1916            * next and previous layouts.
1917            *
1918            * @param groupId the primary key of the group
1919            * @param privateLayout whether the layout is private to the group
1920            * @param layoutId the primary key of the layout
1921            * @param nextLayoutId the primary key of the next layout
1922            * @param previousLayoutId the primary key of the previous layout
1923            * @return the updated layout
1924            * @throws PortalException if a matching layout could not be found
1925            * @throws SystemException if a system exception occurred
1926            */
1927            @Override
1928            public com.liferay.portal.model.Layout updatePriority(long groupId,
1929                    boolean privateLayout, long layoutId, long nextLayoutId,
1930                    long previousLayoutId)
1931                    throws com.liferay.portal.kernel.exception.PortalException,
1932                            com.liferay.portal.kernel.exception.SystemException {
1933                    return _layoutLocalService.updatePriority(groupId, privateLayout,
1934                            layoutId, nextLayoutId, previousLayoutId);
1935            }
1936    
1937            /**
1938            * Updates the priority of the layout matching the primary key.
1939            *
1940            * @param plid the primary key of the layout
1941            * @param priority the layout's new priority
1942            * @return the updated layout
1943            * @throws PortalException if a layout with the primary key could not be
1944            found
1945            * @throws SystemException if a system exception occurred
1946            */
1947            @Override
1948            public com.liferay.portal.model.Layout updatePriority(long plid,
1949                    int priority)
1950                    throws com.liferay.portal.kernel.exception.PortalException,
1951                            com.liferay.portal.kernel.exception.SystemException {
1952                    return _layoutLocalService.updatePriority(plid, priority);
1953            }
1954    
1955            /**
1956            * @deprecated As of 6.2.0, with no direct replacement
1957            */
1958            @Override
1959            public void updateScopedPortletNames(long groupId, boolean privateLayout,
1960                    long layoutId,
1961                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
1962                    java.util.List<java.util.Locale> nameMapModifiedLocales)
1963                    throws com.liferay.portal.kernel.exception.PortalException,
1964                            com.liferay.portal.kernel.exception.SystemException {
1965                    _layoutLocalService.updateScopedPortletNames(groupId, privateLayout,
1966                            layoutId, nameMap, nameMapModifiedLocales);
1967            }
1968    
1969            /**
1970            * Updates the names of the portlets within scope of the group, the scope of
1971            * the layout's UUID, and the privacy.
1972            *
1973            * @param groupId the primary key of the group
1974            * @param privateLayout whether the layout is private to the group
1975            * @param layoutId the primary key of the layout whose UUID to match
1976            * @param name the new name for the portlets
1977            * @param languageId the primary key of the language
1978            * @throws PortalException if a matching layout could not be found
1979            * @throws SystemException if a system exception occurred
1980            * @see com.liferay.portlet.portletconfiguration.action.EditScopeAction
1981            * @deprecated As of 6.2.0, with no direct replacement
1982            */
1983            @Override
1984            public void updateScopedPortletNames(long groupId, boolean privateLayout,
1985                    long layoutId, java.lang.String name, java.lang.String languageId)
1986                    throws com.liferay.portal.kernel.exception.PortalException,
1987                            com.liferay.portal.kernel.exception.SystemException {
1988                    _layoutLocalService.updateScopedPortletNames(groupId, privateLayout,
1989                            layoutId, name, languageId);
1990            }
1991    
1992            @Override
1993            public com.liferay.portal.kernel.lar.MissingReferences validateImportLayoutsFile(
1994                    long userId, long groupId, boolean privateLayout,
1995                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
1996                    java.io.File file)
1997                    throws com.liferay.portal.kernel.exception.PortalException,
1998                            com.liferay.portal.kernel.exception.SystemException {
1999                    return _layoutLocalService.validateImportLayoutsFile(userId, groupId,
2000                            privateLayout, parameterMap, file);
2001            }
2002    
2003            @Override
2004            public com.liferay.portal.kernel.lar.MissingReferences validateImportLayoutsFile(
2005                    long userId, long groupId, boolean privateLayout,
2006                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
2007                    java.io.InputStream inputStream)
2008                    throws com.liferay.portal.kernel.exception.PortalException,
2009                            com.liferay.portal.kernel.exception.SystemException {
2010                    return _layoutLocalService.validateImportLayoutsFile(userId, groupId,
2011                            privateLayout, parameterMap, inputStream);
2012            }
2013    
2014            @Override
2015            public com.liferay.portal.kernel.lar.MissingReferences validateImportPortletInfo(
2016                    long userId, long plid, long groupId, java.lang.String portletId,
2017                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
2018                    java.io.File file)
2019                    throws com.liferay.portal.kernel.exception.PortalException,
2020                            com.liferay.portal.kernel.exception.SystemException {
2021                    return _layoutLocalService.validateImportPortletInfo(userId, plid,
2022                            groupId, portletId, parameterMap, file);
2023            }
2024    
2025            @Override
2026            public com.liferay.portal.kernel.lar.MissingReferences validateImportPortletInfo(
2027                    long userId, long plid, long groupId, java.lang.String portletId,
2028                    java.util.Map<java.lang.String, java.lang.String[]> parameterMap,
2029                    java.io.InputStream inputStream)
2030                    throws com.liferay.portal.kernel.exception.PortalException,
2031                            com.liferay.portal.kernel.exception.SystemException {
2032                    return _layoutLocalService.validateImportPortletInfo(userId, plid,
2033                            groupId, portletId, parameterMap, inputStream);
2034            }
2035    
2036            /**
2037             * @deprecated As of 6.1.0, replaced by {@link #getWrappedService}
2038             */
2039            public LayoutLocalService getWrappedLayoutLocalService() {
2040                    return _layoutLocalService;
2041            }
2042    
2043            /**
2044             * @deprecated As of 6.1.0, replaced by {@link #setWrappedService}
2045             */
2046            public void setWrappedLayoutLocalService(
2047                    LayoutLocalService layoutLocalService) {
2048                    _layoutLocalService = layoutLocalService;
2049            }
2050    
2051            @Override
2052            public LayoutLocalService getWrappedService() {
2053                    return _layoutLocalService;
2054            }
2055    
2056            @Override
2057            public void setWrappedService(LayoutLocalService layoutLocalService) {
2058                    _layoutLocalService = layoutLocalService;
2059            }
2060    
2061            private LayoutLocalService _layoutLocalService;
2062    }