public MultyQueryResultInfo ReadCurrentResult(
ConnectionGroupInfo connectionGroup,
ConcreteTemplateNodeDefinition concreteTemplateNode
)
{
MultiQueryResultReader multiQueryResultReader = new MultiQueryResultReader(Model, this);
return(multiQueryResultReader.Read(connectionGroup, concreteTemplateNode));
}
protected override long?GetParameterId(
ConnectionGroupInfo connectionGroup,
TemplateNodeQueryInfo query,
string parameterName
)
{
return(Storage.TemplateNodeQueryGroupParameterDirectory
.GetId(connectionGroup, query, parameterName));
}
public Int64?GetId(ConnectionGroupInfo connectionGroup, TemplateNodeQueryInfo groupQuery, string parameterName)
{
long?queryId = Storage.TemplateNodeQueryGroupDirectory
.GetId(connectionGroup, groupQuery);
return(this.GetRecordIdByFields(
this.CreateField(TemplateNodeQueryGroupDirectory.TableName.AsFk(), queryId),
this.CreateField(ParameterNameFieldName, parameterName)
));
}
public MultyQueryResultInfo ReadCurrentResult(
ConnectionGroupInfo connectionGroup,
ConcreteTemplateNodeDefinition concreteTemplateNode
)
{
return(this._storageManager.ReadCurrentResult(
connectionGroup,
concreteTemplateNode
));
}
public ServerProperties GetServerProperties(
InstanceInfo instance
)
{
ConnectionGroupInfo connectionGroup = instance.ConnectionGroup;
connectionGroup.ReadGroupIdFrom(Storage.ConnectionGroupDirectory);
Int64?loginId = Storage.LoginDirectory.GetId(instance);
string clause = string.Join(" AND ",
new List <string>
{
ConnectionGroupIdFn.AsSqlClausePair(),
LoginIdFn.AsSqlClausePair(),
ConnectionNameFn.AsSqlClausePair(),
DbTypeFn.AsSqlClausePair(),
IsDynamicConnectionFn.AsSqlClausePair()
}
);
List <ITableRow> rows = this.GetRows(
clause,
new List <SQLiteParameter>
{
SQLiteHelper.GetParameter(ConnectionGroupIdFn, connectionGroup.Identity),
SQLiteHelper.GetParameter(LoginIdFn, loginId),
SQLiteHelper.GetParameter(ConnectionNameFn, instance.Name),
SQLiteHelper.GetParameter(DbTypeFn, instance.DbType),
SQLiteHelper.GetParameter(IsDynamicConnectionFn, instance.IsDynamicConnection)
},
1
);
if (rows != null)
{
if (rows.Count != 0)
{
ITableRow row = rows.ElementAt(0);
string version = row.GetValue <string>(ServerInstanceVersionFn);
string name = row.GetValue <string>(ServerInstanceNameFn);
if (!string.IsNullOrEmpty(version))
{
return(new ServerProperties(
new InstanceVersion(version),
name,
DateTime.Now
));
}
}
}
return(null);
}
public int?GetDataRowCount(
ConnectionGroupInfo connectionGroup,
ConcreteTemplateNodeDefinition concreteTemplateNode
)
{
int?result =
this._storageManager.GetDataRowCount(connectionGroup, concreteTemplateNode) ??
this._storageManager.CurrentStorage.GetRowCount(concreteTemplateNode.TemplateNode);
return(result);
}
public MultyQueryResultInfo Read(
ConnectionGroupInfo connectionGroup,
ConcreteTemplateNodeDefinition concreteTemplateNode
)
{
var result = new MultyQueryResultInfo();
this.ReadFromMeta(connectionGroup, concreteTemplateNode, result);
this.ReadFromCodeGuard(concreteTemplateNode, result);
return(result);
}
private void SaveQueryParameters(ConcreteTemplateNodeDefinition savedNode, ConnectionGroupInfo connection)
{
if (savedNode == null)
{
return;
}
var templateNodeInfo = savedNode.TemplateNode;
Program.Model.GetVaultProcessor(connection)
.CurrentStorage.Save(templateNodeInfo);
}
public Int64?GetId(ConnectionGroupInfo connectionGroup, TemplateNodeQueryInfo query, string parameterName)
{
TemplateNodeInfo templateNode = query.TemplateNode.IsInstance
? query.TemplateNode.Template
: query.TemplateNode;
long?queryId = Storage.TemplateNodeQueryDirectory
.GetId(connectionGroup, templateNode, query);
return(this.GetRecordIdByFields(
this.CreateField(TemplateNodeQueryDirectory.TableName.AsFk(), queryId),
this.CreateField(ParameterNameFieldName, parameterName)
));
}
/// <summary>
/// Get Id for data
/// </summary>
/// <param name="connectionGroup"></param>
/// <returns></returns>
public Int64?GetId(ConnectionGroupInfo connectionGroup)
{
Int64?connectionGroupId = null;
if (connectionGroup != null)
{
connectionGroupId = this.GetRecordIdByFields(
this.CreateField(NameFn, connectionGroup.Name),
this.CreateField(IsDirectConnectionFn, connectionGroup.IsDirectConnection)
);
}
return(connectionGroupId);
}
private string ComposeFileName(
string directory,
ConnectionGroupInfo connectionGroup
)
{
string strFilePath = string.Format("MSSQLServerAuditor.{0}",
connectionGroup.Identity
);
return(Path.Combine(
directory,
strFilePath
));
}
private void EstablishNewConnection()
{
frmConnectionSelection selector = new frmConnectionSelection();
selector.SetConnectionGroupInfos(this._model.GetAvailableConnections());
if (selector.ShowDialog() == DialogResult.OK)
{
ConnectionGroupInfo connectionGroup = selector.SelectedConnectionGroupInfo.ExtractSelectedGroup();
ConnectionTabControl targetTab = GetTargetTab(connectionGroup.Name + "{" + connectionGroup.TemplateFileName + "}");
targetTab.OpenConnection(connectionGroup);
}
}
private void ReadFromMeta(
ConnectionGroupInfo connectionGroup,
ConcreteTemplateNodeDefinition concreteTemplateNode,
MultyQueryResultInfo result
)
{
NodeResultReader nodeResultReader = new MetaResultReader(
this._msSqlAuditor,
this._storageManager,
connectionGroup,
concreteTemplateNode
);
nodeResultReader.ReadTo(result);
}
public Int64?GetId(ConnectionGroupInfo connectionGroup, TemplateNodeQueryInfo query)
{
Debug.Assert(query.TemplateNode.GroupQueries.Contains(query));
TemplateNodeInfo templateNode = query.TemplateNode.IsInstance
? query.TemplateNode.Template
: query.TemplateNode;
long?templateNodeId = Storage.TemplateNodeDirectory.GetId(connectionGroup, templateNode);
return(this.GetRecordIdByFields(
this.CreateField(TemplateNodeDirectory.TableName.AsFk(), templateNodeId),
this.CreateField(TemplateNodeQueryGroupIdFieldName, query.Id),
this.CreateField(TemplateNodeQueryGroupNameFieldName, query.QueryName),
this.CreateField(DefaultDatabaseFieldFn, query.DatabaseForChildrenFieldName)
));
}
private Dictionary <TemplateNodeQueryInfo, DataTable> ReadHistTable(
ConnectionGroupInfo connectionGroup,
ConcreteTemplateNodeDefinition concreteTemplateNode
)
{
Dictionary <TemplateNodeQueryInfo, DataTable> histTable = new Dictionary <TemplateNodeQueryInfo, DataTable>();
TemplateNodeInfo templateNodeInfo = concreteTemplateNode.TemplateNode;
ProgressItem progress = new ProgressItem();
using (SqlProcessor sqlProcessor = MsSqlAuditor.GetNewSqlProcessor(new CancellationToken()))
{
progress.SetPromisedChildCount(1);
MultyQueryResultInfo resultQuery = sqlProcessor.ExecuteMultyQuery(
connectionGroup,
templateNodeInfo.Queries,
progress.GetChild(),
Program.Model.Settings.SystemSettings.MaximumDBRequestsThreadCount,
true
);
if (resultQuery != null)
{
if (resultQuery.List != null)
{
if (resultQuery.List.Count != 0)
{
long requestId = this.Storage.MetaResultTable.GetMaxRequestId() + 1L;
DateTime timestamp = DateTime.Now;
histTable = PrepareHistoryData(resultQuery);
this.Storage.SaveMeta(
templateNodeInfo,
resultQuery,
requestId,
timestamp
);
}
}
}
}
return(histTable);
}
protected bool ValidateAddConnectionForm()
{
InstanceInfo instance = this.cmbConnection.SelectedItem as InstanceInfo;
ConnectionGroupInfo group = this.cmbConnection.SelectedItem as ConnectionGroupInfo;
if ((instance == null || string.IsNullOrEmpty(instance.GetConnectionString())) &&
(group == null || group.Connections.IsNullOrEmpty())
)
{
this.errorProvider.SetError(this.cmbConnection, this.GetLocalizedText("SelectServerError"));
return(false);
}
this.errorProvider.SetError(this.cmbConnection, string.Empty);
return(true);
}
private void UpdateTemplateList()
{
cmbTemplate.Enabled = false;
ClearTemplateList();
ConnectionGroupInfo group = SelectedGroup;
InstanceInfo instance = SelectedInstance;
if (group != null && instance != null)
{
List <TemplateRow> templates = this._templateManager
.GetTemplates(group.Name, instance.Name, instance.DbType)
.Where(row => !Path.IsPathRooted(row.Directory))
.ToList();
foreach (TemplateRow templateRow in templates)
{
string displayName = templateRow.Id;
Template template = this._templates.Find(t => t.Id == templateRow.Name);
if (template != null)
{
displayName = string.Format("{0} ({1})", template.Display, templateRow.Name);
}
BindingWrapper <TemplateRow> templateWrapper = new BindingWrapper <TemplateRow>(
templateRow, row => displayName
);
cmbTemplate.Items.Add(templateWrapper);
}
if (cmbTemplate.Items.Count > 0)
{
cmbTemplate.SelectedIndex = 0;
UpdateLoginList();
}
}
cmbTemplate.Enabled = true;
}
/// <summary>
/// Get ID for data
/// </summary>
/// <param name="connectionGroup">Connection group</param>
/// <param name="templateNode">Template node</param>
/// <param name="templateNodeQuery">Template node query</param>
/// <returns></returns>
public Int64?GetId(
ConnectionGroupInfo connectionGroup,
TemplateNodeInfo templateNode,
TemplateNodeQueryInfo templateNodeQuery
)
{
long?templateNodeId = Storage.TemplateNodeDirectory
.GetId(connectionGroup, templateNode);
string id = templateNodeQuery.Id;
string name = templateNodeQuery.QueryName;
string hierarchy = templateNodeQuery.ResultHierarchy;
return(this.GetRecordIdByFields(
this.CreateField(TemplateNodeIdFieldName, templateNodeId),
this.CreateField(UserIdFieldName, id),
this.CreateField(NameFieldName, name),
this.CreateField(HierarchyFieldName, hierarchy)
));
}
public ConnectionGroupInfo GetGroup(long groupId)
{
ConnectionGroupRow groupRow = this._groupManager
.GetGroupById(groupId);
if (groupRow == null)
{
return(null);
}
ConnectionGroupInfo group = new ConnectionGroupInfo
{
Identity = groupId,
Name = groupRow.Name,
IsDirectConnection = groupRow.IsDirect
};
group.Connections = GetGroupInstances(groupId);
return(group);
}
public EditDirectConnectionDialog(
MsSqlAuditorModel model,
ConnectionGroupInfo connectionGroup
)
{
this._model = model;
CurrentStorage storage = this._model.DefaultVaultProcessor.CurrentStorage;
this._connectionsManager = new ConnectionsManager(model);
this._connectionGroup = connectionGroup;
this._updatesMade = false;
SetLocale();
InitializeComponent();
InitializeEventHandlers();
InitializeBindings();
UpdateControlsState();
}
private List <ConnectionGroupInfo> GetGroupsFromRows(string protocolType, List <ConnectionGroupRow> groupRows)
{
List <ConnectionGroupInfo> groups = new List <ConnectionGroupInfo>();
foreach (ConnectionGroupRow groupRow in groupRows)
{
long?groupId = groupRow.Identity;
ConnectionGroupInfo group = new ConnectionGroupInfo
{
Identity = groupId,
Name = groupRow.Name,
IsDirectConnection = groupRow.IsDirect
};
group.Connections = GetGroupInstances(groupId.Value, protocolType);
groups.Add(group);
}
return(groups);
}
private void mnuNewDirectConnection_Click(object sender, EventArgs e)
{
using (CreateDirectConnectionDialog createConnectionDialog = new CreateDirectConnectionDialog(this._model))
{
if (createConnectionDialog.ShowDialog() == DialogResult.OK)
{
ConnectionData connectionData = createConnectionDialog.ResultConnection;
ConnectionGroupInfo group = connectionData.ConnectionGroup;
Template selectedTemplate = TemplateNodesLoader.GetTemplateByFile(
createConnectionDialog.SelectedTemplateFileFullPath
);
ConnectionTabControl targetTab = GetTargetTab(
group.Name + " {" + group.TemplateFileName + "}"
);
targetTab.SelectedTemplate = selectedTemplate;
targetTab.OpenConnection(group);
}
}
}
private void btnAddConnectionString_Click(object sender, EventArgs e)
{
if (ValidateAddConnectionForm())
{
InstanceInfo instance = this.cmbConnection.SelectedItem as InstanceInfo;
if (instance != null)
{
string cnnString = instance.GetConnectionString();
IEnumerable <InstanceInfo> instances = this.lstConnectionStrings.Items.OfType <InstanceInfo>();
if (!instances.Any(x => cnnString.Equals(x.GetConnectionString())))
{
lstConnectionStrings.Items.Add(instance);
UpdateControlsState();
}
this._updatesMade = true;
return;
}
ConnectionGroupInfo groupInfo = cmbConnection.SelectedItem as ConnectionGroupInfo;
if (groupInfo != null)
{
lstConnectionStrings.Items.Clear();
InstanceInfo[] instances = groupInfo.Connections.ToArray();
lstConnectionStrings.Items.AddRange(instances);
UpdateControlsState();
}
this._updatesMade = true;
}
}
private void UpdateLoginList()
{
cmbLogin.Enabled = false;
ClearLoginList();
ConnectionGroupInfo group = SelectedGroup;
InstanceInfo instance = SelectedInstance;
TemplateRow template = SelectedTemplate;
if (group != null && instance != null && template != null)
{
List <LoginRow> logins = this._loginManager.GetLogins(
template.Name,
group.Name,
instance.Name,
instance.DbType
);
if (logins.Count > 0)
{
foreach (LoginRow loginRow in logins)
{
BindingWrapper <LoginRow> loginWrapper = new BindingWrapper <LoginRow>(
loginRow,
DisplayLogin
);
cmbLogin.Items.Add(loginWrapper);
}
cmbLogin.SelectedIndex = 0;
}
}
cmbLogin.Enabled = true;
}
public void UpdateGroupInstances(ConnectionGroupInfo group, string protocolType)
{
ConnectionGroupRow savedGroupRow = this._groupManager.GetGroupByName(group.Name);
if (savedGroupRow == null)
{
return;
}
long id = savedGroupRow.Identity;
List <ServerInstanceRow> savedRows = this._instanceManager
.GetAllGroupInstances(id, protocolType);
List <InstanceInfo> newInstances = group.Connections;
foreach (ServerInstanceRow savedRow in savedRows)
{
InstanceInfo savedInstance = CreateFromRow(savedRow);
bool exist = newInstances.Any(Predicates.MatchesTo(savedInstance));
if (savedRow.IsDeleted)
{
if (exist)
{
this._instanceManager.RestoreInstance(savedRow);
}
}
else
{
if (!exist)
{
this._instanceManager.DeleteInstance(savedRow);
}
}
}
}
private Dictionary <string, ConnectionInfo> ReadLastConnections(List <ConnectionType> connectionTypes)
{
Dictionary <string, ConnectionInfo> lastConnections = new Dictionary <string, ConnectionInfo>();
string machineName = Environment.MachineName;
foreach (ConnectionType connectionType in connectionTypes)
{
string cnnType = connectionType.Id;
LastConnectionProtocolRow row = this._storage.LastConnectionProtocolTable
.GetLastConnection(machineName, cnnType);
if (row != null)
{
ConnectionGroupInfo group = this._connectionsManager.GetGroup(row.GroupId);
TemplateRow templateRow = this._storage.TemplateDirectory.GetTemplate(row.TemplateId);
if (group != null && templateRow != null)
{
ConnectionInfo connectionInfo = new ConnectionInfo
{
TemplateFile = templateRow.Id,
TemplateDir = templateRow.Directory,
TemplateId = templateRow.Name,
ConnectionId = row.Identity,
GroupName = group.Name,
ConnectionType = cnnType
};
lastConnections.Add(cnnType, connectionInfo);
}
}
}
return(lastConnections);
}
private ConnectionGroupInfo PrepareGroupResult()
{
List <InstanceInfo> instances = this.lstConnectionStrings.Items
.OfType <InstanceInfo>().ToList();
ConnectionGroupInfo group = new ConnectionGroupInfo
{
Connections = instances,
IsExternal = IsExternalTemplateFile,
TemplateDir = Path.GetDirectoryName(SelectedTemplateFile),
TemplateFileName = Path.GetFileName(SelectedTemplateFile),
Name = ConnectionGroupName,
IsDirectConnection = true
};
foreach (InstanceInfo instanceInfo in instances)
{
instanceInfo.ConnectionGroup = group;
}
UpdateGroupInstances(group);
return(group);
}
public MetaResultReader(
MsSqlAuditorModel msSqlAuditor,
StorageManager storageManager,
ConnectionGroupInfo connectionGroup,
ConcreteTemplateNodeDefinition concreteTemplateNode
) : base(
msSqlAuditor,
storageManager,
concreteTemplateNode
)
{
this._instances = new List <InstanceInfo>();
if (base.GroupDefinition.Instance != null)
{
this._instances.Add(base.GroupDefinition.Instance);
}
else
{
this._instances.AddRange(connectionGroup.Connections.Where(info => info.IsEnabled));
}
this._histTable = ReadHistTable(connectionGroup, concreteTemplateNode);
}
/// <summary>
/// Initializes the object ConnectionData.
/// </summary>
/// <param name="model">Model SqlAuditor.</param>
/// <param name="connectionGroup">Info group connection.</param>
public ConnectionData(MsSqlAuditorModel model, ConnectionGroupInfo connectionGroup)
: this(model)
{
ConnectionGroup = connectionGroup;
ReloadTemplate();
}
private void SaveSrcData(
string currentDb,
string reportDb,
ISerializationCancellationToken canceller
)
{
ConnectionData connectionData;
StorageManager backupStorageManager = new StorageManager(
this._model, false, currentDb, null, reportDb);
backupStorageManager.InitializeDataBases();
CheckCancellation(canceller);
IEnumerable <ConcreteTemplateNodeDefinition> nodes =
this._connectionTabControl.GetCurrentTree(out connectionData);
if (nodes != null)
{
IList <ConcreteTemplateNodeDefinition> nodeList = nodes as IList <ConcreteTemplateNodeDefinition> ?? nodes.ToList();
if (nodeList.Any())
{
ConnectionGroupInfo sourceConnection = connectionData.ConnectionGroup;
ConnectionGroupInfo destConnection = sourceConnection.CopyXmlContent();
destConnection.Identity = backupStorageManager.CurrentStorage.ConnectionGroupDirectory.GetId(destConnection);
Dictionary <TemplateNodeInfo, TemplateNodeInfo> clonesDict = new Dictionary <TemplateNodeInfo, TemplateNodeInfo>();
ConnectionData destConnectionData = new ConnectionData(this._model, destConnection);
TemplateNodeInfo nodesRoot = nodeList.First().TemplateNode.GetRootPatent();
TemplateNodeInfo clonedNodesRoot = nodesRoot.CloneNotSavedTree(clonesDict, destConnectionData);
CheckCancellation(canceller);
backupStorageManager.CurrentStorage.NodeInstances.SaveTree(clonedNodesRoot);
CheckCancellation(canceller);
foreach (ConcreteTemplateNodeDefinition concreteTemplateNode in nodeList)
{
CheckCancellation(canceller);
MultyQueryResultInfo queriesResult = this._model.DefaultVaultProcessor.ReadCurrentResult(
sourceConnection,
concreteTemplateNode
);
CheckCancellation(canceller);
TemplateNodeInfo templateNode = concreteTemplateNode.TemplateNode;
if (queriesResult != null)
{
backupStorageManager.SerializeData(
clonesDict[templateNode],
queriesResult
);
}
}
}
}
}
private void SaveQueryParameters(ConcreteTemplateNodeDefinition savedNode, ConnectionGroupInfo connection)
{
if (savedNode == null)
{
return;
}
var templateNodeInfo = savedNode.TemplateNode;
Program.Model.GetVaultProcessor(connection)
.CurrentStorage.Save(templateNodeInfo);
}
