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.kernel.service;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    /**
020     * Provides a wrapper for {@link UserGroupLocalService}.
021     *
022     * @author Brian Wing Shun Chan
023     * @see UserGroupLocalService
024     * @generated
025     */
026    @ProviderType
027    public class UserGroupLocalServiceWrapper implements UserGroupLocalService,
028            ServiceWrapper<UserGroupLocalService> {
029            public UserGroupLocalServiceWrapper(
030                    UserGroupLocalService userGroupLocalService) {
031                    _userGroupLocalService = userGroupLocalService;
032            }
033    
034            @Override
035            public void addGroupUserGroup(long groupId,
036                    com.liferay.portal.kernel.model.UserGroup userGroup) {
037                    _userGroupLocalService.addGroupUserGroup(groupId, userGroup);
038            }
039    
040            @Override
041            public void addGroupUserGroup(long groupId, long userGroupId) {
042                    _userGroupLocalService.addGroupUserGroup(groupId, userGroupId);
043            }
044    
045            @Override
046            public void addGroupUserGroups(long groupId,
047                    java.util.List<com.liferay.portal.kernel.model.UserGroup> UserGroups) {
048                    _userGroupLocalService.addGroupUserGroups(groupId, UserGroups);
049            }
050    
051            @Override
052            public void addGroupUserGroups(long groupId, long[] userGroupIds) {
053                    _userGroupLocalService.addGroupUserGroups(groupId, userGroupIds);
054            }
055    
056            @Override
057            public void addTeamUserGroup(long teamId,
058                    com.liferay.portal.kernel.model.UserGroup userGroup) {
059                    _userGroupLocalService.addTeamUserGroup(teamId, userGroup);
060            }
061    
062            @Override
063            public void addTeamUserGroup(long teamId, long userGroupId) {
064                    _userGroupLocalService.addTeamUserGroup(teamId, userGroupId);
065            }
066    
067            @Override
068            public void addTeamUserGroups(long teamId,
069                    java.util.List<com.liferay.portal.kernel.model.UserGroup> UserGroups) {
070                    _userGroupLocalService.addTeamUserGroups(teamId, UserGroups);
071            }
072    
073            @Override
074            public void addTeamUserGroups(long teamId, long[] userGroupIds) {
075                    _userGroupLocalService.addTeamUserGroups(teamId, userGroupIds);
076            }
077    
078            /**
079            * Adds the user group to the database. Also notifies the appropriate model listeners.
080            *
081            * @param userGroup the user group
082            * @return the user group that was added
083            */
084            @Override
085            public com.liferay.portal.kernel.model.UserGroup addUserGroup(
086                    com.liferay.portal.kernel.model.UserGroup userGroup) {
087                    return _userGroupLocalService.addUserGroup(userGroup);
088            }
089    
090            /**
091            * Adds a user group.
092            *
093            * <p>
094            * This method handles the creation and bookkeeping of the user group,
095            * including its resources, metadata, and internal data structures. It is
096            * not necessary to make subsequent calls to setup default groups and
097            * resources for the user group.
098            * </p>
099            *
100            * @param userId the primary key of the user
101            * @param companyId the primary key of the user group's company
102            * @param name the user group's name
103            * @param description the user group's description
104            * @return the user group
105            * @deprecated As of 6.2.0, replaced by {@link #addUserGroup(long, long,
106            String, String, ServiceContext)}
107            */
108            @Deprecated
109            @Override
110            public com.liferay.portal.kernel.model.UserGroup addUserGroup(long userId,
111                    long companyId, java.lang.String name, java.lang.String description)
112                    throws com.liferay.portal.kernel.exception.PortalException {
113                    return _userGroupLocalService.addUserGroup(userId, companyId, name,
114                            description);
115            }
116    
117            /**
118            * Adds a user group.
119            *
120            * <p>
121            * This method handles the creation and bookkeeping of the user group,
122            * including its resources, metadata, and internal data structures. It is
123            * not necessary to make subsequent calls to setup default groups and
124            * resources for the user group.
125            * </p>
126            *
127            * @param userId the primary key of the user
128            * @param companyId the primary key of the user group's company
129            * @param name the user group's name
130            * @param description the user group's description
131            * @param serviceContext the service context to be applied (optionally
132            <code>null</code>). Can set expando bridge attributes for the
133            user group.
134            * @return the user group
135            */
136            @Override
137            public com.liferay.portal.kernel.model.UserGroup addUserGroup(long userId,
138                    long companyId, java.lang.String name, java.lang.String description,
139                    com.liferay.portal.kernel.service.ServiceContext serviceContext)
140                    throws com.liferay.portal.kernel.exception.PortalException {
141                    return _userGroupLocalService.addUserGroup(userId, companyId, name,
142                            description, serviceContext);
143            }
144    
145            @Override
146            public void addUserUserGroup(long userId,
147                    com.liferay.portal.kernel.model.UserGroup userGroup) {
148                    _userGroupLocalService.addUserUserGroup(userId, userGroup);
149            }
150    
151            @Override
152            public void addUserUserGroup(long userId, long userGroupId) {
153                    _userGroupLocalService.addUserUserGroup(userId, userGroupId);
154            }
155    
156            @Override
157            public void addUserUserGroups(long userId,
158                    java.util.List<com.liferay.portal.kernel.model.UserGroup> UserGroups) {
159                    _userGroupLocalService.addUserUserGroups(userId, UserGroups);
160            }
161    
162            @Override
163            public void addUserUserGroups(long userId, long[] userGroupIds) {
164                    _userGroupLocalService.addUserUserGroups(userId, userGroupIds);
165            }
166    
167            @Override
168            public void clearGroupUserGroups(long groupId) {
169                    _userGroupLocalService.clearGroupUserGroups(groupId);
170            }
171    
172            @Override
173            public void clearTeamUserGroups(long teamId) {
174                    _userGroupLocalService.clearTeamUserGroups(teamId);
175            }
176    
177            @Override
178            public void clearUserUserGroups(long userId) {
179                    _userGroupLocalService.clearUserUserGroups(userId);
180            }
181    
182            /**
183            * Copies the user group's layout to the user.
184            *
185            * @param userGroupId the primary key of the user group
186            * @param userId the primary key of the user
187            * @deprecated As of 6.2.0
188            */
189            @Deprecated
190            @Override
191            public void copyUserGroupLayouts(long userGroupId, long userId)
192                    throws com.liferay.portal.kernel.exception.PortalException {
193                    _userGroupLocalService.copyUserGroupLayouts(userGroupId, userId);
194            }
195    
196            /**
197            * Copies the user group's layouts to the users who are not already members
198            * of the user group.
199            *
200            * @param userGroupId the primary key of the user group
201            * @param userIds the primary keys of the users
202            * @deprecated As of 6.1.0
203            */
204            @Deprecated
205            @Override
206            public void copyUserGroupLayouts(long userGroupId, long[] userIds)
207                    throws com.liferay.portal.kernel.exception.PortalException {
208                    _userGroupLocalService.copyUserGroupLayouts(userGroupId, userIds);
209            }
210    
211            /**
212            * Copies the user groups' layouts to the user.
213            *
214            * @param userGroupIds the primary keys of the user groups
215            * @param userId the primary key of the user
216            * @deprecated As of 6.1.0
217            */
218            @Deprecated
219            @Override
220            public void copyUserGroupLayouts(long[] userGroupIds, long userId)
221                    throws com.liferay.portal.kernel.exception.PortalException {
222                    _userGroupLocalService.copyUserGroupLayouts(userGroupIds, userId);
223            }
224    
225            /**
226            * Creates a new user group with the primary key. Does not add the user group to the database.
227            *
228            * @param userGroupId the primary key for the new user group
229            * @return the new user group
230            */
231            @Override
232            public com.liferay.portal.kernel.model.UserGroup createUserGroup(
233                    long userGroupId) {
234                    return _userGroupLocalService.createUserGroup(userGroupId);
235            }
236    
237            @Override
238            public void deleteGroupUserGroup(long groupId,
239                    com.liferay.portal.kernel.model.UserGroup userGroup) {
240                    _userGroupLocalService.deleteGroupUserGroup(groupId, userGroup);
241            }
242    
243            @Override
244            public void deleteGroupUserGroup(long groupId, long userGroupId) {
245                    _userGroupLocalService.deleteGroupUserGroup(groupId, userGroupId);
246            }
247    
248            @Override
249            public void deleteGroupUserGroups(long groupId,
250                    java.util.List<com.liferay.portal.kernel.model.UserGroup> UserGroups) {
251                    _userGroupLocalService.deleteGroupUserGroups(groupId, UserGroups);
252            }
253    
254            @Override
255            public void deleteGroupUserGroups(long groupId, long[] userGroupIds) {
256                    _userGroupLocalService.deleteGroupUserGroups(groupId, userGroupIds);
257            }
258    
259            /**
260            * @throws PortalException
261            */
262            @Override
263            public com.liferay.portal.kernel.model.PersistedModel deletePersistedModel(
264                    com.liferay.portal.kernel.model.PersistedModel persistedModel)
265                    throws com.liferay.portal.kernel.exception.PortalException {
266                    return _userGroupLocalService.deletePersistedModel(persistedModel);
267            }
268    
269            @Override
270            public void deleteTeamUserGroup(long teamId,
271                    com.liferay.portal.kernel.model.UserGroup userGroup) {
272                    _userGroupLocalService.deleteTeamUserGroup(teamId, userGroup);
273            }
274    
275            @Override
276            public void deleteTeamUserGroup(long teamId, long userGroupId) {
277                    _userGroupLocalService.deleteTeamUserGroup(teamId, userGroupId);
278            }
279    
280            @Override
281            public void deleteTeamUserGroups(long teamId,
282                    java.util.List<com.liferay.portal.kernel.model.UserGroup> UserGroups) {
283                    _userGroupLocalService.deleteTeamUserGroups(teamId, UserGroups);
284            }
285    
286            @Override
287            public void deleteTeamUserGroups(long teamId, long[] userGroupIds) {
288                    _userGroupLocalService.deleteTeamUserGroups(teamId, userGroupIds);
289            }
290    
291            /**
292            * Deletes the user group from the database. Also notifies the appropriate model listeners.
293            *
294            * @param userGroup the user group
295            * @return the user group that was removed
296            * @throws PortalException
297            */
298            @Override
299            public com.liferay.portal.kernel.model.UserGroup deleteUserGroup(
300                    com.liferay.portal.kernel.model.UserGroup userGroup)
301                    throws com.liferay.portal.kernel.exception.PortalException {
302                    return _userGroupLocalService.deleteUserGroup(userGroup);
303            }
304    
305            /**
306            * Deletes the user group with the primary key from the database. Also notifies the appropriate model listeners.
307            *
308            * @param userGroupId the primary key of the user group
309            * @return the user group that was removed
310            * @throws PortalException if a user group with the primary key could not be found
311            */
312            @Override
313            public com.liferay.portal.kernel.model.UserGroup deleteUserGroup(
314                    long userGroupId)
315                    throws com.liferay.portal.kernel.exception.PortalException {
316                    return _userGroupLocalService.deleteUserGroup(userGroupId);
317            }
318    
319            @Override
320            public void deleteUserGroups(long companyId)
321                    throws com.liferay.portal.kernel.exception.PortalException {
322                    _userGroupLocalService.deleteUserGroups(companyId);
323            }
324    
325            @Override
326            public void deleteUserUserGroup(long userId,
327                    com.liferay.portal.kernel.model.UserGroup userGroup) {
328                    _userGroupLocalService.deleteUserUserGroup(userId, userGroup);
329            }
330    
331            @Override
332            public void deleteUserUserGroup(long userId, long userGroupId) {
333                    _userGroupLocalService.deleteUserUserGroup(userId, userGroupId);
334            }
335    
336            @Override
337            public void deleteUserUserGroups(long userId,
338                    java.util.List<com.liferay.portal.kernel.model.UserGroup> UserGroups) {
339                    _userGroupLocalService.deleteUserUserGroups(userId, UserGroups);
340            }
341    
342            @Override
343            public void deleteUserUserGroups(long userId, long[] userGroupIds) {
344                    _userGroupLocalService.deleteUserUserGroups(userId, userGroupIds);
345            }
346    
347            @Override
348            public com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery() {
349                    return _userGroupLocalService.dynamicQuery();
350            }
351    
352            /**
353            * Performs a dynamic query on the database and returns the matching rows.
354            *
355            * @param dynamicQuery the dynamic query
356            * @return the matching rows
357            */
358            @Override
359            public <T> java.util.List<T> dynamicQuery(
360                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) {
361                    return _userGroupLocalService.dynamicQuery(dynamicQuery);
362            }
363    
364            /**
365            * Performs a dynamic query on the database and returns a range of the matching rows.
366            *
367            * <p>
368            * 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.UserGroupModelImpl}. 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.
369            * </p>
370            *
371            * @param dynamicQuery the dynamic query
372            * @param start the lower bound of the range of model instances
373            * @param end the upper bound of the range of model instances (not inclusive)
374            * @return the range of matching rows
375            */
376            @Override
377            public <T> java.util.List<T> dynamicQuery(
378                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start,
379                    int end) {
380                    return _userGroupLocalService.dynamicQuery(dynamicQuery, start, end);
381            }
382    
383            /**
384            * Performs a dynamic query on the database and returns an ordered range of the matching rows.
385            *
386            * <p>
387            * 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.UserGroupModelImpl}. 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.
388            * </p>
389            *
390            * @param dynamicQuery the dynamic query
391            * @param start the lower bound of the range of model instances
392            * @param end the upper bound of the range of model instances (not inclusive)
393            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
394            * @return the ordered range of matching rows
395            */
396            @Override
397            public <T> java.util.List<T> dynamicQuery(
398                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start,
399                    int end,
400                    com.liferay.portal.kernel.util.OrderByComparator<T> orderByComparator) {
401                    return _userGroupLocalService.dynamicQuery(dynamicQuery, start, end,
402                            orderByComparator);
403            }
404    
405            /**
406            * Returns the number of rows matching the dynamic query.
407            *
408            * @param dynamicQuery the dynamic query
409            * @return the number of rows matching the dynamic query
410            */
411            @Override
412            public long dynamicQueryCount(
413                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) {
414                    return _userGroupLocalService.dynamicQueryCount(dynamicQuery);
415            }
416    
417            /**
418            * Returns the number of rows matching the dynamic query.
419            *
420            * @param dynamicQuery the dynamic query
421            * @param projection the projection to apply to the query
422            * @return the number of rows matching the dynamic query
423            */
424            @Override
425            public long dynamicQueryCount(
426                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery,
427                    com.liferay.portal.kernel.dao.orm.Projection projection) {
428                    return _userGroupLocalService.dynamicQueryCount(dynamicQuery, projection);
429            }
430    
431            @Override
432            public com.liferay.portal.kernel.model.UserGroup fetchUserGroup(
433                    long companyId, java.lang.String name) {
434                    return _userGroupLocalService.fetchUserGroup(companyId, name);
435            }
436    
437            @Override
438            public com.liferay.portal.kernel.model.UserGroup fetchUserGroup(
439                    long userGroupId) {
440                    return _userGroupLocalService.fetchUserGroup(userGroupId);
441            }
442    
443            /**
444            * Returns the user group with the matching UUID and company.
445            *
446            * @param uuid the user group's UUID
447            * @param companyId the primary key of the company
448            * @return the matching user group, or <code>null</code> if a matching user group could not be found
449            */
450            @Override
451            public com.liferay.portal.kernel.model.UserGroup fetchUserGroupByUuidAndCompanyId(
452                    java.lang.String uuid, long companyId) {
453                    return _userGroupLocalService.fetchUserGroupByUuidAndCompanyId(uuid,
454                            companyId);
455            }
456    
457            @Override
458            public com.liferay.portal.kernel.dao.orm.ActionableDynamicQuery getActionableDynamicQuery() {
459                    return _userGroupLocalService.getActionableDynamicQuery();
460            }
461    
462            @Override
463            public com.liferay.portal.kernel.dao.orm.ExportActionableDynamicQuery getExportActionableDynamicQuery(
464                    com.liferay.exportimport.kernel.lar.PortletDataContext portletDataContext) {
465                    return _userGroupLocalService.getExportActionableDynamicQuery(portletDataContext);
466            }
467    
468            /**
469            * Returns the groupIds of the groups associated with the user group.
470            *
471            * @param userGroupId the userGroupId of the user group
472            * @return long[] the groupIds of groups associated with the user group
473            */
474            @Override
475            public long[] getGroupPrimaryKeys(long userGroupId) {
476                    return _userGroupLocalService.getGroupPrimaryKeys(userGroupId);
477            }
478    
479            @Override
480            public java.util.List<com.liferay.portal.kernel.model.UserGroup> getGroupUserGroups(
481                    long groupId) {
482                    return _userGroupLocalService.getGroupUserGroups(groupId);
483            }
484    
485            @Override
486            public java.util.List<com.liferay.portal.kernel.model.UserGroup> getGroupUserGroups(
487                    long groupId, int start, int end) {
488                    return _userGroupLocalService.getGroupUserGroups(groupId, start, end);
489            }
490    
491            @Override
492            public java.util.List<com.liferay.portal.kernel.model.UserGroup> getGroupUserGroups(
493                    long groupId, int start, int end,
494                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.model.UserGroup> orderByComparator) {
495                    return _userGroupLocalService.getGroupUserGroups(groupId, start, end,
496                            orderByComparator);
497            }
498    
499            @Override
500            public int getGroupUserGroupsCount(long groupId) {
501                    return _userGroupLocalService.getGroupUserGroupsCount(groupId);
502            }
503    
504            @Override
505            public java.util.List<com.liferay.portal.kernel.model.UserGroup> getGroupUserUserGroups(
506                    long groupId, long userId)
507                    throws com.liferay.portal.kernel.exception.PortalException {
508                    return _userGroupLocalService.getGroupUserUserGroups(groupId, userId);
509            }
510    
511            @Override
512            public com.liferay.portal.kernel.dao.orm.IndexableActionableDynamicQuery getIndexableActionableDynamicQuery() {
513                    return _userGroupLocalService.getIndexableActionableDynamicQuery();
514            }
515    
516            /**
517            * Returns the OSGi service identifier.
518            *
519            * @return the OSGi service identifier
520            */
521            @Override
522            public java.lang.String getOSGiServiceIdentifier() {
523                    return _userGroupLocalService.getOSGiServiceIdentifier();
524            }
525    
526            @Override
527            public com.liferay.portal.kernel.model.PersistedModel getPersistedModel(
528                    java.io.Serializable primaryKeyObj)
529                    throws com.liferay.portal.kernel.exception.PortalException {
530                    return _userGroupLocalService.getPersistedModel(primaryKeyObj);
531            }
532    
533            /**
534            * Returns the teamIds of the teams associated with the user group.
535            *
536            * @param userGroupId the userGroupId of the user group
537            * @return long[] the teamIds of teams associated with the user group
538            */
539            @Override
540            public long[] getTeamPrimaryKeys(long userGroupId) {
541                    return _userGroupLocalService.getTeamPrimaryKeys(userGroupId);
542            }
543    
544            @Override
545            public java.util.List<com.liferay.portal.kernel.model.UserGroup> getTeamUserGroups(
546                    long teamId) {
547                    return _userGroupLocalService.getTeamUserGroups(teamId);
548            }
549    
550            @Override
551            public java.util.List<com.liferay.portal.kernel.model.UserGroup> getTeamUserGroups(
552                    long teamId, int start, int end) {
553                    return _userGroupLocalService.getTeamUserGroups(teamId, start, end);
554            }
555    
556            @Override
557            public java.util.List<com.liferay.portal.kernel.model.UserGroup> getTeamUserGroups(
558                    long teamId, int start, int end,
559                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.model.UserGroup> orderByComparator) {
560                    return _userGroupLocalService.getTeamUserGroups(teamId, start, end,
561                            orderByComparator);
562            }
563    
564            @Override
565            public int getTeamUserGroupsCount(long teamId) {
566                    return _userGroupLocalService.getTeamUserGroupsCount(teamId);
567            }
568    
569            /**
570            * Returns the user group with the name.
571            *
572            * @param companyId the primary key of the user group's company
573            * @param name the user group's name
574            * @return Returns the user group with the name
575            */
576            @Override
577            public com.liferay.portal.kernel.model.UserGroup getUserGroup(
578                    long companyId, java.lang.String name)
579                    throws com.liferay.portal.kernel.exception.PortalException {
580                    return _userGroupLocalService.getUserGroup(companyId, name);
581            }
582    
583            /**
584            * Returns the user group with the primary key.
585            *
586            * @param userGroupId the primary key of the user group
587            * @return the user group
588            * @throws PortalException if a user group with the primary key could not be found
589            */
590            @Override
591            public com.liferay.portal.kernel.model.UserGroup getUserGroup(
592                    long userGroupId)
593                    throws com.liferay.portal.kernel.exception.PortalException {
594                    return _userGroupLocalService.getUserGroup(userGroupId);
595            }
596    
597            /**
598            * Returns the user group with the matching UUID and company.
599            *
600            * @param uuid the user group's UUID
601            * @param companyId the primary key of the company
602            * @return the matching user group
603            * @throws PortalException if a matching user group could not be found
604            */
605            @Override
606            public com.liferay.portal.kernel.model.UserGroup getUserGroupByUuidAndCompanyId(
607                    java.lang.String uuid, long companyId)
608                    throws com.liferay.portal.kernel.exception.PortalException {
609                    return _userGroupLocalService.getUserGroupByUuidAndCompanyId(uuid,
610                            companyId);
611            }
612    
613            /**
614            * Returns all the user groups belonging to the company.
615            *
616            * @param companyId the primary key of the user groups' company
617            * @return the user groups belonging to the company
618            */
619            @Override
620            public java.util.List<com.liferay.portal.kernel.model.UserGroup> getUserGroups(
621                    long companyId) {
622                    return _userGroupLocalService.getUserGroups(companyId);
623            }
624    
625            /**
626            * Returns a range of all the user groups.
627            *
628            * <p>
629            * 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.UserGroupModelImpl}. 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.
630            * </p>
631            *
632            * @param start the lower bound of the range of user groups
633            * @param end the upper bound of the range of user groups (not inclusive)
634            * @return the range of user groups
635            */
636            @Override
637            public java.util.List<com.liferay.portal.kernel.model.UserGroup> getUserGroups(
638                    int start, int end) {
639                    return _userGroupLocalService.getUserGroups(start, end);
640            }
641    
642            /**
643            * Returns all the user groups with the primary keys.
644            *
645            * @param userGroupIds the primary keys of the user groups
646            * @return the user groups with the primary keys
647            */
648            @Override
649            public java.util.List<com.liferay.portal.kernel.model.UserGroup> getUserGroups(
650                    long[] userGroupIds)
651                    throws com.liferay.portal.kernel.exception.PortalException {
652                    return _userGroupLocalService.getUserGroups(userGroupIds);
653            }
654    
655            /**
656            * Returns the number of user groups.
657            *
658            * @return the number of user groups
659            */
660            @Override
661            public int getUserGroupsCount() {
662                    return _userGroupLocalService.getUserGroupsCount();
663            }
664    
665            /**
666            * Returns the userIds of the users associated with the user group.
667            *
668            * @param userGroupId the userGroupId of the user group
669            * @return long[] the userIds of users associated with the user group
670            */
671            @Override
672            public long[] getUserPrimaryKeys(long userGroupId) {
673                    return _userGroupLocalService.getUserPrimaryKeys(userGroupId);
674            }
675    
676            @Override
677            public java.util.List<com.liferay.portal.kernel.model.UserGroup> getUserUserGroups(
678                    long userId) {
679                    return _userGroupLocalService.getUserUserGroups(userId);
680            }
681    
682            @Override
683            public java.util.List<com.liferay.portal.kernel.model.UserGroup> getUserUserGroups(
684                    long userId, int start, int end) {
685                    return _userGroupLocalService.getUserUserGroups(userId, start, end);
686            }
687    
688            @Override
689            public java.util.List<com.liferay.portal.kernel.model.UserGroup> getUserUserGroups(
690                    long userId, int start, int end,
691                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.model.UserGroup> orderByComparator) {
692                    return _userGroupLocalService.getUserUserGroups(userId, start, end,
693                            orderByComparator);
694            }
695    
696            @Override
697            public int getUserUserGroupsCount(long userId) {
698                    return _userGroupLocalService.getUserUserGroupsCount(userId);
699            }
700    
701            @Override
702            public boolean hasGroupUserGroup(long groupId, long userGroupId) {
703                    return _userGroupLocalService.hasGroupUserGroup(groupId, userGroupId);
704            }
705    
706            @Override
707            public boolean hasGroupUserGroups(long groupId) {
708                    return _userGroupLocalService.hasGroupUserGroups(groupId);
709            }
710    
711            @Override
712            public boolean hasTeamUserGroup(long teamId, long userGroupId) {
713                    return _userGroupLocalService.hasTeamUserGroup(teamId, userGroupId);
714            }
715    
716            @Override
717            public boolean hasTeamUserGroups(long teamId) {
718                    return _userGroupLocalService.hasTeamUserGroups(teamId);
719            }
720    
721            @Override
722            public boolean hasUserUserGroup(long userId, long userGroupId) {
723                    return _userGroupLocalService.hasUserUserGroup(userId, userGroupId);
724            }
725    
726            @Override
727            public boolean hasUserUserGroups(long userId) {
728                    return _userGroupLocalService.hasUserUserGroups(userId);
729            }
730    
731            /**
732            * Returns an ordered range of all the user groups that match the keywords.
733            *
734            * <p>
735            * Useful when paginating results. Returns a maximum of <code>end -
736            * start</code> instances. <code>start</code> and <code>end</code> are not
737            * primary keys, they are indexes in the result set. Thus, <code>0</code>
738            * refers to the first result in the set. Setting both <code>start</code>
739            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
740            * result set.
741            * </p>
742            *
743            * @param companyId the primary key of the user group's company
744            * @param keywords the keywords (space separated), which may occur in the
745            user group's name or description (optionally <code>null</code>)
746            * @param params the finder params (optionally <code>null</code>). For more
747            information see {@link
748            com.liferay.portal.kernel.service.persistence.UserGroupFinder}
749            * @param start the lower bound of the range of user groups to return
750            * @param end the upper bound of the range of user groups to return (not
751            inclusive)
752            * @param obc the comparator to order the user groups (optionally
753            <code>null</code>)
754            * @return the matching user groups ordered by comparator <code>obc</code>
755            * @see com.liferay.portal.kernel.service.persistence.UserGroupFinder
756            */
757            @Override
758            public java.util.List<com.liferay.portal.kernel.model.UserGroup> search(
759                    long companyId, java.lang.String keywords,
760                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
761                    int start, int end,
762                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.model.UserGroup> obc) {
763                    return _userGroupLocalService.search(companyId, keywords, params,
764                            start, end, obc);
765            }
766    
767            /**
768            * Returns an ordered range of all the user groups that match the keywords,
769            * using the indexer. It is preferable to use this method instead of the
770            * non-indexed version whenever possible for performance reasons.
771            *
772            * <p>
773            * Useful when paginating results. Returns a maximum of <code>end -
774            * start</code> instances. <code>start</code> and <code>end</code> are not
775            * primary keys, they are indexes in the result set. Thus, <code>0</code>
776            * refers to the first result in the set. Setting both <code>start</code>
777            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
778            * result set.
779            * </p>
780            *
781            * @param companyId the primary key of the user group's company
782            * @param keywords the keywords (space separated), which may occur in the
783            user group's name or description (optionally <code>null</code>)
784            * @param params the finder params (optionally <code>null</code>). For more
785            information see {@link
786            com.liferay.user.groups.admin.web.search.UserGroupIndexer}
787            * @param start the lower bound of the range of user groups to return
788            * @param end the upper bound of the range of user groups to return (not
789            inclusive)
790            * @param sort the field and direction by which to sort (optionally
791            <code>null</code>)
792            * @return the matching user groups ordered by sort
793            * @see com.liferay.user.groups.admin.web.search.UserGroupIndexer
794            */
795            @Override
796            public com.liferay.portal.kernel.search.Hits search(long companyId,
797                    java.lang.String keywords,
798                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
799                    int start, int end, com.liferay.portal.kernel.search.Sort sort) {
800                    return _userGroupLocalService.search(companyId, keywords, params,
801                            start, end, sort);
802            }
803    
804            /**
805            * Returns an ordered range of all the user groups that match the name and
806            * description.
807            *
808            * <p>
809            * Useful when paginating results. Returns a maximum of <code>end -
810            * start</code> instances. <code>start</code> and <code>end</code> are not
811            * primary keys, they are indexes in the result set. Thus, <code>0</code>
812            * refers to the first result in the set. Setting both <code>start</code>
813            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
814            * result set.
815            * </p>
816            *
817            * @param companyId the primary key of the user group's company
818            * @param name the user group's name (optionally <code>null</code>)
819            * @param description the user group's description (optionally
820            <code>null</code>)
821            * @param params the finder params (optionally <code>null</code>). For more
822            information see {@link
823            com.liferay.portal.kernel.service.persistence.UserGroupFinder}
824            * @param andOperator whether every field must match its keywords or just
825            one field
826            * @param start the lower bound of the range of user groups to return
827            * @param end the upper bound of the range of user groups to return (not
828            inclusive)
829            * @param obc the comparator to order the user groups (optionally
830            <code>null</code>)
831            * @return the matching user groups ordered by comparator <code>obc</code>
832            * @see com.liferay.portal.kernel.service.persistence.UserGroupFinder
833            */
834            @Override
835            public java.util.List<com.liferay.portal.kernel.model.UserGroup> search(
836                    long companyId, java.lang.String name, java.lang.String description,
837                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
838                    boolean andOperator, int start, int end,
839                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.model.UserGroup> obc) {
840                    return _userGroupLocalService.search(companyId, name, description,
841                            params, andOperator, start, end, obc);
842            }
843    
844            /**
845            * Returns an ordered range of all the user groups that match the name and
846            * description. It is preferable to use this method instead of the
847            * non-indexed version whenever possible for performance reasons.
848            *
849            * <p>
850            * Useful when paginating results. Returns a maximum of <code>end -
851            * start</code> instances. <code>start</code> and <code>end</code> are not
852            * primary keys, they are indexes in the result set. Thus, <code>0</code>
853            * refers to the first result in the set. Setting both <code>start</code>
854            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
855            * result set.
856            * </p>
857            *
858            * @param companyId the primary key of the user group's company
859            * @param name the user group's name (optionally <code>null</code>)
860            * @param description the user group's description (optionally
861            <code>null</code>)
862            * @param params the finder params (optionally <code>null</code>). For more
863            information see {@link
864            com.liferay.user.groups.admin.web.search.UserGroupIndexer}
865            * @param andSearch whether every field must match its keywords or just one
866            field
867            * @param start the lower bound of the range of user groups to return
868            * @param end the upper bound of the range of user groups to return (not
869            inclusive)
870            * @param sort the field and direction by which to sort (optionally
871            <code>null</code>)
872            * @return the matching user groups ordered by sort
873            * @see com.liferay.portal.kernel.service.persistence.UserGroupFinder
874            */
875            @Override
876            public com.liferay.portal.kernel.search.Hits search(long companyId,
877                    java.lang.String name, java.lang.String description,
878                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
879                    boolean andSearch, int start, int end,
880                    com.liferay.portal.kernel.search.Sort sort) {
881                    return _userGroupLocalService.search(companyId, name, description,
882                            params, andSearch, start, end, sort);
883            }
884    
885            /**
886            * Returns the number of user groups that match the keywords
887            *
888            * @param companyId the primary key of the user group's company
889            * @param keywords the keywords (space separated), which may occur in the
890            user group's name or description (optionally <code>null</code>)
891            * @param params the finder params (optionally <code>null</code>). For more
892            information see {@link
893            com.liferay.portal.kernel.service.persistence.UserGroupFinder}
894            * @return the number of matching user groups
895            * @see com.liferay.portal.kernel.service.persistence.UserGroupFinder
896            */
897            @Override
898            public int searchCount(long companyId, java.lang.String keywords,
899                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params) {
900                    return _userGroupLocalService.searchCount(companyId, keywords, params);
901            }
902    
903            /**
904            * Returns the number of user groups that match the name and description.
905            *
906            * @param companyId the primary key of the user group's company
907            * @param name the user group's name (optionally <code>null</code>)
908            * @param description the user group's description (optionally
909            <code>null</code>)
910            * @param params the finder params (optionally <code>null</code>). For more
911            information see {@link
912            com.liferay.portal.kernel.service.persistence.UserGroupFinder}
913            * @param andOperator whether every field must match its keywords or just
914            one field
915            * @return the number of matching user groups
916            * @see com.liferay.portal.kernel.service.persistence.UserGroupFinder
917            */
918            @Override
919            public int searchCount(long companyId, java.lang.String name,
920                    java.lang.String description,
921                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
922                    boolean andOperator) {
923                    return _userGroupLocalService.searchCount(companyId, name, description,
924                            params, andOperator);
925            }
926    
927            @Override
928            public com.liferay.portal.kernel.search.BaseModelSearchResult<com.liferay.portal.kernel.model.UserGroup> searchUserGroups(
929                    long companyId, java.lang.String keywords,
930                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
931                    int start, int end, com.liferay.portal.kernel.search.Sort sort)
932                    throws com.liferay.portal.kernel.exception.PortalException {
933                    return _userGroupLocalService.searchUserGroups(companyId, keywords,
934                            params, start, end, sort);
935            }
936    
937            @Override
938            public com.liferay.portal.kernel.search.BaseModelSearchResult<com.liferay.portal.kernel.model.UserGroup> searchUserGroups(
939                    long companyId, java.lang.String name, java.lang.String description,
940                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
941                    boolean andSearch, int start, int end,
942                    com.liferay.portal.kernel.search.Sort sort)
943                    throws com.liferay.portal.kernel.exception.PortalException {
944                    return _userGroupLocalService.searchUserGroups(companyId, name,
945                            description, params, andSearch, start, end, sort);
946            }
947    
948            @Override
949            public void setGroupUserGroups(long groupId, long[] userGroupIds) {
950                    _userGroupLocalService.setGroupUserGroups(groupId, userGroupIds);
951            }
952    
953            @Override
954            public void setTeamUserGroups(long teamId, long[] userGroupIds) {
955                    _userGroupLocalService.setTeamUserGroups(teamId, userGroupIds);
956            }
957    
958            /**
959            * @throws PortalException
960            */
961            @Override
962            public void setUserUserGroups(long userId, long[] userGroupIds)
963                    throws com.liferay.portal.kernel.exception.PortalException {
964                    _userGroupLocalService.setUserUserGroups(userId, userGroupIds);
965            }
966    
967            /**
968            * Removes the user groups from the group.
969            *
970            * @param groupId the primary key of the group
971            * @param userGroupIds the primary keys of the user groups
972            */
973            @Override
974            public void unsetGroupUserGroups(long groupId, long[] userGroupIds) {
975                    _userGroupLocalService.unsetGroupUserGroups(groupId, userGroupIds);
976            }
977    
978            /**
979            * Removes the user groups from the team.
980            *
981            * @param teamId the primary key of the team
982            * @param userGroupIds the primary keys of the user groups
983            */
984            @Override
985            public void unsetTeamUserGroups(long teamId, long[] userGroupIds) {
986                    _userGroupLocalService.unsetTeamUserGroups(teamId, userGroupIds);
987            }
988    
989            /**
990            * Updates the user group.
991            *
992            * @param companyId the primary key of the user group's company
993            * @param userGroupId the primary key of the user group
994            * @param name the user group's name
995            * @param description the user group's description
996            * @return the user group
997            * @deprecated As of 6.2.0, replaced by {@link #updateUserGroup(long, long,
998            String, String, ServiceContext)}
999            */
1000            @Deprecated
1001            @Override
1002            public com.liferay.portal.kernel.model.UserGroup updateUserGroup(
1003                    long companyId, long userGroupId, java.lang.String name,
1004                    java.lang.String description)
1005                    throws com.liferay.portal.kernel.exception.PortalException {
1006                    return _userGroupLocalService.updateUserGroup(companyId, userGroupId,
1007                            name, description);
1008            }
1009    
1010            /**
1011            * Updates the user group.
1012            *
1013            * @param companyId the primary key of the user group's company
1014            * @param userGroupId the primary key of the user group
1015            * @param name the user group's name
1016            * @param description the user group's description
1017            * @param serviceContext the service context to be applied (optionally
1018            <code>null</code>). Can set expando bridge attributes for the
1019            user group.
1020            * @return the user group
1021            */
1022            @Override
1023            public com.liferay.portal.kernel.model.UserGroup updateUserGroup(
1024                    long companyId, long userGroupId, java.lang.String name,
1025                    java.lang.String description,
1026                    com.liferay.portal.kernel.service.ServiceContext serviceContext)
1027                    throws com.liferay.portal.kernel.exception.PortalException {
1028                    return _userGroupLocalService.updateUserGroup(companyId, userGroupId,
1029                            name, description, serviceContext);
1030            }
1031    
1032            /**
1033            * Updates the user group in the database or adds it if it does not yet exist. Also notifies the appropriate model listeners.
1034            *
1035            * @param userGroup the user group
1036            * @return the user group that was updated
1037            */
1038            @Override
1039            public com.liferay.portal.kernel.model.UserGroup updateUserGroup(
1040                    com.liferay.portal.kernel.model.UserGroup userGroup) {
1041                    return _userGroupLocalService.updateUserGroup(userGroup);
1042            }
1043    
1044            @Override
1045            public UserGroupLocalService getWrappedService() {
1046                    return _userGroupLocalService;
1047            }
1048    
1049            @Override
1050            public void setWrappedService(UserGroupLocalService userGroupLocalService) {
1051                    _userGroupLocalService = userGroupLocalService;
1052            }
1053    
1054            private UserGroupLocalService _userGroupLocalService;
1055    }