コード例 #1
0
 public void destroy(Integer id) throws NonexistentEntityException {
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     TipoEstadoNormatividad tipoEstadoNormatividad;
     try {
       tipoEstadoNormatividad = em.getReference(TipoEstadoNormatividad.class, id);
       tipoEstadoNormatividad.getId();
     } catch (EntityNotFoundException enfe) {
       throw new NonexistentEntityException(
           "The tipoEstadoNormatividad with id " + id + " no longer exists.", enfe);
     }
     List<Normatividad> normatividadList = tipoEstadoNormatividad.getNormatividadList();
     for (Normatividad normatividadListNormatividad : normatividadList) {
       normatividadListNormatividad.setIdEstado(null);
       normatividadListNormatividad = em.merge(normatividadListNormatividad);
     }
     List<SeguimientoNormatividad> seguimientoNormatividadList =
         tipoEstadoNormatividad.getSeguimientoNormatividadList();
     for (SeguimientoNormatividad seguimientoNormatividadListSeguimientoNormatividad :
         seguimientoNormatividadList) {
       seguimientoNormatividadListSeguimientoNormatividad.setIdEstado(null);
       seguimientoNormatividadListSeguimientoNormatividad =
           em.merge(seguimientoNormatividadListSeguimientoNormatividad);
     }
     em.remove(tipoEstadoNormatividad);
     em.getTransaction().commit();
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
コード例 #2
0
 public void edit(CategHabitacion categHabitacion) throws NonexistentEntityException, Exception {
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     CategHabitacion persistentCategHabitacion =
         em.find(CategHabitacion.class, categHabitacion.getCodigoCategoria());
     Collection<Habitacion> habitacionCollectionOld =
         persistentCategHabitacion.getHabitacionCollection();
     Collection<Habitacion> habitacionCollectionNew = categHabitacion.getHabitacionCollection();
     Collection<Habitacion> attachedHabitacionCollectionNew = new ArrayList<Habitacion>();
     for (Habitacion habitacionCollectionNewHabitacionToAttach : habitacionCollectionNew) {
       habitacionCollectionNewHabitacionToAttach =
           em.getReference(
               habitacionCollectionNewHabitacionToAttach.getClass(),
               habitacionCollectionNewHabitacionToAttach.getNumero());
       attachedHabitacionCollectionNew.add(habitacionCollectionNewHabitacionToAttach);
     }
     habitacionCollectionNew = attachedHabitacionCollectionNew;
     categHabitacion.setHabitacionCollection(habitacionCollectionNew);
     categHabitacion = em.merge(categHabitacion);
     for (Habitacion habitacionCollectionOldHabitacion : habitacionCollectionOld) {
       if (!habitacionCollectionNew.contains(habitacionCollectionOldHabitacion)) {
         habitacionCollectionOldHabitacion.setCodigoCategoria(null);
         habitacionCollectionOldHabitacion = em.merge(habitacionCollectionOldHabitacion);
       }
     }
     for (Habitacion habitacionCollectionNewHabitacion : habitacionCollectionNew) {
       if (!habitacionCollectionOld.contains(habitacionCollectionNewHabitacion)) {
         CategHabitacion oldCodigoCategoriaOfHabitacionCollectionNewHabitacion =
             habitacionCollectionNewHabitacion.getCodigoCategoria();
         habitacionCollectionNewHabitacion.setCodigoCategoria(categHabitacion);
         habitacionCollectionNewHabitacion = em.merge(habitacionCollectionNewHabitacion);
         if (oldCodigoCategoriaOfHabitacionCollectionNewHabitacion != null
             && !oldCodigoCategoriaOfHabitacionCollectionNewHabitacion.equals(categHabitacion)) {
           oldCodigoCategoriaOfHabitacionCollectionNewHabitacion
               .getHabitacionCollection()
               .remove(habitacionCollectionNewHabitacion);
           oldCodigoCategoriaOfHabitacionCollectionNewHabitacion =
               em.merge(oldCodigoCategoriaOfHabitacionCollectionNewHabitacion);
         }
       }
     }
     em.getTransaction().commit();
   } catch (Exception ex) {
     String msg = ex.getLocalizedMessage();
     if (msg == null || msg.length() == 0) {
       Integer id = categHabitacion.getCodigoCategoria();
       if (findCategHabitacion(id) == null) {
         throw new NonexistentEntityException(
             "The categHabitacion with id " + id + " no longer exists.");
       }
     }
     throw ex;
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
コード例 #3
0
  public void edit(Long altId, Vote vote)
      throws NonExistingEntityException, RollbackFailureException, Exception {
    Alternative alternative = em.find(Alternative.class, altId);
    if (alternative == null) {
      throw new NonExistingEntityException("Alternative with Id = " + altId + " does not exist");
    }
    vote.setAlternative(alternative);

    Vote persistentVote = em.find(Vote.class, vote.getId());
    Alternative alternativeOld = persistentVote.getAlternative();
    Alternative alternativeNew = vote.getAlternative();
    if (alternativeNew != null) {
      alternativeNew = em.getReference(alternativeNew.getClass(), alternativeNew.getId());
      vote.setAlternative(alternativeNew);
    }
    vote = em.merge(vote);
    if (alternativeOld != null && !alternativeOld.equals(alternativeNew)) {
      alternativeOld.getVotes().remove(vote);
      alternativeOld = em.merge(alternativeOld);
    }
    if (alternativeNew != null && !alternativeNew.equals(alternativeOld)) {
      alternativeNew.getVotes().add(vote);
      alternativeNew = em.merge(alternativeNew);
    }
  }
コード例 #4
0
 @POST
 @Consumes({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON})
 public void putResponse(
     String userResponse,
     @PathParam("eventId") Long eventId,
     @PathParam("inviteId") Long personId) {
   logger.log(
       Level.INFO,
       "Updating status to {0} for person ID {1} for event ID {2}",
       new Object[] {userResponse, eventId, personId});
   Response response =
       (Response)
           em.createNamedQuery("rsvp.entity.Response.findResponseByEventAndPerson")
               .setParameter("eventId", eventId)
               .setParameter("personId", personId)
               .getSingleResult();
   if (userResponse.equals(ResponseEnum.ATTENDING.getLabel())
       && !response.getResponse().equals(ResponseEnum.ATTENDING)) {
     response.setResponse(ResponseEnum.ATTENDING);
     em.merge(response);
   } else if (userResponse.equals(ResponseEnum.NOT_ATTENDING.getLabel())
       && !response.getResponse().equals(ResponseEnum.NOT_ATTENDING)) {
     response.setResponse(ResponseEnum.NOT_ATTENDING);
     em.merge(response);
   } else if (userResponse.equals(ResponseEnum.MAYBE_ATTENDING.getLabel())
       && !response.getResponse().equals(ResponseEnum.MAYBE_ATTENDING)) {
     response.setResponse(ResponseEnum.MAYBE_ATTENDING);
     em.merge(response);
   }
 }
コード例 #5
0
 public void create(Subgrupos subgrupos) {
   if (subgrupos.getProcesosList() == null) {
     subgrupos.setProcesosList(new ArrayList<Procesos>());
   }
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     List<Procesos> attachedProcesosList = new ArrayList<Procesos>();
     for (Procesos procesosListProcesosToAttach : subgrupos.getProcesosList()) {
       procesosListProcesosToAttach =
           em.getReference(
               procesosListProcesosToAttach.getClass(), procesosListProcesosToAttach.getId());
       attachedProcesosList.add(procesosListProcesosToAttach);
     }
     subgrupos.setProcesosList(attachedProcesosList);
     em.persist(subgrupos);
     for (Procesos procesosListProcesos : subgrupos.getProcesosList()) {
       Subgrupos oldSubgruposIdOfProcesosListProcesos = procesosListProcesos.getSubgruposId();
       procesosListProcesos.setSubgruposId(subgrupos);
       procesosListProcesos = em.merge(procesosListProcesos);
       if (oldSubgruposIdOfProcesosListProcesos != null) {
         oldSubgruposIdOfProcesosListProcesos.getProcesosList().remove(procesosListProcesos);
         oldSubgruposIdOfProcesosListProcesos = em.merge(oldSubgruposIdOfProcesosListProcesos);
       }
     }
     em.getTransaction().commit();
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
コード例 #6
0
 public void destroy(Integer id) throws NonexistentEntityException {
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     Clasedatos clasedatos;
     try {
       clasedatos = em.getReference(Clasedatos.class, id);
       clasedatos.getId();
     } catch (EntityNotFoundException enfe) {
       throw new NonexistentEntityException(
           "The clasedatos with id " + id + " no longer exists.", enfe);
     }
     Entidad entidadId = clasedatos.getEntidadId();
     if (entidadId != null) {
       entidadId.getClasedatosList().remove(clasedatos);
       entidadId = em.merge(entidadId);
     }
     List<Procesos> procesosList = clasedatos.getProcesosList();
     for (Procesos procesosListProcesos : procesosList) {
       procesosListProcesos.getClasedatosList().remove(clasedatos);
       procesosListProcesos = em.merge(procesosListProcesos);
     }
     em.remove(clasedatos);
     em.getTransaction().commit();
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
コード例 #7
0
  @POST
  @Consumes("application/x-www-form-urlencoded")
  @Produces("text/html")
  public String putResponse(
      @FormParam("attendeeResponse") String userResponse,
      @PathParam("eventId") Long eventId,
      @PathParam("inviteId") Long personId) {
    StringBuilder output = new StringBuilder();
    Response response =
        (Response)
            em.createNamedQuery("rsvp.entity.Response.findResponseByEventAndPerson")
                .setParameter("eventId", eventId)
                .setParameter("personId", personId)
                .getSingleResult();
    Event event = response.getEvent();
    Person person = response.getPerson();

    if (userResponse.equals("Yes") && !response.getResponse().equals(ResponseEnum.ATTENDING)) {
      response.setResponse(ResponseEnum.ATTENDING);
      em.merge(response);
    } else if (userResponse.equals("No")
        && !response.getResponse().equals(ResponseEnum.NOT_ATTENDING)) {
      response.setResponse(ResponseEnum.NOT_ATTENDING);
      em.merge(response);
    } else if (userResponse.equals("Maybe")
        && !response.getResponse().equals(ResponseEnum.MAYBE_ATTENDING)) {
      response.setResponse(ResponseEnum.MAYBE_ATTENDING);
      em.merge(response);
    }

    // create the response HTML
    output
        .append("<html lang=\"en\"><head><title>Current response for ")
        .append(person.getFirstName())
        .append(" ")
        .append(person.getLastName())
        .append(" at ")
        .append(event.getName())
        .append("</title>")
        .append("<link href=\"/rsvp/css/default.css\" rel=\"stylesheet\" type=\"text/css\" />")
        .append("</head>");
    output.append("<body><h1>").append(event.getName()).append("</h1>");
    output
        .append("<p>Thanks for your RSVP, ")
        .append(person.getFirstName())
        .append(" ")
        .append(person.getLastName())
        .append("!</p>");
    output
        .append("<p>Your current response is: ")
        .append(response.getResponseText())
        .append("</p>");
    output
        .append("<p><a href=\"/jaxrs_rsvp_db/resources/status/")
        .append(event.getId())
        .append("\">Back to event page</a></p>");
    output.append("</body></html>");

    return output.toString();
  }
コード例 #8
0
 /**
  * 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();
     }
   }
 }
コード例 #9
0
ファイル: BankTransaction.java プロジェクト: ishepard/BankDS
 public String performBill() {
   sender.setCheckingaccount(sender.getCheckingaccount() - amount);
   recipient.setCheckingaccount(recipient.getCheckingaccount() + amount);
   em.merge(sender);
   em.merge(recipient);
   return sender.getCheckingaccount().toString();
 }
コード例 #10
0
 public void destroy(Integer id) throws NonexistentEntityException {
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     Timereport timereport;
     try {
       timereport = em.getReference(Timereport.class, id);
       timereport.getIdtimereport();
     } catch (EntityNotFoundException enfe) {
       throw new NonexistentEntityException(
           "The timereport with id " + id + " no longer exists.", enfe);
     }
     Utilisateur idutilisateur = timereport.getIdutilisateur();
     if (idutilisateur != null) {
       idutilisateur.getTimereportCollection().remove(timereport);
       idutilisateur = em.merge(idutilisateur);
     }
     Tache idtache = timereport.getIdtache();
     if (idtache != null) {
       idtache.getTimereportCollection().remove(timereport);
       idtache = em.merge(idtache);
     }
     em.remove(timereport);
     em.getTransaction().commit();
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
コード例 #11
0
  public void testGF1894() {
    EntityManager em = createEntityManager(m_persistenceUnit);
    beginTransaction(em);
    Employee emp = new Employee("Guy", "Pelletier");

    Address address = new Address();
    address.setCity("College Town");

    emp.setAddress(address);

    try {
      Employee empClone = em.merge(emp);
      assertNotNull(
          "The id field for the merged new employee object was not generated.", empClone.getId());
      commitTransaction(em);

      Employee empFromDB = em.find(Employee.class, empClone.getId());
      assertNotNull(
          "The version locking field for the merged new employee object was not updated after commit.",
          empFromDB.getVersion());

      beginTransaction(em);
      Employee empClone2 = em.merge(empFromDB);
      assertTrue(
          "The id field on a existing merged employee object was modified on a subsequent merge.",
          empFromDB.getId().equals(empClone2.getId()));
      commitTransaction(em);
    } catch (javax.persistence.OptimisticLockException e) {
      fail(
          "An optimistic locking exception was caught on the merge of a new object. An insert should of occurred instead.");
    }

    closeEntityManager(em);
  }
コード例 #12
0
  @Test
  @Priority(10)
  public void initData() {
    EntityManager em = getOrCreateEntityManager();
    try {
      // Revision 1
      em.getTransaction().begin();
      NameInfo ni = new NameInfo("John", "Doe");
      Person person1 = new Person("JDOE", ni);
      em.persist(person1);
      em.getTransaction().commit();

      // Revision 2
      em.getTransaction().begin();
      person1 = em.find(Person.class, person1.getId());
      person1.getNameInfo().setFirstName("Jane");
      em.merge(person1);
      em.getTransaction().commit();

      // Revision 3
      em.getTransaction().begin();
      person1 = em.find(Person.class, person1.getId());
      person1.setName("JDOE2");
      em.merge(person1);
      em.getTransaction().commit();

      personId = person1.getId();
    } finally {
      em.close();
    }
  }
コード例 #13
0
ファイル: EShopBean.java プロジェクト: nelsonjava/pruebas
  // extract from inventory
  public int checkInventory(String sku, String color, String size, int quantity) {

    InventoryPK pk = new InventoryPK(sku, color, size);

    Inventory inventory = em.find(Inventory.class, pk, LockModeType.OPTIMISTIC);
    int amount = inventory.getInventory();
    if (amount > 0) {
      if (amount >= quantity) {
        amount = amount - quantity;
        inventory.setInventory(amount);
        try {
          em.merge(inventory);
        } catch (OptimisticLockException e) {
          return -9999;
        }

        return quantity;
      } else {
        inventory.setInventory(0);
        try {
          em.merge(inventory);
        } catch (OptimisticLockException e) {
          return -9999;
        }

        return amount;
      }
    } else {
      return amount;
    }
  }
コード例 #14
0
  @Override
  public void addTrend(String name, Kwet kwet) {
    Query q = em.createQuery("select trend from Trends trend where trend.name = :name ");
    q.setParameter("name", name);
    List<Trend> trends = q.getResultList();
    Trend trend = null;

    if (trends.isEmpty()) {
      trend = new Trend(name);
      em.persist(trend);

      trend.addKwet(kwet);
      kwet.addTrend(trend);

      em.merge(trend);
      em.merge(kwet);
    } else {
      trend = trends.get(0);
      if (!trend.getKwets().contains(kwet)) {
        trend.addKwet(kwet);
        kwet.addTrend(trend);

        em.merge(trend);
        em.merge(kwet);
      }
    }
  }
コード例 #15
0
 public void destroy(long id) throws NonexistentEntityException {
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     CheckoutRecord checkoutRecord;
     try {
       checkoutRecord = em.getReference(CheckoutRecord.class, id);
       checkoutRecord.getId();
     } catch (EntityNotFoundException enfe) {
       throw new NonexistentEntityException(
           "The checkoutRecord with id " + id + " no longer exists.", enfe);
     }
     Member member = checkoutRecord.getMember();
     if (member != null) {
       member.getRecords().remove(checkoutRecord);
       member = em.merge(member);
     }
     Fine fine = checkoutRecord.getFine();
     if (fine != null) {
       fine.setRecord(null);
       fine = em.merge(fine);
     }
     em.remove(checkoutRecord);
     em.getTransaction().commit();
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
コード例 #16
0
 public void destroy(Integer id) throws NonexistentEntityException {
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     Tema tema;
     try {
       tema = em.getReference(Tema.class, id);
       tema.getId();
     } catch (EntityNotFoundException enfe) {
       throw new NonexistentEntityException("The tema with id " + id + " no longer exists.", enfe);
     }
     Clase idAreaDerecho = tema.getIdAreaDerecho();
     if (idAreaDerecho != null) {
       idAreaDerecho.getTemaList().remove(tema);
       idAreaDerecho = em.merge(idAreaDerecho);
     }
     List<Normatividad> normatividadList = tema.getNormatividadList();
     for (Normatividad normatividadListNormatividad : normatividadList) {
       normatividadListNormatividad.setIdTema(null);
       normatividadListNormatividad = em.merge(normatividadListNormatividad);
     }
     List<Proceso> procesoList = tema.getProcesoList();
     for (Proceso procesoListProceso : procesoList) {
       procesoListProceso.setIdTema(null);
       procesoListProceso = em.merge(procesoListProceso);
     }
     em.remove(tema);
     em.getTransaction().commit();
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
コード例 #17
0
 public void destroy(Integer id) throws NonexistentEntityException {
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     Inventary inventary;
     try {
       inventary = em.getReference(Inventary.class, id);
       inventary.getId();
     } catch (EntityNotFoundException enfe) {
       throw new NonexistentEntityException(
           "The inventary with id " + id + " no longer exists.", enfe);
     }
     Product productId = inventary.getProductId();
     if (productId != null) {
       productId.getInventaryList().remove(inventary);
       productId = em.merge(productId);
     }
     Billing billingId = inventary.getBillingId();
     if (billingId != null) {
       billingId.getInventaryList().remove(inventary);
       billingId = em.merge(billingId);
     }
     em.remove(inventary);
     em.getTransaction().commit();
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
コード例 #18
0
 public void destroy(Integer id) throws NonexistentEntityException {
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     Livreurs livreurs;
     try {
       livreurs = em.getReference(Livreurs.class, id);
       livreurs.getIdLivreur();
     } catch (EntityNotFoundException enfe) {
       throw new NonexistentEntityException(
           "The livreurs with id " + id + " no longer exists.", enfe);
     }
     Statuts statut = livreurs.getStatut();
     if (statut != null) {
       statut.getLivreursList().remove(livreurs);
       statut = em.merge(statut);
     }
     List<Clients> clientsList = livreurs.getClientsList();
     for (Clients clientsListClients : clientsList) {
       clientsListClients.setIdLivreur(null);
       clientsListClients = em.merge(clientsListClients);
     }
     em.remove(livreurs);
     em.getTransaction().commit();
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
コード例 #19
0
  private void btnOKActionPerformed(
      java.awt.event.ActionEvent evt) { // GEN-FIRST:event_btnOKActionPerformed
    EntityManager em = OPDE.createEM();
    try {
      em.getTransaction().begin();
      TradeForm myTradeForm = em.merge(tradeForm);
      em.lock(myTradeForm, LockModeType.OPTIMISTIC);
      myTradeForm.setSubtext(txtZusatz.getText());
      DosageForm dosageForm = em.merge((DosageForm) cmbForm.getSelectedItem());
      em.lock(dosageForm, LockModeType.OPTIMISTIC);
      myTradeForm.setDosageForm(dosageForm);

      em.getTransaction().commit();

      tradeForm = myTradeForm;
    } catch (Exception e) {
      if (em.getTransaction().isActive()) {
        em.getTransaction().rollback();
      }
      OPDE.fatal(e);
    } finally {
      em.close();
    }
    dispose();
  } // GEN-LAST:event_btnOKActionPerformed
 public void create(ChequesProveedores chequesProveedores) {
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     Proveedores proveedoresidProveedores = chequesProveedores.getProveedoresidProveedores();
     if (proveedoresidProveedores != null) {
       proveedoresidProveedores =
           em.getReference(
               proveedoresidProveedores.getClass(), proveedoresidProveedores.getIdProveedores());
       chequesProveedores.setProveedoresidProveedores(proveedoresidProveedores);
     }
     Bancos bancosIdbancos = chequesProveedores.getBancosIdbancos();
     if (bancosIdbancos != null) {
       bancosIdbancos = em.getReference(bancosIdbancos.getClass(), bancosIdbancos.getIdbancos());
       chequesProveedores.setBancosIdbancos(bancosIdbancos);
     }
     em.persist(chequesProveedores);
     if (proveedoresidProveedores != null) {
       proveedoresidProveedores.getChequesProveedoresCollection().add(chequesProveedores);
       proveedoresidProveedores = em.merge(proveedoresidProveedores);
     }
     if (bancosIdbancos != null) {
       bancosIdbancos.getChequesProveedoresCollection().add(chequesProveedores);
       bancosIdbancos = em.merge(bancosIdbancos);
     }
     em.getTransaction().commit();
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
 public void destroy(Integer id) throws NonexistentEntityException {
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     ChequesProveedores chequesProveedores;
     try {
       chequesProveedores = em.getReference(ChequesProveedores.class, id);
       chequesProveedores.getIdchequesProveedores();
     } catch (EntityNotFoundException enfe) {
       throw new NonexistentEntityException(
           "The chequesProveedores with id " + id + " no longer exists.", enfe);
     }
     Proveedores proveedoresidProveedores = chequesProveedores.getProveedoresidProveedores();
     if (proveedoresidProveedores != null) {
       proveedoresidProveedores.getChequesProveedoresCollection().remove(chequesProveedores);
       proveedoresidProveedores = em.merge(proveedoresidProveedores);
     }
     Bancos bancosIdbancos = chequesProveedores.getBancosIdbancos();
     if (bancosIdbancos != null) {
       bancosIdbancos.getChequesProveedoresCollection().remove(chequesProveedores);
       bancosIdbancos = em.merge(bancosIdbancos);
     }
     em.remove(chequesProveedores);
     em.getTransaction().commit();
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
コード例 #22
0
  private MeasurementBaseline calculateBaselineForGroup(
      int groupId,
      int definitionId,
      boolean userEntered,
      long startDate,
      long endDate,
      boolean save)
      throws DataNotAvailableException, BaselineCreationException {

    MeasurementAggregate agg =
        dataManager.getAggregate(
            subjectManager.getOverlord(), groupId, definitionId, startDate, endDate);

    Subject overlord = subjectManager.getOverlord();
    List<Integer> resourceIds = resourceManager.findImplicitResourceIdsByResourceGroup(groupId);
    List<MeasurementSchedule> schedules =
        measurementScheduleManager.findSchedulesByResourceIdsAndDefinitionId(
            overlord, ArrayUtils.unwrapCollection(resourceIds), definitionId);

    MeasurementBaseline baseline = null;
    for (MeasurementSchedule schedule : schedules) {
      // attach the entity, so we can find the baseline
      schedule = entityManager.merge(schedule);

      if (save && (schedule.getBaseline() != null)) {
        /*
         * If saving, make sure we're updating the existing one, if it exists
         */
        baseline = schedule.getBaseline();
      } else {
        /*
         * Otherwise, if we're not saving or if the the schedule doesn't have a current baseline, we create a new
         * baseline object
         */
        baseline = new MeasurementBaseline();

        if (save) {
          /*
           * But, if we *are* in save mode, then set the relationship so when we merge the schedule below it
           * persists this new baseline too
           */
          baseline.setSchedule(schedule);
        }
      }

      baseline.setUserEntered(userEntered);
      baseline.setMean(agg.getAvg());
      baseline.setMin(agg.getMin());
      baseline.setMax(agg.getMax());

      if (save) {
        entityManager.persist(baseline);
        entityManager.merge(schedule);
      }
    }

    // all baselines should be the same
    return baseline;
  }
コード例 #23
0
 public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException {
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     Produto produto;
     try {
       produto = em.getReference(Produto.class, id);
       produto.getIdproduto();
     } catch (EntityNotFoundException enfe) {
       throw new NonexistentEntityException(
           "The produto with id " + id + " no longer exists.", enfe);
     }
     List<String> illegalOrphanMessages = null;
     List<DetalheVenda> detalheVendaListOrphanCheck = produto.getDetalheVendaList();
     for (DetalheVenda detalheVendaListOrphanCheckDetalheVenda : detalheVendaListOrphanCheck) {
       if (illegalOrphanMessages == null) {
         illegalOrphanMessages = new ArrayList<String>();
       }
       illegalOrphanMessages.add(
           "This Produto ("
               + produto
               + ") cannot be destroyed since the DetalheVenda "
               + detalheVendaListOrphanCheckDetalheVenda
               + " in its detalheVendaList field has a non-nullable produto field.");
     }
     List<Promocao> promocaoListOrphanCheck = produto.getPromocaoList();
     for (Promocao promocaoListOrphanCheckPromocao : promocaoListOrphanCheck) {
       if (illegalOrphanMessages == null) {
         illegalOrphanMessages = new ArrayList<String>();
       }
       illegalOrphanMessages.add(
           "This Produto ("
               + produto
               + ") cannot be destroyed since the Promocao "
               + promocaoListOrphanCheckPromocao
               + " in its promocaoList field has a non-nullable codProduto field.");
     }
     if (illegalOrphanMessages != null) {
       throw new IllegalOrphanException(illegalOrphanMessages);
     }
     Unidade codUnidade = produto.getCodUnidade();
     if (codUnidade != null) {
       codUnidade.getProdutoList().remove(produto);
       codUnidade = em.merge(codUnidade);
     }
     Categoria codCategoria = produto.getCodCategoria();
     if (codCategoria != null) {
       codCategoria.getProdutoList().remove(produto);
       codCategoria = em.merge(codCategoria);
     }
     em.remove(produto);
     em.getTransaction().commit();
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
コード例 #24
0
  @Test
  public void testMergeMultipleEntityCopiesAllowedAndDisallowed() {
    Item item1 = new Item();
    item1.setName("item1 name");
    Category category = new Category();
    category.setName("category");
    item1.setCategory(category);
    category.setExampleItem(item1);

    EntityManager em = getOrCreateEntityManager();
    em.getTransaction().begin();
    em.persist(item1);
    em.getTransaction().commit();
    em.close();

    // get another representation of item1
    em = getOrCreateEntityManager();
    em.getTransaction().begin();
    Item item1_1 = em.find(Item.class, item1.getId());
    // make sure item1_1.category is initialized
    Hibernate.initialize(item1_1.getCategory());
    em.getTransaction().commit();
    em.close();

    em = getOrCreateEntityManager();
    em.getTransaction().begin();
    Item item1Merged = em.merge(item1);

    // make sure item1Merged.category is also managed
    Hibernate.initialize(item1Merged.getCategory());

    item1Merged.setCategory(category);
    category.setExampleItem(item1_1);

    // now item1Merged is managed and it has a nested detached item
    // and there is  multiple managed/detached Category objects
    try {
      // the following should fail because multiple copies of Category objects is not allowed by
      // CustomEntityCopyObserver
      em.merge(item1Merged);
      fail(
          "should have failed because CustomEntityCopyObserver does not allow multiple copies of a Category. ");
    } catch (IllegalStateException ex) {
      // expected
    } finally {
      em.getTransaction().rollback();
    }
    em.close();

    em = getOrCreateEntityManager();
    em.getTransaction().begin();
    item1 = em.find(Item.class, item1.getId());
    assertEquals(category.getName(), item1.getCategory().getName());
    assertSame(item1, item1.getCategory().getExampleItem());
    em.getTransaction().commit();
    em.close();

    cleanup();
  }
コード例 #25
0
 public void edit(Room room)
     throws NonexistentEntityException, RollbackFailureException, Exception {
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     Room persistentRoom = em.find(Room.class, room.getId());
     Department departmentOld = persistentRoom.getDepartment();
     Department departmentNew = room.getDepartment();
     Category categoryOld = persistentRoom.getCategory();
     Category categoryNew = room.getCategory();
     if (departmentNew != null) {
       departmentNew = em.getReference(departmentNew.getClass(), departmentNew.getId());
       room.setDepartment(departmentNew);
     }
     if (categoryNew != null) {
       categoryNew = em.getReference(categoryNew.getClass(), categoryNew.getId());
       room.setCategory(categoryNew);
     }
     room = em.merge(room);
     if (departmentOld != null && !departmentOld.equals(departmentNew)) {
       departmentOld.getRoomCollection().remove(room);
       departmentOld = em.merge(departmentOld);
     }
     if (departmentNew != null && !departmentNew.equals(departmentOld)) {
       departmentNew.getRoomCollection().add(room);
       departmentNew = em.merge(departmentNew);
     }
     if (categoryOld != null && !categoryOld.equals(categoryNew)) {
       categoryOld.getRoomCollection().remove(room);
       categoryOld = em.merge(categoryOld);
     }
     if (categoryNew != null && !categoryNew.equals(categoryOld)) {
       categoryNew.getRoomCollection().add(room);
       categoryNew = em.merge(categoryNew);
     }
     em.getTransaction().commit();
   } catch (Exception ex) {
     try {
       em.getTransaction().rollback();
     } catch (Exception re) {
       throw new RollbackFailureException(
           "An error occurred attempting to roll back the transaction.", re);
     }
     String msg = ex.getLocalizedMessage();
     if (msg == null || msg.length() == 0) {
       Integer id = room.getId();
       if (findRoom(id) == null) {
         throw new NonexistentEntityException("The room with id " + id + " no longer exists.");
       }
     }
     throw ex;
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
コード例 #26
0
 public void edit(Groupe groupe) throws NonexistentEntityException, Exception {
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     Groupe persistentGroupe = em.find(Groupe.class, groupe.getIdgroupe());
     Collection<Utilisateur> utilisateurCollectionOld =
         persistentGroupe.getUtilisateurCollection();
     Collection<Utilisateur> utilisateurCollectionNew = groupe.getUtilisateurCollection();
     Collection<Utilisateur> attachedUtilisateurCollectionNew = new ArrayList<Utilisateur>();
     for (Utilisateur utilisateurCollectionNewUtilisateurToAttach : utilisateurCollectionNew) {
       utilisateurCollectionNewUtilisateurToAttach =
           em.getReference(
               utilisateurCollectionNewUtilisateurToAttach.getClass(),
               utilisateurCollectionNewUtilisateurToAttach.getIdutilisateur());
       attachedUtilisateurCollectionNew.add(utilisateurCollectionNewUtilisateurToAttach);
     }
     utilisateurCollectionNew = attachedUtilisateurCollectionNew;
     groupe.setUtilisateurCollection(utilisateurCollectionNew);
     groupe = em.merge(groupe);
     for (Utilisateur utilisateurCollectionOldUtilisateur : utilisateurCollectionOld) {
       if (!utilisateurCollectionNew.contains(utilisateurCollectionOldUtilisateur)) {
         utilisateurCollectionOldUtilisateur.setIdgroupe(null);
         utilisateurCollectionOldUtilisateur = em.merge(utilisateurCollectionOldUtilisateur);
       }
     }
     for (Utilisateur utilisateurCollectionNewUtilisateur : utilisateurCollectionNew) {
       if (!utilisateurCollectionOld.contains(utilisateurCollectionNewUtilisateur)) {
         Groupe oldIdgroupeOfUtilisateurCollectionNewUtilisateur =
             utilisateurCollectionNewUtilisateur.getIdgroupe();
         utilisateurCollectionNewUtilisateur.setIdgroupe(groupe);
         utilisateurCollectionNewUtilisateur = em.merge(utilisateurCollectionNewUtilisateur);
         if (oldIdgroupeOfUtilisateurCollectionNewUtilisateur != null
             && !oldIdgroupeOfUtilisateurCollectionNewUtilisateur.equals(groupe)) {
           oldIdgroupeOfUtilisateurCollectionNewUtilisateur
               .getUtilisateurCollection()
               .remove(utilisateurCollectionNewUtilisateur);
           oldIdgroupeOfUtilisateurCollectionNewUtilisateur =
               em.merge(oldIdgroupeOfUtilisateurCollectionNewUtilisateur);
         }
       }
     }
     em.getTransaction().commit();
   } catch (Exception ex) {
     String msg = ex.getLocalizedMessage();
     if (msg == null || msg.length() == 0) {
       Integer id = groupe.getIdgroupe();
       if (findGroupe(id) == null) {
         throw new NonexistentEntityException("The groupe with id " + id + " no longer exists.");
       }
     }
     throw ex;
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
コード例 #27
0
 public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException {
   EntityManager em = null;
   try {
     em = getEntityManager();
     // em.getTransaction().begin();
     Dir dir;
     try {
       dir = em.getReference(Dir.class, id);
       dir.getDirID();
     } catch (EntityNotFoundException enfe) {
       throw new NonexistentEntityException("The dir with id " + id + " no longer exists.", enfe);
     }
     List<String> illegalOrphanMessages = null;
     List<SVNVersion> SVNVersionListOrphanCheck = dir.getSVNVersionList();
     for (SVNVersion SVNVersionListOrphanCheckSVNVersion : SVNVersionListOrphanCheck) {
       if (illegalOrphanMessages == null) {
         illegalOrphanMessages = new ArrayList<String>();
       }
       illegalOrphanMessages.add(
           "This Dir ("
               + dir
               + ") cannot be destroyed since the SVNVersion "
               + SVNVersionListOrphanCheckSVNVersion
               + " in its SVNVersionList field has a non-nullable dir field.");
     }
     List<SVNFile> SVNFileListOrphanCheck = dir.getSVNFileList();
     for (SVNFile SVNFileListOrphanCheckSVNFile : SVNFileListOrphanCheck) {
       if (illegalOrphanMessages == null) {
         illegalOrphanMessages = new ArrayList<String>();
       }
       illegalOrphanMessages.add(
           "This Dir ("
               + dir
               + ") cannot be destroyed since the SVNFile "
               + SVNFileListOrphanCheckSVNFile
               + " in its SVNFileList field has a non-nullable dir field.");
     }
     if (illegalOrphanMessages != null) {
       throw new IllegalOrphanException(illegalOrphanMessages);
     }
     SVNRepo SVNRepo = dir.getSVNRepo();
     if (SVNRepo != null) {
       SVNRepo.getDirList().remove(dir);
       SVNRepo = em.merge(SVNRepo);
     }
     Revision revision = dir.getRevision();
     if (revision != null) {
       revision.getDirList().remove(dir);
       revision = em.merge(revision);
     }
     em.remove(dir);
     // em.getTransaction().commit();
   } finally {
     if (em != null) {
       // em.close();
     }
   }
 }
コード例 #28
0
 public void edit(Tipousuario tipousuario) throws NonexistentEntityException, Exception {
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     Tipousuario persistentTipousuario = em.find(Tipousuario.class, tipousuario.getTipUsuCod());
     Collection<Usuario> usuarioCollectionOld = persistentTipousuario.getUsuarioCollection();
     Collection<Usuario> usuarioCollectionNew = tipousuario.getUsuarioCollection();
     Collection<Usuario> attachedUsuarioCollectionNew = new ArrayList<Usuario>();
     for (Usuario usuarioCollectionNewUsuarioToAttach : usuarioCollectionNew) {
       usuarioCollectionNewUsuarioToAttach =
           em.getReference(
               usuarioCollectionNewUsuarioToAttach.getClass(),
               usuarioCollectionNewUsuarioToAttach.getUsuCod());
       attachedUsuarioCollectionNew.add(usuarioCollectionNewUsuarioToAttach);
     }
     usuarioCollectionNew = attachedUsuarioCollectionNew;
     tipousuario.setUsuarioCollection(usuarioCollectionNew);
     tipousuario = em.merge(tipousuario);
     for (Usuario usuarioCollectionOldUsuario : usuarioCollectionOld) {
       if (!usuarioCollectionNew.contains(usuarioCollectionOldUsuario)) {
         usuarioCollectionOldUsuario.setTipUsuCod(null);
         usuarioCollectionOldUsuario = em.merge(usuarioCollectionOldUsuario);
       }
     }
     for (Usuario usuarioCollectionNewUsuario : usuarioCollectionNew) {
       if (!usuarioCollectionOld.contains(usuarioCollectionNewUsuario)) {
         Tipousuario oldTipUsuCodOfUsuarioCollectionNewUsuario =
             usuarioCollectionNewUsuario.getTipUsuCod();
         usuarioCollectionNewUsuario.setTipUsuCod(tipousuario);
         usuarioCollectionNewUsuario = em.merge(usuarioCollectionNewUsuario);
         if (oldTipUsuCodOfUsuarioCollectionNewUsuario != null
             && !oldTipUsuCodOfUsuarioCollectionNewUsuario.equals(tipousuario)) {
           oldTipUsuCodOfUsuarioCollectionNewUsuario
               .getUsuarioCollection()
               .remove(usuarioCollectionNewUsuario);
           oldTipUsuCodOfUsuarioCollectionNewUsuario =
               em.merge(oldTipUsuCodOfUsuarioCollectionNewUsuario);
         }
       }
     }
     em.getTransaction().commit();
   } catch (Exception ex) {
     String msg = ex.getLocalizedMessage();
     if (msg == null || msg.length() == 0) {
       Integer id = tipousuario.getTipUsuCod();
       if (findTipousuario(id) == null) {
         throw new NonexistentEntityException(
             "The tipousuario with id " + id + " no longer exists.");
       }
     }
     throw ex;
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
コード例 #29
0
 public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException {
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     Empleado empleado;
     try {
       empleado = em.getReference(Empleado.class, id);
       empleado.getEmpDni();
     } catch (EntityNotFoundException enfe) {
       throw new NonexistentEntityException(
           "The empleado with id " + id + " no longer exists.", enfe);
     }
     List<String> illegalOrphanMessages = null;
     Collection<Usuario> usuarioCollectionOrphanCheck = empleado.getUsuarioCollection();
     for (Usuario usuarioCollectionOrphanCheckUsuario : usuarioCollectionOrphanCheck) {
       if (illegalOrphanMessages == null) {
         illegalOrphanMessages = new ArrayList<String>();
       }
       illegalOrphanMessages.add(
           "This Empleado ("
               + empleado
               + ") cannot be destroyed since the Usuario "
               + usuarioCollectionOrphanCheckUsuario
               + " in its usuarioCollection field has a non-nullable empDni field.");
     }
     if (illegalOrphanMessages != null) {
       throw new IllegalOrphanException(illegalOrphanMessages);
     }
     Turno turCod = empleado.getTurCod();
     if (turCod != null) {
       turCod.getEmpleadoCollection().remove(empleado);
       turCod = em.merge(turCod);
     }
     Cargo carCod = empleado.getCarCod();
     if (carCod != null) {
       carCod.getEmpleadoCollection().remove(empleado);
       carCod = em.merge(carCod);
     }
     Collection<Gastos> gastosCollection = empleado.getGastosCollection();
     for (Gastos gastosCollectionGastos : gastosCollection) {
       gastosCollectionGastos.setEmpDni(null);
       gastosCollectionGastos = em.merge(gastosCollectionGastos);
     }
     Collection<RegistroFalta> registroFaltaCollection = empleado.getRegistroFaltaCollection();
     for (RegistroFalta registroFaltaCollectionRegistroFalta : registroFaltaCollection) {
       registroFaltaCollectionRegistroFalta.setEmpDni(null);
       registroFaltaCollectionRegistroFalta = em.merge(registroFaltaCollectionRegistroFalta);
     }
     em.remove(empleado);
     em.getTransaction().commit();
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }
コード例 #30
0
 public void edit(Carrera carrera) throws NonexistentEntityException, Exception {
   EntityManager em = null;
   try {
     em = getEntityManager();
     em.getTransaction().begin();
     Carrera persistentCarrera = em.find(Carrera.class, carrera.getIdCarrera());
     Collection<Alumno> alumnoCollectionOld = persistentCarrera.getAlumnoCollection();
     Collection<Alumno> alumnoCollectionNew = carrera.getAlumnoCollection();
     Collection<Alumno> attachedAlumnoCollectionNew = new ArrayList<Alumno>();
     for (Alumno alumnoCollectionNewAlumnoToAttach : alumnoCollectionNew) {
       alumnoCollectionNewAlumnoToAttach =
           em.getReference(
               alumnoCollectionNewAlumnoToAttach.getClass(),
               alumnoCollectionNewAlumnoToAttach.getIdAlumnos());
       attachedAlumnoCollectionNew.add(alumnoCollectionNewAlumnoToAttach);
     }
     alumnoCollectionNew = attachedAlumnoCollectionNew;
     carrera.setAlumnoCollection(alumnoCollectionNew);
     carrera = em.merge(carrera);
     for (Alumno alumnoCollectionOldAlumno : alumnoCollectionOld) {
       if (!alumnoCollectionNew.contains(alumnoCollectionOldAlumno)) {
         alumnoCollectionOldAlumno.setIdCarreraFK(null);
         alumnoCollectionOldAlumno = em.merge(alumnoCollectionOldAlumno);
       }
     }
     for (Alumno alumnoCollectionNewAlumno : alumnoCollectionNew) {
       if (!alumnoCollectionOld.contains(alumnoCollectionNewAlumno)) {
         Carrera oldIdCarreraFKOfAlumnoCollectionNewAlumno =
             alumnoCollectionNewAlumno.getIdCarreraFK();
         alumnoCollectionNewAlumno.setIdCarreraFK(carrera);
         alumnoCollectionNewAlumno = em.merge(alumnoCollectionNewAlumno);
         if (oldIdCarreraFKOfAlumnoCollectionNewAlumno != null
             && !oldIdCarreraFKOfAlumnoCollectionNewAlumno.equals(carrera)) {
           oldIdCarreraFKOfAlumnoCollectionNewAlumno
               .getAlumnoCollection()
               .remove(alumnoCollectionNewAlumno);
           oldIdCarreraFKOfAlumnoCollectionNewAlumno =
               em.merge(oldIdCarreraFKOfAlumnoCollectionNewAlumno);
         }
       }
     }
     em.getTransaction().commit();
   } catch (Exception ex) {
     String msg = ex.getLocalizedMessage();
     if (msg == null || msg.length() == 0) {
       Integer id = carrera.getIdCarrera();
       if (findCarrera(id) == null) {
         throw new NonexistentEntityException("The carrera with id " + id + " no longer exists.");
       }
     }
     throw ex;
   } finally {
     if (em != null) {
       em.close();
     }
   }
 }