// initializes a new instance of the UmbracoContext class // internal for unit tests // otherwise it's used by EnsureContext above // warn: does *not* manage setting any IUmbracoContextAccessor internal UmbracoContext(HttpContextBase httpContext, IPublishedSnapshotService publishedSnapshotService, WebSecurity webSecurity, IUmbracoSettingsSection umbracoSettings, IEnumerable <IUrlProvider> urlProviders, IGlobalSettings globalSettings, IVariationContextAccessor variationContextAccessor) { if (httpContext == null) { throw new ArgumentNullException(nameof(httpContext)); } if (publishedSnapshotService == null) { throw new ArgumentNullException(nameof(publishedSnapshotService)); } if (webSecurity == null) { throw new ArgumentNullException(nameof(webSecurity)); } if (umbracoSettings == null) { throw new ArgumentNullException(nameof(umbracoSettings)); } if (urlProviders == null) { throw new ArgumentNullException(nameof(urlProviders)); } VariationContextAccessor = variationContextAccessor ?? throw new ArgumentNullException(nameof(variationContextAccessor)); _globalSettings = globalSettings ?? throw new ArgumentNullException(nameof(globalSettings)); // ensure that this instance is disposed when the request terminates, though we *also* ensure // this happens in the Umbraco module since the UmbracoCOntext is added to the HttpContext items. // // also, it *can* be returned by the container with a PerRequest lifetime, meaning that the // container *could* also try to dispose it. // // all in all, this context may be disposed more than once, but DisposableObject ensures that // it is ok and it will be actually disposed only once. httpContext.DisposeOnPipelineCompleted(this); ObjectCreated = DateTime.Now; UmbracoRequestId = Guid.NewGuid(); HttpContext = httpContext; Security = webSecurity; // beware - we cannot expect a current user here, so detecting preview mode must be a lazy thing _publishedSnapshot = new Lazy <IPublishedSnapshot>(() => publishedSnapshotService.CreatePublishedSnapshot(PreviewToken)); // set the urls... // NOTE: The request will not be available during app startup so we can only set this to an absolute URL of localhost, this // is a work around to being able to access the UmbracoContext during application startup and this will also ensure that people // 'could' still generate URLs during startup BUT any domain driven URL generation will not work because it is NOT possible to get // the current domain during application startup. // see: http://issues.umbraco.org/issue/U4-1890 // OriginalRequestUrl = GetRequestFromContext()?.Url ?? new Uri("http://localhost"); CleanedUmbracoUrl = UriUtility.UriToUmbraco(OriginalRequestUrl); UrlProvider = new UrlProvider(this, umbracoSettings.WebRouting, urlProviders, variationContextAccessor); }
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(Constants.CharArrays.ForwardSlash); 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(Constants.CharArrays.ForwardSlash); logger.Info(TypeOfApplicationUrlHelper, "ApplicationUrl: {UmbracoAppUrl} (IServerRegistrar)", umbracoApplicationUrl); return(umbracoApplicationUrl); } // else give up... return(null); }
public LogScrubber(IBackgroundTaskRunner <RecurringTaskBase> runner, int delayMilliseconds, int periodMilliseconds, ApplicationContext appContext, IUmbracoSettingsSection settings) : base(runner, delayMilliseconds, periodMilliseconds) { _appContext = appContext; _settings = settings; }
private static void SetUmbracoSettings(IUmbracoSettingsSection umbracoSettingsSection) { var type = typeof(UmbracoConfig); var method = type.GetMethod("SetUmbracoSettings", BindingFlags.Instance | BindingFlags.NonPublic); method.Invoke(UmbracoConfig.For, new object[] { umbracoSettingsSection }); }
private IBackgroundTask RegisterTaskRunner(IUmbracoSettingsSection settings) { var task = new ScheduledTasks(_tasksRunner, 60000, 60000, _runtime, settings, _logger); _tasksRunner.TryAdd(task); return(task); }
/// <summary> /// Constructor - can be used for testing /// </summary> /// <param name="umbracoSettings"></param> /// <param name="baseRestSettings"></param> /// <param name="dashboardSettings"></param> /// <param name="healthChecks"></param> public UmbracoConfig(IUmbracoSettingsSection umbracoSettings, IBaseRestSection baseRestSettings, IDashboardSection dashboardSettings, IHealthChecks healthChecks) { SetHealthCheckSettings(healthChecks); SetUmbracoSettings(umbracoSettings); SetBaseRestExtensions(baseRestSettings); SetDashboardSettings(dashboardSettings); }
protected ServiceContext GetServiceContext(IUmbracoSettingsSection umbracoSettings, ILogger logger) { //get the mocked service context to get the mocked domain service var svcCtx = MockHelper.GetMockedServiceContext(); var domainService = Mock.Get(svcCtx.DomainService); //setup mock domain service domainService.Setup(service => service.GetAll(It.IsAny <bool>())) .Returns((bool incWildcards) => new[] { new UmbracoDomain("domain1.com/") { Id = 1, LanguageId = LangDeId, RootContentId = 1001, LanguageIsoCode = "de-DE" }, new UmbracoDomain("domain1.com/en") { Id = 1, LanguageId = LangEngId, RootContentId = 10011, LanguageIsoCode = "en-US" }, new UmbracoDomain("domain1.com/fr") { Id = 1, LanguageId = LangFrId, RootContentId = 10012, LanguageIsoCode = "fr-FR" } }); return(svcCtx); }
public ReportSiteTask(IBackgroundTaskRunner <RecurringTaskBase> runner, int delayBeforeWeStart, int howOftenWeRepeat, IProfilingLogger logger, IUmbracoSettingsSection settings) : base(runner, delayBeforeWeStart, howOftenWeRepeat) { _logger = logger; _httpClient = new HttpClient(); _settings = settings; }
public ContextMocker(string[] qKeys = null) { ILogger loggerMock = Mock.Of <ILogger>(); IProfiler profilerMock = Mock.Of <IProfiler>(); IDictionary dictionary = Mock.Of <IDictionary>();// this is related to injecting the dictionary into the mocked UmbracoHelper var session = new Mock <HttpSessionStateBase>(); var contextBaseMock = new Mock <HttpContextBase>(); contextBaseMock.Setup(ctx => ctx.Session).Returns(session.Object); contextBaseMock.SetupGet(ctx => ctx.Items).Returns(dictionary);//// this is related to injecting the dictionary into the mocked UmbracoHelper if (qKeys != null) { var requestMock = new Mock <HttpRequestBase>(); requestMock.SetupGet(r => r.Url).Returns(new Uri("http://imaginary.com")); var mockedQstring = new Mock <NameValueCollection>(); foreach (var k in qKeys) { mockedQstring.Setup(r => r.Get(It.Is <string>(s => s.Contains(k)))).Returns("example_value_" + k); } requestMock.SetupGet(r => r.QueryString).Returns(mockedQstring.Object); contextBaseMock.SetupGet(p => p.Request).Returns(requestMock.Object); } WebSecurity webSecurityMock = new Mock <WebSecurity>(null, null).Object; IUmbracoSettingsSection umbracoSettingsSectionMock = Mock.Of <IUmbracoSettingsSection>(); HttpContextBaseMock = contextBaseMock.Object; ApplicationContextMock = new ApplicationContext(CacheHelper.CreateDisabledCacheHelper(), new ProfilingLogger(loggerMock, profilerMock)); UmbracoContextMock = UmbracoContext.EnsureContext(contextBaseMock.Object, ApplicationContextMock, webSecurityMock, umbracoSettingsSectionMock, Enumerable.Empty <IUrlProvider>(), true); }
public UserPasswordPolicy(MembershipProviderBase provider, IUmbracoSettingsSection umbracoSettings) : base(provider) { if (umbracoSettings != null) { ForgotPasswordLinkAvailable = umbracoSettings.Security.AllowPasswordReset; DisableAlternativeTemplates = umbracoSettings.WebRouting.DisableAlternativeTemplates; DisableFindContentById = umbracoSettings.WebRouting.DisableFindContentByIdPath; } if (int.TryParse(ConfigurationManager.AppSettings["umbracoTimeOutInMinutes"], out int timeout)) { UmbracoTimeoutInMinutes = timeout; } if (bool.TryParse(ConfigurationManager.AppSettings["umbracoUseSSL"], out bool umbracoUseSSL)) { UmbracoUseSSL = umbracoUseSSL; } if (ConfigurationManager.GetSection("system.web/httpRuntime") is HttpRuntimeSection httpRuntimeSection) { MaxRequestLength = httpRuntimeSection.MaxRequestLength; } // TODO: MaxAllowedContentLength // TODO: MaxRequestLengthUmbraco // TODO: MaxAllowedContentLengthUmbraco }
public override void Initialize() { base.Initialize(); //generate new mock settings and assign so we can configure in individual tests _umbracoSettings = SettingsForTests.GenerateMockSettings(); SettingsForTests.ConfigureSettings(_umbracoSettings); var url = "/test"; var lookup = new Umbraco.Web.Routing.ContentFinderByNiceUrl(); var lookups = new Umbraco.Web.Routing.IContentFinder[] { lookup }; var t = Template.MakeNew("test", new User(0)); var umbracoContext = GetUmbracoContext(url, t.Id); var urlProvider = new UrlProvider(umbracoContext, _umbracoSettings.WebRouting, new IUrlProvider[] { new DefaultUrlProvider() }); var routingContext = new RoutingContext( umbracoContext, lookups, new FakeLastChanceFinder(), urlProvider); //assign the routing context back to the umbraco context umbracoContext.RoutingContext = routingContext; ////assign the routing context back to the umbraco context //umbracoContext.RoutingContext = routingContext; Umbraco.Web.UmbracoContext.Current = routingContext.UmbracoContext; }
public ScheduledTasks(IBackgroundTaskRunner <RecurringTaskBase> runner, int delayMilliseconds, int periodMilliseconds, IRuntimeState runtime, IUmbracoSettingsSection settings, IProfilingLogger logger) : base(runner, delayMilliseconds, periodMilliseconds) { _runtime = runtime; _settings = settings; _logger = logger; }
public override void Initialize() { base.Initialize(); //generate new mock settings and assign so we can configure in individual tests _umbracoSettings = SettingsForTests.GenerateMockSettings(); SettingsForTests.ConfigureSettings(_umbracoSettings); }
/// <summary> /// Creates a standalone UmbracoContext instance /// </summary> /// <param name="httpContext"></param> /// <param name="applicationContext"></param> /// <param name="webSecurity"></param> /// <param name="umbracoSettings"></param> /// <param name="urlProviders"></param> /// <param name="preview"></param> /// <returns> /// A new instance of UmbracoContext /// </returns> public static UmbracoContext CreateContext( HttpContextBase httpContext, ApplicationContext applicationContext, WebSecurity webSecurity, IUmbracoSettingsSection umbracoSettings, IEnumerable <IUrlProvider> urlProviders, bool?preview) { if (httpContext == null) { throw new ArgumentNullException("httpContext"); } if (applicationContext == null) { throw new ArgumentNullException("applicationContext"); } if (webSecurity == null) { throw new ArgumentNullException("webSecurity"); } if (umbracoSettings == null) { throw new ArgumentNullException("umbracoSettings"); } if (urlProviders == null) { throw new ArgumentNullException("urlProviders"); } var umbracoContext = new UmbracoContext( httpContext, applicationContext, new Lazy <IPublishedCaches>(() => PublishedCachesResolver.Current.Caches, false), webSecurity, preview); // create the RoutingContext, and assign var routingContext = new RoutingContext( umbracoContext, //TODO: Until the new cache is done we can't really expose these to override/mock new Lazy <IEnumerable <IContentFinder> >(() => ContentFinderResolver.Current.Finders), new Lazy <IContentFinder>(() => ContentLastChanceFinderResolver.Current.Finder), // create the nice urls provider // there's one per request because there are some behavior parameters that can be changed new Lazy <UrlProvider>( () => new UrlProvider( umbracoContext, umbracoSettings.WebRouting, urlProviders), false)); //assign the routing context back umbracoContext.RoutingContext = routingContext; return(umbracoContext); }
public TestServices(HttpRequestMessage httpRequestMessage, UmbracoContext umbracoContext, ITypedPublishedContentQuery publishedContentQuery, ServiceContext serviceContext, BaseSearchProvider searchProvider, IUmbracoSettingsSection umbracoSettings) { HttpRequestMessage = httpRequestMessage; UmbracoContext = umbracoContext; PublishedContentQuery = publishedContentQuery; ServiceContext = serviceContext; SearchProvider = searchProvider; UmbracoSettings = umbracoSettings; }
private IBackgroundTask RegisterLogScrubber(IUmbracoSettingsSection settings) { // log scrubbing // install on all, will only run on non-replica servers var task = new LogScrubber(_scrubberRunner, DefaultDelayMilliseconds, LogScrubber.GetLogScrubbingInterval(settings, _logger), _runtime, _auditService, settings, _scopeProvider, _logger); _scrubberRunner.TryAdd(task); return(task); }
/// <summary> /// Initializes a new instance of the <see cref="RuntimeState"/> class. /// </summary> public RuntimeState(ILogger logger, IUmbracoSettingsSection settings, IGlobalSettings globalSettings, Lazy <IMainDom> mainDom, Lazy <IServerRegistrar> serverRegistrar) { _logger = logger; _settings = settings; _globalSettings = globalSettings; _mainDom = mainDom; _serverRegistrar = serverRegistrar; }
private void SetupUmbraco() { settings = SettingsForTests.GenerateMockSettings(); SettingsForTests.ConfigureSettings(settings); routingContext = GetRoutingContext("http://localhost", -1, new RouteData()); umbracoContext = routingContext.UmbracoContext; umbracoContext.PublishedContentRequest = new PublishedContentRequest(new Uri("http://localhost"), routingContext, settings.WebRouting, (s) => new[] { "Kunde" }); }
public LogScrubber(IBackgroundTaskRunner <RecurringTaskBase> runner, int delayMilliseconds, int periodMilliseconds, IRuntimeState runtime, IAuditService auditService, IUmbracoSettingsSection settings, IScopeProvider scopeProvider, IProfilingLogger logger) : base(runner, delayMilliseconds, periodMilliseconds) { _runtime = runtime; _auditService = auditService; _settings = settings; _scopeProvider = scopeProvider; _logger = logger; }
/// <summary> /// Gets an Umbraco Context instance for non pipeline requiests. /// </summary> /// <returns>The <see cref="UmbracoContext"/></returns> private UmbracoContext EnsureUmbracoContext() { HttpContextBase context = this.HttpContext; ApplicationContext application = ApplicationContext.Current; WebSecurity security = new WebSecurity(context, application); IUmbracoSettingsSection umbracoSettings = UmbracoConfig.For.UmbracoSettings(); IEnumerable <IUrlProvider> providers = UrlProviderResolver.Current.Providers; return(UmbracoContext.EnsureContext(context, application, security, umbracoSettings, providers, false)); }
// internal for tests internal static bool TrySetApplicationUrl(ApplicationContext appContext, IUmbracoSettingsSection settings) { var logger = appContext.ProfilingLogger.Logger; // 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) { appContext._umbracoApplicationUrl = url.TrimEnd('/'); logger.Info(TypeOfApplicationUrlHelper, "ApplicationUrl: " + appContext.UmbracoApplicationUrl + " (using web.routing/@umbracoApplicationUrl)"); return(true); } // try umbracoSettings:settings/scheduledTasks/@baseUrl // which is assumed to: // - end with SystemDirectories.Umbraco // - NOT contain any scheme (because, legacy) // - end or not with a slash, it will be taken care of // eg "mysite.com/umbraco" url = settings.ScheduledTasks.BaseUrl; if (url.IsNullOrWhiteSpace() == false) { var ssl = GlobalSettings.UseSSL ? "s" : ""; url = "http" + ssl + "://" + url; appContext._umbracoApplicationUrl = url.TrimEnd('/'); logger.Info(TypeOfApplicationUrlHelper, "ApplicationUrl: " + appContext.UmbracoApplicationUrl + " (using scheduledTasks/@baseUrl)"); return(true); } // 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" var resolver = ServerRegistrarResolver.HasCurrent ? ServerRegistrarResolver.Current : null; var registrar = resolver == null ? null : resolver.Registrar as IServerRegistrar2; url = registrar == null ? null : registrar.GetCurrentServerUmbracoApplicationUrl(); if (url.IsNullOrWhiteSpace() == false) { appContext._umbracoApplicationUrl = url.TrimEnd('/'); logger.Info(TypeOfApplicationUrlHelper, "ApplicationUrl: " + appContext.UmbracoApplicationUrl + " (IServerRegistrar)"); return(true); } // else give up... return(false); }
/// <summary> /// Sets the default configuration. /// </summary> /// <returns>The short string helper.</returns> public DefaultShortStringHelperConfig WithDefault(IUmbracoSettingsSection umbracoSettings) { ForceSafeAliases = umbracoSettings.Content.ForceSafeAliases; UrlReplaceCharacters = umbracoSettings.RequestHandler.CharCollection .Where(x => string.IsNullOrEmpty(x.Char) == false) .ToDictionary(x => x.Char, x => x.Replacement); var urlSegmentConvertTo = CleanStringType.Utf8; if (umbracoSettings.RequestHandler.ConvertUrlsToAscii) { urlSegmentConvertTo = CleanStringType.Ascii; } if (umbracoSettings.RequestHandler.TryConvertUrlsToAscii) { urlSegmentConvertTo = CleanStringType.TryAscii; } return(WithConfig(CleanStringType.UrlSegment, new Config { PreFilter = ApplyUrlReplaceCharacters, PostFilter = x => CutMaxLength(x, 240), IsTerm = (c, leading) => char.IsLetterOrDigit(c) || c == '_', // letter, digit or underscore StringType = urlSegmentConvertTo | CleanStringType.LowerCase, BreakTermsOnUpper = false, Separator = '-' }).WithConfig(CleanStringType.FileName, new Config { PreFilter = ApplyUrlReplaceCharacters, IsTerm = (c, leading) => char.IsLetterOrDigit(c) || c == '_', // letter, digit or underscore StringType = CleanStringType.Utf8 | CleanStringType.LowerCase, BreakTermsOnUpper = false, Separator = '-' }).WithConfig(CleanStringType.Alias, new Config { PreFilter = ApplyUrlReplaceCharacters, IsTerm = (c, leading) => leading ? char.IsLetter(c) // only letters : (char.IsLetterOrDigit(c) || c == '_'), // letter, digit or underscore StringType = CleanStringType.Ascii | CleanStringType.UmbracoCase, BreakTermsOnUpper = false }).WithConfig(CleanStringType.UnderscoreAlias, new Config { PreFilter = ApplyUrlReplaceCharacters, IsTerm = (c, leading) => char.IsLetterOrDigit(c) || c == '_', // letter, digit or underscore StringType = CleanStringType.Ascii | CleanStringType.UmbracoCase, BreakTermsOnUpper = false }).WithConfig(CleanStringType.ConvertCase, new Config { PreFilter = null, IsTerm = (c, leading) => char.IsLetterOrDigit(c) || c == '_', // letter, digit or underscore StringType = CleanStringType.Ascii, BreakTermsOnUpper = true })); }
private void Setup() { ILogger loggerMock = Mock.Of <ILogger>(); IProfiler profilerMock = Mock.Of <IProfiler>(); HttpContextBase contextBaseMock = Mock.Of <HttpContextBase>(); WebSecurity webSecurityMock = new Mock <WebSecurity>(null, null).Object; IUmbracoSettingsSection umbracoSettingsSectionMock = Mock.Of <IUmbracoSettingsSection>(); ApplicationContext.Current = new ApplicationContext(CacheHelper.CreateDisabledCacheHelper(), new ProfilingLogger(loggerMock, profilerMock)); UmbracoContext.Current = UmbracoContext.EnsureContext(contextBaseMock, ApplicationContext.Current, webSecurityMock, umbracoSettingsSectionMock, Enumerable.Empty <IUrlProvider>(), true); }
/// <summary> /// Initializes a new instance of the <see cref="UmbracoContextFactory"/> class. /// </summary> public UmbracoContextFactory(IUmbracoContextAccessor umbracoContextAccessor, IPublishedSnapshotService publishedSnapshotService, IVariationContextAccessor variationContextAccessor, IDefaultCultureAccessor defaultCultureAccessor, IUmbracoSettingsSection umbracoSettings, IGlobalSettings globalSettings, UrlProviderCollection urlProviders, IUserService userService) { _umbracoContextAccessor = umbracoContextAccessor ?? throw new ArgumentNullException(nameof(umbracoContextAccessor)); _publishedSnapshotService = publishedSnapshotService ?? throw new ArgumentNullException(nameof(publishedSnapshotService)); _variationContextAccessor = variationContextAccessor ?? throw new ArgumentNullException(nameof(variationContextAccessor)); _defaultCultureAccessor = defaultCultureAccessor ?? throw new ArgumentNullException(nameof(defaultCultureAccessor)); _umbracoSettings = umbracoSettings ?? throw new ArgumentNullException(nameof(umbracoSettings)); _globalSettings = globalSettings ?? throw new ArgumentNullException(nameof(globalSettings)); _urlProviders = urlProviders ?? throw new ArgumentNullException(nameof(urlProviders)); _userService = userService ?? throw new ArgumentNullException(nameof(userService)); }
/// <summary> /// Ensures that there is a "current" UmbracoContext. /// </summary> /// <param name="umbracoContextAccessor"></param> /// <param name="httpContext">An http context.</param> /// <param name="publishedSnapshotService">A published snapshot service.</param> /// <param name="webSecurity">A security helper.</param> /// <param name="umbracoSettings">The umbraco settings.</param> /// <param name="urlProviders">Some url providers.</param> /// <param name="globalSettings"></param> /// <param name="replace">A value indicating whether to replace the existing context.</param> /// <returns>The "current" UmbracoContext.</returns> /// <remarks> /// fixme - this needs to be clarified /// /// If <paramref name="replace"/> is true then the "current" UmbracoContext is replaced /// with a new one even if there is one already. See <see cref="WebRuntimeComponent"/>. Has to do with /// creating a context at startup and not being able to access httpContext.Request at that time, so /// the OriginalRequestUrl remains unspecified until <see cref="UmbracoModule"/> replaces the context. /// /// This *has* to be done differently! /// /// See http://issues.umbraco.org/issue/U4-1890, http://issues.umbraco.org/issue/U4-1717 /// /// </remarks> // used by // UmbracoModule BeginRequest (since it's a request it has an UmbracoContext) // in BeginRequest so *late* ie *after* the HttpApplication has started (+ init? check!) // WebRuntimeComponent (and I'm not quite sure why) // -> because an UmbracoContext seems to be required by UrlProvider to get the "current" published snapshot? // note: at startup not sure we have an HttpContext.Current // at startup not sure we have an httpContext.Request => hard to tell "current" url // should we have a post-boot event of some sort for ppl that *need* ?! // can we have issues w/ routing context? // and tests // can .ContentRequest be null? of course! public static UmbracoContext EnsureContext( IUmbracoContextAccessor umbracoContextAccessor, HttpContextBase httpContext, IPublishedSnapshotService publishedSnapshotService, WebSecurity webSecurity, IUmbracoSettingsSection umbracoSettings, IEnumerable <IUrlProvider> urlProviders, IGlobalSettings globalSettings, IVariationContextAccessor variationContextAccessor, bool replace = false) { if (umbracoContextAccessor == null) { throw new ArgumentNullException(nameof(umbracoContextAccessor)); } if (httpContext == null) { throw new ArgumentNullException(nameof(httpContext)); } if (publishedSnapshotService == null) { throw new ArgumentNullException(nameof(publishedSnapshotService)); } if (webSecurity == null) { throw new ArgumentNullException(nameof(webSecurity)); } if (umbracoSettings == null) { throw new ArgumentNullException(nameof(umbracoSettings)); } if (urlProviders == null) { throw new ArgumentNullException(nameof(urlProviders)); } if (globalSettings == null) { throw new ArgumentNullException(nameof(globalSettings)); } // if there is already a current context, return if not replacing var current = umbracoContextAccessor.UmbracoContext; if (current != null && replace == false) { return(current); } // create & assign to accessor, dispose existing if any umbracoContextAccessor.UmbracoContext?.Dispose(); return(umbracoContextAccessor.UmbracoContext = new UmbracoContext(httpContext, publishedSnapshotService, webSecurity, umbracoSettings, urlProviders, globalSettings, variationContextAccessor)); }
public static UmbracoContext GetUmbracoContext(ApplicationContext applicationContext = null, IWebRoutingSection webRoutingSettings = null, HttpContextBase httpContext = null, WebSecurity webSecurity = null, IUmbracoSettingsSection settingsSection = null, IEnumerable <IUrlProvider> urlProviders = null) { httpContext = httpContext ?? new Mock <HttpContextBase>().Object; applicationContext = applicationContext ?? GetApplicationContext(); return(UmbracoContext.EnsureContext( httpContext, applicationContext, webSecurity ?? GetWebSecurity(http: httpContext, application: applicationContext), settingsSection ?? Mock.Of <IUmbracoSettingsSection>(section => section.WebRouting == (webRoutingSettings ?? GetBasicWebRoutingSettings())), urlProviders ?? Enumerable.Empty <IUrlProvider>(), true)); }
public UserPasswordPolicy GetPasswordPolicy() { UsersMembershipProvider userMembershipProvider = Membership.Providers["UsersMembershipProvider"] as UsersMembershipProvider; if (userMembershipProvider == null) { return(null); } IUmbracoSettingsSection umbracoSettings = UmbracoConfig.For.UmbracoSettings(); return(new UserPasswordPolicy(userMembershipProvider, umbracoSettings)); }
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 umbracoSettings:settings/scheduledTasks/@baseUrl // which is assumed to: // - end with SystemDirectories.Umbraco // - NOT contain any scheme (because, legacy) // - end or not with a slash, it will be taken care of // eg "mysite.com/umbraco" url = settings.ScheduledTasks.BaseUrl; if (url.IsNullOrWhiteSpace() == false) { var ssl = globalSettings.UseHttps ? "s" : ""; url = "http" + ssl + "://" + url; var umbracoApplicationUrl = url.TrimEnd('/'); logger.Info(TypeOfApplicationUrlHelper, "ApplicationUrl: {UmbracoAppUrl} (using scheduledTasks/@baseUrl)", 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 ContentTypeMapDefinition(CommonMapper commonMapper, PropertyEditorCollection propertyEditors, IDataTypeService dataTypeService, IFileService fileService, IContentTypeService contentTypeService, IMediaTypeService mediaTypeService, IMemberTypeService memberTypeService, ILogger logger, IUmbracoSettingsSection umbracoSettingsSection) { _commonMapper = commonMapper; _propertyEditors = propertyEditors; _dataTypeService = dataTypeService; _fileService = fileService; _contentTypeService = contentTypeService; _mediaTypeService = mediaTypeService; _memberTypeService = memberTypeService; _logger = logger; _umbracoSettingsSection = umbracoSettingsSection; }
/// <summary> /// Initializes a new instance of the <see cref="UserGroupsApiController"/> class. /// </summary> public UserGroupsApiController(IUmbracoSettingsSection umbracoSettings, IGlobalSettings globalSettings, IUmbracoContextAccessor umbracoContextAccessor, ISqlContext sqlContext, ServiceContext services, AppCaches appCaches, IProfilingLogger logger, IRuntimeState runtimeState, UmbracoHelper umbracoHelper, IUserService userService, IKeyValueService keyValueService) : base(globalSettings, umbracoContextAccessor, sqlContext, services, appCaches, logger, runtimeState, umbracoHelper) { _userService = userService; _keyValueService = keyValueService; }
//ONLY for unit testing internal void SetUmbracoSettings(IUmbracoSettingsSection value) { _umbracoSettings = value; }
internal RepositoryFactory(bool disableAllCache, IUmbracoSettingsSection settings) { _disableAllCache = disableAllCache; _settings = settings; }
// umbracoSettings /// <summary> /// Sets the umbraco settings singleton to the object specified /// </summary> /// <param name="settings"></param> public static void ConfigureSettings(IUmbracoSettingsSection settings) { UmbracoConfig.For.SetUmbracoSettings(settings); }
/// <summary> /// Constructor - can be used for testing /// </summary> /// <param name="umbracoSettings"></param> /// <param name="baseRestSettings"></param> /// <param name="dashboardSettings"></param> public UmbracoConfig(IUmbracoSettingsSection umbracoSettings, IBaseRestSection baseRestSettings, IDashboardSection dashboardSettings) { SetUmbracoSettings(umbracoSettings); SetBaseRestExtensions(baseRestSettings); SetDashboardSettings(dashboardSettings); }
private static void SetUmbracoSettings(IUmbracoSettingsSection umbracoSettingsSection) { var type = typeof (UmbracoConfig); var method = type.GetMethod("SetUmbracoSettings", BindingFlags.Instance | BindingFlags.NonPublic); method.Invoke(UmbracoConfig.For, new object[] {umbracoSettingsSection}); }