/*
 * RHQ Management Platform
 * Copyright (C) 2005-2008 Red Hat, Inc.
 * All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation version 2 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
package org.rhq.enterprise.server.content;

import java.text.ParseException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import javax.ejb.EJB;
import javax.ejb.Stateless;
import javax.ejb.TransactionAttribute;
import javax.ejb.TransactionAttributeType;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.quartz.CronExpression;
import org.quartz.SchedulerException;

import org.jboss.annotation.IgnoreDependency;
import org.jboss.annotation.ejb.TransactionTimeout;

import org.rhq.core.domain.auth.Subject;
import org.rhq.core.domain.authz.Permission;
import org.rhq.core.domain.content.Advisory;
import org.rhq.core.domain.content.ContentSource;
import org.rhq.core.domain.content.ContentSyncStatus;
import org.rhq.core.domain.content.Distribution;
import org.rhq.core.domain.content.PackageVersion;
import org.rhq.core.domain.content.PackageVersionContentSource;
import org.rhq.core.domain.content.Repo;
import org.rhq.core.domain.content.RepoAdvisory;
import org.rhq.core.domain.content.RepoContentSource;
import org.rhq.core.domain.content.RepoDistribution;
import org.rhq.core.domain.content.RepoGroup;
import org.rhq.core.domain.content.RepoGroupType;
import org.rhq.core.domain.content.RepoPackageVersion;
import org.rhq.core.domain.content.RepoRelationship;
import org.rhq.core.domain.content.RepoRelationshipType;
import org.rhq.core.domain.content.RepoRepoRelationship;
import org.rhq.core.domain.content.RepoSyncResults;
import org.rhq.core.domain.content.ResourceRepo;
import org.rhq.core.domain.content.composite.RepoComposite;
import org.rhq.core.domain.content.transfer.SubscribedRepo;
import org.rhq.core.domain.criteria.PackageVersionCriteria;
import org.rhq.core.domain.criteria.RepoCriteria;
import org.rhq.core.domain.resource.Resource;
import org.rhq.core.domain.server.PersistenceUtility;
import org.rhq.core.domain.util.PageControl;
import org.rhq.core.domain.util.PageList;
import org.rhq.core.domain.util.PageOrdering;
import org.rhq.enterprise.server.RHQConstants;
import org.rhq.enterprise.server.auth.SubjectManagerLocal;
import org.rhq.enterprise.server.authz.AuthorizationManagerLocal;
import org.rhq.enterprise.server.authz.PermissionException;
import org.rhq.enterprise.server.authz.RequiredPermission;
import org.rhq.enterprise.server.plugin.pc.content.ContentProvider;
import org.rhq.enterprise.server.plugin.pc.content.ContentProviderManager;
import org.rhq.enterprise.server.plugin.pc.content.ContentServerPluginContainer;
import org.rhq.enterprise.server.plugin.pc.content.PackageSource;
import org.rhq.enterprise.server.plugin.pc.content.PackageTypeBehavior;
import org.rhq.enterprise.server.plugin.pc.content.RepoDetails;
import org.rhq.enterprise.server.plugin.pc.content.RepoGroupDetails;
import org.rhq.enterprise.server.plugin.pc.content.RepoImportReport;
import org.rhq.enterprise.server.util.CriteriaQueryGenerator;
import org.rhq.enterprise.server.util.CriteriaQueryRunner;
import org.rhq.enterprise.server.util.QueryUtility;

@Stateless
public class RepoManagerBean implements RepoManagerLocal, RepoManagerRemote {

    /**
     * Refers to the default repo relationship created at DB setup time to represent a parent/child repo
     * relationship.
     * <p/>
     * This probably isn't the best place to store this, but for now this is the primary usage of this
     * relationship type.
     */
    private static final String PARENT_RELATIONSHIP_NAME = "parent";

    private final Log log = LogFactory.getLog(RepoManagerBean.class);

    @PersistenceContext(unitName = RHQConstants.PERSISTENCE_UNIT_NAME)
    private EntityManager entityManager;

    @EJB
    private AuthorizationManagerLocal authzManager;

    @IgnoreDependency
    @EJB
    private ContentSourceManagerLocal contentSourceManager;

    @EJB
    private SubjectManagerLocal subjectManager;

    @EJB
    private RepoManagerLocal repoManager;

    public void deleteRepo(Subject subject, int repoId) {
        
        if (!authzManager.canUpdateRepo(subject, repoId)) {
            throw new PermissionException("User [" + subject + "] cannot delete repository with id " + repoId);
        }
        
        log.info("User [" + subject + "] is deleting repository with id [" + repoId + "]...");

        // bulk delete m-2-m mappings to the doomed repo
        // get ready for bulk delete by clearing entity manager
        entityManager.flush();
        entityManager.clear();

        entityManager.createNamedQuery(ResourceRepo.DELETE_BY_REPO_ID).setParameter("repoId", repoId).executeUpdate();

        entityManager.createNamedQuery(RepoContentSource.DELETE_BY_REPO_ID).setParameter("repoId", repoId)
            .executeUpdate();

        entityManager.createNamedQuery(RepoPackageVersion.DELETE_BY_REPO_ID).setParameter("repoId", repoId)
            .executeUpdate();

        Repo repo = entityManager.find(Repo.class, repoId);
        if (repo != null) {
            entityManager.remove(repo);
            log.debug("User [" + subject + "] deleted repository [" + repo + "]");
        } else {
            log.debug("Repository with id [" + repoId + "] doesn't exist - nothing to delete");
        }

        // remove any unused, orphaned package versions
        contentSourceManager.purgeOrphanedPackageVersions(subject);
    }

    @RequiredPermission(Permission.MANAGE_REPOSITORIES)
    public void deleteRepoGroup(Subject subject, int repoGroupId) {
        RepoGroup deleteMe = getRepoGroup(subject, repoGroupId);
        entityManager.remove(deleteMe);
    }

    public boolean deletePackageVersionsFromRepo(Subject subject, int repoId, int[] packageVersionIds) {
        if (packageVersionIds == null || packageVersionIds.length == 0) {
            return true;
        }
        
        if (!authzManager.canUpdateRepo(subject, repoId)) {
            throw new PermissionException("User [" + subject + "] cannot update the repo with id " + repoId + " and therefore cannot delete package versions from it.");
        }
        
        ArrayList<Integer> ids = new ArrayList<Integer>();
        for(int id : packageVersionIds) {
            ids.add(id);
        }

        Query deleteable = entityManager.createNamedQuery(PackageVersion.QUERY_FIND_DELETEABLE_IDS_IN_REPO);
        deleteable.setParameter("repoId", repoId);
        deleteable.setParameter("packageVersionIds", ids);
        
        @SuppressWarnings("unchecked")
        List<Integer> deleteableIds = (List<Integer>) deleteable.getResultList();
        
        if (deleteableIds.isEmpty()) {
            return false;
        }
        
        Query deleteRepoPackageVersions = entityManager.createNamedQuery(RepoPackageVersion.DELETE_MULTIPLE_WHEN_NO_PROVIDER);
        deleteRepoPackageVersions.setParameter("repoId", repoId);            
        deleteRepoPackageVersions.setParameter("packageVersionIds", deleteableIds);
        
        deleteRepoPackageVersions.executeUpdate();
        
        Query deletePackageVersions = entityManager.createNamedQuery(PackageVersion.DELETE_MULTIPLE_IF_NO_CONTENT_SOURCES_OR_REPOS);
        deletePackageVersions.setParameter("packageVersionIds", deleteableIds);
        
        int deleted = deletePackageVersions.executeUpdate();
        
        return deleted == packageVersionIds.length;
    }
    
    @SuppressWarnings("unchecked")
    public PageList<Repo> findRepos(Subject subject, PageControl pc) {
        pc.initDefaultOrderingField("c.name");

        Query query = null;
        Query countQuery = null;
        
        if (authzManager.hasGlobalPermission(subject, Permission.MANAGE_REPOSITORIES)) {
            query = PersistenceUtility.createQueryWithOrderBy(entityManager, Repo.QUERY_FIND_ALL_IMPORTED_REPOS_ADMIN, pc);
            countQuery = PersistenceUtility.createCountQuery(entityManager, Repo.QUERY_FIND_ALL_IMPORTED_REPOS_ADMIN);
        } else {
            query = PersistenceUtility.createQueryWithOrderBy(entityManager, Repo.QUERY_FIND_ALL_IMPORTED_REPOS, pc);
            countQuery = PersistenceUtility.createCountQuery(entityManager, Repo.QUERY_FIND_ALL_IMPORTED_REPOS);
            
            query.setParameter("subject", subject);
            countQuery.setParameter("subject", subject);
        }
        
        List<Repo> results = query.getResultList();
        long count = (Long) countQuery.getSingleResult();

        return new PageList<Repo>(results, (int) count, pc);
    }

    public Repo getRepo(Subject subject, int repoId) {
        if (!authzManager.canViewRepo(subject, repoId)) {
            throw new PermissionException("User [" + subject + "] cannot access the repo with id " + repoId);
        }
        
        Repo repo = entityManager.find(Repo.class, repoId);

        if ((repo != null) && (repo.getRepoContentSources() != null)) {
            // load content sources separately. we can't do this all at once via fetch join because
            // on Oracle we use a LOB column on a content source field and you can't DISTINCT on LOBs
            repo.getRepoContentSources().size();
        }

        return repo;
    }

    @RequiredPermission(Permission.MANAGE_REPOSITORIES)
    public RepoGroup getRepoGroup(Subject subject, int repoGroupId) {
        RepoGroup repoGroup = entityManager.find(RepoGroup.class, repoGroupId);
        return repoGroup;
    }

    @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);
    }

    @SuppressWarnings("unchecked")
    @RequiredPermission(Permission.MANAGE_INVENTORY)
    public PageList<Resource> findSubscribedResources(Subject subject, int repoId, PageControl pc) {
        pc.initDefaultOrderingField("rc.resource.id");

        if (!authzManager.canViewRepo(subject, repoId)) {
            throw new PermissionException("User [" + subject + "] can't access repository with id " + repoId);
        }
        
        Query query = PersistenceUtility
            .createQueryWithOrderBy(entityManager, Repo.QUERY_FIND_SUBSCRIBER_RESOURCES, pc);
        Query countQuery = PersistenceUtility.createCountQuery(entityManager, Repo.QUERY_FIND_SUBSCRIBER_RESOURCES);

        query.setParameter("id", repoId);
        countQuery.setParameter("id", repoId);

        List<Resource> results = query.getResultList();
        long count = (Long) countQuery.getSingleResult();

        return new PageList<Resource>(results, (int) count, pc);
    }

    @SuppressWarnings("unchecked")
    // current resource subscriptions should be viewing, but perhaps available ones shouldn't
    public PageList<RepoComposite> findResourceSubscriptions(Subject subject, int resourceId, PageControl pc) {
        if (!authzManager.canViewResource(subject, resourceId)) {
            throw new PermissionException("User [" + subject + "] can't view resource with id " + resourceId);
        }
        
        pc.initDefaultOrderingField("c.id");

        Query query = PersistenceUtility.createQueryWithOrderBy(entityManager,
            Repo.QUERY_FIND_REPO_COMPOSITES_BY_RESOURCE_ID, pc);
        Query countQuery = entityManager.createNamedQuery(Repo.QUERY_FIND_REPO_COMPOSITES_BY_RESOURCE_ID_COUNT);

        query.setParameter("resourceId", resourceId);
        countQuery.setParameter("resourceId", resourceId);

        List<RepoComposite> results = query.getResultList();
        long count = (Long) countQuery.getSingleResult();

        return new PageList<RepoComposite>(results, (int) count, pc);
    }

    public List<SubscribedRepo> findSubscriptions(Subject subject, int resourceId) {
        if (!authzManager.canViewResource(subject, resourceId)) {
            throw new PermissionException("User [" + subject + "] can't view resource with id " + resourceId);
        }
        
        List<SubscribedRepo> list = new ArrayList<SubscribedRepo>();
        PageControl pc = new PageControl();
        for (RepoComposite repoComposite : findResourceSubscriptions(subject, resourceId, pc)) {
            Repo repo = repoComposite.getRepo();
            SubscribedRepo summary = new SubscribedRepo(repo.getId(), repo.getName());
            list.add(summary);
        }
        return list;
    }

    @SuppressWarnings("unchecked")
    @RequiredPermission(Permission.MANAGE_INVENTORY)
    public PageList<RepoComposite> findAvailableResourceSubscriptions(Subject subject, int resourceId, PageControl pc) {
        pc.initDefaultOrderingField("c.id");

        Query query = null;
        Query countQuery = null;
        
        if (authzManager.hasGlobalPermission(subject, Permission.MANAGE_REPOSITORIES)) {
            query = PersistenceUtility.createQueryWithOrderBy(entityManager,
                Repo.QUERY_FIND_AVAILABLE_REPO_COMPOSITES_BY_RESOURCE_ID_ADMIN, pc);
            countQuery = entityManager
                .createNamedQuery(Repo.QUERY_FIND_AVAILABLE_REPO_COMPOSITES_BY_RESOURCE_ID_ADMIN_COUNT);
        } else {
            query = PersistenceUtility.createQueryWithOrderBy(entityManager,
                Repo.QUERY_FIND_AVAILABLE_REPO_COMPOSITES_BY_RESOURCE_ID, pc);
            countQuery = entityManager
                .createNamedQuery(Repo.QUERY_FIND_AVAILABLE_REPO_COMPOSITES_BY_RESOURCE_ID_COUNT);
            
            query.setParameter("subject", subject);
            countQuery.setParameter("subject", subject);
        }
         
        query.setParameter("resourceId", resourceId);
        countQuery.setParameter("resourceId", resourceId);

        List<RepoComposite> results = query.getResultList();
        long count = (Long) countQuery.getSingleResult();

        return new PageList<RepoComposite>(results, (int) count, pc);
    }

    @SuppressWarnings("unchecked")
    public List<RepoComposite> findResourceSubscriptions(int resourceId) {
        Query query = entityManager.createNamedQuery(Repo.QUERY_FIND_REPO_COMPOSITES_BY_RESOURCE_ID);

        query.setParameter("resourceId", resourceId);

        List<RepoComposite> results = query.getResultList();
        return results;
    }

    @SuppressWarnings("unchecked")
    public List<RepoComposite> findAvailableResourceSubscriptions(int resourceId) {
        Query query = entityManager.createNamedQuery(Repo.QUERY_FIND_AVAILABLE_REPO_COMPOSITES_BY_RESOURCE_ID_ADMIN);

        query.setParameter("resourceId", resourceId);

        List<RepoComposite> results = query.getResultList();
        return results;
    }

    @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")
    public PageList<PackageVersion> findPackageVersionsInRepo(Subject subject, int repoId, String filter, 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_FILTERED, pc);

        query.setParameter("repoId", repoId);
        query.setParameter("filter", QueryUtility.formatSearchParameter(filter));
        query.setParameter("escapeChar", QueryUtility.getEscapeCharacter());

        List<PackageVersion> results = query.getResultList();
        long count = getPackageVersionCountFromRepo(subject, filter, repoId);

        return new PageList<PackageVersion>(results, (int) count, pc);
    }

    public PackageVersion getLatestPackageVersion(Subject subject, int packageId, int repoId) {
        if (!authzManager.canViewRepo(subject, repoId)) {
            throw new PermissionException("User [" + subject + "] cannot access the repo with id " + repoId);
        }
        
        Query q = entityManager.createNamedQuery(PackageVersion.QUERY_FIND_BY_PACKAGE_AND_REPO_ID);
        q.setParameter("packageId", packageId);
        q.setParameter("repoId", repoId);
        
        @SuppressWarnings("unchecked")
        List<PackageVersion> results = (List<PackageVersion>) q.getResultList();
        
        if (results.size() == 0) {
            return null;
        } else if (results.size() == 1) {
            return results.get(0);
        }
        
        PackageVersion latest = results.get(0);
        String packageTypeName = latest.getGeneralPackage().getPackageType().getName();

        Comparator<PackageVersion> versionComparator = null;
        try {
            PackageTypeBehavior behavior = ContentManagerHelper.getPackageTypeBehavior(packageTypeName);
            versionComparator = behavior.getPackageVersionComparator(packageTypeName);
        } catch (Exception e) {
            log.error("Could not get the package type behavior for package type '" + packageTypeName + "'. This should not happen.", e);
        }
        
        if (versionComparator == null) {
            versionComparator = PackageVersion.DEFAULT_COMPARATOR;
        }
        
        Iterator<PackageVersion> it = results.iterator();
        it.next(); //skip the first element, we don't have to compare it with itself
        while(it.hasNext()) {
            PackageVersion current = it.next();
            if (versionComparator.compare(latest, current) < 0) {
                latest = current;
            }
        }
        
        return latest;                    
    }
    
    public Repo updateRepo(Subject subject, Repo repo) throws RepoException {
        validateFields(repo);

        if (!authzManager.hasGlobalPermission(subject, Permission.MANAGE_REPOSITORIES)) {
            if (!authzManager.canUpdateRepo(subject, repo.getId())) {
                throw new PermissionException("User [" + subject + "] can't update repo with id " + repo.getId());
            }
            
            //only the repo manager can update the owner of a repo.
            //make sure that's the case.
            repo.setOwner(subject);
        }
        
        // HHH-2864 - Leave this in until we move to hibernate > 3.2.r14201-2
        getRepo(subject, repo.getId());

        // should we check non-null repo relationships and warn that we aren't changing them?
        log.debug("User [" + subject + "] is updating [" + repo + "]...");
        repo = entityManager.merge(repo);
        log.debug("User [" + subject + "] updated [" + repo + "].");

        try {
            ContentServerPluginContainer pc = ContentManagerHelper.getPluginContainer();
            pc.unscheduleRepoSyncJob(repo);
            pc.scheduleRepoSyncJob(repo);
        } catch (Exception e) {
            log.warn("Failed to reschedule repository synchronization job for [" + repo + "].", e);
        }

        return repo;
    }

    public Repo createRepo(Subject subject, Repo repo) throws RepoException {
        validateRepo(repo);
        
        if (!authzManager.hasGlobalPermission(subject, Permission.MANAGE_REPOSITORIES)) {
            //only the repo manager can update the owner of a repo.
            //make sure that's the case.
            repo.setOwner(subject);
        }
        
        log.debug("User [" + subject + "] is creating [" + repo + "]...");
        entityManager.persist(repo);
        log.info("User [" + subject + "] created [" + repo + "].");

        // If this repo is imported, schedule the repo sync job.
        if (!repo.isCandidate()) {
            try {
                ContentServerPluginContainer pc = ContentManagerHelper.getPluginContainer();
                pc.scheduleRepoSyncJob(repo);
            } catch (Exception e) {
                log.error("Failed to schedule repository synchronization job for [" + repo + "].", e);
                throw new RuntimeException(e);
            }
        }

        return repo; // now has the id set
    }

    @SuppressWarnings("unchecked")
    @RequiredPermission(Permission.MANAGE_REPOSITORIES)
    public void deleteCandidatesWithOnlyContentSource(Subject subject, int contentSourceId) {
        Query query = entityManager.createNamedQuery(Repo.QUERY_FIND_CANDIDATES_WITH_ONLY_CONTENT_SOURCE);

        query.setParameter("contentSourceId", contentSourceId);

        List<Repo> repoList = query.getResultList();

        for (Repo deleteMe : repoList) {
            deleteRepo(subject, deleteMe.getId());
        }
    }

    @RequiredPermission(Permission.MANAGE_REPOSITORIES)
    public void processRepoImportReport(Subject subject, RepoImportReport report, int contentSourceId,
        StringBuilder result) {

        // TODO: The below line was added to simplify things for JON (i.e. patches from JBoss CSP) - remove it if we
        //       need more flexibility for other use cases. (ips, 03/26/10)
        boolean autoImport = (report.getRepoGroups().isEmpty() && report.getRepos().size() == 1);

        // Import groups first
        List<RepoGroupDetails> repoGroups = report.getRepoGroups();

        List<RepoGroupDetails> importedRepoGroups = new ArrayList<RepoGroupDetails>();
        for (RepoGroupDetails createMe : repoGroups) {
            String name = createMe.getName();

            RepoGroup existingGroup = getRepoGroupByName(name);
            if (existingGroup == null) {
                existingGroup = new RepoGroup(name);
                existingGroup.setDescription(createMe.getDescription());

                RepoGroupType groupType = getRepoGroupTypeByName(subject, createMe.getTypeName());
                existingGroup.setRepoGroupType(groupType);

                // Don't let the whole report blow up if one of these fails,
                // but be sure to mention it in the report.
                try {
                    createRepoGroup(subject, existingGroup);
                    importedRepoGroups.add(createMe);
                } catch (RepoException e) {

                    if (e.getType() == RepoException.RepoExceptionType.NAME_ALREADY_EXISTS) {
                        result.append("Skipping existing repository group [").append(name).append("]").append('\n');
                    } else {
                        log.error("Error adding repository group [" + name + "]", e);
                        result.append("Could not add repository group [").append(name)
                            .append("]. See log for more information.").append('\n');
                    }
                }
            }
        }

        if (importedRepoGroups.isEmpty()) {
            result
                .append("There are no new repository groups since the last time this content source was synchronized.\n");
        } else {
            result.append("Imported the following [").append(importedRepoGroups.size())
                .append("] repository group(s): ").append(importedRepoGroups).append('\n');
        }

        // Hold on to all current candidate repos for the content source. If any were not present in this
        // report, remove them from the system (the rationale being, the content source no longer knows
        // about them and thus they cannot be imported).
        RepoCriteria candidateReposCriteria = new RepoCriteria();
        candidateReposCriteria.addFilterContentSourceIds(contentSourceId);
        candidateReposCriteria.addFilterCandidate(true);

        PageList<Repo> candidatesForThisProvider = findReposByCriteria(subject, candidateReposCriteria);

        // Once the groups are in the system, import any repos that were added
        List<RepoDetails> repos = report.getRepos();

        // First add repos that have no parent. We later add repos with a parent afterwards to prevent
        // issues where both the parent and child are specified in this report.
        List<RepoDetails> importedRepos = new ArrayList<RepoDetails>();
        for (RepoDetails createMe : repos) {
            if (createMe.getParentRepoName() == null) {
                try {
                    if (addCandidateRepo(contentSourceId, createMe, autoImport)) {
                        importedRepos.add(createMe);
                    }
                    removeRepoFromList(createMe.getName(), candidatesForThisProvider);
                } catch (Exception e) {
                    if (e instanceof RepoException
                        && ((RepoException) e).getType() == RepoException.RepoExceptionType.NAME_ALREADY_EXISTS) {
                        result.append("Skipping addition of existing repository [").append(createMe.getName())
                            .append("]").append('\n');
                    } else {
                        log.error("Error processing repository [" + createMe + "]", e);
                        result.append("Could not add repository [").append(createMe.getName())
                            .append("]. See log for more information.").append('\n');
                    }
                }
            }
        }

        // Take a second pass through the list checking for any repos that were created to be
        // a child of another repo.
        for (RepoDetails createMe : repos) {
            if (createMe.getParentRepoName() != null) {
                try {
                    if (addCandidateRepo(contentSourceId, createMe, autoImport)) {
                        importedRepos.add(createMe);
                    }
                    removeRepoFromList(createMe.getName(), candidatesForThisProvider);
                } catch (Exception e) {
                    log.error("Error processing repository [" + createMe + "]", e);
                    result.append("Could not add repository [").append(createMe.getName())
                        .append("]. See log for more information.").append('\n');
                }
            }
        }

        if (importedRepos.isEmpty()) {
            result.append("There are no new repositories since the last time this content source was synchronized.\n");
        } else {
            result.append("Imported the following ").append(importedRepos.size()).append(" repository(s): ")
                .append(importedRepos).append('\n');
        }

        // Any repos that haven't been removed from candidatesForThisProvider were not returned in this
        // report, so remove them from the database.
        if (!candidatesForThisProvider.isEmpty()) {
            for (Repo deleteMe : candidatesForThisProvider) {
                deleteRepo(subject, deleteMe.getId());
            }
            result.append("Deleted the following ").append(candidatesForThisProvider.size())
                .append(" obsolete repository(s): ").append(candidatesForThisProvider).append('\n');
        }
    }

    @RequiredPermission(Permission.MANAGE_REPOSITORIES)
    public void importCandidateRepo(Subject subject, List<Integer> repoIds) throws RepoException {
        for (Integer repoId : repoIds) {
            Repo repo = entityManager.find(Repo.class, repoId);

            if (repo == null) {
                throw new RepoException("Unable to find candidate repository with id " + repoId + " for import.");
            }

            if (!repo.isCandidate()) {
                throw new RepoException("Unable to import repository with id " + repoId
                    + ", because it is already imported.");
            }

            repo.setCandidate(false);
        }
    }

    public void removeOwnershipOfSubject(int subjectId) {
        Query q = entityManager.createNamedQuery(Repo.QUERY_UPDATE_REMOVE_OWNER_FROM_REPOS_OWNED_BY_SUBJECT);
        q.setParameter("ownerId", subjectId);
        
        q.executeUpdate();
    }
    
    @RequiredPermission(Permission.MANAGE_REPOSITORIES)
    public RepoGroup createRepoGroup(Subject subject, RepoGroup repoGroup) throws RepoException {
        validateRepoGroup(repoGroup);

        entityManager.persist(repoGroup);

        return repoGroup;
    }

    @SuppressWarnings("unchecked")
    public List<Repo> getRepoByName(String name) {
        Query query = entityManager.createNamedQuery(Repo.QUERY_FIND_BY_NAME);

        query.setParameter("name", name);
        List<Repo> results = query.getResultList();

        return results;
    }

    @SuppressWarnings("unchecked")
    public RepoGroup getRepoGroupByName(String name) {
        Query query = entityManager.createNamedQuery(RepoGroup.QUERY_FIND_BY_NAME);

        query.setParameter("name", name);
        List<RepoGroup> results = query.getResultList();

        if (results.size() > 0) {
            return results.get(0);
        } else {
            return null;
        }
    }

    @SuppressWarnings("unchecked")
    public RepoGroupType getRepoGroupTypeByName(Subject subject, String name) {
        Query query = entityManager.createNamedQuery(RepoGroupType.QUERY_FIND_BY_NAME);

        query.setParameter("name", name);
        List<RepoGroupType> results = query.getResultList();

        if (results.size() > 0) {
            return results.get(0);
        } else {
            return null;
        }
    }

    @SuppressWarnings("unchecked")
    @RequiredPermission(Permission.MANAGE_REPOSITORIES)
    public void addContentSourcesToRepo(Subject subject, int repoId, int[] contentSourceIds) throws Exception {
        Repo repo = entityManager.find(Repo.class, repoId);
        if (repo == null) {
            throw new Exception("There is no repo with an ID [" + repoId + "]");
        }

        repo.setLastModifiedDate(System.currentTimeMillis());

        log.debug("User [" + subject + "] is adding content sources to repo [" + repo + "]");

        ContentServerPluginContainer pc = ContentManagerHelper.getPluginContainer();
        Query q = entityManager.createNamedQuery(PackageVersionContentSource.QUERY_FIND_BY_CONTENT_SOURCE_ID_NO_FETCH);

        for (int id : contentSourceIds) {
            ContentSource contentSource = entityManager.find(ContentSource.class, id);
            if (contentSource == null) {
                throw new Exception("There is no content source with id [" + id + "]");
            }

            Set<ContentSource> alreadyAssociatedContentSources = repo.getContentSources();
            // Only add it if it's not already associated with this repo.
            if (!alreadyAssociatedContentSources.contains(contentSource)) {
                RepoContentSource repoContentSourceMapping = repo.addContentSource(contentSource);
                entityManager.persist(repoContentSourceMapping);
            }
            Set<PackageVersion> alreadyAssociatedPackageVersions = new HashSet<PackageVersion>(
                repo.getPackageVersions());

            // Automatically associate all of the content source's package versions with this repo,
            // but *skip* over the ones that are already linked to this repo from a previous association.
            q.setParameter("id", contentSource.getId());
            List<PackageVersionContentSource> pvcss = q.getResultList();
            for (PackageVersionContentSource pvcs : pvcss) {
                PackageVersion packageVersion = pvcs.getPackageVersionContentSourcePK().getPackageVersion();
                // Only add it if it's not already associated with this repo.
                if (!alreadyAssociatedPackageVersions.contains(packageVersion)) {
                    RepoPackageVersion mapping = new RepoPackageVersion(repo, packageVersion);
                    entityManager.persist(mapping);
                }
            }

            entityManager.flush();
            entityManager.clear();
        }
    }

    public void simpleAddContentSourcesToRepo(Subject subject, int repoId, int[] contentSourceIds) throws Exception {
        Repo repo = entityManager.find(Repo.class, repoId);
        if (repo == null) {
            throw new Exception("There is no repo with an ID [" + repoId + "]");
        }

        for (int id : contentSourceIds) {
            ContentSource cs = entityManager.find(ContentSource.class, id);
            if (cs == null) {
                throw new Exception("There is no content source with id [" + id + "]");
            }

            RepoContentSource ccsmapping = repo.addContentSource(cs);
            entityManager.persist(ccsmapping);
        }
    }

    public void addPackageVersionsToRepo(Subject subject, int repoId, int[] packageVersionIds) {
        if (!authzManager.canUpdateRepo(subject, repoId)) {
            throw new PermissionException("User [" + subject + "] can't update repo with id " + repoId);
        }
                
        Repo repo = entityManager.find(Repo.class, repoId);

        for (int packageVersionId : packageVersionIds) {
            PackageVersion packageVersion = entityManager.find(PackageVersion.class, packageVersionId);

            RepoPackageVersion mapping = new RepoPackageVersion(repo, packageVersion);
            entityManager.persist(mapping);
        }
    }

    @RequiredPermission(Permission.MANAGE_REPOSITORIES)
    public void removeContentSourcesFromRepo(Subject subject, int repoId, int[] contentSourceIds) throws RepoException {
        Repo repo = getRepo(subject, repoId);

        log.debug("User [" + subject + "] is removing content sources from repository [" + repo + "]");

        Set<RepoContentSource> currentSet = repo.getRepoContentSources();

        if ((currentSet != null) && (currentSet.size() > 0)) {
            Set<RepoContentSource> toBeRemoved = new HashSet<RepoContentSource>();
            for (RepoContentSource current : currentSet) {
                for (int id : contentSourceIds) {
                    if (id == current.getRepoContentSourcePK().getContentSource().getId()) {
                        toBeRemoved.add(current);
                        break;
                    }
                }
            }

            for (RepoContentSource doomed : toBeRemoved) {
                entityManager.remove(doomed);
            }

            currentSet.removeAll(toBeRemoved);
        }

        // note that we specifically do not disassociate package versions from the repo, even if those
        // package versions come from the content source that is being removed
    }

    @SuppressWarnings("unchecked")
    public void subscribeResourceToRepos(Subject subject, int resourceId, int[] repoIds) {
        if ((repoIds == null) || (repoIds.length == 0)) {
            return; // nothing to do
        }

        // make sure the user has permissions to subscribe this resource
        if (!authzManager.hasResourcePermission(subject, Permission.MANAGE_CONTENT, resourceId)) {
            throw new PermissionException("[" + subject
                + "] does not have permission to subscribe this resource to repos");
        }

        // find the resource - abort if it does not exist
        Resource resource = entityManager.find(Resource.class, resourceId);
        if (resource == null) {
            throw new RuntimeException("There is no resource with the ID [" + resourceId + "]");
        }

        // find all the repos and subscribe the resource to each of them
        // note that if the length of the ID array doesn't match, then one of the repos doesn't exist
        // and we abort altogether - we do not subscribe to anything unless all repo IDs are valid
        Query q = entityManager.createNamedQuery(Repo.QUERY_FIND_BY_IDS);
        List<Integer> idList = new ArrayList<Integer>(repoIds.length);
        for (Integer id : repoIds) {
            idList.add(id);
        }

        q.setParameter("ids", idList);
        List<Repo> repos = q.getResultList();

        if (repos.size() != repoIds.length) {
            throw new RuntimeException("One or more of the repos do not exist [" + idList + "]->[" + repos + "]");
        }

        //authz check
        for(Repo repo : repos) {
            if (!authzManager.canViewRepo(subject, repo.getId())) {
                throw new PermissionException("User [" + subject + "] cannot access a repo with id " + repo.getId());
            }
        }
        
        for (Repo repo : repos) {
            ResourceRepo mapping = repo.addResource(resource);
            entityManager.persist(mapping);
        }
    }

    @SuppressWarnings("unchecked")
    public void unsubscribeResourceFromRepos(Subject subject, int resourceId, int[] repoIds) {
        if ((repoIds == null) || (repoIds.length == 0)) {
            return; // nothing to do
        }

        // make sure the user has permissions to unsubscribe this resource
        if (!authzManager.hasResourcePermission(subject, Permission.MANAGE_CONTENT, resourceId)) {
            throw new PermissionException("[" + subject
                + "] does not have permission to unsubscribe this resource from repositories");
        }

        // find the resource - abort if it does not exist
        Resource resource = entityManager.find(Resource.class, resourceId);
        if (resource == null) {
            throw new RuntimeException("There is no resource with the ID [" + resourceId + "]");
        }

        // find all the repos and unsubscribe the resource from each of them
        // note that if the length of the ID array doesn't match, then one of the repos doesn't exist
        // and we abort altogether - we do not unsubscribe from anything unless all repo IDs are valid
        Query q = entityManager.createNamedQuery(Repo.QUERY_FIND_BY_IDS);
        List<Integer> idList = new ArrayList<Integer>(repoIds.length);
        for (Integer id : repoIds) {
            idList.add(id);
        }

        q.setParameter("ids", idList);
        List<Repo> repos = q.getResultList();

        if (repos.size() != repoIds.length) {
            throw new RuntimeException("One or more of the repos do not exist [" + idList + "]->[" + repos + "]");
        }

        for (Repo repo : repos) {
            ResourceRepo mapping = repo.removeResource(resource);
            entityManager.remove(mapping);
        }
    }

    public long getPackageVersionCountFromRepo(Subject subject, String filter, int repoId) {
        if (!authzManager.canViewRepo(subject, repoId)) {
            throw new PermissionException("User [" + subject + "] can't access repo with id " + repoId);
        }
        
        Query countQuery = PersistenceUtility.createCountQuery(entityManager,
            PackageVersion.QUERY_FIND_BY_REPO_ID_FILTERED);

        countQuery.setParameter("repoId", repoId);
        countQuery.setParameter("filter", (filter == null) ? null : ("%" + filter.toUpperCase() + "%"));

        return ((Long) countQuery.getSingleResult()).longValue();
    }

    public long getPackageVersionCountFromRepo(Subject subject, int repoId) {
        return getPackageVersionCountFromRepo(subject, null, repoId);
    }

    @SuppressWarnings("unchecked")
    public PageList<Repo> findReposByCriteria(Subject subject, RepoCriteria criteria) {
        CriteriaQueryGenerator generator = new CriteriaQueryGenerator(subject, criteria);
        ;
        
        //TODO this needs the authz applied somehow
        
        CriteriaQueryRunner<Repo> queryRunner = new CriteriaQueryRunner(criteria, generator, entityManager);
        return queryRunner.execute();
    }

    @SuppressWarnings("unchecked")
    public PageList<PackageVersion> findPackageVersionsInRepoByCriteria(Subject subject, PackageVersionCriteria criteria) {
        Integer repoId = criteria.getFilterRepoId();

        if ((null == repoId) || (repoId < 1)) {
            throw new IllegalArgumentException("Illegal filterResourceId: " + repoId);
        }

        if (!authzManager.canViewRepo(subject, repoId)) {
            throw new PermissionException("User [" + subject + "] can't access repo with id " + repoId);
        }
        

        CriteriaQueryGenerator generator = new CriteriaQueryGenerator(subject, criteria);
        ;

        CriteriaQueryRunner<PackageVersion> queryRunner = new CriteriaQueryRunner(criteria, generator, entityManager);

        return queryRunner.execute();
    }

    @RequiredPermission(Permission.MANAGE_REPOSITORIES)
    @TransactionAttribute(TransactionAttributeType.REQUIRED)
    public void addRepoRelationship(Subject subject, int repoId, int relatedRepoId, String relationshipTypeName) {

        Repo repo = entityManager.find(Repo.class, repoId);
        Repo relatedRepo = entityManager.find(Repo.class, relatedRepoId);

        Query typeQuery = entityManager.createNamedQuery(RepoRelationshipType.QUERY_FIND_BY_NAME);
        typeQuery.setParameter("name", relationshipTypeName);
        RepoRelationshipType relationshipType = (RepoRelationshipType) typeQuery.getSingleResult();

        RepoRelationship repoRelationship = new RepoRelationship();
        repoRelationship.setRelatedRepo(relatedRepo);
        repoRelationship.setRepoRelationshipType(relationshipType);
        repoRelationship.addRepo(repo);

        entityManager.persist(repoRelationship);
        relatedRepo.addRepoRelationship(repoRelationship);

        RepoRepoRelationship repoRepoRelationship = new RepoRepoRelationship(repo, repoRelationship);

        entityManager.persist(repoRepoRelationship);
        repo.addRepoRelationship(repoRelationship);
    }

    private void validateFields(Repo repo) throws RepoException {
        if (repo.getName() == null || repo.getName().trim().equals("")) {
            throw new RepoException("Repo name is required");
        }
        if (repo.getSyncSchedule() != null) {
            try {
                CronExpression ce = new CronExpression(repo.getSyncSchedule());
            } catch (ParseException e) {
                throw new RepoException("Repo sync schedule is not a vaild format.");
            }
        }
    }

    private void validateRepo(Repo c) throws RepoException {
        this.validateFields(c);

        List<Repo> repos = getRepoByName(c.getName());
        if (repos.size() != 0) {
            RepoException e = new RepoException("There is already a repo with the name of [" + c.getName() + "]");
            e.setType(RepoException.RepoExceptionType.NAME_ALREADY_EXISTS);
            throw e;
        }
    }

    /**
     * Tests the values of the given repo group to ensure creating the group would be a valid operation, including
     * ensuring the name is specified and there isn't already an existing group with the same name.
     *
     * @param repoGroup group to test
     * @throws RepoException if the group should not be allowed to be created
     */
    private void validateRepoGroup(RepoGroup repoGroup) throws RepoException {
        if (repoGroup.getName() == null || repoGroup.getName().trim().equals("")) {
            throw new RepoException("Repo group name is required");
        }

        RepoGroup existingRepoGroup = getRepoGroupByName(repoGroup.getName());
        if (existingRepoGroup != null) {
            RepoException e = new RepoException("There is already a repo group with the name [" + repoGroup.getName()
                + "]");
            e.setType(RepoException.RepoExceptionType.NAME_ALREADY_EXISTS);
            throw e;
        }
    }

    /**
     * Performs the necessary logic to determine if a candidate repo should be added to the system, adding it
     * in the process if it needs to. If the repo already exists in the system, associate it with the specified
     * content source.
     * <p/>
     * Calling this method with a repo that has a parent assumes the parent has already been created. This call
     * assumes the repo group has been created as well.
     *
     * @param contentSourceId identifies the content source that introduced the candidate into the system
     * @param createMe        describes the candidate to be created
     *
     * @param autoImport      whether or not to import the repo
     *
     * @throws Exception if there is an error associating the content source with the repo or if the repo
     *                   indicates a parent or repo group that does not exist
     */
    private boolean addCandidateRepo(int contentSourceId, RepoDetails createMe, boolean autoImport) throws Exception {

        Subject overlord = subjectManager.getOverlord();
        String name = createMe.getName();

        List<Repo> existingRepos = getRepoByName(name);

        if (!existingRepos.isEmpty()) {
            // The repo already exists - make sure it is associated with the specified content source.
            for (Repo existingRepo : existingRepos) {
                addContentSourcesToRepo(overlord, existingRepo.getId(), new int[] { contentSourceId });
            }
            return false;
        }

        // The repo doesn't exist yet in the system - create it.
        Repo addMe = new Repo(name);
        addMe.setCandidate(!autoImport);
        addMe.setDescription(createMe.getDescription());

        String createMeGroup = createMe.getRepoGroup();
        if (createMeGroup != null) {
            RepoGroup group = getRepoGroupByName(createMeGroup);
            addMe.addRepoGroup(group);
        }

        // Add the new candidate to the database
        addMe = createRepo(overlord, addMe);

        // Associate the content source that introduced the candidate with the repo
        addContentSourcesToRepo(overlord, addMe.getId(), new int[] { contentSourceId });

        // If the repo indicates it has a parent, create that relationship
        String parentName = createMe.getParentRepoName();
        if (parentName != null) {
            List<Repo> parentList = getRepoByName(parentName);

            if (parentList.size() == 0) {
                String error = "Attempting to create repo [" + name + "] with parent [" + parentName
                    + "] but cannot find the parent";
                log.error(error);
                throw new RepoException(error);
            } else {
                Repo parent = parentList.get(0);
                addRepoRelationship(overlord, addMe.getId(), parent.getId(), PARENT_RELATIONSHIP_NAME);
            }
        }

        return true;
    }

    private void removeRepoFromList(String repoName, List<Repo> repoList) {
        Repo deleteMe = null;
        for (Repo checkMe : repoList) {
            if (checkMe.getName().equals(repoName)) {
                deleteMe = checkMe;
                break;
            }
        }

        if (deleteMe != null) {
            repoList.remove(deleteMe);
        }
    }

    @RequiredPermission(Permission.MANAGE_REPOSITORIES)
    public long getDistributionCountFromRepo(Subject subject, int repoId) {
        Query countQuery = PersistenceUtility.createCountQuery(entityManager, RepoDistribution.QUERY_FIND_BY_REPO_ID);

        countQuery.setParameter("repoId", repoId);

        return (Long) countQuery.getSingleResult();
    }

    @RequiredPermission(Permission.MANAGE_REPOSITORIES)
    @SuppressWarnings("unchecked")
    public PageList<Distribution> findAssociatedDistributions(Subject subject, int repoid, PageControl pc) {
        pc.setPrimarySort("rkt.id", PageOrdering.ASC);
        Query query = PersistenceUtility.createQueryWithOrderBy(entityManager, RepoDistribution.QUERY_FIND_BY_REPO_ID,
            pc);

        query.setParameter("repoId", repoid);

        List<RepoDistribution> results = query.getResultList();

        ArrayList<Distribution> distros = new ArrayList();
        for (RepoDistribution result : results) {
            distros.add(result.getRepoDistributionPK().getDistribution());

        }
        long count = getDistributionCountFromRepo(subject, repoid);

        return new PageList<Distribution>(distros, (int) count, pc);

    }

    @RequiredPermission(Permission.MANAGE_REPOSITORIES)
    @SuppressWarnings("unchecked")
    public PageList<Advisory> findAssociatedAdvisory(Subject subject, int repoid, PageControl pc) {
        pc.setPrimarySort("rkt.id", PageOrdering.ASC);
        Query query = PersistenceUtility.createQueryWithOrderBy(entityManager, RepoAdvisory.QUERY_FIND_BY_REPO_ID, pc);

        query.setParameter("repoId", repoid);

        List<RepoAdvisory> results = query.getResultList();

        ArrayList<Advisory> advs = new ArrayList();
        for (RepoAdvisory result : results) {
            advs.add(result.getAdvisory());
        }
        log.debug("list of Advisory : " + advs + " associated to the repo: " + repoid);
        long count = getAdvisoryCountFromRepo(subject, repoid);

        return new PageList<Advisory>(advs, (int) count, pc);

    }

    @RequiredPermission(Permission.MANAGE_REPOSITORIES)
    public long getAdvisoryCountFromRepo(Subject subject, int repoId) {
        Query countQuery = PersistenceUtility.createCountQuery(entityManager, RepoAdvisory.QUERY_FIND_BY_REPO_ID);

        countQuery.setParameter("repoId", repoId);

        return (Long) countQuery.getSingleResult();
    }

    public String calculateSyncStatus(Subject subject, int repoId) {
        Repo found = this.getRepo(subject, repoId);
        List<RepoSyncResults> syncResults = found.getSyncResults();
        // Add the most recent sync results status
        int latestIndex = syncResults.size() - 1;
        if (!syncResults.isEmpty() && syncResults.get(latestIndex) != null) {
            RepoSyncResults results = syncResults.get(latestIndex);
            return results.getStatus().toString();
        } else {
            return ContentSyncStatus.NONE.toString();
        }
    }

    @TransactionAttribute(TransactionAttributeType.REQUIRES_NEW)
    public RepoSyncResults getMostRecentSyncResults(Subject subject, int repoId) {
        Repo found = this.getRepo(subject, repoId);
        List<RepoSyncResults> syncResults = found.getSyncResults();

        int latestIndex = syncResults.size() - 1;
        if (syncResults != null && (!syncResults.isEmpty()) && syncResults.get(latestIndex) != null) {
            return syncResults.get(latestIndex);
        } else {
            return null;
        }
    }

    @RequiredPermission(Permission.MANAGE_REPOSITORIES)
    public int synchronizeRepos(Subject subject, int[] repoIds) throws Exception {
        int syncCount = 0;

        ContentServerPluginContainer pc = ContentManagerHelper.getPluginContainer();

        for (int id : repoIds) {
            try {
                Repo repo = getRepo(subject, id);
                pc.syncRepoNow(repo);
                syncCount++;
            } catch (SchedulerException e) {
                log.error("Error synchronizing repo with id [" + id + "]", e);
            }
        }

        return syncCount;
    }

    @TransactionAttribute(TransactionAttributeType.SUPPORTS)
    // TEMPORARY TIMEOUT DEFINED WHILE WE PROPERLY FIGURE OUT TIMEOUTS
    @TransactionTimeout(86400)
    public int internalSynchronizeRepos(Subject subject, Integer[] repoIds) throws InterruptedException {
        ContentServerPluginContainer pc;
        try {
            pc = ContentManagerHelper.getPluginContainer();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        ContentProviderManager providerManager = pc.getAdapterManager();

        int syncCount = 0;
        for (Integer id : repoIds) {
            boolean syncExecuted = providerManager.synchronizeRepo(id);

            if (syncExecuted) {
                syncCount++;
            }
        }

        return syncCount;
    }

    @RequiredPermission(Permission.MANAGE_REPOSITORIES)
    public void cancelSync(Subject subject, int repoId) throws ContentException {
        ContentServerPluginContainer pc;
        try {
            pc = ContentManagerHelper.getPluginContainer();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }

        Repo repo = this.getRepo(subject, repoId);
        try {
            pc.cancelRepoSync(subject, repo);

        } catch (SchedulerException e) {
            throw new ContentException(e);
        }
        RepoSyncResults results = this.getMostRecentSyncResults(subject, repo.getId());
        results.setStatus(ContentSyncStatus.CANCELLING);
        repoManager.mergeRepoSyncResults(results);
    }

    @SuppressWarnings("unchecked")
    @TransactionAttribute(TransactionAttributeType.REQUIRES_NEW)
    public RepoSyncResults persistRepoSyncResults(RepoSyncResults results) {

        ContentManagerHelper helper = new ContentManagerHelper(entityManager);
        Query q = entityManager.createNamedQuery(RepoSyncResults.QUERY_GET_INPROGRESS_BY_REPO_ID);
        q.setParameter("repoId", results.getRepo().getId());

        RepoSyncResults persistedSyncResults = (RepoSyncResults) helper.persistSyncResults(q, results);
        return (null != persistedSyncResults) ? persistedSyncResults : results;
    }

    @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);
    }

    // we want this in its own tx so other tx's can see it immediately, even if calling method is already in a tx
    @TransactionAttribute(TransactionAttributeType.REQUIRES_NEW)
    public RepoSyncResults mergeRepoSyncResults(RepoSyncResults results) {
        RepoSyncResults retval = entityManager.merge(results);
        return retval;
    }

    public RepoSyncResults getRepoSyncResults(int resultsId) {
        return entityManager.find(RepoSyncResults.class, resultsId);
    }

}