001
014
015 package com.liferay.portal.kernel.backgroundtask;
016
017 import com.liferay.portal.kernel.exception.PortalException;
018 import com.liferay.portal.kernel.util.OrderByComparator;
019 import com.liferay.portal.kernel.util.ProxyFactory;
020 import com.liferay.portal.service.ServiceContext;
021
022 import java.io.File;
023 import java.io.Serializable;
024
025 import java.util.List;
026 import java.util.Map;
027
028
031 public class BackgroundTaskManagerUtil {
032
033 public static BackgroundTask addBackgroundTask(
034 long userId, long groupId, String name,
035 String taskExecutorClassName,
036 Map<String, Serializable> taskContextMap,
037 ServiceContext serviceContext)
038 throws PortalException {
039
040 return _backgroundTaskManager.addBackgroundTask(
041 userId, groupId, name, taskExecutorClassName, taskContextMap,
042 serviceContext);
043 }
044
045 public static BackgroundTask addBackgroundTask(
046 long userId, long groupId, String name,
047 String[] servletContextNames, Class<?> taskExecutorClass,
048 Map<String, Serializable> taskContextMap,
049 ServiceContext serviceContext)
050 throws PortalException {
051
052 return _backgroundTaskManager.addBackgroundTask(
053 userId, groupId, name, servletContextNames, taskExecutorClass,
054 taskContextMap, serviceContext);
055 }
056
057 public static void addBackgroundTaskAttachment(
058 long userId, long backgroundTaskId, String fileName, File file)
059 throws PortalException {
060
061 _backgroundTaskManager.addBackgroundTaskAttachment(
062 userId, backgroundTaskId, fileName, file);
063 }
064
065 public static BackgroundTask amendBackgroundTask(
066 long backgroundTaskId, Map<String, Serializable> taskContextMap,
067 int status, ServiceContext serviceContext) {
068
069 return _backgroundTaskManager.amendBackgroundTask(
070 backgroundTaskId, taskContextMap, status, serviceContext);
071 }
072
073 public static BackgroundTask amendBackgroundTask(
074 long backgroundTaskId, Map<String, Serializable> taskContextMap,
075 int status, String statusMessage, ServiceContext serviceContext) {
076
077 return _backgroundTaskManager.amendBackgroundTask(
078 backgroundTaskId, taskContextMap, status, statusMessage,
079 serviceContext);
080 }
081
082 public static void cleanUpBackgroundTask(
083 BackgroundTask backgroundTask, int status) {
084
085 _backgroundTaskManager.cleanUpBackgroundTask(backgroundTask, status);
086 }
087
088 public static void cleanUpBackgroundTasks() {
089 _backgroundTaskManager.cleanUpBackgroundTasks();
090 }
091
092 public static BackgroundTask deleteBackgroundTask(long backgroundTaskId)
093 throws PortalException {
094
095 return _backgroundTaskManager.deleteBackgroundTask(backgroundTaskId);
096 }
097
098 public static void deleteCompanyBackgroundTasks(long companyId)
099 throws PortalException {
100
101 _backgroundTaskManager.deleteCompanyBackgroundTasks(companyId);
102 }
103
104 public static void deleteGroupBackgroundTasks(long groupId)
105 throws PortalException {
106
107 _backgroundTaskManager.deleteGroupBackgroundTasks(groupId);
108 }
109
110 public static BackgroundTask fetchBackgroundTask(long backgroundTaskId) {
111 return _backgroundTaskManager.fetchBackgroundTask(backgroundTaskId);
112 }
113
114 public static BackgroundTask fetchFirstBackgroundTask(
115 long groupId, String taskExecutorClassName, boolean completed,
116 OrderByComparator<BackgroundTask> orderByComparator) {
117
118 return _backgroundTaskManager.fetchFirstBackgroundTask(
119 groupId, taskExecutorClassName, completed, orderByComparator);
120 }
121
122 public static BackgroundTask fetchFirstBackgroundTask(
123 String taskExecutorClassName, int status) {
124
125 return _backgroundTaskManager.fetchFirstBackgroundTask(
126 taskExecutorClassName, status);
127 }
128
129 public static BackgroundTask fetchFirstBackgroundTask(
130 String taskExecutorClassName, int status,
131 OrderByComparator<BackgroundTask> orderByComparator) {
132
133 return _backgroundTaskManager.fetchFirstBackgroundTask(
134 taskExecutorClassName, status, orderByComparator);
135 }
136
137 public static BackgroundTask getBackgroundTask(long backgroundTaskId)
138 throws PortalException {
139
140 return _backgroundTaskManager.getBackgroundTask(backgroundTaskId);
141 }
142
143 public static List<BackgroundTask>
144 getBackgroundTasks(long groupId, int status) {
145
146 return _backgroundTaskManager.getBackgroundTasks(groupId, status);
147 }
148
149 public static List<BackgroundTask> getBackgroundTasks(
150 long groupId, String taskExecutorClassName) {
151
152 return _backgroundTaskManager.getBackgroundTasks(
153 groupId, taskExecutorClassName);
154 }
155
156 public static List<BackgroundTask> getBackgroundTasks(
157 long groupId, String taskExecutorClassName, int status) {
158
159 return _backgroundTaskManager.getBackgroundTasks(
160 groupId, taskExecutorClassName, status);
161 }
162
163 public static List<BackgroundTask> getBackgroundTasks(
164 long groupId, String taskExecutorClassName, int start, int end,
165 OrderByComparator<BackgroundTask> orderByComparator) {
166
167 return _backgroundTaskManager.getBackgroundTasks(
168 groupId, taskExecutorClassName, start, end, orderByComparator);
169 }
170
171 public static List<BackgroundTask> getBackgroundTasks(
172 long groupId, String name, String taskExecutorClassName, int start,
173 int end, OrderByComparator<BackgroundTask> orderByComparator) {
174
175 return _backgroundTaskManager.getBackgroundTasks(
176 groupId, name, taskExecutorClassName, start, end,
177 orderByComparator);
178 }
179
180 public static List<BackgroundTask> getBackgroundTasks(
181 long groupId, String[] taskExecutorClassNames) {
182
183 return _backgroundTaskManager.getBackgroundTasks(
184 groupId, taskExecutorClassNames);
185 }
186
187 public static List<BackgroundTask> getBackgroundTasks(
188 long groupId, String[] taskExecutorClassNames, int status) {
189
190 return _backgroundTaskManager.getBackgroundTasks(
191 groupId, taskExecutorClassNames, status);
192 }
193
194 public static List<BackgroundTask> getBackgroundTasks(
195 long groupId, String[] taskExecutorClassNames, int start, int end,
196 OrderByComparator<BackgroundTask> orderByComparator) {
197
198 return _backgroundTaskManager.getBackgroundTasks(
199 groupId, taskExecutorClassNames, start, end, orderByComparator);
200 }
201
202 public static List<BackgroundTask> getBackgroundTasks(
203 String taskExecutorClassName, int status) {
204
205 return _backgroundTaskManager.getBackgroundTasks(
206 taskExecutorClassName, status);
207 }
208
209 public static List<BackgroundTask> getBackgroundTasks(
210 String taskExecutorClassName, int status, int start, int end,
211 OrderByComparator<BackgroundTask> orderByComparator) {
212
213 return _backgroundTaskManager.getBackgroundTasks(
214 taskExecutorClassName, status, start, end, orderByComparator);
215 }
216
217 public static List<BackgroundTask> getBackgroundTasks(
218 String[] taskExecutorClassNames, int status) {
219
220 return _backgroundTaskManager.getBackgroundTasks(
221 taskExecutorClassNames, status);
222 }
223
224 public static List<BackgroundTask> getBackgroundTasks(
225 String[] taskExecutorClassNames, int status, int start, int end,
226 OrderByComparator<BackgroundTask> orderByComparator) {
227
228 return _backgroundTaskManager.getBackgroundTasks(
229 taskExecutorClassNames, status, start, end, orderByComparator);
230 }
231
232 public static int getBackgroundTasksCount(
233 long groupId, String taskExecutorClassName) {
234
235 return _backgroundTaskManager.getBackgroundTasksCount(
236 groupId, taskExecutorClassName);
237 }
238
239 public static int getBackgroundTasksCount(
240 long groupId, String taskExecutorClassName, boolean completed) {
241
242 return _backgroundTaskManager.getBackgroundTasksCount(
243 groupId, taskExecutorClassName, completed);
244 }
245
246 public static int getBackgroundTasksCount(
247 long groupId, String name, String taskExecutorClassName) {
248
249 return _backgroundTaskManager.getBackgroundTasksCount(
250 groupId, name, taskExecutorClassName);
251 }
252
253 public static int getBackgroundTasksCount(
254 long groupId, String name, String taskExecutorClassName,
255 boolean completed) {
256
257 return _backgroundTaskManager.getBackgroundTasksCount(
258 groupId, name, taskExecutorClassName, completed);
259 }
260
261 public static int getBackgroundTasksCount(
262 long groupId, String[] taskExecutorClassNames) {
263
264 return _backgroundTaskManager.getBackgroundTasksCount(
265 groupId, taskExecutorClassNames);
266 }
267
268 public static int getBackgroundTasksCount(
269 long groupId, String[] taskExecutorClassNames, boolean completed) {
270
271 return _backgroundTaskManager.getBackgroundTasksCount(
272 groupId, taskExecutorClassNames, completed);
273 }
274
275 public static String getBackgroundTaskStatusJSON(long backgroundTaskId) {
276 return _backgroundTaskManager.getBackgroundTaskStatusJSON(
277 backgroundTaskId);
278 }
279
280 public static void resumeBackgroundTask(long backgroundTaskId) {
281 _backgroundTaskManager.resumeBackgroundTask(backgroundTaskId);
282 }
283
284 public static void triggerBackgroundTask(long backgroundTaskId) {
285 _backgroundTaskManager.triggerBackgroundTask(backgroundTaskId);
286 }
287
288 private static final BackgroundTaskManager
289 _backgroundTaskManager = ProxyFactory.newServiceTrackedInstance(
290 BackgroundTaskManager.class);
291
292 }