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