Escritos

Introducción

A la hora de crear un documento en ODL es necesario hablar de ciertos conceptos que intervienen en este tipo de operaciones. Por un lado están las definiciones de componentes documento y plantilla, y por otro lado existe un formato de fichero .rtf (Rich Text Format) que contendrá la información del escrito. Este tipo de ficheros ofrece la posibilidad de declarar marcas en el contenido, de forma que esas marcas sean sustituídas por campos que provienen, en este caso, de nuestro código ODL. Veamos con más detalle cada uno de los conceptos:

Componente documento

La definición de documento se realiza a nivel de contenedores. Este componente lo definiremos en aquel contenedor en el cual queramos que aparezca la opción de elaboración de escrito. Para esta definición existe sólo un atributo, plantilla_documento, que especificará el fichero .RTF asociado. En ODL, el recurso contenedor sólo permite una definición de documento, por lo que no podremos generar varios escritos a raíz de un mismo objeto.

Componente plantilla

Es un componente de ODL donde definiremos, mediante secciones, los campos a rellenar en el fichero .rtf. La plantilla tomará los valores de los campos mediante referencia.

Pero, ¿y cómo sabe la plantilla a qué documento tiene que enviar esos campos?

Existe un atributo -documento donde especificaremos la definición de la componente documento que, a su vez, tendrá declarado el nombre del fichero .rtf. Podríamos decir que la componente documento actúa como puente de comunicación entre la plantilla y el documento .rtf.

Rich Text Format

Es el formato que utiliza egEasy para la creación de escritos. Este formato permite definir unas marcas o tags, de forma que podamos crear un escrito dinámico, cuyo resultado o contenido puede variar en función de la información contenida en un objeto.

Ejemplo básico

Aprovechando el ejemplo utilizado en el artículo Contenedores, vamos a incluir código ODL para que podamos elaborar un escrito.

En primer lugar, debemos tener claro la estructura e información que contendrá nuestro escrito, para así poder definir las marcas que necesitemos. Para este ejemplo básico, y utilizando la definición del contenedor Libro, queremos generar simplemente una ficha con los datos de un objeto Libro. Por tanto, necesitaremos elaborar un fichero .rtf con el contenido y sus marcas, definir la componente documento en el tipo de contenedores que nos interese elaborar los escritos y, finalmente, definir la plantilla con los campos correspondientes. Veamos pues cómo definimos las marcas en nuestro fichero .rtf para que al elaborar el escrito, se traduzcan en valores concretos:

Documento RTF con marcas

Esta es la marca más básica que puede integrar un documento .rtf. Su sintaxis, <#=Nombre_del_campo>, es muy simple. La marca completa será sustituída por el valor del campo que indiquemos, y para eso, el nombre debe coincidir con el campo incluído en la plantilla. Una vez creado el documento .rtf, tenemos que declarar la componente documento en el contenedor desde donde queremos crear el escrito:

tipo [Libro] es contenedor
   [Datos] es formulario
   ...
   ...
   ...
   fin

   [Escrito] es documento
       -plantilla_documento= "Escrito_001.rtf"
   fin

fin

Como ya explicamos anteriormente, en el atributo plantilla_documento especificamos el documento .rtf con el que se va a generar el escrito. Veamos cómo se refleja el código insertado en la herramienta egExplorer:

Inclusión de la componente documento en un objeto

Como vemos, nos aparece una pestaña nueva al abrir un objeto de tipo "Libro", que obtiene el nombre de la definición de documento. En esta instancia del objeto, podremos elaborar y abrir los escritos que se generen.

Ahora solamente nos falta definir la componente plantilla. Esta componente, no hay que definirla dentro de un contenedor como la definición de documento, sino que declararemos un tipo plantilla como código independiente de cualquier definición de contenedor.

tipo [Elaborar Escrito] es plantilla
   -documento = [Libro].[Escrito];
   [Campos a rellenar] es seccion
      [Enlace] es variable
         -vinculo.definicion = [Libro];
         -edicion.modo = referencia;
         -edicion.valor = [&Dominio];
      [Código] es texto
         -edicion.modo = referencia;
         -edicion.valor = [Enlace]->[Datos].[Código];
      [Título] es texto
         -edicion.modo = referencia;
         -edicion.valor = [Enlace]->[Datos].[Título];
      [Autor] es texto
         -edicion.modo = referencia;
         -edicion.valor = [Enlace]->[Datos].[Autor];
      [Tipo] es texto
         -edicion.modo = referencia;
         -edicion.valor = [Enlace]->[Datos].[Contenido].[Tipo];
   fin
fin

Hemos incluído los campos que se corresponden con las marcas definidas en el fichero .rtf y que serán los encargados de almacenar los valores del objeto que luego sustituirán a las marcas en el .rtf.

Como habrás observado, hay definida una variable. En este caso, la variable obtiene el valor [&Dominio], cuyo valor será la ubicación del recurso, en este caso, la ubicación del contenedor Libro. Su declaración no es estrictamente necesaria, ya que podríamos eliminar la variable y sustituir la referencia a los campos de esta forma, [&Dominio]->[Datos].[Campo].

Veamos entonces cómo se produce la obtención de valores por parte de la plantilla y su posterior sustitución en el .rtf:

Cumplimentar el documento mediante la plantilla

Una vez aceptado el cumplimentado, se abrirá el documento con los valores intercambiados. El documento ya estará creado, y el resultado sería el siguiente:

Sustitución de los valores proporcionados por la plantilla en el documento .RTF

Firmando escritos

En los sistemas de información, es una tarea común firmar los escritos o informes que se generan. Para ello, ODL proporciona un campo firma que ofrece la posibilidad de insertar firmas en los escritos.

Para poder insertar firmas en un escrito, es necesario definir un campo firma en el formulario del contenedor en cuestión. Además, debemos insertar la marca correspondiente en nuestro escrito, que será sustituída por una imagen .bmp que habremos asociado al usuario firmante mediante la aplicación egAdmin. En el caso de las firmas, no es necesario insertar el campo firma en ninguna plantilla, ya que la elaboración de un escrito y la realización de una firma se consideran acciones distintas. En la práctica, normalmente el usuario que elabora el escrito no es el encargado de realizar la firma, de forma que no tiene sentido incluirla en la plantilla. Veamos el siguiente ejemplo:

tipo [Libro] es contenedor
   [Datos] es formulario
      [Código] es timbre
         -certificado.valor = [&Valor_secuencia];
         -certificado.secuencia.nombre = "STR$LIBRO";
         -certificado.secuencia.longitud = 4;
      [Título] es texto
      [Autor] es texto
      [Edición] es texto
      [Editorial] es texto

      [Contenido] es seccion
         [Tipo] es texto
            -edicion.valores = $Matriz("Literario","Biografía","Científico","Infantil");
            -apariencia.desplegable = verdadero;
         [Sinopsis] es texto
            -edicion.longitud = 1000;
      fin
      [Firma1] es firma
fin

Añadir campo firma en el documento .RTF

A la hora de sustituir un campo firma, además de la imagen también se incluyen ciertos datos relacionados con el firmante, también denominados rúbricas. Por defecto, el formato firma de un usuario está compuesto de los campos pie de firma, cargo del usuario, la imagen de la firma y el nombre del usuario, por este orden. Si generamos un escrito con la marca anterior, el resultado sería el siguiente:

Primer paso: elaborar el escrito

Segundo paso: realizamos la firma

Tercer paso: abrir el documento resultante

Una vez creado el objeto, firmado y generado el escrito, prueba a editar algún campo del formulario y observarás que no es posible. Esto es debido a que un objeto, cuando se realiza una firma, el objeto queda protegido, de forma que los campos dejan de ser editables (aunque queden más firmas por realizar).

Para poder editar un campo cualquiera una vez firmado un campo firma, haremos uso del atributo edicion.proteger. En el capítulo 6 de este artículo podremos ver la utilidad de este atributo.

Propiedades de un campo firma

Como hemos dicho, la inclusión de una firma en un escrito incluye además una serie de datos relacionados con el firmante. Estos datos son realmente propiedades del campo firma, que adquieren valor una vez se firma el escrito. Estas propiedades son las siguientes:

• Fecha: indica la fecha en la cual se realizó la firma. Ésta se muestra en formato largo, es decir, con la forma "__ de _________ de ____".
• Usuario: nombre del usuario que realizó la firma.
• ID_Usuario: identificador del usuario que realizó la firma.
• Sede: sede del usuario que realizó la firma.
• Pie_de_firma: delegación de responsabilidad a la cual pertenece el usuario que realizó la firma.
• Cargo: cargo del usuario que realizó la firma.

Las propiedades Usuario, Sede, Pie_de_firma y Cargo son campos editables en la ficha de cada usuario y que podremos modificar mediante el egAdmin.

Pero, ¿y si quisiéramos insertar en el escrito algún dato adicional del campo firma?

En ODL, la forma de acceder a las propiedades, en este caso, de un campo, es la siguiente: Campo.&Propiedad. Por tanto, si quisiéramos insertar la información de la propiedad Sede o Fecha pues sólo tendríamos que añadir las siguientes marcas en nuestro escrito: <#=Nombre_del_campo_firma.&Sede> ó <#=Nombre_del_campo_firma.&Fecha>.

Incluyendo varias firmas en un escrito

En un sistema de información, es normal que un escrito, ya sea un informe, una resolución, etc., tenga que ser firmado por varias personas responsables. En caso de ser así, la solución es simple, añadir tantos campos firma en el formulario como firmas se tengan que realizar en el escrito, con sus respectivas marcas en el fichero .rtf asociado.

Ahora bien, ¿es posible que para realizar una firma se requieran otras? Aunque los campos firmados se puedan ver en el objeto, es posible que interese que se reemplacen en el escrito aunque no se hayan timbrado todas las firmas. Veamos qué atributo nos permite adoptar este comportamiento.

Atributo reemplazar_siempre

Es un atributo que permite que las firmas sean sustituídas en el escrito al momento de realizarlas. Es un atributo lógico, que por defecto adquiere el valor falso, de forma que las firmas serán reemplazadas en el escrito cuando se realicen todas las firmas. Lo añadiremos con valor verdadero en aquellos campos firma que queramos se reemplacen en el momento de realizar la firma, independientemente del estado de otros campos firma.

Ejemplo

Como ya hemos dicho, en caso de no especificar el atributo reemplazar_siempre, su valor será falso y por tanto las firmas se reemplazarán una vez se hayan realizado todas. Por el contrario, veamos como cambiaría el comportamiento de las firmas en caso de incluir el atributo con valor verdadero:

tipo [Libro] es contenedor
   [Datos] es formulario
      [Código] es timbre
         -certificado.valor = [&Valor_secuencia];
         -certificado.secuencia.nombre = "STR$LIBRO";
         -certificado.secuencia.longitud = 4;
      [Título] es texto
      [Autor] es texto
      [Edición] es texto
      [Editorial] es texto

      [Contenido] es seccion
         [Tipo] es texto
            -edicion.valores = $Matriz("Literario","Biografía","Científico","Infantil");
            -apariencia.desplegable = verdadero;
         [Sinopsis] es texto
            -edicion.longitud = 1000;
      fin
      [Firma1] es firma
         -reemplazar_siempre = verdadero;
      [Firma2] es firma
fin

Realizamos la primera firma de la siguiente manera:

Campo Firma1 firmado

Al abrir el documento, veremos que la primera firma sí se ha reemplazado, de forma que la marca de la segunda firma, aún queda pendiente:

Efecto que produce el atributo reemplazar_siempre. La primera firma se ha sustuído en el escrito

Realizamos la segunda firma:

Timbrado de la segunda firma

Y finalmente se genera el documento con las dos firmas:

Reemplazo de la segunda firma

Atributo actualizar_escrito

Existe un atributo general para todos los campos en ODL, llamado actualizar_escrito, que ofrece la posibilidad de actualizar en el escrito un campo que haya sido modificado en el objeto, una vez éste haya sido bloqueado. El valor por defecto es falso, de forma que esta opción estará desactivada para todos los campos.

En caso de querer añadir este atributo a un campo, únicamente tendremos que añadir al campo que nos interese la siguiente sentecia, (-actualizar_escrito = verdadero;).

Si realizas una prueba, elaborando un escrito y luego firmándolo, comprobarás que no es posible editar ningún campo. Como ya explicamos, esto es debido a que el estado del objeto se encuentra protegido por las firmas realizadas. Para este caso, es necesario incluir el atributo edicion.proteger y darle el valor falso. De este modo, aunque el objeto esté protegido, podremos editar el campo. Una vez modificado, abriremos de nuevo el escrito para comprobar que el valor del campo ha variado