@Transactional
  @RequestMapping(value = "/elimina", method = RequestMethod.POST)
  public String elimina(
      HttpServletRequest request,
      @RequestParam Long id,
      Model modelo,
      @ModelAttribute Almacen almacen,
      BindingResult bindingResult,
      RedirectAttributes redirectAttributes) {
    log.debug("Elimina almacen");
    try {
      Long empresaId = (Long) request.getSession().getAttribute("empresaId");
      String nombre = almacenDao.elimina(id, empresaId);

      ambiente.actualizaSesion(request);

      redirectAttributes.addFlashAttribute("message", "almacen.eliminado.message");
      redirectAttributes.addFlashAttribute("messageAttrs", new String[] {nombre});
    } catch (UltimoException e) {
      log.error("No se pudo eliminar el almacen " + id, e);
      bindingResult.addError(
          new ObjectError(
              "almacen", new String[] {"ultimo.almacen.no.eliminado.message"}, null, null));
      return "inventario/almacen/ver";
    } catch (Exception e) {
      log.error("No se pudo eliminar la almacen " + id, e);
      bindingResult.addError(
          new ObjectError("almacen", new String[] {"almacen.no.eliminado.message"}, null, null));
      return "inventario/almacen/ver";
    }

    return "redirect:/inventario/almacen";
  }
  @Transactional
  @RequestMapping(value = "/actualiza", method = RequestMethod.POST)
  public String actualiza(
      HttpServletRequest request,
      @Valid Almacen almacen,
      BindingResult bindingResult,
      Errors errors,
      Model modelo,
      RedirectAttributes redirectAttributes) {
    if (bindingResult.hasErrors()) {
      log.error("Hubo algun error en la forma, regresando");
      for (ObjectError error : bindingResult.getAllErrors()) {
        log.debug("Error: {}", error);
      }
      return "inventario/almacen/edita";
    }

    try {
      Usuario usuario = ambiente.obtieneUsuario();
      almacen = almacenDao.actualiza(almacen, usuario);

      ambiente.actualizaSesion(request, usuario);
    } catch (ConstraintViolationException e) {
      log.error("No se pudo crear la almacen", e);
      errors.rejectValue("nombre", "campo.duplicado.message", new String[] {"nombre"}, null);
      return "inventario/almacen/edita";
    }

    redirectAttributes.addFlashAttribute("message", "almacen.actualizado.message");
    redirectAttributes.addFlashAttribute("messageAttrs", new String[] {almacen.getNombre()});

    return "redirect:/inventario/almacen/ver/" + almacen.getId();
  }
示例#3
0
  @RequestMapping("/pendiente/{id}")
  public String pendiente(
      HttpServletRequest request, @PathVariable Long id, RedirectAttributes redirectAttributes) {
    log.debug("Poniendo pendiente a entrada {}", id);
    try {
      String folio = entradaDao.pendiente(id, ambiente.obtieneUsuario());
      redirectAttributes.addFlashAttribute("message", "entrada.pendiente.message");
      redirectAttributes.addFlashAttribute("messageAttrs", new String[] {folio});
    } catch (NoEstaAbiertaException e) {
      log.error("No se pudo cerrar la entrada", e);
      redirectAttributes.addFlashAttribute("message", "entrada.intento.modificar.cerrada.message");
      redirectAttributes.addFlashAttribute("messageStyle", "alert-error");
      redirectAttributes.addFlashAttribute("messageAttrs", new String[] {""});
    } catch (NoSePuedeCerrarEnCeroException e) {
      log.error("No se pudo poner en pendiente la entrada", e);
      redirectAttributes.addFlashAttribute("message", "entrada.no.cerrada.en.cero.message");
      redirectAttributes.addFlashAttribute("messageStyle", "alert-error");
    } catch (NoCuadraException e) {
      log.error("No se pudo poner en pendiente la entrada", e);
      redirectAttributes.addFlashAttribute("message", "entrada.no.cuadra.message");
      redirectAttributes.addFlashAttribute("messageStyle", "alert-error");
    } catch (NoSePuedeCerrarException e) {
      log.error("No se pudo poner en pendiente la entrada", e);
      redirectAttributes.addFlashAttribute("message", "entrada.no.pendiente.message");
      redirectAttributes.addFlashAttribute("messageStyle", "alert-error");
    }

    return "redirect:/inventario/entrada/ver/" + id;
  }
  private void enviaCorreo(String tipo, List<Almacen> almacenes, HttpServletRequest request)
      throws JRException, MessagingException {
    log.debug("Enviando correo {}", tipo);
    byte[] archivo = null;
    String tipoContenido = null;
    switch (tipo) {
      case "PDF":
        archivo = generaPdf(almacenes);
        tipoContenido = "application/pdf";
        break;
      case "CSV":
        archivo = generaCsv(almacenes);
        tipoContenido = "text/csv";
        break;
      case "XLS":
        archivo = generaXls(almacenes);
        tipoContenido = "application/vnd.ms-excel";
    }

    MimeMessage message = mailSender.createMimeMessage();
    MimeMessageHelper helper = new MimeMessageHelper(message, true);
    helper.setTo(ambiente.obtieneUsuario().getUsername());
    String titulo = messageSource.getMessage("almacen.lista.label", null, request.getLocale());
    helper.setSubject(
        messageSource.getMessage(
            "envia.correo.titulo.message", new String[] {titulo}, request.getLocale()));
    helper.setText(
        messageSource.getMessage(
            "envia.correo.contenido.message", new String[] {titulo}, request.getLocale()),
        true);
    helper.addAttachment(titulo + "." + tipo, new ByteArrayDataSource(archivo, tipoContenido));
    mailSender.send(message);
  }
  @Transactional
  @RequestMapping(value = "/graba", method = RequestMethod.POST)
  public String graba(
      HttpServletRequest request,
      HttpServletResponse response,
      @Valid AlumnoPaquete alumnoPaquete,
      BindingResult bindingResult,
      Errors errors,
      Model modelo,
      RedirectAttributes redirectAttributes) {
    for (String matricula : request.getParameterMap().keySet()) {
      log.debug("Param: {} : {}", matricula, request.getParameterMap().get(matricula));
    }
    if (bindingResult.hasErrors()) {
      log.debug("Hubo algun error en la forma, regresando");
      Map<String, Object> params = new HashMap<>();
      params.put("empresa", request.getSession().getAttribute("empresaId"));
      return Constantes.PATH_ALUMNOPAQUETE_NUEVO;
    }

    try {
      AlumnoPaquete tmp = null;
      Usuario usuario = ambiente.obtieneUsuario();

      if (alumnoPaquete.getId() != null) {
        tmp = alumnoPaqueteManager.obtiene(alumnoPaquete.getId());
        tmp.setPaquete(paqueteDao.obtiene(alumnoPaquete.getPaquete().getId()));
        tmp.setMatricula(alumnoPaquete.getMatricula());
        tmp.setStatus(alumnoPaquete.getStatus());
        alumnoPaqueteManager.graba(tmp, usuario);
        redirectAttributes.addFlashAttribute(
            Constantes.CONTAINSKEY_MESSAGE, "alumnoPaquete.actualizado.message");
        redirectAttributes.addFlashAttribute(
            Constantes.CONTAINSKEY_MESSAGE_ATTRS, new String[] {alumnoPaquete.getMatricula()});
      } else {
        alumnoPaquete.setPaquete(paqueteDao.obtiene(alumnoPaquete.getPaquete().getId()));
        alumnoPaqueteManager.graba(alumnoPaquete, usuario);
        redirectAttributes.addFlashAttribute(
            Constantes.CONTAINSKEY_MESSAGE, "alumnoPaquete.creado.message");
        redirectAttributes.addFlashAttribute(
            Constantes.CONTAINSKEY_MESSAGE_ATTRS, new String[] {alumnoPaquete.getMatricula()});
      }

    } catch (ConstraintViolationException e) {
      log.error("No se pudo crear el tipo de Beca", e);
      return Constantes.PATH_ALUMNOPAQUETE_NUEVO;
    }

    return "redirect:/" + Constantes.PATH_ALUMNOPAQUETE_LISTA + "/";
  }
示例#6
0
  @RequestMapping(value = "/pendiente/cerrar", method = RequestMethod.POST)
  public String cerrarPendiente(
      HttpServletRequest request,
      @ModelAttribute Entrada entrada,
      RedirectAttributes redirectAttributes) {
    log.debug("Cierra entrada {}", entrada.getFolio());
    try {
      entrada = entradaDao.cierraPendiente(entrada, ambiente.obtieneUsuario());
      redirectAttributes.addFlashAttribute("message", "entrada.cerrada.message");
      redirectAttributes.addFlashAttribute("messageAttrs", new String[] {entrada.getFolio()});
    } catch (NoSePuedeCerrarException e) {
      log.error("No se pudo cerrar la entrada", e);
      redirectAttributes.addFlashAttribute("message", "entrada.no.cerrada.message");
      redirectAttributes.addFlashAttribute("messageStyle", "alert-error");
    }

    return "redirect:/inventario/entrada/ver/" + entrada.getId();
  }
示例#7
0
  @Transactional
  @RequestMapping(value = "/actualiza", method = RequestMethod.POST)
  public String actualiza(
      HttpServletRequest request,
      @Valid Entrada entrada,
      BindingResult bindingResult,
      Errors errors,
      Model modelo,
      RedirectAttributes redirectAttributes) {
    if (bindingResult.hasErrors()) {
      log.error("Hubo algun error en la forma, regresando");
      return "inventario/entrada/edita";
    }

    try {
      Usuario usuario = ambiente.obtieneUsuario();
      if (request.getParameter("proveedor.id") == null) {
        log.warn("No se puede crear la entrada si no ha seleccionado un proveedor");
        errors.rejectValue("proveedor", "entrada.sin.proveedor.message");
        return "inventario/entrada/nueva";
      }
      Proveedor proveedor = proveedorDao.obtiene(new Long(request.getParameter("proveedor.id")));
      entrada.setProveedor(proveedor);
      entrada = entradaDao.actualiza(entrada, usuario);
    } catch (NoEstaAbiertaException e) {
      log.error("No se pudo actualizar la entrada", e);
      modelo.addAttribute("message", "entrada.intento.modificar.cerrada.message");
      modelo.addAttribute("messageStyle", "alert-error");
      modelo.addAttribute("messageAttrs", new String[] {entrada.getFolio()});
      return "inventario/entrada/nueva";
    } catch (ConstraintViolationException e) {
      log.error("No se pudo crear la entrada", e);
      errors.rejectValue("factura", "campo.duplicado.message", new String[] {"factura"}, null);

      return "inventario/entrada/nueva";
    }

    redirectAttributes.addFlashAttribute("message", "entrada.actualizada.message");
    redirectAttributes.addFlashAttribute("messageAttrs", new String[] {entrada.getFolio()});

    return "redirect:/inventario/entrada/ver/" + entrada.getId();
  }
示例#8
0
  @Transactional
  @RequestMapping(value = "/crea", method = RequestMethod.POST)
  public String crea(
      HttpServletRequest request,
      HttpServletResponse response,
      @Valid Entrada entrada,
      BindingResult bindingResult,
      Errors errors,
      Model modelo,
      RedirectAttributes redirectAttributes) {
    for (String nombre : request.getParameterMap().keySet()) {
      log.debug("Param: {} : {}", nombre, request.getParameterMap().get(nombre));
    }
    if (bindingResult.hasErrors()) {
      log.debug("Hubo algun error en la forma, regresando");
      return "inventario/entrada/nueva";
    }

    try {
      Usuario usuario = ambiente.obtieneUsuario();
      if (request.getParameter("proveedor.id") == null) {
        log.warn("No se puede crear la entrada si no ha seleccionado un proveedor");
        errors.rejectValue("proveedor", "entrada.sin.proveedor.message");
        return "inventario/entrada/nueva";
      }
      Proveedor proveedor = proveedorDao.obtiene(new Long(request.getParameter("proveedor.id")));
      entrada.setProveedor(proveedor);
      entrada = entradaDao.crea(entrada, usuario);
    } catch (ConstraintViolationException e) {
      log.error("No se pudo crear la entrada", e);
      errors.rejectValue("factura", "campo.duplicado.message", new String[] {"factura"}, null);

      return "inventario/entrada/nueva";
    }

    redirectAttributes.addFlashAttribute("message", "entrada.creada.message");
    redirectAttributes.addFlashAttribute("messageAttrs", new String[] {entrada.getFolio()});

    return "redirect:/inventario/entrada/ver/" + entrada.getId();
  }
示例#9
0
  @RequestMapping
  public String lista(
      HttpServletRequest request,
      HttpServletResponse response,
      @RequestParam(required = false) String filtro,
      @RequestParam(required = false) Long pagina,
      @RequestParam(required = false) String tipo,
      @RequestParam(required = false) String correo,
      @RequestParam(required = false) String order,
      @RequestParam(required = false) String sort,
      Usuario usuario,
      Errors errors,
      Model modelo) {
    log.debug("Mostrando lista de tipos de entradas");
    Map<String, Object> params = new HashMap<>();
    params.put("almacen", request.getSession().getAttribute("almacenId"));
    if (StringUtils.isNotBlank(filtro)) {
      params.put("filtro", filtro);
    }
    if (pagina != null) {
      params.put("pagina", pagina);
      modelo.addAttribute("pagina", pagina);
    } else {
      pagina = 1L;
      modelo.addAttribute("pagina", pagina);
    }
    if (StringUtils.isNotBlank(order)) {
      params.put("order", order);
      params.put("sort", sort);
    }

    if (StringUtils.isNotBlank(tipo)) {
      params.put("reporte", true);
      params = entradaDao.lista(params);
      try {
        generaReporte(tipo, (List<Entrada>) params.get("entradas"), response);
        return null;
      } catch (JRException | IOException e) {
        log.error("No se pudo generar el reporte", e);
        params.remove("reporte");
        errors.reject("error.generar.reporte");
      }
    }

    if (StringUtils.isNotBlank(correo)) {
      params.put("reporte", true);
      params = entradaDao.lista(params);

      params.remove("reporte");
      try {
        enviaCorreo(correo, (List<Entrada>) params.get("entradas"), request);
        modelo.addAttribute("message", "lista.enviada.message");
        modelo.addAttribute(
            "messageAttrs",
            new String[] {
              messageSource.getMessage("entrada.lista.label", null, request.getLocale()),
              ambiente.obtieneUsuario().getUsername()
            });
      } catch (JRException | MessagingException e) {
        log.error("No se pudo enviar el reporte por correo", e);
      }
    }
    params = entradaDao.lista(params);
    modelo.addAttribute("entradas", params.get("entradas"));

    // inicia paginado
    Long cantidad = (Long) params.get("cantidad");
    Integer max = (Integer) params.get("max");
    Long cantidadDePaginas = cantidad / max;
    List<Long> paginas = new ArrayList<>();
    long i = 1;
    do {
      paginas.add(i);
    } while (i++ < cantidadDePaginas);
    List<Entrada> entradas = (List<Entrada>) params.get("entradas");
    Long primero = ((pagina - 1) * max) + 1;
    Long ultimo = primero + (entradas.size() - 1);
    String[] paginacion = new String[] {primero.toString(), ultimo.toString(), cantidad.toString()};
    modelo.addAttribute("paginacion", paginacion);
    modelo.addAttribute("paginas", paginas);
    // termina paginado

    return "inventario/entrada/lista";
  }
  @RequestMapping({"", "/lista"})
  public String lista(
      HttpServletRequest request,
      HttpServletResponse response,
      @RequestParam(required = false) String filtro,
      @RequestParam(required = false) Long pagina,
      @RequestParam(required = false) String tipo,
      @RequestParam(required = false) String correo,
      @RequestParam(required = false) String order,
      @RequestParam(required = false) String sort,
      Usuario usuario,
      Errors errors,
      Model modelo) {
    log.debug("Mostrando lista de tipos de Becas");
    Map<String, Object> params = new HashMap<>();
    Long empresaId = (Long) request.getSession().getAttribute("empresaId");
    params.put("empresa", empresaId);
    if (StringUtils.isNotBlank(filtro)) {
      params.put(Constantes.CONTAINSKEY_FILTRO, filtro);
    }
    if (pagina != null) {
      params.put(Constantes.CONTAINSKEY_PAGINA, pagina);
      modelo.addAttribute(Constantes.CONTAINSKEY_PAGINA, pagina);
    } else {
      pagina = 1L;
      modelo.addAttribute(Constantes.CONTAINSKEY_PAGINA, pagina);
    }
    if (StringUtils.isNotBlank(order)) {
      params.put(Constantes.CONTAINSKEY_ORDER, order);
      params.put(Constantes.CONTAINSKEY_SORT, sort);
    }

    if (StringUtils.isNotBlank(tipo)) {
      params.put(Constantes.CONTAINSKEY_REPORTE, true);
      params = alumnoPaqueteManager.lista(params);
      try {
        generaReporte(
            tipo,
            (List<AlumnoPaquete>) params.get(Constantes.CONTAINSKEY_ALUMNOPAQUETES),
            response);
        return null;
      } catch (JRException | IOException e) {
        log.error("No se pudo generar el reporte", e);
        params.remove(Constantes.CONTAINSKEY_REPORTE);
        // errors.reject("error.generar.reporte");
      }
    }

    if (StringUtils.isNotBlank(correo)) {
      params.put(Constantes.CONTAINSKEY_REPORTE, true);
      params = alumnoPaqueteManager.lista(params);

      params.remove(Constantes.CONTAINSKEY_REPORTE);
      try {
        enviaCorreo(
            correo,
            (List<AlumnoPaquete>) params.get(Constantes.CONTAINSKEY_ALUMNOPAQUETES),
            request);
        modelo.addAttribute(Constantes.CONTAINSKEY_MESSAGE, "lista.enviada.message");
        modelo.addAttribute(
            Constantes.CONTAINSKEY_MESSAGE_ATTRS,
            new String[] {
              messageSource.getMessage("alumnoPaquete.lista.label", null, request.getLocale()),
              ambiente.obtieneUsuario().getUsername()
            });
      } catch (JRException | MessagingException e) {
        log.error("No se pudo enviar el reporte por correo", e);
      }
    }
    params = alumnoPaqueteManager.lista(params);
    log.debug("params{}", params.get(Constantes.CONTAINSKEY_ALUMNOPAQUETES));
    modelo.addAttribute(
        Constantes.CONTAINSKEY_ALUMNOPAQUETES, params.get(Constantes.CONTAINSKEY_ALUMNOPAQUETES));

    // inicia paginado
    Long cantidad = (Long) params.get(Constantes.CONTAINSKEY_CANTIDAD);
    Integer max = (Integer) params.get(Constantes.CONTAINSKEY_MAX);
    Long cantidadDePaginas = cantidad / max;
    List<Long> paginas = new ArrayList<>();
    long i = 1;
    do {
      paginas.add(i);
    } while (i++ < cantidadDePaginas);
    List<AlumnoPaquete> alumnoPaquetes =
        (List<AlumnoPaquete>) params.get(Constantes.CONTAINSKEY_ALUMNOPAQUETES);
    Long primero = ((pagina - 1) * max) + 1;
    log.debug("primero {}", primero);
    Long ultimo = primero + (alumnoPaquetes.size() - 1);
    String[] paginacion = new String[] {primero.toString(), ultimo.toString(), cantidad.toString()};
    modelo.addAttribute(Constantes.CONTAINSKEY_PAGINACION, paginacion);
    log.debug("Paginacion{}", paginacion);
    modelo.addAttribute(Constantes.CONTAINSKEY_PAGINAS, paginas);
    log.debug("paginas{}", paginas);
    modelo.addAttribute(Constantes.CONTAINSKEY_PAGINA, pagina);
    log.debug("Pagina{}", pagina);
    // termina paginado

    return Constantes.PATH_ALUMNOPAQUETE_LISTA;
  }