co.com.codesoftware.logica.inventario.ConteoLogica.java Source code

Java tutorial

Introduction

Here is the source code for co.com.codesoftware.logica.inventario.ConteoLogica.java

Source

/*
 * 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();
        }
    }

}