// Helper
internal static bool EnsureUpdateStore(Type interfaceType, string providerName, bool makeAFlush)
{
using (TimerProfilerFacade.CreateTimerProfiler(interfaceType.ToString()))
{
var newDataTypeDescriptor = BuildNewDataTypeDescriptor(interfaceType);
var oldDataTypeDescriptor = DataMetaDataFacade.GetDataTypeDescriptor(newDataTypeDescriptor.DataTypeId);
if (oldDataTypeDescriptor == null)
{
DataMetaDataFacade.PersistMetaData(newDataTypeDescriptor);
return(false);
}
var dataTypeChangeDescriptor = new DataTypeChangeDescriptor(oldDataTypeDescriptor, newDataTypeDescriptor);
if (!dataTypeChangeDescriptor.AlteredTypeHasChanges)
{
return(false);
}
Log.LogVerbose("DynamicTypeManager", "Updating the store for interface type '{0}' on the '{1}' data provider", interfaceType, providerName);
var updateDataTypeDescriptor = new UpdateDataTypeDescriptor(oldDataTypeDescriptor, newDataTypeDescriptor, providerName);
AlterStore(updateDataTypeDescriptor, makeAFlush);
return(true);
}
}
/// <exclude />
public static Control Render(this IPage page, IEnumerable <IPagePlaceholderContent> placeholderContents, FunctionContextContainer functionContextContainer)
{
Verify.ArgumentNotNull(page, "page");
Verify.ArgumentNotNull(functionContextContainer, "functionContextContainer");
Verify.ArgumentCondition(functionContextContainer.XEmbedableMapper is XEmbeddedControlMapper,
"functionContextContainer", $"Unknown or missing XEmbedableMapper on context container. Use {nameof(GetPageRenderFunctionContextContainer)}().");
CurrentPage = page;
using (GlobalInitializerFacade.CoreIsInitializedScope)
{
string url = PageUrls.BuildUrl(page);
using (TimerProfilerFacade.CreateTimerProfiler(url ?? "(no url)"))
{
var cultureInfo = page.DataSourceId.LocaleScope;
System.Threading.Thread.CurrentThread.CurrentCulture = cultureInfo;
System.Threading.Thread.CurrentThread.CurrentUICulture = cultureInfo;
XEmbeddedControlMapper mapper = (XEmbeddedControlMapper)functionContextContainer.XEmbedableMapper;
XDocument document = TemplateInfo.GetTemplateDocument(page.TemplateId);
ResolvePlaceholders(document, placeholderContents);
Control c = Render(document, functionContextContainer, mapper, page);
return(c);
}
}
}
/// <exclude />
public static void NormalizeXhtmlDocument(XhtmlDocument rootDocument)
{
using (TimerProfilerFacade.CreateTimerProfiler())
{
while (true)
{
XElement nestedDocument = rootDocument.Root.Descendants(XhtmlDocument.XName_html).FirstOrDefault();
if (nestedDocument == null)
{
break;
}
var nestedHead = nestedDocument.Element(XhtmlDocument.XName_head);
var nestedBody = nestedDocument.Element(XhtmlDocument.XName_body);
Verify.IsNotNull(nestedHead, "XHTML document is missing <head /> element");
Verify.IsNotNull(nestedBody, "XHTML document is missing <body /> element");
rootDocument.Root.Add(nestedDocument.Attributes().Except(rootDocument.Root.Attributes(), _nameBasedAttributeComparer));
rootDocument.Head.Add(nestedHead.Nodes());
rootDocument.Head.Add(nestedHead.Attributes().Except(rootDocument.Head.Attributes(), _nameBasedAttributeComparer));
rootDocument.Body.Add(nestedBody.Attributes().Except(rootDocument.Body.Attributes(), _nameBasedAttributeComparer));
nestedDocument.ReplaceWith(nestedBody.Nodes());
}
}
}
internal static void TestEnsureUpdateAllInterfaces()
{
using (TimerProfilerFacade.CreateTimerProfiler())
{
foreach (Type interfaceType in DataProviderRegistry.AllInterfaces)
{
if (!interfaceType.IsAutoUpdateble() || interfaceType.IsGenerated())
{
continue;
}
foreach (string providerName in DataProviderRegistry.GetDataProviderNamesByInterfaceType(interfaceType))
{
try
{
if (DynamicTypeManager.IsEnsureUpdateStoreNeeded(interfaceType))
{
Log.LogError(LogTitle, "Autoupdating the data interface '{0}' on the '{1}' data provider failed!", interfaceType, providerName);
}
}
catch (Exception ex)
{
Log.LogCritical(LogTitle, "Update failed for the interface '{0}' on the '{1}' data provider", interfaceType, providerName);
Log.LogCritical(LogTitle, ex);
}
}
}
}
}
// Helper
internal static bool IsEnsureUpdateStoreNeeded(Type interfaceType)
{
using (TimerProfilerFacade.CreateTimerProfiler())
{
DataTypeDescriptor newDataTypeDescriptor;
if (!TryGetDataTypeDescriptor(interfaceType, out newDataTypeDescriptor))
{
newDataTypeDescriptor = BuildNewDataTypeDescriptor(interfaceType);
}
var oldDataTypeDescriptor = DataMetaDataFacade.GetDataTypeDescriptor(newDataTypeDescriptor.DataTypeId);
if (oldDataTypeDescriptor == null)
{
DataMetaDataFacade.PersistMetaData(newDataTypeDescriptor);
return(false);
}
var dataTypeChangeDescriptor = new DataTypeChangeDescriptor(oldDataTypeDescriptor, newDataTypeDescriptor);
if (!dataTypeChangeDescriptor.AlteredTypeHasChanges)
{
return(false);
}
return(dataTypeChangeDescriptor.AlteredTypeHasChanges);
}
}
/// <exclude />
public static Control AsAspNetControl(this XhtmlDocument xhtmlDocument, IXElementToControlMapper controlMapper)
{
using (TimerProfilerFacade.CreateTimerProfiler())
{
var htmlControl = new HtmlGenericControl("html");
CopyAttributes(xhtmlDocument.Root, htmlControl);
HtmlHead headControl = xhtmlDocument.BuildHtmlHeadControl(controlMapper);
Control bodyControl = xhtmlDocument.Body.AsAspNetControl(controlMapper);
htmlControl.Controls.Add(headControl);
htmlControl.Controls.Add(bodyControl);
PlaceHolder pageHolder = new PlaceHolder();
if (xhtmlDocument.DocumentType != null)
{
string docType = xhtmlDocument.DocumentType.ToString();
var offset = docType.IndexOf("[]", StringComparison.Ordinal);
if (offset >= 0)
{
docType = docType.Remove(offset, 2);
}
pageHolder.Controls.Add(new LiteralControl(docType));
}
pageHolder.Controls.Add(htmlControl);
return(pageHolder);
}
}
public void Delete(IEnumerable <DataSourceId> dataSourceIds)
{
Verify.ArgumentNotNull(dataSourceIds, "dataSourceIds");
using (TimerProfilerFacade.CreateTimerProfiler())
{
Type interfaceType = null;
foreach (DataSourceId dataSourceId in dataSourceIds)
{
if (dataSourceId == null)
{
throw new ArgumentException("datas enumeration may not contain nulls");
}
if (interfaceType == null)
{
interfaceType = dataSourceId.InterfaceType;
}
else if (interfaceType != dataSourceId.InterfaceType)
{
throw new ArgumentException(string.Format("Only one data interface per enumerable type supported"));
}
}
string errorMessage;
if (!DataTypeValidationRegistry.IsValidForProvider(interfaceType, _dataProviderContext.ProviderName, out errorMessage))
{
throw new InvalidOperationException(errorMessage);
}
_sqlDataTypeStoresContainer.Delete(dataSourceIds, _dataProviderContext);
}
}
/// <exclude />
public static Control Render(XDocument document, FunctionContextContainer contextContainer, IXElementToControlMapper mapper, IPage page)
{
using (TimerProfilerFacade.CreateTimerProfiler())
{
ExecuteEmbeddedFunctions(document.Root, contextContainer);
ResolvePageFields(document, page);
NormalizeAspNetForms(document);
if (document.Root.Name != Namespaces.Xhtml + "html")
{
return(new LiteralControl(document.ToString()));
}
XhtmlDocument xhtmlDocument = new XhtmlDocument(document);
NormalizeXhtmlDocument(xhtmlDocument);
ResolveRelativePaths(xhtmlDocument);
PrioritizeHeadNodex(xhtmlDocument);
AppendC1MetaTags(page, xhtmlDocument);
LocalizationParser.Parse(xhtmlDocument);
return(xhtmlDocument.AsAspNetControl(mapper));
}
}
/// <exclude />
public static void NormalizeXhtmlDocument(XhtmlDocument rootDocument)
{
using (TimerProfilerFacade.CreateTimerProfiler())
{
while (true)
{
XElement nestedDocument = rootDocument.Root.Descendants(XhtmlDocument.XName_html).FirstOrDefault();
if (nestedDocument == null)
{
break;
}
var nestedHead = nestedDocument.Element(XhtmlDocument.XName_head);
var nestedBody = nestedDocument.Element(XhtmlDocument.XName_body);
Verify.IsNotNull(nestedHead, "XHTML document is missing <head /> element");
Verify.IsNotNull(nestedBody, "XHTML document is missing <body /> element");
rootDocument.Root.Add(nestedDocument.Attributes().Except(rootDocument.Root.Attributes(), _nameBasedAttributeComparer));
// making <meta property="..." /> from nested documents appear first. We will not filter them later and this ensure desired precedence
bool IsMetaProperty(XElement e) => e.Name.LocalName == "meta" && e.Attribute("property") != null;
rootDocument.Head.AddFirst(nestedHead.Elements().Where(IsMetaProperty));
rootDocument.Head.Add(nestedHead.Nodes().Where(f => !(f is XElement e && IsMetaProperty(e))));
rootDocument.Head.Add(nestedHead.Attributes().Except(rootDocument.Head.Attributes(), _nameBasedAttributeComparer));
rootDocument.Body.Add(nestedBody.Attributes().Except(rootDocument.Body.Attributes(), _nameBasedAttributeComparer));
nestedDocument.ReplaceWith(nestedBody.Nodes());
}
}
}
private static void ResolvePlaceholders(XDocument document, IEnumerable <IPagePlaceholderContent> placeholderContents)
{
using (TimerProfilerFacade.CreateTimerProfiler())
{
var placeHolders =
(from placeholder in document.Descendants(RenderingElementNames.PlaceHolder)
let idAttribute = placeholder.Attribute(RenderingElementNames.PlaceHolderIdAttribute)
where idAttribute != null
select new { Element = placeholder, IdAttribute = idAttribute }).ToList();
foreach (var placeholder in placeHolders)
{
string placeHolderId = placeholder.IdAttribute.Value;
placeholder.IdAttribute.Remove();
IPagePlaceholderContent placeHolderContent =
placeholderContents.FirstOrDefault(f => f.PlaceHolderId == placeHolderId);
XhtmlDocument xhtmlDocument = ParsePlaceholderContent(placeHolderContent);
placeholder.Element.ReplaceWith(xhtmlDocument.Root);
//try
//{
// placeholder.Element.Add(new XAttribute(RenderingElementNames.PlaceHolderIdAttribute, placeHolderId));
//}
//catch (Exception ex)
//{
// throw new InvalidOperationException($"Failed to set id '{placeHolderId}' on element", ex);
//}
}
}
}
/// <exclude />
public static Control Render(XDocument document, FunctionContextContainer contextContainer, IXElementToControlMapper mapper, IPage page)
{
using (TimerProfilerFacade.CreateTimerProfiler())
{
using (Profiler.Measure("Executing embedded functions"))
{
ExecuteEmbeddedFunctions(document.Root, contextContainer);
}
using (Profiler.Measure("Resolving page fields"))
{
ResolvePageFields(document, page);
}
using (Profiler.Measure("Normalizing ASP.NET forms"))
{
NormalizeAspNetForms(document);
}
if (document.Root.Name != RenderingElementNames.Html)
{
return(new LiteralControl(document.ToString()));
}
var xhtmlDocument = new XhtmlDocument(document);
ProcessXhtmlDocument(xhtmlDocument, page);
using (Profiler.Measure("Converting XHTML document into an ASP.NET control"))
{
return(xhtmlDocument.AsAspNetControl(mapper));
}
}
}
public static IQueryable <T> GetData <T>(string providerName)
where T : class, IData
{
using (TimerProfilerFacade.CreateTimerProfiler())
{
return(Call <IDataProvider, IQueryable <T> >(providerName, provider => provider.GetData <T>()));
}
}
public static void Update(string providerName, IEnumerable <IData> dataset)
{
Verify.ArgumentNotNull(dataset, "dataset");
using (TimerProfilerFacade.CreateTimerProfiler())
{
SyncronizedCall <IWritableDataProvider>(providerName, provider => provider.Update(dataset));
}
}
public static void Delete(string providerName, IEnumerable <DataSourceId> dataSourceIds)
{
Verify.ArgumentNotNull(dataSourceIds, "dataSourceIds");
using (TimerProfilerFacade.CreateTimerProfiler())
{
SyncronizedCall <IWritableDataProvider>(providerName, provider => provider.Delete(dataSourceIds));
}
}
/// <exclude />
public static StoreFieldType Deserialize(string serializedData)
{
using (TimerProfiler timerProfiler = TimerProfilerFacade.CreateTimerProfiler())
{
if (string.IsNullOrEmpty(serializedData))
{
throw new ArgumentNullException("serializedData");
}
Dictionary <string, string> dic = StringConversionServices.ParseKeyValueCollection(serializedData);
if (dic.ContainsKey("PhysicalStoreType") == false)
{
throw new ArgumentException("Wrong serialized format");
}
string physicalStoreFieldTypeString = StringConversionServices.DeserializeValue <string>(dic["PhysicalStoreType"]);
PhysicalStoreFieldType physicalStoreFieldType = (PhysicalStoreFieldType)Enum.Parse(typeof(PhysicalStoreFieldType), physicalStoreFieldTypeString);
switch (physicalStoreFieldType)
{
case PhysicalStoreFieldType.String:
if (dic.ContainsKey("Length") == false)
{
throw new ArgumentException("Wrong serialized format");
}
int length = StringConversionServices.DeserializeValueInt(dic["Length"]);
return(new StoreFieldType(physicalStoreFieldType, length));
case PhysicalStoreFieldType.Decimal:
if (dic.ContainsKey("Precision") == false)
{
throw new ArgumentException("Wrong serialized format");
}
if (dic.ContainsKey("Scale") == false)
{
throw new ArgumentException("Wrong serialized format");
}
int precision = StringConversionServices.DeserializeValueInt(dic["Precision"]);
int scale = StringConversionServices.DeserializeValueInt(dic["Scale"]);
return(new StoreFieldType(physicalStoreFieldType, precision, scale));
case PhysicalStoreFieldType.Boolean:
case PhysicalStoreFieldType.DateTime:
case PhysicalStoreFieldType.Guid:
case PhysicalStoreFieldType.Integer:
case PhysicalStoreFieldType.LargeString:
case PhysicalStoreFieldType.Long:
return(new StoreFieldType(physicalStoreFieldType));
}
throw new NotImplementedException();
}
}
public static T GetData <T>(string providerName, IDataId dataId)
where T : class, IData
{
Verify.ArgumentNotNull(dataId, "dataId");
using (TimerProfilerFacade.CreateTimerProfiler())
{
return(Call <IDataProvider, T>(providerName, provider => provider.GetData <T>(dataId)));
}
}
public static List <T> AddNew <T>(string providerName, IEnumerable <T> dataset)
where T : class, IData
{
Verify.ArgumentNotNull(dataset, "dataset");
using (TimerProfilerFacade.CreateTimerProfiler())
{
return(SyncronizedCall <IWritableDataProvider, List <T> >(providerName, provider => provider.AddNew <T>(dataset)));
}
}
public static bool IsLocalizedDataProvider(string providerName)
{
using (TimerProfilerFacade.CreateTimerProfiler())
{
using (_resourceLocker.Locker)
{
var dataProvider = GetDataProvider(providerName);
return(dataProvider is ILocalizedDataProvider);
}
}
}
public static IEnumerable <Type> GetGeneratedInterfaces(string providerName)
{
using (TimerProfilerFacade.CreateTimerProfiler())
{
using (_resourceLocker.Locker)
{
var provider = GetDataProvider <IGeneratedTypesDataProvider>(providerName);
return(provider.GetGeneratedInterfaces());
}
}
}
public static IEnumerable <Type> GetSupportedInterfaces(string providerName)
{
using (TimerProfilerFacade.CreateTimerProfiler(providerName))
{
using (_resourceLocker.Locker)
{
IDataProvider provider = GetDataProvider(providerName);
return(provider.GetSupportedInterfaces());
}
}
}
public static void AlterStore(UpdateDataTypeDescriptor updateDataTypeDescriptor, bool forceCompile)
{
using (TimerProfilerFacade.CreateTimerProfiler())
{
using (_resourceLocker.Locker)
{
var provider = GetDataProvider <IDynamicDataProvider>(updateDataTypeDescriptor.ProviderName);
provider.AlterStore(updateDataTypeDescriptor, forceCompile);
}
}
}
/// <exclude />
public static Control Render(XDocument document, FunctionContextContainer contextContainer, IXElementToControlMapper mapper, IPage page)
{
using (TimerProfilerFacade.CreateTimerProfiler())
{
bool disableCaching = false;
using (Profiler.Measure("Executing embedded functions"))
{
ExecuteFunctionsRec(document.Root, contextContainer, func =>
{
if (!disableCaching && !FunctionAllowsCaching(func))
{
disableCaching = true;
}
return(true);
});
}
if (disableCaching)
{
using (Profiler.Measure("PageRenderer: Disabling HTTP caching as at least one of the functions is not cacheable"))
{
HttpContext.Current?.Response.Cache.SetCacheability(HttpCacheability.NoCache);
}
}
using (Profiler.Measure("Resolving page fields"))
{
ResolvePageFields(document, page);
}
using (Profiler.Measure("Normalizing ASP.NET forms"))
{
NormalizeAspNetForms(document);
}
if (document.Root.Name != RenderingElementNames.Html)
{
return(new LiteralControl(document.ToString()));
}
var xhtmlDocument = new XhtmlDocument(document);
ProcessXhtmlDocument(xhtmlDocument, page);
using (Profiler.Measure("Converting XHTML document into an ASP.NET control"))
{
return(xhtmlDocument.AsAspNetControl(mapper));
}
}
}
// Helper
internal static bool EnsureUpdateStore(Type interfaceType, string providerName, bool makeAFlush)
{
using (TimerProfilerFacade.CreateTimerProfiler(interfaceType.ToString()))
{
var newDataTypeDescriptor = BuildNewDataTypeDescriptor(interfaceType);
var oldDataTypeDescriptor = DataMetaDataFacade.GetDataTypeDescriptor(newDataTypeDescriptor.DataTypeId);
if (interfaceType.IsGenerated())
{
var customFields = oldDataTypeDescriptor.Fields.Where(f => !f.Inherited &&
!oldDataTypeDescriptor.KeyPropertyNames
.Contains(f.Name));
foreach (var field in customFields)
{
newDataTypeDescriptor.Fields.Remove(newDataTypeDescriptor.Fields[field.Name]);
newDataTypeDescriptor.Fields.Add(field);
}
}
if (oldDataTypeDescriptor == null)
{
DataMetaDataFacade.PersistMetaData(newDataTypeDescriptor);
return(false);
}
var dataTypeChangeDescriptor = new DataTypeChangeDescriptor(oldDataTypeDescriptor, newDataTypeDescriptor);
if (!dataTypeChangeDescriptor.AlteredTypeHasChanges)
{
if (dataTypeChangeDescriptor.TypeHasMetaDataChanges)
{
Log.LogInformation(nameof(DynamicTypeManager), $"Updating data type descriptor for type '{newDataTypeDescriptor.GetFullInterfaceName()}'");
DataMetaDataFacade.PersistMetaData(newDataTypeDescriptor);
}
return(false);
}
Log.LogVerbose(nameof(DynamicTypeManager),
"Updating the store for interface type '{0}' on the '{1}' data provider", interfaceType,
providerName);
var updateDataTypeDescriptor = new UpdateDataTypeDescriptor(oldDataTypeDescriptor, newDataTypeDescriptor,
providerName);
AlterStore(updateDataTypeDescriptor, makeAFlush);
return(true);
}
}
public static void CreateStores(string providerName, IReadOnlyCollection <DataTypeDescriptor> typeDescriptors)
{
Verify.ArgumentNotNull(typeDescriptors, "typeDescriptors");
using (TimerProfilerFacade.CreateTimerProfiler())
{
using (_resourceLocker.Locker)
{
var provider = GetDataProvider <IDynamicDataProvider>(providerName);
provider.CreateStores(typeDescriptors);
}
}
}
public static void DropStore(string providerName, DataTypeDescriptor typeDescriptor)
{
Verify.ArgumentNotNull(typeDescriptor, "typeDescriptor");
using (TimerProfilerFacade.CreateTimerProfiler())
{
using (_resourceLocker.Locker)
{
var provider = GetDataProvider <IDynamicDataProvider>(providerName);
provider.DropStore(typeDescriptor);
}
}
}
private void BuildDataProviderNames()
{
using (TimerProfilerFacade.CreateTimerProfiler())
{
var dataProviderSettings = ConfigurationServices.ConfigurationSource.GetSection(DataProviderSettings.SectionName) as DataProviderSettings;
_defaultDynamicTypeDataProviderName = dataProviderSettings.DefaultDynamicTypeDataProviderName;
foreach (DataProviderData data in dataProviderSettings.DataProviderPlugins)
{
_dataProviderNames.Add(data.Name);
}
}
}
public static void Delete(string providerName, IEnumerable <DataSourceId> dataSourceIds)
{
Verify.ArgumentNotNull(dataSourceIds, "dataSourceIds");
using (TimerProfilerFacade.CreateTimerProfiler())
{
DataSourceId firstDataSourceId = dataSourceIds.FirstOrDefault();
if (firstDataSourceId == null)
{
return;
}
SyncronizedCall <IWritableDataProvider>(providerName, provider => provider.Delete(dataSourceIds));
}
}
public static void Update(string providerName, IEnumerable <IData> dataset)
{
Verify.ArgumentNotNull(dataset, "dataset");
using (TimerProfilerFacade.CreateTimerProfiler())
{
IData firstData = dataset.FirstOrDefault();
if (firstData == null)
{
return;
}
SyncronizedCall <IWritableDataProvider>(providerName, provider => provider.Update(dataset));
}
}
internal static bool EnsureUpdateAllInterfaces()
{
using (TimerProfilerFacade.CreateTimerProfiler())
{
bool doFlush = false;
var knownInterfaces = DataProviderRegistry.AllKnownInterfaces.ToList();
if (!knownInterfaces.Contains(typeof(IXmlPageTemplate)))
{
knownInterfaces.Insert(0, typeof(IXmlPageTemplate));
}
foreach (Type interfaceType in knownInterfaces)
{
if (!interfaceType.IsAutoUpdateble() || interfaceType.IsGenerated())
{
continue;
}
foreach (string providerName in DataProviderRegistry.GetDataProviderNamesByInterfaceType(interfaceType))
{
try
{
if (DynamicTypeManager.EnsureUpdateStore(interfaceType, providerName, true))
{
doFlush = true;
}
}
catch (TypeUpdateVersionException)
{
throw;
}
catch (TypeInitializationException tiex)
{
throw new InvalidOperationException("The data type meta stored did not initialize. Check configuration", tiex);
}
catch (Exception ex)
{
Log.LogCritical(LogTitle, "Update failed for the interface '{0}' on the '{1}' data provider", interfaceType, providerName);
Log.LogCritical(LogTitle, ex);
}
}
}
return(doFlush);
}
}
public IQueryable <T> GetData <T>()
where T : class, IData
{
using (TimerProfilerFacade.CreateTimerProfiler(typeof(T).ToString()))
{
string errorMessage;
if (!DataTypeValidationRegistry.IsValidForProvider(typeof(T), _dataProviderContext.ProviderName, out errorMessage))
{
throw new InvalidOperationException(errorMessage);
}
SqlDataTypeStore result = _sqlDataTypeStoresContainer.GetDataTypeStore(typeof(T));
return((IQueryable <T>)result.GetQueryable());
}
}
