Demo Final

Aqui esta el codigo fuente de la presentacion final y la documentacion de usuario para descargar.

Documentacion de Usuario y Codigo

Proyecto. Documentacion Tecnica

Esta entrada es correspondiente a la documentacion tecnica de nuestras clases en mi caso utilice como herramienta Javadoc.

 

La liga para descargar el paquete con la documentacion es la siguiente.

 http://www.megaupload.com/?d=HEORAJ8I

Saludos (:

Proyecto. Implementacion de Pruebas Unitarias

La implementacion de Pruebas Unitarias fue algo facil ya que solo tuvimos que instalar la herramienta necesaria para poder realizar este tipo de pruebas en este caso JUnit.

El resultado arrojado mediante esta herramienta son los siguientes, aqui muestro probe todas las clases que maneja mi sistema y al parecer no arrojo error alguno.

Autogeneracion de Codigo.

Esta entrada corresponde a la comparacion de codigos entre el generado mediante el diagrama con una herramienta case y el realizado actualmente.En el mio se generaron varios codigos asi que solo mostrare 3 que me parecen los principales.
 Clase Base de Datos
CODIGO AUTOGENERADO.

import java.util.*;
/**
 * Class BaseDeDatos
 */
public class BaseDeDatos {
  //
  // Fields
  //  
  //
  // Constructors
  //
  public BaseDeDatos () { };
  //
  // Methods
  //
  //
  // Accessor methods
  //
  //
  // Other methods
  //
  /**
   */
  public void Conexion(  )
  {
  }
  /**
   */
  public void getst(  )
  {
  }
  /**
   */
  public void getCt(  )
  {
  }
} 

Bueno aqui nos manda mas metodos que no aparecen en mi codigo original, algo de similitud serian el metodo "get" que nos regresaria un valor que nos dira si la conexion es correcta. Mi codigo original es el siguiente aqui mismo cree el objeto VEliminar para mandar llamar a la clase del mismo nombre y poder eliminar el registro seleccionado de la base de datos tambien.

import java.sql.*;
import java.util.*;

public class DBManagement {

    private final static String drv ="com.mysql.jdbc.Driver";
    private final static String db = "jdbc:mysql://localhost:3306/bdlogin";
    private final static String user = "root";
    private final static String pass = "131090";

    private String contra;//
    private String usuario;//
    
    Connection ct;
    private Statement st;
    private ResultSet rs;

    public DBManagement()
    {
    try
        {
        Class.forName(drv);
        ct = DriverManager.getConnection(db, user, pass);
        st = ct.createStatement();

        System.out.println("Conexion Exitosa");
        }catch(Exception e)
        {
        System.out.println("No se Puedo conectar");
        }
    }
//constructor para extraer los datos de una tabla sql//
    public void showAll()
    {    
    try{
        ResultSet rs = st.executeQuery("SELECT * FROM Directorio");
        while(rs.next()){
  System.out.println(rs.getString(1)+"|"+ rs.getString(2)+"|"+rs.getString(3));
        }
        }catch(SQLException e){

        System.out.println(e.getMessage());
        System.out.println("Error al realizar la consulta");
    }
    }
    public void eliminarID(int IDtxt)
    {
    try
    {
        st.executeUpdate("DELETE FROM Directorio WHERE ID = "+IDtxt);
    }catch(Exception e)
    {
        System.out.println("No se pudo X_X");
    }
    }
    public Statement getst(){
     return st;
   }
} 

Otra seria la de Inicio de Sesion, aqui el usuario y la contraseña los puse establecidos ya que se me dificulto un poco poder integrar muchas partes de codigo y batalle para poder ingresar mas usuarios, asi que solo es uno por el momento.

AutoGenerado.

import java.util.*;
/**
 * Class InicioSesion
 */
public class InicioSesion {
  //
  // Fields
  //
  private String usuario;
  private String password;
  
  //
  // Constructors
  //
  public InicioSesion () { };
    //
  // Methods
  //
  //
  // Accessor methods
  //
  /**
   * Set the value of usuario
   * @param newVar the new value of usuario
   */
  private void setUsuario ( String newVar ) {
    usuario = newVar;
  }
  /**
   * Get the value of usuario
   * @return the value of usuario
   */
  private String getUsuario ( ) {
    return usuario;
  }

  /**
   * Set the value of password
   * @param newVar the new value of password
   */
  private void setPassword ( String newVar ) {
    password = newVar;
  }
  /**
   * Get the value of password
   * @return the value of password
   */
  private String getPassword ( ) {
    return password;
  }
  //
  // Other methods
  //
  /**
   */
  public void getVerificar(  )
  {
  }
  /**
   */
  public void getData_BD(  )
  {
  }

Mi codigo:
Aqui tengo mas implementacion de Interfaz Grafica y pues los atributos no cambiaron mucho seria usuario y password y  nos muestra si el usuario existe o no ya que este esta registrado en la base de datos.

import javax.swing.*;
import java.io.*;
import java.sql.*;
import java.awt.Panel.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ActionListener.*;

public class VentanaLogin extends JFrame implements ActionListener
{
    private JTextField txtUser, txtPass;
    private JLabel lblUser,lblPass;
    private JButton btnAceptar, btnCancelar;
    private DBManagement BaseDatos = new DBManagement(); 
    String usuario, elPassword;

    public VentanaLogin()
    {
    Container contenedor = getContentPane();
    contenedor.setLayout(new FlowLayout());
    //crear etiqueta y cuadro de texto del usuario
    txtUser = new JTextField(10);
    lblUser = new JLabel("Usuario: ");
    txtUser.setToolTipText("Escriba su nombre de usuario");
    contenedor.add(Box.createVerticalStrut(50) );
    contenedor.add(lblUser);
    contenedor.add(txtUser);
    //crear etiqueta y cuadro de texto del pw
    txtPass = new JPasswordField(10);
    lblPass = new JLabel("Contraseña: ");
    txtPass.setToolTipText("Escriba su contraseña");
    contenedor.add(lblPass);
    contenedor.add(txtPass);
    //Crear y agregar los botones
    btnAceptar = new JButton("Iniciar Sesion");
    //establecer Boton aceptar por defecto 
    getRootPane().setDefaultButton(btnAceptar);

    btnCancelar = new JButton("Cancelar");
    contenedor.add(btnAceptar);
    contenedor.add(btnCancelar);

    btnAceptar.addActionListener(this);
    btnCancelar.addActionListener(this);
    //crear un escuchador 
    
    setTitle("Iniciando");
    setSize(500,300);
    setResizable(false);
    Dimension tamFrame = this.getSize();
    Dimension tamPanalla = Toolkit.getDefaultToolkit().getScreenSize();

    setVisible(true); //Hacer visible al frame
    }
    public boolean validarUsuario(String elUser, String elPass) throws IOException
    {
try
    {
    ResultSet resultadosConsulta = BaseDatos.getst().executeQuery("SELECT*FROM usuarios WHERE usuario ='"+elUser+"' AND password='"+elPass+"'");

    if(resultadosConsulta.first())
        return true;
    else 
        return false;
    }catch (Exception e)
    {
    e.printStackTrace();
    return false;
    }
  }

public void actionPerformed(ActionEvent evt)
    {
        if(evt.getSource() == btnAceptar)
        {
            try {
                if(txtUser.getText().length() > 0 && txtPass.getText().length() > 0)
            {

            if( validarUsuario(txtUser.getText(), txtPass.getText()))
            {
                  setVisible(false);
                  JOptionPane.showMessageDialog(null, "El nombre de Usuario y/0 contrasenia son validos");
                  JOptionPane.showMessageDialog(null, txtUser.getText()+" " +txtPass.getText() );
            GUI g = new GUI();
            }
            else
             {
                  JOptionPane.showMessageDialog(null, "El nombre de Usuario y/0 contrasenia no son validos");
                  JOptionPane.showMessageDialog(null, txtUser.getText()+" " +txtPass.getText() );
                  txtUser.setText("");
                  txtPass.setText("");
                  txtUser.requestFocusInWindow();
             }
            } 
            else 
                {
                JOptionPane.showMessageDialog(null, "Debe escribir usuario y contrasena\n" + " no dejar campos vacios");
                }
            }catch(Exception e)
            {
                e.printStackTrace();
            }
        }else if(evt.getSource() == btnCancelar)
        {
            System.exit(0);
    }
    }
    public static void main(String[] args)
    {
    VentanaLogin prueba = new VentanaLogin();
    prueba.setDefaultCloseOperation(prueba.EXIT_ON_CLOSE);
    }
}

Proyector. Implementacion de Sistemas Distribuidos

Para la implementacion de sistemas Distribuidos por el momento no aplica ya que solo es para un negocio personal.
Pero podria implementarse futuramente ya que podria trabajar en linea para generar las facturas electronicamente para que los clientes puedan acceder en linea. 
Como podria implementarse un sistema de seguridad, mediante un rfc unico para que toda su informacion no pueda ser alterada.
Manejar este tipo de sistema tienen la posibilidad que sus sistemas de facturación interactúen directamente con sistemas informáticos del SIN.
Tambien podria tomarse en cuenta que pueda accederse a  el con diferentes sistemas operativos.

Proyecto. Interfaz Gráfica

Aqui mostrare algunas de la interfaz grafica de mi software no fue algo muy grande ya que tuvimos poco tiempo para implementar todo, solo son las principales inicio de sesion al sistema, y mostraria el registro de clientes.

Proyecto.Implementacion de Eventos, Excepciones y Errores

Bueno esta entrada correspone a la implementacion de Eventos, Excepciones y Errores.
Implementacion de Eventos.
Bueno dentro de mi codigo identifique estos eventos creo que es importante ya que forma parte de una de mis ventanas principales en esta parte de codigo seria el manejador de eventos.Se utiliza un metodo "getSource" del evento ActionEvent para saber de que boton se produjo el evento, despues compara con cada un de los botones para ver si el evento se produjo y si esto sucede se produce una instruccion determinada.El addMenuItem lo que hace es instanciar un objeto de otra clase.

public void actionPerformed(ActionEvent ae){
    if(ae.getSource() == addMenuItem){
 VAgregar a = new VAgregar();
 this.fillTable();
    }else if(ae.getSource() == readMenuItem){
 this.fillTable();
    }else if(ae.getSource() == eliminar){
 VEliminar v2 = new  VEliminar();  

Bueno otro seria el actionPerformed es algo similar pero hay cosas en la que se diferencia, lo que se hace es checar de donde se produjo el evento, aqui en este evento tambien manejo algunas excepciones, esto seria con el try/catch, esto se hace asi para que se lanze una excepcion en caso que se presente un error al tratar de trabajar con la base de datos. Tambien se verfifico el contenido del JTextField, para checar que no este vacio, y despues me tira un mensaje de que se pudo hacer, y en el catch tambien me tira un mensaje si no se pudo completar el try.

public void actionPerformed(ActionEvent e) 
{
if(e.getSource()==Botonaceptar)
{
IDString = (campoID.getText());
if(IDString.equals("") || IDString.isEmpty()) 
{
JOptionPane.showMessageDialog(this, "ID no registrado");
}else
{
IDtxt = Integer.parseInt(IDString);
System.out.println(query);
try {
dbm.eliminarID(IDtxt);
JOptionPane.showMessageDialog(this, "Registro Eliminado");
this.setVisible(false);
}catch(Exception e1){
JOptionPane.showMessageDialog(this,"No se pudo eliminar el registro");
}
}
}else if(e.getSource() == Botoncancelar){
this.setVisible(false);
}
}  

Excepciones y Errores.
El manejo de excepciones siempre va dentro del escuchador de eventos, ya que alli es donde se ejecutan las sentencias de SQL, esta es una parte del codigo.

public void actionPerformed(ActionEvent e){
     JButton b = (JButton)e.getSource();
  
 if(b==boton_aceptar){
     c = (campocliente.getText());

t = (campotel.getText());
            d = (campodir.getText());
            l = (campoloc.getText());
          IDc = (campoIDc.getText());
  //Sentencias para pasar los valores al registro//
try{ 
 rows_updated = 0;
PreparedStatement aux = objeto_base.ct.prepareStatement("INSERT INTO Directorio(nombre,direccion,telefono,localida,ID) VALUES(?,?,?,?,?)");
   aux.setString(1,c);
   aux.setString(2,d);
   aux.setString(3,t);
   aux.setString(4,l);
   aux.setString(5,IDc);
  
   rows_updated = aux.executeUpdate();
   
     JOptionPane.showMessageDialog(this, "Registro Agregado"); 
   this.setVisible(false);  
   
     }catch(Exception ev){
   JOptionPane.showMessageDialog(this, "Error al agregar cliente");
      }
  }else if(b==botoncancelar){
      this.setVisible(false);
  }
     }
 }

try{
 ResultSet aux = dbm.getst().executeQuery("SELECT * FROM Directorio");
 while(aux.next()){
     Object[] fila = {aux.getObject(1),aux.getObject(2),aux.getObject(3),aux.getObject(4),aux.getObject(5)};
     //Ide.add((Integer)aux.getObject(5));
     dtm.addRow(fila);
     System.out.println("Cargando Tabla");    
 }
    }catch(SQLException e){
 e.printStackTrace();
 System.out.println("No Cargo");
 } 

Retroalimentacion.

Estos temas fueron los que pudimos comentar mis compañeros y yo esto nos ayudo mucho ya que habia cosas que no recordabamos.

Casos de Uso: es un forma de ver la interaccion con el sistema, viendo que actores pueden hacer tal cosa y como estas estan relacionadas con otras funciones

Diagramas de Secuencia:respresentan el comportamiento del sistema y ke muestran ordenadamente como van sucediendo los escenarios de casos de uso y se realiza uno por cada caso de uso.

Clases: uelen ser publicas con sus atributos privados y metodos publicos nos sirven para divir en varias partes lo que vendria siendo el programa para la hora de codificar no oscureser el codigo teniendo todo en un solo main
Tambien podemos identificar las clases del sistema como sustantivos, los atributos cono caracteristicas y los metodos como verbos.

Documentacion:la documentacion sirve para mostrarnos los requerimentos del sistema, como los casos etc.. el disenio,: como la arquitectura del sistema los diagramas de clase y de secuencia, y la tecnica del sistema ke es el codigo creado, es importante documentar bien todo lo que hacemos porque por ejemplo nunca sabemos quien mas va a estar trabajando en el codigo pudiera ser alguien que no lo diseno y debe ser claro cada una de las cosas que hace para que cualquier persona pueda trabajar en el.

Las pruebas unitarias: nos ayudan a encontrar posibles errores de los cuales no nos hayamos percatado y de esta manera probar si el funcionamiento es correcto, una herramienta util es JUnit.

Otra cosa importante es que en la prgramacion OO tenemos la reutilizacion de codigo, lo que nos permite ahorrarnos tiempo, y un poco de trabajo.

Sistemas Distribuidos

Unos de los concepto de Sistemas Distribuidos que vimos en clase es el siguiente:

Colección de computadoras autónomas, conectadas mediante una red y middleware distribuido que las habilita para coordinar sus actividades y compartir los recursos del sistema, de tal suerte que los usuarios lo perciban como una sola entidad.

En esta entrada correspone en como a mi proyecto podria aplicarsele un  sistema distribuido, esto seria algo asi equivalente en una tienda de conveniencia en linea, aqui podria descargarse la aplicacion en pdf.

Para esto implemente algunas cosas como  la seguridad del sistema, donde solo hasta ahorita el administrador que puede modificar o realizar cambios para evitar que haya modificacion o alteraciones en el sistema y en este caso los datos de los clientes son confidenciales hasta ya que se muestra la factura.

Tambien podria implementarse ya que sea el sistema distribuido en linea, como método de autentificación el RFC del cliente para que esté a su vez se convertiría en un filtro para solo mostrar las facturas almacenadas en la base de datos que correspondan a ese cliente y nadie mas pueda alterar su informacion.

Patrones de Diseño

Esta entrada corresponde a que patrones de diseño podrian aplicar al software que estamos realizando.

Una de las principales caracteristicas que pretenden los patrones de diseño podria se la Reutilizacion de codigo.

Bueno algunos patrones de diseño que se podrian presentar en el sistema que ahora estoy realizando, podria ser:

Abstract factory ya que este patrón nos permite trabajar con objetos de distintas familias, de tal manera que las familias no se mezclen entre si independientemente del tipo de familia que se use.

facade.(fachada). 

Este se encargara de proveer una interfaz mas unificada mas simple para un conjunto de interfaces de un subsistema. Como una interfaz de alto nivel que hace que el subsistema sea mas fácil de utilizar.

Comand ya que es un patron de comportamiento podria ayudar a registrar las peticiones realizadas por los clientes. 

Hasta ahorita estos son los patrones que pude identificar y puedo utilizar dentro del sistema.

Pruebas Unitarias

En mi proyecto algunas pruebas unitarias que se podrian implementarson las siguietes:

La primera seria el Iniciar Sesion y la segunda es el Ingresar Clientes.

Prueba #	#1
Descripcion	Aqui el cliente ingresar un usuario y contraseña para poder acceder al sistema.
Objetivos	Correcto funcionamiento de Login. Acceso al sistema-
Condiciones	Tener una cuenta ya registrada para que pueda acceder al sistema
Resultado Esperado	Acceso al sistema.
Resultado Obtenido	Se puede acceder al sistema con un usuario valido.

Prueba	#2
Descripcion	Verificar si el cliente existe o ingresar sus datos al sistema.
Objetivos	Mostrar una lista de clientes registrado para generar la factura.
Condiciones	Estar en el registro de clientes.
Resultado Esperado	Clientes almacenados en una base de datos
Resultado Obtenido	Se pueden mostrar los clientes en una base de datos.

Demo1. Taller

Bueno  disculpen la tardanza de esta entrada, pero tuve muchos errores de sintaxis que no me dejaban avanzar en mas funcionamiento, lo unico que pude hacer para la demostracion ahorita es conectar la base de datos de mysql con java, y aqui pude agregar lo que seria la tabla de usuario para el sistema.En este caso solo es un solo usuario Administrador del Sistema.

import java.sql.*;
import java.sql.*;
import java.util.*;


public class DBManagement {


    private final static String drv ="com.mysql.jdbc.Driver";
    private final static String db = "jdbc:mysql://localhost:3306/bdlogin";
    private final static String user = "root";
    private final static String pass = "131090";

    private String contra;//
    private String usuario;//
    
    private Connection ct;
    private Statement st;
    private ResultSet rs;

    public DBManagement()
    {
 try
     {
  Class.forName(drv);
  ct = DriverManager.getConnection(db, user, pass);
  st = ct.createStatement();

  System.out.println("Conexion Exitosa");
     }catch(Exception e)
     {
  System.out.println("No se Puedo conectar");
     }
    }
//constructor para extraer los datos de una tabla sql//
    public void showAll()
    {
 
 try{
  ResultSet rs = st.executeQuery("SELECT * FROM usuarios");
  while(rs.next()){
   System.out.println(rs.getString(1)+"|"+ rs.getString(2));
  }
     }catch(SQLException e){

     System.out.println(e.getMessage());
     System.out.println("Error al realizar la consulta");
 }

    }
    
     public Statement getst(){
  return st;
     }

//}
public static void main(String args[]) {
 DBManagement DBM = new DBManagement();
 DBM.showAll();
   }
} 

Esta es mi primer interfaz grafica para el acceso al sistema principal.

import java.sql.*;
import javax.swing.*;
import java.io.*;
import java.sql.*;
import java.awt.Panel.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ActionListener.*;

public class VentanaLogin extends JFrame implements ActionListener
{
    private JTextField txtUser, txtPass;
    private JLabel lblUser,lblPass;
    private JButton btnAceptar, btnCancelar;
    private DBManagement basedatos = new DBManagement(); 
    String usuario, elPassword;

    public VentanaLogin()
    {
 Container contenedor = getContentPane();
 contenedor.setLayout(new FlowLayout());
 //crear etiqueta y cuadro de texto del usuario
 txtUser = new JTextField(10);
 lblUser = new JLabel("Usuario: ");
 txtUser.setToolTipText("Escriba su nombre de usuario");
 contenedor.add(Box.createVerticalStrut(50) );
 contenedor.add(lblUser);
 contenedor.add(txtUser);
 //crear etiqueta y cuadro de texto del pw
 txtPass = new JPasswordField(10);
 lblPass = new JLabel("Contraseña: ");
 txtPass.setToolTipText("Escriba su contraseña");
 contenedor.add(lblPass);
 contenedor.add(txtPass);
 //Crear y agregar los botones
 btnAceptar = new JButton("Iniciar Sesion");
 //establecer Boton aceptar por defecto 
 getRootPane().setDefaultButton(btnAceptar);

 btnCancelar = new JButton("Cancelar");
 contenedor.add(btnAceptar);
 contenedor.add(btnCancelar);

 btnAceptar.addActionListener(this);
 btnCancelar.addActionListener(this);
 //crear un escuchador 
 
 setTitle("Autentificando usuarios");
 setSize(500,300);
 setResizable(false);
 Dimension tamFrame = this.getSize();
 Dimension tamPanalla = Toolkit.getDefaultToolkit().getScreenSize();

 setVisible(true); //Hacer visible al frame
    }
    boolean validarUsuario(String elUser, String elPass) throws IOException
    {
try
    {
 ResultSet resultadosConsulta = BaseDatos.getst().executeQuery("SELECT*FROM usuario WHERE Usuarios ="+elUser+" AND password="+elPass+"");

 if(resultadosConsulta.first())
     return true;
 else 
     return false;
    }catch (Exception e)
    {
 e.printStackTrace();
 return false;
    }
  }

public void actionPerformed(ActionEvent evt)
 {
  if(evt.getSource() == btnAceptar)
  {
      try {
          if(txtUser.getText().length() > 0 && txtPass.getText().length() > 0)
   {

   if( validarUsuario(txtUser.getText(), txtPass.getText()))
   {
         setVisible(false);
        // GUI ventana1 = new VentanaPrincipal();
        // ventana1.mostrar();
   }
   else
    {
         JOptionPane.showMessageDialog(null, "El nombre de Usuario y/0 contrasenia no son validos");
         JOptionPane.showMessageDialog(null, txtUser.getText()+" " +txtPass.getText() );
         txtUser.setText("");
         txtPass.setText("");
         txtUser.requestFocusInWindow();
    }
   } 
   else 
       {
    JOptionPane.showMessageDialog(null, "Debe escribir usuario y contrasena\n" + " no dejar campos vacios");
       }
      }catch(Exception e)
   {
       e.printStackTrace();
   }
  }else if(evt.getSource() == btnCancelar)
     {
      System.exit(0);
 }
 }
    public static void main(String[] args)
    {
 VentanaLogin prueba = new VentanaLogin();
 prueba.setDefaultCloseOperation(prueba.EXIT_ON_CLOSE);
    }
}  

Proyecto.Eventos,Errores y Excepciones

Primeramente retomemos los conceptos de Errores, Eventos y Excepciones.
Eventos:
Un evento es una accion iniciada por el usuario que esta interactuando con nuestro sistema, por ejemplo, al tener una ventana con botones y el dar click a alguno de esos botones ese es un evento.
Excepciones:
  Las excepciones son objetos que contienen información del error que se ha producido y que heredan de la clase Throwable o de la clase Exception. Si nadie captura la excepción interviene un manejador por defecto que normalmente imprime información que ayuda a encontrar quién produjo la excepción.
Errores:
Los errores por lo general, van más allá de nuestro alcance. Son situaciones criticas que no podemos manejar de forma habitual, incluso, no deberíamos intentar capturarlas y gestionarlas. Indican otro tipo de fallos de los cuales no podemos recuperarnos y solo queda finalizar la ejecución del programa.

EVENTOS:

COMPONENTE GRAFICO GENERADOR	TIPO DE EVENTO	ACCION QUE SE DISPARA
Boton Aceptar, Cancelar	ActionEvent:	Se dirige a la siguiente pantalla o se efectua una accion sobre algun componente.
Maximizar, Minimizar, Cerrar, extender la pantalla	ComponentEvent:	Redimensionar o mover la pantalla.
Boton Agregar,Eliminar,Modificar	ActionListener	va a "escuchar" el menu desplegable de una de mis ventanas principales.

EXCEPCIONES Y ERRORES.

MODO EN QUE SE GENERA	MANEJO
RuntimeException:	errores en el tiempo de ejecución.
IOException:	intentar accesar o modificar archivos inexistentes, o sin el permiso requerido.
Librerías que no están presentes(Error)	ocasionando errores de ejecución y el mal funcionamiento de ciertas partes del código.
Interfaz Grafica	es muy pesada o elaborada, algunos sistemas no pueden cargarla ocasionando la finalización del programa.

Proyecto. Especificacion Tecnica

Bueno esta entrada sera para la especificacion de algunas de los funcionamientos que aun faltan agregar a mi proyecto.
Lista de Funcionalidades que aun no están completas:
El metodo login
La interfaz grafica
El los metodos para agregar, modificar y eliminar. 
*Para que funcionalidad, que falta para completarla:
El lo del usuario que seria el login, necesito que pueda ingresar a la base datos por que de aqui son dos personas las involucradas el proveedor y el cliente para poder tener acceso al sistema de facturacion.
La interfaz pues poder crear las ventanas y llegar al diseño que ya he creado el dibujo de lo que podria ser la interfaz grafica.
Metodos de Agregar, Borrar, Eliminar: En este ya habia podido agreagar clientes pero al cambiar ciertas cosas de codigo ya no me funcionaba.
*Para que funcionalidades, que falta para terminarla:
Pues para lo de agregar, eliminar y modificar checar como podre mdificarlo para que tenga un buen funcionamiento. 

Proyecto. Diagrama de Secuencia

El diagrama de secuencia lo que hace es mostrar la forma en la que interactuan las clases y los métodos para realizar un determinado proceso, podría decirse que los diagramas de secuencia describen el procedimiento que sigue el sistema para realizar un objetivo.

Bueno esta entrada sera referente al diagrama de secuencia aplicado al sistema, en este caso solo puse los objetos mas importantes dentro del sistema.

• Todo comienza cuando el usuario inicia la aplicación y se activan los metodos para continuar con el sistema.
• Posteriormente después pasa a la ventana principal donde se se representan los procesos para agregar eliminar y modificar la información de un cliente,
• Después representar el proceso que se seguiría para imprimir una factura, y finalmente llamando al método para salir del sistema.

Aqui la muestra.

Antipatrones de Diseño(Puntos Extra)

El estudio de los antipatrones es muy útil porque sirve para no escoger malos caminos en el desarrollo de sistemas, teniendo para ello una base documental y así evitar usar simplemente la intuición. Además proporciona una denominación común a problemas que facilita la comunicación entre diferentes desarrolladores.

Antipatrones de desarrollo de software

• The Blob: Este antipatrón se da en objetos con muchos atributos o muchas operaciones. Esto rompe las ventajas de la programación OO, ya que estas clases tan grandes son muy difíciles de mantener, de reusar y de probar.

• Lava Flow: Este antipatrón se da cuando se entrega software antes de ser terminado o suficientemente probado que tiene un código no óptimo y al ser expuesto, sus características no pueden ser modificadas.

 Antipatrones de arquitectura de software

• Vendor Lock-In: El antipatrón “Vendor Lock-in” sucede cuando dependemos de una arquitectura, plataforma o tecnología. Esta dependencia puede tener unas consecuencias muy negativas puesto que nuestros desarrollos pueden ser dependientes de características proporcionadas por terceros, pueden verse “rotos” por el cambio de las características de estas tecnologías, etc…

• Stovepipe system: Este antipatrón se refiere a 2 posibles circunstancias:

a) Un sistema que no puede interoperar con el resto de los sistemas de una organización.

b) Un sistema heredado que un ensamblaje de pequeños sistemas que están tan unidos entre si que no es posible diferenciar cada uno de ellos, imposibilitando su actualización, refactorización.

Antipatrones de gestión de proyectos de software.

• Analysis Paralysis :Parálisis del Análisis (en inglés analysis paralysis) sucede cuando se pretende descubrir y modelar todos y cada uno de los detalles de un sistema informático en una fase inicial, invirtiendo un tiempo excesivo con la intención de no regresar a la etapa de análisis. 

 Referencias

http://santimacnet.wordpress.com/2010/05/29/patrones-y-antipatrones-de-diseno/

http://desdesarrollodesoftware.blogspot.com/2008/06/antipatrones-de-diseo.html

http://www.mcc.unam.mx/~cursos/Algoritmos/javaDC99-2/antipatrones.html

Patrones de Diseño(Puntos Extras)

Un patrón es algún evento, suceso, objeto, en sí cualquier cosa que se repite en el tiempo. 

Existen problemas recurrentes a los cuales puede aplicarse un patrón, dichos patrones reciben el nombre de Patrón de Diseño.

¿Que son los Patrones 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.

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.

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:

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.

Referencias:
Patrones
Patrones de Diseño

Documentacion Tecnica.

La Documentacion es un proceso importante dentro de todo desarrollo de software porque permite conservar la historia, facilita la utilización por parte del usuario, garantiza la permanencia y disminuye los costos de operación y de ejecución del proyecto como tal. Tambien podria definirse como la informacion que nos dice qué hacen los sistemas, cómo lo hacen y para quién lo hacen. 

 La documentacion tecnica implica dos tipo de documentacion la interna y la externa, la documentacion Interna se refiere mas a los programas y la base de datos, y la Externa se refiere a los manuales de uso.

La documentación interna se encuentra dentro del código de la aplicación, especificando la descripción de cambios realizados, fecha, responsable, autorización y cualquier otro dato relevante. 

El software debe contener documentación interna. Los comentarios permiten al programador comunicarse con otros lectores do código fuente. Los comentarios pueden también resultar una clara guía de comprensión durante la última fase de la ingeniería de software –el mantenimiento -.

Importancia de la Documentacion.

La documentación adecuada y completa, de una aplicación que se desea implantar, mantener y actualizar en forma satisfactoria, es esencial en cualquier Sistema de Información, sin embargo, frecuentemente es la parte a la cual se dedica l menor tiempo y se le presta menos atención.

Nosotros como desarrolladores tenemos la obligación de proporcionar a nuestros clientes un documento claro y conciso donde explicamos al funcionamiento de nuestro software; esta será una futura referencia para todos aquellos que quieran ayudarnos a mejorar nuestro software y para guiarlos y que entiendan la visión que tuvimos al momento de construirlo; incluso será una referencia para nosotros mismos ya que en códigos extensos es imposible recordar para que funcionaba y que acción realizaba un segmento de nuestro código.

Referencias.  

Documentacion de Software

Documentacion Interna
Imagen 

Proyecto. Herencia y Polimorfismo

En esta entrada les mostrare las clases de herencia que econtre en mi sistema, bueno yo tome como herencia una clase Personas porque tenemos dos personas que estan involucradas dentro de la factura que son el cliente y el proveedor, otra seria la Clase Factura ya que existe tipos de factura como es la Factura electronica o la Factura en Papel. El siguiente es el esquema de Herencia que se puede aplicar al sistema.

package Proyecto

/*Herencia*/
public class Personas {
    private String nombre;
    private String direccion;
    private String empresa;
    private String mail;
    //constructor
   public Personas (String n, String d, String e, String m) {
       nombre = nom;
       direccion = dir;
       empresa = emp;
       mail = m;
    }
} 
class Proveedor extends Personas {
   public Proveedor (String nom, String dir, String emp, String m) {
 super(nom, dir, emp, m);
    }
}
class Cliente extends Personas {
   public Cliente(String nom, String dir, String emp, String m){
 super(nom, dir, emp,m);
    }
} 

Por el corto tiempo que teniamos para entregar el proyecto y a que un tip que vimos en clase era no forzar la herencia, asi que esta fue la unica que pude visualizar para mi proyecto.
Saludos

Proyecto. Esqueleto de Clases(Taller)

Bueno en esta entrada les mostrare algo de codigo de las clases principales que encontraremos en mi proyecto.

CLASE Factura:
Esta clase es la encargada de generar las facturas, esta contendra los datos que llevara dentro de la misma, el unico metodo que he definidido son el de ingresar datos.

package Proyecto;

public class Factura
{
    //Atributos
    private String Nombre;
    private double Folio;
    private String Proveedor;
    private int Fecha;
    private String Direccion;

    //metodos
    public void ingresar()
    {
    }
} 

CLASE Cliente:
Esta clase lleva los datos de las dos personas que intervienen para realizar la factura que son el cliente y proveedor. Los atributos que podrian intervenir en esta clase serian ingresar y los datos de las personas involucradas.

package Proyecto;
package Proyecto;

public class Cliente
{
    private String nombre;
    private String direccion;
    private Sting email;
    private String contraseña;

    // constructor
    public Cliente(String nom, String dir, String m, String c)
    {
      nombre= nom;
      direccion=dir;
      mail=m;
      contraseña = c
    }
    //Atributos
    
    public void registrar()
    {
    }
   
}
 

CLASE Pedido:
En esta clase llevara los datos de cada producto a registrar.

package Proyecto;

public class Pedido
{
    private String nombreProducto;
    private String codigoProducto;
    private int cantidad;
    //Constructor
    public Producto(String nomProducto, int cantArtic, String numcodigo)
    {

    }
    //Atributos
    public int verificar() 
    {
    }
    public int mostrar()
    {
    }
} 

Proyecto. Herencia y Polimorfismo

En esta entrada veremos si se aplica o no herencia en nuestros proyectos.

Para empezar repasemos algunos conceptos relacionados y ejemplos:

Herencia:

La herencia es una propiedad fundamental en la Programacion orientada a objetos y se refiere que cuando una clase padre (o superclase) comparte atributos y métodos propios con las clases hijas (o subclases).

 Esto se asocia mas en Biologia por ejemplo en la tierra hay muchos Animales(Superclase) pero existen diferentes tipos de animales(mamiferos, reptiles, acuaticos, aereos, etc).

Si lo aplicaremos seria la clase animales hereda atributos a las subclases como(color, tamaño, numero de extremidades, etc), y estos a su vez heredan algunos métodos como(oler, oir, comer,ver).

 La superclase tambien se le conoce como "Clase Padre" y a las subclases como "Clases Hijas".

Las Subclases pueden implementar metodos propios, por ejemplo: las avez vuelan, característica dificílmente compartible con los demás.  

Qué hereda y qué no hereda una clase: 

Una subclase hereda todos los miembros de su súper clase excepto los constructores.

Una subclase no tiene acceso a los miembros privados de su superclase.

Una subclase puede heredar a otras clases. A esto se llama propagación de herencia.

Polimorfismo:  

El polimorfismo lo podemos ver en los metodos, esto es que podemos tener funciones con nombres iguales pero en diferentes clases (sobrecarga), cuando usamos varias funciones con iguales nombres utilizando parametros diferentes (sistema parametrico).  

Aplicado al proyecto. 

En este caso utilizare herencia de las clases predefinidas, y Aqui tendremos la clase padre que la he llamado Factura, dentro de esta tenemos los atributos mas importantes de el sistema, heredan la subclase Producto ya que aqui puden desplegarse que tipos de productos tendremos.

Tambien tendra, una clase llamada BasedeDatos, donde iran métodos como la conexion con la base de datos, la extracion de datos de la base, asi como la escritura de mas informacion en la misma, siendo esta clase hija de una clase "Cliente" donde se almacenaran los atributos mas importante del cliente, ya que al momento de estar facturando es nesesario saber todos los datos del cliente al que se le mostrara su factura.

Referencias. 
Blog de Interes

Diagrama de Clases

En esta entrada les mostrare a lo que es referente a el Diagrama de Clases aplicado en mi proyecto.

¿A que nos referimos con Diagrama de Clases?
Bueno el Diagrama de Clases es parte del Diseño del Sistema, aqui es donde se encuentran las clases que forman parte del sistema, en el cual se muestra el nombre de las clases, atributos y metodos antes definidos en el diseño de clases.

UML es un lenguaje de modelado, no un método.

Un método incluye

• Lenguaje de modelado: Es la notación (en su mayoría gráfica) que

utilizan los métodos para expresar los diseños.

• Proceso: Son los pasos que se aconsejan dar para realizar un diseño.

Referencias:

UML PDF

Saludos. (:

Proyecto(Clase). Diseños con Clases

Bueno esta entrada es para definir el diseño de clases que estarán presentes en el sistema que he elegido. 
Explicación breve de estos conceptos seria la siguiente:

Clases:  

• Implementación de un tipo de dato.
• Definición de propiedades y operaciones.

Características de los Objetos.

Propiedad= atributo de un objeto.
Método = funcionalidad de un objeto.

A esto se le agrega la visibilidad en el diseño de las clases.Tenemos 4 tipos de visibilidad, publica, privada, protegida y package, tratare de explicar cada uno de estos.

 Publica: Los elementos públicos pueden ser usados por cualquier otra Clase.

Privada: sólo accesibles son accesibles desde los métodos de la clase.

Protegida: solo la clase y sus hijos pueden tener acceso.
Package (por defecto): sólo accesibles desde su paquete (no se puede acceder desde sus subpaquetes).

CLASES	Visibilidad	Atributos	Visibilidad	Métodos	visibilidad
Factura	publica	Folio Fecha Proveedor Nombre Dirección	Privada	Llenar Modificar Eliminar Verificar	publica
Cliente	publica	usuario Contraseña	Privada	Ingresar Salir Registrar Verificar	publica
Producto	publica	Nombre de Producto Precio de Producto Código	Privada	Mostrar Verificar la Existencia	publica

Aquí aun me falta la Clase Base de Datos(BD): Para esta seria una de las importantes ya que aquí se concentrara toda la base de Datos que manejara el sistema, la conexion con esta, la extracción de los datos que el usuario ingresara en el sistema, y la consulta de los mismos. Sus métodos serian conexion, y obtener la base de datos esta seria para sacar la información de la base de datos y manipular con otra clase hija que aun no la tengo definida.

Saludos (:

PROYECTO. CASOS DE USO

Primeramente les dare una breve introduccion a que nos referimos con casos de uso y tambien les mostrare como podemos representarlos mediante los Diagramas de Casos de Uso.

LOS CASOS DE USO"

Los Casos de Uso no son parte del diseño (cómo), sino parte del análisis (qué). De forma que al ser parte del análisis nos ayudan a describir qué es lo que es sistema debe hacer. Los Casos de Uso son lo qué hace el sistema desde el punto de vista del usuario. Es decir, describen un uso del sistema y cómo este interactúa con el usuario.  

Bueno ahora si nos enfocamos a la representacion de estos Casos de uso mediante el diagrama. 

DIAGRAMA DE CASOS DE USO.

Un Diagrama de Casos de Uso muestra la relación entre los actores y los casos de uso del sistema. Representa la funcionalidad que ofrece el sistema en lo que se refiere a su interacción externa.

 Elementos: Los elementos que pueden aparecer en un Diagrama de Casos de Uso son: actores, casos de uso y relaciones entre casos de uso.

 Actor: Un actor es algo con comportamiento, como una persona (identificada por un rol), un sistema informatizado u organización, y que realiza algún tipo de interacción con el sistema.

Casos de Uso:

Un caso de uso es una descripción de la secuencia de interacciones que se producen entre un actor y el sistema, cuando el actor usa el sistema para llevar a cabo una tarea específica. Expresa una unidad coherente de funcionalidad, y se representa en el Diagrama de Casos de Uso mediante una elipse con el nombre del caso de uso en su interior. El nombre del caso de uso debe reflejar la tarea específica que el actor desea llevar a cabo usando el sistema. 

Relaciones entre Casos de Uso:

Haya relacion entre un caso de uso y el actor, y si el actor interactua con el sistema para realizar el caso de uso. 

Ahora si los siguientes son los casos de uso aplicados en Mi proyecto.

Nombre del Caso	Actor(es) Involucrados	Descripción	Casos de uso relacionados
Acceder	Cliente	El cliente puede acceder directamente	ninguna
Salir	Cliente	El cliente puede salir directamente	ninguna
Registrar	Cliente	El cliente puede registarse	ninguna
Ver	Proveedor/Usuario	El cliente y el Proveedor pueden ver la Factura
Ingresar	Proveedor	El proveedor llenara la factura	ninguna
Modificar	Proveedor	El proveedor modificara la factura	ninguna
Eliminar	Proveedor	El proveedor eliminara la factura.	ninguna
Verificar	Proveedor	El proveedor puede verificar si hay existencia de la factura	ninguna

El diagrama de Casos de Uso en mi proyecto seria el siguiente:

Referencias: 

Diagramas de Casos de Uso