/// <summary>
/// Deletes resource on the server
/// </summary>
/// <param name="resource">Resource to delete</param>
/// <param name="auth">Authorization info</param>
protected virtual void Delete(object resource, Authorization auth = null)
{
// invoke delete
var resourceId = GetResourceId(resource);
var response = Client.Delete(ResourceUri + "/" + resourceId, auth: auth);
// verify response object
ExpectResponseStatus(response, ExpectedDeletedStatus);
}
/// <summary>
/// Creates resource on the server
/// </summary>
/// <param name="resourceObject">Resource object to create</param>
/// <param name="auth">Authorization info</param>
/// <returns>JObject that represents server response</returns>
protected virtual JObject Create(object resourceObject, Authorization auth = null)
{
// invoke create
var response = Client.Post(ResourceUri, resourceObject, auth: auth);
// verify response object
ExpectResponseStatus(response, ExpectedCreatedStatus);
Expect(response.Json, Is.InstanceOf<JObject>());
RegisterForDeletion(ResourceUri + "/" + GetResourceId((JObject)response.Json));
return (JObject)response.Json;
}
/// <summary>
/// Updates resource on the server
/// </summary>
/// <param name="resource">Resource to update</param>
/// <param name="resourceObject">Resource object to send as update</param>
/// <param name="auth">Authorization info</param>
/// <returns>JObject that represents server response</returns>
protected virtual JObject Update(object resource, object resourceObject, Authorization auth = null)
{
// invoke update
var resourceId = GetResourceId(resource);
var response = Client.Put(ResourceUri + "/" + resourceId, resourceObject, auth: auth);
// verify response object
ExpectResponseStatus(response, 200);
Expect(response.Json, Is.InstanceOf<JObject>());
Expect(GetResourceId((JObject)response.Json), Is.EqualTo(resourceId.ToString()));
return (JObject)response.Json;
}
/// <summary>
/// Gets list of resources from the server
/// </summary>
/// <param name="auth">Authorization info</param>
/// <returns>JArray that represents server response</returns>
protected virtual JArray Get(Authorization auth = null)
{
// invoke get
var response = Client.Get(ResourceUri, auth: auth);
// verify response object
ExpectResponseStatus(response, 200);
Expect(response.Json, Is.InstanceOf<JArray>());
return (JArray)response.Json;
}
/// <summary>
/// Gets list of resources from the server
/// </summary>
/// <param name="query">Optional query parameters</param>
/// <param name="auth">Authorization info</param>
/// <returns>JArray that represents server response</returns>
protected virtual JArray Get(Dictionary<string, string> query, Authorization auth = null)
{
// invoke get
var response = Client.Get(ResourceUri + "?" +
string.Join("&", query.Select(q => string.Format("{0}={1}", q.Key, Uri.EscapeUriString(q.Value)))), auth: auth);
// verify response object
ExpectResponseStatus(response, 200);
Expect(response.Json, Is.InstanceOf<JArray>());
return (JArray)response.Json;
}
/// <summary>
/// Creates an access key and returns corresponding Authorization object
/// </summary>
/// <param name="user">User authorization object</param>
/// <param name="action">Allowed access key action</param>
/// <param name="networkIds">Allowed networks</param>
/// <param name="deviceGuids">Allowed devices</param>
/// <returns>Coresponding Authorization object</returns>
protected Authorization CreateAccessKey(Authorization user, string action, int[] networkIds = null, string[] deviceGuids = null)
{
return(CreateAccessKey(user, new[] { action }, networkIds, deviceGuids));
}
public JsonResponse Run(string method, string url, JObject jsonRequest = null, Authorization auth = null)
{
if (string.IsNullOrEmpty(method))
{
throw new ArgumentException("Method is null or empty!", "method");
}
if (string.IsNullOrEmpty(url))
{
throw new ArgumentException("URL is null or empty!", "url");
}
// prepare request
var request = (HttpWebRequest)HttpWebRequest.Create(BaseUrl + url);
request.Headers.Add("ClientVersion", DeviceHive.Core.Version.ApiVersion);
request.Method = method;
request.Accept = "application/json";
if (auth != null)
{
switch (auth.Type)
{
case "User":
request.Headers["Authorization"] = "Basic " + Convert.ToBase64String(
Encoding.UTF8.GetBytes(string.Format("{0}:{1}", auth.Login, auth.Password)));
break;
case "AccessKey":
request.Headers["Authorization"] = "Bearer " + auth.Login;
break;
case "Device":
request.Headers["Auth-DeviceID"] = auth.Login;
request.Headers["Auth-DeviceKey"] = auth.Password;
break;
}
}
if (jsonRequest != null)
{
request.ContentType = "application/json";
using (var stream = request.GetRequestStream())
{
using (var writer = new StreamWriter(stream))
{
writer.Write(jsonRequest.ToString());
}
}
}
// perform a call
HttpWebResponse response;
try
{
response = (HttpWebResponse)request.GetResponse();
}
catch (WebException ex)
{
response = (HttpWebResponse)ex.Response;
}
// parse response
using (var stream = response.GetResponseStream())
{
using (var reader = new StreamReader(stream))
{
var responseString = reader.ReadToEnd();
try
{
var json = string.IsNullOrEmpty(responseString) ? null : JToken.Parse(responseString);
return(new JsonResponse((int)response.StatusCode, json));
}
catch (JsonReaderException ex)
{
throw new WebException(string.Format("Error while parsing server response! " +
"Status: {0}, Response: {1}", (int)response.StatusCode, responseString), ex);
}
}
}
}
public JsonResponse Delete(string url, Authorization auth = null)
{
return(Run("DELETE", url, auth: auth));
}
public JsonResponse Put(string url, object request, Authorization auth = null)
{
return(Run("PUT", url, jsonRequest: JObject.FromObject(request), auth: auth));
}
public JsonResponse Get(string url, Authorization auth = null)
{
return(Run("GET", url, auth: auth));
}
