diff --git a/database/3.sql b/database/3.sql new file mode 100644 index 0000000..f7811b7 --- /dev/null +++ b/database/3.sql @@ -0,0 +1,6 @@ +drop table if exists tipos_detalle; +drop table if exists detalles; +create table tipos_detalle (id integer primary key, nombre text); +create table detalles(id integer primary key, valor integer not null, descripcion text not null, tipo_detalle_id integer not null, estado_resultado_id integer not null, foreign key (estado_resultado_id) references estado_resultado (id) on update cascade on delete restrict, foreign key (tipo_detalle_id) references tipos_detalle (id) on update cascade on delete restrict); +insert into tipos_detalle (nombre) values ('Agua'), ('Luz'), ('Gas'), ('Telefono'), ('Otro'), ('CTA CTE Con Factura'), ('CTA CTE Con Boleta'), ('CTA CTE Sin Respaldo'); +update version set version = 3; \ No newline at end of file diff --git a/dist/Programa Caja.jar b/dist/Programa Caja.jar index dd1b0ca..f317fdd 100644 Binary files a/dist/Programa Caja.jar and b/dist/Programa Caja.jar differ diff --git a/dist/data/bk b/dist/data/bk new file mode 100644 index 0000000..a41f3e5 Binary files /dev/null and b/dist/data/bk differ diff --git a/dist/data/version_scripts b/dist/data/version_scripts index a41f3e5..8cb6a91 100644 Binary files a/dist/data/version_scripts and b/dist/data/version_scripts differ diff --git a/src/danielcortes/xyz/Main.java b/src/danielcortes/xyz/Main.java index 8ff9f2f..8243efd 100644 --- a/src/danielcortes/xyz/Main.java +++ b/src/danielcortes/xyz/Main.java @@ -36,7 +36,7 @@ import javax.swing.UnsupportedLookAndFeelException; public class Main { - private static final int DATABASE_VERSION = 2; + private static final int DATABASE_VERSION = 3; static { setUpSystemProperties(); diff --git a/src/danielcortes/xyz/data/DAOManager.java b/src/danielcortes/xyz/data/DAOManager.java index 453697f..393f725 100644 --- a/src/danielcortes/xyz/data/DAOManager.java +++ b/src/danielcortes/xyz/data/DAOManager.java @@ -28,6 +28,8 @@ import danielcortes.xyz.models.caja.CajaDAO; import danielcortes.xyz.models.caja.SQLiteCajaDAO; import danielcortes.xyz.models.calculo_fondo.CalculoFondoDAO; import danielcortes.xyz.models.calculo_fondo.SQLiteCalculoFondoDAO; +import danielcortes.xyz.models.detalle.DetalleDAO; +import danielcortes.xyz.models.detalle.SQLiteDetalleDAO; import danielcortes.xyz.models.documentos.DocumentosDAO; import danielcortes.xyz.models.documentos.SQLiteDocumentosDAO; import danielcortes.xyz.models.efectivo.EfectivoDAO; @@ -38,6 +40,8 @@ import danielcortes.xyz.models.estado_resultado.EstadoResultadoDAO; import danielcortes.xyz.models.estado_resultado.SQLiteEstadoResultadoDAO; import danielcortes.xyz.models.ingreso.IngresoDAO; import danielcortes.xyz.models.ingreso.SQLiteIngresoDAO; +import danielcortes.xyz.models.tipo_detalle.SQLiteTipoDetalleDAO; +import danielcortes.xyz.models.tipo_detalle.TipoDetalleDAO; import danielcortes.xyz.models.tipo_egreso.SQLiteTipoEgresoDAO; import danielcortes.xyz.models.tipo_egreso.TipoEgresoDAO; import danielcortes.xyz.models.tipo_ingreso.SQLiteTipoIngresoDAO; @@ -53,8 +57,10 @@ public class DAOManager { private static EfectivoDAO efectivoDAO; private static EgresoDAO egresoDAO; private static IngresoDAO ingresoDAO; + private static DetalleDAO detalleDAO; private static TipoEgresoDAO tipoEgresoDAO; private static TipoIngresoDAO tipoIngresoDAO; + private static TipoDetalleDAO tipoDetalleDAO; private static EstadoResultadoDAO estadoResultadoDAO; private static VersionDAO versionDAO; @@ -65,8 +71,10 @@ public class DAOManager { efectivoDAO = new SQLiteEfectivoDAO(); egresoDAO = new SQLiteEgresoDAO(); ingresoDAO = new SQLiteIngresoDAO(); + detalleDAO = new SQLiteDetalleDAO(); tipoEgresoDAO = new SQLiteTipoEgresoDAO(); tipoIngresoDAO = new SQLiteTipoIngresoDAO(); + tipoDetalleDAO = new SQLiteTipoDetalleDAO(); estadoResultadoDAO = new SQLiteEstadoResultadoDAO(); versionDAO = new SQLiteVersionDAO(); } @@ -78,8 +86,10 @@ public class DAOManager { efectivoDAO = new SQLiteEfectivoDAO(connectionHolder); egresoDAO = new SQLiteEgresoDAO(connectionHolder); ingresoDAO = new SQLiteIngresoDAO(connectionHolder); + detalleDAO = new SQLiteDetalleDAO(connectionHolder); tipoEgresoDAO = new SQLiteTipoEgresoDAO(connectionHolder); tipoIngresoDAO = new SQLiteTipoIngresoDAO(connectionHolder); + tipoDetalleDAO = new SQLiteTipoDetalleDAO(connectionHolder); estadoResultadoDAO = new SQLiteEstadoResultadoDAO(connectionHolder); versionDAO = new SQLiteVersionDAO(connectionHolder); } @@ -108,6 +118,10 @@ public class DAOManager { return ingresoDAO; } + public static DetalleDAO getDetalleDAO() { + return detalleDAO; + } + public static TipoEgresoDAO getTipoEgresoDAO() { return tipoEgresoDAO; } @@ -116,6 +130,10 @@ public class DAOManager { return tipoIngresoDAO; } + public static TipoDetalleDAO getTipoDetalleDAO() { + return tipoDetalleDAO; + } + public static EstadoResultadoDAO getEstadoResultadoDAO() { return estadoResultadoDAO; } diff --git a/src/danielcortes/xyz/models/detalle/Detalle.java b/src/danielcortes/xyz/models/detalle/Detalle.java new file mode 100644 index 0000000..8523b47 --- /dev/null +++ b/src/danielcortes/xyz/models/detalle/Detalle.java @@ -0,0 +1,85 @@ +package danielcortes.xyz.models.detalle; + +import danielcortes.xyz.models.estado_resultado.EstadoResultado; +import danielcortes.xyz.models.tipo_detalle.TipoDetalle; +import java.util.Objects; + +public class Detalle { + private int id; + private int valor; + private String descripcion; + private TipoDetalle tipoDetalle; + private EstadoResultado estadoResultado; + + public int getId() { + return id; + } + + public void setId(int id) { + this.id = id; + } + + public int getValor() { + return valor; + } + + public void setValor(int valor) { + this.valor = valor; + } + + public String getDescripcion() { + return descripcion; + } + + public void setDescripcion(String descripcion) { + this.descripcion = descripcion; + } + + public TipoDetalle getTipoDetalle() { + return tipoDetalle; + } + + public void setTipoDetalle(TipoDetalle tipoDetalle) { + this.tipoDetalle = tipoDetalle; + } + + public EstadoResultado getEstadoResultado() { + return estadoResultado; + } + + public void setEstadoResultado(EstadoResultado estadoResultado) { + this.estadoResultado = estadoResultado; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (!(o instanceof Detalle)) { + return false; + } + Detalle detalle = (Detalle) o; + return id == detalle.id && + valor == detalle.valor && + Objects.equals(descripcion, detalle.descripcion) && + Objects.equals(tipoDetalle, detalle.tipoDetalle) && + Objects.equals(estadoResultado, detalle.estadoResultado); + } + + @Override + public int hashCode() { + return Objects.hash(id, valor, descripcion, tipoDetalle, estadoResultado); + } + + @Override + public String toString() { + return "Detalle{" + + "id=" + id + + ", valor=" + valor + + ", descripcion='" + descripcion + '\'' + + ", tipoDetalle=" + tipoDetalle + + ", estadoResultado=" + estadoResultado + + '}'; + } +} diff --git a/src/danielcortes/xyz/models/detalle/DetalleDAO.java b/src/danielcortes/xyz/models/detalle/DetalleDAO.java new file mode 100644 index 0000000..632d2b6 --- /dev/null +++ b/src/danielcortes/xyz/models/detalle/DetalleDAO.java @@ -0,0 +1,17 @@ +package danielcortes.xyz.models.detalle; + +import danielcortes.xyz.models.estado_resultado.EstadoResultado; +import danielcortes.xyz.models.tipo_detalle.TipoDetalle; +import java.util.List; +import java.util.Optional; + +public interface DetalleDAO { + List getAll(); + List getByTipoDetalle(TipoDetalle tipoDetalle); + Optional getById(int id); + Optional getByEstadoResultado(EstadoResultado estadoResultado); + + void insert(Detalle detalle); + void update(Detalle detalle); + void delete(Detalle detalle); +} diff --git a/src/danielcortes/xyz/models/detalle/SQLiteDetalleDAO.java b/src/danielcortes/xyz/models/detalle/SQLiteDetalleDAO.java new file mode 100644 index 0000000..b703206 --- /dev/null +++ b/src/danielcortes/xyz/models/detalle/SQLiteDetalleDAO.java @@ -0,0 +1,227 @@ +package danielcortes.xyz.models.detalle; + +import danielcortes.xyz.data.ConnectionHolder; +import danielcortes.xyz.data.DAOManager; +import danielcortes.xyz.data.SQLiteConnectionHolder; +import danielcortes.xyz.models.estado_resultado.EstadoResultado; +import danielcortes.xyz.models.tipo_detalle.TipoDetalle; +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; + +public class SQLiteDetalleDAO implements DetalleDAO{ + private static final Logger log = LogManager.getLogger(SQLiteDetalleDAO.class); + private ConnectionHolder connectionHolder; + + public SQLiteDetalleDAO() { + this.connectionHolder = new SQLiteConnectionHolder(); + } + + public SQLiteDetalleDAO(ConnectionHolder connectionHolder) { + this.connectionHolder = connectionHolder; + } + + @Override + public List getAll() { + log.debug("Se intentaran conseguir todos los Detalle"); + List detalleList = new ArrayList<>(); + String query = "select * from detalles"; + try (Connection conn = connectionHolder.getConnection()) { + try (PreparedStatement ps = conn.prepareStatement(query)) { + try (ResultSet rs = ps.executeQuery()) { + while (rs.next()) { + //Confio en que la base de datos mapeo correctamente el estado_resultado_id + @SuppressWarnings("OptionalGetWithoutIsPresent") + EstadoResultado estadoResultado= DAOManager.getEstadoResultadoDAO().getById(rs.getInt("estado_resultado_id")).get(); + //Confio en que la base de datos mapeo correctamente el tipo_detalle_id + @SuppressWarnings("OptionalGetWithoutIsPresent") + TipoDetalle tipoDetalle = DAOManager.getTipoDetalleDAO().getById(rs.getInt("tipo_detalle_id")).get(); + + Detalle detalle = new Detalle(); + detalle.setId(rs.getInt("id")); + detalle.setDescripcion(rs.getString("descripcion")); + detalle.setValor(rs.getInt("valor")); + detalle.setEstadoResultado(estadoResultado); + detalle.setTipoDetalle(tipoDetalle); + detalleList.add(detalle); + } + } + } + } catch (SQLException e) { + log.error("Error al intentar conseguir todos los Detalles de la base de datos", e); + } + log.debug("Se consiguieron " + detalleList.size() + " Detalles"); + return detalleList; + } + + @Override + public List getByTipoDetalle(TipoDetalle tipoDetalle) { + log.debug("Se intentaran conseguir los detalle pertenecientes al tipo detalle " + tipoDetalle); + List detalleList = new ArrayList<>(); + + if(tipoDetalle == TipoDetalle.EMPTY){ + log.debug("El tipo detalle entregado era EMPTY"); + return new ArrayList<>(); + } + + String query = "select * from detalles where tipo_detalle_id = ?"; + try (Connection conn = connectionHolder.getConnection()) { + try (PreparedStatement ps = conn.prepareStatement(query)){ + ps.setInt(1, tipoDetalle.getId()); + try(ResultSet rs = ps.executeQuery()){ + while(rs.next()){ + //Confio en que la base de datos mapeo correctamente el estado_resultado_id + @SuppressWarnings("OptionalGetWithoutIsPresent") + EstadoResultado estadoResultado= DAOManager.getEstadoResultadoDAO().getById(rs.getInt("estado_resultado_id")).get(); + + Detalle detalle = new Detalle(); + detalle.setId(rs.getInt("id")); + detalle.setDescripcion(rs.getString("descripcion")); + detalle.setValor(rs.getInt("valor")); + detalle.setEstadoResultado(estadoResultado); + detalle.setTipoDetalle(tipoDetalle); + } + } + } + }catch (SQLException e) { + log.error("Error al intentar conseguir los Detalles de la base de datos", e); + } + log.debug("Se consiguieron " + detalleList.size() + "Detalles"); + return detalleList; + } + + @Override + public Optional getById(int id) { + log.debug("Se intentaran conseguir el detalle con id " + id); + String query = "select * from detalles where id = ?"; + Detalle detalle = null; + try (Connection conn = connectionHolder.getConnection()) { + try (PreparedStatement ps = conn.prepareStatement(query)){ + ps.setInt(1, id); + try(ResultSet rs = ps.executeQuery()){ + while(rs.next()){ + //Confio en que la base de datos mapeo correctamente el estado_resultado_id + @SuppressWarnings("OptionalGetWithoutIsPresent") + EstadoResultado estadoResultado= DAOManager.getEstadoResultadoDAO().getById(rs.getInt("estado_resultado_id")).get(); + //Confio en que la base de datos mapeo correctamente el tipo_detalle_id + @SuppressWarnings("OptionalGetWithoutIsPresent") + TipoDetalle tipoDetalle = DAOManager.getTipoDetalleDAO().getById(rs.getInt("tipo_detalle_id")).get(); + + detalle = new Detalle(); + detalle.setId(id); + detalle.setDescripcion(rs.getString("descripcion")); + detalle.setValor(rs.getInt("valor")); + detalle.setEstadoResultado(estadoResultado); + detalle.setTipoDetalle(tipoDetalle); + } + } + } + }catch (SQLException e) { + log.error("Error al intentar conseguir el detalle con id " + id, e); + } + log.debug("Se consiguieron el detalle " + detalle); + return Optional.ofNullable(detalle); + } + + @Override + public Optional getByEstadoResultado(EstadoResultado estadoResultado) { + log.debug("Se intentaran conseguir el detalle del estado resultado " + estadoResultado); + + if(estadoResultado == estadoResultado.EMPTY){ + log.debug("El estado resultado entregado era empty"); + return Optional.empty(); + } + + String query = "select * from detalles where id = ?"; + Detalle detalle = null; + try (Connection conn = connectionHolder.getConnection()) { + try (PreparedStatement ps = conn.prepareStatement(query)){ + ps.setInt(1, estadoResultado.getId()); + try(ResultSet rs = ps.executeQuery()){ + while(rs.next()){ + //Confio en que la base de datos mapeo correctamente el tipo_detalle_id + @SuppressWarnings("OptionalGetWithoutIsPresent") + TipoDetalle tipoDetalle = DAOManager.getTipoDetalleDAO().getById(rs.getInt("tipo_detalle_id")).get(); + + detalle = new Detalle(); + detalle.setId(rs.getInt("id")); + detalle.setDescripcion(rs.getString("descripcion")); + detalle.setValor(rs.getInt("valor")); + detalle.setEstadoResultado(estadoResultado); + detalle.setTipoDetalle(tipoDetalle); + } + } + } + }catch (SQLException e) { + log.error("Error al intentar conseguir el detalle del estado resultado " + estadoResultado, e); + } + log.debug("Se consiguieron el detalle " + detalle); + return Optional.ofNullable(detalle); + } + + @Override + public void insert(Detalle detalle) { + log.debug("Se intentara insertar un nuevo detalle" + detalle); + String query = "insert into detalles (valor, descripcion, tipo_detalle_id, estado_resultado_id) values (?, ?, ?, ?)"; + try (Connection conn = connectionHolder.getConnection()) { + try (PreparedStatement ps = conn.prepareStatement(query)) { + ps.setInt(1, detalle.getValor()); + ps.setString(2, detalle.getDescripcion()); + ps.setInt(3, detalle.getTipoDetalle().getId()); + ps.setInt(4, detalle.getEstadoResultado().getId()); + ps.executeUpdate(); + } + + try (PreparedStatement ps = conn.prepareStatement("select last_insert_rowid()")) { + try (ResultSet rs = ps.executeQuery()) { + rs.next(); + detalle.setId(rs.getInt(1)); + } + } + + } catch (SQLException e) { + log.error("Error al intentar insertar el detalle " + detalle); + } + log.debug("Se inserto el detalle " + detalle); + } + + @Override + public void update(Detalle detalle) { + log.debug("Se intentara actualizar el detalle" + detalle); + String query = "update detalles set valor = ?, descripcion = ?, tipo_detalle_id = ?, estado_resultado_id = ? where id = ?"; + try (Connection conn = connectionHolder.getConnection()) { + try (PreparedStatement ps = conn.prepareStatement(query)) { + ps.setInt(1, detalle.getValor()); + ps.setString(2, detalle.getDescripcion()); + ps.setInt(3, detalle.getTipoDetalle().getId()); + ps.setInt(4, detalle.getEstadoResultado().getId()); + ps.setInt(4, detalle.getId()); + ps.executeUpdate(); + } + } catch (SQLException e) { + log.error("Error al actualizar el detalle " + detalle, e); + } + log.debug("Se actualizo el detalle " + detalle); + } + + @Override + public void delete(Detalle detalle) { + log.debug("Se intentara eliminar el detalle " + detalle); + String query = "delete from detalles where id = ?"; + try (Connection conn = connectionHolder.getConnection()) { + try (PreparedStatement ps = conn.prepareStatement(query)) { + ps.setInt(1, detalle.getId()); + ps.execute(); + } + } catch (SQLException e) { + log.error("Error al eliminar el detalle" + detalle, e); + } + log.debug("Se elimino el detalle " + detalle); + } +} diff --git a/src/danielcortes/xyz/models/documentos/SQLiteDocumentosDAO.java b/src/danielcortes/xyz/models/documentos/SQLiteDocumentosDAO.java index 7bc62a1..f04745e 100644 --- a/src/danielcortes/xyz/models/documentos/SQLiteDocumentosDAO.java +++ b/src/danielcortes/xyz/models/documentos/SQLiteDocumentosDAO.java @@ -82,6 +82,7 @@ public class SQLiteDocumentosDAO implements DocumentosDAO { } @Override + public Optional getById(int id) { log.debug("Se intentara conseguir el Documentos con id " + id); Documentos documentos = null; diff --git a/src/danielcortes/xyz/models/tipo_detalle/SQLiteTipoDetalleDAO.java b/src/danielcortes/xyz/models/tipo_detalle/SQLiteTipoDetalleDAO.java new file mode 100644 index 0000000..f2165cf --- /dev/null +++ b/src/danielcortes/xyz/models/tipo_detalle/SQLiteTipoDetalleDAO.java @@ -0,0 +1,95 @@ +package danielcortes.xyz.models.tipo_detalle; + +import danielcortes.xyz.data.ConnectionHolder; +import danielcortes.xyz.data.SQLiteConnectionHolder; +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; + +public class SQLiteTipoDetalleDAO implements TipoDetalleDAO{ + private static final Logger log = LogManager.getLogger(SQLiteTipoDetalleDAO.class); + private ConnectionHolder connectionHolder; + + public SQLiteTipoDetalleDAO() { + this.connectionHolder = new SQLiteConnectionHolder(); + } + + public SQLiteTipoDetalleDAO(ConnectionHolder connectionHolder) { + this.connectionHolder = connectionHolder; + } + + @Override + public List getAll() { + log.debug("Se intentara conseguir todos los tipoDetalle"); + List tipoDetalleList = new ArrayList<>(); + String query = "select * from tipos_detalle"; + try (Connection conn = connectionHolder.getConnection()) { + try (PreparedStatement ps = conn.prepareStatement(query)) { + try (ResultSet rs = ps.executeQuery()) { + while (rs.next()) { + TipoDetalle tipoDetalle = new TipoDetalle(); + tipoDetalle.setId(rs.getInt("id")); + tipoDetalle.setNombre(rs.getString("nombre")); + tipoDetalleList.add(tipoDetalle); + } + } + } + } catch (SQLException e) { + log.error("Error al intentar conseguir todos los tipoDetalle", e); + } + log.debug("Se consiguieron " + tipoDetalleList.size() + " tipoDetalle"); + return tipoDetalleList; + } + + @Override + public Optional getById(int id) { + log.debug("Se intentara conseguir un TipoDetalle con id " + id); + TipoDetalle tipoDetalle = null; + String query = "select * from tipos_detalle where id = ?"; + try (Connection conn = connectionHolder.getConnection()) { + try (PreparedStatement ps = conn.prepareStatement(query)) { + ps.setInt(1, id); + try (ResultSet rs = ps.executeQuery()) { + if (rs.next()) { + tipoDetalle = new TipoDetalle(); + tipoDetalle.setId(rs.getInt("id")); + tipoDetalle.setNombre(rs.getString("nombre")); + } + } + } + } catch (SQLException e) { + log.error("Error al intentar conseguir un TipoDetalle con id " + id, e); + } + log.debug("Se consiguio el tipoDetalle " + tipoDetalle); + return Optional.ofNullable(tipoDetalle); + } + + @Override + public Optional getByNombre(String nombre) { + log.debug("Se intentara conseguir un TipoDetalle con nombre" + nombre); + TipoDetalle tipoDetalle = null; + String query = "select * from tipos_detalle where nombre = ?"; + try (Connection conn = connectionHolder.getConnection()) { + try (PreparedStatement ps = conn.prepareStatement(query)) { + ps.setString(1, nombre); + try (ResultSet rs = ps.executeQuery()) { + if (rs.next()) { + tipoDetalle = new TipoDetalle(); + tipoDetalle.setId(rs.getInt("id")); + tipoDetalle.setNombre(rs.getString("nombre")); + } + } + } + } catch (SQLException e) { + log.error("Error al intentar conseguir un TipoDetalle con nombre " + nombre, e); + } + log.debug("Se consigio el TipoDetalle " + tipoDetalle); + return Optional.ofNullable(tipoDetalle); + } +} diff --git a/src/danielcortes/xyz/models/tipo_detalle/TipoDetalle.java b/src/danielcortes/xyz/models/tipo_detalle/TipoDetalle.java new file mode 100644 index 0000000..0be7ac5 --- /dev/null +++ b/src/danielcortes/xyz/models/tipo_detalle/TipoDetalle.java @@ -0,0 +1,56 @@ +package danielcortes.xyz.models.tipo_detalle; + +import java.util.Objects; + +public class TipoDetalle { + public static final TipoDetalle EMPTY; + + static{ + EMPTY = new TipoDetalle(); + } + + private int id; + private String nombre; + + public int getId() { + return id; + } + + public void setId(int id) { + this.id = id; + } + + public String getNombre() { + return nombre; + } + + public void setNombre(String nombre) { + this.nombre = nombre; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (!(o instanceof TipoDetalle)) { + return false; + } + TipoDetalle that = (TipoDetalle) o; + return id == that.id && + Objects.equals(nombre, that.nombre); + } + + @Override + public int hashCode() { + return Objects.hash(id, nombre); + } + + @Override + public String toString() { + return "TipoDetalle{" + + "id=" + id + + ", nombre='" + nombre + '\'' + + '}'; + } +} diff --git a/src/danielcortes/xyz/models/tipo_detalle/TipoDetalleDAO.java b/src/danielcortes/xyz/models/tipo_detalle/TipoDetalleDAO.java new file mode 100644 index 0000000..3e65e7e --- /dev/null +++ b/src/danielcortes/xyz/models/tipo_detalle/TipoDetalleDAO.java @@ -0,0 +1,28 @@ +package danielcortes.xyz.models.tipo_detalle; + +import java.util.List; +import java.util.Optional; + +public interface TipoDetalleDAO { + + /** + * Obtiene todos los tipo detalle + * + * @return Una lista con los tipo detalle obtenidos + */ + List getAll(); + + /** + * Obtiene un tipo detalle por su id + * @return Dado que no puede que no exista se devuelve un Optional que puede contener el tipo + * detalle o puede estar vacio + */ + Optional getById(int id); + + /** + * Obtiene un tipo detalle por su nombre + * @return Dado que no puede que no exista se devuelve un Optional que puede contener el tipo + * detalle o puede estar vacio + */ + Optional getByNombre(String nombre); +} diff --git a/test/danielcortes/xyz/models/detalle/SQLiteDetalleDAOTest.java b/test/danielcortes/xyz/models/detalle/SQLiteDetalleDAOTest.java new file mode 100644 index 0000000..52bee6b --- /dev/null +++ b/test/danielcortes/xyz/models/detalle/SQLiteDetalleDAOTest.java @@ -0,0 +1,147 @@ +/* + * Copyright (c) 2019 Daniel Antonio Cortés Pincheira. All rights reserved + */ + +package danielcortes.xyz.models.detalle; + +import static org.assertj.core.api.Assertions.assertThat; + +import com.github.javafaker.Faker; +import danielcortes.xyz.data.ConnectionHolder; +import danielcortes.xyz.data.DAOManager; +import danielcortes.xyz.data.SQLiteConnectionHolder; +import danielcortes.xyz.models.estado_resultado.EstadoResultado; +import danielcortes.xyz.models.estado_resultado.EstadoResultadoDAO; +import danielcortes.xyz.models.tipo_detalle.TipoDetalle; +import danielcortes.xyz.models.tipo_detalle.TipoDetalleDAO; +import danielcortes.xyz.models.version.SQLiteVersionDAO; +import danielcortes.xyz.models.version.VersionDAO; +import danielcortes.xyz.utils.RandomLocalDate; +import java.io.File; +import java.time.YearMonth; +import java.util.ArrayList; +import java.util.List; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +class SQLiteDetalleDAOTest { + private static final int databaseVersion = 3; + + private static Faker faker; + private static VersionDAO versionDAO; + private DetalleDAO detalleDAO; + private EstadoResultadoDAO estadoResultadoDAO; + private TipoDetalleDAO tipoDetalleDAO; + + + @BeforeAll + static void setAll() { + ConnectionHolder connectionHolder = new SQLiteConnectionHolder("jdbc:sqlite:/tmp/tmp.sqlite"); + DAOManager.setup(connectionHolder); + versionDAO = new SQLiteVersionDAO(connectionHolder); + faker = new Faker(); + } + + @BeforeEach + void setUp() { + versionDAO.updateTo(databaseVersion); + this.tipoDetalleDAO = DAOManager.getTipoDetalleDAO(); + this.estadoResultadoDAO = DAOManager.getEstadoResultadoDAO(); + this.detalleDAO = DAOManager.getDetalleDAO(); + } + + @AfterEach + void tearDown() { + //noinspection ResultOfMethodCallIgnored + new File("/tmp/tmp.sqlite").delete(); + } + + @ParameterizedTest + @ValueSource(ints={1, 5, 10}) + void getAll(int size) { + //La base de datos al crearse genera un tipoDetalle con id 1 entre otros + @SuppressWarnings("OptionalGetWithoutIsPresent") + TipoDetalle tipoDetalle = this.tipoDetalleDAO.getById(1).get(); + + List e = new ArrayList<>(size); + for(int i = 0; i < size; i++){ + EstadoResultado estadoResultado = giveEstadoResultado(); + + this.estadoResultadoDAO.insert(estadoResultado); + e.add(estadoResultado); + } + + List d1 = new ArrayList<>(size); + for(EstadoResultado estadoResultado: e){ + Detalle detalle = giveDetalle(tipoDetalle, estadoResultado); + this.detalleDAO.insert(detalle); + d1.add(detalle); + } + + List d2 = this.detalleDAO.getAll(); + assertThat(d2) + .hasSize(size) + .containsAll(d1); + } + + @Test + void getByTipoDetalle() { + } + + @Test + void getById() { + } + + @Test + void getByEstadoResultado() { + } + + @Test + void insert() { + } + + @Test + void update() { + } + + @Test + void delete() { + } + + Detalle giveDetalle(TipoDetalle tipoDetalle, EstadoResultado estadoResultado) { + Detalle detalle = new Detalle(); + detalle.setValor(faker.number().numberBetween(0, 10000000)); + detalle.setDescripcion(faker.lorem().sentence()); + detalle.setTipoDetalle(tipoDetalle); + detalle.setEstadoResultado(estadoResultado); + + return detalle; + } + + EstadoResultado giveEstadoResultado() { + EstadoResultado estadoResultado = new EstadoResultado(); + estadoResultado.setMes(YearMonth.from(RandomLocalDate.random())); + estadoResultado.setCostoVenta(faker.number().numberBetween(0, 10000000)); + estadoResultado.setCuentaCorrienteFactura(faker.number().numberBetween(0, 10000000)); + estadoResultado.setCuentaCorrienteBoleta(faker.number().numberBetween(0, 10000000)); + estadoResultado.setCuentaCorrienteSinRespaldo(faker.number().numberBetween(0, 10000000)); + estadoResultado.setRemuneraciones(faker.number().numberBetween(0, 10000000)); + estadoResultado.setFiniquitos(faker.number().numberBetween(0, 10000000)); + estadoResultado.setAguinaldo(faker.number().numberBetween(0, 10000000) ); + estadoResultado.setBonosPersonal(faker.number().numberBetween(0, 10000000)); + estadoResultado.setHonorariosContador(faker.number().numberBetween(0, 10000000)); + estadoResultado.setArriendo(faker.number().numberBetween(0, 10000000)); + estadoResultado.setAgua(faker.number().numberBetween(0, 10000000)); + estadoResultado.setLuz(faker.number().numberBetween(0, 10000000)); + estadoResultado.setGas(faker.number().numberBetween(0, 10000000)); + estadoResultado.setTelefono(faker.number().numberBetween(0, 10000000)); + estadoResultado.setOtroServicio(faker.number().numberBetween(0, 10000000)); + estadoResultado.setPpm(faker.number().randomDouble(2,0,100)); + estadoResultado.setIvaFavor(faker.number().numberBetween(0, 10000000)); + return estadoResultado; + } +} \ No newline at end of file