/// <summary>
/// Writes the configuration of this handler in the given environment to the given XmlWriter.
/// </summary>
/// <param name="xmlWriter">The XmlWriter to writes the configuration to.</param>
public void SaveConfiguration(XmlWriter xmlWriter)
{
if (ConfigurationWriter != null)
{
ConfigurationWriter.SaveConfiguration(xmlWriter, Environment);
}
}
public void WriteConfigurationFile()
{
var configuration = new ConfigurationWriter(this);
configuration.Validate();
configuration.Save();
}
public void EnableMaintenanceMode()
{
var configWriter = new ConfigurationWriter(this);
configWriter.EnableMaintenanceMode();
InMaintenanceMode = true;
}
public void Can_Write_Recursive_Class_To_File()
{
var dict = new Dictionary <string, string>
{
{ "Item", "TEST_VAL_ITEM" },
{ "SubItem_Item", "TEST_VAL_SUBITEM_ITEM" },
{ "SubItem_SubSubItem_Item", "TEST_VAL_SUBITEM_SUBSUBITEM_ITEM" },
{ "SubItem_SubSubItem_Bool", "true" },
{ "SubItem_SubSubItem_Int", "10" },
{ "SubItem_SubSubItem_Long", "10000000" },
{ "SubItem_SubSubItem_Double", "2.2" },
{ "SubItem_SubSubItem_Float", "2.22" }
};
// Set the environment variables we're going to use.
EnvironmentVariableSource.SetEnvironment(dict);
var parsed = ConfigurationParser.ParseConfiguration <TestClass>();
ConfigurationWriter.WriteToFile(parsed, "cwrctf.txt", true);
// Read in that file.
var instance = ConfigurationParser.Parse <TestClass>("cwrctf.txt");
Assert.Equal("TEST_VAL_ITEM", instance.Item);
Assert.Equal("TEST_VAL_SUBITEM_ITEM", instance?.SubItem?.Item);
Assert.Equal("TEST_VAL_SUBITEM_SUBSUBITEM_ITEM", instance?.SubItem?.SubSubItem?.Item);
Assert.True(instance?.SubItem?.SubSubItem?.Bool);
Assert.Equal(10, instance?.SubItem?.SubSubItem?.Int);
Assert.Equal(10000000, instance?.SubItem?.SubSubItem?.Long);
Assert.Equal(2.2D, instance?.SubItem?.SubSubItem?.Double);
Assert.Equal(2.22F, instance?.SubItem?.SubSubItem?.Float);
}
public void CanRoundtrip()
{
var original = new RequestedConfiguration
{
BlockRules =
{
new BlockRule {
BlockName = "Ore", Include = false
},
},
Displays =
{
new RequestedDisplayConfiguration
{
DisplayName = "Components",
IncludeCategories ={ "Components" },
},
new RequestedDisplayConfiguration
{
DisplayName = "Hydrogen",
IncludeCategories ={ "Hydrogen" },
},
},
};
var serialised = new ConfigurationWriter().Serialise(original);
var roundtripped = new ConfigurationReader().Deserialise(serialised);
Assert.Multiple(() =>
{
Assert.That(roundtripped.BlockRules, Is.EquivalentTo(original.BlockRules));
Assert.That(roundtripped.Displays, Is.EquivalentTo(original.Displays).Using(new RequestedDisplayConfigurationEqualityComparer()));
});
}
public void DisableMaintenanceMode()
{
var configWriter = new ConfigurationWriter(this);
configWriter.DisableMaintenanceMode();
InMaintenanceMode = false;
}
public void SetDefaultProject(int projectid)
{
ConfigurationWriter configurationWriter = new ConfigurationWriter();
configurationWriter.AddOrUpdateAppSetting <int>(Constants.DEFAULT_PROJECTID, projectid);
Console.WriteLine("Default Project was successfuly set.", ConsoleColor.Green);
}
public void Can_Default_All_Types()
{
var parsed = ConfigurationParser.ParseConfiguration <AllDefaultTestsClass>();
ConfigurationWriter.WriteToFile(parsed, "cdat.txt", true);
Assert.Equal(4, parsed.IntDefault);
}
/// <summary>
/// Persists the changes to the given configuration file.
/// </summary>
/// <param name="configurationFile">The configuration file to which changes should be persisted.</param>
/// <param name="profileService">The profile service.</param>
private static void PersistChanges(string configurationFile, ProfileService profileService)
{
using (Stream fileStream = File.Open(configurationFile, FileMode.Truncate, FileAccess.Write))
{
var configurationWriter = new ConfigurationWriter(profileService);
configurationWriter.WriteConfiguration(fileStream);
}
}
/// <summary>
/// Saves the configuration to a binary file, using a specific <see cref="BinaryWriter"/>.
/// </summary>
public void SaveToBinaryStream(Stream stream, BinaryWriter writer)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
ConfigurationWriter.WriteToStreamBinary(this, stream, writer);
}
/// <summary>
/// Saves the configuration to a stream.
/// </summary>
public void SaveToStream(Stream stream, Encoding encoding)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
ConfigurationWriter.WriteToStreamTextual(this, stream, encoding);
}
public Settings(SerialPort Port, ConfigurationReader ConfigurationReader, ConfigurationWriter ConfigurationWriter, ModuleConfiguration ModuleConfiguration, LocalServerConfiguration ServerConfiguration)
{
InitializeComponent();
_SerialPort = Port;
_ModuleConfiguration = ModuleConfiguration;
_ConfigurationReader = ConfigurationReader;
_ConfigurationWriter = ConfigurationWriter;
_ServerConfiguration = ServerConfiguration;
}
public List <ConfigurationSetting> ServerSettings(string settingName, object value, ref object message)
{
message = Resources.RestartedSettings;
if (settingName != null)
{
ConfigurationWriter.WriteApplicationSetting(settingName, value);
return(ConfigurationSetting.FindAllSettings());
}
return(ConfigurationSetting.FindAllSettings(true));
}
public IActionResult ChangeKey(ApiKeyItem item)
{
var hashedKey = KeyHash.GetStringSha256Hash(item.ApiKey);
var result = ConfigurationWriter.AddOrUpdateAppSetting("ApiKey", hashedKey);
if (!result.Success)
{
return(NotFound(new StatusMessageResponse <ApiKeyItem>(item, "Failed to write to configuration file")));
}
return(Ok(new StatusMessageResponse <ApiKeyItem>(item, "Successfully changed Api Key. Please restart the Webserver for the changes to take affect.")));
}
public ConfigurationService()
{
var configDir = "";
if (File.Exists(Path.Combine(Directory.GetCurrentDirectory(), "configuration.xml")))
configDir = Path.Combine(Directory.GetCurrentDirectory());
else
configDir = Path.Combine(Directory.GetCurrentDirectory(), "..", "..", "Config");
_configurationReader = new ConfigurationReader(configDir);
_configurationWriter = new ConfigurationWriter(configDir);
}
public void Can_Set_Default_Value()
{
var parsed = ConfigurationParser.ParseConfiguration <DefaultValueClass>();
ConfigurationWriter.WriteToFile(parsed, "csdv.txt", true);
// Read in that file.
var instance = ConfigurationParser.Parse <DefaultValueClass>("csdv.txt");
Assert.True(instance.HasDefault);
Assert.False(instance.DoesNotHaveDefault);
}
public void Can_Convert_Weird_Value_Types()
{
var parsed = ConfigurationParser.ParseConfiguration <DefaultValueWeirdTypesClass>();
ConfigurationWriter.WriteToFile(parsed, "ccwvt.txt", true);
// Read in that file.
var instance = ConfigurationParser.Parse <DefaultValueWeirdTypesClass>("ccwvt.txt");
Assert.True(instance.HasDefault);
Assert.True(instance.DoesNotHaveDefault);
}
public void Can_Read_And_Write_And_Parse_Enums()
{
var config = new EnumClass
{
Enum = TestEnum.Item2,
};
ConfigurationWriter.WriteToFile(config, "crawape.txt", true);
var configParsed = ConfigurationParser.Parse <EnumClass>("crawape.txt");
Assert.Equal(TestEnum.Item2, configParsed.Enum);
}
public void Save(XmlWriter xmlWriter, string sectionName)
{
Assert.IsNotNull(xmlWriter);
Assert.IsNotNull(sectionName);
xmlWriter.WriteStartElement(sectionName);
ConfigurationWriter.Write(xmlWriter, RootNode.Attributes);
foreach (var childNode in RootNode.ChildNodes)
{
ConfigurationWriter.WriteNode(xmlWriter, childNode);
}
xmlWriter.WriteEndElement();
}
public void ConfigWriterTest()
{
//Arrange
var builder = new Mock <IConfigurationBuilder>();
var protocolInfo = new Mock <IProtocolInfo>();
var confReader = new Mock <IConfigurationReader>();
ConfigurationWriter writer = new ConfigurationWriter("hosts.json", builder.Object, protocolInfo.Object, confReader.Object);
//Act
var saveResult = writer.RemoveFromConfig(-1);
var removeResult = writer.SaveInConfig(new [] { "" });
//Assert
Assert.IsFalse(saveResult);
Assert.IsFalse(removeResult);
}
private void Copy_Click(object sender, EventArgs e)
{
var stringWriter = new StringWriter();
var xmlTextWriter = new XmlTextWriter(stringWriter)
{
Formatting = Formatting.Indented
};
foreach (var node in SelectedConfigurationNodes)
{
ConfigurationWriter.WriteNode(xmlTextWriter, node);
}
var s = stringWriter.ToString();
Clipboard.SetText(s);
}
public void RestoreAppConfig(string sourcePath)
{
if (sourcePath == null)
{
return;
}
var configFile = $"{Service.ExePath}.config";
File.Copy(sourcePath, configFile, true);
// Ensure Transport type is correct and populate the config with common settings even if they are defaults
// Will not clobber other settings in the config
var configWriter = new ConfigurationWriter(this);
configWriter.Validate();
configWriter.Save();
}
private void Copy_Click(object sender, EventArgs e)
{
var stringWriter = new StringWriter();
var xmlTextWriter = new XmlTextWriter(stringWriter);
xmlTextWriter.Formatting = Formatting.Indented;
foreach (var node in SelectedConfigurationNodes)
{
var connectionProperties = new ConnectionProperties();
connectionProperties.Load(node);
ConfigurationWriter.WriteNode(xmlTextWriter, node);
}
var s = stringWriter.ToString();
Clipboard.SetText(s);
}
public void Can_Encrypt_And_Decrypt_Text()
{
var item = new EncryptedClass
{
Item1 = "Test string",
Item2 = 65535,
Item3 = true
};
var writer = new ConfigurationWriter();
var encryptHandler = new Func <string, string, string>((name, value) =>
{
return(name switch
{
"Item1" => "xxxxx",
"Item2" => "11111",
"Item3" => "tralse",
_ => throw new ArgumentOutOfRangeException(nameof(name), name, null)
});
});
public MainWindow()
{
InitializeComponent();
_SerialPort = new SerialPort();
_ModuleConfiguration = new ModuleConfiguration();
_CommandProcessor = new CommandProcessingService(_SerialPort);
_ConfigurationReader = new ConfigurationReader(_CommandProcessor, _ModuleConfiguration);
_ConfigurationWriter = new ConfigurationWriter(_CommandProcessor, _ModuleConfiguration);
_ServerConfiguration = new LocalServerConfiguration();
SettingsPage = new Settings(_SerialPort, _ConfigurationReader, _ConfigurationWriter, _ModuleConfiguration, _ServerConfiguration);
BasicSetupPage = new BasicSetup(_CommandProcessor, _ModuleConfiguration);
WiFiSetupPage = new WiFiSetup(_CommandProcessor, _ModuleConfiguration);
TCPIPSetupPage = new TCPUDPSettings(_CommandProcessor, _ModuleConfiguration);
DataLoggerPage = new DataLogging(_ServerConfiguration);
RemoteTerminalPage = new RemoteTerminal(_ServerConfiguration);
SettingsListViewItem.IsSelected = true;
}
public void Can_Write_To_File()
{
var dict = new Dictionary <string, string>
{
{ "Test", "20" },
{ "TestBool", "true" }
};
EnvironmentVariableSource.SetEnvironment(dict);
EnvironmentVariableRepository.SetConfigurationType(ConfigurationTypeEnum.PreferEnvironment);
var output = ConfigurationParser.Parse <NullableClass>(EnvironmentVariableRepository);
ConfigurationWriter.WriteToFile(output, "cwtf.txt", true);
// Read in that file.
var parsedConfig = ConfigurationParser.Parse <NullableClass>("cwtf.txt");
Assert.Equal(20, parsedConfig.Test);
Assert.True(parsedConfig.TestBool);
}
public void CanRoundtrip()
{
var original = new RequestedConfiguration
{
Ingots =
{
[new ItemType("Ingot/Iron")] = new RequestedIngotConfiguration {
Enable = true, StockpileTarget = 500, StockpileLimit = 1000
},
[new ItemType("Ingot/Platinum")] = new RequestedIngotConfiguration {
Enable = false, StockpileLimit = 200
},
[new ItemType("Ore/Test")] = new RequestedIngotConfiguration {
Enable = true, StockpileTarget = 700
},
},
InventoryBlockNames =
{
"Storage",
"Buffer",
},
OreStatusDisplayName = "Status: \"Ore\"",
IngotStatusDisplayName = "IngotStatus",
RefinerySpeedFactor = 5,
AssemblerSpeedFactor = 4,
};
var serialised = new ConfigurationWriter().Serialise(original);
var roundtripped = new ConfigurationReader().Deserialise(serialised);
Assert.Multiple(() =>
{
Assert.That(roundtripped.Ingots, Is.EquivalentTo(original.Ingots).Using(new RequestedIngotConfigurationEqualityComparer()));
Assert.That(roundtripped.InventoryBlockNames, Is.EquivalentTo(original.InventoryBlockNames));
Assert.That(roundtripped.OreStatusDisplayName, Is.EqualTo(original.OreStatusDisplayName));
Assert.That(roundtripped.IngotStatusDisplayName, Is.EqualTo(original.IngotStatusDisplayName));
Assert.That(roundtripped.RefinerySpeedFactor, Is.EqualTo(original.RefinerySpeedFactor));
Assert.That(roundtripped.AssemblerSpeedFactor, Is.EqualTo(original.AssemblerSpeedFactor));
});
}
private List <string> GenerateConfigurationFiles()
{
List <string> files = new List <string>();
var ds = dataGridView.DataSource as List <GseControlSelection>;
var selections = ds.Where(x => x.Selected == true).ToList();
// any selection?
if (selections.Count == 0)
{
MessageBox.Show("Please select at least one GOOSE Control Block.", Program.AppName, MessageBoxButtons.OK, MessageBoxIcon.Information);
return(files);
}
else
{
// selected profile?
foreach (var gse in selections)
{
if (string.IsNullOrWhiteSpace(gse.Direction))
{
MessageBox.Show($"Please select either Publish or Subscribe. [{gse.Name}]", Program.AppName, MessageBoxButtons.OK, MessageBoxIcon.Information);
return(files);
}
if (string.IsNullOrWhiteSpace(gse.Profile))
{
MessageBox.Show($"Please select OpenFMB profile to map. [{gse.Name}]", Program.AppName, MessageBoxButtons.OK, MessageBoxIcon.Information);
return(files);
}
}
// Everything is ok
ConfigurationWriter writer = new ConfigurationWriter();
files.AddRange(writer.WriteGooseConfigurationFiles(selections, "adapter"));
}
return(files);
}
public void SaveSetting(string configFile, string settingName, object value, bool isConnection)
{
ConfigurationWriter.WriteApplicationSetting(configFile, settingName, value, isConnection);
}
private void SetUpMock()
{
configurationWriter = mock.StrictMock<ConfigurationWriter>();
}
private void writeProfileDotConfigFile()
{
new FileSystem().CleanDirectory(_deployedFolderProfilePath);
var writer = new ConfigurationWriter();
writer.Write(Path.Combine(_deployedFolderProfilePath, "Profile.config"), _theProfile);
}
private void SetUpMock()
{
configurationWriter = mock.StrictMock <ConfigurationWriter>();
}
