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