11525 retrieve collections a user can create datasets in

src/main/java/edu/harvard/iq/dataverse/mydata/DataRetrieverAPI.java

@@ -28,6 +28,7 @@
 import java.util.List;
 import java.util.logging.Logger;
 
+import edu.harvard.iq.dataverse.settings.FeatureFlags;
 import edu.harvard.iq.dataverse.util.json.JsonPrinter;
 import jakarta.ejb.EJB;
 import jakarta.inject.Inject;
@@ -126,9 +127,9 @@ private String getJSONErrorString(String jsonMsg, String optionalLoggerMsg){
 
     private void verifyAuth (ContainerRequestContext crc, String userIdentifier) throws WrappedResponse {
         // Handle calls from JSF where the User is in the session
-        boolean requiresApiKey = getRequestApiKey() != null;
         User requestUser = getRequestUser(crc);
-        if (!requiresApiKey && session != null && session.getUser() != null && requestUser instanceof GuestUser) {
+        boolean checkSession = !FeatureFlags.API_SESSION_AUTH.enabled() && (requestUser instanceof GuestUser);
+        if (checkSession && session != null && session.getUser() != null) {
             searchUser = authUser = (AuthenticatedUser) session.getUser();
             if (!authUser.isAuthenticated()) {
                 throw new WrappedResponse(authenticatedUserRequired());
@@ -160,13 +161,13 @@ public String retrieveMyDataAsJsonString(
             @QueryParam("userIdentifier") String userIdentifier,
             @QueryParam("filter_validities") Boolean filterValidities,
             @QueryParam("dataset_valid") List<Boolean> datasetValidities) {
-        boolean OTHER_USER = false;
+        boolean otherUser;
 
         String noMsgResultsFound = BundleUtil.getStringFromBundle("dataretrieverAPI.noMsgResultsFound");
 
         try {
             verifyAuth(crc, userIdentifier);
-            OTHER_USER = !authUser.equals(searchUser);
+            otherUser = !authUser.equals(searchUser);
         } catch (WrappedResponse wr) {
             return this.getJSONErrorString((new JSONObject(wr.getResponse().getEntity().toString())).getString("message"), null);
         }
@@ -299,7 +300,7 @@ public String retrieveMyDataAsJsonString(
         //jsonData.add("total_dvobject_counts", getTotalCountsFromSolrAsJSON(searchUser, this.myDataFinder));
 
 
-        if (OTHER_USER){
+        if (otherUser){
             jsonData.add("other_user", searchUser.getIdentifier());
         }
 

src/test/java/edu/harvard/iq/dataverse/api/DataRetrieverApiIT.java

@@ -207,6 +207,14 @@ public void testRetrieveMyDataCollections() throws InterruptedException {
                 .body("message", startsWith("No user found for:"))
                 .statusCode(NOT_FOUND.getStatusCode());
 
+        // Unknown user gets the list of Dataverses/Collections it has access to
+        retrieveMyCollectionListResponse = UtilIT.retrieveMyCollectionList("badtoken", null);
+        retrieveMyCollectionListResponse.prettyPrint();
+        retrieveMyCollectionListResponse.then().assertThat()
+                .body("status", equalTo("ERROR"))
+                .body("message", equalTo(ApiKeyAuthMechanism.RESPONSE_MESSAGE_BAD_API_KEY))
+                .statusCode(UNAUTHORIZED.getStatusCode());
+
         // Clean up
         dataverses.forEach(dv -> {
             Response deleteDataverseResponse = UtilIT.deleteDataverse(dv, superUserApiToken);

src/test/java/edu/harvard/iq/dataverse/util/json/JsonPrinterTest.java

@@ -20,6 +20,8 @@
 import java.util.*;
 import java.util.stream.Collectors;
 
+import edu.harvard.iq.dataverse.util.template.TemplateBuilder;
+
 import jakarta.json.*;
 
 import edu.harvard.iq.dataverse.util.BundleUtil;
@@ -481,7 +483,7 @@ public void testDatasetWithNondefaultType() {
     @Test
     public void testJsonArrayDataverseCollections() {
         List<Dataverse> collections = new ArrayList<>();
-        for (long i=0; i < 10; i++) {
+        for (long i = 0; i < 10; i++) {
             Dataverse dv = new Dataverse();
             dv.setAlias("alias" + i);
             dv.setName("Alias" + i);
@@ -491,16 +493,127 @@ public void testJsonArrayDataverseCollections() {
         JsonObjectBuilder job = JsonPrinter.jsonArray(collections);
         JsonObject result = job.build();
         assertNotNull(result);
-        System.out.println(result);
         assertEquals(10, result.getInt("count"));
         JsonArray items = result.getJsonArray("items");
         JsonObject item6 = items.getJsonObject(6);
-        System.out.println(item6);
         assertEquals(6, item6.getInt("id"));
         assertEquals("Alias6", item6.getString("name"));
         assertEquals("alias6", item6.getString("alias"));
     }
 
+    @Test
+    public void testJsonTermsOfUseAndAccess() {
+        // Setup a test TermsOfUseAndAccess
+        TermsOfUseAndAccess termsOfUseAndAccess = new TermsOfUseAndAccess();
+        termsOfUseAndAccess.setId(1L);
+        termsOfUseAndAccess.setTermsOfUse("Test Terms of Use");
+        termsOfUseAndAccess.setTermsOfAccess("Test Terms of Access");
+        termsOfUseAndAccess.setConfidentialityDeclaration("Test Confidentiality Declaration");
+        termsOfUseAndAccess.setSpecialPermissions("Test Special Permissions");
+        termsOfUseAndAccess.setRestrictions("Test Restrictions");
+        termsOfUseAndAccess.setCitationRequirements("Test Citation Requirements");
+        termsOfUseAndAccess.setDepositorRequirements("Test Depositor Requirements");
+        termsOfUseAndAccess.setConditions("Test Conditions");
+        termsOfUseAndAccess.setDisclaimer("Test Disclaimer");
+        termsOfUseAndAccess.setDataAccessPlace("Test Data Access Place");
+        termsOfUseAndAccess.setOriginalArchive("Test Original Archive");
+        termsOfUseAndAccess.setAvailabilityStatus("Test Availability Status");
+        termsOfUseAndAccess.setSizeOfCollection("Test Size of Collection");
+        termsOfUseAndAccess.setStudyCompletion("Test Study Completion");
+        termsOfUseAndAccess.setContactForAccess("Test Contact for Access");
+        termsOfUseAndAccess.setFileAccessRequest(true);
+
+        JsonObjectBuilder job = JsonPrinter.jsonTermsOfUseAndAccess(termsOfUseAndAccess);
+        assertNotNull(job);
+        JsonObject jsonObject = job.build();
+
+        // Assert all fields are present and correct
+        assertEquals(termsOfUseAndAccess.getId().longValue(), jsonObject.getJsonNumber("id").longValue());
+        assertEquals(termsOfUseAndAccess.getTermsOfUse(), jsonObject.getString("termsOfUse"));
+        assertEquals(termsOfUseAndAccess.getTermsOfAccess(), jsonObject.getString("termsOfAccess"));
+        assertEquals(termsOfUseAndAccess.getConfidentialityDeclaration(), jsonObject.getString("confidentialityDeclaration"));
+        assertEquals(termsOfUseAndAccess.getSpecialPermissions(), jsonObject.getString("specialPermissions"));
+        assertEquals(termsOfUseAndAccess.getRestrictions(), jsonObject.getString("restrictions"));
+        assertEquals(termsOfUseAndAccess.getCitationRequirements(), jsonObject.getString("citationRequirements"));
+        assertEquals(termsOfUseAndAccess.getDepositorRequirements(), jsonObject.getString("depositorRequirements"));
+        assertEquals(termsOfUseAndAccess.getConditions(), jsonObject.getString("conditions"));
+        assertEquals(termsOfUseAndAccess.getDisclaimer(), jsonObject.getString("disclaimer"));
+        assertEquals(termsOfUseAndAccess.getDataAccessPlace(), jsonObject.getString("dataAccessPlace"));
+        assertEquals(termsOfUseAndAccess.getOriginalArchive(), jsonObject.getString("originalArchive"));
+        assertEquals(termsOfUseAndAccess.getAvailabilityStatus(), jsonObject.getString("availabilityStatus"));
+        assertEquals(termsOfUseAndAccess.getSizeOfCollection(), jsonObject.getString("sizeOfCollection"));
+        assertEquals(termsOfUseAndAccess.getStudyCompletion(), jsonObject.getString("studyCompletion"));
+        assertEquals(termsOfUseAndAccess.getContactForAccess(), jsonObject.getString("contactForAccess"));
+        assertEquals(termsOfUseAndAccess.isFileAccessRequest(), jsonObject.getBoolean("fileAccessRequest"));
+
+        // Assert license is null
+        assertNull(jsonObject.getJsonObject("license"));
+
+        // Test with a license
+        long testLicenseId = 1L;
+        termsOfUseAndAccess.setLicense(createLicense(testLicenseId));
+        job = JsonPrinter.jsonTermsOfUseAndAccess(termsOfUseAndAccess);
+        assertNotNull(job);
+        jsonObject = job.build();
+        assertFalse(jsonObject.isNull("license"));
+        assertEquals(testLicenseId, jsonObject.getJsonObject("license").getJsonNumber("id").longValue());
+    }
+
+    @Test
+    public void testJsonTemplate() {
+        // Setup a test Template
+        Template template = TemplateBuilder.aTemplate().build();
+        JsonObjectBuilder job = JsonPrinter.jsonTemplate(template);
+        assertNotNull(job);
+        JsonObject jsonObject = job.build();
+
+        // Assert all fields are present and correct, skipping the ID since it is not set.
+        assertEquals(template.getName(), jsonObject.getString("name"));
+        assertEquals(template.isIsDefaultForDataverse(), jsonObject.getBoolean("isDefault"));
+        assertEquals(template.getUsageCount().longValue(), jsonObject.getJsonNumber("usageCount").longValue());
+        assertEquals(template.getCreateTime().toString(), jsonObject.getString("createTime"));
+        assertEquals(template.getCreateDate(), jsonObject.getString("createDate"));
+        assertEquals(template.getDataverse().getAlias(), jsonObject.getString("dataverseAlias"));
+
+        // Verify termsOfUseAndAccess field by checking a sub-field
+        JsonObject termsJson = jsonObject.getJsonObject("termsOfUseAndAccess");
+        assertNotNull(termsJson);
+        assertEquals(template.getTermsOfUseAndAccess().getTermsOfUse(), termsJson.getString("termsOfUse"));
+
+        // Verify datasetFields field is an empty JSON object
+        JsonObject datasetFieldsJson = jsonObject.getJsonObject("datasetFields");
+        assertNotNull(datasetFieldsJson);
+        assertTrue(datasetFieldsJson.isEmpty());
+
+        // Verify instructions map properties are correct regardless of order
+        JsonArray instructionsJson = jsonObject.getJsonArray("instructions");
+        assertEquals(2, instructionsJson.size());
+
+        Map<String, String> instructionsMap = instructionsJson.stream()
+                .map(jsonValue -> (JsonObject) jsonValue)
+                .collect(Collectors.toMap(
+                        obj -> obj.getString("instructionField"),
+                        obj -> obj.getString("instructionText")
+                ));
+
+        assertEquals("Enter the author's name here.", instructionsMap.get("author"));
+        assertEquals("Provide a title for the dataset.", instructionsMap.get("title"));
+    }
+
+    private License createLicense(long id) {
+        License license = new License();
+        license.setId(id);
+        license.setName("Test License " + id);
+        license.setShortDescription("Short description for license " + id);
+        try {
+            license.setUri(new java.net.URI("http://test.org/" + id));
+        } catch (java.net.URISyntaxException e) {
+            e.printStackTrace();
+        }
+        license.setActive(true);
+        return license;
+    }
+
     private Dataverse createDataverse(long id) {
         Dataverse dataverse = new Dataverse();
         dataverse.setId(id);