1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.syncope.core.persistence.jpa.entity.task;
20
21 import org.apache.syncope.common.lib.to.MacroTaskTO;
22 import org.apache.syncope.common.lib.to.NotificationTaskTO;
23 import org.apache.syncope.common.lib.to.PropagationTaskTO;
24 import org.apache.syncope.common.lib.to.PullTaskTO;
25 import org.apache.syncope.common.lib.to.PushTaskTO;
26 import org.apache.syncope.common.lib.to.SchedTaskTO;
27 import org.apache.syncope.common.lib.to.TaskTO;
28 import org.apache.syncope.common.lib.types.TaskType;
29 import org.apache.syncope.core.persistence.api.entity.task.MacroTask;
30 import org.apache.syncope.core.persistence.api.entity.task.NotificationTask;
31 import org.apache.syncope.core.persistence.api.entity.task.PropagationTask;
32 import org.apache.syncope.core.persistence.api.entity.task.PullTask;
33 import org.apache.syncope.core.persistence.api.entity.task.PushTask;
34 import org.apache.syncope.core.persistence.api.entity.task.SchedTask;
35 import org.apache.syncope.core.persistence.api.entity.task.Task;
36 import org.apache.syncope.core.persistence.api.entity.task.TaskExec;
37 import org.apache.syncope.core.persistence.api.entity.task.TaskUtils;
38 import org.apache.syncope.core.spring.security.SecureRandomUtils;
39
40 @SuppressWarnings("unchecked")
41 public final class JPATaskUtils implements TaskUtils {
42
43 protected final TaskType type;
44
45 protected JPATaskUtils(final TaskType type) {
46 this.type = type;
47 }
48
49 @Override
50 public TaskType getType() {
51 return type;
52 }
53
54 @Override
55 public <T extends Task<T>> Class<T> taskClass() {
56 Class<T> result = null;
57
58 switch (type) {
59 case PROPAGATION:
60 result = (Class<T>) PropagationTask.class;
61 break;
62
63 case SCHEDULED:
64 result = (Class<T>) SchedTask.class;
65 break;
66
67 case PULL:
68 result = (Class<T>) PullTask.class;
69 break;
70
71 case PUSH:
72 result = (Class<T>) PushTask.class;
73 break;
74
75 case MACRO:
76 result = (Class<T>) MacroTask.class;
77 break;
78
79 case NOTIFICATION:
80 result = (Class<T>) NotificationTask.class;
81 break;
82
83 default:
84 }
85
86 return result;
87 }
88
89 @Override
90 public <T extends Task<T>> T newTask() {
91 T result = null;
92
93 switch (type) {
94 case PROPAGATION:
95 result = (T) new JPAPropagationTask();
96 break;
97
98 case SCHEDULED:
99 result = (T) new JPASchedTask();
100 break;
101
102 case PULL:
103 result = (T) new JPAPullTask();
104 break;
105
106 case PUSH:
107 result = (T) new JPAPushTask();
108 break;
109
110 case MACRO:
111 result = (T) new JPAMacroTask();
112 break;
113
114 case NOTIFICATION:
115 result = (T) new JPANotificationTask();
116 break;
117
118 default:
119 }
120
121 if (result != null) {
122 ((AbstractTask<?>) result).setKey(SecureRandomUtils.generateRandomUUID().toString());
123 }
124
125 return result;
126 }
127
128 @Override
129 public <E extends TaskExec<?>> E newTaskExec() {
130 E result;
131
132 switch (type) {
133 case NOTIFICATION:
134 result = (E) new JPANotificationTaskExec();
135 break;
136
137 case PROPAGATION:
138 result = (E) new JPAPropagationTaskExec();
139 break;
140
141 case PULL:
142 result = (E) new JPAPullTaskExec();
143 break;
144
145 case PUSH:
146 result = (E) new JPAPushTaskExec();
147 break;
148
149 case MACRO:
150 result = (E) new JPAMacroTaskExec();
151 break;
152
153 case SCHEDULED:
154 result = (E) new JPASchedTaskExec();
155 break;
156
157 default:
158 result = null;
159 }
160
161 if (result != null) {
162 ((AbstractTaskExec<?>) result).setKey(SecureRandomUtils.generateRandomUUID().toString());
163 }
164
165 return result;
166 }
167
168 @Override
169 public <T extends TaskTO> Class<T> taskTOClass() {
170 Class<T> result = null;
171
172 switch (type) {
173 case PROPAGATION:
174 result = (Class<T>) PropagationTaskTO.class;
175 break;
176
177 case SCHEDULED:
178 result = (Class<T>) SchedTaskTO.class;
179 break;
180
181 case PULL:
182 result = (Class<T>) PullTaskTO.class;
183 break;
184
185 case PUSH:
186 result = (Class<T>) PushTaskTO.class;
187 break;
188
189 case MACRO:
190 result = (Class<T>) MacroTaskTO.class;
191 break;
192
193 case NOTIFICATION:
194 result = (Class<T>) NotificationTaskTO.class;
195 break;
196
197 default:
198 }
199
200 return result;
201 }
202
203 @Override
204 public <T extends TaskTO> T newTaskTO() {
205 Class<T> taskClass = taskTOClass();
206 try {
207 return taskClass == null ? null : taskClass.getDeclaredConstructor().newInstance();
208 } catch (Exception e) {
209 return null;
210 }
211 }
212
213 @Override
214 public String getTaskTable() {
215 String result = null;
216
217 switch (type) {
218 case NOTIFICATION:
219 result = JPANotificationTask.TABLE;
220 break;
221
222 case PROPAGATION:
223 result = JPAPropagationTask.TABLE;
224 break;
225
226 case PUSH:
227 result = JPAPushTask.TABLE;
228 break;
229
230 case PULL:
231 result = JPAPullTask.TABLE;
232 break;
233
234 case MACRO:
235 result = JPAMacroTask.TABLE;
236 break;
237
238 case SCHEDULED:
239 result = JPASchedTask.TABLE;
240 break;
241
242 default:
243 }
244
245 return result;
246 }
247
248 @Override
249 public Class<? extends Task<?>> getTaskEntity() {
250 Class<? extends Task<?>> result = null;
251
252 switch (type) {
253 case NOTIFICATION:
254 result = JPANotificationTask.class;
255 break;
256
257 case PROPAGATION:
258 result = JPAPropagationTask.class;
259 break;
260
261 case PUSH:
262 result = JPAPushTask.class;
263 break;
264
265 case PULL:
266 result = JPAPullTask.class;
267 break;
268
269 case MACRO:
270 result = JPAMacroTask.class;
271 break;
272
273 case SCHEDULED:
274 result = JPASchedTask.class;
275 break;
276
277 default:
278 }
279
280 return result;
281 }
282
283 @Override
284 public String getTaskExecTable() {
285 String result = null;
286
287 switch (type) {
288 case NOTIFICATION:
289 result = JPANotificationTaskExec.TABLE;
290 break;
291
292 case PROPAGATION:
293 result = JPAPropagationTaskExec.TABLE;
294 break;
295
296 case SCHEDULED:
297 result = JPASchedTaskExec.TABLE;
298 break;
299
300 case PUSH:
301 result = JPAPushTaskExec.TABLE;
302 break;
303
304 case PULL:
305 result = JPAPullTaskExec.TABLE;
306 break;
307
308 case MACRO:
309 result = JPAMacroTaskExec.TABLE;
310 break;
311
312 default:
313 }
314
315 return result;
316 }
317
318 @Override
319 public Class<? extends TaskExec<?>> getTaskExecEntity() {
320 Class<? extends TaskExec<?>> result = null;
321
322 switch (type) {
323 case NOTIFICATION:
324 result = JPANotificationTaskExec.class;
325 break;
326
327 case PROPAGATION:
328 result = JPAPropagationTaskExec.class;
329 break;
330
331 case SCHEDULED:
332 result = JPASchedTaskExec.class;
333 break;
334
335 case PUSH:
336 result = JPAPushTaskExec.class;
337 break;
338
339 case PULL:
340 result = JPAPullTaskExec.class;
341 break;
342
343 case MACRO:
344 result = JPAMacroTaskExec.class;
345 break;
346
347 default:
348 }
349
350 return result;
351 }
352 }