Emmanueru

Emmanueru

martes, 17 de mayo de 2011

Video de Demostración del Proyecto de TPOO

Video:

Los querys para preparar bases de datos para el funcionamiento de este proyecto son los siguientes:

CREATE DATABASE DB

CREATE TABLE Guests (
GuestID varchar(30) NOT NULL,
LastName varchar(30),
FirstName varchar(30),
RoomNumber int,
TimeLeft int,
GuestType varchar(30),
CreditCard varchar(30),
Date varchar(30),
Account float,
PRIMARY KEY(GuestID)
)

CREATE TABLE Admins(
AdminID varchar(30) NOT NULL,
AdminPassword varchar(30),
FirstName varchar(30),
LastName varchar(30),
Occupation varchar(30),
Age int,
Country varchar(30),
PRIMARY KEY(AdminID)
)

CREATE TABLE Rooms(
RoomNumber int NOT NULL,
Occupied varchar(30),
Price float,
PRIMARY KEY(RoomNumber)
)

CREATE TABLE Services(
Service varchar(30) NOT NULL,
Comment varchar(30),
RoomNumber int,
PRIMARY KEY(Service)
)

USE DB

INSERT INTO Rooms VALUES(1, 'NO', 150.0)
INSERT INTO Rooms VALUES(2, 'NO', 150.0)
INSERT INTO Rooms VALUES(3, 'NO', 150.0)
INSERT INTO Rooms VALUES(4, 'NO', 200.0)
INSERT INTO Rooms VALUES(5, 'NO', 200.0)
INSERT INTO Rooms VALUES(6, 'NO', 200.0)
INSERT INTO Rooms VALUES(7, 'NO', 300.0)
INSERT INTO Rooms VALUES(8, 'NO', 300.0)
INSERT INTO Rooms VALUES(9, 'NO', 300.0)
INSERT INTO Rooms VALUES(10, 'NO', 300.0)

INSERT INTO Admins VALUES( 'GLOBAL-777', 'password','John','Doe','GM',777,'USA')

Ya con esto es posible iniciar el sistema, ejecutando la clase main. Esto abrirá un Login, en el cual se puede ingresar los datos del último query:
AdminID: GLOBAL-777
Password: password

Con esto debería abrirse la ventana del administrador, y desde ahi podemos agregar algún cliente, para luego poder probar con este cliente la interfaz del mismo, y además las otras funciones del administrador.

Saludos.

viernes, 13 de mayo de 2011

POO - Clase 11: Sistemas Distribuidos


Un sistema distribuido se define como una colección de computadores autónomos conectados por una red, y con el software distribuido adecuado para que el sistema sea visto por los usuarios como una única entidad capaz de proporcionar facilidades de computación. 

Explicación:

Lo veo como varias computadoras que trabajan en conjunto para realzar alguna función de un sistema, y como dice, sin que nosotros los usuarios notemos que existe tal cosa, ya que para nosotros debe verse como un sistema único.


En mi proyecto:

Tenía pensado implementar algunas funcionalidades de sistemas distribuidos. En particular cliente-servidor, para poder realizar las funciones a base de datos de manera remota, y así tener un servidor donde esta alojado la base de datos, y que el sistema se encuentre en diferentes lugares para acceder a el por medio de una red. 

Este concepto era lo que parece ser: base de datos distribuida. 

Por motivos de tiempo no me parece que pueda lograr aplicarlo ya que es algo un tanto complicado como para poder añadirlo en una semana, pero me gustaría aprender a aplicarlo después.

Referencias:

martes, 10 de mayo de 2011

Extra: Tipos de Sistemas Distribuidos

SSH


"SSH™ (o Secure SHell) es un protocolo que facilita las comunicaciones seguras entre dos sistemas usando una arquitectura cliente/servidor y que permite a los usuarios conectarse a un host remotamente. A diferencia de otros protocolos de comunicación remota tales como FTP o Telnet, SSH encripta la sesión de conexión, haciendo imposible que alguien pueda obtener contraseñas no encriptadas."

Explicación:


Basicamente se refiere a conectarse a otra computadora (servidor la mayoría de veces) remotamente para poder realizar ciertas tareas, desde modificar remotamente archivos, a eliminar o mover archivos entre la misma computadora.

Un uso interesante que vi, es el que hizo la Dra. Schaeffer, me parece que uso ssh para entrar al servidor donde esta hosteada su página web, y la modifico durante la clase para actualizar las calificaciones en Programación Web.

Este se accede mediante el comando:

ssh user@ip-address
...
password: ****

Sockets


Los sockets no son más que puntos o mecanismos de comunicación entre procesos que permiten que un proceso hable ( emita o reciba información ) con otro proceso incluso estando estos procesos en distintas máquinas.



Explicación:

Los sockets van fuertemente ligado a los puertos, ya que son conexiones que se abren para poder recibir o enviar información.

Los sockets son un concepto que había manejado previamente en la materia de Programación Web, en el tema de Cliente-Servidor. Aquí vimos un ejemplo de un chat básico tcp, con 3 clases: Cliente, Servidor, y si no me equivoco, Interfaz.
En su momento no entendí bien como funcionaba, debido a que el programa era en Java, y yo estaba trabajando en Python, pero actualmente entiendo bastante bien como funciona, más por tiempo no creo poder agregar tal funcionamiento a mi proyecto.

jueves, 5 de mayo de 2011

POO - Clase 10: Interfaces Gráficas De Usuario


La interfaz gráfica de usuario, conocida también como GUI (del inglés graphical user interface) es un programa informático que actúa deinterfaz de usuario, utilizando un conjunto de imágenes y objetos gráficos para representar la información y acciones disponibles en la interfaz. Su principal uso, consiste en proporcionar un entorno visual sencillo para permitir la comunicación con el sistema operativo de una máquina o computador.

Explicación:

Actualmente se utilizan computadoras en las que para ejecutar tareas solo es necesario hacer cosas como: mover el mouse, dar clicks, o presionar combinacones de teclas. Anteriormente esto no era asi, las computadoras funcionaban sin una interfaz en la que fueran posibles estas funciones, ya que todo se hacia con comandos en una terminal.

Una interfaz gráfica de usuario sirve principalmente para realizar de una manera visual y mas sencilla diversas funciones en un sistema. Puede ir de algo tan simple como una ventana con un par de botones, hasta la interfaz de un sistema operativo como Windows o Mac.


Diseño de la Interfaz Gráfica de mi proyecto:

Mi interfaz será en si una ventana, pienso que de 600 x 450 la del administrador, y de 600, 400 la del cliente. Contará con diversos componentes para el ingreso de datos como:
  • Botones
  • Labels
  • TextFields
  • RadioButtons
  • Lists
  • Tabs
  • etc.


Para el acomodo de componentes planeo utilizar null layout, para acomodar componentes usando coordenadas.
Un ejemplo de hacer esto sería con el siguiente código:

JPanel p = new JPanel();
JLabel label = new JLabel("Hey you!");
p.setLayout(null);
label.setBounds(new Rectangle( 300, 100, 100, 100);  // X, ,Y, WIDTH, HEIGHT
p.add(label);

El diseño previo de la interfaz gráfica es el siguiente para el Admin:


Y el siguiente para el Guest:
Referencias:




martes, 3 de mayo de 2011

TPOO 11: Interfaz Gráfica

Hola que tal, ,en este post explicaré en que consiste la interfaz gráfica de mi proyecto.

Primero que nada en mi proyecto habrá 3 clases diferentes que involucran aspectos gráficos. La primera es Login la cual en un post anterior había explicado como funciona así que esa la omitiré en este post. Las dos restantes son las GUI principales, que se desplegarán al usuario dependiendo de si es un administrador o un cliente o huésped.

GUI del Administrador:

Como he mencionado antes en las descripciones del proyecto, el administrador debe ser capaz de borrar, agregar, y buscar información sobre clientes a una base de datos, y esto obviamente sería mejor hacerlo por una interfaz gráfica para facilitarle el trabajo.
Por lo tanto el objetivo de ésta interfaz es permitir al administrador realizar esas tareas. La ventana se ve así:


Como se puede apreciar tiene 3 etiquetas en la parte de arriba, Add Client, Delete Client, Search Client, y con imágenes para identificar cada actividad.

Add Client es la pestaña que se muestra en la imagen, y contiene diversos elementos de interfaces gráficas como: botones, labels, radio buttons, text fields.

Para el acomodo de los componentes, no uso ningun layout especial, uso null para poder acomodarlos con coordenadas, a mi parecer la manera más cómoda para acomodarlos, después de intentar con BorderLayout, GridBagLayout, y demás.

En cada pestaña al presionar el botón de Submit, se procesa toda la información que piden los componentes y se ejecutan instrucciones en su mayoría de bases de datos para procesarla.

El código se puede descargar de aquí:   Descargar

Saludos.

martes, 12 de abril de 2011

TPOO 10 : Pruebas Unitarias con Junit

Hola que tal, en este post colocaré y explicaré como se realizan las pruebas unitarias, de una clase creada por mi, usando el framework de JUnit.

Para comenzar, se debe descargar el .jar que contiene las librerías de junit del siguiente link:

(Nota: Descargar el que dice junit-4.9b2.jar - Basic jar )

Ahora se pueden hacer dos cosas, una colocar el classpath de donde lo coloquemos, o moverlo a la carpeta de /usr/lib/jvm/java-6-openjdk/jre/lib/ext.Yo hice la segunda, ya que me parecia mas sencillo.

Al hacer cualquiera de estas dos ya podemos simplemente importar librerías como las siguientes:

import junit.framework.Test;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import junit.textui.TestRunner;

Pruebas Unitarias de mi proyecto:

Las pruebas que haré en mi proyecto, serán principalmente a la base de datos, para comprobar que se agreguen correctamente los datos de un cliente a la misma, y para comprobar que se eliminan correctamente los mismos.

El código de la prueba es el siguiente:

import junit.framework.*;
import junit.textui.TestRunner;
import java.sql.*;

public class Prueba extends TestCase{

 private DataBase db = new DataBase();

  public static Test suite() {

   return new TestSuite(Prueba.class);
  }
 
  public void testAddGuest(){
  System.out.println("Comprobando el agregado de informacion a la BD...");
  //Definimos el Nombre y el Numero de habitacion del cliente que agregaremos
  String firstName = "Emmanuel";
  String lastName = "Garcia";
  int roomNumber = 10; 
  try{
   //usamos el metodo para agregar un cliente a la base de datos
   db.addGuest(firstName,lastName, roomNumber, 2, "normal","123456789"); 
   //comprobamos que el primer nombre y el apellido de la base de datos coincida con el que recien agregamos
   super.assertTrue(firstName.equals(db.getFirstName(roomNumber)) && lastName.equals(db.getLastName(roomNumber)));
  }catch(Exception e){
   e.printStackTrace();
  }
 }

 public void testDeleteGuest(){
  System.out.println("Comprobado el borrado de información de la BD...");
  try{
   //borramos el cliente agregado anteriormente
   db.deleteGuest("EMGA10-02");
   //comprobamos que no existe con assertFalse
   super.assertFalse(db.searchGuest("EMGA10-02"));
  }catch(Exception e){
   e.printStackTrace();
  }
 }
 
  public static void main(String[]args){
   TestRunner.run(Prueba.suite());
  }
} 


Este código funciona usando la clase DataBase, que se puede descargar de aquí.

Esto es todo de pruebas unitarias, cualquier duda porfavor comentar. Saludos.

Referencias:

lunes, 11 de abril de 2011

POO - Clase 9: Diseño de Pruebas Unitarias


En programación, una prueba unitaria es una forma de probar el correcto funcionamiento de un módulo de código. Esto sirve para asegurar que cada uno de los módulos funcione correctamente por separado.

Explicación:


Pruebas unitarias son las que se hacen a un sstema, pero separado en partes. Es decir hacer pruebas a cada sección de un programa que realiza una tarea diferente y única. Por ejemplo: Realizar una prueba para verificar el funcionamiento de una sola clase, o de un solo método, etc.

Las veo muy útiles para detectar errores en métodos, comprobando su funcionamiento con una prueba. Para el diseño de pruebas utilizare lo que es Junit, una librería que se puede descargar de aquí. Es totalmente gratuita y proporciona clases y métodos para facilitar la comparación de valores y otras cosas para realizar tus pruebas.

Ejemplo de Pruebas Unitarias:


Para el ejemplo creé mi clase Automovil, que hace las cosas básicas de un automóvil, acelerar, frenar, etc.
El código es el siguiente:

public class Automovil{
 private int velocidad = 0;
 private String modelo;
 private float gasolina = 100;

 public Automovil(String modelo){
  this.modelo = modelo;
 }

 public void aumentarVelocidad(int aumento){
  if(velocidad < 100){
  velocidad = velocidad + aumento;
  gasolina = gasolina - (aumento/2);
  }
 }
 public void disminuirVelocidad(int disminucion){
  if(velocidad > 10){
  velocidad = velocidad - disminucion;
  }
  else{
  velocidad = 0;
  }
 }

 public void frenadoTotal(){
  velocidad = 0;
 }

 public String getModelo(){
  return modelo;
 }
 public int getVelocidad(){
  return velocidad;
 }
 public float getGasolina(){
  return gasolina;
 }

}

Usando los métodos aumentarVelocidad(), disminuirVelocidad(), y frenadoTotal(), haremos pruebas de como cambian ciertos atributos del automóvil.
Por ejemplo;

  • Al aumentar la velocidad, la variable aumentar debe incrementarse una cierta cantidad, se hará una prueba para comprobarlo.
  • Al crear un objeto del tipo automóvil, se debe comprobar que usando el método devuelva el modelo del automóvil correcto.
  • Al aumentar la velocidad, se debe comprobar(solo para ejemplificar) que la "gasolina" disminuye una cierta cantidad.
  • Al "frenar" se debe comprobar que la velocidad se vuelve 0.
La clase de prueba es la siguiente:

import junit.framework.Test;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import junit.textui.TestRunner;
public class Prueba extends TestCase{

 public static Test suite() {
  return new TestSuite(Prueba.class);
     }
 
 public void testVelocidad(){
  System.out.println("Comprobando la velocidad del auto...");
  Automovil bmw = new Automovil("BMW");
  bmw.aumentarVelocidad(10);
  super.assertEquals( 10, bmw.getVelocidad());
     }
 
     public void testModelo(){
  System.out.println("Comprobando el modelo del auto...");
  String cheyenne = "Cheyenne";
  Automovil chevrolet = new Automovil(cheyenne);
  super.assertTrue(cheyenne.equals(chevrolet.getModelo()));
 }
 
     public void testGasolina(){
  System.out.println("Comprobando la gasolina del auto...");
  Automovil nissan = new Automovil("Tsuru");
  nissan.aumentarVelocidad(15);
  super.assertTrue(nissan.getGasolina() < 100);
     }
 
 public static void main(String[]args){
  TestRunner.run(Prueba.suite());
 }
}
Ya con estos códigos, compile ambos, y corrí Prueba.java, y los resultados fueron los siguientes:


Fueron los resultados esperados ya que como se observa en los tests, las condiciones son las correctas.

Referencias: