public List<Machine> getCustomerMachinesList(Customer cust) {
try {
ResultSet rs =
executeQuery(
"SELECT machines.* FROM customers JOIN machines ON customers.id=cid AND cid="
+ cust.getId()
+ ";");
List list = new ArrayList();
while (rs.next()) {
MachineData machData = new MachineData();
int id = rs.getInt(1);
for (int i = 0; i < MachineData.fieldsName.length; i++) {
String fieldValue = rs.getString(MachineData.fieldsName[i]);
machData.updateByFieldName(MachineData.fieldsName[i], fieldValue);
}
Machine mach = new Machine(machData);
mach.setId(id);
mach.setCid(cust.getId());
list.add(mach);
}
return list;
} catch (SQLException e) {
e.printStackTrace();
}
return null;
}
public CustomersResource() {
System.out.println("[CustomerResource] Instantiated " + this);
Customer customer1 = new Customer();
customer1.setId(1111);
customer1.setName("CustomerOne");
customer1.setAddress("Bombay, India");
Customer customer2 = new Customer();
customer2.setId(2222);
customer2.setName("CustomerTwo");
customer2.setAddress("Pune, India");
Customer customer3 = new Customer();
customer3.setId(3333);
customer3.setName("CustomerThree");
customer3.setAddress("Bangalore, India");
customerMap.put(customer1.getId(), customer1);
customerMap.put(customer2.getId(), customer2);
customerMap.put(customer3.getId(), customer3);
if (testBean != null) {
System.out.println("[CustomersResource] testBean NOT NULL " + testBean);
testBean.setCustomerMap(customerMap);
} else {
System.out.println("[CustomersResource] testBean IS NULL");
}
}
@Test
public void testDeleteCustomer() {
Customer c1 = getNewCustomerWithUniqueName();
Customer c1FromDb = getCustomerComponent().getById(c1.getId());
getCustomerComponent().delete(c1FromDb);
Customer c1FromDbAgain = getCustomerComponent().getById(c1.getId());
assertNull(c1FromDbAgain);
}
public String addDefaultCustomer(Customer customer) {
customerMap.put(customer.getId(), customer);
return "Customer ID: "
+ customer.getId()
+ " Name: "
+ customer.getName()
+ " Address: "
+ customer.getAddress();
}
@Test
public void updateExistingCustomer() {
final String newFirstname = "Bernard";
final String newLastname = "Montgomery";
final Customer customer = new Customer(CUSTOMER.getId(), newFirstname, newLastname);
impl.updateCustomer(customer);
final Customer cust = impl.getCustomerById(CUSTOMER.getId());
assertEquals(newFirstname, cust.getFirstName());
assertEquals(newLastname, cust.getLastName());
}
@Test
public void testCustomerInsertAndGet() {
Customer c1 = getNewCustomerWithUniqueName();
Customer c2 = getNewCustomerWithUniqueName();
assertEquals(c1.getId() + 1, c2.getId());
Customer c1FromDb = getCustomerComponent().getById(c1.getId());
assertEquals(c1.getName(), c1FromDb.getName());
}
@Test
public void testCustomerUpdateAndGet() {
Customer c1 = getNewCustomerWithUniqueName();
Customer c1FromDb = getCustomerComponent().getById(c1.getId());
String NEW_PHONE = "415-555-1212";
c1FromDb.setPhoneNumber(NEW_PHONE);
getCustomerComponent().persist(c1FromDb);
Customer c1FromDbAgain = getCustomerComponent().getById(c1.getId());
assertEquals(NEW_PHONE, c1FromDbAgain.getPhoneNumber());
}
@PUT
@Path("/customers/")
public Response updateCustomer(Customer customer) {
Customer c = customers.get(customer.getId());
Response r;
if (c != null) {
customers.put(customer.getId(), customer);
r = Response.ok().build();
} else {
r = Response.status(406).entity("Cannot find the customer!").build();
}
return r;
}
public void addMachineToDatabase(Machine mach, Customer cust) {
int id = getNextId("machines");
String query = "INSERT INTO machines SET id=" + id + ", ";
query = query + "cid=" + cust.getId() + ", ";
for (int i = 0; i < MachineData.fieldsName.length; i++) {
String fieldname = MachineData.fieldsName[i];
String val = mach.getInfoByFieldName(fieldname);
query = query + fieldname + "= \"" + val + "\"";
if (i != MachineData.fieldsName.length - 1) query = query + ", ";
}
query = query + ";";
executeUpdate(query);
mach.setId(id);
mach.setCid(cust.getId());
}
@Test
public void testFindIterate() {
// insert 1000 customers
int j = 0;
for (int i = 0; i < 1000; i++) {
Customer customer = new Customer();
customer.setName("Hello" + j++);
customer.save();
}
QueryIterator<Customer> iterate =
Customer.find
.query()
.select("id") // .fetch("contacts", new FetchConfig().lazy(20))
.findIterate();
try {
while (iterate.hasNext()) {
Customer customer = iterate.next();
// do something interesting with customer
// customer.getContacts().size();
System.out.println("got name " + customer.getId() + " " + customer.getName());
}
} finally {
// close the underlying resources held by the QueryIterator
// those are: ResultSet and Connection
iterate.close();
}
}
@Test
public void testBasicExpectedBehavior() {
Session session = getNewSession("jboss");
session.beginTransaction();
Customer steve = new Customer(1L, "steve");
session.save(steve);
session.getTransaction().commit();
session.close();
session = getNewSession("acme");
try {
session.beginTransaction();
Customer check = (Customer) session.get(Customer.class, steve.getId());
Assert.assertNull("tenancy not properly isolated", check);
} finally {
session.getTransaction().commit();
session.close();
}
session = getNewSession("jboss");
session.beginTransaction();
session.delete(steve);
session.getTransaction().commit();
session.close();
}
public List<Service> getCustomerServicesList(Customer cust) {
try {
ResultSet rs =
executeQuery(
"SELECT services.* FROM customers JOIN machines JOIN services ON customers.id=cid AND machines.id=mid AND cid="
+ cust.getId()
+ ";");
List list = new ArrayList();
while (rs.next()) {
ServiceData servData = new ServiceData();
int id = rs.getInt(1);
int mid = rs.getInt(2);
for (int i = 0; i < ServiceData.fieldsName.length; i++) {
String fieldValue = rs.getString(ServiceData.fieldsName[i]);
servData.updateByFieldName(ServiceData.fieldsName[i], fieldValue);
}
Service serv = new Service(servData);
serv.setId(id);
serv.setMid(mid);
list.add(serv);
}
return list;
} catch (SQLException e) {
e.printStackTrace();
}
return null;
}
public void testLoadingStrategies() {
Session s = openSession();
s.beginTransaction();
Customer cust = new Customer("Acme, Inc.");
Order order = new Order(new Order.Id(cust, 1));
cust.getOrders().add(order);
s.save(cust);
s.getTransaction().commit();
s.close();
s = openSession();
s.beginTransaction();
cust = (Customer) s.get(Customer.class, cust.getId());
assertEquals(1, cust.getOrders().size());
s.clear();
cust = (Customer) s.createQuery("from Customer").uniqueResult();
assertEquals(1, cust.getOrders().size());
s.clear();
cust = (Customer) s.createQuery("from Customer c join fetch c.orders").uniqueResult();
assertEquals(1, cust.getOrders().size());
s.clear();
s.delete(cust);
s.getTransaction().commit();
s.close();
}
/** Hibernate Test class */
public static void main(String[] args) {
// TODO Auto-generated method stub
// Session session = HibernateUtil.currentSession();
Session session = HibernateSessionFactory.getSession();
session.beginTransaction();
// create query object
Query query = session.createQuery("from Customer");
// create customer list
List<Customer> list = query.list();
Customer cus = null;
if (list != null && list.size() > 0) {
/*for(int i = 0;i<list.size();i++){
cus = (Customer)list.get(i);
System.out.println("" +
"+i= " + i + "ID = "+ cus.getId()+
"name = "+ cus.getName()+"Age = " +cus.getAge());
}*/
for (Customer customer : list) {
cus = customer;
System.out.println(
"ID = " + cus.getId() + " name = " + cus.getName() + " Age = " + cus.getAge());
}
}
session.beginTransaction().commit(); // submit
}
@Test
public void onCustomer() {
Result<Customer> customerResult =
gateway.customer().create(new CustomerRequest().paymentMethodNonce(Nonce.Coinbase));
assertTrue(customerResult.isSuccess());
Customer customer = customerResult.getTarget();
List<CoinbaseAccount> accounts =
gateway.customer().find(customer.getId()).getCoinbaseAccounts();
assertEquals(1, accounts.size());
CoinbaseAccount account = accounts.get(0);
assertNotNull(account);
assertNotNull(account.getToken());
assertNotNull(account.getUserId());
assertThat(account.getUserId(), not(equalTo("")));
assertNotNull(account.getUserName());
assertThat(account.getUserName(), not(equalTo("")));
assertNotNull(account.getUserEmail());
assertThat(account.getUserEmail(), not(equalTo("")));
String token = account.getToken();
gateway.paymentMethod().delete(token);
exception.expect(NotFoundException.class);
gateway.paymentMethod().find(token);
}
@Test
public void updateCreditCardFromTransparentRedirect() {
Customer customer = gateway.customer().create(new CustomerRequest()).getTarget();
CreditCardRequest request =
new CreditCardRequest()
.customerId(customer.getId())
.number("5105105105105100")
.expirationDate("05/12");
CreditCard card = gateway.creditCard().create(request).getTarget();
CreditCardRequest updateRequest = new CreditCardRequest();
CreditCardRequest trParams =
new CreditCardRequest()
.paymentMethodToken(card.getToken())
.number("4111111111111111")
.expirationDate("10/10");
String queryString =
TestHelper.simulateFormPostForTR(
gateway, trParams, updateRequest, gateway.transparentRedirect().url());
Result<CreditCard> result = gateway.transparentRedirect().confirmCreditCard(queryString);
assertTrue(result.isSuccess());
CreditCard updatedCreditCard = gateway.creditCard().find(card.getToken());
assertEquals("411111", updatedCreditCard.getBin());
assertEquals("1111", updatedCreditCard.getLast4());
assertEquals("10/2010", updatedCreditCard.getExpirationDate());
}
final void init() {
Customer c = new Customer();
c.setName("John");
c.setId(123);
customers.put(c.getId(), c);
c = new Customer();
c.setName("Dan");
c.setId(113);
customers.put(c.getId(), c);
Order o = new Order();
o.setDescription("order 223");
o.setId(223);
orders.put(o.getId(), o);
}
@POST
@Path("/customersUniqueResponseCode/")
public Response addCustomerUniqueResponseCode(Customer customer) {
customer.setId(currentId.incrementAndGet());
customers.put(customer.getId(), customer);
return Response.status(201).entity(customer).build();
}
@Test
public void updateCustomerFromTransparentRedirect() {
CustomerRequest request = new CustomerRequest().firstName("John").lastName("Doe");
Customer customer = gateway.customer().create(request).getTarget();
CustomerRequest updateRequest = new CustomerRequest().firstName("Jane");
CustomerRequest trParams = new CustomerRequest().customerId(customer.getId()).lastName("Dough");
String queryString =
TestHelper.simulateFormPostForTR(
gateway, trParams, updateRequest, gateway.transparentRedirect().url());
Result<Customer> result = gateway.transparentRedirect().confirmCustomer(queryString);
assertTrue(result.isSuccess());
Customer updatedCustomer = gateway.customer().find(customer.getId());
assertEquals("Jane", updatedCustomer.getFirstName());
assertEquals("Dough", updatedCustomer.getLastName());
}
public static void main(String[] args) throws Exception {
HashMap map = new HashMap();
// map.put("hibernate.show_sql", "true");
EntityManagerFactory factory = Persistence.createEntityManagerFactory("titan", map);
EntityManager entityManager = factory.createEntityManager();
entityManager.getTransaction().begin();
try {
System.out.println("Initialize DB");
InitializeDB.initialize(entityManager);
System.out.println();
System.out.println();
System.out.println("Find Bill Burke by named parameter");
Customer cust = findCustomerByNamedParameter(entityManager, "Bill", "Burke");
System.out.println("Bill Burke's cust id: " + cust.getId());
System.out.println();
System.out.println();
System.out.println("Find Gavin King by indexed parameter");
cust = findCustomerByIndexedParameter(entityManager, "Gavin", "King");
System.out.println("Gavin King's cust id: " + cust.getId());
System.out.println();
System.out.println();
System.out.println("Output all customers via paging");
List results;
int first = 0;
int max = 2;
do {
results = getCustomers(entityManager, max, first);
Iterator it = results.iterator();
while (it.hasNext()) {
Customer c = (Customer) it.next();
System.out.println(c.getFirstName() + " " + c.getLastName());
}
entityManager.clear();
first = first + results.size();
} while (results.size() > 0);
} finally {
entityManager.getTransaction().commit();
entityManager.close();
factory.close();
}
}
@RequestMapping(value = "/customers", method = RequestMethod.POST)
ResponseEntity<Resource<Customer>> post(@RequestBody Customer c) {
Customer customer =
this.customerRepository.save(new Customer(c.getFirstName(), c.getLastName()));
URI uri =
MvcUriComponentsBuilder.fromController(getClass())
.path("/customers/{id}")
.buildAndExpand(customer.getId())
.toUri();
return ResponseEntity.created(uri).body(this.customerResourceAssembler.toResource(customer));
}
@Test
public void updateNonExistingCustomer() {
final int nonExistingId = getNonExistingCustomerId();
final String newFirstname = "Douglas";
final String newLastname = "MacArthur";
final Customer customer = new Customer(nonExistingId, newFirstname, newLastname);
impl.updateCustomer(customer);
assertNull(impl.getCustomerById(nonExistingId));
final Customer existingCustomer = impl.getCustomerById(CUSTOMER.getId());
assertEquals(CUSTOMER.getFirstName(), existingCustomer.getFirstName());
assertEquals(CUSTOMER.getLastName(), existingCustomer.getLastName());
}
@POST
@Path("/customers/")
public Response addCustomer(Customer customer) {
if (StringUtils.isEmpty(customer.getName())) {
return Response.status(422).build();
}
customer.setId(currentId.incrementAndGet());
customers.put(customer.getId(), customer);
return Response.ok(customer).build();
}
@POST
@Path("add")
@Produces(MediaType.APPLICATION_XML)
@Consumes("application/x-www-form-urlencoded")
public Customer addCustomer(
@FormParam("custId") int id,
@FormParam("custName") String name,
@FormParam("custAddress") String address) {
Customer customer = new Customer();
customer.setId(id);
customer.setName(name);
customer.setAddress(address);
customerMap.put(customer.getId(), customer);
testBean.setCustomerMap(customerMap);
return customer;
}
public static void main(String[] args) {
Set<Customer> customers = new TreeSet<Customer>();
Customer id1 = new Customer();
id1.setId(1l);
customers.add(id1);
Customer id2 = new Customer();
id2.setId(2l);
customers.add(id2);
Customer c = new Customer();
c.setId(1l);
customers.add(c); // mereplace id1 karena mempunyai id yang sama
Iterator<Customer> i = customers.iterator();
while (i.hasNext()) {
Customer current = i.next();
System.out.println("keranjang no-" + current.hashCode() + " idnya:" + current.getId());
}
}
public static String generateEuropeBankAccountNonce(BraintreeGateway gateway, Customer customer) {
SEPAClientTokenRequest request = new SEPAClientTokenRequest();
request.customerId(customer.getId());
request.mandateType(EuropeBankAccount.MandateType.BUSINESS);
request.mandateAcceptanceLocation("Rostock, Germany");
String encodedClientToken = gateway.clientToken().generate(request);
String clientToken = TestHelper.decodeClientToken(encodedClientToken);
String authorizationFingerprint = extractParamFromJson("authorizationFingerprint", clientToken);
Configuration configuration = gateway.getConfiguration();
String url =
configuration.getBaseURL()
+ configuration.getMerchantPath()
+ "/client_api/v1/sepa_mandates";
QueryString payload = new QueryString();
payload
.append("authorization_fingerprint", authorizationFingerprint)
.append("sepa_mandate[locale]", "de-DE")
.append("sepa_mandate[bic]", "DEUTDEFF")
.append("sepa_mandate[iban]", "DE89370400440532013000")
.append("sepa_mandate[accountHolderName]", "Bob Holder")
.append("sepa_mandate[billingAddress][streetAddress]", "123 Currywurst Way")
.append("sepa_mandate[billingAddress][extendedAddress]", "Lager Suite")
.append("sepa_mandate[billingAddress][firstName]", "Wilhelm")
.append("sepa_mandate[billingAddress][lastName]", "Dix")
.append("sepa_mandate[billingAddress][locality]", "Frankfurt")
.append("sepa_mandate[billingAddress][postalCode]", "60001")
.append("sepa_mandate[billingAddress][countryCodeAlpha2]", "DE")
.append("sepa_mandate[billingAddress][region]", "Hesse");
String responseBody;
String nonce = "";
try {
responseBody = HttpHelper.post(url, payload.toString());
nonce = extractParamFromJson("nonce", responseBody);
} catch (Exception e) {
throw new RuntimeException(e);
}
return nonce;
}
public void insertSale(Customer c) throws SQLException {
int id = c.getId();
String name = c.getName();
String address = c.getAddress();
String phone = c.getPhoneNumber();
String cardType = c.getCardType();
String cardNumber = c.getCardNumber();
String cardExp = c.getCardExp();
String secCode = c.getSecCode();
String cartDetails = "";
for (Product p : c.getCart().getProductList())
cartDetails += p.getName() + "@" + p.getUnitPrice() + "x" + p.getQuantity() + " ";
BigDecimal cartTotal = c.getCart().getTotal().setScale(2);
Statement stmt = con.createStatement();
String sql =
"INSERT INTO App.SALES VALUES("
+ id
+ ",'"
+ name
+ "','"
+ address
+ "','"
+ phone
+ "','"
+ cardType
+ "','"
+ cardNumber
+ "','"
+ cardExp
+ "','"
+ secCode
+ "','"
+ cartDetails
+ "',"
+ cartTotal
+ ",'"
+ getCurrentTimeStamp()
+ "')";
stmt.executeUpdate(sql);
}
public static Customer createCreditCard(EntityManagerFactory factory, Customer cust) {
CreditCard card = new CreditCard();
card.setExpirationDate(new java.util.Date());
card.setNumber("4444-4444-4444-4444");
card.setNameOnCard("William Burke");
card.setCreditOrganization("Capital One");
card.setCustomer(cust);
EntityManager manager = factory.createEntityManager();
try {
manager.getTransaction().begin();
manager.persist(card);
manager.getTransaction().commit();
// Show that card.getCustomer() returns null
manager.clear();
CreditCard cardCopy = manager.find(CreditCard.class, card.getId());
System.out.println("should be null: " + cardCopy.getCustomer());
manager.getTransaction().begin();
System.out.println("now set the owning side of the relationship");
Customer custCopy = manager.find(Customer.class, cust.getId());
custCopy.setCreditCard(cardCopy);
manager.getTransaction().commit();
manager.clear();
cardCopy = manager.find(CreditCard.class, card.getId());
System.out.println("should be set now: " + cardCopy.getCustomer().getFirstName());
} finally {
manager.close();
}
return cust;
}
public static Customer createCustomerAddress(EntityManagerFactory factory) {
System.out.println("Create 1st Customer");
Customer cust = new Customer();
cust.setFirstName("Bill");
cust.setLastName("Burke");
Address address = new Address();
address.setStreet("Beacon Street");
address.setCity("Boston");
address.setState("MA");
address.setZip("02115");
cust.setAddress(address);
EntityManager manager = factory.createEntityManager();
try {
manager.getTransaction().begin();
manager.persist(cust);
manager.getTransaction().commit();
} finally {
manager.close();
}
System.out.println("Address was also persisted with auto-generated key: " + address.getId());
System.out.println("Return detached Customer instance: " + cust.getId());
return cust;
}
/**
* called when this event "happens". The customer first chooses the "best" checkout line, then
* either starts checking out or waits in line.
*
* @externals requires Checkout, Customer, StartCheckoutEvent
*/
public void action() {
SoopaStore.readNextArrival();
Checkout checkout = SoopaStore.preferableCheckout();
Customer customer = (Customer) this.getActor();
if (checkout.getLength() == 0) {
// fire a StartCheckoutEvent at the next time unit.
Event event = new StartCheckoutEvent(time + 1, customer, checkout);
checkout.setCheckingOut(customer);
SoopaStore.getEventList().insertInOrder(event);
} else {
// append self to queue. (stand in line)
customer.startWaiting(time);
checkout.getInLine(customer);
}
System.out.printf(
"Time %d: Customer %d arrives (%d items, Patience %d, checkout %d)\n",
time,
customer.getId(),
customer.getNumItems(),
customer.getPatience(),
checkout.getIndex());
}