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);
}
