package com.ejie.ab79.control;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.Formatter;
import java.util.List;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.i18n.LocaleContextHolder;
import org.springframework.context.support.ReloadableResourceBundleMessageSource;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.SessionAttributes;
import org.springframework.web.multipart.MultipartFile;

import com.ejie.ab79.clientesWS.ab61WebService.Ab61Exception;
import com.ejie.ab79.clientesWS.ab61WebService.IdentificadoresPid;
import com.ejie.ab79.clientesWS.ab61WebService.Usuario;
import com.ejie.ab79.clientesWS.ab63WebService.Ab63Exception;
import com.ejie.ab79.clientesWS.ab63WebService.DatosValidarWS;
import com.ejie.ab79.clientesWS.ab63WebService.ObjetosValidarWS;
import com.ejie.ab79.comun.Constantes;
import com.ejie.ab79.exceptions.PifException;
import com.ejie.ab79.model.DatosEstablecimiento;
import com.ejie.ab79.model.inspecciones.Inspecciones;
import com.ejie.ab79.model.preguntasRespuestas.FicherosAdjExp;
import com.ejie.ab79.model.preguntasRespuestas.FicherosAdjPro;
import com.ejie.ab79.model.preguntasRespuestas.ListaFicherosAdjExp;
import com.ejie.ab79.model.preguntasRespuestas.ListaFicherosAdjPro;
import com.ejie.ab79.model.preguntasRespuestas.ListaPreguntasRespuestas;
import com.ejie.ab79.model.preguntasRespuestas.OpcionesPreExp;
import com.ejie.ab79.model.preguntasRespuestas.OpcionesPrePro;
import com.ejie.ab79.model.preguntasRespuestas.PreguntasExpediente;
import com.ejie.ab79.model.preguntasRespuestas.PreguntasProtocolo;
import com.ejie.ab79.model.preguntasRespuestas.PreguntasRespuestasExpediente;
import com.ejie.ab79.model.preguntasRespuestas.PreguntasRespuestasProtocolo;
import com.ejie.ab79.model.preguntasRespuestas.RespuestasExpediente;
import com.ejie.ab79.model.preguntasRespuestas.RespuestasProtocolo;
import com.ejie.ab79.model.protocolos.Protocolos;
import com.ejie.ab79.service.DatosEstablecimientoService;
import com.ejie.ab79.service.inspecciones.InspeccionesService;
import com.ejie.ab79.service.preguntasRespuestas.FicherosAdjExpService;
import com.ejie.ab79.service.preguntasRespuestas.FicherosAdjProService;
import com.ejie.ab79.service.preguntasRespuestas.OpcionesPreExpService;
import com.ejie.ab79.service.preguntasRespuestas.PreguntasExpedienteService;
import com.ejie.ab79.service.preguntasRespuestas.PreguntasProtocoloService;
import com.ejie.ab79.service.preguntasRespuestas.RespuestasExpedienteService;
import com.ejie.ab79.service.preguntasRespuestas.RespuestasProtocoloService;
import com.ejie.ab79.service.protocolos.ProtocolosService;
import com.ejie.ab79.webservice.adaptadores.PIFAdaptador;
import com.ejie.ab79.webservice.adaptadores.ab61WebServiceAdaptador;
import com.ejie.ab79.webservice.adaptadores.ab63WebServiceAdaptador;
import com.ejie.x38.control.bind.annotation.RequestJsonBody;
import com.ejie.x38.dto.TableRequestDto;
import com.ejie.x38.dto.TableResponseDto;

/**
 * InformeTecnicoController  
 * 
 *  
 */
@SessionAttributes("usuario")
@Controller
@RequestMapping(value = "/informeTecnico")

public class InformeTecnicoController {

	private static final Logger logger = LoggerFactory.getLogger(InformeTecnicoController.class);

	@Autowired
	private PreguntasProtocoloService preguntasProtocoloService;
	@Autowired
	private RespuestasProtocoloService respuestasProtocoloService;
	@Autowired
	private InspeccionesService inspeccionesService;
	@Autowired
	private PreguntasExpedienteService preguntasExpedienteService;
	@Autowired
	private RespuestasExpedienteService respuestasExpedienteService;
	@Autowired
	private FicherosAdjProService ficherosAdjProService;
	@Autowired
	private OpcionesPreExpService opcionesPreExpService;
	@Autowired
	private ab63WebServiceAdaptador ab63WebServiceAdaptadorService;
	@Autowired
	private DatosEstablecimientoService datosEstablecimientoService;
	@Autowired
	private ProtocolosService protocolosService;
	@Autowired
	private FicherosAdjExpService ficherosAdjExpService;
	@Autowired
	private PIFAdaptador pifAdapterService;
	@Autowired
	private ab61WebServiceAdaptador ab61WebServiceAdaptadorService;
	@Resource
	private ReloadableResourceBundleMessageSource appMessageSource;

	/**
	 * Metodo de presentacion de la tab Informe Técnico.
	 * 
	 * @param model
	 *            Model
	 * @return String
	 */
	@RequestMapping(value = "/maint/{idInspeccion}", method = RequestMethod.GET)
	public String getFormEdit(@PathVariable("idInspeccion") Integer idInspeccion, Model model, HttpSession session) {
		InformeTecnicoController.logger.info("[GET - View] : informeTecnico");

		session.removeAttribute("listaFicherosAdjProAux");
		session.removeAttribute("listaFicherosAdjExpAux");
		session.removeAttribute("listaFicherosAdjExpTablaAux");
		Inspecciones inspeccion = new Inspecciones();
		inspeccion.setIdInspeccion(idInspeccion);

		inspeccion = this.inspeccionesService.find(inspeccion);
		List<PreguntasRespuestasExpediente> preguntasRespuestasExpediente = this.preguntasExpedienteService
				.findPreguntasRespuestasExpediente(inspeccion);
		parseRecogidaRespuestasExpediente(preguntasRespuestasExpediente);
		ListaPreguntasRespuestas listaPreguntasRespuestas = new ListaPreguntasRespuestas();
		listaPreguntasRespuestas.setPreguntasRespuestasExpediente(preguntasRespuestasExpediente);

		List<PreguntasRespuestasProtocolo> preguntasRespuestasProtocolo = this.preguntasProtocoloService
				.findPreguntasRespuestasProtocolo(inspeccion);
		parseRecogidaRespuestasProtocolo(preguntasRespuestasProtocolo);
		listaPreguntasRespuestas.setPreguntasRespuestasProtocolo(preguntasRespuestasProtocolo);

		Protocolos protocolo = new Protocolos();
		protocolo.setIdProtocolo(inspeccion.getIdProtocolo().getIdProtocolo());
		protocolo = this.protocolosService.find(protocolo);

		if (inspeccion.getIdOrigenInspeccion() == Constantes.ORIGEN_CENSO) {
			List<PreguntasRespuestasExpediente> preguntasRespuestasValidar = this.preguntasExpedienteService
					.findPreguntasRespuestasValidar(inspeccion);

			parseRecogidaValorValidar(preguntasRespuestasValidar);

			listaPreguntasRespuestas.setPreguntasRespuestasValidar(preguntasRespuestasValidar);

		}

		if ((listaPreguntasRespuestas.getPreguntasRespuestasProtocolo() != null
				&& !listaPreguntasRespuestas.getPreguntasRespuestasProtocolo().isEmpty())
				|| (listaPreguntasRespuestas.getPreguntasRespuestasValidar() != null
						&& !listaPreguntasRespuestas.getPreguntasRespuestasValidar().isEmpty())
				|| (listaPreguntasRespuestas.getPreguntasRespuestasExpediente() != null
						&& !listaPreguntasRespuestas.getPreguntasRespuestasExpediente().isEmpty())
						&& protocolo != null) {
			model.addAttribute("protocoloValidado", protocolo.getValidado());
		}

		model.addAttribute("extensionesAceptadasDocumento", Constantes.FICHERO_DOCUMENTO_EXTENSIONES);
		model.addAttribute("extensionesAceptadasImagen", Constantes.FICHERO_IMAGEN_EXTENSIONES);
		model.addAttribute("extensionesAceptadasAudio", Constantes.FICHERO_AUDIO_EXTENSIONES);
		model.addAttribute("extensionesAceptadasExcel", Constantes.FICHERO_EXCEL_EXTENSIONES);
		parseRecogidaRespuestasExpediente(preguntasRespuestasExpediente);
		model.addAttribute("listaPreguntasRespuestas", listaPreguntasRespuestas);
		return "informeTecnico";
	}

	/**
	 * Operacion de filtrado del componente RUP_TABLE.
	 * 
	 * @param filterPreguntasExpediente
	 *            PreguntasExpediente Bean que contiene los parametros de
	 *            filtrado a emplear.
	 * @param tableRequestDto
	 *            Dto que contiene los parametros de configuracion propios del
	 *            RUP_TABLE a aplicar en el filtrado.
	 * @return TableResponseDto<PreguntasExpediente> Dto que contiene el
	 *         resultado del filtrado realizado por el componente RUP_TABLE.
	 */
	@RequestMapping(value = "/filter", method = RequestMethod.POST)
	public @ResponseBody TableResponseDto<PreguntasExpediente> filter(
			@RequestJsonBody(param = "filter") PreguntasExpediente filterPreguntasExpediente,
			@RequestJsonBody TableRequestDto tableRequestDto) {
		InformeTecnicoController.logger.info("[POST - filter] : Obtener PreguntasExpediente");
		return this.preguntasExpedienteService.filterInformeTabla(filterPreguntasExpediente, tableRequestDto, false);
	}

	/**
	 * Recoge las preguntas del informe técnico a mostrar en la vista previa.
	 * 
	 * @param idProtocolo
	 * @param model
	 * @return
	 */
	@RequestMapping(value = "/vistaPrevia/{idProtocolo}/{tipoVistaPrevia}", method = RequestMethod.GET)
	public String vistaPrevia(@PathVariable("idProtocolo") Integer idProtocolo, Model model,
			@PathVariable("tipoVistaPrevia") Integer tipoVistaPrevia) {
		InformeTecnicoController.logger.info(
				"[POST - vistaPrevia] : Obtener PreguntasProtocolo para mostrar vista previa del informe técnico");
		PreguntasProtocolo preguntaProtocolo = new PreguntasProtocolo();
		preguntaProtocolo.setIdProtocolo(idProtocolo);

		if (Constantes.TIPO_PREGUNTAS_TOTALES != tipoVistaPrevia) {

			if (Constantes.TIPO_PREGUNTAS_VALIDAR == tipoVistaPrevia) {
				preguntaProtocolo.setPreguntaValidar(Constantes.VALIDAR);
			}
			List<PreguntasProtocolo> preguntasProtocolo = this.preguntasProtocoloService
					.findByProtocolo(preguntaProtocolo, null, false);
			List<OpcionesPrePro> opcionesPrePro = this.preguntasProtocoloService.findOpcionesPrePro();

			for (PreguntasProtocolo pregunta : preguntasProtocolo) {
				pregunta.setOpcionesPrePro(opcionesPrePro);
			}

			model.addAttribute("listaPreguntas", preguntasProtocolo);

		} else {

			List<PreguntasProtocolo> preguntasInforme = this.preguntasProtocoloService
					.findByProtocolo(preguntaProtocolo, null, false);
			preguntaProtocolo.setPreguntaValidar(Constantes.VALIDAR);
			List<PreguntasProtocolo> preguntasValidar = this.preguntasProtocoloService
					.findByProtocolo(preguntaProtocolo, null, false);
			List<OpcionesPrePro> opcionesPrePro = this.preguntasProtocoloService.findOpcionesPrePro();

			for (PreguntasProtocolo pregunta : preguntasInforme) {
				pregunta.setOpcionesPrePro(opcionesPrePro);
			}

			for (PreguntasProtocolo pregunta : preguntasValidar) {
				pregunta.setOpcionesPrePro(opcionesPrePro);
			}

			model.addAttribute("listaPreguntasInforme", preguntasInforme);
			model.addAttribute("listaPreguntasValidar", preguntasValidar);

		}
		model.addAttribute("tipoVistaPrevia", tipoVistaPrevia);
		return "informeTecnicoVistaPrevia";
	}

	/**
	 * Método para guardar las respuestas a las preguntas del protocolo.
	 * 
	 * @param model
	 * @param listaPreguntasRespuestasProtocolo
	 * @param usuario
	 * @return
	 */
	@RequestMapping(value = "guardarRespuestas", method = RequestMethod.POST)
	public @ResponseBody ListaPreguntasRespuestas add(@RequestBody ListaPreguntasRespuestas listaPreguntasRespuestas,
			@ModelAttribute("usuario") Usuario usuario, HttpSession session) {

		Date fechaHoy = new Date();
		ListaFicherosAdjPro listaFicherosAux = (ListaFicherosAdjPro) session.getAttribute("listaFicherosAdjProAux");
		ListaFicherosAdjExp listaFicherosExpAux = (ListaFicherosAdjExp) session.getAttribute("listaFicherosAdjExpAux");
		List<FicherosAdjPro> ficherosASubir = new ArrayList<FicherosAdjPro>();
		List<FicherosAdjExp> ficherosASubirExpediente = new ArrayList<FicherosAdjExp>();

		if (listaPreguntasRespuestas.getPreguntasRespuestasProtocolo() != null) {
			parseEnvioRespuestasProtocolo(listaPreguntasRespuestas.getPreguntasRespuestasProtocolo());
			// Guardamos las respuestas a las preguntas del protocolo
			// (AB7912T00)
			for (PreguntasRespuestasProtocolo preguntaRespuesta : listaPreguntasRespuestas
					.getPreguntasRespuestasProtocolo()) {

				// Si la pregunta es de tipo texto y la vaciamos nos viene un
				// null, por lo que la tenemos que poner a vacío("")
				if (preguntaRespuesta.getPreguntasProtocolo()
						.getIdTipoPregunta() == Constantes.TIPO_PREGUNTA_TEXTO_LIBRE
						&& preguntaRespuesta.getRespuestasProtocolo() != null
						&& preguntaRespuesta.getRespuestasProtocolo().getIdRespuestaProtocolo() != null
						&& preguntaRespuesta.getRespuestasProtocolo().getRespuesta() == null) {
					preguntaRespuesta.getRespuestasProtocolo().setRespuesta("");
				}

				if (preguntaRespuesta.getRespuestasProtocolo() != null
						&& preguntaRespuesta.getRespuestasProtocolo().getRespuesta() != null) {

					preguntaRespuesta.getRespuestasProtocolo().setFicherosAdjPro(new ArrayList<FicherosAdjPro>());

					// Si la respuesta ya existía update, si no insert
					if (preguntaRespuesta.getRespuestasProtocolo() != null
							&& preguntaRespuesta.getRespuestasProtocolo().getIdRespuestaProtocolo() != null) {

						// Buscamos la respuesta y si ha modificado su valor la
						// actualizamos si no la dejamos como está.
						RespuestasProtocolo respuestaUpdate = this.respuestasProtocoloService
								.find(preguntaRespuesta.getRespuestasProtocolo());

						if (!preguntaRespuesta.getRespuestasProtocolo().getRespuesta()
								.equals(respuestaUpdate.getRespuesta())) {
							preguntaRespuesta.getRespuestasProtocolo().setFechaUltmodificacion(fechaHoy);
							preguntaRespuesta.getRespuestasProtocolo().setUsuarioUltmodificacion(usuario.getUsuario());
							preguntaRespuesta.setRespuestasProtocolo(
									this.respuestasProtocoloService.update(preguntaRespuesta.getRespuestasProtocolo()));
						}

					} else {

						preguntaRespuesta.getRespuestasProtocolo().setIdRelProPre(preguntaRespuesta.getIdRelProPre());
						preguntaRespuesta.getRespuestasProtocolo().setFechaRegistro(fechaHoy);
						preguntaRespuesta.getRespuestasProtocolo().setUsuarioRegistro(usuario.getUsuario());
						preguntaRespuesta.setRespuestasProtocolo(
								this.respuestasProtocoloService.add(preguntaRespuesta.getRespuestasProtocolo()));

					}

					// Guardamos los ficheros a subir en una lista auxiliar
					if (listaFicherosAux != null) {
						for (FicherosAdjPro ficheroAsignacion : listaFicherosAux.getFicherosAdjPro()) {

							if (preguntaRespuesta.getIdRelProPre().equals(ficheroAsignacion.getIdRelProPre())) {
								ficheroAsignacion.setIdRespuestaProtocolo(
										preguntaRespuesta.getRespuestasProtocolo().getIdRespuestaProtocolo());
								ficherosASubir.add(ficheroAsignacion);
							}
						}
					}
				}
			}
		}

		// Recorremos la lista de ficheros auxiliar y añadimos los ficheros
		for (FicherosAdjPro ficheroASubir : ficherosASubir) {
			try {
				IdentificadoresPid identificadoresPid = this.ab61WebServiceAdaptadorService.insertarDocumentoPid(
						ficheroASubir.getPathPif(), ficheroASubir.getNombreFicheroAdjunto(), null,
						ficheroASubir.getNombreFicheroAdjunto(), Constantes.APORTADO_EXPEDIENTE_NO,
						Constantes.CODIGO_APLICACION, usuario.getUsuario());
				ficheroASubir.setIdDocumentoSubido(identificadoresPid.getIdDocumentoPid());
				this.ficherosAdjProService.add(ficheroASubir);
			} catch (Ab61Exception e) {
				InformeTecnicoController.logger.error("Error subida fichero PID - " + e.getMessage(), e);
			}
		}

		// Guardamos las respuestas a las preguntas del expediente (PREGUNTAS
		// VALIDAR (AB7913T00))
		if (listaPreguntasRespuestas.getPreguntasRespuestasValidar() != null) {
			parseEnvioRespuestasExpediente(listaPreguntasRespuestas.getPreguntasRespuestasValidar());
			for (PreguntasRespuestasExpediente preguntaRespuestaValidar : listaPreguntasRespuestas
					.getPreguntasRespuestasValidar()) {

				// Si la pregunta es de tipo texto y la vaciamos nos viene un
				// null, por lo que la tenemos que poner a vacío("")
				if (preguntaRespuestaValidar.getPreguntasExpediente()
						.getIdTipoPregunta() == Constantes.TIPO_PREGUNTA_TEXTO_LIBRE
						&& preguntaRespuestaValidar.getRespuestasExpediente() != null
						&& preguntaRespuestaValidar.getRespuestasExpediente().getIdRespuestaExpediente() != null
						&& preguntaRespuestaValidar.getRespuestasExpediente().getRespuesta() == null) {
					preguntaRespuestaValidar.getRespuestasExpediente().setRespuesta("");
				}

				if (preguntaRespuestaValidar.getRespuestasExpediente() != null
						&& preguntaRespuestaValidar.getRespuestasExpediente().getRespuesta() != null) {

					// Si la respuesta ya existía update, si no insert.
					if (preguntaRespuestaValidar.getRespuestasExpediente().getIdRespuestaExpediente() != null) {

						// Buscamos la respuesta y si el usuario ha modificado
						// su valor la actualizamos, si no, la dejamos como
						// está.
						RespuestasExpediente respuestaValidarUpdate = this.respuestasExpedienteService
								.find(preguntaRespuestaValidar.getRespuestasExpediente());

						if (!preguntaRespuestaValidar.getRespuestasExpediente().getRespuesta()
								.equals(respuestaValidarUpdate.getRespuesta())) {
							preguntaRespuestaValidar.getRespuestasExpediente().setFechaUltmodificacion(fechaHoy);
							preguntaRespuestaValidar.getRespuestasExpediente()
									.setUsuarioUltmodificacion(usuario.getUsuario());
							this.respuestasExpedienteService.update(preguntaRespuestaValidar.getRespuestasExpediente());
						}

					} else {
						preguntaRespuestaValidar.getRespuestasExpediente()
								.setPreguntaExpediente(new PreguntasExpediente(
										preguntaRespuestaValidar.getPreguntasExpediente().getIdPreguntaExpediente()));
						preguntaRespuestaValidar.getRespuestasExpediente().setFechaRegistro(fechaHoy);
						preguntaRespuestaValidar.getRespuestasExpediente().setUsuarioRegistro(usuario.getUsuario());
						this.respuestasExpedienteService.add(preguntaRespuestaValidar.getRespuestasExpediente());
					}
				}
			}
		}

		// Guardamos las respuestas a las preguntas del expediente (AB7913T00)
		if (listaPreguntasRespuestas.getPreguntasRespuestasExpediente() != null) {
			parseEnvioRespuestasExpediente(listaPreguntasRespuestas.getPreguntasRespuestasExpediente());
			for (PreguntasRespuestasExpediente preguntaRespuestaExpediente : listaPreguntasRespuestas
					.getPreguntasRespuestasExpediente()) {

				// Si la pregunta es de tipo texto y la vaciamos nos viene un
				// null, por lo que la tenemos que poner a vacío("")
				if (preguntaRespuestaExpediente.getPreguntasExpediente()
						.getIdTipoPregunta() == Constantes.TIPO_PREGUNTA_TEXTO_LIBRE
						&& preguntaRespuestaExpediente.getRespuestasExpediente() != null
						&& preguntaRespuestaExpediente.getRespuestasExpediente().getIdRespuestaExpediente() != null
						&& preguntaRespuestaExpediente.getRespuestasExpediente().getRespuesta() == null) {
					preguntaRespuestaExpediente.getRespuestasExpediente().setRespuesta("");
				}

				if (preguntaRespuestaExpediente.getRespuestasExpediente() != null
						&& preguntaRespuestaExpediente.getRespuestasExpediente().getRespuesta() != null) {

					// Si la respuesta ya existía update, si no insert
					if (preguntaRespuestaExpediente.getRespuestasExpediente().getIdRespuestaExpediente() != null) {

						// Buscamos la respuesta y si el usuario ha modificado
						// su valor la actualizamos, si no, la dejamos como
						// está.
						RespuestasExpediente respuestaExpedienteUpdate = this.respuestasExpedienteService
								.find(preguntaRespuestaExpediente.getRespuestasExpediente());

						if (!preguntaRespuestaExpediente.getRespuestasExpediente().getRespuesta()
								.equals(respuestaExpedienteUpdate.getRespuesta())) {
							preguntaRespuestaExpediente.getRespuestasExpediente().setFechaUltmodificacion(fechaHoy);
							preguntaRespuestaExpediente.getRespuestasExpediente()
									.setUsuarioUltmodificacion(usuario.getUsuario());
							preguntaRespuestaExpediente.setRespuestasExpediente(this.respuestasExpedienteService
									.update(preguntaRespuestaExpediente.getRespuestasExpediente()));
						}

					} else {
						preguntaRespuestaExpediente.getRespuestasExpediente()
								.setPreguntaExpediente(new PreguntasExpediente(preguntaRespuestaExpediente
										.getPreguntasExpediente().getIdPreguntaExpediente()));
						preguntaRespuestaExpediente.getRespuestasExpediente().setFechaRegistro(fechaHoy);
						preguntaRespuestaExpediente.getRespuestasExpediente().setUsuarioRegistro(usuario.getUsuario());
						preguntaRespuestaExpediente.setRespuestasExpediente(this.respuestasExpedienteService
								.add(preguntaRespuestaExpediente.getRespuestasExpediente()));
					}

					// Guardamos los ficheros preguntas expediente a subir en
					// una lista auxiliar
					if (listaFicherosExpAux != null) {
						for (FicherosAdjExp ficheroAsignacionExp : listaFicherosExpAux.getFicherosAdjExp()) {

							if (preguntaRespuestaExpediente.getPreguntasExpediente().getIdPreguntaExpediente()
									.equals(ficheroAsignacionExp.getIdPreguntaExpediente())) {
								ficheroAsignacionExp.setIdRespuestaExpediente(preguntaRespuestaExpediente
										.getRespuestasExpediente().getIdRespuestaExpediente());
								ficherosASubirExpediente.add(ficheroAsignacionExp);
							}
						}
					}

				}
			}
		}

		// Recorremos la lista de ficheros auxiliar y añadimos los ficheros
		// preguntas expediente
		for (FicherosAdjExp ficheroASubirExpediente : ficherosASubirExpediente) {
			try {
				IdentificadoresPid identificadoresPid = this.ab61WebServiceAdaptadorService.insertarDocumentoPid(
						ficheroASubirExpediente.getPathPif(), ficheroASubirExpediente.getNombreFicheroAdjunto(), null,
						ficheroASubirExpediente.getNombreFicheroAdjunto(), Constantes.APORTADO_EXPEDIENTE_NO,
						Constantes.CODIGO_APLICACION, usuario.getUsuario());
				ficheroASubirExpediente.setIdDocumentoSubido(identificadoresPid.getIdDocumentoPid());
				this.ficherosAdjExpService.add(ficheroASubirExpediente);
			} catch (Ab61Exception e) {
				InformeTecnicoController.logger.error("Error subida fichero expediente PID - " + e.getMessage(), e);
			}
		}

		session.removeAttribute("listaFicherosAdjProAux");
		session.removeAttribute("listaFicherosAdjExpAux");
		return listaPreguntasRespuestas;

	}

	/**
	 * Método para guardar preguntas de expediente
	 * 
	 * @param preguntaExpediente
	 * @param usuario
	 * @return
	 */
	@RequestMapping(value = "/guardarPreguntasExpediente/{idInspeccion}", method = RequestMethod.POST)
	public @ResponseBody PreguntasExpediente guardarPreguntasExpediente(
			@RequestBody PreguntasExpediente preguntaExpediente, @ModelAttribute("usuario") Usuario usuario,
			@PathVariable("idInspeccion") Integer idInspeccion) {

		PreguntasExpediente preguntaExpedienteAux = new PreguntasExpediente();
		try {

			if (preguntaExpediente != null && preguntaExpediente.getIdPreguntaExpediente() != null) {
				// UPDATE
				PreguntasExpediente preguntaExpedienteBBDD = this.preguntasExpedienteService.find(preguntaExpediente);

				if (preguntaExpediente.getIdTipoPregunta() != preguntaExpedienteBBDD.getIdTipoPregunta()) {
					// Si ha cambiado el tipo de pregunta eliminamos la
					// respuesta
					this.respuestasExpedienteService.removeRespuestaFicheros(preguntaExpedienteBBDD);
				}

				preguntaExpediente.setUsuarioUltmodificacion(usuario.getUsuario());
				preguntaExpedienteAux = this.preguntasExpedienteService.updatePregunta(preguntaExpediente);

				if (preguntaExpediente.getOpcionesEs() != null && preguntaExpediente.getOpcionesEu() != null) {

					this.opcionesPreExpService.removeByIdPreguntaExpediente(preguntaExpediente);

					String[] opcionesEs = preguntaExpediente.getOpcionesEs().split(";");
					String[] opcionesEu = preguntaExpediente.getOpcionesEu().split(";");
					List<OpcionesPreExp> listaOpciones = new ArrayList<OpcionesPreExp>();

					for (int i = 0; i < opcionesEs.length; i++) {
						OpcionesPreExp opcionesPreExp = new OpcionesPreExp();
						opcionesPreExp.setIdPreguntaExpediente(preguntaExpedienteAux.getIdPreguntaExpediente());
						opcionesPreExp.setDescripcionCastellano(opcionesEs[i]);
						opcionesPreExp.setDescripcionEuskera(opcionesEu[i]);
						opcionesPreExp.setUsuarioRegistro(usuario.getUsuario());
						this.opcionesPreExpService.add(opcionesPreExp);
						listaOpciones.add(opcionesPreExp);
					}

					preguntaExpedienteAux.setOpcionesPreExp(listaOpciones);
				}

			} else {
				// INSERT
				Inspecciones inspeccion = new Inspecciones();
				inspeccion.setIdInspeccion(idInspeccion);

				if (preguntaExpediente == null) {
					preguntaExpediente = new PreguntasExpediente();
				}
				preguntaExpediente.setInspeccion(inspeccion);
				preguntaExpediente.setUsuarioRegistro(usuario.getUsuario());

				preguntaExpedienteAux = this.preguntasExpedienteService.add(preguntaExpediente);

				if (preguntaExpediente.getOpcionesEs() != null && preguntaExpediente.getOpcionesEu() != null) {

					String[] opcionesEs = preguntaExpediente.getOpcionesEs().split(";");
					String[] opcionesEu = preguntaExpediente.getOpcionesEu().split(";");
					List<OpcionesPreExp> listaOpciones = new ArrayList<OpcionesPreExp>();

					for (int i = 0; i < opcionesEs.length; i++) {
						OpcionesPreExp opcionesPreExp = new OpcionesPreExp();
						opcionesPreExp.setIdPreguntaExpediente(preguntaExpedienteAux.getIdPreguntaExpediente());
						opcionesPreExp.setDescripcionCastellano(opcionesEs[i]);
						opcionesPreExp.setDescripcionEuskera(opcionesEu[i]);
						opcionesPreExp.setUsuarioRegistro(usuario.getUsuario());
						this.opcionesPreExpService.add(opcionesPreExp);
						listaOpciones.add(opcionesPreExp);
					}

					preguntaExpedienteAux.setOpcionesPreExp(listaOpciones);
				}

			}
		} catch (Exception e) {
			InformeTecnicoController.logger.error(e.getMessage());
		}

		return preguntaExpedienteAux;

	}

	@RequestMapping(value = "/guardarRespuestasTabla/{idInspeccion}", method = RequestMethod.POST)
	public @ResponseBody List<RespuestasExpediente> guardarRespuestasTabla(
			@RequestBody List<PreguntasExpediente> preguntasExpediente, @ModelAttribute("usuario") Usuario usuario,
			@PathVariable("idInspeccion") Integer idInspeccion, HttpSession session) {

		List<RespuestasExpediente> respuestasExpediente = new ArrayList<RespuestasExpediente>();
		ListaFicherosAdjExp listaFicherosExpAux = (ListaFicherosAdjExp) session
				.getAttribute("listaFicherosAdjExpTablaAux");
		List<FicherosAdjExp> ficherosASubirExpediente = new ArrayList<FicherosAdjExp>();
		Date fechaHoy = new Date();
		for (PreguntasExpediente pregunta : preguntasExpediente) {

			if (pregunta.getResultado() != null || pregunta.getObservacionesInspeccionCas() != null
					|| pregunta.getObservacionesInspeccionEus() != null) {

				RespuestasExpediente respuesta = new RespuestasExpediente();

				respuesta.setIdRespuestaExpediente(pregunta.getIdRespuestaExpediente());
				respuesta.setPreguntaExpediente(pregunta);
				respuesta.setRespuesta(pregunta.getResultado());
				respuesta.setObservacionesInspeccionCas(pregunta.getObservacionesInspeccionCas());
				respuesta.setObservacionesInspeccionEus(pregunta.getObservacionesInspeccionEus());
				parseEnvioRespuestasTabla(respuesta);

				// Update
				if (respuesta.getIdRespuestaExpediente() != null) {
					respuesta.setFechaUltmodificacion(fechaHoy);
					respuesta.setUsuarioUltmodificacion(usuario.getUsuario());
					respuestasExpediente.add(this.respuestasExpedienteService.update(respuesta));
				}
				// Insert
				else {
					respuesta.setFechaRegistro(fechaHoy);
					respuesta.setUsuarioRegistro(usuario.getUsuario());
					respuestasExpediente.add(this.respuestasExpedienteService.add(respuesta));
				}

				// Guardamos los ficheros preguntas expediente a subir en una
				// lista auxiliar
				if (listaFicherosExpAux != null) {
					for (FicherosAdjExp ficheroAsignacionExp : listaFicherosExpAux.getFicherosAdjExp()) {

						if (pregunta.getIdPreguntaExpediente().equals(ficheroAsignacionExp.getIdPreguntaExpediente())) {
							ficheroAsignacionExp.setIdRespuestaExpediente(respuesta.getIdRespuestaExpediente());
							ficherosASubirExpediente.add(ficheroAsignacionExp);
						}
					}
				}
			}
		}

		// Recorremos la lista de ficheros auxiliar y añadimos los ficheros
		// preguntas expediente
		for (FicherosAdjExp ficheroASubirExpediente : ficherosASubirExpediente) {
			try {
				IdentificadoresPid identificadoresPid = this.ab61WebServiceAdaptadorService.insertarDocumentoPid(
						ficheroASubirExpediente.getPathPif(), ficheroASubirExpediente.getNombreFicheroAdjunto(), null,
						ficheroASubirExpediente.getNombreFicheroAdjunto(), Constantes.APORTADO_EXPEDIENTE_NO,
						Constantes.CODIGO_APLICACION, usuario.getUsuario());
				ficheroASubirExpediente.setIdDocumentoSubido(identificadoresPid.getIdDocumentoPid());
				this.ficherosAdjExpService.add(ficheroASubirExpediente);
			} catch (Ab61Exception e) {
				InformeTecnicoController.logger.error("Error subida fichero expediente tabla PID - " + e.getMessage(),
						e);
			}
		}

		session.removeAttribute("listaFicherosAdjExpTablaAux");
		return respuestasExpediente;

	}

	@RequestMapping(value = "/subidaArchivos", method = RequestMethod.POST)
	public @ResponseBody ListaFicherosAdjPro subida(Model model,
			@ModelAttribute("listaFicherosAdjPro") ListaFicherosAdjPro listaFicherosAdjPro,
			@ModelAttribute("usuario") Usuario usuario,
			@RequestParam(value = "fileDocumento", required = false) MultipartFile fileDocumento,
			@RequestParam(value = "fileImagen", required = false) MultipartFile fileImagen,
			@RequestParam(value = "fileAudio", required = false) MultipartFile fileAudio,
			@RequestParam(value = "idRelProPre", required = true) Integer idRelProPre, HttpSession session)
			throws IOException {
		InformeTecnicoController.logger.info("[POST - subidaArchivos] : Inicio subidaArchivos");

		Date fechaHoy = new Date();
		ListaFicherosAdjPro listaFicherosAdjProAux = new ListaFicherosAdjPro();

		if (session.getAttribute("listaFicherosAdjProAux") == null) {
			listaFicherosAdjProAux.setFicherosAdjPro(new ArrayList<FicherosAdjPro>());
		} else {
			listaFicherosAdjProAux = (ListaFicherosAdjPro) session.getAttribute("listaFicherosAdjProAux");
		}

		for (FicherosAdjPro fichero : listaFicherosAdjPro.getFicherosAdjPro()) {

			fichero.setFechaRegistro(fechaHoy);
			fichero.setUsuarioRegistro(usuario.getUsuario());
			String pathPif = "";

			switch (fichero.getTipoFicheroAdjunto()) {
			case Constantes.FICHERO_DOCUMENTO:
				if (fileDocumento.getSize() > 0) {
					try {
						pathPif = this.pifAdapterService.putFileToPID(fileDocumento.getInputStream(),
								fileDocumento.getOriginalFilename());
					} catch (PifException e) {
						InformeTecnicoController.logger.error("Error subida fichero documento PIF - " + e.getMessage(),
								e);
					}
					fichero.setPathPif(pathPif);
					fichero.setNombreFicheroAdjunto(fileDocumento.getOriginalFilename());
					fichero.setIdRelProPre(idRelProPre);
				}
				break;

			case Constantes.FICHERO_IMAGEN:
				if (fileImagen.getSize() > 0) {
					try {
						pathPif = this.pifAdapterService.putFileToPID(fileImagen.getInputStream(),
								fileImagen.getOriginalFilename());
					} catch (PifException e) {
						InformeTecnicoController.logger.error("Error subida fichero imagen PIF - " + e.getMessage(), e);
					}
					fichero.setPathPif(pathPif);
					fichero.setNombreFicheroAdjunto(fileImagen.getOriginalFilename());
					fichero.setIdRelProPre(idRelProPre);
				}
				break;
			case Constantes.FICHERO_AUDIO:
				if (fileAudio.getSize() > 0) {
					try {
						pathPif = this.pifAdapterService.putFileToPID(fileAudio.getInputStream(),
								fileAudio.getOriginalFilename());
					} catch (PifException e) {
						InformeTecnicoController.logger.error("Error subida fichero audio PIF - " + e.getMessage(), e);
					}
					fichero.setPathPif(pathPif);
					fichero.setNombreFicheroAdjunto(fileAudio.getOriginalFilename());
					fichero.setIdRelProPre(idRelProPre);
				}
				break;
			default:
				InformeTecnicoController.logger.info("Entrada por el case default ");
				break;
			}

		}

		for (FicherosAdjPro fichero : listaFicherosAdjPro.getFicherosAdjPro()) {
			if (!"".equals(fichero.getPathPif())) {
				listaFicherosAdjProAux.getFicherosAdjPro().add(fichero);
			}

		}

		session.setAttribute("listaFicherosAdjProAux", listaFicherosAdjProAux);

		InformeTecnicoController.logger.info("[POST - subidaArchivos] : Fin subidaArchivos");

		return listaFicherosAdjProAux;
	}

	@RequestMapping(value = "/subidaArchivosExpediente", method = RequestMethod.POST)
	public @ResponseBody ListaFicherosAdjExp subidaArchivosExpediente(Model model,
			@ModelAttribute("listaFicherosAdjExp") ListaFicherosAdjExp listaFicherosAdjExp,
			@ModelAttribute("usuario") Usuario usuario,
			@RequestParam(value = "fileDocumentoExpediente", required = false) MultipartFile fileDocumentoExpediente,
			@RequestParam(value = "fileImagenExpediente", required = false) MultipartFile fileImagenExpediente,
			@RequestParam(value = "fileAudioExpediente", required = false) MultipartFile fileAudioExpediente,
			@RequestParam(value = "idPreguntaExpediente", required = true) Integer idPreguntaExpediente,
			HttpSession session) throws IOException {
		InformeTecnicoController.logger.info("[POST - subidaArchivosExpediente] : Inicio subidaArchivosExpediente");

		Date fechaHoy = new Date();
		ListaFicherosAdjExp listaFicherosAdjExpAux = new ListaFicherosAdjExp();

		if (session.getAttribute("listaFicherosAdjExpAux") == null) {
			listaFicherosAdjExpAux.setFicherosAdjExp(new ArrayList<FicherosAdjExp>());
		} else {
			listaFicherosAdjExpAux = (ListaFicherosAdjExp) session.getAttribute("listaFicherosAdjExpAux");
		}

		for (FicherosAdjExp fichero : listaFicherosAdjExp.getFicherosAdjExp()) {

			fichero.setFechaRegistro(fechaHoy);
			fichero.setUsuarioRegistro(usuario.getUsuario());
			String pathPif = "";

			switch (fichero.getTipoFicheroAdjunto()) {
			case Constantes.FICHERO_DOCUMENTO:
				if (fileDocumentoExpediente.getSize() > 0) {
					try {
						pathPif = this.pifAdapterService.putFileToPID(fileDocumentoExpediente.getInputStream(),
								fileDocumentoExpediente.getOriginalFilename());
					} catch (PifException e) {
						InformeTecnicoController.logger
								.error("Error subida fichero expediente documento PIF - " + e.getMessage(), e);
					}
					fichero.setPathPif(pathPif);
					fichero.setNombreFicheroAdjunto(fileDocumentoExpediente.getOriginalFilename());
					fichero.setIdPreguntaExpediente(idPreguntaExpediente);
				}
				break;

			case Constantes.FICHERO_IMAGEN:
				if (fileImagenExpediente.getSize() > 0) {
					try {
						pathPif = this.pifAdapterService.putFileToPID(fileImagenExpediente.getInputStream(),
								fileImagenExpediente.getOriginalFilename());
					} catch (PifException e) {
						InformeTecnicoController.logger
								.error("Error subida fichero expediente imagen PIF - " + e.getMessage(), e);
					}
					fichero.setPathPif(pathPif);
					fichero.setNombreFicheroAdjunto(fileImagenExpediente.getOriginalFilename());
					fichero.setIdPreguntaExpediente(idPreguntaExpediente);
				}
				break;
			case Constantes.FICHERO_AUDIO:
				if (fileAudioExpediente.getSize() > 0) {
					try {
						pathPif = this.pifAdapterService.putFileToPID(fileAudioExpediente.getInputStream(),
								fileAudioExpediente.getOriginalFilename());
					} catch (PifException e) {
						InformeTecnicoController.logger
								.error("Error subida fichero expediente audio PIF - " + e.getMessage(), e);
					}
					fichero.setPathPif(pathPif);
					fichero.setNombreFicheroAdjunto(fileAudioExpediente.getOriginalFilename());
					fichero.setIdPreguntaExpediente(idPreguntaExpediente);
				}
				break;
			default:
				InformeTecnicoController.logger.info("Entrada por el case default ");
				break;
			}
		}

		for (FicherosAdjExp fichero : listaFicherosAdjExp.getFicherosAdjExp()) {
			if (!"".equals(fichero.getPathPif())) {
				listaFicherosAdjExpAux.getFicherosAdjExp().add(fichero);
			}

		}

		session.setAttribute("listaFicherosAdjExpAux", listaFicherosAdjExpAux);

		InformeTecnicoController.logger.info("[POST - subidaArchivosExpediente] : Fin subidaArchivosExpediente");

		return listaFicherosAdjExpAux;
	}

	@RequestMapping(value = "/subidaArchivosExpedienteTabla", method = RequestMethod.POST)
	public @ResponseBody ListaFicherosAdjExp subidaArchivosExpedienteTabla(Model model,
			@ModelAttribute("listaFicherosAdjExp") ListaFicherosAdjExp listaFicherosAdjExp,
			@ModelAttribute("usuario") Usuario usuario,
			@RequestParam(value = "fileDocumentoExpediente", required = false) MultipartFile fileDocumentoExpediente,
			@RequestParam(value = "fileImagenExpediente", required = false) MultipartFile fileImagenExpediente,
			@RequestParam(value = "fileAudioExpediente", required = false) MultipartFile fileAudioExpediente,
			@RequestParam(value = "idPreguntaExpediente", required = true) Integer idPreguntaExpediente,
			HttpSession session) throws IOException {
		InformeTecnicoController.logger
				.info("[POST - subidaArchivosExpedienteTabla] : Inicio subidaArchivosExpedienteTabla");

		Date fechaHoy = new Date();
		ListaFicherosAdjExp listaFicherosAdjExpAux = new ListaFicherosAdjExp();

		if (session.getAttribute("listaFicherosAdjExpTablaAux") == null) {
			listaFicherosAdjExpAux.setFicherosAdjExp(new ArrayList<FicherosAdjExp>());
		} else {
			listaFicherosAdjExpAux = (ListaFicherosAdjExp) session.getAttribute("listaFicherosAdjExpTablaAux");
		}

		for (FicherosAdjExp fichero : listaFicherosAdjExp.getFicherosAdjExp()) {

			fichero.setFechaRegistro(fechaHoy);
			fichero.setUsuarioRegistro(usuario.getUsuario());
			String pathPif = "";

			switch (fichero.getTipoFicheroAdjunto()) {
			case Constantes.FICHERO_DOCUMENTO:
				if (fileDocumentoExpediente.getSize() > 0) {
					try {
						pathPif = this.pifAdapterService.putFileToPID(fileDocumentoExpediente.getInputStream(),
								fileDocumentoExpediente.getOriginalFilename());
					} catch (PifException e) {
						InformeTecnicoController.logger
								.error("Error subida fichero expediente audio PIF - " + e.getMessage(), e);
					}
					fichero.setPathPif(pathPif);
					fichero.setNombreFicheroAdjunto(fileDocumentoExpediente.getOriginalFilename());
					fichero.setIdPreguntaExpediente(idPreguntaExpediente);
				}
				break;

			case Constantes.FICHERO_IMAGEN:
				if (fileImagenExpediente.getSize() > 0) {
					try {
						pathPif = this.pifAdapterService.putFileToPID(fileImagenExpediente.getInputStream(),
								fileImagenExpediente.getOriginalFilename());
					} catch (PifException e) {
						InformeTecnicoController.logger
								.error("Error subida fichero expediente audio PIF - " + e.getMessage(), e);
					}
					fichero.setPathPif(pathPif);
					fichero.setNombreFicheroAdjunto(fileImagenExpediente.getOriginalFilename());
					fichero.setIdPreguntaExpediente(idPreguntaExpediente);
				}
				break;
			case Constantes.FICHERO_AUDIO:
				if (fileAudioExpediente.getSize() > 0) {
					try {
						pathPif = this.pifAdapterService.putFileToPID(fileAudioExpediente.getInputStream(),
								fileAudioExpediente.getOriginalFilename());
					} catch (PifException e) {
						InformeTecnicoController.logger
								.error("Error subida fichero expediente audio PIF - " + e.getMessage(), e);
					}
					fichero.setPathPif(pathPif);
					fichero.setNombreFicheroAdjunto(fileAudioExpediente.getOriginalFilename());
					fichero.setIdPreguntaExpediente(idPreguntaExpediente);
				}
				break;
			default:
				InformeTecnicoController.logger.info("Entrada por el case default ");
				break;
			}
		}

		for (FicherosAdjExp fichero : listaFicherosAdjExp.getFicherosAdjExp()) {
			if (!"".equals(fichero.getPathPif())) {
				listaFicherosAdjExpAux.getFicherosAdjExp().add(fichero);
			}

		}

		session.setAttribute("listaFicherosAdjExpTablaAux", listaFicherosAdjExpAux);

		InformeTecnicoController.logger
				.info("[POST - subidaArchivosExpedienteTabla] : Fin subidaArchivosExpedienteTabla");

		return listaFicherosAdjExpAux;
	}

	/**
	 * Método para descargar los archivos subidos
	 */
	@RequestMapping(value = "/descargaArchivos/{idFichero}", method = RequestMethod.GET)
	@ResponseStatus(HttpStatus.OK)
	public void descarga(@PathVariable("idFichero") Integer idFichero, HttpServletResponse response)
			throws IOException {
		InformeTecnicoController.logger.info("[GET - descargaArchivos] : Inicio descargaArchivos");

		this.ficherosAdjProService.descargaFicheros(idFichero, response);

		InformeTecnicoController.logger.info("[GET - descargaArchivos] : Fin descargaArchivos");
	}

	/**
	 * Método para descargar los archivos subidos preguntas expediente
	 * 
	 */
	@RequestMapping(value = "/descargaArchivosExpediente/{idFichero}", method = RequestMethod.GET)
	@ResponseStatus(HttpStatus.OK)
	public void descargaArchivosExpediente(@PathVariable("idFichero") Integer idFichero, HttpServletResponse response)
			throws IOException {
		InformeTecnicoController.logger.info("[GET - descargaArchivosExpediente] : Inicio descargaArchivosExpediente");

		this.ficherosAdjExpService.descargaFicheros(idFichero, response);

		InformeTecnicoController.logger.info("[GET - descargaArchivosExpediente] : Fin descargaArchivosExpediente");
	}

	/**
	 * Método para parsear las respuestas recibidas y pintarlas correctamente en
	 * la vista
	 * 
	 * @param preguntasRespuestasProtocolo
	 *            Lista de preguntas y respuestas a parsear
	 * @return List de preguntas y respuestas parseadas
	 */
	private List<PreguntasRespuestasProtocolo> parseRecogidaRespuestasProtocolo(
			List<PreguntasRespuestasProtocolo> preguntasRespuestasProtocolo) {

		return this.respuestasProtocoloService.parseRecogidaRespuestasProtocolo(preguntasRespuestasProtocolo);

	}

	/**
	 * Método que convierte las respuestas antes de guardarlas en BBDD
	 * 
	 * @param preguntasRespuestasProtocolo
	 * @return
	 */
	private List<PreguntasRespuestasProtocolo> parseEnvioRespuestasProtocolo(
			List<PreguntasRespuestasProtocolo> preguntasRespuestasProtocolo) {

		return this.respuestasProtocoloService.parseEnvioRespuestasProtocolo(preguntasRespuestasProtocolo);

	}

	/**
	 * Método para parsear las respuestas recibidas y pintarlas correctamente en
	 * la vista
	 * 
	 * @param preguntasRespuestasExpediente
	 *            Lista de preguntas y respuestas a parsear
	 * @return List de preguntas y respuestas parseadas
	 */
	private List<PreguntasRespuestasExpediente> parseRecogidaRespuestasExpediente(
			List<PreguntasRespuestasExpediente> preguntasRespuestasExpediente) {

		return this.respuestasExpedienteService.parseRecogidaRespuestasExpediente(preguntasRespuestasExpediente);

	}

	/**
	 * Método que convierte las respuestas antes de guardarlas en BBDD
	 * 
	 * @param preguntasRespuestasExpediente
	 * @return
	 */
	private List<PreguntasRespuestasExpediente> parseEnvioRespuestasExpediente(
			List<PreguntasRespuestasExpediente> preguntasRespuestasExpediente) {

		return this.respuestasExpedienteService.parseEnvioRespuestasExpediente(preguntasRespuestasExpediente);

	}

	/**
	 * Método que convierte el valor validar de AB7908T00 para pintarlo
	 * correctamente
	 * 
	 * @param preguntasRespuestasValidar
	 */
	private List<PreguntasRespuestasExpediente> parseRecogidaValorValidar(
			List<PreguntasRespuestasExpediente> preguntasRespuestasValidar) {

		return this.preguntasExpedienteService.parseRecogidaValorValidar(preguntasRespuestasValidar);
	}

	/**
	 * Método para parsear las respuestas recibidas y pintarlas correctamente en
	 * la vista
	 * 
	 * @param preguntasRespuestasProtocolo
	 *            Lista de preguntas y respuestas a parsear
	 * @return List de preguntas y respuestas parseadas
	 */
	private RespuestasExpediente parseEnvioRespuestasTabla(RespuestasExpediente respuestaExpediente) {

		return this.respuestasExpedienteService.parseEnvioRespuestasTabla(respuestaExpediente);

	}

	/**
	 * Método que genera una hoja de Excel con las preguntas del expediente de
	 * la tabla del informe técnico.
	 * 
	 * @param idInspeccion
	 * @param response
	 */
	@RequestMapping(value = {
			"/exportarExcelInformeTabla/{idInspeccion}/{sidx}/{sord}/{concepto}/{identificadorInspeccion}/{folderNumber}/{titulo}" }, method = RequestMethod.GET)
	public void getExcelInformeTabla(@PathVariable("idInspeccion") Integer idInspeccion, @PathVariable String sidx,
			@PathVariable String sord, @PathVariable boolean concepto, @ModelAttribute TableRequestDto tableRequestDto,
			HttpServletResponse response, @PathVariable("identificadorInspeccion") String identificadorInspeccion,
			@PathVariable("folderNumber") String folderNumber, @PathVariable("titulo") String titulo) {

		tableRequestDto.setSidx(sidx);
		tableRequestDto.setSord(sord);

		Inspecciones inspeccion = new Inspecciones();
		inspeccion.setIdInspeccion(idInspeccion);
		PreguntasExpediente filterPreguntasExpediente = new PreguntasExpediente();
		filterPreguntasExpediente.setInspeccion(inspeccion);

		List<PreguntasExpediente> preguntasExpedienteTabla = this.preguntasExpedienteService
				.findAllLikeInformeTabla(filterPreguntasExpediente, tableRequestDto, false);
		List<PreguntasRespuestasProtocolo> preguntasRespuestasProtocolo = this.preguntasProtocoloService
				.findPreguntasRespuestasProtocolo(inspeccion);
		List<PreguntasRespuestasExpediente> preguntasRespuestasExpediente = this.preguntasExpedienteService
				.findPreguntasRespuestasExpediente(inspeccion);

		for (PreguntasExpediente pregunta : preguntasExpedienteTabla) {
			if (pregunta.getImporte() != null) {
				StringBuilder sb = new StringBuilder();
				Formatter formatter = new Formatter(sb);
				formatter.format("%(,.2f", pregunta.getImporte());
				formatter.close();

				pregunta.setImporteString(sb.toString());

			}

			if (pregunta.getImporteAdmitido() != null) {
				StringBuilder sb = new StringBuilder();
				Formatter formatter = new Formatter(sb);
				formatter.format("%(,.2f", pregunta.getImporteAdmitido());
				formatter.close();
				pregunta.setImporteAdmitidoString(sb.toString());
			}
		}

		this.preguntasExpedienteService.getExcelInformeTabla(preguntasExpedienteTabla, preguntasRespuestasProtocolo,
				preguntasRespuestasExpediente, response, concepto, identificadorInspeccion, folderNumber, titulo);

	}

	/**
	 * Método que genera una hoja de Excel con las preguntas de protocolo del
	 * informe técnico.
	 */
	@RequestMapping(value = {
			"/exportarExcel/{idInspeccion}/{identificadorInspeccion}/{folderNumber}/{titulo}" }, method = RequestMethod.GET)
	public void getExcel(@PathVariable("idInspeccion") Integer idInspeccion, HttpServletResponse response,
			@PathVariable("identificadorInspeccion") String identificadorInspeccion,
			@PathVariable("folderNumber") String folderNumber, @PathVariable("titulo") String titulo) {

		this.preguntasProtocoloService.getExcel(idInspeccion, response, identificadorInspeccion, folderNumber, titulo);

	}

	/**
	 * Método importa las respuestas de una hoja de Excel y las guarda en BBDD.
	 * 
	 */
	@RequestMapping(value = { "/importarExcel/{idInspeccion}" }, method = RequestMethod.POST)
	public @ResponseBody ListaPreguntasRespuestas importarExcel(@PathVariable("idInspeccion") Integer idInspeccion,
			@RequestParam(value = "fileExcelInforme", required = false) MultipartFile fileExcel,
			@ModelAttribute("usuario") Usuario usuario) throws Exception {

		Date fechaHoy = new Date();

		ListaPreguntasRespuestas preguntasRespuestasImportadas = this.preguntasProtocoloService
				.importarExcel(fileExcel);

		// Preguntas respuestas a validar
		for (PreguntasRespuestasExpediente preguntaRespuestaValidar : preguntasRespuestasImportadas
				.getPreguntasRespuestasValidar()) {

			if (preguntaRespuestaValidar.getExcelErrorRow() == null) {

				// Buscamos la respuesta en base a la pregunta
				RespuestasExpediente respuestaUpdate = this.respuestasExpedienteService
						.findByIdPregunta(preguntaRespuestaValidar.getRespuestasExpediente());

				// Si existe la respuesta update, si no insert
				if (respuestaUpdate != null) {
					// Si ha borrado la respuesta, la borramos de BBDD
					if ("".equals(preguntaRespuestaValidar.getRespuestasExpediente().getRespuesta())) {
						this.respuestasExpedienteService.remove(respuestaUpdate);

					} else {

						// Si ha modificado la respuesta la actualizamos, si no
						// la dejamos como está.
						if (!preguntaRespuestaValidar.getRespuestasExpediente().getRespuesta()
								.equals(respuestaUpdate.getRespuesta())) {
							preguntaRespuestaValidar.getRespuestasExpediente()
									.setIdRespuestaExpediente(respuestaUpdate.getIdRespuestaExpediente());
							preguntaRespuestaValidar.getRespuestasExpediente().setFechaUltmodificacion(fechaHoy);
							preguntaRespuestaValidar.getRespuestasExpediente()
									.setUsuarioUltmodificacion(usuario.getUsuario());
							preguntaRespuestaValidar.setRespuestasExpediente(this.respuestasExpedienteService
									.update(preguntaRespuestaValidar.getRespuestasExpediente()));
						}
					}
				} else if (!"".equals(preguntaRespuestaValidar.getRespuestasExpediente().getRespuesta())) {
					preguntaRespuestaValidar.getRespuestasExpediente().setFechaRegistro(fechaHoy);
					preguntaRespuestaValidar.getRespuestasExpediente().setUsuarioRegistro(usuario.getUsuario());
					preguntaRespuestaValidar.setRespuestasExpediente(
							this.respuestasExpedienteService.add(preguntaRespuestaValidar.getRespuestasExpediente()));
				}

			}

		}

		// Preguntas respuestas de protocolo
		for (PreguntasRespuestasProtocolo preguntaRespuestaProtocolo : preguntasRespuestasImportadas
				.getPreguntasRespuestasProtocolo()) {

			if (preguntaRespuestaProtocolo.getExcelErrorRow() == null) {
				preguntaRespuestaProtocolo.getRespuestasProtocolo().setInspeccion(new Inspecciones(idInspeccion));

				// Buscamos la respuesta en base a la pregunta (relación
				// protocolo - pregunta en este caso)
				RespuestasProtocolo respuestaUpdate = this.respuestasProtocoloService
						.findByIdRelProPreInspeccion(preguntaRespuestaProtocolo.getRespuestasProtocolo());

				// Si existe la respuesta update, si no insert
				if (respuestaUpdate != null) {

					List<FicherosAdjPro> ficherosAdjuntos = this.ficherosAdjProService
							.findFicherosByIdRespuesta(respuestaUpdate.getIdRespuestaProtocolo());

					// Si ha borrado la respuesta, la borramos de BBDD si no
					// tiene ficheros asociados
					if ("".equals(preguntaRespuestaProtocolo.getRespuestasProtocolo().getRespuesta())
							&& ficherosAdjuntos.isEmpty()) {
						this.respuestasProtocoloService.remove(respuestaUpdate);
					} else {

						// Si ha modificado la respuesta la actualizamos, si no
						// la dejamos como está.
						if (!preguntaRespuestaProtocolo.getRespuestasProtocolo().getRespuesta()
								.equals(respuestaUpdate.getRespuesta())) {
							preguntaRespuestaProtocolo.getRespuestasProtocolo()
									.setIdRespuestaProtocolo(respuestaUpdate.getIdRespuestaProtocolo());
							preguntaRespuestaProtocolo.getRespuestasProtocolo().setFechaUltmodificacion(fechaHoy);
							preguntaRespuestaProtocolo.getRespuestasProtocolo()
									.setUsuarioUltmodificacion(usuario.getUsuario());
							preguntaRespuestaProtocolo.setRespuestasProtocolo(this.respuestasProtocoloService
									.update(preguntaRespuestaProtocolo.getRespuestasProtocolo()));
						}
					}
				} else if (!"".equals(preguntaRespuestaProtocolo.getRespuestasProtocolo().getRespuesta())) {
					preguntaRespuestaProtocolo.getRespuestasProtocolo()
							.setIdRelProPre(preguntaRespuestaProtocolo.getIdRelProPre());
					preguntaRespuestaProtocolo.getRespuestasProtocolo().setFechaRegistro(fechaHoy);
					preguntaRespuestaProtocolo.getRespuestasProtocolo().setUsuarioRegistro(usuario.getUsuario());
					preguntaRespuestaProtocolo.setRespuestasProtocolo(
							this.respuestasProtocoloService.add(preguntaRespuestaProtocolo.getRespuestasProtocolo()));
				}

			}

		}

		// Preguntas respuestas de expediente
		for (PreguntasRespuestasExpediente preguntaRespuestaExpediente : preguntasRespuestasImportadas
				.getPreguntasRespuestasExpediente()) {

			if (preguntaRespuestaExpediente.getExcelErrorRow() == null) {

				// Buscamos la respuesta en base a la pregunta
				RespuestasExpediente respuestaUpdate = this.respuestasExpedienteService
						.findByIdPregunta(preguntaRespuestaExpediente.getRespuestasExpediente());

				// Si existe la respuesta update, si no insert
				if (respuestaUpdate != null) {

					// Si ha borrado la respuesta, la borramos de BBDD
					if ("".equals(preguntaRespuestaExpediente.getRespuestasExpediente().getRespuesta())) {
						this.respuestasExpedienteService.remove(respuestaUpdate);
					} else {

						// Si ha modificado su valor la actualizamos, si no la
						// dejamos como está
						if (!preguntaRespuestaExpediente.getRespuestasExpediente().getRespuesta()
								.equals(respuestaUpdate.getRespuesta())) {
							preguntaRespuestaExpediente.getRespuestasExpediente()
									.setIdRespuestaExpediente(respuestaUpdate.getIdRespuestaExpediente());
							preguntaRespuestaExpediente.getRespuestasExpediente().setFechaUltmodificacion(fechaHoy);
							preguntaRespuestaExpediente.getRespuestasExpediente()
									.setUsuarioUltmodificacion(usuario.getUsuario());
							preguntaRespuestaExpediente.setRespuestasExpediente(this.respuestasExpedienteService
									.update(preguntaRespuestaExpediente.getRespuestasExpediente()));
						}
					}
				} else if (!"".equals(preguntaRespuestaExpediente.getRespuestasExpediente().getRespuesta())) {
					preguntaRespuestaExpediente.getRespuestasExpediente().setFechaRegistro(fechaHoy);
					preguntaRespuestaExpediente.getRespuestasExpediente().setUsuarioRegistro(usuario.getUsuario());
					preguntaRespuestaExpediente.setRespuestasExpediente(this.respuestasExpedienteService
							.add(preguntaRespuestaExpediente.getRespuestasExpediente()));
				}
			}
		}

		return preguntasRespuestasImportadas;

	}

	/**
	 * Método importa las respuestas de una hoja de Excel cuando el origen de la
	 * inspección es == 1 y las guarda en BBDD.
	 * 
	 * @param idInspeccion
	 * @param response
	 * @throws Exception
	 */
	@RequestMapping(value = { "/importarExcelTabla/{idInspeccion}" }, method = RequestMethod.POST)
	public @ResponseBody ListaPreguntasRespuestas importarExcelTabla(@PathVariable("idInspeccion") Integer idInspeccion,
			@RequestParam(value = "fileExcelInforme", required = false) MultipartFile fileExcel,
			@ModelAttribute("usuario") Usuario usuario) throws Exception {

		Date fechaHoy = new Date();

		ListaPreguntasRespuestas preguntasRespuestasImportadas = this.preguntasExpedienteService
				.importarExceltabla(fileExcel);

		// Preguntas respuestas de protocolo
		for (PreguntasRespuestasProtocolo preguntaRespuestaProtocolo : preguntasRespuestasImportadas
				.getPreguntasRespuestasProtocolo()) {

			if (preguntaRespuestaProtocolo.getExcelErrorRow() == null) {
				preguntaRespuestaProtocolo.getRespuestasProtocolo().setInspeccion(new Inspecciones(idInspeccion));

				// Buscamos la respuesta en base a la pregunta (relación
				// protocolo - pregunta en este caso)
				RespuestasProtocolo respuestaUpdate = this.respuestasProtocoloService
						.findByIdRelProPreInspeccion(preguntaRespuestaProtocolo.getRespuestasProtocolo());

				// Si existe la respuesta update, si no insert
				if (respuestaUpdate != null) {

					List<FicherosAdjPro> ficherosAdjuntos = this.ficherosAdjProService
							.findFicherosByIdRespuesta(respuestaUpdate.getIdRespuestaProtocolo());

					// Si ha borrado la respuesta, la borramos de BBDD si no
					// tiene ficheros asociados
					if ("".equals(preguntaRespuestaProtocolo.getRespuestasProtocolo().getRespuesta())
							&& ficherosAdjuntos.isEmpty()) {
						this.respuestasProtocoloService.remove(respuestaUpdate);
					} else {

						// Si ha modificado la respuesta la actualizamos, si no
						// la dejamos como está.
						if (!preguntaRespuestaProtocolo.getRespuestasProtocolo().getRespuesta()
								.equals(respuestaUpdate.getRespuesta())) {
							preguntaRespuestaProtocolo.getRespuestasProtocolo()
									.setIdRespuestaProtocolo(respuestaUpdate.getIdRespuestaProtocolo());
							preguntaRespuestaProtocolo.getRespuestasProtocolo().setFechaUltmodificacion(fechaHoy);
							preguntaRespuestaProtocolo.getRespuestasProtocolo()
									.setUsuarioUltmodificacion(usuario.getUsuario());
							preguntaRespuestaProtocolo.setRespuestasProtocolo(this.respuestasProtocoloService
									.update(preguntaRespuestaProtocolo.getRespuestasProtocolo()));
						}
					}
				} else if (!"".equals(preguntaRespuestaProtocolo.getRespuestasProtocolo().getRespuesta())) {
					preguntaRespuestaProtocolo.getRespuestasProtocolo()
							.setIdRelProPre(preguntaRespuestaProtocolo.getIdRelProPre());
					preguntaRespuestaProtocolo.getRespuestasProtocolo().setFechaRegistro(fechaHoy);
					preguntaRespuestaProtocolo.getRespuestasProtocolo().setUsuarioRegistro(usuario.getUsuario());
					preguntaRespuestaProtocolo.setRespuestasProtocolo(
							this.respuestasProtocoloService.add(preguntaRespuestaProtocolo.getRespuestasProtocolo()));
				}

			}

		}

		// Preguntas respuestas de expediente
		for (PreguntasRespuestasExpediente preguntaRespuestaExpediente : preguntasRespuestasImportadas
				.getPreguntasRespuestasExpediente()) {

			if (preguntaRespuestaExpediente.getExcelErrorRow() == null) {

				// Buscamos la respuesta en base a la pregunta
				RespuestasExpediente respuestaUpdate = this.respuestasExpedienteService
						.findByIdPregunta(preguntaRespuestaExpediente.getRespuestasExpediente());

				// Si existe la respuesta update, si no insert
				if (respuestaUpdate != null) {

					// Si ha borrado la respuesta, la borramos de BBDD
					if (("".equals(preguntaRespuestaExpediente.getRespuestasExpediente().getRespuesta())
							&& "".equals(preguntaRespuestaExpediente.getRespuestasExpediente()
									.getObservacionesInspeccionCas())
							&& "".equals(preguntaRespuestaExpediente.getRespuestasExpediente()
									.getObservacionesInspeccionEus())
							&& preguntaRespuestaExpediente.getRespuestasExpediente()
									.getObservacionesInspeccionCas() != null
							&& preguntaRespuestaExpediente.getRespuestasExpediente()
									.getObservacionesInspeccionEus() != null)
							|| ("".equals(preguntaRespuestaExpediente.getRespuestasExpediente().getRespuesta())
									&& preguntaRespuestaExpediente.getRespuestasExpediente()
											.getObservacionesInspeccionCas() == null
									&& preguntaRespuestaExpediente.getRespuestasExpediente()
											.getObservacionesInspeccionEus() == null)) {
						this.respuestasExpedienteService.remove(respuestaUpdate);
					} else {

						preguntaRespuestaExpediente.getRespuestasExpediente()
								.setIdRespuestaExpediente(respuestaUpdate.getIdRespuestaExpediente());
						preguntaRespuestaExpediente.getRespuestasExpediente().setFechaUltmodificacion(fechaHoy);
						preguntaRespuestaExpediente.getRespuestasExpediente()
								.setUsuarioUltmodificacion(usuario.getUsuario());
						preguntaRespuestaExpediente.setRespuestasExpediente(this.respuestasExpedienteService
								.update(preguntaRespuestaExpediente.getRespuestasExpediente()));

					}
				} else if (!"".equals(preguntaRespuestaExpediente.getRespuestasExpediente().getRespuesta())
						|| !"".equals(
								preguntaRespuestaExpediente.getRespuestasExpediente().getObservacionesInspeccionCas())
						|| !"".equals(preguntaRespuestaExpediente.getRespuestasExpediente()
								.getObservacionesInspeccionEus())) {
					preguntaRespuestaExpediente.getRespuestasExpediente().setFechaRegistro(fechaHoy);
					preguntaRespuestaExpediente.getRespuestasExpediente().setUsuarioRegistro(usuario.getUsuario());
					preguntaRespuestaExpediente.setRespuestasExpediente(this.respuestasExpedienteService
							.add(preguntaRespuestaExpediente.getRespuestasExpediente()));
				}
			}
		}

		return preguntasRespuestasImportadas;

	}

	/**
	 * Método que llama al WebService de AB63 actualizarEstablecimiento
	 * 
	 */
	@RequestMapping(value = "/llamarWebService/actualizarEstablecimiento/{folderId}/{idInspeccion}", method = RequestMethod.GET)
	public @ResponseBody String actualizarEstablecimiento(@PathVariable("folderId") String folderId,
			@PathVariable("idInspeccion") Integer idInspeccion, @ModelAttribute(value = "usuario") Usuario usuario,
			HttpServletRequest request, HttpServletResponse response) throws Exception {
		InformeTecnicoController.logger.info("[GET - actualizarEstablecimiento] : actualizarEstablecimiento");

		String result = "";
		try {
			Inspecciones inspeccion = new Inspecciones();
			inspeccion.setIdInspeccion(idInspeccion);
			InformeTecnicoController.logger
					.info("[actualizarEstablecimiento] : Buscar inspeccion id - " + idInspeccion);
			inspeccion = this.inspeccionesService.find(inspeccion);
			InformeTecnicoController.logger.info("[actualizarEstablecimiento] : Inspeccion encontrada - " + inspeccion);

			InformeTecnicoController.logger
					.info("[actualizarEstablecimiento] : Buscar identDatoEstablecimiento por inspeccion");
			DatosEstablecimiento datosEstablecimiento = this.datosEstablecimientoService.findByInspeccion(inspeccion);
			if (datosEstablecimiento != null && datosEstablecimiento.getIdentEstablecimiento() != null) {
				InformeTecnicoController.logger.info("[actualizarEstablecimiento] : identEstablecimiento - "
						+ datosEstablecimiento.getIdentEstablecimiento());
			}
			InformeTecnicoController.logger.info("[actualizarEstablecimiento] : Buscar datosValidarWS");
			List<DatosValidarWS> datosValidarWS = this.preguntasExpedienteService.findDatosValidarWS(inspeccion, null);
			List<String> idsObjValidarWS = this.preguntasExpedienteService.findIdsObjValidarWS(inspeccion);
			List<ObjetosValidarWS> objetosValidarWS = new ArrayList<ObjetosValidarWS>();

			InformeTecnicoController.logger.info("[actualizarEstablecimiento] : Buscar objetosValidarWS");
			for (String idObjValidarWS : idsObjValidarWS) {
				ObjetosValidarWS objetoValidarWS = new ObjetosValidarWS();
				objetoValidarWS.setIdObjetosValidarWS(idObjValidarWS);
				List<DatosValidarWS> datosValidarObjWS = this.preguntasExpedienteService.findDatosValidarWS(inspeccion,
						idObjValidarWS);
				if (!datosValidarObjWS.isEmpty()) {
					objetoValidarWS.setDatosValidarWS(datosValidarObjWS);
					objetosValidarWS.add(objetoValidarWS);
				}
			}

			com.ejie.ab79.clientesWS.ab63WebService.DatosEstablecimientoWS datosEstablecimientoWS = new com.ejie.ab79.clientesWS.ab63WebService.DatosEstablecimientoWS();

			if (datosEstablecimiento != null && datosEstablecimiento.getIdentEstablecimiento() != null) {
				datosEstablecimientoWS.setIdentEstablecimiento(datosEstablecimiento.getIdentEstablecimiento());
			}
			if (!datosValidarWS.isEmpty()) {
				datosEstablecimientoWS.setDatosValidarWS(datosValidarWS);
			}
			if (!objetosValidarWS.isEmpty()) {
				datosEstablecimientoWS.setObjetosValidarWS(objetosValidarWS);
			}
			InformeTecnicoController.logger
					.info("[actualizarEstablecimiento] : ***************************************");
			InformeTecnicoController.logger.info("[actualizarEstablecimiento] : Parámetros de entrada WebService AB63");
			InformeTecnicoController.logger
					.info("[actualizarEstablecimiento] : ***************************************");
			InformeTecnicoController.logger.info("[actualizarEstablecimiento] :     folderId - " + folderId);
			InformeTecnicoController.logger.info("[actualizarEstablecimiento] :     datosEstablecimientoWS - ");

			for (int i = 0; i < datosEstablecimientoWS.getDatosValidarWS().size(); i++) {
				InformeTecnicoController.logger
						.info("[actualizarEstablecimiento] :        datosValidarWS " + (i + 1) + " :");
				InformeTecnicoController.logger
						.info("[actualizarEstablecimiento] :           identificadorDatoEstablecimiento - "
								+ datosEstablecimientoWS.getDatosValidarWS().get(i)
										.getIdentificadorDatoEstablecimiento());
				InformeTecnicoController.logger.info("[actualizarEstablecimiento] :           valorValidar - "
						+ datosEstablecimientoWS.getDatosValidarWS().get(i).getValorValidar());
			}

			for (int j = 0; j < datosEstablecimientoWS.getObjetosValidarWS().size(); j++) {
				InformeTecnicoController.logger
						.info("[actualizarEstablecimiento] :        objetosValidarWS " + (j + 1) + " :");
				InformeTecnicoController.logger.info("[actualizarEstablecimiento] :           idObjetosValidarWS - "
						+ datosEstablecimientoWS.getObjetosValidarWS().get(j).getIdObjetosValidarWS());
				for (int k = 0; k < datosEstablecimientoWS.getObjetosValidarWS().get(j).getDatosValidarWS()
						.size(); k++) {
					InformeTecnicoController.logger.info("[actualizarEstablecimiento] :           objetosValidarWS "
							+ (j + 1) + " - datosValidarWS " + (k + 1) + " :");
					InformeTecnicoController.logger
							.info("[actualizarEstablecimiento] :              identificadorEstablecimiento - "
									+ datosEstablecimientoWS.getObjetosValidarWS().get(j).getDatosValidarWS().get(k)
											.getIdentificadorDatoEstablecimiento());
					InformeTecnicoController.logger
							.info("[actualizarEstablecimiento] :              valorValidar - " + datosEstablecimientoWS
									.getObjetosValidarWS().get(j).getDatosValidarWS().get(k).getValorValidar());
				}
			}
			InformeTecnicoController.logger.info("[actualizarEstablecimiento] :     usuario - " + usuario.getUsuario());
			InformeTecnicoController.logger
					.info("[actualizarEstablecimiento] : ***************************************");
			result = this.ab63WebServiceAdaptadorService.actualizarEstablecimiento(folderId, datosEstablecimientoWS,
					usuario.getUsuario());
			InformeTecnicoController.logger.info("[actualizarEstablecimineto] : Fin llamada WebService");

		} catch (Ab63Exception ex) {
			InformeTecnicoController.logger.error(ex.getMessage());
			handleSQLException(request, response, ex);

		} catch (Exception e) {
			if (e.getMessage() != null) {
				InformeTecnicoController.logger.error(e.getMessage());
			} else {
				InformeTecnicoController.logger.error("", e);
			}

			response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
			response.setContentType("text/html;charset=UTF-8");
			response.getWriter().write(e.getMessage());
			response.flushBuffer();
		}

		return result;

	}

	@RequestMapping(value = {
			"/vaciarRespuestaProtocolo/{idPreguntaProtocolo}/{idRespuestaProtocolo}" }, method = RequestMethod.DELETE)
	@ResponseStatus(value = HttpStatus.OK)
	public @ResponseBody PreguntasProtocolo vaciarRespuestaProtocolo(
			@PathVariable("idPreguntaProtocolo") Integer idPreguntaProtocolo,
			@PathVariable("idRespuestaProtocolo") Integer idRespuestaProtocolo) {
		PreguntasProtocolo preguntaProtocolo = new PreguntasProtocolo(idPreguntaProtocolo);
		this.respuestasProtocoloService.removeRespuestaFicheros(preguntaProtocolo, idRespuestaProtocolo);

		return preguntaProtocolo;

	}

	@RequestMapping(value = { "/vaciarRespuestaExpediente/{idPreguntaExpediente}" }, method = RequestMethod.DELETE)
	@ResponseStatus(value = HttpStatus.OK)
	public @ResponseBody PreguntasExpediente vaciarRespuestaExpediente(
			@PathVariable("idPreguntaExpediente") Integer idPreguntaExpediente) {
		PreguntasExpediente preguntaExpediente = new PreguntasExpediente(idPreguntaExpediente);
		this.respuestasExpedienteService.removeRespuestaFicheros(preguntaExpediente);

		return preguntaExpediente;

	}

	@RequestMapping(value = { "/eliminarPreguntaExpediente/{idPreguntaExpediente}" }, method = RequestMethod.DELETE)
	@ResponseStatus(value = HttpStatus.OK)
	public @ResponseBody PreguntasExpediente eliminarPreguntaExpediente(
			@PathVariable("idPreguntaExpediente") Integer idPreguntaExpediente) {

		PreguntasExpediente preguntaExpediente = new PreguntasExpediente(idPreguntaExpediente);
		this.preguntasExpedienteService.eliminarPreguntaExpediente(preguntaExpediente);

		return preguntaExpediente;

	}

	@RequestMapping(value = "/getPreguntaExpediente/{idPreguntaExpediente}", method = RequestMethod.GET)
	public @ResponseBody PreguntasExpediente get(@PathVariable Integer idPreguntaExpediente) {

		PreguntasExpediente preguntaExpediente = new PreguntasExpediente();
		preguntaExpediente.setIdPreguntaExpediente(idPreguntaExpediente);

		preguntaExpediente = this.preguntasExpedienteService.find(preguntaExpediente);
		List<OpcionesPreExp> opciones = this.preguntasExpedienteService.findOpcionesPreExp();
		String opcionesEs = "";
		String opcionesEu = "";
		List<OpcionesPreExp> opcionesPregunta = new ArrayList<OpcionesPreExp>();

		if (preguntaExpediente.getIdTipoPregunta() == Constantes.TIPO_PREGUNTA_CHECKBOX) {
			for (OpcionesPreExp opcion : opciones) {
				if (preguntaExpediente.getIdPreguntaExpediente().equals(opcion.getIdPreguntaExpediente())) {
					opcionesEs += opcion.getDescripcionCastellano() + "; ";
					opcionesEu += opcion.getDescripcionEuskera() + "; ";
					opcionesPregunta.add(opcion);
				}
			}

			preguntaExpediente.setOpcionesPreExp(opcionesPregunta);

			if (opcionesEs.length() > 0 && opcionesEu.length() > 0) {
				opcionesEs = opcionesEs.substring(0, opcionesEs.length() - 2);
				opcionesEu = opcionesEu.substring(0, opcionesEu.length() - 2);
				preguntaExpediente.setOpcionesEs(opcionesEs);
				preguntaExpediente.setOpcionesEu(opcionesEu);
			}
		}

		InformeTecnicoController.logger.info("[GET - findBy_PK] : Obtener PreguntasProtocolo por PK");

		return preguntaExpediente;
	}

	/**
	 * Captura las excepciones AB63Exception.
	 */
	@ExceptionHandler(value = { Ab63Exception.class })
	public void handleSQLException(HttpServletRequest request, HttpServletResponse response, Exception e)
			throws Exception {

		String mensajeError = "";

		if (LocaleContextHolder.getLocale().getLanguage().equalsIgnoreCase(Constantes.CASTELLANO)) {
			mensajeError = ((Ab63Exception) e).getFaultInfo().getMensajeCastellano();
		} else {
			mensajeError = ((Ab63Exception) e).getFaultInfo().getMensajeEuskera();
		}
		InformeTecnicoController.logger.error(mensajeError);
		// stated Content-Length
		response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
		response.setContentType("text/html;charset=UTF-8");
		response.getWriter().write(mensajeError);
		response.flushBuffer();
	}

}
