/// <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)); }