package com.dacrt.SBIABackend.controler;

import java.math.BigInteger;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
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.util.UUID;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;
import javax.persistence.TypedQuery;
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.beans.factory.annotation.Value;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.jdbc.core.JdbcTemplate;
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.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.dacrt.SBIABackend.security.dto.AuditAllDto;
import com.dacrt.SBIABackend.security.dto.AuditAllResponseDto;
import com.dacrt.SBIABackend.security.dto.AuditDtoMod;
import com.dacrt.SBIABackend.security.dto.AuditModResponseDto;
import com.dacrt.SBIABackend.security.dto.AuditRequestDto;
import com.dacrt.SBIABackend.security.dto.MenuResponseDto;
import com.dacrt.SBIABackend.dto.UnitsDto;
import com.dacrt.SBIABackend.dto.UnitsDtoStatus;
import com.dacrt.SBIABackend.dto.UnitsProcessesDetailDto;
import com.dacrt.SBIABackend.dto.UnitsUsersDto;
import com.dacrt.SBIABackend.dto.VicepresidencyDto;
import com.dacrt.SBIABackend.dto.WorkersDto;
import com.dacrt.SBIABackend.dto.requestDto.UnitsRequestNewDto;
import com.dacrt.SBIABackend.dto.CampaignFormat2Dto;
import com.dacrt.SBIABackend.dto.CampaingDtoStatus;
import com.dacrt.SBIABackend.dto.ChannelsDtoStatus;
import com.dacrt.SBIABackend.dto.FacilityDto;
import com.dacrt.SBIABackend.dto.ProcessTypeDto2;
import com.dacrt.SBIABackend.dto.RecordCatalogoResponseDto;
import com.dacrt.SBIABackend.dto.StatusDto;
import com.dacrt.SBIABackend.dto.SuppliersDtoStatus;
import com.dacrt.SBIABackend.dto.TypeUnitDto;
import com.dacrt.SBIABackend.dto.TypesUnitDto;
import com.dacrt.SBIABackend.dto.UnitDetailDto;
import com.dacrt.SBIABackend.dto.UnitDetalleDto;
import com.dacrt.SBIABackend.dto.responseDto.UnitDetailsResponseDto;
import com.dacrt.SBIABackend.dto.responseDto.UnitsResponseDto;
import com.dacrt.SBIABackend.entity.Facilities;
import com.dacrt.SBIABackend.entity.Processes;
import com.dacrt.SBIABackend.entity.Suppliers;
import com.dacrt.SBIABackend.entity.Unitprocesses;
import com.dacrt.SBIABackend.entity.Units;
import com.dacrt.SBIABackend.entity.Userunits;
import com.dacrt.SBIABackend.entity.Vicepresidencies;
import com.dacrt.SBIABackend.entity.Workers;
import com.dacrt.SBIABackend.security.dto.RespuestaDto;
import com.dacrt.SBIABackend.security.dto.RespuestaMsgDto;
import com.dacrt.SBIABackend.security.dto.RespuestaValueDto;
import com.dacrt.SBIABackend.security.dto.RoleDto;
import com.dacrt.SBIABackend.security.dto.RolesResponseDto;
import com.dacrt.SBIABackend.security.dto.RolesUserDto;
import com.dacrt.SBIABackend.security.dto.SuppliersUsersDto;
import com.dacrt.SBIABackend.security.dto.UserDetailsResponseDto;
import com.dacrt.SBIABackend.security.dto.UserRequestNewDto;
import com.dacrt.SBIABackend.security.dto.UsersListDto;
import com.dacrt.SBIABackend.security.dto.UsersRolesPriWorStaDto;
import com.dacrt.SBIABackend.security.dto.UsersUnitDto;
import com.dacrt.SBIABackend.security.dto.WorkersUsersDto;
import com.dacrt.SBIABackend.security.dto.PrivilegesAllDto;
import com.dacrt.SBIABackend.security.dto.PrivilegesDto;
import com.dacrt.SBIABackend.security.dto.ParamsDto;
import com.dacrt.SBIABackend.security.dto.ParamsResponseDto;
import com.dacrt.SBIABackend.security.entity.Audit;
import com.dacrt.SBIABackend.security.entity.Params;
import com.dacrt.SBIABackend.security.entity.Roles;
import com.dacrt.SBIABackend.security.entity.Users;
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.UsersService;
import com.dacrt.SBIABackend.service.FacilitiesService;
import com.dacrt.SBIABackend.service.UnitsService;
import com.dacrt.SBIABackend.service.VicepresidenciesService;
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.utils.HttpReqRespUtils;
import com.dacrt.SBIABackend.security.repository.AuditRepository;
import com.dacrt.SBIABackend.repository.ProcessesRepository;
import com.dacrt.SBIABackend.repository.UnitprocessesRepository;
import com.dacrt.SBIABackend.repository.UnitsRepository;
import com.dacrt.SBIABackend.repository.UserunitsRepository;
import com.dacrt.SBIABackend.repository.VicepresidenciesRepository;


@RestController
//@RequestMapping("/units")   
@CrossOrigin(origins = "*")

public class UnitsController {
	
	@Autowired
	private ParamsRepository paramsRepository;
	
	@Autowired
	private UsersRepository usersRepository;
	
	@Autowired
	private AuditRepository auditRepository;
	
	@Autowired
	private RolesPrivilegesRepository rolesPrivilegesRepository;
	
	@Autowired
	private UnitprocessesRepository unitprocessesRepository;
	
	@Autowired
	private VicepresidenciesRepository vicepresidenciesRepository;
	
	@Autowired
	UsersService usersService;
	
	@Autowired
	SecurityService securityService;
	
	@Autowired
	ParamsService paramsService;
	
	@Autowired
	MenuService menuService;
	
	@Autowired
	UserunitsRepository userunitsRepository; 
	
	@Autowired
	VicepresidenciesService vicepresidenciesService;
	
	@Autowired
	FacilitiesService facilitiesService;
	
	@Autowired
	UnitsRepository unitsRepository;
	
	@Autowired
	ProcessesRepository processesRepository;
	
	@Autowired
	UnitsService unitsService; 
	
	@Autowired
    private JdbcTemplate jdbcTemplate;
	
	@PersistenceContext
    private EntityManager entityManager;
	
	@Value("${spring.datasource.url}")
	private String conexion;
	
	@Value("${spring.datasource.username}")
	private String userbd;
	
	@Value("${spring.datasource.password}")
	private String passbd;
	
	//@GetMapping("/menus)
		//public ResponseEntity<MenuResponseDto> menu(@PathVariable final String sessionid) throws ParseException {
		@PostMapping("/units")
		public ResponseEntity<?> units(HttpServletRequest request,@RequestBody UsersListDto tiposfiltros) throws ParseException {
			RespuestaDto respuesta = new RespuestaDto("", false);
			HttpStatus estatus = HttpStatus.FORBIDDEN;
			UnitsResponseDto unitsResponseDto = new UnitsResponseDto();
			RecordCatalogoResponseDto unitsFormatResponseDto = new RecordCatalogoResponseDto();
		//	ParamsDto detalleParams;
			UnitsDto detalleUnits;
			StatusDto detalleStatus;
			TypeUnitDto detalleType;
			TypesUnitDto detalleTypes;
			VicepresidencyDto detalleVice;
			FacilityDto detalleFacility;
			PrivilegesAllDto detallePrivilege;
			 CampaignFormat2Dto detalleCompaing2;
		     List<UnitsDto> listasUnits = new ArrayList<>();
		     List<TypesUnitDto> listasTypes = new ArrayList<>();
		     Long cuantosregistro = (long) 0;
		     
		    // List<PrivilegesDto> listasPrivelege = new ArrayList<>();
			 
			 String sessionid = request.getHeader("Authorization");
			 Date fecha = new Date();
			 SimpleDateFormat  formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		     String dataFormattata = formatter.format(fecha);
		     Date fechaDate = formatter.parse(dataFormattata);
		     AuditRequestDto  auditDto=new AuditRequestDto();
		     int idUser;
		        
		     
		       
		     int idrol;
		   	 String searchIn = "";
		   	 String searchAllUnits="";
		   	 String searchListUnit = "";
		     String contentIn = "";
		     int formatList = 0;
		     // String searchModule = "";
			 int searchStatus = 0;
			 int searchVP,searchFacility,searchType;
			 String fechaComoCadena;
			 int orderIn = 0;
			 int offsetIn = 0;
			 int numofrecordsIn = 0;
			 Optional<Params> deSessDuration=paramsRepository.findByParamname("SESSION_DURATION");
			 String SessionDuration=deSessDuration.get().getValue();
			 int duracionSession = Integer.parseInt(SessionDuration);
			 Date fecha2 = new Date();
			
		
			 
				if (sessionid==null) {
					String var = "";
					boolean bloked = false;
					RespuestaDto respuestaDto = new RespuestaDto(var, bloked);
					respuestaDto.setBlocked(bloked);
					respuestaDto.setMsg("Sesión expirada o inválida");
					//Error 400
					return new ResponseEntity(respuestaDto, HttpStatus.BAD_REQUEST);
				} else   {
					 
					   sessionid = sessionid.substring(7);
					   Optional<Users> encontreSessionUsuario =usersRepository.getBySessionid(sessionid);
					   idUser = encontreSessionUsuario.get().getId();
					//   String usuarioIN = encontreSessionUsuario.get().getUsr();
					 //  int position = usuarioIN.indexOf('('); 
					   
					   if (encontreSessionUsuario.isPresent()) {
						   Date FechaReg = encontreSessionUsuario.get().getValidthru(); 

						   //fechaComoCadena  = securityService.consultarSessionActiva(FechaReg,fecha2);
						   fechaComoCadena  = securityService.consultarSessionActiva(FechaReg,fecha2,encontreSessionUsuario.get().getId());

						   
						    if (fechaComoCadena=="") {
							   
							   
							   
							   String var = "";
								boolean bloked = false;
								RespuestaMsgDto respuestaDto = new RespuestaMsgDto(var);
								//respuestaDto.setBlocked(bloked);
								respuestaDto.setMsg("Sesión expirada o inválida"); 
								return new ResponseEntity(respuestaDto, HttpStatus.UNAUTHORIZED);
								//return new ResponseEntity(respuestaDto, HttpStatus.UNAUTHORIZED);
							   
						    }
						   
						   
						   // Este proceso permite obtener un listado de las unidades. (Priv 110)
						    formatList = tiposfiltros.getFormat(); 
						    Roles roles = encontreSessionUsuario.get().getRolid();
						    idrol = roles.getId();
						    int rolisvalid = auditRepository.getCantbyRolAndPrivi(idrol, 110);
						    if (formatList!=2) {
						        if (rolisvalid==0) {
							   
							    String var = "";
								boolean bloked = false;
								RespuestaMsgDto respuestaDto = new RespuestaMsgDto(var);
								//respuestaDto.setBlocked(bloked);
								respuestaDto.setMsg("No tiene los Privilegios"); 
								return new ResponseEntity(respuestaDto, HttpStatus.FORBIDDEN);
								
						        }
						    }  
						   
							  //searchIn = tiposfiltros.getFilters().getSearch();
							  searchIn = tiposfiltros.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(tiposfiltros.getFilters().getSearch()); 
							  searchListUnit = tiposfiltros.getFilters().getUnitidlist();
							  searchStatus = tiposfiltros.getFilters().getStatus();	
							   searchVP = tiposfiltros.getFilters().getVicepresidencyid();
							   searchFacility = tiposfiltros.getFilters().getFacilityid();
							   searchType = tiposfiltros.getFilters().getUnittype();
							  orderIn = tiposfiltros.getOrder();
							  offsetIn = tiposfiltros.getOffset();
							  numofrecordsIn = tiposfiltros.getNumofrecords();
							  
							  try {
								  searchAllUnits = tiposfiltros.getAllunits();
								  if (searchAllUnits==null) {
									  searchAllUnits = "";
								  }
								  
							  }  catch (Exception e) { 
								  
								  searchAllUnits = "";
								  
							  }
							  
							  
							 
							  
							  
							  contentIn = tiposfiltros.getContent();
							  if (contentIn !=null) {
							  menuService.iscontentdiffnull(contentIn, encontreSessionUsuario.get().getId());
							  }
							  							
						
					 } else {
							String var = "";
							boolean bloked = false;
							RespuestaDto respuestaDto = new RespuestaDto(var, bloked);
							respuestaDto.setBlocked(bloked);
							respuestaDto.setMsg("Sesión expirada o inválida");
							//Error 400
							return new ResponseEntity(respuestaDto, HttpStatus.UNAUTHORIZED);
					 }
				}
				
				String Cadena = "elemento ->>";
											
			try {								

				String SentenciaBase="";

			
				
				 switch (searchAllUnits) { 
				    case "":  // viene sin busqueda por el like
				    
				    	 SentenciaBase = " SELECT  u.id, u.dsc,u.name,u.ref,count(up.unitid) AS processes, u.status,"
								+ "	CASE WHEN u.status = 1 THEN 'Activo' ELSE 'Inactivo' END AS estatus,"
								+ "	f.id AS idfac,f.name AS namefac,v.id AS vpid, v.name AS namevp,pr.descr,pr.valor "
								+ "	FROM main.units u LEFT JOIN  main.facilities f ON u.facilityid = f.id  "
								+ "	LEFT JOIN main.vicepresidencies v ON u.vicepresidencyid = v.id  "
								+ "	LEFT JOIN main.unitprocesses up ON u.id = up.unitid "
								//+ " LEFT JOIN main.userunits uu  ON uu.unitid = u.id "
								+ "	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 = 'UNIT_TYPE' ) pr ON u.unittypepar = CAST(pr.valor AS integer), main.userunits uu "
								//+ " WHERE p.paramname = 'UNIT_TYPE' ) pr ON u.unittypepar = CAST(pr.valor AS integer) "
							//	+ " WHERE  uu.userid = " +  idUser;
								+ " WHERE uu.unitid = u.id and uu.userid = " +  idUser;
								
				     break;
				     
				     case "1":
				    	  SentenciaBase = " SELECT  u.id, u.dsc,u.name,u.ref,count(up.unitid) AS processes, u.status,"
									+ "	CASE WHEN u.status = 1 THEN 'Activo' ELSE 'Inactivo' END AS estatus,"
									+ "	f.id AS idfac,f.name AS namefac,v.id AS vpid, v.name AS namevp,pr.descr,pr.valor "
									+ "	FROM main.units u LEFT JOIN  main.facilities f ON u.facilityid = f.id  "
									+ "	LEFT JOIN main.vicepresidencies v ON u.vicepresidencyid = v.id  "
									+ "	LEFT JOIN main.unitprocesses up ON u.id = up.unitid "
									+ " LEFT JOIN main.userunits uu  ON uu.unitid = u.id "
									+ "	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 = 'UNIT_TYPE' ) pr ON u.unittypepar = CAST(pr.valor AS integer) "
									+ " WHERE 1 = 1 ";
				     break;	
				  
				    default:	// viene con el parametro para buscar por el like		   			    				    	
				    	     String var = "";
						     boolean bloked = false;
						     RespuestaDto respuestaDto = new RespuestaDto(var, bloked);
						     respuestaDto.setBlocked(bloked);
						     respuestaDto.setMsg("Llamada al servicio malformado");
						     //Error 400
						      return new ResponseEntity(respuestaDto, HttpStatus.BAD_REQUEST);
				    	
		          }
				
			 	//}	
				//searchAllUnits
				 switch (searchListUnit) { 
				    case "":  // viene sin busqueda por el like
				    
				    	SentenciaBase = SentenciaBase;
				     break;
				  
				    default:	// viene con el parametro para buscar por el like		   			    				    	
				    	SentenciaBase = SentenciaBase  + " AND u.id in (" + searchListUnit + ") ";	
				    	
		         }
				 String SetenciaTypes="";
						
				// if (formatList==1) {
				 
				      SetenciaTypes= "SELECT  elemento ->> 'dsc' AS descr,elemento ->> 'value' AS valor "
				 		+ " FROM main.params p, jsonb_array_elements(CAST(p.value AS jsonb)) AS elemento WHERE paramname = 'UNIT_TYPE' ORDER BY valor ASC";
			
		//		 }

				String QueryTotal = "";
			//	String SentenciaBase = "";
				String name = "u.dsc";
				String status = "u.status";				
				String lowername = "LOWER(u.dsc)";
				String LowerSearch = searchIn.toLowerCase();
			
				 
				 switch (searchStatus) { 
				    case 0:  // Busca por cualquier estatus
				    //	QueryTotal = SentenciaBase + " WHERE 1 = 1 ";
				    	QueryTotal = SentenciaBase;
				     break;
				    case 1:  // Busca por estatus activo
				    	
				    //	QueryTotal = SentenciaBase  + " WHERE " + status + " = " + searchStatus;
				    	QueryTotal = SentenciaBase  + " AND " + status + " = " + searchStatus;
				     break;
				    case 2:  // Busca por estatus Inactivo
				    					    	
				    //	QueryTotal = SentenciaBase  + " WHERE " + "u.status" + " = " + 0;
				    	QueryTotal = SentenciaBase  + " AND " + "u.status" + " = " + 0;
				     break;
				  
				    default:	// viene con el parametro para buscar por el like		   			    				    	
				    	String var2 = "";
						boolean bloked = false;
						RespuestaMsgDto respuestaDto = new RespuestaMsgDto(var2);
						respuestaDto= new RespuestaMsgDto("Llamada al servicio malformado");
						estatus=HttpStatus.BAD_REQUEST;   
						return new ResponseEntity(respuestaDto, estatus);
				    	
		         }
				 
				 
				 switch (searchVP) { 
				    case 0:  // Busca por cualquier estatus
				    	QueryTotal = QueryTotal;
				     break;
				  
				    default:	// viene con el parametro para buscar por el like		   			    				    	
				    	QueryTotal = QueryTotal + " AND  u.vicepresidencyid = " + searchVP;
				    	
		         }
				 
				 switch (searchFacility) { 
				    case 0:  // Busca por cualquier estatus
				    	QueryTotal = QueryTotal;
				     break;
				  
				    default:	// viene con el parametro para buscar por el like		   			    				    	
				    	QueryTotal = QueryTotal + " AND  u.facilityid = " + searchFacility;
				    	
		         }
				 
				 switch (searchType) { 
				    case 0:  // Busca por cualquier estatus
				    	//QueryTotal = QueryTotal + " AND up.unitid = u.id";
				    	QueryTotal = QueryTotal;
				     break;
				  
				    default:	// viene con el parametro para buscar por el like		   			    				    	
				    	QueryTotal = QueryTotal + " AND  u.unittypepar = " + searchType;
				    	
		         }
				 
				 switch (searchIn) { 
				    case "":  // viene sin busqueda por el like
				    	//QueryTotal = SentenciaBase;
				    	//QueryTotal = SentenciaBase  + " WHERE " + lowername + " LIKE " + "'%" + "" + "%'";
				    	QueryTotal = QueryTotal;
				     break;
				  
				    default:	// viene con el parametro para buscar por el like		
				    	//	String lowerdsc = "main.sinacentos(LOWER(ed.dsc))";
				    	QueryTotal = QueryTotal + " AND " + "( main.sinacentos(LOWER(u.dsc))" + " LIKE " + "'%" + LowerSearch + "%'" + " OR " + " main.sinacentos(LOWER(u.name))" + " LIKE " + "'%" + LowerSearch + "%'"
				    	+ " OR " + " main.sinacentos(LOWER(u.ref))" + " LIKE " + "'%" + LowerSearch + "%'" + " OR " + " main.sinacentos(LOWER(f.name))" + " LIKE " + "'%" + LowerSearch + "%'" + " OR " 
				    	+  " main.sinacentos(LOWER(v.name))" + " LIKE " + "'%" + LowerSearch + "%')";
				    	
		         }
				 Query query;
				
				     String groupby = " GROUP BY u.id,u.dsc,u.name,u.ref,u.status,f.id,f.name,v.id,v.name,pr.descr,pr.valor ";
				  
				     QueryTotal = QueryTotal + groupby;
				     if (formatList==1) {
				      query = entityManager.createNativeQuery(QueryTotal);
				     cuantosregistro = (long) query.getResultList().size();
				     }
				// query.getResultList();
				// List<UnitsDtoStatus> resultados = query.getResultList();
				 
				// TypedQuery<UnitsDtoStatus> unitsCount= entityManager.createQuery(QueryTotal, UnitsDtoStatus.class);
				 //cuantosregistro = (long) unitsCount.getResultList().size();
			
				 String ordena="";
				// if (formatList==1) {	 
				     if (orderIn == 1 || orderIn == 2 || orderIn == 3 || orderIn == 4 || orderIn == 5 || orderIn == 99) {
					  ordena = " ASC";
				      }  else if (orderIn == -1 || orderIn == -2 || orderIn == -3 || orderIn == -4 || orderIn == -5 || orderIn == -99) {
					  ordena = " DESC";
				       } else {
					 	String var2 = "";
						boolean bloked = false;
						RespuestaMsgDto respuestaDto = new RespuestaMsgDto(var2);
						respuestaDto= new RespuestaMsgDto("Llamada al servicio malformado");
						estatus=HttpStatus.BAD_REQUEST;   
						return new ResponseEntity(respuestaDto, estatus);
				      }
				// }
				 int absolutoOrden = Math.abs(orderIn);
				 
				 switch (absolutoOrden) { 
				    case 1:  //ordena por dsc ascendente
				    	
				    	QueryTotal = QueryTotal + " ORDER BY " + "u.name" + ordena;
				     break;
				    case 2:   //ordena por status ascendente
				    	
				    	QueryTotal = QueryTotal + " ORDER BY " + status + ordena;
				     break;
                    case 3:   //ordena por status ascendente
				    	
				    	QueryTotal = QueryTotal + " ORDER BY " + "namevp" + ordena;
				     break;
                    case 4:   //ordena por status ascendente
	
	                    QueryTotal = QueryTotal + " ORDER BY " + "namefac" + ordena;
                     break;
                    case 5:   //ordena por status ascendente
	
	                    QueryTotal = QueryTotal + " ORDER BY " + "descr" + ordena;
                    break;
                    case 99:   //ordena por status ascendente
                    	
	                    QueryTotal = QueryTotal + " ORDER BY " + "u.id" + ordena;
                    break;
                    default:
                    	String var2 = "";
                    	boolean bloked = false;
						RespuestaMsgDto respuestaDto = new RespuestaMsgDto(var2);
						respuestaDto= new RespuestaMsgDto("Llamada al servicio malformado");
						estatus=HttpStatus.BAD_REQUEST;   
						return new ResponseEntity(respuestaDto, estatus);
				    
				   }
				 
				 //aqui comienzo a enviar los valor del tipo de unidad de la tabla params
				 
			
				 if (formatList!=2) {  
				       Query queryTypes = entityManager.createNativeQuery(SetenciaTypes);
				       List<Object[]> listatipos= queryTypes.getResultList();
				       for (Object[] types : listatipos) {
				    	   detalleTypes = new TypesUnitDto();
				    	  
				    	   detalleTypes.setDsc((String) types[0]);
				    	   detalleTypes.setValue((String) types[1]);
				    	   listasTypes.add(detalleTypes);
				       }
				       
				       query = entityManager.createNativeQuery(QueryTotal);
				       query.setFirstResult(offsetIn);
					   query.setMaxResults(numofrecordsIn);
					   List<Object[]> listacompleta = query.getResultList();
				     
			    	   detalleUnits = new UnitsDto();
			    		
			    		   for (Object[] reg : listacompleta) {
			    		   detalleUnits = new UnitsDto();
			    		 
			    		   detalleStatus = new StatusDto();
			    		   detalleType = new TypeUnitDto();
			    		   detalleVice = new VicepresidencyDto();
			    		   detalleFacility = new FacilityDto();
			    		   
			    		   detalleUnits.setId((int) reg[0]);			    		   
			    		   detalleUnits.setDsc((String) reg[1]);
			    		   detalleUnits.setName((String) reg[2]);
			    		   detalleUnits.setRef((String) reg[3]);
			    		   detalleUnits.setProcesses((BigInteger) reg[4]);
			    		   //estatus
				    	   detalleStatus.setId((int) reg[5]);
				    	   detalleStatus.setName((String) reg[6]);
				    	   //facilities
				    	   detalleFacility.setId((int) reg[7]);
				    	   detalleFacility.setDsc((String) reg[8]);
				    	   //vicepresedencia
				    	   detalleVice.setId((int) reg[9]);
				    	   detalleVice.setDsc((String) reg[10]);
				    	   //tipo de unidad
				    	   detalleType.setId((String) reg[12]);
				    	   detalleType.setDsc((String) reg[11]);
				    	  
				    	  
				    	   
				    	   
				    	   detalleUnits.setStatus(detalleStatus);
				    	   detalleUnits.setFacility(detalleFacility);
				    	   detalleUnits.setType(detalleType);
				    	   detalleUnits.setVicepresidency(detalleVice);
				    	   
				    	   listasUnits.add(detalleUnits);
			    	   }
			    	
			    	   
	      	    	       detallePrivilege = new PrivilegesAllDto();
			    	  
			    	  	
			    		   boolean tieneView = rolesPrivilegesRepository.existsByRolidAndPrivilegeid(idrol,110);
						   boolean tieneUpdate = rolesPrivilegesRepository.existsByRolidAndPrivilegeid(idrol,111);
						   boolean tieneAdd = rolesPrivilegesRepository.existsByRolidAndPrivilegeid(idrol,112);
						   boolean tieneDelete = rolesPrivilegesRepository.existsByRolidAndPrivilegeid(idrol,113);
						   //existsByRolidAndPrivilegeid
						   
		      	    	 	detallePrivilege.setView(tieneView);
				    	  	detallePrivilege.setUpdate(tieneUpdate);		    	  
				    	  	detallePrivilege.setAdd(tieneAdd);
				    	  	detallePrivilege.setDelete(tieneDelete);
			    	
			    	  	unitsResponseDto.setNumofrecords(cuantosregistro);
			           //paramsResponseDto.setValidthru(ValidThrufechaSalida);
			    	  	unitsResponseDto.setSessionvalidthru(fechaComoCadena);		           
			    	  	unitsResponseDto.setRecords(listasUnits);
			    	  	unitsResponseDto.setPrivileges(detallePrivilege);	
			    	  	unitsResponseDto.setTypes(listasTypes);
			  						           
	                return ResponseEntity.ok(unitsResponseDto);
				 } else {
					 
					 Query queryTypes = entityManager.createNativeQuery(SetenciaTypes);
				       List<Object[]> listatipos= queryTypes.getResultList();
				       for (Object[] types : listatipos) {
				    	   detalleTypes = new TypesUnitDto();
				    	  
				    	   detalleTypes.setDsc((String) types[0]);
				    	   detalleTypes.setValue((String) types[1]);
				    	   listasTypes.add(detalleTypes);
				       }
				       
				       query = entityManager.createNativeQuery(QueryTotal);
				     //  query.setFirstResult(offsetIn);
					 //  query.setMaxResults(numofrecordsIn);
					   List<Object[]> listacompleta = query.getResultList();
				     
			    	   detalleUnits = new UnitsDto();
			    		
			    		   for (Object[] reg : listacompleta) {
			    		   detalleUnits = new UnitsDto();
			    		 
			    		   detalleStatus = new StatusDto();
			    		   detalleType = new TypeUnitDto();
			    		   detalleVice = new VicepresidencyDto();
			    		   detalleFacility = new FacilityDto();
			    		   
			    		   detalleUnits.setId((int) reg[0]);			    		   
			    		   detalleUnits.setDsc((String) reg[1]);
			    		   detalleUnits.setName((String) reg[2]);
			    		   detalleUnits.setRef((String) reg[3]);
			    		   detalleUnits.setProcesses((BigInteger) reg[4]);
			    		   //estatus
				    	   detalleStatus.setId((int) reg[5]);
				    	   detalleStatus.setName((String) reg[6]);
				    	   //facilities
				    	   detalleFacility.setId((int) reg[7]);
				    	   detalleFacility.setDsc((String) reg[8]);
				    	   //vicepresedencia
				    	   detalleVice.setId((int) reg[9]);
				    	   detalleVice.setDsc((String) reg[10]);
				    	   //tipo de unidad
				    	   detalleType.setId((String) reg[12]);
				    	   detalleType.setDsc((String) reg[11]);
				    	  
				    	  
				    	   
				    	   
				    	   detalleUnits.setStatus(detalleStatus);
				    	   detalleUnits.setFacility(detalleFacility);
				    	   detalleUnits.setType(detalleType);
				    	   detalleUnits.setVicepresidency(detalleVice);
				    	   
				    	   listasUnits.add(detalleUnits);
			    	   }
			    	
			    	   
	      	    	 
			    	
			    	  	unitsResponseDto.setNumofrecords(cuantosregistro);
			           //paramsResponseDto.setValidthru(ValidThrufechaSalida);
			    	  	unitsResponseDto.setSessionvalidthru(fechaComoCadena);		           
			    	  	unitsResponseDto.setRecords(listasUnits);
			    	  	unitsResponseDto.setTypes(listasTypes);
			  						           
	                return ResponseEntity.ok(unitsResponseDto);
					
				 }
			
	       
			} catch (Exception e) {
	            // Manejo de excepciones
				respuesta= new RespuestaDto("Error interno del servidor", false);
				estatus=HttpStatus.INTERNAL_SERVER_ERROR;  
				
	        } finally {
		        if (entityManager != null && entityManager.isOpen()) {
		            entityManager.close();
		        }
		    }
			
			return new ResponseEntity(respuesta, estatus);
		
		}
		
		
		@GetMapping("/units/{unitid}")
		public ResponseEntity<?> getOneUnit(HttpServletRequest request, @PathVariable("unitid") final Integer unitid)
				throws ParseException {
			RespuestaMsgDto respuesta = new RespuestaMsgDto("");
			// List<UsersRolesPriWorStaDto> listaUserRolWorStaSup = new ArrayList<>();
			 List<UsersRolesPriWorStaDto> listasUsersRolesPriWorStaDto = new ArrayList<>();
			 UsersRolesPriWorStaDto detalleUsers;
			 WorkersUsersDto detalleworker;
			 SuppliersUsersDto detallesupplier;
			 RolesUserDto detalleroles;
			 UnitDetailDto detalleUnits;
			 UsersUnitDto detalleUserUnits;
			 StatusDto detalleStatus;
			 TypeUnitDto detalleType;
			 VicepresidencyDto detalleVice;
			 FacilityDto detalleFacility;
			 ProcessTypeDto2 detalleProcesses;
			 
			HttpStatus estatus = HttpStatus.FORBIDDEN;
			try {

				RespuestaValueDto respuestaValueDto;
				String var = "";
				boolean bloked = false;
				RespuestaDto respuestaDto = new RespuestaDto(var, bloked);

				RolesResponseDto rolesResponseDto = new RolesResponseDto();
				RoleDto detalleRoles;
				PrivilegesAllDto detallePrivilege;
				Long cuantosregistro = (long) 0;
				List<RoleDto> listasRoles = new ArrayList<>();
				List<PrivilegesAllDto> listasPrivelege = new ArrayList<>();

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

				

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

				if (sessionid == null) {
					respuesta.setMsg("Llamada al servicio malformado");
					return new ResponseEntity(respuesta, HttpStatus.BAD_REQUEST);
				} else {
					sessionid = sessionid.substring(7);
					Optional<Users> encontreSessionUsuario = usersRepository.getBySessionid(sessionid);
					if (encontreSessionUsuario.isPresent()) {
						
						   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);
	  					    fechaComoCadena  = securityService.consultarSessionActiva(FechaReg,fecha2,encontreSessionUsuario.get().getId());
	  					    if (fechaComoCadena=="") {
	  						   
	  						   
	  						   
	  						    String var2 = "";
	  							boolean bloked2 = false;
	  							RespuestaMsgDto respuestaDto2 = new RespuestaMsgDto(var2);
	  							//respuestaDto.setBlocked(bloked);
	  							respuestaDto2.setMsg("Sesión expirada o inválida"); 
	  							return new ResponseEntity(respuestaDto, HttpStatus.UNAUTHORIZED);
	  						   
	  					    }
	  					   
						// Obtiene la información de un usuario en particular. (priv 630)
						  Roles roles = encontreSessionUsuario.get().getRolid();
						   int idrol = roles.getId();
						   int rolisvalid = auditRepository.getCantbyRolAndPrivi(idrol, 110);
						   
						   if (rolisvalid==0) {
							  
							   
								//boolean bloked = false;
								RespuestaMsgDto respuestaPrivDto = new RespuestaMsgDto(var);
								//respuestaDto.setBlocked(bloked);
								respuestaPrivDto.setMsg("No tiene los Privilegios"); 
								return new ResponseEntity(respuestaPrivDto, HttpStatus.FORBIDDEN);
								
						   }
						   
						boolean existeUnit = unitsRepository.existsById(unitid);
						if (!existeUnit) {
							respuesta.setMsg("Registro no encontrado");
							return new ResponseEntity(respuesta, HttpStatus.NOT_FOUND);
						} else {
							//int rolisvalid = 0;
							List<Unitprocesses> listaUnitProccesses = new ArrayList<>();
							List<Integer> listaUnitProccesses2 = new ArrayList<>();
							Optional<Units> UnitElegida = unitsRepository.findById(unitid);
							 
													
							 //listaUnitProccesses=unitprocessesRepository.findByUnitid(unitid);
							 List<UnitsUsersDto> listasUnidadesDto = new ArrayList<>();
							 List<ProcessTypeDto2> listProcessesAsociados= new ArrayList<>();							 
							 detalleUnits = new UnitDetailDto();
							 UnitsProcessesDetailDto detalleUnitsProcesses;
							 detalleUnitsProcesses =new  UnitsProcessesDetailDto();
						
							 
							 
							 String SentenciaBase = " SELECT u.id,u.name,u.dsc,u.ref,u.status,p.id as idpro,p.name as proname,v.id as idvp,v.name as vpname,f.id as idfac,f.name as facname, "
							 + " pr.descr,pr.valor,up.deleted FROM  main.units u "
									 + " LEFT JOIN main.unitprocesses up ON u.id = up.unitid  and up.deleted is null "
								    			+ " LEFT JOIN main.processes p ON up.processid = p.id "
												+ " LEFT JOIN  main.facilities f ON u.facilityid = f.id "
								        		+ " LEFT JOIN main.vicepresidencies v ON u.vicepresidencyid = v.id "
												+ " 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 = 'UNIT_TYPE' ) pr ON u.unittypepar = CAST(pr.valor AS integer) "
							                     	+ " WHERE u.id= " + unitid ;
									//	+ " WHERE u.id= " + unitid + " AND up.deleted is null";
							 
							  Query queryTypes = entityManager.createNativeQuery(SentenciaBase);
						       List<Object[]> listatipos= queryTypes.getResultList();
						       detalleVice = new VicepresidencyDto();
						       List<StatusDto> listasStatus = new ArrayList<>();	
						 	  List<FacilityDto> listasFacility = new ArrayList<>();
					    	  List<VicepresidencyDto> listasVp = new ArrayList<>();
					    	  List<TypeUnitDto> listasType = new ArrayList<>();	
					    	  
					    	   detalleStatus = new StatusDto();
				    		   detalleType = new TypeUnitDto();
				    		   detalleVice = new VicepresidencyDto();
				    		   detalleFacility = new FacilityDto();
				    		   
						       for (Object[] types : listatipos) {
						    	   detalleProcesses= new ProcessTypeDto2();
						    	   detalleUnits.setId((Integer) types[0]);
						    	   detalleUnits.setName((String) types[1]);
						    	   detalleUnits.setDsc((String) types[2]);
						    	   detalleUnits.setRef((String) types[3]);
						    	   
						    	   detalleStatus.setId((Integer) types[4]);
						    	   int valorestatus = (Integer) types[4];
						    	   
						    	   if (valorestatus==1) {
						    		   String descestatus = "Activo";
						    		   detalleStatus.setName(descestatus);
						    		   
						    	   } else {
						    		   String descestatus = "Inactivo";	
						    		   detalleStatus.setName(descestatus);
						    	   }
						    	
						    							    	 						    	   
						    	     String esnull = "" ;
						    	     try {
						    		  detalleProcesses.setId((Integer) types[5]);
						    		
						               } catch (Exception e) {
						          	   
						        	   detalleProcesses.setId(0);
						        	  
						              }
						    	   
						    	      try {
									   detalleProcesses.setName((String) types[6]);
									   esnull = (String) types[6];
                                       } catch (Exception e) {
                                    	   detalleProcesses.setName(null);
						             }
						    	   
						    
						    	     if (esnull!=null) {
						    		   listProcessesAsociados.add(detalleProcesses);
						    		   
						    	     }
						    	     						   
						    	  
						    	   
						    	   detalleVice.setId((Integer) types[7]);
					    		   detalleVice.setDsc((String) types[8]);
					    		   detalleFacility.setId((Integer) types[9]);
					    		   detalleFacility.setDsc((String) types[10]);
					    		   detalleType.setId((String) types[12]);
						           detalleType.setDsc((String) types[11]);
						             
									 
					    		   
					    		   
						    	     detalleUnits.setStatus(detalleStatus);
									 detalleUnits.setFacility(detalleFacility);
									 detalleUnits.setVicepresidency(detalleVice);
									 detalleUnits.setType(detalleType);
									 
								
						       }
						       
						       detalleUnits.setProcesess(listProcessesAsociados);
						       listasStatus.add(detalleStatus);
						       listasFacility.add(detalleFacility);
				    		   listasVp.add(detalleVice);
				    		   listasType.add(detalleType);
							 
																	    		   				    		   				    		  
                           
					    	   
							 UnitDetailsResponseDto entry = new UnitDetailsResponseDto();
				    		   //usersResponseDto.setSessionvalidthru(fechaDate);
					        //UserDetailsResponseDto.setSessionvalidthru(fechaComoCadena);
					    	   entry.setEntry(detalleUnits);
							      // unitsResponseDto.setPrivileges(listasPrivelege);
					       // UserDetailsResponseDto.setPrivileges(detallePrivilege);
							      
							           return ResponseEntity.ok(entry);
						}
					} else {
						respuesta.setMsg("Sesión expirada o inválida");
						estatus = HttpStatus.UNAUTHORIZED;
						return new ResponseEntity(respuesta, estatus);
					}
				}
			} catch (Exception e) {// Error Interno
				// Manejo de excepciones
				respuesta.setMsg("Error interno del servidor");	
				estatus = HttpStatus.INTERNAL_SERVER_ERROR;
				return new ResponseEntity(respuesta, estatus);
			} finally {
		        if (entityManager != null && entityManager.isOpen()) {
		            entityManager.close();
		        }
		    }

		}
		
	@PostMapping("/units/{unitid}")
		public ResponseEntity<ParamsResponseDto> unitUpdate(HttpServletRequest request,@RequestBody UnitsRequestNewDto datosUnidad,@PathVariable("unitid") final Integer unitid) throws ParseException, SQLException {
			
			
			RespuestaValueDto respuestaValueDto;
			RespuestaMsgDto respuesta = new RespuestaMsgDto("");
			HttpStatus estatus = HttpStatus.FORBIDDEN;
			ParamsResponseDto paramsResponseDto = new ParamsResponseDto();
			ParamsDto detalleParams;
			PrivilegesDto detallePrivilege;
		     List<ParamsDto> listasParams = new ArrayList<>();
		     List<PrivilegesDto> listasPrivelege = new ArrayList<>();
		     
			 int idparametro = unitid;
			 
			 int valor = idparametro;
			 String sessionid = request.getHeader("Authorization");
			  Date fecha = new Date();
			    SimpleDateFormat  formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		        String dataFormattata = formatter.format(fecha);
		        Date fechaDate = formatter.parse(dataFormattata);
		        AuditRequestDto  auditDto=new AuditRequestDto();
		        Statement sentenciaPreparada = null;     	   
		        Statement sentenciaPreparadaDel= null;	
		        Statement sentenciaPreparadaUpd= null;
		        Statement sentenciaPreparada2 = null;
		        Connection conexion2 = DriverManager.getConnection(conexion,userbd, passbd);
			   Date fecha2 = new Date();
			   Calendar calendar = Calendar.getInstance();
		
			 
				if (sessionid==null) {
					String var = "";
					boolean bloked = false;
					RespuestaMsgDto respuestaDto = new RespuestaMsgDto(var);
					//respuestaDto.setBlocked(bloked);
					respuestaDto.setMsg("Llamada al servicio malformado");
					//Error 400
					return new ResponseEntity(respuestaDto, HttpStatus.BAD_REQUEST);
				} else   {
					 
					   sessionid = sessionid.substring(7);
					   Optional<Users> encontreSessionUsuario =usersRepository.getBySessionid(sessionid);
				String fechaComoCadena;
					   
					   if (encontreSessionUsuario.isPresent()) {
						   
						   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);
	  					   fechaComoCadena  = securityService.consultarSessionActiva(FechaReg,fecha2,encontreSessionUsuario.get().getId());
	  					    if (fechaComoCadena=="") {
	  						   
	  						   
	  						   
	  						   String var = "";
	  							boolean bloked = false;
	  							RespuestaMsgDto respuestaDto = new RespuestaMsgDto(var);
	  							//respuestaDto.setBlocked(bloked);
	  							respuestaDto.setMsg("Sesión expirada o inválida"); 
	  							return new ResponseEntity(respuestaDto, HttpStatus.UNAUTHORIZED);
	  						   
	  					    }
	  					    
	  					 // searchIn = tiposfiltros.getFilters().getSearch();
						  
						    String SalidaName= usersService.verificarCaracteresValidosConRegex(datosUnidad.getName());
						    String SalidaDesc = usersService.verificarCaracteresValidosConRegex(datosUnidad.getDsc());
						    String SalidaCod = usersService.verificarCaracteresValidosConRegex(datosUnidad.getRef());
						    
						    if (SalidaName=="NOOK" || SalidaDesc=="NOOK" || SalidaCod=="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);
							  }
	  					   
						 //Actualiza o Incluye un registro de un usuario. (Si el unitid es 0 se incluye). (priv 111 MOD Y 112 INC)
						   if (idparametro==0) {
							   //el permiso es el 632
							   Roles roles = encontreSessionUsuario.get().getRolid();
							   int idrol = roles.getId();
							   int rolisvalid = auditRepository.getCantbyRolAndPrivi(idrol, 112);
							  // rolisvalid = 3;
							   if (rolisvalid==0) {
								   
								   String var = "";
									boolean bloked = false;
									RespuestaMsgDto respuestaDto = new RespuestaMsgDto(var);
									//respuestaDto.setBlocked(bloked);
									respuestaDto.setMsg("No tiene los Privilegios"); 
									return new ResponseEntity(respuestaDto, HttpStatus.FORBIDDEN);
								   
							     }
							
							   
						   } else {
						   
						   Roles roles = encontreSessionUsuario.get().getRolid();
						   int idrol = roles.getId();
						   int rolisvalid = auditRepository.getCantbyRolAndPrivi(idrol, 111);
						  // rolisvalid = 3;
						   if (rolisvalid==0) {
							   
							   String var = "";
								boolean bloked = false;
								RespuestaMsgDto respuestaDto = new RespuestaMsgDto(var);
								//respuestaDto.setBlocked(bloked);
								respuestaDto.setMsg("No tiene los Privilegios"); 
								return new ResponseEntity(respuestaDto, HttpStatus.FORBIDDEN);
							   
						     }
						   } 
						   
						 
							
						   
						   if (idparametro==0) {
							   
	                       if  (datosUnidad.getRef()!= "" ) {	
								   
								   //boolean existeRef = unitsRepository.existsByRef(datosUnidad.getRef());
								   String Query1 = "SELECT name FROM main.units WHERE LOWER(ref) = " + "'" + datosUnidad.getRef().toString().toLowerCase() + "'" ;
								   Long cuantosregistroref = (long) jdbcTemplate.queryForList(Query1).size();
								   
								    if (cuantosregistroref>0) {
								    	String var = "";
								    	RespuestaMsgDto respuestaDto = new RespuestaMsgDto(var);
										//respuestaDto.setBlocked(bloked);
										respuestaDto.setMsg("Registro Duplicado");
										//Error 400
										return new ResponseEntity(respuestaDto, HttpStatus.CONFLICT);
								    }
							   }
	                       
	                       if  (datosUnidad.getName()!= "" ) {	
							   
							   //boolean existeName = unitsRepository.existsByName(datosUnidad.getName());
	                    	   String Query2 = "SELECT name FROM main.units WHERE LOWER(name) = " + "'" + datosUnidad.getName().toLowerCase() + "'";
	                    	   
							   Long cuantosregistroname = (long) jdbcTemplate.queryForList(Query2).size();
							   
							    if (cuantosregistroname>0) {
							    	String var = "";
							    	RespuestaMsgDto respuestaDto = new RespuestaMsgDto(var);
									//respuestaDto.setBlocked(bloked);
									respuestaDto.setMsg("Registro Duplicado");
									//Error 40
									return new ResponseEntity(respuestaDto, HttpStatus.CONFLICT);
							    }
						   }
						                     						   
						
							 //  if (usersRepository.existsByEmail(encontreSessionUsuario.get().getEmail())) {
								   
								   
							 //  }
							    //////////////////////////INSERCION BLOQUE DE AUDITORIA///////////////////
							     String module = "Unidades";
							     //String Descmodule = "Actualización de parametro del Sistema con id: " + parmid  ;
							     String Descmodule = "Se agregó: " + datosUnidad.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(fechaDate);
						 		   usersService.registrarAuditSesion(auditDto); 
							   
						   } else {
							   boolean existeUnit =  unitsRepository.existsById(idparametro);
							   if (!existeUnit) {
						    	    String var = "";
									boolean bloked = false;
									RespuestaMsgDto respuestaDto = new RespuestaMsgDto(var);
									//respuestaDto.setBlocked(bloked);
									respuestaDto.setMsg("Registro no encontrado"); 
									return new ResponseEntity(respuestaDto, HttpStatus.NOT_FOUND);
						    	  
						      } else
						    	  
						    	  
						      {
						    	  
						      
								  
								    //////////////////////////INSERCION BLOQUE DE AUDITORIA///////////////////
								     String module = "Unidades";
								     //String Descmodule = "Actualización de parametro del Sistema con id: " + parmid  ;
								     String Descmodule = "Se actualizó: "+ datosUnidad.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(fechaDate);
							 		   usersService.registrarAuditSesion(auditDto); 
							 		  //////////////////////////INSERCION BLOQUE DE AUDITORIA///////////////////					   				
						      }
							   
						   }
							   
						       
				
					   
					 } else {
							String var = "";
							boolean bloked = false;
							RespuestaMsgDto respuestaDto = new RespuestaMsgDto(var);
							//respuestaDto.setBlocked(bloked);
							respuestaDto.setMsg("Sesión expirada o inválida");
							//Error 400
							return new ResponseEntity(respuestaDto, HttpStatus.UNAUTHORIZED);
					 }
				}
				
				
			
			try {
				
				
				Units tipoUnits2=null;
				Units tipoUnits=null;
				Units tipoUnitsNew2=null;
				Optional<Units> nuevoinsertado = null;
				//Userunits tipoUsersUnits = new Userunits();	
				Unitprocesses tipoUsersUnits = new Unitprocesses();
				
				if (idparametro==0) {
					//Users tipoUsersNew = new Users();
					Units tipoUnitsNew = new Units();
					
					tipoUnitsNew.setStatus(datosUnidad.getStatus());
					
					tipoUnitsNew.setName(datosUnidad.getName());
					tipoUnitsNew.setDsc(datosUnidad.getDsc());
					tipoUnitsNew.setRef(datosUnidad.getRef());
					tipoUnitsNew.setModifiedat(fechaDate);
					tipoUnitsNew.setCreatedat(fechaDate); 
					tipoUnitsNew.setUnittypepar(datosUnidad.getUnittypepar());
					
			        if (datosUnidad.getVicepresidencyid()!=0) {
			        	Vicepresidencies tipoVP = vicepresidenciesService.getVicepresidenciesByid(datosUnidad.getVicepresidencyid());
			        	//Optional<Users> UsersElegido = usersRepository.findById(userid);
			        	tipoUnitsNew.setVicepresidencyid(tipoVP);			        				
					} 
		            
			        if (datosUnidad.getFacilityid()!=0) {
			        	Facilities tipoFacility = facilitiesService.getFacilitiesByid(datosUnidad.getFacilityid());
			        	//Optional<Users> UsersElegido = usersRepository.findById(userid);
			        	tipoUnitsNew.setFacilityid(tipoFacility);        				
					} 		  
			        
			        tipoUnitsNew2=unitsService.addIdUnits(tipoUnitsNew);
			        tipoUnits2 = tipoUnitsNew2;
		         

				} else {
					 //tipoUsers = usersService.getUsersByid(idparametro);
					    tipoUnits = unitsService.getUnitByid(idparametro);
					 
					    tipoUnits.setStatus(datosUnidad.getStatus());
						//tipoUsers.setUsr(datosUsuario.getUsr());

						String unit1 = tipoUnits.getName();
						String unit2 = datosUnidad.getName();
						if (unit1.equals(unit2)){
							String Validausers = "La unidad es la misma";
					    	
						} else {
					
						 String QueryTotal = "SELECT name FROM main.units WHERE LOWER(name) = " + "'" + datosUnidad.getName().toString().toLowerCase() + "'" ;
						 Long validaUnit = (long) jdbcTemplate.queryForList(QueryTotal).size();
						 
		                if (validaUnit>0) {
							
							String var = "";
							//boolean bloked = false;
							RespuestaMsgDto respuestaDto = new RespuestaMsgDto(var);
							//respuestaDto.setBlocked(bloked);
							respuestaDto.setMsg("Registro Duplicado");
							//Error 400
							return new ResponseEntity(respuestaDto, HttpStatus.CONFLICT);
							
						} else {
							tipoUnits.setName(datosUnidad.getName());
						}
					}	
						
						tipoUnits.setDsc(datosUnidad.getDsc());																											                 
						
						String ref1 = tipoUnits.getRef();
						String ref2 = datosUnidad.getRef();
						if (ref1.equals(ref2)){
							String Validacorreo = "La ref es la misma";
					    	
						} else {
							//boolean validaref = unitsRepository.existsByRef(datosUnidad.getRef());
							 String QueryTotal2 = "SELECT name FROM main.units WHERE LOWER(ref) = " + "'" + datosUnidad.getRef().toString().toLowerCase() + "'" ;
							 Long validaref = (long) jdbcTemplate.queryForList(QueryTotal2).size();
						   	if (validaref>0) {
								
								
								String var = "";
								//boolean bloked = false;
								RespuestaMsgDto respuestaDto = new RespuestaMsgDto(var);
								//respuestaDto.setBlocked(bloked);
								respuestaDto.setMsg("Registro Duplicado");
								//Error 400
								return new ResponseEntity(respuestaDto, HttpStatus.CONFLICT);
								
							  } else {
								  tipoUnits.setRef(datosUnidad.getRef());
						     }
							
						}
						
						tipoUnits.setModifiedat(fechaDate);	
						tipoUnits.setUnittypepar(datosUnidad.getUnittypepar());
						
						 if (datosUnidad.getVicepresidencyid()!=0) {
					        	Vicepresidencies tipoVP = vicepresidenciesService.getVicepresidenciesByid(datosUnidad.getVicepresidencyid());
					        	//Optional<Users> UsersElegido = usersRepository.findById(userid);
					        	tipoUnits.setVicepresidencyid(tipoVP);			        				
							} 
				            
					        if (datosUnidad.getFacilityid()!=0) {
					        	Facilities tipoFacility = facilitiesService.getFacilitiesByid(datosUnidad.getFacilityid());
					        	//Optional<Users> UsersElegido = usersRepository.findById(userid);
					        	tipoUnits.setFacilityid(tipoFacility);        				
							} 		           	
			            
			          
					        tipoUnits2=unitsService.addIdUnits(tipoUnits);
			            
			      
				      }
			int idmensaje=0;
			int filasBorradas=0;
			//int filasBorradas=0;
			//Connection conexion2 = DriverManager.getConnection(conexion,userbd, passbd);
			//(PreparedStatement sentenciaPreparada = conexion2.prepareStatement(sql))
			//Statement sentenciaPreparada,sentenciaPreparadaDel,sentenciaPreparadaUpd = null;
			sentenciaPreparadaDel = conexion2.createStatement();
			sentenciaPreparada = conexion2.createStatement();
			sentenciaPreparadaUpd= conexion2.createStatement();
			 List<Integer> procesosEliminados; 
			if (idparametro!=0) {
	            try {   
	            	
	            	//private List<Integer> processes = new ArrayList<>(Arrays.asList(10, 25, 5, 30, 15));
	            	//se le coloca a la varibale el mimos nombre del apiary procesosEliminados
	            	//String listaprocesos = arrayAParentesis(datosUnidad.getProcesses());	
	            	
	            	int cuantosviene = datosUnidad.getProcesses().size();
	            	
	            	if (cuantosviene==0) {
	            		List<Integer> notiene = new ArrayList<>();

	                    // Add the integer 0 to the list
	                    notiene.add(0);
	                   // int firstValue = notiene.get(0);
	            		 procesosEliminados = unitprocessesRepository.findIdProcDelete(unitid, notiene);
	            	} else 
	            	{
	            		 procesosEliminados = unitprocessesRepository.findIdProcDelete(unitid,datosUnidad.getProcesses());
	            	}
	            	
	            	
	            	

	            	for (int i = 0; i < procesosEliminados.size(); i++) {
	            		Integer processId = procesosEliminados.get(i);
	            		
	            		
	            	    
	            	       try {
	            	      // unitprocessesRepository.borrarUnitsProcesses(tipoUnits.getId());
	            	         String sqlDel = " DELETE FROM main.unitprocesses e WHERE e.unitid =" + unitid + " and processid =" + processId;
	    	            
	    	                   sentenciaPreparadaDel.execute(sqlDel);
	    	            
	            	            } catch (Exception e) {
	  	            	  // Manejo de excepciones
	    	            	
	    	            	
	            	    	    String sqlUpd = " UPDATE main.unitprocesses set deleted = " + "'" +  fechaDate +  "'" + "  WHERE unitid =" + unitid + " and processid =" + processId;
		    	                //UPDATE main.unitprocesses set deleted = '2025-01-01' where unitid = 2 and processid = 111
		    	                 sentenciaPreparadaUpd.execute(sqlUpd);
	    	            
		    	            
	    	            	
	    	                  } 
	            	   
	            	    
	            	}
	            	
	            	

		            	for (int i = 0; i < datosUnidad.getProcesses().size(); i++) {
		            		Integer processIdNew = datosUnidad.getProcesses().get(i);
		            		boolean existerelaSinsta = unitprocessesRepository.existsByUnitidAndProcessid(unitid, processIdNew);
		            		
		            	 	int existerela = unitprocessesRepository.findProceEliminado(unitid, processIdNew);
		            		if (existerelaSinsta) {
		            	     	if (existerela==0) {
		            	 		
                                  String mensaje = "Aqui no se hace nada, ya existe y esta null el campo deleted";
		            	 		   	            	    	    					            	 	
		            	 		
		            	 	    }
		            	     	else {		            	 				            	 		 
			    	              
			    	              String sqlUpd = " UPDATE main.unitprocesses set deleted = NULL  WHERE unitid =" + unitid + " and processid =" + processIdNew;
			    	                //UPDATE main.unitprocesses set deleted = '2025-01-01' where unitid = 2 and processid = 111
		            	    	    sentenciaPreparadaUpd.execute(sqlUpd);		            	 		
		            	 		
		            	 	   }
		            		} else {
		            			
		            			    String procesos = arrayAParentesis(datosUnidad.getProcesses());			
			   		                String sql = " INSERT INTO main.unitprocesses (unitid,processid) VALUES (" + unitid + "," + processIdNew + " )";
			    	                sentenciaPreparada.execute(sql);
		            			
		            		} 	
		            	 	existerela = 0;
		            	   
		            	   
		            	    
		            	}
		            	
		            	
	            	//unitprocessesRepository.borrarUnitsProcesses(tipoUnits.getId());
	                idmensaje = unitid;
	                 conexion2 = DriverManager.getConnection(conexion,userbd, passbd);
	    			//(PreparedStatement sentenciaPreparada = conexion2.prepareStatement(sql))
	    			 sentenciaPreparada = null;
	    			sentenciaPreparada = conexion2.createStatement();

	         
	    			int cuantasuni = datosUnidad.getProcesses().size();
	    			
	    			
	                
	            } catch (Exception e) {
	            	  // Manejo de excepciones
	    			respuesta= new RespuestaMsgDto("Error borrando la relacion Unidades Procesos");
	    			estatus=HttpStatus.CONFLICT;     
	    			return new ResponseEntity(respuesta, estatus);
	            	
	            }
			} else {
				
			
				
				nuevoinsertado = unitsRepository.findByName(datosUnidad.getName());
				int idInsertado =  nuevoinsertado.get().getId();
				idmensaje = idInsertado;
				//Connection conexion = null;
				 conexion2 = DriverManager.getConnection(conexion,userbd, passbd);
				//(PreparedStatement sentenciaPreparada = conexion2.prepareStatement(sql))
				 //Statement sentenciaPreparada2 = null;
				 sentenciaPreparada2 = conexion2.createStatement();
		  
				int cuantosprocesos = datosUnidad.getProcesses().size();
				
				if (cuantosprocesos > 0 ) {
				   String procesos = arrayAParentesis(datosUnidad.getProcesses());			
		           String sqlNew = "INSERT INTO main.unitprocesses (processid,unitid) SELECT id," + idInsertado + " FROM main.processes  WHERE id IN " + procesos;
		           sentenciaPreparada2.execute(sqlNew);				
		        
			 }
			}
	          
	            		
				if (tipoUnits2!=null) { //Comprobar si es distinto de null
					
					String Resp = unitid.toString();
					respuestaValueDto= new RespuestaValueDto(idmensaje);
					//int parmid = 2;
					//respuestaValueDto= new RespuestaValueDto(userid);
					estatus=HttpStatus.OK;
					return new ResponseEntity(respuestaValueDto, estatus);
					
				}else {
					respuesta= new RespuestaMsgDto("Fallo la actualizacion");
					estatus=HttpStatus.BAD_REQUEST;
					return new ResponseEntity(respuesta, estatus);
					
				}
				
							
	       
			}catch (Exception e) {
	            // Manejo de excepciones
				respuesta= new RespuestaMsgDto("Error interno del servidor");
				estatus=HttpStatus.INTERNAL_SERVER_ERROR;            
	        } finally {
				if (entityManager != null && entityManager.isOpen()) {
					entityManager.close();
				}
				try {
				    if (sentenciaPreparadaDel != null) {
				    	sentenciaPreparadaDel.close();
				    } 
				    if (sentenciaPreparadaUpd != null) {
				    	sentenciaPreparadaUpd.close();
				    } 
				    if (sentenciaPreparada != null) {
				    	sentenciaPreparada.close();
				    } //sentenciaPreparada2
				    if (sentenciaPreparada2 != null) {
				    	sentenciaPreparada2.close();
				    } 
				    if (conexion2 != null) {
			            conexion2.close();
			        }
				} catch (SQLException e) {
				    // Maneja la excepción aquí, por ejemplo, imprimiendo el stack trace
				    e.printStackTrace();
				}
			 }
			
			return new ResponseEntity(respuesta, estatus);
		
		}
		
		public String arrayAParentesis(List<Integer> lista) {
			
		    if (lista == null || lista.isEmpty()) {
		        return "()";
		    }
		    StringBuilder sb = new StringBuilder("(");
		    for (int i = 0; i < lista.size(); i++) {
		        sb.append(lista.get(i));
		        if (i < lista.size() - 1) {
		            sb.append(", ");
		        }
		    }
		    sb.append(")");
		    return sb.toString();
		}
		
		@DeleteMapping("/units/{unitid}")
		public ResponseEntity<?> borrarUnits(HttpServletRequest request, @PathVariable("unitid") final Integer unitid)
				throws ParseException {
			RespuestaMsgDto respuesta = new RespuestaMsgDto("");
			HttpStatus estatus = HttpStatus.FORBIDDEN;
			RoleDto detalleRoles;
			PrivilegesAllDto detallePrivilege;
			
			String var = "";
			boolean bloked = false;
			RespuestaDto respuestaDto = new RespuestaDto(var, bloked);
			String sessionid = request.getHeader("Authorization");
			Date fecha = new Date();
			SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			String dataFormattata = formatter.format(fecha);
			Date fechaDate = formatter.parse(dataFormattata);
			AuditRequestDto auditDto = new AuditRequestDto();
			RespuestaValueDto respuestaValueDto;
			String searchIn = "";


			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.

			if (sessionid == null) {
				respuesta.setMsg("Llamada al servicio malformado");
				estatus=HttpStatus.BAD_REQUEST;
				return new ResponseEntity(respuesta, estatus);
			} else {
				sessionid = sessionid.substring(7);
				Optional<Users> encontreSessionUsuario = usersRepository.getBySessionid(sessionid);

				if (encontreSessionUsuario.isPresent()) {
					//Eliminar un registro de un usuario. (priv 633)

					String fechaComoCadena;
					   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);
						    fechaComoCadena  = securityService.consultarSessionActiva(FechaReg,fecha2,encontreSessionUsuario.get().getId());
						    if (fechaComoCadena=="") {
							   
							   
							   
							    String var2 = "";
								boolean bloked2 = false;
								RespuestaMsgDto respuestaDto2 = new RespuestaMsgDto(var2);
								//respuestaDto.setBlocked(bloked);
								respuestaDto2.setMsg("Sesión expirada o inválida"); 
								return new ResponseEntity(respuestaDto, HttpStatus.UNAUTHORIZED);
							   
						    }
						    
					  Roles roles = encontreSessionUsuario.get().getRolid();
					   int idrol = roles.getId();
					   int rolisvalid = auditRepository.getCantbyRolAndPrivi(idrol, 113);
					   //rolisvalid = 3;
					   if (rolisvalid==0) {
						  
						   
							//boolean bloked = false;
							RespuestaMsgDto respuestaPrivDto = new RespuestaMsgDto(var);
							//respuestaDto.setBlocked(bloked);
							respuestaPrivDto.setMsg("No tiene los Privilegios"); 
							return new ResponseEntity(respuestaPrivDto, HttpStatus.FORBIDDEN);
							
					   }
					   
					
					try {
						
						if (unitsRepository.existsById(unitid)) {
							
							  Optional<Units> uniDelete = unitsRepository.findById(unitid);
							   String module = "Unidades";
							     String Descmodule = "Se eliminó  : " + uniDelete.get().getName();
							    
						         auditDto.setIpaddr(HttpReqRespUtils.getClientIpAddressIfServletRequestExist());
						         //SimpleDateFormat  formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
						         //String dataFormattata = formatter.format(fecha);
						         //Date fechaDate = formatter.parse(dataFormattata);
						         
						         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(fechaDate);
						 		   usersService.registrarAuditSesion(auditDto); 
							
							// Borro el rol boolean existeUsers = ;
							int valor = 0;
							try {
							//usersRepository.deleteusersbyid(userid,fechaDate,valor);	
							unitsRepository.deleteunitsbyid(unitid);	
							respuestaValueDto= new RespuestaValueDto(unitid);
							
							
							estatus=HttpStatus.OK;
							return new ResponseEntity(respuestaValueDto, estatus);
							} catch (Exception e) {// Error Interno
								respuesta.setMsg("Error interno del servidor -conflicto. ");
								estatus=HttpStatus.CONFLICT;
								return new ResponseEntity(respuesta, estatus);
							} 
						} else {// Registro no encontrado
							respuesta.setMsg("Registro no encontrado");
							estatus=HttpStatus.NOT_FOUND;
							return new ResponseEntity(respuesta, estatus);
							
						}

					} catch (Exception e) {// Error Interno
						// Manejo de excepciones
						respuesta.setMsg("Error interno del servidor");
						estatus=HttpStatus.INTERNAL_SERVER_ERROR;
						return new ResponseEntity(respuesta, estatus);
					}
				} else {
					respuesta.setMsg("Sesión expirada o inválida");
					estatus=HttpStatus.UNAUTHORIZED;
					return new ResponseEntity(respuesta, estatus);
					
				}

				
			}
			
		}	
	

}
