public void UpdatePackageStatus(IEnumerable <PackageCollectionItem> installedPackages)
{
// Get the minimum version installed in any target project/solution
InstalledVersion = installedPackages
.GetPackageVersions(Id)
.MinOrDefault();
// Set auto referenced to true any reference for the given id contains the flag.
AutoReferenced = installedPackages.IsAutoReferenced(Id);
_backgroundLatestVersionLoader = AsyncLazy.New(
async() =>
{
var packageVersions = await GetVersionsAsync();
// filter package versions based on allowed versions in packages.config
packageVersions = packageVersions.Where(v => AllowedVersions.Satisfies(v.Version));
var latestAvailableVersion = packageVersions
.Select(p => p.Version)
.MaxOrDefault();
return(latestAvailableVersion);
});
_backgroundDeprecationMetadataLoader = AsyncLazy.New(GetPackageDeprecationMetadataAsync);
OnPropertyChanged(nameof(Status));
}
public static IPackageSearchMetadata WithVersions(this IPackageSearchMetadata metadata, IEnumerable <VersionInfo> versions)
{
return(PackageSearchMetadataBuilder
.FromMetadata(metadata)
.WithVersions(AsyncLazy.New(versions))
.Build());
}
public static IPackageSearchMetadata WithVersions(this IPackageSearchMetadata metadata, Func <IEnumerable <VersionInfo> > valueFactory)
{
return(PackageSearchMetadataBuilder
.FromMetadata(metadata)
.WithVersions(AsyncLazy.New(valueFactory))
.Build());
}
public IPackageSearchMetadata Build()
{
var clonedMetadata = new ClonedPackageSearchMetadata
{
Authors = _metadata.Authors,
DependencySets = _metadata.DependencySets ?? Enumerable.Empty <PackageDependencyGroup>(),
Description = _metadata.Description,
DownloadCount = _metadata.DownloadCount,
IconUrl = _metadata.IconUrl,
Identity = _metadata.Identity,
LicenseUrl = _metadata.LicenseUrl,
Owners = _metadata.Owners,
ProjectUrl = _metadata.ProjectUrl,
Published = _metadata.Published,
ReportAbuseUrl = _metadata.ReportAbuseUrl,
PackageDetailsUrl = _metadata.PackageDetailsUrl,
RequireLicenseAcceptance = _metadata.RequireLicenseAcceptance,
Summary = _metadata.Summary,
Tags = _metadata.Tags,
Title = _metadata.Title,
LazyVersionsFactory = _lazyVersionsFactory,
IsListed = _metadata.IsListed,
PrefixReserved = _metadata.PrefixReserved,
LicenseMetadata = _metadata.LicenseMetadata,
LazyDeprecationFactory = _lazyDeprecationFactory ?? AsyncLazy.New(_metadata.GetDeprecationMetadataAsync),
Vulnerabilities = _metadata.Vulnerabilities,
PackageReader =
(_metadata as LocalPackageSearchMetadata)?.PackageReader ??
(_metadata as ClonedPackageSearchMetadata)?.PackageReader,
};
return(clonedMetadata);
}
public IEnumerable <PackageItemListViewModel> GetCurrent()
{
if (_state.ItemsCount == 0)
{
return(Enumerable.Empty <PackageItemListViewModel>());
}
var listItems = _state.Results
.Select((metadata, index) =>
{
VersionRange allowedVersions = VersionRange.All;
// get the allowed version range and pass it to package item view model to choose the latest version based on that
if (_packageReferences != null)
{
var matchedPackageReferences = _packageReferences.Where(r => StringComparer.OrdinalIgnoreCase.Equals(r.Identity.Id, metadata.Identity.Id));
var allowedVersionsRange = matchedPackageReferences.Select(r => r.AllowedVersions).Where(v => v != null).ToArray();
if (allowedVersionsRange.Length > 0)
{
allowedVersions = allowedVersionsRange[0];
}
}
var listItem = new PackageItemListViewModel
{
Id = metadata.Identity.Id,
Version = metadata.Identity.Version,
IconUrl = metadata.IconUrl,
Author = metadata.Authors,
DownloadCount = metadata.DownloadCount,
Summary = metadata.Summary,
Versions = AsyncLazy.New(metadata.GetVersionsAsync),
AllowedVersions = allowedVersions,
PrefixReserved = metadata.PrefixReserved && !IsMultiSource,
DeprecationMetadata = AsyncLazy.New(metadata.GetDeprecationMetadataAsync),
Vulnerabilities = metadata.Vulnerabilities,
Recommended = index < _recommendedCount,
PackageReader = (metadata as PackageSearchMetadataBuilder.ClonedPackageSearchMetadata)?.PackageReader,
};
listItem.UpdatePackageStatus(_installedPackages);
if (!_context.IsSolution && _context.PackageManagerProviders.Any())
{
listItem.ProvidersLoader = AsyncLazy.New(
async() =>
{
string uniqueProjectName = await _context.Projects[0].GetUniqueNameOrNameAsync(CancellationToken.None);
return(await AlternativePackageManagerProviders.CalculateAlternativePackageManagersAsync(_context.PackageManagerProviders, listItem.Id, uniqueProjectName));
});
}
return(listItem);
});
return(listItems.ToArray());
}
public PackageSearchMetadataCacheItemEntry(IPackageSearchMetadata packageSearchMetadata, IPackageMetadataProvider packageMetadataProvider)
{
_packageSearchMetadata = packageSearchMetadata;
_packageMetadataProvider = packageMetadataProvider;
_detailedPackageSearchMetadata = AsyncLazy.New(() =>
{
return(_packageMetadataProvider.GetPackageMetadataAsync(_packageSearchMetadata.Identity, includePrerelease: true, CancellationToken.None));
});
}
HttpClient CreateHttpClient(PackageSourceViewModel packageSource)
{
var lazyProvider = AsyncLazy.New(() => Enumerable.Empty <ICredentialProvider> ());
var credentialService = new CredentialService(lazyProvider, true, false);
return(HttpClientFactory.CreateHttpClient(
packageSource.GetPackageSource(),
credentialService));
}
PackageItemListViewModel CreatePackageItemListViewModel()
{
packageVersions = new List <VersionInfo> ();
packageItemListViewModel = new PackageItemListViewModel {
Id = "TestPackage",
Version = new NuGetVersion("1.2.3"),
Versions = AsyncLazy.New(() => {
return(Task.FromResult(packageVersions.AsEnumerable()));
})
};
return(packageItemListViewModel);
}
public static ICredentialService CreateNonInteractiveCredentialService()
{
var existingCredentialService = HttpHandlerResourceV3Extensions.GetCustomCredentialService();
if (existingCredentialService != null)
{
return(existingCredentialService.CreateNonInteractive());
}
var lazyProvider = AsyncLazy.New(() => Enumerable.Empty <ICredentialProvider> ());
return(new CredentialService(lazyProvider, nonInteractive: true, handlesDefaultCredentials: false));
}
public IEnumerable <PackageItemListViewModel> GetCurrent()
{
if (_state.ItemsCount == 0)
{
return(Enumerable.Empty <PackageItemListViewModel>());
}
var listItems = _state.Results
.Select(metadata =>
{
VersionRange allowedVersions = VersionRange.All;
// get the allowed version range and pass it to package item view model to choose the latest version based on that
if (_packageReferences != null)
{
var matchedPackageReferences = _packageReferences.Where(r => StringComparer.OrdinalIgnoreCase.Equals(r.PackageIdentity.Id, metadata.Identity.Id));
var allowedVersionsRange = matchedPackageReferences.Select(r => r.AllowedVersions).Where(v => v != null).ToArray();
if (allowedVersionsRange.Length > 0)
{
allowedVersions = allowedVersionsRange[0];
}
}
var listItem = new PackageItemListViewModel
{
Id = metadata.Identity.Id,
Version = metadata.Identity.Version,
IconUrl = metadata.IconUrl,
Author = metadata.Authors,
DownloadCount = metadata.DownloadCount,
Summary = metadata.Summary,
Versions = AsyncLazy.New(() => metadata.GetVersionsAsync()),
AllowedVersions = allowedVersions,
PrefixReserved = metadata.PrefixReserved && !IsMultiSource,
IsPackageDeprecated = metadata.DeprecationMetadata != null,
};
listItem.UpdatePackageStatus(_installedPackages);
if (!_context.IsSolution && _context.PackageManagerProviders.Any())
{
listItem.ProvidersLoader = AsyncLazy.New(
() => AlternativePackageManagerProviders.CalculateAlternativePackageManagersAsync(
_context.PackageManagerProviders,
listItem.Id,
_context.Projects[0]));
}
return(listItem);
});
return(listItems.ToArray());
}
PackageItemListViewModel CreatePackageItemListViewModel(IPackageSearchMetadata metadata)
{
return(new PackageItemListViewModel {
Id = metadata.Identity.Id,
Version = metadata.Identity.Version,
IconUrl = metadata.IconUrl,
Author = metadata.Authors,
DownloadCount = metadata.DownloadCount,
Summary = metadata.Summary,
Description = metadata.Description,
Title = metadata.Title,
LicenseUrl = metadata.LicenseUrl,
ProjectUrl = metadata.ProjectUrl,
Published = metadata.Published,
Versions = AsyncLazy.New(() => metadata.GetVersionsAsync())
});
}
public IEnumerable <PackageItemListViewModel> GetCurrent()
{
if (_state.ItemsCount == 0)
{
return(Enumerable.Empty <PackageItemListViewModel>());
}
var listItems = _state.Results
.Select(metadata =>
{
var listItem = new PackageItemListViewModel
{
Id = metadata.Identity.Id,
Version = metadata.Identity.Version,
IconUrl = metadata.IconUrl,
Author = metadata.Authors,
DownloadCount = metadata.DownloadCount,
Summary = metadata.Summary,
Description = metadata.Description,
Title = metadata.Title,
LicenseUrl = metadata.LicenseUrl,
ProjectUrl = metadata.ProjectUrl,
Published = metadata.Published,
Versions = AsyncLazy.New(() => metadata.GetVersionsAsync())
};
/*listItem.UpdatePackageStatus(_installedPackages);
*
* if (!_context.IsSolution && _context.PackageManagerProviders.Any())
* {
* listItem.ProvidersLoader = AsyncLazy.New(
* () => AlternativePackageManagerProviders.CalculateAlternativePackageManagersAsync(
* _context.PackageManagerProviders,
* listItem.Id,
* _context.Projects[0]));
* }*/
return(listItem);
});
return(listItems.ToArray());
}
public void UpdatePackageStatus(IEnumerable <PackageIdentity> installedPackages)
{
// Get the minimum version installed in any target project/solution
InstalledVersion = installedPackages
.GetPackageVersions(Id)
.MinOrDefault();
_backgroundLoader = AsyncLazy.New(
async() =>
{
var packageVersions = await GetVersionsAsync();
var latestAvailableVersion = packageVersions
.Select(p => p.Version)
.MaxOrDefault();
return(latestAvailableVersion);
});
OnPropertyChanged(nameof(Status));
}
/// <summary>
/// Get package metadata from the package folders.
/// </summary>
public async Task <IPackageSearchMetadata> GetLocalPackageMetadataAsync(
PackageIdentity identity,
bool includePrerelease,
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var sources = new List <SourceRepository>();
if (_localRepository != null)
{
sources.Add(_localRepository);
}
if (_globalLocalRepositories != null)
{
sources.AddRange(_globalLocalRepositories);
}
// Take the package from the first source it is found in
foreach (var source in sources)
{
var result = await source.GetPackageMetadataFromLocalSourceAsync(identity, cancellationToken);
if (result != null)
{
var versionsAndDeprecationMetadataTask = FetchAndMergeVersionsAndDeprecationMetadataAsync(identity, includePrerelease, cancellationToken);
return(PackageSearchMetadataBuilder
.FromMetadata(result)
.WithVersions(AsyncLazy.New(async() => (await versionsAndDeprecationMetadataTask).versions))
.WithDeprecation(AsyncLazy.New(async() => (await versionsAndDeprecationMetadataTask).deprecationMetadata))
.Build());
}
}
return(null);
}
public CredentialService CreateNonInteractive()
{
bool handlesDefaultCredentials = Providers.Any(provider => provider is DefaultNetworkCredentialsCredentialProvider);
var lazyProviders = AsyncLazy.New(() => Providers)
; return(new CredentialService(lazyProviders, nonInteractive: true, handlesDefaultCredentials: handlesDefaultCredentials));
}
public IEnumerable <PackageItemViewModel> GetCurrent()
{
if (_state.ItemsCount == 0)
{
return(Enumerable.Empty <PackageItemViewModel>());
}
var listItemViewModels = new List <PackageItemViewModel>();
foreach (PackageSearchMetadataContextInfo metadata in _state.Results.PackageSearchItems)
{
VersionRange allowedVersions = VersionRange.All;
// get the allowed version range and pass it to package item view model to choose the latest version based on that
if (_packageReferences != null)
{
IEnumerable <IPackageReferenceContextInfo> matchedPackageReferences = _packageReferences.Where(r => StringComparer.OrdinalIgnoreCase.Equals(r.Identity.Id, metadata.Identity.Id));
VersionRange[] allowedVersionsRange = matchedPackageReferences.Select(r => r.AllowedVersions).Where(v => v != null).ToArray();
if (allowedVersionsRange.Length > 0)
{
allowedVersions = allowedVersionsRange[0];
}
}
var listItem = new PackageItemViewModel
{
Id = metadata.Identity.Id,
Version = metadata.Identity.Version,
IconUrl = metadata.IconUrl,
Author = metadata.Authors,
DownloadCount = metadata.DownloadCount,
Summary = metadata.Summary,
AllowedVersions = allowedVersions,
PrefixReserved = metadata.PrefixReserved && !IsMultiSource,
Versions = AsyncLazy.New(() => { return(GetVersionInfoAsync(metadata.Identity)); }),
DeprecationMetadata = AsyncLazy.New(() => { return(GetDeprecationMetadataAsync(metadata.Identity)); }),
DetailedPackageSearchMetadata = AsyncLazy.New(() => { return(GetDetailedPackageSearchMetadataContextInfoAsync(metadata.Identity)); }),
Recommended = metadata.IsRecommended,
RecommenderVersion = metadata.RecommenderVersion,
Vulnerabilities = metadata.Vulnerabilities,
Sources = _packageSources,
PackagePath = metadata.PackagePath,
PackageFileService = _packageFileService,
};
listItem.UpdatePackageStatus(_installedPackages);
if (!_context.IsSolution && _context.PackageManagerProviders.Any())
{
listItem.ProvidersLoader = AsyncLazy.New(
async() =>
{
string uniqueProjectName = await _context.Projects[0].GetUniqueNameOrNameAsync(
_context.ServiceBroker,
CancellationToken.None);
return(await AlternativePackageManagerProviders.CalculateAlternativePackageManagersAsync(
_context.PackageManagerProviders,
listItem.Id,
uniqueProjectName));
});
}
listItemViewModels.Add(listItem);
}
return(listItemViewModels.ToArray());
}
