changed creator and license holder from str to Entity

Author: BernhardKoschicek

openatlas/api/endpoints/file.py

@@ -84,8 +84,9 @@ def get() -> Response | tuple[Any, int]:
                     filename=path.stem,
                     _external=True),
                 'license': license_,
-                'creator': ', '.join(entity.creator),
-                'licenseHolder': ', '.join(entity.license_holder),
+                'creator': ', '.join([rh.name for rh in entity.creator]),
+                'licenseHolder': ', '.join([
+                    rh.name for rh in entity.license_holder]),
                 'publicShareable': entity.public,
                 'IIIFManifest': iiif_manifest}
         if parser['download']:
@@ -128,8 +129,9 @@ def get_file_dict(
             'id': entity.id,
             'title': entity.name,
             'license': get_license_name(entity),
-            'creator': ', '.join(entity.creator),
-            'licenseHolder': ', '.join(entity.license_holder),
+            'creator': ', '.join([rh.name for rh in entity.creator]),
+            'licenseHolder': ', '.join([
+                rh.name for rh in entity.license_holder]),
             'publicShareable': entity.public,
             'mimetype': mime_type,
             'url': url}

openatlas/api/endpoints/iiif.py

@@ -11,8 +11,8 @@
 
 from openatlas.api.endpoints.parser import Parser
 from openatlas.api.resources.api_entity import ApiEntity
-from openatlas.api.resources.error import DisplayFileNotFoundError, \
-    IIIFMetadataNotFound
+from openatlas.api.resources.error import (DisplayFileNotFoundError,
+                                           IIIFMetadataNotFound)
 from openatlas.api.resources.parser import iiif
 from openatlas.api.resources.util import get_license_name, get_license_url
 from openatlas.display.util import check_iiif_file_exist
@@ -167,7 +167,7 @@ def build_annotation(
                 "@type": "dctypes:Text",
                 "chars": annotation.text,
                 "format": "text/plain"}
-            ],
+                ],
             "on": {
                 "@type": "oa:SpecificResource",
                 "full": url_for(
@@ -246,7 +246,8 @@ def get_manifest_version_2(id_: int, parser: Parser) -> dict[str, Any]:
             raise DisplayFileNotFoundError
         license_ = get_license_name(entity)
         if entity.license_holder:
-            license_ = f'{license_}, {', '.join(entity.license_holder)}'
+            license_ = f'{license_}, {', '.join([
+                lh.name for lh in entity.license_holder])}'
         metadata = []
         if references := entity.get_links('P67', inverse=True):
             for reference in references:
@@ -259,9 +260,10 @@ def get_manifest_version_2(id_: int, parser: Parser) -> dict[str, Any]:
                     "label": _('source').capitalize(),
                     "value": f"<a href={url} target=_blank>{text}</a>"})
         if entity.creator:
-            metadata.append({
-                "label": _('creator').capitalize(),
-                "value": entity.creator})
+            for c in entity.creator:
+                metadata.append({
+                    "label": _('creator').capitalize(),
+                    "value": c.name})
         see_also = []
         if related_entities := entity.get_links('P67'):
             for related_entity in related_entities:

openatlas/api/external/arche.py

@@ -142,16 +142,26 @@ def add_arche_file_metadata_to_graph(
     if metadata.license:
         graph.add((subject_uri, ACDH.hasLicense, URIRef(metadata.license)))
 
+    # todo: add role, person or organization
     if metadata.licensors:
-        ensure_person_exist(graph, metadata.licensors)
-        for uri in create_uri(metadata.licensors):
+        names = [e.name for e in metadata.licensors]
+        ensure_person_exist(graph, names)
+        for uri in create_uri(names):
             graph.add((subject_uri, ACDH.hasLicensor, uri))
 
     if metadata.rights_holders:
-        ensure_person_exist(graph, metadata.rights_holders)
-        for uri in create_uri(metadata.rights_holders):
+        names = [e.name for e in metadata.rights_holders]
+        ensure_person_exist(graph, names)
+        for uri in create_uri(names):
             graph.add((subject_uri, ACDH.hasRightsHolder, uri))
 
+    if metadata.creators:
+        names = [e.name for e in metadata.creators]
+        ensure_person_exist(graph, names)
+        for uri in create_uri(names):
+            graph.add((subject_uri, ACDH.hasCreator, uri))
+
+
     if metadata.is_part_of:
         graph.add((subject_uri, ACDH.isPartOf, URIRef(metadata.is_part_of)))
 
@@ -200,11 +210,6 @@ def add_arche_file_metadata_to_graph(
             ACDH.hasBinarySize,
             Literal(metadata.binary_size, datatype=XSD.integer)))
 
-    if metadata.creators:
-        ensure_person_exist(graph, metadata.creators)
-        for uri in create_uri(metadata.creators):
-            graph.add((subject_uri, ACDH.hasCreator, uri))
-
     if metadata.metadata_creators:
         ensure_person_exist(graph, metadata.metadata_creators)
         for uri in create_uri(metadata.metadata_creators):

openatlas/api/external/arche_class.py

@@ -14,9 +14,10 @@ class ArcheFileMetadata:
     titles: list[tuple[str, str]]
     depositors: str | list[str] | None = None
     license: str | None = None
-    licensors: str | list[str] | None = None
+    licensors: list[Entity] | None = None
+    rights_holders: list[Entity] | None = None
+    creators: list[Entity] | None = None
     metadata_creators: str | list[str] | None = None
-    rights_holders: str | list[str] | None = None
     is_part_of: str | None = None
     accepted_date: str | None = None
     curators: str | list[str] | None = None
@@ -26,7 +27,6 @@ class ArcheFileMetadata:
     related_disciplines: str | list[str] | None = None
     transfer_date: str | None = None
     binary_size: int | None = None
-    creators: str | list[str] | None = None
     actors: list[dict[str, str | list[str]]] | None = None
     spatial_coverages: list[dict[str, str | list[str]]] | None = None
     has_publications: list[tuple[Entity, str]] | None = None

openatlas/api/formats/linked_places.py

@@ -91,8 +91,8 @@ def get_lp_file(
         '@id': url_for('api.entity', id_=file.id, _external=True),
         'title': file.name,
         'license': get_license_name(file),
-        'creator': ', '.join(file.creator),
-        'licenseHolder': ', '.join(file.license_holder),
+        'creator': ', '.join([rh.name for rh in file.creator]),
+        'licenseHolder': ', '.join([rh.name for rh in file.creator]),
         'publicShareable': file.public,
         'mimetype': mime_type,
         'mainImage': main_image,

openatlas/api/formats/loud.py

@@ -58,15 +58,15 @@ def get_digital_object_details(
         for license_holder in entity.license_holder:
             digital_object.update({
                 'right_held_by': [{
-                    '_label': license_holder,
+                    '_label': license_holder.name,
                     'type': 'Actor'}]})
     if entity.creator:
         for creator in entity.creator:
             digital_object.update({'created_by': [{
                 '_label': f'Creation of {entity.name}',
                 'type': 'Creation',
                 'carried_out_by': [{
-                    '_label': creator,
+                    '_label': creator.name,
                     'type': 'Actor'}]}]})
     if license_ := get_license_type(entity):
         subject_to: dict[str, Any] = {

openatlas/api/formats/presentation_view.py

@@ -61,8 +61,9 @@ def get_file_dict(
         'id': link.domain.id,
         'title': link.domain.name,
         'license': get_license_name(link.domain),
-        'creator': ', '.join(link.domain.creator),
-        'licenseHolder': ', '.join(link.domain.license_holder),
+        'creator': ', '.join([rh.name for rh in link.domain.creator]),
+        'licenseHolder': ', '.join([
+            rh.name for rh in link.domain.license_holder]),
         'publicShareable': link.domain.public,
         'mimetype': mime_type,
         'fromSuperEntity': root,

openatlas/api/formats/subunits.py

@@ -145,8 +145,9 @@ def get_file(data: dict[str, Any]) -> list[dict[str, Any]]:
             'name': link.domain.name,
             'fileName': path.name if path else None,
             'license': get_license_name(link.domain),
-            'creator': ', '.join(link.domain.creator),
-            'licenseHolder': ', '.join(link.domain.license_holder),
+            'creator': ', '.join([rh.name for rh in link.domain.creator]),
+            'licenseHolder': ', '.join([
+                rh.name for rh in link.domain.license_holder]),
             'publicShareable': link.domain.public,
             'source': link.domain.description or None})
     if data['parser']['format'] == 'xml':

openatlas/display/display.py

@@ -230,7 +230,7 @@ def get_buttons(
                                 _('move entities'),
                                 url_for('change_type', id_=self.entity.id)))
                 case 'remove_reference_system_class' \
-                        if not items and is_authorized('manager'):
+                    if not items and is_authorized('manager'):
                     buttons.append(
                         button(
                             _('remove'),
@@ -414,15 +414,19 @@ def add_data(self) -> None:
         self.data.update(self.get_type_data())
         for name, attribute in self.entity.class_.attributes.items():
             if name in ['creator', 'license_holder']:
+                link_ = link(
+                    f'+ {name}',
+                    url_for(
+                        'rights_holder_insert',
+                        origin_id=self.entity.id,
+                        relation=name))
+                html = f'{link_}'
                 if value := getattr(self.entity, name):
-                    link_ = link(
-                        f'+ {name}',
-                        url_for(
-                            'rights_holder_insert',
-                            origin_id=self.entity.id,
-                            relation=name))
-                    html = f'{link_}<br>{str('<br>'.join(value))}'
-                    self.data[attribute['label']] = html
+                    entries = [
+                        link(rh, url_for('rights_holder_view', id_=rh.id))
+                        for rh in value]
+                    html += f'<br>{str('<br>'.join(entries))}'
+                self.data[attribute['label']] = html
             if name in ['example_id', 'public', 'resolver_url', 'website_url']:
                 if value := getattr(self.entity, name):
                     if isinstance(value, bool):

openatlas/models/entity.py

@@ -73,10 +73,13 @@ def __init__(self, data: dict[str, Any]) -> None:
             self.license_holder = []
             if self.id in g.file_info:
                 self.public = g.file_info[self.id]['public']
-                self.creator = [
-                    c.name for c in g.file_info[self.id]['creator']]
-                self.license_holder = [
-                    lh.name for lh in g.file_info[self.id]['license_holder']]
+                # todo: remove old code if everything works
+                # self.creator = [
+                #    c.name for c in g.file_info[self.id]['creator']]
+                # self.license_holder = [
+                #    lh.name for lh in g.file_info[self.id]['license_holder']]
+                self.creator = g.file_info[self.id]['creator']
+                self.license_holder = g.file_info[self.id]['license_holder']
         if self.class_.name == 'reference_system' and 'website_url' in data:
             self.website_url = data['website_url']
             self.resolver_url = data['resolver_url']