static void MakeParameters(
string query,
DateTime rangeStartUtc,
DateTime?rangeEndUtc,
SignalExpressionPart signal,
SignalEntity unsavedSignal,
TimeSpan?timeout,
out SignalEntity body,
out Dictionary <string, object> parameters)
{
parameters = new Dictionary <string, object>
{
{ "q", query },
{ nameof(rangeStartUtc), rangeStartUtc }
};
if (rangeEndUtc != null)
{
parameters.Add(nameof(rangeEndUtc), rangeEndUtc.Value);
}
if (signal != null)
{
parameters.Add(nameof(signal), signal.ToString());
}
if (timeout != null)
{
parameters.Add("timeoutMS", timeout.Value.TotalMilliseconds.ToString("0"));
}
body = unsavedSignal ?? new SignalEntity();
}
public async Task <ResultSetPart> DeleteInSignalAsync(
SignalEntity signal = null,
string[] intersectIds = null,
string filter = null,
DateTime?fromDateUtc = null,
DateTime?toDateUtc = null)
{
var parameters = new Dictionary <string, object>();
if (intersectIds != null && intersectIds.Length > 0)
{
parameters.Add("intersectIds", string.Join(",", intersectIds));
}
if (filter != null)
{
parameters.Add("filter", filter);
}
if (fromDateUtc != null)
{
parameters.Add("fromDateUtc", fromDateUtc.Value);
}
if (toDateUtc != null)
{
parameters.Add("toDateUtc", toDateUtc.Value);
}
var body = signal ?? new SignalEntity();
return(await GroupPostAsync <SignalEntity, ResultSetPart>("DeleteInSignal", body, parameters).ConfigureAwait(false));
}
/// <summary>
/// Delete matching events from the stream.
/// </summary>
/// <param name="unsavedSignal">A constructed signal that may not appear on the server, for example, a <see cref="SignalEntity"/> that has been
/// created but not saved, a signal from another server, or the modified representation of an entity already persisted.</param>
/// <param name="signal">If provided, a signal expression describing the set of events that will be filtered for the result.</param>
/// <param name="filter">A strict Seq filter expression to match (text expressions must be in double quotes). To
/// convert a "fuzzy" filter into a strict one the way the Seq UI does, use connection.Expressions.ToStrictAsync().</param>
/// <param name="fromDateUtc">Earliest (inclusive) date/time from which to delete.</param>
/// <param name="toDateUtc">Latest (exclusive) date/time from which to delete.</param>
/// <returns>A result carrying the count of events deleted.</returns>
public async Task <DeleteResultPart> DeleteInSignalAsync(
SignalEntity unsavedSignal = null,
SignalExpressionPart signal = null,
string filter = null,
DateTime?fromDateUtc = null,
DateTime?toDateUtc = null)
{
var parameters = new Dictionary <string, object>();
if (signal != null)
{
parameters.Add("signal", signal.ToString());
}
if (filter != null)
{
parameters.Add("filter", filter);
}
if (fromDateUtc != null)
{
parameters.Add("fromDateUtc", fromDateUtc.Value);
}
if (toDateUtc != null)
{
parameters.Add("toDateUtc", toDateUtc.Value);
}
var body = unsavedSignal ?? new SignalEntity();
return(await GroupDeleteAsync <SignalEntity, DeleteResultPart>("DeleteInSignal", body, parameters).ConfigureAwait(false));
}
/// <summary>
/// Retrieve a list of events that match a set of conditions. The complete result is buffered into memory,
/// so if a large result set is expected, use InSignalAsync() and lastReadEventId to page the results.
/// </summary>
/// <param name="unsavedSignal">A constructed signal that may not appear on the server, for example, a <see cref="SignalEntity"/> that has been
/// created but not saved, a signal from another server, or the modified representation of an entity already persisted.</param>
/// <param name="signal">If provided, a signal expression describing the set of events that will be filtered for the result.</param>
/// <param name="filter">A strict Seq filter expression to match (text expressions must be in double quotes). To
/// convert a "fuzzy" filter into a strict one the way the Seq UI does, use connection.Expressions.ToStrictAsync().</param>
/// <param name="count">The number of events to retrieve. If not specified will default to 30.</param>
/// <param name="startAtId">An event id from which to start searching (inclusively).</param>
/// <param name="afterId">An event id to search after (exclusively).</param>
/// <param name="render">If specified, the event's message template and properties will be rendered into its RenderedMessage property.</param>
/// <param name="fromDateUtc">Earliest (inclusive) date/time from which to search.</param>
/// <param name="toDateUtc">Latest (exclusive) date/time from which to search.</param>
/// <param name="shortCircuitAfter">If specified, the number of events after the first match to keep searching before a partial
/// result set is returned. Used to improve responsiveness when the result is displayed in a user interface, not typically used in
/// batch processing scenarios.</param>
/// <param name="permalinkId">If the request is for a permalinked event, specifying the id of the permalink here will
/// allow events that have otherwise been deleted to be found. The special value `"unknown"` provides backwards compatibility
/// with versions prior to 5.0, which did not mark permalinks explicitly.</param>
/// <param name="cancellationToken">Token through which the operation can be cancelled.</param>
/// <returns>The complete list of events, ordered from least to most recent.</returns>
public async Task <ResultSetPart> InSignalAsync(
SignalEntity unsavedSignal = null,
SignalExpressionPart signal = null,
string filter = null,
int count = 30,
string startAtId = null,
string afterId = null,
bool render = false,
DateTime?fromDateUtc = null,
DateTime?toDateUtc = null,
int?shortCircuitAfter = null,
string permalinkId = null,
CancellationToken cancellationToken = default)
{
var parameters = new Dictionary <string, object> {
{ "count", count }
};
if (signal != null)
{
parameters.Add("signal", signal.ToString());
}
if (filter != null)
{
parameters.Add("filter", filter);
}
if (startAtId != null)
{
parameters.Add("startAtId", startAtId);
}
if (afterId != null)
{
parameters.Add("afterId", afterId);
}
if (render)
{
parameters.Add("render", true);
}
if (fromDateUtc != null)
{
parameters.Add("fromDateUtc", fromDateUtc.Value);
}
if (toDateUtc != null)
{
parameters.Add("toDateUtc", toDateUtc.Value);
}
if (shortCircuitAfter != null)
{
parameters.Add("shortCircuitAfter", shortCircuitAfter.Value);
}
if (permalinkId != null)
{
parameters.Add("permalinkId", permalinkId);
}
var body = unsavedSignal ?? new SignalEntity();
return(await GroupPostAsync <SignalEntity, ResultSetPart>("InSignal", body, parameters, cancellationToken).ConfigureAwait(false));
}
public static async Task CreateSignal(string signalName)
{
SignalEntity signal = await _seqConnection.Signals.TemplateAsync();
signal.Title = signalName;
if (applyChanges)
{
await _seqConnection.Signals.AddAsync(signal);
}
}
/// <summary>
/// Execute an SQL query and retrieve the result set as a structured <see cref="QueryResultPart"/>.
/// </summary>
/// <param name="query">The query to execute.</param>
/// <param name="rangeStartUtc">The earliest timestamp from which to include events in the query result.</param>
/// <param name="rangeEndUtc">The exclusive latest timestamp to which events are included in the query result. The default is the current time.</param>
/// <param name="signal">A signal expression over which the query will be executed.</param>
/// <param name="unsavedSignal">A constructed signal that may not appear on the server, for example, a <see cref="SignalEntity"/> that has been
/// created but not saved, a signal from another server, or the modified representation of an entity already persisted.</param>
/// <param name="timeout">The query timeout; if not specified, the query will run until completion.</param>
/// <returns>A structured result set.</returns>
public async Task <QueryResultPart> QueryAsync(
string query,
DateTime rangeStartUtc,
DateTime?rangeEndUtc = null,
SignalExpressionPart signal = null,
SignalEntity unsavedSignal = null,
TimeSpan?timeout = null)
{
MakeParameters(query, rangeStartUtc, rangeEndUtc, signal, unsavedSignal, timeout, out var body, out var parameters);
return(await GroupPostAsync <SignalEntity, QueryResultPart>("Query", body, parameters).ConfigureAwait(false));
}
/// <summary>
/// Execute an SQL query and retrieve the result set as a structured <see cref="QueryResultPart"/>.
/// </summary>
/// <param name="query">The query to execute.</param>
/// <param name="rangeStartUtc">The earliest timestamp from which to include events in the query result.</param>
/// <param name="rangeEndUtc">The exclusive latest timestamp to which events are included in the query result. The default is the current time.</param>
/// <param name="signal">A signal expression over which the query will be executed.</param>
/// <param name="unsavedSignal">A constructed signal that may not appear on the server, for example, a <see cref="SignalEntity"/> that has been
/// created but not saved, a signal from another server, or the modified representation of an entity already persisted.</param>
/// <param name="timeout">The query timeout; if not specified, the query will run until completion.</param>
/// <returns>A CSV result set.</returns>
public async Task <string> QueryCsvAsync(
string query,
DateTime rangeStartUtc,
DateTime?rangeEndUtc = null,
SignalExpressionPart signal = null,
SignalEntity unsavedSignal = null,
TimeSpan?timeout = null)
{
MakeParameters(query, rangeStartUtc, rangeEndUtc, signal, unsavedSignal, timeout, out var body, out var parameters);
parameters.Add("format", "text/csv");
return(await GroupPostReadStringAsync("Query", body, parameters).ConfigureAwait(false));
}
public async Task <ResultSetPart> InSignalAsync(
SignalEntity signal = null,
string[] intersectIds = null,
string filter = null,
int count = 30,
string startAtId = null,
string afterId = null,
bool render = false,
DateTime?fromDateUtc = null,
DateTime?toDateUtc = null,
int?shortCircuitAfter = null)
{
var parameters = new Dictionary <string, object> {
{ "count", count }
};
if (intersectIds != null && intersectIds.Length > 0)
{
parameters.Add("intersectIds", string.Join(",", intersectIds));
}
if (filter != null)
{
parameters.Add("filter", filter);
}
if (startAtId != null)
{
parameters.Add("startAtId", startAtId);
}
if (afterId != null)
{
parameters.Add("afterId", afterId);
}
if (render)
{
parameters.Add("render", true);
}
if (fromDateUtc != null)
{
parameters.Add("fromDateUtc", fromDateUtc.Value);
}
if (toDateUtc != null)
{
parameters.Add("toDateUtc", toDateUtc.Value);
}
if (shortCircuitAfter != null)
{
parameters.Add("shortCircuitAfter", shortCircuitAfter.Value);
}
var body = signal ?? new SignalEntity();
return(await GroupPostAsync <SignalEntity, ResultSetPart>("InSignal", body, parameters).ConfigureAwait(false));
}
public async Task <QueryResultPart> QueryAsync(
string query,
DateTime rangeStartUtc,
DateTime?rangeEndUtc = null,
SignalEntity signal = null,
string[] intersectIds = null)
{
SignalEntity body;
Dictionary <string, object> parameters;
MakeParameters(query, rangeStartUtc, rangeEndUtc, signal, intersectIds, out body, out parameters);
return(await GroupPostAsync <SignalEntity, QueryResultPart>("Query", body, parameters).ConfigureAwait(false));
}
public async Task <string> QueryCsvAsync(
string query,
DateTime rangeStartUtc,
DateTime?rangeEndUtc = null,
SignalEntity signal = null,
string[] intersectIds = null)
{
SignalEntity body;
Dictionary <string, object> parameters;
MakeParameters(query, rangeStartUtc, rangeEndUtc, signal, intersectIds, out body, out parameters);
parameters.Add("format", "text/csv");
return(await GroupPostReadStringAsync("Query", body, parameters).ConfigureAwait(false));
}
static async Task <string> QueryAsync(
SeqConnection connection,
string query,
DateTime?rangeStartUtc,
DateTime?rangeEndUtc,
SignalExpressionPart signalExpression,
int?timeoutMS,
string format = null)
{
// From dates should no longer be mandatory for QueryCsvAsync (issue raised)
var parameters = new Dictionary <string, object>
{
["q"] = query
};
if (format != null)
{
parameters.Add(nameof(format), format);
}
if (rangeStartUtc.HasValue)
{
parameters.Add(nameof(rangeEndUtc), rangeStartUtc.Value);
}
if (rangeEndUtc.HasValue)
{
parameters.Add(nameof(rangeEndUtc), rangeEndUtc.Value);
}
if (signalExpression != null)
{
parameters.Add("signal", signalExpression.ToString());
}
if (timeoutMS.HasValue)
{
parameters.Add("timeoutMS", timeoutMS.Value.ToString("0"));
}
var body = new SignalEntity();
var drg = await connection.LoadResourceGroupAsync("Data");
return(await connection.Client.PostReadStringAsync(drg, "Query", body, parameters));
}
static void MakeParameters(string query, DateTime rangeStartUtc, DateTime?rangeEndUtc, SignalEntity signal,
string[] intersectIds, out SignalEntity body, out Dictionary <string, object> parameters)
{
parameters = new Dictionary <string, object>
{
{ "q", query },
{ nameof(rangeStartUtc), rangeStartUtc }
};
if (rangeEndUtc != null)
{
parameters.Add(nameof(rangeEndUtc), rangeEndUtc.Value);
}
if (intersectIds != null && intersectIds.Length > 0)
{
parameters.Add(nameof(intersectIds), string.Join(",", intersectIds));
}
body = signal ?? new SignalEntity();
}
/// <summary>
/// Remove an existing signal.
/// </summary>
/// <param name="entity">The signal to remove.</param>
/// <param name="cancellationToken">A <see cref="CancellationToken"/> allowing the operation to be canceled.</param>
/// <returns>A task indicating completion.</returns>
public async Task RemoveAsync(SignalEntity entity, CancellationToken cancellationToken = default)
{
await Client.DeleteAsync(entity, "Self", entity, cancellationToken : cancellationToken).ConfigureAwait(false);
}
public async Task <SignalEntity> AddAsync(SignalEntity entity)
{
return(await Client.PostAsync <SignalEntity, SignalEntity>(entity, "Create", entity).ConfigureAwait(false));
}
public static async Task DeleteSignal()
{
SignalEntity signal = await _seqConnection.Signals.FindAsync("signal-XXXX");
await _seqConnection.Signals.RemoveAsync(signal);
}
public async Task <SignalEntity> AddAsync(SignalEntity entity)
{
return(await GroupCreateAsync <SignalEntity, SignalEntity>(entity).ConfigureAwait(false));
}
public async Task RemoveAsync(SignalEntity entity)
{
await Client.DeleteAsync(entity, "Self", entity).ConfigureAwait(false);
}
public async Task UpdateAsync(SignalEntity entity)
{
await Client.PutAsync(entity, "Self", entity).ConfigureAwait(false);
}
/// <summary>
/// Add a new signal.
/// </summary>
/// <param name="entity">The signal to add.</param>
/// <param name="cancellationToken">A <see cref="CancellationToken"/> allowing the operation to be canceled.</param>
/// <returns>The signal, with server-allocated properties such as <see cref="Entity.Id"/> initialized.</returns>
public async Task <SignalEntity> AddAsync(SignalEntity entity, CancellationToken cancellationToken = default)
{
return(await GroupCreateAsync <SignalEntity, SignalEntity>(entity, cancellationToken : cancellationToken).ConfigureAwait(false));
}
