/// <summary>
/// Actually use DotLiquid to render a liquid string into output.
/// </summary>
/// <param name="source">Liquid source to render.</param>
/// <param name="sourceIdentifier">For telemetry purposes, optional string identifying what's being rendered.</param>
/// <param name="output">TextWriter to render output to.</param>
/// <param name="context">DotLiquid context.</param>
private static void InternalRenderLiquid(string source, string sourceIdentifier, TextWriter output, Context context)
{
Template template;
if (!string.IsNullOrEmpty(sourceIdentifier))
{
sourceIdentifier = string.Format(" ({0})", sourceIdentifier);
}
try
{
using (PerformanceProfiler.Instance.StartMarker(PerformanceMarkerName.LiquidExtension, PerformanceMarkerArea.Liquid, PerformanceMarkerTagName.LiquidSourceParsed))
{
template = Template.Parse(source);
}
}
catch (SyntaxException e)
{
ADXTrace.Instance.TraceError(TraceCategory.Application, string.Format("Liquid parse error{0}: {1}", sourceIdentifier, e.ToString()));
output.Write(e.Message);
return;
}
ADXTrace.Instance.TraceInfo(TraceCategory.Application, string.Format("Rendering Liquid{0}", sourceIdentifier));
using (PerformanceProfiler.Instance.StartMarker(PerformanceMarkerName.LiquidExtension, PerformanceMarkerArea.Liquid, PerformanceMarkerTagName.RenderLiquid))
{
template.Render(output, RenderParameters.FromContext(context));
}
foreach (var error in template.Errors)
{
ADXTrace.Instance.TraceError(TraceCategory.Application, string.Format("Liquid rendering error{0}: {1}", sourceIdentifier, error.ToString()));
}
}
private static string Render([NotNull] string templatePath,
[NotNull] Hash hash,
bool rethrowErrors = false)
{
string templateDirectory = Path.GetDirectoryName(Path.GetFullPath(templatePath));
IFileSystem origFileSystem = Template.FileSystem;
try
{
if (!string.IsNullOrEmpty(templateDirectory))
{
Template.FileSystem = new LocalFileSystem(templateDirectory);
}
string templateString = FileSystemUtils.ReadTextFile(templatePath);
Template template = Template.Parse(templateString);
var parameters = new RenderParameters
{
LocalVariables = hash,
RethrowErrors = rethrowErrors
};
string result = template.Render(parameters) ?? string.Empty;
return(result);
}
finally
{
Template.FileSystem = origFileSystem;
}
}
public override Render Render(RenderParameters parameters)
{
int margin;
switch (Alignment)
{
case VerticalAlignment.Top:
margin = 0;
break;
case VerticalAlignment.Center:
margin = (GivenSize.Height - Child.GivenSize.Height) / 2;
break;
case VerticalAlignment.Bottom:
margin = GivenSize.Height - Child.GivenSize.Height;
break;
default:
throw new ArgumentOutOfRangeException();
}
var buffer = new string[GivenSize.Height];
var childRender = Child.Render(parameters);
Array.Copy(
childRender.Buffer,
0,
buffer,
margin,
childRender.Buffer.Length);
return(new Render(buffer, GivenSize));
}
public override void Render(Context context, TextWriter result)
{
Template partial = LoadCachedPartials(_templateName, context);
string shortenedTemplateName = _templateName.Substring(1, _templateName.Length - 2);
object variable = context[_variableName ?? shortenedTemplateName];
context.Stack(() =>
{
foreach (var keyValue in _attributes)
{
context[keyValue.Key] = context[keyValue.Value];
}
if (variable is IEnumerable && !(variable is string))
{
((IEnumerable)variable).Cast <object>().ToList().ForEach(v =>
{
context[shortenedTemplateName] = v;
partial.Render(result, RenderParameters.FromContext(context));
});
return;
}
context[shortenedTemplateName] = variable;
partial.Render(result, RenderParameters.FromContext(context));
});
}
public static GenerationResult GenerateFilePreview(Idea Source, string SourceTemplateText, bool FailWhenInvalid = false)
{
GenerationResult Result = null;
System.Windows.Input.Mouse.OverrideCursor = System.Windows.Input.Cursors.Wait;
try
{
var CompiledTemplate = CreateCompiledTemplate(Source.IdeaDefinitor.ToString(), SourceTemplateText, FailWhenInvalid).Result;
var Parameters = new RenderParameters();
Parameters.LocalVariables = DotLiquid.Hash.FromAnonymousObject(Source);
Parameters.RethrowErrors = true;
var GeneratedOutput = CompiledTemplate.Render(Parameters);
Result = new GenerationResult((Source.OwnerComposition.CompositeContentDomain.GenerationConfiguration.UseIdeaTechNameForFileNaming
? Source.TechName : Source.Name) + GenerationManager.DEFAULT_GEN_EXT, GeneratedOutput);
}
finally
{
System.Windows.Input.Mouse.OverrideCursor = null;
}
return(Result);
}
public static string RenderWithTracing(this Template template, RenderParameters parameters)
{
if (template == null)
{
throw new ArgumentNullException("template");
}
string content = null;
try
{
content = template.Render(parameters);
}
catch (Exception ex)
{
Trace.TraceError(FlattenException(ex));
throw;
}
finally
{
if (template.Errors.Any())
{
template.Errors.ForEach(e => Trace.TraceError(FlattenException(e)));
}
}
return(content);
}
/// <summary>
/// Renders the reCaptcha HTML control.
/// </summary>
/// <param name="htmlHelper"><c>HtmlHelper</c> instance.</param>
/// <param name="htmlAttributes">List of HTML attributes.</param>
/// <param name="parameters"><c>ReCaptchaParameters</c> object.</param>
/// <returns>Returns the reCaptcha HTML control.</returns>
public static MvcHtmlString ReCaptcha(this HtmlHelper htmlHelper, RenderParameters parameters, IDictionary <string, object> htmlAttributes)
{
var builder = new TagBuilder("div");
if (parameters != null)
{
builder.MergeAttributes(parameters.ToDictionary <RenderParameters, string, object>());
}
if (htmlAttributes != null)
{
builder.MergeAttributes(htmlAttributes);
}
string result;
if (!builder.Attributes.TryGetValue("class", out result))
{
result = "g-recaptcha";
builder.AddCssClass(result);
}
if (!result.Contains("g-recaptcha"))
{
builder.AddCssClass("g-recaptcha");
}
return(builder.ToMvcHtmlString(TagRenderMode.Normal));
}
// Protected Methods (1)
protected override void OnRender(ref StringBuilder builder)
{
if (this._SOURCE == null)
{
builder = null;
return;
}
var @params = new RenderParameters();
@params.Filters = this.Filters;
var tpl = Template.Parse(this._SOURCE);
foreach (var item in this.GetAllVars())
{
tpl.Assigns.Add(item.Key, ToLiquidObject(item.Value));
}
var renderedSrc = tpl.Render(@params);
if (renderedSrc != null)
{
builder.Append(renderedSrc);
}
else
{
builder = null;
}
}
public override Rss.RssItem[] GetRssFeedItems(CmsPage page, CmsPlaceholderDefinition placeholderDefinition, CmsLanguage langToRenderFor)
{
List <Rss.RssItem> ret = new List <Rss.RssItem>();
// -- get the news
NewsArticleDb.NewsArticleAggregatorData aggData = (new NewsArticleDb()).fetchNewsAggregator(page, placeholderDefinition.Identifier, langToRenderFor, true);
RenderParameters renderParams = RenderParameters.fromParamList(placeholderDefinition.ParamList, aggData);
NewsAggItem[] newsItems = FetchAllNewsAggItems(page, placeholderDefinition.Identifier, langToRenderFor, renderParams, CmsUrlFormat.FullIncludingProtocolAndDomainName);
int currYear = renderParams.AggregatorData.YearToDisplay;
foreach (NewsAggItem newsItem in newsItems)
{
if (currYear < 0 || newsItem.NewsDate.Year == currYear)
{
Rss.RssItem rssItem = new Rss.RssItem();
rssItem = InitRssItem(rssItem, page, langToRenderFor);
rssItem.Title = newsItem.Title;
rssItem.Link = new Uri(newsItem.PageDisplayURL, UriKind.RelativeOrAbsolute);
rssItem.Guid = new Rss.RssGuid(rssItem.Link);
rssItem.PubDate_GMT = newsItem.NewsDate.ToUniversalTime();
rssItem.Description = newsItem.NewsArticleHtml;
ret.Add(rssItem);
}
}
return(ret.ToArray());
} // GetRssFeedItems
/// <summary>
/// Render template to stream
/// </summary>
/// <param name="path">Template path</param>
/// <param name="arguments">Template arguments</param>
/// <param name="stream">Target stream</param>
public virtual void RenderTemplate(string path, object arguments, Stream stream)
{
// Build template parameters
var parameters = new RenderParameters();
if (arguments is IDictionary <string, object> )
{
parameters.LocalVariables = Hash.FromDictionary((IDictionary <string, object>)arguments);
}
else
{
parameters.LocalVariables = Hash.FromAnonymousObject(arguments);
}
// Find template, display error if not found
var template = Template.FileSystem.ReadTemplateFile(null, path) as Template;
if (template == null)
{
// Can't use using directive here, see http://stackoverflow.com/questions/2666888
var writer = new StreamWriter(stream);
writer.WriteLine($"template file {path} not found");
writer.Flush();
return;
}
// Render to stream
template.Render(stream, parameters);
}
public override void Render(Context context, TextWriter result)
{
IFileSystem fileSystem = context.Registers["file_system"] as IFileSystem ?? Template.FileSystem;
string source = fileSystem.ReadTemplateFile(context, _templateName);
Template partial = Template.Parse(source);
string shortenedTemplateName = _templateName.Substring(1, _templateName.Length - 2);
object variable = context[_variableName ?? shortenedTemplateName];
context.Stack(() =>
{
foreach (var keyValue in _attributes)
{
context[keyValue.Key] = context[keyValue.Value];
}
if (variable is IEnumerable)
{
((IEnumerable)variable).Cast <object>().ToList().ForEach(v =>
{
context[shortenedTemplateName] = v;
partial.Render(result, RenderParameters.FromContext(context));
});
return;
}
context[shortenedTemplateName] = variable;
partial.Render(result, RenderParameters.FromContext(context));
});
}
/// <summary>
/// Render template by content and parameters
/// </summary>
/// <param name="templateContent"></param>
/// <param name="parameters"></param>
/// <returns></returns>
public string RenderTemplate(string templateContent, Dictionary <string, object> parameters)
{
if (String.IsNullOrEmpty(templateContent))
{
return(templateContent);
}
if (parameters == null)
{
parameters = new Dictionary <string, object>();
}
Template.FileSystem = this;
var renderParams = new RenderParameters()
{
LocalVariables = Hash.FromDictionary(parameters)
};
var parsedTemplate = _cacheManager.Get(GetCacheKey("ParseTemplate", templateContent.GetHashCode().ToString()), "LiquidTheme", () => { return(Template.Parse(templateContent)); });
var retVal = parsedTemplate.RenderWithTracing(renderParams);
//Copy key values which were generated in rendering to out parameters
if (parameters != null && parsedTemplate.Registers != null)
{
foreach (var registerPair in parsedTemplate.Registers)
{
parameters[registerPair.Key] = registerPair.Value;
}
}
return(retVal);
}
public static RenderParameters FromPlaceholderParamList(string[] paramList)
{
RenderParameters ret = new RenderParameters();
ret.InitFromPlaceholderParamList(paramList);
return(ret);
}
private string GetCustomerDetailsPartial()
{
string templateStr = GetLiquidFileAsString("CustomerDetailsPartial.liquid");
Template template = Template.Parse(templateStr);
string domain = SettingsService.Flipdish_DomainWithScheme;
string customerName = _order.Customer.Name;
string deliveryInstructions = _order?.DeliveryLocation?.DeliveryInstructions;
string deliveryLocationAddressString = _order?.DeliveryLocation?.PrettyAddressString;
string phoneNumber = _order.Customer.PhoneNumberLocalFormat;
bool isDelivery = _order.DeliveryType == Order.DeliveryTypeEnum.Delivery;
string resDelivery_Instructions = "Delivery Instructions";
var paramaters = new RenderParameters(CultureInfo.CurrentCulture)
{
LocalVariables = Hash.FromAnonymousObject(new
{
domain,
customerName,
deliveryInstructions,
deliveryLocationAddressString,
phoneNumber,
isDelivery,
resDelivery_Instructions
})
};
return(template.Render(paramaters));
}
/// <summary>
/// Gets the callback script.
/// </summary>
/// <param name="callback">Name of callback function.</param>
/// <param name="elementId">Id of the placeholder element.</param>
/// <param name="parameters"><c>RenderParameters</c> instance.</param>
/// <returns>Returns the callback script.</returns>
private static string GetCallbackScript(string callback, string elementId, RenderParameters parameters)
{
if (String.IsNullOrWhiteSpace(callback))
{
throw new ArgumentNullException("callback");
}
if (String.IsNullOrWhiteSpace(elementId))
{
throw new ArgumentNullException("elementId");
}
var serialised = parameters == null
? null
: JsonConvert.SerializeObject(parameters.ToDictionary <RenderParameters, string, object>())
.Replace("\"data-", "\"");
var sb = new StringBuilder();
sb.AppendLine(String.Format("var {0} = function() {{", callback));
sb.AppendLine(String.Format("grecaptcha.render(\"{0}\", {1});", elementId, serialised));
sb.AppendLine("};");
return(sb.ToString());
}
private string Render(Template template, RenderParameters renderParams)
{
var layoutTemplate = FindLayoutTemplate(template);
renderParams.LocalVariables["content_for_layout"] = template.Render(renderParams);
return(layoutTemplate.Render(renderParams));
}
public override Rss.RssItem[] GetRssFeedItems(CmsPage page, CmsPlaceholderDefinition placeholderDefinition, CmsLanguage langToRenderFor)
{
base.categoryList = db.fetchCategoryList(langToRenderFor);
RenderParameters renderParams = RenderParameters.FromPlaceholderParamList(placeholderDefinition.ParamList);
CmsUrlFormat pageLinkFormat = CmsUrlFormat.FullIncludingProtocolAndDomainName;
CmsUrlFormat fileLinkFormat = CmsUrlFormat.FullIncludingProtocolAndDomainName;
FileAggItem[] filesToShow = FetchAllFilesToShow(page, placeholderDefinition.Identifier, langToRenderFor, renderParams, pageLinkFormat, fileLinkFormat);
List <Rss.RssItem> ret = new List <Rss.RssItem>();
foreach (FileAggItem file in filesToShow)
{
Rss.RssItem rssItem = CreateAndInitRssItem(page, langToRenderFor);
// -- link directly to the file url
rssItem.Link = new Uri(file.FileDownloadURL, UriKind.RelativeOrAbsolute);
rssItem.Guid = new Rss.RssGuid(rssItem.Link);
rssItem.Title = file.Title;
rssItem.Description = file.Description;
rssItem.PubDate_GMT = file.LastModified.ToUniversalTime();
ret.Add(rssItem);
} // foreach file
return(ret.ToArray());
} // GetRssFeedItems
public DecoratedStyle(Color color, Texture2D decoration)
{
sprite = new Sprite(decoration);
renderParameters = new RenderParameters();
renderParameters.Color = color;
this.AssignDefaultValues();
}
public override void Render(Context context, TextWriter result)
{
IFileSystem fileSystem = context.Registers["file_system"] as IFileSystem ?? Template.FileSystem;
string source = fileSystem.ReadTemplateFile(context, _templateName);
Template template = Template.Parse(source);
List <Block> parentBlocks = FindBlocks(template.Root);
Blocks.ForEach(block =>
{
Block pb = parentBlocks.Find(b => b.BlockName == block.BlockName);
if (pb != null)
{
pb.Parent = block.Parent;
pb.AddParent(pb.NodeList);
pb.NodeList.Clear();
pb.NodeList.AddRange(block.NodeList);
}
else if (IsExtending(template))
{
template.Root.NodeList.Add(block);
}
});
template.Render(result, RenderParameters.FromContext(context));
}
public override Render Render(RenderParameters parameters)
{
int space = GivenSize.Width - Child.GivenSize.Width, left;
switch (Alignment)
{
case HorizontalAlignment.Left:
left = 0;
break;
case HorizontalAlignment.Center:
left = space / 2;
break;
case HorizontalAlignment.Right:
left = GivenSize.Width - Child.GivenSize.Width;
break;
default:
throw new ArgumentOutOfRangeException();
}
var buffer = new string[GivenSize.Height];
var childRender = Child.Render(parameters);
for (var i = 0; i < buffer.Length; i++)
{
buffer[i] = new string(' ', left) + childRender.Buffer[i] + new string(' ', space - left);
}
return(new Render(buffer, GivenSize));
}
/// <summary>
/// スプライトを描画キューに登録します。
/// </summary>
/// <param name="sprite">描画するスプライト</param>
/// <param name="rect">描画範囲</param>
/// <param name="rotate">回転</param>
/// <param name="rotateOrigin">中心回転座標(スプライトに対して0~1で指定する)</param>
public void Draw(SpriteResource sprite, RawRectangleF rect, float rotate, RawVector2 rotateOrigin)
{
if (!Begining)
{
throw new InvalidOperationException("描画操作が開始していません。");
}
RenderParameters.AddLast(new SpriteRenderParameter(sprite, rotate, rotateOrigin, rect));
}
/// <summary> Creates a new instance of the Engine class with the given parameters. </summary>
public Engine(ScreenParameters screenParameters, ViewportParameters viewportParameters, RenderParameters renderParameters)
{
_screenParameters = screenParameters;
_viewportParameters = viewportParameters;
_renderParameters = renderParameters;
_cameraConverter = new CameraConverter(_screenParameters, _viewportParameters);
}
public GridDocumentRenderer(GridDocument grid, Document document, RenderParameters parameters)
{
_grid = grid;
_document = document;
_parameters = parameters;
// create a page so that we can get the dimensions. this page will be cleared from the document
_documentPageForMetrics = _document.AddPage(_parameters.PageType, _parameters.PageOrientation);
}
Task <string> RenderAsync(CultureInfo culture)
{
var renderParams = new RenderParameters(culture)
{
LocalVariables = _assigns
};
return(Template.Parse("{{number}}").RenderAsync(renderParams));
}
public void Begin()
{
if (Begining)
{
throw new InvalidOperationException("描画操作はすでに開始されています。");
}
Begining = true;
RenderParameters.Clear();
}
public void Render(ViewContext viewContext, TextWriter writer)
{
if (viewContext == null)
{
throw new ArgumentNullException("viewContext");
}
// Copy data from the view context over to DotLiquid
var localVars = new Hash();
if (viewContext.ViewData.Model != null)
{
var liquidContext = (Dictionary <string, object>)viewContext.ViewData.Model;
foreach (var key in liquidContext.Keys)
{
localVars.Add(key, liquidContext[key]);
}
//var model = viewContext.ViewData.Model;
//if(model.GetType().Name.EndsWith("ViewModel"))
//{
// // If it's view model, just copy all properties to the localVars collection
// localVars.Merge(Hash.FromAnonymousObject(model));
//}
//else
//{
// It it's not a view model, just add the model direct as a "model" variable
//localVars.Add("model", model);
//}
}
foreach (var item in viewContext.ViewData)
{
localVars.Add(Template.NamingConvention.GetMemberName(item.Key), item.Value);
}
foreach (var item in viewContext.TempData)
{
localVars.Add(Template.NamingConvention.GetMemberName(item.Key), item.Value);
}
var renderParams = new RenderParameters
{
LocalVariables = Hash.FromDictionary(localVars)
};
// Render the template
//var fileContents = VirtualPathProviderHelper.Load(ViewPath);
//var template = Template.Parse(fileContents);
var template = FindTemplate(ViewPath);
string result = Render(template, renderParams);
writer.Write(result);
//template.Render(writer, renderParams);
}
public static void AssertTemplateResult(string expected, string template, Hash localVariables, SyntaxCompatibility syntax = SyntaxCompatibility.DotLiquid20)
{
var parameters = new RenderParameters(System.Globalization.CultureInfo.CurrentCulture)
{
LocalVariables = localVariables,
SyntaxCompatibilityLevel = syntax
};
Assert.AreEqual(expected, Template.Parse(template).Render(parameters));
}
public static void AssertTemplateResult(string expected, string template, Hash localVariables)
{
var parameters = new RenderParameters(System.Globalization.CultureInfo.CurrentCulture)
{
LocalVariables = localVariables,
};
var tpl = Template.Parse(template);
var actual = tpl.Render(parameters);
Assert.Equal(expected, actual);
}
public static string RenderWithTracing(this Template template, RenderParameters parameters)
{
var content = template.Render(parameters);
if (template.Errors.Any())
{
template.Errors.ForEach(e => Trace.TraceError(FlattenException(e)));
}
return(content);
}
public void Draw(SpriteBatch batch, RenderParameters renderParams)
{
batch.Draw(Texture,
Region.Frame,
null,
renderParams.Color,
renderParams.Rotation,
renderParams.Origin,
renderParams.SpriteEffect,
renderParams.Layer);
}