En los últimos meses la palabra Appian se encuentra en una gran cantidad de foros tecnológicos, pero sigue siendo una gran desconocida para muchas personas. Y es que, ¿qué es Appian? ¿Para qué sirve y cómo funciona? Te invito a continuar leyendo y descubrir juntos cómo funciona y qué características tiene.
Appian se fundó con la convicción de que las personas emprendedoras y apasionadas debían tener voz y la oportunidad de ser escuchadas y, así, darles la oportunidad de destacar.
Appian está desarrollado en Java y orientado a objetos, siendo líder mundial en múltiples sectores de tecnología empresarial. Los sectores son los llamados sistemas inteligentes de gestión de procesos empresariales (iBPMS), gestión dinámica de casos (DCM), automatización de procesos digitales (DPA) y desarrollo de low-code.
El BPM se puede definir como una nueva categoría de software empresarial que permite a las empresas modelizar, implementar y ejecutar conjuntos de actividades interrelacionadas – es decir, procesos – de cualquier naturaleza, ya sea dentro de un departamento o permeando la entidad en su conjunto con extensiones para incluir a los clientes, proveedores y otros agentes como participantes en las tareas de los procesos.
¿Qué nos ofrece Appian?
Appian combina la gestión de procesos empresariales, la inteligencia artificial, la automatización robótica de procesos, los datos y las integraciones en un proceso de automatización inteligente. Automatiza cualquier proceso de principio a fin sin necesidad de utilizar una complicada codificación, incrementando así la eficacia de sus operaciones.
Con Appian puedes coger cualquier dato de cualquier parte y combinarlo todo rápidamente con las visuales herramientas de diseño low-code (SAP, SharePoint, REST, SOAP, XML, JDBC, CSV, Excel).
Iniciación en Appian
En mi caso, la herramienta de Appian está instalada en un servidor de nuestro cliente por lo que, si queremos trabajar con ella, primero debemos acceder a la red de nuestro cliente y cuando estemos en la red a través de un navegador accedemos a cierta URL que nos lleva al diseñador de Appian.
A través de Appian creamos diferentes aplicaciones, las cuales nos van a permitir desarrollar nuestros proyectos:
Una vez tenemos la aplicación, en ella podemos crear cualquiera de los elementos del cuadro de la derecha. Por mi parte, os voy a hablar de aquellos elementos que utilizamos para desarrollar nuestros proyectos, que son:
- Carpetas: En ellas definimos los elementos que vamos a crear dentro; si vamos a crear reglas, modelo de procesos o documentos.
- Tipo de datos: Aquí definiremos nuestras variables para utilizarlas de forma global en interfaces, reglas o procesos.
- Interfaz: Desarrollamos a base de código nuestras interfaces gráficas.
- Constantes: Con ellas creamos literales con valores fijos.
- Regla de Expresión: Se utilizan normalmente para realizar comprobaciones de datos y devolver una respuesta.
- Modelo de proceso: Aquí creamos el flujo de nuestro proyecto en donde decimos cómo funciona entre una tarea u otra.
Profundicemos en cada una de ellas y veamos cómo funcionan en la aplicación.
1. Carpetas
En las carpetas vamos a organizar, dentro de nuestra aplicación, los componentes que vamos a crear. Las carpetas que vamos a crear siempre van a ser la de reglas (Interfaz, Reglas de expresión, Constantes), modelo de procesos o documentos.
2. CDT (Custom Data Type)
Empezaremos creando algo básico como puede ser un “Tipo de datos” o CDT (Custom Data Type), un tipo de datos personalizado que representa una agrupación lógica de datos relacionados. Esto nos permite definir variables que utilizaremos de forma global.
Una vez tengamos nuestra CDT, crearemos una “Interfaz” donde vamos a añadir unos campos para poner el nombre, la contraseña y un párrafo de información personal para guardar los valores generados en nuestra CDT. También crearemos un proceso en el que comprobaremos los valores introducidos en el nombre y contraseña; y, según la comprobación, haremos una acción u otra.
3. Interfaz
Cuando creamos una interfaz tenemos dos formas de trabajar con ella: en modo diseño, donde seleccionamos y arrastramos elementos como si dibujáramos en un lienzo ; y en modo expresión, donde creamos con código nuestros elementos. De entre ambas opciones, revisaremos el modo expresión, ya que la primera no suele ser utilizada para trabajar.
El modo expresión nos muestra tres pantallas:
- La definición de la interfaz, donde escribimos el código.
- La vista previa, la parte visual de lo que creamos.
- El ingreso de reglas, donde definimos las variables globales.
En la parte de ingreso de reglas vamos a definir nuestra variable global que va a ser del tipo de la CDT creada de antes.
En la parte de definición de la interfaz vamos a desarrollar código para crear dos campos de texto, un parrafo y un botón. Con este poco código, creamos lo siguiente:
La nueva regla de entrada, que hemos creado al principio, la utilizamos para dar valor a los campos. Con ello, cuando el usuario introduzca un valor se guardará en la CDT definida.
Una de las ventajas que nos ofrece Appian a la hora de desarrollar código es la ayuda sobre los elementos que desarrollamos, es decir, cuando escribimos un elemento tenemos una pequeña ayuda que nos da información sobre sus propiedades, por ejemplo, para el campo creado a!textField() tenemos la siguiente ayuda:
Otra de las ventajas que nos ofrece Appian es el control de versiones. Cada vez que guardamos una interfaz, constante, proceso etc., estamos creando una versión, la cual queda almacenada y podemos volver a ella siempre que queramos.
4. Constantes
La constante nos permite crear literales para utilizar valores que son fijos. Así mismo, con la constante podemos hacer referencia a valores, modelos de proceso, grupos de usuarios o carpetas. En este caso vamos a crear una constante de texto con el valor de “Nombre” y “Contraseña” para la interfaz anterior.
Cuando antes queríamos definir el valor de la etiqueta, escribíamos a mano “Nombre” o “Contraseña”, pero ahora haremos referencia a la constante e indicaremos cuál es el valor que queremos reflejar, si es el de “Nombre” o “Contraseña”.
5. Reglas de expresión
La regla de expresión nos permitir realizar comprobaciones y devolver una respuesta. En nuestro caso, vamos a crear una regla para comprobar que el usuario introducido es “Alumno” y en caso de que no sea, mostrar un mensaje de error.
En la interfaz que teníamos, ahora vamos a incluir una propiedad nueva al campo de texto del usuario en la que llamaremos a esta regla que acabamos de crear y le pasaremos el valor introducido en el propio campo de texto “Nombre”.
Hemos añadido una validación y, si el valor que introducimos en el nombre es distinto de “Alumno”, muestra el mensaje de error.
6. Modelo de proceso
En el modelo de proceso vamos a diseñar el flujo que queremos que siga nuestra aplicación. Para ello vamos a ver cuáles son los elementos que nos ayudan a crearlo:
- Script task: Son tareas donde podemos realizar cualquier tipo de acción relacionada con el manejo de variables (crear, dar valor, consultar, eliminar…).
- User Input Task: Son tareas de usuario en las que podemos invocar a nuestras interfaces.
- Sub-Process: Con este flujo podemos invocar a otros procesos para relacionar unos procesos con otros.
- XOR: Sirve como decisor, el cual tiene una única entrada y varias salidas, en el cual eliges qué condiciones debe cumplir para seguir el camino deseado. Puedes definir varias condiciones y varias salidas, pero solo sigue un único camino.
- AND: Parecido al XOR, tiene una entrada y varias salidas. Puedes definir varias condiciones y, en el momento en el que se cumple, el camino sigue por todas las salidas definidas.
- OR: Similar al XOR y AND, tiene una entrada y varias salidas y puedes definir varias comprobaciones, pero en este caso realiza las comprobaciones de una en una, y si la primera no se cumple pasa a la segunda, así hasta que cumpla una y siga el camino indicado.
Vamos a crear un proceso para que cuando el usuario ponga el nombre y contraseña y pulse aceptar, haya una tarea que automatice la comprobación del valor introducido en la contraseña y, si se corresponde con el valor que queremos, lo vamos a llevar a realizar una tarea u otra.
Cuando creamos el proceso lo primero que se debe hacer es crear las variables de proceso que tienen que ser del mismo tipo que las de la interfaz.
Cuando tenemos las variables de proceso, tenemos que diseñar el flujo de nuestro proceso. Primero realizaremos una tarea en la que invocaremos la interfaz de inicio de sesión, seguido de un decisor que comprobará qué valor se ha introducido en la contraseña; si es el correcto continuará a otro proceso de una aplicación personal, pero si es incorrecto pasará por una tarea que añade un comentario al párrafo de la interfaz e irá otra vez a la tarea de inicio de sesión.
Este es el flujo de nuestra aplicación. A continuación, trataré de explicar parte por parte cada uno de los componentes.
- Componente “Inicio de sesión” (User Input Task): en él vamos a invocar la interfaz que hemos creado antes; accedemos dentro de ella y seleccionamos nuestra interfaz.
- La variable “datosUsuario” de la interfaz es una CDT de tipo “CDT_PruebaSofttek” y la variable de nuestro proceso es del mismo tipo. Ahora hay que relacionarlas para que los valores generados en la interfaz se pasen al proceso.
En la entrada indicamos que el valor de la CDT de la interfaz va a tener el valor de la CDT del proceso.
En la salida indicamos que el valor generado en la interfaz se va a guardar en la variable del proceso.
De esta forma cuando generemos valores dentro de la interfaz, se guardarán en el proceso; y con los valores del proceso podemos dar valores a las variables de la interfaz.
- El siguiente componente es el XOR de “comprobar contraseña”. En él preguntaré si el valor que se ha generado en la interfaz y que hemos guardado en el proceso es uno u otro, para ser más concreto preguntaré si la contraseña es “Alumno”. Si la contraseña es correcta iré al subproceso persona, y si no, irá a la tarea que añade el comentario y posteriormente otra vez al inicio de sesión.
- El componente de “poner comentario” (Script task), guarda el valor “La contraseña es incorrecta” en el párrafo de información personal.
- El componente “Aplicación personal” (Sub-process), invoca a otro proceso que forma parte de una aplicación personal, de esta forma relacionamos el proceso de inicio de sesión con otro proceso que forma parte de otra aplicación.
Cuando relacionamos un proceso con otro, tenemos variables de entrada y salida, debemos ver qué variables debemos enviar al proceso para que funcione y que variables nos devuelve.
Ejecución de la aplicación
Vamos a ejecutar la aplicación que hemos creado:
El proceso avanza hasta la primera tarea, la ejecutamos de forma manual.
Lo creamos con el nombre correcto, pero con la contraseña incorrecta y le damos a continuar.
Lo que ha sucedido es que el XOR ha comprobado que la contraseña era incorrecta y ha dirigido el flujo a la tarea “poner comentario”, y luego a la tarea “Inicio sesión”. Veamos cómo se muestra ahora la interfaz.
Cuando abrimos la interfaz, en la parte de “Información Personal” vemos que se ha añadido el comentario. A continuación, ponemos la contraseña correcta y pulsamos “Continuar”.
Esta vez la contraseña era correcta y el decisor ha dirigido el flujo hacia el subproceso personal. La aplicación continúa hasta que se realice el subproceso y finaliza.
Y con esto, finalizaría nuestro bloque de iniciación a Appian. ¿Con ganas de continuar conociendo más de la herramienta? ¡Nos vemos pronto!
Si tienes alguna duda, por favor, ¡no olvides dejarme tu comentario!
