public Task <object> Execute(ExecuteArgs arg)
{
var darg = (DocumentExecuteArgs)arg;
var smtpServer = Book.DBTable.LoadByCode("smtpserver");
if (smtpServer == null)
{
throw new NullReferenceException("smtpserver book parameter not found!");
}
using (var client = new SmtpClient(smtpServer.Value))
{
client.UseDefaultCredentials = true;
//client.Credentials = new NetworkCredential("username", "password");
using (var message = new MailMessage())
{
message.From = new MailAddress(arg.Transaction.Caller.Name);
FillTo(message, darg);
message.Body = GetBody(darg);
message.Subject = "Documents Notify";
client.Send(message);
}
}
return(null);
}
static Process NewProcess(ExecuteArgs executeArgs)
{
var p = new Process
{
StartInfo =
{
Arguments = executeArgs.Arguments,
CreateNoWindow = true,
UseShellExecute = false,
RedirectStandardOutput = true,
RedirectStandardInput = true,
RedirectStandardError = true,
FileName = executeArgs.Executable,
StandardOutputEncoding = Encoding.UTF8,
StandardErrorEncoding = Encoding.UTF8,
WorkingDirectory = executeArgs.WorkingDirectory,
}
};
if (executeArgs.EnvVars != null)
{
foreach (var envVar in executeArgs.EnvVars)
{
p.StartInfo.EnvironmentVariables.Add(envVar.Key, envVar.Value);
}
}
return(p);
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnRead_Click(object sender, EventArgs e)
{
if (!IsReady())
{
return;
}
if (!IsExecuting())
{
ExecuteArgs args = new ExecuteArgs();
args.DeviceID = this.DeviceID;
args.ExecuteName = XD1100OperaNames.OPERA_READ;
ExecuteResult r = this._controller.Doit(args);
if (r.IsSuccess)
{
this._isExecuting = true;
this._lastExecuteDateTime = DateTime.Now;
this.SetStatusText(string.Format(XD100Strings.ExecutingOpera, args.ExecuteName));
}
else
{
NUnit.UiKit.UserMessage.DisplayFailure(r.FailMessage);
}
}
else
{
NUnit.UiKit.UserMessage.DisplayFailure(XD100Strings.Executing);
}
}
/// <summary>
///
/// </summary>
public ExecuteResult Doit(ExecuteArgs args)
{
RemoteObject obj = this.GetRemoteObject();
CallbackWrapper w = new CallbackWrapper(new ResultDelegate(Target));
return(obj.Execute(args, w));
}
void MnuExecuteClick(object sender, EventArgs e)
{
if (mnuExecute.Text == "Execute")
{
if (currentDSN == null)
{
MessageBox.Show("Select a data source", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
lblCurrentStatus.Text = "Running query...";
this.Cursor = Cursors.WaitCursor;
textEditorControl1.Cursor = Cursors.WaitCursor;
start = DateTime.Now;
mnuExecute.Text = "CANCEL";
mnuExecute.ForeColor = Color.Red;
mnuRun.Enabled = false;
mnuSchema.Enabled = false;
Application.DoEvents();
ExecuteArgs args = new ExecuteArgs();
args.ConString = string.Format("DSN={0};Uid={1};Pwd={2};", currentDSN.GetDSNName(), txtUserName.Text, txtPassword.Text);
// If there is selected text use that as the sql source or use all of the text
if (textEditorControl1.ActiveTextAreaControl.SelectionManager.HasSomethingSelected)
{
args.SQL = textEditorControl1.ActiveTextAreaControl.SelectionManager.SelectedText;
}
else
{
args.SQL = textEditorControl1.Text;
}
timer = new Timer();
timer.Interval = 1000;
timer.Tick += delegate(object sender1, EventArgs e1)
{
lblCurrentStatus.Text = "Running query - Elapsed time " + DateTime.Now.Subtract(start).TotalSeconds.ToString("N0") + "s";
};
workerExecute = new BackgroundWorker();
workerExecute.WorkerReportsProgress = true;
workerExecute.WorkerSupportsCancellation = true;
workerExecute.DoWork += new DoWorkEventHandler(ExecuteWorker_DoWork);
workerExecute.RunWorkerCompleted += new RunWorkerCompletedEventHandler(ExecuteWorker_RunWorkerCompleted);
workerExecute.RunWorkerAsync(args);
timer.Start();
}
else
{
com.Cancel();
workerExecute.CancelAsync();
}
}
private void ToolRunClick(object sender, EventArgs e)
{
procedure.Save();
if (procedure.ProcedureType == ProcedureTypes.Source || procedure.ProcedureType == ProcedureTypes.Assembly)
{
var args = new ExecuteArgs();
var obj = procedure.CreateObject(args);
if (obj is Window)
{
((Window)obj).TransientFor = ParentWindow;
((Window)obj).Show();
}
else if (obj is Widget)
{
var window = new ToolWindow
{
Mode = ToolShowMode.Dialog,
Target = (Widget)obj,
Title = procedure.Name
};
window.Show(this, Point.Zero);
}
else
{
object result = procedure.ExecuteObject(obj, args);
MessageDialog.ShowMessage(ParentWindow, result == null ? "Succesfull!" : result.ToString(), "Execute complete!");
}
}
else if (procedure.ProcedureType == ProcedureTypes.Query)
{
var form = new PQueryView {
Procedure = procedure
};
var window = new ToolWindow
{
Mode = ToolShowMode.Dialog,
Target = form,
Title = procedure.Name
};
window.Show(this, Point.Zero);
//window.Dispose();
}
else
{
var args = new ExecuteArgs {
Parameters = ProcedureProgress.CreateParam(procedure)
};
var obj = procedure.CreateObject(args);
object result = procedure.ExecuteObject(obj, args);
MessageDialog.ShowMessage(ParentWindow, result == null ? "Succesfull!" : result.ToString(), "Execute complete!");
}
}
public Task <object> Execute(ExecuteArgs arg)
{
var darg = (DocumentExecuteArgs)arg;
var document = (Document)arg.Document;
if (string.IsNullOrEmpty(document.Number))
{
document.Number = Generate(document, arg.Transaction);
}
return(null);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
private bool IsReady()
{
ExecuteArgs args = new ExecuteArgs();
args.DeviceID = this.DeviceID;
args.ExecuteName = DefineExecuteNames.IsReady;
ExecuteResult r = this._controller.Doit(args);
if (!r.IsSuccess)
{
NUnit.UiKit.UserMessage.DisplayFailure(r.FailMessage);
}
return(r.IsSuccess);
}
private void ExecuteWorker(ExecuteArgs args)
{
try
{
Dictionary<string, string> streamProperties = args.IActionData3.Properties;
IActionProperty fileType = args.ActionPropertySet.SystemProperties["FileType"];
m_file = args.IActionData3.FileName;
AddTrackingInfo(m_file);
}
catch (System.Exception ex)
{
args.Exception = ex;
Logger.LogError(ex);
}
}
public async Task <object> Execute(ExecuteArgs parameters)
{
var filter = new QQuery(string.Empty, DocumentWork.DBTable);
filter.BuildPropertyParam(nameof(DocumentWork.IsComplete), CompareType.Equal, false);
filter.BuildPropertyParam(nameof(DocumentWork.IsSystem), CompareType.Equal, true);
//string filter = string.Format("{0}!='{1}' and {2} in (select {3} from {4} where {5} = '{6}')",
foreach (DocumentWork work in DocumentWork.DBTable.Load(filter, DBLoadParam.Load | DBLoadParam.Synchronize, parameters.Transaction))
{
if (work.Stage == null || work.Document == null)
{
continue;
}
work.Document.ExecuteProceduresByWork(work, StageParamProcudureType.Manual, parameters.Transaction);
await work.Document.Save(parameters.Transaction);
}
return(null);
}
public ExecuteResult Doit(ExecuteArgs args)
{
if (args == null)
{
throw new ArgumentNullException("args");
}
this._executeArgs = args;
int deviceID = args.DeviceID;
IDevice device = SoftManager.GetSoft().Hardware.FindDevice(deviceID);
ExecuteResult r = null;
if (StringHelper.Equal(args.ExecuteName, DefineExecuteNames.IsReady))
{
if (device == null)
{
string s = string.Format(RemoteStrings.NotFindDeviceByID, deviceID);
r = ExecuteResult.CreateFailExecuteResult(s);
}
else
{
if (device.Station.CommuniPort != null &&
device.Station.CommuniPort.IsOpened)
{
r = ExecuteResult.CreateSuccessExecuteResult();
}
else
{
r = ExecuteResult.CreateFailExecuteResult(RemoteStrings.NotConnection);
}
}
}
else
{
Debug.Assert(device != null);
TaskExecutor te = new TaskExecutor();
te.Ended += new EventHandler(te_Ended);
r = te.Execute(device, args.ExecuteName, args.KeyValues);
}
return(r);
}
///// <summary>
/////
///// </summary>
///// <param name="e"></param>
//private void ProcessWriteMode(TaskExecutedEventArgs e)
//{
// if (e.ParseResult.Success)
// {
// // tt
// //KeyValuePair<int, int>[] tcLine = this.ucTimeControlLine1.TimeControlLine;
// //int[] adjustValues = CreateAdjustValuesByTimeControlLine(tcLine);
// //WriteLine(adjustValues);
// //this.SetState(State.WriteLine);
// //KeyValuePair<int, int>[] tcLine = this.TimeControlLine2.TimeControlLine;
// //int[] adjustValues = CreateAdjustValuesByTimeControlLine(tcLine);
// //WriteLine(adjustValues);
// //this.SetState(State.WriteLine);
// }
// else
// {
// ShowError();
// }
// this.SetState(State.None);
//}
#endregion //ProcessWriteMode
#region WriteLine
/// <summary>
///
/// </summary>
//private void WriteLine(KeyValuePair<int, int>[] timeControlLine)
private void WriteLine(int[] adjustValues)
{
//Opera op = CreateOpera("WriteTempControlData");
//op.SendPart["TimeControlLine"] = adjustValues;
//// TODO: 2010-08-31 ot control line
////
//op.SendPart["OTControlLine"] = this.ucotControlLine1.OTControlLine;
//_task = new Task(this.Device, op, new ImmediateStrategy());
//CZGRApp.Default.Soft.TaskManager.Tasks.AddToHead(_task);
ExecuteArgs args = new ExecuteArgs();
args.DeviceID = this.DeviceID;
args.ExecuteName = "WriteTempControlData";
args.KeyValues["TimeControlLine"] = adjustValues;
args.KeyValues["OTControlLine"] = this.ucotControlLine1.OTControlLine;
_controller.Doit(args);
}
public static string Execute(string filename, string arguments, Dictionary <string, string> envVars = null)
{
ExecuteArgs executeArgs = new ExecuteArgs {
Executable = filename, Arguments = arguments, EnvVars = envVars
};
var result = Execute(executeArgs);
var allConsoleOutput = result.StdErr.Trim() + result.StdOut.Trim();
if (0 != result.ExitCode)
{
throw new Exception(string.Format(
"Process {0} ended with exitcode {1}" + Environment.NewLine +
"{2}" + Environment.NewLine,
executeArgs.Executable,
result.ExitCode,
allConsoleOutput));
}
return(allConsoleOutput);
}
public static BackgroundWorker ExecuteAsync(DBProcedure procedure, DBItem document, Dictionary <string, object> parameters)
{
BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += (sender, e) =>
{
using (var transaction = new DBTransaction(procedure.Schema.Connection, GuiEnvironment.User))
try
{
var args = new ExecuteArgs(document);
e.Result = Execute(procedure, args);
transaction.Commit();
}
catch (Exception ex)
{
e.Result = ex;
}
};
worker.RunWorkerAsync(parameters);
return(worker);
}
public object ExecuteDocumentProcedure(DBProcedure proc, Document document, bool callback)
{
document.Save();
var args = new ExecuteArgs(document);
object result = null;
try
{
result = proc.CreateObject(args);
if (TypeHelper.IsBaseType(result.GetType(), typeof(Widget)))
{
result = proc.ExecuteObject(result, args);
}
else
{
var task = proc.GetExecutor(result, args);
if (GuiService.Main != null)
{
if (callback)
{
task.Callback += TaskCallback;
}
GuiService.Main.AddTask(this, task);
result = null;
}
else
{
result = task.Execute();
}
}
}
catch (Exception ex)
{
result = ex;
}
return(result);
}
public Task <object> Execute(ExecuteArgs arg)
{
var darg = (DocumentExecuteArgs)arg;
var document = (Document)arg.Document;
var builder = new StringBuilder();
foreach (var work in document.Works)
{
if (work == darg.Work)
{
continue;
}
if (!work.Completed && work.Stage == darg.Stage)
{
if (builder.Length == 0)
{
builder.AppendLine($"Stage {darg.Stage} is uncompleate! Current holders: ");
}
builder.AppendLine($" {work.Department} - {work.Position} {work.User};");
}
}
return(Task.FromResult <object>(builder.Length == 0 ? null : builder.ToString()));
}
public static object Execute(DBProcedure procedure, ExecuteArgs args)
{
CheckParam(procedure, args.Parameters);
return(procedure.Execute(args));
}
public static object Execute(DBProcedure procedure, ExecuteArgs param)
{
CheckParam(procedure, param.Parameters);
return(procedure.Execute(param));
}
//#region ProcessWriteLine
///// <summary>
/////
///// </summary>
///// <param name="e"></param>
//private void ProcessWriteLine(TaskExecutedEventArgs e)
//{
// //throw new NotImplementedException();
// if (e.ParseResult.Success)
// {
// }
// else
// {
// ShowError();
// }
// SetState(State.None);
//}
//#endregion //ProcessWriteLine
#region btnWrite_Click
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnWrite_Click(object sender, EventArgs e)
{
if (!IsReady())
{
return;
}
if (!this._canWrite)
{
NUnit.UiKit.UserMessage.DisplayFailure(XD100Strings.FirstReadGRControlParams);
return;
}
if (this.IsExecuting())
{
NUnit.UiKit.UserMessage.DisplayFailure(XD100Strings.Executing);
return;
}
// enable valve open degree setting
//
//if (this.cmbControlMode.SelectedItem != null)
//{
// Xdgk.GR.Common.XD1100TemperatureControlMode mode = this.cmbControlMode.SelectedItem as Xdgk.GR.Common.XD1100TemperatureControlMode;
// if (mode != null)
// {
// if (mode.Mode == Xdgk.GR.Common.XD1100TemperatureControlModeEnum.ValveOpenDegree)
// {
// //string s = string.Format(XD100ModbusStrings.NotSupportMode, mode.Name);
// string s = string.Format(XD100Strings.NotSupportMode, mode.Name);
// NUnit.UiKit.UserMessage.DisplayFailure(s);
// return;
// }
// }
//}
ExecuteArgs args = new ExecuteArgs();
KeyValueCollection hash = args.KeyValues;
hash["ControlMode"] = (int)this.cmbControlMode.SelectedValue;
hash["ValveType"] = (int)this.cmbValveType.SelectedValue;
hash["SettingValue"] = GetSettingValue();
hash["OTControlLine"] = this.ucotControlLine1.OTControlLine;
KeyValuePair <int, int>[] tcLine = this.TimeControlLine2.TimeControlLine;
int[] adjustValues = CreateAdjustValuesByTimeControlLine(tcLine);
hash["TimeControlLine"] = adjustValues;
args.DeviceID = this.DeviceID;
args.ExecuteName = XD1100OperaNames.OPERA_WRITE;
ExecuteResult r = _controller.Doit(args);
if (r.IsSuccess)
{
this._isExecuting = true;
this._lastExecuteDateTime = DateTime.Now;
string statusText = string.Format(XD100Strings.ExecutingOpera, args.ExecuteName);
this.SetStatusText(statusText);
}
else
{
NUnit.UiKit.UserMessage.DisplayFailure(r.FailMessage);
}
}
public static ExecuteResult Execute(ExecuteArgs executeArgs, IExecuteController controller = null, NPath outputFile = null)
{
using (var p = NewProcess(executeArgs))
{
FileStream fOut, fError;
string tempOutputFile, tempErrorFile;
lock (FileLocker)
{
tempOutputFile = outputFile == null?Path.GetTempFileName() : outputFile.ToString();
tempErrorFile = Path.GetTempFileName();
fOut = File.Create(tempOutputFile);
fError = File.Create(tempErrorFile);
}
var stopWatch = new Stopwatch();
stopWatch.Start();
using (
StreamWriter outputWriter = new StreamWriter(fOut, Encoding.UTF8),
errorWriter = new StreamWriter(fError, Encoding.UTF8))
{
p.OutputDataReceived += (sender, args) =>
{
outputWriter.WriteLine(args.Data);
if (controller != null)
{
controller.OnStdoutReceived(args.Data);
}
};
p.ErrorDataReceived += (sender, args) =>
{
errorWriter.WriteLine(args.Data);
if (controller != null)
{
controller.OnStderrReceived(args.Data);
}
};
lock (PipeLocker)
{
p.Start();
p.BeginOutputReadLine();
p.BeginErrorReadLine();
}
p.WaitForExit();
p.CancelErrorRead();
p.CancelOutputRead();
}
string output = "";
string error;
lock (FileLocker)
{
if (controller != null)
{
controller.AboutToCleanup(tempOutputFile, tempErrorFile);
}
if (outputFile == null)
{
output = File.ReadAllText(tempOutputFile, Encoding.UTF8);
File.Delete(tempOutputFile);
}
error = File.ReadAllText(tempErrorFile, Encoding.UTF8);
File.Delete(tempErrorFile);
}
stopWatch.Stop();
var result = new ExecuteResult()
{
ExitCode = p.ExitCode,
StdOut = outputFile == null ? output : "in outputfile",
StdErr = error,
Duration = TimeSpan.FromMilliseconds(stopWatch.ElapsedMilliseconds)
};
return(result);
}
}
public static ExecuteResult Execute(ExecuteArgs executeArgs, IExecuteController controller = null)
{
void ExecuteWorker_DoWork(object sender, DoWorkEventArgs e)
{
ExecuteArgs args = (ExecuteArgs)e.Argument;
BackgroundWorker worker = (BackgroundWorker)sender;
IList <IList <object> > result = new List <IList <object> >();
using (OdbcConnection con = new OdbcConnection(args.ConString))
{
con.Open();
com = new OdbcCommand(args.SQL, con);
com.CommandTimeout = settings.CommandTimeout;
using (IDataReader r = com.ExecuteReader())
{
// Write the header
IList <object> header = new List <object>();
for (int c = 0; c < r.FieldCount; c++)
{
header.Add(r.GetName(c));
}
result.Add(header);
int i = 0;
// Write the values
while (r.Read())
{
i++;
IList <object> row = new List <object>();
for (int c = 0; c < r.FieldCount; c++)
{
if (worker.CancellationPending)
{
e.Cancel = true;
return;
}
if (r.IsDBNull(c))
{
row.Add(null);
}
else if (r.GetFieldType(c) == typeof(DateTime))
{
row.Add(r.GetDateTime(c));
}
else if (r.GetFieldType(c) == typeof(string))
{
row.Add(r[c].ToString().Trim());
}
else
{
row.Add(r[c]);
}
}
result.Add(row);
if (i >= settings.QueryResultMaximum)
{
break;
}
}
}
}
e.Result = result;
}
