//add system by copying an existing system internal CopySystemAction(TreeListColumn senderColumn, CountryConfigFacade countryConfigFacade, DataConfigFacade dataConfigFacade) { _senderColumn = senderColumn; _countryConfigFacade = countryConfigFacade; _dataConfigFacade = dataConfigFacade; _isAddOn = _dataConfigFacade == null; }
internal DataConfigFacade GetDataConfigFacade(bool enforceReading = false, string alternativePath = "") { if (_isAddOn) { return(null); } try { if (_dataConfigFacade == null || enforceReading) { if (alternativePath == string.Empty) { alternativePath = GetPath(); } _dataConfigFacade = new DataConfigFacade(); _dataConfigFacade.ReadXml(alternativePath, GetDataConfigFileName()); } } catch (Exception e) { Tools.UserInfoHandler.ShowException(e); } return(_dataConfigFacade); }
internal override void PerformValidation(List <string> countries, bool showProblemsOnly) { base.PerformValidation(countries, showProblemsOnly); string noHICP = string.Empty, notDollarF = string.Empty, emptyFactors = string.Empty, zeroFactors = string.Empty, noYearForSystem = string.Empty, noYearForData = string.Empty, noIncomeYear = string.Empty; foreach (string country in countries) { CountryConfigFacade ccf = CountryAdministrator.GetCountryConfigFacade(country); DataConfigFacade dcf = CountryAdministrator.GetDataConfigFacade(country); List <CountryConfig.UpratingIndexRow> indices = (from ui in ccf.GetUpratingIndices() select ui).ToList(); List <CountryConfig.SystemRow> publicSystems = GetPublicSystems(country); List <DataConfig.DataBaseRow> datasets = (from d in dcf.GetDataBaseRows() where d.Private != DefPar.Value.YES select d).ToList(); List <string> indexYears = ccf.GetAllUpratingIndexYears(); RegisterProblems(country, NotDollarF(indices), ref notDollarF); RegisterProblems(country, NoYearForSystem(publicSystems, indexYears), ref noYearForSystem); RegisterProblems(country, NoYearForData(datasets, indexYears), ref noYearForData); RegisterProblems(country, NoIncomeYear(datasets), ref noIncomeYear); RegisterProblems(country, EmptyFactors(ccf, indices, false), ref emptyFactors); RegisterProblems(country, EmptyFactors(ccf, indices, true), ref zeroFactors); } AddDataGridRow("Factors not starting with $f_", notDollarF); AddDataGridRow("Systems for which factor-table does not provide year", noYearForSystem); AddDataGridRow("Databases for which factor-table does not provide year", noYearForData); AddDataGridRow("Databases with undefined income year", noIncomeYear); AddDataGridRow("Factors with empty values", emptyFactors); AddDataGridRow("Factors with zero values (warning)", zeroFactors); }
internal UpratingIndicesForm(EM_UI_MainForm mainForm) { InitializeComponent(); try { _mainForm = mainForm; _countryConfigFacade = EM_UI.CountryAdministration.CountryAdministrator.GetCountryConfigFacade(_mainForm.GetCountryShortName()); _dataConfigFacade = EM_UI.CountryAdministration.CountryAdministrator.GetDataConfigFacade(_mainForm.GetCountryShortName()); dgvDataSet.Tables.Add(dgvDataTable); dgvIndices.DataSource = dgvDataSet; dgvIndices.DataMember = "dgvDataTable"; //load the information for the 'Raw Indices' tab LoadIndices(); //load the information for the 'Factors per Data and System' tab ... //... datasets (for selection by the user) foreach (DataConfig.DataBaseRow dataSet in _dataConfigFacade.GetDataBaseRows()) { cmbDatasets.Items.Add(dataSet.Name); } //... and systems (for the table) foreach (CountryConfig.SystemRow system in _countryConfigFacade.GetSystemRowsOrdered()) { bool showSystem = false; foreach (DevExpress.XtraTreeList.Columns.TreeListColumn c in mainForm.treeList.VisibleColumns) { showSystem = showSystem || (c.Name.ToLower() == system.Name.ToLower()); } if (showSystem) { DataGridViewColumn headerColumn = colIndexName.Clone() as DataGridViewColumn; //clone the factorname-column to overtake the settings headerColumn.Name = system.ID; //to be able to identify each system column, when the table is filled headerColumn.HeaderText = system.Name; int index = dgvFactors.Columns.Add(headerColumn); dgvFactors.Columns[index].Tag = system; } } // only after all the data is loaded, add the row numbers and the refresh listeners dgvIndices.RowHeadersWidthSizeMode = DataGridViewRowHeadersWidthSizeMode.AutoSizeToAllHeaders; dgvIndices.RowsAdded += new System.Windows.Forms.DataGridViewRowsAddedEventHandler(dgvIndices_RefreshRowNumbers); dgvIndices.RowsRemoved += new System.Windows.Forms.DataGridViewRowsRemovedEventHandler(dgvIndices_RefreshRowNumbers); dgvIndices_RefreshRowNumbers(null, null); colIndexDescription.Frozen = true; colReference.Frozen = true; // colComment.Frozen = true; // this can only happen if it is not the last row! } catch (Exception exception) { UserInfoHandler.ShowException(exception); } }
private void AssessExtensionContent(CountryConfigFacade ccf, DataConfigFacade dcf, Dictionary <string, string> idOrderInfo, ref Dictionary <string, List <string> > extensionContent) { extensionContent.Clear(); foreach (string extId in (from s in dcf.GetDataConfig().PolicySwitch select s.SwitchablePolicyID).Distinct()) { List <string> content = new List <string>(); foreach (CountryConfig.Extension_PolicyRow extPolRow in from e in ccf.GetCountryConfig().Extension_Policy where e.ExtensionID == extId select e) { if (extPolRow.PolicyRow.SystemRow != ccf.GetSystemRows().First()) { continue; } string order = idOrderInfo.ContainsKey(extPolRow.PolicyID) ? idOrderInfo[extPolRow.PolicyID] : string.Empty; string name = string.IsNullOrEmpty(extPolRow.PolicyRow.ReferencePolID) ? extPolRow.PolicyRow.Name : ccf.GetPolicyRowByID(extPolRow.PolicyRow.ReferencePolID).Name; string description = $"{order} {name}: {(extPolRow.BaseOff ? DefPar.Value.OFF : DefPar.Value.ON)}"; if (extPolRow.PolicyRow.Private == DefPar.Value.YES) { description += " (private)"; } content.Add(description); } foreach (CountryConfig.Extension_FunctionRow extFunRow in from e in ccf.GetCountryConfig().Extension_Function where e.ExtensionID == extId select e) { if (extFunRow.FunctionRow.PolicyRow.SystemRow != ccf.GetSystemRows().First()) { continue; } string order = idOrderInfo.ContainsKey(extFunRow.FunctionID) ? idOrderInfo[extFunRow.FunctionID] : string.Empty; string description = $"{order} {extFunRow.FunctionRow.Name}: {(extFunRow.BaseOff ? DefPar.Value.OFF : DefPar.Value.ON)}"; if (extFunRow.FunctionRow.Private == DefPar.Value.YES) { description += " (private)"; } content.Add(description); } foreach (CountryConfig.Extension_ParameterRow extParRow in from e in ccf.GetCountryConfig().Extension_Parameter where e.ExtensionID == extId select e) { if (extParRow.ParameterRow.FunctionRow.PolicyRow.SystemRow != ccf.GetSystemRows().First()) { continue; } string order = idOrderInfo.ContainsKey(extParRow.ParameterID) ? idOrderInfo[extParRow.ParameterID] : string.Empty; string description = $"{order} {extParRow.ParameterRow.Name}: {(extParRow.BaseOff ? DefPar.Value.OFF : DefPar.Value.ON)}"; if (extParRow.ParameterRow.Private == DefPar.Value.YES) { description += " (private)"; } content.Add(description); } if (content.Any()) { extensionContent.Add(extId, content); } } }
private static void AssessExtensionInfo(CountryConfigFacade ccf, DataConfigFacade dcf, string extensionId, string offOn, ref Dictionary <string, List <string> > switchInfo) { Dictionary <string, List <string> > dataSwitches = new Dictionary <string, List <string> >(); foreach (DataConfig.PolicySwitchRow polSwitch in from e in dcf.GetDataConfig().PolicySwitch where e.SwitchablePolicyID == extensionId select e) { if (polSwitch.Value != offOn) { continue; } if (!dataSwitches.ContainsKey(polSwitch.DataBaseID)) { dataSwitches.Add(polSwitch.DataBaseID, new List <string>()); } dataSwitches[polSwitch.DataBaseID].Add(polSwitch.SystemID); } foreach (var dataSwitch in dataSwitches) { DataConfig.DataBaseRow dataRow = dcf.GetDataBaseRow(dataSwitch.Key); if (dataRow == null) { continue; } string sumDataSwitches = dataRow.Name + ":"; foreach (string sysId in dataSwitch.Value) { CountryConfig.SystemRow sysRow = ccf.GetSystemRowByID(sysId); if (sysRow == null) { continue; } sumDataSwitches += sysRow.Name + ","; } if (!switchInfo.ContainsKey(extensionId)) { switchInfo.Add(extensionId, new List <string>()); } switchInfo[extensionId].Add(RVItem_Base.TrimEnd(sumDataSwitches)); } }
internal static List <SystemAndData> AssessData(List <CountryConfig.SystemRow> systems, string country) { List <SystemAndData> systemsAndData = new List <SystemAndData>(); DataConfigFacade dcf = CountryAdministrator.GetDataConfigFacade(country); foreach (CountryConfig.SystemRow sys in systems) { SystemAndData sad = new SystemAndData(sys); foreach (DataConfig.DBSystemConfigRow dbs in dcf.GetDBSystemConfigRowsBySystem(sys.Name)) { if (dbs.DataBaseRow.Private == DefPar.Value.YES) { continue; // do not take-up private data into this structure !!! } sad.allData.Add(dbs); if (dbs.BestMatch == DefPar.Value.YES) { sad.bestMatches.Add(dbs); } } systemsAndData.Add(sad); } return(systemsAndData); }
private void EM3_WriteLog() { List <RunLogger.RunInfo> runInfoList = new List <RunLogger.RunInfo>(); foreach (Run run in _runs) { // some info needs to be looked up in country-files string country = run._contentConfig[TAGS.EM2CONFIG_COUNTRY_FILE]; if (country.ToLower().EndsWith(".xml")) { country = country.Substring(0, country.Length - 4); } CountryConfigFacade ccf = CountryAdministrator.GetCountryConfigFacade(country); DataConfigFacade dcf = CountryAdministrator.GetDataConfigFacade(country); string sysID = (from e in run._contentConfig where e.Key.StartsWith(TAGS.EM2CONFIG_SYSTEM_ID) select e.Value).FirstOrDefault(); // SYSTEM_ID is followed by a GUID string dataID = run._contentConfig[TAGS.EM2CONFIG_DATASET_ID]; if (!EM_AppContext.Instance._runExeViaLib && run._process != null) { run.em3RunInfo.duration = new RunLogger.Duration(run._process.StartTime, run._process.ExitTime); run.em3RunInfo.finishStatus = run._processStatus == Run._processStatus_Finished ? RunLogger.RunInfo.FINISH_STATUS.finished : RunLogger.RunInfo.FINISH_STATUS.aborted; } run.em3RunInfo.systemName = ccf.GetSystemRowByID(sysID).Name; run.em3RunInfo.ExtractAddonSystemNames(run._contentConfig, TAGS.EM2CONFIG_ADDON); run.em3RunInfo.databaseName = dcf.GetDataBaseRow(dataID).Name; run.em3RunInfo.currency = run._contentConfig.ContainsKey(TAGS.EM2CONFIG_EXCHANGE_RATE_DATE) ? DefPar.Value.EURO : ccf.GetSystemRowByID(sysID).CurrencyOutput; // config contains entry EXCHANGE_RATE_DATE only if "All Output in €" is checked run.em3RunInfo.exchangeRate = GetExchangeRate(run, country, ccf.GetSystemRowByID(sysID).Name); run.em3RunInfo.ExtractExtensionSwitches(run._contentConfig, TAGS.EM2CONFIG_POLICY_SWITCH); string runOutputPath = run._contentConfig.GetOrEmpty(TAGS.EM2CONFIG_OUTPUTPATH); if (!string.IsNullOrEmpty(runOutputPath) && !EMPath.IsSamePath(runOutputPath, _outputPath)) { run.em3RunInfo.nonDefaultOutputPath = runOutputPath; } runInfoList.Add(run.em3RunInfo); } new RunLogger(EM_AppContext.Instance.GetProjectName(), runInfoList).TxtWriteEMLog(_outputPath); string GetExchangeRate(Run run, string country, string sysName) { ExchangeRatesConfigFacade excf = EM_AppContext.Instance.GetExchangeRatesConfigFacade(false); if (excf == null) { return(Dialogs.ConfigureSystemsForm.DEFAULT_EXCHANGE_RATE); } foreach (ExchangeRatesConfig.ExchangeRatesRow exRate in excf.GetExchangeRates(country)) { if (!exRate.ValidFor.ToLower().Trim().EndsWith(sysName.ToLower()) && !exRate.ValidFor.ToLower().Contains(sysName.ToLower() + ",")) { continue; } string date = run._contentConfig.ContainsKey(TAGS.EM2CONFIG_EXCHANGE_RATE_DATE) && run._contentConfig[TAGS.EM2CONFIG_EXCHANGE_RATE_DATE].ToLower() != "default" ? run._contentConfig[TAGS.EM2CONFIG_EXCHANGE_RATE_DATE].ToLower() : exRate.Default.ToLower(); double value = 1.0; if (date.StartsWith("june")) { value = exRate.June30; } else if (date.StartsWith("year")) { value = exRate.YearAverage; } else if (date.StartsWith("first")) { value = exRate.FirstSemester; } else if (date.StartsWith("second")) { value = exRate.SecondSemester; } return(value.ToString()); } return(Dialogs.ConfigureSystemsForm.DEFAULT_EXCHANGE_RATE); } }
internal static List <DataConfig.ExtensionRow> GetLocalExtensions(DataConfigFacade dataConfigFacade) { return((from e in dataConfigFacade.GetDataConfig().Extension select e).ToList()); }
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(); }
void FillDatasetTable(List <DataConfigFacade> dataConfigFacades, List <string> countryShortNames) { dgvDatasets.Rows.Clear(); for (int i = dgvDatasets.Columns.Count - 1; i >= 0; --i) { if (dgvDatasets.Columns[i].Name.StartsWith(_colDataYearPrefix)) { dgvDatasets.Columns.RemoveAt(i); //delete all but the fix columns (those displaying data-properties like collection year, private, ...) } } List <string> dataYears = new List <string>(); //loop over countries for (int index = 0; index < dataConfigFacades.Count; ++index) { DataConfigFacade dataConfigFacade = dataConfigFacades.ElementAt(index); //loop over dataset of the country bool firstDatasetOfCountry = true; foreach (DataConfig.DataBaseRow dataset in dataConfigFacade.GetDataBaseRows()) { //if the dataset is a "standard dataset", i.e. called cc_yyyy_xx, extract the year of the name string datasetName = dataset.Name.ToLower().EndsWith(".txt") ? dataset.Name.Substring(0, dataset.Name.Length - 4) : dataset.Name; string dataYear = string.Empty; if (datasetName.Length >= 8 && datasetName.Substring(2, 1) == "_" && datasetName.Substring(7, 1) == "_" && EM_Helpers.IsNonNegInteger(datasetName.Substring(3, 4))) { dataYear = datasetName.Substring(3, 4); } else if (datasetName.ToLower().Contains("hypo")) //take respect of hypo-data ... { dataYear = "hypo"; } else if (datasetName.ToLower().Contains("training")) //... and training data (which also exist for most countries) { dataYear = "training"; } else { dataYear = _colHeadingNonStandard; //probably only SL_demo_vi } //add an entry for the dataset year, if not already existent if (!dataYears.Contains(dataYear)) { dataYears.Add(dataYear); } //generate a row for each dataset and equip the row's tag with information (data-year and data-properties) for the cell-filling below int rowIndex = dgvDatasets.Rows.Add(); dgvDatasets.Rows[rowIndex].Tag = new KeyValuePair <string, DataConfig.DataBaseRow>(dataYear, dataset); //put name of country in row header if first dataset for this country if (firstDatasetOfCountry && index < countryShortNames.Count) { dgvDatasets.Rows[rowIndex].HeaderCell.Value = countryShortNames.ElementAt(index); firstDatasetOfCountry = false; } } } //sort the list of years (to get 2001, 2002, 2003, etc. instead of 2001, 2003, 2002, etc.) and generate the columns dataYears.Sort(); dataYears.Reverse(); foreach (string dataYear in dataYears) { DataGridViewTextBoxColumn column = new DataGridViewTextBoxColumn(); column.Name = _colDataYearPrefix + dataYear; column.HeaderCell.Value = dataYear; dgvDatasets.Columns.Insert(0, column); //insert before the fix columns (collection year, private, etc.) } //fill the table foreach (DataGridViewRow row in dgvDatasets.Rows) { KeyValuePair <string, DataConfig.DataBaseRow> rowTag = (KeyValuePair <string, DataConfig.DataBaseRow>)(row.Tag); DataConfig.DataBaseRow dataset = rowTag.Value; string dataYear = rowTag.Key; row.Cells[colYearCollection.Name].Value = dataset.YearCollection; row.Cells[colYearIncome.Name].Value = dataset.YearInc; row.Cells[colPrivate.Name].Value = dataset.Private; row.Cells[_colDataYearPrefix + dataYear].Value = dataset.Name; } }
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 CheckPrivateComponents_BackgroundEventHandler(object sender, System.ComponentModel.DoWorkEventArgs e) { //assess which datasets, systems and policies are private (as a background process of the progress indicator) 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 try { List <Country> countries = CountryAdministrator.GetCountries(); _privateComponents = string.Empty; 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 are private List <CountryConfig.SystemRow> privateSystems = new List <CountryConfig.SystemRow>(); foreach (CountryConfig.SystemRow system in countryConfigFacade.GetSystemRows()) { if (backgroundWorker.CancellationPending) { e.Cancel = true; return; } //user pressed Cancel button: see above if (system.Private.ToLower() == DefPar.Value.YES.ToLower()) { privateSystems.Add(system); } } //assess which policies are private List <CountryConfig.PolicyRow> privatePolicies = new List <CountryConfig.PolicyRow>(); List <CountryConfig.FunctionRow> privateFunctions = new List <CountryConfig.FunctionRow>(); List <CountryConfig.ParameterRow> privateParameters = new List <CountryConfig.ParameterRow>(); if (countryConfigFacade.GetSystemRows().Count > privateSystems.Count) {//only necessary to do for first system, as policies can only be marked private for all systems, but check if not all systems are private foreach (CountryConfig.PolicyRow policy in countryConfigFacade.GetSystemRows()[0].GetPolicyRows()) { if (backgroundWorker.CancellationPending) { e.Cancel = true; return; } //user pressed Cancel button: see above if (policy.Private == DefPar.Value.YES) { privatePolicies.Add(policy); } else { foreach (CountryConfig.FunctionRow function in policy.GetFunctionRows()) { if (function.Private == DefPar.Value.YES) { privateFunctions.Add(function); } else { foreach (CountryConfig.ParameterRow parameter in function.GetParameterRows()) { if (parameter.Private == DefPar.Value.YES) { privateParameters.Add(parameter); } } } } } } } //assess which datasets are private List <DataConfig.DataBaseRow> privateDataSets = new List <DataConfig.DataBaseRow>(); foreach (DataConfig.DataBaseRow dataSet in dataConfigFacade.GetDataBaseRows()) { if (backgroundWorker.CancellationPending) { e.Cancel = true; return; } //user pressed Cancel button: see above if (dataSet.Private.ToLower() == DefPar.Value.YES.ToLower()) { privateDataSets.Add(dataSet); } } backgroundWorker.ReportProgress(Convert.ToInt32((i + 1.0) / (countries.Count * 1.0) * 100.0)); //increase progress (for each country) if (privateDataSets.Count == 0 && privateSystems.Count == 0 && privatePolicies.Count == 0) { continue; } //fill _privateComponents into string which is to be output in btnCheckPrivate_Click _privateComponents += country._shortName.ToUpper() + Environment.NewLine; if (countryConfigFacade.GetCountryRow().Private == DefPar.Value.YES) { _privateComponents += "\tPRIVATE COUNTRY" + Environment.NewLine; } if (privateDataSets.Count != 0) { _privateComponents += "\tPRIVATE DATASETS" + Environment.NewLine; foreach (DataConfig.DataBaseRow dataSet in privateDataSets) { _privateComponents += "\t\t" + dataSet.Name + Environment.NewLine; } } if (privateSystems.Count != 0) { _privateComponents += "\tPRIVATE SYSTEMS" + Environment.NewLine; foreach (CountryConfig.SystemRow system in privateSystems) { _privateComponents += "\t\t" + system.Name + Environment.NewLine; } } if (privatePolicies.Count != 0) { _privateComponents += "\tPRIVATE POLICIES" + Environment.NewLine; foreach (CountryConfig.PolicyRow policy in privatePolicies) { _privateComponents += "\t\t" + policy.Name + Environment.NewLine; } } if (privateFunctions.Count != 0) { _privateComponents += "\tPRIVATE FUNCTIONS" + Environment.NewLine; foreach (CountryConfig.FunctionRow function in privateFunctions) { _privateComponents += "\t\t" + function.Name + " in policy " + function.PolicyRow.Name + " (order " + function.Order + ")" + Environment.NewLine; } } if (privateParameters.Count != 0) { _privateComponents += "\tPRIVATE PARAMETERS" + Environment.NewLine; foreach (CountryConfig.ParameterRow parameter in privateParameters) { _privateComponents += "\t\t" + parameter.Name + " in function " + parameter.FunctionRow.Name + " in policy " + parameter.FunctionRow.PolicyRow.Name + " (function-order " + parameter.FunctionRow.Order + ", parameter-order " + parameter.Order + ")" + Environment.NewLine; } } _privateComponents += "_________________________________________________________" + Environment.NewLine; } foreach (Country addOn in CountryAdministrator.GetAddOns()) { CountryConfigFacade addOnConfigFacade = addOn.GetCountryConfigFacade(); if (addOnConfigFacade.GetCountryRow().Private != DefPar.Value.YES) { continue; } _privateComponents += addOn._shortName.ToUpper() + Environment.NewLine; _privateComponents += "\tPRIVATE ADD-ON" + Environment.NewLine; _privateComponents += "_________________________________________________________" + Environment.NewLine; } } catch (Exception exception) { UserInfoHandler.ShowException(exception); e.Cancel = true; //stop the process and allow progress indicator to set dialog result to Cancel } }
internal ConfigDataAction(string countryShortName, DataConfigFacade dataConfigFacade) { _countryShortName = countryShortName; _dataConfigFacade = dataConfigFacade; }
static void GetCountryInfo_BackgroundEventHandler(object sender, DoWorkEventArgs e) { BackgroundWorker backgroundWorker = sender as BackgroundWorker; if (backgroundWorker.CancellationPending) { e.Result = null; e.Cancel = true; return; } //user pressed Cancel button: stop the process and allow progress indicator to set dialog result to Cancel try { double i = 0; Dictionary <string, List <string> > cmpInfo = new Dictionary <string, List <string> >(); foreach (Country cLoc in CountryAdministrator.GetCountries()) { backgroundWorker.ReportProgress(Convert.ToInt32(i / CountryAdministrator.GetCountries().Count * 100.0)); ++i; CountryConfigFacade ccfLoc = cLoc.GetCountryConfigFacade(); if (ccfLoc == null) { continue; } DataConfigFacade dcfLoc = cLoc.GetDataConfigFacade(); if (dcfLoc == null) { continue; } string cmpCountryFolder = e.Argument.ToString() + cLoc._shortName; if (!Directory.Exists(cmpCountryFolder)) { continue; } Country cCmp = new Country(); cCmp._shortName = cLoc._shortName; CountryConfigFacade ccfCmp = cCmp.GetCountryConfigFacade(true, cmpCountryFolder); if (ccfCmp == null) { continue; } DataConfigFacade dcfCmp = cCmp.GetDataConfigFacade(true, cmpCountryFolder); if (dcfCmp == null) { continue; } string addData = string.Empty, addSys = string.Empty, addPol = string.Empty, delData = string.Empty, delSys = string.Empty, delPol = string.Empty; List <string> cmpData = new List <string>(), cmpSys = new List <string>(), cmpPol = new List <string>(); foreach (DataConfig.DataBaseRow d in dcfCmp.GetDataBaseRows()) { cmpData.Add(d.Name.EndsWith(".txt") ? d.Name.ToLower() : (d.Name + ".txt").ToLower()); } foreach (CountryConfig.SystemRow s in ccfCmp.GetSystemRows()) { cmpSys.Add(s.Name.ToLower()); } if (cmpSys.Count > 0) { foreach (CountryConfig.PolicyRow p in ccfCmp.GetSystemRows().First().GetPolicyRows()) { if (!p.Name.ToLower().StartsWith(UpratingIndices.UpratingIndicesForm._policyUprateFactors_Name)) { cmpPol.Add(p.Name.ToLower()); } } } foreach (DataConfig.DataBaseRow d in dcfLoc.GetDataBaseRows()) { string dataName = d.Name.EndsWith(".txt") ? d.Name.ToLower() : (d.Name + ".txt").ToLower(); if (cmpData.Contains(dataName)) { cmpData.Remove(dataName); } else { addData += dataName + ", "; } } foreach (string d in cmpData) { if (d != string.Empty) { delData += d + ", "; } } foreach (CountryConfig.SystemRow s in ccfLoc.GetSystemRows()) { if (cmpSys.Contains(s.Name.ToLower())) { cmpSys.Remove(s.Name.ToLower()); } else { addSys += s.Name.ToLower() + ", "; } } foreach (string s in cmpSys) { if (s != string.Empty) { delSys += s + ", "; } } if (ccfLoc.GetSystemRows().Count > 0) { foreach (CountryConfig.PolicyRow p in ccfLoc.GetSystemRows().First().GetPolicyRows()) { if (p.Name.ToLower().StartsWith(UpratingIndices.UpratingIndicesForm._policyUprateFactors_Name)) { continue; } if (cmpPol.Contains(p.Name.ToLower())) { cmpPol.Remove(p.Name.ToLower()); } else { addPol += p.Name.ToLower() + ", "; } } } foreach (string p in cmpPol) { if (p != string.Empty) { delPol += p + ", "; } } char[] t = new char[] { ',', ' ' }; cmpInfo.Add(cLoc._shortName, new List <string>() { addData.TrimEnd(t), delData.TrimEnd(t), addSys.TrimEnd(t), delSys.TrimEnd(t), addPol.TrimEnd(t), delPol.TrimEnd(t) }); } backgroundWorker.ReportProgress(100); e.Result = cmpInfo; } catch (Exception exception) { e.Result = exception.Message; backgroundWorker.ReportProgress(100); } }
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 void EM2_RunDecompCountry(string countryShortName) { string currentAction = ""; try { currentAction = "getting " + countryShortName + " config files"; DataRow row = policyDataTable.Select("Country='" + countryShortName + "'")[0]; string sn1 = showFull ? row["System1"].ToString() : countryShortName + "_" + comboBox1.Text; string sn2 = showFull ? row["System2"].ToString() : countryShortName + "_" + comboBox2.Text; CountryConfig.SystemRow sr1 = CountryAdministrator.GetCountryConfigFacade(countryShortName).GetSystemRowByName(sn1); CountryConfig.SystemRow sr2 = CountryAdministrator.GetCountryConfigFacade(countryShortName).GetSystemRowByName(sn2); // make a copy of the country, to be later stored in the temp-folder currentAction = "copying " + countryShortName + " for decomposition"; Country copiedCountry = CountryAdministrator.GetCopyOfCountry(countryShortName); CountryConfigFacade ccf = copiedCountry.GetCountryConfigFacade(); DataConfigFacade _dataConfigFacade = copiedCountry.GetDataConfigFacade(); DataConfig.DataBaseRow dbr1 = null; DataConfig.DataBaseRow dbr2 = null; foreach (DataConfig.DataBaseRow dataSet in _dataConfigFacade.GetDataBaseRows()) { if (dataSet.Name == row["Data1"].ToString()) { dbr1 = dataSet; } if (dataSet.Name == row["Data2"].ToString()) { dbr2 = dataSet; } } // then create all required systems, depending on decomposition and Alpha selection currentAction = "getting " + countryShortName + "'s uprate factors"; Dictionary <string, string> upratingFactors1 = GetUpratingFactors(sr1, dbr1, countryShortName); Dictionary <string, string> upratingFactors2 = GetUpratingFactors(sr2, dbr2, countryShortName); double alpha = 0; List <DecompSystem> allSystems = new List <DecompSystem>(); bool treatAsMarket = chkTreatAsMarket.Checked; // get the systems of the checked addon (if one was checked) string addon = GetCheckedAddon(); bool hasAddon = addon != string.Empty; List <AddOnSystemInfo> addonSystems = hasAddon ? AddOnInfoHelper.GetAddOnSystemInfo(addon) : null; currentAction = "creating " + countryShortName + "'s decomposed systems"; const double ALPHA_CPI = double.MinValue, ALPHA_MII = double.MaxValue; // just any numbers differnt from the alphas in alphaFIX List <double> alphas = new List <double>(); if (checkBoxAlphaCPI.Checked) { alphas.Add(ALPHA_CPI); } if (checkBoxAlphaMII.Checked) { alphas.Add(ALPHA_MII); } if (checkBoxAlphaFIX.Checked) { alphas.AddRange(alphaFIXValues); // those where gathered in GetAlphaFIX } foreach (double a in alphas) { string systemNameExt = ""; // first find Alpha, log text, system name extention etc. if (a == ALPHA_CPI) { Dictionary <string, string> rawIndices = GetRawCPIindices(sr1, countryShortName); if (!(rawIndices.ContainsKey(comboBox1.Text) || rawIndices.ContainsKey(comboBox2.Text))) { throw new Exception("The CPI raw indices ('" + FactorCPI + "') were not found for the selected years!"); } double hicp1 = EM_Helpers.SaveConvertToDouble(rawIndices[comboBox1.Text]); double hicp2 = EM_Helpers.SaveConvertToDouble(rawIndices[comboBox2.Text]); alpha = hicp2 / hicp1; AddToLog($"{RunLogger.PetInfo.LOGTAG_ALPHA_CPI} ({countryShortName})", $"{alpha} ({hicp2}/{hicp1})", LOGMODE.EM2); systemNameExt = "_cpi"; alphaValues.Add(countryShortName + "_cpi", alpha); } else if (a == ALPHA_MII) { double mii1 = getAlphaFromBaselineFile(sr1.Name); double mii2 = getAlphaFromBaselineFile(sr2.Name); alpha = mii2 / mii1; AddToLog($"{RunLogger.PetInfo.LOGTAG_ALPHA_MII} ({countryShortName})", $"{alpha} ({mii2}/{mii1})", LOGMODE.EM2); systemNameExt = "_mii"; alphaValues.Add(countryShortName + "_mii", alpha); } else { alpha = a; systemNameExt = "_a" + GetAlphaFIXId(a); alphaValues.Add(countryShortName + "_fix" + GetAlphaFIXId(a), alpha); } // Then actually create the required systems if (checkRadioData1.Checked || checkRadioDataBoth.Checked) { DecompSystem ds1 = new DecompSystem(); ds1.sr = CountryConfigFacade.CopySystemRow(sr2.Name + "_on_" + dbr1.Name + systemNameExt, ccf.GetSystemRowByID(sr2.ID)); copiedCountry.GetDataConfigFacade().CopyDBSystemConfigRows(ccf.GetSystemRowByID(sr2.ID), ds1.sr); ds1.dbr = dbr1; if (hasAddon) { MergeAddOn(addonSystems, sr2.Name, ds1, copiedCountry); } EM2_FixUprating(ds1.sr, upratingFactors1, upratingFactors2, countryShortName, alpha, 1, treatAsMarket); allSystems.Add(ds1); if (checkRadioMonetary.Checked) { DecompSystem ds2 = new DecompSystem(); ds2.sr = CountryConfigFacade.CopySystemRow(sr2.Name + "ind_on_" + dbr1.Name + systemNameExt, ccf.GetSystemRowByID(sr2.ID)); copiedCountry.GetDataConfigFacade().CopyDBSystemConfigRows(ccf.GetSystemRowByID(sr2.ID), ds2.sr); ds2.dbr = dbr1; if (hasAddon) { MergeAddOn(addonSystems, sr2.Name, ds2, copiedCountry); } EM2_FixUprating(ds2.sr, upratingFactors1, upratingFactors2, countryShortName, alpha, 2, treatAsMarket); allSystems.Add(ds2); DecompSystem ds3 = new DecompSystem(); ds3.sr = CountryConfigFacade.CopySystemRow(sr1.Name + "ind" + systemNameExt, ccf.GetSystemRowByID(sr1.ID)); copiedCountry.GetDataConfigFacade().CopyDBSystemConfigRows(ccf.GetSystemRowByID(sr1.ID), ds3.sr); ds3.dbr = dbr1; if (hasAddon) { MergeAddOn(addonSystems, sr1.Name, ds3, copiedCountry); } EM2_FixUprating(ds3.sr, upratingFactors1, upratingFactors2, countryShortName, alpha, 3, treatAsMarket); allSystems.Add(ds3); } } if (checkRadioData2.Checked || checkRadioDataBoth.Checked) { DecompSystem ds1 = new DecompSystem(); ds1.sr = CountryConfigFacade.CopySystemRow(sr1.Name + "_on_" + dbr2.Name + systemNameExt, ccf.GetSystemRowByID(sr1.ID)); copiedCountry.GetDataConfigFacade().CopyDBSystemConfigRows(ccf.GetSystemRowByID(sr1.ID), ds1.sr); ds1.dbr = dbr2; if (hasAddon) { MergeAddOn(addonSystems, sr1.Name, ds1, copiedCountry); } EM2_FixUprating(ds1.sr, upratingFactors2, upratingFactors1, countryShortName, 1 / alpha, 1, treatAsMarket); allSystems.Add(ds1); if (checkRadioMonetary.Checked) { DecompSystem ds2 = new DecompSystem(); ds2.sr = CountryConfigFacade.CopySystemRow(sr1.Name + "ind_on_" + dbr2.Name + systemNameExt, ccf.GetSystemRowByID(sr2.ID)); copiedCountry.GetDataConfigFacade().CopyDBSystemConfigRows(ccf.GetSystemRowByID(sr1.ID), ds2.sr); ds2.dbr = dbr2; if (hasAddon) { MergeAddOn(addonSystems, sr1.Name, ds2, copiedCountry); } EM2_FixUprating(ds2.sr, upratingFactors2, upratingFactors1, countryShortName, 1 / alpha, 2, treatAsMarket); allSystems.Add(ds2); DecompSystem ds3 = new DecompSystem(); ds3.sr = CountryConfigFacade.CopySystemRow(sr2.Name + "ind" + systemNameExt, ccf.GetSystemRowByID(sr2.ID)); copiedCountry.GetDataConfigFacade().CopyDBSystemConfigRows(ccf.GetSystemRowByID(sr2.ID), ds3.sr); ds3.dbr = dbr1; if (hasAddon) { MergeAddOn(addonSystems, sr2.Name, ds3, copiedCountry); } EM2_FixUprating(ds3.sr, upratingFactors2, upratingFactors1, countryShortName, 1 / alpha, 3, treatAsMarket); allSystems.Add(ds3); } } } currentAction = "writting decomposed " + countryShortName + " in the temp folder"; copiedCountry.WriteXML(EMPath.Folder_Temp(EM_AppContext.FolderEuromodFiles)); currentAction = "running " + countryShortName + "'s decomposed systems"; foreach (DecompSystem ds in allSystems) { workers.Add(RunSystem(countryShortName, ds.sr.Name, dbr2.Name, EM2_CreateConfig(countryShortName, textBoxOutputPath.Text, ds.dbr, ds.sr))); updateInfoLabel(); } } catch (Exception ex) { em3_petInfo.AddSystemIndependentError($"There was a problem with {currentAction}: {ex.Message}"); } }
private void EM2_RunBaselineSystems() { // get the systems of the checked addon (if one was checked) string addon = GetCheckedAddon(); bool hasAddon = addon != string.Empty; List <AddOnSystemInfo> addonSystems = hasAddon ? AddOnInfoHelper.GetAddOnSystemInfo(addon) : null; foreach (DataRow row in policyDataTable.Rows) { if (row.Field <bool>("Check")) { string countryShortName = row["Country"].ToString(); Country copiedCountry = CountryAdministrator.GetCopyOfCountry(countryShortName); CountryConfigFacade ccf = copiedCountry.GetCountryConfigFacade(); DataConfigFacade _dataConfigFacade = copiedCountry.GetDataConfigFacade(); DataConfig.DataBaseRow dbr1 = null; DataConfig.DataBaseRow dbr2 = null; foreach (DataConfig.DataBaseRow dataSet in _dataConfigFacade.GetDataBaseRows()) { if (dataSet.Name == row["Data1"].ToString()) { dbr1 = dataSet; } if (dataSet.Name == row["Data2"].ToString()) { dbr2 = dataSet; } } string sn1 = showFull ? row["System1"].ToString() : countryShortName + "_" + comboBox1.Text; string sn2 = showFull ? row["System2"].ToString() : countryShortName + "_" + comboBox2.Text; CountryConfig.SystemRow sr1 = ccf.GetSystemRowByName(sn1); CountryConfig.SystemRow sr2 = ccf.GetSystemRowByName(sn2); if (sr1 == null) { throw new Exception("System '" + sn1 + "' does not exist!"); } if (sr2 == null) { throw new Exception("System '" + sn2 + "' does not exist!"); } if (hasAddon) { if (checkRadioData1.Checked || checkRadioDataBoth.Checked) { MergeAddOn(addonSystems, copiedCountry, ref sr1); } if (checkRadioData2.Checked || checkRadioDataBoth.Checked) { MergeAddOn(addonSystems, copiedCountry, ref sr2); } } copiedCountry.WriteXML(EMPath.Folder_Temp(EM_AppContext.FolderEuromodFiles)); if (checkBoxAlphaMII.Checked) { SystemBackgroundWorker w1, w2; w1 = RunSystem(countryShortName, sr1.Name, dbr1.Name, EM2_CreateConfig(countryShortName, textBoxOutputPath.Text, dbr1, sr1, true)); w2 = RunSystem(countryShortName, sr2.Name, dbr2.Name, EM2_CreateConfig(countryShortName, textBoxOutputPath.Text, dbr2, sr2, true)); w1.isBaseline = true; w2.isBaseline = true; w1.secondBaseline = w2; w2.secondBaseline = w1; workers.Add(w1); workers.Add(w2); updateInfoLabel(); } else { SystemBackgroundWorker w1 = null, w2 = null; if (checkRadioData1.Checked || checkRadioDataBoth.Checked) { w1 = RunSystem(countryShortName, sr1.Name, dbr1.Name, EM2_CreateConfig(countryShortName, textBoxOutputPath.Text, dbr1, sr1, hasAddon)); w1.isBaseline = true; } if (checkRadioData2.Checked || checkRadioDataBoth.Checked) { w2 = RunSystem(countryShortName, sr2.Name, dbr2.Name, EM2_CreateConfig(countryShortName, textBoxOutputPath.Text, dbr2, sr2, hasAddon)); w2.isBaseline = true; } if (hasAddon && checkRadioDataBoth.Checked) { w1.secondBaseline = w2; w2.secondBaseline = w1; } if (checkRadioData1.Checked || checkRadioDataBoth.Checked) { workers.Add(w1); } if (checkRadioData2.Checked || checkRadioDataBoth.Checked) { workers.Add(w2); } updateInfoLabel(); } } } }
internal void SetDataConfigFacade(DataConfigFacade dataConfigFacade) { _dataConfigFacade = dataConfigFacade; }
internal RenameSystemAction(TreeListColumn senderNode, CountryConfigFacade countryConfigFacade, DataConfigFacade dataConfigFacade) { _senderColumn = senderNode; _dataConfigFacade = dataConfigFacade; _countryConfigFacade = countryConfigFacade; }
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; }
internal DeleteSystemAction(TreeListColumn senderNode, DataConfigFacade dataConfigFacade, bool showRequest = true) { _senderColumn = senderNode; _dataConfigFacade = dataConfigFacade; _showRequest = showRequest; }