fix: issues (1)

Reviewed-on: #30

.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

@@ -1,59 +1,271 @@
+name: Build and Release
+
 on:
   workflow_dispatch:
     inputs:
-      release_notes:
-        description: Release notes (use \n for newlines)
-        type: string
-        required: false
       github_release:
-        description: 'Create Gitea Release'
+        description: "Create Gitea Release"
         default: true
         type: boolean
+      prerelease:
+        description: "Is this a prerelease?"
+        default: false
+        type: boolean
       bump:
-        description: 'Bump type'
+        description: "Bump type"
         required: false
-        default: 'patch'
+        default: "patch"
         type: choice
         options:
-          - 'major'
-          - 'minor'
-          - 'patch'
+          - "major"
+          - "minor"
+          - "patch"
 
+env:
+  BASE_URL: "http://192.168.178.110:3000"
 
 jobs:
-  bump:
+  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
-        uses: actions/checkout@v4
+      - name: Checkout code
+        uses: actions/checkout@v5
         with:
           fetch-depth: 0
-      - name: Install UV
-        uses: astral-sh/setup-uv@v5
+          fetch-tags: true
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+
       - name: Set up Python
-        run: uv python install
+        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: Install dependencies
-        run: uv sync --locked --all-extras --dev
-      - name: Install Bump tool
-        run: uv tool install bump-my-version
-      - name: Bump version
-        id: bump_version
+
+      - name: Set Git identity
         run: |
-          uv tool run bump-my-version bump ${{ github.event.inputs.bump }} --tag --allow-dirty
-      - name: Add release notes
-        id: add_release_notes
+          git config user.name "Gitea CI"
+          git config user.email "ci@git.theprivateserver.de"
+
+      - name: Bump version and push
         run: |
-          echo "RELEASE_NOTES<<EOF" >> $GITHUB_ENV
-          echo "${{ github.event.inputs.release_notes }}" >> $GITHUB_ENV
-          echo "EOF" >> $GITHUB_ENV
-      - name: Create Gitea Release
-        if: ${{ github.event.inputs.github_release == 'true' }}
-        uses: softprops/action-gh-release@v1
+          uv version --bump "${{ github.event.inputs.bump }}"
+      - name: Push version bump
+        uses: ad-m/github-push-action@master
         with:
-          tag_name: 
-          release_name: Release ${{ github.sha }}
-          body: ${{ env.RELEASE_NOTES }}
-          draft: false
-          prerelease: false
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          branch: ${{ github.ref }}

.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

@@ -1 +1 @@
-1.0.0
+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,27 +1,443 @@
 # SemesterapparatsManager
 
-SemesterapparatsManager is a graphical tool for managing semester apparatuses in the University of Education Freiburg. It allows the users to manage the semester apparatuses in a user-friendly way. It's functions include management of physical and digital semester apparatuses, as well as creating the citations for the digital files of the digital semester apparatuses. For that it uses Zotero, an open source reference management software. The semester apparatuses are stored in a SQLite database, which is created and managed by the SemesterapparatsManager. The SemesterapparatsManager is written in Python and uses the PyQt6 library for the graphical user interface
+[![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.
 
-## Features
-- Manage physical semester apparatuses
-  - Add semester apparatuses
-  - Edit semester apparatuses
-  - Delete semester apparatuses
-  - Extend semester apparatuses
-  - Notify professors about semester apparatuses creation or deletion
-  - Add messages to all semester apparatuses, or an individual semester apparatus
-- Manage digital semester apparatuses
-  - Use text parsing to extract information from the submitted form and create the scans
-    - if a book is used multiple parts of a book are used, it can be split into the parts
-  - Create the matching citations for the files
-- Statistics and Search 
-  - Search semester apparatuses by various criteria
-  - Show statistics about the semester apparatuses creation and deletion
-- Edit user data
+## 📋 Table of Contents
 
+- [Overview](#overview)
+- [Features](#features)
+- [Architecture](#architecture)
+- [Installation](#installation)
+- [Usage](#usage)
+- [Development](#development)
+- [Documentation](#documentation)
+- [Contributing](#contributing)
+- [License](#license)
 
-## Images
+## 🎯 Overview
 
-![Main Window](docs/images/mainUI.png)
-![Statistics](docs/images/statistics.png)
+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**

config/config.py

@@ -1,9 +1,10 @@
 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
@@ -15,6 +16,7 @@ class OpenAI:
     def _setattr(self, name: str, value: Any):
         setattr(self, name, value)
 
+
 @dataclass
 class Zotero:
     api_key: str
@@ -33,6 +35,7 @@ class Database:
     name: str
     path: Union[str, Path, None]
     temp: Union[str, Path, None]
+
     def getattr(self, name: str):
         return getattr(self, name)
 
@@ -45,11 +48,13 @@ class Database:
         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
@@ -135,8 +140,9 @@ class Config:
 
     """
 
-    _config: Optional[DictConfig] = None
+    _config: Optional[Union[DictConfig, ListConfig]] = None
     config_exists: bool = True
+
     def __init__(self, config_path: str):
         """
         Loads the configuration file and stores it for future access.
@@ -177,22 +183,25 @@ class Config:
         """
         Reloads the configuration from the file.
         """
-        self._config = OmegaConf.load(self.config_path)
+        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: str):
+    def get_zotero_attr(self, name: str):
         return getattr(self.zotero, name)
 
-    @zotero_attr.setter
-    def zotero_attr(self, name: str, value: Any):
+    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
@@ -205,43 +214,57 @@ class Config:
 
     @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: str):
         return getattr(self.mail, name)
 
     def set_mail_attr(self, name: str, value: Any):
-        OmegaConf.update(self._config, f"mail.{name}", value)
+        if self._config is not None:
+            OmegaConf.update(self._config, f"mail.{name}", value)
 
     def set_database_attr(self, name: str, value: Any):
-        OmegaConf.update(self._config, f"database.{name}", value)
+        if self._config is not None:
+            OmegaConf.update(self._config, f"database.{name}", value)
 
     def set_zotero_attr(self, name: str, value: Any):
-        OmegaConf.update(self._config, f"zotero.{name}", value)
+        if self._config is not None:
+            OmegaConf.update(self._config, f"zotero.{name}", value)
 
     def set_openai_attr(self, name: str, value: Any):
-        OmegaConf.update(self._config, f"openAI.{name}", value)
+        if self._config is not None:
+            OmegaConf.update(self._config, f"openAI.{name}", value)
 
     def set_icon_attr(self, name: str, value: Any):
-        OmegaConf.update(self._config, f"icons.{name}", value)
+        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/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/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_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} - Alexander Kirchner (alexander.kirchner@ph-freiburg.de).eml

@@ -1,54 +0,0 @@
-Message-ID: <987b46cf-2d8b-4a27-acb3-c50f61d3d85d@ph-freiburg.de>
-Date: Tue, 31 Oct 2023 11:38:34 +0100
-MIME-Version: 1.0
-User-Agent: Mozilla Thunderbird
-From: Alexander Kirchner <alexander.kirchner@ph-freiburg.de>
-Subject: =?UTF-8?Q?Information_bez=C3=BCglich_der_Aufl=C3=B6sung_des_Semeste?=
- =?UTF-8?Q?rapparates_=7BAppNr=7D?=
-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
-
-<!DOCTYPE html>
-<html>
-  <head>
-    <meta http-equiv="content-type" content="text/html; charset=UTF-8">
-  </head>
-  <body>
-    <p>Sehr geehrte/r {Profname}, <br>
-    </p>
-    <p><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.
-    Die Medien, die im Apparat aufgestellt waren, werden nun wieder
-    regulär ausleihbar und sind dann an ihren Standorten bei den Fächern
-    zu finden. <br>
-    <br>
-    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. Im Falle einer Verlängerung des Apparates reicht
-    eine Antwort auf diese Mail.
-    <p><br>
-    </p>
-    <p>Bei Fragen können Sie sich jederzeit an mich wenden.<br>
-    </p>
-    <p><br>
-    </p>
-    <pre class="moz-signature" cols="72">-- 
-Freundliche Grüße
-
-Alexander Kirchner
-
-
-Bibliothek der Pädagogischen Hochschule Freiburg
-Tel. 0761/682-778</pre>
-  </body>
-</html>

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/Information zur Auflösung des Semesterapparates.eml

@@ -1,18 +0,0 @@
-Subject: Information zur Auflösung des Semesterapparates {AppNr} - {Appname}
-MIME-Version: 1.0
-Content-Type: text/html; charset="UTF-8"
-Content-Transfer-Encoding: 8bit
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN" "http://www.w3.org/TR/REC-html40/strict.dtd">
-<html>
-  <head>
-    <meta http-equiv="content-type" content="text/html; charset=UTF-8">
-  </head>
-                <body style=" font-family:'Segoe UI'; font-size:9pt; font-weight:400; font-style:normal;">
-<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">{greeting}</p>
-<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>
-<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Ihr Semesterapparat "{Appname} ({AppNr})" wurde wie besprochen aufgelöst. </p>
-<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Die Medien sind von nun an wieder in den Regalen zu finden.</p>
-<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>
-<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><pre class="moz-signature" cols="72">-- </p>
-<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">{signature}</p>
-<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"></pre></p></body></html>

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,11 +1,14 @@
-from src import first_launch, settings
-from src.ui.widgets.welcome_wizard import launch_wizard as startup
-from PySide6 import QtWidgets
 import sys
-from src.ui.userInterface import launch_gui as UI
 
+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__":
+    configure("INFO")
     app = QtWidgets.QApplication(sys.argv)
     if not first_launch:
         setup = startup()
@@ -16,4 +19,4 @@ if __name__ == "__main__":
         else:
             sys.exit()
     else:
-        UI()
+        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,32 +1,36 @@
 [project]
 name = "semesterapparatsmanager"
-version = "1.0.0"
+version = "1.0.2"
 description = "Add your description here"
 readme = "README.md"
-requires-python = ">=3.12"
+requires-python = ">=3.13"
 dependencies = [
     "appdirs>=1.4.4",
-    "beautifulsoup4>=4.12.3",
+    "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",
-    "pyramid>=2.0.2",
+    "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]
@@ -34,30 +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.bumpversion]
-current_version = "1.0.0"
-parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
-serialize = ["{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 = true
-commit = true
-message = "Bump version: {current_version} → {new_version}"
-moveable_tags = []
-commit_args = ""
-setup_hooks = []
-pre_commit_hooks = []
-post_commit_hooks = []
-[[tool.bumpversion.files]]
-filename = "src/__init__.py"
-[[tool.bumpversion.files]]
-filename = ".version"
+[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,34 +1,67 @@
 __version__ = "1.0.0"
 __author__ = "Alexander Kirchner"
-__all__ = ["__version__", "__author__", "Icon", "settings"]
+__all__ = ["__author__", "__version__", "settings"]
 
 import os
-
-from appdirs import AppDirs
-
-from config import Config
+import sys
+from pathlib import Path
+from typing import Union
 
 
-app = AppDirs("SemesterApparatsManager", "SAM")
-LOG_DIR = app.user_log_dir
-CONFIG_DIR = app.user_config_dir
-if not os.path.exists(LOG_DIR):
-    os.makedirs(LOG_DIR)
-if not os.path.exists(CONFIG_DIR):
-    os.makedirs(CONFIG_DIR)
+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 = (
-    app.user_config_dir if settings.database.path is None else settings.database.path
+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 os.path.exists(DATABASE_DIR):
-    os.makedirs(DATABASE_DIR)
+if not Path(DATABASE_DIR).exists():  # type: ignore
+    os.makedirs(DATABASE_DIR)  # type: ignore
 first_launch = settings.exists
-if not os.path.exists(settings.database.temp.expanduser()):
-    settings.database.temp.expanduser().mkdir(parents=True, exist_ok=True)
-from .utils.icon import Icon
+if not Path(settings.database.temp.expanduser()).exists():  # type: ignore
+    settings.database.temp.expanduser().mkdir(parents=True, exist_ok=True)  # type: ignore
 
-if not os.path.exists("logs"):
-    os.mkdir("logs")
+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,15 +1,8 @@
 import hashlib
 import random
 
-from .database import Database
-import loguru
-import sys
-from src import LOG_DIR
-
-log = loguru.logger
-log.remove()
-log.add(sys.stdout, level="INFO")
-log.add(f"{LOG_DIR}/application.log", rotation="1 MB", retention="10 days")
+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

src/backend/__init__.py

@@ -1,8 +0,0 @@
-from .semester import Semester
-from .database import Database
-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
-from .create_file import recreateFile, recreateElsaFile

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,72 +0,0 @@
-import os
-from pathlib import Path
-
-
-from src.backend.database import Database
-
-import loguru
-import sys
-from src import LOG_DIR
-log = loguru.logger
-log.remove()
-log.add(sys.stdout, level="INFO")
-log.add(f"{LOG_DIR}/application.log", rotation="1 MB", retention="10 days")
-
-
-db = Database()
-
-def recreateFile(name: str, app_id: int, filetype: str, open: bool = 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)
-    log.info(f"File created: {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,21 +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.expanduser()
-    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,23 +0,0 @@
-from PySide6.QtCore import QThread, Slot
-from src.utils.documentation import website, QuietHandler
-from wsgiref.simple_server import make_server
-
-
-class DocumentationThread(QThread):
-    def __init__(self):
-        super().__init__()
-        self._server = None  # store server so we can shut it down
-
-    def run(self):
-        # launch_documentation()
-        self._server = make_server(
-            "localhost", 8000, website(), handler_class=QuietHandler
-        )
-        while not self.isInterruptionRequested():
-            self._server.handle_request()
-
-    @Slot()  # slot you can connect to aboutToQuit
-    def stop(self):
-        self.requestInterruption()  # ask the loop above to exit
-        if self._server:
-            self._server.shutdown()  # unblock handle_request()

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/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/threads_availchecker.py

@@ -1,80 +0,0 @@
-import time
-
-# from icecream import ic
-from PySide6.QtCore import QThread
-from PySide6.QtCore import Signal as Signal
-
-from src.backend.database import Database
-from src import LOG_DIR
-from src.logic.webrequest import BibTextTransformer, WebRequest
-
-# from src.transformers import RDS_AVAIL_DATA
-import loguru
-import sys
-
-log = loguru.logger
-log.remove()
-log.add(sys.stdout, level="INFO")
-log.add(f"{LOG_DIR}/application.log", rotation="1 MB", retention="10 days")
-
-
-
-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)
-        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
-        log.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:
-            log.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
-            log.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)
-
-        log.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,18 +1,14 @@
 import time
 
+from src.shared.logging import log
+
 # from icecream import ic
 from PySide6.QtCore import QThread
 from PySide6.QtCore import Signal as Signal
 
-from src.backend import Database
-import loguru
-import sys
-from src import LOG_DIR
-log = loguru.logger
-log.remove()
-log.add(sys.stdout, level="INFO")
-log.add(f"{LOG_DIR}/application.log", rotation="1 MB", retention="10 days")
+from src.database import Database
 
+# use centralized logging from src.shared.logging
 
 # from src.transformers import RDS_AVAIL_DATA
 
@@ -29,8 +25,8 @@ 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()
@@ -46,7 +42,7 @@ class AutoAdder(QThread):
                 time.sleep(1)
 
             except Exception as e:
-                # print(e)
+                # #print(e)
                 log.exception(
                     f"The query failed with message {e} for signature {entry}"
                 )

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

@@ -1,19 +1,13 @@
-from PySide6.QtCore import QThread
-from PySide6.QtCore import Signal
-from src.backend import Database
+from PySide6.QtCore import QThread, Signal
 
-from src.logic.webrequest import BibTextTransformer, WebRequest
-import loguru
-import sys
-from src import LOG_DIR
-log = loguru.logger
-log.remove()
-log.add(sys.stdout, level="INFO")
-log.add(f"{LOG_DIR}/application.log", rotation="1 MB", retention="10 days")
+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.add(sys.stderr, format="{time} {level} {message}", level="INFO")
-log.add(sys.stdout, level="INFO")
+# Logger configured centrally in main; this module just uses `log`
 
 
 class BookGrabber(QThread):
@@ -31,9 +25,10 @@ class BookGrabber(QThread):
         self.book_id = None
         self.use_any = False
         self.use_exact = False
-        self.app_id = None
+        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
@@ -45,13 +40,15 @@ class BookGrabber(QThread):
         self.use_any = any_book
         self.use_exact = exact
         log.info(f"Working on {len(self.data)} entries")
-        self.tstate = (self.app_id, self.prof_id, self.mode, self.data)
+        self.tstate = (self.app_nr, self.prof_id, self.mode, self.data)
         log.debug("State: " + str(self.tstate))
-        self.request.set_apparat(self.app_id)
+        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):
-        self.db = Database()
         item = 0
         iterdata = self.data
         # log.debug(iterdata)
@@ -69,12 +66,12 @@ class BookGrabber(QThread):
                 continue
 
             bd = BibTextTransformer(self.mode)
-            log.debug(webdata)
+            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()
-            log.debug(bd)
+            bloat.debug("Transformed bookdata (preview): {}", preview(bd, 1000))
             if bd is None:
                 # bd = BookData
                 continue
@@ -91,7 +88,7 @@ class BookGrabber(QThread):
             state = 0
             for result in transformer.RDS_DATA:
                 # log.debug(result.RDS_LOCATION)
-                if str(self.app_id) in result.RDS_LOCATION:
+                if str(self.app_nr) in result.RDS_LOCATION:
                     state = 1
                     break
 
@@ -126,27 +123,27 @@ class BookGrabberTest(QThread):
         self.is_Running = True
         log.info("Starting worker thread")
         self.data = None
-        self.app_id = 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_id = appnr
-        self.tstate = (self.app_id, self.prof_id, self.mode, self.data)
+        self.app_nr = appnr
+        self.tstate = (self.app_nr, self.prof_id, self.mode, self.data)
         self.results = []
 
     def add_values(
-        self, app_id: int, prof_id: int, mode: str, data, any_book=False, exact=False
+        self, app_nr: int, prof_id: int, mode: str, data, any_book=False, exact=False
     ):
-        self.app_id = app_id
+        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_id, self.prof_id, self.mode, self.data)
+        self.tstate = (self.app_nr, self.prof_id, self.mode, self.data)
         log.debug("State: " + str(self.tstate))
         # log.debug(self.tstate)
 
@@ -159,7 +156,7 @@ class BookGrabberTest(QThread):
             signature = str(entry)
             log.info("Processing entry: " + signature)
 
-            webdata = WebRequest().set_apparat(self.app_id).get_ppn(entry)
+            webdata = WebRequest().set_apparat(self.app_nr).get_ppn(entry)
             if self.use_any:
                 webdata = webdata.use_any_book
             webdata = webdata.get_data()
@@ -186,7 +183,7 @@ class BookGrabberTest(QThread):
             state = 0
             for result in transformer.RDS_DATA:
                 # log.debug(result.RDS_LOCATION)
-                if str(self.app_id) in result.RDS_LOCATION:
+                if str(self.app_nr) in result.RDS_LOCATION:
                     state = 1
                     break
 

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

@@ -1,4 +1,4 @@
-"""Semester helper class
+"""Semester helper class.
 
 A small utility around the *German* academic calendar that distinguishes
 between *Wintersemester* (WiSe) and *Sommersemester* (SoSe).
@@ -7,7 +7,7 @@ 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``.
+* 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:
 
@@ -15,31 +15,24 @@ Key points
 """
 
 from __future__ import annotations
+
 import datetime
 import re
-from dataclasses import dataclass
-import loguru
-import sys
-from src import LOG_DIR
-log = loguru.logger
-log.remove()
-log.add(sys.stdout, level="INFO")
-log.add(f"{LOG_DIR}/application.log", rotation="1 MB", retention="10 days")
+
+from src.shared.logging import log
 
 
-
-# @dataclass
 class Semester:
     """Represents a German university semester (WiSe or SoSe)."""
 
     # ------------------------------------------------------------------
-    # Class‑level defaults – will be *copied* to each instance and then
+    # Class-level defaults - will be *copied* to each instance and then
     # potentially overwritten in ``__init__``.
     # ------------------------------------------------------------------
-    _year: int | None = int(str(datetime.datetime.now().year)[2:])  # 24 → 24
-    _semester: str | None = None  # "WiSe" or "SoSe" – set later
-    _month: int | None = datetime.datetime.now().month
-    value: str | None = None  # Human‑readable label, e.g. "WiSe 23/24"
+    _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
@@ -61,11 +54,23 @@ class Semester:
 
         self.__post_init__()
 
-    def __post_init__(self) -> None:  # noqa: D401 – keep original name
-        if self._year is None:
-            self._year = int(str(datetime.datetime.now().year)[2:])
+    def __post_init__(self) -> None:
+        now = datetime.datetime.now()
+
         if self._month is None:
-            self._month = datetime.datetime.now().month
+            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()
@@ -73,7 +78,7 @@ class Semester:
     # ------------------------------------------------------------------
     # Dunder helpers
     # ------------------------------------------------------------------
-    def __str__(self) -> str:  # noqa: D401 – keep original name
+    def __str__(self) -> str:
         return self.value or "<invalid Semester>"
 
     def __repr__(self) -> str:  # Helpful for debugging lists
@@ -84,21 +89,27 @@ class Semester:
     # ------------------------------------------------------------------
     def _generate_semester_from_month(self) -> None:
         """Infer *WiSe* / *SoSe* from the month attribute."""
-        self._semester = "WiSe" if (self._month <= 3 or self._month > 9) else "SoSe"
+        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``."""
-        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}"
+        """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":
+    def offset(self, value: int) -> Semester:
         """Return a new :class:`Semester` *value* steps away.
 
         The algorithm maps every semester to a monotonically increasing
@@ -111,10 +122,12 @@ class Semester:
         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")
+            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"
@@ -123,62 +136,67 @@ class Semester:
     # ------------------------------------------------------------------
     # Comparison helpers
     # ------------------------------------------------------------------
-    def isPastSemester(self, other: "Semester") -> bool:
-        if self.year < other.year:
+    def is_past_semester(self, current: Semester) -> bool:
+        log.debug(f"Comparing {self} < {current}")
+        if self.year < current.year:
             return True
-        if self.year == other.year:
+        if self.year == current.year:
             return (
-                self.semester == "WiSe" and other.semester == "SoSe"
+                self.semester == "WiSe" and current.semester == "SoSe"
             )  # WiSe before next SoSe
         return False
 
-    def isFutureSemester(self, other: "Semester") -> bool:
-        if self.year > other.year:
+    def is_future_semester(self, current: Semester) -> bool:
+        if self.year > current.year:
             return True
-        if self.year == other.year:
+        if self.year == current.year:
             return (
-                self.semester == "SoSe" and other.semester == "WiSe"
+                self.semester == "SoSe" and current.semester == "WiSe"
             )  # SoSe after WiSe of same year
         return False
 
-    def isMatch(self, other: "Semester") -> bool:
+    def is_match(self, other: Semester) -> bool:
         return self.year == other.year and self.semester == other.semester
 
     # ------------------------------------------------------------------
     # Convenience properties
     # ------------------------------------------------------------------
     @property
-    def next(self) -> "Semester":
+    def next(self) -> Semester:
         return self.offset(1)
 
     @property
-    def previous(self) -> "Semester":
+    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]:
+    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.isFutureSemester(end) and not start.isMatch(end):
+        if start.is_future_semester(end) and not start.is_match(end):
             raise ValueError("'start' must not be after 'end'")
 
-        chain: list[Semester] = [start.value]
+        chain: list[str] = [str(start)]
         current = start
-        while not current.isMatch(end):
+        while not current.is_match(end):
             current = current.next
-            chain.append(current.value)
+            chain.append(str(current))
             if len(chain) > 1000:  # sanity guard
                 raise RuntimeError("generate_missing exceeded sane iteration limit")
         return chain
@@ -187,10 +205,10 @@ class Semester:
     # Parsing helper
     # ------------------------------------------------------------------
     @classmethod
-    def from_string(cls, s: str) -> "Semester":
-        """Parse a human‑readable semester label and return a :class:`Semester`.
+    def from_string(cls, s: str) -> Semester:
+        """Parse a human-readable semester label and return a :class:`Semester`.
 
-        Accepted formats (case‑insensitive)::
+        Accepted formats (case-insensitive)::
 
             "SoSe <YY>"            → SoSe of year YY
             "WiSe <YY>/<YY+1>"     → Winter term starting in YY
@@ -205,7 +223,7 @@ class Semester:
         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)"
+                "invalid semester string format - expected 'SoSe YY' or 'WiSe YY/YY' (spacing flexible)",
             )
 
         term_raw, y1_str, y2_str = m.groups()
@@ -215,7 +233,7 @@ class Semester:
         if term == "SoSe":
             if y2_str is not None:
                 raise ValueError(
-                    "SoSe string should not contain '/' followed by a second year"
+                    "SoSe string should not contain '/' followed by a second year",
                 )
             return cls(year, "SoSe")
 
@@ -229,14 +247,27 @@ class Semester:
         return cls(year, "WiSe")
 
 
-# ------------------------- quick self‑test -------------------------
+# ------------------------- 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])
+    # print("generate_missing:", [str(s) for s in chain])
 
     # Parsing demo ---------------------------------------------------------
-    for label in ["SoSe 6", "WiSe 6/7", "wise 23/24", "WiSe 9"]:
-        print("from_string:", label, "→", Semester.from_string(label))
+    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

@@ -101,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/__init__.py

@@ -0,0 +1 @@
+

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, word_to_semap, SemapDocument
-from .zotero import ZoteroController
+
+__all__ = [
+    "custom_sort",
+    "sort_semesters_list",
+]

src/logic/c_sort.py

@@ -1,36 +1,4 @@
-def parse_semester(semester: str):
-    """
-    Parses the semester string into a sortable format.
-    Returns a tuple of (year, type), where type is 0 for SoSe and 1 for WiSe.
-    """
-    if semester.startswith("SoSe"):
-        return int(semester.split()[1]), 0
-    elif semester.startswith("WiSe"):
-        year_part = semester.split()[1]
-        start_year, _ = map(int, year_part.split("/"))
-        return start_year, 1
-    else:
-        raise ValueError(f"Invalid semester format: {semester}")
-
-
-def custom_sort(entries):
-    """
-    Sorts the list of tuples based on the custom schema.
-
-    :param entries: List of tuples in the format (str, int, int).
-    :return: Sorted list of tuples.
-    """
-    return sorted(
-        entries,
-        key=lambda entry: (
-            parse_semester(entry[0]),  # Sort by semester parsed as (year, type)
-            entry[1],  # Then by the second element of the tuple
-            entry[2],  # Finally by the third element of the tuple
-        ),
-    )
-
-
-def parse_semester(semester: str):
+def parse_semester(semester: str) -> tuple[int, int]:
     """
     Parses the semester string into a sortable format.
     Returns a tuple of (year, type), where type is 0 for SoSe and 1 for WiSe.
@@ -48,6 +16,23 @@ def parse_semester(semester: str):
         raise ValueError(f"Invalid semester format: {semester}")
 
 
+def custom_sort(entries) -> list:
+    """
+    Sorts the list of tuples based on the custom schema.
+
+    :param entries: List of tuples in the format (str, int, int).
+    :return: Sorted list of tuples.
+    """
+    return sorted(
+        entries,
+        key=lambda entry: (
+            parse_semester(entry[0]),  # Sort by semester parsed as (year, type)
+            entry[1],  # Then by the second element of the tuple
+            entry[2],  # Finally by the third element of the tuple
+        ),
+    )
+
+
 def sort_semesters_list(semesters: list) -> list:
     """
     Sorts a list of semester strings based on year and type.
@@ -83,4 +68,4 @@ if __name__ == "__main__":
         "SoSe 25",
     ]
 
-    print(sort_semesters_list(unsorted))
+    # print(sort_semesters_list(unsorted))

src/logic/constants.py

@@ -1,213 +0,0 @@
-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/logic/csvparser.py

@@ -1,23 +0,0 @@
-import csv
-
-import chardet
-
-
-def csv_to_list(path: str) -> list[str]:
-    """
-    Extracts the data from a csv file and returns it as a pandas dataframe
-    """
-    encoding = chardet.detect(open(path, "rb").read())["encoding"]
-    with open(path, newline="", encoding=encoding) as csvfile:
-        # if decoder fails to map, assign ""
-        reader = csv.reader(csvfile, delimiter=";", quotechar="|")
-        ret = []
-        for row in reader:
-            ret.append(row[0].replace('"', ""))
-        return ret
-
-
-if __name__ == "__main__":
-    text = csv_to_list("C:/Users/aky547/Desktop/semap/71.csv")
-    # remove linebreaks
-    # print(text)

src/logic/dataclass.py

@@ -1,206 +0,0 @@
-from dataclasses import dataclass, field
-
-from enum import Enum
-import json
-from typing import Union, Any, Optional
-
-@dataclass
-class Prof:
-    id: Optional[int] = None
-    _title: Optional[str] = None
-    firstname: Optional[str] = None
-    lastname: Optional[str] = None
-    fullname: Optional[str] = None
-    mail: Optional[str] = None
-    telnr: Optional[str] = None
-
-    # add function that sets the data based on a dict
-    def from_dict(self, data: dict[str, Union[str, int]]):
-        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[str, int], ...]):
-        setattr(self, "id", data[0])
-        setattr(self, "_title", data[1])
-        setattr(self, "firstname", data[2])
-        setattr(self, "lastname", data[3])
-        setattr(self, "fullname", data[4])
-        setattr(self, "mail", data[5])
-        setattr(self, "telnr", data[6])
-        return self
-
-    def name(self, comma: bool = False) -> Optional[str]:
-        if self.firstname is None and self.lastname is None:
-            if "," in self.fullname:
-                self.firstname = self.fullname.split(",")[1].strip()
-                self.lastname = self.fullname.split(",")[0].strip()
-            else:
-                return self.fullname
-
-        if comma:
-            return f"{self.lastname}, {self.firstname}"
-        return f"{self.lastname} {self.firstname}"
-
-
-@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: str | None = None
-    pages: str | None = None
-    library_location: int | None = None
-    in_apparat: bool | None = False
-    adis_idn: str | None = None
-
-    def from_dict(self, data: dict) -> "BookData":
-        for key, value in data.items():
-            setattr(self, key, value)
-        return self
-
-    @property
-    def to_dict(self) -> str:
-        """Convert the dataclass to a dictionary."""
-        return json.dumps(self.__dict__, ensure_ascii=False)
-
-    def from_dataclass(self, dataclass: Optional[Any]) -> None:
-        if dataclass is None:
-            return
-        for key, value in dataclass.__dict__.items():
-            setattr(self, key, value)
-
-    def from_string(self, data: str) -> "BookData":
-        ndata = json.loads(data)
-        return BookData(**ndata)
-
-
-@dataclass
-class MailData:
-    subject: Optional[str] = None
-    body: Optional[str] = None
-    mailto: Optional[str] = None
-    prof: Optional[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 name(self) -> str:
-        return self.value[1]
-
-    @classmethod
-    def get_index(cls, name: str) -> Optional[int]:
-        for i in cls:
-            if i.name == name:
-                return i.id - 1
-
-
-@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
-        else:
-            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)

src/logic/fileparser.py

@@ -1,45 +0,0 @@
-import csv
-
-import pandas as pd
-from docx import Document
-
-
-def csv_to_list(path: str) -> list[str]:
-    """
-    Extracts the data from a csv file and returns it as a pandas dataframe
-    """
-    with open(path, newline="") as csvfile:
-        reader = csv.reader(csvfile, delimiter=";", quotechar="|")
-        data = []
-        for row in reader:
-            for i in range(len(row)):
-                row[i] = row[i].replace('"', "")
-            data.append(row)
-        ret = []
-        for i in data:
-            ret.append(i[0])
-        return ret
-
-
-def word_docx_to_csv(path) -> pd.DataFrame:
-    doc = Document(path)
-    tables = doc.tables
-
-    m_data = []
-    for table in tables:
-        data = []
-        for row in table.rows:
-            row_data = []
-            for cell in row.cells:
-                text = cell.text
-                text = text.replace("\n", "")
-                row_data.append(text)
-            data.append(row_data)
-        df = pd.DataFrame(data)
-        df.columns = df.iloc[0]
-        df = df.iloc[1:]
-
-        m_data.append(df)
-
-    df = m_data[2]
-    return df

src/logic/settings.py

@@ -1,24 +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
-    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)
-
-
-# open the config file and load the settings
-with open("config.yaml", "r") as f:
-    data = yaml.safe_load(f)

src/logic/wordparser.py

@@ -1,315 +0,0 @@
-import sys
-import zipfile
-from dataclasses import dataclass
-from typing import Any, Union
-
-import loguru
-import pandas as pd
-from bs4 import BeautifulSoup
-from docx import Document
-
-from src import LOG_DIR
-from src.backend import Semester
-from src.logic.openai import name_tester, run_shortener, semester_converter
-
-log = loguru.logger
-log.remove()
-log.add(sys.stdout, level="INFO")
-log.add(f"{LOG_DIR}/application.log", rotation="1 MB", retention="10 days")
-
-
-
-letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
-
-
-@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
-    phoneNumber: int = None
-    mail: str = None
-    title: str = None
-    title_suggestions: list[str] = None
-    semester: Union[str, Semester] = None
-    books: list[Book] = None
-    eternal: bool = False
-    personName: str = None
-    personTitle: str = None
-    title_length = 0
-    title_max_length = 0
-
-    def __post_init__(self):
-        self.title_suggestions = []
-
-    @property
-    def nameSetter(self):
-        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:
-            log.warning("Title is too long")
-            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 = []
-        pass
-    @property
-    def renameSemester(self) -> None:
-        if ", Dauer" in self.semester:
-            self.semester = self.semester.split(",")[0]
-            self.eternal = True
-            self.semester = Semester().from_string(self.semester)
-        else:
-            log.warning("Semester {} is not valid", self.semester)
-            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 []
-
-
-def word_docx_to_csv(path: str) -> list[pd.DataFrame]:
-    doc = Document(path)
-    tables = doc.tables
-    m_data = []
-    for table in tables:
-        data = []
-        for row in table.rows:
-            row_data: list[Any] = []
-            for cell in row.cells:
-                text = cell.text
-
-                text = text.replace("\n", "")
-                row_data.append(text)
-                if text == "Ihr Fach:":
-                    row_data.append(get_fach(path))
-            data.append(row_data)
-        df = pd.DataFrame(data)
-        df.columns = df.iloc[0]
-        df = df.iloc[1:]
-
-        m_data.append(df)
-
-    return m_data
-
-
-def get_fach(path: str) -> str:
-    document = zipfile.ZipFile(path)
-    xml_data = document.read("word/document.xml")
-    document.close()
-
-    soup = BeautifulSoup(xml_data, "xml")
-    # text we need is in <w:p w14:paraId="12456A32" ... > -> w:r -> w:t
-    paragraphs = soup.find_all("w:p")
-    names = []
-    for para in paragraphs:
-        para_id = para.get("w14:paraId")
-        if para_id == "12456A32":
-            # get the data in the w:t
-            for run in para.find_all("w:r"):
-                data = run.find("w:t")
-                return data.contents[0]
-
-
-def makeDict():
-    return {
-        "work_author": None,
-        "section_author": None,
-        "year": None,
-        "edition": None,
-        "work_title": None,
-        "chapter_title": None,
-        "location": None,
-        "publisher": None,
-        "signature": None,
-        "issue": None,
-        "pages": None,
-        "isbn": None,
-        "type": None,
-    }
-
-
-def tuple_to_dict(tlist: tuple, type: str) -> dict:
-    ret = []
-    for line in tlist:
-        data = makeDict()
-        if type == "Monografien":
-            data["type"] = type
-            data["work_author"] = line[0]
-            data["year"] = line[1]
-            data["edition"] = line[2]
-            data["work_title"] = line[3]
-            data["location"] = line[4]
-            data["publisher"] = line[5]
-            data["signature"] = line[6]
-            data["pages"] = line[7]
-        elif type == "Herausgeberwerke":
-            data["type"] = type
-            data["section_author"] = line[0]
-            data["year"] = line[1]
-            data["edition"] = line[2]
-            data["chapter_title"] = line[3]
-            data["work_author"] = line[4]
-            data["work_title"] = line[5]
-            data["location"] = line[6]
-            data["publisher"] = line[7]
-            data["signature"] = line[9]
-            data["pages"] = line[8]
-        elif type == "Zeitschriftenaufsätze":
-            data["type"] = type
-            data["section_author"] = line[0]
-            data["year"] = line[1]
-            data["issue"] = line[2]
-            data["chapter_title"] = line[3]
-            data["work_title"] = line[4]
-            data["location"] = line[5]
-            data["publisher"] = line[6]
-            data["signature"] = line[8]
-            data["pages"] = line[7]
-        ret.append(data)
-    return ret
-
-
-def elsa_word_to_csv(path: str):
-    doc = Document(path)
-    # # print all lines in doc
-    doctype = [para.text for para in doc.paragraphs if para.text != ""][-1]
-    tuples = {
-        "Monografien": ("", "", "", "", "", "", "", "", ""),
-        "Herausgeberwerke": ("", "", "", "", "", "", "", "", "", "", ""),
-        "Zeitschriftenaufsätze": ("", "", "", "", "", "", "", "", "", ""),
-    }
-    tables = doc.tables
-
-    m_data: list[pd.DataFrame] = []
-    for table in tables:
-        data: list[list[str]] = []
-        for row in table.rows:
-            row_data: list[str] = []
-            for cell in row.cells:
-                text = cell.text
-                text = text.replace("\n", "")
-                text = text.replace("\u2002", "")
-                row_data.append(text)
-            data.append(row_data)
-        df = pd.DataFrame(data)
-        df.columns = df.iloc[0]
-        df = df.iloc[1:]
-        m_data.append(df)
-    df = m_data[0]
-    # split df to rows
-    data = [
-        row for row in df.itertuples(index=False, name=None) if row != tuples[doctype]
-    ]
-    # log.debug(data)
-    return tuple_to_dict(data, doctype), doctype
-
-
-def word_to_semap(word_path: str) -> SemapDocument:
-    log.info("Parsing Word Document {}", word_path)
-    semap = SemapDocument()
-    df = word_docx_to_csv(word_path)
-    apparatdata = df[0]
-    apparatdata = apparatdata.to_dict()
-    keys = list(apparatdata.keys())
-    print(apparatdata, keys)
-
-    appdata = {keys[i]: keys[i + 1] for i in range(0, len(keys) - 1, 2)}
-    semap.phoneNumber = appdata["Telefon:"]
-    semap.subject = appdata["Ihr Fach:"]
-    semap.mail = appdata["Mailadresse:"]
-    semap.personName = ",".join(appdata["Ihr Name und Titel:"].split(",")[:-1])
-    semap.personTitle = ",".join(appdata["Ihr Name und Titel:"].split(",")[-1:]).strip()
-    apparatdata = df[1]
-    apparatdata = apparatdata.to_dict()
-    keys = list(apparatdata.keys())
-    appdata = {keys[i]: keys[i + 1] for i in range(0, len(keys), 2)}
-    semap.title = appdata["Veranstaltung:"]
-    semap.semester = appdata["Semester:"]
-    semap.renameSemester
-    semap.nameSetter
-
-    books = df[2]
-    booklist = []
-    for i in range(len(books)):
-        if books.iloc[i].isnull().all():
-            continue
-        data = books.iloc[i].to_dict()
-        book = Book()
-        book.from_dict(data)
-        if book.is_empty:
-            continue
-        elif not book.has_signature:
-            continue
-        else:
-            booklist.append(book)
-    log.info("Found {} books", len(booklist))
-    semap.books = booklist
-    return semap
-
-
-if __name__ == "__main__":
-    else_df = elsa_word_to_csv(
-        "C:/Users/aky547/Desktop/ELSA_Bestellung Scann Der Westen und der Rest.docx"
-    )
-    print(else_df)

src/parsers/__init__.py

@@ -0,0 +1,15 @@
+__all__ = [
+    "csv_to_list",
+    "elsa_word_to_csv",
+    "eml_parser",
+    "eml_to_semap",
+    "pdf_to_csv",
+    "pdf_to_semap",
+    "word_to_semap",
+]
+
+
+from .csv_parser import csv_to_list
+from .pdf_parser import pdf_to_csv
+from .word_parser import elsa_word_to_csv, pdf_to_semap, word_to_semap
+from .xml_parser import eml_parser, eml_to_semap

src/parsers/csv_parser.py

@@ -0,0 +1,28 @@
+import csv
+from pathlib import Path
+
+from charset_normalizer import detect
+
+from src.core.models import Book, SemapDocument
+
+
+def csv_to_list(path: str) -> SemapDocument:
+    """Extract the data from a csv file and return it as a minimal SemapDocument."""
+    encoding = detect(open(path, "rb").read())["encoding"]
+    with Path(path).open(newline="", encoding=encoding) as csvfile:
+        # if decoder fails to map, assign ""
+        reader = csv.reader(csvfile, delimiter=";", quotechar="|")
+        ret = []
+        for row in reader:
+            ret.append(row[0].replace('"', ""))
+
+        books = [Book(signature=row) for row in ret]
+
+        return SemapDocument(books=books)
+
+
+if __name__ == "__main__":
+    text = csv_to_list("C:/Users/aky547/Desktop/semap/sap71.csv")
+    # remove linebreaks
+    # debug: print result when running as script
+    # print(text)

src/parsers/pdf_parser.py

@@ -1,10 +1,9 @@
 # add depend path to system path
 
-import pandas as pd
 from pdfquery import PDFQuery
 
 
-def pdf_to_csv(path: str) -> pd.DataFrame:
+def pdf_to_csv(path: str) -> str:
     """
     Extracts the data from a pdf file and returns it as a pandas dataframe
     """
@@ -21,4 +20,4 @@ if __name__ == "__main__":
     text = pdf_to_csv("54_pdf.pdf")
     # remove linebreaks
     text = text.replace("\n", "")
-    print(text)
+    # print(text)

src/parsers/transformers/__init__.py

@@ -0,0 +1,16 @@
+from .transformers import (
+    RDS_AVAIL_DATA,
+    ARRAYData,
+    BibTeXData,
+    COinSData,
+    RDSData,
+    RISData,
+)
+
+# Explicit re-exports to avoid F401 warnings
+RDS_AVAIL_DATA = RDS_AVAIL_DATA
+ARRAYData = ARRAYData
+BibTeXData = BibTeXData
+COinSData = COinSData
+RDSData = RDSData
+RISData = RISData

src/parsers/transformers/schemas.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+from typing import Optional, Any, List
+from dataclasses import dataclass
+from dataclasses import field as dataclass_field
+import json
+
+
+@dataclass
+class Item:
+    superlocation: str | None = dataclass_field(default_factory=str)
+    status: str | None = dataclass_field(default_factory=str)
+    availability: str | None = dataclass_field(default_factory=str)
+    notes: str | None = dataclass_field(default_factory=str)
+    limitation: str | None = dataclass_field(default_factory=str)
+    duedate: str | None = dataclass_field(default_factory=str)
+    id: str | None = dataclass_field(default_factory=str)
+    item_id: str | None = dataclass_field(default_factory=str)
+    ilslink: str | None = dataclass_field(default_factory=str)
+    number: int | None = dataclass_field(default_factory=int)
+    barcode: str | None = dataclass_field(default_factory=str)
+    reserve: str | None = dataclass_field(default_factory=str)
+    callnumber: str | None = dataclass_field(default_factory=str)
+    department: str | None = dataclass_field(default_factory=str)
+    locationhref: str | None = dataclass_field(default_factory=str)
+    location: str | None = dataclass_field(default_factory=str)
+
+    def from_dict(self, data: dict):
+        """Import data from dict"""
+        data = data["items"]
+        for entry in data:
+            for key, value in entry.items():
+                setattr(self, key, value)
+        return self
+
+
+@dataclass
+class RDS_AVAIL_DATA:
+    """Class to store RDS availability data"""
+
+    library_sigil: str = dataclass_field(default_factory=str)
+    items: List[Item] = dataclass_field(default_factory=list)
+
+    def import_from_dict(self, data: str):
+        """Import data from dict"""
+        edata = json.loads(data)
+        # library sigil is first key
+
+        self.library_sigil = str(list(edata.keys())[0])
+        # get data from first key
+        edata = edata[self.library_sigil]
+        for location in edata:
+            item = Item(superlocation=location).from_dict(edata[location])
+
+            self.items.append(item)
+        return self
+
+
+@dataclass
+class RDS_DATA:
+    """Class to store RDS data"""
+
+    RDS_SIGNATURE: str = dataclass_field(default_factory=str)
+    RDS_STATUS: str = dataclass_field(default_factory=str)
+    RDS_LOCATION: str = dataclass_field(default_factory=str)
+    RDS_URL: Any = dataclass_field(default_factory=str)
+    RDS_HINT: Any = dataclass_field(default_factory=str)
+    RDS_COMMENT: Any = dataclass_field(default_factory=str)
+    RDS_HOLDING: Any = dataclass_field(default_factory=str)
+    RDS_HOLDING_LEAK: Any = dataclass_field(default_factory=str)
+    RDS_INTERN: Any = dataclass_field(default_factory=str)
+    RDS_PROVENIENCE: Any = dataclass_field(default_factory=str)
+    RDS_LOCAL_NOTATION: str = dataclass_field(default_factory=str)
+    RDS_LEA: Any = dataclass_field(default_factory=str)
+
+    def import_from_dict(self, data: dict) -> RDS_DATA:
+        """Import data from dict"""
+        for key, value in data.items():
+            setattr(self, key, value)
+        return self
+
+
+@dataclass
+class RDS_GENERIC_DATA:
+    LibrarySigil: str = dataclass_field(default_factory=str)
+    RDS_DATA: List[RDS_DATA] = dataclass_field(default_factory=list)
+
+    def import_from_dict(self, data: str) -> RDS_GENERIC_DATA:
+        """Import data from dict"""
+        edata = json.loads(data)
+        # library sigil is first key
+        self.LibrarySigil = str(list(edata.keys())[0])
+        # get data from first key
+        edata = edata[self.LibrarySigil]
+        for entry in edata:
+            rds_data = RDS_DATA()  # Create a new RDS_DATA instance
+            # Populate the RDS_DATA instance from the entry
+            # This assumes that the entry is a dictionary that matches the structure of the RDS_DATA class
+            rds_data.import_from_dict(entry)
+            self.RDS_DATA.append(rds_data)  # Add the RDS_DATA instance to the list
+        return self
+
+
+@dataclass
+class LoksatzData:
+    type: Optional[str] = None
+    adis_idn: Optional[str] = None
+    t_idn: Optional[str] = None
+    ktrl_nr: Optional[str] = None
+    adis_isil: Optional[str] = None
+    adis_sigel: Optional[str] = None
+    bib_sigel: Optional[str] = None
+    standort: Optional[str] = None
+    signatur: Optional[str] = None
+    ausleihcode: Optional[str] = None
+    sig_katalog: Optional[str] = None
+    erwerb_datum: Optional[str] = None
+    medientypcode: Optional[str] = None
+    bestellart: Optional[str] = None
+    faecherstatistik: Optional[str] = None
+    exemplar_stat: Optional[str] = None
+    so_standort: Optional[str] = None