<?php

require_once("../config/config.proxy.php");

include('functions.proxy.php');


function grabaLog($texto){

    global $configProxy;

    if(isset($configProxy['logActivar']) && $configProxy['logActivar']) {

        if(!is_dir($configProxy['logRuta'])) mkdir($configProxy['logRuta']);
        $rutaCompleta=$configProxy['logRuta'].'/'.$configProxy['logArchivo'];

        if(is_object($texto) || is_array($texto)) $texto=json_encode($texto);

        $log=fopen($rutaCompleta,'a');
        fwrite($log, date('Y-m-d h:i:s').' >>> Proxy >>> '.$texto.PHP_EOL);
        fclose($log);

    }

}

require_once("../src/Http/HttpMethod.php");
require_once("../src/Http/HttpNotFoundException.php");
require_once("../src/Http/Request.php");
require_once("../src/Http/Response.php");
require_once("../src/Routing/Route.php");
require_once("../src/Routing/Router.php");
require_once("../src/Server/PhpNativeServer.php");
require_once("../src/Server/Server.php");

require_once("../src/Services/Webservices.php");

require_once("../src/Proxium/Proxium.php");
require_once("../src/Proxium/ProxiumWS.php");
require_once("../src/Proxium/Uploads.php");

require_once("../src/Auth/Token.php");

use ProxiumWXfrm\Http\HttpNotFoundException;
use ProxiumWXfrm\Http\Request;
use ProxiumWXfrm\Http\Response;
use ProxiumWXfrm\Routing\Router;
use ProxiumWXfrm\Server\PhpNativeServer;

use ProxiumWXfrm\Services\Webservices;
use ProxiumWXfrm\Proxium\PeticionWS;

use ProxiumWXfrm\Proxium\Registro;
use ProxiumWXfrm\Proxium\Login;
use ProxiumWXfrm\Proxium\Integracion;
use ProxiumWXfrm\Proxium\Sincronizacion;

use ProxiumWXfrm\Proxium\RespuestaStandard;

use ProxiumWXfrm\Auth\Token;

use ProxiumWXfrm\Proxium\versionApp;
use ProxiumWXfrm\Proxium\versionAppDownload;

use ProxiumWXfrm\Proxium\Upload;

//require_once("../vendor/autoload.php");



if(isset($_SERVER['HTTPS']) && $_SERVER['HTTPS']=='on') $protocolo='https://';
else $protocolo='http://';

//$dominio=$_SERVER['SERVER_NAME'];
//if($_SERVER['SERVER_PORT']!='80') $puerto=':'.$_SERVER['SERVER_PORT'];
//else $puerto='';

//$rutaPublicacion=$protocolo.$dominio$puerto.$configProxy['dir_publicacion'];

$rutaPublicacion=$protocolo.$_SERVER['HTTP_HOST'].$configProxy['dir_publicacion'];

//echo $rutaPublicacion;

$router=new Router();



$router->post($configProxy['dir_publicacion'].'/uploadApp',function(Request $request){

    $version=new versionApp;
    
    $datos=$request->Data();
    $files=$request->Files();

    if($datos){

        $version->nombre=$datos['version'];
        //$version->archivoBase64=$datos['fichero'];
        $version->archivoPost=$files['fichero'];

        //$resultado=$version->nuevaVersion();
        //$resultadoJson=array('resultado'=>$resultado);
        //$response=Response::json($resultadoJson);

        $response=$version->nuevaVersion();

    }
    else $response=Response::text("Error.")->setStatus(401);

    return $response;

});

$router->get($configProxy['dir_publicacion'].'/descarga',function(Request $request){

    $parametrosQuery=$request->QueryParams();

    if($parametrosQuery['archivo']){

        global $conexionBdd;

        $archivoNombre=$parametrosQuery['archivo'];

        //FALTA LA COMPROBACION DE LA CADUCIDAD
        $consulta='
            SELECT proxiumapi_version.Archivo FROM proxiumapi_version_downloads
            INNER JOIN proxiumapi_version
                ON proxiumapi_version.Nombre=proxiumapi_version_downloads.Version
            WHERE proxiumapi_version_downloads.NombreArchivo=?
        ';
        $parametros=array($archivoNombre);

        //echo $consulta;
        //print_r($parametros);

        try {

            $temp=$conexionBdd->prepare($consulta);
            $temp->execute($parametros);
            
            if($temp->rowCount()>0) {

                $resultado=$temp->fetch();

                //////////////// CREAR UNA CLASE PARA ESTO
                $file=$resultado['Archivo'];
                $archivoTamanyo=filesize($file);
                $archivoContenido=file_get_contents($file);
                $archivo=array($archivoNombre,$archivoTamanyo,$archivoContenido);
                ////////////////

                $response=Response::downloadBinary($archivo);

            }
            

        } catch (PDOException $e) {
                
            $response=Response::text(RespuestaStandard::error(200,"Error en la descarga.")->getRespuesta());
        }
        
    
    }

    return $response;
    

});


$router->post($configProxy['dir_publicacion'].'/getVersionApp',function(Request $request){

    $respuesta=array(
        'version'=>'',
        'fechaHora'=>'',
        'url'=>'',
        'duracion'=>''
    );

    $version=new versionApp;
    //print_r($version);

    if(isset($version->nombre)) {

        $respuesta['version']=$version->nombre;
        $respuesta['fechaHora']=$version->fechaHora;

        $datos=$request->Data();

        if($datos){
            
            /*
            La peticion viene de la app, con datos post
            en este caso puede proceder de:
            - El servidor proxium, la primera vez que sube la versión, para obtener una primera url numfmt_get_error_message
            - La app de un movil, para comprobar si hay una versión nueva a descargar
            */

            if(isset($datos['version'])) $versionEnApp=$datos['version'];
            //Esto definirá si lo pide proxium
            if(isset($datos['idInstalacionDispositivo'])) $idInstalacionDispositivo=$datos['idInstalacionDispositivo'];
            else $idInstalacionDispositivo='';

            if($version->nombre!=$versionEnApp || $idInstalacionDispositivo) { 

                $enlace=new versionAppDownload;

                if(isset($datos['id'])) $dispositivo_id=$datos['id'];
                else $dispositivo_id='';
      
                $enlace->creaEnlace($dispositivo_id,$_SERVER["REMOTE_ADDR"],$version,$idInstalacionDispositivo);
                
                $respuesta['version']=$enlace->version;
                $respuesta['url']=$enlace->url;
                $respuesta['duracion']=$enlace->duracion;
        
            }

        }
        
    }

    $response=Response::text(RespuestaStandard::data($respuesta)->getRespuesta());

    //$response=Response::text('traza version');
    return $response;

});


//REGISTRO DE INSTALACIONES

$router->post($configProxy['dir_publicacion'].'/registro',function(Request $request){

    $datos=$request->Data();

    $token=new Token(
        $datos['id'],
        $_SERVER["REMOTE_ADDR"],
        $datos['token'],
        '',
        '',
        ''
    );

    
    $token->grabaLogPeticion('registro',$datos);

    if($token->validaToken()) {

        $registro=new Registro(
            $datos['id'],
            $datos['empresa'],
            $datos['apiKey'],
            $datos['tokenInstalacion'],
            $datos['instalacion']
        );
        
        $respuesta=$registro->solicitarRegistro();
        //$valores=substr($respuesta,0,10);
        //var_dump($respuesta);

        //print_r($respuesta);
        $response=Response::text($respuesta);

    }
    else {
        $response=Response::text(RespuestaStandard::error(100,"Petición no autorizada. Token no válido.")->getRespuesta());
    }

    return $response;

});



//LOGIN DE USUARIO

$router->post($configProxy['dir_publicacion'].'/login',function(Request $request){

    $datos=$request->Data();

    $token=new Token(
        $datos['id'],
        $_SERVER["REMOTE_ADDR"],
        $datos['token'],
        '',
        '',
        ''
    );

    $token->grabaLogPeticion('login',$datos);
    
    if($token->validaToken()) {

        $login=new Login(
            $datos['id'],
            $datos['empresa'],
            $datos['usuario'],
            $datos['clave'],
            $datos['matricula'],
            ''
        );
        
        $loginOk=$login->login();
        $response=Response::text($loginOk);

    }
    else {
        $response=Response::text(RespuestaStandard::error(100,"Petición no autorizada. Token no válido.")->getRespuesta());
    }
    
    //$response=Response::text('Traza login');

    return $response;

});

$router->post($configProxy['dir_publicacion'].'/refreshTokenLogin',function(Request $request){

    $datos=$request->Data();

    $token=new Token(
        $datos['id'],
        $_SERVER["REMOTE_ADDR"],
        $datos['token'],
        '',
        '',
        ''
    );

    //$token->grabaLogPeticion('login',$datos);
    
    if($token->validaToken()) {

        $login=new Login(
            $datos['id'],
            $datos['empresa'],
            $datos['usuario'],
            '',
            $datos['matricula'],
            $datos['tokenLogin']
        );
        
        $refreshOk=$login->refreshTokenLogin();
        $response=Response::text($refreshOk);

    }
    else {
        $response=Response::text(RespuestaStandard::error(100,"Petición no autorizada. Token no válido.")->getRespuesta());
    }

    return $response;

});

$router->post($configProxy['dir_publicacion'].'/logout',function(Request $request){

    $datos=$request->Data();

    $token=new Token(
        $datos['id'],
        $_SERVER["REMOTE_ADDR"],
        $datos['token'],
        '',
        '',
        ''
    );

    $token->grabaLogPeticion('logout',$datos);
    
    if($token->validaToken()) {

        $login=new Login(
            $datos['id'],
            $datos['empresa'],
            $datos['usuario'],
            '',
            $datos['matricula'],
            $datos['tokenLogin']
        );
        
        $logoutOk=$login->logout();
        $response=Response::text($logoutOk);

    }
    else {
        $response=Response::text(RespuestaStandard::error(100,"Petición no autorizada. Token no válido.")->getRespuesta());
    }

    return $response;

});


//VALIDACION DE TOCKENS DE LA PROPIA API CONTRA MYSQL

$router->post($configProxy['dir_publicacion'].'/getToken',function(Request $request){

    $datos=$request->Data();

    $token=new Token(
        $datos['id'],
        $_SERVER["REMOTE_ADDR"],
        '',
        '',
        '',
        $datos['apiKeyApp']
    );

    $token->grabaLogPeticion('getToken',$datos);

    if($token->validaApiKeyPrivada()) {

        $response=$token->generaToken();

    }
    else {
        $response=Response::text(RespuestaStandard::error(100,"Petición no autorizada. Credenciales API no válidas.")->getRespuesta());
    }

    return $response;

});


//RUTINA PING

$router->post($configProxy['dir_publicacion'].'/ping',function(Request $request){

    $datosToken=$request->Data();

    //print_r($datosToken);
    
    $token=new Token(
        $datosToken['id'],
        $_SERVER["REMOTE_ADDR"],
        $datosToken['token'],
        '',
        '',
        ''
    );
    
    if($token->validaToken()) {
    
        $peticion=new PeticionWS(
            '/Ping',
            ''
        );

        $resultado=$peticion->lanzaGet();

        //$pingCache='';
        //if($resultado->valor=='OK') $pingCache=1;
        //else $pingCache=0;
        $pingCache=$resultado->valor;

        $resultadoPing=array(
            'estadoServidorWeb'=>1,
            'estadoServidorCache'=>$pingCache
        );

        //$response=Response::json($resultadoPing);
        $response=Response::text(RespuestaStandard::data($resultadoPing)->getRespuesta());

    }
    else {
        $response=Response::text(RespuestaStandard::error(100,"Petición no autorizada. Token no válido.")->getRespuesta());
    }

    
    return $response;

});


//LISTA DE SERVICIOS PARA LA APP

$router->post($configProxy['dir_publicacion'].'/listaServicios',function(Request $request){

    $datos=$request->Data();

    $token=new Token(
        $datos['id'],
        $_SERVER["REMOTE_ADDR"],
        $datos['token'],
        '',
        '',
        ''
    );
    
    if($token->validaToken()) {
    
        $urlLlamada='/listaServicios';
        
        $parametrosLlamada=json_encode(
            array(
                'id'=>$datos['id'],
                'empresa'=>$datos['empresa'],
                'usuario'=>$datos['usuario'],
                'matricula'=>$datos['matricula'],
                'tokenLogin'=>$datos['tokenLogin']
            )
        );
        
        
        $peticion=new PeticionWS($urlLlamada,$parametrosLlamada);

        $resultado=$peticion->lanzaPostRaw(false);

        $response=Response::text($resultado);

    }
    else {
        $response=Response::text(RespuestaStandard::error(100,"Petición no autorizada. Token no válido.")->getRespuesta());
    }

    
    return $response;

});


//LISTA DE TAREAS DEL SERVICIO PARA LA APP

$router->post($configProxy['dir_publicacion'].'/listaServiciosTareas',function(Request $request){

    $datos=$request->Data();

    $token=new Token(
        $datos['id'],
        $_SERVER["REMOTE_ADDR"],
        $datos['token'],
        '',
        '',
        ''
    );
    
    if($token->validaToken()) {
    
        $urlLlamada='/listaServiciosTareas';
        
        $parametrosLlamada=json_encode(
            array(
                'id'=>$datos['id'],
                'empresa'=>$datos['empresa'],
                'usuario'=>$datos['usuario'],
                'matricula'=>$datos['matricula'],
                'tokenLogin'=>$datos['tokenLogin'],
                'tipoServicio'=>$datos['tipoServicio']
            )
        );
        
        
        $peticion=new PeticionWS($urlLlamada,$parametrosLlamada);

        $resultado=$peticion->lanzaPostRaw(false);

        $response=Response::text($resultado);

    }
    else {
        $response=Response::text(RespuestaStandard::error(100,"Petición no autorizada. Token no válido.")->getRespuesta());
    }

    
    return $response;

});

$router->post($configProxy['dir_publicacion'].'/datosTarea',function(Request $request){

    $datos=$request->Data();

    $token=new Token(
        $datos['id'],
        $_SERVER["REMOTE_ADDR"],
        $datos['token'],
        '',
        '',
        ''
    );
    
    if($token->validaToken()) {
    
        
        $urlLlamada='/datosTarea';
        
        $parametrosLlamada=json_encode(
            array(
                'id'=>$datos['id'],
                'empresa'=>$datos['empresa'],
                'usuario'=>$datos['usuario'],
                'matricula'=>$datos['matricula'],
                'tokenLogin'=>$datos['tokenLogin'],
                'tipoServicio'=>$datos['tipoServicio'],
                'idTarea'=>$datos['idTarea'],
                'estado'=>$datos['estado'],
                'datosTarea'=>$datos['datosTarea'],
            )
        );
        
        $peticion=new PeticionWS($urlLlamada,$parametrosLlamada);

        $resultado=$peticion->lanzaPostRaw(false);
        
        $response=Response::text($resultado);

    }
    else {
        $response=Response::text(RespuestaStandard::error(100,"Petición no autorizada. Token no válido.")->getRespuesta());
    }

    
    return $response;

});


//GESTION SUBIDA Y DESCARGA DOCUMENTOS

$router->get($configProxy['dir_publicacion'].'/uploadDoc/descarga',function(Request $request){

    $datos=$request->QueryParams();

    $archivo=new Upload();
    $archivo->archivo=$datos['id'];
    $archivo->setRutaArchivo();
    $archivo->nombreArchivoFinal=base64_decode($datos['file']);
    $archivo->paramOperacion=base64_decode($datos['params']);
    $archivo->signature=$datos['signature'];

    $response=$archivo->obtenerArchivo();

    return $response;

});

$router->get($configProxy['dir_publicacion'].'/uploadDoc/borrado',function(Request $request){

    $datos=$request->QueryParams();

    $archivo=new Upload();
    $archivo->archivo=$datos['id'];
    $archivo->setRutaArchivo();
    $archivo->nombreArchivoFinal=base64_decode($datos['file']);
    $archivo->paramOperacion=base64_decode($datos['params']);
    $archivo->signature=$datos['signature'];

    $response=$archivo->borrarArchivo();

    return $response;

});

$router->post($configProxy['dir_publicacion'].'/uploadDoc',function(Request $request){

    $datos=$request->Data();
    $files=$request->Files();
    
    $token=new Token(
        $datos['id'],
        $_SERVER["REMOTE_ADDR"],
        $datos['token'],
        '',
        '',
        ''
    );
    
    if($token->validaToken()) {

        $item=$files['archivo']; 

        $paramOperacion=$datos['paramOperacion'];

        $archivo=new Upload();
        
        if($archivo->subirArchivo($item,$paramOperacion)) {

            //print_r($archivo);

            $urlLlamada='/uploadDoc';

            $parametrosLlamada=json_encode(
                array(
                    'id'=>$datos['id'],
                    'empresa'=>$datos['empresa'],
                    'usuario'=>$datos['usuario'],
                    'matricula'=>$datos['matricula'],
                    'tokenLogin'=>$datos['tokenLogin'],
                    
                    'urlDescarga'=>$archivo->urlDescarga,
                    'urlBorrado'=>$archivo->urlBorrado,
                    'nombreArchivo'=>$archivo->nombreArchivoFinal,

                    'paramOperacion'=>$paramOperacion
                )
            );

            //print_r($parametrosLlamada);

            $peticion=new PeticionWS($urlLlamada,$parametrosLlamada);

            //// ATENCION!!!!!!!! COMENTADO PARA QUE NO LO ENVIE A PROXIUM MIENTRAS
            //// NO TERMINEMOS DE DEPURAR LA APP
            //$resultado=$peticion->lanzaPostRaw(false);
            //$response=Response::text($resultado);

            //$response=Response::text('Traza upload');
            $response=Response::text('{"valor":1,"data":{"resultado":1},"errores":""}');

        }
        else {
            $response=Response::text(RespuestaStandard::error(601,"Error de datos en la subida del archivo.")->getRespuesta());
        }

    }
    else {
        $response=Response::text(RespuestaStandard::error(100,"Petición no autorizada. Token no válido.")->getRespuesta());
    }

    
    return $response;

});



//METODOS GENERICOS SIMPLES PARA INTERFACES WEB

$router->post($configProxy['dir_publicacion'].'/pedirDatos',function(Request $request){

    $urlLlamada='/peticion';

    $datos=$request->Data();

    $parametrosLlamada=json_encode(
        array(
            'id'=>$datos['id'],
            'empresa'=>$datos['empresa'],
            'usuario'=>$datos['usuario'],
            'password'=>$datos['password'],
            'metodo'=>'PedirDatos',
            'peticion'=>$datos['peticion'],
        )
    );

    //print_r($parametrosLlamada);
    
   if(isset($datos['urlServicioCache'])) $urlServicioCache=$datos['urlServicioCache'];
	else $urlServicioCache=NULL;
    
    $peticion=new PeticionWS($urlLlamada,$parametrosLlamada,true,$urlServicioCache);
	//print_r($peticion);
	
    $resultado=$peticion->lanzaPostRaw(false);

    $response=Response::text($resultado);
    
    //$response=Response::text('Hola');
    

    return $response;

});

$router->post($configProxy['dir_publicacion'].'/enviarDatos',function(Request $request){

    $urlLlamada='/peticion';

    $datos=$request->Data();

    $parametrosLlamada=json_encode(
        array(
            'id'=>$datos['id'],
            'empresa'=>$datos['empresa'],
            'usuario'=>$datos['usuario'],
            'password'=>$datos['password'],
            'metodo'=>'EnviarDatos',
            'peticion'=>$datos['peticion'], //Atencion, la peticion como es el archivo de enviarDatos tiene que llegar en base64 no en string como pedirDatos
        )
    );

    $peticion=new PeticionWS($urlLlamada,$parametrosLlamada,true);

    $resultado=$peticion->lanzaPostRaw(false);
    
    $response=Response::text($resultado);

    //$response=Response::text('Hola');
    
    return $response;

});

$router->post($configProxy['dir_publicacion'].'/imprimirDocumento',function(Request $request){

    $urlLlamada='/peticion';

    $datos=$request->Data();

    //echo $datos['archivoFirma'];

    $parametrosLlamada=json_encode(
        array(
            'id'=>$datos['id'],
            'empresa'=>$datos['empresa'],
            'usuario'=>$datos['usuario'],
            'password'=>$datos['password'],
            'metodo'=>'ImprimirDocumento',
            'peticion'=>$datos['peticion'],
            'archivoFirma'=>$datos['archivoFirma']
        )
    );
    
    $peticion=new PeticionWS($urlLlamada,$parametrosLlamada,true);

    $resultado=$peticion->lanzaPostRaw(false);
    
    $response=Response::text($resultado);
    
    

    //$response=Response::text('Hola');
    

    return $response;

});

$router->post($configProxy['dir_publicacion'].'/uploadDocSimple/existeArchivo',function(Request $request){

    global $configProxy;

    $datos=$request->Data();

    $UUID=$datos['UUID'];
    if(isset($datos['nombreArchivo'])) $nombreArchivo=$datos['nombreArchivo']; //Atencion, en los otros metodos relacionados el parametro es id
    else if(isset($datos['id'])) $nombreArchivo=$datos['id'];

    if(isset($nombreArchivo)) {

        $rutaRaiz=$_SERVER["DOCUMENT_ROOT"].$configProxy['dir_publicacion'].$configProxy['dir_data'].$configProxy['dir_uploads'];

        if($UUID) $rutaRaiz.='/'.$UUID;
        $rutaArchivo=$rutaRaiz.'/'.$nombreArchivo;

        if (file_exists($rutaArchivo)) {
            $response=Response::text(RespuestaStandard::data('ok')->getRespuesta());

        }
        else $response=Response::text(RespuestaStandard::error(2,"No se ha podido acceder al archivo o el archivo no existe.")->getRespuesta());

    }
    else $response=Response::text(RespuestaStandard::error(1,"No se ha recibido id del archivo.")->getRespuesta());

    //$response=Response::text('Hola');

    return $response;

});

$router->post($configProxy['dir_publicacion'].'/uploadDocSimple/descarga',function(Request $request){

    global $configProxy;

    $datos=$request->Data();

    if($datos) {

        $UUID=$datos['UUID'];
        if(isset($datos['nombreArchivo'])) $nombreArchivo=$datos['nombreArchivo']; //Atencion, en los otros metodos relacionados el parametro es id
        else if(isset($datos['id'])) $nombreArchivo=$datos['id'];
        else $nombreArchivo='';

        if($nombreArchivo) {

            $rutaRaiz=$_SERVER["DOCUMENT_ROOT"].$configProxy['dir_publicacion'].$configProxy['dir_data'].$configProxy['dir_uploads'];

            if($UUID) $rutaRaiz.='/'.$UUID;
            $rutaArchivo=$rutaRaiz.'/'.$nombreArchivo;

            if (file_exists($rutaArchivo)) {

                $contenido=base64_encode(file_get_contents($rutaArchivo));

                $response=Response::text(RespuestaStandard::data($contenido)->getRespuesta());

            }
            else $response=Response::text(RespuestaStandard::error(3,"No se ha podido acceder al archivo o el archivo no existe.")->getRespuesta());

        }
        else $response=Response::text(RespuestaStandard::error(2,"Algunos de los datos POST son incorrectos o no han sido recibidos.")->getRespuesta());

    }
    else $response=Response::text(RespuestaStandard::error(1,"No se han recibido datos POST.")->getRespuesta());

    return $response;

});

$router->post($configProxy['dir_publicacion'].'/uploadDocSimple/borrado',function(Request $request){

    global $configProxy;
    global $dir_catalogo;

    $datosPost=$request->Data();

    $UUID=$datosPost['UUID'];
	
    //$nombreArchivo=$datosPost['id'];
	if(isset($datosPost['nombreArchivo'])) $nombreArchivo=$datosPost['nombreArchivo']; //Atencion, en los otros metodos relacionados el parametro es id
	else if(isset($datosPost['id'])) $nombreArchivo=$datosPost['id'];
	else $nombreArchivo='';
	
    if(isset($datosPost['esCatalogo'])) $esCatalogo=$datosPost['esCatalogo'];

    $rutaRaiz=$_SERVER["DOCUMENT_ROOT"].$configProxy['dir_publicacion'].$configProxy['dir_data'].$configProxy['dir_uploads'];

    if(isset($esCatalogo) && isset($dir_catalogo)) {
        $rutaGrabado=$dir_catalogo;
    }
    else {
        $rutaGrabado=$rutaRaiz;
    }

    if($UUID) $rutaGrabado.='/'.$UUID;

    $rutaGrabado=str_replace('\\','/',$rutaGrabado);

    if( file_exists($rutaGrabado.'/'.$nombreArchivo) ) {

        $resultado=unlink($rutaGrabado.'/'.$nombreArchivo);	

        if( $resultado ) $response=Response::text(RespuestaStandard::data('Ok')->getRespuesta());
        else $response=Response::text(RespuestaStandard::error(1,"No se ha podido borrar el archivo.")->getRespuesta());

        //Comprobamos si el dir está vacío para borrarlo. Esto no condiciona el mensaje de error
		if($UUID) {
			$directorio = opendir($rutaGrabado);
			if($directorio) {
				$hayArchivos=false;
				while ($archivo = readdir($directorio)) {
					if( !is_dir($archivo)) $hayArchivos=true;
				}
				if(!$hayArchivos) rmdir($rutaGrabado);
			}
		}
    }
    else $response=Response::text(RespuestaStandard::error(1,"El archivo no existe.")->getRespuesta());

    //$response=Response::text('Hola');

    return $response;

});

$router->post($configProxy['dir_publicacion'].'/uploadDocSimple/borradoDirectorio',function(Request $request){

    global $configProxy;

    $datos=$request->Data();

    $UUID=$datos['UUID'];

    $rutaGrabado='..'.$configProxy['dir_data'].$configProxy['dir_uploads'].'/'.$UUID;

    $directorio = opendir($rutaGrabado);

    if($directorio) {

        while ($archivo = readdir($directorio)) {
            if( !is_dir($archivo)) {
                $resultado=unlink($rutaGrabado.'/'.$archivo);	
            }	
        }
        
        $resultado = ($resultado & rmdir($rutaGrabado));
        
        if( $resultado ) $response=Response::text(RespuestaStandard::data('Ok')->getRespuesta());
        else $response=Response::text(RespuestaStandard::error(1,"No se ha podido borrar el directorio.")->getRespuesta());

    }
    else $response=Response::text(RespuestaStandard::error(1,"El directorio no existe.")->getRespuesta());

    return $response;

});

$router->post($configProxy['dir_publicacion'].'/uploadDocSimple',function(Request $request){

	global $configProxy;
    global $dir_catalogo;

    $datosPost=$request->Data();

    $UUID=$datosPost['UUID'];
	$UUID=str_replace('\\','/',$UUID);

    $nombreArchivo=$datosPost['id'];
    $extensionUTF8=((substr($nombreArchivo, -4)==".txt")||(substr($nombreArchivo, -5)==".json"));
    $datos=$datosPost['data'];
    if(isset($datosPost['esCatalogo'])) $esCatalogo=$datosPost['esCatalogo'];

    $rutaRaiz=$_SERVER["DOCUMENT_ROOT"].$configProxy['dir_publicacion'].$configProxy['dir_data'].$configProxy['dir_uploads'];
    
    //echo '<p>Ruta dir_data: '.$configProxy['dir_data'].'</p>';
    //echo '<p>Ruta dir_uploads: '.$configProxy['dir_uploads'].'</p>';

    //echo ' esCatalogo: '.$esCatalogo;
    //echo ' dir_catalogo: '.$dir_catalogo;
    
    if(isset($esCatalogo) && isset($dir_catalogo)) {
        //$rutaGrabado=$dir_catalogo.'/'.$UUID;
   		$rutaGrabado=$dir_catalogo;
    }
    else {
       // $rutaGrabado=$rutaRaiz.'/'.$UUID;
    	$rutaGrabado=$rutaRaiz;
    }

    
    
    $rutaGrabado=str_replace('\\','/',$rutaGrabado);

	$rutaGrabadoCompleta=$rutaGrabado;
	if($UUID!='') $rutaGrabadoCompleta.='/'.$UUID;

    //echo '<p>Ruta grabado: '.$rutaGrabado.'</p>';
	//echo '<p>Ruta grabado completa: '.$rutaGrabadoCompleta.'</p>';


    if(!file_exists($rutaGrabadoCompleta)) {

        
        //echo '<p>No se ha encontrado la ruta. Procedemos a crear los directorios.</p>';

        $dirs=explode('/',$UUID);

        //print_r($dirs);
        
        $dirCrear=$rutaGrabado;

        foreach($dirs as $dir) {

            if($dir!='') $dirCrear.='/'.$dir;
        
        	//echo '<p>dirCrear: '.$dirCrear.'</p>';

            if($dir!='..' && !file_exists($dirCrear)) {
                mkdir($dirCrear);
                chmod($dirCrear,0777);
            }

        }
            

    }
        
    
    $nombre_archivo=$rutaGrabadoCompleta.'/'.$nombreArchivo;

    
    if( $archivo = fopen($nombre_archivo,'w') ) {

        $contenido=base64_decode($datos);
        if ($extensionUTF8) $contenido=utf8_encode($contenido);

        $resultado=fwrite($archivo,$contenido);
        fclose($archivo);
        
        if($resultado) $response=Response::text(RespuestaStandard::data('Ok')->getRespuesta());
        else $response=Response::text(RespuestaStandard::error(1,"No se ha podido volcar el contenido del archivo.")->getRespuesta());
    }
    else $response=Response::text(RespuestaStandard::error(1,"No se ha podido crear el archivo.")->getRespuesta());
    
    

    //$response=Response::text('Hola');

    return $response;

});




////////////// METODOS PARA LA SUBIDA Y GESTION DE DOCUMENTOS DE USUARIO - DOCSUSUARIO (FOTOS SGA) //////////////////

function docsUsuariosRuta($proceso,$id,$empresa) {

	global $configProxy;

    $rutaDocumentosUsuario='';

    if (isset($configProxy['dir_uploads_users_SGA'])) {

        $rutaRaiz=$_SERVER["DOCUMENT_ROOT"].$configProxy['dir_publicacion'].$configProxy['dir_data'].$configProxy['dir_uploads'];

        $rutaDocumentosUsuario=$rutaRaiz.$configProxy['dir_uploads_users_SGA'].'/'.$empresa.'/'.$proceso.'/'.$id;

        //echo $rutaDocumentosUsuario;

    }
    else if (isset($configProxy['dir_uploads_users_tracking'])) {

        switch($proceso) {
            case 'pedidos':
                $rutaDocumentosUsuario=$configProxy['dir_uploads_users_tracking'].'/'.$id;
                break;
            case 'entradas':
                $rutaDocumentosUsuario=$configProxy['dir_uploads_users_tracking'].'/entradas/'.$id;
                break;
                 
        }
    }

    $rutaDocumentosUsuario=str_replace('\\','/',$rutaDocumentosUsuario);

    return $rutaDocumentosUsuario;

}

$router->post($configProxy['dir_publicacion'].'/docsUsuarios/listado',function(Request $request){

    $datosPost=$request->Data();

    $proceso=$datosPost['proceso'];
    $id=$datosPost['id'];
    $empresa=$datosPost['empresa'];

    $rutaDocumentosUsuario=docsUsuariosRuta($proceso,$id,$empresa);

    //echo '---rutaDocumentosUsuario: '.$rutaDocumentosUsuario.'----';
    //echo 'rutaDocumentosUsuario completa: '.$rutaRaiz.$rutaDocumentosUsuario;

    $archivosSubidos = array();

    if(file_exists($rutaDocumentosUsuario)) {

        $directorio = opendir($rutaDocumentosUsuario);

        if($directorio) {

            while ($archivo = readdir($directorio)) {

                if( $archivo != "." && $archivo != ".." && $archivo!="Thumbs.db" ) {
                    $archivosSubidos[] = $archivo;
                }

                if(count($archivosSubidos)>0) {
                    
                    $contenido=json_encode($archivosSubidos,JSON_UNESCAPED_UNICODE);

                    $response=Response::text(RespuestaStandard::data($contenido)->getRespuesta());

                }
                else $response=Response::text(RespuestaStandard::error(1,"No hay documentos para obtener.")->getRespuesta());
            }
        }
        else $response=Response::text(RespuestaStandard::error(1,"No hay documentos para obtener.")->getRespuesta());
    
    }
    else { //Se devuelve array vacío

        $contenido=json_encode($archivosSubidos);
        $response=Response::text(RespuestaStandard::data($contenido)->getRespuesta());

    }

    return $response;

});

$router->post($configProxy['dir_publicacion'].'/docsUsuarios/upload',function(Request $request){

    $datosPost=$request->Data();

    $proceso=$datosPost['proceso'];
    $id=$datosPost['id'];
    $empresa=$datosPost['empresa'];
    $archivo=$datosPost['archivo'];
    $datos=$datosPost['datos'];

    //echo 'proceso: '.$proceso.'----';

    $rutaDocumentosUsuario=docsUsuariosRuta($proceso,$id,$empresa);

    // ATENCION!! Los pedidos se graban en la raiz, NO se crea la subcarpeta "pedidos" como sí ocurre con otros procesos

    //echo '<p>rutaDocumentosUsuario: '.$rutaDocumentosUsuario.'-----</p>';

    
    if(!file_exists($rutaDocumentosUsuario)) {
        $directorios=explode('/',$rutaDocumentosUsuario);
        $construccion='';
        foreach($directorios as $directorio) {
            
            //if($construccion!='') $construccion.='/'; /////ATENCION ESTO EN WINDOWS (c:/dir) Y LINUX (/var) SE COMPORTARÁ DISTINTO
            //$construccion.='/'.$directorio;

            if (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') {
                if($construccion!='') $construccion.='/';
                $construccion.=$directorio;
            }
            else {
                $construccion.='/'.$directorio;
            }

            if(!file_exists($construccion)) {
                $creacion=mkdir($construccion);
                //echo '<p>-----Se crea: '.$construccion.' --> ('.$creacion.') -----</p>';
            }
        }
    }

    
    $rutaArchivo=$rutaDocumentosUsuario.'/'.$archivo;
    
    //echo '<p>rutaArchivo: '.$rutaArchivo.'</p>';

    
    if( $archivo = fopen($rutaArchivo,'w') ) {

        $contenido=base64_decode($datos);

        $resultado=fwrite($archivo,$contenido);
        fclose($archivo);
        
        if($resultado) $response=Response::text(RespuestaStandard::data('Ok')->getRespuesta());
        else $response=Response::text(RespuestaStandard::error(1,"No se ha podido volcar el contenido del archivo.")->getRespuesta());

    }
    else $response=Response::text(RespuestaStandard::error(1,"No se ha podido crear el archivo.")->getRespuesta());
    
    
    //$response=Response::text('##FIN##');
    
    return $response;

});

$router->post($configProxy['dir_publicacion'].'/docsUsuarios/descarga',function(Request $request){

    $datos=$request->Data();

    $datosPost=$request->Data();

    $proceso=$datosPost['proceso'];
    $id=$datosPost['id'];
    $empresa=$datosPost['empresa'];
    $archivo=$datosPost['archivo'];

    $rutaDocumentosUsuario=docsUsuariosRuta($proceso,$id,$empresa);
    $rutaArchivo=$rutaDocumentosUsuario.'/'.$archivo;

    //echo '<p>rutaArchivo: '.$rutaArchivo.'</p>';

    
    if (file_exists($rutaArchivo)) {

        $contenido=base64_encode(file_get_contents($rutaArchivo));

        $response=Response::text(RespuestaStandard::data($contenido)->getRespuesta());

    }
    else $response=Response::text(RespuestaStandard::error(1,"No se ha podido acceder al archivo o el archivo no existe.")->getRespuesta());
    

    //$response=Response::text('Hola');

    return $response;

});

$router->post($configProxy['dir_publicacion'].'/docsUsuarios/borrado',function(Request $request){

    $datos=$request->Data();

    $datosPost=$request->Data();

    $proceso=$datosPost['proceso'];
    $id=$datosPost['id'];
    $empresa=$datosPost['empresa'];
    $archivo=$datosPost['archivo'];

    $rutaDocumentosUsuario=docsUsuariosRuta($proceso,$id,$empresa);
	$rutaArchivo=$rutaDocumentosUsuario.'/'.$archivo;
	//echo '<p>rutaArchivo: '.$rutaArchivo.'</p>';

    
    if (file_exists($rutaArchivo)) {

        unlink($rutaArchivo);

        //Comprobamos si el dir está vacío para borrarlo. Esto no condiciona el mensaje de error
        $directorio = opendir($rutaDocumentosUsuario);
        if($directorio) {
            $hayArchivos=false;
            while ($archivo = readdir($directorio)) {
                if( !is_dir($archivo)) $hayArchivos=true;
            }
            if(!$hayArchivos) rmdir($rutaDocumentosUsuario);
        }

        $response=Response::text(RespuestaStandard::data('Ok')->getRespuesta());

    }
    else $response=Response::text(RespuestaStandard::error(1,"No se ha podido acceder al archivo o el archivo no existe.")->getRespuesta());
    

    //$response=Response::text('Hola');

    return $response;

});

///////////// FIN DOCSUSUARIO //////////////////


$router->post($configProxy['dir_publicacion'].'/peticionRESTBasica',function(Request $request){

    $datos=$request->Data();

    return peticionRestBasica($datos);


});

/*
$router->post($configProxy['dir_publicacion'].'/peticionRESTBasica',function(Request $request){

    //grabaLog('Funcion peticionRESTBasica en proxy');

    $datos=$request->Data();


    $peticionFinal=base64_decode($datos['peticion']);

    
    //$token=new Token(
    //    $datos['id'],
    //    $_SERVER["REMOTE_ADDR"],
    //    $datos['token'],
    //    '',
    //    '',
    //    ''
    //);
    
    
    //if($token->validaToken()) {
    
        
        $urlLlamada='/peticion';
        
        $parametrosLlamada=json_encode(
            array(
                'id'=>$datos['id'],
                'empresa'=>$datos['empresa'],
                'usuario'=>$datos['usuario'],
                'password'=>$datos['password'],
                'metodo'=>$datos['metodo'],
                'peticion'=>$peticionFinal
                //'peticion'=>$datos['peticion']
            )
        );

        //grabaLog($parametrosLlamada);
        
        $peticion=new PeticionWS($urlLlamada,$parametrosLlamada);

        $resultado=$peticion->lanzaPostRaw(false);

        $response=Response::text($resultado);
        

    //}
    //else {
    //    $response=Response::text(RespuestaStandard::error(100,"Petición no autorizada. Token no válido.")->getRespuesta());
    //}

    
    //$response=Response::text('hola');
    
    return $response;
    

});
*/



//EJEMPLO PRIMERA RUTINA PARA SUBIR FOTOS --> NO VÁLIDA

/*

$router->post($configProxy['dir_publicacion'].'/peticion',function(Request $request){ ///NO TIENE PORQUE FUNCIONAR, ES UNA PRIMERA VERSION, LUEGO CLASES MODIFICADAS !!!

    global $configProxy;

    $data=$request->Data();
    $files=$request->Files();

    $datos=$data['datos'];


    $datosToken=json_decode($data['token']);

    $token=new Token(
        $datosToken->id,
        $_SERVER["REMOTE_ADDR"],
        '',
        '',
        '',
        ''
    );

    
    if($token->validaToken()) {
    
        $archivosSubidos=array();
        $subidaOk=true;
        $directorio=$_SERVER['DOCUMENT_ROOT'].$configProxy['dir_publicacion'].$configProxy['dir_tmp'];

        foreach($files as $item) {

            $temporal=$item['tmp_name'];
            $nombre=$item['name'];
            $archivo=$directorio.'/'.date('Ymdhis').'.'.bin2hex(random_bytes(16));

            if(move_uploaded_file($temporal,$archivo)) $archivosSubidos[$nombre]=$archivo;
            else $subidaOk=false;

        }

        if($subidaOk) {


            function makeCurlFile($file){
                $mime = mime_content_type($file); //extension fileinfo
                $info = pathinfo($file);
                $name = $info['basename'];
                $output = new CURLFile($file, $mime, $name);
                return $output;
            }

           
            $parametros=array();
            $nombres=array();
            $contador=0;
            
            foreach($archivosSubidos as $nombre=>$temporal) {
                
                $nombreArchivo='archivo'.$contador;
                $archivo = makeCurlFile($temporal);
                $parametros[$nombreArchivo]=$archivo;
                $nombres[$nombreArchivo]=$nombre;
                $contador++;

            }
             
            $parametros['datos']=$datos; //esto será un json con datos de ws y parametros
            $parametros['datosFiles']=json_encode($nombres);
            
            //print_r($parametros);

            
            
            $curl = curl_init($configProxy['ws_url']); //extension curl

            curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
            curl_setopt($curl, CURLOPT_POST, true);
            curl_setopt($curl, CURLOPT_POSTFIELDS, $parametros);

            curl_setopt($curl, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
            curl_setopt($curl, CURLOPT_USERPWD, "$configProxy['ws_usuario']:$configProxy['ws_clave']");

            $cabeceras=array();
            $cabeceras[]="Content-Type: multipart/form-data";
            //$cabeceras[]="Content-length: ".strlen($data);
            $cabeceras[]="Accept: *\/*";
            $cabeceras[]="Accept-Encoding: identity";
            $cabeceras[]="Connection: keep-alive";
            
            curl_setopt($curl, CURLOPT_HTTPHEADER, $cabeceras);

            $respuesta_curl=curl_exec($curl);
            curl_close($curl);

            //GESTION BORRADO TEMPORALES
            foreach($archivosSubidos as $item) {
            }

            $response=Response::text($respuesta_curl);

            
     
            //$response=Response::text('OK');
        }
        else{

            foreach($archivosSubidos as $archivo) unlink($archivo);

            $response=Response::text("Error en la subida de archivos.")->setStatus(500);
        }

    }
    else $response=Response::text("Petición no autorizada. Token no válido.")->setStatus(401);


    //$response=Response::text("OK.");
    return $response;

});

*/


//// SINCRONIZACION DE TABLAS ENTRE PROXIUM Y PROXY

$router->post($configProxy['dir_publicacion'].'/sincronizacion',function(Request $request){

    global $configProxy;
    global $conexionBdd;

    $datos=$request->Data();

    //$indices=array('EMP','Cliente','Codigo');
    //echo base64_encode(json_encode($indices));
    //          WyJFTVAiLCJDbGllbnRlIiwiQ29kaWdvIl0=
    

    $tabla=$datos['tabla'];
    $indices=json_decode(base64_decode($datos['indices']));

    //print_r($indices);
    //echo 'indice 0: '.$indices[0];

    $sincronizacion=new Sincronizacion($tabla,$indices);

    /*
    $temp='{
        "EMP":"PXPU",
        "Cliente":"1",
        "Codigo":"1",
        "Descripcion":"Este es el primero que sincronizo",
        "PartidaArancelaria":"",
        "PresentacionEmbalajePrimario":"",
        "PesoBrutoEPKg":"100",
        "PesoNetoEPKg":"",
        "VolumenEPm3":"",
        "Valor":"",
        "ControlLote":"S",
        "ControlCaducidad":""
        }';
    $temp=json_decode($linea);
    
    echo base64_encode(json_encode($temp));
    */
    

    //$linea=json_decode(base64_decode($datos['linea']));
    $linea=base64_decode($datos['linea']);
    $linea=mb_convert_encoding($linea,'UTF-8','ISO-8859-1'); ///// !!!!!!!!!!!!!!!!! ////////
    $linea=json_decode($linea);

    $metodo=$datos['metodo'];

    
    $resultado = $sincronizacion->sincroniza($linea,$metodo);

    if($resultado) {
        $response=Response::text(RespuestaStandard::data('Ok')->getRespuesta());
    } else {
        $response=Response::text(RespuestaStandard::error(100,'No se ha podido sincronizar.')->getRespuesta());
    }
        
    
    //$response=Response::text('hola');
    
    return $response;

});


$router->post($configProxy['dir_publicacion'].'/integracion/crea',function(Request $request){

    global $configProxy;
    global $conexionBdd;

    $datos=$request->Data();

    $tipoWeb=$datos['tipoWeb'];
    $tipoProceso=$datos['tipoProceso'];
    $empresa=$datos['empresa'];
    $cliente=$datos['cliente'];
    $usuario=$datos['usuario'];

    $UUID=$datos['UUID'];
    $id=$datos['id'];
    $idProceso=$datos['idProceso'];

    $estado='CREACION';

    //grabaLog('tipoWeb: '.$tipoWeb);
    //grabaLog('tipoProceso: '.$tipoProceso);
    //grabaLog('empresa: '.$empresa);
    //grabaLog('cliente: '.$cliente);
    //grabaLog('usuario: '.$usuario);

    $integracion=new Integracion($tipoWeb,$tipoProceso,$empresa,$cliente,$usuario);

    //grabaLog($integracion);

    //grabaLog('UUID: '.$UUID);
    //grabaLog('id: '.$id);
    //grabaLog('idProceso: '.$idProceso);

    $response = $integracion->registra($UUID,$id,$idProceso,$estado);

    //grabaLog($integracion);

    //$response=Response::text('hola');

    return $response;

});

$router->post($configProxy['dir_publicacion'].'/integracion/grabaEstado',function(Request $request){

    global $configProxy;
    global $conexionBdd;

    $datos=$request->Data();

    if(isset($datos['tipoWeb'])) $tipoWeb=$datos['tipoWeb']; else $tipoWeb='';
    if(isset($datos['tipoProceso'])) $tipoProceso=$datos['tipoProceso']; else $tipoProceso='';
    if(isset($datos['empresa'])) $empresa=$datos['empresa']; else $empresa='';
    if(isset($datos['cliente'])) $cliente=$datos['cliente']; else $cliente='';
    if(isset($datos['usuario'])) $usuario=$datos['usuario']; else $usuario='';

    //if(isset($datos['datos'])) $data=$datos['datos']; else $data='';
    if(isset($datos['datos'])) $data=base64_decode($datos['datos']); else $data='';
    $data=mb_convert_encoding($data,'UTF-8','ISO-8859-1');
    

    $integracion=new Integracion($tipoWeb,$tipoProceso,$empresa,$cliente,$usuario);

    if(isset($datos['UUID'])) $UUID=$datos['UUID'];
    if(isset($datos['id'])) $id=$datos['id'];
    if(isset($datos['idProceso'])) $idProceso=$datos['idProceso'];
    if(isset($datos['estado'])) $estado=$datos['estado'];

    if( isset($UUID) && isset($idProceso) && isset($estado) ) {

        $response = $integracion->registra($UUID,$id,$idProceso,$estado,$data);

    }
    else {
        $response=Response::text(RespuestaStandard::error(100,"Datos incompletos.")->getRespuesta());
    }

    //$response=Response::text('hola');

    return $response;

});

$router->post($configProxy['dir_publicacion'].'/integracion/consultaEstado',function(Request $request){

    global $configProxy;
    global $conexionBdd;

    

    $datos=$request->Data();

    if(isset($datos['tipoWeb'])) $tipoWeb=$datos['tipoWeb']; else $tipoWeb='';
    if(isset($datos['tipoProceso'])) $tipoProceso=$datos['tipoProceso']; else $tipoProceso='';
    if(isset($datos['empresa'])) $empresa=$datos['empresa']; else $empresa='';
    if(isset($datos['cliente'])) $cliente=$datos['cliente']; else $cliente='';
    if(isset($datos['usuario'])) $usuario=$datos['usuario']; else $usuario='';

    $UUID=$datos['UUID'];
    $id=$datos['id'];
    $idProceso=$datos['idProceso'];

    //grabaLog('integracion/consultaEstado --> datos');
    //grabaLog($datos);

    $obviarEstados=$datos['obviarEstados'];

    //grabaLog('OBVIAR ESTADOS');
    //grabaLog($obviarEstados);



    $integracion=new Integracion($tipoWeb,$tipoProceso,$empresa,$cliente,$usuario,$UUID,$id,$idProceso);

    //grabaLog('integracion');
    //grabaLog($integracion);

    $estado=$integracion->estado($obviarEstados);

    //grabaLog('estado');
    //grabaLog($estado);

    if($estado) {

        $response=Response::text(RespuestaStandard::data($estado)->getRespuesta());

    }
    else {

        $response=Response::text(RespuestaStandard::error('','')->getRespuesta());

    }

    //$response=Response::text('hola');

    return $response;

});


//////////////////////////////////////////////////////////////////
////////////                                      ////////////////
//////////// METODOS GENERICOS PARA NEOWEBBUILDER ////////////////
////////////                                      ////////////////
////////////              I N I C I O             ////////////////
////////////                                      ////////////////
//////////////////////////////////////////////////////////////////

$router->post($configProxy['dir_publicacion'].'/neoWebBuilder/enviaProcesamiento',function(Request $request){

    global $configProxy;

    $conexionBdd = new PDO('sqlite:'.$configProxy['sqliteBdNeoWeb']);
    
    $datos=$request->Data();

    $idCache=$datos['idCache'];
    $idUnico=$datos['idUnico'];
    $idObjeto=$datos['idObjeto'];
    $idPantalla=$datos['pantalla'];

    if(isset($datos['boton'])) $idBoton=$datos['boton']; else $idBoton='';
    if(isset($datos['campo'])) $campo=$datos['campo']; else $campo='';
    if(isset($datos['pestanya'])) $pestanya=$datos['pestanya']; else $pestanya='';

    $datos=$datos['datos'];


    $consulta='INSERT INTO ordenesLanzamiento (idCache,idUnico,idObjeto,idPantalla,idBoton,ordenCampo,idPestanya,datos) VALUES (?,?,?,?,?,?,?,?)';

    $parametros[]=$idCache;
    $parametros[]=$idUnico;
    $parametros[]=$idObjeto;
    $parametros[]=$idPantalla;
    $parametros[]=$idBoton;
    $parametros[]=$campo;
    $parametros[]=$pestanya;
    $parametros[]=$datos;

    try {

        $temp=$conexionBdd->prepare($consulta);
        $temp->execute($parametros);

        $response=Response::text(RespuestaStandard::data('Ok')->getRespuesta());

    } catch (PDOException $e) {
        
        $response=Response::text(RespuestaStandard::error(900,$e->getMessage())->getRespuesta());

    }


    //$response=Response::text('hola');

    return $response;

});

$router->post($configProxy['dir_publicacion'].'/neoWebBuilder/enviaDatosGridStatus',function(Request $request){

    global $configProxy;

    $conexionBdd = new PDO('sqlite:'.$configProxy['sqliteBdNeoWeb']);
    
    $datos=$request->Data();

    $grid=$datos['grid'];
    $pantalla=$datos['pantalla'];
    $orden=$datos['orden'];

    $idObjeto=$datos['idObjeto'];
    $idUnico=$datos['idUnico'];
    $idCache=$datos['idCache'];

    $datos=$datos['datos'];

    if(true) {

        $parametros=array();

        $consulta='INSERT INTO tmp_'.$grid.'_status (idCache,idUnico,idObjeto,Grid,Pantalla,Orden,cuando,datos) VALUES (?,?,?,?,?,?,?,?)';

        $parametros[]=$idCache;
        $parametros[]=$idUnico;
        $parametros[]=$idObjeto;
        $parametros[]=$grid;
        $parametros[]=$pantalla;
        $parametros[]=$orden;
        $parametros[]=date('Y-m-d H:i:s');
        $parametros[]=$datos;

        try {

            $temp=$conexionBdd->prepare($consulta);
            $temp->execute($parametros);

            $response=Response::text(RespuestaStandard::data('Ok')->getRespuesta());
    
        } catch (PDOException $e) {
            
            $response=Response::text(RespuestaStandard::error(900,$e->getMessage())->getRespuesta());
    
        }

    }
    else $response=Response::text(RespuestaStandard::error(800,'Error desconocido al recibir datos de estado.')->getRespuesta());

    unset($conexionBdd);

    //$response=Response::text('hola');

    return $response;

});

$router->post($configProxy['dir_publicacion'].'/neoWebBuilder/enviaDatosGrid',function(Request $request){

    global $configProxy;

    //grabaLog('traza 2');

    
    $conexionBdd = new PDO('sqlite:'.$configProxy['sqliteBdNeoWeb']);

    
    
    
    $datos=$request->Data();

    $grid=$datos['grid'];
    $pantalla=$datos['pantalla'];
    $orden=$datos['orden'];

    $idObjeto=$datos['idObjeto'];
    $idUnico=$datos['idUnico'];
    $idCache=$datos['idCache'];

    //grabaLog('traza 3');

    //grabaLog($datos['datos']);

    

    //$registros=json_decode($datos['datos']);
    $registros=json_decode(mb_convert_encoding($datos['datos'],'UTF-8','ISO-8859-1'));

    //grabaLog('traza 4');

    if(!is_array($registros)) $registros=array($registros); //Por si se devolviera solo uno, para poder hacer el foreach

    
    $conexionBdd->beginTransaction();

    
    foreach($registros as $item){

        //grabaLog($item);

        $consulta='';
        $parametros=array();

        

        $idBloque=$item->idBloque;
        $fila=$item->Fila;
        $campos=get_object_vars($item->Campos);

        $consulta.='INSERT INTO tmp_'.$grid.' (idCache,idUnico,idObjeto,Grid,Pantalla,Orden,idBloque,Fila';
        foreach($campos as $ordenCampo=>$valor) $consulta.=',Campo'.$ordenCampo;
        //$consulta.=',Campo1';
        //$consulta.=',Campo2';
        $consulta.=') VALUES (?,?,?,?,?,?,?,?';
        foreach($campos as $ordenCampo=>$valor) $consulta.=',?';
        //$consulta.=',?';
        //$consulta.=',?';
        $consulta.=')';
        
        $parametros[]=$idCache;
        $parametros[]=$idUnico;
        $parametros[]=$idObjeto;
        $parametros[]=$grid;
        $parametros[]=$pantalla;
        $parametros[]=$orden;
        $parametros[]=$idBloque;
        $parametros[]=$fila;
        foreach($campos as $ordenCampo=>$valor) $parametros[]=$valor;
        //$parametros[]=$item->Campo1;
        //$parametros[]=$item->Campo2;

        //echo $consulta;
        //print_r($parametros);

        
        try {

            $temp=$conexionBdd->prepare($consulta);
            $temp->execute($parametros);
    
        } catch (PDOException $e) {
            
            //echo 'Falló la conexión: ' . $e->getMessage();
            $response=Response::text(RespuestaStandard::error(900,$e->getMessage())->getRespuesta());

            $conexionBdd->rollBack();

            break;
    
        }
        

    }
    

    
    if(!isset($response)) {
        
        $conexionBdd->commit();

        $response=Response::text(RespuestaStandard::data('Ok')->getRespuesta());

    }
    

    unset($conexionBdd);

    
    //$response=Response::text('hola');

    return $response;

});

$router->post($configProxy['dir_publicacion'].'/neoWebBuilder/enviaDatosGridUnicoStatus',function(Request $request){

    global $configProxy;

    $conexionBdd = new PDO('sqlite:'.$configProxy['sqliteBdNeoWeb']);
    
    $datos=$request->Data();

    $grid=$datos['grid'];
    $pantalla=$datos['pantalla'];
    $orden=$datos['orden'];

    $idObjeto=$datos['idObjeto'];
    $idUnico=$datos['idUnico'];
    $idCache=$datos['idCache'];

    $datos=$datos['datos'];

    if(true) {

        $parametros=array();

        $consulta='INSERT INTO tmp_Grids_status (idCache,idUnico,idObjeto,Grid,Pantalla,Orden,cuando,datos) VALUES (?,?,?,?,?,?,?,?)';

        $parametros[]=$idCache;
        $parametros[]=$idUnico;
        $parametros[]=$idObjeto;
        $parametros[]=$grid;
        $parametros[]=$pantalla;
        $parametros[]=$orden;
        $parametros[]=date('Y-m-d H:i:s');
        $parametros[]=$datos;

        try {

            $temp=$conexionBdd->prepare($consulta);
            $temp->execute($parametros);

            $response=Response::text(RespuestaStandard::data('Ok')->getRespuesta());
    
        } catch (PDOException $e) {
            
            $response=Response::text(RespuestaStandard::error(900,$e->getMessage())->getRespuesta());
    
        }

    }
    else $response=Response::text(RespuestaStandard::error(800,'Error desconocido al recibir datos de estado.')->getRespuesta());

    unset($conexionBdd);

    //$response=Response::text('hola');

    return $response;

});

$router->post($configProxy['dir_publicacion'].'/neoWebBuilder/enviaDatosGridUnico',function(Request $request){

    global $configProxy;

    //grabaLog('traza 2');

    
    $conexionBdd = new PDO('sqlite:'.$configProxy['sqliteBdNeoWeb']);

    
    
    
    $datos=$request->Data();

    $grid=$datos['grid'];
    $pantalla=$datos['pantalla'];
    $orden=$datos['orden'];

    $idObjeto=$datos['idObjeto'];
    $idUnico=$datos['idUnico'];
    $idCache=$datos['idCache'];

    //grabaLog('traza 3');

    //grabaLog($datos['datos']);

    

    //$registros=json_decode($datos['datos']);
    $registros=json_decode(mb_convert_encoding($datos['datos'],'UTF-8','ISO-8859-1'));

    //grabaLog('traza 4');

    if(!is_array($registros)) $registros=array($registros); //Por si se devolviera solo uno, para poder hacer el foreach

    
    $conexionBdd->beginTransaction();

    
    foreach($registros as $item){

        //grabaLog($item);

        $consulta='';
        $parametros=array();

        $idBloque=$item->idBloque;
        $fila=$item->Fila;
        $campos=get_object_vars($item->Campos);

        $consulta.='INSERT INTO tmp_Grids (idCache,idUnico,idObjeto,Grid,Pantalla,Orden,idBloque,Fila';
        foreach($campos as $ordenCampo=>$valor) $consulta.=',Campo'.$ordenCampo;
        $consulta.=') VALUES (?,?,?,?,?,?,?,?';
        foreach($campos as $ordenCampo=>$valor) $consulta.=',?';
        $consulta.=')';
        
        $parametros[]=$idCache;
        $parametros[]=$idUnico;
        $parametros[]=$idObjeto;
        $parametros[]=$grid;
        $parametros[]=$pantalla;
        $parametros[]=$orden;
        $parametros[]=$idBloque;
        $parametros[]=$fila;
        foreach($campos as $ordenCampo=>$valor) $parametros[]=$valor;

        
        try {

            $temp=$conexionBdd->prepare($consulta);
            $temp->execute($parametros);
    
        } catch (PDOException $e) {
            
             $response=Response::text(RespuestaStandard::error(900,$e->getMessage())->getRespuesta());

            $conexionBdd->rollBack();

            break;
    
        }
        

    }
    

    
    if(!isset($response)) {
        
        $conexionBdd->commit();

        $response=Response::text(RespuestaStandard::data('Ok')->getRespuesta());

    }
    

    unset($conexionBdd);

    
    //$response=Response::text('hola');

    return $response;

});








$router->get($configProxy['dir_publicacion'].'/basicTest',function(Request $request){

    $parametrosQuery=$request->QueryParams();
    //print_r($parametrosQuery);

    $response=Response::text('Basic test ok.');
    return $response;

});

$router->post($configProxy['dir_publicacion'].'/test',function(Request $request){

    $datos=$request->Data();

    $respuesta=array(
        'Respuesta1'=>'aaa',
        'Respuesta2'=>10
    );

    $response=Response::json($respuesta);

    return $response;

});

$router->get($configProxy['dir_publicacion'].'/testSqlite',function(Request $request){

    global $conexionBdd;

    /*
    $consulta ='DROP TABLE test';
    
    try {
        $conexionBdd->query($consulta);
    } catch (PDOException $e) {
        echo $e->getMessage();
    }
    */

    $consulta ='CREATE TABLE IF NOT EXISTS test (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        UUID VARCHAR(255),
        valor VARCHAR(255)
    )';
    
    try {
        $conexionBdd->query($consulta);
    } catch (PDOException $e) {
        echo $e->getMessage();
    }

    
    $consulta ='INSERT INTO test (UUID,valor) VALUES (?,?)';
    $parametros=array('test','Valor test');
    
    try {
        $temp=$conexionBdd->prepare($consulta);
        $temp->execute($parametros);
    } catch (PDOException $e) {
        echo $e->getMessage();
    }

    $consulta ='SELECT * FROM test WHERE UUID=?';
    $parametros=array('test');
    
    try {
        $temp=$conexionBdd->prepare($consulta);
        $temp->execute($parametros);
    } catch (PDOException $e) {
        echo $e->getMessage();
    }
    
    $resultado=$temp->fetch();


    $response=Response::text('Test Sqlite ok --> '.$resultado['valor']);
    return $response;

});




/*
$router->get($configProxy['dir_publicacion'].'/basicTest',function(Request $request){

    $datos=$request->QueryParams();
    return basicTest($datos);

});

$router->post($configProxy['dir_publicacion'].'/test',function(Request $request){

    $datos=$request->Data();
    return test($datos);

});
*/



$router->post($configProxy['dir_publicacion'].'/test2',function(Request $request){

    $datos=$request->Data();

    $peticion=new PeticionWS(
        $datos['Dato1'], 
        $datos['Dato2']
    );

    //$respuesta='{"respuesta1":"aaa","respuesta2":"bbb"}';
    //$response=Response::text($respuesta);

    $respuesta=array(
        'respuesta1'=>'aaa',
        'respuesta2'=>10
    );

    $response=Response::json($respuesta);
    return $response;

});

$router->post($configProxy['dir_publicacion'].'/test3',function(Request $request){

    $datos=$request->Data();

    $peticion=new PeticionWS(
        $datos['Dato1'], 
        $datos['Dato2']
    );

    $valores=array(
        'Respuesta1'=>'aaa',
        'respuesta2'=>10
    );

    $respuesta=json_encode($valores);
    $respuesta=json_decode($respuesta);

    //print_r($respuesta);
    echo $respuesta->Respuesta1;

    $response=Response::text('hola');
    return $response;

});

$router->post($configProxy['dir_publicacion'].'/testUpload',function(Request $request){

    $datos=$request->Data();
    $files=$request->Files();

    $item=$files['archivo'];
    
    $temporal=$item['tmp_name'];
    $nombre=$item['name'];

    $archivo=new Upload();
    $archivo->archivo='kk.jpg';
    $archivo->setRutaArchivo();

    global $configProxy;

    print_r($archivo);
    echo '----';
    echo '----';
    echo $archivo->rutaArchivo;
    echo '----';

    error_reporting(1);

    if(move_uploaded_file($temporal,$archivo->rutaArchivo)) {

        echo "ok";

        /*
        $archivo->nombreArchivoFinal=$file['name'];
        $fileName=base64_encode($archivo->nombreArchivoFinal);
        
        $archivo->paramOperacion=$paramOperacion;
        $params=base64_encode($archivo->paramOperacion);
        
        $archivo->urlDescarga=$rutaPublicacion.'/uploadDoc/descarga?id='.$archivo->archivo.'&file='.$fileName.'&params='.$params.'&signature='.$archivo->getSignature();
        $archivo->urlBorrado=$rutaPublicacion.'/uploadDoc/borrado?id='.$archivo->archivo.'&file='.$fileName.'&params='.$params.'&signature='.$archivo->getSignature();

        $archivo->paramOperacion=$paramOperacion;

        print_r($archivo);
        */

    }
    else echo "error";


    $response=Response::text(RespuestaStandard::data('Ok')->getRespuesta());

    return $response;

});






$server=new PhpNativeServer;

$hayMysql=($configProxy['mysqlServidor'] && $configProxy['mysqlBdd'] && $configProxy['mysqlUsuario'] && $configProxy['mysqlPassword']);

try {

    if($hayMysql) {

        try {
            $conexionBdd = new PDO('mysql:host='.$configProxy['mysqlServidor'].';dbname='.$configProxy['mysqlBdd'],$configProxy['mysqlUsuario'],$configProxy['mysqlPassword']);
            $conexionBdd->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
            $conexionBdd->setAttribute(PDO::ATTR_EMULATE_PREPARES, false);
        } catch (PDOException $e) {
            echo '<p>ERROR en la conexión a la base de datos.</p>';
            $response=Response::text("Error interno. Error de conexión.")->setStatus(500);
        }

    }
    else if($configProxy['sqliteBd']){

        $conexionBdd = new PDO('sqlite:'.$_SERVER["DOCUMENT_ROOT"].$configProxy['dir_publicacion'].$configProxy['sqliteBd']);
        $conexionBdd->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    }

    $request=new Request($server); //Aqui es donde coge todo, la uri y los parametros y todo
    //$method=$_SERVER["REQUEST_METHOD"];
    //$uri=$_SERVER["REQUEST_URI"];

    $route=$router->resolve($request);
    
    $action=$route->action();
    $response=$action($request);
    $server->sendResponse($response);

    if($hayMysql) unset($conexionBdd);

} catch (HttpNotFoundException $e) {

    $server->sendResponse(Response::text("Not found")->setStatus(404));

    if($hayMysql) unset($conexionBdd);
}