void IContentStorageFilter.Versioned(VersionContentContext context)
{
if (context.ExistingContentItem.Is <TPart>() || context.BuildingContentItem.Is <TPart>())
{
Versioned(context, context.ExistingContentItem.As <TPart>(), context.BuildingContentItem.As <TPart>());
}
}
void IContentPartHandler.Versioned(VersionContentContext context, ContentPart existing, ContentPart building)
{
if (existing is TPart && building is TPart)
{
Versioned(context, (TPart)existing, (TPart)building);
}
}
protected async Task <ContentItem> BuildNewVersionAsync(ContentItem existingContentItem)
{
var buildingContentItem = New(existingContentItem.ContentType);
var latestVersion = await _session
.QueryAsync <ContentItem, ContentItemIndex>(x =>
x.ContentItemId == existingContentItem.ContentItemId &&
x.Latest)
.FirstOrDefault();
if (latestVersion != null)
{
latestVersion.Latest = false;
buildingContentItem.Number = latestVersion.Number + 1;
}
else
{
buildingContentItem.Number = 1;
}
buildingContentItem.ContentItemId = existingContentItem.ContentItemId;
var context = new VersionContentContext
{
Id = existingContentItem.ContentItemId,
ContentType = existingContentItem.ContentType,
ExistingContentItem = existingContentItem,
BuildingContentItem = buildingContentItem,
};
Handlers.Invoke(handler => handler.Versioning(context), _logger);
Handlers.Invoke(handler => handler.Versioned(context), _logger);
return(context.BuildingContentItem);
}
public override void Versioned(VersionContentContext context)
{
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(context.ContentType);
if (contentTypeDefinition == null)
{
return;
}
foreach (var typePartDefinition in contentTypeDefinition.Parts)
{
var partName = typePartDefinition.PartDefinition.Name;
var partType = _contentPartFactory.GetContentPartType(partName) ?? typeof(ContentPart);
var buildingPart = context.BuildingContentItem.Get(partType, partName) as ContentPart;
var existingPart = context.ExistingContentItem.Get(partType, partName) as ContentPart;
if (buildingPart != null && existingPart != null)
{
_partHandlers.Invoke(handler => handler.Versioned(context, existingPart, buildingPart), Logger);
context.BuildingContentItem.Weld(partName, buildingPart);
context.ExistingContentItem.Weld(partName, existingPart);
}
}
}
void IContentHandler.Versioning(VersionContentContext context)
{
if (context.ExistingContentItem.Is <TPart>() || context.BuildingContentItem.Is <TPart>())
{
Versioning(context, context.ExistingContentItem.As <TPart>(), context.BuildingContentItem.As <TPart>());
}
}
protected override void Versioning(VersionContentContext context)
{
foreach (var part in context.BuildingContentItem.Parts)
{
LazyLoadHandlers(part);
}
}
protected override void Versioning(VersionContentContext context)
{
if (context.ContentType == "LocalizedTagCloud")
{
SetupTagCloudLoader(context.BuildingContentItem);
}
base.Versioning(context);
}
public override void Versioning(VersionContentContext context)
{
var infosetPart = context.BuildingContentItem.As <InfosetPart>();
if (infosetPart != null)
{
infosetPart.Infoset = context.ContentItemRecord.Infoset;
infosetPart.VersionInfoset = context.BuildingItemVersionRecord.Infoset;
}
}
private void VersioningSocket(VersionContentContext context)
{
var partOld = context.ExistingContentItem.As <SocketsPart>();
var partNew = context.BuildingContentItem.As <SocketsPart>();
if (partOld != null && partNew != null)
{
// Generate drafts for all the connectors
var connectors = partOld.Sockets.AllSockets.SelectMany(q => q.ConnectorItems);
/* TODO: Lazy version ...
* var drafts = new Lazy<IEnumerable<ConnectorPart>>(() =>
* connectors.Value.Select(c=>{
* var draft = Services.ContentManager.GetDraftRequired<ConnectorPart>(c.ContentItem.Id);
* // Store the version id of the new version
* draft.As<ConnectorPart>().LeftContentVersionId = partNew.ContentItem.VersionRecord.Id;
* return draft;
* }));
* var inverses = new Lazy<IEnumerable<ConnectorPart>>(() => {
*
* });
*/
var inverses = new List <ConnectorPart>();
// TODO: This needs some revision; e.g. on a blog with 1000s of posts, it seems a bit crazy to create connector drafts for all of them,
// perhaps only ones we even display an editor for, and in fact only ones that are even edited. The big problem is how to be aware of this.
var drafts = new List <ConnectorPart>();
foreach (var c in connectors)
{
var draft = Services.ContentManager.GetDraftRequired <ConnectorPart>(c.ContentItem.Id);
if (draft == null)
{
continue;
}
// Store the version id of the new version
draft.LeftContentVersionId = partNew.ContentItem.VersionRecord.Id;
drafts.Add(draft);
if (c.InverseConnector != null)
{
// Make inverse draft
var inverse = Services.ContentManager.GetDraftRequired <ConnectorPart>(c.InverseConnector.ContentItem.Id);
inverse.RightContentVersionId = partNew.ContentItem.VersionRecord.Id;
ConnectorPropertyGetHandlers(draft, () => partNew, null, () => inverse);
ConnectorPropertyGetHandlers(inverse, null, () => partNew, () => draft);
}
else
{
ConnectorPropertyGetHandlers(draft, () => partNew, null, null);
}
}
LazyLoadSocketHandlers(partNew, drafts);
}
}
protected virtual ContentItem BuildNewVersion(ContentItem existingContentItem)
{
ContentItemRecord contentItemRecord = existingContentItem.Record;
// locate the existing and the current latest versions, allocate building version
ContentItemVersionRecord existingItemVersionRecord = existingContentItem.VersionRecord;
ContentItemVersionRecord buildingItemVersionRecord = new ContentItemVersionRecord
{
ContentItemRecord = contentItemRecord,
Latest = true,
Published = false,
Data = existingItemVersionRecord.Data,
};
//get the latest version
ContentItemVersionRecord latestVersion = contentItemRecord.Versions.SingleOrDefault(x => x.Latest);
if (latestVersion != null)
{
latestVersion.Latest = false;
buildingItemVersionRecord.Number = latestVersion.Number + 1;
}
else
{
buildingItemVersionRecord.Number = contentItemRecord.Versions.Max(x => x.Number) + 1;
}
//Add new version record
contentItemRecord.Versions.Add(buildingItemVersionRecord);
//Save the version record to the database
_contentItemVersionRepository.Create(buildingItemVersionRecord);
//Create a new contentitem record
ContentItem buildingContentItem = _contentManager.New(existingContentItem.ContentType);
buildingContentItem.VersionRecord = buildingItemVersionRecord;
VersionContentContext context = new VersionContentContext
{
Id = existingContentItem.Id,
ContentType = existingContentItem.ContentType,
ContentItemRecord = contentItemRecord,
ExistingContentItem = existingContentItem,
BuildingContentItem = buildingContentItem,
ExistingItemVersionRecord = existingItemVersionRecord,
BuildingItemVersionRecord = buildingItemVersionRecord,
};
return(context.BuildingContentItem);
}
private void OnVersioning(VersionContentContext context, EntityMetadataPart existing, EntityMetadataPart building)
{
building.Record.FieldMetadataRecords = new List <FieldMetadataRecord>();
foreach (var record in existing.Record.FieldMetadataRecords)
{
var newRecord = new FieldMetadataRecord();
_fieldMetadataRepository.Copy(record, newRecord);
newRecord.OriginalId = record.Id;
newRecord.EntityMetadataRecord = building.Record;
_fieldMetadataRepository.Create(newRecord);
building.Record.FieldMetadataRecords.Add(newRecord);
}
}
protected virtual ContentItem BuildNewVersion(ContentItem existingContentItem, string contentType)
{
var contentItemRecord = existingContentItem.Record;
// locate the existing and the current latest versions, allocate building version
var existingItemVersionRecord = existingContentItem.VersionRecord;
var buildingItemVersionRecord = new ContentItemVersionRecord
{
ContentItemRecord = contentItemRecord,
Latest = true,
Published = false,
Data = existingItemVersionRecord.Data,
};
var latestVersion = contentItemRecord.Versions.SingleOrDefault(x => x.Latest);
if (latestVersion != null)
{
latestVersion.Latest = false;
buildingItemVersionRecord.Number = latestVersion.Number + 1;
}
else
{
buildingItemVersionRecord.Number = contentItemRecord.Versions.Max(x => x.Number) + 1;
}
contentItemRecord.Versions.Add(buildingItemVersionRecord);
_contentItemVersionRepository.Create(buildingItemVersionRecord);
var buildingContentItem = New(contentType);
buildingContentItem.VersionRecord = buildingItemVersionRecord;
var context = new VersionContentContext
{
Id = existingContentItem.Id,
ContentType = existingContentItem.ContentType,
ContentItemRecord = contentItemRecord,
ExistingContentItem = existingContentItem,
BuildingContentItem = buildingContentItem,
ExistingItemVersionRecord = existingItemVersionRecord,
BuildingItemVersionRecord = buildingItemVersionRecord,
};
Handlers.Invoke(handler => handler.Versioning(context), Logger);
Handlers.Invoke(handler => handler.Versioned(context), Logger);
return(context.BuildingContentItem);
}
protected async Task <ContentItem> BuildNewVersionAsync(ContentItem existingContentItem)
{
ContentItem latestVersion;
if (existingContentItem.Latest)
{
latestVersion = existingContentItem;
}
else
{
latestVersion = await _session
.Query <ContentItem, ContentItemIndex>(x =>
x.ContentItemId == existingContentItem.ContentItemId &&
x.Latest)
.FirstOrDefaultAsync();
if (latestVersion != null)
{
_session.Save(latestVersion);
}
}
if (latestVersion != null)
{
latestVersion.Latest = false;
}
// We are not invoking NewAsync as we are cloning an existing item
// This will also prevent the Elements (parts) from being allocated unnecessarily
var buildingContentItem = new ContentItem();
buildingContentItem.ContentType = existingContentItem.ContentType;
buildingContentItem.ContentItemId = existingContentItem.ContentItemId;
buildingContentItem.ContentItemVersionId = _idGenerator.GenerateUniqueId(existingContentItem);
buildingContentItem.DisplayText = existingContentItem.DisplayText;
buildingContentItem.Latest = true;
buildingContentItem.Data = new JObject(existingContentItem.Data);
var context = new VersionContentContext(existingContentItem, buildingContentItem);
await Handlers.InvokeAsync((handler, context) => handler.VersioningAsync(context), context, _logger);
await ReversedHandlers.InvokeAsync((handler, context) => handler.VersionedAsync(context), context, _logger);
return(context.BuildingContentItem);
}
protected void AssignVersioningDates(VersionContentContext context, CommonPart existing, CommonPart building)
{
var utcNow = _clock.UtcNow;
// assign the created date
building.VersionCreatedUtc = utcNow;
// assign modified date for the new version
building.VersionModifiedUtc = utcNow;
// publish date should be null until publish method called
building.VersionPublishedUtc = null;
// assign the created
building.CreatedUtc = existing.CreatedUtc ?? _clock.UtcNow;
// persist any published dates
building.PublishedUtc = existing.PublishedUtc;
// assign modified date for the new version
building.ModifiedUtc = _clock.UtcNow;
}
protected async Task <ContentItem> BuildNewVersionAsync(ContentItem existingContentItem)
{
var buildingContentItem = await NewAsync(existingContentItem.ContentType);
ContentItem latestVersion;
if (existingContentItem.Latest)
{
latestVersion = existingContentItem;
}
else
{
latestVersion = await _session
.Query <ContentItem, ContentItemIndex>(x =>
x.ContentItemId == existingContentItem.ContentItemId &&
x.Latest)
.FirstOrDefaultAsync();
if (latestVersion != null)
{
_session.Save(latestVersion);
}
}
if (latestVersion != null)
{
latestVersion.Latest = false;
}
buildingContentItem.ContentItemId = existingContentItem.ContentItemId;
buildingContentItem.ContentItemVersionId = _idGenerator.GenerateUniqueId(existingContentItem);
buildingContentItem.DisplayText = existingContentItem.DisplayText;
buildingContentItem.Latest = true;
buildingContentItem.Data = new JObject(existingContentItem.Data);
var context = new VersionContentContext(existingContentItem, buildingContentItem);
await Handlers.InvokeAsync(async handler => await handler.VersioningAsync(context), _logger);
await ReversedHandlers.InvokeAsync(async handler => await handler.VersionedAsync(context), _logger);
return(context.BuildingContentItem);
}
protected async Task <ContentItem> BuildNewVersionAsync(ContentItem existingContentItem)
{
var buildingContentItem = New(existingContentItem.ContentType);
ContentItem latestVersion;
if (existingContentItem.Latest)
{
latestVersion = existingContentItem;
}
else
{
latestVersion = await _session
.Query <ContentItem, ContentItemIndex>(x =>
x.ContentItemId == existingContentItem.ContentItemId &&
x.Latest)
.FirstOrDefaultAsync();
}
if (latestVersion != null)
{
latestVersion.Latest = false;
buildingContentItem.Number = latestVersion.Number + 1;
}
else
{
buildingContentItem.Number = 1;
}
buildingContentItem.ContentItemId = existingContentItem.ContentItemId;
buildingContentItem.ContentItemVersionId = _idGenerator.GenerateUniqueId(existingContentItem);
buildingContentItem.Latest = true;
buildingContentItem.Data = new JObject(existingContentItem.Data);
var context = new VersionContentContext(existingContentItem, buildingContentItem);
Handlers.Invoke(handler => handler.Versioning(context), _logger);
Handlers.Reverse().Invoke(handler => handler.Versioned(context), _logger);
return(context.BuildingContentItem);
}
public override async Task VersionedAsync(VersionContentContext context)
{
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(context.ContentItem.ContentType);
if (contentTypeDefinition == null)
{
return;
}
foreach (var typePartDefinition in contentTypeDefinition.Parts)
{
var partName = typePartDefinition.PartDefinition.Name;
var activator = _contentPartFactory.GetTypeActivator(partName);
var buildingPart = (ContentPart)context.BuildingContentItem.Get(activator.Type, partName);
var existingPart = (ContentPart)context.ContentItem.Get(activator.Type, typePartDefinition.Name);
if (buildingPart != null && existingPart != null)
{
await _partHandlers.InvokeAsync(async handler => await handler.VersionedAsync(context, existingPart, buildingPart), Logger);
}
}
}
private void OnVersioned(VersionContentContext context, EntityMetadataPart existing, EntityMetadataPart building)
{
CopyRelationshipRecords(_oneToManyRelationshipRepository, existing.Record, building.Record);
CopyRelationshipRecords(_manyToManyRelationshipRepository, existing.Record, building.Record);
}
protected override void Versioned(VersionContentContext context)
{
base.Versioned(context);
}
protected override void Versioning(VersionContentContext context)
{
VersioningSocket(context);
}
public virtual void Versioned(VersionContentContext context, TPart existing, TPart building)
{
}
protected virtual void Versioning(VersionContentContext context, TPart existing, TPart building)
{
}
public void Versioning(VersionContentContext context)
{
}
public virtual void Versioned(VersionContentContext context) {}
public override Task VersionedAsync(VersionContentContext context)
{
return(TriggerWorkflowEventAsync(nameof(ContentVersionedEvent), context.ContentItem));
}
public void Versioned(VersionContentContext context)
{
}
