30350501786

Committed 28 Jul 2026 10:22AM UTC coverage: 33.452% (+3.2%) from 30.298%

Build # 30350501786

Build Type

Pull #567

github

Committed by

web-flow

Commit Message

Merge 7dc757397 into 7086521ef

Pull Request Pull Request #567: Report and block templates with literals in subject/predicate position

Coverage Stats

2337 of 7695 branches covered (30.37%)

Branch coverage included in aggregate %.

4534 of 12845 relevant lines covered (35.3%)

5.45 hits per line

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

33.65

src/main/java/com/knowledgepixels/nanodash/component/PublishForm.java

package com.knowledgepixels.nanodash.component;

import com.knowledgepixels.nanodash.*;
import com.knowledgepixels.nanodash.component.menu.EntryActionMenu;
import com.knowledgepixels.nanodash.domain.AbstractResourceWithProfile;
import com.knowledgepixels.nanodash.domain.User;
import com.knowledgepixels.nanodash.page.ExplorePage;
import com.knowledgepixels.nanodash.page.NanodashPage;
import com.knowledgepixels.nanodash.page.PreviewPage;
import com.knowledgepixels.nanodash.template.*;
import com.knowledgepixels.nanodash.vocabulary.KPXL_TERMS;
import org.apache.commons.lang3.Strings;
import org.apache.wicket.Component;
import org.apache.wicket.RestartResponseException;
import org.apache.wicket.ajax.AjaxEventBehavior;
import org.apache.wicket.ajax.AjaxRequestTarget;
import org.apache.wicket.ajax.form.AjaxFormComponentUpdatingBehavior;
import org.apache.wicket.feedback.FeedbackMessage;
import org.apache.wicket.markup.html.WebMarkupContainer;
import org.apache.wicket.markup.html.WebPage;
import org.apache.wicket.markup.html.basic.Label;
import org.apache.wicket.markup.html.form.Button;
import org.apache.wicket.markup.html.form.CheckBox;
import org.apache.wicket.markup.html.form.Form;
import org.apache.wicket.markup.html.form.FormComponent;
import org.apache.wicket.markup.html.link.BookmarkablePageLink;
import org.apache.wicket.markup.html.list.ListItem;
import org.apache.wicket.markup.html.list.ListView;
import org.apache.wicket.markup.html.panel.FeedbackPanel;
import org.apache.wicket.markup.html.panel.Panel;
import org.apache.wicket.markup.repeater.Item;
import org.apache.wicket.markup.repeater.data.DataView;
import org.apache.wicket.markup.repeater.data.ListDataProvider;
import org.apache.wicket.model.IModel;
import org.apache.wicket.model.Model;
import org.apache.wicket.request.mapper.parameter.PageParameters;
import org.eclipse.rdf4j.model.IRI;
import org.eclipse.rdf4j.model.Literal;
import org.eclipse.rdf4j.model.Statement;
import org.eclipse.rdf4j.model.ValueFactory;
import org.eclipse.rdf4j.model.impl.SimpleValueFactory;
import org.eclipse.rdf4j.model.vocabulary.FOAF;
import org.eclipse.rdf4j.model.vocabulary.RDF;
import org.eclipse.rdf4j.model.vocabulary.RDFS;
import org.nanopub.MalformedNanopubException;
import org.nanopub.Nanopub;
import org.nanopub.NanopubAlreadyFinalizedException;
import org.nanopub.NanopubCreator;
import org.nanopub.extra.security.SignNanopub;
import org.nanopub.extra.security.SignatureAlgorithm;
import org.nanopub.extra.security.TransformContext;
import org.nanopub.extra.server.PublishNanopub;
import org.nanopub.extra.services.ApiResponse;
import org.nanopub.extra.services.ApiResponseEntry;
import org.nanopub.extra.services.QueryRef;
import org.nanopub.vocabulary.NPX;
import org.nanopub.vocabulary.NTEMPLATE;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.wicketstuff.select2.ChoiceProvider;
import org.wicketstuff.select2.Response;
import org.wicketstuff.select2.Select2Choice;

import java.io.Serializable;
import java.lang.reflect.InvocationTargetException;
import java.util.*;

/**
 * Form for publishing a nanopublication.
 */
public class PublishForm extends Panel {

    private static final Logger logger = LoggerFactory.getLogger(PublishForm.class);

    private static final ValueFactory vf = SimpleValueFactory.getInstance();

    public static final String CREATOR_PUB_INFO_TEMPLATE = "https://w3id.org/np/RAukAcWHRDlkqxk7H2XNSegc1WnHI569INvNr-xdptDGI";
    public static final String LICENSE_PUB_INFO_TEMPLATE = "https://w3id.org/np/RACJ58Gvyn91LqCKIO9zu1eijDQIeEff28iyDrJgjSJF8";
    public static final String DEFAULT_PROV_TEMPLATE = "https://w3id.org/np/RA7lSq6MuK_TIC6JMSHvLtee3lpLoZDOqLJCLXevnrPoU";
    private static final String supersedesPubInfoTemplateId = "https://w3id.org/np/RAoTD7udB2KtUuOuAe74tJi1t3VzK0DyWS7rYVAq1GRvw";
    private static final String derivesFromPubInfoTemplateId = "https://w3id.org/np/RARW4MsFkHuwjycNElvEVtuMjpf4yWDL10-0C5l2MqqRQ";

    private static final String[] fixedPubInfoTemplates = new String[]{CREATOR_PUB_INFO_TEMPLATE, LICENSE_PUB_INFO_TEMPLATE};

    private static final String INVALID_TEMPLATE_MESSAGE = "This form is based on an invalid template and cannot be published.";
    // Page parameters that make the form supersede or override an existing nanopublication
    // ("fill" is the deprecated form of "supersede"):
    private static final String[] sourceParamKeys = new String[]{"supersede", "supersede-a", "override", "override-a", "fill"};

    /**
     * Fill modes for the nanopublication to be created.
     */
    public enum FillMode {
        /**
         * Use fill mode
         */
        USE,
        /**
         * Supersede fill mode
         */
        SUPERSEDE,
        /**
         * Derive fill mode
         */
        DERIVE,
        /**
         * Override fill mode: like {@link #DERIVE} in that it records a
         * {@code prov:wasDerivedFrom} link, but (like {@link #SUPERSEDE}) it
         * keeps the source nanopub's introduced resource IRIs and its root
         * definition nanopub.
         */
        OVERRIDE
    }

    /**
     * A problem reported by {@link Template#getStatementErrors()}, together with the part of the
     * nanopublication ("Assertion", "Provenance", "Publication info") whose template has it.
     *
     * @param part    the nanopublication part the offending template defines
     * @param message the description of the problem
     */
    public record TemplateError(String part, String message) implements Serializable {
    }

    protected Form<?> form;
    protected FeedbackPanel feedbackPanel;
    private final TemplateContext assertionContext;
    private TemplateContext provenanceContext;
    private final List<TemplateContext> pubInfoContexts = new ArrayList<>();
    private final Map<String, TemplateContext> pubInfoContextMap = new HashMap<>();
    private final List<TemplateContext> requiredPubInfoContexts = new ArrayList<>();
    private String targetNamespace;
    private final Class<? extends WebPage> confirmPageClass;

    /**
     * Constructor for the PublishForm.
     *
     * @param id the Wicket component ID
     * @param pageParams the parameters for the page, which may include
     * information on how to fill the form
     * @param publishPageClass the class of the page to redirect to after
     * successful publication
     * @param confirmPageClass the class of the confirmation page to show after
     * publication
     */
    public PublishForm(String id, final PageParameters pageParams, Class<? extends WebPage> publishPageClass, Class<? extends WebPage> confirmPageClass) {
        super(id);
        setOutputMarkupId(true);
        this.confirmPageClass = confirmPageClass;

        WebMarkupContainer linkMessageItem = new WebMarkupContainer("link-message-item");
        if (pageParams.get("link-message").isNull()) {
            linkMessageItem.add(new Label("link-message", ""));
            linkMessageItem.setVisible(false);
        } else {
            linkMessageItem.add(new Label("link-message", Utils.sanitizeHtml(pageParams.get("link-message").toString())).setEscapeModelStrings(false));
        }
        add(linkMessageItem);

        final Nanopub fillNp;
        final FillMode fillMode;
        boolean fillOnlyAssertion = false;
        if (!pageParams.get("use").isNull()) {
            fillNp = Utils.getNanopub(pageParams.get("use").toString());
            fillMode = FillMode.USE;
        } else if (!pageParams.get("use-a").isNull()) {
            fillNp = Utils.getNanopub(pageParams.get("use-a").toString());
            fillMode = FillMode.USE;
            fillOnlyAssertion = true;
        } else if (!pageParams.get("supersede").isNull()) {
            fillNp = Utils.getNanopub(pageParams.get("supersede").toString());
            fillMode = FillMode.SUPERSEDE;
            targetNamespace = pageParams.get("supersede").toString().replaceFirst("RA[A-Za-z0-9-_]{43}$", "");
        } else if (!pageParams.get("supersede-a").isNull()) {
            fillNp = Utils.getNanopub(pageParams.get("supersede-a").toString());
            fillMode = FillMode.SUPERSEDE;
            fillOnlyAssertion = true;
        } else if (!pageParams.get("derive").isNull()) {
            fillNp = Utils.getNanopub(pageParams.get("derive").toString());
            fillMode = FillMode.DERIVE;
        } else if (!pageParams.get("derive-a").isNull()) {
            fillNp = Utils.getNanopub(pageParams.get("derive-a").toString());
            fillMode = FillMode.DERIVE;
            fillOnlyAssertion = true;
        } else if (!pageParams.get("override").isNull()) {
            fillNp = Utils.getNanopub(pageParams.get("override").toString());
            fillMode = FillMode.OVERRIDE;
        } else if (!pageParams.get("override-a").isNull()) {
            fillNp = Utils.getNanopub(pageParams.get("override-a").toString());
            fillMode = FillMode.OVERRIDE;
            fillOnlyAssertion = true;
        } else if (!pageParams.get("fill-all").isNull()) {
            // TODO: This is deprecated and should be removed at some point
            fillNp = Utils.getNanopub(pageParams.get("fill-all").toString());
            fillMode = FillMode.USE;
        } else if (!pageParams.get("fill").isNull()) {
            // TODO: This is deprecated and should be removed at some point
            fillNp = Utils.getNanopub(pageParams.get("fill").toString());
            fillMode = FillMode.SUPERSEDE;
        } else {
            fillNp = null;
            fillMode = null;
        }

        final TemplateData td = TemplateData.get();

        // TODO Properly integrate this namespace feature:
        String templateId = pageParams.get("template").toString();
        Template template = td.getTemplate(templateId);
        if (template != null && template.getTargetNamespace() != null) {
            targetNamespace = template.getTargetNamespace();
        }
        if (!pageParams.get("target-namespace").isNull()) {
            targetNamespace = pageParams.get("target-namespace").toString();
        }
        if (targetNamespace == null) {
            targetNamespace = Template.DEFAULT_TARGET_NAMESPACE;
        }
        String targetNamespaceLabel = targetNamespace + "...";
        targetNamespace = targetNamespace + "~~~ARTIFACTCODE~~~/";

        assertionContext = new TemplateContext(ContextType.ASSERTION, templateId, "statement", targetNamespace);
        assertionContext.setFillMode(fillMode);
        final String prTemplateId;
        if (pageParams.get("prtemplate").toString() != null) {
            prTemplateId = pageParams.get("prtemplate").toString();
        } else {
            if (fillNp != null && !fillOnlyAssertion) {
                if (td.getProvenanceTemplateId(fillNp) != null) {
                    prTemplateId = td.getProvenanceTemplateId(fillNp).stringValue();
                } else {
                    prTemplateId = "http://purl.org/np/RAcm8OurwUk15WOgBM9wySo-T3a5h6as4K8YR5MBrrxUc";
                }
            } else if (assertionContext.getTemplate().getDefaultProvenance() != null) {
                prTemplateId = assertionContext.getTemplate().getDefaultProvenance().stringValue();
            } else {
                prTemplateId = DEFAULT_PROV_TEMPLATE;
            }
        }
        provenanceContext = new TemplateContext(ContextType.PROVENANCE, prTemplateId, "pr-statement", targetNamespace);
        for (String t : fixedPubInfoTemplates) {
            // TODO consistently check for latest versions of templates here and below:
            TemplateContext c = new TemplateContext(ContextType.PUBINFO, t, "pi-statement", targetNamespace);
            pubInfoContexts.add(c);
            pubInfoContextMap.put(c.getTemplate().getId(), c);
            requiredPubInfoContexts.add(c);
            if (t.equals(LICENSE_PUB_INFO_TEMPLATE) && fillMode != FillMode.SUPERSEDE && fillMode != FillMode.DERIVE && fillMode != FillMode.OVERRIDE) {
                IRI defaultLicense = User.getDefaultLicense(NanodashSession.get().getUserIri());
                if (defaultLicense != null) {
                    c.setParam("license", defaultLicense.stringValue());
                }
            }
        }
        if (fillMode == FillMode.SUPERSEDE) {
            TemplateContext c = new TemplateContext(ContextType.PUBINFO, supersedesPubInfoTemplateId, "pi-statement", targetNamespace);
            pubInfoContexts.add(c);
            pubInfoContextMap.put(supersedesPubInfoTemplateId, c);
            //requiredPubInfoContexts.add(c);
            c.setParam("np", fillNp.getUri().stringValue());
        } else if (fillMode == FillMode.DERIVE || fillMode == FillMode.OVERRIDE) {
            TemplateContext c = new TemplateContext(ContextType.PUBINFO, derivesFromPubInfoTemplateId, "pi-statement", targetNamespace);
            pubInfoContexts.add(c);
            pubInfoContextMap.put(derivesFromPubInfoTemplateId, c);
            c.setParam("np", fillNp.getUri().stringValue());
        }
        for (IRI r : assertionContext.getTemplate().getRequiredPubInfoElements()) {
            String latestId = td.getLatestTemplateId(r.stringValue());
            if (pubInfoContextMap.containsKey(r.stringValue()) || pubInfoContextMap.containsKey(latestId)) {
                continue;
            }
            TemplateContext c = new TemplateContext(ContextType.PUBINFO, r.stringValue(), "pi-statement", targetNamespace);
            pubInfoContexts.add(c);
            pubInfoContextMap.put(c.getTemplateId(), c);
            requiredPubInfoContexts.add(c);
        }
        Map<Integer, TemplateContext> piParamIdMap = new HashMap<>();
        for (String k : pageParams.getNamedKeys()) {
            if (!k.matches("pitemplate[1-9][0-9]*")) {
                continue;
            }
            Integer i = Integer.parseInt(k.replaceFirst("^pitemplate([1-9][0-9]*)$", "$1"));
            String tid = pageParams.get(k).toString();
            // TODO Allow for automatically using latest template version:
            //String piTemplateIdLatest = QueryApiAccess.getLatestVersionId(tid);
            TemplateContext c = createPubInfoContext(tid);
            if (piParamIdMap.containsKey(i)) {
                // TODO: handle this error better
                logger.error("Publication Info template param identifier defined multiple times: {}", i);
            }
            piParamIdMap.put(i, c);
        }
        if (fillNp != null && !fillOnlyAssertion) {
            for (IRI piTemplateId : td.getPubinfoTemplateIds(fillNp)) {
                String piTemplateIdLatest = td.getLatestTemplateId(piTemplateId.stringValue());
                if (piTemplateIdLatest.equals(supersedesPubInfoTemplateId)) {
                    continue;
                }
                if (!pubInfoContextMap.containsKey(piTemplateIdLatest)) {
                    // TODO Allow for automatically using latest template version
                    createPubInfoContext(piTemplateId.stringValue());
                }
            }
        }
        if (!pageParams.get("values-from-query").isEmpty() && !pageParams.get("values-from-query-mapping").isEmpty()) {
            String querySpec = pageParams.get("values-from-query").toString();

            String mapping = pageParams.get("values-from-query-mapping").toString();
            String mapsFrom, mapsTo;
            if (mapping.contains(":")) {
                mapsFrom = mapping.split(":")[0];
                mapsTo = mapping.split(":")[1];
            } else {
                mapsFrom = mapping;
                mapsTo = mapping;
            }
            ApiResponse resp = ApiCache.retrieveResponseSync(QueryRef.parseString(querySpec), false);
            int i = 0;
            for (ApiResponseEntry e : resp.getData()) {
                String mapsToSuffix = "";
                if (i > 0) {
                    mapsToSuffix = "__" + i;
                }
                assertionContext.setParam(mapsTo + mapsToSuffix, e.get(mapsFrom));
                i++;
            }
        }
        for (String k : pageParams.getNamedKeys()) {
            if (k.startsWith("param_")) {
                assertionContext.setParam(k.substring(6), pageParams.get(k).toString());
            }
            if (k.startsWith("prparam_")) {
                provenanceContext.setParam(k.substring(8), pageParams.get(k).toString());
            }
            if (k.matches("piparam[1-9][0-9]*_.*")) {
                Integer i = Integer.parseInt(k.replaceFirst("^piparam([1-9][0-9]*)_.*$", "$1"));
                if (!piParamIdMap.containsKey(i)) {
                    logger.error("Parameter {} of the publication info template not found", i);
                    continue;
                }
                String n = k.replaceFirst("^piparam[1-9][0-9]*_(.*)$", "$1");
                logger.info(n);
                piParamIdMap.get(i).setParam(n, pageParams.get(k).toString());
            }
        }

        final Nanopub improveNp;
        if (!pageParams.get("improve").isNull()) {
            improveNp = Utils.getNanopub(pageParams.get("improve").toString());
        } else {
            improveNp = null;
        }

        // Propagate fill source (supersede/derive/improve) so contexts can resolve
        // the `local:nanopub`/`local:assertion` sentinels to the fill nanopub's URIs.
        Nanopub fillSource = fillNp != null ? fillNp : improveNp;
        if (fillSource != null) {
            assertionContext.setFillSource(fillSource);
            provenanceContext.setFillSource(fillSource);
            for (TemplateContext c : pubInfoContexts) {
                c.setFillSource(fillSource);
            }
        }

        // Init statements only now, in order to pick up parameter values:
        assertionContext.initStatements();
        provenanceContext.initStatements();
        for (TemplateContext c : pubInfoContexts) {
            c.initStatements();
        }

        String latestAssertionId = td.getLatestTemplateId(assertionContext.getTemplateId());
        if (!assertionContext.getTemplateId().equals(latestAssertionId)) {
            add(new Label("newversion", "There is a new version of this assertion template:"));
            PageParameters params = new PageParameters(pageParams);
            params.set("template", latestAssertionId);
            add(new BookmarkablePageLink<Void>("newversionlink", publishPageClass, params));
            if ("latest".equals(pageParams.get("template-version").toString())) {
                throw new RestartResponseException(publishPageClass, params);
            }
        } else {
            add(new Label("newversion", "").setVisible(false));
            add(new Label("newversionlink", "").setVisible(false));
        }

        final List<Statement> unusedStatementList = new ArrayList<>();
        final List<Statement> unusedPrStatementList = new ArrayList<>();
        final List<Statement> unusedPiStatementList = new ArrayList<>();
        if (fillNp != null) {
            ValueFiller filler = new ValueFiller(fillNp, ContextType.ASSERTION, true, fillMode);
            filler.fill(assertionContext);
            unusedStatementList.addAll(filler.getUnusedStatements());

            if (!fillOnlyAssertion) {
                ValueFiller prFiller = new ValueFiller(fillNp, ContextType.PROVENANCE, true);
                prFiller.fill(provenanceContext);
                unusedPrStatementList.addAll(prFiller.getUnusedStatements());

                ValueFiller piFiller = new ValueFiller(fillNp, ContextType.PUBINFO, true);
                if (!assertionContext.getTemplate().getTargetNanopubTypes().isEmpty()) {
                    for (Statement st : new ArrayList<>(piFiller.getUnusedStatements())) {
                        if (st.getSubject().stringValue().equals(LocalUri.of("nanopub").stringValue()) && st.getPredicate().equals(NPX.HAS_NANOPUB_TYPE)) {
                            if (assertionContext.getTemplate().getTargetNanopubTypes().contains(st.getObject())) {
                                piFiller.removeUnusedStatement(st);
                            }
                        }
                    }
                }
                for (TemplateContext c : pubInfoContexts) {
                    piFiller.fill(c);
                }
                piFiller.removeUnusedStatements(NanodashSession.get().getUserIri(), FOAF.NAME, null);
                if (piFiller.hasUnusedStatements()) {
                    final String handcodedStatementsTemplateId = "https://w3id.org/np/RAMEgudZsQ1bh1fZhfYnkthqH6YSXpghSE_DEN1I-6eAI";
                    if (!pubInfoContextMap.containsKey(handcodedStatementsTemplateId)) {
                        TemplateContext c = createPubInfoContext(handcodedStatementsTemplateId);
                        c.setFillSource(fillNp);
                        c.initStatements();
                        piFiller.fill(c);
                    }
                }
                unusedPiStatementList.addAll(piFiller.getUnusedStatements());
                // TODO: Also use pubinfo templates stated in nanopub to be filled in?
//                                Set<IRI> pubinfoTemplateIds = Template.getPubinfoTemplateIds(fillNp);
//                                if (!pubinfoTemplateIds.isEmpty()) {
//                                        ValueFiller piFiller = new ValueFiller(fillNp, ContextType.PUBINFO);
//                                        for (IRI pubinfoTemplateId : pubinfoTemplateIds) {
//                                                // TODO: Make smart choice on the ordering in trying to fill in all pubinfo elements
//                                                piFiller.fill(pubInfoContextMap.get(pubinfoTemplateId.stringValue()));
//                                        }
//                                        warningMessage += (piFiller.getWarningMessage() == null ? "" : "Publication info: " + piFiller.getWarningMessage() + " ");
//                                }
            }
        } else if (improveNp != null) {
            ValueFiller filler = new ValueFiller(improveNp, ContextType.ASSERTION, true);
            filler.fill(assertionContext);
            unusedStatementList.addAll(filler.getUnusedStatements());
        }
        if (!unusedStatementList.isEmpty()) {
            add(new Label("warnings", "Some content from the existing nanopublication could not be filled in:"));
        } else {
            add(new Label("warnings", "").setVisible(false));
        }
        add(new DataView<Statement>("unused-statements", new ListDataProvider<Statement>(unusedStatementList)) {

            @Override
            protected void populateItem(Item<Statement> item) {
                item.add(new TripleItem("unused-statement", item.getModelObject(), (fillNp != null ? fillNp : improveNp), null));
            }

        });
        add(new DataView<Statement>("unused-prstatements", new ListDataProvider<Statement>(unusedPrStatementList)) {

            @Override
            protected void populateItem(Item<Statement> item) {
                item.add(new TripleItem("unused-prstatement", item.getModelObject(), (fillNp != null ? fillNp : improveNp), null));
            }

        });
        add(new DataView<Statement>("unused-pistatements", new ListDataProvider<Statement>(unusedPiStatementList)) {

            @Override
            protected void populateItem(Item<Statement> item) {
                item.add(new TripleItem("unused-pistatement", item.getModelObject(), (fillNp != null ? fillNp : improveNp), null));
            }

        });

        // Statements of the involved templates that cannot produce valid RDF, e.g. a literal
        // placeholder in subject position. Such a template silently publishes something other
        // than what it describes, so the problem is spelled out above the form:
        List<TemplateError> templateErrors = new ArrayList<>();
        collectTemplateErrors("Assertion", assertionContext, templateErrors);
        collectTemplateErrors("Provenance", provenanceContext, templateErrors);
        for (TemplateContext c : pubInfoContexts) {
            collectTemplateErrors("Publication info", c, templateErrors);
        }
        if (!templateErrors.isEmpty()) {
            add(new Label("template-error-intro", "This form is based on an invalid template and will not produce the nanopublication it describes:"));
        } else {
            add(new Label("template-error-intro", "").setVisible(false));
        }
        add(new ListView<TemplateError>("template-errors", templateErrors) {

            @Override
            protected void populateItem(ListItem<TemplateError> item) {
                item.add(new Label("template-error-part", item.getModelObject().part() + ": "));
                item.add(new Label("template-error", item.getModelObject().message()));
            }

        });

        // Finalize statements, which picks up parameter values in repetitions:
        assertionContext.finalizeStatements();
        provenanceContext.finalizeStatements();
        for (TemplateContext c : pubInfoContexts) {
            c.finalizeStatements();
        }

        final CheckBox consentCheck = new CheckBox("consentcheck", new Model<>(false));
        consentCheck.add(new InvalidityHighlighting());

        form = new Form<Void>("form") {

            @Override
            protected void onConfigure() {
                super.onConfigure();
                form.getFeedbackMessages().clear();
//                                formComponents.clear();
            }

            protected void onSubmit() {
                // The publish button is hidden in this case, but the form can still be
                // submitted by pressing Enter in one of its fields:
                if (!templateErrors.isEmpty()) {
                    feedbackPanel.error(INVALID_TEMPLATE_MESSAGE);
                    return;
                }
                // Re-check here too: a newer version might have appeared while the form was open.
                if (!canPublishFromSource(pageParams)) {
                    return;
                }

                if (!Boolean.TRUE.equals(consentCheck.getModelObject())) {
                    feedbackPanel.error("You need to check the checkbox that you understand the consequences.");
                    return;
                }
                logger.info("Publish form submitted");
                Nanopub signedNp;
                try {
                    Nanopub np = createNanopub();
                    logger.info("Nanopublication created: {}", np.getUri());
                    TransformContext tc = new TransformContext(SignatureAlgorithm.RSA, NanodashSession.get().getKeyPair(), NanodashSession.get().getUserIri(), false, false, false);
                    signedNp = SignNanopub.signAndTransform(np, tc);
                    logger.info("Nanopublication signed: {}", signedNp.getUri());
                    String npUrl = PublishNanopub.publish(signedNp);
                    logger.info("Nanopublication published: {}", npUrl);
                    Utils.cacheNanopub(signedNp);
                } catch (Exception ex) {
                    signedNp = null;
                    logger.error("Nanopublication publishing failed: {}", ex.getMessage());
                    String message = ex.getClass().getName();
                    if (ex.getMessage() != null) {
                        message = ex.getMessage();
                    }
                    feedbackPanel.error(message);
                }
                if (signedNp != null) {
                    String toRefresh = pageParams.get("refresh-upon-publish").toString("");
                    if (!toRefresh.isEmpty()) {
                        WicketApplication.get().notifyNanopubPublished(signedNp, toRefresh, 5 * 1000);
                    }
                    String contextId = pageParams.get("context").toString("");
                    // Broaden the refresh: also force-refresh the context resource's own
                    // data (e.g. a space's roles/members) so the page we redirect to —
                    // typically its Content tab — reflects the just-published change, not
                    // only the specific view query that was acted on.
                    if (!contextId.isEmpty() && !contextId.equals(toRefresh)
                            && AbstractResourceWithProfile.isResourceWithProfile(contextId)) {
                        WicketApplication.get().notifyNanopubPublished(signedNp, contextId, 5 * 1000);
                    }
                    if (pageParams.get("postpub-redirect-url").isEmpty() && confirmPageClass == null) {
                        // Forward to the context resource's page, or home if no context; always throws.
                        NavigationContext.redirectAfterPublish(signedNp, pageParams);
                    }
                    // Connector flow: show the connector's own confirmation page.
                    NanodashPage confirmPage = getConfirmPage(signedNp, pageParams);
                    if (confirmPage != null) {
                        throw new RestartResponseException(confirmPage);
                    }
                    NavigationContext.redirectAfterPublish(signedNp, pageParams);
                }
            }

            @Override
            protected void onValidate() {
                super.onValidate();
                for (Component fc : assertionContext.getComponents()) {
                    processFeedback(fc);
                }
                for (Component fc : provenanceContext.getComponents()) {
                    processFeedback(fc);
                }
                for (TemplateContext c : pubInfoContexts) {
                    for (Component fc : c.getComponents()) {
                        processFeedback(fc);
                    }
                }
            }

            private void processFeedback(Component c) {
                if (c instanceof FormComponent) {
                    ((FormComponent<?>) c).processInput();
                }
                for (FeedbackMessage fm : c.getFeedbackMessages()) {
                    form.getFeedbackMessages().add(fm);
                }
            }

        };
        form.setOutputMarkupId(true);

        //form.add(new Label("nanopub-namespace", targetNamespaceLabel));
        form.add(newSourceMenu("templatelink", assertionContext.getTemplate().getId()));
        form.add(new Label("templatename", assertionContext.getTemplate().getLabel()));
        String description = assertionContext.getTemplate().getLabel();
        form.add(new Label("templatedesc", assertionContext.getTemplate().getDescription()).setEscapeModelStrings(false));

        form.add(new ListView<StatementItem>("statements", assertionContext.getStatementItems()) {

            protected void populateItem(ListItem<StatementItem> item) {
                item.add(item.getModelObject());
            }

        });

        final Map<String, Boolean> handledProvTemplates = new HashMap<>();
        final String defaultProvTemplateId;
        if (assertionContext.getTemplate().getDefaultProvenance() != null) {
            defaultProvTemplateId = assertionContext.getTemplate().getDefaultProvenance().stringValue();
            handledProvTemplates.put(defaultProvTemplateId, true);
        } else {
            defaultProvTemplateId = null;
        }
        final List<String> recommendedProvTemplateOptionIds = new ArrayList<>();
        final List<String> provTemplateOptionIds = new ArrayList<>();
        if (pageParams.get("prtemplate-options").isNull()) {
            // TODO Make this dynamic and consider updated templates:
            recommendedProvTemplateOptionIds.add(DEFAULT_PROV_TEMPLATE);
            recommendedProvTemplateOptionIds.add("http://purl.org/np/RAcTpoh5Ra0ssqmcpOgWdaZ_YiPE6demO6cpw-2RvSNs8");
            recommendedProvTemplateOptionIds.add("http://purl.org/np/RA4LGtuOqTIMqVAkjnfBXk1YDcAPNadP5CGiaJiBkdHCQ");
            recommendedProvTemplateOptionIds.add("http://purl.org/np/RAl_-VTw9Re_uRF8r8y0rjlfnu7FlhTa8xg_8xkcweqiE");
            recommendedProvTemplateOptionIds.add("https://w3id.org/np/RASORV2mMEVpS4lWh2bwUTEcV-RWjbD9RPbN7J0PIeYAU");
            recommendedProvTemplateOptionIds.add("http://purl.org/np/RAjkBbM5yQm7hKH1l_Jk3HAUqWi3Bd57TPmAOZCsZmi_M");
            recommendedProvTemplateOptionIds.add("http://purl.org/np/RAGXx_k9eQMnXaCbsXMsJbGClwZtQEGNg0GVJu6amdAVw");
            recommendedProvTemplateOptionIds.add("http://purl.org/np/RA1fnITI3Pu1UQ0CHghNpys3JwQrM32LBnjmDLoayp9-4");
            recommendedProvTemplateOptionIds.add("http://purl.org/np/RAJgbsGeGdTG-zq_gU0TLw4s3raMgoRk-mPlc2DSLXvE0");
            recommendedProvTemplateOptionIds.add("http://purl.org/np/RA6SXfhUY-xeblZU8HhPddw6tsu-C5NXevG6C_zv4bMxU");
            for (String s : recommendedProvTemplateOptionIds) {
                handledProvTemplates.put(s, true);
            }

            for (ApiResponseEntry t : td.getProvenanceTemplates()) {
                String tid = t.get("np");
                if (handledProvTemplates.containsKey(tid)) {
                    continue;
                }
                provTemplateOptionIds.add(tid);
                handledProvTemplates.put(tid, true);
            }
        } else {
            for (String s : pageParams.get("prtemplate-options").toString().split(" ")) {
                if (handledProvTemplates.containsKey(s)) {
                    continue;
                }
                recommendedProvTemplateOptionIds.add(s);
                handledProvTemplates.put(s, true);
            }
        }

        ChoiceProvider<String> prTemplateChoiceProvider = new ChoiceProvider<String>() {

            @Override
            public String getDisplayValue(String object) {
                if (object == null || object.isEmpty()) {
                    return "";
                }
                Template t = td.getTemplate(object);
                if (t != null) {
                    return t.getLabel();
                }
                return object;
            }

            @Override
            public String getIdValue(String object) {
                return object;
            }

            // Getting strange errors with Tomcat if this method is not overridden:
            @Override
            public void detach() {
            }

            @Override
            public void query(String term, int page, Response<String> response) {
                if (term == null) {
                    term = "";
                }
                term = term.toLowerCase();
                if (pageParams.get("prtemplate").toString() != null) {
                    // Using this work-around with "——" because 'optgroup' is not available through Wicket's Select2 classes
                    response.add("—— default for this link ——");
                    response.add(prTemplateId);
                }
                if (defaultProvTemplateId != null) {
                    response.add("—— default for this template ——");
                    response.add(defaultProvTemplateId);
                }
                if (!recommendedProvTemplateOptionIds.isEmpty()) {
                    if (pageParams.get("prtemplate-options").isNull()) {
                        response.add("—— recommended ——");
                    }
                    for (String s : recommendedProvTemplateOptionIds) {
                        if (s.toLowerCase().contains(term) || getDisplayValue(s).toLowerCase().contains(term)) {
                            response.add(s);
                        }
                    }
                }
                if (!provTemplateOptionIds.isEmpty()) {
                    response.add("—— others ——");
                    for (String s : provTemplateOptionIds) {
                        if (s.toLowerCase().contains(term) || getDisplayValue(s).toLowerCase().contains(term)) {
                            response.add(s);
                        }
                    }
                }
            }

            @Override
            public Collection<String> toChoices(Collection<String> ids) {
                return ids;
            }

        };
        final IModel<String> prTemplateModel = Model.of(provenanceContext.getTemplate().getId());
        Select2Choice<String> prTemplateChoice = new Select2Choice<String>("prtemplate", prTemplateModel, prTemplateChoiceProvider);
        prTemplateChoice.setRequired(true);
        prTemplateChoice.getSettings().setCloseOnSelect(true);
        prTemplateChoice.add(new AjaxFormComponentUpdatingBehavior("change") {

            @Override
            protected void onUpdate(AjaxRequestTarget target) {
                String o = prTemplateModel.getObject();
                if (o.startsWith("——")) {
                    o = provenanceContext.getTemplate().getId();
                    prTemplateModel.setObject(o);
                }
                provenanceContext = new TemplateContext(ContextType.PROVENANCE, prTemplateModel.getObject(), "pr-statement", targetNamespace);
                provenanceContext.initStatements();
                refreshProvenance(target);
                provenanceContext.finalizeStatements();
            }

        });
        form.add(prTemplateChoice);
        refreshProvenance(null);

        final Map<String, Boolean> handledPiTemplates = new HashMap<>();
        final List<String> recommendedPiTemplateOptionIds = new ArrayList<>();
        final List<String> piTemplateOptionIds = new ArrayList<>();
        // TODO Make this dynamic and consider updated templates:
        recommendedPiTemplateOptionIds.add("http://purl.org/np/RAXflINqt3smqxV5Aq7E9lzje4uLdkKIOefa6Bp8oJ8CY");
        recommendedPiTemplateOptionIds.add("https://w3id.org/np/RARW4MsFkHuwjycNElvEVtuMjpf4yWDL10-0C5l2MqqRQ");
        recommendedPiTemplateOptionIds.add("https://w3id.org/np/RA16U9Wo30ObhrK1NzH7EsmVRiRtvEuEA_Dfc-u8WkUCA");
        recommendedPiTemplateOptionIds.add("http://purl.org/np/RAdyqI6k07V5nAS82C6hvIDtNWk179EIV4DV-sLbOFKg4");
        recommendedPiTemplateOptionIds.add("https://w3id.org/np/RAjvEpLZUE7rMoa8q6mWSsN6utJDp-5FmgO47YGsbgw3w");
        recommendedPiTemplateOptionIds.add("http://purl.org/np/RAxuGRKID6yNg63V5Mf0ot2NjncOnodh-mkN3qT_1txGI");
        for (TemplateContext c : pubInfoContexts) {
            // Key both ID forms: the "others" dedup below compares against listing
            // entries keyed by nanopub URI, which for a template with embedded
            // identity differs from its canonical ID.
            handledPiTemplates.put(c.getTemplate().getId(), true);
            handledPiTemplates.put(c.getTemplate().getNanopub().getUri().stringValue(), true);
        }
        for (String s : recommendedPiTemplateOptionIds) {
            handledPiTemplates.put(s, true);
        }

        for (ApiResponseEntry entry : td.getPubInfoTemplates()) {
            String tid = entry.get("np");
            if (handledPiTemplates.containsKey(tid)) {
                continue;
            }
            piTemplateOptionIds.add(tid);
            handledPiTemplates.put(tid, true);
        }

        ChoiceProvider<String> piTemplateChoiceProvider = new ChoiceProvider<String>() {

            @Override
            public String getDisplayValue(String object) {
                if (object == null || object.isEmpty()) {
                    return "";
                }
                Template t = td.getTemplate(object);
                if (t != null) {
                    return t.getLabel();
                }
                return object;
            }

            @Override
            public String getIdValue(String object) {
                return object;
            }

            // Getting strange errors with Tomcat if this method is not overridden:
            @Override
            public void detach() {
            }

            @Override
            public void query(String term, int page, Response<String> response) {
                if (term == null) {
                    term = "";
                }
                term = term.toLowerCase();
                if (!recommendedPiTemplateOptionIds.isEmpty()) {
                    response.add("—— recommended ——");
                    for (String s : recommendedPiTemplateOptionIds) {
                        boolean isAlreadyUsed = false;
                        for (TemplateContext c : pubInfoContexts) {
                            // TODO: make this more efficient/nicer
                            if (c.getTemplate().hasId(s)) {
                                isAlreadyUsed = true;
                                break;
                            }
                        }
                        if (isAlreadyUsed) {
                            continue;
                        }
                        if (s.toLowerCase().contains(term) || getDisplayValue(s).toLowerCase().contains(term)) {
                            response.add(s);
                        }
                    }
                }
                if (!piTemplateOptionIds.isEmpty()) {
                    response.add("—— others ——");
                    for (String s : piTemplateOptionIds) {
                        boolean isAlreadyUsed = false;
                        for (TemplateContext c : pubInfoContexts) {
                            // TODO: make this more efficient/nicer
                            if (c.getTemplate().hasId(s)) {
                                isAlreadyUsed = true;
                                break;
                            }
                        }
                        if (isAlreadyUsed) {
                            continue;
                        }
                        if (s.toLowerCase().contains(term) || getDisplayValue(s).toLowerCase().contains(term)) {
                            response.add(s);
                        }
                    }
                }
            }

            @Override
            public Collection<String> toChoices(Collection<String> ids) {
                return ids;
            }

        };
        final IModel<String> newPiTemplateModel = Model.of();
        Select2Choice<String> piTemplateChoice = new Select2Choice<String>("pitemplate", newPiTemplateModel, piTemplateChoiceProvider);
        piTemplateChoice.getSettings().setCloseOnSelect(true);
        piTemplateChoice.getSettings().setPlaceholder("add element...");
        piTemplateChoice.add(new AjaxFormComponentUpdatingBehavior("change") {

            @Override
            protected void onUpdate(AjaxRequestTarget target) {
                if (newPiTemplateModel.getObject().startsWith("——")) {
                    newPiTemplateModel.setObject(null);
                    refreshPubInfo(target);
                    return;
                }
                String id = newPiTemplateModel.getObject();
                TemplateContext c = new TemplateContext(ContextType.PUBINFO, id, "pi-statement", targetNamespace);
                c.initStatements();
                pubInfoContexts.add(c);
                newPiTemplateModel.setObject(null);
                refreshPubInfo(target);
                c.finalizeStatements();
            }

        });
        form.add(piTemplateChoice);
        refreshPubInfo(null);

        // An invalid template cannot produce the nanopublication it describes, so there is
        // nothing to consent to, publish or preview; the reasons are listed above the form.
        boolean publishingDisabled = !templateErrors.isEmpty();

        WebMarkupContainer consentSection = new WebMarkupContainer("consent-section");
        consentSection.add(consentCheck);
        consentSection.setVisible(!publishingDisabled);
        form.add(consentSection);

        WebMarkupContainer buttonSection = new WebMarkupContainer("button-section");
        buttonSection.setVisible(!publishingDisabled);
        form.add(buttonSection);

        form.add(new Label("publishing-disabled", "Publishing is disabled because of the template errors listed above.")
                .setVisible(publishingDisabled));

        buttonSection.add(new Button("preview-button") {
            @Override
            public void onSubmit() {
                if (!templateErrors.isEmpty()) {
                    feedbackPanel.error(INVALID_TEMPLATE_MESSAGE);
                    return;
                }
                try {
                    // Re-check here too: a newer version might have appeared while the form was open.
                    if (!canPublishFromSource(pageParams)) {
                        return;
                    }

                    Nanopub np = createNanopub();
                    TransformContext tc = new TransformContext(SignatureAlgorithm.RSA, NanodashSession.get().getKeyPair(), NanodashSession.get().getUserIri(), false, false, false);
                    Nanopub signedNp = SignNanopub.signAndTransform(np, tc);
                    String previewId = signedNp.getUri().stringValue();
                    NanodashSession.get().setPreviewNanopub(previewId,
                            new NanodashSession.PreviewNanopub(signedNp, pageParams, confirmPageClass, Boolean.TRUE.equals(consentCheck.getModelObject()), getPage().getPageReference()));
                    throw new RestartResponseException(PreviewPage.class, new PageParameters().set("id", previewId));
                } catch (RestartResponseException ex) {
                    throw ex;
                } catch (Exception ex) {
                    logger.error("Preview failed: {}", ex.getMessage());
                    String message = ex.getClass().getName();
                    if (ex.getMessage() != null) {
                        message = ex.getMessage();
                    }
                    feedbackPanel.error(message);
                }
            }
        });

        add(form);

        feedbackPanel = new FeedbackPanel("feedback");
        feedbackPanel.setOutputMarkupId(true);
        add(feedbackPanel);
    }

    static EntryActionMenu newSourceMenu(String id, String templateId) {
        BookmarkablePageLink<Void> sourceLink = new BookmarkablePageLink<>("link", ExplorePage.class, new PageParameters().set("id", templateId));
        sourceLink.add(NavigationContext.pageContextFallback());
        sourceLink.setBody(Model.of("<span class=\"actionmenu-icon\">↗︎</span>source")).setEscapeModelStrings(false);
        return new EntryActionMenu(id, List.of(sourceLink));
    }

    private void refreshProvenance(AjaxRequestTarget target) {
        if (target != null) {
            form.remove("prtemplatelink");
            form.remove("pr-statements");
            target.add(form);
            target.appendJavaScript("updateElements();");
        }
        form.add(newSourceMenu("prtemplatelink", provenanceContext.getTemplate().getId()));
        ListView<StatementItem> list = new ListView<StatementItem>("pr-statements", provenanceContext.getStatementItems()) {

            protected void populateItem(ListItem<StatementItem> item) {
                item.add(item.getModelObject());
            }

        };
        list.setOutputMarkupId(true);
        form.add(list);
    }

    private void refreshPubInfo(AjaxRequestTarget target) {
        ListView<TemplateContext> list = new ListView<TemplateContext>("pis", pubInfoContexts) {

            protected void populateItem(ListItem<TemplateContext> item) {
                final TemplateContext pic = item.getModelObject();
                item.add(new Label("pitemplatename", pic.getTemplate().getLabel()));
                item.add(newSourceMenu("pitemplatelink", pic.getTemplate().getId()));
                Label remove = new Label("piremove", "×");
                item.add(remove);
                remove.add(new AjaxEventBehavior("click") {

                    @Override
                    protected void onEvent(AjaxRequestTarget target) {
                        pubInfoContexts.remove(pic);
                        target.add(PublishForm.this);
                        target.appendJavaScript("updateElements();");
                    }

                });
                if (requiredPubInfoContexts.contains(pic)) {
                    remove.setVisible(false);
                }
                item.add(new ListView<StatementItem>("pi-statements", pic.getStatementItems()) {

                    protected void populateItem(ListItem<StatementItem> item) {
                        item.add(item.getModelObject());
                    }

                });
            }

        };
        list.setOutputMarkupId(true);
        if (target == null) {
            form.add(list);
        } else {
            form.remove("pis");
            form.add(list);
            target.add(form);
            target.appendJavaScript("updateElements();");
        }
    }

    private TemplateContext createPubInfoContext(String piTemplateId) {
        TemplateContext c;
        if (pubInfoContextMap.containsKey(piTemplateId)) {
            c = pubInfoContextMap.get(piTemplateId);
        } else {
            c = new TemplateContext(ContextType.PUBINFO, piTemplateId, "pi-statement", targetNamespace);
            pubInfoContextMap.put(piTemplateId, c);
            pubInfoContexts.add(c);
        }
        return c;
    }

    private static void collectTemplateErrors(String part, TemplateContext context, List<TemplateError> errors) {
        if (context == null || context.getTemplate() == null) return;
        for (String error : context.getTemplate().getStatementErrors()) {
            errors.add(new TemplateError(part, error));
        }
    }

    private synchronized Nanopub createNanopub() throws MalformedNanopubException, NanopubAlreadyFinalizedException {
        assertionContext.getIntroducedIris().clear();
        assertionContext.getRolePropertyPins().clear();
        NanopubCreator npCreator = new NanopubCreator(targetNamespace);
        npCreator.setAssertionUri(vf.createIRI(targetNamespace + "assertion"));
        assertionContext.propagateStatements(npCreator);
        provenanceContext.propagateStatements(npCreator);
        for (TemplateContext c : pubInfoContexts) {
            c.propagateStatements(npCreator);
        }
        for (IRI introducedIri : assertionContext.getIntroducedIris()) {
            npCreator.addPubinfoStatement(NPX.INTRODUCES, introducedIri);
        }
        for (IRI embeddedIri : assertionContext.getEmbeddedIris()) {
            npCreator.addPubinfoStatement(NPX.EMBEDS, embeddedIri);
        }
        Map<IRI, IRI> rolePropertyPins = assertionContext.getRolePropertyPins();
        if (!rolePropertyPins.isEmpty()) {
            // A role predicate carrying a direction pin makes this a role-instantiation
            // nanopub; nanopub-query's pin-resolution branch is gated on this type (#525).
            npCreator.addPubinfoStatement(NPX.HAS_NANOPUB_TYPE, KPXL_TERMS.ROLE_INSTANTIATION);
            for (Map.Entry<IRI, IRI> pin : rolePropertyPins.entrySet()) {
                npCreator.addPubinfoStatement(pin.getKey(), RDF.TYPE, pin.getValue());
            }
        }
        npCreator.addNamespace("this", targetNamespace);
        npCreator.addNamespace("sub", targetNamespace + "/");
        npCreator.addTimestampNow();
        // The canonical template ID: the embedded template-node IRI for templates
        // with embedded identity, the nanopub URI for legacy ones.
        IRI templateUri = vf.createIRI(assertionContext.getTemplate().getId());
        npCreator.addPubinfoStatement(NTEMPLATE.WAS_CREATED_FROM_TEMPLATE, templateUri);
        IRI prTemplateUri = vf.createIRI(provenanceContext.getTemplate().getId());
        npCreator.addPubinfoStatement(NTEMPLATE.WAS_CREATED_FROM_PROVENANCE_TEMPLATE, prTemplateUri);
        for (TemplateContext c : pubInfoContexts) {
            IRI piTemplateUri = vf.createIRI(c.getTemplate().getId());
            npCreator.addPubinfoStatement(NTEMPLATE.WAS_CREATED_FROM_PUBINFO_TEMPLATE, piTemplateUri);
        }
        String nanopubLabel = getNanopubLabel(npCreator);
        if (nanopubLabel != null) {
            npCreator.addPubinfoStatement(RDFS.LABEL, vf.createLiteral(nanopubLabel));
        }
        for (IRI type : assertionContext.getTemplate().getTargetNanopubTypes()) {
            npCreator.addPubinfoStatement(NPX.HAS_NANOPUB_TYPE, type);
        }
        IRI userIri = NanodashSession.get().getUserIri();
        if (User.getName(userIri) != null) {
            npCreator.addPubinfoStatement(userIri, FOAF.NAME, vf.createLiteral(User.getName(userIri)));
            npCreator.addNamespace("foaf", FOAF.NAMESPACE);
        }
        String websiteUrl = NanodashPreferences.get().getWebsiteUrl();
        if (websiteUrl != null) {
            npCreator.addPubinfoStatement(NPX.WAS_CREATED_AT, vf.createIRI(websiteUrl));
        }
        return npCreator.finalizeNanopub();
    }

    private String getNanopubLabel(NanopubCreator npCreator) {
        if (assertionContext.getTemplate().getNanopubLabelPattern() == null) {
            return null;
        }

        Map<IRI, String> labelMap = new HashMap<>();
        for (Statement st : npCreator.getCurrentPubinfoStatements()) {
            if (st.getPredicate().equals(RDFS.LABEL) && st.getObject() instanceof Literal objL) {
                labelMap.put((IRI) st.getSubject(), objL.stringValue());
            }
        }

        String nanopubLabel = assertionContext.getTemplate().getNanopubLabelPattern();
        while (nanopubLabel.matches(".*\\$\\{[_a-zA-Z0-9-]+\\}.*")) {
            String placeholderPostfix = nanopubLabel.replaceFirst("^.*\\$\\{([_a-zA-Z0-9-]+)\\}.*$", "$1");
            IRI placeholderIriHash = vf.createIRI(assertionContext.getTemplateNanopubUri() + "#" + placeholderPostfix);
            IRI placeholderIriSlash = vf.createIRI(assertionContext.getTemplateNanopubUri() + "/" + placeholderPostfix);
            IRI placeholderIri;
            String placeholderValue = "";
            if (assertionContext.getComponentModels().get(placeholderIriSlash) != null) {
                placeholderIri = placeholderIriSlash;
            } else {
                placeholderIri = placeholderIriHash;
            }
            IModel<String> m = (IModel<String>) assertionContext.getComponentModels().get(placeholderIri);
            if (m != null) {
                placeholderValue = m.orElse("").getObject();
            }
            if (placeholderValue == null) {
                placeholderValue = "";
            }
            String placeholderLabel = placeholderValue;
            if (assertionContext.getTemplate().isUriPlaceholder(placeholderIri)) {
                try {
                    // TODO Fix this. It doesn't work for placeholders with auto-encode placeholders, etc.
                    //      Not sure we need labels for these, but this code should be improved anyway.
                    String prefix = assertionContext.getTemplate().getPrefix(placeholderIri);
                    if (prefix != null) {
                        placeholderValue = prefix + placeholderValue;
                    }
                    IRI placeholderValueIri = vf.createIRI(placeholderValue);
                    String l = assertionContext.getTemplate().getLabel(placeholderValueIri);
                    if (labelMap.containsKey(placeholderValueIri)) {
                        l = labelMap.get(placeholderValueIri);
                    }
                    if (l == null) {
                        l = GuidedChoiceItem.getLabel(placeholderValue);
                    }
                    if (assertionContext.getTemplate().isAgentPlaceholder(placeholderIri) && !placeholderValue.isEmpty()) {
                        l = User.getName(vf.createIRI(placeholderValue));
                    }
                    if (l != null && !l.isEmpty()) {
                        placeholderLabel = l.replaceFirst(" - .*$", "");
                    } else {
                        placeholderLabel = Utils.getShortNameFromURI(placeholderValueIri);
                    }
                } catch (Exception ex) {
                    logger.error("Nanopub label placeholder IRI error: {}", ex.getMessage());
                }
            }
            placeholderLabel = placeholderLabel.replaceAll("\\s+", " ");
            if (placeholderLabel.length() > 100) {
                placeholderLabel = placeholderLabel.substring(0, 97) + "...";
            }
            nanopubLabel = Strings.CS.replace(nanopubLabel, "${" + placeholderPostfix + "}", placeholderLabel);
        }
        return nanopubLabel;
    }

    private NanodashPage getConfirmPage(Nanopub signedNp, PageParameters pageParams) {
        if (confirmPageClass == null) {
            return null;
        }
        try {
            return (NanodashPage) confirmPageClass.getConstructor(Nanopub.class, PageParameters.class).newInstance(signedNp, pageParams);
        } catch (InstantiationException | IllegalAccessException | IllegalArgumentException
                | InvocationTargetException | NoSuchMethodException | SecurityException ex) {
            logger.error("Could not create instance of confirmation page: {}", ex.getMessage());
        }
        return null;
    }

    /**
     * Returns a hint whether the form is stateless or not.
     *
     * @return false if the form is stateful, true if it is stateless.
     */
    // This is supposed to solve the problem that sometimes (but only sometimes) form content is reset
    // if the user browses other pages in parallel:
    protected boolean getStatelessHint() {
        return false;
    }

    private boolean canPublishFromSource(PageParameters pageParams) {
        if (!isSourceOutdated(pageParams)) {
            return true;
        }
        feedbackPanel.error("The nanopublication you are trying to supersede or override is not the latest version.");
        return false;
    }

    /**
     * Returns the ID of the nanopublication that the given page parameters ask
     * to supersede or override, or null if they ask for neither.
     *
     * @param pageParams the page parameters of the publish page
     * @return the ID of the nanopublication to be superseded or overridden, or
     * null
     */
    public static String getSupersededOrOverriddenNanopubId(PageParameters pageParams) {
        for (String key : sourceParamKeys) {
            if (!pageParams.get(key).isEmpty()) {
                return pageParams.get(key).toString();
            }
        }
        return null;
    }

    /**
     * Checks whether the given page parameters ask to supersede or override a
     * nanopublication that is not the latest version anymore. Only the latest
     * version can be superseded or overridden.
     *
     * @param pageParams the page parameters of the publish page
     * @return true if a newer version of the nanopublication to be superseded
     * or overridden exists
     */
    public static boolean isSourceOutdated(PageParameters pageParams) {
        String sourceNpId = getSupersededOrOverriddenNanopubId(pageParams);
        return sourceNpId != null && !sourceNpId.equals(QueryApiAccess.getLatestVersionId(sourceNpId));
    }

    /**
     * Returns a copy of the given page parameters where the nanopublication to
     * be superseded or overridden is replaced by the given one.
     *
     * @param pageParams the page parameters of the publish page
     * @param npId the ID of the nanopublication to supersede or override
     * instead
     * @return the adjusted copy of the page parameters
     */
    public static PageParameters withSourceNanopub(PageParameters pageParams, String npId) {
        PageParameters newParams = new PageParameters(pageParams);
        for (String key : sourceParamKeys) {
            if (!newParams.get(key).isEmpty()) {
                newParams.set(key, npId);
            }
        }
        return newParams;
    }

}

knowledgepixels / nanodash / 30350501786

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