feat: copyright URLs per locale

.github/workflows/mapping_ci.yml

@@ -7,11 +7,13 @@ on:
   push:
     paths:
       - mapping/**
+      - language/**
       - modules/**
       - build.mill
   pull_request:
     paths:
       - mapping/**
+      - language/**
       - modules/**
       - build.mill
 jobs:

article-api/src/main/scala/no/ndla/articleapi/service/ConverterService.scala

@@ -257,7 +257,7 @@ class ConverterService(using props: Props) extends StrictLogging {
         .map(toApiArticleContentV2)
         .getOrElse(api.ArticleContentV2DTO("", UnknownLanguage.toString))
       val metaImage  = findByLanguageOrBestEffort(article.metaImage, language).map(toApiArticleMetaImage)
-      val copyright  = toApiCopyright(article.copyright)
+      val copyright  = toApiCopyright(article.copyright, language)
       val disclaimer = article.disclaimer.findByLanguageOrBestEffort(language).map(DisclaimerDTO.fromLanguageValue)
 
       Success(
@@ -317,9 +317,9 @@ class ConverterService(using props: Props) extends StrictLogging {
 
   }
 
-  private def toApiCopyright(copyright: Copyright): commonApi.CopyrightDTO = {
+  private def toApiCopyright(copyright: Copyright, language: String): commonApi.CopyrightDTO = {
     commonApi.CopyrightDTO(
-      toApiLicense(copyright.license),
+      toApiLicense(copyright.license, language),
       copyright.origin,
       copyright.creators.map(_.toApi),
       copyright.processors.map(_.toApi),
@@ -330,10 +330,12 @@ class ConverterService(using props: Props) extends StrictLogging {
     )
   }
 
-  def toApiLicense(shortLicense: String): LicenseDTO = {
+  def toApiLicense(shortLicense: String, language: String): LicenseDTO = {
     getLicense(shortLicense) match {
-      case Some(l) => model.api.LicenseDTO(l.license.toString, Option(l.description), l.url)
-      case None    => model.api.LicenseDTO("unknown", None, None)
+      case Some(l) => model
+          .api
+          .LicenseDTO(l.license.toString, Option(l.description), findByLanguageOrBestEffort(l.url, language).map(_.url))
+      case None => model.api.LicenseDTO("unknown", None, None)
     }
   }
 

article-api/src/test/scala/no/ndla/articleapi/service/ConverterServiceTest.scala

@@ -45,11 +45,11 @@ class ConverterServiceTest extends UnitSuite with TestEnvironment {
   val sampleAlt                        = "Fotografi"
 
   test("toApiLicense defaults to unknown if the license was not found") {
-    service.toApiLicense("invalid") should equal(LicenseDTO("unknown", None, None))
+    service.toApiLicense("invalid", "nb") should equal(LicenseDTO("unknown", None, None))
   }
 
   test("toApiLicense converts a short license string to a license object with description and url") {
-    service.toApiLicense("CC-BY-4.0") should equal(
+    service.toApiLicense("CC-BY-4.0", "nb") should equal(
       model
         .api
         .LicenseDTO(

audio-api/src/main/scala/no/ndla/audioapi/service/ConverterService.scala

@@ -98,7 +98,7 @@ class ConverterService(using clock: Clock, props: Props) extends StrictLogging {
         revision = audioMeta.revision.get,
         title = maybeToApiTitle(findByLanguageOrBestEffort(audioMeta.titles, language)),
         audioFile = toApiAudio(findByLanguageOrBestEffort(audioMeta.filePaths, language)),
-        copyright = toApiCopyright(audioMeta.copyright),
+        copyright = toApiCopyright(audioMeta.copyright, language.getOrElse(props.DefaultLanguage)),
         tags = toApiTags(findByLanguageOrBestEffort(audioMeta.tags, language)),
         supportedLanguages = audioMeta.supportedLanguages,
         audioType = audioMeta.audioType.toString,
@@ -137,18 +137,22 @@ class ConverterService(using clock: Clock, props: Props) extends StrictLogging {
     }
   }
 
-  def toApiLicence(licenseAbbrevation: String): commonApi.LicenseDTO = {
+  def toApiLicence(licenseAbbrevation: String, language: String): commonApi.LicenseDTO = {
     getLicense(licenseAbbrevation) match {
-      case Some(license) => commonApi.LicenseDTO(license.license.toString, Option(license.description), license.url)
-      case None          =>
+      case Some(license) => commonApi.LicenseDTO(
+          license.license.toString,
+          Option(license.description),
+          findByLanguageOrBestEffort(license.url, language).map(_.url),
+        )
+      case None =>
         logger.warn("Could not retrieve license information for {}", licenseAbbrevation)
         commonApi.LicenseDTO("unknown", None, None)
     }
   }
 
-  def toApiCopyright(copyright: Copyright): commonApi.CopyrightDTO = {
+  def toApiCopyright(copyright: Copyright, language: String): commonApi.CopyrightDTO = {
     commonApi.CopyrightDTO(
-      toApiLicence(copyright.license),
+      toApiLicence(copyright.license, language),
       copyright.origin,
       copyright.creators.map(_.toApi),
       copyright.processors.map(_.toApi),

audio-api/src/test/scala/no/ndla/audioapi/service/ConverterServiceTest.scala

@@ -60,7 +60,7 @@ class ConverterServiceTest extends UnitSuite with TestEnvironment {
       audioMeta.revision.get,
       api.TitleDTO("Batmen er på vift med en bil", "nb"),
       service.toApiAudio(audioMeta.filePaths.headOption),
-      service.toApiCopyright(audioMeta.copyright),
+      service.toApiCopyright(audioMeta.copyright, "nb"),
       api.TagDTO(Seq("fisk"), "nb"),
       Seq("nb"),
       "standard",
@@ -80,7 +80,7 @@ class ConverterServiceTest extends UnitSuite with TestEnvironment {
       audioMeta.revision.get,
       api.TitleDTO("Batmen er på vift med en bil", "nb"),
       service.toApiAudio(audioMeta.filePaths.headOption),
-      service.toApiCopyright(audioMeta.copyright),
+      service.toApiCopyright(audioMeta.copyright, "nb"),
       api.TagDTO(Seq("fisk"), "nb"),
       Seq("nb"),
       "standard",
@@ -108,13 +108,13 @@ class ConverterServiceTest extends UnitSuite with TestEnvironment {
       Some("https://creativecommons.org/licenses/by-sa/4.0/"),
     )
 
-    service.toApiLicence(licenseAbbr) should equal(license)
+    service.toApiLicence(licenseAbbr, "nb") should equal(license)
   }
 
   test("That toApiLicense returns unknown if the license is invalid") {
     val licenseAbbr = "garbage"
 
-    service.toApiLicence(licenseAbbr) should equal(commonApi.LicenseDTO("unknown", None, None))
+    service.toApiLicence(licenseAbbr, "nb") should equal(commonApi.LicenseDTO("unknown", None, None))
   }
 
   test("That mergeLanguageField merges language fields as expected") {

audio-api/src/test/scala/no/ndla/audioapi/service/WriteServiceTest.scala

@@ -295,7 +295,7 @@ class WriteServiceTest extends UnitSuite with TestEnvironment {
       1,
       "A new english title",
       "en",
-      converterService.toApiCopyright(domainAudioMeta.copyright),
+      converterService.toApiCopyright(domainAudioMeta.copyright, "en"),
       Seq(),
       None,
       None,
@@ -312,7 +312,7 @@ class WriteServiceTest extends UnitSuite with TestEnvironment {
       1,
       "En ny norsk tittel",
       "nb",
-      converterService.toApiCopyright(domainAudioMeta.copyright),
+      converterService.toApiCopyright(domainAudioMeta.copyright, "nb"),
       Seq(),
       None,
       None,
@@ -330,7 +330,7 @@ class WriteServiceTest extends UnitSuite with TestEnvironment {
       1,
       "A new english title",
       "en",
-      converterService.toApiCopyright(domainAudioMeta.copyright),
+      converterService.toApiCopyright(domainAudioMeta.copyright, "en"),
       Seq(),
       None,
       None,
@@ -350,7 +350,7 @@ class WriteServiceTest extends UnitSuite with TestEnvironment {
       1,
       "A new english title",
       "en",
-      converterService.toApiCopyright(domainAudioMeta.copyright),
+      converterService.toApiCopyright(domainAudioMeta.copyright, "en"),
       Seq(),
       None,
       None,
@@ -372,7 +372,7 @@ class WriteServiceTest extends UnitSuite with TestEnvironment {
       1,
       "En ny norsk tittel",
       "nb",
-      converterService.toApiCopyright(domainAudioMeta.copyright),
+      converterService.toApiCopyright(domainAudioMeta.copyright, "nb"),
       Seq(),
       None,
       None,
@@ -837,7 +837,7 @@ class WriteServiceTest extends UnitSuite with TestEnvironment {
       1,
       "A new english title",
       "en",
-      converterService.toApiCopyright(domainAudioMeta.copyright),
+      converterService.toApiCopyright(domainAudioMeta.copyright, "en"),
       Seq("abc", "123", "abc", "def"),
       None,
       None,

concept-api/src/main/scala/no/ndla/conceptapi/service/ConverterService.scala

@@ -75,7 +75,7 @@ class ConverterService(using clock: Clock, props: Props) extends StrictLogging {
           revision = concept.revision.getOrElse(-1),
           title = title,
           content = Some(content),
-          copyright = concept.copyright.map(toApiCopyright),
+          copyright = concept.copyright.map(lic => toApiCopyright(lic, language)),
           source = concept.copyright.flatMap(_.origin),
           tags = tags,
           created = concept.created,
@@ -136,9 +136,12 @@ class ConverterService(using clock: Clock, props: Props) extends StrictLogging {
     api.ConceptTagsDTO(tags.tags, tags.language)
   }
 
-  private def toApiCopyright(copyright: commonDomain.draft.DraftCopyright): commonApi.DraftCopyrightDTO = {
+  private def toApiCopyright(
+      copyright: commonDomain.draft.DraftCopyright,
+      language: String,
+  ): commonApi.DraftCopyrightDTO = {
     commonApi.DraftCopyrightDTO(
-      copyright.license.flatMap(toMaybeApiLicense),
+      copyright.license.flatMap(lic => toMaybeApiLicense(lic, language)),
       copyright.origin,
       copyright.creators.map(_.toApi),
       copyright.processors.map(_.toApi),
@@ -149,16 +152,22 @@ class ConverterService(using clock: Clock, props: Props) extends StrictLogging {
     )
   }
 
-  private def toMaybeApiLicense(shortLicense: String): Option[commonApi.LicenseDTO] = {
-    getLicense(shortLicense).map(l => commonApi.LicenseDTO(l.license.toString, Option(l.description), l.url))
+  private def toMaybeApiLicense(shortLicense: String, language: String): Option[commonApi.LicenseDTO] = {
+    getLicense(shortLicense).map(l =>
+      commonApi.LicenseDTO(
+        l.license.toString,
+        Option(l.description),
+        findByLanguageOrBestEffort(l.url, language).map(_.url),
+      )
+    )
   }
 
-  def toApiLicense(maybeShortLicense: Option[String]): commonApi.LicenseDTO = maybeShortLicense
-    .flatMap(toMaybeApiLicense)
+  def toApiLicense(maybeShortLicense: Option[String], language: String): commonApi.LicenseDTO = maybeShortLicense
+    .flatMap(lic => toMaybeApiLicense(lic, language))
     .getOrElse(commonApi.LicenseDTO("unknown", None, None))
 
-  def toApiLicense(shortLicense: String): commonApi.LicenseDTO =
-    toMaybeApiLicense(shortLicense).getOrElse(commonApi.LicenseDTO("unknown", None, None))
+  def toApiLicense(shortLicense: String, language: String): commonApi.LicenseDTO =
+    toMaybeApiLicense(shortLicense, language).getOrElse(commonApi.LicenseDTO("unknown", None, None))
 
   def toApiConceptTitle(title: Title): api.ConceptTitleDTO =
     api.ConceptTitleDTO(Jsoup.parseBodyFragment(title.title).body().text(), title.title, title.language)

concept-api/src/main/scala/no/ndla/conceptapi/service/search/SearchConverterService.scala

@@ -113,7 +113,7 @@ class SearchConverterService(using converterService: ConverterService) extends S
       .getOrElse(api.ConceptContent("", "", UnknownLanguage.toString()))
     val tag           = findByLanguageOrBestEffort(tags, language).map(converterService.toApiTags)
     val visualElement = findByLanguageOrBestEffort(visualElements, language).map(converterService.toApiVisualElement)
-    val license       = converterService.toApiLicense(searchableConcept.license)
+    val license       = converterService.toApiLicense(searchableConcept.license, language)
     val copyright     = searchableConcept
       .copyright
       .map(c => {

draft-api/src/main/scala/no/ndla/draftapi/controller/DraftController.scala

@@ -32,6 +32,7 @@ import sttp.tapir.*
 import sttp.tapir.server.ServerEndpoint
 
 import scala.util.{Failure, Success, Try}
+import no.ndla.language.Language.findByLanguageOrBestEffort
 
 class DraftController(using
     readService: ReadService,
@@ -433,8 +434,9 @@ class DraftController(using
     .errorOut(errorOutputsFor(401, 403))
     .out(jsonBody[Seq[LicenseDTO]])
     .in(filterNot)
+    .in(language)
     .in(filter)
-    .serverLogicPure { case (filterNot, filter) =>
+    .serverLogicPure { case (filterNot, language, filter) =>
       val licenses: Seq[LicenseDefinition] = mapping
         .License
         .getLicenses
@@ -447,7 +449,15 @@ class DraftController(using
           case _                                                 => false
         }
 
-      licenses.map(x => LicenseDTO(x.license.toString, Option(x.description), x.url)).asRight
+      licenses
+        .map(x =>
+          LicenseDTO(
+            x.license.toString,
+            Option(x.description),
+            findByLanguageOrBestEffort(x.url, language.code).map(_.url),
+          )
+        )
+        .asRight
     }
 
   def newArticle: ServerEndpoint[Any, Eff] = endpoint

draft-api/src/main/scala/no/ndla/draftapi/service/ConverterService.scala

@@ -306,7 +306,7 @@ class ConverterService(using
           status = toApiStatus(article.status),
           title = title,
           content = articleContent,
-          copyright = article.copyright.map(toApiCopyright),
+          copyright = article.copyright.map(lic => toApiCopyright(lic, language)),
           tags = tags,
           requiredLibraries = article.requiredLibraries.map(toApiRequiredLibrary),
           visualElement = visualElement,
@@ -377,11 +377,11 @@ class ConverterService(using
     )
   }
 
-  private def toApiCopyright(copyright: common.draft.DraftCopyright): DraftCopyrightDTO = {
+  private def toApiCopyright(copyright: common.draft.DraftCopyright, language: String): DraftCopyrightDTO = {
     model
       .api
       .DraftCopyrightDTO(
-        copyright.license.map(toApiLicense),
+        copyright.license.map(lic => toApiLicense(lic, language)),
         copyright.origin,
         copyright.creators.map(_.toApi),
         copyright.processors.map(_.toApi),
@@ -392,9 +392,15 @@ class ConverterService(using
       )
   }
 
-  def toApiLicense(shortLicense: String): commonApi.LicenseDTO = {
+  def toApiLicense(shortLicense: String, language: String): commonApi.LicenseDTO = {
     getLicense(shortLicense)
-      .map(l => commonApi.LicenseDTO(l.license.toString, Option(l.description), l.url))
+      .map(l =>
+        commonApi.LicenseDTO(
+          l.license.toString,
+          Option(l.description),
+          findByLanguageOrBestEffort(l.url, language).map(_.url),
+        )
+      )
       .getOrElse(commonApi.LicenseDTO("unknown", None, None))
   }
 

draft-api/src/test/scala/no/ndla/draftapi/controller/DraftControllerTest.scala

@@ -27,6 +27,7 @@ import org.mockito.Mockito.{reset, times, verify, when}
 import sttp.client3.quick.*
 
 import scala.util.{Failure, Success}
+import no.ndla.language.Language.findByLanguageOrBestEffort
 
 class DraftControllerTest extends UnitSuite with TestEnvironment with TapirControllerTest {
   override val controller: DraftController                   = new DraftController
@@ -78,7 +79,13 @@ class DraftControllerTest extends UnitSuite with TestEnvironment with TapirContr
   test("That GET /licenses/ with filter sat to by only returns creative common licenses") {
     val creativeCommonlicenses = getLicenses
       .filter(_.license.toString.startsWith("by"))
-      .map(l => commonApi.LicenseDTO(l.license.toString, Option(l.description), l.url))
+      .map(l =>
+        commonApi.LicenseDTO(
+          l.license.toString,
+          Option(l.description),
+          findByLanguageOrBestEffort(l.url, "en").map(_.url),
+        )
+      )
       .toSet
 
     val resp =
@@ -89,8 +96,16 @@ class DraftControllerTest extends UnitSuite with TestEnvironment with TapirContr
   }
 
   test("That GET /licenses/ with filter not specified returns all licenses") {
-    val allLicenses = getLicenses.map(l => commonApi.LicenseDTO(l.license.toString, Option(l.description), l.url)).toSet
-    val resp        = simpleHttpClient.send(quickRequest.get(uri"http://localhost:$serverPort/draft-api/v1/drafts/licenses"))
+    val allLicenses = getLicenses
+      .map(l =>
+        commonApi.LicenseDTO(
+          l.license.toString,
+          Option(l.description),
+          findByLanguageOrBestEffort(l.url, "en").map(_.url),
+        )
+      )
+      .toSet
+    val resp = simpleHttpClient.send(quickRequest.get(uri"http://localhost:$serverPort/draft-api/v1/drafts/licenses"))
     resp.code.code should be(200)
     val convertedBody = CirceUtil.unsafeParseAs[Set[commonApi.LicenseDTO]](resp.body)
     convertedBody should equal(allLicenses)

draft-api/src/test/scala/no/ndla/draftapi/service/ConverterServiceTest.scala

@@ -38,11 +38,11 @@ class ConverterServiceTest extends UnitSuite with TestEnvironment {
   val service: ConverterService                                         = new ConverterService
 
   test("toApiLicense defaults to unknown if the license was not found") {
-    service.toApiLicense("invalid") should equal(commonApi.LicenseDTO("unknown", None, None))
+    service.toApiLicense("invalid", "en") should equal(commonApi.LicenseDTO("unknown", None, None))
   }
 
   test("toApiLicense converts a short license string to a license object with description and url") {
-    service.toApiLicense(CC_BY.toString) should equal(
+    service.toApiLicense(CC_BY.toString, "en") should equal(
       commonApi.LicenseDTO(
         CC_BY.toString,
         Some("Creative Commons Attribution 4.0 International"),