public FormManageConfiguration(FormMain parent) : base(parent)
{
this.parentFormMain = parent;
InitializeComponent();
//Make sure the root directories exist, based on hard-coded (tool) parameters
//Also create the initial file with the configuration if it doesn't exist already
EnvironmentConfiguration.InitialiseRootPath();
// Set the core TEAM (path) file using the information retrieved from memory. These values were loaded into memory from the path file in the main form.
//Dev or prod environment (working environment)
RadioButton radioButtonWorkingEnvironment;
if (GlobalParameters.WorkingEnvironment == "Development")
{
radioButtonWorkingEnvironment = radioButtonDevelopment;
radioButtonWorkingEnvironment.Checked = true;
}
else if (GlobalParameters.WorkingEnvironment == "Production")
{
radioButtonWorkingEnvironment = radioButtonProduction;
radioButtonWorkingEnvironment.Checked = true;
}
//Paths
textBoxOutputPath.Text = GlobalParameters.OutputPath;
textBoxConfigurationPath.Text = GlobalParameters.ConfigurationPath;
// Load the configuration file using the paths retrieved from the application root contents (configuration path)
try
{
LocalInitialiseConnections(GlobalParameters.ConfigurationPath + GlobalParameters.ConfigFileName + '_' + GlobalParameters.WorkingEnvironment + GlobalParameters.FileExtension);
}
catch (Exception ex)
{
richTextBoxInformation.AppendText("Errors occured trying to load the configuration file, the message is " + ex + ". No default values were loaded. \r\n\r\n");
}
_formLoading = false;
}
public FormMain()
{
InitializeComponent();
// Instantiate the logging
EventLog eventLog = new EventLog();
// Set the version of the build for everything
const string versionNumberForTeamApplication = "v1.6.0";
Text = "TEAM - Taxonomy for ETL Automation Metadata " + versionNumberForTeamApplication;
//richTextBoxInformation.AppendText("Starting from "+GlobalParameters.RootPath+"\r\n\r\n");
//richTextBoxInformation.AppendText("Script path is " + GlobalParameters.ScriptPath + "\r\n\r\n");
richTextBoxInformation.AppendText("Initialising the application.\r\n\r\n");
// Make sure the application and custom location directories exist
try
{
EnvironmentConfiguration.InitialiseRootPath();
eventLog.Add(Event.CreateNewEvent(EventTypes.Information, "... The TEAM directories are available and initialised.\r\n"));
}
catch
{
eventLog.Add(Event.CreateNewEvent(EventTypes.Error, "The directories required to operate TEAM are not available and can not be created. Do you have administrative priviliges in the installation directory to create these additional directories?"));
}
// Set the root path, to be able to locate the customisable configuration file
try
{
EnvironmentConfiguration.LoadRootPathFile();
eventLog.Add(Event.CreateNewEvent(EventTypes.Information, "... The core configuration file has been loaded.\r\n"));
}
catch
{
eventLog.Add(Event.CreateNewEvent(EventTypes.Error, "The core configuration file could not be loaded. Is there a Configuration directory in the TEAM installation location?"));
}
// Make sure the configuration file is in memory
try
{
EnvironmentConfiguration.InitialiseConfigurationPath();
eventLog.Add(Event.CreateNewEvent(EventTypes.Information, "... The user configuration paths are available.\r\n"));
}
catch
{
eventLog.Add(Event.CreateNewEvent(EventTypes.Error, "An issue was encountered creating or detecting the configuration paths."));
}
// Load the available configuration file
try
{
EnvironmentConfiguration.LoadConfigurationFile(GlobalParameters.ConfigurationPath + GlobalParameters.ConfigFileName + '_' + GlobalParameters.WorkingEnvironment + GlobalParameters.FileExtension);
eventLog.Add(Event.CreateNewEvent(EventTypes.Information, "... The user configuration settings (file) have been loaded.\r\n"));
}
catch
{
eventLog.Add(Event.CreateNewEvent(EventTypes.Error, "An issue was encountered loading the user configuration file."));
}
// Load the pattern definition file
try
{
ConfigurationSettings.patternDefinitionList = LoadPatternDefinition.DeserializeLoadPatternDefinition(GlobalParameters.LoadPatternPath + GlobalParameters.LoadPatternDefinitionFile);
eventLog.Add(Event.CreateNewEvent(EventTypes.Information, "... The pattern definition file was loaded successfully.\r\n"));
}
catch
{
eventLog.Add(Event.CreateNewEvent(EventTypes.Error, "An issue was encountered loading the pattern definition file."));
}
// Report the events (including errors) back to the user
int errorCounter = 0;
foreach (Event individualEvent in eventLog)
{
if (individualEvent.eventCode == (int)EventTypes.Error)
{
errorCounter++;
}
richTextBoxInformation.AppendText(individualEvent.eventDescription);
}
richTextBoxInformation.AppendText($"\r\n{errorCounter} error(s) have been found at startup.\r\n\r\n");
TestConnections();
//Startup information
richTextBoxInformation.AppendText("\r\nApplication initialised - the Taxonomy of ETL Automation Metadata (TEAM). \r\n");
richTextBoxInformation.AppendText("Welcome to version " + versionNumberForTeamApplication + ".\r\n\r\n");
labelWorkingEnvironment.Text = "The working environment is: " + GlobalParameters.WorkingEnvironment;
}
/// <summary>
/// Check if the paths exists and create them if necessary
/// </summary>
internal static void InitialiseConfigurationPath()
{
// Create the configuration directory if it does not exist yet
try
{
if (!Directory.Exists(FormBase.GlobalParameters.ConfigurationPath))
{
Directory.CreateDirectory(FormBase.GlobalParameters.ConfigurationPath);
}
}
catch (Exception ex)
{
MessageBox.Show(
"Error creation default directory at " + FormBase.GlobalParameters.ConfigurationPath +
" the message is " + ex, "An issue has been encountered", MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
// Create the output directory if it does not exist yet
try
{
if (!Directory.Exists(FormBase.GlobalParameters.OutputPath))
{
Directory.CreateDirectory(FormBase.GlobalParameters.OutputPath);
}
}
catch (Exception ex)
{
MessageBox.Show(
"Error creation default directory at " + FormBase.GlobalParameters.OutputPath +
" the message is " + ex, "An issue has been encountered", MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
// Create a new dummy configuration file
try
{
// Create a default configuration file if the file does not exist as expected
if (File.Exists(FormBase.GlobalParameters.ConfigurationPath +
FormBase.GlobalParameters.ConfigFileName + '_' +
FormBase.GlobalParameters.WorkingEnvironment +
FormBase.GlobalParameters.FileExtension))
{
return;
}
var newEnvironmentConfiguration = new EnvironmentConfiguration();
newEnvironmentConfiguration.CreateDummyEnvironmentConfiguration(
FormBase.GlobalParameters.ConfigurationPath + FormBase.GlobalParameters.ConfigFileName + '_' +
FormBase.GlobalParameters.WorkingEnvironment + FormBase.GlobalParameters.FileExtension);
}
catch (Exception ex)
{
MessageBox.Show(
"An error occurred while creation the default Configuration File. The error message is " + ex,
"An issue has been encountered", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
// Create a new dummy validation file
try
{
// Create a default configuration file if the file does not exist as expected
if (File.Exists(FormBase.GlobalParameters.ConfigurationPath +
FormBase.GlobalParameters.ValidationFileName + '_' +
FormBase.GlobalParameters.WorkingEnvironment +
FormBase.GlobalParameters.FileExtension))
{
return;
}
var newEnvironmentConfiguration = new EnvironmentConfiguration();
newEnvironmentConfiguration.CreateDummyEnvironmentConfiguration(
FormBase.GlobalParameters.ConfigurationPath + FormBase.GlobalParameters.ValidationFileName +
'_' + FormBase.GlobalParameters.WorkingEnvironment + FormBase.GlobalParameters.FileExtension);
}
catch (Exception ex)
{
MessageBox.Show(
"An error occurred while creation the default Configuration File. The error message is " + ex,
"An issue has been encountered", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
/// <summary>
/// Save validation settings
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void toolStripMenuItem2_Click(object sender, EventArgs e)
{
try
{
// Source object existence check
var stringSourceObjectExistence = "";
if (checkBoxSourceObjectExistence.Checked)
{
stringSourceObjectExistence = "True";
}
else
{
stringSourceObjectExistence = "False";
}
ValidationSettings.SourceObjectExistence = stringSourceObjectExistence;
// Target object existence check
var stringtargetObjectExistence = "";
if (checkBoxTargetObjectExistence.Checked)
{
stringtargetObjectExistence = "True";
}
else
{
stringtargetObjectExistence = "False";
}
ValidationSettings.TargetObjectExistence = stringtargetObjectExistence;
// Source business key existence check
var stringBusinessKeyExistence = "";
if (checkBoxSourceBusinessKeyExistence.Checked)
{
stringBusinessKeyExistence = "True";
}
else
{
stringBusinessKeyExistence = "False";
}
ValidationSettings.SourceBusinessKeyExistence = stringBusinessKeyExistence;
// Source attribute existence check
var stringSourceAttributeExistence = "";
if (checkBoxSourceAttribute.Checked)
{
stringSourceAttributeExistence = "True";
}
else
{
stringSourceAttributeExistence = "False";
}
ValidationSettings.SourceAttributeExistence = stringSourceAttributeExistence;
// Target attribute existence check
var stringTargetAttributeExistence = "";
if (checkBoxTargetAttribute.Checked)
{
stringTargetAttributeExistence = "True";
}
else
{
stringTargetAttributeExistence = "False";
}
ValidationSettings.TargetAttributeExistence = stringTargetAttributeExistence;
// Logical Group Validation
var stringLogicalGroup = "";
if (checkBoxLogicalGroup.Checked)
{
stringLogicalGroup = "True";
}
else
{
stringLogicalGroup = "False";
}
ValidationSettings.LogicalGroup = stringLogicalGroup;
// Link Key Order Validation
var stringLinkKeyOrder = "";
if (checkBoxLinkKeyOrder.Checked)
{
stringLinkKeyOrder = "True";
}
else
{
stringLinkKeyOrder = "False";
}
ValidationSettings.LinkKeyOrder = stringLinkKeyOrder;
// Business key syntax check
var businessKeySyntax = "";
if (checkBoxBusinessKeySyntaxValidation.Checked)
{
businessKeySyntax = "True";
}
else
{
businessKeySyntax = "False";
}
ValidationSettings.BusinessKeySyntax = businessKeySyntax;
// Write to disk
EnvironmentConfiguration.SaveValidationFile();
richTextBoxInformation.Text = "The values have been successfully saved.";
}
catch (Exception ex)
{
MessageBox.Show("Error: Could not write values to memory and disk. Original error: " + ex.Message, "An issues has been encountered", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
private void SetStandardConfigurationSettings()
{
if (checkBoxConfigurationSettings.Checked)
{
EnvironmentConfiguration.CreateEnvironmentConfigurationBackupFile();
// Shared values (same for all samples)
//var metadataRepositoryType = "SQLServer";
var stagingAreaPrefix = "STG";
var hubTablePrefix = "HUB";
var satTablePrefix = "SAT";
var linkTablePrefix = "LNK";
var linkSatTablePrefix = "LSAT";
string psaKeyLocation = "PrimaryKey";
string persistentStagingAreaPrefix;
string keyIdentifier;
string sourceRowId;
string eventDateTime;
string loadDateTime;
string expiryDateTime;
string changeDataIndicator;
string recordSource;
string etlProcessId;
string etlUpdateProcessId;
string logicalDeleteAttribute;
string tableNamingLocation;
string keyNamingLocation;
string recordChecksum;
string currentRecordIndicator;
string alternativeRecordSource;
string alternativeHubLoadDateTime;
string alternativeSatelliteLoadDateTime;
string alternativeRecordSourceFunction;
string alternativeHubLoadDateTimeFunction;
string alternativeSatelliteLoadDateTimeFunction;
// Update the values using the DIRECT information
if (checkBoxDIRECT.Checked)
{
persistentStagingAreaPrefix = "HSTG";
keyIdentifier = "SK";
sourceRowId = "OMD_SOURCE_ROW_ID";
eventDateTime = "OMD_EVENT_DATETIME";
loadDateTime = "OMD_INSERT_DATETIME";
expiryDateTime = "OMD_EXPIRY_DATETIME";
changeDataIndicator = "OMD_CDC_OPERATION";
recordSource = "OMD_RECORD_SOURCE";
etlProcessId = "OMD_INSERT_MODULE_INSTANCE_ID";
etlUpdateProcessId = "OMD_UPDATE_MODULE_INSTANCE_ID";
logicalDeleteAttribute = "OMD_DELETED_RECORD_INDICATOR";
tableNamingLocation = "Prefix";
keyNamingLocation = "Suffix";
recordChecksum = "OMD_HASH_FULL_RECORD";
currentRecordIndicator = "OMD_CURRENT_RECORD_INDICATOR";
alternativeRecordSource = "OMD_RECORD_SOURCE_ID";
alternativeHubLoadDateTime = "OMD_FIRST_SEEN_DATETIME";
alternativeSatelliteLoadDateTime = "OMD_EFFECTIVE_DATETIME";
alternativeRecordSourceFunction = "True";
alternativeHubLoadDateTimeFunction = "True";
alternativeSatelliteLoadDateTimeFunction = "True";
}
else // Use the standard (profiler) sample
{
persistentStagingAreaPrefix = "PSA";
keyIdentifier = "HSH";
sourceRowId = "SOURCE_ROW_ID";
eventDateTime = "EVENT_DATETIME";
loadDateTime = "LOAD_DATETIME";
expiryDateTime = "LOAD_END_DATETIME";
changeDataIndicator = "CDC_OPERATION";
recordSource = "RECORD_SOURCE";
etlProcessId = "ETL_INSERT_RUN_ID";
etlUpdateProcessId = "ETL_UPDATE_RUN_ID";
logicalDeleteAttribute = "DELETED_RECORD_INDICATOR";
tableNamingLocation = "Prefix";
keyNamingLocation = "Suffix";
recordChecksum = "HASH_FULL_RECORD";
currentRecordIndicator = "CURRENT_RECORD_INDICATOR";
alternativeRecordSource = "N/A";
alternativeHubLoadDateTime = "N/A";
alternativeSatelliteLoadDateTime = "N/A";
alternativeRecordSourceFunction = "False";
alternativeHubLoadDateTimeFunction = "False";
alternativeSatelliteLoadDateTimeFunction = "False";
}
//ConfigurationSettings.MetadataRepositoryType = metadataRepositoryType;
ConfigurationSettings.StgTablePrefixValue = stagingAreaPrefix;
ConfigurationSettings.PsaTablePrefixValue = persistentStagingAreaPrefix;
ConfigurationSettings.HubTablePrefixValue = hubTablePrefix;
ConfigurationSettings.SatTablePrefixValue = satTablePrefix;
ConfigurationSettings.LinkTablePrefixValue = linkTablePrefix;
ConfigurationSettings.LsatTablePrefixValue = linkSatTablePrefix;
ConfigurationSettings.DwhKeyIdentifier = keyIdentifier;
ConfigurationSettings.PsaKeyLocation = psaKeyLocation;
ConfigurationSettings.TableNamingLocation = tableNamingLocation;
ConfigurationSettings.KeyNamingLocation = keyNamingLocation;
ConfigurationSettings.EventDateTimeAttribute = eventDateTime;
ConfigurationSettings.LoadDateTimeAttribute = loadDateTime;
ConfigurationSettings.ExpiryDateTimeAttribute = expiryDateTime;
ConfigurationSettings.ChangeDataCaptureAttribute = changeDataIndicator;
ConfigurationSettings.RecordSourceAttribute = recordSource;
ConfigurationSettings.EtlProcessAttribute = etlProcessId;
ConfigurationSettings.EtlProcessUpdateAttribute = etlUpdateProcessId;
ConfigurationSettings.RowIdAttribute = sourceRowId;
ConfigurationSettings.RecordChecksumAttribute = recordChecksum;
ConfigurationSettings.CurrentRowAttribute = currentRecordIndicator;
ConfigurationSettings.LogicalDeleteAttribute = logicalDeleteAttribute;
ConfigurationSettings.EnableAlternativeRecordSourceAttribute = alternativeRecordSourceFunction;
ConfigurationSettings.AlternativeRecordSourceAttribute = alternativeRecordSource;
ConfigurationSettings.EnableAlternativeLoadDateTimeAttribute = alternativeHubLoadDateTimeFunction;
ConfigurationSettings.AlternativeLoadDateTimeAttribute = alternativeHubLoadDateTime;
ConfigurationSettings.EnableAlternativeSatelliteLoadDateTimeAttribute = alternativeSatelliteLoadDateTimeFunction;
ConfigurationSettings.AlternativeSatelliteLoadDateTimeAttribute = alternativeSatelliteLoadDateTime;
EnvironmentConfiguration.SaveConfigurationFile();
}
}
/// <summary>
/// Commit the changes to memory, save the configuration settings to disk and create a backup
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void saveConfigurationFileToolStripMenuItem_Click(object sender, EventArgs e)
{
string workingEnvironment = "";
if (radioButtonDevelopment.Checked)
{
workingEnvironment = "Development";
}
else if (radioButtonProduction.Checked)
{
workingEnvironment = "Production";
}
else
{
MessageBox.Show("An error occurred: neither the Development or Production radiobutton was selected.", "An issue has been encountered", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
// Update the root path file, part of the core solution to be able to store the config and output path
var rootPathConfigurationFile = new StringBuilder();
rootPathConfigurationFile.AppendLine("/* TEAM File Path Settings */");
rootPathConfigurationFile.AppendLine("/* Saved at " + DateTime.Now + " */");
rootPathConfigurationFile.AppendLine("ConfigurationPath|" + textBoxConfigurationPath.Text + "");
rootPathConfigurationFile.AppendLine("OutputPath|" + textBoxOutputPath.Text + "");
rootPathConfigurationFile.AppendLine("WorkingEnvironment|" + workingEnvironment + "");
rootPathConfigurationFile.AppendLine("/* End of file */");
using (var outfile = new StreamWriter(GlobalParameters.RootPath + GlobalParameters.PathFileName + GlobalParameters.FileExtension))
{
outfile.Write(rootPathConfigurationFile.ToString());
outfile.Close();
}
// Update the paths in memory
GlobalParameters.OutputPath = textBoxOutputPath.Text;
GlobalParameters.ConfigurationPath = textBoxConfigurationPath.Text;
GlobalParameters.WorkingEnvironment = workingEnvironment;
// Make sure the new paths as updated are available upon save for backup etc.
EnvironmentConfiguration.InitialiseConfigurationPath();
// Create a file backup for the configuration file
try
{
EnvironmentConfiguration.CreateEnvironmentConfigurationBackupFile();
richTextBoxInformation.Text = "A backup of the current configuration was made at " + DateTime.Now + " in " + textBoxConfigurationPath.Text + ".";
}
catch (Exception)
{
richTextBoxInformation.Text = "TEAM was unable to create a backup of the configuration file.";
}
// Update the in-memory variables for use throughout the application, to commit the saved changes for runtime use.
// This is needed before saving to disk, as the EnvironmentConfiguration Class retrieves the values from memory.
UpdateConfigurationInMemory();
// Save the information
EnvironmentConfiguration.SaveConfigurationFile();
parentFormMain.RevalidateFlag = true;
}
/// <summary>
/// This method will load an existing configuration file and display the values on the form, or create a new dummy one if not available
/// </summary>
/// <param name="chosenFile"></param>
private void LocalInitialiseConnections(string chosenFile)
{
// If the config file does not exist yet, create it by calling the EnvironmentConfiguration Class
if (!File.Exists(chosenFile))
{
var newEnvironmentConfiguration = new EnvironmentConfiguration();
newEnvironmentConfiguration.CreateDummyEnvironmentConfiguration(chosenFile);
}
// Open the configuration file
var configList = new Dictionary <string, string>();
var fs = new FileStream(chosenFile, FileMode.Open, FileAccess.Read);
var sr = new StreamReader(fs);
try
{
string textline;
while ((textline = sr.ReadLine()) != null)
{
if (textline.IndexOf(@"/*", StringComparison.Ordinal) == -1 && textline.Trim() != "")
{
var line = textline.Split('|');
configList.Add(line[0], line[1]);
}
}
sr.Close();
fs.Close();
//DWH settings
textBoxHubTablePrefix.Text = configList["HubTablePrefix"];
textBoxSatPrefix.Text = configList["SatTablePrefix"];
textBoxLinkTablePrefix.Text = configList["LinkTablePrefix"];
textBoxLinkSatPrefix.Text = configList["LinkSatTablePrefix"];
textBoxDWHKeyIdentifier.Text = configList["KeyIdentifier"];
textBoxSchemaName.Text = configList["SchemaName"];
textBoxEventDateTime.Text = configList["EventDateTimeStamp"];
textBoxLDST.Text = configList["LoadDateTimeStamp"];
textBoxExpiryDateTimeName.Text = configList["ExpiryDateTimeStamp"];
textBoxChangeDataCaptureIndicator.Text = configList["ChangeDataIndicator"];
textBoxRecordSource.Text = configList["RecordSourceAttribute"];
textBoxETLProcessID.Text = configList["ETLProcessID"];
textBoxETLUpdateProcessID.Text = configList["ETLUpdateProcessID"];
textBoxStagingAreaPrefix.Text = configList["StagingAreaPrefix"];
textBoxPSAPrefix.Text = configList["PersistentStagingAreaPrefix"];
textBoxSourceRowId.Text = configList["RowID"];
// Databases
textBoxSourceDatabase.Text = configList["SourceDatabase"];
textBoxStagingDatabase.Text = configList["StagingDatabase"];
textBoxPSADatabase.Text = configList["PersistentStagingDatabase"];
textBoxIntegrationDatabase.Text = configList["IntegrationDatabase"];
textBoxPresentationDatabase.Text = configList["PresentationDatabase"];
textBoxMetadataDatabaseName.Text = configList["MetadataDatabase"];
textBoxRecordChecksum.Text = configList["RecordChecksum"];
textBoxCurrentRecordAttributeName.Text = configList["CurrentRecordAttribute"];
textBoxAlternativeRecordSource.Text = configList["AlternativeRecordSource"];
textBoxHubAlternativeLDTSAttribute.Text = configList["AlternativeHubLDTS"];
textBoxSatelliteAlternativeLDTSAttribute.Text = configList["AlternativeSatelliteLDTS"];
textBoxLogicalDeleteAttributeName.Text = configList["LogicalDeleteAttribute"];
// Servers (instances)
textBoxPhysicalModelServerName.Text = configList["PhysicalModelServerName"];
textBoxMetadataServerName.Text = configList["MetadataServerName"];
//Checkbox setting based on loaded configuration
CheckBox myConfigurationCheckBox;
if (configList["AlternativeRecordSourceFunction"] == "False")
{
myConfigurationCheckBox = checkBoxAlternativeRecordSource;
myConfigurationCheckBox.Checked = false;
textBoxAlternativeRecordSource.Enabled = false;
}
else
{
myConfigurationCheckBox = checkBoxAlternativeRecordSource;
myConfigurationCheckBox.Checked = true;
}
if (configList["AlternativeHubLDTSFunction"] == "False")
{
myConfigurationCheckBox = checkBoxAlternativeHubLDTS;
myConfigurationCheckBox.Checked = false;
textBoxHubAlternativeLDTSAttribute.Enabled = false;
}
else
{
myConfigurationCheckBox = checkBoxAlternativeHubLDTS;
myConfigurationCheckBox.Checked = true;
}
if (configList["AlternativeSatelliteLDTSFunction"] == "False")
{
myConfigurationCheckBox = checkBoxAlternativeSatLDTS;
myConfigurationCheckBox.Checked = false;
textBoxSatelliteAlternativeLDTSAttribute.Enabled = false;
}
else
{
myConfigurationCheckBox = checkBoxAlternativeSatLDTS;
myConfigurationCheckBox.Checked = true;
}
//Radiobutton setting for prefix / suffix
RadioButton myTableRadioButton;
if (configList["TableNamingLocation"] == "Prefix")
{
myTableRadioButton = tablePrefixRadiobutton;
myTableRadioButton.Checked = true;
}
else
{
myTableRadioButton = tableSuffixRadiobutton;
myTableRadioButton.Checked = true;
}
//Radiobutton settings for on key location
RadioButton myKeyRadioButton;
if (configList["KeyNamingLocation"] == "Prefix")
{
myKeyRadioButton = keyPrefixRadiobutton;
myKeyRadioButton.Checked = true;
}
else
{
myKeyRadioButton = keySuffixRadiobutton;
myKeyRadioButton.Checked = true;
}
//Radiobutton settings for PSA Natural Key determination
RadioButton myPsaBusinessKeyLocation;
if (configList["PSAKeyLocation"] == "PrimaryKey")
{
myPsaBusinessKeyLocation = radioButtonPSABusinessKeyPK;
myPsaBusinessKeyLocation.Checked = true;
}
else
{
myPsaBusinessKeyLocation = radioButtonPSABusinessKeyIndex;
myPsaBusinessKeyLocation.Checked = true;
}
//Radiobutton settings for repository type
RadioButton myMetadatarepositoryType;
if (configList["metadataRepositoryType"] == "JSON")
{
myMetadatarepositoryType = radioButtonJSON;
myMetadatarepositoryType.Checked = true;
}
else
{
myMetadatarepositoryType = radioButtonSQLServer;
myMetadatarepositoryType.Checked = true;
}
// Authentication approach for metadata
var myRadioButtonMetadataSspi = radioButtonMetadataSSPI;
var myRadioButtonMetadataNamed = radioButtonMetadataNamed;
if (configList["MetadataSSPI"] == "True")
{
myRadioButtonMetadataSspi.Checked = true;
myRadioButtonMetadataNamed.Checked = false;
groupBoxMetadataNamedUser.Visible = false;
}
else
{
myRadioButtonMetadataSspi.Checked = false;
}
if (configList["MetadataNamed"] == "True")
{
myRadioButtonMetadataNamed.Checked = true;
myRadioButtonMetadataSspi.Checked = false;
groupBoxMetadataNamedUser.Visible = true;
}
else
{
myRadioButtonMetadataNamed.Checked = false;
groupBoxMetadataNamedUser.Visible = false;
}
// Authentication approach for the physical model
var myRadioButtonPhysicalModelSspi = radioButtonPhysicalModelSSPI;
var myRadioButtonPhysicalModelNamed = radioButtonPhysicalModelNamed;
if (configList["PhysicalModelSSPI"] == "True")
{
myRadioButtonPhysicalModelSspi.Checked = true;
myRadioButtonPhysicalModelNamed.Checked = false;
groupBoxMetadataNamedUser.Visible = false;
}
else
{
myRadioButtonPhysicalModelSspi.Checked = false;
}
if (configList["PhysicalModelNamed"] == "True")
{
myRadioButtonPhysicalModelNamed.Checked = true;
myRadioButtonPhysicalModelSspi.Checked = false;
groupBoxPhysicalModelNamedUser.Visible = true;
}
else
{
myRadioButtonPhysicalModelNamed.Checked = false;
groupBoxPhysicalModelNamedUser.Visible = false;
}
textBoxMetadataUserName.Text = configList["MetadataUserName"];
textBoxMetadataPassword.Text = configList["MetadataPassword"];
textBoxPhysicalModelUserName.Text = configList["PhysicalModelUserName"];
textBoxPhysicalModelPassword.Text = configList["PhysicalModelPassword"];
// Also commit the values to memory
UpdateConfigurationInMemory();
richTextBoxInformation.AppendText(@"The file " + chosenFile + " was uploaded successfully. \r\n\r\n");
}
catch (Exception ex)
{
richTextBoxInformation.AppendText("\r\n\r\nAn error occured while loading the configuration file. The original error is: '" + ex.Message + "'");
}
}
