This page is for discussion of ways to provide enhanced support for managing metadata terms, and annotating resources, with a new design. Given that a new design may/may not be able to support all desirable features simultaneously,  the discussion should include design  options and prioritization of features if/when conflicts occur. Similarly, some advanced functionality may be useful to contemplate in terms of design but might not be something that gets implemented.

Goals:

The redesign should retain the benefits of the current design (e.g. ability to add custom terms to a space, provenance regarding the origin of specific annotations, ability to add widgets for input/display, send notices of changes to the message bus) and makes it easier to do things such as :

• add some or all terms from existing third-party vocabularies
• provide definitions/best practice guidance associated with each term
• allow metadata to be marked as recommended and/or indicate which metadata will be required during publishing, specified directly by space admins and/or based on available/preferred/default registered repositories)
• organize metadata entries by vocabulary and/or alphabetically and/or by purpose
• clearly distinguish extracted (and therefore ~redundant) metadata from provided values
• allow some extracted terms to be propagated through publishing (right now only provided metadata is published, but space admins or repositories may want to keep high value/hard to reproduce extracted metadata as well)
• emphasize the term/definition/value for metadata and de-emphasize/hide by default the provenance of who entered it when
• support metadata that references external URLs/identifiers and/or internal identifiers (e.g. with Collections/Datasets/Folders/Files)
• enable metadata values to be edited
• deletions/edits of metadata should be captured in provenance
• manage JSON-LD context(s) at the space level (i.e. assuring that all instances of a label refer to the same predicate, all predicates have one label, even as space admins make changes, and handling metadata entered via the API if/when it has conflicting context info)
• support the exchange of contexts/metadata 'profiles' between spaces/ the use of metadata profiles from one space in a read-only manner from another (i.e. one space controls the label/URL/type/definition info)
• support (entry/display) for structured metadata values (e.g. json/json-ld)
• support cardinality constraints (number, order?)

Current Design:

• Individual metadata entries are stored as Mongo documents and are associated with a file or dataset (comments say metadata can be attached to collections but this is not implemented in the GUI) and a JSON-LD context.
• Entries through the GUI usually result in one term/value per entry, but some types (e.g. geospatial) produce more than one term/value/a json value that is displayed with structure. Entries through the API can include multiple term/values which can only be deleted as a unit.
• JSON-LD contexts are stored as another document collection and can be referenced by multiple metadata documents, but these contexts are not aligned with the space metadata choices (e.g. existing metadata docs and contexts are not updated with changes to a space's choices for metadata terms. That only affects the terms available as input options in the GUI)
• Metadata management allows space admins to add/edit/delete entries starting form an instance default list controlled by the overall sys/instance admins. Entries have a label, a formal URI predicate (which together form the context entry. If a URI is not given, a unique URI is generated), and a type which controls the input widget used for entry (but not display?). Some types connect to a 'third party' earth cube geosemantics server to retrieve controlled vocabulary lists or to invoke a geo name to coordinates mapping service, etc. Simple internal types include string and date. Metadata entries do not include definitions. 
• Metadata definitions are separate docs associated with a space

Possible Designs

Space-based Managed metadata doc

• primary artifact is a json doc of the current metadata values referencing a space json-ld context and being associated by id with a dataset/folder/file. CRUD operations from the GUI or API would update this document via a service. Log docs would capture updates (documenting not only new adds, but edits, deletes as well).
• Context/definitions would be maintained, one per space, as part of a doc containing all current terms (each term has label/URI and definition, type, and any cardinality, recommended/required info, etc.) 

How it would work:

• • Metadata mgmt GUI would edit context/definition doc, doc would include any new fields such as term definition, cardinality, etc. as needed. JSON-LD context would be generated from this doc when needed
  • Metadata entry would use this doc from the global instance or the space the entry is in to populate the add metadata box. (with sharing on, a decision would be needed as to whether to allow annotation based on one spaces info or to allow annotation in terms of other spaces). Type/definition, cardinality and other info would be used to enhance the GUI.
  • Display of existing terms would be changed ~per the GUi redesign and mockups done by Michael Iannaccone - presenting metadata values by term alphabetically or by namespace/category, with a widget to expand the provenance of the entry (which would include any trail of edits).
  • Edits to a metadata definition would tie to entries via the formal predicate, e.g. for an entry for 'method'/http://example.org/method, a change of the label for that term to "Experimental Method" would show in the display, whereas the attempt to create a new term "method": http:otherorg/method" would either be blocked due to the label conflict until the original label was updated or would trigger a confirm that the existing metadata should be updated.
  • Changes to the space metadata definitions would not be tracked (could be tracked via update docs as with metadata values)
  • Metadata added through the API would be matched to existing terms (required to be json-ld, the predicate would be matched to the space context and that label used (i.e. the api would not generate an alternate label for existing space definitions). New terms seen in incoming API requests would be added to the context doc as 'view-only' terms - this allows the API and extractors to add any terms they use. Admins could add additional info (a definition, type, etc. to such generated definitions and/or allow them to appear as add choices in the GUI.
  • Movement of items between spaces would be handled as though the API had been used to enter the metadata as part of the transfer assuming no space sharing. With sharing on, the decision of how to handle annotation would have to handle being removed from one of the spaces)
  • Metadata edits would invke the same type-specific entry widget as adding a new value
  • Cardinality of 1 would remove an option from the add menu if a value exists
  • A new type of metadata would be a link/relationship and there would be a widget(s) that would recognize URLs and internal IDs/ID URLs and make them live links (URL might just become live, but a urn:<id> value would get replaced by a dataset name or path and be a link to the page for that item. Other GUIs could be added (e.g. once bulk ops exist, one could select 2 items and then create a link between them, etc.) - these could populate the same metadata field, i.e. relationships would not be a separate type/managed separately. (It would be possible to do the lookup from Clowder URN to item via javascript, which would enable them to be displayed by name in other apps as well if desired - this is what is done for ORCID IDs where we share a javascript across Clowder and repositories.)
  • Required/recommended metadata would be identified by color/icon in the add metadata list (perhaps required fields could be shown with empty values and could be edited)
  • Metadata mgmt GUI could be extended to allow viewing/selection from other vocabs (e.g. Dublin Core, from an external website (in their format or a json conversion we or geosemantic server maintain), or another space profile (e.g. reading that space's context/definition doc and listing the entries for selection - perhaps sortable by label/URI/type/or category, etc.). Once selected, there would be no live link to the original vocab/profile.