Exemplo n.º 1
0
        private bool CheckDeepLicenseAgreements(NuGet.IPackage package)
        {
            this.dependencyWalker.Clear();
            this.dependencyWalker.WalkGraph(new PackageName(package.Id, package.Version.Version));

            List <PackageInfo>    packageGraph      = this.dependencyWalker.VisitedPackages.ToList();
            List <NuGet.IPackage> installedPackages = this.manager.LocalRepository.GetPackages().ToList();

            foreach (PackageInfo visitedPackage in packageGraph)
            {
                // Skip the ones that are already installed
                if (installedPackages.Any(installed =>
                                          installed.Id == visitedPackage.Id &&
                                          installed.Version.Version >= visitedPackage.Version))
                {
                    continue;
                }

                if (!this.CheckLicenseAgreement(visitedPackage))
                {
                    return(false);
                }
            }

            return(true);
        }
Exemplo n.º 2
0
        /// <summary>
        /// Retrieves information about the specified package.
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public PackageInfo GetPackage(PackageName name)
        {
            PackageInfo result;

            lock (this.cacheLock)
            {
                if (this.nameToPackage.TryGetValue(name, out result))
                {
                    return(result);
                }

                NuGet.IPackage nugetPackage = this.GetNuGetPackage(name);
                if (nugetPackage == null)
                {
                    result = null;
                }
                else
                {
                    result = this.WrapPackage(nugetPackage);
                }

                this.nameToPackage[name] = result;
            }
            return(result);
        }
 public void InstallPackage(NuGet.IPackage package, bool ignoreDependencies, bool allowPrereleaseVersions)
 {
     if (InstallPackageCallback != null)
     {
         InstallPackageCallback(package, ignoreDependencies, allowPrereleaseVersions);
     }
 }
 public void UninstallPackage(NuGet.IPackage package, bool forceRemove, bool removeDependencies)
 {
     if (UninstallPackageCallback != null)
     {
         UninstallPackageCallback(package, forceRemove, removeDependencies);
     }
 }
Exemplo n.º 5
0
        private void InstallPackage(PackageName packageName, bool skipLicense)
        {
            NuGet.IPackage installPackage = this.cache.GetNuGetPackage(packageName);
            if (installPackage == null)
            {
                throw new InvalidOperationException(string.Format(
                                                        "Unable to install package '{0}', because no matching package could be found.",
                                                        packageName));
            }

            // Check license terms
            if (!skipLicense && !this.CheckDeepLicenseAgreements(installPackage))
            {
                return;
            }

            Logs.Editor.Write("Installing package '{0}'...", packageName);
            Logs.Editor.PushIndent();
            try
            {
                // Request NuGet to install the package
                this.manager.InstallPackage(installPackage, false, false);
            }
            finally
            {
                Logs.Editor.PopIndent();
            }
        }
Exemplo n.º 6
0
        /// <summary>
        /// Updates the specified package to the latest available version.
        /// </summary>
        /// <param name="packageName"></param>
        public void UpdatePackage(PackageName packageName)
        {
            if (!this.manager.LocalRepository.FindPackagesById(packageName.Id).Any())
            {
                throw new InvalidOperationException(string.Format(
                                                        "Can't update package '{0}', because it is not installed.",
                                                        packageName));
            }

            NuGet.IPackage latestPackage = this.cache.GetNuGetPackage(packageName.VersionInvariant);
            if (latestPackage == null)
            {
                throw new InvalidOperationException(string.Format(
                                                        "Unable to update package '{0}', because no matching package could be found.",
                                                        packageName));
            }

            // Check license terms
            if (!this.CheckDeepLicenseAgreements(latestPackage))
            {
                return;
            }

            Logs.Editor.Write("Updating package '{0}'...", packageName);
            Logs.Editor.PushIndent();
            try
            {
                this.manager.UpdatePackage(latestPackage, true, false);
            }
            finally
            {
                Logs.Editor.PopIndent();
            }
        }
 public void UpdatePackage(NuGet.IPackage newPackage, bool updateDependencies, bool allowPrereleaseVersions)
 {
     if (UpdatePackageCallback != null)
     {
         UpdatePackageCallback(newPackage, updateDependencies, allowPrereleaseVersions);
     }
 }
Exemplo n.º 8
0
        private PackageInfo CreatePackageInfo(NuGet.IPackage package)
        {
            PackageInfo info = new PackageInfo(new PackageName(package.Id, package.Version.Version));

            // Retrieve package data
            info.Title         = package.Title;
            info.Summary       = package.Summary;
            info.Description   = package.Description;
            info.ReleaseNotes  = package.ReleaseNotes;
            info.ProjectUrl    = package.ProjectUrl;
            info.IconUrl       = package.IconUrl;
            info.DownloadCount = package.DownloadCount;
            info.PublishDate   = package.Published.HasValue ? package.Published.Value.DateTime : DateTime.MinValue;
            info.Authors       = package.Authors;
            info.Tags          = package.Tags != null?package.Tags.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries) : Enumerable.Empty <string>();

            // Retrieve the matching set of dependencies. For now, don't support different sets and just pick the first one.
            var matchingDependencySet = package.DependencySets.FirstOrDefault();

            if (matchingDependencySet != null)
            {
                info.Dependencies = matchingDependencySet.Dependencies.Select(d => new PackageName(d.Id, (d.VersionSpec != null && d.VersionSpec.MinVersion != null) ? d.VersionSpec.MinVersion.Version : null));
            }

            return(info);
        }
Exemplo n.º 9
0
        public bool CanUninstallPackage(PackageName packageName)
        {
            NuGet.IPackage uninstallPackage = this.manager.LocalRepository
                                              .FindPackagesById(packageName.Id)
                                              .FirstOrDefault(p => p.Version.Version == packageName.Version);
            if (uninstallPackage == null)
            {
                return(false);
            }

            bool allowed = true;

            this.manager.WhatIf = true;
            this.manager.Logger = null;
            try
            {
                this.manager.UninstallPackage(
                    uninstallPackage,
                    false,
                    true);
            }
            catch (Exception)
            {
                allowed = false;
            }
            this.manager.Logger = this.logger;
            this.manager.WhatIf = false;
            return(allowed);
        }
Exemplo n.º 10
0
        private NuGet.IPackage FindPackageInfo(PackageName packageRef)
        {
            // Find a direct version match
            if (packageRef.Version != null)
            {
                // Query locally first, since we're looking for a specific version number anyway.
                foreach (NuGet.IPackage package in this.manager.LocalRepository.FindPackagesById(packageRef.Id))
                {
                    if (package.Version.Version == packageRef.Version)
                    {
                        return(package);
                    }
                }

                // Nothing found? Query online then.
                try
                {
                    foreach (NuGet.IPackage package in this.GetRepositoryPackages(packageRef.Id))
                    {
                        if (package.Version.Version == packageRef.Version)
                        {
                            return(package);
                        }
                    }
                }
                catch (Exception)
                {
                    return(null);
                }
            }
            // Find the newest available version online
            else
            {
                NuGet.IPackage[] data = null;
                try
                {
                    IEnumerable <NuGet.IPackage> query = this.GetRepositoryPackages(packageRef.Id);
                    data = query.ToArray();
                }
                catch (Exception)
                {
                    return(null);
                }

                var packageQuery = data.Where(p => p.IsListed() && p.IsReleaseVersion());

                NuGet.IPackage newestPackage = packageQuery
                                               .OrderByDescending(p => p.Version.Version)
                                               .FirstOrDefault();

                if (newestPackage != null)
                {
                    return(newestPackage);
                }
            }

            // Nothing was found
            return(null);
        }
Exemplo n.º 11
0
        private Dictionary <string, string> CreateFileMapping(NuGet.IPackage package)
        {
            Dictionary <string, string> fileMapping = new Dictionary <string, string>();

            bool isDualityPackage =
                package.Tags != null &&
                package.Tags.Contains("Duality");
            bool isPluginPackage =
                isDualityPackage &&
                package.Tags.Contains("Plugin");
            string binaryBaseDir  = this.pluginTargetDir;
            string contentBaseDir = this.dataTargetDir;

            if (!isPluginPackage || !isDualityPackage)
            {
                binaryBaseDir = "";
            }

            foreach (var f in package.GetFiles()
                     .Where(f => f.TargetFramework == null || f.TargetFramework.Version < Environment.Version)
                     .OrderByDescending(f => f.TargetFramework == null ? new Version() : f.TargetFramework.Version)
                     .OrderByDescending(f => f.TargetFramework == null))
            {
                // Determine where the file needs to go
                string targetPath = f.EffectivePath;
                string baseDir    = f.Path;
                while (baseDir.Contains(Path.DirectorySeparatorChar) || baseDir.Contains(Path.AltDirectorySeparatorChar))
                {
                    baseDir = Path.GetDirectoryName(baseDir);
                }
                if (string.Equals(baseDir, "lib", StringComparison.InvariantCultureIgnoreCase))
                {
                    targetPath = Path.Combine(binaryBaseDir, targetPath);
                }
                else if (string.Equals(baseDir, "content", StringComparison.InvariantCultureIgnoreCase))
                {
                    targetPath = Path.Combine(contentBaseDir, targetPath);
                }
                else
                {
                    continue;
                }

                // Add a file mapping entry linking target path to package path
                if (fileMapping.ContainsKey(targetPath))
                {
                    continue;
                }
                fileMapping[targetPath] = f.Path;
            }

            return(fileMapping);
        }
Exemplo n.º 12
0
        private void InstallPackage(PackageInfo package, bool skipLicense)
        {
            NuGet.IPackage newPackage = this.FindPackageInfo(package.PackageName);

            // Check license terms
            if (!skipLicense && !this.CheckDeepLicenseAgreements(newPackage))
            {
                return;
            }

            // Request NuGet to install the package
            this.manager.InstallPackage(newPackage, false, false);
        }
Exemplo n.º 13
0
        public void UpdatePackage(LocalPackage package, Version specificVersion = null)
        {
            // Due to a bug in NuGet 2.8.2, specific-version downgrades are limited to the package itself,
            // without updating its dependencies. Otherwise, some of them might be uninstalled without
            // being reinstalled properly.

            this.uninstallQueue = null;
            bool isDowngrade = specificVersion != null && specificVersion < package.Version;

            NuGet.IPackage newPackage = this.FindPackageInfo(new PackageName(package.Id, specificVersion), false);
            this.manager.UpdatePackage(newPackage, !isDowngrade, false);
            this.uninstallQueue = new List <LocalPackage>();
        }
Exemplo n.º 14
0
        public void UpdatePackage(LocalPackage package)
        {
            NuGet.IPackage newPackage = this.FindPackageInfo(new PackageName(package.Id));

            // Check license terms
            if (!this.CheckDeepLicenseAgreements(newPackage))
            {
                return;
            }

            this.uninstallQueue = null;
            this.manager.UpdatePackage(newPackage, true, false);
            this.uninstallQueue = new List <LocalPackage>();
        }
Exemplo n.º 15
0
        private PackageInfo CreatePackageInfo(NuGet.IPackage package)
        {
            PackageInfo info = new PackageInfo(package.Id, package.Version.Version);

            info.Title         = package.Title;
            info.Summary       = package.Summary;
            info.Description   = package.Description;
            info.ProjectUrl    = package.ProjectUrl;
            info.IconUrl       = package.IconUrl;
            info.DownloadCount = package.DownloadCount;
            info.PublishDate   = package.Published.HasValue ? package.Published.Value.DateTime : DateTime.MinValue;
            info.Authors       = package.Authors;
            info.Tags          = package.Tags != null?package.Tags.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries) : Enumerable.Empty <string>();

            return(info);
        }
Exemplo n.º 16
0
 private bool IsUserAvailable(NuGet.IPackage package)
 {
     // Filter unlisted, non-release and special versions
     if (!package.IsReleaseVersion())
     {
         return(false);
     }
     if (!package.IsListed())
     {
         return(false);
     }
     if (package.Version != new SemanticVersion(package.Version.Version))
     {
         return(false);
     }
     return(true);
 }
Exemplo n.º 17
0
        private PackageInfo WrapPackage(NuGet.IPackage package)
        {
            PackageName name = new PackageName(package.Id, package.Version.Version);

            lock (this.cacheLock)
            {
                PackageInfo info;
                if (this.uniquePackageWrap.TryGetValue(name, out info))
                {
                    return(info);
                }

                info = new PackageInfo(package);

                this.uniquePackageWrap.Add(name, info);
                return(info);
            }
        }
Exemplo n.º 18
0
        private bool CheckLicenseAgreement(NuGet.IPackage package)
        {
            if (package.RequireLicenseAcceptance)
            {
                // On the very first install, do not display additional license agreement dialogs
                // because all the packages being installed are the default ones.
                if (this.firstInstall)
                {
                    return(true);
                }

                bool agreed;
                if (!this.licenseAcceptedCache.TryGetValue(package, out agreed) || !agreed)
                {
                    PackageLicenseAgreementEventArgs args = new PackageLicenseAgreementEventArgs(
                        new PackageName(package.Id, package.Version.Version),
                        package.LicenseUrl,
                        package.RequireLicenseAcceptance);

                    if (this.PackageLicenseAcceptRequired != null)
                    {
                        this.PackageLicenseAcceptRequired(this, args);
                    }
                    else
                    {
                        DisplayDefaultLicenseAcceptDialog(args);
                    }

                    agreed = args.IsLicenseAccepted;
                    this.licenseAcceptedCache[package] = agreed;
                }

                if (!agreed)
                {
                    return(false);
                }
            }

            return(true);
        }
Exemplo n.º 19
0
        private bool CheckDeepLicenseAgreements(NuGet.IPackage package)
        {
            var deepDependencyCountDict = this.GetDeepDependencyCount(new[] { this.CreatePackageInfo(package) });

            NuGet.IPackage[] deepPackages = deepDependencyCountDict.Keys.Select(i => this.FindPackageInfo(i.PackageName.VersionInvariant)).ToArray();

            foreach (NuGet.IPackage p in deepPackages)
            {
                // Skip the ones that are already installed
                if (this.manager.LocalRepository.GetPackages().Any(l => l.Id == p.Id && l.Version == p.Version))
                {
                    continue;
                }

                if (!this.CheckLicenseAgreement(p))
                {
                    return(false);
                }
            }

            return(true);
        }
Exemplo n.º 20
0
        private NuGet.IPackage FindPackage(PackageName packageRef)
        {
            try
            {
                // Find a specific version. We're not looking for listed packages only.
                if (packageRef.Version != null)
                {
                    // First try an indexed lookup. This may fail for freshly released packages.
                    foreach (NuGet.IPackage package in this.GetRemotePackages(packageRef.Id))
                    {
                        if (!package.IsReleaseVersion())
                        {
                            continue;
                        }
                        if (package.Version.Version != packageRef.Version)
                        {
                            continue;
                        }
                        return(package);
                    }

                    // If that fails, enumerate all packages and select the one we need.
                    //
                    // Note: Make sure to include OrderByDescending. Without it, non-indexed
                    // packages will not be returned from the query.
                    IQueryable <NuGet.IPackage> query =
                        this.repository.GetPackages()
                        .Where(p => p.Id == packageRef.Id)
                        .OrderByDescending(p => p.Version);
                    foreach (NuGet.IPackage package in query)
                    {
                        if (!package.IsReleaseVersion())
                        {
                            continue;
                        }
                        if (package.Version.Version != packageRef.Version)
                        {
                            continue;
                        }
                        return(package);
                    }

                    // No matching package was found
                    return(null);
                }
                // Find the newest available, listed version online.
                else
                {
                    // Enumerate all package versions - do not rely on an indexed
                    // lookup to get the latest, as the index might not be up-to-date.
                    //
                    // Note: Make sure to include OrderByDescending. Without it, non-indexed
                    // packages will not be returned from the query.
                    IQueryable <NuGet.IPackage> query =
                        this.repository.GetPackages()
                        .Where(p => p.Id == packageRef.Id)
                        .OrderByDescending(p => p.Version);

                    // Note: IQueryable LINQ expressions will actually be transformed into
                    // queries that are executed server-side. Unfortunately for us, the server
                    // will order versions as if they were strings, meaning that 1.0.10 < 1.0.9.
                    // To fix this, we'll have to iterate over them all and find the highest one
                    // manually. We'll still include the OrderByDescending, so we avoid running
                    // into a supposed caching mechanism that doesn't return non-indexed packages
                    // and appears to be active when just filtering by ID.
                    Version        latestVersion = new Version(0, 0);
                    NuGet.IPackage latestPackage = null;
                    foreach (NuGet.IPackage package in query)
                    {
                        if (!this.IsUserAvailable(package))
                        {
                            continue;
                        }
                        if (package.Version.Version > latestVersion)
                        {
                            latestVersion = package.Version.Version;
                            latestPackage = package;
                        }
                    }
                    return(latestPackage);
                }
            }
            catch (Exception e)
            {
                Log.Editor.WriteWarning("Error querying NuGet package repository: {0}", Log.Exception(e));
                return(null);
            }
        }
Exemplo n.º 21
0
 private PackageInfo QueryPackageInfo(PackageName packageRef, bool findMaxVersionBelow)
 {
     NuGet.IPackage package = this.FindPackageInfo(packageRef, findMaxVersionBelow);
     return(package != null?this.CreatePackageInfo(package) : null);
 }
Exemplo n.º 22
0
 public void InstallPackage(PackageInfo package)
 {
     // Request NuGet to install the package
     NuGet.IPackage newPackage = this.FindPackageInfo(package.PackageName, false);
     this.manager.InstallPackage(newPackage, false, false);
 }
 protected override bool IsProjectPackage(NuGet.IPackage package)
 {
     IsProjectPackageIsCalled = true;
     return(IsProjectPackageReturnsValue);
 }
Exemplo n.º 24
0
 public PackageInfo QueryPackageInfo(PackageName packageRef)
 {
     NuGet.IPackage package = this.FindPackageInfo(packageRef);
     return(package != null?this.CreatePackageInfo(package) : null);
 }
Exemplo n.º 25
0
 private static bool IsDualityPackage(NuGet.IPackage package)
 {
     return
         (package.Tags != null &&
          package.Tags.Contains(DualityTag));
 }
Exemplo n.º 26
0
        private void UninstallPackage(PackageName packageName, bool force)
        {
            Logs.Editor.Write("Uninstalling package '{0}'...", packageName);
            Logs.Editor.PushIndent();
            try
            {
                // Find the local package that we'll uninstall
                NuGet.IPackage uninstallPackage = this.manager.LocalRepository
                                                  .FindPackagesById(packageName.Id)
                                                  .FirstOrDefault(p => p.Version.Version == packageName.Version);
                if (uninstallPackage == null)
                {
                    return;
                }

                // Find all dependencies of the package we want to uninstall
                PackageName        uninstallPackageName  = new PackageName(uninstallPackage.Id, uninstallPackage.Version.Version);
                PackageInfo        uninstallPackageInfo  = this.GetPackage(uninstallPackageName);
                List <PackageInfo> uninstallDependencies = new List <PackageInfo>();
                if (uninstallPackageInfo != null)
                {
                    this.dependencyWalker.Clear();
                    this.dependencyWalker.WalkGraph(uninstallPackageInfo);
                    uninstallDependencies.AddRange(this.dependencyWalker.VisitedPackages);
                    uninstallDependencies.RemoveAll(package => package.Id == uninstallPackageInfo.Id);
                }

                // Filter out all dependencies that are used by other Duality packages
                foreach (LocalPackage otherPackage in this.LocalSetup.Packages)
                {
                    if (otherPackage.Id == uninstallPackage.Id)
                    {
                        continue;
                    }

                    PackageInfo otherPackageInfo = otherPackage.Info ?? this.GetPackage(otherPackage.Name);
                    if (otherPackageInfo == null)
                    {
                        continue;
                    }

                    this.dependencyWalker.Clear();
                    this.dependencyWalker.IgnorePackage(uninstallPackage.Id);
                    this.dependencyWalker.WalkGraph(otherPackageInfo);
                    foreach (PackageInfo dependency in this.dependencyWalker.VisitedPackages)
                    {
                        // Don't check versions, as dependencies are usually not resolved
                        // with an exact version match.
                        uninstallDependencies.RemoveAll(item => item.Id == dependency.Id);
                    }
                }

                // Uninstall the package itself
                this.manager.UninstallPackage(
                    uninstallPackage,
                    force);

                // Uninstall its dependencies that are no longer used, in reverse dependency order
                // to avoid stumbling over dependencies that they might have between each other.
                this.OrderByDependencies(uninstallDependencies);
                uninstallDependencies.Reverse();
                foreach (PackageInfo package in uninstallDependencies)
                {
                    List <NuGet.IPackage> matchingNuGetPackages = this.manager.LocalRepository
                                                                  .FindPackagesById(package.Id)
                                                                  .ToList();

                    foreach (NuGet.IPackage nugetPackage in matchingNuGetPackages)
                    {
                        this.manager.UninstallPackage(nugetPackage, force, false);
                    }
                }
            }
            finally
            {
                Logs.Editor.PopIndent();
            }
        }
Exemplo n.º 27
0
        private Dictionary <string, string> CreateFileMapping(NuGet.IPackage package)
        {
            Dictionary <string, string> fileMapping = new Dictionary <string, string>();

            bool isDualityPackage = IsDualityPackage(package);
            bool isPluginPackage  = isDualityPackage && package.Tags.Contains(PluginTag);

            string folderFriendlyPackageName = package.Id;
            string binaryBaseDir             = this.env.TargetPluginPath;
            string contentBaseDir            = this.env.TargetDataPath;
            string sourceBaseDir             = Path.Combine(this.env.TargetSourcePath, folderFriendlyPackageName);

            if (!isPluginPackage || !isDualityPackage)
            {
                binaryBaseDir  = this.env.RootPath;
                contentBaseDir = this.env.RootPath;
            }

            IPackageFile[] packageFiles;
            try
            {
                packageFiles = package.GetFiles()
                               .Where(f => f.TargetFramework == null || f.TargetFramework.Version < Environment.Version)
                               .OrderByDescending(f => f.TargetFramework == null ? new Version() : f.TargetFramework.Version)
                               .OrderByDescending(f => f.TargetFramework == null)
                               .ToArray();
            }
            catch (DirectoryNotFoundException)
            {
                // We'll run into this exception when uninstalling a package without any files.
                return(fileMapping);
            }

            foreach (IPackageFile f in packageFiles)
            {
                // Determine where the file needs to go
                string targetPath = f.EffectivePath;
                string baseDir    = f.Path;
                while (baseDir.Contains(Path.DirectorySeparatorChar) || baseDir.Contains(Path.AltDirectorySeparatorChar))
                {
                    baseDir = Path.GetDirectoryName(baseDir);
                }
                if (string.Equals(baseDir, "lib", StringComparison.InvariantCultureIgnoreCase))
                {
                    targetPath = Path.Combine(binaryBaseDir, targetPath);
                }
                else if (string.Equals(baseDir, "content", StringComparison.InvariantCultureIgnoreCase))
                {
                    targetPath = Path.Combine(contentBaseDir, targetPath);
                }
                else if (string.Equals(baseDir, "source", StringComparison.InvariantCultureIgnoreCase))
                {
                    if (targetPath.StartsWith("source") && targetPath.Length > "source".Length)
                    {
                        targetPath = targetPath.Remove(0, "source".Length + 1);
                    }
                    targetPath = Path.Combine(sourceBaseDir, targetPath);
                }
                else
                {
                    continue;
                }

                // Add a file mapping entry linking target path to package path
                if (fileMapping.ContainsKey(targetPath))
                {
                    continue;
                }
                fileMapping[targetPath] = f.Path;
            }

            return(fileMapping);
        }
Exemplo n.º 28
0
 public PackageInfo QueryPackageInfo(string packageId, Version packageVersion = null)
 {
     NuGet.IPackage package = this.FindPackageInfo(packageId, packageVersion);
     return(package != null?this.CreatePackageInfo(package) : null);
 }
Exemplo n.º 29
0
 public NuGetPackage(Log log, IPackageRepository repo, NuGet.IPackage package)
     : base(log)
 {
     _repo    = repo;
     _package = package;
 }
Exemplo n.º 30
0
        private NuGet.IPackage FindPackage(PackageName packageRef)
        {
            try
            {
                // Find a specific version. We're not looking for listed packages only.
                if (packageRef.Version != null)
                {
                    // First try an indexed lookup. This may fail for freshly released packages.
                    foreach (NuGet.IPackage package in this.GetRemotePackages(packageRef.Id))
                    {
                        if (!package.IsReleaseVersion())
                        {
                            continue;
                        }
                        if (package.Version.Version != packageRef.Version)
                        {
                            continue;
                        }
                        return(package);
                    }

                    // If that fails, enumerate all packages and select the one we need.
                    //
                    // Note: Make sure to include OrderByDescending. Without it, non-indexed
                    // packages will not be returned from the query.
                    IQueryable <NuGet.IPackage> query =
                        this.repository.GetPackages()
                        .Where(p => p.Id == packageRef.Id)
                        .OrderByDescending(p => p.Version);
                    foreach (NuGet.IPackage package in query)
                    {
                        if (!package.IsReleaseVersion())
                        {
                            continue;
                        }
                        if (package.Version.Version != packageRef.Version)
                        {
                            continue;
                        }
                        return(package);
                    }

                    // No matching package was found
                    return(null);
                }
                // Find the newest available, listed version online.
                else
                {
                    // Do an indexed lookup. This may fail for freshly released packages,
                    // but turns out to be more robust otherwise. Our previous approach
                    // of querying non-indexed NuGet API via search sometimes failed with
                    // the server returning no results on the n-th query.
                    Version        latestVersion = new Version(0, 0);
                    NuGet.IPackage latestPackage = null;
                    foreach (NuGet.IPackage package in this.GetRemotePackages(packageRef.Id))
                    {
                        if (!this.IsUserAvailable(package))
                        {
                            continue;
                        }
                        if (package.Version.Version > latestVersion)
                        {
                            latestVersion = package.Version.Version;
                            latestPackage = package;
                        }
                    }
                    return(latestPackage);
                }
            }
            catch (Exception e)
            {
                Logs.Editor.WriteWarning("Error querying NuGet package repository: {0}", LogFormat.Exception(e));
                return(null);
            }
        }