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