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