Java tutorial
/* * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools | Templates * and open the template in the editor. */ package co.com.codesoftware.logica.inventario; import co.com.codesoftware.persistencia.entidad.inventario.ProductoConteoEntity; import co.com.codesoftware.persistencia.HibernateUtil; import co.com.codesoftware.persistencia.ReadFunction; import co.com.codesoftware.persistencia.entidad.inventario.ConteoEntity; import co.com.codesoftware.persistencia.entidad.inventario.ProductoEntity; import co.com.codesoftware.persistencia.utilities.DataType; import co.com.codesoftware.persistencia.utilities.RespuestaEntity; import java.util.ArrayList; import java.util.Date; import java.util.List; import org.hibernate.Criteria; import org.hibernate.FetchMode; import org.hibernate.HibernateException; import org.hibernate.Query; import org.hibernate.Session; import org.hibernate.Transaction; import org.hibernate.criterion.Order; import org.hibernate.criterion.Projections; import org.hibernate.criterion.Restrictions; /** * * @author nicolas */ public class ConteoLogica implements AutoCloseable { private Session sesion; private Transaction tx; private String llamadoFunction; private String idFactura; private String mensaje; /** * Funcion con la cual inserto un conteo * @param codigoConteo * @param codigoProducto * @param cantidad * @param codigoBarras * @param ubicacion * @return */ public RespuestaEntity insProdConteo(Integer codigoConteo, String codigoProducto, Integer cantidad, String codigoBarras, String ubicacion) { RespuestaEntity res = new RespuestaEntity(); try { String descripcion = this.llamaFuncionConteo(codigoConteo, codigoProducto, cantidad, codigoBarras, ubicacion); res.setCodigoRespuesta(0); res.setDescripcionRespuesta(descripcion); res.setMensajeRespuesta(descripcion); } catch (Exception e) { e.printStackTrace(); res.setCodigoRespuesta(0); res.setDescripcionRespuesta(e.getMessage()); res.setMensajeRespuesta(e.toString()); } return res; } /** * * @param codigoConteo * @param codigoProducto * @param cantidad * @param codigoBarras * @return */ public RespuestaEntity insertaProdConteo(Integer codigoConteo, String codigoProducto, Integer cantidad, String codigoBarras) { RespuestaEntity rta = null; try { initOperation(); if (codigoBarras != null && !"".equals(codigoBarras)) { rta = consultaExistenciaCodigoBarras(codigoProducto, codigoBarras, codigoConteo, cantidad); } else { rta = consultaExistenciaProductoCodExt(codigoProducto, codigoConteo, cantidad); } } catch (Exception e) { e.printStackTrace(); } return rta; } public RespuestaEntity consultaExistenciaCodigoBarras(String codigoProd, String codigoBarras, Integer codigoConteo, Integer cantidad) { RespuestaEntity res = null; try { ProductoEntity result = (ProductoEntity) sesion.createCriteria(ProductoEntity.class) .add(Restrictions.eq("codigoBarras", codigoBarras)).uniqueResult(); //si el producto existe ya con codigo de barras if (result != null) { //Se verifica si el producto existe en el conteo ProductoConteoEntity prdConteo = consultaExistenciaProducto(codigoBarras, codigoConteo, cantidad); } else { if (actualizaCodigoBarras(codigoBarras, codigoProd)) { ProductoConteoEntity prdConteo = consultaExistenciaProducto(codigoBarras, codigoConteo, cantidad); } } } catch (Exception e) { e.printStackTrace(); } return res; } public boolean actualizaCodigoBarras(String codigoBarras, String codigoExterno) { try { ProductoEntity produc = (ProductoEntity) sesion.createCriteria(ProductoEntity.class) .add(Restrictions.eq("codigoExt", codigoExterno)).uniqueResult(); produc.setCodigoBarras(codigoBarras); sesion.update(produc); //tx.commit(); return true; } catch (Exception e) { e.printStackTrace(); return false; } } /** * * @param codigo * @return */ public ProductoConteoEntity consultaExistenciaProducto(String codigoBarras, Integer codigoConteo, Integer cantidad) { ProductoConteoEntity respuesta = new ProductoConteoEntity(); try { ProductoConteoEntity prod = (ProductoConteoEntity) sesion.createCriteria(ProductoConteoEntity.class) .createAlias("conteo", "con").createAlias("producto", "prd") .add(Restrictions.eq("con.id", codigoConteo)) .add(Restrictions.eq("prd.codigoBarras", codigoBarras)).uniqueResult(); if (prod != null) { prod.setCantidad(prod.getCantidad() + cantidad); sesion.update(prod); //tx.commit(); } else { ProductoEntity producto = (ProductoEntity) sesion.createCriteria(ProductoEntity.class) .add(Restrictions.eq("codigoBarras", codigoBarras)).uniqueResult(); ConteoEntity conteo = (ConteoEntity) sesion.createCriteria(ConteoEntity.class) .add(Restrictions.eq("id", codigoConteo)).uniqueResult(); prod = new ProductoConteoEntity(); prod.setCantidad(cantidad); prod.setId(selectMaxProductoConteo()); prod.setProducto(producto); prod.setConteo(conteo); sesion.save(prod); //tx.commit(); } } catch (Exception e) { e.printStackTrace(); } return respuesta; } public RespuestaEntity consultaExistenciaProductoCodExt(String codigoExt, Integer codigoConteo, Integer cantidad) { RespuestaEntity respuesta = new RespuestaEntity(); try { ProductoConteoEntity prod = (ProductoConteoEntity) sesion.createCriteria(ProductoConteoEntity.class) .createAlias("conteo", "con").createAlias("producto", "prd") .add(Restrictions.eq("con.id", codigoConteo)).add(Restrictions.eq("prd.codigoExt", codigoExt)) .uniqueResult(); if (prod != null) { prod.setCantidad(prod.getCantidad() + cantidad); sesion.update(prod); //tx.commit(); } else { ProductoEntity producto = (ProductoEntity) sesion.createCriteria(ProductoEntity.class) .add(Restrictions.eq("codigoExt", codigoExt)).uniqueResult(); ConteoEntity conteo = (ConteoEntity) sesion.createCriteria(ConteoEntity.class) .add(Restrictions.eq("id", codigoConteo)).uniqueResult(); prod = new ProductoConteoEntity(); prod.setCantidad(cantidad); prod.setId(selectMaxProductoConteo()); prod.setProducto(producto); prod.setConteo(conteo); sesion.save(prod); //tx.commit(); } } catch (Exception e) { e.printStackTrace(); } return respuesta; } public String validaEstadoConteo() { String estado = ""; try { this.initOperation(); Query query = sesion.createQuery("select c.estado from ConteoEntity c where "); } catch (Exception e) { e.printStackTrace(); return null; } return estado; } /** * Funcion con la cual obtengo el numero maximo del producto conteo para la * insercion de la misma * * @return */ public Integer selectMaxProductoConteo() { Integer resultado = 1; try { Criteria crit = sesion.createCriteria(ProductoConteoEntity.class).setProjection(Projections.max("id")); resultado = (Integer) crit.uniqueResult() + 1; } catch (Exception e) { resultado = 1; e.printStackTrace(); } return resultado; } /** * metodo el cual consulta un grupo de conteos por estado * * @param estado * @return */ public List<ConteoEntity> consultaConteosEstado(String estado) { initOperation(); if (estado == null || "".equalsIgnoreCase(estado)) { estado = "A"; } List<ConteoEntity> respuesta = null; try { Criteria crit = sesion.createCriteria(ConteoEntity.class); if (!"-1".equalsIgnoreCase(estado)) { crit.add(Restrictions.eq("estado", estado)); } crit.addOrder(Order.desc("id")); respuesta = crit.list(); } catch (Exception e) { e.printStackTrace(); } return respuesta; } /** * Funcion que llama el procedimiento almacenado pra el conteo * * @param codigoConteo * @param codigoProducto * @param cantidad * @param codigoBarras * @param ubicacion * @return */ public String llamaFuncionConteo(Integer codigoConteo, String codigoProducto, Integer cantidad, String codigoBarras, String ubicacion) { String rta = ""; List<String> response = new ArrayList<>(); try (ReadFunction rf = new ReadFunction()) { rf.setNombreFuncion("IN_VALIDACONTEO"); rf.setNumParam(6); rf.addParametro("" + codigoProducto, DataType.TEXT); rf.addParametro("" + cantidad, DataType.INT); rf.addParametro("" + codigoBarras, DataType.TEXT); rf.addParametro("" + ubicacion, DataType.TEXT); rf.addParametro("0", DataType.TEXT); rf.addParametro("" + codigoConteo, DataType.INT); rf.callFunctionJdbc(); response = rf.getRespuestaPg(); String respuesta = response.get(0); if (respuesta.indexOf("Error") >= 0) { respuesta = respuesta.replaceAll("Error", ""); rta = respuesta; llamadoFunction = "error"; } else { llamadoFunction = respuesta; rta = respuesta; } } catch (Exception e) { llamadoFunction = "error"; rta = e.toString(); e.printStackTrace(); } return rta; } /** * Funcion con la cual cierro un conteo en el sistema * @param conteo * @return */ public String cierraConteo(Integer conteo) { String rta = ""; List<String> response = new ArrayList<>(); try (ReadFunction rf = new ReadFunction()) { rf.setNombreFuncion("IN_CIERRA_CONTEO"); rf.setNumParam(1); rf.adicionarParametro(conteo, DataType.INT); boolean valida = rf.llamarFuncion(); if (valida) { } else { } } catch (Exception e) { llamadoFunction = "error"; rta = e.toString(); e.printStackTrace(); } return rta; } /** * Funcion que consulta un producto especifico del conteo * * @param conteo * @param codigoExterno * @return */ public ProductoConteoEntity consultaProductoConteo(Integer conteo, String codigoExterno) { ProductoConteoEntity rta = null; try { initOperation(); Criteria crit = sesion.createCriteria(ProductoConteoEntity.class).createAlias("conteo", "con") .createAlias("producto", "prd").add(Restrictions.eq("con.id", conteo)) .add(Restrictions.eq("prd.codigoExt", codigoExterno)); crit.setFetchMode("conteo", FetchMode.JOIN); crit.setFetchMode("producto", FetchMode.JOIN); crit.setFetchMode("producto.referencia", FetchMode.JOIN); crit.setFetchMode("producto.marca", FetchMode.JOIN); crit.setFetchMode("producto.categoria", FetchMode.JOIN); crit.setFetchMode("producto.subcuenta", FetchMode.JOIN); rta = (ProductoConteoEntity) crit.uniqueResult(); } catch (Exception e) { e.printStackTrace(); } return rta; } /** * metodo que consulta todos los productos de un conteo * * @param conteo * @return */ public List<ProductoConteoEntity> consultaProductosConteo(Integer conteo) { List<ProductoConteoEntity> rta = null; try { this.initOperation(); Criteria crit = sesion.createCriteria(ProductoConteoEntity.class); crit.createAlias("conteo", "con"); crit.createAlias("producto", "prod"); crit.add(Restrictions.eq("con.id", conteo)); crit.setFetchMode("conteo", FetchMode.JOIN); crit.setFetchMode("producto", FetchMode.JOIN); crit.setFetchMode("producto.referencia", FetchMode.JOIN); crit.setFetchMode("producto.marca", FetchMode.JOIN); crit.setFetchMode("producto.categoria", FetchMode.JOIN); crit.setFetchMode("producto.subcuenta", FetchMode.JOIN); crit.addOrder(Order.desc("id")); rta = crit.list(); } catch (Exception e) { e.printStackTrace(); } return rta; } /** * Funcion con la cual inserto un conteo * * @param conteoEntity * @return */ public String insertaConteo(ConteoEntity conteoEntity) { String rta = ""; try { this.initOperation(); Integer id = selectMaxConteo(); conteoEntity.setId(id); conteoEntity.setEstado("A"); conteoEntity.setFecha(new Date()); sesion.save(conteoEntity); rta = "Ok"; } catch (Exception e) { e.printStackTrace(); } return rta; } /** * Funcion con la cual obtengo un conteo por medio de us id * @param idConteo * @return */ public ConteoEntity obtenerConteoXId(Integer idConteo) { ConteoEntity conteo = null; try { this.initOperation(); Criteria crit = this.sesion.createCriteria(ConteoEntity.class); crit.add(Restrictions.eq("id", idConteo)); conteo = (ConteoEntity) crit.uniqueResult(); } catch (Exception e) { e.printStackTrace(); } return conteo; } /** * Funcion con la cual obtengo el max de un conteo * @return */ public Integer selectMaxConteo() { Integer resultado = 1; try { Criteria crit = sesion.createCriteria(ConteoEntity.class).setProjection(Projections.max("id")); resultado = (Integer) crit.uniqueResult() + 1; } catch (Exception e) { resultado = 1; e.printStackTrace(); } return resultado; } private void initOperation() throws HibernateException { sesion = HibernateUtil.getSessionFactory().openSession(); tx = sesion.beginTransaction(); } @Override public void close() throws Exception { if (tx != null) { tx.commit(); } if (sesion != null) { sesion.close(); } } }