Ver el código de «Tarea I: Creando una oficina sin papeles»

[[Desarrollar_con_egeasy_paso_a_paso|Desarrollar con egeasy paso a paso]]
[[Imagen:Tarea_I_Figura_1_Diagrama_procedimiento.jpg|thumb|250px|Procedimiento de concesión de becas]]
<br/>
<p>Hasta ahora, los usuarios del Registro utilizan el software sólo para introducir o consultar datos, sin realizar ningún trámite ni llevar a cabo un procedimiento administrativo.</p> 
<p>Supongamos que la organización ofrece becas para la realización de estudios en el extranjero. Estas becas las gestiona el Servicio de Ayudas y Subvenciones. Los interesados deben presentar las solicitudes en el Registro de Entrada y Salida. Un auxiliar del Registro revisa la documentación y, en caso de faltar algo, elabora un requerimiento para el interesado. Este requerimiento debe firmarlo el jefe de servicio del Registro.</p>
<p>Una vez la documentación esté completa, se remite al Servicio de Ayudas y Subvenciones quien resuelve la beca por el procedimiento de concurrencia sin concurso; es decir, que todos aquellos interesados que cumplan con los requisitos recibirán la beca.</p>
<p>Al recibir la documentación, un técnico del Servicio de Ayudas y Subvenciones comprueba la documentación para ver si el interesado cumple con los requisitos. A continuación, procede a elaborar resolución positiva (o negativa). La resolución la deben firmar el jefe del Servicio de Ayudas y Subvenciones y el director de la organización.</p>
<p>Una vez firmada, la resolución se remite al Registro, donde un auxiliar se encarga de darle salida.
El procedimiento se puede resumir en el siguiente diagrama.</p>


__TOC__


==¿Qué nos hace falta?==
Para implementar este ''workflow'', primero debemos identificar los ítems de información y, a continuación, definirlos en el sistema. Analizando, vemos que necesitamos cuatro objetos diferentes:
*'''Entrada''', para las tareas de Registrar entrada de documentación y Comprobar documentación. Este tipo ya lo tenemos definido.
*'''Requerimiento''', para las tareas de Elaborar requerimiento y Firmar requerimiento. 
*'''Resolución positiva''' y '''Resolución negativa''', para las tareas de Elaborar resolución positiva/negativa, Firmar propuesta de resolución, Firmar resolución y Registrar salida de documentación. 

Además, todos los documentos relacionados con una solicitud deben almacenarse en alguna parte. Para ello, definiremos también el tipo '''Expediente de beca'''. 

Por último, debemos definir dos nuevas habitaciones, donde se enviarán sus tareas específicas: la '''Oficina de Ayudas y Subvenciones''' y la '''Oficina de dirección'''. 

==Definir los escritos==

Definimos el requerimiento de documentación con dos componentes: una componente [[Escritos|escrito]], para la plantilla del documento, y una componente formulario, para los campos firma.

 {{PR|tipo}} [Requerimiento de documentación] {{PR|es}} {{RE|contenedor}}
     [Escrito] {{PR|es}} {{T|documento}}
         -{{AT|plantilla_documento}} = {{STR|"Req 001.rtf"}};
     {{PR|fin}}
 
     [Datos generales] {{PR|es}} {{T|formulario}}
         [Firma del escrito] {{PR|es}} {{T|firma}}
     {{PR|fin}}
 {{PR|fin}}

Hacemos lo mismo para las resoluciones. En este caso, como las resoluciones la firman dos personas, debemos incluir dos campos firma, uno para la propuesta y otro para la resolución. 

 {{PR|tipo}} [Resolución positiva] {{PR|es}} {{RE|contenedor}}
     [Escrito] {{PR|es}} {{T|documento}}
         -{{AT|plantilla_documento}} = {{STR|"Res 001.rtf"}};
     {{PR|fin}}
 
     [Datos generales] {{PR|es}} {{T|formulario}}
         [Firma de la propuesta] {{PR|es}} {{T|firma}}
         [Firma de la resolución] {{PR|es}} {{T|firma}}
     {{PR|fin}}
 {{PR|fin}}

 {{PR|tipo}} [Resolución negativa] {{PR|es}} {{RE|contenedor}}
     [Escrito] {{PR|es}} {{T|documento}}
         -{{AT|plantilla_documento}} = {{STR|"Res 002.rtf"}};
     {{PR|fin}}
 
     [Datos generales] {{PR|es}} {{T|formulario}}
         [Firma de la propuesta] {{PR|es}} {{T|firma}}
         [Firma de la resolución] {{PR|es}} {{T|firma}}
     {{PR|fin}}
 {{PR|fin}}

==Definir el Expediente de beca==
<p>Cada vez que se inicie un trámite de beca, abriremos un expediente en el que se recogerá toda la documentación relacionada con el trámite. Este expediente tendrá un número (asignado automáticamente), que identificará el trámite, y una fecha de alta, que indicará la fecha en la que se inició el trámite. Asimismo, tendrá un vínculo a la '''Entrada''' que dio lugar al trámite.</p>
<p>Crearemos el expediente con dos componentes: una componente para el formulario de datos y otra para la colección en la que se almacenarán todos los documentos.</p>
 {{PR|tipo}} [Expediente de beca] {{PR|es}} {{RE|contenedor}}
     [Datos generales] {{PR|es}} {{T|formulario}}
         [Nº de expediente] {{PR|es}} {{T|timbre}}
             -{{AT|certificado.valor}} = [&Valor_secuencia];
             -{{AT|certificado.secuencia.nombre}} = {{STR|"STR$EXPEDIENTE"}}; 
             -{{AT|certificado.secuencia.longitud}} = 5; 
         [Fecha de alta] {{PR|es}} {{T|fecha}}
         [Solicitud] {{PR|es}} {{T|vinculo}}
             -{{AT|vinculo.definicion}} = [Entrada];
             -{{AT|vinculo.etiqueta}} = [Datos generales].[Número] + {{STR|" ("}} 
                                        + [Datos generales].[Remitente]->[Datos generales].[Nombre/Razón social] 
                                        + {{STR|" "}} +  [Datos generales].[Remitente]->[Datos generales].[Apellidos] 
                                        + {{STR|")"}};
             -{{AT|vinculo.valores}} = $matriz([Libro de entrada].[Contenido]);
     {{PR|fin}}
 
     [Documentos] {{PR|es}} {{T|coleccion}}
         -{{AT|nombre_tabla}} = {{STR|"TC$EXPEDIENTE_BECA"}};
 
         {{PR|contiene}} [Requerimiento de documentación]
         {{PR|contiene}} [Resolución positiva]
         {{PR|contiene}} [Resolución negativa]
 
         {{PR|columna}} [Nombre]
             -{{AT|columna_bd.nombre}} = {{STR|"DOCUMENTO"}};
             -{{AT|origen}} = [&Nombre];
     {{PR|fin}}
 {{PR|fin}}

Por último, necesitamos almacenar los expedientes en alguna parte. Para ello, crearemos un objeto del sistema en el que almacenarlos. 

 [Expedientes de beca] {{PR|es}} {{RE|contenedor}}
     [Contenido] {{PR|es}} {{T|coleccion}}
         -{{AT|nombre_tabla}} = {{STR|"TC$EXPEDIENTES"}};
 
         {{PR|contiene}} [Expediente de beca]
 
         {{PR|columna}} [Nº de expediente]
             -{{AT|columna_bd.nombre}} = {{STR|"NUMERO"}};
             -{{AT|origen}} = [Datos generales].[Nº de expediente];
         {{PR|columna}} [Fecha de alta]
             -{{AT|columna_bd.nombre}} = {{STR|"FECHA_ALTA"}};
             -{{AT|origen}} = [Datos generales].[Fecha de alta];
     {{PR|fin}}
 {{PR|fin}}

==Definir las oficinas==
<p>Tan sólo nos queda definir las oficinas y ubicar los recursos necesarios en cada una. En nuestro caso, se reduce sólo al estante de expedientes, ya que es el único recurso común a las tres oficinas.</p>

 [Oficina de Ayudas y Subvenciones] {{PR|es}} {{RE|habitacion}}
     -{{AT|publico}} = falso;
 
     {{PR|ubicado}} [Expedientes de beca] 
         -{{AT|lugar}} = {{STR|"Estantes"}};
 {{PR|fin}}
 
 [Oficina de la dirección] {{PR|es}} {{RE|habitacion}}
     -{{AT|publico}} = falso;
 
     {{PR|ubicado}} [Expedientes de beca] 
         -{{AT|lugar}} = {{STR|"Estantes"}};
 {{PR|fin}}

==¿Cómo funciona el motor de ''workflow''?==
<p>Hasta ahora nos hemos centrado en definir los ítems de información que nos iban a hacer falta para llevar a cabo el procedimiento de concesión de beca. En los próximos apartados veremos cómo implementar el flujo de trabajo, pero primero explicaremos cómo funciona el motor de ''workflow'' de la plataforma.</p>
<p>En egeasy, los procedimientos administrativos se definen en dos pasos. En primer lugar, debe definirse el flujo de tareas. Esta definición se hace en un fichero con extensión nmt. Los ficheros nmt son ficheros de texto plano que se crean en la carpeta Data del proyecto. Una vez definido el flujo de tareas, procederemos a definir los atributos de cada tarea: ítem de trabajo, código que se ejecuta al terminar la tareas, ... Estas definiciones se realizan en ficheros ndf, como hemos hecho con el resto de los recursos.</p>
<p>Comenzaremos con el flujo de tareas. Lo primero que debemos hacer es crear, en la carpeta Data, el fichero '''concesion_beca.nmt'''. A continuación, abrimos el fichero con el editplus.</p>
<p>Los ficheros nmt se componen de '''métodos'''. Por hacer un símil, un método sería equivalente a un procedimiento de PASCAL. Cada método lanza tareas, invoca a otros métodos y ejecuta sentencias en ODL. Adicionalmente, puede tener parámetros de E/S y variables locales.</p>
<p>Aquí tenemos un ejemplo.</p>
 {{PR|metodo}} RegistrarEntrada();
     {{PR|var}}
         TareaRegistro: {{RE|tarea}};
 {{PR|inicio}}
     TareaRegistro = {{T|$lanzar}}({{STR|"Registrar entrada"}});
     TareaRegistro.[&Destino]->[Datos generales].[Asunto] = {{STR|"Esto es una prueba"}};
     $guardar(TareaRegistro.[&Destino]);
 {{PR|fin}}
<p>En este segmento de código hemos definido el método RegistrarEntrada. A continuación, hemos definido la variable TareaRegistro de tipo {{RE|tarea}}. Después hemos definido la secuencia de tareas.</p> 
<p>Cuando comienza la ejecución de un método, el motor de ''workflow'' posiciona el cursor en la primera línea del método que está justo después de '''inicio'''. Comienza a ejecutar línea por línea hasta que alguna de las sentencias lanza una tarea. Entonces, el sistema crea una nueva tarea, le asigna un ítem de trabajo y establece el estado de la tarea a '''pendiente'''. La ejecución del método queda detenida hasta que se finalice la tarea. En nuestro ejemplo, al iniciarse la ejecución del método se lanzaría la tarea '''Registrar entrada'''.</p>
<p>Cualquier usuario con los permisos suficientes puede ir a la bandeja de '''Tareas disponibles''' y '''comenzar la tarea'''. Cuando lo hace, la plataforma abre el ítem de trabajo asignado y cambia el estado de la tarea a '''realizándose'''.</p>
<p>Cuando el usuario finaliza la tarea, el sistema cambia el estado a '''terminada''' y retoma la ejecución del método que invocó a la tarea. En nuestro ejemplo, asignaría a la variable TareaRegistro la tarea que se acaba de terminar. A continuación ejecutaría las siguientes líneas de código, que modifican el ítem de trabajo de la tarea para después almacenarlo.</p>
<p>Un método termina de ejecutarse cuando el cursor alcanza la palabra fin.</p>

===¿Cómo comienza a ejecutarse un método?===
<p>Todo proceso tiene un punto de entrada que lanza a ejecutar la primera línea del primer método. Este punto de entrada es un tipo de tarea que se define como raíz en los ficheros de definiciones ndf.</p>Para cada proceso que exista en nuestro sistema de información, tendremos que definir una tarea, llamémosla ''inicializadora'' del proceso.<p>Veamos a continuación la definición de esta tarea, que se corresponde con el proceso '''Solicitud de beca''':</p>

 {{PR|tipo}} [Solicitud de beca] {{PR|es}} {{RE|tarea}}
     -{{AT|descripcion}} = {{STR|"Proceso que se encarga de realizar la resolución de una solicitud de beca"}};
     -{{AT|fuente.definicion}} = [Registro de entrada y salida];
     -{{AT|destino.definicion}} = [Expediente de beca];
     -{{AT|destino.valor}} = $crear([Expedientes de beca].[Contenido]);
     -{{AT|Al_Comenzar.Nombre}} = {{STR|"Metodos\concesion_beca.RegistrarEntrada"}};
     -{{AT|es_raiz}} = verdadero;
 {{PR|fin}}

<p>La forma de indicar que la tarea '''Solicitud de beca''' inicia un proceso de nuestro sistema de información es mediante el atributo lógico '''es_raiz'''. Dicho atributo tiene asignado por defecto el valor falso, de forma que poniéndolo a verdadero, conseguiremos que dicha tarea inicie un proceso que será lanzado por un usuario.</p>Ahora bien, ¿sobre qué [[Contenedores|contenedor]] queremos que se lance la tarea?<p>Siempre que lanzamos una tarea, es necesario indicar sobre qué contenedor podremos lanzarla. Para ello, ODL proporciona un atributo llamado '''fuente.definicion'''. En el caso de una tarea raíz, se indicarán aquellas habitaciones a las que habrá que acceder para poder iniciar la tarea raíz. Por eso hemos indicado una habitacion en vez de un contenedor en la definición de Solicitud de beca.</p>Esto significa que el usuario podrá lanzar la tarea Solicitud de beca una vez haya accedido a la habitación Registro de entrada y salida. En posteriores definiciones de tareas, veremos que especificaremos un contenedor en vez de una habitación en el atributo fuente.definicion.<p>El método a ejecutar una vez se lance la tarea, lo indicaremos en el atributo '''Al_Comenzar.Nombre''', que como vemos, tiene asignado el método creado anteriormente RegistrarEntrada. La manera de indicar el método es añadiendo la ruta del fichero donde está incluído a partir de la carpeta '''Data''' del modelo, seguido de un punto y el nombre del método.</p>Por último, indicaremos en el atributo '''destino.definicion''' lo que se conoce como ''maintarget'' de un proceso, es decir, aquel contenedor que se asociará al proceso durante su ejecución.<p>El ''maintarget'' de Solicitud de beca será un contenedor de tipo '''Expediente de beca'''. ¿Por qué? Porque las tareas que se lancen dentro de este proceso y la información que se genere se almacenará en un Expediente de beca.</p>Además, no sólo queremos indicar el ''maintarget'' del proceso Solicitud de beca, sino que también queremos crear el expediente una vez se inicie el proceso. Para ello, utilizaremos la función '''$crear''' definida en la librería de funciones de ODL, que nos permite crear un objeto, indicándole la colección donde se va a almacenar. El tipo de objeto será el definido en destino.definicion. El objeto devuelto por $crear se asignará al atributo '''destino.valor'''.

===Interpretación del diagrama de flujo===
Antes de meternos de lleno a desarrollar el ''workflow'', vamos a estudiar el diagrama de flujo de información de concesión de becas facilitado al comienzo de este artículo.<p>Es recomendable que abramos el diagrama ampliado en una pestaña nueva del navegador y lo mantengamos hasta el final de este artículo, de manera que podamos ir fijándonos en él a medida que vamos avanzando en el desarrollo del ''workflow''.</p><p>Fijándonos en el diagrama, vemos que el flujo de trabajo está dividido en tres secciones, donde cada una de ellas equivale a una oficina de la organización. Dentro de cada oficina existen una serie de estados, que equivalen a las diferentes tareas que se pueden lanzar. Por tanto, habrá que implementar una tarea por cada estado que aparece en el diagrama.</p>Si las tareas equivalen a los estados, el flujo de trabajo equivaldría a las líneas de transición que nos permiten cambiar de estado. En nuestro método RegistrarEntrada tendremos que implementar este flujo de trabajo.<p>Podemos ver que para lanzar ciertas tareas, habrá que evaluar una condición. Por ejemplo, para lanzar la tarea ComprobarDocumentacion será necesario evaluar si la documentación necesaria está completa. De no ser así, se lanzaría la tarea ElaborarRequerimiento.</p>Por tanto, en la implementación de nuestro método tendremos que plasmar el camino de datos que observamos en el diagrama.<p>Además, el diagrama nos indica a qué oficina debe acceder un usuario para realizar cada una de las tareas, teniendolo en cuenta a la hora de definir los roles.</p>

===Evolucionando el ''workflow''===
<p>Antes de meternos de lleno en la elaboración del ''workflow'', hagamos un resumen de aquellos ficheros y nuevas definiciones que hemos creado.</p>Por un lado, para poder desarrollar una concesión de beca, hemos definido un expediente de beca, un registro de expedientes de beca, un requerimiento de documentación y una resolución positiva y negativa de la concesión de una beca con la elaboración de sus respectivos documentos. Todas ellas son definiciones de tipo {{RE|contenedor}}, y serán los ítems con los que trabajaremos a lo largo de todo el flujo de información. Además, hemos definido una Oficina de Ayudas y Subvenciones y una Oficina de Dirección. Todas estas definiciones las hemos realizado en el fichero '''Main.ndf''' de la carpeta #Source.<p>En esta misma carpeta, se encuentra el fichero '''tareas.ndf''' donde ya hemos definido la tarea raíz Solicitud de beca y donde vamos a definir el resto de tareas.</p>Por último, en la carpeta Data\Metodos hemos creado el fichero '''concecion_beca.nmt''' donde hemos incluído un ejemplo del método RegistroEntrada.<p>Una vez hecho este resumen, ahora sí que vamos a desarrollar nuestro proceso '''Solicitud de beca'''. Mostraremos paso a paso el código a introducir siguiendo el diagrama de flujo de información. Iremos alternando la implementación del método y de las tareas según lo vayamos necesitando.</p>
<br/>
Cuando se produce una '''Entrada''' para solicitar una beca, el sistema de información generará un '''Expediente de beca''' único y se registrará la entrada que además estará asociada al expediente mediante el campo vínculo '''[Solicitud]'''. A partir de este momento, toda la información que genere el proceso tendrá asociado un Expediente de beca, por ello el ''maintarget'' del proceso Solicitud de beca es el expediente creado.<p>Por tanto, una vez lanzada la tarea raíz y se empeciece a ejecutar el método RegistrarEntrada, habrá que crear un expediente de beca y registrar la entrada recibida lanzando las tareas correspondientes desde el método y definiéndolas:</p>

 {{PR|metodo}} RegistrarEntrada();
     {{PR|var}}
 {{PR|inicio}}
     {{T|$lanzar}}({{STR|"Registrar expediente de beca"}});
     {{T|$lanzar}}({{STR|"Registrar entrada"}});
 {{PR|fin}}

La función '''$lanzar''', lanza una tarea cuyo nombre debemos pasar por parámetro, como vemos en el código. En este caso, no pasamos por parámetro ningún ítem (''target'') a la tarea, ya que será creado por la propia tarea, aunque veremos que en posteriores definiciones sí tendremos que incluir un ''target'' como parámetro de entrada. Además, también es posible indicar la habitación en la cuál un usuario podrá realizar la tarea. En caso de no especificarla, se tomará como habitación la definida en la tarea raíz, que en nuestro caso es '''Registro de entrada y salida'''.<p>Definamos entonces dichas tareas en nuestro fichero ''tareas.ndf'':</p>

 {{PR|tipo}} [Registrar expediente de beca] {{PR|es}} {{RE|tarea}}
     -{{AT|fuente.definicion}} = [Expediente de beca];
     -{{AT|Al_finalizar.Codigo}} = {{STR|"$sellar([&Destino]->[Datos generales].[Nº de expediente]); $guardar([&Destino]); "}};
 {{PR|fin}}

 {{PR|tipo}} [Registrar entrada] {{PR|es}} {{RE|tarea}}
     -{{AT|fuente.definicion}} = [Expediente de beca];
     -{{AT|destino.definicion}} = [Entrada];
     -{{AT|destino.valor}} = $crear([Libro de entrada].[Contenido]);
     -{{AT|Al_finalizar.Codigo}} = {{STR|"$sellar([&Destino]->[Datos generales].[Número]); $guardar([&Destino]); "}};
 {{PR|fin}}

<p>En la tarea '''Registrar expediente de beca''', el atributo {{AT|fuente.definicion}} que hay definido ya lo conocemos. En él indicamos el objeto de referencia de la tarea. En el atributo {{AT|destino.definicion}}, que no aparece, deberíamos indicar el contenedor (''target'', ítem) con el que va a trabajar la tarea, pero este atributo, si no se especifica, asumirá como destino el contenedor definido en fuente.definicion. Equivaldría a poner <code>destino.definicion = [Expediente de beca]</code>.</p>Por tanto, al arrancar esta tarea, se creará un expediente nuevo. El atributo {{AT|Al_finalizar.Codigo}} nos permite invocar un método o directamente asignarle instrucciones en forma de ristra, que se ejecutarán en tiempo de ejecución una vez se finalice la tarea. En nuestro caso, se sellará el campo timbre que existe en el expediente y además se guardará el objeto. Para que entendamos bien las instrucciones empleadas en el atributo Al_finalizar.Codigo, es necesario conocer la propiedad '''[&Destino]''' de una tarea.<p>Esta propiedad permite acceder al ''target'' actual de una tarea, que en el caso de Registrar expediente de beca, es un '''Expediente de beca'''. Una vez accedido al ''target'', podremos acceder a otros componentes que estén definidos en él, como por ejemplo, a un campo timbre incluído en la definición de un formulario, que es exactamente lo que se realiza en nuestro caso. Con la función '''$sellar''', sellamos el campo timbre, y con la función '''$guardar''', guardamos el objeto.</p>Una vez registrado un nuevo expediente, procederemos a registrar la entrada de petición de beca mediante la tarea '''Registrar entrada'''. La diferencia que podemos observar respecto a la tarea anterior es la inclusión de los atributos {{AT|destino.definicion}} y {{AT|destino.valor}}.<p>¿Y por qué ahora sí están incluídos? Esto es debido a que esta tarea no va a registrar un Expediente de beca, sino que registrará una Entrada, aunque el objeto referencia de la tarea sí seguirá siendo el Expediente de beca creado anteriormente.</p>Además, al finalizar la tarea, ejecutaremos el mismo código que la tarea anterior, con la diferencia de que en esta ocasión, la propiedad [&Destino] accederá a un objeto de tipo Entrada, que es el ''target'' de esta tarea. ¿Y el atributo {{AT|destino.valor}}?<p>Como ya explicamos en la definición de la tarea raíz '''Solicitud de beca''', utilizaremos la función '''$crear''' en este atributo, para indicar la colección donde se va a guardar el objeto del tipo definido en el atributo {{AT|destino.definicion}}, es decir, un objeto de tipo Entrada.</p>
<br/>
<p>Una vez realizada esta primera fase, volvemos a fijarnos en el diagrama, y vemos que una vez la Entrada es recibida, registrada, y creado su Expediente de beca, el siguiente paso, sería comprobar la documentación. Para ello, es necesario que la documentación entregada por la persona que realiza la petición de la beca esté completa. En caso de no ser así, se generará un documento de requerimiento, que deberá ser firmado, dando lugar a posibles nuevas entradas en el proceso, pero con un Expediente de beca ya creado. Esto se producirá tantas veces como requerimientos de documentación se puedan dar. Una vez no falte ningún tipo de documentación, se lanzará la tarea '''Comprobar documentación'''.</p>Pero, ¿y cómo podemos saber si en la solicitud de una beca falta documentación?<p>Para ello, hemos modificado la definición del contenedor '''Entrada''', añadiendo simplemente un campo tabla para registrar la documentación y un campo de tipo texto llamado '''[Documentación completa]'''.</p>Veamos primero los cambios introducidos, tanto en el contenedor '''Entrada''' como en el método, para comentarlos posteriormente:

 [Sí o No] {{PR|es}} {{RE|enumerado}}
     {{AT|valores}}
         {{STR|"Sí"}},
         {{STR|"No"}}
 {{PR|fin}}

 {{PR|tipo}} [Entrada] {{PR|es}} {{RE|contenedor}}
     [Datos generales] {{PR|es}} {{T|formulario}}
         ...
         ...
         ...
         [Documentación presentada] {{PR|es}} {{T|tabla}}
             [Documento] {{PR|es}} {{T|texto}}
         {{PR|fin}}
         [Documentación completa] {{PR|es}} {{T|texto}}
             -{{AT|apariencia.desplegable}} = verdadero;
             -{{AT|edicion.seleccion}} = verdadero;
             -{{AT|edicion.valores}} = $matriz([Sí o No]);
     {{PR|fin}}
 {{PR|fin}}

 {{PR|metodo}} RegistrarEntrada();
     {{PR|var}}
         TareaRegistroBeca: tarea;
         TareaRegistroEntrada: tarea;
         ElaborarRequerimiento: tarea;
         ElaborarResolucion: tarea;
         documentacion_incompleta: logico;
 {{PR|inicio}}
     documentacion_incompleta = verdadero;
     TareaRegistroBeca = {{T|$lanzar}}({{STR|"Registrar expediente de beca}}");
     {{PR|mientras}} documentacion_incompleta
         TareaRegistroEntrada = {{T|$lanzar}}({{STR|"Registrar entrada"}});
         TareaRegistroBeca.[&Destino]->[Datos generales].[Solicitud] = TareaRegistroEntrada.[&Destino];
         $guardar(TareaRegistroBeca.[&Destino]);
         {{PR|si}} (TareaRegistroEntrada.[&Destino]->[Datos generales].[Documentación completa] = {{STR|"Sí"}})
             documentacion_incompleta = falso;
         {{PR|sino}}
             ElaborarRequerimiento = {{T|$lanzar}}({{STR|"Elaborar requerimiento"}});
             {{T|$lanzar}}({{STR|"Firmar requerimiento"}}, ElaborarRequerimiento.[&Destino]);
         {{PR|fin}}
     {{PR|fin}}
 {{PR|fin}}

<p>Vemos que en la definición de Entrada hemos incluído los campos que comentamos para comprobar la documentación.</p>También podemos observar que hay una serie de variables declaradas en la implementación de nuestro método, que nos permitirán almacenar en ellas un recurso del mismo tipo que el definido para la variable. La variable lógica '''documentacion_incompleta''', que inicializamos a "verdadero", la utilizaremos para controlar la salida del bucle que se ocupa de los requerimientos de documentación, y como consecuencia, de nuevas entradas. Dicha salida se producirá cuando el campo [Documentación completa] de la Entrada actual tenga valor "Sí", asignándole "falso" a documentacion_incompleta.<p>¿Y cómo consultamos dicho campo?</p>Al lanzar la tarea '''Registrar entrada''', ésta la almacenamos en la variable de tipo tarea '''TareaRegistroEntrada'''. Esto nos va a permitir acceder al ''target'' de la tarea mediante la propiedad [&Destino] en cualquier momento del código, ya que la tarea quedará almacenada en la variable. En este caso, el objeto es de tipo Entrada, por lo que podremos acceder al campo [Documentación completa] y realizar la consulta.<p>Una vez la documentación  esté completa, el usuario modificará el campo [Documentación completa] asignándole el valor "Sí", de manera que saldremos del bucle. En caso contrario, lanzaremos la tarea encargada de elaborar un requerimiento, que a su vez tendrá que ser firmada, lanzando la tarea correspondiente para ficha firma.</p>Respecto a las tareas '''Elaborar requerimiento''' y '''Firmar requerimiento''' es necesario tener en cuenta lo siguiente.<p>Al igual que en el lanzamiento de las demás tareas, la tarea Elaborar requerimiento también es asignada a una variable, en este caso, llamada '''ElaborarRequerimiento'''. A continuación, se lanza la tarea Firmar requerimiento, pero esta vez con un nuevo parámetro. Este parámetro corresponde al ''target'' de la tarea anterior, y lo indicamos como parámetro utilizando la variable ElaborarRequerimiento para acceder a la tarea, junto con la propiedad [&Destino] para acceder a su ''target''. Esto lo realizamos porque la tarea Firmar requerimiento no va a crear ningún ''target'', sino que firmará el campo firma que se encuentra en el objeto '''Requerimiento de documentación''' creado en la tarea anterior. Por tanto, este objeto o ''target'' tendrá que ser pasado como parámetro a la tarea Firmar requerimiento.</p>
<p>Hay dos instrucciones que no hemos comentado aún. Son exactamente las dos instrucciones anteriores a la consulta del campo [Documentación completa].</p>Como ya sabemos, nuestra definición de tipo contenedor Expediente de beca tiene un campo vínculo, que referencia a la última Entrada que se haya almacenado en el expediente. Para que esto suceda, es necesario que después de registrar una nueva entrada se modifique este campo vínculo, para que referencie al último objeto de tipo Entrada. Esto lo conseguimos utilizando dos variables de tipo tarea, una para la tarea Registrar expediente de beca y otra para Registrar entrada. En cada variable almacenamos cada una de las dos tareas, de manera que nos permitan acceder al ''target'' de cada una de ellas. Al campo vínculo '''TareaRegistroBeca.[&Destino]->[Datos generales].[Solicitud]''' le asignaremos el ''target'' de la tarea Registrar entrada, '''TareaRegistroEntrada.[&Destino]'''. Una vez asignada la Entrada al campo vínculo, se guardará el objeto para aplicar los cambios realizados en el objeto.<p>Es necesario realizar estas dos acciones dentro del bucle y antes de realizar la comprobación del campo [Documentación completa] del objeto Entrada, ya que, en caso de no hacerlo, no se estará verificando el campo [Documentación completa] de la nueva Entrada, sino de la anterior, o de ninguna, en caso de que estemos tratando una primera entrada.</p>Una vez analizado el nuevo código introducido en el método, veamos la definición de las nuevas tareas que aparecen; Elaborar requerimiento y Firmar requerimiento:

 {{PR|tipo}} [Elaborar requerimiento] {{PR|es}} {{RE|tarea}}
     -{{AT|fuente.definicion}} = [Expediente de beca];
     -{{AT|destino.definicion}} = [Requerimiento de documentación];
     -{{AT|destino.valor}} = $crear([Documentos]);
 {{PR|fin}}

 {{PR|tipo}} [Firmar requerimiento] {{PR|es}} {{RE|tarea}}
     -{{AT|fuente.definicion}} = [Expediente de beca];
     -{{AT|destino.definicion}} = [Requerimiento de documentación];
     -{{AT|localizacion}} = [Datos generales];
     -{{AT|Al_finalizar.Codigo}} = {{STR|"$firmar([&Destino]->[Datos generales].[Firma del escrito]); $guardar([&Destino]); "}};
 {{PR|fin}}

<p>Cabe comentar un atributo que hasta ahora no hemos tenido que utilizar. Se trata del atributo {{AT|localizacion}}. En él, indicaremos una componente que queramos activar al iniciar la tarea, en principio, para su edición. En este caso, activamos la componente [Datos generales] del contenedor Requerimiento de documentación, que es donde está incluído el campo firma que vamos a editar en esta tarea. En caso de no hacerlo, no podríamos realizar la firma al ejecutar el código <code>{{STR|"$firmar([&Destino]->[Datos generales].[Firma del escrito])</code>.</p>

<p>Una vez hemos analizado ya varias definiciones de tareas, nos damos cuenta que el aspecto más importante a la hora de definir una tarea es tener muy claro el ''target'' con el que va a trabajar la tarea. Es decir, saber si el ''target'' será creado por la propia tarea o si por el contrario, trabajará con un ''target'' ya creado.</p>En caso de crear uno nuevo utilizaremos los atributos destino.definicion y destino.valor para especificar el tipo del objeto y el lugar donde se almacenará. En caso de utilizar uno creado por tareas anteriores, tendremos que incluir el ''target'' de la tarea anterior como parámetro de la nueva tarea. Esto lo conseguimos, como ya hemos visto, utilizando una variable en la cual almacenamos la tarea que nos interese, y con la propiedad [&Destino] referenciamos a su ''target''.

===Finalizando el ''workflow''===
Siguiendo con el flujo de trabajo, pasamos ahora a la siguiente oficina de nuestra organización, '''Servicio de Ayudas y Subvenciones'''.<p>Una vez hemos verificado que la documentación de una solicitud está completa, pasamos a lanzar la tarea '''Comprobar documentación'''. Esta tarea abrirá la última Entrada que referencia el campo vínculo '''[Solicitud]''' de un expediente concreto y analizará la documentación entregada para elaborar una resolución positiva, en caso de cumplir los requisitos, o negativa, en caso de no cumplirlos. El ''target'' de esta tarea, tendrá que ser pasado como parámetro, que al ser la última Entrada registrada, podremos acceder a él utilizando la variable '''TareaRegistroEntrada'''. Pero, hay que tener en cuenta otro aspecto a la hora de lanzar esta tarea.</p>Hasta ahora, no nos hemos preocupado de la oficina en la cual podíamos realizar las tareas. Esto ha sido así debido a que las tareas hasta ahora lanzadas compartían la oficina de la tarea raíz (Registro de entrada y salida), y por tanto, no se especificaba como parámetro al lanzar una tarea. Pero ahora sí es necesario especificarlo, ya que hemos cambiado de oficina. La sintaxis para hacerlo es la siguiente:

 {{T|$lanzar}}({{STR|"nombre"}},target,[oficina])

Veamos el código a añadir en nuestro método y la implementación de la tarea '''Comprobar documentación''':

 {{PR|metodo}} RegistrarEntrada();
     {{PR|var}}
         TareaRegistroBeca: tarea;
         TareaRegistroEntrada: tarea;
         ElaborarRequerimiento: tarea;
         ElaborarResolucion: tarea;
         DocumentacionComprobada: tarea;
         documentacion_incompleta: logico;
 {{PR|inicio}}
     documentacion_incompleta = verdadero;
     TareaRegistroBeca = {{T|$lanzar}}({{STR|"Registrar expediente de beca}}");
     {{PR|mientras}} documentacion_incompleta
         ...
         ...      {{COM|//Bucle}}
         ...
     {{PR|fin}}
     DocumentacionComprobada = {{T|$lanzar}}({{STR|"Comprobar documentación"}},TareaRegistroEntrada.[&Destino],[Oficina de Ayudas y Becas]);
 {{PR|fin}}

 {{PR|tipo}} [Comprobar documentación] {{PR|es}} {{RE|tarea}}
     -{{AT|fuente.definicion}} = [Expediente de beca];
     -{{AT|destino.definicion}} = [Entrada];
 {{PR|fin}}

En este caso, el usuario de la Oficina de Ayudas y Subvenciones analizará la documentación presentada y dejará constancia de dicho análisis especificando si es un caso favorable o desfavorable para la concesión de una beca.<p>Pero, ¿dónde deja constancia?</p>Para ello, hemos definido otro campo de tipo texto en la definición de contenedor Entrada llamado '''[Cumple los requisitos]'''. Este será el campo donde se concretará si un solicitante cumple los requisitos. Veamos el código a incluir en la definición de Entrada:

 {{PR|tipo}} [Entrada] {{PR|es}} {{RE|contenedor}}
     [Datos generales] {{PR|es}} {{T|formulario}}
         ...
         ...
         ...
         [Cumple los requisitos] {{PR|es}} {{T|texto}}
             -{{AT|apariencia.desplegable}} = verdadero;
             -{{AT|edicion.seleccion}} = verdadero;
             -{{AT|edicion.valores}} = $matriz([Sí o No]);
     {{PR|fin}}
 {{PR|fin}}

Siguiendo con el flujo de trabajo del diagrama, las siguientes tareas a lanzar tratarían la elaboración de una resolución de beca, positiva o negativa, en función del valor que contenga el campo [Cumple los requisitos]. Por tanto, habrá que consultar dicho campo para saber cuál de las tareas lanzar:

 {{PR|metodo}} RegistrarEntrada();
     {{PR|var}}
         TareaRegistroBeca: tarea;
         TareaRegistroEntrada: tarea;
         ElaborarRequerimiento: tarea;
         ElaborarResolucion: tarea;
         DocumentacionComprobada: tarea;
         documentacion_incompleta: logico;
 {{PR|inicio}}
     documentacion_incompleta = verdadero;
     TareaRegistroBeca = {{T|$lanzar}}({{STR|"Registrar expediente de beca}}");
     {{PR|mientras}} documentacion_incompleta
         ...
         ...      {{COM|//Bucle}}
         ...
     {{PR|fin}}<br/>
     DocumentacionComprobada = {{T|$lanzar}}({{STR|"Comprobar documentación"}},TareaRegistroEntrada.[&Destino],[Oficina de Ayudas y Becas]);<br/>
     {{PR|si}} (DocumentacionComprobada.[&Destino]->[Datos generales].[Cumple los requisitos] = {{STR|"Sí"}})<br/>	
         ElaborarResolucion = {{T|$lanzar}}({{STR|"Elaborar resolución positiva"}},[Oficina de Ayudas y Subvenciones]);<br/>
     {{PR|sino}}<br/>
         ElaborarResolucion = {{T|$lanzar}}({{STR|"Elaborar resolución negativa"}},[Oficina de Ayudas y Subvenciones]);<br/>
     {{PR|fin}}<br/>
 {{PR|fin}}

Consultamos el campo [Cumple los requisitos] y en función de su valor se lanzará o bien la tarea '''Elaborar resolución positiva''' o '''Elaborar resolución negativa'''.<p>Ambas tareas crearán un ''target'' nuevo, que será o bien un objeto de tipo Resolución positiva o Resolución negativa. Dicho objeto será posteriormente utilizado como ''target'' por las tareas '''Firmar propuesta de resolución''' y '''Firmar resolución''', de forma que tendrán que ser pasados por parámetro en dichas tareas. Una vez realizadas las dos firmas del documento generado, se creará un objeto de tipo Salida que se registrará en el Registro de Entrada y Salida:</p>

 {{PR|tipo}} [Elaborar resolución positiva] {{PR|es}} {{RE|tarea}}
     -{{AT|fuente.definicion}} = [Expediente de beca];
     -{{AT|destino.definicion}} = [Resolución positiva];
     -{{AT|destino.valor}} = $crear([Documentos]);
 {{PR|fin}}

 {{PR|tipo}} [Elaborar resolución negativa] {{PR|es}} {{RE|tarea}}
     -{{AT|fuente.definicion}} = [Expediente de beca];
     -{{AT|destino.definicion}} = [Resolución negativa];
     -{{AT|destino.valor}} = $crear([Documentos]);
 {{PR|fin}}

 {{PR|metodo}} RegistrarEntrada();
     {{PR|var}}
         TareaRegistroBeca: tarea;
         TareaRegistroEntrada: tarea;
         ElaborarRequerimiento: tarea;
         ElaborarResolucion: tarea;
         DocumentacionComprobada: tarea;
         documentacion_incompleta: logico;
 {{PR|inicio}}
     documentacion_incompleta = verdadero;
     TareaRegistroBeca = {{T|$lanzar}}({{STR|"Registrar expediente de beca}}");
     {{PR|mientras}} documentacion_incompleta
         ...
         ...      {{COM|//Bucle}}
         ...
     {{PR|fin}}<br/>
     DocumentacionComprobada = {{T|$lanzar}}({{STR|"Comprobar documentación"}},TareaRegistroEntrada.[&Destino],[Oficina de Ayudas y Becas]);<br/>
     {{PR|si}} (DocumentacionComprobada.[&Destino]->[Datos generales].[Cumple los requisitos] = {{STR|"Sí"}})<br/>
         ElaborarResolucion = {{T|$lanzar}}({{STR|"Elaborar resolución positiva"}},[Oficina de Ayudas y Subvenciones]);<br/>
     {{PR|sino}}<br/>
         ElaborarResolucion = {{T|$lanzar}}({{STR|"Elaborar resolución negativa"}},[Oficina de Ayudas y Subvenciones]);<br/>
     {{PR|fin}}<br/>
     {{T|$lanzar}}({{STR|"Firmar propuesta de resolución"}},ElaborarResolucion.[&Destino],[Oficina de Ayudas y Subvenciones]);<br/>
     {{T|$lanzar}}({{STR|"Firmar resolución"}},ElaborarResolucion.[&Destino],[Oficina de la dirección]);<br/>
     {{T|$lanzar}}({{STR|"Registrar salida de documentación"}});<br/>
 {{PR|fin}}

 {{PR|tipo}} [Firmar propuesta de resolución] {{PR|es}} {{RE|tarea}}
     -{{AT|fuente.definicion}} = [Expediente de beca];
     -{{AT|localizacion}} = [Datos generales];
     -{{AT|Al_finalizar.Codigo}} = {{STR|"$firmar([&Destino]->[Datos generales].[Firma de la propuesta]); $guardar([&Destino]); "}};
 {{PR|fin}}

 {{PR|tipo}} [Firmar resolución] {{PR|es}} {{RE|tarea}}
     -{{AT|fuente.definicion}} = [Expediente de beca];
     -{{AT|localizacion}} = [Datos generales];
     -{{AT|Al_finalizar.Codigo}} = {{STR|"$firmar([&Destino]->[Datos generales].[Firma de la resolución]); $guardar([&Destino]); "}};
 {{PR|fin}}

 {{PR|tipo}} [Registrar salida de documentación] {{PR|es}} {{RE|tarea}}
     -{{AT|fuente.definicion}} = [Libro de salida];
     -{{AT|destino.definicion}} = [Salida];
     -{{AT|destino.valor}} = $crear([Contenido]);	
 {{PR|fin}}

==Crear nuevos perfiles de usuario==
<p>Una vez tenemos implementado nuestro ''workflow'', necesitamos definir nuevos roles puesto que los que teníamos definidos anteriormente han quedado desfasados.</p><p>Definiremos un tipo de rol por cada oficina de nuestra organización:</p>

 {{PR|tipo}} [Permisos comunes] {{PR|es}} {{RE|rol}}
     {{PR|accede}} [Libro de entrada]: abrir;
     {{PR|accede}} [Libro de salida]: abrir;
     {{PR|accede}} [Fichero de terceros]: abrir;
     {{PR|accede}} [Registro de documentación]: abrir;
     {{PR|accede}} [Expedientes de beca]: abrir;
     {{PR|accede}} [Fichero de trabajadores]: abrir;
     {{PR|accede}} [Oficina de recursos comunes]: entrar;
     {{PR|accede}} [Registro de entrada y salida]: entrar;
 {{PR|fin}}

 {{PR|tipo}} [Usuario Oficina del Registro] {{PR|es}} [Permisos comunes]
     {{PR|accede}} [Entrada]: crear;
     {{PR|accede}} [Expediente de beca]: crear;
     {{PR|accede}} [Salida]: crear;
     {{PR|accede}} [Tercero]: crear;
     {{PR|accede}} [Trabajador]: crear;
     {{PR|accede}} [Requerimiento de documentación]: crear;
     realiza [Registrar entrada]
     realiza [Elaborar requerimiento]
     realiza [Firmar requerimiento]
     realiza [Registrar salida de documentación]
     {{T|firma}} [Requerimiento de documentación]: [Datos generales].[Firma del escrito];
 {{PR|fin}}

 {{PR|tipo}} [Usuario Oficina de Servicio de Ayudas y Subvenciones] {{PR|es}} [Permisos comunes]
     {{PR|accede}} [Entrada]: modificar;
     {{PR|accede}} [Expediente de beca]: abrir;
     {{PR|accede}} [Tercero]: abrir;
     {{PR|accede}} [Trabajador]: abrir;
     {{PR|accede}} [Resolución positiva]: modificar;
     {{PR|accede}} [Resolución negativa]: modificar;
     {{PR|accede}} [Oficina de Ayudas y Becas]: entrar;
     realiza [Comprobar documentación]
     realiza [Elaborar resolución positiva]
     realiza [Elaborar resolución negativa]
     realiza [Firmar propuesta de resolución]
     {{T|firma}} [Resolución positiva]: [Datos generales].[Firma de la propuesta];
     {{T|firma}} [Resolución negativa]: [Datos generales].[Firma de la propuesta];
 {{PR|fin}}

 {{PR|tipo}} [Usuario Oficina de la Dirección] {{PR|es}} {{RE|rol}}
     {{PR|accede}} [Resolución positiva]: modificar;
     {{PR|accede}} [Resolución negativa]: modificar;
     {{PR|accede}} [Oficina de la Dirección]: entrar;
     realiza [Firmar resolución]
     {{T|firma}} [Resolución positiva]: [Datos generales].[Firma de la resolución];
     {{T|firma}} [Resolución negativa]: [Datos generales].[Firma de la resolución];
 {{PR|fin}}

<p>Una vez definidos, probaremos el proceso creado utilizando el egExplorer. Pero para ello, tendremos que crear los usuarios correspondientes para poder acceder al centro. Esto lo haremos mediante la herramienta egAdmin, cuyos pasos podemos seguir en el siguiente [[Cómo_instalar_un_centro_desde_cero#Creación_de_usuarios_en_un_centro|tutorial]].</p><p>Cuando tengamos los usuarios creados, sería interesante crear un proceso '''Solicitud de beca''' e ir lanzando sus correspondientes tareas. En el momento que sea necesario cambiar de usuario para que una tarea pueda ser lanzada, cerraremos el egExplorer y accederemos nuevamente a él pero esta vez con un usuario que nos permita lanzar la siguiente tarea.</p><p>En caso de necesitar documentación sobre los roles, podemos acceder a la [[Tarea F: Abriendo el registro al resto de las oficinas|tarea F]] realizada anteriormente.

==Siguiente tarea==
:*[[Tarea_J:_Importar_la_base_de_datos_de_terceros_de_otra_aplicación|Tarea J: Importar la base de datos de terceros de otra aplicación]]

==Véase también==
:*[[Tarea_A:_Libros_y_registro_de_entrada_y_salida|Tarea A: Libros y registro de entrada y salida]]
:*[[Tarea_B:_Mejorando_la_numeración_del_registro|Tarea B: Mejorando la numeración del registro]]
:*[[Tarea_C:_Evolucionando_la_arquitectura_del_registro|Tarea C: Evolucionando la introducción de datos]]
:*[[Tarea_D:_Validar_la_introducción_de_datos|Tarea D: Validar la introducción de datos]]
:*[[Tarea_E:_Utilizar_el_registro_como_un_almacén_de_documentación|Tarea E: Utilizar el registro como un almacén de documentación]]
:*[[Tarea_F:_Abriendo_el_registro_al_resto_de_las_oficinas|Tarea F: Abriendo el registro al resto de las oficinas]]
:*[[Tarea_G:_Evitando_la_replicación_de_código|Tarea G: Evitando la replicación de código]]
:*[[Tarea_H:_Emitir_certificados_de_documentación|Tarea H: Emitir certificados de documentación]]