void btnOK_Click(object sender, EventArgs e)
{
if (!Directory.Exists(txtCountryFolder.Text))
{
UserInfoHandler.ShowError("Import Country Folder does not exist.");
return;
}
if (Directory.Exists(EMPath.Folder_Countries(EM_AppContext.FolderEuromodFiles) + txtShortName.Text))
{
UserInfoHandler.ShowError("Country folder '" + txtShortName.Text + "' already exists at '" + EMPath.Folder_Countries(EM_AppContext.FolderEuromodFiles) + "'.");
return;
}
if (txtFlag.Text != string.Empty && !CountryAdministrator.IsValidFlagFilePath(txtFlag.Text))
{
return;
}
//out-commented as it does not really make sense to not allow for longer country-short-names
//if (txtShortName.Text.Length != 2)
//{
// if (UserInfoHandler.GetInfo("Short Name is supposed to have two characters. Do you want to correct?", MessageBoxButtons.YesNo) == DialogResult.Yes)
// return;
//}
DialogResult = DialogResult.OK;
Close();
}
internal static EM_AppContext Create_EM_AppContext(EM_UI_MainForm countryMainForm)
{
singleton = new EM_AppContext(countryMainForm);
_emptyForm = countryMainForm;
//show the dialog where the user can set the default pathes, if the folder to the country-xml-files does not exist
if (!Directory.Exists(EMPath.Folder_Countries(EM_AppContext.FolderEuromodFiles)))
{
ConfigurePathsForm configurePathsForm = new ConfigurePathsForm();
configurePathsForm.ShowDialog();
}
singleton.SetBrand(); // allow UI to show another look, i.e. present a brand alternative to EUROMOD
DefinitionAdmin.Init(); // initialise the common-lib's description of functions and parametes (once for the life-time of the lib)
return(singleton);
}
void btnOK_Click(object sender, EventArgs e)
{
string potCountryFolder = EMPath.Folder_Countries(EM_AppContext.FolderEuromodFiles) + txtShortName.Text;
string potAddOnFolder = EMPath.Folder_AddOns(EM_AppContext.FolderEuromodFiles) + txtShortName.Text;
if (Directory.Exists(potCountryFolder) || Directory.Exists(potAddOnFolder))
{
UserInfoHandler.ShowError("Country or Add-on '" + txtShortName.Text + "' already exists.");
return;
}
if (txtFlag.Text != string.Empty && !CountryAdministrator.IsValidFlagFilePath(txtFlag.Text))
{
return;
}
DialogResult = DialogResult.OK;
Close();
}
private void btnOK_Click(object sender, EventArgs e)
{
if (lstCountries.SelectedItems.Count == 0 && lstSystems.SelectedItems.Count == 0)
{
UserInfoHandler.ShowInfo("Please select the countries and/or systems you want to include into the project."); return;
}
if (txtProjectName.Text == string.Empty || txtProjectPath.Text == string.Empty)
{
UserInfoHandler.ShowError("Please select a valid Project Name and/or Project Path."); return;
}
projectPath = EMPath.AddSlash(EMPath.AddSlash(txtProjectPath.Text) + txtProjectName.Text);
if (!EM_Helpers.IsValidFileName(projectPath))
{
UserInfoHandler.ShowInfo(projectPath + " is not a valid folder name for the new project."); return;
}
Cursor = Cursors.WaitCursor; bool undo = false;
try
{
// first copy the whole EuromodFiles folder to the respective path, to then adapt the copy
if (!XCopy.Folder(EM_AppContext.FolderEuromodFiles, txtProjectPath.Text, txtProjectName.Text))
{
Cursor = Cursors.Default; return;
}
undo = true;
// delete all unnecessary files and folders (but do not report or stop if any of this fails)
EMPath emPath = new EMPath(EM_AppContext.FolderEuromodFiles);
DeleteFolder(ReplacePath(emPath.GetFolderLog()));
ClearFolder(ReplacePath(EM_AppContext.FolderOutput));
ClearFolder(ReplacePath(emPath.GetFolderTemp()));
DeleteFile(ReplacePath(Path.Combine(emPath.GetFolderConfig(true), "VersionControl.xml")));
string folderCountries = ReplacePath(EMPath.Folder_Countries(EM_AppContext.FolderEuromodFiles));
List <string> selCountries = new List <string>(); foreach (var item in lstCountries.SelectedItems)
{
selCountries.Add(item.ToString().ToLower());
}
ClearFolder(folderCountries, selCountries);
// delete all unnecessary systems
List <string> selSystems = null;
if (lstSystems.SelectedItems.Count > 0 && lstSystems.SelectedItems.Count != lstSystems.Items.Count)
{
selSystems = new List <string>(); foreach (var item in lstSystems.SelectedItems)
{
selSystems.Add(item.ToString().ToLower());
}
}
foreach (string cc in selCountries)
{
DeleteFile(EMPath.AddSlash(projectPath + cc) + cc + "_in_use.txt");
if (selSystems == null)
{
continue; // if all system/years are selected or nothing is selected, assume that user does not want to "reduce" systems
}
Country country = new Country(cc);
CountryConfigFacade ccf = country.GetCountryConfigFacade(true, folderCountries + country._shortName);
DataConfigFacade dcf = country.GetDataConfigFacade(true, folderCountries + country._shortName);
List <CountryConfig.SystemRow> delSystems = new List <CountryConfig.SystemRow>();
foreach (CountryConfig.SystemRow system in ccf.GetSystemRows())
{
if (radShowSystems.Checked)
{
if (!selSystems.Contains(system.Name.ToLower()))
{
delSystems.Add(system);
}
}
else
{
string systemYear = system.Year == null || system.Year == string.Empty ? EM_Helpers.ExtractSystemYear(system.Name) : system.Year;
if (!selSystems.Contains(systemYear))
{
delSystems.Add(system);
}
}
}
List <DataConfig.DBSystemConfigRow> delDBSysCons = new List <DataConfig.DBSystemConfigRow>();
List <string> delSystemIds = (from d in delSystems select d.ID).ToList();
foreach (DataConfig.DataBaseRow dataSet in dcf.GetDataBaseRows())
{
foreach (DataConfig.DBSystemConfigRow dbSystemConfig in dcf.GetDBSystemConfigRows(dataSet.ID))
{
if (delSystemIds.Contains(dbSystemConfig.SystemID))
{
delDBSysCons.Add(dbSystemConfig);
}
}
}
foreach (CountryConfig.SystemRow delSystem in delSystems)
{
delSystem.Delete();
}
foreach (DataConfig.DBSystemConfigRow delDBSysCon in delDBSysCons)
{
delDBSysCon.Delete();
}
country.WriteXML(folderCountries + country._shortName);
}
UserInfoHandler.ShowSuccess("Successfully created project folder " + projectPath + ".");
Close();
}
catch (Exception exception)
{
UserInfoHandler.ShowError(exception.Message);
if (undo)
{
try { if (Directory.Exists(projectPath))
{
Directory.Delete(projectPath, true);
}
} catch { }
}
}
Cursor = Cursors.Default;
}
static internal string GetFlagPath(string shortName, bool addOn)
{ //get "official" flag/symbol path, i.e. the path where country-flag/add-on-symbol ought to be stored from now on (even if it is not yet actually stored there)
if (ConsiderOldAddOnFileStructure(addOn))
{
return(new EMPath(EM_AppContext.FolderEuromodFiles).GetFolderImages()); //if add-ons are still stored "loosely" (not in folders) the symbols are still best stored in the Flags-folder (instead of also loosely in the AddOns-folder)
}
//otherwise the official flag/symbol path is the folder of the country/add-on
return(EMPath.AddSlash((addOn ? EMPath.Folder_AddOns(EM_AppContext.FolderEuromodFiles) : EMPath.Folder_Countries(EM_AppContext.FolderEuromodFiles)) + shortName));
}
static void RemovePrivate_BackgroundEventHandler(object sender, System.ComponentModel.DoWorkEventArgs e)
{
BackgroundWorker backgroundWorker = sender as BackgroundWorker;
if (backgroundWorker.CancellationPending)
{
e.Cancel = true; return;
} //user pressed Cancel button: stop the process and allow progress indicator to set dialog result to Cancel
//then adapt the copy
try
{
List <Country> countries = CountryAdministrator.GetCountries();
//remove private systems, policies and datasets of each country
for (int i = 0; i < countries.Count; ++i)
{
if (backgroundWorker.CancellationPending)
{
e.Cancel = true; return;
} //user pressed Cancel button: see above
Country country = countries[i];
CountryConfigFacade countryConfigFacade = country.GetCountryConfigFacade();
DataConfigFacade dataConfigFacade = country.GetDataConfigFacade();
//assess which systems, policies and datasets are private
List <CountryConfig.SystemRow> privateSystems = new List <CountryConfig.SystemRow>(); //systems
List <CountryConfig.PolicyRow> privatePolicies = new List <CountryConfig.PolicyRow>(); //policies
List <CountryConfig.FunctionRow> privateFunctions = new List <CountryConfig.FunctionRow>(); //functions
List <CountryConfig.ParameterRow> privateParameters = new List <CountryConfig.ParameterRow>(); //parameters
List <string> privateSystemIDs = new List <string>(); //necessary for afterwards identifying database-connections of private systems
foreach (CountryConfig.SystemRow system in countryConfigFacade.GetSystemRows())
{
if (system.Private.ToLower() == DefPar.Value.YES.ToLower())
{
privateSystems.Add(system);
privateSystemIDs.Add(system.ID);
}
else
{
foreach (CountryConfig.PolicyRow policy in system.GetPolicyRows())
{
if (policy.Private == DefPar.Value.YES)
{
privatePolicies.Add(policy);
}
else
{
if (policy.PrivateComment != null && policy.PrivateComment != string.Empty)
{
policy.PrivateComment = string.Empty; //remove private policy-comment if there is any
}
foreach (CountryConfig.FunctionRow function in policy.GetFunctionRows())
{
if (function.Private == DefPar.Value.YES)
{
privateFunctions.Add(function);
}
else
{
if (function.PrivateComment != null && function.PrivateComment != string.Empty)
{
function.PrivateComment = string.Empty; //remove private function-comment if there is any
}
foreach (CountryConfig.ParameterRow parameter in function.GetParameterRows())
{
if (parameter.Private == DefPar.Value.YES)
{
privateParameters.Add(parameter);
}
else if (parameter.PrivateComment != null && parameter.PrivateComment != string.Empty)
{
parameter.PrivateComment = string.Empty; //remove private parameter-comment if there is any
}
}
}
}
}
}
}
}
List <DataConfig.DataBaseRow> privateDataSets = new List <DataConfig.DataBaseRow>(); //datasets
List <DataConfig.DBSystemConfigRow> privateDBSystemConfigs = new List <DataConfig.DBSystemConfigRow>(); //database-connections of private systems
foreach (DataConfig.DataBaseRow dataSet in dataConfigFacade.GetDataBaseRows())
{
if (dataSet.Private.ToLower() == DefPar.Value.YES.ToLower())
{
privateDataSets.Add(dataSet);
}
else
{
foreach (DataConfig.DBSystemConfigRow dbSystemConfig in dataConfigFacade.GetDBSystemConfigRows(dataSet.ID))
{
if (privateSystemIDs.Contains(dbSystemConfig.SystemID))
{
privateDBSystemConfigs.Add(dbSystemConfig);
}
}
}
}
//remove user-set node colors
countryConfigFacade.RemoveAllNodeColors();
//restore or install default base-system-colouring
countryConfigFacade.setAutomaticConditionalFormatting(true);
//remove private systems
if (countryConfigFacade.GetCountryRow().Private == DefPar.Value.YES || //if country is private or
privateSystems.Count == countryConfigFacade.GetSystemRows().Count) //there are no systems left, delete country
{
Directory.Delete(EMPath.Folder_Countries(EM_AppContext.FolderEuromodFiles) + country._shortName, true);
country.SetCountryConfigFacade(null);
country.SetDataConfigFacade(null);
continue;
}
else //otherwise delete private systems
{
foreach (CountryConfig.SystemRow privateSystem in privateSystems)
{
privateSystem.Delete();
}
}
//remove private parameters
foreach (CountryConfig.ParameterRow privateParameter in privateParameters)
{
privateParameter.Delete();
}
//remove private functions
foreach (CountryConfig.FunctionRow privateFunction in privateFunctions)
{
privateFunction.Delete();
}
//remove private policies
foreach (CountryConfig.PolicyRow privatePolicy in privatePolicies)
{
privatePolicy.Delete();
}
//remove private datasets
foreach (DataConfig.DataBaseRow privateDataSet in privateDataSets)
{
privateDataSet.Delete();
}
//remove database-connections of private systems
foreach (DataConfig.DBSystemConfigRow privateDBSystemConfig in privateDBSystemConfigs)
{
privateDBSystemConfig.Delete();
}
country.WriteXML();
country.SetCountryConfigFacade(null);
country.SetDataConfigFacade(null);
backgroundWorker.ReportProgress(Convert.ToInt32((i + 1.0) / (countries.Count * 1.0) * 100.0));
}
//remove private add-ons
foreach (Country addOn in CountryAdministrator.GetAddOns())
{
bool oldStyle = CountryAdministrator.ConsiderOldAddOnFileStructure(true);
CountryConfigFacade addOnConfigFacade = addOn.GetCountryConfigFacade();
if (addOnConfigFacade.GetCountryRow().Private != DefPar.Value.YES)
{
continue;
}
if (oldStyle)
{
File.Delete(EMPath.Folder_AddOns(EM_AppContext.FolderEuromodFiles) + addOn._shortName + ".xml");
}
else
{
Directory.Delete(EMPath.Folder_AddOns(EM_AppContext.FolderEuromodFiles) + addOn._shortName, true);
}
addOn.SetCountryConfigFacade(null);
}
// remove the "other" column from the variables file
VarConfigFacade vcf = EM_AppContext.Instance.GetVarConfigFacade();
foreach (VarConfig.CountryLabelRow r in from l in vcf._varConfig.CountryLabel where l.Country.ToLower() == "other" select l)
{
r.Delete();
}
vcf.Commit(); vcf.WriteXML();
if (backgroundWorker.CancellationPending)
{
e.Cancel = true; return;
} //user pressed Cancel button: see above
}
catch (Exception exception)
{
UserInfoHandler.ShowException(exception);
e.Cancel = true; //stop the process and allow progress indicator to set dialog result to Cancel
}
}
static void Generate_BackgroundEventHandler(object sender, System.ComponentModel.DoWorkEventArgs e)
{
BackgroundWorker backgroundWorker = sender as BackgroundWorker;
if (backgroundWorker.CancellationPending)
{
e.Cancel = true; return;
} //user pressed Cancel button: stop the process and allow progress indicator to set dialog result to Cancel
//assess the name of the new EuromodFiles-folder in accordance to the version number
DirectoryInfo sourceFolder = new DirectoryInfo(EM_AppContext.FolderEuromodFiles);
string folderEMF = "EuromodFiles_" + _publicVersionNumber;
if (!EM_Helpers.IsValidFileName(folderEMF))
{
UserInfoHandler.ShowInfo(folderEMF + " is not a valid folder name. Please change the version number.");
e.Cancel = true; return;
}
//first copy the whole EuromodFiles folder to the respective path
if (!XCopy.Folder(EM_AppContext.FolderEuromodFiles, _publicVersionPath, folderEMF))
{
e.Cancel = true; return;
}
string fullPublicPath = _publicVersionPath + EMPath.AddSlash(folderEMF);
//then adapt the copy
string folderCountries =
EMPath.AddSlash( //at the new path assess the folder that contains the files (usually EuromodFiles)
EMPath.Folder_Countries(EM_AppContext.FolderEuromodFiles).Replace(EM_AppContext.FolderEuromodFiles, fullPublicPath));
try
{
List <Country> countries = CountryAdministrator.GetCountries();
//remove private systems, policies and datasets of each country
for (int i = 0; i < countries.Count; ++i)
{
if (backgroundWorker.CancellationPending)
{
e.Cancel = true; return;
} //user pressed Cancel button: see above
Country country = countries[i];
CountryConfigFacade countryConfigFacade = country.GetCountryConfigFacade(true, folderCountries + country._shortName);
DataConfigFacade dataConfigFacade = country.GetDataConfigFacade(true, folderCountries + country._shortName);
//assess which systems, policies and datasets are private
List <CountryConfig.SystemRow> privateSystems = new List <CountryConfig.SystemRow>(); //systems
List <CountryConfig.PolicyRow> privatePolicies = new List <CountryConfig.PolicyRow>(); //policies
List <CountryConfig.FunctionRow> privateFunctions = new List <CountryConfig.FunctionRow>(); //functions
List <CountryConfig.ParameterRow> privateParameters = new List <CountryConfig.ParameterRow>(); //parameters
List <string> privateSystemIDs = new List <string>(); //necessary for afterwards identifying database-connections of private systems
foreach (CountryConfig.SystemRow system in countryConfigFacade.GetSystemRows())
{
if (system.Private.ToLower() == DefPar.Value.YES.ToLower())
{
privateSystems.Add(system);
privateSystemIDs.Add(system.ID);
}
else
{
foreach (CountryConfig.PolicyRow policy in system.GetPolicyRows())
{
if (policy.Private == DefPar.Value.YES)
{
privatePolicies.Add(policy);
}
else
{
if (policy.PrivateComment != null && policy.PrivateComment != string.Empty)
{
policy.PrivateComment = string.Empty; //remove private policy-comment if there is any
}
foreach (CountryConfig.FunctionRow function in policy.GetFunctionRows())
{
if (function.Private == DefPar.Value.YES)
{
privateFunctions.Add(function);
}
else
{
if (function.PrivateComment != null && function.PrivateComment != string.Empty)
{
function.PrivateComment = string.Empty; //remove private function-comment if there is any
}
foreach (CountryConfig.ParameterRow parameter in function.GetParameterRows())
{
if (parameter.Private == DefPar.Value.YES)
{
privateParameters.Add(parameter);
}
else if (parameter.PrivateComment != null && parameter.PrivateComment != string.Empty)
{
parameter.PrivateComment = string.Empty; //remove private parameter-comment if there is any
}
}
}
}
}
}
}
}
List <DataConfig.DataBaseRow> privateDataSets = new List <DataConfig.DataBaseRow>(); //datasets
List <DataConfig.DBSystemConfigRow> privateDBSystemConfigs = new List <DataConfig.DBSystemConfigRow>(); //database-connections of private systems
foreach (DataConfig.DataBaseRow dataSet in dataConfigFacade.GetDataBaseRows())
{
if (dataSet.Private.ToLower() == DefPar.Value.YES.ToLower())
{
privateDataSets.Add(dataSet);
}
else
{
foreach (DataConfig.DBSystemConfigRow dbSystemConfig in dataConfigFacade.GetDBSystemConfigRows(dataSet.ID))
{
if (privateSystemIDs.Contains(dbSystemConfig.SystemID))
{
privateDBSystemConfigs.Add(dbSystemConfig);
}
}
}
}
//remove user-set node colors
countryConfigFacade.RemoveAllNodeColors();
//restore or install default base-system-colouring
countryConfigFacade.setAutomaticConditionalFormatting(true);
//remove private systems
if (countryConfigFacade.GetCountryRow().Private == DefPar.Value.YES || //if country is private or
privateSystems.Count == countryConfigFacade.GetSystemRows().Count) //there are no systems left, delete country
{
Directory.Delete(folderCountries + country._shortName, true);
country.SetCountryConfigFacade(null);
country.SetDataConfigFacade(null);
continue;
}
else //otherwise delete private systems
{
foreach (CountryConfig.SystemRow privateSystem in privateSystems)
{
privateSystem.Delete();
}
}
//remove private parameters
foreach (CountryConfig.ParameterRow privateParameter in privateParameters)
{
privateParameter.Delete();
}
//remove private functions
foreach (CountryConfig.FunctionRow privateFunction in privateFunctions)
{
privateFunction.Delete();
}
//remove private policies
foreach (CountryConfig.PolicyRow privatePolicy in privatePolicies)
{
privatePolicy.Delete();
}
//remove private datasets
foreach (DataConfig.DataBaseRow privateDataSet in privateDataSets)
{
privateDataSet.Delete();
}
//remove database-connections of private systems
foreach (DataConfig.DBSystemConfigRow privateDBSystemConfig in privateDBSystemConfigs)
{
privateDBSystemConfig.Delete();
}
country.WriteXML(folderCountries + country._shortName);
country.SetCountryConfigFacade(null);
country.SetDataConfigFacade(null);
backgroundWorker.ReportProgress(Convert.ToInt32((i + 1.0) / (countries.Count * 1.0) * 80.0));
}
//remove private add-ons
string folderAddOns = EMPath.AddSlash( //at the new path assess the folder that contains the files (usually EuromodFiles)
EMPath.Folder_AddOns(EM_AppContext.FolderEuromodFiles).Replace(EM_AppContext.FolderEuromodFiles, fullPublicPath));
foreach (Country addOn in CountryAdministrator.GetAddOns())
{
bool oldStyle = CountryAdministrator.ConsiderOldAddOnFileStructure(true);
CountryConfigFacade addOnConfigFacade = addOn.GetCountryConfigFacade(true, folderAddOns + (oldStyle ? string.Empty : addOn._shortName));
if (addOnConfigFacade.GetCountryRow().Private != DefPar.Value.YES)
{
continue;
}
if (oldStyle)
{
File.Delete(folderAddOns + addOn._shortName + ".xml");
}
else
{
Directory.Delete(folderAddOns + addOn._shortName, true);
}
addOn.SetCountryConfigFacade(null);
}
// remove the "other" column from the variables file
string pathVarConfig = new EMPath(EM_AppContext.FolderEuromodFiles).GetVarFilePath(true).Replace(EM_AppContext.FolderEuromodFiles, fullPublicPath);
VarConfigFacade vcf = new VarConfigFacade(pathVarConfig);
if (vcf.LoadVarConfig())
{
foreach (VarConfig.CountryLabelRow r in
from l in vcf._varConfig.CountryLabel where l.Country.ToLower() == "other" select l)
{
r.Delete();
}
vcf.Commit(); vcf.WriteXML(pathVarConfig);
}
if (backgroundWorker.CancellationPending)
{
e.Cancel = true; return;
} //user pressed Cancel button: see above
//change version number
string txtVersionPath = EMPath.Folder_Config(EM_AppContext.FolderEuromodFiles) + "EuromodVersion.txt";
txtVersionPath = txtVersionPath.Replace(EM_AppContext.FolderEuromodFiles, fullPublicPath);
using (StreamWriter versionFile = new StreamWriter(txtVersionPath))
{
versionFile.WriteLine(_publicVersionNumber);
versionFile.WriteLine("PUBLIC VERSION");
}
//remove private rows from log file
string logFile = new EMPath(EM_AppContext.FolderEuromodFiles).GetEmLogFilePath(); // determine the path of the em_log-file in the public folder
logFile = logFile.Replace(EM_AppContext.FolderEuromodFiles, fullPublicPath);
backgroundWorker.ReportProgress(100);
if (File.Exists(logFile))
{
AdaptLogFile(logFile);
}
//take care to not have any "xx_in_use.txt" files in the release
try
{
foreach (string inUseFile in Directory.GetFiles(fullPublicPath, "*_in_use.txt", SearchOption.AllDirectories))
{
File.Delete(inUseFile);
}
}
catch (Exception exception)
{
//do nothing if this fails
UserInfoHandler.RecordIgnoredException("PublicVersion.Generate_BackgroundEventHandler", exception);
}
}
catch (Exception exception)
{
UserInfoHandler.ShowException(exception);
e.Cancel = true; //stop the process and allow progress indicator to set dialog result to Cancel
}
}
private Dictionary <string, string> EM2_CreateConfig(string countryShortName, string outputPath, DataConfig.DataBaseRow dbr, CountryConfig.SystemRow sr, bool useTempCountry = true)
{
Dictionary <string, string> contentEMConfig = new Dictionary <string, string>();
string emVersion = EM_AppContext.Instance.GetProjectName();
if (emVersion.Trim() == string.Empty)
{
UserInfoHandler.ShowError($"{DefGeneral.BRAND_TITLE} version is not defined. Please define it via the menu 'Configuration'.");
return(null);
}
//fill EMConfig-entry-list
string dateTimePrefix = string.Format("{0:yyyyMMddHHmm}", DateTime.Now);
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_ERRLOG_FILE, outputPath + dateTimePrefix + EM_XmlHandler.TAGS.EM2CONFIG_errLogFileName);
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_LOG_WARNINGS, DefPar.Value.YES);
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_EMVERSION, emVersion);
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_UIVERSION, DefGeneral.UI_VERSION);
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_PARAMPATH, useTempCountry ? EMPath.AddSlash(EMPath.Folder_Temp(EM_AppContext.FolderEuromodFiles)) : EMPath.AddSlash(Path.Combine(EMPath.Folder_Countries(EM_AppContext.FolderEuromodFiles), countryShortName)));
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_CONFIGPATH, EMPath.Folder_Config(EM_AppContext.FolderEuromodFiles));
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_OUTPUTPATH, outputPath);
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_DATAPATH, EM_AppContext.FolderInput);
string executablePath = EnvironmentInfo.GetEM2ExecutableFile();
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_EMCONTENTPATH, EM_AppContext.FolderEuromodFiles);
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_HEADER_DATE, dateTimePrefix);
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_OUTFILE_DATE, "-");
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_LOG_RUNTIME, DefPar.Value.NO);
if (EM_AppContext.Instance.IsPublicVersion())
{
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_ISPUBLICVERSION, DefPar.Value.YES);
}
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_DECSIGN_PARAM, EM_Helpers.uiDecimalSeparator);
string startHH = EM_XmlHandler.TAGS.EM2CONFIG_defaultHHID;
string lastHH = EM_XmlHandler.TAGS.EM2CONFIG_defaultHHID;
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_STARTHH, startHH);
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_LASTHH, lastHH);
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_COUNTRY_FILE, CountryAdministrator.GetCountryFileName(countryShortName));
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_DATACONFIG_FILE, CountryAdministrator.GetDataFileName(countryShortName));
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_DATASET_ID, dbr.ID);
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_SYSTEM_ID, sr.ID);
//generate for each (available) switchable policy a POLICY_SWITCH-entry
Dictionary <string, string> extIDAndPattern = new Dictionary <string, string>();
foreach (GlobLocExtensionRow e in ExtensionAndGroupManager.GetExtensions(countryShortName))
{
extIDAndPattern.Add(e.ID, e.ShortName);
}
List <string> policySwitchEntries = new List <string>();
foreach (var e in extIDAndPattern)
{
string extID = e.Key, extShortName = e.Value;
string policySwitchValue = string.Empty;
if (dbr.GetDBSystemConfigRows().Count(x => x.SystemID == sr.ID) > 0)
{
policySwitchValue = ExtensionAndGroupManager.GetExtensionDefaultSwitch(dbr.GetDBSystemConfigRows().First(x => x.SystemID == sr.ID), extID);
}
//generate the POLICY_SWITCH-entry
//taking into account that there is no need to generate it if the switch is set to n/a (i.e. the switchable policy is not switchable for this db-system-combination or does not even exist)
if (policySwitchValue != string.Empty && policySwitchValue != DefPar.Value.NA)
{
string policySwitchEntry = //the executable needs three pieces of information to overwrite the default value of the policy switch:
extShortName //which switchable policy (e.g. BTA_??)
+ "=" + sr.ID //which system
+ "=" + policySwitchValue; //and the respective value (on or off)
policySwitchEntries.Add(policySwitchEntry);
}
}
//for each (available) switchable policy add a POLICY_SWITCH-entry
foreach (string policySwitchEntry in policySwitchEntries)
{
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_POLICY_SWITCH + Guid.NewGuid().ToString(), policySwitchEntry);
}
//now actually write the EMConfigXXX.xml files and hand them over to the run-manager
string configurationFileNameAndPath = EMPath.Folder_Temp(EM_AppContext.FolderEuromodFiles) + EM_XmlHandler.TAGS.EM2CONFIG_labelEMConfig + Guid.NewGuid().ToString() + ".xml";
using (XmlTextWriter configurationFileWriter = new XmlTextWriter(configurationFileNameAndPath, null))
{
configurationFileWriter.Formatting = System.Xml.Formatting.Indented;
configurationFileWriter.WriteStartDocument(true);
configurationFileWriter.WriteStartElement(EM_XmlHandler.TAGS.EM2CONFIG_labelEMConfig);
string runFormInfoText = string.Empty;
foreach (string key in contentEMConfig.Keys)
{
if (key.StartsWith(EM_XmlHandler.TAGS.EM2CONFIG_SYSTEM_ID)) //remove Guid, see above
{
configurationFileWriter.WriteElementString(EM_XmlHandler.TAGS.EM2CONFIG_SYSTEM_ID, contentEMConfig[key]);
}
else if (key.StartsWith(EM_XmlHandler.TAGS.EM2CONFIG_POLICY_SWITCH)) //remove Guid, see above
{
configurationFileWriter.WriteElementString(EM_XmlHandler.TAGS.EM2CONFIG_POLICY_SWITCH, contentEMConfig[key]);
}
else
{
configurationFileWriter.WriteElementString(key, contentEMConfig[key]);
}
}
configurationFileWriter.WriteElementString(EM_XmlHandler.TAGS.EM2CONFIG_LAST_RUN, DefPar.Value.NO);
configurationFileWriter.WriteEndElement();
configurationFileWriter.WriteEndDocument();
}
// EM3 returns the config-dictionary, therefore (mis)use this structure to just store the file-path as the first entry (to avoid extra variables for EM2)
return(new Dictionary <string, string>()
{
{ configurationFileNameAndPath, null }
});
}
internal string GetPath()
{
if (CountryAdministrator.ConsiderOldAddOnFileStructure(_isAddOn))
{
return(EMPath.Folder_AddOns(EM_AppContext.FolderEuromodFiles));
}
else
{
return(EMPath.AddSlash((_isAddOn ? EMPath.Folder_AddOns(EM_AppContext.FolderEuromodFiles) : EMPath.Folder_Countries(EM_AppContext.FolderEuromodFiles)) + _shortName));
}
}
internal static bool CopyXMLFiles(string shortName, out string errorMessage,
string sourceFolder = "", string destinationFolder = "", int addOn = -1)
{
try
{
bool isAddOn = addOn == -1 ? CountryAdministrator.IsAddOn(shortName) : (addOn == 0 ? false : true);
string defaultFolder = isAddOn ? EMPath.Folder_AddOns(EM_AppContext.FolderEuromodFiles) : EMPath.Folder_Countries(EM_AppContext.FolderEuromodFiles);
if (!CountryAdministrator.ConsiderOldAddOnFileStructure(isAddOn))
{
defaultFolder += shortName;
}
if (destinationFolder == string.Empty)
{
destinationFolder = defaultFolder;
}
if (sourceFolder == string.Empty)
{
sourceFolder = defaultFolder;
}
File.Copy(EMPath.AddSlash(sourceFolder) + GetCountryXMLFileName(shortName),
EMPath.AddSlash(destinationFolder) + GetCountryXMLFileName(shortName), true);
if (!isAddOn)
{
File.Copy(EMPath.AddSlash(sourceFolder) + GetDataConfigXMLFileName(shortName),
EMPath.AddSlash(destinationFolder) + GetDataConfigXMLFileName(shortName), true);
}
errorMessage = string.Empty;
return(true);
}
catch (Exception exception)
{
errorMessage = exception.Message;
return(false);
}
}