Metadata language api call

src/main/java/edu/harvard/iq/dataverse/api/Dataverses.java

@@ -1969,4 +1969,15 @@ public Response createTemplate(@Context ContainerRequestContext crc, String body
             return e.getResponse();
         }
     }
+
+    @GET
+    @AuthRequired
+    @Path("{identifier}/metadataLanguage")
+    public Response getMetadataLanguage(@Context ContainerRequestContext crc, @PathParam("identifier") String dvIdtf) {
+        return response(req -> {
+            Dataverse dataverse = findDataverseOrDie(dvIdtf);
+            return ok(jsonLanguage(execCommand(
+                    new GetDataverseMetadataLanguageCommand(req, dataverse))));
+        }, getRequestUser(crc));
+    }
 }

src/main/java/edu/harvard/iq/dataverse/engine/command/impl/GetDataverseMetadataLanguageCommand.java

@@ -0,0 +1,41 @@
+package edu.harvard.iq.dataverse.engine.command.impl;
+
+import java.util.Collections;
+import java.util.Map;
+import java.util.Set;
+
+import edu.harvard.iq.dataverse.Dataverse;
+import edu.harvard.iq.dataverse.DvObjectContainer;
+import edu.harvard.iq.dataverse.authorization.Permission;
+import edu.harvard.iq.dataverse.engine.command.AbstractCommand;
+import edu.harvard.iq.dataverse.engine.command.CommandContext;
+import edu.harvard.iq.dataverse.engine.command.DataverseRequest;
+import edu.harvard.iq.dataverse.engine.command.exception.CommandException;
+
+public class GetDataverseMetadataLanguageCommand extends AbstractCommand<Map<String, String>> {
+
+    private final Dataverse dv;
+
+    public GetDataverseMetadataLanguageCommand(DataverseRequest aRequest, Dataverse dv) {
+        super(aRequest, dv);
+        this.dv = dv;
+    }
+
+    @Override
+    public Map<String, String> execute(CommandContext ctxt) throws CommandException {
+        Map<String, String> langMap = ctxt.settings().getBaseMetadataLanguageMap(null, true);
+        String dvMetadataLanguage = dv.getMetadataLanguage();
+        if (!dvMetadataLanguage.equals(DvObjectContainer.UNDEFINED_CODE)) {
+            return Collections.singletonMap(dvMetadataLanguage, langMap.get(dvMetadataLanguage));
+        }
+        return langMap;
+
+    }
+
+    @Override
+    public Map<String, Set<Permission>> getRequiredPermissions() {
+        return Collections.singletonMap("",
+                dv.isReleased() ? Collections.<Permission>emptySet()
+                : Collections.singleton(Permission.ViewUnpublishedDataverse));
+    }  
+}

src/main/java/edu/harvard/iq/dataverse/util/json/JsonPrinter.java

@@ -1685,4 +1685,14 @@ public static JsonArrayBuilder json(List<UserNotification> notifications, Authen
 
         return notificationsArray;
     }
+
+    public static JsonObjectBuilder jsonLanguage(String locale, String title) {
+        // returns a single metadata language entry
+        return jsonObjectBuilder().add("locale", locale).add("title", title);
+    }
+
+    public static JsonArrayBuilder jsonLanguage(Map<String, String> langMap) {
+        // returns an array of metadatalanguages
+        return Json.createArrayBuilder(langMap.entrySet().stream().map(entry -> jsonLanguage(entry.getKey(), entry.getValue())).toList());
+    }
 }

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

@@ -2457,4 +2457,35 @@ private String getSuperuserToken() {
         UtilIT.makeSuperUser(username);
         return adminApiToken;
     }
+
+    @Test
+    public void testGetDataverseMetadataLanguage() {
+        Response createUser = UtilIT.createRandomUser();
+        createUser.prettyPrint();
+        String username = UtilIT.getUsernameFromResponse(createUser);
+        String apiToken = UtilIT.getApiTokenFromResponse(createUser);
+        UtilIT.deleteSetting(":MetadataLanguages");
+        Response createDataverse1Response = UtilIT.createRandomDataverse(apiToken);
+
+        createDataverse1Response.prettyPrint();
+        createDataverse1Response.then().assertThat().statusCode(CREATED.getStatusCode());
+
+        String alias = UtilIT.getAliasFromResponse(createDataverse1Response);
+
+        Response noLang = UtilIT.getDataverseMetadataLanguage(alias, apiToken);
+        noLang.prettyPrint();
+
+        noLang.then().assertThat().body("data", equalTo(List.of()));
+
+        UtilIT.setSetting(":MetadataLanguages",
+                        "[{\"locale\":\"en\",\"title\":\"English\"},{\"locale\":\"hu\",\"title\":\"magyar\"}]");
+        Response allLangs = UtilIT.getDataverseMetadataLanguage(alias, apiToken);
+        allLangs.prettyPrint();
+        allLangs.then().assertThat()
+                        .body("data.size()", equalTo(2))
+                        .and().body("data[0].locale", equalTo("en"))
+                        .and().body("data[1].locale", equalTo("hu"));
+
+    }
+
 }

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

@@ -5001,4 +5001,12 @@ public static Response callCallbackUrl(String callbackUrl) {
                 .when()
                 .get(callbackUrl);
     }
+
+    public static Response getDataverseMetadataLanguage(String alias, String apiToken) {
+        return given()
+                .header(API_TOKEN_HTTP_HEADER, apiToken)
+                .get("/api/dataverses/"
+                        + alias
+                        + "/metadataLanguage");
+    }
 }