public String deleteSelectedRepoSubscriptions() {
    Subject subject = EnterpriseFacesContextUtility.getSubject();
    String[] selected = getSelectedRepoSubscriptions();
    int repoId = Integer.valueOf(FacesContextUtility.getRequiredRequestParameter("id"));
    int[] resourceIds = getIntegerArray(selected);

    if ((resourceIds != null) && (resourceIds.length > 0)) {
      try {
        RepoManagerLocal manager = LookupUtil.getRepoManagerLocal();

        // TODO: we should have a SLSB method that takes a list of resources
        for (int resourceId : resourceIds) {
          manager.unsubscribeResourceFromRepos(subject, resourceId, new int[] {repoId});
        }

        FacesContextUtility.addMessage(
            FacesMessage.SEVERITY_INFO,
            "Unsubscribed [" + resourceIds.length + "] resources from repository");
      } catch (Exception e) {
        FacesContextUtility.addMessage(
            FacesMessage.SEVERITY_ERROR,
            "Failed to unsubscribe one or more resources from repository",
            e);
      }
    }

    return "success";
  }
  public String associateSelectedContentSourcesWithRepo() {
    Subject subject = EnterpriseFacesContextUtility.getSubject();
    String[] selected = getSelectedRepoUnsubscriptions();
    int repoId = Integer.valueOf(FacesContextUtility.getRequiredRequestParameter("id"));
    int[] resourceIds = getIntegerArray(selected);

    if ((resourceIds != null) && (resourceIds.length > 0)) {
      try {
        RepoManagerLocal manager = LookupUtil.getRepoManagerLocal();

        for (int resourceId : resourceIds) {
          manager.subscribeResourceToRepos(subject, resourceId, new int[] {repoId});
        }

        FacesContextUtility.addMessage(
            FacesMessage.SEVERITY_INFO,
            "Subscribed [" + resourceIds.length + "] resources with repository");
      } catch (Exception e) {
        FacesContextUtility.addMessage(
            FacesMessage.SEVERITY_ERROR,
            "Failed to subscribe one or more resources with repository",
            e);
      }
    }

    return "success";
  }
    public PageList<Resource> fetchDataForPage(PageControl pc) {
      Subject subject = EnterpriseFacesContextUtility.getSubject();
      int id = Integer.valueOf(FacesContextUtility.getRequiredRequestParameter("id"));
      RepoManagerLocal manager = LookupUtil.getRepoManagerLocal();

      PageList<Resource> results = manager.findSubscribedResources(subject, id, pc);
      return results;
    }
  @BeforeMethod
  public void setupBeforeMethod() throws Exception {

    // Plugin service setup
    prepareScheduler();
    pluginService = new TestContentServerPluginService(this);

    TransactionManager tx = getTransactionManager();
    try {
      tx.begin();
      EntityManager entityManager = getEntityManager();

      ContentManagerLocal contentManager = LookupUtil.getContentManager();
      ContentSourceManagerLocal contentSourceManager = LookupUtil.getContentSourceManager();
      RepoManagerLocal repoManager = LookupUtil.getRepoManagerLocal();
      ResourceTypeManagerLocal resourceTypeManager = LookupUtil.getResourceTypeManager();
      SubjectManagerLocal subjectManager = LookupUtil.getSubjectManager();
      Subject overlord = subjectManager.getOverlord();

      // protect if it aleady exists due to a failed run
      contentSourceType = contentSourceManager.getContentSourceType("testType");
      if (null == contentSourceType) {
        // Create a sample content source type that will be used in this test
        contentSourceType = new ContentSourceType("testType");
        entityManager.persist(contentSourceType);
        entityManager.flush();
      }

      // protect if it aleady exists due to a failed run
      ContentSource cs1 =
          contentSourceManager.getContentSourceByNameAndType(
              overlord, "contentSource1", "testType");
      if (null == cs1) {
        // A repo sync will query all providers for that repo, so add multiple providers
        cs1 = new ContentSource("contentSource1", contentSourceType);
        cs1.setDownloadMode(DownloadMode.DATABASE);
        cs1 = contentSourceManager.simpleCreateContentSource(overlord, cs1);
      }
      ContentSource cs2 =
          contentSourceManager.getContentSourceByNameAndType(
              overlord, "contentSource2", "testType");
      if (null == cs2) {
        cs2 = new ContentSource("contentSource2", contentSourceType);
        cs2.setDownloadMode(DownloadMode.DATABASE);
        cs2 = contentSourceManager.simpleCreateContentSource(overlord, cs2);
      }

      pluginService.associateContentProvider(cs1, contentProvider1);
      pluginService.associateContentProvider(cs2, contentProvider2);

      repoContentSources.add(cs1);
      repoContentSources.add(cs2);

      // Create the package type packages will be created against
      resourceType =
          resourceTypeManager.getResourceTypeByNameAndPlugin(
              TestContentProvider.RESOURCE_TYPE_NAME,
              TestContentProvider.RESOURCE_TYPE_PLUGIN_NAME);
      if (null == resourceType) {
        resourceType =
            new ResourceType(
                TestContentProvider.RESOURCE_TYPE_NAME,
                TestContentProvider.RESOURCE_TYPE_PLUGIN_NAME,
                ResourceCategory.PLATFORM,
                null);
        entityManager.persist(resourceType);
        entityManager.flush();
      }

      List<PackageType> packageTypes =
          contentManager.findPackageTypes(
              overlord,
              TestContentProvider.RESOURCE_TYPE_NAME,
              TestContentProvider.RESOURCE_TYPE_PLUGIN_NAME);
      if (!packageTypes.isEmpty()) {
        packageType = packageTypes.get(0);
      } else {
        packageType = new PackageType(TestContentProvider.PACKAGE_TYPE_NAME, resourceType);
        entityManager.persist(packageType);
      }

      // Create the repo to be synced
      List<Repo> repos = repoManager.getRepoByName(TestContentProvider.REPO_WITH_PACKAGES);
      if (!repos.isEmpty()) {
        repoToSync = repos.get(0);
      } else {
        Repo repo = new Repo(TestContentProvider.REPO_WITH_PACKAGES);
        repo.addContentSource(cs1);
        //        repo.addContentSource(cs2);  Disabled until we implement a second test content
        // source to return new stuff
        repoToSync = repoManager.createRepo(overlord, repo);
      }

      tx.commit();
    } catch (Throwable t) {
      tx.rollback();
      // rethrow because if we swallow the exception then tests proceed to execute when they
      // probably should not
      throw new RuntimeException(t);
    }
  }
  @AfterMethod
  public void tearDownAfterMethod() throws Exception {
    try {

      TransactionManager tx = getTransactionManager();
      tx.begin();
      EntityManager entityManager = getEntityManager();

      Query query;

      ContentSourceManagerLocal contentSourceManagerLocal = LookupUtil.getContentSourceManager();
      RepoManagerLocal repoManager = LookupUtil.getRepoManagerLocal();
      DistributionManagerLocal distroManager = LookupUtil.getDistributionManagerLocal();
      SubjectManagerLocal subjectManager = LookupUtil.getSubjectManager();
      Subject overlord = subjectManager.getOverlord();

      // Delete all distributions
      distroManager.deleteDistributionMappingsForRepo(overlord, repoToSync.getId());

      for (String distroLabel : TestContentProvider.DISTRIBUTIONS.keySet()) {
        Distribution distro = distroManager.getDistributionByLabel(distroLabel);
        if (distro != null) {
          // Delete the files
          query = entityManager.createNamedQuery(DistributionFile.DELETE_BY_DIST_ID);
          query.setParameter("distId", distro.getId());
          query.executeUpdate();

          // Delete the actual distro
          distroManager.deleteDistributionByDistId(overlord, distro.getId());
        }
      }

      // Delete all package version <-> content source mappings
      for (ContentSource source : repoContentSources) {
        contentSourceManagerLocal.deleteContentSource(overlord, source.getId());
      }
      repoContentSources.clear();

      // Delete the repo
      repoManager.deleteRepo(overlord, repoToSync.getId());

      // Delete any packages that were created
      for (ContentProviderPackageDetails details : TestContentProvider.PACKAGES.values()) {
        String packageName = details.getContentProviderPackageDetailsKey().getName();

        query = entityManager.createNamedQuery(Package.QUERY_FIND_BY_NAME_PKG_TYPE_ID);
        query.setParameter("name", packageName);
        query.setParameter("packageTypeId", packageType.getId());

        Package p = (Package) query.getSingleResult();
        entityManager.remove(p);
      }

      // Delete the package type
      packageType = entityManager.find(PackageType.class, packageType.getId());
      entityManager.remove(packageType);

      resourceType = entityManager.find(ResourceType.class, resourceType.getId());
      entityManager.remove(resourceType);

      // Delete the content source type
      contentSourceType = entityManager.find(ContentSourceType.class, contentSourceType.getId());
      entityManager.remove(contentSourceType);

      tx.commit();

      // Cleanup providers between tests
      contentProvider1.reset();
      contentProvider2.reset();

    } finally {
      // Plugin service teardown
      unprepareServerPluginService();
      unprepareScheduler();
    }
  }