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 BackgroundTaskLocalService}.
021     *
022     * @author Brian Wing Shun Chan
023     * @see BackgroundTaskLocalService
024     * @generated
025     */
026    @ProviderType
027    public class BackgroundTaskLocalServiceWrapper
028            implements BackgroundTaskLocalService,
029                    ServiceWrapper<BackgroundTaskLocalService> {
030            public BackgroundTaskLocalServiceWrapper(
031                    BackgroundTaskLocalService backgroundTaskLocalService) {
032                    _backgroundTaskLocalService = backgroundTaskLocalService;
033            }
034    
035            /**
036            * Adds the background task to the database. Also notifies the appropriate model listeners.
037            *
038            * @param backgroundTask the background task
039            * @return the background task that was added
040            */
041            @Override
042            public com.liferay.portal.model.BackgroundTask addBackgroundTask(
043                    com.liferay.portal.model.BackgroundTask backgroundTask) {
044                    return _backgroundTaskLocalService.addBackgroundTask(backgroundTask);
045            }
046    
047            @Override
048            public com.liferay.portal.model.BackgroundTask addBackgroundTask(
049                    long userId, long groupId, java.lang.String name,
050                    java.lang.String[] servletContextNames,
051                    java.lang.Class<?> taskExecutorClass,
052                    java.util.Map<java.lang.String, java.io.Serializable> taskContextMap,
053                    com.liferay.portal.service.ServiceContext serviceContext)
054                    throws com.liferay.portal.kernel.exception.PortalException {
055                    return _backgroundTaskLocalService.addBackgroundTask(userId, groupId,
056                            name, servletContextNames, taskExecutorClass, taskContextMap,
057                            serviceContext);
058            }
059    
060            @Override
061            public void addBackgroundTaskAttachment(long userId, long backgroundTaskId,
062                    java.lang.String fileName, java.io.File file)
063                    throws com.liferay.portal.kernel.exception.PortalException {
064                    _backgroundTaskLocalService.addBackgroundTaskAttachment(userId,
065                            backgroundTaskId, fileName, file);
066            }
067    
068            @Override
069            public void addBackgroundTaskAttachment(long userId, long backgroundTaskId,
070                    java.lang.String fileName, java.io.InputStream inputStream)
071                    throws com.liferay.portal.kernel.exception.PortalException {
072                    _backgroundTaskLocalService.addBackgroundTaskAttachment(userId,
073                            backgroundTaskId, fileName, inputStream);
074            }
075    
076            @Override
077            public com.liferay.portal.model.BackgroundTask amendBackgroundTask(
078                    long backgroundTaskId,
079                    java.util.Map<java.lang.String, java.io.Serializable> taskContextMap,
080                    int status, com.liferay.portal.service.ServiceContext serviceContext) {
081                    return _backgroundTaskLocalService.amendBackgroundTask(backgroundTaskId,
082                            taskContextMap, status, serviceContext);
083            }
084    
085            @Override
086            public com.liferay.portal.model.BackgroundTask amendBackgroundTask(
087                    long backgroundTaskId,
088                    java.util.Map<java.lang.String, java.io.Serializable> taskContextMap,
089                    int status, java.lang.String statusMessage,
090                    com.liferay.portal.service.ServiceContext serviceContext) {
091                    return _backgroundTaskLocalService.amendBackgroundTask(backgroundTaskId,
092                            taskContextMap, status, statusMessage, serviceContext);
093            }
094    
095            @Override
096            public void cleanUpBackgroundTask(
097                    com.liferay.portal.model.BackgroundTask backgroundTask, int status) {
098                    _backgroundTaskLocalService.cleanUpBackgroundTask(backgroundTask, status);
099            }
100    
101            @Override
102            public void cleanUpBackgroundTasks() {
103                    _backgroundTaskLocalService.cleanUpBackgroundTasks();
104            }
105    
106            /**
107            * Creates a new background task with the primary key. Does not add the background task to the database.
108            *
109            * @param backgroundTaskId the primary key for the new background task
110            * @return the new background task
111            */
112            @Override
113            public com.liferay.portal.model.BackgroundTask createBackgroundTask(
114                    long backgroundTaskId) {
115                    return _backgroundTaskLocalService.createBackgroundTask(backgroundTaskId);
116            }
117    
118            /**
119            * Deletes the background task from the database. Also notifies the appropriate model listeners.
120            *
121            * @param backgroundTask the background task
122            * @return the background task that was removed
123            * @throws PortalException
124            */
125            @Override
126            public com.liferay.portal.model.BackgroundTask deleteBackgroundTask(
127                    com.liferay.portal.model.BackgroundTask backgroundTask)
128                    throws com.liferay.portal.kernel.exception.PortalException {
129                    return _backgroundTaskLocalService.deleteBackgroundTask(backgroundTask);
130            }
131    
132            /**
133            * Deletes the background task with the primary key from the database. Also notifies the appropriate model listeners.
134            *
135            * @param backgroundTaskId the primary key of the background task
136            * @return the background task that was removed
137            * @throws PortalException if a background task with the primary key could not be found
138            */
139            @Override
140            public com.liferay.portal.model.BackgroundTask deleteBackgroundTask(
141                    long backgroundTaskId)
142                    throws com.liferay.portal.kernel.exception.PortalException {
143                    return _backgroundTaskLocalService.deleteBackgroundTask(backgroundTaskId);
144            }
145    
146            @Override
147            public void deleteCompanyBackgroundTasks(long companyId)
148                    throws com.liferay.portal.kernel.exception.PortalException {
149                    _backgroundTaskLocalService.deleteCompanyBackgroundTasks(companyId);
150            }
151    
152            @Override
153            public void deleteGroupBackgroundTasks(long groupId)
154                    throws com.liferay.portal.kernel.exception.PortalException {
155                    _backgroundTaskLocalService.deleteGroupBackgroundTasks(groupId);
156            }
157    
158            /**
159            * @throws PortalException
160            */
161            @Override
162            public com.liferay.portal.model.PersistedModel deletePersistedModel(
163                    com.liferay.portal.model.PersistedModel persistedModel)
164                    throws com.liferay.portal.kernel.exception.PortalException {
165                    return _backgroundTaskLocalService.deletePersistedModel(persistedModel);
166            }
167    
168            @Override
169            public com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery() {
170                    return _backgroundTaskLocalService.dynamicQuery();
171            }
172    
173            /**
174            * Performs a dynamic query on the database and returns the matching rows.
175            *
176            * @param dynamicQuery the dynamic query
177            * @return the matching rows
178            */
179            @Override
180            public <T> java.util.List<T> dynamicQuery(
181                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) {
182                    return _backgroundTaskLocalService.dynamicQuery(dynamicQuery);
183            }
184    
185            /**
186            * Performs a dynamic query on the database and returns a range of the matching rows.
187            *
188            * <p>
189            * 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.BackgroundTaskModelImpl}. 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.
190            * </p>
191            *
192            * @param dynamicQuery the dynamic query
193            * @param start the lower bound of the range of model instances
194            * @param end the upper bound of the range of model instances (not inclusive)
195            * @return the range of matching rows
196            */
197            @Override
198            public <T> java.util.List<T> dynamicQuery(
199                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start,
200                    int end) {
201                    return _backgroundTaskLocalService.dynamicQuery(dynamicQuery, start, end);
202            }
203    
204            /**
205            * Performs a dynamic query on the database and returns an ordered range of the matching rows.
206            *
207            * <p>
208            * 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.BackgroundTaskModelImpl}. 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.
209            * </p>
210            *
211            * @param dynamicQuery the dynamic query
212            * @param start the lower bound of the range of model instances
213            * @param end the upper bound of the range of model instances (not inclusive)
214            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
215            * @return the ordered range of matching rows
216            */
217            @Override
218            public <T> java.util.List<T> dynamicQuery(
219                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start,
220                    int end,
221                    com.liferay.portal.kernel.util.OrderByComparator<T> orderByComparator) {
222                    return _backgroundTaskLocalService.dynamicQuery(dynamicQuery, start,
223                            end, orderByComparator);
224            }
225    
226            /**
227            * Returns the number of rows matching the dynamic query.
228            *
229            * @param dynamicQuery the dynamic query
230            * @return the number of rows matching the dynamic query
231            */
232            @Override
233            public long dynamicQueryCount(
234                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) {
235                    return _backgroundTaskLocalService.dynamicQueryCount(dynamicQuery);
236            }
237    
238            /**
239            * Returns the number of rows matching the dynamic query.
240            *
241            * @param dynamicQuery the dynamic query
242            * @param projection the projection to apply to the query
243            * @return the number of rows matching the dynamic query
244            */
245            @Override
246            public long dynamicQueryCount(
247                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery,
248                    com.liferay.portal.kernel.dao.orm.Projection projection) {
249                    return _backgroundTaskLocalService.dynamicQueryCount(dynamicQuery,
250                            projection);
251            }
252    
253            @Override
254            public com.liferay.portal.model.BackgroundTask fetchBackgroundTask(
255                    long backgroundTaskId) {
256                    return _backgroundTaskLocalService.fetchBackgroundTask(backgroundTaskId);
257            }
258    
259            @Override
260            public com.liferay.portal.model.BackgroundTask fetchFirstBackgroundTask(
261                    long groupId, java.lang.String taskExecutorClassName,
262                    boolean completed,
263                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.BackgroundTask> orderByComparator) {
264                    return _backgroundTaskLocalService.fetchFirstBackgroundTask(groupId,
265                            taskExecutorClassName, completed, orderByComparator);
266            }
267    
268            @Override
269            public com.liferay.portal.model.BackgroundTask fetchFirstBackgroundTask(
270                    java.lang.String taskExecutorClassName, int status) {
271                    return _backgroundTaskLocalService.fetchFirstBackgroundTask(taskExecutorClassName,
272                            status);
273            }
274    
275            @Override
276            public com.liferay.portal.model.BackgroundTask fetchFirstBackgroundTask(
277                    java.lang.String taskExecutorClassName, int status,
278                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.BackgroundTask> orderByComparator) {
279                    return _backgroundTaskLocalService.fetchFirstBackgroundTask(taskExecutorClassName,
280                            status, orderByComparator);
281            }
282    
283            @Override
284            public com.liferay.portal.kernel.dao.orm.ActionableDynamicQuery getActionableDynamicQuery() {
285                    return _backgroundTaskLocalService.getActionableDynamicQuery();
286            }
287    
288            /**
289            * Returns the background task with the primary key.
290            *
291            * @param backgroundTaskId the primary key of the background task
292            * @return the background task
293            * @throws PortalException if a background task with the primary key could not be found
294            */
295            @Override
296            public com.liferay.portal.model.BackgroundTask getBackgroundTask(
297                    long backgroundTaskId)
298                    throws com.liferay.portal.kernel.exception.PortalException {
299                    return _backgroundTaskLocalService.getBackgroundTask(backgroundTaskId);
300            }
301    
302            @Override
303            public java.lang.String getBackgroundTaskStatusJSON(long backgroundTaskId) {
304                    return _backgroundTaskLocalService.getBackgroundTaskStatusJSON(backgroundTaskId);
305            }
306    
307            @Override
308            public java.util.List<com.liferay.portal.model.BackgroundTask> getBackgroundTasks(
309                    long groupId, java.lang.String name,
310                    java.lang.String taskExecutorClassName, int start, int end,
311                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.BackgroundTask> orderByComparator) {
312                    return _backgroundTaskLocalService.getBackgroundTasks(groupId, name,
313                            taskExecutorClassName, start, end, orderByComparator);
314            }
315    
316            @Override
317            public java.util.List<com.liferay.portal.model.BackgroundTask> getBackgroundTasks(
318                    long groupId, int status) {
319                    return _backgroundTaskLocalService.getBackgroundTasks(groupId, status);
320            }
321    
322            @Override
323            public java.util.List<com.liferay.portal.model.BackgroundTask> getBackgroundTasks(
324                    long groupId, java.lang.String taskExecutorClassName) {
325                    return _backgroundTaskLocalService.getBackgroundTasks(groupId,
326                            taskExecutorClassName);
327            }
328    
329            @Override
330            public java.util.List<com.liferay.portal.model.BackgroundTask> getBackgroundTasks(
331                    long groupId, java.lang.String taskExecutorClassName, int start,
332                    int end,
333                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.BackgroundTask> orderByComparator) {
334                    return _backgroundTaskLocalService.getBackgroundTasks(groupId,
335                            taskExecutorClassName, start, end, orderByComparator);
336            }
337    
338            @Override
339            public java.util.List<com.liferay.portal.model.BackgroundTask> getBackgroundTasks(
340                    long groupId, java.lang.String taskExecutorClassName, int status) {
341                    return _backgroundTaskLocalService.getBackgroundTasks(groupId,
342                            taskExecutorClassName, status);
343            }
344    
345            @Override
346            public java.util.List<com.liferay.portal.model.BackgroundTask> getBackgroundTasks(
347                    long groupId, java.lang.String[] taskExecutorClassNames) {
348                    return _backgroundTaskLocalService.getBackgroundTasks(groupId,
349                            taskExecutorClassNames);
350            }
351    
352            @Override
353            public java.util.List<com.liferay.portal.model.BackgroundTask> getBackgroundTasks(
354                    long groupId, java.lang.String[] taskExecutorClassNames, int start,
355                    int end,
356                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.BackgroundTask> orderByComparator) {
357                    return _backgroundTaskLocalService.getBackgroundTasks(groupId,
358                            taskExecutorClassNames, start, end, orderByComparator);
359            }
360    
361            @Override
362            public java.util.List<com.liferay.portal.model.BackgroundTask> getBackgroundTasks(
363                    long groupId, java.lang.String[] taskExecutorClassNames, int status) {
364                    return _backgroundTaskLocalService.getBackgroundTasks(groupId,
365                            taskExecutorClassNames, status);
366            }
367    
368            /**
369            * Returns a range of all the background tasks.
370            *
371            * <p>
372            * 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.BackgroundTaskModelImpl}. 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.
373            * </p>
374            *
375            * @param start the lower bound of the range of background tasks
376            * @param end the upper bound of the range of background tasks (not inclusive)
377            * @return the range of background tasks
378            */
379            @Override
380            public java.util.List<com.liferay.portal.model.BackgroundTask> getBackgroundTasks(
381                    int start, int end) {
382                    return _backgroundTaskLocalService.getBackgroundTasks(start, end);
383            }
384    
385            @Override
386            public java.util.List<com.liferay.portal.model.BackgroundTask> getBackgroundTasks(
387                    java.lang.String taskExecutorClassName, int status) {
388                    return _backgroundTaskLocalService.getBackgroundTasks(taskExecutorClassName,
389                            status);
390            }
391    
392            @Override
393            public java.util.List<com.liferay.portal.model.BackgroundTask> getBackgroundTasks(
394                    java.lang.String taskExecutorClassName, int status, int start, int end,
395                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.BackgroundTask> orderByComparator) {
396                    return _backgroundTaskLocalService.getBackgroundTasks(taskExecutorClassName,
397                            status, start, end, orderByComparator);
398            }
399    
400            @Override
401            public java.util.List<com.liferay.portal.model.BackgroundTask> getBackgroundTasks(
402                    java.lang.String[] taskExecutorClassNames, int status) {
403                    return _backgroundTaskLocalService.getBackgroundTasks(taskExecutorClassNames,
404                            status);
405            }
406    
407            @Override
408            public java.util.List<com.liferay.portal.model.BackgroundTask> getBackgroundTasks(
409                    java.lang.String[] taskExecutorClassNames, int status, int start,
410                    int end,
411                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.BackgroundTask> orderByComparator) {
412                    return _backgroundTaskLocalService.getBackgroundTasks(taskExecutorClassNames,
413                            status, start, end, orderByComparator);
414            }
415    
416            /**
417            * Returns the number of background tasks.
418            *
419            * @return the number of background tasks
420            */
421            @Override
422            public int getBackgroundTasksCount() {
423                    return _backgroundTaskLocalService.getBackgroundTasksCount();
424            }
425    
426            @Override
427            public int getBackgroundTasksCount(long groupId, java.lang.String name,
428                    java.lang.String taskExecutorClassName) {
429                    return _backgroundTaskLocalService.getBackgroundTasksCount(groupId,
430                            name, taskExecutorClassName);
431            }
432    
433            @Override
434            public int getBackgroundTasksCount(long groupId, java.lang.String name,
435                    java.lang.String taskExecutorClassName, boolean completed) {
436                    return _backgroundTaskLocalService.getBackgroundTasksCount(groupId,
437                            name, taskExecutorClassName, completed);
438            }
439    
440            @Override
441            public int getBackgroundTasksCount(long groupId,
442                    java.lang.String taskExecutorClassName) {
443                    return _backgroundTaskLocalService.getBackgroundTasksCount(groupId,
444                            taskExecutorClassName);
445            }
446    
447            @Override
448            public int getBackgroundTasksCount(long groupId,
449                    java.lang.String taskExecutorClassName, boolean completed) {
450                    return _backgroundTaskLocalService.getBackgroundTasksCount(groupId,
451                            taskExecutorClassName, completed);
452            }
453    
454            @Override
455            public int getBackgroundTasksCount(long groupId,
456                    java.lang.String[] taskExecutorClassNames) {
457                    return _backgroundTaskLocalService.getBackgroundTasksCount(groupId,
458                            taskExecutorClassNames);
459            }
460    
461            @Override
462            public int getBackgroundTasksCount(long groupId,
463                    java.lang.String[] taskExecutorClassNames, boolean completed) {
464                    return _backgroundTaskLocalService.getBackgroundTasksCount(groupId,
465                            taskExecutorClassNames, completed);
466            }
467    
468            /**
469            * Returns the Spring bean ID for this bean.
470            *
471            * @return the Spring bean ID for this bean
472            */
473            @Override
474            public java.lang.String getBeanIdentifier() {
475                    return _backgroundTaskLocalService.getBeanIdentifier();
476            }
477    
478            @Override
479            public com.liferay.portal.model.PersistedModel getPersistedModel(
480                    java.io.Serializable primaryKeyObj)
481                    throws com.liferay.portal.kernel.exception.PortalException {
482                    return _backgroundTaskLocalService.getPersistedModel(primaryKeyObj);
483            }
484    
485            @Override
486            public void resumeBackgroundTask(long backgroundTaskId) {
487                    _backgroundTaskLocalService.resumeBackgroundTask(backgroundTaskId);
488            }
489    
490            /**
491            * Sets the Spring bean ID for this bean.
492            *
493            * @param beanIdentifier the Spring bean ID for this bean
494            */
495            @Override
496            public void setBeanIdentifier(java.lang.String beanIdentifier) {
497                    _backgroundTaskLocalService.setBeanIdentifier(beanIdentifier);
498            }
499    
500            @Override
501            public void triggerBackgroundTask(long backgroundTaskId) {
502                    _backgroundTaskLocalService.triggerBackgroundTask(backgroundTaskId);
503            }
504    
505            /**
506            * Updates the background task in the database or adds it if it does not yet exist. Also notifies the appropriate model listeners.
507            *
508            * @param backgroundTask the background task
509            * @return the background task that was updated
510            */
511            @Override
512            public com.liferay.portal.model.BackgroundTask updateBackgroundTask(
513                    com.liferay.portal.model.BackgroundTask backgroundTask) {
514                    return _backgroundTaskLocalService.updateBackgroundTask(backgroundTask);
515            }
516    
517            /**
518             * @deprecated As of 6.1.0, replaced by {@link #getWrappedService}
519             */
520            @Deprecated
521            public BackgroundTaskLocalService getWrappedBackgroundTaskLocalService() {
522                    return _backgroundTaskLocalService;
523            }
524    
525            /**
526             * @deprecated As of 6.1.0, replaced by {@link #setWrappedService}
527             */
528            @Deprecated
529            public void setWrappedBackgroundTaskLocalService(
530                    BackgroundTaskLocalService backgroundTaskLocalService) {
531                    _backgroundTaskLocalService = backgroundTaskLocalService;
532            }
533    
534            @Override
535            public BackgroundTaskLocalService getWrappedService() {
536                    return _backgroundTaskLocalService;
537            }
538    
539            @Override
540            public void setWrappedService(
541                    BackgroundTaskLocalService backgroundTaskLocalService) {
542                    _backgroundTaskLocalService = backgroundTaskLocalService;
543            }
544    
545            private BackgroundTaskLocalService _backgroundTaskLocalService;
546    }