public BaseEmailController(
ISmtpService smtpService,
IDisplayHelper displayHelper)
{
_smtpService = smtpService;
_displayHelper = displayHelper;
}
public static bool HoneypotProtectionEnabled(this IDisplayHelper displayHelper)
{
return(displayHelper.HttpContext.GetItem(nameof(HoneypotProtectionEnabled), () =>
{
return displayHelper.Resolve <SecuritySettings>().EnableHoneypotProtection;
}));
}
public async Task <IHtmlContent> TabContainer(IDisplayHelper displayAsync, GroupingsViewModel shape, IShapeFactory shapeFactory)
{
var localNavigation = await shapeFactory.CreateAsync("LocalNavigation", Arguments.From(new
{
shape.Identifier,
Tabs = shape.Groupings
}));
var htmlContentBuilder = new HtmlContentBuilder();
htmlContentBuilder.AppendHtml(await displayAsync.ShapeExecuteAsync(localNavigation));
var tagBuilder = shape.GetTagBuilder("div");
tagBuilder.AddCssClass("tab-content");
htmlContentBuilder.AppendHtml(tagBuilder);
var first = true;
foreach (var tab in shape.Items.OfType <IShape>())
{
if (first)
{
first = false;
tab.Classes.Add("show active");
}
tagBuilder.InnerHtml.AppendHtml(await displayAsync.ShapeExecuteAsync(tab));
}
return(htmlContentBuilder);
}
public RouteHandler_GetPixelColor(
ILogger log,
IDisplayHelper displayHelper
) : base(log)
{
this.displayHelper = displayHelper;
}
public RegistrationController(
IUserService userService,
UserManager <IUser> userManager,
SignInManager <IUser> signInManager,
IAuthorizationService authorizationService,
ISiteService siteService,
INotifier notifier,
ISmtpService smtpService,
IDisplayHelper displayHelper,
ILogger <RegistrationController> logger,
IHtmlLocalizer <RegistrationController> htmlLocalizer,
IStringLocalizer <RegistrationController> stringLocalizer,
IEnumerable <IRegistrationFormEvents> registrationEvents) : base(smtpService, displayHelper)
{
_userService = userService;
_userManager = userManager;
_signInManager = signInManager;
_authorizationService = authorizationService;
_siteService = siteService;
_notifier = notifier;
_registrationEvents = registrationEvents;
_logger = logger;
TH = htmlLocalizer;
T = stringLocalizer;
}
/// <summary>
/// Gets the runtime theme variables as specified in the theme's config file
/// alongside the merged user-defined variables
/// </summary>
public static dynamic GetThemeVariables(this IDisplayHelper displayHelper)
{
return(displayHelper.HttpContext.GetItem("ThemeVariables", () =>
{
// TODO: (core) Implement ThemingDisplayHelper.GetThemeVariables()
return new ExpandoObject();
}));
}
private void EnsureDisplayHelper()
{
if (_displayHelper == null)
{
IDisplayHelperFactory _factory = Context.RequestServices.GetService <IDisplayHelperFactory>();
_displayHelper = _factory.CreateHelper(ViewContext);
}
}
public Task <IHtmlContent> LocalNavigation(IDisplayHelper displayAsync, IShape shape)
{
// Morphing this shape to keep Model untouched.
shape.Metadata.Alternates.Clear();
shape.Metadata.Type = "AdminTabs";
return(displayAsync.ShapeExecuteAsync(shape));
}
public static bool IsMobileDevice(this IDisplayHelper displayHelper)
{
return(displayHelper.HttpContext.GetItem(nameof(IsMobileDevice), () =>
{
var userAgent = displayHelper.Resolve <IUserAgent>();
return userAgent.IsMobileDevice && !userAgent.IsTablet;
}));
}
public TicTacToeGame(IGameBoard gameBoard, IDisplayHelper displayHelper, IRandomNumberGenerator randomNumberGenerator)
{
_gameBoard = gameBoard;
_displayHelper = displayHelper;
_randomNumberGenerator = randomNumberGenerator;
// Started with player factory but I think it was over engineered so replaced it with direct player creations
PlayerO = new Player('O');
PlayerX = new Player('X');
}
public TicTacToeGame(IGameBoard gameBoard, IDisplayHelper displayHelper, IRandomNumberGenerator randomNumberGenerator)
{
_gameBoard = gameBoard;
_displayHelper = displayHelper;
_randomNumberGenerator = randomNumberGenerator;
// Started with player factory but I think it was over engineered so replaced it with direct player creations
PlayerO = new Player('O');
PlayerX = new Player('X');
}
public async Task <IHtmlContent> Column(IDisplayHelper displayAsync, GroupViewModel shape)
{
var tagBuilder = shape.GetTagBuilder("div");
foreach (var column in shape.Items)
{
tagBuilder.InnerHtml.AppendHtml(await displayAsync.ShapeExecuteAsync((IShape)column));
}
return(tagBuilder);
}
public async Task <IHtmlContent> Card(IDisplayHelper displayAsync, GroupingViewModel shape)
{
var tagBuilder = shape.GetTagBuilder("div");
tagBuilder.AddCssClass("card-body");
shape.Metadata.Alternates.Clear();
shape.Metadata.Type = "ColumnGrouping";
tagBuilder.InnerHtml.AppendHtml(await displayAsync.ShapeExecuteAsync(shape));
var cardIdPrefix = $"card-{shape.Identifier}-{shape.Grouping.Key}".HtmlClassify();
var cardTag = new TagBuilder("div");
cardTag.AddCssClass("card mb-2");
var headerArrowTag = new TagBuilder("div");
headerArrowTag.AddCssClass("card-header");
headerArrowTag.Attributes["id"] = $"heading-{cardIdPrefix}";
var headerTitleTag = new TagBuilder("h5");
headerTitleTag.AddCssClass("float-start mb-0 mt-1");
headerTitleTag.InnerHtml.Append(shape.Grouping.Key);
var buttonTag = new TagBuilder("button");
buttonTag.AddCssClass("btn btn-link btn-block text-start float-end");
buttonTag.Attributes["type"] = "button";
buttonTag.Attributes["data-bs-toggle"] = "collapse";
buttonTag.Attributes["data-bs-target"] = $"#collapse-{cardIdPrefix}";
buttonTag.Attributes["aria-expanded"] = "true";
buttonTag.Attributes["aria-controls"] = $"collapse-{cardIdPrefix}";
var buttonIconTag = new TagBuilder("i");
buttonIconTag.AddCssClass("fa-solid fa-angle-down");
buttonTag.InnerHtml.AppendHtml(buttonIconTag);
headerArrowTag.InnerHtml.AppendHtml(headerTitleTag);
headerArrowTag.InnerHtml.AppendHtml(buttonTag);
var bodyTag = new TagBuilder("div");
bodyTag.AddCssClass("collapse show");
bodyTag.Attributes["id"] = $"collapse-{cardIdPrefix}";
bodyTag.InnerHtml.AppendHtml(tagBuilder);
cardTag.InnerHtml.AppendHtml(headerArrowTag);
cardTag.InnerHtml.AppendHtml(bodyTag);
return(cardTag);
}
public static string GenerateHelpUrl(this IDisplayHelper displayHelper, string path)
{
var seoCode = displayHelper.Resolve <IWorkContext>()?.WorkingLanguage?.UniqueSeoCode;
if (seoCode.IsEmpty())
{
return(path);
}
return(SmartstoreVersion.GenerateHelpUrl(seoCode, path));
}
public static bool IsStoreClosed(this IDisplayHelper displayHelper)
{
return(displayHelper.HttpContext.GetItem(nameof(IsStoreClosed), () =>
{
// TODO: (core) Implement SecurityDisplayHelperExtensions.IsStoreClosed()
//var settings = displayHelper.Resolve<StoreInformationSettings>;
//return IsAdmin() && settings.StoreClosedAllowForAdmins ? false : settings.StoreClosed;
return false;
}));
}
public async Task <IHtmlContent> Zone(IDisplayHelper DisplayAsync, IEnumerable <object> Shape)
{
var htmlContentBuilder = new HtmlContentBuilder();
foreach (var item in Shape)
{
htmlContentBuilder.AppendHtml(await DisplayAsync.ShapeExecuteAsync((IShape)item));
}
return(htmlContentBuilder);
}
public override void InitHelpers()
{
base.InitHelpers();
_workContext = ViewContext.GetWorkContext();
//Todo:Test
_displayerHelper = _workContext.Resolve <IDisplayHelper>();
//_display = DisplayHelperFactory.CreateHelper(ViewContext, this);
}
public static bool IsHomePage(this IDisplayHelper displayHelper)
{
return(displayHelper.HttpContext.GetItem(nameof(IsHomePage), () =>
{
var routeValues = displayHelper.HttpContext.GetRouteData().Values;
var response = displayHelper.HttpContext.Response;
return response.StatusCode != 404 &&
routeValues.GetControllerName().EqualsNoCase("home") &&
routeValues.GetActionName().EqualsNoCase("index");
}));
}
public DisplayEntitiesCommand(IDisplayHelper displayHelper,
IAccountsRepository accountsRepository,
IBankTransfersRepository bankTransfersRepository,
IBankSitesRepository bankSitesRepository,
IConsoleHelper consoleHelper)
{
_displayHelper = displayHelper;
_accountsRepository = accountsRepository;
_bankTransfersRepository = bankTransfersRepository;
_bankSitesRepository = bankSitesRepository;
_consoleHelper = consoleHelper;
}
public static bool IsStoreClosed(this IDisplayHelper displayHelper)
{
return(displayHelper.HttpContext.GetItem(nameof(IsStoreClosed), () =>
{
var settings = displayHelper.Resolve <StoreInformationSettings>();
var customer = displayHelper.Resolve <IWorkContext>().CurrentCustomer;
return settings.StoreClosedAllowForAdmins && customer.IsAdmin()
? false
: settings.StoreClosed;
}));
}
private static PageIdentity IdentifyPage(IDisplayHelper displayHelper)
{
return(displayHelper.HttpContext.GetItem("PageIdentity", () =>
{
var context = displayHelper.HttpContext;
var routeValues = context.GetRouteData().Values;
var controllerName = routeValues.GetControllerName().ToLowerInvariant();
var actionName = routeValues.GetActionName().ToLowerInvariant();
string currentPageType = "system";
object currentPageId = controllerName + "." + actionName;
if (displayHelper.IsHomePage())
{
currentPageType = "home";
currentPageId = 0;
}
else if (controllerName == "catalog")
{
if (actionName == "category")
{
currentPageType = "category";
currentPageId = routeValues.Get("categoryId");
}
else if (actionName == "manufacturer")
{
currentPageType = "brand";
currentPageId = routeValues.Get("manufacturerId");
}
}
else if (controllerName == "product")
{
if (actionName == "productdetails")
{
currentPageType = "product";
currentPageId = routeValues.Get("productId");
}
}
else if (controllerName == "topic")
{
if (actionName == "topicdetails")
{
currentPageType = "topic";
currentPageId = routeValues.Get("topicId");
}
}
return new PageIdentity {
CurrentPageId = currentPageId, CurrentPageType = currentPageType
};
}));
}
public MenuFilter(
IMenuStorage menuStorage,
IMenuService menuService,
IWidgetProvider widgetProvider,
IPageAssetBuilder assetBuilder,
IDisplayHelper displayHelper)
{
_menuStorage = menuStorage;
_menuService = menuService;
_widgetProvider = widgetProvider;
_assetBuilder = assetBuilder;
_displayHelper = displayHelper;
}
public async Task <IHtmlContent> CardContainer(IDisplayHelper displayAsync, GroupViewModel shape)
{
var tagBuilder = shape.GetTagBuilder("div");
tagBuilder.AddCssClass("mb-3");
foreach (var card in shape.Items.OfType <IShape>())
{
tagBuilder.InnerHtml.AppendHtml(await displayAsync.ShapeExecuteAsync(card));
}
return(tagBuilder);
}
public async Task <IHtmlContent> Tab(IDisplayHelper displayAsync, GroupingViewModel shape)
{
var tagBuilder = shape.GetTagBuilder("div");
tagBuilder.Attributes["id"] = $"tab-{shape.Grouping.Key}-{shape.Identifier}".HtmlClassify();
tagBuilder.AddCssClass("tab-pane fade");
// Morphing this shape to a grouping shape to keep Model untouched.
shape.Metadata.Alternates.Clear();
shape.Metadata.Type = "CardGrouping";
tagBuilder.InnerHtml.AppendHtml(await displayAsync.ShapeExecuteAsync(shape));
return(tagBuilder);
}
public ChangeEmailController(
IUserService userService,
UserManager <IUser> userManager,
ISiteService siteService,
ISmtpService smtpService,
IDisplayHelper displayHelper,
IStringLocalizer <ChangeEmailController> stringLocalizer,
ILogger <ChangeEmailController> logger)
{
_userService = userService;
_userManager = userManager;
_siteService = siteService;
S = stringLocalizer;
_logger = logger;
}
public ResetPasswordController(
IUserService userService,
UserManager <IUser> userManager,
ISiteService siteService,
ISmtpService smtpService,
IDisplayHelper displayHelper,
IStringLocalizer <ResetPasswordController> stringLocalizer,
ILogger <ResetPasswordController> logger,
IEnumerable <IPasswordRecoveryFormEvents> passwordRecoveryFormEvents)
{
_userService = userService;
_userManager = userManager;
_siteService = siteService;
T = stringLocalizer;
_logger = logger;
_passwordRecoveryFormEvents = passwordRecoveryFormEvents;
}
/// <summary>
/// Modifies a URL (appends/updates a query string part and optionally removes another query string).
/// </summary>
/// <param name="url">The URL to modifiy. If <c>null</c>, the current page's URL is resolved.</param>
/// <param name="query">The new query string part.</param>
/// <param name="removeQueryName">A query string name to remove.</param>
/// <returns>The modified URL.</returns>
public static string ModifyUrl(this IDisplayHelper displayHelper, string url, string query, string removeQueryName = null)
{
var webHelper = displayHelper.Resolve <IWebHelper>();
if (webHelper == null)
{
return(url);
}
url = url.NullEmpty() ?? webHelper.GetCurrentPageUrl(true);
var url2 = webHelper.ModifyQueryString(url, query, null);
if (removeQueryName.HasValue())
{
url2 = webHelper.RemoveQueryParam(url2, removeQueryName);
}
return(url2);
}
/// <summary>
/// Gets a runtime theme variable value
/// </summary>
/// <param name="name">The name of the variable</param>
/// <param name="defaultValue">The default value to return if the variable does not exist</param>
/// <returns>The theme variable value</returns>
public static T GetThemeVariable <T>(this IDisplayHelper displayHelper, string name, T defaultValue = default)
{
Guard.NotEmpty(name, nameof(name));
var vars = GetThemeVariables(displayHelper) as IDictionary <string, object>;
if (vars != null && vars.ContainsKey(name))
{
string value = vars[name] as string;
if (!value.HasValue())
{
return(defaultValue);
}
return(value.Convert <T>());
}
return(defaultValue);
}
/// <summary>
/// Gets the runtime theme variables as specified in the theme's config file
/// alongside the merged user-defined variables
/// </summary>
public static dynamic GetThemeVariables(this IDisplayHelper displayHelper)
{
return(displayHelper.HttpContext.GetItem("ThemeVariables", () =>
{
var services = displayHelper.HttpContext.RequestServices;
var storeContext = services.GetService <IStoreContext>();
var themeManifest = displayHelper.GetThemeManifest();
if (storeContext == null || themeManifest == null)
{
return new ExpandoObject();
}
else
{
var repo = services.GetService <ThemeVariableRepository>();
return repo.GetRawVariablesAsync(themeManifest.ThemeName, storeContext.CurrentStore.Id).Await();
}
}));
}
private static IEnumerable <string> ResolveNotifications(IDisplayHelper displayHelper, NotifyType?type)
{
var allNotifications = displayHelper.HttpContext.GetItem("AllNotifications", () =>
{
var result = Enumerable.Empty <NotifyEntry>();
string key = NotifyFilterAttribute.NotificationsAccessKey;
NotifyEntriesHolder holder;
var tempData = displayHelper.Resolve <ITempDataDictionaryFactory>().GetTempData(displayHelper.HttpContext);
if (tempData.ContainsKey(key))
{
holder = tempData[key] as NotifyEntriesHolder;
if (holder != null)
{
result = result.Concat(holder.Entries);
}
}
var viewData = displayHelper.Resolve <IViewDataAccessor>().ViewData;
if (viewData != null && viewData.ContainsKey(key))
{
holder = viewData[key] as NotifyEntriesHolder;
if (holder != null)
{
result = result.Concat(holder.Entries);
}
}
return(new HashSet <NotifyEntry>(result));
});
if (type == null)
{
return(allNotifications.Select(x => x.Message));
}
return(allNotifications.Where(x => x.Type == type.Value).Select(x => x.Message));
}
public static ICollection <string> GetMessages(this IDisplayHelper displayHelper, NotifyType type)
{
return(ResolveNotifications(displayHelper, type).AsReadOnly());
}
