internal CountryConfig.SystemRow PerformAddOnGeneration(string newSystemName, string countryShortName, string addOnShortName,
string baseSystemName, string addOnSystemName)
{
//get the county's and add-on's data
CountryConfigFacade baseCountryConfigFacade = CountryAdministrator.GetCountryConfigFacade(countryShortName);
_addOnCountryConfigFacade = CountryAdministrator.GetCountryConfigFacade(addOnShortName);
//get the base-system and the add-on-system
CountryConfig.SystemRow baseSystemRow = baseCountryConfigFacade.GetSystemRowByName(baseSystemName);
_addOnSystemRow = _addOnCountryConfigFacade.GetSystemRowByName(addOnSystemName);
//add-on-system will be stored in an CountryConfig generated for the purpose of storing it
_mergeCountryConfigFacade = new CountryConfigFacade(countryShortName);
//generate a copy of the base-system, by keeping all ids except the system id identically: otherwise the id-references (e.g. in ChangeParam, AddOn_Par, etc. would not work)
_mergeSystemRow = CountryConfigFacade.CopySystemRowToAnotherCountry(baseSystemRow, _addOnSystemRow.Name,
_mergeCountryConfigFacade.GetCountryConfig(), true);
_mergeSystemRow.Name = newSystemName;
//add policies following instructions in AddOn_Pol-functions
AddPolicies();
//add functions following instructions in AddOn_Func-functions
AddFunctions();
//add parameters following instructions in AddOn_Par-functions
AddParameters();
//replace e.g. yse_uk_#2 respectively yse_uk_#2.4 by the actual id of this function respectively parameter
ReplaceSymbolicIDsInChangeParam();
return(_errorMessages == string.Empty ? _mergeSystemRow : null);
}
private void ChangeNameInExchangeRatesConfig(CountryConfig.SystemRow systemRow, string oldSystemName)
{
ExchangeRatesConfigFacade excf = EM_AppContext.Instance.GetExchangeRatesConfigFacade(false); if (excf == null)
{
return;
}
bool anyChange = false;
foreach (ExchangeRatesConfig.ExchangeRatesRow exchangeRate in
from er in excf.GetExchangeRates() where er.Country.ToLower() == systemRow.CountryRow.ShortName.ToLower() &&
ExchangeRate.ValidForToList(er.ValidFor).Contains(oldSystemName.ToLower()) select er)
{
if (!anyChange && UserInfoHandler.GetInfo("Do you want to update the system name in the global exchange rate table?" + Environment.NewLine + Environment.NewLine +
"Note that, if no exchange rate is found for a system name, the exchange rate is assumed to be 1.", MessageBoxButtons.YesNo) == DialogResult.No)
{
return;
}
exchangeRate.ValidFor = ExchangeRate.RemoveFromValidFor(exchangeRate.ValidFor, oldSystemName);
exchangeRate.ValidFor = ExchangeRate.AddToValidFor(exchangeRate.ValidFor, systemRow.Name); anyChange = true;
}
if (anyChange)
{
excf.WriteXML();
}
}
internal override void PerformAction()
{
CountryConfig.SystemRow systemRow = (_senderColumn.Tag as SystemTreeListTag).GetSystemRow();
string newSystemName = systemRow.Name, oldSystemName = systemRow.Name, newSystemYear = systemRow.Year;
if (!SystemValidation.GetSystemNameAndYear(_dataConfigFacade != null, ref newSystemName, ref newSystemYear, _senderColumn.TreeList))
{
_actionIsCanceled = true;
return;
}
// main action: rename system
systemRow.Name = newSystemName; systemRow.Year = newSystemYear;
// rename references in database-system-connection (if 'country' isn't an add-on)
if (_dataConfigFacade != null)
{
_dataConfigFacade.RenameSystemInDBSystemConfigRows(systemRow.ID, newSystemName);
}
// rename references in conditional formatting
_countryConfigFacade.RenameSystemInConditionalFormats(oldSystemName, newSystemName);
if (_dataConfigFacade != null)
{
// rename standard-output-files (last parameter (request): ask user if she actually wants this to happen)
CopySystemAction.RenameOutputFiles(_countryConfigFacade, systemRow, oldSystemName, true);
// change name in global exchange rate file
ChangeNameInExchangeRatesConfig(systemRow, oldSystemName);
// warn about not-adaptation of AddOn_Applic-policy
OptionalWarningsManager.Show(OptionalWarningsManager._renameSystemWarning);
}
}
internal override void PerformAction()
{
CountryConfig.SystemRow systemRow = (_senderColumn.Tag as SystemTreeListTag).GetSystemRow();
if (_showRequest && Tools.UserInfoHandler.GetInfo("Are you sure you want to delete system '" + _senderColumn.Caption + "'?", MessageBoxButtons.YesNo) == DialogResult.No)
{
_actionIsCanceled = true;
return;
}
//adapt exchange-rate in global table
//note that the exchange-rate-config is not included in the undo-procedure, thus this will not be undone
ExchangeRatesConfigFacade excf = EM_AppContext.Instance.GetExchangeRatesConfigFacade(false);
if (excf != null)
{
excf.RemoveSystems(systemRow.CountryRow.ShortName, new List <string>()
{
systemRow.Name
});
}
if (_dataConfigFacade != null) //if 'country' is an add-on it does not have a dataConfig
{
_dataConfigFacade.DeleteDBSystemConfigRows(systemRow.ID); //first delete all references of the system with datasets
}
CountryConfigFacade.DeleteSystemRow(systemRow); //then delete the system itself
}
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);
}
}
}
}
void btnOK_Click(object sender, EventArgs e)
{
if (!CheckSystemYear())
{
return;
}
bool haveChanges = false;
foreach (DataGridViewRow dataGridViewRow in dgvSystems.Rows)
{
CountryConfig.SystemRow systemRow = dataGridViewRow.Tag as CountryConfig.SystemRow;
if (systemRow.CurrencyParam != dataGridViewRow.Cells[colCurrencyParameters.Name].Value.ToString())
{
systemRow.CurrencyParam = dataGridViewRow.Cells[colCurrencyParameters.Name].Value.ToString();
haveChanges = true;
}
if (systemRow.CurrencyOutput != dataGridViewRow.Cells[colCurrencyOutput.Name].Value.ToString())
{
systemRow.CurrencyOutput = dataGridViewRow.Cells[colCurrencyOutput.Name].Value.ToString();
haveChanges = true;
}
if (EM_Helpers.SaveConvertToBoolean(dataGridViewRow.Cells[colPrivate.Name].Value) == true)
{
if (systemRow.Private != DefPar.Value.YES)
{
systemRow.Private = DefPar.Value.YES;
haveChanges = true;
}
}
else
{
if (systemRow.Private != DefPar.Value.NO)
{
systemRow.Private = DefPar.Value.NO;
haveChanges = true;
}
}
if (systemRow.HeadDefInc != dataGridViewRow.Cells[colHeadDefInc.Name].Value.ToString())
{
systemRow.HeadDefInc = dataGridViewRow.Cells[colHeadDefInc.Name].Value.ToString();
haveChanges = true;
}
if (systemRow.Year != dataGridViewRow.Cells[colYear.Name].Value.ToString())
{
systemRow.Year = dataGridViewRow.Cells[colYear.Name].Value.ToString();
haveChanges = true;
}
string comment = dataGridViewRow.Cells[colComment.Name].Value == null ? string.Empty : dataGridViewRow.Cells[colComment.Name].Value.ToString();
if (systemRow.Comment != comment)
{
systemRow.Comment = comment;
haveChanges = true;
}
}
DialogResult = haveChanges == true ? DialogResult.OK : DialogResult.Cancel;
Close();
}
void FillFunctionNodeWithParameters(CountryConfig.SystemRow systemRow, CountryConfig.FunctionRow functionRow, TreeListNode functionNode, bool isFirstSystem)
{
//generate the parameters of the function
int parameterIndex = 0;
var parameterQuery = (from parameter in functionRow.GetParameterRows() select parameter).OrderBy(parameter => long.Parse(parameter.Order));
foreach (CountryConfig.ParameterRow parameterRow in parameterQuery.ToList())
{
TreeListNode parameterNode = isFirstSystem ? BuildParameterNode(functionNode, parameterRow) : functionNode.Nodes[parameterIndex++];
(parameterNode.Tag as ParameterTreeListTag).AddParameterRowOfSystem(systemRow.ID, parameterRow);
parameterNode.SetValue(systemRow.Name, parameterRow.Value);
}
}
public static string GetSystemYear(string cn, string sn)
{
CountryConfigFacade ccf = EM_UI.CountryAdministration.CountryAdministrator.GetCountryConfigFacade(cn);
if (ccf == null)
{
return("");
}
CountryConfig.SystemRow sr = ccf.GetSystemRowByName(sn);
if (sr == null)
{
return("");
}
return(sr.Year);
}
void FillPolicyNodeWithFunctions(CountryConfig.SystemRow systemRow, CountryConfig.PolicyRow policyRow, TreeListNode policyNode, bool isFirstSystem)
{
//generate the functions of the policy
int functionIndex = 0;
var functionQuery = (from function in policyRow.GetFunctionRows() select function).OrderBy(function => long.Parse(function.Order));
foreach (CountryConfig.FunctionRow functionRow in functionQuery.ToList <CountryConfig.FunctionRow>())
{
TreeListNode functionNode = isFirstSystem ? BuildFunctionNode(policyNode, functionRow) : policyNode.Nodes[functionIndex++];
(functionNode.Tag as FunctionTreeListTag).AddFunctionRowOfSystem(systemRow.ID, functionRow);
functionNode.SetValue(systemRow.Name, ExtensionAndGroupManager.GetExtensionAdaptedSwitch(functionRow));
//generate the parameters of the function
FillFunctionNodeWithParameters(systemRow, functionRow, functionNode, isFirstSystem);
}
}
internal List <string> GetSystemsNamesDistinctAndOrdered(string countryShortName)
{
CountryConfigFacade ccF = CountryAdministration.CountryAdministrator.GetCountryConfigFacade(countryShortName);
Dictionary <string, CountryConfig.SystemRow> systemRows = new Dictionary <string, CountryConfig.SystemRow>();
foreach (DataConfig.DBSystemConfigRow dbSystemConfigRow in _dataConfig.DBSystemConfig.Rows)
{
if (systemRows.ContainsKey(dbSystemConfigRow.SystemID))
{
continue;
}
CountryConfig.SystemRow systemRow = ccF.GetSystemRowByID(dbSystemConfigRow.SystemID);
systemRows.Add(systemRow.ID, systemRow);
}
return((from s in systemRows.Values orderby long.Parse(s.Order) select s.Name).ToList());
}
internal override void PerformAction()
{
CountryConfig.SystemRow systemRow = (_senderColumn == null) ? null : (_senderColumn.Tag as SystemTreeListTag).GetSystemRow();
TreeList countryTreeList = (_senderColumn != null) ? _senderColumn.TreeList : null;
string systemName = systemRow == null ? string.Empty : systemRow.Name;
string systemYear = systemRow == null ? string.Empty : systemRow.Year;
if (!SystemValidation.GetSystemNameAndYear(!_isAddOn, ref systemName, ref systemYear, countryTreeList))
{
_actionIsCanceled = true;
return;
}
CountryConfig.SystemRow newSystemRow;
if (_senderColumn == null) //add very first system
{
newSystemRow = _countryConfigFacade.AddFirstSystemRow(systemName);
}
else //add system by copying an existing system
{
CountryConfig.SystemRow toCopySystemRow = (_senderColumn.Tag as SystemTreeListTag).GetSystemRow();
//copy system itself
newSystemRow = CountryConfigFacade.CopySystemRow(systemName, toCopySystemRow);
//copy all references of the system with datasets (i.e. new system can be used with same datasets as its template)
if (!_isAddOn)
{
_dataConfigFacade.CopyDBSystemConfigRows(toCopySystemRow, newSystemRow);
}
//copy system formats
_countryConfigFacade.CopySystemFormatting(toCopySystemRow, newSystemRow);
//rename output filename of default outputs
RenameOutputFiles(_countryConfigFacade, newSystemRow, toCopySystemRow.Name);
//adapt exchange-rate in global table
//note that the exchange-rate-config is not included in the undo-procedure, thus this will not be undone
AddToExchangeRatesTable(systemName, toCopySystemRow);
ExtensionAndGroupManager.CopyExtensionAndGroupMemberships(_countryConfigFacade.GetCountryConfig(), newSystemRow.ID, toCopySystemRow.ID);
}
newSystemRow.Year = systemYear;
}
internal void CopyDBSystemConfigRows(CountryConfig.SystemRow originalSystemRow, CountryConfig.SystemRow copySystemRow)
{
foreach (DataConfig.DBSystemConfigRow originalDBSystemConfigRow in
(from dbSystemConfig in _dataConfig.DBSystemConfig
where dbSystemConfig.SystemID == originalSystemRow.ID
select dbSystemConfig).ToList())
{
DataConfig.DBSystemConfigRow copyDBSystemConfigRow = _dataConfig.DBSystemConfig.AddDBSystemConfigRow(copySystemRow.ID, copySystemRow.Name, originalDBSystemConfigRow.DataBaseRow,
originalDBSystemConfigRow.UseDefault, originalDBSystemConfigRow.UseCommonDefault, originalDBSystemConfigRow.Uprate, //parameter transferred to database-level, can be deleted once not used in any cc_DataConfig.xml anymore
originalDBSystemConfigRow.BestMatch);
foreach (DataConfig.PolicySwitchRow originalExtensionSwitchRow in originalDBSystemConfigRow.GetPolicySwitchRows())
{
_dataConfig.PolicySwitch.AddPolicySwitchRow(originalExtensionSwitchRow.SwitchablePolicyID,
copySystemRow.ID, originalExtensionSwitchRow.DataBaseID, originalExtensionSwitchRow.Value);
}
}
}
internal void InsertFunctionNode(List <CountryConfig.FunctionRow> functionRowsOfAllSystems, TreeListNode policyNode, int nodeIndex = -1)
{
TreeListNode functionNode = null;
bool isFirstSystem = true;
foreach (CountryConfig.FunctionRow functionRow in functionRowsOfAllSystems)
{
CountryConfig.SystemRow systemRow = functionRow.PolicyRow.SystemRow;
functionNode = isFirstSystem ? BuildFunctionNode(policyNode, functionRow) : policyNode.Nodes.LastNode;
(functionNode.Tag as FunctionTreeListTag).AddFunctionRowOfSystem(systemRow.ID, functionRow);
functionNode.SetValue(systemRow.Name, ExtensionAndGroupManager.GetExtensionAdaptedSwitch(functionRow));
FillFunctionNodeWithParameters(systemRow, functionRow, functionNode, isFirstSystem);
isFirstSystem = false;
}
if (nodeIndex != -1)
{
_mainForm.treeList.SetNodeIndex(functionNode, nodeIndex);
}
}
List <SystemAndBase> AssessBases(List <CountryConfig.SystemRow> systems, string country)
{
List <SystemAndBase> systemsAndBases = new List <SystemAndBase>();
CountryConfigFacade ccf = CountryAdministrator.GetCountryConfigFacade(country);
{
foreach (CountryConfig.SystemRow system in systems)
{
CountryConfig.SystemRow baseSystem = null;
foreach (CountryConfig.ConditionalFormatRow conditionalFormatRow in ccf.GetConditionalFormatRowsOfSystem(system))
{
if (conditionalFormatRow.BaseSystemName != null && conditionalFormatRow.BaseSystemName != string.Empty)
{
baseSystem = ccf.GetSystemRowByName(conditionalFormatRow.BaseSystemName); break;
}
}
systemsAndBases.Add(new SystemAndBase(system, baseSystem));
}
}
return(systemsAndBases);
}
void AddToExchangeRatesTable(string systemName, CountryConfig.SystemRow toCopySystemRow)
{
ExchangeRatesConfigFacade excf = EM_AppContext.Instance.GetExchangeRatesConfigFacade(false); if (excf == null)
{
return;
}
bool found = false;
foreach (ExchangeRatesConfig.ExchangeRatesRow exchangeRate in excf.GetExchangeRates())
{
if (exchangeRate.Country.ToLower() != toCopySystemRow.CountryRow.ShortName.ToLower() ||
!ExchangeRate.ValidForToList(exchangeRate.ValidFor).Contains(toCopySystemRow.Name.ToLower()))
{
continue;
}
exchangeRate.ValidFor = ExchangeRate.AddToValidFor(exchangeRate.ValidFor, systemName); found = true; break;
}
if (found)
{
excf.WriteXML();
}
}
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));
}
}
void FillSystemsList()
{
bool firstFill = !_systemRows.Any(); List <string> selIds = new List <string>();
try { if (!firstFill)
{
foreach (int index in lstSystems.CheckedIndices)
{
selIds.Add(_systemRows.ElementAt(index).ID);
}
}
} catch { }
lstSystems.Items.Clear();
_systemRows.Clear();
foreach (TreeListColumn systemColumn in _mainForm.GetTreeListBuilder().GetSystemColums())
{
CountryConfig.SystemRow systemRow = (systemColumn.Tag as SystemTreeListTag).GetSystemRow();
int index = lstSystems.Items.Add(systemRow.Name);
lstSystems.SetItemChecked(index, firstFill || selIds.Contains(systemRow.ID));
_systemRows.Add(systemRow);
}
}
private Dictionary <string, string> EM3_CreateConfig(string countryShortName, string outputPath,
DataConfig.DataBaseRow dbr, CountryConfig.SystemRow sr,
string parModifications = null)
{
Dictionary <string, string> config = new Dictionary <string, string>();
config.Add(TAGS.CONFIG_PATH_OUTPUT, outputPath);
config.Add(TAGS.CONFIG_PATH_DATA, EM_AppContext.FolderInput);
config.Add(TAGS.CONFIG_PATH_EUROMODFILES, EM_AppContext.FolderEuromodFiles);
config.Add(TAGS.CONFIG_COUNTRY, CountryAdministrator.GetCountryFileName(countryShortName).ToLower().Replace(".xml", ""));
config.Add(TAGS.CONFIG_ID_DATA, dbr.ID);
config.Add(TAGS.CONFIG_ID_SYSTEM, sr.ID);
if (textRunFirstNHH.Text != null && !string.IsNullOrEmpty(textRunFirstNHH.Text) && int.TryParse(textRunFirstNHH.Text, out _))
{
config.Add(TAGS.CONFIG_FIRST_N_HH_ONLY, textRunFirstNHH.Text);
}
if (parModifications != null)
{
config.Add(TAGS.CONFIG_STRING_PAR_MODIFICATIONS, parModifications);
}
string addOn = GetCheckedAddon();
if (!string.IsNullOrEmpty(addOn))
{
string addOnSys = null;
foreach (AddOnSystemInfo aos in AddOnInfoHelper.GetAddOnSystemInfo(addOn))
{
foreach (string sysPattern in aos._supportedSystems)
{
if (EM_Helpers.DoesValueMatchPattern(sysPattern, sr.Name))
{
addOnSys = aos._addOnSystemName; break;
}
}
}
if (addOnSys == null)
{
throw new Exception($"No matching Addon found for {sr.Name}");
}
config.Add(TAGS.CONFIG_ADDON, $"{addOn}|{addOnSys}");
}
return(config);
}
internal abstract void StoreChangedValue(string newValue, CountryConfig.SystemRow systemRow); //overtake user changes to data-row (this function is called by the Actions started by HandleValueChanged)
void btnOK_Click(object sender, EventArgs e)
{
//store information of grid for format settings of conditional formatting
for (int iRow = 0; iRow < dgvConditionalFormatting.RowCount; ++iRow)
{
CountryConfig.ConditionalFormatRow conditionalFormatRow = null;
if (dgvConditionalFormatting.Rows[iRow].Tag != null)
{
conditionalFormatRow = dgvConditionalFormatting.Rows[iRow].Tag as CountryConfig.ConditionalFormatRow;
}
//delete condtional formats
if (dgvConditionalFormatting.Rows[iRow].Visible == false)
{
_countryConfigFacade.DeleteConditionalFormatRow(conditionalFormatRow);
continue;
}
// first delete any existing line, then build the new one.
if (conditionalFormatRow != null)
{
conditionalFormatRow.Delete();
}
conditionalFormatRow = _countryConfigFacade.AddConditionalFormatRow(
dgvConditionalFormatting.Rows[iRow].Cells[colBackColorConditionalFormatting.Name].Value.ToString(),
dgvConditionalFormatting.Rows[iRow].Cells[colForeColorConditionalFormatting.Name].Value.ToString(),
dgvConditionalFormatting.Rows[iRow].Cells[colCondition.Name].Value.ToString(),
string.Empty);
//change conditional formats' systems to apply on
object cellValue = dgvConditionalFormatting.Rows[dgvConditionalFormatting.Rows[iRow].Index].Cells[colSystemsToApply.Name].Value;
if (cellValue != null)
{
foreach (string systemName in cellValue.ToString().Split(_separator.First()))
{
CountryConfig.SystemRow systemRow = _countryConfigFacade.GetSystemRowByName(systemName.Trim());
if (systemRow != null)
{
_countryConfigFacade.AddConditionalFormat_SystemsRow(conditionalFormatRow, systemRow);
}
}
}
}
//store information of grid for format settings of base-derived-system differences
_systemsToExpand = new List <KeyValuePair <string, string> >();
for (int iRow = 0; iRow < dgvBaseSystemFormatting.RowCount; ++iRow)
{
CountryConfig.SystemRow systemRow = _countryConfigFacade.GetSystemRowByName(dgvBaseSystemFormatting.Rows[iRow].Cells[colSystem.Name].Value.ToString());
if (systemRow == null)
{
continue;
}
CountryConfig.ConditionalFormatRow conditionalFormatRow = null;
if (dgvBaseSystemFormatting.Rows[iRow].Tag != null)
{
conditionalFormatRow = dgvBaseSystemFormatting.Rows[iRow].Tag as CountryConfig.ConditionalFormatRow;
}
string baseSystemName = string.Empty;
object cellValue = dgvBaseSystemFormatting.Rows[iRow].Cells[colBaseSystem.Name].Value;
if (cellValue != null)
{
baseSystemName = cellValue.ToString();
}
//expanding of differences between system and its base (if ticked by the user) is handled by the TreeListManager after the CF-action (see TreeListManager.HandleConditionalFormatting)
//here only gather respective systems and their base
if (EM_Helpers.SaveConvertToBoolean(dgvBaseSystemFormatting.Rows[iRow].Cells[colExpandDifferences.Name].Value) == true)
{
if (baseSystemName == string.Empty)
{
continue;
}
_systemsToExpand.Add(new KeyValuePair <string, string>(systemRow.Name, baseSystemName));
}
if (conditionalFormatRow != null) // if there was a base system
{
if (conditionalFormatRow.BaseSystemName == baseSystemName) //just format changed, but same base system
{
conditionalFormatRow.BackColor = dgvBaseSystemFormatting.Rows[iRow].Cells[colBackColorBaseSystemFormatting.Name].Value.ToString();
conditionalFormatRow.ForeColor = dgvBaseSystemFormatting.Rows[iRow].Cells[colForeColorBaseSystemFormatting.Name].Value.ToString();
continue;
}
conditionalFormatRow.Delete(); // else delete this and make a new one if required
}
if (baseSystemName == string.Empty)
{
continue;
}
conditionalFormatRow = _countryConfigFacade.AddConditionalFormatRow(
dgvBaseSystemFormatting.Rows[iRow].Cells[colBackColorBaseSystemFormatting.Name].Value.ToString(),
dgvBaseSystemFormatting.Rows[iRow].Cells[colForeColorBaseSystemFormatting.Name].Value.ToString(),
string.Empty, baseSystemName);
_countryConfigFacade.AddConditionalFormat_SystemsRow(conditionalFormatRow, systemRow);
}
DialogResult = DialogResult.OK;
Close();
}
internal SystemTreeListTag(CountryConfig.SystemRow systemRow)
{
_systemRow = systemRow;
}
internal SystemAndBase(CountryConfig.SystemRow _system, CountryConfig.SystemRow _baseSystem)
{
system = _system; baseSystem = _baseSystem;
}
private void EM2_FixUprating(CountryConfig.SystemRow sr1, Dictionary <string, string> upratingFactors, Dictionary <string, string> upratingFactors2, string countryShortName, double alpha, int uprateType, bool treatAsMarket)
{
// first get the ils_origy & ils_ben components
CountryConfig.PolicyRow ilsdef = sr1.GetPolicyRows().FirstOrDefault(p => p.Name.ToLower() == ("ilsdef_" + countryShortName).ToLower());
if (ilsdef == null)
{
ilsdef = sr1.GetPolicyRows().FirstOrDefault(p => p.Name.ToLower() == ("ildef_" + countryShortName).ToLower());
}
if (ilsdef == null)
{
return;
}
CountryConfig.FunctionRow[] il_funcs = ilsdef.GetFunctionRows();
List <string> ils_origy = ExpandIncomeList(DefVarName.ILSORIGY, il_funcs).Keys.ToList();
List <string> ils_ben = ExpandIncomeList(DefVarName.ILSBEN, il_funcs).Keys.ToList();
List <string> overrideInclude = ExpandIncomeList("pet_override", il_funcs).Where(x => x.Value).Select(x => x.Key).ToList();
List <string> overrideExclude = ExpandIncomeList("pet_override", il_funcs).Where(x => !x.Value).Select(x => x.Key).ToList();
List <string> reservedWords = new List <string> {
"dataset", "def_factor", "factor_name", "factor_value", "factor_condition", "aggvar_name", "aggvar_part", "aggvar_tolerance", "warnifnofactor", "run_cond"
};
// Then apply them to the appropriate variables of s1
foreach (CountryConfig.FunctionRow fr in sr1.GetPolicyRows().First(p => p.Name.ToLower() == ("Uprate_" + countryShortName).ToLower()).GetFunctionRows())
{
if (fr.Name.ToLower() == "uprate")
{
foreach (CountryConfig.ParameterRow pr in fr.GetParameterRows())
{
string pn = pr.Name.ToLower();
if (!reservedWords.Contains(pn))
{
if (uprateType == 3) // uprate all
{
double val;
if (upratingFactors.ContainsKey(pr.Value.ToLower()))
{
pr.Value = FixDecSep((EM_Helpers.SaveConvertToDouble(upratingFactors2[pr.Value.ToLower()]) * alpha).ToString());
}
else if (EM_Helpers.TryConvertToDouble(pr.Value.ToLower(), out val))
{
pr.Value = FixDecSep((val * alpha).ToString());
}
}
else
{
bool marketIncome = overrideInclude.Contains(pn); // if in the override include list
if (!overrideExclude.Contains(pn) && !marketIncome) // else if not in the override exlcude list
{
VarConfig.VariableRow v = EM_AppContext.Instance.GetVarConfigFacade().GetVariableByName(pn);
if (v == null || v.Monetary != "1")
{
marketIncome = false;
}
else
{
if (treatAsMarket)
{
marketIncome = !pn.EndsWith(DefGeneral.POSTFIX_SIMULATED);
}
else
{
marketIncome = !ils_ben.Contains(pn) && (pn[0] == 'y' || pn[0] == 'a' || pn[0] == 'x' || ils_origy.Contains(pn));
}
}
}
// if this is a market income
if (marketIncome)
{
if (uprateType == 1)
{
double val;
if (upratingFactors.ContainsKey(pr.Value.ToLower()))
{
pr.Value = FixDecSep((EM_Helpers.SaveConvertToDouble(upratingFactors[pr.Value.ToLower()]) * alpha).ToString());
}
else if (EM_Helpers.TryConvertToDouble(pr.Value.ToLower(), out val))
{
pr.Value = FixDecSep((val * alpha).ToString());
}
}
else if (uprateType == 2)
{
if (upratingFactors.ContainsKey(pr.Value.ToLower()))
{
pr.Value = FixDecSep((EM_Helpers.SaveConvertToDouble(upratingFactors[pr.Value.ToLower()])).ToString());
}
}
}
else // if it is non-market income
{
if (uprateType == 2)
{
double val;
if (upratingFactors2.ContainsKey(pr.Value.ToLower()))
{
pr.Value = FixDecSep((EM_Helpers.SaveConvertToDouble(upratingFactors2[pr.Value.ToLower()]) / alpha).ToString());
}
else if (EM_Helpers.TryConvertToDouble(pr.Value.ToLower(), out val))
{
pr.Value = FixDecSep((val / alpha).ToString());
}
}
}
}
}
}
}
}
if (uprateType > 1)
{
string[] monetaryTypes = new string[] { DefPeriod.M, DefPeriod.Y, DefPeriod.Q, DefPeriod.W,
DefPeriod.D, DefPeriod.L, DefPeriod.S, DefPeriod.C };
foreach (CountryConfig.FunctionRow fr in sr1.GetPolicyRows().First(p => p.Name.ToLower() == ("Uprate_" + countryShortName).ToLower()).GetFunctionRows())
{
foreach (CountryConfig.ParameterRow pr in fr.GetParameterRows())
{
string val = pr.Value.ToLower().Trim();
if (val.Length < 3)
{
continue;
}
string valType = val.Substring(val.Length - 2);
if (monetaryTypes.Contains(valType))
{
val = val.Substring(0, val.Length - 2);
if (uprateType == 2)
{
pr.Value = FixDecSep((EM_Helpers.SaveConvertToDouble(val) / alpha).ToString()) + valType;
}
else if (uprateType == 3)
{
pr.Value = FixDecSep((EM_Helpers.SaveConvertToDouble(val) * alpha).ToString()) + valType;
}
}
}
}
}
try
{
// Then, fix the output filenames
sr1.GetPolicyRows().First(p => p.Name.ToLower() == ("output_std_" + countryShortName).ToLower())
.GetFunctionRows().First(f => f.Name.ToLower() == "defoutput")
.GetParameterRows().First(p => p.Name.ToLower() == "file")
.Value = sr1.Name + "_std";
sr1.GetPolicyRows().First(p => p.Name.ToLower() == ("output_std_hh_" + countryShortName).ToLower())
.GetFunctionRows().First(f => f.Name.ToLower() == "defoutput")
.GetParameterRows().First(p => p.Name.ToLower() == "file")
.Value = sr1.Name + "_std_hh";
// Finally, if required, do the scaling
if (checkRadioMarket.Checked)
{
CountryConfig.FunctionRow fr = sr1.GetPolicyRows().First(p => p.Name.ToLower() == ("output_std_" + countryShortName).ToLower())
.GetFunctionRows().First(f => f.Name.ToLower() == "defoutput");
CountryConfig.FunctionRow fr_hh = sr1.GetPolicyRows().First(p => p.Name.ToLower() == ("output_std_hh_" + countryShortName).ToLower())
.GetFunctionRows().First(f => f.Name.ToLower() == "defoutput");
if (fr.GetParameterRows().Count(p => p.Name.ToLower() == DefPar.DefOutput.MultiplyMonetaryBy.ToLower()) == 0)
{
CountryConfig.ParameterRow fpr = fr.GetParameterRows().First(p => p.Name.ToLower() == "file");
CountryConfig.ParameterRow cpr = CountryConfigFacade.AddParameterRow(fpr, false,
DefPar.DefOutput.MultiplyMonetaryBy, DefinitionAdmin.GetParDefinition(DefFun.DefOutput, DefPar.DefOutput.MultiplyMonetaryBy));
cpr.Value = FixDecSep((1 / alpha).ToString());
}
else
{
CountryConfig.ParameterRow mpr = fr.GetParameterRows().First(p => p.Name.ToLower() == DefPar.DefOutput.MultiplyMonetaryBy.ToLower());
double d;
if (!EM_Helpers.TryConvertToDouble(mpr.Value, out d))
{
d = 1;
}
mpr.Value = FixDecSep((d / alpha).ToString());
}
if (fr_hh.GetParameterRows().Count(p => p.Name.ToLower() == DefPar.DefOutput.MultiplyMonetaryBy.ToLower()) == 0)
{
CountryConfig.ParameterRow fpr_hh = fr_hh.GetParameterRows().First(p => p.Name.ToLower() == "file");
CountryConfig.ParameterRow cpr = CountryConfigFacade.AddParameterRow(fpr_hh, false,
DefPar.DefOutput.MultiplyMonetaryBy, DefinitionAdmin.GetParDefinition(DefFun.DefOutput, DefPar.DefOutput.MultiplyMonetaryBy));
cpr.Value = FixDecSep((1 / alpha).ToString());
}
else
{
CountryConfig.ParameterRow mpr_hh = fr_hh.GetParameterRows().First(p => p.Name.ToLower() == DefPar.DefOutput.MultiplyMonetaryBy.ToLower());
double d;
if (!EM_Helpers.TryConvertToDouble(mpr_hh.Value, out d))
{
d = 1;
}
mpr_hh.Value = FixDecSep((d / alpha).ToString());
}
}
}
catch
{
throw new Exception("Problem in default output functions.");
}
}
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();
}
private Dictionary <string, string> EM2_CreateConfig(string countryShortName, string outputPath, DataConfig.DataBaseRow dbr, CountryConfig.SystemRow sr, bool useTempCountry = true)
{
Dictionary <string, string> contentEMConfig = new Dictionary <string, string>();
string emVersion = EM_AppContext.Instance.GetProjectName();
if (emVersion.Trim() == string.Empty)
{
UserInfoHandler.ShowError($"{DefGeneral.BRAND_TITLE} version is not defined. Please define it via the menu 'Configuration'.");
return(null);
}
//fill EMConfig-entry-list
string dateTimePrefix = string.Format("{0:yyyyMMddHHmm}", DateTime.Now);
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_ERRLOG_FILE, outputPath + dateTimePrefix + EM_XmlHandler.TAGS.EM2CONFIG_errLogFileName);
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_LOG_WARNINGS, DefPar.Value.YES);
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_EMVERSION, emVersion);
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_UIVERSION, DefGeneral.UI_VERSION);
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_PARAMPATH, useTempCountry ? EMPath.AddSlash(EMPath.Folder_Temp(EM_AppContext.FolderEuromodFiles)) : EMPath.AddSlash(Path.Combine(EMPath.Folder_Countries(EM_AppContext.FolderEuromodFiles), countryShortName)));
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_CONFIGPATH, EMPath.Folder_Config(EM_AppContext.FolderEuromodFiles));
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_OUTPUTPATH, outputPath);
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_DATAPATH, EM_AppContext.FolderInput);
string executablePath = EnvironmentInfo.GetEM2ExecutableFile();
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_EMCONTENTPATH, EM_AppContext.FolderEuromodFiles);
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_HEADER_DATE, dateTimePrefix);
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_OUTFILE_DATE, "-");
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_LOG_RUNTIME, DefPar.Value.NO);
if (EM_AppContext.Instance.IsPublicVersion())
{
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_ISPUBLICVERSION, DefPar.Value.YES);
}
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_DECSIGN_PARAM, EM_Helpers.uiDecimalSeparator);
string startHH = EM_XmlHandler.TAGS.EM2CONFIG_defaultHHID;
string lastHH = EM_XmlHandler.TAGS.EM2CONFIG_defaultHHID;
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_STARTHH, startHH);
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_LASTHH, lastHH);
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_COUNTRY_FILE, CountryAdministrator.GetCountryFileName(countryShortName));
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_DATACONFIG_FILE, CountryAdministrator.GetDataFileName(countryShortName));
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_DATASET_ID, dbr.ID);
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_SYSTEM_ID, sr.ID);
//generate for each (available) switchable policy a POLICY_SWITCH-entry
Dictionary <string, string> extIDAndPattern = new Dictionary <string, string>();
foreach (GlobLocExtensionRow e in ExtensionAndGroupManager.GetExtensions(countryShortName))
{
extIDAndPattern.Add(e.ID, e.ShortName);
}
List <string> policySwitchEntries = new List <string>();
foreach (var e in extIDAndPattern)
{
string extID = e.Key, extShortName = e.Value;
string policySwitchValue = string.Empty;
if (dbr.GetDBSystemConfigRows().Count(x => x.SystemID == sr.ID) > 0)
{
policySwitchValue = ExtensionAndGroupManager.GetExtensionDefaultSwitch(dbr.GetDBSystemConfigRows().First(x => x.SystemID == sr.ID), extID);
}
//generate the POLICY_SWITCH-entry
//taking into account that there is no need to generate it if the switch is set to n/a (i.e. the switchable policy is not switchable for this db-system-combination or does not even exist)
if (policySwitchValue != string.Empty && policySwitchValue != DefPar.Value.NA)
{
string policySwitchEntry = //the executable needs three pieces of information to overwrite the default value of the policy switch:
extShortName //which switchable policy (e.g. BTA_??)
+ "=" + sr.ID //which system
+ "=" + policySwitchValue; //and the respective value (on or off)
policySwitchEntries.Add(policySwitchEntry);
}
}
//for each (available) switchable policy add a POLICY_SWITCH-entry
foreach (string policySwitchEntry in policySwitchEntries)
{
contentEMConfig.Add(EM_XmlHandler.TAGS.EM2CONFIG_POLICY_SWITCH + Guid.NewGuid().ToString(), policySwitchEntry);
}
//now actually write the EMConfigXXX.xml files and hand them over to the run-manager
string configurationFileNameAndPath = EMPath.Folder_Temp(EM_AppContext.FolderEuromodFiles) + EM_XmlHandler.TAGS.EM2CONFIG_labelEMConfig + Guid.NewGuid().ToString() + ".xml";
using (XmlTextWriter configurationFileWriter = new XmlTextWriter(configurationFileNameAndPath, null))
{
configurationFileWriter.Formatting = System.Xml.Formatting.Indented;
configurationFileWriter.WriteStartDocument(true);
configurationFileWriter.WriteStartElement(EM_XmlHandler.TAGS.EM2CONFIG_labelEMConfig);
string runFormInfoText = string.Empty;
foreach (string key in contentEMConfig.Keys)
{
if (key.StartsWith(EM_XmlHandler.TAGS.EM2CONFIG_SYSTEM_ID)) //remove Guid, see above
{
configurationFileWriter.WriteElementString(EM_XmlHandler.TAGS.EM2CONFIG_SYSTEM_ID, contentEMConfig[key]);
}
else if (key.StartsWith(EM_XmlHandler.TAGS.EM2CONFIG_POLICY_SWITCH)) //remove Guid, see above
{
configurationFileWriter.WriteElementString(EM_XmlHandler.TAGS.EM2CONFIG_POLICY_SWITCH, contentEMConfig[key]);
}
else
{
configurationFileWriter.WriteElementString(key, contentEMConfig[key]);
}
}
configurationFileWriter.WriteElementString(EM_XmlHandler.TAGS.EM2CONFIG_LAST_RUN, DefPar.Value.NO);
configurationFileWriter.WriteEndElement();
configurationFileWriter.WriteEndDocument();
}
// EM3 returns the config-dictionary, therefore (mis)use this structure to just store the file-path as the first entry (to avoid extra variables for EM2)
return(new Dictionary <string, string>()
{
{ configurationFileNameAndPath, null }
});
}
Dictionary <string, string> GatherComponents()
{
Dictionary <string, string> selectedComponents = new Dictionary <string, string>();
if (chkAllVariables.Checked)
{
if (chkCountrySpecific.Checked)
{
string countryShortName = _mainForm.GetCountryShortName();
foreach (VarConfig.VariableRow variableRow in EM_AppContext.Instance.GetVarConfigFacade().GetVariablesWithCountrySpecificDescription(countryShortName))
{
if (IsCheckedVariable(variableRow))
{
selectedComponents.Add(variableRow.Name, _componentType_Variable);
}
}
}
else if (chkMonetary.Checked || chkNonMonetary.Checked || chkSimulated.Checked || chkNonSimulated.Checked)
{
foreach (VarConfig.VariableRow variableRow in EM_AppContext.Instance.GetVarConfigFacade().GetVariables())
{
if (IsCheckedVariable(variableRow))
{
selectedComponents.Add(variableRow.Name, _componentType_Variable);
}
}
}
else
{
foreach (string variableName in EM_AppContext.Instance.GetVarConfigFacade().GetVariables_NamesAndDescriptions().Keys)
{
if (!selectedComponents.Keys.Contains(variableName.ToLower()))
{
selectedComponents.Add(variableName.ToLower(), _componentType_Variable);
}
}
}
}
if (chkAssessmentUnits.Checked)
{
List <CountryConfig.ParameterRow> parameterRowsTUs = null;
foreach (TreeListColumn systemColumn in _mainForm.GetTreeListBuilder().GetSystemColums())
{
CountryConfig.SystemRow systemRow = (systemColumn.Tag as SystemTreeListTag).GetSystemRow();
CountryConfigFacade.GetDefFunctionInformation(systemRow, ref parameterRowsTUs, DefFun.DefTu, DefPar.DefTu.Name);
foreach (CountryConfig.ParameterRow parameterRowsTU in parameterRowsTUs)
{
if (!selectedComponents.Keys.Contains(parameterRowsTU.Value.ToLower()))
{
selectedComponents.Add(parameterRowsTU.Value.ToLower(), _componentType_Taxunit);
}
}
}
}
if (chkIncomelists.Checked)
{
List <CountryConfig.ParameterRow> parameterRowsILs = null;
foreach (TreeListColumn systemColumn in _mainForm.GetTreeListBuilder().GetSystemColums())
{
CountryConfig.SystemRow systemRow = (systemColumn.Tag as SystemTreeListTag).GetSystemRow();
CountryConfigFacade.GetDefFunctionInformation(systemRow, ref parameterRowsILs, DefFun.DefIl, DefPar.DefIl.Name);
foreach (CountryConfig.ParameterRow parameterRowsIL in parameterRowsILs)
{
if (!selectedComponents.Keys.Contains(parameterRowsIL.Value.ToLower()))
{
selectedComponents.Add(parameterRowsIL.Value.ToLower(), _componentType_Incomelist);
}
}
}
}
if (chkQueries.Checked)
{
foreach (string queryName in DefinitionAdmin.GetQueryNamesAndDesc(false).Keys)
{
if (!selectedComponents.Keys.Contains(queryName.ToLower()))
{
selectedComponents.Add(queryName.ToLower(), _componentType_Query);
DefinitionAdmin.GetQueryDefinition(queryName, out DefinitionAdmin.Query queryDef, out string dummy, false);
if (queryDef != null)
{
foreach (string queryAlias in queryDef.aliases)
{
selectedComponents.Add(queryAlias.ToLower(), _componentType_Query);
}
}
}
}
}
if (txtComponentName.Text != string.Empty && !IsPatternSearchForSingleComponent()) //pattern-search has to be treated differently
{
if (!selectedComponents.Keys.Contains(txtComponentName.Text.ToLower()))
{
selectedComponents.Add(txtComponentName.Text.ToLower(), _componentType_Unknown);
}
}
return(selectedComponents);
}
internal override void StoreChangedValue(string newValue, CountryConfig.SystemRow systemRow)
{
_policyRows[systemRow.ID].Switch = newValue;
}
static internal int GetSystemYear(CountryConfig.SystemRow system)
{
int year;
return(system.Year == null || system.Year == string.Empty || !int.TryParse(system.Year, out year) ? GetSystemYear(system.Name) : year);
}
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();
}
}
}
}
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}");
}
}
