-
Notifications
You must be signed in to change notification settings - Fork 9
/
ManejadorMovilizer.java
482 lines (415 loc) · 18.4 KB
/
ManejadorMovilizer.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
package Movicoders;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;
import javax.xml.datatype.DatatypeConfigurationException;
import javax.xml.datatype.DatatypeFactory;
import javax.xml.datatype.XMLGregorianCalendar;
import com.movilizer.AnswerColumnSizeType;
import com.movilizer.MoveletType;
import com.movilizer.MovilizerAnswer;
import com.movilizer.MovilizerGenericUploadDataContainer;
import com.movilizer.MovilizerMovelet;
import com.movilizer.MovilizerMoveletDelete;
import com.movilizer.MovilizerMoveletDocument;
import com.movilizer.MovilizerMoveletMasterdata;
import com.movilizer.MovilizerMoveletSet;
import com.movilizer.MovilizerParticipant;
import com.movilizer.MovilizerQuestion;
import com.movilizer.MovilizerRequest;
import com.movilizer.MovilizerResponse;
import com.movilizer.MovilizerRestriction;
import com.movilizer.MovilizerUploadDataContainer;
import com.movilizer.MovilizerValidation;
import com.movilizer.MovilizerWebServiceV15;
import com.movilizer.MovilizerWebServiceV15Service;
import com.movilizer.ValidationType;
/**
* Clase usada para generar objetos Movilizer en versión 2.5
* @author Inazio
*
*/
public class ManejadorMovilizer {
////////////////////////////
// Creación de objetos //
////////////////////////////
/**
* Genera la respuesta de realizar un callback a la nube de Movilizer
* @param solicitud MovilizerRequest a enviar
* @return MovilizerResponse capturado de la operación de callback
*/
public MovilizerResponse crearResponse(MovilizerRequest solicitud) {
MovilizerWebServiceV15Service servicio = new MovilizerWebServiceV15Service();
MovilizerWebServiceV15 puerto = servicio.getMovilizerWebServiceV15Soap11();
MovilizerResponse respuesta = puerto.movilizer(solicitud);
return respuesta;
}
/**
* Crea un request para realizar una petición al cloud de Movilizer con los parámetros básicos ya configurados
* @param systemID Atributo systemID
* @param password Atributo systemPassword
* @param numRespuestas Atributo numResponses
* @param autoKnowledge Atributo autoKnowledge
* @param respuestaSincrona Atributo syncResponse
* @param listaDeletes Lista de MovilizerMoveletDelete
* @param listaMoveletSet Lista de MovilizerMoveletSet
* @return MovilizerRequest con los parámetros básicos ya configurados
*/
public MovilizerRequest crearMovilizerRequest(Long systemID, String password, int numRespuestas, boolean autoKnowledge, boolean respuestaSincrona, List<MovilizerMoveletDelete> listaDeletes, List<MovilizerMoveletSet> listaMoveletSet) {
MovilizerRequest solicitud = new MovilizerRequest();
solicitud.setSystemId(systemID);
solicitud.setSystemPassword(password);
solicitud.setNumResponses(numRespuestas);
solicitud.setUseAutoAcknowledge(autoKnowledge);
solicitud.setSynchronousResponse(respuestaSincrona);
for (MovilizerMoveletDelete moveletDelete : listaDeletes) {
solicitud.getMoveletDelete().add(moveletDelete);
}
for (MovilizerMoveletSet moveletSet : listaMoveletSet) {
solicitud.getMoveletSet().add(moveletSet);
}
return solicitud;
}
/**
* Crear un moveletDelete con todos sus parámetros
* @param moveletKey Atributo moveletKey
* @param ignorarExtensionKey Atributo ignoreExtensionKey
* @param keyExtension Atributo moveletKeyExtension
* @return MovilizerMoveletDelete con todos sus parámetros
*/
public MovilizerMoveletDelete crearMoveletDelete(String moveletKey, boolean ignorarExtensionKey, String keyExtension) {
MovilizerMoveletDelete moveletDelete = new MovilizerMoveletDelete();
moveletDelete.setMoveletKey(moveletKey);
moveletDelete.setIgnoreExtensionKey(ignorarExtensionKey);
moveletDelete.setMoveletKeyExtension(keyExtension);
return moveletDelete;
}
/**
* Crear un moveletDelete con todos sus parámetros
* @param moveletKey Movelet a la que aplicar el moveletDelete
* @param ignorarExtensionKey Atributo ignoreExtensionKey
* @param keyExtension Atributo moveletKeyExtension
* @return MovilizerMoveletDelete con todos sus parámetros
*/
public MovilizerMoveletDelete crearMoveletDelete(MovilizerMovelet moveletKey, boolean ignorarExtensionKey, String keyExtension) {
return this.crearMoveletDelete(moveletKey.getMoveletKey(), ignorarExtensionKey, keyExtension);
}
/**
* Crea un moveletSet con todas sus movelets y participantes correspondientes
* @param movelets Listado de movelets a incluir
* @param participantes Listado de participantes a incluir
* @return MoveletSet con movelets y participantes
*/
public MovilizerMoveletSet crearMoveletSet(List<MovilizerMovelet> movelets, List<MovilizerParticipant> participantes) {
MovilizerMoveletSet moveletSet = new MovilizerMoveletSet();
for (MovilizerMovelet movelet : movelets) {
moveletSet.getMovelet().add(movelet);
}
for (MovilizerParticipant participante : participantes) {
moveletSet.getParticipant().add(participante);
}
return moveletSet;
}
/**
* Crea una movelet con todos los parámetros básicos
* @param moveletKey Atributo moveletKey
* @param nombre Atributo name
* @param questionInicial Atributo initialQuestionKey
* @param visible Atributo visible
* @param tipo Atributo type
* @param fechaValidez Atributo validTillDate
* @param icono Atributo icon
* @param espacioDeNombre Atributo namespace
* @param prioridad Atributo priority
* @return MovilizerMovelet con los parámetros básicos creados
*/
public MovilizerMovelet crearMovelet(String moveletKey, String nombre, String questionInicial, boolean visible, MoveletType tipo, String fechaValidez, int icono, String espacioDeNombre, Long prioridad) {
MovilizerMovelet movelet = new MovilizerMovelet();
movelet.setMoveletKey(moveletKey);
movelet.setName(nombre);
movelet.setPriority(prioridad);
movelet.setMoveletType(tipo);
movelet.setInitialQuestionKey(questionInicial);
movelet.setVisible(visible);
movelet.setValidTillDate(this.stringACalendarioGregoriano(fechaValidez));
movelet.setIcon(Byte.parseByte(String.valueOf(icono)));
movelet.setNamespace(espacioDeNombre);
return movelet;
}
/**
* Crea una movelet con todos los parámetros básicos
* @param moveletKey Atributo moveletKey
* @param nombre Atributo name
* @param questionInicial Question con la que inicia la movelet
* @param visible Atributo visible
* @param tipo Atributo type
* @param fechaValidez Atributo validTillDate
* @param icono Atributo icon
* @param espacioDeNombre Atributo namespace
* @param prioridad Atributo priority
* @return MovilizerMovelet con los parámetros básicos creados
*/
public MovilizerMovelet crearMovelet(String moveletKey, String nombre, MovilizerQuestion questionInicial, boolean visible, MoveletType tipo, String fechaValidez, int icono, String espacioDeNombre, Long prioridad) {
return crearMovelet(moveletKey, espacioDeNombre, questionInicial.getKey(), visible, tipo, fechaValidez, icono, espacioDeNombre, prioridad);
}
/**
* Genera un elemento que sirva para suscribir una movelet a un masterdata
* @param pool Atributo pool
* @param systemID Atributo systemId del masterdata a suscribir
* @param grupo Atributo group
* @return MovilizerMoveletMasterdata con los parámetros ya completados
*/
public MovilizerMoveletMasterdata crearSuscripcionMasterdata(String pool, Long systemID, String grupo) {
MovilizerMoveletMasterdata masterdata = new MovilizerMoveletMasterdata();
masterdata.setPool(pool);
masterdata.setSystemId(systemID);
masterdata.setGroup(grupo);
return masterdata;
}
/**
* Genera un elemento que sirva para suscribir una movelet a un document
* @param systemID Atributo systemId del masterdata a suscribir
* @param pool Atributo pool
* @return MovilizerMoveletDocument con los parámetros ya completados
*/
public MovilizerMoveletDocument crearSuscripcionDocumento(Long systemID, String pool) {
MovilizerMoveletDocument documento = new MovilizerMoveletDocument();
documento.setPool(pool);
documento.setSystemId(systemID);
return documento;
}
/**
* Devuelve una question con los parámetros básicos ya configurados
* @param key Movelet key
* @param tipo Tipo de question
* @param titulo Titulo de la cuestión
* @param backNavigationAllowed Si permite o no retroceder la pantalla
* @return MoveletQuestion con los parámetros de key, type, title y backNavigationAllowed ya rellenos
*/
public MovilizerQuestion crearQuestion(String key, int tipo, String titulo, boolean backNavigationAllowed) {
MovilizerQuestion question = new MovilizerQuestion();
question.setKey(key);
question.setType(Byte.parseByte(String.valueOf(tipo)));
question.setTitle(titulo);
question.setBackNavigationAllowed(backNavigationAllowed);
return question;
}
/**
* Devuelve una answer con los parámetros básicos ya configurados
* @param key Movelet key
* @param clientKey Client key
* @param tipo attributeType
* @param siguienteQuestion nextQuestionKey
* @param posicion Posicion de la answer
* @param dummyAnswer Si es dummy o no
* @param tipoColumna Formato de la answer al ser mostrada
* @param texto Texto predefinido de la answer
* @return MoveletAnswer con los parámetros de key, clientKey, attributeType, nextQuestionKey, position, dummyAnswer, columnSizeType y text
*/
public MovilizerAnswer crearAnswer(String key, String clientKey, int tipo, String siguienteQuestion, int posicion, boolean dummyAnswer, AnswerColumnSizeType tipoColumna, String texto) {
MovilizerAnswer answer = new MovilizerAnswer();
answer.setKey(key);
answer.setAttributeType(Byte.parseByte(String.valueOf(tipo)));
answer.setNextQuestionKey(siguienteQuestion);
answer.setClientKey(clientKey);
answer.setPosition(Short.parseShort(String.valueOf(posicion)));
answer.setDummyAnswer(dummyAnswer);
answer.setColumnSizeType(tipoColumna);
answer.setText(texto);
return answer;
}
/**
* Devuelve una answer con los parámetros básicos ya configurados
* @param key Movelet key
* @param clientKey Client key
* @param tipo attributeType
* @param siguienteQuestion MovilizerQuestion a la que apuntar
* @param posicion Posicion de la answer
* @param dummyAnswer Si es dummy o no
* @param tipoColumna Formato de la answer al ser mostrada
* @param texto Texto predefinido de la answer
* @return MovelizerAnswer con los parámetros de key, clientKey, attributeType, nextQuestionKey, position, dummyAnswer, columnSizeType y text
*/
public MovilizerAnswer crearAnswer(String key, String clientKey, int tipo, MovilizerQuestion siguienteQuestion, int posicion, boolean dummyAnswer, AnswerColumnSizeType tipoColumna, String texto) {
return this.crearAnswer(key, clientKey, tipo, siguienteQuestion.getKey(), posicion, dummyAnswer, tipoColumna, texto);
}
/**
* Devuelve una restricción con los parámetros ya configurados
* @param question Atributo nextQuestionKey
* @param posicion Atributo position
* @param condicion Atributo condition
* @param matchingAssignment Atribuot matchingAssignment
* @return MovilizerRestriction con los parámetros de nextQuestionKey, position, condition y matchingAssingment configurados con los valores pasados por parámetro
*/
public MovilizerRestriction crearRestriccion(String question, int posicion, String condicion, String matchingAssignment) {
MovilizerRestriction restriccion = new MovilizerRestriction();
restriccion.setNextQuestionKey(question);
restriccion.setPosition(Short.parseShort(String.valueOf(posicion)));
restriccion.setCondition(condicion);
restriccion.setMatchingAssignment(matchingAssignment);
return restriccion;
}
/**
* Devuelve una restricción con los parámetros ya configurados
* @param question Question a la que apuntará el nextQuestionKey
* @param posicion Atributo position
* @param condicion Atributo condition
* @param matchingAssignment Atribuot matchingAssignment
* @return MovilizerRestriction con los parámetros de nextQuestionKey, position, condition y matchingAssingment configurados con los valores pasados por parámetro
*/
public MovilizerRestriction crearRestriccion(MovilizerQuestion question, int posicion, String condicion, String matchingAssignment) {
return this.crearRestriccion(question.getKey(), posicion, condicion, matchingAssignment);
}
/**
* Devuelve una validación con los parámetros ya configurados
* @param condicion Atributo condition
* @param texto Atributo text
* @param tipo Atributo type
* @param posicion Atributo position
* @param matchingAssignment Atributo matchingAssignment
* @return MovilizerValidation con los parámetros de condition, text, type, position y matchingAssingment ya configurados con los valores pasados por parámetro
*/
public MovilizerValidation crearValidacion(String condicion, String texto, ValidationType tipo, int posicion, String matchingAssignment) {
MovilizerValidation validacion = new MovilizerValidation();
validacion.setCondition(condicion);
validacion.setText(texto);
validacion.setType(tipo);
validacion.setPosition(Short.parseShort(String.valueOf(posicion)));
validacion.setMatchingAssignment(matchingAssignment);
return validacion;
}
////////////////////////////
// Agregar elementos //
////////////////////////////
/**
* Agrega una lista de answers a una question concreta
* @param question Question a la que agregar answers
* @param lista Lista de answers que agregar
*/
public void agregarAnswersAQuestion(MovilizerQuestion question, List<MovilizerAnswer> lista) {
for (MovilizerAnswer answer : lista) {
question.getAnswer().add(answer);
}
}
/**
* Agrega una lista de restricciones a una question concreta
* @param question Question a la que agregar answers
* @param lista Lista de restricciones que agregar
*/
public void agregarRestriccionesAQuestion(MovilizerQuestion question, List<MovilizerRestriction> lista) {
for (MovilizerRestriction restriccion : lista) {
question.getRestriction().add(restriccion);
}
}
/**
* Agrega una lista de validaciones a una question concreta
* @param question Question a la que agregar answers
* @param lista Lista de validaciones que agregar
*/
public void agregarValidacionesAQuestion(MovilizerQuestion question, List<MovilizerValidation> lista) {
for (MovilizerValidation validacion : lista) {
question.getValidation().add(validacion);
}
}
/**
* Agrega una lista de questions a una movelet concreta
* @param movelet Movelet a la que agregar las questions
* @param lista Lista de questions que agregar
*/
public void agregarQuestionsAMovelet(MovilizerMovelet movelet, List<MovilizerQuestion> lista) {
for (MovilizerQuestion question : lista) {
movelet.getQuestion().add(question);
}
}
/**
* Agrega una lista de masterdatas a una movelet
* @param movelet Movelet a la que agregar MD
* @param lista Lista de masterdatas a agregar
*/
public void agregarMasterdataAMovelet(MovilizerMovelet movelet, List<MovilizerMoveletMasterdata> lista) {
for (MovilizerMoveletMasterdata masterdata : lista) {
movelet.getMasterdata().add(masterdata);
}
}
/**
* Agrega una lista de documents a una movelet
* @param movelet Movelet a la que agregar documentos
* @param lista Lista de documentos a agregar
*/
public void agregarDocumentoAMovelet(MovilizerMovelet movelet, List<MovilizerMoveletDocument> lista) {
for (MovilizerMoveletDocument documento : lista) {
movelet.getDocument().add(documento);
}
}
////////////////////////////
// Lectura de DC //
////////////////////////////
/**
* Devuelve todos los datacontainer que pertenezcan a una moveletKey en concreto
* @param respuesta Respuesta movilizer que analizar
* @param moveletKey Clave de la movelet desde la que se mandaron los DataContainer
* @return Lista de datacontainer
*/
public List<MovilizerGenericUploadDataContainer> leerDatacontainersDesdeMovelet(MovilizerResponse respuesta, String moveletKey) {
List<MovilizerGenericUploadDataContainer> contenedores = new ArrayList<MovilizerGenericUploadDataContainer>();
for (MovilizerUploadDataContainer mud : respuesta.getUploadContainer()) {
if (mud.getContainer().getMoveletKey().equals(moveletKey)) {
contenedores.add(mud.getContainer());
}
}
return contenedores;
}
/**
* Devuelve todos los datacontainer que su clave sea exactamente como la pasada por parámetro
* @param respuesta Respuesta movilizer que analizar
* @param claveDatacontainer Clave del datacontainer
* @return Lista de datacontainer
*/
public List<MovilizerGenericUploadDataContainer> leerDatacontainersConClaveDatacontainerExacta(MovilizerResponse respuesta, String claveDatacontainer) {
List<MovilizerGenericUploadDataContainer> contenedores = new ArrayList<MovilizerGenericUploadDataContainer>();
for (MovilizerUploadDataContainer mud : respuesta.getUploadContainer()) {
if (mud.getContainer().getKey().equals(claveDatacontainer)) {
contenedores.add(mud.getContainer());
}
}
return contenedores;
}
/**
* Devuelve todos los datacontainer que su clave empiece como la pasada por parámetro
* @param respuesta Respuesta movilizer que analizar
* @param claveDatacontainer Clave del datacontainer
* @return Lista de datacontainer
*/
public List<MovilizerGenericUploadDataContainer> leerDatacontainersConClaveDatacontainerInicio(MovilizerResponse respuesta, String claveDatacontainer) {
List<MovilizerGenericUploadDataContainer> contenedores = new ArrayList<MovilizerGenericUploadDataContainer>();
for (MovilizerUploadDataContainer mud : respuesta.getUploadContainer()) {
if (mud.getContainer().getKey().startsWith(claveDatacontainer)) {
contenedores.add(mud.getContainer());
}
}
return contenedores;
}
////////////////////////////
// Útiles varios //
////////////////////////////
/**
* Convierte una fecha en String a un XMLGregorianCalendar con formato yyyy-MM-ddThh:mm:ss.000+00:00
* @param fecha String con formato yyyy-MM-ddThh:mm:ss.000+00:00
* @return Fecha parseada a XMLGregorianCalendar con formato yyyy-MM-ddThh:mm:ss.000+00:00
*/
private XMLGregorianCalendar stringACalendarioGregoriano(String fecha) {
try {
DateFormat formato = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
Date fechaParseada = formato.parse(fecha);
GregorianCalendar calendario = new GregorianCalendar();
calendario.setTime(fechaParseada);
return DatatypeFactory.newInstance().newXMLGregorianCalendar(calendario);
} catch (ParseException | DatatypeConfigurationException e) {
return null;
}
}
}