public void register(ActionEvent actionEvent) {
    CustomerDAO cdao = HibernateDAOFactory.instance().getCustomerDAO();

    RequestContext context = RequestContext.getCurrentInstance();
    FacesMessage msg = null;
    boolean loggedIn = false;
    FacesContext fc = FacesContext.getCurrentInstance();
    ExternalContext ec = fc.getExternalContext();

    if (cdao.checklemail(email)) {
      Customer cs = new Customer();
      cs.setEmail(email);
      cs.setPass(pass);
      cs.setFullName(fullName);
      cs.setAddress(address);
      cs.setPhone(phone);
      cs.setVip(vip);
      cdao.add(cs);
      loggedIn = true;
      msg = new FacesMessage(FacesMessage.SEVERITY_INFO, "Registe succes! Welcome", email);
      String url = "index.xhtml";
      try {
        ec.redirect(url);
      } catch (IOException ex) {

      }
    } else {
      loggedIn = false;
      msg = new FacesMessage(FacesMessage.SEVERITY_WARN, "Registe Error", "Invalid credentials");
    }

    FacesContext.getCurrentInstance().addMessage(null, msg);
    context.addCallbackParam("loggedIn", loggedIn);
  }
 public void ChangeData() {
   model.Customer c = customerdao.get(user.getCustomer().getCustomerid());
   c.setCustomerfirstname(firstname);
   c.setCustomerlastname(lastname);
   c.setCustomeraddress(address);
   c.setCustomerphone(phone);
   customerdao.update(c);
   user.setCustomer(c);
 }
Beispiel #3
0
 @Override
 public void addCustomer(String firstName, String lastName, Date dob, String address) {
   try {
     CustomerDAO dao = new RDBCustomerDAO(connection);
     Customer customer = new Customer(firstName, lastName, dob, address);
     dao.createCustomer(customer);
   } catch (Exception e) {
     System.out.println("Could not create cusomter.");
     e.printStackTrace();
   }
 }
  public void ChangePassword() {

    model.Account a = customerdao.getAccounts(user.getCustomer()).get(0);
    if (oldpassword.equals(a.getAccountpassword())) {
      a.setAccountpassword(newpassword);
      accountdao.update(a);
    }
  }
Beispiel #5
0
  @Override
  public String readCustomer(int id) {
    String s;

    try {
      CustomerDAO dao = new RDBCustomerDAO(connection);
      // Employee employee = new Employee(id);
      // dao.createEmployee(employee);
      // return dao.readCustomer(id);

      // The Below worked before change back to this if things break.
      s = dao.readCustomer(id);
      return s;

      // return "TESTTTTTTTTTTTTTTTTTT";

    } catch (Exception e) {
      System.out.println("Invalid Customer.");
      e.printStackTrace();
      return e.toString();
    }
  }
Beispiel #6
0
  public String perform(HttpServletRequest request) {
    HttpSession session = request.getSession();
    List<String> errors = new ArrayList<String>();
    // authority judge
    if ((EmployeeBean) session.getAttribute("employee") == null) {
      return "employeelogin.do";
    }

    request.setAttribute("errors", errors);
    EmployeeBean employee = (EmployeeBean) session.getAttribute("employee");
    if (employee == null) {
      return "employeelogin.do";
    }

    /*
     * Check the deposit form.
     */
    DepositCheckForm depositcheckform = new DepositCheckForm(request);
    request.setAttribute("depositcheckform", depositcheckform);
    if (!depositcheckform.isPresent()) {
      return "employee_deposit_check.jsp";
    }
    errors.addAll(depositcheckform.getValidationErrors());
    if (errors.size() != 0) {
      return "employee_deposit_check.jsp";
    }

    CustomerBean customer = (CustomerBean) session.getAttribute("modifyCustomer");
    int id = customer.getCustomerId();
    try {
      customer = customerDAO.read(id);
    } catch (RollbackException e1) {
      // TODO Auto-generated catch block
      e1.printStackTrace();
    }

    double amount = depositcheckform.getAmount();

    //////////////////////
    // Transaction START //
    //////////////////////
    try {
      Transaction.begin();
      TransactionBean transaction = new TransactionBean();
      // what kind of transaction
      transaction.setTransactionType(TransactionType.DEPOSIT.toString());
      // who request the deposit
      transaction.setCustomerId(customer.getCustomerId());
      // how much money(in long)
      transaction.writeAmount(amount);
      // Create transaction
      transactionDAO.create(transaction);

      // update balance&available immediately.
      customer.writeCashBalance(amount);
      customerDAO.update(customer);

      Transaction.commit();
    } catch (RollbackException e) {
      e.printStackTrace();
    }
    ////////////////////
    // Transaction END//
    ////////////////////

    session.setAttribute("modifyCustomer", customer);
    // session.setAttribute("customer", customer);

    session.setAttribute(
        "message", "Thank you! You have successfully sent your deposit check request!");
    return "success_employee.jsp";
  }
Beispiel #7
0
  // @Transactional
  public void loadData() {
    DataLoader dataLoader = new DataLoader();
    try {
      Map<BigInteger, Supplier> suppliers = dataLoader.loadSuppliers("suppliers.xml");
      System.out.println(suppliers.keySet());
      logger.info("loadData : Persisting " + suppliers.size() + " suppliers");
      for (Supplier s : suppliers.values()) {
        supplierDAO.create(s);
      }
      Map<String, Customer> customers = dataLoader.loadCustomers("customers.xml");

      logger.info("loadData : Persisting " + customers.size() + " customers");
      for (Customer c : customers.values()) {
        customerDAO.create(c);
      }

      Map<BigInteger, Category> categories = dataLoader.loadCategories("categories.xml");
      logger.info("loadData : Persisting " + categories.size() + " categories");
      for (Category c : categories.values()) {
        categoryDAO.create(c);
      }

      Map<BigInteger, Shipper> shippers = dataLoader.loadShippers("shippers.xml");
      logger.info("loadData : Persisting " + shippers.size() + " shippers");
      for (Shipper s : shippers.values()) {
        shipperDAO.create(s);
      }

      Map<BigInteger, Product> products =
          dataLoader.loadProducts("products.xml", suppliers, categories);
      logger.info("loadData : Persisting " + products.size() + " products");
      for (Product p : products.values()) productDAO.create(p);

      Map<BigInteger, Employee> employees = dataLoader.loadEmployees("employees.xml");
      logger.info("loadData : Persisting " + employees.size() + " employees");
      for (Employee e : employees.values()) {
        try {
          employeeDAO.create(e);
        } catch (Exception es) {
          logger.warn(es.getMessage());
        }
      }

      logger.info("Loading orders with details");

      Map<BigInteger, Order> orders =
          dataLoader.loadOrders("orders_rand_10000.xml", customers, employees, shippers);
      orders.putAll(dataLoader.loadOrders("orders_rand_20000.xml", customers, employees, shippers));

      Map<Integer, OrderDetails> orderDetails =
          dataLoader.loadOrderDetails("orderdetails_rand_10000.xml", orders, products);
      orderDetails.putAll(
          dataLoader.loadOrderDetails("orderdetails_rand_20000.xml", orders, products));

      Map<Order, List<OrderDetails>> orderToOrderDetails =
          buildOrderToOrderDetailsMap(orderDetails);

      for (OrderDetails od : orderDetails.values()) {
        od.getOrderID().addOrderDetails(od);
      }

      List<Order> orderList = new ArrayList<Order>(orders.values());

      logger.info("Orders persisting:");

      int size = orderList.size();
      int i = 0;
      long start, stop = 0;
      StringBuilder builder = new StringBuilder();
      for (int j = 1000; j < size; j += 1000) {
        start = System.currentTimeMillis();
        entityManager.getTransaction().begin();
        while (i < j) {
          //	entityManager.persist(orderList.get(i));
          orderDAO.create(orderList.get(i));
          i++;
        }
        entityManager.getTransaction().commit();

        stop = System.currentTimeMillis();
        builder.append((j / 1000) + " : " + (stop - start) + "\n");
        logger.info("Orders round: " + j / 1000 + " : " + (stop - start));
      }
      System.out.println(builder.toString());

    } catch (Exception e) {
      e.printStackTrace();
    }
  }