@SuppressWarnings("unchecked") public List<PackageType> getPackageTypes(int resourceTypeId) { OrderingField orderingField = new OrderingField("pt.displayName", PageOrdering.ASC); Query query = PersistenceUtility.createQueryWithOrderBy(entityManager, PackageType.QUERY_FIND_BY_RESOURCE_TYPE_ID, orderingField); query.setParameter("typeId", resourceTypeId); List<PackageType> packageList = query.getResultList(); return packageList; }
private static StringBuilder buildOrderBy(StringBuilder query, OrderingField... orderByFields) { boolean first = true; for (OrderingField orderingField : orderByFields) { if (first) { // TODO GH: We could see if there already is an order by clause and contribute or override it query.append(" ORDER BY "); first = false; } else { query.append(", "); } query.append(orderingField.getField()).append(" ").append(orderingField.getOrdering()); } return query; }
public void sortBy(String sortField) { boolean wasAlreadySortedOn = false; for (int i = 0, sz = orderingFields.size(); i < sz; i++) { OrderingField field = orderingFields.get(i); if (sortField.equals(field.getField())) { /* * When a user clicks on some column to sort it, that column is promoted to the primary sort column, and * the rest of the orderings move down in the list */ orderingFields.remove(i); field.flipOrdering(); orderingFields.addFirst(field); wasAlreadySortedOn = true; break; } } /* * if we weren't already sorting on this field, we'll add it as the new primary sort. however, for objects with * many, many fields we want to limit the number of sorted columns, so we'll remove any elements if the list * size exceeds MAX_ORDERING_FIELD_COUNT */ if (wasAlreadySortedOn == false) { OrderingField field = new OrderingField(sortField, PageOrdering.ASC); orderingFields.addFirst(field); if (orderingFields.size() > MAX_ORDERING_FIELD_COUNT) { orderingFields.removeLast(); } } }
public void setPrimarySort(String sortColumn, PageOrdering sortOrder) { OrderingField primaryOrderingField = getPrimaryOrderingField(); if (primaryOrderingField == null) { primaryOrderingField = new OrderingField(sortColumn, sortOrder); orderingFields.add(primaryOrderingField); } else { primaryOrderingField.setField(sortColumn); primaryOrderingField.setOrdering(sortOrder); } }
/** * Add a default ordering field. If the maximum number of sort fields (currently 3) are already * defined this call will have no effect. If the field is already a sort field this call will have no * effect. Otherwise, the ordering field will be appended to the existing ordering fields. * * @param defaultField * @param defaultPageOrdering */ public void addDefaultOrderingField(String defaultField, PageOrdering defaultPageOrdering) { if (orderingFields.size() >= MAX_ORDERING_FIELD_COUNT) { return; // only need to add defaults if there are less than 3 sort orders } for (OrderingField ordering : orderingFields) { if (ordering.getField().equals(defaultField)) { /* * return immediately, since we've apparently already added this sort field to the * list of OrderingFields; UI actions, in particular the integration of sort columns * on tabular displays with this PageControl object, will dictate whether or not the * PageOrdering will be reversed, but that logic occurs elsewhere */ return; } } orderingFields.add(new OrderingField(defaultField, defaultPageOrdering)); }
public PageControl(int pageNumber, int pageSize, OrderingField... orderingFields) { this(pageNumber, pageSize); for (OrderingField orderingField : orderingFields) { // null fields are equivalent to not setting the ordering field at all if (orderingField.getField() != null) { this.orderingFields.add(orderingField); } } }
public PageOrdering getPrimarySortOrder() { OrderingField primaryOrderingField = getPrimaryOrderingField(); if (primaryOrderingField == null) { return null; } return getPrimaryOrderingField().getOrdering(); }
public void setPrimarySortOrder(PageOrdering sortOrder) { OrderingField primaryOrderingField = getPrimaryOrderingField(); if (primaryOrderingField == null) { // attempting to change sortOrder when no sortColumn has been selected, ignore return; } primaryOrderingField.setOrdering(sortOrder); }
public void removeOrderingField(String doomedField) { for (Iterator<OrderingField> i = orderingFields.iterator(); i.hasNext();) { OrderingField field = i.next(); if (field.getField().equals(doomedField)) { i.remove(); break; } } }
private static String getOrderByFragment(OrderingField... orderByFields) { boolean first = true; StringBuilder builder = new StringBuilder(); for (OrderingField orderingField : orderByFields) { if (first) { builder.append(" ORDER BY "); first = false; } else { builder.append(", "); } builder.append(orderingField.getField()).append(" ").append(orderingField.getOrdering()); } return builder.toString(); }
public List<PackageType> getPackageTypes() { OrderingField orderingField = new OrderingField("pt.displayName", PageOrdering.ASC); Query query = PersistenceUtility.createQueryWithOrderBy(entityManager, PackageType.QUERY_FIND_ALL, orderingField); @SuppressWarnings("unchecked") List<PackageType> packageList = (List<PackageType>) query.getResultList(); return packageList; }
public String getPrimarySortColumn() { OrderingField primaryOrderingField = getPrimaryOrderingField(); if (primaryOrderingField == null) { return null; } return primaryOrderingField.getField(); }
private void fixOrder(List<OrderingField> orderingFields) { Collections.reverse(orderingFields); if (this.currentOrderingFields != null && orderingFields.size() > 1 && orderingFields.size() == this.currentOrderingFields.size()) { for (int i = 1, sortFieldsSize = orderingFields.size(); i < sortFieldsSize; i++) { OrderingField orderingField = orderingFields.get(i); OrderingField currentOrderingField = this.currentOrderingFields.get(i); if (orderingField.getField().equals(currentOrderingField.getField()) && orderingField.getOrdering() != currentOrderingField.getOrdering()) { orderingFields.remove(i); orderingFields.add(0, orderingField); } } } } }
private CreateResourceHistory findMatchingCreateResourceHistory(Integer parentId, String resourceKey) { Query query = PersistenceUtility.createQueryWithOrderBy(entityManager, CreateResourceHistory.QUERY_FIND_BY_CHILD_RESOURCE_KEY, new PageControl(0, 1, new OrderingField("mtime", DESC))); query.setParameter("parentResourceId", parentId); query.setParameter("newResourceKey", resourceKey); Iterator iterator = query.getResultList().iterator(); if (iterator.hasNext()) { CreateResourceHistory next = (CreateResourceHistory) iterator.next(); if (next.getStatus() == SUCCESS) { return next; } } return null; }
@Override public String toString() { StringBuilder buf = new StringBuilder("PageControl["); if (firstRecord != null) { buf.append("firstRow=").append(firstRecord); } else { buf.append("page=").append(pageNumber); } buf.append(", size=").append(pageSize); int i = 0; if (orderingFields.size() > 0) { buf.append(", sort["); for (OrderingField orderingField : orderingFields) { if (i++ != 0) { buf.append(", "); } buf.append(orderingField.getField()).append(" ").append(orderingField.getOrdering()); } buf.append("]"); } buf.append("]"); return buf.toString(); }
/** * Determine the Schedules for a Resource and DataType. The data type is used to filter out (numerical) measurement * and / or traits. If it is null, then we don't filter by DataType * * @param subject Subject of the caller * @param resourceId PK of the resource we're interested in * @param dataType DataType of the desired results use null for no filtering * @param displayType the display type of the property or null for no filtering * * @return List of MeasuremenSchedules for the given resource */ @SuppressWarnings("unchecked") public List<MeasurementSchedule> findSchedulesForResourceAndType(Subject subject, int resourceId, DataType dataType, DisplayType displayType, boolean enabledOnly) { OrderingField sortOrder = new OrderingField("ms.definition.displayName", PageOrdering.ASC); Query query = PersistenceUtility.createQueryWithOrderBy(entityManager, MeasurementSchedule.FIND_ALL_FOR_RESOURCE_ID, sortOrder); query.setParameter("resourceId", resourceId); query.setParameter("dataType", dataType); query.setParameter("displayType", displayType); query.setParameter("enabled", enabledOnly ? true : null); List<MeasurementSchedule> results = query.getResultList(); return results; }
private Query buildQuery(String queryString, PageControl pageControl) { boolean first = true; StringBuilder queryBuilder = new StringBuilder(queryString); for (OrderingField orderingField : pageControl.getOrderingFieldsAsArray()) { if (first) { // TODO GH: We could see if there already is an order by clause and contribute or override it queryBuilder.append(" ORDER BY "); first = false; } else { queryBuilder.append(", "); } queryBuilder.append(orderingField.getField()).append(" ").append(orderingField.getOrdering()); } Query query = entityManager.createQuery(queryBuilder.toString()); if (pageControl.getPageSize() > 0) { query.setFirstResult(pageControl.getStartRow()); query.setMaxResults(pageControl.getPageSize()); } return query; }
/** * Convert RichFaces SortField2s to RHQ OrderingFields. * * @param sortFields the SortField2s to be converted * * @return the equivalent RHQ OrderingFields */ private List<OrderingField> toOrderingFields(List<SortField2> sortFields) { if (sortFields == null) { sortFields = Collections.emptyList(); } List<OrderingField> orderingFields = new ArrayList<OrderingField>(sortFields.size()); for (SortField2 sortField : sortFields) { Expression expression = sortField.getExpression(); String expressionString = expression.getExpressionString(); String field; if (expression.isLiteralText()) { field = expressionString; } else { field = expressionString.replaceAll("[#|$]\\{", "").replaceAll("\\}", ""); } Ordering ordering = sortField.getOrdering(); PageOrdering pageOrdering = (ordering == Ordering.ASCENDING) ? PageOrdering.ASC : PageOrdering.DESC; OrderingField orderingField = new OrderingField(field, pageOrdering); orderingFields.add(orderingField); } return orderingFields; }
PageOrdering ordering = orderingField.getOrdering(); String fieldName = orderingField.getField(); String override = criteria.getJPQLSortOverride(fieldName); String suffix = (override == null) ? fieldName : override;
MeasurementDataTrait.FIND_CURRENT_FOR_RESOURCE, new OrderingField("d.displayOrder", PageOrdering.ASC)); } else { query = PersistenceUtility.createQueryWithOrderBy(entityManager, MeasurementDataTrait.FIND_CURRENT_FOR_RESOURCE_AND_DISPLAY_TYPE, new OrderingField("d.displayOrder", PageOrdering.ASC)); query.setParameter("displayType", displayType);