static string FindAttribute(IDictionary attributes, string key)
{
key = key.ToLowerInvariant();
var attributeValue = attributes.Contains(key) ? attributes[key].ToString() : string.Empty;
return(MacroRenderer.ParseAttribute(null, attributeValue));
}
/// <summary>
/// Renders the macro with the specified alias, passing in the specified parameters.
/// </summary>
/// <param name="alias">The alias.</param>
/// <param name="parameters">The parameters.</param>
/// <returns></returns>
public IHtmlString RenderMacro(string alias, object parameters)
{
var macroRenderer = new MacroRenderer(_requestContext.RegisteredComponents, _requestContext);
var result = macroRenderer.RenderMacroAsString(alias, parameters.ToDictionary <string>(), _controllerContext, false, () => _currentPage);
return(new HtmlString(result));
}
private string RenderMacro(MacroBlockTag macroBlockTag, IEnumerable <Option <ILiquidValue> > args)
{
var macroRenderer = new MacroRenderer();
var expressionConstant = (ILiquidValue)macroRenderer.Render(this, macroBlockTag, _templateContext, args.ToList());
return(ValueCaster.RenderAsString(expressionConstant));
}
public void Macro_Is_File_Based(string macroSource, bool expectedNonNull)
{
var model = new MacroModel {
MacroSource = macroSource
};
var filename = MacroRenderer.GetMacroFileName(model);
if (expectedNonNull)
{
Assert.IsNotNull(filename);
}
else
{
Assert.IsNull(filename);
}
}
/// <summary>
/// Gets the parsed node id. As a nodeid on a item element can be null, an integer or even a squarebracket syntax, this helper method
/// is handy for getting the exact parsed nodeid back.
/// </summary>
/// <returns>The parsed nodeid, the id of the current page OR null if it's not specified</returns>
public int?GetParsedNodeId()
{
if (!String.IsNullOrEmpty(NodeId))
{
string tempNodeId = MacroRenderer.ParseAttribute(PageElements, NodeId);
int nodeIdInt = 0;
if (int.TryParse(tempNodeId, out nodeIdInt))
{
return(nodeIdInt);
}
}
else if (UmbracoContext.Current.PageId != null)
{
return(UmbracoContext.Current.PageId.Value);
}
return(null);
}
public void Macro_Is_File_Based(string macroTypeString, bool expectedNonNull)
{
var macroType = Enum <MacroTypes> .Parse(macroTypeString);
var model = new MacroModel
{
MacroType = macroType,
MacroSource = "anything"
};
var filename = MacroRenderer.GetMacroFileName(model);
if (expectedNonNull)
{
Assert.IsNotNull(filename);
}
else
{
Assert.IsNull(filename);
}
}
public IHtmlString RenderField(IRoutableRequestContext routableRequestContext, ControllerContext controllerContext, Content item,
string fieldAlias = "", string valueAlias = "", string altFieldAlias = "", string altValueAlias = "", string altText = "", string insertBefore = "", string insertAfter = "",
bool recursive = false, bool convertLineBreaks = false, bool removeParagraphTags = false,
RebelRenderItemCaseType casing = RebelRenderItemCaseType.Unchanged,
RebelRenderItemEncodingType encoding = RebelRenderItemEncodingType.Unchanged,
string formatString = "")
{
var sb = new StringBuilder();
var valObj = GetFieldValue(item, fieldAlias, valueAlias, recursive);
if ((valObj == null || valObj.ToString().IsNullOrWhiteSpace()) && !altFieldAlias.IsNullOrWhiteSpace())
{
valObj = GetFieldValue(item, altFieldAlias, altValueAlias, recursive);
}
if ((valObj == null || valObj.ToString().IsNullOrWhiteSpace()) && !altText.IsNullOrWhiteSpace())
{
valObj = altText;
}
if(!formatString.IsNullOrWhiteSpace())
formatString = "{0:" + formatString.Replace("\\", "\\\\").Replace("\"", "\\\"") + "}";
else
formatString = "{0}";
var val = string.Format(formatString, valObj);
if(!val.IsNullOrWhiteSpace())
{
switch (casing)
{
case RebelRenderItemCaseType.Upper:
val = val.ToUpper();
break;
case RebelRenderItemCaseType.Lower:
val = val.ToLower();
break;
case RebelRenderItemCaseType.Title:
val = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(val);
break;
default:
break;
}
switch (encoding)
{
case RebelRenderItemEncodingType.Url:
val = HttpUtility.UrlEncode(val);
break;
case RebelRenderItemEncodingType.Html:
val = HttpUtility.HtmlEncode(val);
break;
default:
break;
}
if (convertLineBreaks)
{
val = val.Replace(Environment.NewLine, "<br />");
}
if (removeParagraphTags)
{
val = val.Trim().Trim("<p>").Trim("</p>");
}
sb.Append(HttpUtility.HtmlDecode(insertBefore));
sb.Append(val);
sb.Append(HttpUtility.HtmlDecode(insertAfter));
}
//now we need to parse the macro syntax out and replace it with the rendered macro content
var macroRenderer = new MacroRenderer(routableRequestContext.RegisteredComponents, routableRequestContext);
var macroParser = new MacroSyntaxParser();
IEnumerable<MacroParserResult> parseResults;
var parsed = macroParser.Parse(sb.ToString(),
(macroAlias, macroParams)
=> macroRenderer.RenderMacroAsString(macroAlias,
macroParams,
controllerContext, false,
() => item), out parseResults);
//now we need to parse any internal links and replace with actual URLs
var linkParse = new LinkSyntaxParser();
parsed = linkParse.Parse(parsed, x => routableRequestContext.RoutingEngine.GetUrl(x));
return new MvcHtmlString(parsed);
}
public IHtmlString RenderField(IRoutableRequestContext routableRequestContext, ControllerContext controllerContext, Content item,
string fieldAlias = "", string valueAlias = "", string altFieldAlias = "", string altValueAlias = "", string altText = "", string insertBefore = "", string insertAfter = "",
bool recursive = false, bool convertLineBreaks = false, bool removeParagraphTags = false,
RebelRenderItemCaseType casing = RebelRenderItemCaseType.Unchanged,
RebelRenderItemEncodingType encoding = RebelRenderItemEncodingType.Unchanged,
string formatString = "")
{
var sb = new StringBuilder();
var valObj = GetFieldValue(item, fieldAlias, valueAlias, recursive);
if ((valObj == null || valObj.ToString().IsNullOrWhiteSpace()) && !altFieldAlias.IsNullOrWhiteSpace())
{
valObj = GetFieldValue(item, altFieldAlias, altValueAlias, recursive);
}
if ((valObj == null || valObj.ToString().IsNullOrWhiteSpace()) && !altText.IsNullOrWhiteSpace())
{
valObj = altText;
}
if (!formatString.IsNullOrWhiteSpace())
{
formatString = "{0:" + formatString.Replace("\\", "\\\\").Replace("\"", "\\\"") + "}";
}
else
{
formatString = "{0}";
}
var val = string.Format(formatString, valObj);
if (!val.IsNullOrWhiteSpace())
{
switch (casing)
{
case RebelRenderItemCaseType.Upper:
val = val.ToUpper();
break;
case RebelRenderItemCaseType.Lower:
val = val.ToLower();
break;
case RebelRenderItemCaseType.Title:
val = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(val);
break;
default:
break;
}
switch (encoding)
{
case RebelRenderItemEncodingType.Url:
val = HttpUtility.UrlEncode(val);
break;
case RebelRenderItemEncodingType.Html:
val = HttpUtility.HtmlEncode(val);
break;
default:
break;
}
if (convertLineBreaks)
{
val = val.Replace(Environment.NewLine, "<br />");
}
if (removeParagraphTags)
{
val = val.Trim().Trim("<p>").Trim("</p>");
}
sb.Append(HttpUtility.HtmlDecode(insertBefore));
sb.Append(val);
sb.Append(HttpUtility.HtmlDecode(insertAfter));
}
//now we need to parse the macro syntax out and replace it with the rendered macro content
var macroRenderer = new MacroRenderer(routableRequestContext.RegisteredComponents, routableRequestContext);
var macroParser = new MacroSyntaxParser();
IEnumerable <MacroParserResult> parseResults;
var parsed = macroParser.Parse(sb.ToString(),
(macroAlias, macroParams)
=> macroRenderer.RenderMacroAsString(macroAlias,
macroParams,
controllerContext, false,
() => item), out parseResults);
//now we need to parse any internal links and replace with actual URLs
var linkParse = new LinkSyntaxParser();
parsed = linkParse.Parse(parsed, x => routableRequestContext.RoutingEngine.GetUrl(x));
return(new MvcHtmlString(parsed));
}
public MacroController(IRoutableRequestContext requestContext, IRenderModelFactory renderModelFactory)
{
RoutableRequestContext = requestContext;
_renderModelFactory = renderModelFactory;
_macroRenderer = new MacroRenderer(RoutableRequestContext.RegisteredComponents, RoutableRequestContext);
}
/// <summary>
/// Renders the macro with the specified alias, passing in the specified parameters.
/// </summary>
/// <param name="m">The macro.</param>
/// <param name="parameters">The parameters.</param>
/// <param name="umbracoPage">The legacy umbraco page object that is required for some macros</param>
/// <returns></returns>
internal IHtmlString RenderMacro(MacroModel m, IDictionary <string, object> parameters, page umbracoPage)
{
if (umbracoPage == null)
{
throw new ArgumentNullException(nameof(umbracoPage));
}
if (m == null)
{
throw new ArgumentNullException(nameof(m));
}
if (_umbracoContext.PageId == null)
{
throw new InvalidOperationException("Cannot render a macro when UmbracoContext.PageId is null.");
}
var macroProps = new Hashtable();
foreach (var i in parameters)
{
//TODO: We are doing at ToLower here because for some insane reason the UpdateMacroModel method of macro.cs
// looks for a lower case match. WTF. the whole macro concept needs to be rewritten.
//NOTE: the value could have html encoded values, so we need to deal with that
macroProps.Add(i.Key.ToLowerInvariant(), (i.Value is string) ? HttpUtility.HtmlDecode(i.Value.ToString()) : i.Value);
}
var renderer = new MacroRenderer(Current.ProfilingLogger);
var macroControl = renderer.Render(m, umbracoPage.Elements, _umbracoContext.PageId.Value, macroProps).GetAsControl();
string html;
if (macroControl is LiteralControl)
{
// no need to execute, we already have text
html = (macroControl as LiteralControl).Text;
}
else
{
var containerPage = new FormlessPage();
containerPage.Controls.Add(macroControl);
using (var output = new StringWriter())
{
// .Execute() does a PushTraceContext/PopTraceContext and writes trace output straight into 'output'
// and I do not see how we could wire the trace context to the current context... so it creates dirty
// trace output right in the middle of the page.
//
// The only thing we can do is fully disable trace output while .Execute() runs and restore afterwards
// which means trace output is lost if the macro is a control (.ascx or user control) that is invoked
// from within Razor -- which makes sense anyway because the control can _not_ run correctly from
// within Razor since it will never be inserted into the page pipeline (which may even not exist at all
// if we're running MVC).
//
// I'm sure there's more things that will get lost with this context changing but I guess we'll figure
// those out as we go along. One thing we lose is the content type response output.
// http://issues.umbraco.org/issue/U4-1599 if it is setup during the macro execution. So
// here we'll save the content type response and reset it after execute is called.
var contentType = _umbracoContext.HttpContext.Response.ContentType;
var traceIsEnabled = containerPage.Trace.IsEnabled;
containerPage.Trace.IsEnabled = false;
_umbracoContext.HttpContext.Server.Execute(containerPage, output, true);
containerPage.Trace.IsEnabled = traceIsEnabled;
//reset the content type
_umbracoContext.HttpContext.Response.ContentType = contentType;
//Now, we need to ensure that local links are parsed
html = TemplateUtilities.ParseInternalLinks(output.ToString(), _umbracoContext.UrlProvider);
}
}
return(new HtmlString(html));
}
private void Clear()
{
var itemsCleared = MacroRenderer.ClearCacheByPrefix(this.Context);
LogHelper.TraceIfEnabled <ClearMacroCacheTask>("Cleared {0} macro caches due to an item being published or unpublished", () => itemsCleared);
}
public IHtmlString RenderField(IRoutableRequestContext routableRequestContext, ControllerContext controllerContext, Content item,
string fieldAlias = "", string valueAlias = "", string altFieldAlias = "", string altValueAlias = "", string altText = "", string insertBefore = "", string insertAfter = "",
bool recursive = false, bool convertLineBreaks = false, bool removeParagraphTags = false,
UmbracoRenderItemCaseType casing = UmbracoRenderItemCaseType.Unchanged,
UmbracoRenderItemEncodingType encoding = UmbracoRenderItemEncodingType.Unchanged)
{
var sb = new StringBuilder();
// Handle hard coded "friendly" system keys
if (fieldAlias == "Name" || fieldAlias == "UrlName")
{
valueAlias = fieldAlias;
fieldAlias = NodeNameAttributeDefinition.AliasValue;
}
if (fieldAlias == "CurrentTemplateId")
{
fieldAlias = SelectedTemplateAttributeDefinition.AliasValue;
valueAlias = "TemplateId";
}
if (altFieldAlias == "Name" || altFieldAlias == "UrlName")
{
altValueAlias = altFieldAlias;
altFieldAlias = NodeNameAttributeDefinition.AliasValue;
}
if (altFieldAlias == "CurrentTemplateId")
{
altFieldAlias = SelectedTemplateAttributeDefinition.AliasValue;
altValueAlias = "TemplateId";
}
var val = item.Field <string>(fieldAlias, valueAlias, recursive);
if (val.IsNullOrWhiteSpace() && !altFieldAlias.IsNullOrWhiteSpace())
{
val = item.Field <string>(altFieldAlias, altValueAlias, recursive);
}
if (val.IsNullOrWhiteSpace() && !altText.IsNullOrWhiteSpace())
{
val = altText;
}
if (!val.IsNullOrWhiteSpace())
{
switch (casing)
{
case UmbracoRenderItemCaseType.Upper:
val = val.ToUpper();
break;
case UmbracoRenderItemCaseType.Lower:
val = val.ToLower();
break;
case UmbracoRenderItemCaseType.Title:
val = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(val);
break;
default:
break;
}
switch (encoding)
{
case UmbracoRenderItemEncodingType.Url:
val = HttpUtility.UrlEncode(val);
break;
case UmbracoRenderItemEncodingType.Html:
val = HttpUtility.HtmlEncode(val);
break;
default:
break;
}
if (convertLineBreaks)
{
val = val.Replace(Environment.NewLine, "<br />");
}
if (removeParagraphTags)
{
val = val.Trim().Trim("<p>").Trim("</p>");
}
sb.Append(HttpUtility.HtmlDecode(insertBefore));
sb.Append(val);
sb.Append(HttpUtility.HtmlDecode(insertAfter));
}
//now we need to parse the macro syntax out and replace it with the rendered macro content
var macroRenderer = new MacroRenderer(routableRequestContext.RegisteredComponents, routableRequestContext);
var macroParser = new MacroSyntaxParser();
IEnumerable <MacroParserResult> parseResults;
var parsed = macroParser.Parse(sb.ToString(),
(macroAlias, macroParams)
=> macroRenderer.RenderMacroAsString(macroAlias,
macroParams,
controllerContext, false,
() => item), out parseResults);
//now we need to parse any internal links and replace with actual URLs
var linkParse = new LinkSyntaxParser();
parsed = linkParse.Parse(parsed, x => routableRequestContext.RoutingEngine.GetUrl(x));
return(new MvcHtmlString(parsed));
}
/// <summary>
/// Called by the ASP.NET page framework to notify server controls that use composition-based implementation to create any child controls they contain in preparation for posting back or rendering.
/// </summary>
protected override void CreateChildControls()
{
// collect all attributes set on the control
var keys = Attributes.Keys;
foreach (string key in keys)
{
MacroAttributes.Add(key.ToLower(), HttpUtility.HtmlDecode(Attributes[key]));
}
if (MacroAttributes.ContainsKey("macroalias") == false && MacroAttributes.ContainsKey("macroAlias") == false)
{
MacroAttributes.Add("macroalias", Alias);
}
// set pageId to int.MinValue if no pageID was found,
// e.g. if the macro was rendered on a custom (non-Umbraco) page
var pageId = UmbracoContext.Current.PageId == null ? int.MinValue : UmbracoContext.Current.PageId.Value;
if ((string.IsNullOrEmpty(Language) == false && Text != "") || string.IsNullOrEmpty(FileLocation) == false)
{
var tempMacro = new MacroModel();
MacroRenderer.GenerateMacroModelPropertiesFromAttributes(tempMacro, MacroAttributes);
// executing an inline macro?
// ie the code of the macro is in the control's text body
// ok, this is not supported in v8 anymore
if (string.IsNullOrEmpty(FileLocation))
{
throw new NotSupportedException("Inline macros are not supported anymore.");
}
// executing an on-disk macro
// it has to be a partial (cshtml or vbhtml) macro in v8
var extension = System.IO.Path.GetExtension(FileLocation);
if (extension.InvariantEndsWith(".cshtml") == false && extension.InvariantEndsWith(".vbhtml") == false)
{
throw new NotSupportedException("");
}
tempMacro.MacroSource = FileLocation;
tempMacro.MacroType = MacroTypes.PartialView;
if (string.IsNullOrEmpty(Attributes["Cache"]) == false)
{
int cacheDuration;
if (int.TryParse(Attributes["Cache"], out cacheDuration))
{
tempMacro.CacheDuration = cacheDuration;
}
else
{
Context.Trace.Warn("Template", "Cache attribute is in incorect format (should be an integer).");
}
}
var renderer = new MacroRenderer(Current.ProfilingLogger);
var c = renderer.Render(tempMacro, (Hashtable)Context.Items["pageElements"], pageId).GetAsControl();
if (c != null)
{
Exceptions = renderer.Exceptions;
Controls.Add(c);
}
else
{
Context.Trace.Warn("Template", "Result of inline macro scripting is null");
}
}
else
{
var m = Current.Services.MacroService.GetByAlias(Alias);
if (m == null)
{
return;
}
var tempMacro = new MacroModel(m);
try
{
var renderer = new MacroRenderer(Current.ProfilingLogger);
var c = renderer.Render(tempMacro, (Hashtable)Context.Items["pageElements"], pageId, MacroAttributes).GetAsControl();
if (c != null)
{
Controls.Add(c);
}
else
{
Context.Trace.Warn("Template", "Result of macro " + tempMacro.Name + " is null");
}
}
catch (Exception ee)
{
Context.Trace.Warn("Template", "Error adding macro " + tempMacro.Name, ee);
throw;
}
}
}
public MacroController(IRoutableRequestContext requestContext, IRenderModelFactory renderModelFactory)
{
RoutableRequestContext = requestContext;
_renderModelFactory = renderModelFactory;
_macroRenderer = new MacroRenderer(RoutableRequestContext.RegisteredComponents, RoutableRequestContext);
}
/// <summary>
/// Renders the macro with the specified alias, passing in the specified parameters.
/// </summary>
/// <param name="alias">The alias.</param>
/// <param name="parameters">The parameters.</param>
/// <returns></returns>
public IHtmlString RenderMacro(string alias, object parameters)
{
var macroRenderer = new MacroRenderer(_requestContext.RegisteredComponents, _requestContext);
var result = macroRenderer.RenderMacroAsString(alias, parameters.ToDictionary<string>(), _controllerContext, false, () => _currentPage);
return new HtmlString(result);
}
