private string printNode(ParamTreeNode paramParamTreeNode)
{
TreeNode[] arrayOfTreeNode = paramParamTreeNode.Path;
StringBuilder stringBuffer = new StringBuilder();
foreach (TreeNode treeNode in arrayOfTreeNode)
{
stringBuffer.Append(treeNode + ", ");
}
return(stringBuffer.ToString());
}
private ParamTreeNode getChildOfName(ParamTreeNode paramParamTreeNode, string paramString)
{
System.Collections.IEnumerator enumeration = paramParamTreeNode.children();
while (enumeration.MoveNext())
{
ParamTreeNode paramTreeNode = (ParamTreeNode)enumeration.Current;
if (paramTreeNode.UserObject.ToString().Equals(paramString))
{
return(paramTreeNode);
}
}
return(null);
}
/// <summary>
/// Attempts to bind the next argument, if one is left, or attempst to bind to
/// the final method. This is equivalent to ReflectOptimizer's EmitCallOrNextParam
/// </summary>
private bool GetFinalCallOrNextArg(int param, int outArgs, ParamTreeNode node, object val)
{
Debug.Assert(node.Methods.Count != 0);
if (param - outArgs == args.Length - 1 && GetFinalCall(param, outArgs, node.Methods[0]))
{
StoreArgument(val);
return(true);
}
if (WalkWorker(param + 1, outArgs, node))
{
StoreArgument(val);
return(true);
}
return(false);
}
private void mergeOneChild(ParamTreeNode paramParamTreeNode)
{
if (paramParamTreeNode.ChildCount == 1)
{
ParamTreeNode paramTreeNode = (ParamTreeNode)paramParamTreeNode.getChildAt(0);
System.Collections.IEnumerator enumeration1 = paramTreeNode.children();
List <object> arrayList1 = new List <object>();
while (enumeration1.MoveNext())
{
arrayList1.Add((ParamTreeNode)enumeration1.Current);
}
if (StringUtils.isNullOrBlank(paramParamTreeNode.UserObject.ToString()))
{
paramParamTreeNode.UserObject = paramTreeNode.UserObject;
}
else
{
paramParamTreeNode.UserObject = paramParamTreeNode.UserObject + ", " + paramTreeNode.UserObject;
}
paramParamTreeNode.remove(paramTreeNode);
foreach (ParamTreeNode paramTreeNode1 in arrayList1)
{
paramParamTreeNode.add(paramTreeNode1);
paramTreeNode1.Parent = paramParamTreeNode;
}
if (paramParamTreeNode.ChildCount == 1)
{
mergeOneChild(paramParamTreeNode);
return;
}
}
System.Collections.IEnumerator enumeration = paramParamTreeNode.children();
List <object> arrayList = new List <object>();
while (enumeration.MoveNext())
{
arrayList.Add((ParamTreeNode)enumeration.Current);
}
foreach (ParamTreeNode paramTreeNode in arrayList)
{
mergeOneChild(paramTreeNode);
}
}
public void UpdateParamNode(ParamTreeNode node, string user)
{
if (node.IsParam)
{
var entity = _kCaseThemeParamRepository.GetQuery()
.FirstOrDefault(t => t.Id == node.ParamId);
entity.NAME = node.Name;
entity.LASTUPDATEDBY = user;
entity.LASTUPDATEDDATE = DateTime.Now;
_kCaseThemeParamRepository.Update(entity);
}
else
{
var entity = _kCaseParamCategoryRepository.GetQuery()
.FirstOrDefault(t => t.Id == node.Id);
entity.NAME = node.Name;
entity.LASTUPDATEDBY = user;
entity.LASTUPDATEDDATE = DateTime.Now;
_kCaseParamCategoryRepository.Update(entity);
}
}
public int AddNewParamNode(int themeId, ParamTreeNode node, string user)
{
if (node.IsParam)
{
var entity = new PKS_KCASE_THEME_PARAMETER
{
NAME = node.Name,
PARAMETERTYPE = 1,
KCASEPARAMETERCATEGORYID = node.Pid.Value,
CREATEDBY = user,
CREATEDDATE = DateTime.Now,
LASTUPDATEDBY = user,
LASTUPDATEDDATE = DateTime.Now
};
_kCaseThemeParamRepository.Add(entity);
return(entity.Id);
}
else
{
var entity = new PKS_KCASE_PARAMETER_CATEGORY
{
NAME = node.Name,
LEVELNUMBER = 1,
ORDERNUMBER = 1,
PARENTID = null,
KCASETHEMEID = themeId,
CREATEDBY = user,
CREATEDDATE = DateTime.Now,
LASTUPDATEDBY = user,
LASTUPDATEDDATE = DateTime.Now
};
var query = _kCaseParamCategoryRepository.GetQuery().Where(t => t.LEVELNUMBER == entity.LEVELNUMBER);
if (query != null && query.Count() > 0)
{
entity.ORDERNUMBER = query.Max(t => t.ORDERNUMBER) + 1;
}
_kCaseParamCategoryRepository.Add(entity);
return(entity.Id);
}
}
/// <summary>
/// Attempts to bind the remaining (extra) parameters into a params array.
/// </summary>
private bool GetBoundToParams(int param, int outArgs, ParamTreeNode root)
{
for (int i = 0; i < root.Methods.Count; i++)
{
if (!root.Methods[i].IsParamsMethod)
{
continue;
}
ParameterInfo[] pis = root.Methods[i].GetParameters();
Conversion conv;
object val = TryConvert(GetArgument(param - outArgs), pis[pis.Length - 1].ParameterType.GetElementType(), out conv);
if (conv != Conversion.None)
{
if (param - outArgs == args.Length - 1 && GetFinalCall(param, outArgs, root.Methods[i]))
{
StoreArgument(val);
return(true);
}
if (GetBoundToParams(param + 1, outArgs, root))
{
StoreArgument(val);
return(true);
}
}
else if (param - outArgs == args.Length - 1 && GetArgument(param) == null)
{
// explicitly passing null to the params array, ok...
if (GetFinalCall(param, outArgs, root.Methods[i]))
{
curArg--;
return(true);
}
}
}
return(false);
}
/// <summary>
/// Attempts to bind the remaining (missing) parameters from default values. Default values
/// also include a virtual-default as an empty params array.
/// </summary>
private bool GetBoundToDefaults(int param, int outArgs, ParamTreeNode root)
{
for (int i = 0; i < root.Methods.Count; i++)
{
int curParam = param;
int curOut = outArgs;
// skip any remaining out params...
ParameterInfo[] pis = root.Methods[i].GetParameters();
while (curParam < root.Methods[i].SigLength && (pis[curParam].IsOut && !pis[curParam].IsIn))
{
curOut++;
curParam++;
}
if (curParam >= root.Methods[i].SigLength - 1 && root.Methods[i].IsParamsMethod)
{
// rest of the values go to the params method...
// no arguments for parameter array, we default to an empty one
if (GetFinalCall(curParam, curOut, root.Methods[i]))
{
return(true);
}
}
else if (curParam < root.Methods[i].GetParameters().Length&&
(pt.ArgumentCount - root.Methods[i].DefaultCount) == curParam)
{
// rest of the values are defaults...
if (GetFinalCallOrNextArg(curParam, curOut, root, root.Methods[i].GetParameters()[curParam].DefaultValue))
{
return(true);
}
}
}
// no binding available.
return(false);
}
private void constructTreeFromDescs(ParamTreeNode paramParamTreeNode, IList <string> paramList)
{
foreach (string str in paramList)
{
ParamTreeNode paramTreeNode = paramParamTreeNode;
string[] arrayOfString = str.ToUpper().Split(", ", true);
foreach (string str1 in arrayOfString)
{
ParamTreeNode paramTreeNode1 = getChildOfName(paramTreeNode, str1);
if (paramTreeNode1 != null)
{
paramTreeNode = paramTreeNode1;
}
else
{
paramTreeNode1 = new ParamTreeNode(this, str1);
paramTreeNode.add(paramTreeNode1);
paramTreeNode1.Parent = paramTreeNode;
paramTreeNode = paramTreeNode1;
}
}
}
mergeOneChild(paramParamTreeNode);
}
private IList <ParamItemInputTable> createInputList(Session paramSession, IList <ParamItemTable> paramList)
{
sbyte b = 1;
int i = 1;
string str = "Param";
this.b_hasCostBooks = false;
this.o_missingStr = null;
List <object> arrayList1 = new List <object>();
List <object> arrayList2 = new List <object>();
List <object> arrayList3 = new List <object>();
foreach (ParamItemTable paramItemTable in paramList)
{
paramItemTable = (ParamItemTable)paramSession.load(typeof(ParamItemTable), paramItemTable.Id);
string str1 = paramItemTable.Title.ToUpper();
str1 = StringUtils.replaceAll(str1, " ", "");
str1 = StringUtils.replaceAll(str1, ",", "");
str1 = StringUtils.replaceAll(str1, "\"", "''");
System.Collections.IList list = (System.Collections.IList) this.o_descToAccessRightsMap[str1];
if (list == null)
{
list = new List <object>();
this.o_descToAccessRightsMap[str1] = list;
}
if (!list.Contains(paramItemTable.AccessRights))
{
list.Add(paramItemTable.AccessRights);
}
arrayList3.Add(StringUtils.replaceAll(paramItemTable.Title, "\"", "''"));
foreach (ParamItemInputTable paramItemInputTable1 in paramItemTable.InputSet)
{
if (paramItemInputTable1.SortOrder.Value > i)
{
i = paramItemInputTable1.SortOrder.Value;
}
if (arrayList2.Contains(paramItemInputTable1.Name))
{
continue;
}
arrayList2.Add(paramItemInputTable1.Name);
ParamItemInputTable paramItemInputTable2 = (ParamItemInputTable)paramItemInputTable1.clone();
arrayList1.Add(paramItemInputTable2);
}
}
i++;
this.o_rootNode = new ParamTreeNode(this, "", "");
constructTreeFromDescs(this.o_rootNode, arrayList3);
StringBuilder stringBuffer = new StringBuilder();
stringBuffer.Append("SUBSTITUTE(SUBSTITUTE(CONCATENATE(");
System.Collections.IEnumerator enumeration = this.o_rootNode.preorderEnumeration();
bool @bool = true;
while (enumeration.MoveNext())
{
ParamTreeNode paramTreeNode1 = (ParamTreeNode)enumeration.Current;
ParamTreeNode paramTreeNode2 = (ParamTreeNode)paramTreeNode1.Parent;
if (paramTreeNode1.Leaf)
{
continue;
}
if (!@bool)
{
stringBuffer.Append(",");
}
else
{
@bool = false;
}
if (paramTreeNode1.ChildCount > 1)
{
StringBuilder stringBuffer1 = new StringBuilder();
string str1 = "";
for (sbyte b1 = 0; b1 < paramTreeNode1.ChildCount; b1++)
{
ParamTreeNode paramTreeNode = (ParamTreeNode)paramTreeNode1.getChildAt(b1);
if (b1 != 0)
{
stringBuffer1.Append("\n");
str1 = paramTreeNode.UserObject.ToString();
}
stringBuffer1.Append(paramTreeNode.UserObject.ToString());
}
paramTreeNode1.ParamName = str + b;
ParamItemInputTable paramItemInputTable1 = new ParamItemInputTable();
paramItemInputTable1.Name = paramTreeNode1.ParamName;
paramItemInputTable1.DataType = "datatype.list";
paramItemInputTable1.DefaultValue = "";
if (paramTreeNode1.Level == 0)
{
paramItemInputTable1.DependencyStatement = "";
}
else
{
string str2 = ((ParamTreeNode)paramTreeNode1.Parent).ParamName;
string str3 = str2 + "=\"" + paramTreeNode1.UserObject.ToString().ToUpper() + "\"";
str3 = "AND(ARG_SHOWING(\"" + str2 + "\")," + str3 + ")";
paramItemInputTable1.DependencyStatement = str3;
}
paramItemInputTable1.ValidationStatement = "";
paramItemInputTable1.Description = "";
paramItemInputTable1.Grouping = "A. Specification";
paramItemInputTable1.SelectionList = stringBuffer1.ToString().ToUpper();
paramItemInputTable1.SortOrder = Convert.ToInt32(i);
paramItemInputTable1.Pblk = false;
paramItemInputTable1.Hidden = false;
arrayList1.Add(paramItemInputTable1);
stringBuffer.Append("\n IF(ARG_SHOWING(\"" + paramItemInputTable1.Name + "\")," + paramItemInputTable1.Name + ",\"\")");
b++;
i++;
continue;
}
if (paramTreeNode1.ChildCount == 1)
{
ParamItemInputTable paramItemInputTable1 = new ParamItemInputTable();
paramItemInputTable1.Name = str + b;
paramItemInputTable1.DataType = "datatype.calcvalue";
if (paramTreeNode1.Level == 0)
{
paramItemInputTable1.DependencyStatement = "";
}
else
{
string str1 = ((ParamTreeNode)paramTreeNode1.Parent).ParamName;
string str2 = str1 + "=\"" + paramTreeNode1.UserObject.ToString().ToUpper() + "\"";
str2 = "AND(ARG_SHOWING(\"" + str1 + "\")," + str2 + ")";
paramItemInputTable1.DependencyStatement = str2;
}
paramItemInputTable1.ValidationStatement = "T(\"" + paramTreeNode1.getChildAt(0).ToString().ToUpper() + "\")";
paramItemInputTable1.Description = "";
paramItemInputTable1.Grouping = "A. Specification";
paramItemInputTable1.SelectionList = "";
paramItemInputTable1.SortOrder = Convert.ToInt32(i);
paramItemInputTable1.Pblk = false;
paramItemInputTable1.Hidden = false;
arrayList1.Add(paramItemInputTable1);
stringBuffer.Append("\n IF(ARG_SHOWING(\"" + paramItemInputTable1.Name + "\")," + paramItemInputTable1.Name + ",\"\")");
b++;
i++;
}
}
stringBuffer.Append("\n),\" \",\"\"),\",\",\"\")");
ParamItemInputTable paramItemInputTable = new ParamItemInputTable();
paramItemInputTable.Name = "Result";
paramItemInputTable.DataType = "datatype.calcvalue";
paramItemInputTable.DefaultValue = "";
paramItemInputTable.DependencyStatement = "";
paramItemInputTable.ValidationStatement = stringBuffer.ToString();
paramItemInputTable.Description = "";
paramItemInputTable.Grouping = "A. Specification";
paramItemInputTable.SelectionList = "";
paramItemInputTable.SortOrder = Convert.ToInt32(i++);
b++;
paramItemInputTable.Pblk = false;
paramItemInputTable.Hidden = true;
arrayList1.Add(paramItemInputTable);
this.o_missingStr = this.o_rootNode.UserObject.ToString();
this.o_missingStr = StringUtils.replaceAll(this.o_missingStr, " ", "");
this.o_missingStr = StringUtils.replaceAll(this.o_missingStr, ",", "");
this.o_missingStr = StringUtils.replaceAll(this.o_missingStr, "\"", "''");
System.Collections.IEnumerator iterator = this.o_descToAccessRightsMap.Keys.GetEnumerator();
List <object> arrayList4 = new List <object>();
while (iterator.MoveNext())
{
string str1 = (string)iterator.Current;
System.Collections.IList list = (System.Collections.IList) this.o_descToAccessRightsMap[str1];
if (list.Count > 1)
{
str1 = str1.Substring(this.o_missingStr.Length);
ParamItemInputTable paramItemInputTable1 = constructCostBookByAccessRights(str1, list, i++, b++);
arrayList4.Add(paramItemInputTable1);
arrayList1.Add(paramItemInputTable1);
}
}
if (arrayList4.Count != 0)
{
this.b_hasCostBooks = true;
StringBuilder stringBuffer1 = new StringBuilder();
sbyte b1 = 0;
foreach (ParamItemInputTable paramItemInputTable1 in arrayList4)
{
stringBuffer1.Append("IF(ARG_SHOWING(\"" + paramItemInputTable1.Name + "\")," + paramItemInputTable1.Name + ",");
b1++;
}
stringBuffer1.Append("\"ALL\"");
for (sbyte b2 = 0; b2 < b1; b2++)
{
stringBuffer1.Append(")");
}
paramItemInputTable = new ParamItemInputTable();
paramItemInputTable.Name = "CostBook";
paramItemInputTable.DataType = "datatype.calcvalue";
paramItemInputTable.DefaultValue = "";
paramItemInputTable.DependencyStatement = "";
paramItemInputTable.ValidationStatement = stringBuffer1.ToString();
paramItemInputTable.Description = "";
paramItemInputTable.Grouping = "A. Specification";
paramItemInputTable.SelectionList = "";
paramItemInputTable.SortOrder = Convert.ToInt32(i++);
paramItemInputTable.Pblk = false;
paramItemInputTable.Hidden = true;
arrayList1.Add(paramItemInputTable);
StringBuilder stringBuffer2 = new StringBuilder();
iterator = this.o_costBooksMap.Values.GetEnumerator();
b1 = 0;
while (iterator.MoveNext())
{
string str1 = (string)iterator.Current;
foreach (string str2 in this.o_costBooksMap.Keys)
{
if (((string)this.o_costBooksMap[str2]).Equals(str1))
{
stringBuffer2.Append("IF(CostBook=\"" + str1 + "\",\"" + str2 + "\",\n");
b1++;
}
}
}
if (b1 > 0)
{
stringBuffer2.Append("\"ALL\"");
for (sbyte b3 = 0; b3 < b1; b3++)
{
stringBuffer2.Append(")");
}
}
paramItemInputTable = new ParamItemInputTable();
paramItemInputTable.Name = "CostBookAlias";
paramItemInputTable.DataType = "datatype.calcvalue";
paramItemInputTable.DefaultValue = "";
paramItemInputTable.DependencyStatement = "";
paramItemInputTable.ValidationStatement = stringBuffer2.ToString();
paramItemInputTable.Description = "";
paramItemInputTable.Grouping = "A. Specification";
paramItemInputTable.SelectionList = "";
paramItemInputTable.SortOrder = Convert.ToInt32(i++);
paramItemInputTable.Pblk = false;
paramItemInputTable.Hidden = true;
arrayList1.Add(paramItemInputTable);
}
return(resortGroupsInList(arrayList1));
}
public RetryInfo(Conversion conv, ParamTreeNode node, object value)
{
Conversion = conv;
Node = node;
ConvertedValue = value;
}
/// <summary>
/// Creates the retry list (if necessary) and adds a conversion to the list. This
/// is equivalent to ReflectOptimizer's EmitUpdateRetryList.
/// </summary>
private static List <RetryInfo> UpdateRetryList(object val, List <RetryInfo> retryList, ParamTreeNode node, Conversion conv)
{
if (retryList == null)
{
retryList = new List <RetryInfo>();
}
// Update the retry list...
bool fFound = false;
for (int i = 0; i < retryList.Count; i++)
{
if (retryList[i].Conversion > conv)
{
retryList.Insert(i, new RetryInfo(conv, node, val));
fFound = true;
break;
}
}
if (!fFound)
{
retryList.Add(new RetryInfo(conv, node, val));
}
return(retryList);
}
/// <summary>
/// Walks an argument in the tree, recursing to further arguments to perform the dispatch
/// as necessary. the walk initially starts at either 0 (no instance) or -1 (instance
/// available).
/// </summary>
private bool WalkWorker(int param, int outArgs, ParamTreeNode root)
{
object val;
List <RetryInfo> retryList = null;
if (param - outArgs >= args.Length)
{
return(GetBoundToDefaults(param, outArgs, root));
}
if (root.Children.Count == 0)
{
return(GetBoundToParams(param, outArgs, root));
}
foreach (ParamTreeNode node in root.Children)
{
if (node.ParamType == null)
{
continue; // method w/ less arguments then we're providing...
}
if ((node.Flags & ParamTree.NodeFlags.Out) != 0)
{
if (WalkWorker(param + 1, outArgs + 1, node))
{
return(true);
}
continue;
}
Conversion conv;
val = TryConvert(GetArgument(param - outArgs), node.ParamType, out conv);
if (conv == Conversion.Identity)
{
// nothing can beat us, dispatch now...
if (GetFinalCallOrNextArg(param, outArgs, node, val))
{
return(true);
}
// this method fails dispatch on later argument, don't put it
// in the retry list.
continue;
}
if (conv == Conversion.None)
{
if (node.ParamType != typeof(InstanceArgument) || GetArgument(param) == null)
{
continue;
}
// mixed method/function dispatch, we're calling an unbound method w/
// the 1st parameter matching the declaring type. We favor calling the
// static method so this will get an Implicit conversion level.
val = TryConvert(GetArgument(param), node.Methods[0].DeclaringType, out conv);
if (conv == Conversion.Identity)
{
conv = Conversion.Implicit;
}
}
retryList = UpdateRetryList(val, retryList, node, conv);
}
if (retryList != null && HandleNonIdentityConversion(param, outArgs, retryList))
{
return(true);
}
return(GetBoundToParams(param, outArgs, root));
}
