30350726166

Committed 28 Jul 2026 10:25AM UTC coverage: 33.442% (+3.1%) from 30.298%

Build # 30350726166

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #567 from knowledgepixels/feat/reject-literals-in-subject-predicate

Report and block templates with literals in subject/predicate position

Coverage Stats

2337 of 7695 branches covered (30.37%)

Branch coverage included in aggregate %.

4532 of 12845 relevant lines covered (35.28%)

5.43 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

80.49

src/main/java/com/knowledgepixels/nanodash/template/Template.java

package com.knowledgepixels.nanodash.template;

import com.knowledgepixels.nanodash.LookupApis;
import com.knowledgepixels.nanodash.Utils;
import net.trustyuri.TrustyUriUtils;
import org.eclipse.rdf4j.common.exception.RDF4JException;
import org.eclipse.rdf4j.model.*;
import org.eclipse.rdf4j.model.impl.SimpleValueFactory;
import org.eclipse.rdf4j.model.util.Literals;
import org.eclipse.rdf4j.model.vocabulary.DCTERMS;
import org.eclipse.rdf4j.model.vocabulary.RDF;
import org.eclipse.rdf4j.model.vocabulary.RDFS;
import org.eclipse.rdf4j.model.vocabulary.SHACL;
import org.nanopub.Nanopub;
import org.nanopub.NanopubUtils;
import org.nanopub.vocabulary.NTEMPLATE;
import com.knowledgepixels.nanodash.vocabulary.KPXL_TERMS;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.Serializable;
import java.util.*;

/**
 * Represents a template for creating nanopublications.
 */
public class Template implements Serializable {

    private static final ValueFactory vf = SimpleValueFactory.getInstance();
    private static final Logger logger = LoggerFactory.getLogger(Template.class);

    /**
     * Default target namespace for templates.
     */
    public static final String DEFAULT_TARGET_NAMESPACE = "https://w3id.org/np/";

    // TODO Move these to the other ntemplate vocabulary terms in nanopub-java:
    private static final IRI ADVANCED_STATEMENT = vf.createIRI("https://w3id.org/np/o/ntemplate/AdvancedStatement");

    /**
     * Type of a literal placeholder whose language tag is selected by the user at fill time.
     */
    public static final IRI LANGUAGE_TAGGED_LITERAL_PLACEHOLDER = vf.createIRI("https://w3id.org/np/o/ntemplate/LanguageTaggedLiteralPlaceholder");

    /**
     * Predicate restricting the language tags offered by a language-tag picker.
     */
    public static final IRI POSSIBLE_LANGUAGE_TAG = vf.createIRI("https://w3id.org/np/o/ntemplate/possibleLanguageTag");

    private final Nanopub nanopub;
    private String label;
    private String description;

    // TODO: Make all these maps more generic and the code simpler:
    private IRI templateIri;
    private boolean embeddedIdentity = false;
    private IRI templateKindIri;
    private IRI governingSpace;
    private Map<IRI, List<IRI>> typeMap = new HashMap<>();
    private Map<IRI, List<Value>> possibleValueMap = new HashMap<>();
    private Map<IRI, List<IRI>> possibleValuesToLoadMap = new HashMap<>();
    private Map<IRI, List<String>> apiMap = new HashMap<>();
    private Map<IRI, String> labelMap = new HashMap<>();
    private Map<IRI, IRI> datatypeMap = new HashMap<>();
    private Map<IRI, String> languageTagMap = new HashMap<>();
    private Map<IRI, List<String>> possibleLanguageTagMap = new HashMap<>();
    private Map<IRI, String> prefixMap = new HashMap<>();
    private Map<IRI, String> prefixLabelMap = new HashMap<>();
    private Map<IRI, String> regexMap = new HashMap<>();
    private Map<IRI, List<IRI>> statementMap = new HashMap<>();
    private Map<IRI, IRI> statementSubjects = new HashMap<>();
    private Map<IRI, IRI> statementPredicates = new HashMap<>();
    private Map<IRI, Value> statementObjects = new HashMap<>();
    // Subject/predicate values that are not IRIs (i.e. literals), which is invalid RDF but
    // does occur in published templates. Kept apart from the maps above so the rest of the
    // code keeps seeing IRIs, and reported by getStatementErrors().
    private Map<IRI, Value> nonIriStatementSubjects = new HashMap<>();
    private Map<IRI, Value> nonIriStatementPredicates = new HashMap<>();
    private Map<IRI, Integer> statementOrder = new HashMap<>();
    private IRI defaultProvenance;
    private List<IRI> requiredPubInfoElements = new ArrayList<>();
    private String tag = null;
    private Map<IRI, Value> defaultValues = new HashMap<>();
    private String targetNamespace = null;
    private String nanopubLabelPattern;
    private List<IRI> targetNanopubTypes = new ArrayList<>();

    /**
     * Creates a Template object from a template id.
     *
     * @param templateId the id of the template, which is the URI of a nanopublication that contains the template definition.
     * @throws RDF4JException             if there is an error retrieving the nanopublication.
     * @throws MalformedTemplateException if the template is malformed or not a valid nanopub template.
     */
    Template(String templateId) throws RDF4JException, MalformedTemplateException {
        this(Utils.getNanopub(templateId));
    }

    /**
     * Creates a Template object from a Nanopub object.
     *
     * @param np the Nanopub object containing the template definition.
     * @throws MalformedTemplateException if the template is malformed or not a valid nanopub template.
     */
    Template(Nanopub np) throws MalformedTemplateException {
        nanopub = np;
        processTemplate(nanopub);
    }

    /**
     * Checks if the template is unlisted.
     *
     * @return true if the template is unlisted, false otherwise.
     */
    public boolean isUnlisted() {
        List<IRI> types = typeMap.get(templateIri);
        return types != null && types.contains(NTEMPLATE.UNLISTED_TEMPLATE);
    }

    /**
     * Returns the Nanopub object representing the template.
     *
     * @return the Nanopub object of the template.
     */
    public Nanopub getNanopub() {
        return nanopub;
    }

    /**
     * Returns the ID of the template: for a template with embedded identity (the
     * template node is a regular embedded IRI in the assertion), that embedded IRI;
     * for a legacy template (the template node is the assertion graph URI), the URI
     * of the nanopublication.
     *
     * @return the ID of the template as a string.
     */
    public String getId() {
        if (embeddedIdentity) return templateIri.stringValue();
        return nanopub.getUri().toString();
    }

    /**
     * Checks whether the given ID refers to this template, in either form: the
     * template's canonical ID ({@link #getId()}) or its nanopublication URI. Use
     * this instead of comparing against {@link #getId()} when the ID to compare
     * comes from outside (page parameters, published references), as those may
     * carry either form.
     *
     * @param id the ID to check
     * @return true if the ID refers to this template
     */
    public boolean hasId(String id) {
        return id != null && (id.equals(getId()) || id.equals(nanopub.getUri().stringValue()));
    }

    /**
     * Returns the template kind IRI, i.e. the stable identifier this template
     * version declares itself a version of ({@code dct:isVersionOf} on the template
     * node), or null if it doesn't declare one.
     *
     * @return the template kind IRI, or null
     */
    public IRI getTemplateKindIri() {
        return templateKindIri;
    }

    /**
     * Returns the space governing this template version ({@code gen:governedBy} on
     * the template node), or null if it doesn't declare one. A governed version's
     * latest-resolution floats space-based within its (kind, space) pair instead of
     * following the supersedes chain; see docs/template-identity-and-governance.md.
     *
     * @return the governing space IRI, or null
     */
    public IRI getGoverningSpace() {
        return governingSpace;
    }

    /**
     * Returns the label of the template.
     *
     * @return the label of the template, or a default label if not set.
     */
    public String getLabel() {
        if (label == null) {
            return "Template " + TrustyUriUtils.getArtifactCode(nanopub.getUri().stringValue()).substring(0, 10);
        }
        return label;
    }

    /**
     * Returns the description of the template.
     *
     * @return the description of the template, or an empty string if not set.
     */
    public String getDescription() {
        return description;
    }

    /**
     * Returns the IRI of the template.
     *
     * @param iri the IRI to transform.
     * @return the transformed IRI, or the original IRI if no transformation is needed.
     */
    public String getLabel(IRI iri) {
        iri = transform(iri);
        return labelMap.get(iri);
    }

    /**
     * Returns the IRI of the template, transforming it if necessary.
     *
     * @param iri the IRI to transform.
     * @return the transformed IRI, or the original IRI if no transformation is needed.
     */
    public IRI getFirstOccurrence(IRI iri) {
        iri = transform(iri);
        for (IRI i : getStatementIris()) {
            if (statementMap.containsKey(i)) {
                // grouped statement
                for (IRI g : getStatementIris(i)) {
                    if (iri.equals(statementSubjects.get(g))) return g;
                    if (iri.equals(statementPredicates.get(g))) return g;
                    if (iri.equals(statementObjects.get(g))) return g;
                }
            } else {
                // non-grouped statement
                if (iri.equals(statementSubjects.get(i))) return i;
                if (iri.equals(statementPredicates.get(i))) return i;
                if (iri.equals(statementObjects.get(i))) return i;
            }
        }
        return null;
    }

    /**
     * Returns the datatype for the given literal placeholder IRI.
     *
     * @param iri the literal placeholder IRI.
     * @return the datatype for the literal.
     */
    public IRI getDatatype(IRI iri) {
        iri = transform(iri);
        return datatypeMap.get(iri);
    }

    /**
     * Returns the language tag for the given literal placeholder IRI.
     *
     * @param iri the literal placeholder IRI.
     * @return the language tag for the literal.
     */
    public String getLanguageTag(IRI iri) {
        iri = transform(iri);
        return languageTagMap.get(iri);
    }

    /**
     * Returns the language tags a language-tag-selectable placeholder is restricted to.
     *
     * @param iri the literal placeholder IRI.
     * @return the normalized allowed language tags, or null if unrestricted.
     */
    public List<String> getPossibleLanguageTags(IRI iri) {
        iri = transform(iri);
        return possibleLanguageTagMap.get(iri);
    }

    /**
     * Returns the prefix for the given IRI.
     *
     * @param iri the IRI.
     * @return the prefix for the IRI.
     */
    public String getPrefix(IRI iri) {
        iri = transform(iri);
        return prefixMap.get(iri);
    }

    /**
     * Returns the prefix label for a given IRI.
     *
     * @param iri the IRI to get the prefix label for.
     * @return the prefix label for the IRI, or null if not found.
     */
    public String getPrefixLabel(IRI iri) {
        iri = transform(iri);
        return prefixLabelMap.get(iri);
    }

    /**
     * Returns the regex pattern for a given IRI.
     *
     * @param iri the IRI to get the regex for.
     * @return the regex pattern for the IRI, or null if not found.
     */
    public String getRegex(IRI iri) {
        iri = transform(iri);
        return regexMap.get(iri);
    }

    /**
     * Transforms an IRI by removing the artifact code if it is present.
     *
     * @param iri the IRI to transform.
     * @return the transformed IRI, or the original IRI if no transformation is needed.
     */
    public Value getDefault(IRI iri) {
        if (iri.stringValue().matches(".*__[0-9]+")) {
            String baseIri = iri.stringValue().replaceFirst("__[0-9]+$", "");
            Value v = defaultValues.get(vf.createIRI(baseIri));
            if (v instanceof IRI vIri) {
                // Append repeat suffix only for local URIs; fixed URIs stay unchanged
                if (vIri.stringValue().startsWith(nanopub.getUri().stringValue())) {
                    int repeatSuffix = Integer.parseInt(iri.stringValue().replaceFirst("^.*__([0-9]+)$", "$1"));
                    return vf.createIRI(vIri.stringValue() + (repeatSuffix + 1));
                }
                return vIri;
            }
        }
        iri = transform(iri);
        return defaultValues.get(iri);
    }

    /**
     * Returns the statement IRIs associated with the template.
     *
     * @return the list of statement IRIs for the template.
     */
    public List<IRI> getStatementIris() {
        return statementMap.get(templateIri);
    }

    /**
     * Returns the statement IRIs associated with a specific group IRI.
     *
     * @param groupIri the IRI of the group for which to retrieve statement IRIs.
     * @return the list of statement IRIs for the specified group IRI, or null if no statements are associated with that group.
     */
    public List<IRI> getStatementIris(IRI groupIri) {
        return statementMap.get(groupIri);
    }

    /**
     * Returns the subject, predicate, and object of a statement given its IRI.
     *
     * @param statementIri the IRI of the statement to retrieve.
     * @return the subject, predicate, and object of the statement as a triple.
     */
    public IRI getSubject(IRI statementIri) {
        return statementSubjects.get(statementIri);
    }

    /**
     * Returns the predicate of a statement given its IRI.
     *
     * @param statementIri the IRI of the statement to retrieve.
     * @return the predicate of the statement, or null if not found.
     */
    public IRI getPredicate(IRI statementIri) {
        return statementPredicates.get(statementIri);
    }

    /**
     * Returns the object of a statement given its IRI.
     *
     * @param statementIri the IRI of the statement to retrieve.
     * @return the object of the statement, or null if not found.
     */
    public Value getObject(IRI statementIri) {
        return statementObjects.get(statementIri);
    }

    /**
     * Returns the subject of a statement as the template declares it, which may be a literal
     * and therefore invalid in that position (in which case {@link #getSubject(IRI)} is null).
     * Use this for rendering, so that an invalid subject is shown to the user instead of
     * silently disappearing; see {@link #getStatementErrors()}.
     *
     * @param statementIri the IRI of the statement to retrieve.
     * @return the declared subject of the statement, or null if the statement declares none.
     */
    public Value getDeclaredSubject(IRI statementIri) {
        IRI subj = statementSubjects.get(statementIri);
        if (subj != null) return subj;
        return nonIriStatementSubjects.get(statementIri);
    }

    /**
     * Returns the predicate of a statement as the template declares it, which may be a literal
     * and therefore invalid in that position (in which case {@link #getPredicate(IRI)} is null).
     * See {@link #getDeclaredSubject(IRI)}.
     *
     * @param statementIri the IRI of the statement to retrieve.
     * @return the declared predicate of the statement, or null if the statement declares none.
     */
    public Value getDeclaredPredicate(IRI statementIri) {
        IRI pred = statementPredicates.get(statementIri);
        if (pred != null) return pred;
        return nonIriStatementPredicates.get(statementIri);
    }

    /**
     * Returns human-readable descriptions of the statements of this template that cannot
     * produce valid RDF, because their subject or predicate is a literal, is a placeholder
     * that can only be filled with a literal, or is missing altogether. Only URIs are allowed
     * in subject and predicate position.
     *
     * @return the error descriptions, empty if all statements are well-formed.
     */
    public List<String> getStatementErrors() {
        List<String> errors = new ArrayList<>();
        List<IRI> topIris = getStatementIris();
        if (topIris == null) return errors;
        int i = 0;
        for (IRI top : topIris) {
            i++;
            List<IRI> memberIris = getStatementIris(top);
            if (memberIris == null) {
                collectStatementErrors(top, "Statement " + i, errors);
            } else {
                int j = 0;
                for (IRI member : memberIris) {
                    j++;
                    collectStatementErrors(member, "Statement " + i + "." + j, errors);
                }
            }
        }
        return errors;
    }

    private void collectStatementErrors(IRI statementIri, String statementNumber, List<String> errors) {
        String statementName = statementNumber + " (" + getLocalName(statementIri) + ")";
        collectPositionError(getDeclaredSubject(statementIri), "subject", statementName, errors);
        collectPositionError(getDeclaredPredicate(statementIri), "predicate", statementName, errors);
    }

    private void collectPositionError(Value value, String position, String statementName, List<String> errors) {
        if (value == null) {
            errors.add(statementName + ": no " + position + " is defined.");
        } else if (value instanceof Literal) {
            errors.add(statementName + ": the literal " + describeValue(value) + " is used in " + position +
                    " position, but only URIs are allowed there.");
        } else if (isLiteralPlaceholder((IRI) value)) {
            errors.add(statementName + ": the literal placeholder " + describeValue(value) + " is used in " + position +
                    " position, but only URIs are allowed there.");
        }
    }

    private String describeValue(Value value) {
        if (value instanceof Literal) return "\"" + value.stringValue() + "\"";
        String label = getLabel((IRI) value);
        String localName = getLocalName(value);
        if (label == null) return localName;
        return "\"" + label + "\" (" + localName + ")";
    }

    private String getLocalName(Value value) {
        return value.stringValue().replaceFirst("^.*[/#]", "");
    }

    /**
     * Checks if the template is a local resource.
     *
     * @param iri the IRI to check.
     * @return true if the IRI is a local resource, false otherwise.
     */
    public boolean isLocalResource(IRI iri) {
        iri = transform(iri);
        return typeMap.containsKey(iri) && typeMap.get(iri).contains(NTEMPLATE.LOCAL_RESOURCE);
    }

    /**
     * Checks if the template is an introduced resource.
     *
     * @param iri the IRI to check.
     * @return true if the IRI is an introduced resource, false otherwise.
     */
    public boolean isIntroducedResource(IRI iri) {
        iri = transform(iri);
        return typeMap.containsKey(iri) && typeMap.get(iri).contains(NTEMPLATE.INTRODUCED_RESOURCE);
    }

    /**
     * Returns the role-instantiation direction pin declared on a (predicate) IRI, if
     * any: {@link KPXL_TERMS#INVERSE_ROLE_PROPERTY} or
     * {@link KPXL_TERMS#REGULAR_ROLE_PROPERTY}. Templates declare the pin as an
     * {@code rdf:type} on the predicate (constant or placeholder); nanodash lifts it into
     * pubinfo at publish time so nanopub-query can resolve a custom role predicate's
     * direction (see #525).
     *
     * @param iri the IRI to check (a predicate constant or placeholder).
     * @return the pin class, or null if the IRI carries no role-direction pin.
     */
    public IRI getRoleDirectionPin(IRI iri) {
        iri = transform(iri);
        if (!typeMap.containsKey(iri)) return null;
        List<IRI> types = typeMap.get(iri);
        if (types.contains(KPXL_TERMS.INVERSE_ROLE_PROPERTY)) return KPXL_TERMS.INVERSE_ROLE_PROPERTY;
        if (types.contains(KPXL_TERMS.REGULAR_ROLE_PROPERTY)) return KPXL_TERMS.REGULAR_ROLE_PROPERTY;
        return null;
    }

    /**
     * Checks if the template is an embedded resource.
     *
     * @param iri the IRI to check.
     * @return true if the IRI is an embedded resource, false otherwise.
     */
    public boolean isEmbeddedResource(IRI iri) {
        iri = transform(iri);
        return typeMap.containsKey(iri) && typeMap.get(iri).contains(NTEMPLATE.EMBEDDED_RESOURCE);
    }

    /**
     * Checks if the IRI is a value placeholder.
     *
     * @param iri the IRI to check.
     * @return true if the IRI is a value placeholder, false otherwise.
     */
    public boolean isValuePlaceholder(IRI iri) {
        iri = transform(iri);
        return typeMap.containsKey(iri) && typeMap.get(iri).contains(NTEMPLATE.VALUE_PLACEHOLDER);
    }

    /**
     * Checks if the IRI is a URI placeholder.
     *
     * @param iri the IRI to check.
     * @return true if the IRI is a URI placeholder, false otherwise.
     */
    public boolean isUriPlaceholder(IRI iri) {
        iri = transform(iri);
        if (!typeMap.containsKey(iri)) return false;
        for (IRI t : typeMap.get(iri)) {
            if (t.equals(NTEMPLATE.URI_PLACEHOLDER)) return true;
            if (t.equals(NTEMPLATE.EXTERNAL_URI_PLACEHOLDER)) return true;
            if (t.equals(NTEMPLATE.TRUSTY_URI_PLACEHOLDER)) return true;
            if (t.equals(NTEMPLATE.AUTO_ESCAPE_URI_PLACEHOLDER)) return true;
            if (t.equals(NTEMPLATE.RESTRICTED_CHOICE_PLACEHOLDER)) return true;
            if (t.equals(NTEMPLATE.GUIDED_CHOICE_PLACEHOLDER)) return true;
            if (t.equals(NTEMPLATE.AGENT_PLACEHOLDER)) return true;
        }
        return false;
    }

    /**
     * Checks if the IRI is an external URI placeholder.
     *
     * @param iri the IRI to check.
     * @return true if the IRI is an external URI placeholder, false otherwise.
     */
    public boolean isExternalUriPlaceholder(IRI iri) {
        iri = transform(iri);
        if (!typeMap.containsKey(iri)) return false;
        for (IRI t : typeMap.get(iri)) {
            if (t.equals(NTEMPLATE.EXTERNAL_URI_PLACEHOLDER)) return true;
            if (t.equals(NTEMPLATE.TRUSTY_URI_PLACEHOLDER)) return true;
        }
        return false;
    }

    /**
     * Checks if the IRI is a trusty URI placeholder.
     *
     * @param iri the IRI to check.
     * @return true if the IRI is a trusty URI placeholder, false otherwise.
     */
    public boolean isTrustyUriPlaceholder(IRI iri) {
        iri = transform(iri);
        return typeMap.containsKey(iri) && typeMap.get(iri).contains(NTEMPLATE.TRUSTY_URI_PLACEHOLDER);
    }

    /**
     * Checks if the IRI is an auto-escape URI placeholder.
     *
     * @param iri the IRI to check.
     * @return true if the IRI is an auto-escape URI placeholder, false otherwise.
     */
    public boolean isAutoEscapePlaceholder(IRI iri) {
        iri = transform(iri);
        return typeMap.containsKey(iri) && typeMap.get(iri).contains(NTEMPLATE.AUTO_ESCAPE_URI_PLACEHOLDER);
    }

    /**
     * Checks if the IRI is a literal placeholder.
     *
     * @param iri the IRI to check.
     * @return true if the IRI is a literal placeholder, false otherwise.
     */
    public boolean isLiteralPlaceholder(IRI iri) {
        iri = transform(iri);
        return typeMap.containsKey(iri) && (typeMap.get(iri).contains(NTEMPLATE.LITERAL_PLACEHOLDER) || typeMap.get(iri).contains(NTEMPLATE.LONG_LITERAL_PLACEHOLDER)
                || typeMap.get(iri).contains(LANGUAGE_TAGGED_LITERAL_PLACEHOLDER));
    }

    /**
     * Checks if the given literal placeholder lets the user select the language tag at fill time.
     *
     * @param iri the IRI to check.
     * @return true if the IRI is a language-tag-selectable literal placeholder, false otherwise.
     */
    public boolean isLanguageTagSelectable(IRI iri) {
        iri = transform(iri);
        return typeMap.containsKey(iri) && typeMap.get(iri).contains(LANGUAGE_TAGGED_LITERAL_PLACEHOLDER);
    }

    /**
     * Checks if the IRI is a long literal placeholder.
     *
     * @param iri the IRI to check.
     * @return true if the IRI is a long literal placeholder, false otherwise.
     */
    public boolean isLongLiteralPlaceholder(IRI iri) {
        iri = transform(iri);
        return typeMap.containsKey(iri) && typeMap.get(iri).contains(NTEMPLATE.LONG_LITERAL_PLACEHOLDER);
    }

    /**
     * Checks if the IRI is a restricted choice placeholder.
     *
     * @param iri the IRI to check.
     * @return true if the IRI is a restricted choice placeholder, false otherwise.
     */
    public boolean isRestrictedChoicePlaceholder(IRI iri) {
        iri = transform(iri);
        return typeMap.containsKey(iri) && typeMap.get(iri).contains(NTEMPLATE.RESTRICTED_CHOICE_PLACEHOLDER);
    }

    /**
     * Checks if the IRI is a guided choice placeholder.
     *
     * @param iri the IRI to check.
     * @return true if the IRI is a guided choice placeholder, false otherwise.
     */
    public boolean isGuidedChoicePlaceholder(IRI iri) {
        iri = transform(iri);
        return typeMap.containsKey(iri) && typeMap.get(iri).contains(NTEMPLATE.GUIDED_CHOICE_PLACEHOLDER);
    }

    /**
     * Checks if the IRI is an agent placeholder.
     *
     * @param iri the IRI to check.
     * @return true if the IRI is an agent placeholder, false otherwise.
     */
    public boolean isAgentPlaceholder(IRI iri) {
        iri = transform(iri);
        return typeMap.containsKey(iri) && typeMap.get(iri).contains(NTEMPLATE.AGENT_PLACEHOLDER);
    }

    /**
     * Checks if the IRI is a sequence element placeholder.
     *
     * @param iri the IRI to check.
     * @return true if the IRI is a sequence element placeholder, false otherwise.
     */
    public boolean isSequenceElementPlaceholder(IRI iri) {
        iri = transform(iri);
        return typeMap.containsKey(iri) && typeMap.get(iri).contains(NTEMPLATE.SEQUENCE_ELEMENT_PLACEHOLDER);
    }

    /**
     * Checks if the IRI is a root nanopub placeholder.
     *
     * @param iri the IRI to check.
     * @return true if the IRI is a root nanopub placeholder, false otherwise.
     */
    public boolean isRootNanopubPlaceholder(IRI iri) {
        iri = transform(iri);
        return typeMap.containsKey(iri) && typeMap.get(iri).contains(NTEMPLATE.ROOT_NANOPUB_PLACEHOLDER);
    }

    /**
     * Checks if the IRI is a placeholder of any type.
     *
     * @param iri the IRI to check.
     * @return true if the IRI is a placeholder, false otherwise.
     */
    public boolean isPlaceholder(IRI iri) {
        iri = transform(iri);
        if (!typeMap.containsKey(iri)) return false;
        for (IRI t : typeMap.get(iri)) {
            if (t.equals(NTEMPLATE.VALUE_PLACEHOLDER)) return true;
            if (t.equals(NTEMPLATE.URI_PLACEHOLDER)) return true;
            if (t.equals(NTEMPLATE.EXTERNAL_URI_PLACEHOLDER)) return true;
            if (t.equals(NTEMPLATE.TRUSTY_URI_PLACEHOLDER)) return true;
            if (t.equals(NTEMPLATE.AUTO_ESCAPE_URI_PLACEHOLDER)) return true;
            if (t.equals(NTEMPLATE.RESTRICTED_CHOICE_PLACEHOLDER)) return true;
            if (t.equals(NTEMPLATE.GUIDED_CHOICE_PLACEHOLDER)) return true;
            if (t.equals(NTEMPLATE.AGENT_PLACEHOLDER)) return true;
            if (t.equals(NTEMPLATE.LITERAL_PLACEHOLDER)) return true;
            if (t.equals(NTEMPLATE.LONG_LITERAL_PLACEHOLDER)) return true;
            if (t.equals(LANGUAGE_TAGGED_LITERAL_PLACEHOLDER)) return true;
            if (t.equals(NTEMPLATE.SEQUENCE_ELEMENT_PLACEHOLDER)) return true;
            if (t.equals(NTEMPLATE.ROOT_NANOPUB_PLACEHOLDER)) return true;
        }
        return false;
    }

    /**
     * Checks if the IRI is an optional statement.
     *
     * @param iri the IRI to check.
     * @return true if the IRI is an optional statement, false otherwise.
     */
    public boolean isOptionalStatement(IRI iri) {
        return typeMap.containsKey(iri) && typeMap.get(iri).contains(NTEMPLATE.OPTIONAL_STATEMENT);
    }

    /**
     * Whether the placeholder with the given parameter name is a required field of
     * this template: it appears (as subject or object) in at least one non-optional
     * statement — i.e. a value must be provided to publish. A repetition-index
     * suffix on the name (e.g. {@code public-key__.1}) is ignored, matching the base
     * placeholder. Used to decide whether an empty mapped value should hide a view
     * action's button (see docs/magic-query-params.md).
     *
     * @param paramName the parameter name (placeholder local name, optionally with a
     *                  {@code __.N} repetition suffix)
     * @return true if the placeholder is required (appears in a non-optional statement)
     */
    public boolean isRequiredField(String paramName) {
        if (paramName == null) return false;
        String base = paramName.replaceFirst("__\\..*$", "");
        for (IRI top : getStatementIris()) {
            List<IRI> members = getStatementIris(top);
            if (members != null) {
                if (isOptionalStatement(top)) continue; // whole group optional
                for (IRI st : members) {
                    if (!isOptionalStatement(st) && statementReferencesPlaceholder(st, base)) return true;
                }
            } else if (!isOptionalStatement(top) && statementReferencesPlaceholder(top, base)) {
                return true;
            }
        }
        return false;
    }

    private boolean statementReferencesPlaceholder(IRI statementIri, String localName) {
        return matchesPlaceholderLocalName(getSubject(statementIri), localName)
                || matchesPlaceholderLocalName(getObject(statementIri), localName);
    }

    private boolean matchesPlaceholderLocalName(Value value, String localName) {
        if (!(value instanceof IRI iri) || !isPlaceholder(iri)) return false;
        String s = iri.stringValue();
        int i = Math.max(s.lastIndexOf('/'), s.lastIndexOf('#'));
        return localName.equals(i < 0 ? s : s.substring(i + 1));
    }

    /**
     * Checks if the IRI is an advanced statement, which are only show upon expanding to full view in form mode.
     *
     * @param iri the IRI to check.
     * @return true if the IRI is an advanced statement, false otherwise.
     */
    public boolean isAdvancedStatement(IRI iri) {
        return typeMap.containsKey(iri) && typeMap.get(iri).contains(ADVANCED_STATEMENT);
    }

    /**
     * Checks if the IRI is a grouped statement.
     *
     * @param iri the IRI to check.
     * @return true if the IRI is a grouped statement, false otherwise.
     */
    public boolean isGroupedStatement(IRI iri) {
        return typeMap.containsKey(iri) && typeMap.get(iri).contains(NTEMPLATE.GROUPED_STATEMENT);
    }

    /**
     * Checks if the IRI is a repeatable statement.
     *
     * @param iri the IRI to check.
     * @return true if the IRI is a repeatable statement, false otherwise.
     */
    public boolean isRepeatableStatement(IRI iri) {
        return typeMap.containsKey(iri) && typeMap.get(iri).contains(NTEMPLATE.REPEATABLE_STATEMENT);
    }

    /**
     * Returns the possible values for a given IRI.
     *
     * @param iri the IRI for which to get possible values.
     * @return a list of possible values for the IRI. If no values are found, an empty list is returned.
     */
    public List<Value> getPossibleValues(IRI iri) {
        iri = transform(iri);
        List<Value> l = possibleValueMap.get(iri);
        if (l == null) {
            l = new ArrayList<>();
            possibleValueMap.put(iri, l);
        }
        List<IRI> nanopubList = possibleValuesToLoadMap.get(iri);
        if (nanopubList != null) {
            for (IRI npIri : new ArrayList<>(nanopubList)) {
                try {
                    Nanopub valuesNanopub = Utils.getNanopub(npIri.stringValue());
                    for (Statement st : valuesNanopub.getAssertion()) {
                        if (st.getPredicate().equals(RDFS.LABEL)) {
                            l.add((IRI) st.getSubject());
                        }
                    }
                    nanopubList.remove(npIri);
                } catch (Exception ex) {
                    logger.error("Could not load possible values from nanopub {}", npIri.stringValue(), ex);
                }
            }
        }
        return l;
    }

    /**
     * Returns the IRI of the default provenance for the template.
     *
     * @return the IRI of the default provenance, or null if not set.
     */
    public IRI getDefaultProvenance() {
        return defaultProvenance;
    }

    /**
     * Returns the target namespace for the template.
     *
     * @return the target namespace as a string, or null if not set.
     */
    public String getTargetNamespace() {
        return targetNamespace;
    }

    /**
     * Returns the nanopub label pattern.
     *
     * @return the nanopub label pattern as a string, or null if not set.
     */
    public String getNanopubLabelPattern() {
        return nanopubLabelPattern;
    }

    /**
     * Returns the list of target nanopub types.
     *
     * @return a list of IRI objects representing the target nanopub types.
     */
    public List<IRI> getTargetNanopubTypes() {
        return targetNanopubTypes;
    }

    /**
     * Returns the list of the required pubInfo elements for the template.
     *
     * @return a list of IRI objects representing the required pubInfo elements.
     */
    public List<IRI> getRequiredPubInfoElements() {
        return requiredPubInfoElements;
    }

    /**
     * Returns the possible values from an API for a given IRI and search term.
     *
     * @param iri        the IRI for which to get possible values from the API.
     * @param searchTerm the search term to filter the possible values.
     * @param labelMap   a map to store labels for the possible values.
     * @return a list of possible values from the API, filtered by the search term.
     */
    public List<String> getPossibleValuesFromApi(IRI iri, String searchTerm, Map<String, String> labelMap) {
        iri = transform(iri);
        List<String> values = new ArrayList<>();
        List<String> apiList = apiMap.get(iri);
        if (apiList != null) {
            for (String apiString : apiList) {
                LookupApis.getPossibleValues(apiString, searchTerm, labelMap, values);
            }
        }
        return values;
    }

    /**
     * Returns the tag associated with the template.
     *
     * @return the tag as a string, or null if not set.
     */
    public String getTag() {
        return tag;
    }

    private void processTemplate(Nanopub templateNp) throws MalformedTemplateException {
        IRI assertionUri = templateNp.getAssertionUri();
        Set<IRI> templateNodes = new LinkedHashSet<>();
        for (Statement st : templateNp.getAssertion()) {
            if (!st.getPredicate().equals(RDF.TYPE)) continue;
            if (!(st.getSubject() instanceof IRI subjIri)) continue;
            if (st.getObject().equals(NTEMPLATE.ASSERTION_TEMPLATE) || st.getObject().equals(NTEMPLATE.PROVENANCE_TEMPLATE) || st.getObject().equals(NTEMPLATE.PUBINFO_TEMPLATE)) {
                templateNodes.add(subjIri);
            }
        }

        if (templateNodes.contains(assertionUri)) {
            // Legacy shape (template node = assertion graph URI) takes precedence
            // over any other typed node, so every template that parsed before
            // embedded identity existed keeps parsing identically.
            templateIri = assertionUri;
            processNpTemplate(templateNp);
        } else if (templateNodes.size() == 1) {
            IRI node = templateNodes.iterator().next();
            if (!node.stringValue().startsWith(templateNp.getUri().stringValue())) {
                throw new MalformedTemplateException("Embedded template node must be in the nanopub's namespace: " + node);
            }
            templateIri = node;
            embeddedIdentity = true;
            processNpTemplate(templateNp);
        } else if (templateNodes.size() > 1) {
            throw new MalformedTemplateException("Multiple embedded template nodes found");
        } else {
            // Experimental SHACL-based template:
            processShaclTemplate(templateNp);
        }
        tagUntypedLocalIrisAsLocalResources(templateNp);
        checkLanguageTagPlaceholders();
    }

    // A literal is either language-tagged or datatyped, never both; the language-tag
    // picker wins so the placeholder keeps rendering as a text field.
    private void checkLanguageTagPlaceholders() {
        for (Map.Entry<IRI, List<IRI>> e : typeMap.entrySet()) {
            if (e.getValue().contains(LANGUAGE_TAGGED_LITERAL_PLACEHOLDER) && datatypeMap.containsKey(e.getKey())) {
                logger.warn("Ignoring datatype {} on language-tag-selectable placeholder {}", datatypeMap.get(e.getKey()), e.getKey());
                datatypeMap.remove(e.getKey());
            }
        }
    }

    // Local IRIs in used statement positions that carry no identity type (no placeholder
    // type, not a Local/Introduced/Embedded Resource) are automatically treated as Local
    // Resources, so every produced nanopub mints them under its own namespace instead of
    // copying the template-local IRI verbatim (see issue #551).
    private void tagUntypedLocalIrisAsLocalResources(Nanopub templateNp) {
        List<IRI> topIris = statementMap.get(templateIri);
        if (topIris == null) return;
        String npUri = templateNp.getUri().stringValue();
        List<IRI> statementIris = new ArrayList<>();
        for (IRI iri : topIris) {
            if (statementMap.containsKey(iri)) {
                // grouped statement
                statementIris.addAll(statementMap.get(iri));
            } else {
                statementIris.add(iri);
            }
        }
        for (IRI st : statementIris) {
            tagIfUntypedLocal(statementSubjects.get(st), npUri);
            tagIfUntypedLocal(statementPredicates.get(st), npUri);
            tagIfUntypedLocal(statementObjects.get(st), npUri);
        }
    }

    private void tagIfUntypedLocal(Value value, String npUri) {
        if (!(value instanceof IRI iri)) return;
        String s = iri.stringValue();
        // Only sub-IRIs of the template nanopub are local; the nanopub URI itself is a
        // global reference to the template and stays verbatim:
        if (!s.startsWith(npUri) || s.length() == npUri.length()) return;
        if (iri.equals(templateIri)) return;
        // Statement/group identifiers referenced as values stay untouched:
        if (statementMap.containsKey(iri) || statementSubjects.containsKey(iri)) return;
        if (isPlaceholder(iri) || isLocalResource(iri) || isIntroducedResource(iri) || isEmbeddedResource(iri)) return;
        addType(iri, NTEMPLATE.LOCAL_RESOURCE);
    }

    private void processNpTemplate(Nanopub templateNp) throws MalformedTemplateException {
        for (Statement st : templateNp.getAssertion()) {
            final IRI subj = (IRI) st.getSubject();
            final IRI pred = st.getPredicate();
            final Value obj = st.getObject();
            final String objS = obj.stringValue();

            if (subj.equals(templateIri)) {
                if (pred.equals(RDFS.LABEL)) {
                    label = objS;
                } else if (pred.equals(DCTERMS.DESCRIPTION)) {
                    description = Utils.sanitizeHtml(objS);
                } else if (obj instanceof IRI objIri) {
                    if (pred.equals(NTEMPLATE.HAS_DEFAULT_PROVENANCE)) {
                        defaultProvenance = objIri;
                    } else if (pred.equals(NTEMPLATE.HAS_REQUIRED_PUBINFO_ELEMENT)) {
                        requiredPubInfoElements.add(objIri);
                    } else if (pred.equals(NTEMPLATE.HAS_TARGET_NAMESPACE)) {
                        targetNamespace = objS;
                    } else if (pred.equals(NTEMPLATE.HAS_TARGET_NANOPUB_TYPE)) {
                        targetNanopubTypes.add(objIri);
                    } else if (pred.equals(DCTERMS.IS_VERSION_OF)) {
                        templateKindIri = objIri;
                    } else if (pred.equals(KPXL_TERMS.GOVERNED_BY)) {
                        governingSpace = objIri;
                    }
                } else if (obj instanceof Literal) {
                    if (pred.equals(NTEMPLATE.HAS_TAG)) {
                        // TODO This should be replaced at some point with a more sophisticated mechanism based on classes.
                        // We are assuming that there is at most one tag.
                        this.tag = objS;
                    } else if (pred.equals(NTEMPLATE.HAS_NANOPUB_LABEL_PATTERN)) {
                        nanopubLabelPattern = objS;
                    }
                }
            }
            if (pred.equals(RDF.TYPE) && obj instanceof IRI objIri) {
                addType(subj, objIri);
            } else if (pred.equals(NTEMPLATE.HAS_STATEMENT) && obj instanceof IRI objIri) {
                List<IRI> l = statementMap.get(subj);
                if (l == null) {
                    l = new ArrayList<>();
                    statementMap.put(subj, l);
                }
                l.add((IRI) objIri);
            } else if (pred.equals(NTEMPLATE.POSSIBLE_VALUE)) {
                List<Value> l = possibleValueMap.get(subj);
                if (l == null) {
                    l = new ArrayList<>();
                    possibleValueMap.put(subj, l);
                }
                l.add(obj);
            } else if (pred.equals(NTEMPLATE.POSSIBLE_VALUES_FROM)) {
                List<IRI> l = possibleValuesToLoadMap.get(subj);
                if (l == null) {
                    l = new ArrayList<>();
                    possibleValuesToLoadMap.put(subj, l);
                }
                if (obj instanceof IRI objIri) {
                    l.add(objIri);
                    Nanopub valuesNanopub = Utils.getNanopub(objS);
                    for (Statement s : valuesNanopub.getAssertion()) {
                        if (s.getPredicate().equals(RDFS.LABEL)) {
                            labelMap.put((IRI) s.getSubject(), s.getObject().stringValue());
                        }
                    }
                }
            } else if (pred.equals(NTEMPLATE.POSSIBLE_VALUES_FROM_API)) {
                List<String> l = apiMap.get(subj);
                if (l == null) {
                    l = new ArrayList<>();
                    apiMap.put(subj, l);
                }
                if (obj instanceof Literal) {
                    l.add(objS);
                }
            } else if (pred.equals(RDFS.LABEL) && obj instanceof Literal) {
                labelMap.put(subj, objS);
            } else if (pred.equals(NTEMPLATE.HAS_DATATYPE) && obj instanceof IRI objIri) {
                datatypeMap.put(subj, objIri);
            } else if (pred.equals(NTEMPLATE.HAS_LANGUAGE_TAG) && obj instanceof Literal) {
                languageTagMap.put(subj, Literals.normalizeLanguageTag(objS));
            } else if (pred.equals(POSSIBLE_LANGUAGE_TAG) && obj instanceof Literal) {
                possibleLanguageTagMap.computeIfAbsent(subj, k -> new ArrayList<>()).add(Literals.normalizeLanguageTag(objS));
            } else if (pred.equals(NTEMPLATE.HAS_PREFIX) && obj instanceof Literal) {
                prefixMap.put(subj, objS);
            } else if (pred.equals(NTEMPLATE.HAS_PREFIX_LABEL) && obj instanceof Literal) {
                prefixLabelMap.put(subj, objS);
            } else if (pred.equals(NTEMPLATE.HAS_REGEX) && obj instanceof Literal) {
                regexMap.put(subj, objS);
            } else if (pred.equals(RDF.SUBJECT)) {
                if (obj instanceof IRI objIri) {
                    statementSubjects.put(subj, objIri);
                } else {
                    nonIriStatementSubjects.put(subj, obj);
                }
            } else if (pred.equals(RDF.PREDICATE)) {
                if (obj instanceof IRI objIri) {
                    statementPredicates.put(subj, objIri);
                } else {
                    nonIriStatementPredicates.put(subj, obj);
                }
            } else if (pred.equals(RDF.OBJECT)) {
                statementObjects.put(subj, obj);
            } else if (pred.equals(NTEMPLATE.HAS_DEFAULT_VALUE)) {
                defaultValues.put(subj, obj);
            } else if (pred.equals(NTEMPLATE.STATEMENT_ORDER)) {
                if (obj instanceof Literal && objS.matches("[0-9]+")) {
                    statementOrder.put(subj, Integer.valueOf(objS));
                }
            }
        }
//                List<IRI> assertionTypes = typeMap.get(templateIri);
//                if (assertionTypes == null || (!assertionTypes.contains(NTEMPLATE.ASSERTION_TEMPLATE) &&
//                                !assertionTypes.contains(NTEMPLATE.PROVENANCE_TEMPLATE) && !assertionTypes.contains(PUBINFO_TEMPLATE))) {
//                        throw new MalformedTemplateException("Unknown template type");
//                }
        List<IRI> groupIris = new ArrayList<>();
        for (IRI iri : typeMap.keySet()) {
            if (typeMap.get(iri).contains(NTEMPLATE.GROUPED_STATEMENT)) groupIris.add(iri);
        }
        // Nested groups and repeatable members are out of scope (the group is the unit of
        // repetition); ignore such member flags with a warning instead of half-rendering:
        for (IRI iri : groupIris) {
            if (!isGroupedStatement(iri)) continue;
            List<IRI> memberIris = getStatementIris(iri);
            if (memberIris == null) {
                throw new MalformedTemplateException("Grouped statement has no member statements: " + iri);
            }
            for (IRI member : memberIris) {
                List<IRI> memberTypes = typeMap.get(member);
                if (memberTypes == null) continue;
                if (memberTypes.remove(NTEMPLATE.GROUPED_STATEMENT)) {
                    logger.warn("Ignoring nested nt:GroupedStatement flag on member {} of group {}", member, iri);
                }
                if (memberTypes.remove(NTEMPLATE.REPEATABLE_STATEMENT)) {
                    logger.warn("Ignoring nt:RepeatableStatement flag on member {} of group {}", member, iri);
                }
            }
        }
        for (IRI iri : groupIris) {
            if (!isGroupedStatement(iri)) continue;
            List<IRI> memberIris = getStatementIris(iri);
            // A group needs at least one required member: an all-optional group would match zero
            // statements, making its presence meaningless and repetition detection non-terminating.
            // Degrade to group-level optionality (today's semantics) instead of rejecting:
            boolean hasRequiredMember = false;
            for (IRI member : memberIris) {
                if (!isOptionalStatement(member)) hasRequiredMember = true;
            }
            if (!hasRequiredMember) {
                logger.warn("All members of group {} are optional; treating the group itself as optional instead", iri);
                if (!isOptionalStatement(iri)) {
                    addType(iri, NTEMPLATE.OPTIONAL_STATEMENT);
                }
                for (IRI member : memberIris) {
                    typeMap.get(member).remove(NTEMPLATE.OPTIONAL_STATEMENT);
                }
            }
            // Grouped IRI are added via group, so direct link from template is redundant:
            for (IRI groupedIri : memberIris) {
                statementMap.get(templateIri).remove(groupedIri);
            }
        }
        for (List<IRI> l : statementMap.values()) {
            l.sort(statementComparator);
        }
    }

    private void processShaclTemplate(Nanopub templateNp) throws MalformedTemplateException {
        templateIri = null;
        for (Statement st : templateNp.getAssertion()) {
            if (st.getPredicate().equals(SHACL.TARGET_CLASS)) {
                templateIri = (IRI) st.getSubject();
                break;
            }
        }
        if (templateIri == null) {
            throw new MalformedTemplateException("Base node shape not found");
        }

        IRI baseSubj = vf.createIRI(templateIri.stringValue() + "+subj");
        addType(baseSubj, NTEMPLATE.INTRODUCED_RESOURCE);

        List<IRI> statementList = new ArrayList<>();
        Map<IRI, Integer> minCounts = new HashMap<>();
        Map<IRI, Integer> maxCounts = new HashMap<>();

        for (Statement st : templateNp.getAssertion()) {
            final IRI subj = (IRI) st.getSubject();
            final IRI pred = st.getPredicate();
            final Value obj = st.getObject();
            final String objS = obj.stringValue();

            if (subj.equals(templateIri)) {
                if (pred.equals(RDFS.LABEL)) {
                    label = objS;
                } else if (pred.equals(DCTERMS.DESCRIPTION)) {
                    description = Utils.sanitizeHtml(objS);
                } else if (obj instanceof IRI objIri) {
                    if (pred.equals(NTEMPLATE.HAS_DEFAULT_PROVENANCE)) {
                        defaultProvenance = objIri;
                    } else if (pred.equals(NTEMPLATE.HAS_REQUIRED_PUBINFO_ELEMENT)) {
                        requiredPubInfoElements.add(objIri);
                    } else if (pred.equals(NTEMPLATE.HAS_TARGET_NAMESPACE)) {
                        targetNamespace = objS;
                    } else if (pred.equals(NTEMPLATE.HAS_TARGET_NANOPUB_TYPE)) {
                        targetNanopubTypes.add(objIri);
                    }
                } else if (obj instanceof Literal) {
                    if (pred.equals(NTEMPLATE.HAS_TAG)) {
                        // TODO This should be replaced at some point with a more sophisticated mechanism based on classes.
                        // We are assuming that there is at most one tag.
                        this.tag = objS;
                    } else if (pred.equals(NTEMPLATE.HAS_NANOPUB_LABEL_PATTERN)) {
                        nanopubLabelPattern = objS;
                    }
                }
            }
            if (pred.equals(RDF.TYPE) && obj instanceof IRI objIri) {
                addType(subj, objIri);
            } else if (pred.equals(SHACL.PROPERTY) && obj instanceof IRI objIri) {
                statementList.add(objIri);
                List<IRI> l = statementMap.get(subj);
                if (l == null) {
                    l = new ArrayList<>();
                    statementMap.put(subj, l);
                }
                l.add((IRI) objIri);
                IRI stSubjIri = vf.createIRI(subj.stringValue() + "+subj");
                statementSubjects.put(objIri, stSubjIri);
                addType(stSubjIri, NTEMPLATE.LOCAL_RESOURCE);
                addType(stSubjIri, NTEMPLATE.URI_PLACEHOLDER);
            } else if (pred.equals(SHACL.PATH) && obj instanceof IRI objIri) {
                statementPredicates.put(subj, objIri);
            } else if (pred.equals(SHACL.HAS_VALUE) && obj instanceof IRI objIri) {
                statementObjects.put(subj, objIri);
            } else if (pred.equals(SHACL.TARGET_CLASS) && obj instanceof IRI objIri) {
                IRI stIri = vf.createIRI(templateNp.getUri() + "/$type");
                statementList.add(stIri);
                List<IRI> l = statementMap.get(subj);
                if (l == null) {
                    l = new ArrayList<>();
                    statementMap.put(subj, l);
                }
                l.add((IRI) stIri);
                statementSubjects.put(stIri, baseSubj);
                statementPredicates.put(stIri, RDF.TYPE);
                statementObjects.put(stIri, objIri);
            } else if (pred.equals(NTEMPLATE.POSSIBLE_VALUE)) {
                List<Value> l = possibleValueMap.get(subj);
                if (l == null) {
                    l = new ArrayList<>();
                    possibleValueMap.put(subj, l);
                }
                l.add(obj);
            } else if (pred.equals(NTEMPLATE.POSSIBLE_VALUES_FROM)) {
                List<IRI> l = possibleValuesToLoadMap.get(subj);
                if (l == null) {
                    l = new ArrayList<>();
                    possibleValuesToLoadMap.put(subj, l);
                }
                if (obj instanceof IRI objIri) {
                    l.add(objIri);
                    Nanopub valuesNanopub = Utils.getNanopub(objS);
                    for (Statement s : valuesNanopub.getAssertion()) {
                        if (s.getPredicate().equals(RDFS.LABEL)) {
                            labelMap.put((IRI) s.getSubject(), s.getObject().stringValue());
                        }
                    }
                }
            } else if (pred.equals(NTEMPLATE.POSSIBLE_VALUES_FROM_API)) {
                List<String> l = apiMap.get(subj);
                if (l == null) {
                    l = new ArrayList<>();
                    apiMap.put(subj, l);
                }
                if (obj instanceof Literal) {
                    l.add(objS);
                }
            } else if (pred.equals(RDFS.LABEL) && obj instanceof Literal) {
                labelMap.put(subj, objS);
            } else if (pred.equals(NTEMPLATE.HAS_DATATYPE) && obj instanceof IRI objIri) {
                datatypeMap.put(subj, objIri);
            } else if (pred.equals(NTEMPLATE.HAS_LANGUAGE_TAG) && obj instanceof Literal) {
                languageTagMap.put(subj, Literals.normalizeLanguageTag(objS));
            } else if (pred.equals(POSSIBLE_LANGUAGE_TAG) && obj instanceof Literal) {
                possibleLanguageTagMap.computeIfAbsent(subj, k -> new ArrayList<>()).add(Literals.normalizeLanguageTag(objS));
            } else if (pred.equals(NTEMPLATE.HAS_PREFIX) && obj instanceof Literal) {
                prefixMap.put(subj, objS);
            } else if (pred.equals(NTEMPLATE.HAS_PREFIX_LABEL) && obj instanceof Literal) {
                prefixLabelMap.put(subj, objS);
            } else if (pred.equals(NTEMPLATE.HAS_REGEX) && obj instanceof Literal) {
                regexMap.put(subj, objS);
//                        } else if (pred.equals(RDF.SUBJECT) && obj instanceof IRI objIri) {
//                                statementSubjects.put(subj, objIri);
//                        } else if (pred.equals(RDF.PREDICATE) && obj instanceof IRI objIri) {
//                                statementPredicates.put(subj, objIri);
//                        } else if (pred.equals(RDF.OBJECT)) {
//                                statementObjects.put(subj, obj);
            } else if (pred.equals(NTEMPLATE.HAS_DEFAULT_VALUE)) {
                defaultValues.put(subj, obj);
            } else if (pred.equals(NTEMPLATE.STATEMENT_ORDER)) {
                if (obj instanceof Literal && objS.matches("[0-9]+")) {
                    statementOrder.put(subj, Integer.valueOf(objS));
                }
            } else if (pred.equals(SHACL.MIN_COUNT)) {
                try {
                    minCounts.put(subj, Integer.parseInt(obj.stringValue()));
                } catch (NumberFormatException ex) {
                    logger.error("Could not parse <{}> value: {}", SHACL.MIN_COUNT, obj.stringValue());
                }
            } else if (pred.equals(SHACL.MAX_COUNT)) {
                try {
                    maxCounts.put(subj, Integer.parseInt(obj.stringValue()));
                } catch (NumberFormatException ex) {
                    logger.error("Could not parse <{}> value: {}", SHACL.MAX_COUNT, obj.stringValue());
                }
            }
        }
        for (List<IRI> l : statementMap.values()) {
            l.sort(statementComparator);
        }
        for (IRI iri : statementList) {
            if (!statementObjects.containsKey(iri)) {
                IRI stObjIri = vf.createIRI(iri.stringValue() + "+obj");
                statementObjects.put(iri, stObjIri);
                addType(stObjIri, NTEMPLATE.VALUE_PLACEHOLDER);
                if (!minCounts.containsKey(iri) || minCounts.get(iri) <= 0) {
                    addType(iri, NTEMPLATE.OPTIONAL_STATEMENT);
                }
                if (!maxCounts.containsKey(iri) || maxCounts.get(iri) > 1) {
                    addType(iri, NTEMPLATE.REPEATABLE_STATEMENT);
                }
            }
        }
        if (!labelMap.containsKey(baseSubj) && typeMap.get(baseSubj).contains(NTEMPLATE.URI_PLACEHOLDER) && typeMap.get(baseSubj).contains(NTEMPLATE.LOCAL_RESOURCE)) {
            labelMap.put(baseSubj, "short ID as URI suffix");
        }

        if (label == null) {
            label = NanopubUtils.getLabel(templateNp);
        }
    }

    public void addToLabelMap(Object key, String label) {
        if (key instanceof IRI iri) {
            labelMap.put(iri, label);
        } else {
            labelMap.put(vf.createIRI(key.toString()), label);
        }
    }

    private void addType(IRI thing, IRI type) {
        List<IRI> l = typeMap.get(thing);
        if (l == null) {
            l = new ArrayList<>();
            typeMap.put(thing, l);
        }
        l.add(type);
    }

    private IRI transform(IRI iri) {
        // A template can leave a statement part undefined (see getStatementErrors()), in which
        // case the null propagates here through getSubject()/getPredicate(). Let the type and
        // label lookups below answer "no" for it instead of failing to render the whole form.
        if (iri == null) return null;
        String s = iri.stringValue();
        // Map a rendered IRI back to its template form for map lookups (label, type,
        // datatype, …). RepetitionGroup.transform expands the template's "~~ARTIFACTCODE~~"
        // placeholder to the target-namespace "~~~ARTIFACTCODE~~~" form and appends a "__N"
        // repetition suffix; both must be undone here or the lookup keyed on the template
        // form (e.g. an attached rdfs:label) is missed.
        if (s.contains("~~~ARTIFACTCODE~~~")) {
            s = s.replace("~~~ARTIFACTCODE~~~", "~~ARTIFACTCODE~~");
        }
        if (s.matches(".*__[0-9]+")) {
            // TODO: Check that this double-underscore pattern isn't used otherwise:
            s = s.replaceFirst("__[0-9]+$", "");
        }
        if (s.equals(iri.stringValue())) return iri;
        return vf.createIRI(s);
    }

    private StatementComparator statementComparator = new StatementComparator();

    private class StatementComparator implements Comparator<IRI>, Serializable {

        /**
         * Compares two IRIs based on their order in the template.
         *
         * @param arg0 the first object to be compared.
         * @param arg1 the second object to be compared.
         * @return a negative integer, zero, or a positive integer as the first argument is less than, equal to, or greater than the second.
         */
        @Override
        public int compare(IRI arg0, IRI arg1) {
            Integer i0 = statementOrder.get(arg0);
            Integer i1 = statementOrder.get(arg1);
            if (i0 == null && i1 == null) return arg0.stringValue().compareTo(arg1.stringValue());
            if (i0 == null) return 1;
            if (i1 == null) return -1;
            return i0 - i1;
        }

    }

}

knowledgepixels / nanodash / 30350726166

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous