public void ProcessRequest(HttpContext context)
{
var functionName = (string)context.Request.RequestContext.RouteData.Values["function"];
var dataCulture = GetCurrentDataCulture(context);
using (var data = new DataConnection())
{
if (!data.Get <IFunctionRoute>().Any())
{
context.Response.StatusCode = (int)HttpStatusCode.NotFound;
return;
}
}
IFunction function;
if (!FunctionFacade.TryGetFunction(out function, functionName))
{
context.Response.StatusCode = (int)HttpStatusCode.NotFound;
return;
}
using (var dataScope = new DataScope(DataScopeIdentifier.Public, dataCulture))
{
var functionResult = FunctionFacade.Execute <object>(function, context.Request.QueryString);
if (functionResult == null)
{
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
return;
}
var xhtmlDocument = functionResult as XhtmlDocument;
if (xhtmlDocument != null)
{
PageRenderer.ExecuteEmbeddedFunctions(xhtmlDocument.Root, new FunctionContextContainer());
PageRenderer.NormalizeXhtmlDocument(xhtmlDocument);
var xhtml = xhtmlDocument.ToString();
xhtml = PageUrlHelper.ChangeRenderingPageUrlsToPublic(functionResult.ToString());
xhtml = MediaUrlHelper.ChangeInternalMediaUrlsToPublic(xhtml);
context.Response.Write(xhtml);
}
else
{
context.Response.Write(functionResult.ToString());
if (functionResult is XNode && function.ReturnType != typeof(XhtmlDocument))
{
context.Response.ContentType = "text/xml";
}
}
}
}
public IHtmlString EvaluateMarkup(XElement element)
{
if (element == null)
{
return(null);
}
var doc = new XElement(element);
PageRenderer.ExecuteEmbeddedFunctions(doc, FunctionContextContainer);
return(new HtmlString(doc.ToString()));
}
private static object EvaluateLazyResult(IEnumerable <XNode> xNodes, FunctionContextContainer context)
{
var resultList = new List <object>();
// Attaching the result to be cached to an XElement, so the cached XObject-s will not be later attached to
// an XDocument and causing a bigger memory leak.
var tempParent = new XElement("t");
foreach (var node in xNodes.Evaluate())
{
node.Remove();
if (node is XElement element)
{
if (element.Name == FunctionXName)
{
var functionTreeNode = (FunctionRuntimeTreeNode)FunctionTreeBuilder.Build(element);
var functionCallResult = functionTreeNode.GetValue(context);
if (functionCallResult != null)
{
if (functionCallResult is XDocument document)
{
functionCallResult = document.Root;
}
resultList.Add(functionCallResult);
if (functionCallResult is XObject || functionCallResult is IEnumerable <XObject> )
{
tempParent.Add(functionCallResult);
}
}
}
else
{
PageRenderer.ExecuteEmbeddedFunctions(element, context);
resultList.Add(element);
tempParent.Add(element);
}
}
else
{
resultList.Add(node);
tempParent.Add(node);
}
}
return(resultList.ToArray());
}
private static object EvaluateLazyResult(object result, FunctionContextContainer context)
{
if (result is XDocument)
{
PageRenderer.ExecuteEmbeddedFunctions((result as XDocument).Root, context);
return(result);
}
if (result is IEnumerable <XNode> )
{
return(EvaluateLazyResult(result as IEnumerable <XNode>, context));
}
return(result);
}
/// <summary>
/// Binds placeholders' content to the related properties on a template definition
/// </summary>
/// <param name="template">The template.</param>
/// <param name="pageContentToRender">The page rendering job.</param>
/// <param name="placeholderProperties">The placeholder properties.</param>
/// <param name="functionContextContainer">The function context container, if not null, nested functions fill be evaluated.</param>
public static void BindPlaceholders(IPageTemplate template,
PageContentToRender pageContentToRender,
IDictionary <string, PropertyInfo> placeholderProperties,
FunctionContextContainer functionContextContainer)
{
Verify.ArgumentNotNull(template, "template");
Verify.ArgumentNotNull(pageContentToRender, "pageContentToRender");
Verify.ArgumentNotNull(placeholderProperties, "placeholderProperties");
foreach (var placeholderContent in pageContentToRender.Contents)
{
string placeholderId = placeholderContent.PlaceHolderId;
if (!placeholderProperties.ContainsKey(placeholderId))
{
continue;
}
XhtmlDocument placeholderXhtml = PageRenderer.ParsePlaceholderContent(placeholderContent);
if (functionContextContainer != null)
{
using (Profiler.Measure($"Evaluating placeholder '{placeholderId}'"))
{
PageRenderer.ExecuteEmbeddedFunctions(placeholderXhtml.Root, functionContextContainer);
}
using (Profiler.Measure("Normalizing XHTML document"))
{
PageRenderer.NormalizeXhtmlDocument(placeholderXhtml);
}
}
PageRenderer.ResolveRelativePaths(placeholderXhtml);
PropertyInfo property = placeholderProperties[placeholderId];
if (!property.ReflectedType.IsInstanceOfType(template))
{
string propertyName = property.Name;
property = template.GetType().GetProperty(property.Name);
Verify.IsNotNull(property, "Failed to find placeholder property '{0}'", propertyName);
}
property.SetValue(template, placeholderXhtml, new object[0]);
}
}
/// <exclude />
protected override void CreateChildControls()
{
if (InnerContent == null)
{
ProcessInternalControls();
}
if (InnerContent != null)
{
var functionContextContainer = _functionContextContainer;
if (functionContextContainer == null && this.NamingContainer is UserControlFunction)
{
var containerFunction = this.NamingContainer as UserControlFunction;
functionContextContainer = containerFunction.FunctionContextContainer;
}
if (functionContextContainer == null)
{
functionContextContainer = PageRenderer.GetPageRenderFunctionContextContainer();
}
var controlMapper = (IXElementToControlMapper)functionContextContainer.XEmbedableMapper;
PageRenderer.ExecuteEmbeddedFunctions(InnerContent, functionContextContainer);
var xhmlDocument = new XhtmlDocument(InnerContent);
PageRenderer.NormalizeXhtmlDocument(xhmlDocument);
PageRenderer.ResolveRelativePaths(xhmlDocument);
if (PageRenderer.CurrentPage != null)
{
PageRenderer.ResolvePageFields(xhmlDocument, PageRenderer.CurrentPage);
}
NormalizeAspNetForms(xhmlDocument);
AddNodesAsControls(xhmlDocument.Body.Nodes(), this, controlMapper);
if (Page.Header != null)
{
MergeHeadSection(xhmlDocument, Page.Header, controlMapper);
}
}
base.CreateChildControls();
}
public XElement RenderDocument(XElement doc)
{
using (Profiler.Measure("Executing C1 functions"))
{
PageRenderer.ExecuteEmbeddedFunctions(doc, FunctionContext);
try
{
var xDoc = new XhtmlDocument(doc);
PageRenderer.NormalizeXhtmlDocument(xDoc);
PageRenderer.ResolveRelativePaths(xDoc);
return(xDoc.Root);
}
catch (ArgumentException)
{
return(doc);
}
}
}
private static XhtmlDocument RenderDataListImpl <T>(XhtmlDocument templateDocument, DataTypeDescriptor typeDescriptor, List <T> dataList, FunctionContextContainer functionContextContainer)
where T : class, IData
{
XhtmlDocument outputDocument = new XhtmlDocument();
if (dataList.Count > 0)
{
Type interfaceType = typeDescriptor.GetInterfaceType();
XElement templateBody = new XElement(templateDocument.Body);
Dictionary <string, PropertyInfo> propertyInfoLookup =
interfaceType.GetPropertiesRecursively(p => typeof(IData).IsAssignableFrom(p.DeclaringType)).ToList().ToDictionary(p => p.Name);
List <string> fieldsWithReferenceRendering = new List <string>();
foreach (PropertyInfo dataPropertyInfo in propertyInfoLookup.Values)
{
Type referencedType = null;
if (dataPropertyInfo.TryGetReferenceType(out referencedType))
{
bool canRender = DataXhtmlRenderingServices.CanRender(referencedType, XhtmlRenderingType.Embedable);
if (canRender)
{
fieldsWithReferenceRendering.Add(dataPropertyInfo.Name);
}
}
}
// any optimization would do wonders
foreach (IData data in dataList)
{
XElement currentRowElementsContainer = new XElement(templateBody);
List <DynamicTypeMarkupServices.FieldReferenceDefinition> references =
DynamicTypeMarkupServices.GetFieldReferenceDefinitions(currentRowElementsContainer, typeDescriptor.TypeManagerTypeName).ToList();
// perf waste - if some props are not used;
Dictionary <string, object> objectValues =
propertyInfoLookup.ToDictionary(f => f.Key, f => f.Value.GetValue(data, new object[] { }));
foreach (DynamicTypeMarkupServices.FieldReferenceDefinition reference in references)
{
object value = null;
if (fieldsWithReferenceRendering.Contains(reference.FieldName))
{
// reference field with rendering...
Type referencedType = null;
if (propertyInfoLookup[reference.FieldName].TryGetReferenceType(out referencedType))
{
if (objectValues[reference.FieldName] != null)
{
IDataReference dataReference = DataReferenceFacade.BuildDataReference(referencedType, objectValues[reference.FieldName]);
try
{
value = DataXhtmlRenderingServices.Render(dataReference, XhtmlRenderingType.Embedable).Root;
}
catch (Exception)
{
value = objectValues[reference.FieldName];
}
}
}
}
else
{
if (objectValues.ContainsKey(reference.FieldName)) // prevents unknown props from creating exceptions
{
value = objectValues[reference.FieldName];
}
}
if (value != null)
{
if (value.GetType() == typeof(DateTime))
{
DateTime dateTimeValue = (DateTime)value;
if (dateTimeValue.TimeOfDay.TotalSeconds > 0)
{
value = string.Format("{0} {1}", dateTimeValue.ToShortDateString(), dateTimeValue.ToShortDateString());
}
else
{
value = dateTimeValue.ToShortDateString();
}
}
if (value.GetType() == typeof(string))
{
string stringValue = (string)value;
if (stringValue.StartsWith("<html") && stringValue.Contains(Namespaces.Xhtml.NamespaceName))
{
try
{
value = XElement.Parse(stringValue);
}
catch { }
}
else if (stringValue.Contains('\n'))
{
string valueEncodedWithBr = HttpUtility.HtmlEncode(stringValue).Replace("\n", "<br/>");
value = XElement.Parse(string.Format("<body xmlns='{0}'>{1}</body>", Namespaces.Xhtml, valueEncodedWithBr)).Nodes();
}
}
}
reference.FieldReferenceElement.ReplaceWith(value);
}
FunctionContextContainer fcc = new FunctionContextContainer(functionContextContainer, objectValues);
PageRenderer.ExecuteEmbeddedFunctions(currentRowElementsContainer, fcc);
outputDocument.Body.Add(currentRowElementsContainer.Elements());
}
}
return(outputDocument);
}
public void ProcessRequest(HttpContext context)
{
OutputCacheHelper.InitializeFullPageCaching(context);
using (var renderingContext = RenderingContext.InitializeFromHttpContext())
{
bool cachingEnabled = false;
string cacheKey = null;
DonutCacheEntry cacheEntry = null;
bool consoleUserLoggedIn = Composite.C1Console.Security.UserValidationFacade.IsLoggedIn();
// "Donut caching" is enabled for logged in users, only if profiling is enabled as well.
if (!renderingContext.CachingDisabled &&
(!consoleUserLoggedIn || renderingContext.ProfilingEnabled))
{
cachingEnabled = OutputCacheHelper.TryGetCacheKey(context, out cacheKey);
if (cachingEnabled)
{
using (Profiler.Measure("Cache lookup"))
{
cacheEntry = OutputCacheHelper.GetFromCache(context, cacheKey);
}
}
}
XDocument document;
var functionContext = PageRenderer.GetPageRenderFunctionContextContainer();
bool allFunctionsExecuted = false;
bool preventResponseCaching = false;
if (cacheEntry != null)
{
document = cacheEntry.Document;
foreach (var header in cacheEntry.OutputHeaders)
{
context.Response.Headers[header.Name] = header.Value;
}
// Making sure this response will not go to the output cache
preventResponseCaching = true;
}
else
{
if (renderingContext.RunResponseHandlers())
{
return;
}
var renderer = PageTemplateFacade.BuildPageRenderer(renderingContext.Page.TemplateId);
var slimRenderer = (ISlimPageRenderer)renderer;
using (Profiler.Measure($"{nameof(ISlimPageRenderer)}.Render"))
{
document = slimRenderer.Render(renderingContext.PageContentToRender, functionContext);
}
allFunctionsExecuted = PageRenderer.ExecuteCacheableFunctions(document.Root, functionContext);
if (cachingEnabled && !allFunctionsExecuted && OutputCacheHelper.ResponseCacheable(context))
{
preventResponseCaching = true;
if (!functionContext.ExceptionsSuppressed)
{
using (Profiler.Measure("Adding to cache"))
{
OutputCacheHelper.AddToCache(context, cacheKey, new DonutCacheEntry(context, document));
}
}
}
}
if (!allFunctionsExecuted)
{
using (Profiler.Measure("Executing embedded functions"))
{
PageRenderer.ExecuteEmbeddedFunctions(document.Root, functionContext);
}
}
using (Profiler.Measure("Resolving page fields"))
{
PageRenderer.ResolvePageFields(document, renderingContext.Page);
}
string xhtml;
if (document.Root.Name == RenderingElementNames.Html)
{
var xhtmlDocument = new XhtmlDocument(document);
PageRenderer.ProcessXhtmlDocument(xhtmlDocument, renderingContext.Page);
PageRenderer.ProcessDocumentHead(xhtmlDocument);
xhtml = xhtmlDocument.ToString();
}
else
{
xhtml = document.ToString();
}
if (renderingContext.PreRenderRedirectCheck())
{
return;
}
xhtml = renderingContext.ConvertInternalLinks(xhtml);
if (GlobalSettingsFacade.PrettifyPublicMarkup)
{
xhtml = renderingContext.FormatXhtml(xhtml);
}
var response = context.Response;
if (preventResponseCaching)
{
context.Response.Cache.SetNoServerCaching();
}
// Disabling ASP.NET cache if there's a logged-in user
if (consoleUserLoggedIn)
{
context.Response.Cache.SetCacheability(HttpCacheability.NoCache);
}
// Inserting performance profiling information
if (renderingContext.ProfilingEnabled)
{
xhtml = renderingContext.BuildProfilerReport();
response.ContentType = "text/xml";
}
response.Write(xhtml);
}
}
public override void ExecuteResult(ControllerContext context)
{
string markup;
using (TimerProfilerFacade.CreateTimerProfiler())
{
var page = PageRenderer.CurrentPage;
var markupBuilder = new StringBuilder();
var sw = new StringWriter(markupBuilder);
var output = new HtmlTextWriter(sw);
IView view;
using (Profiler.Measure("Resolving view for template"))
{
view = FindView(context).View;
}
var viewContext = new ViewContext(context, view, ViewData, TempData, output);
view.Render(viewContext, output);
markup = markupBuilder.ToString();
var xml = XDocument.Parse(markup);
var functionContext = PageRenderer.GetPageRenderFunctionContextContainer();
functionContext = new FunctionContextContainer(functionContext, new Dictionary <string, object>
{
{ "viewContext", viewContext }
});
using (Profiler.Measure("Executing embedded functions"))
{
PageRenderer.ExecuteEmbeddedFunctions(xml.Root, functionContext);
}
using (Profiler.Measure("Resolving pagefields"))
{
PageRenderer.ResolvePageFields(xml, page);
}
var document = new XhtmlDocument(xml);
using (Profiler.Measure("Normalizing html"))
{
PageRenderer.NormalizeXhtmlDocument(document);
}
PageRenderer.ResolveRelativePaths(document);
PageRenderer.AppendC1MetaTags(page, document);
using (Profiler.Measure("Resolving localized strings"))
{
LocalizationParser.Parse(document);
}
markup = document.ToString();
using (Profiler.Measure("Changing 'internal' page urls to 'public'"))
{
markup = PageUrlHelper.ChangeRenderingPageUrlsToPublic(markup);
}
using (Profiler.Measure("Changing 'internal' media urls to 'public'"))
{
markup = MediaUrlHelper.ChangeInternalMediaUrlsToPublic(markup);
}
markup = _mvcContext.FormatXhtml(markup);
}
if (_mvcContext.ProfilingEnabled)
{
markup = _mvcContext.BuildProfilerReport();
context.HttpContext.Response.ContentType = "text/xml";
}
context.HttpContext.Response.Write(markup);
}
private static XhtmlDocument ExecuteNestedFunctions(XhtmlDocument document, FunctionContextContainer functionContextContainer)
{
PageRenderer.ExecuteEmbeddedFunctions(document.Root, functionContextContainer);
return(document);
}
public virtual IHttpActionResult Body([FromBody] string body)
{
InitializeFullPageCaching(System.Web.HttpContext.Current);
if (string.IsNullOrWhiteSpace(body))
{
NotFound();
}
var decrypted = LazyFunctionCallDataProvider.UnprotectFunctionCall(body);
if (decrypted == null)
{
return(NotFound());
}
HttpContext.RewritePath(HttpContext.Request.FilePath, HttpContext.Request.PathInfo, decrypted.QueryString);
using (var data = new DataConnection(PublicationScope.Published, ComposerContext.CultureInfo))
{
// Grab a function object to execute
IFunction function = FunctionFacade.GetFunction(decrypted.FunctionName);
PageRenderer.CurrentPage = PageManager.GetPageById(decrypted.PageId);;
// Execute the function, passing all query string parameters as input parameters
var functionResult = (XhtmlDocument)FunctionFacade.Execute <object>(function, decrypted.Parameters.ToDictionary(d => d.Key, d => (object)d.Value));
// output result
if (functionResult != null)
{
var functionContext = new FunctionContextContainer();
PageRenderer.ExecuteEmbeddedFunctions(functionResult.Root, functionContext);
//PageRenderer.ProcessXhtmlDocument(functionResult, productPage);
using (Profiler.Measure("Normalizing XHTML document"))
{
PageRenderer.NormalizeXhtmlDocument(functionResult);
}
using (Profiler.Measure("Resolving relative paths"))
{
PageRenderer.ResolveRelativePaths(functionResult);
}
using (Profiler.Measure("Parsing localization strings"))
{
LocalizationParser.Parse(functionResult);
}
using (Profiler.Measure("Converting URLs from internal to public format (XhtmlDocument)"))
{
InternalUrls.ConvertInternalUrlsToPublic(functionResult);
}
//TODO: Update C1 Version
//PageRenderer.ProcessDocumentHead(functionResult);
StringBuilder sb = new StringBuilder();
foreach (var node in functionResult.Body.Nodes())
{
sb.Append(node.ToString());
}
return(Json(sb.ToString()));
}
}
return(NotFound());
}
