fix: issues (1)

Reviewed-on: #30

.bumpversion.toml

@@ -1,37 +0,0 @@
-[tool.bumpversion]
-current_version = "0.2.0-dev0"
-parse = """(?x)
-    (?P<major>0|[1-9]\\d*)\\.
-    (?P<minor>0|[1-9]\\d*)\\.
-    (?P<patch>0|[1-9]\\d*)
-    (?:
-        -                             # dash separator for pre-release section
-        (?P<pre_l>[a-zA-Z-]+)         # pre-release label
-        (?P<pre_n>0|[1-9]\\d*)        # pre-release version number
-    )?                                # pre-release section is optional
-"""
-serialize = [
-    "{major}.{minor}.{patch}-{pre_l}{pre_n}",
-    "{major}.{minor}.{patch}",
-]
-search = "{current_version}"
-replace = "{new_version}"
-regex = false
-ignore_missing_version = false
-ignore_missing_files = false
-tag = true
-sign_tags = false
-tag_name = "v{new_version}"
-tag_message = "Bump version: {current_version} → {new_version}"
-allow_dirty = false
-commit = true
-message = "Bump version: {current_version} → {new_version}"
-commit_args = ""
-setup_hooks = []
-pre_commit_hooks = []
-post_commit_hooks = []
-[tool.bumpversion.parts.pre_l]
-values = ["dev", "rc", "final"]
-optional_value = "final"
-[[tool.bumpversion.files]]
-filename = "src/__init__.py"

.gitea/workflows/docs.yml

@@ -0,0 +1,63 @@
+name: Documentation
+on:
+  push:
+    branches:
+      - master
+      - main
+    paths:
+      - "docs/**"
+      - "zensical.toml"
+jobs:
+  deploy-wiki:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v5
+
+      - name: Checkout wiki
+        uses: actions/checkout@v5
+        with:
+          repository: ${{ gitea.repository }}.wiki
+          path: wiki
+          token: ${{ secrets.GITEA_TOKEN }}
+
+      - name: Copy docs to wiki
+        run: |
+          # Remove old wiki content (except .git)
+          find wiki -mindepth 1 -maxdepth 1 ! -name '.git' -exec rm -rf {} +
+
+          # Copy markdown files maintaining structure
+          cp -r docs/* wiki/
+
+          # Rename index.md to Home.md for wiki homepage
+          if [ -f wiki/index.md ]; then
+            mv wiki/index.md wiki/Home.md
+          fi
+
+          # Flatten folder structure for Gitea wiki compatibility
+          # Move files from subfolders to root with prefixed names
+          for dir in wiki/*/; do
+            if [ -d "$dir" ]; then
+              dirname=$(basename "$dir")
+              for file in "$dir"*.md; do
+                if [ -f "$file" ]; then
+                  filename=$(basename "$file")
+                  if [ "$filename" = "index.md" ]; then
+                    mv "$file" "wiki/${dirname}.md"
+                  else
+                    mv "$file" "wiki/${dirname}-${filename}"
+                  fi
+                fi
+              done
+              rm -rf "$dir"
+            fi
+          done
+
+      - name: Push to wiki
+        run: |
+          cd wiki
+          git config user.name "Gitea Actions"
+          git config user.email "actions@gitea.local"
+          git add -A
+          git diff --staged --quiet || git commit -m "Update wiki from docs [skip ci]"
+          git push

.gitea/workflows/release.yml

@@ -0,0 +1,271 @@
+name: Build and Release
+
+on:
+  workflow_dispatch:
+    inputs:
+      github_release:
+        description: "Create Gitea Release"
+        default: true
+        type: boolean
+      prerelease:
+        description: "Is this a prerelease?"
+        default: false
+        type: boolean
+      bump:
+        description: "Bump type"
+        required: false
+        default: "patch"
+        type: choice
+        options:
+          - "major"
+          - "minor"
+          - "patch"
+
+env:
+  BASE_URL: "http://192.168.178.110:3000"
+
+jobs:
+  prepare:
+    runs-on: ubuntu-latest
+    outputs:
+      version: ${{ steps.bump.outputs.version }}
+      tag: ${{ steps.bump.outputs.tag }}
+      changelog: ${{ steps.build_changelog.outputs.changelog }}
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+          fetch-tags: true
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          # Uses the version specified in pyproject.toml
+          python-version-file: "pyproject.toml"
+
+      - name: Bump version (local only)
+        id: bump
+        run: |
+          uv version --bump "${{ github.event.inputs.bump }}"  
+
+          version="$(uv version --short)"
+
+          echo "VERSION=$version" >> "$GITHUB_ENV"
+          echo "version=$version" >> "$GITHUB_OUTPUT"
+          echo "tag=v$version" >> "$GITHUB_OUTPUT"
+
+      - name: Install all dependencies
+        run: uv sync --all-groups
+
+      - name: Build documentation
+        run: uv run zensical build --clean
+
+      - name: Upload documentation artifact
+        uses: https://github.com/christopherHX/gitea-upload-artifact@v4
+        with:
+          name: site
+          path: site/
+          retention-days: 1
+
+      - name: Build Changelog
+        id: build_changelog
+        uses: https://github.com/mikepenz/release-changelog-builder-action@v6.0.1
+        with:
+          platform: "gitea"
+          baseURL: "${{ env.BASE_URL }}"
+          configuration: ".gitea/changelog_config.json"
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITEA_TOKEN }}
+
+  # build-linux:
+  #   needs: prepare
+  #   runs-on: ubuntu-latest
+  #   env:
+  #     VERSION: ${{ needs.prepare.outputs.version }}
+  #     TAG_NAME: ${{ needs.prepare.outputs.tag }}
+
+  #   steps:
+  #     - name: Checkout code
+  #       uses: actions/checkout@v5
+  #       with:
+  #         fetch-depth: 0
+  #         fetch-tags: true
+
+  #     - name: Install uv
+  #       uses: astral-sh/setup-uv@v7
+
+  #     - name: Set up Python
+  #       uses: actions/setup-python@v5
+  #       with:
+  #         python-version-file: "pyproject.toml"
+
+  #     - name: Install all dependencies
+  #       run: uv sync --all-groups
+
+  #     - name: Build documentation
+  #       run: uv run zensical build --clean
+
+  #     - name: Build Linux release with Nuitka
+  #       run: |
+  #         uv add patchelf
+  #         uv run python -m nuitka \
+  #           --standalone \
+  #           --output-dir=dist \
+  #           --include-data-dir=./config=config \
+  #           --include-data-dir=./site=site \
+  #           --include-data-dir=./icons=icons \
+  #           --include-data-dir=./mail_vorlagen=mail_vorlagen \
+  #           --enable-plugin=pyside6 \
+  #           --product-name=SemesterApparatsManager \
+  #           --product-version=${VERSION} \
+  #           --output-filename=SAM \
+  #           main.py
+
+  #     - name: Prepare Linux Release Artifact
+  #       run: |
+  #         mkdir -p releases
+  #         cd dist/SemesterApparatsManager.dist
+  #         zip -r "../../releases/SAM-linux-v${VERSION}.zip" *
+  #         cd ../../
+
+  #     - name: Create / Update Gitea Release (Linux asset + changelog)
+  #       if: ${{ github.event.inputs.github_release == 'true' }}
+  #       uses: softprops/action-gh-release@v2
+  #       with:
+  #         tag_name: ${{ env.TAG_NAME }}
+  #         name: Release ${{ env.TAG_NAME }}
+  #         body: ${{ needs.prepare.outputs.changelog }}
+  #         draft: false
+  #         prerelease: ${{ github.event.inputs.prerelease }}
+  #         make_latest: true
+  #         files: |
+  #           releases/SAM-linux-v${{ env.VERSION }}.zip
+  #       env:
+  #         GITHUB_TOKEN: ${{ secrets.TOKEN }}
+  #         GITHUB_REPOSITORY: ${{ github.repository }}
+
+  build-windows:
+    needs: prepare
+    runs-on: windows-latest
+    env:
+      VERSION: ${{ needs.prepare.outputs.version }}
+      TAG_NAME: ${{ needs.prepare.outputs.tag }}
+      UV_PATH: 'C:\Users\gitea_runner_windows\.local\bin\uv.exe'
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v5
+
+      - name: Download documentation artifact
+        uses: christopherhx/gitea-download-artifact@v4
+        with:
+          name: site
+          path: site/
+
+      - name: Ensure Python via uv
+        shell: powershell
+        run: |
+          if (-not (Test-Path $env:UV_PATH)) {
+            Write-Error "uv not found at $env:UV_PATH"
+            exit 1
+          }
+
+          & $env:UV_PATH self update
+
+          $version = "3.12"
+          Write-Host "Checking for Python $version via uv..."
+          $exists = & $env:UV_PATH python list | Select-String $version -Quiet
+
+          if (-not $exists) {
+            Write-Host "Python $version not found; installing with uv..."
+            & $env:UV_PATH python install $version
+          } else {
+            Write-Host "Python $version already installed in uv."
+          }
+
+      - name: Install build dependencies
+        shell: powershell
+        run: |
+          & $env:UV_PATH sync --all-groups
+
+      - name: Build Windows release with Nuitka
+        shell: powershell
+        run: |
+          & $env:UV_PATH run --python 3.12 python -m nuitka `
+            --standalone `
+            --assume-yes-for-downloads `
+            --output-dir=dist `
+            --mingw64 `
+            --include-data-dir=./config=config `
+            --include-data-dir=./site=site `
+            --include-data-dir=./icons=icons `
+            --include-data-dir=./mail_vorlagen=mail_vorlagen `
+            --enable-plugin=pyside6 `
+            --product-name=SemesterApparatsManager `
+            --product-version=${env:VERSION} `
+            --output-filename=SAM.exe `
+            main.py
+
+      - name: Prepare Windows Release Artifact
+        shell: powershell
+        run: |
+          New-Item -ItemType Directory -Force -Path releases | Out-Null
+          Set-Location dist
+          Compress-Archive -Path * -DestinationPath "..\releases\SAM-windows-v${env:VERSION}.zip" -Force
+          Set-Location ..
+
+      - name: Create / Update Gitea Release (Windows asset + changelog)
+        if: ${{ github.event.inputs.github_release == 'true' }}
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{ env.TAG_NAME }}
+          name: Release ${{ env.TAG_NAME }}
+          body: ${{ needs.prepare.outputs.changelog }}
+          draft: false
+          prerelease: ${{ github.event.inputs.prerelease }}
+          make_latest: true
+          files: |
+            releases/SAM-windows-v${{ env.VERSION }}.zip
+        env:
+          GITHUB_TOKEN: ${{ secrets.TOKEN }}
+          GITHUB_REPOSITORY: ${{ github.repository }}
+
+  finalize:
+    needs: [prepare, build-windows]
+    runs-on: ubuntu-latest
+    env:
+      VERSION: ${{ needs.prepare.outputs.version }}
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+          fetch-tags: true
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version-file: "pyproject.toml"
+
+      - name: Set Git identity
+        run: |
+          git config user.name "Gitea CI"
+          git config user.email "ci@git.theprivateserver.de"
+
+      - name: Bump version and push
+        run: |
+          uv version --bump "${{ github.event.inputs.bump }}"
+      - name: Push version bump
+        uses: ad-m/github-push-action@master
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          branch: ${{ github.ref }}

.gitignore

@@ -226,5 +226,8 @@ output
 
 config.yaml
 **/tempCodeRunnerFile.py
-uv.lock
-uv.lock
+
+logs/
+*.pdf
+*.docx
+test.py

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "docs/themes/tanuki"]
+	path = docs/themes/tanuki
+	url = https://github.com/raskell-io/tanuki

.pre-commit-config.yaml

@@ -0,0 +1,13 @@
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.8.6
+    hooks:
+      # Run the formatter
+      - id: ruff-format
+        name: ruff format
+        types_or: [python, pyi, jupyter]
+      # Run the linter with auto-fix
+      - id: ruff
+        name: ruff check
+        args: [--fix]
+        types_or: [python, pyi, jupyter]

.python-version

@@ -1 +1 @@
-3.13
+3.14

.version

@@ -0,0 +1 @@
+1.0.2

.vscode/settings.json

@@ -32,6 +32,7 @@
   "cSpell.words": [
     "adis",
     "Adminbereich",
+    "akkey",
     "Apparatdetails",
     "apparate",
     "appname",
@@ -54,4 +55,7 @@
     "Strg",
     "telnr"
   ],
+  "yaml.schemas": {
+    "https://www.schemastore.org/github-workflow.json": "file:///c%3A/Users/aky547/GitHub/SemesterapparatsManager/.gitea/workflows/release.yml"
+  },
 }

MIGRATION_GUIDE.md

@@ -0,0 +1,216 @@
+# Migration Guide: New File Structure
+
+## Overview
+
+The codebase has been reorganized to improve clarity, maintainability, and separation of concerns. This guide shows how to update your imports.
+
+## New Structure Summary
+
+```
+src/
+├── core/           # Domain models & constants (formerly in logic/)
+├── database/       # Data persistence (formerly in backend/)
+├── services/       # External APIs (from backend/ and logic/)
+├── parsers/        # File parsing (formerly in logic/)
+├── documents/      # Document generation (formerly in utils/)
+├── background/     # Threading tasks (formerly in backend/)
+├── admin/          # Admin commands (formerly in backend/)
+├── shared/         # Cross-cutting concerns (logging, config)
+├── utils/          # Pure utilities
+├── ui/             # UI components (unchanged)
+└── errors/         # Custom exceptions (unchanged)
+```
+
+## Import Changes
+
+### Core Domain Models
+
+**OLD:**
+```python
+from src.logic import BookData, Prof, Semester, Apparat
+from src.logic.dataclass import BookData, Prof
+from src.logic.semester import Semester
+from src.logic.constants import APP_NRS, SEMAP_MEDIA_ACCOUNTS
+```
+
+**NEW:**
+```python
+from src.core.models import BookData, Prof, Semester, Apparat, ApparatData
+from src.core import BookData, Prof, Semester  # Can use shorthand
+from src.core.semester import Semester
+from src.core.constants import APP_NRS, SEMAP_MEDIA_ACCOUNTS
+```
+
+### Database
+
+**OLD:**
+```python
+from src.backend import Database
+from src.backend.database import Database
+from src.backend.db import CREATE_TABLE_MEDIA
+```
+
+**NEW:**
+```python
+from src.database import Database
+from src.database.connection import Database  # If you need specific module
+from src.database.schemas import CREATE_TABLE_MEDIA
+```
+
+### External Services & APIs
+
+**OLD:**
+```python
+from src.backend.catalogue import Catalogue
+from src.backend.webadis import get_book_medianr
+from src.logic.SRU import SWB
+from src.logic.lehmannsapi import LehmannsClient
+from src.logic.zotero import ZoteroController
+from src.logic.webrequest import BibTextTransformer, WebRequest
+```
+
+**NEW:**
+```python
+from src.services import Catalogue, SWB, LehmannsClient, ZoteroController
+from src.services.catalogue import Catalogue
+from src.services.webadis import get_book_medianr
+from src.services.sru import SWB
+from src.services.lehmanns import LehmannsClient
+from src.services.zotero import ZoteroController
+from src.services.webrequest import BibTextTransformer, WebRequest
+```
+
+### Parsers
+
+**OLD:**
+```python
+from src.logic import csv_to_list, word_to_semap
+from src.logic.csvparser import csv_to_list
+from src.logic.wordparser import word_to_semap
+from src.logic.pdfparser import pdf_to_text
+from src.logic.xmlparser import xml_to_dict
+```
+
+**NEW:**
+```python
+from src.parsers import csv_to_list, word_to_semap  # Lazy loading
+from src.parsers.csv_parser import csv_to_list
+from src.parsers.word_parser import word_to_semap
+from src.parsers.pdf_parser import pdf_to_text
+from src.parsers.xml_parser import xml_to_dict
+```
+
+### Document Generation
+
+**OLD:**
+```python
+from src.utils.richtext import create_document, create_pdf
+```
+
+**NEW:**
+```python
+from src.documents import create_document, create_pdf
+from src.documents.generators import create_document, create_pdf
+```
+
+### Background Tasks
+
+**OLD:**
+```python
+from src.backend import AutoAdder, AvailChecker, BookGrabber
+from src.backend.threads_autoadder import AutoAdder
+from src.backend.threads_availchecker import AvailChecker
+from src.backend.thread_bookgrabber import BookGrabber
+from src.backend.thread_neweditions import NewEditionCheckerThread
+```
+
+**NEW:**
+```python
+from src.background import AutoAdder, AvailChecker, BookGrabber, NewEditionCheckerThread
+from src.background.autoadder import AutoAdder
+from src.background.availability_checker import AvailChecker
+from src.background.book_grabber import BookGrabber
+from src.background.new_editions import NewEditionCheckerThread
+```
+
+### Admin Commands
+
+**OLD:**
+```python
+from src.backend import AdminCommands
+from src.backend.admin_console import AdminCommands
+```
+
+**NEW:**
+```python
+from src.admin import AdminCommands
+from src.admin.commands import AdminCommands
+```
+
+### Configuration & Logging
+
+**OLD:**
+```python
+from src.backend.settings import Settings
+from src.logic.settings import Settings
+from src.shared.logging import log  # This stays the same
+```
+
+**NEW:**
+```python
+from src.shared import Settings, load_config, log
+from src.shared.config import Settings, load_config
+from src.shared.logging import log
+```
+
+## File Renames
+
+| Old Path | New Path |
+|----------|----------|
+| `logic/dataclass.py` | `core/models.py` |
+| `logic/SRU.py` | `services/sru.py` |
+| `logic/lehmannsapi.py` | `services/lehmanns.py` |
+| `backend/database.py` | `database/connection.py` |
+| `backend/db.py` | `database/schemas.py` |
+| `backend/threads_autoadder.py` | `background/autoadder.py` |
+| `backend/threads_availchecker.py` | `background/availability_checker.py` |
+| `backend/thread_bookgrabber.py` | `background/book_grabber.py` |
+| `backend/thread_neweditions.py` | `background/new_editions.py` |
+| `backend/admin_console.py` | `admin/commands.py` |
+| `utils/richtext.py` | `documents/generators.py` |
+| `logic/csvparser.py` | `parsers/csv_parser.py` |
+| `logic/pdfparser.py` | `parsers/pdf_parser.py` |
+| `logic/wordparser.py` | `parsers/word_parser.py` |
+| `logic/xmlparser.py` | `parsers/xml_parser.py` |
+
+## Quick Migration Checklist
+
+1. ✅ Update all `from src.backend import Database` → `from src.database import Database`
+2. ✅ Update all `from src.logic import BookData` → `from src.core.models import BookData`
+3. ✅ Update all `from src.backend.catalogue` → `from src.services.catalogue`
+4. ✅ Update all `from src.logic.SRU` → `from src.services.sru`
+5. ✅ Update all `from src.backend.admin_console` → `from src.admin`
+6. ✅ Update threading imports from `src.backend.thread*` → `src.background.*`
+
+## Benefits
+
+- **Clearer architecture**: Each folder has a specific, well-defined purpose
+- **Better dependency flow**: core → database/services → background → ui
+- **Reduced duplication**: Merged 3 duplicate files (pickles.py, settings.py)
+- **Easier navigation**: Intuitive folder names ("services" vs "logic")
+- **Scalability**: Clear extension points for new features
+
+## Backwards Compatibility
+
+The old `backend/` and `logic/` folders still exist with original files. They will be removed in a future cleanup phase after thorough testing.
+
+## Questions?
+
+If you encounter import errors:
+1. Check this guide for the new import path
+2. Search for the class/function name in the new structure
+3. Most moves follow the pattern: external APIs → `services/`, data models → `core/`, threads → `background/`
+
+## Status
+
+✅ **Migration Complete** - Application successfully starts and runs with new structure!

README.md

@@ -1,3 +1,443 @@
-# Semesterapparate
+# SemesterapparatsManager
 
-this repo will be used to create a GUI application to manage the semesterapparate of the PH Freiburg.
+[![Python](https://img.shields.io/badge/Python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![PySide6](https://img.shields.io/badge/PySide6-Qt6-green.svg)](https://doc.qt.io/qtforpython/)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+A comprehensive desktop application for managing semester course reserve collections (Semesterapparate) at the University of Education Freiburg. This tool streamlines the workflow of creating, managing, and maintaining both physical and digital course reserves, with integrated citation management powered by Zotero.
+
+## 📋 Table of Contents
+
+- [Overview](#overview)
+- [Features](#features)
+- [Architecture](#architecture)
+- [Installation](#installation)
+- [Usage](#usage)
+- [Development](#development)
+- [Documentation](#documentation)
+- [Contributing](#contributing)
+- [License](#license)
+
+## 🎯 Overview
+
+SemesterapparatsManager is a Python-based graphical application designed to simplify the complex workflow of academic course reserve management. It provides librarians and staff with tools to:
+
+- **Manage Physical Reserves**: Track books, media, and materials reserved for courses
+- **Handle Digital Collections**: Process, scan, and catalog digital course materials
+- **Automate Citations**: Generate proper bibliographic citations using Zotero integration
+- **Communicate**: Send automated emails to professors about reserve status
+- **Analyze**: View statistics and search through historical data
+- **Integrate**: Connect with library catalogs (SWB, DNB) and vendor APIs (Lehmanns)
+
+### Key Technologies
+
+- **Framework**: PySide6 (Qt6) for cross-platform GUI
+- **Database**: SQLite with migration support
+- **APIs**: Integration with SWB, DNB, Zotero, OpenAI, and catalog services
+- **Document Processing**: Word, PDF, CSV, and XML parsing
+- **Bibliography**: Zotero-based citation management
+
+## ✨ Features
+
+### Course Reserve Management
+
+- **Create & Edit**: Add new semester apparatus with book and media entries
+- **Extend Duration**: Extend existing reserves for additional semesters  
+- **Smart Search**: Find reserves by semester, professor, subject, or signature
+- **Availability Checking**: Automated checks against library catalog
+- **New Edition Detection**: Background thread to find newer editions of books
+
+### Digital Collection Features
+
+- **Document Parsing**: Extract information from submitted Word/PDF forms
+- **Smart Splitting**: Automatically split multi-part book sections
+- **Citation Generation**: Create proper citations for all digital files
+- **ELSA Integration**: Manage electronic semester apparatus (ELSA) workflows
+- **File Management**: Track and recreate files from database
+
+### Communication & Notifications
+
+- **Email Templates**: Pre-configured templates for common scenarios
+- **Professor Notifications**: Automated emails for creation, extension, or dissolution
+- **Message System**: Attach messages to specific reserves or broadcast to all
+
+### Data & Analytics
+
+- **Statistics Dashboard**: Visualize creation and deletion trends
+- **Advanced Search**: Multi-criteria search across all reserves
+- **Export**: Generate reports and documentation
+- **Calendar View**: Timeline of reserve activities
+
+### Administration
+
+- **User Management**: Create, edit, and delete system users
+- **Professor Database**: Maintain professor contact information
+- **Settings Configuration**: Customize database paths, temp directories, API keys
+- **Backup & Migration**: Database migration support for schema updates
+
+## 🏗️ Architecture
+
+### Project Structure
+
+```
+SemesterapparatsManager/
+├── src/
+│   ├── core/              # Domain models & constants
+│   │   ├── models.py      # BookData, Prof, Apparat, Semester, etc.
+│   │   ├── constants.py   # Application constants
+│   │   └── semester.py    # Semester handling logic
+│   ├── database/          # Data persistence layer
+│   │   ├── connection.py  # Database class & operations
+│   │   ├── schemas.py     # SQL schema definitions
+│   │   └── migrations/    # SQL migration files
+│   ├── services/          # External API integrations
+│   │   ├── catalogue.py   # RDS catalog scraping
+│   │   ├── sru.py         # SWB/DNB library API client
+│   │   ├── lehmanns.py    # Lehmanns bookstore API
+│   │   ├── zotero.py      # Zotero integration
+│   │   ├── webadis.py     # WebADIS automation
+│   │   └── openai.py      # OpenAI API integration
+│   ├── parsers/           # Document & file parsing
+│   │   ├── csv_parser.py  # CSV parsing
+│   │   ├── word_parser.py # Word document parsing
+│   │   ├── pdf_parser.py  # PDF text extraction
+│   │   ├── xml_parser.py  # XML parsing
+│   │   └── transformers/  # Bibliography format conversion
+│   ├── documents/         # Document generation
+│   │   └── generators.py  # Word/PDF document creation
+│   ├── background/        # Background tasks & threading
+│   │   ├── autoadder.py   # Automatic book addition
+│   │   ├── availability_checker.py  # Catalog availability
+│   │   ├── book_grabber.py          # Catalog metadata retrieval
+│   │   └── new_editions.py          # New edition detection
+│   ├── ui/                # User interface components
+│   │   ├── userInterface.py  # Main application window
+│   │   ├── dialogs/       # Dialog windows
+│   │   └── widgets/       # Reusable UI widgets
+│   ├── admin/             # Administrative functions
+│   │   └── commands.py    # Admin CLI commands
+│   ├── utils/             # Utility functions
+│   │   ├── files.py       # File operations
+│   │   ├── sorting.py     # Custom sorting logic
+│   │   └── blob.py        # Binary data handling
+│   ├── shared/            # Cross-cutting concerns
+│   │   ├── logging.py     # Centralized logging
+│   │   └── config.py      # Configuration management
+│   └── errors/            # Custom exceptions
+│       └── database.py    # Database-specific errors
+├── tests/                 # Test suite
+├── docs/                  # Documentation
+├── mail_vorlagen/         # Email templates
+├── config.yaml            # Application configuration
+├── main.py                # Application entry point
+└── README.md
+```
+
+### Architecture Principles
+
+**Layered Architecture**:
+```
+UI Layer (PySide6 Qt Widgets)
+    ↓
+Background Tasks (QThread workers)
+    ↓
+Business Logic (Core models & operations)
+    ↓
+Services Layer (External API integrations)
+    ↓
+Data Access Layer (Database & file operations)
+```
+
+**Key Design Patterns**:
+- **Repository Pattern**: Database class abstracts data persistence
+- **Service Layer**: External integrations isolated in `services/`
+- **Observer Pattern**: Qt signals/slots for event-driven updates
+- **Factory Pattern**: Document and citation generators
+- **Strategy Pattern**: Multiple parsing strategies for different file formats
+
+## 🚀 Installation
+
+### Prerequisites
+
+- Python 3.10 or higher
+- [uv](https://github.com/astral-sh/uv) - Fast Python package installer and resolver (recommended)
+  ```bash
+  # Install uv (Windows PowerShell)
+  powershell -c "irm https://astral.sh/uv/install.ps1 | iex"
+  
+  # Or using pip
+  pip install uv
+  ```
+
+### Setup Steps (Using uv - Recommended)
+
+1. **Clone the repository**:
+   ```bash
+   git clone https://github.com/yourusername/SemesterapparatsManager.git
+   cd SemesterapparatsManager
+   ```
+
+2. **Create virtual environment and install dependencies**:
+   ```bash
+   # uv automatically creates venv and installs dependencies
+   uv sync
+   ```
+
+3. **Configure application**:
+   - First launch will present a setup wizard
+   - Configure database path, temp directory, and API keys
+   - Create admin user account
+
+4. **Run the application**:
+   ```bash
+   uv run python main.py
+   ```
+
+### Alternative Setup (Using pip/venv)
+
+<details>
+<summary>Click to expand traditional pip installation steps</summary>
+
+1. **Create virtual environment**:
+   ```bash
+   python -m venv .venv
+   ```
+
+2. **Activate virtual environment**:
+   - Windows (PowerShell):
+     ```powershell
+     .venv\Scripts\Activate.ps1
+     ```
+   - Linux/Mac:
+     ```bash
+     source .venv/bin/activate
+     ```
+
+3. **Install dependencies**:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+4. **Run the application**:
+   ```bash
+   python main.py
+   ```
+
+</details>
+
+### Building Executable
+
+To build a standalone executable:
+
+```bash
+# Using uv
+uv run pyinstaller --noconfirm --onedir --windowed \
+  --icon='icons/app.ico' \
+  --name='SemesterapparatsManager' \
+  --clean \
+  --add-data='config.yaml;.' \
+  --add-data='icons;icons' \
+  main.py
+```
+
+Or use the provided build task (see `pyproject.toml`).
+
+## 📖 Usage
+
+### First Time Setup
+
+1. **Launch Application**: Run `python main.py`
+2. **Setup Wizard**: Configure basic settings
+   - Database location
+   - Temporary files directory
+   - Library catalog credentials (optional)
+   - API keys (Zotero, OpenAI - optional)
+3. **Create Admin User**: Set up your admin credentials
+4. **Login**: Use your credentials to access the main interface
+
+### Creating a Semester Apparatus
+
+1. **Navigate**: Main window → "Neuer Apparat" (New Apparatus)
+2. **Fill Details**:
+   - Semester (e.g., WiSe 2024/25)
+   - Professor information
+   - Course subject
+   - Apparatus number
+3. **Add Books**: Click "Buch hinzufügen" (Add Book)
+   - Enter signature or search by title
+   - System fetches metadata from catalog
+   - Add multiple books as needed
+4. **Add Media**: Click "Medium hinzufügen" (Add Media)
+   - DVDs, CDs, or other media types
+5. **Save**: Confirm and create the apparatus
+6. **Generate Email**: Optionally send notification to professor
+
+### Managing Digital Collections (ELSA)
+
+1. **Upload Form**: Submit Word/PDF form with book chapter information
+### Setting Up Development Environment
+
+1. **Install all dependencies** (including dev dependencies):
+   ```bash
+   # Using uv (recommended)
+   uv sync --all-extras
+   
+   # Or using pip
+   pip install -r requirements-dev.txt
+   ```
+
+2. **Enable logging**:
+   ```python
+   from src.shared.logging import configure
+   configure("DEBUG")  # In main.py
+   ```
+
+3. **Run tests**:
+   ```bash
+   # Using uv
+   uv run pytest tests/
+   
+   # Or with activated venv
+   pytest tests/
+   ```ministrative Tasks
+
+- **User Management**: Admin → Users → Create/Edit/Delete
+- **Professor Database**: Admin → Professors → Manage contacts
+- **System Settings**: Edit → Settings → Configure paths and APIs
+- **Database Maintenance**: Admin → Database → Run migrations
+
+## 🛠️ Development
+
+### Setting Up Development Environment
+
+1. **Install dev dependencies**:
+   ```bash
+   pip install -r requirements-dev.txt
+   ```
+
+2. **Enable logging**:
+   ```python
+   from src.shared.logging import configure
+   configure("DEBUG")  # In main.py
+   ```
+
+3. **Run tests**:
+   ```bash
+   pytest tests/
+   ```
+
+### Project Standards
+
+- **Code Style**: Follow PEP 8
+- **Type Hints**: Use type annotations where possible
+- **Docstrings**: Google-style docstrings for all public functions
+- **Logging**: Use centralized logger from `src.shared.logging`
+- **Imports**: Use new structure (see MIGRATION_GUIDE.md)
+
+### Database Migrations
+
+To create a new migration:
+
+1. Create file: `src/database/migrations/V###__description.sql`
+2. Use sequential numbering (V001, V002, etc.)
+3. Write idempotent SQL (use `IF NOT EXISTS`)
+4. Test migration on copy of production database
+
+Example:
+```sql
+-- V003__add_user_preferences.sql
+CREATE TABLE IF NOT EXISTS user_preferences (
+    user_id INTEGER PRIMARY KEY,
+    theme TEXT DEFAULT 'light',
+    language TEXT DEFAULT 'de',
+    FOREIGN KEY (user_id) REFERENCES user(id)
+);
+```
+
+### Adding New Features
+
+**New Service Integration**:
+1. Create module in `src/services/`
+2. Implement client class with proper error handling
+3. Add to `src/services/__init__.py`
+4. Document API requirements
+
+**New Document Parser**:
+1. Create module in `src/parsers/`
+2. Implement parsing function returning core models
+3. Add to `src/parsers/__init__.py`
+4. Write unit tests
+
+**New UI Dialog**:
+1. Design in Qt Designer (`.ui` file)
+2. Convert: `pyside6-uic dialog.ui -o dialog_ui.py`
+3. Create dialog class in `src/ui/dialogs/`
+4. Connect signals to business logic
+
+## 📚 Documentation
+
+- **[User Manual](docs/)**: Complete user guide built with Zola and the Tanuki theme
+- View documentation at `http://localhost:8000` when running the application
+
+### Building Documentation
+
+The documentation is built using [Zola](https://www.getzola.org/) with the Tanuki theme.
+
+```bash
+# Build documentation using the provided script
+.\build_docs.ps1
+
+# Or manually:
+cd docs
+zola build
+
+# Serve documentation locally for development
+cd docs
+zola serve  # View at http://127.0.0.1:1111
+```
+
+The built documentation is served automatically when you run the application and access the documentation menu.
+
+## 🤝 Contributing
+
+Contributions are welcome! Please follow these guidelines:
+
+1. **Fork** the repository
+2. **Create** a feature branch (`git checkout -b feature/amazing-feature`)
+3. **Commit** your changes (`git commit -m 'Add amazing feature'`)
+4. **Push** to the branch (`git push origin feature/amazing-feature`)
+5. **Open** a Pull Request
+
+### Code Review Checklist
+
+- [ ] Code follows project style guidelines
+- [ ] All tests pass
+- [ ] New features have tests
+- [ ] Documentation is updated
+- [ ] No sensitive data in commits
+- [ ] Import paths use new structure
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🙏 Acknowledgments
+
+- **University of Education Freiburg**: Project sponsor and primary user
+- **Qt/PySide6**: Excellent cross-platform GUI framework
+- **Zotero**: Citation management integration
+- **SWB/DNB**: Library catalog services
+
+## 📞 Support
+
+For questions, issues, or feature requests:
+- **Issues**: [Gitea Issues](https://git.theprivateserver.de/PHB/SemesterapparatsManager/issues)
+- **Email**: alexander.kirchner@ph-freiburg.de
+- **Documentation**: [Read the Docs](https://semesterapparatsmanager.readthedocs.io)
+
+## 🗺️ Roadmap
+
+TBD
+---
+
+**Built with ❤️ for academic libraries**

__main__.py

@@ -1,4 +0,0 @@
-from src.ui.userInterface import launch_gui as UI
-
-if __name__ == "__main__":
-    UI()  #:des

build.app.json

@@ -1,69 +0,0 @@
-{
- "version": "auto-py-to-exe-configuration_v1",
- "pyinstallerOptions": [
-  {
-   "optionDest": "noconfirm",
-   "value": true
-  },
-  {
-   "optionDest": "filenames",
-   "value": "C:/Users/aky547/GitHub/SemesterapparatsManager/__main__.py"
-  },
-  {
-   "optionDest": "onefile",
-   "value": false
-  },
-  {
-   "optionDest": "console",
-   "value": false
-  },
-  {
-   "optionDest": "icon_file",
-   "value": "C:/Users/aky547/Downloads/VZjRNn1k.ico"
-  },
-  {
-   "optionDest": "name",
-   "value": "SemesterAppMan"
-  },
-  {
-   "optionDest": "clean_build",
-   "value": true
-  },
-  {
-   "optionDest": "strip",
-   "value": false
-  },
-  {
-   "optionDest": "noupx",
-   "value": false
-  },
-  {
-   "optionDest": "disable_windowed_traceback",
-   "value": false
-  },
-  {
-   "optionDest": "uac_admin",
-   "value": false
-  },
-  {
-   "optionDest": "uac_uiaccess",
-   "value": false
-  },
-  {
-   "optionDest": "argv_emulation",
-   "value": false
-  },
-  {
-   "optionDest": "bootloader_ignore_signals",
-   "value": false
-  },
-  {
-   "optionDest": "datas",
-   "value": "C:/Users/aky547/GitHub/SemesterapparatsManager/config.yaml;."
-  }
- ],
- "nonPyinstallerOptions": {
-  "increaseRecursionLimit": true,
-  "manualArguments": ""
- }
-}

build.py

@@ -0,0 +1,31 @@
+import os
+import shutil
+
+with open(".version", "r") as version_file:
+    version = version_file.read().strip()
+
+print("Building the project...")
+print("Cleaning build dir...")
+# clear dist directory
+if os.path.exists("dist"):
+    shutil.rmtree("dist")
+    os.makedirs("dist")
+print("Build directory cleaned.")
+build = input("Include console in  build? (y/n): ").strip().lower()
+
+
+command = f"uv run python -m nuitka --standalone --output-dir=dist --include-data-dir=./config=config --include-data-dir=./site=site --include-data-dir=./icons=icons --include-data-dir=./mail_vorlagen=mail_vorlagen --enable-plugin=pyside6 --product-name=SemesterApparatsManager --product-version={version}  --output-filename=SAM.exe --windows-icon-from-ico=icons/logo.ico"
+executable = "main.py"
+
+
+if build == 'y':
+
+    os.system(f"{command} {executable}")
+else:
+    command += " --windows-console-mode=disable"
+    os.system(f"{command} {executable}")
+
+# rename main.dist in dist dir to SemesterApparatsManager
+os.rename("dist/main.dist", "dist/SemesterApparatsManager")
+
+print("Build complete.")

config/base_config.yaml

@@ -0,0 +1,57 @@
+default_apps: true
+save_path: .
+icon_path: icons/
+openAI:
+  api_key:
+  model: 
+zotero:
+  api_key: 
+  library_id: 
+  library_type: user
+database:
+  name: semesterapparate.db
+  path: .
+  temp: ~/AppData/Local/SAM/SemesterApparatsManager/Cache
+mail:
+  smtp_server: 
+  port: 
+  sender: 
+  printer_mail: 
+  user_name: 
+  use_user_name: true
+  password: 
+  signature: 
+colors:
+  dark: '#6b6160'
+  light: '#000000'
+  warning: '#ff0000'
+  success: '#00ff00'
+icons:
+  locked: locked.svg
+  logo: logo.ico
+  show_password: visibility_off.svg
+  hide_password: visibility_on.svg
+  settings: settings.svg
+  today: calendar_today.svg
+  save: save.svg
+  edit_note: edit_note.svg
+  warning: warning.svg
+  error: error.svg
+  mail: mail.svg
+  semester: semester.svg
+  template_fail: test_fail.svg
+  offAction: shutdown.svg
+  info: info.svg
+  help: help.svg
+  close: close.svg
+  notification: notification.svg
+  valid_true: check_success.svg
+  valid_false: check_fail.svg
+  edit: edit.svg
+  important_warn: red_warn.svg
+  person: person_add.svg
+  database: database.svg
+  icons: icons.svg
+  api: api.svg
+  print: print.svg
+  db_search: db_search.svg

config/config.py

@@ -1,7 +1,20 @@
-from typing import Optional
+from typing import Optional, Any, Union
 from dataclasses import dataclass
-from omegaconf import OmegaConf, DictConfig
+from omegaconf import OmegaConf, DictConfig, ListConfig
 import os
+from pathlib import Path
+
+
+@dataclass
+class OpenAI:
+    api_key: str
+    model: str
+
+    def getattr(self, name: str):
+        return getattr(self, name)
+
+    def _setattr(self, name: str, value: Any):
+        setattr(self, name, value)
 
 
 @dataclass
@@ -10,33 +23,41 @@ class Zotero:
     library_id: str
     library_type: str
 
-    def getattr(self, name):
+    def getattr(self, name: str):
         return getattr(self, name)
 
-    def _setattr(self, name, value):
+    def _setattr(self, name: str, value: Any):
         setattr(self, name, value)
 
 
 @dataclass
 class Database:
     name: str
-    path: str
-    temp: str
+    path: Union[str, Path, None]
+    temp: Union[str, Path, None]
 
-    def getattr(self, name):
+    def getattr(self, name: str):
         return getattr(self, name)
 
-    def _setattr(self, name, value):
+    def _setattr(self, name: str, value: Any):
         setattr(self, name, value)
 
+    def __post_init__(self):
+        if isinstance(self.path, str):
+            self.path = Path(self.path).expanduser()
+        if isinstance(self.temp, str):
+            self.temp = Path(self.temp).expanduser()
+
 
 @dataclass
 class Mail:
     smtp_server: str
     port: int
     sender: str
+    sender_name: str
     password: str
     use_user_name: bool
+    printer_mail: str
     user_name: str
     signature: str | None = None
     empty_signature = """<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN" "http://www.w3.org/TR/REC-html40/strict.dtd">
@@ -58,13 +79,13 @@ class Mail:
     <p style="-qt-paragraph-type:empty; margin-top:0px; margin-bottom:0px; margin-left:0px;
     margin-right:0px; -qt-block-indent:0; text-indent:0px;"><br /></p></body></html>"""
 
-    def getattr(self, name):
+    def getattr(self, name: str):
         return getattr(self, name)
 
-    def _setattr(self, name, value):
+    def _setattr(self, name: str, value: Any):
         setattr(self, name, value)
 
-    def setValue(self, **kwargs):
+    def setValue(self, **kwargs: Any):
         for key, value in kwargs.items():
             if hasattr(self, key):
                 setattr(self, key, value)
@@ -78,7 +99,7 @@ class Icons:
         self._colors = None
         self._icons = None
 
-    def assign(self, key, value):
+    def assign(self, key: str, value: Any):
         setattr(self, key, value)
 
     @property
@@ -86,7 +107,7 @@ class Icons:
         return self._path
 
     @path.setter
-    def path(self, value):
+    def path(self, value: Any):
         self._path = value
 
     @property
@@ -94,7 +115,7 @@ class Icons:
         return self._colors
 
     @colors.setter
-    def colors(self, value):
+    def colors(self, value: Any):
         self._colors = value
 
     @property
@@ -102,10 +123,10 @@ class Icons:
         return self._icons
 
     @icons.setter
-    def icons(self, value):
+    def icons(self, value: Any):
         self._icons = value
 
-    def get(self, name):
+    def get(self, name: str):
         return self.icons.get(name)
 
 
@@ -119,7 +140,8 @@ class Config:
 
     """
 
-    _config: Optional[DictConfig] = None
+    _config: Optional[Union[DictConfig, ListConfig]] = None
+    config_exists: bool = True
 
     def __init__(self, config_path: str):
         """
@@ -132,10 +154,22 @@ class Config:
             FileNotFoundError: Configuration file not found
         """
         if not os.path.exists(config_path):
-            raise FileNotFoundError(f"Configuration file not found: {config_path}")
+            # copy base config file to the given path
+            base = "config/base_config.yaml"
+            if not os.path.exists(base):
+                raise FileNotFoundError(f"Base configuration file not found: {base}")
+            with open(base, "r") as base_file:
+                base_config = base_file.read()
+            with open(config_path, "w") as config_file:
+                config_file.write(base_config)
+            self.config_exists = False
         self._config = OmegaConf.load(config_path)
         self.config_path = config_path
 
+    @property
+    def exists(self) -> bool:
+        return self.config_exists
+
     def save(self):
         """
         Saves the current configuration to the file.
@@ -145,62 +179,92 @@ class Config:
         """
         OmegaConf.save(self._config, self.config_path)
 
+    def reload(self):
+        """
+        Reloads the configuration from the file.
+        """
+        if self.config_path is not None:
+            self._config = OmegaConf.load(self.config_path)
+
     @property
     def zotero(self):
+        if self._config is None:
+            raise RuntimeError("Configuration not loaded")
         return Zotero(**self._config.zotero)
 
-    @property
-    def zotero_attr(self, name):
+    def get_zotero_attr(self, name: str):
         return getattr(self.zotero, name)
 
-    @zotero_attr.setter
-    def zotero_attr(self, name, value):
+    def set_zotero_attr(self, name: str, value: Any):
         self.zotero._setattr(name, value)
 
     @property
     def database(self):
+        if self._config is None:
+            raise RuntimeError("Configuration not loaded")
         return Database(**self._config.database)
 
     @property
-    def database_attr(self, name):
+    def database_attr(self, name: str):
         return getattr(self.database, name)
 
     @database_attr.setter
-    def database_attr(self, name, value):
+    def database_attr(self, name: str, value: Any):
         self.database._setattr(name, value)
 
+    @property
+    def openAI(self):
+        if self._config is None:
+            raise RuntimeError("Configuration not loaded")
+        return OpenAI(**self._config.openAI)
+
     @property
     def mail(self):
+        if self._config is None:
+            raise RuntimeError("Configuration not loaded")
         return Mail(**self._config.mail)
 
-    def mail_attr(self, name):
+    def mail_attr(self, name: str):
         return getattr(self.mail, name)
 
-    def set_mail_attr(self, name, value):
-        OmegaConf.update(self._config, f"mail.{name}", value)
+    def set_mail_attr(self, name: str, value: Any):
+        if self._config is not None:
+            OmegaConf.update(self._config, f"mail.{name}", value)
 
-    def set_database_attr(self, name, value):
-        OmegaConf.update(self._config, f"database.{name}", value)
+    def set_database_attr(self, name: str, value: Any):
+        if self._config is not None:
+            OmegaConf.update(self._config, f"database.{name}", value)
 
-    def set_zotero_attr(self, name, value):
-        OmegaConf.update(self._config, f"zotero.{name}", value)
+    def set_zotero_attr(self, name: str, value: Any):
+        if self._config is not None:
+            OmegaConf.update(self._config, f"zotero.{name}", value)
 
-    def set_icon_attr(self, name, value):
-        OmegaConf.update(self._config, f"icons.{name}", value)
+    def set_openai_attr(self, name: str, value: Any):
+        if self._config is not None:
+            OmegaConf.update(self._config, f"openAI.{name}", value)
+
+    def set_icon_attr(self, name: str, value: Any):
+        if self._config is not None:
+            OmegaConf.update(self._config, f"icons.{name}", value)
 
     @property
     def save_path(self):
+        if self._config is None:
+            raise RuntimeError("Configuration not loaded")
         return self._config.save_path
 
     @save_path.setter
     def save_path(self, value: str):
-        self._config.save_path = value
+        if self._config is not None:
+            self._config.save_path = value
 
     def load_config(self, path, filename):
         return OmegaConf.load(os.path.join(path, filename))
 
     @property
     def icons(self):
+        if self._config is None:
+            raise RuntimeError("Configuration not loaded")
         icons = Icons()
         icons.assign("path", self._config.icon_path)
         icons.assign("colors", self._config.colors)

dev/compile_modified.py

@@ -0,0 +1,24 @@
+import py_compile
+import sys
+paths = [
+ 'src/ui/widgets/new_edition_check.py',
+ 'src/utils/icon.py',
+ 'src/ui/widgets/graph.py',
+ 'src/ui/userInterface.py',
+ 'src/ui/dialogs/mailTemplate.py',
+ 'src/services/catalogue.py',
+ 'src/backend/catalogue.py',
+ 'src/parsers/xml_parser.py',
+ 'src/parsers/csv_parser.py',
+ 'src/parsers/transformers/transformers.py',
+ 'src/core/semester.py',
+]
+errs = 0
+for p in paths:
+    try:
+        py_compile.compile(p, doraise=True)
+        print('OK:', p)
+    except Exception as e:
+        print('ERROR:', p, e)
+        errs += 1
+sys.exit(errs)

dev/update_translations.ps1

@@ -0,0 +1,35 @@
+# Requires PowerShell 5+
+# Scans all .ui files under src/ and runs pyside6-lupdate to generate/update .ts files next to them.
+# Usage: Run from repository root: `pwsh dev/update_translations.ps1` or `powershell -ExecutionPolicy Bypass -File dev/update_translations.ps1`
+
+$ErrorActionPreference = 'Stop'
+
+# Use current working directory (CWD) for relative paths
+$cwd = Get-Location
+$lupdate = Join-Path $cwd '.venv\Scripts\pyside6-lupdate.exe'
+if (-not (Test-Path $lupdate)) {
+    Write-Error "Qt for Python lupdate not found at '$lupdate'. Ensure venv is created and PySide6 tools installed."
+}
+
+$uiFiles = Get-ChildItem -Path (Join-Path $cwd 'src') -Filter '*.ui' -Recurse -File
+if ($uiFiles.Count -eq 0) {
+    Write-Host 'No .ui files found under src/. Nothing to update.'
+    exit 0
+}
+
+foreach ($ui in $uiFiles) {
+    # Compute .ts path next to the .ui file
+    $tsPath = [System.IO.Path]::ChangeExtension($ui.FullName, '.ts')
+    # Ensure target directory exists
+    $tsDir = Split-Path -Parent $tsPath
+    if (-not (Test-Path $tsDir)) { New-Item -ItemType Directory -Path $tsDir | Out-Null }
+    
+    # Use absolute paths to avoid path resolution issues
+    $uiAbs = $ui.FullName
+    $tsAbs = $tsPath
+    
+    Write-Host "Updating translations: $uiAbs -> $tsAbs"
+    & $lupdate $uiAbs '-ts' $tsAbs
+}
+
+Write-Host 'Translation update completed.'

dev/update_translations.sh

@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+# Scans all .ui files under src/ and runs pyside6-lupdate to generate/update .ts files next to them.
+# Usage: Run from repository root: `bash dev/update_translations.sh`
+set -euo pipefail
+
+# Ensure we are in repo root (script's directory is dev/)
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(dirname "$SCRIPT_DIR")"
+cd "$REPO_ROOT"
+
+LUPDATE=".venv/bin/pyside6-lupdate"
+if [[ ! -x "$LUPDATE" ]]; then
+  echo "Qt for Python lupdate not found at '$LUPDATE'. Ensure venv is created and PySide6 tools installed." >&2
+  exit 1
+fi
+
+shopt -s nullglob
+mapfile -t UI_FILES < <(find src -type f -name '*.ui')
+
+if [[ ${#UI_FILES[@]} -eq 0 ]]; then
+  echo "No .ui files found under src/. Nothing to update."
+  exit 0
+fi
+
+for ui in "${UI_FILES[@]}"; do
+  ts="${ui%.ui}.ts"
+  echo "Updating translations: $ui -> $ts"
+  "$LUPDATE" "$ui" -ts "$ts"
+done
+
+echo "Translation update completed."

docs/admin.md

@@ -1,25 +0,0 @@
-# Adminbereich
-
-Der Adminbereich ist nur freigeschaltet, wenn der angemeldete Nutzer die Rolle admin hat. Hier können neue Nutzer angelegt, bestehende Nutzer bearbeitet oder gelöscht werden. Zusätzlich können die Daten der ProfessorInnen bearbeitet werden.
-
-Die Verschiedenen Aktionen können über das Dropdown-Menü ausgewählt werden.
-
-## Nutzer anlegen
-![Nutzer anlegen](images/admin_create_user.png)
-
-Hier kann ein neuer Nutzer angelegt werden. Dazu müssen der Nutzername, das Password und die Rolle angegeben werden. Die Rolle kann frei vergeben, oder aus dem Dropdown ausgewählt werden.
-
-Über den Knopf **Anlegen** wird der Nutzer angelegt.
-
-## Nutzer bearbeiten
-![Nutzer bearbeiten](images/admin_edit_user.png)
-
-Hier können die Verschiedenen Nutzer bearbeitet oder gelöscht werden. Hat der ausgewählte Nutzer die Rolle admin, so kann dieser nicht gelöscht werden.
-Um einen Nutzer zu löschen, muss sowohl ein Haken bei **Löschen** gesetzt werden, als auch der Knopf **Löschen** gedrückt werden.
-
-## Lehrperson bearbeiten
-
-![Lehrperson bearbeiten](images/admin_edit_prof.png)
-Hier können die Daten der Lehrperson bearbeitet werden, oder die Lehrperson gelöscht werden. Um eine Lehrperson zu löschen, darf kein Aktiver Apparat vorhanden sein, sowie keine ELSA Aufträge vorhanden sein. 
-
-Um eine Lehrperson zu bearbeiten, muss der Name im Dropdown bei "Alte Angaben" ausgewählt werden. Die Alten Daten werden nun in der Maske angezeigt. Die neuen Daten können nun im unteren Bereich eingegeben werden. Über den Knopf **Aktualisieren** werden die Daten gespeichert.

docs/admin/uebersicht.md

@@ -0,0 +1 @@
+# Übersicht

docs/allgemein/hauptoberflaeche.md

@@ -0,0 +1,118 @@
+# Hauptoberfläche
+
+![Hauptoberfläche](../images/mainUI.png){ loading=lazy }
+
+Die Hauptoberfläche des SemesterapparatsManager besteht aus drei Hauptbereichen, die über Tabs erreichbar sind:
+
+## Navigation
+
+<div class="grid cards" markdown>
+
+-   :lucide-book-plus:{ .lg .middle } **Anlegen**
+
+    ---
+
+    Neue Semesterapparate erstellen, bestehende aktualisieren oder löschen.
+
+    [:octicons-arrow-right-24: Zum Anlegen](../semesterapparat/anlegen.md)
+
+-   :lucide-search:{ .lg .middle } **Suchen/Statistik**
+
+    ---
+
+    Semesterapparate suchen, filtern und Statistiken einsehen.
+
+    [:octicons-arrow-right-24: Zur Suche](../semesterapparat/suche.md)
+
+-   :lucide-file-text:{ .lg .middle } **ELSA**
+
+    ---
+
+    Elektronische Semesterapparate anlegen und Zitate erstellen.
+
+    [:octicons-arrow-right-24: Zu ELSA](../elsa/anlegen.md)
+
+-   :octicons-person-24:{ .lg .middle } **Admin**
+
+    ---
+
+    Adminbereich (nur wenn der angemeldete Nutzer die `Admin` Rolle hat)
+
+    [:octicons-arrow-right-24: Zur Übersicht](../admin/uebersicht.md)
+ 
+
+
+</div>
+
+---
+
+## Übersichtstabelle
+
+![Übersichtstabelle](../images/main_overview.png){ loading=lazy }
+
+In diesem Bereich werden alle erstellten Semesterapparate angezeigt. 
+
+!!! tip "Tipp: Doppelklick"
+    Über einen **Doppelklick** auf einen Apparat werden alle Details geladen und in den Apparatdetails angezeigt.
+
+### Verfügbare Aktionen
+
+| Knopf | Funktion |
+|-------|----------|
+| :lucide-printer: **Übersicht erstellen** | Erstellt eine druckbare Übersicht der angezeigten Apparate für das Regal |
+| :lucide-plus: **neu. App anlegen** | Schaltet die Apparatdetails frei für einen neuen Apparat |
+| :lucide-x: **Auswahl abbrechen** | Entfernt alle Daten und deaktiviert die Apparatdetails |
+
+!!! note "Hinweis: Übersicht drucken"
+    Die Übersicht wird per Mail an den konfigurierten Drucker geschickt. Vor dem Drucken erfolgt eine Bestätigungsabfrage.
+
+---
+
+## Einstellungen
+
+Die Einstellungen erreichen Sie über das Menü oder das :lucide-settings: Icon.
+
+![Einstellungen](../images/settings.png){ loading=lazy }
+
+!!! info "Automatisches Wiederherstellen"
+    Die zuletzt geöffnete Seite wird automatisch beim nächsten Start geöffnet.
+
+### Datenbank
+
+Hier sind alle Informationen zur Datenbank sowie den temporären Daten hinterlegt.
+
+!!! warning "Mehrere Nutzer"
+    Sollte die Anwendung von mehreren Nutzern benutzt werden, sollte der Datenbankpfad nur in Absprache geändert werden. Ansonsten kann es zu Synchronisationsproblemen kommen.
+
+### Zotero
+
+![Zotero Einstellungen](../images/settings_zotero.png){ loading=lazy }
+
+Konfigurieren Sie hier die Zugangsdaten für Zotero, die für die [ELSA-Zitate](../elsa/zitieren.md) benötigt werden.
+
+### E-Mail
+
+![E-Mail Einstellungen](../images/settings_mail.png){ loading=lazy }
+
+=== "Allgemein"
+
+    Zugangsdaten für den SMTP-Mailversand. Diese werden für Benachrichtigungen an Dozenten benötigt.
+
+=== "Signatur"
+
+    Die Signatur wird automatisch an jede ausgehende Mail angehängt.
+
+### Icons
+
+![Icon Einstellungen](../images/settings_icons.png){ loading=lazy }
+
+Übersicht der aktuellen Icons und verfügbaren Farbschemata.
+
+---
+
+## Speichern der Einstellungen
+
+Über den Knopf **Ok** werden die Einstellungen gespeichert. 
+
+!!! success "Sofortige Übernahme"
+    Die meisten Einstellungen werden sofort übernommen. Sollte ein Neustart erforderlich sein, werden Sie darüber informiert.

docs/allgemein/index.md

@@ -0,0 +1,31 @@
+# Allgemein
+
+Willkommen in der Dokumentation des **SemesterapparatsManager**! In diesem Abschnitt finden Sie alle grundlegenden Informationen zum Programm.
+
+<div class="grid cards" markdown>
+
+-   :lucide-info:{ .lg .middle } **Info**
+
+    ---
+
+    Erfahren Sie mehr über den SemesterapparatsManager und seine Funktionen.
+
+    [:octicons-arrow-right-24: Mehr erfahren](info.md)
+
+-   :lucide-download:{ .lg .middle } **Installation**
+
+    ---
+
+    Installieren Sie den SemesterapparatsManager in wenigen Schritten.
+
+    [:octicons-arrow-right-24: Zur Installation](installation.md)
+
+-   :lucide-layout-dashboard:{ .lg .middle } **Hauptoberfläche**
+
+    ---
+
+    Lernen Sie die Benutzeroberfläche des Programms kennen.
+
+    [:octicons-arrow-right-24: Zur Übersicht](hauptoberflaeche.md)
+
+</div>

docs/allgemein/info.md

@@ -0,0 +1,57 @@
+# Info
+
+## Über den SemesterapparatsManager
+
+Der **SemesterapparatsManager** ist ein grafisches Werkzeug zur Verwaltung von Semesterapparaten an der Pädagogischen Hochschule Freiburg. 
+
+!!! abstract "Was ist ein Semesterapparat?"
+    Ein Semesterapparat ist eine Sammlung von Literatur, die von Dozenten für ihre Lehrveranstaltungen zusammengestellt wird. Die Bücher werden in der Bibliothek bereitgestellt und können von Studierenden eingesehen werden.
+
+## Funktionen
+
+Die Anwendung ermöglicht eine benutzerfreundliche Verwaltung von physischen und digitalen Semesterapparaten:
+
+<div class="grid cards" markdown>
+
+-   :lucide-book-plus:{ .lg .middle } **Anlegen**
+
+    ---
+
+    Erstellen Sie neue Semesterapparate mit allen notwendigen Informationen zu Dozenten, Fächern und Literatur.
+
+-   :lucide-search:{ .lg .middle } **Suchen & Statistik**
+
+    ---
+
+    Durchsuchen Sie bestehende Apparate und erhalten Sie statistische Auswertungen.
+
+-   :lucide-file-text:{ .lg .middle } **ELSA**
+
+    ---
+
+    Verwalten Sie elektronische Semesterapparate (ELSA) mit automatischer Zitat-Erstellung via Zotero.
+
+-   :lucide-mail:{ .lg .middle } **Kommunikation**
+
+    ---
+
+    Versenden Sie automatisierte E-Mails an Dozenten bei Erstellung oder Löschung von Apparaten.
+
+</div>
+
+## Technische Details
+
+| Eigenschaft | Wert |
+|-------------|------|
+| **Programmiersprache** | Python 3.10+ |
+| **GUI-Framework** | PySide6 (Qt) |
+| **Datenbank** | SQLite |
+| **Zitat-System** | Zotero Integration |
+| **Stil** | DGPs (Deutsche Gesellschaft für Psychologie) |
+
+## Entwicklung
+
+Der SemesterapparatsManager wurde entwickelt von **Alexander Kirchner** für die Pädagogische Hochschule Freiburg.
+
+!!! info "Open Source"
+    Der Quellcode ist auf einer privaten [Gitea](https://about.gitea.com/) Instanz und kann bei Bedarf eingesehen werden.

docs/allgemein/installation.md

@@ -0,0 +1,92 @@
+# Installation
+
+## Voraussetzungen
+
+Bevor Sie den SemesterapparatsManager installieren können, stellen Sie sicher, dass folgende Voraussetzungen erfüllt sind:
+
+- [x] Windows 10/11 oder höher
+- [x] Internetzugang für Katalog-Abfragen
+- [x] Optional: Zotero-Account für ELSA-Funktionen
+
+!!! warning "Buchmetadaten"
+    Die Metadaten für Bücher können aktuell nur aus dem Hochschulnetz geladen werden, da diese auf ein Internes Format zugreifen, welches nur im Hochschulnetz angezeigt wird.
+## Installation
+
+### Für Endanwender
+
+=== "Portable Version"
+
+    1. Laden Sie die neueste Version von der Release-Seite herunter
+    2. Entpacken Sie die ZIP-Datei in einen Ordner Ihrer Wahl
+    3. Starten Sie `SemesterapparatsManager.exe`
+
+=== "Installer"
+
+    1. Laden Sie den Installer herunter
+    2. Führen Sie die Setup-Datei aus
+    3. Folgen Sie den Anweisungen des Installationsassistenten
+    4. Starten Sie das Programm über das Startmenü
+
+### Für Entwickler
+
+!!! note "Entwicklerinstallation"
+    Diese Anleitung ist für Entwickler gedacht, die den Quellcode bearbeiten möchten.
+
+#### Mit UV (empfohlen)
+
+```bash
+# Repository klonen
+git clone https://github.com/IHR-REPO/SemesterapparatsManager.git
+cd SemesterapparatsManager
+
+# Virtuelle Umgebung erstellen und Abhängigkeiten installieren
+uv sync
+
+# Anwendung starten
+uv run python main.py
+```
+
+#### Mit pip
+
+```bash
+# Repository klonen
+git clone https://github.com/IHR-REPO/SemesterapparatsManager.git
+cd SemesterapparatsManager
+
+# Virtuelle Umgebung erstellen
+python -m venv .venv
+.venv\Scripts\activate
+
+# Abhängigkeiten installieren
+pip install -e ".[dev]"
+
+# Anwendung starten
+python main.py
+```
+
+## Erster Start
+
+Beim ersten Start werden Sie aufgefordert, sich anzumelden:
+
+![Login](../images/login.png){ loading=lazy }
+
+!!! tip "Tipp"
+    Ihre Anmeldedaten werden verschlüsselt gespeichert. Sollten Sie Ihr Passwort vergessen, wenden Sie sich bitten an einen Nutzer mir Adminberechtigungen, um das Passwort zu ändern. Bei Fragen zur Einrichtung wenden Sie sich an den Administrator.
+
+    Sofern Sie keine eigenen Zugangsdaten bei der Einrichtung eingegeben haben, sind dies die Standardanmeldedaten:
+
+     **Username**: admin
+     **Password**: admin
+
+## Konfiguration
+
+Nach der Installation sollten Sie die Einstellungen überprüfen:
+
+1. Öffnen Sie das Programm
+2. Gehen Sie zu **Einstellungen** (über das Menü oder :lucide-settings:)
+3. Konfigurieren Sie:
+    - **Datenbank-Pfad**: Speicherort der SQLite-Datenbank
+    - **Zotero**: API-Schlüssel für Zitat-Funktionen
+    - **E-Mail**: SMTP-Einstellungen für Benachrichtigungen
+
+Weitere Informationen zur Konfiguration finden Sie unter [Hauptoberfläche](hauptoberflaeche.md).

docs/citing.md

@@ -1,30 +0,0 @@
-# Zitieren
-## Oberfläche
-![Zitieroberfläche](images/generate_quote_emtpy.png)
-
-Die [ELSA](elsa.md) Oberfläche bietet die Möglichkeit, für Einträge automatisch Zitate zu erstellen. Hierfür wird der Stil `Deutsche Gesellschaft für Psychologie (DGPs)` verwendet. 
-
-Um ein Zitat zu erstellen, muss zuerst ein Eintrag in der Tabelle ausgewählt werden. Über den Knopf **Eintrag zitieren** wird ein Dialog geöffnet, in dem der Eintrag zitiert werden kann. 
-Sollte ein Eintrag mehrere Abschnitte beinhalten, muss nach der automatischen Suche die Seitenzahl angepasst werden. Ist die Seitenzahl in der Tabelle nur für einen Abschnitt, so wird diese automatisch übernommen.
-
-
-## Zitierdialog
-
-![Zitierdialog mit Ergebnis](images/quote_search_result.png)
-
-Nachdem auf den Knopf **Eintrag zitieren** geklickt wird, wird automatisch der Katalog angefragt und relevante Daten werden in die Felder eingetragen. Ist die Seitenzahl in der Tabelle nur für einen Abschnitt, so wird diese automatisch übernommen.
-
-!!! info "Erläuterung der Knöpfe"
-
-    - **Suchen** Sucht im Katalog nach dem eingegebenen Identifikator
-    - **Zitat erstellen** Stellt eine Verbindung zu Zotero her, erstellt ein entsprechendes Werk und erhält die Zitate als Ergebnis; wechselt zur Oberfläche der Zitate
-    - **Ok** Schließt den Dialog
-    - **Discard** Entfernt alle Eingaben
-    - **Abbrechen** Schließt den Dialog
-    - **Wiederholen** Geht zu den Eingabefeldern zurück, ermöglicht eine erneute Suche mit geänderten Eingaben
-
-## Zitate
-
-![Zitate](images/quote_generated.png)
-
-Über den Knopf **Zitat erstellen** wird eine Verbindung zu Zotero hergestellt und ein entsprechendes Werk erstellt. Die Zitate werden als Ergebnis angezeigt. Der Dialog wechselt automatisch zur Oberfläche der Zitate.

docs/config.md

@@ -1,42 +0,0 @@
-# Einstellungen
-![Einstellungen](images/settings.png)
-
-In den Einstellungen werden alle Informationen angezeigt, die in der config.yaml Datei hinterlegt sind. Diese Datei wird beim Start der Datei eingelesen und als globale Klasse `Config` gespeichert. Dadurch können Einstellungen sofort geändert werden und das Programm muss nicht für jede Änderung neu gestartet werden. 
-
-!!! Info
-    Die zuletzt geöffnete Seite wird automatisch beim nächsten Start geöffnet.
-
-## Seiten
-### Datenbank
-
-Hier sind alle Informationen zur Datenbank, sowie den Tempörären Daten hinterlegt.
-Der Speicherort der Datenbank kann über den Knopf `...`  neben dem Datenbanknamen geändert werden. Der Datenbankpfad passt sich automatisch an.
-
-!!! Warning "Hinweis - Mehrere Nutzer"
-    Sollte die Anwendung von mehreren Nutzern benutzt werden, sollte dieser Pfad nur in absprache geändert werden. Ansonsten kann es zu Problemen kommen.
-
-### Zotero
-![Zotero](images/settings_zotero.png)
-
-In diesem Bereich können die Zugangsdaten für Zotero hinterlegt werden. Diese werden benötigt, um die Zitate für die [ELSA](elsa.md#einträge-zitieren) Zitate zu erstellen.
-
-
-### e-Mail
-![e-Mail](images/settings_mail.png)
-Dieser Bereich ist zweigeteilt, einmal der Allgemeine Teil, und einmal der Teil für die Mailsignatur
-
-#### Allgemein
-Hier können die Zugangsdaten für den Mailversand hinterlegt werden. Diese werden benötigt, um die Nachrichten an die ProffessorInnen zu versenden. Mehr Infos: [Mailversand](mail.md)
-
-#### Signatur
-Hier kann die Signatur für die Mails hinterlegt werden. Diese wird automatisch an jede Mail angehängt.
-
-### Icons
-![Icons](images/settings_icons.png)
-Hier werden sowohl die aktuellen Icons, wie auch die verfügbaren Farben angezeigt.
-
-## Speichern
-
-Über den Knopf **Ok** werden die Einstellungen gespeichert. Sollte ein Neustart der Anwendung erforderlich sein, wird darüber informiert. Ansonsten werden die Einstellungen sofort übernommen.
-
-

docs/create.md

@@ -1,90 +0,0 @@
-# Semesterapparat anlegen
-
-Um einen neuen Semesterapparat anzulegen, muss zuerst der Knopf "neu. App anlegen" gedrückt werden. Das Feld der Apparatdetails wird nun zum bearbeiten entsperrt, und die Daten können in die Felder eingetragen werden.
-
-![Anlegen](images/main_apparatdetails.png)
-
-## Apparatdetails
-### Apparat anlegen
-Um einen Apparat erfolgreich anzulegen, müssen alle Felder, die ein Sternchen (*) haben, ausgefüllt werden. Ist eine Eingabe nicht valide, wird neben der Eingabe ein rotes X angezeigt (siehe Bild).
-Folgende Felder haben spezielle Formatierungsanforderungen:
-
-- Prof. Name: Der Name des Professors muss in der Form "Nachname, Vorname" eingegeben werden.
-- Mail: Die Mailadresse muss in der Form "irgend@etwas.xy" eingegeben werden.
-- Tel: Die Telefonnummer muss mindestens 3 Ziffern enthalten.
-- Semester: Das Semester wird wie folgt angegeben:
-  -  Wintersemester: Checkbox Winter + aktives Jahr wenn Monat zwischen Oktober und Dezember; ansonsten aktives Jahr - 1
-  -  Sommersemester: Checkbox Sommer + aktives Jahr wenn Monat zwischen März und August
-
-
-Beim Versuch, den Apparat zu speichern, bevor alle Felder korrekt ausgefüllt sind, wird eine Fehlermeldung angezeigt, die auf die fehlerhaften Felder hinweist. Nachdem alle Felder korrekt ausgefüllt sind, kann der Apparat gespeichert werden.
-
-![Fehler](images/main_apparatdetails_error.png)
-
-Über einen Klick auf Ok oder Cancel wird die Meldung geschlossen und der Apparat kann weiter bearbeitet werden.
-
-### Dokumente hinzufügen
-
-Dem Apparat können Dokumente hinzugefügt werden. Besonders hilfreich ist das hinzufügen der Antragsformulare, da der SemesterapparatsManager diese Datei lesen und die Bücher automatisch dem Apparat hinzufügen kann.
-
-Dokumente werden über den Knopf "Dokumente hinzufügen" hinzugefügt werden. Es öffnet sich ein Auswahldialog, bei dem Sie dei Datei(en) auswählen können, die Sie hinzufügen möchten.
-
-Handelt es sich bei der Datei um den Antrag, so kann dieser mit dem Knopf "Medien aus Dokument hinzufügen" ausgelesen werden. 
-
-!!! Warning "ZU BEACHTEN"
-
-    Wird dieser Knopf gedrückt, wird der Apparat, wenn möglich, gespeichert und angelegt. Dies ist notwendig, da die Medien nur dann dem Apparat hinzugefügt werden können, wenn dieser bereits in der Datenbank existiert.
-
-Die erkannten Medien werden nun hinzugefügt. Über den Bereich "Medienliste" kann der Fortschritt eingesehen werden. Solange noch Medien hinzugefügt werden, ist es nicht möglich, den Apparat zu bearbeiten, die Auswahl zu beenden oder einen anderen Apparat auszuwählen.
-
-### Apparat speichern
-
-Nachdem alle Felder korrekt ausgefüllt sind, kann der Apparat gespeichert werden. Dazu muss der Knopf "Speichern" gedrückt werden. Der Apparat wird nun in der Datenbank gespeichert und wird in der Tabelle angezeigt. Wurde vor dem Speichern der Haken "Mail senden" gesetzt, öffnet sich ein Fenster, in dem einen Mail, basierend auf einem Template, an den Professor gesendet werden kann. (Erfordert Mail Zugangsdaten [siehe Konfiguration](config.md#email))
-
-## Medienliste
-
-In der Medienliste werden alle Medien angezeigt, die dem Apparat hinzugefügt wurden. Hier können die Medien bearbeitet, gelöscht oder hinzugefügt werden.
-
-Wurde ein Apparat ausgewählt, werden einige Felder unterhalb der Medienliste angezeigt:
-![Optionen der Medienliste](images/medialist_options.png)
-
-
-Standardmäßig werden nur Medien angezeigt, die nicht aus dem Apparat entfernt wurden. Über den Checkbox "gel. Medien anzeigen" werden auch gelöschte Medien angezeigt. 
-Der Knopf "im Apparat?" kann für ein einzelnes, oder mehrere Medien verwendet werden, um zu prüfen, ob die ausgewählten Medien inzwischen dem Apparat hinzugefügt wurden.
-
-Unter der Liste befindet sich ein Knopf "Medien hinzufügen", der es ermöglicht, Medien manuell hinzuzufügen. Hierbei wird ein Dialog geöffnet, in dem die Signaturen der Medien eingetragen werden können. Die Medien werden dann dem Apparat hinzugefügt.
-
-### Kontextmenü 
-
-Mit einem Rechtsklick auf ein Medium wird ein Kontextmenü geöffnet, das folgende Optionen enthält (Mehrfachauswahl der Medien mit Strg + Linksklick möglich):
-
-![Kontextmenü](images/media_context_menu_root.png)
-
-#### Subbereich Allgemeines
-
-![Kontextmenü](images/media_context_menu_general.png)
-- Bearbeiten: Öffnet ein Fenster, in dem die Metadaten des Mediums eingesehen bzw, bearbeitet werden können. (s. [Metadaten bearbeiten](edit_media.md))
-- Löschen: Löscht das Medium aus dem Apparat. Das Medium wird nicht gelöscht, sondern nur aus dem Apparat entfernt. (s. [Bild](images.md#Exemplar löschen))
-
-#### Subbereich Apparate
-
-![Kontextmenü](images/media_context_menu_apparats.png)
-
-
-- Zum Apparat hinzufügen: *Noch nicht implementiert* (derzeit deaktiviert) Fügt das Medium dem Apparat in aDIS hinzu
-- In Apparat verschieben: Öffnet ein Fenster, in dem ein anderer Apparat ausgewählt werden kann, in den die ausgewählten Medien verschoben werden sollen.
-- In Apparat kopieren: Öffnet ein Fenster, in dem ein anderer Apparat ausgewählt werden kann, in den die ausgewählten Medien kopiert werden sollen.
-
-
-## Medien hinzufügen
-
-![Medien hinzufügen](images/add_media.png)
-
-Um Medien hinzuzufügen, müssen die Signaturen der Medien in das Textfeld eingetragen werden. Jede Signatur muss in die Zeile eingegeben werden und mit Enter bestätigt werden.
-Nachdem alle Signaturen hinzugefügt werden, können folgende Optionen gesetzt werden:
-
-- Modus: Gibt an, welche Metadaten verwendet werden. Die beiliegende Tabelle gibt an, welche Metadaten welche Angaben enthalten.
-- Jedes Buch verwenden: Diese Option ermöglicht es, Medien hinzuzufügen, die noch nicht im Apparat sind
-- Exakte Signatur: Diese Option teilt dem System mit, dass genau diese Signatur verwendet werden muss. Ist diese Option nicht gesetzt, wird nach der Signatur gesucht, die am ehesten der eingegebenen Signatur entspricht. (Das gefundene Buch ist das gleiche, nur evtl. ein anderes Exemplar)
-
-Mit dem Knopf "Ok" werden die Medien gesucht und hinzugefügt. 

docs/edit_media.md

@@ -1,7 +0,0 @@
-# Metadaten bearbeiten
-
-![Metadaten bearbeiten](images/edit_book_metadata.png)
-
-In diesem Fenster können die Metadaten eines Mediums bearbeitet werden. Diese bearbeitung macht Sinn, wenn Angaben nicht direkt aus dem Katalog übernommen werden konnten, oder wenn die Angaben nicht korrekt sind.
-
-Über den Knopf "Ok" werden die geänderten Metadaten gespeichert und das Fenster geschlossen. Über den Knopf "Abbrechen" werden die Änderungen verworfen und das Fenster geschlossen.

docs/elsa.md

@@ -1,38 +0,0 @@
-# ELSA 
-
-![ELSA](images/elsa_main.png)
-
-## ELSA anlegen
-Um einen ELSA zu erstellen, muss der Knopf **Neuer Auftrag** gedrückt werden. Das Feld *Auftragsdaten* wird zum bearbeiten freigeschaltet, der Fokus wird automatisch auf das Feld **Prof.** gesetzt.
-
-Hier werden automatisch alle bereits vorhandenen Professoren der Semesterapparate eingetragen. Sollte der Professor noch keinen Apparat haben, so kann der Name manuell eingetragen werden. Es wird nun ein neues Element angezeigt:
-
-![Kontaktdaten](images/new_prof_elsa_fields.png)
-
-Solange diese Felder nicht ausgefüllt sind, kann der Auftrag nicht gespeichert werden.
-
-
-
-Um den ELSA zu speichern, müssen alle Felder ausgefüllt sein. Nach dem Speichern wird der ELSA in der Tabelle angezeigt. Über das Icon ![Icon](images/icon_cal.png) können der aktuelle Tag und das aktuelle Semester eingetragen werden.
-
-### Dokumente hinzufügen
-![Dokumenttabelle](images/elsa_docs.png)
-
-Hat der Professor ein passendes Formular geliefert, so kann dieses über den Knopf **Dokument hinzufügen** hinzugefügt werden. Das Dokument wird in der Datenbank gespeichert und kann über den Knopf **Dokument öffnen** geöffnet werden. Über den Knopf **Medien aus Dokument hinzufügen** werden alle erkannten Medien aus dem Dokument in die Tabelle eingetragen und können zitiert werden.
-
-Sollte der Professor mehrere Segmente aus einem Medium in einer Zeile gelistet haben, so können diese als seperate Einträge hinzugefügt werden. Dazu muss ein Haken bei **Abschnitte trennen** gesetzt sein. 
-
-!!! Warn "Hinweis: Datenformat im Dokument"
-    Um die Abschnitte erfolgreich zu trennen, müssen diese durch ein Semikolon getrennt sein. 
-    
-    Beispiel: `1-5; 18-25; 30-35`
-
-
-
-Durch den Klick auf den Knopf **Medien aus Dokument hinzufügen** wird der Auftrag automatisch gespeichert, die Medien, bzw Abschnitte werden in der Tabelle angezeigt.
-
-### Einträge zitieren
-
-Da alle gescannten Dokumente später auf Illias hochgeladen werden, gibt es die Funktion **Eintrag zitieren**. Für diese Funktion muss ein Eintrag in der Tabelle ausgewählt werden. Über den Knopf **Eintrag zitieren** wird ein Dialog geöffnet, in dem der Eintrag zitiert werden kann. Die Angegebene Seitenzahl wird automatisch übernommen.
-Genauere Beschreibung: [Zitieren](citing.md)
-

docs/elsa/anlegen.md

@@ -0,0 +1,86 @@
+# ELSA anlegen
+
+![ELSA Hauptoberfläche](../images/elsa_main.png){ loading=lazy }
+
+---
+
+## Neuen ELSA erstellen
+
+### Schritte
+
+1. Klicken Sie auf **Neuer Auftrag**
+2. Das Feld *Auftragsdaten* wird freigeschaltet
+3. Der Fokus wechselt automatisch auf das Feld **Prof.**
+
+### Professorenauswahl
+
+Im Feld **Prof.** werden automatisch alle bereits vorhandenen Dozenten aus den Semesterapparaten angezeigt.
+
+!!! info "Neuer Professor"
+    Wenn der Professor noch keinen Apparat hat, kann der Name manuell eingetragen werden. Es erscheinen zusätzliche Felder:
+
+![Kontaktdaten für neuen Professor](../images/new_prof_elsa_fields.png){ loading=lazy }
+
+| Feld | Beschreibung | Pflicht |
+|------|--------------|---------|
+| **Name** | Name des Dozenten | :material-check: |
+| **E-Mail** | Kontakt-E-Mail | :material-check: |
+| **Telefon** | Telefonnummer | :material-check: |
+
+!!! warning "Pflichtfelder"
+    Solange diese Felder nicht ausgefüllt sind, kann der Auftrag **nicht** gespeichert werden.
+
+---
+
+## Schnelleingabe
+
+Über das Kalender-Icon :octicons-calendar-24: können automatisch eingetragen werden:
+
+- [x] Aktuelles Datum
+- [x] Aktuelles Semester
+
+---
+
+## Dokumente hinzufügen
+
+![Dokumenttabelle](../images/elsa_docs.png){ loading=lazy }
+
+### Formular hinzufügen
+
+1. Klicken Sie auf **Dokument hinzufügen**
+2. Wählen Sie die Datei aus
+3. Das Dokument wird in der Datenbank gespeichert
+
+### Medien extrahieren
+
+Über **Medien aus Dokument hinzufügen** werden alle erkannten Medien automatisch in die Tabelle eingetragen.
+
+!!! tip "Abschnitte trennen"
+    Hat der Professor mehrere Abschnitte in einer Zeile gelistet, aktivieren Sie **Abschnitte trennen** – diese werden dann als separate Einträge hinzugefügt.
+
+!!! warning "Formatierung im Dokument"
+    Die Abschnitte müssen durch **Semikolon** getrennt sein:
+    
+    ```
+    1-5; 18-25; 30-35
+    ```
+
+### Automatisches Speichern
+
+Beim Klicken auf **Medien aus Dokument hinzufügen** wird der Auftrag automatisch gespeichert.
+
+---
+
+## Einträge bearbeiten
+
+Die erkannten Medien erscheinen in der Tabelle und können:
+
+- :lucide-edit: Bearbeitet werden
+- :lucide-quote: Zitiert werden → [Zum Zitieren](zitieren.md)
+- :lucide-trash: Gelöscht werden
+
+---
+
+## Dokument öffnen
+
+Über **Dokument öffnen** kann das hinzugefügte Formular jederzeit eingesehen werden. Es wird hierfür eine temporäre Datei erstellt und im entsprechenden Program (Bspw: Word, Excel, Email) geöffnet.

docs/elsa/index.md

@@ -0,0 +1,46 @@
+# ELSA
+
+**ELSA** steht für **E**lektronischer **L**ehr-**S**emester**a**pparat und ermöglicht die Verwaltung digitaler Literatur für Lehrveranstaltungen.
+
+<div class="grid cards" markdown>
+
+-   :lucide-file-plus:{ .lg .middle } **ELSA anlegen**
+
+    ---
+
+    Erstellen Sie einen neuen elektronischen Semesterapparat.
+
+    [:octicons-arrow-right-24: ELSA anlegen](anlegen.md)
+
+-   :lucide-quote:{ .lg .middle } **Zitieren**
+
+    ---
+
+    Erstellen Sie automatische Zitate für Ihre digitalen Medien.
+
+    [:octicons-arrow-right-24: Zum Zitieren](zitieren.md)
+
+</div>
+
+---
+
+## Was ist ELSA?
+
+!!! abstract "Definition"
+    Ein elektronischer Semesterapparat (ELSA) ist eine digitale Sammlung von Literatur, die auf Illias bereitgestellt wird. Die Dokumente werden gescannt und mit korrekten Zitationen versehen.
+
+### Workflow
+
+```mermaid
+graph TD
+    A[ELSA anlegen] --> B[Dokumente hinzufügen]
+    B --> C[Medien aus Dokument extrahieren]
+    C --> D[Einträge zitieren]
+    D --> E[Dateien auf Illias hochladen]
+```
+
+### Voraussetzungen
+
+- [x] Konfigurierter Zotero-Account
+- [x] Eingescannte Dokumente oder Formulare
+- [x] Informationen zum Dozenten und zur Veranstaltung

docs/elsa/zitieren.md

@@ -0,0 +1,95 @@
+# Zitieren
+
+Da alle gescannten Dokumente später auf **Illias** hochgeladen werden, bietet der SemesterapparatsManager eine automatische Zitierfunktion.
+
+---
+
+## Zitierstil
+
+!!! abstract "Verwendeter Stil"
+    Es wird der Zitierstil der **Deutschen Gesellschaft für Psychologie (DGPs)** verwendet.
+
+---
+
+## Oberfläche
+
+![Zitieroberfläche](../images/generate_quote_emtpy.png){ loading=lazy }
+
+### Zitat erstellen
+
+1. Wählen Sie einen Eintrag in der ELSA-Tabelle aus
+2. Klicken Sie auf **Eintrag zitieren**
+3. Der Dialog öffnet sich und sucht automatisch im Katalog
+
+!!! tip "Seitenzahlen"
+    Die angegebene Seitenzahl aus der Tabelle wird automatisch übernommen. Bei mehreren Abschnitten muss die Seitenzahl ggf. angepasst werden.
+
+---
+
+## Zitierdialog
+
+![Zitierdialog mit Ergebnis](../images/quote_search_result.png){ loading=lazy }
+
+Nach dem Öffnen werden automatisch relevante Daten aus dem Katalog abgefragt und in die Felder eingetragen.
+
+### Aktionen
+
+| Knopf | Funktion |
+|-------|----------|
+| :lucide-search: **Suchen** | Sucht im Katalog nach dem Identifikator |
+| :lucide-quote: **Zitat erstellen** | Verbindet mit Zotero und erstellt das Zitat |
+| :lucide-check: **Ok** | Schließt den Dialog |
+| :lucide-trash: **Discard** | Entfernt alle Eingaben |
+| :lucide-x: **Abbrechen** | Schließt den Dialog |
+| :lucide-rotate-ccw: **Wiederholen** | Zurück zur Eingabe für erneute Suche |
+
+---
+
+## Zitat-Erstellung
+
+```mermaid
+sequenceDiagram
+    participant U as Benutzer
+    participant S as SemesterapparatsManager
+    participant Z as Zotero
+
+    U->>S: Klick "Zitat erstellen"
+    S->>Z: Werk anlegen
+    Z-->>S: Werk-ID
+    S->>Z: Zitat abrufen
+    Z-->>S: Formatiertes Zitat
+    S->>U: Zitat anzeigen
+```
+
+### Ablauf
+
+1. Klicken Sie auf **Zitat erstellen**
+2. Eine Verbindung zu Zotero wird hergestellt
+3. Das Werk wird in Ihrer Zotero-Bibliothek angelegt
+4. Das formatierte Zitat wird zurückgegeben
+
+---
+
+## Generierte Zitate
+
+![Generierte Zitate](../images/quote_generated.png){ loading=lazy }
+
+Nach erfolgreicher Erstellung wechselt der Dialog automatisch zur Zitat-Ansicht.
+
+### Verwendung
+
+Die generierten Zitate können:
+
+- :lucide-copy: In die Zwischenablage kopiert werden
+- :lucide-file-text: Als Dateiname für das gescannte Dokument verwendet werden
+- :lucide-upload: Zusammen mit dem Dokument auf Illias hochgeladen werden
+
+---
+
+## Voraussetzungen
+
+!!! warning "Zotero-Konfiguration erforderlich"
+    Für die Zitierfunktion muss Zotero konfiguriert sein:
+    
+    1. Erstellen Sie einen API-Key in Ihrem Zotero-Account
+    2. Tragen Sie den Key in den [Einstellungen](../allgemein/hauptoberflaeche.md#zotero) ein

docs/extend.md

@@ -1,12 +0,0 @@
-# Verlängerung
-
-Ein Dialog zum Verlängern eines Apparates.
-
-![Verlängerung](images/extend.png)
-
-Zum Verlängern muss ein Semester ausgewählt, und ein Jahr eingetragen sein. Die Checkbox für den Dauerapparat kann angekreuzt werden, um den Apparat als Dauerapparat zu markieren.
-
-!!! Info "Info Dauerapparat"
-    Damit der Apparat als Dauerapparat verlängert werden kann, muss ein Semester angegeben werden.
-
-Nach dem Speichern wird das Semester automatisch angepasst und in den entsprechenden Tabellen angezeigt.

docs/images.md

@@ -1,14 +0,0 @@
-# Bilder
-
-## Admin Aktionen
-![Bild](images/actions.png)
-
-## Apparatscheckliste
-![Bild](images/checklist.png)
-
-## Medien hinzufügen
-![Bild](images/add_media.png)
-
-## Kalendar
-![Bild](images/calendar.png)
-

docs/index.md

@@ -1,3 +0,0 @@
-# ToC
-
->TBD

docs/mail.md

@@ -1,47 +0,0 @@
-# Mails
-
-Der SemesterapparatsManager hat die Option, den Dozenten beim erstellen eines Apparates eine Mail zu schicken. Diese Mail enthält die Information, dass der Apparat erstellt wurde und wie er aufgerufen werden kann. 
-
-Zusätzlich kann beim Löschen eines Apparates eine Mail an den Dozenten geschickt werden. Diese Mail enthält die Information, dass der Apparat gelöscht wurde. 
-
-Über eine neue Oberfläche können neue Mail Templates erstellt werden.
-
-
-## Mail
-
-Abhängig davon, ob ein Apparat erstellt oder gelöscht wird/wurde, wird automatisch ein Template geladen. Somit muss nur noch die Anrede und der Text angepasst werden.
-
-Bsp:
-
-![Mail](images/mail_delete.png)
-
-!!! Info
-    Die Felder **eMail** und **Prof** sind schreibgeschützt und können nicht verändert werden.
-
-Über das Dropdown Menü **Art** kann das entsprechende Template ausgewählt werden. Der Knopf recht danaben kann für das [erstellen](#neue-mail-templates) neuer Templates genutzt werden.
-
-Um die Mail abschicken zu können, muss die Anrede mithilfe der Knöpfe über dem Mailtext konfiguriert werden. Die Anrede passt sich automatisch an, basierend auf der angegebenen Anrede.
-
-Wird die Mail erfolgreich verschickt, schließt sich das Fenster automatisch, und es wird eine Kopie der Mail an die Mail semesterapparate@ph-freiburg.de geschickt.
-
-## Neue Mail Templates
-
-Über den Knopf rechts neben der Auswahl der Email Templates können neue Templates erstellt werden.
-
-![MailTemplate](images/mail_create_template.png)
-
-Diese Oberfläche bietet die Möglichkeit, ein neues Template zu erstellen. Mithilfe des Dropdowns **Platzhalter** können Platzhalter ausgewählt und eingefügt werden. Bevor das Template gespeichert werden kann, muss dieses getestet werden. Sollte der Test erfolgreich sein, kann ein Name vergeben werden, das Template wird nun in dem Dropdown angezeigt.
-
-### Template testen
-Sollten Angaben fehlen, wird eine Fehlermeldung angezeigt:
-
-![TemplateTest](images/mail_create_missing.png)
-
-!!! info
-    Die Fehlermeldung ist dynamisch und gibt immer die fehlenden Angaben an.
-
-
-### Template speichern
-Ist das Template fehlerfrei, wird folgender Dialog angezeigt:
-
-![TemplateSave](images/mail_set_template_name.png)

docs/mainUI.md

@@ -1,27 +0,0 @@
-# Hauptoberfläche
-
-![Hauptoberfläche](images/mainUI.png)
-
-Die Hauptoberfläche des SemesterapparatsManager besteht aus drei Hauptbereichen:
-
-- **Anlegen**: Auf dieser Seite können neue Semesterapparate angelegt werden, bestehende Apparate aktualisiert oder gelöscht werden. Weitere Informationen siehe: [Anlegen](create.md)
-  
-- **Suchen/Statistik**: Hier können Semesterapparate gesucht, gefiltert, gelöscht und verlängert werden. Zudem werden Statistiken zum erstellen / löschen von Semesterapparaten angezeigt. Ein zweiter Tab ermöglicht die Suche der Medien in den Semesterapparaten. Weitere Informationen siehe: [Suchen / Statistik](search.md)
-  
-- **ELSA**: Hier können ELSA Apparate angelegt werden, und entsprechende Dateinamen, Beschreibungen und Zitate erstellt werden. Weitere Informationen siehe: [ELSA](elsa.md)
-
-## Übersichtstabelle
-
-![Übersichtstabelle](images/main_overview.png)
-
-In diesem Bereich werden alle erstellten Semesterapparate angezeigt. Über einen Doppelklick auf einen Apparat werden alle Details geladen und in den Apparatdetails angezeigt. Hier können dann auch einige Angaben geändert werden. 
-Weitere Infos siehe: [Anlegen](create.md)   
-
-### Knöpfe
-Dieser Bereich hat folgende Knöpfe:
-
-- **Übersicht erstellen**: Erstellt eine Übersicht der angezeigten Apparate, welche am Regal ausgehängt werden kann. Diese Übersicht wird per Mail an den Drucker geschickt. Vor dem Drucken erfolgt einen Bestätigungsabfrage.
-- **neu. App anlegen**: Schaltet die Apparatdetails frei, um einen neuen Apparat anzulegen. Weiteres siehe: [Anlegen](create.md)
-- **Auswahl abbrechen**: Entfernt alle Daten aus den Apparatsdetails und schaltet diese wieder auf inaktiv.
-
-

docs/search.md

@@ -1,106 +0,0 @@
-# Suche und Statistik
-
-![Suche und Statistik](images/main_search_stat.png)
-
-Auf dieser Seite gibt es zwei Hauptfunktionen: die Suche und die Statistik. Standardmäßig wird die Statistik geöffnet.
-
-
-## Statistikbereich
-
-### Suche
-![Statistiksuche](images/ss_stat_search.png)
-
-In diesem Bereich kann die Suche nach Semesterapparaten durchgeführt werden. Suchoptionen sind:
-
-- **Appnr**: Die Nummer des Semesterapparates, die Auswahl zeigt alle belegten Semesterapparat an
-- **Person**: Der Name des Dozenten, der den Semesterapparat erstellt hat
-- **Fach**: Das Fach des Semesterapparates
-- **Erstell-** und **Endsemester**: Semester, in denen der Semesterapparat erstellt wurde, bzw enden soll
-- **Dauerapp**: Alle Apparate, die als Dauerapparat vermerkt sind
-- **Löschbar**: Überschreibt alle vorhergehenden Parameter und zeigt alle Semesterapparate an, die gelöscht werden können
-
-!!! Info 
-    Um alle Semesterapparate anzuzeigen, kann die Suche ohne Eingabe gestartet werden.
-
-Die Suche kann durch Klicken auf den Button **Suchen** gestartet werden. Die Ergebnisse werden in der Tabelle darunter angezeigt.
-
-### Suchergebnisse
-!!! Info
-    Der Ergebnisbereich kann über den Vertikalen Slider verschoben werden, um mehr Platz für Tabelle, oder den Graphen zu schaffen. Hierzu mit der Maus auf den Raum zwischen den beiden Bereichen klicken und ziehen.
-![Statistiksuchergebnisse](images/ss_stat_result.png)
-
-In diesem Bereich werden die Suchergebnisse angezeigt. Für jeden gefundenen Treffer wird eine Zeile angelegt:
-
-![Statistiksuchergebnisse](images/ss_search_entries.png)
-
-Angezeigt werden:
-
-- **Checkbox**
-- **Apparatsname**
-- **Apparatsnummer**
-- **Person**
-- **Fach**
-
-!!! failure "Info: Gelöschte Apparate"
-    Gelöschte Apparate werden in der Tabelle mit rotem Hintergrund angezeigt. (s. Ausgewählte Löschen)
-Über der Tabelle sind zwei Knöpfe: **Ausgewählte Löschen** und **Ausgewählte Benachrichtigen**
-
-Um diese Aktionen auszuführen, muss mindestens eine Checkbox bei einem Apparat angekreuzt sein.
-
-#### Ausgewählte Löschen
-![Statistiksuchergebnisse](images/ss_stat_delete.png)
-
-Nach dem Klicken auf den Button **Ausgewählte Löschen** wird jeder ausgewählte Apparat gelöscht. Die gelöschten Apparate werden in der Tabelle mit rotem Hintergrund angezeigt.
-
-#### Ausgewählte Benachrichtigen
-
-Mit dem Klick auf den Button wird ein neues Fenster geöffnet:
-
-![Statistiksuchergebnisse](images/mail_delete.png)
-
-Bevor die Mail abgeschickt werden kann, muss die Anrede konfiguriert werden. Weitere Infors finden Sie im Abschnitt [Mails](mail.md).
-
-#### Kontextmenü
-
-Diese Tabelle bietet auch ein Rechtsklickmenu mit folgenden Optionen:
-
-- **Verlängern**: Öffnet den [Verlängerungsdialog](extend.md)
-- **Wiederherstellen**: Stellt einen gelöschten Apparat wieder her
-
-!!! Info "Info: Wiederherstellen"
-    Diese Option kann für einen oder mehrere gelöschte Apparate verwendet werden. Für mehrere Apprate müssen die entsprechenden Zeilen mit Strg+Klick auf die Zeilennummer markiert werden.
-
-
-### Apparatsstatistik
-Rechts neben der Tabelle wird die Statistik der gefundenen Apparate angezeigt:
-![Statistiksuchergebnisse](images/ss_stats_table.png)
-Hierbei werden die Angaben sowohl in einer Tabelle als auch in einem Diagramm dargestellt.
-#### Tabelle
-In der Tabelle werden alle Verwendeten Semester agegeben, in denen ein Apparat entweder erstellt oder gelöscht wurde.
-
-Über einen Doppelklick auf ein Semester werden die Apparate angezeigt, die in diesem Semester erstellt oder gelöscht wurden.
-
-![DetailedView](images/ss_stats_detailed.png)
-
-Ein Klick auf das `>` Symbol einer Person zeigt alle erstellten oder gelöschten Apparate der Person an. Ein Doppelklick auf den erstellten Apparat wechselt die Ansicht zur [Hauptoberfläche](mainUI.md) und zeigt alle Daten an.
-
-!!! Info "Info: Gelöschte Apparate"
-    Gelöschte Apparate können nicht angezeigt werden, die Doppelklick Funktion ist hier deaktiviert.
-
-#### Diagramm
-Das Diagramm zeigt die Anzahl der erstellten und gelöschten Apparate in einem Liniendiagramm an.
-
-![Diagramm](images/ss_stats_graph.png)
-
-## Suchbereich
-
-Der Suchbereich kann verwendet werden, um zu prüfen, ob ein Exemplar in einem Apparat vorhanden ist. Mögliche Suchkriterien sind:
-
-- **Titel**: Der Titel des Exemplars (Trunkierung wurd automaticsh durchgeführt)
-- **Signatur**: Die Signatur des Exemplars (Trunkierung wurd automaticsh durchgeführt)
-
-Über den Knopf **Suchen** wird die Suche gestartet. Die Ergebnisse werden in der Tabelle darunter angezeigt.
-
-!!! Info "Info: Exemplarsuche"
-    Im Vergleich zur Apparatssuche kann hier keine Leere Suche durchgeführt werden, da ggf. zu viele Ergebnisse angezeigt werden können.
-

docs/semesterapparat/anlegen.md

@@ -0,0 +1,144 @@
+# Semesterapparat anlegen
+
+Um einen neuen Semesterapparat anzulegen, muss zuerst der Knopf **neu. App anlegen** gedrückt werden. Das Feld der Apparatdetails wird nun zum Bearbeiten entsperrt.
+
+![Anlegen](../images/main_apparatdetails.png){ loading=lazy }
+
+---
+
+## Apparatdetails
+
+### Pflichtfelder
+
+Um einen Apparat erfolgreich anzulegen, müssen alle Felder mit einem **Sternchen (*)** ausgefüllt werden. Ist eine Eingabe nicht valide, wird neben der Eingabe ein :material-close-circle:{ style="color: red" } angezeigt.
+
+!!! warning "Formatierungsanforderungen"
+    Folgende Felder haben spezielle Formatierungsanforderungen:
+
+| Feld | Format | Beispiel |
+|------|--------|----------|
+| **Prof. Name** | Nachname, Vorname | `Müller, Hans` |
+| **Mail** | Gültige E-Mail-Adresse | `mueller@ph-freiburg.de` |
+| **Tel** | Mindestens 3 Ziffern | `0761-12345` |
+| **Semester** | Automatisch berechnet | siehe unten |
+
+### Semester-Logik
+
+Das Semester wird automatisch wie folgt berechnet:
+
+=== "Wintersemester"
+
+    - Checkbox **Winter** aktivieren
+    - **Jahr**: 
+        - Oktober–Dezember → aktuelles Jahr
+        - Januar–September → aktuelles Jahr - 1
+
+=== "Sommersemester"
+
+    - Checkbox **Sommer** aktivieren
+    - **Jahr**: aktuelles Jahr (März–August)
+
+### Fehlermeldungen
+
+Beim Versuch, den Apparat zu speichern, bevor alle Felder korrekt ausgefüllt sind, erscheint eine Fehlermeldung:
+
+![Fehler](../images/main_apparatdetails_error.png){ loading=lazy }
+
+!!! tip "Tipp"
+    Über **Ok** oder **Cancel** wird die Meldung geschlossen und der Apparat kann weiter bearbeitet werden.
+
+---
+
+## Dokumente hinzufügen
+
+Dem Apparat können Dokumente hinzugefügt werden. Besonders hilfreich ist das Hinzufügen der **Antragsformulare**, da der SemesterapparatsManager diese automatisch auslesen kann.
+
+```mermaid
+graph LR
+    A[Dokument hinzufügen] --> B{Nächste Aktion}
+    B -->|"Daten [...] übernehmen"| C[Medien aus Dokument hinzufügen]
+    B -->|Nein| D[Als Referenz speichern]
+    C --> E[Medien werden automatisch erkannt]
+
+```
+
+1. Klicken Sie auf **Dokumente hinzufügen**
+2. Wählen Sie die gewünschte(n) Datei(en) aus
+3. Bei Antragsformularen: Klicken Sie auf **Medien aus Dokument hinzufügen**
+
+!!! warning "Wichtig: Automatisches Speichern"
+    Beim Klicken auf **Medien aus Dokument hinzufügen** wird der Apparat automatisch gespeichert. Dies ist erforderlich, da Medien nur einem existierenden Apparat hinzugefügt werden können.
+
+---
+
+## Medienliste
+
+![Optionen der Medienliste](../images/medialist_options.png){ loading=lazy }
+
+In der Medienliste werden alle dem Apparat zugeordneten Medien angezeigt.
+
+### Optionen
+
+| Option | Beschreibung |
+|--------|--------------|
+| :lucide-eye: **gel. Medien anzeigen** | Zeigt auch gelöschte Medien an |
+| :lucide-check-circle: **im Apparat?** | Prüft, ob ausgewählte Medien dem Apparat hinzugefügt wurden |
+| :lucide-plus: **Medien hinzufügen** | Manuelle Eingabe von Signaturen |
+
+### Kontextmenü
+
+Mit einem **Rechtsklick** auf ein Medium öffnet sich das Kontextmenü:
+
+![Kontextmenü](../images/media_context_menu_root.png){ loading=lazy }
+
+=== "Allgemeines"
+
+    ![Kontextmenü Allgemeines](../images/media_context_menu_general.png){ loading=lazy }
+
+    - **Bearbeiten**: Metadaten einsehen/bearbeiten
+    - **Löschen**: Medium aus dem Apparat entfernen (nicht physisch löschen)
+
+=== "Apparate"
+
+    ![Kontextmenü Apparate](../images/media_context_menu_apparats.png){ loading=lazy }
+
+    - **Zum Apparat hinzufügen**: *(derzeit deaktiviert)*
+    - **In Apparat verschieben**: Medium in anderen Apparat verschieben
+    - **In Apparat kopieren**: Medium in anderen Apparat kopieren
+
+!!! tip "Mehrfachauswahl"
+    Mit ++ctrl+left-button++ können mehrere Medien ausgewählt werden.
+
+---
+
+## Medien manuell hinzufügen
+
+![Medien hinzufügen](../images/add_media.png){ loading=lazy }
+
+### Eingabe
+
+Geben Sie jede Signatur in eine neue Zeile ein und bestätigen Sie mit ++enter++.
+
+### Optionen
+
+| Option | Beschreibung |
+|--------|--------------|
+| **Modus** | Wählt die Metadatenquelle |
+| **Jedes Buch verwenden** | Erlaubt das Hinzufügen von Medien, die noch nicht im Apparat sind |
+| **Exakte Signatur** | Nur diese spezifische Signatur verwenden (kein alternatives Exemplar) |
+
+!!! info "Signatursuche"
+    Ohne **Exakte Signatur** wird nach der ähnlichsten Signatur gesucht – das gefundene Buch ist dasselbe, aber möglicherweise ein anderes Exemplar.
+
+---
+
+## Apparat speichern
+
+Nach dem Ausfüllen aller Pflichtfelder:
+
+1. Klicken Sie auf **Speichern**
+2. Der Apparat wird in der Datenbank gespeichert
+3. Optional: Bei aktiviertem **Mail senden** öffnet sich der Mail-Dialog
+
+!!! note "E-Mail-Versand"
+    Der E-Mail-Versand erfordert konfigurierte [Mail-Zugangsdaten](../allgemein/hauptoberflaeche.md#e-mail).

docs/semesterapparat/index.md

@@ -0,0 +1,47 @@
+# Semesterapparat
+
+In diesem Abschnitt finden Sie alle Informationen zur Verwaltung von Semesterapparaten.
+
+<div class="grid cards" markdown>
+
+-   :lucide-book-plus:{ .lg .middle } **Anlegen**
+
+    ---
+
+    Erstellen Sie neue Semesterapparate mit allen erforderlichen Informationen.
+
+    [:octicons-arrow-right-24: Apparat anlegen](anlegen.md)
+
+-   :lucide-calendar-plus:{ .lg .middle } **Verlängern**
+
+    ---
+
+    Verlängern Sie bestehende Apparate für ein weiteres Semester.
+
+    [:octicons-arrow-right-24: Apparat verlängern](verlaengern.md)
+
+-   :lucide-trash-2:{ .lg .middle } **Löschen**
+
+    ---
+
+    Entfernen Sie nicht mehr benötigte Semesterapparate.
+
+    [:octicons-arrow-right-24: Apparat löschen](loeschen.md)
+
+-   :lucide-bar-chart-2:{ .lg .middle } **Statistik**
+
+    ---
+
+    Erhalten Sie Einblicke in die Nutzung der Semesterapparate.
+
+    [:octicons-arrow-right-24: Zur Statistik](statistik.md)
+
+-   :lucide-search:{ .lg .middle } **Suche**
+
+    ---
+
+    Durchsuchen Sie bestehende Apparate und Medien.
+
+    [:octicons-arrow-right-24: Zur Suche](suche.md)
+
+</div>

docs/semesterapparat/loeschen.md

@@ -0,0 +1,63 @@
+# Semesterapparat löschen
+
+Das Löschen von Semesterapparaten erfolgt über die [Suche & Statistik](suche.md) Seite.
+
+---
+
+## Löschvorgang
+
+### Einzelnen Apparat löschen
+
+1. Navigieren Sie zu **Suchen/Statistik**
+2. Suchen Sie den gewünschten Apparat
+3. Aktivieren Sie die Checkbox des Apparats
+4. Klicken Sie auf **Ausgewählte Löschen**
+
+### Mehrere Apparate löschen
+
+1. Verwenden Sie die Suche mit dem Filter **Löschbar**
+2. Wählen Sie alle zu löschenden Apparate aus
+3. Klicken Sie auf **Ausgewählte Löschen**
+
+!!! tip "Filter: Löschbar"
+    Der Filter **Löschbar** zeigt alle Apparate an, deren Endsemester abgelaufen ist und die zur Löschung vorgemerkt werden können.
+
+---
+
+## Bestätigung
+
+Nach dem Klicken auf **Ausgewählte Löschen**:
+
+![Löschbestätigung](../images/ss_stat_delete.png){ loading=lazy }
+
+Die gelöschten Apparate werden in der Tabelle mit **rotem Hintergrund** angezeigt.
+
+!!! failure "Gelöschte Apparate"
+    Gelöschte Apparate verbleiben in der Datenbank, werden aber als inaktiv markiert. Sie können bei Bedarf wiederhergestellt werden.
+
+---
+
+## Dozenten benachrichtigen
+
+Bei der Löschung kann eine Benachrichtigung an den Dozenten versendet werden:
+
+![Mail bei Löschung](../images/mail_delete.png){ loading=lazy }
+
+1. Wählen Sie die zu löschenden Apparate aus
+2. Klicken Sie auf **Ausgewählte Benachrichtigen**
+3. Konfigurieren Sie die Anrede
+4. Versenden Sie die Mail
+
+Weitere Informationen: [Mails](../allgemein/hauptoberflaeche.md#e-mail)
+
+---
+
+## Wiederherstellen
+
+Gelöschte Apparate können wiederhergestellt werden:
+
+1. Suchen Sie den gelöschten Apparat (rot markiert)
+2. Rechtsklick → **Wiederherstellen**
+
+!!! success "Mehrfachwiederherstellung"
+    Mit ++ctrl+left-button++ können mehrere Apparate gleichzeitig ausgewählt und wiederhergestellt werden.

docs/semesterapparat/statistik.md

@@ -0,0 +1,86 @@
+# Statistik
+
+Die Statistikfunktion bietet einen Überblick über alle Semesterapparate und deren Entwicklung über die Zeit.
+
+![Statistikbereich](../images/ss_stats_table.png){ loading=lazy }
+
+---
+
+## Apparatsstatistik
+
+Die Statistik zeigt alle Semester an, in denen Apparate erstellt oder gelöscht wurden.
+
+### Tabellenansicht
+
+| Spalte | Beschreibung |
+|--------|--------------|
+| **Semester** | Das betroffene Semester |
+| **Erstellt** | Anzahl erstellter Apparate |
+| **Gelöscht** | Anzahl gelöschter Apparate |
+
+!!! tip "Detailansicht"
+    Mit einem **Doppelklick** auf ein Semester werden die einzelnen Apparate angezeigt.
+
+### Detaillierte Ansicht
+
+![Detailansicht](../images/ss_stats_detailed.png){ loading=lazy }
+
+Die Detailansicht zeigt:
+
+- Alle Personen, die in diesem Semester Apparate erstellt/gelöscht haben
+- Pro Person: Liste aller erstellten oder gelöschten Apparate
+
+??? info "Navigation"
+    - Klick auf :material-chevron-right: zeigt die Apparate einer Person
+    - Doppelklick auf einen Apparat wechselt zur [Hauptoberfläche](../allgemein/hauptoberflaeche.md)
+
+!!! warning "Gelöschte Apparate"
+    Gelöschte Apparate können nicht angezeigt werden – die Doppelklick-Funktion ist dort deaktiviert.
+
+---
+
+## Diagramm
+
+![Statistik-Diagramm](../images/ss_stats_graph.png){ loading=lazy }
+
+Das Liniendiagramm visualisiert:
+
+- :material-chart-line:{ style="color: green" } **Grün**: Erstellte Apparate
+- :material-chart-line:{ style="color: red" } **Rot**: Gelöschte Apparate
+
+!!! tip "Interaktivität"
+    Hovern Sie über Datenpunkte für genaue Werte.
+
+---
+
+## Auswertungen
+
+### Typische Fragestellungen
+
+<div class="grid cards" markdown>
+
+-   :lucide-trending-up: **Wachstum**
+
+    ---
+
+    Wie viele Apparate wurden pro Semester erstellt?
+
+-   :lucide-users: **Nutzung**
+
+    ---
+
+    Welche Dozenten nutzen den Service am meisten?
+
+-   :lucide-calendar: **Saisonalität**
+
+    ---
+
+    Gibt es Unterschiede zwischen Sommer- und Wintersemester?
+
+-   :lucide-archive: **Bereinigung**
+
+    ---
+
+    Wie viele Apparate werden regelmäßig gelöscht?
+
+</div>

docs/semesterapparat/suche.md

@@ -0,0 +1,109 @@
+# Suche
+
+![Suche und Statistik](../images/main_search_stat.png){ loading=lazy }
+
+Die Suchseite bietet zwei Hauptfunktionen: die **Apparatsuche** und die **Mediensuche**.
+
+---
+
+## Apparatsuche
+
+### Suchfilter
+
+![Statistiksuche](../images/ss_stat_search.png){ loading=lazy }
+
+| Filter | Beschreibung |
+|--------|--------------|
+| **AppNr** | Nummer des Semesterapparates (Dropdown mit allen belegten Nummern) |
+| **Person** | Name des Dozenten |
+| **Fach** | Fachrichtung des Apparates |
+| **Erstell-Semester** | Semester der Erstellung |
+| **End-Semester** | Geplantes Ende des Apparates |
+| **Dauerapp** | Nur Dauerapparate anzeigen |
+| **Löschbar** | Alle löschbaren Apparate (überschreibt andere Filter) |
+
+!!! tip "Alle anzeigen"
+    Starten Sie die Suche ohne Eingabe, um **alle** Semesterapparate anzuzeigen.
+
+---
+
+## Suchergebnisse
+
+![Suchergebnisse](../images/ss_stat_result.png){ loading=lazy }
+
+### Ergebnistabelle
+
+Für jeden Treffer wird angezeigt:
+
+- :material-checkbox-marked-outline: Checkbox zur Auswahl
+- **Apparatsname**
+- **Apparatsnummer**
+- **Person**
+- **Fach**
+
+!!! failure "Gelöschte Apparate"
+    Gelöschte Apparate werden mit **rotem Hintergrund** angezeigt.
+
+### Slider
+
+!!! info "Layout anpassen"
+    Der vertikale Slider zwischen Tabelle und Graph kann verschoben werden, um mehr Platz für einen der Bereiche zu schaffen.
+
+---
+
+## Aktionen
+
+### Ausgewählte Löschen
+
+![Löschen](../images/ss_stat_delete.png){ loading=lazy }
+
+1. Aktivieren Sie die Checkboxen der zu löschenden Apparate
+2. Klicken Sie auf **Ausgewählte Löschen**
+3. Gelöschte Apparate werden rot markiert
+
+Weitere Informationen: [Apparat löschen](loeschen.md)
+
+### Ausgewählte Benachrichtigen
+
+![Mail bei Löschung](../images/mail_delete.png){ loading=lazy }
+
+Versendet eine E-Mail an die Dozenten der ausgewählten Apparate.
+
+1. Wählen Sie die Apparate aus
+2. Klicken Sie auf **Ausgewählte Benachrichtigen**
+3. Konfigurieren Sie die Anrede
+4. Versenden Sie die Mail
+
+---
+
+## Kontextmenü
+
+Rechtsklick auf einen Apparat öffnet das Kontextmenü:
+
+| Option | Beschreibung |
+|--------|--------------|
+| :lucide-calendar-plus: **Verlängern** | Öffnet den [Verlängerungsdialog](verlaengern.md) |
+| :lucide-undo: **Wiederherstellen** | Stellt gelöschte Apparate wieder her |
+
+!!! tip "Mehrfachauswahl"
+    Mit ++ctrl+left-button++ auf die Zeilennummer können mehrere Apparate für die Wiederherstellung ausgewählt werden.
+
+---
+
+## Mediensuche
+
+Der **Suchbereich** prüft, ob ein Exemplar in einem Apparat vorhanden ist.
+
+### Suchkriterien
+
+| Kriterium | Beschreibung |
+|-----------|--------------|
+| **Titel** | Titel des Exemplars (automatische Trunkierung) |
+| **Signatur** | Signatur des Exemplars (automatische Trunkierung) |
+
+!!! warning "Pflichtfelder"
+    Im Gegensatz zur Apparatsuche kann hier **keine** leere Suche durchgeführt werden, da zu viele Ergebnisse möglich wären.
+
+### Ergebnisse
+
+Die gefundenen Exemplare werden mit den zugehörigen Apparaten angezeigt.

docs/semesterapparat/verlaengern.md

@@ -0,0 +1,44 @@
+# Semesterapparat verlängern
+
+Ein Dialog zum Verlängern eines Semesterapparates für ein weiteres Semester.
+
+![Verlängerung](../images/extend.png){ loading=lazy }
+
+---
+
+## Verlängerung durchführen
+
+### Schritte
+
+1. Wählen Sie den zu verlängernden Apparat in der [Suche](suche.md) oder [Statistik](statistik.md) aus
+2. Öffnen Sie den Verlängerungsdialog via Rechtsklick → **Verlängern**
+3. Wählen Sie das Zielsemester aus
+4. Klicken Sie auf **Speichern**
+
+### Eingabefelder
+
+| Feld | Beschreibung |
+|------|--------------|
+| **Semester** | Sommer- oder Wintersemester auswählen |
+| **Jahr** | Das Jahr des neuen Semesters |
+| **Dauerapparat** | :lucide-check: Markiert den Apparat als Dauerapparat |
+
+---
+
+## Dauerapparat
+
+!!! info "Was ist ein Dauerapparat?"
+    Ein Dauerapparat wird nicht automatisch zur Löschung vorgemerkt und bleibt aktiv, bis er manuell gelöscht wird.
+
+!!! warning "Hinweis"
+    Damit der Apparat als Dauerapparat verlängert werden kann, **muss** trotzdem ein Semester angegeben werden.
+
+---
+
+## Nach der Verlängerung
+
+Nach dem Speichern:
+
+- [x] Das Endsemester wird automatisch aktualisiert
+- [x] Die Änderung erscheint in allen relevanten Tabellen
+- [x] Optional: Benachrichtigung an den Dozenten versenden

docs/sonstiges/bilder.md

@@ -0,0 +1,51 @@
+# Bilder
+
+Eine Sammlung von Screenshots und Referenzbildern aus dem SemesterapparatsManager.
+
+---
+
+## Admin-Bereich
+
+### Admin-Aktionen
+
+![Admin Aktionen](../images/actions.png){ loading=lazy }
+
+Die Admin-Aktionen ermöglichen administrative Aufgaben wie Datenbankwartung und Systemkonfiguration.
+
+---
+
+## Semesterapparat
+
+### Apparatscheckliste
+
+![Checkliste](../images/checklist.png){ loading=lazy }
+
+Die Checkliste zeigt den aktuellen Status eines Semesterapparates an.
+
+### Medien hinzufügen
+
+![Medien hinzufügen](../images/add_media.png){ loading=lazy }
+
+Dialog zum manuellen Hinzufügen von Medien über ihre Signaturen.
+
+---
+
+## Eingabehilfen
+
+### Kalender
+
+![Kalender](../images/calendar.png){ loading=lazy }
+
+Der Kalender ermöglicht die schnelle Auswahl von Datum und Semester.
+
+---
+
+## Weitere Screenshots
+
+!!! tip "Screenshots in der Dokumentation"
+    Detaillierte Screenshots finden Sie in den jeweiligen Abschnitten:
+    
+    - [Hauptoberfläche](../allgemein/hauptoberflaeche.md) – Übersicht der Benutzeroberfläche
+    - [Semesterapparat anlegen](../semesterapparat/anlegen.md) – Erstellung von Apparaten
+    - [ELSA anlegen](../elsa/anlegen.md) – Elektronische Semesterapparate
+    - [Zitieren](../elsa/zitieren.md) – Zitat-Dialog

docs/sonstiges/index.md

@@ -0,0 +1,15 @@
+# Sonstiges
+
+Zusätzliche Informationen und Ressourcen zum SemesterapparatsManager.
+
+<div class="grid cards" markdown>
+
+-   :lucide-image:{ .lg .middle } **Bilder**
+
+    ---
+
+    Bildergalerie mit Screenshots und Referenzbildern.
+
+    [:octicons-arrow-right-24: Zur Galerie](bilder.md)
+
+</div>

icons/db_search.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="24px" viewBox="0 -960 960 960" width="24px" fill="#e3e3e3"><path d="M472-120q-73-1-137.5-13.5t-112-34Q175-189 147.5-218T120-280q0 33 27.5 62t75 50.5q47.5 21.5 112 34T472-120Zm-71-204q-30-3-58-8t-53.5-12q-25.5-7-48-15.5T200-379q19 11 41.5 19.5t48 15.5q25.5 7 53.5 12t58 8Zm79-275q86 0 177.5-26T760-679q-11-29-100.5-55T480-760q-91 0-178.5 25.5T200-679q15 29 104.5 54.5T480-599Zm-61 396q10 23 23 44t30 39q-73-1-137.5-13.5t-112-34Q175-189 147.5-218T120-280v-400q0-33 28.5-62t77.5-51q49-22 114.5-34.5T480-840q74 0 139.5 12.5T734-793q49 22 77.5 51t28.5 62q0 33-28.5 62T734-567q-49 22-114.5 34.5T480-520q-85 0-157-15t-123-44v101q40 37 100 54t121 22q-8 15-13 34.5t-7 43.5q-60-7-111.5-20T200-379v99q14 25 77 47t142 30ZM864-40 756-148q-22 13-46 20.5t-50 7.5q-75 0-127.5-52.5T480-300q0-75 52.5-127.5T660-480q75 0 127.5 52.5T840-300q0 26-7.5 50T812-204L920-96l-56 56ZM660-200q42 0 71-29t29-71q0-42-29-71t-71-29q-42 0-71 29t-29 71q0 42 29 71t71 29Z"/></svg>

icons/manage_search.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="24px" viewBox="0 -960 960 960" width="24px" fill="#e3e3e3"><path d="M80-200v-80h400v80H80Zm0-200v-80h200v80H80Zm0-200v-80h200v80H80Zm744 400L670-354q-24 17-52.5 25.5T560-320q-83 0-141.5-58.5T360-520q0-83 58.5-141.5T560-720q83 0 141.5 58.5T760-520q0 29-8.5 57.5T726-410l154 154-56 56ZM560-400q50 0 85-35t35-85q0-50-35-85t-85-35q-50 0-85 35t-35 85q0 50 35 85t85 35Z"/></svg>

icons/print.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="24px" viewBox="0 -960 960 960" width="24px" fill="#e3e3e3"><path d="M640-640v-120H320v120h-80v-200h480v200h-80Zm-480 80h640-640Zm560 100q17 0 28.5-11.5T760-500q0-17-11.5-28.5T720-540q-17 0-28.5 11.5T680-500q0 17 11.5 28.5T720-460Zm-80 260v-160H320v160h320Zm80 80H240v-160H80v-240q0-51 35-85.5t85-34.5h560q51 0 85.5 34.5T880-520v240H720v160Zm80-240v-160q0-17-11.5-28.5T760-560H200q-17 0-28.5 11.5T160-520v160h80v-80h480v80h80Z"/></svg>

icons/search_results.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="24px" viewBox="0 -960 960 960" width="24px" fill="#e3e3e3"><path d="M400-320q100 0 170-70t70-170q0-100-70-170t-170-70q-100 0-170 70t-70 170q0 100 70 170t170 70Zm-40-120v-280h80v280h-80Zm-140 0v-200h80v200h-80Zm280 0v-160h80v160h-80ZM824-80 597-307q-41 32-91 49.5T400-240q-134 0-227-93T80-560q0-134 93-227t227-93q134 0 227 93t93 227q0 56-17.5 106T653-363l227 227-56 56Z"/></svg>

icons/trash.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="24px" viewBox="0 -960 960 960" width="24px" fill="#e3e3e3"><path d="M280-120q-33 0-56.5-23.5T200-200v-520h-40v-80h200v-40h240v40h200v80h-40v520q0 33-23.5 56.5T680-120H280Zm400-600H280v520h400v-520ZM360-280h80v-360h-80v360Zm160 0h80v-360h-80v360ZM280-720v520-520Z"/></svg>

mail.py

@@ -1,33 +0,0 @@
-
-from PyQt6 import QtWidgets
-
-from src.ui.dialogs.mail import Mail_Dialog
-
-
-def launch_gui(app_id="", app_name="", app_subject="", prof_name="", prof_mail=""):
-    QtWidgets.QApplication([""])
-
-    dialog = Mail_Dialog(
-        app_id=app_id,
-        app_name=app_name,
-        app_subject=app_subject,
-        prof_name=prof_name,
-        prof_mail=prof_mail,
-        # default_mail="Information bezüglich der Auflösung des Semesterapparates",
-    )
-    dialog.exec()
-
-
-if __name__ == "__main__":
-    app_id = "123"
-    app_name = "Test"
-    app_subject = "TestFach"
-    prof_name = "Test"
-    prof_mail = "kirchneralexander020@gmail.com"
-    launch_gui(
-        app_id=app_id,
-        app_name=app_name,
-        app_subject=app_subject,
-        prof_name=prof_name,
-        prof_mail=prof_mail,
-    )

mail_vorlagen/Bitte um Bestellung von Neuerwerbungen für Semesterapparat {AppNr} - {AppName}.eml

@@ -0,0 +1,13 @@
+
+Subject: Bitte um Bestellung von Neuerwerbungen für Semesterapparat {AppNr} - {AppName}
+
+
+Hallo zusammen, 
+
+für den Semesterapparat {AppNr} - {Appname} wurden folgende Neuauflagen gefunden:
+
+{newEditionsOrdered}
+
+Wäre es möglich, diese, oder neuere Auflagen (wenn vorhanden), zu bestellen?
+
+{signature}

mail_vorlagen/Information bezüglich der Auflösung des Semesterapparates {AppNr}.eml

@@ -1,37 +1,17 @@
-Message-ID: <b44248a9-025e-e86c-85d7-5949534f0ac4@ph-freiburg.de>
-Date: Mon, 17 Jul 2023 12:59:04 +0200
-MIME-Version: 1.0
-User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
- Thunderbird/102.13.0
-Content-Language: de-DE
-From: {user_name} <{user_mail}>
-Subject: =?UTF-8?Q?Information_bez=c3=bcglich_der_Aufl=c3=b6sung_des_Semeste?=
- =?UTF-8?Q?rapparates_=7bAppNr=7d?=
-X-Mozilla-Draft-Info: internal/draft; vcard=0; receipt=0; DSN=0; uuencode=0;
- attachmentreminder=0; deliveryformat=0
-X-Identity-Key: id1
-Fcc: imap://aky547@imap.ph-freiburg.de/INBOX/Sent
-Content-Type: text/html; charset=UTF-8
-Content-Transfer-Encoding: 8bit
 
-<html>
-  <head>
-    <meta http-equiv="content-type" content="text/html; charset=UTF-8">
-  </head>
-  <body>{greeting}
-    <br>
-    <p>auf die E-Mail bezüglich der Auflösung oder Verlängerung der Semesterapparate haben wir von Ihnen keine Rückmeldung erhalten. Deshalb gehen wir davon aus, dass der Apparat aufgelöst werden kann.</p>
-    <p> Die Medien, die in den Apparaten aufgestellt waren, werden nun wieder regulär ausleihbar und sind dann an ihren Standorten bei den Fächern zu finden.</p>
-    <p></p>
-    <p>Falls Sie den Apparat erneut, oder einen neuen Apparat anlegen wollen, können Sie mir das ausgefüllte Formular zur Einrichtung des Apparates (<a class="moz-txt-link-freetext" href="https://www.ph-freiburg.de/bibliothek/lernen/semesterapparate/info-lehrende-sem.html">https://www.ph-freiburg.de/bibliothek/lernen/semesterapparate/info-lehrende-sem.html</a>) zukommen lassen.</p>
-    <p>Im Falle einer Verlängerung des Apparates reicht eine Antwort auf diese Mail.<br>
-    </p>
-    <p>Bei Fragen können Sie sich jederzeit an mich wenden.<br>
-    </p>
-    <p><br>
-    </p>
-    <pre class="moz-signature" cols="72">-- 
-{signature}
-</pre>
-  </body>
-</html>
+Subject: Information bezüglich der Auflösung des Semesterapparates {AppNr}
+
+
+{greeting}
+
+auf die E-Mail bezüglich der Auflösung oder Verlängerung der Semesterapparate haben wir von Ihnen keine Rückmeldung erhalten. Deshalb gehen wir davon aus, dass der Apparat aufgelöst werden kann.
+Die Medien, die in den Apparaten aufgestellt waren, werden nun wieder regulär ausleihbar und sind dann an ihren Standorten bei den Fächern zu finden.
+
+Falls Sie den Apparat erneut, oder einen neuen Apparat anlegen wollen,
+können Sie mir das ausgefüllte Formular zur Einrichtung des Apparates
+https://www.ph-freiburg.de/bibliothek/lernen/semesterapparate/info-lehrende-sem.html
+zukommen lassen. Im Falle einer Verlängerung des Apparates reicht eine Antwort auf diese Mail.
+
+Bei Fragen können Sie sich jederzeit an mich wenden.
+
+{signature}

mail_vorlagen/Information zum Semesterapparat {AppNr} - {AppName}.eml

@@ -1,36 +1,16 @@
-Message-ID: <db617c48-29d6-d3d8-a67c-e9a6cf9b5bdb@ph-freiburg.de>
-Date: Tue, 12 Sep 2023 13:01:35 +0200
-MIME-Version: 1.0
-User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:102.0) Gecko/20100101
- Thunderbird/102.15.0
-From: Alexander Kirchner <alexander.kirchner@ph-freiburg.de>
-Subject: Information zum Semesterapparat {AppNr} - {Appname}
-Content-Language: de-DE
-X-Mozilla-Draft-Info: internal/draft; vcard=0; receipt=0; DSN=0; uuencode=0;
- attachmentreminder=0; deliveryformat=0
-X-Identity-Key: id1
-Fcc: imap://aky547@imap.ph-freiburg.de/INBOX/Sent
-Content-Type: text/html; charset=UTF-8
-Content-Transfer-Encoding: 8bit
 
-<html>
-  <head>
-    <meta http-equiv="content-type" content="text/html; charset=UTF-8">
-  </head>
-  <body>{greeting}
-    <br>
-    <p>Ihr Semesterapparat {Appname} wurde angelegt.</p>
-    <p>Unter folgendem Link können Sie die Apparate einsehen:</p>
-    <p><a class="moz-txt-link-freetext" href="https://bsz.ibs-bw.de/aDISWeb/app?service=direct/0/Home/$DirectLink&amp;sp=SOPAC42&amp;sp=SWI00000002&amp;noRedir">https://bsz.ibs-bw.de/aDISWeb/app?service=direct/0/Home/$DirectLink&amp;sp=SOPAC42&amp;sp=SWI00000002&amp;noRedir</a></p>
-    <p>Ihr Apparat ist unter {AppSubject} > {Profname} > {AppNr} {Appname}.<br>
-    </p>
-    <p><br>
-    </p>
-    <p>Noch nicht vorhandene Medien wurden vorgemerkt und werden nach Rückkehr in die Bibliothek eingearbeitet.</p>
-    <p>Bei Fragen können Sie sich per Mail bei mir melden.<br>
-    </p>
-    <pre class="moz-signature" cols="72">-- 
-{signature}
-</pre>
-  </body>
-</html>
+Subject: Information zum Semesterapparat {AppNr} - {AppName}
+
+
+{greeting}
+
+Ihr Semesterapparat {Appname} wurde angelegt.
+Unter folgendem Link können Sie die Apparate einsehen:
+https://bsz.ibs-bw.de/aDISWeb/app?service=direct/0/Home/$DirectLink&amp;sp=SOPAC42&amp;sp=SWI00000002&amp;noRedir
+
+Ihr Apparat ist unter {AppSubject} > {Profname} > {AppNr} {Appname}
+
+Noch nicht vorhandene Medien wurden vorgemerkt und werden nach Rückkehr in die Bibliothek eingearbeitet.
+Bei Fragen können Sie sich per Mail bei mir melden.
+
+{signature}

mail_vorlagen/Information zur Auflösung des Semesterapparates {AppNr} - {Appname}.eml

@@ -0,0 +1,10 @@
+
+Subject: Information zur Auflösung des Semesterapparates {AppNr} - {Appname}
+
+
+{greeting}
+
+Ihr Semesterapparat "{Appname} ({AppNr})" wurde wie besprochen aufgelöst.
+Die Medien sind von nun an wieder in den Regalen zu finden.
+
+{signature}

mail_vorlagen/Neuauflagen für Semesterapparat {AppNr} - {AppName}.eml

@@ -0,0 +1,15 @@
+
+Subject: Neuauflagen für Semesterapparat {AppNr} - {AppName}
+
+
+{greeting}
+
+Für Ihren Semesterapparat {AppNr} - {Appname} wurden folgende Neuauflagen gefunden: 
+
+{newEditions}
+
+Sollen wir die alte(n) Auflage(n) aus dem Apparat durch diese austauschen? 
+Nicht vorhandene Exemplare werden an die Erwerbungsabteilung weitergegeben 
+und nach Erhalt der Medien in den Apparat eingearbeitet. 
+
+{signature}

mail_vorlagen/blankomail.eml

@@ -0,0 +1,9 @@
+
+Subject: CHANGEME
+
+
+{greeting}
+
+
+
+{signature}

main.py

@@ -1,4 +1,22 @@
+import sys
+
+from PySide6 import QtWidgets
+
+from src import first_launch, settings
+from src.shared.logging import configure
 from src.ui.userInterface import launch_gui as UI
+from src.ui.widgets.welcome_wizard import launch_wizard as startup
 
 if __name__ == "__main__":
-    UI()
+    configure("INFO")
+    app = QtWidgets.QApplication(sys.argv)
+    if not first_launch:
+        setup = startup()
+        if setup == 1:
+            settings.reload()
+            # kill qApplication singleton
+            UI()
+        else:
+            sys.exit()
+    else:
+        UI()

mkdocs.yml

@@ -1,30 +0,0 @@
-site_name: SemesterapparatsManager
-theme:
-  features:
-    - search.suggest
-    - search.highlight
-  name: material
-  icon:
-    admonition:
-      note: fontawesome/solid/note-sticky
-      abstract: fontawesome/solid/book
-      info: fontawesome/solid/circle-info
-      tip: fontawesome/solid/bullhorn
-      success: fontawesome/solid/check
-      question: fontawesome/solid/circle-question
-      warning: fontawesome/solid/triangle-exclamation
-      failure: fontawesome/solid/bomb
-      danger: fontawesome/solid/skull
-      bug: fontawesome/solid/robot
-      example: fontawesome/solid/flask
-      quote: fontawesome/solid/quote-left
-
-markdown_extensions:
-  - admonition
-  - pymdownx.details
-  - pymdownx.superfences
-  - tables
-extra_css:
-  - stylesheets/extra.css
-plugins:
-  - search

pyproject.toml

@@ -1,30 +1,36 @@
 [project]
 name = "semesterapparatsmanager"
-version = "0.1.0"
+version = "1.0.2"
 description = "Add your description here"
 readme = "README.md"
-requires-python = ">=3.12"
+requires-python = ">=3.13"
 dependencies = [
-    "beautifulsoup4>=4.12.3",
+    "appdirs>=1.4.4",
+    "beautifulsoup4>=4.13.5",
+    "bibapi>=0.0.6",
     "bump-my-version>=0.29.0",
-    "chardet>=5.2.0",
+    "charset-normalizer>=3.4.3",
     "comtypes>=1.4.9",
     "darkdetect>=0.8.0",
     "docx2pdf>=0.1.8",
+    "httpx>=0.28.1",
     "loguru>=0.7.3",
-    "mkdocs>=1.6.1",
-    "mkdocs-material>=9.5.49",
-    "mkdocs-material-extensions>=1.3.1",
     "natsort>=8.4.0",
     "omegaconf>=2.3.0",
+    "openai>=1.79.0",
     "pandas>=2.2.3",
+    "pdfquery>=0.4.3",
     "playwright>=1.49.1",
-    "pyqt6>=6.8.0",
-    "pyqtgraph>=0.13.7",
+    "pymupdf>=1.26.6",
+    "flask>=3.1.0",
+    "pyside6>=6.9.1",
     "python-docx>=1.1.2",
     "pyzotero>=1.6.4",
     "ratelimit>=2.2.1",
+    "regex>=2025.11.3",
     "requests>=2.32.3",
+    "setuptools>=82.0.0",
+    "zensical>=0.0.10",
 ]
 
 [dependency-groups]
@@ -32,4 +38,26 @@ dev = [
     "bump-my-version>=0.29.0",
     "icecream>=2.1.4",
     "nuitka>=2.5.9",
+    "pytest",
+    "pytest-cov",
+    "pyinstaller>=6.17.0",
+    "ty>=0.0.15",
 ]
+swbtest = ["alive-progress>=3.3.0"]
+
+[tool.ruff]
+line-length = 88
+target-version = "py313"
+
+
+[[tool.uv.index]]
+name = "gitea"
+url = "https://git.theprivateserver.de/api/packages/PHB/pypi/simple/"
+
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "--cov=src --cov-report=term-missing"
+
+[tool.coverage.run]
+omit = ["main.py", "test.py", "tests/*", "__init__.py", ]

pytest.ini

@@ -1,12 +0,0 @@
-[pytest]
-# command should be *including --cov to generate coverage report
-addopts = --cov
-testpaths = tests
-python_files = test_*.py
-; Configuring pytest
-; More info: https://docs.pytest.org/en/6.2.x/customize.html
-
-;Logging
-; DATE FORMAT EXAMPLE: %Y-%m-%d %H:%M:%S
-; log_cli_format = %(asctime)s %(levelname)-8s %(name)-8s %(message)s
-; log_cli_date_format = %H:%M:%S

src/__init__.py

@@ -1,27 +1,67 @@
-import sys
-from config import Config
-import os
-from loguru import logger as log
-from datetime import datetime
-
-settings = Config("config/config.yaml")
-from .utils.icon import Icon
-
-__version__ = "0.2.0-dev0"
+__version__ = "1.0.0"
 __author__ = "Alexander Kirchner"
+__all__ = ["__author__", "__version__", "settings"]
+
+import os
+import sys
+from pathlib import Path
+from typing import Union
 
 
-if not os.path.exists("logs"):
-    os.mkdir("logs")
-    # open and close the file to create it
-logger = log
-logger.remove()
-logger.add("logs/application.log", rotation="1 week", enqueue=True)
-log.add(
-    f"logs/{datetime.now().strftime('%Y-%m-%d')}.log",
-    rotation="1 day",
-    compression="zip",
+def get_app_base_path() -> Path:
+    """Get the base path for the application, handling PyInstaller frozen apps."""
+    if getattr(sys, "frozen", False):
+        # Running as compiled/frozen
+        return Path(sys.executable).parent
+    return Path(__file__).parent.parent
+
+
+# Initialize LOG_DIR and CONFIG_DIR with fallbacks for frozen apps
+try:
+    from appdirs import AppDirs
+
+    app = AppDirs("SemesterApparatsManager", "SAM")
+    _user_log_dir = app.user_log_dir
+    _user_config_dir = app.user_config_dir
+except Exception:
+    _user_log_dir = None
+    _user_config_dir = None
+
+# Ensure we always have valid paths
+if not _user_log_dir:
+    _user_log_dir = str(get_app_base_path() / "logs")
+if not _user_config_dir:
+    _user_config_dir = str(get_app_base_path() / "config")
+
+from config import Config  # noqa: E402
+
+LOG_DIR: str = _user_log_dir
+CONFIG_DIR: str = _user_config_dir
+
+# Create directories if they don't exist
+try:
+    if not Path(LOG_DIR).exists():
+        os.makedirs(LOG_DIR)
+    if not Path(CONFIG_DIR).exists():
+        os.makedirs(CONFIG_DIR)
+except Exception:
+    # Fallback to current directory if we can't create the directories
+    LOG_DIR = str(get_app_base_path() / "logs")
+    CONFIG_DIR = str(get_app_base_path() / "config")
+    Path(LOG_DIR).mkdir(parents=True, exist_ok=True)
+    Path(CONFIG_DIR).mkdir(parents=True, exist_ok=True)
+
+
+settings = Config(f"{CONFIG_DIR}/config.yaml")
+DATABASE_DIR: Union[Path, str] = (  # type: ignore
+    app.user_config_dir if settings.database.path is None else settings.database.path  # type: ignore
 )
+if not Path(DATABASE_DIR).exists():  # type: ignore
+    os.makedirs(DATABASE_DIR)  # type: ignore
+first_launch = settings.exists
+if not Path(settings.database.temp.expanduser()).exists():  # type: ignore
+    settings.database.temp.expanduser().mkdir(parents=True, exist_ok=True)  # type: ignore
 
-# logger.add(sys.stderr, format="{time} {level} {message}", level="INFO")
-logger.add(sys.stdout)
+if not Path("logs").exists():
+    Path("logs").mkdir(exist_ok=True)
+    # open and close the file to create it

src/admin/__init__.py

@@ -0,0 +1,5 @@
+"""Administrative functions and commands."""
+
+from .commands import AdminCommands
+
+__all__ = ["AdminCommands"]

src/admin/commands.py

@@ -1,7 +1,8 @@
 import hashlib
 import random
 
-from .database import Database
+from src.database import Database
+from src.shared.logging import log
 
 
 # change passwords for apparats, change passwords for users, list users, create and delete users etc
@@ -9,9 +10,14 @@ from .database import Database
 class AdminCommands:
     """Basic Admin commands for the admin console. This class is used to create, delete, and list users. It also has the ability to change passwords for users."""
 
-    def __init__(self):
-        """Defaulf Constructor for the AdminCommands class."""
-        self.db = Database()
+    def __init__(self, db_path=None):
+        """Default Constructor for the AdminCommands class."""
+        if db_path is None:
+            self.db = Database()
+        else:
+            self.db = Database(db_path=db_path)
+        log.info("AdminCommands initialized with database connection.")
+        log.debug("location: {}", self.db.db_path)
 
     def create_password(self, password: str) -> tuple[str, str]:
         """Create a hashed password and a salt for the password.
@@ -44,6 +50,20 @@ class AdminCommands:
         hashed_password = self.hash_password("admin")
         self.db.createUser("admin", salt + hashed_password, "admin", salt)
 
+    def create_user(self, username: str, password: str, role: str = "user") -> bool:
+        """Create a new user in the database.
+
+        Args:
+            username (str): the username of the user to be created.
+            password (str): the password of the user to be created.
+            role (str, optional): the role of the user to be created. Defaults to "user".
+        """
+        hashed_password, salt = self.create_password(password)
+        status = self.db.createUser(
+            user=username, password=salt + hashed_password, role=role, salt=salt
+        )
+        return status
+
     def hash_password(self, password: str) -> str:
         """Hash a password using SHA256.
 

src/backend/__init__.py

@@ -1,7 +0,0 @@
-from .database import Database
-from .semester import Semester
-from .admin_console import AdminCommands
-from .thread_bookgrabber import BookGrabber
-from .threads_availchecker import AvailChecker
-from .threads_autoadder import AutoAdder
-from .documentation_thread import DocumentationThread

src/backend/catalogue.py

@@ -0,0 +1,301 @@
+from typing import List
+
+import regex
+import requests
+from bs4 import BeautifulSoup
+
+from src.core.models import BookData as Book
+from src.shared.logging import log
+
+URL = "https://rds.ibs-bw.de/phfreiburg/opac/RDSIndex/Search?type0%5B%5D=allfields&lookfor0%5B%5D={}&join=AND&bool0%5B%5D=AND&type0%5B%5D=au&lookfor0%5B%5D=&join=AND&bool0%5B%5D=AND&type0%5B%5D=ti&lookfor0%5B%5D=&join=AND&bool0%5B%5D=AND&type0%5B%5D=ct&lookfor0%5B%5D=&join=AND&bool0%5B%5D=AND&type0%5B%5D=isn&lookfor0%5B%5D=&join=AND&bool0%5B%5D=AND&type0%5B%5D=ta&lookfor0%5B%5D=&join=AND&bool0%5B%5D=AND&type0%5B%5D=co&lookfor0%5B%5D=&join=AND&bool0%5B%5D=AND&type0%5B%5D=py&lookfor0%5B%5D=&join=AND&bool0%5B%5D=AND&type0%5B%5D=pp&lookfor0%5B%5D=&join=AND&bool0%5B%5D=AND&type0%5B%5D=pu&lookfor0%5B%5D=&join=AND&bool0%5B%5D=AND&type0%5B%5D=si&lookfor0%5B%5D=&join=AND&bool0%5B%5D=AND&type0%5B%5D=zr&lookfor0%5B%5D=&join=AND&bool0%5B%5D=AND&type0%5B%5D=cc&lookfor0%5B%5D=&join=AND&bool0%5B%5D=AND"
+BASE = "https://rds.ibs-bw.de"
+
+
+class Catalogue:
+    def __init__(self, timeout=15):
+        self.timeout = timeout
+        reachable = self.check_connection()
+        if not reachable:
+            log.error("No internet connection available.")
+            raise ConnectionError("No internet connection available.")
+
+    def check_connection(self):
+        try:
+            response = requests.get("https://www.google.com", timeout=self.timeout)
+            if response.status_code == 200:
+                return True
+        except requests.exceptions.RequestException as e:
+            log.error(f"Could not connect to google.com: {e}")
+
+    def search_book(self, searchterm: str):
+        response = requests.get(URL.format(searchterm), timeout=self.timeout)
+        return response.text
+
+    def search(self, link: str):
+        response = requests.get(link, timeout=self.timeout)
+        return response.text
+
+    def get_book_links(self, searchterm: str) -> List[str]:
+        response = self.search_book(searchterm)
+        soup = BeautifulSoup(response, "html.parser")
+        links = soup.find_all("a", class_="title getFull")
+        res: List[str] = []
+        for link in links:
+            res.append(BASE + link["href"])  # type: ignore
+        return res
+
+    def get_book(self, searchterm: str):
+        log.info(f"Searching for term: {searchterm}")
+
+        links = self.get_book_links(searchterm)
+        # debug: links
+        # print(links)
+        for elink in links:
+            result = self.search(elink)
+            # in result search for class col-xs-12 rds-dl RDS_LOCATION
+            # if found, return text of href
+            soup = BeautifulSoup(result, "html.parser")
+
+            # Optional (unchanged): title and ppn if you need them
+            title_el = soup.find("div", class_="headline text")
+            title = title_el.get_text(strip=True) if title_el else None
+
+            ppn_el = soup.find(
+                "div",
+                class_="col-xs-12 col-md-5 col-lg-4 rds-dl-head RDS_PPN",
+            )
+            # in ppn_el, get text of div col-xs-12 col-md-7 col-lg-8 rds-dl-panel
+            ppn = (
+                ppn_el.find_next_sibling(
+                    "div",
+                    class_="col-xs-12 col-md-7 col-lg-8 rds-dl-panel",
+                ).get_text(strip=True)
+                if ppn_el
+                else None
+            )
+
+            # get edition text at div class col-xs-12 col-md-5 col-lg-4 rds-dl-head RDS_EDITION
+            edition_el = soup.find(
+                "div",
+                class_="col-xs-12 col-md-5 col-lg-4 rds-dl-head RDS_EDITION",
+            )
+            edition = (
+                edition_el.find_next_sibling(
+                    "div",
+                    class_="col-xs-12 col-md-7 col-lg-8 rds-dl-panel",
+                ).get_text(strip=True)
+                if edition_el
+                else None
+            )
+
+            authors = soup.find_all(
+                "div",
+                class_="col-xs-12 col-md-5 col-lg-4 rds-dl-head RDS_PERSON",
+            )
+            author = None
+            if authors:
+                # get the names of the a href links in the div col-xs-12 col-md-7 col-lg-8 rds-dl-panel
+                author_names = []
+                for author in authors:
+                    panel = author.find_next_sibling(
+                        "div",
+                        class_="col-xs-12 col-md-7 col-lg-8 rds-dl-panel",
+                    )
+                    if panel:
+                        links = panel.find_all("a")
+                        for link in links:
+                            author_names.append(link.text.strip())
+                author = (
+                    ";".join(author_names) if len(author_names) > 1 else author_names[0]
+                )
+            signature = None
+
+            panel = soup.select_one("div.panel-body")
+            if panel:
+                # Collect the RDS_* blocks in order, using the 'space' divs as separators
+                groups = []
+                cur = {}
+                for node in panel.select(
+                    "div.rds-dl.RDS_SIGNATURE, div.rds-dl.RDS_STATUS, div.rds-dl.RDS_LOCATION, div.col-xs-12.space",
+                ):
+                    classes = node.get("class", [])
+                    # Separator between entries
+                    if "space" in classes:
+                        if cur:
+                            groups.append(cur)
+                            cur = {}
+                        continue
+
+                    # Read the value from the corresponding panel cell
+                    val_el = node.select_one(".rds-dl-panel")
+                    val = (
+                        val_el.get_text(" ", strip=True)
+                        if val_el
+                        else node.get_text(" ", strip=True)
+                    )
+
+                    if "RDS_SIGNATURE" in classes:
+                        cur["signature"] = val
+                    elif "RDS_STATUS" in classes:
+                        cur["status"] = val
+                    elif "RDS_LOCATION" in classes:
+                        cur["location"] = val
+
+                if cur:  # append the last group if not followed by a space
+                    groups.append(cur)
+
+                # Find the signature for the entry whose location mentions "Semesterapparat"
+                for g in groups:
+                    loc = g.get("location", "").lower()
+                    if "semesterapparat" in loc:
+                        signature = g.get("signature")
+                        return Book(
+                            title=title,
+                            ppn=ppn,
+                            signature=signature,
+                            library_location=loc.split("-")[-1],
+                            link=elink,
+                            author=author,
+                            edition=edition,
+                        )
+                    return Book(
+                        title=title,
+                        ppn=ppn,
+                        signature=signature,
+                        library_location=loc.split("\n\n")[-1],
+                        link=elink,
+                        author=author,
+                        edition=edition,
+                    )
+
+    def get(self, ppn: str) -> Book | None:
+        # based on PPN, get title, people, edition, year, language, pages, isbn,
+        link = f"https://rds.ibs-bw.de/phfreiburg/opac/RDSIndexrecord/{ppn}"
+        result = self.search(link)
+        BeautifulSoup(result, "html.parser")
+
+    def get_ppn(self, searchterm: str) -> str | None:
+        links = self.get_book_links(searchterm)
+        ppn = None
+        for link in links:
+            result = self.search(link)
+            BeautifulSoup(result, "html.parser")
+            # debug: link
+            # print(link)
+            ppn = link.split("/")[-1]
+            if ppn and regex.match(r"^\d{8,10}[X\d]?$", ppn):
+                return ppn
+        return ppn
+
+    def get_semesterapparat_number(self, searchterm: str) -> int:
+        links = self.get_book_links(searchterm)
+        for link in links:
+            result = self.search(link)
+            # in result search for class col-xs-12 rds-dl RDS_LOCATION
+            # if found, return text of href
+            soup = BeautifulSoup(result, "html.parser")
+
+            locations = soup.find_all("div", class_="col-xs-12 rds-dl RDS_LOCATION")
+            for location_el in locations:
+                if "Semesterapparat-" in location_el.text:
+                    match = regex.search(r"Semesterapparat-(\d+)", location_el.text)
+                    if match:
+                        return int(match.group(1))
+                if "Handbibliothek-" in location_el.text:
+                    return location_el.text.strip().split("\n\n")[-1].strip()
+                return location_el.text.strip().split("\n\n")[-1].strip()
+        return 0
+
+    def get_author(self, link: str) -> str:
+        links = self.get_book_links(f"kid:{link}")
+        author = None
+        for link in links:
+            # print(link)
+            result = self.search(link)
+            soup = BeautifulSoup(result, "html.parser")
+            # get all authors, return them as a string seperated by ;
+            authors = soup.find_all(
+                "div",
+                class_="col-xs-12 col-md-5 col-lg-4 rds-dl-head RDS_PERSON",
+            )
+            if authors:
+                # get the names of the a href links in the div col-xs-12 col-md-7 col-lg-8 rds-dl-panel
+                author_names = []
+                for author in authors:
+                    panel = author.find_next_sibling(
+                        "div",
+                        class_="col-xs-12 col-md-7 col-lg-8 rds-dl-panel",
+                    )
+                    if panel:
+                        links = panel.find_all("a")
+                        for link in links:
+                            author_names.append(link.text.strip())
+                author = "; ".join(author_names)
+        return author
+
+    def get_signature(self, isbn: str):
+        links = self.get_book_links(f"{isbn}")
+        signature = None
+        for link in links:
+            result = self.search(link)
+            soup = BeautifulSoup(result, "html.parser")
+            panel = soup.select_one("div.panel-body")
+            if panel:
+                # Collect the RDS_* blocks in order, using the 'space' divs as separators
+                groups = []
+                cur = {}
+                for node in panel.select(
+                    "div.rds-dl.RDS_SIGNATURE, div.rds-dl.RDS_STATUS, div.rds-dl.RDS_LOCATION, div.col-xs-12.space",
+                ):
+                    classes = node.get("class", [])
+                    # Separator between entries
+                    if "space" in classes:
+                        if cur:
+                            groups.append(cur)
+                            cur = {}
+                        continue
+
+                    # Read the value from the corresponding panel cell
+                    val_el = node.select_one(".rds-dl-panel")
+                    val = (
+                        val_el.get_text(" ", strip=True)
+                        if val_el
+                        else node.get_text(" ", strip=True)
+                    )
+
+                    if "RDS_SIGNATURE" in classes:
+                        cur["signature"] = val
+                    elif "RDS_STATUS" in classes:
+                        cur["status"] = val
+                    elif "RDS_LOCATION" in classes:
+                        cur["location"] = val
+
+                if cur:  # append the last group if not followed by a space
+                    groups.append(cur)
+
+                # Find the signature for the entry whose location mentions "Semesterapparat"
+                for g in groups:
+                    # debug: group contents
+                    # print(g)
+                    loc = g.get("location", "").lower()
+                    if "semesterapparat" in loc:
+                        signature = g.get("signature")
+                        return signature
+                    signature = g.get("signature")
+                    return signature
+        # print("No signature found")
+        return signature
+
+    def in_library(self, ppn: str) -> bool:
+        if ppn is None:
+            return False
+        links = self.get_book_links(f"kid:{ppn}")
+        return len(links) > 0
+
+    def get_location(self, ppn: str) -> str | None:
+        if ppn is None:
+            return None
+        link = self.get_book(f"{ppn}")
+        if link is None:
+            return None
+        return link.library_location

src/backend/create_file.py

@@ -1,63 +0,0 @@
-import os
-from pathlib import Path
-
-
-from src.backend.database import Database
-
-db = Database()
-
-
-def recreateFile(name, app_id, filetype, open=True) -> Path:
-    """
-    recreateFile creates a file from the database and opens it in the respective program, if the open parameter is set to True.
-
-    Args:
-    ----
-        - name (str): The filename selected by the user.
-        - app_id (str): the id of the apparatus.
-        - filetype (str): the extension of the file to be created.
-        - open (bool, optional): Determines if the file should be opened. Defaults to True.
-
-    Returns:
-    -------
-        - Path: Absolute path to the file.
-    """
-    path = db.recreateFile(name, app_id, filetype=filetype)
-    path = Path(path)
-    if open:
-        if os.getenv("OS") == "Windows_NT":
-            path = path.resolve()
-            os.startfile(path)
-        else:
-            path = path.resolve()
-            os.system(f"open {path}")
-    return path
-
-
-def recreateElsaFile(filename: str, filetype: str, open=True) -> Path:
-    """
-    recreateElsaFile creates a file from the database and opens it in the respective program, if the open parameter is set to True.
-
-    Args:
-    ----
-        - filename (str): The filename selected by the user.
-        - open (bool, optional): Determines if the file should be opened. Defaults to True.
-
-    Returns:
-    -------
-        - Path: Absolute path to the file.
-    """
-    if filename.startswith("(") and filename.endswith(")"):
-        filename = str(filename[1:-1].replace("'", ""))
-    if not isinstance(filename, str):
-        raise ValueError("filename must be a string")
-    path = db.recreateElsaFile(filename, filetype)
-    path = Path(path)
-    if open:
-        if os.getenv("OS") == "Windows_NT":
-            path = path.resolve()
-            os.startfile(path)
-        else:
-            path = path.resolve()
-            os.system(f"open {path}")
-    return path

src/backend/delete_temp_contents.py

@@ -1,24 +0,0 @@
-import os
-from pathlib import Path
-from src import settings
-
-database = settings.database
-
-
-def delete_temp_contents():
-    """
-    delete_temp_contents deletes the contents of the temp directory.
-    """
-    path = database.temp
-    path = path.replace("~", str(Path.home()))
-    path = Path(path)
-    path = path.resolve()
-    for root, dirs, files in os.walk(path):
-        for file in files:
-            os.remove(os.path.join(root, file))
-        for dir in dirs:
-            os.rmdir(os.path.join(root, dir))
-
-
-if __name__ == "__main__":
-    delete_temp_contents()

src/backend/documentation_thread.py

@@ -1,11 +0,0 @@
-from PyQt6.QtCore import QThread
-from src.utils.documentation import run_mkdocs
-
-
-class DocumentationThread(QThread):
-    def __init__(self):
-        super().__init__()
-
-    def run(self):
-        # launch_documentation()
-        run_mkdocs()

src/backend/pickles.py

@@ -1,10 +0,0 @@
-import pickle
-from typing import Any, ByteString
-
-
-def make_pickle(data: Any):
-    return pickle.dumps(data)
-
-
-def load_pickle(data: ByteString):
-    return pickle.loads(data)

src/backend/semester.py

@@ -1,128 +0,0 @@
-import datetime
-from src import logger
-from dataclasses import dataclass
-
-
-@dataclass
-class Semester:
-    logger.debug("Semester class loaded")
-
-    _year: int | None = str(datetime.datetime.now().year)[2:]
-    _semester: str | None = None
-    _month: int | None = datetime.datetime.now().month
-    value: str = None
-
-    def __post_init__(self):
-        if isinstance(self._year, str):
-            self._year = int(self._year)
-        if self._year is None:
-            self._year = datetime.datetime.now().year[2:]
-        if self._month is None:
-            self._month = datetime.datetime.now().month
-        if self._semester is None:
-            self.generateSemester()
-        self.computeValue()
-
-    def __str__(self):
-        return self.value
-
-    def generateSemester(self):
-        if self._month < 4 or self._month < 9:
-            self._semester = "WiSe"
-        else:
-            self._semester = "SoSe"
-
-    @logger.catch
-    def computeValue(self):
-        # year is only last two digits
-        year = self._year
-        if self._semester == "WiSe":
-            if self._month < 4:
-                valueyear = str(year - 1) + "/" + str(year)
-        else:
-            valueyear = str(year)
-        self.value = f"{self._semester} {valueyear}"
-
-    @logger.catch
-    def offset(self, value: int) -> str:
-        """Generate a new Semester object by offsetting the current semester by a given value
-
-        Args:
-            value (int): The value by which the semester should be offset
-
-        Returns:
-            str: the new semester value
-        """
-        assert isinstance(value, int), "Value must be an integer"
-        if value == 0:
-            return self
-        if value > 0:
-            if value % 2 == 0:
-                return Semester(
-                    self._year - value // 2, self._semester - value // 2 + 1
-                )
-            else:
-                semester = self._semester
-                semester = "SoSe" if semester == "WiSe" else "WiSe"
-                return Semester(self._year + value // 2, semester)
-        else:
-            if value % 2 == 0:
-                return Semester(self.year + value // 2, self._semester)
-            else:
-                semester = self._semester
-                semester = "SoSe" if semester == "WiSe" else "WiSe"
-                return Semester(self._year + value // 2, semester)
-
-    def isPastSemester(self, semester) -> bool:
-        """Checks if the current Semester is a past Semester compared to the given Semester
-
-        Args:
-            semester (str): The semester to compare to
-
-        Returns:
-            bool: True if the current semester is in the past, False otherwise
-        """
-        if self.year < semester.year:
-            return True
-        if self.year == semester.year:
-            if self.semester == "WiSe" and semester.semester == "SoSe":
-                return True
-        return False
-
-    def isFutureSemester(self, semester: "Semester") -> bool:
-        """Checks if the current Semester is a future Semester compared to the given Semester
-
-        Args:
-            semester (str): The semester to compare to
-
-        Returns:
-            bool: True if the current semester is in the future, False otherwise
-        """
-        if self.year > semester.year:
-            return True
-        if self.year == semester.year:
-            if self.semester == "SoSe" and semester.semester == "WiSe":
-                return True
-        return False
-
-    def from_string(self, val):
-        self.value = val
-        self._year = int(val[-2:])
-        self._semester = val[:4]
-        return self
-
-    @property
-    def next(self):
-        return self.offset(1)
-
-    @property
-    def previous(self):
-        return self.offset(-1)
-
-    @property
-    def year(self):
-        return self._year
-
-    @property
-    def semester(self):
-        return self._semester

src/backend/settings.py

@@ -1,26 +0,0 @@
-from dataclasses import dataclass, field
-
-import yaml
-
-
-@dataclass
-class Settings:
-    """Settings for the app."""
-
-    save_path: str
-    database_name: str
-    database_path: str
-    bib_id: str
-    default_apps: bool = True
-    custom_applications: list[dict] = field(default_factory=list)
-
-    def save_settings(self):
-        """Save the settings to the config file."""
-        with open("config.yaml", "w") as f:
-            yaml.dump(self.__dict__, f)
-
-    def load_settings(self):
-        """Load the settings from the config file."""
-        with open("config.yaml", "r") as f:
-            data = yaml.safe_load(f)
-            return data

src/backend/thread_bookgrabber.py

@@ -1,188 +0,0 @@
-import sqlite3
-
-from PyQt6.QtCore import QThread
-from PyQt6.QtCore import pyqtSignal as Signal
-from src.backend import Database
-
-from src.logic.webrequest import BibTextTransformer, WebRequest
-
-
-class BookGrabber(QThread):
-    updateSignal = Signal(int, int)
-    done = Signal()
-
-    def __init__(self, appnr):
-        super(BookGrabber, self).__init__(parent=None)
-        self.is_Running = True
-        logger.info("Starting worker thread")
-        self.data = None
-        self.app_id = None
-        self.prof_id = None
-        self.mode = None
-        self.book_id = None
-        self.use_any = False
-        self.use_exact = False
-        self.appnr = appnr
-        self.tstate = (self.app_id, self.prof_id, self.mode, self.data)
-
-    def add_values(self, app_id, prof_id, mode, data, any_book=False, exact=False):
-        self.app_id = app_id
-        self.prof_id = prof_id
-        self.mode = mode
-        self.data = data
-        self.use_any = any_book
-        self.use_exact = exact
-        logger.info(f"Working on {len(self.data)} entries")
-        self.tstate = (self.app_id, self.prof_id, self.mode, self.data)
-        logger.debug("State: " + str(self.tstate))
-        # print(self.tstate)
-
-    def run(self):
-        self.db = Database()
-        item = 0
-        iterdata = self.data
-        # print(iterdata)
-        if self.prof_id is None:
-            self.prof_id = self.db.getProfNameByApparat(self.app_id)
-        for entry in iterdata:
-            # print(entry)
-            signature = str(entry)
-            logger.info("Processing entry: " + signature)
-
-            webdata = WebRequest().set_apparat(self.appnr).get_ppn(entry)
-            if self.use_any:
-                webdata = webdata.use_any_book
-            webdata = webdata.get_data()
-
-            if webdata == "error":
-                continue
-
-            bd = BibTextTransformer(self.mode)
-            print(webdata)
-            if self.mode == "ARRAY":
-                if self.use_exact:
-                    bd = bd.use_signature(entry)
-            bd = bd.get_data(webdata).return_data()
-            print(bd)
-            if bd is None:
-                # bd = BookData
-                continue
-            bd.signature = entry
-            transformer = (
-                BibTextTransformer("RDS").get_data(webdata).return_data("rds_data")
-            )
-
-            # confirm lock is acquired
-            self.db.addBookToDatabase(bd, self.app_id, self.prof_id)
-            # get latest book id
-            self.book_id = self.db.getLastBookId()
-            logger.info("Added book to database")
-            state = 0
-            for result in transformer.RDS_DATA:
-                # print(result.RDS_LOCATION)
-                if str(self.app_id) in result.RDS_LOCATION:
-                    state = 1
-                    break
-
-            logger.info(f"State of {signature}: {state}")
-            # print("updating availability of " + str(self.book_id) + " to " + str(state))
-            try:
-                self.db.setAvailability(self.book_id, state)
-            except sqlite3.OperationalError as e:
-                logger.error(f"Failed to update availability: {e}")
-
-            # time.sleep(5)
-            item += 1
-            self.updateSignal.emit(item, len(self.data))
-        logger.info("Worker thread finished")
-        # self.done.emit()
-        self.quit()
-
-    def stop(self):
-        self.is_Running = False
-
-
-# class BookGrabber(object):
-#     updateSignal = Signal(int, int)
-#     done = Signal()
-
-#     def __init__(self, app_id, prof_id, mode, data, parent=None):
-#         super(BookGrabber, self).__init__(parent=None)
-#         self.is_Running = True
-#         logger = MyLogger("Worker")
-#         logger.info("Starting worker thread")
-#         self.data = data
-#         logger.info(f"Working on {len(self.data)} entries")
-#         self.app_id = app_id
-#         self.prof_id = prof_id
-#         self.mode = mode
-#         self.book_id = None
-#         self.state = (self.app_id, self.prof_id, self.mode, self.data)
-#         # print(self.state)
-#         logger.info("state: " + str(self.state))
-#         # time.sleep(2)
-
-#     def resetValues(self):
-#         self.app_id = None
-#         self.prof_id = None
-#         self.mode = None
-#         self.data = None
-#         self.book_id = None
-
-#     def run(self):
-#         while self.is_Running:
-#             self.db = Database()
-#             item = 0
-#             iterdata = self.data
-#             # print(iterdata)
-#             for entry in iterdata:
-#                 # print(entry)
-#                 signature = str(entry)
-#                 logger.info("Processing entry: " + signature)
-
-#                 webdata = WebRequest().get_ppn(entry).get_data()
-#                 if webdata == "error":
-#                     continue
-#                 bd = BibTextTransformer(self.mode).get_data(webdata).return_data()
-#                 transformer = BibTextTransformer("RDS")
-#                 rds = transformer.get_data(webdata).return_data("rds_availability")
-#                 bd.signature = entry
-#                 # confirm lock is acquired
-#                 self.db.addBookToDatabase(bd, self.app_id, self.prof_id)
-#                 # get latest book id
-#                 self.book_id = self.db.getLastBookId()
-#                 logger.info("Added book to database")
-#                 state = 0
-#                 # print(len(rds.items))
-#                 for rds_item in rds.items:
-#                     sign = rds_item.superlocation
-#                     loc = rds_item.location
-#                     # logger.debug(sign, loc)
-#                     # logger.debug(rds_item)
-#                     if self.app_id in sign or self.app_id in loc:
-#                         state = 1
-#                         break
-
-#                 logger.info(f"State of {signature}: {state}")
-#                 # print(
-#                     "updating availability of "
-#                     + str(self.book_id)
-#                     + " to "
-#                     + str(state)
-#                 )
-#                 try:
-#                     self.db.setAvailability(self.book_id, state)
-#                 except sqlite3.OperationalError as e:
-#                     logger.error(f"Failed to update availability: {e}")
-
-#                 # time.sleep(5)
-#                 item += 1
-#                 self.updateSignal.emit(item, len(self.data))
-#             logger.info("Worker thread finished")
-#             # self.done.emit()
-#             self.stop()
-#             if not self.is_Running:
-#                 break
-
-#     def stop(self):
-#         self.is_Running = False

src/backend/threads_availchecker.py

@@ -1,72 +0,0 @@
-import time
-
-# from icecream import ic
-from PyQt6.QtCore import QThread
-from PyQt6.QtCore import pyqtSignal as Signal
-
-from src.backend.database import Database
-
-from src.logic.webrequest import BibTextTransformer, WebRequest
-
-# from src.transformers import RDS_AVAIL_DATA
-
-
-class AvailChecker(QThread):
-    updateSignal = Signal(str, int)
-    updateProgress = Signal(int, int)
-
-    def __init__(
-        self, links: list = None, appnumber: int = None, parent=None, books=list[dict]
-    ):
-        if links is None:
-            links = []
-        super().__init__(parent)
-        logger.info("Starting worker thread")
-        logger.info(
-            "Checking availability for "
-            + str(links)
-            + " with appnumber "
-            + str(appnumber)
-            + "..."
-        )
-        self.links = links
-        self.appnumber = appnumber
-        self.books = books
-        logger.info(
-            f"Started worker with appnumber: {self.appnumber} and links: {self.links} and {len(self.books)} books..."
-        )
-        time.sleep(2)
-
-    def run(self):
-        self.db = Database()
-        state = 0
-        count = 0
-        for link in self.links:
-            logger.info("Processing entry: " + str(link))
-            data = WebRequest().set_apparat(self.appnumber).get_ppn(link).get_data()
-            transformer = BibTextTransformer("RDS")
-            rds = transformer.get_data(data).return_data("rds_availability")
-
-            book_id = None
-            for item in rds.items:
-                sign = item.superlocation
-                loc = item.location
-                # # print(item.location)
-                if self.appnumber in sign or self.appnumber in loc:
-                    state = 1
-                    break
-            for book in self.books:
-                if book["bookdata"].signature == link:
-                    book_id = book["id"]
-                    break
-            logger.info(f"State of {link}: " + str(state))
-            # print("Updating availability of " + str(book_id) + " to " + str(state))
-            self.db.setAvailability(book_id, state)
-            count += 1
-            self.updateProgress.emit(count, len(self.links))
-            self.updateSignal.emit(item.callnumber, state)
-
-        logger.info("Worker thread finished")
-        # teminate thread
-
-        self.quit()

src/background/__init__.py

@@ -0,0 +1,16 @@
+"""Background tasks and threading operations."""
+
+from .autoadder import AutoAdder
+from .availability_checker import AvailChecker
+from .book_grabber import BookGrabber, BookGrabberTest
+from .new_editions import NewEditionCheckerThread
+from .documentation_server import DocumentationThread
+
+__all__ = [
+    "AutoAdder",
+    "AvailChecker",
+    "BookGrabber",
+    "BookGrabberTest",
+    "NewEditionCheckerThread",
+    "DocumentationThread",
+]

src/background/autoadder.py

@@ -1,11 +1,14 @@
 import time
 
+from src.shared.logging import log
+
 # from icecream import ic
-from PyQt6.QtCore import QThread
-from PyQt6.QtCore import pyqtSignal as Signal
+from PySide6.QtCore import QThread
+from PySide6.QtCore import Signal as Signal
 
-from src.backend import Database
+from src.database import Database
 
+# use centralized logging from src.shared.logging
 
 # from src.transformers import RDS_AVAIL_DATA
 
@@ -22,13 +25,13 @@ class AutoAdder(QThread):
         self.app_id = app_id
         self.prof_id = prof_id
 
-        # print("Launched AutoAdder")
-        # print(self.data, self.app_id, self.prof_id)
+        # #print("Launched AutoAdder")
+        # #print(self.data, self.app_id, self.prof_id)
 
     def run(self):
         self.db = Database()
         # show the dialog, start the thread to gather data and dynamically update progressbar and listwidget
-        logger.info("Starting worker thread")
+        log.info("Starting worker thread")
         item = 0
         for entry in self.data:
             try:
@@ -39,12 +42,12 @@ class AutoAdder(QThread):
                 time.sleep(1)
 
             except Exception as e:
-                # print(e)
-                logger.exception(
+                # #print(e)
+                log.exception(
                     f"The query failed with message {e} for signature {entry}"
                 )
                 continue
         if item == len(self.data):
-            logger.info("Worker thread finished")
+            log.info("Worker thread finished")
             # teminate thread
             self.finished.emit()

src/background/availability_checker.py

@@ -0,0 +1,83 @@
+# from icecream import ic
+from PySide6.QtCore import QThread
+from PySide6.QtCore import Signal as Signal
+
+from src.database import Database
+from src.services.webadis import get_book_medianr
+from src.services.webrequest import BibTextTransformer, TransformerType, WebRequest
+from src.shared.logging import log
+
+
+class AvailChecker(QThread):
+    updateSignal = Signal(str, int)
+    updateProgress = Signal(int, int)
+
+    def __init__(
+        self,
+        links: list[str] | None = None,
+        appnumber: int | None = None,
+        parent=None,
+        books: list[dict] | None = None,
+    ):
+        if links is None:
+            links = []
+        super().__init__(parent)
+        log.info("Starting worker thread")
+        log.info(
+            "Checking availability for "
+            + str(links)
+            + " with appnumber "
+            + str(appnumber)
+            + "...",
+        )
+        self.links = links
+        self.appnumber = appnumber
+        self.books = books or []
+        log.info(
+            f"Started worker with appnumber: {self.appnumber} and links: {self.links} and {len(self.books)} books...",
+        )
+        # Pre-create reusable request and transformer to avoid per-item overhead
+        self._request = WebRequest().set_apparat(self.appnumber)
+        self._rds_transformer = BibTextTransformer(TransformerType.RDS)
+
+    def run(self) -> None:
+        self.db = Database()
+        state = 0
+        count = 0
+        for link in self.links:
+            log.info("Processing entry: " + str(link))
+            data = self._request.get_ppn(link).get_data()
+            rds = self._rds_transformer.get_data(data).return_data("rds_availability")
+
+            book_id = None
+            if not rds or not rds.items:
+                log.warning(f"No RDS data found for link {link}")
+                continue
+            for item in rds.items:
+                sign = item.superlocation
+                loc = item.location
+                # # #print(item.location)
+                if str(self.appnumber) in sign or str(self.appnumber) in loc:
+                    state = 1
+                    break
+            for book in self.books:
+                if book["bookdata"].signature == link:
+                    book_id = book["id"]
+                    break
+            log.info(f"State of {link}: " + str(state))
+            # #print("Updating availability of " + str(book_id) + " to " + str(state))
+            # use get_book_medianr to update the medianr of the book in the database
+            auth = self.db.getWebADISAuth
+            medianr = get_book_medianr(rds.items[0].callnumber, self.appnumber, auth)
+            book_data = book["bookdata"]
+            book_data.medianr = medianr
+            self.db.updateBookdata(book["id"], book_data)
+            self.db.setAvailability(book_id, state)
+            count += 1
+            self.updateProgress.emit(count, len(self.links))
+            self.updateSignal.emit(item.callnumber, state)
+
+        log.info("Worker thread finished")
+        # teminate thread
+
+        self.quit()

src/background/book_grabber.py

@@ -0,0 +1,202 @@
+from PySide6.QtCore import QThread, Signal
+
+from src.database import Database
+from src.services.webrequest import BibTextTransformer, WebRequest
+from src.shared.logging import log, get_bloat_logger, preview
+
+# bloat logger for large/raw payloads
+bloat = get_bloat_logger()
+
+# Logger configured centrally in main; this module just uses `log`
+
+
+class BookGrabber(QThread):
+    updateSignal = Signal(int, int)
+    done = Signal()
+
+    def __init__(self):
+        super(BookGrabber, self).__init__(parent=None)
+        self.is_Running = True
+        log.info("Starting worker thread")
+        self.data = []
+        self.app_id = None
+        self.prof_id = None
+        self.mode = None
+        self.book_id = None
+        self.use_any = False
+        self.use_exact = False
+        self.app_nr = None
+        self.tstate = (self.app_id, self.prof_id, self.mode, self.data)
+        self.request = WebRequest()
+        self.db = Database()
+
+    def add_values(
+        self, app_id: int, prof_id: int, mode: str, data, any_book=False, exact=False
+    ):
+        self.app_id = app_id
+        self.prof_id = prof_id
+        self.mode = mode
+        self.data: list[str] = data
+        self.use_any = any_book
+        self.use_exact = exact
+        log.info(f"Working on {len(self.data)} entries")
+        self.tstate = (self.app_nr, self.prof_id, self.mode, self.data)
+        log.debug("State: " + str(self.tstate))
+        app_nr = self.db.query_db(
+            "SELECT appnr FROM semesterapparat WHERE id = ?", (self.app_id,)
+        )[0][0]
+        self.request.set_apparat(app_nr)
+        # log.debug(self.tstate)
+
+    def run(self):
+        item = 0
+        iterdata = self.data
+        # log.debug(iterdata)
+
+        for entry in iterdata:
+            # log.debug(entry)
+            log.info("Processing entry: {}", entry)
+
+            webdata = self.request.get_ppn(entry)
+            if self.use_any:
+                webdata = webdata.use_any_book
+            webdata = webdata.get_data()
+
+            if webdata == "error":
+                continue
+
+            bd = BibTextTransformer(self.mode)
+            bloat.debug("Web response (preview): {}", preview(webdata, 2000))
+            if self.mode == "ARRAY":
+                if self.use_exact:
+                    bd = bd.use_signature(entry)
+            bd = bd.get_data(webdata).return_data()
+            bloat.debug("Transformed bookdata (preview): {}", preview(bd, 1000))
+            if bd is None:
+                # bd = BookData
+                continue
+            bd.signature = entry
+            transformer = (
+                BibTextTransformer("RDS").get_data(webdata).return_data("rds_data")
+            )
+
+            # confirm lock is acquired
+            self.db.addBookToDatabase(bd, self.app_id, self.prof_id)
+            # get latest book id
+            self.book_id = self.db.getLastBookId()
+            log.info("Added book to database")
+            state = 0
+            for result in transformer.RDS_DATA:
+                # log.debug(result.RDS_LOCATION)
+                if str(self.app_nr) in result.RDS_LOCATION:
+                    state = 1
+                    break
+
+            log.info(f"State of {entry}: {state}")
+            log.debug(
+                "updating availability of " + str(self.book_id) + " to " + str(state)
+            )
+            try:
+                self.db.setAvailability(self.book_id, state)
+                log.debug("Added book to database")
+            except Exception as e:
+                log.error(f"Failed to update availability: {e}")
+                log.debug("Failed to update availability: " + str(e))
+
+            # time.sleep(5)
+            item += 1
+            self.updateSignal.emit(item, len(self.data))
+        log.info("Worker thread finished")
+        # self.done.emit()
+        self.quit()
+
+    def stop(self):
+        self.is_Running = False
+
+
+class BookGrabberTest(QThread):
+    updateSignal = Signal(int, int)
+    done = Signal()
+
+    def __init__(self, appnr: int):
+        super(BookGrabberTest, self).__init__(parent=None)
+        self.is_Running = True
+        log.info("Starting worker thread")
+        self.data = None
+        self.app_nr = None
+        self.prof_id = None
+        self.mode = None
+        self.book_id = None
+        self.use_any = False
+        self.use_exact = False
+        self.app_nr = appnr
+        self.tstate = (self.app_nr, self.prof_id, self.mode, self.data)
+        self.results = []
+
+    def add_values(
+        self, app_nr: int, prof_id: int, mode: str, data, any_book=False, exact=False
+    ):
+        self.app_nr = app_nr
+        self.prof_id = prof_id
+        self.mode = mode
+        self.data = data
+        self.use_any = any_book
+        self.use_exact = exact
+        log.info(f"Working on {len(self.data)} entries")
+        self.tstate = (self.app_nr, self.prof_id, self.mode, self.data)
+        log.debug("State: " + str(self.tstate))
+        # log.debug(self.tstate)
+
+    def run(self):
+        item = 0
+        iterdata = self.data
+        # log.debug(iterdata)
+        for entry in iterdata:
+            # log.debug(entry)
+            signature = str(entry)
+            log.info("Processing entry: " + signature)
+
+            webdata = WebRequest().set_apparat(self.app_nr).get_ppn(entry)
+            if self.use_any:
+                webdata = webdata.use_any_book
+            webdata = webdata.get_data()
+
+            if webdata == "error":
+                continue
+
+            bd = BibTextTransformer(self.mode)
+            if self.mode == "ARRAY":
+                if self.use_exact:
+                    bd = bd.use_signature(entry)
+            bd = bd.get_data(webdata).return_data()
+            if bd is None:
+                # bd = BookData
+                continue
+            bd.signature = entry
+            transformer = (
+                BibTextTransformer("RDS").get_data(webdata).return_data("rds_data")
+            )
+
+            # confirm lock is acquired
+            # get latest book id
+            log.info("Added book to database")
+            state = 0
+            for result in transformer.RDS_DATA:
+                # log.debug(result.RDS_LOCATION)
+                if str(self.app_nr) in result.RDS_LOCATION:
+                    state = 1
+                    break
+
+            log.info(f"State of {signature}: {state}")
+            # log.debug("updating availability of " + str(self.book_id) + " to " + str(state))
+            self.results.append(bd)
+
+            # time.sleep(5)
+            item += 1
+            self.updateSignal.emit(item, len(self.data))
+        log.info("Worker thread finished")
+        # self.done.emit()
+        self.quit()
+
+    def stop(self):
+        self.is_Running = False

src/background/documentation_server.py

@@ -0,0 +1,28 @@
+from PySide6.QtCore import QThread, Slot
+
+from src.utils.documentation import start_documentation_server
+
+
+class DocumentationThread(QThread):
+    def __init__(self):
+        super().__init__()
+        self._process = None  # store subprocess so we can shut it down
+
+    def run(self):
+        # Start the zensical documentation server
+        self._process = start_documentation_server()
+
+        # Keep thread alive until interruption is requested
+        if self._process:
+            while not self.isInterruptionRequested():
+                self.msleep(100)  # Check every 100ms
+
+    @Slot()  # slot you can connect to aboutToQuit
+    def stop(self):
+        self.requestInterruption()  # ask the loop above to exit
+        if self._process:
+            self._process.terminate()  # terminate the subprocess
+            try:
+                self._process.wait(timeout=5)  # wait up to 5 seconds
+            except Exception:
+                self._process.kill()  # force kill if it doesn't stop

src/background/new_editions.py

@@ -0,0 +1,345 @@
+import os
+import re
+from concurrent.futures import ThreadPoolExecutor
+from math import ceil
+from queue import Empty, Queue
+from time import monotonic  # <-- NEW
+from typing import List, Optional
+
+from PySide6.QtCore import QThread, Signal
+
+# from src.services.webrequest import BibTextTransformer, WebRequest
+from src.services.catalogue import Catalogue
+from src.core.models import BookData
+from src.services.sru import SWB
+from src.shared.logging import log
+
+# use all available cores - 2, but at least 1
+THREAD_COUNT = max(os.cpu_count() - 2, 1)
+THREAD_MIN_ITEMS = 5
+
+# Logger configured centrally in main; use shared `log`
+
+swb = SWB()
+dnb = SWB()
+cat = Catalogue()
+
+RVK_ALLOWED = r"[A-Z0-9.\-\/]"  # conservative RVK character set
+
+
+def find_newer_edition(
+    swb_result: BookData, dnb_result: List[BookData]
+) -> Optional[List[BookData]]:
+    """
+    New edition if:
+      - year > swb.year OR
+      - edition_number > swb.edition_number
+    BUT: discard any candidate with year < swb.year (if both years are known).
+
+    Same-work check:
+      - Compare RVK roots of signatures (after stripping trailing '+N' and '(N)').
+      - If both have signatures and RVKs differ -> skip.
+
+    Preferences (in order):
+      1) RVK matches SWB
+      2) Print over Online-Ressource
+      3) Has signature
+      4) Newer: (year desc, edition_number desc)
+    """
+
+    def strip_copy_and_edition(s: str) -> str:
+        s = re.sub(r"\(\s*\d+\s*\)", "", s)  # remove '(N)'
+        s = re.sub(r"\s*\+\s*\d+\s*$", "", s)  # remove trailing '+N'
+        return s
+
+    def extract_rvk_root(sig: Optional[str]) -> str:
+        if not sig:
+            return ""
+        t = strip_copy_and_edition(sig.upper())
+        t = re.sub(r"\s+", " ", t).strip()
+        m = re.match(rf"^([A-Z]{{1,3}}\s*{RVK_ALLOWED}*)", t)
+        if not m:
+            cleaned = re.sub(rf"[^{RVK_ALLOWED} ]+", "", t).strip()
+            return cleaned.split(" ")[0] if cleaned else ""
+        return re.sub(r"\s+", " ", m.group(1)).strip()
+
+    def has_sig(b: BookData) -> bool:
+        return bool(getattr(b, "signature", None))
+
+    def is_online(b: BookData) -> bool:
+        return (getattr(b, "media_type", None) or "").strip() == "Online-Ressource"
+
+    def is_print(b: BookData) -> bool:
+        return not is_online(b)
+
+    def rvk_matches_swb(b: BookData) -> bool:
+        if not has_sig(b) or not has_sig(swb_result):
+            return False
+        return extract_rvk_root(b.signature) == extract_rvk_root(swb_result.signature)
+
+    def strictly_newer(b: BookData) -> bool:
+        # Hard guard: if both years are known and candidate is older, discard
+        if (
+            b.year is not None
+            and swb_result.year is not None
+            and b.year < swb_result.year
+        ):
+            return False
+
+        newer_by_year = (
+            b.year is not None
+            and swb_result.year is not None
+            and b.year > swb_result.year
+        )
+        newer_by_edition = (
+            b.edition_number is not None
+            and swb_result.edition_number is not None
+            and b.edition_number > swb_result.edition_number
+        )
+        # Thanks to the guard above, newer_by_edition can't pick something with a smaller year.
+        return newer_by_year or newer_by_edition
+
+    swb_has_sig = has_sig(swb_result)
+    swb_rvk = extract_rvk_root(getattr(swb_result, "signature", None))
+
+    # 1) Filter: same work (by RVK if both have sigs) AND strictly newer
+    candidates: List[BookData] = []
+    for b in dnb_result:
+        if has_sig(b) and swb_has_sig:
+            if extract_rvk_root(b.signature) != swb_rvk:
+                continue  # different work
+        if strictly_newer(b):
+            candidates.append(b)
+
+    if not candidates:
+        return None
+
+    # 2) Dedupe by PPN → prefer (rvk-match, is-print, has-signature)
+    def pref_score(x: BookData) -> tuple[int, int, int]:
+        return (
+            1 if rvk_matches_swb(x) else 0,
+            1 if is_print(x) else 0,
+            1 if has_sig(x) else 0,
+        )
+
+    by_ppn: dict[Optional[str], BookData] = {}
+    for b in candidates:
+        key = getattr(b, "ppn", None)
+        prev = by_ppn.get(key)
+        if prev is None or pref_score(b) > pref_score(prev):
+            by_ppn[key] = b
+
+    deduped = list(by_ppn.values())
+    if not deduped:
+        return None
+
+    # 3) Preserve all qualifying newer editions, but order by preference
+    def sort_key(b: BookData):
+        year = b.year if b.year is not None else -1
+        ed = b.edition_number if b.edition_number is not None else -1
+        return (
+            1 if rvk_matches_swb(b) else 0,
+            1 if is_print(b) else 0,
+            1 if has_sig(b) else 0,
+            year,
+            ed,
+        )
+
+    deduped.sort(key=sort_key, reverse=True)
+    return deduped
+
+
+class NewEditionCheckerThread(QThread):
+    updateSignal = Signal(int, int)  # (processed, total)
+    updateProgress = Signal(int, int)  # (processed, total)
+    total_entries_signal = Signal(int)
+    resultsSignal = Signal(list)  # list[tuple[BookData, list[BookData]]]
+
+    # NEW: metrics signals
+    rateSignal = Signal(float)  # items per second ("it/s")
+    etaSignal = Signal(int)  # seconds remaining (-1 when unknown)
+
+    def __init__(self, entries: Optional[list["BookData"]] = None, parent=None):
+        super().__init__(parent)
+        self.entries: list["BookData"] = entries if entries is not None else []
+        self.results: list[tuple["BookData", list["BookData"]]] = []
+
+    def reset(self):
+        self.entries = []
+        self.results = []
+
+    # ---------- internal helpers ----------
+
+    @staticmethod
+    def _split_evenly(items: list, parts: int) -> list[list]:
+        """Split items as evenly as possible into `parts` chunks (no empty tails)."""
+        if parts <= 1 or len(items) <= 1:
+            return [items]
+        n = len(items)
+        base = n // parts
+        extra = n % parts
+        chunks = []
+        i = 0
+        for k in range(parts):
+            size = base + (1 if k < extra else 0)
+            if size == 0:
+                continue
+            chunks.append(items[i : i + size])
+            i += size
+        return chunks
+
+    @staticmethod
+    def _clean_title(raw: str) -> str:
+        title = raw.rstrip(" .:,;!?")
+        title = re.sub(r"\s*\(.*\)", "", title)
+        return title.strip()
+
+    @classmethod
+    def _process_book(
+        cls, book: "BookData"
+    ) -> tuple["BookData", list["BookData"]] | None:
+        """Process one book; returns (original, [found editions]) or None on failure."""
+        if not book.title:
+            return None
+        response: list["BookData"] = []
+        query = [
+            f"pica.tit={book.title}",
+            f"pica.vlg={book.publisher}",
+        ]
+
+        swb_result = swb.getBooks(["pica.bib=20735", f"pica.ppn={book.ppn}"])[0]
+        dnb_results = swb.getBooks(query)
+        new_editions = find_newer_edition(swb_result, dnb_results)
+
+        if new_editions is not None:
+            for new_edition in new_editions:
+                new_edition.library_location = cat.get_location(new_edition.ppn)
+                try:
+                    isbn = (
+                        str(new_edition.isbn[0])
+                        if isinstance(new_edition.isbn, list)
+                        else str(new_edition.isbn)
+                    )
+                    new_edition.link = (
+                        f"https://www.lehmanns.de/search/quick?mediatype_id=2&q={isbn}"
+                    )
+                except (IndexError, TypeError):
+                    isbn = None
+                new_edition.in_library = cat.in_library(new_edition.ppn)
+            response = new_editions
+
+        # client = SWB()
+        # response: list["BookData"] = []
+        # # First, search by title only
+        # results = client.getBooks([f"pica.title={title}", f"pica.vlg={book.publisher}"])
+
+        # lehmanns = LehmannsClient()
+        # results = lehmanns.search_by_title(title)
+        # for result in results:
+        #     if "(eBook)" in result.title:
+        #         result.title = result.title.replace("(eBook)", "").strip()
+        #     swb_results = client.getBooks(
+        #         [
+        #             f"pica.tit={result.title}",
+        #             f"pica.vlg={result.publisher.split(',')[0]}",
+        #         ]
+        #     )
+        #     for swb in swb_results:
+        #         if swb.isbn == result.isbn:
+        #             result.ppn = swb.ppn
+        #             result.signature = swb.signature
+        #             response.append(result)
+        #         if (result.edition_number < swb.edition_number) and (
+        #             swb.year > result.year
+        #         ):
+        #             response.append(result)
+        if response == []:
+            return None
+        # Remove duplicates based on ppn
+        return (book, response)
+
+    @classmethod
+    def _worker(cls, items: list["BookData"], q: Queue) -> None:
+        """Worker for one chunk; pushes ('result', ...), ('progress', 1), and ('done', None)."""
+        try:
+            for book in items:
+                try:
+                    result = cls._process_book(book)
+                except Exception:
+                    result = None
+                if result is not None:
+                    q.put(("result", result))
+                q.put(("progress", 1))
+        finally:
+            q.put(("done", None))
+
+    # ---------- thread entry point ----------
+
+    def run(self):
+        total = len(self.entries)
+        self.total_entries_signal.emit(total)
+
+        # start timer for metrics
+        t0 = monotonic()
+
+        if total == 0:
+            log.debug("No entries to process.")
+            # emit metrics (zero work)
+            self.rateSignal.emit(0.0)
+            self.etaSignal.emit(0)
+            self.resultsSignal.emit([])
+            return
+
+        # Up to 4 workers; ~20 items per worker
+        num_workers = min(THREAD_COUNT, max(1, ceil(total / THREAD_MIN_ITEMS)))
+        chunks = self._split_evenly(self.entries, num_workers)
+        sizes = [len(ch) for ch in chunks]
+
+        q: Queue = Queue()
+        processed = 0
+        finished_workers = 0
+
+        with ThreadPoolExecutor(max_workers=len(chunks)) as ex:
+            futures = [ex.submit(self._worker, ch, q) for ch in chunks]
+
+            log.info(
+                f"Launched {len(futures)} worker thread(s) for {total} entries: {sizes} entries per thread."
+            )
+            for idx, sz in enumerate(sizes, 1):
+                log.debug(f"Thread {idx}: {sz} entries")
+
+            # Aggregate progress/results
+            while finished_workers < len(chunks):
+                try:
+                    kind, payload = q.get(timeout=0.1)
+                except Empty:
+                    continue
+
+                if kind == "progress":
+                    processed += int(payload)
+                    self.updateSignal.emit(processed, total)
+                    self.updateProgress.emit(processed, total)
+
+                    # ---- NEW: compute & emit metrics ----
+                    elapsed = max(1e-9, monotonic() - t0)
+                    rate = processed / elapsed  # items per second
+                    remaining = max(0, total - processed)
+                    eta_sec = int(round(remaining / rate)) if rate > 0 else -1
+
+                    self.rateSignal.emit(rate)
+                    # clamp negative just in case
+                    self.etaSignal.emit(max(0, eta_sec) if eta_sec >= 0 else -1)
+                    # -------------------------------------
+
+                elif kind == "result":
+                    self.results.append(payload)
+                elif kind == "done":
+                    finished_workers += 1
+
+        # Final metrics on completion
+        elapsed_total = max(1e-9, monotonic() - t0)
+        final_rate = total / elapsed_total
+        self.rateSignal.emit(final_rate)
+        self.etaSignal.emit(0)
+
+        self.resultsSignal.emit(self.results)

src/core/__init__.py

@@ -0,0 +1,30 @@
+"""Core domain models and business constants."""
+
+from .models import (
+    Apparat,
+    ApparatData,
+    Book,
+    BookData,
+    ELSA,
+    MailData,
+    Prof,
+    SemapDocument,
+    Subjects,
+    XMLMailSubmission,
+)
+from .constants import *  # noqa: F403
+from .semester import Semester
+
+__all__ = [
+    "Apparat",
+    "ApparatData",
+    "Book",
+    "BookData",
+    "ELSA",
+    "MailData",
+    "Prof",
+    "SemapDocument",
+    "Subjects",
+    "XMLMailSubmission",
+    "Semester",
+]

src/core/constants.py

@@ -0,0 +1,213 @@
+APP_NRS = [i for i in range(1, 181)]
+
+PROF_TITLES = [
+    "Dr. mult.",
+    "Dr. paed.",
+    "Dr. rer. pol.",
+    "Dr. sc. techn.",
+    "Drs.",
+    "Dr. agr.",
+    "Dr. habil.",
+    "Dr. oec.",
+    "Dr. med.",
+    "Dr. e. h.",
+    "Dr. oec. publ.",
+    "Dr. -Ing.",
+    "Dr. theol.",
+    "Dr. med. vet.",
+    "Dr. ing.",
+    "Dr. rer. nat.",
+    "Dr. des.",
+    "Dr. sc. mus.",
+    "Dr. h. c.",
+    "Dr. pharm.",
+    "Dr. med. dent.",
+    "Dr. phil. nat.",
+    "Dr. phil.",
+    "Dr. iur.",
+    "Dr.",
+    "Kein Titel",
+]
+
+SEMAP_MEDIA_ACCOUNTS = {
+    1: "1008000055",
+    2: "1008000188",
+    3: "1008000211",
+    4: "1008000344",
+    5: "1008000477",
+    6: "1008000500",
+    7: "1008000633",
+    8: "1008000766",
+    9: "1008000899",
+    10: "1008000922",
+    11: "1008001044",
+    12: "1008001177",
+    13: "1008001200",
+    14: "1008001333",
+    15: "1008001466",
+    16: "1008001599",
+    17: "1008001622",
+    18: "1008001755",
+    19: "1008001888",
+    20: "1008001911",
+    21: "1008002033",
+    22: "1008002166",
+    23: "1008002299",
+    24: "1008002322",
+    25: "1008002455",
+    26: "1008002588",
+    27: "1008002611",
+    28: "1008002744",
+    29: "1008002877",
+    30: "1008002900",
+    31: "1008003022",
+    32: "1008003155",
+    33: "1008003288",
+    34: "1008003311",
+    35: "1008003444",
+    36: "1008003577",
+    37: "1008003600",
+    38: "1008003733",
+    39: "1008003866",
+    40: "1008003999",
+    41: "1008004011",
+    42: "1008004144",
+    43: "1008004277",
+    44: "1008004300",
+    45: "1008004433",
+    46: "1008004566",
+    47: "1008004699",
+    48: "1008004722",
+    49: "1008004855",
+    50: "1008004988",
+    51: "1008005000",
+    52: "1008005133",
+    53: "1008005266",
+    54: "1008005399",
+    55: "1008005422",
+    56: "1008005555",
+    57: "1008005688",
+    58: "1008005711",
+    59: "1008005844",
+    60: "1008005977",
+    61: "1008006099",
+    62: "1008006122",
+    63: "1008006255",
+    64: "1008006388",
+    65: "1008006411",
+    66: "1008006544",
+    67: "1008006677",
+    68: "1008006700",
+    69: "1008006833",
+    70: "1008006966",
+    71: "1008007088",
+    72: "1008007111",
+    73: "1008007244",
+    74: "1008007377",
+    75: "1008007400",
+    76: "1008007533",
+    77: "1008007666",
+    78: "1008007799",
+    79: "1008007822",
+    80: "1008007955",
+    81: "1008008077",
+    82: "1008008100",
+    83: "1008008233",
+    84: "1008008366",
+    85: "1008008499",
+    86: "1008008522",
+    87: "1008008655",
+    88: "1008008788",
+    89: "1008008811",
+    90: "1008008944",
+    91: "1008009066",
+    92: "1008009199",
+    93: "1008009222",
+    94: "1008009355",
+    95: "1008009488",
+    96: "1008009511",
+    97: "1008009644",
+    98: "1008009777",
+    99: "1008009800",
+    100: "1008009933",
+    101: "1008010022",
+    102: "1008010155",
+    103: "1008010288",
+    104: "1008010311",
+    105: "1008010444",
+    106: "1008010577",
+    107: "1008010600",
+    108: "1008010733",
+    109: "1008010866",
+    110: "1008010999",
+    111: "1008011011",
+    112: "1008011144",
+    113: "1008011277",
+    114: "1008011300",
+    115: "1008011433",
+    116: "1008011566",
+    117: "1008011699",
+    118: "1008011722",
+    119: "1008011855",
+    120: "1008011988",
+    121: "1008012000",
+    122: "1008012133",
+    123: "1008012266",
+    124: "1008012399",
+    125: "1008012422",
+    126: "1008012555",
+    127: "1008012688",
+    128: "1008012711",
+    129: "1008012844",
+    130: "1008012977",
+    131: "1008013099",
+    132: "1008013122",
+    133: "1008013255",
+    134: "1008013388",
+    135: "1008013411",
+    136: "1008013544",
+    137: "1008013677",
+    138: "1008013700",
+    139: "1008013833",
+    140: "1008013966",
+    141: "1008014088",
+    142: "1008014111",
+    143: "1008014244",
+    144: "1008014377",
+    145: "1008014400",
+    146: "1008014533",
+    147: "1008014666",
+    148: "1008014799",
+    149: "1008014822",
+    150: "1008014955",
+    151: "1008015077",
+    152: "1008015100",
+    153: "1008015233",
+    154: "1008015366",
+    155: "1008015499",
+    156: "1008015522",
+    157: "1008015655",
+    158: "1008015788",
+    159: "1008015811",
+    160: "1008015944",
+    161: "1008016066",
+    162: "1008016199",
+    163: "1008016222",
+    164: "1008016355",
+    165: "1008016488",
+    166: "1008016511",
+    167: "1008016644",
+    168: "1008016777",
+    169: "1008016800",
+    170: "1008016933",
+    171: "1008017055",
+    172: "1008017188",
+    173: "1008017211",
+    174: "1008017344",
+    175: "1008017477",
+    176: "1008017500",
+    177: "1008017633",
+    178: "1008017766",
+    179: "1008017899",
+    180: "1008017922",
+}

src/core/models.py

@@ -0,0 +1,485 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Optional, Union
+
+import regex
+
+from src.core.semester import Semester
+
+
+@dataclass
+class Prof:
+    id: int | None = None
+    _title: str | None = None
+    firstname: str | None = None
+    lastname: str | None = None
+    fullname: str | None = None
+    mail: str | None = None
+    telnr: str | None = None
+
+    # add function that sets the data based on a dict
+    def from_dict(self, data: dict[str, Union[str, int]]) -> 'Prof':
+        for key, value in data.items():
+            if hasattr(self, key):
+                setattr(self, key, value)
+        return self
+
+    @property
+    def title(self) -> str:
+        if self._title is None or self._title == "None":
+            return ""
+        return self._title
+
+    @title.setter
+    def title(self, value: str):
+        self._title = value
+
+    # add function that sets the data from a tuple
+    def from_tuple(self, data: tuple[Union[int, str, None], ...]) -> 'Prof':
+        self.id = data[0] if data[0] is not None and isinstance(data[0], int) else None
+        self._title = str(data[1]) if data[1] is not None else None
+        self.firstname = str(data[2]) if data[2] is not None else None
+        self.lastname = str(data[3]) if data[3] is not None else None
+        self.fullname = str(data[4]) if data[4] is not None else None
+        self.mail = str(data[5]) if data[5] is not None else None
+        self.telnr = str(data[6]) if data[6] is not None else None
+        return self
+
+    def name(self, comma: bool = False) -> Optional[str]:
+        if self.firstname is None and self.lastname is None:
+            if self.fullname and "," in self.fullname:
+                parts = self.fullname.split(",")
+                if len(parts) >= 2:
+                    self.firstname = parts[1].strip()
+                    self.lastname = parts[0].strip()
+            else:
+                return self.fullname
+
+        if comma:
+            if self.lastname and self.firstname:
+                return f"{self.lastname}, {self.firstname}"
+            elif self.lastname:
+                return self.lastname
+            elif self.firstname:
+                return f", {self.firstname}"
+        elif self.lastname and self.firstname:
+            return f"{self.lastname} {self.firstname}"
+        elif self.lastname:
+            return self.lastname
+        elif self.firstname:
+            return self.firstname
+        return self.fullname
+
+
+@dataclass
+class BookData:
+    ppn: str | None = None
+    title: str | None = None
+    signature: str | None = None
+    edition: str | None = None
+    link: str | None = None
+    isbn: Union[str, list[str], None] = field(default_factory=list)
+    author: str | None = None
+    language: Union[str, list[str], None] = field(default_factory=list)
+    publisher: str | None = None
+    place: str | None = None
+    year: int | None = None
+    pages: str | None = None
+    library_location: str | None = None
+    in_apparat: bool | None = False
+    adis_idn: str | None = None
+    old_book: Any | None = None
+    media_type: str | None = None
+    in_library: bool | None = None  # whether the book is in the library or not
+    medianr: int | None = None  # Media number in the library system
+
+    def __post_init__(self):
+        self.library_location = (
+            str(self.library_location) if self.library_location else None
+        )
+        if isinstance(self.language, list) and self.language:
+            self.language = [lang.strip() for lang in self.language if lang.strip()]
+            self.language = ",".join(self.language)
+        if self.year is not None:
+            year_str = regex.sub(r"[^\d]", "", str(self.year))
+            self.year = int(year_str) if year_str else None
+        self.in_library = True if self.signature else False
+
+    def from_dict(self, data: dict[str, Any]) -> 'BookData':
+        for key, value in data.items():
+            setattr(self, key, value)
+        return self
+
+    def merge(self, other: BookData) -> BookData:
+        for key, value in other.__dict__.items():
+            # merge lists, if the attribute is a list, extend it
+            if isinstance(value, list):
+                current_value = getattr(self, key)
+                if current_value is None:
+                    current_value = []
+                elif not isinstance(current_value, list):
+                    current_value = [current_value]
+                # extend the list with the new values, but only if they are not already in the list
+                for v in value:
+                    if v not in current_value:
+                        current_value.append(v)
+                setattr(self, key, current_value)
+            if value is not None and (
+                getattr(self, key) is None or getattr(self, key) == ""
+            ):
+                setattr(self, key, value)
+        # in language, drop all entries that are longer than 3 characters
+        if isinstance(self.language, list):
+            self.language = [lang for lang in self.language if len(lang) <= 4]
+        return self
+
+    @property
+    def to_dict(self) -> str:
+        """Convert the dataclass to a dictionary."""
+        data_dict = {
+            key: value for key, value in self.__dict__.items() if value is not None
+        }
+        # remove old_book from data_dict
+        if "old_book" in data_dict:
+            del data_dict["old_book"]
+        return json.dumps(data_dict, ensure_ascii=False)
+
+    def from_dataclass(self, data_obj: Optional[Any]) -> None:
+        if data_obj is None:
+            return
+        for key, value in data_obj.__dict__.items():
+            setattr(self, key, value)
+
+    def get_book_type(self) -> str:
+        if self.pages and "Online" in self.pages:
+            return "eBook"
+        return "Druckausgabe"
+
+    def from_string(self, data: str) -> 'BookData':
+        ndata = json.loads(data)
+        # Create a new BookData instance and set its attributes
+        book_data = BookData()
+        for key, value in ndata.items():
+            setattr(book_data, key, value)
+        return book_data
+
+    def from_LehmannsSearchResult(self, result: Any) -> 'BookData':
+        self.title = result.title
+        self.author = "; ".join(result.authors) if result.authors else None
+        self.edition = str(result.edition) if result.edition else None
+        self.link = result.url
+        self.isbn = (
+            result.isbn13
+            if isinstance(result.isbn13, list)
+            else [result.isbn13]
+            if result.isbn13
+            else []
+        )
+        self.pages = str(result.pages) if result.pages else None
+        self.publisher = result.publisher
+        self.year = str(result.year) if result.year else None
+        # self.pages = str(result.pages) if result.pages else None
+        return self
+
+    @property
+    def edition_number(self) -> Optional[int]:
+        if self.edition is None:
+            return 0
+        match = regex.search(r"(\d+)", self.edition or "")
+        if match:
+            return int(match.group(1))
+        return 0
+
+
+@dataclass
+class MailData:
+    subject: str | None
+    body: str | None
+    mailto: str | None
+    prof: str | None
+
+
+class Subjects(Enum):
+    BIOLOGY = (1, "Biologie")
+    CHEMISTRY = (2, "Chemie")
+    GERMAN = (3, "Deutsch")
+    ENGLISH = (4, "Englisch")
+    PEDAGOGY = (5, "Erziehungswissenschaft")
+    FRENCH = (6, "Französisch")
+    GEOGRAPHY = (7, "Geographie")
+    HISTORY = (8, "Geschichte")
+    HEALTH_EDUCATION = (9, "Gesundheitspädagogik")
+    HTW = (10, "Haushalt / Textil")
+    ART = (11, "Kunst")
+    MATH_IT = (12, "Mathematik / Informatik")
+    MEDIAPEDAGOGY = (13, "Medien in der Bildung")
+    MUSIC = (14, "Musik")
+    PHILOSOPHY = (15, "Philosophie")
+    PHYSICS = (16, "Physik")
+    POLITICS = (17, "Politikwissenschaft")
+    PRORECTORATE = (18, "Prorektorat Lehre und Studium")
+    PSYCHOLOGY = (19, "Psychologie")
+    SOCIOLOGY = (20, "Soziologie")
+    SPORT = (21, "Sport")
+    TECHNIC = (22, "Technik")
+    THEOLOGY = (23, "Theologie")
+    ECONOMICS = (24, "Wirtschaftslehre")
+
+    @property
+    def id(self) -> int:
+        return self.value[0]
+
+    @property
+    def subject_name(self) -> str:
+        return self.value[1]
+
+    @classmethod
+    def get_index(cls, name: str) -> Optional[int]:
+        for i in cls:
+            if i.subject_name == name:
+                return i.id - 1
+        return None
+
+
+@dataclass
+class Apparat:
+    id: int | None = None
+    name: str | None = None
+    prof_id: int | None = None
+    subject: str | None = None
+    appnr: int | None = None
+    created_semester: str | None = None
+    extended_at: str | None = None
+    eternal: bool = False
+    extend_until: str | None = None
+    deleted: int | None = None
+    deleted_date: str | None = None
+    apparat_id_adis: str | None = None
+    prof_id_adis: str | None = None
+    konto: int | None = None
+
+    def from_tuple(self, data: tuple[Any, ...]) -> Apparat:
+        self.id = data[0]
+        self.name = data[1]
+        self.prof_id = data[2]
+        self.subject = data[3]
+        self.appnr = data[4]
+        self.created_semester = data[5]
+        self.extended_at = data[6]
+        self.eternal = data[7]
+        self.extend_until = data[8]
+        self.deleted = data[9]
+        self.deleted_date = data[10]
+        self.apparat_id_adis = data[11]
+        self.prof_id_adis = data[12]
+        self.konto = data[13]
+        return self
+
+    @property
+    def get_semester(self) -> Optional[str]:
+        if self.extend_until is not None:
+            return self.extend_until
+        return self.created_semester
+
+
+@dataclass
+class ELSA:
+    id: int | None = None
+    date: str | None = None
+    semester: str | None = None
+    prof_id: int | None = None
+
+    def from_tuple(self, data: tuple[Any, ...]) -> ELSA:
+        self.id = data[0]
+        self.date = data[1]
+        self.semester = data[2]
+        self.prof_id = data[3]
+        return self
+
+
+@dataclass
+class ApparatData:
+    prof: Prof = field(default_factory=Prof)
+    apparat: Apparat = field(default_factory=Apparat)
+
+
+@dataclass
+class XMLMailSubmission:
+    name: str | None
+    lastname: str | None
+    title: str | None
+    telno: int | None
+    email: str | None
+    app_name: str | None
+    subject: str | None
+    semester: Semester | None
+    books: list[BookData] | None
+
+
+@dataclass
+class Book:
+    author: str | None
+    year: str | None
+    edition: str | None
+    title: str | None
+    location: str | None
+    publisher: str | None
+    signature: str | None
+    internal_notes: str | None
+
+    @property
+    def has_signature(self) -> bool:
+        return self.signature is not None and self.signature != ""
+
+    @property
+    def is_empty(self) -> bool:
+        return all(
+            [
+                self.author == "",
+                self.year == "",
+                self.edition == "",
+                self.title == "",
+                self.location == "",
+                self.publisher == "",
+                self.signature == "",
+                self.internal_notes == "",
+            ],
+        )
+
+    def from_dict(self, data: dict[str, Any]):
+        for key, value in data.items():
+            value = value.strip()
+            if value == "\u2002\u2002\u2002\u2002\u2002":
+                value = ""
+
+            if key == "Autorenname(n):Nachname, Vorname":
+                self.author = value
+            elif key == "Jahr/Auflage":
+                self.year = value.split("/")[0] if "/" in value else value
+                self.edition = value.split("/")[1] if "/" in value else ""
+            elif key == "Titel":
+                self.title = value
+            elif key == "Ort und Verlag":
+                self.location = value.split(",")[0] if "," in value else value
+                self.publisher = value.split(",")[1] if "," in value else ""
+            elif key == "Standnummer":
+                self.signature = value.strip()
+            elif key == "Interne Vermerke":
+                self.internal_notes = value
+
+
+@dataclass
+class SemapDocument:
+    subject: str | None = None
+    phoneNumber: int | None = None
+    mail: str | None = None
+    title: str | None = None
+    personName: str | None = None
+    personTitle: str | None = None
+    title_suggestions: list[str] = field(default_factory=list)
+    semester: Union[str, 'Semester', None] = None
+    books: list[Book] = field(default_factory=list)
+    eternal: bool = False
+    title_length: int = 0
+    title_max_length: int = 0
+
+    def __post_init__(self) -> None:
+        """."""
+        if self.phoneNumber is not None:
+            phone_str = regex.sub(r"[^\d]", "", str(self.phoneNumber))
+            self.phoneNumber = int(phone_str) if phone_str else None
+
+    @property
+    def nameSetter(self):
+        from src.services.openai import name_tester, run_shortener
+
+        data = name_tester(self.personTitle)
+        name = f"{data['last_name']}, {data['first_name']}"
+        if data["title"] is not None:
+            title = data["title"]
+            self.personTitle = title
+        self.personName = name
+        self.title_length = len(self.title) + 3 + len(self.personName.split(",")[0])
+        if self.title_length > 40:
+            name_len = len(self.personName.split(",")[0])
+            self.title_max_length = 38 - name_len
+            suggestions = run_shortener(self.title, self.title_max_length)
+            for suggestion in suggestions:
+                self.title_suggestions.append(suggestion["shortened_string"])
+        else:
+            self.title_suggestions = []
+
+    @property
+    def renameSemester(self) -> None:
+        from src.services.openai import semester_converter
+
+        if self.semester and isinstance(self.semester, str):
+            if ", Dauer" in self.semester:
+                self.semester = self.semester.split(",")[0]
+                self.eternal = True
+                self.semester = Semester().from_string(self.semester)
+            else:
+                self.semester = Semester().from_string(
+                    semester_converter(self.semester),
+                )
+
+    @property
+    def signatures(self) -> list[str]:
+        if self.books is not None:
+            return [book.signature for book in self.books if book.has_signature]
+        return []
+
+
+@dataclass
+class ELSA_Mono:
+    authorName: str
+    year: int
+    signature: str
+    page_from: int
+    page_to: int
+    edition: str | None = None
+
+
+@dataclass
+class ELSA_Journal:
+    authorName: str
+    year: int
+    issue: str
+    page_from: int
+    page_to: int
+    journal_title: str
+    article_title: str
+    signature: str
+
+
+@dataclass
+class Person:
+    firstName: str
+    lastName: str
+    personTitle: str | None = None
+
+    @property
+    def fullName_LNFN(self) -> str:
+        return f"{self.lastName}, {self.firstName}"
+
+
+@dataclass
+class ELSA_Editorial:
+    # TODO: add dataclass fields
+    pass
+
+
+@dataclass
+class ELSADocument:
+    mail: str = None
+    personTitle: str = None
+    personName: Optional[str] = None
+
+    def __post_init__(self) -> None:
+        """."""
+        self.mail = self.mail.strip() if self.mail else None
+        self.personTitle = self.personTitle.strip() if self.personTitle else None
+        self.personName = self.personName.strip() if self.personName else None

src/core/semester.py

@@ -0,0 +1,273 @@
+"""Semester helper class.
+
+A small utility around the *German* academic calendar that distinguishes
+between *Wintersemester* (WiSe) and *Sommersemester* (SoSe).
+
+Key points
+----------
+* A **`Semester`** is identified by a *term* ("SoSe" or "WiSe") and the last two
+  digits of the calendar year in which the term *starts*.
+* Formatting **never** pads the year with a leading zero - so ``6`` stays ``6``.
+* ``offset(n)`` and the static ``generate_missing`` reliably walk the timeline
+  one semester at a time with correct year transitions:
+
+  SoSe 6 → **WiSe 6/7** → SoSe 7 → WiSe 7/8 → …
+"""
+
+from __future__ import annotations
+
+import datetime
+import re
+
+from src.shared.logging import log
+
+
+class Semester:
+    """Represents a German university semester (WiSe or SoSe)."""
+
+    # ------------------------------------------------------------------
+    # Class-level defaults - will be *copied* to each instance and then
+    # potentially overwritten in ``__init__``.
+    # ------------------------------------------------------------------
+    _year: int | None = None  # Will be set in __post_init__
+    _semester: str | None = None  # "WiSe" or "SoSe" - set later
+    _month: int | None = None  # Will be set in __post_init__
+    value: str | None = None  # Human-readable label, e.g. "WiSe 23/24"
+
+    # ------------------------------------------------------------------
+    # Construction helpers
+    # ------------------------------------------------------------------
+    def __init__(
+        self,
+        year: int | None = None,
+        semester: str | None = None,
+        month: int | None = None,
+    ) -> None:
+        if year is not None:
+            self._year = int(year)
+        if semester is not None:
+            if semester not in ("WiSe", "SoSe"):
+                raise ValueError("semester must be 'WiSe' or 'SoSe'")
+            self._semester = semester
+        if month is not None:
+            self._month = month
+
+        self.__post_init__()
+
+    def __post_init__(self) -> None:
+        now = datetime.datetime.now()
+
+        if self._month is None:
+            self._month = now.month
+
+        if self._year is None:
+            # Extract last 2 digits of current year
+            current_year = int(str(now.year)[2:])
+
+            # For winter semester in Jan-Mar, we need to use the previous year
+            # because WiSe started in October of the previous calendar year
+            if self._month <= 3:
+                self._year = (current_year - 1) % 100
+            else:
+                self._year = current_year
+
+        if self._semester is None:
+            self._generate_semester_from_month()
+        self._compute_value()
+
+    # ------------------------------------------------------------------
+    # Dunder helpers
+    # ------------------------------------------------------------------
+    def __str__(self) -> str:
+        return self.value or "<invalid Semester>"
+
+    def __repr__(self) -> str:  # Helpful for debugging lists
+        return f"Semester({self._year!r}, {self._semester!r})"
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+    def _generate_semester_from_month(self) -> None:
+        """Infer *WiSe* / *SoSe* from the month attribute."""
+        if self._month is not None:
+            self._semester = "WiSe" if (self._month <= 3 or self._month > 9) else "SoSe"
+        else:
+            self._semester = "WiSe"  # Default value if month is None
+
+    def _compute_value(self) -> None:
+        """Human-readable semester label - e.g. ``WiSe 23/24`` or ``SoSe 24``."""
+        if self._year is not None:
+            year = self._year
+            if self._semester == "WiSe":
+                next_year = (year + 1) % 100  # wrap 99 → 0
+                self.value = f"WiSe {year}/{next_year}"
+            else:  # SoSe
+                self.value = f"SoSe {year}"
+        else:
+            self.value = "<invalid Semester>"
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+    def offset(self, value: int) -> Semester:
+        """Return a new :class:`Semester` *value* steps away.
+
+        The algorithm maps every semester to a monotonically increasing
+        *linear index* so that simple addition suffices:
+
+        ``index = year * 2 + (0 if SoSe else 1)``.
+        """
+        if not isinstance(value, int):
+            raise TypeError("value must be an int (number of semesters to jump)")
+        if value == 0:
+            return Semester(self._year, self._semester)
+
+        if self._year is None:
+            raise ValueError("Cannot offset from a semester with no year")
+        current_idx = self._year * 2 + (0 if self._semester == "SoSe" else 1)
+        target_idx = current_idx + value
+        if target_idx < 0:
+            raise ValueError("offset would result in a negative year - not supported")
+
+        new_year, semester_bit = divmod(target_idx, 2)
+        new_semester = "SoSe" if semester_bit == 0 else "WiSe"
+        return Semester(new_year, new_semester)
+
+    # ------------------------------------------------------------------
+    # Comparison helpers
+    # ------------------------------------------------------------------
+    def is_past_semester(self, current: Semester) -> bool:
+        log.debug(f"Comparing {self} < {current}")
+        if self.year < current.year:
+            return True
+        if self.year == current.year:
+            return (
+                self.semester == "WiSe" and current.semester == "SoSe"
+            )  # WiSe before next SoSe
+        return False
+
+    def is_future_semester(self, current: Semester) -> bool:
+        if self.year > current.year:
+            return True
+        if self.year == current.year:
+            return (
+                self.semester == "SoSe" and current.semester == "WiSe"
+            )  # SoSe after WiSe of same year
+        return False
+
+    def is_match(self, other: Semester) -> bool:
+        return self.year == other.year and self.semester == other.semester
+
+    # ------------------------------------------------------------------
+    # Convenience properties
+    # ------------------------------------------------------------------
+    @property
+    def next(self) -> Semester:
+        return self.offset(1)
+
+    @property
+    def previous(self) -> Semester:
+        return self.offset(-1)
+
+    @property
+    def year(self) -> int:
+        if self._year is None:
+            raise ValueError("Year is not set for this semester")
+        return self._year
+
+    @property
+    def semester(self) -> str:
+        if self._semester is None:
+            raise ValueError("Semester is not set for this semester")
+        return self._semester
+
+    # ------------------------------------------------------------------
+    # Static helpers
+    # ------------------------------------------------------------------
+    @staticmethod
+    def generate_missing(start: Semester, end: Semester) -> list[str]:
+        """Return all consecutive semesters from *start* to *end* (inclusive)."""
+        if not isinstance(start, Semester) or not isinstance(end, Semester):
+            raise TypeError("start and end must be Semester instances")
+        if start.is_future_semester(end) and not start.is_match(end):
+            raise ValueError("'start' must not be after 'end'")
+
+        chain: list[str] = [str(start)]
+        current = start
+        while not current.is_match(end):
+            current = current.next
+            chain.append(str(current))
+            if len(chain) > 1000:  # sanity guard
+                raise RuntimeError("generate_missing exceeded sane iteration limit")
+        return chain
+
+    # ------------------------------------------------------------------
+    # Parsing helper
+    # ------------------------------------------------------------------
+    @classmethod
+    def from_string(cls, s: str) -> Semester:
+        """Parse a human-readable semester label and return a :class:`Semester`.
+
+        Accepted formats (case-insensitive)::
+
+            "SoSe <YY>"            → SoSe of year YY
+            "WiSe <YY>/<YY+1>"     → Winter term starting in YY
+            "WiSe <YY>"            → Shorthand for the above (next year implied)
+
+        ``YY`` may contain a leading zero ("06" → 6).
+        """
+        if not isinstance(s, str):
+            raise TypeError("s must be a string")
+
+        pattern = r"\s*(WiSe|SoSe)\s+(\d{1,2})(?:\s*/\s*(\d{1,2}))?\s*"
+        m = re.fullmatch(pattern, s, flags=re.IGNORECASE)
+        if not m:
+            raise ValueError(
+                "invalid semester string format - expected 'SoSe YY' or 'WiSe YY/YY' (spacing flexible)",
+            )
+
+        term_raw, y1_str, y2_str = m.groups()
+        term = term_raw.capitalize()  # normalize case → "WiSe" or "SoSe"
+        year = int(y1_str.lstrip("0") or "0")  # "06" → 6, "0" stays 0
+
+        if term == "SoSe":
+            if y2_str is not None:
+                raise ValueError(
+                    "SoSe string should not contain '/' followed by a second year",
+                )
+            return cls(year, "SoSe")
+
+        # term == "WiSe"
+        if y2_str is not None:
+            next_year = int(y2_str.lstrip("0") or "0")
+            expected_next = (year + 1) % 100
+            if next_year != expected_next:
+                raise ValueError("WiSe second year must equal first year + 1 (mod 100)")
+        # Accept both explicit "WiSe 6/7" and shorthand "WiSe 6"
+        return cls(year, "WiSe")
+
+
+# ------------------------- quick self-test -------------------------
+if __name__ == "__main__":
+    # Chain generation demo ------------------------------------------------
+    s_start = Semester(6, "SoSe")  # SoSe 6
+    s_end = Semester(25, "WiSe")  # WiSe 25/26
+    chain = Semester.generate_missing(s_start, s_end)
+    # print("generate_missing:", [str(s) for s in chain])
+
+    # Parsing demo ---------------------------------------------------------
+    examples = [
+        "SoSe 6",
+        "WiSe 6/7",
+        "WiSe 6",
+        "SoSe 23",
+        "WiSe 23/24",
+        "WiSe 24",
+        "WiSe 99/00",
+        "SoSe 00",
+        "WiSe 100/101",  # test large year
+    ]
+    for ex in examples:
+        parsed = Semester.from_string(ex)
+        # debug: demonstration output (disabled)
+        # print(f"'{ex}' → {parsed} ({parsed.year=}, {parsed.semester=})")

src/database/__init__.py

@@ -0,0 +1,5 @@
+"""Database layer for data persistence."""
+
+from .connection import Database
+
+__all__ = ["Database"]

src/database/migrations/V001__create_base_tables.sql

@@ -0,0 +1,132 @@
+BEGIN TRANSACTION;
+
+CREATE TABLE IF NOT EXISTS semesterapparat (
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    name TEXT,
+    prof_id INTEGER,
+    fach TEXT,
+    appnr INTEGER,
+    erstellsemester TEXT,
+    verlängert_am TEXT,
+    dauer BOOLEAN,
+    verlängerung_bis TEXT,
+    deletion_status INTEGER,
+    deleted_date TEXT,
+    apparat_id_adis INTEGER,
+    prof_id_adis INTEGER,
+    konto INTEGER,
+    FOREIGN KEY (prof_id) REFERENCES prof (id)
+  );
+
+CREATE TABLE IF NOT EXISTS media (
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    bookdata TEXT,
+    app_id INTEGER,
+    prof_id INTEGER,
+    deleted INTEGER DEFAULT (0),
+    available BOOLEAN,
+    reservation BOOLEAN,
+    FOREIGN KEY (prof_id) REFERENCES prof (id),
+    FOREIGN KEY (app_id) REFERENCES semesterapparat (id)
+  );
+
+CREATE TABLE IF NOT EXISTS files (
+    id INTEGER PRIMARY KEY,
+    filename TEXT,
+    fileblob BLOB,
+    app_id INTEGER,
+    filetyp TEXT,
+    prof_id INTEGER REFERENCES prof (id),
+    FOREIGN KEY (app_id) REFERENCES semesterapparat (id)
+    );
+
+CREATE TABLE IF NOT EXISTS messages (
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    created_at date NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    message TEXT NOT NULL,
+    remind_at date NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    user_id INTEGER NOT NULL,
+    appnr INTEGER,
+    FOREIGN KEY (user_id) REFERENCES user (id)
+  );
+
+CREATE TABLE IF NOT EXISTS prof (
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    titel TEXT,
+    fname TEXT,
+    lname TEXT,
+    fullname TEXT NOT NULL UNIQUE,
+    mail TEXT,
+    telnr TEXT
+  );
+
+CREATE TABLE IF NOT EXISTS user (
+    id integer NOT NULL PRIMARY KEY AUTOINCREMENT,
+    created_at datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    username TEXT NOT NULL UNIQUE,
+    password TEXT NOT NULL,
+    salt TEXT NOT NULL,
+    role TEXT NOT NULL,
+    email TEXT UNIQUE,
+    name TEXT
+  );
+
+CREATE TABLE IF NOT EXISTS subjects (
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    name TEXT NOT NULL UNIQUE
+);
+
+CREATE TABLE IF NOT EXISTS elsa (
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    date TEXT NOT NULL,
+    semester TEXT NOT NULL,
+    prof_id INTEGER NOT NULL
+  );
+
+CREATE TABLE IF NOT EXISTS elsa_files (
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    filename TEXT NOT NULL,
+    fileblob BLOB NOT NULL,
+    elsa_id INTEGER NOT NULL,
+    filetyp TEXT NOT NULL,
+    FOREIGN KEY (elsa_id) REFERENCES elsa (id)
+  );
+
+CREATE TABLE IF NOT EXISTS elsa_media (
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    work_author TEXT,
+    section_author TEXT,
+    year TEXT,
+    edition TEXT,
+    work_title TEXT,
+    chapter_title TEXT,
+    location TEXT,
+    publisher TEXT,
+    signature TEXT,
+    issue TEXT,
+    pages TEXT,
+    isbn TEXT,
+    type TEXT,
+    elsa_id INTEGER NOT NULL,
+    FOREIGN KEY (elsa_id) REFERENCES elsa (id)
+  );
+
+CREATE TABLE IF NOT EXISTS neweditions (
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    new_bookdata TEXT,
+    old_edition_id INTEGER,
+    for_apparat INTEGER,
+    ordered BOOLEAN DEFAULT (0),
+    FOREIGN KEY (old_edition_id) REFERENCES media (id),
+    FOREIGN KEY (for_apparat) REFERENCES semesterapparat (id)
+);
+
+-- Helpful indices to speed up frequent lookups and joins
+CREATE INDEX IF NOT EXISTS idx_media_app_prof ON media(app_id, prof_id);
+CREATE INDEX IF NOT EXISTS idx_media_deleted ON media(deleted);
+CREATE INDEX IF NOT EXISTS idx_media_available ON media(available);
+CREATE INDEX IF NOT EXISTS idx_messages_remind_at ON messages(remind_at);
+CREATE INDEX IF NOT EXISTS idx_semesterapparat_prof ON semesterapparat(prof_id);
+CREATE INDEX IF NOT EXISTS idx_semesterapparat_appnr ON semesterapparat(appnr);
+
+COMMIT;

src/database/migrations/V002__create_table_webadis_login.sql

@@ -0,0 +1,10 @@
+BEGIN TRANSACTION;
+
+CREATE TABLE IF NOT EXISTS webadis_login (
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    username TEXT NOT NULL,
+    password TEXT NOT NULL
+  );
+
+COMMIT;
+

src/database/migrations/V003_update_webadis_add_user_area.sql

@@ -0,0 +1,6 @@
+BEGIN TRANSACTION;
+
+ALTER TABLE webadis_login
+ADD COLUMN effective_range TEXT;
+
+COMMIT;

src/database/schemas.py

@@ -12,12 +12,12 @@ CREATE_TABLE_APPARAT = """CREATE TABLE semesterapparat (
     deleted_date TEXT,
     apparat_id_adis INTEGER,
     prof_id_adis INTEGER,
-    konto INTEGER REFERENCES app_kontos (id),
+    konto INTEGER,
     FOREIGN KEY (prof_id) REFERENCES prof (id)
   )"""
 CREATE_TABLE_MEDIA = """CREATE TABLE media (
     id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
-    bookdata BLOB,
+    bookdata TEXT,
     app_id INTEGER,
     prof_id INTEGER,
     deleted INTEGER DEFAULT (0),
@@ -26,13 +26,7 @@ CREATE_TABLE_MEDIA = """CREATE TABLE media (
     FOREIGN KEY (prof_id) REFERENCES prof (id),
     FOREIGN KEY (app_id) REFERENCES semesterapparat (id)
   )"""
-CREATE_TABLE_APPKONTOS = """CREATE TABLE app_kontos (
-    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
-    app_id INTEGER,
-    konto INTEGER,
-    passwort TEXT,
-    FOREIGN KEY (app_id) REFERENCES semesterapparat (id)
-    )"""
+
 CREATE_TABLE_FILES = """CREATE TABLE files (
     id INTEGER PRIMARY KEY,
     filename TEXT,
@@ -107,3 +101,12 @@ CREATE_ELSA_MEDIA_TABLE = """CREATE TABLE elsa_media (
     elsa_id INTEGER NOT NULL,
     FOREIGN KEY (elsa_id) REFERENCES elsa (id)
   )"""
+CREATE_TABLE_NEWEDITIONS = """CREATE TABLE neweditions (
+    id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    new_bookdata TEXT,
+    old_edition_id INTEGER,
+    for_apparat INTEGER,
+    ordered BOOLEAN DEFAULT (0),
+    FOREIGN KEY (old_edition_id) REFERENCES media (id),
+    FOREIGN KEY (for_apparat) REFERENCES semesterapparat (id)
+)"""

src/documents/generators.py

@@ -0,0 +1,372 @@
+import os
+from datetime import datetime
+from os.path import basename
+from pathlib import Path
+
+from docx import Document
+from docx.enum.text import WD_PARAGRAPH_ALIGNMENT
+from docx.oxml import OxmlElement
+from docx.oxml.ns import qn
+from docx.shared import Cm, Pt, RGBColor
+
+from src import settings
+from src.shared.logging import log
+
+logger = log
+
+font = "Cascadia Mono"
+
+
+def print_document(file: str) -> None:
+    # send document to printer as attachment of email
+    import smtplib
+    from email.mime.application import MIMEApplication
+    from email.mime.multipart import MIMEMultipart
+    from email.mime.text import MIMEText
+
+    smtp = settings.mail.smtp_server
+    port = settings.mail.port
+    sender_email = settings.mail.sender
+    password = settings.mail.password
+    receiver = settings.mail.printer_mail
+    message = MIMEMultipart()
+    message["From"] = sender_email
+    message["To"] = receiver
+    message["cc"] = settings.mail.sender
+    message["Subject"] = "."
+    mail_body = "."
+    message.attach(MIMEText(mail_body, "html"))
+    with open(file, "rb") as fil:
+        part = MIMEApplication(fil.read(), Name=basename(file))
+    # After the file is closed
+    part["Content-Disposition"] = 'attachment; filename="%s"' % basename(file)
+    message.attach(part)
+    mail = message.as_string()
+    with smtplib.SMTP_SSL(smtp, port) as server:
+        server.connect(smtp, port)
+        server.login(settings.mail.user_name, password)
+        server.sendmail(sender_email, receiver, mail)
+        server.quit()
+        log.success("Mail sent")
+
+
+class SemesterError(Exception):
+    """Custom exception for semester-related errors."""
+
+    def __init__(self, message: str):
+        super().__init__(message)
+        log.error(message)
+
+    def __str__(self):
+        return f"SemesterError: {self.args[0]}"
+
+
+class SemesterDocument:
+    def __init__(
+        self,
+        apparats: list[tuple[int, str]],
+        semester: str,
+        filename: str,
+        full: bool = False,
+    ):
+        assert isinstance(apparats, list), SemesterError(
+            "Apparats must be a list of tuples",
+        )
+        assert all(isinstance(apparat, tuple) for apparat in apparats), SemesterError(
+            "Apparats must be a list of tuples",
+        )
+        assert all(isinstance(apparat[0], int) for apparat in apparats), SemesterError(
+            "Apparat numbers must be integers",
+        )
+        assert all(isinstance(apparat[1], str) for apparat in apparats), SemesterError(
+            "Apparat names must be strings",
+        )
+        assert isinstance(semester, str), SemesterError("Semester must be a string")
+        assert "." not in filename and isinstance(filename, str), SemesterError(
+            "Filename must be a string and not contain an extension",
+        )
+        self.doc = Document()
+        self.apparats = apparats
+        self.semester = semester
+        self.table_font_normal = font
+        self.table_font_bold = font
+        self.header_font = font
+        self.header_font_size = Pt(26)
+        self.sub_header_font_size = Pt(18)
+        self.table_font_size = Pt(10)
+        self.color_red = RGBColor(255, 0, 0)
+        self.color_blue = RGBColor(0, 0, 255)
+        self.filename = filename
+        if full:
+            log.info("Full document generation")
+            self.cleanup
+            log.info("Cleanup done")
+            self.make_document()
+            log.info("Document created")
+            self.create_pdf()
+            log.info("PDF created")
+            print_document(self.filename + ".pdf")
+            log.info("Document printed")
+
+    def set_table_border(self, table):
+        """Adds a full border to the table.
+
+        :param table: Table object to which the border will be applied.
+        """
+        tbl = table._element
+        tbl_pr = tbl.xpath("w:tblPr")[0]
+        tbl_borders = OxmlElement("w:tblBorders")
+
+        # Define border styles
+        for border_name in ["top", "left", "bottom", "right", "insideH", "insideV"]:
+            border = OxmlElement(f"w:{border_name}")
+            border.set(qn("w:val"), "single")
+            border.set(qn("w:sz"), "4")  # Thickness of the border
+            border.set(qn("w:space"), "0")
+            border.set(qn("w:color"), "000000")  # Black color
+            tbl_borders.append(border)
+
+        tbl_pr.append(tbl_borders)
+
+    def create_sorted_table(self) -> None:
+        # Sort the apparats list by the string in the tuple (index 1)
+        self.apparats.sort(key=lambda x: x[1])
+        # Create a table with rows equal to the length of the apparats list
+        table = self.doc.add_table(rows=len(self.apparats), cols=2)
+        table.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
+
+        # Set column widths by directly modifying the cell properties
+        widths = [Cm(1.19), Cm(10)]
+        for col_idx, width in enumerate(widths):
+            for cell in table.columns[col_idx].cells:
+                cell_width_element = cell._element.xpath(".//w:tcPr")[0]
+                tcW = OxmlElement("w:tcW")
+                tcW.set(qn("w:w"), str(int(width.cm * 567)))  # Convert cm to twips
+                tcW.set(qn("w:type"), "dxa")
+                cell_width_element.append(tcW)
+
+        # Adjust row heights
+        for row in table.rows:
+            trPr = row._tr.get_or_add_trPr()  # Get or add the <w:trPr> element
+            trHeight = OxmlElement("w:trHeight")
+            trHeight.set(
+                qn("w:val"),
+                str(int(Pt(15).pt * 20)),
+            )  # Convert points to twips
+            trHeight.set(qn("w:hRule"), "exact")  # Use "exact" for fixed height
+            trPr.append(trHeight)
+
+        # Fill the table with sorted data
+        for row_idx, (number, name) in enumerate(self.apparats):
+            row = table.rows[row_idx]
+
+            # Set font for the first column (number)
+            cell_number_paragraph = row.cells[0].paragraphs[0]
+            cell_number_run = cell_number_paragraph.add_run(str(number))
+            cell_number_run.font.name = self.table_font_bold
+            cell_number_run.font.size = self.table_font_size
+            cell_number_run.font.bold = True
+            cell_number_run.font.color.rgb = self.color_red
+            cell_number_paragraph.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
+
+            # Set font for the second column (name)
+            cell_name_paragraph = row.cells[1].paragraphs[0]
+            words = name.split()
+            if words:
+                # Add the first word in bold
+                bold_run = cell_name_paragraph.add_run(words[0])
+                bold_run.font.bold = True
+                bold_run.font.name = self.table_font_bold
+                bold_run.font.size = self.table_font_size
+
+                # Add the rest of the words normally
+                if len(words) > 1:
+                    normal_run = cell_name_paragraph.add_run(" " + " ".join(words[1:]))
+                    normal_run.font.name = self.table_font_normal
+                    normal_run.font.size = self.table_font_size
+            cell_name_paragraph.alignment = WD_PARAGRAPH_ALIGNMENT.LEFT
+
+        self.set_table_border(table)
+
+    def make_document(self):
+        # Create a new Document
+        section = self.doc.sections[0]
+        section.top_margin = Cm(2.54)  # Default 1 inch (can adjust as needed)
+        section.bottom_margin = Cm(1.5)  # Set bottom margin to 1.5 cm
+        section.left_margin = Cm(2.54)  # Default 1 inch
+        section.right_margin = Cm(2.54)  # Default 1 inch
+
+        # Add the current date
+        current_date = datetime.now().strftime("%Y-%m-%d")
+        date_paragraph = self.doc.add_paragraph(current_date)
+        date_paragraph.alignment = WD_PARAGRAPH_ALIGNMENT.LEFT
+
+        # Add a header
+        semester = f"Semesterapparate {self.semester}"
+        header = self.doc.add_paragraph(semester)
+        header.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
+        header_run = header.runs[0]
+        header_run.font.name = self.header_font
+        header_run.font.size = self.header_font_size
+        header_run.font.bold = True
+        header_run.font.color.rgb = self.color_blue
+
+        sub_header = self.doc.add_paragraph("(Alphabetisch)")
+        sub_header.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
+        sub_header_run = sub_header.runs[0]
+        sub_header_run.font.name = self.header_font
+        sub_header_run.font.size = self.sub_header_font_size
+        sub_header_run.font.color.rgb = self.color_red
+
+        self.doc.add_paragraph("")
+
+        self.create_sorted_table()
+
+    def save_document(self, name: str) -> None:
+        # Save the document
+        self.doc.save(name)
+
+    def create_pdf(self) -> None:
+        # Save the document
+        import comtypes.client
+
+        word = comtypes.client.CreateObject("Word.Application")  # type: ignore
+        self.save_document(self.filename + ".docx")
+        docpath = os.path.abspath(self.filename + ".docx")
+        doc = word.Documents.Open(docpath)
+        curdir = Path.cwd()
+        doc.SaveAs(f"{curdir}/{self.filename}.pdf", FileFormat=17)
+        doc.Close()
+        word.Quit()
+        log.debug("PDF saved")
+
+    @property
+    def cleanup(self) -> None:
+        if os.path.exists(f"{self.filename}.docx"):
+            os.remove(f"{self.filename}.docx")
+            os.remove(f"{self.filename}.pdf")
+
+    @property
+    def send(self) -> None:
+        print_document(self.filename + ".pdf")
+        log.debug("Document sent to printer")
+
+
+class SemapSchilder:
+    def __init__(self, entries: list[str]):
+        self.entries = entries
+        self.filename = "Schilder"
+        self.font_size = Pt(23)
+        self.font_name = font
+        self.doc = Document()
+        self.define_doc_properties()
+        self.add_entries()
+        self.cleanup()
+        self.create_pdf()
+
+    def define_doc_properties(self):
+        # set the doc to have a top margin of 1cm, left and right are 0.5cm, bottom is 0cm
+        section = self.doc.sections[0]
+        section.top_margin = Cm(1)
+        section.bottom_margin = Cm(0)
+        section.left_margin = Cm(0.5)
+        section.right_margin = Cm(0.5)
+
+        # set the font to Times New Roman, size 23 bold, color black
+        for paragraph in self.doc.paragraphs:
+            for run in paragraph.runs:
+                run.font.name = self.font_name
+                run.font.size = self.font_size
+                run.font.bold = True
+                run.font.color.rgb = RGBColor(0, 0, 0)
+                paragraph.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
+
+        # if the length of the text is
+
+    def add_entries(self):
+        for entry in self.entries:
+            paragraph = self.doc.add_paragraph(entry)
+            paragraph.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
+            paragraph.paragraph_format.line_spacing = Pt(23)  # Set fixed line spacing
+            paragraph.paragraph_format.space_before = Pt(2)  # Remove spacing before
+            paragraph.paragraph_format.space_after = Pt(2)  # Remove spacing after
+
+            run = paragraph.runs[0]
+            run.font.name = self.font_name
+            run.font.size = self.font_size
+            run.font.bold = True
+            run.font.color.rgb = RGBColor(0, 0, 0)
+
+            # Add a line to be used as a guideline for cutting
+            line = self.doc.add_paragraph()
+            line.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
+            line.paragraph_format.line_spacing = Pt(23)  # Match line spacing
+            line.paragraph_format.space_before = Pt(2)  # Remove spacing before
+            line.paragraph_format.space_after = Pt(2)  # Remove spacing after
+            line.add_run("--------------------------")
+
+    def save_document(self):
+        # Save the document
+        self.doc.save(f"{self.filename}.docx")
+        log.debug(f"Document saved as {self.filename}.docx")
+
+    def create_pdf(self) -> None:
+        # Save the document
+        import comtypes.client
+
+        word = comtypes.client.CreateObject("Word.Application")  # type: ignore
+        self.save_document()
+        docpath = os.path.abspath(f"{self.filename}.docx")
+        doc = word.Documents.Open(docpath)
+        curdir = Path.cwd()
+        doc.SaveAs(f"{curdir}/{self.filename}.pdf", FileFormat=17)
+        doc.Close()
+        word.Quit()
+        log.debug("PDF saved")
+
+    def cleanup(self) -> None:
+        if os.path.exists(f"{self.filename}.docx"):
+            os.remove(f"{self.filename}.docx")
+        if os.path.exists(f"{self.filename}.pdf"):
+            os.remove(f"{self.filename}.pdf")
+
+    @property
+    def send(self) -> None:
+        print_document(self.filename + ".pdf")
+        log.debug("Document sent to printer")
+
+
+if __name__ == "__main__":
+    entries = [
+        "Lüsebrink (Theorie und Praxis der Leichtathletik)",
+        "Kulovics (ISP-Betreuung)",
+        "Köhler (Ausgewählte Aspekte der materiellen Kultur Textil)",
+        "Grau (Young Adult Literature)",
+        "Schiebel (Bewegung II:Ausgewählte Problemfelder)",
+        "Schiebel (Ernährungswiss. Perspektive)",
+        "Park (Kommunikation und Kooperation)",
+        "Schiebel (Schwimmen)",
+        "Huppertz (Philosophieren mit Kindern)",
+        "Heyl (Heyl)",
+        "Reuter (Verschiedene Veranstaltungen)",
+        "Reinhold (Arithmetik und mathematisches Denken)",
+        "Wirtz (Forschungsmethoden)",
+        "Schleider (Essstörungen)",
+        "Schleider (Klinische Psychologie)",
+        "Schleider (Doktorandenkolloquium)",
+        "Schleider (Störungen Sozialverhaltens/Delinquenz)",
+        "Burth (EU Forschung im Int. Vergleich/EU Gegenstand biling. Didaktik)",
+        "Reinhardt (Einführung Politikdidaktik)",
+        "Schleider (Psychologische Interventionsmethoden)",
+        "Schleider (ADHS)",
+        "Schleider (Beratung und Teamarbeit)",
+        "Schleider (LRS)",
+        "Schleider (Gesundheitspsychologie)",
+        "Schleider (Elterntraining)",
+        "Wulff (Hochschulzertifikat DaZ)",
+        "Dinkelaker ( )",
+        "Droll (Einführung in die Sprachwissenschaft)",
+        "Karoß (Gymnastik - Sich Bewegen mit und ohne Handgeräte)",
+        "Sahrai (Kindheit und Gesellschaft)",
+    ]
+    doc = SemapSchilder(entries)

src/errors/__init__.py

@@ -1,2 +1,2 @@
 # import basic error classes
-from .DatabaseErrors import *
+from .DatabaseErrors import *  # noqa: F403

src/logic/__init__.py

@@ -1,6 +1,8 @@
-from .dataclass import ApparatData, BookData, Prof, Apparat, ELSA
+"""Sorting utilities for semester data."""
+
 from .c_sort import custom_sort, sort_semesters_list
-from .constants import APP_NRS, PROF_TITLES, SEMAP_MEDIA_ACCOUNTS
-from .csvparser import csv_to_list
-from .wordparser import elsa_word_to_csv, word_docx_to_csv
-from .zotero import ZoteroController
+
+__all__ = [
+    "custom_sort",
+    "sort_semesters_list",
+]