} // func GetStringArray
private async Task OpenCursorAsync(LuaTable table)
{
// not optional
var selectExpression = table.GetOptionalValue("name", (string)null) ?? throw new ArgumentNullException("name");
// parse selector
var selectorExpression = PpsDataFilterExpression.Parse(table.GetMemberValue("filter"));
// parse optional columns
var columns = PpsDataColumnExpression.Parse(table.GetMemberValue("columns")).ToArray();
// parse optional order
var orderExpressions = PpsDataOrderExpression.Parse(table.GetMemberValue("order")).ToArray();
// try to get a list
int cursorId;
lock (cursors)
cursorId = ++lastCursorId;
var cursor = new OpenCursor(cursorId, await provider.GetListAsync(selectExpression, columns, selectorExpression, orderExpressions));
lock (cursors)
cursors.Add(cursorId, cursor);
// return the cursor id
await PushPacketAsync(new LuaTable()
{
["id"] = cursorId
});
} // proc OpenCursorAsync
public void TestMember01()
{
LuaTable t = new LuaTable();
t["test"] = "t";
Assert.AreEqual(t["test"], "t");
t.SetMemberValue("Test", "a", true);
Assert.AreEqual(t.GetMemberValue("Test", true, true), "a");
t.SetMemberValue("Test", "b");
Assert.AreEqual(t["Test"], "b");
t.SetMemberValue("Test", "n", true);
Assert.AreEqual(t["test"], "n");
IDictionary <string, object> a = t.Members;
string[] r = new string[2];
a.Keys.CopyTo(r, 0);
Assert.IsTrue(r[0] == "test" && r[1] == "Test");
t.SetMemberValue("Test", null, true, true);
t.SetMemberValue("Test", null, true, true);
Assert.IsTrue(t["Test"] == null);
Assert.IsTrue(t["test"] == null);
}
} // CompareStringKey
public static T ReturnOptionalValue <T>(this LuaTable table, string name, T @default, bool ignoreCase = false, bool rawGet = false)
{
var value = table.GetMemberValue(name, ignoreCase, rawGet);
if (value == null)
{
return(@default);
}
else
{
if (Lua.RtInvokeable(value))
{
value = new LuaResult(Lua.RtInvoke(value))[0];
}
if (value == null)
{
return(@default);
}
try
{
return(value.ChangeType <T>());
}
catch
{
return(@default);
}
}
} // func ReturnOptionalValue
private void Button_Click_1(object sender, RoutedEventArgs e)
{
using (Lua l = new Lua())
{
var t = new LuaTable();
var c = l.CompileChunk(
String.Join(Environment.NewLine,
"local v1 = 2;",
"local v2 = 4;",
"function f()",
" return v1 + v2;",
"end;",
"return f();"), "test", null);
var r = c.Run(t);
txtResult.Text = String.Format("Test: v1=[{0}], v2=[{1}], r={2}", Lua.RtGetUpValue(t.GetMemberValue("f") as Delegate, 1), Lua.RtGetUpValue(t.GetMemberValue("f") as Delegate, 2), r.ToInt32());
}
}
} // proc Rollback
#endregion
#region -- Prepare/Execute ----------------------------------------------------
/// <summary>Prepare a database statement.</summary>
/// <param name="parameter"></param>
/// <param name="firstArgs"></param>
/// <returns></returns>
public PpsDataCommand Prepare(LuaTable parameter, LuaTable firstArgs)
{
if (parameter.GetMemberValue("rows") != null)
{
throw new ArgumentNullException("rows", "Prepare does not support 'rows'.");
}
return(PrepareCore(parameter, firstArgs));
} // func Prepare
private LuaResult LuaRequirePane(LuaTable self, string path, LuaTable initialTable = null)
{
// get the current root
var webRequest = self.GetMemberValue(nameof(IPpsRequest.Request)) as DEHttpClient ?? Request;
var fullUri = webRequest.CreateFullUri(path);
var paneData = this.LoadPaneDataAsync(initialTable ?? new LuaTable(), fullUri).AwaitTask();
return(new LuaResult(new PpsGenericWpfChildPane(this, paneData, fullUri)));
} // func LuaRequirePane
/// <summary>Invoke lua event handler.</summary>
/// <param name="t"></param>
/// <param name="methodName"></param>
/// <param name="args"></param>
/// <returns></returns>
public LuaResult InvokeLuaFunction(LuaTable t, string methodName, params object[] args)
{
var handler = t.GetMemberValue(methodName, rawGet: true);
if (Lua.RtInvokeable(handler))
{
return(new LuaResult(Lua.RtInvoke(handler, args)));
}
return(LuaResult.Empty);
} // func InvokeClientFunction
} // proc Dispose
/// <summary></summary>
/// <param name="otherArgumens"></param>
/// <returns></returns>
public override PpsWindowPaneCompareResult CompareArguments(LuaTable otherArgumens)
{
var r = base.CompareArguments(otherArgumens);
if (r == PpsWindowPaneCompareResult.Reload || r == PpsWindowPaneCompareResult.Incompatible)
{
var otherObj = otherArgumens.GetMemberValue("Object");
return(otherObj == obj ? PpsWindowPaneCompareResult.Same : PpsWindowPaneCompareResult.Reload);
}
return(r);
} // func CompareArguments
static void Main(string[] args)
{
Console.Write(TestAsync().Result);
using (Lua l = new Lua())
{
var t = new LuaTable();
var c = l.CompileChunk(
String.Join(Environment.NewLine,
"local v1 = 2;",
"local v2 = 4;",
"function f()",
" return v1 + v2;",
"end;",
"return f();"), "test", null);
var r = c.Run(t);
Console.WriteLine("Test: v1=[{0}], v2=[{1}], r={2}", Lua.RtGetUpValue(t.GetMemberValue("f") as Delegate, 1), Lua.RtGetUpValue(t.GetMemberValue("f") as Delegate, 2), r.ToInt32());
}
//LinqTest2();
Console.ReadKey();
}
} // proc Dispose
private static ILogger GetHostLog(LuaTable table)
{
// Check for a logger
var sp = table.GetMemberValue("host") as IServiceProvider;
if (sp != null)
{
return(sp.GetService <ILogger>(false));
}
return(null);
} // func LogMsg
} // proc CloseCursorAsync
private async Task GetDataSetAsync(LuaTable table)
{
var identification = table.GetMemberValue("id") ?? throw new ArgumentNullException("id");
var tableFilter = GetStringArray(table, "filter");
var dataset = await provider.GetDataSetAsync(identification, tableFilter);
var result = new LuaTable();
foreach (var tab in dataset.Tables)
{
if (tableFilter.Length != 0 &&
Array.Exists(tableFilter, c => String.Compare(c, tab.TableName, StringComparison.OrdinalIgnoreCase) != 0))
{
continue;
}
var resultTable = new LuaTable();
var columnList = new LuaTable();
foreach (var col in tab.Columns)
{
var resultColumn = GetColumnData(col, new LuaTable());
if (col.IsRelationColumn)
{
resultColumn["parentReleation"] = new LuaTable()
{
["table"] = col.ParentColumn.ParentColumn.Table.Name,
["column"] = col.ParentColumn.ParentColumn.Name
};
}
columnList.Add(resultColumn);
}
resultTable["columns"] = columnList;
// convert rows
foreach (var row in tab)
{
resultTable.Add(GetRowData(new LuaTable(), row));
}
result[tab.TableName] = resultTable;
}
await PushPacketAsync(result);
} // proc ExecuteAsync
public void DebugReport(LuaTable table)
{
table["DebugOutput"] = new Action <string>(text => Log.LogMsg(LogMsgType.Debug, text));
var resultFile = RunReportAsync(table).AwaitTask();
// move to a unique name
var moveFileTo = table.GetMemberValue("name") as string;
var p = moveFileTo.LastIndexOfAny(new char[] { '/', '\\' });
moveFileTo = Path.Combine(Path.GetDirectoryName(resultFile), moveFileTo.Substring(p + 1)) + ".pdf";
if (File.Exists(moveFileTo))
{
File.Delete(moveFileTo);
}
File.Move(resultFile, moveFileTo);
} // proc DebugReport
} // func TryGetCursor
private static string[] GetStringArray(LuaTable table, string memberName)
{
switch (table.GetMemberValue(memberName))
{
case string stringList:
return(stringList.Split(',').Where(s => !String.IsNullOrEmpty(s)).ToArray());
case LuaTable tableArray:
return(tableArray.ArrayList.Select(o => o.ToString()).ToArray());
case null:
return(Array.Empty <string>());
default:
throw new ArgumentOutOfRangeException(memberName, $"'{memberName}' should be a string list or a lua array.");
}
} // func GetStringArray
private OpenCursor GetCursor(LuaTable table)
{
var id = Procs.ChangeType <int>(table.GetMemberValue("id") ?? throw new ArgumentNullException("id"));
lock (cursors)
{
if (cursors.TryGetValue(id, out var cursor))
{
if (cursor.IsDisposed)
{
cursors.Remove(id);
}
else
{
return(cursor);
}
}
}
throw new ArgumentOutOfRangeException("id", $"Cursor '{id}' not found.");
} // func TryGetCursor
} // proc NextCursorAsync
private async Task NextCursorCountAsync(LuaTable table)
{
// get parameter
var cursor = GetCursor(table);
var count = Procs.ChangeType <int>(table.GetMemberValue("count") ?? -1);
// collect rows
var rows = new LuaTable();
while (count-- > 0 && cursor.MoveNext())
{
rows.Add(cursor.GetCurrentRow());
}
// send result
await PushPacketAsync(new LuaTable()
{
["id"] = cursor.Id,
["row"] = rows.Length == 0 ? null : rows
});
} // proc NextCursorCountAsync
public void TestMember01()
{
LuaTable t = new LuaTable();
t["test"] = "t";
Assert.AreEqual(t["test"], "t");
t.SetMemberValue("Test", "a", true);
Assert.AreEqual(t.GetMemberValue("Test", true, true), "a");
t.SetMemberValue("Test", "b");
Assert.AreEqual(t["Test"], "b");
t.SetMemberValue("Test", "n", true);
Assert.AreEqual(t["test"], "n");
IDictionary<string, object> a = t.Members;
string[] r = new string[2];
a.Keys.CopyTo(r, 0);
Assert.IsTrue(r[0] == "test" && r[1] == "Test");
t.SetMemberValue("Test", null, true, true);
t.SetMemberValue("Test", null, true, true);
Assert.IsTrue(t["Test"] == null);
Assert.IsTrue(t["test"] == null);
}
private (IEnumerator <object>, PpsDataCommand) PrepareWithData(LuaTable parameter)
{
if (parameter.GetMemberValue("rows") is IEnumerable <IDataRow> rows) // from datatable or other row source
{
var rowEnumerator = rows.GetEnumerator();
if (rows is IDataColumns columns)
{
rowEnumerator.MoveNext();
}
else
{
if (!rowEnumerator.MoveNext()) // no arguments defined
{
rowEnumerator.Dispose();
return(null, null); // silent return nothing
}
columns = rowEnumerator.Current as IDataColumns;
}
// create columns list parameter
parameter["columnList"] = columns ?? throw new ArgumentException("IDataColumns not implemented.", nameof(parameter));
return(rowEnumerator, PrepareCore(parameter, null));
}
else
{
var rowEnumerator = parameter.ArrayList.OfType <LuaTable>().GetEnumerator();
if (!rowEnumerator.MoveNext())
{
rowEnumerator.Dispose();
return(null, PrepareCore(parameter, null));
}
return(rowEnumerator, PrepareCore(parameter, rowEnumerator.Current));
}
} // func PrepareWithData
public string DebugEmitter(LuaTable table)
{
var arguments = table.GetOptionalValue("converter", (string)null);
var columnName = table.GetOptionalValue("columnName", (string)null);
// create row
var row = GetRowContent((table.GetMemberValue("row") as LuaTable) ?? throw new ArgumentNullException("row", "Row information is missing."));
using (var session = reporting.CreateDebugReportSession())
using (var sw = new StringWriter())
using (var xml = XmlWriter.Create(sw, new XmlWriterSettings()
{
NewLineHandling = NewLineHandling.Entitize, IndentChars = " ", Async = true
}))
{
// emit column
var emitter = session.CreateColumnEmitter(arguments, columnName, row);
xml.WriteStartElement(emitter.ElementName);
emitter.WriteAsync(xml, row).AwaitTask();
xml.WriteEndElement();
xml.Flush();
return(sw.GetStringBuilder().ToString());
}
} // func DebugEmitter
public GSubLuaTableMatchEvaluator(LuaTable t)
{
this.t = t;
this.lIgnoreCase = (bool)Lua.RtConvertValue(t.GetMemberValue("__IgnoreCase"), typeof(bool));
}
/// <summary></summary>
/// <param name="args"></param>
/// <returns></returns>
protected override Task OnLoadAsync(LuaTable args)
{
ClosePdf();
return(OpenPdfAsync(args.GetMemberValue("Object") ?? args.GetMemberValue("FileName")));
} // proc OnLoadAsync
public GSubLuaTableMatchEvaluator(LuaTable t)
{
this.t = t;
this.lIgnoreCase = (bool)Lua.RtConvertValue(t.GetMemberValue("__IgnoreCase"), typeof(bool));
} // ctor
} // ctor
protected override string MatchEvaluatorImpl(Match m)
{
return((string)Lua.RtConvertValue(t.GetMemberValue(m.Groups[1].Value, lIgnoreCase), typeof(string)));
} // func MatchEvaluator
private void Button_Click_1(object sender, RoutedEventArgs e)
{
using (Lua l = new Lua())
{
var t = new LuaTable();
var c = l.CompileChunk(
String.Join(Environment.NewLine,
"local v1 = 2;",
"local v2 = 4;",
"function f()",
" return v1 + v2;",
"end;",
"return f();"), "test", null);
var r = c.Run(t);
txtResult.Text = String.Format("Test: v1=[{0}], v2=[{1}], r={2}", Lua.RtGetUpValue(t.GetMemberValue("f") as Delegate, 1), Lua.RtGetUpValue(t.GetMemberValue("f") as Delegate, 2), r.ToInt32());
}
}
private static void Test()
{
using (Lua l = new Lua())
{
var t = new LuaTable();
var c = l.CompileChunk(
String.Join(Environment.NewLine,
"local v1 = 2;",
"local v2 = 4;",
"function f()",
" return v1 + v2;",
"end;",
"return f();"), "test", null);
var r = c.Run(t);
Console.WriteLine("Test: v1=[{0}], v2=[{1}], r={2}", Lua.RtGetUpValue(t.GetMemberValue("f") as Delegate, 1), Lua.RtGetUpValue(t.GetMemberValue("f") as Delegate, 2), r.ToInt32());
}
}
/// <summary></summary>
/// <param name="arguments"></param>
/// <returns></returns>
protected override async Task LoadInternAsync(LuaTable arguments)
{
async Task CreateNewObjectAsync()
{
// load schema
var documentType = (string)arguments.GetMemberValue("createNew");
if (documentType == null)
{
throw new ArgumentException("No 'object' or 'createNew' set.");
}
// get the object info for the type
var objectInfo = Shell.ObjectInfos[documentType];
if (objectInfo.CreateServerSiteOnly || String.IsNullOrEmpty(objectInfo.DocumentUri))
{
throw new ArgumentNullException("object", "Parameter 'object' is missing.");
}
// create the new object entry
obj = await Shell.CreateNewObjectAsync(objectInfo);
} // proc CreateNewObject
// get the object reference for the document
obj = (PpsObject)arguments.GetMemberValue("Object");
// new document or load one
using (var transaction = await Shell.MasterData.CreateTransactionAsync(PpsMasterDataTransactionLevel.Write))
{
if (obj == null) // no object given
{
await CreateNewObjectAsync();
}
data = await obj.GetDataAsync <PpsObjectDataSet>();
// register events, owner, and in the openDocuments dictionary
dataAccess = await data.AccessAsync(arguments);
dataAccess.DisableUI = new Func <IDisposable>(() => DisableUI("Verarbeite Daten...", -1));
dataAccess.DataChanged += (sender, e) => OnDataChanged();
transaction.Commit();
}
// get the pane to view, if it is not given
if (!arguments.ContainsKey("pane"))
{
// try to get the uri from the pane list
var info = Shell.GetObjectInfo(obj.Typ);
var paneUri = info["defaultPane"] as string;
if (!String.IsNullOrEmpty(paneUri))
{
arguments.SetMemberValue("Pane", paneUri);
}
else
{
// read the schema meta data
paneUri = data.DataSetDefinition.Meta.GetProperty <string>(PpsDataSetMetaData.DefaultPaneUri, null);
if (!String.IsNullOrEmpty(paneUri))
{
arguments.SetMemberValue("Pane", paneUri);
}
}
}
// Load mask
await base.LoadInternAsync(arguments);
InitializeData();
} // proc LoadInternAsync