Exemple #1
0
        /// <summary>
        /// Burns a markup JSON file into a document, producing a new PDF.
        /// </summary>
        /// <param name="sourceDocument">Existing <see cref="RemoteWorkFile" />
        /// to use as the source document.</param>
        /// <param name="markupJson">Existing <see cref="RemoteWorkFile" />
        /// containing the markup JSON you want burned into the source
        /// document.</param>
        /// <returns>RemoteWorkFile for the new PDF.</returns>
        public async Task <RemoteWorkFile> BurnMarkupAsync(RemoteWorkFile sourceDocument, RemoteWorkFile markupJson)
        {
            // Make sure we use the existing affinity token, if defined.
            AffinitySession affinitySession = this.restClient.CreateAffinitySession(sourceDocument.AffinityToken);

            // Make sure markupJson has the same affinity as the sourceDocument
            markupJson = await markupJson.GetInstanceWithAffinity(affinitySession, sourceDocument.AffinityToken);

            string json = this.BuildPostMarkupBurnersRequestJson(sourceDocument, markupJson);

            // Start the redaction creation process
            using (HttpResponseMessage response = await affinitySession.PostAsync("/PCCIS/V1/MarkupBurner", new StringContent(json, Encoding.UTF8, "application/json")))
            {
                await this.ThrowIfPostMarkupBurnersError(response);

                json = await response.Content.ReadAsStringAsync();
            }

            JObject process   = JObject.Parse(json);
            string  processId = (string)process["processId"];

            // Wait for the process to complete
            using (HttpResponseMessage response = await affinitySession.GetFinalProcessStatusAsync($"/PCCIS/V1/MarkupBurner/{processId}"))
            {
                await this.ThrowIfGetMarkupBurnersError(response);

                json = await response.Content.ReadAsStringAsync();
            }

            process = JObject.Parse(json);

            return(new RemoteWorkFile(affinitySession, (string)process["output"]["documentFileId"], affinitySession.AffinityToken, "pdf"));
        }
Exemple #2
0
        /// <summary>
        /// Automatically create redaction definitions for a document and a given set of text-matching rules,
        /// producing a new markup JSON file that can be used in a subsequent operation to actually apply the
        /// redaction definitions to the document.
        /// </summary>
        /// <param name="sourceDocument">Source document the redactions should be created for.</param>
        /// <param name="rules">Rules defining what content in the document should have a redaction region created for it.</param>
        /// <returns><see cref="RemoteWorkFile"/> for the created markup JSON file.</returns>
        public async Task <RemoteWorkFile> CreateRedactionsAsync(RemoteWorkFile sourceDocument, IEnumerable <RedactionMatchRule> rules)
        {
            RedactionMatchRule[] rulesArray = rules.ToArray();

            // Make sure we use the existing affinity token, if defined.
            AffinitySession affinitySession = this.restClient.CreateAffinitySession(sourceDocument.AffinityToken);

            string json = this.BuildPostRedactionCreatorsRequestJson(sourceDocument, rules.ToArray());

            // Start the redaction creation process
            using (HttpResponseMessage response = await affinitySession.PostAsync("/v2/redactionCreators", new StringContent(json, Encoding.UTF8, "application/json")))
            {
                await this.ThrowIfPostRedactionCreatorsError(rulesArray, response);

                json = await response.Content.ReadAsStringAsync();
            }

            JObject process   = JObject.Parse(json);
            string  processId = (string)process["processId"];

            // Wait for the process to complete
            using (HttpResponseMessage response = await affinitySession.GetFinalProcessStatusAsync($"/v2/redactionCreators/{processId}"))
            {
                await this.ThrowIfGetRedactionCreatorsError(response);

                json = await response.Content.ReadAsStringAsync();
            }

            process = JObject.Parse(json);

            return(new RemoteWorkFile(affinitySession, (string)process["output"]["markupFileId"], affinitySession.AffinityToken, "json"));
        }
        public async Task PostAsync()
        {
            mockServer
            .Given(Request.Create().WithPath("/wat").UsingPost())
            .RespondWith(Response.Create().WithStatusCode(200).WithBody(req => $"You POSTed: {req.Body}"));

            AffinitySession session = client.CreateAffinitySession();

            using (HttpResponseMessage response = await session.PostAsync("/wat", new StringContent("Hello world!")))
            {
                response.EnsureSuccessStatusCode();
                Assert.AreEqual("You POSTed: Hello world!", await response.Content.ReadAsStringAsync());
            }
        }
Exemple #4
0
        public async Task BaseAddress_with_trailing_slash_is_applied_correctly_to_each_request()
        {
            mockServer
            .Given(Request.Create().WithPath("/wat/123").UsingGet())
            .RespondWith(Response.Create().WithStatusCode(200).WithBody("GET Response"));

            mockServer
            .Given(Request.Create().WithPath("/wat").UsingPost())
            .RespondWith(Response.Create().WithStatusCode(200).WithBody("POST Response"));

            mockServer
            .Given(Request.Create().WithPath("/wat/123").UsingPut())
            .RespondWith(Response.Create().WithStatusCode(200).WithBody("PUT Response"));

            mockServer
            .Given(Request.Create().WithPath("/wat/123").UsingDelete())
            .RespondWith(Response.Create().WithStatusCode(200).WithBody("DELETE Response"));

            string baseAddressWithoutTrailingSlash = "http://localhost:" + mockServer.Ports.First();
            string baseAddressWithTrailingSlash    = baseAddressWithoutTrailingSlash + "/";

            client = new PrizmDocRestClient(baseAddressWithTrailingSlash);

            AffinitySession session = client.CreateAffinitySession();

            using (HttpResponseMessage response = await session.SendAsync(new HttpRequestMessage(HttpMethod.Get, "/wat/123")))
            {
                Assert.AreEqual(baseAddressWithoutTrailingSlash + "/wat/123", response.RequestMessage.RequestUri.ToString());
            }

            using (HttpResponseMessage response = await session.GetAsync("/wat/123"))
            {
                Assert.AreEqual(baseAddressWithoutTrailingSlash + "/wat/123", response.RequestMessage.RequestUri.ToString());
            }

            using (HttpResponseMessage response = await session.PostAsync("/wat", new StringContent("body")))
            {
                Assert.AreEqual(baseAddressWithoutTrailingSlash + "/wat", response.RequestMessage.RequestUri.ToString());
            }

            using (HttpResponseMessage response = await session.PutAsync("/wat/123", new StringContent("body")))
            {
                Assert.AreEqual(baseAddressWithoutTrailingSlash + "/wat/123", response.RequestMessage.RequestUri.ToString());
            }

            using (HttpResponseMessage response = await session.DeleteAsync("/wat/123"))
            {
                Assert.AreEqual(baseAddressWithoutTrailingSlash + "/wat/123", response.RequestMessage.RequestUri.ToString());
            }
        }
Exemple #5
0
        internal static async Task <WorkFile> PostWorkFile(this AffinitySession session, Stream document, string fileExtension = "txt")
        {
            // Remove leading period on fileExtension if present.
            if (fileExtension != null && fileExtension.StartsWith("."))
            {
                fileExtension = fileExtension.Substring(1);
            }

            string json;

            using (var response = await session.PostAsync($"/PCCIS/V1/WorkFile?FileExtension={fileExtension}", new StreamContent(document)))
            {
                response.EnsureSuccessStatusCode();
                json = await response.Content.ReadAsStringAsync();
            }

            var workFileInfo = JObject.Parse(json);
            var workFile     = new WorkFile((string)workFileInfo["fileId"], session);

            return(workFile);
        }
        public async Task Can_convert_a_DOCX_to_PDF_using_PrizmDoc_Cloud()
        {
            // Construct an instance of the PrizmDocRestClient.
            var    client = new PrizmDocRestClient(Environment.GetEnvironmentVariable("BASE_URL"));
            string apiKey = Environment.GetEnvironmentVariable("API_KEY");

            if (apiKey != null)
            {
                client.DefaultRequestHeaders.Add("Acs-Api-Key", apiKey);
            }

            // Create an affinity session for our processing work.
            //
            // You should use an affinity session anytime you have a group
            // of HTTP requests that go together as part of a processing
            // chain. The session ensures that all HTTP requests will
            // automatically use the same affinity (be routed to the same
            // PrizmDoc Server machine in the cluster).
            AffinitySession session = client.CreateAffinitySession();

            string json;

            // Create a new work file for the input document
            using (FileStream inputFileStream = File.OpenRead("input.docx"))
                using (HttpResponseMessage response = await session.PostAsync("/PCCIS/V1/WorkFile", new StreamContent(inputFileStream)))
                {
                    response.EnsureSuccessStatusCode();
                    json = await response.Content.ReadAsStringAsync();
                }


            JObject inputWorkFile = JObject.Parse(json);
            string  inputFileId   = (string)inputWorkFile["fileId"];

            // Start a conversion process using the input work file
            string postContentConvertersJson =
                @"{
    ""input"": {
        ""sources"": [
            {
                ""fileId"": """ + inputFileId + @"""
            }
        ],
        ""dest"": {
            ""format"": ""pdf""
        }
    }
}";

            using (HttpResponseMessage response = await session.PostAsync("/v2/contentConverters", new StringContent(postContentConvertersJson)))
            {
                response.EnsureSuccessStatusCode();
                json = await response.Content.ReadAsStringAsync();
            }

            JObject process   = JObject.Parse(json);
            string  processId = (string)process["processId"];

            // Wait for the process to finish
            using (HttpResponseMessage response = await session.GetFinalProcessStatusAsync($"/v2/contentConverters/{processId}"))
            {
                response.EnsureSuccessStatusCode();
                json = await response.Content.ReadAsStringAsync();
            }

            process = JObject.Parse(json);

            // Did the process error?
            if ((string)process["state"] != "complete")
            {
                throw new Exception("The process failed to complete:\n" + json);
            }

            // Download the output work file and save it to disk.
            string workFileId = (string)process["output"]["results"][0]["fileId"];

            using (HttpResponseMessage response = await session.GetAsync($"/PCCIS/V1/WorkFile/{workFileId}"))
            {
                response.EnsureSuccessStatusCode();

                using (Stream responseBodyStream = await response.Content.ReadAsStreamAsync())
                    using (FileStream outputFileStream = File.OpenWrite("output.pdf"))
                    {
                        await responseBodyStream.CopyToAsync(outputFileStream);
                    }
            }
        }
        public async Task DefaultRequestHeaders_are_correctly_applied_to_each_request()
        {
            mockServer
            .Given(Request.Create().WithPath("/wat/123").UsingGet())
            .RespondWith(Response.Create().WithStatusCode(200).WithBody("GET Response"));

            mockServer
            .Given(Request.Create().WithPath("/wat").UsingPost())
            .RespondWith(Response.Create().WithStatusCode(200).WithBody("POST Response"));

            mockServer
            .Given(Request.Create().WithPath("/wat/123").UsingPut())
            .RespondWith(Response.Create().WithStatusCode(200).WithBody("PUT Response"));

            mockServer
            .Given(Request.Create().WithPath("/wat/123").UsingDelete())
            .RespondWith(Response.Create().WithStatusCode(200).WithBody("DELETE Response"));

            string baseAddress = "http://localhost:" + mockServer.Ports.First();

            client = new PrizmDocRestClient(baseAddress)
            {
                DefaultRequestHeaders =
                {
                    { "Some-Header",       "An example value"      },
                    { "Some-Other-Header", "Another example value" },
                }
            };

            AffinitySession session = client.CreateAffinitySession();

            using (HttpResponseMessage response = await session.SendAsync(new HttpRequestMessage(HttpMethod.Get, "/wat/123")))
            {
                Assert.IsTrue(response.RequestMessage.Headers.Contains("Some-Header"));
                Assert.AreEqual("An example value", response.RequestMessage.Headers.GetValues("Some-Header").SingleOrDefault());
                Assert.IsTrue(response.RequestMessage.Headers.Contains("Some-Other-Header"));
                Assert.AreEqual("Another example value", response.RequestMessage.Headers.GetValues("Some-Other-Header").SingleOrDefault());
            }

            using (HttpResponseMessage response = await session.GetAsync("/wat/123"))
            {
                Assert.IsTrue(response.RequestMessage.Headers.Contains("Some-Header"));
                Assert.AreEqual("An example value", response.RequestMessage.Headers.GetValues("Some-Header").SingleOrDefault());
                Assert.IsTrue(response.RequestMessage.Headers.Contains("Some-Other-Header"));
                Assert.AreEqual("Another example value", response.RequestMessage.Headers.GetValues("Some-Other-Header").SingleOrDefault());
            }

            using (HttpResponseMessage response = await session.PostAsync("/wat", new StringContent("body")))
            {
                Assert.IsTrue(response.RequestMessage.Headers.Contains("Some-Header"));
                Assert.AreEqual("An example value", response.RequestMessage.Headers.GetValues("Some-Header").SingleOrDefault());
                Assert.IsTrue(response.RequestMessage.Headers.Contains("Some-Other-Header"));
                Assert.AreEqual("Another example value", response.RequestMessage.Headers.GetValues("Some-Other-Header").SingleOrDefault());
            }

            using (HttpResponseMessage response = await session.PutAsync("/wat/123", new StringContent("body")))
            {
                Assert.IsTrue(response.RequestMessage.Headers.Contains("Some-Header"));
                Assert.AreEqual("An example value", response.RequestMessage.Headers.GetValues("Some-Header").SingleOrDefault());
                Assert.IsTrue(response.RequestMessage.Headers.Contains("Some-Other-Header"));
                Assert.AreEqual("Another example value", response.RequestMessage.Headers.GetValues("Some-Other-Header").SingleOrDefault());
            }

            using (HttpResponseMessage response = await session.DeleteAsync("/wat/123"))
            {
                Assert.IsTrue(response.RequestMessage.Headers.Contains("Some-Header"));
                Assert.AreEqual("An example value", response.RequestMessage.Headers.GetValues("Some-Header").SingleOrDefault());
                Assert.IsTrue(response.RequestMessage.Headers.Contains("Some-Other-Header"));
                Assert.AreEqual("Another example value", response.RequestMessage.Headers.GetValues("Some-Other-Header").SingleOrDefault());
            }
        }