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