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.exception.PortalException;
020    import com.liferay.portal.kernel.exception.SystemException;
021    import com.liferay.portal.kernel.search.IndexableType;
022    import com.liferay.portal.kernel.transaction.Isolation;
023    import com.liferay.portal.kernel.transaction.Propagation;
024    import com.liferay.portal.kernel.transaction.Transactional;
025    
026    /**
027     * Provides the local service interface for Group. Methods of this
028     * service will not have security checks based on the propagated JAAS
029     * credentials because this service can only be accessed from within the same
030     * VM.
031     *
032     * @author Brian Wing Shun Chan
033     * @see GroupLocalServiceUtil
034     * @see com.liferay.portal.service.base.GroupLocalServiceBaseImpl
035     * @see com.liferay.portal.service.impl.GroupLocalServiceImpl
036     * @generated
037     */
038    @ProviderType
039    @Transactional(isolation = Isolation.PORTAL, rollbackFor =  {
040            PortalException.class, SystemException.class})
041    public interface GroupLocalService extends BaseLocalService,
042            PersistedModelLocalService {
043            /*
044             * NOTE FOR DEVELOPERS:
045             *
046             * Never modify or reference this interface directly. Always use {@link GroupLocalServiceUtil} to access the group local service. Add custom service methods to {@link com.liferay.portal.service.impl.GroupLocalServiceImpl} and rerun ServiceBuilder to automatically copy the method declarations to this interface.
047             */
048    
049            /**
050            * Adds the group to the database. Also notifies the appropriate model listeners.
051            *
052            * @param group the group
053            * @return the group that was added
054            */
055            @com.liferay.portal.kernel.search.Indexable(type = IndexableType.REINDEX)
056            public com.liferay.portal.model.Group addGroup(
057                    com.liferay.portal.model.Group group);
058    
059            /**
060            * Adds a group.
061            *
062            * @param userId the primary key of the group's creator/owner
063            * @param className the entity's class name
064            * @param classPK the primary key of the entity's instance
065            * @param liveGroupId the primary key of the live group
066            * @param name the entity's name
067            * @param description the group's description (optionally
068            <code>null</code>)
069            * @param type the group's type. For more information see {@link
070            GroupConstants}.
071            * @param friendlyURL the group's friendlyURL (optionally
072            <code>null</code>)
073            * @param site whether the group is to be associated with a main site
074            * @param active whether the group is active
075            * @param serviceContext the service context to be applied (optionally
076            <code>null</code>). Can set asset category IDs and asset tag
077            names for the group, and whether the group is for staging.
078            * @return the group
079            * @deprecated As of 6.2.0, replaced by {@link #addGroup(long, long, String,
080            long, long, Map, Map, int, boolean, int, String, boolean,
081            boolean, ServiceContext)}
082            */
083            @java.lang.Deprecated
084            public com.liferay.portal.model.Group addGroup(long userId,
085                    java.lang.String className, long classPK, long liveGroupId,
086                    java.lang.String name, java.lang.String description, int type,
087                    java.lang.String friendlyURL, boolean site, boolean active,
088                    com.liferay.portal.service.ServiceContext serviceContext)
089                    throws PortalException;
090    
091            /**
092            * Adds the group using the default live group.
093            *
094            * @param userId the primary key of the group's creator/owner
095            * @param className the entity's class name
096            * @param classPK the primary key of the entity's instance
097            * @param name the entity's name
098            * @param description the group's description (optionally
099            <code>null</code>)
100            * @param type the group's type. For more information see {@link
101            GroupConstants}.
102            * @param friendlyURL the group's friendlyURL
103            * @param site whether the group is to be associated with a main site
104            * @param active whether the group is active
105            * @param serviceContext the service context to be applied (optionally
106            <code>null</code>). Can set asset category IDs and asset tag
107            names for the group, and whether the group is for staging.
108            * @return the group
109            * @deprecated As of 6.2.0, replaced by {@link #addGroup(long, long, String,
110            long, long, Map, Map, int, boolean, int, String, boolean,
111            boolean, ServiceContext)}
112            */
113            @java.lang.Deprecated
114            public com.liferay.portal.model.Group addGroup(long userId,
115                    java.lang.String className, long classPK, java.lang.String name,
116                    java.lang.String description, int type, java.lang.String friendlyURL,
117                    boolean site, boolean active,
118                    com.liferay.portal.service.ServiceContext serviceContext)
119                    throws PortalException;
120    
121            /**
122            * Adds a group.
123            *
124            * @param userId the primary key of the group's creator/owner
125            * @param parentGroupId the primary key of the parent group
126            * @param className the entity's class name
127            * @param classPK the primary key of the entity's instance
128            * @param liveGroupId the primary key of the live group
129            * @param name the entity's name
130            * @param description the group's description (optionally
131            <code>null</code>)
132            * @param type the group's type. For more information see {@link
133            GroupConstants}.
134            * @param manualMembership whether manual membership is allowed for the
135            group
136            * @param membershipRestriction the group's membership restriction. For
137            more information see {@link GroupConstants}.
138            * @param friendlyURL the group's friendlyURL (optionally
139            <code>null</code>)
140            * @param site whether the group is to be associated with a main site
141            * @param active whether the group is active
142            * @param serviceContext the service context to be applied (optionally
143            <code>null</code>). Can set asset category IDs and asset tag
144            names for the group, and whether the group is for staging.
145            * @return the group
146            * @deprecated As of 7.0.0, replaced by {@link #addGroup(long, long, String,
147            long, long, Map, Map, int, boolean, int, String, boolean,
148            boolean, ServiceContext)}
149            */
150            @java.lang.Deprecated
151            public com.liferay.portal.model.Group addGroup(long userId,
152                    long parentGroupId, java.lang.String className, long classPK,
153                    long liveGroupId, java.lang.String name, java.lang.String description,
154                    int type, boolean manualMembership, int membershipRestriction,
155                    java.lang.String friendlyURL, boolean site, boolean active,
156                    com.liferay.portal.service.ServiceContext serviceContext)
157                    throws PortalException;
158    
159            public com.liferay.portal.model.Group addGroup(long userId,
160                    long parentGroupId, java.lang.String className, long classPK,
161                    long liveGroupId,
162                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
163                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
164                    int type, boolean manualMembership, int membershipRestriction,
165                    java.lang.String friendlyURL, boolean site, boolean active,
166                    com.liferay.portal.service.ServiceContext serviceContext)
167                    throws PortalException;
168    
169            public com.liferay.portal.model.Group addGroup(long userId,
170                    long parentGroupId, java.lang.String className, long classPK,
171                    long liveGroupId,
172                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
173                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
174                    int type, boolean manualMembership, int membershipRestriction,
175                    java.lang.String friendlyURL, boolean site, boolean inheritContent,
176                    boolean active, com.liferay.portal.service.ServiceContext serviceContext)
177                    throws PortalException;
178    
179            /**
180            * Adds the group using the default live group.
181            *
182            * @param userId the primary key of the group's creator/owner
183            * @param parentGroupId the primary key of the parent group
184            * @param className the entity's class name
185            * @param classPK the primary key of the entity's instance
186            * @param name the entity's name
187            * @param description the group's description (optionally
188            <code>null</code>)
189            * @param type the group's type. For more information see {@link
190            GroupConstants}.
191            * @param friendlyURL the group's friendlyURL
192            * @param site whether the group is to be associated with a main site
193            * @param active whether the group is active
194            * @param serviceContext the service context to be applied (optionally
195            <code>null</code>). Can set asset category IDs and asset tag
196            names for the group, and whether the group is for staging.
197            * @return the group
198            * @deprecated As of 6.2.0, replaced by {@link #addGroup(long, long, String,
199            long, long, Map, Map, int, boolean, int, String, boolean,
200            boolean, ServiceContext)}
201            */
202            @java.lang.Deprecated
203            public com.liferay.portal.model.Group addGroup(long userId,
204                    long parentGroupId, java.lang.String className, long classPK,
205                    java.lang.String name, java.lang.String description, int type,
206                    java.lang.String friendlyURL, boolean site, boolean active,
207                    com.liferay.portal.service.ServiceContext serviceContext)
208                    throws PortalException;
209    
210            public void addOrganizationGroup(long organizationId,
211                    com.liferay.portal.model.Group group);
212    
213            public void addOrganizationGroup(long organizationId, long groupId);
214    
215            public void addOrganizationGroups(long organizationId,
216                    java.util.List<com.liferay.portal.model.Group> Groups);
217    
218            public void addOrganizationGroups(long organizationId, long[] groupIds);
219    
220            public void addRoleGroup(long roleId, com.liferay.portal.model.Group group);
221    
222            public void addRoleGroup(long roleId, long groupId);
223    
224            public void addRoleGroups(long roleId,
225                    java.util.List<com.liferay.portal.model.Group> Groups);
226    
227            public void addRoleGroups(long roleId, long[] groupIds);
228    
229            public void addUserGroup(long userId, com.liferay.portal.model.Group group);
230    
231            public void addUserGroup(long userId, long groupId);
232    
233            public void addUserGroupGroup(long userGroupId,
234                    com.liferay.portal.model.Group group);
235    
236            public void addUserGroupGroup(long userGroupId, long groupId);
237    
238            public void addUserGroupGroups(long userGroupId,
239                    java.util.List<com.liferay.portal.model.Group> Groups);
240    
241            public void addUserGroupGroups(long userGroupId, long[] groupIds);
242    
243            public void addUserGroups(long userId,
244                    java.util.List<com.liferay.portal.model.Group> Groups);
245    
246            public void addUserGroups(long userId, long[] groupIds);
247    
248            /**
249            * Adds a company group if it does not exist. This method is typically used
250            * when a virtual host is added.
251            *
252            * @param companyId the primary key of the company
253            */
254            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
255            public void checkCompanyGroup(long companyId) throws PortalException;
256    
257            /**
258            * Creates systems groups and other related data needed by the system on the
259            * very first startup. Also takes care of creating the Control Panel groups
260            * and layouts.
261            *
262            * @param companyId the primary key of the company
263            */
264            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
265            public void checkSystemGroups(long companyId) throws PortalException;
266    
267            public void clearOrganizationGroups(long organizationId);
268    
269            public void clearRoleGroups(long roleId);
270    
271            public void clearUserGroupGroups(long userGroupId);
272    
273            public void clearUserGroups(long userId);
274    
275            /**
276            * Creates a new group with the primary key. Does not add the group to the database.
277            *
278            * @param groupId the primary key for the new group
279            * @return the new group
280            */
281            public com.liferay.portal.model.Group createGroup(long groupId);
282    
283            /**
284            * Deletes the group from the database. Also notifies the appropriate model listeners.
285            *
286            * @param group the group
287            * @return the group that was removed
288            * @throws PortalException
289            */
290            @com.liferay.portal.kernel.search.Indexable(type = IndexableType.DELETE)
291            public com.liferay.portal.model.Group deleteGroup(
292                    com.liferay.portal.model.Group group) throws PortalException;
293    
294            /**
295            * Deletes the group with the primary key from the database. Also notifies the appropriate model listeners.
296            *
297            * @param groupId the primary key of the group
298            * @return the group that was removed
299            * @throws PortalException if a group with the primary key could not be found
300            */
301            @com.liferay.portal.kernel.search.Indexable(type = IndexableType.DELETE)
302            public com.liferay.portal.model.Group deleteGroup(long groupId)
303                    throws PortalException;
304    
305            public void deleteOrganizationGroup(long organizationId,
306                    com.liferay.portal.model.Group group);
307    
308            public void deleteOrganizationGroup(long organizationId, long groupId);
309    
310            public void deleteOrganizationGroups(long organizationId,
311                    java.util.List<com.liferay.portal.model.Group> Groups);
312    
313            public void deleteOrganizationGroups(long organizationId, long[] groupIds);
314    
315            /**
316            * @throws PortalException
317            */
318            @Override
319            public com.liferay.portal.model.PersistedModel deletePersistedModel(
320                    com.liferay.portal.model.PersistedModel persistedModel)
321                    throws PortalException;
322    
323            public void deleteRoleGroup(long roleId,
324                    com.liferay.portal.model.Group group);
325    
326            public void deleteRoleGroup(long roleId, long groupId);
327    
328            public void deleteRoleGroups(long roleId,
329                    java.util.List<com.liferay.portal.model.Group> Groups);
330    
331            public void deleteRoleGroups(long roleId, long[] groupIds);
332    
333            public void deleteUserGroup(long userId,
334                    com.liferay.portal.model.Group group);
335    
336            public void deleteUserGroup(long userId, long groupId);
337    
338            public void deleteUserGroupGroup(long userGroupId,
339                    com.liferay.portal.model.Group group);
340    
341            public void deleteUserGroupGroup(long userGroupId, long groupId);
342    
343            public void deleteUserGroupGroups(long userGroupId,
344                    java.util.List<com.liferay.portal.model.Group> Groups);
345    
346            public void deleteUserGroupGroups(long userGroupId, long[] groupIds);
347    
348            public void deleteUserGroups(long userId,
349                    java.util.List<com.liferay.portal.model.Group> Groups);
350    
351            public void deleteUserGroups(long userId, long[] groupIds);
352    
353            public void disableStaging(long groupId) throws PortalException;
354    
355            public com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery();
356    
357            /**
358            * Performs a dynamic query on the database and returns the matching rows.
359            *
360            * @param dynamicQuery the dynamic query
361            * @return the matching rows
362            */
363            public <T> java.util.List<T> dynamicQuery(
364                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery);
365    
366            /**
367            * Performs a dynamic query on the database and returns a range of the matching rows.
368            *
369            * <p>
370            * 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.GroupModelImpl}. 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.
371            * </p>
372            *
373            * @param dynamicQuery the dynamic query
374            * @param start the lower bound of the range of model instances
375            * @param end the upper bound of the range of model instances (not inclusive)
376            * @return the range of matching rows
377            */
378            public <T> java.util.List<T> dynamicQuery(
379                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start,
380                    int end);
381    
382            /**
383            * Performs a dynamic query on the database and returns an ordered range of the matching rows.
384            *
385            * <p>
386            * 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.GroupModelImpl}. 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.
387            * </p>
388            *
389            * @param dynamicQuery the dynamic query
390            * @param start the lower bound of the range of model instances
391            * @param end the upper bound of the range of model instances (not inclusive)
392            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
393            * @return the ordered range of matching rows
394            */
395            public <T> java.util.List<T> dynamicQuery(
396                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start,
397                    int end,
398                    com.liferay.portal.kernel.util.OrderByComparator<T> orderByComparator);
399    
400            /**
401            * Returns the number of rows matching the dynamic query.
402            *
403            * @param dynamicQuery the dynamic query
404            * @return the number of rows matching the dynamic query
405            */
406            public long dynamicQueryCount(
407                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery);
408    
409            /**
410            * Returns the number of rows matching the dynamic query.
411            *
412            * @param dynamicQuery the dynamic query
413            * @param projection the projection to apply to the query
414            * @return the number of rows matching the dynamic query
415            */
416            public long dynamicQueryCount(
417                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery,
418                    com.liferay.portal.kernel.dao.orm.Projection projection);
419    
420            public void enableStaging(long groupId) throws PortalException;
421    
422            /**
423            * Returns the company's group.
424            *
425            * @param companyId the primary key of the company
426            * @return the company's group, or <code>null</code> if a matching group
427            could not be found
428            */
429            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
430            public com.liferay.portal.model.Group fetchCompanyGroup(long companyId);
431    
432            /**
433            * Returns the group with the matching friendly URL.
434            *
435            * @param companyId the primary key of the company
436            * @param friendlyURL the friendly URL
437            * @return the group with the friendly URL, or <code>null</code> if a
438            matching group could not be found
439            */
440            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
441            public com.liferay.portal.model.Group fetchFriendlyURLGroup(
442                    long companyId, java.lang.String friendlyURL);
443    
444            /**
445            * Returns the group with the matching group key by first searching the
446            * system groups and then using the finder cache.
447            *
448            * @param companyId the primary key of the company
449            * @param groupKey the group key
450            * @return the group with the group key and associated company, or
451            <code>null</code> if a matching group could not be found
452            */
453            @com.liferay.portal.kernel.spring.aop.Skip
454            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
455            public com.liferay.portal.model.Group fetchGroup(long companyId,
456                    java.lang.String groupKey);
457    
458            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
459            public com.liferay.portal.model.Group fetchGroup(long groupId);
460    
461            /**
462            * Returns the group with the matching UUID and company.
463            *
464            * @param uuid the group's UUID
465            * @param companyId the primary key of the company
466            * @return the matching group, or <code>null</code> if a matching group could not be found
467            */
468            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
469            public com.liferay.portal.model.Group fetchGroupByUuidAndCompanyId(
470                    java.lang.String uuid, long companyId);
471    
472            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
473            public com.liferay.portal.model.Group fetchUserGroup(long companyId,
474                    long userId);
475    
476            /**
477            * Returns the default user's personal site group.
478            *
479            * @param companyId the primary key of the company
480            * @return the default user's personal site group, or <code>null</code> if a
481            matching group could not be found
482            */
483            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
484            public com.liferay.portal.model.Group fetchUserPersonalSiteGroup(
485                    long companyId) throws PortalException;
486    
487            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
488            public com.liferay.portal.kernel.dao.orm.ActionableDynamicQuery getActionableDynamicQuery();
489    
490            /**
491            * Returns the company group.
492            *
493            * @param companyId the primary key of the company
494            * @return the group associated with the company
495            */
496            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
497            public com.liferay.portal.model.Group getCompanyGroup(long companyId)
498                    throws PortalException;
499    
500            /**
501            * Returns a range of all the groups associated with the company.
502            *
503            * <p>
504            * Useful when paginating results. Returns a maximum of <code>end -
505            * start</code> instances. <code>start</code> and <code>end</code> are not
506            * primary keys, they are indexes in the result set. Thus, <code>0</code>
507            * refers to the first result in the set. Setting both <code>start</code>
508            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
509            * result set.
510            * </p>
511            *
512            * @param companyId the primary key of the company
513            * @param start the lower bound of the range of groups to return
514            * @param end the upper bound of the range of groups to return (not
515            inclusive)
516            * @return the range of groups associated with the company
517            */
518            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
519            public java.util.List<com.liferay.portal.model.Group> getCompanyGroups(
520                    long companyId, int start, int end);
521    
522            /**
523            * Returns the number of groups associated with the company.
524            *
525            * @param companyId the primary key of the company
526            * @return the number of groups associated with the company
527            */
528            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
529            public int getCompanyGroupsCount(long companyId);
530    
531            /**
532            * Returns the group with the matching friendly URL.
533            *
534            * @param companyId the primary key of the company
535            * @param friendlyURL the group's friendlyURL
536            * @return the group with the friendly URL
537            */
538            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
539            public com.liferay.portal.model.Group getFriendlyURLGroup(long companyId,
540                    java.lang.String friendlyURL) throws PortalException;
541    
542            /**
543            * Returns the group with the matching group key.
544            *
545            * @param companyId the primary key of the company
546            * @param groupKey the group key
547            * @return the group with the group key
548            */
549            @com.liferay.portal.kernel.spring.aop.Skip
550            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
551            public com.liferay.portal.model.Group getGroup(long companyId,
552                    java.lang.String groupKey) throws PortalException;
553    
554            /**
555            * Returns the group with the primary key.
556            *
557            * @param groupId the primary key of the group
558            * @return the group
559            * @throws PortalException if a group with the primary key could not be found
560            */
561            @com.liferay.portal.kernel.cache.thread.local.ThreadLocalCachable
562            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
563            public com.liferay.portal.model.Group getGroup(long groupId)
564                    throws PortalException;
565    
566            /**
567            * Returns the group with the matching UUID and company.
568            *
569            * @param uuid the group's UUID
570            * @param companyId the primary key of the company
571            * @return the matching group
572            * @throws PortalException if a matching group could not be found
573            */
574            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
575            public com.liferay.portal.model.Group getGroupByUuidAndCompanyId(
576                    java.lang.String uuid, long companyId) throws PortalException;
577    
578            /**
579            * @deprecated As of 7.0.0, replaced by {@link
580            Group#getDescriptiveName(Locale)}
581            */
582            @java.lang.Deprecated
583            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
584            public java.lang.String getGroupDescriptiveName(
585                    com.liferay.portal.model.Group group, java.util.Locale locale)
586                    throws PortalException;
587    
588            /**
589            * @deprecated As of 7.0.0, replaced by {@link
590            Group#getDescriptiveName(Locale)}
591            */
592            @java.lang.Deprecated
593            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
594            public java.lang.String getGroupDescriptiveName(long groupId,
595                    java.util.Locale locale) throws PortalException;
596    
597            /**
598            * Returns all the groups that are direct children of the parent group with
599            * the matching className.
600            *
601            * @param companyId the primary key of the company
602            * @param className the class name of the group
603            * @param parentGroupId the primary key of the parent group
604            * @return the matching groups, or <code>null</code> if no matches were
605            found
606            */
607            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
608            public java.util.List<com.liferay.portal.model.Group> getGroups(
609                    long companyId, java.lang.String className, long parentGroupId);
610    
611            /**
612            * Returns a range of all the groups that are direct children of the parent
613            * group with the matching className.
614            *
615            * @param companyId the primary key of the company
616            * @param className the class name of the group
617            * @param parentGroupId the primary key of the parent group
618            * @param start the lower bound of the range of results
619            * @param end the upper bound of the range of results (not inclusive)
620            * @return the range of matching groups
621            */
622            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
623            public java.util.List<com.liferay.portal.model.Group> getGroups(
624                    long companyId, java.lang.String className, long parentGroupId,
625                    int start, int end);
626    
627            /**
628            * Returns all the groups that are direct children of the parent group.
629            *
630            * @param companyId the primary key of the company
631            * @param parentGroupId the primary key of the parent group
632            * @param site whether the group is to be associated with a main site
633            * @return the matching groups, or <code>null</code> if no matches were
634            found
635            */
636            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
637            public java.util.List<com.liferay.portal.model.Group> getGroups(
638                    long companyId, long parentGroupId, boolean site);
639    
640            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
641            public java.util.List<com.liferay.portal.model.Group> getGroups(
642                    long companyId, long parentGroupId, boolean site, boolean inheritContent);
643    
644            /**
645            * Returns the groups with the matching primary keys.
646            *
647            * @param groupIds the primary keys of the groups
648            * @return the groups with the primary keys
649            */
650            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
651            public java.util.List<com.liferay.portal.model.Group> getGroups(
652                    long[] groupIds) throws PortalException;
653    
654            /**
655            * Returns a range of all the groups.
656            *
657            * <p>
658            * 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.GroupModelImpl}. 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.
659            * </p>
660            *
661            * @param start the lower bound of the range of groups
662            * @param end the upper bound of the range of groups (not inclusive)
663            * @return the range of groups
664            */
665            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
666            public java.util.List<com.liferay.portal.model.Group> getGroups(int start,
667                    int end);
668    
669            /**
670            * Returns the number of groups.
671            *
672            * @return the number of groups
673            */
674            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
675            public int getGroupsCount();
676    
677            /**
678            * Returns the number of groups that are direct children of the parent group
679            * with the matching className.
680            *
681            * @param companyId the primary key of the company
682            * @param className the class name of the group
683            * @param parentGroupId the primary key of the parent group
684            * @return the number of matching groups
685            */
686            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
687            public int getGroupsCount(long companyId, java.lang.String className,
688                    long parentGroupId);
689    
690            /**
691            * Returns the number of groups that are direct children of the parent
692            * group.
693            *
694            * @param companyId the primary key of the company
695            * @param parentGroupId the primary key of the parent group
696            * @param site whether the group is to be associated with a main site
697            * @return the number of matching groups
698            */
699            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
700            public int getGroupsCount(long companyId, long parentGroupId, boolean site);
701    
702            /**
703            * Returns the group associated with the layout.
704            *
705            * @param companyId the primary key of the company
706            * @param plid the primary key of the layout
707            * @return the group associated with the layout
708            */
709            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
710            public com.liferay.portal.model.Group getLayoutGroup(long companyId,
711                    long plid) throws PortalException;
712    
713            /**
714            * Returns the group associated with the layout prototype.
715            *
716            * @param companyId the primary key of the company
717            * @param layoutPrototypeId the primary key of the layout prototype
718            * @return the group associated with the layout prototype
719            */
720            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
721            public com.liferay.portal.model.Group getLayoutPrototypeGroup(
722                    long companyId, long layoutPrototypeId) throws PortalException;
723    
724            /**
725            * Returns the group associated with the layout set prototype.
726            *
727            * @param companyId the primary key of the company
728            * @param layoutSetPrototypeId the primary key of the layout set prototype
729            * @return the group associated with the layout set prototype
730            */
731            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
732            public com.liferay.portal.model.Group getLayoutSetPrototypeGroup(
733                    long companyId, long layoutSetPrototypeId) throws PortalException;
734    
735            /**
736            * Returns a range of all groups that are children of the parent group and
737            * that have at least one layout.
738            *
739            * <p>
740            * Useful when paginating results. Returns a maximum of <code>end -
741            * start</code> instances. <code>start</code> and <code>end</code> are not
742            * primary keys, they are indexes in the result set. Thus, <code>0</code>
743            * refers to the first result in the set. Setting both <code>start</code>
744            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
745            * result set.
746            * </p>
747            *
748            * @param companyId the primary key of the company
749            * @param parentGroupId the primary key of the parent group
750            * @param site whether the group is to be associated with a main site
751            * @param start the lower bound of the range of groups to return
752            * @param end the upper bound of the range of groups to return (not
753            inclusive)
754            * @return the range of matching groups
755            * @deprecated As of 6.2.0, replaced by {@link #getLayoutsGroups(long, long,
756            boolean, int, int, OrderByComparator)}
757            */
758            @java.lang.Deprecated
759            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
760            public java.util.List<com.liferay.portal.model.Group> getLayoutsGroups(
761                    long companyId, long parentGroupId, boolean site, int start, int end);
762    
763            /**
764            * Returns a range of all groups that are children of the parent group and
765            * that have at least one layout.
766            *
767            * <p>
768            * Useful when paginating results. Returns a maximum of <code>end -
769            * start</code> instances. <code>start</code> and <code>end</code> are not
770            * primary keys, they are indexes in the result set. Thus, <code>0</code>
771            * refers to the first result in the set. Setting both <code>start</code>
772            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
773            * result set.
774            * </p>
775            *
776            * @param companyId the primary key of the company
777            * @param parentGroupId the primary key of the parent group
778            * @param site whether the group is to be associated with a main site
779            * @param start the lower bound of the range of groups to return
780            * @param end the upper bound of the range of groups to return (not
781            inclusive)
782            * @param obc the comparator to order the groups (optionally
783            <code>null</code>)
784            * @return the range of matching groups ordered by comparator
785            <code>obc</code>
786            */
787            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
788            public java.util.List<com.liferay.portal.model.Group> getLayoutsGroups(
789                    long companyId, long parentGroupId, boolean site, int start, int end,
790                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> obc);
791    
792            /**
793            * Returns the number of groups that are children or the parent group and
794            * that have at least one layout
795            *
796            * @param companyId the primary key of the company
797            * @param parentGroupId the primary key of the parent group
798            * @param site whether the group is to be associated with a main site
799            * @return the number of matching groups
800            */
801            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
802            public int getLayoutsGroupsCount(long companyId, long parentGroupId,
803                    boolean site);
804    
805            /**
806            * Returns all live groups.
807            *
808            * @return all live groups
809            */
810            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
811            public java.util.List<com.liferay.portal.model.Group> getLiveGroups();
812    
813            /**
814            * Returns a range of all non-system groups of a specified type (className)
815            * that have no layouts.
816            *
817            * <p>
818            * Useful when paginating results. Returns a maximum of <code>end -
819            * start</code> instances. <code>start</code> and <code>end</code> are not
820            * primary keys, they are indexes in the result set. Thus, <code>0</code>
821            * refers to the first result in the set. Setting both <code>start</code>
822            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
823            * result set.
824            * </p>
825            *
826            * @param className the entity's class name
827            * @param privateLayout whether to include groups with private layout sets
828            or non-private layout sets
829            * @param start the lower bound of the range of groups to return
830            * @param end the upper bound of the range of groups to return (not
831            inclusive)
832            * @return the range of matching groups
833            */
834            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
835            public java.util.List<com.liferay.portal.model.Group> getNoLayoutsGroups(
836                    java.lang.String className, boolean privateLayout, int start, int end);
837    
838            /**
839            * Returns all non-system groups having <code>null</code> or empty friendly
840            * URLs.
841            *
842            * @return the non-system groups having <code>null</code> or empty friendly
843            URLs
844            */
845            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
846            public java.util.List<com.liferay.portal.model.Group> getNullFriendlyURLGroups();
847    
848            /**
849            * Returns the OSGi service identifier.
850            *
851            * @return the OSGi service identifier
852            */
853            public java.lang.String getOSGiServiceIdentifier();
854    
855            /**
856            * Returns the specified organization group.
857            *
858            * @param companyId the primary key of the company
859            * @param organizationId the primary key of the organization
860            * @return the group associated with the organization
861            */
862            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
863            public com.liferay.portal.model.Group getOrganizationGroup(long companyId,
864                    long organizationId) throws PortalException;
865    
866            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
867            public java.util.List<com.liferay.portal.model.Group> getOrganizationGroups(
868                    long organizationId);
869    
870            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
871            public java.util.List<com.liferay.portal.model.Group> getOrganizationGroups(
872                    long organizationId, int start, int end);
873    
874            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
875            public java.util.List<com.liferay.portal.model.Group> getOrganizationGroups(
876                    long organizationId, int start, int end,
877                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> orderByComparator);
878    
879            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
880            public int getOrganizationGroupsCount(long organizationId);
881    
882            /**
883            * Returns the organizationIds of the organizations associated with the group.
884            *
885            * @param groupId the groupId of the group
886            * @return long[] the organizationIds of organizations associated with the group
887            */
888            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
889            public long[] getOrganizationPrimaryKeys(long groupId);
890    
891            /**
892            * Returns the specified organization groups.
893            *
894            * @param organizations the organizations
895            * @return the groups associated with the organizations
896            */
897            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
898            public java.util.List<com.liferay.portal.model.Group> getOrganizationsGroups(
899                    java.util.List<com.liferay.portal.model.Organization> organizations);
900    
901            /**
902            * Returns all the groups related to the organizations.
903            *
904            * @param organizations the organizations
905            * @return the groups related to the organizations
906            */
907            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
908            public java.util.List<com.liferay.portal.model.Group> getOrganizationsRelatedGroups(
909                    java.util.List<com.liferay.portal.model.Organization> organizations);
910    
911            /**
912            * Returns the group followed by all its parent groups ordered by closest
913            * ancestor.
914            *
915            * @param groupId the primary key of the group
916            * @return the group followed by all its parent groups ordered by closest
917            ancestor
918            */
919            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
920            public java.util.List<com.liferay.portal.model.Group> getParentGroups(
921                    long groupId) throws PortalException;
922    
923            @Override
924            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
925            public com.liferay.portal.model.PersistedModel getPersistedModel(
926                    java.io.Serializable primaryKeyObj) throws PortalException;
927    
928            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
929            public java.util.List<com.liferay.portal.model.Group> getRoleGroups(
930                    long roleId);
931    
932            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
933            public java.util.List<com.liferay.portal.model.Group> getRoleGroups(
934                    long roleId, int start, int end);
935    
936            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
937            public java.util.List<com.liferay.portal.model.Group> getRoleGroups(
938                    long roleId, int start, int end,
939                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> orderByComparator);
940    
941            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
942            public int getRoleGroupsCount(long roleId);
943    
944            /**
945            * Returns the roleIds of the roles associated with the group.
946            *
947            * @param groupId the groupId of the group
948            * @return long[] the roleIds of roles associated with the group
949            */
950            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
951            public long[] getRolePrimaryKeys(long groupId);
952    
953            /**
954            * Returns the staging group.
955            *
956            * @param liveGroupId the primary key of the live group
957            * @return the staging group
958            */
959            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
960            public com.liferay.portal.model.Group getStagingGroup(long liveGroupId)
961                    throws PortalException;
962    
963            /**
964            * Returns the group directly associated with the user.
965            *
966            * @param companyId the primary key of the company
967            * @param userId the primary key of the user
968            * @return the group directly associated with the user
969            */
970            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
971            public com.liferay.portal.model.Group getUserGroup(long companyId,
972                    long userId) throws PortalException;
973    
974            /**
975            * Returns the specified "user group" group. That is, the group that
976            * represents the {@link UserGroup} entity.
977            *
978            * @param companyId the primary key of the company
979            * @param userGroupId the primary key of the user group
980            * @return the group associated with the user group
981            */
982            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
983            public com.liferay.portal.model.Group getUserGroupGroup(long companyId,
984                    long userGroupId) throws PortalException;
985    
986            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
987            public java.util.List<com.liferay.portal.model.Group> getUserGroupGroups(
988                    long userGroupId);
989    
990            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
991            public java.util.List<com.liferay.portal.model.Group> getUserGroupGroups(
992                    long userGroupId, int start, int end);
993    
994            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
995            public java.util.List<com.liferay.portal.model.Group> getUserGroupGroups(
996                    long userGroupId, int start, int end,
997                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> orderByComparator);
998    
999            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1000            public int getUserGroupGroupsCount(long userGroupId);
1001    
1002            /**
1003            * Returns the userGroupIds of the user groups associated with the group.
1004            *
1005            * @param groupId the groupId of the group
1006            * @return long[] the userGroupIds of user groups associated with the group
1007            */
1008            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1009            public long[] getUserGroupPrimaryKeys(long groupId);
1010    
1011            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1012            public java.util.List<com.liferay.portal.model.Group> getUserGroups(
1013                    long userId);
1014    
1015            /**
1016            * Returns all the user's site groups and immediate organization groups,
1017            * optionally including the user's inherited organization groups and user
1018            * groups. System and staged groups are not included.
1019            *
1020            * @param userId the primary key of the user
1021            * @param inherit whether to include the user's inherited organization
1022            groups and user groups
1023            * @return the user's groups and immediate organization groups
1024            */
1025            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1026            public java.util.List<com.liferay.portal.model.Group> getUserGroups(
1027                    long userId, boolean inherit) throws PortalException;
1028    
1029            /**
1030            * Returns an ordered range of all the user's site groups and immediate
1031            * organization groups, optionally including the user's inherited
1032            * organization groups and user groups. System and staged groups are not
1033            * included.
1034            *
1035            * <p>
1036            * Useful when paginating results. Returns a maximum of <code>end -
1037            * start</code> instances. <code>start</code> and <code>end</code> are not
1038            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1039            * refers to the first result in the set. Setting both <code>start</code>
1040            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1041            * result set.
1042            * </p>
1043            *
1044            * @param userId the primary key of the user
1045            * @param inherit whether to include the user's inherited organization
1046            groups and user groups
1047            * @param start the lower bound of the range of groups to return
1048            * @param end the upper bound of the range of groups to return (not
1049            inclusive)
1050            * @return the range of the user's groups and immediate organization groups
1051            ordered by name
1052            */
1053            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1054            public java.util.List<com.liferay.portal.model.Group> getUserGroups(
1055                    long userId, boolean inherit, int start, int end)
1056                    throws PortalException;
1057    
1058            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1059            public java.util.List<com.liferay.portal.model.Group> getUserGroups(
1060                    long userId, int start, int end);
1061    
1062            /**
1063            * @throws PortalException
1064            */
1065            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1066            public java.util.List<com.liferay.portal.model.Group> getUserGroups(
1067                    long userId, int start, int end,
1068                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> orderByComparator)
1069                    throws PortalException;
1070    
1071            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1072            public int getUserGroupsCount(long userId);
1073    
1074            /**
1075            * Returns the groups associated with the user groups.
1076            *
1077            * @param userGroups the user groups
1078            * @return the groups associated with the user groups
1079            */
1080            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1081            public java.util.List<com.liferay.portal.model.Group> getUserGroupsGroups(
1082                    java.util.List<com.liferay.portal.model.UserGroup> userGroups)
1083                    throws PortalException;
1084    
1085            /**
1086            * Returns all the groups related to the user groups.
1087            *
1088            * @param userGroups the user groups
1089            * @return the groups related to the user groups
1090            */
1091            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1092            public java.util.List<com.liferay.portal.model.Group> getUserGroupsRelatedGroups(
1093                    java.util.List<com.liferay.portal.model.UserGroup> userGroups);
1094    
1095            /**
1096            * Returns the range of all groups associated with the user's organization
1097            * groups, including the ancestors of the organization groups, unless portal
1098            * property <code>organizations.membership.strict</code> is set to
1099            * <code>true</code>.
1100            *
1101            * <p>
1102            * Useful when paginating results. Returns a maximum of <code>end -
1103            * start</code> instances. <code>start</code> and <code>end</code> are not
1104            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1105            * refers to the first result in the set. Setting both <code>start</code>
1106            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1107            * result set.
1108            * </p>
1109            *
1110            * @param userId the primary key of the user
1111            * @param start the lower bound of the range of groups to consider
1112            * @param end the upper bound of the range of groups to consider (not
1113            inclusive)
1114            * @return the range of groups associated with the user's organization
1115            groups
1116            */
1117            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1118            public java.util.List<com.liferay.portal.model.Group> getUserOrganizationsGroups(
1119                    long userId, int start, int end) throws PortalException;
1120    
1121            /**
1122            * Returns the default user's personal site group.
1123            *
1124            * @param companyId the primary key of the company
1125            * @return the default user's personal site group
1126            */
1127            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1128            public com.liferay.portal.model.Group getUserPersonalSiteGroup(
1129                    long companyId) throws PortalException;
1130    
1131            /**
1132            * Returns the userIds of the users associated with the group.
1133            *
1134            * @param groupId the groupId of the group
1135            * @return long[] the userIds of users associated with the group
1136            */
1137            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1138            public long[] getUserPrimaryKeys(long groupId);
1139    
1140            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1141            public java.util.List<com.liferay.portal.model.Group> getUserSitesGroups(
1142                    long userId) throws PortalException;
1143    
1144            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1145            public java.util.List<com.liferay.portal.model.Group> getUserSitesGroups(
1146                    long userId, boolean includeAdministrative) throws PortalException;
1147    
1148            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1149            public boolean hasOrganizationGroup(long organizationId, long groupId);
1150    
1151            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1152            public boolean hasOrganizationGroups(long organizationId);
1153    
1154            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1155            public boolean hasRoleGroup(long roleId, long groupId);
1156    
1157            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1158            public boolean hasRoleGroups(long roleId);
1159    
1160            /**
1161            * Returns <code>true</code> if the live group has a staging group.
1162            *
1163            * @param liveGroupId the primary key of the live group
1164            * @return <code>true</code> if the live group has a staging group;
1165            <code>false</code> otherwise
1166            */
1167            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1168            public boolean hasStagingGroup(long liveGroupId);
1169    
1170            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1171            public boolean hasUserGroup(long userId, long groupId);
1172    
1173            /**
1174            * Returns <code>true</code> if the user is immediately associated with the
1175            * group, or optionally if the user is associated with the group via the
1176            * user's organizations, inherited organizations, or user groups.
1177            *
1178            * @param userId the primary key of the user
1179            * @param groupId the primary key of the group
1180            * @param inherit whether to include organization groups and user groups to
1181            which the user belongs in the determination
1182            * @return <code>true</code> if the user is associated with the group;
1183            <code>false</code> otherwise
1184            */
1185            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1186            public boolean hasUserGroup(long userId, long groupId, boolean inherit);
1187    
1188            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1189            public boolean hasUserGroupGroup(long userGroupId, long groupId);
1190    
1191            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1192            public boolean hasUserGroupGroups(long userGroupId);
1193    
1194            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1195            public boolean hasUserGroups(long userId);
1196    
1197            /**
1198            * Returns the group with the matching group key by first searching the
1199            * system groups and then using the finder cache.
1200            *
1201            * @param companyId the primary key of the company
1202            * @param groupKey the group key
1203            * @return the group with the group key and associated company, or
1204            <code>null</code> if a matching group could not be found
1205            */
1206            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1207            public com.liferay.portal.model.Group loadFetchGroup(long companyId,
1208                    java.lang.String groupKey);
1209    
1210            /**
1211            * Returns the group with the matching group key.
1212            *
1213            * @param companyId the primary key of the company
1214            * @param groupKey the group key
1215            * @return the group with the group key and associated company
1216            */
1217            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1218            public com.liferay.portal.model.Group loadGetGroup(long companyId,
1219                    java.lang.String groupKey) throws PortalException;
1220    
1221            /**
1222            * Rebuilds the group tree.
1223            *
1224            * <p>
1225            * Only call this method if the tree has become stale through operations
1226            * other than normal CRUD. Under normal circumstances the tree is
1227            * automatically rebuilt whenever necessary.
1228            * </p>
1229            *
1230            * @param companyId the primary key of the group's company
1231            */
1232            public void rebuildTree(long companyId) throws PortalException;
1233    
1234            /**
1235            * Returns an ordered range of all the groups that match the class name IDs
1236            * and keywords, optionally including the user's inherited organization
1237            * groups and user groups. System and staged groups are not included.
1238            *
1239            * <p>
1240            * Useful when paginating results. Returns a maximum of <code>end -
1241            * start</code> instances. <code>start</code> and <code>end</code> are not
1242            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1243            * refers to the first result in the set. Setting both <code>start</code>
1244            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1245            * result set.
1246            * </p>
1247            *
1248            * @param companyId the primary key of the company
1249            * @param classNameIds the primary keys of the class names of the entities
1250            the groups are related to (optionally <code>null</code>)
1251            * @param keywords the keywords (space separated), which may occur in the
1252            sites's name, or description (optionally <code>null</code>)
1253            * @param params the finder params (optionally <code>null</code>). To
1254            include a user's organizations, inherited organizations, and user
1255            groups in the search, add an entry with key
1256            &quot;usersGroups&quot; mapped to the user's ID and an entry with
1257            key &quot;inherit&quot; mapped to a non-<code>null</code> object.
1258            For more information see {@link
1259            com.liferay.portal.service.persistence.GroupFinder}.
1260            * @param start the lower bound of the range of groups to return
1261            * @param end the upper bound of the range of groups to return (not
1262            inclusive)
1263            * @return the matching groups ordered by name
1264            */
1265            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1266            public java.util.List<com.liferay.portal.model.Group> search(
1267                    long companyId, long[] classNameIds, java.lang.String keywords,
1268                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
1269                    int start, int end);
1270    
1271            /**
1272            * Returns an ordered range of all the groups that match the class name IDs
1273            * and keywords, optionally including the user's inherited organization
1274            * groups and user groups. System and staged groups are not included.
1275            *
1276            * <p>
1277            * Useful when paginating results. Returns a maximum of <code>end -
1278            * start</code> instances. <code>start</code> and <code>end</code> are not
1279            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1280            * refers to the first result in the set. Setting both <code>start</code>
1281            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1282            * result set.
1283            * </p>
1284            *
1285            * @param companyId the primary key of the company
1286            * @param classNameIds the primary keys of the class names of the entities
1287            the groups are related to (optionally <code>null</code>)
1288            * @param keywords the keywords (space separated), which may occur in the
1289            sites's name, or description (optionally <code>null</code>)
1290            * @param params the finder params (optionally <code>null</code>). To
1291            include a user's organizations, inherited organizations, and user
1292            groups in the search, add an entry with key
1293            &quot;usersGroups&quot; mapped to the user's ID and an entry with
1294            key &quot;inherit&quot; mapped to a non-<code>null</code> object.
1295            For more information see {@link
1296            com.liferay.portal.service.persistence.GroupFinder}.
1297            * @param start the lower bound of the range of groups to return
1298            * @param end the upper bound of the range of groups to return (not
1299            inclusive)
1300            * @param obc the comparator to order the groups (optionally
1301            <code>null</code>)
1302            * @return the matching groups ordered by comparator <code>obc</code>
1303            */
1304            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1305            public java.util.List<com.liferay.portal.model.Group> search(
1306                    long companyId, long[] classNameIds, java.lang.String keywords,
1307                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
1308                    int start, int end,
1309                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> obc);
1310    
1311            /**
1312            * Returns an ordered range of all the groups that match the class name IDs,
1313            * name, and description, optionally including the user's inherited
1314            * organization groups and user groups. System and staged groups are not
1315            * included.
1316            *
1317            * <p>
1318            * Useful when paginating results. Returns a maximum of <code>end -
1319            * start</code> instances. <code>start</code> and <code>end</code> are not
1320            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1321            * refers to the first result in the set. Setting both <code>start</code>
1322            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1323            * result set.
1324            * </p>
1325            *
1326            * @param companyId the primary key of the company
1327            * @param classNameIds the primary keys of the class names of the entities
1328            the groups are related to (optionally <code>null</code>)
1329            * @param name the group's name (optionally <code>null</code>)
1330            * @param description the group's description (optionally
1331            <code>null</code>)
1332            * @param params the finder params (optionally <code>null</code>). To
1333            include a user's organizations, inherited organizations, and user
1334            groups in the search, add an entry with key
1335            &quot;usersGroups&quot; mapped to the user's ID and an entry with
1336            key &quot;inherit&quot; mapped to a non-<code>null</code> object.
1337            For more information see {@link
1338            com.liferay.portal.service.persistence.GroupFinder}.
1339            * @param andOperator whether every field must match its keywords, or just
1340            one field.
1341            * @param start the lower bound of the range of groups to return
1342            * @param end the upper bound of the range of groups to return (not
1343            inclusive)
1344            * @return the matching groups ordered by name
1345            */
1346            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1347            public java.util.List<com.liferay.portal.model.Group> search(
1348                    long companyId, long[] classNameIds, java.lang.String name,
1349                    java.lang.String description,
1350                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
1351                    boolean andOperator, int start, int end);
1352    
1353            /**
1354            * Returns an ordered range of all the groups that match the class name IDs,
1355            * name, and description, optionally including the user's inherited
1356            * organization groups and user groups. System and staged groups are not
1357            * included.
1358            *
1359            * <p>
1360            * Useful when paginating results. Returns a maximum of <code>end -
1361            * start</code> instances. <code>start</code> and <code>end</code> are not
1362            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1363            * refers to the first result in the set. Setting both <code>start</code>
1364            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1365            * result set.
1366            * </p>
1367            *
1368            * @param companyId the primary key of the company
1369            * @param classNameIds the primary keys of the class names of the entities
1370            the groups are related to (optionally <code>null</code>)
1371            * @param name the group's name (optionally <code>null</code>)
1372            * @param description the group's description (optionally
1373            <code>null</code>)
1374            * @param params the finder params (optionally <code>null</code>). To
1375            include a user's organizations, inherited organizations, and user
1376            groups in the search, add an entry with key
1377            &quot;usersGroups&quot; mapped to the user's ID and an entry with
1378            key &quot;inherit&quot; mapped to a non-<code>null</code> object.
1379            For more information see {@link
1380            com.liferay.portal.service.persistence.GroupFinder}.
1381            * @param andOperator whether every field must match its keywords, or just
1382            one field.
1383            * @param start the lower bound of the range of groups to return
1384            * @param end the upper bound of the range of groups to return (not
1385            inclusive)
1386            * @param obc the comparator to order the groups (optionally
1387            <code>null</code>)
1388            * @return the matching groups ordered by comparator <code>obc</code>
1389            */
1390            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1391            public java.util.List<com.liferay.portal.model.Group> search(
1392                    long companyId, long[] classNameIds, java.lang.String name,
1393                    java.lang.String description,
1394                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
1395                    boolean andOperator, int start, int end,
1396                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> obc);
1397    
1398            /**
1399            * Returns an ordered range of all the groups belonging to the parent group
1400            * that match the class name IDs and keywords, optionally including the
1401            * user's inherited organization groups and user groups. System and staged
1402            * groups are not included.
1403            *
1404            * <p>
1405            * Useful when paginating results. Returns a maximum of <code>end -
1406            * start</code> instances. <code>start</code> and <code>end</code> are not
1407            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1408            * refers to the first result in the set. Setting both <code>start</code>
1409            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1410            * result set.
1411            * </p>
1412            *
1413            * @param companyId the primary key of the company
1414            * @param classNameIds the primary keys of the class names of the entities
1415            the groups are related to (optionally <code>null</code>)
1416            * @param parentGroupId the primary key of the parent group
1417            * @param keywords the keywords (space separated), which may occur in the
1418            sites's name, or description (optionally <code>null</code>)
1419            * @param params the finder params (optionally <code>null</code>). To
1420            include a user's organizations, inherited organizations, and user
1421            groups in the search, add an entry with key
1422            &quot;usersGroups&quot; mapped to the user's ID and an entry with
1423            key &quot;inherit&quot; mapped to a non-<code>null</code> object.
1424            For more information see {@link
1425            com.liferay.portal.service.persistence.GroupFinder}.
1426            * @param start the lower bound of the range of groups to return
1427            * @param end the upper bound of the range of groups to return (not
1428            inclusive)
1429            * @return the matching groups ordered by name
1430            */
1431            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1432            public java.util.List<com.liferay.portal.model.Group> search(
1433                    long companyId, long[] classNameIds, long parentGroupId,
1434                    java.lang.String keywords,
1435                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
1436                    int start, int end);
1437    
1438            /**
1439            * Returns an ordered range of all the groups belonging to the parent group
1440            * that match the class name IDs and keywords, optionally including the
1441            * user's inherited organization groups and user groups. System and staged
1442            * groups are not included.
1443            *
1444            * <p>
1445            * Useful when paginating results. Returns a maximum of <code>end -
1446            * start</code> instances. <code>start</code> and <code>end</code> are not
1447            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1448            * refers to the first result in the set. Setting both <code>start</code>
1449            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1450            * result set.
1451            * </p>
1452            *
1453            * @param companyId the primary key of the company
1454            * @param classNameIds the primary keys of the class names of the entities
1455            the groups are related to (optionally <code>null</code>)
1456            * @param parentGroupId the primary key of the parent group
1457            * @param keywords the keywords (space separated), which may occur in the
1458            sites's name, or description (optionally <code>null</code>)
1459            * @param params the finder params (optionally <code>null</code>). To
1460            include a user's organizations, inherited organizations, and user
1461            groups in the search, add an entry with key
1462            &quot;usersGroups&quot; mapped to the user's ID and an entry with
1463            key &quot;inherit&quot; mapped to a non-<code>null</code> object.
1464            For more information see {@link
1465            com.liferay.portal.service.persistence.GroupFinder}.
1466            * @param start the lower bound of the range of groups to return
1467            * @param end the upper bound of the range of groups to return (not
1468            inclusive)
1469            * @param obc the comparator to order the groups (optionally
1470            <code>null</code>)
1471            * @return the matching groups ordered by comparator <code>obc</code>
1472            */
1473            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1474            public java.util.List<com.liferay.portal.model.Group> search(
1475                    long companyId, long[] classNameIds, long parentGroupId,
1476                    java.lang.String keywords,
1477                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
1478                    int start, int end,
1479                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> obc);
1480    
1481            /**
1482            * Returns an ordered range of all the groups belonging to the parent group
1483            * that match the class name IDs, name, and description, optionally
1484            * including the user's inherited organization groups and user groups.
1485            * System and staged groups are not included.
1486            *
1487            * <p>
1488            * Useful when paginating results. Returns a maximum of <code>end -
1489            * start</code> instances. <code>start</code> and <code>end</code> are not
1490            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1491            * refers to the first result in the set. Setting both <code>start</code>
1492            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1493            * result set.
1494            * </p>
1495            *
1496            * @param companyId the primary key of the company
1497            * @param classNameIds the primary keys of the class names of the entities
1498            the groups are related to (optionally <code>null</code>)
1499            * @param parentGroupId the primary key of the parent group
1500            * @param name the group's name (optionally <code>null</code>)
1501            * @param description the group's description (optionally
1502            <code>null</code>)
1503            * @param params the finder params (optionally <code>null</code>). To
1504            include a user's organizations, inherited organizations, and user
1505            groups in the search, add an entry with key
1506            &quot;usersGroups&quot; mapped to the user's ID and an entry with
1507            key &quot;inherit&quot; mapped to a non-<code>null</code> object.
1508            For more information see {@link
1509            com.liferay.portal.service.persistence.GroupFinder}.
1510            * @param andOperator whether every field must match its keywords, or just
1511            one field.
1512            * @param start the lower bound of the range of groups to return
1513            * @param end the upper bound of the range of groups to return (not
1514            inclusive)
1515            * @return the matching groups ordered by name
1516            */
1517            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1518            public java.util.List<com.liferay.portal.model.Group> search(
1519                    long companyId, long[] classNameIds, long parentGroupId,
1520                    java.lang.String name, java.lang.String description,
1521                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
1522                    boolean andOperator, int start, int end);
1523    
1524            /**
1525            * Returns an ordered range of all the groups belonging to the parent group
1526            * that match the class name IDs, name, and description, optionally
1527            * including the user's inherited organization groups and user groups.
1528            * System and staged groups are not included.
1529            *
1530            * <p>
1531            * Useful when paginating results. Returns a maximum of <code>end -
1532            * start</code> instances. <code>start</code> and <code>end</code> are not
1533            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1534            * refers to the first result in the set. Setting both <code>start</code>
1535            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1536            * result set.
1537            * </p>
1538            *
1539            * @param companyId the primary key of the company
1540            * @param classNameIds the primary keys of the class names of the entities
1541            the groups are related to (optionally <code>null</code>)
1542            * @param parentGroupId the primary key of the parent group
1543            * @param name the group's name (optionally <code>null</code>)
1544            * @param description the group's description (optionally
1545            <code>null</code>)
1546            * @param params the finder params (optionally <code>null</code>). To
1547            include a user's organizations, inherited organizations, and user
1548            groups in the search, add an entry with key
1549            &quot;usersGroups&quot; mapped to the user's ID and an entry with
1550            key &quot;inherit&quot; mapped to a non-<code>null</code> object.
1551            For more information see {@link
1552            com.liferay.portal.service.persistence.GroupFinder}.
1553            * @param andOperator whether every field must match its keywords, or just
1554            one field.
1555            * @param start the lower bound of the range of groups to return
1556            * @param end the upper bound of the range of groups to return (not
1557            inclusive)
1558            * @param obc the comparator to order the groups (optionally
1559            <code>null</code>)
1560            * @return the matching groups ordered by comparator <code>obc</code>
1561            */
1562            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1563            public java.util.List<com.liferay.portal.model.Group> search(
1564                    long companyId, long[] classNameIds, long parentGroupId,
1565                    java.lang.String name, java.lang.String description,
1566                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
1567                    boolean andOperator, int start, int end,
1568                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> obc);
1569    
1570            /**
1571            * Returns an ordered range of all the groups that match the keywords,
1572            * optionally including the user's inherited organization groups and user
1573            * groups. System and staged groups are not included.
1574            *
1575            * <p>
1576            * Useful when paginating results. Returns a maximum of <code>end -
1577            * start</code> instances. <code>start</code> and <code>end</code> are not
1578            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1579            * refers to the first result in the set. Setting both <code>start</code>
1580            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1581            * result set.
1582            * </p>
1583            *
1584            * @param companyId the primary key of the company
1585            * @param keywords the keywords (space separated), which may occur in the
1586            sites's name, or description (optionally <code>null</code>)
1587            * @param params the finder params (optionally <code>null</code>). To
1588            include the user's inherited organizations and user groups in the
1589            search, add entries having &quot;usersGroups&quot; and
1590            &quot;inherit&quot; as keys mapped to the the user's ID. For more
1591            information see {@link
1592            com.liferay.portal.service.persistence.GroupFinder}.
1593            * @param start the lower bound of the range of groups to return
1594            * @param end the upper bound of the range of groups to return (not
1595            inclusive)
1596            * @return the matching groups ordered by name
1597            */
1598            @com.liferay.portal.kernel.cache.thread.local.ThreadLocalCachable
1599            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1600            public java.util.List<com.liferay.portal.model.Group> search(
1601                    long companyId, java.lang.String keywords,
1602                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
1603                    int start, int end);
1604    
1605            /**
1606            * Returns an ordered range of all the groups that match the keywords,
1607            * optionally including the user's inherited organization groups and user
1608            * groups. System and staged groups are not included.
1609            *
1610            * <p>
1611            * Useful when paginating results. Returns a maximum of <code>end -
1612            * start</code> instances. <code>start</code> and <code>end</code> are not
1613            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1614            * refers to the first result in the set. Setting both <code>start</code>
1615            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1616            * result set.
1617            * </p>
1618            *
1619            * @param companyId the primary key of the company
1620            * @param keywords the keywords (space separated), which may occur in the
1621            sites's name, or description (optionally <code>null</code>)
1622            * @param params the finder params (optionally <code>null</code>). To
1623            include the user's inherited organizations and user groups in the
1624            search, add entries having &quot;usersGroups&quot; and
1625            &quot;inherit&quot; as keys mapped to the the user's ID. For more
1626            information see {@link
1627            com.liferay.portal.service.persistence.GroupFinder}.
1628            * @param start the lower bound of the range of groups to return
1629            * @param end the upper bound of the range of groups to return (not
1630            inclusive)
1631            * @param obc the comparator to order the groups (optionally
1632            <code>null</code>)
1633            * @return the matching groups ordered by comparator <code>obc</code>
1634            */
1635            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1636            public java.util.List<com.liferay.portal.model.Group> search(
1637                    long companyId, java.lang.String keywords,
1638                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
1639                    int start, int end,
1640                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> obc);
1641    
1642            /**
1643            * Returns an ordered range of all the site groups and organization groups
1644            * that match the name and description, optionally including the user's
1645            * inherited organization groups and user groups. System and staged groups
1646            * are not included.
1647            *
1648            * <p>
1649            * Useful when paginating results. Returns a maximum of <code>end -
1650            * start</code> instances. <code>start</code> and <code>end</code> are not
1651            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1652            * refers to the first result in the set. Setting both <code>start</code>
1653            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1654            * result set.
1655            * </p>
1656            *
1657            * @param companyId the primary key of the company
1658            * @param name the group's name (optionally <code>null</code>)
1659            * @param description the group's description (optionally
1660            <code>null</code>)
1661            * @param params the finder params (optionally <code>null</code>). To
1662            include the user's inherited organizations and user groups in the
1663            search, add entries having &quot;usersGroups&quot; and
1664            &quot;inherit&quot; as keys mapped to the the user's ID. For more
1665            information see {@link
1666            com.liferay.portal.service.persistence.GroupFinder}.
1667            * @param andOperator whether every field must match its keywords, or just
1668            one field.
1669            * @param start the lower bound of the range of groups to return
1670            * @param end the upper bound of the range of groups to return (not
1671            inclusive)
1672            * @return the matching groups ordered by name
1673            */
1674            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1675            public java.util.List<com.liferay.portal.model.Group> search(
1676                    long companyId, java.lang.String name, java.lang.String description,
1677                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
1678                    boolean andOperator, int start, int end);
1679    
1680            /**
1681            * Returns an ordered range of all the site groups and organization groups
1682            * that match the name and description, optionally including the user's
1683            * inherited organization groups and user groups. System and staged groups
1684            * are not included.
1685            *
1686            * <p>
1687            * Useful when paginating results. Returns a maximum of <code>end -
1688            * start</code> instances. <code>start</code> and <code>end</code> are not
1689            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1690            * refers to the first result in the set. Setting both <code>start</code>
1691            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1692            * result set.
1693            * </p>
1694            *
1695            * @param companyId the primary key of the company
1696            * @param name the group's name (optionally <code>null</code>)
1697            * @param description the group's description (optionally
1698            <code>null</code>)
1699            * @param params the finder params (optionally <code>null</code>). To
1700            include the user's inherited organizations and user groups in the
1701            search, add entries having &quot;usersGroups&quot; and
1702            &quot;inherit&quot; as keys mapped to the the user's ID. For more
1703            information see {@link
1704            com.liferay.portal.service.persistence.GroupFinder}.
1705            * @param andOperator whether every field must match its keywords, or just
1706            one field.
1707            * @param start the lower bound of the range of groups to return
1708            * @param end the upper bound of the range of groups to return (not
1709            inclusive)
1710            * @param obc the comparator to order the groups (optionally
1711            <code>null</code>)
1712            * @return the matching groups ordered by comparator <code>obc</code>
1713            */
1714            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1715            public java.util.List<com.liferay.portal.model.Group> search(
1716                    long companyId, java.lang.String name, java.lang.String description,
1717                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
1718                    boolean andOperator, int start, int end,
1719                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> obc);
1720    
1721            /**
1722            * Returns an ordered range of all the company's groups, optionally
1723            * including the user's inherited organization groups and user groups.
1724            * System and staged groups are not included.
1725            *
1726            * <p>
1727            * Useful when paginating results. Returns a maximum of <code>end -
1728            * start</code> instances. <code>start</code> and <code>end</code> are not
1729            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1730            * refers to the first result in the set. Setting both <code>start</code>
1731            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1732            * result set.
1733            * </p>
1734            *
1735            * @param companyId the primary key of the company
1736            * @param params the finder params (optionally <code>null</code>). To
1737            include a user's organizations, inherited organizations, and user
1738            groups in the search, add an entry with key
1739            &quot;usersGroups&quot; mapped to the user's ID and an entry with
1740            key &quot;inherit&quot; mapped to a non-<code>null</code> object.
1741            For more information see {@link
1742            com.liferay.portal.service.persistence.GroupFinder}.
1743            * @param start the lower bound of the range of groups to return
1744            * @param end the upper bound of the range of groups to return (not
1745            inclusive)
1746            * @return the matching groups ordered by name
1747            */
1748            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1749            public java.util.List<com.liferay.portal.model.Group> search(
1750                    long companyId,
1751                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
1752                    int start, int end);
1753    
1754            /**
1755            * Returns an ordered range of all the groups belonging to the parent group
1756            * that match the keywords, optionally including the user's inherited
1757            * organization groups and user groups. System and staged groups are not
1758            * included.
1759            *
1760            * <p>
1761            * Useful when paginating results. Returns a maximum of <code>end -
1762            * start</code> instances. <code>start</code> and <code>end</code> are not
1763            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1764            * refers to the first result in the set. Setting both <code>start</code>
1765            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1766            * result set.
1767            * </p>
1768            *
1769            * @param companyId the primary key of the company
1770            * @param parentGroupId the primary key of the parent group
1771            * @param keywords the keywords (space separated), which may occur in the
1772            sites's name, or description (optionally <code>null</code>)
1773            * @param params the finder params (optionally <code>null</code>). To
1774            include the user's inherited organizations and user groups in the
1775            search, add entries having &quot;usersGroups&quot; and
1776            &quot;inherit&quot; as keys mapped to the the user's ID. For more
1777            information see {@link
1778            com.liferay.portal.service.persistence.GroupFinder}.
1779            * @param start the lower bound of the range of groups to return
1780            * @param end the upper bound of the range of groups to return (not
1781            inclusive)
1782            * @return the matching groups ordered by name
1783            */
1784            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1785            public java.util.List<com.liferay.portal.model.Group> search(
1786                    long companyId, long parentGroupId, java.lang.String keywords,
1787                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
1788                    int start, int end);
1789    
1790            /**
1791            * Returns an ordered range of all the groups belonging to the parent group
1792            * that match the keywords, optionally including the user's inherited
1793            * organization groups and user groups. System and staged groups are not
1794            * included.
1795            *
1796            * <p>
1797            * Useful when paginating results. Returns a maximum of <code>end -
1798            * start</code> instances. <code>start</code> and <code>end</code> are not
1799            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1800            * refers to the first result in the set. Setting both <code>start</code>
1801            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1802            * result set.
1803            * </p>
1804            *
1805            * @param companyId the primary key of the company
1806            * @param parentGroupId the primary key of the parent group
1807            * @param keywords the keywords (space separated), which may occur in the
1808            sites's name, or description (optionally <code>null</code>)
1809            * @param params the finder params (optionally <code>null</code>). To
1810            include the user's inherited organizations and user groups in the
1811            search, add entries having &quot;usersGroups&quot; and
1812            &quot;inherit&quot; as keys mapped to the the user's ID. For more
1813            information see {@link
1814            com.liferay.portal.service.persistence.GroupFinder}.
1815            * @param start the lower bound of the range of groups to return
1816            * @param end the upper bound of the range of groups to return (not
1817            inclusive)
1818            * @param obc the comparator to order the groups (optionally
1819            <code>null</code>)
1820            * @return the matching groups ordered by comparator <code>obc</code>
1821            */
1822            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1823            public java.util.List<com.liferay.portal.model.Group> search(
1824                    long companyId, long parentGroupId, java.lang.String keywords,
1825                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
1826                    int start, int end,
1827                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> obc);
1828    
1829            /**
1830            * Returns an ordered range of all the site groups belonging to the parent
1831            * group and organization groups that match the name and description,
1832            * optionally including the user's inherited organization groups and user
1833            * groups. System and staged groups are not included.
1834            *
1835            * <p>
1836            * Useful when paginating results. Returns a maximum of <code>end -
1837            * start</code> instances. <code>start</code> and <code>end</code> are not
1838            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1839            * refers to the first result in the set. Setting both <code>start</code>
1840            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1841            * result set.
1842            * </p>
1843            *
1844            * @param companyId the primary key of the company
1845            * @param parentGroupId the primary key of the parent group
1846            * @param name the group's name (optionally <code>null</code>)
1847            * @param description the group's description (optionally
1848            <code>null</code>)
1849            * @param params the finder params (optionally <code>null</code>). To
1850            include the user's inherited organizations and user groups in the
1851            search, add entries having &quot;usersGroups&quot; and
1852            &quot;inherit&quot; as keys mapped to the the user's ID. For more
1853            information see {@link
1854            com.liferay.portal.service.persistence.GroupFinder}.
1855            * @param andOperator whether every field must match its keywords, or just
1856            one field.
1857            * @param start the lower bound of the range of groups to return
1858            * @param end the upper bound of the range of groups to return (not
1859            inclusive)
1860            * @return the matching groups ordered by name
1861            */
1862            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1863            public java.util.List<com.liferay.portal.model.Group> search(
1864                    long companyId, long parentGroupId, java.lang.String name,
1865                    java.lang.String description,
1866                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
1867                    boolean andOperator, int start, int end);
1868    
1869            /**
1870            * Returns an ordered range of all the site groups belonging to the parent
1871            * group and organization groups that match the name and description,
1872            * optionally including the user's inherited organization groups and user
1873            * groups. System and staged groups are not included.
1874            *
1875            * <p>
1876            * Useful when paginating results. Returns a maximum of <code>end -
1877            * start</code> instances. <code>start</code> and <code>end</code> are not
1878            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1879            * refers to the first result in the set. Setting both <code>start</code>
1880            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1881            * result set.
1882            * </p>
1883            *
1884            * @param companyId the primary key of the company
1885            * @param parentGroupId the primary key of the parent group
1886            * @param name the group's name (optionally <code>null</code>)
1887            * @param description the group's description (optionally
1888            <code>null</code>)
1889            * @param params the finder params (optionally <code>null</code>). To
1890            include the user's inherited organizations and user groups in the
1891            search, add entries having &quot;usersGroups&quot; and
1892            &quot;inherit&quot; as keys mapped to the the user's ID. For more
1893            information see {@link
1894            com.liferay.portal.service.persistence.GroupFinder}.
1895            * @param andOperator whether every field must match its keywords, or just
1896            one field.
1897            * @param start the lower bound of the range of groups to return
1898            * @param end the upper bound of the range of groups to return (not
1899            inclusive)
1900            * @param obc the comparator to order the groups (optionally
1901            <code>null</code>)
1902            * @return the matching groups ordered by comparator <code>obc</code>
1903            */
1904            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1905            public java.util.List<com.liferay.portal.model.Group> search(
1906                    long companyId, long parentGroupId, java.lang.String name,
1907                    java.lang.String description,
1908                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
1909                    boolean andOperator, int start, int end,
1910                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> obc);
1911    
1912            /**
1913            * Returns the number of groups that match the class name IDs, and keywords,
1914            * optionally including the user's inherited organization groups and user
1915            * groups. System and staged groups are not included.
1916            *
1917            * @param companyId the primary key of the company
1918            * @param classNameIds the primary keys of the class names of the entities
1919            the groups are related to (optionally <code>null</code>)
1920            * @param keywords the keywords (space separated), which may occur in the
1921            sites's name, or description (optionally <code>null</code>)
1922            * @param params the finder params (optionally <code>null</code>). To
1923            include the user's inherited organization groups and user groups
1924            in the search, add entries having &quot;usersGroups&quot; and
1925            &quot;inherit&quot; as keys mapped to the the user's ID. For more
1926            information see {@link
1927            com.liferay.portal.service.persistence.GroupFinder}.
1928            * @return the number of matching groups
1929            */
1930            @com.liferay.portal.kernel.cache.thread.local.ThreadLocalCachable
1931            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1932            public int searchCount(long companyId, long[] classNameIds,
1933                    java.lang.String keywords,
1934                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params);
1935    
1936            /**
1937            * Returns the number of groups that match the class name IDs, name, and
1938            * description, optionally including the user's inherited organization
1939            * groups and user groups. System and staged groups are not included.
1940            *
1941            * @param companyId the primary key of the company
1942            * @param classNameIds the primary keys of the class names of the entities
1943            the groups are related to (optionally <code>null</code>)
1944            * @param name the group's name (optionally <code>null</code>)
1945            * @param description the group's description (optionally
1946            <code>null</code>)
1947            * @param params the finder params (optionally <code>null</code>). To
1948            include the user's inherited organization groups and user groups
1949            in the search, add entries having &quot;usersGroups&quot; and
1950            &quot;inherit&quot; as keys mapped to the the user's ID. For more
1951            information see {@link
1952            com.liferay.portal.service.persistence.GroupFinder}.
1953            * @param andOperator whether every field must match its keywords, or just
1954            one field.
1955            * @return the number of matching groups
1956            */
1957            @com.liferay.portal.kernel.cache.thread.local.ThreadLocalCachable
1958            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1959            public int searchCount(long companyId, long[] classNameIds,
1960                    java.lang.String name, java.lang.String description,
1961                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
1962                    boolean andOperator);
1963    
1964            /**
1965            * Returns the number of groups belonging to the parent group that match the
1966            * class name IDs, and keywords, optionally including the user's inherited
1967            * organization groups and user groups. System and staged groups are not
1968            * included.
1969            *
1970            * @param companyId the primary key of the company
1971            * @param classNameIds the primary keys of the class names of the entities
1972            the groups are related to (optionally <code>null</code>)
1973            * @param parentGroupId the primary key of the parent group
1974            * @param keywords the keywords (space separated), which may occur in the
1975            sites's name, or description (optionally <code>null</code>)
1976            * @param params the finder params (optionally <code>null</code>). To
1977            include the user's inherited organization groups and user groups
1978            in the search, add entries having &quot;usersGroups&quot; and
1979            &quot;inherit&quot; as keys mapped to the the user's ID. For more
1980            information see {@link
1981            com.liferay.portal.service.persistence.GroupFinder}.
1982            * @return the number of matching groups
1983            */
1984            @com.liferay.portal.kernel.cache.thread.local.ThreadLocalCachable
1985            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
1986            public int searchCount(long companyId, long[] classNameIds,
1987                    long parentGroupId, java.lang.String keywords,
1988                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params);
1989    
1990            /**
1991            * Returns the number of groups belonging to the parent group that match the
1992            * class name IDs, name, and description, optionally including the user's
1993            * inherited organization groups and user groups. System and staged groups
1994            * are not included.
1995            *
1996            * @param companyId the primary key of the company
1997            * @param classNameIds the primary keys of the class names of the entities
1998            the groups are related to (optionally <code>null</code>)
1999            * @param parentGroupId the primary key of the parent group
2000            * @param name the group's name (optionally <code>null</code>)
2001            * @param description the group's description (optionally
2002            <code>null</code>)
2003            * @param params the finder params (optionally <code>null</code>). To
2004            include the user's inherited organization groups and user groups
2005            in the search, add entries having &quot;usersGroups&quot; and
2006            &quot;inherit&quot; as keys mapped to the the user's ID. For more
2007            information see {@link
2008            com.liferay.portal.service.persistence.GroupFinder}.
2009            * @param andOperator whether every field must match its keywords, or just
2010            one field.
2011            * @return the number of matching groups
2012            */
2013            @com.liferay.portal.kernel.cache.thread.local.ThreadLocalCachable
2014            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
2015            public int searchCount(long companyId, long[] classNameIds,
2016                    long parentGroupId, java.lang.String name,
2017                    java.lang.String description,
2018                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2019                    boolean andOperator);
2020    
2021            /**
2022            * Returns the number of groups that match the keywords, optionally
2023            * including the user's inherited organization groups and user groups.
2024            * System and staged groups are not included.
2025            *
2026            * @param companyId the primary key of the company
2027            * @param keywords the keywords (space separated), which may occur in the
2028            sites's name, or description (optionally <code>null</code>)
2029            * @param params the finder params (optionally <code>null</code>). To
2030            include the user's inherited organization groups and user groups
2031            in the search, add entries having &quot;usersGroups&quot; and
2032            &quot;inherit&quot; as keys mapped to the the user's ID. For more
2033            information see {@link
2034            com.liferay.portal.service.persistence.GroupFinder}.
2035            * @return the number of matching groups
2036            */
2037            @com.liferay.portal.kernel.cache.thread.local.ThreadLocalCachable
2038            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
2039            public int searchCount(long companyId, java.lang.String keywords,
2040                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params);
2041    
2042            /**
2043            * Returns the number of groups and immediate organization groups that match
2044            * the name and description, optionally including the user's inherited
2045            * organization groups and user groups. System and staged groups are not
2046            * included.
2047            *
2048            * @param companyId the primary key of the company
2049            * @param name the group's name (optionally <code>null</code>)
2050            * @param description the group's description (optionally
2051            <code>null</code>)
2052            * @param params the finder params (optionally <code>null</code>). To
2053            include the user's inherited organization groups and user groups
2054            in the search, add entries having &quot;usersGroups&quot; and
2055            &quot;inherit&quot; as keys mapped to the the user's ID. For more
2056            information see {@link
2057            com.liferay.portal.service.persistence.GroupFinder}.
2058            * @param andOperator whether every field must match its keywords, or just
2059            one field.
2060            * @return the number of matching groups
2061            */
2062            @com.liferay.portal.kernel.cache.thread.local.ThreadLocalCachable
2063            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
2064            public int searchCount(long companyId, java.lang.String name,
2065                    java.lang.String description,
2066                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2067                    boolean andOperator);
2068    
2069            /**
2070            * Returns the number of groups belonging to the parent group that match the
2071            * keywords, optionally including the user's inherited organization groups
2072            * and user groups. System and staged groups are not included.
2073            *
2074            * @param companyId the primary key of the company
2075            * @param parentGroupId the primary key of the parent group
2076            * @param keywords the keywords (space separated), which may occur in the
2077            sites's name, or description (optionally <code>null</code>)
2078            * @param params the finder params (optionally <code>null</code>). To
2079            include the user's inherited organization groups and user groups
2080            in the search, add entries having &quot;usersGroups&quot; and
2081            &quot;inherit&quot; as keys mapped to the the user's ID. For more
2082            information see {@link
2083            com.liferay.portal.service.persistence.GroupFinder}.
2084            * @return the number of matching groups
2085            */
2086            @com.liferay.portal.kernel.cache.thread.local.ThreadLocalCachable
2087            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
2088            public int searchCount(long companyId, long parentGroupId,
2089                    java.lang.String keywords,
2090                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params);
2091    
2092            /**
2093            * Returns the number of groups belonging to the parent group and immediate
2094            * organization groups that match the name and description, optionally
2095            * including the user's inherited organization groups and user groups.
2096            * System and staged groups are not included.
2097            *
2098            * @param companyId the primary key of the company
2099            * @param parentGroupId the primary key of the parent group
2100            * @param name the group's name (optionally <code>null</code>)
2101            * @param description the group's description (optionally
2102            <code>null</code>)
2103            * @param params the finder params (optionally <code>null</code>). To
2104            include the user's inherited organization groups and user groups
2105            in the search, add entries having &quot;usersGroups&quot; and
2106            &quot;inherit&quot; as keys mapped to the the user's ID. For more
2107            information see {@link
2108            com.liferay.portal.service.persistence.GroupFinder}.
2109            * @param andOperator whether every field must match its keywords, or just
2110            one field.
2111            * @return the number of matching groups
2112            */
2113            @com.liferay.portal.kernel.cache.thread.local.ThreadLocalCachable
2114            @Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
2115            public int searchCount(long companyId, long parentGroupId,
2116                    java.lang.String name, java.lang.String description,
2117                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2118                    boolean andOperator);
2119    
2120            public void setOrganizationGroups(long organizationId, long[] groupIds);
2121    
2122            public void setRoleGroups(long roleId, long[] groupIds);
2123    
2124            public void setUserGroupGroups(long userGroupId, long[] groupIds);
2125    
2126            public void setUserGroups(long userId, long[] groupIds);
2127    
2128            /**
2129            * Removes the groups from the role.
2130            *
2131            * @param roleId the primary key of the role
2132            * @param groupIds the primary keys of the groups
2133            */
2134            public void unsetRoleGroups(long roleId, long[] groupIds);
2135    
2136            /**
2137            * Removes the user from the groups.
2138            *
2139            * @param userId the primary key of the user
2140            * @param groupIds the primary keys of the groups
2141            */
2142            public void unsetUserGroups(long userId, long[] groupIds);
2143    
2144            /**
2145            * Updates the group's asset replacing categories and tag names.
2146            *
2147            * @param userId the primary key of the user
2148            * @param group the group
2149            * @param assetCategoryIds the primary keys of the asset categories
2150            (optionally <code>null</code>)
2151            * @param assetTagNames the asset tag names (optionally <code>null</code>)
2152            */
2153            public void updateAsset(long userId, com.liferay.portal.model.Group group,
2154                    long[] assetCategoryIds, java.lang.String[] assetTagNames)
2155                    throws PortalException;
2156    
2157            /**
2158            * Updates the group's friendly URL.
2159            *
2160            * @param groupId the primary key of the group
2161            * @param friendlyURL the group's new friendlyURL (optionally
2162            <code>null</code>)
2163            * @return the group
2164            */
2165            public com.liferay.portal.model.Group updateFriendlyURL(long groupId,
2166                    java.lang.String friendlyURL) throws PortalException;
2167    
2168            /**
2169            * Updates the group in the database or adds it if it does not yet exist. Also notifies the appropriate model listeners.
2170            *
2171            * @param group the group
2172            * @return the group that was updated
2173            */
2174            @com.liferay.portal.kernel.search.Indexable(type = IndexableType.REINDEX)
2175            public com.liferay.portal.model.Group updateGroup(
2176                    com.liferay.portal.model.Group group);
2177    
2178            /**
2179            * Updates the group.
2180            *
2181            * @param groupId the primary key of the group
2182            * @param parentGroupId the primary key of the parent group
2183            * @param name the name's key
2184            * @param description the group's new description (optionally
2185            <code>null</code>)
2186            * @param type the group's new type. For more information see {@link
2187            GroupConstants}.
2188            * @param manualMembership whether manual membership is allowed for the
2189            group
2190            * @param membershipRestriction the group's membership restriction. For
2191            more information see {@link GroupConstants}.
2192            * @param friendlyURL the group's new friendlyURL (optionally
2193            <code>null</code>)
2194            * @param active whether the group is active
2195            * @param serviceContext the service context to be applied (optionally
2196            <code>null</code>). Can set asset category IDs and asset tag
2197            names for the group.
2198            * @return the group
2199            * @deprecated As of 7.0.0, replaced by {@link #updateGroup(long, long, Map,
2200            Map, int, boolean, int, String, boolean, boolean,
2201            ServiceContext)}
2202            */
2203            @java.lang.Deprecated
2204            public com.liferay.portal.model.Group updateGroup(long groupId,
2205                    long parentGroupId, java.lang.String name,
2206                    java.lang.String description, int type, boolean manualMembership,
2207                    int membershipRestriction, java.lang.String friendlyURL,
2208                    boolean inheritContent, boolean active,
2209                    com.liferay.portal.service.ServiceContext serviceContext)
2210                    throws PortalException;
2211    
2212            public com.liferay.portal.model.Group updateGroup(long groupId,
2213                    long parentGroupId,
2214                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
2215                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
2216                    int type, boolean manualMembership, int membershipRestriction,
2217                    java.lang.String friendlyURL, boolean inheritContent, boolean active,
2218                    com.liferay.portal.service.ServiceContext serviceContext)
2219                    throws PortalException;
2220    
2221            /**
2222            * Updates the group's type settings.
2223            *
2224            * @param groupId the primary key of the group
2225            * @param typeSettings the group's new type settings (optionally
2226            <code>null</code>)
2227            * @return the group
2228            */
2229            public com.liferay.portal.model.Group updateGroup(long groupId,
2230                    java.lang.String typeSettings) throws PortalException;
2231    
2232            /**
2233            * Associates the group with a main site if the group is an organization.
2234            *
2235            * @param groupId the primary key of the group
2236            * @param site whether the group is to be associated with a main site
2237            * @return the group
2238            */
2239            public com.liferay.portal.model.Group updateSite(long groupId, boolean site)
2240                    throws PortalException;
2241    }