/// <summary>
/// Renders module links.
/// </summary>
/// <param name="mod">The module for which the module links are rendered.</param>
/// <param name="renderMode">The module links' rendering mode.</param>
/// <param name="cssClass">The optional CSS classes to use for the module links.</param>
/// <returns>Returns the module links as HTML.</returns>
public async Task <string> RenderModuleLinksAsync(ModuleDefinition mod, ModuleAction.RenderModeEnum renderMode, string cssClass)
{
HtmlBuilder hb = new HtmlBuilder();
MenuList moduleMenu = await mod.GetModuleMenuListAsync(renderMode, ModuleAction.ActionLocationEnum.ModuleLinks);
string menuContents = (await RenderMenuAsync(moduleMenu, null, Globals.CssModuleLinks));
if (!string.IsNullOrWhiteSpace(menuContents))
{
await Manager.AddOnManager.AddTemplateFromUIHintAsync("ActionIcons"); // action icons
// <div>
YTagBuilder div2Tag = new YTagBuilder("div");
div2Tag.AddCssClass(Manager.AddOnManager.CheckInvokedCssModule(cssClass));
hb.Append(div2Tag.ToString(YTagRenderMode.StartTag));
// <ul><li> menu
hb.Append(menuContents);
// </div>
hb.Append(div2Tag.ToString(YTagRenderMode.EndTag));
}
return(hb.ToString());
}
public override async Task <MenuList> GetModuleMenuListAsync(ModuleAction.RenderModeEnum renderMode, ModuleAction.ActionLocationEnum location)
{
MenuList menuList = await base.GetModuleMenuListAsync(renderMode, location);
AddBlockedNumberModule mod = new AddBlockedNumberModule();
menuList.New(mod.GetAction_Add(AddUrl), location);
return(menuList);
}
public override async Task <MenuList> GetModuleMenuListAsync(ModuleAction.RenderModeEnum renderMode, ModuleAction.ActionLocationEnum location)
{
MenuList menuList = await base.GetModuleMenuListAsync(renderMode, location);
SiteAnnouncementModule mod = new SiteAnnouncementModule();
menuList.New(mod.GetAction_Send(SendUrl), location);
return(menuList);
}
public override async Task <MenuList> GetModuleMenuListAsync(ModuleAction.RenderModeEnum renderMode, ModuleAction.ActionLocationEnum location)
{
MenuList menuList = await base.GetModuleMenuListAsync(renderMode, location);
MenuEditModule mod = new MenuEditModule();
menuList.New(mod.GetAction_Edit(EditUrl, ModuleGuid), location);
return(menuList);
}
public override async Task <MenuList> GetModuleMenuListAsync(ModuleAction.RenderModeEnum renderMode, ModuleAction.ActionLocationEnum location)
{
MenuList menuList = await base.GetModuleMenuListAsync(renderMode, location);
SchedulerAddModule mod = new SchedulerAddModule();
menuList.New(mod.GetAction_Add(AddUrl), location);
LogBrowseModule logMod = new LogBrowseModule();
menuList.NewIf(logMod.GetAction_Items(LogUrl), ModuleAction.ActionLocationEnum.ModuleLinks, location);
return(menuList);
}
public override async Task <MenuList> GetModuleMenuListAsync(ModuleAction.RenderModeEnum renderMode, ModuleAction.ActionLocationEnum location)
{
MenuList menuList = await base.GetModuleMenuListAsync(renderMode, location);
if (location == ModuleAction.ActionLocationEnum.ModuleLinks)
{
using (LogRecordDataProvider dataProvider = LogRecordDataProvider.GetLogRecordDataProvider()) {
menuList.New(await GetAction_RemoveAllAsync());
menuList.New(await GetAction_DownloadZippedLogAsync());
menuList.New(await GetAction_DownloadLogAsync());
}
}
return(menuList);
}
/// <summary>
/// Called by the framework when the component needs to be rendered as HTML.
/// </summary>
/// <param name="model">The model being rendered by the component.</param>
/// <returns>The component rendered as HTML.</returns>
public async Task <string> RenderAsync(ModuleAction model)
{
using (Manager.StartNestedComponent(FieldName)) {
HtmlBuilder hb = new HtmlBuilder();
ModuleAction.RenderModeEnum render = PropData.GetAdditionalAttributeValue("RenderAs", ModuleAction.RenderModeEnum.Button);
if (model != null)
{
hb.Append($@"
<div class='yt_moduleaction t_display'>
{await model.RenderAsync(render)}
</div>");
}
return(hb.ToString());
}
}
public override async Task <MenuList> GetModuleMenuListAsync(ModuleAction.RenderModeEnum renderMode, ModuleAction.ActionLocationEnum location)
{
MenuList menuList = await base.GetModuleMenuListAsync(renderMode, location);
EntryEditModule mod = new EntryEditModule();
int blogEntry;
if (Manager.TryGetUrlArg <int>("BlogEntry", out blogEntry))
{
menuList.New(await mod.GetAction_EditAsync(EditUrl, blogEntry), location);
}
BlogModule blogMod = new BlogModule();
menuList.New(await blogMod.GetAction_RssFeedAsync(), location);
return(menuList);
}
public override async Task <MenuList> GetModuleMenuListAsync(ModuleAction.RenderModeEnum renderMode, ModuleAction.ActionLocationEnum location)
{
MenuList baseMenuList = await base.GetModuleMenuListAsync(renderMode, location);
MenuList menuList = new MenuList();
PageEditModule modEdit = new PageEditModule();
menuList.New(await modEdit.GetAction_EditAsync(null), location);
menuList.New(await GetAction_ExportPageAsync(null), location);
menuList.New(await modEdit.GetAction_RemoveAsync(null), location);
menuList.New(GetAction_SwitchToView(), location);
menuList.New(GetAction_SwitchToEdit(), location);
menuList.New(await GetAction_W3CValidationAsync(), location);
menuList.New(await GetAction_RestartSite(), location);
menuList.New(GetAction_ClearJsCssCache(), location);
menuList.AddRange(baseMenuList);
return(menuList);
}
/// <summary>
/// Called by the framework when the component needs to be rendered as HTML.
/// </summary>
/// <param name="model">The model being rendered by the component.</param>
/// <returns>The component rendered as HTML.</returns>
public async Task <string> RenderAsync(List <ModuleAction> model)
{
using (Manager.StartNestedComponent(FieldName)) {
HtmlBuilder hb = new HtmlBuilder();
ModuleAction.RenderModeEnum render = PropData.GetAdditionalAttributeValue <ModuleAction.RenderModeEnum>("RenderAs", ModuleAction.RenderModeEnum.Button);
if (model != null && model.Count > 0)
{
hb.Append($@"
<div class='yt_moduleactions t_display'>");
foreach (ModuleAction a in model)
{
hb.Append($@"
{ await a.RenderAsync(render) }");
}
hb.Append($@"
</div>");
}
return(hb.ToString());
}
}
public override async Task <MenuList> GetModuleMenuListAsync(ModuleAction.RenderModeEnum renderMode, ModuleAction.ActionLocationEnum location)
{
MenuList menuList = await base.GetModuleMenuListAsync(renderMode, location);
return(menuList);
}
internal static async Task <string> RenderMenuAsync(YHtmlHelper htmlHelper, List <ModuleAction> subMenu, Guid?subGuid, string cssClass, ModuleAction.RenderModeEnum renderMode, ModuleAction.RenderEngineEnum renderEngine, int level)
{
HtmlBuilder hb = new HtmlBuilder();
string menuContents = await RenderLIAsync(htmlHelper, subMenu, subGuid, renderMode, renderEngine, null, level);
if (string.IsNullOrWhiteSpace(menuContents))
{
return(null);
}
// <ul>
YTagBuilder ulTag = new YTagBuilder("ul");
ulTag.AddCssClass(string.Format("t_lvl{0}", level));
if (renderEngine == ModuleAction.RenderEngineEnum.BootstrapSmartMenu)
{
ulTag.AddCssClass("dropdown-menu");
}
if (subGuid != null)
{
ulTag.AddCssClass("t_megamenu_content");
ulTag.AddCssClass("mega-menu"); // used by smartmenus
}
if (!string.IsNullOrWhiteSpace(cssClass))
{
ulTag.AddCssClass(cssClass);
}
hb.Append(ulTag.ToString(YTagRenderMode.StartTag));
// <li>....</li>
hb.Append(menuContents);
// </ul>
hb.Append(ulTag.ToString(YTagRenderMode.EndTag));
return(hb.ToString());
}
internal static async Task <string> RenderLIAsync(YHtmlHelper htmlHelper, List <ModuleAction> subMenu, Guid?subGuid, ModuleAction.RenderModeEnum renderMode, ModuleAction.RenderEngineEnum renderEngine, string liCss, int level)
{
HtmlBuilder hb = new HtmlBuilder();
++level;
if (subGuid != null)
{
// megamenu content
// <li>
YTagBuilder tag = new YTagBuilder("li");
tag.AddCssClass("t_megamenu_content");
if (!string.IsNullOrWhiteSpace(liCss))
{
tag.AddCssClass(liCss);
}
if (renderEngine == ModuleAction.RenderEngineEnum.BootstrapSmartMenu)
{
tag.AddCssClass("nav-item");
}
hb.Append(tag.ToString(YTagRenderMode.StartTag));
ModuleDefinition subMod = await ModuleDefinition.LoadAsync((Guid)subGuid, AllowNone : true);
if (subMod != null)
{
subMod.ShowTitle = false; // don't show the module title in a submenu (temp. override)
if (htmlHelper == null)
{
throw new InternalError("HtmlHelper required for module rendering");
}
hb.Append(await subMod.RenderModuleAsync(htmlHelper));
}
hb.Append("</li>\n");
}
else
{
foreach (var menuEntry in subMenu)
{
if (menuEntry.Enabled && await menuEntry.RendersSomethingAsync())
{
bool rendered = false;
string subMenuContents = null;
Guid?subModGuid = null;
if (!Manager.EditMode)
{
// don't show submodule in edit mode
if ((menuEntry.SubModule != null && menuEntry.SubModule != Guid.Empty))
{
subModGuid = menuEntry.SubModule;
}
}
if (subModGuid != null || (menuEntry.SubMenu != null && menuEntry.SubMenu.Count > 0))
{
subMenuContents = await RenderMenuAsync(htmlHelper, menuEntry.SubMenu, subModGuid, menuEntry.CssClass, renderMode, renderEngine, level);
if (!string.IsNullOrWhiteSpace(subMenuContents))
{
// <li>
YTagBuilder tag = new YTagBuilder("li");
if (renderEngine == ModuleAction.RenderEngineEnum.BootstrapSmartMenu)
{
tag.AddCssClass("dropdown");
tag.AddCssClass("nav-item");
}
if (subModGuid != null)
{
tag.AddCssClass("t_megamenu_hassub");
}
if (!string.IsNullOrWhiteSpace(liCss))
{
tag.AddCssClass(liCss);
}
hb.Append(tag.ToString(YTagRenderMode.StartTag));
string menuContents = await CoreRendering.RenderActionAsync(menuEntry, renderMode, null, RenderEngine : renderEngine, HasSubmenu : true, BootstrapSmartMenuLevel : level);
hb.Append(menuContents);
hb.Append("\n");
hb.Append(subMenuContents);
hb.Append("</li>\n");
rendered = true;
}
}
if (!rendered)
{
// <li>
YTagBuilder tag = new YTagBuilder("li");
//if (!menuEntry.Enabled)
// tag.MergeAttribute("disabled", "disabled");
if (!string.IsNullOrWhiteSpace(liCss))
{
tag.AddCssClass(liCss);
}
if (renderEngine == ModuleAction.RenderEngineEnum.BootstrapSmartMenu)
{
tag.AddCssClass("nav-item");
}
hb.Append(tag.ToString(YTagRenderMode.StartTag));
string menuContents = await CoreRendering.RenderActionAsync(menuEntry, renderMode, null, RenderEngine : renderEngine, BootstrapSmartMenuLevel : level);
hb.Append(menuContents);
hb.Append("</li>\n");
}
}
}
}
--level;
return(hb.ToString());
}
internal static async Task <string> RenderActionAsync(ModuleAction action, ModuleAction.RenderModeEnum mode, string id,
ModuleAction.RenderEngineEnum RenderEngine = ModuleAction.RenderEngineEnum.KendoMenu, int BootstrapSmartMenuLevel = 0, bool HasSubmenu = false)
{
// check if we're in the right mode
if (!await action.RendersSomethingAsync())
{
return(null);
}
await Manager.AddOnManager.AddTemplateFromUIHintAsync("ActionIcons");// this is needed because we're not used by templates
if (!string.IsNullOrWhiteSpace(action.ConfirmationText) && (action.Style != ModuleAction.ActionStyleEnum.Post && action.Style != ModuleAction.ActionStyleEnum.Nothing))
{
throw new InternalError("When using ConfirmationText, the Style property must be set to Post");
}
if (!string.IsNullOrWhiteSpace(action.PleaseWaitText) && (action.Style != ModuleAction.ActionStyleEnum.Normal && action.Style != ModuleAction.ActionStyleEnum.Post))
{
throw new InternalError("When using PleaseWaitText, the Style property must be set to Normal or Post");
}
if (action.CookieAsDoneSignal && action.Style != ModuleAction.ActionStyleEnum.Normal)
{
throw new InternalError("When using CookieAsDoneSignal, the Style property must be set to Normal");
}
ModuleAction.ActionStyleEnum style = action.Style;
if (style == ModuleAction.ActionStyleEnum.OuterWindow)
{
if (!Manager.IsInPopup)
{
style = ModuleAction.ActionStyleEnum.Normal;
}
}
if (style == ModuleAction.ActionStyleEnum.Popup || style == ModuleAction.ActionStyleEnum.PopupEdit)
{
if (Manager.IsInPopup)
{
style = ModuleAction.ActionStyleEnum.NewWindow;
}
}
if (style == ModuleAction.ActionStyleEnum.Popup || style == ModuleAction.ActionStyleEnum.PopupEdit || style == ModuleAction.ActionStyleEnum.ForcePopup)
{
await YetaWFCoreRendering.Render.AddPopupsAddOnsAsync();
}
bool newWindow = false, outerWindow = false;
bool popup = false, popupEdit = false;
bool nothing = false, post = false;
switch (style)
{
default:
case ModuleAction.ActionStyleEnum.Normal:
break;
case ModuleAction.ActionStyleEnum.NewWindow:
newWindow = true;
break;
case ModuleAction.ActionStyleEnum.Popup:
case ModuleAction.ActionStyleEnum.ForcePopup:
popup = Manager.CurrentSite.AllowPopups;
break;
case ModuleAction.ActionStyleEnum.PopupEdit:
popup = Manager.CurrentSite.AllowPopups;
popupEdit = Manager.CurrentSite.AllowPopups;
break;
case ModuleAction.ActionStyleEnum.OuterWindow:
outerWindow = true;
break;
case ModuleAction.ActionStyleEnum.Nothing:
nothing = true;
break;
case ModuleAction.ActionStyleEnum.Post:
post = true;
break;
}
YTagBuilder tag = new YTagBuilder("a");
if (!string.IsNullOrWhiteSpace(action.Tooltip))
{
tag.MergeAttribute(Basics.CssTooltip, action.Tooltip);
}
if (!string.IsNullOrWhiteSpace(action.Name))
{
tag.MergeAttribute("data-name", action.Name);
}
if (!action.Displayed)
{
tag.MergeAttribute("style", "display:none");
}
if (HasSubmenu)
{
if (RenderEngine == ModuleAction.RenderEngineEnum.BootstrapSmartMenu)
{
tag.AddCssClass("dropdown-toggle");
tag.Attributes.Add("data-toggle", "dropdown-toggle");
}
tag.Attributes.Add("aria-haspopup", "true");
tag.Attributes.Add("aria-expanded", "false");
}
if (RenderEngine == ModuleAction.RenderEngineEnum.BootstrapSmartMenu)
{
tag.AddCssClass(BootstrapSmartMenuLevel <= 1 ? "nav-link" : "dropdown-item");
}
if (!string.IsNullOrWhiteSpace(id))
{
tag.Attributes.Add("id", id);
}
if (!string.IsNullOrWhiteSpace(action.CssClass))
{
tag.AddCssClass(Manager.AddOnManager.CheckInvokedCssModule(action.CssClass));
}
string extraClass;
switch (mode)
{
default:
case ModuleAction.RenderModeEnum.Button: extraClass = "y_act_button"; break;
case ModuleAction.RenderModeEnum.ButtonIcon: extraClass = "y_act_buttonicon"; break;
case ModuleAction.RenderModeEnum.ButtonOnly: extraClass = "y_act_buttononly"; break;
case ModuleAction.RenderModeEnum.IconsOnly: extraClass = "y_act_icon"; break;
case ModuleAction.RenderModeEnum.LinksOnly: extraClass = "y_act_link"; break;
case ModuleAction.RenderModeEnum.NormalLinks: extraClass = "y_act_normlink"; break;
case ModuleAction.RenderModeEnum.NormalMenu: extraClass = "y_act_normmenu"; break;
}
tag.AddCssClass(Manager.AddOnManager.CheckInvokedCssModule(extraClass));
string url = action.GetCompleteUrl(OnPage: true);
if (!string.IsNullOrWhiteSpace(url))
{
tag.MergeAttribute("href", Utility.UrlEncodePath(url));
if (Manager.CurrentPage != null)
{
string currUrl = Manager.CurrentPage.EvaluatedCanonicalUrl;
if (!string.IsNullOrWhiteSpace(currUrl) && currUrl != "/") // this doesn't work on home page because everything matches
{
if (action.Url == currUrl)
{
tag.AddCssClass("t_currenturl");
}
if (currUrl.StartsWith(action.Url))
{
tag.AddCssClass("t_currenturlpart");
}
}
}
}
else
{
tag.MergeAttribute("href", "javascript:void(0);");
}
if (!string.IsNullOrWhiteSpace(action.ConfirmationText))
{
if (action.Category == ModuleAction.ActionCategoryEnum.Delete)
{
// confirm deletions?
if (UserSettings.GetProperty <bool>("ConfirmDelete"))
{
tag.MergeAttribute(Basics.CssConfirm, action.ConfirmationText);
}
}
else
{
// confirm actions?
if (UserSettings.GetProperty <bool>("ConfirmActions"))
{
tag.MergeAttribute(Basics.CssConfirm, action.ConfirmationText);
}
}
}
if (!string.IsNullOrWhiteSpace(action.PleaseWaitText))
{
tag.MergeAttribute(Basics.CssPleaseWait, action.PleaseWaitText);
}
if (action.CookieAsDoneSignal)
{
tag.Attributes.Add(Basics.CookieDoneCssAttr, "");
}
if (action.SaveReturnUrl)
{
tag.Attributes.Add(Basics.CssSaveReturnUrl, "");
if (!action.AddToOriginList)
{
tag.Attributes.Add(Basics.CssDontAddToOriginList, "");
}
}
if (!string.IsNullOrWhiteSpace(action.ExtraData))
{
tag.Attributes.Add(Basics.CssExtraData, action.ExtraData);
}
if (action.NeedsModuleContext)
{
tag.Attributes.Add(Basics.CssAddModuleContext, "");
}
if (post)
{
tag.Attributes.Add(Basics.PostAttr, "");
}
if (action.DontFollow || action.CookieAsDoneSignal || post || nothing)
{
tag.MergeAttribute("rel", "nofollow"); // this is so bots don't follow this assuming it's a simple page (Post actions can't be retrieved with GET/HEAD anyway)
}
if (outerWindow)
{
tag.Attributes.Add(Basics.CssOuterWindow, "");
}
if (!nothing)
{
tag.AddCssClass(Manager.AddOnManager.CheckInvokedCssModule(Basics.CssActionLink));
}
if (newWindow)
{
tag.MergeAttribute("target", "_blank");
tag.MergeAttribute("rel", "noopener noreferrer");
}
if (popup)
{
tag.AddCssClass(Manager.AddOnManager.CheckInvokedCssModule(Basics.CssPopupLink));
if (popupEdit)
{
tag.Attributes.Add(Basics.CssAttrDataSpecialEdit, "");
}
}
if (mode == ModuleAction.RenderModeEnum.Button || mode == ModuleAction.RenderModeEnum.ButtonIcon || mode == ModuleAction.RenderModeEnum.ButtonOnly)
{
tag.Attributes.Add(Basics.CssAttrActionButton, "");
}
bool hasText = false, hasImg = false;
string innerHtml = "";
if (mode != ModuleAction.RenderModeEnum.LinksOnly && mode != ModuleAction.RenderModeEnum.ButtonOnly && !string.IsNullOrWhiteSpace(action.ImageUrlFinal))
{
string text = mode == ModuleAction.RenderModeEnum.NormalMenu ? action.MenuText : action.LinkText;
if (RenderEngine == ModuleAction.RenderEngineEnum.KendoMenu)
{
innerHtml += ImageHTML.BuildKnownIcon(action.ImageUrlFinal, alt: text, cssClass: Basics.CssNoTooltip + " k-image"); // k-image is needed to align <i> and <img> correctly
}
else
{
innerHtml += ImageHTML.BuildKnownIcon(action.ImageUrlFinal, alt: text, cssClass: Basics.CssNoTooltip);
}
hasImg = true;
}
if (mode != ModuleAction.RenderModeEnum.IconsOnly && mode != ModuleAction.RenderModeEnum.ButtonIcon)
{
string text = mode == ModuleAction.RenderModeEnum.NormalMenu ? action.MenuText : action.LinkText;
if (!string.IsNullOrWhiteSpace(text))
{
innerHtml += Utility.HtmlEncode(text);
hasText = true;
}
}
if (hasText)
{
if (hasImg)
{
tag.AddCssClass("y_act_textimg");
}
else
{
tag.AddCssClass("y_act_text");
}
}
else
{
if (hasImg)
{
tag.AddCssClass("y_act_img");
}
}
if (HasSubmenu && RenderEngine == ModuleAction.RenderEngineEnum.BootstrapSmartMenu)
{
innerHtml += " <span class='caret'></span>";
}
tag.AddCssClass(Globals.CssModuleNoPrint);
tag.InnerHtml = innerHtml;
return(tag.ToString(YTagRenderMode.Normal));
}
/// <summary>
/// Renders a module action.
/// </summary>
/// <param name="action">The module action to render.</param>
/// <param name="mode">The module action's rendering mode.</param>
/// <param name="id">The ID to generate.</param>
/// <returns>Returns the module action as HTML.</returns>
public async Task <string> RenderModuleActionAsync(ModuleAction action, ModuleAction.RenderModeEnum mode, string id)
{
return(await RenderActionAsync(action, mode, id));
}
