public string GetXslFileName(ConcreteTemplateNodeDefinition nodeDefinition)
{
string dbName = string.Empty;
TemplateNodeInfo templateToDisplay = GetTemplateToDisplay(nodeDefinition, out dbName);
if (string.IsNullOrEmpty(templateToDisplay.XslTemplateFileName))
{
return(null);
}
if (!string.IsNullOrWhiteSpace(templateToDisplay.XslTemplateFileName))
{
return(this._model.FilesProvider.GetXslLocalizedTemplateFileName(
templateToDisplay.XslTemplateFileName,
nodeDefinition.Connection.TemplateDir
));
}
TemplateNodeLocaleInfo localized = templateToDisplay.GetLocale(
true,
this._model.Settings.ReportLanguage
);
return(this._model.FilesProvider.GetXslTemplateFileName(
localized.TemplateFile,
nodeDefinition.Connection.TemplateDir
));
}
private string GetFileName(
TemplateNodeInfo node,
ConnectionGroupInfo connectionGroup
)
{
string rootFolder = string.Empty;
do
{
Debug.Assert(node.IsInstance);
string strFilePath = string.Format("{0}",
node.TemplateNodeId
);
rootFolder = Path.Combine(
strFilePath.GetValidFileName(),
rootFolder
);
node = node.Parent;
} while (node != null);
rootFolder = Path.Combine(connectionGroup.Identity.ToSafeString(), rootFolder);
return(ComposeFileName(rootFolder, connectionGroup));
}
private void SetChildrenNotProcessedYet(TemplateNodeInfo node, bool value)
{
Debug.Assert(node.IsInstance);
Debug.Assert(node.TemplateNodeId != null);
if (node.TemplateNodeId == null)
{
this.Save(node);
}
if (node.TemplateNodeId == null)
{
throw new InvalidOperationException(node + " is not saved (has no PrimaryKey)");
}
using (this.Connection.OpenWrapper())
{
String query = string.Format(
"UPDATE [{0}] SET [{1}] = {2} WHERE [{3}] = {4} AND ([{1}] IS NULL OR [{1}] != {2});",
TableName,
ChildrenNotYetProcessedFn,
SqLiteBool.ToBit(value),
IdentityField,
node.TemplateNodeId.Value
);
new SqlCustomCommand(this.Connection, query).Execute(1);
}
}
public string GetTableName(
TemplateNodeQueryInfo templateNodeQueryInfo,
Int64 recordSet
)
{
TemplateNodeInfo templateNode = templateNodeQueryInfo.TemplateNode;
Debug.Assert(templateNodeQueryInfo.TemplateNode.IsInstance);
long?id = this.CurrentStorage.TemplateNodeDirectory.GetId(
templateNode.ConnectionGroup,
templateNode.Template
);
string tableName = String.Format(
"t_{0}_{1}_{2}_q{3}_r{4}",
templateNode.TemplateId ?? String.Empty,
id,
templateNodeQueryInfo.QueryName,
templateNodeQueryInfo.Id ?? "0",
recordSet
);
// Log.InfoFormat("tableName:'{0}'",
// tableName
// );
return(tableName);
}
public List <TemplateNodeUpdateJob> GetJobs(TemplateNodeInfo node)
{
long templateNodeId = node.TemplateNodeId.GetValueOrDefault();
List <ScheduleSettingsRow> rows = this._currentStorage.ScheduleSettingsTable
.GetAllRowsByTemplateNodeId(templateNodeId);
List <TemplateNodeUpdateJob> jobs = new List <TemplateNodeUpdateJob>();
foreach (ScheduleSettingsRow row in rows)
{
if (row != null)
{
TemplateNodeUpdateJob job = this.CreateJob(row, node);
jobs.Add(job);
}
else
{
jobs.Add(TemplateNodeUpdateJob.Empty);
}
}
return(jobs);
}
/// <summary>
/// Get Id for data
/// </summary>
/// <param name="connectionGroup">Connection group</param>
/// <param name="templateNode">Template node</param>
/// <returns></returns>
public Int64?GetId(ConnectionGroupInfo connectionGroup, TemplateNodeInfo templateNode)
{
Debug.Assert(!templateNode.IsInstance);
Int64?parentId = null;
if (templateNode.Parent != null)
{
parentId = this.GetId(connectionGroup, templateNode.Parent);
}
long?templateId = Storage.TemplateDirectory.GetId(connectionGroup);
TemplateNodeQueryInfo pq = templateNode.GetParentQuery();
object parentQueryId = pq != null
? (object)Storage.TemplateNodeQueryGroupDirectory.GetId(connectionGroup, pq)
: null;
return(this.GetRecordIdByFields(
this.CreateField(TemplateIdFn, templateId),
this.CreateField(ParentIdFn, parentId),
this.CreateField(UserIdFieldName, templateNode.Id),
this.CreateField(NameFn, templateNode.Name),
this.CreateField(IconFieldName, templateNode.IconImageReferenceName),
this.CreateField(ShowIfEmptyFieldName, !templateNode.HideEmptyResultDatabases),
this.CreateField(ShowNumberOfRecordsFieldName, templateNode.ShowNumberOfRecords),
this.CreateField(ParentQueryGroupIdFn, parentQueryId)
));
}
public abstract long?GetQueryId(
TemplateNodeInfo node,
TemplateNodeQueryInfo templateNodeQuery,
InstanceInfo instance,
DateTime dateCreated,
bool onlyFind
);
private void DrawOverlayIcon(DrawTreeNodeEventArgs e)
{
if (ActiveScheduleOverlayImage == null)
{
return;
}
ConcreteTemplateNodeDefinition definition = e.Node.Tag as ConcreteTemplateNodeDefinition;
if (definition != null && definition.NodeActivated)
{
TemplateNodeInfo nodeDef = definition.TemplateNode;
// Draw overlay icon if the node has active jobs
if (nodeDef != null && nodeDef.HasActiveJobs)
{
Image overlayImage = ActiveScheduleOverlayImage;
int nodeHeight = e.Node.Bounds.Height;
// Overlay image size and coordinates
int imgSize = nodeHeight / 2;
int imgLeft = e.Node.Bounds.Left - SPACE_IL - imgSize;
int imgTop = e.Node.Bounds.Bottom - imgSize;
// draw overlay icon
e.Graphics.DrawImage(
overlayImage,
imgLeft,
imgTop,
imgSize,
imgSize
);
}
}
}
public void SaveScheduledUpdateTime(TemplateNodeInfo node, DateTime value)
{
Debug.Assert(node.IsInstance);
Debug.Assert(node.TemplateNodeId != null);
if (node.TemplateNodeId == null)
{
this.Save(node);
}
if (node.TemplateNodeId == null)
{
throw new InvalidOperationException(node + " is not saved (has no PrimaryKey)");
}
using (this.Connection.OpenWrapper())
{
string query = string.Format(
"UPDATE [{0}] SET [{1}] = @dateTimeValue WHERE [{2}] = {3} AND ([{1}] IS NULL OR [{1}] != @dateTimeValue);",
TableName,
NodeScheduledUpdateFn,
IdentityField,
node.TemplateNodeId.Value
);
new SqlCustomCommand(this.Connection, query, new SQLiteParameter("@dateTimeValue", value))
.Execute(0);
}
}
public void SaveRequestedData(
TemplateNodeInfo templateNodeInfo,
MultyQueryResultInfo results
)
{
this._storageManager.SaveRequestedData(templateNodeInfo, results);
}
internal int?GetRowCount(TemplateNodeInfo node)
{
Debug.Assert(node.IsInstance);
int cachedValue = 0;
int?rowsTotal = null;
if (node.TemplateNodeId == null)
{
return(null);
}
if (this._nodesRowCountCache.TryGetValue(node.TemplateNodeId.Value, out cachedValue))
{
return(cachedValue);
}
foreach (InstanceInfo serverInstance in node.ConnectionGroup.Connections)
{
foreach (TemplateNodeQueryInfo tqi in node.Queries)
{
Int64?queryId = this.QueryDirectory.GetQueryId(
node,
tqi,
serverInstance,
new DateTime(),
true
);
if (queryId == null)
{
continue;
}
if (rowsTotal == null)
{
rowsTotal = 0;
}
ITableRow lastMetaRow = this.ReadLastMeta(queryId.Value);
rowsTotal += lastMetaRow != null
? (int)(Int64)lastMetaRow.Values[MetaResultTable.RowCountFieldName]
: 0;
}
}
if (rowsTotal == null)
{
return(null);
}
this._nodesRowCountCache.AddOrUpdate(node.TemplateNodeId.Value, id => rowsTotal.Value, (id, old) => rowsTotal.Value);
//NodeInstances.SetReportsRowCountTotal(node.PrimaryKey.Value, rowsTotal.Value);
return(rowsTotal.Value);
}
private TemplateNodeUpdateJob CreateJob(ScheduleSettingsRow row, TemplateNodeInfo node)
{
var scheduleSettings = new ScheduleSettings
{
ActiveWeekDays = row.ActiveWeekDays
.Split(',')
.Select(
s =>
{
DayOfWeek result;
if (Enum.TryParse(s, out result))
{
return(result as DayOfWeek?);
}
return(null);
})
.Where(d => d != null)
.Select(d => d.Value).ToList(),
Enabled = row.Enabled,
Id = row.TemplateNodesScheduleUserId,
Name = row.TemplateNodesScheduleUserName,
IsSendMessage = row.IsSendMessage,
EndDate = row.EndDate.GetValueOrDefault(),
OccursOnceDateTime = row.OccursOnceDateTime,
OccursOnceDateTimeEnabled = row.OccursOnceDateTimeEnabled,
StartDate = row.StartDate,
DayOfMonth = new DayOfMonthSettings
{
DayNumber = (int)row.DayNumber
},
ReccurPeriod = new TimeUnitBasedPeriod(
(ReccurPeriodTimeUnit)row.TimeUnit,
(int)row.TimeUnitCount),
DailyFrequency =
new DailyFrequency
{
EndingAt = row.EndingAt.FromTicks(),
OccursOnceTime = row.OccursOnceTime.FromTicks(),
PeriodTimeUnit = row.PeriodTimeUnit.HasValue
? (DailyFrequency.TimeUnit?)row.PeriodTimeUnit.Value
: null,
PeriodTimeUnitCount = (int?)row.PeriodTimeUnitCount,
StartingAt = row.StartingAt.FromTicks(),
OccursOnce = row.OccursOnce
},
HasEndDate = row.EndDate.HasValue
};
return(new TemplateNodeUpdateJob
{
LastRan = row.LastRan,
Settings = scheduleSettings,
NodeInfo = node,
SettingsId = row.Identity
});
}
private void SaveDynamicConnections(
TemplateNodeInfo templateNode,
MultyQueryResultInfo queriesResult
)
{
foreach (TemplateNodeResultItem templateNodeResultItem in queriesResult.List)
{
TemplateNodeQueryInfo queryInfo = templateNodeResultItem.TemplateNodeQuery;
TemplateNodeInfo templateNodeClone = templateNode;
if (queryInfo.ConnectionsSelectId != null)
{
QueryResultInfo queryResult = templateNodeResultItem.QueryResult;
foreach (InstanceInfo instanceInfo in templateNodeClone.ConnectionGroup.Connections)
{
Int64?destParentQueryId = this.CurrentStorage.QueryDirectory.GetQueryId(
templateNode,
queryInfo,
instanceInfo,
DateTime.Now,
false
);
foreach (KeyValuePair <InstanceInfo, QueryInstanceResultInfo> queryInstanceResultInfo in queryResult.InstancesResult)
{
InstanceInfo selectConnectionInstance = queryInstanceResultInfo.Key;
Int64?dynamicQueryId = this.CurrentStorage.QueryDirectory.GetQueryId(
templateNodeClone,
queryInfo,
selectConnectionInstance,
DateTime.Now,
false
);
if (destParentQueryId == null)
{
continue;
}
DynamicConnection dynamicConnection = new DynamicConnection(
selectConnectionInstance.Name,
selectConnectionInstance.Type.ToString(),
selectConnectionInstance.IsODBC,
dynamicQueryId
);
this.CurrentStorage.DynamicConnectionDirectory.UpdateConnection(
destParentQueryId.Value,
dynamicConnection
);
}
}
}
}
}
public void SaveTree(TemplateNodeInfo node)
{
this.Save(node);
foreach (TemplateNodeInfo ch in node.Childs)
{
this.SaveTree(ch);
}
this.SetChildrenNotProcessedYet(node, false);
}
public void UpdateTreeNodeTimings(
TemplateNodeInfo node,
MultyQueryResultInfo results
)
{
UpdateTreeNodeTimings(
node,
results.NodeLastUpdated,
results.NodeLastUpdateDuration
);
}
/// <summary>
/// Load template from Xml-file
/// </summary>
/// <param name="model">Model mssql auditor.</param>
/// <param name="document">XML document.</param>
/// <param name="connectionGroup"></param>
/// <returns>List of templates</returns>
public static TemplateNodeInfo LoadFromXml(MsSqlAuditorModel model, XmlDocument document, out string startupTemplateId, out Stack <string> startupTemplateInfoIdStack)
{
var serializer = new XmlSerializer(typeof(Template));
var root = new TemplateNodeInfo();
string templateId = null;
//
// #248 - fix memory leaks during XML files processing
//
// var nodeReader = new XmlNodeReader(document);
root.Locales = new List <TemplateNodeLocaleInfo>();
using (var nodeReader = new XmlNodeReader(document))
{
using (var xmlReader = XmlReader.Create(nodeReader, XmlUtils.GetXmlReaderSettings()))
{
var wrapper = (Template)serializer.Deserialize(xmlReader);
root.MainFormWindowTitle = wrapper.MainFormWindowTitle;
root.TreeTitle = wrapper.TreeTitle;
root.Childs = wrapper.Infos;
templateId = wrapper.Id;
startupTemplateId = wrapper.StartupTemplateId;
foreach (var localeInfo in wrapper.Locales)
{
root.Locales.Add(new TemplateNodeLocaleInfo()
{
Language = localeInfo.Language,
Text = localeInfo.Text,
TemplateFile = localeInfo.TemplateFile
});
}
root.TemplateId = templateId;
root.Queries = new List <TemplateNodeQueryInfo>();
root.GroupQueries = wrapper.GroupQueries ?? new List <TemplateNodeQueryInfo>();
root.ConnectionQueries = new List <TemplateNodeQueryInfo>();
root.SqlCodeGuardQueries = new List <TemplateNodeSqlGuardQueryInfo>();
startupTemplateInfoIdStack = new Stack <string>();
if (!String.IsNullOrEmpty(startupTemplateId))
{
SetupStartupTemplateNodeIdStack(wrapper.Infos, startupTemplateInfoIdStack, startupTemplateId);
}
}
}
NormalizeTemplateNode(root);
root.Init(templateId, model);
return(root);
}
/// <summary>
/// Load template from Xml-file
/// </summary>
/// <param name="model">Model mssql auditor.</param>
/// <param name="document">XML document.</param>
/// <param name="connectionGroup"></param>
/// <returns>List of templates</returns>
public static TemplateNodeInfo LoadFromXml(MsSqlAuditorModel model, XmlDocument document, out string startupTemplateId, out Stack<string> startupTemplateInfoIdStack)
{
var serializer = new XmlSerializer(typeof(Template));
var root = new TemplateNodeInfo();
string templateId = null;
//
// #248 - fix memory leaks during XML files processing
//
// var nodeReader = new XmlNodeReader(document);
root.Locales = new List<TemplateNodeLocaleInfo>();
using (var nodeReader = new XmlNodeReader(document))
{
using (var xmlReader = XmlReader.Create(nodeReader, XmlUtils.GetXmlReaderSettings()))
{
var wrapper = (Template)serializer.Deserialize(xmlReader);
root.MainFormWindowTitle = wrapper.MainFormWindowTitle;
root.TreeTitle = wrapper.TreeTitle;
root.Childs = wrapper.Infos;
templateId = wrapper.Id;
startupTemplateId = wrapper.StartupTemplateId;
foreach (var localeInfo in wrapper.Locales)
{
root.Locales.Add(new TemplateNodeLocaleInfo()
{
Language = localeInfo.Language,
Text = localeInfo.Text,
TemplateFile = localeInfo.TemplateFile
});
}
root.TemplateId = templateId;
root.Queries = new List<TemplateNodeQueryInfo>();
root.GroupQueries = wrapper.GroupQueries ?? new List<TemplateNodeQueryInfo>();
root.ConnectionQueries = new List<TemplateNodeQueryInfo>();
root.SqlCodeGuardQueries = new List<TemplateNodeSqlGuardQueryInfo>();
startupTemplateInfoIdStack = new Stack<string>();
if (!String.IsNullOrEmpty(startupTemplateId))
{
SetupStartupTemplateNodeIdStack(wrapper.Infos, startupTemplateInfoIdStack, startupTemplateId);
}
}
}
NormalizeTemplateNode(root);
root.Init(templateId, model);
return root;
}
private static void NormalizeTemplateNode(TemplateNodeInfo node)
{
foreach (TemplateNodeLocaleInfo locale in node.Locales)
{
locale.Text = locale.Text.RemoveWhitespaces();
}
foreach (TemplateNodeInfo subnode in node.Childs)
{
NormalizeTemplateNode(subnode);
}
}
public void UpdateTreeNodeTimings(
TemplateNodeInfo node,
DateTime?lastUpdateDateTime,
DateTime?lastUpdateDuration
)
{
NodeInstances.UpdateTreeNodeLastUpdateAndDuration(
node,
lastUpdateDateTime,
lastUpdateDuration
);
}
public void UpdateTreeNodeCounterValue(
TemplateNodeInfo node,
int?counterValue
)
{
int?currentValue = GetTreeNodeCounterValue(node);
if (!Nullable.Equals(counterValue, currentValue))
{
NodeInstances.UpdateTreeNodeCounterValue(node, counterValue);
}
}
/// <summary>
/// Convert TemplateNodeInfo to the plain list
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
private static IEnumerable <TemplateNodeInfo> ToPlainList(TemplateNodeInfo node)
{
var result = new List <TemplateNodeInfo> {
node
};
foreach (var child in node.Childs)
{
result.AddRange(ToPlainList(child));
}
return(result);
}
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)
));
}
internal void SaveMeta(
TemplateNodeInfo templateNodeInfo,
MultyQueryResultInfo results,
long requestId,
DateTime timestamp
)
{
Debug.Assert(templateNodeInfo.IsInstance);
Int64 sessionId = 1L;
List <ITableRow> metaRows = new List <ITableRow>();
foreach (TemplateNodeResultItem tuple in results.List)
{
TemplateNodeQueryInfo templateNodeQuery = tuple.TemplateNodeQuery;
QueryResultInfo queryResult = tuple.QueryResult;
foreach (QueryInstanceResultInfo queryInstanceResult in queryResult.InstancesResult.Values)
{
InstanceInfo instance = queryInstanceResult.Instance;
Int64?queryId = this.QueryDirectory.GetQueryId(
templateNodeInfo,
templateNodeQuery,
instance,
timestamp,
false);
Log.InfoFormat("Instance:'{0}';QueryId:'{1}'",
instance,
queryId
);
ITableRow row = this.MetaResultTable.GetMetaRow(
requestId,
sessionId,
timestamp,
queryInstanceResult,
queryId,
null
);
metaRows.Add(row);
}
}
this.MetaResultTable.ReplaceRows(metaRows);
this.ResetRowCountCache(templateNodeInfo);
}
public void SerializeData(
TemplateNodeInfo templateNodeInfo,
MultyQueryResultInfo queriesResult
)
{
SaveDynamicConnections(templateNodeInfo, queriesResult);
SaveRequestedData(templateNodeInfo, queriesResult);
this.CurrentStorage.UpdateTreeNodeTimings(
templateNodeInfo,
queriesResult
);
}
internal void ResetRowCountCache(TemplateNodeInfo node)
{
int oldValue = 0;
if (node != null)
{
if (node.TemplateNodeId != null)
{
this._nodesRowCountCache.TryRemove(
node.TemplateNodeId.Value,
out oldValue
);
}
}
}
public Tuple <DateTime?, DateTime?> GetTreeNodeLastUpdateAndDuration(TemplateNodeInfo node)
{
DateTime?lastUpdate = null;
DateTime?lastUpdateDuration = null;
Debug.Assert(node.IsInstance);
if (node.TemplateNodeId == null)
{
return(new Tuple <DateTime?, DateTime?>(null, null));
}
using (this.Connection.OpenWrapper())
{
String query = string.Format(
"SELECT {0}, {1} FROM [{2}] WHERE {3} = {4}",
NodeLastUpdated,
NodeLastUpdateDuration,
TableName,
IdentityField,
node.TemplateNodeId.Value
);
using (SQLiteCommand cmd = new SQLiteCommand(query, this.Connection))
{
using (SQLiteDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
int ordinalDateUpdate = reader.GetOrdinal(NodeLastUpdated);
int ordinalDateUpdateDuration = reader.GetOrdinal(NodeLastUpdateDuration);
if (!reader.IsDBNull(ordinalDateUpdate))
{
lastUpdate = reader.GetDateTime(ordinalDateUpdate);
}
if (!reader.IsDBNull(ordinalDateUpdateDuration))
{
lastUpdateDuration = reader.GetDateTime(ordinalDateUpdateDuration);
}
}
}
}
}
return(new Tuple <DateTime?, DateTime?>(lastUpdate, lastUpdateDuration));
}
private void tmSchedulerTimer_Tick(object sender, EventArgs e)
{
foreach (ConnectionData connection in Connections)
{
List <Tuple <TemplateNodeInfo, Job> > nodeJobs = new List <Tuple <TemplateNodeInfo, Job> >();
connection.RootOfStaticTree.GetScheduledNodes(nodeJobs, true);
foreach (Tuple <TemplateNodeInfo, Job> nodeJob in nodeJobs)
{
Job job = nodeJob.Item2;
TemplateNodeInfo node = nodeJob.Item1;
ConnectionData localConnection = connection;
Action action = () =>
{
TreeNode uiTreeNode = FindJobbedUiTreeNode(job) ?? CreateTreeViewNode(node);
Action sendEmailAction = null;
if (job.Settings.IsSendMessage)
{
sendEmailAction = () =>
{
ConcreteTemplateNodeDefinition definition = new ConcreteTemplateNodeDefinition(
node,
localConnection.ConnectionGroup
);
AddEmailTask(definition, job);
};
}
TaskManager.BeginRefreshTask(
uiTreeNode,
true,
NodeUpdatingSource.ForcedFromServer,
sendEmailAction
);
};
this._jobProcessor.RunIfTime(
job,
action,
connection.CreationDateTime
);
}
}
}
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 void ParseNode(TemplateNodeInfo node)
{
foreach (var queryInfo in node.Queries.Where(info => info.ParameterValues.Any()))
{
this._dicParameters.Add(ParseQuery(queryInfo));
}
foreach (var queryInfo in node.GroupQueries.Where(info => info.ParameterValues.Any()))
{
this._dicParameters.Add(ParseQuery(queryInfo));
}
foreach (var queryInfo in node.SqlCodeGuardQueries)
{
this._dicParameters.Add(ParseQuery(queryInfo));
}
}
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);
}
public void SaveChildren(TemplateNodeInfo node)
{
List <TemplateNodeInfo> children = node.Childs;
Debug.Assert(children.All(n => n.IsInstance));
Debug.Assert(children.All(n => n.Parent == node));
if (children.Count == 0)
{
return;
}
this.DisableChildren(node);
this.Save(children);
this.SetChildrenNotProcessedYet(node, false);
}
private void UpdateQueryParameters(TemplateNodeInfo templateNode)
{
IEnumerable<TemplateNodeQueryInfo> allQueries =
templateNode.Queries.Union(templateNode.GroupQueries);
var allParameters = this._dicParameters.SelectMany(el => el.Value).ToArray();
foreach (TemplateNodeQueryInfo tnQi in allQueries)
{
foreach (ParameterValue parameterValue in tnQi.ParameterValues)
{
ParameterInfo parameterInfo =
allParameters.FirstOrDefault(p => p.Parameter == parameterValue.Name);
if (parameterInfo != null)
{
parameterValue.UserValue = parameterInfo.Value;
}
}
}
}
private void ParseNode(TemplateNodeInfo node)
{
foreach (var queryInfo in node.Queries.Where(info => info.ParameterValues.Any()))
{
this._dicParameters.Add(ParseQuery(queryInfo));
}
foreach (var queryInfo in node.GroupQueries.Where(info => info.ParameterValues.Any()))
{
this._dicParameters.Add(ParseQuery(queryInfo));
}
foreach (var queryInfo in node.SqlCodeGuardQueries)
{
this._dicParameters.Add(ParseQuery(queryInfo));
}
}
private static void NormalizeTemplateNode(TemplateNodeInfo node)
{
foreach (TemplateNodeLocaleInfo locale in node.Locales)
{
locale.Text = locale.Text.RemoveWhitespaces();
}
foreach (TemplateNodeInfo subnode in node.Childs)
{
NormalizeTemplateNode(subnode);
}
}
