EJ2-69533-focal

README.md

@@ -56,6 +56,8 @@ Also, you can run the Docker container along with the license key using this doc
 docker run -d -p 6001:80 –e SYNCFUSION_LICENSE_KEY=YOUR_LICENSE_KEY syncfusion/pdfviewer-server:latest 
 ```
 
-For Ex: docker run -d -p 6001:80 –e SYNCFUSION_LICENSE_KEY=Mzg1ODMzQDMxMzgyZTM0MmUzMGdFRGJvUno1MUx4Tit4S09CeS9xRHZzZU4ySVBjQVFuT0VpdWpHUWJ6aXM9 syncfusion/pdfviewer-server:latest 
+For Ex: docker run -d -p 6001:80 –e 
+
+pdfviewer-server:latest 
 Now the PDF Viewer server Docker instance runs in the localhost with the provided port number http://localhost:6001. Open this link in the browser and navigate to the PDF Viewer Web API control http://localhost:6001/api/pdfviewer. It returns the default get method response. 
 

Ubuntu-Focal/PdfViewerWebService_6.0/.dockerignore

@@ -0,0 +1,25 @@
+**/.classpath
+**/.dockerignore
+**/.env
+**/.git
+**/.gitignore
+**/.project
+**/.settings
+**/.toolstarget
+**/.vs
+**/.vscode
+**/*.*proj.user
+**/*.dbmdl
+**/*.jfm
+**/azds.yaml
+**/bin
+**/charts
+**/docker-compose*
+**/Dockerfile*
+**/node_modules
+**/npm-debug.log
+**/obj
+**/secrets.dev.yaml
+**/values.dev.yaml
+LICENSE
+README.md

Ubuntu-Focal/PdfViewerWebService_6.0/Controllers/PDFViewerController.cs

@@ -0,0 +1,291 @@
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Caching.Memory;
+using Newtonsoft.Json;
+using Syncfusion.EJ2.PdfViewer;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Net;
+
+namespace PdfViewerWebService_6._0.Controllers
+{
+    [Route("[controller]")]
+    [ApiController]
+    public class PDFViewerController : ControllerBase
+    {
+        private IWebHostEnvironment _hostingEnvironment;
+        //Initialize the memory cache object   
+        public IMemoryCache _cache;
+        public PDFViewerController(IWebHostEnvironment hostingEnvironment, IMemoryCache cache)
+        {
+            _hostingEnvironment = hostingEnvironment;
+            _cache = cache;
+            Console.WriteLine("PdfViewerController initialized");
+        }
+
+        [HttpPost("Load")]
+        [Microsoft.AspNetCore.Cors.EnableCors("MyPolicy")]
+        [Route("[controller]/Load")]
+        //Post action for Loading the PDF documents   
+        public IActionResult Load([FromBody] Dictionary<string, string> jsonObject)
+        {
+            Console.WriteLine("Load called");
+            //Initialize the PDF viewer object with memory cache object
+            PdfRenderer pdfviewer = new PdfRenderer(_cache);
+            MemoryStream stream = new MemoryStream();
+            object jsonResult = new object();
+            if (jsonObject != null && jsonObject.ContainsKey("document"))
+            {
+                if (bool.Parse(jsonObject["isFileName"]))
+                {
+                    string documentPath = GetDocumentPath(jsonObject["document"]);
+                    if (!string.IsNullOrEmpty(documentPath))
+                    {
+                        byte[] bytes = System.IO.File.ReadAllBytes(documentPath);
+                        stream = new MemoryStream(bytes);
+                    }
+                    else
+                    {
+                        string fileName = jsonObject["document"].Split(new string[] { "://" }, StringSplitOptions.None)[0];
+
+                        if (fileName == "http" || fileName == "https")
+                        {
+                            WebClient WebClient = new WebClient();
+                            byte[] pdfDoc = WebClient.DownloadData(jsonObject["document"]);
+                            stream = new MemoryStream(pdfDoc);
+                        }
+
+                        else
+                        {
+                            return this.Content(jsonObject["document"] + " is not found");
+                        }
+                    }
+                }
+                else
+                {
+                    byte[] bytes = Convert.FromBase64String(jsonObject["document"]);
+                    stream = new MemoryStream(bytes);
+                }
+            }
+            jsonResult = pdfviewer.Load(stream, jsonObject);
+            return Content(JsonConvert.SerializeObject(jsonResult));
+        }
+
+        [AcceptVerbs("Post")]
+        [HttpPost("Bookmarks")]
+        [Microsoft.AspNetCore.Cors.EnableCors("MyPolicy")]
+        [Route("[controller]/Bookmarks")]
+        //Post action for processing the bookmarks from the PDF documents
+        public IActionResult Bookmarks([FromBody] Dictionary<string, string> jsonObject)
+        {
+            //Initialize the PDF Viewer object with memory cache object
+            PdfRenderer pdfviewer = new PdfRenderer(_cache);
+            var jsonResult = pdfviewer.GetBookmarks(jsonObject);
+            return Content(JsonConvert.SerializeObject(jsonResult));
+        }
+
+        [AcceptVerbs("Post")]
+        [HttpPost("RenderPdfPages")]
+        [Microsoft.AspNetCore.Cors.EnableCors("MyPolicy")]
+        [Route("[controller]/RenderPdfPages")]
+        //Post action for processing the PDF documents  
+        public IActionResult RenderPdfPages([FromBody] Dictionary<string, string> jsonObject)
+        {
+            //Initialize the PDF Viewer object with memory cache object
+            PdfRenderer pdfviewer = new PdfRenderer(_cache);
+            object jsonResult = pdfviewer.GetPage(jsonObject);
+            return Content(JsonConvert.SerializeObject(jsonResult));
+        }
+
+        [AcceptVerbs("Post")]
+        [HttpPost("RenderPdfTexts")]
+        [Microsoft.AspNetCore.Cors.EnableCors("MyPolicy")]
+        [Route("[controller]/RenderPdfTexts")]
+        //Post action for processing the PDF texts  
+        public IActionResult RenderPdfTexts([FromBody] Dictionary<string, string> jsonObject)
+        {
+            //Initialize the PDF Viewer object with memory cache object
+            PdfRenderer pdfviewer = new PdfRenderer(_cache);
+            object jsonResult = pdfviewer.GetDocumentText(jsonObject);
+            return Content(JsonConvert.SerializeObject(jsonResult));
+        }
+
+        [AcceptVerbs("Post")]
+        [HttpPost("RenderThumbnailImages")]
+        [Microsoft.AspNetCore.Cors.EnableCors("MyPolicy")]
+        [Route("[controller]/RenderThumbnailImages")]
+        //Post action for rendering the ThumbnailImages
+        public IActionResult RenderThumbnailImages([FromBody] Dictionary<string, string> jsonObject)
+        {
+            //Initialize the PDF Viewer object with memory cache object
+            PdfRenderer pdfviewer = new PdfRenderer(_cache);
+            object result = pdfviewer.GetThumbnailImages(jsonObject);
+            return Content(JsonConvert.SerializeObject(result));
+        }
+        [AcceptVerbs("Post")]
+        [HttpPost("RenderAnnotationComments")]
+        [Microsoft.AspNetCore.Cors.EnableCors("MyPolicy")]
+        [Route("[controller]/RenderAnnotationComments")]
+        //Post action for rendering the annotations
+        public IActionResult RenderAnnotationComments([FromBody] Dictionary<string, string> jsonObject)
+        {
+            //Initialize the PDF Viewer object with memory cache object
+            PdfRenderer pdfviewer = new PdfRenderer(_cache);
+            object jsonResult = pdfviewer.GetAnnotationComments(jsonObject);
+            return Content(JsonConvert.SerializeObject(jsonResult));
+        }
+        [AcceptVerbs("Post")]
+        [HttpPost("ExportAnnotations")]
+        [Microsoft.AspNetCore.Cors.EnableCors("MyPolicy")]
+        [Route("[controller]/ExportAnnotations")]
+        //Post action to export annotations
+        public IActionResult ExportAnnotations([FromBody] Dictionary<string, string> jsonObject)
+        {
+            PdfRenderer pdfviewer = new PdfRenderer(_cache);
+            string jsonResult = pdfviewer.ExportAnnotation(jsonObject);
+            return Content(jsonResult);
+        }
+        [AcceptVerbs("Post")]
+        [HttpPost("ImportAnnotations")]
+        [Microsoft.AspNetCore.Cors.EnableCors("MyPolicy")]
+        [Route("[controller]/ImportAnnotations")]
+        //Post action to import annotations
+        public IActionResult ImportAnnotations([FromBody] Dictionary<string, string> jsonObject)
+        {
+            PdfRenderer pdfviewer = new PdfRenderer(_cache);
+            string jsonResult = string.Empty;
+            object JsonResult;
+            if (jsonObject != null && jsonObject.ContainsKey("fileName"))
+            {
+                string documentPath = GetDocumentPath(jsonObject["fileName"]);
+                if (!string.IsNullOrEmpty(documentPath))
+                {
+                    jsonResult = System.IO.File.ReadAllText(documentPath);
+                }
+                else
+                {
+                    return this.Content(jsonObject["document"] + " is not found");
+                }
+            }
+            else
+            {
+                string extension = Path.GetExtension(jsonObject["importedData"]);
+                if (extension != ".xfdf")
+                {
+                    JsonResult = pdfviewer.ImportAnnotation(jsonObject);
+                    return Content(JsonConvert.SerializeObject(JsonResult));
+                }
+                else
+                {
+                    string documentPath = GetDocumentPath(jsonObject["importedData"]);
+                    if (!string.IsNullOrEmpty(documentPath))
+                    {
+                        byte[] bytes = System.IO.File.ReadAllBytes(documentPath);
+                        jsonObject["importedData"] = Convert.ToBase64String(bytes);
+                        JsonResult = pdfviewer.ImportAnnotation(jsonObject);
+                        return Content(JsonConvert.SerializeObject(JsonResult));
+                    }
+                    else
+                    {
+                        return this.Content(jsonObject["document"] + " is not found");
+                    }
+                }
+            }
+            return Content(jsonResult);
+        }
+
+        [AcceptVerbs("Post")]
+        [HttpPost("ExportFormFields")]
+        [Microsoft.AspNetCore.Cors.EnableCors("MyPolicy")]
+        [Route("[controller]/ExportFormFields")]
+        public IActionResult ExportFormFields([FromBody] Dictionary<string, string> jsonObject)
+
+        {
+            PdfRenderer pdfviewer = new PdfRenderer(_cache);
+            string jsonResult = pdfviewer.ExportFormFields(jsonObject);
+            return Content(jsonResult);
+        }
+
+        [AcceptVerbs("Post")]
+        [HttpPost("ImportFormFields")]
+        [Microsoft.AspNetCore.Cors.EnableCors("MyPolicy")]
+        [Route("[controller]/ImportFormFields")]
+        public IActionResult ImportFormFields([FromBody] Dictionary<string, string> jsonObject)
+        {
+            PdfRenderer pdfviewer = new PdfRenderer(_cache);
+            jsonObject["data"] = GetDocumentPath(jsonObject["data"]);
+            object jsonResult = pdfviewer.ImportFormFields(jsonObject);
+            return Content(JsonConvert.SerializeObject(jsonResult));
+        }
+
+        [AcceptVerbs("Post")]
+        [HttpPost("Unload")]
+        [Microsoft.AspNetCore.Cors.EnableCors("MyPolicy")]
+        [Route("[controller]/Unload")]
+        //Post action for unloading and disposing the PDF document resources  
+        public IActionResult Unload([FromBody] Dictionary<string, string> jsonObject)
+        {
+            //Initialize the PDF Viewer object with memory cache object
+            PdfRenderer pdfviewer = new PdfRenderer(_cache);
+            pdfviewer.ClearCache(jsonObject);
+            return this.Content("Document cache is cleared");
+        }
+
+
+        [HttpPost("Download")]
+        [Microsoft.AspNetCore.Cors.EnableCors("MyPolicy")]
+        [Route("[controller]/Download")]
+        //Post action for downloading the PDF documents
+        public IActionResult Download([FromBody] Dictionary<string, string> jsonObject)
+        {
+            //Initialize the PDF Viewer object with memory cache object
+            PdfRenderer pdfviewer = new PdfRenderer(_cache);
+            string documentBase = pdfviewer.GetDocumentAsBase64(jsonObject);
+            return Content(documentBase);
+        }
+
+        [HttpPost("PrintImages")]
+        [Microsoft.AspNetCore.Cors.EnableCors("MyPolicy")]
+        [Route("[controller]/PrintImages")]
+        //Post action for printing the PDF documents
+        public IActionResult PrintImages([FromBody] Dictionary<string, string> jsonObject)
+        {
+            //Initialize the PDF Viewer object with memory cache object
+            PdfRenderer pdfviewer = new PdfRenderer(_cache);
+            object pageImage = pdfviewer.GetPrintImage(jsonObject);
+            return Content(JsonConvert.SerializeObject(pageImage));
+        }
+
+        //Gets the path of the PDF document
+        private string GetDocumentPath(string document)
+        {
+            string documentPath = string.Empty;
+            if (!System.IO.File.Exists(document))
+            {
+                var path = _hostingEnvironment.ContentRootPath;
+                if (System.IO.File.Exists(path + "/Data/" + document))
+                    documentPath = path + "/Data/" + document;
+            }
+            else
+            {
+                documentPath = document;
+            }
+            Console.WriteLine(documentPath);
+            return documentPath;
+        }
+        // GET api/values
+        [HttpGet]
+        public IEnumerable<string> Get()
+        {
+            return new string[] { "value1", "value2" };
+        }
+
+        // GET api/values/5
+        [HttpGet("{id}")]
+        public string Get(int id)
+        {
+            return "value";
+        }
+    }
+}

Ubuntu-Focal/PdfViewerWebService_6.0/Controllers/WeatherForecastController.cs

@@ -0,0 +1,33 @@
+using Microsoft.AspNetCore.Mvc;
+
+namespace PdfViewerWebService_6._0.Controllers
+{
+    [ApiController]
+    [Route("[controller]")]
+    public class WeatherForecastController : ControllerBase
+    {
+        private static readonly string[] Summaries = new[]
+        {
+        "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
+    };
+
+        private readonly ILogger<WeatherForecastController> _logger;
+
+        public WeatherForecastController(ILogger<WeatherForecastController> logger)
+        {
+            _logger = logger;
+        }
+
+        [HttpGet(Name = "GetWeatherForecast")]
+        public IEnumerable<WeatherForecast> Get()
+        {
+            return Enumerable.Range(1, 5).Select(index => new WeatherForecast
+            {
+                Date = DateTime.Now.AddDays(index),
+                TemperatureC = Random.Shared.Next(-20, 55),
+                Summary = Summaries[Random.Shared.Next(Summaries.Length)]
+            })
+            .ToArray();
+        }
+    }
+}

Ubuntu-Focal/PdfViewerWebService_6.0/Dockerfile

@@ -0,0 +1,28 @@
+#See https://aka.ms/containerfastmode to understand how Visual Studio uses this Dockerfile to build your images for faster debugging.
+
+FROM mcr.microsoft.com/dotnet/aspnet:6.0 AS base
+RUN ln -s /lib/x86_64-linux-gnu/libdl-2.24.so /lib/x86_64-linux-gnu/libdl.so
+
+# install System.Drawing native dependencies
+RUN apt-get update && apt-get install -y --allow-unauthenticated libgdiplus libc6-dev libx11-dev
+RUN ln -s libgdiplus.so gdiplus.dll
+
+WORKDIR /app
+EXPOSE 80
+EXPOSE 443
+
+FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
+WORKDIR /src
+COPY ["PdfViewerWebService_6.0.csproj", "."]
+RUN dotnet restore "./PdfViewerWebService_6.0.csproj"
+COPY . .
+WORKDIR "/src/."
+RUN dotnet build "PdfViewerWebService_6.0.csproj" -c Release -o /app/build
+
+FROM build AS publish
+RUN dotnet publish "PdfViewerWebService_6.0.csproj" -c Release -o /app/publish /p:UseAppHost=false
+
+FROM base AS final
+WORKDIR /app
+COPY --from=publish /app/publish .
+ENTRYPOINT ["dotnet", "PdfViewerWebService_6.0.dll"]