29344362295

Committed 14 Jul 2026 03:13PM UTC coverage: 28.485% (-0.8%) from 29.306%

Build # 29344362295

Build Type

Pull #557

github

Committed by

web-flow

Commit Message

Merge df950e1a3 into e89f67f90

Pull Request Pull Request #557: feat: chat with local Claude Code via MCP endpoint

Coverage Stats

1986 of 7698 branches covered (25.8%)

Branch coverage included in aggregate %.

3930 of 13071 relevant lines covered (30.07%)

4.54 hits per line

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

20.72

src/main/java/com/knowledgepixels/nanodash/NanodashSession.java

package com.knowledgepixels.nanodash;

import com.knowledgepixels.nanodash.component.NanopubResults;
import com.knowledgepixels.nanodash.domain.User;
import com.knowledgepixels.nanodash.page.OrcidLoginPage;
import com.knowledgepixels.nanodash.page.ProfilePage;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpSession;
import jakarta.xml.bind.DatatypeConverter;
import org.apache.commons.io.FileUtils;
import org.apache.wicket.PageReference;
import org.apache.wicket.Session;
import org.apache.wicket.protocol.http.WebSession;
import org.apache.wicket.request.Request;
import org.apache.wicket.request.flow.RedirectToUrlException;
import org.apache.wicket.request.mapper.parameter.PageParameters;
import org.eclipse.rdf4j.model.IRI;
import org.eclipse.rdf4j.model.ValueFactory;
import org.eclipse.rdf4j.model.impl.SimpleValueFactory;
import org.nanopub.extra.security.*;
import org.nanopub.extra.setting.IntroNanopub;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.io.IOException;
import java.io.Serializable;
import java.nio.charset.StandardCharsets;
import java.security.KeyPair;
import java.util.Date;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

import org.apache.wicket.markup.html.WebPage;
import org.nanopub.Nanopub;

/**
 * Represents a session in the Nanodash application.
 */
public class NanodashSession extends WebSession {

    private transient HttpSession httpSession;
    private static final Logger logger = LoggerFactory.getLogger(NanodashSession.class);

    /**
     * Retrieves the current Nanodash session.
     *
     * @return The current NanodashSession instance.
     */
    public static NanodashSession get() {
        return (NanodashSession) Session.get();
    }

    /**
     * Returns the current user's agent IRI, or null when no session is bound to
     * the current thread (e.g. a background or non-request context) or no user is
     * logged in. Safe to call outside a request cycle, unlike {@link #get()}.
     *
     * @return the current user IRI, or null
     */
    public static IRI getCurrentUserIriOrNull() {
        return Session.exists() ? get().getUserIri() : null;
    }

    /**
     * Constructs a new NanodashSession for the given request.
     * Initializes the HTTP session and loads profile information.
     *
     * @param request The HTTP request.
     */
    public NanodashSession(Request request) {
        super(request);
        setLocale(Locale.US);
        httpSession = ((HttpServletRequest) request.getContainerRequest()).getSession();
        bind();
        loadProfileInfo();
    }

    @Override
    public Session setLocale(Locale locale) {
        return super.setLocale(Locale.US);
    }

    private static ValueFactory vf = SimpleValueFactory.getInstance();

//        private IntroExtractor introExtractor;

    private String userDir = System.getProperty("user.home") + "/.nanopub/";
    private NanopubResults.ViewMode nanopubResultsViewMode = NanopubResults.ViewMode.LIST;
    private boolean claudeChatDockExpanded = false;

    private KeyPair keyPair;
    private IRI userIri;
    private ConcurrentMap<IRI, IntroNanopub> introNps;
//        private Boolean isOrcidLinked;
//        private String orcidLinkError;

    private Integer localIntroCount = null;
    private IntroNanopub localIntro = null;

    private Date lastTimeIntroPublished = null;

    /**
     * Loads profile information for the user.
     * Initializes user-related data such as keys and introductions.
     */
    public void loadProfileInfo() {
        localIntroCount = null;
        localIntro = null;
        NanodashPreferences prefs = NanodashPreferences.get();
        if (prefs.isOrcidLoginMode()) {
            File usersDir = new File(System.getProperty("user.home") + "/.nanopub/nanodash-users/");
            if (!usersDir.exists()) usersDir.mkdir();
        }
        if (userIri == null && !prefs.isReadOnlyMode() && !prefs.isOrcidLoginMode()) {
            if (getOrcidFile().exists()) {
                try {
                    String orcid = FileUtils.readFileToString(getOrcidFile(), StandardCharsets.UTF_8).trim();
                    //String orcid = Files.readString(orcidFile.toPath(), StandardCharsets.UTF_8).trim();
                    if (orcid.matches(ProfilePage.ORCID_PATTERN)) {
                        userIri = vf.createIRI("https://orcid.org/" + orcid);
                        if (httpSession != null) httpSession.setMaxInactiveInterval(24 * 60 * 60);  // 24h
                    }
                } catch (IOException ex) {
                    logger.error("Couldn't read ORCID file", ex);
                }
            }
        }
        if (userIri != null && keyPair == null) {
            File keyFile = getKeyFile();
            if (keyFile.exists()) {
                try {
                    keyPair = SignNanopub.loadKey(keyFile.getPath(), SignatureAlgorithm.RSA);
                } catch (Exception ex) {
                    logger.error("Couldn't load key pair", ex);
                }
            } else {
                // Automatically generate new keys
                makeKeys();
            }
        }
        if (userIri != null && keyPair != null && introNps == null) {
            introNps = new ConcurrentHashMap<>(User.getIntroNanopubs(getPubkeyString()));
        }
//                checkOrcidLink();
    }

    /**
     * Checks if the user's profile is complete.
     *
     * @return True if the profile is complete, false otherwise.
     */
    public boolean isProfileComplete() {
        return userIri != null && keyPair != null && introNps != null;
    }

    /**
     * Redirects the user to the login page if their profile is incomplete.
     *
     * @param path       The path to redirect to after login.
     * @param parameters The page parameters for the redirect.
     */
    public void redirectToLoginIfNeeded(String path, PageParameters parameters) {
        String loginUrl = getLoginUrl(path, parameters);
        if (loginUrl == null) return;
        throw new RedirectToUrlException(loginUrl);
    }

    /**
     * Retrieves the login URL for the user.
     *
     * @param path       The path to redirect to after login.
     * @param parameters The page parameters for the redirect.
     * @return The login URL, or null if the user is already logged in.
     */
    public String getLoginUrl(String path, PageParameters parameters) {
        if (isProfileComplete()) return null;
        if (NanodashPreferences.get().isOrcidLoginMode()) {
            return OrcidLoginPage.getOrcidLoginUrl(path, parameters);
        } else {
            return ProfilePage.MOUNT_PATH;
        }
    }

    /**
     * Retrieves the public key as a Base64-encoded string.
     *
     * @return The public key string, or null if the key pair is not set.
     */
    public String getPubkeyString() {
        if (keyPair == null) return null;
        return DatatypeConverter.printBase64Binary(keyPair.getPublic().getEncoded()).replaceAll("\\s", "");
    }

    /**
     * Retrieves the public key hash for the user.
     *
     * @return The SHA-256 hash of the public key, or null if the public key is not set.
     */
    public String getPubkeyhash() {
        String pubkey = getPubkeyString();
        if (pubkey == null) return null;
        return Utils.createSha256HexHash(pubkey);
    }

    /**
     * Checks if the user's public key is approved.
     *
     * @return True if the public key is approved, false otherwise.
     */
    public boolean isPubkeyApproved() {
        if (keyPair == null || userIri == null) return false;
        return User.isApprovedPubkeyhashForUser(getPubkeyhash(), userIri);
    }

    /**
     * Retrieves the user's key pair.
     *
     * @return The key pair.
     */
    public KeyPair getKeyPair() {
        return keyPair;
    }

    /**
     * Generates a new key pair for the user.
     */
    public void makeKeys() {
        try {
            MakeKeys.make(getKeyFile().getAbsolutePath().replaceFirst("_rsa$", ""), SignatureAlgorithm.RSA);
            keyPair = SignNanopub.loadKey(getKeyFile().getPath(), SignatureAlgorithm.RSA);
        } catch (Exception ex) {
            logger.error("Couldn't create key pair", ex);
        }
    }

    /**
     * Retrieves the user's IRI.
     *
     * @return The user's IRI, or null if not set.
     */
    public IRI getUserIri() {
        return userIri;
    }

    /**
     * Retrieves the user's introduction nanopublications.
     *
     * @return A list of user's introduction nanopublications.
     */
    public List<IntroNanopub> getUserIntroNanopubs() {
        return User.getIntroNanopubs(userIri);
    }

    /**
     * Counts the number of local introduction nanopublications.
     *
     * @return The count of local introduction nanopublications.
     */
    public int getLocalIntroCount() {
        if (localIntroCount == null) {
            localIntroCount = 0;
            for (IntroNanopub inp : getUserIntroNanopubs()) {
                if (isIntroWithLocalKey(inp)) {
                    localIntroCount++;
                    localIntro = inp;
                }
            }
            if (localIntroCount > 1) localIntro = null;
        }
        return localIntroCount;
    }

    /**
     * Retrieves the local introduction nanopublication.
     *
     * @return The local introduction nanopublication, or null if not found.
     */
    public IntroNanopub getLocalIntro() {
        getLocalIntroCount();
        return localIntro;
    }

    /**
     * Checks if the given introduction nanopublication is associated with the local key.
     *
     * @param inp The introduction nanopublication.
     * @return True if associated with the local key, false otherwise.
     */
    public boolean isIntroWithLocalKey(IntroNanopub inp) {
        IRI location = Utils.getLocation(inp);
        NanopubSignatureElement el = Utils.getNanopubSignatureElement(inp);
        String siteUrl = NanodashPreferences.get().getWebsiteUrl();
        if (location != null && siteUrl != null) {
            String l = location.stringValue();
            // TODO: Solve the name change recognition in a better way:
            if (!l.equals(siteUrl) && !l.replace("nanobench", "nanodash").equals(siteUrl)) return false;
        }
        if (!getPubkeyString().equals(el.getPublicKeyString())) return false;
        for (KeyDeclaration kd : inp.getKeyDeclarations()) {
            if (getPubkeyString().equals(kd.getPublicKeyString())) return true;
        }
        return false;
    }

    /**
     * Sets the user's ORCID identifier.
     *
     * @param orcid The ORCID identifier.
     */
    public void setOrcid(String orcid) {
        if (!orcid.matches(ProfilePage.ORCID_PATTERN)) {
            throw new RuntimeException("Illegal ORCID identifier: " + orcid);
        }
        if (NanodashPreferences.get().isOrcidLoginMode()) {
            userDir = System.getProperty("user.home") + "/.nanopub/nanodash-users/" + orcid + "/";
            File f = new File(userDir);
            if (!f.exists()) f.mkdir();
        } else {
            try {
                FileUtils.writeStringToFile(getOrcidFile(), orcid + "\n", StandardCharsets.UTF_8);
                //                        Files.writeString(orcidFile.toPath(), orcid + "\n");
            } catch (IOException ex) {
                logger.error("Couldn't write ORCID file", ex);
            }
        }
        userIri = vf.createIRI("https://orcid.org/" + orcid);
        loadProfileInfo();
        if (httpSession != null) httpSession.setMaxInactiveInterval(24 * 60 * 60);  // 24h
    }

    /**
     * Logs out the user and invalidates the session.
     */
    public void logout() {
        userIri = null;
        invalidateNow();
    }

    /**
     * Retrieves the user's introduction nanopublications as a map.
     *
     * @return A map of introduction nanopublications.
     */
    public Map<IRI, IntroNanopub> getIntroNanopubs() {
        return introNps;
    }

//        public void checkOrcidLink() {
//                if (isOrcidLinked == null && userIri != null) {
//                        orcidLinkError = "";
//                        introExtractor = null;
//                        try {
//                                introExtractor = IntroNanopub.extract(userIri.stringValue(), null);
//                                if (introExtractor.getIntroNanopub() == null) {
//                                        orcidLinkError = "ORCID account is not linked.";
//                                        isOrcidLinked = false;
//                                } else {
//                                        IntroNanopub inp = IntroNanopub.get(userIri.stringValue(), introExtractor);
//                                        if (introNps != null && introNps.containsKey(inp.getNanopub().getUri())) {
//                                                // TODO: also check whether introduction contains local key
//                                                isOrcidLinked = true;
//                                        } else {
//                                                isOrcidLinked = false;
//                                                orcidLinkError = "Error: ORCID is linked to another introduction nanopublication.";
//                                        }
//                                }
//                        } catch (Exception ex) {
//                                logger.error("ORCID check failed");
//                                orcidLinkError = "ORCID check failed.";
//                        }
//                }
//        }
//
//        public void resetOrcidLinked() {
//                isOrcidLinked = null;
//        }
//
//        public boolean isOrcidLinked() {
//                checkOrcidLink();
//                return isOrcidLinked != null && isOrcidLinked == true;
//        }
//
//        public String getOrcidLinkError() {
//                return orcidLinkError;
//        }
//
//        public String getOrcidName() {
//                if (introExtractor == null || introExtractor.getName() == null) return null;
//                if (introExtractor.getName().trim().isEmpty()) return null;
//                return introExtractor.getName();
//        }

    /**
     * Retrieves the file for storing the user's ORCID identifier.
     *
     * @return The ORCID file.
     */
    private File getOrcidFile() {
        return new File(userDir + "orcid");
    }

    /**
     * Retrieves the file for storing the user's private key.
     *
     * @return The key file.
     */
    public File getKeyFile() {
        return new File(userDir + "id_rsa");
    }

    /**
     * Sets the time when the introduction was last published.
     */
    public void setIntroPublishedNow() {
        lastTimeIntroPublished = new Date();
    }

    /**
     * Checks if the introduction has been published.
     *
     * @return True if the introduction has been published, false otherwise.
     */
    public boolean hasIntroPublished() {
        return lastTimeIntroPublished != null;
    }

    /**
     * Calculates the time since the last introduction was published.
     *
     * @return The time in milliseconds since the last introduction was published, or Long.MAX_VALUE if it has never been published.
     */
    public long getTimeSinceLastIntroPublished() {
        if (lastTimeIntroPublished == null) return Long.MAX_VALUE;
        return new Date().getTime() - lastTimeIntroPublished.getTime();
    }

    /**
     * Sets the view mode for displaying nanopublication results.
     *
     * @param viewMode The desired view mode (e.g., GRID or LIST).
     */
    public void setNanopubResultsViewMode(NanopubResults.ViewMode viewMode) {
        this.nanopubResultsViewMode = viewMode;
    }

    /**
     * Retrieves the current view mode for displaying nanopublication results.
     *
     * @return The current view mode.
     */
    public NanopubResults.ViewMode getNanopubResultsViewMode() {
        return this.nanopubResultsViewMode;
    }

    /**
     * Whether the docked Claude chat panel is expanded on this session's pages.
     *
     * @return true if expanded
     */
    public boolean isClaudeChatDockExpanded() {
        return claudeChatDockExpanded;
    }

    /**
     * Set whether the docked Claude chat panel is expanded.
     *
     * @param claudeChatDockExpanded true to expand
     */
    public void setClaudeChatDockExpanded(boolean claudeChatDockExpanded) {
        this.claudeChatDockExpanded = claudeChatDockExpanded;
    }

    // --- Preview nanopub support ---

    public static class PreviewNanopub implements Serializable {
        private final Nanopub nanopub;
        private final PageParameters pageParams;
        private final Class<? extends WebPage> confirmPageClass;
        private final boolean consentChecked;
        private final PageReference sourcePageRef;

        public PreviewNanopub(Nanopub nanopub, PageParameters pageParams, Class<? extends WebPage> confirmPageClass, boolean consentChecked, PageReference sourcePageRef) {
            this.nanopub = nanopub;
            this.pageParams = pageParams;
            this.confirmPageClass = confirmPageClass;
            this.consentChecked = consentChecked;
            this.sourcePageRef = sourcePageRef;
        }

        public Nanopub getNanopub() { return nanopub; }
        public PageParameters getPageParams() { return pageParams; }
        public Class<? extends WebPage> getConfirmPageClass() { return confirmPageClass; }
        public boolean isConsentChecked() { return consentChecked; }
        public PageReference getSourcePageRef() { return sourcePageRef; }
    }

    private ConcurrentMap<String, PreviewNanopub> previewMap = new ConcurrentHashMap<>();

    public void setPreviewNanopub(String id, PreviewNanopub preview) {
        previewMap.put(id, preview);
    }

    public PreviewNanopub getPreviewNanopub(String id) {
        return previewMap.get(id);
    }

    public PreviewNanopub removePreviewNanopub(String id) {
        return previewMap.remove(id);
    }

}

1	package com.knowledgepixels.nanodash;
2
3	import com.knowledgepixels.nanodash.component.NanopubResults;
4	import com.knowledgepixels.nanodash.domain.User;
5	import com.knowledgepixels.nanodash.page.OrcidLoginPage;
6	import com.knowledgepixels.nanodash.page.ProfilePage;
7	import jakarta.servlet.http.HttpServletRequest;
8	import jakarta.servlet.http.HttpSession;
9	import jakarta.xml.bind.DatatypeConverter;
10	import org.apache.commons.io.FileUtils;
11	import org.apache.wicket.PageReference;
12	import org.apache.wicket.Session;
13	import org.apache.wicket.protocol.http.WebSession;
14	import org.apache.wicket.request.Request;
15	import org.apache.wicket.request.flow.RedirectToUrlException;
16	import org.apache.wicket.request.mapper.parameter.PageParameters;
17	import org.eclipse.rdf4j.model.IRI;
18	import org.eclipse.rdf4j.model.ValueFactory;
19	import org.eclipse.rdf4j.model.impl.SimpleValueFactory;
20	import org.nanopub.extra.security.*;
21	import org.nanopub.extra.setting.IntroNanopub;
22	import org.slf4j.Logger;
23	import org.slf4j.LoggerFactory;
24
25	import java.io.File;
26	import java.io.IOException;
27	import java.io.Serializable;
28	import java.nio.charset.StandardCharsets;
29	import java.security.KeyPair;
30	import java.util.Date;
31	import java.util.List;
32	import java.util.Locale;
33	import java.util.Map;
34	import java.util.concurrent.ConcurrentHashMap;
35	import java.util.concurrent.ConcurrentMap;
36
37	import org.apache.wicket.markup.html.WebPage;
38	import org.nanopub.Nanopub;
39
40	/**
41	* Represents a session in the Nanodash application.
42	*/
43	public class NanodashSession extends WebSession {
44
45	private transient HttpSession httpSession;
46	private static final Logger logger = LoggerFactory.getLogger(NanodashSession.class);	9✔
47
48	/**
49	* Retrieves the current Nanodash session.
50	*
51	* @return The current NanodashSession instance.
52	*/
53	public static NanodashSession get() {
54	return (NanodashSession) Session.get();	9✔
55	}
56
57	/**
58	* Returns the current user's agent IRI, or null when no session is bound to
59	* the current thread (e.g. a background or non-request context) or no user is
60	* logged in. Safe to call outside a request cycle, unlike {@link #get()}.
61	*
62	* @return the current user IRI, or null
63	*/
64	public static IRI getCurrentUserIriOrNull() {
65	return Session.exists() ? get().getUserIri() : null;	×
66	}
67
68	/**
69	* Constructs a new NanodashSession for the given request.
70	* Initializes the HTTP session and loads profile information.
71	*
72	* @param request The HTTP request.
73	*/
74	public NanodashSession(Request request) {
75	super(request);	9✔
76	setLocale(Locale.US);	12✔
77	httpSession = ((HttpServletRequest) request.getContainerRequest()).getSession();	18✔
78	bind();	6✔
79	loadProfileInfo();	6✔
80	}	3✔
81
82	@Override
83	public Session setLocale(Locale locale) {
84	return super.setLocale(Locale.US);	12✔
85	}
86
87	private static ValueFactory vf = SimpleValueFactory.getInstance();	9✔
88
89	// private IntroExtractor introExtractor;
90
91	private String userDir = System.getProperty("user.home") + "/.nanopub/";	15✔
92	private NanopubResults.ViewMode nanopubResultsViewMode = NanopubResults.ViewMode.LIST;	9✔
93	private boolean claudeChatDockExpanded = false;	9✔
94
95	private KeyPair keyPair;
96	private IRI userIri;
97	private ConcurrentMap<IRI, IntroNanopub> introNps;
98	// private Boolean isOrcidLinked;
99	// private String orcidLinkError;
100
101	private Integer localIntroCount = null;	9✔
102	private IntroNanopub localIntro = null;	9✔
103
104	private Date lastTimeIntroPublished = null;	9✔
105
106	/**
107	* Loads profile information for the user.
108	* Initializes user-related data such as keys and introductions.
109	*/
110	public void loadProfileInfo() {
111	localIntroCount = null;	9✔
112	localIntro = null;	9✔
113	NanodashPreferences prefs = NanodashPreferences.get();	6✔
114	if (prefs.isOrcidLoginMode()) {	9!
115	File usersDir = new File(System.getProperty("user.home") + "/.nanopub/nanodash-users/");	×
116	if (!usersDir.exists()) usersDir.mkdir();	×
117	}
118	if (userIri == null && !prefs.isReadOnlyMode() && !prefs.isOrcidLoginMode()) {	27!
119	if (getOrcidFile().exists()) {	12!
120	try {
121	String orcid = FileUtils.readFileToString(getOrcidFile(), StandardCharsets.UTF_8).trim();	×
122	//String orcid = Files.readString(orcidFile.toPath(), StandardCharsets.UTF_8).trim();
123	if (orcid.matches(ProfilePage.ORCID_PATTERN)) {	×
124	userIri = vf.createIRI("https://orcid.org/" + orcid);	×
125	if (httpSession != null) httpSession.setMaxInactiveInterval(24 * 60 * 60); // 24h	×
126	}
127	} catch (IOException ex) {	×
128	logger.error("Couldn't read ORCID file", ex);	×
129	}	×
130	}
131	}
132	if (userIri != null && keyPair == null) {	9!
133	File keyFile = getKeyFile();	×
134	if (keyFile.exists()) {	×
135	try {
136	keyPair = SignNanopub.loadKey(keyFile.getPath(), SignatureAlgorithm.RSA);	×
137	} catch (Exception ex) {	×
138	logger.error("Couldn't load key pair", ex);	×
139	}	×
140	} else {
141	// Automatically generate new keys
142	makeKeys();	×
143	}
144	}
145	if (userIri != null && keyPair != null && introNps == null) {	9!
146	introNps = new ConcurrentHashMap<>(User.getIntroNanopubs(getPubkeyString()));	×
147	}
148	// checkOrcidLink();
149	}	3✔
150
151	/**
152	* Checks if the user's profile is complete.
153	*
154	* @return True if the profile is complete, false otherwise.
155	*/
156	public boolean isProfileComplete() {
157	return userIri != null && keyPair != null && introNps != null;	×
158	}
159
160	/**
161	* Redirects the user to the login page if their profile is incomplete.
162	*
163	* @param path The path to redirect to after login.
164	* @param parameters The page parameters for the redirect.
165	*/
166	public void redirectToLoginIfNeeded(String path, PageParameters parameters) {
167	String loginUrl = getLoginUrl(path, parameters);	×
168	if (loginUrl == null) return;	×
169	throw new RedirectToUrlException(loginUrl);	×
170	}
171
172	/**
173	* Retrieves the login URL for the user.
174	*
175	* @param path The path to redirect to after login.
176	* @param parameters The page parameters for the redirect.
177	* @return The login URL, or null if the user is already logged in.
178	*/
179	public String getLoginUrl(String path, PageParameters parameters) {
180	if (isProfileComplete()) return null;	×
181	if (NanodashPreferences.get().isOrcidLoginMode()) {	×
182	return OrcidLoginPage.getOrcidLoginUrl(path, parameters);	×
183	} else {
184	return ProfilePage.MOUNT_PATH;	×
185	}
186	}
187
188	/**
189	* Retrieves the public key as a Base64-encoded string.
190	*
191	* @return The public key string, or null if the key pair is not set.
192	*/
193	public String getPubkeyString() {
194	if (keyPair == null) return null;	×
195	return DatatypeConverter.printBase64Binary(keyPair.getPublic().getEncoded()).replaceAll("\\s", "");	×
196	}
197
198	/**
199	* Retrieves the public key hash for the user.
200	*
201	* @return The SHA-256 hash of the public key, or null if the public key is not set.
202	*/
203	public String getPubkeyhash() {
204	String pubkey = getPubkeyString();	×
205	if (pubkey == null) return null;	×
206	return Utils.createSha256HexHash(pubkey);	×
207	}
208
209	/**
210	* Checks if the user's public key is approved.
211	*
212	* @return True if the public key is approved, false otherwise.
213	*/
214	public boolean isPubkeyApproved() {
215	if (keyPair == null \|\| userIri == null) return false;	×
216	return User.isApprovedPubkeyhashForUser(getPubkeyhash(), userIri);	×
217	}
218
219	/**
220	* Retrieves the user's key pair.
221	*
222	* @return The key pair.
223	*/
224	public KeyPair getKeyPair() {
225	return keyPair;	×
226	}
227
228	/**
229	* Generates a new key pair for the user.
230	*/
231	public void makeKeys() {
232	try {
233	MakeKeys.make(getKeyFile().getAbsolutePath().replaceFirst("_rsa$", ""), SignatureAlgorithm.RSA);	×
234	keyPair = SignNanopub.loadKey(getKeyFile().getPath(), SignatureAlgorithm.RSA);	×
235	} catch (Exception ex) {	×
236	logger.error("Couldn't create key pair", ex);	×
237	}	×
238	}	×
239
240	/**
241	* Retrieves the user's IRI.
242	*
243	* @return The user's IRI, or null if not set.
244	*/
245	public IRI getUserIri() {
246	return userIri;	9✔
247	}
248
249	/**
250	* Retrieves the user's introduction nanopublications.
251	*
252	* @return A list of user's introduction nanopublications.
253	*/
254	public List<IntroNanopub> getUserIntroNanopubs() {
255	return User.getIntroNanopubs(userIri);	12✔
256	}
257
258	/**
259	* Counts the number of local introduction nanopublications.
260	*
261	* @return The count of local introduction nanopublications.
262	*/
263	public int getLocalIntroCount() {
264	if (localIntroCount == null) {	9!
265	localIntroCount = 0;	12✔
266	for (IntroNanopub inp : getUserIntroNanopubs()) {	21!
267	if (isIntroWithLocalKey(inp)) {	×
268	localIntroCount++;	×
269	localIntro = inp;	×
270	}
271	}	×
272	if (localIntroCount > 1) localIntro = null;	15!
273	}
274	return localIntroCount;	12✔
275	}
276
277	/**
278	* Retrieves the local introduction nanopublication.
279	*
280	* @return The local introduction nanopublication, or null if not found.
281	*/
282	public IntroNanopub getLocalIntro() {
283	getLocalIntroCount();	×
284	return localIntro;	×
285	}
286
287	/**
288	* Checks if the given introduction nanopublication is associated with the local key.
289	*
290	* @param inp The introduction nanopublication.
291	* @return True if associated with the local key, false otherwise.
292	*/
293	public boolean isIntroWithLocalKey(IntroNanopub inp) {
294	IRI location = Utils.getLocation(inp);	×
295	NanopubSignatureElement el = Utils.getNanopubSignatureElement(inp);	×
296	String siteUrl = NanodashPreferences.get().getWebsiteUrl();	×
297	if (location != null && siteUrl != null) {	×
298	String l = location.stringValue();	×
299	// TODO: Solve the name change recognition in a better way:
300	if (!l.equals(siteUrl) && !l.replace("nanobench", "nanodash").equals(siteUrl)) return false;	×
301	}
302	if (!getPubkeyString().equals(el.getPublicKeyString())) return false;	×
303	for (KeyDeclaration kd : inp.getKeyDeclarations()) {	×
304	if (getPubkeyString().equals(kd.getPublicKeyString())) return true;	×
305	}	×
306	return false;	×
307	}
308
309	/**
310	* Sets the user's ORCID identifier.
311	*
312	* @param orcid The ORCID identifier.
313	*/
314	public void setOrcid(String orcid) {
315	if (!orcid.matches(ProfilePage.ORCID_PATTERN)) {	×
316	throw new RuntimeException("Illegal ORCID identifier: " + orcid);	×
317	}
318	if (NanodashPreferences.get().isOrcidLoginMode()) {	×
319	userDir = System.getProperty("user.home") + "/.nanopub/nanodash-users/" + orcid + "/";	×
320	File f = new File(userDir);	×
321	if (!f.exists()) f.mkdir();	×
322	} else {	×
323	try {
324	FileUtils.writeStringToFile(getOrcidFile(), orcid + "\n", StandardCharsets.UTF_8);	×
325	// Files.writeString(orcidFile.toPath(), orcid + "\n");
326	} catch (IOException ex) {	×
327	logger.error("Couldn't write ORCID file", ex);	×
328	}	×
329	}
330	userIri = vf.createIRI("https://orcid.org/" + orcid);	×
331	loadProfileInfo();	×
332	if (httpSession != null) httpSession.setMaxInactiveInterval(24 * 60 * 60); // 24h	×
333	}	×
334
335	/**
336	* Logs out the user and invalidates the session.
337	*/
338	public void logout() {
339	userIri = null;	×
340	invalidateNow();	×
341	}	×
342
343	/**
344	* Retrieves the user's introduction nanopublications as a map.
345	*
346	* @return A map of introduction nanopublications.
347	*/
348	public Map<IRI, IntroNanopub> getIntroNanopubs() {
349	return introNps;	×
350	}
351
352	// public void checkOrcidLink() {
353	// if (isOrcidLinked == null && userIri != null) {
354	// orcidLinkError = "";
355	// introExtractor = null;
356	// try {
357	// introExtractor = IntroNanopub.extract(userIri.stringValue(), null);
358	// if (introExtractor.getIntroNanopub() == null) {
359	// orcidLinkError = "ORCID account is not linked.";
360	// isOrcidLinked = false;
361	// } else {
362	// IntroNanopub inp = IntroNanopub.get(userIri.stringValue(), introExtractor);
363	// if (introNps != null && introNps.containsKey(inp.getNanopub().getUri())) {
364	// // TODO: also check whether introduction contains local key
365	// isOrcidLinked = true;
366	// } else {
367	// isOrcidLinked = false;
368	// orcidLinkError = "Error: ORCID is linked to another introduction nanopublication.";
369	// }
370	// }
371	// } catch (Exception ex) {
372	// logger.error("ORCID check failed");
373	// orcidLinkError = "ORCID check failed.";
374	// }
375	// }
376	// }
377	//
378	// public void resetOrcidLinked() {
379	// isOrcidLinked = null;
380	// }
381	//
382	// public boolean isOrcidLinked() {
383	// checkOrcidLink();
384	// return isOrcidLinked != null && isOrcidLinked == true;
385	// }
386	//
387	// public String getOrcidLinkError() {
388	// return orcidLinkError;
389	// }
390	//
391	// public String getOrcidName() {
392	// if (introExtractor == null \|\| introExtractor.getName() == null) return null;
393	// if (introExtractor.getName().trim().isEmpty()) return null;
394	// return introExtractor.getName();
395	// }
396
397	/**
398	* Retrieves the file for storing the user's ORCID identifier.
399	*
400	* @return The ORCID file.
401	*/
402	private File getOrcidFile() {
403	return new File(userDir + "orcid");	21✔
404	}
405
406	/**
407	* Retrieves the file for storing the user's private key.
408	*
409	* @return The key file.
410	*/
411	public File getKeyFile() {
412	return new File(userDir + "id_rsa");	×
413	}
414
415	/**
416	* Sets the time when the introduction was last published.
417	*/
418	public void setIntroPublishedNow() {
419	lastTimeIntroPublished = new Date();	×
420	}	×
421
422	/**
423	* Checks if the introduction has been published.
424	*
425	* @return True if the introduction has been published, false otherwise.
426	*/
427	public boolean hasIntroPublished() {
428	return lastTimeIntroPublished != null;	×
429	}
430
431	/**
432	* Calculates the time since the last introduction was published.
433	*
434	* @return The time in milliseconds since the last introduction was published, or Long.MAX_VALUE if it has never been published.
435	*/
436	public long getTimeSinceLastIntroPublished() {
437	if (lastTimeIntroPublished == null) return Long.MAX_VALUE;	15!
438	return new Date().getTime() - lastTimeIntroPublished.getTime();	×
439	}
440
441	/**
442	* Sets the view mode for displaying nanopublication results.
443	*
444	* @param viewMode The desired view mode (e.g., GRID or LIST).
445	*/
446	public void setNanopubResultsViewMode(NanopubResults.ViewMode viewMode) {
447	this.nanopubResultsViewMode = viewMode;	×
448	}	×
449
450	/**
451	* Retrieves the current view mode for displaying nanopublication results.
452	*
453	* @return The current view mode.
454	*/
455	public NanopubResults.ViewMode getNanopubResultsViewMode() {
456	return this.nanopubResultsViewMode;	×
457	}
458
459	/**
460	* Whether the docked Claude chat panel is expanded on this session's pages.
461	*
462	* @return true if expanded
463	*/
464	public boolean isClaudeChatDockExpanded() {
465	return claudeChatDockExpanded;	×
466	}
467
468	/**
469	* Set whether the docked Claude chat panel is expanded.
470	*
471	* @param claudeChatDockExpanded true to expand
472	*/
473	public void setClaudeChatDockExpanded(boolean claudeChatDockExpanded) {
474	this.claudeChatDockExpanded = claudeChatDockExpanded;	×
475	}	×
476
477	// --- Preview nanopub support ---
478
479	public static class PreviewNanopub implements Serializable {
480	private final Nanopub nanopub;
481	private final PageParameters pageParams;
482	private final Class<? extends WebPage> confirmPageClass;
483	private final boolean consentChecked;
484	private final PageReference sourcePageRef;
485
486	public PreviewNanopub(Nanopub nanopub, PageParameters pageParams, Class<? extends WebPage> confirmPageClass, boolean consentChecked, PageReference sourcePageRef) {	×
487	this.nanopub = nanopub;	×
488	this.pageParams = pageParams;	×
489	this.confirmPageClass = confirmPageClass;	×
490	this.consentChecked = consentChecked;	×
491	this.sourcePageRef = sourcePageRef;	×
492	}	×
493
494	public Nanopub getNanopub() { return nanopub; }	×
495	public PageParameters getPageParams() { return pageParams; }	×
496	public Class<? extends WebPage> getConfirmPageClass() { return confirmPageClass; }	×
497	public boolean isConsentChecked() { return consentChecked; }	×
498	public PageReference getSourcePageRef() { return sourcePageRef; }	×
499	}
500
501	private ConcurrentMap<String, PreviewNanopub> previewMap = new ConcurrentHashMap<>();	15✔
502
503	public void setPreviewNanopub(String id, PreviewNanopub preview) {
504	previewMap.put(id, preview);	×
505	}	×
506
507	public PreviewNanopub getPreviewNanopub(String id) {
508	return previewMap.get(id);	×
509	}
510
511	public PreviewNanopub removePreviewNanopub(String id) {
512	return previewMap.remove(id);	×
513	}
514
515	}

knowledgepixels / nanodash / 29344362295

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