tg-prepare 2.2.2__py3-none-any.whl

tgp_backend/tgclient.py

@@ -0,0 +1,187 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2023-2025 TU-Dresden (ZIH)
+# ralf.klammer@tu-dresden.de
+# moritz.wilhelm@tu-dresden.de
+import logging
+
+from tgadmin.tgadmin import _crud_delete_op
+from tgadmin.tgimport import TGimport
+
+from tgclients import (
+    TextgridAuth,
+    TextgridConfig,
+    TextgridCrud,
+    TextgridSearch,
+)
+from tgclients.config import PROD_SERVER, TEST_SERVER
+
+log = logging.getLogger(__name__)
+
+
+class TGclient(object):
+    def __init__(self, sid, instance="test", verbose=False):
+        self.sid = sid
+
+        if instance == "live":
+            self.server = PROD_SERVER
+        else:
+            self.server = TEST_SERVER
+        self.config = TextgridConfig(self.server)
+
+        self.crud = TextgridCrud(self.config)
+        self.tgauth = TextgridAuth(self.config)
+        self.tgsearch = TextgridSearch(self.config, nonpublic=True)
+
+        self._contents = {}
+
+    def check_session(self):
+        try:
+            if self.sid:
+                self.tgsearch.search(sid=self.sid)
+                return True
+        except Exception as e:
+            log.error(f"Error checking session id: {self.sid} : {e}")
+        return False
+        # return self.tgauth.check_session(self.sid)  # returns username
+
+    def create_project(self, name, description=""):
+        log.info(f"Creating project {name}")
+        return self.tgauth.create_project(self.sid, name, description)
+
+    def clear_project(self, project_id):
+        # delete content of project
+        # repeat until whole content has been deleted
+        # (necessary because of default limit in '_crud_delete_op')
+        log.info(f"Clearing project contents {project_id}")
+        content = self.get_project_content(project_id)
+        handled_count = 0
+        initial_count = int(content.hits)
+        while handled_count < initial_count:
+            for tgobj in content.result:
+                # can only delete objects that are not already published
+                if tgobj.object_value.generic.generated.availability == None:
+                    _crud_delete_op(self, tgobj)
+                handled_count += 1
+            content = self.get_project_content(project_id)
+
+    def delete_project(self, project_id):
+        self.clear_project(project_id)
+
+        log.info(f"Deleting project {project_id}")
+        return self.tgauth.delete_project(self.sid, project_id)
+
+    def get_project_content(self, project_id):
+        log.warning("Deprecated: use TGclient.get_project_contents() instead")
+        contents = self.tgsearch.search(
+            filters=["project.id:" + project_id], sid=self.sid
+        )
+        return contents
+
+    def _query_contents(self, tg_project_id):
+        if not self._contents.get(tg_project_id):
+            log.debug(f"Querying contents for project id: {tg_project_id}")
+            try:
+                self._contents[tg_project_id] = self.tgsearch.search(
+                    filters=["project.id:" + tg_project_id],
+                    sid=self.sid,
+                )
+            except Exception as e:
+                log.error(f"Error querying contents for project: {e}")
+                return []
+
+        return self._contents[tg_project_id].result
+
+    def get_project_contents(
+        self,
+        tg_project_id,
+        public=None,
+        count=False,
+        category=None,
+    ):
+        _filter = None
+        if category == "tei":
+            _filter = ["text/xml"]
+        elif category == "images":
+            _filter = ["image/jpeg", "image/png", "image/gif"]
+        elif category == "other":
+            _filter = [
+                "image/png",
+                "text/markdown",
+                "application/xslt+xml",
+                "text/tg.portalconfig+xml",
+            ]
+
+        contents = self._query_contents(tg_project_id)
+        results = {}
+        for tgobj in contents:
+            result = {}
+            result["title"] = tgobj.object_value.generic.provided.title[0]
+            result["tguri"] = (
+                tgobj.object_value.generic.generated.textgrid_uri.value
+            )
+            result["mime"] = tgobj.object_value.generic.provided.format
+            result["published"] = (
+                tgobj.object_value.generic.generated.availability is not None
+            )
+            log.debug(f"Found object: {result}")
+
+            if _filter is None or result["mime"] in _filter:
+                results[result["title"]] = result
+            else:
+                log.info(
+                    "Skipping object with unsupported mime-type: %s"
+                    % result["mime"]
+                )
+        return len(results) if count else results
+
+    def get_project_description(self, project_id):
+        desc = self.tgauth.get_project_description(project_id)
+        if desc:
+            return {
+                "id": project_id,
+                "name": desc.name,
+                "description": desc.description,
+                "tei_count": self.get_project_contents(
+                    project_id, count=True, category="tei"
+                ),
+                "img_count": self.get_project_contents(
+                    project_id, count=True, category="images"
+                ),
+                "other_count": self.get_project_contents(
+                    project_id, count=True, category="other"
+                ),
+                "content_count": self.get_project_contents(
+                    project_id, count=True
+                ),
+            }
+        else:
+            log.warning(f"Cannot find project description for: {project_id}")
+
+    def get_assigned_projects(self):
+        log.info("Listing assigned projects")
+        # TODO: this needs a better error handling to indicate user,
+        # that the session-id seeems to be invalid
+        try:
+            _projects = self.tgauth.list_assigned_projects(self.sid)
+        except Exception as e:
+            log.error(f"Error listing assigned projects: {e}")
+            return []
+
+        for project_id in _projects:
+            yield self.get_project_description(project_id)
+
+    # def upload(self, filenames: list[str], project_id: str, imex_file: str):
+    #     tg_importer = TGimport(
+    #         self.sid,
+    #         self.crud,
+    #         project_id=project_id,
+    #         ignore_warnings=True,
+    #         imex_location=imex_file,
+    #     )
+    #     tg_importer.upload(filenames=filenames, threaded=True)
+
+    def publish(self, tg_project_id):
+        log.info(f"Publishing project {tg_project_id}")
+        # TODO: implement publish logic in tgclients
+        # see tgadmin.tgadmin.publish() tgadmin.py::Z646
+        breakpoint()

tgp_backend/user.py

@@ -0,0 +1,137 @@
+# -*- 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 json
+import hashlib
+
+from flask_login import UserMixin  # type: ignore
+
+from .config import MAIN_PATH
+
+log = logging.getLogger(__name__)
+
+
+class User(UserMixin):
+    def __init__(
+        self,
+        username,
+        password_hash=None,
+        email=None,
+        role="user",
+        is_active=True,
+    ):
+        self.id = username
+        self.username = username
+        self.password_hash = password_hash
+        self.email = email
+        self.role = role
+        self._is_active = is_active  # Underscore prefix for internal attribute
+        self.last_login = None
+
+    @property
+    def is_active(self):
+        """Return True if the user is active."""
+        return self._is_active
+
+    @is_active.setter
+    def is_active(self, value):
+        """Set the active status of the user."""
+        self._is_active = value
+
+    def check_password(self, password):
+        """Verify password against stored hash"""
+        hashed = hashlib.sha256(password.encode()).hexdigest()
+        return hashed == self.password_hash
+
+    def to_dict(self):
+        """Converts User to dictionary for JSON storage"""
+        return {
+            "username": self.username,
+            "password_hash": self.password_hash,
+            "email": self.email,
+            "role": self.role,
+            "is_active": self._is_active,  # Use internal attribute
+            "last_login": self.last_login,
+        }
+
+    @staticmethod
+    def from_dict(data):
+        """Creates User object from dictionary"""
+        user = User(
+            username=data["username"],
+            password_hash=data["password_hash"],
+            email=data.get("email"),
+            role=data.get("role", "user"),
+            is_active=data.get("is_active", True),
+        )
+        user.last_login = data.get("last_login")
+        return user
+
+
+class UserManager:
+    def __init__(self):
+        self.users_file = os.path.join(MAIN_PATH, "users.json")
+        os.makedirs(os.path.dirname(self.users_file), exist_ok=True)
+        self.load_users()
+
+    def load_users(self):
+        """Loads users from JSON file"""
+        self.users = {}
+        if os.path.exists(self.users_file):
+            try:
+                with open(self.users_file, "r") as f:
+                    users_data = json.load(f)
+                    for username, data in users_data.items():
+                        self.users[username] = User.from_dict(data)
+                        self.initialize_user_folder(
+                            username
+                        )  # Initialisiere Benutzerordner
+            except Exception as e:
+                print(f"Error loading users: {e}")
+                self.create_default_admin()
+        else:
+            self.create_default_admin()
+
+    def save_users(self):
+        """Saves users to JSON file"""
+        users_data = {
+            username: user.to_dict() for username, user in self.users.items()
+        }
+        with open(self.users_file, "w") as f:
+            json.dump(users_data, f, indent=2)
+
+    def get_user(self, username):
+        """Returns user by username"""
+        return self.users.get(username)
+
+    def create_user(self, username, password, email=None, role="user"):
+        """Creates new user"""
+        if username in self.users:
+            return False, "Username already taken"
+
+        password_hash = hashlib.sha256(password.encode()).hexdigest()
+        user = User(username, password_hash, email, role)
+        self.users[username] = user
+        self.save_users()
+        self.initialize_user_folder(username)  # Initialisiere Benutzerordner
+        return True, "User created successfully"
+
+    def create_default_admin(self):
+        """Creates default admin user"""
+        self.create_user("admin", "admin123", role="admin")
+        print("Default admin user created (admin/admin123)")
+
+    def initialize_user_folder(self, username):
+        """Initialisiert den Benutzer-spezifischen Ordner"""
+        user_folder = os.path.join(MAIN_PATH, username)
+        os.makedirs(user_folder, exist_ok=True)
+        log.info(f"Benutzerordner initialisiert: {user_folder}")
+
+    def get_user_folder(self, username):
+        """Gibt den Pfad des Benutzerordners zurück"""
+        return os.path.join(MAIN_PATH, username)

tgp_backend/util.py

@@ -0,0 +1,131 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2023-2024 TU-Dresden (ZIH)
+# ralf.klammer@tu-dresden.de
+import logging
+
+import os
+import re
+
+from collections import defaultdict
+
+from .config import get_config_value
+
+log = logging.getLogger(__name__)
+
+
+def config(*args, **kwargs):
+    log.warning(
+        """
+            Using deprecated config function.
+            Please use tgp_backend.config.get_config_value instead.
+        """
+    )
+    return get_config_value(*args, **kwargs)
+
+
+def cli_startup(log_level=logging.INFO, log_file=None):
+    log_config = dict(
+        level=log_level,
+        format="%(asctime)s %(name)-10s %(levelname)-4s %(message)s",
+    )
+    if log_file:
+        log_config["filename"] = log_file
+
+    logging.basicConfig(**log_config)
+    logging.getLogger("").setLevel(log_level)
+
+
+def get_file_extension(fname):
+    found_extension = re.search("\.[A-Za-z0-9]*$", fname, re.IGNORECASE)
+    if found_extension:
+        return found_extension[0][1:].lower()
+    return ""
+
+
+def list_files_and_folders(path, get_selectable=False):
+
+    selectable_folders = []
+
+    def recursive_list(dir_path, depth=0):
+        items = []
+        for entry in os.scandir(dir_path):
+            if entry.name.startswith("."):
+                continue
+
+            if entry.is_dir():
+                children = recursive_list(entry.path, depth=depth + 1)
+                contains_xml = any(
+                    f.get("name", "").endswith(".xml") for f in children
+                )
+                item = {
+                    "type": "folder",
+                    "name": entry.name,
+                    "depth": depth,
+                    "path": entry.path,
+                    "contains_xml": contains_xml,
+                    "children": {"count": len(children), "list": children},
+                }
+                items.append(item)
+                if contains_xml:
+                    selectable_folders.append(item)
+            else:
+                items.append(
+                    {
+                        "type": "file",
+                        "name": entry.name,
+                        "depth": depth,
+                        "path": entry.path,
+                    }
+                )
+        return items
+
+    result = recursive_list(path)
+    if get_selectable:
+        return selectable_folders
+    else:
+        return result
+
+
+def get_selectable_folders(path):
+
+    return list_files_and_folders(path, get_selectable=True)
+
+
+def remove_empty_strings_from_dict(d):
+    for key in d:
+        if d[key] == "":
+            d[key] = None
+    return d
+
+
+def parse_request_data(request, attrib_prefix):
+    """
+    Processes form data and creates a list of dictionaries
+    for the specified attributes.
+    """
+    grouped_data = defaultdict(lambda: defaultdict(list))
+
+    # Group data based on prefix
+    for key in request.form.keys():
+        if key.startswith(attrib_prefix):
+            try:
+                _, field, data_type = key.split("-")
+                grouped_data[field][data_type] = request.form.getlist(key)
+            except ValueError:
+                log.warning(
+                    f"Invalid key format: {key}. Expected format: '{attrib_prefix}-field-data_type'."
+                )
+                continue  # Skip invalid keys
+
+    # Transform grouped data into desired structure
+    max_length = max(len(data["xpath"]) for data in grouped_data.values())
+    return [
+        {
+            field: {
+                "xpath": data["xpath"][i],
+                "value": data["value"][i],
+            }
+            for field, data in grouped_data.items()
+        }
+        for i in range(max_length)
+    ]

tgp_ui/app.py

@@ -0,0 +1,150 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2023-2025 TU-Dresden (ZIH)
+# ralf.klammer@tu-dresden.de
+# moritz.wilhelm@tu-dresden.de
+
+import logging
+
+import click  # type: ignore
+import os
+
+from flask import Flask, render_template, session  # type: ignore
+from flask_json import FlaskJSON  # type: ignore
+from flask_login import LoginManager, current_user  # type: ignore
+
+from tgp_backend.project import Project
+
+from tgp_backend.auth import SecretKeyManager
+from tgp_backend.config import LOG_LEVEL, MAIN_PATH, get_config_value
+from tgp_backend.nextcloud import Nextcloud
+from tgp_backend.user import UserManager
+
+from .routes.project import project_routes
+from .routes.views import main_views
+from .routes.data import data_routes
+from .routes.tabs import tab_manager
+from .routes.collection import collection_routes
+from .routes.publication import publication_routes
+from .routes.auth import auth_routes
+
+log = logging.getLogger(__name__)
+
+log_level = get_config_value("log", "level", default="DEBUG") == "DEBUG"
+log.setLevel(log_level)
+file_handler = logging.FileHandler(
+    get_config_value("log", "path", default="/tmp/tg_prepare.log")
+)
+file_handler.setLevel(log_level)
+logging.getLogger().addHandler(file_handler)
+
+base_params = {
+    "title": "TG Prepare",
+}
+
+app = Flask(__name__)
+FlaskJSON(app)
+
+secret_manager = SecretKeyManager(MAIN_PATH)
+app.secret_key = secret_manager.secret_key
+
+# Additional security settings, if not in DEBUG mode
+app.config.update(SESSION_COOKIE_NAME="tgp_session")
+if LOG_LEVEL != "DEBUG":
+    app.config.update(
+        SESSION_COOKIE_SECURE=True,  # Only allow cookies over HTTPS
+        SESSION_COOKIE_HTTPONLY=True,  # Prevent JavaScript access to cookies
+        SESSION_COOKIE_SAMESITE="Strict",  # Protect against CSRF attacks
+    )
+
+# Initialize Authentication and User Management
+login_manager = LoginManager()
+login_manager.init_app(app)
+login_manager.login_view = (
+    "auth.login"  # Redirect to login page if not authenticated
+)
+
+
+# Initialize user loader for Flask-Login
+@login_manager.user_loader
+def load_user(user_id):
+    return user_manager.get_user(user_id)
+
+
+# Initialize UserManager
+user_manager = UserManager()
+app.user_manager = user_manager
+
+
+# Initialize Blueprints
+app.register_blueprint(main_views)
+app.register_blueprint(project_routes)
+app.register_blueprint(data_routes)
+app.register_blueprint(tab_manager)
+app.register_blueprint(collection_routes)
+app.register_blueprint(publication_routes)
+app.register_blueprint(auth_routes)
+
+
+def get_textgrid_login_url(instance):
+    """
+    Returns the TextGrid login URL based on the instance (test or production).
+    """
+    if instance == "test":
+        return "https://test.textgridlab.org/1.0/Shibboleth.sso/Login?target=/1.0/secure/TextGrid-WebAuth.php?authZinstance=test.textgridlab.org"
+    else:
+        return "https://textgridlab.org/1.0/Shibboleth.sso/Login?target=/1.0/secure/TextGrid-WebAuth.php?authZinstance=textgrid-esx2.gwdg.de"
+
+
+def get_projects():
+    projects = []
+    if current_user.is_authenticated:
+        path = os.path.join(MAIN_PATH, current_user.username)
+        for sub in os.listdir(path):
+            projectpath = os.path.join(path, sub)
+            if os.path.isdir(projectpath):
+                projects.append(Project(sub, current_user.username))
+    return projects
+
+
+app.jinja_env.globals.update(
+    len=len,
+    round=round,
+    title="TG Prepare",
+    get_projects=get_projects,
+    get_textgrid_login_url=get_textgrid_login_url,
+)
+
+
+def _startup():
+
+    # Create the projects directory if it does not exist
+    if not os.path.exists(MAIN_PATH):
+        os.makedirs(MAIN_PATH)
+
+    logging.getLogger("zeep").setLevel(logging.INFO)
+    app.run(
+        host=get_config_value("main", "host", default="0.0.0.0"),
+        port=get_config_value("main", "port", default=8077),
+        debug=get_config_value("log", "level", default="DEBUG") == "DEBUG",
+    )
+
+
+@click.command()
+@click.option("--path", "-p", default=None)
+def startup(path):
+    base_params["path"] = path if path else os.getcwd()
+    _startup()
+
+
+@app.route("/nextcloud_tab/", methods=["POST"])
+def nextcloud_tab():
+    nextcloud = Nextcloud(**session)
+    return render_template(
+        "nxc_tab.html",
+        nextcloud=nextcloud if nextcloud.test_connection() else None,
+        user=session.get("username", "-"),
+    )
+
+
+if __name__ == "__main__":
+    startup()

tgp_ui/routes/auth.py

@@ -0,0 +1,72 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2023-2025 TU-Dresden (ZIH)
+# ralf.klammer@tu-dresden.de
+# moritz.wilhelm@tu-dresden.de
+
+import logging
+
+from datetime import datetime
+
+from flask import (  # type: ignore
+    Blueprint,
+    render_template,
+    redirect,
+    url_for,
+    request,
+    flash,
+    current_app,
+)
+from flask_login import (  # type: ignore
+    login_user,
+    logout_user,
+    login_required,
+    current_user,
+)
+
+log = logging.getLogger(__name__)
+
+# Create Blueprint for authentication routes
+auth_routes = Blueprint("auth", __name__)
+
+
+@auth_routes.route("/login", methods=["GET", "POST"])
+def login():
+    # Redirect if user is already authenticated
+    if current_user.is_authenticated:
+        return redirect(url_for("views.overview"))
+
+    if request.method == "POST":
+        username = request.form.get("username")
+        password = request.form.get("password")
+        # Check if "remember me" option is selected
+        remember = True if request.form.get("remember") else False
+
+        user_manager = current_app.user_manager
+        user = user_manager.get_user(username)
+
+        # Validate user credentials
+        if not user or not user.check_password(password):
+            flash(
+                "Bitte überprüfe deine Anmeldedaten und versuche es erneut.",
+                "danger",
+            )
+            return render_template("auth/login.html")
+
+        # Login successful
+        user.last_login = datetime.now().isoformat()
+        user_manager.save_users()
+        login_user(user, remember=remember)
+
+        # Redirect to requested page or default to overview
+        next_page = request.args.get("next")
+        return redirect(next_page or url_for("views.overview"))
+
+    return render_template("auth/login.html")
+
+
+@auth_routes.route("/logout")
+@login_required
+def logout():
+    # Log out the current user
+    logout_user()
+    return redirect(url_for("auth.login"))