/// <summary>
/// Lookup for a content item based on a <see cref="ContentIdentity"/>. If multiple
/// resolvers can give a result, the one with the highest priority is used. As soon as
/// only one content item is returned from resolvers, it is returned as the result.
/// </summary>
/// <param name="contentIdentity">The <see cref="ContentIdentity"/> instance to lookup</param>
/// <returns>The <see cref="ContentItem"/> instance represented by the identity object.</returns>
public ContentItem ResolveIdentity(ContentIdentity contentIdentity) {
var resolvers = _identityResolverSelectors.Value
.Select(x => x.GetResolver(contentIdentity))
.Where(x => x != null)
.OrderByDescending(x => x.Priority);
if (!resolvers.Any())
return null;
IEnumerable<ContentItem> contentItems = null;
foreach (var resolver in resolvers) {
var resolved = resolver.Resolve(contentIdentity).ToArray();
// first pass
if (contentItems == null) {
contentItems = resolved;
}
else { // subsquent passes means we need to intersect
contentItems = contentItems.Intersect(resolved).ToArray();
}
if (contentItems.Count() == 1) {
return contentItems.First();
}
}
return contentItems.FirstOrDefault();
}
public void Set(string id, string contentType)
{
var contentIdentity = new ContentIdentity(id);
_contentTypes[contentIdentity] = contentType;
_allIdentitiesForImport.Add(contentIdentity);
_allIdentitiesForImportStatus[contentIdentity] = false;
}
public ContentItem Get(string id)
{
var contentIdentity = new ContentIdentity(id);
// lookup in local cache
if (_identities.ContainsKey(contentIdentity))
{
return(_identities[contentIdentity]);
}
// no result ? then check if there are some more content items to load from the db
if (_lastIndex == int.MaxValue)
{
// everything has already been loaded from db
return(null);
}
var equalityComparer = new ContentIdentity.ContentIdentityEqualityComparer();
IEnumerable <ContentItem> block;
// load identities in blocks
while ((block = _contentManager.HqlQuery()
.ForVersion(VersionOptions.Latest)
.OrderBy(x => x.ContentItemVersion(), x => x.Asc("Id"))
.Slice(_lastIndex, BulkPage)).Any())
{
foreach (var item in block)
{
_lastIndex++;
// ignore content item if it has already been imported
if (_contentItemIds.ContainsKey(item.Id))
{
continue;
}
var identity = _contentManager.GetItemMetadata(item).Identity;
// ignore content item if the same identity is already present
if (_identities.ContainsKey(identity))
{
continue;
}
_identities.Add(identity, item);
_contentItemIds.Add(item.Id, identity);
if (equalityComparer.Equals(identity, contentIdentity))
{
return(item);
}
}
}
_lastIndex = int.MaxValue;
return(null);
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
ContentIdentity contentIdentity = (ContentIdentity)value;
var o = new JObject();
foreach (var name in contentIdentity.Names)
{
o.Add(new JProperty(name, contentIdentity.Get(name)));
}
o.WriteTo(writer);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
JObject o = JObject.Load(reader);
var contentIdentity = new ContentIdentity();
foreach (var p in o.Properties())
{
if (p.Value != null && p.Value.Type == JTokenType.String)
{
contentIdentity.Add(p.Name, p.Value.ToString());
}
}
return(contentIdentity);
}
public void Store(string id, ContentItem item)
{
var contentIdentity = new ContentIdentity(id);
if (_identities.ContainsKey(contentIdentity))
{
_identities.Remove(contentIdentity);
_contentItemIds.Remove(item.Id);
}
_identities.Add(contentIdentity, item);
if (!_contentItemIds.ContainsKey(item.Id))
{
_contentItemIds.Add(item.Id, contentIdentity);
}
}
public ContentItemMetadata()
{
Identity = new ContentIdentity();
}
public ContentItem Get(string id, VersionOptions versionOptions, string contentTypeHint = null)
{
var contentIdentity = new ContentIdentity(id);
// lookup in local cache
if (_identities.ContainsKey(contentIdentity))
{
if (_draftVersionRecordIds.ContainsKey(_identities[contentIdentity]))
{
//draft was previously created. Recall.
versionOptions = VersionOptions.VersionRecord(_draftVersionRecordIds[_identities[contentIdentity]]);
}
var result = _contentManager.Get(_identities[contentIdentity], versionOptions);
// if two identities are conflicting, then ensure that there types are the same
// e.g., importing a blog as home page (alias=) and the current home page is a page, the blog
// won't be imported, and blog posts will be attached to the page
if (contentTypeHint == null || result.ContentType == contentTypeHint)
{
return(result);
}
}
ContentItem existingItem = _contentManager.ResolveIdentity(contentIdentity);
//ensure we have the correct version
if (existingItem != null)
{
existingItem = _contentManager.Get(existingItem.Id, versionOptions);
}
if (existingItem == null && _identities.ContainsKey(contentIdentity))
{
existingItem = _contentManager.Get(_identities[contentIdentity], versionOptions);
}
if (existingItem != null)
{
_identities[contentIdentity] = existingItem.Id;
if (versionOptions.IsDraftRequired)
{
_draftVersionRecordIds[existingItem.Id] = existingItem.VersionRecord.Id;
}
return(existingItem);
}
//create item if not found and draft was requested, or it is found later in the import queue
if (versionOptions.IsDraftRequired || _allIdentitiesForImportStatus.ContainsKey(contentIdentity))
{
var contentType = _contentTypes.ContainsKey(contentIdentity) ? _contentTypes[contentIdentity] : contentTypeHint;
if (!_contentTypes.ContainsKey(contentIdentity))
{
throw new ArgumentException("Unknown content type for " + id);
}
var contentItem = _contentManager.Create(contentType, VersionOptions.Draft);
_identities[contentIdentity] = contentItem.Id;
//store versionrecordid in case a draft is requested again
_draftVersionRecordIds[contentItem.Id] = contentItem.VersionRecord.Id;
//add the requested item as a dependency if it is not the currently running item
if (_allIdentitiesForImportStatus.ContainsKey(contentIdentity) &&
!_allIdentitiesForImportStatus[contentIdentity])
{
_dependencyIdentities.Enqueue(contentIdentity);
}
return(contentItem);
}
return(null);
}
public ContentItem Get(string id, string contentTypeHint = null)
{
var contentIdentity = new ContentIdentity(id);
// lookup in local cache
if (_identities.ContainsKey(contentIdentity))
{
var result = _contentManager.Get(_identities[contentIdentity], VersionOptions.DraftRequired);
// if two identities are conflicting, then ensure that there types are the same
// e.g., importing a blog as home page (alias=) and the current home page is a page, the blog
// won't be imported, and blog posts will be attached to the page
if (contentTypeHint == null || result.ContentType == contentTypeHint)
{
return(result);
}
}
// no result ? then check if there are some more content items to load from the db
if (_lastIndex != int.MaxValue)
{
var equalityComparer = new ContentIdentity.ContentIdentityEqualityComparer();
IEnumerable <ContentItem> block;
// load identities in blocks
while ((block = _contentManager.HqlQuery()
.ForVersion(VersionOptions.Latest)
.OrderBy(x => x.ContentItemVersion(), x => x.Asc("Id"))
.Slice(_lastIndex, BulkPage)).Any())
{
foreach (var item in block)
{
_lastIndex++;
// ignore content item if it has already been imported
if (_contentItemIds.ContainsKey(item.Id))
{
continue;
}
var identity = _contentManager.GetItemMetadata(item).Identity;
// ignore content item if the same identity is already present
if (_identities.ContainsKey(identity))
{
continue;
}
_identities.Add(identity, item.Id);
_contentItemIds.Add(item.Id, identity);
if (equalityComparer.Equals(identity, contentIdentity))
{
return(_contentManager.Get(item.Id, VersionOptions.DraftRequired));
}
}
_contentManager.Flush();
_contentManager.Clear();
}
}
_lastIndex = int.MaxValue;
if (!_contentTypes.ContainsKey(contentIdentity))
{
throw new ArgumentException("Unknown content type for " + id);
}
var contentItem = _contentManager.Create(_contentTypes[contentIdentity], VersionOptions.Draft);
_identities[contentIdentity] = contentItem.Id;
_contentItemIds[contentItem.Id] = contentIdentity;
return(contentItem);
}
public void Set(string id, string contentType)
{
var contentIdentity = new ContentIdentity(id);
_contentTypes[contentIdentity] = contentType;
}
public ContentItem Get(string id)
{
var contentIdentity = new ContentIdentity(id);
// lookup in local cache
if (_identities.ContainsKey(contentIdentity))
{
return(_contentManager.Get(_identities[contentIdentity], VersionOptions.DraftRequired));
}
// no result ? then check if there are some more content items to load from the db
if (_lastIndex != int.MaxValue)
{
var equalityComparer = new ContentIdentity.ContentIdentityEqualityComparer();
IEnumerable <ContentItem> block;
// load identities in blocks
while ((block = _contentManager.HqlQuery()
.ForVersion(VersionOptions.Latest)
.OrderBy(x => x.ContentItemVersion(), x => x.Asc("Id"))
.Slice(_lastIndex, BulkPage)).Any())
{
foreach (var item in block)
{
_lastIndex++;
// ignore content item if it has already been imported
if (_contentItemIds.ContainsKey(item.Id))
{
continue;
}
var identity = _contentManager.GetItemMetadata(item).Identity;
// ignore content item if the same identity is already present
if (_identities.ContainsKey(identity))
{
continue;
}
_identities.Add(identity, item.Id);
_contentItemIds.Add(item.Id, identity);
if (equalityComparer.Equals(identity, contentIdentity))
{
return(_contentManager.Get(item.Id, VersionOptions.DraftRequired));
}
}
_contentManager.Flush();
_contentManager.Clear();
}
}
_lastIndex = int.MaxValue;
if (!_contentTypes.ContainsKey(contentIdentity))
{
throw new ArgumentException("Unknown content type for " + id);
}
var contentItem = _contentManager.Create(_contentTypes[contentIdentity], VersionOptions.Draft);
_identities.Add(contentIdentity, contentItem.Id);
_contentItemIds.Add(contentItem.Id, contentIdentity);
return(contentItem);
}
