internal static void PreloadPageCaching()
{
string key = DataScopeManager.CurrentDataScope.ToString() + LocalizationScopeManager.CurrentLocalizationScope;
if (!_preloadedPageDataScopes.Contains(key))
{
lock (_preloadingSyncRoot)
{
if (!_preloadedPageDataScopes.Contains(key))
{
using (var conn = new DataConnection())
{
conn.DisableServices();
var pages = DataFacade.GetData <IPage>().GroupBy(p => p.Id).Evaluate();
if (pages.Count > 0)
{
var dataSourceId = pages.First().First().DataSourceId;
foreach (var pageVersionsGroup in pages)
{
string pageKey = GetCacheKey(pageVersionsGroup.Key, dataSourceId);
_pageCache.Add(pageKey, new ReadOnlyCollection <IPage>(pageVersionsGroup.ToList()));
}
}
}
_preloadedPageDataScopes.Add(key);
}
}
}
if (!_pageStructurePreloaded)
{
lock (_preloadingSyncRoot)
{
if (!_pageStructurePreloaded)
{
var pageStructures = DataFacade.GetData <IPageStructure>().Evaluate();
foreach (var str in pageStructures)
{
_pageStructureCache.Add(str.Id, new ExtendedNullable <PageStructureRecord> {
Value = new PageStructureRecord(str)
});
}
foreach (var pair in pageStructures.GroupBy(ps => ps.ParentId))
{
_childrenCache.Add(pair.Key, new ReadOnlyCollection <Guid>(
pair
.OrderBy(p => p.LocalOrdering)
.Select(v => v.Id).ToList()));
}
_pageStructurePreloaded = true;
}
}
}
}
/// <exclude />
public static IData GetMetaData(Guid pageId, Guid pageVersionId, string definitionName, Type metaDataType)
{
Verify.ArgumentNotNull(definitionName, nameof(definitionName));
Verify.ArgumentNotNull(metaDataType, nameof(metaDataType));
//TODO: Consider caching here
var parameterExpression = Expression.Parameter(metaDataType);
var lambdaExpression = Expression.Lambda(
Expression.And(
Expression.And(
Expression.Equal(
Expression.Property(
parameterExpression,
GetDefinitionPageReferencePropertyInfo(metaDataType)
),
Expression.Constant(pageId, typeof(Guid))
),
Expression.Equal(
Expression.Property(
parameterExpression,
GetDefinitionPageReferencePropertyVersionInfo(metaDataType)
),
Expression.Constant(pageVersionId, typeof(Guid))
)
),
Expression.Equal(
Expression.Property(
parameterExpression,
GetDefinitionNamePropertyInfo(metaDataType)
),
Expression.Constant(definitionName, typeof(string))
)),
parameterExpression
);
using (var conn = new DataConnection())
{
conn.DisableServices();
var whereExpression = ExpressionCreator.Where(DataFacade.GetData(metaDataType).Expression, lambdaExpression);
IEnumerable <IData> dataset = ExpressionHelper.GetCastedObjects <IData>(metaDataType, whereExpression);
return(dataset.SingleOrDefaultOrException("There're multiple meta data on a page. Page '{0}', definition name '{1}', meta type '{2}'",
pageId, definitionName, metaDataType.FullName));
}
}
private static IReadOnlyCollection <IPage> GetAllPageVersions(Guid pageId)
{
string cacheKey = GetCacheKey <IPage>(pageId, Guid.Empty);
IReadOnlyCollection <IPage> allPageVersions = _pageCache.Get(cacheKey);
if (allPageVersions == null)
{
using (var conn = new DataConnection())
{
conn.DisableServices();
allPageVersions = new ReadOnlyCollection <IPage>(
conn.Get <IPage>().Where(p => p.Id == pageId).ToList()
);
}
_pageCache.Add(cacheKey, allPageVersions);
}
return(allPageVersions);
}
/// <exclude />
public static ReadOnlyCollection <IPagePlaceholderContent> GetPlaceholderContent(Guid pageId, Guid versionId)
{
string cacheKey = GetCacheKey <IPagePlaceholderContent>(pageId, versionId);
var result = _placeholderCache.Get(cacheKey);
if (result == null)
{
using (var conn = new DataConnection())
{
conn.DisableServices();
var list = DataFacade.GetData <IPagePlaceholderContent>(false)
.Where(f => f.PageId == pageId && f.VersionId == versionId).ToList();
result = new ReadOnlyCollection <IPagePlaceholderContent>(list);
}
_placeholderCache.Add(cacheKey, result);
}
return(result);
}
