private void lstVwAssemblies_Click(object sender, EventArgs e)
{
if (SampleAssembly == null || lstVwAssemblies.SelectedItems.Count < 1)
{
return;
}
lstVwObjectView.Items.Clear();
Type selectedType = SampleAssembly.Assembly.GetType(lstVwAssemblies.SelectedItems[0].SubItems[2].Text);
if (rbFields.Checked)
{
currentMode = DataMapType.FieldColumnMap;
ListObjectDetails.LoadFields(selectedType, lstVwObjectView);
}
else if (rbProperties.Checked)
{
currentMode = DataMapType.PropertyColumnMap;
ListObjectDetails.LoadProperties(selectedType, lstVwObjectView);
}
else if (rbMethods.Checked)
{
currentMode = DataMapType.MethodParameterMap;
ListObjectDetails.LoadMethods(selectedType, lstVwObjectView);
}
else if (rbConstructors.Checked)
{
currentMode = DataMapType.MethodParameterMap;
ListObjectDetails.LoadConstuctors(selectedType, lstVwObjectView);
}
}
public static bool FindStoreAndUpdate(List <DataStore> stores, DataMapType currentMode, string methodName, DataTable queryResult, Guid mapId)
{
DataStore result = null;
switch (currentMode)
{
case DataMapType.FieldColumnMap:
result = stores.Where(x => x.MapType.Equals(DataMapType.FieldColumnMap)).FirstOrDefault();
if (result == null)
{
result = new DataStore();
result.ActualData = queryResult;
result.DataStoreName = DataMapType.FieldColumnMap.ToString();
result.MethodID = Guid.Empty;
result.MapType = DataMapType.FieldColumnMap;
stores.Add(result);
}
break;
case DataMapType.PropertyColumnMap:
result = stores.Where(x => x.MapType.Equals(DataMapType.PropertyColumnMap)).FirstOrDefault();
if (result == null)
{
result = new DataStore();
result.ActualData = queryResult;
result.DataStoreName = DataMapType.PropertyColumnMap.ToString();
result.MapType = DataMapType.PropertyColumnMap;
result.MethodID = Guid.Empty;
stores.Add(result);
}
break;
case DataMapType.MethodParameterMap:
result = stores.Where(x => x.MapType.Equals(DataMapType.MethodParameterMap) && x.DataStoreName.Equals(methodName) && x.MethodID == mapId).FirstOrDefault();
if (result == null)
{
result = new DataStore();
result.ActualData = queryResult;
result.DataStoreName = methodName;
result.MapType = DataMapType.MethodParameterMap;
result.MethodID = mapId;
stores.Add(result);
}
break;
}
if (result != null)
{
result.ActualData = queryResult;
return(true);
}
return(false);
}
private void mnuMapWindow_Click(object sender, EventArgs e)
{
try
{
if (projectView.SelectedNode.Parent.Text.Trim().Equals("Mapped Objects"))
{
ToolStripMenuItem sentIt = (ToolStripMenuItem)sender;
MapReferences aRef = (MapReferences)projectView.SelectedNode.Tag;
Tuple <String, int> parsed = ParseTextLabel(sentIt.Text);
BaseStore store = null;
Guid mapGuid = Guid.Empty;
aRef.LastMap = ConvertMenuToMapType(parsed.Item1);
currentMode = aRef.LastMap;
if (aRef.LastMap == DataMapType.MethodParameterMap)
{
aRef.LastMethodMap = (MethodParameterMap)sentIt.Tag;
mapGuid = aRef.LastMethodMap.ID;
store = MapManager.FindStore(aRef.LastMethodMap.MethodName, mapGuid, aRef.ReferenceInfo);
}
else
{
store = MapManager.FindStore(aRef.LastMap.ToString(), mapGuid, aRef.ReferenceInfo);
}
UIMapper autoMapIt = null;
if (store != null && store.GetType().Equals(typeof(RuleStore)))
{
autoMapIt = new UIMapper(aRef.ViableInfo.TheMap, ((RuleStore)store).Rules, aRef.LastMethodMap, currentMode);
}
else
{
autoMapIt = new UIMapper(aRef.ViableInfo.TheMap, aRef.LastMethodMap, currentMode);
}
//autoMapIt.AutoMap = true;
if (autoMapIt.ShowDialog() == DialogResult.OK)
{
aRef.ViableInfo.TheMap = UIMapper.Result;
if (store.GetType().Equals(typeof(RuleStore)))
{
((RuleStore)store).Rules = UIMapper.RuleSets;
}
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
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);
}
private void mnuQueryWindow_Click(object sender, EventArgs e)
{
if (projectView.SelectedNode.Parent.Text.Trim().Equals("Mapped Objects"))
{
if (aDataObject != null)
{
dgTableView.Tag = null;
MapReferences aRef = (MapReferences)projectView.SelectedNode.Tag;
ToolStripMenuItem sentIt = (ToolStripMenuItem)sender;
Tuple <String, int> parsed = ParseTextLabel(sentIt.Text);
aRef.LastMap = ConvertMenuToMapType(parsed.Item1);
currentMode = aRef.LastMap;
//aRef.MethodName = parsed.Item1;
if (viewSql == null || viewSql.IsDisposed)
{
viewSql = new Thyme.UI(aDataObject);
this.AddOwnedForm(viewSql);
viewSql.Show();
}
else
{
viewSql.ApplyDataObject(aDataObject);
viewSql.WindowState = FormWindowState.Maximized;
}
ReturnData editing = new ReturnData();
string storeName = String.Empty;
Guid mapGuid = Guid.Empty;
if (aRef.LastMap == DataMapType.MethodParameterMap)
{
aRef.LastMethodMap = (MethodParameterMap)sentIt.Tag;
mapGuid = aRef.LastMethodMap.ID;
editing.QueryResult = MapManager.FindQueryInfo(aRef.ViableInfo.StoredData, aRef.LastMethodMap.MethodName, currentMode, mapGuid, out storeName);
}
else
{
editing.QueryResult = MapManager.FindQueryInfo(aRef.ViableInfo.StoredData, null, currentMode, Guid.Empty, out storeName);
}
editing.SQLText = MapManager.GetSQL(storeName, mapGuid, aRef.ReferenceInfo);
viewSql.SetEditData(editing);
}
else
{
MessageBox.Show("Select a database to connect to.", "Problem!", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
/// <summary>
/// 新ID转换成老HISID
/// </summary>
/// <param name="type"></param>
/// <param name="id">新的HIS编码</param>
/// <param name="db"></param>
/// <returns></returns>
public static string ConvertNewhisidToOldHisid(DataMapType type, string id, RelationalDatabase db)
{
string ssql = "select oldid from datamap where NEWTABLE='" + type.ToString() + "' and newid='" + id + "'";
DataTable tb = db.GetDataTable(ssql);
if (tb.Rows.Count > 0)
{
return(Convertor.IsNull(tb.Rows[0]["oldid"], ""));
}
else
{
return("");
}
}
public static DataStore FindStore(List <DataStore> stores, DataMapType currentMode, string methodName, Guid mapId)
{
DataStore result = null;
switch (currentMode)
{
case DataMapType.MethodParameterMap:
result = stores.Where(x => x.MapType.Equals(DataMapType.MethodParameterMap) && x.DataStoreName.Equals(methodName) && x.MethodID == mapId).FirstOrDefault();
break;
default:
result = stores.Where(x => x.MapType.Equals(currentMode)).FirstOrDefault();
break;
}
return(result);
}
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 void SetCurrentMode(String menuText)
{
switch (menuText)
{
case "Data for Properties":
case "Map for Properties":
currentMode = DataMapType.PropertyColumnMap;
break;
case "Data For Fields":
case "Map For Fields":
currentMode = DataMapType.FieldColumnMap;
break;
case "Data for Methods":
case "Map for Methods":
currentMode = DataMapType.MethodParameterMap;
break;
}
}
private void SetDisplayMode(DataMapType displayMode)
{
switch (displayMode)
{
case DataMapType.FieldColumnMap:
rbModeFields.Checked = true;
break;
//case ObjectModes.RuleBased:
case DataMapType.MethodParameterMap:
rbModeParameters.Checked = true;
break;
case DataMapType.PropertyColumnMap:
rbModeProp.Checked = true;
break;
}
currentMode = displayMode;
}
public static DataMapType TransFormModeToMapType(ObjectModes aMode)
{
DataMapType result = DataMapType.None;
switch (aMode)
{
case ObjectModes.Fields:
result = DataMapType.FieldColumnMap;
break;
case ObjectModes.Parameters:
result = DataMapType.MethodParameterMap;
break;
case ObjectModes.Properties:
result = DataMapType.PropertyColumnMap;
break;
}
return(result);
}
private DataMapType ConvertMenuToMapType(string text)
{
DataMapType result = DataMapType.None;
switch (text)
{
case "Map for Properties":
case "Data for Properties":
result = DataMapType.PropertyColumnMap;
break;
case "Data For Fields":
case "Map For Fields":
result = DataMapType.FieldColumnMap;
break;
default:
result = DataMapType.MethodParameterMap;
break;
}
return(result);
}
private void ctxViewRule_Click(object sender, EventArgs e)
{
DataMapType theType = EnumPlus.ConvertString(typeof(DataMapType), mppedObjectsTree.SelectedNode.Tag.GetType().Name);
var store = Result.ReferenceInfo.StoreReferences.Where(x => x.MapType == theType);
if (store != null)
{
IDataRule storeRule = null;
switch (theType)
{
case DataMapType.FieldColumnMap:
case DataMapType.PropertyColumnMap:
RuleStore rStore = (RuleStore)store.First();
storeRule = rStore.Rules.Where(x => x.FieldName.Equals(mppedObjectsTree.SelectedNode.Text.Trim())).FirstOrDefault();
break;
case DataMapType.MethodParameterMap:
RuleStore rpStore = (RuleStore)store.Where(x => x.DataStoreName.Equals(mppedObjectsTree.SelectedNode.Text.Trim()) && x.ParamterCount.Equals(lstMapDetails.Items.Count)).First();
storeRule = rpStore.Rules.Where(x => x.FieldName.Equals(lstMapDetails.SelectedItems[0].SubItems[0].Text.Trim())).First();
break;
}
DisplayRule(storeRule, false);
}
}
public static void FindRuleAndUpdate(string dataStoreName, ReferenceData aRef, List <IDataRule> rules, DataMapType mapType, Guid mapId)
{
var aRule = aRef.StoreReferences.Where(x => x.DataStoreName.Equals(dataStoreName) && x.MapID == mapId && x.GetType().Equals(typeof(RuleStore))).FirstOrDefault();
if (aRule == null)
{
RuleStore nRule = new RuleStore();
nRule.DataStoreName = dataStoreName;
nRule.Rules = rules;
nRule.MapType = mapType;
nRule.ParamterCount = rules.Count;
aRef.StoreReferences.Add(nRule);
}
else
{
((RuleStore)aRule).Rules = rules;
}
}
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 DataTable FindQueryInfo(List <DataStore> aStore, string methodName, DataMapType currentMode, Guid mapId, out string storeName)
{
storeName = String.Empty;
DataStore result = MapManager.FindStore(aStore, currentMode, methodName, mapId);
if (result == null)
{
return(null);
}
storeName = result.DataStoreName;
return(result.ActualData);
}
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 static bool LoadDataTableToMapNode(TreeView projectView, String className, ReturnData data, DataMapType mode)
{
MapReferences newRef = null;
if (!FindMap(projectView, className, out newRef))
{
return(false);
}
Guid anId = Guid.Empty;
string methodName = mode.ToString();
if (mode == DataMapType.MethodParameterMap)
{
methodName = newRef.LastMethodMap.MethodName;
anId = newRef.LastMethodMap.ID;
}
if (MapManager.FindStoreAndUpdate(newRef.ViableInfo.StoredData, mode, methodName, data.QueryResult, anId))
{
MapManager.FindSQLAndUpdate(methodName, anId, data.QueryResult.Columns.Count, newRef.ReferenceInfo, data.SQLText);
}
return(true);
}
/// <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 UIMapper(MapedObject review, MethodParameterMap methodMap, DataMapType mode)
: this()
{
UIMappEdit(review, methodMap, mode);
}
