public async Task <PackageSearchResults> Search(string query, PackageSearchOptions options, Uri source = null)
{
await _progressService.StartLoading("Search");
_progressService.WriteMessage(string.Format("Searching for {0}", query));
if (source == null)
{
source = new Uri(_sourceService.GetDefaultSource().Url);
}
if (source.Scheme == "http" || source.Scheme == "https")
{
var results = await ODataPackageService.Search(query, _packageFactory, options, source);
await _progressService.StopLoading();
return(results);
}
if (source.IsFile || source.IsUnc)
{
await _progressService.StopLoading();
return(null);
}
throw new InvalidDataException("Invalid Source Uri. Double check that you current source is a valid endpoint.");
}
public async Task <PackageResults> Search(string query, PackageSearchOptions options)
{
using (await Lock.ReadLockAsync())
{
var choco = Lets.GetChocolatey().SetCustomLogging(new SerilogLogger(Logger, _progressService));
choco.Set(
config =>
{
config.CommandName = CommandNameType.list.ToString();
config.Input = query;
config.AllVersions = options.IncludeAllVersions;
config.ListCommand.Page = options.CurrentPage;
config.ListCommand.PageSize = options.PageSize;
if (string.IsNullOrWhiteSpace(query) || !string.IsNullOrWhiteSpace(options.SortColumn))
{
config.ListCommand.OrderByPopularity = string.IsNullOrWhiteSpace(options.SortColumn) ||
options.SortColumn == "DownloadCount";
}
config.ListCommand.Exact = options.MatchQuery;
if (!string.IsNullOrWhiteSpace(options.Source))
{
config.Sources = options.Source;
}
#if !DEBUG
config.Verbose = false;
#endif // DEBUG
});
var packages =
(await choco.ListAsync <PackageResult>()).Select(
pckge => GetMappedPackage(choco, pckge, _mapper));
return(new PackageResults
{
Packages = packages.ToArray(),
TotalCount = await Task.Run(() => choco.ListCount())
});
}
}
public async Task <PackageResults> Search(string query, PackageSearchOptions options)
{
_choco.Set(
config =>
{
config.CommandName = CommandNameType.list.ToString();
config.Input = query;
config.AllVersions = options.IncludeAllVersions;
config.ListCommand.Page = options.CurrentPage;
config.ListCommand.PageSize = options.PageSize;
config.Prerelease = options.IncludePrerelease;
config.ListCommand.LocalOnly = false;
if (string.IsNullOrWhiteSpace(query) || !string.IsNullOrWhiteSpace(options.SortColumn))
{
config.ListCommand.OrderByPopularity = string.IsNullOrWhiteSpace(options.SortColumn) ||
options.SortColumn == "DownloadCount";
}
config.ListCommand.Exact = options.MatchQuery;
if (!string.IsNullOrWhiteSpace(options.Source))
{
config.Sources = options.Source;
}
#if !DEBUG
config.Verbose = false;
#endif // DEBUG
});
var packages =
(await _choco.ListAsync <PackageResult>()).Select(
pckge => GetMappedPackage(_choco, pckge, _mapper));
return(new PackageResults
{
Packages = packages.ToArray(),
TotalCount = await Task.Run(() => _choco.ListCount())
});
}
public async Task <IEnumerable <NuGetReference> > GetNewerVersionsAsync(NuGetReference reference, IEnumerable <TargetFrameworkMoniker> tfms, PackageSearchOptions options, CancellationToken token)
{
if (_packages.TryGetValue(reference.Name, out var known))
{
return(new NuGetReference[] { known });
}
var latest = await _other.GetNewerVersionsAsync(reference, tfms, options, token).ConfigureAwait(false);
if (latest is not null && latest.LastOrDefault() is NuGetReference latestReference)
{
_unknownPackages[latestReference.Name] = latestReference.Version;
_logger.LogError("Unexpected check for newer version: {Name}, {Version}", reference.Name, reference.Version);
}
return(latest ?? Enumerable.Empty <NuGetReference>());
}
public async Task <NuGetReference?> GetLatestVersionAsync(string packageName, IEnumerable <TargetFrameworkMoniker> tfms, PackageSearchOptions options, CancellationToken token)
{
if (_packages.TryGetValue(packageName, out var known))
{
return(known);
}
var latest = await _other.GetLatestVersionAsync(packageName, tfms, options, token).ConfigureAwait(false);
if (latest is not null)
{
_unknownPackages[packageName] = latest.Version;
_logger.LogError("Unexpected version: {Name}, {Version}", latest.Name, latest.Version);
}
return(latest);
}
private static string GetMemoryCacheKey(Uri source, string query, PackageSearchOptions options)
{
return(string.Format(CultureInfo.CurrentCulture, "FileSystemPackageService.QueryResult.{0}|{1}|{2}|{3}", source, query, options.IncludeAllVersions, options.IncludePrerelease));
}
public static async Task <PackageSearchResults> Search(string queryString, IChocolateyService chocolateyService, Func <IPackageViewModel> packageFactory, PackageSearchOptions options, Uri source)
{
List <IPackageViewModel> packages;
if ((packages = (List <IPackageViewModel>)Cache.Get(GetMemoryCacheKey(source, queryString, options))) == null)
{
var queryCommand = string.Format("list {0} {1} {2} -source \"{3}\"", queryString,
options.IncludePrerelease ? "-pre" : "", options.IncludeAllVersions ? "-all" : "", source);
var chocoPackageList = (await chocolateyService.RunIndirectChocolateyCommand(queryCommand, false))
.ToDictionary(o => o.ToString().Split(' ')[0], o => o.ToString().Split(' ')[1]);
packages = (await chocolateyService.GetPackagesFromLocalDirectory(chocoPackageList, source.ToString())).ToList();
Cache.Set(GetMemoryCacheKey(source, queryString, options), packages, new CacheItemPolicy
{
AbsoluteExpiration = DateTime.Now.AddHours(1)
});
}
IQueryable <IPackageViewModel> query = packages.AsQueryable();
if (!string.IsNullOrWhiteSpace(options.SortColumn))
{
query = options.SortDescending
? query.OrderByDescending(options.SortColumn)
: query.OrderBy(options.SortColumn);
}
return(new PackageSearchResults
{
Packages = query.Skip(options.CurrentPage * options.PageSize).Take(options.PageSize),
TotalCount = packages.Count
});
}
private async Task <IEnumerable <NuGetReference> > SearchByNameAsync(string name, IEnumerable <TargetFrameworkMoniker> tfms, PackageSearchOptions options, NuGetVersion?currentVersion = null, IEnumerable <PackageSource>?sources = null, CancellationToken token = default)
{
var results = new List <IPackageSearchMetadata>();
if (sources is null)
{
sources = _packageSource;
}
foreach (var source in sources)
{
try
{
var metadata = await GetSourceRepository(source).GetResourceAsync <PackageMetadataResource>(token).ConfigureAwait(false);
var searchResults = await CallWithRetryAsync(() => metadata.GetMetadataAsync(name, includePrerelease: options.Prerelease, includeUnlisted: options.Unlisted, _context, _nugetLogger, token)).ConfigureAwait(false);
results.AddRange(searchResults);
}
catch (NuGetProtocolException)
{
_logger.LogWarning("Failed to get package versions from source {PackageSource} due to a NuGet protocol error", source.Source);
_logger.LogInformation("If NuGet packages are coming from an authenticated source, Upgrade Assistant requires a .NET Core-compatible v2 credential provider be installed. To authenticate with an Azure DevOps NuGet source, for example, see https://github.com/microsoft/artifacts-credprovider#setup");
}
catch (HttpRequestException exc)
{
_logger.LogWarning("Failed to get package versions from source {PackageSource} due to an HTTP error ({StatusCode})", source.Source, exc.StatusCode);
}
}
return(FilterSearchResults(name, results, tfms, currentVersion, options.LatestMinorAndBuildOnly));
}
private async Task <NuGetReference?> GetLatestVersionAsync(string packageName, IEnumerable <TargetFrameworkMoniker> tfms, PackageSearchOptions options, IEnumerable <PackageSource>?sources, CancellationToken token)
{
if (options is null)
{
throw new ArgumentNullException(nameof(options));
}
var result = await SearchByNameAsync(packageName, tfms, options, null, sources, token : token).ConfigureAwait(false);
return(result.LastOrDefault());
}
public Task <NuGetReference?> GetLatestVersionAsync(string packageName, IEnumerable <TargetFrameworkMoniker> tfms, PackageSearchOptions options, CancellationToken token) => GetLatestVersionAsync(packageName, tfms, options, default, token);
public Task <IEnumerable <NuGetReference> > GetNewerVersionsAsync(NuGetReference reference, IEnumerable <TargetFrameworkMoniker> tfms, PackageSearchOptions options, CancellationToken token)
{
if (reference is null)
{
throw new ArgumentNullException(nameof(reference));
}
if (options is null)
{
throw new ArgumentNullException(nameof(options));
}
return(SearchByNameAsync(reference.Name, tfms, options, currentVersion: reference.GetNuGetVersion(), _packageSource, token: token));
}
public static async Task <PackageSearchResults> Search(string query, Func <IPackageViewModel> packageFactory, PackageSearchOptions options, Uri source)
{
var service = GetFeed(source);
var queryString = query;
IQueryable <V2FeedPackage> feedQuery = service.Packages.Where(package => package.IsPrerelease == options.IncludePrerelease || package.IsPrerelease == false);
if (!options.IncludeAllVersions)
{
feedQuery = feedQuery.Where(package => package.IsLatestVersion || package.IsAbsoluteLatestVersion);
}
if (!string.IsNullOrWhiteSpace(queryString))
{
feedQuery = options.MatchQuery ?
feedQuery.Where(package => package.Id == queryString || package.Title == queryString) :
feedQuery.Where(package => package.Id.Contains(queryString) || package.Title.Contains(queryString));
}
var totalCount = feedQuery.Count();
if (!string.IsNullOrWhiteSpace(options.SortColumn))
{
feedQuery = !options.SortDescending ? feedQuery.OrderBy(options.SortColumn) : feedQuery.OrderByDescending(options.SortColumn);
}
feedQuery = feedQuery.Skip(options.CurrentPage * options.PageSize).Take(options.PageSize);
var feedDataServiceQuery = (DataServiceQuery <V2FeedPackage>)feedQuery;
var result = await Task.Factory.FromAsync(feedDataServiceQuery.BeginExecute, ar => feedDataServiceQuery.EndExecute(ar), null);
var packages = result.Select(package => AutoMapper.Mapper.Map(package, packageFactory()));
return(new PackageSearchResults
{
TotalCount = totalCount,
Packages = packages
});
}
