es.emergya.bbdd.dao.IncidenciaHome.java Source code

Java tutorial

Introduction

Here is the source code for es.emergya.bbdd.dao.IncidenciaHome.java

Source

/*
 * Copyright (C) 2010, Emergya (http://www.emergya.es)
 *
 * @author <a href="mailto:jlrodriguez@emergya.es">Juan Lus Rodrguez</a>
 * @author <a href="mailto:marias@emergya.es">Mara Arias</a>
 *
 * This file is part of GoFleet
 *
 * This software is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This software is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * As a special exception, if you link this library with other files to
 * produce an executable, this library does not by itself cause the
 * resulting executable to be covered by the GNU General Public License.
 * This exception does not however invalidate any other reasons why the
 * executable file might be covered by the GNU General Public License.
 */
package es.emergya.bbdd.dao;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;

import org.appfuse.dao.hibernate.GenericDaoHibernate;
import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.criterion.CriteriaSpecification;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Property;
import org.hibernate.criterion.Restrictions;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import es.emergya.bbdd.bean.CategoriaIncidencia;
import es.emergya.bbdd.bean.EstadoIncidencia;
import es.emergya.bbdd.bean.Incidencia;
import es.emergya.bbdd.bean.Recurso;
import es.emergya.consultas.UsuarioConsultas;
import es.emergya.utils.LogicConstants;

@Repository("incidenciaHome")
public class IncidenciaHome extends GenericDaoHibernate<Incidencia, Long> {

    public IncidenciaHome() {
        super(Incidencia.class);
    }

    @Transactional(propagation = Propagation.REQUIRED, readOnly = true, rollbackFor = Throwable.class)
    @Override
    public Incidencia get(Long id) {
        try {
            final Incidencia i = super.get(id);
            if (i != null) {
                if (i.getCreador() != null)
                    i.getCreador().getId();
                if (i.getEstado() != null)
                    i.getEstado().getId();
                if (i.getCategoria() != null)
                    i.getCategoria().getId();
                if (i.getRecursos() != null)
                    for (Recurso r : i.getRecursos())
                        if (r != null)
                            r.getId();
            }
            return i;
        } catch (Throwable t) {
            log.error("Estamos buscando un objeto que no existe", t);
            return null;
        }
    }

    @Transactional(propagation = Propagation.REQUIRED, readOnly = true, rollbackFor = Throwable.class)
    public Integer getTotal() {
        try {
            Session currentSession = getSession();
            currentSession.clear();
            Criteria criteria = currentSession.createCriteria(Incidencia.class)
                    .setProjection(Projections.rowCount());
            return (Integer) criteria.uniqueResult();
        } catch (Throwable t) {
            log.error(t, t);
            return -1;
        }
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW, readOnly = false, rollbackFor = Throwable.class)
    public boolean saveOrUpdate(Incidencia p) {
        if (p == null)
            return false;

        Incidencia entity = null;
        try {
            Session currentSession = getSession();
            if (p.getId() != null && this.get(p.getId()) != null)
                entity = get(p.getId());

            if (entity == null)
                entity = p;
            else {
                if (p.getCategoria() != null)
                    try {
                        entity.setCategoria((CategoriaIncidencia) super.getSession().get(CategoriaIncidencia.class,
                                p.getCategoria().getId()));
                    } catch (Throwable t) {
                        log.error("Categoria desconocida", t);
                    }
                else
                    entity.setCategoria(null);
                if (p.getCreador() != null)
                    entity.setCreador(UsuarioConsultas.find(p.getCreador().getNombreUsuario()));
                else
                    entity.setCreador(null);
                entity.setDescripcion(p.getDescripcion());
                if (p.getEstado() != null)
                    try {
                        entity.setEstado((EstadoIncidencia) super.getSession().get(EstadoIncidencia.class,
                                p.getEstado().getId()));
                    } catch (Throwable t) {
                        log.error("Estado desconocido", t);
                    }
                else
                    entity.setEstado(null);
                entity.setFechaCierre(p.getFechaCierre());
                entity.setFechaCreacion(p.getFechaCreacion());
                entity.setGeometria(p.getGeometria());
                entity.setPrioridad(p.getPrioridad());
                entity.setTitulo(p.getTitulo());
            }
            currentSession.saveOrUpdate(entity);
        } catch (Throwable t) {
            log.error("Error al guardar una incidencia: " + p, t);
            return false;
        }
        return true;
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW, readOnly = false, rollbackFor = Throwable.class)
    public boolean delete(Incidencia r) {
        if (r == null || r.getId() == null)
            return false;
        try {
            this.remove(r.getId());
        } catch (Throwable t) {
            log.error(t, t);
            return false;
        }
        return true;
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW, readOnly = true, rollbackFor = Throwable.class)
    public Calendar lastUpdated() {
        Calendar res = Calendar.getInstance();
        try {
            Session currentSession = getSession();
            currentSession.clear();
            Criteria criteria = currentSession.createCriteria(Incidencia.class)
                    .setProjection(Projections.max("updatedAt"));
            res.setTime((Date) criteria.uniqueResult());
        } catch (NullPointerException t) {
            log.error("No hay datos en la tabla.");
            return null;
        } catch (Throwable t) {
            log.error(t, t);
            return null;
        }
        return res;
    }

    @SuppressWarnings("unchecked")
    @Transactional(propagation = Propagation.REQUIRES_NEW, readOnly = true, rollbackFor = Throwable.class)
    public List<Incidencia> getAll() {
        List<Incidencia> res = new LinkedList<Incidencia>();
        try {
            Session currentSession = getSession();
            currentSession.clear();
            Criteria criteria = currentSession.createCriteria(Incidencia.class)
                    .setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
            res = (List<Incidencia>) criteria.list();
            for (Incidencia i : res) {
                if (i.getCreador() != null)
                    i.getCreador().getId();
                if (i.getEstado() != null)
                    i.getEstado().getId();
                if (i.getCategoria() != null)
                    i.getCategoria().getId();
            }
        } catch (Throwable t) {
            log.error(t, t);
        }
        return res;
    }

    @SuppressWarnings("unchecked")
    @Transactional(propagation = Propagation.REQUIRES_NEW, readOnly = true, rollbackFor = Throwable.class)
    public List<Incidencia> getOpened() {
        List<Incidencia> res = new LinkedList<Incidencia>();
        try {
            Session currentSession = getSession();
            currentSession.clear();
            Criteria criteria = currentSession.createCriteria(Incidencia.class).createCriteria("estado")
                    .add(Restrictions.ne("id", 3l)).setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
            res = (List<Incidencia>) criteria.list();

            for (Incidencia i : res)
                if (i != null) {
                    if (i.getCreador() != null)
                        i.getCreador().getId();
                    if (i.getEstado() != null)
                        i.getEstado().getId();
                    if (i.getCategoria() != null)
                        i.getCategoria().getId();
                }
        } catch (Throwable t) {
            log.error(t, t);
        }
        return res;
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW, readOnly = true, rollbackFor = Throwable.class)
    public Incidencia find(String identificador) {
        try {
            Session currentSession = getSession();
            currentSession.clear();
            Criteria criteria = currentSession.createCriteria(Incidencia.class)
                    .add(Restrictions.eq("referenciaHumana", identificador))
                    .setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY).setMaxResults(1);
            final Incidencia uniqueResult = (Incidencia) criteria.uniqueResult();
            return uniqueResult;
        } catch (Throwable t) {
            log.error(t, t);
        }
        return null;
    }

    @SuppressWarnings("unchecked")
    @Transactional(propagation = Propagation.REQUIRES_NEW, readOnly = true, rollbackFor = Throwable.class)
    public List<Incidencia> getByExample(Incidencia f) {
        try {
            Session currentSession = getSession();
            currentSession.clear();
            Criteria criteria = currentSession.createCriteria(Incidencia.class).addOrder(Order.asc("titulo"));

            // titulo
            if (f.getTitulo() != null && f.getTitulo().trim().length() > 0) {
                criteria.add(Restrictions.ilike("titulo", LogicConstants.getGenericString(f.getTitulo())));
            }

            // prioridad
            if (f.getPrioridad() != null) {
                criteria.add(Restrictions.eq("prioridad", f.getPrioridad()));
            }

            // categoria
            if (f.getCategoria() != null) {
                criteria.createAlias("categoria", "cat")
                        .add(Restrictions.eq("cat.identificador", f.getCategoria().getIdentificador()));
            }

            // estado
            if (f.getEstado() != null) {
                criteria.createAlias("estado", "est")
                        .add(Restrictions.eq("est.identificador", f.getEstado().getIdentificador()));
            } else {
                criteria.createAlias("estado", "est").add(Restrictions.ne("est.id", 3l));
            }

            List<Incidencia> res = new LinkedList<Incidencia>();
            res = criteria.list();
            for (Incidencia i : res)
                if (i != null) {
                    if (i.getCreador() != null)
                        i.getCreador().getId();
                    if (i.getEstado() != null)
                        i.getEstado().getId();
                    if (i.getCategoria() != null)
                        i.getCategoria().getId();
                }
            return res;
        } catch (Throwable t) {
            log.error("Error extrayendo las categorias de las incidencias", t);
        }
        return new LinkedList<Incidencia>();
    }

    @SuppressWarnings("unchecked")
    @Transactional(propagation = Propagation.REQUIRES_NEW, readOnly = true, rollbackFor = Throwable.class)
    public List<Object> getCategorias() {
        try {
            Session currentSession = getSession();
            currentSession.clear();
            Criteria criteria = currentSession.createCriteria(CategoriaIncidencia.class)
                    .addOrder(Order.asc("identificador"));
            return criteria.list();
        } catch (Throwable t) {
            log.error("Error extrayendo las categorias de las incidencias", t);
        }
        return new LinkedList<Object>();
    }

    @SuppressWarnings("unchecked")
    @Transactional(propagation = Propagation.REQUIRES_NEW, readOnly = true, rollbackFor = Throwable.class)
    public List<Object> getStatuses() {
        try {
            Session currentSession = getSession();
            currentSession.clear();
            Criteria criteria = currentSession.createCriteria(EstadoIncidencia.class)
                    .addOrder(Order.asc("identificador"));
            return criteria.list();
        } catch (Throwable t) {
            log.error("Error extrayendo los estados de las incidencias", t);
        }
        return new LinkedList<Object>();
    }

    /**
     * Devuelve todas las incidencias que estuvieron abiertas en el intervalo
     * pasado y su posicin coincide con alguna de las zonas indicadas. Si no se
     * pasan zonas, la posicin no se utilizar como criterio para obtener la
     * lista de incidencias.
     * 
     * @param nombreUsuario
     *            el nombre de usuario del usuario que realiza la consulta.
     * @param fechaInicio
     *            el instante inicial a usar en el filtro.
     * @param fechaFinal
     *            el instante final a usar en el filtro.
     * @param zonas
     *            Lista de zonas en las que deben estar las incidencias.
     * @return La lista de zonas que estuvieron abiertas en algn momento del
     *         periodo en alguna de las zonas pasadas.
     */
    @Transactional(propagation = Propagation.REQUIRES_NEW, readOnly = true, rollbackFor = Throwable.class)
    public List<Incidencia> getIncidenciasEnPeriodo(String nombreUsuario, Calendar fechaInicio,
            Calendar fechaFinal) {
        Date inicio = null;
        Date fin = null;

        if (fechaInicio != null) {
            inicio = fechaInicio.getTime();
        } else {
            return new ArrayList<Incidencia>(0);
        }
        if (fechaFinal != null) {
            fin = fechaFinal.getTime();
        } else {
            return new ArrayList<Incidencia>(0);
        }

        Criteria c = getSession().createCriteria(Incidencia.class).addOrder(Order.asc("referenciaHumana"))
                .setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY)
                .createAlias("street", "st", Criteria.LEFT_JOIN).createAlias("portal", "pt", Criteria.LEFT_JOIN);
        if (fin != null) {
            c = c.add(Restrictions.le("fechaCreacion", fin));
        }
        if (inicio != null) {
            c = c.add(Restrictions.or(Restrictions.ge("fechaCierre", inicio),
                    Property.forName("fechaCierre").isNull()));
        }

        log.trace("Criteria final: " + c);

        return c.list();
    }

    /**
     * Busca una incidencia a partir de su referencia interna.
     * 
     * @param referenciaIngerna
     *            cdigo interno proporcionado por Eurocop para la incidencia.
     * @return la incidencia con la referenciaInterna pasada o <code>null</code>
     *         si no existe en la base de datos.
     */
    @Transactional(propagation = Propagation.REQUIRES_NEW, readOnly = true, rollbackFor = Throwable.class)
    public Incidencia findIncidenciaByReferenciaInterna(Long referenciaInterna) {
        Incidencia resultado;
        if (referenciaInterna != null) {
            Criteria crit = getSession().createCriteria(Incidencia.class)
                    .add(Restrictions.eq("referenciaInterna", referenciaInterna));
            resultado = (Incidencia) crit.uniqueResult();

        } else {
            resultado = null;
        }

        return resultado;

    }

    /**
     * Almacena la incidencia en la base de datos.
     * 
     * @param incidencia
     * @return
     */
    @Transactional(propagation = Propagation.REQUIRES_NEW, readOnly = false, rollbackFor = Throwable.class)
    public Incidencia saveIncidencia(Incidencia incidencia) {
        getSession().save(incidencia);
        return incidencia;
    }

    /**
     * Actualiza los estados de las incidencias que NO se encuentren en el array
     * y cuyo estado no es ya el pasado como parmetro.
     * 
     * @param idsIncidencias
     *            Array de ids de incidencias
     * @param estado
     *            Estado a establecer
     */
    @Transactional(propagation = Propagation.REQUIRES_NEW, readOnly = false, rollbackFor = Throwable.class)
    public void updateEstadosIncidencias(Long[] idsIncidencias, String estado) {

        if (idsIncidencias != null && idsIncidencias.length > 0) {
            EstadoIncidencia estadoObj = getEstadoIncidenciaByIdentificador(estado);
            if (estado != null) {
                Criteria crit = getSession().createCriteria(Incidencia.class)
                        .add(Restrictions.not(Restrictions.in("id", idsIncidencias)))
                        .add(Restrictions.ne("estado", estadoObj));

                List<Incidencia> resultado = crit.list();
                for (Incidencia inc : resultado) {
                    if (log.isTraceEnabled()) {
                        log.trace("Actualizamos el estado de la incidencia " + inc.getId() + " a " + estado);
                    }
                    inc.setEstado(estadoObj);
                    getSession().update(inc);
                }
            } else {
                log.error("El estado " + estado + " no se encuentra en la base de datos");
            }
        }
    }

    /**
     * Obtiene el objeto EstadoIncidencia que se corresponda con el
     * identificador
     * 
     * @param identificador
     *            Identificador del EstadoIncidencia a obtenet
     * @return EstadoIncidencia correspondiente, o null en caso de no
     *         encontrarlo
     */
    @Transactional(propagation = Propagation.REQUIRES_NEW, readOnly = true, rollbackFor = Throwable.class)
    public EstadoIncidencia getEstadoIncidenciaByIdentificador(String identificador) {
        EstadoIncidencia resultado;
        if (identificador != null && !identificador.equals("")) {
            Criteria crit = getSession().createCriteria(EstadoIncidencia.class)
                    .add(Restrictions.like("identificador", identificador));
            resultado = (EstadoIncidencia) crit.uniqueResult();

        } else {
            resultado = null;
        }

        return resultado;
    }

}