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);
}
private void mnuCustomMap_Click(object sender, EventArgs e)
{
UIMapper manualMapping = null;
MapedObject aMapObject = null;
MapManager.FindOrCreateMap(projectView, lstVwAssemblies.SelectedItems[0].SubItems[2].Text, ref aMapObject);
if ((rbFields.Checked || rbProperties.Checked) && lstVwObjectView.SelectedItems.Count > 0)
{
//MapManager.FindOrCreateMap(projectView, lstVwAssemblies.SelectedItems[0].SubItems[2].Text, ref aMapObject);
manualMapping = new UIMapper(aMapObject, lstVwObjectView.SelectedItems, dgTableView.SelectedRows, currentMode);
}
else if (lstVwObjectView.SelectedItems.Count > 0)
{
//MapManager.FindOrCreateMap(projectView, lstVwAssemblies.SelectedItems[0].SubItems[2].Text, ref aMapObject);
//string theparams = String.Empty;
//if (rbConstructors.Checked)
// theparams = lstVwObjectView.SelectedItems[0].SubItems[1].Text;
//else
// theparams = lstVwObjectView.SelectedItems[0].SubItems[2].Text;
//string[] parameters = theparams.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
//manualMapping = new UIMapper(aMapObject, lstVwObjectView.SelectedItems[0].SubItems[0].Text, Parameters.ParseString(parameters), dgTableView.SelectedRows, currentMode);
manualMapping = CreateParamsMapper(aMapObject);
}
ApplyField(manualMapping);
if (dgTableView.Tag != null)
{
StoreDataTable(this, (exportControlEventArgs)dgTableView.Tag);
}
}
public static MapedObject LoadObjectOnly(string fileName)
{
MapedObject loadObject = null;
FileSerializations.FileDeserialization(fileName, ref loadObject);
return(loadObject);
}
public static MethodParameterMap MapToParameters(ListViewItem aItem, MapedObject aMap, String methodName, int parameterCount, Guid id, bool ruleBased)
{
ParameterMap aRuleField = new ParameterMap();
aRuleField.DataType = aItem.SubItems[2].Text;
aRuleField.IsNullable = bool.Parse(aItem.SubItems[4].Text);
aRuleField.ParameterName = aItem.SubItems[1].Text;
aRuleField.RuleBased = ruleBased;
return(AddParameterMap(aMap, aRuleField, methodName, id, parameterCount));
}
public UIMapper(MapedObject aMap, ListView.SelectedListViewItemCollection objectView, DataGridViewSelectedRowCollection dataRows, DataMapType displayMode)
: this()
{
InitializeComponent();
_aMap = aMap;
lblClassName.Text = aMap.ClassName;
LoadFromDataGrid(dataRows);
LoadTargetFieldsOrProperties(objectView);
Result = null;
SetDisplayMode(displayMode);
}
public UIMapper(MapedObject aMap, string methodName, List <Parameters> objectView, DataGridViewSelectedRowCollection dataRows, DataMapType displayMode)
: this()
{
InitializeComponent();
lblMethodName.Text = methodName;
lblClassName.Text = aMap.ClassName;
LoadFromDataGrid(dataRows);
LoadTargetParameters(objectView);
_aMap = aMap;
Result = null;
SetDisplayMode(displayMode);
}
public static void InitializeFields(dynamic currentObject, MapedObject anObject, DataRow aRow)
{
List <FieldInfo> allFields = AssemblyAccessor.GetClassFields(currentObject.GetType(), anObject.FieldMaps);
foreach (FieldColumnMap aMap in anObject.FieldMaps)
{
FieldInfo aField = allFields.Where(x => x.Name.Equals(aMap.FieldName)).FirstOrDefault();
if (aField != null)
{
aField.SetValue(currentObject, aRow.Field <object>(aMap.ColumnName));
}
}
}
public static void InitializeProperties(dynamic currentObject, MapedObject anObject, DataRow aRow)
{
List <PropertyInfo> allProps = AssemblyAccessor.GetClassProperties(currentObject.GetType(), anObject.PropMaps);
foreach (PropertyColumnMap aMap in anObject.PropMaps)
{
PropertyInfo aProp = allProps.Where(x => x.Name.Equals(aMap.PropertyName)).FirstOrDefault();
if (aProp != null)
{
aProp.SetValue(currentObject, aRow.Field <object>(aMap.ColumnName), null);
}
}
}
public static List <String> CreateTemplateNoParams(DataTable dg, MapedObject map, String storeName, String customName)
{
List <String> result = new List <string>();
if (String.IsNullOrEmpty(customName))
{
customName = String.Format("_{0}", NameSpaceManager.RemoveNameSpace(map.ClassName).ToLower());
}
string createObject = String.Format("{0} {1} = new {0}();", NameSpaceManager.RemoveNameSpace(map.ClassName), customName);
string afterObjects = String.Format("{1} = new {0}();", NameSpaceManager.RemoveNameSpace(map.ClassName), customName);
string insert = InputBox.frmInput.InputBox("Adding a Object to a Collection? Enter code:", null, customName, false);
result.Add(createObject);
int count = -1;
foreach (DataRow aRow in dg.Rows)
{
count++;
if (count > 0)
{
if (!String.IsNullOrEmpty(insert))
{
result.Add(insert);
}
result.Add(" ");
result.Add("//NewObject");
result.Add(afterObjects);
}
DataMapType storeType = DataMapType.None;
if (Enum.TryParse <DataMapType>(storeName, out storeType))
{
switch (storeType)
{
case DataMapType.FieldColumnMap:
BuildFieldTemplate(customName, aRow, map.FieldMaps, result);
break;
case DataMapType.PropertyColumnMap:
BuildPropertyTemplate(customName, aRow, map.PropMaps, result);
break;
}
}
}
if (!String.IsNullOrEmpty(insert))
{
result.Add(insert);
}
return(result);
}
public static void FindOrCreateMap(TreeView projectView, string className, ref MapedObject aMapObject)
{
MapReferences refInfo;
if (Mapped.FindMap(projectView, className, out refInfo))
{
aMapObject = refInfo.ViableInfo.TheMap;
}
else
{
aMapObject = new MapedObject();
aMapObject.ClassName = className;
}
}
/// <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);
}
}
private UIMapper CreateParamsMapper(MapedObject aMapObject)
{
string theparams = String.Empty;
if (rbConstructors.Checked)
{
theparams = lstVwObjectView.SelectedItems[0].SubItems[1].Text;
}
else
{
theparams = lstVwObjectView.SelectedItems[0].SubItems[2].Text;
}
string[] parameters = theparams.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
return(new UIMapper(aMapObject, lstVwObjectView.SelectedItems[0].SubItems[0].Text, Parameters.ParseString(parameters), dgTableView.SelectedRows, currentMode));
}
public static MethodParameterMap MapToParameterColumnMap(ListViewItem aItem, MapedObject aMap, String methodName, int parameterCount, bool ruleBased, Guid id)
{
ParameterColumnMap aPair = new ParameterColumnMap();
if (!ruleBased)
{
aPair.ColumnName = aItem.SubItems[0].Text;
}
else
{
aPair.ColumnName = aItem.SubItems[1].Text;
}
aPair.RuleBased = ruleBased;
aPair.ParameterName = aItem.SubItems[1].Text;
aPair.DataType = aItem.SubItems[2].Text;
aPair.IsNullable = bool.Parse(aItem.SubItems[4].Text);
return(AddParameterMap(aMap, aPair, methodName, id, parameterCount));
}
public static void MapToFields(ListViewItem aItem, MapedObject aMap, bool ruleBased)
{
FieldColumnMap aPair = new FieldColumnMap();
if (!ruleBased)
{
aPair.ColumnName = aItem.SubItems[0].Text;
}
else
{
aPair.ColumnName = aItem.SubItems[1].Text;
}
aPair.RuleBased = ruleBased;
aPair.FieldName = aItem.SubItems[1].Text;
aPair.DataType = aItem.SubItems[2].Text;
aPair.IsNullable = bool.Parse(aItem.SubItems[4].Text);
aMap.FieldMaps.Add(aPair);
}
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);
}
public static MapReferences LoadMapToTree(TreeView projectView, MapedObject aMap, ContextMenuStrip mapMenu)
{
MapReferences newRef = null;
if (!FindMap(projectView, aMap.ClassName, out newRef))
{
newRef = new MapReferences();
newRef.ViableInfo = new ViableMapAndData();
newRef.ViableInfo.TheMap = aMap;
TreeNode aNode = projectView.Nodes[0].Nodes[3].Nodes.Add(NameSpaceManager.RemoveNameSpace(aMap.ClassName));
aNode.Tag = newRef;
aNode.ToolTipText = aMap.ClassName;
aNode.ContextMenuStrip = mapMenu;
projectView.SelectedNode = aNode;
}
return(newRef);
}
private void mnuAutoMap_Click(object sender, EventArgs e)
{
if (currentMode != DataMapType.None && lstVwObjectView.SelectedItems.Count > 0 && dgTableView.SelectedRows.Count > 0)
{
UIMapper autoMapIt = null;
MapedObject aMapObject = null;
MapManager.FindOrCreateMap(projectView, lstVwAssemblies.SelectedItems[0].SubItems[2].Text, ref aMapObject);
if ((rbFields.Checked || rbProperties.Checked))
{
autoMapIt = new UIMapper(aMapObject, lstVwObjectView.SelectedItems, dgTableView.SelectedRows, currentMode);
}
else
{
autoMapIt = CreateParamsMapper(aMapObject);
}
autoMapIt.AutoMap = true;
ApplyField(autoMapIt);
if (dgTableView.Tag != null)
{
StoreDataTable(this, (exportControlEventArgs)dgTableView.Tag);
}
}
}
public static List <String> CreateTemplateParams(DataTable dg, MapedObject map, String storeName, String customName)
{
List <String> results = new List <string>();
if (String.IsNullOrEmpty(customName))
{
customName = String.Format("_{0}", NameSpaceManager.RemoveNameSpace(map.ClassName).ToLower());
}
string insert = InputBox.frmInput.InputBox("Adding a Object to a Collection? Enter code:", null, customName, false);
var aMap = map.MethodParameters.Where(x => x.MethodName == storeName).FirstOrDefault();
int count = -1;
bool delcareClass = true;
foreach (DataRow aRow in dg.Rows)
{
count++;
if (count > 0)
{
if (!String.IsNullOrEmpty(insert))
{
results.Add(insert);
}
results.Add(" ");
results.Add("//NewObject");
delcareClass = false;
}
BuildParamTemplate(aMap, aRow, results, customName, map.ClassName, delcareClass);
}
if (!String.IsNullOrEmpty(insert))
{
results.Add(insert);
}
return(results);
}
public static void StoreMap(MapedObject aMap, String fileName)
{
FileSerializations.FileSerialization(fileName, aMap);
}
public UIMapper(MapedObject review, MethodParameterMap methodMap, DataMapType mode)
: this()
{
UIMappEdit(review, methodMap, mode);
}
public static MethodParameterMap GetParameterMap(String methodName, MapedObject aMap, int paramterCount)
{
return(aMap.MethodParameters.Where(x => x.MethodName.Equals(methodName) && x.ParameterCount.Equals(paramterCount)).FirstOrDefault());
}
