/**
  * Elimina un almacen de la base de datos con el <code>id</code> especificado.
  *
  * @param id el <code>id</code> del almacen en la base de datos.
  * @throws NonexistentEntityException Se lanza ésta excepción cuando el almacen que se quiere
  *     eliminar no existe en la base de datos.
  */
 public void destruirAlmacen(Long id) throws NonexistentEntityException {
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     Almacen almacen;
     try {
       almacen = em.getReference(Almacen.class, id);
       almacen.getId();
     } catch (EntityNotFoundException enfe) {
       throw new NonexistentEntityException(
           "El almacen que desea eliminar de la base de datos no existe.", enfe);
     }
     Sucursal sucursal = almacen.getSucursal();
     if (sucursal != null) {
       sucursal.getAlmacenes().remove(almacen);
       sucursal = em.merge(sucursal);
     }
     List<LoteAlmacenado> lotesAlmacenados = almacen.getLotesAlmacenados();
     for (LoteAlmacenado lotesAlmacenadosLoteAlmacenado : lotesAlmacenados) {
       lotesAlmacenadosLoteAlmacenado.setAlmacen(null);
       lotesAlmacenadosLoteAlmacenado = em.merge(lotesAlmacenadosLoteAlmacenado);
     }
     em.remove(almacen);
     em.getTransaction().commit();
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
 /**
  * Persiste un objeto <code>Almacen</code> en la base de datos.
  *
  * @param almacen es el <code>Almacen</code> que se persistirá.
  */
 public void crearAlmacen(Almacen almacen) {
   if (almacen.getLotesAlmacenados() == null) {
     almacen.setLotesAlmacenados(new ArrayList<LoteAlmacenado>());
   }
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     Sucursal sucursal = almacen.getSucursal();
     if (sucursal != null) {
       sucursal = em.getReference(sucursal.getClass(), sucursal.getId());
       almacen.setSucursal(sucursal);
     }
     List<LoteAlmacenado> attachedLotesAlmacenados = new ArrayList();
     for (LoteAlmacenado lotesAlmacenadosLoteAlmacenadoToAttach : almacen.getLotesAlmacenados()) {
       lotesAlmacenadosLoteAlmacenadoToAttach =
           em.getReference(
               lotesAlmacenadosLoteAlmacenadoToAttach.getClass(),
               lotesAlmacenadosLoteAlmacenadoToAttach.getId());
       attachedLotesAlmacenados.add(lotesAlmacenadosLoteAlmacenadoToAttach);
     }
     almacen.setLotesAlmacenados(attachedLotesAlmacenados);
     em.persist(almacen);
     if (sucursal != null) {
       sucursal.getAlmacenes().add(almacen);
       sucursal = em.merge(sucursal);
     }
     for (LoteAlmacenado lotesAlmacenadosLoteAlmacenado : almacen.getLotesAlmacenados()) {
       Almacen oldAlmacenOfLotesAlmacenadosLoteAlmacenado =
           lotesAlmacenadosLoteAlmacenado.getAlmacen();
       lotesAlmacenadosLoteAlmacenado.setAlmacen(almacen);
       lotesAlmacenadosLoteAlmacenado = em.merge(lotesAlmacenadosLoteAlmacenado);
       if (oldAlmacenOfLotesAlmacenadosLoteAlmacenado != null) {
         oldAlmacenOfLotesAlmacenadosLoteAlmacenado
             .getLotesAlmacenados()
             .remove(lotesAlmacenadosLoteAlmacenado);
         oldAlmacenOfLotesAlmacenadosLoteAlmacenado =
             em.merge(oldAlmacenOfLotesAlmacenadosLoteAlmacenado);
       }
     }
     em.getTransaction().commit();
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
Beispiel #3
0
  public Almacen removeAlmacen(Almacen almacen) {
    getAlmacens().remove(almacen);
    almacen.setProducto(null);

    return almacen;
  }
Beispiel #4
0
  public Almacen addAlmacen(Almacen almacen) {
    getAlmacens().add(almacen);
    almacen.setProducto(this);

    return almacen;
  }
 /**
  * Actualiza un objeto <code>Almacen</code> en la base de datos.
  *
  * @param almacen es el <code>Almacen</code> que se actualizará en la base de datos.
  * @throws NonexistentEntityException Se lanza ésta excepción cuando el almacen que se quiere
  *     actualizar no existe en la base de datos.
  * @throws Exception
  */
 public void editarAlmacen(Almacen almacen) throws NonexistentEntityException, Exception {
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     Almacen persistentAlmacen = em.find(Almacen.class, almacen.getId());
     Sucursal sucursalOld = persistentAlmacen.getSucursal();
     Sucursal sucursalNew = almacen.getSucursal();
     List<LoteAlmacenado> lotesAlmacenadosOld = persistentAlmacen.getLotesAlmacenados();
     List<LoteAlmacenado> lotesAlmacenadosNew = almacen.getLotesAlmacenados();
     if (sucursalNew != null) {
       sucursalNew = em.getReference(sucursalNew.getClass(), sucursalNew.getId());
       almacen.setSucursal(sucursalNew);
     }
     List<LoteAlmacenado> attachedLotesAlmacenadosNew = new ArrayList();
     for (LoteAlmacenado lotesAlmacenadosNewLoteAlmacenadoToAttach : lotesAlmacenadosNew) {
       lotesAlmacenadosNewLoteAlmacenadoToAttach =
           em.getReference(
               lotesAlmacenadosNewLoteAlmacenadoToAttach.getClass(),
               lotesAlmacenadosNewLoteAlmacenadoToAttach.getId());
       attachedLotesAlmacenadosNew.add(lotesAlmacenadosNewLoteAlmacenadoToAttach);
     }
     lotesAlmacenadosNew = attachedLotesAlmacenadosNew;
     almacen.setLotesAlmacenados(lotesAlmacenadosNew);
     almacen = em.merge(almacen);
     if (sucursalOld != null && !sucursalOld.equals(sucursalNew)) {
       sucursalOld.getAlmacenes().remove(almacen);
       sucursalOld = em.merge(sucursalOld);
     }
     if (sucursalNew != null && !sucursalNew.equals(sucursalOld)) {
       sucursalNew.getAlmacenes().add(almacen);
       sucursalNew = em.merge(sucursalNew);
     }
     for (LoteAlmacenado lotesAlmacenadosOldLoteAlmacenado : lotesAlmacenadosOld) {
       if (!lotesAlmacenadosNew.contains(lotesAlmacenadosOldLoteAlmacenado)) {
         lotesAlmacenadosOldLoteAlmacenado.setAlmacen(null);
         lotesAlmacenadosOldLoteAlmacenado = em.merge(lotesAlmacenadosOldLoteAlmacenado);
       }
     }
     for (LoteAlmacenado lotesAlmacenadosNewLoteAlmacenado : lotesAlmacenadosNew) {
       if (!lotesAlmacenadosOld.contains(lotesAlmacenadosNewLoteAlmacenado)) {
         Almacen oldAlmacenOfLotesAlmacenadosNewLoteAlmacenado =
             lotesAlmacenadosNewLoteAlmacenado.getAlmacen();
         lotesAlmacenadosNewLoteAlmacenado.setAlmacen(almacen);
         lotesAlmacenadosNewLoteAlmacenado = em.merge(lotesAlmacenadosNewLoteAlmacenado);
         if (oldAlmacenOfLotesAlmacenadosNewLoteAlmacenado != null
             && !oldAlmacenOfLotesAlmacenadosNewLoteAlmacenado.equals(almacen)) {
           oldAlmacenOfLotesAlmacenadosNewLoteAlmacenado
               .getLotesAlmacenados()
               .remove(lotesAlmacenadosNewLoteAlmacenado);
           oldAlmacenOfLotesAlmacenadosNewLoteAlmacenado =
               em.merge(oldAlmacenOfLotesAlmacenadosNewLoteAlmacenado);
         }
       }
     }
     em.getTransaction().commit();
   } catch (Exception ex) {
     String msg = ex.getLocalizedMessage();
     if (msg == null || msg.length() == 0) {
       Long id = almacen.getId();
       if (encontrarAlmacen(id) == null) {
         throw new NonexistentEntityException(
             "El almacén que desea actualizar en la base de datos no existe.");
       }
     }
     throw ex;
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }