public ReportsPersister(IAppDataFolder appDataFolder, ShellSettings shellSettings) { _appDataFolder = appDataFolder; _shellSettings = shellSettings; _dataContractSerializer = new DataContractSerializer(typeof(Report), new [] { typeof(ReportEntry) }); _reportsFileName = Path.Combine(Path.Combine("Sites", _shellSettings.Name), "reports.dat"); }
public void Init() { _settingsA = new ShellSettings { Name = "Alpha" }; _settingsB = new ShellSettings { Name = "Beta", }; _routes = new RouteCollection(); var rootBuilder = new ContainerBuilder(); rootBuilder.Register(ctx => _routes); rootBuilder.RegisterType<ShellRoute>().InstancePerDependency(); rootBuilder.RegisterType<RunningShellTable>().As<IRunningShellTable>().SingleInstance(); rootBuilder.RegisterModule(new WorkContextModule()); rootBuilder.RegisterType<WorkContextAccessor>().As<IWorkContextAccessor>().InstancePerMatchingLifetimeScope("shell"); rootBuilder.RegisterType<HttpContextAccessor>().As<IHttpContextAccessor>(); rootBuilder.RegisterType<ExtensionManager>().As<IExtensionManager>(); rootBuilder.RegisterType<StubCacheManager>().As<ICacheManager>(); rootBuilder.RegisterType<StubAsyncTokenProvider>().As<IAsyncTokenProvider>(); rootBuilder.RegisterType<StubParallelCacheContext>().As<IParallelCacheContext>(); _rootContainer = rootBuilder.Build(); _containerA = _rootContainer.BeginLifetimeScope( "shell", builder => { builder.Register(ctx => _settingsA); builder.RegisterType<RoutePublisher>().As<IRoutePublisher>().InstancePerMatchingLifetimeScope("shell"); }); _containerB = _rootContainer.BeginLifetimeScope( "shell", builder => { builder.Register(ctx => _settingsB); builder.RegisterType<RoutePublisher>().As<IRoutePublisher>().InstancePerMatchingLifetimeScope("shell"); }); }
public void FactoryMethodWillCreateShellRoutes() { var settings = new ShellSettings { Name = "Alpha" }; var builder = new ContainerBuilder(); builder.RegisterType<ShellRoute>().InstancePerDependency(); builder.RegisterAutoMocking(); builder.Register(ctx => settings); var container = builder.Build(); var buildShellRoute = container.Resolve<Func<RouteBase, ShellRoute>>(); var routeA = new Route("foo", new MvcRouteHandler()); var route1 = buildShellRoute(routeA); var routeB = new Route("bar", new MvcRouteHandler()) { DataTokens = new RouteValueDictionary { { "area", "Beta" } } }; var route2 = buildShellRoute(routeB); Assert.That(route1, Is.Not.SameAs(route2)); Assert.That(route1.ShellSettingsName, Is.EqualTo("Alpha")); Assert.That(route1.Area, Is.Null); Assert.That(route2.ShellSettingsName, Is.EqualTo("Alpha")); Assert.That(route2.Area, Is.EqualTo("Beta")); }
public ShellDescriptorManager( IRepository<ShellDescriptorRecord> shellDescriptorRepository, IShellDescriptorManagerEventHandler events, ShellSettings shellSettings) { _shellDescriptorRepository = shellDescriptorRepository; _events = events; _shellSettings = shellSettings; T = NullLocalizer.Instance; }
public ShellRoute(RouteBase route, ShellSettings shellSettings, IWorkContextAccessor workContextAccessor, IRunningShellTable runningShellTable) { _route = route; _shellSettings = shellSettings; _runningShellTable = runningShellTable; _workContextAccessor = workContextAccessor; if (!string.IsNullOrEmpty(_shellSettings.RequestUrlPrefix)) _urlPrefix = new UrlPrefix(_shellSettings.RequestUrlPrefix); Area = route.GetAreaName(); }
public SessionConfigurationCache(ShellSettings shellSettings, ShellBlueprint shellBlueprint, IAppDataFolder appDataFolder, IHostEnvironment hostEnvironment, IEnumerable<ISessionConfigurationEvents> configurers) { _shellSettings = shellSettings; _shellBlueprint = shellBlueprint; _appDataFolder = appDataFolder; _hostEnvironment = hostEnvironment; _configurers = configurers; _currentConfig = null; Logger = NullLogger.Instance; }
public FormsAuthenticationService(ShellSettings settings, IClock clock, IContentManager contentManager, IHttpContextAccessor httpContextAccessor) { _settings = settings; _clock = clock; _contentManager = contentManager; _httpContextAccessor = httpContextAccessor; Logger = NullLogger.Instance; ExpirationTimeSpan = TimeSpan.FromDays(30); }
public RecipeScheduler( IProcessingEngine processingEngine, ShellSettings shellSettings, IShellDescriptorManager shellDescriptorManager, Lazy<IRecipeStepExecutor> recipeStepExecutor, IShellDescriptorManagerEventHandler events) { _processingEngine = processingEngine; _shellSettings = shellSettings; _shellDescriptorManager = shellDescriptorManager; _recipeStepExecutor = recipeStepExecutor; _events = events; }
public static string ComposeSettings(ShellSettings settings) { if (settings == null) return ""; var sb = new StringBuilder(); foreach (var key in settings.Keys) { sb.AppendLine(key + ": " + (settings[key] ?? EmptyValue)); } return sb.ToString(); }
public SchemaCommandGenerator( ISessionFactoryHolder sessionFactoryHolder, IExtensionManager extensionManager, ICompositionStrategy compositionStrategy, ShellSettings shellSettings, IDataServicesProviderFactory dataServicesProviderFactory) { _sessionFactoryHolder = sessionFactoryHolder; _extensionManager = extensionManager; _compositionStrategy = compositionStrategy; _shellSettings = shellSettings; _dataServicesProviderFactory = dataServicesProviderFactory; }
public RoutePublisher( RouteCollection routeCollection, ShellSettings shellSettings, IWorkContextAccessor workContextAccessor, IRunningShellTable runningShellTable, IExtensionManager extensionManager) { _routeCollection = routeCollection; _shellSettings = shellSettings; _workContextAccessor = workContextAccessor; _runningShellTable = runningShellTable; _extensionManager = extensionManager; }
void IShellSettingsManager.SaveSettings(ShellSettings settings) { if (settings == null) throw new ArgumentNullException("settings"); if (String.IsNullOrEmpty(settings.Name)) throw new ArgumentException("The Name property of the supplied ShellSettings object is null or empty; the settings cannot be saved.", "settings"); Logger.Debug("Saving ShellSettings for tenant '{0}'...", settings.Name); var filePath = Path.Combine(Path.Combine("Sites", settings.Name), _settingsFileName); _appDataFolder.CreateFile(filePath, ShellSettingsSerializer.ComposeSettings(settings)); Logger.Debug("ShellSettings saved successfully; flagging tenant '{0}' for restart.", settings.Name); _events.Saved(settings); }
public ShellStateCoordinator( ShellSettings settings, IShellStateManager stateManager, IExtensionManager extensionManager, IProcessingEngine processingEngine, IFeatureEventHandler featureEvents) { _settings = settings; _stateManager = stateManager; _extensionManager = extensionManager; _processingEngine = processingEngine; _featureEvents = featureEvents; Logger = NullLogger.Instance; }
public SetupController( INotifier notifier, ISetupService setupService, IViewsBackgroundCompilation viewsBackgroundCompilation, ShellSettings shellSettings) { _viewsBackgroundCompilation = viewsBackgroundCompilation; _shellSettings = shellSettings; _notifier = notifier; _setupService = setupService; T = NullLocalizer.Instance; Logger = NullLogger.Instance; }
public void EncryptionSettingsAreStoredAndReadable() { IShellSettingsManager loader = new ShellSettingsManager(_appDataFolder, new Mock<IShellSettingsManagerEventHandler>().Object); var foo = new ShellSettings { Name = "Foo", DataProvider = "Bar", DataConnectionString = "Quux", EncryptionAlgorithm = "AES", EncryptionKey = "ABCDEFG", HashAlgorithm = "HMACSHA256", HashKey = "HIJKLMN" }; loader.SaveSettings(foo); Assert.That(loader.LoadSettings().Count(), Is.EqualTo(1)); var settings = loader.LoadSettings().First(); Assert.That(settings.EncryptionAlgorithm, Is.EqualTo("AES")); Assert.That(settings.EncryptionKey, Is.EqualTo("ABCDEFG")); Assert.That(settings.HashAlgorithm, Is.EqualTo("HMACSHA256")); Assert.That(settings.HashKey, Is.EqualTo("HIJKLMN")); }
public void CustomSettingsCanBeStoredAndRetrieved() { IShellSettingsManager loader = new ShellSettingsManager(_appDataFolder, new Mock<IShellSettingsManagerEventHandler>().Object); var foo = new ShellSettings { Name = "Default" }; foo["Property1"] = "Foo"; foo["Property2"] = "Bar"; loader.SaveSettings(foo); Assert.That(loader.LoadSettings().Count(), Is.EqualTo(1)); var settings = loader.LoadSettings().First(); Assert.That(settings.Name, Is.EqualTo("Default")); Assert.That(settings["Property1"], Is.EqualTo("Foo")); Assert.That(settings["Property2"], Is.EqualTo("Bar")); }
public void Add(ShellSettings settings) { _lock.EnterWriteLock(); try { _shells = _shells .Where(s => s.Name != settings.Name) .Concat(new[] {settings}) .ToArray(); Organize(); } finally { _lock.ExitWriteLock(); } }
public DefaultLocalizedStringManager( IWebSiteFolder webSiteFolder, IExtensionManager extensionManager, ICacheManager cacheManager, ShellSettings shellSettings, ISignals signals) { _webSiteFolder = webSiteFolder; _extensionManager = extensionManager; _cacheManager = cacheManager; _shellSettings = shellSettings; _signals = signals; Logger = NullLogger.Instance; }
public ShellContext CreateDescribedContext(ShellSettings settings, ShellDescriptor shellDescriptor) { Logger.Debug("Creating described context for tenant {0}", settings.Name); var blueprint = _compositionStrategy.Compose(settings, shellDescriptor); var shellScope = _shellContainerFactory.CreateContainer(settings, blueprint); return new ShellContext { Settings = settings, Descriptor = shellDescriptor, Blueprint = blueprint, LifetimeScope = shellScope, Shell = shellScope.Resolve<ICoeveryShell>(), }; }
public string AddTask(ShellSettings shellSettings, ShellDescriptor shellDescriptor, string eventName, Dictionary<string, object> parameters) { var entry = new Entry { ShellSettings = shellSettings, ShellDescriptor = shellDescriptor, MessageName = eventName, EventData = parameters, TaskId = Guid.NewGuid().ToString("n"), ProcessId = Guid.NewGuid().ToString("n"), }; Logger.Information("Adding event {0} to process {1} for shell {2}", eventName, entry.ProcessId, shellSettings.Name); _entries.GetState().Add(entry); return entry.ProcessId; }
//private readonly IEnumerable<Recipe> _recipes; public SetupService( ShellSettings shellSettings, ICoeveryHost coeveryHost, IShellSettingsManager shellSettingsManager, IShellContainerFactory shellContainerFactory, ICompositionStrategy compositionStrategy, IProcessingEngine processingEngine) { _shellSettings = shellSettings; _coeveryHost = coeveryHost; _shellSettingsManager = shellSettingsManager; _shellContainerFactory = shellContainerFactory; _compositionStrategy = compositionStrategy; _processingEngine = processingEngine; //_recipes = recipeHarvester.HarvestRecipes("Coevery.Setup"); T = NullLocalizer.Instance; }
public NavigationManager( IEnumerable<INavigationProvider> navigationProviders, IEnumerable<IMenuProvider> menuProviders, IAuthorizationService authorizationService, IEnumerable<INavigationFilter> navigationFilters, UrlHelper urlHelper, ICoeveryServices coeveryServices, ShellSettings shellSettings) { _navigationProviders = navigationProviders; _menuProviders = menuProviders; _authorizationService = authorizationService; _navigationFilters = navigationFilters; _urlHelper = urlHelper; _coeveryServices = coeveryServices; _shellSettings = shellSettings; Logger = NullLogger.Instance; }
public ShellSettings(ShellSettings settings) { _values = new Dictionary<string, string>(settings._values, StringComparer.OrdinalIgnoreCase); Name = settings.Name; DataProvider = settings.DataProvider; DataConnectionString = settings.DataConnectionString; DataTablePrefix = settings.DataTablePrefix; RequestUrlHost = settings.RequestUrlHost; RequestUrlPrefix = settings.RequestUrlPrefix; EncryptionAlgorithm = settings.EncryptionAlgorithm; EncryptionKey = settings.EncryptionKey; HashAlgorithm = settings.HashAlgorithm; HashKey = settings.HashKey; State = settings.State; Themes = settings.Themes; Modules = settings.Modules; }
public void Init() { const string encryptionAlgorithm = "AES"; const string hashAlgorithm = "HMACSHA256"; var shellSettings = new ShellSettings { Name = "Foo", DataProvider = "Bar", DataConnectionString = "Quux", EncryptionAlgorithm = encryptionAlgorithm, EncryptionKey = SymmetricAlgorithm.Create(encryptionAlgorithm).Key.ToHexString(), HashAlgorithm = hashAlgorithm, HashKey = HMAC.Create(hashAlgorithm).Key.ToHexString() }; var builder = new ContainerBuilder(); builder.RegisterInstance(shellSettings); builder.RegisterType<DefaultEncryptionService>().As<IEncryptionService>(); _container = builder.Build(); }
public UserService( IMembershipService membershipService, IClock clock, IMessageService messageService, ShellSettings shellSettings, IEncryptionService encryptionService, IShapeFactory shapeFactory, IShapeDisplay shapeDisplay, ISiteService siteService, IRepository<UserRecord> userRecordRepository) { _membershipService = membershipService; _clock = clock; _messageService = messageService; _encryptionService = encryptionService; _shapeFactory = shapeFactory; _shapeDisplay = shapeDisplay; _siteService = siteService; _userRecordRepository = userRecordRepository; Logger = NullLogger.Instance; }
public UserService( IContentManager contentManager, IMembershipService membershipService, IClock clock, IMessageService messageService, ShellSettings shellSettings, IEncryptionService encryptionService, IShapeFactory shapeFactory, IShapeDisplay shapeDisplay, ISiteService siteService ) { _contentManager = contentManager; _membershipService = membershipService; _clock = clock; _messageService = messageService; _encryptionService = encryptionService; _shapeFactory = shapeFactory; _shapeDisplay = shapeDisplay; _siteService = siteService; Logger = NullLogger.Instance; }
public SessionFactoryHolder( ShellSettings shellSettings, ShellBlueprint shellBlueprint, IDataServicesProviderFactory dataServicesProviderFactory, IAppDataFolder appDataFolder, ISessionConfigurationCache sessionConfigurationCache, IHostEnvironment hostEnvironment, IDatabaseCacheConfiguration cacheConfiguration, Func<IEnumerable<ISessionConfigurationEvents>> configurers) { _shellSettings = shellSettings; _shellBlueprint = shellBlueprint; _dataServicesProviderFactory = dataServicesProviderFactory; _appDataFolder = appDataFolder; _sessionConfigurationCache = sessionConfigurationCache; _hostEnvironment = hostEnvironment; _cacheConfiguration = cacheConfiguration; _configurers = configurers; T = NullLocalizer.Instance; Logger = NullLogger.Instance; }
private readonly string _virtualPath; // ~/Media/Default/ #endregion Fields #region Constructors public FileSystemStorageProvider(ShellSettings settings) { var mediaPath = HostingEnvironment.IsHosted ? HostingEnvironment.MapPath("~/Media/") ?? "" : Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Media"); _storagePath = Path.Combine(mediaPath, settings.Name); _virtualPath = "~/Media/" + settings.Name + "/"; var appPath = ""; if (HostingEnvironment.IsHosted) { appPath = HostingEnvironment.ApplicationVirtualPath; } if (!appPath.EndsWith("/")) appPath = appPath + '/'; if (!appPath.StartsWith("/")) appPath = '/' + appPath; _publicPath = appPath + "Media/" + settings.Name + "/"; T = NullLocalizer.Instance; }
public void NormalExecutionReturnsExpectedObjects() { var settings = new ShellSettings { Name = ShellSettings.DefaultName }; var descriptor = new ShellDescriptor { SerialNumber = 6655321 }; var blueprint = new ShellBlueprint(); var shellLifetimeScope = _container.BeginLifetimeScope("shell"); _container.Mock<IShellDescriptorCache>() .Setup(x => x.Fetch(ShellSettings.DefaultName)) .Returns(descriptor); _container.Mock<ICompositionStrategy>() .Setup(x => x.Compose(settings, descriptor)) .Returns(blueprint); _container.Mock<IShellContainerFactory>() .Setup(x => x.CreateContainer(settings, blueprint)) .Returns(shellLifetimeScope); _container.Mock<IShellDescriptorManager>() .Setup(x => x.GetShellDescriptor()) .Returns(descriptor); _container.Mock<IHttpContextAccessor>() .Setup(x => x.Current()) .Returns(default(HttpContextBase)); var factory = _container.Resolve<IShellContextFactory>(); var context = factory.CreateShellContext(settings); Assert.That(context.Settings, Is.SameAs(settings)); Assert.That(context.Descriptor, Is.SameAs(descriptor)); Assert.That(context.Blueprint, Is.SameAs(blueprint)); Assert.That(context.LifetimeScope, Is.SameAs(shellLifetimeScope)); Assert.That(context.Shell, Is.SameAs(shellLifetimeScope.Resolve<ICoeveryShell>())); }
public static ShellSettings ParseSettings(string text) { var shellSettings = new ShellSettings(); if (String.IsNullOrEmpty(text)) { return(shellSettings); } var settings = new StringReader(text); string setting; while ((setting = settings.ReadLine()) != null) { if (string.IsNullOrWhiteSpace(setting)) { continue; } var separatorIndex = setting.IndexOf(Separator); if (separatorIndex == -1) { continue; } string key = setting.Substring(0, separatorIndex).Trim(); string value = setting.Substring(separatorIndex + 1).Trim(); if (!value.Equals(EmptyValue, StringComparison.OrdinalIgnoreCase)) { switch (key) { case "Name": shellSettings.Name = value; break; case "DataProvider": shellSettings.DataProvider = value; break; case "State": TenantState state; shellSettings.State = Enum.TryParse(value, true, out state) ? state : TenantState.Uninitialized; break; case "DataConnectionString": shellSettings.DataConnectionString = value; break; case "DataPrefix": shellSettings.DataTablePrefix = value; break; case "RequestUrlHost": shellSettings.RequestUrlHost = value; break; case "RequestUrlPrefix": shellSettings.RequestUrlPrefix = value; break; case "EncryptionAlgorithm": shellSettings.EncryptionAlgorithm = value; break; case "EncryptionKey": shellSettings.EncryptionKey = value; break; case "HashAlgorithm": shellSettings.HashAlgorithm = value; break; case "HashKey": shellSettings.HashKey = value; break; case "Themes": shellSettings.Themes = value.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries); break; case "Modules": shellSettings.Modules = value.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries); break; default: shellSettings[key] = value; break; } } } return(shellSettings); }
public void SaveSettings(ShellSettings settings) { _shellSettings.Add(settings); }