FACULTAD DE INGENIERÍA INGENIERIA DE SISTEMAS …pegasus.javeriana.edu.co/.../Manuales/Manual_de_Mantenimiento.pdf · Ilustración 23 Contenido de una Clase Java ... Ilustración

FACULTAD DE INGENIERÍA INGENIERIA DE SISTEMAS

Trabajo de Grado:

SISINFOCOOP: Prototipo de un Sistema de Información para la administración de datos en una

Cooperativa multiactiva con sección de crédito y aportes

Documento:

Manual de Mantenimiento de la aplicación SISINFOCOOP

Oscar Javier Rey Caro

[email protected]

Tabla de Contenido Tabla de Contenido ............................................................................................................................2

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

1 Pre-requisitos .............................................................................................................................7

2 Diagrama de Entidades de Negocio ............................................................................................8

3 Roles .........................................................................................................................................11

4 Estructura de carpetas del proyecto en el IDE..........................................................................12

4.1 Proyecto-ear .....................................................................................................................12

4.2 Proyecto-ejb .....................................................................................................................13

4.3 Proyecto-war ....................................................................................................................19

4.3.1 Descriptor pom.xml ..................................................................................................23

4.3.2 Paginas XHTML .........................................................................................................25

5 Estrategia de programación de los CRUD .................................................................................29

5.1 Creación de Capas ............................................................................................................30

5.1.1 Modelo .....................................................................................................................30

5.1.2 DAO ..........................................................................................................................30

5.1.3 ManageBean o Control .............................................................................................31

5.1.4 Vista ..........................................................................................................................33

5.2 Utilización de PrimeFaces .................................................................................................34

5.2.1 Componentes Utilizados ...........................................................................................34

5.2.2 Create .......................................................................................................................34

5.2.3 Read ..........................................................................................................................35

5.2.4 Update ......................................................................................................................35

5.2.5 Delete .......................................................................................................................36

5.2.6 Búsquedas ................................................................................................................36

5.3 Casos de uso .....................................................................................................................37

5.3.1 Caso De Uso: Modulo Seguridad ..............................................................................37

5.3.2 Caso De Uso: Modulo Administración ......................................................................38

5.3.3 Caso De Uso: Modulo Asociados ..............................................................................41

5.3.4 Caso De Uso: Modulo Crédito ...................................................................................42

5.3.5 Caso De Uso: Modulo Transacciones ........................................................................44

5.3.6 Caso De Uso: Modulo Reportes ................................................................................46

6 Casos de Uso de Negocio .........................................................................................................48

6.1 Nombre del caso de uso Registrar Transacción Crédito ...................................................48

6.1.1 Descripción del caso de uso ......................................................................................48

6.1.2 Entidades ..................................................................................................................48

6.1.3 Flujo de negocio en términos de páginas y acciones ................................................49

6.1.4 Especificación de las acciones del caso de uso .........................................................51

6.1.5 Especificación de las páginas del caso de uso ...........................................................52

6.2 Nombre del caso de uso Transacción de aporte ...............................................................54


6.2.2 Entidades ..................................................................................................................54




6.3 Nombre del caso de uso Documento Contable ................................................................63


6.3.2 Entidades ..................................................................................................................63




Tabla de Ilustraciones Ilustración 1 Modelo ERD de SISINFOCOOP .......................................................................................8

Ilustración 2 Estructura de Carpetas ................................................................................................12

Ilustración 3 Descriptor de despliegue pom.xml del paquete proyecto-ear ....................................12

Ilustración 4 Estructura carpeta Proyecto-ejb ..................................................................................13

Ilustración 5 Carpetas java y resources ............................................................................................13

Ilustración 6 Descriptor pom.xml .....................................................................................................14

Ilustración 7 Clases que heredan de la clase Genérico .....................................................................16

Ilustración 8 Clases tipo enum .........................................................................................................17

Ilustración 9 Entidades del Sistema ..................................................................................................18

Ilustración 10 Clases de servicio .......................................................................................................19

Ilustración 11 Estructura módulo WAR ............................................................................................20

Ilustración 12 Backing Beans del sistema .........................................................................................21

Ilustración 13 Clases converter ........................................................................................................22

Ilustración 14 Clases utilitarias .........................................................................................................23

Ilustración 15 Descriptor pom.xml ...................................................................................................25

Ilustración 16 Estructura war – xhtml ..............................................................................................26

Ilustración 17 Contenido de la Carpeta Pages ..................................................................................26

Ilustración 18 Contenido de la carpeta resources ............................................................................27

Ilustración 19 Carpeta templates .....................................................................................................28

Ilustración 20 Carpeta WEB-INF .......................................................................................................28

Ilustración 21 Raíz de la Carpeta webapp ........................................................................................29

Ilustración 22 Estructura generación CRUD .....................................................................................29

Ilustración 23 Contenido de una Clase Java .....................................................................................30

Ilustración 24 Búsqueda por filtros ..................................................................................................37

Ilustración 25 Diagrama Caso de Uso - Modulo Seguridad ...............................................................38

Ilustración 26 Diagrama Caso de Uso - Modulo Seguridad ...............................................................38

Ilustración 27 Diagrama Caso de Uso - Modulo Administración ......................................................39




Ilustración 31 Diagrama Caso de Uso - Modulo Asociados ...............................................................41

Ilustración 32 Diagrama Caso de Uso - Modulo Asociados ...............................................................42

Ilustración 33 Diagrama Caso de Uso - Modulo Crédito ...................................................................43

Ilustración 34 Diagrama Caso de Uso - Modulo Crédito ...................................................................44

Ilustración 35 Diagrama Caso de Uso - Modulo Transacciones ........................................................45



Ilustración 38 Diagrama Caso de Uso - Modulo Reportes ................................................................47

Ilustración 39 Entidades participantes del caso de uso ....................................................................49

Ilustración 40 Grafo de páginas y acciones ......................................................................................50

Ilustración 41 TransaccionCreditoEJB ...............................................................................................51

Ilustración 42 Clase generico ............................................................................................................51

Ilustración 43 Clase TransaccionCreditoBean ...................................................................................52

Ilustración 44 Página Principal del módulo transacciones................................................................53

Ilustración 45 Pagina transaccion-vredito.xhtml ..............................................................................53

Ilustración 46 Diagrama entidades participantes del CU ..................................................................55

Ilustración 47 Grafo de páginas y acciones ......................................................................................56

Ilustración 48 Clase transaccionAporteEJB .......................................................................................57


Ilustración 50 Clase TransaccionAporteBean ...................................................................................58

Ilustración 51 Página principal.xhtml del módulo transacciones .....................................................59

Ilustración 52 Pagina transacion-aporte.xhtml del módulo transacciones .......................................59







Ilustración 59 Entidades del caso de uso ..........................................................................................63

Ilustración 60 Pagina principal.xhtml modulo transacciones ...........................................................64

Ilustración 61 Clase DocumentoContableEJB ...................................................................................65


Ilustración 63 Clase DocumentoContableBean ................................................................................67

Ilustración 64 Página principal del Módulo Transacciones "principal.xhtml" ...................................68

Ilustración 65 Pagina documento-contable.xhtml............................................................................68

Introducción

SISINFOCOOP, es un sistema de información para la administración de datos en una Cooperativa

multiactiva con sección de crédito y aportes. El sistema está compuesto por 6 módulos, que

prestarán distintos servicios de acuerdo al rol asignado a cada usuario. Básicamente permite el

ingreso, validación e impresión de la información correspondiente a Asociados, Créditos y Aportes.

El presente manual pretende dar algunos conceptos básicos, para hacer modificaciones,

actualizaciones al código; para ello se describirán conceptos de código, implementaciones,

herencias y demás información relevante para poder hacer una modificación satisfactoria.

Según la terminología ANSI-IEEE, el mantenimiento del software es: “la modificación de un

producto software después de su entrega al cliente o usuario para corregir defectos, para mejorar

el rendimiento u otras propiedades deseables, o para adaptarlo a un cambio de entorno”.

Este manual está dirigido a estudiantes de ingeniería de sistemas, ingenieros de sistemas y todo

aquel que cuente con conocimientos básicos de programación y de sistemas de información.

El propósito de este documento es dar a conocer la estructura del proyecto dentro del ambiente

de desarrollo, para realizar cambios, actualizaciones, o cualquier tipo de intervención sobre el

código en cualquiera de sus capas o componentes.

1 Pre-requisitos

Antes de iniciar a realizar cualquier modificación, le recomendamos leer este manual, para evitar

cambios no deseados, que puedan afectar el rendimiento del prototipo o que dejará de funcionar.

Para ello usted debe tener instalado eclipse luna, el respectivo servidor wildfly entre otras

herramientas, para ello ver el (Anexo. Manual Instalación Herramientas desarrollo) donde se

explica la instalación de las herramientas necesarias para llevar a cabo alguna modificación sobre

el código.

2 Diagrama de Entidades de Negocio A continuación se presenta el diagrama que contiene las entidades de negocio que hacen parte del

sistema y cómo se relacionan entre sí; además una breve descripción de cada una de ellas.

Ilustración 1 Modelo ERD de SISINFOCOOP

A continuación se encuentra una descripción de cada una de las entidades que conforma el

sistema de información SISINFOCOOP.

Entidad Descripción Relaciones

Persona Clase Padre, de esta heredan asociado, codeudor, empleado y asesor comercial.

La entidad tiene una relación de muchas direcciones.

Usuario Entidad que contiene el usuario y password, para validarse ante el sistema

Un usuario puede tener muchos roles y viceversa.

UsuarioRol Entidad que agrupa un usuario y sus respectivos roles

Rol Entidad con los roles del sistema

Empleado Entidad que hereda de Persona, y es la representación de empleado

Puede tener un usuario

Asociado Es la representación de asociado de la cooperativa y hereda de persona

Puede tener una solicitud de crédito y un crédito o créditos.

Codeudor Entidad que hereda de persona y es la representación de codeudor de un crédito

Puede ser codeudor de un crédito.

AsesorComercial Entidad que hereda de persona, representa un asesor comercial

Puede tener cero o más créditos asociados.

Pagaduría Es la representación de una pagaduría

Tiene una dirección. Tiene cero o más créditos asociados.

Dirección Es la representación de una dirección

Pertenece a una Ciudad.

Ciudad Es la representación de una ciudad de Colombia

Una ciudad pertenece a un departamento.

Departamento Es la representación de un departamento de Colombia

Puede tener una o más ciudades.

Crédito Es la representación de un crédito

Tiene asociada una pagaduría, un proveedor y un asesor comercial. Puede tener una o más transacciones. Puede Tener memos, que son observaciones o algún evento que ha surgido y se debe dejar documentado. Puede tener una solicitud de crédito.

SolicitudCredito Es la representación de una solicitud de crédito.

Se relaciona con asociado y con crédito.

Referencia Es la representación de una referencia.

Se relaciona con una solicitud de crédito.

CuentaAporte Es la representación de una vinculación de un asociado a una pagaduría.

Se relaciona con asociado y con pagaduría.

DocumentoContable Es la representación de un documento contable

Se relaciona con una pagaduría. Se relaciona con transacciones de créditos y de aportes.

Transacción Crédito Representa la transacción de un crédito

Se relaciona con un crédito. Se relaciona con un documento contable. Se relaciona con un tipo de transacción.

Transacción Aporte Representa la transacción de aporte.

Se relaciona con una vinculación aportes. Se relaciona con un documento contable. Se relaciona con una pagaduría.

TipoTransaccion Es la representación de los tipos de transacción.

Se relacionada con transacción crédito y de aporte.

Tabla 1 Descripción de las Entidades

3 Roles A continuación se presentara los roles y una descripción de cada uno de ellos.

ROL Descripción

Administrador Este rol, permite la administración total de sistema, podrá llevar a cabo todas las operaciones CRUD, con las que cuente el sistema. También tiene acceso a los módulos de transacciones y reportes.

Empleado Este rol, permite hacer operaciones de crear, editar y actualizar sobre todos los módulos, a excepción del módulo de seguridad al cual no tendrá acceso.

Asesor Este rol, tendrá acceso al módulo de asociados a la opción de administración de asociados, para consultar por número de documentó si existe o no un asociado. Adicionalmente podrá consultar por número de documento los aportes y los créditos de un asociado.

Asociado Este rol, solo podrá acceder al módulo de reportes, para consultar sus aportes y/o su crédito.

Tabla 2 Descripción de Roles

4 Estructura de carpetas del proyecto en el IDE El prototipo fue implementado utilizando el IDE Eclipse Luna, el proyecto se administró utilizando

maven. A continuación veremos la estructura básica del proyecto:

Ilustración 2 Estructura de Carpetas

Cuando realicemos la importación del proyecto al IDE eclipse, obtendremos una estructura igual a

la de la Ilustración 2 Estructura de Carpetas. A continuación se explicará el contenido de cada una

de ellas.

4.1 Proyecto-ear Aplicación empresarial, es un formato para empaquetar en un sólo archivo varios módulos.

Permite desplegar varios módulos en un servidor de aplicaciones. Contiene archivos XML llamados

descriptores de despliegue que describen los módulos que componen la aplicación.

<project xmlns="http://maven.apache.org/POM/4.0.0"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://maven.apache.org/POM/4.0.0

http://maven.apache.org/xsd/maven-4.0.0.xsd">

<modelVersion>4.0.0</modelVersion>

<parent>

<groupId>org.proyecto</groupId>

<artifactId>proyecto</artifactId>

<version>1.0</version>

</parent>

<artifactId>proyecto-ear</artifactId>

<packaging>ear</packaging>

<dependencies>

<dependency>


<artifactId>proyecto-ejb</artifactId>


</dependency>

<dependency>


<artifactId>proyecto-war</artifactId>


<type>war</type>

</dependency>

</dependencies>

</project> Ilustración 3 Descriptor de despliegue pom.xml del paquete proyecto-ear

4.2 Proyecto-ejb Módulo ejb, donde encontramos empaquetados los Enterprise JavaBeans.

La estructura de esta carpeta es la siguiente:

Ilustración 4 Estructura carpeta Proyecto-ejb

src/main/java: donde guardaremos nuestras clases java fuente. Debajo de esta carpeta

situaremos nuestras clases en distintos paquetes.

src/main/resources: aquí almacenaremos los recursos (ficheros xml, ficheros de

propiedades, imágenes, etc.) que pueda necesitar las clases java de nuestro proyecto.

Ilustración 5 Carpetas java y resources

En el directorio raíz del módulo proyecto-ejb encontraremos un archivo llamado pom.xml, a partir

del cual vamos a poder definir distintos parámetros de nuestro proyecto, desde los autores del

mismo hasta los plugins que queremos que use Maven. El pom.xml del que partimos inicialmente

tiene el siguiente aspecto,

<?xml version="1.0"?>

<project


http://maven.apache.org/xsd/maven-4.0.0.xsd"

xmlns="http://maven.apache.org/POM/4.0.0"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">


<parent>




</parent>


<name>proyecto-ejb</name>

<url>http://maven.apache.org</url>

<properties>

<project.build.sourceEncoding>UTF-8

</project.build.sourceEncoding>

</properties>

<dependencies>

<dependency>

<groupId>javax</groupId>

<artifactId>javaee-api</artifactId>


<scope>provIDEd</scope>

</dependency>

<dependency>

<groupId>org.postgresql</groupId>

<artifactId>postgresql</artifactId>

<version>9.4-1201-jdbc41</version>

</dependency>

</dependencies>

<build>

<finalName>proyecto-ejb</finalName>

<plugins>

<plugin>

<groupId>org.apache.maven.plugins</groupId>

<artifactId>maven-compiler-plugin</artifactId>


<configuration>

<source>1.7</source>

<target>1.7</target>

</configuration>

</plugin>

</plugins>

</build>

</project> Ilustración 6 Descriptor pom.xml

Si desea obtener más información sobre el pom.xml, puede consultar

http://maven.apache.org/guIDEs/introduction/introduction-to-dependency-mechanism.html

Continuando, con este módulo-ejb, pasaremos ahora a ver el contenido de la carpeta

src/main/java.

org.proyecto.dao: Capa de persistencia, utilizando el patrón DAO, como su nombre lo

indica es un patrón de diseño que busca reutilizar código mediante la implementación de

operaciones básicas que se desea implementar en variedad de clases, un ejemplo de ello

son las operaciones de crear, consultar, listar, eliminar, y modificar (CRUD), por cada una

de las entidades tenemos un DAO. A continuación vemos la clase Genérico, de la cual se

extienden aquellas clases que necesitan tener el acceso a los datos, para nuestro caso será

una clase por cada una de las distintas entidades de nuestro sistema.

public abstract class Generico<T>{

private Class<T> entityClass;

public Generico(Class<T> entityClass) {

this.entityClass = entityClass;

}

protected abstract EntityManager getEntityManager();

@RolesAllowed({"Administrador", "Empleado", "Asesor", "Asociado"})

public void create(T entity) throws Exception {

getEntityManager().persist(entity);

}


public void edit(T entity) throws Exception {

getEntityManager().merge(entity);

}

@RolesAllowed("Administrador")

public void remove(T entity) throws Exception {

getEntityManager().remove(getEntityManager().merge(entity));

}


public T find(Object id) throws Exception {

return getEntityManager().find(entityClass, id);

}

@SuppressWarnings({ "rawtypes", "unchecked" })


public List<T> findAll() {

javax.persistence.criteria.CriteriaQuery cq =

getEntityManager().getCriteriaBuilder().createQuery();

cq.select(cq.from(entityClass));

return getEntityManager().createQuery(cq).getResultList();

}

}

http://maven.apache.org/guides/introduction/introduction-to-dependency-mechanism.html

A continuación veremos las clases que heredan de la clase Genérico:

Ilustración 7 Clases que heredan de la clase Genérico

org.proyecto.enumerado: En esta carpeta se encontrara con las clases de tipo enum, en la

siguiente ilustración vemos las clases utilizadas.

Ilustración 8 Clases tipo enum

org.proyecto.modelo: En esta carpeta encontramos las entidades del sistema, con sus

respectivas anotaciones JPA.

Ilustración 9 Entidades del Sistema

org.proyecto.servicio: Encontramos las clases que tiene reglas de negocio, y se procesan

estas mismas, o en el evento que se desee guardar información en más de una tabla, se

pasa por la capa de servicio.

Ilustración 10 Clases de servicio

4.3 Proyecto-war Es un archivo JAR (con la extensión WAR) usado para distribuir una colección de archivos JSF,

servlets, clases Java, archivos XML y contenido web estático (HTML). En conjunto constituyen una

aplicación Web. A continuación vemos la estructura de este módulo:

Ilustración 11 Estructura módulo WAR

org.proyecto.bean: Son los controladores, también conocidos como @ BackingBeans,

estos backing beans procesa lógica de negocio, hace llamados a los EJBs, adicionalmente

se utilizan para el manejo de excepciones y mensajes, para mostrar esta por pantalla,

haciendo un llamado a facescontext.addMessage(). Para ello y con el fin de reutilizar

código se tiene una clase utilitario.java de la cual heredan todos los backing beans.

Ilustración 12 Backing Beans del sistema

org.proyecto.converter: los Converter forman parte del Framework de JSF, y como su

nombre lo indica sirven para convertir la entrada desde las páginas JSF (desde

selectOneMenu) de String a algún tipo de Dato complejo como un objeto por ejemplo de

tipo Persona. Las entradas de datos en JSF se procesan como String y a través de los

Converter pueden transformarse en el tipo de dato u objeto que se necesite.

<p:selectOneMenu style="width: 202px" id="asesor" value="#{creditoBean.nuevoCredito.idAsesorComercial}" required="true" requiredMessage="Campo Asesor requerido!" converter="#{asesorConverter}">

<f:selectItem itemValue="#{null}" itemLabel="-- Seleccione un Asesor --" /> <f:selectItems value="#{creditoBean.asesores}" var="asesor" itemValue="#{asesor}"

itemLabel="#{asesor.idPersona.primerNombre.toUpperCase()} #{asesor.idPersona.segundoNombre.toUpperCase()} #{asesor.idPersona.primerApellido.toUpperCase()} #{asesor.idPersona.segundoApellido.toUpperCase()}" />

</p:selectOneMenu>

Ilustración 13 Clases converter

org.proyecto.util: Aquí se tienen algunas clases que se han utilizado en algún momento

durante el desarrollo del proyecto, estas tienen métodos para la reutilización de código,

como es el caso de la clase utilitario.java, donde se tiene métodos para poner en pantalla

el manejo de mensajes.

Ilustración 14 Clases utilitarias

Descriptor pom.xml

Configuración del archivo pom.xml como se hace uso de primefaces es necesario tener la

configuración de este con la finalidad de tener los jars que se necesitan para usar los componentes

personalizados que este framework nos brinda. Lo que hemos hecho es añadir las librerías desde

el repositorio de Maven, y se añadió un tema de la galería de Primefaces.

<?xml version="1.0"?>

<project


http://maven.apache.org/xsd/maven-4.0.0.xsd"

xmlns="http://maven.apache.org/POM/4.0.0"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">


<parent>




</parent>

<artifactId>proyecto-war</artifactId>

<packaging>war</packaging>

<name>proyecto-war</name>

<url>http://maven.apache.org</url>

<dependencies>

<dependency>




</dependency>

<dependency>

<groupId>javax</groupId>

<artifactId>javaee-api</artifactId>


<scope>provIDEd</scope>

</dependency>

<dependency>

<groupId>org.primefaces</groupId>

<artifactId>primefaces</artifactId>


</dependency>

<dependency>

<groupId>org.primefaces.themes</groupId>

<artifactId>glass-x</artifactId>

<version>1.0.10</version>

</dependency>

<dependency>

<groupId>org.primefaces.extensions</groupId>

<artifactId>primefaces-extensions</artifactId>


</dependency>

<dependency>

<groupId>com.lowagie</groupId>

<artifactId>itext</artifactId>


<exclusions>

<exclusion>

<groupId>bouncycastle</groupId>

<artifactId>bcprov-jdk14</artifactId>

</exclusion>

<exclusion>

<groupId>bouncycastle</groupId>

<artifactId>bcmail-jdk14</artifactId>

</exclusion>

<exclusion>

<groupId>org.bouncycastle</groupId>

<artifactId>bctsp-jdk14</artifactId>

</exclusion>

</exclusions>

</dependency>

<dependency>

<groupId>org.apache.poi</groupId>

<artifactId>poi</artifactId>


</dependency>

<dependency>

<groupId>org.apache.poi</groupId>

<artifactId>poi-ooxml</artifactId>


</dependency>

<dependency>

<groupId>commons-fileupload</groupId>

<artifactId>commons-fileupload</artifactId>


</dependency>

<dependency>

<groupId>commons-io</groupId>

<artifactId>commons-io</artifactId>


</dependency>

</dependencies>

<repositories>

<repository>

<id>prime-repo</id>

<name>PrimeFaces Maven Repository</name>

<url>http://repository.primefaces.org</url>

<layout>default</layout>

</repository>

</repositories>

<build>

<finalName>proyecto-war</finalName>

<plugins>

<plugin>

<groupId>org.apache.maven.plugins</groupId>

<artifactId>maven-compiler-plugin</artifactId>


<configuration>

<source>1.7</source>

<target>1.7</target>

</configuration>

</plugin>

</plugins>

</build>

</project> Ilustración 15 Descriptor pom.xml

Paginas XHTML

Como hemos indicado con anterioridad, en el diseño de estas páginas web, se utilizó PrimeFaces

que es una librería de componentes visuales open source desarrollada y mantenida por Prime

Technology, para JavaServer Faces (JSF). Una de las ventajas de utilizar Primefaces, es que

permite la integración con otros componentes como por ejemplo RichFaces. Adicionalmente

PrimeFaces tiene soporte para AJAX, que es una técnica de desarrollo web para crear aplicaciones

interactivas. Estas aplicaciones se ejecutan en el cliente, en el navegador de los usuarios mientras

se mantiene la comunicación asíncrona con el servidor en segundo plano.

Para el presente prototipo se utilizó un témplate para que todas las páginas tuvieran el mismo

diseño y para cada uno de los módulos también se tiene un témplate o plantilla. Adicionalmente el

desarrollador debe tener conocimiento de archivos .css para cambiar tipos de letra, colores,

imágenes entre otras características de diseño.

La estructura para el diseño de las páginas web es el siguiente:

Ilustración 16 Estructura war – xhtml

Dentro del componente proyecto-war, encontramos la siguiente ruta src/main/webapp, en esta

última carpeta vamos a encontrar una serie de carpetas que manejaran la presentación de la

aplicación, empezaremos por explicar el contenido de la carpeta pages:

Pages: Dentro de esta carpeta encontramos 6 carpetas adicionales que corresponde a

cada uno de los módulos que tiene el prototipo. Dentro de estas carpetas encontramos

las paginas xhtml, que podremos modificar según el criterio o diseño que deseemos

cambiar.

Ilustración 17 Contenido de la Carpeta Pages

Resources: En esta carpeta encontramos los recursos necesarios para el diseño de

nuestras páginas web.

o CSS: En esta carpeta encontramos el archivo con extensión .CSS, la hoja de estilo

en cascada o CSS es un lenguaje usado para definir y crear la presentación de un

documento estructurado escrito en HTML o XML, en este archivo podemos

cambiar como tipo de letra, tamaño, color de botones, imágenes de fondo, entre

otras características

Ilustración 18 Contenido de la carpeta resources

o Fonts: En esta Carpeta encontramos los tipos de fuente que el prototipo requiere

para el manejo del tipo de letra.

o Images: En esta carpeta se encuentra las distintas imágenes que se utilizan a lo

largo del prototipo, por ejemplo el logo, y las imágenes de los módulos.

o Js: En esta carpeta encontramos archivos JavaScript, por ejemplo la traducción al

idioma español para los atributos del tag <calendar> ya que por defecto es el

inglés.

Templates: En esta carpeta encontramos las plantillas o templates, con el menú de cada

uno de los módulos, por ejemplo el template.administracion.xhtml, tiene el menú de

administración de personas, administración de proveedores, administración de pagaduría

y administración de asesores comerciales, allí mismo se maneja cual es la url de cada una

de las opciones.

Ilustración 19 Carpeta templates

WEB-INF: Carpeta con los archivos descriptores que están explicados en el manual de

configuración e instalación. (Ver Anexo: Manual de configuración e instalación.)

Ilustración 20 Carpeta WEB-INF

Raíz de webapp: Encontramos dos archivos uno index.xhtml y otro principal.xhtml, en la

página de índex se maneja la parte de autorización y autenticación. La página principal

tenemos todos los módulos que ofrece la aplicación según el rol.

Ilustración 21 Raíz de la Carpeta webapp

5 Estrategia de programación de los CRUD En la presenté sección se presentará los pasos necesarios para construir un CRUD (Create, Read,

Update y Delete) utilizando Java Server Faces 2.2 que facilita la creación de páginas y la

comunicación de estas a las clases Java e Hibernate para realizar el almacenamiento de datos.

Los CRUD sigue el patrón MVC para la programación Web, que separa las clases en capas según la

responsabilidad de cada una. A continuación se muestra la estructura que va a crear el DAO,

Modelo, Vista y el Controlador que componen los paquetes.

Ilustración 22 Estructura generación CRUD

5.1 Creación de Capas

Modelo

El paquete modelo debe contener una llamada de clase que será un POJO (Plain Old Java Object)

con las anotaciones necesarias, un ejemplo de una clase es la que se muestra a continuación:

package org.proyecto.modelo;

import java.io.Serializable;

import javax.persistence.Entity;

@Entity

@Table(name = "asociado", schema = "cooperativa")

@XmlRootElement

@NamedQueries({

@NamedQuery(name = "Asociado.findAll", query = "SELECT a FROM Asociado

a")})

public class Asociado implements Serializable {

private static final long serialVersionUID = 1L;

@Id

@GeneratedValue(strategy = GenerationType.IDENTITY)

@Basic(optional = false)

@Column(name = "id_asociado")

private Integer idAsociado;

@Basic(optional = false)

@NotNull

@Size(min = 1, max = 20)

@Column(name = "tipo_asociado")

private String tipoAsociado;

public Asociado() {

}

public Asociado(Integer idAsociado) {

this.idAsociado = idAsociado;

}

//getters y setters … Ilustración 23 Contenido de una Clase Java

DAO

El paquete DAO, es el cargado de la comunicación con la DB, llevando a cabo la persistencia.

Dentro de este paquete se encuentra clases como AsociadoDAO, donde por cada entidad se tiene

una clase DAO; esta clase hereda de GENERICO.JAVA, clase abstracta con métodos de CRUD y

método de conexión a la DB para mantener la persistencia. A continuación se presenta un ejemplo

de una clase “xxxDAO.Java”

import java.util.ArrayList;

import java.util.HashMap;

import javax.annotation.security.RolesAllowed;

import javax.ejb.Stateless;

import javax.persistence.EntityManager;

import javax.persistence.PersistenceContext;

import javax.persistence.Query;

@Stateless

@RolesAllowed({"Administrador", "Empleado", "Asesor"})

public class AsociadoDao extends Generico<Asociado> {

@PersistenceContext

private EntityManager em;

@Override

protected EntityManager getEntityManager() {

return em;

}

public AsociadoDao() {

super(Asociado.class);

} Tabla 1 Ejemplo clase AsociadoDAO

ManageBean o Control

Este paquete de control hará capa de comunicación con las paginas JSF y con la DB; es responsable

de realizar las operaciones necesarias en las páginas JSF. Las clases aquí tiene el sufijo “Bean”; a

continuación se muestra un ejemplo de una clase:

package org.proyecto.bean;

import java.io.Serializable;

import javax.annotation.PostConstruct;

import javax.faces.view.ViewScoped;

import javax.inject.Inject;

import javax.inject.Named;

import org.primefaces.context.RequestContext;

@Named(value = "asociadoBean")

@ViewScoped

public class AsociadoBean extends Utilitario implements Serializable {


@Inject

private AsociadoServicio asociadoServicio;

@Inject

private PersonaDao personaDao;

@Inject

private RolDao rolDao;

private Asociado nuevoAsociado;

private Asociado asociadoEliminar;

public void buscar(){

personaSeleccionada =

personaDao.buscarPorNoDocumento(numeroDocumento);

if(personaSeleccionada != null){

inicializarAsociado();

}else{

ponerMensajeInfo("No se encontraron coincidencias",

"");

RequestContext.getCurrentInstance().update("messages");

}

}

public void cancelar(){


setPersonaSeleccionada(null);

}

public void guardar(){

try{

Asociado asociado =

asociadoServicio.buscarPorPersona(personaSeleccionada);

if(asociado == null){

if(!nuevoAsociado.getIdUsuario().getUsuario().equa

ls("")){

nuevoAsociado.getIdUsuario().setEstado("A")

nuevoAsociado.getIdUsuario().setPassword(Crypt.encryptM

D5(nuevoAsociado.getIdUsuario().getPassword()));

}else{

nuevoAsociado.setIdUsuario(null);

}

asociadoServicio.crearAsociado(nuevoAsociado, rolAsociado);

ponerMensajeInfo("Asociado creado con éxito", "");


setPersonaSeleccionada(null);

}else{

ponerMensajeError("La persona seleccionada ya está

asignada a otro Asociado","");

}


}catch(Exception e){

ponerMensajeError("Error general: " +

e.getMessage(),"");


}

}

Vista

Este paquete consta de páginas XHTML, estas páginas se comunican con los métodos y atributos

de la clase que tiene el sufijo Bean, permitiendo la interacción con la DB. A continuación se

muestra un ejemplo:

<html xmlns="http://www.w3.org/1999/xhtml"

xmlns:h="http://xmlns.jcp.org/jsf/html"

xmlns:jsf="http://xmlns.jcp.org/jsf"

xmlns:f="http://java.sun.com/jsf/core"

xmlns:p="http://primefaces.org/ui"

xmlns:ui="http://xmlns.jcp.org/jsf/facelets"

>

<h:head>

<title>Cooperativa de Aporte y Crédito</title>

<h:outputScript library="js" name="es.js" />

</h:head>

<h:body>

<ui:composition template="/templates/template.xhtml">

<ui:define name="content">

<h:outputScript library="js" name="es.js" />

<p:growl id="messages" showDetail="true" autoUpdate="true"

life="6000" />

<h:form id="formLogin" prependId="false"

onsubmit="document.getElementById('formLogin').action =

'j_security_check';">

<p:tabView id="tab" style="text-align: center"

styleClass="panelModulos">

<p:tab title="Ingreso al Sistema">

<p:fieldset id="fieldGeneral" styleClass="fieldSet"

legend="Login">

<h:panelGrid columns="2" style="margin: 0 auto">

<h:outputLabel styleClass="label" value="Usuario:" />

<p:inputText id="j_username" styleClass="input"

value="#{indexBean.username}" required="true"

requiredMessage="Campo usuario requerido!!" />

<h:outputLabel styleClass="label"

value="Contraseña:" />

<p:password id="j_password" styleClass="input"

required="true" requiredMessage="Campo

contraseña requerido!!"

value="#{indexBean.clave}"

feedback="true" promptLabel="Ingrese su clave"

weakLabel="Seguridad baja" goodLabel="Seguridad

buena" strongLabel="Seguridad fuerte" />

<p:columnGroup />

<h:commandButton styleClass="myButton"

value="Ingresar" type="submit"

action="#{indexBean.login}" style="margin-

top: .5em" />

</h:panelGrid>

</p:fieldset>

5.2 Utilización de PrimeFaces La utilización de PrimeFaces, no requiere mayor configuración; simplemente se debe insertar la

siguiente declaración en cada página, donde se necesite utilizar este componente:

xmlns:p="http://primefaces.org/ui"

Para cambiar el skin que se utiliza, solamente es necesario modificar el web.xml en la siguiente

declaración:

<context-param>

<param-name>primefaces.THEME</param-name>

<param-value>glass-x</param-value> // Aqui debe poner el nombre del

// skin nuevo.

</context-param>

Componentes Utilizados

dataTable: Componente que permite generar una tabla en la página, con opciones como

búsquedas, filtros, selección de filas haciendo uso de los siguientes atributos:

o Selection

o Facets

o sortBy

o Expansion

o Filter

commandButton: A través de estos se realizan las llamadas AJAX; Permite especificar que

porciones de la vista JSF deben de ser enviadas al servidor para procesar sus

modificaciones (atributo process) e indicar que elementos de la vista deben ser

actualizados una vez completada la acción (atributo update).

panelGrid, panel: Paneles y componentes Primefaces que actúan como contenedores de

componentes con los estilos y "skins" de Primefaces.

confirmDialog: este componente permite crear una venta estilo pop, y requiere de una

variable widgetVar utilizado para definir el nombre para el componente confirmDialog.

rendered: Estos nos permiten mostrar o ocultar controles dependiendo del valor de una

expresión de JSF, en este prototipo se utilizó para ocultar las columnas de eliminar o editar

de acuerdo al rol que tiene asignado el usuario.

Estos son los componente más usados a lo largo de las paginas XHTML

Create

Para la inserción de nuevos datos, se ponen los campos que representan los atributos de la

entidad; dentro de unos tags <fieldset> y <panelGrid> , este formulario se envía con todos los valores

que tiene adentro y se actualiza la página parcialmente a través del tag <commandButton> donde se le

indica el id del formulario y se hace un llamado al método del Bean.

<p:fieldset id="fieldGeneral" styleClass="fieldSet" legend="Datos

generales">

<h:panelGrid columns="4" style="margin: 0 auto; text-align: center;">

<h:outputLabel styleClass="label" value="Primer nombre:" />

<p:inputText styleClass="input"

value="#{personaBean.nuevaPersona.primerNombre}" required="tru

requiredMessage="Campo primer nombre requerido" style="text-

transform: capitalize" />

<h:outputLabel styleClass="label" value="Segundo nombre:" />

<p:commandButton update=":formPersona:tab" process="@this

fieldGeneral" style="margin-top: 1em; margin-bottom: 1em"

value="Guardar" rendered="#{!personaBean.editar}"

action="#{personaBean.guardar}" />

Read

Para mostrar las tuplas de una entidad, se hace el uso del componente <dataTable> el cual tiene

unos atributos entre los cuales encontramos “value”; atributo que permite hacer el llamado a un

método del Bean, método que obtiene una lista de todas las tuplas con sus atributos.

<p:dataTable value="#{personaBean.listaPersonas}" id="tblPersona"

var="persona">

Update

Para hacer una actualización sobre algún registro, se necesita hacer editable la entrada o la

selección de la tabla, para ello se debe insertar una variable de tipo booleano en el modelo, y se

debe asignar un valor de “true” para que los campos de esa tabla sea editables, esta variable se

incorpora el clase que tiene sufijo Bean. Como se muestra a continuación:

private boolean editar; public void seleccionarParaEditar(Persona persona){

listaDirecciones = new ArrayList<>();

if(persona.getDireccionPersonaList().size() > 0){

for(DireccionPersona dp :

persona.getDireccionPersonaList()){

listaDirecciones.add(dp.getIdDireccion());

}

}

setNuevaPersona(persona);

setEditar(Boolean.TRUE);

}

public void setEditar(boolean editar) {

this.editar = editar;

}

Delete

El proceso de eliminar es similar al de actualizar, pero esta vez el llamado del método se hace

desde la confirmación de un dialogo del componente <confirmDialog>, la invocación del

confirmDialog se hace el componente <commandButton> con el atributo “oncomplete”.

<p:commandButton value="Sí" action="#{personaBean.eliminar}" update=":formPersona:tab" process="@this :formPersona:tab:tblPersona" oncomplete="PF('confirmDlg').hide();" styleClass="ui-confirmdialog-yes" icon="ui-icon-check" />

<p:confirmDialog header="Confirmación" widgetVar="confirmDlg"> <f:facet name="message"> <h:outputText value="Está seguro que desea eliminar la persona #{personaBean.personaEliminar.primerNombre} #{personaBean.personaEliminar.segundoNombre} #{personaBean.personaEliminar.primerApellido} #{personaBean.personaEliminar.segundoApellido}?" /> </f:facet> <p:commandButton value="Sí" action="#{personaBean.eliminar}" update=":formPersona:tab" process="@this :formPersona:tab:tblPersona" oncomplete="PF('confirmDlg').hide();" styleClass="ui-confirmdialog-yes" icon="ui-icon-check" /> <p:commandButton value="No" styleClass="ui-confirmdialog-no" update=":formPersona:tab" process="@this :formPersona:tab:tblPersona" oncomplete="PF('confirmDlg').hide();" icon="ui-icon-close" /> </p:confirmDialog>

Búsquedas

Para la realización de búsquedas por algún criterio que el cliente definió previamente, se utilizó el

atributo <filter> del componente <dataTable>. Este lo que hace es habilitar un campo de entrada

debajo de cada título de la tabla asi:

<p:column sortBy="#{persona.numeroDocumento}"

filterBy="#{persona.numeroDocumento}"

filterMatchMode="contains" headerText="No. Identificación">

<h:outputText value="#{persona.numeroDocumento}" />

</p:column>

Con estos atributos <filterBy> y <filterMacthMode> se puede habilitar el campo de búsqueda

debajo de cada título de la columna de la tabla, como se muestra a continuación:

Ilustración 24 Búsqueda por filtros

Las búsquedas se hacen en tiempo real, ya que la información de la tabla ha sido cargada

previamente.

5.3 Casos de uso

Caso De Uso: Modulo Seguridad

5.3.1.1 Descripción del caso de uso

El sistema debe permitir realizar operaciones CRUD sobre Usuario y Rol, también debe permitir

asignar rol, hacer login, cerrar sesión y cambiar contraseña.

5.3.1.1.1 Diagrama Caso de Uso

Ilustración 25 Diagrama Caso de Uso - Modulo Seguridad

Ilustración 26 Diagrama Caso de Uso - Modulo Seguridad

Caso De Uso: Modulo Administración


El sistema debe permitir realizar operaciones CRUD Personas, Asesores Comerciales, Proveedor,

Pagaduría y Asignar una persona como Asesor Comercial.


A continuación se adjunta los diagramas que conforman el módulo de administración

Ilustración 27 Diagrama Caso de Uso - Modulo Administración




Caso De Uso: Modulo Asociados


El sistema debe permitir realizar operaciones CRUD de Asociado, de cuenta aporte y Asignar

asociado, y Registrar una cuenta Aporte a un asociado.


A continuación se adjunta los diagramas que conforman el módulo Asociados

Ilustración 31 Diagrama Caso de Uso - Modulo Asociados

Ilustración 32 Diagrama Caso de Uso - Modulo Asociados

Caso De Uso: Modulo Crédito


El sistema debe permitir realizar operaciones CRUD de Crédito, solicitud crédito y memo.

Registrar un crédito a un asociado y registrar un memo a un crédito.


A continuación se adjunta los diagramas que conforman el módulo de crédito

Ilustración 33 Diagrama Caso de Uso - Modulo Crédito

Ilustración 34 Diagrama Caso de Uso - Modulo Crédito

Caso De Uso: Modulo Transacciones


El sistema debe permitir realizar operaciones CRUD de documento contable, transacción aporte y

transacción crédito. Registrar una transacción aporte, registrar transacción crédito, y registrar

documento contable.


A continuación se adjunta los diagramas que conforman el módulo transacciones.

Ilustración 35 Diagrama Caso de Uso - Modulo Transacciones



Caso De Uso: Modulo Reportes


El sistema debe permitir realizar operaciones de reporte de crédito, aportes, proveedor, pagaduría

y asesor comercial.


A continuación se adjunta los diagramas que conforman el módulo reportes.

Ilustración 38 Diagrama Caso de Uso - Modulo Reportes

6 Casos de Uso de Negocio

6.1 Nombre del caso de uso Registrar Transacción Crédito Registrar Transacción Crédito (en Java: TransaccionCredito)

Descripción del caso de uso

El sistema debe permitir registrar una transacción crédito, es decir que sobre un crédito que tiene

un asociado, se van a realizar una serie de transacciones que la cooperativa previamente ha

definido, para el presente prototipo se tiene los siguientes tipos de transacciones sobre el crédito

de un asociado:

Abono Cuota

Devolución Cuota

Entidades

Las entidades que participan en el registro de la transacción aporte son:

DocumentoContable: Entidad tiene asociada la transacción de aporte.

TransaccionCredito: Entidad que tendrá las tuplas de las transacciones de aportes de los

distintos asociados.

TipoTransaccion: Entidad que lista las opciones que se tiene sobre las transacciones como

si es Abono Crédito, Devolución Cuota entre otras.

Pagaduría: Es la entidad que tiene asociado un crédito y un documento contable.

Crédito: Entidad a la cual se le van asociar una transacción.

Ilustración 39 Entidades participantes del caso de uso

Flujo de negocio en términos de páginas y acciones

6.1.3.1 Descripción del flujo de negocio

1. Allí en el módulo de transacciones el usuario podrá seleccionar de una lista alguna de las opciones de las que se despliega, para nuestro caso deberá seleccionar “Transacciones de Créditos”, será re direccionado a la página transaccion-credito.xhtml, estando allí deberá introducir el número de documento contable asociado a la(s) transacción(es), o podrá buscar el número de documento contable por pagaduría de la lista desplegable, el método para esto es buscarDocumento(), llamando al método buscarPorNoDocumento(). En el evento que el campo No. Documento Contable sea nulo o este vacío y la lista Pagaduría tenga alguna selección, se invocara el método buscarPorPagaduria() que devuelve los documentos contables asociados a esa pagaduría seleccionada.

2. Cuando el usuario hace la selección del documento contable se verifica si tiene transacciones asociadas, si las tiene se refrescara la página mostrando las transacciones asociadas, de lo contrario se mostrara el crédito o créditos asociados a la pagaduría del documento contable, y se le solicitara al usuario el tipo de transacción y se le solicitara que seleccione el crédito o créditos que son sujetos de transacciones con el campo de valor editable por si el valor de la transacción es diferente, al oprimir el botón registrar transacciones, se invoca el método mostrarRegistros(), con el propósito de mostrar el crédito o créditos seleccionados de

class ERD View

EA 12.0 Unregistered Trial Version EA 12.0 Unregistered Trial Version EA 12.0 Unregistered Trial Version EA 12.0 Unregistered Trial Version EA 12.0 Unregistered Trial Version



































Pagaduria

- id: long {id}

- noIdentificacion: int

- nombre: String

- codigoDescuento: String

- personaContacto: String

- telefonoContacto: String

Credito

- id: long {id}

- noLibranza: String

- valorLibranza: float

- noCuotas: int

- valorDesembolso: float

- fechaInicioPago: Date

DocumentoContable

- id: long {id}

- fecha: Date

- numeroDocumento: String

- valor: float

- cantidadTransacciones: String

TipoTransaccion

- id: long {id}

- nombre: String

- Factor: int

- descripcion: String

TransaccionCredito

- id: long {id}

- fechaAplicacion: Date

- valorTransaccion: float

transacciones, luego al oprimir el botón confirmar transacciones se invoca el método confirmarTransacciones().

3. Si por el contrario el usuario oprime el botón Editar transacciones, se invocara el método editarRegistros(), para volver a ver el crédito o créditos asociados a esa pagaduría y poder hacer la nueva selección.

6.1.3.2 Grafo de páginas y acciones

transaccion-credito.xhtml

· Documento Contable· Transacción Aportes· Transacción Crédito

principal.xhtml

buscarDocumento()

mostrarRegistros()

mostrarRegistros()

confirmarTransacciones()

Buscar

Seleccion

Registrar transacciones

Confirmar transacciones

buscarPorNoDocumento()

buscarPorPagaduria()

Editar transacciones

editarRegistros()

Ilustración 40 Grafo de páginas y acciones

6.1.3.3 Roles de usuarios y sus derechos sobre las acciones

Solamente el usuario con rol Administrador y rol Empleado" tiene acceso a estas páginas y sus

acciones.

Especificación de las acciones del caso de uso

6.1.4.1 TransaccionCreditoEJB @Stateless

public class TransaccionCreditoEJB extends Generico<TransaccionAporte> {

@PersistenceContext


@Override


return em;

}

Ilustración 41 TransaccionCreditoEJB

6.1.4.2 Generico /**

* Clase que ofrece servicios relacionados con la persistencia de la entidad

* Esta clase define los métodos como créate, edit, remove, find, ente otros

* métodos.

*/





}




} Ilustración 42 Clase generico

6.1.4.3 TransaccionCreditoBean

@ViewScoped

public class TransaccionCreditoBean extends Utilitario implements

Serializable{

/**

* Metodo buscarDocumento: Este método lo que hace es buscar el documento contable * que se debió crear anteriormente, para asociar las transacciones de crédito o créditos. */ public void buscarDocumento(){

}

/**

* Método confirmarTransacciones: Este método, lo que hace es insertar las transacciones * seleccionadas en la base de datos. */

public void confirmarTransacciones(){

}

/**

* Método mostrarRegistros: Este método, lo que hace visualizar los créditos seleccionados * antes de hacer la persistencia, es un método de confirmación por si el usuario desea * editar la selección o confirmar la selección. */ public void mostrarRegistros(){

} Ilustración 43 Clase TransaccionCreditoBean

Especificación de las páginas del caso de uso

6.1.5.1 Principal

Página principal del aplicativo, es el punto de inicio “principal.xhtml” y el final es la página

“transaccion-credito.xhtml” con el respectivo refresh donde queda al inicio donde se solicita

búsqueda de documento contable.

6.1.5.2 Transacción Aporte: página transacción-credito.xhtml

Página encargada, de desplegar la información referente a la búsqueda del documento contable,

también despliega la información de crédito o créditos adscritos a la pagaduría para seleccionar a

los que les va hacer algún tipo de transacción sobre estos mismos.

· Buscar documento contable por numero o por pagaduría

· Seleccionar crédito o créditos sujetos de transacciones.

6.1.5.3 Prototipo pantallas caso de uso A continuación se muestra el bosquejo de las pantallas que están relacionadas al caso de uso:

· Página principal.xhtml del módulo transacciones

Ilustración 44 Página Principal del módulo transacciones

· Página transaccion-credito.xhtml

Ilustración 45 Pagina transaccion-vredito.xhtml

6.2 Nombre del caso de uso Transacción de aporte Transacción de aporte (en Java: TransaccionAporte)


El sistema debe permitir realizar operaciones transaccionales sobre una cuenta de aportes, la cual

tiene asociada una pagaduría y un asociado, para el presente prototipo se tiene los siguientes

tipos de transacciones sobre los aportes de un asociado:

Abono Aporte

Devolución Aporte

Entidades


CuentaAsociado: Entidad a la cual se le asociaran las transacciones de aportes.

DocumentoContable: Entidad tiene asociada la transacción de aporte y la pagaduría a la

que pertenece el documento contable.

TransaccionAporte: Entidad que tendrá las tuplas de las transacciones de las cuentas de

los asociados.

TipoTransaccion: Entidad que lista las opciones que se tiene sobre las transacciones como

si es Abono aporte, Devolución Aporte entre otras.

Pagaduría: Es la entidad a la cual se le asocia un asociado para que este tenga una cuenta

asociado.

Persona: Es la entidad padre y Asociado hereda de esta, también se guarda el id de esta

entidad en la entidad transacción aporte.

Ilustración 46 Diagrama entidades participantes del CU

class ERD View

EA 12.0 Unregistered Trial Version EA 12.0 Unregistered Trial Version EA 12.0 Unregistered Trial Version EA 12.0 Unregistered Trial Version EA 12.0 Unregistered Trial Version EA 12.0 Unregistered Trial Version EA 12.0 Unregistered Trial Version

















































Pagaduria

- id: long {id}


- nombre: String




Asociado

- id: long {id}

DocumentoContable

- id: long {id}

- fecha: Date


- valor: float


TipoTransaccion

- id: long {id}

- nombre: String

- Factor: int

- descripcion: String

CuentaAporte

- id: long {id}

- valorAporte: float

TransaccionAporte

- id: long {id}

- fechaAplicacion: Date

- valorTransaccion: float

Persona

- idpp: long {id}

- noDocumento: int

- primerNombre: String

- segundoNombre: String

- primerApellido: String

- segundoApellido: String

- fechaNacimiento: Date

- telefonoCasa: String

- telefonoTrabajo: String

- telefonoMovil: String

- fechaExpedicion: Date

- lugarExpedicion: String

- email: String



4. Estando en el módulo de transacciones el usuario podrá seleccionar de una lista desplegable alguna de las opciones del módulo, para nuestro caso el usuario deberá seleccionar “Transacciones de Aportes”, será re direccionado a la página transaccion-aporte.xhtml allí deberá ingresar el número de documento contable, el método para esto es buscarDocumento(). 4.1. En el evento que el campo No. Documento Contable sea nulo o este vacío y la lista

Pagaduría tenga alguna selección, se invocara el método buscarPorPagaduria() que devuelve los documentos contables asociados a esa pagaduría seleccionada.

5. Cuando el usuario hace la selección del documento contable se verifica si tiene transacciones asociadas, si las tiene se refrescara la página mostrando las transacciones asociadas, de lo contrario se mostrara las cuentas de aportes asociadas a la pagaduría del documento contable, y se le solicitara al usuario el tipo de transacción y se le solicitara que seleccione los asociados que son sujetos de transacciones, con el campo de valor editable por si el valor de la transacción es diferente, al oprimir el botón registrar transacciones, se invoca el método mostrarRegistros(), con el propósito de mostrar las cuentas seleccionadas de transacciones, luego al oprimir el botón confirmar transacciones se invoca el método confirmarTransacciones().

6. Si por el contrario el usuario oprime el botón Editar transacciones, se invocara el método editarRegistros(), para volver a ver las cuentas de aportes asociadas a esa pagaduría y poder hacer la nueva selección.

6.2.3.2 Grafo de Páginas y Acciones

transaccion-aporte.xhtml


principal.xhtml

buscarDocumento()

mostrarRegistros()

mostrarRegistros()

confirmarTransacciones()

Buscar

Seleccion

Registrar transacciones

Confirmar transacciones

buscarPorNoDocumento()

buscarPorPagaduria()

Editar transacciones

editarRegistros()

Ilustración 47 Grafo de páginas y acciones

6.2.3.3 Roles de usuarios y sus derechos sobre las acciones

Solamente el usuario con rol Administrador y rol Empleado" tiene acceso a estas páginas y sus

acciones.


6.2.4.1 TransaccionAporteEJB @Stateless

public class TransaccionAporteEJB extends Generico<TransaccionAporte> {

@PersistenceContext


@Override


return em;

}

Ilustración 48 Clase transaccionAporteEJB

6.2.4.2 Generico

/**



* métodos.

*/





}




}

Ilustración 49 Clase generico

6.2.4.3 TransaccionAporteBean

@ViewScoped

public class TransaccionAporteBean extends Utilitario implements

Serializable{

/** * Metodo buscarDocumento: Este método lo que hace es buscar el documento contable * que se debió crear anteriormente, para asociar las transacciones de aportes si el * campo no. Documento del formulario esta nulo o vacío y si tiene alguna selección de * pagaduría, entonces se realizara la búsqueda por pagaduría de lo contrario se hará * validación informando que debe seleccionar un criterio de búsqueda. Este método * como tiene una inyección al @EJB documentoContableEJB tiene acceso a los métodos * buscarPorNoDocumento() y buscarPorPagaduria(), que son métodos de búsqueda * según el campo seleccionado, por defecto se verifica que el campo No Documento no * este nulo. */ public void buscarDocumento(){

}

/**

* Método confirmarTransacciones: Este método, lo que hace es insertar las * transacciones seleccionadas en la base de datos. */

public void confirmarTransacciones(){

}

/**

* Método mostrarRegistros: Este método, lo que hace visualizar las cuentas seleccionadas * antes de hacer la persistencia, es un método de confirmación por si el usuario desea * editar la selección o confirmar la selección. */

public void mostrarRegistros(){

}

Ilustración 50 Clase TransaccionAporteBean


6.2.5.1 Principal.xhtml

Página principal del aplicativo, es el punto de inicio “principal.xhtml” y el final es la página

“transaccion-aporte.xhtml” con el respectivo refresh donde queda al inicio donde se solicita

búsqueda de documento contable.

6.2.5.2 Transacción Aporte: página transacción-aporte.xhtml

Página encargada, de desplegar la información referente a la búsqueda del documento contable,

también despliega la información de los asociados adscritos a la pagaduría para seleccionar a los

que les va hacer algún tipo de transacción sobre los aportes.

· Buscar documento contable por numero o por pagaduría · Seleccionar los asociados sujetos de transacciones.



Ilustración 51 Página principal.xhtml del módulo transacciones

· Página transaccion-aporte.xhtml

Ilustración 52 Pagina transacion-aporte.xhtml del módulo transacciones

· Página transaccion-aporte.xhtml o Refresh cuando se busca por pagaduría


· Página transaccion-aporte.xhtml o Refresh cuando se busca por No. Documento contable


· Página transaccion-aporte.xhtml o Cuando uno selecciona tipo de transacción o Cuando uno selecciona los asociados sujeto de la transacción.


· Página transaccion-aporte.xhtml o Refresh cuando se oprime el botón de registrar transacciones


· Página transaccion-aporte.xhtml o Refresh cuando se oprime el botón confirmar transacciones


· Página transaccion-aporte.xhtml o Refresh cuando se oprime el botón si


6.3 Nombre del caso de uso Documento Contable Documento Contable


El sistema debe permitir realizar operaciones CRUD de un documento contable, requisito

indispensable para llevar las operaciones tanto de aportes como de créditos.

Entidades


DocumentoContable: Entidad que tiene los atributos indispensables para generar un

documento contable.

Pagaduría: Entidad indispensable para asignar al documento contable.

Ilustración 59 Entidades del caso de uso

class ERD View




































Pagaduria

- id: long {id}


- nombre: String




DocumentoContable

- id: long {id}

- fecha: Date


- valor: float




7. En la página principal.xhtml el usuario seleccionara el módulo de transacciones y será re direccionado a la página principal.xhmtl de la ruta “transaccion/principal.xhtml “.

8. Allí en el modulo de transacciones el usuario podrá seleccionar de una lista alguna de las opciones de las que se despliega, como se puede ver en la siguiente ilustración,

Ilustración 60 Pagina principal.xhtml modulo transacciones

Para nuestro caso primero deberá seleccionar “Administración de Documentos Contables”, será re direccionado a la página documento-contable.xhtml , las operaciones del CRUD se realizaran utilizando JSF 2.2 Table CRUD Ajax y realizando render de la página por cada método que se invoque del EJB DocumentoContableEJB. 8.1. Cuando se ingresa por primera vez a la página documento-contable.xhtml, se inicializa el

documento contable, esto significa que los campos para crear un documento contable pueden ser introducidos de una vez en una parte de la página.

8.2. Adicionalmente se desplegara una tabla con la información de los documentos contables anteriormente creados y que están en la DB, esta tabla tendrá las opciones de editar y eliminar un documento contable según el rol.

6.3.3.2 Roles de usuarios y sus derechos sobre las acciones Solamente el usuario con rol Administrador y rol Empleado" tiene acceso a estas páginas y sus

acciones.

6.3.3.3 Diagrama de acciones y métodos

documento-contable.xhtml


principal.xhtml

InicializarDocumentoContable()guardar()

InicializarDocumentoContable()

editar()

eliminar()

Guardar

Cancelar

Editar

Eliminar

Tabla 3 Diagrama de acciones y métodos


6.3.4.1 DocumentoContableEJB /**

* EJB que ofrece servicios asociados al CU024-DocumentoContable

*/

@Stateless

public class DocumentoContableEJB extends Generico<DocumentoContable> {

@PersistenceContext


@Override


return em;

}

Ilustración 61 Clase DocumentoContableEJB

6.3.4.2 Generico /**



* métodos.

*/





}




} Ilustración 62 Clase generico

6.3.4.3 DocumentoContableBean

/**

* Backing bean asociado a la página documento-contable.xhtml

*

*/

@ViewScoped

public class DocumentoContableBean extends Utilitario implements

Serializable{


@Inject

private DocumentoContableEJB documentoContableEJB;

@Inject

private PagaduriaEJB pagaduriaEJB;

/**

* Metodo inicializarDocumentoContable: Este método lo que hace crear una nueva * Instancia de documento contable, y una instancia de pagaduría ya que un documento * Contable tiene una relación con pagaduría. */

public void inicializarDocumentoContable (){

}

/**

* Método guardar: Este método, lo que hace es insertar los atributos del documento * Contable en la DB */

public void guardar (){

}

/**

* Método editar: Método para la edición de un documento contable que ha sido * seleccionado y hacer los cambios en la DB. */ public void editar(){

}

/**

* Método eliminar: Este método, lo que hace es remover la el objeto que se ha * seleccionado de la DB. */ public void eliminar(){

}

Ilustración 63 Clase DocumentoContableBean


6.3.5.1 Principal.xhtml

Página principal del módulo transacciones, es el punto de inicio “principal.xhtml” y el final es la

página “documento-contable.xhtml” con el respectivo render donde queda al inicio donde se

puede insertar un nuevo documento contable.

6.3.5.2 Documento Contable: página documento-contable.xhtml

Página encargada, de desplegar la información referente a la creación, modificación, eliminación y

edición de documentos contables. Cabe resaltar que se utiliza JSF 2.2 Table CRUD Ajax para

realizar todas las operaciones de tipo CRUD en una sola página, que se denomina “single page”.



Ilustración 64 Página principal del Módulo Transacciones "principal.xhtml"

· Página documento-contable.xhtml

Ilustración 65 Pagina documento-contable.xhtml

Como se puede observar en la

Ilustración 65 Pagina documento-contable.xhtml

las operaciones de tipo CRUD están en una sola página, y estas se actualizan con el render y aplica

la actualización al formulario que está activo.

Documents

FACULTAD DE INGENIERÍA INGENIERIA DE SISTEMAS …pegasus.javeriana.edu.co/.../Manuales/Manual_de_Mantenimiento.pdf · Ilustración 23 Contenido de una Clase Java ... Ilustración