Sebaxtian

El enemigo dentro

sebaxtian — Wed, 13 Mar 2024 14:04:24 +0000

Mientras el chico alto repartía los panfletos, el de la cara redonda se subió a la tarima y nos soltó su discurso. Las octavillas estaban escritas con el estilo simplista característico: «¡Hundamos las elecciones fraudulentas al rectorado! ¡Unamos nuestras fuerzas en una nueva huelga general en la universidad! ¡Demos un golpe decisivo a la conjunción poder industrial + poder académico = imperialismo japonés!». La teoría era magnífica, nada podía reprochársele al contenido, pero el texto carecía de poder de convicción. No inspiraba confianza ni movía corazones. Otro tanto sucedía con el discurso del chico de la cara redonda. La misma canción de siempre. La melodía era idéntica, solo diferían algunas comas. «El auténtico enemigo de estos tipos no es el poder estatal, es la falta de imaginación», pensé.

Extracto de «Tokio Blues» de Haruki Murakami

Subconjuntos en subpáneles

sebaxtian — Thu, 03 Nov 2016 14:25:54 +0000

Supongamos múltiples tipos de cuentas, todas con información que no difiere estructuralmente entre cada tipo y almacenadas todas en un mismo módulo. Para el ejemplo, y aunque lógicamente parezca una locura, podríamos suponer que instituciones, programas y departamentos se almacenarán todos como cuentas, bajo el supuesto de que la información requerida para cada uno de los tipos será siempre la misma.

Ahora bien, supongamos distintos tipos de relaciones entre contactos y cuentas, como por ejemplo estudiantes registrados, profesores, administrativos, docentes, además de otras tantas relaciones posibles.

Ahora supongamos la vista de una cuenta tipo Institución y a continuación imaginemos el subpanel con todos los contactos con los que tendrá relación. Ahora visualice la mezcla indistinta de estudiantes, docentes y administrativos que tendrá ese subpanel y comprenderá el problema en el que nos metimos por querer tener en un mismo módulo diferentes tipos de cuentas.

¿No sería genial poder separar el subpanel en conjuntos por cada tipo de relación y así evitar esa orgía de información?

Para el ejemplo supondremos los siguientes datos:

módulo_a: es el módulo que consultaremos
módulo_b: es el módulo que dividiremos en subpáneles
relación: es el nombre con el cuál declaró la relación entre Módulos A y B.
filtro: es el dato a filtrar. Debe corresponder a una variable que haya creado o que ya exista en el módulo. Dependiendo de eso deberá cambiar la forma como se hace la consulta SQL.
filtro_n: el dato n corresponde al elemento con el cuál se hará el filtro

El primer paso es la declaración de los distintos subpáneles. Es posible que ya exista el archivo así que deberá cambiar el contenido.

//custom/Extension/modules//Ext/Layoutdefs/_.php

"]["subpanel_setup"]['_'] = array (
		'order' => 101,
		'module' => '',
		'subpanel_name' => 'default',
		'sort_order' => 'asc',
		'sort_by' => 'id',
		'title_key' => 'LBL_',
		'get_subpanel_data' => 'function:get_',
		'generate_select' => true,
		'top_buttons' => array(),
		'function_parameters' => array(
			'import_function_file' => 'custom/Extension/application/Ext/Utils/_utils.php',
			'' => '',
		),
		'generate_select' => true,
	);
	
	$layout_defs[""]["subpanel_setup"]['_'] = array (
		'order' => 101,
		'module' => '',
		'subpanel_name' => 'default',
		'sort_order' => 'asc',
		'sort_by' => 'id',
		'title_key' => 'LBL_',
		'get_subpanel_data' => 'function:get_',
		'generate_select' => true,
		'top_buttons' => array(),
		'function_parameters' => array(
			'import_function_file' => 'custom/Extension/application/Ext/Utils/_utils.php',
			'' => '',
		),
		'generate_select' => true,
	);

El siguiente paso es la declaración de la función que atenderá este sistema de filtro. Es posible que el archivo ya exista.

//custom/Extension/application/Ext/Utils/_utils.php

function get_($params) {
    $args = func_get_args();
    
lt;filtro> = $args[0][''];
    $return_array['select'] = " SELECT .*";
    $return_array['from'] = " FROM  ";
    $return_array['where'] = " WHERE .deleted = '0' AND cstm._c = " . lt;filtro> . "";
    $return_array['join'] = " INNER JOIN _cstm cstm ON cstm.id_c = .id";
    $return_array['join_tables'][0] = "";
    return $return_array;
}

También se deberá agregar las modificaciones a la traducción para incluir los nuevos campos

//custom/Extension/modules//Ext/Language/en_us..php

	$mod_strings['LBL_'] = '';
	$mod_strings['LBL_'] = '';

Paso final, ejecutamos la acción de “Reparar y Reconstruir“, y ya tendremos los subpáneles.

Unos agujeros en Siberia

sebaxtian — Sat, 22 Oct 2016 15:11:46 +0000

«La liberación de metano en esas regiones inaccesibles, parece indicar que la capa de permafrost está comenzando a perforarse, lo que permite escapar al gas. Hemos encontrado niveles elevados de metano en la superficie del mar y aún más a ciertas profundidades.» – Örjan Gustafsson

Comic tomado de Cyanide & Happiness y cita tomada del artículo en Wikipedia sobre la Hipótesis del fusil de clatratos.

Almacenando arreglos en un campo

sebaxtian — Wed, 27 Apr 2016 01:19:47 +0000

Almacenando arreglos en un campo
Declaración de la variable y sus funciones de almacenamiento
Agregar las vistas
Para los perspizaces

Seguramente ya se habrán topado con el widget para agregar correos a una cuenta. Esta solución es muy interesante desde la óptica de la usabilidad porque se trata de un campo que puede ampliarse conforme se vayan necesitando nuevos items, y si bien uno podría decir que con un relacionamiento es posible simular un elemento de este tipo, también es verdad que para el usuario es mejor tener un listado dentro de la declaración del módulo en vez de un subpanel. Así son los usuarios.

Es necesario también hacer diferencia entre dos tipos de variables. En el caso de los correos se trata de relaciones entre la cuenta y una línea de correo, y esto se hace para que un cambio en un correo se vea reflejado al instante en todos los beans (cuentas, compañías, oportunidades, contactos, etc). La otra opción es un campo encargado de almacenar un arreglo o una matriz y que guardará el dato como una cadena JSON.

Para el presente ejemplo supondremos que vamos a almacenar un arreglo como una cadena JSON dentro del campo.

Capítulos: | 1 | 2 | 3 | 4 | Siguiente |

Campos personales en relaciones

sebaxtian — Wed, 13 Apr 2016 01:03:14 +0000

La herramienta Studio de SuiteCRM facilita el trabajo de declaración de relaciones entre módulos, pero su funcionalidad se queda corta cuando además requerimos la declaración de campos al interior de la relación misma. En circunstancias como esta no queda más alternativa que echar mano al código fuente.

Para el presente ejemplo supondremos que ya está declarada la relación entre los módulos y que ha ejecutado la acción de reconstrucción.

Capítulos: | 1 | 2 | 3 | 4 | 5 | Siguiente |

Campo para una imagen en la configuración

sebaxtian — Sat, 02 Apr 2016 17:33:31 +0000

En la anterior entrada expliqué cómo crear una vista para el manejo de variables de configuración. El ejemplo se limitaba a dos campos de texto, y en teoría agregar otros campos básicos (texto, área de texto, numérico y color) no debería representar problema alguno. Pero al hacer págnas configuración es muy común encontrar campos para imágenes. El presente ejemplo extiende la anterior nota para agregar este tipo de variables a la configuración y por lo tanto debe haber realizado el anterior ejemplo para poder realizar esta actividad.

El primer punto a tener en cuenta es buscar la forma de subir la imagen. Uno pensaría que SuiteCRM integraría un punto de entrada de este tipo, pero por lo que pude entrever cada módulo crea su propio mecanismo, y el resultado es que cada uno tiene sus propias particularidades. En definitiva es aconsejable crear uno propio. Recuerde que la declaración del EntryPoint se hace en el directorio de Aplicaciones, pero el archivo del EntryPoint puede estar en cualquier directorio. Por facilidad mnemotécnica la ubico en el Configurator porque al fin de cuentas lo usaremos con este módulo.

//custom/modules/Configurator/UploadImageFile.php

encode($returnArray);
    sugar_cleanup();
    exit();
}

global $sugar_config;
//Solo aceptamos jpg, jpeg y png.
//No podemos aceptar gif ni bmp porque internamente SUgar los descarta
$supportedExtensions = array('jpg', 'png', 'jpeg');

//Declaramos las variables del sistema
$json = getJSONobj();
$rmdir=true;
$returnArray = array();
$upload_ok = false;

//Obtenemos los datos de la foto
$section = $_REQUEST['section'];
$name = $_REQUEST['name'];

//Declarar el directorio donde quedará la imagen
$upload_path = $section . '/' . $name ;
//Debe venir el archivo file_1
if(isset($_FILES['file_1'])){
	//Declarar el mecanismo para manipular el archivo temporal
    $upload = new UploadFile('file_1');
    //Confirmar que hay archivo
    if($upload->confirm_upload()) {
		//Determinar dónde quedará la imagen
        $upload_dir  = 'upload://' . $upload_path;
        //Asegurar que podremos subir la imagen
        UploadStream::ensureDir($upload_dir);
        //Verificar que se subió la imagen a la posición temporal
        if(!verify_uploaded_image($upload->temp_file_location)){
			//Si no se subió, declarar el error
            $returnArray['data']='other';
            $returnArray['path'] = '';
            echo $json->encode($returnArray);
            sugar_cleanup();
            exit();
        }
        //Determinar el directorio donde se almacenará definitivamente la imagen
        $file_name = $upload_dir."/".$upload->get_stored_file_name();
        //Guardar la imagen en la ubicación definitiva
        if($upload->final_move($file_name)) {
            $upload_ok = true;
        }
    }
}

//Si no se almacenó laimagen en la posición definitiva
if(!$upload_ok) {
	//Declarar el error
    $returnArray['data']='not_recognize';
    echo $json->encode($returnArray);
    sugar_cleanup();
    exit();
}

//Determinar la url del upload
$returnArray['upload']=$upload->get_upload_url();

//Si el archivo existe
if(file_exists($file_name) && is_file($file_name)) {
	//Obtener los datos del archivo y declarar las variables
    $encoded_file_name = rawurlencode($upload->get_stored_file_name());
	$returnArray['filename'] = $file_name;
    $returnArray['path'] = $upload_path . '/' . $encoded_file_name;
    $returnArray['url']= 'cache/images/'.$encoded_file_name;
    //Verificar que se subió la imagen
    if(!verify_uploaded_image($file_name, false)) {
        $returnArray['data']='other';
        $returnArray['path'] = '';
        unlink($file_name);
    } else {
		//Sino, copiarla
		copy($file_name, sugar_cached('images/'.$upload->get_stored_file_name()));
	}
	//Si hay 'data' es porque ubo un problema 
    if(!empty($returnArray['data'])){
        echo $json->encode($returnArray);
    }else{ //Sino, ndicar en data que el proceso se concluyó bien
        $rmdir=false;
        $returnArray['data']='ok';
        echo $json->encode($returnArray);
    }
}else{ //SI no existe el archivo, informar del error
    $returnArray['data']='file_error';
    echo $json->encode($returnArray);
}
sugar_cleanup();
exit();

//custom/Extension/application/Ext/EntryPointRegistry/UploadImageFile.php

 'custom/modules/Configurator/UploadImageFile.php',
		'auth' => true,
	);

Ejecutamos la acción de “Reparar y Reconstruir“, y tendremos a nuestra disposición el punto de entrada para subir una imagen.

Ahora modificamos la declaración de la vista y agregamos la línea de la foto en la sección donde se declaran las variables de la configuración del paquete (líneas 22 a 30 del ejemplo de la anterior entrada).

//custom/modules/Configurator/views/view..php

        //Declarar la instancia para administrar
        //la configuración
        $cfg = new Configurator();
		//Declarar los elementos de la configuración
		//en caso de aun no estar declarados
		if (!array_key_exists('', $cfg->config)) {
		    $cfg->config[''] = array(
		        'name' => '',
		        'code' => '',
		    );
			$cfg->saveConfig();
		}
		
		//Agregar la nueva variable
		if(!isset($cfg->config['']['logo'])) {
			$cfg->config['']['logo'] = '';
			$cfg->saveConfig();
		}

También se deberá agregar las modificaciones a la traducción para incluir los nuevos campos

//custom/Extension/modules/Configurator/Ext/Language/en_us..php

	$mod_strings['LBL__LOGO'] = 'Current Logo:';
	$mod_strings['LBL__LOGO_HELP'] = 'This logo is displayed in the tickets.';
	$mod_strings['LBL__NEW_LOGO'] = 'Select Logo:';

A continuación creamos la plantilla con los agregados para hacer uso del entryPoint. Igual que en el anterior ejemplo no hay funciones para chequeo de variables así que se deja al lector la labor correspondiente.

//custom/modules/Configurator/tpls/.tpl

{*

/*********************************************************************************
 * Vista para la administración de la información del centro comercial
 ********************************************************************************/

*}

	{$MOD.LBL__SETTINGS}
	





{$error.main}



	
		
		 
		  
	





	{$MOD.LBL__DESCRIPTION}


	
		{$MOD.LBL__NAME} 
		
			
		
		{$MOD.LBL__CODE} 
		
			
		
	
	
        
        {$MOD.LBL__LOGO} {sugar_help text=$MOD.LBL__LOGO_HELP}
        
        
            _logo_image" style="width: auto; max-height: 150px;" src='{$config..logo}' alt='{$MOD.LBL__LOGO}'>
        
    
    
        
            {$MOD.LBL__NEW_LOGO} {sugar_help text=$MOD.LBL__NEW_LOGO_HELP_NO_SPACE}
        
        
            
            
        
    






{if $logger_visible}

{/if}
	
{$MOD.LBL_LOGGER}

	
		{$MOD.LBL_LOGGER_FILENAME}
		
		{$MOD.LBL_LOGGER_FILE_EXTENSION}
		
		{$MOD.LBL_LOGGER_FILENAME_SUFFIX}
		
	
	
		{$MOD.LBL_LOGGER_MAX_LOG_SIZE} 
		 
		{$MOD.LBL_LOGGER_DEFAULT_DATE_FORMAT}
		
	
	
		{$MOD.LBL_LOGGER_LOG_LEVEL} 
		 
		{$MOD.LBL_LOGGER_MAX_LOGS} 
		 
	

	    {$MOD.LBL_LOGVIEW}
	





		 
		 

{$JAVASCRIPT}



    
        
        {sugar_getimage name="sqsWait" ext=".gif" alt=$mod_strings.LBL_LOADING other_attributes='id="loading_img_" style="display:none" '}
    

{if $error._logo}

{/if}
{literal}

{/literal}

{$MOD.LBL__DESCRIPTION}
{$MOD.LBL__NAME}		{$MOD.LBL__CODE}
{$MOD.LBL__LOGO} {sugar_help text=$MOD.LBL__LOGO_HELP}	_logo_image" style="width: auto; max-height: 150px;" src='{$config..logo}' alt='{$MOD.LBL__LOGO}'>
{$MOD.LBL__NEW_LOGO} {sugar_help text=$MOD.LBL__NEW_LOGO_HELP_NO_SPACE}

{$MOD.LBL_LOGGER}
{$MOD.LBL_LOGGER_FILENAME}	{$MOD.LBL_LOGGER_FILE_EXTENSION}	{$MOD.LBL_LOGGER_FILENAME_SUFFIX}
{$MOD.LBL_LOGGER_MAX_LOG_SIZE}	{$MOD.LBL_LOGGER_DEFAULT_DATE_FORMAT}
{$MOD.LBL_LOGGER_LOG_LEVEL}	{$MOD.LBL_LOGGER_MAX_LOGS}
{$MOD.LBL_LOGVIEW}

Páginas de configuración y otra forma de agregar vistas

sebaxtian — Sat, 02 Apr 2016 14:48:06 +0000

Muchas veces he remarcado la importancia de replicar el lenguaje visual y de acciones en distintas páginas de un mismo sitio/programa/plataforma con el objeto de facilitar al usuario deducir nuevas acciones a partir de la experiencia que haya adquirido con el manejo del programa. La demostración más directa de lo que digo es que todos los usuarios usuario esperaría encontrar los procesos de configuración dentro del entorno de administración, y se extrañarían de que fuera de otra manera.

Siguiendo con la lógica MVC de SuiteCRM encontramos que estas páginas de configuración son en realidad vistas de los módulos Administration y Configurator, que junto la clase Configurator ofrecen el grueso de funciones para acceder y administrar la información de configuración que vayamos creando.

En una anterior entrada explicaba la forma de crear una vista y la forma de emplear un controlador para llamar a la vista después de ejecutar las acciones, sin embargo para esta vez no crearemos directamente el controlador sino que declararemos el mapa con el cual vincular una acción a esta nueva vista, y por lo tanto al declarar la vista deberá incluirse la lógica funcional en su interior (es decir, MVC al carajo).

Empezamos creando la vista que deberá ir en el módulo Configurator y que deberá tener el nombre de la acción que ejecutará la vista de la página de configuración. Atención a las mayúsculas en la declaración de la Clase.

También preste especial atención a la diferencia entre y , porque una cosa es la Acción para llamar a la página de configuración del paquete de módulos, y otra el paquete de módulos.

//custom/modules/Configurator/views/view..php

 extends SugarView {
	
    /**
     * Acciones que se ejecutaran antes de visualizar la página 
     */
    public function preDisplay() {
        global $current_user;
		
		//Debe ser administrador, sino terminamos el proceso
        if (!is_admin($current_user)) {
            sugar_die("Unauthorized access to administration.");
        }
        
        //Declarar la instancia para administrar
        //la configuración
        $cfg = new Configurator();
		//Declarar los elementos de la configuración
		//en caso de aun no estar declarados
		if (!array_key_exists('', $cfg->config)) {
		    $cfg->config[''] = array(
		        'name' => '',
		        'code' => '',
		    );
			$cfg->saveConfig();
		}
        
        //Guardar configuración en caso de venir la solicitud
        if(isset($_REQUEST['save'])) {
			$cfg->saveConfig();
		}
    }

    /**
     * Función para visualizar la plantilla
     */
    public function display() {
		//Declarar que necestamos los elementos de traducción
        global $mod_strings, $app_strings;
        
        //Declarar la instancia para administrar
        //la configuración                
        $cfg = new Configurator();
        
        //Asignar elementos de traducción                 
		$this->ss->assign('MOD', $mod_strings);
        $this->ss->assign('APP', $app_strings);
        
        //Asinar elementos de configuración
        $this->ss->assign('config', $cfg->config);
        
        //Imprimir la plantilla		
		echo $this->ss->fetch('custom/modules/Configurator/tpls/.tpl');
       
    }
}

El siguiente paso es la declaración de la plantilla de la vista y su archivo de traducciones. Esta es una plantilla básica que no incluye procesos para chequear los, así que queda a consideración del usuario los métodos para declarar estas funciones.

//custom/modules/Configurator/tpls/.tpl

{*

/*********************************************************************************
 * Vista para la administración de la información del centro comercial
 ********************************************************************************/

*}

	{$MOD.LBL__SETTINGS}
	





{$error.main}



	
		
		 
		  
	





	{$MOD.LBL__DESCRIPTION}


	
		{$MOD.LBL__NAME} 
		
			
		
		{$MOD.LBL__CODE} 
		
			
		
	





		 
		 

{$JAVASCRIPT}

{$MOD.LBL__DESCRIPTION}
{$MOD.LBL__NAME}		{$MOD.LBL__CODE}

El penúltimo paso es la declaración de la acción que ejecutará la vista y el archivo de traducciones.

//custom/Extension/modules/Configurator/Ext/ActionViewMap/.php

'] = '';

//custom/Extension/modules/Configurator/Ext/Language/en_us..php

_SETTINGS'] = 'Mall Settings';
    $mod_strings['LBL__DESCRIPTION'] = 'Change settings to adjust to the Mall';
    $mod_strings['LBL__NAME'] = 'Mall Name:';
    $mod_strings['LBL__CODE'] = 'Code:';

El último paso es la declaración del acción para que se visualice en la página de administración y su correspondiente archivo de traducciones.

En el presente ejemplo agregaremos la acción al final de la sección del Sistema (segunda sección del administrador de SuiteCRM). Es posible crear una sección propia, pero en esta caso particular por tratarse de una única acción se vería como un desperdicio de espacio.

Este grupo de acciones se ejecutará en el módulo Administration.

//custom/Extension/modules/Administration/Ext/Administration/.php

'] = array(
		//Nombre del ícono. Los íconos disponibles están en ./themes/default/images
		'editlabels',
		
		//Nombre del enlace 
		'LBL__LINK_NAME',
		
		//Descripción
		'LBL__LINK_DESCRIPTION',
		
		//URL del enlace
		'./index.php?module=Configurator&action=',
	);
	
	$admin_group_header[1][3][''] = $accion;

//custom/Extension/modules/Administration/Ext/Language/en_us..php

_LINK_NAME'] = 'Package Settings';
	$mod_strings['LBL__LINK_DESCRIPTION'] = 'Change settings to adjust the package';

Paso final, ejecutamos la acción de “Reparar y Reconstruir“, y ya tendremos el botón para administrar.

¿Y cómo usar la configuración almacenada?

 = $cfg->config[''];

Crear PDF con páginas de tamaño dinámico

sebaxtian — Fri, 25 Mar 2016 00:31:27 +0000

La mayoría de los PDF tienen páginas del mismo tamaño, pero en casos particulares se hace evidente la necesidad de buscar una alternativa dinámica. como por ejemplo la impresión de varias boletas con una impresora para facturas que hace el corte según el tamaño de cada página.

El siguiente código emplea la librería mpdf para generar el documento, una plantilla sobre la cuál se irán generando las distintas boletas, y dos arreglos con los títulos y párrafos para cada versión.

El algoritmo maneja una instancia del generador de documentos PDF que será la encargada del documento final, y otra donde se irá creando cada nueva boleta y que será empleado para conocer el tamaño del documento impreso. Una vez conocida esta información crearemos una nueva página con este tamaño dentro de la instancia que almacena el documento final, de tal manera que en esta nueva página quepa la nueva boleta.


			div.pagina { /*font-family: DejaVuSansMono;*/ } 
			h1, table.logos td { text-align: center; } 
			table.logos { width: 100%; }
		
		
			%titulo%
			%parrafo%
		";
	
	//Títulos
	$titulos = array(
		'Vivamus elementum rutrum mattis',
		'Donec consequat aliquet lorem vel',
		'Fusce mattis tellus vel nulla'
	);
		
	//Párrafos
	$parrafos = array(
		'Pellentesque tellus diam, sollicitudin a semper ac, semper et augue. Duis orci nulla, ornare a orci ut, consequat tempus lorem. Morbi venenatis nisi et rutrum ultricies. Nulla pulvinar posuere malesuada. Aliquam id odio feugiat, mattis ante ac, viverra magna. Interdum et malesuada fames ac ante ipsum primis in faucibus. Ut libero dui, eleifend at pulvinar sed, volutpat eu augue. Nullam non metus non felis suscipit pulvinar. Praesent at magna ex. Etiam blandit diam id interdum faucibus. Phasellus ac blandit nulla, id scelerisque lacus. Donec hendrerit eros in bibendum lobortis. Nulla tincidunt tellus at erat pulvinar tempus a commodo mauris. Vestibulum blandit arcu justo, non ultrices elit egestas quis. Integer fringilla non risus quis ullamcorper.',
		'Donec pulvinar, enim eu interdum egestas, nibh nunc pellentesque enim, quis egestas quam urna id ligula. Curabitur lobortis felis ex, vel viverra est feugiat ut. Fusce sed nisi et turpis consequat eleifend. Curabitur congue rhoncus volutpat. Suspendisse purus leo, euismod at malesuada ac, commodo a ex. Pellentesque consectetur mi facilisis ullamcorper consequat.',
		'Aenean in nisi sit amet magna congue dapibus at nec nulla. Nullam sit amet nisi magna. Curabitur egestas tellus lectus, eget malesuada enim imperdiet non. Cras vestibulum nunc ut aliquam dignissim. Nunc consequat sed tellus a elementum. Phasellus pharetra erat et metus consectetur sollicitudin. Praesent aliquet sed neque hendrerit tempor. Suspendisse lobortis id lacus et sollicitudin. Proin et justo ac mauris pellentesque egestas. Maecenas sit amet nisl vitae mauris luctus mollis. '
	);
	
	//Crearemos tantas páginas como items hay en el 
	//arreglo de nombres
	foreach( $titulos as $key => $titulo ) {
		//PDF con el que calcularemos el tamaño de la página
		$pdf_aux = new mPDF('en', array('74mm', '100mm'), 8, '', 5, 5, 4, 4);
		
		//Reemplazar las variables y obtener el HTML para esta página
		$data = str_replace(
			array('%titulo%', '%parrafo%'),
			array($titulos[$key] ,$parrafos[$key]),
			$template
		);
		
		//Agregar los datos al pdf de referencia 
		$pdf_aux->WriteHTML($data);
		//Calcular el tamaño de la zona impresa como
		//Total de páginas impresas completas multiplicado por la zona 
		//que se puede imprimir en cada página, mas la zona que se uso
		//en la última hoja mas el margen inferior
		$calculado = ((($pdf_aux->page - 1) * ($pdf_aux->fh - $pdf_aux->lMargin - $pdf_aux->bMargin)) + ($pdf_aux->y)) + $pdf_aux->bMargin;
		
		//Añadir al pdf que vamos a imprimir la nueva página
		//usando el tamaño calculado
		$pdf->AddPageByArray( 
			array(
				'orientation' => 'P',
				'sheet-size' => array('74mm', $calculado.'mm') 
			)
		);
		//Teniendo ya la nueva página, agregar
		//los datos
		$pdf->WriteHTML($data);
	}
	
	//Descargar PDF
	$pdf->Output();
?>

Puntos de entrada

sebaxtian — Wed, 23 Mar 2016 18:27:54 +0000

La lógica de los controles y las vistas en el Framework MVC de SuiteCRM (y en general en cualquier otro framework que siga este modelo) es ejecutar una acción y presentar los resultados en una vista, pero para aquellas circunstancias en donde el objetivo no es la visualización de una vista sino la generación de un archivo PDF para imprimir, agregar datos a una encuesta o generar un correo en forma automática a partir de de los datos de un formulario en un sitio web externo se debe usarotra aproximación.

Para estos casos SuiteCRM emplean los EntryPoints, que son descritos como páginas de acceso al entorno SuiteCRM.

El primer paso será la creación del script que atenderá los llamados al EntryPoint, archivo que puede ubicarse en cualquier lugar pero que se recomienda ubicar en:

//custom/.php

format('c');

Este script podrá recibir variables por GET o por POST (igual que cualquier otro script php), incluirá el entorno global ( por ejemplo $this ) y tendremos además acceso a todas las primitivas de SuiteCRM para administrar las instancias de los módulos.

La primera línea es de vital importancia, porque es la que evita que el script sea usado tras un llamado directo desde el navegador.

Una vez tenemos el script que atenderá el llamado al punto de entrada, es hora de crear el elemento con el cual se declara el EntryPoint.

Nóte que los puntos de entrada se declaran dentro de la aplicación, y no dentro de un módulo.

Una vez tengamos el archivo disponible, agregaremos una única línea para declarar el punto de ingreso.

//custom/Extension/application/Ext/EntryPointRegistry/.php

'] = array(
			'file' => 'custom/.php',
			'auth' => false,
		);

El arreglo tiene dos variables, una es la ubicación del archivo que atenderá el llamado al punto de entrada, y la otra indica si se permite usar el punto de entrada sin haber iniciado sesión. Una vez se tengan los dos archivos será hora de ejecutar la acción de “Reparar y Reconstruir“, y paso seguido tendremos disponible el llamado usando la siguiente URL
http:////index.php?entryPoint=

Agregar acciones en menús

sebaxtian — Tue, 22 Mar 2016 18:25:25 +0000

SuiteCRM hace una separación interesante en cuanto a dónde ubicar cada elemento para que al cargar el proceso de «Reparación y Reconstrucción Rápida» todos los nuevos elementos encajen en su lugar. Es como un tablero donde hay agujeros con formas especiales para cada tipo de pieza, de tal manera que solo las piezas ubicadas correctamente pasarán hasta la caja recolectora. Acá entre nos esa forma de ver el mundo me perturba porque al fin de cuentas estos límites son funcionales para las interfaces de usuario en donde facilitar el lenguaje visual es un paso lógico en su diseño, pero limitar al desarrollador para que solo pueda usar las formas predefinidas sin permitirle agregar nuevas es como decirle a un escritor que escriba un libro usando tarjetas con frases preescritas. Pero como el modelo de programación a seguir para hacer buen uso de SuiteCRM es este, entonces así se deberá hacer.

Para la muestra agreguemos un botón.

Capítulos: | 1 | 2 | 3 | 4 | Siguiente |