3.4.0

Conceptos Básicos

Históricamente los proyectos desarrollados con SIU-Toba han tenido la mayor parte del marcado (HTML) generada por el framework, esto ha permitido que el look&feel de las operaciones sea similar en todos los casos.

Sin embargo, en aquellas situaciones donde se buscaba diferenciarse era necesario realizar una redefinición de varias clases y aún asi el look&feel básico era dificil de modificar.

Es en esa situación donde surge el denominado manejador de salida, un conjunto de clases que implementan la generación del marcado y que pueden dar lugar a implementaciones distintas como conjunto.

Requerimientos

El uso de esta funcionalidad tiene a priori los siguientes requerimientos:

  • Una instalación funcional de SIU-Toba > 3.2.0
  • La descarga del manejador de salida elegido como paquete (o implementación propia)
  • La inyección de la instancia del manejador a utilizar mediante el contexto de ejecución

Creando mi manejador de salida

SIU-Toba incorpora un manejador de salida por defecto que implementa el marcado clásico del framework, sin embargo es posible modificar la salida del mismo incorporando nuestro propio manejador en runtime. La cuestión es, como creo mi manejador?.

Un manejador de salida es un conjunto de clases que implementan la siguiente interfase.

Esta implementación tiene una clase mandatoria la cual deben existir en la raiz del namespace correspondiente al manejador (xx => nombre manejador).

  • xx_factory donde se determina que componentes del manejador son implementados y que clases lo hacen.

Asi, mismo se recomienda tener un objeto de configuración:

  • xx_config donde se incorporarán configuraciones y funciones relacionadas.

Generando la salida

La clase xx_factory especifica aquellos componentes cuya salida esta implementada por este manejador, la salida del resto de los componentes se implementará mediante los manejadores cargados previamente. Cabe aclarar, cada componente debe tener implementación completa.. el fallback no se realiza a nivel de método, sino a nivel de componentes.

Por otro lado, cuando decimos implementar no nos referimos a la extensión de otro manejador, ya que ello generaría una dependencia de la implementación particular.. acarreando futuros problemas en caso de que la misma se modifique. Lo ideal es implementar todos los metodos de la clase del componente, como en el siguiente ejemplo.

<?php
namespace SIU\ManejadorReferencia\Componentes\Interfaz;

use SIU\InterfacesManejadorSalidaToba\Componentes\Interfaz\IElemento;
class referencia_ei implements IElemento
{
    public function getHtmlDescripcion($mensaje, $tipo=null) {
        
        if (! isset($tipo) || $tipo == 'info') {
            $imagen = '<span class="glyphicon glyphicon-info-sign" aria-hidden="true"></span>';
            $clase = 'alert-info';
        }
        if ($tipo== 'warning') {
            $imagen = '<span class="glyphicon glyphicon-warning-sign" aria-hidden="true"></span>';
            $clase = 'alert-warning';
        }
        if ($tipo == 'error') {
            $imagen = '<span class="glyphicon glyphicon-ban-circle" aria-hidden="true"></span>';
            $clase = 'alert-danger';
        }
        $descripcion = \toba_parser_ayuda::parsear($mensaje);
        return "<div class='alert $clase' role='alert'>$imagen $descripcion</div>";
    }
    
    public function getInicioBarraSuperior($tiene_titulo, $botonera_sup, $class, $style) {
        return "<div class='panel-heading'>\n";
    }
    
    public function getContenidoBarraSuperior($titulo, $descripcion, $modo_tooltip, $colapsable, $colapsado_coherente, $objeto_js,$js_colapsado) {
        $salida = $titulo;
        //---Barra de colapsado
        if ($colapsable && isset($objeto_js) && $colapsado_coherente) {
            $img_min = \toba_recurso::imagen_toba('nucleo/sentido_asc_sel.gif', false);
            $salida .= "<img class='ei-barra-colapsar' id='colapsar_boton_$objeto_js' src='$img_min' onclick='{$objeto_js}.cambiar_colapsado()'>";
        }
        return $salida;
    }
    
    public function getFinBarraSuperior() {
        return "</div>";
    }
    
    public function getInicioBotonera($class, $extra) {
        return "<div class='$class'>";
    }
    
    public function getFinBotonera() {
        return "</div>";        
    }
}
>?

Los metodos necesarios para cada componente se definen en la interfase del manejador.

Seleccionando la versión

Se recomienda que en lo posible el manejador de salida (sea propio o no), se obtenga mediante un paquete de forma que pueda ser instalado via composer. Esto permite a su vez que exista reutilización del mismo en distintos proyectos y no sea necesario estar copiando código de un lugar a otro.

Las versiones de Toba suelen salir acopladas a una versión puntual de la interfase que implementa, por lo que es necesario al definir el paquete propio especificar como dependencia la versión de la interfase a implementar. Esto permitira que al momento de realizar la migración de versión, se pueda conocer en desarrollo si existe alguna incompatibilidad de versiones debido a una nueva publicación.

{
    "name" : "mi/manejador-salida",
    "description" : "Implementación del patrón 'Abstract Factory' para la salida del proyecto X",
    ],
    "repositories" : [{
            "type" : "composer",
            "url" : "https://satis.siu.edu.ar"
        }
    ],
    "require" : {
        "siu/interfaces-manejador-salida-toba" : "~1.3"
    },
    "autoload" : {
        "psr-4" : {
            "mi-namespace\\" : "src"
        }
    },
    "minimum-stability" : "dev",
    "prefer-stable" : true
}

Configurando el runtime

A medida que vamos implementando componentes necesitamos ajustar su visualización y para ello es fundamental poder hacer uso del manejador que estamos desarrollando. Para utilizar nuestro manejador de salida debemos indicarle a SIU-Toba que el mismo esta disponible, eso lo realizamos de la siguiente manera:

<?php
//Indicamos las clases a utilizar si no esta por autoload
use SIU\ManejadorReferencia\referencia_factory; 
use SIU\ManejadorReferencia\referencia_config;

class contexto_ejecucion extends toba_contexto_ejecucion
{
    function conf__inicial()
    {

        //------------------------------------------------------------------------------------------------------------//
        //     Cambio el manejador de salida en runtime 
        //------------------------------------------------------------------------------------------------------------//
        //Instanciacion del provider (en este caso propio del proyecto)
        $referencia_manejador = new referencia_factory();
        toba::output()->registrarServicio($referencia_manejador);
        //Configuro un color por defecto distinto 
        referencia_config::setMainColor( '#11DD13');
    }
}
?>

Lo primero que hacemos es instanciar la factory de nuestro manejador, la cual indicará al framework las clases disponibles para la generación del marcado.

La invocación a toba::output() devuelve una instancia de la clase toba_factory_service mediante la cual se registran las instancias de las clases que implementan las salidas de los componentes.

Por defecto dicha clase tiene registrado el manejador de salida Toba, el cual implementa el marcado clasico del framework y actúa como fallback frente a otros registros.