public async Task <Response> GetDocument(GetDocumentRequest request)
{
Response response = new GetDocumentResponseInvalidDocID(request);
if (_dal.isDocExists(request.DocID))
{
try
{
DataSet ds = _dal.GetDocument(request.DocID);
var docData = ds.Tables[0].Rows[0];
var doc = new Document();
doc.DocID = (string)docData["DOC_ID"];
doc.UserID = (string)docData["USER_ID"];
doc.DocumentName = (string)docData["DOCUMENT_NAME"];
doc.ImageURL = (string)docData["IMAGE_URL"];
response = new GetDocumentResponseOK(doc);
}
catch (Exception ex)
{
response = new AppResponseError(ex.Message);
}
}
return(response);
}
/// <summary>
/// Gets the contents of the specified configuration document.
/// </summary>
/// <param name="name">The name of the configuration document.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
///
/// <returns>The response from the GetDocument service method, as returned by SimpleSystemsManagement.</returns>
/// <exception cref="Amazon.SimpleSystemsManagement.Model.InternalServerErrorException">
/// An error occurred on the server side.
/// </exception>
/// <exception cref="Amazon.SimpleSystemsManagement.Model.InvalidDocumentException">
/// The configuration document is not valid.
/// </exception>
public Task <GetDocumentResponse> GetDocumentAsync(string name, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var request = new GetDocumentRequest();
request.Name = name;
return(GetDocumentAsync(request, cancellationToken));
}
public Document GetDocument(String documentName, String collectionID = "GrpcTestData")
{
var getDocumentRequest = new GetDocumentRequest();
getDocumentRequest.Name = Parent + "/documents/" + collectionID + "/" + documentName;
Document retDoc;
try
{
retDoc = FsClient.GetDocument(getDocumentRequest);
}
catch (Grpc.Core.RpcException e)
{
if (e.Status.StatusCode == Grpc.Core.StatusCode.NotFound)
{
// FirestoreTestUtils.ColoredConsoleWrite(ConsoleColor.Red, "ERROR: Document " + documentName + " not found!");
throw e;
}
else
{
Console.WriteLine("{0} Exception caught.", e);
}
throw e;
}
catch (Exception e)
{
Console.WriteLine("{0} Exception caught.", e);
throw e;
}
return(retDoc);
}
public void GetDocumentRequestObject()
{
moq::Mock <Firestore.FirestoreClient> mockGrpcClient = new moq::Mock <Firestore.FirestoreClient>(moq::MockBehavior.Strict);
GetDocumentRequest request = new GetDocumentRequest
{
Name = "projects/test/databases/test/documents/name1c9368b0",
Mask = new DocumentMask(),
Transaction = proto::ByteString.CopyFromUtf8("transaction6ab7d5f4"),
ReadTime = new wkt::Timestamp(),
};
Document expectedResponse = new Document
{
Name = "name1c9368b0",
Fields =
{
{
"key8a0b6e3c",
new Value()
},
},
CreateTime = new wkt::Timestamp(),
UpdateTime = new wkt::Timestamp(),
};
mockGrpcClient.Setup(x => x.GetDocument(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
FirestoreClient client = new FirestoreClientImpl(mockGrpcClient.Object, null);
Document response = client.GetDocument(request);
xunit::Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
internal GetDocumentResponse GetDocument(GetDocumentRequest request)
{
var marshaller = new GetDocumentRequestMarshaller();
var unmarshaller = GetDocumentResponseUnmarshaller.Instance;
return(Invoke <GetDocumentRequest, GetDocumentResponse>(request, marshaller, unmarshaller));
}
public async stt::Task GetDocumentRequestObjectAsync()
{
moq::Mock <Firestore.FirestoreClient> mockGrpcClient = new moq::Mock <Firestore.FirestoreClient>(moq::MockBehavior.Strict);
GetDocumentRequest request = new GetDocumentRequest
{
Name = "projects/test/databases/test/documents/name1c9368b0",
Mask = new DocumentMask(),
Transaction = proto::ByteString.CopyFromUtf8("transaction6ab7d5f4"),
ReadTime = new wkt::Timestamp(),
};
Document expectedResponse = new Document
{
Name = "name1c9368b0",
Fields =
{
{
"key8a0b6e3c",
new Value()
},
},
CreateTime = new wkt::Timestamp(),
UpdateTime = new wkt::Timestamp(),
};
mockGrpcClient.Setup(x => x.GetDocumentAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <Document>(stt::Task.FromResult(expectedResponse), null, null, null, null));
FirestoreClient client = new FirestoreClientImpl(mockGrpcClient.Object, null);
Document responseCallSettings = await client.GetDocumentAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
xunit::Assert.Same(expectedResponse, responseCallSettings);
Document responseCancellationToken = await client.GetDocumentAsync(request, st::CancellationToken.None);
xunit::Assert.Same(expectedResponse, responseCancellationToken);
mockGrpcClient.VerifyAll();
}
public async Task <Response> GetDocument(GetDocumentRequest request)
{
Response retval = new GetDocumentResponseInvalidDocID(request);
if (_dal.IsDocumentExists(_conn, request.DocId))
{
try
{
DataSet ds = _dal.GetDocument(_conn, request.DocId);
var data = ds.Tables[0].Rows[0];
Document doc = new Document()
{
DocID = (string)data["document_id"],
DocumentName = (string)data["document_name"],
ImageURL = (string)data["image_url"],
UserID = (string)data["user_id"]
};
retval = new GetDocumentResponseOK(doc);
}
catch
{
retval = new AppResponseError("Error in get document");
}
}
return(retval);
}
public override Task <GetDocumentResponse> GetDocument(GetDocumentRequest request, ServerCallContext context)
{
_logger.LogInformation("GetDocumentRequest: " + request.ToString());
switch (request.DocumentIdCase)
{
case GetDocumentRequest.DocumentIdOneofCase.CiklinId:
{
var ciklinId = request.CiklinId;
var matchedDocument = _indexHolder
.GetIndex()
.Documents
.Where(document =>
(document as Document).CiklinId == ciklinId)
.FirstOrDefault();
return(Task.FromResult(new GetDocumentResponse()
{
Document = matchedDocument
}));
}
case GetDocumentRequest.DocumentIdOneofCase.DfdId:
{
var dfdId = request.DfdId;
var matchedDocument = _indexHolder.GetIndex().Documents.Where(document => (document as Document).DfdId == dfdId).FirstOrDefault();
return(Task.FromResult(new GetDocumentResponse()
{
Document = matchedDocument
}));
}
default:
throw new Exception("Bad request");
}
}
/// <summary>
/// Gets document stream of latest version of given document ID.
/// If version ID is null, it retrieves latest version of requested document ID.
/// </summary>
/// <param name="getDocumentStreamRequest">Request parameters.</param>
/// <returns>Response for stream of latest version of requested document.</returns>
public async Task <GetDocumentStreamResponse> GetDocumentStreamAsync(GetDocumentStreamRequest getDocumentStreamRequest)
{
String versionId = getDocumentStreamRequest.VersionId;
if (versionId == null)
{
GetDocumentRequest getDocumentRequest = new GetDocumentRequest()
{
DocumentId = getDocumentStreamRequest.DocumentId,
AuthenticationToken = authenticationToken
};
GetDocumentResponse response = await client.GetDocumentAsync(getDocumentRequest).ConfigureAwait(false);
versionId = response.Metadata.LatestVersionMetadata.Id;
}
Stream documentVersionStream = await GetDocumentVersionStreamAsync(getDocumentStreamRequest.DocumentId, versionId).ConfigureAwait(false);
GetDocumentStreamResponse getDocumentStreamResponse = new GetDocumentStreamResponse(getDocumentStreamRequest)
{
Stream = documentVersionStream
};
return(getDocumentStreamResponse);
}
public async Task <GetDocumentResponse> GetDocumentAsync(GetDocumentRequest request)
{
string url = request.GetUrl(_clusterUrl);
var response = await SendAsync(url, HttpMethod.Get, null);
return(new GetDocumentResponse(response));
}
public virtual HttpRequest Create(GetDocumentRequest request)
{
var httpRequest = CreateFor<GetDocumentRequest>(HttpMethod.Get, GenerateRequestUrl(request.Id, request.Rev));
httpRequest.SetIfMatch(request.Rev);
return httpRequest;
}
public virtual HttpRequest Create(GetDocumentRequest request)
{
Ensure.Any.IsNotNull(request, nameof(request));
return(new HttpRequest(HttpMethod.Get, GenerateRelativeUrl(request))
.SetRequestTypeHeader(request.GetType())
.SetIfMatchHeader(request.Rev));
}
public virtual HttpRequest Create(GetDocumentRequest request)
{
var httpRequest = CreateFor <GetDocumentRequest>(HttpMethod.Get, GenerateRequestUrl(request.Id, request.Rev));
httpRequest.SetIfMatch(request.Rev);
return(httpRequest);
}
/// <summary>
/// Initiates the asynchronous execution of the GetDocument operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetDocument operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task <GetDocumentResponse> GetDocumentAsync(GetDocumentRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new GetDocumentRequestMarshaller();
var unmarshaller = GetDocumentResponseUnmarshaller.Instance;
return(InvokeAsync <GetDocumentRequest, GetDocumentResponse>(request, marshaller,
unmarshaller, cancellationToken));
}
private static async Task <T> GetConflictResolvedAsync(DataBase store, string id, Func <ICollection <T>, T> merger, CancellationToken cancellationToken = default(CancellationToken))
{
var req = new GetDocumentRequest(id);
req.Conflicts = true;
var data = await store.Documents.GetAsync(req, cancellationToken);
//await store.Entities.GetAsync<T>(req, cancellationToken);
if (!data.IsSuccess)
{
return(null);
}
var mainContent = JsonConvert.DeserializeObject <T>(data.Content);
if (data.Conflicts == null || data.Conflicts.Length == 0)
{
return(mainContent);
}
List <T> conflicting = new List <T>();
List <DocumentHeader> toDelete = new List <DocumentHeader>();
conflicting.Add(mainContent);
foreach (var fetch in data.Conflicts)
{
var item = await store.Documents.GetAsync(id, fetch, cancellationToken);
if (item.IsSuccess)
{
conflicting.Add(JsonConvert.DeserializeObject <T>(item.Content));
toDelete.Add(new DocumentHeader(item.Id, item.Rev));
}
else
{
return(null); //assume connection lost or competing merge
}
}
T merged = merger(conflicting);
if (merged == null)
{
Log.Error("Error trying to fetch conflicting data from " + store + ":" + id + " with no merger set. Fixed. Result will be arbitrary");
merged = mainContent;
}
merged._id = id;
merged._rev = data.Rev;
var putResult = await store.Entities.PutAsync(merged);
if (putResult.IsSuccess)
{
var deleteRequest = new BulkRequest().Delete(toDelete.ToArray());
deleteRequest.AllOrNothing = true;
await store.Documents.BulkAsync(deleteRequest); //await, ignore result, let others clean it up if failed
return(putResult.Content);
}
return(null); //assume connection lost or asynchronous update
}
protected virtual string GenerateRelativeUrl(GetDocumentRequest request)
{
var urlParams = new UrlParams();
urlParams.AddIfNotNullOrWhiteSpace("rev", request.Rev);
urlParams.AddIfTrue("conflicts", request.Conflicts);
return(string.Format("/{0}{1}", new UrlSegment(request.Id), new QueryString(urlParams)));
}
public virtual async Task <DocumentResponse> GetAsync(GetDocumentRequest request, CancellationToken cancellationToken = default)
{
var httpRequest = GetDocumentHttpRequestFactory.Create(request);
using (var res = await SendAsync(httpRequest, cancellationToken).ForAwait())
{
return(await DocumentReponseFactory.CreateAsync(res).ForAwait());
}
}
public virtual async Task <DocumentResponse> GetAsync(GetDocumentRequest request)
{
var httpRequest = CreateHttpRequest(request);
using (var res = await SendAsync(httpRequest).ForAwait())
{
return(ProcessDocumentResponse(res));
}
}
public Document Get(GetDocumentRequest request)
{
Document document = this.documentsManager.GetDocument(request);
if (document == null)
{
throw HttpError.NotFound("");
}
return(document);
}
public virtual async Task <DocumentResponse> GetAsync(GetDocumentRequest request)
{
Ensure.That(request, "request").IsNotNull();
using (var httpRequest = CreateHttpRequest(request))
{
using (var res = await SendAsync(httpRequest).ForAwait())
{
return(ProcessDocumentResponse(res));
}
}
}
public void When_GET_of_document_with_no_conflicts_when_including_conflicts_It_returns_the_document()
{
var postResponse = SUT.PostAsync(ClientTestData.Artists.Artist1Json).Result;
var request = new GetDocumentRequest(postResponse.Id)
{
Conflicts = true
};
var response = SUT.GetAsync(request).Result;
response.Should().BeSuccessfulGet(postResponse.Id, postResponse.Rev);
}
public void TestGetDocument()
{
var localName = "test_multi_pages.docx";
var remoteName = "TestGetDocument.docx";
var fullName = Path.Combine(this.dataFolder, remoteName);
this.StorageApi.PutCreate(fullName, null, null, File.ReadAllBytes(BaseTestContext.GetDataDir(BaseTestContext.CommonFolder) + localName));
var request = new GetDocumentRequest(remoteName, this.dataFolder);
var actual = this.WordsApi.GetDocument(request);
Assert.AreEqual(200, actual.Code);
}
/// <summary>Snippet for GetDocument</summary>
public void GetDocument_RequestObject()
{
// Snippet: GetDocument(GetDocumentRequest,CallSettings)
// Create client
FirestoreClient firestoreClient = FirestoreClient.Create();
// Initialize request argument(s)
GetDocumentRequest request = new GetDocumentRequest
{
Name = new AnyPathName("[PROJECT]", "[DATABASE]", "[DOCUMENT]", "[ANY_PATH]").ToString(),
};
// Make the request
Document response = firestoreClient.GetDocument(request);
// End snippet
}
public void When_GET_of_document_when_including_revisions_It_returns_at_least_its_revision()
{
var postResponse = SUT.PostAsync(ClientTestData.Artists.Artist1Json).Result;
var postResponseRevId = postResponse.Rev.Split('-')[1];
var request = new GetDocumentRequest(postResponse.Id)
{
Revisions = true
};
var response = SUT.GetAsync(request).Result;
response.Should().BeSuccessfulGet(postResponse.Id, postResponse.Rev);
response.Revisions.Should().NotBeNull();
response.Revisions.Ids.Should().NotBeNullOrEmpty().And.Contain(postResponseRevId);
}
/// <summary>Snippet for GetDocument</summary>
public void GetDocumentRequestObject()
{
// Snippet: GetDocument(GetDocumentRequest, CallSettings)
// Create client
FirestoreClient firestoreClient = FirestoreClient.Create();
// Initialize request argument(s)
GetDocumentRequest request = new GetDocumentRequest
{
Name = "",
Mask = new DocumentMask(),
Transaction = ByteString.Empty,
};
// Make the request
Document response = firestoreClient.GetDocument(request);
// End snippet
}
public async Task <IActionResult> Details(string id, string rev)
{
using (var client = new MyCouchClient(new DbConnectionInfo("http://localhost:5984/", "tasks")))
{
var task = new TodoTask();
var request = new GetDocumentRequest(id, rev);
var response = await client.Documents.GetAsync(request);
task = JsonConvert.DeserializeObject <TodoTask>(response.Content);
task._id = response.Id;
task._rev = response.Rev;
return(View(task));
}
}
/// <summary>Snippet for GetDocumentAsync</summary>
public async Task GetDocumentAsync_RequestObject()
{
// Snippet: GetDocumentAsync(GetDocumentRequest,CallSettings)
// Additional: GetDocumentAsync(GetDocumentRequest,CancellationToken)
// Create client
FirestoreClient firestoreClient = await FirestoreClient.CreateAsync();
// Initialize request argument(s)
GetDocumentRequest request = new GetDocumentRequest
{
Name = new AnyPathName("[PROJECT]", "[DATABASE]", "[DOCUMENT]", "[ANY_PATH]").ToString(),
};
// Make the request
Document response = await firestoreClient.GetDocumentAsync(request);
// End snippet
}
private async Task <Response> GetSharedDocuments(string userId)
{
Response retval;
GetSharedDocumentsRequest shareReq = new GetSharedDocumentsRequest()
{
UserID = userId
};
var jsonRequest = JsonConvert.SerializeObject(shareReq);
var response = await SendRequest(jsonRequest);
if (response.IsSuccessStatusCode)
{
List <Document> documents = new List <Document>();
var content = await response.Content.ReadAsStringAsync();
var codeResponse = JsonConvert.DeserializeObject <GetSharedDocumentsResponseOK>(content);
foreach (string docId in codeResponse.Documents)
{
GetDocumentRequest request = new GetDocumentRequest()
{
DocId = docId
};
Response docResponse = await GetDocument(request);
if (docResponse is GetDocumentResponseOK)
{
Document doc = (docResponse as GetDocumentResponseOK).Document;
documents.Add(doc);
}
else if (docResponse is AppResponseError)
{
return(docResponse);
}
}
retval = new GetDocumentsResponseOK(documents);
}
else
{
retval = new AppResponseError(response.StatusCode.ToString());
}
return(retval);
}
/// <summary>Snippet for GetDocumentAsync</summary>
public async Task GetDocumentRequestObjectAsync()
{
// Snippet: GetDocumentAsync(GetDocumentRequest, CallSettings)
// Additional: GetDocumentAsync(GetDocumentRequest, CancellationToken)
// Create client
FirestoreClient firestoreClient = await FirestoreClient.CreateAsync();
// Initialize request argument(s)
GetDocumentRequest request = new GetDocumentRequest
{
Name = "",
Mask = new DocumentMask(),
Transaction = ByteString.Empty,
};
// Make the request
Document response = await firestoreClient.GetDocumentAsync(request);
// End snippet
}
public async Task GetDocumentAsync()
{
Mock <Firestore.FirestoreClient> mockGrpcClient = new Mock <Firestore.FirestoreClient>(MockBehavior.Strict);
GetDocumentRequest request = new GetDocumentRequest
{
Name = new AnyPathName("[PROJECT]", "[DATABASE]", "[DOCUMENT]", "[ANY_PATH]").ToString(),
};
Document expectedResponse = new Document
{
Name = "name2-1052831874",
};
mockGrpcClient.Setup(x => x.GetDocumentAsync(request, It.IsAny <CallOptions>()))
.Returns(new Grpc.Core.AsyncUnaryCall <Document>(Task.FromResult(expectedResponse), null, null, null, null));
FirestoreClient client = new FirestoreClientImpl(mockGrpcClient.Object, null);
Document response = await client.GetDocumentAsync(request);
Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public void TestGetDocument()
{
string remoteFileName = "TestGetDocument.docx";
this.UploadFileToStorage(
remoteDataFolder + "/" + remoteFileName,
null,
null,
File.ReadAllBytes(LocalTestDataFolder + localFile)
);
var request = new GetDocumentRequest(
documentName: remoteFileName,
folder: remoteDataFolder
);
var actual = this.WordsApi.GetDocument(request);
Assert.NotNull(actual.Document);
Assert.AreEqual("TestGetDocument.docx", actual.Document.FileName);
}
