internal static bool ValidateEditorInput(string value, TreeListNode node, TreeListColumn column, ref string errorText)
{
if (value == DefPar.Value.NA)
{
return(true);
}
CountryConfig.ParameterRow countryParameterRow = (node.Tag as ParameterTreeListTag).GetDefaultParameterRow();
SystemTreeListTag systemColumnTag = column.Tag as SystemTreeListTag;
switch (DefinitionAdmin.GetParDefinition(countryParameterRow.FunctionRow.Name, countryParameterRow.Name).valueType)
{
case DefPar.PAR_TYPE.FORMULA: return(ValidateFormula(value, systemColumnTag, ref errorText));
case DefPar.PAR_TYPE.CONDITION: return(ValidateCondition(value, systemColumnTag, ref errorText));
case DefPar.PAR_TYPE.TEXT: return(ValidateString(value, systemColumnTag, ref errorText));
case DefPar.PAR_TYPE.NUMBER: return(ValidateAmount(value, systemColumnTag, ref errorText));
case DefPar.PAR_TYPE.VAR: return(ValidateVariable(value, systemColumnTag, ref errorText));
case DefPar.PAR_TYPE.VARorIL: return(ValidateVariableIncomelist(value, systemColumnTag, ref errorText));
}
return(true);
}
static internal string GetIDBySymbolicID(string symbolicID, CountryConfigFacade countryConfigFacade, string systemID)
{
ReplaceCountrySymbol(symbolicID, countryConfigFacade.GetCountryShortName());
if (symbolicID.Contains(_symbolicID_ParameterSeparator))
{
CountryConfig.ParameterRow parameterRow = GetParameterRowBySymbolicID(symbolicID, countryConfigFacade, systemID);
if (parameterRow != null)
{
return(parameterRow.ID);
}
}
else if (symbolicID.Contains(_symbolicID_OrderSeparator))
{
CountryConfig.FunctionRow functionRow = GetFunctionRowBySymbolicID(symbolicID, countryConfigFacade, systemID);
if (functionRow != null)
{
return(functionRow.ID);
}
}
else
{
CountryConfig.PolicyRow policyRow = countryConfigFacade.GetPolicyRowByFullName(systemID, symbolicID);
if (policyRow != null)
{
return(policyRow.ID);
}
}
return(string.Empty);
}
static System.Data.DataRow GetDataRowBySymbolicID(string symbolicID, CountryConfigFacade countryConfigFacade, string systemID, bool function)
{
string policyName = string.Empty;
string functionDisplayOrder = string.Empty;
string parameterDisplayOrder = string.Empty;
CountryConfig.FunctionRow functionRow = null;
CountryConfig.ParameterRow parameterRow = null;
if (GetPolicyAndOrderFromSymbolicID(symbolicID, countryConfigFacade.GetCountryShortName(), ref policyName, ref functionDisplayOrder, ref parameterDisplayOrder))
{
if (EM_Helpers.IsNonNegInteger(functionDisplayOrder))
{
functionRow = GetFunctionRowByPolicyNameAndDisplayOrder(countryConfigFacade, systemID, policyName, functionDisplayOrder);
}
else //take account of functions DefIL and DefTU, which use the (value of the) name parameter as identifier instead of the order
{
functionRow = GetFunctionRowByPolicyNameAndValueOfSpecialParameter(countryConfigFacade, systemID, policyName,
DefPar.DefIl.Name, functionDisplayOrder);
}
}
if (function)
{
return(functionRow);
}
if (functionRow != null)
{
parameterRow = GetParameterRowByDisplayOrder(countryConfigFacade, functionRow.ID, parameterDisplayOrder);
}
return(parameterRow);
}
private bool IsPlaceholderSibling(CountryConfig.ParameterRow parRow, List <string> potentialGroupPars)
{
if (!potentialGroupPars.Contains(DefPar.PAR_TYPE.PLACEHOLDER.ToString().ToLower()))
{
return(false);
}
return(DefinitionAdmin.GetParDefinition(parRow.FunctionRow.Name, parRow.Name, false) == null);
}
//either use the comment alongside the name-parameter or the function's comment
internal string GetILTUComment(CountryConfig.ParameterRow parameterRowILTU)
{
if (parameterRowILTU.Comment != null && parameterRowILTU.Comment != string.Empty)
{
return(parameterRowILTU.Comment);
}
return(parameterRowILTU.FunctionRow.Comment);
}
internal override int GetSpecialNodeColor()
{
CountryConfig.ParameterRow parameterRow = GetDefaultParameterRow();
if (parameterRow == null || parameterRow.IsNull(CountryConfigFacade._columnName_Color))
{
return(DefPar.Value.NO_COLOR);
}
return(parameterRow.Color);
}
private static string GetConstDescription(CountryConfig.ParameterRow parameterRow)
{
var condition = from p in parameterRow.FunctionRow.GetParameterRows()
where p.Name.ToLower() == DefPar.DefConst.Condition.ToLower() &
p.Group == parameterRow.Group
select p;
return(condition.Count() == 0 ? parameterRow.Value
: condition.First().Value + ": " + parameterRow.Value);
}
TreeListNode BuildParameterNode(TreeListNode functionNode, CountryConfig.ParameterRow parameterRow)
{
TreeListNode parameterNode = _mainForm.treeList.AppendNode(null, functionNode);
parameterNode.SetValue(_policyColumnName, parameterRow.Name);
parameterNode.SetValue(_commentColumnName, parameterRow.Comment);
parameterNode.SetValue(_groupColumnName, parameterRow.Group);
parameterNode.Tag = new ParameterTreeListTag(_mainForm);
parameterNode.StateImageIndex = (parameterRow.Private == DefPar.Value.YES) ?
DefGeneral.IMAGE_IND_PRIV_PAR : -1;
parameterNode.ImageIndex = parameterNode.SelectImageIndex = -1; //not used
return(parameterNode);
}
internal static void RenameOutputFiles(CountryConfigFacade countryConfigFacade, CountryConfig.SystemRow systemRow, string oldSystemName, bool request = false)
{
//search policies Output_Std_cc and Output_Std_HH_cc
//CountryConfig.PolicyRow policyRow = countryConfigFacade.GetPolicyRowByName(systemRow.ID, standardOutputPolicyName);
//if (policyRow == null) continue;
//within these policies search for function(s) DefOutput
//List<CountryConfig.FunctionRow> defOutputFunctionRows = countryConfigFacade.GetFunctionRowsByPolicyIDAndFunctionName(policyRow.ID, DefFun.DefOutput);
var defOutputFunctionRows = from f in countryConfigFacade.GetCountryConfig().Function
where f.PolicyRow.SystemID == systemRow.ID && f.Name.ToLower() == DefFun.DefOutput.ToLower()
select f;
foreach (CountryConfig.FunctionRow defOutputFunctionRow in defOutputFunctionRows)
{
//within these functions search for parameter File
CountryConfig.ParameterRow parameterRow = countryConfigFacade.GetParameterRowByName(defOutputFunctionRow.ID, DefPar.DefOutput.File);
if (parameterRow == null)
{
continue;
}
//if parameter file found replace system name (e.g. rename UK_2009_std to UK_2009_reform_std)
int index = parameterRow.Value.ToLower().IndexOf(oldSystemName.ToLower());
if (index < 0)
{
continue;
}
string newOutputName = parameterRow.Value.Substring(0, index) + systemRow.Name + parameterRow.Value.Substring(index + oldSystemName.Length);
if (request)
{
if (UserInfoHandler.GetInfo("Do you want to adapt the names of output-files to the new system name?" + Environment.NewLine +
string.Format("(e.g. '{0}' to '{1}')", parameterRow.Value, newOutputName), MessageBoxButtons.YesNo) == DialogResult.Yes)
{
request = false; // do not ask again for any other output-policy
}
else
{
return; // do not rename
}
}
parameterRow.Value = newOutputName;
}
}
static CountryConfig.ParameterRow GetParameterRowByDisplayOrder(CountryConfigFacade countryConfigFacade, string functionID, string displayOrder)
{
try
{
CountryConfig.FunctionRow functionRow = countryConfigFacade.GetFunctionRowByID(functionID);
int displayIndex = Convert.ToInt32(displayOrder) - 1;
CountryConfig.ParameterRow par = null;
if (functionRow != null && displayIndex >= 0)
{
List <CountryConfig.ParameterRow> siblingParameters = functionRow.GetParameterRows().OrderBy(p => long.Parse(p.Order)).ToList();
if (displayIndex < siblingParameters.Count)
{
par = siblingParameters.ElementAt(displayIndex);
}
}
return(par);
}
catch { return(null); }
}
void AddFunctions()
{
//analyse all AddOn_Func functions
foreach (CountryConfig.FunctionRow function_AddOnFunction in
_addOnCountryConfigFacade.GetFunctionRowsBySystemIDAndFunctionName(_addOnSystemRow.ID, DefFun.AddOn_Func))
{
if (function_AddOnFunction.Switch.ToLower() != DefPar.Value.ON.ToLower())
{
continue;
}
//assess which function is to be merged and whereto by interpreting the AddOnFunc-function's parameters
CountryConfig.ParameterRow parameter_FunctionID = _addOnCountryConfigFacade.GetParameterRowByName(function_AddOnFunction.ID,
DefPar.AddOn_Func.Id_Func);
CountryConfig.ParameterRow parameter_InsertAfterFunction = _addOnCountryConfigFacade.GetParameterRowByName(function_AddOnFunction.ID,
DefPar.AddOn_Func.Insert_After_Func);
CountryConfig.ParameterRow parameter_InsertBeforeFunction = _addOnCountryConfigFacade.GetParameterRowByName(function_AddOnFunction.ID,
DefPar.AddOn_Func.Insert_Before_Func);
if (parameter_FunctionID == null || (parameter_InsertAfterFunction == null && parameter_InsertBeforeFunction == null))
{
if (parameter_FunctionID == null)
{
_errorMessages += ImportExportHelper.GenerateErrorMessage(function_AddOnFunction, "Compulsory parameter '" +
DefPar.AddOn_Func.Id_Func + "' not defined.");
}
if (parameter_InsertAfterFunction == null && parameter_InsertBeforeFunction == null)
{
_errorMessages += ImportExportHelper.GenerateErrorMessage(function_AddOnFunction, "Compulsory parameter '" +
DefPar.AddOn_Func.Insert_After_Func + "' (alternatively '" + DefPar.AddOn_Func.Insert_Before_Func + "') not defined.");
}
continue;
}
//search for the function to insert in the add-on-system and for the link-function (before/after the which the function is to be inserted) in the just generated (copied) system
CountryConfig.FunctionRow addOnFunction_Function = _addOnCountryConfigFacade.GetFunctionRowByID(parameter_FunctionID.Value);
if (addOnFunction_Function == null) //take account of 'symbolic' identifier, e.g. ADDON_DOSOMEWHAT_#3
{
addOnFunction_Function = ImportExportHelper.GetFunctionRowBySymbolicID(parameter_FunctionID.Value, _addOnCountryConfigFacade, _addOnSystemRow.ID);
}
bool before = parameter_InsertBeforeFunction != null ? true : false;
string referenceFunctionID = before ? parameter_InsertBeforeFunction.Value : parameter_InsertAfterFunction.Value;
CountryConfig.FunctionRow addOnFunction_ReferenceFunction = _mergeCountryConfigFacade.GetFunctionRowByID(referenceFunctionID);
if (addOnFunction_ReferenceFunction == null) //take account of 'symbolic' identifier
{
addOnFunction_ReferenceFunction = ImportExportHelper.GetFunctionRowBySymbolicID(referenceFunctionID, _mergeCountryConfigFacade, _mergeSystemRow.ID);
}
if (addOnFunction_Function == null || addOnFunction_ReferenceFunction == null)
{
if (addOnFunction_Function == null)
{
_errorMessages += ImportExportHelper.GenerateErrorMessage(function_AddOnFunction, "Unknown function '" + parameter_FunctionID.Value + "'.");
}
if (addOnFunction_ReferenceFunction == null)
{
_errorMessages += ImportExportHelper.GenerateErrorMessage(function_AddOnFunction, "Unknown function '" + referenceFunctionID + "'.");
}
continue;
}
//if everything is ok, insert the function at the indicated place
CountryConfig.FunctionRow addOnFunctionRow = CountryConfigFacade.CopyFunctionRow(addOnFunction_Function,
addOnFunction_ReferenceFunction,
before,
addOnFunction_Function.Switch == DefPar.Value.NA,
true); //keep all ids identically: otherwise the id-references (e.g. in ChangeParam, AddOn_Par, etc.) within the add-on would not work
ImportExportHelper.ReplaceCountrySymbol(addOnFunctionRow, _mergeCountryConfigFacade.GetCountryShortName()); //replace all incidents of =cc= by country symbol
}
}
static internal string GetSymbolicID(CountryConfig.ParameterRow parameterRow, string replaceCountryShortName = "")
{ //e.g. ILDef_sl_#10.3 for the 3rd parameter in the 10th function in policy ILDef_sl
return(GetSymbolicID(parameterRow.FunctionRow) + _symbolicID_ParameterSeparator + OrderToDisplayOrder(parameterRow));
}
static string OrderToDisplayOrder(CountryConfig.ParameterRow parameterRow)
{
List <CountryConfig.ParameterRow> siblingParameters = parameterRow.FunctionRow.GetParameterRows().OrderBy(p => long.Parse(p.Order)).ToList();
return((siblingParameters.IndexOf(parameterRow) + 1).ToString());
}
static internal void ReplaceCountrySymbol(CountryConfig.ParameterRow parameterRow, string countryShortName)
{
parameterRow.Value = ReplaceCountrySymbol(parameterRow.Value, countryShortName);
}
void AddPolicies()
{
//analyse all AddOn_Pol functions
foreach (CountryConfig.FunctionRow function_AddOnPolicy in
_addOnCountryConfigFacade.GetFunctionRowsBySystemIDAndFunctionName(_addOnSystemRow.ID, DefFun.AddOn_Pol))
{
if (function_AddOnPolicy.Switch.ToLower() != DefPar.Value.ON.ToLower())
{
continue;
}
//assess which policy is to be merged and whereto by interpreting the AddOnPol-function's parameters
CountryConfig.ParameterRow parameter_PolicyName = _addOnCountryConfigFacade.GetParameterRowByName(function_AddOnPolicy.ID, DefPar.AddOn_Pol.Pol_Name);
CountryConfig.ParameterRow parameter_InsertAfterPolicy = _addOnCountryConfigFacade.GetParameterRowByName(function_AddOnPolicy.ID, DefPar.AddOn_Pol.Insert_After_Pol);
CountryConfig.ParameterRow parameter_InsertBeforePolicy = _addOnCountryConfigFacade.GetParameterRowByName(function_AddOnPolicy.ID, DefPar.AddOn_Pol.Insert_Before_Pol);
CountryConfig.ParameterRow parameter_AllowDuplicates = _addOnCountryConfigFacade.GetParameterRowByName(function_AddOnPolicy.ID, "allow_duplicates");
if (parameter_PolicyName == null || (parameter_InsertAfterPolicy == null && parameter_InsertBeforePolicy == null))
{
if (parameter_PolicyName == null)
{
_errorMessages += ImportExportHelper.GenerateErrorMessage(function_AddOnPolicy,
"Compulsory parameter '" + DefPar.AddOn_Pol.Pol_Name + "' not defined.");
}
if (parameter_InsertAfterPolicy == null && parameter_InsertBeforePolicy == null)
{
_errorMessages += ImportExportHelper.GenerateErrorMessage(function_AddOnPolicy, "Compulsory parameter '" +
DefPar.AddOn_Pol.Insert_After_Pol +
"' (alternatively '" + DefPar.AddOn_Pol.Insert_Before_Pol + "') not defined.");
}
continue;
}
//search for the policy to insert in the add-on-system and for the link-policy (before/after the which the policy is to be inserted) in the just generated (copied) system
CountryConfig.PolicyRow addOnPolicy_Policy = _addOnCountryConfigFacade.GetPolicyRowByName(_addOnSystemRow.ID, parameter_PolicyName.Value);
bool before = parameter_InsertBeforePolicy != null ? true : false;
string referencePolicyName = before ? parameter_InsertBeforePolicy.Value : parameter_InsertAfterPolicy.Value;
referencePolicyName = ImportExportHelper.ReplaceCountrySymbol(referencePolicyName, _mergeCountryConfigFacade.GetCountryShortName()); //replace =cc= by country-short-name
CountryConfig.PolicyRow addOnPolicy_ReferencePolicy = _mergeCountryConfigFacade.GetPolicyRowByName(_mergeSystemRow.ID, referencePolicyName);
if (addOnPolicy_Policy == null || addOnPolicy_ReferencePolicy == null)
{
if (addOnPolicy_Policy == null)
{
_errorMessages += ImportExportHelper.GenerateErrorMessage(function_AddOnPolicy, "Unknown policy '" + parameter_PolicyName.Value + "'.");
}
if (addOnPolicy_ReferencePolicy == null)
{
_errorMessages += ImportExportHelper.GenerateErrorMessage(function_AddOnPolicy, "Unknown policy '" + referencePolicyName + "'.");
}
continue;
}
//if everything is ok, insert the policy at the indicated place
bool allowDuplicates = parameter_AllowDuplicates != null && parameter_AllowDuplicates.Value == DefPar.Value.YES;
CountryConfig.PolicyRow addOnPolicyRow = CountryConfigFacade.CopyPolicyRow(addOnPolicy_Policy,
addOnPolicy_Policy.Name,
addOnPolicy_ReferencePolicy, before,
addOnPolicy_Policy.Switch == DefPar.Value.NA,
!allowDuplicates); //unless duplicates of policies are not foreseen: keep all ids identically
//otherwise the id-references (e.g. in ChangeParam, AddOn_Par, etc.) within the add-on would not work
ImportExportHelper.ReplaceCountrySymbol(addOnPolicyRow, _mergeCountryConfigFacade.GetCountryShortName()); //replace all incidents of =cc= by country symbol
}
}
internal void AddParameterRowOfSystem(string systemID, CountryConfig.ParameterRow parameterRow)
{
_parameterRows.Add(systemID, parameterRow);
}
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 mniDescriptionAsComment_Click(object sender, EventArgs e)
{
//a(ny) system is necessary to find out which incomelists (via DefIL), constants (via DefConst) and variables (via DefVar) are defined and to gather their descriptions
TreeListColumn anySystemColumn = null;
foreach (TreeListColumn column in _mainForm.treeList.Columns)
{
if (TreeListBuilder.IsSystemColumn(column))
{
anySystemColumn = column;
break;
}
}
if (anySystemColumn == null || anySystemColumn.Tag == null)
{
return;
}
_mainForm.Cursor = Cursors.WaitCursor;
Dictionary <string, string> descriptionsILVarConst = new Dictionary <string, string>(); //gather incomelists and their description in a dictionary to be applied below
SystemTreeListTag systemTag = anySystemColumn.Tag as SystemTreeListTag;
foreach (DataSets.CountryConfig.ParameterRow ilParameterRow in systemTag.GetParameterRowsILs())
{
if (!descriptionsILVarConst.Keys.Contains(ilParameterRow.Value.ToLower()))
{
descriptionsILVarConst.Add(ilParameterRow.Value.ToLower(), systemTag.GetILTUComment(ilParameterRow));
}
}
foreach (DataSets.CountryConfig.ParameterRow parameterRow in systemTag.GetParameterRowsConstants())
{
if (!descriptionsILVarConst.Keys.Contains(parameterRow.Name.ToLower()))
{
descriptionsILVarConst.Add(parameterRow.Name.ToLower(), parameterRow.Comment);
}
}
foreach (DataSets.CountryConfig.ParameterRow parameterRow in systemTag.GetParameterRowsDefVariables())
{
if (!descriptionsILVarConst.Keys.Contains(parameterRow.Name.ToLower()))
{
descriptionsILVarConst.Add(parameterRow.Name.ToLower(), parameterRow.Comment);
}
}
//the necessary comment-changes must be gathered in an action-group (to allow for a common undo)
ActionGroup actionGroup = new ActionGroup();
//loop over the parameters of the DefIL-function to put the respective descriptions of its components in the comment column
BaseTreeListTag treeListTag = _mainForm.treeList.FocusedNode.Tag as BaseTreeListTag;
TreeListNode functionNode = treeListTag.GetDefaultParameterRow() != null ? _mainForm.treeList.FocusedNode.ParentNode : _mainForm.treeList.FocusedNode;
foreach (TreeListNode parameterNode in functionNode.Nodes)
{
CountryConfig.ParameterRow parameterRow = (parameterNode.Tag as ParameterTreeListTag).GetDefaultParameterRow();
string description = string.Empty;
if (descriptionsILVarConst.Keys.Contains(parameterRow.Name.ToLower())) //component is an incomelist, variable or constant
{
description = descriptionsILVarConst[parameterRow.Name.ToLower()];
}
else //component is a variable (defined in the variables description file)
{
description = EM_AppContext.Instance.GetVarConfigFacade().GetDescriptionOfVariable(parameterRow.Name, _mainForm.GetCountryShortName());
}
if (description != string.Empty)
{
actionGroup.AddAction(new ChangeParameterCommentAction(parameterNode, description, true, _mainForm.GetTreeListBuilder().GetCommentColumn()));
}
//else: 'name' parameter, no description or unknown component
}
if (actionGroup.GetActionsCount() > 0)
{
_mainForm.PerformAction(actionGroup, false);
}
_mainForm.Cursor = Cursors.Default;
}
void AddParameters()
{
//analyse all AddOn_Par functions
foreach (CountryConfig.FunctionRow function_AddOnParameters in
_addOnCountryConfigFacade.GetFunctionRowsBySystemIDAndFunctionName(_addOnSystemRow.ID, DefFun.AddOn_Par))
{
if (function_AddOnParameters.Switch.ToLower() != DefPar.Value.ON.ToLower())
{
continue;
}
//assess which parameters are to be merged and into which function by interpreting the AddOnPar-function's parameters
CountryConfig.ParameterRow parameter_InsertFunctionID = _addOnCountryConfigFacade.GetParameterRowByName(function_AddOnParameters.ID, DefPar.AddOn_Par.Insert_Func);
if (parameter_InsertFunctionID == null)
{
_errorMessages += ImportExportHelper.GenerateErrorMessage(function_AddOnParameters, "Compulsory parameter '" + DefPar.AddOn_Par.Insert_Func + "' not defined.");
continue;
}
//search for the function where parameters are to be added in the just generated (copied) system
CountryConfig.FunctionRow addOnParameters_InsertFunction = _mergeCountryConfigFacade.GetFunctionRowByID(parameter_InsertFunctionID.Value);
if (addOnParameters_InsertFunction == null) //take account of 'symbolic' identifier, e.g. output_std_sl_#3
{
addOnParameters_InsertFunction = ImportExportHelper.GetFunctionRowBySymbolicID(parameter_InsertFunctionID.Value, _mergeCountryConfigFacade, _mergeSystemRow.ID);
}
if (addOnParameters_InsertFunction == null)
{
_errorMessages += ImportExportHelper.GenerateErrorMessage(function_AddOnParameters, "Unknown function '" + parameter_InsertFunctionID.Value + "'.");
continue;
}
//if everything is ok, insert the parameters (all other parameters than insert_func in AddOn_Par) into the function
foreach (CountryConfig.ParameterRow addOnParameters_ParameterNameAndValue in function_AddOnParameters.GetParameterRows())
{
if (addOnParameters_ParameterNameAndValue.Name.ToLower() == DefPar.AddOn_Par.Insert_Func.ToLower())
{
continue;
}
DefinitionAdmin.Par parDef = DefinitionAdmin.GetParDefinition(addOnParameters_InsertFunction.Name, addOnParameters_ParameterNameAndValue.Name, false);
if (parDef == null)
{
_errorMessages += ImportExportHelper.GenerateErrorMessage(function_AddOnParameters,
"Function '" + addOnParameters_InsertFunction.Name + "' does not allow for parameter '" + addOnParameters_ParameterNameAndValue.Name + "'.");
continue;
}
//add parameter, however if a respective parameter with value n/a exists, it can be used
//this is even necessary for single parameters (which may only exist once) if an add-on is added more than once (i.e. there is already the n/a parameter of the first adding-on)
CountryConfig.ParameterRow parameterRow = null;
List <CountryConfig.ParameterRow> parameterList = (from pR in addOnParameters_InsertFunction.GetParameterRows()
where pR.Name.ToLower() == addOnParameters_ParameterNameAndValue.Name.ToLower() &&
pR.Group == addOnParameters_ParameterNameAndValue.Group &&
pR.Value == DefPar.Value.NA
select pR).ToList();
if (parameterList.Count != 0)
{
parameterRow = parameterList.First();
}
if (parameterRow == null)
{
parameterRow = CountryConfigFacade.AddParameterRowAtTail(addOnParameters_InsertFunction, addOnParameters_ParameterNameAndValue.Name, parDef);
}
if (parameterRow.Name.ToLower() == DefinitionAdmin.ParTypeToString(DefPar.PAR_TYPE.PLACEHOLDER).ToLower())
{
parameterRow.Name = addOnParameters_ParameterNameAndValue.Name; //for adding parameters e.g. to function DefIL
}
parameterRow.Value = addOnParameters_ParameterNameAndValue.Value;
parameterRow.Comment = addOnParameters_ParameterNameAndValue.Comment;
ImportExportHelper.ReplaceCountrySymbol(parameterRow, _mergeCountryConfigFacade.GetCountryShortName()); //replace all incidents of =cc= by country symbol
}
}
}
