@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; }
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; }
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; }
/** * 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; }
/** * 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 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); } }
/** * 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; }
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);
Configuration.QUERY_GET_PLUGIN_CONFIG_MAP_BY_GROUP_ID, new OrderingField("r.id", PageOrdering.ASC)); query.setParameter("resourceGroupId", compatibleGroup.getId());
Configuration.QUERY_GET_RESOURCE_CONFIG_MAP_BY_GROUP_ID, new OrderingField("r.id", PageOrdering.ASC)); query.setParameter("resourceGroupId", compatibleGroup.getId());
PageControl pc = new PageControl(0, 1000, new OrderingField("cu.id", PageOrdering.ASC)); while (true) { List<Integer> pagedChildUpdateIds = getConfigurationUpdateIds(groupConfigurationUpdateId,
PageOrdering order = (pageControl.getPrimarySortOrder() == null) ? PageOrdering.ASC : pageControl .getPrimarySortOrder(); filter = getOrderByFragment(new OrderingField(pageControl.getPrimarySortColumn(), order));