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            @Override
509            public com.liferay.portal.kernel.dao.orm.IndexableActionableDynamicQuery getIndexableActionableDynamicQuery() {
510                    return _userGroupLocalService.getIndexableActionableDynamicQuery();
511            }
512    
513            /**
514            * Returns the OSGi service identifier.
515            *
516            * @return the OSGi service identifier
517            */
518            @Override
519            public java.lang.String getOSGiServiceIdentifier() {
520                    return _userGroupLocalService.getOSGiServiceIdentifier();
521            }
522    
523            @Override
524            public com.liferay.portal.model.PersistedModel getPersistedModel(
525                    java.io.Serializable primaryKeyObj)
526                    throws com.liferay.portal.kernel.exception.PortalException {
527                    return _userGroupLocalService.getPersistedModel(primaryKeyObj);
528            }
529    
530            /**
531            * Returns the teamIds of the teams associated with the user group.
532            *
533            * @param userGroupId the userGroupId of the user group
534            * @return long[] the teamIds of teams associated with the user group
535            */
536            @Override
537            public long[] getTeamPrimaryKeys(long userGroupId) {
538                    return _userGroupLocalService.getTeamPrimaryKeys(userGroupId);
539            }
540    
541            @Override
542            public java.util.List<com.liferay.portal.model.UserGroup> getTeamUserGroups(
543                    long teamId) {
544                    return _userGroupLocalService.getTeamUserGroups(teamId);
545            }
546    
547            @Override
548            public java.util.List<com.liferay.portal.model.UserGroup> getTeamUserGroups(
549                    long teamId, int start, int end) {
550                    return _userGroupLocalService.getTeamUserGroups(teamId, start, end);
551            }
552    
553            @Override
554            public java.util.List<com.liferay.portal.model.UserGroup> getTeamUserGroups(
555                    long teamId, int start, int end,
556                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.UserGroup> orderByComparator) {
557                    return _userGroupLocalService.getTeamUserGroups(teamId, start, end,
558                            orderByComparator);
559            }
560    
561            @Override
562            public int getTeamUserGroupsCount(long teamId) {
563                    return _userGroupLocalService.getTeamUserGroupsCount(teamId);
564            }
565    
566            /**
567            * Returns the user group with the name.
568            *
569            * @param companyId the primary key of the user group's company
570            * @param name the user group's name
571            * @return Returns the user group with the name
572            */
573            @Override
574            public com.liferay.portal.model.UserGroup getUserGroup(long companyId,
575                    java.lang.String name)
576                    throws com.liferay.portal.kernel.exception.PortalException {
577                    return _userGroupLocalService.getUserGroup(companyId, name);
578            }
579    
580            /**
581            * Returns the user group with the primary key.
582            *
583            * @param userGroupId the primary key of the user group
584            * @return the user group
585            * @throws PortalException if a user group with the primary key could not be found
586            */
587            @Override
588            public com.liferay.portal.model.UserGroup getUserGroup(long userGroupId)
589                    throws com.liferay.portal.kernel.exception.PortalException {
590                    return _userGroupLocalService.getUserGroup(userGroupId);
591            }
592    
593            /**
594            * Returns the user group with the matching UUID and company.
595            *
596            * @param uuid the user group's UUID
597            * @param companyId the primary key of the company
598            * @return the matching user group
599            * @throws PortalException if a matching user group could not be found
600            */
601            @Override
602            public com.liferay.portal.model.UserGroup getUserGroupByUuidAndCompanyId(
603                    java.lang.String uuid, long companyId)
604                    throws com.liferay.portal.kernel.exception.PortalException {
605                    return _userGroupLocalService.getUserGroupByUuidAndCompanyId(uuid,
606                            companyId);
607            }
608    
609            /**
610            * Returns all the user groups belonging to the company.
611            *
612            * @param companyId the primary key of the user groups' company
613            * @return the user groups belonging to the company
614            */
615            @Override
616            public java.util.List<com.liferay.portal.model.UserGroup> getUserGroups(
617                    long companyId) {
618                    return _userGroupLocalService.getUserGroups(companyId);
619            }
620    
621            /**
622            * Returns a range of all the user groups.
623            *
624            * <p>
625            * 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.
626            * </p>
627            *
628            * @param start the lower bound of the range of user groups
629            * @param end the upper bound of the range of user groups (not inclusive)
630            * @return the range of user groups
631            */
632            @Override
633            public java.util.List<com.liferay.portal.model.UserGroup> getUserGroups(
634                    int start, int end) {
635                    return _userGroupLocalService.getUserGroups(start, end);
636            }
637    
638            /**
639            * Returns all the user groups with the primary keys.
640            *
641            * @param userGroupIds the primary keys of the user groups
642            * @return the user groups with the primary keys
643            */
644            @Override
645            public java.util.List<com.liferay.portal.model.UserGroup> getUserGroups(
646                    long[] userGroupIds)
647                    throws com.liferay.portal.kernel.exception.PortalException {
648                    return _userGroupLocalService.getUserGroups(userGroupIds);
649            }
650    
651            /**
652            * Returns the number of user groups.
653            *
654            * @return the number of user groups
655            */
656            @Override
657            public int getUserGroupsCount() {
658                    return _userGroupLocalService.getUserGroupsCount();
659            }
660    
661            /**
662            * Returns the userIds of the users associated with the user group.
663            *
664            * @param userGroupId the userGroupId of the user group
665            * @return long[] the userIds of users associated with the user group
666            */
667            @Override
668            public long[] getUserPrimaryKeys(long userGroupId) {
669                    return _userGroupLocalService.getUserPrimaryKeys(userGroupId);
670            }
671    
672            @Override
673            public java.util.List<com.liferay.portal.model.UserGroup> getUserUserGroups(
674                    long userId) {
675                    return _userGroupLocalService.getUserUserGroups(userId);
676            }
677    
678            @Override
679            public java.util.List<com.liferay.portal.model.UserGroup> getUserUserGroups(
680                    long userId, int start, int end) {
681                    return _userGroupLocalService.getUserUserGroups(userId, start, end);
682            }
683    
684            @Override
685            public java.util.List<com.liferay.portal.model.UserGroup> getUserUserGroups(
686                    long userId, int start, int end,
687                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.UserGroup> orderByComparator) {
688                    return _userGroupLocalService.getUserUserGroups(userId, start, end,
689                            orderByComparator);
690            }
691    
692            @Override
693            public int getUserUserGroupsCount(long userId) {
694                    return _userGroupLocalService.getUserUserGroupsCount(userId);
695            }
696    
697            @Override
698            public boolean hasGroupUserGroup(long groupId, long userGroupId) {
699                    return _userGroupLocalService.hasGroupUserGroup(groupId, userGroupId);
700            }
701    
702            @Override
703            public boolean hasGroupUserGroups(long groupId) {
704                    return _userGroupLocalService.hasGroupUserGroups(groupId);
705            }
706    
707            @Override
708            public boolean hasTeamUserGroup(long teamId, long userGroupId) {
709                    return _userGroupLocalService.hasTeamUserGroup(teamId, userGroupId);
710            }
711    
712            @Override
713            public boolean hasTeamUserGroups(long teamId) {
714                    return _userGroupLocalService.hasTeamUserGroups(teamId);
715            }
716    
717            @Override
718            public boolean hasUserUserGroup(long userId, long userGroupId) {
719                    return _userGroupLocalService.hasUserUserGroup(userId, userGroupId);
720            }
721    
722            @Override
723            public boolean hasUserUserGroups(long userId) {
724                    return _userGroupLocalService.hasUserUserGroups(userId);
725            }
726    
727            /**
728            * Returns an ordered range of all the user groups that match the keywords.
729            *
730            * <p>
731            * Useful when paginating results. Returns a maximum of <code>end -
732            * start</code> instances. <code>start</code> and <code>end</code> are not
733            * primary keys, they are indexes in the result set. Thus, <code>0</code>
734            * refers to the first result in the set. Setting both <code>start</code>
735            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
736            * result set.
737            * </p>
738            *
739            * @param companyId the primary key of the user group's company
740            * @param keywords the keywords (space separated), which may occur in the
741            user group's name or description (optionally <code>null</code>)
742            * @param params the finder params (optionally <code>null</code>). For more
743            information see {@link
744            com.liferay.portal.service.persistence.UserGroupFinder}
745            * @param start the lower bound of the range of user groups to return
746            * @param end the upper bound of the range of user groups to return (not
747            inclusive)
748            * @param obc the comparator to order the user groups (optionally
749            <code>null</code>)
750            * @return the matching user groups ordered by comparator <code>obc</code>
751            * @see com.liferay.portal.service.persistence.UserGroupFinder
752            */
753            @Override
754            public java.util.List<com.liferay.portal.model.UserGroup> search(
755                    long companyId, java.lang.String keywords,
756                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
757                    int start, int end,
758                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.UserGroup> obc) {
759                    return _userGroupLocalService.search(companyId, keywords, params,
760                            start, end, obc);
761            }
762    
763            /**
764            * Returns an ordered range of all the user groups that match the keywords,
765            * using the indexer. It is preferable to use this method instead of the
766            * non-indexed version whenever possible for performance reasons.
767            *
768            * <p>
769            * Useful when paginating results. Returns a maximum of <code>end -
770            * start</code> instances. <code>start</code> and <code>end</code> are not
771            * primary keys, they are indexes in the result set. Thus, <code>0</code>
772            * refers to the first result in the set. Setting both <code>start</code>
773            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
774            * result set.
775            * </p>
776            *
777            * @param companyId the primary key of the user group's company
778            * @param keywords the keywords (space separated), which may occur in the
779            user group's name or description (optionally <code>null</code>)
780            * @param params the finder params (optionally <code>null</code>). For more
781            information see {@link
782            com.liferay.portlet.usergroupsadmin.util.UserGroupIndexer}
783            * @param start the lower bound of the range of user groups to return
784            * @param end the upper bound of the range of user groups to return (not
785            inclusive)
786            * @param sort the field and direction by which to sort (optionally
787            <code>null</code>)
788            * @return the matching user groups ordered by sort
789            * @see com.liferay.portlet.usergroupsadmin.util.UserGroupIndexer
790            */
791            @Override
792            public com.liferay.portal.kernel.search.Hits search(long companyId,
793                    java.lang.String keywords,
794                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
795                    int start, int end, com.liferay.portal.kernel.search.Sort sort) {
796                    return _userGroupLocalService.search(companyId, keywords, params,
797                            start, end, sort);
798            }
799    
800            /**
801            * Returns an ordered range of all the user groups that match the name and
802            * description.
803            *
804            * <p>
805            * Useful when paginating results. Returns a maximum of <code>end -
806            * start</code> instances. <code>start</code> and <code>end</code> are not
807            * primary keys, they are indexes in the result set. Thus, <code>0</code>
808            * refers to the first result in the set. Setting both <code>start</code>
809            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
810            * result set.
811            * </p>
812            *
813            * @param companyId the primary key of the user group's company
814            * @param name the user group's name (optionally <code>null</code>)
815            * @param description the user group's description (optionally
816            <code>null</code>)
817            * @param params the finder params (optionally <code>null</code>). For more
818            information see {@link
819            com.liferay.portal.service.persistence.UserGroupFinder}
820            * @param andOperator whether every field must match its keywords or just
821            one field
822            * @param start the lower bound of the range of user groups to return
823            * @param end the upper bound of the range of user groups to return (not
824            inclusive)
825            * @param obc the comparator to order the user groups (optionally
826            <code>null</code>)
827            * @return the matching user groups ordered by comparator <code>obc</code>
828            * @see com.liferay.portal.service.persistence.UserGroupFinder
829            */
830            @Override
831            public java.util.List<com.liferay.portal.model.UserGroup> search(
832                    long companyId, java.lang.String name, java.lang.String description,
833                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
834                    boolean andOperator, int start, int end,
835                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.UserGroup> obc) {
836                    return _userGroupLocalService.search(companyId, name, description,
837                            params, andOperator, start, end, obc);
838            }
839    
840            /**
841            * Returns an ordered range of all the user groups that match the name and
842            * description. It is preferable to use this method instead of the
843            * non-indexed version whenever possible for performance reasons.
844            *
845            * <p>
846            * Useful when paginating results. Returns a maximum of <code>end -
847            * start</code> instances. <code>start</code> and <code>end</code> are not
848            * primary keys, they are indexes in the result set. Thus, <code>0</code>
849            * refers to the first result in the set. Setting both <code>start</code>
850            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
851            * result set.
852            * </p>
853            *
854            * @param companyId the primary key of the user group's company
855            * @param name the user group's name (optionally <code>null</code>)
856            * @param description the user group's description (optionally
857            <code>null</code>)
858            * @param params the finder params (optionally <code>null</code>). For more
859            information see {@link
860            com.liferay.portlet.usergroupsadmin.util.UserGroupIndexer}
861            * @param andSearch whether every field must match its keywords or just one
862            field
863            * @param start the lower bound of the range of user groups to return
864            * @param end the upper bound of the range of user groups to return (not
865            inclusive)
866            * @param sort the field and direction by which to sort (optionally
867            <code>null</code>)
868            * @return the matching user groups ordered by sort
869            * @see com.liferay.portal.service.persistence.UserGroupFinder
870            */
871            @Override
872            public com.liferay.portal.kernel.search.Hits search(long companyId,
873                    java.lang.String name, java.lang.String description,
874                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
875                    boolean andSearch, int start, int end,
876                    com.liferay.portal.kernel.search.Sort sort) {
877                    return _userGroupLocalService.search(companyId, name, description,
878                            params, andSearch, start, end, sort);
879            }
880    
881            /**
882            * Returns the number of user groups that match the keywords
883            *
884            * @param companyId the primary key of the user group's company
885            * @param keywords the keywords (space separated), which may occur in the
886            user group's name or description (optionally <code>null</code>)
887            * @param params the finder params (optionally <code>null</code>). For more
888            information see {@link
889            com.liferay.portal.service.persistence.UserGroupFinder}
890            * @return the number of matching user groups
891            * @see com.liferay.portal.service.persistence.UserGroupFinder
892            */
893            @Override
894            public int searchCount(long companyId, java.lang.String keywords,
895                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params) {
896                    return _userGroupLocalService.searchCount(companyId, keywords, params);
897            }
898    
899            /**
900            * Returns the number of user groups that match the name and description.
901            *
902            * @param companyId the primary key of the user group's company
903            * @param name the user group's name (optionally <code>null</code>)
904            * @param description the user group's description (optionally
905            <code>null</code>)
906            * @param params the finder params (optionally <code>null</code>). For more
907            information see {@link
908            com.liferay.portal.service.persistence.UserGroupFinder}
909            * @param andOperator whether every field must match its keywords or just
910            one field
911            * @return the number of matching user groups
912            * @see com.liferay.portal.service.persistence.UserGroupFinder
913            */
914            @Override
915            public int searchCount(long companyId, java.lang.String name,
916                    java.lang.String description,
917                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
918                    boolean andOperator) {
919                    return _userGroupLocalService.searchCount(companyId, name, description,
920                            params, andOperator);
921            }
922    
923            @Override
924            public com.liferay.portal.kernel.search.BaseModelSearchResult<com.liferay.portal.model.UserGroup> searchUserGroups(
925                    long companyId, java.lang.String keywords,
926                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
927                    int start, int end, com.liferay.portal.kernel.search.Sort sort)
928                    throws com.liferay.portal.kernel.exception.PortalException {
929                    return _userGroupLocalService.searchUserGroups(companyId, keywords,
930                            params, start, end, sort);
931            }
932    
933            @Override
934            public com.liferay.portal.kernel.search.BaseModelSearchResult<com.liferay.portal.model.UserGroup> searchUserGroups(
935                    long companyId, java.lang.String name, java.lang.String description,
936                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
937                    boolean andSearch, int start, int end,
938                    com.liferay.portal.kernel.search.Sort sort)
939                    throws com.liferay.portal.kernel.exception.PortalException {
940                    return _userGroupLocalService.searchUserGroups(companyId, name,
941                            description, params, andSearch, start, end, sort);
942            }
943    
944            @Override
945            public void setGroupUserGroups(long groupId, long[] userGroupIds) {
946                    _userGroupLocalService.setGroupUserGroups(groupId, userGroupIds);
947            }
948    
949            @Override
950            public void setTeamUserGroups(long teamId, long[] userGroupIds) {
951                    _userGroupLocalService.setTeamUserGroups(teamId, userGroupIds);
952            }
953    
954            /**
955            * @throws PortalException
956            */
957            @Override
958            public void setUserUserGroups(long userId, long[] userGroupIds)
959                    throws com.liferay.portal.kernel.exception.PortalException {
960                    _userGroupLocalService.setUserUserGroups(userId, userGroupIds);
961            }
962    
963            /**
964            * Removes the user groups from the group.
965            *
966            * @param groupId the primary key of the group
967            * @param userGroupIds the primary keys of the user groups
968            */
969            @Override
970            public void unsetGroupUserGroups(long groupId, long[] userGroupIds) {
971                    _userGroupLocalService.unsetGroupUserGroups(groupId, userGroupIds);
972            }
973    
974            /**
975            * Removes the user groups from the team.
976            *
977            * @param teamId the primary key of the team
978            * @param userGroupIds the primary keys of the user groups
979            */
980            @Override
981            public void unsetTeamUserGroups(long teamId, long[] userGroupIds) {
982                    _userGroupLocalService.unsetTeamUserGroups(teamId, userGroupIds);
983            }
984    
985            /**
986            * Updates the user group.
987            *
988            * @param companyId the primary key of the user group's company
989            * @param userGroupId the primary key of the user group
990            * @param name the user group's name
991            * @param description the user group's description
992            * @return the user group
993            * @deprecated As of 6.2.0, replaced by {@link #updateUserGroup(long, long,
994            String, String, ServiceContext)}
995            */
996            @Deprecated
997            @Override
998            public com.liferay.portal.model.UserGroup updateUserGroup(long companyId,
999                    long userGroupId, java.lang.String name, java.lang.String description)
1000                    throws com.liferay.portal.kernel.exception.PortalException {
1001                    return _userGroupLocalService.updateUserGroup(companyId, userGroupId,
1002                            name, description);
1003            }
1004    
1005            /**
1006            * Updates the user group.
1007            *
1008            * @param companyId the primary key of the user group's company
1009            * @param userGroupId the primary key of the user group
1010            * @param name the user group's name
1011            * @param description the user group's description
1012            * @param serviceContext the service context to be applied (optionally
1013            <code>null</code>). Can set expando bridge attributes for the
1014            user group.
1015            * @return the user group
1016            */
1017            @Override
1018            public com.liferay.portal.model.UserGroup updateUserGroup(long companyId,
1019                    long userGroupId, java.lang.String name, java.lang.String description,
1020                    com.liferay.portal.service.ServiceContext serviceContext)
1021                    throws com.liferay.portal.kernel.exception.PortalException {
1022                    return _userGroupLocalService.updateUserGroup(companyId, userGroupId,
1023                            name, description, serviceContext);
1024            }
1025    
1026            /**
1027            * Updates the user group in the database or adds it if it does not yet exist. Also notifies the appropriate model listeners.
1028            *
1029            * @param userGroup the user group
1030            * @return the user group that was updated
1031            */
1032            @Override
1033            public com.liferay.portal.model.UserGroup updateUserGroup(
1034                    com.liferay.portal.model.UserGroup userGroup) {
1035                    return _userGroupLocalService.updateUserGroup(userGroup);
1036            }
1037    
1038            @Override
1039            public UserGroupLocalService getWrappedService() {
1040                    return _userGroupLocalService;
1041            }
1042    
1043            @Override
1044            public void setWrappedService(UserGroupLocalService userGroupLocalService) {
1045                    _userGroupLocalService = userGroupLocalService;
1046            }
1047    
1048            private UserGroupLocalService _userGroupLocalService;
1049    }