protected override TRecord CreateRecordCore(ContentItemVersionRecord versionRecord, TRecord record)
{
record.ContentItemRecord = versionRecord.ContentItemRecord;
record.ContentItemVersionRecord = versionRecord;
_repository.Create(record);
return(record);
}
public virtual ContentItem Get(int id, VersionOptions options, QueryHints hints, string contentType)
{
ContentItem contentItem;
ContentItemVersionRecord versionRecord = null;
var contentTypeDefinition = _contentDefinitionManager.GetTypeDefinition(contentType);
if (contentTypeDefinition == null)
{
contentTypeDefinition = new ContentTypeDefinitionBuilder().Named(contentType).Build();
}
if (hints == QueryHints.Empty)
{
hints = new QueryHints();
}
hints = hints.ExpandRecords(contentTypeDefinition.Parts.Select(c => c.PartDefinition.Name + "Record"));
// do a query to load the records in case Get is called directly
contentItem = GetContentItem(hints, contentTypeDefinition,
(contentItemCriteria, contentItemVersionCriteria) =>
{
contentItemCriteria.Add(Restrictions.Eq("Id", id));
if (options.IsPublished)
{
contentItemVersionCriteria.Add(Restrictions.Eq("Published", true));
}
else if (options.IsLatest)
{
contentItemVersionCriteria.Add(Restrictions.Eq("Latest", true));
}
else if (options.IsDraft && !options.IsDraftRequired)
{
contentItemVersionCriteria.Add(
Restrictions.And(Restrictions.Eq("Published", false),
Restrictions.Eq("Latest", true)));
}
else if (options.IsDraft || options.IsDraftRequired)
{
contentItemVersionCriteria.Add(Restrictions.Eq("Latest", true));
}
if (options.VersionNumber != default(int))
{
contentItemVersionCriteria.Add(Restrictions.Eq("VersionNumber", options.VersionNumber));
}
contentItemVersionCriteria.SetFetchMode("ContentItemRecord", FetchMode.Eager);
contentItemVersionCriteria.SetFetchMode("ContentItemRecord.ContentType", FetchMode.Eager);
contentItemVersionCriteria.SetMaxResults(1);
});
FinalizeContentItem(contentItem, options, contentType);
return(contentItem);
}
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);
}
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);
}
private ContentItem Transform(object[] tuple)
{
ContentItemVersionRecord contentItemVersionRecord = null;
ContentItemRecord contentItemRecord = null;
List <ContentPartRecord> contentParts = new List <ContentPartRecord>();
foreach (var item in tuple)
{
if (item is ContentItemRecord)
{
contentItemRecord = item as ContentItemRecord;
}
else if (item is ContentItemVersionRecord)
{
contentItemVersionRecord = item as ContentItemVersionRecord;
}
else if (item is ContentPartRecord)
{
contentParts.Add(item as ContentPartRecord);
}
}
if (contentItemRecord != null && contentItemVersionRecord != null)
{
contentItemVersionRecord.ContentItemRecord = contentItemRecord;
}
ContentItem contentItem = this.createContentItem(contentTypeDefinition.Name);
if (contentItemVersionRecord != null)
{
contentItem.VersionRecord = contentItemVersionRecord;
}
foreach (var partRecord in contentParts)
{
var partRecordType = partRecord.GetType();
foreach (var part in contentItem.Parts)
{
if (this.partTypeRecordMatchingService.Match(part, partRecord))
{
this.partTypeRecordMatchingService.Set(part, partRecord);
}
}
}
return(contentItem);
}
public int BuildNewContentItemVersion(ContentItem versionToPromote)
{
var readOnlySettings = versionToPromote.Has <ReadOnlySettings>()
? versionToPromote.As <ReadOnlySettings>()
: new ReadOnlySettings()
{
ReadOnly = false
};
if (readOnlySettings.ReadOnly)
{
return(0);
}
var contentItemRecord = versionToPromote.Record;
var newItemVersionRecord = new ContentItemVersionRecord
{
ContentItemRecord = contentItemRecord,
Latest = true,
Published = false,
Data = contentItemRecord.Data,
};
var latestVersion = contentItemRecord.Versions.SingleOrDefault(x => x.Latest);
if (latestVersion != null)
{
latestVersion.Latest = false;
newItemVersionRecord.Number = latestVersion.Number + 1;
}
else
{
newItemVersionRecord.Number = contentItemRecord.Versions.Max(x => x.Number) + 1;
}
contentItemRecord.Versions.Add(newItemVersionRecord);
_contentItemVersionRepository.Create(newItemVersionRecord);
var newContentItem = _contentManager.New(versionToPromote.ContentType);
newContentItem.VersionRecord = newItemVersionRecord;
return(newContentItem.Version);
}
public bool Promote(int id, int versionId)
{
//Get the last version number to create a new version
int lastversionNumber = _contentManager.GetAllVersions(id).Max(r => r.VersionRecord.Number);
//Retrieve the content item to clone
ContentItem contentItem = _contentManager.Get(id, VersionOptions.VersionRecord(versionId));
if (contentItem == null)
{
_notifier.Error(T("Could not find content with id {0}", id));
return(false);
}
int versionOfContentItemToClone = contentItem.VersionRecord.Number;
//Unfortunately it creates not a new record but updates the old record
_contentManager.Create(contentItem, VersionOptions.Number(lastversionNumber + 1));
//var newContent = BuildNewVersion(contentItem);
//Update the table that a new version is added
ContentItemVersionRecord previousLastRecord =
_versionManagerDataService.ContentItemVersionRecords.FirstOrDefault(
r => r.ContentItemRecord.Id == id && r.Latest);
ContentItemVersionRecord newLastRecord =
_versionManagerDataService.ContentItemVersionRecords.Where(r => r.ContentItemRecord.Id == contentItem.Id)
.OrderByDescending(r => r.Number)
.FirstOrDefault();
if (previousLastRecord != null && newLastRecord != null)
{
previousLastRecord.Latest = false;
newLastRecord.Latest = true;
_versionManagerDataService.SetContentItemVersionRecord(previousLastRecord);
_versionManagerDataService.SetContentItemVersionRecord(newLastRecord);
}
_notifier.Information(T("Successfully promoted version {0} to {1}.", versionOfContentItemToClone,
lastversionNumber + 1));
return(true);
}
private void RecordAuditTrailEvent(string eventName, IContent content, ContentItemVersionRecord previousContentItemVersion = null, XElement diffGram = null, XElement previousVersionXml = null)
{
var blackList = new[] { "Site" };
if (blackList.Contains(content.ContentItem.ContentType))
{
return;
}
var properties = new Dictionary <string, object> {
{ "Content", content }
};
var metaData = _contentManager.GetItemMetadata(content);
var eventData = new Dictionary <string, object> {
{ "ContentId", content.Id },
{ "ContentIdentity", metaData.Identity.ToString() },
{ "ContentType", content.ContentItem.ContentType },
{ "VersionId", content.ContentItem.Version },
{ "VersionNumber", content.ContentItem.VersionRecord != null ? content.ContentItem.VersionRecord.Number : 0 },
{ "Published", content.ContentItem.VersionRecord != null && content.ContentItem.VersionRecord.Published },
{ "Title", metaData.DisplayText }
};
if (previousContentItemVersion != null)
{
eventData["PreviousVersionId"] = previousContentItemVersion.Id;
eventData["PreviousVersionNumber"] = previousContentItemVersion.Number;
}
if (diffGram != null && previousVersionXml != null)
{
eventData["PreviousVersionXml"] = previousVersionXml.ToString(SaveOptions.DisableFormatting);
eventData["DiffGram"] = diffGram.ToString(SaveOptions.DisableFormatting);
}
_auditTrailManager.CreateRecord <ContentAuditTrailEventProvider>(
eventName,
_wca.GetContext().CurrentUser,
properties,
eventData,
eventFilterKey: "content",
eventFilterData: content.Id.ToString(CultureInfo.InvariantCulture));
}
public virtual ContentItem Get(int id, VersionOptions options)
{
ContentItem contentItem;
ContentItemVersionRecord versionRecord = null;
// obtain the root records based on version options
if (options.VersionRecordId != 0)
{
// short-circuit if item held in session
if (_contentManagerSession.RecallVersionRecordId(options.VersionRecordId, out contentItem))
{
return(contentItem);
}
versionRecord = _contentItemStore.Get(id, options).VersionRecord;
}
else if (options.VersionNumber != 0)
{
// short-circuit if item held in session
if (_contentManagerSession.RecallVersionNumber(id, options.VersionNumber, out contentItem))
{
return(contentItem);
}
versionRecord = _contentItemStore.Get(id, options).VersionRecord;
}
else if (_contentManagerSession.RecallContentRecordId(id, out contentItem))
{
// try to reload a previously loaded published content item
if (options.IsPublished)
{
return(contentItem);
}
versionRecord = contentItem.VersionRecord;
}
// no record means content item is not in db
if (versionRecord == null)
{
// check in memory
var record = _contentItemStore.Get(id, options).VersionRecord;
if (record == null)
{
return(null);
}
versionRecord = record;
}
// return item if obtained earlier in session
if (_contentManagerSession.RecallVersionRecordId(versionRecord.Id, out contentItem))
{
if (options.IsDraftRequired && versionRecord.Published)
{
return(BuildNewVersion(contentItem));
}
return(contentItem);
}
// allocate instance and set record property
contentItem = New(versionRecord.ContentItemRecord.ContentType.Name);
contentItem.VersionRecord = versionRecord;
// store in session prior to loading to avoid some problems with simple circular dependencies
_contentManagerSession.Store(contentItem);
// create a context with a new instance to load
var context = new LoadContentContext(contentItem);
// invoke handlers to acquire state, or at least establish lazy loading callbacks
Handlers.Invoke(handler => handler.Loading(context));
Handlers.Invoke(handler => handler.Loaded(context));
// when draft is required and latest is published a new version is appended
if (options.IsDraftRequired && versionRecord.Published)
{
contentItem = BuildNewVersion(context.ContentItem);
}
return(contentItem);
}
public virtual ContentItem Get(int id, VersionOptions options, QueryHints hints)
{
var session = _contentManagerSession();
ContentItem contentItem;
ContentItemVersionRecord versionRecord = null;
// obtain the root records based on version options
if (options.VersionRecordId != 0)
{
// short-circuit if item held in session
if (session.RecallVersionRecordId(options.VersionRecordId, out contentItem))
{
return(contentItem);
}
versionRecord = _contentItemVersionRepository.Get(options.VersionRecordId);
}
else if (session.RecallContentRecordId(id, out contentItem))
{
// try to reload a previously loaded published content item
if (options.IsPublished)
{
return(contentItem);
}
versionRecord = contentItem.VersionRecord;
}
else
{
// do a query to load the records in case Get is called directly
var contentItemVersionRecords = GetManyImplementation(hints,
(contentItemCriteria, contentItemVersionCriteria) => {
contentItemCriteria.Add(Restrictions.Eq("Id", id));
if (options.IsPublished)
{
contentItemVersionCriteria.Add(Restrictions.Eq("Published", true));
}
else if (options.IsLatest)
{
contentItemVersionCriteria.Add(Restrictions.Eq("Latest", true));
}
else if (options.IsDraft && !options.IsDraftRequired)
{
contentItemVersionCriteria.Add(
Restrictions.And(Restrictions.Eq("Published", false),
Restrictions.Eq("Latest", true)));
}
else if (options.IsDraft || options.IsDraftRequired)
{
contentItemVersionCriteria.Add(Restrictions.Eq("Latest", true));
}
contentItemVersionCriteria.SetFetchMode("ContentItemRecord", FetchMode.Eager);
contentItemVersionCriteria.SetFetchMode("ContentItemRecord.ContentType", FetchMode.Eager);
//contentItemVersionCriteria.SetMaxResults(1);
});
if (options.VersionNumber != 0)
{
versionRecord = contentItemVersionRecords.FirstOrDefault(
x => x.Number == options.VersionNumber) ??
_contentItemVersionRepository.Get(
x => x.ContentItemRecord.Id == id && x.Number == options.VersionNumber);
}
else
{
versionRecord = contentItemVersionRecords.FirstOrDefault();
}
}
// no record means content item is not in db
if (versionRecord == null)
{
// check in memory
var record = _contentItemRepository.Get(id);
if (record == null)
{
return(null);
}
versionRecord = GetVersionRecord(options, record);
if (versionRecord == null)
{
return(null);
}
}
// return item if obtained earlier in session
if (session.RecallVersionRecordId(versionRecord.Id, out contentItem))
{
if (options.IsDraftRequired && versionRecord.Published)
{
return(BuildNewVersion(contentItem));
}
return(contentItem);
}
// allocate instance and set record property
contentItem = New(versionRecord.ContentItemRecord.ContentType.Name);
contentItem.VersionRecord = versionRecord;
// store in session prior to loading to avoid some problems with simple circular dependencies
session.Store(contentItem);
// create a context with a new instance to load
var context = new LoadContentContext(contentItem);
// invoke handlers to acquire state, or at least establish lazy loading callbacks
Handlers.Invoke(handler => handler.Loading(context), Logger);
Handlers.Invoke(handler => handler.Loaded(context), Logger);
// when draft is required and latest is published a new version is appended
if (options.IsDraftRequired && versionRecord.Published)
{
contentItem = BuildNewVersion(context.ContentItem);
}
return(contentItem);
}
public bool SetContentItemVersionRecord(ContentItemVersionRecord record)
{
_contentItemVersionRepository.Update(record);
return(true);
}
public PublishContentContext(ContentItem contentItem, ContentItemVersionRecord previousItemVersionRecord)
: base(contentItem)
{
PublishingItemVersionRecord = contentItem.VersionRecord;
PreviousItemVersionRecord = previousItemVersionRecord;
}
protected override TRecord GetRecordCore(ContentItemVersionRecord versionRecord)
{
return(_repository.Get(versionRecord.Id));
}
