/// <summary>
/// Begins an async multi get operation
/// </summary>
/// <param name="keys">The keys.</param>
/// <returns></returns>
public Task <JsonDocument[]> MultiGetAsync(string[] keys)
{
var request = HttpJsonRequest.CreateHttpJsonRequest(this, url + "/queries/", "POST", credentials, convention);
var array = Encoding.UTF8.GetBytes(new JArray(keys).ToString(Formatting.None));
return(Task.Factory.FromAsync(request.BeginWrite, request.EndWrite, array, null)
.ContinueWith(writeTask => Task.Factory.FromAsync <string>(request.BeginReadResponseString, request.EndReadResponseString, null))
.Unwrap()
.ContinueWith(task =>
{
JArray responses;
try
{
responses = JObject.Parse(task.Result).Value <JArray>("Results");
}
catch (WebException e)
{
var httpWebResponse = e.Response as HttpWebResponse;
if (httpWebResponse == null ||
httpWebResponse.StatusCode != HttpStatusCode.Conflict)
{
throw;
}
throw ThrowConcurrencyException(e);
}
return SerializationHelper.JObjectsToJsonDocuments(responses.Cast <JObject>())
.ToArray();
}));
}
public IAsyncResult BeginGet(string key, AsyncCallback callback, object state)
{
EnsureIsNotNullOrEmpty(key, "key");
var metadata = new JObject();
AddTransactionInformation(metadata);
var request = HttpJsonRequest.CreateHttpJsonRequest(this, url + "/docs/" + key, "GET", metadata, credentials);
var asyncCallback = callback;
if (callback != null)
{
asyncCallback = ar => callback(new UserAsyncData(request, ar)
{
Key = key
});
}
var asyncResult = request.BeginReadResponseString(asyncCallback, state);
return(new UserAsyncData(request, asyncResult)
{
Key = key
});
}
/// <summary>
/// Returns a list of suggestions based on the specified suggestion query.
/// </summary>
/// <param name="index">The index to query for suggestions</param>
/// <param name="suggestionQuery">The suggestion query.</param>
public Task <SuggestionQueryResult> SuggestAsync(string index, SuggestionQuery suggestionQuery)
{
if (suggestionQuery == null)
{
throw new ArgumentNullException("suggestionQuery");
}
var requestUri = url + string.Format("/suggest/{0}?term={1}&field={2}&max={3}&distance={4}&accuracy={5}",
Uri.EscapeUriString(index),
Uri.EscapeDataString(suggestionQuery.Term),
Uri.EscapeDataString(suggestionQuery.Field),
Uri.EscapeDataString(suggestionQuery.MaxSuggestions.ToString()),
Uri.EscapeDataString(suggestionQuery.Distance.ToString()),
Uri.EscapeDataString(suggestionQuery.Accuracy.ToString()));
var request = HttpJsonRequest.CreateHttpJsonRequest(this, requestUri, "GET", credentials, convention);
request.AddOperationHeaders(OperationsHeaders);
var serializer = convention.CreateSerializer();
return(Task.Factory.FromAsync <string>(request.BeginReadResponseString, request.EndReadResponseString, null)
.ContinueWith(task =>
{
using (var reader = new JsonTextReader(new StringReader(task.Result)))
{
var json = (JToken)serializer.Deserialize(reader);
return new SuggestionQueryResult
{
Suggestions = json["Suggestions"].Children().Select(x => x.Value <string>()).ToArray(),
};
}
}));
}
public IAsyncResult BeginBatch(ICommandData[] commandDatas, AsyncCallback callback, object state)
{
var metadata = new JObject();
AddTransactionInformation(metadata);
var req = HttpJsonRequest.CreateHttpJsonRequest(this, url + "/bulk_docs", "POST", metadata, credentials);
var jArray = new JArray(commandDatas.Select(x => x.ToJson()));
var data = Encoding.UTF8.GetBytes(jArray.ToString(Formatting.None));
var multiStepAsyncResult = new MultiStepAsyncResult(state, req);
var asyncResult = req.BeginWrite(data, ContinueOperation, new Contiuation
{
Callback = callback,
State = state,
Request = req,
MultiAsyncResult = multiStepAsyncResult
});
if (asyncResult.CompletedSynchronously)
{
ContinueOperation(asyncResult);
}
return(multiStepAsyncResult);
}
/// <summary>
/// Begins the async batch operation
/// </summary>
/// <param name="commandDatas">The command data.</param>
/// <returns></returns>
public Task <BatchResult[]> BatchAsync(ICommandData[] commandDatas)
{
var metadata = new JObject();
AddTransactionInformation(metadata);
var req = HttpJsonRequest.CreateHttpJsonRequest(this, url + "/bulk_docs", "POST", metadata, credentials, convention);
var jArray = new JArray(commandDatas.Select(x => x.ToJson()));
var data = Encoding.UTF8.GetBytes(jArray.ToString(Formatting.None));
return(Task.Factory.FromAsync(req.BeginWrite, req.EndWrite, data, null)
.ContinueWith(writeTask => Task.Factory.FromAsync <string>(req.BeginReadResponseString, req.EndReadResponseString, null))
.Unwrap()
.ContinueWith(task =>
{
string response;
try
{
response = task.Result;
}
catch (WebException e)
{
var httpWebResponse = e.Response as HttpWebResponse;
if (httpWebResponse == null ||
httpWebResponse.StatusCode != HttpStatusCode.Conflict)
{
throw;
}
throw ThrowConcurrencyException(e);
}
return JsonConvert.DeserializeObject <BatchResult[]>(response);
}));
}
/// <summary>
/// Puts the attachment with the specified key asyncronously
/// </summary>
/// <param name="key">The key.</param>
/// <param name="etag">The etag.</param>
/// <param name="data">The data.</param>
/// <param name="metadata">The metadata.</param>
public Task PutAttachmentAsync(string key, Guid?etag, byte[] data, JObject metadata)
{
if (metadata == null)
{
metadata = new JObject();
}
if (etag != null)
{
metadata["ETag"] = new JValue(etag.Value.ToString());
}
var request = HttpJsonRequest.CreateHttpJsonRequest(this, url.Static(key), "PUT", metadata, credentials, convention);
request.AddOperationHeaders(OperationsHeaders);
return(request
.WriteAsync(data)
.ContinueWith(write =>
{
if (write.Exception != null)
{
throw new InvalidOperationException("Unable to write to server");
}
return request.ReadResponseStringAsync();
}).Unwrap());
}
/// <summary>
/// Begins the async query.
/// </summary>
/// <param name="index">The index.</param>
/// <param name="query">The query.</param>
/// <param name="includes">The include paths</param>
public Task <QueryResult> QueryAsync(string index, IndexQuery query, string[] includes)
{
EnsureIsNotNullOrEmpty(index, "index");
var path = query.GetIndexQueryUrl(url, index, "indexes");
if (includes != null && includes.Length > 0)
{
path += "&" + string.Join("&", includes.Select(x => "include=" + x).ToArray());
}
var request = HttpJsonRequest.CreateHttpJsonRequest(this, path, "GET", credentials, convention);
return(Task.Factory.FromAsync <string>(request.BeginReadResponseString, request.EndReadResponseString, null)
.ContinueWith(task =>
{
JToken json;
using (var reader = new JsonTextReader(new StringReader(task.Result)))
json = (JToken)convention.CreateSerializer().Deserialize(reader);
return new QueryResult
{
IsStale = Convert.ToBoolean(json["IsStale"].ToString()),
IndexTimestamp = json.Value <DateTime>("IndexTimestamp"),
IndexEtag = new Guid(request.ResponseHeaders["ETag"]),
Results = json["Results"].Children().Cast <JObject>().ToList(),
TotalResults = Convert.ToInt32(json["TotalResults"].ToString()),
IndexName = json.Value <string>("IndexName"),
SkippedResults = Convert.ToInt32(json["SkippedResults"].ToString())
};
}));
}
/// <summary>
/// Begins an async get operation
/// </summary>
/// <param name="key">The key.</param>
/// <returns></returns>
public Task <JsonDocument> GetAsync(string key)
{
EnsureIsNotNullOrEmpty(key, "key");
var metadata = new JObject();
AddTransactionInformation(metadata);
var request = HttpJsonRequest.CreateHttpJsonRequest(this, url + "/docs/" + key, "GET", metadata, credentials, convention);
return(Task.Factory.FromAsync <string>(request.BeginReadResponseString, request.EndReadResponseString, null)
.ContinueWith(task =>
{
try
{
var responseString = task.Result;
return new JsonDocument
{
DataAsJson = JObject.Parse(responseString),
NonAuthoritiveInformation = request.ResponseStatusCode == HttpStatusCode.NonAuthoritativeInformation,
Key = key,
LastModified = DateTime.ParseExact(request.ResponseHeaders["Last-Modified"], "r", CultureInfo.InvariantCulture),
Etag = new Guid(request.ResponseHeaders["ETag"]),
Metadata = request.ResponseHeaders.FilterHeaders(isServerDocument: false)
};
}
catch (WebException e)
{
var httpWebResponse = e.Response as HttpWebResponse;
if (httpWebResponse == null)
{
throw;
}
if (httpWebResponse.StatusCode == HttpStatusCode.NotFound)
{
return null;
}
if (httpWebResponse.StatusCode == HttpStatusCode.Conflict)
{
var conflicts = new StreamReader(httpWebResponse.GetResponseStreamWithHttpDecompression());
var conflictsDoc = JObject.Load(new JsonTextReader(conflicts));
var conflictIds = conflictsDoc.Value <JArray>("Conflicts").Select(x => x.Value <string>()).ToArray();
throw new ConflictException("Conflict detected on " + key +
", conflict must be resolved before the document will be accessible")
{
ConflictedVersionIds = conflictIds
};
}
throw;
}
}));
}
/// <summary>
/// Puts the document with the specified key in the database
/// </summary>
/// <param name="key">The key.</param>
/// <param name="etag">The etag.</param>
/// <param name="document">The document.</param>
/// <param name="metadata">The metadata.</param>
public Task <PutResult> PutAsync(string key, Guid?etag, JObject document, JObject metadata)
{
if (metadata == null)
{
metadata = new JObject();
}
var method = String.IsNullOrEmpty(key) ? "POST" : "PUT";
if (etag != null)
{
metadata["ETag"] = new JValue(etag.Value.ToString());
}
var request = HttpJsonRequest.CreateHttpJsonRequest(this, url + "/docs/" + key, method, metadata, credentials, convention);
request.AddOperationHeaders(OperationsHeaders);
return(request.WriteAsync(Encoding.UTF8.GetBytes(document.ToString()))
.ContinueWith(task =>
{
if (task.Exception != null)
{
throw new InvalidOperationException("Unable to write to server");
}
return request.ReadResponseStringAsync()
.ContinueWith(task1 =>
{
try
{
return JsonConvert.DeserializeObject <PutResult>(task1.Result, new JsonEnumConverter());
}
catch (AggregateException e)
{
var webexception = e.ExtractSingleInnerException() as WebException;
if (ShouldThrowForPutAsync(webexception))
{
throw;
}
throw ThrowConcurrencyException(webexception);
}
catch (WebException e)
{
if (ShouldThrowForPutAsync(e))
{
throw;
}
throw ThrowConcurrencyException(e);
}
});
})
.Unwrap());
}
/// <summary>
/// Puts the index definition for the specified name asyncronously
/// </summary>
/// <param name="name">The name.</param>
/// <param name="indexDef">The index def.</param>
/// <param name="overwrite">Should overwrite index</param>
public Task <string> PutIndexAsync(string name, IndexDefinition indexDef, bool overwrite)
{
string requestUri = url + "/indexes/" + Uri.EscapeUriString(name);
var webRequest = (HttpWebRequest)WebRequestCreator.ClientHttp.Create(new Uri(requestUri));
AddOperationHeaders(webRequest);
webRequest.Method = "HEAD";
webRequest.Credentials = credentials;
return(webRequest.GetResponseAsync()
.ContinueWith(task =>
{
try
{
task.Result.Close();
if (overwrite == false)
{
throw new InvalidOperationException("Cannot put index: " + name + ", index already exists");
}
}
catch (AggregateException e)
{
var webException = e.ExtractSingleInnerException() as WebException;
if (ShouldThrowForPutIndexAsync(webException))
{
throw;
}
}
catch (WebException e)
{
if (ShouldThrowForPutIndexAsync(e))
{
throw;
}
}
var request = HttpJsonRequest.CreateHttpJsonRequest(this, requestUri, "PUT", credentials, convention);
request.AddOperationHeaders(OperationsHeaders);
var serializeObject = JsonConvert.SerializeObject(indexDef, new JsonEnumConverter());
return request
.WriteAsync(Encoding.UTF8.GetBytes(serializeObject))
.ContinueWith(writeTask => request.ReadResponseStringAsync()
.ContinueWith(readStrTask =>
{
//NOTE: JsonConvert.DeserializeAnonymousType() doesn't work in Silverlight because the ctr is private!
var obj = JsonConvert.DeserializeObject <IndexContainer>(readStrTask.Result);
return obj.Index;
})).Unwrap();
}).Unwrap());
}
/// <summary>
/// Deletes the attachment with the specified key asyncronously
/// </summary>
/// <param name="key">The key.</param>
/// <param name="etag">The etag.</param>
public Task DeleteAttachmentAsync(string key, Guid?etag)
{
var metadata = new JObject();
if (etag != null)
{
metadata["ETag"] = new JValue(etag.Value.ToString());
}
var request = HttpJsonRequest.CreateHttpJsonRequest(this, url.Static(key), "DELETE", metadata, credentials, convention);
request.AddOperationHeaders(OperationsHeaders);
return(request.ReadResponseStringAsync());
}
/// <summary>
/// Puts the document with the specified key in the database
/// </summary>
/// <param name="key">The key.</param>
/// <param name="etag">The etag.</param>
/// <param name="document">The document.</param>
/// <param name="metadata">The metadata.</param>
public Task <PutResult> PutAsync(string key, Guid?etag, JObject document, JObject metadata)
{
if (metadata == null)
{
metadata = new JObject();
}
var method = String.IsNullOrEmpty(key) ? "POST" : "PUT";
if (etag != null)
{
metadata["ETag"] = new JValue(etag.Value.ToString());
}
var request = HttpJsonRequest.CreateHttpJsonRequest(this, url + "/docs/" + key, method, metadata, credentials, convention);
request.AddOperationHeaders(OperationsHeaders);
var bytes = Encoding.UTF8.GetBytes(document.ToString());
return(Task.Factory.FromAsync(request.BeginWrite, request.EndWrite, bytes, null)
.ContinueWith(task =>
{
if (task.Exception != null)
{
throw new InvalidOperationException("Unable to write to server");
}
return Task.Factory.FromAsync <string>(request.BeginReadResponseString, request.EndReadResponseString, null)
.ContinueWith(task1 =>
{
try
{
return JsonConvert.DeserializeObject <PutResult>(task1.Result, new JsonEnumConverter());
}
catch (WebException e)
{
var httpWebResponse = e.Response as HttpWebResponse;
if (httpWebResponse == null ||
httpWebResponse.StatusCode != HttpStatusCode.Conflict)
{
throw;
}
throw ThrowConcurrencyException(e);
}
});
})
.Unwrap());
}
public IAsyncResult BeginQuery(string index, IndexQuery query, AsyncCallback callback, object state)
{
EnsureIsNotNullOrEmpty(index, "index");
string path = query.GetIndexQueryUrl(url, index, "indexes");
var request = HttpJsonRequest.CreateHttpJsonRequest(this, path, "GET", credentials);
var asyncCallback = callback;
if (callback != null)
{
asyncCallback = ar => callback(new UserAsyncData(request, ar));
}
var asyncResult = request.BeginReadResponseString(asyncCallback, state);
return(new UserAsyncData(request, asyncResult));
}
/// <summary>
/// Gets the indexes from the server asyncronously
/// </summary>
/// <param name="start">Paging start</param>
/// <param name="pageSize">Size of the page.</param>
public Task <IndexDefinition[]> GetIndexesAsync(int start, int pageSize)
{
var request = HttpJsonRequest.CreateHttpJsonRequest(this, url + "/indexes/?start=" + start + "&pageSize=" + pageSize, "GET", credentials, convention);
return(request.ReadResponseStringAsync()
.ContinueWith(task =>
{
var serializer = convention.CreateSerializer();
using (var reader = new JsonTextReader(new StringReader(task.Result)))
{
var json = (JToken)serializer.Deserialize(reader);
//NOTE: To review, I'm not confidence this is the correct way to deserialize the index definition
return json
.Select(x => JsonConvert.DeserializeObject <IndexDefinition>(x["definition"].ToString()))
.ToArray();
}
}));
}
/// <summary>
/// Begins the async query.
/// </summary>
/// <param name="query">A string representation of a Linq query</param>
public Task <QueryResult> LinearQueryAsync(string linq, int start, int pageSize)
{
var query = @"{
Query: '" + linq + @"',
Start: " + start + @",
PageSize: " + pageSize + @"
}" ;
var metadata = new JObject();
var request = HttpJsonRequest.CreateHttpJsonRequest(this, url + "/linearQuery", "POST", metadata, credentials, convention);
request.AddOperationHeaders(OperationsHeaders);
return(request
.WriteAsync(Encoding.UTF8.GetBytes(query))
.ContinueWith(write =>
{
if (write.Exception != null)
{
throw new InvalidOperationException("Unable to write to server");
}
return request.ReadResponseStringAsync();
})
.ContinueWith(task =>
{
JToken json;
using (var reader = new JsonTextReader(new StringReader(task.Result.Result)))
json = (JToken)convention.CreateSerializer().Deserialize(reader);
//TODO: the json includes LastScanResults and Errors, but it doesn't include the commented out properties below.
// Should this change?
return new QueryResult
{
//IsStale = Convert.ToBoolean(json["IsStale"].ToString()),
//IndexTimestamp = json.Value<DateTime>("IndexTimestamp"),
//IndexEtag = new Guid(request.ResponseHeaders["ETag"].First()),
Results = json["Results"].Children().Cast <JObject>().ToList(),
TotalResults = Convert.ToInt32(json["TotalResults"].ToString()),
//SkippedResults = Convert.ToInt32(json["SkippedResults"].ToString()),
//Includes = json["Includes"].Children().Cast<JObject>().ToList(),
};
}));
}
public IAsyncResult BeginMultiGet(string[] keys, AsyncCallback callback, object state)
{
var request = HttpJsonRequest.CreateHttpJsonRequest(this, url + "/queries/", "POST", credentials);
var array = Encoding.UTF8.GetBytes(new JArray(keys).ToString(Formatting.None));
var multiStepAsyncResult = new MultiStepAsyncResult(state, request);
var asyncResult = request.BeginWrite(array, ContinueOperation, new Contiuation
{
Callback = callback,
State = state,
Request = request,
MultiAsyncResult = multiStepAsyncResult
});
if (asyncResult.CompletedSynchronously)
{
ContinueOperation(asyncResult);
}
return(multiStepAsyncResult);
}
/// <summary>
/// Puts the index definition for the specified name asyncronously
/// </summary>
/// <param name="name">The name.</param>
/// <param name="indexDef">The index def.</param>
/// <param name="overwrite">Should overwrite index</param>
public Task <string> PutIndexAsync(string name, IndexDefinition indexDef, bool overwrite)
{
string requestUri = url + "/indexes/" + name;
var webRequest = (HttpWebRequest)WebRequest.Create(requestUri);
AddOperationHeaders(webRequest);
webRequest.Method = "HEAD";
webRequest.Credentials = credentials;
return(webRequest.GetResponseAsync()
.ContinueWith(task =>
{
try
{
task.Result.Close();
if (overwrite == false)
{
throw new InvalidOperationException("Cannot put index: " + name + ", index already exists");
}
}
catch (WebException e)
{
var response = e.Response as HttpWebResponse;
if (response == null || response.StatusCode != HttpStatusCode.NotFound)
{
throw;
}
}
var request = HttpJsonRequest.CreateHttpJsonRequest(this, requestUri, "PUT", credentials, convention);
request.AddOperationHeaders(OperationsHeaders);
var serializeObject = JsonConvert.SerializeObject(indexDef, new JsonEnumConverter());
byte[] bytes = Encoding.UTF8.GetBytes(serializeObject);
return Task.Factory.FromAsync(request.BeginWrite, request.EndWrite, bytes, null)
.ContinueWith(writeTask => Task.Factory.FromAsync <string>(request.BeginReadResponseString, request.EndReadResponseString, null)
.ContinueWith(readStrTask =>
{
var obj = new { index = "" };
obj = JsonConvert.DeserializeAnonymousType(readStrTask.Result, obj);
return obj.index;
})).Unwrap();
}).Unwrap());
}
public static HttpJsonRequest ToJsonRequest(this string url, object requestor, ICredentials credentials, Document.DocumentConvention convention)
{
return(HttpJsonRequest.CreateHttpJsonRequest(requestor, url, "GET", credentials, convention));
}
