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