miércoles, 30 de marzo de 2011

Identificación de Patrones Diseño

Programación Orientada a Objetos - Semana 9 - Reporte 8




Un patrón es algún evento, suceso, objeto, en sí cualquier cosa que se repite en el tiempo.
Por ejemplo, en una fábrica se pueden producir diferentes tipos de artículos, por ejemplo, un jabón. El producto puede ir desde un jabón neutro, hasta uno aromatizado. Para todos se sigue un patrón el cual varía solamente al final, cuando se generan productos concretos desde un producto base. Entonces, se puede decir que el patrón es toda la línea de producción, ya que es un proceso recurrente que tiene como resultado uno o varios productos.

El mundo del software no es la excepción, existen problemas recurrentes a los cuales puede aplicarse un patrón, dichos patrones reciben el nombre de Patrón de Diseño.

"Los patrones de diseño son el esqueleto de las soluciones a problemas comunes en el desarrollo de software. Son una descripción de clases y objetos comunicándose entre sí adaptada para resolver un problema de diseño general en un contexto particular."

Los patrones nos brindan soluciones (probadas) a problemas en el desarrollo de software los cuales están sujetos a contextos similares. Por ejemplo, un software de llenado se formas, recibos, facturas, cheques, etcétera, todos pueden tener una finalidad diferente, pero todos tienen un patrón parecido para el llenado de información por lo que su codificación puede ser parecida o la misma; a todos los anteriores se les puede aplicar un patrón de diseño igual.

Existen tres clases de patrones de diseño:

De creación: conciernen al proceso de creación de objetos.
De estructura: tratan la composición de clases y/o objetos.
De comportamiento: caracterizan las formas en las que interactúan y reparten responsabilidades las distintas clases u objetos.

Algunas de las ventajas de usar patrones de diseño son:

Indican cómo resolver un problema particular utilizando un pequeño número de clases relacionadas de forma determinada, pero no indican cómo diseñar un sistema completo, sino sólo aspectos puntuales del mismo.
Facilitan la re utilización de las clases y del propio diseño.
La propia estructura del patrón es reutilizada cada vez que se aplica.

A pesar de ser muy útiles, rara vez se nota su efecto sobre el código y es casi imposible saber que patrón fue utilizado en su desarrollo. También suele ser necesario programas más clases que las necesarias y se produce una sobrecarga en el código

IDENTIFICACIÓN EN EL PROYECTO

Encontré dos patrones que pueden aplicarse al proyecto:

BUILDER PATTERN (Constructor - Tipo Creacional)



Es un patrón de diseño creacional. Separa la construcción de un objeto complejo y a partir de ese proceso se pueden generar distintas representaciones de dicho objeto.

Para aplicar éste patrón se necesita:

- Constructor: especifica una interfaz abstracta para crear un objeto complejo Producto.
- Constructor Concreto: construye y ensambla las partes del Producto implementando la interfaz de Constructor.
- Director: obtiene las partes que forman el Producto y lo construye usando la interfaz de Constructor.
- Parte: representa las partes que se usan para construir el Producto.
- Producto: representa el objeto complejo en construcción.

Yo lo puedo utilizar al generar una factura ya que la generación de una factura necesita un proceso de llenado de formas, esta es la base o patrón.
Además necesito primero generar las partes que componen una factura:

1. Crear el proveedor del servicio.
2. Crear el origen de la carga.
3. Crear el destino de la carga.
4. Crear el pedido (que contiene la carga)
5. Realizar los cálculos (totales, descuentos, impuestos)
6. Armar la factura.
7. Exportar a PDF ó Generar factura electrónica ó Generar una factura impresa.

Como se puede observar, primero se sigue un mismo patrón, dividiendo un objeto complejo en pequeñas partes para posteriormente juntarlas y obtener un producto.
Después con el mismo patrón puedo obtener diferentes presentaciones del mismo producto

COMPOSITE PATTERN (Compuesto - Tipo Estructural)



El Patrón compuesto realiza una jerarquización en forma de "árbol" entre los objetos y así mostrar una relación parte-todo. Incluso se pueden tomar las variables de un objeto como nodos hoja las cuales siguen formando parte de un todo.

Este patrón se usa cuando los objetos tienen cierta jerarquía en el código y cuando ciertas operaciones se realizan en uno o varios objetos.

Una de las formas en que yo puedo utilizar este patrón es al momento de tomar los datos del cliente:

Como pueden ver en la imagen de ejemplo, cada campo de una forma es una hoja, una parte individual de un todo, 2 o más de dichos campos generan un objeto compuesto y así sucesivamente hasta llegar al producto final, es éste caso, una forma.

En mi caso la secuencia sería la siguiente:

1. Los campos para los datos del Origen.
2. Los campos para los datos del Destino.
3. Los campos para tomar la Orden.

En éste caso, los campos son las hojas de los objetos compuestos (Origen, Destino, Orden)

4. Los objetos que forman una Factura.

Origen, Destino y Orden son "hojas" de un objeto compuesto, la factura.

5. Las facturas que forman al objeto compuesto, base de datos.

Todas las facturas son hojas de una base de datos.

El Patrón Compuesto es bueno usarlo cuando necesitamos implementar un código que necesite agregar, remover, borrar, modificar, guardar, etcétera; algún dato u objeto, es decir, cuando se implementa algo parecido a una base de datos o un registro.

ITERATOR (Iterador - De comportamiento)

Posiblemente lo usemos y no nos demos cuenta, es un buen patrón de diseño cuando necesitamos acceder a información de manera secuencial.

- Cuando se quiere acceder al contenido de un objeto agregado sin revelar su representación interna.-
- Cuando se quiere permitir múltiples tipos de recorridos sobre objetos agregados.
- Cuando se quiere proporcionar una interfaz uniforme para recorrer diferentes estructuras de agregación.

Éste patrón lo utilizo en cierto momento de mi código, cuando necesito accesar a los datos que almacene en la Orden, mi objeto Orden es una lista de Conceptos a facturar, entonces yo necesito accesar a dicha lista por medio de un iterador para observar las características de cada uno.

También necesito accesar a la información de la base de datos una vez que la almaceno temporalmente en el programa.
Cuando implemente la búsqueda de Clientes o Facturas, necesitaré almacenar todas las coincidencias en una lista temporal, y posteriormente accesar a ella mediante un Iterador para observar el objeto buscado.

Bueno amigos, estos son los Patrones de Diseño que relaciono con mi proyecto, además, espero que les sea útil la información y para posteriores referencias les dejo las páginas que visité para saber más sobre patrones de diseño.


Y un libro que se llama PRO JavaScript Design Patterns (Ya no tengo el link pero es un libro que obtuve en PDF)

SALUDOS


jueves, 24 de marzo de 2011

Demostración de avance parcial

Taller de Programación Orientada a Objetos - Semana 8 - Reporte 7

Que tal amigos! En esta entrada voy a mostrarles una breve explicación y ejecución del código de mi proyecto.

Como recordaran, estoy realizando un Sistema de Facturación Electrónica para una empresa de logística empresarial.

Actualmente para lograr mi objetivo estoy trabajando con 5 clases:


La clase Bill que es la factura.
La clase Billing que es el módulo principal de facturación, contiene la función main por lo que es el inicio de la aplicación.
La clase Items que representa los artículos o conceptos del pedido.
La clase Order que es una lista de artículos y conceptos.
La clase Person que son las personas involucradas en la factura, Cliente y Proveedor.

En este caso vamos a analizar la clase Billing.

Lo primero que se va a realizar es generar un nuevo módulo de facturación y llamar a la función mainMenu() la cual mostrara el menú principal.




Esta pantalla muestra 3 opciones, 1. Factura 2. Base de Datos 3. Salir.





Si entramos a la opción Factura se desplegarán 3 nuevas opciones: 1. Nueva factura 2. Buscar 3. Salir.




En el menú principal, si entramos a la opción Base de Datos se desplegarán 6 nuevas opciones: 1. Ver 2. Alta 3. Baja 4. Modificar 5. Buscar 6. Salir.



Las opciones de Base de Datos solo muestran los mensajes de las acciones que se realizarán dependiendo de la opción seleccionada.




En la opción Factura del menú principal, la opción Buscar solo mostrara una impresión en pantalla indicando que una factura se buscará.
La opción Nueva Factura ira pidiendo algunos datos para generar un cliente y almacenar cada uno de los datos pedidos en los atributos del mismo.





Ahora en éste video verán la ejecución del código, debido a una falla del micrófono de mi computadora, tendremos que verlo en silencio, lo cual esta bien porque si leyeron la explicación de arriba solo basta con observar :)


Como pueden ver por ahora el diseño esta bien aunque algo simple, no obstante ya tengo los algoritmos necesarios para programar las opciones de la base de datos (alta, baja, buscar, etcétera).
Así mismo ya estoy en búsqueda de las librerías necesarias para poder exportar mis facturas a un formato electrónico y para imprimirlas físicamente.

Espero les haya gustado mi explicación y les sirva de algo mi entrada.

Saludos!! :)

martes, 22 de marzo de 2011

Presentación de Diagramas UML y de Secuencia

Programación Orientada a Objetos - Semana 8 - Reporte 7

Hola a todos!!

Estas son las diapositivas que corresponden a la presentación de mis diagramas, referentes a mi proyecto.




Este es el diagrama UML correspondiente a mi diseño actual. Cabe mencionar que con este diseño he logrado implementar algo de código que funciona correctamente.
A grandes rasgos, en primer lugar podemos ver que todas mis clases están encapsuladas dentro del paquete toBill.
(De izquierda a derecha) Posteriormente tenemos la clase Billing que por ahora funciona como la clase principal de mi programa, esta clase incluye otra llamada Proxy cuyo funcionamiento es crear un puente que comunique a la aplicación con la base de datos. Billing tiene como atributo una factura Bill.
Bill tiene como atributos un cliente, un proveedor y una orden (Client, Supplier, Order). Los métodos implementados dentro de la clase factura incluyen la capacidad de imprimirse a si misma, exportarse a otros formatos y realizar los cálculos necesarios.
La clase Person es la siguiente, de ella se dividen 2: Client y Supplier que son las 2 partes involucradas en el proceso de facturación. En esta clase se implementa un poco de herencia.
La clase siguiente es Order, la cual es una lista de Items o articulos a facturar. Order puede añadir artículos a la lista, removerlos e imprimir su contenido.
Por último tenemos a la clase Item que son cada uno de los conceptos o artículos a facturar. Se trata de nodos los cuales se van encadenando para formar una lista.



Aqui se visualiza el proceso actual que se sigue para armar una factura.
Todo comienza cuando el usuario inicia la aplicación lo cual genera un nuevo módulo de facturación Billing. Con ello se activan los métodos para continuar con el proceso.
Posteriormente se llama al método getData() el cual está dentro de Billing. getData() tomara uno a uno los datos del cliente y los irá almacenando en variables temporales; una vez terminado se generá un nuevo objeto Client y los valores de las variables temporales se envían a los atributos al constructor de Client, con lo que finaliza la primera parte que es generar el cliente.
Después, getData() comienza abriendo un ciclo con el cual se pretende pedir los artículos a facturar, el ciclo. Se genera la Order y un Item, se van pidiendo los datos del Item los cuales se almacenan en sus respectivas variables y una vez terminado, el Item se añade a la lista principal, es decir, Order.
Una vez generados estos dos objetos, se envían al constructor de Bill para generar la factura, la cual posteriormente se puede imprimir, exportar a otros formatos o guardar.


Espero le entiendan a mi presentación.
Dudas o sugerencias no duden en comentar

SALUDOS

miércoles, 16 de marzo de 2011

Código autogenerado y comparación

Taller de Programación Orientada a Objetos - Semana 7 - Reporte 6

COMPARACIÓN DE DIAGRAMAS


1. Diagrama diseñado por mi.






2. Diagrama autogenerado por mi código



Aunque en escencia son lo mismo, la verdad es que ambos difieren en varios aspectos.
Los mas importantes a resaltar son primeramente las variables. Podemos ver que en el diagrama que yo diseñe se ven las variables dentro de la cajita de las clases, pero en el diagrama autogenerado no aparecen. Esto es porque el nivel de acceso por default en el primer diagrama es "PUBLIC", mientras que en segundo diagrama mis variables estan declaradas como "PRIVATE", por eso aparecen ocultas.

Otra diferencia es la declaración de algunos métodos. Prinicipalmente los constructores de cada clase, que en el primer diagrama solo aparecen declarados y en el segundo aparecen incluso con los parámetros que éstos recibirán.

En ambos aparecen por medio de flechas con la punta en forma de rombo, las uniones de las clases que envían parámetros a otras, y el nombre de la variable arriba, debajo o a un lado de la flecha.

Para mi ambos tienen cosas que le faltan al otro. El primero muestra mas funciones, ya que es en el que estoy visualizando mi código con mas imaginación. Mientras que en el segundo me falta implementar mis ideas para que se complete correctamente.

COMPARACIÓN DEL CÓDIGO

El código fue muy diferente en ambos casos, para empezar, la autogeneración de código me produjo más clases que las que de verdad tengo y necesito, además de dividirme el proyecto en 2 partes: LogicalView (¿?) y toBill (paquete real):

Mayor cantidad de clases:
logicalview




toBill




Clases reales




Otra diferencia es que código autogenerado por el diagrama UML diseñado por mi no compilo muy bien, creo que se debío principalmente a la extraña forma en que se declaro el contructor de cada clase:

Algunos constructores autogenerados








Constructores correctos.




Otra diferencia que hay es que en lugar de tener un solo método para tomar los datos y posteriormente enviarlos al constructor, se autogeneraron varios métodos "GET" y "SET" (para tomar los datos y despues colocarlos en su atributo correspondiente).
Esto me dio un poco de desconfianza pero prefiero mi método personal el cual es más corto y funcional (en mi opinión)

Métodos SET y GET






Método getData()




Otro error visible en la autogeneración es que la clase Bill (factura) hereda los atributos de Paper (factura en papel) lo cual esta equivocado ya que es a la inversa:

Incorrecto (Autogenerado)

Correcto


Estos son los detallitos mas sobresalientes de ambos, lo demás son simples funciónes vacías las cuales ya estan completadas en mi código. Asi como espacios para los comentarios, etcétera.

SALUDOS!!!

Diagramas UML y Diagramas de Secuencia

Programación Orientada a Objetos - Semana 7 - Reporte 6

Usar diagramas UML resulta bastante útil cuando deseamos programar una aplicación bajo el paradígma orientado a objetos. Dichos diagramas nos ayudan a planear, visualizar y entender la estructura de nuestra aplicación en terminos de clases y jerarquías.

Para realizar los diagramas UML utilice la aplicación UMBRELLO, esta aplicación es capaz de generar código fuente a partir de nuestro diagrama, y viceversa.

DIAGRAMA UML

Aqui les muestro el diseño actual de mi aplicación. Todo está probado, es decir, compila y se ejecuta correctamente.


En él pueden observar la estructura principal del código que estoy implementando. Hasta arriba pueden ver que todas mis clases pertenecen al paquete toBill (facturar).
Después, en el siguiente nivel pueden ver las clases que necesito para hacer funcionar mi código, tengo primeramente la clase Billing que es el módulo principal de facturación, es decir, la clase que generará la interfaz gráfica. En esta clase se implementa otra subclase llamada Proxy que es la encargada de comunicar el módulo de facturación con la base de datos.
También necesito la factura en si, que esta representada por la clase Bill, tenemos como atributos un cliente, un proveedor y una orden (Client, Supplier, Order). Y la factura hasta ahora puede calcular sus totales y descuentos, exportarse a si misma a otros formatos e imprimirse. A partir de Bill se implementas 2 subclases más, Paper (factura en papel) y Electronic (factura digital).
También se especifica a las personas involucradas en la clase Person, la cual tiene como atributos todos los datos personales del cliente y del proveedor. Como se puede ver, apartir de esta clase se implementan dos subclases más: Supplier (o proveedor) y Client (o cliente).
Siguiendo en el segundo nivel, podemos observar la clase Order la cual tiene como atributos un Item (artículo) y numItems (número de artículos). Los métodos de la clase Order permiten: agregar artículos (add()), quitar artículos de la lista (remove()) e imprimir la lista de artículos (toPrintItems()).
Por último, la clase Items es una clase nueva, que implemente al diseñar mejor mi orden como una lista, entonces esto convierte a mis artículos en nodos de una lista. Mi orden es la lista y mis artículos los nodos. Esto me facilito mucho el diseño de la factura.
Como atributos se tiene un root que es el puntero a los nodos, el código del artículo, la descripción, la cantidad y el precio.

DIAGRAMA DE SECUENCIA

Aqui les muestro el diagrama de secuencia en el cual se detalla el proceso actual que se sigue para generar una factura. De igual forma, dicho proceso esta probado y se crean objetos completamente funcionales.



Primeramente, el Usuario va a inicializar el módulo de facturación generando un nuevo objeto Billing, como aún no tengo un menú implementado, el módulo de facturación pasa directamente a la función getData() en donde se pedirán los datos del cliente uno a uno. Después se crea el objeto Client y mediante el constructor se colocan las variables en su lugar.
Despues se va pidiendo la orden, artículo por artículo. Se crea la lista Order y se pide la información de cada Item despues de generán los Items para almacenar la información pedida y a la vez ligarlos a la lista. Mediante un loop while se van pidiendo más y más artículos hasta terminar, también podemos eliminarlos.
Por último se crea una nueva factura Bill y se le envían a su constructor la orden que acabamos de crear y el nuevo cliente. Esto da forma a la factura la cual posteriormente podemos Eliminar, guardar, imprimir o exportar

Espero les haya gustado mi explicación, y le hayan entendido. A mis colegas que estamos compartiendo la misma idea del proyecto, espero que les sirva.

SALUDOS :)

jueves, 24 de febrero de 2011

PROYECTO: Especificación Técnica

Taller de Programación Orientada a Objetos – Semana 5 – Reporte 5`

SISTEMA DE FACTURACIÓN





Título: Especificación Técnica "Sistema de Facturación"
Autor: Juan Carlos Espinosa Ceniceros
Version del software: 0.3

Índice:
0. Introducción y Generalidades
1. Clases y Métodos
2. GUI
3. Base de Datos

0. Introducción



El Sistema de Facturación involucra una serie de interfaces que en conjunto generan uno de los sistemas de administración más poderoso del mundo.

0.1 Objetivo



El objetivo del software es mejorar la administración de una empresa, proporcionando las herramientas necesarias para:
- Facilitar la creación de facturas.
- Facilitar la contabilidad de la empresa.
- Reducir tiempos y costos.

0.2 Descripcion Funcional



El sistema contempla las siguientes funciones:
- Manejar una base de datos con todos clientes.
- Manejar una base de datos con las facturas.
- Mantener un registro de todos los movimientos realizados a una factura, un cliente y a la base de datos en general.
- Generar de forma automática reportes de contabilidad, ya sean diarios, semanales, quincenales o mensuales.
- Generar según las necesidades del usuario, copias digitales de cada documento, las cuales podrán ser impresas cuando sea necesario.
- Permitir la búsqueda de un documento, aplicando una variedad de filtros según las necesidades del usuario.

0.3 Aspectos técnicos



- Sistema portable (compatible, por lo menos, con los 3 sistemas operativos más usados en PCs)
- Escrito en lenguaje de programación JAVA, integrando librerías de MySQL.
- Incorporación de todas las librerías necesarias para exportar documentos a PDF, impresora y facturación electrónica

Se trata de un sistema monousuario, basado en las necesidades de una sola persona que a su vez es la administradora del negocio, por lo que no se ha pensado en implementar algún sistema de seguridad. Aún asi se ha evaluado esta opción y posiblemente se incluya un sistema de control en el cual sea necesario introducir una contraseña para realizar algunas acciones delicadas. No se tienen visualizadas dichas acciones delicadas, pero se espera que con el tiempo salgan a relucir estos detalles.

1. Clases y Métodos



Se contemplan 4 clases padre diferentes y 5 subclases. Una mejor funcionalidad posiblemente se traduzca en algunas clases extra, pero eso se verá conforme haya más avances.

1.1 Clase Billing



Es la clase principal, prepara la interfaz gráfica creando la ventana principal, una barra con menús y una barra de herramientas. Controla las comunicaciones entre las demás clases y la comunicación entre la base de datos y la aplicación principal. Cierra las comunicaciones y finaliza la aplicación.

1.1.1 Subclase Proxy



Su función principal es abrir un camino entre la aplicación principal y la base de datos. Sus atributos pueden ser una factura y una persona. Abre, manipula, guarda y cierra la base de datos. Busca, abre, manipula, guarda y cierra archivos.

Métodos de la Subclase

1.1.1.1 Método write()

Su función es guardar algún dato dependiendo del tipo de información recibida, puede recibir una factura o un cliente. El método responde de diferente forma a cada caso. Si el dato es un cliente, se procede a almacenarlo en la base de datos. Si el dato es una factura, se procede a guardarla en un formato compatible. Para ello se genera ya sea un nuevo archivo en la computadora o un nuevo registro en la base de datos. Los datos se escriben en el archivo de forma que puedan ser extraídos fácilmente después y se procede a almacenarlo. Los datos del cliente se vacían en el registro y se procede a guardarlo en la base de datos.
*NOTA: Aún falta definir el formato y la manera de guardar la factura. Falta generar la base de datos.

1.1.1.2 Método read()

Su función es extraer datos, ya de una factura o de la base de datos. Recibe un string que indica el valor a extraer y un entero cuya función es actuar como bandera e indicar el tipo de dato enviado. El método abre la base de datos o un archivo según sea el caso. Posteriormente se lee en busca de coincidencias, una vez que se ha dado con el dato, esté se almacena en alguna variable, lista o estructura y se regresan los datos que se han pedido.
*NOTA: Aún falta definir el proceso para ejecutar este método y la forma en que los datos serán regresados.

1.1.1.3 Método find()

Su función es realizar búsquedas profundas, puede combinarse con el método read() para generar resultados. Una vez realizado el proceso de read() su función será ordenar los datos hallados y mostrarlos en una estructura lógica que pueda ser interpretada fácilmente por el usuario.
Recibe un string que indica el valor a extraer y un entero cuya función es actuar como bandera e indicar el tipo de dato enviado. Regresa los resultados de la búsqueda.
*NOTA: Falta la implementación completa.

1.1.1.4 Método delete()

Se encarga de eliminar una factura o cliente de la base de datos. Su funcionalidad se combina con los métodos read() y find() para poder ubicar el archivo o dato preciso a eliminar.
Simplemente borra el archivo o registro seleccionado sin alterar la estructura de los demás registros o archivos. Recibe un string que indica el nombre del archivo o registro a eliminar y un entero cuya función es actuar como bandera e indicar el tipo de dato enviado. Regresa un entero, 0 para éxito, cualquier otro valor para error. Posteriormente se muestra un mensaje indicando la razón del error.
*NOTA: Falta la implementación

1.1.2 Método gui()


Como su nombre lo indica, contiene todas aquellas instrucciones necesarias para generar la interfaz gráfica. Importa funciones de la librería javax.swing para crear ventanas, paneles y botones necesarios para la interfaz. Se genera la ventana principal y los paneles donde se colocarán los demás elementos (botones, cuadros de texto, etcétera). Se definen tamaños, colores y demás elementos necesarios.

1.1.3 Constructor



public Billing(): Es el constructor de la clase, su función es generar una nueva área de trabajo. Provee los canales de comunicación y demás funciones.

1.1.4 Método principal



public static void main (String[] args ): Clase principal dentro de cualquier código generado en el lenguaje de programación JAVA, se encarga de llamar al contructor y al método Gui().
*NOTA: Falta la implementación avanzada del constructor, el método gui() y el método main().

1.2 Clase Person



Son las personas involucradas en una factura, es decir, el proveedor y el cliente.
Esta clase tiene dos subclases:

1.2.1 Subclase Client



Genera un nuevo cliente, es el primer paso para generar la factura. Los atributos son los justos para lograr una buena identificación del mismo.

1.2.2 Subclase Supplier



Genera un nuevo proveedor para la factura, esto es en teoría ya que solo existe un solo proveedor. Por consiguiente se tiene la teoría de que los datos de esta persona serán estáticos a menos que se necesite lo contrario.

1.2.3 Método getData()

Su función es pedir los datos que almacenaran los atributos del cliente. Se necesita primero implementarlo en la línea de comandos, una entrada y salida básica de datos. Posteriormente se debe implementar en forma de cuadros de texto en la ventana principal. Los datos son almacenados en el cliente. El cliente debe enviarse a la factura para su posterior manipulación.

1.3 Clase Order



Es el primer paso para generar una factura, se crea una lista con todos los artículos incluidos en la orden de compra.

1.3.1Método getOrder()

Su función es capturar la orden y almacenar la información en los atributos de la misma. Se implementa una interfaz secilla, una entrada y salida de datos básica en la terminal. Después se implementa por medio de campos de texto en la interfaz. Toda la orden se almacena, se empaqueta y es enviada a la factura.

1.4 Clase Bill



Es el último lugar que visita toda la información que hemos capturado, por consiguiente, es la clase que se encarga de generar la factura y redireccionarla de diferentes formas.
La clase tiene como atributos un proveedor (Supplier), un cliente (Client) y un pedido (Order). La unión de estos tres conforma la factura. Posteriormente la factura queda en Standby, esperando alguna instrucción del usuario. Dichas instrucciones quedan definidas por los siguientes métodos:

1.4.1 Método make()

Hasta ahora es un método hipotético. Su función será generar folios para sí misma, el cual debe ser progresivo y diferente a todos los anteriores, posteriormente se unirán las 2 personas (Person [Supplier, Client]) y el pedido. Se generara la factura.
Su función parece más la de un constructor, pero veremos si es necesario para realizar otras acciones.

1.4.2 Método export()

Su función es la de exportar la factura a diferentes formatos, puede ser en formato local para simplemente guardarla en la computadora.
También se puede exportar la factura a PDF para generar una versión electrónica. Y la última opción es generar una versión compatible para ser impresa.
*NOTA: Falta la implementación de ambos métodos y las librerías que ayudaran a exportar

2. GUI



La ventana principal es generada por el método gui() dentro de la clase principal Billing.
gui() genera una ventana, posteriormente se genera la barra de menús con 3 botones a los cuales se asignan estas funciones:

1. Nueva Factura: Provee herramientas para generar una nueva factura y otras acciones.
2. Base de Datos: Provee herramientas para manipular la base de datos.
3. Búsqueda: Provee herramientas y filtros para buscar un cliente o factura.

Los tres botones anteriores son montados en un panel tipo gridLayout()

Cada uno de los menús afecta una segunda barra llamada barra de herramientas. Esta barra provee acciones específicas para cada menú por lo cual debe ser redibujada cada vez que se cambia entre los 3 menús antes escritos.

Al centro se encontrara el panel principal, por asi llamarlo. Es el panel que cambiara dependiendo del menú seleccionado y posteriormente servirá para mostrar el área con los campos para generar una nueva factura, los resultados de una búsqueda o la visualización de una factura en PDF.

3. Base de datos



Se integra al sistema una base de datos usando MySQL.
*NOTA: Falta la base de datos.

4. Referencias



Estas referencias explican a grandes razgos lo que es una especificación técnica:

http://spanish.joelonsoftware.com/PainlessSpecs/2.html
http://spanish.joelonsoftware.com/PainlessSpecs/WhatTimeIsIt_Spanish.html
http://www.ub.edu.ar/catedras/ingenieria/ing_software/ubftecwwwdfd/espsoft/espsoft.htm
http://es.w3support.net/index.php?db=so&id=677901

Estas referencia contienen ejemplos acerca de como realizar una especificación técnica

http://www.joelonsoftware.com/articles/fog0000000043.html
http://www.cajatrujillo.com.pe/portalnew/doc/proveedores/ESPECIFICACIONESTECNICASSWANTIFRAUDE.pdf
http://www.gridlab.org/Resources/Deliverables/D9.2.pdf

lunes, 14 de febrero de 2011

PROYECTO: Presentación de Temas

Programación Orientada a Objetos - Semana 5 - Reporte 5

Les subo las diapositivas de mi clase, están muy claras y creo no necesitan explicación alguna :)











domingo, 13 de febrero de 2011

PROYECTO: Documentación y Herramientas Avanzadas de desarrollo

Taller de Programación Orientada a Objetos – Semana 4 – Reporte 4

Que tal compañeros!!

En la siguiente entrada les mostraré como aplique la herramienta JAVADOC a mi código en particular. La verdad fue muy fácil y sencillo y lo mejor es que no hay que instalar nada (tomando en cuenta que han instalado el JDK, y que están codificando en el lenguaje JAVA)


Para referencias de cómo instalar JDK en sus equipos den clic AQUÍ


Para empezar hay que identificar cada clase, y a su vez los métodos que dicha clase, y a su vez los parámetros que recibe el método y el valor que regresa.
Después hay que tener aunque sea una vaga idea de para qué sirve cada parte que hemos identificado, para así lograr generar un comentario sólido y explicar claramente su funcionalidad.

Posteriormente procederemos a generar nuestra documentación con el comando: javadoc, en mi caso con la siguiente sintáxis:

En las imágenes pueden ver ejemplos de los comentarios que introduje en mi código, así como parte de las clases con sus métodos que intenté explicar.





Después de una serie de comentarios parecidos en otras clases y métodos de mi código logré un resultado como este:



Son varias capturas de pantalla donde se muestra la documentación generada por Javadoc.

Y una parte del HTML generado, también vía captura de pantalla.






Espero les sea útil esta información

Saludos!!!