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