Add HTML Stamp with Page Numbering to Generated PDF

using System;
using System.IO;
using System.ComponentModel.DataAnnotations;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Http;
using HiQPdf_Next_AspNetDemo.Models;

using HiQPdf.Next;

namespace HiQPdf_Next_AspNetDemo.Controllers
{
    public class StampWithHtmlGeneratedPdfController : Controller
    {
        private readonly IWebHostEnvironment m_hostingEnvironment;
        public StampWithHtmlGeneratedPdfController(IWebHostEnvironment hostingEnvironment)
        {
            m_hostingEnvironment = hostingEnvironment;
        }

        public IActionResult Index()
        {
            var model = SetViewModel();

            return View(model);
        }

        [HttpPost]
        public ActionResult ConvertToPdf(StampWithHtmlGeneratedPdfViewModel model)
        {
            if (!ModelState.IsValid)
            {
                var errorMessage = ModelStateHelper.GetModelErrors(ModelState);
                throw new ValidationException(errorMessage);
            }

            // Set the serial number received after purchase to use the library in licensed mode; leave it commented for demo mode
            // Licensing.SerialNumber = "your-serial-number";

            // Create an HTML to PDF converter object with default settings
            HtmlToPdf htmlToPdfConverter = new HtmlToPdf();

            bool stampEnabled = model.StampEnabled;
            if (stampEnabled)
            {
                PdfHtmlTemplate stamp = null;

                // Get stamp width
                int stampWidth = model.StampWidth;

                // Get stamp height
                int stampHeight = model.StampHeight.HasValue ? model.StampHeight.Value : 0;

                // Get stamp top left corner X and Y position
                int x = model.StampXPosition;
                int y = model.StampYPosition;

                // Get horizontal alignment, which takes precedence over the X coordinate when specified
                PdfTemplateHorizontalAlign horizontalAlign = model.HorizontalAlign;

                // Get vertical alignment, which takes precedence over the Y coordinate when specified
                PdfTemplateVerticalAlign verticalAlign = model.VerticalAlign;

                // Set the stamp HTML from a URL or from an HTML string
                bool stampHtmlFromUrl = model.StampHtmlSource == "Url";
                if (stampHtmlFromUrl)
                {
                    string stampUrl = model.StampUrl;

                    if (stampHeight > 0)
                    {
                        // The stamp has a specified height
                        stamp = htmlToPdfConverter.Document.AddHtmlTemplate(x, y, stampWidth, stampHeight,
                            horizontalAlign, verticalAlign, stampUrl);
                    }
                    else
                    {
                        // The stamp size is automatically determined from the HTML content when AutoSizeContentHeight is true
                        stamp = htmlToPdfConverter.Document.AddHtmlTemplate(x, y, stampWidth, stampHeight,
                           horizontalAlign, verticalAlign, stampUrl);
                    }
                }
                else
                {
                    string stampHtml = model.StampHtml;
                    string stampHtmlBaseUrl = model.StampHtmlBaseUrl;

                    if (stampHeight > 0)
                    {
                        // The stamp has a specified height
                        stamp = htmlToPdfConverter.Document.AddHtmlTemplate(x, y, stampWidth, stampHeight,
                            horizontalAlign, verticalAlign, stampHtml, stampHtmlBaseUrl);
                    }
                    else
                    {
                        // The stamp size is automatically determined from the HTML content when AutoSizeContentHeight is true
                        stamp = htmlToPdfConverter.Document.AddHtmlTemplate(x, y, stampWidth, stampHeight,
                            horizontalAlign, verticalAlign, stampHtml, stampHtmlBaseUrl);
                    }
                }

                // Set stamp rotation degrees. Positive values rotate counter-clockwise
                stamp.RotationDegrees = model.RotationDirection == RotationDirection.CounterClockwise
                        ? model.RotationDegrees
                        : -model.RotationDegrees;

                // Set stamp rotation pivot
                stamp.RotationPivot = model.RotationPivot;

                // If AutoSizeContentHeight is true, the Height property is positive and FitHeight is true,
                // the content may be scaled down to fit the specified height
                bool fitStampHeight = model.FitStampHeight;
                stamp.FitHeight = fitStampHeight;

                // Set the auto resize stamp option to allow the stamp height adjust based on HTML content
                bool autoSizeStampContentHeight = model.AutoSizeStampContentHeight;
                stamp.AutoSizeContentHeight = autoSizeStampContentHeight;

                // Set Min and Max content height used when the AutoSizeContentHeight property is true
                stamp.MinContentHeight = model.StampMinContentHeight;
                stamp.MaxContentHeight = model.StampMaxContentHeight;

                // The zoom at which the stamp HTML is laid out and drawn, at the same stamp width
                stamp.Zoom = model.StampZoom;

                // Set stamp visibility in PDF for the first page, odd pages, and even pages
                stamp.ShowInFirstPage = model.ShowStampInFirstPage;
                stamp.ShowInOddPages = model.ShowStampInOddPages;
                stamp.ShowInEvenPages = model.ShowStampInEvenPages;

                // Sets the opacity for the entire stamp content, including text.
                // To apply opacity only to the background, use the alpha channel
                // in the CSS background-color property of the body element,
                // e.g., background-color: rgba(255, 255, 255, 0.75);
                int opacity = model.StampOpacity;
                stamp.Opacity = ((float)opacity) / 100;

                // Optimize the stamp rendering time by providing a hint if the HTML template contains variables such as { page_number} or { total_pages}
                stamp.SkipVariablesParsing = model.SkipVariablesParsing;

                // Optionally set additional time to wait for the asynchronous stamp HTML content before rendering
                if (model.WaitBeforeConvert > 0)
                    stamp.WaitBeforeConvert = model.WaitBeforeConvert;
            }

            // Convert the HTML page to a PDF document in a memory buffer
            byte[] outPdfBuffer = htmlToPdfConverter.ConvertUrlToMemory(model.Url);

            // Send the PDF file to browser
            FileResult fileResult = new FileContentResult(outPdfBuffer, "application/pdf");
            fileResult.FileDownloadName = "StampWithHtmlGeneratedPdf.pdf";

            return fileResult;
        }

        private PdfTemplateHorizontalAlign SelectedHorizontalAlign(string selectedValue)
        {
            switch (selectedValue)
            {
                case "None":
                    return PdfTemplateHorizontalAlign.None;
                case "Left":
                    return PdfTemplateHorizontalAlign.Left;
                case "Center":
                    return PdfTemplateHorizontalAlign.Center;
                case "Right":
                    return PdfTemplateHorizontalAlign.Right;
                default:
                    return PdfTemplateHorizontalAlign.None;
            }
        }

        private PdfTemplateVerticalAlign SelectedVerticalAlign(string selectedValue)
        {
            switch (selectedValue)
            {
                case "None":
                    return PdfTemplateVerticalAlign.None;
                case "Top":
                    return PdfTemplateVerticalAlign.Top;
                case "Center":
                    return PdfTemplateVerticalAlign.Center;
                case "Bottom":
                    return PdfTemplateVerticalAlign.Bottom;
                default:
                    return PdfTemplateVerticalAlign.None;
            }
        }

        private StampWithHtmlGeneratedPdfViewModel SetViewModel()
        {
            var model = new StampWithHtmlGeneratedPdfViewModel();

            var contentRootPath = Path.Combine(m_hostingEnvironment.ContentRootPath, "wwwroot");

            HttpRequest request = ControllerContext.HttpContext.Request;
            UriBuilder uriBuilder = new UriBuilder();
            uriBuilder.Scheme = request.Scheme;
            uriBuilder.Host = request.Host.Host;
            if (request.Host.Port != null)
                uriBuilder.Port = (int)request.Host.Port;
            uriBuilder.Path = request.PathBase.ToString() + request.Path.ToString();
            uriBuilder.Query = request.QueryString.ToString();

            string currentPageUrl = uriBuilder.Uri.AbsoluteUri;
            string rootUrl = currentPageUrl.Substring(0, currentPageUrl.Length - "StampWithHtmlGeneratedPdf".Length);

            model.StampHtml = System.IO.File.ReadAllText(Path.Combine(contentRootPath, "DemoFiles/Html/Stamp_HTML.html"));
            model.StampHtmlBaseUrl = rootUrl + "DemoFiles/Html/";
            model.StampUrl = rootUrl + "DemoFiles/Html/Stamp_HTML.html";

            return model;
        }
    }
}

<!DOCTYPE html>
<html>
<head>
    <title>HTML Stamp with Page Numbers</title>
</head>
<!-- Use background-color: rgba(r, g, b, a) to apply background opacity (a = 0 transparent, 1 opaque) -->
<body style="background-color: rgba(255, 255, 255, 0.9); font-family: 'Times New Roman'; font-size: 16px; margin: 5px">
    <table style="width: 100%; border: 3px solid royalblue">
        <tr>
            <td>
                <a href="http://www.hiqpdf.com">
                    <img alt="Logo Image" src="Images/HiQPdfLogo.png" />
                </a>
            </td>
            <td>
                <table>
                    <tr>
                        <td style="font-size: 30px; font-weight: bold; color: #BE1200">
                            HTML Stamp with Page Numbers
                        </td>
                    </tr>
                    <tr>
                        <td>
                            <span style="font-size: 16px">Page <span style="color:blue">{page_number}</span> of <span style="color:green">{total_pages}</span> pages</span>
                        </td>
                    </tr>
                </table>
            </td>
        </tr>
    </table>
</body>
</html>