public async Task GetCachedPackageInfo(string PackageID)
{
NuGetFactory factory = new NuGetFactory("NuGet", "https://api.nuget.org/v3/index.json");
var metaResource = await factory.GetUIMetadata();
var searchResource = await factory.GetSearch();
var packageMeta = await searchResource.Search(PackageID, new SearchFilter { IncludePrerelease = true }, 0, 100, CancellationToken.None);
var packagesFound = packageMeta.Where(x => x.Identity.Id.Equals(PackageID, StringComparison.InvariantCultureIgnoreCase)).ToList();
Assert.False(packagesFound.Count == 0);
Assert.True(packagesFound.Count > 0);
var nugetPackage = packagesFound.First();
var versions = await (await factory.GetMetadata()).GetVersions(PackageID, CancellationToken.None);
foreach (var version in versions)
{
var versionIdentity = new PackageIdentity(nugetPackage.Identity.Id, version);
var meta = await metaResource.GetMetadata(versionIdentity, CancellationToken.None);
foreach (var item in meta.DependencySets)
{
Assert.NotNull(item.TargetFramework.Framework);
}
}
}
internal async Task <Stream> DownloadPackage(string source, string packageID, string version)
{
NuGetFactory factory = new NuGetFactory(source);
var package = new PackageIdentity(packageID, NuGetVersion.Parse(version));
var settings = SharedInfo.Instance.GetNuGetSettings();
var download = await factory.GetDownload();
var info = await download.GetDownloadResourceResultAsync(package, settings, CancellationToken.None);
return(info.PackageStream);
}
public async Task <NuGetPackageViewResponse> ViewPackageInfo(string packageID, string source)
{
if (string.IsNullOrEmpty(packageID))
{
throw new ArgumentNullException("packageID");
}
if (string.IsNullOrEmpty(source))
{
throw new ArgumentNullException("source");
}
NuGetFactory factory = new NuGetFactory(source);
var model = new NuGetPackageViewResponse();
model.Request.PackageID = packageID;
model.Request.SourceUrl = factory.SourceUrl;
model.Request.Source = source;
var metaResource = await factory.GetUIMetadata();
var versions = (await CacheGetAllVersionsOfPackage(factory, packageID)).Reverse().Take(10);
foreach (var version in versions)
{
var packageVersion = new NuGetPackageVersion();
#region Meta
var versionIdentity = new PackageIdentity(packageID, version);
packageVersion = await CacheGetVersionMeta(metaResource, versionIdentity, true);
#endregion
#region Version Specific
packageVersion.IsReleaseVersion = !version.IsPrerelease;
packageVersion.IsLegacy = version.IsLegacyVersion;
packageVersion.IsPreRelease = version.IsPrerelease;
packageVersion.Version = version.ToNormalizedString();
packageVersion.OrderKey = packageVersion.LastUpdatedDate.ToString("yyyyMMdd") + packageVersion.Version;
packageVersion.LastUpdated = (packageVersion.LastUpdatedDate == DateTime.MinValue)
? string.Empty : packageVersion.LastUpdatedDate.ToString("MMM dd, yyyy");
#endregion
model.Versions.Add(packageVersion);
}
model.Versions = model.Versions.OrderByDescending(x => x.OrderKey).ToList();
model.LatestVersion = model.Versions.FirstOrDefault();
return(model);
}
private async Task DoSearch(NuGetFactory factory, D3DependencyChild current,
int maxLevel,
PackageIdentity package, NuGetFramework fx)
{
if (current.Level > maxLevel)
{
return;
}
// same package may be traversed multiple times, so we can cache it
// don't cache the tree as depth may change for the same package
SourcePackageDependencyInfo packageDependencyInfo = await CacheResolvePackage(factory, package, fx);
if (packageDependencyInfo.Dependencies.Any())
{
if (current.children == null)
{
current.children = new List <D3DependencyChild>();
}
foreach (var dependency in packageDependencyInfo.Dependencies)
{
// unlikely that the version of a particular dependency will change in 30 minutes
// so we can cache it
IEnumerable <NuGetVersion> allVersions = await CacheGetAllVersionsOfDependency(factory, dependency);
if (allVersions.Any())
{
var bestMatch = dependency.VersionRange.FindBestMatch(allVersions);
var child = new D3DependencyChild
{
key = dependency.Id,
version = bestMatch.Version.ToString(),
parent = current.key,
Level = current.Level + 1
};
current.children.Add(child);
var nextPackage = new PackageIdentity(child.key, bestMatch);
await DoSearch(factory, child, maxLevel, nextPackage, fx);
}
}
}
}
private async Task <SourcePackageDependencyInfo> CacheResolvePackage(NuGetFactory factory, PackageIdentity package, NuGetFramework fx)
{
string key = String.Format(@"{0}-{1}", package.ToString(), fx.ToString());
if (base.IsInCache <SourcePackageDependencyInfo>("CacheResolvePackage", key))
{
return(Get <SourcePackageDependencyInfo>("CacheResolvePackage", key));
}
else
{
var depResource = await factory.GetDependency();
var output = await depResource.ResolvePackage(package, fx, CancellationToken.None);
return(Get <SourcePackageDependencyInfo>("CacheResolvePackage", key, () => { return output; }));
}
}
public async Task <NuGetPackageSearchResponse> SearchPackages(string searchTerm, string source)
{
if (string.IsNullOrEmpty(searchTerm))
{
throw new ArgumentNullException("searchTerm");
}
if (string.IsNullOrEmpty(source))
{
throw new ArgumentNullException("source");
}
NuGetFactory factory = new NuGetFactory(source);
var model = new NuGetPackageSearchResponse
{
Request = new NuGetPackageSearchRequest
{
SearchKeyword = searchTerm,
Source = source,
SourceUrl = factory.SourceUrl
}
};
var searchResource = await factory.GetSearch();
var packageMeta = await searchResource.Search(searchTerm, new SearchFilter { IncludePrerelease = true }, 0, 100, CancellationToken.None);
var packagesFound = packageMeta.ToList();
foreach (var searchInfo in packagesFound)
{
var result = new NuGetPackageSearchResult();
result.Title = searchInfo.Title;
result.Summary = searchInfo.Summary;
result.DownloadCount = searchInfo.LatestPackageMetadata.DownloadCount;
result.IconUri = searchInfo.LatestPackageMetadata.IconUrl;
result.PackageID = searchInfo.Identity.Id;
result.LatestVersion = searchInfo.LatestPackageMetadata.Identity.Version.ToNormalizedString();
result.Authors = searchInfo.LatestPackageMetadata.Authors;
result.Tags = searchInfo.LatestPackageMetadata.Tags;
model.Results.Add(result);
}
return(model);
}
public async Task<NuGetPackageViewResponse> ViewPackageInfo(string packageID, string source)
{
if (string.IsNullOrEmpty(packageID))
throw new ArgumentNullException("packageID");
if (string.IsNullOrEmpty(source))
throw new ArgumentNullException("source");
NuGetFactory factory = new NuGetFactory(source);
var model = new NuGetPackageViewResponse();
model.Request.PackageID = packageID;
model.Request.SourceUrl = factory.SourceUrl;
model.Request.Source = source;
var metaResource = await factory.GetUIMetadata();
var versions = (await CacheGetAllVersionsOfPackage(factory, packageID)).Reverse().Take(10);
foreach (var version in versions)
{
var packageVersion = new NuGetPackageVersion();
#region Meta
var versionIdentity = new PackageIdentity(packageID, version);
packageVersion = await CacheGetVersionMeta(metaResource, versionIdentity, true);
#endregion
#region Version Specific
packageVersion.IsReleaseVersion = !version.IsPrerelease;
packageVersion.IsLegacy = version.IsLegacyVersion;
packageVersion.IsPreRelease = version.IsPrerelease;
packageVersion.Version = version.ToNormalizedString();
packageVersion.OrderKey = packageVersion.LastUpdatedDate.ToString("yyyyMMdd") + packageVersion.Version;
packageVersion.LastUpdated = (packageVersion.LastUpdatedDate == DateTime.MinValue)
? string.Empty : packageVersion.LastUpdatedDate.ToString("MMM dd, yyyy");
#endregion
model.Versions.Add(packageVersion);
}
model.Versions = model.Versions.OrderByDescending(x => x.OrderKey).ToList();
model.LatestVersion = model.Versions.FirstOrDefault();
return model;
}
public async Task <D3DependencyChild> ViewDependencies(string packageID, string packageVersion, string source,
string framework, string frameworkVersion, string frameworkProfile, int maxLevel = 3)
{
if (string.IsNullOrEmpty(packageID))
{
throw new ArgumentNullException("packageID");
}
if (string.IsNullOrEmpty(packageVersion))
{
throw new ArgumentNullException("packageVersion");
}
if (string.IsNullOrEmpty(source))
{
throw new ArgumentNullException("source");
}
if (string.IsNullOrEmpty(framework))
{
throw new ArgumentNullException("framework");
}
if (string.IsNullOrEmpty(frameworkVersion))
{
throw new ArgumentNullException("frameworkVersion");
}
var factory = new NuGetFactory(source);
NuGetFramework fx = new NuGetFramework(framework, Version.Parse(frameworkVersion), frameworkProfile);
PackageIdentity package = new PackageIdentity(packageID, NuGetVersion.Parse(packageVersion));
var root = new D3DependencyChild
{
key = packageID,
version = packageVersion,
Level = 0
};
await DoSearch(factory, root, maxLevel, package, fx);
return(root);
}
public async Task<NuGetPackageSearchResponse> SearchPackages(string searchTerm, string source)
{
if (string.IsNullOrEmpty(searchTerm))
throw new ArgumentNullException("searchTerm");
if (string.IsNullOrEmpty(source))
throw new ArgumentNullException("source");
NuGetFactory factory = new NuGetFactory(source);
var model = new NuGetPackageSearchResponse
{
Request = new NuGetPackageSearchRequest
{
SearchKeyword = searchTerm,
Source = source,
SourceUrl = factory.SourceUrl
}
};
var searchResource = await factory.GetSearch();
var packageMeta = await searchResource.Search(searchTerm, new SearchFilter { IncludePrerelease = true }, 0, 100, CancellationToken.None);
var packagesFound = packageMeta.ToList();
foreach (var searchInfo in packagesFound)
{
var result = new NuGetPackageSearchResult();
result.Title = searchInfo.Title;
result.Summary = searchInfo.Summary;
result.DownloadCount = searchInfo.LatestPackageMetadata.DownloadCount;
result.IconUri = searchInfo.LatestPackageMetadata.IconUrl;
result.PackageID = searchInfo.Identity.Id;
result.LatestVersion = searchInfo.LatestPackageMetadata.Identity.Version.ToNormalizedString();
result.Authors = searchInfo.LatestPackageMetadata.Authors;
result.Tags = searchInfo.LatestPackageMetadata.Tags;
model.Results.Add(result);
}
return model;
}
private async Task <IEnumerable <NuGetVersion> > CacheGetAllVersionsOfPackage(NuGetFactory factory, string packageID)
{
if (base.IsInCache <IEnumerable <NuGetVersion> >("CacheGetAllVersionsOfPackage", packageID))
{
return(Get <IEnumerable <NuGetVersion> >("CacheGetAllVersionsOfPackage", packageID));
}
else
{
var baseMetaResource = await factory.GetMetadata();
var output = await baseMetaResource.GetVersions(packageID, CancellationToken.None);
return(Get <IEnumerable <NuGetVersion> >("CacheGetAllVersionsOfPackage", packageID, () => { return output; }));
}
}
private async Task<SourcePackageDependencyInfo> CacheResolvePackage(NuGetFactory factory, PackageIdentity package, NuGetFramework fx)
{
string key = String.Format(@"{0}-{1}", package.ToString(), fx.ToString());
if (base.IsInCache<SourcePackageDependencyInfo>("CacheResolvePackage", key))
{
return Get<SourcePackageDependencyInfo>("CacheResolvePackage", key);
}
else
{
var depResource = await factory.GetDependency();
var output = await depResource.ResolvePackage(package, fx, CancellationToken.None);
return Get<SourcePackageDependencyInfo>("CacheResolvePackage", key, () => { return output; });
}
}
private async Task DoSearch(NuGetFactory factory, D3DependencyChild current,
int maxLevel,
PackageIdentity package, NuGetFramework fx)
{
if (current.Level > maxLevel)
{
return;
}
// same package may be traversed multiple times, so we can cache it
// don't cache the tree as depth may change for the same package
SourcePackageDependencyInfo packageDependencyInfo = await CacheResolvePackage(factory, package, fx);
if (packageDependencyInfo.Dependencies.Any())
{
if (current.children == null)
{
current.children = new List<D3DependencyChild>();
}
foreach (var dependency in packageDependencyInfo.Dependencies)
{
// unlikely that the version of a particular dependency will change in 30 minutes
// so we can cache it
IEnumerable<NuGetVersion> allVersions = await CacheGetAllVersionsOfDependency(factory, dependency);
if (allVersions.Any())
{
var bestMatch = dependency.VersionRange.FindBestMatch(allVersions);
var child = new D3DependencyChild
{
key = dependency.Id,
version = bestMatch.Version.ToString(),
parent = current.key,
Level = current.Level + 1
};
current.children.Add(child);
var nextPackage = new PackageIdentity(child.key, bestMatch);
await DoSearch(factory, child, maxLevel, nextPackage, fx);
}
}
}
}
internal async Task<Stream> DownloadPackage(string source, string packageID, string version)
{
NuGetFactory factory = new NuGetFactory(source);
var package = new PackageIdentity(packageID, NuGetVersion.Parse(version));
var settings = SharedInfo.Instance.GetNuGetSettings();
var download = await factory.GetDownload();
var info = await download.GetDownloadResourceResultAsync(package, settings, CancellationToken.None);
return info.PackageStream;
}
public async Task<D3DependencyChild> ViewDependencies(string packageID, string packageVersion, string source,
string framework, string frameworkVersion, string frameworkProfile, int maxLevel = 3)
{
if (string.IsNullOrEmpty(packageID))
throw new ArgumentNullException("packageID");
if (string.IsNullOrEmpty(packageVersion))
throw new ArgumentNullException("packageVersion");
if (string.IsNullOrEmpty(source))
throw new ArgumentNullException("source");
if (string.IsNullOrEmpty(framework))
throw new ArgumentNullException("framework");
if (string.IsNullOrEmpty(frameworkVersion))
throw new ArgumentNullException("frameworkVersion");
var factory = new NuGetFactory(source);
NuGetFramework fx = new NuGetFramework(framework, Version.Parse(frameworkVersion), frameworkProfile);
PackageIdentity package = new PackageIdentity(packageID, NuGetVersion.Parse(packageVersion));
var root = new D3DependencyChild
{
key = packageID,
version = packageVersion,
Level = 0
};
await DoSearch(factory, root, maxLevel, package, fx);
return root;
}
public async Task<NuGetPackageVersion> ViewPackageVersionInfo(string packageID, string packageVersion,
string source)
{
if (string.IsNullOrEmpty(packageID))
throw new ArgumentNullException("packageID");
if (string.IsNullOrEmpty(source))
throw new ArgumentNullException("source");
if (string.IsNullOrEmpty(packageVersion))
throw new ArgumentNullException("packageVersion");
NuGetFactory factory = new NuGetFactory(source);
var metaResource = await factory.GetUIMetadata();
var versionIdentity = new PackageIdentity(packageID, NuGetVersion.Parse(packageVersion));
return await CacheGetVersionMeta(metaResource, versionIdentity, false);
}
private async Task <IEnumerable <NuGetVersion> > CacheGetAllVersionsOfDependency(NuGetFactory factory,
NuGet.Packaging.Core.PackageDependency dependency)
{
return(await CacheGetAllVersionsOfPackage(factory, dependency.Id));
}
private async Task<IEnumerable<NuGetVersion>> CacheGetAllVersionsOfDependency(NuGetFactory factory,
NuGet.Packaging.Core.PackageDependency dependency)
{
return await CacheGetAllVersionsOfPackage(factory, dependency.Id);
}
private async Task<IEnumerable<NuGetVersion>> CacheGetAllVersionsOfPackage(NuGetFactory factory, string packageID)
{
if (base.IsInCache<IEnumerable<NuGetVersion>>("CacheGetAllVersionsOfPackage", packageID))
{
return Get<IEnumerable<NuGetVersion>>("CacheGetAllVersionsOfPackage", packageID);
}
else
{
var baseMetaResource = await factory.GetMetadata();
var output = await baseMetaResource.GetVersions(packageID, CancellationToken.None);
return Get<IEnumerable<NuGetVersion>>("CacheGetAllVersionsOfPackage", packageID, () => { return output; });
}
}
public async Task DependencyTest(string keyword, string version, string framework, bool hasDependencies)
{
var factory = new NuGetFactory("NuGet", "https://api.nuget.org/v3/index.json");
var baseMetaResource = await factory.GetMetadata();
var metaResource = await factory.GetUIMetadata();
var depResource = await factory.GetDependency();
var searchResource = await factory.GetSearch();
var versionNG = new NuGetVersion(version);
var fx = NuGetFramework.Parse(framework);
var packageId = new PackageIdentity(keyword, versionNG);
Assert.NotNull(fx);
Assert.NotNull(versionNG);
// Search with keyword
var filter = new SearchFilter { IncludePrerelease = true };
var packagesFound = await searchResource.Search(keyword, filter, 0, 10, CancellationToken.None);
foreach (var package in packagesFound)
{
Assert.NotNull(package.Identity.Id);
Assert.NotNull(package.Identity.Version);
Debug.WriteLine(package.Identity.ToString());
Debug.WriteLine(package.Identity.Version.ToNormalizedString());
}
// Get metadata for packageId
var metaResult = await metaResource.GetMetadata(packageId.Id, true, false, CancellationToken.None);
var versions = await (await factory.GetMetadata()).GetVersions(packageId.Id, CancellationToken.None);
foreach (var uiPackageMetadata in metaResult)
{
foreach (var dset in uiPackageMetadata.DependencySets)
{
Assert.NotNull(dset.TargetFramework.DotNetFrameworkName);
foreach (var depends in dset.Packages)
{
Debug.WriteLine(depends.ToString());
Assert.NotNull(depends.ToString());
}
}
}
foreach (var versionF in versions)
{
Assert.NotNull(versionF.ToNormalizedString());
}
// Get dependency for packageId + version + fx
var packageDependencyInfo = await depResource.ResolvePackage(packageId, fx, CancellationToken.None);
foreach (var dependency in packageDependencyInfo.Dependencies)
{
var allVersions = await baseMetaResource.GetVersions(dependency.Id, CancellationToken.None);
var bestMatch = dependency.VersionRange.FindBestMatch(allVersions);
Assert.NotNull(bestMatch);
}
}
