public async Task <CreateDocumentResponse> CreateDocumentAsync(CreateDocumentRequest request) { //// This should do nothing but call the http function through HttpClient var response = await client.PostAsJsonAsync("api/documents", request); return(await response.Content.ReadAsAsync <CreateDocumentResponse>()); }
public async Task MergeIndicesTest() { // arranges var firstDocument = new Foo { Id = Guid.NewGuid().ToString(), FooDescription = "Some foo description" }; var secondDocument = new Foo { Id = Guid.NewGuid().ToString(), FooDescription = "Another foo description" }; var firstDocumentRequest = new CreateDocumentRequest <Foo> { Id = firstDocument.Id, Document = firstDocument }; var secondDocumentRequest = new CreateDocumentRequest <Foo> { Id = secondDocument.Id, Document = secondDocument }; var firstIndex = await _elasticsearchResource.CreateIndexAsync <Foo>(); await _elasticsearchResource.CreateDocumentsAsync(firstIndex, firstDocumentRequest); var secondIndex = await _elasticsearchResource.CreateIndexAsync <Foo>(); await _elasticsearchResource.CreateDocumentsAsync(secondIndex, secondDocumentRequest); // act var mergedIndex = await _elasticsearchResource.MergeIndicesAsync(firstIndex, secondIndex); // assert SearchResponse <Foo> searchResponse = await _elasticsearchResource.Client.LowLevel.SearchAsync <SearchResponse <Foo> >( mergedIndex, typeof(Foo).Name.ToLowerInvariant(), PostData.String(string.Empty)); searchResponse.IsValid.Should().BeTrue(); searchResponse.Documents.Should().HaveCount(2); searchResponse.Documents.Should().Contain(foo => foo.Id == firstDocument.Id); searchResponse.Documents.Should().Contain(foo => foo.Id == secondDocument.Id); }
public async Task <Response> CreateDocument(CreateDocumentRequest request) { Response retval = new CreateDocumentResponseInvalidData(request); if (_dal.IsUserExists(_conn, request.UserID)) { var id = Guid.NewGuid().ToString(); Document document = new Document() { DocID = id, DocumentName = request.DocumentName, ImageURL = request.ImageURL, UserID = request.UserID }; try { _dal.CreateDocument(_conn, document); retval = new CreateDocumentResponseOK(request); await _webSocket.Notify("new Document" + id); } catch (Exception ex) { retval = new AppResponseError("Error in create document"); } } return(retval); }
public void CreateDocumentRequestObject() { moq::Mock <Firestore.FirestoreClient> mockGrpcClient = new moq::Mock <Firestore.FirestoreClient>(moq::MockBehavior.Strict); CreateDocumentRequest request = new CreateDocumentRequest { Parent = "projects/test/databases/test/documents/parent7858e4d0", CollectionId = "collection_idd84d1a0a", DocumentId = "document_id10fcfae7", Document = new Document(), Mask = new DocumentMask(), }; Document expectedResponse = new Document { Name = "name1c9368b0", Fields = { { "key8a0b6e3c", new Value() }, }, CreateTime = new wkt::Timestamp(), UpdateTime = new wkt::Timestamp(), }; mockGrpcClient.Setup(x => x.CreateDocument(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse); FirestoreClient client = new FirestoreClientImpl(mockGrpcClient.Object, null); Document response = client.CreateDocument(request); xunit::Assert.Same(expectedResponse, response); mockGrpcClient.VerifyAll(); }
public async stt::Task CreateDocumentRequestObjectAsync() { moq::Mock <Firestore.FirestoreClient> mockGrpcClient = new moq::Mock <Firestore.FirestoreClient>(moq::MockBehavior.Strict); CreateDocumentRequest request = new CreateDocumentRequest { Parent = "projects/test/databases/test/documents/parent7858e4d0", CollectionId = "collection_idd84d1a0a", DocumentId = "document_id10fcfae7", Document = new Document(), Mask = new DocumentMask(), }; Document expectedResponse = new Document { Name = "name1c9368b0", Fields = { { "key8a0b6e3c", new Value() }, }, CreateTime = new wkt::Timestamp(), UpdateTime = new wkt::Timestamp(), }; mockGrpcClient.Setup(x => x.CreateDocumentAsync(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.CreateDocumentAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None)); xunit::Assert.Same(expectedResponse, responseCallSettings); Document responseCancellationToken = await client.CreateDocumentAsync(request, st::CancellationToken.None); xunit::Assert.Same(expectedResponse, responseCancellationToken); mockGrpcClient.VerifyAll(); }
/** * This scenario demonstrates the creation of a document * that will be signed by a sign rule. * In a signing rule multiples users are assigned to the * same action but just an arbitrary number of them are * required to sign in order to complete that action. */ public override async Task RunAsync() { // 1. The file's bytes must be read by the application and uploaded var filePath = "sample.pdf"; var fileName = Path.GetFileName(filePath); var file = File.ReadAllBytes(filePath); var uploadModel = await SignerClient.UploadFileAsync(fileName, file, "application/pdf"); // 2. Define the name of the document which will be visible in the application var fileUploadModel = new FileUploadModel(uploadModel) { DisplayName = "Signing Rule Sample" }; // 3. For each participant on the flow, create one instance of ParticipantUserModel var participantUserOne = new ParticipantUserModel() { Name = "Jack Bauer", Email = "*****@*****.**", Identifier = "75502846369" }; var participantUserTwo = new ParticipantUserModel() { Name = "James Bond", Email = "*****@*****.**", Identifier = "95588148061" }; // 4. Each signing rule requires just one FlowActionCreateModel no matter // the number of participants assigned to it. The participants are assigned to // it via a list of ParticipantUserModel assigned to the `SignRuleUsers` property. // The number of required signatures from this list of participants is represented by // the property `NumberRequiredSignatures`. var flowActionCreateModelSigningRule = new FlowActionCreateModel() { Type = FlowActionType.SignRule, NumberRequiredSignatures = 1, SignRuleUsers = new List <ParticipantUserModel>() { participantUserOne, participantUserTwo } }; // 5. Send the document create request var documentRequest = new CreateDocumentRequest() { Files = new List <FileUploadModel>() { fileUploadModel }, FlowActions = new List <FlowActionCreateModel>() { flowActionCreateModelSigningRule } }; var result = (await SignerClient.CreateDocumentAsync(documentRequest)).First(); System.Console.WriteLine($"Document {result.DocumentId} created"); }
private CreateDocumentRequest CreateDocumentRequest() { var request = new CreateDocumentRequest { Name = "Sample Document", Url = SampleDocUrl, Recipients = new[] { new Models.CreateDocument.Recipient { Email = "*****@*****.**", FirstName = "Jake", LastName = "Scott", Role = "u1", } }, Fields = new Dictionary <string, Field> { { "optId", new Field { Title = "Field 1" } } } }; return(request); }
internal CreateDocumentResponse CreateDocument(CreateDocumentRequest request) { var marshaller = new CreateDocumentRequestMarshaller(); var unmarshaller = CreateDocumentResponseUnmarshaller.Instance; return(Invoke <CreateDocumentRequest, CreateDocumentResponse>(request, marshaller, unmarshaller)); }
public async Task CreateDocumentsTest() { // arranges var firstDocument = new Foo { Id = Guid.NewGuid().ToString(), FooDescription = "Some foo description" }; var secondDocument = new Foo { Id = Guid.NewGuid().ToString(), FooDescription = "Another foo description" }; var firstDocumentRequest = new CreateDocumentRequest <Foo> { Id = firstDocument.Id, Document = firstDocument }; var secondDocumentRequest = new CreateDocumentRequest <Foo> { Id = secondDocument.Id, Document = secondDocument }; // act var index = await _elasticsearchResource.CreateIndexAsync <Foo>(); await _elasticsearchResource.CreateDocumentsAsync(index, firstDocumentRequest, secondDocumentRequest); // assert ISearchResponse <Foo> searchResponse = await _elasticsearchResource.Client .SearchAsync <Foo>(new SearchRequest <Foo>(Indices.Index(index))); searchResponse.IsValid.Should().BeTrue(); searchResponse.Documents.Should().HaveCount(2); searchResponse.Documents.Should().Contain(foo => foo.Id == firstDocument.Id); searchResponse.Documents.Should().Contain(foo => foo.Id == secondDocument.Id); }
public async Task <GetDocumentResponse> CreateDocument(byte[] fileContent, CreateDocumentRequest request) { var sharedDocuments = new List <ShareDocumentResponse>(); using (var client = SetApiKey()) { if (request == null) { request = CreateDocumentRequest(); } var response = await client.CreateDocument(fileContent, request); if (!string.IsNullOrEmpty(response.Uuid)) { var sendRequest = new SendDocumentRequest { Message = "Please sign this document", Silent = request.DisableEmail }; var sendDocResponse = await client.SendDocument(response.Uuid, sendRequest); var getDocResponse = await client.GetDocument(response.Uuid); return(getDocResponse); } else { return(null); } } }
/// <inheritdoc /> public Task <Guid> CreateDocumentAsync(CreateDocumentRequest request) { this._logger.LogDebug(nameof(this.CreateDocumentAsync), request); var command = this._mapper.Map <CreateDocumentCommand>(request); return(this._mediator.Send(command)); }
/// <summary> /// Initiates the asynchronous execution of the CreateDocument operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the CreateDocument 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 <CreateDocumentResponse> CreateDocumentAsync(CreateDocumentRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new CreateDocumentRequestMarshaller(); var unmarshaller = CreateDocumentResponseUnmarshaller.Instance; return(InvokeAsync <CreateDocumentRequest, CreateDocumentResponse>(request, marshaller, unmarshaller, cancellationToken)); }
/// <summary> /// Creates a configuration document. /// /// /// <para> /// After you create a configuration document, you can use <a>CreateAssociation</a> to /// associate it with one or more running instances. /// </para> /// </summary> /// <param name="content">A valid JSON file. For more information about the contents of this file, see <a href="http://docs.aws.amazon.com/ssm/latest/APIReference/aws-ssm-document.html">Configuration Document</a>.</param> /// <param name="name">A name for 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 CreateDocument service method, as returned by SimpleSystemsManagement.</returns> /// <exception cref="Amazon.SimpleSystemsManagement.Model.DocumentAlreadyExistsException"> /// The specified configuration document already exists. /// </exception> /// <exception cref="Amazon.SimpleSystemsManagement.Model.DocumentLimitExceededException"> /// You can have at most 100 active configuration documents. /// </exception> /// <exception cref="Amazon.SimpleSystemsManagement.Model.InternalServerErrorException"> /// An error occurred on the server side. /// </exception> /// <exception cref="Amazon.SimpleSystemsManagement.Model.InvalidDocumentContentException"> /// The content for the configuration document is not valid. /// </exception> /// <exception cref="Amazon.SimpleSystemsManagement.Model.MaxDocumentSizeExceededException"> /// The size limit of a configuration document is 64 KB. /// </exception> public Task <CreateDocumentResponse> CreateDocumentAsync(string content, string name, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var request = new CreateDocumentRequest(); request.Content = content; request.Name = name; return(CreateDocumentAsync(request, cancellationToken)); }
public async Task <IActionResult> CreateOther( [FromHeader] Guid personUniqueId, [FromBody] CreateDocumentRequest <OtherDocumentDetail> model, [FromServices] DocumentsManager manager) { var documentId = await manager.CreateDocumentAsync(User.Identity.Name, personUniqueId, model); return(Json(new ApiResponse <string>(documentId))); }
/** * This scenario demonstrates the creation of a document * that needs to be signed using the XAdES format for a * specific XML element. */ public override async Task RunAsync() { // 1. The file's bytes must be read by the application and uploaded var filePath = "sample.xml"; var fileName = Path.GetFileName(filePath); var file = File.ReadAllBytes(filePath); var uploadModel = await SignerClient.UploadFileAsync(fileName, file, "application/xml"); // 2. Define the name of the document which will be visible in the application var fileUploadModel = new FileUploadModel(uploadModel) { DisplayName = "XML Element Sign Sample" }; // 3. For each participant on the flow, create one instance of ParticipantUserModel var participantUser = new ParticipantUserModel() { Name = "Jack Bauer", Email = "*****@*****.**", Identifier = "75502846369" }; // 4. Specify the type of the element (Id is used below) and the value of the identifier var xadesOptionsModel = new XadesOptionsModel() { SignatureType = XadesSignatureTypes.XmlElement, ElementToSignIdentifierType = XadesElementIdentifierTypes.Id, ElementToSignIdentifier = "NFe35141214314050000662550010001084271182362300" }; // 5. Create a FlowActionCreateModel instance for each action (signature or approval) in the flow. // This object is responsible for defining the personal data of the participant and the type of // action that he will perform on the flow. var flowActionCreateModel = new FlowActionCreateModel() { Type = FlowActionType.Signer, User = participantUser, XadesOptions = xadesOptionsModel }; // 6. Send the document create request var documentRequest = new CreateDocumentRequest() { Files = new List <FileUploadModel>() { fileUploadModel }, FlowActions = new List <FlowActionCreateModel>() { flowActionCreateModel } }; var result = (await SignerClient.CreateDocumentAsync(documentRequest)).First(); System.Console.WriteLine($"Document {result.DocumentId} created"); }
/** * This scenario demonstrates the creation of a document * and the generation of an action URL for the embedded signature * integration. */ public override async Task RunAsync() { // 1. The file's bytes must be read by the application and uploaded var filePath = "sample.pdf"; var fileName = Path.GetFileName(filePath); var file = File.ReadAllBytes(filePath); var uploadModel = await SignerClient.UploadFileAsync(fileName, file, "application/pdf"); // 2. Define the name of the document which will be visible in the application var fileUploadModel = new FileUploadModel(uploadModel) { DisplayName = "Embedded Signature Sample" }; // 3. For each participant on the flow, create one instance of ParticipantUserModel var participantUser = new ParticipantUserModel() { Name = "Jack Bauer", Email = "*****@*****.**", Identifier = "75502846369" }; // 4. Create a FlowActionCreateModel instance for each action (signature or approval) in the flow. // This object is responsible for defining the personal data of the participant and the type of // action that he will perform on the flow var flowActionCreateModel = new FlowActionCreateModel() { Type = FlowActionType.Signer, User = participantUser }; // 5. Send the document create request var documentRequest = new CreateDocumentRequest() { Files = new List <FileUploadModel>() { fileUploadModel }, FlowActions = new List <FlowActionCreateModel>() { flowActionCreateModel } }; var result = (await SignerClient.CreateDocumentAsync(documentRequest)).First(); // 6. Get the embed URL for the participant var actionUrlRequest = new ActionUrlRequest() { Identifier = participantUser.Identifier }; var actionUrlResponse = await SignerClient.GetActionUrlAsync(result.DocumentId, actionUrlRequest); // 7. Load the embed URL in your own application using the LacunaSignerWidget as described in // https://docs.lacunasoftware.com/pt-br/articles/signer/embedded-signature.html System.Console.WriteLine(actionUrlResponse.EmbedUrl); }
public async Task <GetDocumentResponse> Upload(string fileName, CreateDocumentRequest request) { var sharedDocuments = new List <ShareDocumentResponse>(); var pandaDocHelper = new PandaDocHelper(); byte[] fileContent = System.IO.File.ReadAllBytes(fileName); var response = await pandaDocHelper.CreateDocument(fileContent, request); return(response); }
public void CreateDocInvalidData() { var request = new CreateDocumentRequest() { DocumentName = "apple", ImageURL = "dfdf", UserID = "*****@*****.**" }; var response = _documentService.CreateDocument(request).Result; Assert.IsInstanceOf(typeof(CreateDocumentResponseInvalidData), response); }
public async void CreateDocumentAsync() { using (PandaDocHttpClient client = await EnsureLoggedIn()) { CreateDocumentRequest request = CreateDocumentRequest(); PandaDocHttpResponse <CreateDocumentResponse> response = await client.CreateDocument(request); response.AssertOk(); } }
public void CreateDocument() { using (PandaDocHttpClient client = EnsureLoggedIn().Result) { CreateDocumentRequest request = CreateDocumentRequest(); PandaDocHttpResponse <CreateDocumentResponse> response = client.CreateDocument(request).Result; response.AssertOk(); } }
public async Task <CreateDocumentResponse> CreateDocument(CreateDocumentRequest request) { var accountInfo = _auth.GenerateSecurityInformation(); request.AddAccountInfo(accountInfo); EnvioPedidoClient client = new EnvioPedidoClient(); var result = await client.orderPedidoXMLAsync(request.BuildRequest()); return(_deserializer.Deserialize <CreateDocumentResponse>(result)); }
public ConfirmationResponse Execute(CreateDocumentRequest request) { request.ThrowExceptionIfInvalid(); var entity = ToDomainEntity(request); var result = _documentRepository.Create(entity); return(new ConfirmationResponse("Document created successfully.") { Id = result, }); }
public Response CreateDocument(CreateDocumentRequest request) { try { var id = _idGeneretor.GenerateId(request.OwnerId + request.DocumentName); var ds = _dal.CreateDocument(id, request.OwnerId, request.DocumentName); return(new CreateDocumentResponseOK(id)); } catch (Exception ex) { return(new ResponseError(ex.Message)); } }
public async Task <GetDocumentResponse> Upload(byte[] fileBytes, CreateDocumentRequest request) { GetDocumentResponse response = new GetDocumentResponse(); if (fileBytes.Length > 0) { var pandaDocHelper = new PandaDocHelper(); var docresponse = await pandaDocHelper.CreateDocument(fileBytes, request); response = docresponse; } return(response); }
public void TestCreateDocument() { string remoteFileName = "TestCreateDocument.doc"; var request = new CreateDocumentRequest( fileName: remoteFileName, folder: remoteDataFolder ); var actual = this.WordsApi.CreateDocument(request); Assert.NotNull(actual.Document); Assert.AreEqual("TestCreateDocument.doc", actual.Document.FileName); }
public async Task <GetDocumentResponse> Upload(string fileName) { var sharedDocuments = new List <ShareDocumentResponse>(); CreateDocumentRequest request = CreateDocumentRequest(); if (string.IsNullOrEmpty(fileName)) { fileName = "D:\\panda.pdf"; } byte[] fileContent = File.ReadAllBytes(fileName); var response = await pandaDocHelper.CreateDocument(fileContent, request); return(response.Value); }
/** * This scenario demonstrates the creation of a PDF document * that needs to be signed using the CAdES format. */ public override async Task RunAsync() { // 1. The file's bytes must be read by the application and uploaded var filePath = "sample.pdf"; var fileName = Path.GetFileName(filePath); var file = File.ReadAllBytes(filePath); var uploadModel = await SignerClient.UploadFileAsync(fileName, file, "application/pdf"); // 2. Define the name of the document which will be visible in the application var fileUploadModel = new FileUploadModel(uploadModel) { DisplayName = "PDF Cades Sample" }; // 3. For each participant on the flow, create one instance of ParticipantUserModel var participantUser = new ParticipantUserModel() { Name = "Jack Bauer", Email = "*****@*****.**", Identifier = "75502846369" }; // 4. Create a FlowActionCreateModel instance for each action (signature or approval) in the flow. // This object is responsible for defining the personal data of the participant and the type of // action that he will perform on the flow var flowActionCreateModel = new FlowActionCreateModel() { Type = FlowActionType.Signer, User = participantUser }; // 5. Send the document create request specifying that it requires CAdES signatures, since PAdES is // the default for PDF files. var documentRequest = new CreateDocumentRequest() { Files = new List <FileUploadModel>() { fileUploadModel }, FlowActions = new List <FlowActionCreateModel>() { flowActionCreateModel }, ForceCadesSignature = true }; var result = (await SignerClient.CreateDocumentAsync(documentRequest)).First(); System.Console.WriteLine($"Document {result.DocumentId} created"); }
/// <summary> /// 创建电子文档 /// </summary> /// <param name="req"><see cref="CreateDocumentRequest"/></param> /// <returns><see cref="CreateDocumentResponse"/></returns> public CreateDocumentResponse CreateDocumentSync(CreateDocumentRequest req) { JsonResponseModel <CreateDocumentResponse> rsp = null; try { var strResp = this.InternalRequestSync(req, "CreateDocument"); rsp = JsonConvert.DeserializeObject <JsonResponseModel <CreateDocumentResponse> >(strResp); } catch (JsonSerializationException e) { throw new TencentCloudSDKException(e.Message); } return(rsp.Response); }
/// <summary>Snippet for CreateDocument</summary> public void CreateDocument_RequestObject() { // Snippet: CreateDocument(CreateDocumentRequest,CallSettings) // Create client FirestoreClient firestoreClient = FirestoreClient.Create(); // Initialize request argument(s) CreateDocumentRequest request = new CreateDocumentRequest { Parent = new AnyPathName("[PROJECT]", "[DATABASE]", "[DOCUMENT]", "[ANY_PATH]").ToString(), CollectionId = "", DocumentId = "", Document = new Document(), }; // Make the request Document response = firestoreClient.CreateDocument(request); // End snippet }
/** * This scenario demonstrates the creation of a document with description * */ public override async Task RunAsync() { // 1. The file's bytes must be read by the application and uploaded var filePath = "sample.pdf"; var fileName = Path.GetFileName(filePath); var file = File.ReadAllBytes(filePath); var uploadModel = await SignerClient.UploadFileAsync(fileName, file, "application/pdf"); // 2. Define the name of the document which will be visible in the application var fileUploadModel = new FileUploadModel(uploadModel) { DisplayName = "One Description Sample" }; // 3. For each participant on the flow, create one instance of ParticipantUserModel var participantUser = new ParticipantUserModel() { Name = "Jack Bauer", Email = "*****@*****.**", Identifier = "75502846369" }; // 4. Create a FlowActionCreateModel instance for each action (signature or approval) in the flow. var flowActionCreateModel = new FlowActionCreateModel() { Type = FlowActionType.Signer, User = participantUser }; // 5. Send the document create request writing the description as a string var documentRequest = new CreateDocumentRequest() { Files = new List <FileUploadModel>() { fileUploadModel }, Description = "Some Description Sample", FlowActions = new List <FlowActionCreateModel>() { flowActionCreateModel } }; var result = (await SignerClient.CreateDocumentAsync(documentRequest)).First(); System.Console.WriteLine($"Document {result.DocumentId} created"); }