protected async Task <T> SafeCall <T>(IActivityMonitor m, Func <SourceRepository, MetadataResource, NuGetLoggerAdapter, Task <T> > f)
{
bool retry = false;
var logger = new NuGetLoggerAdapter(m);
if (_sourceRepository == null)
{
_sourceRepository = new SourceRepository(PackageSource, NuGetClient.StaticProviders);
}
again:
MetadataResource meta = null;
try
{
meta = await _sourceRepository.GetResourceAsync <MetadataResource>();
return(await f(_sourceRepository, meta, logger));
}
catch (MissingRequiredSecretException)
{
throw; //It's useless to retry in this case
}
catch (Exception ex)
{
if (meta != null && !retry)
{
retry = true;
if (CanRetry(meta, logger, ex))
{
goto again;
}
}
throw;
}
}
public async Task <IEnumerable <NuGetVersion> > GetNuGetVersionsAsync(string packageId, SourceCacheContext sourceCacheContext, CancellationToken token)
{
List <MetadataResource> metadataResources = new List <MetadataResource>();
foreach (SourceRepository repo in _sourceRepositoryProvider.GetRepositories())
{
MetadataResource metadataResource = await repo.GetResourceAsync <MetadataResource>();
if (metadataResource != null)
{
metadataResources.Add(metadataResource);
}
}
List <Task <IEnumerable <NuGetVersion> > > tasks = new List <Task <IEnumerable <NuGetVersion> > >();
using (sourceCacheContext)
{
foreach (MetadataResource resource in metadataResources)
{
tasks.Add(resource.GetVersions(packageId, sourceCacheContext, _logger, token));
}
var nugetVersions = await Task.WhenAll(tasks.ToArray());
return(nugetVersions.SelectMany(t => t).Distinct().OrderByDescending(t => t).ToList());
}
}
public async Task <NuGetVersion> GetNuGetLatestVersionAsync(string packageId, SourceCacheContext sourceCacheContext, bool includePrerelease, bool includeUnlisted, CancellationToken token)
{
List <MetadataResource> metadataResources = new List <MetadataResource>();
foreach (SourceRepository repo in _sourceRepositoryProvider.GetRepositories())
{
MetadataResource metadataResource = await repo.GetResourceAsync <MetadataResource>();
if (metadataResource != null)
{
metadataResources.Add(metadataResource);
}
}
List <Task <NuGetVersion> > tasks = new List <Task <NuGetVersion> >();
using (sourceCacheContext)
{
foreach (MetadataResource resource in metadataResources)
{
tasks.Add(resource.GetLatestVersion(packageId, includePrerelease, includeUnlisted, sourceCacheContext, _logger, token));
}
var nugetVersions = await Task.WhenAll(tasks);
return(nugetVersions.Where(t => t != null).Distinct().OrderByDescending(t => t).FirstOrDefault());
}
}
/// <summary>
/// Initializes the <see cref="PackagesToPublish"/> and <see cref="PackagesAlreadyPublishedCount"/>.
/// This can be called multiple times.
/// </summary>
/// <param name="ctx">The Cake context.</param>
/// <param name="allPackagesToPublish">The set of packages </param>
/// <returns>The awaitable.</returns>
public async Task InitializePackagesToPublishAsync(ICakeContext ctx, IEnumerable <SimplePackageId> allPackagesToPublish)
{
if (_packagesToPublish != null)
{
_packagesToPublish.Clear();
PackagesAlreadyPublishedCount = 0;
}
else
{
_packagesToPublish = new List <SimplePackageId>();
}
var logger = InitializeAndGetLogger(ctx);
MetadataResource meta = await _sourceRepository.GetResourceAsync <MetadataResource>();
foreach (var p in allPackagesToPublish)
{
if (await meta.Exists(p.PackageIdentity, _sourceCache, logger, CancellationToken.None))
{
++PackagesAlreadyPublishedCount;
}
else
{
ctx.Debug($"Package {p.PackageId} must be published to remote feed '{Name}'.");
_packagesToPublish.Add(p);
}
}
ctx.Debug($" ==> {_packagesToPublish.Count} package(s) must be published to remote feed '{Name}'.");
}
protected override long ExecuteWorkImplementation()
{
var now = DateTime.UtcNow;
var latestMetadataResource = m_metadataRepository.GetLatestMetadataResource(m_projectId, false);
var userEntity = m_metadataRepository.Load <User>(m_userId);
var publisherEntity = m_data.PublisherId != null?m_metadataRepository.Load <Publisher>(m_data.PublisherId) : null;
Resource resource;
int versionNumber;
if (latestMetadataResource == null)
{
var projectEntity = m_metadataRepository.Load <Project>(m_projectId);
resource = new Resource
{
Name = "Metadata",
Project = projectEntity,
ContentType = ContentTypeEnum.None,
ResourceType = ResourceTypeEnum.ProjectMetadata
};
versionNumber = 1;
}
else
{
resource = latestMetadataResource.Resource;
versionNumber = latestMetadataResource.VersionNumber + 1;
}
var newResourceVersion = new MetadataResource
{
Resource = resource,
BiblText = m_data.BiblText,
Copyright = m_data.Copyright,
CreateTime = now,
CreatedByUser = userEntity,
ManuscriptCountry = m_data.ManuscriptCountry,
ManuscriptExtent = m_data.ManuscriptExtent,
ManuscriptSettlement = m_data.ManuscriptSettlement,
ManuscriptIdno = m_data.ManuscriptIdno,
ManuscriptRepository = m_data.ManuscriptRepository,
NotAfter = m_data.NotAfter,
NotBefore = m_data.NotBefore,
OriginDate = m_data.OriginDate,
PublishDate = m_data.PublishDate,
PublishPlace = m_data.PublishPlace,
Publisher = publisherEntity,
RelicAbbreviation = m_data.RelicAbbreviation,
SourceAbbreviation = m_data.SourceAbbreviation,
SubTitle = m_data.SubTitle,
Title = m_data.Title,
VersionNumber = versionNumber
};
resource.LatestVersion = newResourceVersion;
return((long)m_metadataRepository.Create(newResourceVersion));
}
public async Task TestMetadataResource(string SourceUrl)
{
SourceRepository repo = GetSourceRepository(SourceUrl);
MetadataResource resource = await repo.GetResource <MetadataResource>();
Assert.True(resource != null);
NuGetVersion latestVersion = await resource.GetLatestVersion("Nuget.core", true, true, CancellationToken.None);
Assert.True(latestVersion.ToNormalizedString().Contains("2.8.3"));
}
public static string Resource(MetadataResource resource)
{
var builder = new StringBuilder();
builder.AppendLine("<pre>");
builder.AppendLine("{");
ResourceBlock(builder, resource.Properties, 1);
builder.AppendLine("}");
builder.AppendLine("</pre>");
return builder.ToString();
}
public async Task TestLatestVersion2()
{
SourceRepository repo = GetSourceRepository(RCRootUrl);
MetadataResource resource = await repo.GetResource <MetadataResource>();
Assert.True(resource != null);
NuGetVersion latestVersion = await resource.GetLatestVersion("TestPackage.AlwaysPrerelease", false, true, CancellationToken.None);
//*TODOs: Use a proper test package whose latest version is fixed instead of using nuget.core.
Assert.True(latestVersion == null);
}
public async Task TestLatestVersion3()
{
SourceRepository repo = GetSourceRepository(RCRootUrl);
MetadataResource resource = await repo.GetResource <MetadataResource>();
Assert.True(resource != null);
NuGetVersion latestVersion = await resource.GetLatestVersion("TestPackage.MinClientVersion", false, true, CancellationToken.None);
//*TODOs: Use a proper test package whose latest version is fixed instead of using nuget.core.
Assert.True(latestVersion.ToNormalizedString().Contains("1.0.0"));
}
private static Task <NuGetVersion> GetOrAddVersion(MetadataResource resource, string packageId)
{
return(_packageVersionLookup.GetOrAdd(packageId, id =>
{
return resource.GetLatestVersion(
packageId,
includePrerelease: true,
includeUnlisted: false,
log: NullLogger.Instance,
token: default(CancellationToken));
}));
}
public override async Task <Tuple <bool, INuGetResource> > TryCreate(SourceRepository source, CancellationToken token)
{
MetadataResource resource = null;
var v2repo = await GetRepository(source, token);
if (v2repo != null)
{
resource = new MetadataResourceV2(v2repo);
}
return(new Tuple <bool, INuGetResource>(resource != null, resource));
}
static void dumpAllLookups(RetsMetadata metadata,
MetadataResource resource)
{
string resourceName = resource.GetResourceID();
IEnumerable lookups = metadata.GetAllLookups(resourceName);
foreach (MetadataLookup lookup in lookups)
{
Console.WriteLine("Resource name: " + resourceName + " [" +
resource.GetStandardName() + "]");
Console.WriteLine("Lokup name: " + lookup.GetLookupName() + " (" +
lookup.GetVisibleName() + ")");
dumpAllLookupTypes(metadata, lookup);
Console.WriteLine();
}
}
static void dumpAllClasses(RetsMetadata metadata,
MetadataResource resource)
{
string resourceName = resource.GetResourceID();
IEnumerable classes = metadata.GetAllClasses(resourceName);
foreach (MetadataClass aClass in classes)
{
Console.WriteLine("Resource name: " + resourceName + " [" +
resource.GetStandardName() + "]");
Console.WriteLine("Class name: " + aClass.GetClassName() + " [" +
aClass.GetStandardName() + "]");
dumpAllTables(metadata, aClass);
Console.WriteLine();
}
}
public override async Task <Tuple <bool, INuGetResource> > TryCreate(SourceRepository source, CancellationToken token)
{
MetadataResource resource = null;
if (FeedTypeUtility.GetFeedType(source.PackageSource) == FeedType.FileSystem)
{
var v2repo = await GetRepository(source, token);
if (v2repo != null)
{
resource = new MetadataResourceV2(v2repo);
}
}
return(new Tuple <bool, INuGetResource>(resource != null, resource));
}
static void dumpAllClasses(RetsMetadata metadata,
MetadataResource resource)
{
string resourceName = resource.GetResourceID();
IEnumerable classes = metadata.GetAllClasses(resourceName);
foreach (MetadataClass aClass in classes)
{
Console.WriteLine("Resource name: " + resourceName + " [" +
resource.GetStandardName() + "]");
Console.WriteLine("Class name: " + aClass.GetClassName() + " [" +
aClass.GetStandardName() + "]");
dumpAllTables(metadata, aClass);
Console.WriteLine();
}
}
static void dumpAllLookups(RetsMetadata metadata,
MetadataResource resource)
{
string resourceName = resource.GetResourceID();
IEnumerable lookups = metadata.GetAllLookups(resourceName);
foreach (MetadataLookup lookup in lookups)
{
Console.WriteLine("Resource name: " + resourceName + " [" +
resource.GetStandardName() + "]");
Console.WriteLine("Lookup name: " + lookup.GetLookupName() + " (" +
lookup.GetVisibleName() + ")");
dumpAllLookupTypes(metadata, lookup);
Console.WriteLine();
}
}
public async Task TestAllBasicScenariosForLocalShare()
{
List <PackageIdentity> packages = new List <PackageIdentity>();
packages.Add(new PackageIdentity("Nuget.core", new NuGetVersion("2.8.5")));
packages.Add(new PackageIdentity("Nuget.core", new NuGetVersion("2.5.0")));
//create a local package source by downloading the specific packages from remote feed.
SetupLocalShare(packages);
//Create source repo based on the local share.
string curDir = string.Empty;
#if !DNXCORE50
curDir = Environment.CurrentDirectory;
#endif
SourceRepository repo = GetSourceRepository(curDir);
UIMetadataResource resource = repo.GetResource <UIMetadataResource>();
Assert.True(resource != null);
//check if UIPackageMetadata works fine.
IEnumerable <UIPackageMetadata> packageMetadataList = resource.GetMetadata("Nuget.core", true, true, CancellationToken.None).Result;
Assert.True(packageMetadataList != null);
Assert.Equal(3, packageMetadataList.Count());
Assert.True(packageMetadataList.All(item => item.Tags.Contains("nuget")));
Assert.True(packageMetadataList.All(item => item.RequireLicenseAcceptance.Equals(false)));
Assert.True(packageMetadataList.All(item => item.ProjectUrl.ToString().Equals("http://nuget.codeplex.com/")));
Assert.True(packageMetadataList.Any(item => item.DependencySets.Count() == 1));
Assert.True(packageMetadataList.First(item => item.DependencySets.Count() == 1).DependencySets.First().Packages.Any(item2 => item2.Id.Equals("Microsoft.Web.Xdt", StringComparison.OrdinalIgnoreCase)));
//Check if downloadresource works fine.
DownloadResource downloadResource = repo.GetResource <DownloadResource>();
Uri downloadUrl = await downloadResource.GetDownloadUrl(new PackageIdentity("Nuget.core", new NuGetVersion("2.5.0")));
Assert.True(downloadUrl.IsFile);
Assert.True(File.Exists(downloadUrl.LocalPath)); //path doesnt contain the folder name and also the version is normalized in path for local scenario.
//Check if metadata resource works fine.
MetadataResource metadataResource = repo.GetResource <MetadataResource>();
NuGetVersion latestVersion = await metadataResource.GetLatestVersion("Nuget.core", true, false, CancellationToken.None);
Assert.True(latestVersion.ToNormalizedString().Contains("2.8.5"));
}
public override async Task <Tuple <bool, INuGetResource> > TryCreate(SourceRepository source, CancellationToken token)
{
MetadataResource resource = null;
if (await source.GetFeedType(token) == FeedType.HttpV2)
{
var serviceDocument = await source.GetResourceAsync <ODataServiceDocumentResourceV2>(token);
var httpSource = await source.GetResourceAsync <HttpSourceResource>(token);
var parser = new V2FeedParser(httpSource.HttpSource, serviceDocument.BaseAddress, source.PackageSource);
resource = new MetadataResourceV2Feed(parser, source);
}
return(new Tuple <bool, INuGetResource>(resource != null, resource));
}
public void ReturnResourceResult()
{
var metadata = new GlimpseMetadata();
var storeMock = new Mock <IReadOnlyPersistenceStore>();
storeMock.Setup(s => s.GetMetadata()).Returns(metadata);
var contextMock = new Mock <IResourceContext>();
contextMock.Setup(c => c.PersistenceStore).Returns(storeMock.Object);
contextMock.Setup(c => c.Parameters[ResourceParameter.Callback.Name]).Returns("a string");
var resource = new MetadataResource();
var result = resource.Execute(contextMock.Object);
Assert.NotNull(result);
}
private IEnumerable <MetadataResource> ParseResources(XNamespace ns, IEnumerable <XElement> resourceElements)
{
var resources = new List <MetadataResource>();
foreach (var resourceElem in resourceElements)
{
var resource = new MetadataResource
{
ResourceId = resourceElem.Descendants(ns + "ResourceID").FirstOrDefault()?.Value,
StandardName = resourceElem.Descendants(ns + "StandardName").FirstOrDefault()?.Value,
VisibleName = resourceElem.Descendants(ns + "VisibleName").FirstOrDefault()?.Value,
Description = resourceElem.Descendants(ns + "Description").FirstOrDefault()?.Value,
KeyField = resourceElem.Descendants(ns + "KeyField").FirstOrDefault()?.Value,
ClassCount = resourceElem.Descendants(ns + "ClassCount").FirstOrDefault()?.Value,
ClassVersion = resourceElem.Descendants(ns + "ClassVersion").FirstOrDefault()?.Value,
ClassDate = resourceElem.Descendants(ns + "ClassDate").FirstOrDefault()?.Value,
ObjectVersion = resourceElem.Descendants(ns + "ObjectVersion").FirstOrDefault()?.Value,
ObjectDate = resourceElem.Descendants(ns + "ObjectDate").FirstOrDefault()?.Value,
SearchHelpVersion = resourceElem.Descendants(ns + "SearchHelpVersion").FirstOrDefault()?.Value,
SearchHelpDate = resourceElem.Descendants(ns + "SearchHelpDate").FirstOrDefault()?.Value,
EditMaskVersion = resourceElem.Descendants(ns + "EditMaskVersion").FirstOrDefault()?.Value,
EditMaskDate = resourceElem.Descendants(ns + "EditMaskDate").FirstOrDefault()?.Value,
LookupVersion = resourceElem.Descendants(ns + "LookupVersion").FirstOrDefault()?.Value,
LookupDate = resourceElem.Descendants(ns + "LookupDate").FirstOrDefault()?.Value,
UpdateHelpVersion = resourceElem.Descendants(ns + "UpdateHelpVersion").FirstOrDefault()?.Value,
UpdateHelpDate = resourceElem.Descendants(ns + "UpdateHelpDate").FirstOrDefault()?.Value,
ValidationExpressionVersion = resourceElem.Descendants(ns + "ValidationExpressionVersion").FirstOrDefault()?.Value,
ValidationExpressionDate = resourceElem.Descendants(ns + "ValidationExpressionDate").FirstOrDefault()?.Value,
ValidationLookupVersion = resourceElem.Descendants(ns + "ValidationLookupVersion").FirstOrDefault()?.Value,
ValidationLookupDate = resourceElem.Descendants(ns + "ValidationLookupDate").FirstOrDefault()?.Value,
ValidationExternalVersion = resourceElem.Descendants(ns + "ValidationExternalVersion").FirstOrDefault()?.Value,
ValidationExternalDate = resourceElem.Descendants(ns + "ValidationExternalDate").FirstOrDefault()?.Value
};
var metadataClassElem = resourceElem.Descendants(ns + "METADATA-CLASS").FirstOrDefault();
resource.Classes = ParseClasses(ns, metadataClassElem.Descendants(ns + "Class"));
resources.Add(resource);
}
return(resources);
}
async Task <ArtifactAvailableInstances> GetAvailable(MetadataResource meta, NuGetLoggerAdapter logger, string name)
{
var v = new ArtifactAvailableInstances(this, name);
var latest = await meta.GetVersions(name, true, false, _feed.Client.SourceCache, logger, CancellationToken.None);
foreach (var nugetVersion in latest)
{
var vText = nugetVersion.ToNormalizedString();
var sV = SVersion.TryParse(vText);
if (!sV.IsValid)
{
logger.Monitor.Warn($"Unable to parse version '{vText}' for '{name}': {sV.ErrorMessage}");
}
else
{
v = v.WithVersion(sV);
}
}
return(v);
}
protected override Project ExecuteWorkImplementation()
{
var dbResult = m_projectRepository.GetProjectWithUser(m_projectId);
m_metadata = m_metadataRepository
.GetMetadataByProjectIds(new[] { m_projectId }, m_fetchAuthors, m_fetchResponsiblePersons, m_fetchBookTypes)
.FirstOrDefault();
if (m_fetchPageCount)
{
var pageCounts = m_projectRepository.GetAllPageCount(new[] { m_projectId });
var item = pageCounts.FirstOrDefault();
if (item != null)
{
m_pageCount = item.PageCount;
}
}
return(dbResult);
}
private static async Task <bool> IsAlreadyUploadedAsync(MetadataResource resource, PackageIdentity packageId)
{
if (resource == null)
{
// If we couldn't locate the v3 feed, republish the packages
return(false);
}
try
{
return(await resource.Exists(packageId, NullLogger.Instance, default(CancellationToken)));
}
catch (Exception ex)
{
// If we can't read feed info, republish the packages
var exceptionMessage = (ex?.InnerException ?? ex.GetBaseException()).Message;
Log.WriteInformation($"Failed to read package existence {Environment.NewLine}{exceptionMessage}.");
return(false);
}
}
public void Return404ResultIfDataIsMissing()
{
var storeMock = new Mock <IReadOnlyPersistenceStore>();
storeMock.Setup(s => s.GetMetadata()).Returns <GlimpseMetadata>(null);
var contextMock = new Mock <IResourceContext>();
contextMock.Setup(c => c.PersistenceStore).Returns(storeMock.Object);
var resource = new MetadataResource();
var result = resource.Execute(contextMock.Object);
Assert.NotNull(result);
var statusCodeResult = result as StatusCodeResourceResult;
Assert.NotNull(statusCodeResult);
Assert.Equal(404, statusCodeResult.StatusCode);
}
/// <summary>
/// Creates a list of push entries from a set of local artifacts into this feed.
/// </summary>
/// <param name="artifacts">Local artifacts.</param>
/// <returns>The set of push into this feed.</returns>
public override async Task <IEnumerable <ArtifactPush> > CreatePushListAsync(IEnumerable <ILocalArtifact> artifacts)
{
List <ArtifactPush> result = new List <ArtifactPush>();
ILogger logger = InitializeAndGetLogger(Cake);
MetadataResource meta = await _sourceRepository.GetResourceAsync <MetadataResource>();
foreach (ILocalArtifact p in artifacts)
{
PackageIdentity pId = new PackageIdentity(p.ArtifactInstance.Artifact.Name, new NuGetVersion(p.ArtifactInstance.Version.ToNormalizedString()));
if (await meta.Exists(pId, _sourceCache, logger, CancellationToken.None))
{
Cake.Debug($" ==> Feed '{Name}' already contains {p.ArtifactInstance}.");
}
else
{
Cake.Debug($"Package {p.ArtifactInstance} must be published to remote feed '{Name}'.");
result.Add(new ArtifactPush(p, this));
}
}
return(result);
}
public async Task TestAllResourcesForNonExistentPackage(string SourceUrl)
{
string packageId = "nonexistentpackage";
string version = "1.0";
SourceRepository repo = GetSourceRepository(SourceUrl);
DownloadResource downloadResource = await repo.GetResource <DownloadResource>();
Assert.True(downloadResource != null);
Uri downloadMetadata = await downloadResource.GetDownloadUrl(new PackageIdentity(packageId, new NuGetVersion(version)));
Assert.True(downloadMetadata == null);
MetadataResource metadataResource = await repo.GetResource <MetadataResource>();
Assert.True(metadataResource != null);
NuGetVersion latestVersion = await metadataResource.GetLatestVersion(packageId, true, true, CancellationToken.None);
Assert.True(latestVersion == null);
UIMetadataResource uiMetadataResource = await repo.GetResource <UIMetadataResource>();
Assert.True(uiMetadataResource != null);
var result = await uiMetadataResource.GetMetadata(packageId, true, true, CancellationToken.None);
Assert.False(result.Any());
DepedencyInfoResource resource = await repo.GetResource <DepedencyInfoResource>();
//Check if we are able to obtain a resource
Assert.True(resource != null);
List <PackageIdentity> packageIdentities = new List <PackageIdentity>();
packageIdentities.Add(new PackageIdentity(packageId, new NuGetVersion(version)));
IEnumerable <PackageDependencyInfo> packages = await resource.ResolvePackages(packageIdentities, NuGet.Frameworks.NuGetFramework.AnyFramework, true, new CancellationToken());
Assert.True(packages == null || packages.Count() == 0);
}
public override MetadataResource GetLatestMetadataResource(long projectId)
{
if (CanGetLatestMetadata)
{
var metadata = new MetadataResource
{
Id = 14,
Resource = new Resource
{
Project = new Project {
Id = projectId
},
ContentType = ContentTypeEnum.None,
ResourceType = ResourceTypeEnum.ProjectMetadata,
},
VersionNumber = LatestMetadataVersion
};
metadata.Resource.LatestVersion = metadata;
return(metadata);
}
return(null);
}
public void PublishSnapshot(long snapshotId, long projectId, List <string> externalPageIds,
MetadataResource metadata)
{
var snapshotResource = new SnapshotPageIdsResourceContract
{
OrderedPageIds = externalPageIds,
SnapshotId = snapshotId,
ProjectId = projectId,
MetadataResource = new SnapshotMetadataResourceContract
{
Title = metadata.Title,
SubTitle = metadata.SubTitle,
AuthorsLabel = metadata.AuthorsLabel,
RelicAbbreviation = metadata.RelicAbbreviation,
SourceAbbreviation = metadata.SourceAbbreviation,
PublishPlace = metadata.PublishPlace,
PublishDate = metadata.PublishDate,
PublisherText = metadata.PublisherText,
PublisherEmail = metadata.PublisherEmail,
Copyright = metadata.Copyright,
BiblText = metadata.BiblText,
OriginDate = metadata.OriginDate,
NotBefore = metadata.NotBefore,
NotAfter = metadata.NotAfter,
ManuscriptIdno = metadata.ManuscriptIdno,
ManuscriptSettlement = metadata.ManuscriptSettlement,
ManuscriptCountry = metadata.ManuscriptCountry,
ManuscriptRepository = metadata.ManuscriptRepository,
ManuscriptExtent = metadata.ManuscriptExtent,
ManuscriptTitle = metadata.ManuscriptTitle
}
};
var client = m_communicationProvider.GetFulltextServiceClient();
client.CreateSnapshot(snapshotResource);
}
internal async Task InstallInternalAsync(
Project project,
List <Packaging.Core.PackageDependency> packages,
ISourceRepositoryProvider repoProvider,
bool skipAssemblyReferences,
bool ignoreDependencies,
CancellationToken token)
{
foreach (var group in packages.GroupBy(e => e.Id, StringComparer.OrdinalIgnoreCase))
{
if (group.Count() > 1)
{
// throw if a package id appears more than once
throw new InvalidOperationException(VsResources.InvalidPackageList);
}
}
// find the latest package
List <MetadataResource> metadataResources = new List <MetadataResource>();
// create the resources for looking up the latest version
foreach (var repo in repoProvider.GetRepositories())
{
MetadataResource resource = await repo.GetResourceAsync <MetadataResource>();
if (resource != null)
{
metadataResources.Add(resource);
}
}
// find the highest version within the ranges
var idToIdentity = new Dictionary <string, PackageIdentity>(StringComparer.OrdinalIgnoreCase);
foreach (var dep in packages)
{
NuGetVersion highestVersion = null;
if (dep.VersionRange != null &&
VersionComparer.Default.Equals(dep.VersionRange.MinVersion, dep.VersionRange.MaxVersion) &&
dep.VersionRange.MinVersion != null)
{
// this is a single version, not a range
highestVersion = dep.VersionRange.MinVersion;
}
else
{
var tasks = new List <Task <IEnumerable <NuGetVersion> > >();
foreach (var resource in metadataResources)
{
tasks.Add(resource.GetVersions(dep.Id, NullLogger.Instance, token));
}
var versions = await Task.WhenAll(tasks.ToArray());
highestVersion = versions.SelectMany(v => v).Where(v => dep.VersionRange.Satisfies(v)).Max();
}
if (highestVersion == null)
{
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, VsResources.UnknownPackage, dep.Id));
}
if (!idToIdentity.ContainsKey(dep.Id))
{
idToIdentity.Add(dep.Id, new PackageIdentity(dep.Id, highestVersion));
}
}
// Skip assembly references and disable binding redirections should be done together
bool disableBindingRedirects = skipAssemblyReferences;
VSAPIProjectContext projectContext = new VSAPIProjectContext(skipAssemblyReferences, disableBindingRedirects);
await InstallInternalAsync(
project,
idToIdentity.Values.ToList(),
repoProvider,
projectContext,
includePrerelease : false,
ignoreDependencies : ignoreDependencies,
token : token);
}
public void UpdateMetadata(long projectId, int userId, BookData bookData)
{
var now = DateTime.UtcNow;
var lastMetadata = m_metadataRepository.GetLatestMetadataResource(projectId);
var firstManuscript = bookData.ManuscriptDescriptions?.FirstOrDefault();
var authorsString = bookData.Authors != null
? string.Join(", ", bookData.Authors.Select(x => x.Name))
: null;
var metadata = new MetadataResource
{
AuthorsLabel = authorsString,
BiblText = bookData.BiblText,
Comment = string.Empty,
Copyright = bookData.Copyright,
CreatedByUser = m_metadataRepository.Load <User>(userId),
CreateTime = now,
PublisherText = bookData.Publisher?.Text,
PublisherEmail = bookData.Publisher?.Email,
PublishDate = bookData.PublishDate,
PublishPlace = bookData.PublishPlace,
SourceAbbreviation = bookData.SourceAbbreviation,
RelicAbbreviation = bookData.RelicAbbreviation,
Title = bookData.Title,
SubTitle = bookData.SubTitle
};
if (lastMetadata == null)
{
var resource = new Resource
{
Project = m_metadataRepository.Load <Project>(projectId),
ContentType = ContentTypeEnum.None,
Name = "Metadata",
ResourceType = ResourceTypeEnum.ProjectMetadata
};
metadata.Resource = resource;
metadata.VersionNumber = 1;
}
else
{
metadata.Resource = lastMetadata.Resource;
metadata.VersionNumber = lastMetadata.VersionNumber + 1;
}
metadata.Resource.LatestVersion = metadata;
if (firstManuscript != null)
{
metadata.ManuscriptSettlement = firstManuscript.Settlement;
metadata.ManuscriptCountry = firstManuscript.Country;
metadata.ManuscriptExtent = firstManuscript.Extent;
metadata.ManuscriptIdno = firstManuscript.Idno;
metadata.ManuscriptRepository = firstManuscript.Repository;
metadata.ManuscriptTitle = firstManuscript.Title;
metadata.NotBefore = firstManuscript.NotBefore;
metadata.NotAfter = firstManuscript.NotAfter;
metadata.OriginDate = firstManuscript.OriginDate;
}
m_metadataRepository.Create(metadata);
}
public void RequireParameterKeys()
{
var metadata = new MetadataResource();
Assert.NotEmpty(metadata.Parameters);
}
public NuGetPackageExistenceChecker(MetadataResource metadataResource, INuGetSymbolsPackageDownloader symbolsPackageDownloader, ILogger logger)
{
_metadataResource = metadataResource;
_symbolsPackageDownloader = symbolsPackageDownloader;
_logger = logger;
}
public void PublishSnapshot(long snapshotId, long projectId, List <string> externalPageIds, MetadataResource metadata)
{
// Snapshots are not supported in eXistDB storage, uploaded book version is directly published
}
