public void AppConfigSettingsMgrValidKayTest()
{
var settingsConfig = new SettingsConfiguration().ReadFrom.SystemAppConfig();
settingsConfig.OnSettingsSaving += (sender, args) =>
{
args.Should().NotBeNull();
args.Data.Should().NotBeNull();
};
settingsConfig.OnSettingsLoading += (sender, args) =>
{
args.Should().NotBeNull();
args.Data.Should().NotBeNull();
};
var settingsMgr = settingsConfig.CreateSettingsMgr <ISettingsValueMgr>();
settingsMgr.Should().NotBeNull();
settingsMgr.Should().BeAssignableTo <ISettingsValueMgr>();
var settingsNew = settingsMgr.ReadSetting("TestKey1", "");
settingsNew.Should().Be("TestValue1");
}
private void RegisterSettings(IServiceCollection services)
{
SettingsConfiguration = Configuration.Get <SettingsConfiguration>();
services.Configure <AzureAdConfiguration>(options => Configuration.Bind("AzureAd", options));
services.Configure <ServicesConfiguration>(options => Configuration.Bind("Services", options));
services.Configure <NotifyConfiguration>(options => Configuration.Bind("NotifyConfiguration", options));
}
public void OverrideTest()
{
var defaultSettings = new CustomSettings();
var settingsConfig = new SettingsConfiguration().WriteTo.Memory(defaultSettings)
.ReadFrom.Memory(defaultSettings)
.ReaderOverrides.WithAction <CustomSettings>(
(s) =>
{
s.String1 = "Override1";
return(s);
})
.WriterOverrides.WithAction <CustomSettings>(
(s) =>
{
return(s);
});
var settingsMgr = settingsConfig.CreateSettingsMgr <ISettingsObjectMgr>();
var settings = settingsMgr.ReadSettings <CustomSettings>();
settings.String1.Should().Be("Override1");
}
public async Task AzureFileTestAsync()
{
var connectionString = ConfigurationManager.AppSettings["settings:sink:AzureFile:ConnectionString"];
var settingsConfig = new SettingsConfiguration().WriteTo.AzureFileStorage(connectionString)
.ReadFrom.AzureFileStorage(connectionString);
settingsConfig.OnSettingsSaving += (sender, args) =>
{
args.Should().NotBeNull();
args.Data.Should().NotBeNull();
};
settingsConfig.OnSettingsLoading += (sender, args) =>
{
args.Should().NotBeNull();
args.Data.Should().NotBeNull();
};
var settingsMgr = settingsConfig.CreateSettingsMgr <ISettingsObjectMgrAsync>();
settingsMgr.Should().NotBeNull();
settingsMgr.Should().BeAssignableTo <ISettingsObjectMgrAsync>();
var settings = new CustomSettings();
await settingsMgr.WriteSettingsAsync(settings);
settings.String1 = "Test1";
var settingsNew = await settingsMgr.ReadSettingsAsync <CustomSettings>();
settings.String1.Should().NotBe(settingsNew.String1);
}
public void AzureDocumentDbTest()
{
var endPointUri = new Uri(ConfigurationManager.AppSettings["settings:sink:AzureDocumentDb:EndPoint"]);
var authKey = ConfigurationManager.AppSettings["settings:sink:AzureDocumentDb:AuthorizationKey"];
var settingsConfig = new SettingsConfiguration().WriteTo.AzureDocumentDb(endPointUri, authKey).ReadFrom.AzureDocumentDb(endPointUri, authKey);
settingsConfig.OnSettingsSaving += (sender, args) =>
{
args.Should().NotBeNull();
args.Data.Should().NotBeNull();
};
settingsConfig.OnSettingsLoading += (sender, args) =>
{
args.Should().NotBeNull();
args.Data.Should().NotBeNull();
};
var settingsMgr = settingsConfig.CreateSettingsMgr <ISettingsObjectMgr>();
settingsMgr.Should().NotBeNull();
settingsMgr.Should().BeAssignableTo <ISettingsObjectMgr>();
var settings = new CustomSettings();
settingsMgr.WriteSettings(settings);
settings.String1 = "Test1";
var settingsNew = settingsMgr.ReadSettings <CustomSettings>();
settings.String1.Should().NotBe(settingsNew.String1);
}
public void ConfigBuilderSettingsMgrValidKayTest()
{
var settingsConfig = new SettingsConfiguration().ReadFrom.ConfigBuilder();
settingsConfig.OnSettingsSaving += (sender, args) =>
{
args.Should().NotBeNull();
args.Data.Should().NotBeNull();
};
settingsConfig.OnSettingsLoading += (sender, args) =>
{
args.Should().NotBeNull();
args.Data.Should().NotBeNull();
};
var settingsMgr = settingsConfig.CreateSettingsMgr <ISettingsObjectMgr>();
settingsMgr.Should().NotBeNull();
settingsMgr.Should().BeAssignableTo <ISettingsObjectMgr>();
var settings = settingsMgr.ReadSettings <CustomSettings>();
settings.Should().NotBeNull();
settings.Should().BeOfType <CustomSettings>();
settings.String1.Should().Be("String1");
}
public SettingsDialogData([CanBeNull] SettingsConfiguration config = null)
{
panel = DialogPanelManager.GetPanelByType <SettingsDialogContents>(DialogPanelType.Settings);
if (config != null)
{
SettingsManager.Config = config;
}
}
private void RegisterSettings(IServiceCollection services)
{
SettingsConfiguration = Configuration.Get <SettingsConfiguration>();
services.Configure <AzureAdConfiguration>(options => Configuration.Bind("AzureAd", options));
services.Configure <ServiceBusSettings>(options => Configuration.Bind("ServiceBusQueue", options));
services.Configure <ServicesConfiguration>(options => Configuration.Bind("Services", options));
services.Configure <KinlyConfiguration>(options => Configuration.Bind("KinlyConfiguration", options));
services.Configure <FeatureFlagConfiguration>(featureFlagConfigurationOptions => Configuration.Bind("FeatureFlags", featureFlagConfigurationOptions));
}
public AutogeneratedSettingsVm Get(
SettingsConfiguration config,
string projPath,
IObservable <IChangeSet <IModListingGetter> > loadOrder,
IObservable <ILinkCache?> linkCache)
{
return(new AutogeneratedSettingsVm(
config, projPath, loadOrder.ObserveOn(RxApp.MainThreadScheduler), linkCache,
_ProvideBundle));
}
public AppSettings ProvideSettings()
{
var config = new SettingsConfiguration(
"AppSettings",
string.Empty,
typeof(SettingsProvider).Assembly.GetBasePath());
var appSettingsDto = _settingsFactory.CreateSettings <AppSettingsDto>(config);
return(new AppSettings(appSettingsDto.Value1, appSettingsDto.Value2));
}
private void RegisterSettings(IServiceCollection services)
{
SettingsConfiguration = Configuration.Get <SettingsConfiguration>();
services.Configure <AzureAdConfiguration>(options => Configuration.Bind("AzureAd", options));
services.Configure <ServicesConfiguration>(options => Configuration.Bind("Services", options));
services.Configure <WowzaConfiguration>(options => Configuration.Bind("WowzaConfiguration", options));
services.Configure <KinlyConfiguration>(options => Configuration.Bind("KinlyConfiguration", options));
services.Configure <CvpConfiguration>(options => Configuration.Bind("CvpConfiguration", options));
services.AddSingleton(Configuration.GetSection("KinlyConfiguration").Get <KinlyConfiguration>());
services.AddSingleton(Configuration.GetSection("WowzaConfiguration").Get <WowzaConfiguration>());
}
public void Initialize(string settingsPath)
{
var settingsConfig = new SettingsConfiguration(
AppSettings.SectionKey,
string.Empty,
settingsPath,
@"Apps\DeeplTranslator\");
var settingsDto = _settingsFactory.CreateSettings <AppSettingsDto>(settingsConfig);
_appSettings = new AppSettings(settingsDto.DeeplApiKey);
}
public DeeplSettingsProvider(ISettingsFactory settingsFactory)
{
var environmentName = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
var config = new SettingsConfiguration(
"AppSettings",
environmentName,
typeof(DeeplSettingsProvider).Assembly.GetBasePath(),
"Apps/DeeplTranslations");
Settings = settingsFactory.CreateSettings <DeeplSettingsDto>(config);
}
public void AppConfigSettingsMgrInValidKeyTest()
{
var settingsConfig = new SettingsConfiguration().ReadFrom.SystemAppConfig();
var settingsMgr = settingsConfig.CreateSettingsMgr <ISettingsValueMgr>();
settingsMgr.Should().NotBeNull();
settingsMgr.Should().BeAssignableTo <ISettingsValueMgr>();
var settingsNew = settingsMgr.ReadSetting("TestKey1_Invalid", "");
settingsNew.Should().BeNullOrEmpty();
}
public void AppConfigSettingsMgrDefaultValueTest()
{
var settingsConfig = new SettingsConfiguration().ReadFrom.SystemAppConfig();
var settingsMgr = settingsConfig.CreateSettingsMgr <ISettingsValueMgr>();
settingsMgr.Should().NotBeNull();
settingsMgr.Should().BeAssignableTo <ISettingsValueMgr>();
var settingsNew = settingsMgr.ReadSetting("TestKey1_DefaultValue", "Default Value");
settingsNew.Should().Be("Default Value");
}
public FileSystemSettings ProvideFileSystemSettings()
{
var config = new SettingsConfiguration(
"FileSystemSettings",
string.Empty,
typeof(SettingsProvider).Assembly.GetBasePath());
var fileSystemSettingsDto = _settingsFactory.CreateSettings <FileSystemSettingsDto>(config);
return(new FileSystemSettings {
DirectoryPath = fileSystemSettingsDto.DirectoryPath
});
}
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers().AddNewtonsoftJson();
services.AddSwagger();
services.AddCors(options => options.AddPolicy("CorsPolicy",
builder =>
{
builder
.AllowAnyHeader()
.AllowAnyMethod()
.SetIsOriginAllowed(host => true)
.AllowCredentials();
}));
services.AddApplicationInsightsTelemetry(Configuration["ApplicationInsights:InstrumentationKey"]);
services.AddApplicationInsightsTelemetryProcessor <SuccessfulDependencyProcessor>();
services.AddJsonOptions();
SettingsConfiguration = Configuration.Get <SettingsConfiguration>();
services.Configure <AzureAdConfiguration>(options => Configuration.Bind("AzureAd", options));
services.Configure <ServicesConfiguration>(options => Configuration.Bind("Services", options));
services.Configure <UserGroupsConfiguration>(options => Configuration.Bind("UserGroups", options));
services.AddCustomTypes();
RegisterAuth(services);
services.AddDbContextPool <TestApiDbContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("TestApi")));
services.AddAuthorization(AddPolicies);
services.AddMvc(AddMvcPolicies);
services.AddMvc(opt => opt.Filters.Add(typeof(LoggingMiddleware))).SetCompatibilityVersion(CompatibilityVersion.Version_3_0);
services.AddMvc(opt => opt.Filters.Add(typeof(RequestModelValidatorFilter))).SetCompatibilityVersion(CompatibilityVersion.Version_3_0)
.AddFluentValidation(fv => fv.RegisterValidatorsFromAssemblyContaining <AllocateUserRequestValidator>());
services.AddTransient <IRequestModelValidatorService, RequestModelValidatorService>();
services.AddTransient <IValidatorFactory, RequestModelValidatorFactory>();
}
public static void LoadTextBoxFolder(TextBox textBoxFolder, SettingsConfiguration settings)
{
string[] args = Environment.GetCommandLineArgs();
ArgumentsHelper cmdline = new ArgumentsHelper(args);
string cd = cmdline["cd"];
if (!string.IsNullOrWhiteSpace(cd))
{
textBoxFolder.Text = cd;
}
else
{
string folderDefault = settings.FolderDefault;
if (!string.IsNullOrWhiteSpace(folderDefault))
{
textBoxFolder.Text = folderDefault;
}
}
}
public void Initialize()
{
var defaultSettings = new CustomSettings();
var settingsConfig = new SettingsConfiguration().WriteTo.Memory(defaultSettings)
.ReadFrom.Memory(defaultSettings)
.ReaderOverrides.WithAction <CustomSettings>(
(s) =>
{
s.String1 = "Override1";
return(s);
})
.WriterOverrides.WithAction <CustomSettings>(
(s) =>
{
return(s);
});
var settingsMgr = settingsConfig.CreateSettingsMgr <ISettingsObjectMgr>();
SettingsManager.SetSettingsManager(settingsMgr);
}
public void JsonNetTest()
{
var f = System.IO.Path.Combine(TestContext.CurrentContext.WorkDirectory, "customSettings.json");
var settingsConfig = new SettingsConfiguration().WriteTo.JsonNet(f).ReadFrom.JsonNet(f);
settingsConfig.OnSettingsSaving += (sender, args) =>
{
args.Should().NotBeNull();
args.Data.Should().NotBeNull();
};
settingsConfig.OnSettingsLoading += (sender, args) =>
{
args.Should().NotBeNull();
args.Data.Should().NotBeNull();
};
var settingsMgr = settingsConfig.CreateSettingsMgr <ISettingsObjectMgr>();
settingsMgr.Should().NotBeNull();
settingsMgr.Should().BeAssignableTo <ISettingsObjectMgr>();
var settings = new CustomSettings();
settingsMgr.WriteSettings(settings);
settings.String1 = "Test1";
var settingsNew = settingsMgr.ReadSettings <CustomSettings>();
settingsNew.Should().NotBeNull();
settingsNew.Should().BeOfType <CustomSettings>();
settings.String1.Should().NotBe(settingsNew.String1);
settings.Should().BeOfType <CustomSettings>();
}
public static IServiceCollection AddSettingsManager(this IServiceCollection services, Action <ISettingsConfiguration> options = null)
{
var config = new SettingsConfiguration();
services.AddSingleton <ISettingsConfiguration>(provider =>
{
options?.Invoke(config);
return(config);
});
services.AddTransient <IGlobalSettingStore, GlobalSettingConfigurationStore>();
services.AddSingleton <IGlobalSettingManager, GlobalSettingManager>();
services.AddSingleton <ICacheSettingManager, CacheSettingManager>();
services.Scan(scan =>
{
scan.FromAssemblies(GetAssemblies(config.AssemblyLoaderParttern))
.AddClasses(c => c.AssignableTo(typeof(GlobalSettingProvider)))
.AddClasses(c => c.AssignableTo(typeof(CacheSettingProvider)))
.AsSelf()
.WithSingletonLifetime();
});
return(services);
}
public static void LoadComboBoxPlaylist(ComboBox comboBoxPlaylist, CheckBox checkBoxPlaylist, SettingsConfiguration settings)
{
comboBoxPlaylist.Items.Add(Constants.WinMediaPlayerPLS);
comboBoxPlaylist.Items.Add(Constants.WinampM3U);
bool playlistChecked = settings.PlaylistChecked;
checkBoxPlaylist.Checked = playlistChecked;
comboBoxPlaylist.Enabled = playlistChecked;
try
{
string playlistDefault = settings.PlaylistDefault;
SelectItem(comboBoxPlaylist, playlistDefault, true);
}
catch (Exception)
{
SelectFirstItem(comboBoxPlaylist);
}
}
public async Task AzureDocumentDbMaxVersionsTest()
{
var endPointUri = new Uri(ConfigurationManager.AppSettings["settings:sink:AzureDocumentDb:EndPoint"]);
var authKey = ConfigurationManager.AppSettings["settings:sink:AzureDocumentDb:AuthorizationKey"];
var databaseName = "AppSettings";
var collectionName = "Config";
int maxVersions = 3;
var settingsConfig = new SettingsConfiguration().WriteTo
.AzureDocumentDb(endPointUri, authKey, maxVersions: maxVersions, databaseName: databaseName,
collectionName: collectionName)
.ReadFrom.AzureDocumentDb(endPointUri, authKey);
settingsConfig.OnSettingsSaving += (sender, args) =>
{
args.Should().NotBeNull();
args.Data.Should().NotBeNull();
};
settingsConfig.OnSettingsLoading += (sender, args) =>
{
args.Should().NotBeNull();
args.Data.Should().NotBeNull();
};
var settingsMgr = settingsConfig.CreateSettingsMgr <ISettingsObjectMgr>();
settingsMgr.Should().NotBeNull();
settingsMgr.Should().BeAssignableTo <ISettingsObjectMgr>();
var settings = new CustomSettings();
for (int i = 0; i <= maxVersions; i++)
{
settings.Int1 = i;
settingsMgr.WriteSettings(settings);
}
var client = new DocumentClient(endPointUri,
authKey);
await client.OpenAsync();
var database = client
.CreateDatabaseQuery()
.Where(x => x.Id == databaseName)
.AsEnumerable()
.FirstOrDefault();
var collection =
client.CreateDocumentCollectionQuery(database.SelfLink)
.Where(x => x.Id == collectionName)
.AsEnumerable()
.FirstOrDefault();
var documents = client.CreateDocumentQuery(collection.SelfLink)
.OrderByDescending(x => x.Timestamp)
.Select(x => x)
.ToList();
documents.Count.Should().BeLessOrEqualTo(maxVersions);
}
public void AzureDocumentDbAppSettingsConstructor()
{
var settingsConfig = new SettingsConfiguration().WriteTo.AzureDocumentDb().ReadFrom.AzureDocumentDb();
}
public AutogeneratedSettingsVM(
SettingsConfiguration config,
string projPath,
string displayName,
IObservable <IChangeSet <LoadOrderEntryVM> > loadOrder,
IObservable <ILinkCache> linkCache,
Action <string> log)
{
var targetSettingsVM = Observable.Return(Unit.Default)
.ObserveOn(RxApp.TaskpoolScheduler)
.Select(_ =>
{
return(Observable.Create <(bool Processing, GetResponse <ReflectionSettingsBundleVM> SettingsVM)>(async(observer, cancel) =>
{
try
{
observer.OnNext((true, GetResponse <ReflectionSettingsBundleVM> .Fail("Loading")));
var reflectionBundle = await ReflectionSettingsBundleVM.ExtractBundle(
projPath,
targets: config.Targets,
detectedLoadOrder: loadOrder,
linkCache: linkCache,
displayName: displayName,
log: log,
cancel: cancel);
if (reflectionBundle.Failed)
{
observer.OnNext((false, reflectionBundle));
return;
}
observer.OnNext((false, reflectionBundle.Value));
}
catch (Exception ex)
{
observer.OnNext((false, GetResponse <ReflectionSettingsBundleVM> .Fail(ex)));
}
observer.OnCompleted();
}));
})
.Switch()
.DisposePrevious()
.Replay(1)
.RefCount();
_SettingsLoading = targetSettingsVM
.Select(t => t.Processing)
.ToGuiProperty(this, nameof(SettingsLoading), deferSubscription: true);
_Bundle = targetSettingsVM
.Select(x =>
{
if (x.Processing || x.SettingsVM.Failed)
{
return(new ReflectionSettingsBundleVM());
}
return(x.SettingsVM.Value);
})
.ObserveOnGui()
.Select(x =>
{
SelectedSettings = x.Settings?.FirstOrDefault();
return(x);
})
.DisposePrevious()
.ToGuiProperty <ReflectionSettingsBundleVM?>(this, nameof(Bundle), initialValue: null, deferSubscription: true);
_Status = targetSettingsVM
.Select(x => (ErrorResponse)x.SettingsVM)
.ToGuiProperty(this, nameof(Error), ErrorResponse.Success, deferSubscription: true);
}
public DevOpsPrController(PullRequestService prService, SettingsConfiguration settings)
{
_prService = prService;
_settingsConfiguration = settings;
}
public UnhandeledExceptionMiddleware(RequestDelegate next, ILogger logger, SettingsConfiguration settings)
{
_next = next;
_logger = logger;
_settings = settings;
}
public async Task <bool> RunAsync()
{
if (_firstStart)
{
Log.Setup(true, false);
Log.Info("Starting Ditto...");
}
// Try to load the settings from the XML file.
// Should this not exist, it will automatically create one.
try
{
Settings = await SettingsConfiguration.ReadAsync("data/settings.xml");
// Write the settings again to update it with any new properties that might have been added.
await Settings.WriteAsync("data/settings.xml").ConfigureAwait(false);
}
catch (Exception ex)
{
Log.Fatal(ex);
return(false);
}
// Try to initialize the database
try
{
(Database = new DatabaseHandler()).Setup(Settings.Credentials.Sql.Type, Settings.Credentials.Sql.ConnectionString);
}
catch (Exception ex)
{
Log.Fatal("Unable to create a connection with the database, please check the file \"/data/settings.xml\"", ex);
return(false);
}
// Try to initialise the service 'Google'
try
{
await(Google = new GoogleService()).SetupAsync(Settings.Credentials.GoogleApiKey).ConfigureAwait(false);
}
catch (Exception ex)
{
Log.Error("Could not initialize Google {0}\n", ex.ToString());
}
// Try to initialise 'Giphy'
try
{
Giphy = new Giphy(Settings.Credentials.GiphyApiKey);
}
catch (ApiException ex)
{
Log.Warn("Could not initialize Giphy {0}\n", ex.ToString());
}
// Try to initialise 'Twitch'
try
{
Twitch = new TwitchLib.Api.TwitchAPI();
Twitch.Settings.ClientId = Settings.Credentials.TwitchApiClientId;
Twitch.Settings.Secret = Settings.Credentials.TwitchApiSecret;
var twitchResult = await Twitch.V5.Auth.CheckCredentialsAsync().ConfigureAwait(false);
if (Twitch.Settings.ClientId == null || !twitchResult.Result)
{
Twitch = null;
throw new ApiException("Twitch credentials check failed.");
}
}
catch (Exception ex)
{
Log.Warn("Could not initialize Twitch {0}\n", ex.ToString());
}
// Create our discord client
Client?.Dispose();
Client = new ObjectLock <DiscordClientEx>(new DiscordClientEx(new DiscordSocketConfig()
{
MessageCacheSize = Settings.Cache.AmountOfCachedMessages,
LogLevel = LogSeverity.Warning,
//TotalShards = 1,
ConnectionTimeout = (int)(Settings.Timeout * 60),
HandlerTimeout = (int)(Settings.Timeout * 60),
DefaultRetryMode = RetryMode.AlwaysRetry,
//AlwaysDownloadUsers = true,
}), 1, 1);
// Various services
if (Cache == null)
{
(Cache = new CacheHandler()).Setup(TimeSpan.FromSeconds(Settings.Cache.CacheTime));
}
CommandHandler?.Dispose();
await(CommandHandler = new CommandHandler(Client)).SetupAsync().ConfigureAwait(false);
await Client.DoAsync((client)
=> client.Connected += async() =>
{
// Setup services
await CommandHandler.SetupAsync().ConfigureAwait(false);
ReactionHandler?.Dispose();
await(ReactionHandler = new ReactionHandler()).SetupAsync(Client).ConfigureAwait(false);
PlayingStatusHandler.Setup(TimeSpan.FromMinutes(1));
}
).ConfigureAwait(false);
if (_firstStart)
{
Connected += async() =>
{
// Start services
await CommandHandler.StartAsync().ConfigureAwait(false);
PlayingStatusHandler.Start();
Connected -= Initialised;
};
// Call this once after a successful connection.
Connected += Initialised;
}
await Client.DoAsync((client)
=> client.Ready += async() =>
{
if (!Running)
{
Running = true;
await Connected().ConfigureAwait(false);
}
Log.Info("Connected");
if (Type == BotType.Bot)
{
await client.SetGameAsync(null);
await client.SetStatusAsync(UserStatusEx.Online);
}
}
).ConfigureAwait(false);
await Client.DoAsync((client)
=> client.Disconnected += (e) =>
{
if (Reconnecting)
{
//_reconnecting = false;
}
else
{
Log.Warn("Bot has been disconnected. {0}", (object)(Exiting ? null : $"| {e}"));
if (!Exiting && Settings.AutoReconnect && !Reconnecting)
{
var _ = Task.Run(() => ReconnectAsync());
}
}
return(Task.CompletedTask);
}
).ConfigureAwait(false);
await Client.DoAsync((client)
=> client.LoggedOut += () =>
{
Log.Warn("Bot has logged out.");
if (!Exiting && Settings.AutoReconnect && !Reconnecting)
{
var _ = Task.Run(() => ReconnectAsync());
}
return(Task.CompletedTask);
}
).ConfigureAwait(false);
var autoReconnect = Settings.AutoReconnect;
Settings.AutoReconnect = false;
try
{
await LoginAsync().ConfigureAwait(false);
Settings.AutoReconnect = autoReconnect;
}
catch (Exception ex)
{
Log.Fatal("Failed to login, please check your internet connection and bot token.", ex);
return(false);
}
await Client.DoAsync((c) => c.StartAsync()).ConfigureAwait(false);
_firstStart = false;
return(true);
}
public Form1()
{
InitializeComponent();
config = new SettingsBuilder().Build();
}
