BEA Aqualogic BPM 5.7 (Fuego)

Comunicando con Base de Datos con PBL (Process Business Language)

Para ejecutar comandos SQL en Aqualogic BPM 5.7 hay que seguir los siguientes pasos:

Primer paso

Se debe crear nuevo "External Resource", haciendo click derecho en el directorio del proyecto "External Resources", del tipo "SQL Database". Los campos se deben completar con la información de la base de datos que queremos consultar y con un nombre significativo.

Segundo paso

Se debe crear un nuevo "BPM Object", haciendo click derecho sobre el modulo deseado en el directorio de "Catalog", y luego crear un método en nuestro objeto, haciendo click derecho sobre el objeto y seleccionando la opción "New Method". Ahora se debe editar el nuevo método, expandiendo el objeto bpm y haciendo doble click sobre el nombre del método creado. Ahora podemos editarlo e incluir el código necesario para comunicarnos con la BD a través de una clase propia de Fuego, un ejemplo de implementación puede ser el siguiente:

String queryAEjecutar ="SELECT campo1, campo2, campo3 FROM nombreTabla WHERE nombreColumna in (?,?)";

String nombreDeLaBDCreada = "NombreBD";

String[] arrayDeParametros = {"valor1", "valor2"};

Iterator <Any[Any]> iterator = DynamicSQL.executeQuery(sentence : queryAEjecutar, implname : nombreDeLaBDCreada, inParameters : arrayDeParametros);

Como se puede observar, el resultado de realizar la consulta va a ser un iterador, que luego puede ser recorrido con un "foreach".

foreach (e in iterator) {


  logMessage("campo1: "+e["campo1"], severity : INFO);

  logMessage("campo2: "+e["campo2"], severity : INFO);

  logMessage("campo3: "+e["campo3"], severity : INFO);

  logMessage("nombreColumna: "+e["nombreColumna"], severity : INFO);

}

Versionando con CVS

El producto Aqualogic BPM 5.7 incluye un cliente de CVS que permite agregar, remover, actualizar en un repositorio CVS.

Configurar el cliente CVS

Levantar el Studio BPM.
File -> Preference ->Default Version Control
- Version Control Manger: CVS
- Host: host del servidor CVS
- User Name: usuario del CVS
- User Password: password del usuario CVS
- path: ruta dentro del repositorio donde se guardará el proyecto.

Subir el proyecto al CVS

Levantar el Studio BPM.
Abrir el proyecto a versionar.
File -> Project Preference -> Project Version Control.
- Version Control Manager: CVS (nos carga la información ingresada en el punto anterior).
File -> VCS -> Store project in repository
- Path: directorio en el que se creará el proyecto en el repositorio.
- Si es la primera vez que se sube un proyecto de Aqualogic BPM, pedirá que se ingrese la ruta del directorio donde se creará el "common catalog"
  - Common catalog: Es un catalogo de componente, el cual puede ser compartido por otros proyectos de Aqualogic BPM.

En el repositorio quedarán creados 2 directorios, el del proyecto y el del common catalog, ademas se crearán 2 alias en el CVS que apuntan al proyecto y al common catalog.

Obtener el proyecto del CVS

Levantar el Studio BPM.
File -> Project Preference -> Project Version Control.
File -> Import -> Project -> from Repository.
- Version Control Manager: CVS
- En la siguiente pantalla, seleccionar el proyecto del repositorio.

Trabajar con proyectos versionados

Aqualogic BPM 5.7, posee una política restrictiva de edición para los proyecto versionados. La política, consiste en que todo el proyecto se encuentra en modo lectura y solo un usuario puede editar un determinado archivo versionado (Ej.: un proceso).

Editar un procesos

Seleccionar el proceso a editar.
Menú contextual -> VCS -> edit.

Esto habilita al usuario a modificar el proceso. En caso de que exitiera otro usuario modificando el proceso nos aparecerá un mensaje de error.

Grabar los cambios realizados en un proceso

Seleccionar el proceso que se esta editando.
Menú contextual -> VCS -> commit.

Este paso es importante, debido a que si se libera la edición del proceso sin realizar el commit se perderán los cambios.

Liberar la edición del proceso

Seleccionar el proceso que se esta editando.
Menú contextual -> VCS -> unedit.

Pasaje de Parametros

Para pasar parámetros al proceso desde una actividad de creación (aquellas que dan inicio al proceso) que tenga asociada un ScreenFlow, hay que seguir los siguientes pasos.

El primer paso es decirle al proceso que va a recibir parametros de la siguiente manera:

Doble click en la tarea "begin" y luego en "Argument Mapping"

Click en el botón que parece una flecha violeta hacia abajo y ahí agregamos el nombre del parametro que va a recibir. Es recomendable utilizar nombres descriptivos ya que sino se puede volver bastante confuso.

Ahora lo único que falta es mapear el parámetro a una variable del proceso (puede ser creada en la misma pantalla haciendo click sobre el botón que está al lado del de crear parametros)

El segundo paso es realizar un proceso similar al primer paso, con la diferencia que debe hacerce en la tarea "end" del ScreenFlow asociado a la actividad de creación.

El tercer paso es mapear las salidas del ScreenFlow con las Entradas del proceso de la siguiente manera:

Doble click en la actividad que tiene asociada el ScreenFlow, luego en "Argument Mapping" y luego en la barra de la izquiera seleccionar "NombreDelScreenFlow Out"

Luego solo basta con mapear los argumentos, seleccionando los nombres

Incluir un jar y utilizarlo

Una vez que tenemos creado nuestro proyecto BPM podemos llegar a necesitar utilizar ciertas clases de java, tanto para modelar entidades como para invocar servicios externos a nuestro proyecto.

En el caso que necesitemos incluír alguna librería al proyecto BPM los pasos a realizar son los siguientes:

En "Recursos externos" hacer botón derecho y seleccionar la opción "Nuevo recurso externo".
Seleccionar un nombre y en tipo seleccionar "Biblioteca de clase Java".
Le damos clic al botón "Agregar" y buscamos el jar correspondiente que vamos a querer incluír.
Aceptar.

Finalizado estos pasos vamos a ver que se agregó a "Recursos externos" la librería que acabamos de incluir. Lo siguiente va a ser crear un módulo desde el cual invocar a las clases de nuestro jar. Para esto tenemos que hacer lo siguiente:

En "Catálogo" hacemos botón derecho y seleccionamos la opción "Crear módulo".
Le ponemos un nombre y le damos Aceptar.
Realizado esto, veremos que se agregó un módulo al Catálogo. Lo que tenemos que hacer ahora es indicarle a ese módulo que contenga la configuración de nuestro jar. Para esto hacemos clic derecho sobre el módulo > Componente de catálogo > Java.
Seleccionamos la opción "Usar una configuración existente" (está marcada por defecto) y en el combo seleccionamos nuestro recurso externo que agregamos antes.
Luego, seleccionaremos las clases Java que quiero incluír en mi módulo.
Se hará la carga de clases automáticamente.
Finalizado esto deberíamos ver dentro de "Catálogo" nuestro módulo nuevo y al amplicar su contenido ver el árbol de las clases que incluímos en él.

Para poder usar estas clases que incluímos, dentro de una actividad se podrán crear instancias de esta forma:

ClaseDeMiBiblioteca instancia = new ClaseDeMiBiblioteca();

e invocar a sus métodos de esta forma:

ObjetoRespuesta respuesta = (ObjetoRespuesta) instancia.metodo(arg1 : parametroAEnviar);

Tratamiento de excepciones de servicios externos

Puede suceder que, al momento de invocar algún servicio externo a nuestro proyecto de BPM, este retorne como respuesta una excepción. Para poder darle un comportamiento a nuestro proceso en BPM se puede utilizar una transición del tipo "Excepción" entre dos actividades.

Para dar un ejemplo concreto vamos a imaginarnos 2 actividades a las que llamaremos "Inicio" y "Comportamiento correcto". La actividad "Inicio" invocará a un servicio, y si sale todo bien, se pasará luego a la actividad "Comportamiento correcto".

Ahora, puede suceder que cuando "Inicio" invoca al servicio, éste devuelva una Excepción. ¿Qué hacemos en ese caso? Creamos una actividad (en nuestro ejemplo es "Comportamiento excepción"), la cual nuestro sistema ejecutará en caso de que el servicio falle, y le asociamos una transición entre "Inicio" y esta nueva actividad de esta forma:

Para crear dicha transición, debemos crear la actividad a la cual asociarla, dale doble clic y luego seleccionar como tipo de transición aquella que dice "Excepción". Para indicarle para qué tipo de Excepción queremos que se siga dicho flujo, en "Nombre de excepción" deberemos cargar la clase con la excepción que puede llegar.

Si queremos obtener el mensaje de la excepción, podemos utilizar la variable predefinida por BPM lastException en la cual se guarda la ultima excepción ocurrida en la instancia.

Creación de Instancias mediante PBL

Para crear instancias de procesos mediante PBL se utiliza el siguiente código: logMessage("DOS_IDEAS: Creando la instancia ConsumidorProceso", severity : Severity.DEBUG);

String mensaje = "Este es un mensaje creado por el productor a las " + 'now'; ProcessInstance.create(processId : ProcessInstance.organization + "/" + ProcessInstance.organizationalUnit + "/ConsumidorProceso",


                      arguments : { "mensaje_InArgument" : mensaje }, argumentsSetName : "BeginIn");

Donde:

processId es el identificador (no el nombre) del proceso que queremos crear, en nuestro caso vamos a crear el proceso "ConsumidorProceso".
arguments es el array de argumentos de entrada que se definio en el proceso.

En el siguiente link podemos descargarnos un ejemplo del svn: Crear Instancia mediante PBL

Manipulación de Instancias mediante PAPI

Aqualogic BPM 5.7, provee una API para trabajar con el FDI. Esta API se la conoce como PAPI. Una de las cosas que nos permite realizar es obtener una instancia de BPM y manipular dicha instancia. En el siguiente link podemos descargarnos un ejemplo del svn: Manipular instancia por FDI.

A continuación tenemos un ejemplo de como abortar una instancia: logMessage("DOS_IDEAS: Cerrando instancia con nombre [" + identificador + "]", severity : Severity.DEBUG);

ProcessService processService = ProcessService(); try {


   processService.connectTo(url : Fuego.Server.directoryURL, user : "tester", password : "tester");

   Instance[] instances = {  };
   InstanceFilter instanciaFilter = InstanceFilter();
   instanciaFilter.create(processService : processService);

   SearchScope searchScope = SearchScope(participantScope : ParticipantScope.ALL, 
                                         statusScope : StatusScope.ONLY_INPROCESS);

instanciaFilter.searchScope = searchScope;

   instanciaFilter.addAttributeTo(variable : "identificador", comparator : Comparison.IS, 
                                  value : unaVariable);


    

   instances = processService.getInstancesByFilter(filter : instanciaFilter);

   foreach (unaInstancia in instances) {
       logMessage("DOS_IDEAS: Cerrando: " + unaInstancia, severity : Severity.DEBUG);

       unaInstancia.abort();

       logMessage("DOS_IDEAS: Instancia cerrada exitosamente", severity : Severity.DEBUG);
   }

}
catch (Java.Lang.Exception ex) {

   logMessage("DOS_IDEAS: Error al abortar instancia [" + identificador + "]: " + ex.message, severity : Severity.DEBUG);

}
finally {

   processService.disconnectFrom();

}

Creamos la conexión al FDI

Se debe proveer un usuario y password existente en la aplicación y que tenga los permisos para poder manipular la instancia. Si el usuario no posee permisos para manipular la instancia, al realizar la busqueda posiblemente no tenga visibilidad de la instancia. En caso de que se este utilizando el Studio, el password es el mismo que el user. ProcessService processService = ProcessService(); processService.connectTo(url : Fuego.Server.directoryURL, user : "tester", password : "tester"); La conexión debe ser finalizada mediante el método disconnectFrom processService.disconnectFrom();

Creamos el filtro

Crea un filtro para buscar las instancias en el FDI.


   InstanceFilter instanciaFilter = InstanceFilter();
   instanciaFilter.create(processService : processService);

Agregamos al filtro, la condición de que obtenga la instancia de todos los participantes y que se encuentren en proceso.


  SearchScope searchScope = SearchScope(participantScope : ParticipantScope.ALL, 
                                         statusScope : StatusScope.ONLY_INPROCESS);

instanciaFilter.searchScope = searchScope; El alcance de los participantes pueden ser:

ALL: todos los participantes.
ALL_IN_ROLE: todas las instancias del rol.
PARTICIPANT: todas las instancias del participante.
PARTICIPANT_ROLE: todas las intancias de los roles del participante.

Agregamos un filtro, para que filtre las instancia cuya variable externa identificador tenga el valor de unaVariable


instanciaFilter.addAttributeTo(variable : "identificador", comparator : Comparison.IS, value : unaVariable);

Obtenemos las instancias

Obtenemos el listado de instancia que concuerdan con el filtro instanciaFilter Instance[] instances = processService.getInstancesByFilter(filter : instanciaFilter);

Manipulamos las instancias obtenidas

Recorremos la lista de instancias obtenidas y en nuestro caso las abortamos.


  foreach (unaInstancia in instances) {
         unaInstancia.abort();
   }

Las posibles acciones que podemos realizar sobre una instancia son:

abort: Cancela la instancia.
suspend: Suspende la instancia.
select: Selecciona la instancia.
reasign: Reasigna la instancia a un participante.

Ver también