39389438900

Committed 20 Oct 2026 07:52AM UTC coverage: 54.03% (-0.06%) from 54.087%

Build # 39389438900

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #803 from knowledgepixels/perf/slow-tests

build(test): run the tests in four JVMs

Coverage Stats

6185 of 12294 branches covered (50.31%)

Branch coverage included in aggregate %.

10910 of 19346 relevant lines covered (56.39%)

9.28 hits per line

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

36.18

src/main/java/com/knowledgepixels/nanodash/domain/UserData.java

package com.knowledgepixels.nanodash.domain;

import com.knowledgepixels.nanodash.*;
import org.eclipse.rdf4j.common.exception.RDF4JException;
import org.eclipse.rdf4j.model.IRI;
import org.eclipse.rdf4j.model.ValueFactory;
import org.eclipse.rdf4j.model.impl.SimpleValueFactory;
import org.eclipse.rdf4j.model.util.Values;
import org.nanopub.MalformedNanopubException;
import org.nanopub.Nanopub;
import org.nanopub.SimpleTimestampPattern;
import org.nanopub.extra.security.MalformedCryptoElementException;
import org.nanopub.extra.security.NanopubSignatureElement;
import org.nanopub.extra.security.SignatureUtils;
import org.nanopub.extra.server.GetNanopub;
import org.nanopub.extra.services.ApiResponse;
import org.nanopub.extra.services.ApiResponseEntry;
import org.nanopub.extra.services.QueryRef;
import org.nanopub.extra.setting.IntroNanopub;
import org.nanopub.extra.setting.NanopubSetting;
import org.nanopub.vocabulary.NPX;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

/**
 * UserData class manages user-related data.
 */
public class UserData implements Serializable {

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

    private HashMap<IRI, Set<String>> approvedIdPubkeyhashMap = new HashMap<>();
    private HashMap<String, Set<IRI>> approvedPubkeyhashIdMap = new HashMap<>();
    private HashMap<String, Set<IRI>> approvedPubkeyhashLocationMap = new HashMap<>();
    private HashMap<IRI, Set<String>> unapprovedIdPubkeyhashMap = new HashMap<>();
    private HashMap<String, Set<IRI>> unapprovedPubkeyhashIdMap = new HashMap<>();
    private HashMap<String, Set<IRI>> unapprovedPubkeyhashLocationMap = new HashMap<>();
    private HashMap<IRI, Boolean> softwareIdMap = new HashMap<>();
    private HashMap<String, Set<IRI>> pubkeyhashIntroMap = new HashMap<>();
    private HashMap<IRI, IntroNanopub> introMap = new HashMap<>();
    private Set<IRI> approvedIntros = new HashSet<>();
    private HashMap<IRI, String> idNameMap = new HashMap<>();
    private HashMap<IRI, List<IntroNanopub>> introNanopubLists = new HashMap<>();
    private final HashMap<IRI, ProfilePicture> profilePictures = new HashMap<>();
    private final HashMap<IRI, IRI> defaultLicense = new HashMap<>();

    private boolean complete = true;

    /**
     * Constructor for UserData.
     * Initializes the user data by fetching nanopublications settings.
     *
     * @param forced whether the user-detail queries must be re-fetched from the API even
     *               when a cached response exists. The periodic refresh passes true so each
     *               cycle actually brings the data current; the initial load passes false so
     *               it can build from cached responses right away — in particular from the
     *               persisted snapshot after a restart (issue #570), where forced fetches
     *               would stall the first request on the network.
     */
    UserData(boolean forced) {
        final NanodashPreferences pref = NanodashPreferences.get();

        // TODO Make nanopublication setting configurable:
        NanopubSetting setting = null;
        if (pref.getSettingUri() != null) {
            try {
                setting = new NanopubSetting(GetNanopub.get(pref.getSettingUri(), Utils.getRegistryHttpClient()));
            } catch (Exception ex) {
                // Retrieving it goes to the registry, which a cold instance may not be able to
                // reach (issue #684); the local setting stands in until it answers.
                logger.warn("Could not retrieve the configured nanopublication setting {}: {}", pref.getSettingUri(), ex.toString());
                complete = false;
            }
        }
        if (setting == null) {
            // No fallback beyond this one, and its failure is a misconfiguration rather than a
            // service that cannot answer, so it stays fatal.
            try {
                setting = NanopubSetting.getLocalSetting();
            } catch (RDF4JException | MalformedNanopubException | IOException ex) {
                throw new RuntimeException(ex);
            }
        }
        String settingId = setting.getNanopub().getUri().stringValue();
        try {
            if (setting.getUpdateStrategy().equals(NPX.UPDATES_BY_CREATOR)) {
                settingId = QueryApiAccess.getLatestVersionId(settingId);
                setting = new NanopubSetting(GetNanopub.get(settingId, Utils.getRegistryHttpClient()));
            }
            logger.info("Using nanopublication setting: {}", settingId);
        } catch (Exception ex) {
            // Resolving the latest version goes to the query service and the registry, so it
            // fails on a cold instance whose services are unavailable. The setting itself is
            // not read below, so the local one carries us until the services answer.
            logger.warn("Could not resolve the latest version of the nanopublication setting {}: {}", settingId, ex.toString());
            complete = false;
        }

//                // Get users that are listed directly in the authority index, and consider them approved:
//                ByteArrayOutputStream out = new ByteArrayOutputStream(); // TODO use piped out-in stream here
//                new FetchIndex(setting.getAgentIntroCollection().stringValue(), out, RDFFormat.TRIG, false, true, null).run();
//                InputStream in = new ByteArrayInputStream(out.toByteArray());
//                try {
//                        MultiNanopubRdfHandler.process(RDFFormat.TRIG, in, new MultiNanopubRdfHandler.NanopubHandler() {
//                                @Override
//                                public void handleNanopub(Nanopub np) {
//                                        // TODO: Check that latest version talks about same user
//                                        register(QueryApiAccess.getLatestVersionId(np.getUri().stringValue()), true);
//                                }
//                        });
//                } catch (RDFParseException | RDFHandlerException | IOException | MalformedNanopubException ex) {
//                        logger.error();
//                }
///
//                if (setting.getTrustRangeAlgorithm().equals(NPX.TRANSITIVE_TRUST)) {
//                        ApiResponse resp = QueryApiAccess.forcedGet("get-approved-nanopubs");
//                        List<ApiResponseEntry> results = new ArrayList<>(resp.getData());
//                        while (true) {
//                                boolean keepLooping = false;
//                                for (ApiResponseEntry entry : new ArrayList<>(results)) {
//                                        if (hasValue(approvedPubkeyIdMap, entry.get("pubkey"), Utils.vf.createIRI(entry.get("approver")))) {
//                                                register(entry.get("approved_np"), true);
//                                                results.remove(entry);
//                                                keepLooping = true;
//                                        }
//                                }
//                                if (!keepLooping) break;
//                        }
//                }

        logger.info("Loading approved users...");
        try {
            for (RegistryAccountInfo rai : RegistryAccountInfo.fromUrl(Utils.getMainRegistryUrl() + "list.json")) {
                registerApproved(rai);
            }
        } catch (Exception ex) {
            logger.error("Could not load the approved users from the registry: {}", ex.toString());
            complete = false;
        }

        logger.info("Loading user details...");
        // Get latest introductions for all users, including unapproved ones:
        for (ApiResponseEntry entry : entriesOf(QueryApiAccess.GET_ALL_USER_INTROS, forced)) {
            register(entry);
        }

        for (ApiResponseEntry entry : entriesOf(QueryApiAccess.GET_ALL_USER_PROFILE_PICS, forced)) {
            // The value can be a link or SVG markup (issue #634), and nothing stops a user
            // from declaring something unusable as either — hence the null check rather
            // than a bare parse, which would abort the whole user-data load.
            ProfilePicture picture = ProfilePicture.of(entry.get("imageUrl"));
            if (picture != null) profilePictures.put(Values.iri(entry.get("user")), picture);
        }

        for (ApiResponseEntry entry : entriesOf(QueryApiAccess.GET_ALL_USER_DEFAULT_LICENSE, forced)) {
            defaultLicense.put(Values.iri(entry.get("user")), Values.iri(entry.get("license")));
        }
    }

    /**
     * The entries of one of the user-detail queries, or none when the query service cannot
     * answer, in which case the data is marked as {@link #isComplete() not complete}.
     * <p>
     * Nothing here is worth failing the whole load for. A cold instance whose query service is
     * unavailable could not build user data at all, and since session construction needs it,
     * that left the instance unable to serve any page, its own error page included (issue
     * #684). What it can build is partial data — whoever the registry says is approved, and
     * no introductions — which is a serviceable state to render from and is replaced as soon
     * as the service answers.
     */
    private List<ApiResponseEntry> entriesOf(String queryId, boolean forced) {
        try {
            ApiResponse response = ApiCache.retrieveResponseSync(new QueryRef(queryId), forced);
            if (response != null) return response.getData();
            logger.warn("No response yet for {}; user data stays incomplete", queryId);
        } catch (Exception ex) {
            logger.error("Could not load {}: {}", queryId, ex.toString());
        }
        complete = false;
        return Collections.emptyList();
    }

    /**
     * Whether this user data could be built in full. It cannot when a service it is built from
     * is unavailable (issue #684): what is here is then only as much as the services that did
     * answer could tell, and the data is meant to be replaced by a complete load rather than
     * kept for the usual refresh interval.
     *
     * @return true if every source answered
     */
    public boolean isComplete() {
        return complete;
    }

    private IntroNanopub toIntroNanopub(IRI iri) {
        if (iri == null) return null;
        if (introMap.containsKey(iri)) return introMap.get(iri);
        Nanopub np = Utils.getNanopub(iri.stringValue());
        if (np == null) return null;
        IntroNanopub introNp = new IntroNanopub(np);
        introMap.put(np.getUri(), introNp);
        return introNp;
    }

    private void registerApproved(RegistryAccountInfo rai) {
        if (rai.getAgent().equals("$")) return;
        addValue(approvedIdPubkeyhashMap, rai.getAgentIri(), rai.getPubkey());
        addValue(approvedPubkeyhashIdMap, rai.getPubkey(), rai.getAgentIri());
    }

    private void register(ApiResponseEntry entry) {
        IRI userIri;
        try {
            userIri = vf.createIRI(entry.get("user"));
        } catch (IllegalArgumentException ex) {
            logger.error("Error creating IRI from user string: {}", entry.get("user"), ex);
            return;
        }
        String pubkeyhash = entry.get("pubkeyHash");
        boolean approved = approvedIdPubkeyhashMap.containsKey(userIri) && approvedIdPubkeyhashMap.get(userIri).contains(pubkeyhash);
        boolean authoritative = "true".equals(entry.get("authoritative"));
        IRI introNpIri = null;
        try {
            introNpIri = vf.createIRI(entry.get("intronp"));
        } catch (IllegalArgumentException ex) {
            logger.error("Error creating IRI from intronp string: {}", entry.get("intronp"), ex);
        }
        IRI keyLocation = null;
        try {
            if (!entry.get("keyLocation").isEmpty()) {
                keyLocation = vf.createIRI(entry.get("keyLocation"));
            }
        } catch (IllegalArgumentException ex) {
            logger.error("Error creating IRI from keyLocation string: {}", entry.get("keyLocation"), ex);
        }
        if (approved) {
            if (authoritative) {
                if (introNpIri != null) approvedIntros.add(introNpIri);
                if (keyLocation != null) addValue(approvedPubkeyhashLocationMap, pubkeyhash, keyLocation);
            }
        } else {
            addValue(unapprovedIdPubkeyhashMap, userIri, entry.get("pubkeyHash"));
            addValue(unapprovedPubkeyhashIdMap, entry.get("pubkeyHash"), userIri);
            if (keyLocation != null) addValue(unapprovedPubkeyhashLocationMap, pubkeyhash, keyLocation);
        }
        if (introNpIri != null) {
            addValue(pubkeyhashIntroMap, entry.get("pubkeyHash"), introNpIri);
        }
        String name = entry.get("name");
        if (!name.isEmpty() && !idNameMap.containsKey(userIri)) {
            idNameMap.put(userIri, name);
        }
        if ("true".equals(entry.get("isSoftware"))) {
            softwareIdMap.put(userIri, true);
        }


    }

/*
    private void register(String npId, boolean approved) {
        if (!TrustyUriUtils.isPotentialTrustyUri(npId)) return;
        IntroNanopub introNp = toIntroNanopub(npId);
        if (introNp == null) {
            //logger.error("No latest version of introduction found");
            return;
        }
        if (introNp.getUser() == null) {
            //logger.error("No identifier found in introduction");
            return;
        }
        if (introNp.getKeyDeclarations().isEmpty()) {
            //logger.error("No key declarations found in introduction");
            return;
        }
        if (approved) {
            approvedIntroMap.put(introNp.getNanopub().getUri(), introNp);
        }
        String userId = introNp.getUser().stringValue();
        IRI userIri = Utils.vf.createIRI(userId);
        if (userId.startsWith("https://orcid.org/")) {
            // Some simple ORCID ID wellformedness check:
            if (!userId.matches("https://orcid.org/[0-9]{4}-[0-9]{4}-[0-9]{4}-[0-9]{3}[0-9X]")) return;
        }
        for (KeyDeclaration kd : introNp.getKeyDeclarations()) {
            String pubkey = kd.getPublicKeyString();
            IRI keyLocation = kd.getKeyLocation();
            if (approved) {
                addValue(approvedIdPubkeyMap, userIri, pubkey);
                addValue(approvedPubkeyIdMap, pubkey, userIri);
                if (keyLocation != null) addValue(approvedPubkeyLocationMap, pubkey, keyLocation);
            } else {
                if (!hasValue(approvedIdPubkeyMap, userIri, pubkey)) {
                    addValue(unapprovedIdPubkeyMap, userIri, pubkey);
                    addValue(unapprovedPubkeyIdMap, pubkey, userIri);
                    if (keyLocation != null) addValue(unapprovedPubkeyLocationMap, pubkey, keyLocation);
                }
                addValue(pubkeyIntroMap, pubkey, introNp.getNanopub().getUri());
            }
        }
        if (!idNameMap.containsKey(userIri)) {
            idNameMap.put(userIri, introNp.getName());
        }
    }
    */

    private void addValue(Map<IRI, Set<String>> map, IRI key, String value) {
        Set<String> values = map.get(key);
        if (values == null) {
            values = new HashSet<>();
            map.put(key, values);
        }
        values.add(value);
    }

    private void addValue(Map<String, Set<IRI>> map, String key, IRI value) {
        Set<IRI> values = map.get(key);
        if (values == null) {
            values = new HashSet<>();
            map.put(key, values);
        }
        values.add(value);
    }

    private boolean hasValue(Map<IRI, Set<String>> map, IRI key, String value) {
        Set<String> values = map.get(key);
        if (values == null) return false;
        return values.contains(value);
    }

//        private static boolean hasValue(Map<String,Set<IRI>> map, String key, IRI value) {
//                Set<IRI> values = map.get(key);
//                if (values == null) return false;
//                return values.contains(value);
//        }

    /**
     * Checks if the given IRI is a user identifier.
     *
     * @param userIri the IRI to check
     * @return true if the IRI is a user identifier, false otherwise
     */
    public boolean isUser(IRI userIri) {
        return approvedIdPubkeyhashMap.containsKey(userIri) || unapprovedIdPubkeyhashMap.containsKey(userIri);
    }

    /**
     * Checks if the given IRI is a software identifier.
     *
     * @param userIri the IRI to check
     * @return true if the IRI is a software identifier, false otherwise
     */
    public boolean isSoftware(IRI userIri) {
        return softwareIdMap.containsKey(userIri) && softwareIdMap.get(userIri);
    }

    /**
     * Checks if the given userId is a valid user identifier.
     *
     * @param userId the user identifier to check, must start with "https://" or "http://"
     * @return true if the userId is a valid user identifier, false otherwise
     */
    public boolean isUser(String userId) {
        if (!userId.startsWith("https://") && !userId.startsWith("http://")) {
            return false;
        }
        try {
            IRI userIri = Utils.vf.createIRI(userId);
            return isUser(userIri);
        } catch (IllegalArgumentException ex) {
            return false;
        }
    }

    /**
     * Checks if the given public key is approved for the specified user.
     *
     * @param pubkeyHash the public key to check
     * @param user       the IRI of the user to check against
     * @return true if the key is approved for the user, false otherwise
     */
    public boolean isApprovedPubkeyHashForUser(String pubkeyHash, IRI user) {
        return hasValue(approvedIdPubkeyhashMap, user, pubkeyHash);
    }

    private String getShortName(IRI userIri) {
        if (userIri == null) return "(unknown)";
        String n = userIri.stringValue();
        n = n.replaceFirst("^https://orcid.org/", "");
        if (n.length() > 40) return n.substring(0, 30) + "...";
        return n;
    }

    /**
     * Retrieves the IRI of a user based on their public key.
     *
     * @param pubkeyHash   the public key of the user
     * @param approvedOnly if true, only approved users are considered; if false, unapproved users are also considered
     * @return the IRI of the user if found, or null if not found
     */
    public IRI getUserIriForPubkeyHash(String pubkeyHash, boolean approvedOnly) {
        Set<IRI> userIris = approvedPubkeyhashIdMap.get(pubkeyHash);
        if (userIris != null && userIris.size() == 1) return userIris.iterator().next();
        if (!approvedOnly) {
            userIris = unapprovedPubkeyhashIdMap.get(pubkeyHash);
            if (userIris != null && userIris.size() == 1) return userIris.iterator().next();
        }
        return null;
    }

    /**
     * Retrieves the IRI of the owner of a nanopublication's signature.
     *
     * @param np the nanopublication
     * @return the IRI of the signature owner if found, or null if not found or if an error occurs
     */
    public IRI getSignatureOwnerIri(Nanopub np) {
        try {
            if (np != null) {
                NanopubSignatureElement se = SignatureUtils.getSignatureElement(np);
                if (se != null) {
                    String pubkeyHash = Utils.createSha256HexHash(se.getPublicKeyString());
                    return getUserIriForPubkeyHash(pubkeyHash, true);
                }
            }
        } catch (MalformedCryptoElementException ex) {
            logger.error("Error getting signature element", ex);
        }
        return null;
    }

    /**
     * Retrieves the name of a user based on their IRI.
     *
     * @param userIri the IRI of the user
     * @return the name of the user if found, or null if not found
     */
    public String getName(IRI userIri) {
        return idNameMap.get(userIri);
    }

    /**
     * Retrieves the display name of a user based on their IRI.
     *
     * @param userIri the IRI of the user
     * @return the display name of the user, which includes their name and short name
     */
    public String getDisplayName(IRI userIri) {
        String name = getName(userIri);
        if (name != null && !name.isEmpty()) {
            return name + " (" + getShortName(userIri) + ")";
        }
        return getShortName(userIri);
    }

    /**
     * Retrieves a short display name for a user based on their IRI.
     *
     * @param userIri the IRI of the user
     * @return the short display name of the user, which is either their name or their short name
     */
    public String getShortDisplayName(IRI userIri) {
        String name = getName(userIri);
        if (name != null && !name.isEmpty()) {
            return name;
        }
        return getShortName(userIri);
    }

    /**
     * Retrieves a short display name for a user based on their IRI and public key.
     *
     * @param userIri    the IRI of the user
     * @param pubkeyHash the public key of the user
     * @return the short display name of the user, which may include a contested identity note if multiple identities are associated with the public key
     */
    public String getShortDisplayNameForPubkeyHash(IRI userIri, String pubkeyHash) {
        Set<IRI> ids = approvedPubkeyhashIdMap.get(pubkeyHash);
        if (ids == null || ids.isEmpty()) {
            ids = unapprovedPubkeyhashIdMap.get(pubkeyHash);
            if (ids == null || ids.isEmpty()) {
                return getShortDisplayName(userIri);
            } else if (ids.size() == 1) {
                return getShortDisplayName(ids.iterator().next());
            } else {
                // Not showing "contested identity" for now.
                return getShortDisplayName(userIri);  // + " (contested identity)";
            }
        } else if (ids.size() == 1) {
            return getShortDisplayName(ids.iterator().next());
        } else {
            // Not showing "contested identity" for now.
            //return "(contested identity)";
            return getShortDisplayName(ids.iterator().next());
        }
    }

    /**
     * Finds a single user ID for a given public key.
     *
     * @param pubkeyHash the public key to search for
     * @return the IRI of the user if exactly one ID is found for the public key, or null if no ID or multiple IDs are found
     */
    public IRI findSingleIdForPubkeyHash(String pubkeyHash) {
        if (approvedPubkeyhashIdMap.containsKey(pubkeyHash) && !approvedPubkeyhashIdMap.get(pubkeyHash).isEmpty()) {
            if (approvedPubkeyhashIdMap.get(pubkeyHash).size() == 1) {
                return approvedPubkeyhashIdMap.get(pubkeyHash).iterator().next();
            } else {
                return null;
            }
        }
        if (unapprovedPubkeyhashIdMap.containsKey(pubkeyHash) && !unapprovedPubkeyhashIdMap.get(pubkeyHash).isEmpty()) {
            if (unapprovedPubkeyhashIdMap.get(pubkeyHash).size() == 1) {
                return unapprovedPubkeyhashIdMap.get(pubkeyHash).iterator().next();
            } else {
                return null;
            }
        }
        return null;
    }

    /**
     * Comparator for sorting users by their display names in a case-insensitive manner.
     */
    public final transient Comparator<IRI> userComparator = (iri1, iri2) -> {
        String name1 = getName(iri1);
        String name2 = getName(iri2);
        boolean hasName1 = name1 != null && !name1.isEmpty();
        boolean hasName2 = name2 != null && !name2.isEmpty();
        if (hasName1 != hasName2) {
            return hasName1 ? -1 : 1;
        }
        return getDisplayName(iri1).toLowerCase().compareTo(getDisplayName(iri2).toLowerCase());
    };

    /**
     * Retrieves a list of users, either approved or unapproved.
     *
     * @param approved if true, retrieves approved users; if false, retrieves unapproved users
     * @return a sorted list of user IRIs
     */
    public List<IRI> getUsers(boolean approved) {
        List<IRI> list;
        if (approved) {
            list = new ArrayList<IRI>(approvedIdPubkeyhashMap.keySet());
        } else {
            list = new ArrayList<IRI>();
            for (IRI u : unapprovedIdPubkeyhashMap.keySet()) {
                if (!approvedIdPubkeyhashMap.containsKey(u)) list.add(u);
            }
        }
        // TODO Cache the sorted list to not sort from scratch each time:
        list.sort(userComparator);
        return list;
    }

    /**
     * Retrieves a list of public keys for a given user.
     *
     * @param user     the IRI of the user whose public keys are to be retrieved
     * @param approved if true, retrieves approved public keys; if false, retrieves unapproved public keys
     * @return a list of public keys associated with the user, either approved or unapproved
     */
    public List<String> getPubkeyHashes(IRI user, Boolean approved) {
        List<String> pubkeys = new ArrayList<>();
        if (user != null) {
            if (approved == null || approved) {
                if (approvedIdPubkeyhashMap.containsKey(user)) pubkeys.addAll(approvedIdPubkeyhashMap.get(user));
            }
            if (approved == null || !approved) {
                if (unapprovedIdPubkeyhashMap.containsKey(user)) pubkeys.addAll(unapprovedIdPubkeyhashMap.get(user));
            }
        }
        return pubkeys;
    }

    /**
     * Retrieves a list of introduction nanopublications for a given user.
     *
     * @param user the IRI of the user whose introduction nanopublications are to be retrieved
     * @return a list of introduction nanopublications associated with the user, sorted by creation time
     */
    public List<IntroNanopub> getIntroNanopubs(IRI user) {
        if (introNanopubLists.containsKey(user)) return introNanopubLists.get(user);

        Map<IRI, IntroNanopub> introNps = new HashMap<>();
        if (approvedIdPubkeyhashMap.containsKey(user)) {
            for (String pk : approvedIdPubkeyhashMap.get(user)) {
                getIntroNanopubs(pk, introNps);
            }
        }
        if (unapprovedIdPubkeyhashMap.containsKey(user)) {
            for (String pk : unapprovedIdPubkeyhashMap.get(user)) {
                getIntroNanopubs(pk, introNps);
            }
        }
        List<IntroNanopub> list = new ArrayList<>(introNps.values());
        list.sort((i0, i1) -> {
            Calendar c0 = SimpleTimestampPattern.getCreationTime(i0.getNanopub());
            Calendar c1 = SimpleTimestampPattern.getCreationTime(i1.getNanopub());
            if (c0 == null && c1 == null) return 0;
            if (c0 == null) return 1;
            if (c1 == null) return -1;
            return -c0.compareTo(c1);
        });
        introNanopubLists.put(user, list);
        return list;
    }

    /**
     * Retrieves a map of introduction nanopublications for a given public key.
     *
     * @param pubkey the public key for which introduction nanopublications are to be retrieved
     * @return a map where the keys are IRI identifiers of introduction nanopublications and the values are the corresponding IntroNanopub objects
     */
    public Map<IRI, IntroNanopub> getIntroNanopubs(String pubkey) {
        Map<IRI, IntroNanopub> introNps = new HashMap<>();
        getIntroNanopubs(pubkey, introNps);
        return introNps;
    }

    private void getIntroNanopubs(String pubkeyhash, Map<IRI, IntroNanopub> introNps) {
        if (pubkeyhashIntroMap.containsKey(pubkeyhash)) {
            for (IRI iri : pubkeyhashIntroMap.get(pubkeyhash)) {
                IntroNanopub introNp = toIntroNanopub(iri);
                if (introNp != null) {
                    introNps.put(iri, introNp);
                }
            }
        }
    }

    /**
     * Checks if the given introduction nanopublication is approved.
     *
     * @param in the introduction nanopublication to check
     * @return true if the introduction nanopublication is approved, false otherwise
     */
    public boolean isApproved(IntroNanopub in) {
        return approvedIntros.contains(in.getNanopub().getUri());
    }

    /**
     * Retrieves the location of a public key.
     *
     * @param pubkeyHash the public key for which the location is to be retrieved
     * @return the IRI of the key location if found, or null if not found or if multiple locations are associated with the key
     */
    public IRI getKeyLocationForPubkeyHash(String pubkeyHash) {
        if (approvedPubkeyhashLocationMap.containsKey(pubkeyHash) && !approvedPubkeyhashLocationMap.get(pubkeyHash).isEmpty()) {
            if (approvedPubkeyhashLocationMap.get(pubkeyHash).size() == 1)
                return approvedPubkeyhashLocationMap.get(pubkeyHash).iterator().next();
            return null;
        }
        if (unapprovedPubkeyhashLocationMap.containsKey(pubkeyHash) && unapprovedPubkeyhashLocationMap.get(pubkeyHash).size() == 1) {
            return unapprovedPubkeyhashLocationMap.get(pubkeyHash).iterator().next();
        }
        return null;
    }

    /**
     * Retrieves the profile picture IRI for a user based on their IRI. Users declare their
     * own picture, and the underlying query accepts any signer, so this is for user IRIs
     * only: spaces and maintained resources go through the admin-gated per-resource query
     * instead (issue #632, see
     * {@link com.knowledgepixels.nanodash.domain.AbstractResourceWithProfile#getProfilePicture()}).
     *
     * @param userIri the IRI of the user for whom to retrieve the profile picture
     * @return the IRI of the user's profile picture if found, or null if not found
     */
    public ProfilePicture getProfilePicture(IRI userIri) {
        return profilePictures.get(userIri);
    }

    /**
     * Retrieves the default license IRI for a user based on their IRI.
     *
     * @param userIri the IRI of the user for whom to retrieve the default license
     * @return the IRI of the user's default license if found, or null if not found
     */
    public IRI getDefaultLicense(IRI userIri) {
        return defaultLicense.get(userIri);
    }

}

knowledgepixels / nanodash / 39389438900

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