PageRenderTime 78ms CodeModel.GetById 15ms app.highlight 57ms RepoModel.GetById 0ms app.codeStats 1ms

/fap/app/controllers/PaginaVerificacionController.java

https://github.com/FAP-Team/Fap-Module
Java | 957 lines | 750 code | 136 blank | 71 comment | 162 complexity | 42dcb7e384d938cabc272cf357b7a960 MD5 | raw file
  1package controllers;
  2
  3import java.io.File;
  4import java.io.FileInputStream;
  5import java.io.InputStream;
  6import java.util.ArrayList;
  7import java.util.Collections;
  8import java.util.Comparator;
  9import java.util.HashMap;
 10import java.util.List;
 11import java.util.Map;
 12
 13import javax.inject.Inject;
 14import javax.persistence.EntityTransaction;
 15
 16import reports.Report;
 17import services.FirmaService;
 18import services.GestorDocumentalService;
 19import services.GestorDocumentalServiceException;
 20import services.NotificacionService;
 21import services.RegistroService;
 22import services.filesystem.TipoDocumentoEnTramite;
 23
 24import org.joda.time.DateTime;
 25
 26import platino.FirmaUtils;
 27import play.Play;
 28import play.db.jpa.JPA;
 29import play.mvc.Util;
 30import properties.FapProperties;
 31import tags.ComboItem;
 32import utils.CalcularFirmantes;
 33import utils.ComboUtils;
 34import utils.NotificacionUtils;
 35import validation.CustomValidation;
 36import verificacion.VerificacionUtils;
 37import messages.Messages;
 38import models.Agente;
 39import models.Documento;
 40import models.DocumentoNotificacion;
 41import models.Firma;
 42import models.Firmante;
 43import models.Firmantes;
 44import models.Notificacion;
 45import models.Requerimiento;
 46import models.SolicitudGenerica;
 47import models.TableKeyValue;
 48import models.TipoDocumento;
 49import models.Tramite;
 50import models.TramitesVerificables;
 51import models.Verificacion;
 52import models.VerificacionDocumento;
 53import models.VerificacionTramites;
 54import controllers.fap.AgenteController;
 55import controllers.fap.VerificacionFapController;
 56import controllers.gen.PaginaVerificacionControllerGen;
 57import emails.Mails;
 58import enumerado.fap.gen.EstadoNotificacionEnum;
 59import enumerado.fap.gen.EstadosDocumentoVerificacionEnum;
 60import enumerado.fap.gen.EstadosSolicitudEnum;
 61import enumerado.fap.gen.EstadosVerificacionEnum;
 62import es.gobcan.eadmon.verificacion.ws.dominio.DocumentoVerificacion;
 63import es.gobcan.aciisi.servicios.enotificacion.notificacion.NotificacionException;
 64import es.gobcan.platino.servicios.registro.Documentos;
 65
 66public class PaginaVerificacionController extends PaginaVerificacionControllerGen {
 67	
 68    @Inject
 69    static FirmaService firmaService;
 70
 71    @Inject
 72    static RegistroService registroService;
 73    
 74    @Inject
 75    static NotificacionService notificacionService;
 76    
 77	@Inject
 78	static GestorDocumentalService gestorDocumentalService;
 79	
 80	public static void index(String accion, Long idSolicitud, Long idVerificacion) {
 81		if (accion == null)
 82			accion = getAccion();
 83		if (!permiso(accion)) {
 84			Messages.fatal("No tiene suficientes privilegios para acceder a esta solicitud");
 85			renderTemplate("gen/PaginaVerificacion/PaginaVerificacion.html");
 86		}
 87		
 88		SolicitudGenerica solicitud = PaginaVerificacionController.getSolicitudGenerica(idSolicitud);
 89
 90		Verificacion verificacion = null;
 91		if ("crear".equals(accion))
 92			verificacion = PaginaVerificacionController.getVerificacion();
 93		else if (!"borrado".equals(accion))
 94			verificacion = PaginaVerificacionController.getVerificacion(idSolicitud, idVerificacion);
 95
 96        if ((solicitud != null) && (solicitud.verificacion != null) && (solicitud.verificacion.estado != null)){
 97        	log.info("Visitando página: " + "gen/PaginaVerificacion/PaginaVerificacion.html");
 98        	if ((verificacion.uriTramite == null) || (verificacion.uriTramite.isEmpty())){
 99        		VerificacionTramites vTramites = VerificacionTramites.get(VerificacionTramites.class);
100        		if ((vTramites.uriTramitePorDefecto != null) && (!vTramites.uriTramitePorDefecto.isEmpty()))
101        			verificacion.uriTramite=vTramites.uriTramitePorDefecto;
102        	}
103        	renderTemplate("gen/PaginaVerificacion/PaginaVerificacion.html", accion, idSolicitud, idVerificacion, solicitud, verificacion);
104        } else
105        	redirect("AccesoVerificacionesController.index", accion, idSolicitud);
106		
107	}
108	
109	//Métodos en el controlador manual
110	public static List<ComboItem> getTramitesCombo () {
111		List<ComboItem> result = new ArrayList<ComboItem>();
112		VerificacionTramites vTramites = VerificacionTramites.get(VerificacionTramites.class);
113		for (TramitesVerificables t: vTramites.tramites) {
114			if (t.verificable)
115				result.add(new ComboItem(t.uriTramite, t.nombre));
116		}
117		return result;
118	}
119	
120	public static void iniciarVerificacion(Long idSolicitud, Long idVerificacion, Verificacion verificacion, String botonIniciarVerificacion) {
121		checkAuthenticity();
122		if (!permisoIniciarVerificacion("editar")) {
123			Messages.error("No tiene permisos suficientes para realizar la acción");
124		}
125		Verificacion dbVerificacion = PaginaVerificacionController.getVerificacion(idSolicitud, idVerificacion);
126
127		PaginaVerificacionController.iniciarVerificacionBindReferences(verificacion);
128		
129		if (!Messages.hasErrors()) {
130			//dbVerificacion.uriTramite = verificacion.tramiteNombre.uri;
131			PaginaVerificacionController.iniciarVerificacionValidateCopy("editar", dbVerificacion, verificacion);
132		}
133
134		if (!Messages.hasErrors()) {
135			PaginaVerificacionController.iniciarVerificacionValidateRules(dbVerificacion, verificacion);
136		}
137		if (!Messages.hasErrors()) {
138			dbVerificacion.estado = EstadosVerificacionEnum.verificandoTipos.name();
139			dbVerificacion.fechaUltimaActualizacion = new DateTime();
140			dbVerificacion.verificacionTiposDocumentos = VerificacionUtils.existDocumentosNuevos(dbVerificacion, idSolicitud);
141			//SolicitudGenerica dbSolicitud = getSolicitudGenerica(idSolicitud);
142			//dbSolicitud.estado = EstadosSolicitudEnum.enVerificacion.name();
143			dbVerificacion.save();
144			//dbSolicitud.save();
145			log.info("Acción sobre iniciar verificacion de página: " + "gen/PaginaVerificacion/PaginaVerificacion.html" + " , intentada con éxito");
146		} else
147			log.info("Acción sobre iniciar verificacion de página: " + "gen/PaginaVerificacion/PaginaVerificacion.html" + " , intentada sin éxito (Problemas de Validación)");
148		PaginaVerificacionController.iniciarVerificacionRender(idSolicitud, idVerificacion);
149	}
150	
151	public static void tablaverificacionTipos(Long idSolicitud) {
152
153		java.util.List<Documento> rows = Documento.find("select documento from SolicitudGenerica solicitud join solicitud.verificacion.verificacionTiposDocumentos documento where solicitud.id=? and (documento.verificado is null or documento.verificado = false)",idSolicitud).fetch();
154
155		Map<String, Long> ids = (Map<String, Long>) tags.TagMapStack.top("idParams");
156		List<Documento> rowsFiltered = rows; //Tabla sin permisos, no filtra
157
158		tables.TableRenderResponse<Documento> response = new tables.TableRenderResponse<Documento>(rowsFiltered, false, false, false, "", "", "", getAccion(), ids);
159
160		renderJSON(response.toJSON("fechaSubida", "fechaRegistro", "tipo", "descripcionVisible", "verificado", "urlDescarga", "id"));
161	}
162	
163	public static void verificaTipos(Long idSolicitud, Long idVerificacion, String finalizaVerificarTipos) {
164		checkAuthenticity();
165		if (!permisoVerificaTipos("editar")) {
166			Messages.error("No tiene permisos suficientes para realizar la acción");
167		}
168
169		if (!Messages.hasErrors()) {
170			PaginaVerificacionController.verificaTiposValidateRules();
171		}
172		if (!Messages.hasErrors()) {
173			SolicitudGenerica dbSolicitud = getSolicitudGenerica(idSolicitud);
174			
175			try {
176				dbSolicitud.verificacion.documentos = VerificacionUtils.getVerificacionDocumentosFromNewDocumentos((List<Documento>)VerificacionFapController.invoke(VerificacionFapController.class, "getNuevosDocumentosVerificar", dbSolicitud.verificacion.id, idSolicitud), dbSolicitud.verificacion.uriTramite, dbSolicitud.verificaciones, idSolicitud);
177			} catch (Throwable e) {
178				play.Logger.error("Error recuperando los documentos nuevos a verificar", e.getMessage());
179			}
180
181			dbSolicitud.verificacion.estado = EstadosVerificacionEnum.obtenerNoProcede.name();
182			dbSolicitud.verificacion.nuevosDocumentos.clear();
183			dbSolicitud.verificacion.verificacionTiposDocumentos.clear();
184			dbSolicitud.verificacion.fechaUltimaActualizacion = new DateTime();
185			dbSolicitud.save();
186			Messages.ok("Finaliza la verificación de tipos");
187			log.info("Acción verificacion de tipos de página: " + "gen/PaginaVerificacion/PaginaVerificacion.html" + " , intentada con éxito");
188		} else
189			log.info("Acción verificacion de tipos de página: " + "gen/PaginaVerificacion/PaginaVerificacion.html" + " , intentada sin éxito (Problemas de Validación)");
190		PaginaVerificacionController.verificaTiposRender(idSolicitud, idVerificacion);
191	}
192	
193	public static void verificaTiposNuevosDoc(Long idSolicitud, Long idVerificacion, String finalizaVerificarTipos) {
194		checkAuthenticity();
195		if (!permisoVerificaTiposNuevosDoc("editar")) {
196			Messages.error("No tiene permisos suficientes para realizar la acción");
197		}
198		if (!Messages.hasErrors()) {
199			PaginaVerificacionController.verificaTiposNuevosDocValidateRules();
200		}
201		if (!Messages.hasErrors()) {
202			SolicitudGenerica dbSolicitud = getSolicitudGenerica(idSolicitud);
203			for (Documento doc: dbSolicitud.verificacion.nuevosDocumentos){
204				VerificacionDocumento vDoc= new VerificacionDocumento(doc);
205				TipoDocumento tipo = TipoDocumento.find("select tipo from TipoDocumento tipo where tipo.tramitePertenece=? and tipo.uri=?", dbSolicitud.verificacion.uriTramite, doc.tipo).first();
206				if (tipo != null)
207					vDoc.identificadorMultiple = tipo.cardinalidad;
208				else
209					log.error("Tipo no encontrado al verificar los tipos de documentos nuevos: "+doc.tipo);
210				vDoc.existe = true;
211				vDoc.estadoDocumentoVerificacion = EstadosDocumentoVerificacionEnum.noVerificado.name();
212				vDoc.save();
213				dbSolicitud.verificacion.documentos.add(vDoc);
214			}
215			
216			/// Si existen verificaciones anteriores el estado al que pasa es "obtenerNoProcede",
217			/// en caso contrario a "enVerificacion"
218			if (dbSolicitud.verificaciones.size() > 0)
219				dbSolicitud.verificacion.estado = EstadosVerificacionEnum.obtenerNoProcede.name();
220			else
221				dbSolicitud.verificacion.estado = EstadosVerificacionEnum.enVerificacion.name();
222			dbSolicitud.verificacion.nuevosDocumentos.clear();
223			dbSolicitud.verificacion.verificacionTiposDocumentos.clear();
224			dbSolicitud.verificacion.fechaUltimaActualizacion = new DateTime();
225			dbSolicitud.save();
226			log.info("Acción sobre verificacion de tipos de nuevos documentos de página: " + "gen/PaginaVerificacion/PaginaVerificacion.html" + " , intentada con éxito");
227		} else
228			log.info("Acción sobre verificacion de tipos de nuevos documentos de página: " + "gen/PaginaVerificacion/PaginaVerificacion.html" + " , intentada sin éxito (Problemas de Validación)");
229		PaginaVerificacionController.verificaTiposNuevosDocRender(idSolicitud, idVerificacion);
230	}
231	
232	public static void nuevosDocumentos(Long idSolicitud, Long idVerificacion, String adjuntarNuevosDocumentos) {
233		checkAuthenticity();
234		if (!permisoNuevosDocumentos("editar")) {
235			Messages.error("No tiene permisos suficientes para realizar la acción");
236		}
237		if (!Messages.hasErrors()) {
238			PaginaVerificacionController.nuevosDocumentosValidateRules();
239		}
240		if (!Messages.hasErrors()) {
241			SolicitudGenerica dbSolicitud = getSolicitudGenerica(idSolicitud);
242			List<Documento> documentosNuevos = VerificacionUtils.existDocumentosNuevos(dbSolicitud.verificacion, idSolicitud);
243			// Compruebo que no existen documentos nuevos aportados por el solicitante y que no esten incluidos en la verificacion actual
244			if (!documentosNuevos.isEmpty()){
245				dbSolicitud.verificacion.nuevosDocumentos.addAll(documentosNuevos);
246				dbSolicitud.verificacion.estado=EstadosVerificacionEnum.enVerificacionNuevosDoc.name();
247				dbSolicitud.verificacion.verificacionTiposDocumentos = VerificacionUtils.existDocumentosNuevos(dbSolicitud.verificacion, idSolicitud);
248				dbSolicitud.save();
249				Messages.info("Nuevos documentos aportados por el solicitante añadidos a la verificación actual. Verifique los tipos de estos documentos para proseguir con la verificación en curso.");
250			}
251			log.info("Acción sobre adjuntar Nuevos Documentos en página: " + "gen/PaginaVerificacion/PaginaVerificacion.html" + " , intentada con éxito");
252		} else
253			log.info("Acción sobre adjuntar Nuevos Documentos en página: " + "gen/PaginaVerificacion/PaginaVerificacion.html" + " , intentada sin éxito (Problemas de Validación)");
254		PaginaVerificacionController.nuevosDocumentosRender(idSolicitud, idVerificacion);
255	}
256	
257	public static void gnuevoRequerimientoBorradorPreliminar(Long idSolicitud, Long idVerificacion, String obtenerBorradorPreliminar) {
258		checkAuthenticity();
259		if (!permisoGnuevoRequerimientoBorradorPreliminar("editar")) {
260			Messages.error("No tiene permisos suficientes para realizar la acción");
261		}
262		if (!Messages.hasErrors()) {
263			PaginaVerificacionController.gnuevoRequerimientoBorradorPreliminarValidateRules();
264		}
265		if (!Messages.hasErrors()) {
266			try {
267				SolicitudGenerica dbSolicitud = SolicitudGenerica.findById(idSolicitud);
268				new Report("reports/requerimiento.html").header("reports/header.html").footer("reports/footer-borrador.html").renderResponse(dbSolicitud);
269			} catch (Exception e) {
270				play.Logger.error("Error generando el borrador", e.getMessage());
271				Messages.error("Error generando el borrador");
272			} catch (Throwable e) {
273				play.Logger.error("Error generando el borrador", e.getMessage());
274				Messages.error("Error generando el borrador");
275			}
276			log.info("Acción Editar de página: " + "gen/PaginaVerificacion/PaginaVerificacion.html" + " , intentada con éxito");
277		} else
278			log.info("Acción Editar de página: " + "gen/PaginaVerificacion/PaginaVerificacion.html" + " , intentada sin éxito (Problemas de Validación)");
279		PaginaVerificacionController.gnuevoRequerimientoBorradorPreliminarRender(idSolicitud, idVerificacion);
280	}
281	
282	@Util
283	// Este @Util es necesario porque en determinadas circunstancias crear(..) llama a editar(..).
284	public static void gnuevoRequerimientoBorradorPreliminargR(Long idSolicitud, Long idVerificacion, String obtenerBorradorPreliminar) {
285		checkAuthenticity();
286		if (!permisoGnuevoRequerimientoBorradorPreliminargR("editar")) {
287			Messages.error("No tiene permisos suficientes para realizar la acción");
288		}
289		
290		if (!Messages.hasErrors()) {
291			PaginaVerificacionController.gnuevoRequerimientoBorradorPreliminargRValidateRules();
292		}
293		
294		if (!Messages.hasErrors()) {
295			try {
296				SolicitudGenerica dbSolicitud = SolicitudGenerica.findById(idSolicitud);
297				new Report("reports/requerimiento.html").header("reports/header.html").footer("reports/footer-borrador.html").renderResponse(dbSolicitud);
298			} catch (Exception e) {
299				play.Logger.error("Error generando el borrador", e.getMessage());
300				Messages.error("Error generando el borrador");
301			} catch (Throwable e) {
302				play.Logger.error("Error generando el borrador", e.getMessage());
303				Messages.error("Error generando el borrador");
304			}
305			log.info("Acción Editar de página: " + "gen/PaginaVerificacion/PaginaVerificacion.html" + " , intentada con éxito");
306		} else
307			log.info("Acción Editar de página: " + "gen/PaginaVerificacion/PaginaVerificacion.html" + " , intentada sin éxito (Problemas de Validación)");
308		PaginaVerificacionController.gnuevoRequerimientoBorradorPreliminargRRender(idSolicitud, idVerificacion);
309	}
310	
311	@Util
312	// Este @Util es necesario porque en determinadas circunstancias crear(..) llama a editar(..).
313	public static void guardarMotivoRequerimientoGeneral(Long idSolicitud, Long idVerificacion, SolicitudGenerica solicitud, String guardarRequerimientoMotivoRequerimientoGeneralbtn, String btnFinalizarVerificacion) {
314		checkAuthenticity();
315		if (!permisoGuardarMotivoRequerimientoGeneral("editar")) {
316			Messages.error("No tiene permisos suficientes para realizar la acción");
317		}
318		SolicitudGenerica dbSolicitud = PaginaVerificacionController.getSolicitudGenerica(idSolicitud);
319
320		PaginaVerificacionController.guardarMotivoRequerimientoGeneralBindReferences(solicitud);
321
322		PaginaVerificacionController.guardarRequerimientoMotivoRequerimientoGeneralbtnGuardarMotivoRequerimientoGeneral(idSolicitud, idVerificacion, solicitud);
323		if (!Messages.hasErrors()) {
324
325			PaginaVerificacionController.guardarMotivoRequerimientoGeneralValidateCopy("editar", dbSolicitud, solicitud);
326
327		}
328
329		if (!Messages.hasErrors()) {
330			PaginaVerificacionController.guardarMotivoRequerimientoGeneralValidateRules(dbSolicitud, solicitud);
331		}
332		
333		Agente logAgente = AgenteController.getAgente();
334		
335		if (!Messages.hasErrors()) {
336			dbSolicitud.save();
337		}
338		if (guardarRequerimientoMotivoRequerimientoGeneralbtn != null) {
339				PaginaVerificacionController.guardarMotivoRequerimientoGeneralRender(idSolicitud, idVerificacion);
340		}
341
342		if (btnFinalizarVerificacion != null) {
343			PaginaVerificacionController.btnFinalizarVerificacionGuardarMotivoRequerimientoGeneral(idSolicitud, idVerificacion, solicitud);
344			PaginaVerificacionController.guardarMotivoRequerimientoGeneralRender(idSolicitud, idVerificacion);
345		}
346
347		if (!Messages.hasErrors()) {
348			log.info("Acción Editar de página: " + "gen/PaginaVerificacion/PaginaVerificacion.html" + " , intentada con éxito " + " Agente: " + logAgente);
349		} else
350			log.info("Acción Editar de página: " + "gen/PaginaVerificacion/PaginaVerificacion.html" + " , intentada sin éxito (Problemas de Validación)" + " Agente: " + logAgente);
351		PaginaVerificacionController.guardarMotivoRequerimientoGeneralRender(idSolicitud, idVerificacion);
352	}
353	
354	@Util
355	// Este @Util es necesario porque en determinadas circunstancias crear(..) llama a editar(..).
356	public static void btnFinalizarVerificacionGuardarMotivoRequerimientoGeneral(Long idSolicitud, Long idVerificacion, SolicitudGenerica solicitud) {
357	//public static void finalizarVerificacion(Long idSolicitud, Long idVerificacion, String btnFinalizarVerificacion) {	
358		checkAuthenticity();
359		if (!permisoFinalizarVerificacion("editar")) {
360			Messages.error("No tiene permisos suficientes para realizar la acción");
361		}
362
363		if (!Messages.hasErrors()) {
364			SolicitudGenerica dbSolicitud = getSolicitudGenerica(idSolicitud);
365			// Comprobamos que esten todos los documentos verificados
366			if (!VerificacionUtils.existsDocumentoNoVerificado(dbSolicitud.verificacion)){
367				// Si hay cosas que requerir, la verificación tiene causas subsanables
368				if (((dbSolicitud.verificacion.requerimiento.motivo != null) && (!dbSolicitud.verificacion.requerimiento.motivo.trim().isEmpty()))
369                        || (VerificacionUtils.documentosIncorrectos(dbSolicitud.verificacion))){
370					log.info("Hay que requerir y notificar, existe un motivo general de requerimiento o documentos en estado noValidos o noPresentados (Solicitud "+dbSolicitud.id+")");
371					CustomValidation.required("solicitud.verificacion.requerimiento.firmante", dbSolicitud.verificacion.requerimiento.firmante);
372					Requerimiento requerimiento = dbSolicitud.verificacion.requerimiento;
373					if(!Messages.hasErrors()){
374						try {
375							String tipoDocumentoRequerimiento = FapProperties.get("fap.aed.tiposdocumentos.requerimiento");
376													
377							if((requerimiento.oficial != null) && (requerimiento.oficial.uri != null) && (!requerimiento.oficial.uri.trim().equals(""))){
378							    Documento oficialOld = requerimiento.oficial;
379							    requerimiento.oficial = null;
380							    requerimiento.save();
381							    gestorDocumentalService.deleteDocumento(oficialOld);
382							}						
383
384							//Genera el documento oficial
385							SolicitudGenerica solicitudb = dbSolicitud;
386							File oficial =  new Report("reports/requerimiento.html").header("reports/header.html").registroSize().renderTmpFile(solicitudb);
387							requerimiento.oficial = new Documento();
388							requerimiento.oficial.tipo = tipoDocumentoRequerimiento;
389							requerimiento.oficial.descripcion = "Requerimiento";
390							requerimiento.oficial.clasificado=false;
391							
392							gestorDocumentalService.saveDocumentoTemporal(requerimiento.oficial, new FileInputStream(oficial), oficial.getName());
393							
394							requerimiento.estado = "borrador";
395							requerimiento.save();
396							
397							
398							// Actualizamos los datos de la verificacion para verificaciones posteriores, en este caso el estado.
399							dbSolicitud.verificacion.estado = EstadosVerificacionEnum.enRequerimiento.name();
400							Messages.ok("Se deberá realizar un Requerimiento");
401						}catch(Exception e){
402							Messages.error("Se produjo un error generando el documento de requerimiento.");
403							play.Logger.error(e, "Error al generar el documento de requerimiento: " + e.getMessage());
404							e.printStackTrace();
405						}
406					}
407
408				} else { // Si la verificación ha ido correcta, no hay ninguna causa subsanable
409					log.info("La verificación se ha podido finalizar con éxito, todo es correcto");
410					Messages.ok("La verificación no tiene ningun requerimiento, finalizada correctamente y con éxito");
411					
412					// Ponemos todos los documentos de la verificacion como verificados, para que no se incluyan en sucesivas verificaciones
413					VerificacionUtils.setVerificadoDocumentos(dbSolicitud.verificacion.documentos, dbSolicitud.documentacion.documentos);
414					if (dbSolicitud.verificacion.tramiteNombre.nombre.equalsIgnoreCase("Solicitud")){
415						if ((dbSolicitud.registro.oficial != null) && (!dbSolicitud.registro.oficial.uri.isEmpty()) && ((dbSolicitud.registro.oficial.verificado == null) || (!dbSolicitud.registro.oficial.verificado)))
416							VerificacionUtils.setVerificadoDocumento(dbSolicitud.verificacion.documentos, dbSolicitud.registro.oficial);
417					}
418					// Actualizamos los datos de la verificacion para verificaciones posteriores, en este caso el estado.
419					dbSolicitud.verificacion.estado = EstadosVerificacionEnum.verificacionPositiva.name();
420					
421					// Actualizamos los datos de la verificacion para verificaciones posteriores. Copiamos la verificacionActual a las verificaciones Anteriores para poder empezar una nueva verificación.
422					dbSolicitud.verificaciones.add(dbSolicitud.verificacion);
423					// Si el trámite es distinto de "Solicitud" se vuelve al estado anterior de la verificación
424					if (!dbSolicitud.verificacion.tramiteNombre.nombre.equalsIgnoreCase("Solicitud")) {
425						dbSolicitud.estado = dbSolicitud.estadoAntesVerificacion;
426					}
427					else {
428						// Según el estado anterior de la Solicitud cambiamos a nuevo estado
429						if (dbSolicitud.estado.equals(EstadosSolicitudEnum.enVerifAceptadoRSLPROV.name()))
430							dbSolicitud.estado = EstadosSolicitudEnum.concedidoRSLPROV.name();
431						else if (dbSolicitud.estado.equals(EstadosSolicitudEnum.enVerifAceptadoRSLDEF.name()))
432							dbSolicitud.estado = EstadosSolicitudEnum.concedidoRSLDEF.name();
433						else
434							dbSolicitud.estado = EstadosSolicitudEnum.verificado.name();
435					}
436				}
437
438				dbSolicitud.save();
439			} else {
440				Messages.error("Existen documentos aún por verificar, compruebe y verifiquelos para finalizar la Verificación Actual");
441			}
442		}
443
444		if (!Messages.hasErrors()) {
445			PaginaVerificacionController.finalizarVerificacionValidateRules();
446		}
447		if (!Messages.hasErrors()) {
448
449			log.info("Acción Editar de página: " + "gen/PaginaVerificacion/PaginaVerificacion.html" + " , intentada con éxito");
450		} else
451			log.info("Acción Editar de página: " + "gen/PaginaVerificacion/PaginaVerificacion.html" + " , intentada sin éxito (Problemas de Validación)");
452		PaginaVerificacionController.finalizarVerificacionRender(idSolicitud, idVerificacion);
453	}
454
455    @Util
456    public static boolean permisoFinalizarVerificacion(String accion) {
457        //Sobreescribir para incorporar permisos a mano
458        return true;
459    }
460
461    @Util
462    public static void finalizarVerificacionValidateRules() {
463        //Sobreescribir para validar las reglas de negocio
464    }
465
466    @Util
467    public static void finalizarVerificacionRender(Long idSolicitud, Long idVerificacion) {
468        if (!Messages.hasMessages()) {
469            Messages.ok("Página editada correctamente");
470            Messages.keep();
471            redirect("PaginaVerificacionController.index", "editar", idSolicitud, idVerificacion);
472        }
473        Messages.keep();
474        redirect("PaginaVerificacionController.index", "editar", idSolicitud, idVerificacion);
475    }
476
477	/**
478	 * Lista los gestores que pueden firmar el requerimiento
479	 * @return
480	 */
481	public static List<ComboItem> gestorAFirmar() {
482		return ComboUtils.gestorAFirmar();
483	}
484
485	
486	@Util
487	// Este @Util es necesario porque en determinadas circunstancias crear(..) llama a editar(..).
488	public static void gRequerirFirmaRequerimiento(Long idSolicitud, Long idVerificacion, SolicitudGenerica solicitud, String requerirFirma) {
489		checkAuthenticity();
490		if (!permisoGRequerirFirmaRequerimiento("editar")) {
491			Messages.error("No tiene permisos suficientes para realizar la acción");
492		}
493		SolicitudGenerica dbSolicitud = PaginaVerificacionController.getSolicitudGenerica(idSolicitud);
494
495		if (!Messages.hasErrors()) {
496			PaginaVerificacionController.gRequerirFirmaRequerimientoValidateCopy("editar", dbSolicitud, solicitud);
497		}
498
499		if (!Messages.hasErrors()) {
500			// Se debe enviar el mail de "solicitarFirmaRequerimiento"
501			envioMailFirmaRequerimiento(dbSolicitud);
502		}
503		if (!Messages.hasErrors()) {
504			dbSolicitud.save();
505			log.info("Acción Editar de página: " + "gen/PaginaVerificacion/PaginaVerificacion.html" + " , intentada con éxito");
506		} else
507			log.info("Acción Editar de página: " + "gen/PaginaVerificacion/PaginaVerificacion.html" + " , intentada sin éxito (Problemas de Validación)");
508		PaginaVerificacionController.gRequerirFirmaRequerimientoRender(idSolicitud, idVerificacion);
509	}
510
511	private static void envioMailFirmaRequerimiento(SolicitudGenerica solicitud) {
512		String mailRevisor = null;
513		String mailGestor = null;
514		try {
515			Agente revisor = AgenteController.getAgente();
516			mailRevisor = revisor.email;
517			mailGestor = ((Agente) Agente.find("select agente from Agente agente where agente.username=?", solicitud.verificacion.requerimiento.firmante).first()).email;
518			play.classloading.enhancers.LocalvariablesNamesEnhancer.LocalVariablesNamesTracer.addVariable("solicitud", solicitud);
519			play.classloading.enhancers.LocalvariablesNamesEnhancer.LocalVariablesNamesTracer.addVariable("mailGestor", mailGestor);
520			play.classloading.enhancers.LocalvariablesNamesEnhancer.LocalVariablesNamesTracer.addVariable("mailRevisor", mailRevisor);
521			
522			Mails.enviar("solicitarFirmaRequerimiento", solicitud, mailGestor, mailRevisor);
523            Messages.ok("Se envió requerimiento al gestor firmante solicitado.");
524            solicitud.verificacion.estado = EstadosVerificacionEnum.enRequerimientoFirmaSolicitada.name();
525            solicitud.save();
526		} catch (Exception e) {
527			play.Logger.error("No se pudo enviar el mail solicitarFirmaRequerimiento a los mails: "+mailGestor+", "+mailRevisor+". Error: "+e.getMessage());
528		}
529	}
530	
531	@Util
532	public static void gRequerirFirmaRequerimientoValidateCopy(String accion, SolicitudGenerica dbSolicitud, SolicitudGenerica solicitud) {
533		CustomValidation.clearValidadas();
534		if (secure.checkGrafico("requerimientoRequerirFirma", "editable", accion, (Map<String, Long>) tags.TagMapStack.top("idParams"), null)) {
535			CustomValidation.valid("solicitud.verificacion.requerimiento", dbSolicitud.verificacion.requerimiento);
536			CustomValidation.valid("solicitud.verificacion", dbSolicitud.verificacion);
537			CustomValidation.valid("solicitud", dbSolicitud);
538			CustomValidation.required("solicitud.verificacion.requerimiento.firmante", dbSolicitud.verificacion.requerimiento.firmante);
539			CustomValidation.validValueFromTable("solicitud.verificacion.requerimiento.firmante", solicitud.verificacion.requerimiento.firmante);
540			dbSolicitud.verificacion.requerimiento.registro.firmantes.todos = CalcularFirmantes.getGestorComoFirmante(solicitud.verificacion.requerimiento.firmante);
541			dbSolicitud.verificacion.requerimiento.registro.firmantes.save();
542			dbSolicitud.save();
543		}
544	}
545	
546	@Util
547	// Este @Util es necesario porque en determinadas circunstancias crear(..) llama a editar(..).
548	public static void gFirmarRequerimiento(Long idSolicitud, Long idVerificacion, String firma, String firmaRequerimiento) {
549		checkAuthenticity();
550		if (!permisoGFirmarRequerimiento("editar")) {
551			Messages.error("No tiene permisos suficientes para realizar la acción");
552		}
553		SolicitudGenerica dbSolicitud = PaginaVerificacionController.getSolicitudGenerica(idSolicitud);
554
555		if (firmaRequerimiento != null) {
556			
557			// Si no ha sido firmada
558			if (!dbSolicitud.verificacion.requerimiento.registro.fasesRegistro.firmada) {
559				PaginaVerificacionController.firmaRequerimientoGFirmarRequerimiento(idSolicitud, idVerificacion, firma);
560			}
561			
562			// Si ya fue firmada y no ha sido registrada
563			if (dbSolicitud.verificacion.requerimiento.registro.fasesRegistro.firmada
564					&& !dbSolicitud.verificacion.requerimiento.registro.fasesRegistro.registro) {
565				try {
566
567					models.JustificanteRegistro justificanteSalida = registroService.registroDeSalida(dbSolicitud.solicitante, dbSolicitud.verificacion.requerimiento.oficial, dbSolicitud.expedientePlatino, "Requerimiento");
568					
569					// ----- Hecho por Paco ------------------------
570					
571					dbSolicitud.verificacion.requerimiento.registro.informacionRegistro.setDataFromJustificante(justificanteSalida);
572					
573					Documento documento = dbSolicitud.verificacion.requerimiento.justificante;
574			        documento.tipo = FapProperties.get("fap.aed.tiposdocumentos.justificanteRegistroSalida");
575			        String aplicacionJ = "la aplicación";
576			        if ((FapProperties.get("fap.app.name.requerimiento.justificante.descripcion") != null) && (!"undefined".equals(FapProperties.get("fap.app.name.requerimiento.justificante.descripcion"))))
577			        	aplicacionJ = FapProperties.get("fap.app.name.requerimiento.justificante.descripcion");
578			        documento.descripcion = "Justificante de registro de requerimientos de la solicitud de "+aplicacionJ;
579			        documento.save();
580
581			        InputStream is = justificanteSalida.getDocumento().contenido.getInputStream();
582			        gestorDocumentalService.saveDocumentoTemporal(documento, is, "JustificanteRequerimiento" + dbSolicitud.verificacion.requerimiento.id + ".pdf");
583			        play.Logger.info("Justificante del Requerimiento almacenado en el AED");
584			        
585			        List<Documento> documentos = new ArrayList<Documento>();
586			        
587			        documentos.add(dbSolicitud.verificacion.requerimiento.justificante);
588			        documentos.add(dbSolicitud.verificacion.requerimiento.oficial);
589			        
590			        // TODO: OJO, Descomentar esto, que el el correcto funcionamiento, pero pro problemas de la sede electronica de mis notificaciones
591					//       No se puede ni poner a notificable tanto el requerimiento como su justificante de registro
592					//       Ni poder los datos de registro del requerimiento
593			        
594			        try { // Sin registro
595		                gestorDocumentalService.clasificarDocumentos(dbSolicitud, documentos, false /*true*/);
596		            } catch (Exception e) {
597		                play.Logger.error("No se ha podido clasificar el justificante del requerimiento: "+e.getMessage());
598		            }
599			        
600//			        documentos.clear();
601//			        documentos.add(dbSolicitud.verificacion.requerimiento.oficial);
602//			        
603//			        try { // Con registro
604//		                gestorDocumentalService.clasificarDocumentos(dbSolicitud, documentos, dbSolicitud.verificacion.requerimiento.registro.informacionRegistro, true);
605//		            } catch (Exception e) {
606//		            	play.Logger.error("No se ha podido clasificar el requerimiento oficial: "+e.getMessage());
607//		            }
608					
609			        // ------------------------------------------
610			        
611					play.Logger.info("Se ha registrado de Salida el documento del requerimiento de la solicitud "+dbSolicitud.id);
612					Messages.ok("Se ha registrado el Requerimiento correctamente.");
613					dbSolicitud.verificacion.requerimiento.registro.fasesRegistro.registro = true;
614					
615					//Si todo fue correcto, cambio el estado de la verificacion a firmada y registrada
616					//para diferenciarla de las que aún esperan la firma.
617					dbSolicitud.verificacion.estado=EstadosVerificacionEnum.enRequerimientoFirmadaRegistrada.name();
618					
619					dbSolicitud.save();
620					
621				} catch (Exception e) {
622					Messages.error("No se ha podido registrar el requerimiento de la solicitud "+dbSolicitud.id);
623					play.Logger.error("No se ha podido registrar el requerimiento de la solicitud "+dbSolicitud.id+": "+e.getMessage());
624				}
625			}
626			
627			// Si ya fue registrada
628			if (dbSolicitud.verificacion.requerimiento.registro.fasesRegistro.registro) {
629				Notificacion notificacion = dbSolicitud.verificacion.requerimiento.notificacion;
630				if (notificacion.estado == null || notificacion.estado.isEmpty()) {
631					//La notificación no ha sido creada
632					DocumentoNotificacion docANotificar = new DocumentoNotificacion(dbSolicitud.verificacion.requerimiento.justificante.uri);
633					notificacion.documentosANotificar.add(docANotificar);
634					notificacion.interesados.addAll(dbSolicitud.solicitante.getAllInteresados());
635					notificacion.descripcion = "Notificación";
636					notificacion.plazoAcceso = FapProperties.getInt("fap.notificacion.plazoacceso");
637					notificacion.plazoRespuesta = FapProperties.getInt("fap.notificacion.plazorespuesta");
638					notificacion.frecuenciaRecordatorioAcceso = FapProperties.getInt("fap.notificacion.frecuenciarecordatorioacceso");
639					notificacion.frecuenciaRecordatorioRespuesta = FapProperties.getInt("fap.notificacion.frecuenciarecordatoriorespuesta");
640					notificacion.estado = EstadoNotificacionEnum.creada.name();
641					notificacion.idExpedienteAed = dbSolicitud.expedienteAed.idAed;
642					notificacion.asunto = "Notificación por Requerimiento";
643					notificacion.save();
644					dbSolicitud.save();
645				}
646
647			}
648			
649			PaginaVerificacionController.gFirmarRequerimientoRender(idSolicitud, idVerificacion);
650		}
651
652		if (!Messages.hasErrors()) {
653			PaginaVerificacionController.gFirmarRequerimientoValidateRules(firma);
654		}
655		if (!Messages.hasErrors()) {
656			log.info("Acción Editar de página: " + "gen/PaginaVerificacion/PaginaVerificacion.html" + " , intentada con éxito");
657		} else
658			log.info("Acción Editar de página: " + "gen/PaginaVerificacion/PaginaVerificacion.html" + " , intentada sin éxito (Problemas de Validación)");
659		PaginaVerificacionController.gFirmarRequerimientoRender(idSolicitud, idVerificacion);
660	}
661	
662	@Util
663	public static void firmaRequerimientoGFirmarRequerimiento(Long idSolicitud, Long idVerificacion, String firma) {
664		SolicitudGenerica solicitud = PaginaVerificacionController.getSolicitudGenerica(idSolicitud);
665
666		if (solicitud.verificacion.requerimiento.registro.firmantes.todos == null || solicitud.verificacion.requerimiento.registro.firmantes.todos.size() == 0) {
667			solicitud.verificacion.requerimiento.registro.firmantes.todos = CalcularFirmantes.getGestoresComoFirmantes();
668			solicitud.verificacion.requerimiento.registro.firmantes.save();
669		}
670		FirmaUtils.firmar(solicitud.verificacion.requerimiento.oficial, solicitud.verificacion.requerimiento.registro.firmantes.todos, firma, null);
671		
672		if (!Messages.hasErrors()) {
673			Messages.ok("El requerimiento se ha firmado correctamente");
674			
675			solicitud.verificacion.requerimiento.registro.fasesRegistro.firmada = true;
676			solicitud.save();
677		}
678	}
679	
680	@Util
681	// Este @Util es necesario porque en determinadas circunstancias crear(..) llama a editar(..).
682	public static void gPonerADisposicion(Long idSolicitud, Long idVerificacion, String ponerADisposicion) {
683		checkAuthenticity();
684		if (!permisoGPonerADisposicion("editar")) {
685			Messages.error("No tiene permisos suficientes para realizar la acción");
686		}
687
688		if (!Messages.hasErrors()) {
689			Agente gestor = AgenteController.getAgente();
690			SolicitudGenerica solicitud = getSolicitudGenerica(idSolicitud);
691			Notificacion notificacion = solicitud.verificacion.requerimiento.notificacion;
692		
693			EntityTransaction tx = JPA.em().getTransaction();
694			if (notificacion.estado.equals(EstadoNotificacionEnum.creada.name())) {
695				// TODO: Está en estado creada, debo notificarla
696				try {
697					if (tx.isActive())
698				    	tx.commit();
699					tx.begin();
700					notificacionService.enviarNotificaciones(notificacion, AgenteController.getAgente());
701					
702					play.Logger.info("Se ha puesto a disposición la notificación "+notificacion.id);
703					notificacion.fechaPuestaADisposicion = new DateTime();
704					notificacion.save();
705					tx.commit();
706				} catch (Exception e) {
707					if ( tx != null && tx.isActive() ) tx.rollback();
708					Messages.error("Ha ocurrido un error en el proceso de notificación");
709					play.Logger.error("Ha ocurrido un error en el proceso de notificación para la notificacion: "+notificacion.id+" error: "+e.getMessage());
710					e.printStackTrace();
711				}
712				tx.begin();
713			}
714			
715			// Si fue puesta a disposición
716			if (notificacion.estado.equals(EstadoNotificacionEnum.puestaadisposicion.name())) {
717				try{
718					if (tx.isActive())
719				    	tx.commit();
720					tx.begin();
721					
722					if (!solicitud.verificacion.estado.equals(EstadosVerificacionEnum.enRequerido.name())) {
723						solicitud.verificacion.estado = EstadosVerificacionEnum.enRequerido.name();
724						// Ponemos todos los documentos de la verificacion como verificados, para que no se incluyan en sucesivas verificaciones
725						VerificacionUtils.setVerificadoDocumentos(solicitud.verificacion.documentos, solicitud.documentacion.documentos);
726						
727						//Se marca la solicitud como verificada
728						if (solicitud.verificacion.tramiteNombre.nombre.equalsIgnoreCase("Solicitud")) { 
729							if ((solicitud.registro.oficial != null) && (!solicitud.registro.oficial.uri.isEmpty()) && ((solicitud.registro.oficial.verificado == null) || (!solicitud.registro.oficial.verificado))) 
730								VerificacionUtils.setVerificadoDocumento(solicitud.verificacion.documentos, solicitud.registro.oficial); 
731						}
732						
733						// Actualizamos los datos de la verificacion para verificaciones posteriores. Copiamos la verificacionActual a las verificaciones Anteriores para poder empezar una nueva verificación.
734						solicitud.verificaciones.add(solicitud.verificacion);
735						solicitud.save();
736					}
737					notificacion.estado = EstadoNotificacionEnum.enviada.name();
738					notificacion.save();
739					
740					play.classloading.enhancers.LocalvariablesNamesEnhancer.LocalVariablesNamesTracer.addVariable("solicitud", solicitud);
741					Mails.enviar("emitirRequerimiento", solicitud);
742					tx.commit();
743				} catch (Exception e) {
744					if ( tx != null && tx.isActive() ) tx.rollback();
745					play.Logger.error("No se pudo enviar el mail emitirRequerimiento: "+e.getMessage());
746				}
747				tx.begin();
748			}
749		}
750
751		if (!Messages.hasErrors()) {
752			PaginaVerificacionController.gPonerADisposicionValidateRules();
753		}
754		
755		if (!Messages.hasErrors()) {
756			log.info("Acción Editar de página: " + "gen/PaginaVerificacion/PaginaVerificacion.html" + " , intentada con éxito");
757			Messages.ok("El proceso de notificación se ha realizado satisfactoriamente");
758		} else
759			log.info("Acción Editar de página: " + "gen/PaginaVerificacion/PaginaVerificacion.html" + " , intentada sin éxito (Problemas de Validación)");
760		PaginaVerificacionController.gPonerADisposicionRender(idSolicitud, idVerificacion);
761	}
762	
763	@Util
764	// Este @Util es necesario porque en determinadas circunstancias crear(..) llama a editar(..).
765	public static void anularVerificacion(Long idSolicitud, Long idVerificacion, String botonAnularVerificacion) {
766		checkAuthenticity();
767		if (!permisoAnularVerificacion("editar")) {
768			Messages.error("No tiene permisos suficientes para realizar la acción");
769		}
770		SolicitudGenerica solicitud = getSolicitudGenerica(idSolicitud);
771		long idVerificacionActualyMal=0;
772		if (!Messages.hasErrors()) {
773			// Cambiamos la verificación actual a null para 'resetear' la verificación y simular el anulamiento de la misma
774			solicitud.verificacion.setNullOneToMany();
775			solicitud.save();
776			idVerificacionActualyMal = solicitud.verificacion.id;
777			solicitud.verificacion = null;
778			solicitud.estado = solicitud.estadoAntesVerificacion;
779		}
780
781		if (!Messages.hasErrors()) {
782			PaginaVerificacionController.anularVerificacionValidateRules();
783		}
784		if (!Messages.hasErrors()) {
785			solicitud.save();
786			log.info("Anulada Verificación Correctamente por el Agente: "+AgenteController.getAgente().username+". Deshechada la Verificación con ID: "+idVerificacionActualyMal);
787			Messages.warning("Verificación Anulada Correctamente, puede iniciar una Nueva Verificación");
788			Messages.keep();
789			redirect("AccesoVerificacionesController.index", getAccion(), idSolicitud);
790		} else
791			log.info("Acción Editar de página: " + "gen/PaginaVerificacion/PaginaVerificacion.html" + " , intentada sin éxito (Problemas de Validación)");
792		PaginaVerificacionController.anularVerificacionRender(idSolicitud, idVerificacion);
793	}
794
795    @Util
796    public static void reabrirVerificacion(Long idSolicitud, Long idVerificacion, String botonReabrirVerificacion) {
797        checkAuthenticity();
798        if (!permisoReabrirVerificacion("editar")) {
799            Messages.error("No tiene permisos suficientes para realizar la acción");
800        }
801
802        if(!Messages.hasErrors()) {
803            Verificacion verificacion = Verificacion.findById(idVerificacion);
804            if (verificacion != null) {
805                verificacion.estado = EstadosVerificacionEnum.enVerificacion.name();
806                verificacion.save();
807                Messages.ok("Ahora puede modificar la verificación");
808            }
809        }
810
811        Agente logAgente = AgenteController.getAgente();
812        if (!Messages.hasErrors()) {
813            log.info("Acción Editar de página: " + "gen/PaginaVerificacion/PaginaVerificacion.html" + " , intentada con éxito " + " Agente: " + logAgente);
814        } else
815            log.info("Acción Editar de página: " + "gen/PaginaVerificacion/PaginaVerificacion.html" + " , intentada sin éxito (Problemas de Validación)" + " Agente: " + logAgente);
816        PaginaVerificacionController.reabrirVerificacionRender(idSolicitud, idVerificacion);
817    }
818
819	
820	@Util
821	public static void obtenerNoProcede(Long idSolicitud, Long idVerificacion){
822		//Debe extraer los documentos clasificados como no procede en verificaciones anteriores
823		//todas las verificaciones de la solicitud
824		SolicitudGenerica solicitud = SolicitudGenerica.findById(idSolicitud);
825		List<Verificacion> verificaciones = solicitud.verificaciones;
826		Map<String, VerificacionDocumento> docsnp = new HashMap<String, VerificacionDocumento>();		
827		
828		for (Verificacion verif : verificaciones) {
829			List<VerificacionDocumento> documentos = verif.documentos;
830			
831			for (VerificacionDocumento doc : documentos) {
832				//Si estado es noProcede, existe y no está ya en la lista -> Añadir
833				if ((doc.estadoDocumentoVerificacion.equals(EstadosDocumentoVerificacionEnum.noProcede.name())) && (doc.existe) && (!docsnp.containsKey(doc.uriDocumento))){
834					docsnp.put(doc.uriDocumento, new VerificacionDocumento(doc));
835				}
836				//Si está en lista, existe, el estado es distinto de noProcede y fecha posterior al almacenado
837				else if ((!doc.estadoDocumentoVerificacion.equals(EstadosDocumentoVerificacionEnum.noProcede.name())) && (doc.existe) && (docsnp.containsKey(doc.uriDocumento))){
838					docsnp.remove(doc.uriDocumento);
839				}
840			}
841		}
842		Verificacion verificacion = Verificacion.findById(idVerificacion);
843		verificacion.documentos.addAll(docsnp.values());
844		verificacion.estado = EstadosVerificacionEnum.enVerificacion.name();
845		verificacion.save();
846	}
847	
848	@Util
849	// Este @Util es necesario porque en determinadas circunstancias crear(..) llama a editar(..).
850	public static void frmtiposProceso(Long idSolicitud, Long idVerificacion, String obtenerNoProcede) {
851		checkAuthenticity();
852		if (!permisoFrmtiposProceso("editar")) {
853			Messages.error("No tiene permisos suficientes para realizar la acción");
854		}
855
856		if (!Messages.hasErrors()) {
857			obtenerNoProcede(idSolicitud, idVerificacion);
858		}
859
860		if (!Messages.hasErrors()) {
861			PaginaVerificacionController.frmtiposProcesoValidateRules();
862		}
863		if (!Messages.hasErrors()) {
864
865			log.info("Acción Editar de página: " + "gen/PaginaVerificacion/PaginaVerificacion.html" + " , intentada con éxito");
866		} else
867			log.info("Acción Editar de página: " + "gen/PaginaVerificacion/PaginaVerificacion.html" + " , intentada sin éxito (Problemas de Validación)");
868		PaginaVerificacionController.frmtiposProcesoRender(idSolicitud, idVerificacion);
869	}
870	
871
872	public static void tablaverificacionDocumentos(Long idSolicitud) {
873		SolicitudGenerica solicitud = SolicitudGenerica.findById(idSolicitud);
874		java.util.List<VerificacionDocumento> rows = solicitud.verificacion.documentos;
875		Map<String, Long> ids = (Map<String, Long>) tags.TagMapStack.top("idParams");
876		List<VerificacionDocumento> rowsFiltered = rows; //Tabla sin permisos, no filtra
877
878		tables.TableRenderResponse<VerificacionDocumento> response = new tables.TableRenderResponse<VerificacionDocumento>(rowsFiltered, false, false, false, "", "", "", getAccion(), ids);
879
880		renderJSON(response.toJSON("fechaPresentacion", "descripcion", "nombreTipoDocumento", "estadoDocumentoVerificacion", "identificadorMultiple", "linkUrlDescarga", "id"));
881	}
882	
883	@Util
884	public static void incluirNoProcede(SolicitudGenerica solicitud, Long idVerificacion) {
885		Verificacion verificacion = Verificacion.findById(idVerificacion);
886		TipoDocumento tDoc = TipoDocumento.find("select tDoc from TipoDocumento tDoc where uri=? and tramitePertenece=?", verificacion.incluirFichMultiple, verificacion.uriTramite).first();
887		if (tDoc == null) {
888			play.Logger.error("No existe el tipo de documento "+verificacion.incluirFichMultiple+"en el trámite "+verificacion.uriTramite+" de la verificación actual: "+verificacion.id);
889			Messages.error("No existe el tipo de documento en el trámite de la verificación actual");
890			return;
891		}
892		VerificacionDocumento vDoc = new VerificacionDocumento();
893		vDoc.existe = false;
894		vDoc.uriTipoDocumento = tDoc.uri;
895		vDoc.identificadorMultiple = tDoc.cardinalidad;
896		vDoc.descripcion = TableKeyValue.getValue("tiposDocumentos", tDoc.uri);
897		vDoc.estadoDocumentoVerificacion = EstadosDocumentoVerificacionEnum.noProcede.name();
898		vDoc.save();
899		verificacion.documentos.add(vDoc);
900		verificacion.save();
901	}
902	
903	/**
904	 * A partir del trámite de la verificación, devuelve todos los tipos de documentos
905	 * que cumplan:
906	 * 		- Aportado por CIUDADANO
907	 * 
908	 * @return
909	 */
910	public static List<ComboItem> comboMultiples() {
911		Long idSolicitud = Long.parseLong(params.get("idSolicitud"));
912		Long idVerificacion = Long.parseLong(params.get("idVerificacion"));
913		Verificacion verificacion = Verificacion.findById(idVerificacion);
914		// Obtenemos el trámite actual
915		Tramite tramite = verificacion.tramiteNombre;
916		List<ComboItem> result = new ArrayList<ComboItem>();
917		for (TipoDocumento tDoc : tramite.documentos) {
918			if (tDoc.aportadoPor.equalsIgnoreCase("CIUDADANO")) {
919				result.add(new ComboItem(tDoc.uri, tDoc.nombre));
920			}
921		}
922
923		return result;
924	}
925	
926	@Util
927	// Este @Util es necesario porque en determinadas circunstancias crear(..) llama a editar(..).
928	public static void incluirNoProcedeMultiples(Long idSolicitud, Long idVerificacion, SolicitudGenerica solicitud, String incluirNoProcede) {
929		checkAuthenticity();
930		
931		if (!permisoIncluirNoProcedeMultiples("editar")) {
932			Messages.error("No tiene permisos suficientes para realizar la acción");
933		}
934		SolicitudGenerica dbSolicitud = PaginaVerificacionController.getSolicitudGenerica(idSolicitud);
935
936		PaginaVerificacionController.incluirNoProcedeMultiplesBindReferences(solicitud);
937
938		if (!Messages.hasErrors()) {
939			PaginaVerificacionController.incluirNoProcedeMultiplesValidateCopy("editar", dbSolicitud, solicitud);
940		}
941		
942		if ((!Messages.hasErrors()) && (!incluirNoProcede.isEmpty())){
943			incluirNoProcede(solicitud, idVerificacion);
944		}
945
946		if (!Messages.hasErrors()) {
947			PaginaVerificacionController.incluirNoProcedeMultiplesValidateRules(dbSolicitud, solicitud);
948		}
949		if (!Messages.hasErrors()) {
950			dbSolicitud.save();
951			log.info("Acción Editar de página: " + "gen/PaginaVerificacion/PaginaVerificacion.html" + " , intentada con éxito");
952		} else
953			log.info("Acción Editar de página: " + "gen/PaginaVerificacion/PaginaVerificacion.html" + " , intentada sin éxito (Problemas de Validación)");
954		PaginaVerificacionController.incluirNoProcedeMultiplesRender(idSolicitud, idVerificacion);
955	}
956	
957}