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