SIU-Arai/catalogos-cliente

De SIU
Saltar a: navegación, buscar
Siu-arai iso.png

SIU-Arai Catalogos (cliente)

Esta librería permite que una aplicación pueda interactuar con SIU Arai Catalogos (servidor).

Forma de trabajo

La distribución de la librería se realiza a través de gitlab: https://hub.siu.edu.ar.

Instalación

Consumo de la librería

Agregar en el archivo composer.json de la aplicación cliente

"repositories":
[
{
        "type": "composer",
        "url": "https://satis.siu.edu.ar"
}
],
"require": {
        "siu/arai-cli": "v1.1.4"
}

Dentro de la ruta /vendor/siu/arai-cli/src/SIU/AraiCli se encuentra el archivo Factory.php donde se debe configurar

$container['arai-catalogos-path-logs'] = '/../../../logs/arai-catalogos-cli.log'; //PATH Y ARCHIVO DONDE SE ALMACENAN LOGS
$container['arai-catalogos-logger'] = function ($c) {
    $log = new Logger('arai-catalogos-cli');
    $streamHandler = new StreamHandler(__DIR__ . $c['arai-catalogos-path-logs'], Logger::NOTICE, false);
    $log->pushHandler($streamHandler);
    return $log;
};
$container['arai-catalogos-json-schema-path'] = '/../../../../../res/catalogos/schemas/'; //PATH DONDE SE ENCUENTRAN LOS JSON SCHEMAS VALIDATORS
$container['arai-catalogos-config-file'] = '/../../../res/catalogos/config/config.json'; //PATH Y ARCHIVO JSON DE CONFIGURACION
$container['arai-catalogos-config'] = function ($c) {
    $config = json_decode(file_get_contents(__DIR__ . $c['arai-catalogos-config-file']), true);
    return $config;
};

Cambios en la base

Se agregan tres nuevos campos a las tablas que pasan a convertirse en catálogos comunes, revisión que guarda el número de revisión asociado, id_arai que guarda el id global, y sincronizar es un flag que indica si ese registro debe ser sincronizado (para aquellos catálogos que cuenten con sincronización parcial de datos).

Para el catálogo Rubro el sql aplicado sería:

ALTER TABLE anx_rubros
        ADD revision INTEGER;

ALTER TABLE anx_rubros
        ADD id_arai INTEGER;

ALTER TABLE anx_rubros
        ADD sincronizar CHAR(1) DEFAULT 'N';

Consumo de la librería en aplicación que utiliza SIU Toba

[[1]]

Copiar el archivo cliente.ini en /{proyecto}/vendor/siu-toba/framework/instalacion/i__{instancia}/p__{proyecto}/rest/arai-catalogos con el contenido

[conexion]
;Recuerde dejar una barra (/) al finalizar la URL
to = "URL SERVIDOR"
auth_tipo="basic"
auth_usuario="USUARIO"
auth_password="CLAVE"

En contexto_ejecucion_[proyecto].php agregar, esto complementa el contenedor que utiliza la librería:

$container = \SIU\AraiCli\Factory::getContainer();                     
$container['arai-catalogos-def-path'] = '/../../arai_definicion_catalogos.json'; //Archivo JSON donde está la definición de los catalogos
$container['arai-catalogos-lista'] = function ($c) {                           
        $definition = json_decode(file_get_contents(__DIR__ . $c['arai-catalogos-def-path']), true);
        return $definition;
};                     

//Configura el cliente guzzle, la configuración la toma del archivo cliente.ini
ubicado en /{proyecto}/vendor/siu-toba/framework/instalacion/i__{instancia}/p__{proyecto}/rest/arai-catalogos
$container['arai-catalogos-cliente'] = function ($c) {
    $cliente = toba::servicio_web_rest('arai-catalogos');
    return $cliente->guzzle();
};
$container['arai-catalogos-encoding'] = 'LATIN1';
$container['arai-catalogos-namespace'] = 'SIU\AraiCli\Services\AraiCatalogos';

En el archivo arai_definicion_catalogos.json se definen los catálogos utilizados, y la configuración de cada uno de ellos, ejemplo:


{
    "catalogos": {
        "bienServicio": {
            "definicion": [{
                    "tabla": "scp_catalogo_bienes_servicios", // Tabla asociada al catalogo
                    "columnas": ["id_catalogo_bien_servicio_padre", "id_bien_servicio_tipo", "codigo", "codigo_completo", "nombre", "nivel", "estado"] // Columnas asociadas al catalogo
                }],
            "lk": ["codigo_completo"], // Clave logica
            "fk":  {
                "bienServicio" : "id_catalogo_bien_servicio_padre" //Clave foranea: primero se indica el catalogo, luego el campo, en este caso se trata de una FK recursiva
            },
            "relacion_recursiva": { // En caso de existir relaciones recursivas crear este elemento
                "id": "id_arai",  // Id global (id arai)
                "fk": "id_catalogo_bien_servicio_padre", // Campo de la FK
                "id_local": "id_catalogo_bien_servicio"  // Id local asociado
            },    
            "id_componente_dt": 101000448,  // ID del datos tabla que apunta a la tabla maestra del catalogo
            "ultima_revision": "call_user_func('sincronizador_arai_cli::getUltimaRevision', 'diaguita.scp_catalogo_bienes_servicios')" // Callback que permite obtener la ultima revision del catalogo
        },
        "bienPatrimonial": {
            "definicion": [{
                    "tabla": "scp_catalogo_bienes_patrimoniales",
                    "columnas": ["id_catalogo_bien_uso_padre","vida_util","id_bien_tipo","debe_amortizarse","codigo","codigo_completo","nombre","nivel","estado"]
                }],
            "lk": ["codigo_completo"],
            "fk":  {
                "bienPatrimonial" : "id_catalogo_bien_uso_padre"
            },
            "relacion_recursiva": {
                "id": "id_arai",
                "fk": "id_catalogo_bien_uso_padre",
                "id_local": "id_catalogo_bien_patrimonial"
            },
            "id_componente_dt": 101000455,
            "ultima_revision": "call_user_func('sincronizador_arai_cli::getUltimaRevision', 'diaguita.scp_catalogo_bienes_patrimoniales')"
        }
    }
}

A continuación se muestra el consumo en un ABM (del catalogo Rubro del sistema SIU Pilaga), se edita el CI de la operación, que en este caso se reutiliza para la mayoría de los ABMs (ci_abm_filtro.php):

Se fuerza una sincronización con el servidor cada vez que se carga la operación de la siguiente forma:

function conf() {      
    $arai_cli = new sincronizador_arai_cli($this->catalogo, $this->get_tabla());
    $this->s__clase_catalogo = $arai_cli->getClaseCatalogo();
    $this->s__tabla_catalogo = $arai_cli->getTablaCatalogo();
    $this->s__encabezado = $arai_cli->getEncabezado();
    $arai_cli->sincronizacion(true);
}

Código que gestiona el alta

function evt__formulario__alta($datos) {
        $arai_cli_lib = new $this->s__clase_catalogo($this->s__encabezado, $this->catalogo);
        try {
        $this->verifica_duplicados($datos);
        $respuesta = $arai_cli_lib->setDatos($datos, 'A', $datos["id_arai"]);
        //El alta local se realiza para guardar campos que pueden no estar siendo guardados en el catálogo central, al sincronizar se termina de actualizar la revisión
        if (isset($respuesta["idArai"])) {
            $datos["id_arai"] = $respuesta["idArai"];
        }
        } catch (toba_error $e) {
        throw $e;
        } catch (Exception $e) {
        throw new excepcion_pilaga($e);
        }
      -- REALIZAR LLAMADO A FUNCION QUE REALIZA EL ALTA LOCAL PARA EVITAR QUE DATOS QUE NO VAN AL CATALOGO CENTRAL SE PIERDAN
}

function verifica_duplicados($datos) {
        $tabla = $this->get_tabla();
        $arai_cli_lib = new $this->s__clase_catalogo($this->s__encabezado, $this->catalogo);
        $claves = $arai_cli_lib->getColumnasLK();

        foreach ($claves as $clave) {
            $r[$clave] = $datos[$clave];
        }

        $dao = "\$datos_tabla = $this->clase::$this->metodo(null);";
        eval($dao);
        $tabla->cargar_con_datos($datos_tabla);
        $id = $tabla->get_id_fila_condicion($r);

        if (count($id)>0) {
            throw new excepcion_pilaga("Se intenta dar de alta un registro con una clave que ya existe. Verifique los datos ingresados.");
        }
}

protected function get_tabla() {
        return $this->dep('datos');
}

Modificación

function evt__formulario__modificacion($datos) {
    //Le inyecto la revision general del catalogo
    $datos["revision"] = sincronizador_arai_cli::getUltimaRevision($this->s__tabla_catalogo);
   
    $arai_cli_lib = new $this->s__clase_catalogo($this->s__encabezado, $this->catalogo);
   
    try {
        $respuesta = $arai_cli_lib->setDatos($datos, 'M', $datos["id_arai"]);
        //El modificación local se realiza para guardar campos que pueden no estar siendo guardados en el catálogo central, al sincronizar se termina de actualizar la revisión
        if (isset($respuesta["idArai"])) {
            $datos["id_arai"] = $respuesta["idArai"];
            self::evt__formulario__modificacion_local($datos);
        }
    } catch (toba_error $e) {
        throw $e;
    } catch (Exception $e) {
        throw new excepcion_pilaga($e->getMessage());
    }
}

Baja

function evt__formulario__baja($seleccion = null) {            
        if (!is_null($seleccion))
            $this->s__seleccion = $seleccion;

        //Le inyecto la revision general del catalogo
        $datos["revision"] = sincronizador_arai_cli::getUltimaRevision($this->s__tabla_catalogo);

        $arai_cli_lib = new $this->s__clase_catalogo($this->s__encabezado, $this->catalogo);       

        try {          
                $respuesta = $arai_cli_lib->setDatos(null, 'B', $this->s__seleccion["id_arai"]);
        } catch (toba_error $e) {
                throw $e;
        } catch (Exception $e) {
                throw new excepcion_pilaga($e);
        }
}

La clase sincronizador_arai_cli es el nexo entre la aplicación cliente y la librería arai-catalogos-cli

Comandos administrativos

Existen dos comandos (actualmente se pueden ver en Pilaga y Diaguita): sincronizacion (ej: ./pilaga.sh arai sincronizacion) y sincronizacion_inicial (ej: ./pilaga.sh arai sincronizacion_inicial)

Ejemplo (utiliza libreria xlib para el formateo de la salida a consola):

class comando_arai_catalogos extends comando_toba_pilaga {
    function __construct($manejador_interface, $interprete = null) {
        parent::__construct($manejador_interface, $interprete);
        ini_set("memory_limit", '1024M');
    }

    static function get_info() {
        return 'Opciones sincronización ARAI Catalogos.';
    }

    /**
     * Determina el catalogo
     *
     * @param unknown_type $obligatorio
     * @return unknown
     */

    protected function get_catalogo($obligatorio = true) {
        $catalogo = null;
        $param = $this->get_parametros();

        if (isset($param['-c']) && ( trim($param['-c']) != '')) {
            $catalogo = $param['-c'];
        } elseif (isset($this->catalogo)) {
            $catalogo = $this->catalogo;
        }

        if ($obligatorio && is_null($catalogo)) {
            throw new toba_error("Es necesario definir un Catalogo. Utilice el modificador '-c'.");
        }

        return $catalogo;
    }
   
    protected function get_revision($obligatorio = true) {
        $revision = null;
        $param = $this->get_parametros();

        if (isset($param['-rev']) && ( trim($param['-rev']) != '')) {
            $revision = $param['-rev'];
        }
       
        if ($obligatorio && is_null($revision)) {
            throw new toba_error("Es necesario definir una revisión. Utilice el modificador '-rev'.");
        }

        return $revision;
    }

    function mostrar_observaciones() {
        $this->consola->mensaje("INVOCACION: pilaga arai_catalogos [OPCIONES] [PARAMETROS]");
        $this->consola->enter();
    }

    function sincronizacion($inicial) {
        $container = \SIU\AraiCli\Factory::getContainer();     
       
        if (!isset($container['arai-catalogos-lista'])) {
                xlib::salida_comandos()->mostrar_mensaje("La aplicación no tiene activo el parámetro 'aplicar_sincronizacion_arai'\nDebe ponerlo en Si para poder utilizar este comando.");
            xlib::salida_comandos()->separador();
                return false;
        }

        $catalogo = $this->get_catalogo();
        $revision = $this->get_revision(false);
       
        xlib::salida_comandos()->mostrar_titulo('Arai Catálogos - Sincronización ' . (($inicial) ? 'inicial. ' : '. ') . "Catálogo: $catalogo");
        xlib::salida_comandos()->separador();

        if (!isset($container['arai-catalogos-lista']['catalogos'][$catalogo])) {
            xlib::salida_comandos()->mostrar_mensaje("El catálogo $catalogo no se encuentra definido en la aplicación, verifique el nombre ingresado.");
            xlib::salida_comandos()->separador();
            return false;
        }

        $datos_tabla_name = $container['arai-catalogos-lista']['catalogos'][$catalogo]['id_componente_dt'];
        $datos_tabla = toba::tabla( $datos_tabla_name );
        $tabla = $container['arai-catalogos-lista']['catalogos'][$catalogo]['tabla_maestra'];
        $namespace = $container['arai-catalogos-namespace'];
       
        $encabezado = array();
        sincronizador_arai_cli::setDatosEncabezadoApp($encabezado, $tabla);
               
        if (class_exists($namespace . '\\' . $catalogo))
            $clase_catalogo = $namespace . '\\' . $catalogo;
        else
            $clase_catalogo = $namespace . '\AraiCatalogos';

        $arai_cli = new sincronizador_arai_cli($catalogo, $datos_tabla, $revision);
        $arai_cli->sincronizacion($inicial, true);

        xlib::salida_comandos()->mostrar_titulo('La sincronización finalizó con éxito!');
        xlib::salida_comandos()->separador();  
    }

    //-------------------------------------------------------------
    // Opciones
    //-------------------------------------------------------------

    /**
     * Sincronización inicial con ARAI.
     */

    function opcion__sincronizacion_inicial() {
        // Iniciar contexto de pilaga
        toba::nucleo()->iniciar_contexto_desde_consola(apex_pa_instancia, apex_pa_proyecto);
        $this->sincronizacion(true);
    }

    /**
     * Sincroniza con ARAI.
     */

    function opcion__sincronizacion() {
        // Iniciar contexto de pilaga
        toba::nucleo()->iniciar_contexto_desde_consola(apex_pa_instancia, apex_pa_proyecto);
        $this->sincronizacion(false);
    }
}

El proyecto SIU Pilaga que ya se encuentra integrado con arai-catalogos a partir de la versión 3.0.3

El proyecto SIU Diaguita que ya se encuentra integrado con arai-catalogos a partir de la versión 2.5

Consumo de la librería en aplicación que NO utilizan SIU Toba

En la carpeta "example" se encuentran los fuentes requeridos para poder utilizar la librería desde proyectos que no utilizan el framework SIU TOBA. La clase a utilizar es sincronizador_arai_cli


<Volver