/// <summary> /// Handles the signal for the class. /// </summary> /// <param name="signaler">Signaler used to signal the slot.</param> /// <param name="input">Root node for invocation.</param> /// <returns>An awaitable task.</returns> public async Task SignalAsync(ISignaler signaler, Node input) { // Figuring out if caller wants to return multiple result sets or not. var multipleResultSets = Executor.HasMultipleResultSets(input); // Invoking execute helper. await Executor.ExecuteAsync( input, signaler.Peek <MySqlConnectionWrapper>("mysql.connect").Connection, signaler.Peek <Transaction>("mysql.transaction"), async (cmd, max) => { using (var reader = await cmd.ExecuteReaderAsync()) { do { Node parentNode = input; if (multipleResultSets) { parentNode = new Node(); input.Add(parentNode); } while (await reader.ReadAsync()) { if (!Executor.BuildResultRow(reader, parentNode, ref max)) { break; } } } while (multipleResultSets && await reader.NextResultAsync()); } }); }
/// <summary> /// Implementation of your slot. /// </summary> /// <param name="signaler">Signaler used to raise the signal.</param> /// <param name="input">Arguments to your slot.</param> public void Signal(ISignaler signaler, Node input) { // Figuring out if caller wants to return multiple result sets or not. var multipleResultSets = Executor.HasMultipleResultSets(input); // Invoking execute helper. Executor.Execute( input, signaler.Peek <SqlConnectionWrapper>("mssql.connect").Connection, signaler.Peek <Transaction>("mssql.transaction"), (cmd, max) => { using (var reader = cmd.ExecuteReader()) { do { Node parentNode = input; if (multipleResultSets) { parentNode = new Node(); input.Add(parentNode); } while (reader.Read()) { if (!Executor.BuildResultRow(reader, parentNode, ref max)) { break; } } } while (multipleResultSets && reader.NextResult()); } }); }
/// <summary> /// Implementation of your slot. /// </summary> /// <param name="signaler">Signaler used to raise the signal.</param> /// <param name="input">Arguments to your slot.</param> /// <returns>An awaitable task.</returns> public async Task SignalAsync(ISignaler signaler, Node input) { // Parsing and creating SQL. var exe = com.helpers.SqlBuilder.Parse <SqlReadBuilder>(signaler, input); if (exe == null) { return; } // Executing SQL, now parametrized. await com.Executor.ExecuteAsync( exe, signaler.Peek <MySqlConnectionWrapper>("mysql.connect").Connection, signaler.Peek <com.Transaction>("mysql.transaction"), async (cmd, _) => { using (var reader = await cmd.ExecuteReaderAsync()) { input.Clear(); while (await reader.ReadAsync()) { var rowNode = new Node("."); for (var idxCol = 0; idxCol < reader.FieldCount; idxCol++) { var colNode = new Node(reader.GetName(idxCol), com.Converter.GetValue(reader[idxCol])); rowNode.Add(colNode); } input.Add(rowNode); } } }); }
/// <summary> /// Handles the signal for the class. /// </summary> /// <param name="signaler">Signaler used to signal the slot.</param> /// <param name="input">Root node for invocation.</param> public void Signal(ISignaler signaler, Node input) { Executor.Execute( input, signaler.Peek <MySqlConnectionWrapper>("mysql.connect").Connection, signaler.Peek <Transaction>("mysql.transaction"), (cmd, _) => { input.Value = Converter.GetValue(cmd.ExecuteScalar()); }); }
/// <summary> /// Implementation of your slot. /// </summary> /// <param name="signaler">Signaler used to raise the signal.</param> /// <param name="input">Arguments to your slot.</param> public void Signal(ISignaler signaler, Node input) { Executor.Execute( input, signaler.Peek <SqlConnectionWrapper>("mssql.connect").Connection, signaler.Peek <Transaction>("mssql.transaction"), (cmd, _) => { input.Value = cmd.ExecuteNonQuery(); }); }
/// <summary> /// Implementation of your slot. /// </summary> /// <param name="signaler">Signaler used to raise the signal.</param> /// <param name="input">Arguments to your slot.</param> /// <returns>An awaitable task.</returns> public async Task SignalAsync(ISignaler signaler, Node input) { await Executor.ExecuteAsync( input, signaler.Peek <SqlConnectionWrapper>("mssql.connect").Connection, signaler.Peek <Transaction>("mssql.transaction"), async (cmd, _) => { input.Value = await cmd.ExecuteNonQueryAsync(); }); }
/// <summary> /// Implementation of signal /// </summary> /// <param name="signaler">Signaler used to signal</param> /// <param name="input">Parameters passed from signaler</param> public void Signal(ISignaler signaler, Node input) { input.Clear(); var filter = input.GetEx <string>(); input.Value = null; var whitelist = signaler.Peek <List <Node> >("whitelist"); if (filter == null) { input.AddRange(_signalProvider.Keys .Where(x => !x.StartsWith(".", StringComparison.InvariantCulture) && (whitelist == null || whitelist.Any(x2 => x2.Name == x))) .Select(x => new Node("", x))); } else { input.AddRange(_signalProvider.Keys .Where(x => !x.StartsWith(".", StringComparison.InvariantCulture) && x.StartsWith(filter, StringComparison.InvariantCulture) && (whitelist == null || whitelist.Any(x2 => x2.Name == x))) .Select(x => new Node("", x))); } }
/// <summary> /// Implementation of signal /// </summary> /// <param name="signaler">Signaler used to signal</param> /// <param name="input">Parameters passed from signaler</param> /// <returns>An awaitable task.</returns> public async Task SignalAsync(ISignaler signaler, Node input) { // Making sure we can reset back to original nodes after every single iteration. var old = input.Children.Select(x => x.Clone()).ToList(); // Storing termination node, to check if we should terminate early for some reasons. var terminate = signaler.Peek <Node>("slots.result"); foreach (var idx in input.Evaluate()) { // Inserting "data pointer". input.Insert(0, new Node(".dp", idx)); // Evaluating "body" lambda of [for-each] await signaler.SignalAsync("eval", input); // Resetting back to original nodes. input.Clear(); // Notice, cloning in case we've got another iteration, to avoid changing original nodes' values. input.AddRange(old.Select(x => x.Clone())); // Checking if execution for some reasons was terminated. if (terminate != null && (terminate.Value != null || terminate.Children.Any())) { return; } } }
/// <summary> /// [mssql.transaction.create] slot for creating a new MS SQL database transaction. /// </summary> /// <param name="signaler">Signaler used to raise the signal.</param> /// <param name="input">Arguments to your slot.</param> /// <returns>An awaitable task.</returns> public async Task SignalAsync(ISignaler signaler, Node input) { await signaler.ScopeAsync( "mssql.transaction", new Transaction(signaler, signaler.Peek <SqlConnectionWrapper>("mssql.connect").Connection), async() => await signaler.SignalAsync("eval", input)); }
/// <summary> /// Slot implementation. /// </summary> /// <param name="signaler">Signaler that raised signal.</param> /// <param name="input">Arguments to slot.</param> public void Signal(ISignaler signaler, Node input) { signaler.Peek <Node>("slots.result") .AddRange(input.Value == null ? input.Children.ToList() : input.Evaluate().Select(x => x.Clone())); }
/// <summary> /// Handles the signal for the class. /// </summary> /// <param name="signaler">Signaler used to signal the slot.</param> /// <param name="input">Root node for invocation.</param> public void Signal(ISignaler signaler, Node input) { signaler.Scope( "mssql.transaction", new Transaction(signaler, signaler.Peek <SqlConnectionWrapper>("mssql.connect").Connection), () => signaler.Signal("eval", input)); }
/// <summary> /// Slot implementation. /// </summary> /// <param name="signaler">Signaler that raised signal.</param> /// <param name="input">Arguments to slot.</param> public void Signal(ISignaler signaler, Node input) { var result = signaler.Peek <Node>("slots.result"); if (input.Children.Any()) { // Simple case result.AddRange(input.Children.ToList()); result.Value = input.Value; } else { // Checking if we have an expression value. if (input.Value is Expression exp) { var expResult = exp.Evaluate(input).ToList(); if (expResult.Count == 1) { result.Value = expResult.First().Value; } else if (expResult.Count > 1) { result.AddRange(expResult.Select(x => x.Clone())); } } else { // Single return value. result.Value = input.Value; } } }
/// <summary> /// Implementation of your slot. /// </summary> /// <param name="signaler">Signaler used to raise the signal.</param> /// <param name="input">Arguments to your slot.</param> /// <returns>An awaitable task.</returns> public async Task SignalAsync(ISignaler signaler, Node input) { /* * Checking if caller wants us to return the ID of the newly * create record. */ var returnId = input.Children .FirstOrDefault(x => x.Name == "return-id")?.GetEx <bool>() ?? true; // Parsing and creating SQL. var exe = returnId ? com.helpers.SqlBuilder.Parse <SqlCreateBuilder>(signaler, input) : com.helpers.SqlBuilder.Parse <SqlCreateBuilderNoId>(signaler, input); /* * Notice, if the builder doesn't return a node, we are * not supposed to actually execute the SQL, but rather only * to generate it. */ if (exe == null) { return; } // Executing SQL, now parametrized. await com.Executor.ExecuteAsync( exe, signaler.Peek <MySqlConnectionWrapper>("mysql.connect").Connection, signaler.Peek <com.Transaction>("mysql.transaction"), async (cmd) => { /* * Checking if caller wants us to return the ID of the newly * created record. */ if (returnId) { input.Value = await cmd.ExecuteScalarAsync(); } else { await cmd.ExecuteNonQueryAsync(); input.Value = null; } input.Clear(); }); }
/// <summary> /// Implementation of your slot. /// </summary> /// <param name="signaler">Signaler used to raise the signal.</param> /// <param name="input">Arguments to your slot.</param> /// <returns>An awaitable task.</returns> public async Task SignalAsync(ISignaler signaler, Node input) { /* * Figuring out if we should return ID of newly created * record to caller. */ var returnId = input.Children .FirstOrDefault(x => x.Name == "return-id")?.GetEx <bool>() ?? true; // Parsing and creating SQL. var exe = returnId ? com.helpers.SqlBuilder.Parse <SqlCreateBuilder>(signaler, input) : com.helpers.SqlBuilder.Parse <SqlCreateBuilderNoId>(signaler, input); /* * If the parsing process doesn't return a node, we're not supposed * to actually execute the SQL, but only to generate it * and parametrize it. */ if (exe == null) { return; } // Executing SQL, now parametrized. await com.Executor.ExecuteAsync( exe, signaler.Peek <SqlConnectionWrapper>("mssql.connect").Connection, signaler.Peek <com.Transaction>("mssql.transaction"), async (cmd, _) => { /* * Notice, create SQL returns last inserted ID, but only * if caller told us he wanted it to do such. */ if (returnId) { input.Value = await cmd.ExecuteScalarAsync(); } else { await cmd.ExecuteNonQueryAsync(); input.Value = null; } input.Clear(); }); }
/// <summary> /// Implementation of your slot. /// </summary> /// <param name="signaler">Signaler used to raise signal.</param> /// <param name="input">Arguments to your slot.</param> public void Signal(ISignaler signaler, Node input) { var response = signaler.Peek <HttpResponse>("http.response"); foreach (var idx in input.Children) { response.Headers[idx.Name] = idx.GetEx <string>(); } }
/// <summary> /// Implementation of your slot. /// </summary> /// <param name="signaler">Signaler used to raise the signal.</param> /// <param name="input">Arguments to your slot.</param> public void Signal(ISignaler signaler, Node input) { // Parsing and creating SQL. var exe = com.helpers.SqlBuilder.Parse <SqlDeleteBuilder>(signaler, input); if (exe == null) { return; } // Executing SQL, now parametrized. com.Executor.Execute( exe, signaler.Peek <SqlConnectionWrapper>("mssql.connect").Connection, signaler.Peek <com.Transaction>("mssql.transaction"), (cmd, _) => { input.Value = cmd.ExecuteNonQuery(); input.Clear(); }); }
/// <summary> /// Implementation of your slot. /// </summary> /// <param name="signaler">Signaler used to raise the signal.</param> /// <param name="input">Arguments to your slot.</param> /// <returns>An awaitable task.</returns> public async Task SignalAsync(ISignaler signaler, Node input) { // Parsing and creating SQL. var exe = com.helpers.SqlBuilder.Parse <SqlDeleteBuilder>(signaler, input); if (exe == null) { return; } // Executing SQL, now parametrized. await com.Executor.ExecuteAsync( exe, signaler.Peek <MySqlConnectionWrapper>("mysql.connect").Connection, signaler.Peek <com.Transaction>("mysql.transaction"), async (cmd, _) => { input.Value = await cmd.ExecuteNonQueryAsync(); input.Clear(); }); }
/// <summary> /// Implementation of signal /// </summary> /// <param name="signaler">Signaler used to signal</param> /// <param name="input">Parameters passed from signaler</param> /// <returns>An awaitable task.</returns> public async Task SignalAsync(ISignaler signaler, Node input) { SanityCheck(input); // Storing termination node, to check if we should terminate early for some reasons. var terminate = signaler.Peek <Node>("slots.result"); // Making sure we don't enter an infinite loop. int iterations = 0; // Evaluating lambda while condition is true. while (true) { // Checking if we've passed our maximum number of iterations. iterations = SanityCheckIterations(iterations); // Making sure we can reset back to original nodes after every single iteration. var old = input.Children.Select(x => x.Clone()).ToList(); // This will evaluate the condition. await signaler.SignalAsync("eval", input); // Verifying we're supposed to proceed into body of [while]. if (!input.Children.First().GetEx <bool>()) { break; } // Retrieving [.lambda] node and doing basic sanity check. var lambda = input.Children.Skip(1).First(); if (lambda.Name != ".lambda") { throw new ArgumentException("Keyword [while] requires its second child to be [.lambda]"); } // Evaluating "body" lambda of [while]. await signaler.SignalAsync("eval", lambda); // Resetting back to original nodes. input.Clear(); // Notice, cloning in case we've got another iteration, to avoid changing original nodes' values. input.AddRange(old.Select(x => x.Clone())); // Checking if execution for some reasons was terminated. if (terminate != null && (terminate.Value != null || terminate.Children.Any())) { return; } } }
/// <summary> /// Implementation of your slot. /// </summary> /// <param name="signaler">Signaler used to raise signal.</param> /// <param name="input">Arguments to your slot.</param> public void Signal(ISignaler signaler, Node input) { var request = signaler.Peek <MagicRequest>("http.request"); var key = input.GetEx <string>(); if (request.Cookies.TryGetValue(key, out string value)) { input.Value = value; } else { input.Value = null; } }
/// <summary> /// Handles the signal for the class. /// </summary> /// <param name="signaler">Signaler used to signal the slot.</param> /// <param name="input">Root node for invocation.</param> /// <returns>An awaitable task.</returns> public async Task SignalAsync(ISignaler signaler, Node input) { await Executor.ExecuteAsync( input, signaler.Peek <MySqlConnectionWrapper>("mysql.connect").Connection, signaler.Peek <Transaction>("mysql.transaction"), async (cmd) => { using (var reader = await cmd.ExecuteReaderAsync()) { while (await reader.ReadAsync()) { var rowNode = new Node(); for (var idxCol = 0; idxCol < reader.FieldCount; idxCol++) { var colNode = new Node(reader.GetName(idxCol), Converter.GetValue(reader[idxCol])); rowNode.Add(colNode); } input.Add(rowNode); } } }); }
/// <summary> /// Slot implementation. /// </summary> /// <param name="signaler">Signaler that raised signal.</param> /// <param name="input">Arguments to slot.</param> public void Signal(ISignaler signaler, Node input) { // Retrieving slot's lambda, no reasons to clone, GetSlot will clone. var filter = input.GetEx <string>(); input.Value = null; if (string.IsNullOrEmpty(filter)) { var list = Create.Slots() .Select(x => new Node("", x)) .ToList(); list.Sort((lhs, rhs) => string .Compare( lhs.Get <string>(), rhs.Get <string>(), System.StringComparison.InvariantCulture)); var whitelist = signaler.Peek <List <Node> >("whitelist"); input.AddRange(list .Where(x => whitelist == null || whitelist.Any(x2 => x2.Name == "signal" && x2.Get <string>() == x.Get <string>()))); } else { var list = Create.Slots() .Where(x => x.StartsWith(filter)) .Select(x => new Node("", x)) .ToList(); list.Sort((lhs, rhs) => string .Compare( lhs.Get <string>(), rhs.Get <string>(), System.StringComparison.InvariantCulture)); var whitelist = signaler.Peek <List <Node> >("whitelist"); input.AddRange(list.Where(x => whitelist == null || whitelist.Any(x2 => x2.Name == "signal" && x2.Get <string>() == x.Get <string>()))); } }
/* * Executes the given scope. */ async Task ExecuteAsync(ISignaler signaler, IEnumerable <Node> nodes) { // Storing termination node, to check if we should terminate early for some reasons. var terminate = signaler.Peek <Node>("slots.result"); var whitelist = signaler.Peek <List <Node> >("whitelist"); // Evaluating "scope". foreach (var idx in nodes) { if (whitelist != null && !whitelist.Any(x => x.Name == idx.Name)) { throw new HyperlambdaException($"Slot [{idx.Name}] doesn't exist in currrent scope"); } // Invoking signal. await signaler.SignalAsync(idx.Name, idx); // Checking if execution for some reasons was terminated. if (terminate != null && (terminate.Value != null || terminate.Children.Any())) { return; } } }
/// <summary> /// Implementation of your slot. /// </summary> /// <param name="signaler">Signaler used to raise the signal.</param> /// <param name="input">Arguments to your slot.</param> public void Signal(ISignaler signaler, Node input) { var connection = signaler.Peek <SqlConnectionWrapper>("mssql.connect").Connection; foreach (var idxBatch in GetBatches(input.GetEx <string>())) { using (var cmd = connection.CreateCommand()) { cmd.CommandText = idxBatch; var result = cmd.ExecuteNonQuery(); var resultNode = new Node(); resultNode.Add(new Node("Records affected", result)); input.Add(resultNode); } } input.Value = null; }
Node GetLambda(ISignaler signaler, Node input) { var name = input.GetEx <string>(); var whitelist = signaler.Peek <List <Node> >("whitelist"); if (whitelist != null && !whitelist.Any(x => x.Name == "signal" && x.Get <string>() == name)) { throw new ArgumentException($"Dynamic slot [{name}] does not exist in scope"); } var lambda = Create.GetSlot(name); // Preparing arguments, if there are any. if (input.Children.Any()) { lambda.Insert(0, new Node(".arguments", null, input.Children.ToList())); } return(lambda); }
/* * Same as above, only async version. */ static internal async Task <bool> SignalAsync(ISignaler signaler, Node input, bool condition) { var whitelist = signaler.Peek <List <Node> >("whitelist"); foreach (var idx in input.Children) { if (idx.Name.Any() && idx.Name.FirstOrDefault() != '.') { if (whitelist != null && !whitelist.Any(x => x.Name == idx.Name)) { throw new HyperlambdaException($"Slot [{idx.Name}] doesn't exist in currrent scope"); } await signaler.SignalAsync(idx.Name, idx); } if (idx.GetEx <bool>() == condition) { return(true); } } return(false); }
/// <summary> /// Handles the signal for the class. /// </summary> /// <param name="signaler">Signaler used to signal the slot.</param> /// <param name="input">Root node for invocation.</param> public void Signal(ISignaler signaler, Node input) { signaler.Peek <Transaction>("mysql.transaction").Commit(); }
public void Signal(ISignaler signaler, Node input) { input.Value = signaler.Peek <string>("value"); }
/// <summary> /// Implementation of your slot. /// </summary> /// <param name="signaler">Signaler used to raise signal.</param> /// <param name="input">Arguments to your slot.</param> public void Signal(ISignaler signaler, Node input) { var request = signaler.Peek <MagicRequest>("http.request"); input.AddRange(request.Headers.Select(x => new Node(x.Key, x.Value))); }
public void Signal(ISignaler signaler, Node input) { input.Value = signaler.Peek <object>("value.dispose").ToString(); }
/// <summary> /// Implementation of signal /// </summary> /// <param name="signaler">Signaler used to signal</param> /// <param name="input">Parameters passed from signaler</param> public void Signal(ISignaler signaler, Node input) { input.Value = signaler.Peek <object>("dynamic." + input.GetEx <string>()); }