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