package com.dacrt.SBIABackend.controler;

import java.net.URI;
import java.sql.SQLException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Optional;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;
import javax.servlet.http.HttpServletRequest;
import javax.transaction.Transactional;

import org.json.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataIntegrityViolationException;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import com.dacrt.SBIABackend.dto.AppTypeRespDto;
import com.dacrt.SBIABackend.dto.BcpdrpparDto;
import com.dacrt.SBIABackend.dto.DataprocessparDto;
import com.dacrt.SBIABackend.dto.DependencyResponseDto;
import com.dacrt.SBIABackend.dto.EntryImpactDto;
import com.dacrt.SBIABackend.dto.EntrySupplierDto;
import com.dacrt.SBIABackend.dto.EntrySupplierDto2;
import com.dacrt.SBIABackend.dto.EvalProcessRecordsDto;
import com.dacrt.SBIABackend.dto.EvalProcessRequestDto;
import com.dacrt.SBIABackend.dto.EvalProcessResponseDto;
import com.dacrt.SBIABackend.dto.EvalprosuplliersActualizarDto;
import com.dacrt.SBIABackend.dto.ExternalReqsActualizarDto;
import com.dacrt.SBIABackend.dto.ImpactResponseDto;
import com.dacrt.SBIABackend.dto.PeriodParResponseDto;
import com.dacrt.SBIABackend.dto.PeriodsResponseDto;
import com.dacrt.SBIABackend.dto.ProcessResponDto;
import com.dacrt.SBIABackend.dto.RelatedcompanyparDto;
import com.dacrt.SBIABackend.dto.RequiredRespDto;
import com.dacrt.SBIABackend.dto.RequiredResponseDto;
import com.dacrt.SBIABackend.dto.RpoRespDto;
import com.dacrt.SBIABackend.dto.RpocontractualDto;
import com.dacrt.SBIABackend.dto.RtoRespDto;
import com.dacrt.SBIABackend.dto.RtoResponseDto;
import com.dacrt.SBIABackend.dto.RtocontractualDto;
import com.dacrt.SBIABackend.dto.ScaleResponseDto;
import com.dacrt.SBIABackend.dto.StatusDto;
import com.dacrt.SBIABackend.dto.StatusResponseDto;
import com.dacrt.SBIABackend.dto.TotalsResponseDto;
import com.dacrt.SBIABackend.dto.TypeResponseDto;
import com.dacrt.SBIABackend.dto.UnitsResponseDto;
import com.dacrt.SBIABackend.entity.Evalprocesses;
import com.dacrt.SBIABackend.entity.Evalprocimpacts;
import com.dacrt.SBIABackend.entity.Evalprocsupliers;
import com.dacrt.SBIABackend.entity.Externalreqs;
import com.dacrt.SBIABackend.entity.Suppliers;
import com.dacrt.SBIABackend.repository.CampaignsRepository;
import com.dacrt.SBIABackend.repository.EvalprocessesRepository;
import com.dacrt.SBIABackend.repository.EvalprocimpactsRepository;
import com.dacrt.SBIABackend.repository.EvalprosuppliersRepository;
import com.dacrt.SBIABackend.repository.SuppliersRepository;
import com.dacrt.SBIABackend.security.dto.AuditRequestDto;
import com.dacrt.SBIABackend.security.dto.PrivilegesAllDto;
import com.dacrt.SBIABackend.security.dto.RespuestaMsgDto;
import com.dacrt.SBIABackend.security.dto.RespuestaValueDto;
import com.dacrt.SBIABackend.security.entity.Params;
import com.dacrt.SBIABackend.security.entity.Users;
import com.dacrt.SBIABackend.security.repository.AuditRepository;
import com.dacrt.SBIABackend.security.repository.ParamsRepository;
import com.dacrt.SBIABackend.security.repository.RolesPrivilegesRepository;
import com.dacrt.SBIABackend.security.repository.UsersRepository;
import com.dacrt.SBIABackend.security.service.MenuService;
import com.dacrt.SBIABackend.security.service.ParamsService;
import com.dacrt.SBIABackend.security.service.SecurityService;
import com.dacrt.SBIABackend.security.service.UsersService;
import com.dacrt.SBIABackend.utils.HttpReqRespUtils;

@RestController
@CrossOrigin(origins = "*")
public class EvalprosuppliersController {
	@Autowired
	private ParamsRepository paramsRepository;
	
	@Autowired
	private UsersRepository usersRepository;
	
	@Autowired
	private AuditRepository auditRepository;
	
	@Autowired
	private RolesPrivilegesRepository rolesPrivilegesRepository;
	
	@Autowired
	UsersService usersService;
	
	@Autowired
	ParamsService paramsService;
	
	@Autowired
	SecurityService securityService;
	
	@Autowired
	CampaignsRepository campaignsRepository;
	
	@Autowired
	MenuService menuService;
	
	@PersistenceContext
    private EntityManager entityManager;
	
	@Autowired
	EvalprocimpactsRepository evalprocimpactsRepository;
	
	@Autowired
	EvalprocessesRepository evalprocessesRepository;
	
	@Autowired
	EvalprosuppliersRepository evalprosuppliersRepository;
	
	@Autowired
	SuppliersRepository suppliersRepository;
	
	Logger logger = LoggerFactory.getLogger(EvalprosuppliersController.class);
	
	@GetMapping({ "/evalprocesses/{evalprocessid}/suppliers/{evalprocsupid}" })
	public ResponseEntity<EntrySupplierDto> ObtenerUnEvalSuplliers(HttpServletRequest request,
			@PathVariable("evalprocessid") final Integer evalprocessid,
			@PathVariable(name = "evalprocsupid", required = false) final Integer evalprocsupid) throws ParseException {
		RespuestaMsgDto respuesta = new RespuestaMsgDto("");
		HttpStatus estatus = HttpStatus.FORBIDDEN;
		long cuantosregistro = 0;

		String sessionid = request.getHeader("Authorization");
		Date fecha = new Date();
		SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String dataFormattata = formatter.format(fecha);

		String contentIn = "";
		int orderIn = 0;
		int offsetIn = 0;
		int numofrecordsIn = 0;
		int rolisvalid = 0;

		Optional<Params> deSessDuration = paramsRepository.findByParamname("SESSION_DURATION");
		String SessionDuration = deSessDuration.get().getValue();
		int duracionSession = Integer.parseInt(SessionDuration);
		Date fecha2 = new Date();
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(fecha2); // tuFechaBase es un Date;
		// calendar.add(Calendar.MINUTE, minutosASumar); //minutosASumar es int.
		calendar.add(Calendar.MINUTE, duracionSession); // horasASumar es int.
		// lo que más quieras sumar
		Date ValidThrufechaSalida = calendar.getTime(); // Y ya tienes la fecha sumada.
		SimpleDateFormat salida = new SimpleDateFormat("yyyy-MM-dd HH:mm"); // 2024-12-23 23:00
		String fechaComoCadena = salida.format(ValidThrufechaSalida);
		System.out.println(fechaComoCadena);
		
		// Verifico la session
		if (sessionid == null) {
			respuesta.setMsg("Llamada al servicio malformado");
			estatus = HttpStatus.BAD_REQUEST;
			return new ResponseEntity(respuesta, estatus);
		} else {
			sessionid = sessionid.substring(7);
			// verifico si la sesión del usuario existe.
			Optional<Users> encontreSessionUsuario = usersRepository.getBySessionid(sessionid);
			if (encontreSessionUsuario.isPresent()) { // si la sesión del usuario existe
				Date FechaReg = encontreSessionUsuario.get().getValidthru();
				// Llamada a la funcion que validad el tiempo de Session, retorna la fecha
				// sumandole el tiempo de session activa, y vacio si no esta activa
				fechaComoCadena = securityService.consultarSessionActiva(FechaReg, fecha2,
						encontreSessionUsuario.get().getId());
				
				if (fechaComoCadena == "") {
					RespuestaMsgDto respuestaDto2;
					String var2 = "";
					boolean bloked2 = false;
					respuestaDto2 = new RespuestaMsgDto(var2);
					respuestaDto2.setMsg("Sesión expirada o inválida");
					return new ResponseEntity(respuestaDto2, HttpStatus.UNAUTHORIZED);
				}
				
				// Obtengo el rol de usuario y verifico si corresponde al privilegio del usuario
				rolisvalid = auditRepository.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(), 200);
				if (rolisvalid == 0) {
					respuesta.setMsg("No tiene los Privilegios");
					estatus = HttpStatus.FORBIDDEN;
					return new ResponseEntity(respuesta, estatus);
				}

				// Verifico si existe el id de la Evaluación del proceso
				Optional<Evalprocesses> obtproceso = evalprocessesRepository.findById(evalprocessid);
				Evalprocsupliers evalprocsupliers = new Evalprocsupliers();
				// Verifico si encontre el proceso
			    if (!obtproceso.isPresent()) {
			    	respuesta.setMsg("Registro no encontrado");
					return new ResponseEntity(respuesta, HttpStatus.NOT_FOUND);
			    }
			    
				try {
					Query query;
					
					Query query2;
					Query query3;
					Query query4;
					Query query5;
					
					String QueryTotal = "";
					// Luego consulto la tabla EvalProcessSuppliers
					String SentenciaBase = "SELECT  eu.id, " + " eu.supplierid,  " + " s.name,  " + " s.dsc,  "
							+ " s.suppliertypepar,  " + " (SELECT elemento ->> 'dsc' AS descr   "
							+ " FROM main.params p,   " + " jsonb_array_elements(CAST(p.value AS jsonb)) AS elemento   "
							+ " WHERE p.paramname = 'SUPPLIER_TYPE'   "
							+ " AND CAST(s.suppliertypepar AS TEXT) = elemento ->> 'value') des_suppliertypepar,  "
							+ " s.relatedcompanyyesnopar,  " + " ( SELECT elemento ->> 'dsc' AS descr   "
							+ " FROM main.params p,   " + " jsonb_array_elements(CAST(p.value AS jsonb)) AS elemento   "
							+ " WHERE p.paramname = 'RELATEDCOMPANY_YESNO'   "
							+ " AND s.relatedcompanyyesnopar = elemento ->> 'value') des_relatedcompanyyesnopar,  "
							+ " s.dataprocyesnopar,  " + " ( SELECT elemento ->> 'dsc' AS descr   "
							+ " FROM main.params p,   " + " jsonb_array_elements(CAST(p.value AS jsonb)) AS elemento   "
							+ " WHERE p.paramname = 'DATAPROCESS_YESNO'   "
							+ " AND s.dataprocyesnopar = elemento ->> 'value') des_dataprocyesnopar,  "
							+ " s.bcpdrpyesnopar,  " + " ( SELECT elemento ->> 'dsc' AS descr   "
							+ " FROM main.params p,   " + " jsonb_array_elements(CAST(p.value AS jsonb)) AS elemento   "
							+ " WHERE p.paramname = 'BCPDRP_YESNO'   "
							+ " AND s.bcpdrpyesnopar = elemento ->> 'value') des_bcpdrpyesnopar,  "
							+ " s.rtocontractual,  " + " (SELECT elemento ->> 'filter' AS filter  "
							+ " FROM main.params p,  " + "	 jsonb_array_elements(CAST(p.value AS jsonb)) AS elemento  "
							+ " WHERE p.paramname = 'EVALPROC_PERIOD'  "
							+ " AND CAST(s.rtoperiodpar AS TEXT) = elemento ->> 'value') filter_rtocontractual, "
							+ " s.rtoperiodpar, 						 " + " ( SELECT elemento ->> 'dsc' AS descr   "
							+ " FROM main.params p,   " + " jsonb_array_elements(CAST(p.value AS jsonb)) AS elemento   "
							+ " WHERE p.paramname = 'EVALPROC_PERIOD'   "
							+ " AND s.rtoperiodpar = elemento ->> 'value') des_rtoperiodpar,  "
							+ " s.rpocontractual,  "
							+ " (SELECT elemento ->> 'filter' AS filter  "
							+ " FROM main.params p,  "
							+ "	 jsonb_array_elements(CAST(p.value AS jsonb)) AS elemento  "
							+ " WHERE p.paramname = 'EVALPROC_PERIOD'  "
							+ " AND CAST(s.apoperiodpar AS TEXT) = elemento ->> 'value') filter_rpocontractual, "
							+ " s.apoperiodpar,  " + " ( SELECT elemento ->> 'dsc' AS descr   "
							+ "	FROM main.params p,  " + " jsonb_array_elements(CAST(p.value AS jsonb)) AS elemento   "
							+ " WHERE p.paramname = 'EVALPROC_PERIOD'   "
							+ " AND s.apoperiodpar = elemento ->> 'value') des_apoperiodpar,  " + " eu.rtoqty,  "
							+ " (SELECT elemento ->> 'filter' AS filter  " + " FROM main.params p,  "
							+ "	 jsonb_array_elements(CAST(p.value AS jsonb)) AS elemento  "
							+ " WHERE p.paramname = 'EVALPROC_PERIOD'  "
							+ " AND CAST(eu.rtoevalprocsupperiodpar AS TEXT) = elemento ->> 'value') filter_rtoqty, "
							+ " eu.rtoevalprocsupperiodpar,  " + " ( SELECT elemento ->> 'dsc' AS descr   "
							+ " FROM main.params p,   " + "  jsonb_array_elements(CAST(p.value AS jsonb)) AS elemento  "
							+ " WHERE p.paramname = 'EVALPROC_PERIOD'   "
							+ " AND eu.rtoevalprocsupperiodpar = elemento ->> 'value') des_rtoevalprocsupperiodpar,  "
							+ " eu.rpoqty, " + " (SELECT elemento ->> 'filter' AS filter  " + " FROM main.params p,  "
							+ "	 jsonb_array_elements(CAST(p.value AS jsonb)) AS elemento  "
							+ " WHERE p.paramname = 'EVALPROC_PERIOD'  "
							+ " AND CAST(eu.rpoevalprocsupperiodpar AS TEXT) = elemento ->> 'value') filter_rpoqty, "
							+ " eu.rpoevalprocsupperiodpar,  " + " ( SELECT elemento ->> 'dsc' AS descr   "
							+ "	 FROM main.params p,   "
							+ "	 jsonb_array_elements(CAST(p.value AS jsonb)) AS elemento   "
							+ " WHERE p.paramname = 'EVALPROC_PERIOD'   "
							+ " AND eu.rpoevalprocsupperiodpar = elemento ->> 'value') des_rpoevalprocsupperiodpar,  "
							+ " eu.evalprocsuprequiredpar,  " + " ( SELECT elemento ->> 'dsc' AS descr   "
							+ "	FROM main.params p,   "
							+ "  jsonb_array_elements(CAST(p.value AS jsonb)) AS elemento   "
							+ " WHERE p.paramname = 'EVALPROC_YESNO'   "
							+ " AND eu.evalprocsuprequiredpar = elemento ->> 'value') des_evalprocsuprequiredpar,  "
							+ " eu.evalprocsupdependencypar,  " + " ( SELECT elemento ->> 'dsc' AS descr   "
							+ " FROM main.params p,   "
							+ "	  jsonb_array_elements(CAST(p.value AS jsonb)) AS elemento   "
							+ " WHERE p.paramname = 'EVALPROC_YESNO'   "
							+ "	 AND eu.evalprocsupdependencypar = elemento ->> 'value') des_evalprocsupdependencypar  "
							+ " FROM main.evalprocsupliers eu,  " + " main.suppliers s " + " WHERE s.id=eu.supplierid "
							+ " AND eu.evalprocessid = :evalprocessid";
					
					if (evalprocsupid != null) {
						QueryTotal = SentenciaBase + " AND eu.id= :evalprocsupid ";
					} else {
						QueryTotal = SentenciaBase;
					}
					
					System.out.println(QueryTotal);
					query = entityManager.createNativeQuery(QueryTotal);
					query.setParameter("evalprocessid", evalprocessid);
					if (evalprocsupid != null) {
						query.setParameter("evalprocsupid", evalprocsupid);
					}
					cuantosregistro = (long) query.getResultList().size();
					query.setFirstResult(offsetIn);
					query.setMaxResults(numofrecordsIn);
					List<Object[]> resultados = query.getResultList();
					
					String QueryPeriod = "SELECT CAST(elem AS TEXT) " + "	FROM main.params pa, "
							+ "	jsonb_array_elements(CAST(pa.value AS jsonb)) AS elem "
							+ "	WHERE pa.paramname = 'EVALPROC_PERIOD' ";

					String QueryScale = "SELECT CAST(elem AS TEXT) " + "	FROM main.params pa, "
							+ "	jsonb_array_elements(CAST(pa.value AS jsonb)) AS elem "
							+ "	WHERE pa.paramname = 'EVALPROC_SCALESUP' ";
							//+ "	WHERE pa.paramname = 'EVALPROC_SCALEIMPACT' ";
					
					String QueryAppType = "SELECT CAST(elem AS TEXT) " + "	FROM main.params pa, "
							+ "	jsonb_array_elements(CAST(pa.value AS jsonb)) AS elem "
							+ "	WHERE pa.paramname = 'SUPPLIER_TYPE' ";
					
					String QueryRequired = "SELECT CAST(elem AS TEXT) " + "	FROM main.params pa, "
							+ "	jsonb_array_elements(CAST(pa.value AS jsonb)) AS elem "
							+ "	WHERE pa.paramname = 'EVALPROC_YESNO' ";
					
					EntrySupplierDto entrySupplierDto = new EntrySupplierDto();
					EntrySupplierDto2 entrySupplierDto2 = new EntrySupplierDto2();
					TypeResponseDto type = new TypeResponseDto();
					RelatedcompanyparDto relatedcompanypar = new RelatedcompanyparDto();
					DataprocessparDto dataprocesspar = new DataprocessparDto();
					BcpdrpparDto bcpdrppar = new BcpdrpparDto();
					RtocontractualDto rtocontractual = new RtocontractualDto();
					RpocontractualDto rpocontractual = new RpocontractualDto();
					RtoRespDto rto = new RtoRespDto();
					RpoRespDto rpo = new RpoRespDto();
					RequiredResponseDto requiredpar = new RequiredResponseDto();
					DependencyResponseDto dependencypar = new DependencyResponseDto();

					PeriodParResponseDto periodsResponseDtoRtoCon = new PeriodParResponseDto();
					PeriodParResponseDto periodsResponseDtoRpoCon = new PeriodParResponseDto();
					PeriodParResponseDto periodsResponseRto = new PeriodParResponseDto();
					PeriodParResponseDto periodsResponseRpo = new PeriodParResponseDto();
					
					PeriodParResponseDto periodParResponseDto = new PeriodParResponseDto();
					
					PeriodsResponseDto periodsResponseDto = new PeriodsResponseDto();
					ScaleResponseDto scaleResponseDto = new ScaleResponseDto();
					AppTypeRespDto appTypeRespDto = new AppTypeRespDto();
					RequiredRespDto requiredRespDto = new RequiredRespDto();
					List<ScaleResponseDto> scaleResponseDtoList = new ArrayList();
					List<PeriodsResponseDto> periodsResponseDtoList = new ArrayList();
					List<AppTypeRespDto> appTypeRespDtoList = new ArrayList();
					List<RequiredRespDto> requiredRespDtoList = new ArrayList();
					
					query2 = entityManager.createNativeQuery(QueryPeriod);
					List<Object[]> resultadosPeriod = query2.getResultList();
					
					JSONObject jsonObject;
					String jsonStringPeriod = "";
					if (resultadosPeriod.size() > 0) {
						for (Object period : resultadosPeriod) {
							jsonStringPeriod = (String) period; // Recupera el JSON como String
							jsonObject = new JSONObject(jsonStringPeriod); // Convierte String a JSONObject
							// Extrae los valores del JSONObject
							String dsc = jsonObject.getString("dsc");
							String value = jsonObject.getString("value");

							periodsResponseDto.setDsc(dsc);
							periodsResponseDto.setValue(value);
							periodsResponseDtoList.add(periodsResponseDto);
							periodsResponseDto = new PeriodsResponseDto();
						}
					}
					
					query3 = entityManager.createNativeQuery(QueryScale);
					List<Object[]> resultadosScale = query3.getResultList();
					
					String jsonStringScale = "";
					if (resultadosScale.size() > 0) {
						for (Object scale : resultadosScale) {
							jsonStringScale = (String) scale; // Recupera el JSON como String
							jsonObject = new JSONObject(jsonStringScale); // Convierte String a JSONObject
							// Extrae los valores del JSONObject
							String dsc = jsonObject.getString("dsc");
							String value = jsonObject.getString("value");

							scaleResponseDto.setDsc(dsc);
							scaleResponseDto.setValue(value);
							scaleResponseDtoList.add(scaleResponseDto);
							scaleResponseDto = new ScaleResponseDto();
						}
					}
					
					query4 = entityManager.createNativeQuery(QueryAppType);
					List<Object[]> resultadosAppType = query4.getResultList();
					
					String jsonStringAppType = "";
					if (resultadosAppType.size() > 0) {
						for (Object appType : resultadosAppType) {
							jsonStringAppType = (String) appType; // Recupera el JSON como String
							jsonObject = new JSONObject(jsonStringAppType); // Convierte String a JSONObject
							// Extrae los valores del JSONObject
							String dsc = jsonObject.getString("dsc");
							String value = jsonObject.getString("value");

							appTypeRespDto.setDsc(dsc);
							appTypeRespDto.setValue(value);
							appTypeRespDtoList.add(appTypeRespDto);
							appTypeRespDto = new AppTypeRespDto();
						}
					}
					
					query5 = entityManager.createNativeQuery(QueryRequired);
					List<Object[]> resultadosRequired = query5.getResultList();
					
					String jsonStringRequired = "";
					if (resultadosRequired.size() > 0) {
						for (Object required : resultadosRequired) {
							jsonStringRequired = (String) required; // Recupera el JSON como String
							jsonObject = new JSONObject(jsonStringRequired); // Convierte String a JSONObject
							// Extrae los valores del JSONObject
							String dsc = jsonObject.getString("dsc");
							String value = jsonObject.getString("value");

							requiredRespDto.setDsc(dsc);
							requiredRespDto.setValue(value);
							requiredRespDtoList.add(requiredRespDto);
							requiredRespDto = new RequiredRespDto();
						}
					}
					
					Integer filter = 0;
					Integer periodo = 0;
					if (cuantosregistro > 0) {
						for (Object[] fila : resultados) {
							entrySupplierDto2.setId((Integer) fila[0]);
							entrySupplierDto2.setSupplierid(String.valueOf(fila[1]));
							entrySupplierDto2.setName((String) fila[2]);
							entrySupplierDto2.setDsc((String) fila[3]);
							
							type.setId((String) fila[4]);
							type.setName((String) fila[5]);
							entrySupplierDto2.setType(type);
							
							relatedcompanypar.setDsc((String) fila[7]);
							relatedcompanypar.setValue((String) fila[6]);
							entrySupplierDto2.setRelatedcompanypar(relatedcompanypar);
							
							dataprocesspar.setDsc((String) fila[9]);
							dataprocesspar.setValue((String) fila[8]);
							entrySupplierDto2.setDataprocesspar(dataprocesspar);
							
							bcpdrppar.setDsc((String) fila[11]);
							bcpdrppar.setValue((String) fila[10]);
							entrySupplierDto2.setBcpdrppar(bcpdrppar);
							
							if (String.valueOf(fila[12]).compareTo("0") != 0) {
								periodsResponseDtoRtoCon.setId((String) fila[14]); 
								periodsResponseDtoRtoCon.setName((String) fila[15]);
								rtocontractual.setPeriod(periodsResponseDtoRtoCon);
								filter = Integer.parseInt((String) fila[13]);
								rtocontractual.setQty(String.valueOf(((Integer) fila[12]) / filter));
								entrySupplierDto2.setRtocontractual(rtocontractual);
							} else {
								periodsResponseDtoRtoCon.setId("1");
								periodsResponseDtoRtoCon.setName("Horas");
								rtocontractual.setPeriod(periodsResponseDtoRtoCon);
								rtocontractual.setQty("");
								entrySupplierDto2.setRtocontractual(rtocontractual);
							}
							
							if (String.valueOf(fila[16]).compareTo("0") != 0) {
								periodsResponseDtoRpoCon.setId((String) fila[18]);
								periodsResponseDtoRpoCon.setName((String) fila[19]);
								rpocontractual.setPeriod(periodsResponseDtoRpoCon);
								filter = Integer.parseInt((String) fila[17]);
								rpocontractual.setQty(String.valueOf((Integer) fila[16] / filter));
								entrySupplierDto2.setRpocontractual(rpocontractual);
							} else {
								periodsResponseDtoRpoCon.setId("1");
								periodsResponseDtoRpoCon.setName("Horas");
								rpocontractual.setPeriod(periodsResponseDtoRpoCon);
								rpocontractual.setQty("");
								entrySupplierDto2.setRpocontractual(rpocontractual);
							}
							
							if (String.valueOf(fila[20]).compareTo("0") != 0) {
								periodsResponseRto.setId((String) fila[22]);
								periodsResponseRto.setName((String) fila[23]);
								rto.setPeriodpar(periodsResponseRto);
								filter = Integer.parseInt((String) fila[21]);
								rto.setQty(String.valueOf((Integer) fila[20] / filter));
								entrySupplierDto2.setRto(rto);
							} else {
								periodsResponseRto.setId("1");
								periodsResponseRto.setName("Horas");
								rto.setPeriodpar(periodsResponseRto);
								rto.setQty("");
								entrySupplierDto2.setRto(rto);
							}
							
							if (String.valueOf(fila[24]).compareTo("0") != 0) {
								periodsResponseRpo.setId((String) fila[26]);
								periodsResponseRpo.setName((String) fila[27]);
								rpo.setPeriodpar(periodsResponseRpo);
								filter = Integer.parseInt((String) fila[25]);
								rpo.setQty(String.valueOf(((Integer) fila[24]) / filter));
								entrySupplierDto2.setRpo(rpo);
							} else {
								periodsResponseRpo.setId("1");
								periodsResponseRpo.setName("Horas");
								rpo.setPeriodpar(periodsResponseRpo);
								rpo.setQty("");
								entrySupplierDto2.setRpo(rpo);
							}
							
							requiredpar.setId((String) fila[28]);
							requiredpar.setName((String) fila[29]);
							entrySupplierDto2.setRequiredpar(requiredpar);
							
							dependencypar.setId((String) fila[30]);
							dependencypar.setName((String) fila[31]);
							entrySupplierDto2.setDependencypar(dependencypar);
							
							type = new TypeResponseDto();
							relatedcompanypar = new RelatedcompanyparDto();
							dataprocesspar = new DataprocessparDto();
							bcpdrppar = new BcpdrpparDto();
							rtocontractual = new RtocontractualDto();
							rpocontractual = new RpocontractualDto();
							rto = new RtoRespDto();
							rpo = new RpoRespDto();
							requiredpar = new RequiredResponseDto();
							dependencypar = new DependencyResponseDto();
							periodsResponseDto = new PeriodsResponseDto();
						}
					
						entrySupplierDto.setEntry(entrySupplierDto2);
						entrySupplierDto.setSessionvalidthru(fechaComoCadena);
						entrySupplierDto.setPeriods(periodsResponseDtoList);
						entrySupplierDto.setRequired(requiredRespDtoList);
						entrySupplierDto.setScale(scaleResponseDtoList);
						entrySupplierDto.setApptype(appTypeRespDtoList);
						
					} else {
						entrySupplierDto2.setId(0);
						entrySupplierDto2.setSupplierid("");
						entrySupplierDto2.setName("");
						entrySupplierDto2.setDsc("");
						
						type.setId("-1");
						type.setName("No Definido");
						entrySupplierDto2.setType(type);
						
						relatedcompanypar.setDsc("No Definido");
						relatedcompanypar.setValue("-1");
						entrySupplierDto2.setRelatedcompanypar(relatedcompanypar);
						
						dataprocesspar.setDsc("No Definido");
						dataprocesspar.setValue("-1");
						entrySupplierDto2.setDataprocesspar(dataprocesspar);
						
						bcpdrppar.setDsc("No Definido");
						bcpdrppar.setValue("-1");
						entrySupplierDto2.setBcpdrppar(bcpdrppar);
						
						periodsResponseDtoRtoCon.setId("1");
						periodsResponseDtoRtoCon.setName("Horas");
						rtocontractual.setPeriod(periodsResponseDtoRtoCon);
						rtocontractual.setQty("");
						entrySupplierDto2.setRtocontractual(rtocontractual);
						
						periodsResponseDtoRpoCon.setId("1");
						periodsResponseDtoRpoCon.setName("Horas");
						rpocontractual.setPeriod(periodsResponseDtoRpoCon);
						rpocontractual.setQty("");
						entrySupplierDto2.setRpocontractual(rpocontractual);
						
						periodsResponseRto.setId("1");
						periodsResponseRto.setName("Horas");
						rto.setPeriodpar(periodsResponseRto);
						rto.setQty("");
						entrySupplierDto2.setRto(rto);
						
						periodsResponseRpo.setId("1");
						periodsResponseRpo.setName("Horas");
						rpo.setPeriodpar(periodsResponseRpo);
						rpo.setQty("");
						entrySupplierDto2.setRpo(rpo);
						
						requiredpar.setId("2");
						requiredpar.setName("No");
						entrySupplierDto2.setRequiredpar(requiredpar);
						
						dependencypar.setId("2");
						dependencypar.setName("No");
						entrySupplierDto2.setDependencypar(dependencypar);
						
						entrySupplierDto.setEntry(entrySupplierDto2);
						entrySupplierDto.setSessionvalidthru(fechaComoCadena);
						entrySupplierDto.setPeriods(periodsResponseDtoList);
						entrySupplierDto.setRequired(requiredRespDtoList);
						entrySupplierDto.setScale(scaleResponseDtoList);
						entrySupplierDto.setApptype(appTypeRespDtoList);
					}
						
						return new ResponseEntity(entrySupplierDto, HttpStatus.OK);
				} catch (Exception e) {
					respuesta.setMsg("Error interno del servidor " + e.getMessage());
					estatus = HttpStatus.INTERNAL_SERVER_ERROR;
				} finally {
					if (entityManager != null && entityManager.isOpen()) {
						entityManager.close();
					}
				}
			} else { // Si la sesión que viene es inválida
				respuesta.setMsg("Sesión expirada o inválida");
				estatus = HttpStatus.BAD_REQUEST;
				return new ResponseEntity(respuesta, estatus);
			}
			return new ResponseEntity(respuesta, estatus);
		}
	}
	
	@PostMapping({ "/evalprocesses/{evalprocessid}/suppliers",
			"/evalprocesses/{evalprocessid}/suppliers/{evalprocsupid}" })
	public ResponseEntity<?> actualizarEvalSuppliers(HttpServletRequest request,
			@RequestBody EvalprosuplliersActualizarDto evalprosuplliersActualizarDto,
			@PathVariable("evalprocessid") final Integer evalprocessid,
			@PathVariable(name = "evalprocsupid", required = false) final Integer evalprocsupid) throws ParseException {
		RespuestaMsgDto respuesta = new RespuestaMsgDto("");
		HttpStatus estatus = HttpStatus.FORBIDDEN;
		long cuantosregistro = 0;

		String sessionid = request.getHeader("Authorization");
		Date fecha = new Date();
		SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String dataFormattata = formatter.format(fecha);

		AuditRequestDto auditDto = new AuditRequestDto();
		String module = "";
		String Descmodule = "";

		Date fecha3 = new Date();
		SimpleDateFormat formatter2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String dataFormattata2 = formatter.format(fecha3);
		Date fechaDate2 = formatter.parse(dataFormattata2);

		Optional<Operationlines> operationLines;

		Optional<Params> deSessDuration = paramsRepository.findByParamname("SESSION_DURATION");
		String SessionDuration = deSessDuration.get().getValue();
		int duracionSession = Integer.parseInt(SessionDuration);
		Date fecha2 = new Date();
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(fecha2); // tuFechaBase es un Date;
		// calendar.add(Calendar.MINUTE, minutosASumar); //minutosASumar es int.
		calendar.add(Calendar.MINUTE, duracionSession); // horasASumar es int.
		// lo que más quieras sumar
		Date ValidThrufechaSalida = calendar.getTime(); // Y ya tienes la fecha sumada.
		SimpleDateFormat salida = new SimpleDateFormat("yyyy-MM-dd HH:mm"); // 2024-12-23 23:00
		String fechaComoCadena = salida.format(ValidThrufechaSalida);
		System.out.println(fechaComoCadena);

		// Verifico la session
		if (sessionid == null) {
			respuesta.setMsg("Llamada al servicio malformado");
			estatus = HttpStatus.BAD_REQUEST;
			return new ResponseEntity(respuesta, estatus);
		} else {
			/// AQUI SE VALIDA EL ESTATUS DE LA CAMPANA PARA SABER SI SE PUEDE INCLUIR AL
			/// REGISTRO O MODIFICAR
			int statusCampaigns = campaignsRepository.findStatusCampaignByProcessId(evalprocessid);
			 
			if (statusCampaigns == 0) {
				 
				 String var = "";
					boolean bloked = false;
					RespuestaMsgDto respuestaDto = new RespuestaMsgDto(var);
				// respuestaDto.setBlocked(bloked);
					respuestaDto.setMsg("No tiene los privilegios");
				// Error 400
					return new ResponseEntity(respuestaDto, HttpStatus.FORBIDDEN);
				 
			}
			sessionid = sessionid.substring(7); // verifico si la sesión del usuario existe.

			Optional<Users> encontreSessionUsuario = usersRepository.getBySessionid(sessionid);

			if (encontreSessionUsuario.isPresent()) { // si la sesión del usuario existe
				Date FechaReg = encontreSessionUsuario.get().getValidthru();
				// Llamada a la funcion que validad el tiempo de Session, retorna la fecha
				// sumandole el tiempo de session activa, y vacio si no esta activa
				fechaComoCadena = securityService.consultarSessionActiva(FechaReg, fecha2,
						encontreSessionUsuario.get().getId());
				if (fechaComoCadena == "") {
					RespuestaMsgDto respuestaDto2;
					String var2 = "";
					boolean bloked2 = false;
					respuestaDto2 = new RespuestaMsgDto(var2);
					respuestaDto2.setMsg("Sesión expirada o inválida");
					return new ResponseEntity(respuestaDto2, HttpStatus.UNAUTHORIZED);
				}

				// Verifico si existe el id de la Evaluación del proceso
				Optional<Evalprocesses> obtproceso = evalprocessesRepository.findById(evalprocessid);
				Evalprocsupliers evalprocsupliers = new Evalprocsupliers();
				// Verifico si encontre el proceso
			    if (!obtproceso.isPresent()) {
			    	respuesta.setMsg("Registro no encontrado");
					return new ResponseEntity(respuesta, HttpStatus.NOT_FOUND);
			    }
			    
				int rolisvalid = 0;
				if (evalprocsupid != 0) {// actualizar requerimiento externo
					try {
						// verifico si tiene el privilegio
						rolisvalid = auditRepository
								.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(), 201);
						if (rolisvalid == 0) {
							respuesta.setMsg("No tiene los Privilegios");
							estatus = HttpStatus.FORBIDDEN;
							return new ResponseEntity(respuesta, estatus);
						}

						// Verifico si existe el id de suppliers en la base de datos
					    Optional<Evalprocsupliers> obtsuppliers = evalprosuppliersRepository.findById(evalprocsupid);
					    Evalprocsupliers obtsuppliers1 = new Evalprocsupliers();
					    Evalprocsupliers obtsuppliers3 = new Evalprocsupliers();
					    Suppliers supplier = new Suppliers();
						// Verifico si encontre el suplliers
						if (obtsuppliers.isPresent()) {
							obtsuppliers1 = obtsuppliers.get();
						} else {
							respuesta.setMsg("Registro no encontrado");
							return new ResponseEntity(respuesta, HttpStatus.NOT_FOUND);
						}
						
						Optional<Suppliers> suppliers = suppliersRepository
								.findById(evalprosuplliersActualizarDto.getEvalprocsupid());
						
						if (suppliers.get().getStatus()==2){
							respuesta.setMsg("El estatus del proveedor está en estatus inactivo");
							return new ResponseEntity(respuesta, HttpStatus.BAD_REQUEST);
						} 
						// Construyo los datos de la entidad de externalreqs
						obtsuppliers1
								.setEvalprocsupdependencypar(evalprosuplliersActualizarDto.getEvalprocdependencypar());
						obtsuppliers1.setSupplierid(suppliers.get()); 
						
						// RTO
						if (evalprosuplliersActualizarDto.getRtoperiodpar() == 1)
							// obtsuppliers1.setRtoqty(evalprosuplliersActualizarDto.getRtoqty()*24*60);
							obtsuppliers1.setRtoqty(evalprosuplliersActualizarDto.getRtoqty() * 60);
						
						if (evalprosuplliersActualizarDto.getRtoperiodpar() == 2)
						//	obtsuppliers1.setRtoqty(evalprosuplliersActualizarDto.getRtoqty()*60);
							obtsuppliers1.setRtoqty(evalprosuplliersActualizarDto.getRtoqty() * 24 * 60);
						
						if (evalprosuplliersActualizarDto.getRtoperiodpar() == 3)
							obtsuppliers1.setRtoqty(evalprosuplliersActualizarDto.getRtoqty());
						
						// RPO
						if (evalprosuplliersActualizarDto.getRpoperiodpar() == 1)
							//	obtsuppliers1.setRpoqty(evalprosuplliersActualizarDto.getRpoqty()*24*60);
							obtsuppliers1.setRpoqty(evalprosuplliersActualizarDto.getRpoqty() * 60);
						
						if (evalprosuplliersActualizarDto.getRpoperiodpar() == 2)
							// obtsuppliers1.setRpoqty(evalprosuplliersActualizarDto.getRpoqty()*60);
							obtsuppliers1.setRpoqty(evalprosuplliersActualizarDto.getRpoqty() * 24 * 60);
						
						if (evalprosuplliersActualizarDto.getRpoperiodpar() == 3)
							obtsuppliers1.setRpoqty(evalprosuplliersActualizarDto.getRpoqty());
						
						obtsuppliers1
								.setEvalprocsuprequiredpar(evalprosuplliersActualizarDto.getEvalprocsuprequiredpar());
						obtsuppliers1
								.setRpoevalprocsupperiodpar(evalprosuplliersActualizarDto.getRpoperiodpar().toString());
						obtsuppliers1
								.setRtoevalprocsupperiodpar(evalprosuplliersActualizarDto.getRtoperiodpar().toString());
						obtsuppliers1.setModifiedat(fecha2);

						obtsuppliers3 = evalprosuppliersRepository.save(obtsuppliers1);

						if (obtsuppliers3 != null) {
							module = "Evaluación de Procesos Proveedores";
							Descmodule = "Se actualizó la Evaluación de Procesos " + evalprocessid + " de Proveedores: "
									+ obtsuppliers3.getId();
							auditDto.setIpaddr(HttpReqRespUtils.getClientIpAddressIfServletRequestExist());
							String singo1 = "(";
							String singo2 = ")";
							String usryemail = encontreSessionUsuario.get().getUsr().concat(" ").concat(singo1)
									.concat(encontreSessionUsuario.get().getEmail().concat(singo2));
							auditDto.setUserref(usryemail);
							auditDto.setModule(module);
							auditDto.setDesc(Descmodule);
							auditDto.setCreatedat(fechaDate2);
							usersService.registrarAuditSesion(auditDto);

							RespuestaValueDto respuestaValueDto = new RespuestaValueDto(obtsuppliers3.getId());
							URI location = URI
									.create("/evalprocesses/" + evalprocessid + "/suppliers/" + obtsuppliers3.getId()); // O
																														// la
																														// URL
																														// correcta
																														// para
																														// //
																														// tu
							return ResponseEntity.created(location).body(respuestaValueDto);

						}
					} catch (DataIntegrityViolationException ex) {
			    	    Throwable rootCause = ex.getRootCause();
			    	    String mensajeError = "Error al guardar.";
			    	    HttpStatus estatusError = HttpStatus.CONFLICT;

			    	    if (rootCause instanceof SQLException) {
			    	        SQLException sqlEx = (SQLException) rootCause;
			    	        if (sqlEx.getSQLState() != null && sqlEx.getSQLState().equals("23505")) {
			    	            mensajeError = "Registro Duplicado.";
			    	        } else {
			    	           // mensajeError = "Error de base de datos: " + sqlEx.getMessage();
			    	            mensajeError = "Registro Duplicado: ";
			    	            estatusError = HttpStatus.CONFLICT; // O el estatus que consideres apropiado
			    	            ex.printStackTrace(); // Loguea la excepción para depuración
			    	        }
			    	    } else {
			    	     //   mensajeError = "Registro Duplicado: " + ex.getMessage();
			    	    	 mensajeError = "Registro Duplicado: ";
			    	        estatusError = HttpStatus.CONFLICT; // O el estatus que consideres apropiado
			    	        ex.printStackTrace(); // Loguea la excepción para depuración
			    	    }

						respuesta = new RespuestaMsgDto(mensajeError);
						estatus = estatusError;
						return new ResponseEntity(respuesta, estatus);

			} catch (Exception e) {
						respuesta = new RespuestaMsgDto("Error interno del servidor: " + e.getMessage());
						estatus = HttpStatus.INTERNAL_SERVER_ERROR;
						e.printStackTrace(); // Loguea la excepción para depuración
						return new ResponseEntity(respuesta, estatus);
					} finally {
						if (entityManager != null && entityManager.isOpen()) {
							entityManager.close();
						}
			}
				} else {
					try {
						rolisvalid = auditRepository
								.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(), 202);
						 if (rolisvalid == 0) {
							 respuesta.setMsg("No tiene los Privilegios"); 
							 estatus = HttpStatus.FORBIDDEN;
							 return new ResponseEntity(respuesta, estatus); 
					     }
						 
						Optional<Suppliers> suppliers = suppliersRepository
								.findById(evalprosuplliersActualizarDto.getEvalprocsupid());
						if (suppliers.get().getStatus()==2){
							respuesta.setMsg("El estatus del proveedor está en estatus inactivo");
							return new ResponseEntity(respuesta, HttpStatus.BAD_REQUEST);
						}
						 Evalprocsupliers obtsuppliers1 = new Evalprocsupliers();
						 Evalprocsupliers obtsuppliers3 = new Evalprocsupliers();	
						  // Construyo los datos de la entidad de externalreqs
						obtsuppliers1
								.setEvalprocsupdependencypar(evalprosuplliersActualizarDto.getEvalprocdependencypar());
							obtsuppliers1.setSupplierid(suppliers.get()); 
							
						// RTO
						if (evalprosuplliersActualizarDto.getRtoperiodpar() == 1)
								//	obtsuppliers1.setRtoqty(evalprosuplliersActualizarDto.getRtoqty()*24*60);
							obtsuppliers1.setRtoqty(evalprosuplliersActualizarDto.getRtoqty() * 60);
							
						if (evalprosuplliersActualizarDto.getRtoperiodpar() == 2)
								//	obtsuppliers1.setRtoqty(evalprosuplliersActualizarDto.getRtoqty()*60);
							obtsuppliers1.setRtoqty(evalprosuplliersActualizarDto.getRtoqty() * 24 * 60);
							
						if (evalprosuplliersActualizarDto.getRtoperiodpar() == 3)
								obtsuppliers1.setRtoqty(evalprosuplliersActualizarDto.getRtoqty());
							
						// RPO
						if (evalprosuplliersActualizarDto.getRpoperiodpar() == 1)
							// obtsuppliers1.setRpoqty(evalprosuplliersActualizarDto.getRpoqty()*24*60);
							obtsuppliers1.setRpoqty(evalprosuplliersActualizarDto.getRpoqty() * 60);
							
						if (evalprosuplliersActualizarDto.getRpoperiodpar() == 2)
							// obtsuppliers1.setRpoqty(evalprosuplliersActualizarDto.getRpoqty()*60);
							obtsuppliers1.setRpoqty(evalprosuplliersActualizarDto.getRpoqty() * 24 * 60);

						if (evalprosuplliersActualizarDto.getRpoperiodpar() == 3)
								obtsuppliers1.setRpoqty(evalprosuplliersActualizarDto.getRpoqty());
							
							obtsuppliers1.setEvalprocessid(obtproceso.get());
						obtsuppliers1
								.setEvalprocsuprequiredpar(evalprosuplliersActualizarDto.getEvalprocsuprequiredpar());
						obtsuppliers1
								.setRpoevalprocsupperiodpar(evalprosuplliersActualizarDto.getRpoperiodpar().toString());
						obtsuppliers1
								.setRtoevalprocsupperiodpar(evalprosuplliersActualizarDto.getRtoperiodpar().toString());
							obtsuppliers1.setModifiedat(fecha2);
							obtsuppliers1.setCreatedat(fecha2);

						 obtsuppliers3 = evalprosuppliersRepository.save(obtsuppliers1);

						 if (obtsuppliers3 != null) {
								module = "Evaluación de Procesos Proveedores";
							Descmodule = "Se insertó la Evaluación de Procesos " + evalprocessid + " de Proveedores: "
									+ obtsuppliers3.getId();
								auditDto.setIpaddr(HttpReqRespUtils.getClientIpAddressIfServletRequestExist());
								String singo1 = "(";
								String singo2 = ")";
								String usryemail = encontreSessionUsuario.get().getUsr().concat(" ").concat(singo1)
										.concat(encontreSessionUsuario.get().getEmail().concat(singo2));
								auditDto.setUserref(usryemail);
								auditDto.setModule(module);
								auditDto.setDesc(Descmodule);
								auditDto.setCreatedat(fechaDate2);
								usersService.registrarAuditSesion(auditDto);

								RespuestaValueDto respuestaValueDto = new RespuestaValueDto(obtsuppliers3.getId());
							URI location = URI
									.create("/evalprocesses/" + evalprocessid + "/suppliers/" + obtsuppliers3.getId()); // O
																														// la
																														// URL
																														// correcta
																														// para
																														// //
																														// tu
								return ResponseEntity.created(location).body(respuestaValueDto);
						} else {
								 respuesta.setMsg("No se pudo actualizar por alguna razón");
						     	 estatus = HttpStatus.CONFLICT;
						     	 return new ResponseEntity(respuesta, estatus);
							 }
						 } catch (DataIntegrityViolationException ex) {
						//// estandarice los mensajes a duplicado, ya que todos tienen que ver con temas
						//// de integridad de la data
					    	    Throwable rootCause = ex.getRootCause();
					    	    String mensajeError = "Error al guardar.";
					    	    HttpStatus estatusError = HttpStatus.CONFLICT;

					    	    if (rootCause instanceof SQLException) {
					    	        SQLException sqlEx = (SQLException) rootCause;
					    	        if (sqlEx.getSQLState() != null && sqlEx.getSQLState().equals("23505")) {
					    	            mensajeError = "Registro Duplicado.";
					    	        } else {
					    	           // mensajeError = "Error de base de datos: " + sqlEx.getMessage();
					    	            mensajeError = "Registro Duplicado: ";
					    	            estatusError = HttpStatus.CONFLICT; // O el estatus que consideres apropiado
					    	            ex.printStackTrace(); // Loguea la excepción para depuración
					    	        }
					    	    } else {
					    	     //   mensajeError = "Registro Duplicado: " + ex.getMessage();
					    	    	 mensajeError = "Registro Duplicado: ";
					    	        estatusError = HttpStatus.CONFLICT; // O el estatus que consideres apropiado
					    	        ex.printStackTrace(); // Loguea la excepción para depuración
					    	    }

						respuesta = new RespuestaMsgDto(mensajeError);
						estatus = estatusError;
								return new ResponseEntity(respuesta, estatus);

					} catch (Exception e) {
						respuesta = new RespuestaMsgDto("Error interno del servidor: " + e.getMessage());
						estatus = HttpStatus.INTERNAL_SERVER_ERROR;
								e.printStackTrace(); // Loguea la excepción para depuración
								return new ResponseEntity(respuesta, estatus);
					} finally {
						if (entityManager != null && entityManager.isOpen()) {
							entityManager.close();
						}
					}
				}
			}
			return new ResponseEntity(respuesta, HttpStatus.OK);
		}

	}
	
	@DeleteMapping({ "/evalprocesses/{evalprocessid}/suppliers",
			"/evalprocesses/{evalprocessid}/suppliers/{evalprocsupid}" })
	public ResponseEntity<?> deleteEvalSupplier(HttpServletRequest request,
			@PathVariable("evalprocessid") final Integer evalprocessid,
			@PathVariable(name = "evalprocsupid", required = false) final Integer evalprocsupid) throws ParseException {
		RespuestaMsgDto respuesta = new RespuestaMsgDto("");
		HttpStatus estatus = HttpStatus.FORBIDDEN;
		long cuantosregistro = 0;

		String sessionid = request.getHeader("Authorization");
		Date fecha = new Date();
		SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String dataFormattata = formatter.format(fecha);

		AuditRequestDto auditDto = new AuditRequestDto();
		String module = "";
		String Descmodule = "";
		
		Date fecha3 = new Date();
		SimpleDateFormat formatter2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String dataFormattata2 = formatter.format(fecha3);
		Date fechaDate2 = formatter.parse(dataFormattata2);
		
		Optional<Params> deSessDuration = paramsRepository.findByParamname("SESSION_DURATION");
		String SessionDuration = deSessDuration.get().getValue();
		int duracionSession = Integer.parseInt(SessionDuration);
		Date fecha2 = new Date();
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(fecha2); // tuFechaBase es un Date;
		// calendar.add(Calendar.MINUTE, minutosASumar); //minutosASumar es int.
		calendar.add(Calendar.MINUTE, duracionSession); // horasASumar es int.
		// lo que más quieras sumar
		Date ValidThrufechaSalida = calendar.getTime(); // Y ya tienes la fecha sumada.
		SimpleDateFormat salida = new SimpleDateFormat("yyyy-MM-dd HH:mm"); // 2024-12-23 23:00
		String fechaComoCadena = salida.format(ValidThrufechaSalida);
		System.out.println(fechaComoCadena);
		
		 // Verifico la session 
		if (sessionid == null) {
		  respuesta.setMsg("Llamada al servicio malformado");
			estatus = HttpStatus.BAD_REQUEST;
		  return new ResponseEntity(respuesta, estatus); 
		} else {
			
			int statusCampaigns = campaignsRepository.findStatusCampaignByProcessId(evalprocessid);
			 
			if (statusCampaigns == 0) {
				 
				 String var = "";
					boolean bloked = false;
					RespuestaMsgDto respuestaDto = new RespuestaMsgDto(var);
				// respuestaDto.setBlocked(bloked);
					respuestaDto.setMsg("No tiene los privilegios");
				// Error 400
					return new ResponseEntity(respuestaDto, HttpStatus.FORBIDDEN);
				 
			  }

			sessionid = sessionid.substring(7); // verifico si la sesión del usuario existe.
			Optional<Users> encontreSessionUsuario = usersRepository.getBySessionid(sessionid);
			if (encontreSessionUsuario.isPresent()) { // si la sesión del usuario existe
			  Date FechaReg = encontreSessionUsuario.get().getValidthru(); 
			  // Llamada a la funcion que validad el tiempo de Session, retorna la fecha 
			  // sumandole el tiempo de session activa, y vacio si no esta activa 
				fechaComoCadena = securityService.consultarSessionActiva(FechaReg, fecha2,
						encontreSessionUsuario.get().getId());
			  if (fechaComoCadena == "") { 
				  RespuestaMsgDto respuestaDto2;
				  String var2 = "";
				  boolean bloked2 = false;
				  respuestaDto2 = new RespuestaMsgDto(var2);
				  respuestaDto2.setMsg("Sesión expirada o inválida");
				  return new ResponseEntity(respuestaDto2, HttpStatus.UNAUTHORIZED);
			  }
			  
			  int rolisvalid = 0; 
			  try  {
					
					// verifico si tiene el privilegio
					rolisvalid = auditRepository.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(),
							203);
					if (rolisvalid == 0) {
						respuesta.setMsg("No tiene los Privilegios"); 
						estatus = HttpStatus.FORBIDDEN;
						return new ResponseEntity(respuesta, estatus); 
					}
					
					Optional<Evalprocesses> obtproceso = evalprocessesRepository.findById(evalprocessid);
					Evalprocsupliers evalprocsupliers = new Evalprocsupliers();
					// Verifico si encontre el proceso
				    if (!obtproceso.isPresent()) {
				    	respuesta.setMsg("Registro no encontrado");
						return new ResponseEntity(respuesta, HttpStatus.NOT_FOUND);
				    }
					
					// Verifico si existe el id de externalreqs en la base de datos
					Optional<Evalprocsupliers> obtSuppliers = evalprosuppliersRepository.findById(evalprocsupid);
					Evalprocsupliers suppliers1 = new Evalprocsupliers();
					Evalprocsupliers suppliers2 = new Evalprocsupliers();
					
					// Verifico si encontre el requisito externos
				    if (obtSuppliers.isPresent()) {
						suppliers1 = obtSuppliers.get();
					} else {
				    	respuesta.setMsg("Registro no encontrado");
						return new ResponseEntity(respuesta, HttpStatus.NOT_FOUND);
				    }
				    
				    try {
					    					    
				    	evalprosuppliersRepository.delete(suppliers1);
						
						module = "Evaluación de Procesos Proveedores";
						Descmodule = "Se borró de la Evaluación de Procesos " + evalprocessid + " Proveedores: "
								+ suppliers1.getId();
						auditDto.setIpaddr(HttpReqRespUtils.getClientIpAddressIfServletRequestExist());
						String singo1 = "(";
						String singo2 = ")";
						String usryemail = encontreSessionUsuario.get().getUsr().concat(" ").concat(singo1)
								.concat(encontreSessionUsuario.get().getEmail().concat(singo2));
						auditDto.setUserref(usryemail);
						auditDto.setModule(module);
						auditDto.setDesc(Descmodule);
						auditDto.setCreatedat(fechaDate2);
						usersService.registrarAuditSesion(auditDto);
						
						RespuestaValueDto respuestaValueDto = new RespuestaValueDto(evalprocsupid); 
						URI location = URI.create("/evalprocesses/" + evalprocessid + "/suppliers/" + evalprocsupid); // O
																														// la
																														// URL
																														// correcta
																														// para
																														// //
																														// tu
						return ResponseEntity.created(location).body(respuestaValueDto);
					} catch (Exception e) {
						 respuesta.setMsg("No se pudo borrar por alguna razón");
					     estatus = HttpStatus.CONFLICT;
					     return new ResponseEntity(respuesta, estatus);
					} finally {
						if (entityManager != null && entityManager.isOpen()) {
							entityManager.close();
					} 
					}
				} catch (Exception e) {
					respuesta.setMsg("Error interno. Descripción del error " + e.getMessage());
				     estatus = HttpStatus.INTERNAL_SERVER_ERROR;
				     return new ResponseEntity(respuesta, estatus);
				} finally {
					if (entityManager != null && entityManager.isOpen()) {
						entityManager.close();
					}
				}
			}
			return new ResponseEntity(respuesta, HttpStatus.OK);
		}	
	}
}