Handle multi language input fields in web ui

web/api/lib/worker/enricher/enricher.ex

@@ -1,9 +1,11 @@
 defmodule Api.Worker.Enricher.Enricher do
   alias Api.Worker.Enricher.Preprocess
+  alias Api.Worker.Enricher.I18NFieldConverter
   alias Api.Worker.Enricher.Gazetteer
   alias Api.Worker.Enricher.Relations
   alias Api.Worker.Enricher.Labels
   alias Api.Worker.Enricher.Children
+
   require Logger
 
   def process(changes, project, get_for_id, configuration) do
@@ -17,6 +19,7 @@ defmodule Api.Worker.Enricher.Enricher do
 
   defp process_change(change = %{ deleted: true }, _project, _get_for_id, _configuration), do: change
   defp process_change(change, project, get_for_id, configuration) do
+
     try do
       change
       |> Preprocess.add_sort_field
@@ -25,6 +28,7 @@ defmodule Api.Worker.Enricher.Enricher do
       |> Relations.expand(get_for_id)
       |> Labels.add_labels(configuration)
       |> put_in([:doc, :project], project)
+      |> I18NFieldConverter.convert(configuration)
     rescue
       error ->
         Logger.error "Enrichment failed for resource #{change.doc.resource.id}: "

web/api/lib/worker/enricher/i18n_field_converter.ex

@@ -0,0 +1,95 @@
+defmodule Api.Worker.Enricher.I18NFieldConverter do
+
+  alias Api.Core.CategoryTreeList
+  alias Api.Worker.Enricher.Utils
+
+  defp convert_string(resource, field_name, field_value) when not is_map(field_value) do  # this is from legacy project then
+    put_in(resource, [field_name], %{ "unspecifiedLanguage" => field_value })
+  end
+  defp convert_string resource, _field_name, _field_value do
+    resource
+  end
+
+  defp convert_string_array_item(item) when not is_map(item) do # legacy
+    %{ "unspecifiedLanguage" => item }
+  end
+  defp convert_string_array_item item do
+    item
+  end
+
+  defp convert_string_array(resource, field_name, field_value) do
+    put_in(resource, [field_name], Enum.map(field_value, &convert_string_array_item/1))
+  end
+
+  defp convert_dating_source(dating_item_source) when not is_map(dating_item_source) do # from legacy project
+    # TODO review, here we use keyword, above we use string
+    %{ unspecifiedLanguage: dating_item_source }
+  end
+  defp convert_dating_source dating_item_source do
+    dating_item_source
+  end
+
+  defp convert_dating_item dating_item do
+    put_in(dating_item.source, convert_dating_source(dating_item.source))
+  end
+
+  defp convert_dating resource, field_name, field_value do
+    put_in(resource, [field_name], Enum.map(field_value, &convert_dating_item/1))
+  end
+
+  defp convert_dimension_measurement_comment(dimension_measurement_comment) when not is_map(dimension_measurement_comment) do # legacy project
+    %{ unspecifiedLanguage: dimension_measurement_comment }
+  end
+  defp convert_dimension_measurement_comment dimension_measurement_comment do
+    dimension_measurement_comment
+  end
+
+  defp convert_dimension_item dimension_item do
+    put_in(dimension_item.measurementComment, convert_dimension_measurement_comment(dimension_item.measurementComment))
+  end
+
+  defp convert_dimension resource, field_name, field_value do
+    put_in(resource, [field_name], Enum.map(field_value, &convert_dimension_item/1))
+  end
+
+  defp convert_resource_field category_definition_groups do
+    fn {field_name, field_value}, resource ->
+      field_definition = Utils.get_field_definition category_definition_groups, Atom.to_string(field_name)
+
+      if is_nil(field_definition[:inputType]) do
+        resource
+      else
+        cond do
+          field_definition.inputType == "dating" ->
+            convert_dating resource, field_name, field_value
+
+          field_definition.inputType == "dimension" ->
+            convert_dimension resource, field_name, field_value
+
+          field_definition.inputType == "multiInput"
+            or field_definition.inputType == "simpleMultiInput" ->
+              convert_string_array resource, field_name, field_value
+
+          field_definition.inputType == "input"
+              or field_definition.inputType == "simpleInput"
+              or field_definition.inputType == "text" ->
+            convert_string resource, field_name, field_value
+
+          true ->
+            resource
+        end
+      end
+    end
+  end
+
+  def convert_category change = %{ doc: %{ resource: resource } }, category_definition_groups do
+    resource = Enum.reduce(resource, resource, convert_resource_field(category_definition_groups))
+    put_in(change.doc.resource, resource)
+  end
+
+  def convert change, configuration do
+    name = change.doc.resource.category.name # TODO review category.name, maybe document the expectation
+    category_definition = CategoryTreeList.find_by_name(name, configuration)
+    convert_category change, category_definition.groups
+  end
+end

web/api/lib/worker/enricher/labels.ex

@@ -1,7 +1,8 @@
 defmodule Api.Worker.Enricher.Labels do
   require Logger
-  alias Api.Core.Utils
+  alias Api.Core
   alias Api.Core.CategoryTreeList
+  alias Api.Worker.Enricher.Utils
 
   @core_properties [:id, :identifier, :shortDescription, :geometry, :geometry_wgs84, :georeference,
     :gazId, :parentId, :featureVectors, :license, :shortName, :originalFilename]
@@ -18,7 +19,7 @@ defmodule Api.Worker.Enricher.Labels do
     else
       Enum.reduce(resource, %{}, add_labels_to_field(category_definition, configuration))
       |> Enum.into(%{})
-      |> Utils.atomize
+      |> Core.Utils.atomize
     end
   end
 
@@ -49,7 +50,7 @@ defmodule Api.Worker.Enricher.Labels do
     cond do
       Enum.member?(@core_properties, field_name) -> put_in(resource, [field_name], field_value)
 
-      get_field_definition(category_definition, field_name) == nil ->
+      Utils.get_field_definition(category_definition.groups, field_name) == nil ->
         Logger.warn "Label not found: field \"#{field_name}\" of category \"#{category_definition.name}\""
         resource
       true ->
@@ -94,7 +95,7 @@ defmodule Api.Worker.Enricher.Labels do
 
   defp get_label(_, nil, _), do: nil
   defp get_label(field_name, field_value, category_definition) do
-     field_definition = get_field_definition(category_definition, field_name)
+     field_definition = Utils.get_field_definition(category_definition.groups, field_name)
      cond do
       is_nil(field_definition) -> raise "No field definition found for field #{field_name} of category "
         <> category_definition.name
@@ -105,16 +106,6 @@ defmodule Api.Worker.Enricher.Labels do
      end
   end
 
-  defp get_field_definition(category_definition, field_name) do
-    group = Enum.find(category_definition.groups, &get_field_definition_from_group(&1, field_name))
-    get_field_definition_from_group(group, field_name)
-  end
-
-  defp get_field_definition_from_group(%{ fields: fields }, field_name) do
-    Enum.find(fields, fn field -> field.name == field_name end)
-  end
-  defp get_field_definition_from_group(_, _), do: nil
-
   defp get_labels_object(%{ "labels" => labels }), do: labels
   defp get_labels_object(_), do: %{}
 end

web/api/lib/worker/enricher/utils.ex

@@ -0,0 +1,13 @@
+defmodule Api.Worker.Enricher.Utils do
+
+  # TODO extract
+  def get_field_definition(category_definition_groups, field_name) do
+    group = Enum.find(category_definition_groups, &get_field_definition_from_group(&1, field_name))
+    get_field_definition_from_group(group, field_name)
+  end
+
+  defp get_field_definition_from_group(%{ fields: fields }, field_name) do
+    Enum.find(fields, fn field -> field.name == field_name end)
+  end
+  defp get_field_definition_from_group(_, _), do: nil
+end

web/api/test/unit/worker/enricher/i18n_field_converter_test.exs

@@ -0,0 +1,116 @@
+defmodule Api.Worker.Enricher.I18NFieldConverterTest do
+
+  use ExUnit.Case, async: true
+  use Plug.Test
+  alias Api.Worker.Enricher.I18NFieldConverter
+
+  test "convert input, simpleInput, multiInput, simpleMultiInput" do
+    change = %{
+        doc: %{
+          resource: %{
+            category: %{
+              name: "Trench"
+            },
+            legacyInputField: "hallo",
+            inputField: %{ "de" => "hallo-de" },
+            simpleInputField: "hallo-simple-input",
+            legacyTextField: "hallo\ntext",
+            textField: %{ "de" => "hallo-de\ntext" },
+            legacyMultiInputField: ["a", "b"],
+            multiInputField: [%{ "de" => "a" }, %{ "de" => "b" }],
+            simpleMultiInputField: ["a", "b"]
+          }
+        },
+      }
+    category_definition_groups =
+      [
+        %{
+          fields: [
+            %{ inputType: "input", name: "legacyInputField" },
+            %{ inputType: "input", name: "inputField" },
+            %{ inputType: "simpleInput", name: "simpleInputField" },
+            %{ inputType: "text", name: "legacyTextField" },
+            %{ inputType: "text", name: "textField" },
+            %{ inputType: "multiInput", name: "legacyMultiInputField" },
+            %{ inputType: "multiInput", name: "multiInputField" },
+            %{ inputType: "simpleMultiInput", name: "simpleMultiInputField" }
+          ]
+        }
+      ]
+
+    resource = (I18NFieldConverter.convert_category change, category_definition_groups).doc.resource
+
+    assert %{ "unspecifiedLanguage" => "hallo" } == resource.legacyInputField
+    assert %{ "de" => "hallo-de" } == resource.inputField
+    assert %{ "unspecifiedLanguage" => "hallo-simple-input" } == resource.simpleInputField
+    assert %{ "unspecifiedLanguage" => "hallo\ntext" } == resource.legacyTextField
+    assert %{ "de" => "hallo-de\ntext" } == resource.textField
+    assert [%{ "unspecifiedLanguage" => "a" }, %{ "unspecifiedLanguage" => "b" }] == resource.legacyMultiInputField
+    assert [%{ "de" => "a" }, %{ "de" => "b" }] == resource.multiInputField
+    assert [%{ "unspecifiedLanguage" => "a" }, %{ "unspecifiedLanguage" => "b" }] == resource.simpleMultiInputField
+  end
+
+  test "convert dating" do
+    category_definition_groups =
+      [
+        %{
+          fields: [
+            %{ inputType: "dating", name: "datingField" },
+            %{ inputType: "dating", name: "legacyDatingField" },
+          ]
+        }
+      ]
+    change = %{
+        doc: %{
+          resource: %{
+            category: %{
+              name: "Trench"
+            },
+            datingField: [%{
+              source: %{de: "Eine Datierung", en: "A Dating"}
+            }],
+            legacyDatingField: [%{
+              source: "Eine Datierung"
+            }]
+          }
+        },
+      }
+
+    resource = (I18NFieldConverter.convert_category change, category_definition_groups).doc.resource
+
+    assert %{ de: "Eine Datierung", en: "A Dating" } == (List.first resource.datingField).source
+    assert %{ unspecifiedLanguage: "Eine Datierung" } == (List.first resource.legacyDatingField).source
+  end
+
+  test "convert dimension" do
+    category_definition_groups =
+      [
+        %{
+          fields: [
+            %{ inputType: "dimension", name: "dimensionField" },
+            %{ inputType: "dimension", name: "legacyDimensionField" },
+          ]
+        }
+      ]
+    change = %{
+        doc: %{
+          resource: %{
+            category: %{
+              name: "Trench"
+            },
+            dimensionField: [%{
+              measurementComment: %{de: "Eine Abmessung", en: "A dimension"}
+            }],
+            legacyDimensionField: [%{
+              measurementComment: "Eine Abmessung"
+            }]
+          }
+        },
+      }
+
+    resource = (I18NFieldConverter.convert_category change, category_definition_groups).doc.resource
+
+    assert %{ de: "Eine Abmessung", en: "A dimension" } == (List.first resource.dimensionField).measurementComment
+    assert %{ unspecifiedLanguage: "Eine Abmessung" } == (List.first resource.legacyDimensionField).measurementComment
+  end
+end

web/ui/src/api/document.ts

@@ -1,7 +1,7 @@
 import { Geometry } from 'geojson';
 import { isObject, to } from 'tsfun';
-import { Dating, Dimension, Literature, OptionalRange } from 'idai-field-core';
-import { getLabel } from '../shared/languages';
+import { Dating, Dimension, Literature, OptionalRange, I18N } from 'idai-field-core';
+import { getLabel, getTranslation } from '../shared/languages';
 import { ResultDocument } from './result';
 
 
@@ -22,9 +22,9 @@ export interface ChangeEvent {
 export interface Resource {
     category: LabeledValue;
     id: string;
-    identifier: string;
-    shortDescription: string;
-    shortName?: string;
+    identifier: I18N.String;
+    shortDescription: I18N.String;
+    shortName?: I18N.String;
     groups: FieldGroup[];
     geometry: Geometry;
     childrenCount: number;
@@ -116,7 +116,7 @@ export function getDocumentImages(document: Document): ResultDocument[]|undefine
     const group: FieldGroup = document.resource.groups
         .find(group => group.fields.map(to('name')).includes('isDepictedIn'));
 
-    return group
+    return getTranslation(group
         ? group.fields.find((rel: Field) => rel.name === 'isDepictedIn')?.targets
-        : undefined;
+        : undefined as undefined);
 }

web/ui/src/api/result.ts

@@ -1,5 +1,5 @@
 import { Geometry } from 'geojson';
-import { ImageGeoreference } from 'idai-field-core';
+import { ImageGeoreference, I18N } from 'idai-field-core';
 import { ChangeEvent, I18nString, LabeledValue } from './document';
 
 export interface Result {
@@ -21,9 +21,9 @@ export interface ResultDocument {
 export interface ResultResource {
     category: LabeledValue;
     id: string;
-    identifier: string;
-    shortDescription: string;
-    shortName?: string;
+    identifier: I18N.String;
+    shortDescription: I18N.String;
+    shortName?: I18N.String;
     childrenCount: number;
     parentId: string;
     grandparentId: string;