Java Code Examples for javax.persistence.EntityManager

/** 
 * {@inheritDoc}
 */
@Override public void update(Stock stock){
  validateNoNull(stock,"stock");
  validateNotEmpty(stock.getSymbol(),"symbol");
  EntityManager entityManager=getEntityManager();
  try {
    entityManager.getTransaction().begin();
    entityManager.merge(stock);
    entityManager.getTransaction().commit();
  }
 catch (  PersistenceException exc) {
    entityManager.getTransaction().rollback();
    throw exc;
  }
}
 

@Override public Set<String> getTypes(){
  EntityManager em=this.emf.createEntityManager();
  Set<String> types=new HashSet<String>();
  try {
    Query query=em.createQuery("SELECT DISTINCT t.type FROM JpaRecord t");
    List<String> values=query.getResultList();
    logger.debug("PropValues are " + values.toString());
    types.addAll(values);
    return types;
  }
  finally {
    cleanup(em);
  }
}
 

@Test public void testGet() throws Exception {
  EntityManagerFactory emf=new ProxyingEntityManagerFactory(new MockEMF());
  EntityManager em=emf.createEntityManager();
  Person person=new Person();
  person.setId(1l);
  person.setName("Ales");
  em.persist(person);
  Food food=new Food();
  food.setPersonId(1l);
  food.setDescription("Pizza");
  food=em.merge(food);
  Person lazy=food.getPerson();
  Assert.assertSame(person,lazy);
}
 

@Override public Collection<FacilityConfig> allFacilities(){
  EntityManager em=emf.createEntityManager();
  try {
    TypedQuery<EcclesFacility> query=em.createQuery("from EcclesFacility",EcclesFacility.class);
    return new ArrayList<FacilityConfig>(query.getResultList());
  }
  finally {
    em.close();
  }
}
 

public EntityManager getEntityManager(){
  Map<Object,Object> attributes=FacesContext.getCurrentInstance().getAttributes();
  EntityManager manager=(EntityManager)attributes.get(PersistenceService.class);
  if (manager == null) {
    manager=entityManagerFactory.createEntityManager();
    attributes.put(PersistenceService.class,manager);
    manager.getTransaction().begin();
  }
  return manager;
}
 

public static User addUser(String id){
  EntityManagerFactory emf=Persistence.createEntityManagerFactory("org.jbpm.task");
  EntityManager em=emf.createEntityManager();
  User user=findUser(id,em);
  if (user == null) {
    user=new User(id);
    em.persist(user);
  }
  em.close();
  emf.close();
  return user;
}
 

public void clearPersistenceContext(){
  if (TransactionSynchronizationManager.hasResource("cmdEM")) {
    EntityManager cmdScopedEntityManager=(EntityManager)this.env.get(EnvironmentName.CMD_SCOPED_ENTITY_MANAGER);
    if (cmdScopedEntityManager != null) {
      cmdScopedEntityManager.clear();
    }
  }
}
 

/** 
 * @inheritDoc
 */
public EntityManager createEntityManager(final Map theMap){
  assertOpen();
  EntityManager aManager=newEntityManager(theMap);
  mManagers.add(aManager);
  return aManager;
}
 

public static Folder findFolder(Integer id){
  if (id == null) {
    return null;
  }
  EntityManager em=entityManager();
  Folder session=em.find(Folder.class,id);
  return session;
}
 

public EntityManager getEntityManager(String persistenceUnit){
  EntityManager entityManager=null;
  if (cache.containsKey(persistenceUnit)) {
    entityManager=cache.get(persistenceUnit);
  }
 else {
    entityManager=factory.create(persistenceUnit).createEntityManager();
    entityManager.setFlushMode(FlushModeType.AUTO);
    cache.put(persistenceUnit,entityManager);
    this.logger.info(bundle.getString("entity-manager-was-created",persistenceUnit));
  }
  return entityManager;
}
 

protected <T>T run(EMAction<T> action,final boolean useTx) throws Throwable {
  final EntityManager em=getEMF().createEntityManager();
  try {
    EntityTransaction tx=null;
    if (useTx)     tx=em.getTransaction();
    try {
      if (useTx)       tx.begin();
      return action.go(em);
    }
 catch (    Throwable t) {
      if (useTx)       tx.setRollbackOnly();
      throw t;
    }
 finally {
      if (useTx) {
        if (tx.getRollbackOnly())         tx.rollback();
 else         tx.commit();
      }
    }
  }
  finally {
    em.close();
  }
}
 

public EucalyptusMessage authenticate(final X509Certificate cert,final EucalyptusMessage msg) throws EucalyptusCloudException {
  try {
    return super.authenticate(cert,msg);
  }
 catch (  EucalyptusCloudException e) {
    AbstractKeyStore userKs=UserKeyStore.getInstance();
    String userAlias=null;
    try {
      userAlias=userKs.getCertificateAlias(cert);
    }
 catch (    GeneralSecurityException ex) {
      throw new EucalyptusCloudException(ex);
    }
    EntityManager em=EntityWrapper.getEntityManagerFactory(EucalyptusProperties.NAME).createEntityManager();
    Session session=(Session)em.getDelegate();
    UserInfo searchUser=new UserInfo();
    CertificateInfo searchCert=new CertificateInfo();
    searchCert.setCertAlias(userAlias);
    Example qbeUser=Example.create(searchUser).enableLike(MatchMode.EXACT);
    Example qbeCert=Example.create(searchCert).enableLike(MatchMode.EXACT);
    List<UserInfo> users=(List<UserInfo>)session.createCriteria(UserInfo.class).add(qbeUser).createCriteria("certificates").add(qbeCert).list();
    if (users.size() > 1) {
      em.close();
      throw new EucalyptusCloudException("Certificate with more than one entities: " + userAlias);
    }
 else     if (users.size() < 1) {
      em.close();
      throw new EucalyptusCloudException("WS-Security screw up -- unauthorized user has authorized certificate: " + userAlias);
    }
 else {
      msg.setUserId(users.get(0).getUserName());
      if (users.get(0).isAdministrator())       msg.setEffectiveUserId(EucalyptusProperties.NAME);
 else       msg.setEffectiveUserId(users.get(0).getUserName());
      em.close();
    }
    return msg;
  }
}
 

/** 
 * @see org.jboss.arquillian.persistence.JpaCacheEvictionStrategy#evictCache(javax.persistence.EntityManagerFactory)
 */
@Override public final void evictCache(EntityManager em){
  final Cache cache=em.getEntityManagerFactory().getCache();
  if (cache != null) {
    cache.evictAll();
  }
}
 

/** 
 * <p>Executes a sql script.</p>
 * @param entityManager the entity manager
 * @param fileName      the file name
 * @throws java.io.IOException if any error occurs
 */
public static void runScript(EntityManager entityManager,String fileName) throws IOException {
  InputStream input=Thread.currentThread().getContextClassLoader().getResourceAsStream(fileName);
  BufferedReader inputReader=new BufferedReader(new InputStreamReader(input));
  StringBuilder stringBuilder=new StringBuilder();
  String line;
  while ((line=inputReader.readLine()) != null) {
    if (!line.startsWith("--")) {
      stringBuilder.append(line);
    }
  }
  String[] commands=stringBuilder.toString().split(";");
  for (  final String command : commands) {
    entityManager.createNativeQuery(command).executeUpdate();
  }
}
 

private boolean acquire(final EntityManager em,Lock lock){
  lock.setUniqueId(uniqueId);
  if (lockTimeout > 0) {
    final Calendar cal=Calendar.getInstance();
    cal.add(Calendar.SECOND,lockTimeout);
    lock.setExpirationDate(cal.getTime());
  }
 else {
    lock.setExpirationDate(null);
  }
  boolean success=false;
  try {
    if (lock.getApplicationId() != null) {
      lock=em.merge(lock);
    }
 else {
      lock.setApplicationId(applicationId);
      em.persist(lock);
    }
    success=true;
  }
 catch (  PersistenceException e) {
    success=false;
    if (logger.isDebugEnabled()) {
      logger.debug("{} could not obtain {} lock.",new Object[]{uniqueId,applicationId,e});
    }
 else {
      logger.info("{} could not obtain {} lock.",uniqueId,applicationId);
    }
  }
  return success;
}
 

public static void execute(EntityManager em,int count){
  log.debug("Building model database with {} rows",count);
  em.getTransaction().begin();
  try {
    for (int i=0; i < count; i++) {
      Person person=new Person();
      person.setFirstName(dataFactory.getFirstName());
      person.setLastName(dataFactory.getLastName());
      person.setPhone(dataFactory.getNumberText(10));
      em.persist(person);
      if (i % 20 == 0) {
        em.getTransaction().commit();
        em.getTransaction().begin();
      }
    }
    em.getTransaction().commit();
  }
 catch (  Exception e) {
    em.getTransaction().rollback();
  }
}