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;
}
}
protected override void Versioned(VersionContentContext context, TPart existing, TPart building)
{
if (OnVersioned != null)
{
OnVersioned(context, existing, building);
}
}
void IContentPartHandler.Versioned(VersionContentContext context, ContentPart existing, ContentPart building)
{
if (existing is TPart && building is TPart)
{
Versioned(context, (TPart)existing, (TPart)building);
}
}
protected override void Versioning(VersionContentContext context)
{
if (context.ContentType == "LocalizedTagCloud")
{
SetupTagCloudLoader(context.BuildingContentItem);
}
base.Versioning(context);
}
public override void Versioning(VersionContentContext context)
{
var utcNow = _clock.UtcNow;
context.BuildingContentItem.CreatedUtc = context.ExistingContentItem.CreatedUtc ?? utcNow;
context.BuildingContentItem.PublishedUtc = context.ExistingContentItem.PublishedUtc;
context.BuildingContentItem.ModifiedUtc = utcNow;
}
void IContentHandler.Versioned(VersionContentContext context)
{
foreach (var filter in Filters.OfType <IContentStorageFilter>())
{
filter.Versioned(context);
}
Versioned(context);
}
void AssignVersioningDates(VersionContentContext context, ContentPart<CommonVersionRecord> existing, ContentPart<CommonVersionRecord> building) {
// assign create/modified dates for the new version
building.Record.CreatedUtc = _clock.UtcNow;
building.Record.ModifiedUtc = _clock.UtcNow;
// publish date should be null until publish method called
building.Record.PublishedUtc = null;
}
public override void Versioning(VersionContentContext context)
{
var utcNow = _clock.UtcNow;
context.BuildingContentItem.CreatedUtc = context.ContentItem.CreatedUtc ?? utcNow;
context.BuildingContentItem.PublishedUtc = context.ContentItem.PublishedUtc;
context.BuildingContentItem.ModifiedUtc = utcNow;
}
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 override void Versioning(VersionContentContext context, ContentPart <TRecord> existing, ContentPart <TRecord> building)
{
// move known ORM values over
_repository.Copy(existing.Record, building.Record);
// only the up-reference to the particular version differs at this point
building.Record.ContentItemVersionRecord = context.BuildingItemVersionRecord;
// push the new instance into the transaction and session
_repository.Create(building.Record);
}
public ContentItem NewVersion(ContentItem existingContentItem)
{
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,
// Always set up version number to max from existing to avoid conflicts
Number = contentItemRecord.Versions.Max(x => x.Number) + 1,
};
var latestVersion = contentItemRecord.Versions.SingleOrDefault(x => x.Latest);
if (latestVersion != null) {
latestVersion.Latest = false;
}
contentItemRecord.Versions.Add(buildingItemVersionRecord);
_contentItemVersionRepository.Create(buildingItemVersionRecord);
var buildingContentItem = _content.New(existingContentItem.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 void SetNewVersionValues(VersionContentContext context, ExtendedMenuItemPart part, ExtendedMenuItemPart newVersionPart)
{
if (newVersionPart.Is<CommonPart>())
{
newVersionPart.As<CommonPart>().VersionModifiedUtc = part.As<CommonPart>().VersionModifiedUtc;
}
}
protected void SetNewVersionValues(VersionContentContext context, VersionInfoPart part, VersionInfoPart newVersionPart)
{
newVersionPart.Draft = true;
newVersionPart.Removed = false;
}
public void Versioning(VersionContentContext context)
{
}
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 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 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 override void Versioned(VersionContentContext context)
{
base.Versioned(context);
}
public virtual void Versioned(VersionContentContext context)
{
}
protected override void Versioning(VersionContentContext context) {
VersioningSocket(context);
}
protected virtual ContentItem BuildNewVersion(ContentItem existingContentItem)
{
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);
_contentStorageManager.Store(buildingItemVersionRecord);
var buildingContentItem = New(existingContentItem.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 override void Versioning(VersionContentContext context) {
foreach (var part in context.BuildingContentItem.Parts) {
LazyLoadHandlers(part);
}
}
protected async Task<ContentItem> BuildNewVersionAsync(ContentItem existingContentItem) {
var contentItemRecord = existingContentItem.Record;
// locate the existing and the current latest versions, allocate building version
var existingItemVersionRecord = existingContentItem.VersionRecord;
var buildingItemVersionRecord = new ContentItemVersionRecord {
ContentItemId = contentItemRecord.Id,
Latest = true,
Published = false,
};
var latestVersion = await _session
.QueryAsync<ContentItemVersionRecord, ContentItemVersionRecordIndex>(x =>
x.ContentItemId == contentItemRecord.Id && x.Latest)
.FirstOrDefault();
if (latestVersion != null) {
latestVersion.Latest = false;
buildingItemVersionRecord.Number = latestVersion.Number + 1;
}
else {
var biggest = await _session.QueryIndexAsync<ContentItemVersionRecordIndex>(x =>
x.ContentItemId == contentItemRecord.Id)
.OrderByDescending(x => x.Number)
.FirstOrDefault();
buildingItemVersionRecord.Number = biggest.Number + 1;
}
buildingItemVersionRecord.ContentItemId = contentItemRecord.Id;
_session.Save(buildingItemVersionRecord);
var buildingContentItem = New(existingContentItem.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 virtual void Versioned(VersionContentContext context)
{
}
void IContentHandler.Versioning(VersionContentContext context)
{
}
protected async Task<ContentItem> BuildNewVersionAsync(ContentItem existingContentItem)
{
var buildingContentItem = New(existingContentItem.ContentType);
ContentItem latestVersion;
if (existingContentItem.Latest)
{
latestVersion = existingContentItem;
}
else
{
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;
buildingContentItem.Latest = true;
var context = new VersionContentContext
{
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 void Versioned(VersionContentContext context)
{
}
public virtual void Versioned(VersionContentContext context, TPart existing, TPart building)
{
}
private static void CopyOwnerAndContainer(VersionContentContext c, CommonAspect c1, CommonAspect c2) {
c2.Owner = c1.Owner;
c2.Container = c1.Container;
}
