public async Task <IEnumerable <IPackageSearchMetadata> > LoadAsync(string searchTerm, PageContinuation pageContinuation, SearchFilter searchFilter, CancellationToken token)
{
try
{
if (pageContinuation.Current <= 0)
{
//start search from begin, don't skip packages
_discardedPackagesSet.Clear();
}
var localContinuation = new PageContinuation(pageContinuation, !pageContinuation.Source.PackageSources.Any());
var installedPackagesMetadatas = (await _projectRepositoryLoader.Value.LoadAsync(searchTerm, localContinuation, searchFilter, token));
pageContinuation.GetNext();
Log.Info("Local packages queryed for further available update searching");
List <IPackageSearchMetadata> updateList = new List <IPackageSearchMetadata>();
//getting last metadata
foreach (var package in installedPackagesMetadatas)
{
if (_discardedPackagesSet.Contains(package.Identity.Id))
{
continue;
}
var clonedMetadata = await PackageMetadataProvider.GetHighestPackageMetadataAsync(package.Identity.Id, searchFilter.IncludePrerelease, token);
if (clonedMetadata is null)
{
Log.Warning($"Couldn't retrieve update metadata for installed {package.Identity}");
continue;
}
if (clonedMetadata.Identity.Version > package.Identity.Version)
{
var combinedMetadata = UpdatePackageSearchMetadataBuilder.FromMetadatas(clonedMetadata as ClonedPackageSearchMetadata, package).Build();
updateList.Add(combinedMetadata);
}
_discardedPackagesSet.Add(package.Identity.Id);
if (updateList.Count >= pageContinuation.Size)
{
break;
}
}
return(updateList);
}
catch (Exception ex) when(token.IsCancellationRequested)
{
throw new OperationCanceledException("Search request was canceled", ex, token);
}
}
public static async Task <IEnumerable <IPackageSearchMetadata> > LoadWithDefaultsAsync(this IPackageLoaderService packageLoaderService, string repository, CancellationToken token = default)
{
Argument.IsNotNull(() => packageLoaderService);
var defaultFilter = new SearchFilter(true);
var localPagination = new PageContinuation(0, new PackageSourceWrapper(repository));
return(await packageLoaderService.LoadAsync(string.Empty, localPagination, defaultFilter, token));
}
protected override async Task InitializeAsync()
{
try
{
if (IsActive && _initialSearchParams is not null)
{
// Set page initial search params as Settings parameters
// Only on first loaded page
Settings.IsPreReleaseIncluded = _initialSearchParams.IsPrereleaseIncluded;
Settings.SearchString = _initialSearchParams.SearchString;
Settings.IsRecommendedOnly = _initialSearchParams.IsRecommendedOnly;
}
// Execution delay
SingleDelayTimer.Elapsed += OnTimerElapsed;
SingleDelayTimer.AutoReset = false;
SingleDelayTimer.SynchronizingObject = _typeFactory.CreateInstanceWithParameters <ISynchronizeInvoke>(
_dispatcherProviderService.GetCurrentDispatcher());
PackageItems = new FastObservableCollection <NuGetPackage>();
PackageItems.CollectionChanged += OnPackageItemsCollectionChanged;
_packageOperationContextService.OperationContextDisposing += OnOperationContextDisposing;
IsFirstLoaded = false;
var pageSize = _nuGetConfigurationService.GetPackageQuerySize();
if (Settings.ObservedFeed is not null && !string.IsNullOrEmpty(Settings.ObservedFeed.Source))
{
var currentFeed = Settings.ObservedFeed;
PageInfo = new PageContinuation(pageSize, Settings.ObservedFeed.GetPackageSource());
var searchParams = new PackageSearchParameters(Settings.IsPreReleaseIncluded, Settings.SearchString, Settings.IsRecommendedOnly);
await VerifySourceAndLoadPackagesAsync(PageInfo, currentFeed, searchParams, pageSize);
}
else
{
Log.Info("None of the source feeds configured");
}
}
public async Task <IEnumerable <IPackageSearchMetadata> > LoadAsyncFromSourcesAsync(string searchTerm, PageContinuation pageContinuation,
SearchFilter searchFilter, CancellationToken token)
{
SourceRepository tempRepoLocal = null;
var repositoryCollection = pageContinuation.Source.PackageSources.Select(source =>
{
tempRepoLocal = _repositoryProvider.CreateRepository(source);
return(tempRepoLocal);
}).ToArray();
try
{
var searchResource = await MultiplySourceSearchResource.CreateAsync(repositoryCollection);
var packages = await searchResource.SearchAsync(searchTerm, searchFilter, pageContinuation.GetNext(), pageContinuation.Size, _nugetLogger, token);
return(packages);
}
catch (FatalProtocolException ex) when(token.IsCancellationRequested)
{
//task is cancelled, supress
throw new OperationCanceledException("Search request was cancelled", ex, token);
}
}
public async Task <IEnumerable <IPackageSearchMetadata> > LoadAsync(string searchTerm, PageContinuation pageContinuation, SearchFilter searchFilter, CancellationToken token)
{
Argument.IsValid(nameof(pageContinuation), pageContinuation, pageContinuation.IsValid);
if (pageContinuation.Source.PackageSources.Count < 2)
{
var repository = _repositoryProvider.CreateRepository(pageContinuation.Source.PackageSources.FirstOrDefault());
try
{
var searchResource = await repository.GetResourceAsync <PackageSearchResource>();
var packages = await searchResource.SearchAsync(searchTerm, searchFilter, pageContinuation.GetNext(), pageContinuation.Size, _nugetLogger, token);
await LoadVersionsEagerIfNeedAsync(searchResource, packages);
return(packages);
}
catch (FatalProtocolException ex) when(token.IsCancellationRequested)
{
//task is cancelled, supress
throw new OperationCanceledException("Search request was canceled", ex, token);
}
}
else
{
var packages = await LoadAsyncFromSourcesAsync(searchTerm, pageContinuation, searchFilter, token);
return(packages);
}
}
public async Task <IEnumerable <IPackageSearchMetadata> > LoadAsync(string searchTerm, PageContinuation pageContinuation, SearchFilter searchFilter, CancellationToken token)
{
Argument.IsValid(nameof(pageContinuation), pageContinuation, pageContinuation.IsValid);
var source = pageContinuation.Source.PackageSources.FirstOrDefault();
var observedProjects = _extensibleProjectLocator.GetAllExtensibleProjects();
SourceRepository repository = null;
if (source is not null)
{
repository = _repositoryProvider.CreateRepository(source);
}
else
{
repository = observedProjects.FirstOrDefault().AsSourceRepository(_repositoryProvider);
}
try
{
var localPackages = await _projectManager.CreatePackagesCollectionFromProjectsAsync(observedProjects, token);
var pagedPackages = localPackages
.GetLatest(VersionComparer.Default)
.Where(package => package.Id.IndexOf(searchTerm ?? String.Empty, StringComparison.OrdinalIgnoreCase) != -1)
.OrderBy(package => package.Id)
.Skip(pageContinuation.GetNext());
if (pageContinuation.Size > 0)
{
pagedPackages = pagedPackages.Take(pageContinuation.Size).ToList();
}
List <IPackageSearchMetadata> combinedFindedMetadata = new List <IPackageSearchMetadata>();
foreach (var package in pagedPackages)
{
var metadata = await GetPackageMetadataAsync(package, searchFilter.IncludePrerelease, token);
if (metadata is not null)
{
combinedFindedMetadata.Add(metadata);
}
}
return(combinedFindedMetadata);
}
catch (FatalProtocolException ex) when(token.IsCancellationRequested)
{
//task is cancelled, supress
throw new OperationCanceledException("Search request was canceled", ex, token);
}
}
