private async Task <JObject> KeenWebApiRequest(string operation = "", Dictionary <string, string> parms = null)
{
var parmVals = parms == null ? "" : string.Join("&", from p in parms.Keys
where !string.IsNullOrEmpty(parms[p])
select string.Format("{0}={1}", p, Uri.EscapeDataString(parms[p])));
var url = string.Format("{0}{1}{2}",
_serverUrl,
string.IsNullOrWhiteSpace(operation) ? "" : "/" + operation,
string.IsNullOrWhiteSpace(parmVals) ? "" : "?" + parmVals);
using (var client = new HttpClient())
{
client.DefaultRequestHeaders.Add("Authorization", _prjSettings.MasterKey);
var responseMsg = await client.GetAsync(url).ConfigureAwait(false);
var responseString = await responseMsg.Content.ReadAsStringAsync().ConfigureAwait(false);
var response = JObject.Parse(responseString);
// error checking, throw an exception with information from the json
// response if available, then check the HTTP response.
KeenUtil.CheckApiErrorCode((dynamic)response);
if (!responseMsg.IsSuccessStatusCode)
{
throw new KeenException("Request failed with status: " + responseMsg.StatusCode);
}
return(response);
}
}
public async Task DeleteDatasetAsync(string datasetName)
{
if (string.IsNullOrWhiteSpace(datasetName))
{
throw new KeenException("A dataset name is required.");
}
if (string.IsNullOrWhiteSpace(_masterKey))
{
throw new KeenException("An API MasterKey is required to get dataset results.");
}
var responseMsg = await _keenHttpClient
.DeleteAsync(GetDatasetUrl(datasetName), _masterKey)
.ConfigureAwait(continueOnCapturedContext: false);
var responseString = await responseMsg
.Content
.ReadAsStringAsync()
.ConfigureAwait(continueOnCapturedContext: false);
if (HttpStatusCode.NoContent != responseMsg.StatusCode)
{
var response = JObject.Parse(responseString);
KeenUtil.CheckApiErrorCode(response);
throw new KeenException($"Request failed with status: {responseMsg.StatusCode}");
}
}
public async Task <DatasetDefinition> GetDefinitionAsync(string datasetName)
{
if (string.IsNullOrWhiteSpace(datasetName))
{
throw new KeenException("A dataset name is required.");
}
if (string.IsNullOrWhiteSpace(_readKey))
{
throw new KeenException("An API ReadKey is required to get dataset results.");
}
var responseMsg = await _keenHttpClient
.GetAsync(GetDatasetUrl(datasetName), _readKey)
.ConfigureAwait(continueOnCapturedContext: false);
var responseString = await responseMsg
.Content
.ReadAsStringAsync()
.ConfigureAwait(continueOnCapturedContext: false);
var response = JObject.Parse(responseString);
KeenUtil.CheckApiErrorCode(response);
if (!responseMsg.IsSuccessStatusCode)
{
throw new KeenException($"Request failed with status: {responseMsg.StatusCode}");
}
return(JsonConvert.DeserializeObject <DatasetDefinition>(responseString,
SerializerSettings));
}
public async Task DefaultHeaders_Success()
{
object responseData = new[] { new { result = 2 } };
var handler = new FuncHandler()
{
PreProcess = (req, ct) =>
{
// Make sure the default headers are in place
Assert.IsTrue(req.Headers.Contains("Keen-Sdk"));
Assert.AreEqual(KeenUtil.GetSdkVersion(), req.Headers.GetValues("Keen-Sdk").Single());
Assert.IsTrue(req.Headers.Contains("Authorization"));
var key = req.Headers.GetValues("Authorization").Single();
Assert.IsTrue(SettingsEnv.ReadKey == key ||
SettingsEnv.WriteKey == key ||
SettingsEnv.MasterKey == key);
},
ProduceResultAsync = (req, ct) =>
{
return(CreateJsonStringResponseAsync(responseData));
},
DeferToDefault = false
};
var client = new KeenClient(SettingsEnv, new TestKeenHttpClientProvider()
{
ProvideKeenHttpClient =
(url) => KeenHttpClientFactory.Create(url,
new HttpClientCache(),
null,
new DelegatingHandlerMock(handler))
});
// Try out all the endpoints
Assert.DoesNotThrow(() => client.GetSchemas());
// Remaining operations expect an object, not an array of objects
responseData = new { result = 2 };
var @event = new { AProperty = "AValue" };
Assert.DoesNotThrow(() => client.AddEvent("AddEventTest", @event));
Assert.DoesNotThrow(() => client.AddEvents("AddEventTest", new[] { @event }));
Assert.DoesNotThrow(() => client.DeleteCollection("DeleteColTest"));
Assert.IsNotNull(client.GetSchema("AddEventTest"));
// Currently all the queries/extraction go through the same KeenWebApiRequest() call.
var count = await client.QueryAsync(
QueryType.Count(),
"testCollection",
"",
QueryRelativeTimeframe.ThisMonth());
Assert.IsNotNull(count);
Assert.AreEqual("2", count);
}
public void GetSdkVersion_Success()
{
string sdkVersion = KeenUtil.GetSdkVersion();
Assert.IsNotNull(sdkVersion);
Assert.IsNotEmpty(sdkVersion);
Assert.IsTrue(sdkVersion.StartsWith(".net"));
}
public void GetSdkVersion_Success()
{
// TODO : Decide on a better place for this when we break out tests and do a CC push.
string sdkVersion = KeenUtil.GetSdkVersion();
Assert.IsNotNull(sdkVersion);
Assert.IsNotEmpty(sdkVersion);
Assert.IsTrue(sdkVersion.StartsWith(".net"));
}
public async Task <JObject> GetResultsAsync(string datasetName,
string indexBy,
string timeframe)
{
if (string.IsNullOrWhiteSpace(datasetName))
{
throw new KeenException("A dataset name is required.");
}
if (string.IsNullOrWhiteSpace(indexBy))
{
throw new KeenException("A value to index by is required.");
}
if (string.IsNullOrWhiteSpace(timeframe))
{
throw new KeenException("A timeframe by is required.");
}
if (string.IsNullOrWhiteSpace(_readKey))
{
throw new KeenException("An API ReadKey is required to get dataset results.");
}
var datasetResultsUrl = $"{GetDatasetUrl(datasetName)}/results";
// Absolute timeframes can have reserved characters like ':', and index_by can be
// any valid JSON member name, which can have all sorts of stuff, so we escape here.
var url = $"{datasetResultsUrl}?" +
$"index_by={Uri.EscapeDataString(indexBy)}" +
$"&timeframe={Uri.EscapeDataString(timeframe)}";
var responseMsg = await _keenHttpClient
.GetAsync(url, _readKey)
.ConfigureAwait(continueOnCapturedContext: false);
var responseString = await responseMsg
.Content
.ReadAsStringAsync()
.ConfigureAwait(continueOnCapturedContext: false);
var response = JObject.Parse(responseString);
KeenUtil.CheckApiErrorCode(response);
if (!responseMsg.IsSuccessStatusCode)
{
throw new KeenException($"Request failed with status: {responseMsg.StatusCode}");
}
return(response);
}
public async Task <JObject> GetResultsAsync(string datasetName,
string indexBy,
string timeframe)
{
if (string.IsNullOrWhiteSpace(datasetName))
{
throw new KeenException("A dataset name is required.");
}
if (string.IsNullOrWhiteSpace(indexBy))
{
throw new KeenException("A value to index by is required.");
}
if (string.IsNullOrWhiteSpace(timeframe))
{
throw new KeenException("A timeframe by is required.");
}
if (string.IsNullOrWhiteSpace(_masterKey))
{
throw new KeenException("An API masterkey is required to get dataset results.");
}
var datasetResultsUrl = $"{GetDatasetUrl(datasetName)}/results";
var url = $"{datasetResultsUrl}?index_by={indexBy}&timeframe={timeframe}";
var responseMsg = await _keenHttpClient
.GetAsync(url, _masterKey)
.ConfigureAwait(continueOnCapturedContext: false);
var responseString = await responseMsg
.Content
.ReadAsStringAsync()
.ConfigureAwait(continueOnCapturedContext: false);
var response = JObject.Parse(responseString);
KeenUtil.CheckApiErrorCode(response);
if (!responseMsg.IsSuccessStatusCode)
{
throw new KeenException($"Request failed with status: {responseMsg.StatusCode}");
}
return(response);
}
private async Task <JObject> KeenWebApiRequest(string operation = "",
Dictionary <string, string> parms = null)
{
if (string.IsNullOrWhiteSpace(_key))
{
throw new KeenException("An API ReadKey or MasterKey is required.");
}
var parmVals = (parms == null) ?
"" : string.Join("&", from p in parms.Keys
where !string.IsNullOrEmpty(parms[p])
select string.Format("{0}={1}",
p,
Uri.EscapeDataString(parms[p])));
var url = string.Format("{0}{1}{2}",
_queryRelativeUrl,
string.IsNullOrWhiteSpace(operation) ? "" : "/" + operation,
string.IsNullOrWhiteSpace(parmVals) ? "" : "?" + parmVals);
var responseMsg = await _keenHttpClient.GetAsync(url, _key).ConfigureAwait(false);
var responseString = await responseMsg
.Content
.ReadAsStringAsync()
.ConfigureAwait(false);
var response = JObject.Parse(responseString);
// error checking, throw an exception with information from the json
// response if available, then check the HTTP response.
KeenUtil.CheckApiErrorCode(response);
if (!responseMsg.IsSuccessStatusCode)
{
throw new KeenException("Request failed with status: " +
responseMsg.StatusCode);
}
return(response);
}
public async Task <DatasetDefinitionCollection> ListDefinitionsAsync(
int limit = 10,
string afterName = null)
{
if (string.IsNullOrWhiteSpace(_readKey))
{
throw new KeenException("An API ReadKey is required to get dataset results.");
}
// limit is just an int, so no need to encode here.
var datasetResultsUrl = $"{_cachedDatasetRelativeUrl}?limit={limit}";
if (!string.IsNullOrWhiteSpace(afterName))
{
// afterName should be a valid dataset name, which can only be
// alphanumerics, '_' and '-', so we don't escape here.
datasetResultsUrl += $"&after_name={afterName}";
}
var responseMsg = await _keenHttpClient
.GetAsync(datasetResultsUrl, _readKey)
.ConfigureAwait(continueOnCapturedContext: false);
var responseString = await responseMsg
.Content
.ReadAsStringAsync()
.ConfigureAwait(continueOnCapturedContext: false);
var response = JObject.Parse(responseString);
KeenUtil.CheckApiErrorCode(response);
if (!responseMsg.IsSuccessStatusCode)
{
throw new KeenException($"Request failed with status: {responseMsg.StatusCode}");
}
return(JsonConvert.DeserializeObject <DatasetDefinitionCollection>(responseString,
SerializerSettings));
}
public async Task <DatasetDefinition> CreateDatasetAsync(DatasetDefinition dataset)
{
if (string.IsNullOrWhiteSpace(_masterKey))
{
throw new KeenException("An API MasterKey is required to get dataset results.");
}
// Validate
if (null == dataset)
{
throw new KeenException("An instance of DatasetDefinition must be provided");
}
// This throws if dataset is not valid.
dataset.Validate();
var content = JsonConvert.SerializeObject(dataset, SerializerSettings);
var responseMsg = await _keenHttpClient
.PutAsync(GetDatasetUrl(dataset.DatasetName), _masterKey, content)
.ConfigureAwait(continueOnCapturedContext: false);
var responseString = await responseMsg
.Content
.ReadAsStringAsync()
.ConfigureAwait(continueOnCapturedContext: false);
var response = JObject.Parse(responseString);
KeenUtil.CheckApiErrorCode(response);
if (!responseMsg.IsSuccessStatusCode)
{
throw new KeenException($"Request failed with status: {responseMsg.StatusCode}");
}
return(JsonConvert.DeserializeObject <DatasetDefinition>(responseString,
SerializerSettings));
}
public async Task <DatasetDefinitionCollection> ListDefinitionsAsync(
int limit = 10,
string afterName = null)
{
if (string.IsNullOrWhiteSpace(_masterKey))
{
throw new KeenException("An API masterkey is required to get dataset results.");
}
var datasetResultsUrl = $"{_cachedDatasetRelativeUrl}?limit={limit}";
if (!string.IsNullOrWhiteSpace(afterName))
{
datasetResultsUrl += $"&after_name={afterName}";
}
var responseMsg = await _keenHttpClient
.GetAsync(datasetResultsUrl, _masterKey)
.ConfigureAwait(continueOnCapturedContext: false);
var responseString = await responseMsg
.Content
.ReadAsStringAsync()
.ConfigureAwait(continueOnCapturedContext: false);
var response = JObject.Parse(responseString);
KeenUtil.CheckApiErrorCode(response);
if (!responseMsg.IsSuccessStatusCode)
{
throw new KeenException($"Request failed with status: {responseMsg.StatusCode}");
}
return(JsonConvert.DeserializeObject <DatasetDefinitionCollection>(responseString,
SERIALIZER_SETTINGS));
}
