Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,82 +1,186 @@
-import os
+import datetime
+from urllib.parse import quote
+
+import requests
 from lxml import etree
+import streamlit as st
 
 # =====================================================================
-# CONFIGURATION
+# Namespaces
 # =====================================================================
 
-MODS_DIR = "mods_records"          # Ordner mit MODS-Kapiteln
-OUTPUT_XML = "crossref.xml"
-
-# Namespaces
+CROSSREF_NS = "http://www.crossref.org/schema/4.4.2"
+XSI_NS = "http://www.w3.org/2001/XMLSchema-instance"
 JATS_NS = "http://www.ncbi.nlm.nih.gov/JATS1"
 XML_NS = "http://www.w3.org/XML/1998/namespace"
+AI_NS = "http://www.crossref.org/AccessIndicators.xsd"
+MODS_NS = "http://www.loc.gov/mods/v3"
 XML_LANG = f"{{{XML_NS}}}lang"
 
-NSMAP = {
-    "jats": JATS_NS,
-    "xlink": "http://www.w3.org/1999/xlink",
-}
 
 # =====================================================================
-# TEXT CLEANING: Entfernt nur Silbentrennungsartefakte (Option 1)
+# Hilfsfunktionen
 # =====================================================================
 
-def clean_text(text):
-    """Bereinigt Soft-Hyphen, PDF-Trennungen, ersetzt aber nichts anderes."""
+def clean_text(text: str) -> str:
+    """Bereinigt Soft-Hyphen, PDF-Trennungen, Zeilenumbrüche – sonst unverändert."""
     if not text:
         return ""
     return (
         text.replace("\u00AD", "")   # Soft Hyphen
             .replace("­", "")       # alternative Soft Hyphen
-            .replace("\n", " ")     # Zeilenumbrüche entfernen
+            .replace("\n", " ")
     ).strip()
 
 
-# =====================================================================
-# XML HELPERS
-# =====================================================================
-
 def get_text(node, xpath, ns):
-    """Safely extract text content using an xpath."""
     elem = node.find(xpath, namespaces=ns)
     return clean_text(elem.text) if elem is not None and elem.text else ""
 
 
-# =====================================================================
-# PARSE A SINGLE MODS FILE INTO <content_item>
-# =====================================================================
+def build_dora_mods_url(base_url: str, repo_code: str, object_or_url: str) -> str:
+    """
+    Erzeugt MODS-URL aus einer DORA-ID wie 'wsl:41900'.
+    Wenn schon eine http(s)-URL übergeben wird, wird sie unverändert zurückgegeben.
+    Standardmäßig wird admin.dora.lib4ri.ch für den Download verwendet.
+    """
+    if object_or_url.startswith("http://") or object_or_url.startswith("https://"):
+        return object_or_url
+    encoded = quote(object_or_url, safe="")
+    base_url = base_url.rstrip("/")
+    return f"{base_url}/{repo_code}/islandora/object/{encoded}/datastream/MODS/download"
+
+
+def build_persistent_url(repo_code: str, object_id: str) -> str:
+    """
+    Erzeugt die neue persistente URL im Format:
+    https://www.dora.lib4ri.ch/{repo}/item/{id}
+    """
+    # Force public domain for persistent links
+    public_base = "https://www.dora.lib4ri.ch"
+    return f"{public_base}/{repo_code}/item/{object_id}"
+
+
+def fetch_mods_xml(mods_url: str) -> etree._Element:
+    """Lädt eine MODS-Datei von einer URL und gibt den Root-Element zurück."""
+    resp = requests.get(mods_url)
+    resp.raise_for_status()
+    # Use recover=True to handle malformed XML (e.g. unescaped HTML in notes)
+    parser = etree.XMLParser(recover=True, remove_blank_text=True)
+    return etree.fromstring(resp.content, parser=parser)
+
+
+def parse_book_mods(book_root: etree._Element, repo_base_url: str) -> dict:
+    """Extrahiert Buch-Metadaten aus einem Buch-MODS-Record."""
+    ns = book_root.nsmap.copy()
+    if "mods" not in ns:
+        ns["mods"] = MODS_NS
+
+    # Buchtitel
+    book_title = get_text(book_root, ".//mods:titleInfo/mods:title", ns)
+
+    # Serie (falls vorhanden)
+    series_title = get_text(
+        book_root,
+        ".//mods:relatedItem[@type='series']/mods:titleInfo/mods:title",
+        ns
+    )
+    series_issn = get_text(
+        book_root,
+        ".//mods:relatedItem[@type='series']/mods:identifier[@type='issn']",
+        ns
+    )
 
-def mods_to_content_item(mods_path):
-    tree = etree.parse(mods_path)
-    root = tree.getroot()
-    ns = root.nsmap
-
-    # --------------------------------------------------------
-    # Extract metadata
-    # --------------------------------------------------------
-    title = get_text(root, ".//mods:titleInfo/mods:title", ns)
-    doi = get_text(root, ".//mods:identifier[@type='doi']", ns)
-    year = get_text(root, ".//mods:originInfo/mods:dateIssued", ns)
-    abstract = get_text(root, ".//mods:abstract", ns)
-
-    first_page = get_text(root, ".//mods:extent[@unit='page']/mods:start", ns)
-    last_page = get_text(root, ".//mods:extent[@unit='page']/mods:end", ns)
-
-    # --------------------------------------------------------
-    # Extract authors
-    # --------------------------------------------------------
+    # Herausgeber (editor) & Autoren (author - für Monographs)
+    editors = []
     authors = []
-    for name in root.findall(".//mods:name[@type='personal']", ns):
+    for name in book_root.findall(".//mods:name[@type='personal']", ns):
+        role = name.find("mods:role/mods:roleTerm", ns)
+        if role is not None:
+            role_text = role.text.lower()
+            if role_text == "editor":
+                given = get_text(name, "mods:namePart[@type='given']", ns)
+                family = get_text(name, "mods:namePart[@type='family']", ns)
+                editors.append({"given": given, "family": family})
+            elif role_text == "author":
+                given = get_text(name, "mods:namePart[@type='given']", ns)
+                family = get_text(name, "mods:namePart[@type='family']", ns)
+                # Authors at book level (for Monographs)
+                authors.append({"given": given, "family": family})
+
+    # Publisher
+    publisher_name = get_text(book_root, ".//mods:originInfo/mods:publisher", ns)
+
+    # Publikationsjahr (online)
+    pub_year = get_text(
+        book_root,
+        ".//mods:originInfo/mods:dateIssued[@encoding='w3cdtf'][@keyDate='yes']",
+        ns
+    )
+    if not pub_year:
+        pub_year = get_text(book_root, ".//mods:originInfo/mods:dateIssued", ns)
+
+    # DOI & URI
+    book_doi = get_text(book_root, ".//mods:identifier[@type='doi']", ns)
+    
+    # Persistent URL format
+    # Example: https://www.dora.lib4ri.ch/psi/item/psi:84778
+    book_id = get_text(book_root, ".//mods:identifier[@type='local']", ns)
+    if not book_id:
+        # Fallback to building ID from DOI if possible, or use a placeholder
+        book_id = book_doi.split("/")[-1] if book_doi else ""
+    
+    # Get repo_code from the ID itself (e.g. 'psi' from 'psi:84778')
+    current_repo = book_id.split(":")[0] if ":" in book_id else repo_base_url.split("/")[-1]
+    book_resource = build_persistent_url(current_repo, book_id) if book_id else ""
+
+    # ISBN / noisbn
+    isbn_val = get_text(book_root, ".//mods:identifier[@type='isbn']", ns)
+    noisbn_reason = "archive_volume" if not isbn_val else None
+
+    # Default to current date if not found/provided
+    today = datetime.date.today()
+
+    meta = {
+        "book_title": book_title,
+        "series_title": series_title or "",
+        "series_issn": series_issn or "",
+        "publisher_name": publisher_name,
+        "pub_year": int(pub_year[:4]) if pub_year else today.year,
+        "pub_month": str(today.month),
+        "pub_day": str(today.day),
+        "noisbn_reason": noisbn_reason or "",
+        "book_doi": book_doi or "",
+        "book_resource": book_resource or "",
+        "report_number": "", 
+        "editors": editors,
+        "authors": authors,
+    }
+    return meta
+
+
+def mods_to_content_item(mods_root: etree._Element, repo_base_url: str) -> tuple[etree._Element, int]:
+    """Wandelt ein Kapitel-MODS in ein Crossref <content_item> um."""
+    ns = mods_root.nsmap.copy()
+    if "mods" not in ns:
+        ns["mods"] = MODS_NS
+
+    title = get_text(mods_root, ".//mods:titleInfo/mods:title", ns)
+    doi = get_text(mods_root, ".//mods:identifier[@type='doi']", ns)
+    year = get_text(mods_root, ".//mods:originInfo/mods:dateIssued", ns)
+    abstract = get_text(mods_root, ".//mods:abstract", ns)
+    first_page = get_text(mods_root, ".//mods:extent[@unit='page']/mods:start", ns)
+    last_page = get_text(mods_root, ".//mods:extent[@unit='page']/mods:end", ns)
+
+    # Autoren
+    authors = []
+    for name in mods_root.findall(".//mods:name[@type='personal']", ns):
         role = name.find("mods:role/mods:roleTerm", ns)
         if role is not None and role.text == "author":
             given = get_text(name, "mods:namePart[@type='given']", ns)
             family = get_text(name, "mods:namePart[@type='family']", ns)
             authors.append((given, family))
 
-    # --------------------------------------------------------
-    # Build <content_item>
-    # --------------------------------------------------------
     ci = etree.Element("content_item", component_type="chapter")
 
     # Contributors
@@ -91,7 +195,7 @@ def mods_to_content_item(mods_path):
         etree.SubElement(pn, "given_name").text = given
         etree.SubElement(pn, "surname").text = family
 
-    # Titles
+    # Titel
     titles = etree.SubElement(ci, "titles")
     etree.SubElement(titles, "title").text = title
 
@@ -100,11 +204,12 @@ def mods_to_content_item(mods_path):
     p = etree.SubElement(jats_abs, f"{{{JATS_NS}}}p")
     p.text = abstract
 
-    # Publication date
+    # Publikationsdatum
     pub = etree.SubElement(ci, "publication_date", media_type="online")
-    etree.SubElement(pub, "year").text = year
+    if year:
+        etree.SubElement(pub, "year").text = year[:4]
 
-    # Pages
+    # Seiten
     if first_page or last_page:
         pages = etree.SubElement(ci, "pages")
         if first_page:
@@ -112,128 +217,741 @@ def mods_to_content_item(mods_path):
         if last_page:
             etree.SubElement(pages, "last_page").text = last_page
 
-    # DOI block
+    # License information (AccessIndicators) - must come before doi_data
+    ai_program = etree.SubElement(ci, f"{{{AI_NS}}}program", name="AccessIndicators")
+    license_ref = etree.SubElement(ai_program, f"{{{AI_NS}}}license_ref")
+    license_ref.text = "https://creativecommons.org/licenses/by/4.0/"
+    license_ref.set("applies_to", "vor")
+    license_ref.set("start_date", year[:4] + "-01-01" if year else "")
+
+    # DOI
     if doi:
         doi_data = etree.SubElement(ci, "doi_data")
         etree.SubElement(doi_data, "doi").text = doi
-
-        doi_tail = doi.split(":")[-1]
+        
+        # New persistent URL format
+        chapter_id = doi.split("/")[-1] if "/" in doi else doi
+        repo_code_extracted = chapter_id.split(":")[0] if ":" in chapter_id else repo_base_url.split("/")[-1]
         etree.SubElement(
             doi_data,
             "resource"
-        ).text = f"https://www.dora.lib4ri.ch/wsl/islandora/object/{doi_tail}"
+        ).text = build_persistent_url(repo_code_extracted, chapter_id)
 
-    # Sorting helper: use first_page numeric value if available
+    # Sortierung nach first_page
     try:
         page_number = int(first_page)
-    except:
+    except Exception:
         page_number = 999999
 
     return ci, page_number
 
 
-# =====================================================================
-# MAIN: Assemble full Crossref XML
-# =====================================================================
-
-def assemble_crossref(mods_dir, output_path):
-
-    # Root <book>
-    book = etree.Element(
-        "book",
-        book_type="edited_book",
-        nsmap=NSMAP
+def build_doi_batch_xml(
+    book_meta: dict,
+    depositor_meta: dict,
+    chapter_items: list[tuple[etree._Element, int]],
+    book_type: str = "edited_book",
+) -> bytes:
+    """
+    Erzeugt Crossref-<doi_batch>.
+    book_type: 'edited_book', 'monograph', oder 'report-paper' (custom internal flag).
+    """
+    doi_batch = etree.Element(
+        "doi_batch",
+        nsmap={
+            None: CROSSREF_NS,
+            "xsi": XSI_NS,
+            "jats": JATS_NS,
+            "ai": AI_NS,
+        }
+    )
+    doi_batch.set("version", "4.4.2")
+    doi_batch.set(
+        f"{{{XSI_NS}}}schemaLocation",
+        "http://www.crossref.org/schema/4.4.2 "
+        "http://www.crossref.org/schema/deposit/crossref4.4.2.xsd"
     )
 
-    # ----------------------------------------------------------------
-    # FIXED BOOK METADATA (Editors, Publisher, Series, DOI)
-    # ----------------------------------------------------------------
-    metadata = etree.XML("""
-      <book_series_metadata>
-        <series_metadata>
-          <titles><title>WSL Berichte</title></titles>
-          <issn>22963456</issn>
-        </series_metadata>
-
-        <contributors>
-          <person_name sequence="first" contributor_role="editor">
-            <given_name>Alexander</given_name>
-            <surname>Bast</surname>
-          </person_name>
-          <person_name sequence="additional" contributor_role="editor">
-            <given_name>Michael</given_name>
-            <surname>Bründl</surname>
-          </person_name>
-          <person_name sequence="additional" contributor_role="editor">
-            <given_name>Marcia</given_name>
-            <surname>Phillips</surname>
-          </person_name>
-        </contributors>
-
-        <titles>
-          <title>WSL research programme Climate Change Impacts on Alpine Mass Movements - CCAMM project report</title>
-        </titles>
-
-        <publication_date media_type="online">
-          <month>12</month>
-          <day>08</day>
-          <year>2025</year>
-        </publication_date>
-
-        <noisbn reason="archive_volume"/>
-
-        <publisher>
-          <publisher_name>Swiss Federal Institute for Forest, Snow and Landscape Research, WSL</publisher_name>
-        </publisher>
-
-        <doi_data>
-          <doi>10.55419/wsl:41891</doi>
-          <resource>https://www.dora.lib4ri.ch/wsl/islandora/object/wsl:41891</resource>
-        </doi_data>
-      </book_series_metadata>
-    """, parser=etree.XMLParser(remove_blank_text=True))
-
-    book.append(metadata)
-
-    # ----------------------------------------------------------------
-    # Process ALL MODS chapters
-    # ----------------------------------------------------------------
-    chapters = []
-
-    for filename in sorted(os.listdir(mods_dir)):
-        if filename.lower().endswith(".xml"):
-            path = os.path.join(mods_dir, filename)
-            print(f"Processing MODS file: {path}")
-            ci, page_number = mods_to_content_item(path)
-            chapters.append((page_number, ci))
-
-    # Sort by first page
-    chapters.sort(key=lambda x: x[0])
-
-    # Append all chapter blocks
-    for _, chapter in chapters:
-        book.append(chapter)
-
-    # ----------------------------------------------------------------
-    # WRITE OUTPUT FILE
-    # ----------------------------------------------------------------
+    # HEAD
+    head = etree.SubElement(doi_batch, "head")
+    etree.SubElement(head, "doi_batch_id").text = depositor_meta["doi_batch_id"]
+
+    ts = datetime.datetime.utcnow().strftime("%Y%m%d%H%M%S")
+    etree.SubElement(head, "timestamp").text = ts
+
+    depositor = etree.SubElement(head, "depositor")
+    etree.SubElement(depositor, "depositor_name").text = depositor_meta["depositor_name"]
+    etree.SubElement(depositor, "email_address").text = depositor_meta["depositor_email"]
+
+    etree.SubElement(head, "registrant").text = depositor_meta["registrant"]
+
+    # BODY
+    body = etree.SubElement(doi_batch, "body")
+
+    # Determine structure based on book_type
+    if book_type == "report-paper":
+        report_paper = etree.SubElement(body, "report-paper")
+        # Decide between report-paper_metadata and report-paper_series_metadata
+        has_series = (book_meta.get("series_title") or book_meta.get("series_issn"))
+        if has_series:
+            metadata_root = etree.SubElement(report_paper, "report-paper_series_metadata")
+            # 1. SERIES METADATA (Required if using report-paper_series_metadata)
+            series_metadata = etree.SubElement(metadata_root, "series_metadata")
+            if book_meta.get("series_title"):
+                stitles = etree.SubElement(series_metadata, "titles")
+                etree.SubElement(stitles, "title").text = book_meta["series_title"]
+            if book_meta.get("series_issn"):
+                etree.SubElement(series_metadata, "issn").text = book_meta["series_issn"]
+        else:
+            metadata_root = etree.SubElement(report_paper, "report-paper_metadata")
+    else:
+        # BOOK STRUCTURE (Edited Book or Monograph)
+        book = etree.SubElement(body, "book", book_type=book_type)
+        # If it's a monograph or edited book, we often use book_series_metadata or book_metadata
+        # For simplicity and to match the schema, let's stick to book_series_metadata if series exists
+        if book_meta.get("series_title") or book_meta.get("series_issn"):
+            metadata_root = etree.SubElement(book, "book_series_metadata")
+            series_metadata = etree.SubElement(metadata_root, "series_metadata")
+            if book_meta.get("series_title"):
+                stitles = etree.SubElement(series_metadata, "titles")
+                etree.SubElement(stitles, "title").text = book_meta["series_title"]
+            if book_meta.get("series_issn"):
+                etree.SubElement(series_metadata, "issn").text = book_meta["series_issn"]
+        else:
+            metadata_root = etree.SubElement(book, "book_metadata")
+
+    # 2. CONTRIBUTORS
+    # Contributors (Editors or Authors)
+    contributors_list = []
+    role = "editor"
+    if book_type in ["monograph", "report-paper"]:
+        contributors_list = book_meta.get("authors", [])
+        role = "author"
+    else:
+        contributors_list = book_meta.get("editors", [])
+        role = "editor"
+
+    if contributors_list:
+        contribs = etree.SubElement(metadata_root, "contributors")
+        for idx, person in enumerate(contributors_list):
+            pn = etree.SubElement(
+                contribs,
+                "person_name",
+                sequence="first" if idx == 0 else "additional",
+                contributor_role=role
+            )
+            etree.SubElement(pn, "given_name").text = person["given"]
+            etree.SubElement(pn, "surname").text = person["family"]
+
+    # 3. TITLES
+    titles = etree.SubElement(metadata_root, "titles")
+    etree.SubElement(titles, "title").text = book_meta["book_title"]
+
+    # 4. PUBLICATION DATE
+    pub = etree.SubElement(metadata_root, "publication_date", media_type="online")
+    if book_meta.get("pub_month") and book_meta.get("pub_month").strip():
+        try:
+            etree.SubElement(pub, "month").text = f"{int(book_meta['pub_month']):02d}"
+        except ValueError:
+            pass
+    if book_meta.get("pub_day") and book_meta.get("pub_day").strip():
+        try:
+            etree.SubElement(pub, "day").text = f"{int(book_meta['pub_day']):02d}"
+        except ValueError:
+            pass
+    etree.SubElement(pub, "year").text = str(book_meta["pub_year"])
+
+    # 5. NOISBN (only for books)
+    if book_type != "report-paper":
+        if book_meta.get("noisbn_reason"):
+            etree.SubElement(metadata_root, "noisbn", reason=book_meta["noisbn_reason"])
+
+    # 6. PUBLISHER
+    pub_node = etree.SubElement(metadata_root, "publisher")
+    etree.SubElement(pub_node, "publisher_name").text = book_meta["publisher_name"]
+
+    # 7. PUBLISHER ITEM (Report Number) - Only for report-paper
+    if book_type == "report-paper" and book_meta.get("report_number"):
+        publisher_item = etree.SubElement(metadata_root, "publisher_item")
+        etree.SubElement(publisher_item, "identifier", id_type="report-number").text = book_meta["report_number"]
+
+    # 8. DOI DATA
+    if book_meta.get("book_doi") or book_meta.get("book_resource"):
+        doi_data = etree.SubElement(metadata_root, "doi_data")
+        if book_meta.get("book_doi"):
+            etree.SubElement(doi_data, "doi").text = book_meta["book_doi"]
+        if book_meta.get("book_resource"):
+            etree.SubElement(doi_data, "resource").text = book_meta["book_resource"]
+
+    # 10. COMPONENTS (Chapters)
+    # Sort and append chapters
+    if book_type != "report-paper": 
+         # For books, chapters are children of <book> node
+         # But wait, in the loop below we append to 'book' variable.
+         # 'book' variable is only defined if book_type != 'report-paper'.
+         pass
+    
+    chapter_items.sort(key=lambda x: x[1])
+    for ci, _page in chapter_items:
+        if book_type == "report-paper":
+            report_paper.append(ci)
+        else:
+            book.append(ci)
+
     xml_bytes = etree.tostring(
-        book,
+        doi_batch,
         pretty_print=True,
         encoding="UTF-8",
         xml_declaration=True
     )
+    return xml_bytes
+
+
+class CrossrefSchemaResolver(etree.Resolver):
+    """Custom resolver to fetch included XSD schemas from Crossref and W3C."""
+
+    def resolve(self, url, id, context):
+        # Map of known schema locations
+        schema_map = {
+            'mathml3-content.xsd': 'http://www.w3.org/Math/XMLSchema/mathml3/mathml3-content.xsd',
+            'mathml3-presentation.xsd': 'http://www.w3.org/Math/XMLSchema/mathml3/mathml3-presentation.xsd',
+            'mathml3-strict-content.xsd': 'http://www.w3.org/Math/XMLSchema/mathml3/mathml3-strict-content.xsd',
+            'mathml3-common.xsd': 'http://www.w3.org/Math/XMLSchema/mathml3/mathml3-common.xsd',
+        }
+
+        # Determine the URL to fetch
+        if url.startswith("http://") or url.startswith("https://"):
+            schema_url = url
+        elif url in schema_map:
+            schema_url = schema_map[url]
+        else:
+            schema_url = f"https://www.crossref.org/schemas/{url}"
+
+        try:
+            response = requests.get(schema_url, timeout=15)
+            response.raise_for_status()
+            return self.resolve_string(response.content, context)
+        except Exception:
+            # If fetching fails, return None to use default behavior
+            return None
+
+
+def validate_crossref_xml(xml_bytes: bytes) -> tuple[bool, list[str]]:
+    """
+    Validiert Crossref XML gegen das offizielle XSD Schema.
+
+    Returns:
+        tuple: (is_valid, error_messages)
+    """
+    errors = []
+
+    try:
+        # Parse XML
+        doc = etree.fromstring(xml_bytes)
 
-    with open(output_path, "wb") as f:
-        f.write(xml_bytes)
+        # Crossref XSD Schema URL
+        schema_url = "https://www.crossref.org/schemas/crossref4.4.2.xsd"
 
-    print("Crossref XML successfully written to:", output_path)
+        # Download schema (mit Caching in Session State für Performance)
+        if 'crossref_schema' not in st.session_state:
+            try:
+                # Create parser with custom resolver
+                parser = etree.XMLParser()
+                parser.resolvers.add(CrossrefSchemaResolver())
+
+                # Download main schema
+                schema_resp = requests.get(schema_url, timeout=30)
+                schema_resp.raise_for_status()
+
+                # Parse schema with resolver
+                schema_doc = etree.fromstring(schema_resp.content, parser)
+                st.session_state.crossref_schema = etree.XMLSchema(schema_doc)
+            except Exception as e:
+                errors.append(f"Fehler beim Laden des XSD Schemas: {e}")
+                return False, errors
+
+        schema = st.session_state.crossref_schema
+
+        # Validierung
+        is_valid = schema.validate(doc)
+
+        if not is_valid:
+            for error in schema.error_log:
+                errors.append(f"Zeile {error.line}: {error.message}")
+
+        return is_valid, errors
+
+    except etree.XMLSyntaxError as e:
+        errors.append(f"XML Syntax Fehler: {e}")
+        return False, errors
+    except Exception as e:
+        errors.append(f"Unerwarteter Fehler: {e}")
+        return False, errors
 
 
 # =====================================================================
-# RUN SCRIPT
+# REPOSITORY CONFIGURATION
 # =====================================================================
 
+REPO_CONFIG = {
+    "wsl": {
+        "publisher": "Swiss Federal Institute for Forest, Snow and Landscape Research, WSL",
+        "registrant": "Swiss Federal Institute for Forest, Snow and Landscape Research, WSL",
+        "prefix": "10.55419",
+        "role": "wslx"
+    },
+    "psi": {
+        "publisher": "Paul Scherrer Institute, PSI",
+        "registrant": "Paul Scherrer Institute, PSI",
+        "prefix": "10.55402",
+        "role": "psit"
+    },
+    "empa": {
+        "publisher": "Swiss Federal Laboratories for Materials Science and Technology, Empa",
+        "registrant": "Swiss Federal Laboratories for Materials Science and Technology, Empa",
+        "prefix": "10.55368",
+        "role": "empa"
+    },
+    "eawag": {
+        "publisher": "Swiss Federal Institute of Aquatic Science and Technology, Eawag", 
+        "registrant": "Swiss Federal Institute of Aquatic Science and Technology, Eawag",
+        "prefix": "10.55408",
+        "role": "eawa"
+    }
+}
+
+def main():
+    st.title("Crossref XML Generator/Uploader")
+
+    st.markdown(
+        "Dieses Dashboard lädt **MODS-Metadaten direkt aus DORA** mittels IDs "
+        "und erzeugt ein vollständiges Crossref-XML (`doi_batch`) für Reports (WSL Berichte und PSI Berichte) und Edited Books/Conference Proceedings."
+    )
+
+    st.subheader("Konfiguration & Quelle")
+
+    col_config, col_source = st.columns(2)
+    
+    with col_config:
+        st.markdown("#### Verbindung & Typ")
+        base_url = st.text_input(
+            "DORA Basis-URL",
+            value="https://admin.dora.lib4ri.ch"
+        )
+        
+        repo_list = list(REPO_CONFIG.keys())
+        repo_code = st.selectbox(
+            "Repository-Code",
+            options=repo_list,
+            index=0, 
+            format_func=lambda x: x.upper()
+        )
+        
+        repo_config = REPO_CONFIG[repo_code]
+        repo_base_url = f"{base_url.rstrip('/')}/{repo_code}"
+        
+        pub_type = st.radio(
+            "Publikationstyp",
+            ("Edited Book", "Report (WSL, Monograph Series)", "Report (Eawag, PSI, Paper Series)"),
+            horizontal=False
+        )
+    
+    # Mapping auf Crossref book_type / report type
+    cr_book_type = "edited_book"
+    if "Monograph" in pub_type:
+        cr_book_type = "monograph"
+    elif "Paper Series" in pub_type:
+        cr_book_type = "report-paper"
+
+    with col_source:
+        st.markdown("#### MODS-Quelle")
+        # Dynamic default ID based on repo
+        default_id = "41891"
+        if repo_code == "psi":
+            default_id = "84057"
+        
+        book_id_or_url = st.text_input(
+            "DORA-ID oder MODS-URL",
+            value=f"{repo_code}:{default_id}",
+            help="Beispiel: wsl:41900 oder komplette URL"
+        )
+        
+        st.write("") # Spacer
+        if st.button("Metadaten laden", type="primary"):
+            try:
+                mods_url = build_dora_mods_url(base_url, repo_code, book_id_or_url)
+                st.info(f"Lade MODS von: {mods_url}")
+                book_root = fetch_mods_xml(mods_url)
+                meta = parse_book_mods(book_root, repo_base_url)
+                
+                # --- Attempt to extract report number from MODS ---
+                ns = book_root.nsmap.copy()
+                if "mods" not in ns:
+                    ns["mods"] = MODS_NS
+                report_num = get_text(book_root, ".//mods:identifier[@type='report number']", ns)
+                if not report_num:
+                     report_num = get_text(book_root, ".//mods:identifier[@type='report-number']", ns)
+                
+                if not report_num:
+                     # Check <note type="report number">
+                     report_num = get_text(book_root, ".//mods:note[@type='report number']", ns)
+    
+                if report_num:
+                     meta["report_number"] = report_num
+                     st.info(f"Report Number gefunden: {report_num}")
+                # --------------------------------------------------
+    
+                # Update flat fields in session state for widgets
+                for k, v in meta.items():
+                    if k in ["book_title", "series_title", "series_issn", "publisher_name", 
+                            "pub_year", "pub_month", "pub_day", "noisbn_reason", 
+                            "book_doi", "book_resource", "report_number"]:
+                        st.session_state[k] = v
+                    st.session_state.book_meta[k] = v
+                
+                # Special handling for persons text area
+                if cr_book_type in ["monograph", "report-paper"]:
+                    current_list = meta.get("authors", [])
+                else:
+                    current_list = meta.get("editors", [])
+                st.session_state["persons_input"] = "\n".join(f"{e['given']};{e['family']}" for e in current_list)
+
+                st.session_state.book_meta_loaded = True
+                st.success("Metadaten erfolgreich geladen.")
+                st.rerun()
+            except Exception as e:
+                st.error(f"Fehler beim Laden der MODS: {e}")
+                import traceback
+                st.text(traceback.format_exc())
+
+    # Session State Init Logic (unchanged but placed after UI definition for clarity in reading flow, strictly it runs before inputs generally)
+    if "book_meta_loaded" not in st.session_state:
+        st.session_state.book_meta_loaded = False
+
+    # Current date for defaults
+    today = datetime.date.today()
+
+    # Initialize session state keys for widgets if not present
+    if "book_title" not in st.session_state:
+        st.session_state.book_title = ""
+    if "series_title" not in st.session_state:
+        st.session_state.series_title = ""
+    if "series_issn" not in st.session_state:
+        st.session_state.series_issn = ""
+    if "publisher_name" not in st.session_state:
+        st.session_state.publisher_name = repo_config["publisher"]
+    if "pub_year" not in st.session_state:
+        st.session_state.pub_year = today.year
+    if "pub_month" not in st.session_state:
+        st.session_state.pub_month = str(today.month)
+    if "pub_day" not in st.session_state:
+        st.session_state.pub_day = str(today.day)
+    if "noisbn_reason" not in st.session_state:
+        st.session_state.noisbn_reason = ""
+    if "book_doi" not in st.session_state:
+        st.session_state.book_doi = ""
+    if "book_resource" not in st.session_state:
+        st.session_state.book_resource = ""
+    if "report_number" not in st.session_state:
+        st.session_state.report_number = ""
+    if "persons_input" not in st.session_state:
+        st.session_state.persons_input = ""
+
+    if "book_meta" not in st.session_state:
+        st.session_state.book_meta = {
+            "book_title": "",
+            "series_title": "",
+            "series_issn": "",
+            "publisher_name": repo_config["publisher"],
+            "pub_year": today.year,
+            "pub_month": str(today.month),
+            "pub_day": str(today.day),
+            "noisbn_reason": "",
+            "book_doi": "",
+            "book_resource": "",
+            "report_number": "", 
+            "editors": [],
+            "authors": [],
+        }
+        
+    # CHECK: has the repo code changed since last run?
+    if "last_repo_code" not in st.session_state:
+        st.session_state.last_repo_code = repo_code
+        st.session_state.registrant = repo_config["registrant"]
+        st.session_state.cr_role = repo_config.get("role", "")
+    
+    if st.session_state.last_repo_code != repo_code:
+        # Repo changed! Update defaults
+        st.session_state.publisher_name = repo_config["publisher"]
+        st.session_state.book_meta["publisher_name"] = repo_config["publisher"]
+        st.session_state.registrant = repo_config["registrant"]
+        
+        # If the user hasn't typed anything yet or if we force update?
+        # Let's force update the role in session state so the input widget picks it up
+        st.session_state.cr_role = repo_config.get("role", "")
+        
+        st.session_state.last_repo_code = repo_code
+
+    st.markdown("---")
+    st.subheader("Metadaten & Inhalte")
+    
+    # Use expander for metadata editing to keep UI clean
+    with st.expander("Metadaten bearbeiten", expanded=True):
+        bm = st.session_state.book_meta
+    
+        col_b1, col_b2 = st.columns(2)
+        with col_b1:
+            st.text_input("Titel", key="book_title")
+            st.text_input("Serientitel", key="series_title")
+            st.text_input("Serien-ISSN", key="series_issn")
+            st.text_input("Publisher Name", key="publisher_name")
+            
+            if cr_book_type == "report-paper":
+                st.text_input("Report Number", key="report_number")
+    
+        with col_b2:
+            c_y, c_m, c_d = st.columns(3)
+            with c_y:
+                st.number_input("Jahr", min_value=1900, max_value=2100, key="pub_year")
+            with c_m:
+                st.text_input("Monat", key="pub_month")
+            with c_d:
+                st.text_input("Tag", key="pub_day")
+            
+            if cr_book_type != "report-paper":
+                 st.text_input("noisbn reason", key="noisbn_reason")
+    
+        st.markdown("##### Identifikatoren")
+        col_id1, col_id2 = st.columns(2)
+        with col_id1:
+             st.text_input("DOI", key="book_doi")
+        with col_id2:
+             st.text_input("Resource URL", key="book_resource")
+             
+        st.caption(f"Basis DOI Prefix: {repo_config['prefix']}")
+    
+        st.markdown("##### Mitwirkende")
+        # Decide label based on type
+        if cr_book_type in ["monograph", "report-paper"]:
+            st.info("Bitte **Autoren** eintragen (Vorname;Nachname).")
+            label = "Autoren"
+        else:
+            st.info("Bitte **Editoren** eintragen (Vorname;Nachname).")
+            label = "Editoren"
+    
+        persons_text = st.text_area(label, key="persons_input", height=100)
+    
+        # Parse and save back
+        new_persons = []
+        for line in persons_text.splitlines():
+            line = line.strip()
+            if not line:
+                continue
+            parts = [p.strip() for p in line.split(";")]
+            if len(parts) == 2:
+                new_persons.append({"given": parts[0], "family": parts[1]})
+        
+        if cr_book_type in ["monograph", "report-paper"]:
+            bm["authors"] = new_persons
+        else:
+            bm["editors"] = new_persons
+
+    st.markdown("---")
+    st.subheader("Depositor & Batch Info")
+    
+    with st.expander("Depositor Details", expanded=False):
+        col_d1, col_d2 = st.columns(2)
+        with col_d1:
+            depositor_name = st.text_input(
+                "Depositor Name",
+                value="Lib4RI - Library for the Research Institutes within the ETH Domain: Eawag, Empa, PSI & WSL"
+            )
+        with col_d2:
+            depositor_email = st.text_input("Depositor Email", value="dora@lib4ri.ch")
+        
+        ts = datetime.datetime.now().strftime("%Y%m%d%H%M%S")
+        
+        batch_prefix = "book"
+        if cr_book_type == "report-paper":
+            batch_prefix = "report"
+        elif cr_book_type == "monograph":
+            batch_prefix = "monograph"
+            
+        doi_batch_id = st.text_input(
+            "DOI Batch ID",
+            value=f"{batch_prefix}_{ts}",
+            help="Wird im XML-Header verwendet. Sollte eindeutig sein."
+        )
+            
+        if "registrant" not in st.session_state:
+            st.session_state.registrant = repo_config["registrant"]
+        
+        registrant = st.text_input("Registrant", value=st.session_state.registrant)
+        st.session_state.registrant = registrant
+    
+        depositor_meta = {
+            "depositor_name": depositor_name,
+            "depositor_email": depositor_email,
+            "registrant": st.session_state.registrant,
+            "doi_batch_id": doi_batch_id
+        }
+
+    st.subheader("Kapitel / Inhalte")
+    st.caption("Ein Eintrag pro Zeile: ID (z.B. wsl:12345) oder URL")
+
+    st.markdown(
+        "Gib **eine DORA-ID** (z.B. `wsl:41900`) oder eine **komplette MODS-URL** "
+        "pro Zeile ein."
+    )
+
+    chapters_text = st.text_area("Kapitel-Liste", height=200, help="Liste der IDs oder URLs")
+
+    st.markdown("---")
+    st.subheader("XML Generierung")
+
+    if st.button("Crossref XML generieren", type="primary"):
+        try:
+            chapter_items = []
+
+            for line in chapters_text.splitlines():
+                line = line.strip()
+                if not line:
+                    continue
+                mods_url = build_dora_mods_url(base_url, repo_code, line)
+                st.write(f"Lade Kapitel-MODS von: {mods_url}")
+                mods_root = fetch_mods_xml(mods_url)
+                ci, page_no = mods_to_content_item(mods_root, repo_base_url)
+                chapter_items.append((ci, page_no))
+
+            if not chapter_items and cr_book_type == "edited_book":
+                st.warning("Keine Kapitel angegeben! Ein Edited Book sollte normalerweise Kapitel enthalten.")
+            
+            # book_meta aus session state / widgets zusammenbauen
+            book_meta = {
+                "book_title": st.session_state.book_title,
+                "series_title": st.session_state.series_title,
+                "series_issn": st.session_state.series_issn,
+                "publisher_name": st.session_state.publisher_name,
+                "pub_year": int(st.session_state.pub_year) if st.session_state.get("pub_year") else 0,
+                "pub_month": st.session_state.pub_month,
+                "pub_day": st.session_state.pub_day,
+                "noisbn_reason": st.session_state.get("noisbn_reason", ""),
+                "book_doi": st.session_state.book_doi,
+                "book_resource": st.session_state.book_resource,
+                "report_number": st.session_state.get("report_number", ""),
+                "editors": new_persons if cr_book_type not in ["monograph", "report-paper"] else [],
+                "authors": new_persons if cr_book_type in ["monograph", "report-paper"] else [],
+            }
+
+            xml_bytes = build_doi_batch_xml(book_meta, depositor_meta, chapter_items, book_type=cr_book_type)
+            
+            # Store in session state
+            st.session_state.crossref_xml = xml_bytes
+            st.session_state.crossref_filename = "crossref_edited_book.xml"
+            
+            st.success("Crossref XML erfolgreich erzeugt!")
+
+            # Validierung gegen Crossref XSD Schema
+            st.subheader("XML Validierung")
+            with st.spinner("Validiere XML gegen Crossref Schema..."):
+                is_valid, validation_errors = validate_crossref_xml(xml_bytes)
+
+            if is_valid:
+                st.success("✓ XML ist valide und bereit für Crossref!")
+            else:
+                st.error("✗ XML Validierung fehlgeschlagen:")
+                for error in validation_errors:
+                    st.error(f"  • {error}")
+                st.warning("Das XML kann trotzdem heruntergeladen werden, wird aber möglicherweise von Crossref abgelehnt.")
+
+        except Exception as e:
+            st.error(f"Fehler bei der Erzeugung des XML: {e}")
+            import traceback
+            st.text(traceback.format_exc())
+
+    # Display Download and Upload if XML exists in session state
+    if "crossref_xml" in st.session_state:
+        xml_bytes = st.session_state.crossref_xml
+        
+        # Download Button
+        st.download_button(
+            label="XML herunterladen",
+            data=xml_bytes,
+            file_name=st.session_state.crossref_filename,
+            mime="application/xml"
+        )
+
+        # ---------------------------------------------------------
+        # Crossref Upload Section
+        # ---------------------------------------------------------
+        st.markdown("---")
+        st.subheader("Automatischer Upload zu Crossref")
+        
+        # Determine default role if not in session state
+        if "cr_role" not in st.session_state:
+             st.session_state.cr_role = REPO_CONFIG.get(st.session_state.last_repo_code, {}).get("role", "")
+
+        col_u1, col_u2 = st.columns(2)
+        with col_u1:
+            cr_user = st.text_input("Crossref Username", value="dora@lib4ri.ch")
+            # Use key to bind to session state
+            cr_role = st.text_input("Crossref Role (wslx, empa, eawa, psit)", key="cr_role")
+        with col_u2:
+            cr_pass = st.text_input("Crossref Password", type="password")
+        
+        if st.button("Upload to Crossref"):
+            if not cr_user or not cr_pass:
+                st.error("Bitte Username und Passwort für Crossref angeben.")
+            else:
+                with st.spinner("Lade zu Crossref hoch..."):
+                    res = upload_to_crossref(xml_bytes, cr_user, cr_pass, cr_role)
+                    
+                    if isinstance(res, str) and res.startswith("Exception"):
+                            st.error(f"Upload fehlgeschlagen: {res}")
+                    else:
+                            # Crossref returns 200 even on some logic errors, text contains details
+                            if res.status_code == 200:
+                                if "successfully received" in res.text:
+                                    st.success("Upload erfolgreich! Crossref hat die Datei empfangen.")
+                                    with st.expander("Server-Antwort ansehen"):
+                                        st.text(res.text)
+                                else:
+                                    st.warning("Upload technisch erfolgreich (HTTP 200), aber Crossref meldet eventuell Fehler.")
+                                    with st.expander("Server-Antwort ansehen (Fehleranalyse)"):
+                                        st.text(res.text)
+                            else:
+                                st.error(f"HTTP Fehler: {res.status_code}")
+                                st.text(res.text)
+
+
+def upload_to_crossref(xml_content, username, password, role=None):
+    url = "https://doi.crossref.org/servlet/deposit"
+    
+    # Construct login_id with role if provided (format: username/role)
+    login_id = username
+    if role and role.strip():
+        login_id = f"{username}/{role.strip()}"
+
+    # Multipart form data
+    # 'operation': 'doMDUpload'
+    # 'login_id': username (or username/role)
+    # 'login_passwd': password
+    # 'fname': (filename, file_content, content_type)
+    
+    files = {
+        'fname': ('crossref_submission.xml', xml_content, 'application/xml')
+    }
+    data = {
+        'operation': 'doMDUpload',
+        'login_id': login_id,
+        'login_passwd': password
+    }
+    
+    try:
+        response = requests.post(url, files=files, data=data, timeout=60)
+        return response
+    except Exception as e:
+        return f"Exception: {e}"
+
 if __name__ == "__main__":
-    assemble_crossref(MODS_DIR, OUTPUT_XML)
-    print("DONE.")
+    main()