private void OnFileDownloaded(object sender, DownloadEventArgs e)
{
if (e.FileSaved)
{
Log.Warning("Download", "File have been downloaded with success");
_NbFileDownloaded++;
ProgressBar.ProgressTo(ProgressBar.Progress + 0.3, SIZE_PROGRESS_LONG, Easing.Linear);
if (_NbFileDownloaded == 2)
{
Preferences.Set(Constants.DATE_DOWNLAOD, DateTime.Now.ToString());
Preferences.Set(Constants.SHARED_DATABASE_PATH, Path.Combine(_DownloadDirectoryPath, Constants.DATABASE_FILE_NAME));
DataManager.GetInstance(ConfigInstance.GetInstance().IsDev, Preferences.Get(Constants.SHARED_DATABASE_PATH, ""));
string pathZipFile = Path.Combine(_DownloadDirectoryPath, Constants.IMG_FILE_NAME);
ZipManager.Unzip(pathZipFile, _ImgDirectoryPath);
//delete temporary file after get values
File.Delete(Path.Combine(_DownloadDirectoryPath, Constants.IMG_FILE_NAME));
ProgressBar.ProgressTo(0.99, SIZE_PROGRESS_LONG, Easing.Linear);
_App.ChangePage(new MainPage());
}
}
else
{
Log.Warning("Download", "Error while saving the file");
}
}
public ConfigurationSetFactoryTests()
{
identity = new ConfigurationIdentity("fbce468f-0950-4b5f-a7e1-8e24e746bb91");
registry = new ConfigurationSetRegistry();
registry.AddConfigurationSet(new TestConfiguationModule().BuildConfigurationSetModel());
defaultOptions = new List <ExternalOption>
{
new ExternalOption {
Id = 1, Description = "testOne"
}
};
additionalOption = new List <OptionDependentOnAnotherOption>
{
new OptionDependentOnAnotherOption {
Id = 1, ExternalOption = defaultOptions[0], Value = 23.3
}
};
mockConfigProvider = new Mock <IConfigProvider>();
mockConfigProvider.Setup(test => test.GetCollectionAsync(typeof(ExternalOption), It.IsAny <ConfigurationIdentity>()))
.Returns(() => Task.FromResult <IEnumerable>(defaultOptions));
mockConfigProvider.Setup(test => test.GetCollectionAsync(typeof(OptionDependentOnAnotherOption), It.IsAny <ConfigurationIdentity>()))
.Returns(() => Task.FromResult <IEnumerable>(additionalOption));
defaultConfig = new SampleConfig
{
LlamaCapacity = 23,
ExternalOption = defaultOptions[0]
};
var instance = new ConfigInstance <SampleConfig>(defaultConfig, identity.ClientId);
mockConfigProvider.Setup(test => test.GetAsync(typeof(SampleConfig), identity))
.Returns(() => Task.FromResult <ConfigInstance>(instance));
target = new ConfigurationSetFactory(mockConfigProvider.Object, new TestOptionSetFactory(), registry);
}
public async Task SimulateStartup()
{
DirectoryDefaultManager dirManager = new DirectoryDefaultManager();
_ImgDirectoryPath = dirManager.GetImageDirectory();
_DownloadDirectoryPath = dirManager.GetDownlaodDirectory();
if (!CheckIsDownload() || !File.Exists(Path.Combine(_DownloadDirectoryPath, Constants.DATABASE_FILE_NAME)) || !Directory.Exists(_ImgDirectoryPath))
{
await ProgressBar.ProgressTo(0.1, SIZE_PROGRESS_LONG, Easing.Linear);
//save temporary file
_Downloader.OnFileDownloaded += OnFileDownloaded;
// Use the configuration value
_Downloader.DownloadFile(ConfigInstance.GetInstance().DatabaseUrl, _DownloadDirectoryPath, Constants.DATABASE_FILE_NAME);
_Downloader.DownloadFile(ConfigInstance.GetInstance().ImageUrl, _DownloadDirectoryPath, Constants.IMG_FILE_NAME);
await ProgressBar.ProgressTo(0.2, SIZE_PROGRESS_LONG, Easing.Linear);
}
else
{
Log.Warning("Download", "Database already save");
DataManager.GetInstance(ConfigInstance.GetInstance().IsDev, Preferences.Get(Constants.SHARED_DATABASE_PATH, ""));
await ProgressBar.ProgressTo(0.99, SIZE_PROGRESS_SMALL, Easing.Linear);
_App.ChangePage(new MainPage());
}
}
public async Task CheckOptionsAreUpdated()
{
var config = new SampleConfig
{
Option = new Option {
Id = 1, Description = "Not the right description"
},
MoarOptions = new List <Option>
{
new Option {
Id = 3, Description = "fail"
},
OptionProvider.OptionTwo
}
};
var instance = new ConfigInstance <SampleConfig>(config, identity.ClientId);
mockConfigProvider.Setup(test => test.GetAsync(typeof(SampleConfig), identity))
.Returns(() => Task.FromResult <ConfigInstance>(instance));
var configSet = (TestConfiguationModule)await target.BuildConfigSet(typeof(TestConfiguationModule), identity);
Assert.Equal(config.Option.Description, OptionProvider.OptionOne.Description);
Assert.Equal(config.MoarOptions[0].Description, OptionProvider.OptionThree.Description);
Assert.Equal(config.MoarOptions[1], OptionProvider.OptionTwo);
}
public async Task Set_UpdatesRegistry()
{
var expectedInstance = new ConfigInstance <SimpleConfig>(new SimpleConfig {
IntProperty = 23
}, defaultIdentity);
List <SnapshotEntryInfo> observedValue = new List <SnapshotEntryInfo>();
connector.Setup(c => c.SetSnapshotRegistryFileAsync(It.IsAny <string>()))
.Returns((string value) =>
{
observedValue = JsonConvert.DeserializeObject <List <SnapshotEntryInfo> >(value);
return(Task.FromResult(0));
});
var entry = new ConfigurationSnapshotEntry
{
Info = defaultEntry,
Configurations = new List <ConfigInstance> {
expectedInstance
}
};
await target.SaveSnapshot(entry);
Assert.Equal(new[] { defaultEntry }, observedValue, new SnapShotEqualityComparer());
}
public ConfigEndpointTests()
{
clients = new List <ConfigurationClient>
{
new ConfigurationClient {
ClientId = " AplicationId-1"
}
};
repository = new Mock <IConfigurationClientService>();
repository.Setup(s => s.GetClientOrDefault(It.IsAny <string>()))
.Returns((string value) => Task.FromResult(clients.SingleOrDefault(s => string.Equals(value, s.ClientId, StringComparison.OrdinalIgnoreCase))));
configSetConfig = new ConfigurationModelRegistry();
var configSetDef = new ConfigurationSetModel <SimpleConfigSet>();
configSetDef.GetOrInitialize(c => c.Config);
configSetConfig.AddConfigurationSet(configSetDef);
defaultConfig = new ConfigInstance <SimpleConfig>(new SimpleConfig {
IntProperty = 43
}, new ConfigurationIdentity(clients[0], new Version(1, 0)));
configurationService = new Mock <IConfigurationService>();
configurationService.Setup(r => r.GetAsync(typeof(SimpleConfig), It.Is <ConfigurationIdentity>(arg => arg.Client == clients[0]))).ReturnsAsync(defaultConfig);
responseFactory = new Mock <IHttpResponseFactory>();
responseFactory.Setup(r => r.BuildJsonResponse(It.IsAny <HttpContext>(), defaultConfig.Configuration))
.Returns(Task.FromResult(true));
responseFactory = new Mock <IHttpResponseFactory>();
options = new ConfigServerOptions();
target = new ConfigEndpoint(new ConfigInstanceRouter(repository.Object, configurationService.Object, configSetConfig), repository.Object, responseFactory.Object);
}
public ConfigRouterTests()
{
clients = new List <ConfigurationClient>
{
new ConfigurationClient {
ClientId = " AplicationId-1"
}
};
repository = new Mock <IConfigRepository>();
repository.Setup(s => s.GetClientsAsync())
.ReturnsAsync(clients);
configSetConfig = new ConfigurationSetRegistry();
var configSetDef = new ConfigurationSetModel <SimpleConfigSet>();
configSetDef.GetOrInitialize(c => c.Config);
configSetConfig.AddConfigurationSet(configSetDef);
defaultConfig = new ConfigInstance <SimpleConfig>(new SimpleConfig {
IntProperty = 43
}, clients[0].ClientId);
configurationService = new Mock <IConfigurationService>();
configurationService.Setup(r => r.GetAsync(typeof(SimpleConfig), It.Is <ConfigurationIdentity>(arg => arg.ClientId == clients[0].ClientId))).ReturnsAsync(defaultConfig);
responseFactory = new Mock <IConfigHttpResponseFactory>();
responseFactory.Setup(r => r.BuildResponse(It.IsAny <HttpContext>(), defaultConfig.Configuration))
.Returns(Task.FromResult(true));
responseFactory = new Mock <IConfigHttpResponseFactory>();
target = new ConfigEnpoint(new ConfigInstanceRouter(repository.Object, configurationService.Object, configSetConfig), responseFactory.Object);
}
public async Task Set_SavesConfiguration()
{
var expectedInstance = new ConfigInstance <SimpleConfig>(new SimpleConfig {
IntProperty = 23
}, defaultIdentity);
List <SnapshotTextEntry> observedValue = new List <SnapshotTextEntry>();
connector.Setup(c => c.SetSnapshotEntries(defaultEntry.Id, It.IsAny <IEnumerable <SnapshotTextEntry> >()))
.Returns((string id, IEnumerable <SnapshotTextEntry> e) =>
{
observedValue = e.ToList();
return(Task.FromResult(0));
});
var entry = new ConfigurationSnapshotEntry
{
Info = defaultEntry,
Configurations = new List <ConfigInstance> {
expectedInstance
}
};
await target.SaveSnapshot(entry);
Assert.Single(observedValue);
Assert.Equal(expectedInstance.Name, observedValue[0].ConfigurationName);
var jObject = JObject.Parse(observedValue[0].ConfigurationJson);
Assert.Equal(defaultIdentity.ServerVersion.ToString(), jObject.GetValue(nameof(ConfigStorageObject.ServerVersion)).ToString());
Assert.Equal(defaultIdentity.Client.ClientId, jObject.GetValue(nameof(ConfigStorageObject.ClientId)).ToString());
Assert.Equal(expectedInstance.Name, jObject.GetValue(nameof(ConfigStorageObject.ConfigName)).ToString());
Assert.Equal(23, jObject.GetValue(nameof(ConfigStorageObject.Config)).ToObject <SimpleConfig>().IntProperty);
}
public object MapToEditConfig(ConfigInstance config, ConfigurationSetModel model)
{
var configModel = model.Configs.Single(s => s.Type == config.ConfigType);
var source = config.GetConfiguration();
return(BuildObject(source, configModel.ConfigurationProperties));
}
public async Task <CommandResult> Handle(UpdateConfigurationSetFromJsonUploadCommand command)
{
var configSetModel = registry.GetConfigSetDefinition(command.ConfigurationSetType);
var mappedConfigs = configurationSetUploadMapper.MapConfigurationSetUpload(command.JsonUpload, configSetModel).ToArray();
var propertyModelLookup = configSetModel.Configs.ToDictionary(k => k.Name, StringComparer.OrdinalIgnoreCase);
var validationResult = await ValidateConfigs(mappedConfigs, propertyModelLookup, command.Identity);
if (validationResult.IsValid)
{
foreach (var config in mappedConfigs)
{
var model = propertyModelLookup[config.Key];
if (model.IsReadOnly)
{
continue;
}
ConfigInstance instance = BuildConfigInstance(command, model, config.Value);
await configRepository.UpdateConfigAsync(instance);
await eventService.Publish(new ConfigurationUpdatedEvent(instance));
}
return(CommandResult.Success());
}
else
{
return(CommandResult.Failure(string.Join(Environment.NewLine, validationResult.Errors)));
}
}
private void OnFileDownloaded(object sender, DownloadEventArgs e)
{
if (e.FileSaved)
{
Log.Debug("Download", "File have been downloaded with success");
_NbFileDownloaded++;
if (_NbFileDownloaded == 2)
{
SharedPreferenceManager.SaveString(ApplicationContext, Constants.DATE_DOWNLAOD, DateTime.Now.ToString());
SharedPreferenceManager.SaveString(ApplicationContext, Constants.SHARED_DATABASE_PATH, System.IO.Path.Combine(_DownloadDirectoryPath, Constants.DATABASE_FILE_NAME));
if (Controller.Permission.CheckPermission.PermissionGranted(ApplicationContext, Manifest.Permission.ReadExternalStorage))
{
DataManager.GetInstance(ConfigInstance.GetInstance().IsDev, SharedPreferenceManager.GetString(ApplicationContext, Constants.SHARED_DATABASE_PATH, ""));
string pathZipFile = System.IO.Path.Combine(_DownloadDirectoryPath, Constants.IMG_FILE_NAME);
ZipManager.Unzip(pathZipFile, _ImgDirectoryPath);
}
else
{
Toast.MakeText(ApplicationContext, "Permission non accordée pour la lecture du fichier, aller dans les paramètres de l'application pour modifier cette valeur.", ToastLength.Long).Show();
}
//delete temporary file after get values
File.Delete(System.IO.Path.Combine(_DownloadDirectoryPath, Constants.IMG_FILE_NAME));
HideProgressBar();
StartActivity(typeof(HomeActivity));
Finish();
}
}
else
{
Log.Error("Download", "Error while saving the file");
}
}
public App()
{
InitializeComponent();
if (Preferences.Get(Constants.SHARED_SCREENLAUNCH, -1) != -1)
{
try
{
string databaseFile = Preferences.Get(Constants.SHARED_DATABASE_PATH, "");
if (string.IsNullOrEmpty(databaseFile))
{
throw new NullReferenceException("database path not save in preferences");
}
DataManager.GetInstance(ConfigInstance.GetInstance().IsDev, databaseFile);
ChangePage(new MainPage((MenuItemType)Preferences.Get(Constants.SHARED_SCREENLAUNCH, -1)));
}
catch
{
MainPage = new Splash(this);
}
}
else
{
MainPage = new Splash(this);
}
Preferences.Set(Constants.SHARED_SCREENLAUNCH, -1);
}
private async Task HandleUploadRequest(HttpContext context, ConfigInstance configInstance)
{
object input;
if (configInstance is ConfigCollectionInstance collectionInstance)
{
input = await context.GetObjectFromJsonBodyOrDefaultAsync(ReflectionHelpers.BuildGenericType(typeof(IEnumerable <>), configInstance.ConfigType));
}
else
{
input = await context.GetObjectFromJsonBodyOrDefaultAsync(configInstance.ConfigType);
}
var validationResult = await confgiurationValidator.Validate(input, GetConfigurationSetForModel(configInstance).Configs.Single(s => s.Type == configInstance.ConfigType), new ConfigurationIdentity(configInstance.ClientId));
if (validationResult.IsValid)
{
configInstance.SetConfiguration(input);
await configRepository.UpdateConfigAsync(configInstance);
await eventService.Publish(new ConfigurationUpdatedEvent(configInstance));
responseFactory.BuildNoContentResponse(context);
}
else
{
responseFactory.BuildStatusResponse(context, 422);
}
}
// Simulates background work that happens behind the splash screen
private void SimulateStartup()
{
if (!CheckIsDownload() || !File.Exists(System.IO.Path.Combine(_DownloadDirectoryPath, Constants.DATABASE_FILE_NAME)))
{
if (Controller.Permission.CheckPermission.PermissionGranted(ApplicationContext, Manifest.Permission.WriteExternalStorage))
{
//save temporary file
_Downloader.OnFileDownloaded += OnFileDownloaded;
// Use the configuration value
_Downloader.DownloadFile(ConfigInstance.GetInstance().DatabaseUrl, _DownloadDirectoryPath, Constants.DATABASE_FILE_NAME);
_Downloader.DownloadFile(ConfigInstance.GetInstance().ImageUrl, _DownloadDirectoryPath, Constants.IMG_FILE_NAME);
}
else
{
Android.Support.V4.App.ActivityCompat.RequestPermissions(this, new String[] { Manifest.Permission.WriteExternalStorage }, 5);
OnResume();
}
}
else
{
Log.Debug("Download", "Database already save");
DataManager.GetInstance(ConfigInstance.GetInstance().IsDev, SharedPreferenceManager.GetString(ApplicationContext, Constants.SHARED_DATABASE_PATH, ""));
HideProgressBar();
StartActivity(typeof(HomeActivity));
Finish();
}
}
private async Task HandleValuePostRequest(HttpContext context, ConfigInstance configInstance)
{
var model = GetConfigurationSetForModel(configInstance);
ConfigInstance newConfigInstance;
try
{
newConfigInstance = await GetConfigInstance(context, configInstance, model);
}
catch (ConfigModelParsingException ex)
{
await responseFactory.BuildInvalidRequestResponse(context, new [] { ex.Message });
return;
}
var validationResult = await validator.Validate(newConfigInstance.GetConfiguration(), model.Get(configInstance.ConfigType), new ConfigurationIdentity(configInstance.ClientId));
if (validationResult.IsValid)
{
await configRepository.UpdateConfigAsync(newConfigInstance);
await eventService.Publish(new ConfigurationUpdatedEvent(newConfigInstance));
responseFactory.BuildNoContentResponse(context);
}
else
{
await responseFactory.BuildInvalidRequestResponse(context, validationResult.Errors);
}
}
public async Task Handle_CallsSaveWithCorrectConfiguration()
{
var snapshotName = "NameOne";
ConfigurationSnapshotEntry observedEntry = null;
var config = new ConfigInstance <SimpleConfig>(new SimpleConfig {
IntProperty = 23
}, new ConfigurationIdentity(client, version));
configurationService.Setup(s => s.GetAsync(typeof(SimpleConfig), It.Is <ConfigurationIdentity>(i => i.Client.Equals(client) && i.ServerVersion.Equals(version))))
.ReturnsAsync(config);
snapshotRepository.Setup(s => s.SaveSnapshot(It.IsAny <ConfigurationSnapshotEntry>()))
.Returns((ConfigurationSnapshotEntry entry) =>
{
observedEntry = entry;
return(Task.FromResult(true));
});
var result = await target.Handle(new CreateSnapshotCommand { ClientId = clientId, Name = snapshotName });
Assert.True(result.IsSuccessful);
Assert.NotNull(observedEntry);
Assert.Equal(1, observedEntry.Configurations.Count);
var observedConfig = observedEntry.Configurations.Single().GetConfiguration() as SimpleConfig;
Assert.NotNull(observedConfig);
Assert.Equal(23, observedConfig.IntProperty);
}
private bool DoesMatch(ConfigInstance c, SampleConfig testConfig)
{
if (c is ConfigInstance <SampleConfig> castConfig)
{
return(testConfig.LlamaCapacity == castConfig.Configuration.LlamaCapacity);
}
return(false);
}
private SnapshotTextEntry Map(ConfigInstance config)
{
var configObject = ConfigStorageObjectHelper.BuildStorageObject(config);
return(new SnapshotTextEntry {
ConfigurationJson = JsonConvert.SerializeObject(configObject), ConfigurationName = config.Name
});
}
public ConfigInstance UpdateConfigurationInstance(ConfigInstance original, JObject newEditPayload, ConfigurationSetModel model)
{
var configModel = model.Configs.Single(s => s.Type == original.ConfigType);
var newConfig = UpdateObject(original.ConstructNewConfiguration(), newEditPayload, configModel.ConfigurationProperties);
original.SetConfiguration(newConfig);
return(original);
}
/// <summary>
/// Saves changes to configuration
/// </summary>
/// <param name="config">Updated configuration to be saved</param>
/// <returns>A task that represents the asynchronous save operation.</returns>
public Task UpdateConfigAsync(ConfigInstance config)
{
var tcs = new TaskCompletionSource <bool>();
SaveChanges(config);
tcs.SetResult(true);
return(tcs.Task);
}
internal void ShutdownTask()
{
ConfigInstance.Save();
QuotesInstance.Dispose();
IntervalMessagesInstance.Dispose();
ChatFiltering.Dispose();
Cvars.Dispose();
SuiBotInstance.LeaveChannel(Channel);
}
private void SaveChanges(ConfigInstance config)
{
if (!innerStore.ContainsKey(config.ClientId))
{
innerStore.Add(config.ClientId, new Dictionary <Type, ConfigInstance>());
}
innerStore[config.ClientId][config.ConfigType] = config;
}
private async Task HandleValuePostRequest(HttpContext context, ConfigInstance configInstance)
{
var input = await context.GetJObjectFromJsonBodyAsync();
var newConfigInstance = configurationEditPayloadMapper.UpdateConfigurationInstance(configInstance, input, GetConfigurationSetForModel(configInstance));
await configRepository.UpdateConfigAsync(newConfigInstance);
responseFactory.BuildNoContentResponse(context);
}
/// <summary>
/// Saves changes to configuration
/// </summary>
/// <param name="config">Updated configuration to be saved</param>
/// <returns>A task that represents the asynchronous save operation.</returns>
public async Task UpdateConfigAsync(ConfigInstance config)
{
var configId = config.ConfigType.Name;
var configPath = GetCacheKey(configId, config.ClientId);
var configText = JsonConvert.SerializeObject(config.GetConfiguration(), jsonSerializerSettings);
await storageConnector.SetConfigFileAsync(configId, config.ClientId, configText);
memoryCache.Set <string>(cachePrefix + configPath, configText, new MemoryCacheEntryOptions().SetSlidingExpiration(TimeSpan.FromMinutes(5)));
}
public async Task Calls_Validator()
{
var config = new ConfigInstance <SampleConfig>(new SampleConfig(), command.Identity);
configurationUpdatePayloadMapper.Setup(m => m.UpdateConfigurationInstance(It.IsAny <ConfigInstance>(), command.ConfigurationAsJson, It.IsAny <ConfigurationSetModel>()))
.ReturnsAsync(() => config);
var result = await target.Handle(command);
validator.Verify(v => v.Validate(config.GetConfiguration(), model.Get <SampleConfig>(), command.Identity));
}
public async Task <ConfigInstance> UpdateConfigurationInstance(ConfigInstance original, JContainer newEditPayload, ConfigurationSetModel model)
{
var configModel = model.Configs.Single(s => s.Type == original.ConfigType);
var identity = new ConfigurationIdentity(original.ClientId);
var configurationSets = await GetRequiredConfiguration(model, identity);
var newConfig = UpdateObject(original, newEditPayload, configModel, identity, configurationSets);
original.SetConfiguration(newConfig);
return(original);
}
private ConfigStorageObject BuildStorageObject(ConfigInstance config)
{
return(new ConfigStorageObject
{
ServerVersion = config.ConfigurationIdentity.ServerVersion.ToString(),
ClientId = config.ConfigurationIdentity.Client.ClientId,
ConfigName = config.Name,
TimeStamp = DateTime.UtcNow,
Config = config.GetConfiguration()
});
}
private object UpdateObject(ConfigInstance original, JContainer newEditPayload, ConfigurationModel model, ConfigurationIdentity configIdentity, IEnumerable <ConfigurationSet> requiredConfigurationSets)
{
if (original is ConfigCollectionInstance collection)
{
return(UpdateObject(collection, (JArray)newEditPayload, (ConfigurationOptionModel)model, configIdentity, requiredConfigurationSets));
}
else
{
return(UpdateObject(original.ConstructNewConfiguration(), (JObject)newEditPayload, model.ConfigurationProperties, configIdentity, requiredConfigurationSets));
}
}
private Task HandleValueRequest(HttpContext context, ConfigInstance configInstance)
{
if (context.Request.Method == "GET")
{
return(responseFactory.BuildResponse(context, configurationEditModelMapper.MapToEditConfig(configInstance, GetConfigurationSetForModel(configInstance))));
}
if (context.Request.Method == "POST")
{
return(HandleValuePostRequest(context, configInstance));
}
throw new System.Exception("Only Get or Post methods expected");
}
private IEnumerable <ConfigInstance> BuildConfigInstances(IEnumerable <SnapshotTextEntry> entries, Dictionary <string, ConfigurationRegistration> configurationInRegistry, ConfigurationIdentity targetConfigurationIdentity)
{
foreach (var entry in entries)
{
if (!configurationInRegistry.TryGetValue(entry.ConfigurationName, out var configInfo))
{
continue;
}
ConfigInstance newInstance = BuildInstance(targetConfigurationIdentity, entry, configInfo);
yield return(newInstance);
}
}
