static internal void ReplaceCountrySymbol(CountryConfig.FunctionRow functionRow, string countryShortName) { foreach (CountryConfig.ParameterRow parameterRow in functionRow.GetParameterRows()) { ReplaceCountrySymbol(parameterRow, countryShortName); } }
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); } }
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); } }
static internal string GetSymbolicID(CountryConfig.FunctionRow functionRow, string replaceCountryShortName = "") { //for functions DefIL and DefTU use a more practical and less insecure identifier than display order, i.e. the name if (functionRow.Name.ToLower() == DefFun.DefIl.ToLower() || functionRow.Name.ToLower() == DefFun.DefTu.ToLower()) { foreach (CountryConfig.ParameterRow parameterRow in functionRow.GetParameterRows()) { if (parameterRow.Name.ToLower() == DefPar.DefIl.Name.ToLower()) { string symbolicID = parameterRow.Value; //replace country symbol in taxunit name if required (e.g. tu_individual_sl -> tu_individua_=cc=) if (replaceCountryShortName != string.Empty && functionRow.Name.ToLower() == DefFun.DefTu.ToLower() && symbolicID.ToLower().EndsWith(replaceCountryShortName.ToLower())) { symbolicID = symbolicID.Substring(0, symbolicID.Length - replaceCountryShortName.Length) + DefPar.Value.PLACEHOLDER_CC; } return(GetSymbolicID(functionRow.PolicyRow, replaceCountryShortName) + _symbolicID_OrderSeparator + symbolicID); //e.g. ILDef_sl_#ils_dispy for the function defining ils_dispy in policy ILDef_sl } } //should not happen, but if no name-parameter found still use order } //for all other functions use display order return(GetSymbolicID(functionRow.PolicyRow, replaceCountryShortName) + _symbolicID_OrderSeparator + OrderToDisplayOrder(functionRow)); //e.g. ILDef_sl_#10 for the 10th function in policy ILDef_sl }
private int GetMaxGroupUsedByFunction(CountryConfig.FunctionRow functionRow, string groupName) { int maxGroup = 0; List <string> potentialGroupPars = new List <string>(); DefinitionAdmin.Fun fun = DefinitionAdmin.GetFunDefinition(functionRow.Name, false); if (fun != null) // find all parameters belonging to this group, e.g. functionRow.Name=BenCalc, groupName=Comp_X: { // find: Comp_PerTU, Comp_PerElig, Comp_Cond, Comp_LowLim, Comp_UpLim var pgs = from pg in fun.GetGroupParList() where pg.groupName.ToLower() == groupName.ToLower() select pg; if (pgs.Count() > 0) // this should always be fulfilled (i.e. the function has such a group) { foreach (var p in pgs.First().par) { potentialGroupPars.Add(p.Key.ToLower()); foreach (string s in p.Value.substitutes) { potentialGroupPars.Add(s); } } } } foreach (CountryConfig.ParameterRow countryConfigParameterRow in functionRow.GetParameterRows()) { if (countryConfigParameterRow.Group == string.Empty || !EM_Helpers.IsNonNegInteger(countryConfigParameterRow.Group)) { continue; //no group parameter } if (!potentialGroupPars.Contains(countryConfigParameterRow.Name.ToLower()) && !IsPlaceholderSibling(countryConfigParameterRow, potentialGroupPars)) { continue; //no sibling } if (EM_Helpers.SaveConvertToInt(countryConfigParameterRow.Group) > maxGroup) { maxGroup = EM_Helpers.SaveConvertToInt(countryConfigParameterRow.Group); } } return(maxGroup); }
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 } } }
internal void UpdateContent(TreeListNode focusedNode) { try { if (_inApplyAction) { return; } _displayedFunctionRow = null; _focusedNode = focusedNode; //needed to know where to put the parameters within the function if (_focusedNode != null && _focusedNode.Tag != null) { _displayedFunctionRow = (_focusedNode.Tag as BaseTreeListTag).GetDefaultFunctionRow(); //selected function or function where selected parameter is part of (null if policy selelcted) } ClearContent(); //empty controls and activate/deactivate corresponding to whether a function is selected in the tree or not if (_displayedFunctionRow == null) { return; //no function selected in tree } lblFunction.Text = _displayedFunctionRow.Name + " (order: " + _displayedFunctionRow.Order + ") in policy " + _displayedFunctionRow.PolicyRow.Name; Dictionary <string, string> groupList = new Dictionary <string, string>(); //helper list for group parameters foreach (AddParameterTag apt in GetFullParList(_displayedFunctionRow.Name)) { string parName = apt._parName; DefinitionAdmin.Par parDef = apt._parDef; string groupName = apt._parGroup == null ? string.Empty : apt._parGroup.groupName; bool isGroup = apt._parGroup != null; //parameter belongs/doesn't belong to a group; does: comp_Cond, comp_perTU bool isSingle = parDef.maxCount == 1; //parameter can/cannot be used more than once; can: DefOuput/Var, cannot: TAX_UNIT bool isFootnote = parDef.isFootnote; //parameter is/isn't a footnote parameter; is: #_UpLim, #_Amount bool isConflict = parDef.substitutes.Count > 0; //parameter has/hasn't a Substitute; has: Output_Var / Output_Add_Var bool isIn = false; //parameter isn't ... foreach (CountryConfig.ParameterRow countryConfigParameterRow in _displayedFunctionRow.GetParameterRows()) { if (countryConfigParameterRow.Name.ToLower() == parName.ToLower()) { isIn = true; //.. is already used in the function break; } } string subsitude = string.Empty; string groupOrNo = string.Empty; string count = string.Empty; if (isSingle && !isGroup && !isFootnote && isIn) { continue; //parameter is already used (and multi use is not possible) } if (!isSingle || isGroup || isFootnote) { count = "1"; //as default multiple useable parameter is added once } if (isGroup) //group parameter, e.g. comp_Cond, comp_perTU { //propse the likely group identifier, i.e. the next available number if (groupList.Keys.Contains(groupName.ToLower())) { groupOrNo = groupList[groupName.ToLower()]; //for all group parameters of the same group the same group identifier is proposed } else { int maxGroup = GetMaxGroupUsedByFunction(_displayedFunctionRow, groupName) + 1; groupOrNo = maxGroup.ToString(); groupList.Add(groupName.ToLower(), groupOrNo); } } if (isFootnote) //footnote parameter, e.g. #_UpLim, #_Amount { //propse the likely footnote identifier, i.e. the next available number groupOrNo = (CountryConfigFacade.GetMaxFootnoteUsedByFunction(_displayedFunctionRow, parName) + 1).ToString(); } if (isConflict && !isGroup) {//if e.g. output_var is already used, still show output_add_var, but put out_var in substitute column TreeListNode functionNode = ((focusedNode.Tag as BaseTreeListTag).GetDefaultParameterRow() == null) ? focusedNode : focusedNode.ParentNode; foreach (TreeListNode parameterNode in functionNode.Nodes) { string parameterName = parameterNode.GetDisplayText(TreeListBuilder._policyColumnName); foreach (string conflictPar in parDef.substitutes) { if (parameterName.ToLower() == conflictPar.ToLower()) { subsitude = parameterName; apt._parameterNode = parameterNode; break; } } if (subsitude != string.Empty) { break; } } } int index = dgvParameter.Rows.Add(false, parName, subsitude, groupOrNo, count, parDef.description); dgvParameter.Rows[index].Tag = apt; } ShowHideRows(); dgvParameter.Select(); } catch (Exception exception) { UserInfoHandler.ShowException(exception); } }
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 AddILToMatrix(string ILName, CountryConfig.FunctionRow ILDefFunctionRow, Dictionary <string, CountryConfig.FunctionRow> ILNamesAndILDefFunctionRows, ref Dictionary <string, Dictionary <string, double> > matrix, double inhertitedFactor = 1) { foreach (CountryConfig.ParameterRow ILDefParameterRow in ILDefFunctionRow.GetParameterRows()) { if (ILDefParameterRow.Name.ToLower() == DefPar.DefIl.Name.ToLower()) { continue; } string ILEntry = string.Empty; double factor = 0; //new style: incomelist entry (i.e. variable or incomelist) stored in parameter.Name, factor stored in parameter.Value if (EM_Helpers.IsNumeric(ILDefParameterRow.Value) || ILDefParameterRow.Value == "+" || ILDefParameterRow.Value == "-") { if (ILDefParameterRow.Value == "+") { factor = inhertitedFactor; } else if (ILDefParameterRow.Value == "-") { factor = inhertitedFactor * -1.0; } else { factor = inhertitedFactor * EM_Helpers.SaveConvertToDouble(ILDefParameterRow.Value); } ILEntry = ILDefParameterRow.Name.ToLower(); } //old style: incomelist entry (i.e. variable or incomelist) stored in parameter.Value, +/- stored in parameter.Name, factor stored in parameter.Group else { if (ILDefParameterRow.Group == string.Empty) { factor = inhertitedFactor; } else { factor = inhertitedFactor * EM_Helpers.SaveConvertToDouble(ILDefParameterRow.Group); //either there is a factor in the group column or factor is 1 } if (ILDefParameterRow.Name.StartsWith("-")) { factor = inhertitedFactor * (-1); } else if (!ILDefParameterRow.Name.StartsWith("+")) { continue; //should not happen } ILEntry = ILDefParameterRow.Value.ToLower(); } if (ILNamesAndILDefFunctionRows.Keys.Contains(ILEntry)) { AddILToMatrix(ILName, ILNamesAndILDefFunctionRows[ILEntry], ILNamesAndILDefFunctionRows, ref matrix, factor); //recursive call: break incomelist down in its variables } else { if (!matrix.Keys.Contains(ILEntry)) {//variable not yet in matrix: add a variable-row with a column for each incomelist (cell is empty if variable is not contained in an incomelist) Dictionary <string, double> variableNamesAndInitialValues = new Dictionary <string, double>(); foreach (string variableName in ILNamesAndILDefFunctionRows.Keys) { variableNamesAndInitialValues.Add(variableName, 0); } matrix.Add(ILEntry, variableNamesAndInitialValues); } matrix[ILEntry][ILName] += factor; } } }