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;
}
public void SaveRequestedData(
TemplateNodeInfo templateNodeInfo,
MultyQueryResultInfo results
)
{
this._storageManager.SaveRequestedData(templateNodeInfo, results);
}
/// <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 TemplateNodeInfo CloneNotSavedTree(
Dictionary <TemplateNodeInfo, TemplateNodeInfo> originalsAndClones,
ConnectionData connectionData,
TemplateNodeInfo parent = null
)
{
TemplateNodeInfo clone = (TemplateNodeInfo)MemberwiseClone();
clone._templateNodeId = null;
clone.Parent = parent;
clone.Connection = connectionData;
clone.Childs = new List <TemplateNodeInfo>(
Childs.Select(
ch => ch.CloneNotSavedTree(
originalsAndClones,
connectionData,
clone
)
)
);
originalsAndClones.Add(this, clone);
return(clone);
}
public abstract long? GetQueryId( TemplateNodeInfo node, TemplateNodeQueryInfo templateNodeQuery, InstanceInfo instance, DateTime dateCreated, bool onlyFind );
/// <summary>
/// Constructor (without database).
/// </summary>
/// <param name="templateNode">Template node.</param>
/// <param name="connection">Information group on connection.</param>
public ConcreteTemplateNodeDefinition(TemplateNodeInfo templateNode, ConnectionGroupInfo connection)
{
this._templateNode = templateNode;
this._group = GroupDefinition.NullGroup;
this.Connection = connection;
this.NodeActivated = true;
this.NodeAvailable = true;
}
/// <summary>
/// Constructor (with database).
/// </summary>
/// <param name="templateNode">Template node.</param>
/// <param name="group">Database.</param>
/// ///
/// <param name="connection">Connection group information.</param>
public ConcreteTemplateNodeDefinition(TemplateNodeInfo templateNode, GroupDefinition @group, ConnectionGroupInfo connection)
{
Debug.Assert(templateNode.IsInstance);
this._templateNode = templateNode;
this._group = @group;
this.Connection = connection;
this.NodeActivated = true;
this.NodeAvailable = true;
}
public TemplateNodeInfo GetRootPatent()
{
TemplateNodeInfo result = this;
while (result.Parent != null)
{
result = result.Parent;
}
return(result);
}
public TemplateNodeQueryInfo()
{
this._queryFileName = null;
this._queryName = null;
this._resultHierarchy = null;
this._parameterValues = null;
this._id = null;
this._idsHierarchyCache = null;
this.TemplateNode = null;
this._locales = null;
}
public TemplateNodeQueryInfo()
{
this._queryFileName = null;
this._queryName = null;
this._resultHierarchy = null;
this._parameterValues = null;
this._id = null;
this._idsHierarchyCache = null;
this.TemplateNode = null;
this._locales = null;
}
private static IEnumerable <TemplateNodeInfo> InstantiateStaticNodes(
IEnumerable <TemplateNodeInfo> templateNodes,
ConnectionData connection,
TemplateNodeInfo parent
)
{
Debug.Assert(templateNodes.All(t => !t.IsInstance));
Debug.Assert(parent.IsInstance);
foreach (TemplateNodeInfo templateNode in templateNodes.Where(n => !n.NeedDataRowToBeInstantiated))
{
yield return(templateNode.Instantiate(connection, null, parent));
}
}
public NodeAttirbutes(TemplateNodeInfo nodeInstance, DataRow dataRow = null) : this()
{
this._NodeInstance = nodeInstance;
if (dataRow != null)
{
for (var i = 0; i < dataRow.Table.Columns.Count; i++)
{
var name = dataRow.Table.Columns[i].ColumnName;
var value = dataRow[i].ToString();
Values.Add(name, value);
}
this._Initialized = true;
}
}
public NodeAttirbutes(TemplateNodeInfo nodeInstance, DataRow dataRow = null) : this()
{
this._NodeInstance = nodeInstance;
if (dataRow != null)
{
for (var i = 0; i < dataRow.Table.Columns.Count; i++)
{
var name = dataRow.Table.Columns[i].ColumnName;
var value = dataRow[i].ToString();
Values.Add(name, value);
}
this._Initialized = true;
}
}
public List<TemplateNodeUpdateJob> LoadScheduleSettings(TemplateNodeInfo node, bool fromCache)
{
long templateNodeId = node.TemplateNodeId.GetValueOrDefault();
List<TemplateNodeUpdateJob> result;
if (fromCache)
{
result = Cache.GetOrAdd(
GetCacheKey(templateNodeId),
() => GetJobs(node)
);
}
else
{
result = GetJobs(node);
}
return result;
}
/// <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)
);
}
/// <summary>
/// Reload template.
/// </summary>
public void ReloadTemplate()
{
if (ConnectionGroup == null)
{
throw new InvalidOperationException();
}
var fileName = this._model.FilesProvider.GetTreeTemplateFileName(ConnectionGroup.TemplateFileName, ConnectionGroup.TemplateDir);
string startupTemplateId = null;
Stack<string> startupTemplateInfoIdStack = null;
this.RootOfTemplate = this._model.LoadTemplateNodes(fileName, ConnectionGroup.IsExternal, out startupTemplateId, out startupTemplateInfoIdStack);
this.StartupTemplateId = startupTemplateId;
this.StartupTemplateInfoIdStack = startupTemplateInfoIdStack;
if (RootOfTemplate.Childs.Count > 0)
{
ConnectionGroup.TemplateId = RootOfTemplate.Childs.First().TemplateId;
}
}
public List<TemplateNodeUpdateJob> GetJobs(List<ScheduleSettingsRow> rows, TemplateNodeInfo node)
{
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;
}
public TemplateNodeInfo InstatiateStaticTree(ConnectionData connection, TemplateNodeInfo parent, Int64?id)
{
//Debug.Assert(parent == null || parent.IsInstance);
//Debug.Assert(!this.IsInstance);
var nodeInstance = this.IsInstance ? this : this.Instantiate(connection, null, parent);
if (id != null)
{
nodeInstance.AssignTemplateId(id.Value);
}
nodeInstance.UpdateChildren(NodeUpdatingSource.LocallyOnly, null);
foreach (var child in nodeInstance.Childs)
{
child.InstatiateStaticTree(connection, nodeInstance, null);
}
return(nodeInstance);
}
public TemplateNodeInfo Instantiate(ConnectionData connection, string defaultDatabaseAttribute, TemplateNodeInfo parent)
{
Debug.Assert(!IsInstance);
TemplateNodeInfo result = (TemplateNodeInfo)MemberwiseClone();
result.Template = this;
result.Attributes = new NodeAttirbutes(result);
result.Childs = new List <TemplateNodeInfo>();
result.Connection = connection;
result.ReplicationSourceQuery = null;
result._defaultDatabaseAttributeName = defaultDatabaseAttribute;
result.Queries = Queries.Select(q => q.Clone()).ToList();
result.ConnectionQueries = ConnectionQueries.Select(q => q.Clone()).ToList();
result.GroupQueries = GroupQueries.Select(q => q.Clone()).ToList();
result.Parent = parent;
return(result);
}
public void ReadTo(long nodeInstanceAttrId, TemplateNodeInfo.NodeAttirbutes attributes, SQLiteConnection cnn)
{
string sql = string.Format(
"SELECT * FROM {0} WHERE {1} = {2}",
TableName,
NodeInstaceIdFn,
nodeInstanceAttrId
);
using (SQLiteCommand cmd = new SQLiteCommand(sql, cnn))
{
using (SQLiteDataReader reader = cmd.ExecuteReader())
{
while (reader.Read())
{
attributes.Values[(string)reader[NameFn]] = (string)reader[ValueFn];
//attributes.Initialized = true;
//TODO KupVadim [20.12.2014 23:27]: This flag broken getter for UIid, NodeAttribute.GetUid()
}
}
}
}
private TemplateNodeInfo Search(TemplateNodeInfo searchable)
{
if (this.TemplateNodeId == searchable.TemplateNodeId)
{
return(this);
}
foreach (var templateNodeInfo in this.Childs)
{
if (templateNodeInfo.TemplateNodeId == searchable.TemplateNodeId)
{
return(templateNodeInfo);
}
var founded = templateNodeInfo.Search(searchable);
if (founded != null)
{
return(founded);
}
}
return(null);
}
private Color GetColor(TemplateNodeInfo templateInfo)
{
return string.IsNullOrEmpty(templateInfo.FontColor)
? Color.Black
: Colors.FromString(templateInfo.FontColor);
}
public override long? GetQueryId(
TemplateNodeInfo node,
TemplateNodeQueryInfo templateNodeQuery,
InstanceInfo instance,
DateTime dateCreated,
bool onlyFind
)
{
Int64? queryId = 0L;
Debug.Assert(node.IsInstance);
if (node.TemplateNodeId == null)
{
throw new InvalidOperationException();
}
Int64? templateNodeQueryId = Storage.TemplateNodeQueryDirectory
.GetId(node.ConnectionGroup, node.Template, templateNodeQuery);
Int64? serverId = Storage.ServerInstanceDirectory
.GetId(node.ConnectionGroup, instance);
if (onlyFind)
{
Tuple<long, long, long> key = new Tuple<Int64, Int64, Int64>(
(long) node.TemplateNodeId.Value,
(long) templateNodeQueryId,
(long) serverId
);
return this.Cache.GetOrAdd(
key, () =>
{
ITableRow row = this.NewRow();
row.Values.Add(NodeInstanceIdFn, node.TemplateNodeId.Value);
row.Values.Add(TemplateNodeQueryIdFn, templateNodeQueryId);
row.Values.Add(ServerInstanceIdFn, serverId);
queryId = this.GetRow(row);
Log.InfoFormat("ServerId:'{0}';NodeInstanceId:'{1}';TemplateNodeQueryId:'{2}';PrimaryKey:'{3}'",
serverId,
node.TemplateNodeId.Value,
templateNodeQueryId,
queryId
);
return queryId;
}
);
}
List<Field> customFields = new List<Field>
{
this.CreateField(DefaultDatabaseNameFn, node.GetDefaultDatabase()),
this.CreateField(TableDefinition.DateCreated, dateCreated),
this.CreateField(NodeInstanceIdFn, node.TemplateNodeId.GetValueOrDefault()),
this.CreateField(TemplateNodeQueryIdFn, templateNodeQueryId),
this.CreateField(ServerInstanceIdFn, serverId)
};
queryId = this.GetRecordIdByFields(customFields.ToArray());
Log.InfoFormat("ServerId:'{0}';NodeInstanceId:'{1}';TemplateNodeQueryId:'{2}';id:'{3}'",
serverId,
node.TemplateNodeId.GetValueOrDefault(),
templateNodeQueryId,
queryId
);
return queryId;
}
public void UpdateTreeNodeCounterValue(
TemplateNodeInfo node,
int? counterValue
)
{
int? currentValue = GetTreeNodeCounterValue(node);
if (!Nullable.Equals(counterValue, currentValue))
{
NodeInstances.UpdateTreeNodeCounterValue(node, counterValue);
}
}
public void UpdateTreeNodeTimings(
TemplateNodeInfo node,
MultyQueryResultInfo results
)
{
UpdateTreeNodeTimings(
node,
results.NodeLastUpdated,
results.NodeLastUpdateDuration
);
}
public ITableRow ReadLastMeta(
TemplateNodeInfo node,
InstanceInfo instance,
TemplateNodeQueryInfo templateNodeQuery
)
{
Int64? queryId = this.QueryDirectory.GetQueryId(
node,
templateNodeQuery,
instance,
new DateTime(),
true
);
return queryId != null
? this.ReadLastMeta(queryId.Value)
: null;
}
private void FillTreeNodes(
TemplateNodeInfo parent,
TreeNodeCollection treeNodes
)
{
List<Tuple<TreeNode, ConcreteTemplateNodeDefinition>> pendingUpdateNodes =
new List<Tuple<TreeNode, ConcreteTemplateNodeDefinition>>();
Action action = () =>
{
treeNodes.Clear();
treeNodes.AddRange(parent.Childs.Select(n =>
{
ConcreteTemplateNodeDefinition nodedef;
TreeNode node = this._treeControl.CreateTreeViewNode(n, out nodedef);
pendingUpdateNodes.Add(new Tuple<TreeNode, ConcreteTemplateNodeDefinition>(node, nodedef));
return node;
}).ToArray());
if (parent.ChildrenAreLoadingNow)
{
treeNodes.Add(new TreeNode(this._treeControl._model.LocaleManager.GetLocalizedText(
"common", "NodesQueryingTreeNodeText")
)
{
ImageKey = "NodesQuerying",
SelectedImageKey = "NodesQuerying"
});
}
};
this._treeControl.SafeInvoke(action);
foreach (Tuple<TreeNode, ConcreteTemplateNodeDefinition> pendingNode in pendingUpdateNodes)
{
TreeNode node = pendingNode.Item1;
ConcreteTemplateNodeDefinition nodeDef = pendingNode.Item2;
if (parent.IsDisabled)
{
nodeDef.TemplateNode.IsDisabled = true;
nodeDef.NodeActivated = false;
}
nodeDef.NodeAvailable = nodeDef.IsAvailableForDatabase(Program.Model) ?? true;
if (!nodeDef.NodeAvailable)
{
this._treeControl.SetNotAvailableNode(node);
}
else
{
this._treeControl.SetNodeLoaded(node);
List<TemplateNodeUpdateJob> refreshJobs = nodeDef.TemplateNode.GetRefreshJob(true);
nodeDef.TemplateNode.HasActiveJobs = refreshJobs.Any(
job =>
job != null
&& !job.IsEmpty()
&& job.Enabled
);
UpdateTreeCounts(node, NodeUpdatingSource.LocallyOnly);
}
}
}
public TemplateNodeInfo Instantiate(ConnectionData connection, DataRow row, TemplateNodeQueryInfo replicationSourceQuery, TemplateNodeInfo parent)
{
Debug.Assert(!IsInstance);
Debug.Assert(NeedDataRowToBeInstantiated);
var result = (TemplateNodeInfo)MemberwiseClone();
result.Childs = new List <TemplateNodeInfo>();
result.Template = this;
result.Attributes = new NodeAttirbutes(result, row);
result.Connection = connection;
result.ReplicationSourceQuery = replicationSourceQuery;
result.Queries = Queries.Select(q => q.Clone()).ToList();
result.ConnectionQueries = ConnectionQueries.Select(q => q.Clone()).ToList();
result.GroupQueries = GroupQueries.Select(q => q.Clone()).ToList();
result.Parent = parent;
result.Id = null;
result.Name = Name + result.Id;
result.OnAttributesChanged();
return(result);
}
public NodeAttirbutes()
{
this.Values = new Dictionary <string, string>();
this._NodeInstance = null;
this._Initialized = false;
}
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 void SaveTree(TemplateNodeInfo node)
{
this.Save(node);
foreach (TemplateNodeInfo ch in node.Childs)
{
this.SaveTree(ch);
}
this.SetChildrenNotProcessedYet(node, false);
}
internal void ResetRowCountCache(TemplateNodeInfo node)
{
int oldValue = 0;
if (node != null)
{
if (node.TemplateNodeId != null)
{
this._nodesRowCountCache.TryRemove(
node.TemplateNodeId.Value,
out oldValue
);
}
}
}
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 bool TryLoadChildren(TemplateNodeInfo node)
{
if (node.TemplateNodeId == null)
{
return false;
}
bool? notProcessedYet = this.GetChildrenNotYetProcessed(node.TemplateNodeId.Value);
if (notProcessedYet ?? true)
{
return false;
}
String sql = string.Format(
"SELECT I.{0}, I.*, PQ.{1}, T.{9} AS [TemplateUserId] " +
"FROM {2} AS I " +
"LEFT JOIN {3} AS T ON I.{7} = T.{13} " +
"LEFT JOIN {4} AS PQ ON T.{8} = PQ.{14} " +
"WHERE I.{5} = {6} AND I.{10} = {11} " +
"ORDER BY I.{12}",
IdentityField,
TemplateNodeQueryGroupDirectory.DefaultDatabaseFieldFn,
TableName,
TemplateNodeDirectory.TableName,
TemplateNodeQueryGroupDirectory.TableName,
ParentIdFn,
node.TemplateNodeId,
TemplateNodeIdFn,
TemplateNodeDirectory.ParentQueryGroupIdFn,
TemplateNodeDirectory.UserIdFieldName,
NodeEnabledFn,
SqLiteBool.ToBit(true),
NodeSequenceNumberFn,
TemplateNodeDirectory.TableIdentityField,
TemplateNodeQueryGroupDirectory.TableIdentityField
);
node.Childs.Clear();
using (this.Connection.OpenWrapper())
{
new SqlSelectCommand(
this.Connection,
sql,
reader =>
{
string templateUserId = reader["TemplateUserId"].ToString();
TemplateNodeInfo template = node.Template.Childs.FirstOrDefault(
n => n.Id == templateUserId.ToString()
);
if (template == null)
{
this.DisableNode((Int64)reader[IdentityField]);
return;
}
string defaultDbFieldnName =
reader[TemplateNodeQueryGroupDirectory.DefaultDatabaseFieldFn].ToString();
TemplateNodeInfo newNode = template.Instantiate(node.Connection, defaultDbFieldnName, node);
long newNodeId = (Int64)reader[IdentityField];
newNode.AssignTemplateId(newNodeId);
List<TemplateNodeUpdateJob> refreshJobs = newNode.GetRefreshJob(true);
foreach (TemplateNodeUpdateJob refreshJob in refreshJobs)
{
if (refreshJob != null && !refreshJob.IsEmpty())
{
if (!(reader[NodeScheduledUpdateFn] is DBNull))
{
refreshJob.LastRan = (DateTime)reader[NodeScheduledUpdateFn];
}
}
}
this._storage.NodeInstanceAttributes.ReadTo(
newNodeId,
newNode.Attributes,
this.Connection
);
newNode.OnAttributesChanged();
node.Childs.Add(newNode);
})
.Execute(100);
}
Dictionary<string, TemplateNodeInfo> absent = new Dictionary<string, TemplateNodeInfo>();
foreach (TemplateNodeInfo nodeTemplate in node.Template.Childs.Where(n => !n.NeedDataRowToBeInstantiated))
{
absent[nodeTemplate.Id] = nodeTemplate;
}
foreach (TemplateNodeInfo loaded in node.Childs)
{
absent.Remove(loaded.Template.Id);
}
if (absent.Any())
{
Dictionary<TemplateNodeInfo, int> templateIndexes = new Dictionary<TemplateNodeInfo, int>();
for (int i = 0; i < node.Template.Childs.Count; i++)
{
templateIndexes[node.Template.Childs[i]] = i;
}
List<TemplateNodeInfo> newStatics = absent.Values.Select(t => t.Instantiate(node.Connection, null, node)).ToList();
IOrderedEnumerable<TemplateNodeInfo> newList =
new List<TemplateNodeInfo>(node.Childs).Union(newStatics).OrderBy(n => templateIndexes[n.Template]);
node.Childs.Clear();
node.Childs.AddRange(newList);
this.SaveChildren(node);
}
return true;
}
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;
}
public bool TryLoadRoodId(TemplateNodeInfo node, Int64? connectionGroupId, Int64? templatedId)
{
String sql = string.Format(
"SELECT ni.[{8}] FROM [{0}] ni " +
"JOIN [{4}] tn ON ni.[{5}] = tn.[{8}] " +
"WHERE ni.[{1}] IS NULL AND ni.[{2}] = {3} " +
"AND tn.[{6}] = {7}",
TableName,
ParentIdFn,
ConnectionIdFn,
connectionGroupId,
TemplateNodeDirectory.TableName,
TemplateNodeIdFn,
TemplateNodeDirectory.TemplateIdFn,
templatedId,
TemplateNodeDirectory.TableIdentityField
);
using (this.Connection.OpenWrapper())
{
bool result = false;
new SqlSelectCommand(
this.Connection,
sql,
reader =>
{
node.AssignTemplateId((Int64)reader[IdentityField]);
result = true;
})
.Execute(100);
if (result)
{
return true;
}
}
return false;
}
public void Save(TemplateNodeInfo templateNodeInfo)
{
NodeInstances.Save(templateNodeInfo);
templateNodeInfo.SaveUserParameters(this);
}
public void UpdateTreeNodeCounterValue(TemplateNodeInfo node, int? counterValue)
{
Debug.Assert(node.IsInstance);
if (node.TemplateNodeId == null)
{
this.Save(node);
}
if (node.TemplateNodeId == null)
{
return;
}
using (this.Connection.OpenWrapper())
{
const string paramName = "@intCounterValue";
string update = string.Format("UPDATE [{0}] SET [{1}] = {2}", TableName, NodeCounterValue, paramName);
string whereClause = string.Format("[{0}] = {1}", IdentityField, node.TemplateNodeId.Value);
SQLiteParameter parameter;
if (counterValue != null)
{
whereClause += string.Format(" AND ([{0}] IS NULL OR [{0}] != {1})", NodeCounterValue, paramName);
parameter = new SQLiteParameter(paramName, counterValue.Value);
}
else
{
whereClause += string.Format(" AND [{0}] IS NOT NULL", NodeCounterValue);
parameter = new SQLiteParameter(paramName, DBNull.Value);
}
string query = string.Format(
"{0} WHERE {1};",
update,
whereClause
);
new SqlCustomCommand(this.Connection, query, parameter)
.Execute(100);
}
}
public void UpdateTreeNodeTimings(
TemplateNodeInfo node,
DateTime? lastUpdateDateTime,
DateTime? lastUpdateDuration
)
{
NodeInstances.UpdateTreeNodeLastUpdateAndDuration(
node,
lastUpdateDateTime,
lastUpdateDuration
);
}
public void UpdateTreeNodeLastUpdateAndDuration(
TemplateNodeInfo node,
DateTime? lastUpdateDateTime,
DateTime? lastUpdateDuration
)
{
Debug.Assert(node.IsInstance);
if (node.TemplateNodeId != null)
{
using (this.Connection.OpenWrapper())
{
String query = string.Format(
"UPDATE [{0}] SET"
+ " [{1}] = @NodeLastUpdated"
+ " ,[{2}] = @NodeLastUpdateDuration"
+ " WHERE"
+ " [{3}] = @{3}"
+ " AND ("
+ " ([{1}] IS NULL OR [{1}] != @NodeLastUpdated)"
+ " OR"
+ " ([{2}] IS NULL OR [{2}] != @NodeLastUpdateDuration)"
+ " );",
TableName,
NodeLastUpdated,
NodeLastUpdateDuration,
IdentityField
);
SQLiteParameter[] sqliteParameters = {
new SQLiteParameter("@NodeLastUpdated", lastUpdateDateTime),
new SQLiteParameter("@NodeLastUpdateDuration", lastUpdateDuration),
new SQLiteParameter("@" + IdentityField, node.TemplateNodeId.Value)
};
new SqlCustomCommand(this.Connection, query, sqliteParameters)
.Execute(0);
}
}
}
public int? GetTreeNodeCounterValue(TemplateNodeInfo node)
{
return NodeInstances.GetTreeNodeCounterValue(node);
}
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);
}
}
