package com.dacrt.SBIABackend.controler;

import java.net.URI;
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 java.net.URLDecoder;
import java.nio.charset.StandardCharsets;

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

import org.json.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
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.EntryStrategyDto;
import com.dacrt.SBIABackend.dto.EntryStrategyDto2;
import com.dacrt.SBIABackend.dto.FilterStrategiesDto;
import com.dacrt.SBIABackend.dto.OperationlineDto;
import com.dacrt.SBIABackend.dto.ProcessActualizarDto;
import com.dacrt.SBIABackend.dto.ProcessRemoteDto;
import com.dacrt.SBIABackend.dto.ProcessResponseDto;
import com.dacrt.SBIABackend.dto.ProcessTypeDto;
import com.dacrt.SBIABackend.dto.ProcessesListDto;
import com.dacrt.SBIABackend.dto.StatusDto;
import com.dacrt.SBIABackend.dto.StrategiesActualizarDto;
import com.dacrt.SBIABackend.dto.StrategiesDependencyDto;
import com.dacrt.SBIABackend.dto.StrategiesDependencyDto2;
import com.dacrt.SBIABackend.dto.StrategiesDto;
import com.dacrt.SBIABackend.dto.StrategiesRecordsResponseDto;
import com.dacrt.SBIABackend.dto.StrategiesResponseDto;
import com.dacrt.SBIABackend.dto.StrategiesTypeDto;
import com.dacrt.SBIABackend.dto.StrategiesTypeDto2;
import com.dacrt.SBIABackend.dto.responseDto.StrategiesRecordsResponseDtoF2;
import com.dacrt.SBIABackend.dto.responseDto.StrategiesResponseDtoF2;
import com.dacrt.SBIABackend.entity.Processchannels;
import com.dacrt.SBIABackend.entity.Processes;
import com.dacrt.SBIABackend.entity.Processserviceoffers;
import com.dacrt.SBIABackend.entity.Strategies;
import com.dacrt.SBIABackend.repository.StrategiesRepository;
import com.dacrt.SBIABackend.repository.StrategiesdetRepository;
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.PrivilegesRepository;
import com.dacrt.SBIABackend.security.repository.UsersRepository;
import com.dacrt.SBIABackend.security.service.MenuService;
import com.dacrt.SBIABackend.security.service.SecurityService;
import com.dacrt.SBIABackend.security.service.UsersService;
import com.dacrt.SBIABackend.utils.HttpReqRespUtils;
import java.math.BigInteger;

@RestController
@CrossOrigin(origins = "*")
public class StrategiesController {
	@PersistenceContext
	private EntityManager entityManager;

	@Autowired
	private PrivilegesRepository privilegesRepository;

	@Autowired
	private ParamsRepository paramsRepository;

	@Autowired
	private StrategiesRepository strategiesRepository;

	@Autowired
	private StrategiesdetRepository strategiesdetRepository;

	@Autowired
	private AuditRepository auditRepository;

	@Autowired
	private UsersRepository usersRepository;

	@Autowired
	MenuService menuService;

	@Autowired
	SecurityService securityService;

	@Autowired
	UsersService usersService;

	Logger logger = LoggerFactory.getLogger(StrategiesController.class);

	@PostMapping("/strategies")
	public ResponseEntity<?> listarStrategies(HttpServletRequest request, @RequestBody StrategiesDto filtros)
			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 searchIn = "";
		int statusIn = 0;
		int strategytypeIn = 0;
		int strategydependencyIn = 0;

		String searchModule = "";
		String searchUsr = "";
		String contentIn = "";
		int orderIn = 0;
		int offsetIn = 0;
		int numofrecordsIn = 0;
		int rolisvalid = 0;
		int rolisvalidDRP = 0;
		int formatList = 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);
				}
				
                formatList = filtros.getFormat();
			    
			    if (formatList==0) {
			    	formatList = 1;
			    } else {
			    	formatList = filtros.getFormat();
			    }

				// Obtengo el rol de usuario y verifico si corresponde al privilegio del usuario
				rolisvalid = auditRepository.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(), 300);
				if (formatList!=2) {
			    	if (rolisvalid == 0) {
					respuesta.setMsg("No tiene los Privilegios");
					estatus = HttpStatus.FORBIDDEN;
					return new ResponseEntity(respuesta, estatus);
			     	}
				}
				
				
				
				// Obtengo los datos del Body
				//searchIn = filtros.getFilters().getSearch();// dato de busqueda por nombre
				searchIn = filtros.getFilters().getSearch();
				
				 String Salida = usersService.verificarCaracteresValidosConRegex(searchIn);
				  
				  if (Salida=="NOOK") {
					  String var = "";
						boolean bloked = false;
						RespuestaMsgDto respuestaDto = new RespuestaMsgDto(var);
						//respuestaDto.setBlocked(bloked);
						respuestaDto.setMsg("Caracteres no permitidos en la busqueda"); 
						return new ResponseEntity(respuestaDto, HttpStatus.BAD_REQUEST);
				  }
				  
				searchIn = usersService.eliminarAcentosService(filtros.getFilters().getSearch());
				statusIn = filtros.getFilters().getStatus();// dato de busqueda por status
				strategytypeIn = filtros.getFilters().getStrategytype() == "" ? 0
						: Integer.parseInt(filtros.getFilters().getStrategytype());
				
				strategydependencyIn = filtros.getFilters().getStrategydependency() == "" ? 0
						: Integer.parseInt(filtros.getFilters().getStrategydependency());
				orderIn = filtros.getOrder(); // Orden Ascedente o Descendente
				offsetIn = filtros.getOffset();// Primer registro a mostrar
				numofrecordsIn = filtros.getNumofrecords();// Número de registros a mostrar
				contentIn = filtros.getContent();
				
				
				
				//Filtro por el privilegio 314
				rolisvalid = auditRepository.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(), 300);
				rolisvalidDRP = auditRepository.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(), 314);
					
				
				if (rolisvalidDRP==0) {
					strategytypeIn=1;	//BCP
				}	
				
				if (strategydependencyIn==5 && rolisvalidDRP==0) {
					strategytypeIn=1;	//BCP
					
				}
				
				
				// Verifico los Shorcouts
				if (contentIn != null && contentIn != "")
					menuService.iscontentdiffnull(contentIn, encontreSessionUsuario.get().getId());
			} 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);
			}

			try {
				// Sentencia General
				String QueryTotal = "";
				String id = "s.id"; // id de estrategia
				String name = "s.name"; // buscar por nombre
				String status = "s.status"; // buscar por status
				String strategytype = "s.strategytypepar"; // buscar por tipo de estrategia
				String strategydependency = "s.strategydependencypar"; // buscar por tipo de dependencia
				String lowername = "main.sinacentos(LOWER(s.name))"; // se convierte en minúscula
				String lowerdsc = "main.sinacentos(LOWER(s.dsc))"; // se convierte en minúscula
				String LowerSearch = searchIn.toLowerCase(); // se convierte en minúscula

				StrategiesRecordsResponseDto strategiesRecordsResponseDto = new StrategiesRecordsResponseDto();
				StrategiesRecordsResponseDtoF2 strategiesRecordsResponseDtoF2 = new StrategiesRecordsResponseDtoF2();
				StatusDto statusDto = new StatusDto();
				StrategiesTypeDto strategiesTypeDto = new StrategiesTypeDto();
				StrategiesDependencyDto strategiesDependencyDto = new StrategiesDependencyDto();
				List<StrategiesTypeDto> strategiesTypeList = new ArrayList();
				List<StrategiesDependencyDto> strategiesDependencyList = new ArrayList();
				List<StrategiesRecordsResponseDto> strategiesRecordsResponseList = new ArrayList();
				List<StrategiesRecordsResponseDtoF2> strategiesRecordsResponseListF2 = new ArrayList();
				StrategiesResponseDto strategiesResponseDto = new StrategiesResponseDto();
				StrategiesResponseDtoF2 strategiesResponseDtoF2 = new StrategiesResponseDtoF2();

				PrivilegesAllDto detallePrivilege = new PrivilegesAllDto();
				String SentenciaBase;
				if (formatList==2) {
					 SentenciaBase = "SELECT s.id, s.name, s.dsc, s.status, "
					 		+ "                     CASE WHEN s.status = 1 THEN 'Activo' ELSE 'Inactivo' END AS descStatus, "
					 		+ "                     s.strategytypepar, st.descr tipoestrategia, "
							+ "                     s.strategydependencypar, sd.descr tipodependencia "
							+ " FROM                main.strategies  s "
							+ " LEFT JOIN           (SELECT elemento ->> 'dsc' AS descr,elemento ->> 'value' AS valor "
							+ "                     FROM main.params p,jsonb_array_elements(CAST(p.value AS jsonb)) AS elemento "
							+ "                     WHERE p.paramname = 'STRATEGY_TYPE' ) st ON s.strategytypepar = CAST(st.valor AS integer)"
							+ " LEFT JOIN           (SELECT elemento ->> 'dsc' AS descr,elemento ->> 'value' AS valor "
							+ "                     FROM main.params p,jsonb_array_elements(CAST(p.value AS jsonb)) AS elemento "
							+ "                     WHERE p.paramname = 'STRATEGY_DEPENDENCY' ) sd ON s.strategydependencypar = CAST(sd.valor AS integer)";
				} else {
			     	 SentenciaBase = "SELECT s.id, s.name, s.dsc, s.status, "
				 		+ "                     CASE WHEN s.status = 1 THEN 'Activo' ELSE 'Inactivo' END AS descStatus,"
						+ "                     s.strategytypepar, st.descr tipoestrategia, "
						+ "                     s.strategydependencypar, sd.descr tipodependencia, "
						+ "                     (select count(*) from main.strategiesdet std where std.strategyid=s.id) AS cant_strategias "
						+ " FROM                main.strategies            s "
						+ " LEFT JOIN           (SELECT elemento ->> 'dsc' AS descr,elemento ->> 'value' AS valor "
						+ "                     FROM main.params p,jsonb_array_elements(CAST(p.value AS jsonb)) AS elemento "
						+ "                     WHERE p.paramname = 'STRATEGY_TYPE' ) st ON s.strategytypepar = CAST(st.valor AS integer)"
						+ " LEFT JOIN           (SELECT elemento ->> 'dsc' AS descr,elemento ->> 'value' AS valor "
						+ "                     FROM main.params p,jsonb_array_elements(CAST(p.value AS jsonb)) AS elemento "
						+ "                     WHERE p.paramname = 'STRATEGY_DEPENDENCY' ) sd ON s.strategydependencypar = CAST(sd.valor AS integer)";
				}
				QueryTotal = SentenciaBase + " WHERE 1=1 ";
		if (formatList==1) {		
				switch (searchIn) {
				case "":
					QueryTotal = SentenciaBase + " AND 1=1 ";
					break;
				default: // viene con el parametro para buscar por el like
					QueryTotal = SentenciaBase + " WHERE (" + lowername + " LIKE main.sinacentos( " + "'%" + LowerSearch + "%')" + " OR "
							+ lowerdsc + " LIKE main.sinacentos(" + "'%" + LowerSearch + "%')" + " ) ";
					break;
				}
		 }
				switch (statusIn) {
				case 0:
					QueryTotal = QueryTotal + " AND 1=1 ";
					break;
				case 1:
					QueryTotal = QueryTotal + " AND s.status = 1 ";
					break;
				case 2:
					QueryTotal = QueryTotal + " AND s.status = 0 ";
					break;
				default:
					respuesta.setMsg("Llamada al servicio malformado");
					estatus = HttpStatus.BAD_REQUEST;
					return new ResponseEntity(respuesta, estatus);
				}
				
				switch (strategydependencyIn) {
				case 0:
					QueryTotal = QueryTotal + " AND 1=1 ";
					break;
				default:
					QueryTotal = QueryTotal + " AND s.strategydependencypar = " + strategydependencyIn;
					break;
				}
		
				switch (strategytypeIn) {
				case 0:
					QueryTotal = QueryTotal + " AND 1=1 ";
					break;
				default:
					QueryTotal = QueryTotal + " AND s.strategytypepar = " + strategytypeIn;
					break;
				}
		
		if (formatList==1) {
		
				switch (orderIn) {
				case 1: // ordena por tipo y nombre ascendente
					QueryTotal = QueryTotal + " ORDER BY " + strategytype + ", " + name + " ASC";
					break;

				case 2:// ordena dependencia y nombre
					QueryTotal = QueryTotal + " ORDER BY " + strategydependency + ", " + name + " ASC";
					break;

				case 3: // ordena por nombre
					QueryTotal = QueryTotal + " ORDER BY " + name + " ASC";
					break;

				case 4:// ordena por status
					QueryTotal = QueryTotal + " ORDER BY " + status + " ASC";
					break;

				case 99: // ordena por el id de strategies ORDER BY " + id + " ASC";
					QueryTotal = QueryTotal + " ORDER BY " + id + " ASC";
					break;

				case -1:// // ordena por tipo y nombre descendente
					QueryTotal = QueryTotal + " ORDER BY " + strategytype + ", " + name + " DESC";
					break;

				case -2:// ordena dependencia y nombre descendente
					QueryTotal = QueryTotal + " ORDER BY " + strategydependency + ", " + name + " DESC";
					break;

				case -3:// ordena por nombre
					QueryTotal = QueryTotal + " ORDER BY " + name + " DESC";
					break;
				
				case -4:// ordena por status
					QueryTotal = QueryTotal + " ORDER BY " + status + " DESC";
					break;

				case -99: // ordena por el id de proceso descendente
					QueryTotal = QueryTotal + " ORDER BY " + id + " DESC";
					break;

				default:
					respuesta.setMsg("Error el ordenamiento no es el correcto");
					estatus = HttpStatus.BAD_REQUEST;
					return new ResponseEntity(respuesta, estatus);
				}
		} 
		
		if (formatList==2) {
			QueryTotal = QueryTotal + " ORDER BY " + name + " ASC";
		}
			
				Query query;
				Query query2;
				Query query3;

				String QueryTypes = "SELECT CAST(elem AS TEXT) " + "	FROM main.params pa, "
						+ "	jsonb_array_elements(CAST(pa.value AS jsonb)) AS elem "
						+ "	WHERE pa.paramname = 'STRATEGY_TYPE' ";

				String QueryDependency = "SELECT CAST(elem AS TEXT) " + "	FROM main.params pa, "
						+ "	jsonb_array_elements(CAST(pa.value AS jsonb)) AS elem "
						+ "	WHERE pa.paramname = 'STRATEGY_DEPENDENCY' ";

				query = entityManager.createNativeQuery(QueryTotal);
				cuantosregistro = (long) query.getResultList().size();
				 if (formatList==1) {
			     	query.setFirstResult(offsetIn);
			     	query.setMaxResults(numofrecordsIn);
				 }
				List<Object[]> resultados = query.getResultList();
				
				List<Object[]> resultadosTypes;
				List<Object[]> resultadosDependency;
				StrategiesTypeDto tipoStrategies = new StrategiesTypeDto();
				StrategiesDependencyDto tipoDependency = new StrategiesDependencyDto();
              //strategiesRecordsResponseDtoF2
				StrategiesTypeDto2 tipoStrategies2 = new StrategiesTypeDto2();
				StrategiesDependencyDto2 tipoDependency2 = new StrategiesDependencyDto2();
				List<StrategiesDependencyDto2> strategiesDependencyList2 = new ArrayList();
				List<StrategiesTypeDto2> strategiesTypeList2 = new ArrayList();
				String urlDecodificada = "";
			  if (formatList==2) {
				if (cuantosregistro > 0) {
					for (Object[] fila : resultados) {
						strategiesRecordsResponseDtoF2.setId((int) fila[0]);
						strategiesRecordsResponseDtoF2.setName((String) fila[1]);
						strategiesRecordsResponseDtoF2.setDsc((String) fila[2]);
						statusDto.setId((int) fila[3]);
						statusDto.setName((String) fila[4]);
						
						strategiesRecordsResponseDtoF2.setStatus(statusDto);
                        strategiesTypeDto.setId((int) fila[5]);
						
						urlDecodificada = (String) fila[6];
					    urlDecodificada = URLDecoder.decode(urlDecodificada,StandardCharsets.UTF_8.toString());
						strategiesTypeDto.setDsc(urlDecodificada);
						//strategiesRecordsResponseDto.setType(strategiesTypeDto);
					     
						strategiesRecordsResponseDtoF2.setType(strategiesTypeDto);
						
						strategiesDependencyDto.setId((int) fila[7]);
						strategiesDependencyDto.setDsc((String) fila[8]);
						strategiesRecordsResponseDtoF2.setDependency(strategiesDependencyDto);
						
						strategiesRecordsResponseListF2.add(strategiesRecordsResponseDtoF2);
						strategiesRecordsResponseDtoF2 = new StrategiesRecordsResponseDtoF2();
						strategiesTypeDto = new StrategiesTypeDto();
						strategiesDependencyDto = new StrategiesDependencyDto();
						//StrategiesRecordsResponseDtoF2 strategiesRecordsResponseDtoF2 

						statusDto = new StatusDto();
						
					}
					//strategiesResponseDtoF2.setNumofrecords(cuantosregistro);
					strategiesResponseDtoF2.setRecords(strategiesRecordsResponseListF2);
					strategiesResponseDtoF2.setSessionvalidthru(fechaComoCadena);
                     return new ResponseEntity(strategiesResponseDtoF2, HttpStatus.OK);
				}	 else {
				//	strategiesResponseDtoF2.setNumofrecords(cuantosregistro);
					strategiesResponseDtoF2.setRecords(strategiesRecordsResponseListF2);
					strategiesResponseDtoF2.setSessionvalidthru(fechaComoCadena);
                     return new ResponseEntity(strategiesResponseDtoF2, HttpStatus.OK);
				}
			} else	{
				if (cuantosregistro > 0) {
					for (Object[] fila : resultados) {
						strategiesRecordsResponseDto.setId((int) fila[0]);
						strategiesRecordsResponseDto.setName((String) fila[1]);
						strategiesRecordsResponseDto.setDsc((String) fila[2]);

						statusDto.setId((int) fila[3]);
						statusDto.setName((String) fila[4]);
						strategiesRecordsResponseDto.setStatus(statusDto);

						strategiesTypeDto.setId((int) fila[5]);
						
						urlDecodificada = (String) fila[6];
					    urlDecodificada = URLDecoder.decode(urlDecodificada,StandardCharsets.UTF_8.toString());
						strategiesTypeDto.setDsc(urlDecodificada);
						strategiesRecordsResponseDto.setType(strategiesTypeDto);

						strategiesDependencyDto.setId((int) fila[7]);
						strategiesDependencyDto.setDsc((String) fila[8]);
						strategiesRecordsResponseDto.setDependency(strategiesDependencyDto);
						strategiesRecordsResponseDto.setStrategiesdet(((BigInteger) fila[9]).intValue());
						strategiesRecordsResponseList.add(strategiesRecordsResponseDto);
						strategiesRecordsResponseDto = new StrategiesRecordsResponseDto();

						strategiesTypeDto = new StrategiesTypeDto();
						strategiesDependencyDto = new StrategiesDependencyDto();
						statusDto = new StatusDto();
					}

					// Se construye el Dto de Roles de Respuesta según los privilegios que
					// tenga el usuario
					rolisvalid = 0;
					detallePrivilege = new PrivilegesAllDto();
					rolisvalid = auditRepository.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(),
							301);
					if (rolisvalid > 0)
						detallePrivilege.setUpdate(true);
					else
						detallePrivilege.setUpdate(false);

					rolisvalid = 0;
					rolisvalid = auditRepository.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(),
							300);
					if (rolisvalid > 0)
						detallePrivilege.setView(true);
					else
						detallePrivilege.setView(false);

					rolisvalid = 0;
					rolisvalid = auditRepository.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(),
							302);
					if (rolisvalid > 0)
						detallePrivilege.setAdd(true);
					else
						detallePrivilege.setAdd(false);

					rolisvalid = 0;
					rolisvalid = auditRepository.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(),
							303);
					if (rolisvalid > 0)
						detallePrivilege.setDelete(true);
					else
						detallePrivilege.setDelete(false);

					query2 = entityManager.createNativeQuery(QueryTypes);
					resultadosTypes = query2.getResultList();
					JSONObject jsonObject;
					String jsonStringTipo = "";
					if (resultadosTypes.size() > 0) {
						for (Object tipos : resultadosTypes) {
							jsonStringTipo = (String) tipos; // Recupera el JSON como String
							jsonObject = new JSONObject(jsonStringTipo); // Convierte String a JSONObject
							// Extrae los valores del JSONObject
							String ids = jsonObject.getString("value");
							String dsc = jsonObject.getString("dsc");

							if (rolisvalidDRP>0) {
							tipoStrategies2.setDsc(dsc);
							tipoStrategies2.setValue(Integer.parseInt(ids));
							strategiesTypeList2.add(tipoStrategies2);
							}else {
								if (ids.compareTo("1")==0) {
									tipoStrategies2.setDsc(dsc);
									tipoStrategies2.setValue(Integer.parseInt(ids));
									strategiesTypeList2.add(tipoStrategies2);
								}
								
							}

							tipoStrategies2 = new StrategiesTypeDto2();
						}
					}

					query3 = entityManager.createNativeQuery(QueryDependency);
					resultadosDependency = query3.getResultList();
					String jsonStringDependency = "";
					if (resultadosDependency.size() > 0) {
						for (Object dependency : resultadosDependency) {
							jsonStringDependency = (String) dependency; // Recupera el JSON como String
							jsonObject = new JSONObject(jsonStringDependency); // Convierte String a JSONObject
							// Extrae los valores del JSONObject
							String ids = jsonObject.getString("value");
							String dsc = jsonObject.getString("dsc");

							tipoDependency2.setDsc(dsc);
							tipoDependency2.setValue(Integer.parseInt(ids));
							strategiesDependencyList2.add(tipoDependency2);
							tipoDependency2 = new StrategiesDependencyDto2();
						}
					}

					strategiesResponseDto.setNumofrecords(cuantosregistro);
					strategiesResponseDto.setRecords(strategiesRecordsResponseList);
					strategiesResponseDto.setSessionvalidthru(fechaComoCadena);
					strategiesResponseDto.setTypes(strategiesTypeList2);
					strategiesResponseDto.setDependencies(strategiesDependencyList2);
					strategiesResponseDto.setPrivileges(detallePrivilege);
				} else {
					// Se construye el Dto de Roles de Respuesta según los privilegios que
					// tenga el usuario
					rolisvalid = 0;
					detallePrivilege = new PrivilegesAllDto();
					rolisvalid = auditRepository.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(),
							301);
					if (rolisvalid > 0)
						detallePrivilege.setUpdate(true);
					else
						detallePrivilege.setUpdate(false);

					rolisvalid = 0;
					rolisvalid = auditRepository.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(),
							300);
					if (rolisvalid > 0)
						detallePrivilege.setView(true);
					else
						detallePrivilege.setView(false);

					rolisvalid = 0;
					rolisvalid = auditRepository.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(),
							302);
					if (rolisvalid > 0)
						detallePrivilege.setAdd(true);
					else
						detallePrivilege.setAdd(false);

					rolisvalid = 0;
					rolisvalid = auditRepository.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(),
							303);
					if (rolisvalid > 0)
						detallePrivilege.setDelete(true);
					else
						detallePrivilege.setDelete(false);

					query2 = entityManager.createNativeQuery(QueryTypes);
					resultadosTypes = query2.getResultList();
					JSONObject jsonObject;
					String jsonStringTipo = "";
					if (resultadosTypes.size() > 0) {
						for (Object tipos : resultadosTypes) {
							jsonStringTipo = (String) tipos; // Recupera el JSON como String
							jsonObject = new JSONObject(jsonStringTipo); // Convierte String a JSONObject
							// Extrae los valores del JSONObject
							String ids = jsonObject.getString("value");
							String dsc = jsonObject.getString("dsc");

							if (rolisvalidDRP>0) {
							tipoStrategies2.setDsc(dsc);
							tipoStrategies2.setValue(Integer.parseInt(ids));
							strategiesTypeList2.add(tipoStrategies2);
							}else {
								if (ids.compareTo("1")==0) {
									tipoStrategies2.setDsc(dsc);
									tipoStrategies2.setValue(Integer.parseInt(ids));
									strategiesTypeList2.add(tipoStrategies2);
								}
								
							}
							
							tipoStrategies2 = new StrategiesTypeDto2();
						}
					}

					query3 = entityManager.createNativeQuery(QueryDependency);
					resultadosDependency = query3.getResultList();
					String jsonStringDependency = "";
					if (resultadosDependency.size() > 0) {
						for (Object dependency : resultadosDependency) {
							jsonStringDependency = (String) dependency; // Recupera el JSON como String
							jsonObject = new JSONObject(jsonStringDependency); // Convierte String a JSONObject
							// Extrae los valores del JSONObject
							String ids = jsonObject.getString("value");
							String dsc = jsonObject.getString("dsc");

							tipoDependency2.setDsc(dsc);
							tipoDependency2.setValue(Integer.parseInt(ids));
							strategiesDependencyList2.add(tipoDependency2);
							tipoDependency2 = new StrategiesDependencyDto2();
						}
					}

					strategiesResponseDto.setNumofrecords(cuantosregistro);
					strategiesResponseDto.setRecords(strategiesRecordsResponseList);
					strategiesResponseDto.setSessionvalidthru(fechaComoCadena);
					strategiesResponseDto.setTypes(strategiesTypeList2);
					strategiesResponseDto.setDependencies(strategiesDependencyList2);
					strategiesResponseDto.setPrivileges(detallePrivilege);

				}

				return new ResponseEntity(strategiesResponseDto, 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();
		        }
		    }
		}
		return new ResponseEntity(respuesta, HttpStatus.OK);
	}

	@GetMapping("/strategies/{strategyid}")
	public ResponseEntity<?> ObtenerStrategies(HttpServletRequest request,
			@PathVariable("strategyid") final Integer strategyid) 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 searchModule = "";
		String searchUsr = "";
		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(), 300);
				if (rolisvalid == 0) {
					respuesta.setMsg("No tiene los Privilegios");
					estatus = HttpStatus.FORBIDDEN;
					return new ResponseEntity(respuesta, estatus);
				}

			} 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);
			}

			try {

				EntryStrategyDto entryStrategyDto = new EntryStrategyDto();
				EntryStrategyDto2 entryStrategyDto2 = new EntryStrategyDto2();
				StatusDto statusDto = new StatusDto();
				StrategiesTypeDto strategiesTypeDto = new StrategiesTypeDto();
				StrategiesDependencyDto strategiesDependencyDto = new StrategiesDependencyDto();
				List<EntryStrategyDto> entryStrategyDtoList = new ArrayList();

				String SentenciaBase = "SELECT s.id, s.name,s.dsc, s.status, "
						+ "                     CASE WHEN s.status = 1 THEN 'Activo' ELSE 'Inactivo' END AS descStatus,"
						+ "                     s.strategytypepar, st.descr tipoestrategia, "
						+ "                     s.strategydependencypar, sd.descr tipodependencia "
						+ " FROM                main.strategies            s "
						+ " LEFT JOIN           (SELECT elemento ->> 'dsc' AS descr,elemento ->> 'value' AS valor "
						+ "                     FROM main.params p,jsonb_array_elements(CAST(p.value AS jsonb)) AS elemento "
						+ "                     WHERE p.paramname = 'STRATEGY_TYPE' ) st ON s.strategytypepar = CAST(st.valor AS integer)"
						+ " LEFT JOIN           (SELECT elemento ->> 'dsc' AS descr,elemento ->> 'value' AS valor "
						+ "                     FROM main.params p,jsonb_array_elements(CAST(p.value AS jsonb)) AS elemento "
						+ "                     WHERE p.paramname = 'STRATEGY_DEPENDENCY' ) sd ON s.strategydependencypar = CAST(sd.valor AS integer) "
						+ " WHERE s.id = :strategyid ";

				Query query;

				query = entityManager.createNativeQuery(SentenciaBase);
				query.setParameter("strategyid", strategyid);
				cuantosregistro = (long) query.getResultList().size();
				query.setFirstResult(offsetIn);
				query.setMaxResults(numofrecordsIn);
				List<Object[]> resultados = query.getResultList();
				List<Object[]> resultadosTypes;
				List<Object[]> resultadosDependency;
				StrategiesTypeDto tipoStrategies = new StrategiesTypeDto();
				StrategiesDependencyDto tipoDependency = new StrategiesDependencyDto();

				StrategiesTypeDto2 tipoStrategies2 = new StrategiesTypeDto2();
				StrategiesDependencyDto2 tipoDependency2 = new StrategiesDependencyDto2();
				List<StrategiesDependencyDto2> strategiesDependencyList2 = new ArrayList();
				List<StrategiesTypeDto2> strategiesTypeList2 = new ArrayList();

				if (cuantosregistro > 0) {
					for (Object[] fila : resultados) {
						entryStrategyDto.setId((int) fila[0]);
						entryStrategyDto.setName((String) fila[1]);
						entryStrategyDto.setDsc((String) fila[2]);

						statusDto.setId((int) fila[3]);
						statusDto.setName((String) fila[4]);
						entryStrategyDto.setStatus(statusDto);

						strategiesTypeDto.setId((int) fila[5]);
						strategiesTypeDto.setDsc((String) fila[6]);
						entryStrategyDto.setType(strategiesTypeDto);

						strategiesDependencyDto.setId((int) fila[7]);
						strategiesDependencyDto.setDsc((String) fila[8]);
						entryStrategyDto.setDependency(strategiesDependencyDto);
						
						entryStrategyDto2.setEntry(entryStrategyDto);
					}

					return new ResponseEntity(entryStrategyDto2, HttpStatus.OK);
				} else {
					respuesta.setMsg("Registro no encontrado");
					return new ResponseEntity(respuesta, HttpStatus.NOT_FOUND);
				}

			} catch (Exception e) {
				respuesta.setMsg("Error interno del servidor " + e.getMessage());
				estatus = HttpStatus.INTERNAL_SERVER_ERROR;
			} finally {
		        if (entityManager != null && entityManager.isOpen()) {
		            entityManager.close();
		        }
		    }
		}
		return new ResponseEntity(respuesta, HttpStatus.OK);
	}

	@PostMapping("/strategies/{strategyid}")
	public ResponseEntity<?> ActualizarStrategies(HttpServletRequest request,
			@RequestBody StrategiesActualizarDto strategiesActualizarDto,
			@PathVariable("strategyid") final Integer strategyid) 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 {
			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;
				//ver si tiene el privilegio de DRP
				rolisvalid = auditRepository.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(), 314);

				if (rolisvalid==0 && strategiesActualizarDto.getStrategytypepar()==2){
					respuesta.setMsg("No tiene los Privilegios");
					estatus = HttpStatus.FORBIDDEN;
					return new ResponseEntity(respuesta, estatus);
				}
				
				
				 String Salida = usersService.verificarCaracteresValidosConRegex(strategiesActualizarDto.getName());
				  
				  if (Salida=="NOOK") {
					  String var = "";
						boolean bloked = false;
						RespuestaMsgDto respuestaDto = new RespuestaMsgDto(var);
						//respuestaDto.setBlocked(bloked);
						respuestaDto.setMsg("Caracteres no permitidos en la busqueda"); 
						return new ResponseEntity(respuestaDto, HttpStatus.BAD_REQUEST);
				  }
				  
				  
				if (strategyid != 0) {// actualizar strategies
					try {
						// verifico si tiene el privilegio
						rolisvalid = auditRepository
								.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(), 301);
						if (rolisvalid == 0) {
							respuesta.setMsg("No tiene los Privilegios");
							estatus = HttpStatus.FORBIDDEN;
							return new ResponseEntity(respuesta, estatus);
						}

						// Verificar si el campo nombre no puede ser vacío
						if (strategiesActualizarDto.getName() == "") {
							String var = "";
							RespuestaMsgDto respuestaDto = new RespuestaMsgDto(var);
							respuestaDto.setMsg("El campo nombre no puede serº vacío");
							return new ResponseEntity(respuestaDto, HttpStatus.BAD_REQUEST);
						}

						// Verifico si existe el id de strategies en la base de datos
						Optional<Strategies> obtStrategies = strategiesRepository.findById(strategyid);
						Strategies strategies = new Strategies();
						Strategies strategies2 = new Strategies();
						// Verifico si encontre la estrategia
						if (obtStrategies != null) {
							strategies = obtStrategies.get();
						} else {
							respuesta.setMsg("Registro no encontrado");
							return new ResponseEntity(respuesta, HttpStatus.NOT_FOUND);
						}

						// Verificar si el nombre de la estrategia existe en la base de datos
						if (strategiesRepository.existsByName(strategiesActualizarDto.getName()) && strategiesRepository
								.getByName(strategiesActualizarDto.getName()).get().getId() != strategyid) {
							respuesta.setMsg("Registro Duplicado");
							return new ResponseEntity(respuesta, HttpStatus.CONFLICT);
						}

						int contarStrategies=strategiesdetRepository.contarStrategies(strategyid);
						//Aquí se restringe la actualización de la estrategia si tiene estrategias detalladas 
						if (contarStrategies>0) { //solo se actualiza el estatus y la descripción
							strategies.setStatus(strategiesActualizarDto.getStatus());
							strategies.setDsc(strategiesActualizarDto.getDsc());
							strategies.setModifiedat(fecha2);
						}else { //sino se actualiza todo
						strategies.setStatus(strategiesActualizarDto.getStatus());
						strategies.setName(strategiesActualizarDto.getName());
						strategies.setDsc(strategiesActualizarDto.getDsc());
						strategies.setStrategydependencypar(strategiesActualizarDto.getStrategydependencypar());
						strategies.setStrategytypepar(strategiesActualizarDto.getStrategytypepar());
						strategies.setModifiedat(fecha2);
						}
						

						strategies2 = strategiesRepository.save(strategies);
						if (strategies2 != null) {
							module = "Estrategias Generales";
							Descmodule = "Se actualizó la Estrategia General: " + strategies2.getName();
							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(strategies2.getId());
							URI location = URI.create("/strategies/" + strategies2.getId()); // O la URL correcta para // tu
																					// recurso

							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 (Exception e) {
						respuesta.setMsg("Error interno del servidor ");
						estatus = HttpStatus.INTERNAL_SERVER_ERROR;
					}
				} else {
					try {
						// verifico si tiene el privilegio
						rolisvalid = auditRepository
								.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(), 302);
						if (rolisvalid == 0) {
							respuesta.setMsg("No tiene los Privilegios");
							estatus = HttpStatus.FORBIDDEN;
							return new ResponseEntity(respuesta, estatus);
						}

						// Verificar si el campo nombre no puede ser vacío
						if (strategiesActualizarDto.getName() == "") {
							String var = "";
							RespuestaMsgDto respuestaDto = new RespuestaMsgDto(var);
							respuestaDto.setMsg("El campo nombre no puede ser vacío");
							return new ResponseEntity(respuestaDto, HttpStatus.BAD_REQUEST);
						}

						// Verificar si el registro está duplicado el nombre en la base de datos
						if (strategiesRepository.existsByName(strategiesActualizarDto.getName())) {
							String var = "";
							RespuestaMsgDto respuestaDto = new RespuestaMsgDto(var);
							respuestaDto.setMsg("Registro Duplicado");
							return new ResponseEntity(respuestaDto, HttpStatus.CONFLICT);
						}

						// Construyo los datos de la entidad estrategia
						Strategies strategies = new Strategies();
						Strategies strategies2 = new Strategies();
						strategies.setStatus(strategiesActualizarDto.getStatus());
						strategies.setName(strategiesActualizarDto.getName());
						strategies.setDsc(strategiesActualizarDto.getDsc());
						strategies.setStrategydependencypar(strategiesActualizarDto.getStrategydependencypar());
						strategies.setStrategytypepar(strategiesActualizarDto.getStrategytypepar());
						strategies.setModifiedat(fecha2);
						strategies.setCreatedat(fecha2);

						strategies2 = strategiesRepository.save(strategies);

						if (strategies2 != null) {
							module = "Estrategias Generales";
							Descmodule = "Se agregó la Estrategia General: " + strategies2.getName();
							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(strategies2.getId());
							URI location = URI.create("/strategies/" + strategies2.getId()); // O la URL correcta para // tu
																					// recurso

							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 (Exception e) {
						respuesta.setMsg("Error interno del servidor ");
						estatus = HttpStatus.INTERNAL_SERVER_ERROR;
					}
				}

			} 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, HttpStatus.OK);
	}

	@DeleteMapping("/strategies/{strategyid}")
	public ResponseEntity<?> borrarStrategies(HttpServletRequest request,
			@RequestBody @PathVariable("strategyid") final Integer strategyid) 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 {
			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;
				rolisvalid = auditRepository.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(), 303);
				if (rolisvalid == 0) {
					respuesta.setMsg("No tiene los Privilegios");
					estatus = HttpStatus.FORBIDDEN;
					return new ResponseEntity(respuesta, estatus);
				}

				// Verifico si existe el id de strategies en la base de datos
				Optional<Strategies> obtStrategies = strategiesRepository.findById(strategyid);
				Strategies strategies = new Strategies();
				// Verifico si encontre la estrategia
				if (obtStrategies.isPresent()) {
					strategies = obtStrategies.get();
				} else {
					respuesta.setMsg("Registro no encontrado");
					return new ResponseEntity(respuesta, HttpStatus.NOT_FOUND);
				}

				try {

					strategiesRepository.borrarStrategies(strategies.getId());
					module = "Estrategias Generales";
					Descmodule = "Se borró la Estrategia General: " + strategies.getName();
					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(strategyid);
					URI location = URI.create("/strategies/" + strategyid); // O la URL correcta para // tu recurso

					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);
				}

			} 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);
			}
		}

	}
}