public void It_can_populate_an_albums_view_query_response_of_strings()
{
var response = new ViewQueryResponse <string[]>();
SUT.PopulateViewQueryResponse(response, JsonTestData.ViewQueryAlbums.AsStream());
response.RowCount.Should().Be(4);
response.Rows[0].Id.Should().Be("1");
response.Rows[0].Key.Should().Be("Fake artist 1");
response.Rows[0].Value.Length.Should().Be(1);
response.Rows[0].Value[0].Should().Be("{\"name\":\"Greatest fakes #1\"}");
response.Rows[1].Id.Should().Be("2");
response.Rows[1].Key.Should().Be("Fake artist 2");
response.Rows[1].Value.Length.Should().Be(2);
response.Rows[1].Value[0].Should().Be("{\"name\":\"Greatest fakes #2.1\"}");
response.Rows[1].Value[1].Should().Be("{\"name\":\"Greatest fakes #2.2\"}");
response.Rows[2].Id.Should().Be("3");
response.Rows[2].Key.Should().Be("Fake artist 3");
response.Rows[2].Value.Length.Should().Be(3);
response.Rows[2].Value[0].Should().Be("{\"name\":\"Greatest fakes #3.1\"}");
response.Rows[2].Value[1].Should().Be("{\"name\":\"Greatest fakes #3.2\"}");
response.Rows[2].Value[2].Should().Be("{\"name\":\"Greatest fakes #3.3\"}");
response.Rows[3].Id.Should().Be("4");
response.Rows[3].Key.Should().Be("Fake artist 4");
response.Rows[3].Value.Length.Should().Be(4);
response.Rows[3].Value[0].Should().Be("{\"name\":\"Greatest fakes #4.1\"}");
response.Rows[3].Value[1].Should().Be("{\"name\":\"Greatest fakes #4.2\"}");
response.Rows[3].Value[2].Should().Be("{\"name\":\"Greatest fakes #4.3\"}");
response.Rows[3].Value[3].Should().Be("{\"name\":\"Greatest fakes #4.4\"}");
}
public async Task <IEnumerable <T> > GetDocuments <T>(string documentType)
{
using (var client = new MyCouchClient(DbConnectionInfo))
{
var viewQuery = new QueryViewRequest(SystemViewIdentity.AllDocs)
.Configure(q => q.Reduce(false)
.IncludeDocs(true)
.StartKey(documentType)
.EndKey($"{documentType}{HighestUnicodeChar}"));
ViewQueryResponse result = await client.Views.QueryAsync(viewQuery);
if (!result.IsSuccess)
{
_logger.Error($"unable to find documents for type: {documentType} - error: {result.Reason}");
return(default(IEnumerable <T>));
}
var results = new List <T>();
foreach (var responseRow in result.Rows)
{
var resultRow = JsonConvert.DeserializeObject <T>(responseRow.IncludedDoc);
results.Add(resultRow);
}
return(results);
}
}
public async Task GetAllTest()
{
var client = new MyCouchClient("http://127.0.0.1:5984", "transactions");
var queryViewRequest = new QueryViewRequest("query", "all").Configure(query => query.IncludeDocs(true));
var response = new ViewQueryResponse <Transaction>();
try
{
response = await client.Views.QueryAsync <Transaction>(queryViewRequest);
var transactions = response
.Rows
.Select(row => (Transaction)JsonConvert.DeserializeObject(row.IncludedDoc, typeof(Transaction))) // iad to resort to this, freakin framework works finicky
.ToList();
var list = new List <string>();
foreach (var transaction in transactions)
{
if (transaction.PositionId == null)
{
transaction.PositionId = "0";
}
var json = JsonConvert.SerializeObject(transaction);
list.Add(json);
}
var t = await client.Documents.BulkAsync(new BulkRequest().Include(list.ToArray()));
}
catch (Exception e)
{
}
}
public virtual void PopulateViewQueryResponse <T>(ViewQueryResponse <T> response, Stream data) where T : class
{
var mappings = new Dictionary <string, Action <JsonTextReader> >
{
{ "total_rows", jr => response.TotalRows = (long)jr.Value },
{ "update_seq", jr => response.UpdateSeq = (long)jr.Value },
{ "offset", jr => response.OffSet = (long)jr.Value },
{ "rows", jr =>
{
if (response is ViewQueryResponse <string> )
{
response.Rows = YieldViewQueryRowsOfString(jr).ToArray() as ViewQueryResponse <T> .Row[];
}
else if (response is ViewQueryResponse <string[]> )
{
response.Rows = YieldViewQueryRowsOfStrings(jr).ToArray() as ViewQueryResponse <T> .Row[];
}
else
{
response.Rows = InternalSerializer.Deserialize <ViewQueryResponse <T> .Row[]>(jr); //TODO: Do as with string[]
}
} },
};
Map(data, mappings);
}
public void It_can_populate_an_albums_view_query_response_of_albums()
{
var response = new ViewQueryResponse <Album[]>();
SUT.PopulateViewQueryResponse(response, JsonTestData.ViewQueryAlbums.AsStream());
response.RowCount.Should().Be(4);
response.Rows[0].Id.Should().Be("1");
response.Rows[0].Key.Should().Be("Fake artist 1");
response.Rows[0].Value.Length.Should().Be(1);
CustomAsserts.AreValueEqual(TestData.Artists.Artist1.Albums, response.Rows[0].Value);
response.Rows[1].Id.Should().Be("2");
response.Rows[1].Key.Should().Be("Fake artist 2");
response.Rows[1].Value.Length.Should().Be(2);
CustomAsserts.AreValueEqual(TestData.Artists.Artist2.Albums, response.Rows[1].Value);
response.Rows[2].Id.Should().Be("3");
response.Rows[2].Key.Should().Be("Fake artist 3");
response.Rows[2].Value.Length.Should().Be(3);
CustomAsserts.AreValueEqual(TestData.Artists.Artist3.Albums, response.Rows[2].Value);
response.Rows[3].Id.Should().Be("4");
response.Rows[3].Key.Should().Be("Fake artist 4");
response.Rows[3].Value.Length.Should().Be(4);
CustomAsserts.AreValueEqual(TestData.Artists.Artist4.Albums, response.Rows[3].Value);
}
public virtual async Task MaterializeAsync <TValue, TIncludedDoc>(ViewQueryResponse <TValue, TIncludedDoc> response, HttpResponseMessage httpResponse)
{
response.ETag = httpResponse.Headers.GetETag();
using (var content = await httpResponse.Content.ReadAsStreamAsync().ForAwait())
Serializer.Populate(response, content);
}
public void Delete()
{
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;
var bulkRequest = new BulkRequest()
{
AllOrNothing = false
};
foreach (var resultsRow in results.Rows)
{
BookOrderDto dto = JsonConvert.DeserializeObject <BookOrderDto>(
resultsRow.IncludedDoc);
bulkRequest.Delete(dto._id, dto._rev);
Console.WriteLine($"Delete request for id:{dto._id}");
}
client.Documents.BulkAsync(bulkRequest).Wait();
}
}
public virtual async void Materialize <TValue, TIncludedDoc>(ViewQueryResponse <TValue, TIncludedDoc> response, HttpResponseMessage httpResponse)
{
using (var content = await httpResponse.Content.ReadAsStreamAsync().ForAwait())
{
Serializer.Populate(response, content);
}
}
async Task <ViewQueryResponse <string> > GetPersonListAsync()
{
List <MyPerson> database = new List <MyPerson>();
string sourceDirectory = @"/Users/chrisk/source/KiwiRest/RestFiles/App_Data/files";
AfisEngine Afis = new AfisEngine();
DateTime date1 = DateTime.Now;
Console.WriteLine("Starting PersonList: " + date1);
WebClient client = new WebClient();
string uri = "http://localhost:5984/prints/_all_docs&include_docs=true";
// string data = client.DownloadString (uri);
// var fromJson = JsonSerializer.DeserializeFromString<AllDocs>(data);
var myCouchClient = new MyCouch.MyCouchClient("http://localhost:5984/prints");
ViewQueryResponse <string> result = null;
try
{
var queryView = new QueryViewRequest("_all_docs");
queryView.Configure(query => query
.IncludeDocs(true));
result = await myCouchClient.Views.QueryAsync <string>(queryView);
}
catch (Exception e) {
}
return(result);
}
private async void DeleteButton_Click(object sender, RoutedEventArgs e)
{
using (var store = new MyCouchStore("http://*****:*****@localhost:5984", "tv-series"))
{
//Delete a document using user given ID
await store.DeleteAsync(SearchIDTxt.Text);
SearchIDTxt.Clear();
ReadTxt.Clear();
SearchIDTxt.IsEnabled = true;
MessageBox.Show("Document Successfully Deleted", "TV-Series", MessageBoxButton.OK, MessageBoxImage.Exclamation);
}
// Refreshes the number of tv-serie documents when one is removed.
using (var client = new MyCouchClient("http://*****:*****@localhost:5984", "tv-series"))
{
var personQuery = new QueryViewRequest("series", "CountNoTvSeries").Configure(query2 => query2
.Reduce(false));
ViewQueryResponse result2 = await client.Views.QueryAsync(personQuery);
NoTvSeriesTxt.Text = result2.RowCount.ToString();
}
}
private async void CreateButton_Click(object sender, RoutedEventArgs e)
{
using (var client = new MyCouchClient("http://*****:*****@localhost:5984", "tv-series"))
{
//POST (create) with server generated id & Rev
await client.Documents.PostAsync("{\"title\": \"" + TitleText.Text + "\", \"creator\":\"" + CreatorTxt.Text + "\",\"stars\":\"" + StarsTxt.Text +
"\",\"seasons\":\"" + SeasonsTxt.Text + "\",\"mpa_rating\":\"" + MPARatingTxt.Text + "\",\"imbd_rating\":\"" + IMBDRatingTxt.Text + "/10\"}");
MessageBox.Show("Document Successfully Created", "TV-Series", MessageBoxButton.OK, MessageBoxImage.Information);
// Clears all text boxes when a document is created.
TitleText.Clear();
CreatorTxt.Clear();
StarsTxt.Clear();
SeasonsTxt.Clear();
MPARatingTxt.Clear();
IMBDRatingTxt.Clear();
// Refreshes the number of tv-serie documents when one is created.
var personQuery = new QueryViewRequest("series", "CountNoTvSeries").Configure(query2 => query2
.Reduce(false));
ViewQueryResponse result2 = await client.Views.QueryAsync(personQuery);
NoTvSeriesTxt.Text = result2.RowCount.ToString();
}
}
protected async virtual void OnSuccessfulResponse <TValue, TIncludedDoc>(ViewQueryResponse <TValue, TIncludedDoc> response, HttpResponseMessage httpResponse)
{
using (var content = await httpResponse.Content.ReadAsStreamAsync().ForAwait())
{
EntitySerializer.Populate(response, content);
}
}
public async Task <IEnumerable <T> > GetDocuments <T>(string designdoc, string viewName, Dictionary <string, object> customParams)
{
using (var client = new MyCouchClient(DbConnectionInfo))
{
var viewQuery = new QueryViewRequest(designdoc, viewName);
viewQuery.CustomQueryParameters = customParams;
ViewQueryResponse result = await client.Views.QueryAsync(viewQuery);
if (!result.IsSuccess)
{
_logger.Error($"unable to execute view: {viewName} - error: {result.Reason}");
return(new List <T>());
}
var results = new List <T>();
foreach (var responseRow in result.Rows)
{
var resultRow = JsonConvert.DeserializeObject <T>(responseRow.IncludedDoc);
if (resultRow is ISoftDelete && (resultRow as ISoftDelete).IsDeleted)
{
continue;
}
results.Add(resultRow);
}
return(results);
}
}
public IEnumerable <BookOrder> GetBySupplier(string supplier, BookOrderState state)
{
List <BookOrder> bookOrders = new List <BookOrder>();
using (var client = new MyCouchClient(_databaseUri, _databaseName))
{
QueryViewRequest request = new QueryViewRequest(
"bookorders", "bysupplier");
request.Configure(parameters => parameters
.Key(supplier)
.IncludeDocs(false));
ViewQueryResponse <string> docIdsBySupplier =
client.Views.QueryAsync <string>(request).Result;
if (docIdsBySupplier.IsEmpty)
{
return(Enumerable.Empty <BookOrder>());
}
QueryViewRequest request2 = new QueryViewRequest(
"bookorders", "bystate");
request2.Configure(parameters => parameters
.Key(state)
.IncludeDocs(false));
ViewQueryResponse <string> docIdsByState =
client.Views.QueryAsync <string>(request2).Result;
if (docIdsByState.IsEmpty)
{
return(Enumerable.Empty <BookOrder>());
}
var docIds = docIdsBySupplier.Rows.Select(x => x.Id)
.Intersect(docIdsByState.Rows.Select(x => x.Id));
var request3 = new QueryViewRequest("_all_docs");
request3.Configure(parameters => parameters
.Keys(docIds.ToArray())
.IncludeDocs(true));
var results =
client.Views.QueryAsync <string>(request3).Result;
if (results.IsEmpty)
{
return(Enumerable.Empty <BookOrder>());
}
foreach (var resultsRow in results.Rows)
{
BookOrderDto dto = JsonConvert.DeserializeObject <BookOrderDto>(
resultsRow.IncludedDoc);
bookOrders.Add(BookOrderMapper.MapFrom(dto));
}
}
return(bookOrders);
}
/// <summary>
/// Calls Map Reduce
/// </summary>
/// <returns></returns>
private async Task viewTempsAsync()
{
using (var client = new MyCouchClient(dbConnect, "weatherapp"))
{
var query = new QueryViewRequest("_design/viewAllTemp");
ViewQueryResponse <string> response = await client.Views.QueryAsync(query);
MessageBox.Show(response.ToString());
}
}
private async void MainWindow_Loaded(object sender, RoutedEventArgs e)
{
/* Query / map reduce for counting the number of tv series documents.
* This is so that the number of tv-serie documents is shown when the program is opened
*/
//Connecting to the database / fauxton using MyCouch
using (var client = new MyCouchClient("http://*****:*****@localhost:5984", "tv-series"))
{
var personQuery = new QueryViewRequest("series", "CountNoTvSeries").Configure(query2 => query2
.Reduce(false));
ViewQueryResponse result2 = await client.Views.QueryAsync(personQuery);
NoTvSeriesTxt.Text = result2.RowCount.ToString();
}
}
public void It_can_populate_an_all_docs_view_query_response_of_string()
{
var response = new ViewQueryResponse <string>();
SUT.PopulateViewQueryResponse(response, JsonTestData.ViewQueryAllDocsResult.AsStream());
response.RowCount.Should().Be(2);
response.Rows[0].Id.Should().Be("1");
response.Rows[0].Key.Should().Be("1");
response.Rows[0].Value.Should().Be("{\"rev\":\"43-4886b6a3da60a647adea18b1c6c81cd5\"}");
response.Rows[1].Id.Should().Be("2");
response.Rows[1].Key.Should().Be("2");
response.Rows[1].Value.Should().Be("{\"rev\":\"42-e7620ba0ea71c48f6a11bacee4999d79\"}");
}
private static async void BulkDelete(IMyCouchClient client, ViewQueryResponse <dynamic> response)
{
if (response.IsEmpty)
{
return;
}
var bulkRequest = new BulkRequest();
foreach (var row in response.Rows)
{
bulkRequest.Delete(row.Id, row.Value.rev.ToString());
}
await client.Documents.BulkAsync(bulkRequest).ForAwait();
}
public async Task GetAllTest()
{
var client = new MyCouchClient("https://*****:*****@tradeasdb.southeastasia.cloudapp.azure.com:6984", "tradeas");
//var client = new MyCouchClient("http://127.0.0.1:5984", "brokers");
//var temp = new MyCouchClient("http://127.0.0.1:5984", "brokers-temp");
while (true)
{
var queryViewRequest = new QueryViewRequest("query", "new-view").Configure(query =>
query.IncludeDocs(true)
.Limit(1000));
var response = new ViewQueryResponse <Models.BrokerTransaction>();
try
{
response = await client.Views.QueryAsync <Models.BrokerTransaction>(queryViewRequest);
var transactions = response
.Rows
.Select(row => row.Value)
.ToList();
if (response.Rows.Length <= 0)
{
break;
}
var list = new List <string>();
foreach (var transaction in transactions)
{
// transaction.Code = transaction.Id;
// transaction.Id += "-broker";
// transaction.Rev = null;
//var json = JsonConvert.SerializeObject(new BrokerJson(transaction));
// list.Add(json);
//temp.Documents.PutAsync(null, null)
var a = client.Documents.DeleteAsync(transaction.Id, transaction.Rev);
}
var t = await client.Documents.BulkAsync(new BulkRequest().Include(list.ToArray()));
}
catch (Exception e)
{
}
}
}
public void It_can_populate_an_all_docs_view_query_response_of_dictionary()
{
var response = new ViewQueryResponse <IDictionary <string, object> >();
SUT.PopulateViewQueryResponse(response, JsonTestData.ViewQueryAllDocsResult.AsStream());
response.RowCount.Should().Be(2);
response.Rows[0].Id.Should().Be("1");
response.Rows[0].Key.Should().Be("1");
string rev1 = response.Rows[0].Value["rev"].ToString();
rev1.Should().Be("43-4886b6a3da60a647adea18b1c6c81cd5");
response.Rows[1].Id.Should().Be("2");
response.Rows[1].Key.Should().Be("2");
string rev2 = response.Rows[1].Value["rev"].ToString();
rev2.Should().Be("42-e7620ba0ea71c48f6a11bacee4999d79");
}
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>());
}
}
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 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>()));
}
}
private static void BulkDelete(IMyCouchClient client, ViewQueryResponse <dynamic> response)
{
if (response.IsEmpty)
{
return;
}
var bulkRequest = new BulkRequest();
foreach (var row in response.Rows)
{
if (row.Id.ToLower() == "_design/_replicator")
{
continue;
}
bulkRequest.Delete(row.Id, row.Value.rev.ToString());
}
if (!bulkRequest.IsEmpty)
{
client.Documents.BulkAsync(bulkRequest).Wait();
}
}
private static void BulkDelete(IMyCouchClient client, ViewQueryResponse<dynamic> response)
{
if (response.IsEmpty)
return;
var bulkRequest = new BulkRequest();
foreach (var row in response.Rows)
{
if (row.Id.ToLower() == "_design/_replicator")
continue;
bulkRequest.Delete(row.Id, row.Value.rev.ToString());
}
if(!bulkRequest.IsEmpty)
client.Documents.BulkAsync(bulkRequest).Wait();
}
public static ViewQueryResponseAssertions <T, TIncludedDoc> Should <T, TIncludedDoc>(this ViewQueryResponse <T, TIncludedDoc> response)
{
return(new ViewQueryResponseAssertions <T, TIncludedDoc>(response));
}
public static ViewQueryResponseAssertions <T> Should <T>(this ViewQueryResponse <T> response)
{
return(new ViewQueryResponseAssertions <T>(response));
}
public static ViewQueryResponseAssertions Should(this ViewQueryResponse response)
{
return(new ViewQueryResponseAssertions(response));
}
public ViewQueryResponseAssertions(ViewQueryResponse response)
: base(response)
{
}
protected virtual void OnSuccessfulViewQueryResponseContentMaterializer <T>(HttpResponseMessage response, ViewQueryResponse <T> result) where T : class
{
using (var content = response.Content.ReadAsStream())
ResponseMaterializer.PopulateViewQueryResponse(result, content);
}
public QueryResult(ViewQueryResponse <T, T> result)
{
TotalRows = result.TotalRows;
Offset = result.OffSet;
Rows = result.Rows.Select(r => r.IncludedDoc);
}
