private IEnumerable<ITaskItem> ResolvePackage(ITaskItem package) { string id = package.ItemSpec; string version = package.GetMetadata("Version"); Log.LogMessage(MessageImportance.Normal, "Resolving Package Reference {0} {1}...", id, version); // Initial version just searches a machine-level repository var localFs = new PhysicalFileSystem(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "NuGet", "Lib")); var defaultResolver = new DefaultPackagePathResolver(localFs); var machineRepo = new LocalPackageRepository(defaultResolver, localFs); var buildRepo = new BuildPackageRepository(); var remoteRepo = new DataServicePackageRepository(new Uri("https://nuget.org/api/v2")); var project = new BuildProjectSystem(ProjectDirectory, new FrameworkName(TargetFramework), CurrentReferences); var manager = new PackageManager(remoteRepo, defaultResolver, localFs, machineRepo); var projectManager = new ProjectManager(remoteRepo, defaultResolver, project, buildRepo); // Install the package var ver = new SemanticVersion(version); manager.PackageInstalling += manager_PackageInstalling; manager.InstallPackage(id, ver); projectManager.AddPackageReference(id, ver); return project.OutputReferences.Select(item => { var name = AssemblyName.GetAssemblyName(item); return new TaskItem(name.FullName, new Dictionary<string, string>() { {"HintPath", item }, {"Private", "true"} }); }); }
public override async Task <Stream> GetStream(PackageIdentity identity, CancellationToken token) { Stream result = null; IPackage package = null; SemanticVersion version = SemanticVersion.Parse(identity.Version.ToString()); // attempt a normal lookup first if (!V2Client.TryFindPackage(identity.Id, version, out package)) { // skip further look ups for online repos DataServicePackageRepository v2Online = V2Client as DataServicePackageRepository; if (v2Online == null) { IVersionComparer versionComparer = VersionComparer.VersionRelease; // otherwise search further to find the package - this is needed for v2 non-normalized versions V2Client.FindPackagesById(identity.Id).Any(p => versionComparer.Equals(identity.Version, NuGetVersion.Parse(p.ToString()))); } } if (package != null) { result = package.GetStream(); } return(result); }
public async Task Test() { await luceneRepository.AddPackageAsync(LoadSamplePackage("Package", "1.0.0"), CancellationToken.None); var repo = new DataServicePackageRepository(new Uri(ServerUrl + "api/odata/")); var results = repo.Search("", new string[0], allowPrereleaseVersions: false).ToList(); Assert.That(results.Count, Is.EqualTo(1)); }
public void ShowsVersionsFromMirror() { var repo = new DataServicePackageRepository(new Uri(ServerUrl + "api/odata/")); var result = repo.FindPackagesById("Nuget.Core"); Assert.That(result.Count(), Is.GreaterThan(1), "Should look in mirror for packages."); }
public async Task Test() { await luceneRepository.AddPackageAsync(LoadSamplePackage("Package", "1.0.0"), CancellationToken.None); var repo = new DataServicePackageRepository(new Uri(ServerUrl + "api/odata/")); var results = repo.Search("", new string[0], allowPrereleaseVersions: false).ToList(); Assert.That(results.Count, Is.EqualTo(1)); }
public void FindPackageMirrors() { var repo = new DataServicePackageRepository(new Uri(ServerUrl + "api/odata/")); var result = repo.FindPackage("Nuget.Core", new SemanticVersion("2.8.1")); Assert.That(result, Is.Not.Null, "Should mirror package from origin."); Assert.That(luceneRepository.LucenePackages.Count(), Is.EqualTo(1)); }
static void Main(string [] args) { var options = new CliOptions(); if (CommandLine.Parser.Default.ParseArguments(args, options)) { // consume Options instance properties if (options.Verbose) { Console.WriteLine(options.Repository); Console.WriteLine(options.LocalDir); Console.WriteLine(options.MaxConcurrentDownloads); } else { Console.WriteLine("working ..."); } } else { // Display the default usage information Console.WriteLine(options.GetUsage()); return; } //Connect to the official package repository var repo = new DataServicePackageRepository(new Uri(options.Repository)); //Get the list of all NuGet packages var skip = 0; var packages = new BlockingCollection <DataServicePackage>(5); var packageDownloaders = new Task[options.MaxConcurrentDownloads]; for (int i = 0; i < options.MaxConcurrentDownloads; i++) { packageDownloaders[i] = Task.Run(() => RunPackageDownloader(packages, options.LocalDir)); } // reading list of packages and add it to collection for (;;) { var packagesList = repo.GetPackages().Skip(skip).Take(10).ToList(); if (packagesList.Count() == 0) { packages.CompleteAdding(); break; } foreach (DataServicePackage p in packagesList) { packages.Add(p); } skip += 10; } }
public void Setup() { var mfs = new Mock<MockFileSystem>() { CallBase = true }; var pr = new DefaultPackagePathResolver(mfs.Object); var mc = MachineCache.Default; var l = new LocalPackageRepository(pr, mfs.Object); var r1 = new DataServicePackageRepository(new Uri(@"http://nuget.org")); var r2 = new DataServicePackageRepository(new Uri(@"http://beta.nuget.org")); ar = new AggregateRepository(new List<IPackageRepository>() { mc, l, r1, r2 }); }
private IPackageRepository GetRepository() { var repository = V2Client as DataServicePackageRepository; if (repository != null) { var sourceUri = UriUtility.CreateSourceUri(repository.Source); repository = new DataServicePackageRepository(sourceUri); } // If the repository is not a DataServicePackageRepository just return the current one. return(repository ?? V2Client); }
public WebProjectManager(string remoteSource, string siteRoot) { string webRepositoryDirectory = GetWebRepositoryDirectory(siteRoot); Uri uri = new Uri(remoteSource); IPackageRepository repository = new DataServicePackageRepository(uri); //PackageRepositoryFactory.Default.CreateRepository(remoteSource); IPackagePathResolver resolver = new DefaultPackagePathResolver(webRepositoryDirectory); IPackageRepository repository2 = new LocalPackageRepository(webRepositoryDirectory, false); //PackageRepositoryFactory.Default.CreateRepository(webRepositoryDirectory); IProjectSystem system = new WebProjectSystem(siteRoot); ((DataServicePackageRepository)repository).ProgressAvailable += new EventHandler <ProgressEventArgs>(repository_ProgressAvailable); //((DataServicePackageRepository)repository).SendingRequest += new EventHandler<WebRequestEventArgs>(repository_sendingRequest); this._projectManager = new ProjectManager(repository, resolver, system, repository2); _projectManager.Logger = new LoggerController(); }
private DownloadResourceResult DownloadFromUrl( SourcePackageDependencyInfo package, DataServicePackageRepository repository, NuGet.Common.ILogger logger, CancellationToken token) { IPackage newPackage = null; var version = SemanticVersion.Parse(package.Version.ToString()); var cacheRepository = MachineCache.Default; try { // Try finding the package in the machine cache var localPackage = cacheRepository.FindPackage(package.Id, version) as OptimizedZipPackage; // Validate the package matches the hash if (localPackage != null && localPackage.IsValid && MatchPackageHash(localPackage, package.PackageHash)) { newPackage = localPackage; } } catch { // Ignore cache failures here to match NuGet.Core // The bad package will be deleted and replaced during the download. } // If the local package does not exist in the cache download it from the source if (newPackage == null) { newPackage = DownloadToMachineCache( cacheRepository, package, repository, package.DownloadUri, logger, token); } // Read the package from the machine cache if (newPackage != null) { return(new DownloadResourceResult(newPackage.GetStream())); } return(null); }
private DataServicePackageRepository GetPackageRepository() { if (_packageRepository == null || _packageRepository.Source != _redirectedlPackageSource) { try { Uri packageUri = new Uri(PackageSource); IWebProxy packageSourceProxy = _proxyService.GetProxy(packageUri); IHttpClient packageSourceClient = new RedirectedHttpClient(packageUri, packageSourceProxy); _packageRepository = new DataServicePackageRepository(packageSourceClient); _redirectedlPackageSource = _packageRepository.Source; } catch (Exception) { _packageRepository = null; } } return(_packageRepository); }
public void Setup() { var mfs = new Mock <MockFileSystem>() { CallBase = true }; var pr = new DefaultPackagePathResolver(mfs.Object); var mc = MachineCache.Default; var l = new LocalPackageRepository(pr, mfs.Object); var r1 = new DataServicePackageRepository(new Uri(@"http://nuget.org")); var r2 = new DataServicePackageRepository(new Uri(@"http://beta.nuget.org")); ar = new AggregateRepository(new List <IPackageRepository>() { mc, l, r1, r2 }); }
public void RunFromGallery() { Directory.CreateDirectory(_targetDirectory); var client = new HttpClient(DeveloperFeed); client.SendingRequest += (sender, e) => { e.Request.Credentials = _credentials; e.Request.PreAuthenticate = true; }; var remoteRepo = new DataServicePackageRepository(client); var targetRepo = new LocalPackageRepository(_targetDirectory); var packages = remoteRepo.GetPackages() .Where(p => p.IsAbsoluteLatestVersion) .ToList(); Parallel.ForEach(packages, new ParallelOptions { MaxDegreeOfParallelism = 4 }, package => { // Some packages are updated without revving the version. We'll only opt not to re-download // a package if an identical version does not exist on disk. var existingPackage = targetRepo.FindPackage(package.Id, package.Version); var dataServicePackage = (DataServicePackage)package; if (existingPackage == null || !existingPackage.GetHash(dataServicePackage.PackageHashAlgorithm).Equals(dataServicePackage.PackageHash, StringComparison.Ordinal)) { Trace.WriteLine(string.Format("{0}: Adding package {1}", DateTime.Now, package.GetFullName())); var packagePath = GetPackagePath(package); using (var input = package.GetStream()) using (var output = File.Create(packagePath)) { input.CopyTo(output); } PurgeOldVersions(targetRepo, package); } }); }
public static DataServicePackageRepository CreateDataServicePackageRepository(IHttpClient httpClient, TimeSpan timeout) { var userAgent = string.Format("{0}/{1} ({2})", UserAgent, typeof (MirroringPackageRepositoryFactory).Assembly.GetName().Version, Environment.OSVersion); var remoteRepository = new DataServicePackageRepository(httpClient); remoteRepository.SendingRequest += (s, e) => { e.Request.Timeout = (int) timeout.TotalMilliseconds; ((HttpWebRequest) e.Request).UserAgent = userAgent; e.Request.Headers.Add(RepositoryOperationNames.OperationHeaderName, RepositoryOperationNames.Mirror); }; return remoteRepository; }
public static DataServicePackageRepository CreateDataServicePackageRepository(IHttpClient httpClient, TimeSpan timeout) { var userAgent = string.Format("{0}/{1} ({2})", UserAgent, typeof(MirroringPackageRepositoryFactory).Assembly.GetName().Version, Environment.OSVersion); var remoteRepository = new DataServicePackageRepository(httpClient); remoteRepository.SendingRequest += (s, e) => { e.Request.Timeout = (int)timeout.TotalMilliseconds; ((HttpWebRequest)e.Request).UserAgent = userAgent; e.Request.Headers.Add(RepositoryOperationNames.OperationHeaderName, RepositoryOperationNames.Mirror); }; return(remoteRepository); }
private static void Latest() { var orchard = new DataServicePackageRepository(new Uri("http://packages.orchardproject.net/FeedService.svc")); var nuget = new DataServicePackageRepository(new Uri("https://nuget.org/api/v2")); var symbolsource = new DataServicePackageRepository(new Uri("http://nuget.gw.symbolsource.org/Public/Orchard/FeedService.mvc")); var cache = Directory.GetCurrentDirectory(); var solution = new ProjectCollection(); var logger = new ConsoleLogger(); foreach (var d in Directory.EnumerateDirectories(Path.Combine(cache, "aa", "Content", "Modules"))) { var project = solution.LoadProject(Path.Combine(d, Path.GetFileName(d) + ".csproj")); project.RemoveItem( project.Items.Where(i => i.ItemType == "ProjectReference" && i.GetMetadataValue("Name") == "Orchard.Core"). Single()); project.RemoveItem( project.Items.Where( i => i.ItemType == "ProjectReference" && i.GetMetadataValue("Name") == "Orchard.Framework").Single()); project.AddItem("Reference", "Orchard.Core", new[] { new KeyValuePair <string, string>("HintPath", @"C:\Users\marcin.mikolajczak\Downloads\Temp\Orchard.Core.dll") }); project.AddItem("Reference", "Orchard.Framework", new[] { new KeyValuePair <string, string>("HintPath", @"C:\Users\marcin.mikolajczak\Downloads\Temp\Orchard.Framework.dll") }); } foreach (var project in solution.LoadedProjects) { project.Build(logger); } }
private IPackage DownloadToMachineCache( IPackageCacheRepository cacheRepository, PackageIdentity package, DataServicePackageRepository repository, Uri downloadUri, NuGet.Common.ILogger logger, CancellationToken token) { var packageName = new PackageNameWrapper(package); var version = SemanticVersion.Parse(package.Version.ToString()); IPackage newPackage = null; FileInfo tmpFile = null; FileStream tmpFileStream = null; // Create a v2 http client var downloadClient = new HttpClient(downloadUri) { UserAgent = UserAgent.UserAgentString }; EventHandler <ProgressEventArgs> progressHandler = (sender, progress) => { // Throw if this was canceled. This will stop the download. token.ThrowIfCancellationRequested(); }; Exception downloadException = null; Action <Stream> downloadAction = (stream) => { try { repository.PackageDownloader.ProgressAvailable += progressHandler; repository.PackageDownloader.DownloadPackage(downloadClient, packageName, stream); } catch (Exception ex) when(ex is OperationCanceledException || ex is IOException && ex.InnerException is SocketException) { // The task was canceled. To avoid writing a partial file to the machine cache // we need to clear out the current tmp file stream so that it will be ignored. stream.SetLength(0); // If the machine cache is using the physical file system we can find the // path of temp file and clean it up. Otherwise NuGet.Core will just leave the temp file. tmpFileStream = stream as FileStream; if (tmpFileStream != null) { tmpFile = new FileInfo(tmpFileStream.Name); } downloadException = ex; } catch (Exception ex) { downloadException = ex; } finally { repository.PackageDownloader.ProgressAvailable -= progressHandler; } }; // We either do not have a package available locally or they are invalid. // Download the package from the server. if (cacheRepository.InvokeOnPackage(package.Id, version, (stream) => downloadAction(stream))) { if (!token.IsCancellationRequested) { newPackage = cacheRepository.FindPackage(package.Id, version); Debug.Assert(newPackage != null); } } // After the stream is no longer in use, delete the tmp file // NuGet.Core does not properly clean these up since it does not have cancel support. if (tmpFile != null && token.IsCancellationRequested && tmpFile.Exists) { try { tmpFile.Delete(); } catch { // Ignore exceptions for tmp file clean up } } if (downloadException != null) { throw downloadException; } return(newPackage); }
private DownloadResourceResult DownloadFromIdentity( PackageIdentity identity, IPackageRepository repository, NuGet.Common.ILogger logger, CancellationToken token) { var version = SemanticVersion.Parse(identity.Version.ToString()); var dataServiceRepo = repository as DataServicePackageRepository; if (dataServiceRepo != null) { // Clone the repo to allow for concurrent calls var sourceUri = UriUtility.CreateSourceUri(dataServiceRepo.Source); dataServiceRepo = new DataServicePackageRepository(sourceUri); var package = dataServiceRepo.FindPackage(identity.Id, version); var dataServicePackage = package as DataServicePackage; if (dataServicePackage != null) { token.ThrowIfCancellationRequested(); // For online sources get the url and retrieve it with cancel support var url = dataServicePackage.DownloadUrl; var downloadedPackage = DownloadToMachineCache( MachineCache.Default, identity, dataServiceRepo, url, logger, token); if (downloadedPackage != null) { return(new DownloadResourceResult(downloadedPackage.GetStream())); } } } else { var package = repository.FindPackage(identity.Id, version); if (package != null) { // Use a folder reader for unzipped repos if (repository is UnzippedPackageRepository) { var packagePath = Path.Combine(repository.Source, identity.Id + "." + version); var directoryInfo = new DirectoryInfo(packagePath); if (directoryInfo.Exists) { return(new DownloadResourceResult( package.GetStream(), new PackageFolderReader(directoryInfo))); } } return(new DownloadResourceResult(package.GetStream())); } } return(new DownloadResourceResult(DownloadResourceResultStatus.NotFound)); }
public Protocol2TestClient(Uri serverUri, string feed) : base(serverUri, feed) { packageServer = new PackageServer(uri.ToString(), ""); packageRepository = new DataServicePackageRepository(uri); }
/// <summary> /// </summary> private int Run(Assembly integrationAgentAssembly, string integrationAgentExeFileName, string integrationAgentExeDirectory, string[] args) { var parameters = Program.ParseArguments(args); var fileVersion = FileVersionInfo.GetVersionInfo(integrationAgentAssembly.Location).FileVersion; if (parameters.ShowVersion || parameters.ShowHelp) { Console.WriteLine("IntegrationAgent v" + fileVersion); } if (parameters.ShowHelp) { Program.ShowHelp(); } if (parameters.ShowVersion || parameters.ShowHelp) { return(0); } // Verify that assembly is signed and uses the correct key var traceWriter = Program.CreateTraceWriter(parameters.TraceLevel); traceWriter(TraceLevel.Verbose, "Checking assembly strong name."); if (!integrationAgentAssembly.HasValidStrongName()) { traceWriter(TraceLevel.Error, "Unsigned assembly!"); return(1); } traceWriter(TraceLevel.Verbose, "Verifying assembly signature."); if (!integrationAgentAssembly.PublicKeyTokenEqualsTo(Token.Bytes)) { traceWriter(TraceLevel.Error, "Invalid assembly!"); return(2); } // If no JSON config file name provided as paramter uses the application name traceWriter(TraceLevel.Verbose, "Looking for JSON config file."); var configFile = Path.Combine(integrationAgentExeDirectory, Path.GetFileNameWithoutExtension(integrationAgentExeFileName) + ".json"); if (!string.IsNullOrEmpty(parameters.Config)) { if (!parameters.Config.EndsWith(".json")) { parameters.Config = parameters.Config + ".json"; } configFile = Path.Combine(integrationAgentExeDirectory, parameters.Config); } // Check and reads the configuration file var configuration = new Configuration(); if (File.Exists(configFile)) { traceWriter(TraceLevel.Verbose, "Reading the JSON config file."); var configJson = File.ReadAllText(configFile); var jsonSerializer = new JavaScriptSerializer(); configuration = jsonSerializer.Deserialize <Configuration>(configJson) ?? configuration; traceWriter(TraceLevel.Verbose, "JSON config file loaded."); } // Merges config file and command line parameters. Command line paramters have precedence. configuration.package = parameters.Package ?? configuration.package; configuration.token = parameters.Token ?? configuration.token; configuration.repository = parameters.Repository ?? configuration.repository; configuration.repositoryUsername = parameters.RepositoryUsername ?? configuration.repositoryUsername; configuration.repositoryPassword = parameters.RepositoryPassword ?? configuration.repositoryPassword; traceWriter(TraceLevel.Verbose, "Checking input parameters."); if (string.IsNullOrWhiteSpace(configuration.package) && string.IsNullOrEmpty(configuration.token)) { traceWriter(TraceLevel.Error, "Invalid configuration!"); return(3); } // Initializes NuGet repositories traceWriter(TraceLevel.Verbose, "Initializing NuGet repositories."); var nugetRepository = new DataServicePackageRepository(new Uri(NuGetRepository)); var aggregateRepository = new AggregateRepository(new[] { nugetRepository }); if (Uri.IsWellFormedUriString(configuration.repository, UriKind.Absolute)) { if (!string.IsNullOrWhiteSpace(configuration.repositoryUsername) && !string.IsNullOrWhiteSpace(configuration.repositoryPassword)) { HttpClient.DefaultCredentialProvider = new NugetCredentialProvider( configuration.repositoryUsername, configuration.repositoryPassword); } var client = new HttpClient(new Uri(configuration.repository)); var customRepository = new DataServicePackageRepository(client); aggregateRepository = new AggregateRepository(new[] { customRepository, nugetRepository }); } // Perform auto-update if not disabled if (!parameters.DisableUpdates) { traceWriter(TraceLevel.Verbose, "Checking for self update."); var integrationAgentAssemblyName = integrationAgentAssembly.GetName(); var version = new SemanticVersion(integrationAgentAssemblyName.Version); var package = aggregateRepository .GetUpdates(new[] { new PackageName(integrationAgentAssemblyName.Name, version) }, includePrerelease: false, includeAllVersions: false) .OrderBy(p => p.Version) .LastOrDefault(); if (package != null && package.Version > version) { traceWriter(TraceLevel.Verbose, "Newer version found. Updating files."); var filename = Path.GetFileName(integrationAgentExeFileName); var file = package.GetFiles().FirstOrDefault(f => !string.IsNullOrEmpty(f.Path) && Path.GetFileName(f.Path).Equals(filename, StringComparison.OrdinalIgnoreCase)); if (file != null) { File.Delete(integrationAgentExeFileName + ".bak"); File.Move(integrationAgentExeFileName, integrationAgentExeFileName + ".bak"); using (Stream fromStream = file.GetStream(), toStream = File.Create(integrationAgentExeFileName)) { fromStream.CopyTo(toStream); } Process.Start(integrationAgentExeFileName, string.Join(" ", args) + " -disableupdates"); Environment.Exit(0); } } else { traceWriter(TraceLevel.Verbose, "Version is up to date."); } } // Install the package to run including its dependencies traceWriter(TraceLevel.Verbose, "Checking for execution package."); var packagesPath = Path.Combine(integrationAgentExeDirectory, "packages"); var remotePackage = aggregateRepository.FindPackagesById(configuration.package).OrderBy(p => p.Version).LastOrDefault(); var localRepository = new SharedPackageRepository(packagesPath); if (!localRepository.Exists(remotePackage)) { traceWriter(TraceLevel.Verbose, "Execution package not found localy. Installing remote."); var packageManager = new PackageManager(aggregateRepository, packagesPath); packageManager.InstallPackage(remotePackage, ignoreDependencies: false, allowPrereleaseVersions: false); } var localPackage = localRepository.FindPackagesById(configuration.package).OrderBy(p => p.Version).LastOrDefault(); if (localPackage == null) { traceWriter(TraceLevel.Error, "Package not found!"); return(4); } // Build a dictionary list of assemblies based on assembly fully qualified name for dynamically resolving from the loaded package traceWriter(TraceLevel.Verbose, "Resolving execution package dependencies."); var allAssemblies = localRepository .GetPackages() .ToArray() .SelectMany(p => p.AssemblyReferences.Select(a => { var path = Path.Combine(packagesPath, p.Id + "." + p.Version, a.Path); var aname = AssemblyName.GetAssemblyName(path); return(new { key = aname.FullName, value = path }); })) .DistinctBy(i => i.key) .ToDictionary(i => i.key, i => i.value); AppDomain.CurrentDomain.AssemblyResolve += (sender, eventArgs) => { var aname = new AssemblyName(eventArgs.Name); if (allAssemblies.ContainsKey(aname.FullName)) { return(Assembly.LoadFile(allAssemblies[aname.FullName])); } return(null); }; // Run the package export delegate if found var assemblies = localPackage.AssemblyReferences.Select(a => new AssemblyCatalog(Path.Combine(packagesPath, localPackage.Id + "." + localPackage.Version, a.Path))); using (var catalog = new AggregateCatalog(assemblies)) using (var container = new CompositionContainer(catalog)) { traceWriter(TraceLevel.Verbose, "Resolving execution package entry point."); container.SatisfyImportsOnce(this); if (this.RunAssembly == null) { traceWriter(TraceLevel.Error, "Execution package extry point not found!"); return(5); } traceWriter(TraceLevel.Verbose, "Invoking execution package extry point."); this.RunAssembly(configuration.token, traceWriter); traceWriter(TraceLevel.Verbose, "Execution package finished successfully."); return(0); } }
private void LoadPackages() { StatusContent = "Connecting to package source..."; TaskScheduler uiScheduler = TaskScheduler.FromCurrentSynchronizationContext(); Task.Factory.StartNew <DataServicePackageRepository>(GetPackageRepository).ContinueWith( task => { DataServicePackageRepository repository = task.Result; if (repository == null) { StatusContent = String.Empty; ClearPackages(); return; } var query = repository.GetPackages(); if (!String.IsNullOrEmpty(_currentSearch)) { query = query.Find(_currentSearch.Split(' ')); } switch (SortColumn) { case "Id": query = SortDirection == ListSortDirection.Descending ? query.OrderByDescending(p => p.Id) : query.OrderBy(p => p.Id); break; case "Authors": query = SortDirection == ListSortDirection.Descending ? query.OrderByDescending(p => p.Authors) : query.OrderBy(p => p.Authors); break; case "VersionDownloadCount": query = SortDirection == ListSortDirection.Descending ? query.OrderByDescending(p => p.VersionDownloadCount) : query.OrderBy(p => p.VersionDownloadCount); break; case "Rating": query = SortDirection == ListSortDirection.Descending ? query.OrderByDescending(p => p.VersionRating) : query.OrderBy(p => p.VersionRating); break; default: query = query.OrderByDescending(p => p.VersionDownloadCount); break; } _currentQuery = query.Select(p => new PackageInfo { Id = p.Id, Version = p.Version, Authors = p.Authors, VersionRating = p.VersionRating, VersionDownloadCount = p.VersionDownloadCount, PackageHash = p.PackageHash }); // every time the search query changes, we reset to page 0 LoadPage(0); }, CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion, uiScheduler ); }