Java tutorial
/* * 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); } }