17666649186

Committed 12 Sep 2025 06:35AM UTC coverage: 13.717% (-0.06%) from 13.781%

Build # 17666649186

Build Type

push

github

Committed by

tkuhn

Commit Message

feat: Unify owner and member lists; minor style refactoring

Run Details

432 of 3976 branches covered (10.87%)

Branch coverage included in aggregate %.

1105 of 7229 relevant lines covered (15.29%)

0.68 hits per line

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

0.0

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

package com.knowledgepixels.nanodash;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

import org.eclipse.rdf4j.model.IRI;
import org.eclipse.rdf4j.model.Literal;
import org.eclipse.rdf4j.model.Statement;
import org.eclipse.rdf4j.model.vocabulary.DCTERMS;
import org.nanopub.Nanopub;
import org.nanopub.extra.services.ApiResponse;
import org.nanopub.extra.services.ApiResponseEntry;
import org.nanopub.vocabulary.NTEMPLATE;

import com.knowledgepixels.nanodash.template.Template;
import com.knowledgepixels.nanodash.template.TemplateData;

/**
 * Class representing a Nanodash project.
 */
public class Project implements Serializable {

    private static List<Project> projectList = null;
    private static ConcurrentMap<String,Project> projectsByCoreInfo = new ConcurrentHashMap<>();
    private static ConcurrentMap<String,Project> projectsById = new ConcurrentHashMap<>();

    public static synchronized void refresh(ApiResponse resp) {
        projectList = new ArrayList<>();
        ConcurrentMap<String,Project> prevProjectsByCoreInfoPrev = projectsByCoreInfo;
        projectsByCoreInfo = new ConcurrentHashMap<>();
        projectsById.clear();
        for (ApiResponseEntry entry : resp.getData()) {
            Project project = new Project(entry.get("project"), entry.get("label"), entry.get("np"));
            Project prevProject = prevProjectsByCoreInfoPrev.get(project.getCoreInfoString());
            if (prevProject != null) project = prevProject;
            projectList.add(project);
            projectsByCoreInfo.put(project.getCoreInfoString(), project);
            projectsById.put(project.getId(), project);
        }
    }

    public static void ensureLoaded() {
        if (projectList == null) {
            refresh(QueryApiAccess.forcedGet("get-projects"));
        }
    }

    public static List<Project> getProjectList() {
        ensureLoaded();
        return projectList;
    }

    public static Project get(String id) {
        ensureLoaded();
        return projectsById.get(id);
    }

    public static void refresh() {
        ensureLoaded();
        for (Project project : projectList) {
            project.dataNeedsUpdate = true;
        }
    }

    private String id, label, rootNanopubId;
    private Nanopub rootNanopub = null;

    private String description = null;
    private List<IRI> owners = new ArrayList<>();
    private List<IRI> members = new ArrayList<>();
    private ConcurrentMap<String,IRI> ownerPubkeyMap = new ConcurrentHashMap<>();
    private List<Template> templates = new ArrayList<>();
    private Set<String> templateTags = new HashSet<>();
    private ConcurrentMap<String, List<Template>> templatesPerTag = new ConcurrentHashMap<>();
    private List<IRI> queryIds = new ArrayList<>();
    private IRI defaultProvenance = null;

    private boolean dataInitialized = false;
    private boolean dataNeedsUpdate = true;

    private Project(String id, String label, String rootNanopubId) {
        this.id = id;
        this.label = label;
        this.rootNanopubId = rootNanopubId;
        this.rootNanopub = Utils.getAsNanopub(rootNanopubId);

        for (Statement st : rootNanopub.getAssertion()) {
            if (st.getSubject().stringValue().equals(getId())) {
                if (st.getPredicate().equals(DCTERMS.DESCRIPTION)) {
                    description = st.getObject().stringValue();
                } else if (st.getPredicate().equals(Space.HAS_OWNER) && st.getObject() instanceof IRI obj) {
                    addOwner(obj);
                } else if (st.getPredicate().equals(Space.HAS_PINNED_TEMPLATE) && st.getObject() instanceof IRI obj) {
                    templates.add(TemplateData.get().getTemplate(obj.stringValue()));
                } else if (st.getPredicate().equals(Space.HAS_PINNED_QUERY) && st.getObject() instanceof IRI obj) {
                    queryIds.add(obj);
                } else if (st.getPredicate().equals(NTEMPLATE.HAS_DEFAULT_PROVENANCE) && st.getObject() instanceof IRI obj) {
                    defaultProvenance = obj;
                }
            } else if (st.getPredicate().equals(NTEMPLATE.HAS_TAG) && st.getObject() instanceof Literal l) {
                templateTags.add(l.stringValue());
                List<Template> list = templatesPerTag.get(l.stringValue());
                if (list == null) {
                    list = new ArrayList<>();
                    templatesPerTag.put(l.stringValue(), list);
                }
                list.add(TemplateData.get().getTemplate(st.getSubject().stringValue()));
            }
        }

    }

    private void addOwner(IRI owner) {
        // TODO This isn't efficient for long owner lists:
        if (owners.contains(owner)) return;
        owners.add(owner);
        UserData ud = User.getUserData();
        for (String pubkeyhash : ud.getPubkeyhashes(owner, true)) {
            ownerPubkeyMap.put(pubkeyhash, owner);
        }
    }

    public String getId() {
        return id;
    }

    public String getRootNanopubId() {
        return rootNanopubId;
    }

    public String getCoreInfoString() {
        return id + " " + rootNanopubId;
    }

    public Nanopub getRootNanopub() {
        return rootNanopub;
    }

    public String getLabel() {
        return label;
    }

    public String getDescription() {
        return description;
    }

    public boolean isDataInitialized() {
        triggerDataUpdate();
        return dataInitialized;
    }

    public List<IRI> getOwners() {
        triggerDataUpdate();
        return owners;
    }

    public List<IRI> getMembers() {
        triggerDataUpdate();
        return members;
    }

    public List<Template> getTemplates() {
        return templates;
    }

    public Set<String> getTemplateTags() {
        return templateTags;
    }

    public ConcurrentMap<String, List<Template>> getTemplatesPerTag() {
        return templatesPerTag;
    }

    public List<IRI> getQueryIds() {
        return queryIds;
    }

    public IRI getDefaultProvenance() {
        return defaultProvenance;
    }

    private synchronized void triggerDataUpdate() {
        if (dataNeedsUpdate) {
            new Thread(() -> {
                for (ApiResponseEntry r : QueryApiAccess.forcedGet("get-owners", "unit", id).getData()) {
                    String pubkeyhash = r.get("pubkeyhash");
                    if (ownerPubkeyMap.containsKey(pubkeyhash)) {
                        addOwner(Utils.vf.createIRI(r.get("owner")));
                    }
                }
                members = new ArrayList<>();
                for (ApiResponseEntry r : QueryApiAccess.forcedGet("get-members", "unit", id).getData()) {
                    IRI memberId = Utils.vf.createIRI(r.get("member"));
                    // TODO These checks are inefficient for long member lists:
                    if (owners.contains(memberId)) continue;
                    if (members.contains(memberId)) continue;
                    members.add(memberId);
                }
                owners.sort(User.getUserData().userComparator);
                members.sort(User.getUserData().userComparator);
                dataInitialized = true;
            }).start();
            dataNeedsUpdate = false;
        }
    }

}

1	package com.knowledgepixels.nanodash;
2
3	import java.io.Serializable;
4	import java.util.ArrayList;
5	import java.util.HashSet;
6	import java.util.List;
7	import java.util.Set;
8	import java.util.concurrent.ConcurrentHashMap;
9	import java.util.concurrent.ConcurrentMap;
10
11	import org.eclipse.rdf4j.model.IRI;
12	import org.eclipse.rdf4j.model.Literal;
13	import org.eclipse.rdf4j.model.Statement;
14	import org.eclipse.rdf4j.model.vocabulary.DCTERMS;
15	import org.nanopub.Nanopub;
16	import org.nanopub.extra.services.ApiResponse;
17	import org.nanopub.extra.services.ApiResponseEntry;
18	import org.nanopub.vocabulary.NTEMPLATE;
19
20	import com.knowledgepixels.nanodash.template.Template;
21	import com.knowledgepixels.nanodash.template.TemplateData;
22
23	/**
24	* Class representing a Nanodash project.
25	*/
26	public class Project implements Serializable {
27
28	private static List<Project> projectList = null;	×
29	private static ConcurrentMap<String,Project> projectsByCoreInfo = new ConcurrentHashMap<>();	×
30	private static ConcurrentMap<String,Project> projectsById = new ConcurrentHashMap<>();	×
31
32	public static synchronized void refresh(ApiResponse resp) {
33	projectList = new ArrayList<>();	×
34	ConcurrentMap<String,Project> prevProjectsByCoreInfoPrev = projectsByCoreInfo;	×
35	projectsByCoreInfo = new ConcurrentHashMap<>();	×
36	projectsById.clear();	×
37	for (ApiResponseEntry entry : resp.getData()) {	×
38	Project project = new Project(entry.get("project"), entry.get("label"), entry.get("np"));	×
39	Project prevProject = prevProjectsByCoreInfoPrev.get(project.getCoreInfoString());	×
40	if (prevProject != null) project = prevProject;	×
41	projectList.add(project);	×
42	projectsByCoreInfo.put(project.getCoreInfoString(), project);	×
43	projectsById.put(project.getId(), project);	×
44	}	×
45	}	×
46
47	public static void ensureLoaded() {
48	if (projectList == null) {	×
49	refresh(QueryApiAccess.forcedGet("get-projects"));	×
50	}
51	}	×
52
53	public static List<Project> getProjectList() {
54	ensureLoaded();	×
55	return projectList;	×
56	}
57
58	public static Project get(String id) {
59	ensureLoaded();	×
60	return projectsById.get(id);	×
61	}
62
63	public static void refresh() {
64	ensureLoaded();	×
65	for (Project project : projectList) {	×
66	project.dataNeedsUpdate = true;	×
67	}	×
68	}	×
69
70	private String id, label, rootNanopubId;
71	private Nanopub rootNanopub = null;	×
72
73	private String description = null;	×
74	private List<IRI> owners = new ArrayList<>();	×
75	private List<IRI> members = new ArrayList<>();	×
76	private ConcurrentMap<String,IRI> ownerPubkeyMap = new ConcurrentHashMap<>();	×
77	private List<Template> templates = new ArrayList<>();	×
78	private Set<String> templateTags = new HashSet<>();	×
79	private ConcurrentMap<String, List<Template>> templatesPerTag = new ConcurrentHashMap<>();	×
80	private List<IRI> queryIds = new ArrayList<>();	×
81	private IRI defaultProvenance = null;	×
82
83	private boolean dataInitialized = false;	×
84	private boolean dataNeedsUpdate = true;	×
85
86	private Project(String id, String label, String rootNanopubId) {	×
87	this.id = id;	×
88	this.label = label;	×
89	this.rootNanopubId = rootNanopubId;	×
90	this.rootNanopub = Utils.getAsNanopub(rootNanopubId);	×
91
92	for (Statement st : rootNanopub.getAssertion()) {	×
93	if (st.getSubject().stringValue().equals(getId())) {	×
94	if (st.getPredicate().equals(DCTERMS.DESCRIPTION)) {	×
95	description = st.getObject().stringValue();	×
96	} else if (st.getPredicate().equals(Space.HAS_OWNER) && st.getObject() instanceof IRI obj) {	×
97	addOwner(obj);	×
98	} else if (st.getPredicate().equals(Space.HAS_PINNED_TEMPLATE) && st.getObject() instanceof IRI obj) {	×
99	templates.add(TemplateData.get().getTemplate(obj.stringValue()));	×
100	} else if (st.getPredicate().equals(Space.HAS_PINNED_QUERY) && st.getObject() instanceof IRI obj) {	×
101	queryIds.add(obj);	×
102	} else if (st.getPredicate().equals(NTEMPLATE.HAS_DEFAULT_PROVENANCE) && st.getObject() instanceof IRI obj) {	×
103	defaultProvenance = obj;	×
104	}
105	} else if (st.getPredicate().equals(NTEMPLATE.HAS_TAG) && st.getObject() instanceof Literal l) {	×
106	templateTags.add(l.stringValue());	×
107	List<Template> list = templatesPerTag.get(l.stringValue());	×
108	if (list == null) {	×
109	list = new ArrayList<>();	×
110	templatesPerTag.put(l.stringValue(), list);	×
111	}
112	list.add(TemplateData.get().getTemplate(st.getSubject().stringValue()));	×
113	}
114	}	×
115
116	}	×
117
118	private void addOwner(IRI owner) {
119	// TODO This isn't efficient for long owner lists:
120	if (owners.contains(owner)) return;	×
121	owners.add(owner);	×
122	UserData ud = User.getUserData();	×
123	for (String pubkeyhash : ud.getPubkeyhashes(owner, true)) {	×
124	ownerPubkeyMap.put(pubkeyhash, owner);	×
125	}	×
126	}	×
127
128	public String getId() {
129	return id;	×
130	}
131
132	public String getRootNanopubId() {
133	return rootNanopubId;	×
134	}
135
136	public String getCoreInfoString() {
137	return id + " " + rootNanopubId;	×
138	}
139
140	public Nanopub getRootNanopub() {
141	return rootNanopub;	×
142	}
143
144	public String getLabel() {
145	return label;	×
146	}
147
148	public String getDescription() {
149	return description;	×
150	}
151
152	public boolean isDataInitialized() {
153	triggerDataUpdate();	×
154	return dataInitialized;	×
155	}
156
157	public List<IRI> getOwners() {
158	triggerDataUpdate();	×
159	return owners;	×
160	}
161
162	public List<IRI> getMembers() {
163	triggerDataUpdate();	×
164	return members;	×
165	}
166
167	public List<Template> getTemplates() {
168	return templates;	×
169	}
170
171	public Set<String> getTemplateTags() {
172	return templateTags;	×
173	}
174
175	public ConcurrentMap<String, List<Template>> getTemplatesPerTag() {
176	return templatesPerTag;	×
177	}
178
179	public List<IRI> getQueryIds() {
180	return queryIds;	×
181	}
182
183	public IRI getDefaultProvenance() {
184	return defaultProvenance;	×
185	}
186
187	private synchronized void triggerDataUpdate() {
188	if (dataNeedsUpdate) {	×
189	new Thread(() -> {	×
190	for (ApiResponseEntry r : QueryApiAccess.forcedGet("get-owners", "unit", id).getData()) {	×
191	String pubkeyhash = r.get("pubkeyhash");	×
192	if (ownerPubkeyMap.containsKey(pubkeyhash)) {	×
193	addOwner(Utils.vf.createIRI(r.get("owner")));	×
194	}
195	}	×
196	members = new ArrayList<>();	×
197	for (ApiResponseEntry r : QueryApiAccess.forcedGet("get-members", "unit", id).getData()) {	×
198	IRI memberId = Utils.vf.createIRI(r.get("member"));	×
199	// TODO These checks are inefficient for long member lists:
200	if (owners.contains(memberId)) continue;	×
201	if (members.contains(memberId)) continue;	×
202	members.add(memberId);	×
203	}	×
204	owners.sort(User.getUserData().userComparator);	×
205	members.sort(User.getUserData().userComparator);	×
206	dataInitialized = true;	×
207	}).start();	×
208	dataNeedsUpdate = false;	×
209	}
210	}	×
211
212	}

knowledgepixels / nanodash / 17666649186

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