/src/java/recursos/UsuarioFacadeREST.java

package recursos;

import accesodatos.Calendario;
import accesodatos.Evento;
import accesodatos.Usuario;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.Response;

/**
 *
 * @author fran
 */
@Stateless
@Path("usuarios")
public class UsuarioFacadeREST extends AbstractFacade<Usuario> {

    @PersistenceContext(unitName = "CalendarioRESTPU")
    private EntityManager em;

    public UsuarioFacadeREST() {
        super(Usuario.class);
    }

    @POST
    @Override
    @Consumes({"application/xml", "application/json"})
    public Response create(Usuario entity) {
        Response respuesta;
        try {
            super.create(entity);
            respuesta = Response.status(Response.Status.CREATED).build();
        } catch (Exception e) {
            respuesta = Response.status(Response.Status.INTERNAL_SERVER_ERROR).build();
        }
        return respuesta;
    }

    @PUT
    @Override
    @Consumes({"application/xml", "application/json"})
    public Response edit(Usuario entity) {
        Response respuesta;
        try {
            super.edit(entity);
            respuesta = Response.status(Response.Status.ACCEPTED).build();
        } catch (Exception e) {
            respuesta = Response.status(Response.Status.NOT_MODIFIED).build();
        }
        return respuesta;
    }

    @DELETE
    @Path("{id}")
    public Response remove(@PathParam("id") Integer id) {
        Response respuesta;
        try {
            super.remove(super.find(id));
            respuesta = Response.status(Response.Status.NO_CONTENT).build();
        } catch (Exception e) {
            respuesta = Response.status(Response.Status.NOT_FOUND).build();
        }
        return respuesta;
    }

    @GET
    @Path("{id}")
    @Produces({"application/xml", "application/json"})
    public Usuario find(@PathParam("id") Integer id) {
        return super.find(id);
    }

    @GET
    @Override
    @Produces({"application/xml", "application/json"})
    public List<Usuario> findAll() {
        return super.findAll();
    }

    @GET
    @Path("{from}/{to}")
    @Produces({"application/xml", "application/json"})
    public List<Usuario> findRange(@PathParam("from") Integer from, @PathParam("to") Integer to) {
        return super.findRange(new int[]{from, to});
    }

    @GET
    @Path("count")
    @Produces("text/plain")
    public String countREST() {
        return String.valueOf(super.count());
    }

    /**
     * Rellena la lista con aquellos calendarios que sean publicos, y la
     * devuelve.
     *
     *
     * @param iter
     * @param calPublicos
     * @return
     */
    public List<Calendario> rellenaCalPublicos(Iterator<Calendario> iter) {
        Calendario calendario;
        List<Calendario> calPublicos = new ArrayList<Calendario>();
        if (!iter.hasNext()) {
            calendario = iter.next();
            if (calendario.getPublico()) {
                calPublicos.add(calendario);
            }
        } else {
            while (iter.hasNext()) {
                calendario = iter.next();
                if (calendario.getPublico()) {
                    calPublicos.add(calendario);
                }
            }
        }
        return calPublicos;
    }

    /**
     * Procesa la lista de calendarios que son publicos y devuelve la lista de
     * todos los eventos de dichos calendarios.
     *
     * @param iter
     * @param calPublicos
     * @return
     */
    private List<Evento> leeCalPublicos(Iterator<Calendario> iter) {
        Calendario actual;
        Collection<Evento> eventosDeUnCalendario;
        List<Evento> eventosPublicos = new ArrayList<Evento>();
        Iterator<Evento> iterEventos;
        Evento evento;
        while (iter.hasNext()) {
            actual = iter.next();
            eventosDeUnCalendario = actual.getEventoCollection();
            iterEventos = eventosDeUnCalendario.iterator();
            if (!iterEventos.hasNext()) {
                evento = iterEventos.next();
                eventosPublicos.add(evento);
            } else {
                while (iterEventos.hasNext()) {
                    evento = iterEventos.next();
                    eventosPublicos.add(evento);
                }
            }

        }
        return eventosPublicos;
    }

    /**
     * Procesa la lista de eventos publicos y la filtra por el calendario
     * identificado con el parametro idCalendario.
     *
     * @param iter
     * @param idCalendario
     * @return
     */
    private List<Evento> filtraPorIdCalendario(Iterator<Evento> iter, Integer idCalendario) {
        Evento eventoActual;
        List<Evento> listaFiltrada = new ArrayList<Evento>();
        if (!iter.hasNext()) {
            eventoActual = iter.next();
            if (eventoActual.getCalendarioidCalendario().getIdCalendario()
                    .equals(idCalendario)) {
                listaFiltrada.add(eventoActual);
            }
        } else {
            while (iter.hasNext()) {
                eventoActual = iter.next();
                if (eventoActual.getCalendarioidCalendario().getIdCalendario()
                        .equals(idCalendario)) {
                    listaFiltrada.add(eventoActual);
                }
            }
        }
        return listaFiltrada;
    }

    /**
     *
     * @param iter
     * @param fecha
     * @return
     * @throws ParseException
     */
    private List<Evento> filtrarPorFecha(Iterator<Evento> iter, String fecha) throws ParseException {
        Evento eventoActual;
        List<Evento> listaFiltrada = new ArrayList<Evento>();
        Collection<Evento> eventosPublicos;
        String oldstring = fecha;
        Date fechaCasting = new SimpleDateFormat("yyyy-MM-dd").parse(oldstring);
        if (!iter.hasNext()) {
            eventoActual = iter.next();
            if (eventoActual.getFecha().equals(fechaCasting)) {
                listaFiltrada.add(eventoActual);
            }
        } else {
            while (iter.hasNext()) {
                eventoActual = iter.next();
                if (eventoActual.getFecha().equals(fechaCasting)) {
                    listaFiltrada.add(eventoActual);
                }
            }
        }
        return listaFiltrada;
    }

    /**
     *
     * @param listaOriginal
     * @param numero
     * @return
     */
    private List<Evento> filtrarPorNumero(List<Evento> listaOriginal, Integer numero) {
        Evento actual;
        List<Evento> listaFiltrada = new ArrayList<Evento>();
        for(int i = 0; i < numero && i < listaOriginal.size() ; i++){
            actual = listaOriginal.get(i);
            listaFiltrada.add(actual);
        }
        return listaFiltrada;
    }

    @GET
    @Path("{id}/calendarios/publicos")
    @Produces({"application/xml", "application/json"})
    public List<Calendario> findCalendariosPublicos(@PathParam("id") Integer id) {
        Usuario user = super.find(id);
        Iterator<Calendario> iter = user.getCalendarioCollection().iterator();

        return rellenaCalPublicos(iter);
    }

    @GET
    @Path("{id}/calendarios/publicos/eventos")
    @Produces({"application/xml", "application/json"})
    public List<Evento> findEventosPublicosByUserId(@PathParam("id") Integer id) {
        Usuario user = super.find(id);
        Iterator<Calendario> iter = user.getCalendarioCollection().iterator();

        List<Evento> eventosPublicos;
        eventosPublicos = leeCalPublicos(rellenaCalPublicos(iter).iterator());


        return eventosPublicos;
    }

    @GET
    @Path("{idUser}/calendarios/{idCalendario}/publicos/eventos")
    @Produces({"application/xml", "application/json"})
    public List<Evento> findAllEventosPublicosByCalendarioId(@PathParam("idUser") Integer id, @PathParam("idCalendario") Integer idCalendario) {
        Usuario user = super.find(id);
        Iterator<Calendario> iter = user.getCalendarioCollection().iterator();

        List<Evento> eventosPublicos;
        eventosPublicos = leeCalPublicos(rellenaCalPublicos(iter).iterator());
        return filtraPorIdCalendario(eventosPublicos.iterator(), idCalendario);
    }

    @GET
    @Path("{idUser}/calendarios/{idCalendario}/publicos/eventos/{fecha}")
    @Produces({"application/xml", "application/json"})
    public List<Evento> findEventosPublicosByFechaCalendario(@PathParam("idUser") Integer id,
            @PathParam("idCalendario") Integer idCalendario,
            @PathParam("fecha") String fecha) throws ParseException {
        //Declaracion de variables
        Usuario user = super.find(id);
        Iterator<Calendario> iter = user.getCalendarioCollection().iterator();
        List<Evento> eventosPublicos;
        List<Evento> evsPorCalendario;
        //Procesamos los filtrados
        eventosPublicos = leeCalPublicos(rellenaCalPublicos(iter).iterator());
        evsPorCalendario = filtraPorIdCalendario(eventosPublicos.iterator(),
                idCalendario);

        return filtrarPorFecha(evsPorCalendario.iterator(), fecha);
    }

    @GET
    @Path("{idUser}/calendarios/publicos/eventos/{fecha}")
    @Produces({"application/xml", "application/json"})
    public List<Evento> findEventosPublicosByFecha(@PathParam("idUser") Integer id,
            @PathParam("fecha") String fecha) throws ParseException {
        Usuario user = super.find(id);
        Iterator<Calendario> iter = user.getCalendarioCollection().iterator();
        List<Evento> eventosPublicos;
        eventosPublicos = leeCalPublicos(rellenaCalPublicos(iter).iterator());

        return filtrarPorFecha(eventosPublicos.iterator(), fecha);
    }

    @GET
    @Path("{idUser}/calendarios/publicos/eventos/limitar/{num}")
    @Produces({"application/xml", "application/json"})
    public List<Evento> filtrarEventosPublicosByNum(@PathParam("idUser") Integer id,
            @PathParam("num") Integer num) throws ParseException {
        List<Evento> eventosPublicos;
        
        Usuario user = super.find(id);
        Iterator<Calendario> iter = user.getCalendarioCollection().iterator();
        eventosPublicos = leeCalPublicos(rellenaCalPublicos(iter).iterator());

        return filtrarPorNumero(eventosPublicos, num);
    }
    
    @GET
    @Path("{idUser}/calendarios/{idCalendario}/publicos/eventos/limitar/{num}")
    @Produces({"application/xml", "application/json"})
    public List<Evento> filtrarEvsPubsCalendarioByNum(@PathParam("idUser") Integer id,
            @PathParam("idCalendario") Integer idCalendario,
            @PathParam("num") Integer num) throws ParseException {
        //Declaracion de variables
        Usuario user = super.find(id);
        Iterator<Calendario> iter = user.getCalendarioCollection().iterator();
        List<Evento> eventosPublicos;
        List<Evento> evsPorCalendario;
        //Procesamos los filtrados
        eventosPublicos = leeCalPublicos(rellenaCalPublicos(iter).iterator());
        evsPorCalendario = filtraPorIdCalendario(eventosPublicos.iterator(),
                idCalendario);

        return filtrarPorNumero(evsPorCalendario, num);
    }

    @Override
    protected EntityManager getEntityManager() {
        return em;
    }
}