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 TeamLocalService}.
021     *
022     * @author Brian Wing Shun Chan
023     * @see TeamLocalService
024     * @generated
025     */
026    @ProviderType
027    public class TeamLocalServiceWrapper implements TeamLocalService,
028            ServiceWrapper<TeamLocalService> {
029            public TeamLocalServiceWrapper(TeamLocalService teamLocalService) {
030                    _teamLocalService = teamLocalService;
031            }
032    
033            /**
034            * Adds the team to the database. Also notifies the appropriate model listeners.
035            *
036            * @param team the team
037            * @return the team that was added
038            */
039            @Override
040            public com.liferay.portal.model.Team addTeam(
041                    com.liferay.portal.model.Team team) {
042                    return _teamLocalService.addTeam(team);
043            }
044    
045            /**
046            * @deprecated As of 7.0.0, replaced by {@link #addTeam(long, long, String,
047            String, ServiceContext)}
048            */
049            @Deprecated
050            @Override
051            public com.liferay.portal.model.Team addTeam(long userId, long groupId,
052                    java.lang.String name, java.lang.String description)
053                    throws com.liferay.portal.kernel.exception.PortalException {
054                    return _teamLocalService.addTeam(userId, groupId, name, description);
055            }
056    
057            @Override
058            public com.liferay.portal.model.Team addTeam(long userId, long groupId,
059                    java.lang.String name, java.lang.String description,
060                    com.liferay.portal.service.ServiceContext serviceContext)
061                    throws com.liferay.portal.kernel.exception.PortalException {
062                    return _teamLocalService.addTeam(userId, groupId, name, description,
063                            serviceContext);
064            }
065    
066            @Override
067            public void addUserGroupTeam(long userGroupId,
068                    com.liferay.portal.model.Team team) {
069                    _teamLocalService.addUserGroupTeam(userGroupId, team);
070            }
071    
072            @Override
073            public void addUserGroupTeam(long userGroupId, long teamId) {
074                    _teamLocalService.addUserGroupTeam(userGroupId, teamId);
075            }
076    
077            @Override
078            public void addUserGroupTeams(long userGroupId,
079                    java.util.List<com.liferay.portal.model.Team> Teams) {
080                    _teamLocalService.addUserGroupTeams(userGroupId, Teams);
081            }
082    
083            @Override
084            public void addUserGroupTeams(long userGroupId, long[] teamIds) {
085                    _teamLocalService.addUserGroupTeams(userGroupId, teamIds);
086            }
087    
088            @Override
089            public void addUserTeam(long userId, com.liferay.portal.model.Team team) {
090                    _teamLocalService.addUserTeam(userId, team);
091            }
092    
093            @Override
094            public void addUserTeam(long userId, long teamId) {
095                    _teamLocalService.addUserTeam(userId, teamId);
096            }
097    
098            @Override
099            public void addUserTeams(long userId,
100                    java.util.List<com.liferay.portal.model.Team> Teams) {
101                    _teamLocalService.addUserTeams(userId, Teams);
102            }
103    
104            @Override
105            public void addUserTeams(long userId, long[] teamIds) {
106                    _teamLocalService.addUserTeams(userId, teamIds);
107            }
108    
109            @Override
110            public void clearUserGroupTeams(long userGroupId) {
111                    _teamLocalService.clearUserGroupTeams(userGroupId);
112            }
113    
114            @Override
115            public void clearUserTeams(long userId) {
116                    _teamLocalService.clearUserTeams(userId);
117            }
118    
119            /**
120            * Creates a new team with the primary key. Does not add the team to the database.
121            *
122            * @param teamId the primary key for the new team
123            * @return the new team
124            */
125            @Override
126            public com.liferay.portal.model.Team createTeam(long teamId) {
127                    return _teamLocalService.createTeam(teamId);
128            }
129    
130            /**
131            * @throws PortalException
132            */
133            @Override
134            public com.liferay.portal.model.PersistedModel deletePersistedModel(
135                    com.liferay.portal.model.PersistedModel persistedModel)
136                    throws com.liferay.portal.kernel.exception.PortalException {
137                    return _teamLocalService.deletePersistedModel(persistedModel);
138            }
139    
140            /**
141            * Deletes the team from the database. Also notifies the appropriate model listeners.
142            *
143            * @param team the team
144            * @return the team that was removed
145            * @throws PortalException
146            */
147            @Override
148            public com.liferay.portal.model.Team deleteTeam(
149                    com.liferay.portal.model.Team team)
150                    throws com.liferay.portal.kernel.exception.PortalException {
151                    return _teamLocalService.deleteTeam(team);
152            }
153    
154            /**
155            * Deletes the team with the primary key from the database. Also notifies the appropriate model listeners.
156            *
157            * @param teamId the primary key of the team
158            * @return the team that was removed
159            * @throws PortalException if a team with the primary key could not be found
160            */
161            @Override
162            public com.liferay.portal.model.Team deleteTeam(long teamId)
163                    throws com.liferay.portal.kernel.exception.PortalException {
164                    return _teamLocalService.deleteTeam(teamId);
165            }
166    
167            @Override
168            public void deleteTeams(long groupId)
169                    throws com.liferay.portal.kernel.exception.PortalException {
170                    _teamLocalService.deleteTeams(groupId);
171            }
172    
173            @Override
174            public void deleteUserGroupTeam(long userGroupId,
175                    com.liferay.portal.model.Team team) {
176                    _teamLocalService.deleteUserGroupTeam(userGroupId, team);
177            }
178    
179            @Override
180            public void deleteUserGroupTeam(long userGroupId, long teamId) {
181                    _teamLocalService.deleteUserGroupTeam(userGroupId, teamId);
182            }
183    
184            @Override
185            public void deleteUserGroupTeams(long userGroupId,
186                    java.util.List<com.liferay.portal.model.Team> Teams) {
187                    _teamLocalService.deleteUserGroupTeams(userGroupId, Teams);
188            }
189    
190            @Override
191            public void deleteUserGroupTeams(long userGroupId, long[] teamIds) {
192                    _teamLocalService.deleteUserGroupTeams(userGroupId, teamIds);
193            }
194    
195            @Override
196            public void deleteUserTeam(long userId, com.liferay.portal.model.Team team) {
197                    _teamLocalService.deleteUserTeam(userId, team);
198            }
199    
200            @Override
201            public void deleteUserTeam(long userId, long teamId) {
202                    _teamLocalService.deleteUserTeam(userId, teamId);
203            }
204    
205            @Override
206            public void deleteUserTeams(long userId,
207                    java.util.List<com.liferay.portal.model.Team> Teams) {
208                    _teamLocalService.deleteUserTeams(userId, Teams);
209            }
210    
211            @Override
212            public void deleteUserTeams(long userId, long[] teamIds) {
213                    _teamLocalService.deleteUserTeams(userId, teamIds);
214            }
215    
216            @Override
217            public com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery() {
218                    return _teamLocalService.dynamicQuery();
219            }
220    
221            /**
222            * Performs a dynamic query on the database and returns the matching rows.
223            *
224            * @param dynamicQuery the dynamic query
225            * @return the matching rows
226            */
227            @Override
228            public <T> java.util.List<T> dynamicQuery(
229                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) {
230                    return _teamLocalService.dynamicQuery(dynamicQuery);
231            }
232    
233            /**
234            * Performs a dynamic query on the database and returns a range of the matching rows.
235            *
236            * <p>
237            * 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.TeamModelImpl}. 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.
238            * </p>
239            *
240            * @param dynamicQuery the dynamic query
241            * @param start the lower bound of the range of model instances
242            * @param end the upper bound of the range of model instances (not inclusive)
243            * @return the range of matching rows
244            */
245            @Override
246            public <T> java.util.List<T> dynamicQuery(
247                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start,
248                    int end) {
249                    return _teamLocalService.dynamicQuery(dynamicQuery, start, end);
250            }
251    
252            /**
253            * Performs a dynamic query on the database and returns an ordered range of the matching rows.
254            *
255            * <p>
256            * 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.TeamModelImpl}. 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.
257            * </p>
258            *
259            * @param dynamicQuery the dynamic query
260            * @param start the lower bound of the range of model instances
261            * @param end the upper bound of the range of model instances (not inclusive)
262            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
263            * @return the ordered range of matching rows
264            */
265            @Override
266            public <T> java.util.List<T> dynamicQuery(
267                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start,
268                    int end,
269                    com.liferay.portal.kernel.util.OrderByComparator<T> orderByComparator) {
270                    return _teamLocalService.dynamicQuery(dynamicQuery, start, end,
271                            orderByComparator);
272            }
273    
274            /**
275            * Returns the number of rows matching the dynamic query.
276            *
277            * @param dynamicQuery the dynamic query
278            * @return the number of rows matching the dynamic query
279            */
280            @Override
281            public long dynamicQueryCount(
282                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) {
283                    return _teamLocalService.dynamicQueryCount(dynamicQuery);
284            }
285    
286            /**
287            * Returns the number of rows matching the dynamic query.
288            *
289            * @param dynamicQuery the dynamic query
290            * @param projection the projection to apply to the query
291            * @return the number of rows matching the dynamic query
292            */
293            @Override
294            public long dynamicQueryCount(
295                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery,
296                    com.liferay.portal.kernel.dao.orm.Projection projection) {
297                    return _teamLocalService.dynamicQueryCount(dynamicQuery, projection);
298            }
299    
300            @Override
301            public com.liferay.portal.model.Team fetchTeam(long groupId,
302                    java.lang.String name) {
303                    return _teamLocalService.fetchTeam(groupId, name);
304            }
305    
306            @Override
307            public com.liferay.portal.model.Team fetchTeam(long teamId) {
308                    return _teamLocalService.fetchTeam(teamId);
309            }
310    
311            /**
312            * Returns the team matching the UUID and group.
313            *
314            * @param uuid the team's UUID
315            * @param groupId the primary key of the group
316            * @return the matching team, or <code>null</code> if a matching team could not be found
317            */
318            @Override
319            public com.liferay.portal.model.Team fetchTeamByUuidAndGroupId(
320                    java.lang.String uuid, long groupId) {
321                    return _teamLocalService.fetchTeamByUuidAndGroupId(uuid, groupId);
322            }
323    
324            @Override
325            public com.liferay.portal.kernel.dao.orm.ActionableDynamicQuery getActionableDynamicQuery() {
326                    return _teamLocalService.getActionableDynamicQuery();
327            }
328    
329            @Override
330            public com.liferay.portal.kernel.dao.orm.ExportActionableDynamicQuery getExportActionableDynamicQuery(
331                    com.liferay.portlet.exportimport.lar.PortletDataContext portletDataContext) {
332                    return _teamLocalService.getExportActionableDynamicQuery(portletDataContext);
333            }
334    
335            @Override
336            public java.util.List<com.liferay.portal.model.Team> getGroupTeams(
337                    long groupId) {
338                    return _teamLocalService.getGroupTeams(groupId);
339            }
340    
341            @Override
342            public com.liferay.portal.kernel.dao.orm.IndexableActionableDynamicQuery getIndexableActionableDynamicQuery() {
343                    return _teamLocalService.getIndexableActionableDynamicQuery();
344            }
345    
346            /**
347            * Returns the OSGi service identifier.
348            *
349            * @return the OSGi service identifier
350            */
351            @Override
352            public java.lang.String getOSGiServiceIdentifier() {
353                    return _teamLocalService.getOSGiServiceIdentifier();
354            }
355    
356            @Override
357            public com.liferay.portal.model.PersistedModel getPersistedModel(
358                    java.io.Serializable primaryKeyObj)
359                    throws com.liferay.portal.kernel.exception.PortalException {
360                    return _teamLocalService.getPersistedModel(primaryKeyObj);
361            }
362    
363            @Override
364            public com.liferay.portal.model.Team getTeam(long groupId,
365                    java.lang.String name)
366                    throws com.liferay.portal.kernel.exception.PortalException {
367                    return _teamLocalService.getTeam(groupId, name);
368            }
369    
370            /**
371            * Returns the team with the primary key.
372            *
373            * @param teamId the primary key of the team
374            * @return the team
375            * @throws PortalException if a team with the primary key could not be found
376            */
377            @Override
378            public com.liferay.portal.model.Team getTeam(long teamId)
379                    throws com.liferay.portal.kernel.exception.PortalException {
380                    return _teamLocalService.getTeam(teamId);
381            }
382    
383            /**
384            * Returns the team matching the UUID and group.
385            *
386            * @param uuid the team's UUID
387            * @param groupId the primary key of the group
388            * @return the matching team
389            * @throws PortalException if a matching team could not be found
390            */
391            @Override
392            public com.liferay.portal.model.Team getTeamByUuidAndGroupId(
393                    java.lang.String uuid, long groupId)
394                    throws com.liferay.portal.kernel.exception.PortalException {
395                    return _teamLocalService.getTeamByUuidAndGroupId(uuid, groupId);
396            }
397    
398            /**
399            * Returns a range of all the teams.
400            *
401            * <p>
402            * 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.TeamModelImpl}. 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.
403            * </p>
404            *
405            * @param start the lower bound of the range of teams
406            * @param end the upper bound of the range of teams (not inclusive)
407            * @return the range of teams
408            */
409            @Override
410            public java.util.List<com.liferay.portal.model.Team> getTeams(int start,
411                    int end) {
412                    return _teamLocalService.getTeams(start, end);
413            }
414    
415            /**
416            * Returns all the teams matching the UUID and company.
417            *
418            * @param uuid the UUID of the teams
419            * @param companyId the primary key of the company
420            * @return the matching teams, or an empty list if no matches were found
421            */
422            @Override
423            public java.util.List<com.liferay.portal.model.Team> getTeamsByUuidAndCompanyId(
424                    java.lang.String uuid, long companyId) {
425                    return _teamLocalService.getTeamsByUuidAndCompanyId(uuid, companyId);
426            }
427    
428            /**
429            * Returns a range of teams matching the UUID and company.
430            *
431            * @param uuid the UUID of the teams
432            * @param companyId the primary key of the company
433            * @param start the lower bound of the range of teams
434            * @param end the upper bound of the range of teams (not inclusive)
435            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
436            * @return the range of matching teams, or an empty list if no matches were found
437            */
438            @Override
439            public java.util.List<com.liferay.portal.model.Team> getTeamsByUuidAndCompanyId(
440                    java.lang.String uuid, long companyId, int start, int end,
441                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Team> orderByComparator) {
442                    return _teamLocalService.getTeamsByUuidAndCompanyId(uuid, companyId,
443                            start, end, orderByComparator);
444            }
445    
446            /**
447            * Returns the number of teams.
448            *
449            * @return the number of teams
450            */
451            @Override
452            public int getTeamsCount() {
453                    return _teamLocalService.getTeamsCount();
454            }
455    
456            /**
457            * Returns the userGroupIds of the user groups associated with the team.
458            *
459            * @param teamId the teamId of the team
460            * @return long[] the userGroupIds of user groups associated with the team
461            */
462            @Override
463            public long[] getUserGroupPrimaryKeys(long teamId) {
464                    return _teamLocalService.getUserGroupPrimaryKeys(teamId);
465            }
466    
467            @Override
468            public java.util.List<com.liferay.portal.model.Team> getUserGroupTeams(
469                    long userGroupId) {
470                    return _teamLocalService.getUserGroupTeams(userGroupId);
471            }
472    
473            @Override
474            public java.util.List<com.liferay.portal.model.Team> getUserGroupTeams(
475                    long userGroupId, int start, int end) {
476                    return _teamLocalService.getUserGroupTeams(userGroupId, start, end);
477            }
478    
479            @Override
480            public java.util.List<com.liferay.portal.model.Team> getUserGroupTeams(
481                    long userGroupId, int start, int end,
482                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Team> orderByComparator) {
483                    return _teamLocalService.getUserGroupTeams(userGroupId, start, end,
484                            orderByComparator);
485            }
486    
487            @Override
488            public int getUserGroupTeamsCount(long userGroupId) {
489                    return _teamLocalService.getUserGroupTeamsCount(userGroupId);
490            }
491    
492            @Override
493            public java.util.List<com.liferay.portal.model.Team> getUserOrUserGroupTeams(
494                    long groupId, long userId) {
495                    return _teamLocalService.getUserOrUserGroupTeams(groupId, userId);
496            }
497    
498            /**
499            * Returns the userIds of the users associated with the team.
500            *
501            * @param teamId the teamId of the team
502            * @return long[] the userIds of users associated with the team
503            */
504            @Override
505            public long[] getUserPrimaryKeys(long teamId) {
506                    return _teamLocalService.getUserPrimaryKeys(teamId);
507            }
508    
509            @Override
510            public java.util.List<com.liferay.portal.model.Team> getUserTeams(
511                    long userId) {
512                    return _teamLocalService.getUserTeams(userId);
513            }
514    
515            @Override
516            public java.util.List<com.liferay.portal.model.Team> getUserTeams(
517                    long userId, long groupId) {
518                    return _teamLocalService.getUserTeams(userId, groupId);
519            }
520    
521            @Override
522            public java.util.List<com.liferay.portal.model.Team> getUserTeams(
523                    long userId, int start, int end) {
524                    return _teamLocalService.getUserTeams(userId, start, end);
525            }
526    
527            @Override
528            public java.util.List<com.liferay.portal.model.Team> getUserTeams(
529                    long userId, int start, int end,
530                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Team> orderByComparator) {
531                    return _teamLocalService.getUserTeams(userId, start, end,
532                            orderByComparator);
533            }
534    
535            @Override
536            public int getUserTeamsCount(long userId) {
537                    return _teamLocalService.getUserTeamsCount(userId);
538            }
539    
540            @Override
541            public boolean hasUserGroupTeam(long userGroupId, long teamId) {
542                    return _teamLocalService.hasUserGroupTeam(userGroupId, teamId);
543            }
544    
545            @Override
546            public boolean hasUserGroupTeams(long userGroupId) {
547                    return _teamLocalService.hasUserGroupTeams(userGroupId);
548            }
549    
550            @Override
551            public boolean hasUserTeam(long userId, long teamId) {
552                    return _teamLocalService.hasUserTeam(userId, teamId);
553            }
554    
555            @Override
556            public boolean hasUserTeams(long userId) {
557                    return _teamLocalService.hasUserTeams(userId);
558            }
559    
560            @Override
561            public java.util.List<com.liferay.portal.model.Team> search(long groupId,
562                    java.lang.String name, java.lang.String description,
563                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
564                    int start, int end,
565                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Team> obc) {
566                    return _teamLocalService.search(groupId, name, description, params,
567                            start, end, obc);
568            }
569    
570            @Override
571            public int searchCount(long groupId, java.lang.String name,
572                    java.lang.String description,
573                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params) {
574                    return _teamLocalService.searchCount(groupId, name, description, params);
575            }
576    
577            @Override
578            public void setUserGroupTeams(long userGroupId, long[] teamIds) {
579                    _teamLocalService.setUserGroupTeams(userGroupId, teamIds);
580            }
581    
582            @Override
583            public void setUserTeams(long userId, long[] teamIds) {
584                    _teamLocalService.setUserTeams(userId, teamIds);
585            }
586    
587            /**
588            * Updates the team in the database or adds it if it does not yet exist. Also notifies the appropriate model listeners.
589            *
590            * @param team the team
591            * @return the team that was updated
592            */
593            @Override
594            public com.liferay.portal.model.Team updateTeam(
595                    com.liferay.portal.model.Team team) {
596                    return _teamLocalService.updateTeam(team);
597            }
598    
599            @Override
600            public com.liferay.portal.model.Team updateTeam(long teamId,
601                    java.lang.String name, java.lang.String description)
602                    throws com.liferay.portal.kernel.exception.PortalException {
603                    return _teamLocalService.updateTeam(teamId, name, description);
604            }
605    
606            @Override
607            public TeamLocalService getWrappedService() {
608                    return _teamLocalService;
609            }
610    
611            @Override
612            public void setWrappedService(TeamLocalService teamLocalService) {
613                    _teamLocalService = teamLocalService;
614            }
615    
616            private TeamLocalService _teamLocalService;
617    }