Se agrego el miodelo de detalle

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;

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();

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;
   }

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 +
+        '}';
+  }
+}

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<Detalle> getAll();
+  List<Detalle> getByTipoDetalle(TipoDetalle tipoDetalle);
+  Optional<Detalle> getById(int id);
+  Optional<Detalle> getByEstadoResultado(EstadoResultado estadoResultado);
+
+  void insert(Detalle detalle);
+  void update(Detalle detalle);
+  void delete(Detalle detalle);
+}

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<Detalle> getAll() {
+    log.debug("Se intentaran conseguir todos los Detalle");
+    List<Detalle> 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<Detalle> getByTipoDetalle(TipoDetalle tipoDetalle) {
+    log.debug("Se intentaran conseguir los detalle pertenecientes al tipo detalle " + tipoDetalle);
+    List<Detalle> 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<Detalle> 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<Detalle> 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);
+  }
+}

src/danielcortes/xyz/models/documentos/SQLiteDocumentosDAO.java

@@ -82,6 +82,7 @@ public class SQLiteDocumentosDAO implements DocumentosDAO {
   }
 
   @Override
+
   public Optional<Documentos> getById(int id) {
     log.debug("Se intentara conseguir el Documentos con id " + id);
     Documentos documentos = null;

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<TipoDetalle> getAll() {
+    log.debug("Se intentara conseguir todos los tipoDetalle");
+    List<TipoDetalle> 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<TipoDetalle> 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<TipoDetalle> 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);
+  }
+}

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 + '\'' +
+        '}';
+  }
+}

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<TipoDetalle> 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<TipoDetalle> 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<TipoDetalle> getByNombre(String nombre);
+}

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<EstadoResultado> e = new ArrayList<>(size);
+    for(int i = 0; i < size; i++){
+      EstadoResultado estadoResultado = giveEstadoResultado();
+
+      this.estadoResultadoDAO.insert(estadoResultado);
+      e.add(estadoResultado);
+    }
+
+    List<Detalle> d1 = new ArrayList<>(size);
+    for(EstadoResultado estadoResultado: e){
+      Detalle detalle = giveDetalle(tipoDetalle, estadoResultado);
+      this.detalleDAO.insert(detalle);
+      d1.add(detalle);
+    }
+
+    List<Detalle> 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;
+  }
+}