/// <summary>
/// Run a query returning a single value.
/// </summary>
/// <param name="queryType">Type of query to run.</param>
/// <param name="collection">Name of event collection to query.</param>
/// <param name="targetProperty">Name of property to analyse.</param>
/// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param>
/// <param name="filters">Filter to narrow down the events used in analysis. Optional, may be null.</param>
/// <param name="timezone">The timezone to use when specifying a relative timeframe. Optional, may be blank.</param>
/// <returns></returns>
public async Task <string> QueryAsync(QueryType queryType, string collection, string targetProperty,
IQueryTimeframe timeframe = null, IEnumerable <QueryFilter> filters = null, string timezone = "")
{
return
(await
Queries.Metric(queryType, collection, targetProperty, timeframe, filters, timezone)
.ConfigureAwait(false));
}
/// <summary>
/// Run multiple types of analysis over the same data.
/// Each item represents one interval.
/// </summary>
/// <param name="collection">Name of event collection to query.</param>
/// <param name="analysisParams">Defines the multiple types of analyses to perform.</param>
/// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param>
/// <param name="interval">The block size for partitioning the specified timeframe. Optional, may be null.</param>
/// <param name="filters">Filters to narrow down the events used in analysis. Optional, may be null.</param>
/// <param name="timezone">The timezone to use when specifying a relative timeframe. Optional, may be blank.</param>
/// <returns></returns>
public async Task <IEnumerable <QueryIntervalValue <IDictionary <string, string> > > > QueryMultiAnalysisIntervalAsync(
string collection, IEnumerable <MultiAnalysisParam> analysisParams, IQueryTimeframe timeframe = null,
QueryInterval interval = null, IEnumerable <QueryFilter> filters = null, string timezone = "")
{
return
(await
Queries.MultiAnalysis(collection, analysisParams, timeframe, interval, filters, timezone)
.ConfigureAwait(false));
}
QueryMultiAnalysisIntervalGroupAsync(string collection, IEnumerable <MultiAnalysisParam> analysisParams,
IQueryTimeframe timeframe = null, QueryInterval interval = null, IEnumerable <QueryFilter> filters = null,
string groupBy = "", string timezone = "")
{
return
(await
Queries.MultiAnalysis(collection, analysisParams, timeframe, interval, filters, groupBy, timezone)
.ConfigureAwait(false));
}
/// <summary>
/// Funnels count relevant events in succession. See API documentation for details.
/// </summary>
/// <param name="steps">Analysis steps for funnel.</param>
/// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param>
/// <param name="timezone">The timezone to use when specifying a relative timeframe. Optional, may be blank.</param>
/// <returns></returns>
public FunnelResult QueryFunnel(IEnumerable <FunnelStep> steps,
IQueryTimeframe timeframe = null, string timezone = "")
{
try
{
return(QueryFunnelAsync(steps, timeframe, timezone).Result);
}
catch (AggregateException ex)
{
throw ex.TryUnwrap();
}
}
/// <summary>
/// Extract full-form event data with all property values.
/// </summary>
/// <param name="collection">Name of event collection to query.</param>
/// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param>
/// <param name="filters">Filter to narrow down the events used in analysis. Optional, may be null.</param>
/// <param name="latest">Request up to 100 of the most recent events added to a given collection.</param>
/// <param name="email">If specified, email will be sent when the data is ready for download. Otherwise, it will be returned directly.</param>
/// <returns></returns>
public IEnumerable <dynamic> QueryExtractResource(string collection, IQueryTimeframe timeframe = null,
IEnumerable <QueryFilter> filters = null, int latest = 0, string email = "")
{
try
{
return(QueryExtractResourceAsync(collection, timeframe, filters, latest, email).Result);
}
catch (AggregateException ex)
{
throw ex.TryUnwrap();
}
}
/// <summary>
/// Return a single value.
/// </summary>
/// <param name="queryType">Type of query to run.</param>
/// <param name="collection">Name of event collection to query.</param>
/// <param name="targetProperty">Name of property to analyse.</param>
/// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param>
/// <param name="filters">Filter to narrow down the events used in analysis. Optional, may be null.</param>
/// <param name="timezone">The timezone to use when specifying a relative timeframe. Optional, may be blank.</param>
/// <returns></returns>
public string Query(QueryType queryType, string collection, string targetProperty,
IQueryTimeframe timeframe = null, IEnumerable <QueryFilter> filters = null, string timezone = "")
{
try
{
return(QueryAsync(queryType, collection, targetProperty, timeframe, filters, timezone).Result);
}
catch (AggregateException ex)
{
throw ex.TryUnwrap();
}
}
public async Task <IEnumerable <dynamic> > Extract(string collection, IQueryTimeframe timeframe = null, IEnumerable <QueryFilter> filters = null, int latest = 0, string email = "")
{
var parms = new Dictionary <string, string>();
parms.Add(KeenConstants.QueryParmEventCollection, collection);
parms.Add(KeenConstants.QueryParmTimeframe, timeframe.ToSafeString());
parms.Add(KeenConstants.QueryParmFilters, filters == null ? "" : JArray.FromObject(filters).ToString());
parms.Add(KeenConstants.QueryParmEmail, email);
parms.Add(KeenConstants.QueryParmLatest, latest > 0 ? latest.ToString() : "");
var reply = await KeenWebApiRequest(KeenConstants.QueryExtraction, parms).ConfigureAwait(false);
return(from i in reply.Value <JArray>("result") select(dynamic) i);
}
/// <summary>
/// Run multiple types of analysis over the same data.
/// Each item represents one interval.
/// </summary>
/// <param name="collection">Name of event collection to query.</param>
/// <param name="analysisParams">Defines the multiple types of analyses to perform.</param>
/// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param>
/// <param name="interval">The block size for partitioning the specified timeframe. Optional, may be null.</param>
/// <param name="filters">Filters to narrow down the events used in analysis. Optional, may be null.</param>
/// <param name="timezone">The timezone to use when specifying a relative timeframe. Optional, may be blank.</param>
/// <returns></returns>
public IEnumerable <QueryIntervalValue <IDictionary <string, string> > > QueryMultiAnalysisInterval(
string collection, IEnumerable <MultiAnalysisParam> analysisParams, IQueryTimeframe timeframe = null,
QueryInterval interval = null, IEnumerable <QueryFilter> filters = null, string timezone = "")
{
try
{
return
(QueryMultiAnalysisIntervalAsync(collection, analysisParams, timeframe, interval, filters, timezone)
.Result);
}
catch (AggregateException ex)
{
throw ex.TryUnwrap();
}
}
QueryMultiAnalysisIntervalGroup(string collection, IEnumerable <MultiAnalysisParam> analysisParams,
IQueryTimeframe timeframe = null, QueryInterval interval = null, IEnumerable <QueryFilter> filters = null,
string groupBy = "", string timezone = "")
{
try
{
return
(QueryMultiAnalysisIntervalGroupAsync(collection, analysisParams, timeframe, interval, filters,
groupBy, timezone).Result);
}
catch (AggregateException ex)
{
throw ex.TryUnwrap();
}
}
public async Task <FunnelResult> Funnel(IEnumerable <FunnelStep> steps,
IQueryTimeframe timeframe = null, string timezone = "")
{
var stepsJson = JArray.FromObject(steps).ToString(Formatting.None);
var parms = new Dictionary <string, string>();
if (null != timeframe)
{
parms.Add(KeenConstants.QueryParmTimeframe, timeframe.ToString());
}
parms.Add(KeenConstants.QueryParmTimezone, timezone);
parms.Add(KeenConstants.QueryParmSteps, stepsJson);
var reply = await KeenWebApiRequest(KeenConstants.QueryFunnel, parms).ConfigureAwait(false);
var o = reply.ToObject <FunnelResult>();
return(o);
}
public async Task <IEnumerable <QueryIntervalValue <IEnumerable <QueryGroupValue <IDictionary <string, string> > > > > > MultiAnalysis(string collection, IEnumerable <MultiAnalysisParam> analysisParams, IQueryTimeframe timeframe = null, QueryInterval interval = null, IEnumerable <QueryFilter> filters = null, string groupby = "", string timezone = "")
{
var parms = new Dictionary <string, string>();
parms.Add(KeenConstants.QueryParmEventCollection, collection);
parms.Add(KeenConstants.QueryParmTimeframe, timeframe.ToSafeString());
parms.Add(KeenConstants.QueryParmInterval, interval.ToSafeString());
parms.Add(KeenConstants.QueryParmTimezone, timezone);
parms.Add(KeenConstants.QueryParmGroupBy, groupby);
parms.Add(KeenConstants.QueryParmFilters, filters == null ? "" : JArray.FromObject(filters).ToString());
parms.Add(KeenConstants.QueryParmAnalyses, SerializeMultiAnalysisQueryParameter(analysisParams));
var reply = await KeenWebApiRequest(KeenConstants.QueryMultiAnalysis, parms).ConfigureAwait(false);
var result = new List <QueryIntervalValue <IEnumerable <QueryGroupValue <IDictionary <string, string> > > > >();
foreach (JObject i in reply.Value <JArray>("result"))
{
var qgl = new List <QueryGroupValue <IDictionary <string, string> > >();
foreach (JObject o in i.Value <JArray>("value"))
{
var d = new Dictionary <string, string>();
string grpVal = "";
foreach (JProperty p in o.Values <JProperty>())
{
if (p.Name == groupby)
{
grpVal = (string)p.Value;
}
else
{
d.Add(p.Name, (string)p.Value);
}
}
qgl.Add(new QueryGroupValue <IDictionary <string, string> >(d, grpVal));
}
var t = i.Value <JObject>("timeframe");
var qv = new QueryIntervalValue <IEnumerable <QueryGroupValue <IDictionary <string, string> > > >(qgl, t.Value <DateTime>("start"), t.Value <DateTime>("end"));
result.Add(qv);
}
return(result);
}
public async Task <IDictionary <string, string> > MultiAnalysis(string collection, IEnumerable <MultiAnalysisParam> analysisParams, IQueryTimeframe timeframe = null, IEnumerable <QueryFilter> filters = null, string timezone = "")
{
var parms = new Dictionary <string, string>();
parms.Add(KeenConstants.QueryParmEventCollection, collection);
parms.Add(KeenConstants.QueryParmTimeframe, timeframe.ToSafeString());
parms.Add(KeenConstants.QueryParmTimezone, timezone);
parms.Add(KeenConstants.QueryParmFilters, filters == null ? "" : JArray.FromObject(filters).ToString());
parms.Add(KeenConstants.QueryParmAnalyses, SerializeMultiAnalysisQueryParameter(analysisParams));
var reply = await KeenWebApiRequest(KeenConstants.QueryMultiAnalysis, parms).ConfigureAwait(false);
var result = new Dictionary <string, string>();
foreach (JProperty i in reply.Value <JObject>("result").Children())
{
result.Add(i.Name, (string)i.Value);
}
return(result);
}
/// <summary>
/// Returns items collected by time interval and group.
/// </summary>
/// <param name="queryType">Type of query to run.</param>
/// <param name="collection">Name of event collection to query.</param>
/// <param name="targetProperty">Name of property to analyse.</param>
/// <param name="groupBy">Name of field by which to group results.</param>
/// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param>
/// <param name="interval">The block size for partitioning the specified timeframe. Optional, may be null.</param>
/// <param name="filters">Filters to narrow down the events used in analysis. Optional, may be null.</param>
/// <param name="timezone">The timezone to use when specifying a relative timeframe. Optional, may be blank.</param>
/// <returns></returns>
public IEnumerable <QueryIntervalValue <IEnumerable <QueryGroupValue <string> > > > QueryIntervalGroup(
QueryType queryType, string collection, string targetProperty, string groupBy, IQueryTimeframe timeframe,
QueryInterval interval, IEnumerable <QueryFilter> filters = null, string timezone = "")
{
try
{
return
(QueryIntervalGroupAsync(queryType, collection, targetProperty, groupBy, timeframe, interval, filters,
timezone).Result);
}
catch (AggregateException ex)
{
throw ex.TryUnwrap();
}
}
public async Task <IEnumerable <QueryIntervalValue <IEnumerable <QueryGroupValue <string> > > > > Metric(QueryType queryType, string collection, string targetProperty, string groupby, IQueryTimeframe timeframe, QueryInterval interval, IEnumerable <QueryFilter> filters = null, string timezone = "")
{
if (queryType == null)
{
throw new ArgumentNullException("queryType");
}
if (string.IsNullOrWhiteSpace(collection))
{
throw new ArgumentNullException("collection");
}
if (string.IsNullOrWhiteSpace(targetProperty) && (queryType != QueryType.Count()))
{
throw new ArgumentNullException("targetProperty");
}
if (null == timeframe)
{
throw new ArgumentException("timeframe", "Timeframe must be specified for a series query.");
}
if (null == interval)
{
throw new ArgumentNullException("interval", "interval must be specified for a series query");
}
if (string.IsNullOrWhiteSpace(groupby))
{
throw new ArgumentNullException("groupby", "groupby field name must be specified for a goupby query");
}
var parms = new Dictionary <string, string>();
parms.Add(KeenConstants.QueryParmEventCollection, collection);
parms.Add(KeenConstants.QueryParmTargetProperty, targetProperty);
parms.Add(KeenConstants.QueryParmGroupBy, groupby);
parms.Add(KeenConstants.QueryParmTimeframe, timeframe.ToSafeString());
parms.Add(KeenConstants.QueryParmInterval, interval.ToSafeString());
parms.Add(KeenConstants.QueryParmTimezone, timezone);
parms.Add(KeenConstants.QueryParmFilters, filters == null ? "" : JArray.FromObject(filters).ToString());
var reply = await KeenWebApiRequest(queryType.ToString(), parms).ConfigureAwait(false);
IEnumerable <QueryIntervalValue <IEnumerable <QueryGroupValue <string> > > > result;
if (queryType == QueryType.SelectUnique())
{
// This is to support SelectUnique which is the only query type with a list-type result.
result = from i in reply.Value <JArray>("result")
let v = (from r in i.Value <JArray>("value")
let c = string.Join(",", r.Value <JArray>("result").Values <string>())
let g = r.Value <string>(groupby)
select new QueryGroupValue <string>(c, g))
let t = i.Value <JObject>("timeframe")
select new QueryIntervalValue <IEnumerable <QueryGroupValue <string> > >(v, t.Value <DateTime>("start"), t.Value <DateTime>("end"));
}
else
{
result = from i in reply.Value <JArray>("result")
let v = (from r in i.Value <JArray>("value")
let c = r.Value <string>("result")
let g = r.Value <string>(groupby)
select new QueryGroupValue <string>(c, g))
let t = i.Value <JObject>("timeframe")
select new QueryIntervalValue <IEnumerable <QueryGroupValue <string> > >(v, t.Value <DateTime>("start"), t.Value <DateTime>("end"));
}
return(result);
}
public async Task <string> Metric(QueryType queryType, string collection, string targetProperty, IQueryTimeframe timeframe = null, IEnumerable <QueryFilter> filters = null, string timezone = "")
{
if (queryType == null)
{
throw new ArgumentNullException("queryType");
}
if (string.IsNullOrWhiteSpace(collection))
{
throw new ArgumentNullException("collection");
}
if (string.IsNullOrWhiteSpace(targetProperty) && (queryType != QueryType.Count()))
{
throw new ArgumentNullException("targetProperty");
}
var parms = new Dictionary <string, string>();
parms.Add(KeenConstants.QueryParmEventCollection, collection);
parms.Add(KeenConstants.QueryParmTargetProperty, targetProperty);
parms.Add(KeenConstants.QueryParmTimeframe, timeframe.ToSafeString());
parms.Add(KeenConstants.QueryParmTimezone, timezone);
parms.Add(KeenConstants.QueryParmFilters, filters == null ? "" : JArray.FromObject(filters).ToString());
var reply = await KeenWebApiRequest(queryType.ToString(), parms).ConfigureAwait(false);
string result;
if (queryType == QueryType.SelectUnique())
{
// This is to support SelectUnique which is the only query type with a list-type result.
result = string.Join(",", (reply.Value <JArray>("result").Values <string>()));
}
else
{
result = reply.Value <string>("result");
}
return(result);
}
public async Task <IEnumerable <QueryIntervalValue <IEnumerable <QueryGroupValue <IDictionary <string, string> > > > > > MultiAnalysis(string collection, IEnumerable <MultiAnalysisParam> analysisParams, IQueryTimeframe timeframe = null, QueryInterval interval = null, IEnumerable <QueryFilter> filters = null, string groupby = "", string timezone = "")
{
var jObs = analysisParams.Select(x => new JProperty(x.Label, JObject.FromObject(new { analysis_type = x.Analysis, target_property = x.TargetProperty })));
var parmsJson = JsonConvert.SerializeObject(new JObject(jObs), Formatting.None, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
});
var parms = new Dictionary <string, string>();
parms.Add(KeenConstants.QueryParmEventCollection, collection);
parms.Add(KeenConstants.QueryParmTimeframe, timeframe.ToSafeString());
parms.Add(KeenConstants.QueryParmInterval, interval.ToSafeString());
parms.Add(KeenConstants.QueryParmTimezone, timezone);
parms.Add(KeenConstants.QueryParmGroupBy, groupby);
parms.Add(KeenConstants.QueryParmFilters, filters == null ? "" : JArray.FromObject(filters).ToString());
parms.Add(KeenConstants.QueryParmAnalyses, parmsJson);
var reply = await KeenWebApiRequest(KeenConstants.QueryMultiAnalysis, parms).ConfigureAwait(false);
var result = new List <QueryIntervalValue <IEnumerable <QueryGroupValue <IDictionary <string, string> > > > >();
foreach (JObject i in reply.Value <JArray>("result"))
{
var qgl = new List <QueryGroupValue <IDictionary <string, string> > >();
foreach (JObject o in i.Value <JArray>("value"))
{
var d = new Dictionary <string, string>();
string grpVal = "";
foreach (JProperty p in o.Values <JProperty>())
{
if (p.Name == groupby)
{
grpVal = (string)p.Value;
}
else
{
d.Add(p.Name, (string)p.Value);
}
}
qgl.Add(new QueryGroupValue <IDictionary <string, string> >(d, grpVal));
}
var t = i.Value <JObject>("timeframe");
var qv = new QueryIntervalValue <IEnumerable <QueryGroupValue <IDictionary <string, string> > > >(qgl, t.Value <DateTime>("start"), t.Value <DateTime>("end"));
result.Add(qv);
}
return(result);
}
public async Task <IDictionary <string, string> > MultiAnalysis(string collection, IEnumerable <MultiAnalysisParam> analysisParams, IQueryTimeframe timeframe = null, IEnumerable <QueryFilter> filters = null, string timezone = "")
{
var jObs = analysisParams.Select(x =>
new JProperty(x.Label, JObject.FromObject(new { analysis_type = x.Analysis, target_property = x.TargetProperty })));
var parmsJson = JsonConvert.SerializeObject(new JObject(jObs), Formatting.None, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
});
var parms = new Dictionary <string, string>();
parms.Add(KeenConstants.QueryParmEventCollection, collection);
parms.Add(KeenConstants.QueryParmTimeframe, timeframe.ToSafeString());
parms.Add(KeenConstants.QueryParmTimezone, timezone);
parms.Add(KeenConstants.QueryParmFilters, filters == null ? "" : JArray.FromObject(filters).ToString());
parms.Add(KeenConstants.QueryParmAnalyses, parmsJson);
var reply = await KeenWebApiRequest(KeenConstants.QueryMultiAnalysis, parms).ConfigureAwait(false);
var result = new Dictionary <string, string>();
foreach (JProperty i in reply.Value <JObject>("result").Children())
{
result.Add(i.Name, (string)i.Value);
}
return(result);
}
/// <summary>
/// Returns items collected by time interval and group.
/// </summary>
/// <param name="queryType">Type of query to run.</param>
/// <param name="collection">Name of event collection to query.</param>
/// <param name="targetProperty">Name of property to analyse.</param>
/// <param name="groupBy">Name of field by which to group results.</param>
/// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param>
/// <param name="interval">The block size for partitioning the specified timeframe. Optional, may be null.</param>
/// <param name="filters">Filters to narrow down the events used in analysis. Optional, may be null.</param>
/// <param name="timezone">The timezone to use when specifying a relative timeframe. Optional, may be blank.</param>
/// <returns></returns>
public async Task <IEnumerable <QueryIntervalValue <IEnumerable <QueryGroupValue <string> > > > > QueryIntervalGroupAsync
(QueryType queryType, string collection, string targetProperty, string groupBy, IQueryTimeframe timeframe,
QueryInterval interval, IEnumerable <QueryFilter> filters = null, string timezone = "")
{
return
(await
Queries.Metric(queryType, collection, targetProperty, groupBy, timeframe, interval, filters,
timezone).ConfigureAwait(false));
}
/// <summary>
/// Extract full-form event data with all property values.
/// </summary>
/// <param name="collection">Name of event collection to query.</param>
/// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param>
/// <param name="filters">Filter to narrow down the events used in analysis. Optional, may be null.</param>
/// <param name="latest">Request up to 100 of the most recent events added to a given collection.</param>
/// <param name="email">If specified, email will be sent when the data is ready for download. Otherwise, it will be returned directly.</param>
/// <returns></returns>
public async Task <IEnumerable <dynamic> > QueryExtractResourceAsync(string collection,
IQueryTimeframe timeframe = null, IEnumerable <QueryFilter> filters = null, int latest = 0, string email = "")
{
return(await Queries.Extract(collection, timeframe, filters, latest, email).ConfigureAwait(false));
}
/// <summary>
/// Funnels count relevant events in succession. See API documentation for details.
/// </summary>
/// <param name="steps">Analysis steps for funnel.</param>
/// <param name="timeframe">Specifies window of time from which to select events for analysis. May be absolute or relative.</param>
/// <param name="timezone">The timezone to use when specifying a relative timeframe. Optional, may be blank.</param>
/// <returns></returns>
public async Task <FunnelResult> QueryFunnelAsync(IEnumerable <FunnelStep> steps,
IQueryTimeframe timeframe = null, string timezone = "")
{
return(await Queries.Funnel(steps, timeframe, timezone).ConfigureAwait(false));
}
