diff --git a/jpa-persistence/pom.xml b/jpa-persistence/pom.xml index 08374bc..0c889c9 100644 --- a/jpa-persistence/pom.xml +++ b/jpa-persistence/pom.xml @@ -13,56 +13,71 @@ JPA persistence module - - - org.eclipse.persistence - javax.persistence - 2.1.0 - provided - - - javax.validation - validation-api - 1.1.0.Final - provided - - - ${project.groupId} - dukes-domain-model - ${project.version} - - - - - ${project.artifactId} - - - org.codehaus.mojo - exec-maven-plugin - 1.2.1 - - - compile - - exec - - - - - false - ${glassfish.home}/bin/asadmin${glassfish.executables.suffix} - - 0 - 1 - - - create-auth-realm - --classname=com.sun.enterprise.security.auth.realm.jdbc.JDBCRealm - --property=jaas-context=jdbcRealm:datasource-jndi=java\:global/ForestDataSource:user-table=forest.PERSON:user-name-column=email:password-column=password:group-table=forest.GROUPS:group-table-user-name-column=name:group-name-column=name:assign-groups=USERS,ADMINS:digest-algorithm=MD5 - jdbcRealm - - - - - + + + org.eclipse.persistence + javax.persistence + 2.1.0 + provided + + + javax.validation + validation-api + 1.1.0.Final + provided + + + org.glassfish.javaeetutorial + dukes-domain-model + ${project.version} + + + org.glassfish.javaeetutorial + usecases-identity + ${project.version} + + + org.glassfish.javaeetutorial + usecases-catalog + ${project.version} + + + org.glassfish.javaeetutorial + usecases-ecommerce + ${project.version} + + + + + ${project.artifactId} + + + org.codehaus.mojo + exec-maven-plugin + 1.2.1 + + + compile + + exec + + + + + false + ${glassfish.home}/bin/asadmin${glassfish.executables.suffix} + + 0 + 1 + + + create-auth-realm + --classname=com.sun.enterprise.security.auth.realm.jdbc.JDBCRealm + --property=jaas-context=jdbcRealm:datasource-jndi=java\:global/ForestDataSource:user-table=forest.PERSON:user-name-column=email:password-column=password:group-table=forest.GROUPS:group-table-user-name-column=name:group-name-column=name:assign-groups=USERS,ADMINS:digest-algorithm=MD5 + jdbcRealm + + + + + diff --git a/jpa-persistence/src/main/java/com/forest/persitence/jpa/AbstractBasePersistence.java b/jpa-persistence/src/main/java/com/forest/persitence/jpa/AbstractBasePersistence.java index 9647d49..e9fc298 100644 --- a/jpa-persistence/src/main/java/com/forest/persitence/jpa/AbstractBasePersistence.java +++ b/jpa-persistence/src/main/java/com/forest/persitence/jpa/AbstractBasePersistence.java @@ -5,9 +5,10 @@ * compliance with the terms of the License at: * http://java.net/projects/javaeetutorial/pages/BerkeleyLicense */ -package com.forest.ejb; +package com.forest.persitence.jpa; import java.util.List; +import java.util.logging.Logger; import javax.persistence.EntityManager; import javax.persistence.criteria.CriteriaBuilder; import javax.persistence.criteria.CriteriaQuery; @@ -16,42 +17,41 @@ * * @author markito */ -public abstract class AbstractFacade { - private Class entityClass; +public abstract class AbstractBasePersistence { + private Class entityClass; - public AbstractFacade() { + private static final Logger logger = Logger.getLogger(AbstractBasePersistence.class.getCanonicalName()); - } - public AbstractFacade(final Class entityClass) { + public AbstractBasePersistence(final Class entityClass) { this.entityClass = entityClass; } protected abstract EntityManager getEntityManager(); - public void create(T entity) { + public void create(M entity) { getEntityManager().persist(entity); } - public void edit(T entity) { + public void update(M entity) { getEntityManager().merge(entity); } - public void remove(T entity) { + public void remove(M entity) { getEntityManager().remove(getEntityManager().merge(entity)); } - public T find(Object id) { + public M find(Object id) { return getEntityManager().find(entityClass, id); } - public List findAll() { + public List findAll() { javax.persistence.criteria.CriteriaQuery cq = getEntityManager().getCriteriaBuilder().createQuery(); cq.select(cq.from(entityClass)); return getEntityManager().createQuery(cq).getResultList(); } - public List findRange(int[] range) { + public List findRange(int[] range) { javax.persistence.criteria.CriteriaQuery cq = getEntityManager().getCriteriaBuilder().createQuery(); cq.select(cq.from(entityClass)); javax.persistence.Query q = getEntityManager().createQuery(cq); @@ -60,7 +60,7 @@ public List findRange(int[] range) { return q.getResultList(); } - public List findRange(int[] range, CriteriaQuery query) { + public List findRange(int[] range, CriteriaQuery query) { javax.persistence.Query q = getEntityManager().createQuery(query); q.setMaxResults(range[1] - range[0]); q.setFirstResult(range[0]); @@ -74,7 +74,7 @@ public CriteriaBuilder getCriteriaBuilder() { public int count() { javax.persistence.criteria.CriteriaQuery cq = getEntityManager().getCriteriaBuilder().createQuery(); - javax.persistence.criteria.Root rt = cq.from(entityClass); + javax.persistence.criteria.Root rt = cq.from(entityClass); cq.select(getEntityManager().getCriteriaBuilder().count(rt)); javax.persistence.Query q = getEntityManager().createQuery(cq); return ((Long) q.getSingleResult()).intValue(); diff --git a/jpa-persistence/src/main/java/com/forest/persitence/jpa/AdministratorPersistenceJPA.java b/jpa-persistence/src/main/java/com/forest/persitence/jpa/AdministratorPersistenceJPA.java new file mode 100644 index 0000000..51206d7 --- /dev/null +++ b/jpa-persistence/src/main/java/com/forest/persitence/jpa/AdministratorPersistenceJPA.java @@ -0,0 +1,47 @@ +package com.forest.persitence.jpa; + +import javax.persistence.EntityManager; + +import com.forest.entity.AdministratorEntity; +import com.forest.model.Administrator; +import com.forest.usecase.identity.persistence.AdministratorPersistence; + +public class AdministratorPersistenceJPA extends AbstractBasePersistence implements AdministratorPersistence { + + public AdministratorPersistenceJPA() { + super(AdministratorEntity.class); + } + + private EntityManager entityManager; + + public void setEntityManager(EntityManager em) { + this.entityManager = em; + } + + @Override + protected EntityManager getEntityManager() { + return entityManager; + } + + @Override + public void createAdministrator(Administrator administrator) { + super.create(administrator); + } + + + @Override + public void updateAdministrator(Administrator person) { + update(person); + } + + @Override + public void removeAdministrator(Administrator person) { + remove(person); + } + + @Override + public Administrator getAdministrator(int id) { + return find(id); + } + +} diff --git a/jpa-persistence/src/main/java/com/forest/persitence/jpa/CategoryPersistenceJPA.java b/jpa-persistence/src/main/java/com/forest/persitence/jpa/CategoryPersistenceJPA.java new file mode 100644 index 0000000..f12ed68 --- /dev/null +++ b/jpa-persistence/src/main/java/com/forest/persitence/jpa/CategoryPersistenceJPA.java @@ -0,0 +1,49 @@ +package com.forest.persitence.jpa; + +import javax.persistence.EntityManager; + +import com.forest.entity.CategoryEntity; +import com.forest.model.Category; +import com.forest.usecase.catalog.persistence.CategoryPersistence; + +public class CategoryPersistenceJPA extends AbstractBasePersistence implements CategoryPersistence { + + public CategoryPersistenceJPA() { + super(CategoryEntity.class); + } + + private EntityManager entityManager; + + public void setEntityManager(EntityManager em) { + this.entityManager = em; + } + + @Override + protected EntityManager getEntityManager() { + return entityManager; + } + + @Override + public void createCategory(Category category) { + create(category); + } + + @Override + public void updateCategory(Category category) { + update(category); + } + + @Override + public void removeCategory(Category category) { + remove(category); + } + + @Override + public Category getCategory(int id) { + return find(id); + } + + + + +} diff --git a/jpa-persistence/src/main/java/com/forest/persitence/jpa/GroupPersistenceJPA.java b/jpa-persistence/src/main/java/com/forest/persitence/jpa/GroupPersistenceJPA.java new file mode 100644 index 0000000..d89db63 --- /dev/null +++ b/jpa-persistence/src/main/java/com/forest/persitence/jpa/GroupPersistenceJPA.java @@ -0,0 +1,56 @@ +package com.forest.persitence.jpa; + +import javax.persistence.EntityManager; + +import com.forest.entity.GroupsEntity; +import com.forest.model.Group; +import com.forest.usecase.identity.persistence.GroupPersistence; + +public class GroupPersistenceJPA extends AbstractBasePersistence implements GroupPersistence { + + public GroupPersistenceJPA() { + super(GroupsEntity.class); + } + + private EntityManager entityManager; + + public void setEntityManager(EntityManager em) { + this.entityManager = em; + } + + @Override + protected EntityManager getEntityManager() { + return entityManager; + } + + @Override + public void createGroup(Group group) { + super.create(group); + + } + + @Override + public void updateGroup(Group group) { + update(group); + } + + @Override + public void removeGroup(Group group) { + remove(group); + } + + @Override + public Group getGroup(int id) { + return find(id); + } + + @Override + public Group findGroupByName(String name) { + return (Group) entityManager.createNamedQuery("Groups.findByName") + .setParameter("name", "Administrator") + .getSingleResult(); + } + + + +} diff --git a/jpa-persistence/src/main/java/com/forest/persitence/jpa/OrderDetailPersistenceJPA.java b/jpa-persistence/src/main/java/com/forest/persitence/jpa/OrderDetailPersistenceJPA.java new file mode 100644 index 0000000..495f11d --- /dev/null +++ b/jpa-persistence/src/main/java/com/forest/persitence/jpa/OrderDetailPersistenceJPA.java @@ -0,0 +1,60 @@ +package com.forest.persitence.jpa; + +import java.util.List; + +import javax.persistence.EntityManager; + +import com.forest.entity.OrderDetailEntity; +import com.forest.model.OrderDetail; +import com.forest.model.OrderDetailPK; +import com.forest.usecase.ecommerce.persistence.OrderDetailPersistence; + +public class OrderDetailPersistenceJPA extends + AbstractBasePersistence implements + OrderDetailPersistence { + + public OrderDetailPersistenceJPA() { + super(OrderDetailEntity.class); + } + + private EntityManager entityManager; + + public void setEntityManager(EntityManager em) { + this.entityManager = em; + } + + @Override + protected EntityManager getEntityManager() { + return entityManager; + } + + @Override + public void createOrderDetail(OrderDetail orderDetail) { + create(orderDetail); + } + + @Override + public void updateOrderDetail(OrderDetail orderDetail) { + update(orderDetail); + } + + @Override + public void removeOrderDetail(OrderDetail orderDetail) { + remove(orderDetail); + } + + @Override + public OrderDetail getOrderDetail(OrderDetailPK id) { + return find(id); + } + + @Override + public List findOrderDetailByOrder(int orderId) { + List details = getEntityManager() + .createNamedQuery("OrderDetail.findByOrderId") + .setParameter("orderId", orderId).getResultList(); + + return details; + } + +} diff --git a/jpa-persistence/src/main/java/com/forest/persitence/jpa/OrderPersistenceJPA.java b/jpa-persistence/src/main/java/com/forest/persitence/jpa/OrderPersistenceJPA.java new file mode 100644 index 0000000..87e0cb7 --- /dev/null +++ b/jpa-persistence/src/main/java/com/forest/persitence/jpa/OrderPersistenceJPA.java @@ -0,0 +1,68 @@ +package com.forest.persitence.jpa; + +import java.util.List; + +import javax.persistence.EntityManager; +import javax.persistence.Query; + +import com.forest.entity.CustomerOrderEntity; +import com.forest.model.CustomerOrder; +import com.forest.model.OrderStatus; +import com.forest.usecase.ecommerce.persistence.CustomerOrderPersistence; + +public class OrderPersistenceJPA extends AbstractBasePersistence implements CustomerOrderPersistence { + + public OrderPersistenceJPA() { + super(CustomerOrderEntity.class); + } + + private EntityManager entityManager; + + public void setEntityManager(EntityManager em) { + this.entityManager = em; + } + + @Override + protected EntityManager getEntityManager() { + return entityManager; + } + + @Override + public void createCustomerOrder(CustomerOrder product) { + create(product); + } + + @Override + public void updateCustomerOrder(CustomerOrder product) { + update(product); + } + + @Override + public void removeCustomerOrder(CustomerOrder product) { + remove(product); + } + + @Override + public CustomerOrder getCustomerOrder(int id) { + return find(id); + } + + @Override + public List getOrdersByCustomerId(Integer id) { + Query createNamedQuery = getEntityManager().createNamedQuery("CustomerOrder.findByCustomerId"); + + createNamedQuery.setParameter("id", id); + + return createNamedQuery.getResultList(); + } + + @Override + public List getOrdersByStatus(OrderStatus status) { + Query createNamedQuery = getEntityManager().createNamedQuery("CustomerOrder.findByStatus"); + createNamedQuery.setParameter("status", status.getStatus()); + List orders = createNamedQuery.getResultList(); + return orders; + } + + +} diff --git a/jpa-persistence/src/main/java/com/forest/persitence/jpa/OrderStatusPersistenceJPA.java b/jpa-persistence/src/main/java/com/forest/persitence/jpa/OrderStatusPersistenceJPA.java new file mode 100644 index 0000000..ed245e3 --- /dev/null +++ b/jpa-persistence/src/main/java/com/forest/persitence/jpa/OrderStatusPersistenceJPA.java @@ -0,0 +1,60 @@ +package com.forest.persitence.jpa; + +import javax.persistence.EntityManager; +import javax.persistence.Query; + +import com.forest.entity.OrderStatusEntity; +import com.forest.model.OrderStatus; +import com.forest.usecase.ecommerce.persistence.OrderStatusPersistence; + +public class OrderStatusPersistenceJPA extends + AbstractBasePersistence implements + OrderStatusPersistence { + + public OrderStatusPersistenceJPA() { + super(OrderStatusEntity.class); + } + + private EntityManager entityManager; + + public void setEntityManager(EntityManager em) { + this.entityManager = em; + } + + @Override + protected EntityManager getEntityManager() { + return entityManager; + } + + @Override + public void createOrderStatus(OrderStatus orderStatus) { + create(orderStatus); + } + + @Override + public void updateOrderStatus(OrderStatus orderStatus) { + update(orderStatus); + } + + @Override + public void removeOrderStatus(OrderStatus orderStatus) { + remove(orderStatus); + } + + @Override + public OrderStatus getOrderStatus(int id) { + return find(id); + } + + @Override + public OrderStatus findOrderStatusByName(String status) { + Query createNamedQuery = getEntityManager().createNamedQuery( + "OrderStatus.findByStatus"); + + // SELECT o FROM OrderStatus o WHERE o.status = :status + createNamedQuery.setParameter("status", status); + + return (OrderStatus) createNamedQuery.getSingleResult(); + } + +} diff --git a/jpa-persistence/src/main/java/com/forest/persitence/jpa/PersonPersistenceJPA.java b/jpa-persistence/src/main/java/com/forest/persitence/jpa/PersonPersistenceJPA.java new file mode 100644 index 0000000..4294c88 --- /dev/null +++ b/jpa-persistence/src/main/java/com/forest/persitence/jpa/PersonPersistenceJPA.java @@ -0,0 +1,62 @@ +package com.forest.persitence.jpa; + +import javax.persistence.EntityManager; +import javax.persistence.Query; + +import com.forest.entity.PersonEntity; +import com.forest.model.Person; +import com.forest.usecase.identity.persistence.PersonPersistence; + +public class PersonPersistenceJPA extends AbstractBasePersistence implements PersonPersistence { + + public PersonPersistenceJPA() { + super(PersonEntity.class); + } + + private EntityManager entityManager; + + public void setEntityManager(EntityManager em) { + this.entityManager = em; + } + + @Override + protected EntityManager getEntityManager() { + return entityManager; + } + + @Override + public void createPerson(Person person) { + super.create(person); + + } + + @Override + public Person findPersonByEmail(String email) { + Query createNamedQuery = getEntityManager().createNamedQuery("Person.findByEmail"); + + createNamedQuery.setParameter("email", email); + + if (createNamedQuery.getResultList().size() > 0) { + return (Person) createNamedQuery.getSingleResult(); + } + else { + return null; + } + } + + @Override + public void updatePerson(Person person) { + update(person); + } + + @Override + public void removePerson(Person person) { + remove(person); + } + + @Override + public Person getPerson(Integer id) { + return find(id); + } + +} diff --git a/jpa-persistence/src/main/java/com/forest/persitence/jpa/ProductPersistenceJPA.java b/jpa-persistence/src/main/java/com/forest/persitence/jpa/ProductPersistenceJPA.java new file mode 100644 index 0000000..18c1754 --- /dev/null +++ b/jpa-persistence/src/main/java/com/forest/persitence/jpa/ProductPersistenceJPA.java @@ -0,0 +1,68 @@ +package com.forest.persitence.jpa; + +import java.util.List; + +import javax.persistence.EntityManager; +import javax.persistence.criteria.CriteriaBuilder; +import javax.persistence.criteria.CriteriaQuery; +import javax.persistence.criteria.Root; + +import com.forest.entity.CategoryEntity; +import com.forest.entity.ProductEntity; +import com.forest.model.Product; +import com.forest.usecase.catalog.persistence.ProductPersistence; + +public class ProductPersistenceJPA extends AbstractBasePersistence implements ProductPersistence { + + public ProductPersistenceJPA() { + super(ProductEntity.class); + } + + private EntityManager entityManager; + + public void setEntityManager(EntityManager em) { + this.entityManager = em; + } + + @Override + protected EntityManager getEntityManager() { + return entityManager; + } + + @Override + public void createProduct(Product product) { + create(product); + } + + @Override + public void updateProduct(Product product) { + update(product); + } + + @Override + public void removeProduct(Product product) { + remove(product); + } + + @Override + public Product getProduct(int id) { + return find(id); + } + + @Override + public List findByCategory(int[] range, int categoryId) { + CategoryEntity cat = new CategoryEntity(); + cat.setId(categoryId); + + CriteriaBuilder qb = entityManager.getCriteriaBuilder(); + CriteriaQuery query = qb.createQuery(ProductEntity.class); + Root product = query.from(ProductEntity.class); + query.where(qb.equal(product.get("category"), cat)); + + return this.findRange(range, query); + } + + + + +}