internal override RepositoryItem GetEditor(TreeListNode senderNode, TreeListColumn senderColumn) { try { //assess whether the policy is switchable for the specific system, i.e. is controlled via the switches-dialog and the run-tool if (ExtensionAndGroupManager.ShowExtensionSwitchEditor(_policyRows[(senderColumn.Tag as SystemTreeListTag).GetSystemRow().ID])) { return(GetSwitchEditor()); } } catch (Exception exception) { Tools.UserInfoHandler.RecordIgnoredException("PolicyTreeListTag.GetEditor", exception); } return(_mainForm.OnOffToggleEditor); //if no return the (standard) combobox, which allows selecting the switch (on, off, ...) }
// avoid that user's paste something else than on/off/etc. into policy- and function-switches internal bool IsPermittedPasteValue(string value, string systemID) { if (GetDefaultParameterRow() != null) { return(true); // no check for parameters } if ((GetDefaultFunctionRow() != null && ExtensionAndGroupManager.ShowExtensionSwitchEditor(GetDefaultFunctionRow())) || (GetDefaultPolicyRow() != null && ExtensionAndGroupManager.ShowExtensionSwitchEditor(GetDefaultPolicyRow()))) { return(false); // if switch='switch' the cell is not-editable } return(value.ToLower() == DefPar.Value.ON || value.ToLower() == DefPar.Value.OFF || value.ToLower() == DefPar.Value.TOGGLE || value.ToLower() == DefPar.Value.NA); }
void FillPolicyNodeWithFunctions(CountryConfig.SystemRow systemRow, CountryConfig.PolicyRow policyRow, TreeListNode policyNode, bool isFirstSystem) { //generate the functions of the policy int functionIndex = 0; var functionQuery = (from function in policyRow.GetFunctionRows() select function).OrderBy(function => long.Parse(function.Order)); foreach (CountryConfig.FunctionRow functionRow in functionQuery.ToList <CountryConfig.FunctionRow>()) { TreeListNode functionNode = isFirstSystem ? BuildFunctionNode(policyNode, functionRow) : policyNode.Nodes[functionIndex++]; (functionNode.Tag as FunctionTreeListTag).AddFunctionRowOfSystem(systemRow.ID, functionRow); functionNode.SetValue(systemRow.Name, ExtensionAndGroupManager.GetExtensionAdaptedSwitch(functionRow)); //generate the parameters of the function FillFunctionNodeWithParameters(systemRow, functionRow, functionNode, isFirstSystem); } }
internal override void PerformAction() { CountryConfig.SystemRow systemRow = (_senderColumn == null) ? null : (_senderColumn.Tag as SystemTreeListTag).GetSystemRow(); TreeList countryTreeList = (_senderColumn != null) ? _senderColumn.TreeList : null; string systemName = systemRow == null ? string.Empty : systemRow.Name; string systemYear = systemRow == null ? string.Empty : systemRow.Year; if (!SystemValidation.GetSystemNameAndYear(!_isAddOn, ref systemName, ref systemYear, countryTreeList)) { _actionIsCanceled = true; return; } CountryConfig.SystemRow newSystemRow; if (_senderColumn == null) //add very first system { newSystemRow = _countryConfigFacade.AddFirstSystemRow(systemName); } else //add system by copying an existing system { CountryConfig.SystemRow toCopySystemRow = (_senderColumn.Tag as SystemTreeListTag).GetSystemRow(); //copy system itself newSystemRow = CountryConfigFacade.CopySystemRow(systemName, toCopySystemRow); //copy all references of the system with datasets (i.e. new system can be used with same datasets as its template) if (!_isAddOn) { _dataConfigFacade.CopyDBSystemConfigRows(toCopySystemRow, newSystemRow); } //copy system formats _countryConfigFacade.CopySystemFormatting(toCopySystemRow, newSystemRow); //rename output filename of default outputs RenameOutputFiles(_countryConfigFacade, newSystemRow, toCopySystemRow.Name); //adapt exchange-rate in global table //note that the exchange-rate-config is not included in the undo-procedure, thus this will not be undone AddToExchangeRatesTable(systemName, toCopySystemRow); ExtensionAndGroupManager.CopyExtensionAndGroupMemberships(_countryConfigFacade.GetCountryConfig(), newSystemRow.ID, toCopySystemRow.ID); } newSystemRow.Year = systemYear; }
internal void InsertFunctionNode(List <CountryConfig.FunctionRow> functionRowsOfAllSystems, TreeListNode policyNode, int nodeIndex = -1) { TreeListNode functionNode = null; bool isFirstSystem = true; foreach (CountryConfig.FunctionRow functionRow in functionRowsOfAllSystems) { CountryConfig.SystemRow systemRow = functionRow.PolicyRow.SystemRow; functionNode = isFirstSystem ? BuildFunctionNode(policyNode, functionRow) : policyNode.Nodes.LastNode; (functionNode.Tag as FunctionTreeListTag).AddFunctionRowOfSystem(systemRow.ID, functionRow); functionNode.SetValue(systemRow.Name, ExtensionAndGroupManager.GetExtensionAdaptedSwitch(functionRow)); FillFunctionNodeWithParameters(systemRow, functionRow, functionNode, isFirstSystem); isFirstSystem = false; } if (nodeIndex != -1) { _mainForm.treeList.SetNodeIndex(functionNode, nodeIndex); } }
void InsertExtensionsColumns(bool global, bool countrySpecific) { Worksheet sheetExtensions = global & countrySpecific ? sheetExtensionsContent : global ? sheetGlobalExtensions : sheetCountriesExtensions; Dictionary <string, int> extensions = global & countrySpecific ? allExtensions : global ? globalExtensions : countriesExtensions; int colSwitches = 1; List <Tuple <string, string> > ext = new List <Tuple <string, string> >(); if (global) { foreach (GlobLocExtensionRow gle in ExtensionAndGroupManager.GetGlobalExtensions()) { ext.Add(new Tuple <string, string>(gle.ID, gle.Name)); } } if (countrySpecific) { foreach (Tuple <string, string, bool> e in countriesExtensionInfo) { ext.Add(new Tuple <string, string>(e.Item1, $"{e.Item2}{(e.Item3 ? " (whole content private)" : string.Empty)}")); } } for (int c = 0; c < ext.Count - 2; ++c) { int cIns = colSwitches + 1 + c; sheetExtensions.Columns[cIns].Insert(InsertCellsMode.ShiftCellsRight); sheetExtensions.Columns[cIns].CopyFrom(sheetExtensions.Columns[colSwitches]); // to overtake the format } int cLabel = -1; for (int c = 0; c < ext.Count; ++c) { cLabel = colSwitches + c; sheetExtensions[1, cLabel].Value = ext[c].Item2; extensions.Add(ext[c].Item1, cLabel); } }
internal void InsertPolicyNode(CountryConfig.PolicyRow distinctPolicyRow, int nodeIndex = -1) { TreeListNode policyNode = _mainForm.treeList.AppendNode(null, null); if (nodeIndex != -1) { _mainForm.treeList.SetNodeIndex(policyNode, nodeIndex); } //a reference policy is a policy that does not really exist, but marks (in the spine) //the re-calculation of a policy that was already calculated further up in the spine CountryConfig.PolicyRow referencePolicy = null; if (distinctPolicyRow.ReferencePolID != null && distinctPolicyRow.ReferencePolID != string.Empty) { referencePolicy = _countryConfigFacade.GetPolicyRowByID(distinctPolicyRow.ReferencePolID); //get the "real" policy to assess the necessary information (in essence the name) } //equip the node with the non system specific information about the policy policyNode.SetValue(_policyColumnName, referencePolicy == null ? distinctPolicyRow.Name : referencePolicy.Name); policyNode.SetValue(_commentColumnName, distinctPolicyRow.Comment); policyNode.Tag = new PolicyTreeListTag(_mainForm); //here create the tag - (system specific) information will be filled in below policyNode.StateImageIndex = policyNode.SelectImageIndex = PolicyTreeListTag.GetStateImageIndex(distinctPolicyRow); policyNode.ImageIndex = -1; //not used bool isFirstSystem = true; foreach (CountryConfig.SystemRow systemRow in _countryConfigFacade.GetSystemRowsOrdered()) { //equip the policy node with the system specific information about the policy CountryConfig.PolicyRow policyRow = _countryConfigFacade.GetPolicyRowByNameOrderAndSystemID(distinctPolicyRow.Name, distinctPolicyRow.Order, systemRow.ID); (policyNode.Tag as PolicyTreeListTag).AddPolicyRowOfSystem(systemRow.ID, policyRow); policyNode.SetValue(systemRow.Name, ExtensionAndGroupManager.GetExtensionAdaptedSwitch(policyRow)); FillPolicyNodeWithFunctions(systemRow, policyRow, policyNode, isFirstSystem); isFirstSystem = false; } }
void AddSwitchablePolicyConfig(bool local) { foreach (string ID in GetRelevantIDs(_mcSwitchablePolicyConfig, local, true)) { ExtensionAndGroupMergeHelper.CopyGlobalExtensionFromAnotherConfig(_vcLocal, ExtensionAndGroupManager.GetGlobalExtension(ID)); } }
void AssessCountryInfo() { rvCountryInfo = new List <RVCountryInfo>(); systemYears = new List <int>(); systemYearsPublic = new List <int>(); CountryConfigFacade ccfMTR = CountryAdministrator.GetCountryConfigFacade("MTR"); CountryConfigFacade ccfLMA = CountryAdministrator.GetCountryConfigFacade("LMA"); CountryConfigFacade ccfNRR = CountryAdministrator.GetCountryConfigFacade("NRR"); foreach (string country in countries) { CountryConfigFacade ccf = CountryAdministrator.GetCountryConfigFacade(country); DataConfigFacade dcf = CountryAdministrator.GetDataConfigFacade(country); RVCountryInfo ccInfo = new RVCountryInfo(country); List <int> ccSystemYearsPublic = new List <int>(); foreach (CountryConfig.SystemRow system in CountryAdministrator.GetCountryConfigFacade(country).GetSystemRows()) { int year = RVItem_SystemConfiguration.GetSystemYear(system); if (year == -1) { continue; } bool isPrivate = system.Private == DefPar.Value.YES; if (!ccInfo.systemYearInfo.ContainsKey(year)) { ccInfo.systemYearInfo.Add(year, isPrivate); } else if (ccInfo.systemYearInfo[year] == true) { ccInfo.systemYearInfo[year] = isPrivate; // if there is a public and a private system for the year, let the public dominate } if (!systemYears.Contains(year)) { systemYears.Add(year); } if (!isPrivate) { ccSystemYearsPublic.Add(year); if (!systemYearsPublic.Contains(year)) { systemYearsPublic.Add(year); } } List <DataConfig.DBSystemConfigRow> bm = (from d in dcf.GetDataConfig().DBSystemConfig where d.SystemID == system.ID & d.BestMatch == DefPar.Value.YES select d).ToList(); if (bm.Count > 0 && !ccInfo.bestMatchInfo.ContainsKey(year)) { ccInfo.bestMatchInfo.Add(year, bm.First().DataBaseRow.Name); } } //ccInfo.privateComponents = (from p in ccf.GetPolicyRowsOrderedAndDistinct() // where p.Private == DefPar.Value.YES select p.Name).ToList(); int oPol = 0; foreach (CountryConfig.PolicyRow pol in ccf.GetPolicyRowsOrderedAndDistinct()) { ++oPol; int oFun = 0; string privFun = string.Empty; ccInfo.idOrderInfo.Add(pol.ID, $"{oPol}"); if (pol.Private == DefPar.Value.YES) { ccInfo.privatePolicies.Add(string.Format("{0} {1}", oPol, pol.Name)); continue; } foreach (CountryConfig.FunctionRow fun in (from f in pol.GetFunctionRows() select f).OrderBy(f => long.Parse(f.Order))) { ++oFun; int oPar = 0; string privPar = string.Empty; ccInfo.idOrderInfo.Add(fun.ID, $"{oPol}.{oFun}"); if (fun.Private == DefPar.Value.YES) { privFun += string.Format("{0} {1} ", oFun, fun.Name); continue; } foreach (CountryConfig.ParameterRow par in (from p in fun.GetParameterRows() select p).OrderBy(p => long.Parse(p.Order))) { ++oPar; ccInfo.idOrderInfo.Add(par.ID, $"{oPol}.{oFun}.{oPar}"); if (par.Private == DefPar.Value.YES) { privPar += string.Format("{0} {1} ", oPar, par.Name); continue; } } if (privPar != string.Empty) { ccInfo.privateParameters.Add(string.Format("{0}.{1} {2}/{3}/...: {4}", oPol.ToString(), oFun.ToString(), pol.Name, fun.Name, privPar)); } } if (privFun != string.Empty) { ccInfo.privateFunctions.Add(string.Format("{0} {1}/...: {2}", oPol, pol.Name, privFun)); } } foreach (DataConfig.DataBaseRow data in dcf.GetDataBaseRows()) { if (ccInfo.dataInfo.ContainsKey(data.Name)) { continue; } bool isPrivate = data.Private == DefPar.Value.YES; ccInfo.dataInfo.Add(data.Name, isPrivate); if (data.Name.ToLower().StartsWith("training")) { ccInfo.hasTrainingData = true; ccInfo.isTrainingPublic = !isPrivate; } if (data.Name.ToLower().StartsWith("hypo")) { ccInfo.hasHypoData = true; } if (isPrivate) { continue; } ccInfo.dataNA.Add(data.Name, new List <string>()); if (!data.Name.ToLower().Contains("hhot")) { foreach (int systemYearPublic in ccSystemYearsPublic) { bool isAvailable = false; foreach (DataConfig.DBSystemConfigRow dbs in dcf.GetDBSystemConfigRows(data.ID)) { CountryConfig.SystemRow systemRow = CountryAdministrator.GetCountryConfigFacade(country).GetSystemRowByName(dbs.SystemName); if (RVItem_SystemConfiguration.GetSystemYear(systemRow) == systemYearPublic) { isAvailable = true; break; } } if (!isAvailable) { ccInfo.dataNA[data.Name].Add(systemYearPublic.ToString()); } } } } foreach (string extId in (from s in dcf.GetDataConfig().PolicySwitch select s.SwitchablePolicyID).Distinct()) { AssessExtensionInfo(ccf, dcf, extId, DefPar.Value.ON, ref ccInfo.switchInfoOn); AssessExtensionInfo(ccf, dcf, extId, DefPar.Value.OFF, ref ccInfo.switchInfoOff); } AssessExtensionContent(ccf, dcf, ccInfo.idOrderInfo, ref ccInfo.extensionContent); foreach (DataConfig.ExtensionRow er in dcf.GetDataConfig().Extension) { ; } foreach (GlobLocExtensionRow er in ExtensionAndGroupManager.GetLocalExtensions(ccInfo.country)) { countriesExtensionInfo.Add(new Tuple <string, string, bool>(er.ID, er.Name, IsWholeContentPrivate(ccf.GetCountryConfig(), er.ID))); } ccInfo.mtrImplemented = AddOnImplemented(ccfMTR, country, "mtr"); ccInfo.lmaImplemented = AddOnImplemented(ccfLMA, country, "lma"); ccInfo.nrrImplemented = AddOnImplemented(ccfNRR, country, "nrr"); rvCountryInfo.Add(ccInfo); } systemYears.Sort(); systemYearsPublic.Sort(); }
internal override void PerformAction() { TreeListNode policyNode = _senderNode; if (_senderNode.ParentNode != null) { policyNode = _senderNode.ParentNode; } int newFunctionNodeIndex = -1; List <CountryConfig.FunctionRow> newFunctionRows = new List <CountryConfig.FunctionRow>(); foreach (CountryConfig.PolicyRow policyRow in (policyNode.Tag as PolicyTreeListTag).GetPolicyRows()) //loop over systems { CountryConfig.FunctionRow newFunctionRow = null; //(1) add function //if the sender node is a policy node: insert as last function ('Add Function' was called from policy node or 'Add Function After' was called from last function node in policy) if (_senderNode == policyNode) { newFunctionRow = CountryConfigFacade.AddFunctionRowAtTail(_functionName, policyRow, // the switch of a function inside an extension-policy cannot be changed, therefore add as on (otherwise one would need to remove the policy from the extension to be able to change the switch to on) ExtensionAndGroupManager.ShowExtensionSwitchEditor(policyRow) ? DefPar.Value.ON : DefPar.Value.NA); } //if the sender node is a function node: insert before ('Add Function Before' was called from function node) else { CountryConfig.FunctionRow neighbourFunction = (_senderNode.Tag as FunctionTreeListTag).GetFunctionRowOfSystem(policyRow.SystemRow.ID); newFunctionRow = CountryConfigFacade.AddFunctionRow(_functionName, neighbourFunction, true, ExtensionAndGroupManager.ShowExtensionSwitchEditor(policyRow) ? DefPar.Value.ON : DefPar.Value.NA); // see comment above newFunctionNodeIndex = _mainForm.treeList.GetNodeIndex(_senderNode); } _addedFunctionsIDs.Add(newFunctionRow.ID); //(2) add compulsory parameters DefinitionAdmin.Fun fun = DefinitionAdmin.GetFunDefinition(_functionName, false); if (fun != null) { for (short doCommon = 0; doCommon < 2; ++doCommon) // add function-specific parameters before common { foreach (var p in fun.GetParList()) { AddPar(p, false); } foreach (var pg in fun.GetGroupParList()) { if (pg.minCount > 0) { foreach (var p in pg.par) { AddPar(p, true); } } } void AddPar(KeyValuePair <string, DefinitionAdmin.Par> p, bool group) { string parName = p.Key.ToUpper() == DefPar.PAR_TYPE.PLACEHOLDER.ToString().ToUpper() ? DefinitionAdmin.ParTypeToString(DefPar.PAR_TYPE.PLACEHOLDER) : p.Key; DefinitionAdmin.Par parDef = p.Value; if (parDef.minCount > 0 && ((doCommon == 0 && !parDef.isCommon) || (doCommon == 1 && parDef.isCommon))) { CountryConfigFacade.AddParameterRowAtTail(newFunctionRow, parName, parDef, group ? "1" : string.Empty); } } } } newFunctionRows.Add(newFunctionRow); } _mainForm.GetTreeListBuilder().InsertFunctionNode(newFunctionRows, policyNode, newFunctionNodeIndex); }
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 } }); }