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.portal.kernel.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
741            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
742            * result set.
743            * </p>
744            *
745            * @param companyId the primary key of the user group's company
746            * @param keywords the keywords (space separated), which may occur in the
747            user group's name or description (optionally <code>null</code>)
748            * @param params the finder params (optionally <code>null</code>). For more
749            information see {@link
750            com.liferay.portal.service.persistence.UserGroupFinder}
751            * @param start the lower bound of the range of user groups to return
752            * @param end the upper bound of the range of user groups to return (not
753            inclusive)
754            * @param obc the comparator to order the user groups (optionally
755            <code>null</code>)
756            * @return the matching user groups ordered by comparator <code>obc</code>
757            * @see com.liferay.portal.service.persistence.UserGroupFinder
758            */
759            @Override
760            public java.util.List<com.liferay.portal.model.UserGroup> search(
761                    long companyId, java.lang.String keywords,
762                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
763                    int start, int end,
764                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.UserGroup> obc) {
765                    return _userGroupLocalService.search(companyId, keywords, params,
766                            start, end, obc);
767            }
768    
769            /**
770            * Returns an ordered range of all the user groups that match the keywords,
771            * using the indexer. It is preferable to use this method instead of the
772            * non-indexed version whenever possible for performance reasons.
773            *
774            * <p>
775            * Useful when paginating results. Returns a maximum of <code>end -
776            * start</code> instances. <code>start</code> and <code>end</code> are not
777            * primary keys, they are indexes in the result set. Thus, <code>0</code>
778            * refers to the first result in the set. Setting both <code>start</code>
779            * and <code>end</code> to {@link
780            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
781            * result set.
782            * </p>
783            *
784            * @param companyId the primary key of the user group's company
785            * @param keywords the keywords (space separated), which may occur in the
786            user group's name or description (optionally <code>null</code>)
787            * @param params the finder params (optionally <code>null</code>). For more
788            information see {@link
789            com.liferay.portlet.usergroupsadmin.util.UserGroupIndexer}
790            * @param start the lower bound of the range of user groups to return
791            * @param end the upper bound of the range of user groups to return (not
792            inclusive)
793            * @param sort the field and direction by which to sort (optionally
794            <code>null</code>)
795            * @return the matching user groups ordered by sort
796            * @see com.liferay.portlet.usergroupsadmin.util.UserGroupIndexer
797            */
798            @Override
799            public com.liferay.portal.kernel.search.Hits search(long companyId,
800                    java.lang.String keywords,
801                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
802                    int start, int end, com.liferay.portal.kernel.search.Sort sort) {
803                    return _userGroupLocalService.search(companyId, keywords, params,
804                            start, end, sort);
805            }
806    
807            /**
808            * Returns an ordered range of all the user groups that match the name and
809            * description.
810            *
811            * <p>
812            * Useful when paginating results. Returns a maximum of <code>end -
813            * start</code> instances. <code>start</code> and <code>end</code> are not
814            * primary keys, they are indexes in the result set. Thus, <code>0</code>
815            * refers to the first result in the set. Setting both <code>start</code>
816            * and <code>end</code> to {@link
817            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
818            * result set.
819            * </p>
820            *
821            * @param companyId the primary key of the user group's company
822            * @param name the user group's name (optionally <code>null</code>)
823            * @param description the user group's description (optionally
824            <code>null</code>)
825            * @param params the finder params (optionally <code>null</code>). For more
826            information see {@link
827            com.liferay.portal.service.persistence.UserGroupFinder}
828            * @param andOperator whether every field must match its keywords or just
829            one field
830            * @param start the lower bound of the range of user groups to return
831            * @param end the upper bound of the range of user groups to return (not
832            inclusive)
833            * @param obc the comparator to order the user groups (optionally
834            <code>null</code>)
835            * @return the matching user groups ordered by comparator <code>obc</code>
836            * @see com.liferay.portal.service.persistence.UserGroupFinder
837            */
838            @Override
839            public java.util.List<com.liferay.portal.model.UserGroup> search(
840                    long companyId, java.lang.String name, java.lang.String description,
841                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
842                    boolean andOperator, int start, int end,
843                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.UserGroup> obc) {
844                    return _userGroupLocalService.search(companyId, name, description,
845                            params, andOperator, start, end, obc);
846            }
847    
848            /**
849            * Returns an ordered range of all the user groups that match the name and
850            * description. It is preferable to use this method instead of the
851            * non-indexed version whenever possible for performance reasons.
852            *
853            * <p>
854            * Useful when paginating results. Returns a maximum of <code>end -
855            * start</code> instances. <code>start</code> and <code>end</code> are not
856            * primary keys, they are indexes in the result set. Thus, <code>0</code>
857            * refers to the first result in the set. Setting both <code>start</code>
858            * and <code>end</code> to {@link
859            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
860            * result set.
861            * </p>
862            *
863            * @param companyId the primary key of the user group's company
864            * @param name the user group's name (optionally <code>null</code>)
865            * @param description the user group's description (optionally
866            <code>null</code>)
867            * @param params the finder params (optionally <code>null</code>). For more
868            information see {@link
869            com.liferay.portlet.usergroupsadmin.util.UserGroupIndexer}
870            * @param andSearch whether every field must match its keywords or just one
871            field
872            * @param start the lower bound of the range of user groups to return
873            * @param end the upper bound of the range of user groups to return (not
874            inclusive)
875            * @param sort the field and direction by which to sort (optionally
876            <code>null</code>)
877            * @return the matching user groups ordered by sort
878            * @see com.liferay.portal.service.persistence.UserGroupFinder
879            */
880            @Override
881            public com.liferay.portal.kernel.search.Hits search(long companyId,
882                    java.lang.String name, java.lang.String description,
883                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
884                    boolean andSearch, int start, int end,
885                    com.liferay.portal.kernel.search.Sort sort) {
886                    return _userGroupLocalService.search(companyId, name, description,
887                            params, andSearch, start, end, sort);
888            }
889    
890            /**
891            * Returns the number of user groups that match the keywords
892            *
893            * @param companyId the primary key of the user group's company
894            * @param keywords the keywords (space separated), which may occur in the
895            user group's name or description (optionally <code>null</code>)
896            * @param params the finder params (optionally <code>null</code>). For more
897            information see {@link
898            com.liferay.portal.service.persistence.UserGroupFinder}
899            * @return the number of matching user groups
900            * @see com.liferay.portal.service.persistence.UserGroupFinder
901            */
902            @Override
903            public int searchCount(long companyId, java.lang.String keywords,
904                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params) {
905                    return _userGroupLocalService.searchCount(companyId, keywords, params);
906            }
907    
908            /**
909            * Returns the number of user groups that match the name and description.
910            *
911            * @param companyId the primary key of the user group's company
912            * @param name the user group's name (optionally <code>null</code>)
913            * @param description the user group's description (optionally
914            <code>null</code>)
915            * @param params the finder params (optionally <code>null</code>). For more
916            information see {@link
917            com.liferay.portal.service.persistence.UserGroupFinder}
918            * @param andOperator whether every field must match its keywords or just
919            one field
920            * @return the number of matching user groups
921            * @see com.liferay.portal.service.persistence.UserGroupFinder
922            */
923            @Override
924            public int searchCount(long companyId, java.lang.String name,
925                    java.lang.String description,
926                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
927                    boolean andOperator) {
928                    return _userGroupLocalService.searchCount(companyId, name, description,
929                            params, andOperator);
930            }
931    
932            @Override
933            public com.liferay.portal.kernel.search.BaseModelSearchResult<com.liferay.portal.model.UserGroup> searchUserGroups(
934                    long companyId, java.lang.String keywords,
935                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
936                    int start, int end, com.liferay.portal.kernel.search.Sort sort)
937                    throws com.liferay.portal.kernel.exception.PortalException {
938                    return _userGroupLocalService.searchUserGroups(companyId, keywords,
939                            params, start, end, sort);
940            }
941    
942            @Override
943            public com.liferay.portal.kernel.search.BaseModelSearchResult<com.liferay.portal.model.UserGroup> searchUserGroups(
944                    long companyId, java.lang.String name, java.lang.String description,
945                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
946                    boolean andSearch, int start, int end,
947                    com.liferay.portal.kernel.search.Sort sort)
948                    throws com.liferay.portal.kernel.exception.PortalException {
949                    return _userGroupLocalService.searchUserGroups(companyId, name,
950                            description, params, andSearch, start, end, sort);
951            }
952    
953            /**
954            * Sets the Spring bean ID for this bean.
955            *
956            * @param beanIdentifier the Spring bean ID for this bean
957            */
958            @Override
959            public void setBeanIdentifier(java.lang.String beanIdentifier) {
960                    _userGroupLocalService.setBeanIdentifier(beanIdentifier);
961            }
962    
963            @Override
964            public void setGroupUserGroups(long groupId, long[] userGroupIds) {
965                    _userGroupLocalService.setGroupUserGroups(groupId, userGroupIds);
966            }
967    
968            @Override
969            public void setTeamUserGroups(long teamId, long[] userGroupIds) {
970                    _userGroupLocalService.setTeamUserGroups(teamId, userGroupIds);
971            }
972    
973            /**
974            * @throws PortalException
975            */
976            @Override
977            public void setUserUserGroups(long userId, long[] userGroupIds)
978                    throws com.liferay.portal.kernel.exception.PortalException {
979                    _userGroupLocalService.setUserUserGroups(userId, userGroupIds);
980            }
981    
982            /**
983            * Removes the user groups from the group.
984            *
985            * @param groupId the primary key of the group
986            * @param userGroupIds the primary keys of the user groups
987            */
988            @Override
989            public void unsetGroupUserGroups(long groupId, long[] userGroupIds) {
990                    _userGroupLocalService.unsetGroupUserGroups(groupId, userGroupIds);
991            }
992    
993            /**
994            * Removes the user groups from the team.
995            *
996            * @param teamId the primary key of the team
997            * @param userGroupIds the primary keys of the user groups
998            */
999            @Override
1000            public void unsetTeamUserGroups(long teamId, long[] userGroupIds) {
1001                    _userGroupLocalService.unsetTeamUserGroups(teamId, userGroupIds);
1002            }
1003    
1004            /**
1005            * Updates the user group.
1006            *
1007            * @param companyId the primary key of the user group's company
1008            * @param userGroupId the primary key of the user group
1009            * @param name the user group's name
1010            * @param description the user group's description
1011            * @return the user group
1012            * @throws PortalException if a user group with the primary key could
1013            not be found or if the new information was invalid
1014            * @deprecated As of 6.2.0, replaced by {@link #updateUserGroup(long, long,
1015            String, String, ServiceContext)}
1016            */
1017            @Deprecated
1018            @Override
1019            public com.liferay.portal.model.UserGroup updateUserGroup(long companyId,
1020                    long userGroupId, java.lang.String name, java.lang.String description)
1021                    throws com.liferay.portal.kernel.exception.PortalException {
1022                    return _userGroupLocalService.updateUserGroup(companyId, userGroupId,
1023                            name, description);
1024            }
1025    
1026            /**
1027            * Updates the user group.
1028            *
1029            * @param companyId the primary key of the user group's company
1030            * @param userGroupId the primary key of the user group
1031            * @param name the user group's name
1032            * @param description the user group's description
1033            * @param serviceContext the service context to be applied (optionally
1034            <code>null</code>). Can set expando bridge attributes for the
1035            user group.
1036            * @return the user group
1037            * @throws PortalException if a user group with the primary key could not be
1038            found or if the new information was invalid
1039            */
1040            @Override
1041            public com.liferay.portal.model.UserGroup updateUserGroup(long companyId,
1042                    long userGroupId, java.lang.String name, java.lang.String description,
1043                    com.liferay.portal.service.ServiceContext serviceContext)
1044                    throws com.liferay.portal.kernel.exception.PortalException {
1045                    return _userGroupLocalService.updateUserGroup(companyId, userGroupId,
1046                            name, description, serviceContext);
1047            }
1048    
1049            /**
1050            * Updates the user group in the database or adds it if it does not yet exist. Also notifies the appropriate model listeners.
1051            *
1052            * @param userGroup the user group
1053            * @return the user group that was updated
1054            */
1055            @Override
1056            public com.liferay.portal.model.UserGroup updateUserGroup(
1057                    com.liferay.portal.model.UserGroup userGroup) {
1058                    return _userGroupLocalService.updateUserGroup(userGroup);
1059            }
1060    
1061            /**
1062             * @deprecated As of 6.1.0, replaced by {@link #getWrappedService}
1063             */
1064            @Deprecated
1065            public UserGroupLocalService getWrappedUserGroupLocalService() {
1066                    return _userGroupLocalService;
1067            }
1068    
1069            /**
1070             * @deprecated As of 6.1.0, replaced by {@link #setWrappedService}
1071             */
1072            @Deprecated
1073            public void setWrappedUserGroupLocalService(
1074                    UserGroupLocalService userGroupLocalService) {
1075                    _userGroupLocalService = userGroupLocalService;
1076            }
1077    
1078            @Override
1079            public UserGroupLocalService getWrappedService() {
1080                    return _userGroupLocalService;
1081            }
1082    
1083            @Override
1084            public void setWrappedService(UserGroupLocalService userGroupLocalService) {
1085                    _userGroupLocalService = userGroupLocalService;
1086            }
1087    
1088            private UserGroupLocalService _userGroupLocalService;
1089    }