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 QueryUtil#ALL_POS} will return the full
729            * result set.
730            * </p>
731            *
732            * @param companyId the primary key of the company
733            * @param start the lower bound of the range of groups to return
734            * @param end the upper bound of the range of groups to return (not
735            inclusive)
736            * @return the range of groups associated with the company
737            */
738            @Override
739            public java.util.List<com.liferay.portal.model.Group> getCompanyGroups(
740                    long companyId, int start, int end) {
741                    return _groupLocalService.getCompanyGroups(companyId, start, end);
742            }
743    
744            /**
745            * Returns the number of groups associated with the company.
746            *
747            * @param companyId the primary key of the company
748            * @return the number of groups associated with the company
749            */
750            @Override
751            public int getCompanyGroupsCount(long companyId) {
752                    return _groupLocalService.getCompanyGroupsCount(companyId);
753            }
754    
755            /**
756            * Returns the group with the matching friendly URL.
757            *
758            * @param companyId the primary key of the company
759            * @param friendlyURL the group's friendlyURL
760            * @return the group with the friendly URL
761            * @throws PortalException if a matching group could not be found, or if the
762            friendly URL was invalid
763            */
764            @Override
765            public com.liferay.portal.model.Group getFriendlyURLGroup(long companyId,
766                    java.lang.String friendlyURL)
767                    throws com.liferay.portal.kernel.exception.PortalException {
768                    return _groupLocalService.getFriendlyURLGroup(companyId, friendlyURL);
769            }
770    
771            /**
772            * Returns the group with the matching group key.
773            *
774            * @param companyId the primary key of the company
775            * @param groupKey the group key
776            * @return the group with the group key
777            * @throws PortalException if a matching group could not be found
778            */
779            @Override
780            public com.liferay.portal.model.Group getGroup(long companyId,
781                    java.lang.String groupKey)
782                    throws com.liferay.portal.kernel.exception.PortalException {
783                    return _groupLocalService.getGroup(companyId, groupKey);
784            }
785    
786            /**
787            * Returns the group with the primary key.
788            *
789            * @param groupId the primary key of the group
790            * @return the group
791            * @throws PortalException if a group with the primary key could not be found
792            */
793            @Override
794            public com.liferay.portal.model.Group getGroup(long groupId)
795                    throws com.liferay.portal.kernel.exception.PortalException {
796                    return _groupLocalService.getGroup(groupId);
797            }
798    
799            /**
800            * Returns the group with the matching UUID and company.
801            *
802            * @param uuid the group's UUID
803            * @param companyId the primary key of the company
804            * @return the matching group
805            * @throws PortalException if a matching group could not be found
806            */
807            @Override
808            public com.liferay.portal.model.Group getGroupByUuidAndCompanyId(
809                    java.lang.String uuid, long companyId)
810                    throws com.liferay.portal.kernel.exception.PortalException {
811                    return _groupLocalService.getGroupByUuidAndCompanyId(uuid, companyId);
812            }
813    
814            /**
815            * @deprecated As of 7.0.0, replaced by {@link
816            Group#getDescriptiveName(Locale)}
817            */
818            @Deprecated
819            @Override
820            public java.lang.String getGroupDescriptiveName(
821                    com.liferay.portal.model.Group group, java.util.Locale locale)
822                    throws com.liferay.portal.kernel.exception.PortalException {
823                    return _groupLocalService.getGroupDescriptiveName(group, locale);
824            }
825    
826            /**
827            * @deprecated As of 7.0.0, replaced by {@link
828            Group#getDescriptiveName(Locale)}
829            */
830            @Deprecated
831            @Override
832            public java.lang.String getGroupDescriptiveName(long groupId,
833                    java.util.Locale locale)
834                    throws com.liferay.portal.kernel.exception.PortalException {
835                    return _groupLocalService.getGroupDescriptiveName(groupId, locale);
836            }
837    
838            /**
839            * Returns all the groups that are direct children of the parent group with
840            * the matching className.
841            *
842            * @param companyId the primary key of the company
843            * @param className the class name of the group
844            * @param parentGroupId the primary key of the parent group
845            * @return the matching groups, or <code>null</code> if no matches were
846            found
847            */
848            @Override
849            public java.util.List<com.liferay.portal.model.Group> getGroups(
850                    long companyId, java.lang.String className, long parentGroupId) {
851                    return _groupLocalService.getGroups(companyId, className, parentGroupId);
852            }
853    
854            /**
855            * Returns a range of all the groups that are direct children of the parent
856            * group with the matching className.
857            *
858            * @param companyId the primary key of the company
859            * @param className the class name of the group
860            * @param parentGroupId the primary key of the parent group
861            * @param start the lower bound of the range of results
862            * @param end the upper bound of the range of results (not inclusive)
863            * @return the range of matching groups
864            */
865            @Override
866            public java.util.List<com.liferay.portal.model.Group> getGroups(
867                    long companyId, java.lang.String className, long parentGroupId,
868                    int start, int end) {
869                    return _groupLocalService.getGroups(companyId, className,
870                            parentGroupId, start, end);
871            }
872    
873            /**
874            * Returns all the groups that are direct children of the parent group.
875            *
876            * @param companyId the primary key of the company
877            * @param parentGroupId the primary key of the parent group
878            * @param site whether the group is to be associated with a main site
879            * @return the matching groups, or <code>null</code> if no matches were
880            found
881            */
882            @Override
883            public java.util.List<com.liferay.portal.model.Group> getGroups(
884                    long companyId, long parentGroupId, boolean site) {
885                    return _groupLocalService.getGroups(companyId, parentGroupId, site);
886            }
887    
888            @Override
889            public java.util.List<com.liferay.portal.model.Group> getGroups(
890                    long companyId, long parentGroupId, boolean site, boolean inheritContent) {
891                    return _groupLocalService.getGroups(companyId, parentGroupId, site,
892                            inheritContent);
893            }
894    
895            /**
896            * Returns the groups with the matching primary keys.
897            *
898            * @param groupIds the primary keys of the groups
899            * @return the groups with the primary keys
900            * @throws PortalException if any one of the groups could not be found
901            */
902            @Override
903            public java.util.List<com.liferay.portal.model.Group> getGroups(
904                    long[] groupIds)
905                    throws com.liferay.portal.kernel.exception.PortalException {
906                    return _groupLocalService.getGroups(groupIds);
907            }
908    
909            /**
910            * Returns a range of all the groups.
911            *
912            * <p>
913            * 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.
914            * </p>
915            *
916            * @param start the lower bound of the range of groups
917            * @param end the upper bound of the range of groups (not inclusive)
918            * @return the range of groups
919            */
920            @Override
921            public java.util.List<com.liferay.portal.model.Group> getGroups(int start,
922                    int end) {
923                    return _groupLocalService.getGroups(start, end);
924            }
925    
926            /**
927            * Returns the number of groups.
928            *
929            * @return the number of groups
930            */
931            @Override
932            public int getGroupsCount() {
933                    return _groupLocalService.getGroupsCount();
934            }
935    
936            /**
937            * Returns the number of groups that are direct children of the parent group
938            * with the matching className.
939            *
940            * @param companyId the primary key of the company
941            * @param className the class name of the group
942            * @param parentGroupId the primary key of the parent group
943            * @return the number of matching groups
944            */
945            @Override
946            public int getGroupsCount(long companyId, java.lang.String className,
947                    long parentGroupId) {
948                    return _groupLocalService.getGroupsCount(companyId, className,
949                            parentGroupId);
950            }
951    
952            /**
953            * Returns the number of groups that are direct children of the parent
954            * group.
955            *
956            * @param companyId the primary key of the company
957            * @param parentGroupId the primary key of the parent group
958            * @param site whether the group is to be associated with a main site
959            * @return the number of matching groups
960            */
961            @Override
962            public int getGroupsCount(long companyId, long parentGroupId, boolean site) {
963                    return _groupLocalService.getGroupsCount(companyId, parentGroupId, site);
964            }
965    
966            /**
967            * Returns the group associated with the layout.
968            *
969            * @param companyId the primary key of the company
970            * @param plid the primary key of the layout
971            * @return the group associated with the layout
972            * @throws PortalException if a matching group could not be found
973            */
974            @Override
975            public com.liferay.portal.model.Group getLayoutGroup(long companyId,
976                    long plid) throws com.liferay.portal.kernel.exception.PortalException {
977                    return _groupLocalService.getLayoutGroup(companyId, plid);
978            }
979    
980            /**
981            * Returns the group associated with the layout prototype.
982            *
983            * @param companyId the primary key of the company
984            * @param layoutPrototypeId the primary key of the layout prototype
985            * @return the group associated with the layout prototype
986            * @throws PortalException if a matching group could not be found
987            */
988            @Override
989            public com.liferay.portal.model.Group getLayoutPrototypeGroup(
990                    long companyId, long layoutPrototypeId)
991                    throws com.liferay.portal.kernel.exception.PortalException {
992                    return _groupLocalService.getLayoutPrototypeGroup(companyId,
993                            layoutPrototypeId);
994            }
995    
996            /**
997            * Returns the group associated with the layout set prototype.
998            *
999            * @param companyId the primary key of the company
1000            * @param layoutSetPrototypeId the primary key of the layout set prototype
1001            * @return the group associated with the layout set prototype
1002            * @throws PortalException if a matching group could not be found
1003            */
1004            @Override
1005            public com.liferay.portal.model.Group getLayoutSetPrototypeGroup(
1006                    long companyId, long layoutSetPrototypeId)
1007                    throws com.liferay.portal.kernel.exception.PortalException {
1008                    return _groupLocalService.getLayoutSetPrototypeGroup(companyId,
1009                            layoutSetPrototypeId);
1010            }
1011    
1012            /**
1013            * Returns a range of all groups that are children of the parent group and
1014            * that have at least one layout.
1015            *
1016            * <p>
1017            * Useful when paginating results. Returns a maximum of <code>end -
1018            * start</code> instances. <code>start</code> and <code>end</code> are not
1019            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1020            * refers to the first result in the set. Setting both <code>start</code>
1021            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1022            * result set.
1023            * </p>
1024            *
1025            * @param companyId the primary key of the company
1026            * @param parentGroupId the primary key of the parent group
1027            * @param site whether the group is to be associated with a main site
1028            * @param start the lower bound of the range of groups to return
1029            * @param end the upper bound of the range of groups to return (not
1030            inclusive)
1031            * @return the range of matching groups
1032            * @deprecated As of 6.2.0, replaced by {@link #getLayoutsGroups(long, long,
1033            boolean, int, int, OrderByComparator)}
1034            */
1035            @Deprecated
1036            @Override
1037            public java.util.List<com.liferay.portal.model.Group> getLayoutsGroups(
1038                    long companyId, long parentGroupId, boolean site, int start, int end) {
1039                    return _groupLocalService.getLayoutsGroups(companyId, parentGroupId,
1040                            site, start, end);
1041            }
1042    
1043            /**
1044            * Returns a range of all groups that are children of the parent group and
1045            * that have at least one layout.
1046            *
1047            * <p>
1048            * Useful when paginating results. Returns a maximum of <code>end -
1049            * start</code> instances. <code>start</code> and <code>end</code> are not
1050            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1051            * refers to the first result in the set. Setting both <code>start</code>
1052            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1053            * result set.
1054            * </p>
1055            *
1056            * @param companyId the primary key of the company
1057            * @param parentGroupId the primary key of the parent group
1058            * @param site whether the group is to be associated with a main site
1059            * @param start the lower bound of the range of groups to return
1060            * @param end the upper bound of the range of groups to return (not
1061            inclusive)
1062            * @param obc the comparator to order the groups (optionally
1063            <code>null</code>)
1064            * @return the range of matching groups ordered by comparator
1065            <code>obc</code>
1066            */
1067            @Override
1068            public java.util.List<com.liferay.portal.model.Group> getLayoutsGroups(
1069                    long companyId, long parentGroupId, boolean site, int start, int end,
1070                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> obc) {
1071                    return _groupLocalService.getLayoutsGroups(companyId, parentGroupId,
1072                            site, start, end, obc);
1073            }
1074    
1075            /**
1076            * Returns the number of groups that are children or the parent group and
1077            * that have at least one layout
1078            *
1079            * @param companyId the primary key of the company
1080            * @param parentGroupId the primary key of the parent group
1081            * @param site whether the group is to be associated with a main site
1082            * @return the number of matching groups
1083            */
1084            @Override
1085            public int getLayoutsGroupsCount(long companyId, long parentGroupId,
1086                    boolean site) {
1087                    return _groupLocalService.getLayoutsGroupsCount(companyId,
1088                            parentGroupId, site);
1089            }
1090    
1091            /**
1092            * Returns all live groups.
1093            *
1094            * @return all live groups
1095            */
1096            @Override
1097            public java.util.List<com.liferay.portal.model.Group> getLiveGroups() {
1098                    return _groupLocalService.getLiveGroups();
1099            }
1100    
1101            /**
1102            * Returns a range of all non-system groups of a specified type (className)
1103            * that have no layouts.
1104            *
1105            * <p>
1106            * Useful when paginating results. Returns a maximum of <code>end -
1107            * start</code> instances. <code>start</code> and <code>end</code> are not
1108            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1109            * refers to the first result in the set. Setting both <code>start</code>
1110            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1111            * result set.
1112            * </p>
1113            *
1114            * @param className the entity's class name
1115            * @param privateLayout whether to include groups with private layout sets
1116            or non-private layout sets
1117            * @param start the lower bound of the range of groups to return
1118            * @param end the upper bound of the range of groups to return (not
1119            inclusive)
1120            * @return the range of matching groups
1121            */
1122            @Override
1123            public java.util.List<com.liferay.portal.model.Group> getNoLayoutsGroups(
1124                    java.lang.String className, boolean privateLayout, int start, int end) {
1125                    return _groupLocalService.getNoLayoutsGroups(className, privateLayout,
1126                            start, end);
1127            }
1128    
1129            /**
1130            * Returns all non-system groups having <code>null</code> or empty friendly
1131            * URLs.
1132            *
1133            * @return the non-system groups having <code>null</code> or empty friendly
1134            URLs
1135            */
1136            @Override
1137            public java.util.List<com.liferay.portal.model.Group> getNullFriendlyURLGroups() {
1138                    return _groupLocalService.getNullFriendlyURLGroups();
1139            }
1140    
1141            /**
1142            * Returns the specified organization group.
1143            *
1144            * @param companyId the primary key of the company
1145            * @param organizationId the primary key of the organization
1146            * @return the group associated with the organization
1147            * @throws PortalException if a matching group could not be found
1148            */
1149            @Override
1150            public com.liferay.portal.model.Group getOrganizationGroup(long companyId,
1151                    long organizationId)
1152                    throws com.liferay.portal.kernel.exception.PortalException {
1153                    return _groupLocalService.getOrganizationGroup(companyId, organizationId);
1154            }
1155    
1156            @Override
1157            public java.util.List<com.liferay.portal.model.Group> getOrganizationGroups(
1158                    long organizationId) {
1159                    return _groupLocalService.getOrganizationGroups(organizationId);
1160            }
1161    
1162            @Override
1163            public java.util.List<com.liferay.portal.model.Group> getOrganizationGroups(
1164                    long organizationId, int start, int end) {
1165                    return _groupLocalService.getOrganizationGroups(organizationId, start,
1166                            end);
1167            }
1168    
1169            @Override
1170            public java.util.List<com.liferay.portal.model.Group> getOrganizationGroups(
1171                    long organizationId, int start, int end,
1172                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> orderByComparator) {
1173                    return _groupLocalService.getOrganizationGroups(organizationId, start,
1174                            end, orderByComparator);
1175            }
1176    
1177            @Override
1178            public int getOrganizationGroupsCount(long organizationId) {
1179                    return _groupLocalService.getOrganizationGroupsCount(organizationId);
1180            }
1181    
1182            /**
1183            * Returns the organizationIds of the organizations associated with the group.
1184            *
1185            * @param groupId the groupId of the group
1186            * @return long[] the organizationIds of organizations associated with the group
1187            */
1188            @Override
1189            public long[] getOrganizationPrimaryKeys(long groupId) {
1190                    return _groupLocalService.getOrganizationPrimaryKeys(groupId);
1191            }
1192    
1193            /**
1194            * Returns the specified organization groups.
1195            *
1196            * @param organizations the organizations
1197            * @return the groups associated with the organizations
1198            */
1199            @Override
1200            public java.util.List<com.liferay.portal.model.Group> getOrganizationsGroups(
1201                    java.util.List<com.liferay.portal.model.Organization> organizations) {
1202                    return _groupLocalService.getOrganizationsGroups(organizations);
1203            }
1204    
1205            /**
1206            * Returns all the groups related to the organizations.
1207            *
1208            * @param organizations the organizations
1209            * @return the groups related to the organizations
1210            */
1211            @Override
1212            public java.util.List<com.liferay.portal.model.Group> getOrganizationsRelatedGroups(
1213                    java.util.List<com.liferay.portal.model.Organization> organizations) {
1214                    return _groupLocalService.getOrganizationsRelatedGroups(organizations);
1215            }
1216    
1217            /**
1218            * Returns the group followed by all its parent groups ordered by closest
1219            * ancestor.
1220            *
1221            * @param groupId the primary key of the group
1222            * @return the group followed by all its parent groups ordered by closest
1223            ancestor
1224            * @throws PortalException if a group with the primary key could not be
1225            found
1226            */
1227            @Override
1228            public java.util.List<com.liferay.portal.model.Group> getParentGroups(
1229                    long groupId)
1230                    throws com.liferay.portal.kernel.exception.PortalException {
1231                    return _groupLocalService.getParentGroups(groupId);
1232            }
1233    
1234            @Override
1235            public com.liferay.portal.model.PersistedModel getPersistedModel(
1236                    java.io.Serializable primaryKeyObj)
1237                    throws com.liferay.portal.kernel.exception.PortalException {
1238                    return _groupLocalService.getPersistedModel(primaryKeyObj);
1239            }
1240    
1241            @Override
1242            public java.util.List<com.liferay.portal.model.Group> getRoleGroups(
1243                    long roleId) {
1244                    return _groupLocalService.getRoleGroups(roleId);
1245            }
1246    
1247            @Override
1248            public java.util.List<com.liferay.portal.model.Group> getRoleGroups(
1249                    long roleId, int start, int end) {
1250                    return _groupLocalService.getRoleGroups(roleId, start, end);
1251            }
1252    
1253            @Override
1254            public java.util.List<com.liferay.portal.model.Group> getRoleGroups(
1255                    long roleId, int start, int end,
1256                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> orderByComparator) {
1257                    return _groupLocalService.getRoleGroups(roleId, start, end,
1258                            orderByComparator);
1259            }
1260    
1261            @Override
1262            public int getRoleGroupsCount(long roleId) {
1263                    return _groupLocalService.getRoleGroupsCount(roleId);
1264            }
1265    
1266            /**
1267            * Returns the roleIds of the roles associated with the group.
1268            *
1269            * @param groupId the groupId of the group
1270            * @return long[] the roleIds of roles associated with the group
1271            */
1272            @Override
1273            public long[] getRolePrimaryKeys(long groupId) {
1274                    return _groupLocalService.getRolePrimaryKeys(groupId);
1275            }
1276    
1277            /**
1278            * Returns the staging group.
1279            *
1280            * @param liveGroupId the primary key of the live group
1281            * @return the staging group
1282            * @throws PortalException if a matching staging group could not be found
1283            */
1284            @Override
1285            public com.liferay.portal.model.Group getStagingGroup(long liveGroupId)
1286                    throws com.liferay.portal.kernel.exception.PortalException {
1287                    return _groupLocalService.getStagingGroup(liveGroupId);
1288            }
1289    
1290            /**
1291            * Returns the group directly associated with the user.
1292            *
1293            * @param companyId the primary key of the company
1294            * @param userId the primary key of the user
1295            * @return the group directly associated with the user
1296            * @throws PortalException if a matching group could not be found
1297            */
1298            @Override
1299            public com.liferay.portal.model.Group getUserGroup(long companyId,
1300                    long userId) throws com.liferay.portal.kernel.exception.PortalException {
1301                    return _groupLocalService.getUserGroup(companyId, userId);
1302            }
1303    
1304            /**
1305            * Returns the specified "user group" group. That is, the group that
1306            * represents the {@link UserGroup} entity.
1307            *
1308            * @param companyId the primary key of the company
1309            * @param userGroupId the primary key of the user group
1310            * @return the group associated with the user group
1311            * @throws PortalException if a matching group could not be found
1312            */
1313            @Override
1314            public com.liferay.portal.model.Group getUserGroupGroup(long companyId,
1315                    long userGroupId)
1316                    throws com.liferay.portal.kernel.exception.PortalException {
1317                    return _groupLocalService.getUserGroupGroup(companyId, userGroupId);
1318            }
1319    
1320            @Override
1321            public java.util.List<com.liferay.portal.model.Group> getUserGroupGroups(
1322                    long userGroupId) {
1323                    return _groupLocalService.getUserGroupGroups(userGroupId);
1324            }
1325    
1326            @Override
1327            public java.util.List<com.liferay.portal.model.Group> getUserGroupGroups(
1328                    long userGroupId, int start, int end) {
1329                    return _groupLocalService.getUserGroupGroups(userGroupId, start, end);
1330            }
1331    
1332            @Override
1333            public java.util.List<com.liferay.portal.model.Group> getUserGroupGroups(
1334                    long userGroupId, int start, int end,
1335                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> orderByComparator) {
1336                    return _groupLocalService.getUserGroupGroups(userGroupId, start, end,
1337                            orderByComparator);
1338            }
1339    
1340            @Override
1341            public int getUserGroupGroupsCount(long userGroupId) {
1342                    return _groupLocalService.getUserGroupGroupsCount(userGroupId);
1343            }
1344    
1345            /**
1346            * Returns the userGroupIds of the user groups associated with the group.
1347            *
1348            * @param groupId the groupId of the group
1349            * @return long[] the userGroupIds of user groups associated with the group
1350            */
1351            @Override
1352            public long[] getUserGroupPrimaryKeys(long groupId) {
1353                    return _groupLocalService.getUserGroupPrimaryKeys(groupId);
1354            }
1355    
1356            @Override
1357            public java.util.List<com.liferay.portal.model.Group> getUserGroups(
1358                    long userId) {
1359                    return _groupLocalService.getUserGroups(userId);
1360            }
1361    
1362            /**
1363            * Returns all the user's site groups and immediate organization groups,
1364            * optionally including the user's inherited organization groups and user
1365            * groups. System and staged groups are not included.
1366            *
1367            * @param userId the primary key of the user
1368            * @param inherit whether to include the user's inherited organization
1369            groups and user groups
1370            * @return the user's groups and immediate organization groups
1371            * @throws PortalException if a user with the primary key could not be found
1372            */
1373            @Override
1374            public java.util.List<com.liferay.portal.model.Group> getUserGroups(
1375                    long userId, boolean inherit)
1376                    throws com.liferay.portal.kernel.exception.PortalException {
1377                    return _groupLocalService.getUserGroups(userId, inherit);
1378            }
1379    
1380            /**
1381            * Returns an ordered range of all the user's site groups and immediate
1382            * organization groups, optionally including the user's inherited
1383            * organization groups and user groups. System and staged groups are not
1384            * included.
1385            *
1386            * <p>
1387            * Useful when paginating results. Returns a maximum of <code>end -
1388            * start</code> instances. <code>start</code> and <code>end</code> are not
1389            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1390            * refers to the first result in the set. Setting both <code>start</code>
1391            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1392            * result set.
1393            * </p>
1394            *
1395            * @param userId the primary key of the user
1396            * @param inherit whether to include the user's inherited organization
1397            groups and user groups
1398            * @param start the lower bound of the range of groups to return
1399            * @param end the upper bound of the range of groups to return (not
1400            inclusive)
1401            * @return the range of the user's groups and immediate organization groups
1402            ordered by name
1403            * @throws PortalException if a user with the primary key could not be found
1404            */
1405            @Override
1406            public java.util.List<com.liferay.portal.model.Group> getUserGroups(
1407                    long userId, boolean inherit, int start, int end)
1408                    throws com.liferay.portal.kernel.exception.PortalException {
1409                    return _groupLocalService.getUserGroups(userId, inherit, start, end);
1410            }
1411    
1412            @Override
1413            public java.util.List<com.liferay.portal.model.Group> getUserGroups(
1414                    long userId, int start, int end) {
1415                    return _groupLocalService.getUserGroups(userId, start, end);
1416            }
1417    
1418            /**
1419            * @throws PortalException
1420            */
1421            @Override
1422            public java.util.List<com.liferay.portal.model.Group> getUserGroups(
1423                    long userId, int start, int end,
1424                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> orderByComparator)
1425                    throws com.liferay.portal.kernel.exception.PortalException {
1426                    return _groupLocalService.getUserGroups(userId, start, end,
1427                            orderByComparator);
1428            }
1429    
1430            @Override
1431            public int getUserGroupsCount(long userId) {
1432                    return _groupLocalService.getUserGroupsCount(userId);
1433            }
1434    
1435            /**
1436            * Returns the groups associated with the user groups.
1437            *
1438            * @param userGroups the user groups
1439            * @return the groups associated with the user groups
1440            * @throws PortalException if any one of the user group's group could not be
1441            found
1442            */
1443            @Override
1444            public java.util.List<com.liferay.portal.model.Group> getUserGroupsGroups(
1445                    java.util.List<com.liferay.portal.model.UserGroup> userGroups)
1446                    throws com.liferay.portal.kernel.exception.PortalException {
1447                    return _groupLocalService.getUserGroupsGroups(userGroups);
1448            }
1449    
1450            /**
1451            * Returns all the groups related to the user groups.
1452            *
1453            * @param userGroups the user groups
1454            * @return the groups related to the user groups
1455            */
1456            @Override
1457            public java.util.List<com.liferay.portal.model.Group> getUserGroupsRelatedGroups(
1458                    java.util.List<com.liferay.portal.model.UserGroup> userGroups) {
1459                    return _groupLocalService.getUserGroupsRelatedGroups(userGroups);
1460            }
1461    
1462            /**
1463            * Returns the range of all groups associated with the user's organization
1464            * groups, including the ancestors of the organization groups, unless portal
1465            * property <code>organizations.membership.strict</code> is set to
1466            * <code>true</code>.
1467            *
1468            * <p>
1469            * Useful when paginating results. Returns a maximum of <code>end -
1470            * start</code> instances. <code>start</code> and <code>end</code> are not
1471            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1472            * refers to the first result in the set. Setting both <code>start</code>
1473            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1474            * result set.
1475            * </p>
1476            *
1477            * @param userId the primary key of the user
1478            * @param start the lower bound of the range of groups to consider
1479            * @param end the upper bound of the range of groups to consider (not
1480            inclusive)
1481            * @return the range of groups associated with the user's organization
1482            groups
1483            * @throws PortalException if a user with the primary key could not be found
1484            or if another portal exception occurred
1485            */
1486            @Override
1487            public java.util.List<com.liferay.portal.model.Group> getUserOrganizationsGroups(
1488                    long userId, int start, int end)
1489                    throws com.liferay.portal.kernel.exception.PortalException {
1490                    return _groupLocalService.getUserOrganizationsGroups(userId, start, end);
1491            }
1492    
1493            /**
1494            * Returns the default user's personal site group.
1495            *
1496            * @param companyId the primary key of the company
1497            * @return the default user's personal site group
1498            * @throws PortalException if a matching group or default user for the
1499            company could not be found
1500            */
1501            @Override
1502            public com.liferay.portal.model.Group getUserPersonalSiteGroup(
1503                    long companyId)
1504                    throws com.liferay.portal.kernel.exception.PortalException {
1505                    return _groupLocalService.getUserPersonalSiteGroup(companyId);
1506            }
1507    
1508            /**
1509            * Returns the userIds of the users associated with the group.
1510            *
1511            * @param groupId the groupId of the group
1512            * @return long[] the userIds of users associated with the group
1513            */
1514            @Override
1515            public long[] getUserPrimaryKeys(long groupId) {
1516                    return _groupLocalService.getUserPrimaryKeys(groupId);
1517            }
1518    
1519            @Override
1520            public java.util.List<com.liferay.portal.model.Group> getUserSitesGroups(
1521                    long userId) throws com.liferay.portal.kernel.exception.PortalException {
1522                    return _groupLocalService.getUserSitesGroups(userId);
1523            }
1524    
1525            @Override
1526            public java.util.List<com.liferay.portal.model.Group> getUserSitesGroups(
1527                    long userId, boolean includeAdministrative)
1528                    throws com.liferay.portal.kernel.exception.PortalException {
1529                    return _groupLocalService.getUserSitesGroups(userId,
1530                            includeAdministrative);
1531            }
1532    
1533            @Override
1534            public boolean hasOrganizationGroup(long organizationId, long groupId) {
1535                    return _groupLocalService.hasOrganizationGroup(organizationId, groupId);
1536            }
1537    
1538            @Override
1539            public boolean hasOrganizationGroups(long organizationId) {
1540                    return _groupLocalService.hasOrganizationGroups(organizationId);
1541            }
1542    
1543            @Override
1544            public boolean hasRoleGroup(long roleId, long groupId) {
1545                    return _groupLocalService.hasRoleGroup(roleId, groupId);
1546            }
1547    
1548            @Override
1549            public boolean hasRoleGroups(long roleId) {
1550                    return _groupLocalService.hasRoleGroups(roleId);
1551            }
1552    
1553            /**
1554            * Returns <code>true</code> if the live group has a staging group.
1555            *
1556            * @param liveGroupId the primary key of the live group
1557            * @return <code>true</code> if the live group has a staging group;
1558            <code>false</code> otherwise
1559            */
1560            @Override
1561            public boolean hasStagingGroup(long liveGroupId) {
1562                    return _groupLocalService.hasStagingGroup(liveGroupId);
1563            }
1564    
1565            @Override
1566            public boolean hasUserGroup(long userId, long groupId) {
1567                    return _groupLocalService.hasUserGroup(userId, groupId);
1568            }
1569    
1570            /**
1571            * Returns <code>true</code> if the user is immediately associated with the
1572            * group, or optionally if the user is associated with the group via the
1573            * user's organizations, inherited organizations, or user groups.
1574            *
1575            * @param userId the primary key of the user
1576            * @param groupId the primary key of the group
1577            * @param inherit whether to include organization groups and user groups to
1578            which the user belongs in the determination
1579            * @return <code>true</code> if the user is associated with the group;
1580            <code>false</code> otherwise
1581            */
1582            @Override
1583            public boolean hasUserGroup(long userId, long groupId, boolean inherit) {
1584                    return _groupLocalService.hasUserGroup(userId, groupId, inherit);
1585            }
1586    
1587            @Override
1588            public boolean hasUserGroupGroup(long userGroupId, long groupId) {
1589                    return _groupLocalService.hasUserGroupGroup(userGroupId, groupId);
1590            }
1591    
1592            @Override
1593            public boolean hasUserGroupGroups(long userGroupId) {
1594                    return _groupLocalService.hasUserGroupGroups(userGroupId);
1595            }
1596    
1597            @Override
1598            public boolean hasUserGroups(long userId) {
1599                    return _groupLocalService.hasUserGroups(userId);
1600            }
1601    
1602            /**
1603            * Returns the group with the matching group key by first searching the
1604            * system groups and then using the finder cache.
1605            *
1606            * @param companyId the primary key of the company
1607            * @param groupKey the group key
1608            * @return the group with the group key and associated company, or
1609            <code>null</code> if a matching group could not be found
1610            */
1611            @Override
1612            public com.liferay.portal.model.Group loadFetchGroup(long companyId,
1613                    java.lang.String groupKey) {
1614                    return _groupLocalService.loadFetchGroup(companyId, groupKey);
1615            }
1616    
1617            /**
1618            * Returns the group with the matching group key.
1619            *
1620            * @param companyId the primary key of the company
1621            * @param groupKey the group key
1622            * @return the group with the group key and associated company
1623            * @throws PortalException if a matching group could not be found
1624            */
1625            @Override
1626            public com.liferay.portal.model.Group loadGetGroup(long companyId,
1627                    java.lang.String groupKey)
1628                    throws com.liferay.portal.kernel.exception.PortalException {
1629                    return _groupLocalService.loadGetGroup(companyId, groupKey);
1630            }
1631    
1632            /**
1633            * Rebuilds the group tree.
1634            *
1635            * <p>
1636            * Only call this method if the tree has become stale through operations
1637            * other than normal CRUD. Under normal circumstances the tree is
1638            * automatically rebuilt whenever necessary.
1639            * </p>
1640            *
1641            * @param companyId the primary key of the group's company
1642            * @throws PortalException if a group with the primary key could not be
1643            found
1644            */
1645            @Override
1646            public void rebuildTree(long companyId)
1647                    throws com.liferay.portal.kernel.exception.PortalException {
1648                    _groupLocalService.rebuildTree(companyId);
1649            }
1650    
1651            /**
1652            * Returns an ordered range of all the groups that match the class name IDs
1653            * and keywords, optionally including the user's inherited organization
1654            * groups and user groups. System and staged groups are not included.
1655            *
1656            * <p>
1657            * Useful when paginating results. Returns a maximum of <code>end -
1658            * start</code> instances. <code>start</code> and <code>end</code> are not
1659            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1660            * refers to the first result in the set. Setting both <code>start</code>
1661            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1662            * result set.
1663            * </p>
1664            *
1665            * @param companyId the primary key of the company
1666            * @param classNameIds the primary keys of the class names of the entities
1667            the groups are related to (optionally <code>null</code>)
1668            * @param keywords the keywords (space separated), which may occur in the
1669            sites's name, or description (optionally <code>null</code>)
1670            * @param params the finder params (optionally <code>null</code>). To
1671            include a user's organizations, inherited organizations, and user
1672            groups in the search, add an entry with key
1673            &quot;usersGroups&quot; mapped to the user's ID and an entry with
1674            key &quot;inherit&quot; mapped to a non-<code>null</code> object.
1675            For more information see {@link
1676            com.liferay.portal.service.persistence.GroupFinder}.
1677            * @param start the lower bound of the range of groups to return
1678            * @param end the upper bound of the range of groups to return (not
1679            inclusive)
1680            * @return the matching groups ordered by name
1681            */
1682            @Override
1683            public java.util.List<com.liferay.portal.model.Group> search(
1684                    long companyId, long[] classNameIds, java.lang.String keywords,
1685                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
1686                    int start, int end) {
1687                    return _groupLocalService.search(companyId, classNameIds, keywords,
1688                            params, start, end);
1689            }
1690    
1691            /**
1692            * Returns an ordered range of all the groups that match the class name IDs
1693            * and keywords, optionally including the user's inherited organization
1694            * groups and user groups. System and staged groups are not included.
1695            *
1696            * <p>
1697            * Useful when paginating results. Returns a maximum of <code>end -
1698            * start</code> instances. <code>start</code> and <code>end</code> are not
1699            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1700            * refers to the first result in the set. Setting both <code>start</code>
1701            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1702            * result set.
1703            * </p>
1704            *
1705            * @param companyId the primary key of the company
1706            * @param classNameIds the primary keys of the class names of the entities
1707            the groups are related to (optionally <code>null</code>)
1708            * @param keywords the keywords (space separated), which may occur in the
1709            sites's name, or description (optionally <code>null</code>)
1710            * @param params the finder params (optionally <code>null</code>). To
1711            include a user's organizations, inherited organizations, and user
1712            groups in the search, add an entry with key
1713            &quot;usersGroups&quot; mapped to the user's ID and an entry with
1714            key &quot;inherit&quot; mapped to a non-<code>null</code> object.
1715            For more information see {@link
1716            com.liferay.portal.service.persistence.GroupFinder}.
1717            * @param start the lower bound of the range of groups to return
1718            * @param end the upper bound of the range of groups to return (not
1719            inclusive)
1720            * @param obc the comparator to order the groups (optionally
1721            <code>null</code>)
1722            * @return the matching groups ordered by comparator <code>obc</code>
1723            */
1724            @Override
1725            public java.util.List<com.liferay.portal.model.Group> search(
1726                    long companyId, long[] classNameIds, java.lang.String keywords,
1727                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
1728                    int start, int end,
1729                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> obc) {
1730                    return _groupLocalService.search(companyId, classNameIds, keywords,
1731                            params, start, end, obc);
1732            }
1733    
1734            /**
1735            * Returns an ordered range of all the groups that match the class name IDs,
1736            * name, and description, optionally including the user's inherited
1737            * organization groups and user groups. System and staged groups are not
1738            * included.
1739            *
1740            * <p>
1741            * Useful when paginating results. Returns a maximum of <code>end -
1742            * start</code> instances. <code>start</code> and <code>end</code> are not
1743            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1744            * refers to the first result in the set. Setting both <code>start</code>
1745            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1746            * result set.
1747            * </p>
1748            *
1749            * @param companyId the primary key of the company
1750            * @param classNameIds the primary keys of the class names of the entities
1751            the groups are related to (optionally <code>null</code>)
1752            * @param name the group's name (optionally <code>null</code>)
1753            * @param description the group's description (optionally
1754            <code>null</code>)
1755            * @param params the finder params (optionally <code>null</code>). To
1756            include a user's organizations, inherited organizations, and user
1757            groups in the search, add an entry with key
1758            &quot;usersGroups&quot; mapped to the user's ID and an entry with
1759            key &quot;inherit&quot; mapped to a non-<code>null</code> object.
1760            For more information see {@link
1761            com.liferay.portal.service.persistence.GroupFinder}.
1762            * @param andOperator whether every field must match its keywords, or just
1763            one field.
1764            * @param start the lower bound of the range of groups to return
1765            * @param end the upper bound of the range of groups to return (not
1766            inclusive)
1767            * @return the matching groups ordered by name
1768            */
1769            @Override
1770            public java.util.List<com.liferay.portal.model.Group> search(
1771                    long companyId, long[] classNameIds, java.lang.String name,
1772                    java.lang.String description,
1773                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
1774                    boolean andOperator, int start, int end) {
1775                    return _groupLocalService.search(companyId, classNameIds, name,
1776                            description, params, andOperator, start, end);
1777            }
1778    
1779            /**
1780            * Returns an ordered range of all the groups that match the class name IDs,
1781            * name, and description, optionally including the user's inherited
1782            * organization groups and user groups. System and staged groups are not
1783            * included.
1784            *
1785            * <p>
1786            * Useful when paginating results. Returns a maximum of <code>end -
1787            * start</code> instances. <code>start</code> and <code>end</code> are not
1788            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1789            * refers to the first result in the set. Setting both <code>start</code>
1790            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1791            * result set.
1792            * </p>
1793            *
1794            * @param companyId the primary key of the company
1795            * @param classNameIds the primary keys of the class names of the entities
1796            the groups are related to (optionally <code>null</code>)
1797            * @param name the group's name (optionally <code>null</code>)
1798            * @param description the group's description (optionally
1799            <code>null</code>)
1800            * @param params the finder params (optionally <code>null</code>). To
1801            include a user's organizations, inherited organizations, and user
1802            groups in the search, add an entry with key
1803            &quot;usersGroups&quot; mapped to the user's ID and an entry with
1804            key &quot;inherit&quot; mapped to a non-<code>null</code> object.
1805            For more information see {@link
1806            com.liferay.portal.service.persistence.GroupFinder}.
1807            * @param andOperator whether every field must match its keywords, or just
1808            one field.
1809            * @param start the lower bound of the range of groups to return
1810            * @param end the upper bound of the range of groups to return (not
1811            inclusive)
1812            * @param obc the comparator to order the groups (optionally
1813            <code>null</code>)
1814            * @return the matching groups ordered by comparator <code>obc</code>
1815            */
1816            @Override
1817            public java.util.List<com.liferay.portal.model.Group> search(
1818                    long companyId, long[] classNameIds, java.lang.String name,
1819                    java.lang.String description,
1820                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
1821                    boolean andOperator, int start, int end,
1822                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> obc) {
1823                    return _groupLocalService.search(companyId, classNameIds, name,
1824                            description, params, andOperator, start, end, obc);
1825            }
1826    
1827            /**
1828            * Returns an ordered range of all the groups belonging to the parent group
1829            * that match the class name IDs and keywords, optionally including the
1830            * user's inherited organization groups and user groups. System and staged
1831            * groups are not included.
1832            *
1833            * <p>
1834            * Useful when paginating results. Returns a maximum of <code>end -
1835            * start</code> instances. <code>start</code> and <code>end</code> are not
1836            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1837            * refers to the first result in the set. Setting both <code>start</code>
1838            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1839            * result set.
1840            * </p>
1841            *
1842            * @param companyId the primary key of the company
1843            * @param classNameIds the primary keys of the class names of the entities
1844            the groups are related to (optionally <code>null</code>)
1845            * @param parentGroupId the primary key of the parent group
1846            * @param keywords the keywords (space separated), which may occur in the
1847            sites's name, or description (optionally <code>null</code>)
1848            * @param params the finder params (optionally <code>null</code>). To
1849            include a user's organizations, inherited organizations, and user
1850            groups in the search, add an entry with key
1851            &quot;usersGroups&quot; mapped to the user's ID and an entry with
1852            key &quot;inherit&quot; mapped to a non-<code>null</code> object.
1853            For more information see {@link
1854            com.liferay.portal.service.persistence.GroupFinder}.
1855            * @param start the lower bound of the range of groups to return
1856            * @param end the upper bound of the range of groups to return (not
1857            inclusive)
1858            * @return the matching groups ordered by name
1859            */
1860            @Override
1861            public java.util.List<com.liferay.portal.model.Group> search(
1862                    long companyId, long[] classNameIds, long parentGroupId,
1863                    java.lang.String keywords,
1864                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
1865                    int start, int end) {
1866                    return _groupLocalService.search(companyId, classNameIds,
1867                            parentGroupId, keywords, params, start, end);
1868            }
1869    
1870            /**
1871            * Returns an ordered range of all the groups belonging to the parent group
1872            * that match the class name IDs and keywords, optionally including the
1873            * user's inherited organization groups and user groups. System and staged
1874            * groups are not included.
1875            *
1876            * <p>
1877            * Useful when paginating results. Returns a maximum of <code>end -
1878            * start</code> instances. <code>start</code> and <code>end</code> are not
1879            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1880            * refers to the first result in the set. Setting both <code>start</code>
1881            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1882            * result set.
1883            * </p>
1884            *
1885            * @param companyId the primary key of the company
1886            * @param classNameIds the primary keys of the class names of the entities
1887            the groups are related to (optionally <code>null</code>)
1888            * @param parentGroupId the primary key of the parent group
1889            * @param keywords the keywords (space separated), which may occur in the
1890            sites's name, or description (optionally <code>null</code>)
1891            * @param params the finder params (optionally <code>null</code>). To
1892            include a user's organizations, inherited organizations, and user
1893            groups in the search, add an entry with key
1894            &quot;usersGroups&quot; mapped to the user's ID and an entry with
1895            key &quot;inherit&quot; mapped to a non-<code>null</code> object.
1896            For more information see {@link
1897            com.liferay.portal.service.persistence.GroupFinder}.
1898            * @param start the lower bound of the range of groups to return
1899            * @param end the upper bound of the range of groups to return (not
1900            inclusive)
1901            * @param obc the comparator to order the groups (optionally
1902            <code>null</code>)
1903            * @return the matching groups ordered by comparator <code>obc</code>
1904            */
1905            @Override
1906            public java.util.List<com.liferay.portal.model.Group> search(
1907                    long companyId, long[] classNameIds, long parentGroupId,
1908                    java.lang.String keywords,
1909                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
1910                    int start, int end,
1911                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> obc) {
1912                    return _groupLocalService.search(companyId, classNameIds,
1913                            parentGroupId, keywords, params, start, end, obc);
1914            }
1915    
1916            /**
1917            * Returns an ordered range of all the groups belonging to the parent group
1918            * that match the class name IDs, name, and description, optionally
1919            * including the user's inherited organization groups and user groups.
1920            * System and staged groups are not included.
1921            *
1922            * <p>
1923            * Useful when paginating results. Returns a maximum of <code>end -
1924            * start</code> instances. <code>start</code> and <code>end</code> are not
1925            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1926            * refers to the first result in the set. Setting both <code>start</code>
1927            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1928            * result set.
1929            * </p>
1930            *
1931            * @param companyId the primary key of the company
1932            * @param classNameIds the primary keys of the class names of the entities
1933            the groups are related to (optionally <code>null</code>)
1934            * @param parentGroupId the primary key of the parent group
1935            * @param name the group's name (optionally <code>null</code>)
1936            * @param description the group's description (optionally
1937            <code>null</code>)
1938            * @param params the finder params (optionally <code>null</code>). To
1939            include a user's organizations, inherited organizations, and user
1940            groups in the search, add an entry with key
1941            &quot;usersGroups&quot; mapped to the user's ID and an entry with
1942            key &quot;inherit&quot; mapped to a non-<code>null</code> object.
1943            For more information see {@link
1944            com.liferay.portal.service.persistence.GroupFinder}.
1945            * @param andOperator whether every field must match its keywords, or just
1946            one field.
1947            * @param start the lower bound of the range of groups to return
1948            * @param end the upper bound of the range of groups to return (not
1949            inclusive)
1950            * @return the matching groups ordered by name
1951            */
1952            @Override
1953            public java.util.List<com.liferay.portal.model.Group> search(
1954                    long companyId, long[] classNameIds, long parentGroupId,
1955                    java.lang.String name, java.lang.String description,
1956                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
1957                    boolean andOperator, int start, int end) {
1958                    return _groupLocalService.search(companyId, classNameIds,
1959                            parentGroupId, name, description, params, andOperator, start, end);
1960            }
1961    
1962            /**
1963            * Returns an ordered range of all the groups belonging to the parent group
1964            * that match the class name IDs, name, and description, optionally
1965            * including the user's inherited organization groups and user groups.
1966            * System and staged groups are not included.
1967            *
1968            * <p>
1969            * Useful when paginating results. Returns a maximum of <code>end -
1970            * start</code> instances. <code>start</code> and <code>end</code> are not
1971            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1972            * refers to the first result in the set. Setting both <code>start</code>
1973            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
1974            * result set.
1975            * </p>
1976            *
1977            * @param companyId the primary key of the company
1978            * @param classNameIds the primary keys of the class names of the entities
1979            the groups are related to (optionally <code>null</code>)
1980            * @param parentGroupId the primary key of the parent group
1981            * @param name the group's name (optionally <code>null</code>)
1982            * @param description the group's description (optionally
1983            <code>null</code>)
1984            * @param params the finder params (optionally <code>null</code>). To
1985            include a user's organizations, inherited organizations, and user
1986            groups in the search, add an entry with key
1987            &quot;usersGroups&quot; mapped to the user's ID and an entry with
1988            key &quot;inherit&quot; mapped to a non-<code>null</code> object.
1989            For more information see {@link
1990            com.liferay.portal.service.persistence.GroupFinder}.
1991            * @param andOperator whether every field must match its keywords, or just
1992            one field.
1993            * @param start the lower bound of the range of groups to return
1994            * @param end the upper bound of the range of groups to return (not
1995            inclusive)
1996            * @param obc the comparator to order the groups (optionally
1997            <code>null</code>)
1998            * @return the matching groups ordered by comparator <code>obc</code>
1999            */
2000            @Override
2001            public java.util.List<com.liferay.portal.model.Group> search(
2002                    long companyId, long[] classNameIds, long parentGroupId,
2003                    java.lang.String name, java.lang.String description,
2004                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2005                    boolean andOperator, int start, int end,
2006                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> obc) {
2007                    return _groupLocalService.search(companyId, classNameIds,
2008                            parentGroupId, name, description, params, andOperator, start, end,
2009                            obc);
2010            }
2011    
2012            /**
2013            * Returns an ordered range of all the groups that match the keywords,
2014            * optionally including the user's inherited organization groups and user
2015            * groups. System and staged groups are not included.
2016            *
2017            * <p>
2018            * Useful when paginating results. Returns a maximum of <code>end -
2019            * start</code> instances. <code>start</code> and <code>end</code> are not
2020            * primary keys, they are indexes in the result set. Thus, <code>0</code>
2021            * refers to the first result in the set. Setting both <code>start</code>
2022            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
2023            * result set.
2024            * </p>
2025            *
2026            * @param companyId the primary key of the company
2027            * @param keywords the keywords (space separated), which may occur in the
2028            sites's name, or description (optionally <code>null</code>)
2029            * @param params the finder params (optionally <code>null</code>). To
2030            include the user's inherited organizations and user groups in the
2031            search, add entries having &quot;usersGroups&quot; and
2032            &quot;inherit&quot; as keys mapped to the the user's ID. For more
2033            information see {@link
2034            com.liferay.portal.service.persistence.GroupFinder}.
2035            * @param start the lower bound of the range of groups to return
2036            * @param end the upper bound of the range of groups to return (not
2037            inclusive)
2038            * @return the matching groups ordered by name
2039            */
2040            @Override
2041            public java.util.List<com.liferay.portal.model.Group> search(
2042                    long companyId, java.lang.String keywords,
2043                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2044                    int start, int end) {
2045                    return _groupLocalService.search(companyId, keywords, params, start, end);
2046            }
2047    
2048            /**
2049            * Returns an ordered range of all the groups that match the keywords,
2050            * optionally including the user's inherited organization groups and user
2051            * groups. System and staged groups are not included.
2052            *
2053            * <p>
2054            * Useful when paginating results. Returns a maximum of <code>end -
2055            * start</code> instances. <code>start</code> and <code>end</code> are not
2056            * primary keys, they are indexes in the result set. Thus, <code>0</code>
2057            * refers to the first result in the set. Setting both <code>start</code>
2058            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
2059            * result set.
2060            * </p>
2061            *
2062            * @param companyId the primary key of the company
2063            * @param keywords the keywords (space separated), which may occur in the
2064            sites's name, or description (optionally <code>null</code>)
2065            * @param params the finder params (optionally <code>null</code>). To
2066            include the user's inherited organizations and user groups in the
2067            search, add entries having &quot;usersGroups&quot; and
2068            &quot;inherit&quot; as keys mapped to the the user's ID. For more
2069            information see {@link
2070            com.liferay.portal.service.persistence.GroupFinder}.
2071            * @param start the lower bound of the range of groups to return
2072            * @param end the upper bound of the range of groups to return (not
2073            inclusive)
2074            * @param obc the comparator to order the groups (optionally
2075            <code>null</code>)
2076            * @return the matching groups ordered by comparator <code>obc</code>
2077            */
2078            @Override
2079            public java.util.List<com.liferay.portal.model.Group> search(
2080                    long companyId, java.lang.String keywords,
2081                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2082                    int start, int end,
2083                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> obc) {
2084                    return _groupLocalService.search(companyId, keywords, params, start,
2085                            end, obc);
2086            }
2087    
2088            /**
2089            * Returns an ordered range of all the site groups and organization groups
2090            * that match the name and description, optionally including the user's
2091            * inherited organization groups and user groups. System and staged groups
2092            * are not included.
2093            *
2094            * <p>
2095            * Useful when paginating results. Returns a maximum of <code>end -
2096            * start</code> instances. <code>start</code> and <code>end</code> are not
2097            * primary keys, they are indexes in the result set. Thus, <code>0</code>
2098            * refers to the first result in the set. Setting both <code>start</code>
2099            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
2100            * result set.
2101            * </p>
2102            *
2103            * @param companyId the primary key of the company
2104            * @param name the group's name (optionally <code>null</code>)
2105            * @param description the group's description (optionally
2106            <code>null</code>)
2107            * @param params the finder params (optionally <code>null</code>). To
2108            include the user's inherited organizations and user groups in the
2109            search, add entries having &quot;usersGroups&quot; and
2110            &quot;inherit&quot; as keys mapped to the the user's ID. For more
2111            information see {@link
2112            com.liferay.portal.service.persistence.GroupFinder}.
2113            * @param andOperator whether every field must match its keywords, or just
2114            one field.
2115            * @param start the lower bound of the range of groups to return
2116            * @param end the upper bound of the range of groups to return (not
2117            inclusive)
2118            * @return the matching groups ordered by name
2119            */
2120            @Override
2121            public java.util.List<com.liferay.portal.model.Group> search(
2122                    long companyId, java.lang.String name, java.lang.String description,
2123                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2124                    boolean andOperator, int start, int end) {
2125                    return _groupLocalService.search(companyId, name, description, params,
2126                            andOperator, start, end);
2127            }
2128    
2129            /**
2130            * Returns an ordered range of all the site groups and organization groups
2131            * that match the name and description, optionally including the user's
2132            * inherited organization groups and user groups. System and staged groups
2133            * are not included.
2134            *
2135            * <p>
2136            * Useful when paginating results. Returns a maximum of <code>end -
2137            * start</code> instances. <code>start</code> and <code>end</code> are not
2138            * primary keys, they are indexes in the result set. Thus, <code>0</code>
2139            * refers to the first result in the set. Setting both <code>start</code>
2140            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
2141            * result set.
2142            * </p>
2143            *
2144            * @param companyId the primary key of the company
2145            * @param name the group's name (optionally <code>null</code>)
2146            * @param description the group's description (optionally
2147            <code>null</code>)
2148            * @param params the finder params (optionally <code>null</code>). To
2149            include the user's inherited organizations and user groups in the
2150            search, add entries having &quot;usersGroups&quot; and
2151            &quot;inherit&quot; as keys mapped to the the user's ID. For more
2152            information see {@link
2153            com.liferay.portal.service.persistence.GroupFinder}.
2154            * @param andOperator whether every field must match its keywords, or just
2155            one field.
2156            * @param start the lower bound of the range of groups to return
2157            * @param end the upper bound of the range of groups to return (not
2158            inclusive)
2159            * @param obc the comparator to order the groups (optionally
2160            <code>null</code>)
2161            * @return the matching groups ordered by comparator <code>obc</code>
2162            */
2163            @Override
2164            public java.util.List<com.liferay.portal.model.Group> search(
2165                    long companyId, java.lang.String name, java.lang.String description,
2166                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2167                    boolean andOperator, int start, int end,
2168                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> obc) {
2169                    return _groupLocalService.search(companyId, name, description, params,
2170                            andOperator, start, end, obc);
2171            }
2172    
2173            /**
2174            * Returns an ordered range of all the company's groups, optionally
2175            * including the user's inherited organization groups and user groups.
2176            * System and staged groups are not included.
2177            *
2178            * <p>
2179            * Useful when paginating results. Returns a maximum of <code>end -
2180            * start</code> instances. <code>start</code> and <code>end</code> are not
2181            * primary keys, they are indexes in the result set. Thus, <code>0</code>
2182            * refers to the first result in the set. Setting both <code>start</code>
2183            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
2184            * result set.
2185            * </p>
2186            *
2187            * @param companyId the primary key of the company
2188            * @param params the finder params (optionally <code>null</code>). To
2189            include a user's organizations, inherited organizations, and user
2190            groups in the search, add an entry with key
2191            &quot;usersGroups&quot; mapped to the user's ID and an entry with
2192            key &quot;inherit&quot; mapped to a non-<code>null</code> object.
2193            For more information see {@link
2194            com.liferay.portal.service.persistence.GroupFinder}.
2195            * @param start the lower bound of the range of groups to return
2196            * @param end the upper bound of the range of groups to return (not
2197            inclusive)
2198            * @return the matching groups ordered by name
2199            */
2200            @Override
2201            public java.util.List<com.liferay.portal.model.Group> search(
2202                    long companyId,
2203                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2204                    int start, int end) {
2205                    return _groupLocalService.search(companyId, params, start, end);
2206            }
2207    
2208            /**
2209            * Returns an ordered range of all the groups belonging to the parent group
2210            * that match the keywords, optionally including the user's inherited
2211            * organization groups and user groups. System and staged groups are not
2212            * included.
2213            *
2214            * <p>
2215            * Useful when paginating results. Returns a maximum of <code>end -
2216            * start</code> instances. <code>start</code> and <code>end</code> are not
2217            * primary keys, they are indexes in the result set. Thus, <code>0</code>
2218            * refers to the first result in the set. Setting both <code>start</code>
2219            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
2220            * result set.
2221            * </p>
2222            *
2223            * @param companyId the primary key of the company
2224            * @param parentGroupId the primary key of the parent group
2225            * @param keywords the keywords (space separated), which may occur in the
2226            sites's name, or description (optionally <code>null</code>)
2227            * @param params the finder params (optionally <code>null</code>). To
2228            include the user's inherited organizations and user groups in the
2229            search, add entries having &quot;usersGroups&quot; and
2230            &quot;inherit&quot; as keys mapped to the the user's ID. For more
2231            information see {@link
2232            com.liferay.portal.service.persistence.GroupFinder}.
2233            * @param start the lower bound of the range of groups to return
2234            * @param end the upper bound of the range of groups to return (not
2235            inclusive)
2236            * @return the matching groups ordered by name
2237            */
2238            @Override
2239            public java.util.List<com.liferay.portal.model.Group> search(
2240                    long companyId, long parentGroupId, java.lang.String keywords,
2241                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2242                    int start, int end) {
2243                    return _groupLocalService.search(companyId, parentGroupId, keywords,
2244                            params, start, end);
2245            }
2246    
2247            /**
2248            * Returns an ordered range of all the groups belonging to the parent group
2249            * that match the keywords, optionally including the user's inherited
2250            * organization groups and user groups. System and staged groups are not
2251            * included.
2252            *
2253            * <p>
2254            * Useful when paginating results. Returns a maximum of <code>end -
2255            * start</code> instances. <code>start</code> and <code>end</code> are not
2256            * primary keys, they are indexes in the result set. Thus, <code>0</code>
2257            * refers to the first result in the set. Setting both <code>start</code>
2258            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
2259            * result set.
2260            * </p>
2261            *
2262            * @param companyId the primary key of the company
2263            * @param parentGroupId the primary key of the parent group
2264            * @param keywords the keywords (space separated), which may occur in the
2265            sites's name, or description (optionally <code>null</code>)
2266            * @param params the finder params (optionally <code>null</code>). To
2267            include the user's inherited organizations and user groups in the
2268            search, add entries having &quot;usersGroups&quot; and
2269            &quot;inherit&quot; as keys mapped to the the user's ID. For more
2270            information see {@link
2271            com.liferay.portal.service.persistence.GroupFinder}.
2272            * @param start the lower bound of the range of groups to return
2273            * @param end the upper bound of the range of groups to return (not
2274            inclusive)
2275            * @param obc the comparator to order the groups (optionally
2276            <code>null</code>)
2277            * @return the matching groups ordered by comparator <code>obc</code>
2278            */
2279            @Override
2280            public java.util.List<com.liferay.portal.model.Group> search(
2281                    long companyId, long parentGroupId, java.lang.String keywords,
2282                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2283                    int start, int end,
2284                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> obc) {
2285                    return _groupLocalService.search(companyId, parentGroupId, keywords,
2286                            params, start, end, obc);
2287            }
2288    
2289            /**
2290            * Returns an ordered range of all the site groups belonging to the parent
2291            * group and organization groups that match the name and description,
2292            * optionally including the user's inherited organization groups and user
2293            * groups. System and staged groups are not included.
2294            *
2295            * <p>
2296            * Useful when paginating results. Returns a maximum of <code>end -
2297            * start</code> instances. <code>start</code> and <code>end</code> are not
2298            * primary keys, they are indexes in the result set. Thus, <code>0</code>
2299            * refers to the first result in the set. Setting both <code>start</code>
2300            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
2301            * result set.
2302            * </p>
2303            *
2304            * @param companyId the primary key of the company
2305            * @param parentGroupId the primary key of the parent group
2306            * @param name the group's name (optionally <code>null</code>)
2307            * @param description the group's description (optionally
2308            <code>null</code>)
2309            * @param params the finder params (optionally <code>null</code>). To
2310            include the user's inherited organizations and user groups in the
2311            search, add entries having &quot;usersGroups&quot; and
2312            &quot;inherit&quot; as keys mapped to the the user's ID. For more
2313            information see {@link
2314            com.liferay.portal.service.persistence.GroupFinder}.
2315            * @param andOperator whether every field must match its keywords, or just
2316            one field.
2317            * @param start the lower bound of the range of groups to return
2318            * @param end the upper bound of the range of groups to return (not
2319            inclusive)
2320            * @return the matching groups ordered by name
2321            */
2322            @Override
2323            public java.util.List<com.liferay.portal.model.Group> search(
2324                    long companyId, long parentGroupId, java.lang.String name,
2325                    java.lang.String description,
2326                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2327                    boolean andOperator, int start, int end) {
2328                    return _groupLocalService.search(companyId, parentGroupId, name,
2329                            description, params, andOperator, start, end);
2330            }
2331    
2332            /**
2333            * Returns an ordered range of all the site groups belonging to the parent
2334            * group and organization groups that match the name and description,
2335            * optionally including the user's inherited organization groups and user
2336            * groups. System and staged groups are not included.
2337            *
2338            * <p>
2339            * Useful when paginating results. Returns a maximum of <code>end -
2340            * start</code> instances. <code>start</code> and <code>end</code> are not
2341            * primary keys, they are indexes in the result set. Thus, <code>0</code>
2342            * refers to the first result in the set. Setting both <code>start</code>
2343            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
2344            * result set.
2345            * </p>
2346            *
2347            * @param companyId the primary key of the company
2348            * @param parentGroupId the primary key of the parent group
2349            * @param name the group's name (optionally <code>null</code>)
2350            * @param description the group's description (optionally
2351            <code>null</code>)
2352            * @param params the finder params (optionally <code>null</code>). To
2353            include the user's inherited organizations and user groups in the
2354            search, add entries having &quot;usersGroups&quot; and
2355            &quot;inherit&quot; as keys mapped to the the user's ID. For more
2356            information see {@link
2357            com.liferay.portal.service.persistence.GroupFinder}.
2358            * @param andOperator whether every field must match its keywords, or just
2359            one field.
2360            * @param start the lower bound of the range of groups to return
2361            * @param end the upper bound of the range of groups to return (not
2362            inclusive)
2363            * @param obc the comparator to order the groups (optionally
2364            <code>null</code>)
2365            * @return the matching groups ordered by comparator <code>obc</code>
2366            */
2367            @Override
2368            public java.util.List<com.liferay.portal.model.Group> search(
2369                    long companyId, long parentGroupId, java.lang.String name,
2370                    java.lang.String description,
2371                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2372                    boolean andOperator, int start, int end,
2373                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Group> obc) {
2374                    return _groupLocalService.search(companyId, parentGroupId, name,
2375                            description, params, andOperator, start, end, obc);
2376            }
2377    
2378            /**
2379            * Returns the number of groups that match the class name IDs, and keywords,
2380            * optionally including the user's inherited organization groups and user
2381            * groups. System and staged groups are not included.
2382            *
2383            * @param companyId the primary key of the company
2384            * @param classNameIds the primary keys of the class names of the entities
2385            the groups are related to (optionally <code>null</code>)
2386            * @param keywords the keywords (space separated), which may occur in the
2387            sites's name, or description (optionally <code>null</code>)
2388            * @param params the finder params (optionally <code>null</code>). To
2389            include the user's inherited organization groups and user groups
2390            in the search, add entries having &quot;usersGroups&quot; and
2391            &quot;inherit&quot; as keys mapped to the the user's ID. For more
2392            information see {@link
2393            com.liferay.portal.service.persistence.GroupFinder}.
2394            * @return the number of matching groups
2395            */
2396            @Override
2397            public int searchCount(long companyId, long[] classNameIds,
2398                    java.lang.String keywords,
2399                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params) {
2400                    return _groupLocalService.searchCount(companyId, classNameIds,
2401                            keywords, params);
2402            }
2403    
2404            /**
2405            * Returns the number of groups that match the class name IDs, name, and
2406            * description, optionally including the user's inherited organization
2407            * groups and user groups. System and staged groups are not included.
2408            *
2409            * @param companyId the primary key of the company
2410            * @param classNameIds the primary keys of the class names of the entities
2411            the groups are related to (optionally <code>null</code>)
2412            * @param name the group's name (optionally <code>null</code>)
2413            * @param description the group's description (optionally
2414            <code>null</code>)
2415            * @param params the finder params (optionally <code>null</code>). To
2416            include the user's inherited organization groups and user groups
2417            in the search, add entries having &quot;usersGroups&quot; and
2418            &quot;inherit&quot; as keys mapped to the the user's ID. For more
2419            information see {@link
2420            com.liferay.portal.service.persistence.GroupFinder}.
2421            * @param andOperator whether every field must match its keywords, or just
2422            one field.
2423            * @return the number of matching groups
2424            */
2425            @Override
2426            public int searchCount(long companyId, long[] classNameIds,
2427                    java.lang.String name, java.lang.String description,
2428                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2429                    boolean andOperator) {
2430                    return _groupLocalService.searchCount(companyId, classNameIds, name,
2431                            description, params, andOperator);
2432            }
2433    
2434            /**
2435            * Returns the number of groups belonging to the parent group that match the
2436            * class name IDs, and keywords, optionally including the user's inherited
2437            * organization groups and user groups. System and staged groups are not
2438            * included.
2439            *
2440            * @param companyId the primary key of the company
2441            * @param classNameIds the primary keys of the class names of the entities
2442            the groups are related to (optionally <code>null</code>)
2443            * @param parentGroupId the primary key of the parent group
2444            * @param keywords the keywords (space separated), which may occur in the
2445            sites's name, or description (optionally <code>null</code>)
2446            * @param params the finder params (optionally <code>null</code>). To
2447            include the user's inherited organization groups and user groups
2448            in the search, add entries having &quot;usersGroups&quot; and
2449            &quot;inherit&quot; as keys mapped to the the user's ID. For more
2450            information see {@link
2451            com.liferay.portal.service.persistence.GroupFinder}.
2452            * @return the number of matching groups
2453            */
2454            @Override
2455            public int searchCount(long companyId, long[] classNameIds,
2456                    long parentGroupId, java.lang.String keywords,
2457                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params) {
2458                    return _groupLocalService.searchCount(companyId, classNameIds,
2459                            parentGroupId, keywords, params);
2460            }
2461    
2462            /**
2463            * Returns the number of groups belonging to the parent group that match the
2464            * class name IDs, name, and description, optionally including the user's
2465            * inherited organization groups and user groups. System and staged groups
2466            * are not included.
2467            *
2468            * @param companyId the primary key of the company
2469            * @param classNameIds the primary keys of the class names of the entities
2470            the groups are related to (optionally <code>null</code>)
2471            * @param parentGroupId the primary key of the parent group
2472            * @param name the group's name (optionally <code>null</code>)
2473            * @param description the group's description (optionally
2474            <code>null</code>)
2475            * @param params the finder params (optionally <code>null</code>). To
2476            include the user's inherited organization groups and user groups
2477            in the search, add entries having &quot;usersGroups&quot; and
2478            &quot;inherit&quot; as keys mapped to the the user's ID. For more
2479            information see {@link
2480            com.liferay.portal.service.persistence.GroupFinder}.
2481            * @param andOperator whether every field must match its keywords, or just
2482            one field.
2483            * @return the number of matching groups
2484            */
2485            @Override
2486            public int searchCount(long companyId, long[] classNameIds,
2487                    long parentGroupId, java.lang.String name,
2488                    java.lang.String description,
2489                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2490                    boolean andOperator) {
2491                    return _groupLocalService.searchCount(companyId, classNameIds,
2492                            parentGroupId, name, description, params, andOperator);
2493            }
2494    
2495            /**
2496            * Returns the number of groups that match the keywords, optionally
2497            * including the user's inherited organization groups and user groups.
2498            * System and staged groups are not included.
2499            *
2500            * @param companyId the primary key of the company
2501            * @param keywords the keywords (space separated), which may occur in the
2502            sites's name, or description (optionally <code>null</code>)
2503            * @param params the finder params (optionally <code>null</code>). To
2504            include the user's inherited organization groups and user groups
2505            in the search, add entries having &quot;usersGroups&quot; and
2506            &quot;inherit&quot; as keys mapped to the the user's ID. For more
2507            information see {@link
2508            com.liferay.portal.service.persistence.GroupFinder}.
2509            * @return the number of matching groups
2510            */
2511            @Override
2512            public int searchCount(long companyId, java.lang.String keywords,
2513                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params) {
2514                    return _groupLocalService.searchCount(companyId, keywords, params);
2515            }
2516    
2517            /**
2518            * Returns the number of groups and immediate organization groups that match
2519            * the name and description, optionally including the user's inherited
2520            * organization groups and user groups. System and staged groups are not
2521            * included.
2522            *
2523            * @param companyId the primary key of the company
2524            * @param name the group's name (optionally <code>null</code>)
2525            * @param description the group's description (optionally
2526            <code>null</code>)
2527            * @param params the finder params (optionally <code>null</code>). To
2528            include the user's inherited organization groups and user groups
2529            in the search, add entries having &quot;usersGroups&quot; and
2530            &quot;inherit&quot; as keys mapped to the the user's ID. For more
2531            information see {@link
2532            com.liferay.portal.service.persistence.GroupFinder}.
2533            * @param andOperator whether every field must match its keywords, or just
2534            one field.
2535            * @return the number of matching groups
2536            */
2537            @Override
2538            public int searchCount(long companyId, java.lang.String name,
2539                    java.lang.String description,
2540                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2541                    boolean andOperator) {
2542                    return _groupLocalService.searchCount(companyId, name, description,
2543                            params, andOperator);
2544            }
2545    
2546            /**
2547            * Returns the number of groups belonging to the parent group that match the
2548            * keywords, optionally including the user's inherited organization groups
2549            * and user groups. System and staged groups are not included.
2550            *
2551            * @param companyId the primary key of the company
2552            * @param parentGroupId the primary key of the parent group
2553            * @param keywords the keywords (space separated), which may occur in the
2554            sites's name, or description (optionally <code>null</code>)
2555            * @param params the finder params (optionally <code>null</code>). To
2556            include the user's inherited organization groups and user groups
2557            in the search, add entries having &quot;usersGroups&quot; and
2558            &quot;inherit&quot; as keys mapped to the the user's ID. For more
2559            information see {@link
2560            com.liferay.portal.service.persistence.GroupFinder}.
2561            * @return the number of matching groups
2562            */
2563            @Override
2564            public int searchCount(long companyId, long parentGroupId,
2565                    java.lang.String keywords,
2566                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params) {
2567                    return _groupLocalService.searchCount(companyId, parentGroupId,
2568                            keywords, params);
2569            }
2570    
2571            /**
2572            * Returns the number of groups belonging to the parent group and immediate
2573            * organization groups that match the name and description, optionally
2574            * including the user's inherited organization groups and user groups.
2575            * System and staged groups are not included.
2576            *
2577            * @param companyId the primary key of the company
2578            * @param parentGroupId the primary key of the parent group
2579            * @param name the group's name (optionally <code>null</code>)
2580            * @param description the group's description (optionally
2581            <code>null</code>)
2582            * @param params the finder params (optionally <code>null</code>). To
2583            include the user's inherited organization groups and user groups
2584            in the search, add entries having &quot;usersGroups&quot; and
2585            &quot;inherit&quot; as keys mapped to the the user's ID. For more
2586            information see {@link
2587            com.liferay.portal.service.persistence.GroupFinder}.
2588            * @param andOperator whether every field must match its keywords, or just
2589            one field.
2590            * @return the number of matching groups
2591            */
2592            @Override
2593            public int searchCount(long companyId, long parentGroupId,
2594                    java.lang.String name, java.lang.String description,
2595                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2596                    boolean andOperator) {
2597                    return _groupLocalService.searchCount(companyId, parentGroupId, name,
2598                            description, params, andOperator);
2599            }
2600    
2601            /**
2602            * Sets the Spring bean ID for this bean.
2603            *
2604            * @param beanIdentifier the Spring bean ID for this bean
2605            */
2606            @Override
2607            public void setBeanIdentifier(java.lang.String beanIdentifier) {
2608                    _groupLocalService.setBeanIdentifier(beanIdentifier);
2609            }
2610    
2611            @Override
2612            public void setOrganizationGroups(long organizationId, long[] groupIds) {
2613                    _groupLocalService.setOrganizationGroups(organizationId, groupIds);
2614            }
2615    
2616            @Override
2617            public void setRoleGroups(long roleId, long[] groupIds) {
2618                    _groupLocalService.setRoleGroups(roleId, groupIds);
2619            }
2620    
2621            @Override
2622            public void setUserGroupGroups(long userGroupId, long[] groupIds) {
2623                    _groupLocalService.setUserGroupGroups(userGroupId, groupIds);
2624            }
2625    
2626            @Override
2627            public void setUserGroups(long userId, long[] groupIds) {
2628                    _groupLocalService.setUserGroups(userId, groupIds);
2629            }
2630    
2631            /**
2632            * Removes the groups from the role.
2633            *
2634            * @param roleId the primary key of the role
2635            * @param groupIds the primary keys of the groups
2636            */
2637            @Override
2638            public void unsetRoleGroups(long roleId, long[] groupIds) {
2639                    _groupLocalService.unsetRoleGroups(roleId, groupIds);
2640            }
2641    
2642            /**
2643            * Removes the user from the groups.
2644            *
2645            * @param userId the primary key of the user
2646            * @param groupIds the primary keys of the groups
2647            */
2648            @Override
2649            public void unsetUserGroups(long userId, long[] groupIds) {
2650                    _groupLocalService.unsetUserGroups(userId, groupIds);
2651            }
2652    
2653            /**
2654            * Updates the group's asset replacing categories and tag names.
2655            *
2656            * @param userId the primary key of the user
2657            * @param group the group
2658            * @param assetCategoryIds the primary keys of the asset categories
2659            (optionally <code>null</code>)
2660            * @param assetTagNames the asset tag names (optionally <code>null</code>)
2661            * @throws PortalException if a user with the primary key could not be found
2662            */
2663            @Override
2664            public void updateAsset(long userId, com.liferay.portal.model.Group group,
2665                    long[] assetCategoryIds, java.lang.String[] assetTagNames)
2666                    throws com.liferay.portal.kernel.exception.PortalException {
2667                    _groupLocalService.updateAsset(userId, group, assetCategoryIds,
2668                            assetTagNames);
2669            }
2670    
2671            /**
2672            * Updates the group's friendly URL.
2673            *
2674            * @param groupId the primary key of the group
2675            * @param friendlyURL the group's new friendlyURL (optionally
2676            <code>null</code>)
2677            * @return the group
2678            * @throws PortalException if a group with the primary key could not be
2679            found or if a valid friendly URL could not be created for the
2680            group
2681            */
2682            @Override
2683            public com.liferay.portal.model.Group updateFriendlyURL(long groupId,
2684                    java.lang.String friendlyURL)
2685                    throws com.liferay.portal.kernel.exception.PortalException {
2686                    return _groupLocalService.updateFriendlyURL(groupId, friendlyURL);
2687            }
2688    
2689            /**
2690            * Updates the group in the database or adds it if it does not yet exist. Also notifies the appropriate model listeners.
2691            *
2692            * @param group the group
2693            * @return the group that was updated
2694            */
2695            @Override
2696            public com.liferay.portal.model.Group updateGroup(
2697                    com.liferay.portal.model.Group group) {
2698                    return _groupLocalService.updateGroup(group);
2699            }
2700    
2701            /**
2702            * Updates the group.
2703            *
2704            * @param groupId the primary key of the group
2705            * @param parentGroupId the primary key of the parent group
2706            * @param name the name's key
2707            * @param description the group's new description (optionally
2708            <code>null</code>)
2709            * @param type the group's new type. For more information see {@link
2710            GroupConstants}.
2711            * @param manualMembership whether manual membership is allowed for the
2712            group
2713            * @param membershipRestriction the group's membership restriction. For
2714            more information see {@link GroupConstants}.
2715            * @param friendlyURL the group's new friendlyURL (optionally
2716            <code>null</code>)
2717            * @param active whether the group is active
2718            * @param serviceContext the service context to be applied (optionally
2719            <code>null</code>). Can set asset category IDs and asset tag
2720            names for the group.
2721            * @return the group
2722            * @throws PortalException if a group with the primary key could not be
2723            found or if the friendly URL was invalid or could one not be
2724            created
2725            * @deprecated As of 7.0.0, replaced by {@link #updateGroup(long, long, Map,
2726            Map, int, boolean, int, String, boolean, boolean,
2727            ServiceContext)}
2728            */
2729            @Deprecated
2730            @Override
2731            public com.liferay.portal.model.Group updateGroup(long groupId,
2732                    long parentGroupId, java.lang.String name,
2733                    java.lang.String description, int type, boolean manualMembership,
2734                    int membershipRestriction, java.lang.String friendlyURL,
2735                    boolean inheritContent, boolean active,
2736                    com.liferay.portal.service.ServiceContext serviceContext)
2737                    throws com.liferay.portal.kernel.exception.PortalException {
2738                    return _groupLocalService.updateGroup(groupId, parentGroupId, name,
2739                            description, type, manualMembership, membershipRestriction,
2740                            friendlyURL, inheritContent, active, serviceContext);
2741            }
2742    
2743            @Override
2744            public com.liferay.portal.model.Group updateGroup(long groupId,
2745                    long parentGroupId,
2746                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
2747                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
2748                    int type, boolean manualMembership, int membershipRestriction,
2749                    java.lang.String friendlyURL, boolean inheritContent, boolean active,
2750                    com.liferay.portal.service.ServiceContext serviceContext)
2751                    throws com.liferay.portal.kernel.exception.PortalException {
2752                    return _groupLocalService.updateGroup(groupId, parentGroupId, nameMap,
2753                            descriptionMap, type, manualMembership, membershipRestriction,
2754                            friendlyURL, inheritContent, active, serviceContext);
2755            }
2756    
2757            /**
2758            * Updates the group's type settings.
2759            *
2760            * @param groupId the primary key of the group
2761            * @param typeSettings the group's new type settings (optionally
2762            <code>null</code>)
2763            * @return the group
2764            * @throws PortalException if a group with the primary key could not be
2765            found
2766            */
2767            @Override
2768            public com.liferay.portal.model.Group updateGroup(long groupId,
2769                    java.lang.String typeSettings)
2770                    throws com.liferay.portal.kernel.exception.PortalException {
2771                    return _groupLocalService.updateGroup(groupId, typeSettings);
2772            }
2773    
2774            /**
2775            * Associates the group with a main site if the group is an organization.
2776            *
2777            * @param groupId the primary key of the group
2778            * @param site whether the group is to be associated with a main site
2779            * @return the group
2780            * @throws PortalException if a group with the primary key could not be
2781            found
2782            */
2783            @Override
2784            public com.liferay.portal.model.Group updateSite(long groupId, boolean site)
2785                    throws com.liferay.portal.kernel.exception.PortalException {
2786                    return _groupLocalService.updateSite(groupId, site);
2787            }
2788    
2789            /**
2790             * @deprecated As of 6.1.0, replaced by {@link #getWrappedService}
2791             */
2792            @Deprecated
2793            public GroupLocalService getWrappedGroupLocalService() {
2794                    return _groupLocalService;
2795            }
2796    
2797            /**
2798             * @deprecated As of 6.1.0, replaced by {@link #setWrappedService}
2799             */
2800            @Deprecated
2801            public void setWrappedGroupLocalService(GroupLocalService groupLocalService) {
2802                    _groupLocalService = groupLocalService;
2803            }
2804    
2805            @Override
2806            public GroupLocalService getWrappedService() {
2807                    return _groupLocalService;
2808            }
2809    
2810            @Override
2811            public void setWrappedService(GroupLocalService groupLocalService) {
2812                    _groupLocalService = groupLocalService;
2813            }
2814    
2815            private GroupLocalService _groupLocalService;
2816    }