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