public async Task <PackageSearchResponse> Handle(PackageSearchRequest request)
        {
            var projectPath = request.ProjectPath;

            if (request.ProjectPath.EndsWith(".json"))
            {
                projectPath = Path.GetDirectoryName(projectPath);
            }

            if (!string.IsNullOrWhiteSpace(projectPath))
            {
                if (request.SupportedFrameworks == null)
                {
                    request.SupportedFrameworks = Enumerable.Empty <string>();
                }

                if (request.PackageTypes == null)
                {
                    request.PackageTypes = Enumerable.Empty <string>();
                }

                if (request.Sources == null)
                {
                    request.Sources = Enumerable.Empty <string>();
                }

                var token  = CancellationToken.None;
                var filter = new SearchFilter()
                {
                    SupportedFrameworks = request.SupportedFrameworks,
                    IncludePrerelease   = request.IncludePrerelease,
                    PackageTypes        = request.PackageTypes
                };
                var tasks = new List <Task <IEnumerable <SimpleSearchMetadata> > >();
                var repositoryProvider = new OmniSharpSourceRepositoryProvider(projectPath);
                var repos = repositoryProvider.GetRepositories().ToArray();
                if (request.Sources.Any())
                {
                    // Reduce to just the sources we requested
                    repos = repos.Join(request.Sources, x => x.PackageSource.Source, x => x, (x, y) => x).ToArray();
                }

                foreach (var repo in repos)
                {
                    var resource = await repo.GetResourceAsync <SimpleSearchResource>();

                    if (resource != null)
                    {
                        tasks.Add(resource.Search(request.Search, filter, 0, 50, token));
                    }
                }

                var results = await Task.WhenAll(tasks);

                return(MergeResults(results, repos));
            }

            return(new PackageSearchResponse());
        }
        public Task <PackageSourceResponse> Handle(PackageSourceRequest request)
        {
            var projectPath = request.ProjectPath;

            if (request.ProjectPath.EndsWith(".json"))
            {
                projectPath = Path.GetDirectoryName(projectPath);
            }

            if (!string.IsNullOrWhiteSpace(projectPath))
            {
                var tasks = new List <Task <IEnumerable <SimpleSearchMetadata> > >();
                var repositoryProvider = new OmniSharpSourceRepositoryProvider(projectPath);
                var repos = repositoryProvider.GetRepositories().ToArray();
                return(Task.FromResult(new PackageSourceResponse()
                {
                    Sources = repos.Select(x => x.PackageSource.Source)
                }));
            }

            return(Task.FromResult(new PackageSourceResponse()));
        }
Exemple #3
0
        public async Task <PackageVersionResponse> Handle(PackageVersionRequest request)
        {
            var projectPath = request.ProjectPath;

            if (request.ProjectPath.EndsWith(".json"))
            {
                projectPath = Path.GetDirectoryName(projectPath);
            }

            if (!string.IsNullOrWhiteSpace(projectPath))
            {
                if (request.Sources == null)
                {
                    request.Sources = Enumerable.Empty <string>();
                }

                var token = CancellationToken.None;

                var filter = new SearchFilter
                {
                    IncludePrerelease = request.IncludePrerelease
                };
                var foundVersions      = new List <NuGetVersion>();
                var repositoryProvider = new OmniSharpSourceRepositoryProvider(projectPath);
                var repos = repositoryProvider.GetRepositories().ToArray();
                if (request.Sources.Any())
                {
                    // Reduce to just the sources we requested
                    repos = repos.Join(request.Sources, x => x.PackageSource.Source, x => x, (x, y) => x).ToArray();
                }
                foreach (var repo in repos)
                {
                    // TODO: Swap when bug is fixed
                    // https://github.com/NuGet/NuGet3/pull/90

                    /*
                     * var resource = await repo.GetResourceAsync<FindPackageByIdResource>();
                     * if (resource != null)
                     * {
                     *  resource.Logger = NullLogger.Instance;
                     *  resource.NoCache = true;
                     *  foundVersions.AddRange(await resource.GetAllVersionsAsync(request.Id, token));
                     * }*/
                    var resource = await repo.GetResourceAsync <SimpleSearchResource>();

                    if (resource != null)
                    {
                        var result = await resource.Search(request.Id, filter, 0, 50, token);

                        var package = result.FirstOrDefault(metadata => metadata.Identity.Id == request.Id);
                        if (package != null)
                        {
                            foundVersions.AddRange(package.AllVersions);
                        }
                    }
                }

                var comparer = new VersionComparer();
                var versions = Enumerable.Distinct <NuGetVersion>(foundVersions, comparer)
                               .OrderByDescending(version => version, comparer)
                               .Select(version => version.ToNormalizedString());

                return(new PackageVersionResponse()
                {
                    Versions = versions
                });
            }

            return(new PackageVersionResponse());
        }