public AppendOnlyCatalogWriter(Storage storage, int maxPageSize = 1000, bool append = true, ICatalogGraphPersistence catalogGraphPersistence = null, CatalogContext context = null)
: base(storage, catalogGraphPersistence, context)
{
_append = append;
_first = true;
MaxPageSize = maxPageSize;
}
protected override ResourceSaveOperation CreateSaveOperationForItem(IStorage storage, CatalogContext context, CatalogItem item, CancellationToken cancellationToken)
{
// This method decides what to do with the item.
// If it's a RegistrationMakerCatalogItem and it already exists, then don't write content.
var registrationMakerCatalogItem = item as RegistrationMakerCatalogItem;
if (registrationMakerCatalogItem != null)
{
var content = item.CreateContent(Context); // note: always do this first
var resourceUri = item.GetItemAddress();
var saveOperation = new ResourceSaveOperation();
saveOperation.ResourceUri = resourceUri;
if (!registrationMakerCatalogItem.IsExistingItem && content != null)
{
saveOperation.SaveTask = storage.Save(resourceUri, content, cancellationToken);
}
else
{
Trace.WriteLine(string.Format("Resource {0} already exists. Skipping.", resourceUri), "Debug");
}
return saveOperation;
}
return base.CreateSaveOperationForItem(storage, context, item, cancellationToken);
}
public override StorageContent CreateContent(CatalogContext context)
{
using (IGraph graph = new Graph())
{
INode entry = graph.CreateUriNode(GetItemAddress());
// catalog infrastructure fields
graph.Assert(entry, graph.CreateUriNode(Schema.Predicates.Type), graph.CreateUriNode(GetItemType()));
graph.Assert(entry, graph.CreateUriNode(Schema.Predicates.Type), graph.CreateUriNode(Schema.DataTypes.Permalink));
graph.Assert(entry, graph.CreateUriNode(Schema.Predicates.CatalogTimeStamp), graph.CreateLiteralNode(TimeStamp.ToString("O"), Schema.DataTypes.DateTime));
graph.Assert(entry, graph.CreateUriNode(Schema.Predicates.CatalogCommitId), graph.CreateLiteralNode(CommitId.ToString()));
graph.Assert(entry, graph.CreateUriNode(Schema.Predicates.Published), graph.CreateLiteralNode(_published.ToString("O"), Schema.DataTypes.DateTime));
graph.Assert(entry, graph.CreateUriNode(Schema.Predicates.Id), graph.CreateLiteralNode(_id));
graph.Assert(entry, graph.CreateUriNode(Schema.Predicates.OriginalId), graph.CreateLiteralNode(_id));
graph.Assert(entry, graph.CreateUriNode(Schema.Predicates.Version), graph.CreateLiteralNode(_version));
SetIdVersionFromGraph(graph);
// create JSON content
JObject frame = context.GetJsonLdContext("context.Catalog.json", GetItemType());
StorageContent content = new StringStorageContent(Utils.CreateArrangedJson(graph, frame), "application/json", "no-store");
return content;
}
}
public CatalogWriterBase(IStorage storage, ICatalogGraphPersistence graphPersistence = null, CatalogContext context = null)
{
Options.InternUris = false;
Storage = storage;
GraphPersistence = graphPersistence;
Context = context ?? new CatalogContext();
_batch = new List<CatalogItem>();
_open = true;
RootUri = Storage.ResolveUri("index.json");
}
public override StorageContent CreateContent(CatalogContext context)
{
string id = BaseAddress + _name + ".json";
JObject obj = new JObject
{
{ "name", _name },
{ "@id", id },
{ "@type", _type },
{ "@context", new JObject { { "@vocab", "http://test.org/schema#" } } }
};
return new StringStorageContent(obj.ToString(), "application/json");
}
public override StorageContent CreateContent(CatalogContext context)
{
IGraph graph = new Graph();
INode subject = graph.CreateUriNode(GetItemAddress());
graph.Assert(subject, graph.CreateUriNode(Schema.Predicates.Type), graph.CreateUriNode(Schema.DataTypes.Package));
graph.Assert(subject, graph.CreateUriNode(Schema.Predicates.Type), graph.CreateUriNode(Schema.DataTypes.Permalink));
graph.Assert(subject, graph.CreateUriNode(Schema.Predicates.CatalogEntry), graph.CreateUriNode(_catalogUri));
graph.Assert(subject, graph.CreateUriNode(Schema.Predicates.Registration), graph.CreateUriNode(GetRegistrationAddress()));
graph.Assert(subject, graph.CreateUriNode(Schema.Predicates.PackageContent), graph.CreateUriNode(GetPackageContentAddress()));
graph.Assert(subject, graph.CreateUriNode(Schema.Predicates.Published), graph.CreateLiteralNode(GetPublishedDate().ToString("O"), Schema.DataTypes.DateTime));
graph.Assert(subject, graph.CreateUriNode(Schema.Predicates.Listed), graph.CreateLiteralNode(_listed.ToString(), Schema.DataTypes.Boolean));
JObject frame = context.GetJsonLdContext("context.Package.json", Schema.DataTypes.Package);
return new JTokenStorageContent(Utils.CreateJson(graph, frame), "application/json", "no-store");
}
public override StorageContent CreateContent(CatalogContext context)
{
PackagePipelineContext pipelineContext = new PackagePipelineContext(GetBaseAddress());
_pipeline.Execute(_pipelinePackage, pipelineContext);
_pageContent = ((GraphPackageMetadata)pipelineContext.PageResult).Graph;
_itemAddress = pipelineContext.Uri;
JObject frame = context.GetJsonLdContext("context.PackageDetails.json", Schema.DataTypes.PackageDetails);
string json = pipelineContext.Result.ToContent(frame).ToString();
return new StringStorageContent(json, "application/json", "no-store");
}
public override StorageContent CreateContent(CatalogContext context)
{
IGraph catalogEntry = new Graph();
INode catalogEntrySubject = catalogEntry.CreateUriNode(GetItemAddress());
// catalog infrastructure fields
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.Type), catalogEntry.CreateUriNode(GetItemType()));
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.Type), catalogEntry.CreateUriNode(Schema.DataTypes.Permalink));
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.CatalogTimeStamp), catalogEntry.CreateLiteralNode(TimeStamp.ToString("O"), Schema.DataTypes.DateTime));
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.CatalogCommitId), catalogEntry.CreateLiteralNode(CommitId.ToString()));
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.Published), catalogEntry.CreateLiteralNode(_publicationDetails.Published.ToString("O"), Schema.DataTypes.DateTime));
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.TenantId), catalogEntry.CreateLiteralNode(_publicationDetails.TenantId));
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.Tenant), catalogEntry.CreateLiteralNode(_publicationDetails.TenantName));
Uri ownerUri = _publicationDetails.Owner.GetUri(GetItemAddress());
INode ownerSubject = catalogEntry.CreateUriNode(ownerUri);
catalogEntry.Assert(ownerSubject, catalogEntry.CreateUriNode(Schema.Predicates.NameIdentifier), catalogEntry.CreateLiteralNode(_publicationDetails.Owner.NameIdentifier));
catalogEntry.Assert(ownerSubject, catalogEntry.CreateUriNode(Schema.Predicates.Name), catalogEntry.CreateLiteralNode(_publicationDetails.Owner.Name));
catalogEntry.Assert(ownerSubject, catalogEntry.CreateUriNode(Schema.Predicates.GivenName), catalogEntry.CreateLiteralNode(_publicationDetails.Owner.GivenName));
catalogEntry.Assert(ownerSubject, catalogEntry.CreateUriNode(Schema.Predicates.Surname), catalogEntry.CreateLiteralNode(_publicationDetails.Owner.Surname));
catalogEntry.Assert(ownerSubject, catalogEntry.CreateUriNode(Schema.Predicates.Iss), catalogEntry.CreateLiteralNode(_publicationDetails.Owner.Iss));
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.Owner), ownerSubject);
string id = string.Format("{0}/{1}", _packageIdentity.Namespace, _packageIdentity.Id);
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.Id), catalogEntry.CreateLiteralNode(id));
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.OriginalId), catalogEntry.CreateLiteralNode(_packageIdentity.Id));
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.Version), catalogEntry.CreateLiteralNode(_packageIdentity.Version.ToNormalizedString()));
SetIdVersionFromGraph(catalogEntry);
// create JSON content
string json = Utils.CreateJson(catalogEntry, _context);
StorageContent content = new StringStorageContent(json, "application/json", "no-store");
return content;
}
public override IGraph CreatePageContent(CatalogContext context)
{
var resourceUri = new Uri(GetBaseAddress() + GetRelativeAddress());
var graph = new Graph();
var subject = graph.CreateUriNode(resourceUri);
var idPredicate = graph.CreateUriNode(Schema.Predicates.Id);
var versionPredicate = graph.CreateUriNode(Schema.Predicates.Version);
if (_id != null)
{
graph.Assert(subject, idPredicate, graph.CreateLiteralNode(_id));
}
if (_version != null)
{
graph.Assert(subject, versionPredicate, graph.CreateLiteralNode(_version));
}
return graph;
}
public override StorageContent CreateContent(CatalogContext context)
{
IGraph catalogEntry = new Graph();
INode catalogEntrySubject = catalogEntry.CreateUriNode(GetItemAddress());
// catalog infrastructure fields
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.Type), catalogEntry.CreateUriNode(GetItemType()));
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.Type), catalogEntry.CreateUriNode(_itemType));
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.Type), catalogEntry.CreateUriNode(Schema.DataTypes.Permalink));
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.CatalogTimeStamp), catalogEntry.CreateLiteralNode(TimeStamp.ToString("O"), Schema.DataTypes.DateTime));
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.CatalogCommitId), catalogEntry.CreateLiteralNode(CommitId.ToString()));
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.Published), catalogEntry.CreateLiteralNode(_publicationDetails.Published.ToString("O"), Schema.DataTypes.DateTime));
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.TenantId), catalogEntry.CreateLiteralNode(_publicationDetails.TenantId));
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.Tenant), catalogEntry.CreateLiteralNode(_publicationDetails.TenantName));
Uri ownerUri = _publicationDetails.Owner.GetUri(GetItemAddress());
INode ownerSubject = catalogEntry.CreateUriNode(ownerUri);
catalogEntry.Assert(ownerSubject, catalogEntry.CreateUriNode(Schema.Predicates.NameIdentifier), catalogEntry.CreateLiteralNode(_publicationDetails.Owner.NameIdentifier));
//catalogEntry.Assert(ownerSubject, catalogEntry.CreateUriNode(Schema.Predicates.Name), catalogEntry.CreateLiteralNode(_publicationDetails.Owner.Name));
catalogEntry.Assert(ownerSubject, catalogEntry.CreateUriNode(Schema.Predicates.GivenName), catalogEntry.CreateLiteralNode(_publicationDetails.Owner.GivenName));
catalogEntry.Assert(ownerSubject, catalogEntry.CreateUriNode(Schema.Predicates.Surname), catalogEntry.CreateLiteralNode(_publicationDetails.Owner.Surname));
//catalogEntry.Assert(ownerSubject, catalogEntry.CreateUriNode(Schema.Predicates.Iss), catalogEntry.CreateLiteralNode(_publicationDetails.Owner.Iss));
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.Owner), ownerSubject);
// visibility
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.Visibility), catalogEntry.CreateLiteralNode(_publicationDetails.Visibility.Visibility.ToString()));
switch (_publicationDetails.Visibility.Visibility)
{
case PublicationVisibility.VisibilityScope.Organization:
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.Organization), catalogEntry.CreateLiteralNode(_publicationDetails.Visibility.Organization));
break;
case PublicationVisibility.VisibilityScope.Subscription:
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.Subscription), catalogEntry.CreateLiteralNode(_publicationDetails.Visibility.Subscription));
break;
}
// listed
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.Listed), catalogEntry.CreateLiteralNode(_isListed.ToString(), Schema.DataTypes.Boolean));
// add the nuspec metadata
Uri nuspecSubject = _nuspec["@id"].ToObject<Uri>();
IGraph nuspecGraph = Utils.CreateGraph(_nuspec);
// Any statements made about this @id in the nuspec we want to make about the catalog items @id
// - catalog readers can then apply this logic in reverse
// - by so doing the catalog entry becomes an audit entry for the data
catalogEntry.Merge(nuspecGraph, false);
foreach (Triple triple in catalogEntry.GetTriplesWithSubject(catalogEntry.CreateUriNode(nuspecSubject)))
{
catalogEntry.Assert(catalogEntrySubject, triple.Predicate.CopyNode(catalogEntry), triple.Object.CopyNode(catalogEntry));
}
GraphHelpers.MaterializeInference(catalogEntry);
SetIdVersionFromGraph(catalogEntry);
// create JSON content
string json = Utils.CreateJson(catalogEntry, _context);
StorageContent content = new StringStorageContent(json, "application/json", "no-store");
return content;
}
public override IGraph CreatePageContent(CatalogContext context)
{
try
{
IGraph content;
using (TripleStore store = new TripleStore())
{
store.Add(_catalogItem, true);
SparqlParameterizedString sparql = new SparqlParameterizedString();
sparql.CommandText = Utils.GetResource("sparql.ConstructPackagePageContentGraph.rq");
sparql.SetUri("package", GetItemAddress());
sparql.SetUri("catalogPackage", _catalogUri);
sparql.SetUri("baseAddress", BaseAddress);
sparql.SetUri("packageContent", GetPackageContentAddress());
sparql.SetUri("registrationBaseAddress", _registrationBaseAddress);
content = SparqlHelpers.Construct(store, sparql.ToString());
}
return content;
}
catch (Exception e)
{
throw new Exception(string.Format("Exception processing catalog item {0}", _catalogUri), e);
}
}
public RegistrationCatalogWriter(Storage storage, int partitionSize = 100, IList<Uri> cleanUpList = null, ICatalogGraphPersistence graphPersistence = null, CatalogContext context = null)
: base(storage, graphPersistence, context)
{
_cleanUpList = cleanUpList;
PartitionSize = partitionSize;
}
public override IGraph CreatePageContent(CatalogContext context)
{
return _pageContent;
}
public override StorageContent CreateContent(CatalogContext context)
{
return new StringStorageContent(string.Format("item {0}", _id));
}
protected virtual ResourceSaveOperation CreateSaveOperationForItem(IStorage storage, CatalogContext context, CatalogItem item, CancellationToken cancellationToken)
{
// This method decides what to do with the item.
// Standard method of operation: if content == null, don't do a thing. Else, write content.
var content = item.CreateContent(Context); // note: always do this first
var resourceUri = item.GetItemAddress();
var operation = new ResourceSaveOperation();
operation.ResourceUri = resourceUri;
if (content != null)
{
operation.SaveTask = storage.Save(resourceUri, content, cancellationToken);
}
return operation;
}
public virtual StorageContent CreateContent(CatalogContext context)
{
return null;
}
/// <summary>
/// Create the core graph used in CreateContent(context)
/// </summary>
public virtual IGraph CreateContentGraph(CatalogContext context)
{
return null;
}
public override StorageContent CreateContent(CatalogContext context)
{
// metadata from nuspec
using (IGraph graph = CreateContentGraph(context))
{
// catalog infrastructure fields
INode rdfTypePredicate = graph.CreateUriNode(Schema.Predicates.Type);
INode timeStampPredicate = graph.CreateUriNode(Schema.Predicates.CatalogTimeStamp);
INode commitIdPredicate = graph.CreateUriNode(Schema.Predicates.CatalogCommitId);
Triple resource = graph.GetTriplesWithPredicateObject(rdfTypePredicate, graph.CreateUriNode(GetItemType())).First();
graph.Assert(resource.Subject, timeStampPredicate, graph.CreateLiteralNode(TimeStamp.ToString("O"), Schema.DataTypes.DateTime));
graph.Assert(resource.Subject, commitIdPredicate, graph.CreateLiteralNode(CommitId.ToString()));
// create JSON content
JObject frame = context.GetJsonLdContext("context.PackageDetails.json", GetItemType());
StorageContent content = new StringStorageContent(Utils.CreateArrangedJson(graph, frame), "application/json", "no-store");
return content;
}
}
public override IGraph CreateContentGraph(CatalogContext context)
{
XDocument nuspec = NormalizeNuspecNamespace(_nupkgMetadata.Nuspec, context.GetXslt("xslt.normalizeNuspecNamespace.xslt"));
IGraph graph = CreateNuspecGraph(nuspec, GetBaseAddress(), context.GetXslt("xslt.nuspec.xslt"));
// catalog infrastructure fields
INode rdfTypePredicate = graph.CreateUriNode(Schema.Predicates.Type);
INode permanentType = graph.CreateUriNode(Schema.DataTypes.Permalink);
Triple resource = graph.GetTriplesWithPredicateObject(rdfTypePredicate, graph.CreateUriNode(GetItemType())).First();
graph.Assert(resource.Subject, rdfTypePredicate, permanentType);
// published
INode publishedPredicate = graph.CreateUriNode(Schema.Predicates.Published);
DateTime published = _publishedDate ?? TimeStamp;
graph.Assert(resource.Subject, publishedPredicate, graph.CreateLiteralNode(published.ToString("O"), Schema.DataTypes.DateTime));
// listed
INode listedPredicated = graph.CreateUriNode(Schema.Predicates.Listed);
Boolean listed = GetListed(published);
graph.Assert(resource.Subject, listedPredicated, graph.CreateLiteralNode(listed.ToString(), Schema.DataTypes.Boolean));
// created
INode createdPredicate = graph.CreateUriNode(Schema.Predicates.Created);
DateTime created = _createdDate ?? TimeStamp;
graph.Assert(resource.Subject, createdPredicate, graph.CreateLiteralNode(created.ToString("O"), Schema.DataTypes.DateTime));
// lastEdited
INode lastEditedPredicate = graph.CreateUriNode(Schema.Predicates.LastEdited);
DateTime lastEdited = _lastEditedDate ?? DateTime.MinValue;
graph.Assert(resource.Subject, lastEditedPredicate, graph.CreateLiteralNode(lastEdited.ToString("O"), Schema.DataTypes.DateTime));
// entries
if (_nupkgMetadata.Entries != null)
{
INode packageEntryPredicate = graph.CreateUriNode(Schema.Predicates.PackageEntry);
INode packageEntryType = graph.CreateUriNode(Schema.DataTypes.PackageEntry);
INode fullNamePredicate = graph.CreateUriNode(Schema.Predicates.FullName);
INode namePredicate = graph.CreateUriNode(Schema.Predicates.Name);
INode lengthPredicate = graph.CreateUriNode(Schema.Predicates.Length);
INode compressedLengthPredicate = graph.CreateUriNode(Schema.Predicates.CompressedLength);
foreach (PackageEntry entry in _nupkgMetadata.Entries)
{
Uri entryUri = new Uri(resource.Subject.ToString() + "#" + entry.FullName);
INode entryNode = graph.CreateUriNode(entryUri);
graph.Assert(resource.Subject, packageEntryPredicate, entryNode);
graph.Assert(entryNode, rdfTypePredicate, packageEntryType);
graph.Assert(entryNode, fullNamePredicate, graph.CreateLiteralNode(entry.FullName));
graph.Assert(entryNode, namePredicate, graph.CreateLiteralNode(entry.Name));
graph.Assert(entryNode, lengthPredicate, graph.CreateLiteralNode(entry.Length.ToString(), Schema.DataTypes.Integer));
graph.Assert(entryNode, compressedLengthPredicate, graph.CreateLiteralNode(entry.CompressedLength.ToString(), Schema.DataTypes.Integer));
}
}
// packageSize and packageHash
graph.Assert(resource.Subject, graph.CreateUriNode(Schema.Predicates.PackageSize), graph.CreateLiteralNode(_nupkgMetadata.PackageSize.ToString(), Schema.DataTypes.Integer));
graph.Assert(resource.Subject, graph.CreateUriNode(Schema.Predicates.PackageHash), graph.CreateLiteralNode(_nupkgMetadata.PackageHash));
graph.Assert(resource.Subject, graph.CreateUriNode(Schema.Predicates.PackageHashAlgorithm), graph.CreateLiteralNode("SHA512"));
// identity and version
SetIdVersionFromGraph(graph);
return graph;
}
public override IGraph CreateContentGraph(CatalogContext context)
{
XDocument original = GetNuspec();
XDocument nuspec = NormalizeNuspecNamespace(original, context.GetXslt("xslt.normalizeNuspecNamespace.xslt"));
IGraph graph = CreateNuspecGraph(nuspec, GetBaseAddress(), context.GetXslt("xslt.nuspec.xslt"));
// catalog infrastructure fields
INode rdfTypePredicate = graph.CreateUriNode(Schema.Predicates.Type);
INode permanentType = graph.CreateUriNode(Schema.DataTypes.Permalink);
Triple resource = graph.GetTriplesWithPredicateObject(rdfTypePredicate, graph.CreateUriNode(GetItemType())).First();
graph.Assert(resource.Subject, rdfTypePredicate, permanentType);
// published
INode publishedPredicate = graph.CreateUriNode(Schema.Predicates.Published);
DateTime published = GetPublished() ?? TimeStamp;
graph.Assert(resource.Subject, publishedPredicate, graph.CreateLiteralNode(published.ToString("O"), Schema.DataTypes.DateTime));
// listed
INode listedPredicated = graph.CreateUriNode(Schema.Predicates.Listed);
Boolean listed = GetListed(published);
graph.Assert(resource.Subject, listedPredicated, graph.CreateLiteralNode(listed.ToString(), Schema.DataTypes.Boolean));
// created
INode createdPredicate = graph.CreateUriNode(Schema.Predicates.Created);
DateTime created = GetCreated() ?? TimeStamp;
graph.Assert(resource.Subject, createdPredicate, graph.CreateLiteralNode(created.ToString("O"), Schema.DataTypes.DateTime));
// lastEdited
INode lastEditedPredicate = graph.CreateUriNode(Schema.Predicates.LastEdited);
DateTime lastEdited = GetLastEdited() ?? DateTime.MinValue;
graph.Assert(resource.Subject, lastEditedPredicate, graph.CreateLiteralNode(lastEdited.ToString("O"), Schema.DataTypes.DateTime));
// licenseNames
string licenseNames = GetLicenseNames();
if (licenseNames != null)
{
INode licenseNamesPredicate = graph.CreateUriNode(Schema.Predicates.LicenseNames);
graph.Assert(resource.Subject, licenseNamesPredicate, graph.CreateLiteralNode(licenseNames));
}
// licenseReportUrl
string licenseReportUrl = GetLicenseReportUrl();
if (licenseReportUrl != null)
{
INode licenseReportUrlPredicate = graph.CreateUriNode(Schema.Predicates.LicenseReportUrl);
graph.Assert(resource.Subject, licenseReportUrlPredicate, graph.CreateLiteralNode(licenseReportUrl));
}
//// refreshed
//INode refreshedPredicate = graph.CreateUriNode(Schema.Predicates.Refreshed);
//DateTime listed = GetRefreshed() ?? TimeStamp;
//graph.Assert(resource.Subject, refreshedPredicate, graph.CreateLiteralNode(listed.ToString("O"), Schema.DataTypes.DateTime));
// entries
IEnumerable<PackageEntry> entries = GetEntries();
if (entries != null)
{
INode packageEntryPredicate = graph.CreateUriNode(Schema.Predicates.PackageEntry);
INode packageEntryType = graph.CreateUriNode(Schema.DataTypes.PackageEntry);
INode fullNamePredicate = graph.CreateUriNode(Schema.Predicates.FullName);
INode namePredicate = graph.CreateUriNode(Schema.Predicates.Name);
INode lengthPredicate = graph.CreateUriNode(Schema.Predicates.Length);
INode compressedLengthPredicate = graph.CreateUriNode(Schema.Predicates.CompressedLength);
foreach (PackageEntry entry in entries)
{
Uri entryUri = new Uri(resource.Subject.ToString() + "#" + entry.FullName);
INode entryNode = graph.CreateUriNode(entryUri);
graph.Assert(resource.Subject, packageEntryPredicate, entryNode);
graph.Assert(entryNode, rdfTypePredicate, packageEntryType);
graph.Assert(entryNode, fullNamePredicate, graph.CreateLiteralNode(entry.FullName));
graph.Assert(entryNode, namePredicate, graph.CreateLiteralNode(entry.Name));
graph.Assert(entryNode, lengthPredicate, graph.CreateLiteralNode(entry.Length.ToString(), Schema.DataTypes.Integer));
graph.Assert(entryNode, compressedLengthPredicate, graph.CreateLiteralNode(entry.CompressedLength.ToString(), Schema.DataTypes.Integer));
}
}
// packageSize and packageHash
long? packageSize = GetPackageSize();
if (packageSize != null)
{
graph.Assert(resource.Subject, graph.CreateUriNode(Schema.Predicates.PackageSize), graph.CreateLiteralNode(packageSize.ToString(), Schema.DataTypes.Integer));
}
string packageHash = GetPackageHash();
if (packageHash != null)
{
graph.Assert(resource.Subject, graph.CreateUriNode(Schema.Predicates.PackageHash), graph.CreateLiteralNode(packageHash));
graph.Assert(resource.Subject, graph.CreateUriNode(Schema.Predicates.PackageHashAlgorithm), graph.CreateLiteralNode("SHA512"));
}
// identity and version
SetIdVersionFromGraph(graph);
// apply addons
foreach (GraphAddon addon in GetAddons())
{
addon.ApplyToGraph(graph, (IUriNode)resource.Subject);
}
return graph;
}
