/// <summary>
/// Gets a shortcode definition for the specified shortcode name.
/// </summary>
/// <param name="shortcodeName"></param>
/// <returns></returns>
public static DynamicShortcodeDefinition GetShortcodeDefinition(string shortcodeName)
{
DynamicShortcodeDefinition newShortcode = null;
var shortcodeDefinition = LavaShortcodeCache.All().Where(c => c.TagName != null && c.TagName.Equals(shortcodeName, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
if (shortcodeDefinition == null)
{
return(null);
}
newShortcode = new DynamicShortcodeDefinition();
newShortcode.Name = shortcodeDefinition.Name;
newShortcode.TemplateMarkup = shortcodeDefinition.Markup;
var parameters = RockSerializableDictionary.FromUriEncodedString(shortcodeDefinition.Parameters);
newShortcode.Parameters = new Dictionary <string, string>(parameters.Dictionary);
newShortcode.EnabledLavaCommands = shortcodeDefinition.EnabledLavaCommands.SplitDelimitedValues(",").ToList();
if (shortcodeDefinition.TagType == TagType.Block)
{
newShortcode.ElementType = LavaShortcodeTypeSpecifier.Block;
}
else
{
newShortcode.ElementType = LavaShortcodeTypeSpecifier.Inline;
}
return(newShortcode);
}
/// <summary>
/// Register the specified shortcodes with the Lava Engine.
/// </summary>
/// <param name="engine"></param>
public static void RegisterShortcodes(ILavaEngine engine)
{
ClearCache();
// Register shortcodes defined in the code base.
try
{
var shortcodeTypes = Rock.Reflection.FindTypes(typeof(ILavaShortcode)).Select(a => a.Value).ToList();
foreach (var shortcodeType in shortcodeTypes)
{
engine.RegisterShortcode(shortcodeType.Name, (shortcodeName) =>
{
var shortcode = Activator.CreateInstance(shortcodeType) as ILavaShortcode;
return(shortcode);
});
}
}
catch (Exception ex)
{
ExceptionLogService.LogException(ex, null);
}
// Register shortcodes defined in the current database.
var shortCodes = LavaShortcodeCache.All();
foreach (var shortcode in shortCodes)
{
engine.RegisterShortcode(shortcode.TagName, (shortcodeName) => GetShortcodeDefinition(shortcodeName));
}
}
/// <summary>
/// Initializes the specified tag name.
/// </summary>
/// <param name="tagName">Name of the tag.</param>
/// <param name="markup">The markup.</param>
/// <param name="tokens">The tokens.</param>
/// <exception cref="System.Exception">Could not find the variable to place results in.</exception>
public override void Initialize(string tagName, string markup, List <string> tokens)
{
_markup = markup;
_tagName = tagName;
_shortcode = LavaShortcodeCache.All().Where(c => c.TagName == tagName).FirstOrDefault();
base.Initialize(tagName, markup, tokens);
}
/// <summary>
/// Initializes the specified tag name.
/// </summary>
/// <param name="tagName">Name of the tag.</param>
/// <param name="markup">The markup.</param>
/// <param name="tokens">The tokens.</param>
/// <exception cref="System.Exception">Could not find the variable to place results in.</exception>
public override void Initialize(string tagName, string markup, List <string> tokens)
{
_markup = markup;
_tagName = tagName;
_shortcode = LavaShortcodeCache.Read(_tagName);
base.Initialize(tagName, markup, tokens);
}
/// <summary>
/// Handles the Click event of the btnSave control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
protected void btnSave_Click(object sender, EventArgs e)
{
LavaShortcode lavaShortcode;
var rockContext = new RockContext();
var lavaShortCodeService = new LavaShortcodeService(rockContext);
if (lavaShortCodeService.Queryable().Any(a => a.TagName == tbTagName.Text) && hfOriginalTagName.Value != tbTagName.Text)
{
Page.ModelState.AddModelError("DuplicateTag", "Tag with the same name is already in use.");
return;
}
int lavaShortCode = hfLavaShortcodeId.ValueAsInt();
if (lavaShortCode == 0)
{
lavaShortcode = new LavaShortcode();
lavaShortCodeService.Add(lavaShortcode);
}
else
{
lavaShortcode = lavaShortCodeService.Get(lavaShortCode);
}
lavaShortcode.Name = tbLavaShortcodeName.Text;
lavaShortcode.IsActive = cbIsActive.Checked;
lavaShortcode.Description = tbDescription.Text;
lavaShortcode.Documentation = htmlDocumentation.Text;
lavaShortcode.TagType = rblTagType.SelectedValueAsEnum <TagType>();
lavaShortcode.TagName = tbTagName.Text;
lavaShortcode.Markup = ceMarkup.Text;
lavaShortcode.Parameters = kvlParameters.Value;
lavaShortcode.EnabledLavaCommands = String.Join(",", lcpLavaCommands.SelectedLavaCommands);
rockContext.SaveChanges();
// unregister shortcode
if (hfOriginalTagName.Value.IsNotNullOrWhitespace())
{
Template.UnregisterShortcode(hfOriginalTagName.Value);
}
// register shortcode
if (lavaShortcode.TagType == TagType.Block)
{
Template.RegisterShortcode <DynamicShortcodeBlock>(lavaShortcode.TagName);
}
else
{
Template.RegisterShortcode <DynamicShortcodeInline>(lavaShortcode.TagName);
}
LavaShortcodeCache.Flush(lavaShortcode.Id);
NavigateToParentPage();
}
/// <summary>
/// Method that will be run at Rock startup
/// </summary>
public override void OnStartup()
{
// get all the block dynamic shortcodes and register them
var blockShortCodes = LavaShortcodeCache.All().Where(s => s.TagType == TagType.Block);
foreach (var shortcode in blockShortCodes)
{
// register this shortcode
Template.RegisterShortcode <DynamicShortcodeBlock>(shortcode.TagName);
}
}
/// <summary>
/// Method that will be run at Rock startup
/// </summary>
public override void OnStartup()
{
// get all the inline dynamic shortcodes and register them
var inlineShortCodes = LavaShortcodeCache.All().Where(s => s.TagType == TagType.Inline);
foreach (var shortcode in inlineShortCodes)
{
// register this shortcode
Template.RegisterShortcode <DynamicShortcodeInline>(shortcode.TagName);
}
}
/// <summary>
/// Raises the <see cref="E:System.Web.UI.Control.Load" /> event.
/// </summary>
/// <param name="e">The <see cref="T:System.EventArgs" /> object that contains the event data.</param>
protected override void OnLoad(EventArgs e)
{
RouteCollection routes = RouteTable.Routes;
PageRouteService pageRouteService = new PageRouteService(new Rock.Data.RockContext());
var pageRoutes = pageRouteService.Queryable().ToList();
// Check to see if we have any missing routes. If so, simply run reregister.
foreach (var pageRoute in pageRoutes)
{
var route = routes.OfType <Route>().Where(a => a.Url == pageRoute.Route && a.PageIds().Contains(pageRoute.PageId)).FirstOrDefault();
if (route == null)
{
nbNotification.NotificationBoxType = Rock.Web.UI.Controls.NotificationBoxType.Warning;
nbNotification.Text = "Routes were out-of-date. Running reregister routes.";
ReRegisterRoutes();
break;
}
}
// Check to see if we have any missing shortcodes
var outOfDate = RockDateTime.Now.AddMinutes(-30);
var sc = new LavaShortcodeService(new Rock.Data.RockContext()).Queryable().Where(l => l.CreatedDateTime > outOfDate || l.ModifiedDateTime > outOfDate).ToList();
if (sc.Count > 0)
{
nbNotification.NotificationBoxType = Rock.Web.UI.Controls.NotificationBoxType.Warning;
nbNotification.Text = "Shortcodes were out-of-date. Running register shortcodes. " + sc.Count;
foreach (var code in sc)
{
// register shortcode
if (code.TagType == TagType.Block)
{
Template.RegisterShortcode <DynamicShortcodeBlock>(code.TagName);
}
else
{
Template.RegisterShortcode <DynamicShortcodeInline>(code.TagName);
}
}
LavaShortcodeCache.Clear();
}
}
private static void InitializeLavaShortcodes(ILavaEngine engine)
{
// Register shortcodes defined in the codebase.
try
{
var shortcodeTypes = Rock.Reflection.FindTypes(typeof(ILavaShortcode)).Select(a => a.Value).ToList();
foreach (var shortcodeType in shortcodeTypes)
{
// Create an instance of the shortcode to get the registration name.
var instance = Activator.CreateInstance(shortcodeType) as ILavaShortcode;
var name = instance.SourceElementName;
if (string.IsNullOrWhiteSpace(name))
{
name = shortcodeType.Name;
}
// Register the shortcode with a factory method to create a new instance of the shortcode from the System.Type defined in the codebase.
engine.RegisterShortcode(name, (shortcodeName) =>
{
var shortcode = Activator.CreateInstance(shortcodeType) as ILavaShortcode;
return(shortcode);
});
}
}
catch (Exception ex)
{
ExceptionLogService.LogException(ex, null);
}
// Register shortcodes defined in the current database.
var shortCodes = LavaShortcodeCache.All();
foreach (var shortcode in shortCodes)
{
// Register the shortcode with the current Lava Engine.
// The provider is responsible for retrieving the shortcode definition from the data store and managing the web-based shortcode cache.
WebsiteLavaShortcodeProvider.RegisterShortcode(engine, shortcode.TagName);
}
}
private static void RegisterDynamicShortcodes(ILavaEngine engine)
{
// Register dynamic shortcodes with a factory method to ensure that the latest definition is retrieved from the global cache each time the shortcode is used.
Func <string, DynamicShortcodeDefinition> shortCodeFactory = (shortcodeName) =>
{
var shortcodeDefinition = LavaShortcodeCache.All().Where(c => c.TagName == shortcodeName).FirstOrDefault();
if (shortcodeDefinition == null)
{
return(null);
}
var newShortcode = new DynamicShortcodeDefinition();
newShortcode.Name = shortcodeDefinition.Name;
newShortcode.TemplateMarkup = shortcodeDefinition.Markup;
var parameters = RockSerializableDictionary.FromUriEncodedString(shortcodeDefinition.Parameters);
newShortcode.Parameters = new Dictionary <string, string>(parameters.Dictionary);
newShortcode.EnabledLavaCommands = shortcodeDefinition.EnabledLavaCommands.SplitDelimitedValues(",", StringSplitOptions.RemoveEmptyEntries).ToList();
if (shortcodeDefinition.TagType == TagType.Block)
{
newShortcode.ElementType = LavaShortcodeTypeSpecifier.Block;
}
else
{
newShortcode.ElementType = LavaShortcodeTypeSpecifier.Inline;
}
return(newShortcode);
};
var shortCodes = LavaShortcodeCache.All();
foreach (var shortcode in shortCodes)
{
engine.RegisterShortcode(shortcode.TagName, shortCodeFactory);
}
}
/// <summary>
/// Updates any Cache Objects that are associated with this entity
/// </summary>
/// <param name="entityState">State of the entity.</param>
/// <param name="dbContext">The database context.</param>
public void UpdateCache(EntityState entityState, Rock.Data.DbContext dbContext)
{
LavaShortcodeCache.UpdateCachedEntity(this.Id, entityState);
}
/// <summary>
/// Gets the cache object associated with this Entity
/// </summary>
/// <returns></returns>
public IEntityCache GetCacheObject()
{
return(LavaShortcodeCache.Get(this.Id));
}
/// <summary>
/// Renders the specified context.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="result">The result.</param>
public override void Render(Context context, TextWriter result)
{
// get enabled security commands
if (context.Registers.ContainsKey("EnabledCommands"))
{
_enabledSecurityCommands = context.Registers["EnabledCommands"].ToString();
}
var shortcode = LavaShortcodeCache.Get(_shortcode.Id);
if (shortcode != null)
{
var parms = ParseMarkup(_markup, context);
// add a unique id so shortcodes have easy access to one
parms.AddOrReplace("uniqueid", "id-" + Guid.NewGuid().ToString());
// keep track of the recursion depth
int currentRecurrsionDepth = 0;
if (parms.ContainsKey("RecursionDepth"))
{
currentRecurrsionDepth = parms["RecursionDepth"].ToString().AsInteger() + 1;
if (currentRecurrsionDepth > _maxRecursionDepth)
{
result.Write("A recursive loop was detected and processing of this shortcode has stopped.");
return;
}
}
parms.AddOrReplace("RecursionDepth", currentRecurrsionDepth);
var lavaTemplate = shortcode.Markup;
var blockMarkup = _blockMarkup.ToString().ResolveMergeFields(_internalMergeFields, _enabledSecurityCommands);
// pull child parameters from block content
Dictionary <string, object> childParamters;
blockMarkup = GetChildParameters(blockMarkup, out childParamters);
foreach (var item in childParamters)
{
parms.AddOrReplace(item.Key, item.Value);
}
// merge the block markup in
if (blockMarkup.IsNotNullOrWhiteSpace())
{
Regex rgx = new Regex(@"{{\s*blockContent\s*}}", RegexOptions.IgnoreCase);
lavaTemplate = rgx.Replace(lavaTemplate, blockMarkup);
parms.AddOrReplace("blockContentExists", true);
}
else
{
parms.AddOrReplace("blockContentExists", false);
}
// next ensure they did not use any entity commands in the block that are not allowed
// this is needed as the shortcode it configured to allow entities for processing that
// might allow more entities than the source block, template, action, etc allows
var securityCheck = blockMarkup.ResolveMergeFields(new Dictionary <string, object>(), _enabledSecurityCommands);
Regex securityPattern = new Regex(String.Format(RockLavaBlockBase.NotAuthorizedMessage, ".*"));
Match securityMatch = securityPattern.Match(securityCheck);
if (securityMatch.Success)
{
result.Write(securityMatch.Value); // return security error message
}
else
{
if (shortcode.EnabledLavaCommands.IsNotNullOrWhiteSpace())
{
_enabledSecurityCommands = shortcode.EnabledLavaCommands;
}
var results = lavaTemplate.ResolveMergeFields(parms, _enabledSecurityCommands);
result.Write(results.Trim());
base.Render(context, result);
}
}
else
{
result.Write($"An error occurred while processing the {0} shortcode.", _tagName);
}
}
/// <summary>
/// Clears all of the entries from the shortcode cache.
/// </summary>
public static void ClearCache()
{
LavaShortcodeCache.Clear();
}
