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