com.edu.ufps.maregroups.controller.negocio.Negocio.java Source code

Java tutorial

Introduction

Here is the source code for com.edu.ufps.maregroups.controller.negocio.Negocio.java

Source

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package com.edu.ufps.maregroups.controller.negocio;

import com.edu.ufps.maregroups.model.DTO.*;
import com.edu.ufps.maregroups.model.DAO.factory.*;
import com.edu.ufps.maregroups.model.DAO.interfaces.*;
import com.edu.ufps.maregroups.util.Encriptador;
import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Serializable;
import java.sql.SQLException;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.HashSet;
import javax.servlet.http.Part;
import javax.swing.JOptionPane;

/**
 *
 * @author andrea
 */
public class Negocio implements Serializable {

    private static DAOFactory factory;

    public Negocio() {
        getFactory();
    }

    private DAOFactory getFactory() {
        if (Negocio.factory == null) {
            Negocio.factory = new DAOFactory();
        }

        return Negocio.factory;
    }

    /*
    public short obtenerTipo() {
    if (this.usuario != null) {
        return this.usuario.getTipoUsuario();
    }
    return 0;
    }*/
    public boolean registrarAdministrador(AdministradorDTO dto) {
        boolean ex = false;
        IAdministradorDAO admon = Negocio.factory.obtenerAdministrador();
        try {
            ex = admon.insertar(dto);
        } catch (Exception e) {
            JOptionPane.showMessageDialog(null, "Error al intentar guardar, intentelo mas tarde");
        }
        return ex;
    }

    /*
    public short validarUsuario(UsuarioDTO dto) throws Exception {
    this.usuario = null;
    IUsuarioDAO user = Negocio.factory.obtenerUsuario();
    try {
        this.usuario = user.validar(dto);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return this.usuario.getTipoUsuario();
    }*/
    public UsuarioDTO iniciarSesion(String tipoDoc, String numDoc, String contrasena) throws Exception {
        IUsuarioDAO user = Negocio.factory.obtenerUsuario();
        return user.validar(Integer.parseInt(tipoDoc), Integer.parseInt(numDoc), Encriptador.encriptar(contrasena));
    }

    public InvestigadorDTO consultarInvestigador(String tipoDoc, String numDoc) throws Exception {
        IInvestigadorDAO investigadorDao;
        InvestigadorDTO investigador;
        try {
            investigadorDao = factory.obtenerInvestigador();
            investigador = investigadorDao.consultarInvestigador(tipoDoc, numDoc);
        } catch (SQLException ex) {
            throw ex;
        }
        return investigador;
    }

    public boolean modificarInvestigador(InvestigadorDTO dto) throws Exception {
        boolean exito;
        IInvestigadorDAO inv = Negocio.factory.obtenerInvestigador();
        try {
            /*if (this.usuario.getPassword().equals(contra)) {
            dto.setPassword(this.usuario.getPassword());
            if (dto.getGenero().equals("...") || dto.getGenero().isEmpty()) {
                dto.setGenero(this.usuario.getGenero());
            }
            dto.setNumDoc(this.usuario.getNumDoc());
            dto.setTipoDoc(this.usuario.getTipoDoc());*/
            exito = inv.modificarInvestigador(dto);
        } catch (Exception ex) {
            throw ex;
        }

        return exito;
    }

    //pendiente pasar a cambiarEstadoInv
    public boolean desactivarInvestigador(InvestigadorDTO dto) throws Exception {
        int ex = 0;
        IInvestigadorDAO inv = Negocio.factory.obtenerInvestigador();
        try {
            ex = inv.eliminarInvestigador(dto);
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (ex == 0) {
            return false;
        }
        return true;
    }

    //pendiente modificar DTOS agregar idUsuario(tipoDoc y numDoc) para hacer insercion por los ids
    public boolean registrarProyecto(ProyectoDTO dto, String autores) throws Exception {

        boolean pro = false;
        IProyectoInvestigadorDAO proyec;
        ArrayList<InvestigadorDTO> investigadores;
        InvestigadorDTO investigador;
        JsonArray jsonArray;
        Gson gson = new Gson();
        String tipoDoc, numDoc;
        ProyectoInvestigadorDTO proyecto;

        try {
            jsonArray = gson.fromJson(autores, JsonArray.class);
            investigadores = new ArrayList<>(0);

            for (JsonElement jsonElement : jsonArray) {
                tipoDoc = jsonElement.getAsJsonObject().get("tipoDoc").getAsString();
                numDoc = jsonElement.getAsJsonObject().get("numDoc").getAsString();
                investigador = new InvestigadorDTO();
                investigador.setTipoDoc(tipoDoc);
                investigador.setNumDoc(numDoc);
                investigadores.add(investigador);
            }

            proyec = Negocio.factory.obtenerProyectoInvestigador();
            proyecto = new ProyectoInvestigadorDTO(dto);
            proyecto.setInvestigadores(investigadores);
            pro = proyec.registrarProyecto(proyecto);
        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        }
        return pro;

    }

    public ArrayList<ProyectoDTO> listaProyectosPendientes() throws Exception {
        IProyectoDAO proyectoDao = factory.obtenerProyecto();
        return (ArrayList<ProyectoDTO>) proyectoDao.listarProyectosPorEstado(0);
    }

    public ArrayList<String> stringProyectos(InvestigadorDTO investigador) throws Exception {

        IProyectoInvestigadorDAO inve = Negocio.factory.obtenerProyectoInvestigador();
        ArrayList<String> aux = null;
        try {

            aux = (ArrayList<String>) inve.stringProyectos((InvestigadorDTO) investigador);

        } catch (Exception ex) {
            ex.printStackTrace();
        }

        return aux;
    }

    public ArrayList<ProyectoDTO> listarProyectosPorInvestigador(InvestigadorDTO investigador) throws Exception {
        IProyectoInvestigadorDAO inve = Negocio.factory.obtenerProyectoInvestigador();
        ArrayList<ProyectoDTO> aux = null;
        try {
            aux = (ArrayList<ProyectoDTO>) inve.listarProyectos(investigador);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return aux;
    }

    public ProyectoDTO consultarProyecto(String nomProyecto) throws Exception {

        IProyectoDAO inv = Negocio.factory.obtenerProyecto();
        ProyectoDTO pro = null;
        try {
            pro = inv.consultarProyecto(nomProyecto);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return pro;

    }

    public boolean eliminarProyectos(ArrayList<ProyectoDTO> proyectos) throws Exception {
        boolean ep = false;
        IProyectoDAO p = Negocio.factory.obtenerProyecto();

        try {
            for (ProyectoDTO pr : proyectos) {
                ep = p.eliminarProyecto(pr);
            }
        } catch (Exception e) {
            return false;
        }
        return ep;

    }

    //saber si existe usuario en sesion SOBRA
    /*public boolean existeUsuario() {
        
    if (this.usuario != null) {
        return true;
    }
    return false;
        
    }*/
    public boolean registrarInvestigador(InvestigadorDTO dto) throws Exception {
        int x = 0;
        boolean ex = false;
        IInvestigadorDAO user = Negocio.factory.obtenerInvestigador();
        try {
            x = user.insertarInvestigador(dto);
            ex = true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
        return ex;

    }

    /**
     * METODOS DE ANDREA
     *
     * @param dto
     * @return
     */
    public boolean registrarEstudio(EstudioDTO dto) throws Exception {
        boolean ex;
        IEstudioDAO e = Negocio.factory.obtenerEstudio();
        try {
            e.insertarEstudio(dto);
            //esto es por si se deja el muchos a muchos pendiente de revision
            //this.insertarEstudioInvestigador(dto);
            ex = true;
        } catch (Exception p) {
            p.printStackTrace();
            throw p;
        }
        return ex;

    }

    public ArrayList<EstudioDTO> consultarEstudiosPorInvestigador(InvestigadorDTO investigador) throws Exception {
        ArrayList<EstudioDTO> exito = new ArrayList();
        IEstudioDAO ex = Negocio.factory.obtenerEstudio();
        try {
            exito = (ArrayList<EstudioDTO>) ex.listarEstudiosPorInvestigador(investigador);
        } catch (Exception p) {
            p.printStackTrace();
            throw p;
        }
        return exito;
    }

    public void eliminarVariosEstudios(ArrayList<Long> idsEstudios) throws Exception {
        IEstudioDAO ex;
        try {
            ex = Negocio.factory.obtenerEstudio();
            ex.eliminarVarios(idsEstudios);
        } catch (SQLException p) {
            p.printStackTrace();
            throw p;
        }
    }

    /*
    Pendiente de revisin si no 
    public boolean eliminarEstudios(ArrayList<EstudioDTO> estudios) throws Exception {
    boolean exito = false;
    IEstudioInvestigadorDAO ex = Negocio.factory.obtenerEstudioInv();
    try {
        for (EstudioDTO est : estudios) {
            exito = ex.eliminarEstudioDeInvestigador(est, (InvestigadorDTO) this.usuario);
        
        }
    } catch (Exception p) {
        return false;
    }
    return exito;
        
    }*/
    public ArrayList<LineasInvestigacionDTO> consultarLineas() throws Exception {
        ArrayList<LineasInvestigacionDTO> lineas = new ArrayList();
        ILineasInvestigacionDAO lineaDao = Negocio.factory.obtenerLineas();
        try {
            lineas = (ArrayList<LineasInvestigacionDTO>) lineaDao.listarLineas();
        } catch (Exception p) {
            JOptionPane.showMessageDialog(null, "Error al intentar listar, intentelo mas tarde");
        }
        return lineas;
    }

    public boolean registrarProducto(ProductoDTO dto, ArrayList<InvestigadorDTO> investigadores) throws Exception {

        boolean exito = false;
        try {
            IProductoDAO productoDAO = Negocio.factory.obtenerProducto();
            exito = productoDAO.insertarProducto(dto, investigadores);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return exito;
    }

    public boolean aceptarProyectos(String proyectos[]) throws Exception {
        IPublicacionDAO p = Negocio.factory.obtenerPublicacion();
        if (proyectos != null) {
            for (int j = 0; j < proyectos.length; j++) {
                p.aceptarProyectos(proyectos[j]);
            }
        }

        return true;
    }

    public boolean eliminarProyectos(String proyectos[]) throws Exception {
        IPublicacionDAO p = Negocio.factory.obtenerPublicacion();
        if (proyectos != null) {
            for (String proyecto : proyectos) {
                p.eliminarProyectos(proyecto);
            }
        }
        return true;
    }

    public ArrayList<ProductoDTO> listarProducto(ProyectoDTO dto) {
        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
    }

    public ArrayList<ProductoDTO> listarProductosPorInvestigadorYProyecto(InvestigadorDTO inv, String tituloproy)
            throws Exception {

        ArrayList<ProductoDTO> productos = null;

        try {
            IProductoDAO pDAO = Negocio.factory.obtenerProducto();
            productos = pDAO.listarProductosPorInvestigadorYProyecto(inv, tituloproy);
        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        }

        return productos;
    }

    public boolean eliminarProducto(ArrayList<ProductoDTO> productos, ProyectoDTO dto) {
        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
    }

    //metodo Andrea
    public boolean registrarLinea(LineasInvestigacionDTO dto) throws Exception {
        boolean ex = false;
        ILineasInvestigacionDAO e = Negocio.factory.obtenerLineas();
        try {
            ex = e.insertarLinea(dto);

        } catch (Exception p) {
            p.printStackTrace();
        }
        System.out.println("Negocio " + ex);
        return ex;

    }

    public boolean eliminarLineas(ArrayList<LineasInvestigacionDTO> linea) throws Exception {
        boolean exito = false;
        ILineasInvestigacionDAO ex = Negocio.factory.obtenerLineas();
        try {
            for (LineasInvestigacionDTO est : linea) {
                exito = ex.eliminarLinea(est);
            }
        } catch (Exception p) {
            p.printStackTrace();
            exito = false;
        } finally {
            return exito;
        }
    }

    public boolean modificarLineaInv(LineasInvestigacionDTO dto) throws Exception {

        boolean exito = false;
        try {
            ILineasInvestigacionDAO linea = Negocio.factory.obtenerLineas();
            exito = linea.modificarLinea(dto);
        } catch (Exception ex) {
            ex.printStackTrace();
            throw ex;
        }
        return exito;
    }

    public boolean modificarDatos(InfoGrupoDTO dto) throws Exception {

        boolean exito = false;
        try {
            IInfoGrupoDAO info = Negocio.factory.obtenerInfo();
            exito = info.modificarDatos(dto);
        } catch (Exception ex) {
            ex.printStackTrace();
            throw ex;
        }
        return exito;
    }

    public ArrayList<InvestigadorDTO> consultarInv() throws Exception {
        ArrayList<InvestigadorDTO> exito = new ArrayList();
        IInvestigadorDAO ex = Negocio.factory.obtenerInvestigador();
        try {
            exito = (ArrayList<InvestigadorDTO>) ex.listarInvestigadores();
        } catch (Exception p) {
            p.printStackTrace();
            throw p;
        }
        return exito;
    }

    public boolean desactivarInvestigadores(ArrayList<InvestigadorDTO> inv) throws Exception {
        int exito = 0;
        IInvestigadorDAO ex = Negocio.factory.obtenerInvestigador();
        try {
            for (InvestigadorDTO est : inv) {
                exito = ex.eliminarInvestigador(est);

            }
        } catch (Exception p) {
            return false;
        }
        return true;

    }

    //METODOS DE ADMINISTRADOR
    public ArrayList<InvestigadorDTO> listarInvPendientes() throws Exception {
        IInvestigadorDAO ex = Negocio.factory.obtenerInvestigador();
        return (ArrayList<InvestigadorDTO>) ex.listarInvPenditenes();
    }

    public boolean aceptarInvestigadores(String inv[]) throws Exception {
        IPublicacionDAO p = Negocio.factory.obtenerPublicacion();
        String aux[];
        InvestigadorDTO in = new InvestigadorDTO();
        if (inv != null) {
            for (int j = 0; j < inv.length; j++) {
                aux = inv[j].split("-");
                in.setNumDoc(aux[0]);
                in.setTipoDoc(aux[1]);
                p.aceptarInvestigadores(in);
            }
        }
        return true;
    }

    public boolean eliminarInvestigadores(String inv[]) throws Exception {
        IPublicacionDAO p = Negocio.factory.obtenerPublicacion();
        String aux[];
        InvestigadorDTO in = new InvestigadorDTO();
        if (inv != null) {
            for (int j = 0; j < inv.length; j++) {
                aux = inv[j].split("-");
                in.setNumDoc(aux[0]);
                in.setTipoDoc(aux[1]);
                p.rechazarInvestigadores(in);
            }
        }
        return true;
    }

    public ArrayList<String> listaProyectosPublicados() throws Exception {
        IPublicacionDAO dao = Negocio.factory.obtenerPublicacion();
        return (ArrayList<String>) dao.listarProyectosPublicados();
    }

    public boolean desactivarProyectos(String proyectos[]) throws Exception {
        IPublicacionDAO p = Negocio.factory.obtenerPublicacion();
        if (proyectos != null) {
            for (int j = 0; j < proyectos.length; j++) {
                p.desactivarProyectos(proyectos[j]);
            }
        }

        return true;
    }

    public ArrayList<String> listarProyectosPublicadosString() throws Exception {
        IProyectoInvestigadorDAO pro = Negocio.factory.obtenerProyectoInvestigador();
        try {
            return (ArrayList<String>) pro.listarProyectosPublicadosString();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return null;
    }

    public ArrayList<ProyectoDTO> listarProyectosPublicados() throws Exception {
        IProyectoInvestigadorDAO pro = Negocio.factory.obtenerProyectoInvestigador();
        try {
            return (ArrayList<ProyectoDTO>) pro.listarProyectosPublicados();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return null;
    }

    public boolean registrarNoticia(NoticiaDTO noticia) throws Exception {
        boolean exito = false;
        try {
            INoticiaDAO noticiaDAO = Negocio.factory.obtenerNoticia();
            exito = noticiaDAO.registrarNoticia(noticia);
        } catch (Exception ex) {
            ex.printStackTrace();
            throw ex;
        }
        return exito;
    }

    public ArrayList<NoticiaDTO> listarNoticias() throws Exception {
        ArrayList<NoticiaDTO> noticias = null;
        try {
            INoticiaDAO noticiaDAO = Negocio.factory.obtenerNoticia();
            noticias = (ArrayList<NoticiaDTO>) noticiaDAO.listarNoticias();
        } catch (Exception ex) {
            ex.printStackTrace();
            throw ex;
        }

        return noticias;
    }

    public boolean eliminarNoticia(long idNoticia) throws Exception {
        boolean exito = false;
        try {
            INoticiaDAO noticiaDAO = Negocio.factory.obtenerNoticia();
            exito = noticiaDAO.eliminarNoticia(idNoticia);
        } catch (Exception ex) {
            ex.printStackTrace();
            throw ex;
        }
        return exito;
    }

    public boolean eliminarNoticias(ArrayList<Long> noticias) throws Exception {
        boolean exito = false;
        try {
            INoticiaDAO noticiaDAO = Negocio.factory.obtenerNoticia();
            exito = noticiaDAO.eliminarNoticias(noticias);
        } catch (Exception ex) {
            ex.printStackTrace();
            throw ex;
        }
        return exito;
    }

    public boolean registrarEvento(EventoDTO evento) throws Exception {
        boolean exito = false;
        try {
            IEventoDAO eventoDAO = Negocio.factory.obtenerEvento();
            exito = eventoDAO.registrarEvento(evento);
        } catch (Exception ex) {
            ex.printStackTrace();
            throw ex;
        }
        return exito;
    }

    public ArrayList<EventoDTO> listarEventos() throws Exception {
        ArrayList<EventoDTO> eventos = null;
        try {
            IEventoDAO eventoDAO = Negocio.factory.obtenerEvento();
            eventos = eventoDAO.listarEventos();
        } catch (Exception ex) {
            ex.printStackTrace();
            throw ex;
        }

        return eventos;
    }

    public ArrayList<EventoDTO> listarEventosPorFecha(String fecha) throws Exception {
        ArrayList<EventoDTO> eventos = null;
        try {
            IEventoDAO eventoDAO = Negocio.factory.obtenerEvento();
            eventos = eventoDAO.listarEventosPorFecha(fecha);
        } catch (Exception ex) {
            ex.printStackTrace();
            throw ex;
        }

        return eventos;
    }

    public boolean eliminarEventos(ArrayList<Long> eventos) throws Exception {
        boolean exito = false;
        try {
            IEventoDAO eventoDAO = Negocio.factory.obtenerEvento();
            exito = eventoDAO.eliminarEventos(eventos);
        } catch (Exception ex) {
            ex.printStackTrace();
            throw ex;
        }
        return exito;
    }

    public EventoDTO getEvento(long idEvento) throws Exception {
        EventoDTO evento = null;

        try {
            IEventoDAO eventoDAO = Negocio.factory.obtenerEvento();
            evento = eventoDAO.getEvento(idEvento);
        } catch (Exception ex) {
            ex.printStackTrace();
            throw ex;
        }

        return evento;
    }

    public InfoGrupoDTO consultarInfo() throws Exception {
        InfoGrupoDTO info = null;
        IInfoGrupoDAO ex = Negocio.factory.obtenerInfo();
        try {

            info = ex.listarInfo();
        } catch (Exception p) {
            p.printStackTrace();
            throw p;
        }
        return info;
    }

    public boolean registrarArticulo(ArticuloDTO art, String investigadoresString) throws Exception {

        IArticuloDAO artDAO = Negocio.factory.obtenerArticulo();
        ArrayList<InvestigadorDTO> investigadores;
        InvestigadorDTO investigador;
        JsonArray jsonArray;
        Gson gson = new Gson();
        String tipoDoc, numDoc;

        jsonArray = gson.fromJson(investigadoresString, JsonArray.class);
        investigadores = new ArrayList<>(0);

        for (JsonElement jsonElement : jsonArray) {
            tipoDoc = jsonElement.getAsJsonObject().get("tipoDoc").getAsString();
            numDoc = jsonElement.getAsJsonObject().get("numDoc").getAsString();
            investigador = new InvestigadorDTO();
            investigador.setTipoDoc(tipoDoc);
            investigador.setNumDoc(numDoc);
            investigadores.add(investigador);
        }

        return artDAO.insertarArticulo(art, investigadores);
    }

    public boolean eliminarArticulo(long id) throws Exception {

        boolean exito = false;

        try {
            IArticuloDAO artDAO = Negocio.factory.obtenerArticulo();
            exito = artDAO.eliminarArticulo(id);
        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        }
        return exito;
    }

    public ArticuloDTO getArticulo(long id) throws Exception {

        ArticuloDTO art = null;

        try {
            IArticuloDAO artDAO = Negocio.factory.obtenerArticulo();
            art = artDAO.getArticulo(id);
        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        }
        return art;
    }

    public ArrayList<ArticuloDTO> listarArticulos() throws Exception {
        IArticuloDAO artDAO = Negocio.factory.obtenerArticulo();
        return (ArrayList<ArticuloDTO>) artDAO.listarArticulos();
    }

    public ArrayList<ArticuloDTO> filtrarArticulos(String filtro) throws Exception {

        ArrayList<ArticuloDTO> articulos = new ArrayList();

        try {
            IArticuloDAO artDAO = Negocio.factory.obtenerArticulo();
            articulos = (ArrayList<ArticuloDTO>) artDAO.busquedaFiltrada(filtro);
        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        }

        return articulos;
    }

    public ArrayList<ArticuloDTO> listarArticulosPorInv(InvestigadorDTO inv) throws Exception, ParseException {

        ArrayList<ArticuloDTO> articulos = new ArrayList();

        try {
            IArticuloDAO artDAO = Negocio.factory.obtenerArticulo();
            articulos = (ArrayList<ArticuloDTO>) artDAO.listarArticulosPorInv(inv);
        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        }

        return articulos;
    }

    public boolean registrarPonencia(ProyectoDTO proyecto, PonenciaDTO pon,
            ArrayList<InvestigadorDTO> investigadores) throws Exception {

        boolean exito = false;

        try {
            IPonenciaDAO ponDAO = Negocio.factory.obtenerPonencia();
            exito = ponDAO.insertarPonencia(proyecto.getTitulo(), pon, investigadores);
        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        }
        return exito;
    }

    public boolean eliminarPonencia(long id) throws Exception {

        boolean exito = false;

        try {
            IPonenciaDAO ponDAO = Negocio.factory.obtenerPonencia();
            exito = ponDAO.eliminarPonencia(id);
        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        }
        return exito;
    }

    public PonenciaDTO getPonencia(long id) throws Exception, ParseException {

        PonenciaDTO pon = null;

        try {
            IPonenciaDAO ponDAO = Negocio.factory.obtenerPonencia();
            pon = ponDAO.getPonencia(id);
        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        }
        return pon;
    }

    public ArrayList<PonenciaDTO> listarPonencias() throws Exception {
        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
    }

    public ArrayList<PonenciaDTO> filtrarPonencias(String filtro) throws Exception {

        ArrayList<PonenciaDTO> ponencias = new ArrayList();

        try {
            IPonenciaDAO poDAO = Negocio.factory.obtenerPonencia();
            ponencias = (ArrayList<PonenciaDTO>) poDAO.busquedaFiltrada(filtro);
        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        }

        return ponencias;
    }

    public ArrayList<PonenciaDTO> listarPonenciasPorInv(InvestigadorDTO inv) throws Exception, ParseException {

        ArrayList<PonenciaDTO> ponencias = new ArrayList();

        try {
            IPonenciaDAO ponDAO = Negocio.factory.obtenerPonencia();
            ponencias = (ArrayList<PonenciaDTO>) ponDAO.listarPonenciasPorInv(inv);
        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        }

        return ponencias;
    }

    public String obtenerCantidadMensualPorInv(int mes, InvestigadorDTO inv) throws Exception {

        String msg = "";

        try {
            IProductoDAO pDAO = Negocio.factory.obtenerProducto();
            msg = pDAO.cantidadPorMes(mes, inv);
        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        }

        return msg;
    }

    public String getConteoMensual(int mes, InvestigadorDTO inv) throws Exception {

        String msg = "";

        try {
            IProductoDAO pDAO = Negocio.factory.obtenerProducto();
            msg = pDAO.getConteoMensual(mes, inv);
        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        }

        return msg;
    }

    public boolean aceptarProductos(String[] p) throws Exception {

        boolean exito = false;

        try {
            IPublicacionDAO pDAO = Negocio.factory.obtenerPublicacion();
            exito = pDAO.aceptarProductos(p);
        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        }
        return exito;
    }

    public boolean rechazarProductos(String[] p) throws Exception {

        boolean exito = false;

        try {
            IPublicacionDAO pDAO = Negocio.factory.obtenerPublicacion();
            exito = pDAO.rechazarProductos(p);
        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        }
        return exito;
    }

    public ArrayList<String> listarProductosEnEspera() throws Exception {

        ArrayList<String> productos = new ArrayList();

        try {
            IProductoDAO pDAO = Negocio.factory.obtenerProducto();
            productos = pDAO.listarProductosEnEspera();
        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        }

        return productos;
    }

    public boolean registrarSoftware(ProyectoDTO proyecto, SoftwareDTO soft,
            ArrayList<InvestigadorDTO> investigadores) throws Exception, ParseException {

        boolean exito = false;

        try {
            ISoftwareDAO softDAO = Negocio.factory.obtenerSoftware();
            exito = softDAO.insertarSoftware(proyecto.getTitulo(), soft, investigadores);
        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        }

        return exito;
    }

    public ArrayList<SoftwareDTO> filtrarSoftwares(String filtro) throws Exception {

        ArrayList<SoftwareDTO> softwares = new ArrayList();

        try {
            ISoftwareDAO soDAO = Negocio.factory.obtenerSoftware();
            softwares = soDAO.busquedaFiltrada(filtro);
        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        }

        return softwares;
    }

    public ArrayList<InvestigadorDTO> listarInvestigadores() throws Exception {
        IInvestigadorDAO investigadorDao = Negocio.factory.obtenerInvestigador();
        return (ArrayList<InvestigadorDTO>) investigadorDao.listarInvestigadores();
    }

    public ArrayList<LineasInvestigacionDTO> listarLineas() throws Exception {
        ILineasInvestigacionDAO lineasDao = Negocio.factory.obtenerLineas();
        return (ArrayList<LineasInvestigacionDTO>) lineasDao.listarLineas();
    }

    public NoticiaDTO getNoticia(long idNoticia) throws Exception {
        INoticiaDAO noticiaDao = Negocio.factory.obtenerNoticia();
        return noticiaDao.getNoticia(idNoticia);
    }

    public boolean modificarNoticia(NoticiaDTO noticia) throws Exception {
        INoticiaDAO noticiaDao = Negocio.factory.obtenerNoticia();
        return noticiaDao.modificarNoticia(noticia);
    }

    public EstudioDTO consultarEstudioPorId(long idEstudio) throws Exception {
        IEstudioDAO estudioDao = Negocio.factory.obtenerEstudio();
        return estudioDao.consultarEstudioPorId(idEstudio);
    }

    public boolean modificarEstudio(EstudioDTO estudio) throws Exception {
        IEstudioDAO estudioDao = Negocio.factory.obtenerEstudio();
        return estudioDao.modificarEstudio(estudio);
    }

    public TipoProductoDTO consultarTipoDeProductoPorId(long id) throws Exception {
        ITipoProducto tipoProductoDao = Negocio.factory.obtenerTipoProductoDao();
        return tipoProductoDao.getTipoDeProducto(id);
    }

    public ArrayList<TipoProductoDTO> listarTiposDeProducto() throws Exception {
        ITipoProducto tipoProductoDao = Negocio.factory.obtenerTipoProductoDao();
        return (ArrayList<TipoProductoDTO>) tipoProductoDao.listarTiposDeProducto();
    }

    public String subirArchivo(Part part, String ruta, String nombreASubir, short tipoArchivo) throws IOException {

        String extension, nombreArchivo;
        OutputStream out = null;
        InputStream filecontent = null;
        File imagen, parent;
        boolean exito;
        int read;

        try {
            nombreArchivo = extractFileName(part);
            int num = nombreArchivo.indexOf(".");
            extension = nombreArchivo.substring(num, nombreArchivo.length());
            System.out.println(extension);
            if (getTiposDeArchivoValidos(tipoArchivo).contains(extension)) {
                imagen = new File(ruta);

                if (!imagen.exists()) {
                    imagen.mkdirs();
                }

                imagen = new File(ruta + File.separator + nombreArchivo);
                out = new FileOutputStream(new File(ruta + File.separator + nombreArchivo));

                filecontent = part.getInputStream();

                final byte[] bytes = new byte[1024];

                while ((read = filecontent.read(bytes)) != -1) {
                    out.write(bytes, 0, read);
                }
                filecontent.close();
                out.close();
                parent = imagen.getParentFile();

                System.out.println(ruta);

                nombreArchivo = Encriptador.encriptar(nombreASubir);
                nombreArchivo = nombreArchivo + extension;

                exito = imagen.renameTo(new File(parent, nombreArchivo));

                if (!exito) {
                    imagen.delete();
                    throw new IOException("No se pudo cargar el archivo");
                }
            } else {
                throw new IOException("Tipo de archivo no vlido");
            }
        } catch (IOException ex) {
            ex.printStackTrace();
            throw ex;
        } finally {
            if (out != null) {
                out.close();
            }
            if (filecontent != null) {
                filecontent.close();
            }
        }
        System.out.println(ruta + "/" + nombreArchivo);
        return nombreArchivo;
    }

    /**
     * Metodo que define los tipos de archivo a cargar en el sistema dependiendo
     * del documento en cuestin
     *
     * @param tipoArchivoASubir tipo de archivo a subir 1. Soporte 2. Foto
     * @return hashset de tipos de archivo validos a cargar al servidor o null
     * si el documento no es valido
     */
    private HashSet<String> getTiposDeArchivoValidos(short tipoArchivoASubir) {

        HashSet<String> tiposValidos;

        switch (tipoArchivoASubir) {
        case 1:
            tiposValidos = new HashSet<>(0);
            tiposValidos.add(".pdf");
            tiposValidos.add(".jpg");
            tiposValidos.add(".png");
            tiposValidos.add(".PDF");
            tiposValidos.add(".JPG");
            tiposValidos.add(".PNG");
            return tiposValidos;
        case 2:
            tiposValidos = new HashSet<>(0);
            tiposValidos.add(".jpg");
            tiposValidos.add(".png");
            tiposValidos.add(".JPG");
            tiposValidos.add(".PNG");
            return tiposValidos;
        default:
            return null;
        }
    }

    private String extractFileName(Part part) {
        String contentDisp = part.getHeader("content-disposition");
        String[] items = contentDisp.split(";");
        for (String s : items) {
            if (s.trim().startsWith("filename")) {
                return s.substring(s.indexOf("=") + 2, s.length() - 1);
            }
        }
        return "";
    }

    public boolean registrarPonencia(PonenciaDTO ponencia, String investigadoresString) throws Exception {

        IPonenciaDAO ponenciaDao = Negocio.factory.obtenerPonencia();
        ArrayList<InvestigadorDTO> investigadores;
        InvestigadorDTO investigador;
        JsonArray jsonArray;
        Gson gson = new Gson();
        String tipoDoc, numDoc;

        jsonArray = gson.fromJson(investigadoresString, JsonArray.class);
        investigadores = new ArrayList<>(0);

        for (JsonElement jsonElement : jsonArray) {
            tipoDoc = jsonElement.getAsJsonObject().get("tipoDoc").getAsString();
            numDoc = jsonElement.getAsJsonObject().get("numDoc").getAsString();
            investigador = new InvestigadorDTO();
            investigador.setTipoDoc(tipoDoc);
            investigador.setNumDoc(numDoc);
            investigadores.add(investigador);
        }

        return ponenciaDao.registrarPonencia(ponencia, investigadores);
    }

    public PaisDTO buscarPaisPorId(int idPais) throws Exception {
        IPaisDAO paisDao = Negocio.factory.obtenerPais();
        return paisDao.buscarPaisPorId(idPais);
    }

    public ArrayList<PaisDTO> listarPaises() throws Exception {
        IPaisDAO paisDao = Negocio.factory.obtenerPais();
        return (ArrayList<PaisDTO>) paisDao.listarPaises();
    }

    public CiudadDTO buscarCiudadPorId(long idCiudad) throws Exception {
        ICiudadDAO ciudadDao = Negocio.factory.obtenerCiudad();
        return ciudadDao.buscarCiudadPorId(idCiudad);
    }

    public ArrayList<CiudadDTO> listarCiudades() throws Exception {
        ICiudadDAO ciudadDao = Negocio.factory.obtenerCiudad();
        return (ArrayList<CiudadDTO>) ciudadDao.listarCiudades();
    }

    public SoftwareDTO buscarSoftwarePorId(long idSoftware) throws Exception {
        ISoftwareDAO softwareDao = Negocio.factory.obtenerSoftware();
        return softwareDao.buscarSoftwarePorId(idSoftware);
    }

    public ArrayList<SoftwareDTO> listarSoftwares() throws Exception {
        ISoftwareDAO softwareDao = Negocio.factory.obtenerSoftware();
        return softwareDao.listarSoftwares();
    }

    public boolean registrarSoftware(SoftwareDTO software, String investigadoresString) throws Exception {

        ISoftwareDAO softwareDao = Negocio.factory.obtenerSoftware();
        ArrayList<InvestigadorDTO> investigadores;
        InvestigadorDTO investigador;
        JsonArray jsonArray;
        Gson gson = new Gson();
        String tipoDoc, numDoc;

        jsonArray = gson.fromJson(investigadoresString, JsonArray.class);
        investigadores = new ArrayList<>(0);

        for (JsonElement jsonElement : jsonArray) {
            tipoDoc = jsonElement.getAsJsonObject().get("tipoDoc").getAsString();
            numDoc = jsonElement.getAsJsonObject().get("numDoc").getAsString();
            investigador = new InvestigadorDTO();
            investigador.setTipoDoc(tipoDoc);
            investigador.setNumDoc(numDoc);
            investigadores.add(investigador);
        }

        return softwareDao.registrarSoftware(software, investigadores);
    }

    public ProductoDTO buscarProductoPorId(long id) throws Exception {
        IProductoDAO productoDao = Negocio.factory.obtenerProducto();
        return productoDao.buscarProductoPorId(id);
    }

    public ArrayList<ProductoDTO> listarProductosPorProyectoPorInvestigador(InvestigadorDTO inv, String tituloproy)
            throws Exception {
        IProductoDAO productoDao = Negocio.factory.obtenerProducto();
        return productoDao.listarProductosPorInvestigadorYProyecto(inv, tituloproy);
    }

    public ArrayList<ProductoDTO> listarProductosPorAprobar() throws Exception {
        IProductoDAO productoDao = Negocio.factory.obtenerProducto();
        return productoDao.listarProductosPorAprobar();
    }

    public boolean registrarProducto(ProductoDTO producto, String investigadoresString) throws Exception {

        IProductoDAO productoDao = Negocio.factory.obtenerProducto();
        ArrayList<InvestigadorDTO> investigadores;
        InvestigadorDTO investigador;
        JsonArray jsonArray;
        Gson gson = new Gson();
        String tipoDoc, numDoc;

        jsonArray = gson.fromJson(investigadoresString, JsonArray.class);
        investigadores = new ArrayList<>(0);

        for (JsonElement jsonElement : jsonArray) {
            tipoDoc = jsonElement.getAsJsonObject().get("tipoDoc").getAsString();
            numDoc = jsonElement.getAsJsonObject().get("numDoc").getAsString();
            investigador = new InvestigadorDTO();
            investigador.setTipoDoc(tipoDoc);
            investigador.setNumDoc(numDoc);
            investigadores.add(investigador);
        }

        return productoDao.registrarProducto(producto, investigadores);
    }

    public LineasInvestigacionDTO buscarLineaPorNombre(String nombreLinea) throws Exception {
        ILineasInvestigacionDAO lineaDao = factory.obtenerLineas();
        return lineaDao.getLinea(new LineasInvestigacionDTO(nombreLinea, null, null));
    }

    public ArrayList<ProyectoDTO> listarProyectosDondeParticipa(InvestigadorDTO dto) throws Exception {
        IProyectoInvestigadorDAO inve = Negocio.factory.obtenerProyectoInvestigador();
        return (ArrayList<ProyectoDTO>) inve.listarProyectosDondeParticipa(dto);
    }

    public boolean cambiarEstadoAVariosProyectos(String jsonString) throws Exception {

        ArrayList<ProyectoDTO> proyectos;
        ProyectoDTO proyecto;
        JsonArray jsonArray;
        Gson gson = new Gson();
        String tituloProyecto;
        int estado;
        IProyectoDAO proyectoDao;
        jsonArray = gson.fromJson(jsonString, JsonArray.class);
        proyectos = new ArrayList<>(0);

        for (JsonElement jsonElement : jsonArray) {
            tituloProyecto = jsonElement.getAsJsonObject().get("titulo").getAsString();
            estado = jsonElement.getAsJsonObject().get("estado").getAsInt();
            proyecto = new ProyectoDTO();
            proyecto.setTitulo(tituloProyecto);
            proyecto.setEstado(estado);
            proyectos.add(proyecto);
        }

        proyectoDao = factory.obtenerProyecto();
        return proyectoDao.cambiarEstadoAVarios(proyectos);
    }

    public boolean eliminarNoticias(String jsonIds) throws Exception {
        ArrayList<Long> idsNoticias;
        JsonArray jsonArray;
        Gson gson = new Gson();
        INoticiaDAO noticiaDao;
        jsonArray = gson.fromJson(jsonIds, JsonArray.class);
        idsNoticias = new ArrayList<>(0);

        for (JsonElement jsonElement : jsonArray) {
            idsNoticias.add(jsonElement.getAsJsonObject().get("id").getAsLong());
        }

        noticiaDao = factory.obtenerNoticia();
        return noticiaDao.eliminarNoticias(idsNoticias);
    }
}