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