public JsonResult deleteJet(DataLibrary.Models.Jet jet)
{
SqlProcessor.deleteJet(jet);
return(Json(jet, JsonRequestBehavior.AllowGet));
}
public JsonResult JetList()
{
var result = SqlProcessor.JetList();
return(Json(result, JsonRequestBehavior.AllowGet));
}
public JsonResult UpdateJet(DataLibrary.Models.Jet jet)
{
var result = SqlProcessor.updateJet(jet);
return(Json(result, JsonRequestBehavior.AllowGet));
}
public JsonResult submitJet(DataLibrary.Models.Jet jet)
{
var newJet = SqlProcessor.CreateJet(jet.modelName, jet.serialNumber);
return(Json(newJet, JsonRequestBehavior.AllowGet));
}
///-------------------------------------------------------------------------------------------------
/// <summary> Emits the given fragment to a function to handle it. </summary>
///
/// <param name="processor"> Function to handle the SQL. </param>
public virtual void Emit(SqlProcessor processor)
{
processor(Escape(Value));
}
private void UpdateDynamicChildren(CancellationToken cancellationToken)
{
ChildrenAreLoadingNow = true;
try
{
List <TemplateNodeInfo> newNodes = new List <TemplateNodeInfo>();
using (SqlProcessor sqlProcessor = this._model.GetNewSqlProcessor(cancellationToken))
{
foreach (TemplateNodeQueryInfo query in GroupQueries)
{
List <TemplateNodeInfo> templateNodesToBeReplicated = GetSubnodesFor(query).ToList();
List <QueryInfo> queryInfos = this._model.GetQueryByTemplateNodeQueryInfo(query);
foreach (InstanceInfo serverInstance in Connection.ConnectionGroup.Connections.Where(c => c.IsEnabled))
{
cancellationToken.ThrowIfCancellationRequested();
QueryInfo queryInfo = queryInfos.FirstOrDefault(x =>
x.Source == serverInstance.Type || x.Source == QuerySource.SQLite
);
DataTable[] tables = GetGroupSelectResultsFromServer(sqlProcessor, serverInstance, queryInfo, query);
cancellationToken.ThrowIfCancellationRequested();
foreach (DataTable t in tables)
{
for (int rowIndex = 0; rowIndex < t.Rows.Count; rowIndex++)
{
List <TemplateNodeInfo> replicants =
templateNodesToBeReplicated.Select(
tn => tn.Instantiate(
Connection,
t.Rows[rowIndex],
query,
this
)
).ToList();
newNodes.AddRange(replicants);
}
}
}
}
}
cancellationToken.ThrowIfCancellationRequested();
if (newNodes.Count == 0)
{
return;
}
lock (Childs)
{
Childs.AddRange(newNodes);
this._model.GetVaultProcessor(Connection.ConnectionGroup).CurrentStorage.NodeInstances.SaveChildren(this);
}
}
catch (Exception ex)
{
log.Error("private Task CreateAddDynamicChildrenTask(Action done)", ex);
}
finally
{
ChildrenAreLoadingNow = false;
}
}
/// <summary>
/// Run queries for the node
/// </summary>
/// <param name="nodeInfo">TemplateNodeInfo</param>
/// <param name="connData">Connection data</param>
/// <param name="templateRowId">Template Id</param>
private void RunQueries(TemplateNodeInfo nodeInfo, ConnectionData connData, long templateRowId, long scheduleId, string runningKey)
{
MultyQueryResultInfo result;
ProgressItem item = new ProgressItem();
CancellationToken token = new CancellationToken();
log.DebugFormat(
@"Started: Connection:'{0}';templateRowId:'{1}';Query:'{2}'",
connData.Title,
templateRowId,
nodeInfo.Name
);
lock (_runningTasksLock)
{
_runningTasks.TryAdd(runningKey, nodeInfo.Name);
}
using (SqlProcessor sqlProcessor = _model.GetNewSqlProcessor(token))
{
nodeInfo.SetConnectionData(null);
TemplateNodeInfo node = nodeInfo.Instantiate(connData, null, null);
node.AssignTemplateId(templateRowId);
node.LoadUserParameters(_storage);
Stopwatch durationWatch = new Stopwatch();
DateTime startTime = DateTime.Now;
durationWatch.Start();
result = sqlProcessor.ExecuteMultyQuery(
connData.ConnectionGroup,
node.Queries,
item,
_model.Settings.SystemSettings.MaximumDBRequestsThreadCount
);
IStorageManager istorage = _model.GetVaultProcessor(connData.ConnectionGroup);
istorage.SaveRequestedData(node, result);
durationWatch.Stop();
DateTime duration = new DateTime(durationWatch.Elapsed.Ticks);
istorage.CurrentStorage.UpdateTreeNodeTimings(
node,
startTime,
duration
);
//_serviceSchedules.FirstOrDefault(sch => sch.TemplateNodeId == nodeInstanceRowId).LastRan = startTime;
_serviceSchedules[scheduleId].LastRan = startTime;
}
nodeInfo.SetConnectionData(connData);
lock (_runningTasksLock)
{
string outTask;
_runningTasks.TryRemove(runningKey, out outTask);
}
}
public DataTableForm(SqlProcessor sqlProcessor) : this()
{
this.sqlProcessor = sqlProcessor;
}
