Example usage for java.math BigDecimal add

Introduction

In this page you can find the example usage for java.math BigDecimal add.

Prototype

private static long add(long xs, long ys) 

Source Link

Usage

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

private void depreciacionAcumuladaPorCentroDeCostoDetalle(Activo activo, MathContext mc,
        Map<String, BigDecimal> totales) {
    BigDecimal total = totales.get("ACUMULADA");
    total = total.add(activo.getDepreciacionAcumulada(), mc);
    totales.put("ACUMULADA", total);

    total = totales.get("MENSUAL");
    total = total.add(activo.getDepreciacionMensual(), mc);
    totales.put("MENSUAL", total);

    total = totales.get("ANUAL");
    total = total.add(activo.getDepreciacionAnual(), mc);
    totales.put("ANUAL", total);

    total = totales.get("NETO");
    total = total.add(activo.getValorNeto(), mc);
    totales.put("NETO", total);
}

---

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

private void depreciacionMensualPorCentroDeCostoDetalle(Activo activo, MathContext mc,
        Map<String, BigDecimal> totales) {
    BigDecimal total = totales.get("ACUMULADA");
    total = total.add(activo.getDepreciacionAcumulada(), mc);
    totales.put("ACUMULADA", total);

    total = totales.get("MENSUAL");
    total = total.add(activo.getDepreciacionMensual(), mc);
    totales.put("MENSUAL", total);

    total = totales.get("ANUAL");
    total = total.add(activo.getDepreciacionAnual(), mc);
    totales.put("ANUAL", total);

    total = totales.get("NETO");
    total = total.add(activo.getValorNeto(), mc);
    totales.put("NETO", total);
}

---

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

private void depreciacionAcumuladaPorCentroDeCosto(Activo activo, MathContext mc,
        Map<String, Map<String, Object>> mapa1, List<Map<String, Object>> tiposDeActivo,
        Map<String, Map<String, Object>> tiposDeActivoMap) {
    Map<String, Object> mapa2 = mapa1.get(activo.getCentroCostoCuenta());
    Map<String, BigDecimal> mapa3;
    if (mapa2 == null) {
        mapa2 = new HashMap<>();
        mapa3 = new HashMap<>();
        for (Map<String, Object> tipoActivo : tiposDeActivo) {
            mapa3.put((String) tipoActivo.get("cuenta"), BigDecimal.ZERO);
        }// w  w  w  .  j  a v  a2s .com
        mapa3.put("TOTAL", BigDecimal.ZERO);
        mapa2.put("totales", mapa3);
        mapa2.put("cuenta", activo.getCentroCostoCuenta());
        mapa2.put("nombre", activo.getCentroCostoNombre());
        mapa1.put(activo.getCentroCostoCuenta(), mapa2);
    }

    mapa3 = (Map<String, BigDecimal>) mapa2.get("totales");

    BigDecimal cantidad = mapa3.get(activo.getTipoActivoCuenta());
    cantidad = cantidad.add(activo.getDepreciacionAcumulada(), mc);
    mapa3.put(activo.getTipoActivoCuenta(), cantidad);

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

    // Totales
    cantidad = mapa3.get("TOTAL");
    cantidad = cantidad.add(activo.getDepreciacionAcumulada(), mc);
    mapa3.put("TOTAL", cantidad);

    tipoActivo = (Map<String, Object>) tiposDeActivoMap.get("TOTAL");
    total = (BigDecimal) tipoActivo.get("total");
    total = total.add(activo.getDepreciacionAcumulada(), mc);
    tipoActivo.put("total", total);
}

---

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

private void depreciacionMensualPorCentroDeCosto(Activo activo, MathContext mc,
        Map<String, Map<String, Object>> mapa1, List<Map<String, Object>> tiposDeActivo,
        Map<String, Map<String, Object>> tiposDeActivoMap) {
    Map<String, Object> mapa2 = mapa1.get(activo.getCentroCostoCuenta());
    Map<String, BigDecimal> mapa3;
    if (mapa2 == null) {
        mapa2 = new HashMap<>();
        mapa3 = new HashMap<>();
        for (Map<String, Object> tipoActivo : tiposDeActivo) {
            mapa3.put((String) tipoActivo.get("cuenta"), BigDecimal.ZERO);
        }//  ww w .  j  a v a2  s . c o  m
        mapa3.put("TOTAL", BigDecimal.ZERO);
        mapa2.put("totales", mapa3);
        mapa2.put("cuenta", activo.getCentroCostoCuenta());
        mapa2.put("nombre", activo.getCentroCostoNombre());
        mapa1.put(activo.getCentroCostoCuenta(), mapa2);
    }

    mapa3 = (Map<String, BigDecimal>) mapa2.get("totales");

    BigDecimal cantidad = mapa3.get(activo.getTipoActivoCuenta());
    cantidad = cantidad.add(activo.getDepreciacionMensual(), mc);
    mapa3.put(activo.getTipoActivoCuenta(), cantidad);

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

    // Totales
    cantidad = mapa3.get("TOTAL");
    cantidad = cantidad.add(activo.getDepreciacionMensual(), mc);
    mapa3.put("TOTAL", cantidad);

    tipoActivo = (Map<String, Object>) tiposDeActivoMap.get("TOTAL");
    total = (BigDecimal) tipoActivo.get("total");
    total = total.add(activo.getDepreciacionMensual(), mc);
    tipoActivo.put("total", total);
}

---

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

@Override
@SuppressWarnings("unchecked")
@Transactional(readOnly = true)//from   w  ww.  j  a v  a  2 s  . c o m
public Map<String, Object> depreciacionAcumuladaPorTipoActivoDetalle(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 tipoActivoId = (String) params.get("tipoActivoId");
    Date fecha = (Date) params.get("fecha");
    Query query = currentSession().createQuery(
            "select ta from TipoActivo ta where ta.cuenta.id.idCtaMayor = :tipoActivoId and ta.cuenta.id.ejercicio.id.idEjercicio = :ejercicioId and ta.cuenta.id.ejercicio.id.organizacion.id = :organizacionId");
    query.setString("tipoActivoId", tipoActivoId);
    query.setString("ejercicioId", usuario.getEjercicio().getId().getIdEjercicio());
    query.setLong("organizacionId", usuario.getEjercicio().getId().getOrganizacion().getId());
    TipoActivo tipoActivo = (TipoActivo) query.uniqueResult();
    if (tipoActivo != null) {
        params.put("tipoActivo", tipoActivo);
        Criteria criteria = currentSession().createCriteria(Activo.class);
        criteria.add(Restrictions.eq("empresa.id", usuario.getEmpresa().getId()));
        criteria.add(Restrictions.eq("tipoActivo.id", tipoActivo.getId()));
        criteria.add(Restrictions.le("fechaCompra", fecha));
        List<Activo> activos = criteria.list();
        for (Activo activo : activos) {
            log.trace("Depreciando activo {}", activo.getId());
            activo = this.deprecia(activo, fecha);

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

            total = totales.get("MENSUAL");
            total = total.add(activo.getDepreciacionMensual(), mc);
            totales.put("MENSUAL", total);

            total = totales.get("ANUAL");
            total = total.add(activo.getDepreciacionAnual(), mc);
            totales.put("ANUAL", total);

            total = totales.get("NETO");
            total = total.add(activo.getValorNeto(), mc);
            totales.put("NETO", total);
        }
        params.put("activos", activos);
        params.put("totales", totales);

    }
    return params;
}

---

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

@Override
@SuppressWarnings("unchecked")
@Transactional(readOnly = true)/*from  w w w  .  j a v a2  s  .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

private void concentradoDepreciacionPorCentroDeCosto(Activo activo, MathContext mc,
        Map<String, Map<String, Object>> mapa1, List<Map<String, Object>> tiposDeActivo,
        Map<String, Map<String, Object>> tiposDeActivoMap) {
    Map<String, Object> mapa2 = mapa1.get(activo.getCentroCostoCuenta());
    Map<String, Map<String, BigDecimal>> mapa3;
    if (mapa2 == null) {
        mapa2 = new HashMap<>();
        mapa3 = new HashMap<>();
        for (Map<String, Object> tipoActivo : tiposDeActivo) {
            Map<String, BigDecimal> mapa4 = new HashMap<>();
            mapa4.put("acumulada", BigDecimal.ZERO);
            mapa4.put("mensual", BigDecimal.ZERO);
            mapa4.put("anual", BigDecimal.ZERO);
            mapa4.put("valorNeto", BigDecimal.ZERO);
            mapa4.put("costo", BigDecimal.ZERO);
            mapa3.put((String) tipoActivo.get("cuenta"), mapa4);
        }// ww w.  ja  va2s  .c  o  m
        mapa2.put("totales", mapa3);
        mapa2.put("cuenta", activo.getCentroCostoCuenta());
        mapa2.put("nombre", activo.getCentroCostoNombre());
        mapa1.put(activo.getCentroCostoCuenta(), mapa2);
    }

    mapa3 = (Map<String, Map<String, BigDecimal>>) mapa2.get("totales");

    Map<String, BigDecimal> mapa4 = mapa3.get(activo.getTipoActivoCuenta());
    BigDecimal acumulada = mapa4.get("acumulada");
    acumulada = acumulada.add(activo.getDepreciacionAcumulada(), mc);
    mapa4.put("acumulada", acumulada);

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

    BigDecimal anual = mapa4.get("anual");
    anual = anual.add(activo.getDepreciacionAnual(), mc);
    mapa4.put("anual", anual);

    BigDecimal valorNeto = mapa4.get("valorNeto");
    valorNeto = valorNeto.add(activo.getValorNeto(), mc);
    mapa4.put("valorNeto", valorNeto);

    BigDecimal costo = mapa4.get("costo");
    costo = costo.add(activo.getMoi(), mc);
    mapa4.put("costo", costo);

    Map<String, BigDecimal> total = mapa3.get("TOTAL");
    acumulada = total.get("acumulada");
    acumulada = acumulada.add(activo.getDepreciacionAcumulada(), mc);
    total.put("acumulada", acumulada);

    mensual = total.get("mensual");
    mensual = mensual.add(activo.getDepreciacionMensual(), mc);
    total.put("mensual", mensual);

    anual = total.get("anual");
    anual = anual.add(activo.getDepreciacionAnual(), mc);
    total.put("anual", anual);

    valorNeto = total.get("valorNeto");
    valorNeto = valorNeto.add(activo.getValorNeto(), mc);
    total.put("valorNeto", valorNeto);

    costo = total.get("costo");
    costo = costo.add(activo.getMoi(), mc);
    total.put("costo", costo);

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

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

    anual = (BigDecimal) tipoActivo.get("anual");
    anual = anual.add(activo.getDepreciacionAnual(), mc);
    tipoActivo.put("anual", anual);

    valorNeto = (BigDecimal) tipoActivo.get("valorNeto");
    valorNeto = valorNeto.add(activo.getValorNeto(), mc);
    tipoActivo.put("valorNeto", valorNeto);

    costo = (BigDecimal) tipoActivo.get("costo");
    costo = costo.add(activo.getMoi(), mc);
    tipoActivo.put("costo", costo);

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

    tipoActivo = (Map<String, Object>) tiposDeActivoMap.get("TOTAL");
    mensual = (BigDecimal) tipoActivo.get("mensual");
    mensual = mensual.add(activo.getDepreciacionMensual(), mc);
    tipoActivo.put("mensual", mensual);

    tipoActivo = (Map<String, Object>) tiposDeActivoMap.get("TOTAL");
    anual = (BigDecimal) tipoActivo.get("anual");
    anual = anual.add(activo.getDepreciacionAnual(), mc);
    tipoActivo.put("anual", anual);

    tipoActivo = (Map<String, Object>) tiposDeActivoMap.get("TOTAL");
    valorNeto = (BigDecimal) tipoActivo.get("valorNeto");
    valorNeto = valorNeto.add(activo.getValorNeto(), mc);
    tipoActivo.put("valorNeto", valorNeto);

    tipoActivo = (Map<String, Object>) tiposDeActivoMap.get("TOTAL");
    costo = (BigDecimal) tipoActivo.get("costo");
    costo = costo.add(activo.getMoi(), mc);
    tipoActivo.put("costo", costo);
}

---

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

@Override
@SuppressWarnings("unchecked")
@Transactional(readOnly = true)//from  w  w  w  .  j a v  a2 s.  co 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:nl.strohalm.cyclos.services.transactions.PaymentServiceImpl.java

@Override
public List<ScheduledPaymentDTO> calculatePaymentProjection(final ProjectionDTO params) {
    getProjectionValidator().validate(params);

    final LocalSettings localSettings = settingsService.getLocalSettings();

    final int paymentCount = params.getPaymentCount();
    final TimePeriod recurrence = params.getRecurrence();
    final BigDecimal totalAmount = params.getAmount();
    final BigDecimal paymentAmount = localSettings.round(totalAmount
            .divide(CoercionHelper.coerce(BigDecimal.class, paymentCount), localSettings.getMathContext()));
    BigDecimal accumulatedAmount = BigDecimal.ZERO;
    Calendar currentDate = DateHelper.truncate(params.getFirstExpirationDate());
    final List<ScheduledPaymentDTO> payments = new ArrayList<ScheduledPaymentDTO>(paymentCount);
    for (int i = 0; i < paymentCount; i++) {
        final ScheduledPaymentDTO dto = new ScheduledPaymentDTO();
        dto.setDate(currentDate);//ww  w.j a v a2  s  . co  m
        dto.setAmount(i == paymentCount - 1 ? totalAmount.subtract(accumulatedAmount) : paymentAmount);
        payments.add(dto);
        accumulatedAmount = accumulatedAmount.add(dto.getAmount(), localSettings.getMathContext());
        currentDate = recurrence.add(currentDate);
    }
    return payments;
}

---

From source file:ca.uhn.fhir.jpa.dao.SearchBuilder.java

private Predicate createPredicateNumeric(CriteriaBuilder builder, IQueryParameterType params,
        ParamPrefixEnum cmpValue, BigDecimal valueValue, final Expression<BigDecimal> path,
        String invalidMessageName, String theValueString) {
    Predicate num;/* w w w . jav a 2  s. c o m*/
    switch (cmpValue) {
    case GREATERTHAN:
        num = builder.gt(path, valueValue);
        break;
    case GREATERTHAN_OR_EQUALS:
        num = builder.ge(path, valueValue);
        break;
    case LESSTHAN:
        num = builder.lt(path, valueValue);
        break;
    case LESSTHAN_OR_EQUALS:
        num = builder.le(path, valueValue);
        break;
    case APPROXIMATE:
    case EQUAL:
    case NOT_EQUAL:
        BigDecimal mul = calculateFuzzAmount(cmpValue, valueValue);
        BigDecimal low = valueValue.subtract(mul, MathContext.DECIMAL64);
        BigDecimal high = valueValue.add(mul, MathContext.DECIMAL64);
        Predicate lowPred;
        Predicate highPred;
        if (cmpValue != ParamPrefixEnum.NOT_EQUAL) {
            lowPred = builder.ge(path.as(BigDecimal.class), low);
            highPred = builder.le(path.as(BigDecimal.class), high);
            num = builder.and(lowPred, highPred);
            ourLog.trace("Searching for {} <= val <= {}", low, high);
        } else {
            // Prefix was "ne", so reverse it!
            lowPred = builder.lt(path.as(BigDecimal.class), low);
            highPred = builder.gt(path.as(BigDecimal.class), high);
            num = builder.or(lowPred, highPred);
        }
        break;
    default:
        String msg = myContext.getLocalizer().getMessage(SearchBuilder.class, invalidMessageName,
                cmpValue.getValue(), params.getValueAsQueryToken(myContext));
        throw new InvalidRequestException(msg);
    }
    return num;
}

---

• «
• 1
• 2
• »