/// <summary> /// Setups the logger using global settings /// </summary> /// <param name="globalSettings">The global settings.</param> public static void Setup(IGlobalSettings globalSettings) { bool blnConfigured = false; try { //if an xml file is present use that var executingFile = new FileInfo(Assembly.GetExecutingAssembly().Location); if (executingFile.Directory != null) { var file = new FileInfo(Path.Combine(executingFile.Directory.FullName, "log.config")); if (file.Exists) { log4net.Config.XmlConfigurator.Configure(file); blnConfigured = true; } } } catch { } //if no configruation file was found via global settings (or it failed) //use fallback default if (blnConfigured == false) { var patternLayout = new PatternLayout { Header = new PatternString("[START MODE=%property{StartMode} DATE=%date{yyyy-MM-dd HH:mm:ss}]\r\n").Format(), Footer = "[END]\r\n", ConversionPattern = "[%date{yyyy-MM-dd HH:mm:ss}] - %message%newline%exception" }; var roller = new RollingFileAppender { Name = "P99AuctionLogger", AppendToFile = true, File = globalSettings.LogFileName, Layout = patternLayout, MaxSizeRollBackups = 5, MaximumFileSize = "10MB", RollingStyle = RollingFileAppender.RollingMode.Size }; var hierarchy = (log4net.Repository.Hierarchy.Hierarchy) LogManager.GetRepository(); var root = hierarchy.Root; var attachable = root as IAppenderAttachable; root.Level = Level.Warn; if (attachable != null) { attachable.AddAppender(roller); roller.ActivateOptions(); } hierarchy.Configured = true; } }
/// <summary> /// Initializes a new instance of the <see cref="ApplicationHostNutConfiguration"/> class. /// </summary> public ApplicationHostNutConfiguration() { var appSettings = new AppConfigApplicationSettings(); _applicationSettings = appSettings; _globalSettings = appSettings; _connectionStrings = new AppConfigConnectionStrings(); }
/// <summary> /// Outputs a script tag containing the bare minimum (non secure) server vars for use with the angular app /// </summary> /// <param name="html"></param> /// <param name="uri"></param> /// <param name="externalLoginsUrl"> /// The post URL used to sign in with external logins - this can change depending on for what service the external login is service. /// Example: normal back office login or authenticating upgrade login /// </param> /// <param name="features"></param> /// <param name="globalSettings"></param> /// <returns></returns> /// <remarks> /// These are the bare minimal server variables that are required for the application to start without being authenticated, /// we will load the rest of the server vars after the user is authenticated. /// </remarks> public static IHtmlString BareMinimumServerVariablesScript(this HtmlHelper html, UrlHelper uri, string externalLoginsUrl, UmbracoFeatures features, IGlobalSettings globalSettings) { var serverVars = new BackOfficeServerVariables(uri, Current.RuntimeState, features, globalSettings); var minVars = serverVars.BareMinimumServerVariables(); var str = @"<script type=""text/javascript""> var Umbraco = {}; Umbraco.Sys = {}; Umbraco.Sys.ServerVariables = " + JsonConvert.SerializeObject(minVars) + @"; </script>"; return(html.Raw(str)); }
public MacrosController(IGlobalSettings globalSettings, IUmbracoContextAccessor umbracoContextAccessor, ISqlContext sqlContext, ServiceContext services, AppCaches appCaches, IProfilingLogger logger, IRuntimeState runtimeState, UmbracoHelper umbracoHelper) : base(globalSettings, umbracoContextAccessor, sqlContext, services, appCaches, logger, runtimeState, umbracoHelper) { _macroService = Services.MacroService; }
/// <summary> /// Initializes a new instance of the <see cref="ClientController" /> class. /// </summary> /// <param name="clientSettings">The client settings.</param> /// <param name="globalSettings">The global settings.</param> /// <param name="balloonController">The balloon controller.</param> /// <param name="logger">The logger.</param> /// <param name="dataDispatcher">The data dispatcher.</param> /// <param name="viewResolver">The view resolver.</param> /// <exception cref="ArgumentNullException"> /// </exception> /// <exception cref="System.ArgumentNullException"></exception> public ClientController(IClientSettings clientSettings, IGlobalSettings globalSettings, IBalloonController balloonController, ILog logger, IDataDispatcher dataDispatcher, IViewResolver viewResolver) { if (clientSettings == null) throw new ArgumentNullException(nameof(clientSettings)); if (globalSettings == null) throw new ArgumentNullException(nameof(globalSettings)); if (balloonController == null) throw new ArgumentNullException(nameof(balloonController)); if (logger == null) throw new ArgumentNullException(nameof(logger)); if (dataDispatcher == null) throw new ArgumentNullException(nameof(dataDispatcher)); if (viewResolver == null) throw new ArgumentNullException(nameof(viewResolver)); _balloonController = balloonController; _clientSettings = clientSettings; _globalSettings = globalSettings; _viewResolver = viewResolver; _logger = logger; _dataDispatcher = dataDispatcher; //setup the view model for the notification window (sys tray) _notificationModel = new NotifyIconViewModel(); _notificationModel.ExitApplication += this.MainWindow_CloseExplicit; _notificationModel.ShowAuctionTracker += this.NotificationView_ShowAuctionTracker; //wire up the dispatcher _dataDispatcher.MessageReceived += this.MessageMonitor_MessageReceived; _dataDispatcher.StatusChanged += this.DataDispatcher_StatusChanged; //Primary window view model _trackerWindowModel = new MainWindowViewModel(); //status message switcher _uiMessageQueue = new UiMessageQueue(500); _uiMessageQueue.ActiveItemChanged += this.UiMessageQueue_ActiveItemChanged; }
/// <summary> /// In order for preview to work this needs to be called /// </summary> /// <param name="app"></param> /// <param name="umbracoContextAccessor"></param> /// <param name="runtimeState"></param> /// <param name="globalSettings"></param> /// <param name="securitySettings"></param> /// <param name="stage"></param> /// <returns></returns> /// <remarks> /// This ensures that during a preview request that the back office use is also Authenticated and that the back office Identity /// is added as a secondary identity to the current IPrincipal so it can be used to Authorize the previewed document. /// </remarks> public static IAppBuilder UseUmbracoPreviewAuthentication(this IAppBuilder app, IUmbracoContextAccessor umbracoContextAccessor, IRuntimeState runtimeState, IGlobalSettings globalSettings, ISecuritySection securitySettings, PipelineStage stage) { if (runtimeState.Level != RuntimeLevel.Run) { return(app); } var authOptions = app.CreateUmbracoCookieAuthOptions(umbracoContextAccessor, globalSettings, runtimeState, securitySettings); app.Use(typeof(PreviewAuthenticationMiddleware), authOptions, Current.Configs.Global()); // This middleware must execute at least on PostAuthentication, by default it is on Authorize // The middleware needs to execute after the RoleManagerModule executes which is during PostAuthenticate, // currently I've had 100% success with ensuring this fires after RoleManagerModule even if this is set // to PostAuthenticate though not sure if that's always a guarantee so by default it's Authorize. if (stage < PipelineStage.PostAuthenticate) { throw new InvalidOperationException("The stage specified for UseUmbracoPreviewAuthentication must be greater than or equal to " + PipelineStage.PostAuthenticate); } app.UseStageMarker(stage); return(app); }
public HttpsCheck(ILocalizedTextService textService, IRuntimeState runtime, IGlobalSettings globalSettings) { _textService = textService; _runtime = runtime; _globalSettings = globalSettings; }
/// <summary> /// Ensures that the UmbracoBackOfficeAuthenticationMiddleware is assigned to the pipeline /// </summary> /// <param name="app"></param> /// <param name="umbracoContextAccessor"></param> /// <param name="runtimeState"></param> /// <param name="userService"></param> /// <param name="globalSettings"></param> /// <param name="securitySection"></param> /// <param name="stage"> /// Configurable pipeline stage /// </param> /// <returns></returns> public static IAppBuilder UseUmbracoBackOfficeCookieAuthentication(this IAppBuilder app, IUmbracoContextAccessor umbracoContextAccessor, IRuntimeState runtimeState, IUserService userService, IGlobalSettings globalSettings, ISecuritySection securitySection, PipelineStage stage) { //Create the default options and provider var authOptions = app.CreateUmbracoCookieAuthOptions(umbracoContextAccessor, globalSettings, runtimeState, securitySection); authOptions.Provider = new BackOfficeCookieAuthenticationProvider(userService, runtimeState, globalSettings) { // Enables the application to validate the security stamp when the user // logs in. This is a security feature which is used when you // change a password or add an external login to your account. OnValidateIdentity = SecurityStampValidator .OnValidateIdentity <BackOfficeUserManager, BackOfficeIdentityUser, int>( TimeSpan.FromMinutes(30), (manager, user) => manager.GenerateUserIdentityAsync(user), identity => identity.GetUserId <int>()), }; return(app.UseUmbracoBackOfficeCookieAuthentication(umbracoContextAccessor, runtimeState, globalSettings, securitySection, authOptions, stage)); }
/// <summary> /// Ensures that the cookie middleware for validating external logins is assigned to the pipeline with the correct /// Umbraco back office configuration /// </summary> /// <param name="app"></param> /// <param name="umbracoContextAccessor"></param> /// <param name="runtimeState"></param> /// <param name="globalSettings"></param> /// <returns></returns> /// <remarks> /// By default this will be configured to execute on PipelineStage.Authenticate /// </remarks> public static IAppBuilder UseUmbracoBackOfficeExternalCookieAuthentication(this IAppBuilder app, IUmbracoContextAccessor umbracoContextAccessor, IRuntimeState runtimeState, IGlobalSettings globalSettings) { return(app.UseUmbracoBackOfficeExternalCookieAuthentication(umbracoContextAccessor, runtimeState, globalSettings, PipelineStage.Authenticate)); }
public SlackWebHookHandler(ITopicService topicService, IGlobalSettings globalSettings) { _topicService = topicService; _globalSettings = globalSettings; this.Receiver = SlackWebHookReceiver.ReceiverName; }
/// <summary> /// Configure a custom BackOfficeUserManager for Umbraco /// </summary> /// <param name="app"></param> /// <param name="runtimeState"></param> /// <param name="globalSettings"></param> /// <param name="userManager"></param> public static void ConfigureUserManagerForUmbracoBackOffice <TManager, TUser>(this IAppBuilder app, IRuntimeState runtimeState, IGlobalSettings globalSettings, Func <IdentityFactoryOptions <TManager>, IOwinContext, TManager> userManager) where TManager : BackOfficeUserManager <TUser> where TUser : BackOfficeIdentityUser { if (runtimeState == null) { throw new ArgumentNullException(nameof(runtimeState)); } if (userManager == null) { throw new ArgumentNullException(nameof(userManager)); } //Configure Umbraco user manager to be created per request app.CreatePerOwinContext <TManager>(userManager); app.SetBackOfficeUserManagerType <TManager, TUser>(); //Create a sign in manager per request app.CreatePerOwinContext <BackOfficeSignInManager>( (options, context) => BackOfficeSignInManager.Create(options, context, globalSettings, app.CreateLogger(typeof(BackOfficeSignInManager).FullName))); }
public static BackOfficeSignInManager Create(IdentityFactoryOptions <BackOfficeSignInManager> options, IOwinContext context, IGlobalSettings globalSettings, ILogger logger) { return(new BackOfficeSignInManager( context.GetBackOfficeUserManager(), context.Authentication, logger, globalSettings, context.Request)); }
public InstallController(IUmbracoContextAccessor umbracoContextAccessor, InstallHelper installHelper, IRuntimeState runtime, ILogger logger, IGlobalSettings globalSettings) { _umbracoContextAccessor = umbracoContextAccessor; _installHelper = installHelper; _runtime = runtime; _logger = logger; _globalSettings = globalSettings; }
public BackOfficeSignInManager(UserManager <BackOfficeIdentityUser, int> userManager, IAuthenticationManager authenticationManager, ILogger logger, IGlobalSettings globalSettings, IOwinRequest request) : base(userManager, authenticationManager) { if (logger == null) { throw new ArgumentNullException("logger"); } if (request == null) { throw new ArgumentNullException("request"); } _logger = logger; _request = request; _globalSettings = globalSettings; AuthenticationType = Constants.Security.BackOfficeAuthenticationType; }
public NewInstallStep(HttpContextBase http, IUserService userService, DatabaseBuilder databaseBuilder, IGlobalSettings globalSettings) { _http = http; _userService = userService; _databaseBuilder = databaseBuilder; _globalSettings = globalSettings; }
public ConnectionManager RegisterGlobalSettings(IGlobalSettings settings) { _globalSettings = settings; return(this); }
public AutoScalingGroup(IGlobalSettings globalSettings) : base(globalSettings) { }
public HomeController(IGlobalSettings globalSettings) { _globalSettings = globalSettings; }
protected ContentControllerBase(IGlobalSettings globalSettings, IUmbracoContextAccessor umbracoContextAccessor, ISqlContext sqlContext, ServiceContext services, AppCaches appCaches, IProfilingLogger logger, IRuntimeState runtimeState, UmbracoHelper umbracoHelper) : base(globalSettings, umbracoContextAccessor, sqlContext, services, appCaches, logger, runtimeState, umbracoHelper) { }
public MediaTypeController(ICultureDictionaryFactory cultureDictionaryFactory, IGlobalSettings globalSettings, IUmbracoContextAccessor umbracoContextAccessor, ISqlContext sqlContext, ServiceContext services, AppCaches appCaches, IProfilingLogger logger, IRuntimeState runtimeState, UmbracoHelper umbracoHelper) : base(cultureDictionaryFactory, globalSettings, umbracoContextAccessor, sqlContext, services, appCaches, logger, runtimeState, umbracoHelper) { }
/// <summary> /// Ensures that the UmbracoBackOfficeAuthenticationMiddleware is assigned to the pipeline /// </summary> /// <param name="app"></param> /// <param name="umbracoContextAccessor"></param> /// <param name="runtimeState"></param> /// <param name="userService"></param> /// <param name="globalSettings"></param> /// <param name="securitySection"></param> /// <returns></returns> /// <remarks> /// By default this will be configured to execute on PipelineStage.Authenticate /// </remarks> public static IAppBuilder UseUmbracoBackOfficeCookieAuthentication(this IAppBuilder app, IUmbracoContextAccessor umbracoContextAccessor, IRuntimeState runtimeState, IUserService userService, IGlobalSettings globalSettings, ISecuritySection securitySection) { return(app.UseUmbracoBackOfficeCookieAuthentication(umbracoContextAccessor, runtimeState, userService, globalSettings, securitySection, PipelineStage.Authenticate)); }
public MediaController(PropertyEditorCollection propertyEditors, IGlobalSettings globalSettings, IUmbracoContextAccessor umbracoContextAccessor, ISqlContext sqlContext, ServiceContext services, AppCaches appCaches, IProfilingLogger logger, IRuntimeState runtimeState, UmbracoHelper umbracoHelper, IContentTypeBaseServiceProvider contentTypeBaseServiceProvider) : base(globalSettings, umbracoContextAccessor, sqlContext, services, appCaches, logger, runtimeState, umbracoHelper) { _propertyEditors = propertyEditors ?? throw new ArgumentNullException(nameof(propertyEditors)); _contentTypeBaseServiceProvider = contentTypeBaseServiceProvider; }
/// <summary> /// Ensures that the UmbracoBackOfficeAuthenticationMiddleware is assigned to the pipeline /// </summary> /// <param name="app"></param> /// <param name="umbracoContextAccessor"></param> /// <param name="runtimeState"></param> /// <param name="globalSettings"></param> /// <param name="securitySection"></param> /// <param name="cookieOptions">Custom auth cookie options can be specified to have more control over the cookie authentication logic</param> /// <param name="stage"> /// Configurable pipeline stage /// </param> /// <returns></returns> public static IAppBuilder UseUmbracoBackOfficeCookieAuthentication(this IAppBuilder app, IUmbracoContextAccessor umbracoContextAccessor, IRuntimeState runtimeState, IGlobalSettings globalSettings, ISecuritySection securitySection, CookieAuthenticationOptions cookieOptions, PipelineStage stage) { if (app == null) { throw new ArgumentNullException(nameof(app)); } if (runtimeState == null) { throw new ArgumentNullException(nameof(runtimeState)); } if (cookieOptions == null) { throw new ArgumentNullException(nameof(cookieOptions)); } if (cookieOptions.Provider == null) { throw new ArgumentNullException("cookieOptions.Provider cannot be null.", nameof(cookieOptions)); } if (cookieOptions.Provider is BackOfficeCookieAuthenticationProvider == false) { throw new ArgumentException($"cookieOptions.Provider must be of type {typeof(BackOfficeCookieAuthenticationProvider)}.", nameof(cookieOptions)); } app.UseUmbracoBackOfficeCookieAuthenticationInternal(cookieOptions, runtimeState, stage); //don't apply if app is not ready if (runtimeState.Level != RuntimeLevel.Upgrade && runtimeState.Level != RuntimeLevel.Run) { return(app); } var cookieAuthOptions = app.CreateUmbracoCookieAuthOptions( umbracoContextAccessor, globalSettings, runtimeState, securitySection, //This defines the explicit path read cookies from for this middleware new[] { $"{globalSettings.Path}/backoffice/UmbracoApi/Authentication/GetRemainingTimeoutSeconds" }); cookieAuthOptions.Provider = cookieOptions.Provider; //This is a custom middleware, we need to return the user's remaining logged in seconds app.Use <GetUserSecondsMiddleWare>( cookieAuthOptions, Current.Configs.Global(), Current.Configs.Settings().Security, app.CreateLogger <GetUserSecondsMiddleWare>()); //This is required so that we can read the auth ticket format outside of this pipeline app.CreatePerOwinContext <UmbracoAuthTicketDataProtector>( (options, context) => new UmbracoAuthTicketDataProtector(cookieOptions.TicketDataFormat)); return(app); }
public AuthenticationController(IGlobalSettings globalSettings, IUmbracoContextAccessor umbracoContextAccessor, ISqlContext sqlContext, ServiceContext services, AppCaches appCaches, IProfilingLogger logger, IRuntimeState runtimeState, UmbracoHelper umbracoHelper) : base(globalSettings, umbracoContextAccessor, sqlContext, services, appCaches, logger, runtimeState, umbracoHelper, Current.Mapper) { }
/// <summary> /// In order for preview to work this needs to be called /// </summary> /// <param name="app"></param> /// <param name="umbracoContextAccessor"></param> /// <param name="runtimeState"></param> /// <param name="globalSettings"></param> /// <param name="securitySettings"></param> /// <returns></returns> /// <remarks> /// This ensures that during a preview request that the back office use is also Authenticated and that the back office Identity /// is added as a secondary identity to the current IPrincipal so it can be used to Authorize the previewed document. /// </remarks> /// <remarks> /// By default this will be configured to execute on PipelineStage.PostAuthenticate /// </remarks> public static IAppBuilder UseUmbracoPreviewAuthentication(this IAppBuilder app, IUmbracoContextAccessor umbracoContextAccessor, IRuntimeState runtimeState, IGlobalSettings globalSettings, ISecuritySection securitySettings) { return(app.UseUmbracoPreviewAuthentication(umbracoContextAccessor, runtimeState, globalSettings, securitySettings, PipelineStage.PostAuthenticate)); }
protected UmbracoWebService(IProfilingLogger profilingLogger, IUmbracoContextAccessor umbracoContextAccessor, UmbracoHelper umbraco, ServiceContext services, IGlobalSettings globalSettings) { Logger = profilingLogger; ProfilingLogger = profilingLogger; UmbracoContextAccessor = umbracoContextAccessor; Umbraco = umbraco; Services = services; GlobalSettings = globalSettings; }
/// <summary> /// Create the default umb cookie auth options /// </summary> /// <param name="app"></param> /// <param name="umbracoContextAccessor"></param> /// <param name="globalSettings"></param> /// <param name="runtimeState"></param> /// <param name="securitySettings"></param> /// <param name="explicitPaths"></param> /// <returns></returns> public static UmbracoBackOfficeCookieAuthOptions CreateUmbracoCookieAuthOptions(this IAppBuilder app, IUmbracoContextAccessor umbracoContextAccessor, IGlobalSettings globalSettings, IRuntimeState runtimeState, ISecuritySection securitySettings, string[] explicitPaths = null) { //this is how aspnet wires up the default AuthenticationTicket protector so we'll use the same code var ticketDataFormat = new TicketDataFormat( app.CreateDataProtector(typeof(CookieAuthenticationMiddleware).FullName, Constants.Security.BackOfficeAuthenticationType, "v1")); var authOptions = new UmbracoBackOfficeCookieAuthOptions( explicitPaths, umbracoContextAccessor, securitySettings, globalSettings, runtimeState, ticketDataFormat); return(authOptions); }
internal static string TryGetApplicationUrl(IUmbracoSettingsSection settings, ILogger logger, IGlobalSettings globalSettings, IServerRegistrar serverRegistrar) { // try umbracoSettings:settings/web.routing/@umbracoApplicationUrl // which is assumed to: // - end with SystemDirectories.Umbraco // - contain a scheme // - end or not with a slash, it will be taken care of // eg "http://www.mysite.com/umbraco" var url = settings.WebRouting.UmbracoApplicationUrl; if (url.IsNullOrWhiteSpace() == false) { var umbracoApplicationUrl = url.TrimEnd('/'); logger.Info(TypeOfApplicationUrlHelper, "ApplicationUrl: {UmbracoAppUrl} (using web.routing/@umbracoApplicationUrl)", umbracoApplicationUrl); return(umbracoApplicationUrl); } // try the server registrar // which is assumed to return a url that: // - end with SystemDirectories.Umbraco // - contain a scheme // - end or not with a slash, it will be taken care of // eg "http://www.mysite.com/umbraco" url = serverRegistrar.GetCurrentServerUmbracoApplicationUrl(); if (url.IsNullOrWhiteSpace() == false) { var umbracoApplicationUrl = url.TrimEnd('/'); logger.Info(TypeOfApplicationUrlHelper, "ApplicationUrl: {UmbracoAppUrl} (IServerRegistrar)", umbracoApplicationUrl); return(umbracoApplicationUrl); } // else give up... return(null); }
public CustomDocumentController(IGlobalSettings globalSettings, IUmbracoContextAccessor umbracoContextAccessor, ServiceContext services, AppCaches appCaches, IProfilingLogger profilingLogger, UmbracoHelper umbracoHelper) : base(globalSettings, umbracoContextAccessor, services, appCaches, profilingLogger, umbracoHelper) { }
public static string GetApplicationUrlFromCurrentRequest(HttpRequestBase request, IGlobalSettings globalSettings) { // if (HTTP and SSL not required) or (HTTPS and SSL required), // use ports from request // otherwise, // if non-standard ports used, // user may need to set umbracoApplicationUrl manually per // https://our.umbraco.com/documentation/Using-Umbraco/Config-files/umbracoSettings/#ScheduledTasks var port = (request.IsSecureConnection == false && globalSettings.UseHttps == false) || (request.IsSecureConnection && globalSettings.UseHttps) ? ":" + request.ServerVariables["SERVER_PORT"] : ""; var useSsl = globalSettings.UseHttps || port == "443"; var ssl = useSsl ? "s" : ""; // force, whatever the first request var url = "http" + ssl + "://" + request.ServerVariables["SERVER_NAME"] + port + IOHelper.ResolveUrl(SystemDirectories.Umbraco); return(url.TrimEnd('/')); }
public DateFormattedUrlProvider(IRequestHandlerSection requestSettings, ILogger logger, IGlobalSettings globalSettings, ISiteDomainHelper siteDomainHelper) : base(requestSettings, logger, globalSettings, siteDomainHelper) { }
public BatchedDatabaseServerMessenger( IRuntimeState runtime, IUmbracoDatabaseFactory databaseFactory, IScopeProvider scopeProvider, ISqlContext sqlContext, IProfilingLogger proflog, IGlobalSettings globalSettings, bool enableDistCalls, DatabaseServerMessengerOptions options) : this(runtime, databaseFactory, scopeProvider, sqlContext, proflog, globalSettings, options) { }
public NotificationProcessor(IGlobalSettings globalSettings, IMessageWrapper messageWrapper) { _globalSettings = globalSettings; _messageWrapper = messageWrapper; _cancellationTokenSource = new CancellationTokenSource(); }
public BatchedDatabaseServerMessenger( IRuntimeState runtime, IUmbracoDatabaseFactory databaseFactory, IScopeProvider scopeProvider, ISqlContext sqlContext, IProfilingLogger proflog, IGlobalSettings globalSettings, DatabaseServerMessengerOptions options) : base(runtime, scopeProvider, sqlContext, proflog, globalSettings, true, options) { _databaseFactory = databaseFactory; }
public TopicService(IGlobalSettings globalSettings) { _globalSettings = globalSettings; Task.Run(() => this.EnsureTopic()).Wait(); }
public MediaTreeController(UmbracoTreeSearcher treeSearcher, IGlobalSettings globalSettings, IUmbracoContextAccessor umbracoContextAccessor, ISqlContext sqlContext, ServiceContext services, AppCaches appCaches, IProfilingLogger logger, IRuntimeState runtimeState, UmbracoHelper umbracoHelper) : base(globalSettings, umbracoContextAccessor, sqlContext, services, appCaches, logger, runtimeState, umbracoHelper) { _treeSearcher = treeSearcher; }