private static MethodParameterMap AddParameterMap(MapedObject aMap, InfoMap aPair, String methodName, Guid id, int paramCount)
{
var methodParams = aMap.MethodParameters.Where(x => x.MethodName.Equals(methodName) && x.ID == id).FirstOrDefault();
if (methodParams == null)
{
methodParams = new MethodParameterMap();
methodParams.MethodName = methodName;
methodParams.ParameterCount = paramCount;
if (aPair.RuleBased)
{
methodParams.ParameterMaps.Add((ParameterMap)aPair);
}
else
{
methodParams.ColumnParameterMaps.Add((ParameterColumnMap)aPair);
}
aMap.MethodParameters.Add(methodParams);
}
else if (aPair.RuleBased)
{
methodParams.ParameterMaps.Add((ParameterMap)aPair);
}
else if (!aPair.RuleBased)
{
methodParams.ColumnParameterMaps.Add((ParameterColumnMap)aPair);
}
return(methodParams);
}
public static List <Object[]> BuildParameterArrayList(ViableMapAndData aMap, string methodName)
{
List <Object[]> parameterList = new List <object[]>();
var methodStores = aMap.StoredData.Where(x => x.MapType.Equals(DataMapType.MethodParameterMap));
if (methodStores.Any())
{
var parameterStores = methodStores.Where(x => x.DataStoreName.Equals(methodName));
if (parameterStores != null)
{
foreach (DataStore aStore in parameterStores)
{
if (aStore.ActualData != null)
{
MethodParameterMap aParamMap = ParameterExtruder.GetParameterMap(methodName, aMap.TheMap, aStore.ActualData.Columns.Count);
foreach (DataRow aRow in aStore.ActualData.Rows)
{
object[] parameters = ParameterExtruder.ExtractParameters(aParamMap, aRow);
parameterList.Add(parameters);
}
}
else
{
parameterList.Add(null);
}
}
}
}
return(parameterList);
}
private void AddMapRows(MethodParameterMap map)
{
lstMapDetails.Items.Clear();
foreach (ParameterMap aMap in map.ParameterMaps)
{
ListViewItem anItem = new ListViewItem(aMap.ParameterName);
anItem.SubItems.Add(new ListViewItem.ListViewSubItem(anItem, aMap.DataType));
anItem.SubItems.Add(new ListViewItem.ListViewSubItem(anItem, aMap.IsNullable.ToString()));
lstMapDetails.Items.Add(anItem);
}
}
public static String[] GetParameterNames(MethodParameterMap aMap)
{
string[] results = null;
if (aMap.ColumnParameterMaps.Count > 0)
{
results = aMap.ColumnParameterMaps.Select(x => x.DataType + " " + x.ParameterName).ToArray();
}
else if (aMap.ParameterMaps.Count > 0)
{
results = aMap.ParameterMaps.Select(x => x.DataType + " " + x.ParameterName).ToArray();
}
return(results);
}
/// <summary>
/// This allows for an existing map to be edited
/// </summary>
/// <param name="review"></param>
/// <param name="_rules"></param>
/// <param name="methodName"></param>
/// <param name="paramCount"></param>
/// <param name="mode"></param>
public UIMapper(MapedObject review, List <IDataRule> _rules, MethodParameterMap methodMap, DataMapType mode)
: this()
{
if (_rules.Count > 0)
{
_aMap = review;
MethodMap = methodMap;
lblMethodName.Text = methodMap.MethodName;
lblClassName.Text = review.ClassName;
//var aMethod = review.MethodParameters.Where(x => x.MethodName.Equals(methodName) && x.ID == id).FirstOrDefault();
LoadParameterMaps(methodMap.ParameterMaps, _rules);
SetDisplayMode(mode);
}
}
public static Object[] ExtractParameters(MethodParameterMap paramMap, DataRow aRow)
{
Object[] parameters = new Object[paramMap.ParameterCount];
if (paramMap.ColumnParameterMaps.Count > 0)
{
ExtractColumnParameters(parameters, paramMap.ColumnParameterMaps, aRow);
}
else if (paramMap.ParameterMaps.Count > 0)
{
ExtractColumnParameters(parameters, paramMap.ParameterMaps, aRow);
}
else
{
parameters = null;
}
return(parameters);
}
private void UIMappEdit(MapedObject review, MethodParameterMap methodMap, DataMapType mode)
{
InitializeComponent();
_aMap = review;
MethodMap = methodMap;
if (methodMap != null)
{
lblMethodName.Text = methodMap.MethodName;
}
lblClassName.Text = review.ClassName;
switch (mode)
{
case DataMapType.PropertyColumnMap:
LoadColumnsFromMap(review.PropMaps);
break;
case DataMapType.FieldColumnMap:
LoadColumnsFromMap(review.FieldMaps);
break;
case DataMapType.MethodParameterMap:
//var method = review.MethodParameters.Where(x => x.MethodName.Equals(methodName) && x.ID == id).FirstOrDefault();
if (methodMap != null)
{
if (methodMap.ParameterMaps.Any())
{
//LoadParameterMaps(method.ParameterMaps)
}
else if (methodMap.ColumnParameterMaps.Any())
{
LoadColumnsFromMap(methodMap.ColumnParameterMaps);
}
}
break;
}
allowSwitching = true;
SetDisplayMode(mode);
}
private static void BuildParamTemplate(MethodParameterMap aMap, DataRow aRow, List <String> results, string customName, string className, bool declareClass = false)
{
string period = ".";
string aSpace = " ";
if (!declareClass)
{
aSpace = String.Empty;
}
StringBuilder result = new StringBuilder();
int count = 0;
string method = "{0}{1}{2}{3}{4}({5});";
foreach (ParameterColumnMap cMap in aMap.ColumnParameterMaps)
{
result.Append(BuildParameterTemplate.BuildTemplate(aRow, cMap));
}
string parameters = result.ToString();
int indx = parameters.LastIndexOf(",");
parameters = parameters.Remove(indx);
if (aMap.MethodName == ".ctor")
{
string preFix = String.Empty;
if (declareClass)
{
preFix = className;
}
results.Add(string.Format(method, preFix, aSpace, customName, " = new ", className, parameters));
count++;
}
else
{
results.Add(string.Format(method, customName, period, aMap.MethodName, "", "", parameters));
}
}
public static String FormParameterMethod(MethodParameterMap aMap)
{
string[] paramNames = GetParameterNames(aMap);
return(String.Format("{0}({1})", aMap.MethodName, String.Join(", ", from paramName in paramNames select paramName)));
}
public UIMapper(MapedObject review, MethodParameterMap methodMap, DataMapType mode)
: this()
{
UIMappEdit(review, methodMap, mode);
}
