How to use

org.rhq.core.domain.util.PageList

constructor

public PageList<TagReportComposite> findTagReportCompositesByCriteria(Subject subject, TagCriteria tagCriteria) {
  // TODO criteria stuff
  Query query = entityManager.createNamedQuery(Tag.QUERY_TAG_COMPOSITE_REPORT);
  PageList<TagReportComposite> result = new PageList<TagReportComposite>();
  result.addAll(query.getResultList());
  return result;
}

public PageList<LdapGroup> findLdapGroupsByRole(int roleId, PageControl pageControl) {
  Role role = entityManager.find(Role.class, roleId);
  if (role == null) {
    throw new IllegalArgumentException("Could not find role[" + roleId + "] to lookup ldap Groups on");
  }
  return new PageList<LdapGroup>(role.getLdapGroups(), role.getLdapGroups().size(), pageControl);
}

@SuppressWarnings("unchecked")
public PageList<PackageType> getPackageTypes(int resourceTypeId, PageControl pageControl) {
  pageControl.setPrimarySort("pt.name", PageOrdering.ASC);
  Query queryCount = PersistenceUtility.createCountQuery(entityManager,
    PackageType.QUERY_FIND_BY_RESOURCE_TYPE_ID);
  Query query = PersistenceUtility.createQueryWithOrderBy(entityManager,
    PackageType.QUERY_FIND_BY_RESOURCE_TYPE_ID, pageControl);
  queryCount.setParameter("typeId", resourceTypeId);
  query.setParameter("typeId", resourceTypeId);
  long totalCount = (Long) queryCount.getSingleResult();
  List<PackageType> types = query.getResultList();
  return new PageList<PackageType>(types, (int) totalCount, pageControl);
}

@SuppressWarnings("unchecked")
public PageList<PackageVersionMetadataComposite> getPackageVersionMetadata(int resourceId, PageControl pc) {
  pc.initDefaultOrderingField("pv.id");
  Query query = PersistenceUtility.createQueryWithOrderBy(entityManager,
    PackageVersion.QUERY_FIND_METADATA_BY_RESOURCE_ID, pc);
  Query countQuery = PersistenceUtility.createCountQuery(entityManager,
    PackageVersion.QUERY_FIND_METADATA_BY_RESOURCE_ID);
  query.setParameter("resourceId", resourceId);
  countQuery.setParameter("resourceId", resourceId);
  List<PackageVersionMetadataComposite> results = query.getResultList();
  long count = (Long) countQuery.getSingleResult();
  return new PageList<PackageVersionMetadataComposite>(results, (int) count, pc);
}

@SuppressWarnings("unchecked")
public PageList<InstalledPackageHistory> getInstalledPackageHistoryForResource(int resourceId, PageControl pc) {
  pc.initDefaultOrderingField("iph.timestamp", PageOrdering.DESC);
  Query query = PersistenceUtility.createQueryWithOrderBy(entityManager,
    InstalledPackageHistory.QUERY_FIND_BY_RESOURCE_ID, pc);
  Query queryCount = PersistenceUtility.createCountQuery(entityManager,
    InstalledPackageHistory.QUERY_FIND_BY_RESOURCE_ID);
  query.setParameter("resourceId", resourceId);
  queryCount.setParameter("resourceId", resourceId);
  long totalCount = (Long) queryCount.getSingleResult();
  List<InstalledPackageHistory> packages = query.getResultList();
  return new PageList<InstalledPackageHistory>(packages, (int) totalCount, pc);
}

@SuppressWarnings( { "unchecked" })
public PageList<GroupDefinition> getGroupDefinitions(Subject subject, PageControl pc) {
  pc.initDefaultOrderingField("gd.name");
  if (authorizationManager.isInventoryManager(subject)) {
    Query query = PersistenceUtility.createQueryWithOrderBy(entityManager, GroupDefinition.QUERY_FIND_ALL, pc);
    List<GroupDefinition> results = query.getResultList();
    int count = getGroupDefinitionCount(subject);
    return new PageList<GroupDefinition>(results, count, pc);
  } else {
    return new PageList<GroupDefinition>(pc);
  }
}

@SuppressWarnings("unchecked")
@RequiredPermission(Permission.MANAGE_REPOSITORIES)
public PageList<ContentSource> findAssociatedContentSources(Subject subject, int repoId, PageControl pc) {
  pc.initDefaultOrderingField("cs.id");
  Query query = PersistenceUtility.createQueryWithOrderBy(entityManager, ContentSource.QUERY_FIND_BY_REPO_ID, pc);
  Query countQuery = PersistenceUtility.createCountQuery(entityManager, ContentSource.QUERY_FIND_BY_REPO_ID);
  query.setParameter("id", repoId);
  countQuery.setParameter("id", repoId);
  List<ContentSource> results = query.getResultList();
  long count = (Long) countQuery.getSingleResult();
  return new PageList<ContentSource>(results, (int) count, pc);
}

@Override
@SuppressWarnings("unchecked")
public PageList<ConfigurationUpdateComposite> findPluginConfigurationUpdateCompositesByParentId(
  int configurationUpdateId, PageControl pageControl) {
  pageControl.initDefaultOrderingField("cu.modifiedTime");
  Query query = PersistenceUtility.createQueryWithOrderBy(entityManager,
    PluginConfigurationUpdate.QUERY_FIND_COMPOSITE_BY_PARENT_UPDATE_ID, pageControl);
  query.setParameter("groupConfigurationUpdateId", configurationUpdateId);
  long count = getPluginConfigurationUpdateCountByParentId(configurationUpdateId);
  List<ConfigurationUpdateComposite> results = query.getResultList();
  return new PageList<ConfigurationUpdateComposite>(results, (int) count, pageControl);
}

public PageList<LdapGroup> findLdapGroups(PageControl pc) {
  pc.initDefaultOrderingField("g.name");
  String queryName = LdapGroup.QUERY_FIND_ALL;
  Query queryCount = PersistenceUtility.createCountQuery(entityManager, queryName);
  Query query = PersistenceUtility.createQueryWithOrderBy(entityManager, queryName, pc);
  long count = (Long) queryCount.getSingleResult();
  List<LdapGroup> groups = query.getResultList();
  return new PageList<LdapGroup>(groups, (int) count, pc);
}

/** Methods with page control are typically accessed by the GUI, as such apply permission check. */
@SuppressWarnings("unchecked")
@RequiredPermission(Permission.MANAGE_INVENTORY)
public PageList<Agent> getAgentsByServer(Subject subject, Integer serverId, PageControl pageControl) {
  pageControl.initDefaultOrderingField("a.name");
  Query query = PersistenceUtility.createQueryWithOrderBy(entityManager, Agent.QUERY_FIND_BY_SERVER, pageControl);
  Query countQuery = PersistenceUtility.createCountQuery(entityManager, Agent.QUERY_FIND_BY_SERVER);
  query.setParameter("serverId", serverId);
  countQuery.setParameter("serverId", serverId);
  long count = (Long) countQuery.getSingleResult();
  List<Agent> results = query.getResultList();
  return new PageList<Agent>(results, (int) count, pageControl);
}

@SuppressWarnings("unchecked")
@RequiredPermission(Permission.MANAGE_INVENTORY)
public PageList<Agent> getAgentMembers(Subject subject, int affinityGroupId, PageControl pageControl) {
  pageControl.initDefaultOrderingField("a.name");
  Query query = PersistenceUtility.createQueryWithOrderBy(entityManager, Agent.QUERY_FIND_BY_AFFINITY_GROUP,
    pageControl);
  Query countQuery = PersistenceUtility.createCountQuery(entityManager, Agent.QUERY_FIND_BY_AFFINITY_GROUP);
  query.setParameter("affinityGroupId", affinityGroupId);
  countQuery.setParameter("affinityGroupId", affinityGroupId);
  long count = (Long) countQuery.getSingleResult();
  List<Agent> results = query.getResultList();
  return new PageList<Agent>(results, (int) count, pageControl);
}

@SuppressWarnings("unchecked")
@RequiredPermission(Permission.MANAGE_REPOSITORIES)
public PageList<RepoSyncResults> getRepoSyncResults(Subject subject, int repoId, PageControl pc) {
  pc.initDefaultOrderingField("cssr.startTime", PageOrdering.DESC);
  Query query = PersistenceUtility.createQueryWithOrderBy(entityManager,
    RepoSyncResults.QUERY_GET_ALL_BY_REPO_ID, pc);
  Query countQuery = PersistenceUtility.createCountQuery(entityManager, RepoSyncResults.QUERY_GET_ALL_BY_REPO_ID);
  query.setParameter("repoId", repoId);
  countQuery.setParameter("repoId", repoId);
  List<RepoSyncResults> results = query.getResultList();
  long count = (Long) countQuery.getSingleResult();
  return new PageList<RepoSyncResults>(results, (int) count, pc);
}

@SuppressWarnings("unchecked")
@RequiredPermission(Permission.MANAGE_INVENTORY)
public PageList<Server> getServerMembers(Subject subject, int affinityGroupId, PageControl pageControl) {
  pageControl.initDefaultOrderingField("s.name");
  Query query = PersistenceUtility.createQueryWithOrderBy(entityManager, Server.QUERY_FIND_BY_AFFINITY_GROUP,
    pageControl);
  Query countQuery = PersistenceUtility.createCountQuery(entityManager, Server.QUERY_FIND_BY_AFFINITY_GROUP);
  query.setParameter("affinityGroupId", affinityGroupId);
  countQuery.setParameter("affinityGroupId", affinityGroupId);
  long count = (Long) countQuery.getSingleResult();
  List<Server> results = query.getResultList();
  return new PageList<Server>(results, (int) count, pageControl);
}

@SuppressWarnings("unchecked")
@RequiredPermission(Permission.MANAGE_REPOSITORIES)
public PageList<PackageVersionContentSource> getPackageVersionsFromContentSource(Subject subject,
  int contentSourceId, PageControl pc) {
  pc.initDefaultOrderingField("pvcs.contentSource.id");
  Query query = PersistenceUtility.createQueryWithOrderBy(entityManager,
    PackageVersionContentSource.QUERY_FIND_BY_CONTENT_SOURCE_ID, pc);
  query.setParameter("id", contentSourceId);
  List<PackageVersionContentSource> results = query.getResultList();
  long count = getPackageVersionCountFromContentSource(subject, contentSourceId);
  return new PageList<PackageVersionContentSource>(results, (int) count, pc);
}

@SuppressWarnings("unchecked")
@RequiredPermission(Permission.MANAGE_REPOSITORIES)
public PageList<ContentSource> getAllContentSources(Subject subject, PageControl pc) {
  pc.initDefaultOrderingField("cs.name");
  Query query = PersistenceUtility.createQueryWithOrderBy(entityManager,
    ContentSource.QUERY_FIND_ALL_WITH_CONFIG, pc);
  Query countQuery = PersistenceUtility.createCountQuery(entityManager, ContentSource.QUERY_FIND_ALL);
  List<ContentSource> results = query.getResultList();
  long count = (Long) countQuery.getSingleResult();
  return new PageList<ContentSource>(results, (int) count, pc);
}

@SuppressWarnings("unchecked")
@RequiredPermission(Permission.MANAGE_INVENTORY)
public PageList<Server> getServerNonMembers(Subject subject, int affinityGroupId, PageControl pageControl) {
  pageControl.initDefaultOrderingField("s.name");
  Query query = PersistenceUtility.createQueryWithOrderBy(entityManager,
    Server.QUERY_FIND_WITHOUT_AFFINITY_GROUP, pageControl);
  Query countQuery = PersistenceUtility.createCountQuery(entityManager, Server.QUERY_FIND_WITHOUT_AFFINITY_GROUP);
  long count = (Long) countQuery.getSingleResult();
  List<Server> results = query.getResultList();
  return new PageList<Server>(results, (int) count, pageControl);
}

@SuppressWarnings("unchecked")
@RequiredPermission(Permission.MANAGE_INVENTORY)
public PageList<Agent> getAgentNonMembers(Subject subject, int affinityGroupId, PageControl pageControl) {
  pageControl.initDefaultOrderingField("a.name");
  Query query = PersistenceUtility.createQueryWithOrderBy(entityManager, Agent.QUERY_FIND_WITHOUT_AFFINITY_GROUP,
    pageControl);
  Query countQuery = PersistenceUtility.createCountQuery(entityManager, Agent.QUERY_FIND_WITHOUT_AFFINITY_GROUP);
  long count = (Long) countQuery.getSingleResult();
  List<Agent> results = query.getResultList();
  return new PageList<Agent>(results, (int) count, pageControl);
}

@SuppressWarnings("unchecked")
public PageList<PackageVersion> findPackageVersionsInRepo(Subject subject, int repoId, PageControl pc) {
  if (!authzManager.canViewRepo(subject, repoId)) {
    throw new PermissionException("User [" + subject + "] can't access repo with id " + repoId);
  }
  
  pc.initDefaultOrderingField("pv.generalPackage.name, pv.version");
  Query query = PersistenceUtility.createQueryWithOrderBy(entityManager,
    PackageVersion.QUERY_FIND_BY_REPO_ID_WITH_PACKAGE, pc);
  query.setParameter("repoId", repoId);
  List<PackageVersion> results = query.getResultList();
  long count = getPackageVersionCountFromRepo(subject, null, repoId);
  return new PageList<PackageVersion>(results, (int) count, pc);
}

@SuppressWarnings("unchecked")
@RequiredPermissions({ @RequiredPermission(Permission.MANAGE_SETTINGS),
  @RequiredPermission(Permission.MANAGE_INVENTORY) })
public PageList<AffinityGroupCountComposite> getComposites(Subject subject, PageControl pageControl) {
  pageControl.initDefaultOrderingField("ag.name");
  Query query = PersistenceUtility.createQueryWithOrderBy(entityManager, AffinityGroup.QUERY_FIND_ALL_COMPOSITES,
    pageControl);
  int count = getAffinityGroupCount();
  List<AffinityGroupCountComposite> results = query.getResultList();
  return new PageList<AffinityGroupCountComposite>(results, count, pageControl);
}

@SuppressWarnings("unchecked")
@RequiredPermissions({ @RequiredPermission(Permission.MANAGE_SETTINGS),
  @RequiredPermission(Permission.MANAGE_INVENTORY) })
public PageList<ServerWithAgentCountComposite> getServerComposites(Subject subject, PageControl pc) {
  pc.initDefaultOrderingField("s.name");
  Query query = PersistenceUtility.createQueryWithOrderBy(entityManager, Server.QUERY_FIND_ALL_COMPOSITES, pc);
  List<ServerWithAgentCountComposite> results = query.getResultList();
  int count = getServerCount();
  return new PageList<ServerWithAgentCountComposite>(results, count, pc);
}