public void UpdateDatasource(object table)
{
//At first it will load from Json and Json will be serialized into DataColumns as DataColumn item, not UIColumn item as expected. That is why we need
//DataColumns2, to store its UIColumn list, and copy it to DataColumns
if (table.GetType() != typeof(DataSourceUITable))
{
string json = Utility.Serializer.Json.Serialize(table);
json = json.Replace("DataColumns", "DataColumns2");
json = json.Replace("DataColumns22", "DataColumns2");
DataSourceUITable tbl = Utility.Serializer.Json.Deserialize <DataSourceUITable>(json);
foreach (UIColumn col in tbl.DataColumns2)
{
if (col.ConfigContent == null)
{
SetDefaultConfigContent(col);
}
tbl.DataColumns.Add(col);
}
CurrentTable = tbl;
}
else
{
CurrentTable = (DataSourceUITable)table;
}
gridColumns.AutoGenerateColumns = false;
//gridColumns.DataSource = tbl.DataColumns;
gridColumns.DataSource = CurrentTable.DataColumns.ConvertAll(c => c as UIColumn);
}
private void AddNewTable(object sender, System.Windows.RoutedEventArgs e)
{
AddNewTablePage ANTP = new AddNewTablePage();
ANTP.ShowAsWindow();
DataSourceTable dsTableDetails = ANTP.DSTableDetails;
if (dsTableDetails != null)
{
dsTableDetails.DSC = DSDetails.DSC;
DataSourceTableTreeItem DSTTI = new DataSourceTableTreeItem();
DSTTI.DSTableDetails = dsTableDetails;
DSTTI.DSDetails = DSDetails;
if (dsTableDetails.DSTableType == DataSourceTable.eDSTableType.GingerKeyValue)
{
dsTableDetails.DSC.AddTable(dsTableDetails.Name, "[GINGER_ID] AUTOINCREMENT,[GINGER_KEY_NAME] Text,[GINGER_KEY_VALUE] Text,[GINGER_LAST_UPDATED_BY] Text,[GINGER_LAST_UPDATE_DATETIME] Text");
}
else if (dsTableDetails.DSTableType == DataSourceTable.eDSTableType.Customized)
{
dsTableDetails.DSC.AddTable(dsTableDetails.Name, "[GINGER_ID] AUTOINCREMENT,[GINGER_USED] Text,[GINGER_LAST_UPDATED_BY] Text,[GINGER_LAST_UPDATE_DATETIME] Text");
}
mTreeView.Tree.AddChildItemAndSelect(this, DSTTI);
DSDetails.DSTableList.Add(dsTableDetails);
}
}
public JsonResult AddDataSourceTable(int DataSourceId, string TableName)
{
Object returnData;
try
{
ISourceDataAccess dataAccess = SourceDataAccessFactory.CreateDataAccess(Common.Enums.SourceDatabaseType.TSQL);
TableModel table = dataAccess.ListAllTables().Single(x => x.TableName == TableName);
DataSourceTable dsTable = new DataSourceTable();
dsTable.DataSourceId = DataSourceId;
dsTable.CreatedBy = GetCurrentUser().Email;
dsTable.CreatedDate = DateTime.Now;
dsTable.DataSourceTableIdGuid = Guid.NewGuid();
dsTable.TableAlias = table.TableName.Replace("SRC_", "");
dsTable.TableName = table.TableName;
dsTable.Columns = new JavaScriptSerializer().Serialize(table.Columns);
SqlConfidenceContext context = new SqlConfidenceContext();
context.DataSourceTables.Add(dsTable);
context.SaveChanges();
returnData = new { Success = true };
return(Json(returnData));
}
catch (Exception ex)
{
returnData = new { Success = false, ErrorMessage = "Error adding table, please check the logs" };
Trace.WriteLine(String.Format("Error adding table {0} to {1} - {2}", TableName, DataSourceId, ex.Message));
return(Json(returnData));
}
}
LogicColumn CreateNewDeleteLogicColumn(DataSourceTable table, DataSourceLogicTable newTable, List <Model.DataColumn> datacols)
{
Model.LogicColumn logicColumn = new Model.LogicColumn();
logicColumn.ReturnType = "void";
logicColumn.Tag = "delete-int-and-int";
logicColumn.Use = true;
logicColumn.FunctionName = "DeleteBy";
List <FunctionParameter> parameters = new List <FunctionParameter>();
foreach (Model.DataColumn col in datacols)
{
logicColumn.FunctionName += col.ColumnName + "And";
string dtType = Helper.DatabaseMapper.MapType(col.DataType);
string varName1 = Helper.StrUtil.LowFirst(col.ColumnName) + "";
parameters.Add(new FunctionParameter(varName1, dtType, col));
}
if (logicColumn.FunctionName.Length > 0)
{
logicColumn.FunctionName = logicColumn.FunctionName.Substring(0, logicColumn.FunctionName.Length - 3);
}
Dictionary <string, object> dict = new Dictionary <string, object>();
dict.Add("Parameters", parameters);
logicColumn.ConfigContent = new FunctionConfigurator();
logicColumn.ConfigContent.DisplayConfiguration(dict);
return(logicColumn);
}
protected DataSourceValidationTable Copy(DataSourceTable table)
{
DataSourceValidationTable newTable = new DataSourceValidationTable();
newTable.TableName = table.TableName;
newTable.TableSchema = table.TableSchema;
foreach (Model.DataColumn col in table.DataColumns)
{
Model.ValidatorColumn validatorCol = new ValidatorColumn();
validatorCol.ColumnName = col.ColumnName;
string[] words = Regex.Matches(validatorCol.ColumnName, "(^[a-z]+|[A-Z]+(?![a-z])|[A-Z][a-z]+)")
.OfType <Match>()
.Select(m => m.Value)
.ToArray();
string result = string.Join(" ", words);
validatorCol.ColumnText = result;
validatorCol.DataType = col.DataType;
validatorCol.Key = col.Key;
validatorCol.Use = col.Use;
validatorCol.Size = col.Size;
validatorCol.ConfigContent = new ValidationIsEmpty();
Dictionary <string, object> dict = new Dictionary <string, object>();
dict.Add("InvalidMessage", "Please fill " + result);
validatorCol.ConfigContent.DisplayConfiguration(dict);
validatorCol.ValidationTypeList.Add(new ModelItemType(validatorCol.ConfigContent.GetControlType(), validatorCol.ConfigContent));
newTable.DataColumns.Add(validatorCol);
}
return(newTable);
}
/// <summary>
/// This method is used to create the table
/// </summary>
/// <param name="query"></param>
private string CreateTable(string name, string query, DataSourceTable.eDSTableType DSTableType = DataSourceTable.eDSTableType.GingerKeyValue)
{
string fileName = string.Empty;
try
{
DataSourceTable dsTableDetails = new DataSourceTable();
dsTableDetails.Name = name;
dsTableDetails.DSC = DSDetails.DSC;
dsTableDetails.DSTableType = DSTableType;
DataSourceTableTreeItem DSTTI = new DataSourceTableTreeItem();
DSTTI.DSTableDetails = dsTableDetails;
DSTTI.DSDetails = DSDetails;
dsTableDetails.DSC.AddTable(dsTableDetails.Name, query);
mTreeView.Tree.AddChildItemAndSelect(this, DSTTI);
DSDetails.DSTableList.Add(dsTableDetails);
fileName = this.DSDetails.FileFullPath;
}
catch (Exception ex)
{
Reporter.ToUser(eUserMsgKey.CreateTableError, ex.Message);
Reporter.ToLog(eLogLevel.ERROR, ex.StackTrace);
}
return(fileName);
}
public void CommitDb()
{
// Arrange
ObservableList <DataSourceTable> dataSourceTableList = liteDB.GetTablesList();
DataSourceTable dataSource = null;
List <string> mColumnNames = null;
string Query = "db.MyCustomizedDataTable.find limit 1";
foreach (DataSourceTable dataSourceTable in dataSourceTableList)
{
if (dataSourceTable.Name == "MyCustomizedDataTable")
{
dataSource = dataSourceTable;
}
}
DataTable dataTable = liteDB.GetQueryOutput(dataSource.Name);
dataSource.DataTable = dataTable;
liteDB.AddRow(mColumnNames, dataSource);
liteDB.SaveTable(dataSource.DataTable);
int oldRowCount = liteDB.GetRowCount(dataSource.Name);
//Act
liteDB.DeleteDBTableContents(dataSource.Name);
DataTable newDt = liteDB.GetQueryOutput(Query);
liteDB.SaveTable(newDt);
var newRowCount = liteDB.GetRowCount(dataSource.Name);
//Assert
Assert.AreEqual(newRowCount, 0, "RowCountValidation");
Assert.AreNotEqual(oldRowCount, newRowCount, "RowCountValidation");
}
private void SetDataTable()
{
if (mActDSTableElement.DSList == null)
{
mActDSTableElement.DSList = WorkSpace.Instance.SolutionRepository.GetAllRepositoryItems <DataSourceBase>();
}
DataSourceBase dataSource = null;
var tableName = mActDSTableElement.DSTableName;
if (string.IsNullOrEmpty(tableName))
{
return;
}
foreach (var ds in mActDSTableElement.DSList)
{
if (ds.Name == mActDSTableElement.DSName)
{
dataSource = ds;
}
}
mDataTable = dataSource.GetTable(tableName);
foreach (DataSourceTable dst in dataSource.GetTablesList())
{
if (dst.Name == mActDSTableElement.DSTableName)
{
mDataSourceTable = dst;
break;
}
}
}
public void AddRow()
{
// Arrange
ObservableList <DataSourceTable> dataSourceTableList = liteDB.GetTablesList();
DataSourceTable dataSource = null;
List <string> mColumnNames = null;
foreach (DataSourceTable dataSourceTable in dataSourceTableList)
{
if (dataSourceTable.Name == "MyCustomizedDataTable")
{
dataSource = dataSourceTable;
}
}
DataTable dataTable = liteDB.GetQueryOutput(dataSource.Name);
dataSource.DataTable = dataTable;
liteDB.AddRow(mColumnNames, dataSource);
dataTable = liteDB.GetQueryOutput(dataSource.Name);
//Act
liteDB.SaveTable(dataTable);
var a = liteDB.GetResult("db.MyCustomizedDataTable.count");
//Assert
Assert.AreEqual("1", a, "RowCount");
}
public void CommitDb()
{
// Arrange
ObservableList <DataSourceTable> dataSourceTableList = accessDataSource.GetTablesList();
DataSourceTable dataSource = null;
List <string> mColumnNames = null;
foreach (DataSourceTable dataSourceTable in dataSourceTableList)
{
if (dataSourceTable.Name == "MyCustomizedDataTable")
{
dataSource = dataSourceTable;
}
}
DataTable dataTable = accessDataSource.GetQueryOutput("select * from " + dataSource.Name);
dataSource.DataTable = dataTable;
accessDataSource.AddRow(mColumnNames, dataSource);
accessDataSource.SaveTable(dataSource.DataTable);
int oldRowCount = accessDataSource.GetRowCount(dataSource.Name);
//Act
accessDataSource.RunQuery("DELETE from " + dataSource.Name);
accessDataSource.SaveTable(dataSource.DataTable);
int newRowCount = accessDataSource.GetRowCount(dataSource.Name);
//Assert
Assert.AreEqual(newRowCount, 0, "RowCountValidation");
Assert.AreNotEqual(oldRowCount, newRowCount, "RowCountValidation");
}
public void DefineDataSourceReturnsTheSameDataSourceIfAlreadyDefined()
{
DataSourceTable table = new DataSourceTable();
DataSource source = table.DefineDataSource("source");
Assert.AreSame(source, table.DefineDataSource("source"));
}
private void AddTable(object sender, RoutedEventArgs e)
{
AddNewTablePage ANTP = new AddNewTablePage();
ANTP.ShowAsWindow();
DataSourceTable dsTableDetails = ANTP.DSTableDetails;
if (dsTableDetails != null)
{
dsTableDetails.DSC = mDSDetails.DSC;
if (dsTableDetails.DSTableType == DataSourceTable.eDSTableType.GingerKeyValue)
{
dsTableDetails.DSC.AddTable(dsTableDetails.Name, "[GINGER_ID] AUTOINCREMENT,[GINGER_KEY_NAME] Text,[GINGER_KEY_VALUE] Text,[GINGER_LAST_UPDATED_BY] Text,[GINGER_LAST_UPDATE_DATETIME] Text");
}
else if (dsTableDetails.DSTableType == DataSourceTable.eDSTableType.Customized)
{
dsTableDetails.DSC.AddTable(dsTableDetails.Name, "[GINGER_ID] AUTOINCREMENT,[GINGER_USED] Text,[GINGER_LAST_UPDATED_BY] Text,[GINGER_LAST_UPDATE_DATETIME] Text");
}
mDSTableList.Add(dsTableDetails);
}
}
private void btnRefresh_Click(object sender, EventArgs e)
{
ModelType selectedItem = (ModelType)cmbModelType.SelectedItem;
DataSourceTable table = (DataSourceTable)cmbDatasource.SelectedItem;
InitItemsFromDataSource(selectedItem, table);
}
public void AddRow()
{
// Arrange
ObservableList <DataSourceTable> dataSourceTableList = accessDataSource.GetTablesList();
DataSourceTable dataSource = null;
List <string> mColumnNames = null;
foreach (DataSourceTable dataSourceTable in dataSourceTableList)
{
if (dataSourceTable.Name == "MyCustomizedDataTable")
{
dataSource = dataSourceTable;
}
}
int rowsCount = accessDataSource.GetRowCount(dataSource.Name);
DataTable dataTable = accessDataSource.GetQueryOutput("select * from " + dataSource.Name);
dataSource.DataTable = dataTable;
accessDataSource.AddRow(mColumnNames, dataSource);
//Act
accessDataSource.SaveTable(dataSource.DataTable);
DataTable res = accessDataSource.GetQueryOutput("select * from " + dataSource.Name);
//Assert
Assert.AreEqual(rowsCount + 1, res.Rows.Count, "RowCount");
}
public async Task <IActionResult> PutDataSourceTable(Guid id, [FromBody] DataSourceTable dataSourceTable)
{
var dataSource = await _context.DataSources.FindAsync(id);
if (dataSource == null)
{
return(NotFound());
}
dataSource.DataSourceName = dataSourceTable.DataSourceName;
dataSource.Configuration = dataSourceTable.Configuration;
dataSource.IsStreaming = dataSourceTable.IsStreaming;
dataSource.ConnectionString = dataSourceTable.ConnectionString;
dataSource.LastUpdated = DateTime.Now;
_context.Entry(dataSource).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DataSourceTableExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public static string CheckDataSource(string DataSourceVE, ObservableList <DataSourceBase> DSList)
{
string DSVE = DataSourceVE;
DataSourceBase DataSource = null;
DataSourceTable DSTable = null;
if (string.IsNullOrEmpty(DataSourceVE) || DSVE.IndexOf("{DS Name=") != 0)
{
return("Invalid Data Source Value : '" + DataSourceVE + "'");
}
DSVE = DSVE.Replace("{DS Name=", "");
DSVE = DSVE.Replace("}", "");
if (DSVE.IndexOf(" DST=") == -1)
{
return("Invalid Data Source Value : '" + DataSourceVE + "'");
}
string DSName = DSVE.Substring(0, DSVE.IndexOf(" DST="));
foreach (DataSourceBase ds in DSList)
{
if (ds.Name == DSName)
{
DataSource = ds;
break;
}
}
if (DataSource == null)
{
return("Data Source: '" + DSName + "' used in '" + DataSourceVE + "' not found in solution.");
}
DSVE = DSVE.Substring(DSVE.IndexOf(" DST=")).Trim();
if (DSVE.IndexOf(" ") == -1)
{
return("Invalid Data Source Value : '" + DataSourceVE + "'");
}
string DSTableName = DSVE.Substring(DSVE.IndexOf("DST=") + 4, DSVE.IndexOf(" ") - 4);
if (DataSource.DSType == DataSourceBase.eDSType.MSAccess)
{
DataSource.FileFullPath = WorkSpace.Instance.Solution.SolutionOperations.ConvertSolutionRelativePath(DataSource.FileFullPath);
ObservableList <DataSourceTable> dsTables = DataSource.GetTablesList();
foreach (DataSourceTable dst in dsTables)
{
if (dst.Name == DSTableName)
{
DSTable = dst;
break;
}
}
if (DSTable == null)
{
return("Data Source Table : '" + DSTableName + "' used in '" + DataSourceVE + "' not found in solution.");
}
}
return("");
}
public void ResolveDataSourceReturnsNullIfTheDataSourceIsNotDefinedButOthersAre()
{
DataSourceTable table = new DataSourceTable();
table.DefineDataSource("someOtherSource");
Assert.IsNull(table.ResolveDataSource("test"));
}
private void btnAddFunction_Click(object sender, EventArgs e)
{
LogicColumn newcol = CreateDefaultLogicColumn();
DataSourceTable tbl = CurrentTable;
tbl.DataColumns.Add(newcol);
gridColumns.DataSource = CurrentTable.DataColumns.ConvertAll(c => c as LogicColumn);
}
public void InitFromDatasource(DataSourceTable table)
{
gridColumns.AutoGenerateColumns = false;
DataSourceValidationTable newTable = Copy(table);
gridColumns.DataSource = newTable.DataColumns.ConvertAll(c => c as ValidatorColumn);
CurrentTable = newTable;
}
/// <summary>
/// Defines a new data source within this data context if one does not exist.
/// Otherwise returns the existing one.
/// </summary>
/// <param name="name">The data source name.</param>
/// <returns>The defined data source.</returns>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="name"/> is null.</exception>
public DataSource DefineDataSource(string name)
{
if (dataSourceTable == null)
{
dataSourceTable = new DataSourceTable();
}
return(dataSourceTable.DefineDataSource(name));
}
protected DataSourceLogicTable Copy(DataSourceTable table)
{
DataSourceLogicTable newTable = new DataSourceLogicTable();
newTable.TableName = table.TableName;
newTable.TableSchema = table.TableSchema;
AddDefaultFunctions(table, newTable);
//AddDefaultFunctionsAgain(table, newTable);
return(newTable);
}
/// <summary>
/// Command to parse the data source from the model JSON and populate the train and test DataViews.
/// </summary>
/// <param name="dataSource">Reference to the data sources database table.</param>
/// <param name="dataSourceJson">The data source JSON configuration to parse.</param>
/// <param name="isTestData">True if this is the TestDataView, false if the TrainDataView.</param>
/// <returns>True if successful, false otherwise.</returns>
private bool _ParseDataSourceJson(ref DataSourceTable dataSource, JToken dataSourceJson, bool isTestData)
{
string sourceType = dataSourceJson.Value <string>("Type");
switch (sourceType)
{
case "Binary":
if (isTestData)
{
TestDataView = MLContext._LoadFromBinary(dataSourceJson);
}
else
{
TrainDataView = MLContext._LoadFromBinary(dataSourceJson);
}
return(true);
case "Database":
if (isTestData)
{
TestDataView = MLContext._LoadFromDatabase(dataSourceJson);
}
else
{
TrainDataView = MLContext._LoadFromDatabase(dataSourceJson);
}
return(true);
case "File":
string fileName = dataSource.FileName;
byte[] fileBytes = dataSource.File;
FileInfo tempFile = new FileInfo($"temp/{dataSource.DataSourceId}/{fileName}");
if (tempFile.Exists)
{
tempFile.Delete();
}
using (FileStream fileStream = new FileStream(tempFile.FullName, FileMode.Create, FileAccess.ReadWrite))
{
fileStream.Write(fileBytes, 0, fileBytes.Length);
}
dataSourceJson["LocalPath"] = tempFile.FullName;
if (isTestData)
{
TestDataView = MLContext._LoadFromFile(dataSourceJson);
}
else
{
TrainDataView = MLContext._LoadFromFile(dataSourceJson);
}
return(true);
default:
return(false);
}
}
public DataSourceExportToExcel(DataSourceTable dataSourceTable)
{
InitializeComponent();
mDataSourceTable = dataSourceTable;
InitPageData();
mDataTable = dataSourceTable.DataTable;
InitColumnListGrid(mDataTable.Columns);
xExportSheetName.ValueTextBox.Text = mDataTable.TableName;
}
public DataSourceTableModel GetDataSourceTableByPrimaryKey(Int64 MasterReport_Id, string TableName)
{
DataSourceTable result = this.dataContext
.DataSourceTables
.FirstOrDefault(pk => pk.MasterReport_Id == MasterReport_Id && pk.TableName == TableName);
if (result == null)
{
return(null);
}
return(result.CopyToObject(new DataSourceTableModel()) as DataSourceTableModel);
}
void AddDefaultListFunctionsAgain(DataSourceTable table, DataSourceLogicTable newTable)
{
int colCounter = 0;
foreach (Model.DataColumn col in table.DataColumns)
{
if (col.DataType.ToLower().Contains("int") && col.Key == false)
{
AddDefaultListFunctionsAgainOnNewTable(table, newTable, colCounter, col);
}
colCounter++;
}
}
void AddDefaultListFunctionsAgainOnNewTable(DataSourceTable table, DataSourceLogicTable newTable, int colCounter, Model.DataColumn col)
{
int colCounter2 = 0;
foreach (Model.DataColumn col2 in table.DataColumns)
{
LogicColumn logicColumn = CreateDefaultListFunctionAgainLogicColumn(colCounter, colCounter2, col, col2, newTable);
if (logicColumn != null)
{
newTable.DataColumns.Add(logicColumn);
}
colCounter2++;
}
}
/// <summary>
/// LoadDataSource
/// </summary>
void LoadDataSource(bool isFind)
{
this.isInit = true;
using (ProxyEntityFactory proxy = new ProxyEntityFactory())
{
DataTable dt = proxy.Service.SelectFullTable(new EntityEmrTableBasicInfo());
DataSourceTable = EntityTools.ConvertToEntityList <EntityEmrTableBasicInfo>(dt);
}
if (DataSourceTable == null)
{
DataSourceTable = new List <EntityEmrTableBasicInfo>();
}
foreach (EntityEmrTableBasicInfo item in DataSourceTable)
{
if (string.IsNullOrEmpty(item.pyCode))
{
item.pyCode = SpellCodeHelper.GetPyCode(item.tableName);
}
if (string.IsNullOrEmpty(item.wbCode))
{
item.wbCode = SpellCodeHelper.GetWbCode(item.tableName);
}
item.imageIndex = 1;
item.parent = "99";
item.isLeaf = true;
}
EntityEmrTableBasicInfo defaultVo = null;
if (DataSourceTable.Count > 0 && defaultVo == null)
{
defaultVo = DataSourceTable[0];
}
EntityEmrTableBasicInfo vo = new EntityEmrTableBasicInfo();
vo.tableCode = "99";
vo.tableName = "全部表格";
vo.imageIndex = 2;
DataSourceTable.Add(vo);
Viewer.tvTable.BeginUpdate();
Viewer.tvTable.DataSource = DataSourceTable;
Viewer.tvTable.ExpandAll();
Viewer.tvTable.EndUpdate();
if (defaultVo != null && isFind == false)
{
LoadTable(defaultVo);
}
Viewer.ValueChanged = false;
this.isInit = false;
}
void GenerateAll(string path, CodeGeneratorProject project, CodeGeneratorModule module)
{
List <CodeTemplate> codeTemplates = (List <CodeTemplate>)dataGridView1.DataSource;
foreach (CodeTemplate template in codeTemplates)
{
if (template.Checked)
{
Info("Generating " + module.SessionName + " : " + template.TemplateName);
string filename = template.DefaultFilename.Replace("<companyname>", project.Company).Replace("<projectname>", project.ProjectName).Replace("<modulename>", module.ModuleName);
DataSourceTable table = (DataSourceTable)module.Datasource;
string tableName = table.TableName;
filename = filename.Replace("<tablename>", tableName);
filename = path + "/" + filename;
string dir = System.IO.Path.GetDirectoryName(filename);
if (System.IO.Directory.Exists(dir) == false)
{
System.IO.Directory.CreateDirectory(dir);
}
Info("Generating file : " + module.SessionName + " : " + filename);
string result = CodeCompiler.GenerateCodeForModule(project, module, template.TemplateCodePlain);
result = result.Replace("\\%", "%");
try
{
System.IO.File.WriteAllText(filename, result);
Info("Done ");
}
catch (Exception err)
{
Info(err.Message);
}
currentProgress++;
this.SetPgBarValue(currentProgress);
}
}
if (this.OnGenerateDoneEvent != null)
{
this.OnGenerateDoneEvent(module);
}
//MessageBox.Show("Done");
}
private void tviDSTable_MouseDoubleClick(object sender, MouseButtonEventArgs e)
{
TreeViewItem tvi = (TreeViewItem)e.Source;
DataSourceTable dsTable = (DataSourceTable)tvi.DataContext;
ActDataSourcePage dsVEPage;
string VE = "";
dsVEPage = new ActDataSourcePage(((TreeViewItem)tvi.Parent).Tag.ToString(), dsTable);
dsVEPage.ShowAsWindow();
VE = dsVEPage.VE;
if (VE != "")
{
AddExpToValue(VE);
}
}
public void ResolveDataSourceReturnsADataSource()
{
DataSourceTable table = new DataSourceTable();
DataSource source1 = table.DefineDataSource("source1");
Assert.IsNotNull(source1);
DataSource source2 = table.DefineDataSource("source2");
Assert.IsNotNull(source2);
Assert.AreSame(source1, table.ResolveDataSource("source1"));
Assert.AreSame(source2, table.ResolveDataSource("source2"));
}
