18155160356

Committed 01 Oct 2025 07:42AM UTC coverage: 13.788% (-0.03%) from 13.817%

Build # 18155160356

Build Type

push

github

Committed by

ashleycaselli

Commit Message

docs: add missing or update Javadoc annotations

Run Details

445 of 4084 branches covered (10.9%)

Branch coverage included in aggregate %.

1155 of 7520 relevant lines covered (15.36%)

0.69 hits per line

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

29.37

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

package com.knowledgepixels.nanodash.template;

import com.knowledgepixels.nanodash.QueryApiAccess;
import net.trustyuri.TrustyUriUtils;
import org.eclipse.rdf4j.model.IRI;
import org.eclipse.rdf4j.model.Statement;
import org.nanopub.Nanopub;
import org.nanopub.extra.services.ApiResponse;
import org.nanopub.extra.services.ApiResponseEntry;
import org.nanopub.extra.services.QueryRef;
import org.nanopub.vocabulary.NTEMPLATE;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.Serializable;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

/**
 * Singleton class that manages templates data.
 */
public class TemplateData implements Serializable {

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

    private static TemplateData instance;

    /**
     * Refreshes the templates data by creating a new instance of TemplateData.
     */
    public static synchronized void refreshTemplates() {
        instance = new TemplateData();
    }

    /**
     * Ensures that the TemplateData instance is loaded.
     */
    public static synchronized void ensureLoaded() {
        if (instance == null) refreshTemplates();
    }

    /**
     * Gets the singleton instance of TemplateData.
     *
     * @return the TemplateData instance
     */
    public static TemplateData get() {
        ensureLoaded();
        return instance;
    }

    private List<ApiResponseEntry> assertionTemplates, provenanceTemplates, pubInfoTemplates;
    private ConcurrentMap<String, Template> templateMap;

    /**
     * Constructor to initialize the TemplateData instance.
     */
    public TemplateData() {
        assertionTemplates = new ArrayList<>();
        provenanceTemplates = new ArrayList<>();
        pubInfoTemplates = new ArrayList<>();
        templateMap = new ConcurrentHashMap<>();
        refreshTemplates(assertionTemplates, "get-assertion-templates");
        refreshTemplates(provenanceTemplates, "get-provenance-templates");
        refreshTemplates(pubInfoTemplates, "get-pubinfo-templates");
    }

    private void refreshTemplates(List<ApiResponseEntry> templates, String queryId) {
        ApiResponse templateEntries = QueryApiAccess.forcedGet(new QueryRef(queryId));
        String previousId = null;
        logger.info("Loading templates...");
        for (ApiResponseEntry entry : templateEntries.getData()) {
            if ("true".equals(entry.get("unlisted"))) continue;
            if (!entry.get("np").equals(previousId)) {
                templates.add(entry);
            }
            previousId = entry.get("np");
        }
        templates.sort(templateComparator);
    }

    /**
     * Returns the list of assertion templates.
     *
     * @return a list of assertion templates
     */
    public List<ApiResponseEntry> getAssertionTemplates() {
        return assertionTemplates;
    }

    /**
     * Returns the list of provenance templates.
     *
     * @return a list of provenance templates
     */
    public List<ApiResponseEntry> getProvenanceTemplates() {
        return provenanceTemplates;
    }

    /**
     * Returns the list of publication information templates.
     *
     * @return a list of publication information templates
     */
    public List<ApiResponseEntry> getPubInfoTemplates() {
        return pubInfoTemplates;
    }

    /**
     * Returns a Template object for the given template ID.
     *
     * @param id the ID of the template
     * @return the Template object if found, or null if not found or invalid
     */
    public Template getTemplate(String id) {
        Template template = templateMap.get(id);
        if (template != null) return template;
        if (TrustyUriUtils.isPotentialTrustyUri(id)) {
            try {
                Template t = new Template(id);
                templateMap.put(id, t);
                return t;
            } catch (Exception ex) {
                logger.error("Exception: {}", ex.getMessage());
                return null;
            }
        }
        return null;
    }

    /**
     * Returns a Template object for the template of the given Nanopub.
     *
     * @param np the Nanopub from which to extract the template
     * @return the Template object if found, or null if not found or invalid
     */
    public Template getTemplate(Nanopub np) {
        IRI templateId = getTemplateId(np);
        if (templateId == null) return null;
        return getTemplate(templateId.stringValue());
    }

    /**
     * Returns a Template object for the provenance template of the given Nanopub.
     *
     * @param np the Nanopub from which to extract the provenance template
     * @return the Template object if found, or null if not found or invalid
     */
    public Template getProvenanceTemplate(Nanopub np) {
        IRI templateId = getProvenanceTemplateId(np);
        if (templateId == null) return null;
        return getTemplate(templateId.stringValue());
    }

    /**
     * Returns a set of Template objects for the publication information templates of the given Nanopub.
     *
     * @param np the Nanopub from which to extract the publication information templates
     * @return a set of Template objects
     */
    public Set<Template> getPubinfoTemplates(Nanopub np) {
        Set<Template> templates = new HashSet<>();
        for (IRI id : getPubinfoTemplateIds(np)) {
            templates.add(getTemplate(id.stringValue()));
        }
        return templates;
    }

    /**
     * Returns the template ID of the given Nanopub.
     *
     * @param nanopub the Nanopub from which to extract the template ID
     * @return the IRI of the template ID, or null if not found
     */
    public IRI getTemplateId(Nanopub nanopub) {
        for (Statement st : nanopub.getPubinfo()) {
            if (!st.getSubject().equals(nanopub.getUri())) continue;
            if (!st.getPredicate().equals(NTEMPLATE.WAS_CREATED_FROM_TEMPLATE)) continue;
            if (!(st.getObject() instanceof IRI)) continue;
            return (IRI) st.getObject();
        }
        return null;
    }

    /**
     * Returns the provenance template ID of the given Nanopub.
     *
     * @param nanopub the Nanopub from which to extract the provenance template ID
     * @return the IRI of the provenance template ID, or null if not found
     */
    public IRI getProvenanceTemplateId(Nanopub nanopub) {
        for (Statement st : nanopub.getPubinfo()) {
            if (!st.getSubject().equals(nanopub.getUri())) continue;
            if (!st.getPredicate().equals(NTEMPLATE.WAS_CREATED_FROM_PROVENANCE_TEMPLATE)) continue;
            if (!(st.getObject() instanceof IRI)) continue;
            return (IRI) st.getObject();
        }
        return null;
    }

    /**
     * Returns the set of publication information template IDs for the given Nanopub.
     *
     * @param nanopub the Nanopub from which to extract the publication information template IDs
     * @return a set of IRI objects representing the publication information template IDs
     */
    public Set<IRI> getPubinfoTemplateIds(Nanopub nanopub) {
        Set<IRI> iriSet = new HashSet<>();
        for (Statement st : nanopub.getPubinfo()) {
            if (!st.getSubject().equals(nanopub.getUri())) continue;
            if (!st.getPredicate().equals(NTEMPLATE.WAS_CREATED_FROM_PUBINFO_TEMPLATE)) continue;
            if (!(st.getObject() instanceof IRI)) continue;
            iriSet.add((IRI) st.getObject());
        }
        return iriSet;
    }

    /**
     * Returns a list of Template objects from the given ApiResponse.
     *
     * @param apiResponse the ApiResponse containing template entries
     * @return a list of Template objects
     */
    public static List<Template> getTemplateList(ApiResponse apiResponse) {
        List<Template> templates = new ArrayList<>();
        for (ApiResponseEntry e : apiResponse.getData()) {
            String templateNpId = e.get("template_np");
            if (templateNpId == null) templateNpId = e.get("np");
            templates.add(TemplateData.get().getTemplate(templateNpId));
        }
        return templates;
    }

    private static final TemplateComparator templateComparator = new TemplateComparator();

    private static class TemplateComparator implements Comparator<ApiResponseEntry>, Serializable {

        /**
         * Compares two Template objects based on their labels.
         *
         * @param o1 the first object to be compared.
         * @param o2 the second object to be compared.
         * @return a negative integer, zero, or a positive integer as the first argument is less than, equal to, or greater than the second.
         */
        @Override
        public int compare(ApiResponseEntry o1, ApiResponseEntry o2) {
            return o1.get("label").compareTo(o2.get("label"));
        }

    }

}

1	package com.knowledgepixels.nanodash.template;
2
3	import com.knowledgepixels.nanodash.QueryApiAccess;
4	import net.trustyuri.TrustyUriUtils;
5	import org.eclipse.rdf4j.model.IRI;
6	import org.eclipse.rdf4j.model.Statement;
7	import org.nanopub.Nanopub;
8	import org.nanopub.extra.services.ApiResponse;
9	import org.nanopub.extra.services.ApiResponseEntry;
10	import org.nanopub.extra.services.QueryRef;
11	import org.nanopub.vocabulary.NTEMPLATE;
12	import org.slf4j.Logger;
13	import org.slf4j.LoggerFactory;
14
15	import java.io.Serializable;
16	import java.util.*;
17	import java.util.concurrent.ConcurrentHashMap;
18	import java.util.concurrent.ConcurrentMap;
19
20	/**
21	* Singleton class that manages templates data.
22	*/
23	public class TemplateData implements Serializable {
24
25	private static final Logger logger = LoggerFactory.getLogger(TemplateData.class);	3✔
26
27	private static TemplateData instance;
28
29	/**
30	* Refreshes the templates data by creating a new instance of TemplateData.
31	*/
32	public static synchronized void refreshTemplates() {
33	instance = new TemplateData();	4✔
34	}	1✔
35
36	/**
37	* Ensures that the TemplateData instance is loaded.
38	*/
39	public static synchronized void ensureLoaded() {
40	if (instance == null) refreshTemplates();	3✔
41	}	1✔
42
43	/**
44	* Gets the singleton instance of TemplateData.
45	*
46	* @return the TemplateData instance
47	*/
48	public static TemplateData get() {
49	ensureLoaded();	1✔
50	return instance;	2✔
51	}
52
53	private List<ApiResponseEntry> assertionTemplates, provenanceTemplates, pubInfoTemplates;
54	private ConcurrentMap<String, Template> templateMap;
55
56	/**
57	* Constructor to initialize the TemplateData instance.
58	*/
59	public TemplateData() {	2✔
60	assertionTemplates = new ArrayList<>();	5✔
61	provenanceTemplates = new ArrayList<>();	5✔
62	pubInfoTemplates = new ArrayList<>();	5✔
63	templateMap = new ConcurrentHashMap<>();	5✔
64	refreshTemplates(assertionTemplates, "get-assertion-templates");	5✔
65	refreshTemplates(provenanceTemplates, "get-provenance-templates");	5✔
66	refreshTemplates(pubInfoTemplates, "get-pubinfo-templates");	5✔
67	}	1✔
68
69	private void refreshTemplates(List<ApiResponseEntry> templates, String queryId) {
70	ApiResponse templateEntries = QueryApiAccess.forcedGet(new QueryRef(queryId));	6✔
71	String previousId = null;	2✔
72	logger.info("Loading templates...");	3✔
73	for (ApiResponseEntry entry : templateEntries.getData()) {	11✔
74	if ("true".equals(entry.get("unlisted"))) continue;	7✔
75	if (!entry.get("np").equals(previousId)) {	6✔
76	templates.add(entry);	4✔
77	}
78	previousId = entry.get("np");	4✔
79	}	1✔
80	templates.sort(templateComparator);	3✔
81	}	1✔
82
83	/**
84	* Returns the list of assertion templates.
85	*
86	* @return a list of assertion templates
87	*/
88	public List<ApiResponseEntry> getAssertionTemplates() {
89	return assertionTemplates;	×
90	}
91
92	/**
93	* Returns the list of provenance templates.
94	*
95	* @return a list of provenance templates
96	*/
97	public List<ApiResponseEntry> getProvenanceTemplates() {
98	return provenanceTemplates;	×
99	}
100
101	/**
102	* Returns the list of publication information templates.
103	*
104	* @return a list of publication information templates
105	*/
106	public List<ApiResponseEntry> getPubInfoTemplates() {
107	return pubInfoTemplates;	×
108	}
109
110	/**
111	* Returns a Template object for the given template ID.
112	*
113	* @param id the ID of the template
114	* @return the Template object if found, or null if not found or invalid
115	*/
116	public Template getTemplate(String id) {
117	Template template = templateMap.get(id);	×
118	if (template != null) return template;	×
119	if (TrustyUriUtils.isPotentialTrustyUri(id)) {	×
120	try {
121	Template t = new Template(id);	×
122	templateMap.put(id, t);	×
123	return t;	×
124	} catch (Exception ex) {	×
125	logger.error("Exception: {}", ex.getMessage());	×
126	return null;	×
127	}
128	}
129	return null;	×
130	}
131
132	/**
133	* Returns a Template object for the template of the given Nanopub.
134	*
135	* @param np the Nanopub from which to extract the template
136	* @return the Template object if found, or null if not found or invalid
137	*/
138	public Template getTemplate(Nanopub np) {
139	IRI templateId = getTemplateId(np);	×
140	if (templateId == null) return null;	×
141	return getTemplate(templateId.stringValue());	×
142	}
143
144	/**
145	* Returns a Template object for the provenance template of the given Nanopub.
146	*
147	* @param np the Nanopub from which to extract the provenance template
148	* @return the Template object if found, or null if not found or invalid
149	*/
150	public Template getProvenanceTemplate(Nanopub np) {
151	IRI templateId = getProvenanceTemplateId(np);	×
152	if (templateId == null) return null;	×
153	return getTemplate(templateId.stringValue());	×
154	}
155
156	/**
157	* Returns a set of Template objects for the publication information templates of the given Nanopub.
158	*
159	* @param np the Nanopub from which to extract the publication information templates
160	* @return a set of Template objects
161	*/
162	public Set<Template> getPubinfoTemplates(Nanopub np) {
163	Set<Template> templates = new HashSet<>();	×
164	for (IRI id : getPubinfoTemplateIds(np)) {	×
165	templates.add(getTemplate(id.stringValue()));	×
166	}	×
167	return templates;	×
168	}
169
170	/**
171	* Returns the template ID of the given Nanopub.
172	*
173	* @param nanopub the Nanopub from which to extract the template ID
174	* @return the IRI of the template ID, or null if not found
175	*/
176	public IRI getTemplateId(Nanopub nanopub) {
177	for (Statement st : nanopub.getPubinfo()) {	×
178	if (!st.getSubject().equals(nanopub.getUri())) continue;	×
179	if (!st.getPredicate().equals(NTEMPLATE.WAS_CREATED_FROM_TEMPLATE)) continue;	×
180	if (!(st.getObject() instanceof IRI)) continue;	×
181	return (IRI) st.getObject();	×
182	}
183	return null;	×
184	}
185
186	/**
187	* Returns the provenance template ID of the given Nanopub.
188	*
189	* @param nanopub the Nanopub from which to extract the provenance template ID
190	* @return the IRI of the provenance template ID, or null if not found
191	*/
192	public IRI getProvenanceTemplateId(Nanopub nanopub) {
193	for (Statement st : nanopub.getPubinfo()) {	×
194	if (!st.getSubject().equals(nanopub.getUri())) continue;	×
195	if (!st.getPredicate().equals(NTEMPLATE.WAS_CREATED_FROM_PROVENANCE_TEMPLATE)) continue;	×
196	if (!(st.getObject() instanceof IRI)) continue;	×
197	return (IRI) st.getObject();	×
198	}
199	return null;	×
200	}
201
202	/**
203	* Returns the set of publication information template IDs for the given Nanopub.
204	*
205	* @param nanopub the Nanopub from which to extract the publication information template IDs
206	* @return a set of IRI objects representing the publication information template IDs
207	*/
208	public Set<IRI> getPubinfoTemplateIds(Nanopub nanopub) {
209	Set<IRI> iriSet = new HashSet<>();	×
210	for (Statement st : nanopub.getPubinfo()) {	×
211	if (!st.getSubject().equals(nanopub.getUri())) continue;	×
212	if (!st.getPredicate().equals(NTEMPLATE.WAS_CREATED_FROM_PUBINFO_TEMPLATE)) continue;	×
213	if (!(st.getObject() instanceof IRI)) continue;	×
214	iriSet.add((IRI) st.getObject());	×
215	}	×
216	return iriSet;	×
217	}
218
219	/**
220	* Returns a list of Template objects from the given ApiResponse.
221	*
222	* @param apiResponse the ApiResponse containing template entries
223	* @return a list of Template objects
224	*/
225	public static List<Template> getTemplateList(ApiResponse apiResponse) {
226	List<Template> templates = new ArrayList<>();	×
227	for (ApiResponseEntry e : apiResponse.getData()) {	×
228	String templateNpId = e.get("template_np");	×
229	if (templateNpId == null) templateNpId = e.get("np");	×
230	templates.add(TemplateData.get().getTemplate(templateNpId));	×
231	}	×
232	return templates;	×
233	}
234
235	private static final TemplateComparator templateComparator = new TemplateComparator();	5✔
236
237	private static class TemplateComparator implements Comparator<ApiResponseEntry>, Serializable {
238
239	/**
240	* Compares two Template objects based on their labels.
241	*
242	* @param o1 the first object to be compared.
243	* @param o2 the second object to be compared.
244	* @return a negative integer, zero, or a positive integer as the first argument is less than, equal to, or greater than the second.
245	*/
246	@Override
247	public int compare(ApiResponseEntry o1, ApiResponseEntry o2) {
248	return o1.get("label").compareTo(o2.get("label"));	8✔
249	}
250
251	}
252
253	}

knowledgepixels / nanodash / 18155160356

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