diff --git a/.classpath b/.classpath index 2d74975..ea2a815 100644 --- a/.classpath +++ b/.classpath @@ -1,7 +1,8 @@ - + + diff --git a/.gitignore b/.gitignore index a031ac2..2dde1e7 100644 --- a/.gitignore +++ b/.gitignore @@ -4,9 +4,9 @@ .mtj.tmp/ # Package Files # -*.jar *.war *.ear +*.dat # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml hs_err_pid* diff --git a/.settings/org.eclipse.jdt.core.prefs b/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 0000000..295926d --- /dev/null +++ b/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,7 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8 +org.eclipse.jdt.core.compiler.compliance=1.8 +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.source=1.8 diff --git a/README.md b/README.md index 44ff3bd..90c7b98 100644 --- a/README.md +++ b/README.md @@ -4,3 +4,5 @@ dms1415 Aplicación que gestiona los datos de una agenda: Contactos, Tipo de contactos, Llamadas. Aplicando patrones de diseño + +===== \ No newline at end of file diff --git a/lib/hsqldb.jar b/lib/hsqldb.jar new file mode 100644 index 0000000..3b1e6bd Binary files /dev/null and b/lib/hsqldb.jar differ diff --git a/res/ScriptCargaDatos b/rsc/ScriptCargaDatos similarity index 100% rename from res/ScriptCargaDatos rename to rsc/ScriptCargaDatos diff --git a/res/ScriptCreacionAgenda b/rsc/ScriptCreacionAgenda similarity index 100% rename from res/ScriptCreacionAgenda rename to rsc/ScriptCreacionAgenda diff --git a/src/ubu/lsi/dms/agenda/modelo/Call.java b/src/ubu/lsi/dms/agenda/modelo/Call.java new file mode 100644 index 0000000..260a418 --- /dev/null +++ b/src/ubu/lsi/dms/agenda/modelo/Call.java @@ -0,0 +1,137 @@ +package ubu.lsi.dms.agenda.modelo; + +import java.io.Serializable; + +/** + * Clase de entidad con la información de Llamada + * + * @author Carlos López + * + */ +@SuppressWarnings("serial") +public class Call implements Serializable { + + private int idLlamada; + private Contact contacto; + private String fechaLlamada; + private String asunto, notas; + + public Call(int idLlamada, Contact contacto, String fechaLlamada, + String asunto, String notas) { + super(); + this.idLlamada = idLlamada; + this.contacto = contacto; + this.fechaLlamada = fechaLlamada; + this.asunto = asunto; + this.notas = notas; + } + + /** + * @return the contacto + */ + public Contact getContacto() { + return contacto; + } + + /** + * @param contacto + * the contacto to set + */ + public void setContacto(Contact contacto) { + this.contacto = contacto; + } + + /** + * @return the fechaLlamada + */ + public String getFechaLlamada() { + return fechaLlamada; + } + + /** + * @param fechaLlamada + * the fechaLlamada to set + */ + public void setFechaLlamada(String fechaLlamada) { + this.fechaLlamada = fechaLlamada; + } + + /** + * @return the asunto + */ + public String getAsunto() { + return asunto; + } + + /** + * @param asunto + * the asunto to set + */ + public void setAsunto(String asunto) { + this.asunto = asunto; + } + + /** + * @return the notas + */ + public String getNotas() { + return notas; + } + + /** + * @param notas + * the notas to set + */ + public void setNotas(String notas) { + this.notas = notas; + } + + /** + * @return the idLlamada + */ + public int getIdLlamada() { + return idLlamada; + } + + @Override + public String toString() { + return "Llamada [idLlamada=" + idLlamada + ", contacto=" + contacto + + ", fechaLlamada=" + fechaLlamada + ", asunto=" + asunto + + ", notas=" + notas + "]"; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + Call other = (Call) obj; + if (asunto == null) { + if (other.asunto != null) + return false; + } else if (!asunto.equals(other.asunto)) + return false; + if (contacto == null) { + if (other.contacto != null) + return false; + } else if (!contacto.equals(other.contacto)) + return false; + if (fechaLlamada == null) { + if (other.fechaLlamada != null) + return false; + } else if (!fechaLlamada.equals(other.fechaLlamada)) + return false; + if (idLlamada != other.idLlamada) + return false; + if (notas == null) { + if (other.notas != null) + return false; + } else if (!notas.equals(other.notas)) + return false; + return true; + } + +} diff --git a/src/ubu/lsi/dms/agenda/modelo/Contact.java b/src/ubu/lsi/dms/agenda/modelo/Contact.java new file mode 100644 index 0000000..4913ff0 --- /dev/null +++ b/src/ubu/lsi/dms/agenda/modelo/Contact.java @@ -0,0 +1,443 @@ +package ubu.lsi.dms.agenda.modelo; + +import java.io.Serializable; + +/** + * Clase de entidad con la información de Contactos + * + * @author Carlos López + * + */ +@SuppressWarnings("serial") +public class Contact implements Serializable { + private int idContacto; + private String nombre, apellidos, estimado, direccion, ciudad, prov, + codPostal, region, pais, nombreCompania, cargo, telefonoTrabajo, + extensionTrabajo, telefonoMovil, numFax, nomCorreoElectronico, + notas; + + private ContactType tipoContacto; + + public Contact(int idContacto, String nombre, String apellidos, + String estimado, String direccion, String ciudad, String prov, + String codPostal, String region, String pais, + String nombreCompania, String cargo, String telefonoTrabajo, + String extensionTrabajo, String telefonoMovil, String numFax, + String nomCorreoElectronico, String notas, ContactType tipoContacto) { + super(); + this.idContacto = idContacto; + this.nombre = nombre; + this.apellidos = apellidos; + this.estimado = estimado; + this.direccion = direccion; + this.ciudad = ciudad; + this.prov = prov; + this.codPostal = codPostal; + this.region = region; + this.pais = pais; + this.nombreCompania = nombreCompania; + this.cargo = cargo; + this.telefonoTrabajo = telefonoTrabajo; + this.extensionTrabajo = extensionTrabajo; + this.telefonoMovil = telefonoMovil; + this.numFax = numFax; + this.nomCorreoElectronico = nomCorreoElectronico; + this.notas = notas; + this.tipoContacto = tipoContacto; + } + + /** + * @return the nombre + */ + public String getNombre() { + return nombre; + } + + /** + * @param nombre + * the nombre to set + */ + public void setNombre(String nombre) { + this.nombre = nombre; + } + + /** + * @return the apellidos + */ + public String getApellidos() { + return apellidos; + } + + /** + * @param apellidos + * the apellidos to set + */ + public void setApellidos(String apellidos) { + this.apellidos = apellidos; + } + + /** + * @return the estimado + */ + public String getEstimado() { + return estimado; + } + + /** + * @param estimado + * the estimado to set + */ + public void setEstimado(String estimado) { + this.estimado = estimado; + } + + /** + * @return the direccion + */ + public String getDireccion() { + return direccion; + } + + /** + * @param direccion + * the direccion to set + */ + public void setDireccion(String direccion) { + this.direccion = direccion; + } + + /** + * @return the ciudad + */ + public String getCiudad() { + return ciudad; + } + + /** + * @param ciudad + * the ciudad to set + */ + public void setCiudad(String ciudad) { + this.ciudad = ciudad; + } + + /** + * @return the prov + */ + public String getProv() { + return prov; + } + + /** + * @param prov + * the prov to set + */ + public void setProv(String prov) { + this.prov = prov; + } + + /** + * @return the codPostal + */ + public String getCodPostal() { + return codPostal; + } + + /** + * @param codPostal + * the codPostal to set + */ + public void setCodPostal(String codPostal) { + this.codPostal = codPostal; + } + + /** + * @return the region + */ + public String getRegion() { + return region; + } + + /** + * @param region + * the region to set + */ + public void setRegion(String region) { + this.region = region; + } + + /** + * @return the pais + */ + public String getPais() { + return pais; + } + + /** + * @param pais + * the pais to set + */ + public void setPais(String pais) { + this.pais = pais; + } + + /** + * @return the nombreCompania + */ + public String getNombreCompania() { + return nombreCompania; + } + + /** + * @param nombreCompania + * the nombreCompania to set + */ + public void setNombreCompania(String nombreCompania) { + this.nombreCompania = nombreCompania; + } + + /** + * @return the cargo + */ + public String getCargo() { + return cargo; + } + + /** + * @param cargo + * the cargo to set + */ + public void setCargo(String cargo) { + this.cargo = cargo; + } + + /** + * @return the telefonoTrabajo + */ + public String getTelefonoTrabajo() { + return telefonoTrabajo; + } + + /** + * @param telefonoTrabajo + * the telefonoTrabajo to set + */ + public void setTelefonoTrabajo(String telefonoTrabajo) { + this.telefonoTrabajo = telefonoTrabajo; + } + + /** + * @return the extensionTrabajo + */ + public String getExtensionTrabajo() { + return extensionTrabajo; + } + + /** + * @param extensionTrabajo + * the extensionTrabajo to set + */ + public void setExtensionTrabajo(String extensionTrabajo) { + this.extensionTrabajo = extensionTrabajo; + } + + /** + * @return the telefonoMovil + */ + public String getTelefonoMovil() { + return telefonoMovil; + } + + /** + * @param telefonoMovil + * the telefonoMovil to set + */ + public void setTelefonoMovil(String telefonoMovil) { + this.telefonoMovil = telefonoMovil; + } + + /** + * @return the numFax + */ + public String getNumFax() { + return numFax; + } + + /** + * @param numFax + * the numFax to set + */ + public void setNumFax(String numFax) { + this.numFax = numFax; + } + + /** + * @return the nomCorreoElectronico + */ + public String getNomCorreoElectronico() { + return nomCorreoElectronico; + } + + /** + * @param nomCorreoElectronico + * the nomCorreoElectronico to set + */ + public void setNomCorreoElectronico(String nomCorreoElectronico) { + this.nomCorreoElectronico = nomCorreoElectronico; + } + + /** + * @return the notas + */ + public String getNotas() { + return notas; + } + + /** + * @param notas + * the notas to set + */ + public void setNotas(String notas) { + this.notas = notas; + } + + /** + * @return the tipoContacto + */ + public ContactType getTipoContacto() { + return tipoContacto; + } + + /** + * @param tipoContacto + * the tipoContacto to set + */ + public void setTipoContacto(ContactType tipoContacto) { + this.tipoContacto = tipoContacto; + } + + /** + * @return the idContacto + */ + public int getIdContacto() { + return idContacto; + } + + @Override + public String toString() { + return "Contacto [idContacto=" + idContacto + ", nombre=" + nombre + + ", apellidos=" + apellidos + ", estimado=" + estimado + + ", direccion=" + direccion + ", ciudad=" + ciudad + ", prov=" + + prov + ", codPostal=" + codPostal + ", region=" + region + + ", pais=" + pais + ", nombreCompania=" + nombreCompania + + ", cargo=" + cargo + ", telefonoTrabajo=" + telefonoTrabajo + + ", extensionTrabajo=" + extensionTrabajo + ", telefonoMovil=" + + telefonoMovil + ", numFax=" + numFax + + ", nomCorreoElectronico=" + nomCorreoElectronico + ", notas=" + + notas + ", tipoContacto=" + tipoContacto + "]"; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + Contact other = (Contact) obj; + if (apellidos == null) { + if (other.apellidos != null) + return false; + } else if (!apellidos.equals(other.apellidos)) + return false; + if (cargo == null) { + if (other.cargo != null) + return false; + } else if (!cargo.equals(other.cargo)) + return false; + if (ciudad == null) { + if (other.ciudad != null) + return false; + } else if (!ciudad.equals(other.ciudad)) + return false; + if (codPostal == null) { + if (other.codPostal != null) + return false; + } else if (!codPostal.equals(other.codPostal)) + return false; + if (direccion == null) { + if (other.direccion != null) + return false; + } else if (!direccion.equals(other.direccion)) + return false; + if (estimado == null) { + if (other.estimado != null) + return false; + } else if (!estimado.equals(other.estimado)) + return false; + if (extensionTrabajo == null) { + if (other.extensionTrabajo != null) + return false; + } else if (!extensionTrabajo.equals(other.extensionTrabajo)) + return false; + if (idContacto != other.idContacto) + return false; + if (nomCorreoElectronico == null) { + if (other.nomCorreoElectronico != null) + return false; + } else if (!nomCorreoElectronico.equals(other.nomCorreoElectronico)) + return false; + if (nombre == null) { + if (other.nombre != null) + return false; + } else if (!nombre.equals(other.nombre)) + return false; + if (nombreCompania == null) { + if (other.nombreCompania != null) + return false; + } else if (!nombreCompania.equals(other.nombreCompania)) + return false; + if (notas == null) { + if (other.notas != null) + return false; + } else if (!notas.equals(other.notas)) + return false; + if (numFax == null) { + if (other.numFax != null) + return false; + } else if (!numFax.equals(other.numFax)) + return false; + if (pais == null) { + if (other.pais != null) + return false; + } else if (!pais.equals(other.pais)) + return false; + if (prov == null) { + if (other.prov != null) + return false; + } else if (!prov.equals(other.prov)) + return false; + if (region == null) { + if (other.region != null) + return false; + } else if (!region.equals(other.region)) + return false; + if (telefonoMovil == null) { + if (other.telefonoMovil != null) + return false; + } else if (!telefonoMovil.equals(other.telefonoMovil)) + return false; + if (telefonoTrabajo == null) { + if (other.telefonoTrabajo != null) + return false; + } else if (!telefonoTrabajo.equals(other.telefonoTrabajo)) + return false; + if (tipoContacto == null) { + if (other.tipoContacto != null) + return false; + } else if (!tipoContacto.equals(other.tipoContacto)) + return false; + return true; + } +} diff --git a/src/ubu/lsi/dms/agenda/modelo/ContactType.java b/src/ubu/lsi/dms/agenda/modelo/ContactType.java new file mode 100644 index 0000000..84bb1c0 --- /dev/null +++ b/src/ubu/lsi/dms/agenda/modelo/ContactType.java @@ -0,0 +1,69 @@ +package ubu.lsi.dms.agenda.modelo; + +import java.io.Serializable; + +/** + * Clase de entidad con la información de TipodeContacto + * + * @author Carlos López + * + */ +@SuppressWarnings("serial") +public class ContactType implements Serializable { + private int idTipoContacto; + private String TipoContacto; + + public ContactType(int idTipoContacto, String tipoContacto) { + super(); + this.idTipoContacto = idTipoContacto; + TipoContacto = tipoContacto; + } + + /** + * @return the tipoContacto + */ + public String getTipoContacto() { + return TipoContacto; + } + + /** + * @param tipoContacto + * the tipoContacto to set + */ + public void setTipoContacto(String tipoContacto) { + TipoContacto = tipoContacto; + } + + /** + * @return the idTipoContacto + */ + public int getIdTipoContacto() { + return idTipoContacto; + } + + @Override + public String toString() { + return "TipoContacto [idTipoContacto=" + idTipoContacto + + ", TipoContacto=" + TipoContacto + "]"; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + ContactType other = (ContactType) obj; + if (TipoContacto == null) { + if (other.TipoContacto != null) + return false; + } else if (!TipoContacto.equals(other.TipoContacto)) + return false; + if (idTipoContacto != other.idTipoContacto) + return false; + return true; + } + +} diff --git a/src/ubu/lsi/dms/agenda/modelo/Contacto.java b/src/ubu/lsi/dms/agenda/modelo/Contacto.java deleted file mode 100644 index 7a591ce..0000000 --- a/src/ubu/lsi/dms/agenda/modelo/Contacto.java +++ /dev/null @@ -1,64 +0,0 @@ -package ubu.lsi.dms.agenda.modelo; - -import java.io.Serializable; - -/** - * Clase de entidad con la información de Contactos - * @author Carlos López - * - */ -@SuppressWarnings("serial") -public class Contacto implements Serializable{ - private int idContacto; - private String nombre , apellidos , estimado , direccion , ciudad , prov , codPostal , region , - pais , nombreCompania , cargo , telefonoTrabajo , extensionTrabajo , telefonoMovil , numFax , - nomCorreoElectronico, notas; - - private TipoContacto tipoContacto; - - public Contacto(int idContacto, String nombre, String apellidos, - String estimado, String direccion, String ciudad, String prov, - String codPostal, String region, String pais, - String nombreCompania, String cargo, String telefonoTrabajo, - String extensionTrabajo, String telefonoMovil, String numFax, - String nomCorreoElectronico, String notas, TipoContacto tipoContacto) { - super(); - this.idContacto = idContacto; - this.nombre = nombre; - this.apellidos = apellidos; - this.estimado = estimado; - this.direccion = direccion; - this.ciudad = ciudad; - this.prov = prov; - this.codPostal = codPostal; - this.region = region; - this.pais = pais; - this.nombreCompania = nombreCompania; - this.cargo = cargo; - this.telefonoTrabajo = telefonoTrabajo; - this.extensionTrabajo = extensionTrabajo; - this.telefonoMovil = telefonoMovil; - this.numFax = numFax; - this.nomCorreoElectronico = nomCorreoElectronico; - this.notas = notas; - this.tipoContacto = tipoContacto; - } - - @Override - public String toString() { - return "Contacto [idContacto=" + idContacto + ", nombre=" + nombre - + ", apellidos=" + apellidos + ", estimado=" + estimado - + ", direccion=" + direccion + ", ciudad=" + ciudad + ", prov=" - + prov + ", codPostal=" + codPostal + ", region=" + region - + ", pais=" + pais + ", nombreCompania=" + nombreCompania - + ", cargo=" + cargo + ", telefonoTrabajo=" + telefonoTrabajo - + ", extensionTrabajo=" + extensionTrabajo + ", telefonoMovil=" - + telefonoMovil + ", numFax=" + numFax - + ", nomCorreoElectronico=" + nomCorreoElectronico + ", notas=" - + notas + ", tipoContacto=" + tipoContacto + "]"; - } - - - - -} diff --git a/src/ubu/lsi/dms/agenda/modelo/Llamada.java b/src/ubu/lsi/dms/agenda/modelo/Llamada.java deleted file mode 100644 index 4f121b5..0000000 --- a/src/ubu/lsi/dms/agenda/modelo/Llamada.java +++ /dev/null @@ -1,41 +0,0 @@ -package ubu.lsi.dms.agenda.modelo; - -import java.io.Serializable; -/** - * Clase de entidad con la información de Llamada - * @author Carlos López - * - */ -@SuppressWarnings("serial") -public class Llamada implements Serializable{ - - private int idLlamada; - private Contacto contacto; - private String fechaLlamada ; - private String asunto,notas; - - - - public Llamada(int idLlamada, Contacto contacto, String fechaLlamada, - String asunto, String notas) { - super(); - this.idLlamada = idLlamada; - this.contacto = contacto; - this.fechaLlamada = fechaLlamada; - this.asunto = asunto; - this.notas = notas; - } - - @Override - public String toString() { - return "Llamada [idLlamada=" + idLlamada + ", contacto=" + contacto - + ", fechaLlamada=" + fechaLlamada + ", asunto=" + asunto - + ", notas=" + notas + "]"; - } - - - - - - -} diff --git a/src/ubu/lsi/dms/agenda/modelo/TipoContacto.java b/src/ubu/lsi/dms/agenda/modelo/TipoContacto.java deleted file mode 100644 index 332ba6f..0000000 --- a/src/ubu/lsi/dms/agenda/modelo/TipoContacto.java +++ /dev/null @@ -1,32 +0,0 @@ -package ubu.lsi.dms.agenda.modelo; - -import java.io.Serializable; - -/** - * Clase de entidad con la información de TipodeContacto - * @author Carlos López - * - */ -@SuppressWarnings("serial") -public class TipoContacto implements Serializable{ - private int idTipoContacto; - private String TipoContacto; - - - public TipoContacto(int idTipoContacto, String tipoContacto) { - super(); - this.idTipoContacto = idTipoContacto; - TipoContacto = tipoContacto; - } - - - @Override - public String toString() { - return "TipoContacto [idTipoContacto=" + idTipoContacto - + ", TipoContacto=" + TipoContacto + "]"; - } - - - - -} diff --git a/src/ubu/lsi/dms/agenda/persistence/BinaryFacade.java b/src/ubu/lsi/dms/agenda/persistence/BinaryFacade.java new file mode 100644 index 0000000..ea9304b --- /dev/null +++ b/src/ubu/lsi/dms/agenda/persistence/BinaryFacade.java @@ -0,0 +1,429 @@ +package ubu.lsi.dms.agenda.persistence; + +import java.io.File; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.util.ArrayList; +import java.util.List; +import java.util.logging.Logger; + +import ubu.lsi.dms.agenda.modelo.Call; +import ubu.lsi.dms.agenda.modelo.Contact; +import ubu.lsi.dms.agenda.modelo.ContactType; + +@SuppressWarnings("unchecked") +/** + * Class that creates a binary persistence facade. + * Facade pattern is applied to this class. + * Singleton pattern is applied to this class. + * @author Alejandro González Rogel + * @author Plamen Petyov Petkov + */ +public class BinaryFacade implements PersistenceFacade { + + /** + * Returns the reference to a BinaryFacade instance. + * + * @return BinaryFacade instance. + */ + public static BinaryFacade getInstance() { + if(instance == null) + instance = new BinaryFacade(); + return instance; + } // getInstance + + /** + * Self-instance. + */ + private static BinaryFacade instance = null; + // Persistence file paths + /** + * Calls persistence file path. + */ + private final File calls; + /** + * Contacts persistence file path. + */ + private final File contacts; + + /** + * ContactTypes persistence file path. + */ + private final File contactTypes; + + /** + * Log messages about the BinaryFacade insertions + */ + Logger logger = Logger.getLogger("ubu.lsi.dms.agenda.persistence"); + + /** + * Private constructor. Initialize our file paths. + */ + private BinaryFacade() { + calls = new File(".\\rsc\\calls.dat"); + contacts = new File(".\\rsc\\contacts.dat"); + contactTypes = new File(".\\rsc\\contactTypes.dat"); + } // BinaryFacade + + @Override + public List getCallsByContact(Contact contact) { + List listOfCalls = new ArrayList(); + ObjectInputStream in = null; + try { + in = new ObjectInputStream(new FileInputStream(calls)); + listOfCalls = loadFile(calls); + } catch (IOException e) { + e.printStackTrace(); + } finally { + try { + if (in != null) + in.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + + List callsByContact = new ArrayList(); + for (Call c : listOfCalls) + if (c.getContacto().equals(contact)) + callsByContact.add(c); + return callsByContact; + } // getCallsByContact + + @Override + public Contact getContact(String surname) { + List listOfContacts = new ArrayList(); + ObjectInputStream in = null; + try { + in = new ObjectInputStream(new FileInputStream(contacts)); + listOfContacts = (ArrayList) in.readObject(); + } catch (ClassNotFoundException e) { + e.printStackTrace(); + } catch (IOException e) { + e.printStackTrace(); + } finally { + try { + if (in != null) + in.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + + for (Contact c : listOfContacts) + if (c.getApellidos().equals(surname)) + return c; + return null; + } // getContact + + @Override + public List getContactsBySurname(String surname) { + List listOfContacts = new ArrayList(); + List contactsBySurname = new ArrayList(); + ObjectInputStream in = null; + + try { + in = new ObjectInputStream(new FileInputStream(contacts)); + listOfContacts = loadFile(contacts); + } catch (IOException e) { + e.printStackTrace(); + } finally { + try { + if (in != null) + in.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + + for (Contact c : listOfContacts) + if (c.getApellidos().equals(surname)) + contactsBySurname.add(c); + + return contactsBySurname; + } // getContactsBySurname + + @Override + public List getContactTypes() { + List listOfCTs = new ArrayList(); + ObjectInputStream in = null; + try { + in = new ObjectInputStream(new FileInputStream(contactTypes)); + listOfCTs = loadFile(contactTypes); + } catch (IOException e) { + e.printStackTrace(); + } finally { + try { + if (in != null) + in.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + return listOfCTs; + } // getContactTypes + + @Override + public void insertCall(Call call) { + ObjectOutputStream out = null; + ObjectInputStream in = null; + List listOfCalls = new ArrayList(); + List listOfContacts = new ArrayList(); + boolean contactFound = false; + + try { + if (calls.exists()) + // Take everything from the files + listOfCalls = loadFile(calls); + out = new ObjectOutputStream(new FileOutputStream(calls)); + listOfCalls.add(call); + out.writeObject(listOfCalls); + // We look for if the contact who called us is already stored in our + // agenda. + if (contacts.exists()) { + listOfContacts = loadFile(contacts); + for (Contact c : listOfContacts) + if (c.getIdContacto() == call.getContacto().getIdContacto()) + contactFound = true; + } + // If the contact isn't there we add it + if (!contactFound) { + insertContact(call.getContacto()); + } + } catch (IOException e) { + e.printStackTrace(); + } finally { + try { + if (in != null) + in.close(); + + if (out != null) + out.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + } // insertCall + + @Override + public void insertContact(Contact contact) { + ObjectOutputStream out = null; + ObjectInputStream in = null; + List listOfContacts = new ArrayList(); + + try { + if (contacts.exists()) + // Take everything from the files + listOfContacts = loadFile(contacts); + out = new ObjectOutputStream(new FileOutputStream(contacts)); + listOfContacts.add(contact); + out.writeObject(listOfContacts); + } catch (IOException e) { + e.printStackTrace(); + } finally { + try { + if (in != null) + in.close(); + + if (out != null) + out.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + } // insertContact + + @Override + public void insertContactType(ContactType ct) { + ObjectOutputStream out = null; + ObjectInputStream in = null; + List listOfCTs = new ArrayList(); + + try { + if (contactTypes.exists()) + // Take everything from the files + listOfCTs = loadFile(contactTypes); + out = new ObjectOutputStream(new FileOutputStream(contactTypes)); + listOfCTs.add(ct); + out.writeObject(listOfCTs); + } catch (IOException e) { + e.printStackTrace(); + } finally { + try { + if (in != null) + in.close(); + + if (out != null) + out.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + } // insertContactType + + /** + * Loads all the objects the file has stored. + * + * @param file + * we want to load + * @return List of loaded objects + */ + private List loadFile(File file) { + List list = new ArrayList(); + ObjectInputStream in = null; + + try { + in = new ObjectInputStream(new FileInputStream(file)); + list = (ArrayList) in.readObject(); + + } catch (IOException | ClassNotFoundException e) { + e.printStackTrace(); + } finally { + try { + if (in != null) + in.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + return list; + } // loadFile + + @Override + public void updateCall(Call call) { + + ObjectInputStream in = null; + ObjectOutputStream out = null; + boolean callFound = false; + List listOfCalls = new ArrayList(); + + // Read all the contacts + try { + if (calls.exists()) { + in = new ObjectInputStream(new FileInputStream(calls)); + listOfCalls = loadFile(calls); + // Look for a call with similar ID and + // ,if we find it, replace the contact with new information + for (int i = 0; i < listOfCalls.size() && !callFound; i++) { + if (listOfCalls.get(i).getIdLlamada() == call + .getIdLlamada()) { + listOfCalls.remove(i); + listOfCalls.add(i, call); + callFound = true; + } + } + + if (callFound) { + // Store the new data again + out = new ObjectOutputStream(new FileOutputStream(calls)); + out.writeObject(listOfCalls); + } else { + logger.info("We couldn't update the given call. It doesn't exist."); + } + + } + } catch (IOException e) { + e.printStackTrace(); + } finally { + try { + if (in != null) + in.close(); + + if (out != null) + out.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + } // updateCall + + @Override + public void updateContact(Contact contact) { + ObjectInputStream in = null; + ObjectOutputStream out = null; + boolean contactFound = false; + List listOfContacts; + + // Read all the contacts + try { + in = new ObjectInputStream(new FileInputStream(contacts)); + listOfContacts = loadFile(contacts); + // Look for a contact with similar ID and + // ,if we find it, replace the contact with new information + for (int i = 0; i < listOfContacts.size() && !contactFound; i++) { + if (listOfContacts.get(i).getIdContacto() == contact + .getIdContacto()) { + listOfContacts.remove(i); + listOfContacts.add(i, contact); + contactFound = true; + } + } + if (contactFound) { + // Store the new data again + out = new ObjectOutputStream(new FileOutputStream(contacts)); + out.writeObject(listOfContacts); + } else { + logger.info("We couldn't update the given contact. It doesn't exist."); + } + } catch (IOException e) { + e.printStackTrace(); + } finally { + try { + if (in != null) + in.close(); + + if (out != null) + out.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + } // updateContact + + @Override + public void updateContactType(ContactType ct) { + ObjectInputStream in = null; + ObjectOutputStream out = null; + boolean contactFound = false; + List listOfCTs; + + // Read all the contacts + try { + in = new ObjectInputStream(new FileInputStream(contactTypes)); + listOfCTs = loadFile(contactTypes); + // Look for a contact with similar ID and + // ,if we find it, replace the contact with new information + for (int i = 0; i < listOfCTs.size() && !contactFound; i++) { + if (listOfCTs.get(i).getIdTipoContacto() == ct + .getIdTipoContacto()) { + listOfCTs.remove(i); + listOfCTs.add(i, ct); + contactFound = true; + } + } + + if (contactFound) { // Store the new data again + out = new ObjectOutputStream(new FileOutputStream(contactTypes)); + out.writeObject(listOfCTs); + } else { + logger.info("We couldn't update the given contact type. It doesn't exist."); + } + } catch (IOException e) { + e.printStackTrace(); + } finally { // We close all the Streams we may have opened. + try { + if (in != null) + in.close(); + + if (out != null) + out.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + } // updateContactType + +} // class BinaryFacade diff --git a/src/ubu/lsi/dms/agenda/persistence/BinaryFactory.java b/src/ubu/lsi/dms/agenda/persistence/BinaryFactory.java new file mode 100644 index 0000000..236c47b --- /dev/null +++ b/src/ubu/lsi/dms/agenda/persistence/BinaryFactory.java @@ -0,0 +1,48 @@ +package ubu.lsi.dms.agenda.persistence; + +/** + * Clase fábrica que crea una fábrica de persistencia binaria. Implementa la + * interfaz PersistenceFactory. Se aplica el patron de diseño Abstract Factory. + * Participante como fábrica concreta. Se aplica el patron de diseño Singleton + * para crear instancia única de la clase. + * + * @author Alejandro González Rogel + * @author Plamen Petyov Petkov + */ +public class BinaryFactory implements PersistenceFactory { + + /** + * Devuelve la referencia a una instancia de la clase BinaryFactory. Método + * necesario para el patron Singleton. + * + * @return instance la referencia a la instancia única. + */ + public static BinaryFactory getInstance() { + return instance; + } // getInstance + + /** + * Guarda una referencia a la instancia de la propia clase. Atributo + * necesario para el patron Singleton. + */ + private static BinaryFactory instance = new BinaryFactory(); + + /** + * Constructor privado para evitar instanciaciones externas. + */ + private BinaryFactory() { + } + + /* + * (non-Javadoc) + * + * @see + * ubu.lsi.dms.agenda.persistence.PersistenceFactory#createPersistenceFacade + * () + */ + @Override + public BinaryFacade createPersistenceFacade() { + return BinaryFacade.getInstance(); + } // createPersistenceFacade + +} // class BinaryFactory diff --git a/src/ubu/lsi/dms/agenda/persistence/DBFacade.java b/src/ubu/lsi/dms/agenda/persistence/DBFacade.java new file mode 100644 index 0000000..9a51bde --- /dev/null +++ b/src/ubu/lsi/dms/agenda/persistence/DBFacade.java @@ -0,0 +1,436 @@ +package ubu.lsi.dms.agenda.persistence; + +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.List; + +import ubu.lsi.dms.agenda.modelo.Call; +import ubu.lsi.dms.agenda.modelo.Contact; +import ubu.lsi.dms.agenda.modelo.ContactType; + +/** + * Clase fachada que realiza la función de fachada para las operaciones de + * persistencia sobre una base de datos. Además cumple el patrón singleton. + * + * @author Alberto Vivar Arribas + * @author Mario López Jiménez + */ +public class DBFacade implements PersistenceFacade { + + /** + * Devuelve la referencia a la única instancia que debería existir de la + * DBFacade. + * + * @return instancia de DBFacade. + */ + public static DBFacade getInstance() { + return instance; + } + + private static final DBFacade instance = new DBFacade(); + + /* + * Datos importantes de la base de datos. + * + * Primero, la url para la conexión a la base de datos. Usuario en dicha + * BBDD. Contraseña para el usuario. + * + * Nombres descriptivos que almacenan la sentencia correspondiente a las + * diferentes operaciones. + */ + private final String urlDB, usuario, contrasena, getContactSentence, + getContactsBySurnameSentence, getContactTypesSentence, + getCallsByContactSentence, insertContactSentence, + insertContactTypeSentence, insertCallSentence, + updateContactSentence, updateContactTypeSentence, + updateCallSentence; + + /** + * Constructor de la fachada: hemos impedido su uso para seguir el patrón + * singleton. Ahora es un constructor sin visibilidad fuera de la clase. + */ + private DBFacade() { + urlDB = "jdbc:hsqldb:hsql://localhost/mydatabase"; + usuario = "SA"; + contrasena = ""; + + // Creamos las sentencias de seleción + getContactSentence = "select * from contactos left join tiposdecontacto using (idtipocontacto) where apellidos = ?"; + insertContactSentence = "insert into contactos (idcontacto, nombre, apellidos, estimado, direccion, ciudad, prov, codpostal, region, pais, nombrecompania, cargo, telefonotrabajo, extensiontrabajo, telefonomovil, numfax, nomcorreoelectronico, idtipocontacto, notas) values (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?);"; + insertCallSentence = "insert into llamadas (idllamada, fechallamada, asunto, notas ,idcontacto) values ( ? , ? , ? , ? , ? );"; + insertContactTypeSentence = "insert into tiposdecontacto (idtipocontacto, tipocontacto) values ( ? , ? );"; + updateContactSentence = "update contactos set nombre = ?, apellidos = ?, estimado = ?, direccion = ?, ciudad = ?, prov = ?, codpostal = ?, region = ?, pais = ?, nombrecompania = ?, cargo = ?, telefonotrabajo = ?, extensiontrabajo = ?, telefonomovil = ?, numfax = ?, nomcorreoelectronico = ?, idtipocontacto = ?, notas = ? where idcontacto = ? "; + updateCallSentence = "update llamadas set idcontacto = ?, fechallamada = ?, asunto = ?, notas = ? where idllamada = ?"; + updateContactTypeSentence = "update tiposdecontacto set tipocontacto = ? where idtipocontacto = ?;"; + getContactsBySurnameSentence = "select * from contactos left join tiposdecontacto using (idtipocontacto) where apellidos = ?"; + getCallsByContactSentence = "select * from llamadas where idcontacto = ? "; + getContactTypesSentence = "select * from tiposdecontacto"; + } + + @Override + public List getCallsByContact(Contact contacto) { + // Creamos una lista para meter los tipos de contacto + List callList = new ArrayList(); + + try (Connection conn = DriverManager.getConnection(urlDB, usuario, + contrasena)) { + // Preparamos la sentencia y la ejecutamos + PreparedStatement ps = conn + .prepareStatement(getCallsByContactSentence); + ps.setInt(1, contacto.getIdContacto()); + ResultSet rs = ps.executeQuery(); + + // Añadimos todos los tipos de contacto a la lista + while (rs.next()) { + callList.add(new Call(rs.getInt("idLlamada"), contacto, rs + .getString("fechallamada"), rs.getString("asunto"), rs + .getString("notas"))); + } + + // Cerramos los recursos + rs.close(); + ps.close(); + + } catch (SQLException ex) { + System.err.println(ex.getMessage()); + } + + return callList; + } + + @Override + public Contact getContact(String surname) { + + // Creamos unas variables necesarias + int idContacto = 0, idTipoContacto = 0; + String nombre = null, apellidos = null, estimado = null, direccion = null, ciudad = null, prov = null, codPostal = null, region = null, pais = null, nombreCompania = null, cargo = null, telefonoTrabajo = null, extensionTrabajo = null, telefonoMovil = null, numFax = null, nomCorreoElectronico = null, notas = null, tipoContacto = null; + + try (Connection conn = DriverManager.getConnection(urlDB, usuario, + contrasena)) { + + // Preparamos la sentencia y la ejecutamos + PreparedStatement ps = conn.prepareStatement(getContactSentence); + ps.setString(1, surname); + ResultSet rs = ps.executeQuery(); + + // Recogemos todos los datos necesarios para crear el contacto + if (rs.next()) { + idContacto = rs.getInt("idcontacto"); + nombre = rs.getString("nombre"); + apellidos = rs.getString("apellidos"); + estimado = rs.getString("estimado"); + direccion = rs.getString("direccion"); + ciudad = rs.getString("ciudad"); + prov = rs.getString("prov"); + codPostal = rs.getString("codpostal"); + region = rs.getString("region"); + pais = rs.getString("pais"); + nombreCompania = rs.getString("nombrecompania"); + cargo = rs.getString("cargo"); + telefonoTrabajo = rs.getString("telefonotrabajo"); + extensionTrabajo = rs.getString("extensiontrabajo"); + telefonoMovil = rs.getString("telefonomovil"); + numFax = rs.getString("numfax"); + nomCorreoElectronico = rs.getString("nomcorreoelectronico"); + notas = rs.getString("notas"); + idTipoContacto = rs.getInt("idtipocontacto"); + tipoContacto = rs.getString("tipocontacto"); + } + // Cerramos los recursos + rs.close(); + ps.close(); + + } catch (SQLException ex) { + System.err.println(ex.getMessage()); + } + + return new Contact(idContacto, nombre, apellidos, estimado, direccion, + ciudad, prov, codPostal, region, pais, nombreCompania, cargo, + telefonoTrabajo, extensionTrabajo, telefonoMovil, numFax, + nomCorreoElectronico, notas, new ContactType(idTipoContacto, + tipoContacto)); + } + + @Override + public List getContactsBySurname(String surname) { + // Creamos la lista que posteriormente vamos a llena + List contactList = new ArrayList(); + + int idContacto = 0, idTipoContacto = 0; + String nombre = null, apellidos = null, estimado = null, direccion = null, ciudad = null, prov = null, codPostal = null, region = null, pais = null, nombreCompania = null, cargo = null, telefonoTrabajo = null, extensionTrabajo = null, telefonoMovil = null, numFax = null, nomCorreoElectronico = null, notas = null, tipoContacto = null; + + try (Connection conn = DriverManager.getConnection(urlDB, usuario, + contrasena)) { + // Preparamos la sentencia y la ejecutamos + PreparedStatement ps = conn + .prepareStatement(getContactsBySurnameSentence); + ps.setString(1, surname); + ResultSet rs = ps.executeQuery(); + + // Recogemos todos los datos necesarios para crear el contacto + while (rs.next()) { + idContacto = rs.getInt("idcontacto"); + nombre = rs.getString("nombre"); + apellidos = rs.getString("apellidos"); + estimado = rs.getString("estimado"); + direccion = rs.getString("direccion"); + ciudad = rs.getString("ciudad"); + prov = rs.getString("prov"); + codPostal = rs.getString("codpostal"); + region = rs.getString("region"); + pais = rs.getString("pais"); + nombreCompania = rs.getString("nombrecompania"); + cargo = rs.getString("cargo"); + telefonoTrabajo = rs.getString("telefonotrabajo"); + extensionTrabajo = rs.getString("extensiontrabajo"); + telefonoMovil = rs.getString("telefonomovil"); + numFax = rs.getString("numfax"); + nomCorreoElectronico = rs.getString("nomcorreoelectronico"); + notas = rs.getString("notas"); + idTipoContacto = rs.getInt("idtipocontacto"); + tipoContacto = rs.getString("tipocontacto"); + contactList.add(new Contact(idContacto, nombre, apellidos, + estimado, direccion, ciudad, prov, codPostal, region, + pais, nombreCompania, cargo, telefonoTrabajo, + extensionTrabajo, telefonoMovil, numFax, + nomCorreoElectronico, notas, new ContactType( + idTipoContacto, tipoContacto))); + } + // Cerramos los recursos + rs.close(); + ps.close(); + + } catch (SQLException ex) { + System.err.println(ex.getMessage()); + } + + return contactList; + } + + @Override + public List getContactTypes() { + // Creamos una lista para meter los tipos de contacto + List contactList = new ArrayList(); + + try (Connection conn = DriverManager.getConnection(urlDB, usuario, + contrasena)) { + // Preparamos la sentencia y la ejecutamos + PreparedStatement ps = conn + .prepareStatement(getContactTypesSentence); + ResultSet rs = ps.executeQuery(); + + // Añadimos todos los tipos de contacto a la lista + while (rs.next()) { + contactList.add(new ContactType(rs.getInt("idtipocontacto"), rs + .getString("tipocontacto"))); + } + + // Cerramos los recursos + rs.close(); + ps.close(); + + } catch (SQLException ex) { + System.err.println(ex.getMessage()); + } + + return contactList; + } + + @Override + public void insertCall(Call call) { + + try (Connection conn = DriverManager.getConnection(urlDB, usuario, + contrasena)) { + if (getContact(call.getContacto().getApellidos()).getApellidos() == null) { + insertContact(call.getContacto()); + } + // Preparamos la sentencia y la ejecutamos + PreparedStatement ps = conn.prepareStatement(insertCallSentence); + + // Establecemos los parámetros de la inserción + ps.setInt(1, call.getIdLlamada()); + ps.setString(2, call.getFechaLlamada()); + ps.setString(3, call.getAsunto()); + ps.setString(4, call.getNotas()); + ps.setInt(5, call.getContacto().getIdContacto()); + + if (ps.executeUpdate() == 0) { + new SQLException("No se han producido inserciones!"); + } + + // Cerramos los recursos + ps.close(); + + } catch (SQLException ex) { + System.err.println(ex.getMessage()); + } + } + + @Override + public void insertContact(Contact contact) { + + try (Connection conn = DriverManager.getConnection(urlDB, usuario, + contrasena)) { + + // Preparamos la sentencia y la ejecutamos + PreparedStatement ps = conn.prepareStatement(insertContactSentence); + + // Establecemos los parámetros de la inserción + ps.setInt(1, contact.getIdContacto()); + ps.setString(2, contact.getNombre()); + ps.setString(3, contact.getApellidos()); + ps.setString(4, contact.getEstimado()); + ps.setString(5, contact.getDireccion()); + ps.setString(6, contact.getCiudad()); + ps.setString(7, contact.getProv()); + ps.setString(8, contact.getCodPostal()); + ps.setString(9, contact.getRegion()); + ps.setString(10, contact.getPais()); + ps.setString(11, contact.getNombreCompania()); + ps.setString(12, contact.getCargo()); + ps.setString(13, contact.getTelefonoTrabajo()); + ps.setString(14, contact.getExtensionTrabajo()); + ps.setString(15, contact.getTelefonoMovil()); + ps.setString(16, contact.getNumFax()); + ps.setString(17, contact.getNomCorreoElectronico()); + ps.setInt(18, contact.getTipoContacto().getIdTipoContacto()); + ps.setString(19, contact.getNotas()); + + // Comprobamos que la actualización haya sido exitosa. + if (ps.executeUpdate() == 0) { + new SQLException("No se han producido inserciones!"); + } + + // Cerramos los recursos + ps.close(); + + } catch (SQLException ex) { + System.err.println(ex.getMessage()); + } + } + + @Override + public void insertContactType(ContactType ct) { + + try (Connection conn = DriverManager.getConnection(urlDB, usuario, + contrasena)) { + // Preparamos la sentencia y la ejecutamos + PreparedStatement ps = conn + .prepareStatement(insertContactTypeSentence); + + // Establecemos los parámetros de la inserción + ps.setInt(1, ct.getIdTipoContacto()); + ps.setString(2, ct.getTipoContacto()); + + if (ps.executeUpdate() == 0) + new SQLException("No se han producido inserciones!"); + + // Cerramos los recursos + ps.close(); + + } catch (SQLException ex) { + System.err.println(ex.getMessage()); + } + + } + + @Override + public void updateCall(Call call) { + + try (Connection conn = DriverManager.getConnection(urlDB, usuario, + contrasena)) { + // Preparamos la sentencia y la ejecutamos + PreparedStatement ps = conn.prepareStatement(updateCallSentence); + + // Establecemos los parámetros de la inserción + ps.setInt(1, call.getContacto().getIdContacto()); + ps.setString(2, call.getFechaLlamada()); + ps.setString(3, call.getAsunto()); + ps.setString(4, call.getNotas()); + ps.setInt(5, call.getIdLlamada()); + + // Comprobamos que la actualización haya sido exitosa. + if (ps.executeUpdate() == 0) { + new SQLException("No se ha podido actualizar la llamada"); + } + + // Cerramos los recursos + ps.close(); + + } catch (SQLException ex) { + System.err.println(ex.getMessage()); + } + } + + @Override + public void updateContact(Contact contact) { + + try (Connection conn = DriverManager.getConnection(urlDB, usuario, + contrasena)) { + // Preparamos la sentencia y la ejecutamos + PreparedStatement ps = conn.prepareStatement(updateContactSentence); + + // Establecemos los parámetros de la inserción + ps.setString(1, contact.getNombre()); + ps.setString(2, contact.getApellidos()); + ps.setString(3, contact.getEstimado()); + ps.setString(4, contact.getDireccion()); + ps.setString(5, contact.getCiudad()); + ps.setString(6, contact.getProv()); + ps.setString(7, contact.getCodPostal()); + ps.setString(8, contact.getRegion()); + ps.setString(9, contact.getPais()); + ps.setString(10, contact.getNombreCompania()); + ps.setString(11, contact.getCargo()); + ps.setString(12, contact.getTelefonoTrabajo()); + ps.setString(13, contact.getExtensionTrabajo()); + ps.setString(14, contact.getTelefonoMovil()); + ps.setString(15, contact.getNumFax()); + ps.setString(16, contact.getNomCorreoElectronico()); + ps.setInt(17, contact.getTipoContacto().getIdTipoContacto()); + ps.setString(18, contact.getNotas()); + ps.setInt(19, contact.getIdContacto()); + + // Comprobamos que la actualización haya sido exitosa. + if (ps.executeUpdate() == 0) { + new SQLException("No se han producido inserciones!"); + } + + // Cerramos los recursos + ps.close(); + + } catch (SQLException ex) { + System.err.println(ex.getMessage()); + } + } + + @Override + public void updateContactType(ContactType ct) { + + try (Connection conn = DriverManager.getConnection(urlDB, usuario, + contrasena)) { + // Preparamos la sentencia y la ejecutamos + PreparedStatement ps = conn + .prepareStatement(updateContactTypeSentence); + + // Establecemos los parámetros de la inserción + ps.setString(1, ct.getTipoContacto()); + ps.setInt(2, ct.getIdTipoContacto()); + + if (ps.executeUpdate() == 0) { + new SQLException("No se han producido inserciones!"); + } + + // Cerramos los recursos + ps.close(); + + } catch (SQLException ex) { + System.err.println(ex.getMessage()); + } + } + +} diff --git a/src/ubu/lsi/dms/agenda/persistence/DBFactory.java b/src/ubu/lsi/dms/agenda/persistence/DBFactory.java new file mode 100644 index 0000000..46c2ad3 --- /dev/null +++ b/src/ubu/lsi/dms/agenda/persistence/DBFactory.java @@ -0,0 +1,48 @@ +package ubu.lsi.dms.agenda.persistence; + +/** + * Clase fábrica que crea una fábrica de persistencia en base de datos. + * Implementa la interfaz PersistenceFactory. Se aplica el patron de diseño + * Abstract Factory. Participante como fábrica concreta. Se aplica el patron de + * diseño Singleton para crear instancia única de la clase. + * + * @author Alberto Vivar Arribas + * @author Mario López Jiménez + */ +public class DBFactory implements PersistenceFactory { + + /** + * Devuelve la referencia a una instancia de la clase DBFactory. Método + * necesario para el patron Singleton. + * + * @return instance la referencia a la instancia única. + */ + public static DBFactory getInstance() { + return instance; + } // getInstance + + /** + * Guarda una referencia a la instancia de la propia clase. Atributo + * necesario para el patron Singleton. + */ + private static DBFactory instance = new DBFactory(); + + /** + * Constructor privado para evitar instanciaciones externas. + */ + private DBFactory() { + } + + /* + * (non-Javadoc) + * + * @see + * ubu.lsi.dms.agenda.persistence.PersistenceFactory#createPersistenceFacade + * () + */ + @Override + public DBFacade createPersistenceFacade() { + return DBFacade.getInstance(); + } // createPersistenceFacade + +} // class DBFactory diff --git a/src/ubu/lsi/dms/agenda/persistence/PersistenceFacade.java b/src/ubu/lsi/dms/agenda/persistence/PersistenceFacade.java new file mode 100644 index 0000000..ceb6a58 --- /dev/null +++ b/src/ubu/lsi/dms/agenda/persistence/PersistenceFacade.java @@ -0,0 +1,103 @@ +package ubu.lsi.dms.agenda.persistence; + +import java.util.List; + +import ubu.lsi.dms.agenda.modelo.Call; +import ubu.lsi.dms.agenda.modelo.Contact; +import ubu.lsi.dms.agenda.modelo.ContactType; + +/** + * Interfaz fachada que se utiliza para la creación de una fachada persistente. + * Se aplica el patron de diseño Abstract Factory. Participante como producto + * abstracto. + * + * @author Plamen Petyov Petkov + * + */ +public interface PersistenceFacade { + + /** + * Obtiene las llamadas de un contacto + * + * @param contacto + * Contacto del que obtener las llamadas. + */ + public List getCallsByContact(Contact contacto); + + /** + * Busca a un contacto por apellido. + * + * @param surname + * @return el primer contacto con ese apellido. + */ + public Contact getContact(String surname); + + /** + * Obtiene una lista de todos los contactos existentes en la persistencia + * filtrados por el apellido. + * + * @param surname + * @return lista de contactos con ese apellido. + */ + public List getContactsBySurname(String surname); + + /** + * Devuelve una lista con todos los tipos de contacto existentes en la + * persistencia. + * + * @return lista de todos los tipos de contacto. + */ + public List getContactTypes(); + + /** + * Inserta una llamada (incluyendo la referencia a un contacto) (Al final + * lanzas dos insert -llamada y contacto-. + * + * @param call + * LLamada a insertar + */ + public void insertCall(Call call); + + /** + * Inserta un contacto en la persistencia. + * + * @param contact + * contacto a insertar. + */ + public void insertContact(Contact contact); + + /** + * Inserta un tipo de contacto en la persistencia. + * + * @param ct + * Tipo de contacto a insertar. + */ + public void insertContactType(ContactType ct); + + /** + * Actualiza una llamada en la persistencia. + * + * @param call + * LLamada a actualizar. + */ + public void updateCall(Call call); + + /** + * Actualiza los datos de un contacto en la base de datos. Solamente + * actualiza, no inserta nada. Lanza algo que diga que no había nada que + * actualizar. + * + * @param contact + * Contacto a actualizar. + */ + public void updateContact(Contact contact); + + /** + * Actualiza el nombre del tipo de contacto contra la persistencia. + * + * @param ct + * Tipo de contacto a actualizar + */ + public void updateContactType(ContactType ct); + +} diff --git a/src/ubu/lsi/dms/agenda/persistence/PersistenceFactory.java b/src/ubu/lsi/dms/agenda/persistence/PersistenceFactory.java new file mode 100644 index 0000000..7e8fa3f --- /dev/null +++ b/src/ubu/lsi/dms/agenda/persistence/PersistenceFactory.java @@ -0,0 +1,21 @@ +package ubu.lsi.dms.agenda.persistence; + +/** + * Interfaz fábrica que se utiliza para la creación de una fachada de + * persistencia. Se aplica el patron de diseño Abstract Factory. Participante + * como fábrica abstracta. + * + * @author Plamen Petyov Petkov + * + */ +public interface PersistenceFactory { + + /** + * Crea una fachada de persistencia que proporciona los métodos necesarios + * para comunicarse con el modelo de datos. + * + * @return objeto de tipo PersistenceFacade + */ + public PersistenceFacade createPersistenceFacade(); + +} diff --git a/src/ubu/lsi/dms/agenda/persistencia/package-info.java b/src/ubu/lsi/dms/agenda/persistence/package-info.java similarity index 90% rename from src/ubu/lsi/dms/agenda/persistencia/package-info.java rename to src/ubu/lsi/dms/agenda/persistence/package-info.java index 8e02dae..960e250 100644 --- a/src/ubu/lsi/dms/agenda/persistencia/package-info.java +++ b/src/ubu/lsi/dms/agenda/persistence/package-info.java @@ -10,4 +10,4 @@ * @author Carlos López * */ -package ubu.lsi.dms.agenda.persistencia; \ No newline at end of file +package ubu.lsi.dms.agenda.persistence; \ No newline at end of file diff --git a/src/ubu/lsi/dms/agenda/persistencia/FabricaBD.java b/src/ubu/lsi/dms/agenda/persistencia/FabricaBD.java deleted file mode 100644 index 656248e..0000000 --- a/src/ubu/lsi/dms/agenda/persistencia/FabricaBD.java +++ /dev/null @@ -1,21 +0,0 @@ -/** - * - */ -package ubu.lsi.dms.agenda.persistencia; - -/** - * @author alumno - * - */ -public class FabricaBD implements FabricaPersistencia { - - /* (non-Javadoc) - * @see ubu.lsi.dms.agenda.persistencia.FabricaPersistencia#crearFachadaPersistente() - */ - @Override - public FachadaPersistente crearFachadaPersistente() { - // TODO Auto-generated method stub - return null; - } - -} diff --git a/src/ubu/lsi/dms/agenda/persistencia/FabricaBin.java b/src/ubu/lsi/dms/agenda/persistencia/FabricaBin.java deleted file mode 100644 index 992a3ec..0000000 --- a/src/ubu/lsi/dms/agenda/persistencia/FabricaBin.java +++ /dev/null @@ -1,25 +0,0 @@ -/** - * - */ -package ubu.lsi.dms.agenda.persistencia; - -/** - * @author alumno - * - */ -public class FabricaBin implements FabricaPersistencia { - - /* - * (non-Javadoc) - * - * @see - * ubu.lsi.dms.agenda.persistencia.FabricaPersistencia#crearFachadaPersistente - * () - */ - @Override - public FachadaPersistente crearFachadaPersistente() { - // TODO Auto-generated method stub - return null; - } - -} diff --git a/src/ubu/lsi/dms/agenda/persistencia/FabricaPersistencia.java b/src/ubu/lsi/dms/agenda/persistencia/FabricaPersistencia.java deleted file mode 100644 index 6dd1116..0000000 --- a/src/ubu/lsi/dms/agenda/persistencia/FabricaPersistencia.java +++ /dev/null @@ -1,13 +0,0 @@ -/** - * - */ -package ubu.lsi.dms.agenda.persistencia; - -/** - * @author alumno - * - */ -public interface FabricaPersistencia { - public FachadaPersistente crearFachadaPersistente(); - -} diff --git a/src/ubu/lsi/dms/agenda/persistencia/FachadaBD.java b/src/ubu/lsi/dms/agenda/persistencia/FachadaBD.java deleted file mode 100644 index 0279220..0000000 --- a/src/ubu/lsi/dms/agenda/persistencia/FachadaBD.java +++ /dev/null @@ -1,12 +0,0 @@ -/** - * - */ -package ubu.lsi.dms.agenda.persistencia; - -/** - * @author alumno - * - */ -public class FachadaBD implements FachadaPersistente { - -} diff --git a/src/ubu/lsi/dms/agenda/persistencia/FachadaBin.java b/src/ubu/lsi/dms/agenda/persistencia/FachadaBin.java deleted file mode 100644 index 0848530..0000000 --- a/src/ubu/lsi/dms/agenda/persistencia/FachadaBin.java +++ /dev/null @@ -1,12 +0,0 @@ -/** - * - */ -package ubu.lsi.dms.agenda.persistencia; - -/** - * @author alumno - * - */ -public class FachadaBin implements FachadaPersistente { - -} diff --git a/src/ubu/lsi/dms/agenda/persistencia/FachadaPersistente.java b/src/ubu/lsi/dms/agenda/persistencia/FachadaPersistente.java deleted file mode 100644 index d99c4a0..0000000 --- a/src/ubu/lsi/dms/agenda/persistencia/FachadaPersistente.java +++ /dev/null @@ -1,12 +0,0 @@ -/** - * - */ -package ubu.lsi.dms.agenda.persistencia; - -/** - * @author alumno - * - */ -public interface FachadaPersistente { - -} diff --git a/src/ubu/lsi/dms/agenda/test/persistencia/BDFacadeTest.java b/src/ubu/lsi/dms/agenda/test/persistencia/BDFacadeTest.java new file mode 100644 index 0000000..3e6132a --- /dev/null +++ b/src/ubu/lsi/dms/agenda/test/persistencia/BDFacadeTest.java @@ -0,0 +1,189 @@ +package ubu.lsi.dms.agenda.test.persistencia; + +import java.util.ArrayList; +import java.util.List; + +import ubu.lsi.dms.agenda.modelo.Call; +import ubu.lsi.dms.agenda.modelo.Contact; +import ubu.lsi.dms.agenda.modelo.ContactType; +import ubu.lsi.dms.agenda.persistence.DBFactory; +import ubu.lsi.dms.agenda.persistence.PersistenceFacade; +import ubu.lsi.dms.agenda.persistence.PersistenceFactory; + +/** + * Contiene los métodos necesarios para probar la persistencia sobre bases de + * datos. + * + * @author Alberto Vivar Arribas + */ +public class BDFacadeTest { + /** + * Creamos la fábrica de persistencia + */ + private static PersistenceFactory factory = DBFactory.getInstance(); + /** + * Generamos la instancia de la fachada de persistencia. + */ + private static PersistenceFacade dbf = factory.createPersistenceFacade(); + + /** + * Generamos los datos que vamos a emplear. + */ + private static CommonData datos = CommonData.getInstance(); + + /** + * Separamos los contactos, las llamadas y los tipos de contactos. + */ + private static List contactListFromCode = datos.getContactList(); + private static List callListFromCode = datos.getCallList(); + private static List contactTypeListFromCode = datos + .getContactTypeList(); + + public static void main(String[] args) { + /* + * Si las aserciones no están activadas en la máquina virtual no tiene + * sentido lanzar las pruebas. + */ + if (!areAssertsEnabled()) { + System.out + .println("Para que las pruebas funcionen correctamente,\n" + + "activa las aserciones con -ea como parámetro de la máquina virtual de java,\n" + + "además de tener las tablas creadas y vacías..."); + System.err.println("Pruebas abortadas!!!"); + return; + } + // Las pruebas en sí + System.out.println("Comenzando pruebas...\n"); + pruebasTiposDeContacto(); + System.out.println("Pruebas de tipos de contactos pasadas!!!"); + pruebasContactos(); + System.out.println("Pruebas de contactos pasadas!!!"); + pruebasLLamadas(); + System.out.println("Pruebas de llamadas pasadas!!!"); + System.out + .println("Enhorabuena, todas las pruebas de BBDD han salido correctamente!!!"); + } + + /** + * Comprueba si los asertos están activadas + * + * @return Cierto si están activadas, falso si no. + */ + public static boolean areAssertsEnabled() { + boolean isEnabled = false; + try { + assert false; + } catch (AssertionError ex) { + isEnabled = true; + } + return isEnabled; + } + + /** + * Pruebas que se realizan a los tipos de contacto. + */ + private static void pruebasTiposDeContacto() { + /* + * Creamos la lista donde almacenar lo que obtengamos de la BBDD. + */ + List contactTypeListFromDB = new ArrayList(); + /* + * Insertamos los tipos de contacto en la BBDD y comprobamos que estén + * todos correctamente. + */ + for (ContactType contactType : contactTypeListFromCode) { + dbf.insertContactType(contactType); + } + contactTypeListFromDB.addAll(dbf.getContactTypes()); + assert contactTypeListFromCode.containsAll(contactTypeListFromDB); + contactTypeListFromDB.clear(); + + /* + * Actualizamos los tipos de contacto y comprobamos que los cambios se + * hayan reflejado en la BBDD. + */ + for (ContactType contactType : contactTypeListFromCode) { + contactType.setTipoContacto(contactType.getTipoContacto() + "1"); + dbf.updateContactType(contactType); + } + contactTypeListFromDB.addAll(dbf.getContactTypes()); + assert contactTypeListFromCode.containsAll(contactTypeListFromDB); + contactTypeListFromDB.clear(); + } + + /** + * Pruebas que se realizan a las llamadas. + */ + private static void pruebasLLamadas() { + /* + * Creamos la lista donde almacenar lo que obtengamos de la BBDD. + */ + List callListFromDB = new ArrayList(); + /* + * Insertamos las llamadas en la BBDD y comprobamos que estén todos + * correctamente. + */ + for (Call call : callListFromCode) { + dbf.insertCall(call); + callListFromDB.addAll(dbf.getCallsByContact(call.getContacto())); + } + assert callListFromCode.containsAll(callListFromDB); + callListFromDB.clear(); + + /* + * Actualizamos las llamadas y comprobamos que los cambios se hayan + * reflejado en la BBDD. + */ + for (Call call : callListFromCode) { + // Cambiamos un campo, como por ejemplo el de las notas + call.setNotas(call.getNotas() + "1"); + dbf.updateCall(call); + callListFromDB.addAll(dbf.getCallsByContact(call.getContacto())); + } + assert callListFromCode.containsAll(callListFromDB); + callListFromDB.clear(); + } + + /** + * Pruebas que se realizan a los contactos + */ + private static void pruebasContactos() { + /* + * Creamos la lista donde almacenar lo que obtengamos de la BBDD + */ + List contactListFromDB = new ArrayList(); + List contactListListFromDB = new ArrayList(); + /* + * Insertamos los contactos en la BBDD y comprobamos que estén todos + * correctamente. + */ + for (Contact contact : contactListFromCode) { + dbf.insertContact(contact); + contactListListFromDB.addAll(dbf.getContactsBySurname(contact + .getApellidos())); + contactListFromDB.add(dbf.getContact(contact.getApellidos())); + } + assert contactListFromCode.containsAll(contactListListFromDB); + assert contactListFromCode.containsAll(contactListFromDB); + contactListListFromDB.clear(); + contactListFromDB.clear(); + + /* + * Actualizamos los contactos y comprobamos que los cambios se hayan + * reflejado en la BBDD. + */ + for (Contact contact : contactListFromCode) { + // Cambiamos un campo, por ejemplo los apellidos + contact.setApellidos(contact.getApellidos() + "1"); + dbf.updateContact(contact); + contactListListFromDB.addAll(dbf.getContactsBySurname(contact + .getApellidos())); + contactListFromDB.add(dbf.getContact(contact.getApellidos())); + } + assert contactListFromCode.containsAll(contactListListFromDB); + assert contactListFromCode.containsAll(contactListFromDB); + contactListListFromDB.clear(); + contactListFromDB.clear(); + } + +} diff --git a/src/ubu/lsi/dms/agenda/test/persistencia/BinaryFacadeTest.java b/src/ubu/lsi/dms/agenda/test/persistencia/BinaryFacadeTest.java new file mode 100644 index 0000000..f6db856 --- /dev/null +++ b/src/ubu/lsi/dms/agenda/test/persistencia/BinaryFacadeTest.java @@ -0,0 +1,173 @@ +package ubu.lsi.dms.agenda.test.persistencia; + +import java.io.File; +import java.util.List; + +import ubu.lsi.dms.agenda.modelo.Call; +import ubu.lsi.dms.agenda.modelo.Contact; +import ubu.lsi.dms.agenda.modelo.ContactType; +import ubu.lsi.dms.agenda.persistence.BinaryFactory; +import ubu.lsi.dms.agenda.persistence.PersistenceFacade; +import ubu.lsi.dms.agenda.persistence.PersistenceFactory; + +/** + * Clase que contiene tests para probar la persistencia con ficheros binarios. + * + * @author Plamen Petkov + * + */ +public class BinaryFacadeTest { + + static CommonData data = CommonData.getInstance(); + static PersistenceFactory factory = BinaryFactory.getInstance(); + static PersistenceFacade facade = factory.createPersistenceFacade(); + static File[] files = { new File(".\\rsc\\calls.dat"), + new File(".\\rsc\\contacts.dat"), + new File(".\\rsc\\contactTypes.dat") }; + + // Datos de prueba obtenidos de la clase CommonData + static List calls = data.getCallList(); + static List contacts = data.getContactList(); + static List contactTypes = data.getContactTypeList(); + + public static void main(String args[]) { + + removeFiles(); + /* + * Si las aserciones no están activadas en la máquina virtual no tiene + * sentido lanzar las pruebas. + */ + if (!areAssertsEnabled()) { + System.out + .println("Para que las pruebas funcionen correctamente,\n" + + "activa las aserciones con -ea como parámetro de la máquina virtual de java,\n"); + System.err.println("Pruebas abortadas"); + return; + } + + ctTest(); + + contactTest(); + + callTest(); + + System.out.println("All tests concluded successfully!"); + + } // main + + /** + * Test para los metodos de la fachada que trabajan con la clase Call + */ + private static void callTest() { + List listOfCalls; + + // Inserta las llamadas de la lista de datos + for (Call call : calls) + facade.insertCall(call); + + // Obtiene las llamadas del primer contacto de la lista de datos + assert facade.getCallsByContact(contacts.get(0)).size() == 1; + + // Actualiza las llamadas cambiando el contacto de cada llamada por el + // segundo contacto de la lista de datos + for (Call call : calls) { + Call newCall = new Call(call.getIdLlamada(), contacts.get(1), "", + "", ""); + facade.updateCall(newCall); + } + + // Obtiene las llamadas del segundo contacto de la lista de datos + // Comprueba que el numero de llamadas obtenidas es igual al numero + // total de llamadas + // Comprueba que el numero de llamadas del primer contacto de la lista + // es 0 + listOfCalls = facade.getCallsByContact(contacts.get(1)); + assert listOfCalls.size() == calls.size(); + assert facade.getCallsByContact(contacts.get(0)).size() == 0; + } + + /** + * Tests para los metodos de la fachada que trabajan con la clase + */ + private static void contactTest() { + List listOfContacts; + + // Inserta los contactos de la lista de datos + for (Contact contact : contacts) + facade.insertContact(contact); + + // Obtiene el contacto con apellido Apellidos001 y comprueba que es el + // primer contacto insertado (primer contacto de la lista de datos) + assert facade.getContact("Apellidos001").equals(contacts.get(0)); + // Comprueba que no hay contacto con apellido Petkov + assert facade.getContact("Petkov") == null; + + // Actualiza los contactos añadiendo los mismos datos a todos los + // contactos excepto el idContacto + for (Contact contact : contacts) { + Contact newContact = new Contact(contact.getIdContacto(), + "NombreNuevo", "ApellidosNuevos", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", null); + facade.updateContact(newContact); + } + + // Obtiene los contactos con apellido ApellidosNuevos y comprueba que + // la lista inicial no contiene ninguno de ellos + listOfContacts = facade.getContactsBySurname("ApellidosNuevos"); + for (Contact contact : listOfContacts) + assert !(contacts.contains(contact)); + } + + /** + * Tests para los metodos de la fachada que trabajan con la clase + */ + private static void ctTest() { + List listOfCTs; + + // Inserta los tipo de contacto de la lista de datos + for (ContactType ct : contactTypes) + facade.insertContactType(ct); + + // Obtiene la los tipos de contacto + listOfCTs = facade.getContactTypes(); + // Comprueba que la lista contiene a todos los tipos de contacto + // insertados + assert listOfCTs.containsAll(contactTypes); + + // Actualiza un tipo de contacto añadiendo la cadena "updated" + for (ContactType ct : listOfCTs) + facade.updateContactType(new ContactType(ct.getIdTipoContacto(), ct + .getTipoContacto() + "updated")); + + listOfCTs = facade.getContactTypes(); + // Comprueba que todos los tipos de contacto contienen la cadena + // "updated" + for (ContactType ct : listOfCTs) + assert ct.getTipoContacto().contains("updated"); + } + + /** + * Elimina los archivos de persistencia en caso de que existan. + */ + private static void removeFiles() { + for (File file : files) + if (file.exists()) + file.delete(); + } // removeFiles + + /** + * Comprueba si los asertos están activadas + * + * @return Cierto si están activadas, falso si no. + */ + public static boolean areAssertsEnabled() { + boolean isEnabled = false; + try { + assert false; + } catch (AssertionError ex) { + isEnabled = true; + } + return isEnabled; + } + +} // class BinaryFacadeTest diff --git a/src/ubu/lsi/dms/agenda/test/persistencia/CommonData.java b/src/ubu/lsi/dms/agenda/test/persistencia/CommonData.java new file mode 100644 index 0000000..0fc05db --- /dev/null +++ b/src/ubu/lsi/dms/agenda/test/persistencia/CommonData.java @@ -0,0 +1,85 @@ +package ubu.lsi.dms.agenda.test.persistencia; + +import java.util.ArrayList; +import java.util.List; + +import ubu.lsi.dms.agenda.modelo.Call; +import ubu.lsi.dms.agenda.modelo.Contact; +import ubu.lsi.dms.agenda.modelo.ContactType; + +/** + * Vamos a almacenar en una clase los tipos que necesitemos para realizar las + * pruebas que necesitamos en ambas clase, tanto en la fachada de BBDD como en + * la fachada binaria. + * + * @author killer7129 + * + */ +public class CommonData { + private List contactList; + private List callList; + private List contactTypeList; + + private static CommonData instance = null; + + private CommonData() { + // Inicializamos los arraylist + contactList = new ArrayList(); + callList = new ArrayList(); + contactTypeList = new ArrayList(); + + for (int i = 1; i <= 10; i++) { + switch (i) { + case 1 - 9: + System.out.println("Entro con " + i); + } + // Creamos un string para formaterar el número de 0 + String letra = null; + if (i >= 1 && i <= 9) { + letra = "00" + i; + } else if (i >= 10 && i <= 99) { + letra = "0" + i; + } else if (i >= 100 && i <= 999) { + letra = "" + i; + } + // Creamos un contacto, una llamada y un tipo de contacto + ContactType contactType = new ContactType(i, "TipoDeContacto" + + letra); + Contact contact = new Contact(i, "Nombre" + letra, "Apellidos" + + letra, "Estimado" + letra, "Direccion" + letra, "Ciudad" + + letra, "Prov" + letra, "CodProv" + letra, "Region" + + letra, "Pais" + letra, "NombreCompania" + letra, "Cargo" + + letra, "TelefonoTrabajo" + letra, "ExtensionTrabajo" + + letra, "TelefonoMovil" + letra, "NumFax" + letra, + "NomCorreoElectronico" + letra, "Notas" + letra, + contactType); + Call call = new Call(i, contact, "2014-10-18 01:00:00.000000", + "Asunto" + letra, "Notas" + letra); + + if (i < 10) { + contactList.add(contact); + contactTypeList.add(contactType); + } + callList.add(call); + } + } + + public static CommonData getInstance() { + if (instance == null) { + instance = new CommonData(); + } + return instance; + } + + public List getContactList() { + return contactList; + } + + public List getCallList() { + return callList; + } + + public List getContactTypeList() { + return contactTypeList; + } +} \ No newline at end of file diff --git a/src/ubu/lsi/dms/agenda/test/package-info.java b/src/ubu/lsi/dms/agenda/test/persistencia/package-info.java similarity index 74% rename from src/ubu/lsi/dms/agenda/test/package-info.java rename to src/ubu/lsi/dms/agenda/test/persistencia/package-info.java index 2e2093e..0edc249 100644 --- a/src/ubu/lsi/dms/agenda/test/package-info.java +++ b/src/ubu/lsi/dms/agenda/test/persistencia/package-info.java @@ -5,4 +5,4 @@ * @author clopezno * */ -package ubu.lsi.dms.agenda.test; \ No newline at end of file +package ubu.lsi.dms.agenda.test.persistencia; \ No newline at end of file