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); }
void cmbDatasets_SelectedIndexChanged(object sender, EventArgs e) { if (cmbDatasets.SelectedIndex == -1) { return; //no dataset selected } dgvFactors.Rows.Clear(); //look up which dataset was selected to assess the data's income year, and put it into text-edit foreach (DataConfig.DataBaseRow dataset in _dataConfigFacade.GetDataBaseRows()) { if (cmbDatasets.Text == dataset.Name) { txtIncomeYear.Text = dataset.YearInc; break; } } //check if the 'Raw Indices' table contains the data-year bool noIncomeYear = false; if (!GetExistingYears().Contains(txtIncomeYear.Text)) { //UserInfoHandler.ShowError("Year " + txtIncomeYear.Text + " is not recorded in Raw Indices table. Factors cannot be calculated."); UserInfoHandler.ShowInfo("Year " + txtIncomeYear.Text + " is not recorded in Raw Indices table. Factors are set to " + _factorValueInvalid + "."); noIncomeYear = true; //return; } //fill the 'Factors ...' table for the selected dataset foreach (string indexName in GetIndicesNames()) //loop over all indices { //add one row to the 'Factors ...' table for each index DataGridViewRow factorRow = dgvFactors.Rows[dgvFactors.Rows.Add()]; //put the name of the index (e.g. cpi) in the first column factorRow.Cells[colIndexName.Name].Value = indexName; foreach (DataGridViewColumn systemColumn in dgvFactors.Columns) //loop over the country's systems { if (systemColumn == colIndexName) { continue; //name-column is already filled } if (noIncomeYear) { factorRow.Cells[systemColumn.Name].Value = _factorValueInvalid; } else { CountryConfig.SystemRow systemRow = systemColumn.Tag as CountryConfig.SystemRow; string systemYear = systemRow.Year != null && systemRow.Year != string.Empty ? systemRow.Year : EM_Helpers.ExtractSystemYear((systemColumn.Tag as CountryConfig.SystemRow).Name); // in the display, round the number to 4 digits - also make sure that you display dot regardless of the windows decimal separator. CalculateFactor takes care of all this... factorRow.Cells[systemColumn.Name].Value = CalculateFactor(indexName, txtIncomeYear.Text, systemYear); } } } }
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 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 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); } }
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 } }
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 override void PerformAction() { ConfigureDataForm configureDataForm = new ConfigureDataForm(_countryShortName); //firstly provide dialog with the information it needs to display (i.e. info on datasets and available system-dataset combinations) ... foreach (CountryConfig.SystemRow systemRow in CountryAdministrator.GetCountryConfigFacade(_countryShortName).GetSystemRows().OrderBy(s => long.Parse(s.Order))) { configureDataForm._systemInfo.Add(systemRow.ID, systemRow.Name); } foreach (DataConfig.DataBaseRow dataBaseRow in _dataConfigFacade.GetDataBaseRows()) { ConfigureDataForm.RowTag rowTag = new ConfigureDataForm.RowTag(); rowTag.ID = dataBaseRow.ID; rowTag.Name = dataBaseRow.Name; rowTag.Comment = dataBaseRow.Comment; rowTag.YearCollection = dataBaseRow.YearCollection; rowTag.YearInc = dataBaseRow.YearInc; rowTag.Currency = dataBaseRow.Currency; rowTag.FilePath = dataBaseRow.FilePath; rowTag.DecimalSign = dataBaseRow.DecimalSign; rowTag.Private = dataBaseRow.Private; rowTag.UseCommonDefault = dataBaseRow.UseCommonDefault; rowTag.ReadXVariables = string.IsNullOrEmpty(dataBaseRow.ReadXVariables) ? DefPar.Value.NO : dataBaseRow.ReadXVariables; rowTag.IsCommonDefaultNull = dataBaseRow.IsUseCommonDefaultNull(); rowTag.ListStringOutVar = dataBaseRow.ListStringOutVar; rowTag.IndirectTaxTableYear = dataBaseRow.IndirectTaxTableYear; foreach (DataConfig.DBSystemConfigRow dbSystemConfigRow in _dataConfigFacade.GetDBSystemConfigRows(dataBaseRow.ID)) { ConfigureDataForm.CellTag cellTag = new ConfigureDataForm.CellTag(); cellTag.SystemID = dbSystemConfigRow.SystemID; cellTag.UseDefault = dbSystemConfigRow.UseDefault; cellTag.UseCommonDefault = dbSystemConfigRow.UseCommonDefault; cellTag.Uprate = dbSystemConfigRow.Uprate; cellTag.BestMatch = dbSystemConfigRow.BestMatch; rowTag.CellTags.Add(dbSystemConfigRow.SystemID, cellTag); } configureDataForm._dataBaseInfo.Add(rowTag); } //... then show the dialog ... if (configureDataForm.ShowDialog() == System.Windows.Forms.DialogResult.Cancel) { _actionIsCanceled = true; return; } //... finally store the modified information List <DataConfig.DataBaseRow> dataBaseRowsToDelete = new List <DataConfig.DataBaseRow>(); List <DataConfig.DBSystemConfigRow> dbSystemConfigRowsToDelete = new List <DataConfig.DBSystemConfigRow>(); foreach (ConfigureDataForm.RowTag dataBaseInfo in configureDataForm._dataBaseInfo) { DataConfig.DataBaseRow dataBaseRow = _dataConfigFacade.GetDataBaseRow(dataBaseInfo.ID); if (dataBaseInfo.ChangeState == ConfigureDataForm.ChangeStates.removed) { dataBaseRowsToDelete.Add(dataBaseRow); continue; } if (dataBaseInfo.ChangeState == ConfigureDataForm.ChangeStates.added) { dataBaseRow = _dataConfigFacade.AddDataBaseRow(dataBaseInfo.Name, dataBaseInfo.FilePath); _datasetAdded = true; } if (dataBaseInfo.ChangeState != ConfigureDataForm.ChangeStates.unchanged) { dataBaseRow.ID = dataBaseInfo.ID; dataBaseRow.Name = dataBaseInfo.Name; dataBaseRow.Comment = dataBaseInfo.Comment; dataBaseRow.YearCollection = dataBaseInfo.YearCollection; dataBaseRow.YearInc = dataBaseInfo.YearInc; dataBaseRow.Currency = dataBaseInfo.Currency; dataBaseRow.FilePath = dataBaseInfo.FilePath; dataBaseRow.DecimalSign = dataBaseInfo.DecimalSign; dataBaseRow.Private = dataBaseInfo.Private; dataBaseRow.UseCommonDefault = dataBaseInfo.UseCommonDefault; dataBaseRow.ReadXVariables = dataBaseInfo.ReadXVariables; dataBaseRow.ListStringOutVar = dataBaseInfo.ListStringOutVar; dataBaseRow.IndirectTaxTableYear = dataBaseInfo.IndirectTaxTableYear; } foreach (ConfigureDataForm.CellTag dbSystemCombination in dataBaseInfo.CellTags.Values) { DataConfig.DBSystemConfigRow dbSystemConfigRow = _dataConfigFacade.GetDBSystemConfigRow(dataBaseInfo.ID, dbSystemCombination.SystemID); if (dbSystemCombination.ChangeState == ConfigureDataForm.ChangeStates.removed) { dbSystemConfigRowsToDelete.Add(dbSystemConfigRow); continue; } if (dbSystemCombination.ChangeState == ConfigureDataForm.ChangeStates.added) { dbSystemConfigRow = _dataConfigFacade.AddDBSystemConfigRow(dbSystemCombination.SystemID, CountryAdministrator.GetCountryConfigFacade(_countryShortName).GetSystemRowByID(dbSystemCombination.SystemID).Name, dataBaseRow); } if (dbSystemCombination.ChangeState != ConfigureDataForm.ChangeStates.unchanged) { dbSystemConfigRow.SystemID = dbSystemCombination.SystemID; dbSystemConfigRow.UseDefault = dbSystemCombination.UseDefault; dbSystemConfigRow.UseCommonDefault = dbSystemCombination.UseCommonDefault; dbSystemConfigRow.Uprate = dbSystemCombination.Uprate; dbSystemConfigRow.BestMatch = dbSystemCombination.BestMatch; } } } foreach (DataConfig.DataBaseRow dataBaseRowToDelete in dataBaseRowsToDelete) { dataBaseRowToDelete.Delete(); } foreach (DataConfig.DBSystemConfigRow dbSystemConfigRowToDelete in dbSystemConfigRowsToDelete) { dbSystemConfigRowToDelete.Delete(); } }