public TagConverter(ISettingsProvider settingsProvider)
{
using (var reader = new StreamReader(settingsProvider.Get<string>(SettingsKeys.TagMappingFile)))
{
normalizedTags = reader
.ReadAllLines()
.Where(x => !string.IsNullOrWhiteSpace(x))
.Select(ParseTagDescription)
.ToDictionary(x => x.Name, x => x.RawTags);
rawTagsMapping = normalizedTags
.SelectMany(normalizedTag => normalizedTag.Value.Select(rawTag => new { Normalized = normalizedTag.Key, Raw = rawTag }))
.ToDictionary(x => x.Raw, x => x.Normalized);
}
using (var reader = new StreamReader(settingsProvider.Get<string>(SettingsKeys.CorrectionsFile)))
{
correctionsByProblemUrl = reader
.ReadAllLines()
.Where(x => !string.IsNullOrWhiteSpace(x))
.SelectMany(ParseCorrections)
.GroupBy(x => x.ProblemUrl)
.ToDictionary(x => x.Key, x => x.ToArray());
}
}
public Server(ISettingsProvider settingsProvider)
{
SettingsProvider = settingsProvider;
var port = SettingsProvider.Get<int>("server.port");
MinecraftServer = new MinecraftServer(new IPEndPoint(IPAddress.Any, port));
MinecraftServer.Settings.MotD = SettingsProvider.Get<string>("server.motd");
MinecraftServer.Settings.OnlineMode = SettingsProvider.Get<bool>("server.onlinemode");
MinecraftServer.ChatMessage += MinecraftServerOnChatMessage;
MinecraftServer.PlayerLoggedIn += MinecraftServerOnPlayerLoggedIn;
MinecraftServer.PlayerLoggedOut += MinecraftServerOnPlayerLoggedOut;
MinecraftServer.TabComplete += MinecraftServer_TabComplete;
}
public Server(ISettingsProvider settingsProvider)
{
SettingsProvider = settingsProvider;
var port = SettingsProvider.Get <int>("server.port");
MinecraftServer = new MinecraftServer(new IPEndPoint(IPAddress.Any, port));
MinecraftServer.Settings.MotD = SettingsProvider.Get <string>("server.motd");
MinecraftServer.Settings.OnlineMode = SettingsProvider.Get <bool>("server.onlinemode");
MinecraftServer.ChatMessage += MinecraftServerOnChatMessage;
MinecraftServer.PlayerLoggedIn += MinecraftServerOnPlayerLoggedIn;
MinecraftServer.PlayerLoggedOut += MinecraftServerOnPlayerLoggedOut;
}
public override void Log(CustomLogDefinition log)
{
if (!settingsProvider.Get(LoggerSettings.SupportBulkLogs))
{
throw new NotSupportedException("Bulk logs not supported in this installation. Please contact {C}.".ReplaceBranding());
}
if (!settingsProvider.Get(LoggerSettings.SupportCustomLogs))
{
throw new NotSupportedException("Custom Logs not supported in this installation. Please contact {C} support.".ReplaceBranding());
}
SendLog(log);
}
public BudgetModel CreateNewBudget(string budgetPath)
{
var deviceSettings = _settingsProvider.Get <Device>();
Guid deviceId = deviceSettings.DeviceID;
if (File.Exists(budgetPath))
{
File.Delete(budgetPath);
}
IBudgetStore budgetStore = new SQLiteBudgetStore(deviceId, budgetPath);
var budgetModel = BudgetModel.CreateNew(deviceId, budgetStore);
return(budgetModel);
}
private void Load()
{
_mouseWheelAction = MouseWheelActionOriginal;
var keys = _settingsProvider.Get(SettingsConstants.KeyMap, DefaultSettings.KeyMap);
_keys = new List <KeyCombinationItem>();
foreach (var pair in keys)
{
_keys.Add(new KeyCombinationItem
{
Key = pair.Key,
KeyCombination = pair.Value
});
}
_defaultKeys = new List <KeyCombinationItem>();
foreach (var pair in DefaultSettings.KeyMap)
{
_defaultKeys.Add(new KeyCombinationItem
{
Key = pair.Key,
KeyCombination = pair.Value
});
}
_originalKeys = keys;
}
public async Task <Unit> Handle(Request request, CancellationToken cancellationToken)
{
Settings settings = _settingsProvder.Get(request.Directory);
foreach (var appDirectory in settings.AppDirectories)
{
string apiDirectory = $"{appDirectory}{Path.DirectorySeparatorChar}src{Path.DirectorySeparatorChar}app{Path.DirectorySeparatorChar}@api";
string modelsDirectory = $"{apiDirectory}{Path.DirectorySeparatorChar}models";
string servicesDirectory = $"{apiDirectory}{Path.DirectorySeparatorChar}services";
if (!Directory.Exists(modelsDirectory))
{
_commandService.Start($"mkdir {modelsDirectory}");
}
if (!Directory.Exists(servicesDirectory))
{
_commandService.Start($"mkdir {servicesDirectory}");
}
foreach (var resource in settings.Resources)
{
_commandService.Start($"spa type {resource}", modelsDirectory);
_commandService.Start($"spa service {resource}", servicesDirectory);
}
_commandService.Start($"spa .", modelsDirectory);
_commandService.Start($"spa .", servicesDirectory);
}
return(new());
}
public void Initialize()
{
var deviceSettings = _settingsProvider.Get <Device>();
if (deviceSettings.OpenLastBudgetOnStartup && !string.IsNullOrWhiteSpace(deviceSettings.LastBudget?.BudgetPath))
{
deviceSettings.LastBudget.LastEdited = DateTime.Now;
deviceSettings.Save();
if (!_budgetLoader.IsBudgetValid(deviceSettings.LastBudget.BudgetPath).IsValid)
{
_navigationService.NavigateTo <WelcomeViewModel>();
}
else
{
try
{
MountBudget(_budgetLoader.LoadBudget(deviceSettings.LastBudget.BudgetPath));
_navigationService.NavigateTo <MainBudgetViewModel>();
}
catch (Exception)
{
_dialogService.ShowError($"There was an error opening the budget {deviceSettings.LastBudget.BudgetPath}. It may be corrupt.");
_navigationService.NavigateTo <WelcomeViewModel>();
}
}
}
else
{
_navigationService.NavigateTo <WelcomeViewModel>();
}
}
public StopWordsFilter(ISettingsProvider settingsProvider)
{
var stopwordsFile = settingsProvider.Get<string>(SettingsKeys.StopwordsFile);
using (var reader = new StreamReader(stopwordsFile))
{
stopwords = new HashSet<string>(reader.ReadAllLines());
}
}
/// <summary>
/// Load score / scoreValue from local storage
/// </summary>
/// <param name="key">Achievement / scoreValue identifier</param>
public Achievement <TGameServicesKeys> LoadLocal(TGameServicesKeys key)
{
var result = _settings.Get <Achievement <TGameServicesKeys> >(_gameServicesMetadata.Resolve(key).Id);
result.GameServiceKey = key;
return(result);
}
public Server(ISettingsProvider settingsProvider)
{
SettingsProvider = settingsProvider;
// Touch TerrainGeneration to load it into app domain
FlatlandGenerator.DefaultGeneratorOptions.ToString();
var generator = Level.GetGenerator(SettingsProvider.Get<string>("level.type"));
if (generator == null)
generator = new FlatlandGenerator();
Level level;
if (Directory.Exists(SettingsProvider.Get<string>("level.name")))
level = Level.LoadFrom(SettingsProvider.Get<string>("level.name"));
else
{
level = new Level(generator, SettingsProvider.Get<string>("level.name"));
level.AddWorld("overworld");
level.SaveTo(SettingsProvider.Get<string>("level.name"));
}
MinecraftServer = new MinecraftServer(level);
MinecraftServer.Settings.MotD = SettingsProvider.Get<string>("server.motd");
MinecraftServer.Settings.OnlineMode = SettingsProvider.Get<bool>("server.onlinemode");
MinecraftServer.ChatMessage += MinecraftServerOnChatMessage;
MinecraftServer.PlayerLoggedIn += MinecraftServerOnPlayerLoggedIn;
MinecraftServer.PlayerLoggedOut += MinecraftServerOnPlayerLoggedOut;
//MinecraftServer.TabComplete += MinecraftServer_TabComplete;
}
private IConnection CreateConnection()
{
ConnectionFactory factory = new ConnectionFactory {
AutomaticRecoveryEnabled = true,
TopologyRecoveryEnabled = true,
NetworkRecoveryInterval = TimeSpan.FromSeconds(1),
RequestedConnectionTimeout = 15000,
HostName = settingsProvider.Get(RuntimePlatformSettings.Plugin.CacheInvalidation.RabbitMQAddress),
Port = settingsProvider.Get(RuntimePlatformSettings.Plugin.CacheInvalidation.RabbitMQPort),
UserName = settingsProvider.Get(RuntimePlatformSettings.Plugin.CacheInvalidation.RabbitMQUsername),
Password = settingsProvider.Get(RuntimePlatformSettings.Plugin.CacheInvalidation.RabbitMQPassword),
VirtualHost = settingsProvider.Get(RuntimePlatformSettings.Plugin.CacheInvalidation.RabbitMQVirtualHost),
};
var isTlsEnabled = settingsProvider.Get(RuntimePlatformSettings.Plugin.CacheInvalidation.RabbitMQTlsEnabled);
if (isTlsEnabled)
{
var serverName = settingsProvider.Get(RuntimePlatformSettings.Plugin.CacheInvalidation.RabbitMQTlsServerCanonicalName);
if (string.IsNullOrEmpty(serverName))
{
serverName = factory.HostName;
}
factory.Ssl.Enabled = isTlsEnabled;
factory.Ssl.ServerName = serverName;
factory.Ssl.Version =
System.Security.Authentication.SslProtocols.Tls
| System.Security.Authentication.SslProtocols.Tls11
| System.Security.Authentication.SslProtocols.Tls12;
}
return(factory.CreateConnection());
}
public Server(ISettingsProvider settingsProvider)
{
SettingsProvider = settingsProvider;
// Touch TerrainGeneration to load it into app domain
FlatlandGenerator.DefaultGeneratorOptions.ToString();
var generator = Level.GetGenerator(SettingsProvider.Get <string>("level.type"));
if (generator == null)
{
generator = new FlatlandGenerator();
}
Level level;
if (Directory.Exists(SettingsProvider.Get <string>("level.name")))
{
level = Level.LoadFrom(SettingsProvider.Get <string>("level.name"));
}
else
{
level = new Level(generator, SettingsProvider.Get <string>("level.name"));
level.AddWorld("overworld");
level.SaveTo(SettingsProvider.Get <string>("level.name"));
}
MinecraftServer = new MinecraftServer(level);
MinecraftServer.Settings.MotD = SettingsProvider.Get <string>("server.motd");
MinecraftServer.Settings.OnlineMode = SettingsProvider.Get <bool>("server.onlinemode");
MinecraftServer.ChatMessage += MinecraftServerOnChatMessage;
MinecraftServer.PlayerLoggedIn += MinecraftServerOnPlayerLoggedIn;
MinecraftServer.PlayerLoggedOut += MinecraftServerOnPlayerLoggedOut;
//MinecraftServer.TabComplete += MinecraftServer_TabComplete;
}
public Task <IEnumerable <Institution> > InstitutionSearch(string query, Products?product = null, CancellationToken cancellationToken = default(CancellationToken))
{
if (string.IsNullOrEmpty(query))
{
throw new ArgumentNullException(nameof(query));
}
var config = _settings.Get <PlaidConfig>(_settingsPrefix);
var url = config.Url.AppendPathSegments("institutions", "search").SetQueryParam("q", query);
if (product.HasValue)
{
url = url.SetQueryParam("p", product.Value.ToString());
}
return(url.GetJsonAsync <IEnumerable <Institution> >(cancellationToken));
}
public Server(ISettingsProvider settingsProvider)
{
SettingsProvider = settingsProvider;
var port = SettingsProvider.Get<int>("Server.Port");
MinecraftServer = new MinecraftServer(new IPEndPoint(IPAddress.Any, port));
MinecraftServer.ChatMessage += MinecraftServerOnChatMessage;
MinecraftServer.PlayerLoggedIn += MinecraftServerOnPlayerLoggedIn;
MinecraftServer.PlayerLoggedOut += MinecraftServerOnPlayerLoggedOut;
}
private void _settingsProvider_SettingChanged(object sender, SettingChangeEventArgs e)
{
if (e.SettingName.Equals("ShowLogo", StringComparison.InvariantCultureIgnoreCase))
{
ShowLogo = _settingsProvider.Get("ShowLogo", true);
}
else if (e.SettingName.Equals("AutoPlay", StringComparison.InvariantCultureIgnoreCase))
{
AutoPlay = _settingsProvider.Get("AutoPlay", true);
}
}
public static string GetCacheControlPath(ISettingsProvider settingsProvider)
{
string path = settingsProvider.Get <string>(RuntimePlatformSettings.Cache.CacheControlPath);
if (!path.IsEmpty() && !path.EndsWith(FileSystemUtils.PathSeparator))
{
path = path + FileSystemUtils.PathSeparator;
}
return(path ?? string.Empty);
}
public Settings GetSettings()
{
var settings = _storage.GetValue <Settings>(CurrentSettingsKey);
if (settings == null)
{
settings = _settingsProvider.Get();
_storage.SetValue(CurrentSettingsKey, settings);
}
return(settings);
}
public async Task <Unit> Handle(Request request, CancellationToken cancellationToken)
{
Settings settings = _settingsProvider.Get(request.Directory);
//request.Directory <- App Directory
new BarrelBuilder(_commandService, _fileSystem, request.Directory)
.Add(request.Name)
.Build();
return(new());
}
/// <summary>
/// Create a new instance of the <see cref="DatabaseAccess"/> class using the given <c>IDatabaseServices</c>.
/// </summary>
/// <param name="initialize">True to initialize the providers, false otherwise</param>
/// <param name="settingsProvider">True to initialize the providers, false otherwise</param>
private DatabaseAccess(bool initialize, ISettingsProvider settingsProvider)
{
if (initialize)
{
this.settingsProvider = settingsProvider;
var source = settingsProvider.Get <bool>(RuntimePlatformSettings.Application.IsApplication) ? DatabaseSettingsSerialization.Source.Application : DatabaseSettingsSerialization.Source.Services;
systemProvider = CreatePlatformDatabaseAccessProvider(source, DatabaseSettingsSerialization.User.Runtime, DatabaseSettingsSerialization.DataSpace.Platform, settingsProvider);
#if SPLIT_DEVELOPMENT
runtimeProvider = CreatePlatformDatabaseAccessProvider(source, DatabaseSettingsSerialization.User.Runtime, DatabaseSettingsSerialization.DataSpace.Business, settingsProvider);
#endif
}
}
private void OnEventMessage(EventMessage message)
{
if (message.Content == Event.StateRefreshSuggested)
{
Duration = _engine.Duration;
_updatingCurrentPosition = true;
CurrentPosition = _engine.CurrentPosition;
_updatingCurrentPosition = false;
}
else if (message.Content == Event.MediaControlCreated)
{
_engineReady = true;
if (_settingsProvider.Get("RememberVolume", true))
{
var volume = _settingsProvider.Get("Volume", _volume);
ChangeVolume(volume - _volume);
if (_settingsProvider.Get("IsMute", false))
{
ToggleMute();
}
}
else
{
ChangeVolume(0);
}
}
else if (message.Content == Event.MainWindowClosing)
{
if (_settingsProvider.Get("RememberVolume", true))
{
_settingsProvider.Set("Volume", _volume);
_settingsProvider.Set("IsMute", _isMute);
}
}
}
private void OpenBudget()
{
var budgetPath = _budgetLoader.GetBudgetOpenPath();
if (budgetPath == null)
{
return;
}
ValidBudgetCheck validBudgetCheck = _budgetLoader.IsBudgetValid(budgetPath);
if (!validBudgetCheck.IsValid)
{
_dialogService.ShowError(validBudgetCheck.Error);
return;
}
try
{
BudgetModel budgetModel = _budgetLoader.LoadBudget(budgetPath);
Budget budget = budgetModel.GetBudget();
BudgetStub stub = new BudgetStub()
{
BudgetName = budget.Name, BudgetPath = budgetPath, LastEdited = DateTime.Now
};
var deviceSettings = _settingsProvider.Get <Device>();
deviceSettings.AddRecentBudgetToTop(stub);
deviceSettings.Save();
_mainViewModel.MountBudget(budgetModel);
_navigationService.NavigateTo <MainBudgetViewModel>();
}
catch (Exception)
{
_dialogService.ShowError($"There was an error opening the budget {budgetPath}. It may be corrupt.");
}
}
public Task <Unit> Handle(Request request, CancellationToken cancellationToken)
{
Settings settings = _settingsProvider.Get(request.Directory);
var tokens = new TokensBuilder()
.With(nameof(request.EntityName), (Token)request.EntityName)
.With(nameof(request.Directory), (Token)request.Directory)
.Build();
var result = new List <string>()
{
_templateProcessor.Process("export type {{ entityNamePascalCase }} = {", tokens)
};
var modelsDirectory = $"{settings.DomainDirectory}{Path.DirectorySeparatorChar}Models";
foreach (var path in Directory.GetFiles(modelsDirectory, $"{((Token)request.EntityName).PascalCase}.cs", SearchOption.AllDirectories))
{
foreach (var line in File.ReadAllLines(path))
{
if (line.Contains("public string") || line.Contains("public Guid"))
{
result.Add($" {_namingConventionConverter.Convert(NamingConvention.CamelCase, line.Split(' ')[10])}: string,");
}
if (line.Contains("public int") || line.Contains("public double"))
{
result.Add($" {_namingConventionConverter.Convert(NamingConvention.CamelCase, line.Split(' ')[10])}: number,");
}
if (line.Contains("public bool"))
{
result.Add($" {_namingConventionConverter.Convert(NamingConvention.CamelCase, line.Split(' ')[10])}: boolean,");
}
}
}
result.Add("};");
var filePath = _templateProcessor.Process("{{ directory }}//{{ entityNameSnakeCase }}.ts", tokens);
if (System.IO.File.Exists(filePath) && request.Force == false)
{
return(Task.FromResult(new Unit()));
}
_fileWriter.WriteAllLines(filePath, result.ToArray());
return(Task.FromResult(new Unit()));
}
public ApplicationInfo GenerateApplicationInfo(Transaction trans, ISettingsProvider settingsProvider, string manifestContent, string[] entityModuleNames, string moduleDefinitions, string espaceName, int espaceId, int espaceVersionId, string espaceUID, IEnumerable <GlobalObjectKey> staticEntityKeys)
{
var applicationInfo = new ApplicationInfo(manifestContent, entityModuleNames);
applicationInfo.Data.ApplicationDefaultTimeout = settingsProvider.Get(RuntimePlatformSettings.Application.DefaultTimeout);
applicationInfo.Data.HasTracingEnabled = ShouldEnableTracing();
var moduleDefinitionsJson = DeserializeToModuleDefinitions(moduleDefinitions);
GetStaticEntities(trans, moduleDefinitionsJson, staticEntityKeys);
applicationInfo.Data.ModuleDefinitions = moduleDefinitionsJson;
return(applicationInfo);
}
public Task <ExchangeTokenResponse> ExchangeToken(string publicToken, CancellationToken cancellationToken = default(CancellationToken))
{
if (string.IsNullOrEmpty(publicToken))
{
throw new ArgumentNullException(nameof(publicToken));
}
var config = _settings.Get <PlaidConfig>(_settingsPrefix);
ExchangeTokenRequest request = new ExchangeTokenRequest(config.ClientId, config.ClientSecret, publicToken);
return(config.Url.RequestJsonAsync <ExchangeTokenResponse>(request, cancellationToken));
}
public void Load()
{
if (_isLoaded)
{
return;
}
foreach (var setting in _settingsesProvider.Get())
{
var existingValue = Environment.GetEnvironmentVariable(setting.Key, EnvironmentVariableTarget.Process);
_previousState.Add(new Setting(setting.Key, existingValue));
Environment.SetEnvironmentVariable(setting.Key, setting.Value, EnvironmentVariableTarget.Process);
}
_isLoaded = true;
}
public NLogLoggerImplementation(IServiceProvider serviceProvider, Func <Target, WrapperTargetBase> extraTargetWrapper = null)
{
this.settingsProvider = serviceProvider.GetRequiredService <ISettingsProvider>();
this.extraTargetWrapper = extraTargetWrapper;
var pluginProvider = serviceProvider.GetRequiredService <LoggingPluginProvider>();
this.targetFactories = pluginProvider.Implementations
.Where(impl => impl.AppliesTo(settingsProvider))
.OrderByDescending((plugin) => plugin.Priority)
.Select(impl => impl.GetLoggingTargetFactory(serviceProvider))
.ToArray();
this.maxMessagesSizeInKbForLargeContentQueues = settingsProvider.Get(LoggerSettings.MaxMessagesSizeInKbForLargeContentQueues) * 1000;
}
protected override void OnCreated()
{
Entity account = ExecutionContextAccessor.Target.GetEntity(new ColumnSet());
account["qubit_autonumber"] = "12345";
using (WebClient client = new WebClient())
{
string url = _settingsProvider.Get("abnservice");
account["qubit_abn"] = client.DownloadString($"{url.TrimEnd('/')}/validate");
}
_organizationService.Update(account);
_someService.DoSomethingSpectacular();
}
public static void Fill(IIntegrationDatabaseConfiguration conf, string prefix, ISettingsProvider settingsProvider)
{
var meta = new MetaDatabaseConfiguration(conf);
var @params = meta.AllParameters;
foreach (var setter in @params)
{
if (setter != null && setter.Persist)
{
var setting = new Setting <string>(prefix + setter.Name, null, setter.Encrypt);
string value = settingsProvider.Get(setting);
if (value != null)
{
setter.Set(value);
}
}
}
}
public AppSettingsService(ISettingsProvider settingsProvider)
{
DebugHelper.Assert(settingsProvider != null);
this.settingsProvider = settingsProvider ?? throw new ArgumentNullException(nameof(settingsProvider));
// Initialize settings properties, using default values if necessary.
ApplicationTheme defaultTheme = ApplicationTheme.Dark;
int iTheme = settingsProvider.Get <int>(AppThemeSetting, (int)defaultTheme);
if (!Enum.IsDefined(typeof(ApplicationTheme), iTheme))
{
AppTheme = defaultTheme;
}
else
{
AppTheme = (ApplicationTheme)iTheme;
}
ClearClipboardOnTimer = settingsProvider.Get <uint>(ClearClipboardTimerSetting, 12);
EnableClipboardTimer = settingsProvider.Get(EnableClearClipboardTimerSetting, true);
LockTimer = settingsProvider.Get <uint>(LockTimerSetting, 60 * 5);
EnableLockTimer = settingsProvider.Get(EnableLockTimerSetting, true);
EnableMotd = settingsProvider.Get(EnableMotdSetting, true);
CopyPasswordOnUrlOpen = settingsProvider.Get(CopyPasswordOnUrlLaunchSetting, false);
DatabaseSortMode.Mode defaultMode = Contracts.Enums.DatabaseSortMode.Mode.DatabaseOrder;
int iSortMode = settingsProvider.Get <int>(DatabaseSortModeSetting, (int)defaultMode);
if (!Enum.IsDefined(typeof(DatabaseSortMode.Mode), iSortMode))
{
DatabaseSortMode = defaultMode;
}
else
{
DatabaseSortMode = (DatabaseSortMode.Mode)iSortMode;
}
}
public WelcomeViewModel(
MainViewModel mainViewModel,
INavigationService navigationService,
ISettingsProvider settingsProvider,
IBudgetLoader budgetLoader,
IDialogService dialogService)
{
_mainViewModel = mainViewModel;
_navigationService = navigationService;
_settingsProvider = settingsProvider;
_budgetLoader = budgetLoader;
_dialogService = dialogService;
InitializeRelayCommands();
var deviceSettings = _settingsProvider.Get <Device>();
LastBudget = deviceSettings.LastBudget;
RecentBudgets = new ObservableCollection <BudgetStub>(deviceSettings.RecentBudgets);
}
private void SetupMockWebServices(IKernel services)
{
ISettingsProvider settingsProvider = services.Get <ISettingsProvider>();
string abnUrl = settingsProvider.Get("abnservice");
IFluentMockServerSettings mockServerSettings = new FluentMockServerSettings
{
Urls = new[]
{
abnUrl
}
};
services.Bind <IFluentMockServerSettings>()
.ToConstant(mockServerSettings)
.InTransientScope();
IHttpMock httpMock = services.Get <IHttpMock>();
httpMock.SetupRequest(Request.Create().WithPath("/validate").UsingGet(), Response.Create().WithBody("Test"));
}
private void _settingsProvider_SettingChanged(object sender, SettingChangeEventArgs e)
{
if (e.SettingName.Equals(SettingsConstants.TopMost, StringComparison.InvariantCultureIgnoreCase))
{
TopMost = _settingsProvider.Get(SettingsConstants.TopMost, DefaultSettings.TopMost);
}
else if (e.SettingName.Equals(SettingsConstants.CenterWindow, StringComparison.InvariantCultureIgnoreCase))
{
CenterWindow = _settingsProvider.Get(SettingsConstants.CenterWindow, DefaultSettings.CenterWindow);
}
else if (e.SettingName.Equals(SettingsConstants.KeyMap, StringComparison.InvariantCultureIgnoreCase))
{
ReadKeyCombinations();
}
else if (e.SettingName.Equals(SettingsConstants.MouseWheelAction, StringComparison.InvariantCultureIgnoreCase))
{
_mouseWheelAction = _settingsProvider.Get(SettingsConstants.MouseWheelAction, DefaultSettings.MouseWheekAction);
}
}
public CidaServer(string workingDirectory, ISettingsProvider settingsProvider, ILogger logger)
{
this.settingsProvider = settingsProvider;
this.logger = logger;
this.grpcManager = new GrpcManager(settingsProvider.Get <GrpcConfiguration>(), this.logger);
this.globalConfigurationService = new GlobalConfigurationService(this.logger);
this.ftpClient = new FtpClient(this.globalConfigurationService, this.logger);
this.databaseProvider = new CidaDbConnectionProvider(this.globalConfigurationService);
this.cidaContext = new CidaContext(this.databaseProvider);
this.moduleLoader = new ModuleLoaderManager(
Path.Combine(workingDirectory, ModuleLoaderManager.ModuleFolderName),
this.grpcManager, this.ftpClient, this.cidaContext,
new DatabaseConnector(this.cidaContext, this.databaseProvider, this.globalConfigurationService),
this.logger,
this.globalConfigurationService,
new ModuleFtpClientFactory(ftpClient),
new ModuleLoggerFactory(NLog.LogManager.LogFactory),
this.settingsProvider.Get <ServerConfiguration>().UnpackedModuleDirectories);
this.interNodeConnectionManager = new InterNodeConnectionManager(
this.settingsProvider.Get <InfrastructureConfiguration>(), this.globalConfigurationService);
}
public static IRuntimeDatabaseConfiguration For(
DatabasePluginProvider <IPlatformDatabaseProvider> provider,
DatabaseSettingsSerialization.Source source,
DatabaseSettingsSerialization.User user,
DatabaseSettingsSerialization.DataSpace dataSpace,
ISettingsProvider settingsProvider)
{
var providerKeySetting = new Setting <string>(BuildSettingName(source, user, dataSpace, DatabaseConfigurations.ProviderKeyName), string.Empty);
var providerKeyString = settingsProvider.Get(providerKeySetting);
if (string.IsNullOrEmpty(providerKeyString))
{
return(null);
}
var providerKey = DatabaseProviderKey.Deserialize(providerKeyString);
var conf = provider.GetImplementation(providerKey).CreateEmptyRuntimeDatabaseConfiguration();
RuntimeDatabaseConfigurations.Fill(conf, BuildSettingName(source, user, dataSpace, ""), settingsProvider);
return(conf);
}
public RandomProvider(ISettingsProvider settingsProvider)
{
random = new Random(settingsProvider.Get<int>(SettingsKeys.RandomSeed));
}
