gestión de expedientes sigem v1 - perarrua.es€¦ · • conectores de registro: sicres. •...

Avanza LOCAL SIGEM

Gestión de expedientes SIGEMGestión de expedientes SIGEM

v1.1v1.1DESCRIPCIÓN TÉCNICA

DEL PRODUCTO

Avanza LOCAL SIGEM

Tabla de contenidos

1 Conceptos generales ...................................................................................... 4

1.1 Introducción............................................................................................ 4

1.2 La infraestructura de desarrollo............................................................ 6

2 Arquitectura................................................................................................... 8

2.1 Visión general......................................................................................... 8

2.1.1 Conectores...................................................................................... 10

2.1.2 Motor de tramitación..................................................................... 12

2.2 Objetos de negocio: El IItem................................................................ 14

2.2.1 IItem como objeto de negocio...................................................... 14

2.2.2 Extensiones sobre IItem................................................................ 17

2.3 Objetos de acceso a datos...................................................................... 21

3 Funcionalidad del framework...................................................................... 28

1/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

3.1 Funcionalidad base............................................................................... 28

3.1.1 Gestión de Sesiones: SessionAPI y IClientContext..................... 30

3.1.2 Funcionalidad del interfaz base.................................................... 32

3.2 Entidades.............................................................................................. 33

3.3 Transacciones de tramitación.............................................................. 37

3.4 Generación documentos........................................................................ 40

3.4.1 Conectores de almacenamiento..................................................... 49

3.5 La lista de trabajo................................................................................. 52

4 Desarrollo de reglas..................................................................................... 58

4.1 Eventos.................................................................................................. 58

4.2 Reglas.................................................................................................... 60

5 Particularización tramitador....................................................................... 63

5.1 El objeto de presentación: ItemBean................................................... 65

5.2 El objeto decorador........................................................................... 69

5.3 Modificación acciones estándar............................................................ 73

5.4 Librería de tags J2EE........................................................................... 76

6 Desarrollo de aplicaciones(formularios)...................................................... 82

2/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

6.1 Creación de aplicaciones....................................................................... 83

6.1.1 EntityApp....................................................................................... 83

6.1.2 Formulario JSP............................................................................. 87

3/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

1 Conceptos generales

1.1 Introducción

La gestión de expedientes SIGEM es un framework para el desarrollo de proyectos de gestión de expedientes y procesos administrativos.

Está compuesto no sólo por un conjunto de librerías para el desarrollo si no que además aporta tanto herramientas de ayuda y aplicaciones especializadas ya construidas (catálogo de procedimientos,

4/89

Avanza LOCAL SIGEM

Infraestructura de desarrollo (API’s, interfaces y conectores)

Herramientas de ayuda al desarrollo:

Administradores y asistentes.

Herramientas de reutilización de

desarrollos

Avanza LOCAL SIGEM

tramitador,etc.) como métodos de extender y reutilizar las ya existentes.

Hay disponibles por tanto asistentes para la generación de aplicaciones/formularios para las fases y trámites. Aplicaciones como el catálogo de procedimientos para la definición de todo lo necesario para modelizar la tramitación de un proceso, el tramitador de expedientes, ayudas a la integración con otros sistemas, etc.

Todo ello conforma una plataforma global, flexible y expandible para el desarrollo de proyectos de gestión de expedientes con el objetivo de disminuir el esfuerzo necesario para su construcción.

5/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

1.2 La infraestructura de desarrollo

El framework se divide funcionalmente en tres capas lógicas diferenciadas:

• Infraestructura: En ella se apoyan las otras dos y comprende, entre otras, la capa de acceso a datos, la gestión de entidades de negocio, el soporte organizativo (LDAP, etc.) y utilidades varias.

• BPM: Constituido por los paquetes de proceso de reglas y el motor de transacciones.

• Producción Administrativa: Se enmarcan en esta capa toda la funcionalidad propia de la gestión de expedientes tales como la generación de documentos, la bandeja de entrada del registro, catalogación de procedimientos, etc.

6/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

La separación funcional posibilita el uso de los distintos módulos del framework sin ningún prerequisito. Por ejemplo, se puede utilizar tan solo la gestión de acceso a datos o de entidades sin necesidad de establecer ningún tipo de sesión previa en invesflow Java.

Así se consigue una alta reutilización del framework ya que no sólo se tiene una linea de funcionalidad vertical, que obligatoriamente se apoya en módulos anteriores que pueden presentar o no requisitos funcionales, si no también una linea de funcionalidad horizontal en la cual se puede prescindir del aquello que no se necesite o que no cumpla las exigencias aparte de poder expandir el framework con nueva funcionalidad.

7/89

Avanza LOCAL SIGEM

Infraestructura

Producción Administrativa

To-do lists

mgmt.

Gestión de Libros de Registro

Gestor de

tramitación

Gestión de entidades

Sesiones PersistenciaDAO Seguridad/

Credenciales

IItem

Generación de

documentos

Directory mgmt

ArchivoRecuperación

Organización

CatalogaciónIndexación Búsqueda

BPM

Motor de Reglas Motor de Tramitación

Avanza LOCAL SIGEM

2 Arquitectura

2.1 Visión general

La implementación de invesflow Java está formada por tres grandes capas:

• DAO: Capa de acceso a datos. Su objetivo es proporcionar una base unificada para gestionar la persistencia de los datos que utilizarán el resto de capas. Por tanto se define un único objeto de acceso de

8/89

Avanza LOCAL SIGEM

DAO - ObjectDAO, CollectionDAO

Módulos sistema

EntidadesGeneraciónDocumentos BPM

Gestiónlistas de trabajo

Conectores

API SPAC – IItem, invesflowAPI

Avanza LOCAL SIGEM

datos: el ObjectDAO. Además esta capa está compuesta a su vez por varios módulos:

• Gestor de base de datos: Explora la base de datos y recopila tanto la información necesaria para crear los ObjectDAO como todo lo necesario para guardar y recuperar los datos a los que referencia.

• Gestor de entidades de datos: Explota el catálogo de entidades del framework y crea automáticamente en tiempo de ejecución los objetos para exponerlos ( EntityDAO).

• Gestor de consultas: Explota las relaciones definidas en el modelo de datos para crear en tiempo de ejecución los objetos que la representen (ObjectDAO).

• Módulos del sistema: La lógica de negocio se encuentra implementada en los distintos subsistemas los cuales cumplen cada uno un propósito bien definido. Una gran mayoría de los módulos se adaptan mediante conectores que permitan tanto la extensión de nuevas funcionalidades como la adaptabilidad del sistema. Se encuentran entre otros los siguientes módulos

• Gestión de documentos. Se encarga de la generación de documentos a partir de plantillas y de su almacenamiento posterior mediante el conector adecuado en el gestor documental.

• BPM: El gestor de transacciones de procesos se encarga de realizar todos los cambios en los procesos según la especificación dada por el procedimiento que lo rige.

• API de SPAC: El punto de entrada al framework. Se basa en un único interfaz, IItem que representa cualquier tipo de objeto de negocio que pueda gestionar el framework.

9/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

2.1.1 Conectores

Los subsistemas del framework poseen un punto de anclaje aislado con respecto al resto de módulos. Gracias a ello la funcionalidad se añade en forma de conector con un protocolo predefinido especificado en un interface Java permitiendo variar la implementación sin ningún impacto en el resto de componentes.

Ejemplos de conectores de ISPAC son:

• Conector documental: para el almacenamiento y recuperación de los documentos en distintos gestores documentales. SPAC implementa ya un buen número de ellos:

• Documentum.

10/89

Avanza LOCAL SIGEM

Entidades detramitación

Conectores ISPAC

Tramitación - Objetos de negocio (IItem, IITemCollection)

Sistemas degestión

Conector específico

Conector XML, WebService,

etc

Conector SPAC

Terceros

Avanza LOCAL SIGEM

• invesdoc.

• En sistema de ficheros.(Principalmente como gestor documental para desarrollo.

• En base de datos.(Principalmente como gestor documental para desarrollo).

• Conector organizativo: recupera la información de los usuarios, grupos y unidades organizativas. Existen dos implementaciones:

• LDAP.

• Sistema de usuarios invesdoc.

• Conectores bandeja de entrada:

• Conectores de Registro: SICRES.

• Avisos.

Todos ellos devuelven el mismo tipo de objeto de negocio (IItem) proporcionando un integración consistente sea cual sea el origen de los datos.

Este mismo esquema se puede adoptar a la hora de crear nuevos conectores para la integración de datos de gestión provenientes de otros sistemas.

11/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

2.1.2 Motor de tramitación

Dado un procedimiento el motor de tramitación es el encargado tanto de crear nuevos procesos a partir de su definición como de avanzar su estado de tramitación a medida que se cierran o activan fases, tramites, hasta alcanzar los hitos requeridos en la historia del expediente.

El motor de transacciones recibe una entrada: la definición del procedimiento y genera dos salidas: el estado de los procesos y los hitos conseguidos.

• Definición de proceso: Rige los procesos y determina que fases y tramites se deben activar cuando se da por concluida una fase o trámite.

12/89

Avanza LOCAL SIGEM

Definición de procesos

Estado de procesos Hitos de expedientes

Procesos en curso Traza de tramitación

Motor de WorkflowMotor de Workflow

Colas de trabajo

Avanza LOCAL SIGEM

• Estado de los procesos en curso: Durante la tramitación sólo se guardan referencias al estado de las fases y trámites en curso, borrándose y creándose nuevas a medida que éstas se cierran y el expediente avance. Así el estado de un proceso se puede ver como un cursor o apuntador a la definición del procedimiento. Este diseño dota de gran flexibilidad al motor de transacciones permitiendo tanto ciclos en los flujos como la reubicación de las fases de un expediente.

• Hitos de expedientes: El motor de tramitación anota en un histórico del expediente todo lo concerniente a las actuaciones que se han realizado sobre él, el responsable y fechas entre otros datos. Por ejemplo: el inicio de un expediente, dar por concluida una fase o la generación de un documento. Además se permite que el propio desarrollador genere sus propios hitos con información adicional a la estándar.

El módulo de gestión de listas de trabajos se encarga de ordenar el conjunto de estado de procesos y filtrarlo por criterios de responsabilidad para confeccionar las listas de fases y trámites pendientes por realizar del usuario que pide la consulta.

13/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

2.2 Objetos de negocio: El IItem

Para homogeneizar el acceso a los diversos objetos de negocio el framework presenta un única perspectiva con la cual elaborar toda su interacción. Dicha perspectiva se concreta como la definición de un interfaz que han de cumplimentar todos los objetos: IItem

Por tanto los objetos de negocio pueden provenir del propio framework o de diversas fuentes como, por ejemplo, una integración con un sistema corporativo. En cualquier caso siempre presentarán el mismo aspecto y se manipularan de la misma forma independientemente de cual sea su origen.

2.2.1 IItem como objeto de negocio

IItem es el interfaz que han de cumplimentar necesariamente todos los objetos de negocio u objetos de transferencia. Gracias a ello todas las interacciones con el framework tendrán el mismo patrón de desarrollo, disminuyendo enormemente el tiempo empleado en la construcción de procedimientos.

El IItem expone a través de sus métodos el acceso a un objeto genérico compuesto por propiedades, a las cuales se les puede leer y

14/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

modificar sus valores, y obtener la descripción de esas propiedades que lo componen. Además es posible obtener la representación del objeto como un mapa de nombres de propiedad a sus valores correspondientes o también, como texto en formato XML.

Todo ello proporciona los siguientes beneficios:

• Independencia del resto de capas.

• Robustez debido a la capacidad de autoexploración ya que el propio IItem expone cuales son sus propiedades.

• Proporciona una visión homogénea para todos los objetos, sea cual sea su origen (BBDD, LDAP, XML, etc.) o funcionalidad (objetos del framework, objetos creados para resolver una integración, etc.).

• Reutilización de gran cantidad de funcionalidad disponible en paquetes del propio framework

• La capa de presentación del framework tiene como tipo base el IItem al que extiende a su vez en el objeto básico de presentación ItemBean. Así se consigue que ésta obtenga los mismos beneficios (homogeneidad, robustez, etc.) que la capa de negocio.

Ejemplos

Crear un nuevo registro en la entidad de importes.

final int ENTITY_IMPORTES = 10;

IInvesflowAPI invesflowAPI = session.getAPI();IEntitiesAPI entitiesAPI = invesflowAPI.getEntitiesAPI();

IItem itemimporte = entitiesAPI.createEntity(ENTITY_IMPORTES);

15/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

itemimporte.set("NUMEXP", "EXP-0001");itemimporte.set("IMPORTE", 64300);itemimporte.store(session.getClientContext());

int importe= itemimporte.getInt("IMPORTE");

// Se puede obtener la representación del IItem // como una cadena en formato XMLString sdocxml=itemimporte.toXML();

El objeto IItemCollection

El interfaz IItemCollection representa una colección de IItems. Ofrece métodos para recorrer todos los objetos que la conforman, convertirla a una colección estándar de J2EE o a una representación textual en formato XML.

Ejemplos

// Acceso a una colección de entidades (items).

// De un expediente IItemCollection itemcol=entitiesAPI.getEntities(ENTITY_IMPORTES,numexp);

// o en general...IItemCollection itemcol=entitiesAPI.queryEntities(ENTITY_IMPORTES,

"WHERE IMPORTE > 1000");

// La colección se puede iterar de varias formas:// Directamente..while(itemcol.next()){ IItem item=itecom.value(); System.out.println(item.toXML());}

//.. o mediante un iterador

Iterator it=itemcol.iterator();

16/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

//También se puede obtener su representación como //una colección estándar

List itemlist=itemcol.toList();

2.2.2 Extensiones sobre IItem

El framework puede añadir conocimiento al interface IItem

básico de manera que puedan quedar disponibles nuevas funcionalidades pero comportándose siempre como un objeto IItem normal.

Por ejemplo al siguiente IItem con los datos de tramitación de un proceso (no confundir con un registro de la entidad de expedientes) se le añaden métodos para poder acceder a su vez a fases en curso del expediente, trámites, hitos, etc.

public interface IProcess extends IItem{

public IItemCollection getStages() throws ISPACException;

public IItemCollection getMilestones() throws ISPACException;

public IItemCollection getSyncnodes() throws ISPACException; public IItemCollection getTasks() throws ISPACException;

public IItemCollection getTasks(int nIdStage) throws ISPACException;}

17/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

Un ejemplo de utilización de estos IItems extendidos sería el siguiente:

IInvesflowAPI invesflowAPI = session.getAPI(); IProcess proc = invesflowAPI.getProcess(“EXP/0001”);

// Obtención de las fases del proceso.ItemCollection stages= proc.getStages();

// Un IProcess es también un IItem

Date deadline=proc.getDate(“FECHA_LIMITE”);String idresp= proc.getString(“ID_RESP”);

Composición de IItems

En numerosas ocasiones puede ser útil el generar un IItem que represente la unión de uno más IItems, sin importar el origen o la heterogeneidad de los datos que representan. Como se verá más adelante es una funcionalidad muy utilizada al desarrollar los formularios o aplicaciones para procedimientos mediante objetos EntityApp.

Para ello se necesita construir un objeto de tipo CompositeItem, que se encargará de presentar el agregado de items como un objeto de tipo IItem a su vez. El único requisito es elegir cual es el campo clave de todo el conjunto y cualificar mediante un prefijo las propiedades de cada uno de los IItems que lo componen.

Como ejemplo se construirá un IItem compuesto por dos items: datos del expediente y datos del interesado.

IItem expitem=getExp(...);

18/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

IItem usritem=getInteresado(...);

//Se crea el item compuesto y se elige la futura propiedad EXPEDIENTE:NUMEXP//como campo clave.CompositeItem composite = new CompositeItem("EXPEDIENTE:NUMEXP");

//Se añaden los items que conformarán el item compuesto junto con el prefijo que //que se utilizará para referirse a las propiedades de cada entidad.composite.addItem( expitem, "EXPEDIENTE:");composite.addItem( usritem, "INTERESADO:");

//CompositeItem implementa IItem y por tanto toda su funcionalidadIItem unionitem=composite;

String nombre=unionitem.getString("INTERESADO:NOMBRE");String numexp=unionitem.getString("EXPEDIENTE:NUMEXP");

//El agregado también se puede guardarunionitem.set("EXPEDIENTE:ASUNTO","Expediente de ejemplo");unionitem.store(ctx);

El IItem como objeto de integración de datos

Existen varias utilidades para facilitar la conversión de datos a IItem. Entre ellos se tienen:

• GenericItem: Implementación de un IItem como una tabla hash de propiedades y valores. Se puede utilizar como base para otras implementaciones e integraciones.

Properties properties=new Properties();properties.add(new Property(0, "ID",Types.INTEGER));properties.add(new Property(1, "NOMBRE",Types.VARCHAR));IItem item=new GenericItem(properties,"ID");

19/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

• Transformador de XML en colecciones de IItem: El siguiente ejemplo crea un colección de IItems a partir de una definición particular del IItem contenido en un documento XML. Dicha definición se realiza mediante expresiones XPath.

//Definición de un IItem dependiente del XML a tratar.XmlItemInfo xmlItemInfo=new XmlItemInfo(

"/SERVICIO/SALIDAS/listasal",//expr que representa un IItem"salida", //expr que representa una propiedad"@dato", //expr que define el nombre de la propiedad"./text()", //expr que define el valor de la propiedad"PARTIDA"); //Nombre de la propiedad índice

Document doc=XMLDocUtil.newDocument(servicioResp.toString());

ItemFactory itemfactory = new ItemFactory(itemprop);IItemCollection itemcol=itemfactory.newXmlCollectionItem(doc,xmlItemInfo);

20/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

2.3 Objetos de acceso a datos

En el marco de un procedimiento puede ser necesaria la capacidad de obtener a bajo nivel ciertos datos para, por ejemplo, solventar una integración con un sistema que se encuentra en otra base de datos. Para ello se pueden utilizar toda la infraestructura de acceso a datos del framework, ahorrándose un desarrollo más laborioso que emplee directamente JDBC.

Acceso al modelo de datos: ObjectDAO y CollectionDAO

ObjectDAO es la representación de un registro perteneciente a una tabla o vista de base de datos. Se comporta como un componente compuesto de propiedades las cuales se pueden consultar en tiempo de ejecución.

Dicho componente proporciona las siguientes ventajas:

• Homogeneidad en el acceso a datos debida a la autoexploración ya que el propio ObjectDAO expone cuales son sus propiedades.

• Robustez ya que no es necesario modificar su implementación si se altera la composición de la tabla en BBDD.

21/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

• ObjectDAO implementa IItem y por tanto obtiene adicionalmente todas sus ventajas. Por tanto un objeto ObjectDAO se puede emplear directamente como objeto de negocio.

• No es necesario establecer una sesión con invesflow Java para utilizarlos.

El objeto CollectionDAO representa una lista ordenada de ObjectDAO. También implementa el método disconnect() el cual proporciona su representación como IItemCollection, aparte de poder obtenerlo como lista o mapa de objetos estándar.

Es importante notar que CollectionDAO es una capa muy ligera pensada para no añadir sobrecarga extra, ya que utiliza internamente un recordset para el acceso a los datos y crea bajo demanda cada uno de los ObjectDAOs sólamente cuando se le solicitan.

La forma de uso de estos objetos es mediante la definición de objetos de acceso a datos (Data Access Object) específicos basados en las clases abstractas ObjectDAO y CollectionDAO.

También se puede utilizar el objecto genérico EntityDAO(que implementa a su vez ObjectDAO) si previamente se ha dado de alta la tabla en el catálogo de entidades. De esta forma se hace innecesaria la implementación específica de clases de acceso a datos utilizando todas las entidades la misma (EntityDAO).

22/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

Creación de un DAO

Para definir un objeto de acceso a datos es necesario implementar los siguientes métodos:

[...]

// Devuelve el nombre de la tablapublic abstract String getTableName();

// Proporciona el SQL por defecto que identifica al registro;// normalmente por el campo clave.protected abstract String getDefaultSQL(int nActionDAO)throws ISPACException;

// Calcula un nuevo identificador para el campo clave de la tabla.protected abstract void newObject(DbCnt cnt) throws ISPACException;

// Obtiene el nombre del campo clave.public abstract String getKeyName() throws ISPACException;

[...]

Un ejemplo de implementación de un DAO para el cual se utilizará la siguiente tabla que además se ha dado de alta también en el catálogo de entidades con identificador 10:

ENT_IMPORTESID NUMEXP IMPORTE1 EXP/002 89002 EXP/034 5600

23/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

public class ImporteDAO extends ObjectDAO{

static final String TABLENAME = "ENT_IMPORTE";static final String IDSEQUENCE = "SQ_ENT_IMPORTE";static final String IDKEY = "ID";

public ImporteDAO(DbCnt cnt, int id) throws ISPACException{

super(cnt, id, null);}

public ImporteDAO() throws ISPACException{

super(null);}

public String getTableName(){

return TABLENAME;}

protected void newObject(DbCnt cnt) throws ISPACException{

set(IDKEY,IdSequenceMgr.getIdSequence(cnt,IDSEQUENCE));}

protected String getDefaultSQL(int nActionDAO) throws ISPACException{

return " WHERE " + IDKEY + " = " + getInt(IDKEY);}

public String getKeyName() throws ISPACException{

return IDKEY;}

}

Obtención de la conexión

La clase DbCnt encapsula la lógica necesaria para solicitar una conexión, ya sea a un pool de conexiones mediante JNDI o directamente.

24/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

Como se podrá comprobar más adelante, la mayoría de las veces no es necesario crear una conexión utilizando el objeto DbCnt si no que es el propio framework quien lo proporciona. Para ello se debe solicitarlos al contexto de cliente: IClientContext.getConnection();

Ejemplo:

DbCnt cnt1=null;DbCnt cnt2=null;DbCnt cnt3=null;DbCnt cnt4=null;

try{// Obtención de una conexión del pool de conexiones definido en ispac.properties// sin necesidad de establecer sesión con el framework

cnt1=new DbCnt();cnt1.getConnection();

// Obtención de una conexión de un pool de conexiones específico.cnt2=new DbCnt("java:comp/env/jdbc/iSpaceCoreDS");cnt2.getConnection();

// Obtención de una conexión sin utilizar pool.cnt3=new DbCnt();cnt3.getConnectionEx("oracle.jdbc.driver.OracleDriver",

"jdbc:oracle:thin:ispace/[email protected]:1521:iasdb");

// Obtención de una conexión a traves del contexto de cliente, tras haber// establecido una sesión con invesflow Java.

cnt4=clientcontext.getConnection();}finally{// En cualquier caso es imprescindible liberar la conexión

if (cnt1!=null)cnt1.closeConnection();



if (cnt4!=null) clientcontext.releaseConnection();

}

25/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

Utilizando el DAO

Ejemplo de accesos con el objeto ImporteDAO definido en el apartado anterior.

//Varias formas de acceso

// 1 Mediante el constructorImporteDAO importe=new ImporteDAO(cnt,2);importe.get("NUMEXP");

// 2 Mediante el método loadimporte = new ImporteDAO();importe.setKey(2);importe.load(cnt);

//Crear un nuevo registroimporte = new ImporteDAO();

importe.createNew(cnt);importe.set("NUMEXP","EXPEDIENTE-0001");importe.set("IMPORTE",45000);importe.store(cnt);

//Modificar un registroimporte=new ImporteDAO(cnt,2);importe.set("IMPORTE",0);importe.store(cnt);

//Accediendo a colecciones de DAOsCollectionDAO objlist=new CollectionDAO(ImporteDAO.class);

objlist.query(cnt,"WHERE IMPORTE is not null");

while(objlist.next()){

ImporteDAO importe=(ImporteDAO)objlist.value();System.out.print(importe.toXML());

}

26/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

Uso de EntityDAO

Similar al anterior, sólo que la definición de una clase específica es innecesaria y se puede utilizar la clase genérica EntityDAO. Los EntityDAO se generan mediante una clase factory que se encarga de construirlos dependiendo de la definición de la entidad.

Para ello se debe recordar que a la tabla importe se le ha dado de alta previamente en el catálogo de entidades con el identificador 10.

//ENTITY_IMPORTES = 10int entityId=Constantes.ENTITY_IMPORTES;

// Se utiliza la clase factory para crear el EntityDAO requerido.// Un EntityDAO es también un ObjectDAOObjectDAO entity= EntityFactoryDAO.getInstance().newEntityDAO(cnt,entityId);entity.createNew( cnt);entity.set("NUMEXP","EXPEDIENTE-0001");entity.set("IMPORTE",45000);entity.store(cnt);

CollectionDAO entities = EntityFactoryDAO.getInstance().queryEntities(cnt, entityId," WHERE NUMEXP IS NOT NULL");

27/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

3 Funcionalidad del framework

3.1 Funcionalidad base

El API de invesflow Java lo conforman los siguientes interfaces:

• SesionAPI: autentifica el usuario con el sistema organizativo adecuado (LDAP o invesdoc) y crea el contexto del cliente.

28/89

Avanza LOCAL SIGEM

IInvesflowAPI

IWorklistAPI

ITXTransaction

IGenDocAPI

IEntitiesAPI

IClientContext

SesionAPI

Avanza LOCAL SIGEM

• IClientContext: El compendio de toda la información y funcionalidad necesaria para el framewok de un cliente conectado.

• IInvesflowAPI: proporciona funcionalidad de base (acceder a datos de los expedientes y procedimientos) y además a partir del cual se accede al resto de interfaces.

• IEntitiesAPI: acceso, consulta y modificación de los registros de todas las entidades asociadas a los expedientes que intervienen en su modificación.

• ITXTransaction: acciones sobre expedientes como iniciar expediente, cerrar fase, etc.

• IWorklistAPI: permite acceder a la lista de trabajo de un responsable, es decir, a todas aquellas fases y trámites pendientes de realizar cuyo responsable es el usuario conectado.

• IGenDocAPI: se encarga de la generación de documentos a partir de plantillas y ofrece la funcionalidad del conector repositorios de gestión documental.

29/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

3.1.1 Gestión de Sesiones: SessionAPI y IClientContext

SessionAPI es el punto de entrada al framework, el gestor encargado de la autenticación del usuario, de la asignación del ticket que la indentifica unívocamente y de la creación de un contexto de cliente.

IClientContext expone toda la funcionalidad del framework, la información del usuario obtenida del sistema organizativo, variables de sesión y gestiona la persistencia y el control transaccional de los objetos.

Login inicial en el framework

Tras autentificarse en el sistema se entrega una cadena de texto: el ticket. Este ticket se debe guardar asociándolo con el cliente que se acaba de autentificar (en el objeto HttpSession o como una cookie).

String user = "usuario1";String password = "temporal";

// Autenticación del usuarioSessionAPI sesion = new SessionAPI();

//Opcional: se puede asociar la identificación de la máquina cliente//a la sesión. Si no se requiere se puede suministrar en el método login//una cadena vacia en su lugar.String remoteHost = request.getRemoteHost();if ((remoteHost == null) || (remoteHost == ""))

remoteHost = request.getRemoteAddr();

30/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

try { sesion.login(remoteHost, user, password);} catch (ISPACException e) {

//Tratar adecuadamente el error}

// Se obtiene finalmente el ticket que identificará// la sesión obtenida.String ticket = sesion.getTicket();

Obtención del contexto de un usario previamente conectado

Para utilizar la funcionalidad del framework basta con iniciar el objeto SessionAPI con el ticket que se entrega en el método de login, el cual se debe guardar asociándolo con el cliente conectado.

// Código previo a realizar peticiones en el API de ISPACSessionAPI sesion = new SessionAPI();String ticket = "<ticket previamente obtenido>";

sesion.init(ticket);

try {IClientContext ctx=session.getClientContext();// Obtener el APIIInvesflowAPI invesflowAPI = ctx.getAPI();// código particular de la acción

} finally {

//IMPORTANTE: Liberar la sesión siempre antes de //terminar la acción de Strutssesion.release();

}

31/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

3.1.2 Funcionalidad del interfaz base

En el invesflowAPI se encuentran la mayoría de métodos de acceso a procesos y procedimientos. Estos métodos acceden a los expedientes sin ningún tipo de filtro por responsabilidad.

Además invesflowAPI contiene el conjunto de métodos que proporcionan el acceso al resto de interfaces que conforman el API.

Métodos representativos

• getProcedure: Devuelve el procedimiento identificado

public IProcedure getProcedure(int procedureId) throws ISPACException;

• getProcess: Crea un nuevo registro de entidad y devuelve el IItem que lo representa.

public IProcess getProcess(int nIdProc) throws ISPACException;

• getMilestones: Obtiene la colección de hitos alcanzados en el expediente indicado por el identificador del proceso.

public IItemCollection getMilestones(int nIdProc) throws ISPACException;

32/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

3.2 Entidades

La funcionalidad ofrecida por el API de entidades posibilita el mantenimiento y búsqueda de entidades las cuales pueden estar asociadas o no a algún expediente en concreto.

También expone todos los métodos necesarios para la creación y utilización de aplicaciones o formularios.

Métodos representativos

• getEntity: Obtiene una entidad sin ningún valor de registro. Por tanto el objeto IItem devuelto tendrá todas sus propiedades pero sin ningún valor cargado.

public IItem getEntity(int entityId) throws ISPACException;

• createEntity: Crea un nuevo registro de entidad y devuelve el IItem que lo representa.

public IItem createEntity(int entityId) throws ISPACException;

• getEntity: Obtiene el registro con id key de la entidad especificada y devuelve el IItem que lo representa.

public IItem getEntity(int entityId, int key) throws ISPACException;

33/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

En el siguiente ejemplo se crea un nuevo registro en la entidad con identificador 10 (Entidad de Importes) y se modifica sus propiedades.

Posteriormente llamando al método IItem.store(...) se guardan las modificaciones.

final int ENTITY_IMPORTES = 10;

IClientContext ctx=session.getClientContext();IInvesflowAPI invesflowAPI = ctx.getAPI();

IEntitiesAPI entitiesAPI = invesflowAPI.getEntitiesAPI();

IItem itemimporte = entitiesAPI.createEntity(ENTITY_IMPORTES);

itemimporte.set("NUMEXP", "EXP-0001");itemimporte.set("IMPORTE", 64300);itemimporte.store(ctx);

• getEntities: Obtiene la colección de registros de la entidad especificada asociados con el expediente con número 'numexp'

public IItemCollection getEntities(int entityId, String numexp) throws ISPACException;

• queryEntities(int,String): Obtiene la colección de registros de entidad que cumplen la condición SQL especificada en 'query'

public IItemCollection queryEntities(int entityId, String query) throws ISPACException;

Ejemplo:// Acceso a una colección de entidades (items).// De un expediente en particular con número de expediente "numexp"...IItemCollection itemcol=entitiesAPI.getEntities(ENTITY_IMPORTES,numexp);

// o en general...IItemCollection itemcol=entitiesAPI.queryEntities(ENTITY_IMPORTES,

"WHERE IMPORTE > 1000");

34/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

• queryEntities(Map,String): Sólo disponible en la versión 1.1 del framework. Permite especificar una consulta sobre una o más entidades o tablas. Para ello es preciso definir un mapa con el prefijo que se quiere asignar a las tablas que intervienen la consulta. El resultado es una colección de IItems compuestos por cada una de las filas resultado del join con las propiedades cualificadas según el prefijo asociado con anterioridad. Los IItems resultantes de la consulta no son actualizables mediante el método IItem.store().

public IItemCollection queryEntities(Map entmap,String query) throws ISPACException

Ejemplo: Para realizar el siguiente join con el API de entidades.

SELECT * FROM SPAC_PROCESOS PROCESO, SPAC_FASES FASE WHERE PROCESO.ID = FASE.ID_EXP

Se utilizaría el siguiente código.

tableentitymap.put("PROCESO","SPAC_PROCESOS");tableentitymap.put("FASE","SPAC_FASES");

IItemCollection consulta;consulta=entityAPI.queryJoinEntities(tableentitymap,

" WHERE PROCESO.ID = FASE.ID_EXP ");

Para acceder a las propiedades de los IItems resultado de la consulta hay que calificarlas adecuadamente utilizando su prefijo.

35/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

consulta.getString("PROCESO:NUMEXP");consulta.getString("FASE:NOMBRE");

Es posible especificar para el join tanto tablas como entidades. Basta con asignar al mapa de prefijos el nombre de la tabla o un objeto Integer o Long con el identificador de la entidad.

//Tabla SPAC_PROCESOStableentitymap.put("PROCESO","SPAC_PROCESOS");//Entidad de expedientes, definida como constantetableentitymap.put("EXPED",new Integer(ISPACEntities.DT_ID_EXPEDIENTES);//Entidad del catálogo con identificador 23tableentitymap.put("DATOS",new Integer(23);

36/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

3.3 Transacciones de tramitación

Se denominan transacciones del motor de tramitación a todo tipo de acción realizada sobre el estado de un expediente que modifique éste. Toda transacción es atómica, es decir se realiza en su totalidad o no se produce ningún cambio en el expediente. Hay que tener en cuenta que la ejecución de una transacción puede disparar eventos que a su vez pueden lanzar más transacciones y/o modificar datos de entidades. Por tanto si se produce un error en cualquiera de esas reglas se anularían todos los cambios producidos sobre el expediente y sus datos.

• createProcess: Crea un nuevo proceso a partir del procedimiento indicado. Una concluida la transacción devuelve el identificador de proceso creado.

public int createProcess(int nProcedure) throws ISPACException;

Ejemplo:

IInvesflowAPI invesflowAPI = ctx.getAPI();ITXTransaction tx = invesflowAPI.getTransactionAPI();

// Se crea el procedimiento indicado según el parámetro // pasado en la URL con nombre procedureIdString procedureId = request.getParameter("procedureId");int nIdProcess = tx.createProcess(Integer.parseInt(procedureId));

37/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

• closeStage: Da por concluida la fase activando el resto de fases según lo indicado en la definición del procedimiento. El parámetro nIdStage es el identificador de la fase en el proceso.

public void closeStage(int nIdStage) throws ISPACException;

• createTask: Crea un nuevo trámite el cual queda asignado a la fase especificada.

public int createTask(int nIdStage,int nIdTaskPCD) throws ISPACException;

• closeTask: Da por concluido el trámite. El parámetro nIdTask es el identificador del trámite en el proceso.

public void closeTask(int nIdTask) throws ISPACException;

Ejemplo: Cierre de todas las fases de un expediente.


//Se obtienen todas las fases activas del expediente "EXP/0001"IProcess proc=invesflowAPI.getProcess("EXP/0001");IItemCollection itemcol=proc.getStages();

Iterator it=itemcol.iterator();while (it.hasNext()){

IItem stage = (IItem) it.next();tx.closeStage(stage.getKeyInt());

}

38/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

• newMilestone: Crea un nuevo hito particular en el proceso.Se proporciona además un campo identificador nIdInfo y un campo texto info para permitir añadir información extra específica del llamante. Es obligatorio suministrar el identificador de proceso nIdProc mientras que es opcional especificar los identificadores de fase y trámite en el procedimiento (pasar valores a 0 si no se desea asignar el hito a una fase específica).

public void newMilestone(int nIdProc, int nIdStagePCD, int nIdTaskPCD,int nIdInfo, String info) throws ISPACException;

Ejemplo: Generación de un hito propio.


tx.newMilestone(339,0,0,Publicacion.ESPERANDO_FIRMA,"Esperando autorización");

3.4 Generación documentos

39/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

Una funcionalidad básica para la gestión de expedientes es la generación de documentación de forma dinámica en el transcurso de la tramitación. Dicha documentación se puede generar mediante la mezcla de datos del sistema con documentos patrón o bien de forma directa anexando documentación externa.

La generación de documentos maneja dos tipos básicos de elementos:

• Tipos de documentos.

Definen el tipo de documentación que podemos generar en el contexto de la tramitación.

• Plantillas.

Son los documentos patrón que el sistema utiliza en la generación de los documentos. El contenido de las plantillas se fusiona con los datos del sistema para generar los documentos.

Las plantillas se agrupan por tipos de documentos y pueden estar definidas como documentos Microsoft Word o documentos OpenOffice. El documento generado será del mismo tipo que la plantilla.

40/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

Para realizar la fusión de datos del expediente con la plantillas adecuadas generando el documento final se siguen los siguientes pasos:

1. El motor de combinación obtiene la plantilla de BBDD

2. Utilizando un analizador de plantillas como OpenOffice, busca todos los marcadores(tags) existentes y los reserva en una lista

3. El interprete de marcadores resuelve todos los tags obtenidos en el paso anterior y obtiene a su vez una lista de resultados.

41/89

Avanza LOCAL SIGEM

Catálogo de

plantillas

Motor de combinación

1.- Lee plantilla

3.- Solicita resolución

4.- Genera

Documento final

Intérprete de marcadores

2.- Utiliza

Repositorio de documentos

Analizador de plantillas

Parser RTF(en

desarrollo)

Avanza LOCAL SIGEM

4. El motor de combinación sustituye los marcadores originales de la plantilla por el resultado de su evaluación.

5. El documento final generado se entrega al conector de gestión documental que se encarga de guardarlo en el repositorio adecuado.

Tags de plantillas

Para realizar la mezcla en las plantillas se definen marcadores con sintaxis XML que se sustituirán por el texto calculado por el intérprete .

• Entidades:

Sustituye el texto del tag por el contenido de la propiedad de nombre PROPIEDAD asociado a la entidad de nombre ENTIDAD.

<ispactag entity="ENTIDAD" property="PROPIEDAD" />

Sustituye el texto del tag por el contenido de la propiedad de nombre PROPIEDAD asociado a la entidad con identificador ID.

<ispactag entityid="ID" property="PROPIEDAD" />

En ambos casos, el registro de la entidad se determina por el número de expediente para el que se está generando el documento.

42/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

• Variables de sesión:

Sustituye el texto del tag por el contenido de la variable de sesión de nombre VARIABLE.

<ispactag sessionvar="VARIABLE"/>

• Reglas:

Sustituye el texto del tag por el resultado obtenido de ejecutar la regla de nombre REGLA.

<ispactag rule="REGLA" nombreparametro="valor" />

Sustituye el texto del tag por el resultado obtenido de ejecutar la regla de identificador ID.

<ispactag ruleid="ID" nombreparametro1="valor1" nombreparametro2="valor2"/>

Si la regla necesita parámetros para su ejecución, estos se definen como atributos del tag, tantos como sean necesarios. Los parámetros se obtienen en la regla mediante el método asociado al contexto de ejecución de la regla IRuleContext de la siguiente forma:

String value1=rulecontext.get("nombreparametro1");String value2=rulecontext.get("nombreparametro2");

43/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

Ejemplo:

Plantilla con tag de ejemplo

Numexp:

<ispactag entity="EXPEDIENTE" property="NUMEXP" />

Lista documentos:

<ispactag rule="ObtenerDocumentos" resumen="si" firmados="no" />

Generación de documentos por lotes

Permite la generación de un tipo de documento para un conjunto de fases o tareas seleccionados.

En la generación de documentos por lotes se puede elegir y editar la plantilla, seleccionar los registros de la entidad para los que se va a generar los documentos, salvar e imprimir los documentos generados.

Para realizar la impresión por lotes hay que incluir la siguientes sentencias en la acción:

44/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

List listMenus = new ArrayList();

IActions actions = managerAPI.getActionsAPI();MessageResources messages = this.getResources( request);

// Se ejecuta la acción entityDocuments.do contra el frame workframe.String message = messages.getMessage("generate.documents");Menu menu = new Menu(message, "NOMBRE", "documentId", ActionBean.ID);

// Obtiene la lista de tipos de documentos como accionesmenu.addItems(actions.getStateDocuments(state,"javascript:generateDocuments('entityDocuments.do');"));listMenus.add(menu);

// Salva el menú en la peticiónrequest.setAttribute("menusToolbar", listMenus);

Anexar ficheros a documentos

Una vez generado un tipo de documento podemos anexar una de las plantillas asociadas al tipo de documento o bien anexar un fichero.

API de generación de documentos

Para obtener el API de generación de documentos desde una acción tenemos que ejecutar las siguientes sentencias:

IInvesflowAPI invesFlowAPI = session.getAPI();IGenDocAPI documentAPI = invesFlowAPI.getGenDocAPI();

Los métodos que implementa el interface de generación de documentos son los siguientes:

• getDocTypesFromStage: Obtiene la lista de tipos de documento que se pueden generar desde una fase de un procedimiento.

45/89

Avanza LOCAL SIGEM

javascript:generateDocuments('entityDocuments.do) >> >> endobj 374 0 obj << /Type /Annot /Subtype /Link /Border [0 0 0] /Rect [324.8 577.6 506.6 587] /A << /Type /Action /S /URI /URI (javascript:generateDocuments('entityDocuments.do) >> >> endobj 375 0 obj << /Type /Annot /Subtype /Link /Border [0 0 0] /Rect [167.4 233.1 365.5 250.4] /A << /Type /Action /S /URI /URI (http://displaytag.sourceforge.net/) >> >> endobj 511 0 obj << /Type /Catalog /Pages 376 0 R /Outlines 451 0 R >> endobj 512 0 obj << /Title <FEFF004400650073006100720072006F006C006C006F00200063006F006E00200069006E0076006500730066006C006F00770020004A0032004500450020002800530050004100430029> /Author <FEFF004C00690064006900610020004700610072006300ED00610020004D006F007200E1006E> /Creator <FEFF005700720069007400650072> /Producer <FEFF004F00700065006E004F00660066006900630065002E006F0072006700200032002E0030> /CreationDate (D:20070622000128+02'00'

javascript:generateDocuments('entityDocuments.do) >> >> endobj 375 0 obj << /Type /Annot /Subtype /Link /Border [0 0 0] /Rect [167.4 233.1 365.5 250.4] /A << /Type /Action /S /URI /URI (http://displaytag.sourceforge.net/) >> >> endobj 511 0 obj << /Type /Catalog /Pages 376 0 R /Outlines 451 0 R >> endobj 512 0 obj << /Title <FEFF004400650073006100720072006F006C006C006F00200063006F006E00200069006E0076006500730066006C006F00770020004A0032004500450020002800530050004100430029> /Author <FEFF004C00690064006900610020004700610072006300ED00610020004D006F007200E1006E> /Creator <FEFF005700720069007400650072> /Producer <FEFF004F00700065006E004F00660066006900630065002E006F0072006700200032002E0030> /CreationDate (D:20070622000128+02'00'

Avanza LOCAL SIGEM

public IItemCollection getDocTypesFromStage(int stageId)throws ISPACException;

• getDocumentType: Obtiene las propiedades de un tipo de documento.

public IItem getDocumentType(int typeId) throws ISPACException;

• getDocTypesFromTask: Obtiene la lista de tipos de documento que se pueden generar en el contexto de una tarea de un procedimiento.

public IItemCollection getDocTypesFromTask(int taskId) throws ISPACException;

• getTemplatesInStage: Obtiene la lista de plantillas de un tipo de documento generables en el contexto de una fase de un proceso.

public IItemCollection getTemplatesInStage(int docType, int stageId) throws ISPACException;

• getTemplatesInStages: Obtiene la lista de plantillas de un tipo de documento generables en el contexto de un conjunto de fases.

public IItemCollection getTemplatesInStages(int docType, int []stagesId) throws ISPACException;

• getTemplatesInTask: Obtiene la lista de plantillas de un tipo de documento generables en el contexto de una tarea de un proceso.

46/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

public IItemCollection getTemplatesInTask(int docType, int taskId) throws ISPACException;

• getTemplatesInTasks: Obtiene la lista de plantillas de un tipo de documento generables en el contexto de un conjunto de tareas.

public IItemCollection getTemplatesInTasks(int docType,int []tasksId) throws ISPACException;

• createStageDocument: Genera un tipo de documento en el contexto de una fase de un proceso. Devuelve la entidad del documento.

public IItem createStageDocument(int stageId,int docType)throws ISPACException;

• createTaskDocument: Genera un tipo de documento en el contexto de una tarea de un proceso. Devuelve la entidad del documento.

public IItem createTaskDocument(int taskId,int docType)throws ISPACException;

• attachStageTemplate: Anexa una plantilla a un documento en el contexto de una fase de proceso. Devuelve la entidad del documento.

public IItem attachStageTemplate(int stageId,int docId,int templateId)throws ISPACException;

47/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

3.4.1 Conectores de almacenamiento

Un conector de almacenamiento es cualquier clase java que implemente el interface estándar de ISPAC de acceso a repositorios: IdocConnector.

Todos los documentos se referencian mediante un GUID.

• ExistDocument: Devuelve verdadero si existe el documento en el gestor documental.

public boolean existsDocument(String sGUID) throws ISPACException;

• getDocument: Vuelca el contenido del documento en el stream out.

public void getDocument(String sGUID, OutputStream out) throws ISPACException;

• setDocument:Modifica el contenido del documento con los datos suministrados por el flujo de entrada in.

public void setDocument(String sGUID,InputStream in,int length, String sProperties) throws ISPACException;

• NewDocument: Crea un nuevo documento con el contenido del stream de datos in y devuelve el GUID asociado por el gestor documental. Las propiedades se pasan como una cadena de texto en formato XML.

48/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

public String newDocument(InputStream in, int length, String sProperties) throws ISPACException;

Documento XML de propiedades a modo de ejemplo:

<?xml version="1.0" encoding="ISO-8859-1"? ><properties> <document id='n'> <type>n</type>

<name><![CDATA[nombre del documento]]></name> </document> <procedure id='n'> <name><![CDATA[nombre del procedimiento]]></name> </procedure> <expedient id='n'> <name><![CDATA[nombre del expediente]]></name> </expedient> <user> <guid><![CDATA[GUID usuario]]></guid> <name><![CDATA[nombre del usuario]]></name> </user> <stage id='n'> <name><![CDATA[nombre de la fase]]></name> </stage> <task id='n'> <name><![CDATA[nombre de la tarea]]></name> </task> <mimetype> <name><![CDATA[nombre de la tarea]]></name> </mimetype> <sign> <value><![CDATA[valor firma]]></value> </sign></properties>

• deleteDocument:Elimina un documento.

public void deleteDocument(String sGUID) throws ISPACException;

• getDocumentSize:Obtiene el tamaño del documento.

49/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

public int getDocumentSize(String sGUID) throws ISPACException;

• getMimeType: Obtiene el mimetype de un documento.

public String getMimeType(String sGUID) throws ISPACException;

• createRepository: Crea la estructura del conector de almacenamiento.

public void createRepository() throws ISPACException;

50/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

3.5 La lista de trabajo

Se denominan listas de trabajos al acceso a las colas de fases y trámites por realizar los cuales son responsabilidad del usuario conectado. Dicha responsabilidad puede ser única (asignada directamente al responsable) o compartida (asignada a algún grupo o unidad organizativa a la que pertenezca el usuario.

Por tanto los métodos de lista de trabajo ofrecerán visiones distintas de los procesos en curso para cada usuario. Si se necesita acceder a los expedientes o procesos activos sin tener en cuenta la responsabilidad deben usarse los métodos implementados en el interfaz base IInvesflowAPI.

Todos los IItems que representan tanto procesos, fases y trámites obtenidos por medio de la lista de trabajo no son actualizables. Sus modificaciones de estado se realizan mediante el motor de transacciones con su API correspondiente ITXTransaction

• getProcedures: Devuelve la lista de procedimientos en los cuales existe algún proceso que sea responsabilidad del usuario conectado.

public abstract IItemCollection getProcedures() throws ISPACException;

51/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

• getStages:Devuelve la lista de fases de un procedimiento en las cuales existen expedientes pendientes con esa fase activa y además cuya responsabilidad recae en el usuario conectado.

public abstract IItemCollection getStages(int idProcedure) throws ISPACException;

• getProcesses: Obtiene la lista de expedientes de una fase todos los cuales son responsabilidad del usuario conectado.

public abstract IItemCollection getProcesses(int idStagePCD) throws ISPACException;

• getProcess(String): Devuelve el proceso identificado por su número de expediente si éste es responsabilidad del usuario.

public abstract IItem getProcess(String numexp) throws ISPACException;

• getProcess(int): Obtiene el expediente con el identificador especificado si éste es responsabilidad del usuario.

public abstract IItem getProcess(int id) throws ISPACException;

• getCreateProcedures: Devuelve la lista de procedimientos que puede iniciar el usuario conectado mediante la transacción createExpedient().

public abstract IItemCollection getCreateProcedures() throws ISPACException;

52/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

• findActiveStages: Busca en la lista de fases activas del proceso indicado y devuelve aquellas que son responsabilidad del usuario conectado.

public abstract IItemCollection findActiveStages(int nIdProcess) throws ISPACException;

• findActiveTasks: Busca en la lista de trámites activos del proceso indicado y devuelve aquellos que son responsabilidad del usuario conectado.

public abstract IItemCollection findActiveTasks(int nIdProcess) throws ISPACException;

• findStageActiveTasks: Busca en la lista de trámites activos dependientes de la fase indicada en el proceso indicado y devuelve aquellos que son responsabilidad del usuario conectado.

public abstract IItemCollection findStageActiveTasks(int nIdProcess,int IdStagePCD) throws ISPACException;

ISPAC v1.1

• getProcesses(int,String): Devuelve una lista de expedientes de la fase indicada los cuales son responsabilidad del usuario conectado. Opcionalmente los relaciona con otras entidades del expediente para obtener la lista con datos adicionales según lo indicado por el archivo XML de definición de listas de procesos.

53/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

public IItemCollection getProcesses(int idStagePCD,String processlistfmtpath)throws ISPACException

Ejemplo de definición de formato para la lista de trabajo:

<?xml version="1.0" encoding="ISO-8859-1"?><processlistformat>

<worklist name="WORKLIST"/>

<entity name="EXPED" entityid="1"/>

<!-- Tablas externas a relacionar con los expedientes.Este tag puede aparecer múltiples veces.


54/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

name - indica el prefijo que se quiere utilizar para diferenciar las propiedades de esta tabla

tablename - el nombre de la tabla que se quiere unir a la lista de trabajo.

numexpfield - el campo que contiene el número de expediente en dicha tabla.-->

<table name="TEST" tablename="TEST_TABLE" numexpfield="NUMEXP" />



<codetable name="SUST" table="SPAC_DT_CONCEJOS" code="VALOR" value="SUSTITUTO"><substitute name="EXPED" property="CONCEJO"/>

</codetable>



<query> WORKLIST.NUMEXP = 'EXP/386'</query>

<showfields>

<propertyfmt type="BeanPropertySimpleFmt"property='EXPED:NUMEXP' readOnly='false'title='Numexp' fieldType='DATA' />

<propertyfmt type="BeanPropertySimpleFmt"property='PROC:NOMBRE' readOnly='false'title='Procedimiento' fieldType='DATA' />

<propertyfmt type="BeanPropertySimpleFmt"property='SUST:EXPED:CONCEJO' readOnly='false'title='Nombre Concejo' fieldType='DATA' />

</showfields>

55/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

</processlistformat>

56/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

4 Desarrollo de reglas.

Una regla es cualquier clase que implementa el interface IRule y que se ejecuta como respuesta a un suceso (evento) que se produce en la tramitación o a petición del usuario.

Es mediante el uso de reglas como el desarrollador del procedimiento le incorpora la lógica particular, asociándolas a los distintos eventos de la tramitación.

4.1 Eventos

Los posibles tipos de eventos están definidos en la clase ieci.tdw.ispac.api.rule.EventsDefines.

Todo evento esta relacionado con alguno de los siguientes objetos de la tramitación:

• Proceso.

• Fase.

• Tarea.

• Plantilla.

• Entidad.

• Flujo.

57/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

Se producen como respuesta a uno de los siguientes sucesos en la tramitación de un expediente o proceso:

• Iniciar proceso, fase o tarea.

• Recorrer flujo.

• Cerrar fase o tarea.

• Cancelar proceso.

• Reactivar proceso.

• Reubicar proceso o fase.

• Fuera de plazo de proceso, tarea o fase.

• Cálculo de responsable del proceso.

• Cálculo del número de expediente.

• Borrar trámite.

• Crear documento.

• Anexar plantilla al documento.

• Anexar fichero al documento.

• Registro de entrada - Iniciar proceso.

• Registro de entrada - Anexar proceso.

58/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

4.2 Reglas

Las reglas implementan el interface IRule, en el que se definen las siguientes funciones:

public boolean init(IRuleContext rulectx) throws ISPACRuleException;

Método de inicialización de la regla. Se le pasa como parámetro un objeto que implementa el interface IRuleContext y que contiene el contexto en el que se ejecuta la regla.

El contexto depende del evento que la lanza la tarea:

• Identificador de procedimiento.

• Identificador de fase en el procedimiento.

• Identificador de tarea en el procedimiento.

• Identificador de proceso.

• Identificador de fase en el proceso.

• Identificador de tarea en el proceso.

• Número de expediente.

• Propiedades por nombre.

• ClientContext. Conexión del cliente con la base de datos, gestión de transacciones, variables de sesión, etc.

59/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

Si en la ejecución del método se produjeran errores, se debe lanzar obligatoriamente una excepción del tipo ISPACRuleExecption.

public boolean validate(IRuleContext rulectx) throws ISPACRuleException;

Valida la ejecución de la regla. Permite decidir por ejemplo si el usuario conectado puede ejecutarla, si se puede cerrar una fase o una tarea, recorrer un flujo, iniciar una tarea, etc.

Si el resultado de la validación es false, entonces la regla debe de informar de la causa llamando a la función del contexto de ejecución setInfoMessage.

El sistema obtiene esta información del contexto de ejecución de la regla, llamando a la función getInfoMessage.

public Object execute(IRuleContext rulectx) throws ISPACRuleException;

Este método ejecuta la acción asociada a la regla si el resultado de la validación es true. El resultado de la ejecución es un objeto de cualquier tipo o null.

Si la regla esta asociada a un tag de una plantilla, entonces el valor devuelto tiene que ser un objeto String. El texto del String sustituirá al texto del tag.

public void cancel(IRuleContext rulectx) throws ISPACRuleException;

El método cancel se ejecuta cuando el sistema tiene problemas al ejecutar la acción asociada a la regla. Permite deshacer las operaciones realizadas en el método execute().

60/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

public class IniciarExpediente implements IRule { public boolean init(IRuleContext rulectx) throws ISPACRuleException { return true; }

public boolean validate(IRuleContext rulectx) throws ISPACRuleException { return true; }

public Object execute(IRuleContext rulectx) throws ISPACRuleException { try { IClientContext clientContext = rulectx.getClientContext(); IInvesflowAPI invesFlowAPI = clientContext.getAPI(); IEntitiesAPI entitiesAPI = invesFlowAPI.getEntitiesAPI();

// Obtiene los datos del expediente IItem expedient = entitiesAPI.getExpedient(rulectx.getNumExp()); // Obtiene los datos del procedimiento IProcedure procedure = invesFlowAPI.getProcedure(rulectx.getProcedureId()); // Inicializar propiedades de la entidad del expediente expedient.set(PropName.EXP_ID_PCD, procedure.getId()); expedient.set(PropName.EXP_ASUNTO, procedure.getNombre()); expedient.store(clientContext); } catch (ISPACException e) { throw new ISPACRuleException(e); }

return null; }

public void cancel(IRuleContext rulectx) throws ISPACRuleException {}

61/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

5 Particularización tramitador

La aplicación de tramitación está diseñada para permitir su personalización, adaptación y extensión a las necesidades particulares de cada proyecto o implantación.

Debido a los requisitos de flexibilidad y extensibilidad existentes en la aplicación de tramitación se ha construido una nueva capa, orientada a la web, donde se encuentra la funcionalidad base necesaria para su implementación. Cabe notar que aunque se trate de una nueva capa ésta forma parte integrante del framework de ISPAC.

62/89

Avanza LOCAL SIGEM

Framework Base ISPAC

Framework Web ISPAC

DecoradoresAPI deTramitación

Gestor WebDAV

Aplicaciones/Formularios

Librerias tags/AJAX

Aplicación Web (Tramitador)

Avanza LOCAL SIGEM

Todo el conjunto de componentes y módulos para el desarrollo web cumple los siguientes objetivos:

• Facilitar el cambio de conducta y de apariencia de la aplicación.

• Diseño declarativo del comportamiento de la aplicación (decoradores) para que los cambios necesarios sean mínimos

• Servir de base para construir otros tramitadores o aplicaciones web específicas con necesidades de acceso a la gestión de expedientes

63/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

5.1 El objeto de presentación: ItemBean

Según las especificaciones de J2EE y Struts es imprescindible que los datos a presentar estén representados mediante un JavaBean estándar.

ItemBean cumple el objetivo de servir de nexo de unión entre la capa de negocio y la de presentación, envolviendo el objeto IItem y presentándolo mediante una capa de acceso estándar JavaBean implementada en la clase abstracta ObjectBean.

Además el ItemBean puede servir para construir y refinar la presentación de los datos del IItem añadiendo propiedades nuevas de interés para el interface web.

ObjectBean

Proporciona una implementación base para obtener y cambiar el valor de propiedades siguiendo las directrices de los objetos JavaBean. Se utiliza normalmente para construir páginas JSP.

64/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

public abstract class ObjectBean{

//Obtiene el valor de la propiedad identificada por su nombre: keyname.public abstract Object getProperty(String keyname) throws ISPACException;

//Almacena un objeto para la propiedad de nombre keypublic abstract void setProperty(String key, Object value)throws ISPACException;

}

ItemBean

Implementación especifica de ObjectBean para recubrir el acceso a un objeto IItem.Si la propiedad solicitada para asignar un valor no existe en el IItem, el ItemBean crea una nueva y la guarda en un conjunto de propiedades aparte. De esta forma se puede extender y complementar con propiedades de presentación los propios datos del IItem.

class ItemBean extends ObjectBean{IItem mitem;HashMap valuesExtra;

[...]public Object getProperty(String keyname) throws ISPACException {

if (mitem.getProperty(keyname) != null)return mitem.get(keyname);

elsereturn valuesExtra.get(keyname);

}

public void setProperty(String key, Object value) throws ISPACException {

if (mitem.getProperty(key) != null) mitem.set(key,value);

elsevaluesExtra.put(key,value);

}[...]}

65/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

En la mayoría de los casos la implementación por defecto de ItemBean es suficiente y no haría falta crear ningún otro bean para ello.

En el siguiente ejemplo se va a definir un nuevo bean en el que se desea añadir nuevas propiedades calculadas a partir de las ya existentes en el IItem.

/* Añade dos propiedades nuevas resultado de la traducción de propiedades númericas a su representación textual: ESTADO_AVISO en ESTADO_AVISO_TEXT TIPO_AVISO en TIPO_AVISO_TEXT*/

public class NotificationBean extends ItemBean{ public static HashMap ESTADOAVISOMAP = new HashMap(); public static HashMap TIPOAVISOMAP = new HashMap();

static { ESTADOAVISOMAP.put(null,"Desconocido"); ESTADOAVISOMAP.put("0","Pendiente"); ESTADOAVISOMAP.put("1","En curso"); ESTADOAVISOMAP.put("2","Tratado");

TIPOAVISOMAP.put(null,"Desconocido"); TIPOAVISOMAP.put("1","SPAC"); TIPOAVISOMAP.put("2","Registro"); } //En la versión 1.1 del framework es mejor utilizar el método processItem(...) public void processItem(IItem item) throws ISPACException {

String estadoAviso=(String)ESTADOAVISOMAP.get(item.getString("ESTADO_AVISO"));String tipoAviso=(String)TIPOAVISOMAP.get(item.getString("TIPO_AVISO"));setProperty("ESTADO_AVISO_TEXT",estadoAviso);setProperty("TIPO_AVISO_TEXT",tipoAviso);mitem = item;

}}

66/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

CollectionBean

CollectionBean toma una colección de items IItemCollection y la convierte en una lista o mapa de ItemBean o cualquier otra clase derivada de él.

Ejemplos:

IWorklistAPI worklist = invesflowAPI.getWorkListAPI();IInboxAPI inbox = invesflowAPI.getInboxAPI();

// Obtener una lista de procedimientos activos y convertirlos a un// ItemBeanIItemCollection collection = worklist.getProcedures();List beanlist = CollectionBean.getBeanList(ItemBean.class,collection);// beanlist es ya una lista estándar de objetos JavaBean.request.setAttribute("ProceduresList", list);

// Por simplicidad también se puede omitir la clase si se trata de un// ItemBeanbeanlist = CollectionBean.getBeanList(collection);request.setAttribute("ProceduresList", list);

// Ahora utilizando el ItemBean definido en el ejemplo anterior: NoticeBean.collection = inbox.getNotices();beanlist = CollectionBean.getBeanList(NoticeBean.class, collection);request.setAttribute("NoticesList", beanlist);

67/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

5.2 El objeto decorador

El decorador o formateador permite definir de forma declarativa no sólo la presentación de los objetos de negocio si no también modificar su comportamiento.

Un decorador o formateador se compone de una lista de objetos decoradores de propiedades (BeanPropertyFmt) que contienen la información necesaria para su presentación. Ya se encuentran implementados decoradores como BeanPropertySimpleFmt que no procesa de ninguna forma el valor de la propiedad asignada y BeanPropertyDateFmt que utiliza el atributo format para obtener correctamente la representación de la fecha.

Los decoradores se pueden crear mediante sentencias que tienen en cuenta el estado de la tramitación como ocurre en la acción ShowProcessListAction o a partir de un documento XML con su definición:

CacheFormatterFactory factory = CacheFormatterFactory.getInstance();BeanFormatter formatter =

factory.getFormatter(getISPACPath("/digester/infoformatter.xml"));// Salva el decorador en la peticiónrequest.setAttribute("Formatter", formatter);

El documento XML con la definición de un decorador presenta la siguiente estructura:

68/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

<?xml version="1.0" encoding="ISO-8859-1"?><beanformatter>

<propertyfmt type="BeanPropertySimpleFmt" property='NUMEXP' readOnly='false' title='Expediente' fieldType='LIST'/>

<propertyfmt type="BeanPropertySimpleFmt" property='ASUNTO' readOnly='false' title='Asunto' fieldType='LIST'/>

<propertyfmt type="BeanPropertyDateFmt" property='FESTADO' readOnly='false' format='dd-MM-yyyy' title='Fecha de inicio' fieldType='LIST'/>

<propertyfmt type="BeanPropertyDateFmt" property='FREG' readOnly='false' format='dd-MM-yyyy' title='Fecha límite' fieldType='LIST'/>

</beanformatter>

tag propertyfmt

Se pueden declarar los siguientes atributos:

• type

El tipo de decorador que se desea para visualizar el el tipo de dato. Puede ser por ejemplo, BeanPropertySimpleFmt para datos numéricos y caracteres o BeanPropertyDateFmt para datos del tipo fecha.

• property

Nombre de la propiedad a visualizar.

69/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

• format

Formato de la propiedad si es del tipo fecha o numérico. En cualquiera de los casos.

• title

Título de la propiedad.

• fieldType

Tipo de campo. Sus valores dependen de la implementación particular del JSP. Para JSP estándar de invesflow Java suelen tomar los valores LIST, LINK, CHECKBOX, etc.

• styleClass

Estilo CSS a aplicar.

• width

Anchura del campo.

• headerClass

Estilo CSS de la cabecera cuando el decorador se utiliza dentro de un tag display.

• sortable

Indica si el campo se ordena cuando el decorador se utiliza dentro de

70/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

un tag display. Los posibles valores son true/false.

• media

Formatos a los que se permite exportar el contenido del campo cuando el decorador se utiliza dentro de un tag display.Pueden ser una cadena con los valores html csv excel xml pdf separados por comas.

• url

URL base si se desea realizar un link.

• id

Nombre del parámetro que se añade a la URL.

• fieldLink

El nombre de la propiedad que contiene el dato a incluir en el enlace.

Un ejemplo del decorador lo podemos ver en la página jsp/ispac/common/expList.jsp en la que se utiliza para decidir que campos se van a visualizar de forma tabular utilizando la libreria de tags display (http://displaytag.sourceforge.net).

5.3 Modificación acciones estándar

71/89

Avanza LOCAL SIGEM

http://displaytag.sourceforge.net/

Avanza LOCAL SIGEM

La funcionalidad base del tramitador estándar está implementada mediante un conjunto de acciones Struts.

Una acción iSPAC es una clase Java que extiende de la clase base BaseAction la cual a su vez implementa una acción clásica de Struts. Por tanto tiene que implementar la función executeAction:

public ActionForward executeAction( ActionMapping mapping, ActionForm form, HttpServletRequest request,

HttpServletResponse response, SessionAPI session) throws Exception;

Recibe como parámetros, entre otros, el formulario Struts asociado y la sesión del cliente ya conectado.

El formulario es el objeto que actúa como interface entre las propiedades de la aplicación y la página JSP de presentación.

A modo de ejemplo se va a crear una acción en la cual se va a mostrar la lista de procedimientos en los cuales el usuario tiene alguna tarea por realizar:

72/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

Código de la acción

public class ProceduresListAction extends BaseAction{ public ActionForward executeAction( ActionMapping mapping,

ActionForm form, HttpServletRequest request, HttpServletResponse response, SessionAPI session) throws Exception

{ IClientContext cct = session.getClientContext();

IInvesflowAPI invesflowAPI = session.getAPI(); IWorklistAPI worklist = invesflowAPI.getWorkListAPI();

IManagerAPI managerAPI = ManagerAPIFactory.getInstance().getManagerAPI(cct);

// Decoradores.CacheFormatterFactory factory = CacheFormatterFactory.getInstance();BeanFormatter formatter = factory.getFormatter(getISPACPath

("/digester/proceduresformatter.xml"));request.setAttribute("FormatterPcd", formatter);

//Listado de procedimientoscollection = worklist.getProcedures();list = CollectionBean.getBeanList(collection);request.setAttribute("ProceduresList", list);

return mapping.findForward("success"); }};

73/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

Decorador asociado a la acción

<?xml version="1.0" encoding="ISO-8859-1"?><beanformatter>

<propertyfmt type="BeanPropertySimpleFmt" property='NOMBRE' readOnly='false' title='Expediente' fieldType='LINK'/> styleClass='pcdStyle' url='showStagesList.do' id='pcdId'/>

</beanformatter>

Página JSP asociada a la acción

<table><logic:iterate id="item" name="ProceduresList"

type="ieci.tdw.ispac.ispaclib.bean.ItemBean"> <tr> <logic:iterate id="format" name="FormatterPcd"

type="ieci.tdw.ispac.ispaclib.bean.BeanPropertyFmt">

<logic:equal name="format" property="fieldType" value="LINK"> <td>

<html:link action='<%=format.getUrl()%>' styleClass='<%=format.getStyleClass()%>' paramId='<%=format.getId()%>' paramName="item"

paramProperty='<%=format.getPropertyLink()%>'> <bean:write name="format"

property='<%=format.prepareFormat(item)%>'/> </html:link> </td></logic:equal>

<logic:equal name="format" property="fieldType" value="DATA"> <td class='<%=format.getStyleClass()%>'>

<bean:write name="format" property='<%=format.prepareFormat(item)%>'/>

</td></logic:equal>

</logic:iterate> </tr></logic:iterate></table>

74/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

5.4 Librería de tags J2EE

Tags iSPAC

Tag keepalive

Este tag tiene como finalidad mantener activa la sesión HTTP y el contexto de ejecución del usuario conectado mientras esté abierta la aplicación.

Una vez que se ha incluido el tag en una página JSP, al cargarse en el explorador, la página realiza peticiones al servlet keepalivesession a intervalos de tiempo definidos en el fichero de propiedades de la aplicación:

KEEP_ALIVE = 60000

Cada petición inicializa el tiempo de inactividad del usuario conectado. Para que el tag funcione correctamente es necesario declarar el servlet en el fichero web.xml de la aplicación web.

Tag getdocument

Permite definir un interfaz para editar un documento mediante MSWord desde el explorador.

Atributos:

• document: identificador del registro de la entidad de documentos.

75/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

• image: imagen de presentación asociada al interfaz.

• message: clave del recurso de texto asociado al interfaz.

• styleClass: estilo de presentación del texto.

• target: nombre del iframe contra el que se ejecuta la acción getdocument.do que carga el documento.

Esta acción genera un documento HTML que al cargarse instancia un objeto Word.Application. El objeto Word abre el documento mediante el metodo open al que se le pasa como parámetro una URL que implementa el protocolo WEBDAV.

Para que el tag funcione es necesario declarar el servlet storage en el fichero web.xml de la aplicación:

<servlet> <servlet-name>storage</servlet-name>

<servlet-class>ieci.tdw.ispac.ispacmgr.webdav.servlets.StorageServlet</servlet-class>

<init-param> <param-name>debug</param-name> <param-value>999</param-value> </init-param> </servlet>

<servlet-mapping> <servlet-name>storage</servlet-name> <url-pattern>/storage/*</url-pattern> </servlet-mapping>

Tags iSPAC v1.1

76/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

Tag de base que se utiliza como interfaz entre el formulario activo y la acción que se quiere realizar. Sobre él se construyen dos tipos distintos de tags: imageframe y linkframe.

Tags actionframe: imageframe y linkframe

• id: nombre del tag.

• target: nombre del iframe contra el que se ejecuta la acción.

• action: Acción asociada a la ejecución de tag.

• image: Imagen asociada al tag cuando se trata de un imageframe.

• titleKey: Clave del mensaje que se visualiza al situarse sobre la imagen.

• showFrame: true si la acción muestra interface.

• inputField: Nombre de la propiedad del formulario que se utiliza como parámetro de entrada. Se pasa con el nombre de parámetro 'field' en la URL asociada a la acción.

Tag parameter

En el cuerpo de los tag actionframe se definen los tag parameter cuya función es asociar una propiedad del formulario activo con una propiedad del bean intermedio que se obtiene como resultado de ejecutar la acción designada. Se deben declarar tantos tags como propiedades del formulario se quieran modificar.

El conjunto de todos los tags parameter constituye un mapa que se guarda como una variable de sesión y cuyo nombre se pasa como el mbre de parámetro parameter en la URL asociada a la acción.

77/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

• name: Nombre del actionframe al que se asocia.

• id: Nombre de la propiedad del formulario.

• property: Nombre del propiedad del bean intermedio cuyo valor sustituye al valor de la propiedad del formulario.

Tag updatefields

Vuelca las propiedades del bean intermedio en el formulario. Se debe declarar en la página jsp que se ejecuta como respuesta a la acción de los tags actionframe.

• name: Nombre del bean intermedio.

• parameters: Nombre del mapa que contiene la definición de los parámetros.

Los atributos id del tag actionframe, name del tag parameter y parameters del tag updatefields tienen que coincidir.

Tag hideframe

Oculta el interfaz una vez que se haya ejecutado la acción.

• event: true por defecto e indica que el código asociado al tag está asociado a un evento javascript:

onclick='<ispac:hideframe/>'.

78/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

En la página JSP /forms/expedientform.jsp se tiene un ejemplo de utilización del tag imageframe para obtener un valor sustituto.

<html:hidden property="property(SPAC_EXPEDIENTES:CONCEJO)"/> <html:text property="property(SPAC_DT_CONCEJOS:SUSTITUTO)" styleClass="inputReadOnly" readonly="true" size="30"/>

<ispac:imageframe id="SPAC_DT_CONCEJOS" target="workframe" action="selectSubstitute.do?entity=8" image="img/search-mg.gif" titleKey="select.concejo" showFrame="true" inputField="property(SPAC_EXPEDIENTES:CONCEJO)">

<ispac:parameter name="SPAC_DT_CONCEJOS" id="property(SPAC_EXPEDIENTES:CONCEJO)" property="VALOR"/>

<ispac:parameter name="SPAC_DT_CONCEJOS" id="property(SPAC_DT_CONCEJOS:SUSTITUTO)" property="SUSTITUTO"/>

</ispac:imageframe>

El valor del campo de entrada se puede obtener en la acción con la siguiente instrucción.

String field = request.getParameter("field");

Como se puede comprobar en la url asociada a la acción se puede pasar tantos parámetros como se desee.

Para obtener los parámetros del tag parameter en la acción y pasárselos a la página JSP donde se ejecuta el tag updatefields:

79/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

// Nombre de la variable de sesión ispac que contiene los parámetros del tag String parameters = request.getParameter("parameters");

// Obtiene el documento XML que describe la structura de parámetros String sParameters = session.getClientContext().getSsVariable( parameters);

// Convierte el documento XML en un mapa y lo guarda en la petición if (sParameters != null) request.setAttribute(parameters, ActionFrameTag.toMap( sParameters));

80/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

6 Desarrollo de aplicaciones(formularios)

La aplicación o formulario añade la lógica de negocio y relaciona el IItem, el decorador encargado de la lógica de presentación de los datos y la página JSP donde se visualizan los datos.

81/89

Avanza LOCAL SIGEM

Código generado

EntityForm

OrigenDatos

Frm simple

Frm maestro/detalle

Cargar,Guardar

EntityApp IItem

CustomEntityApp

Avanza LOCAL SIGEM

6.1 Creación de aplicaciones

6.1.1 EntityApp

La clase java asociada a la aplicación o formulario extiende de la clase abstracta EntityApp. Su funcionalidad es la de servir como interfaz entre el formulario Struts asociado a la acción y los campos del formulario htm asociados a la página JSP.

Una aplicación EntityApp es también un objeto ItemBean por tanto permite extenderlo con la funcionalidad requerida para su presentación.

En el código asociado a la acción ShowExpedientAction, se puede observar como el sistema obtiene la aplicación asociada a la entidad en que se encuentra el estado de tramitación y como la asocia con formulario de entidad.

IInvesflowAPI invesFlowAPI = session.getAPI();

IEntitiesAPI entitiesAPI = invesFlowAPI.getEntitiesAPI();

// Acceso al esquema

IScheme scheme = managerAPI.getSchemeAPI();

// Formulario Struts asociado a la acción

EntityForm defaultForm = (EntityForm) form;

// Obtiene la aplicación asociada de acuerdo al estado de tramitación.

EntityApp entityApp = scheme.getDefaultEntityApp(state);

// Vuelca los datos de la aplicación en el formulario Struts

defaultForm.setEntityApp(entityApp);

82/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

...

// Página jsp asociada a la presentación de los datos

String strURL = entityApp.getURL();

// Cambia la página jsp asociada al tile

request.setAttribute("application", strURL);

return mapping.findForward("success");

Para crear el objeto, el framework instancia la clase asociada a la aplicación y completa su estado llamando a los siguientes métodos:// Identificador de la aplicación

setAppId(appId)

// Nombre de la aplicación (relacionada con la validación Struts)

setAppName(sAppName)

// Página jsp encargada de la presentación de los datos

setURL( sURL)

// Objeto Iitem con los datos de la entidad

setItem( item)

// Identificador de la entidad

setMainEntity( entityId);

// Párametros asociados a la creación de la aplicación

setParameters( sParameters);

// Decorador asociado a la presentación de los datos

setFormatter( sFormatter);

Todos estos métodos tienen ya una implementación por defecto en la clase base. Las clases derivadas tienen, no obstante, que implementar obligatoriamente las siguientes:

83/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

//Inicialización de la aplicaciónpublic abstract void initiate() throws ISPACException;

//Validación previa en el servidor antes de guardar los datospublic abstract boolean validate() throws ISPACException;

//Cambiar un valor de la aplicaciónpublic abstract void setValue( String key, String value) throws ISPACException;

//Obtener un valor de la aplicaciónpublic abstract String getValue( String key) throws ISPACException;

Como ejemplo práctico se pueden observar las clases SimpleEntityApp que gestionan una aplicación con un único objeto IItem de una entidad; y la clase CompositeEntityApp que gestiona una aplicación con un objeto IItem de una entidad principal y un segundo objeto IItem de una entidad relacionada definido como parámetros en un XML. La clase SimpleEntityApp puede usarse como punto de partida para desarrollar aplicaciones con funcionalidad específica.

Ejemplo:

public class SimpleEntityApp extends EntityApp{ public SimpleEntityApp(ClientContext context) {super(context);}

public boolean validate() throws ISPACException { return true;}

public void initiate() throws ISPACException {}

public void setValue( String key, String value) throws ISPACException{try{ Property property = (Property) mitem.getProperty(key); if (property != null) {

//Se obtiene el valor adecuado al tipo de la propiedadObject object = TypeConverter.parse(property.getType(),value);mitem.set( key, object);

}}

84/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

catch(ISPACException ie){

throw new ISPACException("La propiedad " + property.getName() + "no admite el valor " + value,ie);

} }

public String getValue( String key) throws ISPACException {return mitem.getString( key);

}}

La inicialización de la aplicación se realiza en la ejecución de la función initiate. La entidad relacionada la obtiene explorando el documento XML asociado a los parámetros de la aplicación.

En la acción StoreEntityAction la aplicación asociada actúa como interfaz entre el formulario Struts y el framework. Así sólo es necesario un único formulario Struts (EntityForm, DefaultForm en ISPAC 1.02) y un par de acciones genéricas para cargar y guardar todas los datos de todas las aplicaciones.

IScheme scheme=managerAPI.getSchemeAPI();EntityForm defaultForm = (EntityForm) form;// Obtiene la aplicación asociada al estadoEntityApp entityApp = scheme.getEntityApp(state);[...]// Vuelca el contenido del formulario Struts en la aplicacióndefaultForm.processEntityApp(entityApp);if (!entityApp.validate()){

// Construye los mensajes de error}else{

// Guarda los datosentityApp.store();

}

85/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

6.1.2 Formulario JSP

La página JSP se encarga de la presentación de los datos obtenidos por la aplicación. El acceso a los datos expuestos es el mismo utilizado por Struts: se define una acción y se le asigna el formulario Struts que va utilizar (EntityForm) y con que nombre (en general: defaultForm) se va a referenciar desde los tags utilizados en la página JSP.

El objeto aplicación EntityApp es accesible desde la página JSP ya que EntityForm lo guarda como una propiedad más. Se puede acceder por tanto de la siguiente forma:

<bean:define id="entapp" name="defaultForm" property="entityApp" />

Las propiedades se obtienen del formulario Struts asociado a la acción que ya ha sido cargado con los datos adecuados proporcionados por la aplicación correspondiente (EntityApp).

En las primeras líneas del formulario asociado a la página JSP se mantienen las propiedades de contexto de la aplicación.

<html:form action="storeEntity.do"><html:hidden property="entityAppName"/><html:hidden property="entity"/><html:hidden property="key"/><html:hidden property="readonly"/>

[...]</html:form>

86/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

El resto de propiedades de la aplicación son accesibles desde la página mediante el siguiente tag:

<html:text property="property(NOMBRE)"/>

Estas propiedades se mantienen en el formulario EntityForm asociado a la acción como un mapa de objetos llamado property. Los objetos del mapa están referenciados por el nombre de la propiedad que representan.

Es responsabilidad de la aplicación asignar el nombre a cada una de las propiedades. Si la aplicación es del tipo SimpleEntityApp el nombre de la propiedad es el nombre del campo, pero si la entidad utiliza agregados (ver CompositeItem) entonces el nombre de cada propiedad tiene que estar cualificado por un prefijo seguido del nombre de la propiedad.

public class ExpedienteFacturaApp extends SimpleEntityApp {

public IItem processItem(IItem item) throws ISPACException {

//Crea un agregado para editar conjuntamente los datos de un expediente//junto con los de la factura asociadaCompositeItem composite = new CompositeItem("EXPEDIENTES:ID");composite.addItem(item, "EXPEDIENTES:");

return composite; }

public void initiate() throws ISPACException {

IItem item = getAsociatedEntity(Entidades.FACTURAS);((CompositeItem) mitem).addItem(item, "FACTURAS:");

}

87/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

protected IItem getAsociatedEntity(int entityId) throws ISPACException { IEntitiesAPI entitiesAPI = mContext.getAPI().getEntitiesAPI ();

// Si no tiene asociada una factura se devuelve un Item vacío. if (getItem().get("EXPEDIENTES:ID_FACTURA") == null) return entitiesAPI.getEntity(entityId);

int billId = getItem().getInt("EXPEDIENTES:ID_FACTURA"); return entitiesAPI.getEntity(billId);

}}

Una vez creado el agregado en la aplicación se pueden referenciar las propiedades de uno u otro IItem utilizando el prefijo correspondiente.

<html:text property="property(EXPEDIENTES:NOMBRE)"/>

<html:text property="property(FACTURAS:IMPORTE)"/>

Cuando la página JSP visualiza una lista de objetos IItem en una tabla, la acción asociada puede crear un objeto decorador para decidir que propiedades son las que se van a visualizar.

Ejemplo: Implementación de la relación maestro-detalle entre un expediente y sus facturas.

public class ExpedienteFacturaApp extends SimpleEntityApp {[...]//Método getter en ExpedienteFacturaApppublic List getDetalleFacturasList() throws ISPACException {

IEntitiesAPI entitiesAPI = mContext.getAPI().getEntitiesAPI (); IitemCollection itemcol = entitiesAPI.queryEntities(Entidades.FACTURAS,

"WHERE ID = " + getItem().getString("EXPEDIENTES:ID"));

88/89

Avanza LOCAL SIGEM

Avanza LOCAL SIGEM

return CollectionBean.getBeanList(itemcol);}[...]};

Ejemplo de acceso a la lista desde la página:

<bean:define id="entapp" name="defaultForm" property="entityApp" /><bean:define id="BillList" name="entapp" property="detalleFacturasList" /><bean:define id="BillFormatter" name="defaultForm" property="formatter" />

89/89

Avanza LOCAL SIGEM