Implement controlled list manager and reference datatype #10541

.coveragerc

@@ -9,7 +9,6 @@ omit =
     */urls.py
     */wsgi.py
     */celery.py
-    */__init__.py
 
 data_file = coverage/python/.coverage
 

.git-blame-ignore-revs

@@ -5,8 +5,12 @@
 eea27d316c5ff975556e15ccd4c11d7c393dd95c
 8de09526329685ee4d80c816c3475a66b19d46e9
 e3d8197d5a7d1f03ed125fe2f47d4fbef0913404
-9740c846eda0cc067f49d7abffdcb1a93fe3e0a9
 eff6710e8b44faef5a628b0ea1373cd99cb47e9e
+# Reformatting of 7.6 features under dev (2024)
+9740c846eda0cc067f49d7abffdcb1a93fe3e0a9
+# Reformatting of 8.0 features under dev (2024)
+0a4e7a54dc9795756208a5356bd92a3a11d467f2
+1d7d411aba53e32f6be2e998c8b9b22bba72e56f
 # Relevant subset of git log --grep black
 9b7e30d4499cb02dec6d17c7c99f9a7087fcdd47
 b959f1139a1d789e6c116d43d8be7daa0baa6075

arches/app/datatypes/base.py

@@ -517,3 +517,11 @@ def pre_structure_tile_data(self, tile, nodeid, **kwargs):
         Adds properties to a tile necessary for some clients, but not essential to the tile
         """
         pass
+
+    def validate_node(self, node):
+        """
+        Confirms a node is properly configured to collect data.
+        If improperly configured, this method should raise
+        a GraphValidationError
+        """
+        pass

arches/app/datatypes/datatypes.py

@@ -2423,7 +2423,7 @@ def get_localized_option_text(self, node, option_id, return_lang=False):
                 return get_localized_value(option["text"], return_lang=return_lang)
         raise Exception(
             _(
-                "No domain option found for option id {0}, in node conifg: {1}".format(
+                "No domain option found for option id {0}, in node config: {1}".format(
                     option_id, node.config["options"]
                 )
             )
@@ -3272,3 +3272,123 @@ def get_value_from_jsonld(json_ld_node):
             return
     except IndexError as e:
         return
+
+
+class ReferenceDataType(BaseDataType):
+    def validate(
+        self,
+        value,
+        row_number=None,
+        source="",
+        node=None,
+        nodeid=None,
+        strict=False,
+        **kwargs,
+    ):
+        errors = []
+        title = _("Invalid Reference Datatype Value")
+        if value is None:
+            return errors
+
+        if type(value) == list and len(value):
+            for reference in value:
+                if "uri" in reference and len(reference["uri"]):
+                    pass
+                else:
+                    errors.append(
+                        {
+                            "type": "ERROR",
+                            "message": _(
+                                "Reference objects require a 'uri' property and corresponding value"
+                            ),
+                            "title": title,
+                        }
+                    )
+                if "labels" in reference:
+                    pref_label_languages = []
+                    for label in reference["labels"]:
+                        if not all(
+                            key in label
+                            for key in ("id", "value", "language_id", "valuetype_id")
+                        ):
+                            errors.append(
+                                {
+                                    "type": "ERROR",
+                                    "message": _(
+                                        "Reference labels require properties: id(uuid), value(string), language_id(e.g. 'en'), and valuetype_id(e.g. 'prefLabel')"
+                                    ),
+                                    "title": title,
+                                }
+                            )
+                        if label["valuetype_id"] == "prefLabel":
+                            pref_label_languages.append(label["language_id"])
+
+                    if len(set(pref_label_languages)) < len(pref_label_languages):
+                        errors.append(
+                            {
+                                "type": "ERROR",
+                                "message": _(
+                                    "A reference can have only one prefLabel per language"
+                                ),
+                                "title": title,
+                            }
+                        )
+        else:
+            errors.append(
+                {
+                    "type": "ERROR",
+                    "message": _("Reference value must be a list of reference objects"),
+                    "title": title,
+                }
+            )
+        return errors
+
+    def transform_value_for_tile(self, value, **kwargs):
+        return value
+
+    def clean(self, tile, nodeid):
+        super().clean(tile, nodeid)
+        if tile.data[nodeid] == []:
+            tile.data[nodeid] = None
+
+    def transform_export_values(self, value, *args, **kwargs):
+        return ",".join(value)
+
+    def get_display_value(self, tile, node, **kwargs):
+        labels = []
+        requested_language = kwargs.pop("language", None)
+        current_language = requested_language or get_language()
+        for item in self.get_tile_data(tile)[str(node.nodeid)]:
+            for label in item["labels"]:
+                if (
+                    label["language_id"] == current_language
+                    and label["valuetype_id"] == "prefLabel"
+                ):
+                    labels.append(label.get("value", ""))
+        return ", ".join(labels)
+
+    def collects_multiple_values(self):
+        return True
+
+    def default_es_mapping(self):
+        return {
+            "properties": {
+                "uri": {"type": "keyword"},
+                "id": {"type": "keyword"},
+                "labels": {
+                    "properties": {},
+                },
+            }
+        }
+
+    def validate_node(self, node):
+        from arches.app.models.graph import (
+            GraphValidationError,
+        )  # prevent circular import
+
+        try:
+            uuid.UUID(node.config["controlledList"])
+        except (TypeError, KeyError):
+            raise GraphValidationError(
+                _("A reference datatype node requires a controlled list")
+            )

arches/app/media/js/utils/create-vue-application.js

@@ -7,25 +7,12 @@ import StyleClass from 'primevue/styleclass';
 import ToastService from 'primevue/toastservice';
 import Tooltip from 'primevue/tooltip';
 
-import Aura from '@primevue/themes/aura';
-
 import { createApp } from 'vue';
 import { createGettext } from "vue3-gettext";
 
 import arches from 'arches';
 
-const DEFAULT_THEME = {
-    theme: {
-        preset: Aura,
-        options: {
-            prefix: 'p',
-            darkModeSelector: 'system',
-            cssLayer: false
-        }
-    }
-};
-
-export default async function createVueApplication(vueComponent, themeConfiguration) {
+export default async function createVueApplication(vueComponent) {
     /**
      * This wrapper allows us to maintain a level of control inside arches-core
      * over Vue apps. For instance this allows us to abstract i18n setup/config
@@ -53,7 +40,7 @@ export default async function createVueApplication(vueComponent, themeConfigurat
 
         const app = createApp(vueComponent);
 
-        app.use(PrimeVue, themeConfiguration || DEFAULT_THEME);
+        app.use(PrimeVue);
         app.use(gettext);
         app.use(ConfirmationService);
         app.use(DialogService);

arches/app/media/js/viewmodels/reference-select.js

@@ -0,0 +1,167 @@
+define([
+    'jquery',
+    'knockout',
+    'knockout-mapping',
+    'arches',
+    'viewmodels/widget',
+], function($, ko, koMapping, arches, WidgetViewModel) {
+    var NAME_LOOKUP = {};
+    var ReferenceSelectViewModel = function(params) {
+        var self = this;
+
+        params.configKeys = ['placeholder'];
+        this.multiple = !!ko.unwrap(params.node.config.multiValue);
+        this.displayName = ko.observable('');
+        this.selectionValue = ko.observable([]); // formatted version of this.value that select2 can use
+        this.activeLanguage = arches.activeLanguage;
+
+        WidgetViewModel.apply(this, [params]);
+
+        this.getPrefLabel = function(labels){
+            return koMapping.toJS(labels)?.find(
+                label => label.language_id === arches.activeLanguage && label.valuetype_id === 'prefLabel'
+            )?.value || arches.translations.unlabeledItem;
+        }; 
+
+        this.isLabel = function (value) {
+            return ['prefLabel', 'altLabel'].includes(value.valuetype_id);
+        };
+
+        this.displayValue = ko.computed(function() {
+            const val = self.value();
+            let name = null;
+            if (val) {
+                name = val.map(item => self.getPrefLabel(item.labels)).join(", ");
+            }
+            return name;
+        });
+
+        this.valueAndSelectionDiffer = function(value, selection) {
+            if (!(ko.unwrap(value) instanceof Array)) {
+                return true;
+            }
+            const valueUris = ko.unwrap(value).map(val=>ko.unwrap(val.uri));
+            return JSON.stringify(selection) !== JSON.stringify(valueUris);
+        };
+
+        this.selectionValue.subscribe(selection => {
+            if (selection) {
+                if (!(selection instanceof Array)) { selection = [selection]; }
+                if (self.valueAndSelectionDiffer(self.value, selection)) {
+                    const newItem = selection.map(uri => {
+                        return {
+                            "labels": NAME_LOOKUP[uri].labels,
+                            "listid": NAME_LOOKUP[uri]["listid"],
+                            "uri": uri
+                        };
+                    });
+                    self.value(newItem);
+                }
+            } else {
+                self.value(null);
+            }
+        });
+
+        this.value.subscribe(val => {
+            if (val?.length) {
+                self.selectionValue(val.map(item=>ko.unwrap(item.uri)));
+            } else {
+                self.selectionValue(null);
+            }
+        });
+
+        this.select2Config = {
+            value: self.selectionValue,
+            clickBubble: true,
+            multiple: this.multiple,
+            closeOnSelect: true,
+            placeholder: self.placeholder,
+            allowClear: true,
+            ajax: {
+                url: arches.urls.controlled_list(ko.unwrap(params.node.config.controlledList)),
+                dataType: 'json',
+                quietMillis: 250,
+                data: function(requestParams) {
+
+                    return {
+                        flat: true
+                    };
+                },
+                processResults: function(data) {
+                    const items = data.items; 
+                    items.forEach(item => {
+                        item["listid"] = item.id;
+                        item.id = item.uri;
+                        item.disabled = item.guide;
+                        item.labels = item.values.filter(val => self.isLabel(val));
+                    });
+                    return {
+                        "results": items,
+                        "pagination": {
+                            "more": false
+                        }
+                    };
+                }
+            },
+            templateResult: function(item) {
+                let indentation = '';
+                for (let i = 0; i < item.depth; i++) {
+                    indentation += '&nbsp;&nbsp;&nbsp;&nbsp;';
+                }
+
+                if (item.uri) {
+                    const text = self.getPrefLabel(item.labels) || arches.translations.searching + '...';
+                    NAME_LOOKUP[item.uri] = {"prefLabel": text, "labels": item.labels, "listid": item.controlled_list_id};
+                    return indentation + text;
+                }
+            },
+            templateSelection: function(item) {
+                if (!item.uri) { // option has a different shape when coming from initSelection vs templateResult
+                    return item.text; 
+                } else {
+                    return NAME_LOOKUP[item.uri]["prefLabel"];
+                }
+            },
+            escapeMarkup: function(markup) { return markup; },
+            initComplete: false,
+            initSelection: function(el, callback) {
+
+                const setSelectionData = function(data) {
+                    const valueData = koMapping.toJS(self.value());
+                    valueData.forEach(function(value) {
+                        NAME_LOOKUP[value.uri] = {
+                                "prefLabel": self.getPrefLabel(value.labels),
+                                "labels": value.labels,
+                                "listid": value.listid 
+                            };
+                    });
+
+                    if(!self.select2Config.initComplete){
+                        valueData.forEach(function(data) {
+                            const option = new Option(
+                                self.getPrefLabel(data.labels),
+                                data.uri,
+                                true, 
+                                true
+                            );
+                            $(el).append(option);
+                            self.selectionValue().push(data.uri);
+                        });
+                        self.select2Config.initComplete = true;
+                    }
+                    callback(valueData);
+                };
+
+                if (self.value()?.length) {
+                    setSelectionData();
+                } else {
+                    callback([]);
+                }
+
+            }
+        };
+
+    };
+
+    return ReferenceSelectViewModel;
+});