@Override public Predicate buildPredicate(CriteriaBuilder builder, FieldPathBuilder fieldPathBuilder, From root, String ceilingEntity, String fullPropertyName, Path explicitPath, List directValues) { //expect it to be allParentCategoryXrefs.category.name, so we need to restrict on allParentCategoryXrefs - 2 levels up Predicate equal = builder.equal(explicitPath.getParentPath().getParentPath().get("defaultReference"), Boolean.TRUE); return equal; } })
protected void attachArchivalConditionIfPossible(Class<?> clazz, Path<?> path, CriteriaBuilder cb, List<Predicate> predicates) { if (Status.class.isAssignableFrom(clazz)) { predicates.add( cb.or( cb.isNull(path.get("archiveStatus").get("archived")), cb.equal(path.get("archiveStatus").get("archived"), 'N') ) ); } }
@Override public List<PageField> readPageFieldsByPageId(Long pageId) { CriteriaBuilder builder = em.getCriteriaBuilder(); CriteriaQuery<PageField> criteria = builder.createQuery(PageField.class); Root<PageFieldImpl> pageField = criteria.from(PageFieldImpl.class); criteria.select(pageField); Path<Object> path = pageField.get("page").get("id"); criteria.where(builder.equal(pageField.get("page").get("id"), pageId)); TypedQuery<PageField> query = em.createQuery(criteria); query.setHint(QueryHints.HINT_CACHEABLE, true); return query.getResultList(); }
protected void attachActiveRestriction(Date currentDate, Path<? extends Product> product, Path<? extends Sku> sku, List<Predicate> restrictions) { CriteriaBuilder builder = em.getCriteriaBuilder(); // Add the product archived status flag restriction restrictions.add(builder.or( builder.isNull(product.get("archiveStatus").get("archived")), builder.equal(product.get("archiveStatus").get("archived"), 'N'))); // Add the active start/end date restrictions restrictions.add(builder.lessThan(sku.get("activeStartDate").as(Date.class), currentDate)); restrictions.add(builder.or( builder.isNull(sku.get("activeEndDate")), builder.greaterThan(sku.get("activeEndDate").as(Date.class), currentDate))); }
@Override public List<IndexFieldType> getIndexFieldTypesByAbbreviationOrPropertyName(String name) { CriteriaBuilder builder = em.getCriteriaBuilder(); CriteriaQuery<IndexFieldType> criteria = builder.createQuery(IndexFieldType.class); Root<IndexFieldTypeImpl> root = criteria.from(IndexFieldTypeImpl.class); criteria.select(root); List<Predicate> restrictions = new ArrayList<>(); restrictions.add(builder.or( builder.equal(root.get("indexField").get("field").get("abbreviation").as(String.class), name), builder.equal(root.get("indexField").get("field").get("propertyName").as(String.class), name))); restrictions.add(builder.or( builder.isNull(root.get("archiveStatus").get("archived")), builder.equal(root.get("archiveStatus").get("archived"), 'N'))); criteria.where(restrictions.toArray(new Predicate[restrictions.size()])); TypedQuery<IndexFieldType> query = em.createQuery(criteria); query.setHint(QueryHints.HINT_CACHEABLE, true); query.setHint(QueryHints.HINT_CACHE_REGION, "query.Catalog"); return query.getResultList(); }
public SandBox retrieveSandBoxManagementById(Long sandBoxId) { CriteriaBuilder builder = sandBoxEntityManager.getCriteriaBuilder(); CriteriaQuery<SandBox> criteria = builder.createQuery(SandBox.class); Root<SandBoxManagementImpl> sandbox = criteria.from(SandBoxManagementImpl.class); criteria.select(sandbox.get("sandBox").as(SandBox.class)); criteria.where( builder.and(builder.equal(sandbox.get("sandBox").get("id"), sandBoxId), builder.or(builder.isNull(sandbox.get("sandBox").get("archiveStatus").get("archived").as(String.class)), builder.notEqual(sandbox.get("sandBox").get("archiveStatus").get("archived").as(Character.class), 'Y'))) ); TypedQuery<SandBox> query = sandBoxEntityManager.createQuery(criteria); List<SandBox> results = query.getResultList(); if (results == null || results.size() == 0) { return null; } return results.get(0); }
/** * given a list of AND-ed restrictions, it determines wether or not the record is "archived", and adds the necessary restrictions. * A record is considered "archived" when the ARCHIVED field is explicitly "Y", so both null and "N" will do as non-archived * @param builder * @param restrictions * @param archivedPath * @param archivedFieldName */ public static void notArchived(CriteriaBuilder builder, List<Predicate> restrictions, Path archivedPath, String archivedFieldName) { Path<ArchiveStatus> archiveValue = archivedPath.<ArchiveStatus> get(archivedFieldName); Predicate archivedNull = builder.isNull(archiveValue); Predicate notArchived = builder.equal(archiveValue, statusNotArchived); restrictions.add(builder.or(archivedNull, notArchived)); }
@Override public List<SandBox> retrieveChildSandBoxesByParentId(Long parentSandBoxId) { CriteriaBuilder builder = sandBoxEntityManager.getCriteriaBuilder(); CriteriaQuery<SandBox> criteria = builder.createQuery(SandBox.class); Root<SandBoxManagementImpl> sandbox = criteria.from(SandBoxManagementImpl.class); criteria.select(sandbox.get("sandBox").as(SandBox.class)); criteria.where( builder.and(sandbox.get("sandBox").get("parentSandBox").in(parentSandBoxId), builder.or(builder.isNotNull(sandbox.get("sandBox").get("name")), builder.notEqual(sandbox.get("sandBox").get("name").as(String.class), "")), builder.or(builder.isNull(sandbox.get("sandBox").get("archiveStatus").get("archived").as(String.class)), builder.notEqual(sandbox.get("sandBox").get("archiveStatus").get("archived").as(Character.class), 'Y'))) ); TypedQuery<SandBox> query = sandBoxEntityManager.createQuery(criteria); return query.getResultList(); }
@Override public List<IndexField> readFieldsByEntityType(FieldEntity entityType) { CriteriaBuilder builder = em.getCriteriaBuilder(); CriteriaQuery<IndexField> criteria = builder.createQuery(IndexField.class); Root<IndexFieldImpl> root = criteria.from(IndexFieldImpl.class); criteria.select(root); criteria.where(root.get("field").get("entityType").as(String.class).in(entityType.getAllLookupTypes())); TypedQuery<IndexField> query = em.createQuery(criteria); query.setHint(QueryHints.HINT_CACHEABLE, true); query.setHint(QueryHints.HINT_CACHE_REGION, "query.Search"); return query.getResultList(); }
@Override public List<SandBox> retrieveAllSandBoxes() { CriteriaBuilder builder = sandBoxEntityManager.getCriteriaBuilder(); CriteriaQuery<SandBox> criteria = builder.createQuery(SandBox.class); Root<SandBoxManagementImpl> sandbox = criteria.from(SandBoxManagementImpl.class); criteria.select(sandbox.get("sandBox").as(SandBox.class)); criteria.where( builder.and(builder.or( builder.isNotNull(sandbox.get("sandBox").get("name")), builder.notEqual(sandbox.get("sandBox").get("name").as(String.class), "")), builder.or( builder.isNull(sandbox.get("sandBox").get("archiveStatus").get("archived").as(String.class)), builder.notEqual(sandbox.get("sandBox").get("archiveStatus").get("archived").as(Character.class), 'Y'))) ); TypedQuery<SandBox> query = sandBoxEntityManager.createQuery(criteria); return query.getResultList(); }
@Override public List<SandBox> retrieveSandBoxesByType(SandBoxType sandboxType) { CriteriaBuilder builder = sandBoxEntityManager.getCriteriaBuilder(); CriteriaQuery<SandBox> criteria = builder.createQuery(SandBox.class); Root<SandBoxManagementImpl> sandbox = criteria.from(SandBoxManagementImpl.class); criteria.select(sandbox.get("sandBox").as(SandBox.class)); criteria.where( builder.and(builder.equal(sandbox.get("sandBox").get("sandboxType"), sandboxType.getType()), builder.or( builder.isNotNull(sandbox.get("sandBox").get("name")), builder.notEqual(sandbox.get("sandBox").get("name").as(String.class), "")), builder.or( builder.isNull(sandbox.get("sandBox").get("archiveStatus").get("archived").as(String.class)), builder.notEqual(sandbox.get("sandBox").get("archiveStatus").get("archived").as(Character.class), 'Y'))) ); TypedQuery<SandBox> query = sandBoxEntityManager.createQuery(criteria); return query.getResultList(); }
public Predicate buildPredicate(CriteriaBuilder builder, FieldPathBuilder fieldPathBuilder, From root, String ceilingEntity, String fullPropertyName, Path explicitPath, List directValues) { return root.get("productOption").get("id").in(directValues); } }));
@Override public Predicate buildPredicate(CriteriaBuilder builder, FieldPathBuilder fieldPathBuilder, From root, String ceilingEntity, String fullPropertyName, Path explicitPath, List directValues) { return root.get("productOption").get("id").in(directValues); } }));
@Override public List<Order> readOrdersForCustomersInDateRange(List<Long> customerIds, Date startDate, Date endDate) { CriteriaBuilder builder = em.getCriteriaBuilder(); CriteriaQuery<Order> criteria = builder.createQuery(Order.class); Root<OrderImpl> order = criteria.from(OrderImpl.class); criteria.select(order); List<Predicate> restrictions = new ArrayList<>(); restrictions.add(builder.between(order.<Date>get("submitDate"), startDate, endDate)); restrictions.add(order.get("customer").get("id").in(customerIds)); criteria.where(restrictions.toArray(new Predicate[restrictions.size()])); criteria.orderBy(builder.desc(order.get("customer")), builder.asc(order.get("submitDate"))); TypedQuery<Order> query = em.createQuery(criteria); query.setHint(QueryHints.HINT_CACHEABLE, true); query.setHint(QueryHints.HINT_CACHE_REGION, "query.Order"); return query.getResultList(); }
@Override public Map<Long, String> retrieveSandboxNamesForSandBoxes(Set<Long> sandBoxIds) { CriteriaBuilder builder = sandBoxEntityManager.getCriteriaBuilder(); CriteriaQuery<SandBox> criteria = builder.createQuery(SandBox.class); Root<SandBoxManagementImpl> sandbox = criteria.from(SandBoxManagementImpl.class); criteria.select(sandbox.get("sandBox").as(SandBox.class)); criteria.where( builder.and(builder.in(sandbox.get("sandBox").get("id")).value(sandBoxIds), builder.or(builder.isNull(sandbox.get("sandBox").get("archiveStatus").get("archived").as(String.class)), builder.notEqual(sandbox.get("sandBox").get("archiveStatus").get("archived").as(Character.class), 'Y'))) ); TypedQuery<SandBox> query = sandBoxEntityManager.createQuery(criteria); List<SandBox> results = query.getResultList(); Map<Long, String> map = new HashMap<Long, String>(); for (SandBox result : results) { map.put(result.getId(), result.getName()); } return map; }
@Override public List<IndexField> readSearchableFieldsByEntityType(FieldEntity entityType) { CriteriaBuilder builder = em.getCriteriaBuilder(); CriteriaQuery<IndexField> criteria = builder.createQuery(IndexField.class); Root<IndexFieldImpl> root = criteria.from(IndexFieldImpl.class); criteria.select(root); criteria.where( builder.equal(root.get("searchable").as(Boolean.class), Boolean.TRUE), root.get("field").get("entityType").as(String.class).in(entityType.getAllLookupTypes()) ); TypedQuery<IndexField> query = em.createQuery(criteria); query.setHint(QueryHints.HINT_CACHEABLE, true); query.setHint(QueryHints.HINT_CACHE_REGION, "query.Search"); return query.getResultList(); }
@Override public List<OrderItem> readOrderItemsForCustomersInDateRange(List<Long> customerIds, Date startDate, Date endDate) { CriteriaBuilder builder = em.getCriteriaBuilder(); CriteriaQuery<OrderItem> criteria = builder.createQuery(OrderItem.class); Root<OrderImpl> order = criteria.from(OrderImpl.class); Join<Order, OrderItem> orderItems = order.join("orderItems"); criteria.select(orderItems); List<Predicate> restrictions = new ArrayList<>(); restrictions.add(builder.between(order.<Date>get("submitDate"), startDate, endDate)); restrictions.add(order.get("customer").get("id").in(customerIds)); criteria.where(restrictions.toArray(new Predicate[restrictions.size()])); criteria.orderBy(builder.desc(order.get("customer")), builder.asc(order.get("submitDate"))); TypedQuery<OrderItem> query = em.createQuery(criteria); query.setHint(QueryHints.HINT_CACHEABLE, true); query.setHint(QueryHints.HINT_CACHE_REGION, "query.Order"); return query.getResultList(); }
public List<Site> retrieveSitesByPotentialIdentifiers(String... potentialIdentifiers) { CriteriaBuilder builder = em.getCriteriaBuilder(); CriteriaQuery<Site> criteria = builder.createQuery(Site.class); Root<SiteImpl> site = criteria.from(SiteImpl.class); criteria.select(site); criteria.where(builder.and(site.get("siteIdentifierValue").as(String.class).in(potentialIdentifiers), builder.and( builder.or(builder.isNull(site.get("archiveStatus").get("archived").as(String.class)), builder.notEqual(site.get("archiveStatus").get("archived").as(Character.class), 'Y')), builder.or(builder.isNull(site.get("deactivated").as(Boolean.class)), builder.notEqual(site.get("deactivated").as(Boolean.class), true)) ) ) ); TypedQuery<Site> query = em.createQuery(criteria); query.setHint(QueryHints.HINT_CACHEABLE, true); query.setHint(QueryHints.HINT_CACHE_REGION, "blSiteElementsQuery"); return query.getResultList(); }
private <T> Expression<T> traversePath(Path<?> root, PropertyPath path) { Path<Object> result = root.get(path.getSegment()); return (Expression<T>) (path.hasNext() ? traversePath(result, path.next()) : result); } }
static Expression<Object> toExpressionRecursively(Path<Object> path, PropertyPath property) { Path<Object> result = path.get(property.getSegment()); return property.hasNext() ? toExpressionRecursively(result, property.next()) : result; }