/// <summary>
/// All the variables are initialized here.
/// </summary>
private void Initialize()
{
//Other
this.resultModelList = new List<ResultModel>();
this.resultList = new ArrayList();
//Model
dbConnection = new ConnectionModel();
//View
this.mainForm = new MainForm();
this.mainView = new MainView(this);
this.adminLoginView = new AdminLoginView();
this.inleesView = new InleesView(this);
this.resultView = new ResultView(this);
this.loadMapView = new LoadMapView(this);
this.statisticView = new StatisticView(this);
//Controller
this.mainViewController = new MainViewController(this);
this.inleesViewController = new InleesViewController(this);
this.resultController = new ResultController(this);
this.resultDialogController = new ResultDialogController(this);
this.colonyController = new ColonyController();
this.fileSelectController = new FileController(this);
this.statisticController = new StatisticController(this);
// ADD INLEESVIEW AND RESULTVIEW TO MAINVIEW
this.mainViewController.AddToPage(inleesView, 0);
this.mainViewController.AddToPage(resultView, 1);
this.mainViewController.AddToPage(statisticView, 2);
this.mainForm.Controls.Add(mainView);
this.mainView.Dock = DockStyle.Fill;
this.resultView.Dock = DockStyle.Fill;
this.statisticView.Dock = DockStyle.Fill;
// START APP
Application.EnableVisualStyles();
Application.Run(mainForm);
}
/// <summary>
/// Obtiene el plan de ejecución de una consulta
/// </summary>
public async Task <DataTable> GetExecutionPlanAsync(ConnectionModel connection, string query, ArgumentListModel arguments,
TimeSpan timeout, CancellationToken cancellationToken)
{
return(await DbScriptsManager.GetExecutionPlanAsync(connection, query, arguments, timeout, cancellationToken));
}
/// <summary>
/// Obtiene el datareader de una consulta
/// </summary>
public async Task <System.Data.Common.DbDataReader> ExecuteReaderAsync(ConnectionModel connection, string query, ArgumentListModel arguments,
TimeSpan timeout, CancellationToken cancellationToken)
{
return(await DbScriptsManager.ExecuteReaderAsync(connection, query, arguments, timeout, cancellationToken));
}
/// <summary>
/// Obtiene un <see cref="DataTable"/> paginada con una consulta sobre una conexión
/// </summary>
public async Task <DataTable> GetDatatableQueryAsync(ConnectionModel connection, string query, ArgumentListModel arguments,
int actualPage, int pageSize, TimeSpan timeout, CancellationToken cancellationToken)
{
return(await DbScriptsManager.GetDatatableQueryAsync(connection, query, arguments, actualPage, pageSize, timeout, cancellationToken));
}
private async Task <List <ShiftModel> > GetCachedShiftsAsync(ConnectionModel connection, DateTime weekStartDate)
{
var cachedShifts = await _scheduleCacheService.LoadScheduleAsync(connection.TeamId, weekStartDate);
return(cachedShifts.Tracked.OrderBy(s => s.StartDate).ToList());
}
public void WriteDataRecord(ConnectionModel connectionModel, IDataRecord dataRecord, string databaseFile)
{
var dataLink = _localDataLinkProvider.GetDataLink(connectionModel, databaseFile);
dataLink.Write(dataRecord);
}
public IDataRecord GetDataRecord(ConnectionModel connectionModel, IKey key, string instrumentName, string serverParkName)
{
var dataLink = _remoteDataLinkProvider.GetDataLink(connectionModel, instrumentName, serverParkName);
return(dataLink.ReadRecord(key));
}
public IDataSet GetDataSet(ConnectionModel connectionModel, string instrumentName, string serverParkName)
{
var dataLink = _remoteDataLinkProvider.GetDataLink(connectionModel, instrumentName, serverParkName);
return(dataLink.Read(null));
}
/// <summary>
/// Muestra el plan de ejecución
/// </summary>
private async Task ShowExecutionPlanAsync()
{
string query = GetEditorSelectedText();
if (string.IsNullOrWhiteSpace(query))
{
SolutionViewModel.MainController.HostController.SystemController.ShowMessage("Introduzca una consulta");
}
else
{
ConnectionModel connection = ComboConnections.GetSelectedConnection();
if (connection == null)
{
SolutionViewModel.MainController.HostController.SystemController.ShowMessage("Seleccione una conexión");
}
else
{
(ArgumentListModel arguments, string error) = SolutionViewModel.ConnectionExecutionViewModel.GetParameters();
if (!string.IsNullOrWhiteSpace(error))
{
SolutionViewModel.MainController.HostController.SystemController.ShowMessage(error);
}
else
{
try
{
DataTable table = await SolutionViewModel.Manager.GetExecutionPlanAsync(connection, query, arguments,
connection.TimeoutExecuteScript, _cancellationToken);
string plan = string.Empty;
// Obtiene el plan de ejecución
if (table != null)
{
foreach (DataRow row in table.Rows)
{
// Añade el contenido de las columnas
for (int column = 0; column < table.Columns.Count; column++)
{
if (!(row[column] is DBNull) && row[column] != null)
{
plan += row[column].ToString();
}
}
// Añade un salto de línea
plan += Environment.NewLine;
}
}
// Asigna el texto del plan de ejecución
ExecutionPlanText = plan;
}
catch (Exception exception)
{
SolutionViewModel.MainController.Logger.Default.LogItems.Error($"Error al obtener el plan de ejecución. {exception.Message}");
}
}
}
}
}
public bool KeyExists(ConnectionModel connectionModel, IKey key, string instrumentName, string serverParkName)
{
var dataLink = _remoteDataLinkProvider.GetDataLink(connectionModel, instrumentName, serverParkName);
return(dataLink.KeyExists(key));
}
private static async Task MusicPlayLoop(DiscordChannel channel, ConnectionModel connection)
{
try
{
while (connection.Connected)
{
if (connection.Songs.TryDequeue(out SongModel model))
{
await channel.SendMessageAsync($"Now Playing: **{model}**");
try
{
using (MediaFoundationReader reader = new MediaFoundationReader(model.FilePath))
using (MediaFoundationResampler resampler = new MediaFoundationResampler(reader, 48000))
{
VolumeSampleProvider volume = new VolumeSampleProvider(resampler.ToSampleProvider())
{
Volume = connection.Volume
};
connection.SampleProvider = volume;
IWaveProvider waveProvider = connection.SampleProvider.ToWaveProvider16();
connection.Total = reader.TotalTime;
connection.NowPlaying = model;
byte[] buff = new byte[3840];
int br = 0;
await connection.Connection.SendSpeakingAsync(true);
while ((br = waveProvider.Read(buff, 0, buff.Length)) > 0)
{
connection.Token.ThrowIfCancellationRequested();
if (connection.Skip)
{
break;
}
if (br < buff.Length)
{
for (int i = br; i < buff.Length; i++)
{
buff[i] = 0;
}
}
connection.Elapsed = reader.CurrentTime;
await connection.Connection.SendAsync(buff, 20);
connection.RecordBuffer.AddSamples(buff, 0, buff.Length);
}
if (connection.Connected)
{
await connection.Connection.SendSpeakingAsync(false);
}
connection.Skip = false;
}
}
catch (OperationCanceledException) { break; }
catch (InvalidOperationException) { break; }
catch (Exception ex)
{
await channel.SendMessageAsync($"Something went a bit wrong attempting to play that and a {ex.GetType().Name} was thrown. Sorry!\r\n{ex.Message}");
}
}
connection.NowPlaying = null;
connection.Skip = false;
await Task.Delay(500);
}
}
catch
{
if (connection.Connected)
{
throw;
}
}
}
/// <summary>
/// 刷新数据库表和视图
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void 刷新ToolStripMenuItem2_Click(object sender, EventArgs e)
{
TreeNode node = Treeview.SelectedNode;
if (node.Level == 3)
{
node = node.Parent;
}
if (node.Level == 4)
{
node = node.Parent.Parent;
}
node.Nodes.Clear();
ConnectionModel conModel = null;
try
{
conModel = _ConnectList.Find(delegate(ConnectionModel con) { return(con.ID.ToString().Equals(node.Parent.Tag.ToString())); });
IDbObject dbObject;
if (conModel.DbType.Equals(DatabaseType.MsAccess.ToString()))
{
dbObject = new WEF.DbDAL.OleDb.DbObject(conConnectionString);
ShowTablesAndViews(node, dbObject.GetTables(""), dbObject.GetVIEWs(""));
}
else if (conModel.DbType.Equals(DatabaseType.SqlServer.ToString()))
{
dbObject = new WEF.DbDAL.SQL2000.DbObject(conConnectionString);
ShowTablesAndViews(node, dbObject.GetTables(node.Text), dbObject.GetVIEWs(node.Text));
}
else if (conModel.DbType.Equals(DatabaseType.SqlServer9.ToString()))
{
dbObject = new WEF.DbDAL.SQL2005.DbObject(conConnectionString);
ShowTablesAndViews(node, dbObject.GetTables(node.Text), dbObject.GetVIEWs(node.Text));
}
else if (conModel.DbType.Equals(DatabaseType.Oracle.ToString()))
{
dbObject = new WEF.DbDAL.Oracle.DbObject(conConnectionString);
ShowTablesAndViews(node, dbObject.GetTables(node.Text), dbObject.GetVIEWs(node.Text));
}
else if (conModel.DbType.Equals(DatabaseType.MySql.ToString()))
{
dbObject = new WEF.DbDAL.MySql.DbObject(conConnectionString);
ShowTablesAndViews(node, dbObject.GetTables(node.Text), dbObject.GetVIEWs(node.Text));
}
else if (conModel.DbType.Equals(DatabaseType.Sqlite3.ToString()))
{
dbObject = new WEF.DbDAL.SQLite.DbObject(conConnectionString);
ShowTablesAndViews(node, dbObject.GetTables(node.Text), dbObject.GetVIEWs(node.Text));
}
else if (conModel.DbType.Equals(DatabaseType.MongoDB.ToString()))
{
var mongoDBTool = MongoDBTool.Connect(conConnectionString);
ShowCollections(node, mongoDBTool.GetCollections(node.Text));
}
node.ExpandAll();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "出错啦!", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
/// <summary>
/// 获取数据库服务器
/// </summary>
private void getDatabaseinfo(TreeNode node)
{
LoadForm.ShowLoading(this);
Task.Factory.StartNew(() =>
{
try
{
ConnectionModel conModel = null;
this.Invoke(new Action(() =>
{
conModel = _ConnectList.Find(delegate(ConnectionModel con) { return(con.ID.ToString().Equals(node.Tag?.ToString() ?? "")); });
}));
conConnectionString = conModel.ConnectionString;
IDbObject dbObject;
if (conModel.DbType.Equals(DatabaseType.MsAccess.ToString()))
{
dbObject = new WEF.DbDAL.OleDb.DbObject(conConnectionString);
TreeNode tnode = null;
this.Invoke(new Action(() =>
{
tnode = new TreeNode(conModel.Database, 1, 1);
tnode.Tag = conConnectionString;
tnode.ContextMenuStrip = contextMenuStripOneDataBase;
node.Nodes.Add(tnode);
}));
var tables = dbObject.GetTables("");
var views = dbObject.GetVIEWs("");
this.Invoke(new Action(() =>
{
ShowTablesAndViews(tnode, tables, views);
}));
}
else if (conModel.DbType.Equals(DatabaseType.Sqlite3.ToString()))
{
dbObject = new WEF.DbDAL.SQLite.DbObject(conConnectionString);
TreeNode tnode = null;
this.Invoke(new Action(() =>
{
tnode = new TreeNode(conModel.Database, 1, 1);
tnode.Tag = conConnectionString;
tnode.ContextMenuStrip = contextMenuStripOneDataBase;
node.Nodes.Add(tnode);
}));
var tables = dbObject.GetTables("");
var views = dbObject.GetVIEWs("");
this.Invoke(new Action(() =>
{
ShowTablesAndViews(tnode, tables, views);
}));
}
else if (conModel.DbType.Equals(DatabaseType.SqlServer.ToString()) || conModel.DbType.Equals(DatabaseType.SqlServer9.ToString()))
{
if (conModel.DbType.Equals(DatabaseType.SqlServer.ToString()))
{
dbObject = new WEF.DbDAL.SQL2000.DbObject(conConnectionString);
}
else
{
dbObject = new WEF.DbDAL.SQL2005.DbObject(conConnectionString);
}
if (conModel.Database.Equals("all"))
{
DataTable dt = dbObject.GetDBList();
foreach (DataRow dr in dt.Rows)
{
TreeNode tnode = null;
this.Invoke(new Action(() =>
{
tnode = new TreeNode(dr[0].ToString(), 1, 1);
tnode.Tag = conConnectionString.Replace("master", dr[0].ToString());
tnode.ContextMenuStrip = contextMenuStripOneDataBase;
node.Nodes.Add(tnode);
}));
var tables = dbObject.GetTables(tnode.Text);
var views = dbObject.GetVIEWs(tnode.Text);
this.Invoke(new Action(() =>
{
ShowTablesAndViews(tnode, tables, views);
}));
}
}
else
{
TreeNode tnode = null;
this.Invoke(new Action(() =>
{
tnode = new TreeNode(conModel.Database, 1, 1);
tnode.Tag = conConnectionString;
tnode.ContextMenuStrip = contextMenuStripOneDataBase;
node.Nodes.Add(tnode);
}));
var tables = dbObject.GetTables(tnode.Text);
var views = dbObject.GetVIEWs(tnode.Text);
this.Invoke(new Action(() =>
{
ShowTablesAndViews(tnode, tables, views);
}));
}
}
else if (conModel.DbType.Equals(DatabaseType.Oracle.ToString()))
{
dbObject = new WEF.DbDAL.Oracle.DbObject(conConnectionString);
TreeNode tnode = null;
this.Invoke(new Action(() =>
{
tnode = new TreeNode(conModel.Database, 1, 1);
tnode.Tag = conConnectionString;
tnode.ContextMenuStrip = contextMenuStripOneDataBase;
node.Nodes.Add(tnode);
}));
var tables = dbObject.GetTables(tnode.Text);
var views = dbObject.GetVIEWs(tnode.Text);
this.Invoke(new Action(() =>
{
ShowTablesAndViews(tnode, tables, views);
}));
}
else if (conModel.DbType.Equals(DatabaseType.MySql.ToString()))
{
dbObject = new WEF.DbDAL.MySql.DbObject(conConnectionString);
if (conModel.Database.Equals("all"))
{
DataTable dt = dbObject.GetDBList();
foreach (DataRow dr in dt.Rows)
{
TreeNode tnode = null;
this.Invoke(new Action(() =>
{
tnode = new TreeNode(dr[0].ToString(), 1, 1);
tnode.Tag = conConnectionString.Replace("master", dr[0].ToString());
tnode.ContextMenuStrip = contextMenuStripOneDataBase;
node.Nodes.Add(tnode);
}));
var tables = dbObject.GetTables(tnode.Text);
var views = dbObject.GetVIEWs(tnode.Text);
this.Invoke(new Action(() =>
{
ShowTablesAndViews(tnode, tables, views);
}));
}
}
else
{
TreeNode tnode = null;
this.Invoke(new Action(() =>
{
tnode = new TreeNode(conModel.Database, 1, 1);
tnode.Tag = conConnectionString;
tnode.ContextMenuStrip = contextMenuStripOneDataBase;
node.Nodes.Add(tnode);
}));
var tables = dbObject.GetTables(tnode.Text);
var views = dbObject.GetVIEWs(tnode.Text);
this.Invoke(new Action(() =>
{
ShowTablesAndViews(tnode, tables, views);
}));
}
}
else if (conModel.DbType.Equals(DatabaseType.PostgreSQL.ToString()))
{
dbObject = new WEF.DbDAL.PostgreSQL.DbObject(conConnectionString);
if (conModel.Database.Equals("all"))
{
DataTable dt = dbObject.GetDBList();
foreach (DataRow dr in dt.Rows)
{
TreeNode tnode = null;
this.Invoke(new Action(() =>
{
tnode = new TreeNode(dr[0].ToString(), 1, 1);
tnode.Tag = conConnectionString.Replace("postgres", dr[0].ToString());
tnode.ContextMenuStrip = contextMenuStripOneDataBase;
node.Nodes.Add(tnode);
}));
var tables = dbObject.GetTables(tnode.Text);
var views = dbObject.GetVIEWs(tnode.Text);
this.Invoke(new Action(() =>
{
ShowTablesAndViews(tnode, tables, views);
}));
}
}
else
{
TreeNode tnode = null;
this.Invoke(new Action(() =>
{
tnode = new TreeNode(conModel.Database, 1, 1);
tnode.Tag = conConnectionString;
tnode.ContextMenuStrip = contextMenuStripOneDataBase;
node.Nodes.Add(tnode);
}));
var tables = dbObject.GetTables(tnode.Text);
var views = dbObject.GetVIEWs(tnode.Text);
this.Invoke(new Action(() =>
{
ShowTablesAndViews(tnode, tables, views);
}));
}
}
else if (conModel.DbType.Equals(DatabaseType.MongoDB.ToString()))
{
var dataBaseName = "admin";
var mongoDBTool = MongoDBTool.Connect(conConnectionString);
if (conModel.Database.Equals("all"))
{
var dataBaseNames = mongoDBTool.GetDataBases();
foreach (var dbs in dataBaseNames)
{
TreeNode tnode = null;
this.Invoke(new Action(() =>
{
tnode = new TreeNode(dbs, 1, 1);
tnode.Tag = conConnectionString.Replace(dataBaseName, dbs);
tnode.ContextMenuStrip = contextMenuStripOneMongoDB;
node.Nodes.Add(tnode);
}));
var cs = mongoDBTool.GetCollections(dbs);
this.Invoke(new Action(() =>
{
ShowCollections(tnode, cs);
}));
}
}
else
{
dataBaseName = conModel.Database;
TreeNode tnode = null;
this.Invoke(new Action(() =>
{
tnode = new TreeNode(conModel.Database, 1, 1);
tnode.Tag = conConnectionString;
tnode.ContextMenuStrip = contextMenuStripOneMongoDB;
node.Nodes.Add(tnode);
}));
var collections = mongoDBTool.GetCollections(dataBaseName);
this.Invoke(new Action(() =>
{
ShowCollections(tnode, collections);
}));
}
}
LoadForm.HideLoading(this);;
}
catch (Exception ex)
{
LoadForm.HideLoading(this);;
MessageBox.Show(ex.Message, "出错啦!", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
finally
{
this.Invoke(new Action(() =>
{
node.Expand();
}));
}
});
}
/// <summary>
/// Ejecuta una consulta
/// </summary>
internal async Task ExecuteQueryAsync(ConnectionModel connection, string query,
Models.ArgumentListModel arguments,
TimeSpan timeout, CancellationToken cancellationToken)
{
await Task.Run(() => new ScriptSqlController(this).ExecuteAsync(GetDbProvider(connection), query, arguments, timeout, cancellationToken));
}
/// <summary>
/// Graba los datos del esquema de una conexión
/// </summary>
public async Task SaveAsync(ConnectionModel connection, string fileName)
{
new SchemaXmlManager().Save(await Manager.DbScriptsManager.GetDbSchemaAsync(connection, System.Threading.CancellationToken.None),
fileName);
}
/// <summary>
/// Ejecuta un archivo
/// </summary>
private async Task <bool> ExecuteFileAsync(BlockLogModel block, ExecuteFilesItemViewModel file, ConnectionModel connection,
Application.Connections.Models.ArgumentListModel arguments, System.Threading.CancellationToken cancellationToken)
{
bool executed = false;
System.Timers.Timer timer = new System.Timers.Timer(TimeSpan.FromMilliseconds(500).TotalMilliseconds);
// Asigna el manejador de eventos al temporizador
timer.Elapsed += (sender, args) => file.SetStatus(ExecuteFilesItemViewModel.Status.Start, "Ejecutando ...");
timer.Start();
// Ejecuta el archivo
try
{
string content = LibHelper.Files.HelperFiles.LoadTextFile(System.IO.Path.Combine(file.Path, file.FileName));
// Ejecuta el contenido del archivo
if (string.IsNullOrWhiteSpace(content))
{
file.SetStatus(ExecuteFilesItemViewModel.Status.Error, "El archivo está vacío");
}
else
{
// Arranca la ejecución
file.SetStatus(ExecuteFilesItemViewModel.Status.Start, "Ejecutando ...");
// Ejecuta la consulta
await SolutionViewModel.MainViewModel.Manager.ExecuteQueryAsync(connection, content, arguments,
connection.TimeoutExecuteScript, cancellationToken);
// Detiene la ejecución
file.SetStatus(ExecuteFilesItemViewModel.Status.End, "Fin de ejecución");
}
// Indica que se ha ejecutado correctamente
executed = true;
}
catch (Exception exception)
{
block.Error($"Error al ejecutar el archivo '{file.FileName}'");
block.Error(exception.Message);
file.SetStatus(ExecuteFilesItemViewModel.Status.Error, $"Error al ejecutar el archivo. {exception.Message}");
}
// Detiene el reloj
timer.Stop();
timer.Dispose();
// Devuelve el valor que indica si se ha ejecutado correctamente
return(!executed);
}
public FieldServiceTests()
{
_connectionModel = new ConnectionModel();
_instrumentName = "TestInstrumentName";
_serverParkName = "TestServerParkName";
}
/// <summary>
/// Ejecuta la consulta
/// </summary>
public async Task ExecuteQueryAsync()
{
string querySelected = GetEditorSelectedText();
if (string.IsNullOrWhiteSpace(querySelected))
{
SolutionViewModel.MainController.HostController.SystemController.ShowMessage("Introduzca una consulta para ejecutar");
}
else
{
ConnectionModel connection = ComboConnections.GetSelectedConnection();
if (connection == null)
{
SolutionViewModel.MainController.HostController.SystemController.ShowMessage("Seleccione una conexión");
}
else
{
(ArgumentListModel arguments, string error) = SolutionViewModel.ConnectionExecutionViewModel.GetParameters();
if (!string.IsNullOrWhiteSpace(error))
{
SolutionViewModel.MainController.HostController.SystemController.ShowMessage(error);
}
else
{
// Limpia los datos
DataResults = null;
// Arranca la consulta
StartQuery();
// Ejecuta la consulta
try
{
// Actualiza la página actual si es una consulta nueva
if (string.IsNullOrWhiteSpace(_lastQuery) || !querySelected.Equals(_lastQuery, StringComparison.CurrentCultureIgnoreCase))
{
ActualPage = 1;
}
// Carga la consulta
if (PaginateQuery)
{
DataResults = await SolutionViewModel.Manager.GetDatatableQueryAsync(connection, querySelected, arguments,
ActualPage, PageSize,
connection.TimeoutExecuteScript,
_cancellationToken);
}
else
{
DataResults = await SolutionViewModel.Manager.GetDatatableQueryAsync(connection, querySelected, arguments, 0, 0,
connection.TimeoutExecuteScript,
_cancellationToken);
}
// Guarda la consulta que se acaba de lanzar
_lastQuery = querySelected;
}
catch (Exception exception)
{
SolutionViewModel.Manager.Logger.Default.LogItems.Error($"Error al ejecutar la consulta. {exception.Message}");
}
// Detiene la ejecucion
StopQuery();
}
}
}
}
public IDataSet GetDataSet(ConnectionModel connectionModel, string databaseFile)
{
var dataLink = _localDataLinkProvider.GetDataLink(connectionModel, databaseFile);
return(dataLink.Read(null));
}
/// <summary>
/// Carga el esquema de una conexión
/// </summary>
public async Task LoadSchemaAsync(ConnectionModel connection, CancellationToken cancellationToken)
{
await DbScriptsManager.LoadSchemaAsync(connection, cancellationToken);
}
public void WriteDataRecord(ConnectionModel connectionModel, IDataRecord dataRecord, string instrumentName, string serverParkName)
{
var dataLink = _remoteDataLinkProvider.GetDataLink(connectionModel, instrumentName, serverParkName);
dataLink.Write(dataRecord);
}
/// <summary>
/// Ejecuta una consulta sobre una conexión
/// </summary>
public async Task ExecuteQueryAsync(ConnectionModel connection, string query, ArgumentListModel arguments,
TimeSpan timeout, CancellationToken cancellationToken)
{
await DbScriptsManager.ExecuteQueryAsync(connection, query, arguments, timeout, cancellationToken);
}
/// <summary>
/// Ejecuta una consulta interpretada sobre una conexión
/// </summary>
public async Task ExecuteInterpretedQueryAsync(ConnectionModel connection, string query, ArgumentListModel arguments, CancellationToken cancellationToken)
{
await DbScriptsManager.ExecuteInterpretedQueryAsync(connection, query, arguments, cancellationToken);
}
public NodeConnectionViewModel(TreeSolutionBaseViewModel trvTree, IHierarchicalViewModel parent, ConnectionModel connection) :
base(trvTree, parent, connection.Name, TreeConnectionsViewModel.NodeType.Connection.ToString(), TreeConnectionsViewModel.IconType.Connection.ToString(),
connection, true, true, MvvmColor.Red)
{
Connection = connection;
}
