@Test
  public void shouldSyncDbAttributesWhileUpdatingWorkspace() throws Exception {
    final AccountImpl account = new AccountImpl("accountId", "namespace", "test");
    final WorkspaceImpl workspace = createWorkspace("id", account, "name");

    // persist the workspace
    manager.getTransaction().begin();
    manager.persist(account);
    manager.persist(workspace);
    manager.getTransaction().commit();
    manager.clear();

    // put a new attribute
    workspace
        .getConfig()
        .getProjects()
        .get(0)
        .getAttributes()
        .put("new-attr", singletonList("value"));
    workspaceDao.update(workspace);

    manager.clear();

    // check it's okay
    assertEquals(
        workspaceDao.get(workspace.getId()).getConfig().getProjects().get(0).getAttributes().size(),
        3);
  }
  @Test
  public void shouldCascadeRemoveObjectsWhenTheyRemovedFromEntity() {
    final AccountImpl account = new AccountImpl("accountId", "namespace", "test");
    final WorkspaceImpl workspace = createWorkspace("id", account, "name");

    // Persist the account
    manager.getTransaction().begin();
    manager.persist(account);
    manager.getTransaction().commit();
    manager.clear();

    // Persist the workspace
    manager.getTransaction().begin();
    manager.persist(workspace);
    manager.getTransaction().commit();
    manager.clear();

    // Cleanup one to many dependencies
    manager.getTransaction().begin();
    final WorkspaceConfigImpl config = workspace.getConfig();
    config.getProjects().clear();
    config.getCommands().clear();
    config.getEnvironments().clear();
    manager.merge(workspace);
    manager.getTransaction().commit();
    manager.clear();

    // If all the One To Many dependencies are removed then all the embedded objects
    // which depend on those object are also removed, which guaranteed by foreign key constraints
    assertEquals(asLong("SELECT COUNT(p) FROM ProjectConfig p"), 0L, "Project configs");
    assertEquals(asLong("SELECT COUNT(c) FROM Command c"), 0L, "Commands");
    assertEquals(asLong("SELECT COUNT(e) FROM Environment e"), 0L, "Environments");
  }
  @Test
  public void mapAndElementCollection() throws Exception {

    OneToManyAddress home = new OneToManyAddress();
    home.setCity("Paris");

    OneToManyAddress work = new OneToManyAddress();
    work.setCity("San Francisco");

    OneToManyUser user = new OneToManyUser();
    user.getAddresses().put("home", home);
    user.getAddresses().put("work", work);
    user.getNicknames().add("idrA");
    user.getNicknames().add("day[9]");

    em.persist(home);
    em.persist(work);
    em.persist(user);

    OneToManyUser user2 = new OneToManyUser();
    user2.getNicknames().add("idrA");
    user2.getNicknames().add("day[9]");

    em.persist(user2);
    em.flush();
    em.clear();

    user = em.find(OneToManyUser.class, user.getId());

    assertThat(user.getNicknames()).as("Should have 2 nick1").hasSize(2);
    assertThat(user.getNicknames()).as("Should contain nicks").contains("idrA", "day[9]");

    user.getNicknames().remove("idrA");
    user.getAddresses().remove("work");

    em.persist(user);
    em.flush();
    em.clear();

    user = em.find(OneToManyUser.class, user.getId());

    // TODO do null value
    assertThat(user.getAddresses()).as("List should have 1 elements").hasSize(1);
    assertThat(user.getAddresses().get("home").getCity())
        .as("home address should be under home")
        .isEqualTo(home.getCity());
    assertThat(user.getNicknames()).as("Should have 1 nick1").hasSize(1);
    assertThat(user.getNicknames()).as("Should contain nick").contains("day[9]");

    em.remove(user);
    // CascadeType.ALL 로 user 삭제 시 address 삭제 됨
    // em.srem(em.load(Address.class, home.getId()));
    // em.srem(em.load(Address.class, work.getId()));

    user2 = em.find(OneToManyUser.class, user2.getId());
    assertThat(user2.getNicknames()).as("Should have 2 nicks").hasSize(2);
    assertThat(user2.getNicknames()).as("Should contain nick").contains("idrA", "day[9]");
    em.remove(user2);
    em.flush();
  }
  @Test
  @Ignore
  public void testMoreHutsPaidAndNew() {
    final int id1 =
        reservationService.createReservationAdmin(ReservationModelUtils.createReservationModel());
    reservationService.updateReservationState(ReservationState.PAID.name(), id1);
    entityManager.clear();

    final int id2 =
        reservationService.createReservationAdmin(ReservationModelUtils.createReservationModel());
    reservationService.updateReservationState(ReservationState.PAID.name(), id2);
    entityManager.clear();

    final int id3 =
        reservationService.createReservationAdmin(ReservationModelUtils.createReservationModel());
    reservationService.updateReservationState(ReservationState.PAID.name(), id3);
    entityManager.clear();

    final int id4 =
        reservationService.createReservationAdmin(ReservationModelUtils.createReservationModel());

    reservationService.createReservationAdmin(ReservationModelUtils.createReservationModel());
    //
    final List<Reservation> reservations = reservationRepository.findAll();

    assertNotNull(reservations);
    assertFalse(reservations.isEmpty());
    assertEquals(5, reservations.size());
  }
  @Override
  public void syncronizePhotos() throws QueryModelException {
    List<Long> listPerTarjetas = new ArrayList<Long>();
    // Se obtienen las fotos de los usuarios que tienen tarjetas desde la base de datos
    try {
      TypedQuery<Long> cardsQuery =
          entityManagerSyncronize.createQuery(
              "select distinct x.perId from ScuVTarjeta x", Long.class);
      listPerTarjetas = cardsQuery.getResultList();
    } catch (Exception ex) {
      logger.error("No se ha podido consultar la base de datos.", ex);
      entityManagerSyncronize.clear();
      throw new QueryModelException(ex);
    }

    for (Long id : listPerTarjetas) {

      try {

        if (id == 164200) {
          selectPerson(id);
        } else {
          selectPerson(id);
        }
      } catch (QueryModelException qmEx) {
        logger.info("No se ha podido obtener la Foto del usuario de la base de datos.");
      }
    }
    entityManagerSyncronize.clear();
  }
  @Test(expected = RuntimeException.class)
  //    @Ignore("mails")
  public void testMoreHutsPaid() {
    final int id1 =
        reservationService.createReservationAdmin(ReservationModelUtils.createReservationModel());
    reservationService.updateReservationState(ReservationState.PAID.name(), id1);
    entityManager.clear();

    final int id2 =
        reservationService.createReservationAdmin(ReservationModelUtils.createReservationModel());
    reservationService.updateReservationState(ReservationState.PAID.name(), id2);
    entityManager.clear();

    final int id3 =
        reservationService.createReservationAdmin(ReservationModelUtils.createReservationModel());
    reservationService.updateReservationState(ReservationState.PAID.name(), id3);
    entityManager.clear();

    final int id4 =
        reservationService.createReservationAdmin(ReservationModelUtils.createReservationModel());
    reservationService.updateReservationState(ReservationState.PAID.name(), id4);
    entityManager.clear();

    reservationService.createReservationAdmin(ReservationModelUtils.createReservationModel());
  }
Beispiel #7
0
 @Test(expectedExceptions = OptimisticLockException.class)
 public void testOptimisticLockException() {
   ComponentSpec cs =
       createComponentSpec(
           Long.toString(1),
           "chris",
           "cs",
           "type1",
           "chris",
           Collections.<Tag>emptyList(),
           Collections.<String, String>emptyMap());
   em.getTransaction().begin();
   em.persist(cs);
   em.getTransaction().commit();
   em.clear();
   Assert.assertFalse(em.contains(cs));
   em.getTransaction().begin();
   ComponentSpec orig = em.find(ComponentSpec.class, Long.toString(1));
   orig.setComponentName("revisedName");
   em.getTransaction().commit();
   em.clear();
   ComponentSpec current = em.find(ComponentSpec.class, Long.toString(1));
   Assert.assertEquals(current.getObjVersion(), 1);
   Assert.assertEquals(cs.getObjVersion(), 0);
   em.getTransaction().begin();
   em.merge(cs);
   em.getTransaction()
       .commit(); // optimistic lock exception should be thrown as there has been an intervening
                  // commit
 }
  public void testNonInsertableAndUpdatable121Mappings() {
    EntityManager em = createEntityManager();

    try {
      beginTransaction(em);

      Order order = new Order();
      order.setQuantity(10);

      Item item = new Item();
      item.setName("Party Balloons");
      order.setItem(item);

      Item itemPair = new Item();
      itemPair.setName("Ribbons");
      order.setItemPair(itemPair);

      em.persist(order);
      em.persist(item);
      em.persist(itemPair);
      commitTransaction(em);

      em.clear();
      clearCache();

      // Now try to read it back and update.
      beginTransaction(em);

      order = em.find(Order.class, order.getOrderId());

      assertTrue("The item pair was inserted", order.getItemPair() == null);
      order.setItemPair(em.merge(itemPair));

      Item newItem = new Item();
      newItem.setName("Party Boots");
      order.setItem(newItem);

      em.persist(newItem);
      commitTransaction(em);

      em.clear();
      clearCache();

      order = em.find(Order.class, order.getOrderId());

      assertTrue("The item pair was not updated.", order.getItemPair() != null);
      assertTrue("Orginal item was replaced", order.getItem().getItemId().equals(item.getItemId()));
      assertFalse(
          "New item replaced original item",
          order.getItem().getItemId().equals(newItem.getItemId()));

    } catch (IllegalStateException e) {
      if (isTransactionActive(em)) {
        rollbackTransaction(em);
      }
    } finally {
      closeEntityManager(em);
    }
  }
  private void selectPerson(long id) throws QueryModelException {
    ICacheEntry cacheEntry = null;
    PerFoto perFotos = null;

    try {
      TypedQuery<PerFoto> photosQuery =
          entityManagerSyncronize.createQuery(
              "select x from PerFotos x where x.perId = '" + id + "'", PerFoto.class);
      perFotos = photosQuery.getSingleResult();
    } catch (Exception ex) {
      entityManagerSyncronize.clear();
      throw new QueryModelException(ex);
    }

    byte[] cacheEntryBytes = null;
    Date cacheEntryTimestamp = null;

    try {
      cacheEntry = this.diskCache.getEntry(perFotos.getPerId());
    } catch (DiskCacheException dcEx) {
      logger.error("No se ha podido obtener la entrada para el perId indicado", dcEx);
    }

    if (cacheEntry != null) {
      try {
        cacheEntryBytes = cacheEntry.getBytes();
        cacheEntryTimestamp = cacheEntry.getTimestamp();
        if (cacheEntryBytes == null
            || cacheEntryTimestamp == null
            || cacheEntryTimestamp.compareTo(perFotos.getFecha()) < 0) {
          try {
            diskCache.addEntry(perFotos.getPerId(), perFotos.getFecha(), perFotos.getBinario());
          } catch (DiskCacheException dcEx) {
            logger.error("No se ha podido persistir la entrada en disco", dcEx);
          }
        }
      } catch (DiskCacheException dcEx) {
        logger.error("No se han podido obtener los parametros de la entrada", dcEx);
      }
    } else {
      try {
        diskCache.addEntry(perFotos.getPerId(), perFotos.getFecha(), perFotos.getBinario());
      } catch (DiskCacheException dcEx) {
        logger.error("No se ha podido persistir la entrada en disco", dcEx);
      }
    }
    entityManagerSyncronize.clear();
  }
Beispiel #10
0
  @Override
  public void clear() {
    EntityManager em = emf.createEntityManager();
    EntityTransaction txn = em.getTransaction();

    try {
      // the clear operation often deadlocks - let's try several times
      for (int i = 0; ; ++i) {
        txn.begin();
        try {
          log.trace("Clearing JPA Store");
          String entityTable = em.getMetamodel().entity(configuration.entityClass()).getName();
          @SuppressWarnings("unchecked")
          List<Object> items = em.createQuery("FROM " + entityTable).getResultList();
          for (Object o : items) em.remove(o);
          if (configuration.storeMetadata()) {
            String metadataTable = em.getMetamodel().entity(MetadataEntity.class).getName();
            Query clearMetadata = em.createQuery("DELETE FROM " + metadataTable);
            clearMetadata.executeUpdate();
          }
          txn.commit();
          em.clear();
          break;
        } catch (Exception e) {
          log.trace("Failed to clear store", e);
          if (i >= 10) throw new JpaStoreException("Exception caught in clear()", e);
        } finally {
          if (txn != null && txn.isActive()) txn.rollback();
        }
      }
    } finally {
      em.close();
    }
  }
 @Override
 public List<VigenciasNormasEmpleados> buscarVigenciasNormasEmpleados(EntityManager em) {
   em.clear();
   CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
   cq.select(cq.from(VigenciasNormasEmpleados.class));
   return em.createQuery(cq).getResultList();
 }
Beispiel #12
0
  public void modifyAttribute(
      String uniqueIdentifier, Attribute attribute, HashMap<String, String> parameters)
      throws KLMSItemNotFoundException {
    EntityManager em = emf.createEntityManager();
    em.getTransaction().begin();

    ManagedObject object = getObjectByUID(uniqueIdentifier, em);
    ArrayList<Attribute> objectAttributes = object.getAttributes();

    for (Attribute attrib : objectAttributes) {
      if (attrib.getAttributeName().equals(attribute.getAttributeName())) {
        KLMSAttributeValue[] values = attrib.getValues();
        KLMSAttributeValue[] newValues = attribute.getValues();
        if (attrib.getAttributeType() == EnumTypeKLMS.Structure) {
          for (int i = 0; i < values.length; i++) {
            attrib.setValue(newValues[i].getValueString(), newValues[i].getName());
          }
        } else {
          attrib.setValue(newValues[0].getValueString(), null);
        }
      }
    }

    em.getTransaction().commit();
    em.clear();
  }
Beispiel #13
0
  private void commonTestFindLockModeIsolations(
      EntityManager em,
      LockModeType lockMode,
      int expectedSupportSQLCount,
      String expectedSupportSQL,
      int expectedNonSupportSQLCount,
      String expectedNonSupportSQL,
      int expectedVersionUpdateCount,
      String expectedVersionUpdateSQL) {
    OpenJPAEntityManager oem = (OpenJPAEntityManager) em.getDelegate();
    JDBCFetchConfigurationImpl fConfig =
        (JDBCFetchConfigurationImpl) ((EntityManagerImpl) oem).getBroker().getFetchConfiguration();
    DBDictionary dict =
        ((JDBCConfiguration) ((OpenJPAEntityManagerSPI) oem).getConfiguration())
            .getDBDictionaryInstance();

    em.clear();
    resetSQL();
    int beforeIsolation = fConfig.getIsolation();
    em.find(LockEmployee.class, 1, lockMode);
    if (dict.supportsIsolationForUpdate() && dict instanceof DB2Dictionary) {
      assertEquals(expectedSupportSQLCount, getSQLCount());
      assertAllSQLInOrder(expectedSupportSQL);
    } else {
      assertEquals(expectedNonSupportSQLCount, getSQLCount());
      assertAllSQLInOrder(expectedNonSupportSQL);
    }

    resetSQL();
    em.flush();
    assertEquals(expectedVersionUpdateCount, getSQLCount());
    if (expectedVersionUpdateSQL != null) assertAllSQLInOrder(expectedVersionUpdateSQL);

    assertEquals(beforeIsolation, fConfig.getIsolation());
  }
  @Test
  public void testJPAPolymorphicCollection() throws Exception {
    em.getTransaction().begin();
    Hero h = new Hero();
    h.setName("Spartacus");
    em.persist(h);
    SuperHero sh = new SuperHero();
    sh.setName("Batman");
    sh.setSpecialPower("Technology and samurai techniques");
    em.persist(sh);
    HeroClub hc = new HeroClub();
    hc.setName("My hero club");
    hc.getMembers().add(h);
    hc.getMembers().add(sh);
    em.persist(hc);
    em.getTransaction().commit();

    em.clear();

    em.getTransaction().begin();
    HeroClub lhc = em.find(HeroClub.class, hc.getName());
    assertThat(lhc).isNotNull();
    Hero lh = lhc.getMembers().get(0);
    assertThat(lh).isNotNull();
    assertThat(lh).isInstanceOf(Hero.class);
    Hero lsh = lhc.getMembers().get(1);
    assertThat(lsh).isNotNull();
    assertThat(lsh).isInstanceOf(SuperHero.class);
    lhc.getMembers().clear();
    em.remove(lh);
    em.remove(lsh);
    em.remove(lhc);
    em.getTransaction().commit();
  }
Beispiel #15
0
  public static void main(String[] args) {

    EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("myunit");

    EntityManager manager = entityManagerFactory.createEntityManager();

    Teacher teacher1 = new Teacher("Bloch3", 5);
    for (int i = 0; i < 1000; i++) {
      teacher1.getCourses().add(new Course(String.valueOf(i), "desc", teacher1));
    }

    manager.getTransaction().begin();
    manager.persist(teacher1);
    manager.getTransaction().commit();

    manager.clear();

    Teacher teacher =
        manager
            .createQuery("SELECT t FROM Teacher t WHERE t.name = :tName", Teacher.class)
            .setParameter("tName", "Bloch")
            .getSingleResult();

    System.out.println(teacher);

    int level = teacher.getLevel();

    int size = teacher.getCourses().size();
  }
 public boolean estudianteCumplePreRequisitos(Integer id, Integer prerequisitoCursoId)
     throws NoPrerrequisitosException {
   EntityManager em = emf.createEntityManager();
   EntityTransaction tx = em.getTransaction();
   boolean ret = false;
   try {
     tx = em.getTransaction();
     tx.begin();
     tx.commit();
     ret = service.estudianteCumplePreRequisitos(id, prerequisitoCursoId, em);
     if (ret == false)
       throw new NoPrerrequisitosException("El estudiante no cumple con los prerequisitos");
   } catch (Exception e) {
     if (em != null && tx != null) {
       tx.rollback();
     }
     throw new NoPrerrequisitosException("El estudiante no cumple con los prerequisitos");
   } finally {
     if (em != null) {
       em.clear();
       em.close();
     }
     return ret;
   }
 }
  public void testPersistAttachment() {
    Attachment attach1 = new Attachment();
    attach1.setId(2);
    attach1.setDescription("some attachment description");
    attach1.setPath("/home/user");

    manager.getTransaction().begin();
    manager.persist(attach1);
    manager.getTransaction().commit();
    manager.getTransaction().begin();
    manager.clear();
    manager.getTransaction().commit();
    manager.getTransaction().begin();
    Attachment att = manager.find(Attachment.class, 2);
    assertEquals("/home/user", att.getPath());
    manager.getTransaction().commit();

    StringWriter writer = new StringWriter();
    try {
      traceDatabase(writer);
      System.out.println(writer);
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }
  @Test
  public void testCreateAndFindMessage() {
    Message msg = new Message();

    msg.setText("Hallo JPA");
    msg.setDate(new Date());

    em.getTransaction().begin();
    em.persist(msg);
    msg.setSubject("My new subject");
    em.getTransaction().commit();

    em.clear();

    Message found = em.find(Message.class, msg.getId());
    assertNotNull("Should find message object.", found);
    em.getTransaction().begin();
    found.setSubject("Very new subject");
    em.getTransaction().commit();

    em.close();
    em = emf.createEntityManager();

    found.setText("Changed in detached mode");

    em.getTransaction().begin();
    Message merged = em.merge(found);
    merged.setSubject("Merged");
    em.getTransaction().commit();

    //        em.refresh(found);
    assertNotNull("Message should be found.", found);
  }
  @Test
  public void testJTAStandalone() throws Exception {

    final EntityManagerFactory emf =
        Persistence.createEntityManagerFactory(
            "jpajtastandalone", TestHelper.getEnvironmentProperties());

    TransactionManager transactionManager = extractJBossTransactionManager(emf);

    transactionManager.begin();
    final EntityManager em = emf.createEntityManager();
    Poem poem = new Poem();
    poem.setName("L'albatros");
    em.persist(poem);
    transactionManager.commit();

    em.clear();

    transactionManager.begin();
    poem = em.find(Poem.class, poem.getId());
    assertThat(poem).isNotNull();
    assertThat(poem.getName()).isEqualTo("L'albatros");
    em.remove(poem);
    transactionManager.commit();

    em.close();

    dropSchemaAndDatabase(emf);
    emf.close();
  }
Beispiel #20
0
  private void withBatch() {
    int entityCount = 100;
    // tag::batch-session-batch-insert-example[]
    EntityManager entityManager = null;
    EntityTransaction txn = null;
    try {
      entityManager = entityManagerFactory().createEntityManager();

      txn = entityManager.getTransaction();
      txn.begin();

      int batchSize = 25;

      for (int i = 0; i < entityCount; ++i) {
        Person Person = new Person(String.format("Person %d", i));
        entityManager.persist(Person);

        if (i % batchSize == 0) {
          // flush a batch of inserts and release memory
          entityManager.flush();
          entityManager.clear();
        }
      }

      txn.commit();
    } catch (RuntimeException e) {
      if (txn != null && txn.isActive()) txn.rollback();
      throw e;
    } finally {
      if (entityManager != null) {
        entityManager.close();
      }
    }
    // end::batch-session-batch-insert-example[]
  }
Beispiel #21
0
  public void verifyUserPermission(UserPermissionEntry requestUserPermissionEntry)
      throws KLMSPermissionDeniedException {
    EntityManager em = emf.createEntityManager();
    em.getTransaction().begin();

    String query =
        "select k from UserPermissionEntry k where k.uid = '"
            + requestUserPermissionEntry.getUniqueIdentifier()
            + "'";
    TypedQuery<UserPermissionEntry> tq = em.createQuery(query, UserPermissionEntry.class);
    UserPermissionEntry userPermissionEntry = tq.getSingleResult();

    if (userPermissionEntry.hasCredential() && !requestUserPermissionEntry.hasCredential()) {
      throw new KLMSPermissionDeniedException("Request Credential is missing");
    }
    if (userPermissionEntry.hasCredential() && requestUserPermissionEntry.hasCredential()) {
      if (!userPermissionEntry.equals(requestUserPermissionEntry)) {
        throw new KLMSPermissionDeniedException(
            "Request Credential does not match the Credential of the requested Object");
      }
    }

    em.getTransaction().commit();
    em.clear();
  }
Beispiel #22
0
  public void testEnumInEmbeddedId() {
    EntityManager em = emf.createEntityManager();
    Beneficiary b = new Beneficiary();
    b.setId("b8");
    List<BeneContact> contacts = new ArrayList<BeneContact>();
    BeneContact c = new BeneContact();
    c.setEmail("email8");
    BeneContactId id = new BeneContactId();
    id.setContactType(BeneContactId.ContactType.HOME);
    c.setBeneficiary(b);

    c.setId(id);
    em.persist(c);
    contacts.add(c);
    b.setContacts(contacts);
    em.persist(b);
    em.getTransaction().begin();
    em.flush();
    em.getTransaction().commit();
    em.clear();
    BeneContactId id1 = c.getId();
    BeneContact c1 = em.find(BeneContact.class, id1);
    assertEquals("email8", c1.getEmail());
    em.close();
  }
Beispiel #23
0
  public Hashtable<String, String> getNumberOfObjects() {
    Hashtable<String, String> objects = new Hashtable<>();

    EntityManager em = emf.createEntityManager();
    em.getTransaction().begin();

    Query q = em.createNativeQuery("SELECT count(ID) AS Anzahl FROM MANAGEDOBJECT");
    objects.put("Managed Objects", q.getSingleResult().toString());

    Query q2 = em.createNativeQuery("SELECT count(ID) AS Anzahl FROM SYMMETRICKEY");
    objects.put("Symmetric Keys", q2.getSingleResult().toString());

    Query q3 = em.createNativeQuery("SELECT count(ID) AS Anzahl FROM TEMPLATE");
    objects.put("Templates", q3.getSingleResult().toString());

    Query q4 = em.createNativeQuery("SELECT count(ID) AS Anzahl FROM PRIVATEKEY");
    objects.put("Private Keys", q4.getSingleResult().toString());

    Query q5 = em.createNativeQuery("SELECT count(ID) AS Anzahl FROM PUBLICKEY");
    objects.put("Public Keys", q5.getSingleResult().toString());

    Query q6 = em.createNativeQuery("SELECT count(ID) AS Anzahl FROM SECRETDATA");
    objects.put("Secret Data", q6.getSingleResult().toString());

    //		Query q7 = em.createNativeQuery("SELECT count(ID) AS Anzahl FROM CERTIFICATE");
    //		objects.put("Certificates", q7.getSingleResult().toString());

    //		Query q8 = em.createNativeQuery("SELECT count(ID) AS Anzahl FROM OPAQUEOBJECT");
    //		objects.put("Opaque Objects", q8.getSingleResult().toString());

    em.getTransaction().commit();
    em.clear();

    return objects;
  }
Beispiel #24
0
 public void add(ManagedObject o) {
   EntityManager em = emf.createEntityManager();
   em.getTransaction().begin();
   em.persist(o);
   em.getTransaction().commit();
   em.clear();
 }
  public Committer createCommit(Committer c) {
    em.persist(c);

    tx.commit();

    em.clear();
    return c;
  }
  @BeforeClass
  public static void setUp() throws Exception {
    entityManager = provider.em();
    transaction = provider.tx();
    transaction.begin();

    entityManager.flush();
    entityManager.clear();
  }
 @Override
 public void create(Location location) {
   try {
     entityManager.persist(location);
   } catch (RuntimeException ex) {
     entityManager.clear();
     throw ex;
   }
 }
Beispiel #28
0
  public void persistUserPermissionEntry(UserPermissionEntry userPermissionEntry) {
    EntityManager em = emf.createEntityManager();
    em.getTransaction().begin();

    em.persist(userPermissionEntry);

    em.getTransaction().commit();
    em.clear();
  }
Beispiel #29
0
 public void addManagedObjects(ArrayList<ManagedObject> moList) {
   EntityManager em = emf.createEntityManager();
   em.getTransaction().begin();
   for (ManagedObject mo : moList) {
     em.persist(mo);
   }
   em.getTransaction().commit();
   em.clear();
 }
Beispiel #30
0
  public void recover(String uniqueIdentifier) throws KLMSItemNotFoundException {
    EntityManager em = emf.createEntityManager();
    em.getTransaction().begin();

    getObjectByUID(uniqueIdentifier, em).recover();

    em.getTransaction().commit();
    em.clear();
  }