From 2abc850c33693b607169b798110b0ad12981654d Mon Sep 17 00:00:00 2001
From: Tom Schraitle <toms@suse.de>
Date: Mon, 29 Jan 2024 13:50:06 +0100
Subject: [PATCH] Fix DOCTEAM-1249: Create external JSON-LD file

The structure is based on schema.org

Introduce new parameters:

* generate.json-ld.external (0=no, 1=yes)
  Should a JSON-LD structure stored?
* json-ld-use-individual-authors (0=no, 1=yes)
  Should the individual authors be used?
* json-ld.ext (default ".json)
  The default extension of the JSON file
* json-ld-date-timezone (default "T00:00+02:00)
  The default timezone for dates when no timezone is specified
* json-ld-fallback-author-name (default "SUSE Product & Solution
  Documentation Team")
  Default name of author when no <author> is specified
* json-ld-fallback-author-url (default: "https://documentation.suse.com")
  Default URL for an author, when no <author> is specified
* json-ld-fallback-author-type (default "Corporation")
  Default type of an author, when no <author> is specified
* json-ld-fallback-author-logo (default
  "https://www.suse.com/assets/img/suse-white-logo-green.svg")
  Default logo URL, when no <author> is specified
* json-ld-image-url (default $json-ld-fallback-author-logo)
  Default image URL for a TechArticle
* stitchfile (str, default ='')
  Absolute filename to the single stitch file that Docserv generates on startup
---
 suse2022-ns/xhtml/docbook.xsl |  33 ++
 suse2022-ns/xhtml/json-ld.xsl | 714 +++++++++++++++++++++++++++-------
 suse2022-ns/xhtml/param.xsl   |  19 +-
 3 files changed, 621 insertions(+), 145 deletions(-)

diff --git a/suse2022-ns/xhtml/docbook.xsl b/suse2022-ns/xhtml/docbook.xsl
index b0986865..559f4307 100644
--- a/suse2022-ns/xhtml/docbook.xsl
+++ b/suse2022-ns/xhtml/docbook.xsl
@@ -699,6 +699,39 @@
     </xsl:if>
   </xsl:template>
 
+
+  <!-- ############################################################## -->
+  <xsl:template match="d:book|d:article|d:set" priority="2" mode="process.root">
+    <xsl:apply-imports/>
+    <xsl:if test="$rootid = @xml:id and $is.chunk = 0">
+      <xsl:choose>
+        <xsl:when test="$dcfilename != ''">
+          <xsl:call-template name="generate-json-ld-external">
+            <xsl:with-param name="node" select="." />
+          </xsl:call-template>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:call-template name="log.message">
+            <xsl:with-param name="level">WARN</xsl:with-param>
+            <xsl:with-param name="context-desc">
+              <xsl:text>JSON-LD</xsl:text>
+            </xsl:with-param>
+            <xsl:with-param name="message">
+              <xsl:text>The parameter $dcfile is unset. Cannot find the DC file in Docserv config.</xsl:text>
+            </xsl:with-param>
+          </xsl:call-template>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:if>
+  </xsl:template>
+
+  <xsl:template match="/" priority="2" mode="process.root">
+    <xsl:apply-imports/>
+    <xsl:call-template name="generate-json-ld-external">
+      <xsl:with-param name="node" select="/*"/>
+    </xsl:call-template>
+  </xsl:template>
+
   <xsl:template match="*" mode="process.root">
     <xsl:param name="prev"/>
     <xsl:param name="next"/>
diff --git a/suse2022-ns/xhtml/json-ld.xsl b/suse2022-ns/xhtml/json-ld.xsl
index c774891b..33def1dd 100644
--- a/suse2022-ns/xhtml/json-ld.xsl
+++ b/suse2022-ns/xhtml/json-ld.xsl
@@ -7,26 +7,63 @@
      * $generate.json-ld (default 1): generate the structure (=1) or not (=0)
 
    Output:
-     HTML <script type="application/ld+json"> tag containing JSON-LD
+     * Inside HTML <script type="application/ld+json"> tag containing JSON-LD
+     * An external JSON file named after the DC file (without the "DC-" prefix,
+       but with a ".json" suffix)
 
    Specification:
-     https://schema.org/TechArticle
+     * https://schema.org/TechArticle
+     * https://confluence.suse.com/x/CYBGVg
 
    Example:
+     From doc-modular, DC-sudo-configure-superuser-privileges:
      <script type="application/ld+json">
       {
-        "@context": "https://schema.org/",
-        "@type": "TechArticle",
-        "name": "Getting Started with ExampleApp",
-        "headline": "ExampleApp Documentation",
-        "description": "A comprehensive guide to get started with ExampleApp.",
-        "author": {
-          "@type": "Person",
-          "name": "Tux Penguin",
-          "role": "Writer"
+        "@context": "http://schema.org",
+        "@type": [
+          "TechArticle"
+        ],
+        "image": "https://www.suse.com/assets/img/suse-white-logo-green.svg",
+        "isPartOf": {
+          "@type": "CreativeWorkSeries",
+          "name": "Smart Docs"
         },
-        "datePublished": "2023-07-24",
-        "dateModified": "2023-07-25",
+        "inLanguage": "en",
+        "headline": "Configuring superuser privileges with sudo",
+        "description": "Learn how to delegate superuser privileges with sudo.",
+        "author": [
+          {
+            "@type": "Corporation",
+            "name": "SUSE Product & Solution Documentation Team",
+            "url": "https://www.suse.com/assets/img/suse-white-logo-green.svg"
+          }
+        ],
+        "datePublished": "2024-02-15T00:00+02:00",
+        "dateModified": "2024-02-16T00:00+02:00",
+        "about": [
+          {
+            "@type": "Thing",
+            "name": "Systems Management"
+          },
+          {
+            "@type": "Thing",
+            "name": "Configuration"
+          },
+          {
+            "@type": "Thing",
+            "name": "Security"
+          }
+        ],
+        "mentions": [
+          {
+            "@type": "SoftwareApplication",
+            "name": "Adaptable Linux Platform",
+            "softwareVersion": "1",
+            "applicationCategory": "Operating System",
+            "operatingSystem": "Linux",
+            "processorRequirements": "AMD64/Intel 64, IBM LinuxONE, Arm, POWER"
+          }
+        ],
         "sameAs": [
           "https://www.facebook.com/SUSEWorldwide/about",
           "https://www.youtube.com/channel/UCHTfqIzPKz4f_dri36lAQGA",
@@ -34,8 +71,9 @@
           "https://www.linkedin.com/company/suse"
         ],
         "publisher": {
-          "@type": "Organization",
+          "@type": "Corporation",
           "name": "SUSE",
+          "url": "https://documentation.suse.com",
           "logo": {
             "@type": "ImageObject",
             "url": "https://www.suse.com/assets/img/suse-white-logo-green.svg"
@@ -44,9 +82,29 @@
       }
      </script>
 
-   Authors:    Thomas Schraitle <toms@opensuse.org>,
+   HINT 1
+     To create a JSON-LD structure for the HTML file, use generate.json-ld=1
+     If you need an additional external JSON-LD file, use:
+     * generate.json-ld=1
+     * generate.json-ld.external=1
+     * stitchfile="/tmp/docserv-stitch-....xml"
+     * dcfilename="DC-..."
+
+   HINT 2
+     Validate the output with:
+     * https://validator.schema.org
+     * https://search.google.com/test/rich-results
+
+   Authors:    Thomas Schraitle <toms@opensuse.org>, 2023-2024
 
 -->
+<!DOCTYPE xsl:stylesheet [
+  <!ENTITY ascii.uc "ABCDEFGHIJKLMNOPQRSTUVWXYZ">
+  <!ENTITY ascii.lc "abcdefghijklmnopqrstuvwxy">
+  <!ENTITY lowercase "&ascii.lc;">
+  <!ENTITY uppercase "&ascii.uc;">
+
+]>
 <xsl:stylesheet version="1.0"
   xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
   xmlns:d="http://docbook.org/ns/docbook"
@@ -55,38 +113,268 @@
   xmlns="http://www.w3.org/1999/xhtml"
   exclude-result-prefixes="date exsl d">
 
-  <xsl:template name="generate-json-ld">
+  <xsl:variable name="stitchxml" select="document($stitchfile)/*"/>
+  <xsl:key name="docserv-dcfiles" match="dc" use="."/>
+
+
+  <xsl:template name="sanitize-date">
+    <xsl:param name="date" select="."/>
+    <xsl:variable name="length"  select="string-length($date)"/>
+    <xsl:variable name="dashes" select="($length - string-length(translate($date, '-', ''))) = 2"/>
+    <xsl:variable name="withcolon" select="contains($date, ':')" />
+    <!-- Check if the (ISO?) date is in YYYY-MM or YYYY-M format and append
+         "0" where necessary
+    -->
+    <xsl:choose>
+      <!-- This is the case of a complete date: YYYYMMDDT00:00+02:00
+           We return it unchanged
+      -->
+      <xsl:when test="$length = 22">
+        <xsl:value-of select="$date"/>
+      </xsl:when>
+      <!-- We have a potential complete ISO date, return it unchanged -->
+      <xsl:when test="$length = 10 and $dashes">
+        <xsl:value-of select="concat($date, $json-ld-date-timezone)"/>
+      </xsl:when>
+      <!-- We have an incomplete date, probably YYYY-M-D -->
+      <xsl:when test="$length = 8 and $dashes">
+        <xsl:variable name="year" select="substring($date, 1, 4)"/>
+        <xsl:variable name="month" select="concat('0', substring($date, 6, 2))"/>
+        <xsl:variable name="day" select="concat('0', substring($date, 8, 2))"/>
+        <xsl:value-of select="concat($year, '-', $month, '-', $day, $json-ld-date-timezone)"/>
+      </xsl:when>
+      <!-- We have an incomplete date, probably YYYY-MM so append the day -->
+      <xsl:when test="$length = 7">
+        <xsl:value-of select="concat(substring($date, 1, 7), '-01', $json-ld-date-timezone)"/>
+      </xsl:when>
+      <!-- We have an incomplete date, probably YYYY-M.  -->
+      <xsl:when test="$length = 6">
+        <xsl:variable name="year" select="substring($date, 1, 4)"/>
+        <xsl:variable name="month" select="concat('0', substring($date, 6, 2))"/>
+        <xsl:value-of select="concat($year, '-', $month, '-', '01', $json-ld-date-timezone)"/>
+      </xsl:when>
+      <!-- A potential ISO date with a timezone? Return it unchanged -->
+      <xsl:when test="$length = 16 and $withcolon">
+        <xsl:value-of select="$date"/>
+      </xsl:when>
+      <xsl:when test="$length = 14 and $withcolon">
+        <xsl:variable name="year" select="substring($date, 1, 4)"/>
+        <xsl:variable name="month" select="concat('0', substring($date, 6, 2))"/>
+        <xsl:variable name="day" select="concat('0', substring($date, 8, 2))"/>
+        <xsl:variable name="timezone" select="substring($date, 9)"/>
+        <xsl:value-of select="concat($year, '-', $month, '-', $day, $timezone)"/>
+      </xsl:when>
+      <!-- Seems, we don't have a date. We can't guess anything useful, so output a warning -->
+      <xsl:otherwise>
+        <xsl:message>WARN: Cannot convert string '<xsl:value-of select="$date"/>'. Not a valid date!</xsl:message>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <xsl:template name="get-basename">
+    <xsl:param name="node" select="."/>
+    <xsl:variable name="base">
+      <xsl:choose>
+          <xsl:when test="$node/@xml:base">
+            <xsl:value-of select="substring-before($node/@xml:base, '.xml')" />
+          </xsl:when>
+          <xsl:when test="$node/@xml:id and $use.id.as.filename != 0">
+            <xsl:value-of select="$node/@xml:id" />
+          </xsl:when>
+          <xsl:otherwise /><!-- TODO: What do we do here, if nothing works? -->
+        </xsl:choose>
+    </xsl:variable>
+    <xsl:value-of select="$base"/>
+  </xsl:template>
+
+  <xsl:template name="get-dc-filename">
+    <xsl:param name="node" select="."/>
+    <xsl:variable name="base">
+      <xsl:call-template name="get-basename">
+        <xsl:with-param name="node" select="$node"/>
+      </xsl:call-template>
+    </xsl:variable>
+    <xsl:choose>
+      <xsl:when test="$dcfilename != ''">
+        <xsl:value-of select="$dcfilename"/>
+      </xsl:when>
+      <xsl:otherwise>
+        <xsl:value-of select="concat('DC-', $base)"/>
+      </xsl:otherwise>
+    </xsl:choose>
+  </xsl:template>
+
+  <!-- ========================================================== -->
+  <xsl:template name="generate-json-ld-external">
+    <xsl:param name="node" select="."/>
+    <xsl:variable name="base">
+      <xsl:call-template name="get-basename">
+        <xsl:with-param name="node" select="$node"/>
+      </xsl:call-template>
+    </xsl:variable>
+    <xsl:variable name="filename">
+      <xsl:variable name="dcfile">
+        <xsl:call-template name="get-dc-filename"/>
+      </xsl:variable>
+      <xsl:variable name="file" select="substring-after($dcfile, 'DC-')"/>
+      <xsl:choose>
+        <xsl:when test="$base != ''">
+          <xsl:value-of select="concat($base, $json-ld.ext)"/>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:value-of select="concat($file, $json-ld.ext)"/>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+    <xsl:variable name="content">
+      <xsl:call-template name="generate-json-content">
+        <xsl:with-param name="node" select="$node"/>
+      </xsl:call-template>
+    </xsl:variable>
+
+    <xsl:if test="$generate.json-ld.external != 0">
+      <!--
+        <xsl:message>Going to write external JSON-LD structure to "<xsl:value-of
+        select="$filename"/>" for <xsl:value-of select="local-name($node)"/>
+      Found <xsl:value-of select="count($stitchxml)"/> node(s) (=<xsl:value-of select="local-name($stitchxml)"/>).
+      <xsl:if test="$dcfilename">Found DC filename "<xsl:value-of select="$dcfilename"/>"</xsl:if>
+      base.dir="<xsl:value-of select="$base.dir"/>"
+      filename="<xsl:value-of select="$filename"/>"
+      </xsl:message>
+      -->
+      <xsl:call-template name="write.chunk">
+        <xsl:with-param name="filename" select="concat($base.dir, $filename)"/>
+        <xsl:with-param name="quiet" select="0"/>
+        <xsl:with-param name="method">text</xsl:with-param>
+        <xsl:with-param name="doctype-public"/>
+        <xsl:with-param name="doctype-system"/>
+        <xsl:with-param name="content" select="$content"/>
+      </xsl:call-template>
+    </xsl:if>
+  </xsl:template>
+
+
+  <xsl:template name="generate-json-content">
     <xsl:param name="node"/>
-    <xsl:if test="$generate.json-ld != 0">
-      <xsl:message>INFO: Going to generate JSON-LD...</xsl:message>
-      <script type="application/ld+json">
-{
+    <xsl:text>{</xsl:text>
     "@context": "http://schema.org",
-    "@type": "TechArticle",<!--
-
+    "@type": ["TechArticle"],
+    "image": "<xsl:value-of select="$json-ld-image-url"/>",
+    <xsl:call-template name="json-ld-type">
+      <xsl:with-param name="node" select="$node"/>
+    </xsl:call-template>
+    <xsl:call-template name="json-ld-series">
+      <xsl:with-param name="node" select="$node"/>
+    </xsl:call-template>
+    <xsl:call-template name="json-ld-language">
+      <xsl:with-param name="node" select="$node"/>
+    </xsl:call-template>
+    <xsl:call-template name="json-ld-headline">
+      <xsl:with-param name="node" select="$node"/>
+    </xsl:call-template>
+    <xsl:call-template name="json-ld-description">
+      <xsl:with-param name="node" select="$node"/>
+    </xsl:call-template>
+    <xsl:call-template name="json-ld-keywords">
+      <xsl:with-param name="node" select="$node"/>
+    </xsl:call-template>
+    <!-- Later -->
+    <!--<xsl:call-template name="json-ld-license">
+      <xsl:with-param name="node" select="$node"/>
+    </xsl:call-template>
+    -->
+    <xsl:call-template name="json-ld-authors-and-contributors">
+      <xsl:with-param name="node" select="$node"/>
+    </xsl:call-template>
+    <xsl:call-template name="json-ld-authors-and-contributors">
+      <xsl:with-param name="node" select="$node"/>
+      <xsl:with-param name="type">editor</xsl:with-param>
+    </xsl:call-template>
+    <xsl:call-template name="json-ld-authors-and-contributors">
+      <xsl:with-param name="node" select="$node"/>
+      <xsl:with-param name="type">contributor</xsl:with-param>
+    </xsl:call-template>
+    <xsl:call-template name="json-ld-techpartner">
+      <xsl:with-param name="node" select="$node"/>
+    </xsl:call-template>
+    <xsl:call-template name="json-ld-datePublished">
+      <xsl:with-param name="node" select="$node"/>
+    </xsl:call-template>
+    <xsl:call-template name="json-ld-dateModified">
+      <xsl:with-param name="node" select="$node"/>
+    </xsl:call-template>
+    <xsl:call-template name="json-ld-category">
+      <xsl:with-param name="node" select="$node"/>
+    </xsl:call-template>
+    <xsl:call-template name="json-ld-task">
+      <xsl:with-param name="node" select="$node"/>
+    </xsl:call-template>
+    <!-- Belongs to type "SoftwareApplication" -->
+    <xsl:call-template name="json-ld-software">
+      <xsl:with-param name="node" select="$node"/>
+    </xsl:call-template>
+
+    <!-- This is the last entry. Don't add further additions due to the
+         trailing comma missing.
     -->
-        <xsl:call-template name="json-ld-headline"/>
-        <xsl:call-template name="json-ld-description"/>
-<!--        <xsl:call-template name="json-ld-keywords"/>-->
-
-        <xsl:call-template name="json-ld-license"/><!-- Later -->
-        <xsl:call-template name="json-ld-authors-and-authorgroups"/>
-        <xsl:call-template name="json-ld-datePublished"/>
-        <xsl:call-template name="json-ld-dateModified"/>
-<!--        <xsl:call-template name="json-ld-version"/>-->
-        <xsl:call-template name="json-ld-publisher"/>
-}
+    <xsl:call-template name="json-ld-publisher">
+      <xsl:with-param name="node" select="$node"/>
+    </xsl:call-template>
+    <xsl:text>}</xsl:text>
+  </xsl:template>
+
+
+  <xsl:template name="generate-json-ld">
+    <xsl:param name="node" select="."/>
+    <xsl:if test="$generate.json-ld != 0">
+      <xsl:message>INFO: Going to generate JSON-LD... ("<xsl:value-of select="$stitchfile"/>") for context element <xsl:value-of select="local-name($node)"/></xsl:message>
+      <script type="application/ld+json">
+        <xsl:call-template name="generate-json-content">
+          <xsl:with-param name="node" select="$node"/>
+        </xsl:call-template>
       </script>
       <xsl:text>&#10;</xsl:text>
     </xsl:if>
   </xsl:template>
 
+  <!-- ========================================================== -->
+  <xsl:template name="json-ld-type">
+    <xsl:param name="node" select="."/>
+    <!-- We expect only _one_ type (relevant for TRD) -->
+    <xsl:variable name="type" select="$node/d:info/d:meta[@name='type'][1]"/>
+    <xsl:if test="$type">
+    "additionalType": "<xsl:value-of select="normalize-space($type)"/>",
+    </xsl:if>
+  </xsl:template>
+
   <xsl:template name="json-ld-headline">
     <xsl:param name="node" select="."/>
-    <xsl:variable name="headline" select="normalize-space(($node/d:info/d:meta[@name='title'] | $node/d:info/d:title | $node/d:title)[last()])"/>
+    <xsl:variable name="headline"
+      select="normalize-space(($node/d:info/d:meta[@name='title'] | $node/d:info/d:title | $node/d:title)[last()])"/>
     "headline": "<xsl:value-of select="translate($headline, '&quot;', '')"/>",
   </xsl:template>
 
+  <xsl:template name="json-ld-language">
+    <xsl:param name="node" select="."/>
+    <xsl:variable name="candidate-lang" select="($node/ancestor-or-self::*/@xml:lang)[last()]"/>
+    <xsl:variable name="lang">
+      <xsl:choose>
+        <!-- Ensure we have lang-COUNTRY with country in uppercase -->
+        <xsl:when test="contains($candidate-lang, '-')">
+          <xsl:variable name="country" select="translate(substring-after($candidate-lang, '-'),
+            '&lowercase;', '&uppercase;')"/>
+          <xsl:value-of select="concat(substring-before($candidate-lang, '-'), '-', $country)"/>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:value-of select="$candidate-lang"/>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+    <xsl:if test="$lang != ''">
+    "inLanguage": "<xsl:value-of select="$lang"/>",
+    </xsl:if>
+  </xsl:template>
+
   <xsl:template name="json-ld-description">
     <xsl:param name="node" select="."/>
     <xsl:variable name="description">
@@ -127,16 +415,21 @@
 
   <xsl:template name="json-ld-keywords">
     <xsl:param name="node" select="."/>
-    <xsl:variable name="keywords" select="$node/d:info/d:keywordset"/>
+    <xsl:variable name="keywords" select="$node/d:info/d:keywordset/d:keyword"/>
+    <xsl:variable name="meta_keywords" select="$node/d:info/meta[@name='keyword']"/>
 
-    <xsl:if test="$keywords">
-    "keywords": [
-      <xsl:for-each select="$keywords/d:keyword">
-        <xsl:value-of select="concat('&quot;', normalize-space(.), '&quot;')"/>
-        <xsl:if test="position() != last()">,&#10;      </xsl:if>
-      </xsl:for-each>
-    ],
-    </xsl:if>
+    <xsl:choose>
+      <xsl:when test="($meta_keywords | $keywords)">
+<!--        <xsl:value-of select="concat('    &quot;keywords:&quot;', ' [')"/>-->
+        <xsl:text>    "keywords": [</xsl:text>
+        <xsl:for-each select="$meta_keywords | $keywords">
+          <xsl:value-of select="concat('&quot;', normalize-space(.), '&quot;')"/>
+          <xsl:if test="position() != last()">,&#10;      </xsl:if>
+        </xsl:for-each>
+        <xsl:text>    ],</xsl:text>
+      </xsl:when>
+      <xsl:otherwise/><!-- Do nothing, if we don't find them -->
+    </xsl:choose>
   </xsl:template>
 
   <xsl:template name="json-ld-license">
@@ -148,8 +441,12 @@
     -->
   </xsl:template>
 
-  <xsl:template name="json-ld-authors-and-authorgroups">
+  <xsl:template name="json-ld-authors-and-contributors">
     <xsl:param name="node" select="."/>
+    <!-- Only "author", "editor" and "contributor" is possible.
+         WARNING: The value is not really checked
+    -->
+    <xsl:param name="type">author</xsl:param>
     <!--
        Implementation details:
 
@@ -164,7 +461,7 @@
        - We put everything from set A into a "$author" variable and wrap around an <authorgroup>
        - In XSLT 1.0, if we create temporary fragment trees (so called "result tree fragments") we need to
          convert them into "real" node trees with the extension function exsl:node-set().
-         Yes, it's annoying as fuck. :-(
+         Yes, it's annoying. :-(
        - Everything else with <authorgroup> are stored in $authorgroup variable
        - Both node sets contain <authorgroup> elements. We can create a union node set with "|"
        - The <authorgroup> element only deals as a parent element, a wrapper for its content.
@@ -173,130 +470,117 @@
        - Depending on if we have one element or many, we deal accordingly. If we don't have any element
          at all, we fallback to the default author.
     -->
-    <xsl:variable name="authors">
-      <xsl:if test="$node/d:info/d:author | $node/d:info/d:corpauthor | $node/d:info/d:othercredit | $node/d:info/d:editor">
-        <d:authorgroup>
-          <xsl:copy-of select="$node/d:info/d:author |
-                               $node/d:info/d:corpauthor |
-                               $node/d:info/d:othercredit |
-                               $node/d:info/d:editor"
-           />
-        </d:authorgroup>
-      </xsl:if>
+    <xsl:variable name="tmp-authors">
+      <d:authorgroup>
+        <xsl:choose>
+          <xsl:when test="$type = 'contributor'">
+            <xsl:copy-of select="$node/d:info/d:authorgroup/*[self::d:othercredit] |
+                                 $node/d:info/d:othercredit"/>
+          </xsl:when>
+          <xsl:when test="$type = 'editor'">
+            <xsl:copy-of select="$node/d:info/d:authorgroup/*[self::d:editor] |
+                                 $node/d:info/d:editor"/>
+          </xsl:when>
+          <xsl:otherwise>
+            <xsl:copy-of select="$node/d:info/d:authorgroup/*[self::d:author] |
+                                 $node/d:info/d:author"/>
+          </xsl:otherwise>
+        </xsl:choose>
+      </d:authorgroup>
     </xsl:variable>
-    <xsl:variable name="rtf-authors" select="exsl:node-set($authors)/*"/>
-    <xsl:variable name="authorgroup" select="$node/d:info/d:authorgroup"/>
-    <xsl:variable name="candidate-authors" select="$rtf-authors | $authorgroup"/>
+    <xsl:variable name="rtf-authors" select="exsl:node-set($tmp-authors)/*"/>
 
 <!--    <xsl:message>INFO: json-ld-authors-and-authorgroups
      authors = <xsl:value-of select="count($authors)"/>
-     name(author) = <xsl:value-of select="local-name($authors)"/>
      rtf-authors = <xsl:value-of select="count($rtf-authors/*)"/>
-     name(rtf-author) = <xsl:value-of select="local-name($rtf-authors)"/>
-     authorgroup = <xsl:value-of select="count($authorgroup)"/>
-     name(authorgroup) = <xsl:value-of select="local-name($authorgroup)"/>
-     candidate = <xsl:value-of select="count($candidate-authors/*)"/>
-     name(candidate) = <xsl:value-of select="local-name($candidate-authors)"/>
+     name(rtf-authors) = <xsl:value-of select="local-name($rtf-authors)"/>
+     name(rtf-authors/*[1]) = <xsl:value-of select="local-name($rtf-authors/*[1])"/>
     </xsl:message>-->
 
     <xsl:choose>
-      <xsl:when test="number($json-ld-use-individual-authors) = 1 and count($candidate-authors/*) = 1">
-        <xsl:message>INFO: found one author</xsl:message>
-        <xsl:variable name="person">
-          <xsl:call-template name="person.name">
-            <xsl:with-param name="node" select="$candidate-authors/*"/>
-          </xsl:call-template>
-        </xsl:variable>
-    "author": {
-      "@type": "Person",
-      "name": "<xsl:value-of select="$person"/>"<!--,
-      "role": "Writer"-->
-    },
-      </xsl:when>
-      <xsl:when test="number($json-ld-use-individual-authors) = 1 and count($candidate-authors/*) > 1">
-    "author": [<!--
-        --><xsl:call-template name="json-ld-person.name.list">
-          <xsl:with-param name="node" select="$candidate-authors"/>
-        </xsl:call-template>
+      <!-- If we don't find any authors, create a default one -->
+      <xsl:when test="$type = 'author' and count($rtf-authors/*) = 0">
+    "author": [
+      {
+        "@type": "<xsl:value-of select="$json-ld-fallback-author-type"/>",
+        "name": "<xsl:value-of select="$json-ld-fallback-author-name"/>",
+        "url": "<xsl:value-of select="$json-ld-fallback-author-logo"/>"
+      }
     ],
       </xsl:when>
-      <xsl:otherwise>
-        <xsl:call-template name="json-ld-author-fallback"/>
-      </xsl:otherwise>
-    </xsl:choose>
-  </xsl:template>
-
-  <xsl:template name="json-ld-author-fallback">
-    <xsl:param name="node" select="."/>
-    "author": {
-       "@type": "<xsl:value-of select="$json-ld-fallback-author-type"/>",
-       "name": "<xsl:value-of select="$json-ld-fallback-author-name"/>",
-       <xsl:if test="$json-ld-fallback-author-url != ''"
-         >"url": "<xsl:value-of select="$json-ld-fallback-author-url"/>",</xsl:if>
-       <xsl:if test="$json-ld-fallback-author-logo != ''">
-       "logo": "<xsl:value-of select="$json-ld-fallback-author-logo"/>"</xsl:if>
-    },
-  </xsl:template>
-
-  <xsl:template name="json-ld-version">
-    <xsl:param name="node" select="."/>
-    <xsl:variable name="version" select="($node/d:info/d:productnumber)"/>
-
-    <xsl:if test="$version != ''">
-    "version": "<xsl:value-of select="$version"/>",
-    </xsl:if>
-  </xsl:template>
-
-  <xsl:template name="json-ld-person.name.list">
-    <xsl:param name="node" select="."/>
-    <xsl:param name="person.list"  select="$node/d:author|$node/d:corpauthor|$node/d:othercredit|$node/d:editor"/>
-    <xsl:param name="person.count" select="count($person.list)"/>
-    <xsl:param name="count" select="1"/>
-
-    <xsl:choose>
-      <xsl:when test="$count &gt; $person.count"></xsl:when>
-      <xsl:otherwise>
-        <xsl:variable name="name">
-          <xsl:call-template name="person.name">
-            <xsl:with-param name="node" select="$person.list[position()=$count]"/>
+      <xsl:when test="count($rtf-authors/*) > 0">
+    "<xsl:value-of select="$type"/>": [
+      <xsl:for-each select="$rtf-authors/*">
+        <xsl:variable name="person">
+          <xsl:choose>
+            <xsl:when test="d:personname">
+              <xsl:call-template name="person.name">
+            <xsl:with-param name="node" select="."/>
           </xsl:call-template>
+            </xsl:when>
+            <xsl:when test="d:orgname">
+              <xsl:value-of select="d:orgname"/>
+            </xsl:when>
+          </xsl:choose>
         </xsl:variable>
+        <xsl:variable name="json-type">
+          <xsl:choose>
+            <xsl:when test="d:orgname">Corporation</xsl:when>
+            <xsl:when test="d:personname">Person</xsl:when>
+          </xsl:choose>
+        </xsl:variable>
+        <xsl:variable name="uri" select="normalize-space(d:uri)"/>
         {
-          "@type": "Person",
-          "name": "<xsl:value-of select="string($name)"/>"
-        }<xsl:if test="$count &lt; $person.count">,&#10;</xsl:if>
-        <xsl:call-template name="json-ld-person.name.list">
-          <xsl:with-param name="person.list" select="$person.list"/>
-          <xsl:with-param name="person.count" select="$person.count"/>
-          <xsl:with-param name="count" select="$count+1"/>
-        </xsl:call-template>
-      </xsl:otherwise>
+        "@type": "<xsl:value-of select="$json-type"/>",
+        "name": "<xsl:value-of select="$person"/>"<xsl:if test="$uri">,
+        "url": "<xsl:value-of select="normalize-space(d:uri)"/>"
+        </xsl:if>
+        <xsl:if test="not(d:orgname) and ./d:affiliation/d:orgname">,
+          "affiliation": {
+          "@type": "Corporation",
+          "name": "<xsl:value-of select="./d:affiliation/d:orgname"/>"
+          }
+        </xsl:if>
+        <!--, "role": "Writer"-->
+        }<xsl:if test="position() != last()">,&#10;      </xsl:if>
+      </xsl:for-each>
+    ],
+      </xsl:when>
+      <!-- Do we need an xsl:otherwise? -->
     </xsl:choose>
   </xsl:template>
 
   <xsl:template name="json-ld-datePublished">
     <xsl:param name="node" select="."/>
-    <xsl:variable name="date">
+    <xsl:variable name="candidate-date">
       <xsl:choose>
         <!-- We look at different tags to extract some date information.
              Depending on which tag(s) are available.
+             Sorted xsl:when from highest to lowest
 
              TODO: check format. It must be in ISO format.
         -->
         <xsl:when test="$node/d:info/d:meta[@name='published']">
           <xsl:value-of select="normalize-space(string($node/d:info/d:meta[@name='published']))"/>
         </xsl:when>
+        <xsl:when test="$node/d:info/d:revhistory/d:revision[1]/d:date">
+          <xsl:value-of select="normalize-space(string($node/d:info/d:revhistory/d:revision[1]/d:date))"/>
+        </xsl:when>
         <xsl:when test="normalize-space($node/d:info/d:pubdate) != ''">
           <xsl:value-of select="normalize-space(string($node/d:info/d:pubdate))"/>
         </xsl:when>
         <xsl:when test="normalize-space($node/d:info/d:date) != ''">
-          <xsl:value-of select="normalize-space(string($node/d:info/d:pubdate))"/>
-        </xsl:when>
-        <xsl:when test="$node/d:info/d:revhistory/d:revision[1]/d:date">
-          <xsl:value-of select="normalize-space(string($node/d:info/d:revhistory/d:revision[1]/d:date))"/>
+          <xsl:value-of select="normalize-space(string($node/d:info/d:date))"/>
         </xsl:when>
       </xsl:choose>
     </xsl:variable>
+    <xsl:variable name="date">
+      <xsl:if test="$candidate-date != ''">
+        <xsl:call-template name="sanitize-date">
+          <xsl:with-param name="date" select="$candidate-date"/>
+        </xsl:call-template>
+      </xsl:if>
+    </xsl:variable>
 
     <xsl:choose>
       <xsl:when test="$date != ''">
@@ -315,16 +599,23 @@
   </xsl:template>
 
   <xsl:template name="json-ld-dateModified">
+    <xsl:param name="node" select="."/>
+    <xsl:variable name="candidate-date">
+      <xsl:choose>
+        <xsl:when test="function-available('date:date-time') or
+                        function-available('date:dateTime')">
+          <xsl:call-template name="datetime.format">
+            <xsl:with-param name="date" select="date:date-time()" />
+            <xsl:with-param name="format">Y-m-d</xsl:with-param>
+          </xsl:call-template>
+          <xsl:value-of select="$json-ld-date-timezone"/>
+        </xsl:when>
+      </xsl:choose>
+    </xsl:variable>
     <xsl:variable name="date">
-    <xsl:choose>
-      <xsl:when test="function-available('date:date-time') or
-                      function-available('date:dateTime')">
-        <xsl:call-template name="datetime.format">
-          <xsl:with-param name="date" select="date:date-time()"/>
-          <xsl:with-param name="format">Y-m-d</xsl:with-param><!-- ISO -->
+      <xsl:call-template name="sanitize-date">
+        <xsl:with-param name="date" select="$candidate-date"/>
       </xsl:call-template>
-      </xsl:when>
-    </xsl:choose>
     </xsl:variable>
 
     <xsl:choose>
@@ -361,4 +652,141 @@
     }
   </xsl:template>
 
+  <xsl:template name="json-ld-category">
+    <xsl:param name="node" select="."/>
+    <!-- the @content can be removed if we don't use them anymore -->
+    <xsl:variable name="categories" select="$node/d:info/d:meta[@name='category']/@content |
+                                            $node/d:info/d:meta[@name='category']/*"/>
+
+    <!-- WARNING: This may be not completely correct.
+         According to schema.org, it can be only string, not a list.
+    -->
+    <xsl:if test="count($categories) > 0">
+    "articleSection": [ <xsl:for-each select="$categories">
+        "<xsl:value-of select="normalize-space(.)"/>"
+        <xsl:if test="position() != last()">,&#10;      </xsl:if>
+    </xsl:for-each>
+    ],
+    </xsl:if>
+  </xsl:template>
+
+  <xsl:template name="json-ld-techpartner">
+    <xsl:param name="node" select="."/>
+    <xsl:variable name="meta-techpartner" select="$node/d:info/d:meta[@name='techpartner']/d:phrase"/>
+    <xsl:if test="$meta-techpartner">
+    "affiliatedOrganization": [ <xsl:for-each select="$meta-techpartner">
+      {
+        "@type": "Organization",
+        "name": "<xsl:value-of select="normalize-space(.)"/>"
+      }<xsl:if test="position() != last()">,&#10;      </xsl:if>
+    </xsl:for-each>
+    ],
+    </xsl:if>
+  </xsl:template>
+
+  <!-- The following templates access the Docserv config -->
+  <xsl:template name="json-ld-series">
+    <xsl:param name="node" select="."/>
+    <xsl:variable name="meta-series" select="$node/d:info/d:meta[@name='series']"/>
+
+    <xsl:if test="$meta-series != ''">
+    "isPartOf": {
+      "@type": "CreativeWorkSeries",
+      "name": "<xsl:value-of select="normalize-space($meta-series)"/>"
+    },
+    </xsl:if>
+  </xsl:template>
+
+  <xsl:template name="json-ld-releasenotes">
+    <xsl:param name="node" select="."/>
+    <xsl:variable name="dcfile">
+      <xsl:call-template name="get-dc-filename">
+        <xsl:with-param name="node" select="$node"/>
+      </xsl:call-template>
+    </xsl:variable>
+    <xsl:variable name="candidate-productid">
+      <xsl:for-each select="$stitchxml">
+        <xsl:value-of select="translate(key('docserv-dcfiles', $dcfile)/ancestor::product/@productid,
+                                        '&lowercase;',
+                                        '&uppercase;')"/>
+      </xsl:for-each>
+    </xsl:variable>
+    <xsl:variable name="productid">
+      <xsl:choose>
+        <!-- We need to adjust some values... -->
+        <xsl:when test="$candidate-productid = 'SLES'">SUSE-SLES</xsl:when>
+        <xsl:when test="$candidate-productid = 'SLED'">SUSE-SLED</xsl:when>
+        <xsl:when test="$candidate-productid = 'SLE-MICRO'">SLE-Micro</xsl:when>
+        <xsl:otherwise>
+          <xsl:value-of select="$candidate-productid"/>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:variable>
+    <xsl:variable name="release">
+      <xsl:for-each select="$stitchxml">
+        <xsl:value-of select="key('docserv-dcfiles', $dcfile)/ancestor::docset/@setid"/>
+      </xsl:for-each>
+    </xsl:variable>
+    <!--
+      Only add the releasenotes for SLES or SLED
+      The releasenotes URL has this syntax (PRODUCT and RELEASE are placeholders):
+      https://www.suse.com/releasenotes/x86_64/<PRODUCT>/<RELEASE>/
+    -->
+    <xsl:if test="$productid = 'sles' or $productid = 'sled'">
+    "releaseNotes": "<xsl:value-of
+      select="concat('https://www.suse.com/releasenotes/x86_64/',
+                     $productid, '/', $release, '/')"/>",
+    </xsl:if>
+  </xsl:template>
+
+  <xsl:template name="json-ld-task">
+    <xsl:param name="node" select="."/>
+    <xsl:variable name="task" select="$node/d:info/d:meta[@name='task']/d:phrase"/>
+    <xsl:if test="count($task) > 0">
+    "about": [<xsl:for-each select="$task">{
+        "@type": "Thing",
+        "name": "<xsl:value-of select="normalize-space(.)"/>"
+      }<xsl:if test="position() != last()">,&#10;      </xsl:if>
+      </xsl:for-each>
+    ],
+    </xsl:if>
+  </xsl:template>
+
+  <xsl:template name="json-ld-software">
+    <xsl:param name="node" select="."/>
+    <xsl:variable name="info-productnumber" select="normalize-space($node/d:info/d:productnumber)"/>
+    <xsl:variable name="info-productname" select="normalize-space($node/d:info/d:productname)"/>
+    <xsl:variable name="meta-productname" select="$node/d:info/d:meta[@name='productname']/d:productname"/>
+    <xsl:variable name="tmp-productname-with-version">
+      <xsl:if test="$info-productname">
+        <productname xmlns="http://docbook.org/ns/docbook" version="{$info-productnumber}"
+        ><xsl:value-of select="$info-productname"/></productname>
+      </xsl:if>
+    </xsl:variable>
+    <xsl:variable name="productname-with-version" select="exsl:node-set($tmp-productname-with-version)/*"/>
+    <xsl:variable name="productname" select="($productname-with-version | $meta-productname)"/>
+    <xsl:variable name="archs" select="$node/d:info/d:meta[@name='architecture']/d:phrase"/>
+    <xsl:variable name="candidate-arch">
+      <xsl:for-each select="$archs">
+        <xsl:value-of select="."/>
+        <xsl:if test="position() != last()">, </xsl:if>
+      </xsl:for-each>
+    </xsl:variable>
+
+    <xsl:if test="$productname">
+    "mentions": [
+      <xsl:for-each select="$productname">
+      { "@type": "SoftwareApplication",
+        "name": "<xsl:value-of select="normalize-space(.)"/>",
+        <xsl:if test="normalize-space(@version) != ''">"softwareVersion": "<xsl:value-of select="@version"/>",</xsl:if>
+        "applicationCategory": "Operating System",
+        "operatingSystem": "Linux"<xsl:if test="normalize-space($candidate-arch) != ''">,
+        "processorRequirements": "<xsl:value-of select="$candidate-arch"/>"
+        </xsl:if>
+      }
+      <xsl:if test="position() != last()">,&#10;      </xsl:if>
+      </xsl:for-each>
+    ],
+    </xsl:if>
+  </xsl:template>
 </xsl:stylesheet>
\ No newline at end of file
diff --git a/suse2022-ns/xhtml/param.xsl b/suse2022-ns/xhtml/param.xsl
index ed3292e1..073288b1 100644
--- a/suse2022-ns/xhtml/param.xsl
+++ b/suse2022-ns/xhtml/param.xsl
@@ -461,13 +461,28 @@ task before
 
   <!-- Should we generate a JSON-LD structure? 0=no, 1=yes -->
   <xsl:param name="generate.json-ld" select="0"/>
+  <!-- Should we generate an external JSON-LD structure 0=no, 1=yes
+       Only works when $generate.json-ld=1 was set
+  -->
+  <xsl:param name="generate.json-ld.external" select="0"/>
+  <!-- Filename to the single stitch file that Docserv generates on startup -->
+  <xsl:param name="stitchfile"/>
   <!-- Should the individual authors be used? 0=no, 1=yes  -->
   <xsl:param name="json-ld-use-individual-authors" select="1"/>
-  <xsl:param name="json-ld-fallback-author-name">SUSE documentation team</xsl:param>
+  <!-- File extension -->
+  <xsl:param name="json-ld.ext">.json</xsl:param>
+  <!-- Timezone -->
+  <xsl:param name="json-ld-date-timezone">T00:00+02:00</xsl:param>
+  <xsl:param name="json-ld-fallback-author-name">SUSE Product &amp; Solution Documentation Team</xsl:param>
   <xsl:param name="json-ld-fallback-author-url">https://documentation.suse.com</xsl:param>
   <xsl:param name="json-ld-fallback-author-type">Corporation</xsl:param>
-  <xsl:param name="json-ld-fallback-author-logo">https://www.suse.com/assets/img/suse-white-logo-green.svg</xsl:param>
+  <xsl:param name="json-ld-fallback-author-logo"
+    >https://www.suse.com/assets/img/suse-white-logo-green.svg</xsl:param>
+  <!-- The logo -->
+  <xsl:param name="json-ld-image-url" select="$json-ld-fallback-author-logo" />
 
+  <!-- The DC file needs to be passed to find the structure in the Docserv config -->
+  <xsl:param name="dcfilename"/>
 
   <xsl:variable name="placeholder.ssi.language">{{#language#}}</xsl:variable>