private static LiquidTemplate CreateRenderer(IList<LiquidError> errors, string erroneousTemplate)
{
var liquidAstGenerator = new LiquidASTGenerator();
OnParsingErrorEventHandler liquidAstGeneratorParsingErrorEventHandler = errors.Add;
liquidAstGenerator.ParsingErrorEventHandler += liquidAstGeneratorParsingErrorEventHandler;
var liquidAst = liquidAstGenerator.Generate(erroneousTemplate);
var template = new LiquidTemplate(liquidAst);
return template;
}
public void It_Should_Allow_A_Variable_With_Int_Index()
{
// Arrange
ITemplateContext ctx =
new TemplateContext().WithAllFilters();
LiquidCollection arr = new LiquidCollection {
LiquidNumeric.Create(33)
};
ctx.DefineLocalVariable("bar", arr);
var template = LiquidTemplate.Create("{{ 1 | plus: bar[0] }}");
// Act
String result = template.LiquidTemplate.Render(ctx).Result;
Logger.Log(result);
// Assert
Assert.That(result, Is.EqualTo("34"));
}
public void It_Should_Render_A_Table_Row_From_A_String()
{
// Arrange
TemplateContext ctx = new TemplateContext();
ctx.DefineLocalVariable("numbers", DictionaryFactory.CreateArrayFromJson("[1, 2, 3, 4, 5, 6]"));
var template = LiquidTemplate.Create(@"{% tablerow n in ""Test"" cols:2%}ITER{{n}}{% endtablerow %}");
// Act
String result = template.LiquidTemplate.Render(ctx).Result;
Logger.Log(result);
String expected =
"<tr class=\"row1\">\r\n<td class=\"col1\">ITERTest</td></tr>";
// Act
// Assert
Assert.Contains(expected, result);
}
public void Poco_Object_Should_Be_Serialized()
{
ITemplateContext ctx = new TemplateContext()
.DefineLocalVariable("poco", new MyPoco
{
MyStringField = "A string field",
MyNullableIntField = 123,
MyOtherField = "Some Other Field",
MyIgnoredField = "This Shouldn't Show Up",
MyIgnoreIfNotNullField = null,
NestedPoco = new MyPoco {
MyStringField = "Nested Poco"
}
}.ToLiquid());
var parsingResult = LiquidTemplate.Create("Poco Result: {{ poco }}");
var renderingResult = parsingResult.LiquidTemplate.Render(ctx);
Assert.Contains(@"Poco Result: { ""mystringfield"" : ""A string field"", ""mynullableintfield"" : 123, ""myrenamedfield"" : ""Some Other Field"", ""nestedpoco"" : { ""mystringfield"" : ""Nested Poco"", ""mynullableintfield"" : null, ""myrenamedfield"" : null } }", renderingResult.Result);
}
public void Render_TemplateNotSet_Throws()
{
Person model = new Person()
{
Firstname = "Jim",
Lastname = "Bob",
};
TemplateContext context = new TemplateContext("p", model);
try
{
LiquidTemplate target = new LiquidTemplate();
target.RegisterType(typeof(Person));
target.Render(context);
}
catch (InvalidOperationException ex)
{
Assert.AreEqual("The template has not been parsed.", ex.Message);
throw;
}
}
public void It_Should_Register_A_Rendering_Error()
{
// Arrange
var ctx = CreateContext(new Dictionary <String, String>
{
{ "test", "problem: {{ 1 | divided_by: 0}}" }
}).WithAllFilters();
const String template = "{% include 'test' %}";
// Act
//var parsingResult = new LiquidASTGenerator().Generate(template);
var liquidTemplate = LiquidTemplate.Create(template);
var result = liquidTemplate.LiquidTemplate.Render(ctx);
Assert.True(result.HasRenderingErrors);
Assert.Contains("divided by 0", result.RenderingErrors[0].Message);
}
public void It_Should_Render_A_Table_Row_With_A_Generator()
{
// Arrange
TemplateContext ctx = new TemplateContext();
var template = LiquidTemplate.Create(@"{% tablerow n in (1..6) cols:2%}ITER{{n}}{% endtablerow %}");
// Act
String result = template.LiquidTemplate.Render(ctx).Result;
Logger.Log(result);
String expected =
"<tr class=\"row1\">\r\n" +
@"<td class=""col1"">ITER1</td><td class=""col2"">ITER2</td></tr>" + "\r\n" +
@"<tr class=""row2""><td class=""col1"">ITER3</td><td class=""col2"">ITER4</td></tr>" + "\r\n" +
@"<tr class=""row3""><td class=""col1"">ITER5</td><td class=""col2"">ITER6</td></tr>";
// Act
// Assert
Assert.That(result, Is.StringContaining(expected));
}
public ActionResult ReminderPreview(ReminderJSON reminder)
{
var template = db.fees_templates.SingleOrDefault(x => x.id == reminder.templateid);
if (template == null)
{
return(SendJsonErrorResponse("Template not found"));
}
var viewmodel = new Reminder();
viewmodel.Initialise(reminder);
var liquid = new LiquidTemplate(template.body);
liquid.AddParameters("reminder", viewmodel);
var view = liquid.Render();
return(Json(view.ToJsonOKData()));
}
public void It_Should_Include_Name_Of_VirtualFile_With_ParsingErrors()
{
// Arrange
var ctx = CreateContext(new Dictionary <String, String> {
{ "test", "{% if .wefiouhwef %}" }
});
const String str = "{% include 'test' %}";
//IList<LiquidError> renderingErrors = new List<LiquidError>();
//IList<LiquidError> parsingErrors = new List<LiquidError>();
// Act
var template = LiquidTemplate.Create(str);
var result = template.LiquidTemplate.Render(ctx);
//RenderingHelper.RenderTemplate(str, ctx, renderingErrors.Add, parsingErrors.Add);
Assert.False(result.RenderingErrors.Any());
Assert.True(result.ParsingErrors.Any());
Assert.Equal("test", result.ParsingErrors[0].TokenSource);
}
public void It_Should_Lookup_An_Array_In_A_Dictionary()
{
// Arrange
ITemplateContext ctx = new TemplateContext().WithAllFilters();
var arr = new LiquidCollection {
LiquidString.Create("HELLO")
};
ctx.DefineLocalVariable("a", new LiquidHash {
{ "b", arr }
});
//var template = LiquidTemplate.Create("{% assign x = 1 | plus: bar.foo %} 1 + {{ bar.foo }} = {{ x }}");
var template = LiquidTemplate.Create("{{ a.b[0] }} WORLD");
// Act
String result = template.LiquidTemplate.Render(ctx).Result;
Logger.Log(result);
// Assert
Assert.That(result, Is.EqualTo("HELLO WORLD"));
}
public void It_Should_Extend_An_Object()
{
// Arrange
var obj = new LiquidValueConverterTests.ClassWithAttributes {
Ok = "To Liquid"
};
var templateContext = new TemplateContext()
.ErrorWhenValueMissing()
.DefineLocalVariable("test", obj.ToLiquid());
// Act
var parserResult = LiquidTemplate.Create("Hello {{ test.ok }}");
Assert.That(parserResult.HasParsingErrors, Is.False);
var renderingResult = parserResult.LiquidTemplate.Render(templateContext);
Assert.That(renderingResult.HasParsingErrors, Is.False);
Console.WriteLine(String.Join(",", renderingResult.RenderingErrors.Select(x => x.Message)));
Assert.That(renderingResult.HasRenderingErrors, Is.False);
// Assert
Assert.That(renderingResult.Result, Is.EqualTo("Hello To Liquid"));
}
public void It_Should_Register_A_Parsing_Error_At_Rendering_Time_When_Invalid_Syntax()
{
// Arrange
var ctx = CreateContext(new Dictionary <String, String>
{
{ "test", "problem: {% unterminated" }
}).WithAllFilters();
const String template = "{% include 'test' %}";
// Act
//var parsingResult = new LiquidASTGenerator().Generate(template);
//Assert.False(parsingResult.HasParsingErrors);
var liquidTemplate = LiquidTemplate.Create(template);
var result = liquidTemplate.LiquidTemplate.Render(ctx);
//Console.WriteLine(result.Result);
Assert.True(result.HasParsingErrors);
Assert.Contains("missing TAGEND", result.ParsingErrors[0].Message);
}
public void It_Should_Allow_Variables_In_Args()
{
// Arrange
const string templateString = "Result : {%for i in array limit: x offset: y %}{{ i }}{%endfor%}";
TemplateContext ctx = new TemplateContext();
var arr = new LiquidCollection();
for (var index = 1; index < 10; index++)
{
arr.Add(LiquidNumeric.Create(index));
}
ctx.DefineLocalVariable("array", arr);
ctx.DefineLocalVariable("x", LiquidNumeric.Create(2));
ctx.DefineLocalVariable("y", LiquidNumeric.Create(2));
var template = LiquidTemplate.Create(templateString);
// Act
String result = template.LiquidTemplate.Render(ctx).Result;
// Assert
Assert.Equal("Result : 34", result);
}
public void It_Should_Render_A_Table_Row()
{
// Arrange
TemplateContext ctx = new TemplateContext();
ctx.DefineLocalVariable("numbers", DictionaryFactory.CreateArrayFromJson("[1, 2, 3, 4, 5, 6]"));
var template = LiquidTemplate.Create(@"{% tablerow n in numbers cols:2%}ITER{{n}}{% endtablerow %}");
// Act
String result = template.LiquidTemplate.Render(ctx).Result;
Logger.Log(result);
String expected =
"<tr class=\"row1\">\r\n" +
@"<td class=""col1"">ITER1</td><td class=""col2"">ITER2</td></tr>" + "\r\n" +
@"<tr class=""row2""><td class=""col1"">ITER3</td><td class=""col2"">ITER4</td></tr>" + "\r\n" +
@"<tr class=""row3""><td class=""col1"">ITER5</td><td class=""col2"">ITER6</td></tr>";
// Act
// Assert
Assert.That(result, Is.StringContaining(expected));
}
public void It_Should_Parse_Two_Filter_Arguments()
{
// Arrange
LiquidHash dict = new LiquidHash {
{ "foo", LiquidNumeric.Create(22) }, { "bar", LiquidNumeric.Create(23) }
};
ITemplateContext ctx =
new TemplateContext().WithAllFilters()
.WithFilter <FilterFactoryTests.MockStringToStringFilter>("mockfilter")
.DefineLocalVariable("bar", dict)
.DefineLocalVariable("foo", dict);
//LiquidCollection arr = new LiquidCollection(new List<ILiquidValue> { new LiquidNumeric(33) });
//ctx.DefineLocalVariable("bar", arr);
var template = LiquidTemplate.Create("{{ 1 | mockfilter: bar.foo, foo.bar }}");
// Act
String result = template.LiquidTemplate.Render(ctx).Result;
Logger.Log(result);
// Assert
Assert.Equal("1 22 23", result);
}
public void It_Should_Parse_A_Variable_And_A_Value(String liquid, String expected)
{
// Arrange
LiquidHash dict = new LiquidHash {
{ "foo", LiquidNumeric.Create(22) }, { "bar", LiquidNumeric.Create(23) }
};
ITemplateContext ctx =
new TemplateContext().WithAllFilters()
.WithFilter <FilterFactoryTests.MockStringToStringFilter>("mockfilter")
.DefineLocalVariable("bar", dict)
.DefineLocalVariable("foo", dict);
//LiquidCollection arr = new LiquidCollection(new List<ILiquidValue> { new LiquidNumeric(33) });
//ctx.DefineLocalVariable("bar", arr);
var template = LiquidTemplate.Create(liquid);
// Act
String result = template.LiquidTemplate.Render(ctx).Result;
Logger.Log(result);
// Assert
Assert.That(result, Is.EqualTo(expected));
}
public override object ParseLoremIpsum()
{
return(LiquidTemplate.Create(_source3));
}
public override object ParseSample()
{
return(LiquidTemplate.Create(_source1));
}
public LiquidNetBenchmarks()
{
_sampleTemplateLiquidNet = LiquidTemplate.Create(_source1);
}
public override object Parse()
{
return(LiquidTemplate.Create(TextTemplate));
}
public ActionResult ReminderSend(ReminderJSON reminder)
{
var template = db.fees_templates.SingleOrDefault(x => x.id == reminder.templateid);
if (template == null)
{
return(SendJsonErrorResponse("Template not found"));
}
var viewmodel = new Reminder();
viewmodel.Initialise(reminder);
var parent = repository.GetUser(reminder.parentid);
if (parent == null)
{
return(SendJsonErrorResponse("Could not locate parent"));
}
if (reminder.useEmail && string.IsNullOrEmpty(parent.email))
{
return(SendJsonErrorResponse("Selected parent has no email address. Select another parent."));
}
if (reminder.useSMS && string.IsNullOrEmpty(parent.phone_cell))
{
return(SendJsonErrorResponse("Selected parent has no cell phone number. Select another parent."));
}
if (reminder.useEmail)
{
var liquid = new LiquidTemplate(template.body);
liquid.AddParameters("reminder", viewmodel);
var emailbody = liquid.Render();
new Thread(() => Email.SendMail(" School", "*****@*****.**", parent.ToName(false), parent.email, template.title, emailbody, false, null)).Start();
}
// save reminder params into db
foreach (var feeid in reminder.children.SelectMany(x => x.feeids))
{
var dbentry = new fees_reminder();
dbentry.templatename = template.title;
dbentry.created = DateTime.UtcNow;
dbentry.paymentdue = reminder.date_due;
dbentry.receiver = parent.id;
dbentry.sender = sessionid.Value;
dbentry.feeid = feeid;
dbentry.uniqueid = viewmodel.uniqueid;
db.fees_reminders.InsertOnSubmit(dbentry);
}
repository.Save();
// return view
var view = this.RenderViewToString("Alerts",
new[]
{
new LateFeeAlertSiblings(
reminder.children.Select(x => x.studentid))
}).ToJsonOKData();
view.message = "Reminder sent successfully";
return(Json(view));
}
public LiquidParsingResult ParseLoremIpsumLiquidNet()
{
return(LiquidTemplate.Create(_source3));
}
public LiquidParsingResult ParseSampleLiquidNet()
{
return(LiquidTemplate.Create(_source1));
}
protected LiquidTemplate CreateLiquidTemplate(string templateName, string page_title)
{
var template = new LiquidTemplate(MASTERdomain, (bool)Session[BrowserCapability.IsMobileSession]);
template.InitLayoutTemplate("layout/theme.liquid");
if (!string.IsNullOrEmpty(page_title))
{
template.AddParameters("page_title", page_title);
}
template.AddParameters("template", templateName);
template.AddParameters("linklists", new LinkLists(MASTERdomain));
template.AddParameters("pages", new Pages(MASTERdomain));
template.AddParameters("blogs", new Blogs(MASTERdomain));
template.AddParameters("collections", new Collections(MASTERdomain, sessionid));
template.AddParameters("powered_by_link", "<a href='http://www.tradelr.com'>This online store is powered by tradelr</a>");
// settings
var settings_file = string.Format("{0}/{1}/config/settings_data.json", GeneralConstants.APP_ROOT_DIR, template.handler.GetThemeUrl());
template.AddParameters("settings", template.ReadThemeSettings(settings_file));
// cart
var cartid = GetCartIdFromCookie();
var liquidCart = new Cart();
if (!string.IsNullOrEmpty(cartid))
{
var cart = MASTERdomain.carts.SingleOrDefault(x => x.id.ToString() == cartid);
if (cart != null)
{
if (cart.orderid.HasValue)
{
// cart already processed. clear cookie
Response.Cookies["cart"].Expires = DateTime.UtcNow.AddMonths(-1);
}
else
{
liquidCart = cart.ToLiquidModel(sessionid);
}
}
}
template.AddParameters("cart", liquidCart);
template.AddParameters("shop", MASTERdomain.ToLiquidModel());
template.AddHeaderContent(MASTERdomain.metaTagVerification);
// login panel
template.AddParameters("login_for_store",
this.RenderViewToString("~/Views/store/liquid/loginPanel.ascx",
new LoginPanel()
{
isLoggedIn =sessionid.HasValue,
hostName = accountHostname.ToDomainUrl()
}));
// add filters
// currency
var currency = MASTERdomain.currency.ToCurrency();
template.AddFilterValues("currency", currency);
// add registers
template.AddRegisters("current_url", Request.Url);
// add term form date
if (TempData["form"] != null)
{
template.AddParameters("posted_contact_form", TempData["form"]);
}
return template;
}
public override object ParseBig()
{
return(LiquidTemplate.Create(BlogPostTemplate));
}
public LiquidNetBenchmarks()
{
_liquidNetTemplate = LiquidTemplate.Create(ProductTemplate);
}
