public void revoke(Set<DataverseRole> roles, RoleAssignee assignee, DvObject defPoint) {
   for (DataverseRole role : roles) {
     em.createNamedQuery("RoleAssignment.deleteByAssigneeIdentifier_RoleIdDefinition_PointId")
         .setParameter("assigneeIdentifier", assignee.getIdentifier())
         .setParameter("roleId", role.getId())
         .setParameter("definitionPointId", defPoint.getId())
         .executeUpdate();
     em.refresh(role);
   }
   em.refresh(assignee);
 }
Exemplo n.º 2
0
  @Test
  public void checkPositionsNotNull() throws Exception {
    EntityManager em = getEm();
    HIterationProject project = em.find(HIterationProject.class, 1l);
    // assertThat( project, notNullValue() );

    HDocument hdoc = new HDocument("fullpath", ContentType.TextPlain, en_US);
    hdoc.setProjectIteration(project.getProjectIterations().get(0));

    List<HTextFlow> textFlows = hdoc.getTextFlows();
    HTextFlow flow1 = new HTextFlow(hdoc, "textflow1", "some content");
    HTextFlow flow2 = new HTextFlow(hdoc, "textflow2", "more content");
    textFlows.add(flow1);
    textFlows.add(flow2);
    em.persist(hdoc);
    em.flush();
    // em.clear();
    // hdoc = em.find(HDocument.class, docId);
    em.refresh(hdoc);

    List<HTextFlow> textFlows2 = hdoc.getTextFlows();
    assertThat(textFlows2.size(), is(2));
    flow1 = textFlows2.get(0);
    assertThat(flow1, notNullValue());
    flow2 = textFlows2.get(1);
    assertThat(flow2, notNullValue());

    // TODO: we should automate this...
    hdoc.incrementRevision();

    textFlows2.remove(flow1);
    flow1.setObsolete(true);
    dao.syncRevisions(hdoc, flow1);

    // flow1.setPos(null);
    em.flush();
    em.refresh(hdoc);
    em.refresh(flow1);
    em.refresh(flow2);
    assertThat(hdoc.getTextFlows().size(), is(1));
    flow2 = hdoc.getTextFlows().get(0);
    assertThat(flow2.getResId(), equalTo("textflow2"));

    flow1 = hdoc.getAllTextFlows().get("textflow1");
    // assertThat(flow1.getPos(), nullValue());
    assertThat(flow1.isObsolete(), is(true));
    assertThat(flow1.getRevision(), is(2));
    flow2 = hdoc.getAllTextFlows().get("textflow2");
    // assertThat(flow1.getPos(), is(0));
    assertThat(flow2.isObsolete(), is(false));
  }
  @Transactional
  @RequestMapping(value = "/fileRegistered", method = RequestMethod.POST)
  public ModelAndView newFileRegistered(
      @ModelAttribute("file") file file,
      BindingResult result1,
      @ModelAttribute("client") @Valid client client,
      BindingResult result2,
      ModelAndView model) {

    if (result1.hasErrors()) {
      model.setViewName("error");
      System.out.println("File error");
      return model;
    }

    if (result2.hasErrors()) {
      model.setViewName("error");
      System.out.println("Client error");
      return model;
    }

    model.setViewName("success");

    em.persist(client);
    em.flush();
    em.refresh(client);

    file.setClient_ClientID(client.getClientId());
    em.persist(file);

    mapFileWithEmployee(file.getFileNumber(), file.getFileName(), file.getAssignedAdvocate());

    return model;
  }
 @Transactional
 public AccessKey authenticate(@NotNull String key) {
   Optional<AccessKey> accessKeyOpt =
       genericDAO
           .createNamedQuery(AccessKey.class, "AccessKey.getByKey", Optional.of(CacheConfig.get()))
           .setParameter("someKey", key)
           .getResultList()
           .stream()
           .findFirst();
   if (!accessKeyOpt.isPresent()) {
     return null;
   }
   AccessKey accessKey = accessKeyOpt.get();
   final Long expirationPeriod =
       configurationService.getLong(Constants.SESSION_TIMEOUT, Constants.DEFAULT_SESSION_TIMEOUT);
   if (accessKey.getExpirationDate() != null) {
     final Long expiresIn =
         accessKey.getExpirationDate().getTime() - timestampService.getTimestamp().getTime();
     if (AccessKeyType.SESSION == accessKey.getType()
         && expiresIn > 0
         && expiresIn < expirationPeriod / 2) {
       em.refresh(accessKey, LockModeType.PESSIMISTIC_WRITE);
       accessKey.setExpirationDate(
           new Date(timestampService.getTimestamp().getTime() + expirationPeriod));
       return genericDAO.merge(accessKey);
     }
   }
   return accessKey;
 }
Exemplo n.º 5
0
 public void refresh(Map map) {
   try {
     entityManager.refresh(map);
   } catch (RuntimeException e) {
     throw e;
   }
 }
  /**
   * Refresh method test loads an entity with two different entity managers. One updates the entity
   * and another refreshes it. The test checks whether refreshed entity contains changes.
   */
  @Test
  public void entityEquality_refresh_EntityManager() {
    // load an entity
    EntityManager emRefresh = factory.createEntityManager();
    Person person1 = emRefresh.find(Person.class, SIMON_SLASH_ID);

    // load the same entity by different entity manager
    EntityManager emChange = factory.createEntityManager();
    Person person2 = emChange.find(Person.class, SIMON_SLASH_ID);

    // change the first entity - second entity remains the same
    emRefresh.getTransaction().begin();
    person1.setFirstName("refreshDemo");
    assertNotSame("refreshDemo", person2.getFirstName());

    // commit the transaction - second entity still remains the same
    emRefresh.getTransaction().commit();
    assertNotSame("refreshDemo", person2.getFirstName());

    // refresh second entity - it changes
    emChange.refresh(person2);
    assertEquals("refreshDemo", person2.getFirstName());

    emRefresh.close();
    emChange.close();
  }
Exemplo n.º 7
0
 public void refresh(Base base) {
   try {
     entityManager.refresh(base);
   } catch (RuntimeException e) {
     throw e;
   }
 }
 /**
  * Finds a Person in the database given its id.
  *
  * @param personId The id of the person
  * @return The found person
  */
 public static Person getPersonById(int personId) {
   EntityManager em = Assignment3Dao.instance.createEntityManager();
   Person person = em.find(Person.class, personId);
   if (person != null) em.refresh(person);
   Assignment3Dao.instance.closeConnections(em);
   return person;
 }
 /** Test refresh. */
 public void testRefresh() {
   EntityManager em = createEntityManager();
   beginTransaction(em);
   Order order = new Order();
   try {
     order.id = this.nextId++;
     order.orderedBy = "ACME";
     order.address = new Address();
     order.address.city = "Ottawa";
     em.persist(order);
     commitTransaction(em);
   } finally {
     closeEntityManagerAndTransaction(em);
   }
   clearCache();
   em = createEntityManager();
   beginTransaction(em);
   try {
     order = em.find(Order.class, order.id);
     order.orderedBy = "Fred Jones";
     em.refresh(order);
     if (order.orderedBy.equals("Fred Jones")) {
       fail("Refresh failed: " + order.orderedBy);
     }
   } finally {
     closeEntityManagerAndTransaction(em);
   }
 }
  public void testPostPersistBusInheritAndDefault() {
    int busListenerPostPersistCountBefore = BusListener.POST_PERSIST_COUNT;
    int fueledVehiclePostPersistCountBefore = FueledVehicleListener.POST_PERSIST_COUNT;
    int defaultListenerPostPersistCountBefore = DefaultListener.POST_PERSIST_COUNT;
    int defaultListenerPostLoadCountBefore = DefaultListener.POST_LOAD_COUNT;
    int defaultListenerPostLoadCountIntermidiate;

    EntityManager em = createEntityManager();
    beginTransaction(em);

    try {
      Bus bus = new Bus();
      bus.setPassengerCapacity(new Integer(50));
      bus.setFuelCapacity(new Integer(175));
      bus.setDescription("OC Transpo Bus");
      bus.setFuelType("Diesel");
      em.persist(bus);
      em.flush();

      // This should fire a postLoad event ...
      em.refresh(bus);
      defaultListenerPostLoadCountIntermidiate = DefaultListener.POST_LOAD_COUNT;

      javax.persistence.Query q =
          em.createQuery("select distinct b from Bus b where b.id = " + bus.getId());
      // This should not fire a postLoad event ...
      q.getResultList();

      commitTransaction(em);
    } catch (RuntimeException ex) {
      if (isTransactionActive(em)) {
        rollbackTransaction(em);
      }

      closeEntityManager(em);
      throw ex;
    }

    int busListenerPostPersistCountAfter = BusListener.POST_PERSIST_COUNT;
    int fueledVehiclePostPersistCountAfter = FueledVehicleListener.POST_PERSIST_COUNT;
    int defaultListenerPostPersistCountAfter = DefaultListener.POST_PERSIST_COUNT;
    int defaultListenerPostLoadCountAfter = DefaultListener.POST_LOAD_COUNT;

    assertFalse(
        "The PostPersist callback method on BusListener was not called.",
        busListenerPostPersistCountBefore == busListenerPostPersistCountAfter);
    assertFalse(
        "The PostPersist callback method on FueledVehicleListener was not called.",
        fueledVehiclePostPersistCountBefore == fueledVehiclePostPersistCountAfter);
    assertFalse(
        "The PostPersist callback method on DefaultListener was not called.",
        defaultListenerPostPersistCountBefore == defaultListenerPostPersistCountAfter);
    assertTrue(
        "The PostLoad callback method on DefaultListener was called more than once, possibly on the refresh.",
        (defaultListenerPostLoadCountIntermidiate - defaultListenerPostLoadCountBefore) == 1);
    assertTrue(
        "The PostLoad callback method on DefaultListener was called on the getQueryResult().",
        defaultListenerPostLoadCountIntermidiate == defaultListenerPostLoadCountAfter);
  }
Exemplo n.º 11
0
 public Usuario refresh(Usuario usuario) {
   entityManager.getTransaction().begin();
   Usuario u = entityManager.merge(usuario);
   entityManager.refresh(u);
   entityManager.getTransaction().commit();
   entityManager.close();
   return u;
 }
Exemplo n.º 12
0
 @Override
 public void setPrintReadState(EntityPrint.EnumReadStatus readState, EntityPrint print) {
   print = em.merge(print);
   em.refresh(print);
   print.setReadStatus(readState);
   em.persist(print);
   em.flush();
 }
 @Override
 protected Product createMock() {
   com.tasktop.c2c.server.internal.tasks.domain.Product mockProduct =
       MockProductFactory.create(entityManager);
   entityManager.flush();
   entityManager.refresh(mockProduct);
   return (Product) mockProduct;
 }
Exemplo n.º 14
0
 @Override
 public CulturalCategory createCulturalCategory(CulturalCategory culturalCategory)
     throws Exception {
   em.persist(culturalCategory);
   em.flush();
   em.refresh(culturalCategory);
   return culturalCategory;
 }
Exemplo n.º 15
0
 public void reload() {
   TypedQuery<Article> q = em.createQuery("select u from Article u", Article.class);
   articles = q.getResultList();
   for (Article a : articles) {
     em.refresh(a);
   }
   fireTableDataChanged();
 }
  @Override
  public void refresh(Object entity, LockModeType lockMode, Map<String, Object> properties) {
    EntityManager em = getCurrent();

    if (em != null) {
      em.refresh(entity, lockMode, properties);
      return;
    }

    em = createEntityManager();

    try {
      em.refresh(entity, lockMode, properties);
    } finally {
      freeEntityManager(em);
    }
  }
  /**
   * Find person by id
   *
   * @param personId
   * @return
   */
  public static Person getPersonById(int personId) {
    EntityManager em = LifeStyleDao.instance.createEntityManager();
    Person p = em.find(Person.class, personId);
    if (p != null) em.refresh(p);

    LifeStyleDao.instance.closeConnections(em);

    return p;
  }
Exemplo n.º 18
0
 @Override
 @Transactional(value = "transactionManager")
 public T refresh(final PK id) {
   if (type == null) {
     throw new UnsupportedOperationException("The type must be set to use this method.");
   }
   T managedEntity = entityManager.find(type, id);
   entityManager.refresh(managedEntity);
   return managedEntity;
 }
Exemplo n.º 19
0
 @Override
 @Transactional(value = "transactionManager")
 public T refresh(final T transientObject) {
   T managedEntity = null;
   if (entityManager.contains(transientObject)) {
     managedEntity = transientObject;
   } else {
     managedEntity = entityManager.merge(transientObject);
   }
   entityManager.refresh(managedEntity);
   return managedEntity;
 }
Exemplo n.º 20
0
 protected Object saveOrUpdate(final Object entity) {
   Object updatedEntity = entity;
   try {
     if (!entityManager.contains(entity)) {
       updatedEntity = entityManager.merge(entity);
     }
   } catch (IllegalArgumentException e) {
     // Exception thrown from merge method because entity does not yet exist in the DB
     entityManager.persist(updatedEntity);
   }
   entityManager.flush();
   entityManager.refresh(updatedEntity);
   return updatedEntity;
 }
Exemplo n.º 21
0
  public VDC findByAlias(String alias) {
    String query = "SELECT v from VDC v where v.alias = :fieldName";
    VDC vdc = null;
    try {
      vdc = (VDC) em.createQuery(query).setParameter("fieldName", alias).getSingleResult();
      em.refresh(
          vdc); // Refresh because the cached object doesn't include harvestingDataverse object -
                // need to review why this is happening
    } catch (javax.persistence.NoResultException e) {
      // Do nothing, just return null.
    }

    return vdc;
  }
  /** Refresh on detached entity throws an IllegalArgumentException. */
  @Test
  public void refreshDetachedEntity() {
    EntityManager em = factory.createEntityManager();
    Person person1 = em.find(Person.class, SIMON_SLASH_ID);

    em.detach(person1);
    try {
      em.refresh(person1);
    } catch (IllegalArgumentException ex) {
      em.close();
      return;
    }

    fail("An exception was expected.");
  }
  /** Refresh the state of the instance from the database. */
  @Override
  public void refresh(Object entity) {
    EntityManager em = getCurrent();

    if (em != null) {
      em.refresh(entity);
      return;
    }

    try {
      if (_ut.getStatus() == Status.STATUS_NO_TRANSACTION)
        throw new TransactionRequiredException(L.l("refresh must be called within transaction."));
    } catch (SystemException e) {
      throw new RuntimeException(e);
    }

    em = createEntityManager();

    try {
      em.refresh(entity);
    } finally {
      freeEntityManager(em);
    }
  }
Exemplo n.º 24
0
  @GET
  @Path("/list/{userId}")
  @Produces("application/json")
  public Response getJsonList(@PathParam("userId") int id) {
    User user = em.find(User.class, id);
    if (user != null) {
      em.refresh(user);
      List<Account> list = user.getAccounts();
      if (!list.isEmpty()) {
        GenericEntity<List<Account>> entity = new GenericEntity<List<Account>>(list) {};
        return Response.ok(entity).build();
      }
    }

    return Response.status(Status.NOT_FOUND).build();
  }
Exemplo n.º 25
0
 @Override
 @Transactional
 public ProfileImpl getById(String userId) throws NotFoundException, ServerException {
   requireNonNull(userId, "Required non-null id");
   try {
     final EntityManager manager = managerProvider.get();
     final ProfileImpl profile = manager.find(ProfileImpl.class, userId);
     if (profile == null) {
       throw new NotFoundException(format("Couldn't find profile for user with id '%s'", userId));
     }
     manager.refresh(profile);
     return profile;
   } catch (RuntimeException x) {
     throw new ServerException(x.getLocalizedMessage(), x);
   }
 }
 // email, password
 // notificationType, notficationId,
 @POST
 @Path("getall")
 @Consumes("application/json")
 @Produces("application/json")
 public JsonObject putJson(JsonObject content) {
   String email = content.getString(JsonStrings.email);
   String password = content.getString(JsonStrings.password);
   JsonObjectBuilder builder = Json.createObjectBuilder();
   User user = null;
   try {
     user =
         em.createNamedQuery("User.findByEmail", User.class)
             .setParameter("email", email)
             .getSingleResult();
   } catch (NoResultException e) {
   }
   if (user == null) {
     throw new UnsupportedOperationException();
   }
   if (!user.getPassword().equals(password)) {
     throw new UnsupportedOperationException();
   }
   activeBean.register(content, user);
   em.refresh(em.merge(user));
   Collection<UsersNotifications> usersNotifications = null;
   usersNotifications = user.getUsersNotificationsCollection();
   if (usersNotifications == null || usersNotifications.isEmpty()) {
     builder.add(JsonStrings.newNotifications, false);
     return builder.build();
   }
   builder.add(JsonStrings.newNotifications, true);
   JsonArrayBuilder arrayBuilder = Json.createArrayBuilder();
   for (UsersNotifications notification : usersNotifications) {
     JsonObjectBuilder internalBuilder = Json.createObjectBuilder();
     internalBuilder.add(JsonStrings.notificationType, notification.getNotificationType());
     internalBuilder.add(JsonStrings.notificationItemId, notification.getNotifyId());
     arrayBuilder.add(internalBuilder);
   }
   em.createNamedQuery("UsersNotifications.deleteByUserId")
       .setParameter("userId", user)
       .executeUpdate();
   em.flush();
   builder.add(JsonStrings.notificationTable, arrayBuilder);
   return builder.build();
 }
Exemplo n.º 27
0
  public static void main(String... args) {
    EntityManagerFactory emFactory = Persistence.createEntityManagerFactory("JpaBasicsTutorial");
    EntityManager em = emFactory.createEntityManager();
    EntityManager em1 = emFactory.createEntityManager();

    Person person = new Person();
    em.getTransaction().begin();
    person.setName("Merry Jane");
    System.out.println("Before peprsist: " + person);
    em.persist(person);
    System.out.println("After peprsist: " + person);
    em.flush();
    System.out.println("After flush: " + person);
    em.getTransaction().commit();
    System.out.println("After commit: " + person);

    em.getTransaction().begin();
    person = em.find(Person.class, person.getId(), LockModeType.WRITE);
    System.out.println("Founded person: " + person);
    em.getTransaction().commit();
    System.out.println("After commit: " + person);

    em.getTransaction().begin();
    person = em.find(Person.class, person.getId(), LockModeType.OPTIMISTIC_FORCE_INCREMENT);
    System.out.println("Founded person: " + person);
    em.flush();
    System.out.println("Founded person after flush: " + person);
    em.getTransaction().rollback();
    System.out.println("After rollback: " + person);

    // Case does not works
    em1.getTransaction().begin();
    Person person1 = em.find(Person.class, person.getId(), LockModeType.NONE);
    person.setName("John");
    em.getTransaction().begin();
    person = em.find(Person.class, person.getId(), LockModeType.WRITE);
    System.out.println("Founded person: " + person);
    em1.getTransaction().rollback();
    em.refresh(person);
    em.flush();
    System.out.println("Founded person after flush: " + person);
    em.getTransaction().commit();
    System.out.println("After flush and commit: " + person);
  }
Exemplo n.º 28
0
  @Override
  public void addBook(EntityBook book, EntityRelease release, EntityAuthor author) {
    // Autor se umisti do databaze.
    if (author.getId() != null) {
      author = em.merge(author);
      em.refresh(author);
    } else {
      em.persist(author);
    }

    // Propoji se autor s knihou.
    book.getAuthorCollection().add(author);
    author.getBookCollection().add(book);
    em.persist(book);
    em.persist(author);

    // Vytvori se nove vydani knihy.
    release.setBook(book);
    book.getReleasesCollection().add(release);
    em.persist(book);
    em.persist(release);

    // Ziska se uzivatel.
    Principal principal = sessionContext.getCallerPrincipal();
    EntityUser user = beanSessionUser.getUserByEmail(principal.getName());

    // Vytvori se novy vytisk knihy.
    EntityPrint print = new EntityPrint();
    print.setRelease(release);
    release.getPrintsCollection().add(print);
    print.setOwnershipType(EntityPrint.EnumOwnershipType.PHYSICAL);
    print.setReadStatus(EntityPrint.EnumReadStatus.UNREAD);
    print.setUser(user);
    user.getPrintsCollection().add(print);

    em.persist(print);
    em.persist(release);
    em.persist(user);

    em.flush();
  }
  private void validateCycleFree(Task task, Errors errors) {
    Queue<Task> queue = new LinkedList<Task>();

    for (Dependency dep : task.getDependenciesesForBlocked()) {
      queue.add(dep.getBugsByDependson());
    }

    while (!queue.isEmpty()) {
      Task node = entityManager.find(Task.class, queue.remove().getId());
      if (node.getId().equals(task.getId())) {
        errors.reject("task.dependency.cycle");
        return;
      }

      entityManager.refresh(node);

      for (Dependency dep : node.getDependenciesesForBlocked()) {
        queue.add(dep.getBugsByDependson());
      }
    }
  }
 // Note: Update all for Table Per class only works with the one single
 // reference class. So it's not a full feature test.
 public void testUpdateAllQuery() {
   EntityManager em = createEntityManager();
   beginTransaction(em);
   try {
     ExpressionBuilder eb = new ExpressionBuilder();
     UpdateAllQuery updateQuery = new UpdateAllQuery(Assassin.class);
     updateQuery.addUpdate(eb.get("name"), "Generic Assassin Name");
     ((JpaEntityManager) em.getDelegate()).getServerSession().executeQuery(updateQuery);
     Assassin assassin = (Assassin) em.find(ContractedPersonel.class, assassinId);
     em.refresh(assassin);
     commitTransaction(em);
     assertTrue("Update all did not work", assassin.getName().equals("Generic Assassin Name"));
   } catch (Exception e) {
     e.printStackTrace();
     fail("Error issuing update all contracted personel query: " + e.getMessage());
   } finally {
     if (isTransactionActive(em)) {
       rollbackTransaction(em);
     }
     closeEntityManager(em);
   }
 }