tg-prepare 2.2.2__py3-none-any.whl

tgp_ui/routes/collection.py

@@ -0,0 +1,319 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2023-2025 TU-Dresden (ZIH)
+# ralf.klammer@tu-dresden.de
+# moritz.wilhelm@tu-dresden.de
+
+import logging
+
+import os
+
+from flask import Blueprint, render_template, request, send_file
+from flask_json import json_response
+from flask_login import current_user
+
+from io import BytesIO
+
+from tg_model.tei import TEIParser
+
+from tgp_backend.directories import generateList
+from tgp_backend.project import Project
+from tgp_backend.util import parse_request_data
+
+log = logging.getLogger(__name__)
+
+collection_routes = Blueprint("collection", __name__)
+
+
+# ***TABS***
+# **********
+@collection_routes.route(
+    "/tab_select_directories/<string:projectname>", methods=["GET", "POST"]
+)
+def tab_select_directories(projectname):
+
+    project = Project(projectname, current_user.username)
+    if request.method == "POST":
+        project.project_config.update(
+            tei_directories=request.form.getlist("selected_folder")
+        )
+
+    tei_directories = [
+        sp["inpath"] for sp in project.project_config.get_subprojects()
+    ]
+
+    return render_template(
+        "tabs/select_directories.html",
+        project=project,
+        selected_directories=tei_directories,
+    )
+
+
+@collection_routes.route(
+    "/tab_manage_collections/<string:projectname>", methods=["GET"]
+)
+def tab_manage_collections(projectname):
+
+    project = Project(projectname, current_user.username)
+
+    return render_template(
+        "tabs/manage_collections.html",
+        project=project,
+    )
+
+
+@collection_routes.route(
+    "/tab_validate_metadata/<string:projectname>", methods=["GET"]
+)
+@collection_routes.route(
+    "/tab_validate_metadata/<string:projectname>/<string:refresh>",
+    methods=["GET"],
+)
+def tab_validate_metadata(projectname, refresh=False):
+
+    project = Project(projectname, current_user.username)
+    return render_template(
+        "tabs/validate_metadata.html",
+        projectname=projectname,
+        validation_results=project.get_validation_results(refresh=refresh),
+    )
+
+
+# ***OTHER***
+# **********
+@collection_routes.route(
+    "/load_collection/<string:projectname>/<string:collectionname>",
+    methods=["GET"],
+)
+def load_collection(projectname, collectionname):
+    collection = None
+    project = Project(projectname, current_user.username)
+    collection = None
+    if collectionname:
+        collection = project.get_collection(collectionname)
+
+    return render_template(
+        "details/manage_collection.html",
+        collectionname=collectionname,
+        collection=collection["config"],
+        project=project,
+    )
+
+
+@collection_routes.route(
+    "/save_collection_attributes/<string:projectname>/<string:collectionname>",
+    methods=["POST"],
+)
+def save_collection_attributes(projectname, collectionname):
+    project = Project(projectname, current_user.username)
+    collection = project.get_collection(collectionname)
+    collection_config = collection["config"]
+
+    multi_attribs = ["collector", "rights_holder"]
+    for multi_attrib in multi_attribs:
+        elements = []
+        for name, url in zip(
+            request.form.getlist(f"{multi_attrib}_name"),
+            request.form.getlist(f"{multi_attrib}_url"),
+        ):
+            elements.append({"fullname": name, "url": url})
+        setattr(collection_config, multi_attrib, elements)
+
+    for attrib in ["short_title", "long_title"]:
+        value = request.form.get(attrib)
+        setattr(collection_config, attrib, value)
+
+    collection_config.save()
+    return load_collection(
+        projectname=projectname, collectionname=collectionname
+    )
+
+
+@collection_routes.route(
+    "/save_collection_classifications/<string:projectname>/<string:collectionname>",
+    methods=["POST"],
+)
+def save_collection_classifications(projectname, collectionname):
+    project = Project(projectname, current_user.username)
+    collection = project.get_collection(collectionname)
+    collection_config = collection["config"]
+
+    # Save basic classifications...
+    collection_config.basic_classifications = parse_request_data(
+        request, "basic_classifications"
+    )
+    # ...and GND subjects
+    collection_config.gnd_subjects = parse_request_data(
+        request, "gnd_subjects"
+    )
+
+    collection_config.save()
+    return load_collection(
+        projectname=projectname, collectionname=collectionname
+    )
+
+
+@collection_routes.route(
+    "/save_collection_metadata/<string:projectname>/<string:collectionname>",
+    methods=["POST"],
+)
+def save_collection_metadata(projectname, collectionname):
+    project = Project(projectname, current_user.username)
+    collection = project.get_collection(collectionname)
+    collection_config = collection["config"]
+    for attrib in request.form:
+        if "xpath" in attrib:
+            key = attrib.replace("_xpath", "")
+            type_ = "xpath"
+        elif "value" in attrib:
+            key = attrib.replace("_value", "")
+            type_ = "value"
+        if key in collection_config.xpath_or_value_attribs:
+            cc_attrib = getattr(collection_config, key)
+            cc_attrib[type_] = request.form.get(attrib)
+        else:
+            log.warning(
+                f"Attribute '{attrib}' not found in collection config."
+            )
+    collection_config.save()
+    return load_collection(
+        projectname=projectname, collectionname=collectionname
+    )
+
+
+@collection_routes.route(
+    "/download_collection_yaml/<string:projectname>/<string:collectionname>",
+    methods=["GET"],
+)
+def download_collection_yaml(projectname, collectionname):
+    project = Project(projectname, current_user.username)
+    collection = project.get_collection(collectionname)
+    return send_file(
+        collection["config"].path,
+        mimetype="application/yaml",
+        as_attachment=True,
+        download_name=f"{collectionname}.yaml",
+    )
+
+
+@collection_routes.route(
+    "/upload_collection_yaml/<string:projectname>/<string:collectionname>",
+    methods=["POST"],
+)
+def upload_collection_yaml(projectname, collectionname):
+    collection = Project(projectname, current_user.username).get_collection(
+        collectionname
+    )
+
+    # Get the uploaded file and save it to the collection config path
+    new_config_file = request.files.get("config")
+    new_config_file.save(collection["config"].path)
+
+    # Reload the collection config
+    new_collection = Project(
+        projectname, current_user.username
+    ).get_collection(collectionname)
+
+    # Preserve short and long title
+    for key in ["short_title", "long_title"]:
+        setattr(
+            new_collection["config"], key, getattr(collection["config"], key)
+        )
+    new_collection["config"].save()
+
+    # reload the collection view
+    return load_collection(
+        projectname=projectname, collectionname=collectionname
+    )
+
+
+@collection_routes.route(
+    "/modal/tei_explorer/<string:projectname>/<string:collectionname>",
+    methods=["GET", "POST"],
+)
+def modal_tei_explorer(projectname, collectionname):
+    project = Project(projectname, current_user.username)
+    # collection = project.get_collection(collectionname)
+    dir_list_dict, file_list_dict = generateList(
+        project.get_subproject_inpath(collectionname)
+    )
+
+    xpath = request.args.get("xpath", "")
+
+    return render_template(
+        "modal/tei_explorer.html",
+        projectname=projectname,
+        collectionname=collectionname,
+        dir_list=dir_list_dict,
+        file_list=file_list_dict,
+        xpath=xpath,
+        project=project,
+    )
+
+
+@collection_routes.route("/load_tei_content", methods=["GET"])
+def load_tei_content():
+    path = request.args.get("path")
+    log.debug("load_tei_content path: %s" % path)
+    _type = request.args.get("type")
+    if path is not None:
+        tei_parser = TEIParser(fullpath=path)
+        if _type == "header":
+            return json_response(
+                value="OK",
+                content=tei_parser.find(
+                    "//teiHeader", node_as_text=True
+                ).decode("utf-8"),
+            )
+        elif _type == "text":
+            return json_response(
+                value="OK",
+                content=tei_parser.find(".//text", node_as_text=True).decode(
+                    "utf-8"
+                ),
+            )
+        return json_response(value="Unknown type requested!")
+
+
+@collection_routes.route(
+    "/modal/xpath_parser/<string:projectname>/<string:collectionname>",
+    methods=["GET", "POST"],
+)
+def modal_xpath_parser(
+    projectname,
+    collectionname,
+):
+    project = Project(projectname, current_user.username)
+    collection = project.get_collection(
+        collectionname,
+    )
+    collection_parser = collection["parser"]
+
+    xpath = request.args.get("xpath")
+    if not xpath:
+        xpath = request.form.get("xpath", "")
+
+    return render_template(
+        "modal/xpath_parser.html",
+        xpath=xpath,
+        projectname=projectname,
+        collectionname=collectionname,
+        collection_parser=collection_parser,
+    )
+
+
+@collection_routes.route("/export_tsv/<projectname>/<collectionname>")
+def export_tsv(projectname, collectionname):
+    project = Project(projectname, current_user.username)
+    collection = project.get_collection(
+        collectionname,
+    )
+    filepath = collection["modeler"].export()
+    if os.path.isfile(filepath):
+        with open(filepath, "rb") as file:
+            file_content = BytesIO(file.read())
+
+        return send_file(
+            file_content,
+            download_name=os.path.basename(filepath),
+            as_attachment=True,
+        )

tgp_ui/routes/data.py

@@ -0,0 +1,229 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2023-2025 TU-Dresden (ZIH)
+# ralf.klammer@tu-dresden.de
+# moritz.wilhelm@tu-dresden.de
+
+import logging
+
+import os
+import shutil
+
+from flask import Blueprint, render_template, request, send_file, session
+from flask_json import json_response
+from flask_login import current_user
+
+from io import BytesIO
+
+from tgp_backend.config import MAIN_PATH
+from tgp_backend.nextcloud import Nextcloud
+from tgp_backend.project import Project
+from tgp_backend.session_manager import SessionManagerNextcloud
+
+log = logging.getLogger(__name__)
+
+data_routes = Blueprint("data", __name__)
+
+
+# ***TABS***
+# **********
+@data_routes.route("/tab-import-data/<string:projectname>", methods=["GET"])
+def tab_import_data(projectname=None, project=None, error_message=None):
+    if not project:
+        if not projectname:
+            raise ValueError("Project name must be provided.")
+        else:
+            project = Project(projectname, current_user.username)
+    return render_template(
+        "tabs/import_data.html",
+        project=project,
+        error_message=error_message,
+    )
+
+
+# ***DIRECT UPLOAD***
+# *******************
+@data_routes.route("/upload_files/<string:projectname>", methods=["POST"])
+def upload_files(projectname=None):
+    project = Project(projectname, current_user.username)
+    project.file_upload(request.files.getlist("files"))
+
+    return tab_import_data(project=project)
+
+
+# ***GITHUB***
+# ************
+@data_routes.route("/modal/github/<projectname>", methods=["GET", "POST"])
+def modal_github(projectname):
+    """
+    Render the Github modal.
+    """
+    project = Project(projectname, current_user.username)
+    return render_template(
+        "modal/github_modal.html",
+        project=project,
+    )
+
+
+@data_routes.route("/clone_git_project/<string:projectname>", methods=["POST"])
+def clone_git_project(projectname=None):
+    project = Project(projectname, current_user.username)
+    project.clone_git_project(request.form.get("github_repo"))
+
+    return tab_import_data(project=project)
+
+
+# ***NEXTCLOUD***
+# ***************
+
+
+def render_nextcloud_tree(projectname, items):
+    """
+    Render the Nextcloud tree view.
+    """
+    # items = items or nc.nxc_list_files_and_folders()
+    project = Project(projectname, current_user.username)
+    return render_template(
+        "modal/file_explorer_nextcloud.html",
+        project=project,
+        items=items,
+        show_checkbox=True,
+        show_all_folders=True,
+    )
+
+
+def render_nextcloud_login(projectname, message=None):
+    """
+    Render the Nextcloud login form.
+    """
+    return render_template(
+        "modal/nextcloud_login.html", projectname=projectname, message=message
+    )
+
+
+@data_routes.route("/modal/nextcloud/<projectname>", methods=["GET", "POST"])
+@data_routes.route(
+    "/modal/nextcloud/<projectname>/<logout>", methods=["GET", "POST"]
+)
+def modal_nextcloud(projectname, form_type=None, logout=False):
+
+    nxc_session_manager = SessionManagerNextcloud(session)
+
+    if logout:
+        # If the user wants to log out, delete the session credentials
+        nxc_session_manager.delete_nextcloud_credentials()
+        return render_nextcloud_login(projectname, message="You logged out.")
+
+    nc = Nextcloud(**nxc_session_manager.get_credentials())
+    if nc.test_connection():
+        # An active Nextcloud session exists, so we can use it to render
+        # the tree view
+        return render_nextcloud_tree(
+            projectname, nc.nxc_list_files_and_folders()
+        )
+    elif nxc_session_manager.request_has_valid_credentials(request):
+        # If credentials are provided,
+        # Recreate a Nextcloud instance and test the connection
+        nxc_session_manager.save_credentials(request.form)
+        nc = Nextcloud(**nxc_session_manager.get_credentials())
+        if nc.test_connection():
+            return render_nextcloud_tree(
+                projectname, nc.nxc_list_files_and_folders()
+            )
+
+        else:
+            return render_nextcloud_login(
+                projectname,
+                message="Login failed. Please check your credentials.",
+            )
+    else:
+        # If no valid credentials are provided, render the login form
+        log.info("No valid Nextcloud credentials found, showing login form.")
+        # This will clear any previous session data
+        nxc_session_manager.delete_nextcloud_credentials()
+        return render_nextcloud_login(projectname)
+
+
+@data_routes.route("/download_nextcloud/<projectname>", methods=["POST"])
+def download_nextcloud(projectname):
+
+    nxc_session_manager = SessionManagerNextcloud(session)
+
+    selected_option = request.form.getlist("selected_folder")
+
+    if selected_option:
+        nc = Nextcloud(**nxc_session_manager.get_credentials())
+        nc.download_nxc_files(selected_option, projectname=projectname)
+
+        return json_response(
+            status=200,
+            message="Downloaded.",
+        )
+    else:
+        return json_response(
+            status=400, message="No folder selected for download."
+        )
+
+
+# ***OTHER***
+# *******************
+@data_routes.route("/image/<path:filepath>")
+def serve_image(filepath):
+    filepath = "/" + filepath
+    if os.path.isfile(filepath):
+        return send_file(filepath)
+    return "", 404
+
+
+@data_routes.route("/file/<path:filepath>")
+def serve_file(filepath):
+
+    filepath = "/" + filepath
+
+    if os.path.isfile(filepath):
+        with open(filepath, "rb") as file:
+            file_content = BytesIO(file.read())
+
+        return send_file(
+            file_content,
+            download_name=os.path.basename(filepath),
+            as_attachment=True,
+        )
+
+
+@data_routes.route("/api/delete-folder", methods=["DELETE"])
+def delete_folder():
+    error_message = None  # Variable für die Fehlermeldung
+    try:
+        path = request.form.get("path")
+        projectname = request.form.get("projectname")
+
+        if not path:
+            error_message = "No path specified"
+        elif not path.startswith(MAIN_PATH):
+            # Security check to ensure path is within allowed directory
+            error_message = "Invalid path"
+        elif not os.path.exists(path):
+            # Check if path exists
+            error_message = "Path not found"
+        else:
+            # Check if the path is a file or a folder
+            if os.path.isfile(path):
+                # Delete the file
+                os.remove(path)
+                log.info(f"File deleted: {path}")
+            elif os.path.isdir(path):
+                # Delete the folder and its contents
+                shutil.rmtree(path)
+                log.info(f"Folder deleted: {path}")
+            else:
+                error_message = "Path is neither a file nor a folder"
+
+    except Exception as e:
+        log.error(f"Error deleting path: {e}")
+        error_message = f"An error occurred: {str(e)}"
+
+    # Am Ende einmal `tab_import_data` aufrufen
+    return tab_import_data(
+        projectname=projectname,
+        error_message=error_message,
+    )

tgp_ui/routes/project.py

@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2023-2025 TU-Dresden (ZIH)
+# ralf.klammer@tu-dresden.de
+# moritz.wilhelm@tu-dresden.de
+
+import logging
+
+import os
+import shutil
+
+from flask import Blueprint, redirect, render_template, request
+from flask import url_for as default_url_for
+from flask_json import json_response
+from flask_login import current_user
+
+
+from tgp_backend.config import MAIN_PATH
+from tgp_backend.project import Project
+
+from .views import overview
+
+log = logging.getLogger(__name__)
+
+project_routes = Blueprint("project", __name__)
+
+
+def get_prefix():
+    return request.headers.get(
+        "X-Forwarded-Prefix", request.headers.get("X-Script-Name", "")
+    )
+
+
+def url_for(*args, **kwargs):
+    """Overrides Flask's url_for globally to include the prefix"""
+    return get_prefix() + default_url_for(*args, **kwargs)
+
+
+@project_routes.route("/new_project", methods=["POST"])
+def new_project():
+    project = Project(request.form.get("projectname"), current_user.username)
+    project.create()
+    return redirect(url_for("views.project_view", projectname=project.path))
+
+
+@project_routes.route("/delete_project/<string:projectname>", methods=["POST"])
+def delete_project(projectname):
+
+    # projectname = request.form.get("projectname")
+    fullpath = f"{MAIN_PATH}/{projectname}"
+
+    # Delete the project
+    if fullpath.strip("/") == MAIN_PATH.strip("/"):
+        log.error(f"Cannot delete main path ({MAIN_PATH})!")
+    elif os.path.exists(fullpath):
+        shutil.rmtree(fullpath)
+    else:
+        log.warning("Project does not exist!")
+
+    return overview()
+
+
+@project_routes.route(
+    "/modal_delete_project/<string:projectname>", methods=["POST"]
+)
+def modal_delete_project(projectname):
+    return render_template(
+        "modal/delete_project.html",
+        projectname=projectname,
+    )
+
+
+@project_routes.route(
+    "/tab-edit-project/<string:projectname>", methods=["GET", "POST"]
+)
+def tab_edit_project(projectname):
+    project = Project(projectname, current_user.username)
+    if request.method == "POST":
+        collectors = []
+        for name, url in zip(
+            request.form.getlist("collector_name"),
+            request.form.getlist("collector_url"),
+        ):
+            collectors.append({"name": name, "url": url})
+
+        project.update(
+            title=request.form["title"],
+            description=request.form["description"],
+            collectors=collectors,
+            avatar=request.files["avatar"],
+            xslt=request.files.get("xslt"),
+        )
+    return render_template(
+        "tabs/edit_project.html",
+        project=project,
+    )
+
+
+@project_routes.route("/delete-xslt/<string:projectname>", methods=["DELETE"])
+def delete_xslt(projectname):
+    project = Project(projectname, current_user.username)
+    log.debug(f"Deleting XSLT for project {projectname}")
+    project.clear_xslt()
+    return json_response("OK")