Example usage for org.hibernate Query setDate

List of usage examples for org.hibernate Query setDate

  1. HOME
  2. Java
  3. org.hibernate
  4. org.hibernate.*
  5. Query
  6. setDate

Introduction

In this page you can find the example usage for org.hibernate Query setDate.

Prototype

@Deprecated
@SuppressWarnings("unchecked")
default Query<R> setDate(String name, Date val)

Source Link

Document

Bind the val (time is truncated) of a given Date object to a named query parameter.

Usage

From source file:mx.edu.um.mateo.activos.dao.impl.ActivoDaoHibernate.java

License:Open Source License

@Override
@SuppressWarnings("unchecked")
@Transactional(readOnly = true)/*from   www .  jav  a  2 s  . co  m*/
public Map<String, Object> depreciacionAcumuladaPorCentroDeCosto(Map<String, Object> params) {
    Usuario usuario = (Usuario) params.get("usuario");
    Query tiposDeActivoQuery = currentSession().createQuery(
            "select new map(ta.nombre as nombre, ta.cuenta.id.idCtaMayor as cuenta, ta.id as id) from TipoActivo ta where ta.cuenta.id.ejercicio.id.idEjercicio = :ejercicioId and ta.cuenta.id.ejercicio.id.organizacion.id = :organizacionId order by ta.cuenta.id.idCtaMayor");
    tiposDeActivoQuery.setString("ejercicioId", usuario.getEjercicio().getId().getIdEjercicio());
    tiposDeActivoQuery.setLong("organizacionId", usuario.getEjercicio().getId().getOrganizacion().getId());
    List<Map<String, Object>> tiposDeActivo = tiposDeActivoQuery.list();
    Map<String, Map<String, Object>> tiposDeActivoMap = new HashMap<>();
    for (Map<String, Object> tipoActivo : tiposDeActivo) {
        tipoActivo.put("total", BigDecimal.ZERO);
        tiposDeActivoMap.put((String) tipoActivo.get("cuenta"), tipoActivo);
    }
    Map<String, Object> totalCC = new HashMap<>();
    totalCC.put("nombre", "");
    totalCC.put("cuenta", "TOTAL");
    totalCC.put("id", 0);
    totalCC.put("total", BigDecimal.ZERO);
    tiposDeActivo.add(totalCC);
    tiposDeActivoMap.put("TOTAL", totalCC);
    params.put("tiposDeActivo", tiposDeActivo);

    Date fecha = (Date) params.get("fecha");

    MathContext mc = new MathContext(16, RoundingMode.HALF_UP);
    Map<String, Map<String, Object>> mapa1 = new TreeMap<>();
    Query query = currentSession().createQuery(
            "select new Activo(a.id, a.version, a.moi, a.fechaCompra, a.tipoActivo.porciento, a.tipoActivo.vidaUtil, a.inactivo, a.fechaInactivo, a.fechaReubicado, a.tipoActivo.cuenta.id.idCtaMayor, a.centroCosto.id.idCosto, a.centroCosto.nombre) from Activo a inner join a.tipoActivo where a.empresa.id = :empresaId and a.fechaCompra <= :fecha and a.fechaReubicado is null");
    query.setLong("empresaId", usuario.getEmpresa().getId());
    query.setDate("fecha", fecha);
    List<Activo> activos = query.list();
    for (Activo activo : activos) {
        log.trace("Depreciando activo {}", activo.getId());
        activo = this.deprecia(activo, fecha);

        this.depreciacionAcumuladaPorCentroDeCosto(activo, mc, mapa1, tiposDeActivo, tiposDeActivoMap);
    }

    // Busca activos reubicados
    query = currentSession().createQuery(
            "select new Activo(a.id, a.version, a.moi, a.fechaCompra, a.tipoActivo.porciento, a.tipoActivo.vidaUtil, a.inactivo, a.fechaInactivo, a.fechaReubicado, a.tipoActivo.cuenta.id.idCtaMayor, a.centroCosto.id.idCosto, a.centroCosto.nombre) from Activo a inner join a.tipoActivo where a.empresa.id = :empresaId and a.fechaCompra <= :fecha and a.fechaReubicado != null");
    query.setLong("empresaId", usuario.getEmpresa().getId());
    query.setDate("fecha", fecha);
    activos = query.list();
    for (Activo activo : activos) {
        query = currentSession().createQuery(
                "select r from ReubicacionActivo r where r.activo.id = :activoId order by r.fecha");
        query.setLong("activoId", activo.getId());
        List<ReubicacionActivo> reubicaciones = query.list();
        Date fechaAnterior = null;
        boolean bandera1 = true;
        for (ReubicacionActivo reubicacion : reubicaciones) {
            if (reubicacion.getFecha().before(fecha)) {
                activo.setCentroCosto(reubicacion.getCentroCostoAnterior());
                if (fechaAnterior != null) {
                    activo.setFechaCompra(fechaAnterior);
                }
                this.deprecia(activo, reubicacion.getFecha());
                fechaAnterior = reubicacion.getFecha();
            } else {
                if (fechaAnterior != null) {
                    activo.setFechaCompra(fechaAnterior);
                }
                activo.setCentroCosto(reubicacion.getCentroCostoAnterior());
                this.deprecia(activo, fecha);
                bandera1 = false;
            }

            this.depreciacionAcumuladaPorCentroDeCosto(activo, mc, mapa1, tiposDeActivo, tiposDeActivoMap);
        }

        if (bandera1) {
            activo.setFechaCompra(activo.getFechaReubicado());
            this.deprecia(activo, fecha);
            this.depreciacionAcumuladaPorCentroDeCosto(activo, mc, mapa1, tiposDeActivo, tiposDeActivoMap);
        }
    }

    if (log.isTraceEnabled()) {
        for (Map<String, Object> centroCosto : mapa1.values()) {
            log.trace("CentroCosto: {} : {}", centroCosto.get("nombre"), centroCosto.get("totales"));
        }
    }

    params.put("centrosDeCosto", mapa1.values());
    return params;
}

From source file:mx.edu.um.mateo.activos.dao.impl.ActivoDaoHibernate.java

License:Open Source License

@Override
@SuppressWarnings("unchecked")
@Transactional(readOnly = true)/*from   ww w .  j av a 2 s .c  om*/
public Map<String, Object> depreciacionAcumuladaPorCentroDeCostoDetalle(Map<String, Object> params) {
    MathContext mc = new MathContext(16, RoundingMode.HALF_UP);
    Map<String, BigDecimal> totales = new HashMap<>();
    totales.put("ACUMULADA", BigDecimal.ZERO);
    totales.put("MENSUAL", BigDecimal.ZERO);
    totales.put("ANUAL", BigDecimal.ZERO);
    totales.put("NETO", BigDecimal.ZERO);
    Usuario usuario = (Usuario) params.get("usuario");
    String centroCostoId = (String) params.get("centroCostoId");
    Date fecha = (Date) params.get("fecha");
    CCostoPK ccostoPK = new CCostoPK(usuario.getEjercicio(), centroCostoId);
    CentroCosto centroCosto = (CentroCosto) currentSession().get(CentroCosto.class, ccostoPK);
    params.put("centroCosto", centroCosto);
    Criteria criteria = currentSession().createCriteria(Activo.class);
    criteria.add(Restrictions.eq("empresa.id", usuario.getEmpresa().getId()));
    criteria.add(Restrictions.eq("centroCosto.id.ejercicio.id.idEjercicio",
            usuario.getEjercicio().getId().getIdEjercicio()));
    criteria.add(Restrictions.eq("centroCosto.id.ejercicio.id.organizacion.id",
            usuario.getEjercicio().getId().getOrganizacion().getId()));
    criteria.add(Restrictions.eq("centroCosto.id.idCosto", centroCostoId));
    criteria.add(Restrictions.le("fechaCompra", fecha));
    criteria.add(Restrictions.isNull("fechaReubicado"));
    List<Activo> activos = criteria.list();
    for (Activo activo : activos) {
        log.trace("Depreciando activo {}", activo.getId());
        activo = this.deprecia(activo, fecha);

        this.depreciacionAcumuladaPorCentroDeCostoDetalle(activo, mc, totales);
    }

    // busca reubicados
    Query query = currentSession().createQuery(
            "select a from ReubicacionActivo ra inner join ra.activo a where ra.empresa.id = :empresaId and (ra.centroCosto.id.idCosto = :centroCostoId or ra.centroCostoAnterior.id.idCosto = :centroCostoId) and a.fechaCompra < :fecha group by a");
    query.setLong("empresaId", usuario.getEmpresa().getId());
    query.setString("centroCostoId", centroCostoId);
    query.setDate("fecha", fecha);
    List<Activo> reubicados = query.list();
    for (Activo activo : reubicados) {
        log.trace("Depreciando reubicado {}", activo.getId());
        query = currentSession().createQuery(
                "select r from ReubicacionActivo r where r.activo.id = :activoId order by r.fecha");
        query.setLong("activoId", activo.getId());
        List<ReubicacionActivo> reubicaciones = query.list();
        Date fechaAnterior = null;
        boolean bandera1 = true;
        for (ReubicacionActivo reubicacion : reubicaciones) {
            boolean seDeprecio = false;
            if (reubicacion.getFecha().before(fecha)
                    && reubicacion.getCentroCostoAnterior().getId().getIdCosto().equals(centroCostoId)) {
                if (fechaAnterior != null) {
                    activo.setFechaCompra(fechaAnterior);
                }
                activo.setCentroCosto(reubicacion.getCentroCostoAnterior());
                this.deprecia(activo, reubicacion.getFecha());
                activos.add(activo);
                seDeprecio = true;
            } else if (reubicacion.getCentroCostoAnterior().getId().getIdCosto().equals(centroCostoId)) {
                if (fechaAnterior != null) {
                    activo.setFechaCompra(fechaAnterior);
                }
                activo.setCentroCosto(reubicacion.getCentroCostoAnterior());
                this.deprecia(activo, fecha);
                activos.add(activo);
                seDeprecio = true;
                bandera1 = false;
            } else {
                activo.setCentroCosto(reubicacion.getCentroCostoAnterior());
            }
            fechaAnterior = reubicacion.getFecha();

            if (seDeprecio) {
                this.depreciacionAcumuladaPorCentroDeCostoDetalle(activo, mc, totales);
            }
        }

        if (bandera1 && activo.getCentroCosto().getId().getIdCosto().equals(centroCostoId)) {
            activo.setFechaCompra(activo.getFechaReubicado());
            this.deprecia(activo, fecha);
            activos.add(activo);
            this.depreciacionAcumuladaPorCentroDeCostoDetalle(activo, mc, totales);
        }

    }
    params.put("activos", activos);
    params.put("totales", totales);
    return params;
}

From source file:mx.edu.um.mateo.activos.dao.impl.ActivoDaoHibernate.java

License:Open Source License

@Override
@SuppressWarnings("unchecked")
@Transactional(readOnly = true)//from www .  jav a  2 s.co m
public Map<String, Object> depreciacionMensualPorCentroDeCosto(Map<String, Object> params) {
    Usuario usuario = (Usuario) params.get("usuario");
    Query tiposDeActivoQuery = currentSession().createQuery(
            "select new map(ta.nombre as nombre, ta.cuenta.id.idCtaMayor as cuenta, ta.id as id) from TipoActivo ta where ta.cuenta.id.ejercicio.id.idEjercicio = :ejercicioId and ta.cuenta.id.ejercicio.id.organizacion.id = :organizacionId order by ta.cuenta.id.idCtaMayor");
    tiposDeActivoQuery.setString("ejercicioId", usuario.getEjercicio().getId().getIdEjercicio());
    tiposDeActivoQuery.setLong("organizacionId", usuario.getEjercicio().getId().getOrganizacion().getId());
    List<Map<String, Object>> tiposDeActivo = tiposDeActivoQuery.list();
    Map<String, Map<String, Object>> tiposDeActivoMap = new HashMap<>();
    for (Map<String, Object> tipoActivo : tiposDeActivo) {
        tipoActivo.put("total", BigDecimal.ZERO);
        tiposDeActivoMap.put((String) tipoActivo.get("cuenta"), tipoActivo);
    }
    Map<String, Object> totalCC = new HashMap<>();
    totalCC.put("nombre", "");
    totalCC.put("cuenta", "TOTAL");
    totalCC.put("id", 0);
    totalCC.put("total", BigDecimal.ZERO);
    tiposDeActivo.add(totalCC);
    tiposDeActivoMap.put("TOTAL", totalCC);
    params.put("tiposDeActivo", tiposDeActivo);

    Date fecha = (Date) params.get("fecha");

    MathContext mc = new MathContext(16, RoundingMode.HALF_UP);
    Map<String, Map<String, Object>> mapa1 = new TreeMap<>();
    Query query = currentSession().createQuery(
            "select new Activo(a.id, a.version, a.moi, a.fechaCompra, a.tipoActivo.porciento, a.tipoActivo.vidaUtil, a.inactivo, a.fechaInactivo, a.fechaReubicado, a.tipoActivo.cuenta.id.idCtaMayor, a.centroCosto.id.idCosto, a.centroCosto.nombre) from Activo a inner join a.tipoActivo where a.empresa.id = :empresaId and a.fechaCompra <= :fecha and a.fechaReubicado is null");
    query.setLong("empresaId", usuario.getEmpresa().getId());
    query.setDate("fecha", fecha);
    List<Activo> activos = query.list();
    for (Activo activo : activos) {
        log.trace("Depreciando activo {}", activo.getId());
        activo = this.deprecia(activo, fecha);

        this.depreciacionMensualPorCentroDeCosto(activo, mc, mapa1, tiposDeActivo, tiposDeActivoMap);
    }

    // busca reubicados
    query = currentSession().createQuery(
            "select new Activo(a.id, a.version, a.moi, a.fechaCompra, a.tipoActivo.porciento, a.tipoActivo.vidaUtil, a.inactivo, a.fechaInactivo, a.fechaReubicado, a.tipoActivo.cuenta.id.idCtaMayor, a.centroCosto.id.idCosto, a.centroCosto.nombre) from Activo a inner join a.tipoActivo where a.empresa.id = :empresaId and a.fechaCompra <= :fecha and a.fechaReubicado != null");
    query.setLong("empresaId", usuario.getEmpresa().getId());
    query.setDate("fecha", fecha);
    activos = query.list();
    for (Activo activo : activos) {
        log.trace("Depreciando activo {}", activo.getId());
        query = currentSession().createQuery(
                "select r from ReubicacionActivo r where r.activo.id = :activoId order by r.fecha");
        query.setLong("activoId", activo.getId());
        List<ReubicacionActivo> reubicaciones = query.list();
        Date fechaAnterior = null;
        boolean bandera1 = true;
        for (ReubicacionActivo reubicacion : reubicaciones) {
            if (reubicacion.getFecha().before(fecha)) {
                activo.setCentroCosto(reubicacion.getCentroCostoAnterior());
                if (fechaAnterior != null) {
                    activo.setFechaCompra(fechaAnterior);
                }
                this.deprecia(activo, reubicacion.getFecha());
                fechaAnterior = reubicacion.getFecha();
            } else {
                if (fechaAnterior != null) {
                    activo.setFechaCompra(fechaAnterior);
                }
                activo.setCentroCosto(reubicacion.getCentroCostoAnterior());
                this.deprecia(activo, fecha);
                bandera1 = false;
            }

            this.depreciacionMensualPorCentroDeCosto(activo, mc, mapa1, tiposDeActivo, tiposDeActivoMap);
        }

        if (bandera1) {
            activo.setFechaCompra(activo.getFechaReubicado());
            this.deprecia(activo, fecha);
            this.depreciacionMensualPorCentroDeCosto(activo, mc, mapa1, tiposDeActivo, tiposDeActivoMap);
        }
    }

    if (log.isTraceEnabled()) {
        for (Map<String, Object> centroCosto : mapa1.values()) {
            log.trace("CentroCosto: {} : {}", centroCosto.get("nombre"), centroCosto.get("totales"));
        }
    }

    params.put("centrosDeCosto", mapa1.values());
    return params;
}

From source file:mx.edu.um.mateo.activos.dao.impl.ActivoDaoHibernate.java

License:Open Source License

@Override
@SuppressWarnings("unchecked")
@Transactional(readOnly = true)//from   ww  w  .  j  ava2  s.  c o m
public Map<String, Object> depreciacionMensualPorCentroDeCostoDetalle(Map<String, Object> params) {
    MathContext mc = new MathContext(16, RoundingMode.HALF_UP);
    Map<String, BigDecimal> totales = new HashMap<>();
    totales.put("ACUMULADA", BigDecimal.ZERO);
    totales.put("MENSUAL", BigDecimal.ZERO);
    totales.put("ANUAL", BigDecimal.ZERO);
    totales.put("NETO", BigDecimal.ZERO);
    Usuario usuario = (Usuario) params.get("usuario");
    String centroCostoId = (String) params.get("centroCostoId");
    Date fecha = (Date) params.get("fecha");
    CCostoPK ccostoPK = new CCostoPK(usuario.getEjercicio(), centroCostoId);
    CentroCosto centroCosto = (CentroCosto) currentSession().get(CentroCosto.class, ccostoPK);
    params.put("centroCosto", centroCosto);
    Criteria criteria = currentSession().createCriteria(Activo.class);
    criteria.add(Restrictions.eq("empresa.id", usuario.getEmpresa().getId()));
    criteria.add(Restrictions.eq("centroCosto.id.ejercicio.id.idEjercicio",
            usuario.getEjercicio().getId().getIdEjercicio()));
    criteria.add(Restrictions.eq("centroCosto.id.ejercicio.id.organizacion.id",
            usuario.getEjercicio().getId().getOrganizacion().getId()));
    criteria.add(Restrictions.eq("centroCosto.id.idCosto", centroCostoId));
    criteria.add(Restrictions.le("fechaCompra", fecha));
    criteria.add(Restrictions.isNull("fechaReubicado"));
    List<Activo> activos = criteria.list();
    for (Activo activo : activos) {
        log.trace("Depreciando activo {}", activo.getId());
        activo = this.deprecia(activo, fecha);

        this.depreciacionMensualPorCentroDeCostoDetalle(activo, mc, totales);
    }

    // busca reubicados
    Query query = currentSession().createQuery(
            "select a from ReubicacionActivo ra inner join ra.activo a where ra.empresa.id = :empresaId and (ra.centroCosto.id.idCosto = :centroCostoId or ra.centroCostoAnterior.id.idCosto = :centroCostoId) and a.fechaCompra < :fecha group by a");
    query.setLong("empresaId", usuario.getEmpresa().getId());
    query.setString("centroCostoId", centroCostoId);
    query.setDate("fecha", fecha);
    List<Activo> reubicados = query.list();
    for (Activo activo : reubicados) {
        log.trace("Depreciando reubicado {}", activo.getId());
        query = currentSession().createQuery(
                "select r from ReubicacionActivo r where r.activo.id = :activoId order by r.fecha");
        query.setLong("activoId", activo.getId());
        List<ReubicacionActivo> reubicaciones = query.list();
        Date fechaAnterior = null;
        boolean bandera1 = true;
        for (ReubicacionActivo reubicacion : reubicaciones) {
            boolean seDeprecio = false;
            if (reubicacion.getFecha().before(fecha)
                    && reubicacion.getCentroCostoAnterior().getId().getIdCosto().equals(centroCostoId)) {
                if (fechaAnterior != null) {
                    activo.setFechaCompra(fechaAnterior);
                }
                activo.setCentroCosto(reubicacion.getCentroCostoAnterior());
                this.deprecia(activo, reubicacion.getFecha());
                activos.add(activo);
                seDeprecio = true;
            } else if (reubicacion.getCentroCostoAnterior().getId().getIdCosto().equals(centroCostoId)) {
                if (fechaAnterior != null) {
                    activo.setFechaCompra(fechaAnterior);
                }
                activo.setCentroCosto(reubicacion.getCentroCostoAnterior());
                this.deprecia(activo, fecha);
                activos.add(activo);
                seDeprecio = true;
                bandera1 = false;
            } else {
                activo.setCentroCosto(reubicacion.getCentroCostoAnterior());
            }
            fechaAnterior = reubicacion.getFecha();

            if (seDeprecio) {
                this.depreciacionMensualPorCentroDeCostoDetalle(activo, mc, totales);
            }
        }

        if (bandera1 && activo.getCentroCosto().getId().getIdCosto().equals(centroCostoId)) {
            activo.setFechaCompra(activo.getFechaReubicado());
            this.deprecia(activo, fecha);
            this.depreciacionMensualPorCentroDeCostoDetalle(activo, mc, totales);
            activos.add(activo);
        }

    }
    params.put("activos", activos);
    params.put("totales", totales);
    return params;
}

From source file:mx.edu.um.mateo.activos.dao.impl.ActivoDaoHibernate.java

License:Open Source License

@Override
@SuppressWarnings("unchecked")
@Transactional(readOnly = true)/*  w w w.java2s. c  om*/
public Map<String, Object> depreciacionAcumuladaPorTipoActivo(Map<String, Object> params) {
    Usuario usuario = (Usuario) params.get("usuario");
    Query tiposDeActivoQuery = currentSession().createQuery(
            "select new map(ta.nombre as nombre, ta.cuenta.id.idCtaMayor as cuenta, ta.id as id) from TipoActivo ta where ta.cuenta.id.ejercicio.id.idEjercicio = :ejercicioId and ta.cuenta.id.ejercicio.id.organizacion.id = :organizacionId order by ta.cuenta.id.idCtaMayor");
    tiposDeActivoQuery.setString("ejercicioId", usuario.getEjercicio().getId().getIdEjercicio());
    tiposDeActivoQuery.setLong("organizacionId", usuario.getEjercicio().getId().getOrganizacion().getId());
    List<Map<String, Object>> tiposDeActivo = tiposDeActivoQuery.list();
    Map<String, Map<String, Object>> tiposDeActivoMap = new HashMap<>();
    for (Map<String, Object> tipoActivo : tiposDeActivo) {
        tipoActivo.put("ACUMULADA", BigDecimal.ZERO);
        tipoActivo.put("MENSUAL", BigDecimal.ZERO);
        tiposDeActivoMap.put((String) tipoActivo.get("cuenta"), tipoActivo);
    }
    log.trace("TiposDeActivoMap: {}", tiposDeActivoMap);

    params.put("tiposDeActivo", tiposDeActivo);

    Map<String, BigDecimal> totales = new HashMap<>();
    totales.put("ACUMULADA", BigDecimal.ZERO);
    totales.put("MENSUAL", BigDecimal.ZERO);

    Date fecha = (Date) params.get("fecha");

    MathContext mc = new MathContext(16, RoundingMode.HALF_UP);
    Query query = currentSession().createQuery(
            "select new Activo(a.id, a.version, a.moi, a.fechaCompra, a.tipoActivo.porciento, a.tipoActivo.vidaUtil, a.inactivo, a.fechaInactivo, a.fechaReubicado, a.tipoActivo.cuenta.id.idCtaMayor, a.centroCosto.id.idCosto, a.centroCosto.nombre) from Activo a inner join a.tipoActivo where a.empresa.id = :empresaId and a.fechaCompra <= :fecha");
    query.setLong("empresaId", usuario.getEmpresa().getId());
    query.setDate("fecha", fecha);
    List<Activo> activos = query.list();
    for (Activo activo : activos) {
        log.trace("Depreciando activo {}", activo.getId());
        activo = this.deprecia(activo, fecha);

        Map<String, Object> tipoActivo = (Map<String, Object>) tiposDeActivoMap
                .get(activo.getTipoActivoCuenta());
        BigDecimal acumulada = (BigDecimal) tipoActivo.get("ACUMULADA");
        acumulada = acumulada.add(activo.getDepreciacionAcumulada(), mc);
        tipoActivo.put("ACUMULADA", acumulada);

        BigDecimal totalAcumulada = (BigDecimal) totales.get("ACUMULADA");
        totalAcumulada = totalAcumulada.add(activo.getDepreciacionAcumulada(), mc);
        totales.put("ACUMULADA", totalAcumulada);

        BigDecimal mensual = (BigDecimal) tipoActivo.get("MENSUAL");
        mensual = mensual.add(activo.getDepreciacionMensual(), mc);
        tipoActivo.put("MENSUAL", mensual);

        BigDecimal totalMensual = (BigDecimal) totales.get("MENSUAL");
        totalMensual = totalMensual.add(activo.getDepreciacionMensual(), mc);
        totales.put("MENSUAL", totalMensual);
    }

    if (log.isTraceEnabled()) {
        for (Map<String, Object> tipoActivo : tiposDeActivo) {
            log.trace("TipoActivo: {} : {} : {}", new Object[] { tipoActivo.get("nombre"),
                    tipoActivo.get("ACUMULADA"), tipoActivo.get("MENSUAL") });
        }

        log.trace("Totales: {}", totales);
    }

    params.put("totales", totales);

    return params;
}

From source file:mx.edu.um.mateo.activos.dao.impl.ActivoDaoHibernate.java

License:Open Source License

@Override
@SuppressWarnings("unchecked")
@Transactional(readOnly = true)/*from   w ww  .  jav  a  2  s .c  o m*/
public Map<String, Object> reporteDIA(Integer anio, Usuario usuario) {
    Map<String, Object> resultado = new HashMap<>();
    Calendar fecha = Calendar.getInstance();
    fecha.setTimeInMillis(0);
    fecha.set(Calendar.DAY_OF_YEAR, 1);
    fecha.set(Calendar.YEAR, anio);
    fecha.set(Calendar.HOUR_OF_DAY, 0);

    Calendar fecha2 = Calendar.getInstance();
    fecha2.setTime(fecha.getTime());
    fecha2.add(Calendar.YEAR, 1);
    log.debug("Armando reporte dia de {} a {}", fecha, fecha2);

    MathContext mc = new MathContext(16, RoundingMode.HALF_UP);
    Map<String, Map<String, Object>> grupos = new TreeMap<>();
    BigDecimal totalCosto = BigDecimal.ZERO.setScale(2, RoundingMode.HALF_UP);
    BigDecimal totalCompras = BigDecimal.ZERO.setScale(2, RoundingMode.HALF_UP);
    BigDecimal totalBajas = BigDecimal.ZERO.setScale(2, RoundingMode.HALF_UP);
    BigDecimal costoFinal = BigDecimal.ZERO.setScale(2, RoundingMode.HALF_UP);
    BigDecimal totalDepreciacionAcumulada = BigDecimal.ZERO.setScale(2, RoundingMode.HALF_UP);
    BigDecimal totalComprasAcumuladas = BigDecimal.ZERO.setScale(2, RoundingMode.HALF_UP);
    BigDecimal totalBajasAcumuladas = BigDecimal.ZERO.setScale(2, RoundingMode.HALF_UP);
    BigDecimal totalDepreciacionFinal = BigDecimal.ZERO.setScale(2, RoundingMode.HALF_UP);
    BigDecimal valorNeto = BigDecimal.ZERO.setScale(2, RoundingMode.HALF_UP);

    Criteria criteria = currentSession().createCriteria(TipoActivo.class);
    criteria.add(Restrictions.eq("empresa.id", usuario.getEmpresa().getId()));
    List<TipoActivo> tiposDeActivo = criteria.list();
    for (TipoActivo tipoActivo : tiposDeActivo) {
        Map<String, Object> ta = new HashMap<>();
        ta.put("cuenta", tipoActivo.getCuenta().getId().getIdCtaMayor());
        ta.put("nombre", tipoActivo.getNombre());
        ta.put("costo", BigDecimal.ZERO.setScale(2, RoundingMode.HALF_UP));
        ta.put("compras", BigDecimal.ZERO.setScale(2, RoundingMode.HALF_UP));
        ta.put("bajas", BigDecimal.ZERO.setScale(2, RoundingMode.HALF_UP));
        ta.put("costoFinal", BigDecimal.ZERO.setScale(2, RoundingMode.HALF_UP));
        ta.put("depreciacionAcumulada", BigDecimal.ZERO.setScale(2, RoundingMode.HALF_UP));
        ta.put("comprasAcumuladas", BigDecimal.ZERO.setScale(2, RoundingMode.HALF_UP));
        ta.put("bajasAcumuladas", BigDecimal.ZERO.setScale(2, RoundingMode.HALF_UP));
        ta.put("depreciacionFinal", BigDecimal.ZERO.setScale(2, RoundingMode.HALF_UP));
        ta.put("valorNeto", BigDecimal.ZERO.setScale(2, RoundingMode.HALF_UP));
        grupos.put(tipoActivo.getCuenta().getId().getIdCtaMayor(), ta);
    }

    log.debug("Activos");
    Query query = currentSession().createQuery(
            "select new Activo(a.id, a.version, a.moi, a.fechaCompra, a.tipoActivo.porciento, a.tipoActivo.vidaUtil, a.inactivo, a.fechaInactivo, a.fechaReubicado, a.tipoActivo.cuenta.id.idCtaMayor, a.centroCosto.id.idCosto, a.centroCosto.nombre) "
                    + "from Activo a inner join a.tipoActivo " + "where a.empresa.id = :empresaId "
                    + "and a.fechaCompra <= :fecha " + "and (a.inactivo = false or a.fechaInactivo > :fecha)");
    query.setLong("empresaId", usuario.getEmpresa().getId());
    query.setDate("fecha", fecha.getTime());
    for (Activo activo : (List<Activo>) query.list()) {
        activo = this.deprecia(activo, fecha.getTime());
        Map<String, Object> ta = grupos.get(activo.getTipoActivoCuenta());
        BigDecimal costo = (BigDecimal) ta.get("costo");
        costo = costo.add(activo.getMoi(), mc);
        ta.put("costo", costo);

        BigDecimal depreciacionAcumulada = (BigDecimal) ta.get("depreciacionAcumulada");
        depreciacionAcumulada = depreciacionAcumulada.add(activo.getDepreciacionAcumulada(), mc);
        ta.put("depreciacionAcumulada", depreciacionAcumulada);

        totalCosto = totalCosto.add(activo.getMoi());
        totalDepreciacionAcumulada = totalDepreciacionAcumulada.add(activo.getDepreciacionAcumulada(), mc);

        activo = this.deprecia(activo, fecha2.getTime());
        BigDecimal depreciacionFinal = (BigDecimal) ta.get("depreciacionFinal");
        depreciacionFinal = depreciacionFinal.add(activo.getDepreciacionAcumulada(), mc);
        ta.put("depreciacionFinal", depreciacionFinal);

        totalDepreciacionFinal = totalDepreciacionFinal.add(activo.getDepreciacionAcumulada(), mc);
    }

    // Compras
    query = currentSession().createQuery(
            "select new Activo(a.id, a.version, a.moi, a.fechaCompra, a.tipoActivo.porciento, a.tipoActivo.vidaUtil, a.inactivo, a.fechaInactivo, a.fechaReubicado, a.tipoActivo.cuenta.id.idCtaMayor, a.centroCosto.id.idCosto, a.centroCosto.nombre) "
                    + "from Activo a inner join a.tipoActivo " + "where a.empresa.id = :empresaId "
                    + "and a.fechaCompra between :fecha and :fecha2 "
                    + "and (a.inactivo = false or a.fechaInactivo > :fecha)");
    query.setLong("empresaId", usuario.getEmpresa().getId());
    query.setDate("fecha", fecha.getTime());
    query.setDate("fecha2", fecha2.getTime());
    for (Activo activo : (List<Activo>) query.list()) {
        activo = this.deprecia(activo, fecha.getTime());
        Map<String, Object> ta = grupos.get(activo.getTipoActivoCuenta());
        BigDecimal compras = (BigDecimal) ta.get("compras");
        compras = compras.add(activo.getMoi(), mc);
        ta.put("compras", compras);
        totalCompras = totalCompras.add(activo.getMoi(), mc);

        activo = this.deprecia(activo, fecha2.getTime());
        BigDecimal comprasAcumuladas = (BigDecimal) ta.get("comprasAcumuladas");
        comprasAcumuladas = comprasAcumuladas.add(activo.getDepreciacionAcumulada(), mc);
        ta.put("comprasAcumuladas", comprasAcumuladas);

        totalComprasAcumuladas = totalComprasAcumuladas.add(activo.getDepreciacionAcumulada(), mc);
        totalDepreciacionFinal = totalDepreciacionFinal.add(activo.getDepreciacionAcumulada(), mc);
    }

    // Bajas
    query = currentSession().createQuery(
            "select new Activo(a.id, a.version, a.moi, a.fechaCompra, a.tipoActivo.porciento, a.tipoActivo.vidaUtil, a.inactivo, a.fechaInactivo, a.fechaReubicado, a.tipoActivo.cuenta.id.idCtaMayor, a.centroCosto.id.idCosto, a.centroCosto.nombre) "
                    + "from Activo a inner join a.tipoActivo " + "where a.empresa.id = :empresaId "
                    + "and a.inactivo = true and a.fechaInactivo between :fecha and :fecha2");
    query.setLong("empresaId", usuario.getEmpresa().getId());
    query.setDate("fecha", fecha.getTime());
    query.setDate("fecha2", fecha2.getTime());
    for (Activo activo : (List<Activo>) query.list()) {
        activo = this.deprecia(activo, fecha.getTime());
        Map<String, Object> ta = grupos.get(activo.getTipoActivoCuenta());
        BigDecimal bajas = (BigDecimal) ta.get("bajas");
        bajas = bajas.add(activo.getMoi(), mc);
        ta.put("bajas", bajas);

        BigDecimal bajasAcumuladas = (BigDecimal) ta.get("bajasAcumuladas");
        bajasAcumuladas = bajasAcumuladas.add(activo.getDepreciacionAcumulada(), mc);
        ta.put("bajasAcumuladas", bajasAcumuladas);

        totalBajas = totalBajas.add(activo.getMoi(), mc);
        totalBajasAcumuladas = totalBajasAcumuladas.add(activo.getDepreciacionAcumulada(), mc);
    }

    for (TipoActivo tipoActivo : tiposDeActivo) {
        Map<String, Object> grupo = grupos.get(tipoActivo.getCuenta().getId().getIdCtaMayor());
        BigDecimal costo = (BigDecimal) grupo.get("costo");
        BigDecimal compras = (BigDecimal) grupo.get("compras");
        BigDecimal bajas = (BigDecimal) grupo.get("bajas");
        BigDecimal grupoCostoFinal = costo.add(compras.subtract(bajas, mc), mc);
        grupo.put("costoFinal", grupoCostoFinal);
        costoFinal = costoFinal.add(grupoCostoFinal, mc);

        BigDecimal depreciacionFinal = (BigDecimal) grupo.get("depreciacionFinal");
        BigDecimal depreciacionAcumulada = (BigDecimal) grupo.get("depreciacionAcumulada");
        grupo.put("comprasAcumuladas", depreciacionFinal.subtract(depreciacionAcumulada, mc));
        totalComprasAcumuladas = totalDepreciacionFinal.subtract(totalDepreciacionAcumulada, mc);

        BigDecimal grupoValorNeto = grupoCostoFinal.subtract(depreciacionFinal, mc);
        grupo.put("valorNeto", grupoValorNeto);
        valorNeto = valorNeto.add(grupoValorNeto, mc);
        log.debug("{} : {} : {} : {} : {}", new Object[] { tipoActivo.getNombre(), costoFinal,
                depreciacionFinal, grupoValorNeto, valorNeto });
    }

    resultado.put("lista", grupos.values());
    resultado.put("totalCosto", totalCosto);
    resultado.put("totalCompras", totalCompras);
    resultado.put("totalBajas", totalBajas);
    resultado.put("costoFinal", costoFinal);
    resultado.put("totalDepreciacionAcumulada", totalDepreciacionAcumulada);
    resultado.put("totalComprasAcumuladas", totalComprasAcumuladas);
    resultado.put("totalBajasAcumuladas", totalBajasAcumuladas);
    resultado.put("totalDepreciacionFinal", totalDepreciacionFinal);
    resultado.put("valorNeto", valorNeto);
    return resultado;
}

From source file:mx.edu.um.mateo.activos.dao.impl.ActivoDaoHibernate.java

License:Open Source License

@Override
@Transactional(readOnly = true)/*from   w  ww . java2 s  .  co  m*/
public Map<String, Object> concentradoDepreciacionPorCentroDeCosto(Map<String, Object> params) {
    Usuario usuario = (Usuario) params.get("usuario");
    Query tiposDeActivoQuery = currentSession().createQuery(
            "select new map(ta.nombre as nombre, ta.cuenta.id.idCtaMayor as cuenta, ta.id as id) from TipoActivo ta where ta.cuenta.id.ejercicio.id.idEjercicio = :ejercicioId and ta.cuenta.id.ejercicio.id.organizacion.id = :organizacionId order by ta.cuenta.id.idCtaMayor");
    tiposDeActivoQuery.setString("ejercicioId", usuario.getEjercicio().getId().getIdEjercicio());
    tiposDeActivoQuery.setLong("organizacionId", usuario.getEjercicio().getId().getOrganizacion().getId());
    List<Map<String, Object>> tiposDeActivo = new ArrayList<>();
    Map<String, Object> totalCC = new HashMap<>();
    totalCC.put("nombre", "");
    totalCC.put("cuenta", "TOTAL");
    totalCC.put("id", 0);
    totalCC.put("acumulada", BigDecimal.ZERO);
    totalCC.put("mensual", BigDecimal.ZERO);
    totalCC.put("anual", BigDecimal.ZERO);
    totalCC.put("valorNeto", BigDecimal.ZERO);
    totalCC.put("costo", BigDecimal.ZERO);
    tiposDeActivo.add(totalCC);
    tiposDeActivo.addAll(tiposDeActivoQuery.list());
    Map<String, Map<String, Object>> tiposDeActivoMap = new HashMap<>();
    tiposDeActivoMap.put("TOTAL", totalCC);
    for (Map<String, Object> tipoActivo : tiposDeActivo) {
        if (!tipoActivo.get("cuenta").equals("TOTAL")) {
            tipoActivo.put("acumulada", BigDecimal.ZERO);
            tipoActivo.put("mensual", BigDecimal.ZERO);
            tipoActivo.put("anual", BigDecimal.ZERO);
            tipoActivo.put("valorNeto", BigDecimal.ZERO);
            tipoActivo.put("costo", BigDecimal.ZERO);
            tiposDeActivoMap.put((String) tipoActivo.get("cuenta"), tipoActivo);
        }
    }
    params.put("tiposDeActivo", tiposDeActivo);

    Date fecha = (Date) params.get("fecha");

    MathContext mc = new MathContext(16, RoundingMode.HALF_UP);
    Map<String, Map<String, Object>> mapa1 = new TreeMap<>();
    Query query = currentSession().createQuery(
            "select new Activo(a.id, a.version, a.moi, a.fechaCompra, a.tipoActivo.porciento, a.tipoActivo.vidaUtil, a.inactivo, a.fechaInactivo, a.fechaReubicado, a.tipoActivo.cuenta.id.idCtaMayor, a.centroCosto.id.idCosto, a.centroCosto.nombre) from Activo a inner join a.tipoActivo where a.empresa.id = :empresaId and a.fechaCompra <= :fecha and a.fechaReubicado is null");
    query.setLong("empresaId", usuario.getEmpresa().getId());
    query.setDate("fecha", fecha);
    List<Activo> activos = query.list();
    for (Activo activo : activos) {
        log.trace("Depreciando activo {}", activo.getId());
        activo = this.deprecia(activo, fecha);

        this.concentradoDepreciacionPorCentroDeCosto(activo, mc, mapa1, tiposDeActivo, tiposDeActivoMap);
    }

    query = currentSession().createQuery(
            "select new Activo(a.id, a.version, a.moi, a.fechaCompra, a.tipoActivo.porciento, a.tipoActivo.vidaUtil, a.inactivo, a.fechaInactivo, a.fechaReubicado, a.tipoActivo.cuenta.id.idCtaMayor, a.centroCosto.id.idCosto, a.centroCosto.nombre) from Activo a inner join a.tipoActivo where a.empresa.id = :empresaId and a.fechaCompra <= :fecha and a.fechaReubicado != null");
    query.setLong("empresaId", usuario.getEmpresa().getId());
    query.setDate("fecha", fecha);
    activos = query.list();
    for (Activo activo : activos) {
        query = currentSession().createQuery(
                "select r from ReubicacionActivo r where r.activo.id = :activoId order by r.fecha");
        query.setLong("activoId", activo.getId());
        List<ReubicacionActivo> reubicaciones = query.list();
        Date fechaAnterior = null;
        boolean bandera1 = true;
        for (ReubicacionActivo reubicacion : reubicaciones) {
            if (reubicacion.getFecha().before(fecha)) {
                activo.setCentroCosto(reubicacion.getCentroCostoAnterior());
                if (fechaAnterior != null) {
                    activo.setFechaCompra(fechaAnterior);
                }
                this.deprecia(activo, reubicacion.getFecha());
                fechaAnterior = reubicacion.getFecha();
            } else {
                if (fechaAnterior != null) {
                    activo.setFechaCompra(fechaAnterior);
                }
                activo.setCentroCosto(reubicacion.getCentroCostoAnterior());
                this.deprecia(activo, fecha);
                bandera1 = false;
            }

            this.concentradoDepreciacionPorCentroDeCosto(activo, mc, mapa1, tiposDeActivo, tiposDeActivoMap);
        }

        if (bandera1) {
            activo.setFechaCompra(activo.getFechaReubicado());
            this.deprecia(activo, fecha);
            this.concentradoDepreciacionPorCentroDeCosto(activo, mc, mapa1, tiposDeActivo, tiposDeActivoMap);
        }
    }

    if (log.isTraceEnabled()) {
        for (Map<String, Object> centroCosto : mapa1.values()) {
            log.trace("CentroCosto: {} : {} : {}", new Object[] { centroCosto.get("cuenta"),
                    centroCosto.get("nombre"), centroCosto.get("totales") });
        }
        log.trace("TiposDeActivo: {}", tiposDeActivo);
    }

    params.put("centrosDeCosto", mapa1.values());
    return params;
}

From source file:mx.edu.um.mateo.inventario.dao.impl.ProductoDaoHibernate.java

License:Open Source License

@SuppressWarnings("unchecked")
@Override/*from  w w w.j  a v a  2s.  c o  m*/
public void guardaHistorial(Date fecha) {
    log.debug("Buscando historial de productos de la fecha {}", fecha);
    StringBuilder sb = new StringBuilder();
    sb.append("select new HistorialProducto(p.id, p.almacen) from Producto p order by p.codigo");
    log.debug("Cargando lista de productos");
    List<HistorialProducto> productos = currentSession().createQuery(sb.toString()).list();
    List<HistorialProducto> resultado = new ArrayList<>();
    log.debug("Buscando historial por producto ({})", productos.size());
    int cont = 0;
    for (HistorialProducto hp : productos) {
        if (cont++ % 10 == 0) {
            log.debug("Leyendo {} / {} Productos", cont, productos.size());
        }
        sb = new StringBuilder();
        sb.append(
                "select new map(p.existencia as existencia) from XProducto p where p.productoId = :productoId and p.fechaCreacion <= :fecha order by p.fechaCreacion desc");
        Query query = currentSession().createQuery(sb.toString());
        query.setLong("productoId", hp.getProductoId());
        query.setTimestamp("fecha", fecha);
        query.setMaxResults(1);
        Map<String, Object> existencia = (Map<String, Object>) query.uniqueResult();
        if (existencia != null && !existencia.isEmpty()) {
            sb = new StringBuilder();
            sb.append("select hp from HistorialProducto hp where fecha = :fecha and productoId = :productoId");
            Query query2 = currentSession().createQuery(sb.toString());
            query2.setDate("fecha", fecha);
            query2.setLong("productoId", hp.getProductoId());
            HistorialProducto otro = (HistorialProducto) query2.uniqueResult();
            if (otro != null) {
                hp = otro;
            }
            hp.setExistencia((BigDecimal) existencia.get("existencia"));
            hp.setFecha(fecha);
            resultado.add(hp);
        }
    }
    log.debug("{} / {} Productos", cont, productos.size());
    log.debug("Guardando historial de productos ({})", resultado.size());
    cont = 0;
    for (HistorialProducto hp : resultado) {
        if (cont++ % 10 == 0) {
            log.debug("Guardando {} / {} Productos", cont, resultado.size());
        }
        currentSession().saveOrUpdate(hp);
    }
}

From source file:mx.edu.um.mateo.inventario.dao.impl.ProductoDaoHibernate.java

License:Open Source License

@Override
public List<Map<String, Object>> revisaEntradas(String fechaString, Usuario usuario) {
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    List<Map<String, Object>> entradas = new ArrayList<>();
    try {//  w w w.j ava 2s. c om
        Date fecha = sdf.parse(fechaString);
        StringBuilder s = new StringBuilder();
        s.append(
                "select new map(x.entradaId as entradaId, e.folio as folio, x.productoId as productoId, p.sku as sku, count(x.productoId) as cantidad) ");
        s.append("from XProducto x, Entrada e, Producto p ");
        s.append(
                "where x.entradaId = e.id and x.productoId = p.id and x.fechaCreacion >= :fecha and x.almacenId = :almacenId ");
        s.append("group by x.entradaId, e.folio, x.productoId, p.sku ");
        s.append("order by cantidad desc, e.folio desc");
        Query query = currentSession().createQuery(s.toString());
        query.setDate("fecha", fecha);
        query.setLong("almacenId", usuario.getAlmacen().getId());
        List<Map<String, Object>> resultados = (List<Map<String, Object>>) query.list();
        for (Map<String, Object> resultado : resultados) {
            if (((Long) resultado.get("cantidad")) > 1) {
                entradas.add(resultado);
            }
        }
    } catch (ParseException e) {
        log.error("No pude entender la fecha " + fechaString, e);
    }

    return entradas;
}

From source file:mx.edu.um.mateo.rh.dao.impl.DiaFeriadoDaoHibernate.java

/**
 * @see mx.edu.um.mateo.rh.dao.DiaFeriadoDao#esFeriado(java.util.Date)
 */// ww w.  jav a  2 s  .  com
@Override
@Transactional(readOnly = true)
public Boolean esFeriado(Date fecha) {
    Boolean feriado = true;
    Query query = currentSession().createQuery("select f from DiaFeriado f where f.fecha = :fecha");
    query.setDate("fecha", fecha);
    DiaFeriado dia = (DiaFeriado) query.uniqueResult();
    if (dia == null) {
        feriado = false;
    }
    return feriado;
}