public void Loaded(LoadContentContext context)
{
}
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 (options.VersionNumber != 0)
{
// short-circuit if item held in session
if (session.RecallVersionNumber(id, options.VersionNumber, out contentItem))
{
return(contentItem);
}
versionRecord = _contentItemVersionRepository.Get(x => x.ContentItemRecord.Id == id && x.Number == options.VersionNumber);
}
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.LastOrDefault();
}
}
// 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);
}
protected virtual void Loaded(LoadContentContext context, TPart instance)
{
}
public void Loading(LoadContentContext context)
{
}
public async Task <ContentItem> GetAsync(string contentItemId, VersionOptions options)
{
ContentItem contentItem = null;
// obtain the root records based on version options
if (options.VersionRecordId != 0)
{
if (_contentManagerSession.RecallVersionId(options.VersionRecordId, out contentItem))
{
return(contentItem);
}
contentItem = await _session.GetAsync <ContentItem>(options.VersionRecordId);
}
else if (options.VersionNumber != 0)
{
if (_contentManagerSession.RecallContentItemId(contentItemId, options.VersionNumber, out contentItem))
{
return(contentItem);
}
contentItem = await _session
.QueryAsync <ContentItem, ContentItemIndex>()
.Where(x =>
x.ContentItemId == contentItemId &&
x.Number == options.VersionNumber
)
.FirstOrDefault();
}
else if (options.IsLatest)
{
contentItem = await _session
.QueryAsync <ContentItem, ContentItemIndex>()
.Where(x => x.ContentItemId == contentItemId && x.Latest == true)
.FirstOrDefault();
}
else if (options.IsDraft && !options.IsDraftRequired)
{
contentItem = await _session
.QueryAsync <ContentItem, ContentItemIndex>()
.Where(x =>
x.ContentItemId == contentItemId &&
x.Published == false &&
x.Latest == true)
.FirstOrDefault();
}
else if (options.IsDraft || options.IsDraftRequired)
{
// Loaded whatever is the latest as it will be cloned
contentItem = await _session
.QueryAsync <ContentItem, ContentItemIndex>()
.Where(x =>
x.ContentItemId == contentItemId &&
x.Latest == true)
.FirstOrDefault();
}
else if (options.IsPublished)
{
// If the published version is requested and is already loaded, we can
// return it right away
if (_contentManagerSession.RecallPublishedItemId(contentItemId, out contentItem))
{
return(contentItem);
}
contentItem = await _session
.QueryAsync <ContentItem, ContentItemIndex>()
.Where(x => x.ContentItemId == contentItemId && x.Published == true)
.FirstOrDefault();
}
if (contentItem == null)
{
if (!options.IsDraftRequired)
{
return(null);
}
}
// Return item if obtained earlier in session
// If IsPublished is required then the test has already been checked before
ContentItem recalled = null;
if (!_contentManagerSession.RecallVersionId(contentItem.Id, out recalled))
{
// 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), _logger);
Handlers.Reverse().Invoke(handler => handler.Loaded(context), _logger);
contentItem = context.ContentItem;
}
else
{
contentItem = recalled;
}
if (options.IsDraftRequired)
{
// When draft is required and latest is published a new version is added
if (contentItem.Published)
{
// Save the previous version
_session.Save(contentItem);
contentItem = await BuildNewVersionAsync(contentItem);
}
// Save the new version
_session.Save(contentItem);
}
return(contentItem);
}
public async Task <ContentItem> Get(int contentItemId, VersionOptions options)
{
ContentItem contentItem;
// obtain the root records based on version options
if (options.VersionRecordId != 0)
{
if (_contentManagerSession.RecallVersionId(options.VersionRecordId, out contentItem))
{
return(contentItem);
}
contentItem = await _session.GetAsync <ContentItem>(options.VersionRecordId);
}
else if (options.VersionNumber != 0)
{
if (_contentManagerSession.RecallContentItemId(contentItemId, options.VersionNumber, out contentItem))
{
return(contentItem);
}
contentItem = await _session
.QueryAsync <ContentItem, ContentItemIndex>()
.Where(x =>
x.ContentItemId == contentItemId &&
x.Number == options.VersionNumber
)
.FirstOrDefault();
}
else if (_contentManagerSession.RecallPublishedItemId(contentItemId, out contentItem))
{
if (options.IsPublished)
{
return(contentItem);
}
}
else if (options.IsLatest)
{
contentItem = await _session
.QueryAsync <ContentItem, ContentItemIndex>()
.Where(x => x.ContentItemId == contentItemId && x.Latest == true)
.FirstOrDefault();
}
else if (options.IsDraft && !options.IsDraftRequired)
{
contentItem = await _session
.QueryAsync <ContentItem, ContentItemIndex>()
.Where(x =>
x.ContentItemId == contentItemId &&
x.Published == false &&
x.Latest == true)
.FirstOrDefault();
}
else if (options.IsDraft || options.IsDraftRequired)
{
contentItem = await _session
.QueryAsync <ContentItem, ContentItemIndex>()
.Where(x =>
x.ContentItemId == contentItemId &&
x.Latest == true)
.FirstOrDefault();
}
else if (options.IsPublished)
{
contentItem = await _session
.QueryAsync <ContentItem, ContentItemIndex>()
.Where(x => x.ContentItemId == contentItemId && x.Published == true)
.FirstOrDefault();
}
if (contentItem == null)
{
if (!options.IsDraftRequired)
{
return(null);
}
}
// 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), _logger);
Handlers.Invoke(handler => handler.Loaded(context), _logger);
// when draft is required and latest is published a new version is appended
if (options.IsDraftRequired && contentItem.Published)
{
contentItem = await BuildNewVersionAsync(context.ContentItem);
}
return(contentItem);
}
public virtual void Loaded(LoadContentContext context)
{
}
protected void LazyLoadSmsHandlers(LoadContentContext context, SmsContactPart part)
{
// Add handlers that will load content for id's just-in-time
part.SmsEntries.Loader(() => OnSmsLoader(context));
}
protected override void Loading(LoadContentContext context)
{
base.Loading(context);
}
public override Task LoadingAsync(LoadContentContext context, PricePart part)
{
part.Price = _moneyService.EnsureCurrency(part.Price);
return(base.LoadingAsync(context, part));
}
protected void LazyLoadHandlers(LoadContentContext context, UserProvidersPart part)
{
// Add handlers that will load content for id's just-in-time
part.ProviderEntriesField.Loader(() => OnLoader(context));
}
protected void LazyLoadHandlers(LoadContentContext context, MobileContactPart part)
{
// Add handlers that will load content for id's just-in-time
part.MobileEntries.Loader(() => OnLoader(context));
}
void lazyLoadHandlers(LoadContentContext context, BingMapListPart part)
{
// add handlers that will load content just-in-time
part.BingLocationsField.Loader(() =>
_mapService.GetBingLocations(part.Id));
}
protected override void Loaded(LoadContentContext context)
{
base.Loading(context);
InitilizeLoader(context.ContentItem);
}
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 void Loaded(LoadContentContext context) {}
protected void LazyLoadEmailHandlers(LoadContentContext context, EmailContactPart part)
{
// Add handlers that will load content for id's just-in-time
part.EmailEntries.Loader(() => OnEmailLoader(context));
}
