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) { }