Пример #1
0
  public void init(PortletConfig config) throws PortletException {
    super.init(config);
    // create application properties with default
    Properties defaultProps =
        PropertiesUtils.loadDefault(getPortletContext().getRealPath(default_properties));
    applicationProps = new Properties(defaultProps);
    // now load properties from last invocation
    applicationProps =
        PropertiesUtils.loadLastState(
            applicationProps, getPortletContext().getRealPath(saved_properties));

    // sets values
    if (applicationProps.getProperty("defaultURL") != null)
      defaultURL = applicationProps.getProperty("defaultURL");
    if (applicationProps.getProperty("defaultHeight") != null)
      defaultHeight = applicationProps.getProperty("defaultHeight");
    if (applicationProps.getProperty("defaultWidth") != null)
      defaultWidth = applicationProps.getProperty("defaultWidth");
    if (applicationProps.getProperty("defaultMessage") != null)
      defaultMessage = applicationProps.getProperty("defaultMessage");
    if (applicationProps.getProperty("hide_url") != null)
      if (applicationProps.getProperty("hide_url").equalsIgnoreCase("true")) hide_url = true;
    if (applicationProps.getProperty("hide_new_windows") != null)
      if (applicationProps.getProperty("hide_new_windows").equalsIgnoreCase("true"))
        hide_new_windows = true;

    // CREATOR_CONSULTATION = new CreateConsultation();
    // CREATOR_URI = new CreateUri();
    emf_consultation = Persistence.createEntityManagerFactory("consultation");
    emf_resource = Persistence.createEntityManagerFactory("resource");
    daoConsultation = new DAOConsultation(emf_consultation);
    daoResource = new DAOResource(emf_resource);
  }
Пример #2
0
  /**
   * This method does all of the setup for the test and returns a HashMap containing the persistence
   * objects that the test might need.
   *
   * @param persistenceUnitName The name of the persistence unit used by the test.
   * @return HashMap<String Object> with persistence objects, such as the EntityManagerFactory and
   *     DataSource
   */
  public static HashMap<String, Object> setupWithPoolingDataSource(
      final String persistenceUnitName, String dataSourceName, final boolean testMarshalling) {
    HashMap<String, Object> context = new HashMap<String, Object>();

    // set the right jdbc url
    Properties dsProps = getDatasourceProperties();
    String jdbcUrl = dsProps.getProperty("url");
    String driverClass = dsProps.getProperty("driverClassName");

    determineTestMarshalling(dsProps, testMarshalling);

    if (TEST_MARSHALLING) {
      Class<?> testClass = null;
      StackTraceElement[] ste = Thread.currentThread().getStackTrace();
      int i = 1;
      do {
        try {
          testClass = Class.forName(ste[i++].getClassName());
        } catch (ClassNotFoundException e) {
          // do nothing..
        }
      } while (PersistenceUtil.class.equals(testClass) && i < ste.length);
      assertNotNull("Unable to resolve test class!", testClass);

      jdbcUrl = initializeTestDb(dsProps, testClass);
    }

    boolean startH2TcpServer = false;
    if (jdbcUrl.matches("jdbc:h2:tcp:.*")) {
      startH2TcpServer = true;
    }

    // Setup the datasource
    PoolingDataSource ds1 = setupPoolingDataSource(dsProps, dataSourceName, startH2TcpServer);
    if (driverClass.startsWith("org.h2")) {
      ds1.getDriverProperties().setProperty("url", jdbcUrl);
    }
    ds1.init();
    context.put(DATASOURCE, ds1);

    // Setup persistence
    EntityManagerFactory emf;
    if (TEST_MARSHALLING) {
      Properties overrideProperties = new Properties();
      overrideProperties.setProperty("hibernate.connection.url", jdbcUrl);
      EntityManagerFactory realEmf =
          Persistence.createEntityManagerFactory(persistenceUnitName, overrideProperties);
      emf = (EntityManagerFactory) EntityManagerFactoryProxy.newInstance(realEmf);

      UserTransaction ut = (UserTransaction) UserTransactionProxy.newInstance(realEmf);
      context.put(TRANSACTION, ut);
    } else {
      emf = Persistence.createEntityManagerFactory(persistenceUnitName);
    }

    context.put(ENTITY_MANAGER_FACTORY, emf);

    return context;
  }
 @Override
 protected void createStaticEntityMangers() throws Exception {
   super.createStaticEntityMangers();
   TestContext ctx = TestContext.get();
   emfac2 = Persistence.createEntityManagerFactory(ctx.getPersistenceUnitName() + "2");
   emfac3 = Persistence.createEntityManagerFactory(ctx.getPersistenceUnitName() + "3");
   em2 = emfac2.createEntityManager();
   em3 = emfac3.createEntityManager();
 }
Пример #4
0
 @Test
 public void testPersistenceHook() {
   assertEquals(
       Persistence.createEntityManagerFactory("test-data-source").getClass(),
       EntityManagerFactoryImpl.class);
   assertEquals(
       Persistence.createEntityManagerFactory("test-data-source", new HashMap()).getClass(),
       EntityManagerFactoryImpl.class);
 }
Пример #5
0
  @Override
  protected void doPost(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
    PrintWriter out = response.getWriter();
    try {
      request.getPart("file").write(request.getPart("file").getSubmittedFileName());
      //            out.println("File uploaded successfully! " +
      // request.getPart("file").getSubmittedFileName());
    } catch (Exception e) {
      out.println("Exception -->" + e.getMessage());
    } finally {
    }

    // create a new transaction to add data about the image upload to DB.
    emf = Persistence.createEntityManagerFactory("ImageRektPU");
    em = emf.createEntityManager();
    //        out.println("Still works<br>");
    //        out.println("Transaction created<br>");
    try {
      em.getTransaction().begin();
      //            out.println("Transaction created<br>");
      //            int fileuploader = Integer.parseInt(request.getParameter("fileuploader"));
      //            out.println("User " + request.getParameter("user"));
      User u =
          (User)
              em.createNamedQuery("User.findByUid")
                  .setParameter("uid", Integer.parseInt(request.getParameter("user")))
                  .getSingleResult();
      //            out.println(u.getUname() + "<br>");
      // image title, description, Date generated in java the name of the file
      //            Image img = new Image(request.getParameter("titleinput"),
      // request.getParameter("descriptioninput"), new Date(),
      // request.getPart("file").getSubmittedFileName(), u);
      Image img =
          new Image(
              request.getParameter("titleinput"),
              request.getParameter("descriptioninput"),
              new Date(),
              request.getPart("file").getSubmittedFileName(),
              u);
      //            out.println(img.getTitle() + "<br>");
      em.persist(img);
      em.getTransaction().commit();
      //            out.println("File in DB successfully!");

      emf = Persistence.createEntityManagerFactory("ImageRektPU");
      em = emf.createEntityManager();
      em.getTransaction().begin();
      this.imageList = em.createNamedQuery("Image.findAll").getResultList();
      image = this.imageList.get(this.imageList.size() - 1);
      out.println(image.getIid());
      em.getTransaction().commit();
    } catch (Exception e) {
      out.println("BOOM! " + e);
    }
    emf.close();
  }
Пример #6
0
 public static synchronized EntityManager getEntityManager() {
   if (em == null) {
     em = Persistence.createEntityManagerFactory(persistenceUnitName).createEntityManager();
   }
   if (!em.isOpen()) {
     em = Persistence.createEntityManagerFactory(persistenceUnitName).createEntityManager();
   }
   if (!em.getTransaction().isActive()) {
     em.getTransaction().begin();
   }
   // log.debug("created EntityManager");
   return em;
 }
  @Test
  public void testExcludeHbmPar() throws Exception {
    File testPackage = buildExcludeHbmPar();
    addPackageToClasspath(testPackage);

    EntityManagerFactory emf = null;
    try {
      emf = Persistence.createEntityManagerFactory("excludehbmpar", new HashMap());
    } catch (PersistenceException e) {
      Throwable nested = e.getCause();
      if (nested == null) {
        throw e;
      }
      nested = nested.getCause();
      if (nested == null) {
        throw e;
      }
      if (!(nested instanceof ClassNotFoundException)) {
        throw e;
      }
      fail("Try to process hbm file: " + e.getMessage());
    }
    EntityManager em = emf.createEntityManager();
    Caipirinha s = new Caipirinha("Strong");
    em.getTransaction().begin();
    em.persist(s);
    em.getTransaction().commit();

    em.getTransaction().begin();
    s = em.find(Caipirinha.class, s.getId());
    em.remove(s);
    em.getTransaction().commit();
    em.close();
    emf.close();
  }
  private EntityManagerFactory makeEntityManagerFactory(String s) throws SQLException {
    Properties props = new Properties();
    String url = String.format("jdbc:h2:mem:%s;DB_CLOSE_DELAY=-1", s);
    props.put("javax.persistence.jdbc.url", url);
    props.put("javax.persistence.jdbc.driver", "org.h2.Driver");
    props.put("javax.persistence.transactionType", "RESOURCE_LOCAL");

    // OpenJPA support
    props.put("openjpa.Connection2URL", url);
    props.put("openjpa.Connection2DriverName", "org.h2.Driver");
    props.put("openjpa.jdbc.SynchronizeMappings", "buildSchema(SchemaAction='add')");
    props.put("openjpa.ConnectionRetainMode", "always");
    props.put("openjpa.ConnectionFactoryMode", "local");
    // eclipse-link support
    props.put("eclipselink.ddl-generation", "create-tables");
    props.put("eclipselink.ddl-generation.output-mode", "database");
    // Hibernate support
    props.put("hibernate.hbm2ddl.auto", "create-drop");
    props.put("hibernate.connection.driver_class", "org.h2.Driver");
    props.put("hibernate.dialect", "org.hibernate.dialect.H2Dialect");
    props.put("hibernate.connection.url", url);
    props.put("hibernate.show_sql", "true");
    JdbcDataSource dataSource = new JdbcDataSource();
    dataSource.setURL(url);
    String dataSourceUrl = "java:/dummyDataSource_" + s;
    try {
      new InitialContext().bind(dataSourceUrl, dataSource);
    } catch (NamingException e) {
      throw new AssertionError(e);
    }
    props.put("hibernate.connection.datasource", dataSourceUrl);
    return Persistence.createEntityManagerFactory(s, props);
  }
Пример #9
0
  @Deprecated
  public static StatefulKnowledgeSession loadStatefulKnowledgeSession(
      KnowledgeBase kbase, int sessionId) {
    Properties properties = getProperties();
    String persistenceEnabled = properties.getProperty("persistence.enabled", "false");
    RuntimeEnvironmentBuilder builder = null;
    if ("true".equals(persistenceEnabled)) {
      String dialect =
          properties.getProperty(
              "persistence.persistenceunit.dialect", "org.hibernate.dialect.H2Dialect");
      Map<String, String> map = new HashMap<String, String>();
      map.put("hibernate.dialect", dialect);
      EntityManagerFactory emf =
          Persistence.createEntityManagerFactory(
              properties.getProperty(
                  "persistence.persistenceunit.name", "org.jbpm.persistence.jpa"),
              map);

      builder =
          RuntimeEnvironmentBuilder.Factory.get()
              .newDefaultBuilder()
              .entityManagerFactory(emf)
              .addEnvironmentEntry(
                  EnvironmentName.TRANSACTION_MANAGER,
                  TransactionManagerServices.getTransactionManager());

    } else {
      builder = RuntimeEnvironmentBuilder.Factory.get().newDefaultInMemoryBuilder();
    }
    builder.knowledgeBase(kbase);
    RuntimeManager manager =
        RuntimeManagerFactory.Factory.get().newSingletonRuntimeManager(builder.get());
    return (StatefulKnowledgeSession) manager.getRuntimeEngine(EmptyContext.get()).getKieSession();
  }
 public static synchronized EntityManager getEntityManager() {
   if (em == null) {
     if (emf == null) emf = Persistence.createEntityManagerFactory("AgendaContatos");
     em = emf.createEntityManager();
   }
   return em;
 }
Пример #11
0
 /** Initialise JPA entity manager factories. */
 public JPAApi start() {
   for (JPAConfig.PersistenceUnit persistenceUnit : jpaConfig.persistenceUnits()) {
     emfs.put(
         persistenceUnit.name, Persistence.createEntityManagerFactory(persistenceUnit.unitName));
   }
   return this;
 }
Пример #12
0
  public Collection<Genre> lister() {

    EntityManager em =
        Persistence.createEntityManagerFactory("DTAStreamingWebPU").createEntityManager();

    return em.createQuery("SELECT g FROM Genres g ORDER BY g.id").getResultList();
  }
Пример #13
0
public class AccountServlet extends HttpServlet {

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

  @Override
  protected void doGet(HttpServletRequest req, HttpServletResponse resp)
      throws ServletException, IOException {

    HttpSession session = req.getSession();
    Principal p = req.getUserPrincipal();

    String username = p.getName();
    req.setAttribute("username", username);
    if (req.isUserInRole("user")) {
      session.setAttribute("user", true);
    } else if (req.isUserInRole("owner")) {
      session.setAttribute("owner", true);
      OwnerAccountPage ownerAccountPage = new OwnerAccountPage(entityManagerFactory);
      CharityOwner ownersCharity = ownerAccountPage.getCharity(username);
      req.setAttribute("charity", ownersCharity);
    }
    RequestDispatcher requestDispatcher = req.getRequestDispatcher("../WEB-INF/account.jsp");
    requestDispatcher.forward(req, resp);
  }

  @Override
  protected void doPost(HttpServletRequest req, HttpServletResponse resp)
      throws ServletException, IOException {

    doGet(req, resp);
  }
}
/** Created by Rekish on 11/13/2015. Retrieve data from the Assignee table in the database */
public class AssigneeDAOImpl implements AssigneeDAO {
  private static final Logger LOGGER = LoggerFactory.getLogger(AssigneeDAOImpl.class);
  private EntityManagerFactory factory = Persistence.createEntityManagerFactory("issueUnit");
  private EntityManager manager = factory.createEntityManager();
  private static final String EXCEPTION_STRING = "Exception Occurred";

  /** @return all the possible options from the assignee table as a List<> */
  @Override
  public List<Assignee> getAssigneeList() {
    LOGGER.info("Getting all assignee's.");
    List<Assignee> assigneeList = null;

    try {
      manager.getTransaction().begin();
      Query query = manager.createQuery("SELECT a FROM Assignee a");
      manager.getTransaction().commit();
      assigneeList = query.getResultList();
    } catch (IllegalStateException exception) {
      LOGGER.error(EXCEPTION_STRING, exception);
    } finally {
      if (manager.getTransaction().isActive()) {
        manager.getTransaction().rollback();
        manager.close();
        factory.close();
      }
    }
    return assigneeList;
  }
}
Пример #15
0
@ManagedBean(eager = true)
@RequestScoped
public class History implements Serializable {

  /** */
  private static final long serialVersionUID = -7136876637706661208L;

  EntityManagerFactory emf = Persistence.createEntityManagerFactory("jobqueue-api-pu");
  EntityManager em = emf.createEntityManager();

  private ArrayList<com.enioka.jqm.jpamodel.History> hs = null;

  public History() {}

  public ArrayList<com.enioka.jqm.jpamodel.History> getHs() {

    em.clear();

    @SuppressWarnings("unchecked")
    List<com.enioka.jqm.jpamodel.History> tmp =
        em.createQuery("SELECT h FROM History h").getResultList();

    hs = new ArrayList<com.enioka.jqm.jpamodel.History>();

    for (com.enioka.jqm.jpamodel.History j : tmp) {
      hs.add(j);
    }

    return hs;
  }

  public void setHs(ArrayList<com.enioka.jqm.jpamodel.History> hs) {
    this.hs = hs;
  }
}
  @Override
  protected void setUp() throws Exception {
    ds1 = setupPoolingDataSource();
    ds1.init();

    emf = Persistence.createEntityManagerFactory(PERSISTENCE_UNIT_NAME);
  }
  @Override
  protected void setUp() throws Exception {
    super.setUp();
    env = EnvironmentFactory.newEnvironment();
    Environment domainEnv = EnvironmentFactory.newEnvironment();
    domainEmf = Persistence.createEntityManagerFactory("org.jbpm.persistence.example");

    domainEnv.set(EnvironmentName.ENTITY_MANAGER_FACTORY, domainEmf);
    env.set(
        EnvironmentName.OBJECT_MARSHALLING_STRATEGIES,
        new ObjectMarshallingStrategy[] {
          new JPAPlaceholderResolverStrategy(domainEnv),
          new SerializablePlaceholderResolverStrategy(
              ClassObjectMarshallingStrategyAcceptor.DEFAULT)
        });
    ksession.setEnvironment(env);

    server = new MinaTaskServer(taskService);
    System.out.println("Waiting for the MinaTask Server to come up");
    try {
      startTaskServerThread(server, false);
    } catch (Exception e) {
      startTaskServerThread(server, true);
    }

    AsyncMinaHTWorkItemHandler asyncWSHumanTaskHandler =
        new AsyncMinaHTWorkItemHandler("my-mina-connector", client, ksession, null);
    setClient(asyncWSHumanTaskHandler.getClient());
    setHandler(asyncWSHumanTaskHandler);
  }
Пример #18
0
 public static EntityManagerFactory getEMF() {
   if (emf == null) {
     emf = Persistence.createEntityManagerFactory(PERSISTENCE_UNIT_NAME);
     System.out.println(emf.isOpen());
   }
   return emf;
 }
Пример #19
0
  /**
   * Returns a list of dates from trade open until expiration.
   *
   * @param expiration
   * @return
   */
  public static List<Date> getTradeDatesStarting(Date expiration, Date startDate) {

    EntityManagerFactory emf = Persistence.createEntityManagerFactory("JPAOptionsTrader");
    EntityManager em = emf.createEntityManager();

    // Note: table name refers to the Entity Class and is case sensitive
    //       field names are property names in the Entity Class
    Query query =
        em.createQuery(
            "select distinct(opt.trade_date) from "
                + TradeProperties.SYMBOL_FOR_QUERY
                + " opt "
                + "where "
                + "opt.trade_date >= :tradeDate "
                + "opt.expiration=:expiration "
                //				+ "and opt.call_put = :call_put "
                //				+ "and opt.delta > 0.04 "
                //				+ "and opt.delta < 0.96 "
                + "order by opt.trade_date");

    query.setParameter("tradeDate", startDate);
    query.setParameter("expiration", expiration);
    //		query.setParameter("call_put", callPut);

    List<Date> dates = query.getResultList();
    em.close();
    return dates;
  }
  public void remover(Integer id) throws Exception {
    EntityManagerFactory emf = Persistence.createEntityManagerFactory("DAW-Trabalho-ModelPU");
    EntityManager em = emf.createEntityManager();

    try {
      if (em.getTransaction().isActive() == false) {
        em.getTransaction().begin();
      }

      Venda objeto = em.find(Venda.class, id);
      em.remove(objeto);
      em.getTransaction().commit();
    } catch (Exception e) {
      if (em.getTransaction().isActive() == false) {
        em.getTransaction().begin();
      }

      em.getTransaction().rollback();

      throw new Exception("Erro ao executar a operação de persistência:" + e.getMessage());
    } finally {
      em.close();
      emf.close();
    }
  }
Пример #21
0
  @Test
  public void testCfgXmlPar() throws Exception {
    File testPackage = buildCfgXmlPar();
    addPackageToClasspath(testPackage);

    EntityManagerFactory emf = Persistence.createEntityManagerFactory("cfgxmlpar", new HashMap());
    EntityManager em = emf.createEntityManager();
    Item i = new Item();
    i.setDescr("Blah");
    i.setName("factory");
    Morito m = new Morito();
    m.setPower("SuperStrong");
    em.getTransaction().begin();
    em.persist(i);
    em.persist(m);
    em.getTransaction().commit();

    em.getTransaction().begin();
    i = em.find(Item.class, i.getName());
    em.remove(i);
    em.remove(em.find(Morito.class, m.getId()));
    em.getTransaction().commit();
    em.close();
    emf.close();
  }
Пример #22
0
  public static void main(String[] args) throws Exception {
    System.out.println("hello from Customer.java");

    EntityManagerFactory factory = Persistence.createEntityManagerFactory("customerPU");
    EntityManager manager = factory.createEntityManager();
    Query q1 = manager.createQuery("SELECT COUNT(c) FROM Customer c");
    Long count = (Long) q1.getSingleResult();
    if (count == 0) {
      // record is empty, read from data.txst
      System.out.println("record empty, read from data.txt...");
      // try {
      FileReader fr = new FileReader("data.txt");
      BufferedReader br = new BufferedReader(fr);
      String s;
      while ((s = br.readLine()) != null) {

        // System.out.println(s);
        // split the string s
        Object[] items = s.split("\\|");
        // store in string list
        // List<String> itemList= new ArrayList<String>(Arrays.asList(items));
        // string list converted to array

        // Object[] itemArray = itemList.toArray();
        // insert data into database table
        manager.getTransaction().begin();
        Customer c = new Customer();

        // add email
        c.setEmail((String) items[0]);

        // add pass
        c.setPass((String) items[1]);

        // add name
        c.setName((String) items[2]);

        // add address
        c.setAddress((String) items[3]);

        // add yob
        c.setYob((String) items[4]);

        // change to managed state
        manager.persist(c);
        manager.getTransaction().commit();
      }
      fr.close();
    }

    // display the records
    Query q2 = manager.createNamedQuery("Customer.findAll");
    List<Customer> customers = q2.getResultList();
    for (Customer c : customers) {
      System.out.println(c.getName() + ", " + c.getEmail());
    }

    manager.close();
    factory.close();
  }
Пример #23
0
  @Test
  public void testDefaultPar() throws Exception {
    File testPackage = buildDefaultPar();
    addPackageToClasspath(testPackage);

    // run the test
    EntityManagerFactory emf = Persistence.createEntityManagerFactory("defaultpar", new HashMap());
    EntityManager em = emf.createEntityManager();
    ApplicationServer as = new ApplicationServer();
    as.setName("JBoss AS");
    Version v = new Version();
    v.setMajor(4);
    v.setMinor(0);
    v.setMicro(3);
    as.setVersion(v);
    Mouse mouse = new Mouse();
    mouse.setName("mickey");
    em.getTransaction().begin();
    em.persist(as);
    em.persist(mouse);
    assertEquals(1, em.createNamedQuery("allMouse").getResultList().size());
    Lighter lighter = new Lighter();
    lighter.name = "main";
    lighter.power = " 250 W";
    em.persist(lighter);
    em.flush();
    em.remove(lighter);
    em.remove(mouse);
    assertNotNull(as.getId());
    em.remove(as);
    em.getTransaction().commit();
    em.close();
    emf.close();
  }
 public static EntityManager getEntityManager() {
   if (em == null) {
     emf = Persistence.createEntityManagerFactory("Twitt");
     em = emf.createEntityManager();
   }
   return em;
 }
Пример #25
0
  public Genre rechercher(String id) {

    EntityManager em =
        Persistence.createEntityManagerFactory("DTAStreamingWebPU").createEntityManager();

    return em.find(Genre.class, id);
  }
Пример #26
0
  public static void main(String[] args) {

    EntityManagerFactory emfactory = Persistence.createEntityManagerFactory("JPA");
    EntityManager entitymanager = emfactory.createEntityManager();
    entitymanager.getTransaction().begin();

    // Teaching staff entity
    TeachingStaff ts1 = new TeachingStaff(1, "Gopal", "MSc MEd", "Maths");
    TeachingStaff ts2 = new TeachingStaff(2, "Manisha", "BSc BEd", "English");

    // Non-Teaching Staff entity
    NonTeachingStaff nts1 = new NonTeachingStaff(3, "Satish", "Accounts");
    NonTeachingStaff nts2 = new NonTeachingStaff(4, "Krishna", "Office Admin");

    // storing all entities
    entitymanager.persist(ts1);
    entitymanager.persist(ts2);
    entitymanager.persist(nts1);
    entitymanager.persist(nts2);

    entitymanager.getTransaction().commit();

    entitymanager.close();
    emfactory.close();
  }
Пример #27
0
  @BeforeClass
  public static void initializeEntityManagerFactory() {

    entityManagerFactory =
        Persistence.createEntityManagerFactory("MyTestPersistenceUnit", properties());
    System.out.println("InitializeEntityFactory!!");
  }
  public static void main(String[] args) {
    try {
      EntityManagerFactory f = Persistence.createEntityManagerFactory("DemoPU");
      EntityManager manager = f.createEntityManager();
      Scanner in = new Scanner(System.in);
      System.out.print("Enter id to modify");
      int id = in.nextInt();
      in.nextLine();
      Emp e = manager.find(Emp.class, id);
      System.out.println("current details are");
      System.out.println(e.getEname() + "\t" + e.getJob() + "\t" + e.getSalary());
      System.out.println("Enter name to update");
      String n = in.nextLine();
      System.out.println("Enter job to update");
      String j = in.nextLine();
      System.out.println("Enter salary to update");
      int s = in.nextInt();
      EntityTransaction t = manager.getTransaction();
      t.begin();
      e.setEname(n);
      e.setJob(j);
      e.setSalary(s);

      t.commit();
      manager.close();
      System.out.println("updated");
    } catch (Exception e) {
      System.out.println(e);
    }
  }
Пример #29
0
  /** Constructs the EntityManagerFactory. */
  @BeforeClass
  public static void setUpJPA() {
    dataSource = DatabaseTools.setupJDBCandJNDI(jndi, databaseName);

    // Create the JPA EMF
    emf = Persistence.createEntityManagerFactory(persistentUnit);
  }
  /**
   * Cria o Entity Manager caso não esteja criado.
   *
   * @return EntityManagerFactory - Fabrica do Entity Manager
   */
  public static EntityManagerFactory getEntityManagerFactory() {
    if (fabrica == null) {
      fabrica = Persistence.createEntityManagerFactory("netquiz");
    }

    return fabrica;
  }