public static Dictionary <string, object> CreateParam(DBProcedure procedure, DBItem document = null)
{
var parameters = DBProcedure.CreateParams(document);
CheckParam(procedure, parameters);
return(parameters);
}
public void SyncDBTime()
{
if (processingSync)
{
return;
}
processingSync = true;
var currentDBTime = DBProcedure.GetServerTimestamp(_dbConfig);
var timeGapToFollow = currentDBTime - DBTime;
long absoluteTimeGapInMilliseconds = Convert.ToInt64(Math.Abs(timeGapToFollow.TotalMilliseconds));
if (absoluteTimeGapInMilliseconds > timeGapToleranceInMilliseconds)
{
if (timeGapToFollow.TotalMilliseconds > 0)
{
Console.WriteLine($"{DateTime.Now.Ticks} : local is {DBTime.Ticks} db is {currentDBTime.Ticks}. just re sync");
ResetFromDBTime(currentDBTime);
}
else
{
Console.WriteLine($"{DateTime.Now.Ticks} : old syncedDBTime is {DBTime.Ticks} / currentDBTime is {currentDBTime.Ticks}. stasis needed {absoluteTimeGapInMilliseconds} ms.");
stopwatch.Stop();
Thread.Sleep(Convert.ToInt32(absoluteTimeGapInMilliseconds));
ResetFromDBTime(currentDBTime);
Console.WriteLine($"{DateTime.Now.Ticks} : sync after stasis is done");
}
}
processingSync = false;
}
public ExecuteDocumentArg(Document document, DBProcedure precedure, object result, object tag)
{
this.precedure = precedure;
this.result = result;
this.document = document;
this.tag = tag;
}
public Startup(IConfiguration configuration)
{
Configuration = configuration;
DBProcedure.InitJsonMapper();
string logRootPath = (string)configuration.GetValue(typeof(string), "LogRoot");
if (!string.IsNullOrEmpty(logRootPath))
{
Console.WriteLine($"log root : {logRootPath}");
Console.WriteLine("StartUp Start");
}
try
{
ConfigurationManager.Instance.Initialize(Configuration, MySqlClientFactory.Instance);
DBTimeWatch.Instance.Initialize(ConfigurationManager.Instance.DBConfig);
RedisProcedure.Initialize(ConfigurationManager.Instance.RedisConnectionString);
if (!string.IsNullOrEmpty(logRootPath))
{
Console.WriteLine("StartUp Done");
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw e;
}
}
private void ListErrorCellMouseClick(object sender, LayoutHitTestEventArgs e)
{
LayoutList list = sender as LayoutList;
if (list.SelectedItem is System.CodeDom.Compiler.CompilerError error)
{
string code = System.IO.Path.GetFileNameWithoutExtension(error.FileName);
DBProcedure p = DBService.Schems.ParseProcedure(code);
if (GuiService.Main == null)
{
Select(error.Column, error.Line);
}
else if (p != null)
{
string name = GetName(p);
if (!(GuiService.Main.DockPanel.Find(name) is ProcedureEditor editor))
{
editor = new ProcedureEditor {
Procedure = p
};
}
GuiService.Main.DockPanel.Put(editor);
editor.Select(error.Column, error.Line);
}
}
}
public MenuItemProcedure(DBProcedure proc)
{
this.procedure = proc;
Text = procedure.ToString();
Image = (Image)Locale.GetImage("plugin");
#if GTK
DisplayStyle = System.Windows.Forms.ToolStripItemDisplayStyle.ImageAndText;
Overflow = System.Windows.Forms.ToolStripItemOverflow.AsNeeded;
#endif
}
public ActionResult <DBProcedure> Put(DBProcedure value)
{
var procedure = DBService.Schems.DefaultSchema.Procedures[value.Name];
if (procedure != null)
{
procedure.DisplayName = value.DisplayName;
}
return(procedure);
}
private void ProcedureItemClick(object sender, EventArgs e)
{
var sen = sender as MenuItemProcedure;
if (sen.DropDown?.Items.Count > 0)
{
return;
}
DBProcedure proc = sen.Procedure;
object result = null;
var list = GetList();
if (list != null && list.Count > 1)
{
if (!ExecuteDocumentsProcedure(proc, list))
{
for (int i = 0; i < list.Count; i++)
{
Document listDocument = list[i];
result = ExecuteDocumentProcedure(proc, listDocument, false);//i == list.Count - 1);
if (result != null)
{
CheckProcRezult(new ExecuteDocumentArg(listDocument, proc, result, this));
}
}
}
if (GuiService.Main != null)
{
var task = new TaskExecutor
{
Name = "Confirmation!",
Action = () =>
{
Application.Invoke(() => MessageDialog.ShowMessage(ParentWindow,
string.Format(Locale.Get("DocumentEditor", "Method {0}\nExecute successful!"), proc.Name), "Methods"));
return(null);
}
};
GuiService.Main.AddTask(this, task);
}
}
else
{
result = ExecuteDocumentProcedure(proc, document, true);
if (result != null)
{
CheckProcRezult(new ExecuteDocumentArg(document, proc, result, this));
}
}
}
public static void ShowResultDialog(object parent, DBProcedure proc, object result)
{
var textbox = new RichTextView();
textbox.LoadText(result.ToString(), Xwt.Formats.TextFormat.Plain);
var wind = new ToolWindow()
{
Target = textbox,
Mode = ToolShowMode.Dialog,
Size = new Size(600, 400)
};
wind.ButtonClose.Visible = false;
wind.Label.Text = "Result of " + (proc != null ? proc.Name : string.Empty);
wind.Show();
//wind.Dispose();
}
public static bool ExecuteDocumentsProcedure(DBProcedure proc, IEnumerable documents)
{
if (proc.ProcedureType == ProcedureTypes.Assembly || proc.ProcedureType == ProcedureTypes.Source)
{
var type = proc.GetObjectType();
if (type.GetInterface("IDocuments") != null)
{
object result = proc.CreateObject();
if (result is IDocuments)
{
((IDocuments)result).Documents = documents;
return(true);
}
}
}
return(false);
}
public static void CheckParam(DBProcedure procedure, Dictionary <string, object> parameterList)
{
bool showDialog = false;
foreach (DBProcParameter param in procedure.Parameters)
{
if (!parameterList.ContainsKey(param.Name))
{
showDialog = true;
break;
}
}
if (showDialog)
{
if (!FormParam.Initialize(procedure, parameterList))
{
throw new Exception("Cancel!");
}
}
}
private void ToolLoadFileClick(object sender, EventArgs e)
{
var dialog = new OpenFileDialog()
{
Multiselect = true
};
if (dialog.Run(ParentWindow))
{
foreach (string fileName in dialog.FileNames)
{
string name = Path.GetFileName(fileName);
var query = new Query <DBProcedure>(new[]
{
new QueryParameter <DBProcedure>()
{
Invoker = EmitInvoker.Initialize <DBProcedure>(nameof(DBProcedure.DataName)),
Value = name
},
new QueryParameter <DBProcedure>()
{
Invoker = EmitInvoker.Initialize <DBProcedure>(nameof(DBProcedure.ProcedureType)),
Value = ProcedureTypes.File
},
});
if (!(CurrentSchema.Procedures.Find(query) is DBProcedure procedire))
{
procedire = new DBProcedure
{
ProcedureType = ProcedureTypes.File,
DataName = name,
Name = Path.GetFileNameWithoutExtension(name)
};
}
procedire.Data = File.ReadAllBytes(fileName);
procedire.Stamp = File.GetLastWriteTime(fileName);
procedire.Save();
}
MessageDialog.ShowMessage(ParentWindow, Locale.Get("FlowExplorer", "Files load complete!"), "File Loader!");
}
}
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 void BuildParameters()
{
parameters = DBProcedure.CreateParams(document);
//Clear Fields
foreach (var field in fields)
{
Tools.Items.Remove(field);
field.Dispose();
}
fields.Clear();
DBItem row = null;
foreach (var param in procedure.Parameters)
{
if (!parameters.ContainsKey(param.Name))
{
//New temporary table
if (table == null || table.Name != (procedure.Name + "Param"))
{
if (table != null)
{
table.Dispose();
}
table = new DBTable <DBItem>(procedure.Name + "Param")
{
Schema = procedure.Schema,
BlockSize = 1
};
}
if (row == null)
{
row = table.NewItem();
}
DBColumn col = new DBColumn
{
Name = !string.IsNullOrEmpty(param.Name) ? param.Name : "NewParam",
Table = table
};
if (param.Column != null)
{
if (param.Column.IsPrimaryKey)
{
col.ReferenceTable = param.Column.Table;
}
if (param.Column.IsReference)
{
col.ReferenceTable = param.Column.ReferenceTable;
}
}
col.DataType = param.DataType;
table.Columns.Add(col);
var tool = new ToolDataFieldEditor
{
FieldWidth = col.ReferenceTable != null ? 150 : 80,
Visible = true
};
tool.Field.LabelSize = -1;
tool.Field.BindData(row, col.Name);
fields.Add(tool);
Tools.Add(tool);
}
}
if (Query == null || Query.Name != procedure.Name)
{
var commnad = procedure.BuildCommand(parameters);
SetCommand(commnad, procedure.Schema, procedure.Name);
}
procedure.UpdateCommand(command, parameters);
}
public static object Execute(DBProcedure procedure, ExecuteArgs args)
{
CheckParam(procedure, args.Parameters);
return(procedure.Execute(args));
}
public static object Execute(DBProcedure procedure, DBItem document = null)
{
return(Execute(procedure, new ExecuteArgs(document)));
}
public static bool Initialize(DBProcedure procedure, Dictionary <string, object> existingParam)
{
var window = new FormParam();
window.Label.Text = procedure.ToString();
var table = new DBTable <DBItem>(procedure.Name + "Param")
{
Schema = procedure.Schema,
BlockSize = 1
};
foreach (var param in procedure.Parameters)
{
if (existingParam.ContainsKey(param.Name.ToString()))
{
continue;
}
DBColumn col = new DBColumn
{
Name = param.Name != null && param.Name.Length > 0 ? param.Name : "NewColumn",
Table = table
};
if (param.Column != null)
{
if (param.Column.IsPrimaryKey)
{
col.ReferenceTable = param.Column.Table;
}
if (param.Column.IsReference)
{
col.ReferenceTable = param.Column.ReferenceTable;
}
}
col.DataType = param.DataType;
table.Columns.Add(col);
}
var row = table.NewItem();
window.propertyes.FieldSource = row;
window.propertyes.ResetFields();
window.propertyes.EditState = EditListState.Edit;
window.ButtonAcceptClick += (s, e) =>
{
foreach (var column in table.Columns)
{
if (row[column] == DBNull.Value &&
MessageDialog.AskQuestion("Параметры", "Не все Параметры были указаны, продолжить?", Command.No, Command.Yes) == Command.No)
{
return;
}
existingParam.Add(column.Name, row[column]);
}
window.Hide();
};
window.Show(null, Point.Zero);
//p.Dispose();
//ts.Dispose();
return(true);
}
public static string GetName(DBProcedure p)
{
return("procedure" + p.Name);
}
public static object Execute(DBProcedure procedure, ExecuteArgs param)
{
CheckParam(procedure, param.Parameters);
return(procedure.Execute(param));
}
private void ToolBuildClick(object sender, EventArgs e)
{
Procedure.Save();
if (procedure.ProcedureType == ProcedureTypes.StoredFunction)
{
procedure.Schema.Connection.ExecuteQuery("drop function " + procedure.Name);
procedure.Schema.Connection.ExecuteQuery(procedure.Source);
GuiService.Main.SetStatus(new StateInfo("Compiler", "Function compiler succesful!"));
}
else if (procedure.ProcedureType == ProcedureTypes.StoredProcedure)
{
procedure.Schema.Connection.ExecuteQuery("drop procedure " + procedure.Name);
procedure.Schema.Connection.ExecuteQuery(procedure.Source);
GuiService.Main.SetStatus(new StateInfo("Compiler", "Procedure compiler succesful!"));
}
else if (procedure.ProcedureType == ProcedureTypes.Source)
{
//TODO this.source.Document.FoldingManager.UpdateFoldings(null, null);
System.CodeDom.Compiler.CompilerResults result;
if (procedure.DataName == null || procedure.DataName.Length == 0)
{
DBProcedure.Compile(procedure.Name, new DBProcedure[] { procedure }, out result, true);
}
else
{
DBProcedure.Compile(procedure.DataName, procedure.Schema.Procedures.SelectByFile(procedure.DataName), out result, true);
}
string name = "CompilerErrorList";
if (procedure.TempAssembly == null)
{
if (GuiService.Main != null)
{
if (!(GuiService.Main.DockPanel.Find(name) is LayoutList errors))
{
errors = new LayoutList
{
Name = name,
Text = "Errors"
};
errors.CellMouseClick += ListErrorCellMouseClick;
}
errors.ListSource = result.Errors;
GuiService.Main.DockPanel.Put(errors, DockType.Bottom);
GuiService.Main.SetStatus(new StateInfo("Compiler", "Error in source!", DBProcedure.CompilerError(result), StatusType.Error));
}
}
else
{
if (GuiService.Main != null)
{
if (GuiService.Main.DockPanel.Find(name) is LayoutList errors)
{
GuiService.Main.DockPanel.Delete(errors);
}
GuiService.Main.SetStatus(new StateInfo("Compiler", "Succesful!"));
}
}
}
}
