private void RegisterFramework(IServiceCollection serviceCollection)
{
serviceCollection.AddScoped <IPageHeadBuilder, PageHeadBuilder>();
serviceCollection.AddScoped <IThemeProvider, ThemeProvider>();
serviceCollection.AddScoped <IThemeContext, ThemeContext>();
serviceCollection.AddScoped <SlugRouteTransformer>();
serviceCollection.AddScoped <IResourceManager, ResourceManager>();
if (DataSettingsManager.DatabaseIsInstalled())
{
serviceCollection.AddScoped <LocService>();
}
else
{
var provider = serviceCollection.BuildServiceProvider();
var _tmp = provider.GetRequiredService <IStringLocalizerFactory>();
serviceCollection.AddScoped(c => new LocService(_tmp));
}
//powered by
serviceCollection.AddSingleton <IPoweredByMiddlewareOptions, PoweredByMiddlewareOptions>();
}
public void Configure(IApplicationBuilder application, IWebHostEnvironment webHostEnvironment)
{
if (!DataSettingsManager.DatabaseIsInstalled())
{
return;
}
application.UseMiddleware <DbVersionCheckMiddleware>();
}
/// <summary>
/// Add exception handling
/// </summary>
/// <param name="application">Builder for configuring an application's request pipeline</param>
public static void UseGrandExceptionHandler(this IApplicationBuilder application)
{
var serviceProvider = application.ApplicationServices;
var appConfig = serviceProvider.GetRequiredService <AppConfig>();
var hostingEnvironment = serviceProvider.GetRequiredService <IWebHostEnvironment>();
var useDetailedExceptionPage = appConfig.DisplayFullErrorStack || hostingEnvironment.IsDevelopment();
if (useDetailedExceptionPage)
{
//get detailed exceptions for developing and testing purposes
application.UseDeveloperExceptionPage();
}
else
{
//or use special exception handler
application.UseExceptionHandler("/errorpage.htm");
}
//log errors
application.UseExceptionHandler(handler =>
{
handler.Run(async context =>
{
var exception = context.Features.Get <IExceptionHandlerFeature>()?.Error;
if (exception == null)
{
return;
}
string authHeader = context.Request.Headers["Authorization"];
var apirequest = authHeader != null && authHeader.Split(' ')[0] == "Bearer";
if (apirequest)
{
await context.Response.WriteAsync(exception.Message);
return;
}
try
{
//check whether database is installed
if (DataSettingsManager.DatabaseIsInstalled())
{
var logger = context.RequestServices.GetRequiredService <ILogger>();
//get current customer
var workContext = context.RequestServices.GetRequiredService <IWorkContext>();
//log error
logger.Error(exception.Message, exception, workContext.CurrentCustomer);
}
}
finally
{
//rethrow the exception to show the error page
throw exception;
}
});
});
}
private void RegisterInstallService(IServiceCollection serviceCollection)
{
var databaseInstalled = DataSettingsManager.DatabaseIsInstalled();
if (!databaseInstalled)
{
//installation service
serviceCollection.AddScoped <IInstallationLocalizedService, InstallationLocalizedService>();
serviceCollection.AddScoped <IInstallationService, InstallationService>();
}
}
/// <summary>
/// Called before the action executes, after model binding is complete
/// </summary>
/// <param name="context">A context for action filters</param>
public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
{
if (context == null || context.HttpContext == null || context.HttpContext.Request == null)
{
await next();
return;
}
if (!DataSettingsManager.DatabaseIsInstalled())
{
await next();
return;
}
//only in GET requests
if (!HttpMethods.IsGet(context.HttpContext.Request.Method))
{
await next();
return;
}
//whether SEO friendly URLs are enabled
if (!_config.SeoFriendlyUrlsForLanguagesEnabled)
{
await next();
return;
}
var lang = context.RouteData.Values["language"];
if (lang == null)
{
await next();
return;
}
//check whether current page URL is already localized URL
var pageUrl = context.HttpContext?.Request?.GetEncodedPathAndQuery();
if (await IsLocalized(pageUrl, context.HttpContext.Request.PathBase))
{
await next();
return;
}
pageUrl = AddLanguageSeo(pageUrl, context.HttpContext.Request.PathBase, _workContext.WorkingLanguage);
context.Result = new RedirectResult(pageUrl, false);
}
/// <summary>
/// Configure the using of added middleware
/// </summary>
/// <param name="application">Builder for configuring an application's request pipeline</param>
public void Configure(IApplicationBuilder application, IWebHostEnvironment webHostEnvironment)
{
//check whether database is installed
if (!DataSettingsManager.DatabaseIsInstalled())
{
return;
}
//configure authentication
application.UseHostFiltering();
}
/// <summary>
/// Adds services for WebEncoderOptions
/// </summary>
/// <param name="services">Collection of service descriptors</param>
public static void AddWebEncoder(this IServiceCollection services)
{
if (!DataSettingsManager.DatabaseIsInstalled())
{
return;
}
services.Configure <WebEncoderOptions>(options =>
{
options.TextEncoderSettings = new TextEncoderSettings(UnicodeRanges.All);
});
}
public virtual IActionResult RestartInstall()
{
if (DataSettingsManager.DatabaseIsInstalled())
{
return(RedirectToRoute("HomePage"));
}
//stop application
_applicationLifetime.StopApplication();
//Redirect to home page
return(RedirectToRoute("HomePage"));
}
/// <summary>
/// Adds services required for themes support
/// </summary>
/// <param name="services">Collection of service descriptors</param>
public static void AddThemes(this IServiceCollection services)
{
if (!DataSettingsManager.DatabaseIsInstalled())
{
return;
}
//themes support
services.Configure <RazorViewEngineOptions>(options =>
{
options.ViewLocationExpanders.Add(new ThemeViewLocationExpander());
});
}
/// <summary>
/// Save log application started
/// </summary>
/// <param name="application">Builder for configuring an application's request pipeline</param>
public static void LogApplicationStarted(this IApplicationBuilder application)
{
//whether database is already installed
if (!DataSettingsManager.DatabaseIsInstalled())
{
return;
}
var serviceProvider = application.ApplicationServices;
var logger = serviceProvider.GetRequiredService <ILogger>();
logger.Information("Application started", null, null);
}
public void RegisterEndpoint(IEndpointRouteBuilder endpointRouteBuilder)
{
var pattern = "";
if (DataSettingsManager.DatabaseIsInstalled())
{
var config = endpointRouteBuilder.ServiceProvider.GetRequiredService <AppConfig>();
if (config.SeoFriendlyUrlsForLanguagesEnabled)
{
pattern = $"{{language:lang={config.SeoFriendlyUrlsDefaultCode}}}/";
}
}
//home page
endpointRouteBuilder.MapControllerRoute("HomePage", pattern, new { controller = "Home", action = "Index" });
RegisterAccountRoute(endpointRouteBuilder, pattern);
RegisterVendorRoute(endpointRouteBuilder, pattern);
RegisterCartRoute(endpointRouteBuilder, pattern);
RegisterOrderRoute(endpointRouteBuilder, pattern);
RegisterMerchandiseReturnRoute(endpointRouteBuilder, pattern);
RegisterCommonRoute(endpointRouteBuilder, pattern);
RegisterCatalogRoute(endpointRouteBuilder, pattern);
RegisterProductRoute(endpointRouteBuilder, pattern);
RegisterCmsRoute(endpointRouteBuilder, pattern);
RegisterBlogRoute(endpointRouteBuilder, pattern);
RegisterNewsletterRoute(endpointRouteBuilder, pattern);
RegisterAddToCartRoute(endpointRouteBuilder, pattern);
RegisterOutOfStockSubscriptionRoute(endpointRouteBuilder, pattern);
RegisterCheckoutRoute(endpointRouteBuilder, pattern);
RegisterDownloadRoute(endpointRouteBuilder, pattern);
RegisterPageRoute(endpointRouteBuilder, pattern);
RegisterInstallRoute(endpointRouteBuilder, pattern);
}
public virtual IActionResult ChangeLanguage(string language)
{
if (DataSettingsManager.DatabaseIsInstalled())
{
return(RedirectToRoute("HomePage"));
}
var locService = _serviceProvider.GetRequiredService <IInstallationLocalizedService>();
locService.SaveCurrentLanguage(language);
//Reload the page
return(RedirectToAction("Index", "Install"));
}
/// <summary>
/// Configure the using of added middleware
/// </summary>
/// <param name="application">Builder for configuring an application's request pipeline</param>
public void Configure(IApplicationBuilder application, IWebHostEnvironment webHostEnvironment)
{
//check whether database is installed
if (!DataSettingsManager.DatabaseIsInstalled())
{
return;
}
//configure authentication
application.UseGrandAuthentication();
//set workcontext
application.UseMiddleware <WorkContextMiddleware>();
}
/// <summary>
/// Called early in the filter pipeline to confirm request is authorized
/// </summary>
/// <param name="filterContext">Authorization filter context</param>
public async Task OnAuthorizationAsync(AuthorizationFilterContext filterContext)
{
if (filterContext == null)
{
throw new ArgumentNullException(nameof(filterContext));
}
//check whether this filter has been overridden for the action
var actionFilter = filterContext.ActionDescriptor.FilterDescriptors
.Where(f => f.Scope == FilterScope.Action)
.Select(f => f.Filter).OfType <AuthorizeAdminAttribute>().FirstOrDefault();
//ignore filter (the action is available even if a customer hasn't access to the admin area)
if (actionFilter?.IgnoreFilter ?? _ignoreFilter)
{
return;
}
if (!DataSettingsManager.DatabaseIsInstalled())
{
return;
}
//there is AdminAuthorizeFilter, so check access
if (filterContext.Filters.Any(filter => filter is AuthorizeAdminFilter))
{
//authorize permission of access to the admin area
if (!await _permissionService.Authorize(StandardPermission.AccessAdminPanel))
{
filterContext.Result = new RedirectToRouteResult("AdminLogin", new RouteValueDictionary());
}
//get allowed IP addresses
var ipAddresses = _securitySettings.AdminAreaAllowedIpAddresses;
//there are no restrictions
if (ipAddresses == null || !ipAddresses.Any())
{
return;
}
//whether current IP is allowed
var currentIp = filterContext.HttpContext?.Connection?.RemoteIpAddress?.ToString();
if (!ipAddresses.Any(ip => ip.Equals(currentIp, StringComparison.OrdinalIgnoreCase)))
{
filterContext.Result = new RedirectToRouteResult("AdminLogin", new RouteValueDictionary());
}
}
}
public virtual async Task <IActionResult> Index()
{
if (DataSettingsManager.DatabaseIsInstalled())
{
return(RedirectToRoute("HomePage"));
}
var locService = _serviceProvider.GetRequiredService <IInstallationLocalizedService>();
var installed = await _cacheBase.GetAsync("Installed", async() => { return(await Task.FromResult(false)); });
if (installed)
{
return(View(new InstallModel()
{
Installed = true
}));
}
var model = new InstallModel {
AdminEmail = "*****@*****.**",
InstallSampleData = false,
DatabaseConnectionString = "",
};
model.AvailableProviders = Enum.GetValues(typeof(DbProvider)).Cast <DbProvider>().Select(v => new SelectListItem {
Text = v.ToString(),
Value = ((int)v).ToString()
}).ToList();
foreach (var lang in locService.GetAvailableLanguages())
{
model.AvailableLanguages.Add(new SelectListItem {
Value = Url.RouteUrl("InstallChangeLanguage", new { language = lang.Code }),
Text = lang.Name,
Selected = locService.GetCurrentLanguage().Code == lang.Code,
});
}
//prepare collation list
foreach (var col in locService.GetAvailableCollations())
{
model.AvailableCollation.Add(new SelectListItem {
Value = col.Value,
Text = col.Name,
Selected = locService.GetCurrentLanguage().Code == col.Value,
});
}
return(View(model));
}
/// <summary>
/// Adds services required for application session state
/// </summary>
/// <param name="services">Collection of service descriptors</param>
public static void AddHttpSession(this IServiceCollection services, AppConfig config)
{
services.AddSession(options =>
{
options.Cookie = new CookieBuilder()
{
Name = $"{config.CookiePrefix}Session",
HttpOnly = true,
};
if (DataSettingsManager.DatabaseIsInstalled())
{
options.Cookie.SecurePolicy = config.CookieSecurePolicyAlways ? CookieSecurePolicy.Always : CookieSecurePolicy.SameAsRequest;
}
});
}
/// <summary>
/// Create and configure MiniProfiler service
/// </summary>
/// <param name="application">Builder for configuring an application's request pipeline</param>
public static void UseProfiler(this IApplicationBuilder application)
{
//whether database is already installed
if (!DataSettingsManager.DatabaseIsInstalled())
{
return;
}
var appConfig = application.ApplicationServices.GetRequiredService <AppConfig>();
//whether MiniProfiler should be displayed
if (appConfig.DisplayMiniProfilerInPublicStore)
{
application.UseMiniProfiler();
}
}
/// <summary>
/// Configure the using of added middleware
/// </summary>
/// <param name="application">Builder for configuring an application's request pipeline</param>
/// <param name="webHostEnvironment">WebHostEnvironment</param>
public void Configure(IApplicationBuilder application, IWebHostEnvironment webHostEnvironment)
{
//check whether database is installed
if (!DataSettingsManager.DatabaseIsInstalled())
{
return;
}
var serviceProvider = application.ApplicationServices;
var hostingConfig = serviceProvider.GetRequiredService <HostingConfig>();
if (hostingConfig.UseForwardedHeaders)
{
application.UseGrandForwardedHeaders();
}
}
/// <summary>
/// Adds services required for anti-forgery support
/// </summary>
/// <param name="services">Collection of service descriptors</param>
public static void AddAntiForgery(this IServiceCollection services, AppConfig config)
{
//override cookie name
services.AddAntiforgery(options =>
{
options.Cookie = new CookieBuilder()
{
Name = $"{config.CookiePrefix}Antiforgery"
};
if (DataSettingsManager.DatabaseIsInstalled())
{
//whether to allow the use of anti-forgery cookies from SSL protected page on the other store pages which are not
options.Cookie.SecurePolicy = config.CookieSecurePolicyAlways ? CookieSecurePolicy.Always : CookieSecurePolicy.SameAsRequest;
}
});
}
/// <summary>
/// Called before the action executes, after model binding is complete
/// </summary>
/// <param name="context">A context for action filters</param>
public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
{
await next();
if (context == null || context.HttpContext == null || context.HttpContext.Request == null)
{
return;
}
//check request query parameters
var request = context.HttpContext.Request;
if (request?.Query == null || !request.Query.Any())
{
return;
}
if (!DataSettingsManager.DatabaseIsInstalled())
{
return;
}
//try to find by ID
var affiliateIds = request.Query[ID_QUERY_PARAMETER_NAME];
if (affiliateIds.Any())
{
string affiliateId = affiliateIds.FirstOrDefault();
if (!string.IsNullOrEmpty(affiliateId))
{
await SetCustomerAffiliateId(await _affiliateService.GetAffiliateById(affiliateId));
}
return;
}
//try to find by friendly name
var affiliateNames = request.Query[FRIENDLYURLNAME_QUERY_PARAMETER_NAME];
if (affiliateNames.Any())
{
var affiliateName = affiliateNames.FirstOrDefault();
if (!string.IsNullOrEmpty(affiliateName))
{
await SetCustomerAffiliateId(await _affiliateService.GetAffiliateByFriendlyUrlName(affiliateName));
}
}
}
/// <summary>
/// Invoke middleware actions
/// </summary>
/// <param name="context">HTTP context</param>
/// <param name="webHelper">Web helper</param>
/// <returns>Task</returns>
public async Task InvokeAsync(HttpContext context)
{
//whether database is installed
if (!DataSettingsManager.DatabaseIsInstalled())
{
var installUrl = $"/install";
if (!context.Request.GetEncodedPathAndQuery().StartsWith(installUrl, StringComparison.OrdinalIgnoreCase))
{
//redirect
context.Response.Redirect(installUrl);
return;
}
}
//or call the next middleware in the request pipeline
await _next(context);
}
/// <summary>
/// Add Progressive Web App
/// </summary>
/// <param name="services">Collection of service descriptors</param>
public static void AddPWA(this IServiceCollection services, IConfiguration configuration)
{
if (!DataSettingsManager.DatabaseIsInstalled())
{
return;
}
var config = new AppConfig();
configuration.GetSection("Application").Bind(config);
if (config.EnableProgressiveWebApp)
{
var options = new WebEssentials.AspNetCore.Pwa.PwaOptions {
Strategy = (WebEssentials.AspNetCore.Pwa.ServiceWorkerStrategy)config.ServiceWorkerStrategy,
RoutesToIgnore = "/admin/*"
};
services.AddProgressiveWebApp(options);
}
}
/// <summary>
/// Called before the action executes, after model binding is complete
/// </summary>
/// <param name="context">A context for action filters</param>
public async Task OnAuthorizationAsync(AuthorizationFilterContext context)
{
if (context == null || context.HttpContext == null || context.HttpContext.Request == null)
{
return;
}
if (!DataSettingsManager.DatabaseIsInstalled())
{
return;
}
//get action and controller names
var actionDescriptor = context.ActionDescriptor as ControllerActionDescriptor;
var actionName = actionDescriptor?.ActionName;
var controllerName = actionDescriptor?.ControllerName;
if (string.IsNullOrEmpty(actionName) || string.IsNullOrEmpty(controllerName))
{
return;
}
//don't validate on ChangePassword page and store closed
if ((!(controllerName.Equals("Customer", StringComparison.OrdinalIgnoreCase) &&
actionName.Equals("ChangePassword", StringComparison.OrdinalIgnoreCase)))
&&
!(controllerName.Equals("Common", StringComparison.OrdinalIgnoreCase) &&
actionName.Equals("StoreClosed", StringComparison.OrdinalIgnoreCase))
)
{
//check password expiration
var passwordIsExpired = await _mediator.Send(new GetPasswordIsExpiredQuery()
{
Customer = _workContext.CurrentCustomer
});
if (passwordIsExpired)
{
//redirect to ChangePassword page if expires
context.Result = new RedirectToRouteResult("CustomerChangePassword", new RouteValueDictionary());
}
}
}
/// <summary>
/// Called early in the filter pipeline to confirm request is authorized
/// </summary>
/// <param name="filterContext">Authorization filter context</param>
public async Task OnAuthorizationAsync(AuthorizationFilterContext filterContext)
{
//ignore filter (the action available even when navigation is not allowed)
if (filterContext == null)
{
throw new ArgumentNullException(nameof(filterContext));
}
//check whether this filter has been overridden for the Action
var actionFilter = filterContext.ActionDescriptor.FilterDescriptors
.Where(f => f.Scope == FilterScope.Action)
.Select(f => f.Filter).OfType <PublicStoreAttribute>().FirstOrDefault();
//ignore filter (the action is available even if navigation is not allowed)
if (actionFilter?.IgnoreFilter ?? _ignoreFilter)
{
return;
}
if (!DataSettingsManager.DatabaseIsInstalled())
{
return;
}
//check whether current customer has access to a public store
if (await _permissionService.Authorize(StandardPermission.PublicStoreAllowNavigation))
{
return;
}
if (_storeInformationSettings.StoreClosed)
{
filterContext.Result = new RedirectToRouteResult("StoreClosed", new RouteValueDictionary());
}
else
{
//customer has not access to a public store
filterContext.Result = new RedirectToRouteResult("Login", new RouteValueDictionary());
}
}
/// <summary>
/// Add mini profiler service for the application
/// </summary>
/// <param name="services">Collection of service descriptors</param>
public static void AddGrandMiniProfiler(this IServiceCollection services)
{
//whether database is already installed
if (!DataSettingsManager.DatabaseIsInstalled())
{
return;
}
//add MiniProfiler services
services.AddMiniProfiler(options =>
{
options.IgnoredPaths.Add("/api");
options.IgnoredPaths.Add("/odata");
options.IgnoredPaths.Add("/health/live");
options.IgnoredPaths.Add("/.well-known/pki-validation");
//determine who can access the MiniProfiler results
options.ResultsAuthorize = request =>
!request.HttpContext.RequestServices.GetRequiredService <AppConfig>().DisplayMiniProfilerInPublicStore ||
request.HttpContext.RequestServices.GetRequiredService <IPermissionService>().Authorize(StandardPermission.AccessAdminPanel).Result;
});
}
/// <summary>
/// Add and configure any of the middleware
/// </summary>
/// <param name="services">Collection of service descriptors</param>
/// <param name="configuration">Configuration root of the application</param>
public void ConfigureServices(IServiceCollection services, IConfiguration configuration)
{
//database is already installed, so start scheduled tasks
if (DataSettingsManager.DatabaseIsInstalled())
{
var typeSearcher = new AppTypeSearcher();
var scheduleTasks = typeSearcher.ClassesOfType <IScheduleTask>();
var scheduleTasksInstalled = scheduleTasks
.Where(t => PluginExtensions.OnlyInstalledPlugins(t)); //ignore not installed plugins
foreach (var task in scheduleTasksInstalled)
{
var assemblyName = task.Assembly.GetName().Name;
services.AddSingleton <IHostedService, BackgroundServiceTask>(sp =>
{
return(new BackgroundServiceTask($"{task.FullName}, {assemblyName}", sp));
});
}
}
}
/// <summary>
/// Called early in the filter pipeline to confirm request is authorized
/// </summary>
/// <param name="filterContext">Authorization filter context</param>
public async Task OnAuthorizationAsync(AuthorizationFilterContext context)
{
//ignore filter actions
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
//check whether this filter has been overridden for the Action
var actionFilter = context.ActionDescriptor.FilterDescriptors
.Where(f => f.Scope == FilterScope.Action)
.Select(f => f.Filter).OfType <AuthorizeVendorAttribute>().FirstOrDefault();
//ignore filter (the action is available even if the current customer isn't a vendor)
if (actionFilter?.IgnoreFilter ?? _ignoreFilter)
{
return;
}
if (!DataSettingsManager.DatabaseIsInstalled())
{
return;
}
//whether current customer is vendor
if (!await _groupService.IsVendor(_workContext.CurrentCustomer))
{
return;
}
//ensure that this user has active vendor record associated
if (_workContext.CurrentVendor == null)
{
context.Result = new ChallengeResult();
}
}
/// <summary>
/// Called before the action executes, after model binding is complete
/// </summary>
/// <param name="context">A context for action filters</param>
public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
{
await next();
if (context == null || context.HttpContext == null || context.HttpContext.Request == null)
{
return;
}
if (!DataSettingsManager.DatabaseIsInstalled())
{
return;
}
//only in GET requests
if (!HttpMethods.IsGet(context.HttpContext.Request.Method))
{
return;
}
//update last activity date
if (_workContext.CurrentCustomer.LastActivityDateUtc.AddMinutes(1.0) < DateTime.UtcNow)
{
await _customerService.UpdateCustomerField(_workContext.CurrentCustomer, x => x.LastActivityDateUtc, DateTime.UtcNow);
}
//get current IP address
var currentIpAddress = context.HttpContext?.Connection?.RemoteIpAddress?.ToString();
//update customer's IP address
if (!string.IsNullOrEmpty(currentIpAddress) && !currentIpAddress.Equals(_workContext.CurrentCustomer.LastIpAddress, StringComparison.OrdinalIgnoreCase))
{
_workContext.CurrentCustomer.LastIpAddress = currentIpAddress;
await _customerService.UpdateCustomerField(_workContext.CurrentCustomer, x => x.LastIpAddress, currentIpAddress);
}
//whether is need to store last visited page URL
if (!_customerSettings.StoreLastVisitedPage)
{
return;
}
//get current page
var pageUrl = context.HttpContext?.Request?.GetDisplayUrl();
if (string.IsNullOrEmpty(pageUrl))
{
return;
}
//get previous last page
var previousPageUrl = _workContext.CurrentCustomer.GetUserFieldFromEntity <string>(SystemCustomerFieldNames.LastVisitedPage);
//save new one if don't match
if (!pageUrl.Equals(previousPageUrl, StringComparison.OrdinalIgnoreCase))
{
await _userFieldService.SaveField(_workContext.CurrentCustomer, SystemCustomerFieldNames.LastVisitedPage, pageUrl);
}
if (!string.IsNullOrEmpty(context.HttpContext.Request.Headers[HeaderNames.Referer]))
{
if (!context.HttpContext.Request.Headers[HeaderNames.Referer].ToString().Contains(context.HttpContext.Request.Host.ToString()))
{
var previousUrlReferrer = _workContext.CurrentCustomer.GetUserField <string>(_userFieldService, SystemCustomerFieldNames.LastUrlReferrer);
var actualUrlReferrer = context.HttpContext.Request.Headers[HeaderNames.Referer];
if (previousUrlReferrer != actualUrlReferrer)
{
await _userFieldService.SaveField(_workContext.CurrentCustomer, SystemCustomerFieldNames.LastUrlReferrer, actualUrlReferrer);
}
}
}
if (_customerSettings.SaveVisitedPage)
{
if (!_workContext.CurrentCustomer.IsSearchEngineAccount())
{
//activity
await _customerActivityService.InsertActivity("PublicStore.Url", pageUrl, pageUrl, _workContext.CurrentCustomer);
//action
await _customerActionEventService.Url(_workContext.CurrentCustomer, context.HttpContext?.Request?.Path.ToString(), context.HttpContext?.Request?.Headers["Referer"]);
}
}
}
public void RegisterEndpoint(IEndpointRouteBuilder endpointRouteBuilder)
{
if (!DataSettingsManager.DatabaseIsInstalled())
{
return;
}
var pattern = "{**SeName}";
var config = endpointRouteBuilder.ServiceProvider.GetRequiredService <AppConfig>();
if (config.SeoFriendlyUrlsForLanguagesEnabled)
{
pattern = $"{{language:lang={config.SeoFriendlyUrlsDefaultCode}}}/{{**SeName}}";
}
endpointRouteBuilder.MapDynamicControllerRoute <SlugRouteTransformer>(pattern);
//and default one
endpointRouteBuilder.MapControllerRoute(
name: "Default",
pattern: "{controller=Home}/{action=Index}/{id?}");
//generic URLs
endpointRouteBuilder.MapControllerRoute(
name: "GenericUrl",
pattern: "{GenericSeName}",
new { controller = "Common", action = "GenericUrl" });
//define this routes to use in UI views (in case if you want to customize some of them later)
endpointRouteBuilder.MapControllerRoute(
name: "Product",
pattern: pattern,
new { controller = "Product", action = "ProductDetails" });
endpointRouteBuilder.MapControllerRoute(
name: "Category",
pattern: pattern,
new { controller = "Catalog", action = "Category" });
endpointRouteBuilder.MapControllerRoute(
name: "Brand",
pattern: pattern,
new { controller = "Catalog", action = "Brand" });
endpointRouteBuilder.MapControllerRoute(
name: "Collection",
pattern: pattern,
new { controller = "Catalog", action = "Collection" });
endpointRouteBuilder.MapControllerRoute(
name: "Vendor",
pattern: pattern,
new { controller = "Catalog", action = "Vendor" });
endpointRouteBuilder.MapControllerRoute(
name: "NewsItem",
pattern: pattern,
new { controller = "News", action = "NewsItem" });
endpointRouteBuilder.MapControllerRoute(
name: "BlogPost",
pattern: pattern,
new { controller = "Blog", action = "BlogPost" });
endpointRouteBuilder.MapControllerRoute(
name: "Page",
pattern: pattern,
new { controller = "Page", action = "PageDetails" });
endpointRouteBuilder.MapControllerRoute(
name: "KnowledgebaseArticle",
pattern: pattern,
new { controller = "Knowledgebase", action = "KnowledgebaseArticle" });
endpointRouteBuilder.MapControllerRoute(
name: "KnowledgebaseCategory",
pattern: pattern,
new { controller = "Knowledgebase", action = "ArticlesByCategory" });
endpointRouteBuilder.MapControllerRoute(
name: "Course",
pattern: pattern,
new { controller = "Course", action = "Details" });
}
public virtual async Task <IActionResult> Index(InstallModel model)
{
if (DataSettingsManager.DatabaseIsInstalled())
{
return(RedirectToRoute("HomePage"));
}
var locService = _serviceProvider.GetRequiredService <IInstallationLocalizedService>();
if (model.DatabaseConnectionString != null)
{
model.DatabaseConnectionString = model.DatabaseConnectionString.Trim();
}
string connectionString = "";
if (model.ConnectionInfo)
{
if (String.IsNullOrEmpty(model.DatabaseConnectionString))
{
ModelState.AddModelError("", locService.GetResource("ConnectionStringRequired"));
}
else
{
connectionString = model.DatabaseConnectionString;
}
}
else
{
if (String.IsNullOrEmpty(model.MongoDBDatabaseName))
{
ModelState.AddModelError("", locService.GetResource("DatabaseNameRequired"));
}
if (String.IsNullOrEmpty(model.MongoDBServerName))
{
ModelState.AddModelError("", locService.GetResource("MongoDBServerNameRequired"));
}
string userNameandPassword = "";
if (!(String.IsNullOrEmpty(model.MongoDBUsername)))
{
userNameandPassword = model.MongoDBUsername + ":" + model.MongoDBPassword + "@";
}
connectionString = "mongodb://" + userNameandPassword + model.MongoDBServerName + "/" + model.MongoDBDatabaseName;
}
if (!string.IsNullOrEmpty(connectionString))
{
try
{
var mdb = new MongoDBContext();
if (await mdb.DatabaseExist(connectionString))
{
ModelState.AddModelError("", locService.GetResource("AlreadyInstalled"));
}
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.InnerException != null ? ex.InnerException.Message : ex.Message);
}
}
else
{
ModelState.AddModelError("", locService.GetResource("ConnectionStringRequired"));
}
if (ModelState.IsValid)
{
try
{
//save settings
var settings = new DataSettings {
ConnectionString = connectionString,
DbProvider = model.DataProvider
};
await DataSettingsManager.SaveSettings(settings);
var installationService = _serviceProvider.GetRequiredService <IInstallationService>();
await installationService.InstallData(model.AdminEmail, model.AdminPassword, model.Collation,
model.InstallSampleData, model.CompanyName, model.CompanyAddress, model.CompanyPhoneNumber, model.CompanyEmail);
//reset cache
DataSettingsManager.ResetCache();
PluginManager.ClearPlugins();
var pluginsInfo = PluginManager.ReferencedPlugins.ToList();
foreach (var pluginInfo in pluginsInfo)
{
try
{
var plugin = pluginInfo.Instance <IPlugin>(_serviceProvider);
await plugin.Install();
}
catch (Exception ex)
{
var _logger = _serviceProvider.GetRequiredService <ILogger>();
await _logger.InsertLog(Domain.Logging.LogLevel.Error, "Error during installing plugin " + pluginInfo.SystemName,
ex.Message + " " + ex.InnerException?.Message);
}
}
//register default permissions
var permissionProviders = new List <Type>();
permissionProviders.Add(typeof(PermissionProvider));
foreach (var providerType in permissionProviders)
{
var provider = (IPermissionProvider)Activator.CreateInstance(providerType);
await _mediator.Send(new InstallPermissionsCommand()
{
PermissionProvider = provider
});
}
//restart application
await _cacheBase.SetAsync("Installed", true, 120);
return(View(new InstallModel()
{
Installed = true
}));
}
catch (Exception exception)
{
//reset cache
DataSettingsManager.ResetCache();
await _cacheBase.Clear();
System.IO.File.Delete(CommonPath.SettingsPath);
ModelState.AddModelError("", string.Format(locService.GetResource("SetupFailed"), exception.Message + " " + exception.InnerException?.Message));
}
}
//prepare db providers
model.AvailableProviders = Enum.GetValues(typeof(DbProvider)).Cast <DbProvider>().Select(v => new SelectListItem {
Text = v.ToString(),
Value = ((int)v).ToString()
}).ToList();
//prepare language list
foreach (var lang in locService.GetAvailableLanguages())
{
model.AvailableLanguages.Add(new SelectListItem {
Value = Url.RouteUrl("InstallChangeLanguage", new { language = lang.Code }),
Text = lang.Name,
Selected = locService.GetCurrentLanguage().Code == lang.Code,
});
}
//prepare collation list
foreach (var col in locService.GetAvailableCollations())
{
model.AvailableCollation.Add(new SelectListItem {
Value = col.Value,
Text = col.Name,
Selected = locService.GetCurrentLanguage().Code == col.Value,
});
}
return(View(model));
}
