/// <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>());
}