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