/// <summary>
/// Returns <see cref="QueryViewRequest.Keys"/> as compatible JSON document for use e.g.
/// with POST of keys against views.
/// </summary>
/// <returns></returns>
protected virtual string GetKeysAsJsonObject(QueryViewRequest query)
{
if (!query.HasKeys)
return "{}";
return string.Format("{{\"keys\":[{0}]}}",
string.Join(",", query.Keys.Select(k => FormatValue(k))));
}
public virtual HttpRequest Create(QueryViewRequest request)
{
Ensure.That(request, "request").IsNotNull();
return request.HasKeys
? CreateFor<QueryViewRequest>(HttpMethod.Post, GenerateRequestUrl(request)).SetContent(GetKeysAsJsonObject(request))
: CreateFor<QueryViewRequest>(HttpMethod.Get, GenerateRequestUrl(request));
}
/// <summary>
/// Returns all configured options of <see cref="QueryViewRequest"/> as key values.
/// The values are formatted to JSON-compatible strings.
/// </summary>
/// <returns></returns>
protected virtual IDictionary<string, string> ConvertRequestToJsonCompatibleKeyValues(QueryViewRequest request)
{
var kvs = new Dictionary<string, string>();
if (request.IncludeDocs.HasValue)
kvs.Add(KeyNames.IncludeDocs, request.IncludeDocs.Value.ToString().ToLower());
if (request.Descending.HasValue)
kvs.Add(KeyNames.Descending, request.Descending.Value.ToString().ToLower());
if (request.Reduce.HasValue)
kvs.Add(KeyNames.Reduce, request.Reduce.Value.ToString().ToLower());
if (request.InclusiveEnd.HasValue)
kvs.Add(KeyNames.InclusiveEnd, request.InclusiveEnd.Value.ToString().ToLower());
if (request.UpdateSeq.HasValue)
kvs.Add(KeyNames.UpdateSeq, request.UpdateSeq.Value.ToString().ToLower());
if (request.Group.HasValue)
kvs.Add(KeyNames.Group, request.Group.Value.ToString().ToLower());
if (request.GroupLevel.HasValue)
kvs.Add(KeyNames.GroupLevel, request.GroupLevel.Value.ToString(MyCouchRuntime.NumberFormat));
if (request.Stale.HasValue)
kvs.Add(KeyNames.Stale, request.Stale.Value.AsString());
if (HasValue(request.Key))
kvs.Add(KeyNames.Key, FormatValue(request.Key));
if (HasValue(request.Keys))
kvs.Add(KeyNames.Keys, FormatValues(request.Keys));
if (HasValue(request.StartKey))
kvs.Add(KeyNames.StartKey, FormatValue(request.StartKey));
if (HasValue(request.StartKeyDocId))
kvs.Add(KeyNames.StartKeyDocId, FormatValue(request.StartKeyDocId));
if (HasValue(request.EndKey))
kvs.Add(KeyNames.EndKey, FormatValue(request.EndKey));
if (HasValue(request.EndKeyDocId))
kvs.Add(KeyNames.EndKeyDocId, FormatValue(request.EndKeyDocId));
if (request.Limit.HasValue)
kvs.Add(KeyNames.Limit, request.Limit.Value.ToString(MyCouchRuntime.NumberFormat));
if (request.Skip.HasValue)
kvs.Add(KeyNames.Skip, request.Skip.Value.ToString(MyCouchRuntime.NumberFormat));
return kvs;
}
protected virtual string GenerateRequestUrl(QueryViewRequest request)
{
if (request is QuerySystemViewRequest)
{
return string.Format("{0}/{1}{2}",
Connection.Address,
request.ViewIdentity.Name,
GenerateQueryString(request));
}
return string.Format("{0}/_design/{1}/_view/{2}{3}",
Connection.Address,
request.ViewIdentity.DesignDocument,
request.ViewIdentity.Name,
GenerateQueryString(request));
}
/// <summary>
/// Gets the idea open status.
/// </summary>
/// <returns>The idea open status.</returns>
public async Task <Result> GetIdeasOpenStatus()
{
var queryViewRequest = new QueryViewRequest("ideas", "status").Configure(c => c.Key("open").IncludeDocs(true));
var response = await Views.QueryAsync <Idea>(queryViewRequest)
as ViewQueryResponse <Idea>;
var ideas = response.Rows.Select(row => (Idea)JsonConvert.DeserializeObject(row.IncludedDoc, typeof(Idea)));
var taskResult = new TaskResult
{
IsSuccessful = true,
Messages = new List <string>
{
response.Error,
response.Reason
}
};
taskResult.SetData(ideas.ToList());
return(taskResult);
}
// List all
public async Task <GetMovies> GetList()
{
using (var client = new MyCouchClient(host, db))
{
// View
var req = new QueryViewRequest("search", "all");
var result = await client.Views.QueryAsync <Movie>(req);
var movies = result.Rows.Select
(
x => new Movie(x.Id, x.Value.Title,
x.Value.Summary, x.Value.InTheaters,
x.Value.Trailer, x.Value.ReleaseDate,
x.Value.Poster)
).ToList();
return(new GetMovies(result.IsSuccess, result.RowCount, movies));
}
}
public virtual async Task <QueryInfo> GetValueByKeysAsync <TValue>(ViewIdentity view, object[] keys, Action <TValue> onResult) where TValue : class
{
ThrowIfDisposed();
EnsureArg.IsNotNull(view, nameof(view));
EnsureArg.HasItems(keys, nameof(keys));
EnsureArg.IsNotNull(onResult, nameof(onResult));
var request = new QueryViewRequest(view).Configure(r => r.Keys(keys));
var response = await Client.Views.QueryAsync <TValue>(request).ForAwait();
ThrowIfNotSuccessfulResponse(response);
foreach (var row in response.Rows.Where(r => r.Value != null))
{
onResult(row.Value);
}
return(CreateQueryInfoFrom(response));
}
public async virtual Task <QueryInfo> GetIncludedDocByKeysAsync <TIncludedDoc>(ViewIdentity view, object[] keys, Action <TIncludedDoc> onResult) where TIncludedDoc : class
{
ThrowIfDisposed();
Ensure.That(view, "view").IsNotNull();
Ensure.That(keys, "keys").HasItems();
Ensure.That(onResult, "onResult").IsNotNull();
var request = new QueryViewRequest(view).Configure(r => r.Keys(keys).IncludeDocs(true));
var response = await Client.Views.QueryAsync <string, TIncludedDoc>(request).ForAwait();
ThrowIfNotSuccessfulResponse(response);
foreach (var row in response.Rows.Where(r => r.IncludedDoc != null))
{
onResult(row.IncludedDoc);
}
return(CreateQueryInfoFrom(response));
}
public async Task <IEnumerable <TEntity> > ListAsync(int?limit = null)
{
using (var client = _couchDb.GetClient())
{
var query = new QueryViewRequest("all", "list");
query.Key = typeof(TEntity).Name.ToLower();
query.Reduce = false;
if (limit.HasValue)
{
query.Limit = limit.Value;
}
var response = await client.Views.QueryAsync <TEntity>(query);
if (response.IsSuccess)
{
return(response.Rows.Select(r => r.Value));
}
throw new CouchDbException(response.Error);
}
}
public virtual async Task <QueryInfo> GetIncludedDocByKeysAsync <TIncludedDoc>(ViewIdentity view, object[] keys, Action <TIncludedDoc> onResult, CancellationToken cancellationToken = default) where TIncludedDoc : class
{
ThrowIfDisposed();
EnsureArg.IsNotNull(view, nameof(view));
EnsureArg.HasItems(keys, nameof(keys));
EnsureArg.IsNotNull(onResult, nameof(onResult));
var request = new QueryViewRequest(view).Configure(r => r.Keys(keys).IncludeDocs(true));
var response = await Client.Views.QueryAsync <string, TIncludedDoc>(request, cancellationToken).ForAwait();
ThrowIfNotSuccessfulResponse(response);
foreach (var row in response.Rows.Where(r => r.IncludedDoc != null))
{
onResult(row.IncludedDoc);
}
return(CreateQueryInfoFrom(response, cancellationToken));
}
private async void GetEveryDoc()
{
dataViewAll.Rows.Clear();
using (var dbClient = new MyCouchClient(link, databaseName))
{
var dbQuery = new QueryViewRequest("_all_docs");
var responseDB = await dbClient.Views.QueryAsync <dynamic>(dbQuery);
dynamic array = responseDB.Rows.ToArray();
foreach (var keyValue in array)
{
dataViewAll.Rows.Add(keyValue.Key.ToString());
MessageBox.Show(keyValue.Key.ToString() + ":" + keyValue.Value.ToString(), "Film Documents IDs", MessageBoxButtons.OK);
}
dataViewAll.AutoResizeColumns();
dataViewAll.AutoResizeRows();
}
}
public async Task <IEnumerable <T> > GetDocumentsById <T>(IEnumerable <string> documentIds)
{
using (var client = new MyCouchClient(DbConnectionInfo))
{
var keys = documentIds.Select(GetFullDocumentId <T>);
var viewQuery = new QueryViewRequest(SystemViewIdentity.AllDocs)
.Configure(q => q.Reduce(false)
.IncludeDocs(true)
.Keys(keys.ToArray()));
ViewQueryResponse result = await client.Views.QueryAsync(viewQuery);
if (!result.IsSuccess)
{
_logger.Debug($"there was an error getting documents - message: {result.Reason}");
}
return(result.Rows.Select(r => r.IncludedDoc).Deserialize <T>());
}
}
/// <summary>
/// Gets the orphan transactions.
/// </summary>
/// <returns>The orphan transactions.</returns>
public async Task<Result> GetOrphanTransactions()
{
var queryViewRequest = new QueryViewRequest("query", "byPositionId").Configure(query => query.IncludeDocs(true));
var response = await Views.QueryAsync<Transaction>(queryViewRequest)
as ViewQueryResponse<Transaction>;
var transactions = response
.Rows
.Select(row => (Transaction) JsonConvert.DeserializeObject(row.IncludedDoc, typeof(Transaction))) // iad to resort to this, freakin framework works finicky
.ToList();
var result = new TaskResult {
IsSuccessful = true,
Messages = new List<string>
{
response.Error,
response.Reason
}}
.SetData(transactions);
return result;
}
public IEnumerable <BookOrder> Get()
{
List <BookOrder> bookOrders = new List <BookOrder>();
using (var client = new MyCouchClient(_databaseUri, _databaseName))
{
QueryViewRequest request = new QueryViewRequest(
"bookorders", "allOrders");
request.Configure(parameters => parameters.IncludeDocs(true));
ViewQueryResponse <string> results =
client.Views.QueryAsync <string>(request).Result;
foreach (var resultsRow in results.Rows)
{
BookOrderDto dto = JsonConvert.DeserializeObject <BookOrderDto>(
resultsRow.IncludedDoc);
bookOrders.Add(BookOrderMapper.MapFrom(dto));
}
}
return(bookOrders);
}
public virtual IObservable <T> GetByIds <T>(params string[] ids) where T : class
{
ThrowIfDisposed();
Ensure.That(ids, "ids").HasItems();
return(Observable.Create <T>(async o =>
{
var request = new QueryViewRequest(SystemViewIdentity.AllDocs).Configure(r => r.Keys(ids).IncludeDocs(true));
var response = await Client.Views.QueryAsync <string, T>(request).ForAwait();
ThrowIfNotSuccessfulResponse(response);
foreach (var row in response.Rows.Where(r => r.IncludedDoc != null))
{
o.OnNext(row.IncludedDoc);
}
o.OnCompleted();
return Disposable.Empty;
}).SubscribeOn(ObservableSubscribeOnScheduler()));
}
public virtual IObservable <DocumentHeader> GetHeaders(string[] ids)
{
ThrowIfDisposed();
Ensure.That(ids, "ids").HasItems();
return(Observable.Create <DocumentHeader>(async o =>
{
var request = new QueryViewRequest(SystemViewIdentity.AllDocs).Configure(r => r.Keys(ids));
var response = await Client.Views.QueryAsync <AllDocsValue>(request).ForAwait();
ThrowIfNotSuccessfulResponse(response);
foreach (var row in response.Rows)
{
o.OnNext(new DocumentHeader(row.Id, row.Value.Rev));
}
o.OnCompleted();
return Disposable.Empty;
}).SubscribeOn(ObservableSubscribeOnScheduler()));
}
public async Task <IEnumerable <TShirt> > GetAll()
{
Task <ViewQueryResponse <TShirt> > tshirtTask;
ViewQueryResponse <TShirt> tshirtResult;
List <TShirt> tshirts = null;
// TODO: inject client or replace client with store
using (var client = new MyCouchClient("http://localhost:5984", "cshirts")) {
var query = new QueryViewRequest("getAllTshirts");
tshirtTask = client.Views.QueryAsync <TShirt>(query);
}
tshirtResult = await tshirtTask;
foreach (var row in tshirtResult.Rows)
{
var tshirt = new TShirt();
tshirt = row.Value;
tshirts.Add(tshirt);
}
Console.WriteLine(tshirts);
return(tshirts);
}
protected virtual string GenerateRelativeUrl(QueryViewRequest request)
{
if (request.ViewIdentity is SystemViewIdentity)
{
return(string.Format("/{0}{1}",
new UrlSegment(request.ViewIdentity.Name),
GenerateRequestUrlQueryString(request)));
}
if (!string.IsNullOrWhiteSpace(request.ListName))
{
return(string.Format("/_design/{0}/_list/{1}/{2}{3}",
new UrlSegment(request.ViewIdentity.DesignDocument),
new UrlSegment(request.ListName),
new UrlSegment(request.ViewIdentity.Name),
GenerateRequestUrlQueryString(request)));
}
return(string.Format("/_design/{0}/_view/{1}{2}",
new UrlSegment(request.ViewIdentity.DesignDocument),
new UrlSegment(request.ViewIdentity.Name),
GenerateRequestUrlQueryString(request)));
}
public Task <IEnumerable <T> > GetDocuments <T>(string documentKey)
{
var validKey = ReplaceInvalidChars(documentKey);
using (var client = new MyCouchClient(DbConnectionInfo))
{
var viewQuery = new QueryViewRequest(SystemViewIdentity.AllDocs)
.Configure(q => q.Reduce(false)
.IncludeDocs(true)
.StartKey(validKey)
.EndKey($"{validKey}{HighestUnicodeChar}"));
ViewQueryResponse result = client.Views.QueryAsync(viewQuery).Result;
if (!result.IsSuccess)
{
_logger.Error($"unable to find documents for type: {validKey} - error: {result.Reason}");
throw new Exception($"unable to find documents for type: {validKey} - error: {result.Reason}");
}
return(Task.FromResult(result.Rows.Select(r => r.IncludedDoc).Deserialize <T>()));
}
}
/// <summary>
/// Bulks the async.
/// </summary>
/// <returns>The async.</returns>
public TaskResult GetAll()
{
var queryViewRequest = new QueryViewRequest("query", "all")
.Configure(c => c.IncludeDocs(true));
var response = Views.QueryAsync <ImportTracker>(queryViewRequest);
if (response.Result.RowCount == 0)
{
var taskResult = new TaskResult {
IsSuccessful = false
};
taskResult.SetData(new List <ImportTracker>());
return(taskResult);
}
var importTrackers = response
.Result
.Rows
.Select(row =>
(ImportTracker)JsonConvert.DeserializeObject(row.IncludedDoc,
typeof(ImportTracker))) // iad to resort to this, freakin framework works finicky
.ToList();
var result = new TaskResult
{
IsSuccessful = true,
Messages = new List <string>
{
response.Result.Error,
response.Result.Reason
}
};
result.SetData(importTrackers);
return(result);
}
public virtual HttpRequest Create(QueryViewRequest request)
{
Ensure.Any.IsNotNull(request, nameof(request));
var httpRequest = request.HasKeys
? new HttpRequest(HttpMethod.Post, GenerateRelativeUrl(request)).SetJsonContent(GenerateRequestBody(request))
: new HttpRequest(HttpMethod.Get, GenerateRelativeUrl(request));
httpRequest.SetRequestTypeHeader(request.GetType());
if (request.HasAccepts)
{
httpRequest.SetAcceptHeader(request.Accepts);
}
else
{
if (!string.IsNullOrWhiteSpace(request.ListName))
{
httpRequest.SetAcceptHeader(HttpContentTypes.Json, HttpContentTypes.Html);
}
}
return(httpRequest);
}
/// <summary>
/// Bulks the async.
/// </summary>
/// <returns>The async.</returns>
public async Task <Result> GetAll()
{
var queryViewRequest = new QueryViewRequest("query", "all")
.Configure(c => c.IncludeDocs(true));
var response = await Views.QueryAsync <Import>(queryViewRequest);
var imports = response
.Rows
.Select(row => row.Value) // iad to resort to this, freakin framework works finicky
.ToList();
var result = new TaskResult
{
IsSuccessful = true,
Messages = new List <string>
{
response.Error,
response.Reason
}
}
.SetData(imports);
return(result);
}
public virtual IObservable <TIncludedDoc> GetIncludedDocByKeys <TIncludedDoc>(ViewIdentity view, params object[] keys) where TIncludedDoc : class
{
ThrowIfDisposed();
Ensure.That(view, "view").IsNotNull();
Ensure.That(keys, "keys").HasItems();
return(Observable.Create <TIncludedDoc>(async o =>
{
var request = new QueryViewRequest(view).Configure(r => r.Keys(keys).IncludeDocs(true));
var response = await Client.Views.QueryAsync <string, TIncludedDoc>(request).ForAwait();
ThrowIfNotSuccessfulResponse(response);
foreach (var row in response.Rows.Where(r => r.IncludedDoc != null))
{
o.OnNext(row.IncludedDoc);
}
o.OnCompleted();
return Disposable.Empty;
}).SubscribeOn(ObservableSubscribeOnScheduler()));
}
protected virtual string GenerateRequestBody(QueryViewRequest request)
{
return(request.HasKeys
? Serializer.Serialize(new { keys = request.Keys })
: "{}");
}
public virtual async Task <ViewQueryResponse <TValue, TIncludedDoc> > QueryAsync <TValue, TIncludedDoc>(QueryViewRequest request, CancellationToken cancellationToken)
{
EnsureThatNoListFunctionIsUsed(request);
var httpRequest = QueryViewHttpRequestFactory.Create(request);
using (var res = await SendAsync(httpRequest, cancellationToken).ForAwait())
return(await ViewQueryResponseFactory.CreateAsync <TValue, TIncludedDoc>(res).ForAwait());
}
public QueryViewRequestConfigurator(QueryViewRequest request)
{
Request = request;
}
protected virtual string GenerateQueryString(QueryViewRequest request)
{
var p = GenerateQueryStringParams(request);
return string.IsNullOrEmpty(p) ? string.Empty : string.Concat("?", p);
}
static void WorkTimerCallback(object state)
{
MyCouchClient couch = (MyCouchClient)state;
List <ADAITask> taskList = new List <ADAITask>();
Console.Write("Getting settings...");
Task <GetEntityResponse <Settings> > settingsTask = couch.Entities.GetAsync <Settings>("settings");
settingsTask.Wait();
Settings settings;
if (settingsTask.Result.IsSuccess)
{
settings = settingsTask.Result.Content;
Console.WriteLine("done");
}
else
{
settings = new Settings();
Console.WriteLine("error - using defaults");
}
Console.WriteLine("Current settings: autoWatch = " + settings.autoWatch);
Console.Write("Polling tasklist...");
QueryViewRequest req = new QueryViewRequest("tasks", "tasks").Configure(q => q.IncludeDocs(true));
Task <ViewQueryResponse <string, ADAITask> > queryTask = couch.Views.QueryAsync <string, ADAITask>(req);
queryTask.Wait();
Console.WriteLine("done - " + queryTask.Result.TotalRows + " tasks fetched");
if (queryTask.Result.TotalRows == 0 && !settings.autoWatch)
{
Console.WriteLine("Finished! Waiting for next polling interval...");
return;
}
Console.Write("Connecting to " + DB + "...");
OracleConnection conn = null;
try
{
conn = new OracleConnection(connString);
conn.Open();
// Open session
OracleCommand cmdOpenSession = new OracleCommand("e.env_session_intf#.open_session", conn);
cmdOpenSession.CommandType = System.Data.CommandType.StoredProcedure;
cmdOpenSession.ExecuteNonQuery();
Console.WriteLine("done");
OracleCommand cmd = new OracleCommand();
cmd.Connection = conn;
cmd.CommandType = System.Data.CommandType.Text;
// Copy task IDs to a list that we then use in an OracleParameter for the IN clause
foreach (ViewQueryResponse <string, ADAITask> .Row row in queryTask.Result.Rows)
{
//taskIdList.Add(row.IncludedDoc.TaskID);
OracleParameter par = new OracleParameter(":t" + cmd.Parameters.Count, OracleDbType.Int32);
par.Value = row.IncludedDoc.TaskID;
cmd.Parameters.Add(par);
}
StringBuilder inClause = new StringBuilder();
foreach (OracleParameter par in cmd.Parameters)
{
inClause.AppendFormat("{0},", par.ParameterName);
}
if (inClause.Length > 0)
{
inClause.Remove(inClause.Length - 1, 1); // Remove trailing comma
}
else
{
inClause.Append("null");
}
StringBuilder q = new StringBuilder();
q.AppendLine("select env_task.id, env_task.name, env_wfc_status.name, env_release.user_id");
q.AppendLine(" from e.env_task, e.env_wfc_status, e.env_release, env_user");
q.AppendLine(" where env_task.env_wfc_status_id = env_wfc_status.id");
q.AppendLine(" and env_task.env_release_id = env_release.id");
q.AppendLine(" and env_task.resp_env_user_id = env_user.id");
q.AppendFormat(" and (env_task.id in ({0})", inClause);
q.AppendLine();
// Also include new tasks not already watched?
if (settings.autoWatch)
{
OracleParameter parUser = new OracleParameter();
parUser.OracleDbType = OracleDbType.Varchar2;
parUser.ParameterName = ":oracle_user";
parUser.Value = username.ToUpper();
cmd.Parameters.Add(parUser);
q.AppendFormat(" or env_user.oracle_user = {0}", parUser.ParameterName);
q.AppendLine();
q.AppendLine(" and env_task.env_wfc_status_id in (2018 /* Integration Test Running */, 2015 /* Ready to Integrate */)");
}
q.AppendLine(")");
cmd.CommandText = q.ToString();
Console.Write("Running query...");
Debug.WriteLine(cmd.CommandText);
OracleDataReader reader = cmd.ExecuteReader();
Console.WriteLine("done");
foreach (ViewQueryResponse <string, ADAITask> .Row row in queryTask.Result.Rows)
{
taskList.Add(row.IncludedDoc);
}
while (reader.Read())
{
ADAITask t = null;
if (taskList.Exists(m => m.TaskID == reader.GetInt32(0)))
{
t = queryTask.Result.Rows.Where(e => e.IncludedDoc.TaskID == reader.GetInt32(0)).Single().IncludedDoc;
}
else
{
t = new ADAITask(reader.GetInt32(0));
taskList.Add(t);
}
t.TaskName = reader.GetString(1);
t.TaskStatus = reader.GetString(2);
t.TaskRelease = reader.GetString(3);
t.LastUpdated = DateTime.Now;
Debug.WriteLine("Task ID: " + t.TaskID + ", Task Name: " + t.TaskName + ", Task Status: " + t.TaskStatus +
", Task Release: " + t.TaskRelease);
}
reader.Close();
}
catch (OracleException e)
{
Console.WriteLine(e.Message);
return;
}
finally
{
if (conn != null)
{
conn.Close();
}
}
MyCouchStore store = new MyCouchStore(couch);
foreach (ADAITask t in taskList)
{
Console.Write("Updating doc for task " + t.TaskID + "...");
Task <ADAITask> storeTask = store.StoreAsync <ADAITask>(t);
storeTask.Wait();
Console.WriteLine("done");
}
Console.WriteLine("Finished! Waiting for next polling interval...");
//GetChangesRequest getChangesRequest = new GetChangesRequest
//{
// Feed = ChangesFeed.Normal
//};
//Task<ChangesResponse> changesTask = store.Client.Changes.GetAsync(getChangesRequest);
//changesTask.Wait();
//changeObserver.SetIgnoreUntilSeqNr(changesTask.Result.LastSeq);
}
/// <summary>
/// Generates <see cref="QueryViewRequest"/> configured values as querystring params.
/// </summary>
/// <remarks><see cref="QueryViewRequest.Keys"/> are not included in this string.</remarks>
/// <returns></returns>
protected virtual string GenerateQueryStringParams(QueryViewRequest request)
{
return string.Join("&", ConvertRequestToJsonCompatibleKeyValues(request)
.Where(kv => kv.Key != KeyNames.Keys)
.Select(kv => string.Format("{0}={1}", kv.Key, Uri.EscapeDataString(kv.Value))));
}
protected virtual void WithHttpRequestFor(QueryViewRequest query, Action <HttpRequestMessage> a)
{
using (var req = SUT.Create(query))
a(req);
}
protected virtual string GenerateRequestUrlQueryString(QueryViewRequest request)
{
var p = GenerateQueryStringParams(request);
return(string.IsNullOrEmpty(p) ? string.Empty : string.Concat("?", p));
}
protected virtual void WithHttpRequestFor(QueryViewRequest query, Action <HttpRequest> a)
{
var req = SUT.Create(query);
a(req);
}
protected virtual string GenerateQueryStringParams(QueryViewRequest request)
{
return(string.Join("&", GenerateJsonCompatibleKeyValues(request)
.Select(kv => string.Format("{0}={1}", kv.Key, UrlParam.Encode(kv.Value)))));
}
/// <summary>
/// Returns all configured options of <see cref="QueryViewRequest"/> as key values.
/// The values are formatted to JSON-compatible strings.
/// </summary>
/// <returns></returns>
protected virtual IDictionary <string, string> GenerateJsonCompatibleKeyValues(QueryViewRequest request)
{
var kvs = new Dictionary <string, string>();
if (request.IncludeDocs.HasValue)
{
kvs.Add(KeyNames.IncludeDocs, Serializer.ToJson(request.IncludeDocs.Value));
}
if (request.Descending.HasValue)
{
kvs.Add(KeyNames.Descending, Serializer.ToJson(request.Descending.Value));
}
if (request.Reduce.HasValue)
{
kvs.Add(KeyNames.Reduce, Serializer.ToJson(request.Reduce.Value));
}
if (request.InclusiveEnd.HasValue)
{
kvs.Add(KeyNames.InclusiveEnd, Serializer.ToJson(request.InclusiveEnd.Value));
}
if (request.UpdateSeq.HasValue)
{
kvs.Add(KeyNames.UpdateSeq, Serializer.ToJson(request.UpdateSeq.Value));
}
if (request.Group.HasValue)
{
kvs.Add(KeyNames.Group, Serializer.ToJson(request.Group.Value));
}
if (request.GroupLevel.HasValue)
{
kvs.Add(KeyNames.GroupLevel, Serializer.ToJson(request.GroupLevel.Value));
}
if (request.Stale.HasValue)
{
kvs.Add(KeyNames.Stale, request.Stale.Value.AsString());
}
if (request.Key != null)
{
kvs.Add(KeyNames.Key, Serializer.ToJson(request.Key));
}
if (request.StartKey != null)
{
kvs.Add(KeyNames.StartKey, Serializer.ToJson(request.StartKey));
}
if (!string.IsNullOrWhiteSpace(request.StartKeyDocId))
{
kvs.Add(KeyNames.StartKeyDocId, request.StartKeyDocId);
}
if (request.EndKey != null)
{
kvs.Add(KeyNames.EndKey, Serializer.ToJson(request.EndKey));
}
if (!string.IsNullOrWhiteSpace(request.EndKeyDocId))
{
kvs.Add(KeyNames.EndKeyDocId, request.EndKeyDocId);
}
if (request.Limit.HasValue)
{
kvs.Add(KeyNames.Limit, Serializer.ToJson(request.Limit.Value));
}
if (request.Skip.HasValue)
{
kvs.Add(KeyNames.Skip, Serializer.ToJson(request.Skip.Value));
}
if (request.HasCustomQueryParameters)
{
foreach (var param in request.CustomQueryParameters)
{
kvs.Add(param.Key, param.Value.ToStringExtended());
}
}
return(kvs);
}
public QueryViewRequestConfiguratorTests()
{
_request = new QueryViewRequest("foodesigndocument", "barviewname");
SUT = new QueryViewRequestConfigurator(_request);
}
public virtual async Task <ViewQueryResponse <TValue, TIncludedDoc> > QueryAsync <TValue, TIncludedDoc>(QueryViewRequest request)
{
using (var httpRequest = CreateHttpRequest(request))
{
using (var res = await SendAsync(httpRequest).ForAwait())
{
return(ProcessHttpResponse <TValue, TIncludedDoc>(res));
}
}
}
