Пример #1
0
 public FacturaAlmacen agregaSalida(Long facturaId, Long salidaId) {
   FacturaAlmacen factura = (FacturaAlmacen) currentSession().get(FacturaAlmacen.class, facturaId);
   Salida salida = (Salida) currentSession().load(Salida.class, salidaId);
   factura.getSalidas().add(salida);
   factura.setFechaModificacion(new Date());
   currentSession().save(factura);
   currentSession().flush();
   return factura;
 }
Пример #2
0
 public FacturaAlmacen agregaEntrada(Long facturaId, Long entradaId) {
   FacturaAlmacen factura = (FacturaAlmacen) currentSession().get(FacturaAlmacen.class, facturaId);
   Entrada entrada = (Entrada) currentSession().load(Entrada.class, entradaId);
   factura.getEntradas().add(entrada);
   factura.setFechaModificacion(new Date());
   currentSession().save(factura);
   currentSession().flush();
   return factura;
 }
Пример #3
0
 public FacturaAlmacen eliminaEntrada(Long facturaId, Long entradaId) {
   log.debug("Eliminando entrada {} de factura {}", entradaId, facturaId);
   FacturaAlmacen factura = (FacturaAlmacen) currentSession().get(FacturaAlmacen.class, facturaId);
   Entrada entrada = (Entrada) currentSession().load(Entrada.class, entradaId);
   factura.getEntradas().remove(entrada);
   factura.setFechaModificacion(new Date());
   currentSession().save(factura);
   currentSession().flush();
   return factura;
 }
Пример #4
0
 public FacturaAlmacen eliminaSalida(Long facturaId, Long salidaId) {
   log.debug("Eliminando salida {} de factura {}", salidaId, facturaId);
   FacturaAlmacen factura = (FacturaAlmacen) currentSession().get(FacturaAlmacen.class, facturaId);
   Salida salida = (Salida) currentSession().load(Salida.class, salidaId);
   log.debug("SalidasA: {}", factura.getSalidas());
   factura.getSalidas().remove(salida);
   log.debug("SalidasB: {}", factura.getSalidas());
   factura.setFechaModificacion(new Date());
   currentSession().save(factura);
   currentSession().flush();
   return factura;
 }
Пример #5
0
  public String elimina(Long id, Usuario usuario) throws NoEstaAbiertaException {
    FacturaAlmacen factura = obtiene(id);
    if (factura.getEstatus().getNombre().equals(Constantes.ABIERTA)) {
      String nombre = factura.getFolio();
      currentSession().delete(factura);
      audita(factura, usuario, Constantes.ELIMINAR, new Date());

      currentSession().flush();
      return nombre;
    } else {
      throw new NoEstaAbiertaException("No se puede eliminar una factura que no este abierta");
    }
  }
Пример #6
0
 private void audita(FacturaAlmacen factura, Usuario usuario, String actividad, Date fecha) {
   XFacturaAlmacen xfactura = new XFacturaAlmacen();
   BeanUtils.copyProperties(factura, xfactura);
   xfactura.setId(null);
   xfactura.setFacturaAlmacenId(factura.getId());
   xfactura.setAlmacenId(factura.getAlmacen().getId());
   xfactura.setClienteId(factura.getCliente().getId());
   xfactura.setEstatusId(factura.getEstatus().getId());
   xfactura.setFechaCreacion(fecha);
   xfactura.setActividad(actividad);
   xfactura.setCreador((usuario != null) ? usuario.getUsername() : "sistema");
   currentSession().save(xfactura);
 }
Пример #7
0
  public FacturaAlmacen cancelar(Long id, Usuario usuario)
      throws NoEstaCerradaException, NoSePuedeCancelarException {
    FacturaAlmacen factura = (FacturaAlmacen) currentSession().get(FacturaAlmacen.class, id);
    if (factura != null) {
      if (factura.getEstatus().getNombre().equals(Constantes.CERRADA)) {
        Query query =
            currentSession().createQuery("select e from Estatus e where e.nombre = :nombre");
        query.setString("nombre", Constantes.CERRADA);
        Estatus cerrada = (Estatus) query.uniqueResult();

        Date fecha = new Date();
        for (Entrada entrada : factura.getEntradas()) {
          entrada.setEstatus(cerrada);
          entrada.setFechaModificacion(fecha);
          currentSession().update(entrada);

          audita(entrada, usuario, Constantes.ACTUALIZAR, fecha);
        }

        for (Salida salida : factura.getSalidas()) {
          salida.setEstatus(cerrada);
          salida.setFechaModificacion(fecha);
          currentSession().update(salida);

          audita(salida, usuario, Constantes.ACTUALIZAR, fecha);
        }

        query.setString("nombre", Constantes.CANCELADA);
        Estatus cancelada = (Estatus) query.uniqueResult();
        factura.setFechaModificacion(new Date());
        factura.setEstatus(cancelada);
        currentSession().update(factura);
        currentSession().flush();
        return factura;
      } else {
        throw new NoEstaCerradaException(
            "No se puede actualizar una factura que no este cerrada", factura);
      }
    } else {
      throw new NoSePuedeCancelarException(
          "No se puede cancelar la factura porque no existe", factura);
    }
  }
Пример #8
0
  public FacturaAlmacen crea(FacturaAlmacen factura, Usuario usuario) {
    Session session = currentSession();
    if (usuario != null) {
      factura.setAlmacen(usuario.getAlmacen());
    }
    Query query = currentSession().createQuery("select e from Estatus e where e.nombre = :nombre");
    query.setString("nombre", Constantes.ABIERTA);
    Estatus estatus = (Estatus) query.uniqueResult();
    factura.setEstatus(estatus);
    factura.setFolio(getFolioTemporal(factura.getAlmacen()));
    Date fecha = new Date();
    factura.setFechaCreacion(fecha);
    factura.setFechaModificacion(fecha);
    session.save(factura);

    audita(factura, usuario, Constantes.CREAR, fecha);

    session.flush();
    return factura;
  }
Пример #9
0
  public FacturaAlmacen cierra(FacturaAlmacen factura, Usuario usuario)
      throws NoSePuedeCerrarException, NoSePuedeCerrarEnCeroException, NoEstaAbiertaException {
    if (factura != null) {
      if (factura.getEstatus().getNombre().equals(Constantes.ABIERTA)) {
        if (usuario != null) {
          factura.setAlmacen(usuario.getAlmacen());
        }

        Date fecha = new Date();
        factura.setIva(BigDecimal.ZERO);
        factura.setTotal(BigDecimal.ZERO);
        Query query =
            currentSession().createQuery("select e from Estatus e where e.nombre = :nombre");
        query.setString("nombre", Constantes.FACTURADA);
        Estatus facturada = (Estatus) query.uniqueResult();
        for (Salida salida : factura.getSalidas()) {
          salida.setEstatus(facturada);
          salida.setFechaModificacion(fecha);
          currentSession().update(salida);
          audita(salida, usuario, Constantes.FACTURADA, fecha);
          factura.setIva(factura.getIva().add(salida.getIva()));
          factura.setTotal(factura.getTotal().add(salida.getTotal()));
        }

        for (Entrada entrada : factura.getEntradas()) {
          entrada.setEstatus(facturada);
          entrada.setFechaModificacion(fecha);
          currentSession().update(entrada);
          audita(entrada, usuario, Constantes.FACTURADA, fecha);
          factura.setIva(factura.getIva().subtract(entrada.getIva()));
          factura.setTotal(factura.getTotal().subtract(entrada.getTotal()));
        }

        query.setString("nombre", Constantes.CERRADA);
        Estatus estatus = (Estatus) query.uniqueResult();
        factura.setEstatus(estatus);
        factura.setFolio(getFolio(factura.getAlmacen()));
        factura.setFechaModificacion(fecha);

        currentSession().update(factura);

        audita(factura, usuario, Constantes.ACTUALIZAR, fecha);

        currentSession().flush();
        return factura;
      } else {
        throw new NoEstaAbiertaException("No se puede actualizar una factura que no este abierta");
      }
    } else {
      throw new NoSePuedeCerrarException("No se puede cerrar la factura pues no existe");
    }
  }
Пример #10
0
 public String cierra(Long facturaId, Usuario usuario)
     throws NoSePuedeCerrarException, NoSePuedeCerrarEnCeroException, NoEstaAbiertaException {
   FacturaAlmacen factura = (FacturaAlmacen) currentSession().get(FacturaAlmacen.class, facturaId);
   factura = cierra(factura, usuario);
   return factura.getFolio();
 }
Пример #11
0
  public FacturaAlmacen actualiza(FacturaAlmacen otraFactura, Usuario usuario)
      throws NoEstaAbiertaException {
    FacturaAlmacen factura =
        (FacturaAlmacen) currentSession().get(FacturaAlmacen.class, otraFactura.getId());
    switch (factura.getEstatus().getNombre()) {
      case Constantes.ABIERTA:
        Session session = currentSession();
        factura.setVersion(otraFactura.getVersion());
        factura.setFecha(otraFactura.getFecha());
        factura.setComentarios(otraFactura.getComentarios());
        factura.setIva(otraFactura.getIva());
        factura.setTotal(otraFactura.getTotal());
        factura.setCliente(otraFactura.getCliente());
        Date fecha = new Date();
        factura.setFechaModificacion(fecha);
        session.update(factura);

        audita(factura, usuario, Constantes.ACTUALIZAR, fecha);

        session.flush();
        return factura;
      default:
        throw new NoEstaAbiertaException("No se puede actualizar una factura que no este abierta");
    }
  }