admin.schubert/Validation_Suite
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Compare commits

base: admin.schubert:main
Branches Tags
admin.schubert:main
admin.schubert:v2.7.2
admin.schubert:v2.7.1
admin.schubert:v2.5.0
admin.schubert:v2.2.0
..
compare: admin.schubert:v2.2.0
Branches Tags
admin.schubert:main
admin.schubert:v2.7.2
admin.schubert:v2.7.1
admin.schubert:v2.5.0
admin.schubert:v2.2.0

No commits in common. "main" and "v2.2.0" have entirely different histories.
main ... v2.2.0

28941 changed files with 500 additions and 4368154 deletions
Download patch file Download diff file Expand all files Collapse all files

4
validation-suite/.env
View file

@ -1,4 +0,0 @@
AUTH_COOKIE_SECURE=false
AUTH_COOKIE_NAME=atlas_access_token
AUTH_COOKIE_SAMESITE=lax
MERCURY_INTERNAL_URL=http://mercury-api:8000

4
validation-suite/.env.example
View file

@ -6,7 +6,3 @@ JWT_SECRET=replace-this-secret
ADMIN_EMAIL=admin@schubamed.de
ADMIN_PASSWORD=ValidationSuite!2026
NEXT_PUBLIC_API_BASE_URL=http://localhost:8000/api/v1
AUTH_COOKIE_NAME=atlas_access_token
AUTH_COOKIE_SECURE=false
AUTH_COOKIE_SAMESITE=lax
MERCURY_INTERNAL_URL=http://mercury-api:8000

7
validation-suite/backend/mercury/Dockerfile
View file

@ -7,17 +7,15 @@ ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONPATH=/app
RUN apt-get update \
&& apt-get install -y --no-install-recommends build-essential libpq-dev libcairo2 pango1.0-tools libpango-1.0-0 libgdk-pixbuf-2.0-0 libglib2.0-0 libffi-dev shared-mime-info \
&& apt-get install -y --no-install-recommends build-essential libpq-dev libcairo2 pango1.0-tools libpango-1.0-0 libgdk-pixbuf-2.0-0 libffi-dev \
&& rm -rf /var/lib/apt/lists/*
COPY pyproject.toml .
RUN pip install --no-cache-dir ".[dev]"
RUN pip install --no-cache-dir .
COPY alembic.ini .
COPY alembic ./alembic
COPY app ./app
COPY tests ./tests
COPY docs ./docs
COPY docker-entrypoint.sh /docker-entrypoint.sh
RUN chmod +x /docker-entrypoint.sh
@ -25,3 +23,4 @@ RUN chmod +x /docker-entrypoint.sh
EXPOSE 8000
ENTRYPOINT ["/docker-entrypoint.sh"]
CMD ["gunicorn", "app.main:app", "-k", "uvicorn.workers.UvicornWorker", "--bind", "0.0.0.0:8000", "--workers", "2"]

3
validation-suite/backend/mercury/alembic/env.py
View file

@ -7,7 +7,7 @@ from sqlalchemy import engine_from_config, pool
from app.core.config import settings
from app.db.base import Base
from app.models import contact, customer, device, document, equipment, location, program, report_settings, user, validation
from app.models import contact, customer, device, document, equipment, location, program, user, validation
config = context.config
config.set_main_option("sqlalchemy.url", settings.database_url)
@ -45,3 +45,4 @@ if context.is_offline_mode():
run_migrations_offline()
else:
run_migrations_online()

42
validation-suite/backend/mercury/alembic/versions/202607110001_validation_workflow.py
View file

@ -1,42 +0,0 @@
from __future__ import annotations
from alembic import op
revision = "202607110001"
down_revision = "202607100002"
branch_labels = None
depends_on = None
def upgrade() -> None:
op.execute("ALTER TABLE validations ALTER COLUMN status TYPE varchar(40) USING status::text")
op.execute(
"""
UPDATE validations
SET status = CASE status
WHEN 'draft' THEN 'ENTWURF'
WHEN 'ready_for_report' THEN 'BEREIT_ZUR_PRUEFUNG'
WHEN 'in_progress' THEN 'IN_PRUEFUNG'
WHEN 'completed' THEN 'ABGESCHLOSSEN'
ELSE status
END
"""
)
op.execute("ALTER TABLE validations ALTER COLUMN status SET DEFAULT 'ENTWURF'")
def downgrade() -> None:
op.execute(
"""
UPDATE validations
SET status = CASE status
WHEN 'ENTWURF' THEN 'draft'
WHEN 'BEREIT_ZUR_PRUEFUNG' THEN 'ready_for_report'
WHEN 'IN_PRUEFUNG' THEN 'in_progress'
WHEN 'FREIGEGEBEN' THEN 'ready_for_report'
WHEN 'ABGESCHLOSSEN' THEN 'completed'
WHEN 'STORNIERT' THEN 'completed'
ELSE status
END
"""
)

25
validation-suite/backend/mercury/alembic/versions/202607110002_revalidation_versioning.py
View file

@ -1,25 +0,0 @@
from __future__ import annotations
from alembic import op
import sqlalchemy as sa
revision = "202607110002"
down_revision = "202607110001"
branch_labels = None
depends_on = None
def upgrade() -> None:
op.add_column("validations", sa.Column("revalidation_interval_months", sa.Integer(), nullable=False, server_default="24"))
op.add_column("validations", sa.Column("next_validation_manually_overridden", sa.Boolean(), nullable=False, server_default=sa.false()))
op.add_column("validations", sa.Column("version", sa.Integer(), nullable=False, server_default="1"))
op.add_column("validations", sa.Column("previous_validation_id", sa.String(), nullable=True))
op.create_foreign_key("fk_validations_previous_validation_id_validations", "validations", "validations", ["previous_validation_id"], ["id"])
def downgrade() -> None:
op.drop_constraint("fk_validations_previous_validation_id_validations", "validations", type_="foreignkey")
op.drop_column("validations", "previous_validation_id")
op.drop_column("validations", "version")
op.drop_column("validations", "next_validation_manually_overridden")
op.drop_column("validations", "revalidation_interval_months")

139
validation-suite/backend/mercury/alembic/versions/202607110003_report_templates_helios_imports.py
View file

@ -1,139 +0,0 @@
from __future__ import annotations
from alembic import op
import sqlalchemy as sa
revision = "202607110003"
down_revision = "202607110002"
branch_labels = None
depends_on = None
def upgrade() -> None:
op.create_table(
"report_templates",
sa.Column("template_key", sa.String(length=120), nullable=False),
sa.Column("name", sa.String(length=180), nullable=False),
sa.Column("version", sa.String(length=40), nullable=False),
sa.Column("validation_type", sa.String(length=120), nullable=False),
sa.Column("reference_path", sa.String(length=500), nullable=False),
sa.Column("active", sa.Boolean(), nullable=False),
sa.Column("id", sa.String(), nullable=False),
sa.Column("created_at", sa.DateTime(timezone=True), server_default=sa.text("now()"), nullable=False),
sa.Column("updated_at", sa.DateTime(timezone=True), server_default=sa.text("now()"), nullable=False),
sa.PrimaryKeyConstraint("id", name=op.f("pk_report_templates")),
sa.UniqueConstraint("template_key", name=op.f("uq_report_templates_template_key")),
)
op.create_index(op.f("ix_report_templates_active"), "report_templates", ["active"], unique=False)
op.create_index(op.f("ix_report_templates_template_key"), "report_templates", ["template_key"], unique=False)
op.create_index(op.f("ix_report_templates_validation_type"), "report_templates", ["validation_type"], unique=False)
op.create_table(
"text_blocks",
sa.Column("template_id", sa.String(), nullable=False),
sa.Column("block_key", sa.String(length=160), nullable=False),
sa.Column("title", sa.String(length=240), nullable=False),
sa.Column("content", sa.Text(), nullable=False),
sa.Column("order_index", sa.Integer(), nullable=False),
sa.Column("version", sa.String(length=40), nullable=False),
sa.Column("active", sa.Boolean(), nullable=False),
sa.Column("id", sa.String(), nullable=False),
sa.Column("created_at", sa.DateTime(timezone=True), server_default=sa.text("now()"), nullable=False),
sa.Column("updated_at", sa.DateTime(timezone=True), server_default=sa.text("now()"), nullable=False),
sa.ForeignKeyConstraint(["template_id"], ["report_templates.id"], name=op.f("fk_text_blocks_template_id_report_templates")),
sa.PrimaryKeyConstraint("id", name=op.f("pk_text_blocks")),
)
op.create_index(op.f("ix_text_blocks_active"), "text_blocks", ["active"], unique=False)
op.create_index(op.f("ix_text_blocks_block_key"), "text_blocks", ["block_key"], unique=False)
op.create_index(op.f("ix_text_blocks_template_id"), "text_blocks", ["template_id"], unique=False)
op.create_table(
"report_sections",
sa.Column("template_id", sa.String(), nullable=False),
sa.Column("section_key", sa.String(length=160), nullable=False),
sa.Column("number", sa.String(length=40), nullable=True),
sa.Column("title", sa.String(length=240), nullable=False),
sa.Column("order_index", sa.Integer(), nullable=False),
sa.Column("page_break_before", sa.Boolean(), nullable=False),
sa.Column("active", sa.Boolean(), nullable=False),
sa.Column("id", sa.String(), nullable=False),
sa.Column("created_at", sa.DateTime(timezone=True), server_default=sa.text("now()"), nullable=False),
sa.Column("updated_at", sa.DateTime(timezone=True), server_default=sa.text("now()"), nullable=False),
sa.ForeignKeyConstraint(["template_id"], ["report_templates.id"], name=op.f("fk_report_sections_template_id_report_templates")),
sa.PrimaryKeyConstraint("id", name=op.f("pk_report_sections")),
)
op.create_index(op.f("ix_report_sections_active"), "report_sections", ["active"], unique=False)
op.create_index(op.f("ix_report_sections_section_key"), "report_sections", ["section_key"], unique=False)
op.create_index(op.f("ix_report_sections_template_id"), "report_sections", ["template_id"], unique=False)
op.create_table(
"checklist_templates",
sa.Column("template_id", sa.String(), nullable=False),
sa.Column("checklist_key", sa.String(length=160), nullable=False),
sa.Column("title", sa.String(length=240), nullable=False),
sa.Column("columns", sa.JSON(), nullable=False),
sa.Column("items", sa.JSON(), nullable=False),
sa.Column("order_index", sa.Integer(), nullable=False),
sa.Column("active", sa.Boolean(), nullable=False),
sa.Column("id", sa.String(), nullable=False),
sa.Column("created_at", sa.DateTime(timezone=True), server_default=sa.text("now()"), nullable=False),
sa.Column("updated_at", sa.DateTime(timezone=True), server_default=sa.text("now()"), nullable=False),
sa.ForeignKeyConstraint(["template_id"], ["report_templates.id"], name=op.f("fk_checklist_templates_template_id_report_templates")),
sa.PrimaryKeyConstraint("id", name=op.f("pk_checklist_templates")),
)
op.create_index(op.f("ix_checklist_templates_active"), "checklist_templates", ["active"], unique=False)
op.create_index(op.f("ix_checklist_templates_checklist_key"), "checklist_templates", ["checklist_key"], unique=False)
op.create_index(op.f("ix_checklist_templates_template_id"), "checklist_templates", ["template_id"], unique=False)
op.create_table(
"measurement_imports",
sa.Column("validation_id", sa.String(), nullable=False),
sa.Column("import_type", sa.String(length=60), nullable=False),
sa.Column("original_filename", sa.String(length=255), nullable=False),
sa.Column("storage_path", sa.String(length=500), nullable=False),
sa.Column("sha256", sa.String(length=64), nullable=False),
sa.Column("parser_version", sa.String(length=40), nullable=False),
sa.Column("status", sa.String(length=60), nullable=False),
sa.Column("id", sa.String(), nullable=False),
sa.Column("created_at", sa.DateTime(timezone=True), server_default=sa.text("now()"), nullable=False),
sa.Column("updated_at", sa.DateTime(timezone=True), server_default=sa.text("now()"), nullable=False),
sa.ForeignKeyConstraint(["validation_id"], ["validations.id"], name=op.f("fk_measurement_imports_validation_id_validations")),
sa.PrimaryKeyConstraint("id", name=op.f("pk_measurement_imports")),
)
op.create_index(op.f("ix_measurement_imports_import_type"), "measurement_imports", ["import_type"], unique=False)
op.create_index(op.f("ix_measurement_imports_sha256"), "measurement_imports", ["sha256"], unique=False)
op.create_index(op.f("ix_measurement_imports_status"), "measurement_imports", ["status"], unique=False)
op.create_index(op.f("ix_measurement_imports_validation_id"), "measurement_imports", ["validation_id"], unique=False)
op.create_table(
"measurement_import_values",
sa.Column("import_id", sa.String(), nullable=False),
sa.Column("test_run", sa.String(length=120), nullable=False),
sa.Column("field_name", sa.String(length=120), nullable=False),
sa.Column("raw_value", sa.Text(), nullable=True),
sa.Column("normalized_value", sa.String(length=180), nullable=True),
sa.Column("unit", sa.String(length=40), nullable=True),
sa.Column("source_page", sa.Integer(), nullable=True),
sa.Column("source_text", sa.Text(), nullable=True),
sa.Column("confidence", sa.Integer(), nullable=False),
sa.Column("confirmed", sa.Boolean(), nullable=False),
sa.Column("corrected_value", sa.String(length=180), nullable=True),
sa.Column("id", sa.String(), nullable=False),
sa.Column("created_at", sa.DateTime(timezone=True), server_default=sa.text("now()"), nullable=False),
sa.Column("updated_at", sa.DateTime(timezone=True), server_default=sa.text("now()"), nullable=False),
sa.ForeignKeyConstraint(["import_id"], ["measurement_imports.id"], name=op.f("fk_measurement_import_values_import_id_measurement_imports")),
sa.PrimaryKeyConstraint("id", name=op.f("pk_measurement_import_values")),
)
op.create_index(op.f("ix_measurement_import_values_confirmed"), "measurement_import_values", ["confirmed"], unique=False)
op.create_index(op.f("ix_measurement_import_values_field_name"), "measurement_import_values", ["field_name"], unique=False)
op.create_index(op.f("ix_measurement_import_values_import_id"), "measurement_import_values", ["import_id"], unique=False)
op.create_index(op.f("ix_measurement_import_values_test_run"), "measurement_import_values", ["test_run"], unique=False)
def downgrade() -> None:
op.drop_table("measurement_import_values")
op.drop_table("measurement_imports")
op.drop_table("checklist_templates")
op.drop_table("report_sections")
op.drop_table("text_blocks")
op.drop_table("report_templates")

36
validation-suite/backend/mercury/alembic/versions/202607110004_users_password_management.py
View file

@ -1,36 +0,0 @@
from __future__ import annotations
from alembic import op
import sqlalchemy as sa
revision = "202607110004"
down_revision = "202607110003"
branch_labels = None
depends_on = None
def upgrade() -> None:
op.add_column("users", sa.Column("first_name", sa.String(length=80), nullable=True))
op.add_column("users", sa.Column("last_name", sa.String(length=80), nullable=True))
op.add_column("users", sa.Column("must_change_password", sa.Boolean(), nullable=False, server_default=sa.true()))
op.add_column("users", sa.Column("last_login_at", sa.DateTime(timezone=True), nullable=True))
op.add_column("users", sa.Column("password_changed_at", sa.DateTime(timezone=True), nullable=True))
op.execute(
sa.text(
"UPDATE users SET first_name = COALESCE(first_name, split_part(full_name, ' ', 1)), "
"last_name = COALESCE(last_name, NULLIF(substr(full_name, length(split_part(full_name, ' ', 1)) + 2), ''))"
)
)
op.execute(sa.text("UPDATE users SET first_name = COALESCE(first_name, 'Validation'), last_name = COALESCE(last_name, 'Admin')"))
op.alter_column("users", "first_name", nullable=False)
op.alter_column("users", "last_name", nullable=False)
op.alter_column("users", "must_change_password", server_default=None)
def downgrade() -> None:
op.drop_column("users", "password_changed_at")
op.drop_column("users", "last_login_at")
op.drop_column("users", "must_change_password")
op.drop_column("users", "last_name")
op.drop_column("users", "first_name")

21
validation-suite/backend/mercury/alembic/versions/202607110005_reference_masterdata_notes.py
View file

@ -1,21 +0,0 @@
from __future__ import annotations
from alembic import op
import sqlalchemy as sa
revision = "202607110005"
down_revision = "202607110004"
branch_labels = None
depends_on = None
def upgrade() -> None:
op.add_column("contacts", sa.Column("notes", sa.String(length=500), nullable=True))
op.add_column("devices", sa.Column("notes", sa.Text(), nullable=True))
op.add_column("equipment", sa.Column("notes", sa.String(length=500), nullable=True))
def downgrade() -> None:
op.drop_column("equipment", "notes")
op.drop_column("devices", "notes")
op.drop_column("contacts", "notes")

108
validation-suite/backend/mercury/alembic/versions/202607110006_convert_user_role_enum_to_string.py
View file

@ -1,108 +0,0 @@
from __future__ import annotations
from alembic import op
import sqlalchemy as sa
revision = "202607110006"
down_revision = "202607110005"
branch_labels = None
depends_on = None
ALLOWED_ROLES = ("admin", "pruefer", "mitarbeiter", "leser")
def _other_columns_use_userrole(connection) -> bool:
result = connection.execute(
sa.text(
"""
SELECT EXISTS (
SELECT 1
FROM pg_attribute a
JOIN pg_class c ON c.oid = a.attrelid
JOIN pg_type t ON t.oid = a.atttypid
JOIN pg_namespace n ON n.oid = c.relnamespace
WHERE t.typname = 'userrole'
AND NOT (n.nspname = 'public' AND c.relname = 'users' AND a.attname = 'role')
AND a.attnum > 0
AND NOT a.attisdropped
)
"""
)
)
return bool(result.scalar())
def _normalize_roles(connection) -> None:
connection.execute(
sa.text(
"""
UPDATE users
SET role = CASE upper(role::text)
WHEN 'ADMIN' THEN 'admin'
WHEN 'PRUEFER' THEN 'pruefer'
WHEN 'EMPLOYEE' THEN 'mitarbeiter'
WHEN 'MITARBEITER' THEN 'mitarbeiter'
WHEN 'AUDITOR' THEN 'leser'
WHEN 'LESER' THEN 'leser'
ELSE role::text
END
"""
)
)
invalid_roles = connection.execute(
sa.text(
"""
SELECT DISTINCT role::text
FROM users
WHERE role::text NOT IN ('admin', 'pruefer', 'mitarbeiter', 'leser')
"""
),
).scalars().all()
if invalid_roles:
raise RuntimeError(f"Unknown user roles encountered during migration: {', '.join(sorted(invalid_roles))}")
def upgrade() -> None:
connection = op.get_bind()
op.alter_column(
"users",
"role",
existing_type=sa.Enum(name="userrole"),
type_=sa.String(length=50),
existing_nullable=False,
existing_server_default=None,
postgresql_using="role::text",
nullable=False,
)
_normalize_roles(connection)
op.execute(sa.text("ALTER TABLE users ALTER COLUMN role SET DEFAULT 'mitarbeiter'"))
if not _other_columns_use_userrole(connection):
op.execute(sa.text("DROP TYPE IF EXISTS userrole"))
def downgrade() -> None:
connection = op.get_bind()
op.execute(
sa.text(
"CREATE TYPE userrole AS ENUM ('admin', 'pruefer', 'mitarbeiter', 'leser')"
)
)
invalid_roles = connection.execute(
sa.text(
"""
SELECT DISTINCT role
FROM users
WHERE role NOT IN ('admin', 'pruefer', 'mitarbeiter', 'leser')
"""
),
).scalars().all()
if invalid_roles:
raise RuntimeError(f"Cannot downgrade user roles with invalid values: {', '.join(sorted(invalid_roles))}")
op.alter_column(
"users",
"role",
existing_type=sa.String(length=50),
type_=sa.Enum("admin", "pruefer", "mitarbeiter", "leser", name="userrole"),
nullable=False,
)
op.execute(sa.text("ALTER TABLE users ALTER COLUMN role SET DEFAULT 'mitarbeiter'::userrole"))

25
validation-suite/backend/mercury/alembic/versions/202607110007_add_user_deleted_at.py
View file

@ -1,25 +0,0 @@
"""add deleted_at to users for soft delete
Revision ID: 202607110007
Revises: 202607110006
Create Date: 2026-07-11 00:07:00.000000
"""
from __future__ import annotations
from alembic import op
import sqlalchemy as sa
revision = "202607110007"
down_revision = "202607110006"
branch_labels = None
depends_on = None
def upgrade() -> None:
op.add_column("users", sa.Column("deleted_at", sa.DateTime(timezone=True), nullable=True))
def downgrade() -> None:
op.drop_column("users", "deleted_at")

66
validation-suite/backend/mercury/alembic/versions/202607120001_orion_report_settings.py
View file

@ -1,66 +0,0 @@
"""orion report settings
Revision ID: 202607120001
Revises: 202607110007
Create Date: 2026-07-12 12:00:00.000000
"""
from __future__ import annotations
from alembic import op
import sqlalchemy as sa
revision = "202607120001"
down_revision = "202607110007"
branch_labels = None
depends_on = None
def upgrade() -> None:
op.create_table(
"orion_report_settings",
sa.Column("scope", sa.String(length=40), nullable=False),
sa.Column("layout_profile", sa.String(length=40), nullable=False),
sa.Column("show_cover_result_text", sa.Boolean(), nullable=False),
sa.Column("signature_mode", sa.String(length=60), nullable=False),
sa.Column("image_size", sa.String(length=40), nullable=False),
sa.Column("page_break_before_main_chapters", sa.Boolean(), nullable=False),
sa.Column("updated_by_user_id", sa.String(), nullable=True),
sa.Column("id", sa.String(), nullable=False),
sa.Column("created_at", sa.DateTime(timezone=True), server_default=sa.func.now(), nullable=False),
sa.Column("updated_at", sa.DateTime(timezone=True), server_default=sa.func.now(), nullable=False),
sa.ForeignKeyConstraint(["updated_by_user_id"], ["users.id"], name=op.f("fk_orion_report_settings_updated_by_user_id_users")),
sa.PrimaryKeyConstraint("id", name=op.f("pk_orion_report_settings")),
sa.UniqueConstraint("scope", name=op.f("uq_orion_report_settings_scope")),
)
op.create_index(op.f("ix_orion_report_settings_scope"), "orion_report_settings", ["scope"], unique=True)
op.create_index(op.f("ix_orion_report_settings_updated_by_user_id"), "orion_report_settings", ["updated_by_user_id"], unique=False)
op.execute(
"""
INSERT INTO orion_report_settings (
id,
scope,
layout_profile,
show_cover_result_text,
signature_mode,
image_size,
page_break_before_main_chapters
)
VALUES (
'00000000-0000-4000-8000-000000000001',
'GLOBAL',
'STANDARD',
true,
'TECHNICAL_ONLY',
'MEDIUM',
true
)
"""
)
def downgrade() -> None:
op.drop_index(op.f("ix_orion_report_settings_updated_by_user_id"), table_name="orion_report_settings")
op.drop_index(op.f("ix_orion_report_settings_scope"), table_name="orion_report_settings")
op.drop_table("orion_report_settings")

59
validation-suite/backend/mercury/alembic/versions/202607120002_orion_report_settings_v11.py
View file

@ -1,59 +0,0 @@
"""orion report settings v1.1
Revision ID: 202607120002
Revises: 202607120001
Create Date: 2026-07-12 13:00:00.000000
"""
from __future__ import annotations
from alembic import op
import sqlalchemy as sa
revision = "202607120002"
down_revision = "202607120001"
branch_labels = None
depends_on = None
def upgrade() -> None:
op.add_column("orion_report_settings", sa.Column("page_margin", sa.String(length=40), nullable=False, server_default="STANDARD"))
op.add_column("orion_report_settings", sa.Column("section_spacing", sa.String(length=40), nullable=False, server_default="STANDARD"))
op.add_column("orion_report_settings", sa.Column("table_layout", sa.String(length=40), nullable=False, server_default="STANDARD"))
op.add_column("orion_report_settings", sa.Column("table_font_size", sa.String(length=40), nullable=False, server_default="STANDARD"))
op.add_column("orion_report_settings", sa.Column("image_position", sa.String(length=40), nullable=False, server_default="SIDE_BY_SIDE"))
op.add_column("orion_report_settings", sa.Column("max_images_per_page", sa.Integer(), nullable=False, server_default="2"))
op.add_column("orion_report_settings", sa.Column("show_image_captions", sa.Boolean(), nullable=False, server_default=sa.true()))
op.add_column("orion_report_settings", sa.Column("show_header", sa.Boolean(), nullable=False, server_default=sa.true()))
op.add_column("orion_report_settings", sa.Column("show_footer", sa.Boolean(), nullable=False, server_default=sa.true()))
op.add_column("orion_report_settings", sa.Column("logo_size", sa.String(length=40), nullable=False, server_default="MEDIUM"))
op.add_column("orion_report_settings", sa.Column("compact_cover", sa.Boolean(), nullable=False, server_default=sa.false()))
for column in [
"page_margin",
"section_spacing",
"table_layout",
"table_font_size",
"image_position",
"max_images_per_page",
"show_image_captions",
"show_header",
"show_footer",
"logo_size",
"compact_cover",
]:
op.alter_column("orion_report_settings", column, server_default=None)
def downgrade() -> None:
op.drop_column("orion_report_settings", "compact_cover")
op.drop_column("orion_report_settings", "logo_size")
op.drop_column("orion_report_settings", "show_footer")
op.drop_column("orion_report_settings", "show_header")
op.drop_column("orion_report_settings", "show_image_captions")
op.drop_column("orion_report_settings", "max_images_per_page")
op.drop_column("orion_report_settings", "image_position")
op.drop_column("orion_report_settings", "table_font_size")
op.drop_column("orion_report_settings", "table_layout")
op.drop_column("orion_report_settings", "section_spacing")
op.drop_column("orion_report_settings", "page_margin")

38
validation-suite/backend/mercury/alembic/versions/202607120003_customer_external_reference.py
View file

@ -1,38 +0,0 @@
"""customer external reference
Revision ID: 202607120003
Revises: 202607120002
Create Date: 2026-07-12 14:00:00.000000
"""
from __future__ import annotations
from alembic import op
import sqlalchemy as sa
revision = "202607120003"
down_revision = "202607120002"
branch_labels = None
depends_on = None
def upgrade() -> None:
op.add_column("customers", sa.Column("source_system", sa.String(length=80), nullable=True))
op.add_column("customers", sa.Column("external_id", sa.String(length=120), nullable=True))
op.create_index(op.f("ix_customers_source_system"), "customers", ["source_system"], unique=False)
op.create_index(op.f("ix_customers_external_id"), "customers", ["external_id"], unique=False)
op.create_index(
"ix_customers_source_system_external_id",
"customers",
["source_system", "external_id"],
unique=False,
)
def downgrade() -> None:
op.drop_index("ix_customers_source_system_external_id", table_name="customers")
op.drop_index(op.f("ix_customers_external_id"), table_name="customers")
op.drop_index(op.f("ix_customers_source_system"), table_name="customers")
op.drop_column("customers", "external_id")
op.drop_column("customers", "source_system")

BIN
validation-suite/backend/mercury/app/__pycache__/cli.cpython-313.pyc
View file

Binary file not shown.

BIN
validation-suite/backend/mercury/app/__pycache__/main.cpython-313.pyc
View file

Binary file not shown.

BIN
validation-suite/backend/mercury/app/api/__pycache__/dependencies.cpython-313.pyc
View file

Binary file not shown.

16
validation-suite/backend/mercury/app/api/dependencies.py
View file

@ -7,7 +7,7 @@ from sqlalchemy.orm import Session
from app.core.config import settings
from app.db.session import get_session
from app.models.user import User, UserRole
from app.models.user import User
bearer = HTTPBearer()
@ -30,17 +30,3 @@ def current_user(
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Inactive user")
return user
def require_role(*roles: UserRole):
def dependency(user: User = Depends(current_user)) -> User:
if user.role not in roles:
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Forbidden")
return user
return dependency
def current_admin(user: User = Depends(current_user)) -> User:
if user.role != UserRole.ADMIN.value:
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Forbidden")
return user

BIN
validation-suite/backend/mercury/app/api/v1/__pycache__/auth.cpython-313.pyc
View file

Binary file not shown.

BIN
validation-suite/backend/mercury/app/api/v1/__pycache__/domain.cpython-313.pyc
View file

Binary file not shown.

BIN
validation-suite/backend/mercury/app/api/v1/__pycache__/router.cpython-313.pyc
View file

Binary file not shown.

37
validation-suite/backend/mercury/app/api/v1/auth.py
View file

@ -1,53 +1,24 @@
from __future__ import annotations
from datetime import UTC, datetime
from fastapi import APIRouter, Depends, HTTPException
from fastapi import APIRouter, Depends
from sqlalchemy.orm import Session
from app.api.dependencies import current_user
from app.db.session import get_session
from app.models.user import User
from app.core.security import hash_password, verify_password
from app.schemas.auth import ChangePasswordRequest, LoginRequest, TokenResponse, UserRead
from app.schemas.auth import LoginRequest, TokenResponse, UserRead
from app.services.auth_service import AuthService
from app.core.config import settings
router = APIRouter(prefix="/auth", tags=["auth"])
@router.post("/login", response_model=TokenResponse)
def login(payload: LoginRequest, session: Session = Depends(get_session)) -> TokenResponse:
token, user = AuthService(session).login(payload.email, payload.password)
return TokenResponse(
access_token=token,
expires_in=settings.access_token_minutes * 60,
user=user,
)
token = AuthService(session).login(payload.email, payload.password)
return TokenResponse(access_token=token)
@router.get("/me", response_model=UserRead)
def me(user: User = Depends(current_user)) -> User:
return user
@router.post("/change-password")
def change_password(
payload: ChangePasswordRequest,
user: User = Depends(current_user),
session: Session = Depends(get_session),
) -> dict[str, str]:
if not verify_password(payload.current_password, user.password_hash):
raise HTTPException(status_code=422, detail="Das aktuelle Passwort ist falsch.")
if payload.new_password != payload.new_password_confirmation:
raise HTTPException(status_code=422, detail="Die neuen Passwoerter stimmen nicht ueberein.")
if len(payload.new_password) < 12:
raise HTTPException(status_code=422, detail="Das neue Passwort muss mindestens 12 Zeichen haben.")
if verify_password(payload.new_password, user.password_hash):
raise HTTPException(status_code=422, detail="Das neue Passwort darf nicht identisch zum alten sein.")
user.password_hash = hash_password(payload.new_password)
user.must_change_password = False
user.password_changed_at = datetime.now(UTC)
session.commit()
return {"status": "ok"}

688
validation-suite/backend/mercury/app/api/v1/domain.py
View file

@ -2,31 +2,18 @@ from __future__ import annotations
from typing import Any
import json
import logging
import shutil
import uuid
from datetime import UTC, datetime
from pathlib import Path
from fastapi import APIRouter, Depends, File, Form, HTTPException, Query, Response, UploadFile
from fastapi.encoders import jsonable_encoder
from fastapi.responses import FileResponse, HTMLResponse, JSONResponse
from fastapi import APIRouter, Depends, Query, Response
from sqlalchemy import func, select
from sqlalchemy.exc import IntegrityError, ProgrammingError
from sqlalchemy.orm import Session
from app.api.dependencies import current_admin, current_user
from app.api.dependencies import current_user
from app.db.session import get_session
from app.models.contact import Contact
from app.models.customer import Customer
from app.models.device import Device
from app.models.equipment import Equipment
from app.models.location import Location
from app.models.user import User, UserRole
from app.models.validation import Validation
from app.modules.helios.service import HeliosImportService
from app.modules.orion.service import OrionReportService
from app.schemas.common import PaginatedResponse
from app.schemas.domain import (
ContactCreate,
@ -44,166 +31,24 @@ from app.schemas.domain import (
LocationCreate,
LocationRead,
LocationUpdate,
MeasurementImportConfirmRequest,
MeasurementImportPreviewRead,
ValidationCreate,
ValidationImportPreview,
ValidationImportRequest,
ValidationImportSummary,
ValidationRead,
ValidationReview,
ValidationUpdate,
QuickStartCreateRequest,
QuickStartCustomerData,
QuickStartValidationSummary,
OrionReportSettingsRead,
OrionReportSettingsUpdate,
UserCreate,
UserRead,
UserUpdate,
UserPasswordResetRequest,
)
from app.services.domain_service import CrudService, DomainServices
from app.services.customer_import import CustomerImportService, parse_json_object
from app.services.quickstart_service import QuickStartService
from app.services.report_settings import OrionReportSettingsService
from app.services.validation_workflow import ValidationWorkflowService
router = APIRouter(tags=["domain"], dependencies=[Depends(current_user)])
logger = logging.getLogger(__name__)
@router.get("/report-templates/default/checklists")
def default_report_checklists(session: Session = Depends(get_session)) -> list[dict]:
from app.modules.orion.template_service import ReportTemplateService
bundle = ReportTemplateService(session).ensure_default_template()
session.commit()
return [
{
"checklist_key": item.checklist_key,
"title": item.title,
"columns": item.columns,
"items": item.items,
"order_index": item.order_index,
}
for item in bundle.checklists
]
@router.get("/report-settings", response_model=OrionReportSettingsRead)
def get_report_settings(
session: Session = Depends(get_session),
_: User = Depends(current_admin),
):
return OrionReportSettingsService(session).get_global()
@router.put("/report-settings", response_model=OrionReportSettingsRead)
def update_report_settings(
payload: OrionReportSettingsUpdate,
session: Session = Depends(get_session),
user: User = Depends(current_admin),
):
try:
settings = OrionReportSettingsService(session).update_global(payload, user)
session.commit()
session.refresh(settings)
return settings
except IntegrityError as exc:
session.rollback()
raise HTTPException(status_code=409, detail="Berichtseinstellungen konnten nicht gespeichert werden.") from exc
@router.post("/report-settings/preview")
def preview_report_settings(
payload: OrionReportSettingsUpdate | None = None,
session: Session = Depends(get_session),
_: User = Depends(current_admin),
):
try:
pdf = OrionReportService(session, Path("/app/reports")).render_settings_preview_pdf(payload)
except Exception as exc:
logger.exception("Orion settings preview generation failed")
raise HTTPException(status_code=502, detail="Die PDF-Vorschau konnte nicht erzeugt werden.") from exc
return Response(
content=pdf,
media_type="application/pdf",
headers={"Content-Disposition": 'attachment; filename="orion-layout-preview.pdf"'},
)
@router.get("/dashboard")
def dashboard(session: Session = Depends(get_session)) -> dict[str, int]:
today = func.current_date()
result_groups = {
"validation_result_open": ["OFFEN", "offen", None, ""],
"validation_result_passed": ["BESTANDEN", "bestanden"],
"validation_result_conditional": ["BESTANDEN_MIT_AUFLAGEN", "bestanden_mit_auflagen", "mit_auflagen", "bestanden mit Auflagen"],
"validation_result_failed": ["NICHT_BESTANDEN", "nicht_bestanden", "nicht bestanden"],
}
result_counts = {
key: session.scalar(select(func.count()).select_from(Validation).where(Validation.result.in_(values)))
or 0
for key, values in result_groups.items()
if None not in values
}
result_counts["validation_result_open"] = (
session.scalar(
select(func.count())
.select_from(Validation)
.where((Validation.result.in_(["OFFEN", "offen", ""])) | (Validation.result.is_(None)))
)
or 0
)
return {
"customers": session.scalar(select(func.count()).select_from(Customer)) or 0,
"locations": session.scalar(select(func.count()).select_from(Location)) or 0,
"contacts": session.scalar(select(func.count()).select_from(Contact)) or 0,
"devices": session.scalar(select(func.count()).select_from(Device)) or 0,
"equipment": session.scalar(select(func.count()).select_from(Equipment)) or 0,
"equipment_green": session.scalar(
select(func.count()).select_from(Equipment).where(Equipment.status == "green")
)
or 0,
"equipment_yellow": session.scalar(
select(func.count()).select_from(Equipment).where(Equipment.status == "yellow")
)
or 0,
"equipment_red": session.scalar(
select(func.count()).select_from(Equipment).where(Equipment.status == "red")
)
or 0,
"validations": session.scalar(select(func.count()).select_from(Validation)) or 0,
"validation_drafts": session.scalar(
select(func.count()).select_from(Validation).where(Validation.status == "ENTWURF")
)
or 0,
"validation_ready": session.scalar(
select(func.count())
.select_from(Validation)
.where(Validation.status == "BEREIT_ZUR_PRUEFUNG")
)
or 0,
"validation_in_review": session.scalar(
select(func.count()).select_from(Validation).where(Validation.status == "IN_PRUEFUNG")
)
or 0,
"validation_approved": session.scalar(
select(func.count()).select_from(Validation).where(Validation.status == "FREIGEGEBEN")
)
or 0,
"validation_completed": session.scalar(
select(func.count()).select_from(Validation).where(Validation.status == "ABGESCHLOSSEN")
)
or 0,
"validation_overdue": session.scalar(
select(func.count())
.select_from(Validation)
.where(Validation.next_validation_on < today)
)
or 0,
**result_counts,
}
@ -215,83 +60,18 @@ def paging(
return {"page": page, "page_size": page_size, "search": search}
@router.post("/customer-imports/preview")
async def preview_customer_import(
file: UploadFile,
mapping: str | None = Form(default=None),
session: Session = Depends(get_session),
_: User = Depends(current_admin),
):
try:
content = await file.read()
parsed_mapping = parse_json_object(mapping) if mapping else None
return CustomerImportService(session).preview(file.filename or "import", content, parsed_mapping)
except ValueError as exc:
raise HTTPException(status_code=422, detail=str(exc)) from exc
except UnicodeDecodeError as exc:
raise HTTPException(status_code=422, detail="Die CSV-Datei muss UTF-8 kodiert sein.") from exc
@router.post("/customer-imports/confirm")
async def confirm_customer_import(
file: UploadFile,
mapping: str = Form(...),
row_actions: str | None = Form(default=None),
ignore_empty_values: bool = Form(default=True),
session: Session = Depends(get_session),
user: User = Depends(current_admin),
):
try:
content = await file.read()
result = CustomerImportService(session).confirm(
file.filename or "import",
content,
parse_json_object(mapping),
parse_json_object(row_actions),
ignore_empty_values,
user,
)
return result
except ValueError as exc:
session.rollback()
raise HTTPException(status_code=422, detail=str(exc)) from exc
except IntegrityError as exc:
session.rollback()
raise HTTPException(status_code=409, detail="Der Kundenimport konnte nicht vollständig gespeichert werden.") from exc
def commit_create(session: Session, service: CrudService, payload):
try:
item = service.create(payload.model_dump())
if isinstance(item, Validation):
ValidationWorkflowService(session).apply_revalidation_date(item)
session.commit()
session.refresh(item)
return item
except IntegrityError as exc:
session.rollback()
from fastapi import HTTPException
raise HTTPException(
status_code=409, detail="Datensatz verletzt Datenbankbeziehungen."
) from exc
def commit_update(session: Session, service: CrudService, item_id: str, payload):
try:
item = service.update(item_id, payload.model_dump())
if isinstance(item, Validation):
ValidationWorkflowService(session).apply_revalidation_date(item)
session.commit()
session.refresh(item)
return item
except IntegrityError as exc:
session.rollback()
from fastapi import HTTPException
raise HTTPException(
status_code=409, detail="Datensatz verletzt Datenbankbeziehungen."
) from exc
def commit_delete(session: Session, service: CrudService, item_id: str) -> Response:
@ -320,14 +100,6 @@ def delete_customer(item_id: str, session: Session = Depends(get_session)):
return commit_delete(session, DomainServices(session).customers, item_id)
@router.get("/customers/{item_id}/quickstart-data", response_model=QuickStartCustomerData)
def customer_quickstart_data(item_id: str, session: Session = Depends(get_session)):
try:
return QuickStartService(session).customer_data(item_id)
except ValueError as exc:
raise HTTPException(status_code=404, detail=str(exc)) from exc
@router.get("/locations", response_model=PaginatedResponse[LocationRead])
def list_locations(params: dict = Depends(paging), session: Session = Depends(get_session)):
return DomainServices(session).locations.list(**params)
@ -399,9 +171,7 @@ def create_equipment(payload: EquipmentCreate, session: Session = Depends(get_se
@router.put("/equipment/{item_id}", response_model=EquipmentRead)
def update_equipment(
item_id: str, payload: EquipmentUpdate, session: Session = Depends(get_session)
):
def update_equipment(item_id: str, payload: EquipmentUpdate, session: Session = Depends(get_session)):
return commit_update(session, DomainServices(session).equipment, item_id, payload)
@ -411,39 +181,8 @@ def delete_equipment(item_id: str, session: Session = Depends(get_session)):
@router.get("/validations", response_model=PaginatedResponse[ValidationRead])
def list_validations(
search: str | None = Query(default=None, max_length=120),
page: int = Query(default=1, ge=1),
page_size: int = Query(default=20, ge=1, le=100),
sort_by: str = Query(default="updated_at"),
sort_order: str = Query(default="desc", pattern="^(asc|desc)$"),
status: str | None = None,
customer_id: str | None = None,
device_id: str | None = None,
validation_type: str | None = None,
result: str | None = None,
date_from: str | None = None,
date_to: str | None = None,
overdue_only: bool = False,
session: Session = Depends(get_session),
):
return ValidationWorkflowService(session).query_validations(
search=search,
page=page,
page_size=page_size,
sort_by=sort_by,
sort_order=sort_order,
filters={
"status": status,
"customer_id": customer_id,
"device_id": device_id,
"validation_type": validation_type,
"result": result,
"date_from": date_from,
"date_to": date_to,
"overdue_only": overdue_only,
},
)
def list_validations(params: dict = Depends(paging), session: Session = Depends(get_session)):
return DomainServices(session).validations.list(**params)
@router.get("/validations/next-report-number")
@ -462,431 +201,16 @@ def get_validation(item_id: str, session: Session = Depends(get_session)):
return item
@router.get("/devices/{item_id}/last-validation", response_model=QuickStartValidationSummary | None)
def last_device_validation(item_id: str, session: Session = Depends(get_session)):
try:
return QuickStartService(session).device_last_validation(item_id)
except ValueError as exc:
raise HTTPException(status_code=404, detail=str(exc)) from exc
@router.post("/validations", response_model=ValidationRead, status_code=201)
def create_validation(payload: ValidationCreate, session: Session = Depends(get_session)):
return commit_create(session, DomainServices(session).validations, payload)
@router.post("/validations/quick-start", response_model=ValidationRead, status_code=201)
def create_quick_start_validation(
payload: QuickStartCreateRequest,
session: Session = Depends(get_session),
me: User = Depends(current_user),
):
try:
validation = QuickStartService(session).create_validation(payload, me)
session.commit()
session.refresh(validation)
return validation
except ValueError as exc:
session.rollback()
raise HTTPException(status_code=422, detail=str(exc)) from exc
@router.put("/validations/{item_id}", response_model=ValidationRead)
def update_validation(
item_id: str, payload: ValidationUpdate, session: Session = Depends(get_session)
):
def update_validation(item_id: str, payload: ValidationUpdate, session: Session = Depends(get_session)):
return commit_update(session, DomainServices(session).validations, item_id, payload)
@router.delete("/validations/{item_id}", status_code=204)
def delete_validation(item_id: str, session: Session = Depends(get_session)):
item = DomainServices(session).validations.repository.get(item_id)
if item and item.status != "ENTWURF":
from fastapi import HTTPException
raise HTTPException(status_code=409, detail="Only draft validations can be deleted")
return commit_delete(session, DomainServices(session).validations, item_id)
@router.post("/validations/{item_id}/review", response_model=ValidationReview)
def review_validation(item_id: str, session: Session = Depends(get_session)):
item = DomainServices(session).validations.repository.get(item_id)
if item is None:
from fastapi import HTTPException
raise HTTPException(status_code=404, detail="Resource not found")
review = ValidationWorkflowService(session).mark_ready_for_review(item)
session.commit()
return review
@router.post("/validations/{item_id}/duplicate", response_model=ValidationRead, status_code=201)
def duplicate_validation(item_id: str, session: Session = Depends(get_session)):
item = DomainServices(session).validations.repository.get(item_id)
if item is None:
from fastapi import HTTPException
raise HTTPException(status_code=404, detail="Resource not found")
clone = ValidationWorkflowService(session).duplicate(item)
session.commit()
session.refresh(clone)
return clone
@router.post("/validations/{item_id}/new-version", response_model=ValidationRead, status_code=201)
def new_validation_version(item_id: str, session: Session = Depends(get_session)):
item = DomainServices(session).validations.repository.get(item_id)
if item is None:
from fastapi import HTTPException
raise HTTPException(status_code=404, detail="Resource not found")
clone = ValidationWorkflowService(session).create_new_version(item)
session.commit()
session.refresh(clone)
return clone
@router.post("/validations/{item_id}/cancel", response_model=ValidationRead)
def cancel_validation(item_id: str, session: Session = Depends(get_session)):
item = DomainServices(session).validations.repository.get(item_id)
if item is None:
from fastapi import HTTPException
raise HTTPException(status_code=404, detail="Resource not found")
item.status = "STORNIERT"
session.commit()
session.refresh(item)
return item
@router.post("/validations/{item_id}/attachments")
def upload_validation_attachment(
item_id: str,
category: str = Form(...),
description: str = Form(default=""),
order: int = Form(default=0),
file: UploadFile = File(...),
session: Session = Depends(get_session),
):
item = DomainServices(session).validations.repository.get(item_id)
if item is None:
from fastapi import HTTPException
raise HTTPException(status_code=404, detail="Resource not found")
if item.status in {"FREIGEGEBEN", "ABGESCHLOSSEN"}:
from fastapi import HTTPException
raise HTTPException(status_code=409, detail="Freigegebene Berichte sind schreibgeschuetzt.")
original_name = Path(file.filename or "anlage").name
suffix = Path(original_name).suffix
stored_name = f"{uuid.uuid4().hex}{suffix}"
upload_dir = Path("/app/uploads/validations") / item_id
upload_dir.mkdir(parents=True, exist_ok=True)
storage_path = upload_dir / stored_name
with storage_path.open("wb") as target:
shutil.copyfileobj(file.file, target)
attachment = {
"category": category,
"filename": original_name,
"content_type": file.content_type,
"description": description,
"order": order,
"storage_path": str(storage_path),
"url": f"/uploads/validations/{item_id}/{stored_name}",
}
current = list(item.attachments or [])
current.append(attachment)
item.attachments = current
session.commit()
return attachment
@router.post(
"/validations/{item_id}/measurement-imports/winlog-pdf",
response_model=MeasurementImportPreviewRead,
)
async def upload_winlog_pdf_import(
item_id: str,
file: UploadFile = File(...),
attachment_only: bool = Form(default=False),
session: Session = Depends(get_session),
):
item = DomainServices(session).validations.repository.get(item_id)
if item is None:
from fastapi import HTTPException
raise HTTPException(status_code=404, detail="Resource not found")
preview = HeliosImportService(session).save_winlog_pdf(
item_id,
file.filename or "winlog.pdf",
await file.read(),
attachment_only=attachment_only,
)
session.commit()
return preview
@router.post(
"/measurement-imports/{import_id}/confirm",
response_model=MeasurementImportPreviewRead,
)
def confirm_measurement_import(
import_id: str,
payload: MeasurementImportConfirmRequest,
session: Session = Depends(get_session),
):
try:
preview = HeliosImportService(session).confirm_values(
import_id, [item.model_dump() for item in payload.values]
)
except ValueError as exc:
from fastapi import HTTPException
raise HTTPException(status_code=404, detail=str(exc)) from exc
session.commit()
return preview
@router.get("/validations/{item_id}/export.json")
def export_validation_json(item_id: str, session: Session = Depends(get_session)):
item = DomainServices(session).validations.repository.get(item_id)
if item is None:
from fastapi import HTTPException
raise HTTPException(status_code=404, detail="Resource not found")
data = ValidationWorkflowService(session).export_json(item)
return JSONResponse(
content=json.loads(json.dumps(data, default=str)),
headers={"Content-Disposition": f'attachment; filename="{item.report_number}.json"'},
)
@router.post("/validations/import/csv-preview", response_model=ValidationImportPreview)
async def preview_validation_csv(file: UploadFile, session: Session = Depends(get_session)):
return ValidationWorkflowService(session).preview_csv(await file.read())
@router.post("/validations/import/json", response_model=ValidationImportSummary)
def import_validation_json(
payload: ValidationImportRequest, session: Session = Depends(get_session)
):
summary = ValidationWorkflowService(session).import_rows(
payload.rows, payload.duplicate_strategy
)
session.commit()
return summary
@router.get("/validations/{item_id}/report.html", response_class=HTMLResponse)
def validation_report_preview(item_id: str, session: Session = Depends(get_session)):
return OrionReportService(session, Path("/app/reports")).render_html(item_id)
@router.get("/validations/{item_id}/report.pdf")
def validation_report_pdf(item_id: str, session: Session = Depends(get_session)):
try:
report_path = OrionReportService(session, Path("/app/reports")).render_pdf(item_id)
except Exception as exc:
logger.exception("PDF generation failed for validation %s", item_id)
from fastapi import HTTPException
raise HTTPException(
status_code=502,
detail="Der PDF-Bericht konnte nicht erzeugt werden. Die HTML-Vorschau ist weiterhin verfuegbar.",
) from exc
return FileResponse(
report_path,
media_type="application/pdf",
filename=report_path.name,
)
def _user_payload(user: User) -> dict:
return {
"id": user.id,
"created_at": user.created_at,
"updated_at": user.updated_at,
"email": user.email,
"first_name": user.first_name,
"last_name": user.last_name,
"role": UserRole(user.role),
"is_active": user.is_active,
"must_change_password": user.must_change_password,
"last_login_at": user.last_login_at,
"password_changed_at": user.password_changed_at,
}
@router.get("/users", response_model=PaginatedResponse[UserRead])
def list_users(
session: Session = Depends(get_session),
page: int = Query(1, ge=1),
page_size: int = Query(20, ge=1, le=100),
search: str | None = Query(default=None),
role: str | None = Query(default=None),
active: bool | None = Query(default=None),
sort_by: str = Query(default="created_at"),
sort_order: str = Query(default="desc"),
_: User = Depends(current_admin),
):
query = select(User)
query = query.where(User.deleted_at.is_(None))
if search:
term = f"%{search.strip()}%"
query = query.where(
(User.first_name.ilike(term))
| (User.last_name.ilike(term))
| (User.email.ilike(term))
)
if role:
query = query.where(User.role == role)
if active is not None:
query = query.where(User.is_active.is_(active))
sort_columns = {
"name": User.last_name,
"email": User.email,
"role": User.role,
"is_active": User.is_active,
"last_login_at": User.last_login_at,
"password_changed_at": User.password_changed_at,
"created_at": User.created_at,
"updated_at": User.updated_at,
}
sort_column = sort_columns.get(sort_by, User.created_at)
query = query.order_by(sort_column.asc() if sort_order.lower() == "asc" else sort_column.desc())
total = session.scalar(select(func.count()).select_from(query.order_by(None).subquery())) or 0
pages = max((total + page_size - 1) // page_size, 1)
items = list(session.scalars(query.offset((page - 1) * page_size).limit(page_size)))
return {"items": items, "total": total, "page": page, "page_size": page_size, "pages": pages}
@router.post("/users", status_code=201)
def create_user(payload: UserCreate, session: Session = Depends(get_session), _: User = Depends(current_admin)):
from app.core.security import hash_password
import secrets
from app.models.user import User
normalized_email = payload.email.strip().lower()
logger.debug("create_user request email=%s normalized_email=%s", payload.email, normalized_email)
existing = session.scalar(select(User).where(func.lower(User.email) == normalized_email))
logger.debug("create_user select result=%s count=%s", bool(existing), 1 if existing else 0)
if existing is not None:
raise HTTPException(status_code=409, detail="Die E-Mail-Adresse wird bereits verwendet.")
temporary_password = payload.temporary_password or secrets.token_urlsafe(12)
try:
user = User(
email=normalized_email,
first_name=payload.first_name,
last_name=payload.last_name,
role=payload.role.value,
password_hash=hash_password(temporary_password),
is_active=payload.is_active,
must_change_password=payload.must_change_password,
)
logger.debug("create_user insert email=%s", normalized_email)
session.add(user)
session.commit()
logger.debug("create_user commit ok email=%s id=%s", normalized_email, user.id)
session.refresh(user)
logger.debug("create_user response email=%s status=201", normalized_email)
return JSONResponse(
content={"temporary_password": temporary_password, "user": jsonable_encoder(user)},
status_code=201,
)
except IntegrityError as exc:
session.rollback()
logger.exception("create_user integrity error email=%s", normalized_email)
raise HTTPException(status_code=409, detail="Die E-Mail-Adresse wird bereits verwendet.") from exc
except ProgrammingError as exc:
session.rollback()
raise HTTPException(status_code=422, detail="Die Benutzerrolle ist ungültig.") from exc
@router.get("/users/{item_id}", response_model=UserRead)
def get_user(item_id: str, session: Session = Depends(get_session), _: User = Depends(current_admin)):
user = session.get(User, item_id)
if user is None or user.deleted_at is not None:
raise HTTPException(status_code=404, detail="Resource not found")
return user
@router.put("/users/{item_id}", response_model=UserRead)
def update_user(item_id: str, payload: UserUpdate, session: Session = Depends(get_session), me: User = Depends(current_admin)):
user = session.get(User, item_id)
if user is None or user.deleted_at is not None:
raise HTTPException(status_code=404, detail="Resource not found")
if user.id == me.id and not payload.is_active:
raise HTTPException(status_code=409, detail="Own admin account cannot be deactivated")
active_admins = session.scalar(
select(func.count()).select_from(User).where(User.role == UserRole.ADMIN.value, User.is_active.is_(True))
) or 0
if user.role == UserRole.ADMIN.value and active_admins <= 1 and (not payload.is_active or payload.role != UserRole.ADMIN.value):
raise HTTPException(status_code=409, detail="Der letzte aktive ADMIN darf nicht deaktiviert oder herabgestuft werden.")
try:
normalized_email = payload.email.strip().lower()
logger.debug("update_user request id=%s email=%s normalized_email=%s", item_id, payload.email, normalized_email)
existing = session.scalar(
select(User).where(func.lower(User.email) == normalized_email, User.id != user.id)
)
logger.debug("update_user select result=%s count=%s", bool(existing), 1 if existing else 0)
if existing is not None:
raise HTTPException(status_code=409, detail="Die E-Mail-Adresse wird bereits verwendet.")
user.first_name = payload.first_name
user.last_name = payload.last_name
user.email = normalized_email
user.role = payload.role.value
user.is_active = payload.is_active
user.must_change_password = payload.must_change_password
logger.debug("update_user commit start id=%s email=%s", user.id, normalized_email)
session.commit()
logger.debug("update_user commit ok id=%s email=%s", user.id, normalized_email)
session.refresh(user)
return user
except IntegrityError as exc:
session.rollback()
logger.exception("update_user integrity error id=%s email=%s", item_id, payload.email)
raise HTTPException(status_code=409, detail="Die E-Mail-Adresse wird bereits verwendet.") from exc
except ProgrammingError as exc:
session.rollback()
raise HTTPException(status_code=422, detail="Die Benutzerrolle ist ungültig.") from exc
@router.delete("/users/{item_id}", status_code=204)
def delete_user(item_id: str, session: Session = Depends(get_session), me: User = Depends(current_admin)):
user = session.get(User, item_id)
if user is None or user.deleted_at is not None:
raise HTTPException(status_code=404, detail="Resource not found")
if user.id == me.id:
raise HTTPException(status_code=409, detail="Das eigene Benutzerkonto kann nicht geloescht werden.")
active_admins = session.scalar(
select(func.count()).select_from(User).where(User.role == UserRole.ADMIN.value, User.is_active.is_(True))
) or 0
if user.role == UserRole.ADMIN.value and active_admins <= 1:
raise HTTPException(status_code=409, detail="Der letzte aktive ADMIN darf nicht geloescht werden.")
referenced_validations = session.scalar(
select(func.count()).select_from(Validation).where(Validation.examiner_id == user.id)
) or 0
if referenced_validations == 0:
session.delete(user)
session.commit()
return Response(status_code=204)
user.is_active = False
user.deleted_at = datetime.now(UTC)
session.commit()
return Response(status_code=204)
@router.post("/users/{item_id}/reset-password")
def reset_user_password(item_id: str, session: Session = Depends(get_session), _: User = Depends(current_admin)):
import secrets
from app.core.security import hash_password
user = session.get(User, item_id)
if user is None or user.deleted_at is not None:
raise HTTPException(status_code=404, detail="Resource not found")
temporary_password = secrets.token_urlsafe(12)
user.password_hash = hash_password(temporary_password)
user.must_change_password = True
session.commit()
return JSONResponse(content={"temporary_password": temporary_password})

138
validation-suite/backend/mercury/app/cli.py
View file

@ -1,138 +0,0 @@
from __future__ import annotations
import argparse
import json
import sys
from getpass import getpass
from pathlib import Path
from app.db.session import SessionLocal
from app.models.user import User
from app.services.demo_data import DemoDataService
from app.services.reference_masterdata import ReferenceMasterdataImportService
def cmd_import_reference_masterdata(args: argparse.Namespace) -> int:
with SessionLocal() as session:
service = ReferenceMasterdataImportService(session)
result = service.import_reference_docx(
Path(args.reference),
dry_run=args.dry_run,
update_existing=args.update_existing,
create_validation=args.create_validation,
)
payload = result.as_dict()
if args.json_summary:
print(json.dumps(payload, ensure_ascii=False, default=str))
else:
for label in ["created", "updated", "unchanged", "conflicts", "errors"]:
print(f"{label}: {len(payload[label])}")
for item in payload[label]:
print(f" - {item}")
if result.validation_id:
print(f"validation_id: {result.validation_id}")
return 0
def cmd_reset_password(args: argparse.Namespace) -> int:
from app.core.security import hash_password
from sqlalchemy import select
with SessionLocal() as session:
user = session.scalar(select(User).where(User.email == args.email.lower()))
if user is None:
raise SystemExit(f"User not found: {args.email}")
first = getpass("New password: ")
second = getpass("Repeat password: ")
if first != second:
raise SystemExit("Passwords do not match")
user.password_hash = hash_password(first)
session.commit()
print("Password updated")
return 0
def cmd_create_admin(_: argparse.Namespace) -> int:
from app.core.security import hash_password
from app.models.user import UserRole
from sqlalchemy import select
email = input("E-Mail: ").strip().lower()
first_name = input("Vorname: ").strip()
last_name = input("Nachname: ").strip()
password = getpass("Passwort: ")
password_confirmation = getpass("Passwort bestätigen: ")
if password != password_confirmation:
raise SystemExit("Passwords do not match")
with SessionLocal() as session:
existing = session.scalar(select(User).where(User.email == email))
if existing is not None:
raise SystemExit("User already exists")
session.add(
User(
email=email,
first_name=first_name,
last_name=last_name,
role=UserRole.ADMIN.value,
password_hash=hash_password(password),
is_active=True,
must_change_password=False,
)
)
session.commit()
print("Admin user created")
return 0
def cmd_demo_data(args: argparse.Namespace) -> int:
with SessionLocal() as session:
summary = DemoDataService(session).run(
customers=args.customers,
devices=args.devices,
validations=args.validations,
reports=args.reports,
images=args.images,
reset=args.reset,
)
print(json.dumps(summary, ensure_ascii=False))
return 0
def build_parser() -> argparse.ArgumentParser:
parser = argparse.ArgumentParser(prog="python -m app.cli")
subparsers = parser.add_subparsers(dest="command", required=True)
import_parser = subparsers.add_parser("import-reference-masterdata")
import_parser.add_argument("--reference", required=True)
import_parser.add_argument("--dry-run", action="store_true")
import_parser.add_argument("--update-existing", action="store_true")
import_parser.add_argument("--create-validation", action="store_true")
import_parser.add_argument("--json-summary", action="store_true")
import_parser.set_defaults(func=cmd_import_reference_masterdata)
reset_parser = subparsers.add_parser("reset-password")
reset_parser.add_argument("--email", required=True)
reset_parser.set_defaults(func=cmd_reset_password)
admin_parser = subparsers.add_parser("create-admin")
admin_parser.set_defaults(func=cmd_create_admin)
demo_parser = subparsers.add_parser("demo-data")
demo_parser.add_argument("--customers", type=int, default=10)
demo_parser.add_argument("--devices", type=int, default=10)
demo_parser.add_argument("--validations", type=int, default=20)
demo_parser.add_argument("--reports", action="store_true")
demo_parser.add_argument("--images", action="store_true")
demo_parser.add_argument("--reset", action="store_true")
demo_parser.set_defaults(func=cmd_demo_data)
return parser
def main(argv: list[str] | None = None) -> int:
parser = build_parser()
args = parser.parse_args(argv)
return args.func(args)
if __name__ == "__main__":
raise SystemExit(main(sys.argv[1:]))

BIN
validation-suite/backend/mercury/app/core/__pycache__/config.cpython-313.pyc
View file

Binary file not shown.

BIN
validation-suite/backend/mercury/app/core/__pycache__/security.cpython-313.pyc
View file

Binary file not shown.

1
validation-suite/backend/mercury/app/core/config.py
View file

@ -17,7 +17,6 @@ class Settings(BaseSettings):
jwt_algorithm: str = "HS256"
access_token_minutes: int = 60 * 8
cors_origins: list[str] = ["http://localhost:3000"]
public_base_url: str = Field(default="http://localhost:8000", alias="PUBLIC_BASE_URL")
admin_email: str = Field(default="admin@schubamed.de", alias="ADMIN_EMAIL")
admin_password: str = Field(default="ValidationSuite!2026", alias="ADMIN_PASSWORD")

3
validation-suite/backend/mercury/app/core/security.py
View file

@ -18,5 +18,6 @@ def verify_password(password: str, password_hash: str) -> bool:
def create_access_token(subject: str, role: str) -> str:
expires_at = datetime.now(UTC) + timedelta(minutes=settings.access_token_minutes)
payload = {"sub": subject, "role": role, "iss": settings.app_name, "iat": datetime.now(UTC), "type": "access", "exp": expires_at}
payload = {"sub": subject, "role": role, "exp": expires_at}
return jwt.encode(payload, settings.jwt_secret, algorithm=settings.jwt_algorithm)

BIN
validation-suite/backend/mercury/app/db/__pycache__/base.cpython-313.pyc
View file

Binary file not shown.

BIN
validation-suite/backend/mercury/app/db/__pycache__/seed.cpython-313.pyc
View file

Binary file not shown.

BIN
validation-suite/backend/mercury/app/db/__pycache__/session.cpython-313.pyc
View file

Binary file not shown.

7
validation-suite/backend/mercury/app/db/seed.py
View file

@ -16,12 +16,10 @@ def seed_admin() -> None:
session.add(
User(
email=settings.admin_email.lower(),
first_name="Validation Suite",
last_name="Administrator",
role=UserRole.ADMIN.value,
full_name="Validation Suite Administrator",
role=UserRole.admin,
password_hash=hash_password(settings.admin_password),
is_active=True,
must_change_password=False,
)
)
session.commit()
@ -29,3 +27,4 @@ def seed_admin() -> None:
if __name__ == "__main__":
seed_admin()

15
validation-suite/backend/mercury/app/main.py
View file

@ -1,15 +1,10 @@
from __future__ import annotations
from pathlib import Path
from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware
from fastapi.staticfiles import StaticFiles
from app.api.v1.router import api_router
from app.core.config import settings
from app.db.session import SessionLocal
from app.modules.orion.template_service import ReportTemplateService
app = FastAPI(title=settings.app_name, version="0.1.0")
app.add_middleware(
@ -19,18 +14,10 @@ app.add_middleware(
allow_methods=["*"],
allow_headers=["*"],
)
Path("/app/uploads").mkdir(parents=True, exist_ok=True)
app.mount("/uploads", StaticFiles(directory="/app/uploads"), name="uploads")
app.include_router(api_router)
@app.on_event("startup")
def load_reference_templates() -> None:
with SessionLocal() as session:
ReportTemplateService(session).ensure_default_template()
session.commit()
@app.get("/health")
def health() -> dict[str, str]:
return {"status": "ok"}

16
validation-suite/backend/mercury/app/models/__init__.py
View file

@ -5,15 +5,6 @@ from app.models.document import Document
from app.models.equipment import Equipment
from app.models.location import Location
from app.models.program import Program
from app.models.report_template import (
ChecklistTemplate,
MeasurementImport,
MeasurementImportValue,
ReportSection,
ReportTemplate,
TextBlock,
)
from app.models.report_settings import OrionReportSettings
from app.models.user import User
from app.models.validation import Validation
@ -25,13 +16,6 @@ __all__ = [
"Equipment",
"Location",
"Program",
"ChecklistTemplate",
"MeasurementImport",
"MeasurementImportValue",
"ReportSection",
"ReportTemplate",
"OrionReportSettings",
"TextBlock",
"User",
"Validation",
]

BIN
validation-suite/backend/mercury/app/models/__pycache__/__init__.cpython-313.pyc
View file

Binary file not shown.

BIN
validation-suite/backend/mercury/app/models/__pycache__/contact.cpython-313.pyc
View file

Binary file not shown.

BIN
validation-suite/backend/mercury/app/models/__pycache__/customer.cpython-313.pyc
View file

Binary file not shown.

BIN
validation-suite/backend/mercury/app/models/__pycache__/device.cpython-313.pyc
View file

Binary file not shown.

BIN
validation-suite/backend/mercury/app/models/__pycache__/document.cpython-313.pyc
View file

Binary file not shown.

BIN
validation-suite/backend/mercury/app/models/__pycache__/equipment.cpython-313.pyc
View file

Binary file not shown.

BIN
validation-suite/backend/mercury/app/models/__pycache__/location.cpython-313.pyc
View file

Binary file not shown.

BIN
validation-suite/backend/mercury/app/models/__pycache__/program.cpython-313.pyc
View file

Binary file not shown.

BIN
validation-suite/backend/mercury/app/models/__pycache__/report_template.cpython-313.pyc
View file

Binary file not shown.

BIN
validation-suite/backend/mercury/app/models/__pycache__/user.cpython-313.pyc
View file

Binary file not shown.

BIN
validation-suite/backend/mercury/app/models/__pycache__/validation.cpython-313.pyc
View file

Binary file not shown.

2
validation-suite/backend/mercury/app/models/contact.py
View file

@ -14,6 +14,6 @@ class Contact(Base, UUIDMixin, TimestampMixin):
function: Mapped[str | None] = mapped_column(String(120))
email: Mapped[str | None] = mapped_column(String(255))
phone: Mapped[str | None] = mapped_column(String(80))
notes: Mapped[str | None] = mapped_column(String(500))
customer: Mapped["Customer"] = relationship(back_populates="contacts")

3
validation-suite/backend/mercury/app/models/customer.py
View file

@ -17,8 +17,6 @@ class Customer(Base, UUIDMixin, TimestampMixin):
__tablename__ = "customers"
customer_type: Mapped[CustomerType] = mapped_column(Enum(CustomerType))
source_system: Mapped[str | None] = mapped_column(String(80), index=True)
external_id: Mapped[str | None] = mapped_column(String(120), index=True)
name: Mapped[str] = mapped_column(String(220), index=True)
street: Mapped[str | None] = mapped_column(String(220))
postal_code: Mapped[str | None] = mapped_column(String(20))
@ -31,3 +29,4 @@ class Customer(Base, UUIDMixin, TimestampMixin):
contacts: Mapped[list["Contact"]] = relationship(back_populates="customer", cascade="all, delete-orphan")
locations: Mapped[list["Location"]] = relationship(back_populates="customer", cascade="all, delete-orphan")

2
validation-suite/backend/mercury/app/models/device.py
View file

@ -24,6 +24,6 @@ class Device(Base, UUIDMixin, TimestampMixin):
water_treatment: Mapped[str | None] = mapped_column(String(220))
documentation: Mapped[str | None] = mapped_column(Text)
supplier: Mapped[str | None] = mapped_column(String(180))
notes: Mapped[str | None] = mapped_column(Text)
location: Mapped["Location | None"] = relationship(back_populates="devices")

2
validation-suite/backend/mercury/app/models/equipment.py
View file

@ -32,4 +32,4 @@ class Equipment(Base, UUIDMixin, TimestampMixin):
calibration_due_on: Mapped[date | None] = mapped_column(Date)
certificate_document_id: Mapped[str | None] = mapped_column(String(80))
status: Mapped[EquipmentStatus] = mapped_column(Enum(EquipmentStatus), default=EquipmentStatus.green)
notes: Mapped[str | None] = mapped_column(String(500))

78
validation-suite/backend/mercury/app/models/report_settings.py
View file

@ -1,78 +0,0 @@
from __future__ import annotations
import enum
from sqlalchemy import Boolean, ForeignKey, Integer, String
from sqlalchemy.orm import Mapped, mapped_column
from app.db.base import Base, TimestampMixin, UUIDMixin
class OrionReportSettingsScope(str, enum.Enum):
global_ = "GLOBAL"
class OrionLayoutProfile(str, enum.Enum):
compact = "COMPACT"
standard = "STANDARD"
class OrionSignatureMode(str, enum.Enum):
technical_only = "TECHNICAL_ONLY"
technical_and_client = "TECHNICAL_AND_CLIENT"
class OrionImageSize(str, enum.Enum):
small = "SMALL"
medium = "MEDIUM"
large = "LARGE"
class OrionPageMargin(str, enum.Enum):
narrow = "NARROW"
standard = "STANDARD"
wide = "WIDE"
class OrionSpacing(str, enum.Enum):
compact = "COMPACT"
standard = "STANDARD"
class OrionTableFontSize(str, enum.Enum):
small = "SMALL"
standard = "STANDARD"
class OrionImagePosition(str, enum.Enum):
stacked = "STACKED"
side_by_side = "SIDE_BY_SIDE"
class OrionLogoSize(str, enum.Enum):
small = "SMALL"
medium = "MEDIUM"
large = "LARGE"
class OrionReportSettings(Base, UUIDMixin, TimestampMixin):
__tablename__ = "orion_report_settings"
scope: Mapped[str] = mapped_column(String(40), nullable=False, unique=True, index=True)
layout_profile: Mapped[str] = mapped_column(String(40), nullable=False, default=OrionLayoutProfile.standard.value)
show_cover_result_text: Mapped[bool] = mapped_column(Boolean, nullable=False, default=True)
signature_mode: Mapped[str] = mapped_column(String(60), nullable=False, default=OrionSignatureMode.technical_only.value)
image_size: Mapped[str] = mapped_column(String(40), nullable=False, default=OrionImageSize.medium.value)
page_break_before_main_chapters: Mapped[bool] = mapped_column(Boolean, nullable=False, default=True)
page_margin: Mapped[str] = mapped_column(String(40), nullable=False, default=OrionPageMargin.standard.value)
section_spacing: Mapped[str] = mapped_column(String(40), nullable=False, default=OrionSpacing.standard.value)
table_layout: Mapped[str] = mapped_column(String(40), nullable=False, default=OrionSpacing.standard.value)
table_font_size: Mapped[str] = mapped_column(String(40), nullable=False, default=OrionTableFontSize.standard.value)
image_position: Mapped[str] = mapped_column(String(40), nullable=False, default=OrionImagePosition.side_by_side.value)
max_images_per_page: Mapped[int] = mapped_column(Integer, nullable=False, default=2)
show_image_captions: Mapped[bool] = mapped_column(Boolean, nullable=False, default=True)
show_header: Mapped[bool] = mapped_column(Boolean, nullable=False, default=True)
show_footer: Mapped[bool] = mapped_column(Boolean, nullable=False, default=True)
logo_size: Mapped[str] = mapped_column(String(40), nullable=False, default=OrionLogoSize.medium.value)
compact_cover: Mapped[bool] = mapped_column(Boolean, nullable=False, default=False)
updated_by_user_id: Mapped[str | None] = mapped_column(ForeignKey("users.id"), nullable=True, index=True)

98
validation-suite/backend/mercury/app/models/report_template.py
View file

@ -1,98 +0,0 @@
from __future__ import annotations
import enum
from sqlalchemy import Boolean, ForeignKey, Integer, JSON, String, Text
from sqlalchemy.orm import Mapped, mapped_column
from app.db.base import Base, TimestampMixin, UUIDMixin
class ReportTemplate(Base, UUIDMixin, TimestampMixin):
__tablename__ = "report_templates"
template_key: Mapped[str] = mapped_column(String(120), unique=True, index=True)
name: Mapped[str] = mapped_column(String(180))
version: Mapped[str] = mapped_column(String(40))
validation_type: Mapped[str] = mapped_column(String(120), index=True)
reference_path: Mapped[str] = mapped_column(String(500))
active: Mapped[bool] = mapped_column(Boolean, default=True, index=True)
class TextBlock(Base, UUIDMixin, TimestampMixin):
__tablename__ = "text_blocks"
template_id: Mapped[str] = mapped_column(ForeignKey("report_templates.id"), index=True)
block_key: Mapped[str] = mapped_column(String(160), index=True)
title: Mapped[str] = mapped_column(String(240))
content: Mapped[str] = mapped_column(Text)
order_index: Mapped[int] = mapped_column(Integer, default=0)
version: Mapped[str] = mapped_column(String(40), default="1.0")
active: Mapped[bool] = mapped_column(Boolean, default=True, index=True)
class ReportSection(Base, UUIDMixin, TimestampMixin):
__tablename__ = "report_sections"
template_id: Mapped[str] = mapped_column(ForeignKey("report_templates.id"), index=True)
section_key: Mapped[str] = mapped_column(String(160), index=True)
number: Mapped[str | None] = mapped_column(String(40))
title: Mapped[str] = mapped_column(String(240))
order_index: Mapped[int] = mapped_column(Integer, default=0)
page_break_before: Mapped[bool] = mapped_column(Boolean, default=False)
active: Mapped[bool] = mapped_column(Boolean, default=True, index=True)
class ChecklistTemplate(Base, UUIDMixin, TimestampMixin):
__tablename__ = "checklist_templates"
template_id: Mapped[str] = mapped_column(ForeignKey("report_templates.id"), index=True)
checklist_key: Mapped[str] = mapped_column(String(160), index=True)
title: Mapped[str] = mapped_column(String(240))
columns: Mapped[list[str]] = mapped_column(JSON, default=list)
items: Mapped[list[dict]] = mapped_column(JSON, default=list)
order_index: Mapped[int] = mapped_column(Integer, default=0)
active: Mapped[bool] = mapped_column(Boolean, default=True, index=True)
class MeasurementImportStatus(str, enum.Enum):
uploaded = "HOCHGELADEN"
analyzing = "ANALYSE_LAEUFT"
preview_ready = "VORSCHAU_BEREIT"
confirmed = "BESTAETIGT"
error = "FEHLER"
attachment_only = "NUR_ANLAGE"
class MeasurementImportType(str, enum.Enum):
winlog_csv = "WINLOG_CSV"
winlog_pdf = "WINLOG_PDF"
winlog_attachment_only = "WINLOG_ATTACHMENT_ONLY"
class MeasurementImport(Base, UUIDMixin, TimestampMixin):
__tablename__ = "measurement_imports"
validation_id: Mapped[str] = mapped_column(ForeignKey("validations.id"), index=True)
import_type: Mapped[str] = mapped_column(String(60), index=True)
original_filename: Mapped[str] = mapped_column(String(255))
storage_path: Mapped[str] = mapped_column(String(500))
sha256: Mapped[str] = mapped_column(String(64), index=True)
parser_version: Mapped[str] = mapped_column(String(40))
status: Mapped[str] = mapped_column(String(60), index=True)
class MeasurementImportValue(Base, UUIDMixin, TimestampMixin):
__tablename__ = "measurement_import_values"
import_id: Mapped[str] = mapped_column(ForeignKey("measurement_imports.id"), index=True)
test_run: Mapped[str] = mapped_column(String(120), index=True)
field_name: Mapped[str] = mapped_column(String(120), index=True)
raw_value: Mapped[str | None] = mapped_column(Text)
normalized_value: Mapped[str | None] = mapped_column(String(180))
unit: Mapped[str | None] = mapped_column(String(40))
source_page: Mapped[int | None] = mapped_column(Integer)
source_text: Mapped[str | None] = mapped_column(Text)
confidence: Mapped[int] = mapped_column(Integer, default=0)
confirmed: Mapped[bool] = mapped_column(Boolean, default=False, index=True)
corrected_value: Mapped[str | None] = mapped_column(String(180))

29
validation-suite/backend/mercury/app/models/user.py
View file

@ -1,40 +1,25 @@
from __future__ import annotations
import enum
from datetime import datetime
from sqlalchemy import Boolean, DateTime, String
from sqlalchemy.orm import Mapped, mapped_column, validates
from sqlalchemy import Boolean, Enum, String
from sqlalchemy.orm import Mapped, mapped_column
from app.db.base import Base, TimestampMixin, UUIDMixin
class UserRole(str, enum.Enum):
ADMIN = "admin"
PRUEFER = "pruefer"
MITARBEITER = "mitarbeiter"
LESER = "leser"
admin = "admin"
employee = "employee"
auditor = "auditor"
class User(Base, UUIDMixin, TimestampMixin):
__tablename__ = "users"
email: Mapped[str] = mapped_column(String(255), unique=True, index=True)
full_name: Mapped[str] = mapped_column(String(160), nullable=False)
first_name: Mapped[str] = mapped_column(String(80))
last_name: Mapped[str] = mapped_column(String(80))
role: Mapped[str] = mapped_column(String(50), nullable=False, default=UserRole.MITARBEITER.value)
full_name: Mapped[str] = mapped_column(String(160))
role: Mapped[UserRole] = mapped_column(Enum(UserRole), default=UserRole.employee)
password_hash: Mapped[str] = mapped_column(String(255))
is_active: Mapped[bool] = mapped_column(Boolean, default=True)
must_change_password: Mapped[bool] = mapped_column(Boolean, default=True)
deleted_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
last_login_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
password_changed_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
@validates("first_name", "last_name")
def _sync_full_name(self, key: str, value: str) -> str:
first_name = value if key == "first_name" else getattr(self, "first_name", None)
last_name = value if key == "last_name" else getattr(self, "last_name", None)
if first_name is not None and last_name is not None:
self.full_name = f"{first_name} {last_name}".strip()
return value

22
validation-suite/backend/mercury/app/models/validation.py
View file

@ -3,19 +3,17 @@ from __future__ import annotations
import enum
from datetime import date
from sqlalchemy import Boolean, Date, ForeignKey, Integer, JSON, String, Text
from sqlalchemy import Date, Enum, ForeignKey, JSON, String, Text
from sqlalchemy.orm import Mapped, mapped_column
from app.db.base import Base, TimestampMixin, UUIDMixin
class ValidationStatus(str, enum.Enum):
draft = "ENTWURF"
ready_for_review = "BEREIT_ZUR_PRUEFUNG"
in_review = "IN_PRUEFUNG"
approved = "FREIGEGEBEN"
completed = "ABGESCHLOSSEN"
cancelled = "STORNIERT"
draft = "draft"
in_progress = "in_progress"
ready_for_report = "ready_for_report"
completed = "completed"
class Validation(Base, UUIDMixin, TimestampMixin):
@ -24,7 +22,7 @@ class Validation(Base, UUIDMixin, TimestampMixin):
report_number: Mapped[str] = mapped_column(String(80), unique=True, index=True)
customer_id: Mapped[str] = mapped_column(ForeignKey("customers.id"), index=True)
location_id: Mapped[str | None] = mapped_column(ForeignKey("locations.id"), index=True)
contact_id: Mapped[str | None] = mapped_column(ForeignKey("contacts.id"), index=True, nullable=True)
contact_id: Mapped[str | None] = mapped_column(ForeignKey("contacts.id"), index=True)
device_id: Mapped[str | None] = mapped_column(ForeignKey("devices.id"), index=True)
validation_type: Mapped[str] = mapped_column(String(120))
project: Mapped[str | None] = mapped_column(String(180))
@ -35,12 +33,8 @@ class Validation(Base, UUIDMixin, TimestampMixin):
scheduled_on: Mapped[date | None] = mapped_column(Date)
performed_on: Mapped[date | None] = mapped_column(Date)
next_validation_on: Mapped[date | None] = mapped_column(Date)
revalidation_interval_months: Mapped[int] = mapped_column(Integer, default=24)
next_validation_manually_overridden: Mapped[bool] = mapped_column(Boolean, default=False)
version: Mapped[int] = mapped_column(Integer, default=1)
previous_validation_id: Mapped[str | None] = mapped_column(ForeignKey("validations.id"), nullable=True)
examiner_id: Mapped[str | None] = mapped_column(ForeignKey("users.id"), nullable=True)
status: Mapped[str] = mapped_column(String(40), default=ValidationStatus.draft.value)
examiner_id: Mapped[str | None] = mapped_column(ForeignKey("users.id"))
status: Mapped[ValidationStatus] = mapped_column(Enum(ValidationStatus), default=ValidationStatus.draft)
result: Mapped[str | None] = mapped_column(String(120))
notes: Mapped[str | None] = mapped_column(Text)
equipment_ids: Mapped[list[str]] = mapped_column(JSON, default=list)

BIN
validation-suite/backend/mercury/app/modules/helios/__pycache__/service.cpython-313.pyc
View file

Binary file not shown.

185
validation-suite/backend/mercury/app/modules/helios/service.py
View file

@ -1,21 +1,9 @@
from __future__ import annotations
import csv
import hashlib
import re
from dataclasses import dataclass
from pathlib import Path
from sqlalchemy import select
from sqlalchemy.orm import Session
from app.models.report_template import (
MeasurementImport,
MeasurementImportStatus,
MeasurementImportType,
MeasurementImportValue,
)
@dataclass(frozen=True)
class MeasurementSeries:
@ -24,181 +12,8 @@ class MeasurementSeries:
class HeliosImportService:
parser_version = "helios-winlog-pdf-1.0"
def __init__(self, session: Session | None = None, upload_root: Path | None = None) -> None:
self.session = session
self.upload_root = upload_root or Path("/app/uploads")
def import_csv(self, path: Path) -> MeasurementSeries:
with path.open(newline="", encoding="utf-8-sig") as handle:
reader = csv.DictReader(handle)
return MeasurementSeries(headers=reader.fieldnames or [], rows=list(reader))
def save_winlog_pdf(
self, validation_id: str, filename: str, content: bytes, attachment_only: bool = False
) -> dict:
if self.session is None:
raise RuntimeError("A database session is required for Winlog imports")
safe_name = Path(filename or "winlog.pdf").name
target_dir = self.upload_root / "validations" / validation_id / "winlog"
target_dir.mkdir(parents=True, exist_ok=True)
storage_path = target_dir / safe_name
storage_path.write_bytes(content)
digest = hashlib.sha256(content).hexdigest()
import_row = MeasurementImport(
validation_id=validation_id,
import_type=(
MeasurementImportType.winlog_attachment_only.value
if attachment_only
else MeasurementImportType.winlog_pdf.value
),
original_filename=safe_name,
storage_path=str(storage_path),
sha256=digest,
parser_version=self.parser_version,
status=(
MeasurementImportStatus.attachment_only.value
if attachment_only
else MeasurementImportStatus.uploaded.value
),
)
self.session.add(import_row)
self.session.flush()
values: list[MeasurementImportValue] = []
if not attachment_only:
values = self._extract_pdf_values(import_row, storage_path)
import_row.status = (
MeasurementImportStatus.preview_ready.value
if values
else MeasurementImportStatus.attachment_only.value
)
import_row.import_type = (
MeasurementImportType.winlog_pdf.value
if values
else MeasurementImportType.winlog_attachment_only.value
)
self.session.flush()
return self.preview(import_row.id)
def preview(self, import_id: str) -> dict:
if self.session is None:
raise RuntimeError("A database session is required for Winlog imports")
import_row = self.session.get(MeasurementImport, import_id)
if import_row is None:
raise ValueError("Measurement import not found")
values = list(
self.session.scalars(
select(MeasurementImportValue).where(MeasurementImportValue.import_id == import_id)
)
)
return {
"id": import_row.id,
"validation_id": import_row.validation_id,
"import_type": import_row.import_type,
"original_filename": import_row.original_filename,
"sha256": import_row.sha256,
"parser_version": import_row.parser_version,
"status": import_row.status,
"values": [
{
"id": value.id,
"test_run": value.test_run,
"field_name": value.field_name,
"raw_value": value.raw_value,
"normalized_value": value.normalized_value,
"unit": value.unit,
"source_page": value.source_page,
"source_text": value.source_text,
"confidence": value.confidence,
"confirmed": value.confirmed,
"corrected_value": value.corrected_value,
}
for value in values
],
}
def confirm_values(self, import_id: str, values: list[dict]) -> dict:
if self.session is None:
raise RuntimeError("A database session is required for Winlog imports")
import_row = self.session.get(MeasurementImport, import_id)
if import_row is None:
raise ValueError("Measurement import not found")
by_id = {
value.id: value
for value in self.session.scalars(
select(MeasurementImportValue).where(MeasurementImportValue.import_id == import_id)
)
}
for payload in values:
item = by_id.get(payload.get("id"))
if item is None:
continue
item.confirmed = bool(payload.get("confirmed"))
item.corrected_value = payload.get("corrected_value") or item.corrected_value
import_row.status = MeasurementImportStatus.confirmed.value
self.session.flush()
return self.preview(import_id)
def _extract_pdf_values(self, import_row: MeasurementImport, path: Path) -> list[MeasurementImportValue]:
from pypdf import PdfReader
values: list[MeasurementImportValue] = []
try:
reader = PdfReader(str(path))
pages = [page.extract_text() or "" for page in reader.pages]
except Exception:
import_row.status = MeasurementImportStatus.error.value
return []
for page_index, page_text in enumerate(pages, start=1):
if not page_text.strip():
continue
test_run = self._detect_test_run(page_text)
for field_name, pattern, unit in self._patterns():
match = re.search(pattern, page_text, flags=re.IGNORECASE)
if not match:
continue
raw_value = match.group(1).strip()
value = MeasurementImportValue(
import_id=import_row.id,
test_run=test_run,
field_name=field_name,
raw_value=raw_value,
normalized_value=raw_value,
unit=unit,
source_page=page_index,
source_text=match.group(0)[:500],
confidence=80,
confirmed=False,
corrected_value=None,
)
self.session.add(value)
values.append(value)
return values
def _detect_test_run(self, text: str) -> str:
lower = text.lower()
if "vakuum" in lower:
return "Vakuumtest"
if "bowie" in lower or "leerkammer" in lower:
return "Bowie-Dick / Leerkammerprofil"
for index in (1, 2, 3):
if f"testlauf {index}" in lower or f"test {index}" in lower:
return f"Testlauf {index}"
return "nicht zugeordnet"
def _patterns(self) -> list[tuple[str, str, str | None]]:
return [
("program_name", r"Programm(?:name)?[:\s]+([^\n]+)", None),
("batch_number", r"Charge(?:nnummer)?[:\s]+([^\n]+)", None),
("start_time", r"Start(?:zeit)?[:\s]+([0-9:.\-\s]+)", None),
("end_time", r"(?:Ende|Endzeit)[:\s]+([0-9:.\-\s]+)", None),
("duration", r"Dauer[:\s]+([0-9:.\-\s]+)", None),
("min_temperature", r"Min(?:dest)?temperatur[:\s]+([0-9,.]+)", "°C"),
("max_temperature", r"Max(?:imal|\.)?temperatur[:\s]+([0-9,.]+)", "°C"),
("temperature_band", r"Temperaturband[:\s]+([0-9,.]+)", "K"),
("holding_time", r"Haltezeit[:\s]+([0-9:.\-\s]+)", None),
("pressure", r"Druck[:\s]+([0-9,.-]+)", "bar"),
("leak_rate", r"Leckrate[:\s]+([0-9,.-]+)", "mbar/min"),
("result", r"Ergebnis[:\s]+([^\n]+)", None),
]

BIN
validation-suite/backend/mercury/app/modules/orion/__pycache__/assets.cpython-313.pyc
View file

Binary file not shown.

BIN
validation-suite/backend/mercury/app/modules/orion/__pycache__/context.cpython-313.pyc
View file

Binary file not shown.

BIN
validation-suite/backend/mercury/app/modules/orion/__pycache__/html.cpython-313.pyc
View file

Binary file not shown.

BIN
validation-suite/backend/mercury/app/modules/orion/__pycache__/result.cpython-313.pyc
View file

Binary file not shown.

BIN
validation-suite/backend/mercury/app/modules/orion/__pycache__/service.cpython-313.pyc
View file

Binary file not shown.

BIN
validation-suite/backend/mercury/app/modules/orion/__pycache__/template_service.cpython-313.pyc
View file

Binary file not shown.

12
validation-suite/backend/mercury/app/modules/orion/assets.py
View file

@ -1,12 +0,0 @@
from __future__ import annotations
from pathlib import Path
ORION_ASSET_DIR = Path(__file__).resolve().parent / "assets"
SCHUBAMED_LOGO_PATH = ORION_ASSET_DIR / "schubamed-logo.svg"
def schubamed_logo_uri() -> str:
if not SCHUBAMED_LOGO_PATH.exists():
raise FileNotFoundError(f"Required Orion logo asset is missing: {SCHUBAMED_LOGO_PATH}")
return SCHUBAMED_LOGO_PATH.resolve().as_uri()

9
validation-suite/backend/mercury/app/modules/orion/assets/schubamed-logo.svg
View file

@ -1,9 +0,0 @@
<?xml version="1.0" ?>
<svg xmlns="http://www.w3.org/2000/svg" version="1.1" viewBox="0 0 640 480">
<path d="M476,95 L483,94 L486,97 L486,99 L484,101 L477,102 Z" fill="#F60B2F"/>
<path d="M473,92 L473,112 L476,112 L477,104 L480,104 L485,112 L489,112 L485,106 L489,101 L488,93 Z" fill="#F60B2F"/>
<path d="M476,83 L487,84 L496,92 L498,97 L498,107 L496,111 L485,120 L475,120 L470,118 L464,112 L461,106 L461,98 L464,91 L469,86 Z" fill="#F60B2F"/>
<path d="M329,84 L328,399 L329,401 L338,401 L354,399 L358,396 L358,119 L363,118 L385,127 L391,133 L392,386 L403,381 L417,372 L421,365 L422,158 L432,170 L444,193 L450,211 L454,230 L454,250 L448,281 L441,297 L440,303 L460,316 L466,315 L478,284 L483,255 L483,232 L480,210 L470,178 L454,150 L431,124 L407,106 L378,92 L350,85 Z" fill="#F60B2F"/>
<path d="M308,83 L283,86 L256,94 L235,104 L211,121 L193,139 L178,160 L167,182 L159,208 L159,216 L162,219 L278,285 L281,289 L280,367 L269,364 L250,355 L229,340 L211,320 L203,308 L194,289 L190,285 L186,283 L163,283 L162,288 L168,305 L184,334 L195,348 L209,362 L236,381 L268,395 L298,401 L310,400 L310,271 L303,265 L201,207 L192,200 L207,170 L217,157 L229,145 L255,127 L280,117 L281,200 L284,202 L307,202 L310,200 L310,84 Z" fill="#F60B2F"/>
<path d="M473,80 L467,83 L461,89 L458,95 L458,108 L463,117 L468,121 L476,124 L487,123 L493,120 L498,115 L501,109 L501,94 L497,87 L491,82 L486,80 Z" fill="#F60B2F"/>
</svg>
Side by side

Before

Width:  |  Height:  |  Size: 1.4 KiB

37
validation-suite/backend/mercury/app/modules/orion/components/__init__.py
View file

@ -1,37 +0,0 @@
from app.modules.orion.components.base import ReportComponent
from app.modules.orion.components.chapters import (
AttachmentComponent,
ChecklistComponent,
CoverComponent,
CustomerComponent,
DeviceComponent,
DryingComponent,
EnvironmentComponent,
EquipmentComponent,
LoadingComponent,
MeasurementComponent,
ProgramComponent,
RecommendationComponent,
StaticTextComponent,
SummaryComponent,
TocComponent,
)
__all__ = [
"AttachmentComponent",
"ChecklistComponent",
"CoverComponent",
"CustomerComponent",
"DeviceComponent",
"DryingComponent",
"EnvironmentComponent",
"EquipmentComponent",
"LoadingComponent",
"MeasurementComponent",
"ProgramComponent",
"RecommendationComponent",
"StaticTextComponent",
"ReportComponent",
"SummaryComponent",
"TocComponent",
]

BIN
validation-suite/backend/mercury/app/modules/orion/components/__pycache__/__init__.cpython-313.pyc
View file

Binary file not shown.

BIN
validation-suite/backend/mercury/app/modules/orion/components/__pycache__/base.cpython-313.pyc
View file

Binary file not shown.

BIN
validation-suite/backend/mercury/app/modules/orion/components/__pycache__/chapters.cpython-313.pyc
View file

Binary file not shown.

15
validation-suite/backend/mercury/app/modules/orion/components/base.py
View file

@ -1,15 +0,0 @@
from __future__ import annotations
from abc import ABC, abstractmethod
from app.modules.orion.context import ReportContext
class ReportComponent(ABC):
anchor: str
title: str
@abstractmethod
def render(self, context: ReportContext) -> str:
raise NotImplementedError

551
validation-suite/backend/mercury/app/modules/orion/components/chapters.py
View file

@ -1,551 +0,0 @@
from __future__ import annotations
from pathlib import Path
from urllib.parse import quote
from app.core.config import settings
from app.modules.orion.assets import schubamed_logo_uri
from app.modules.orion.components.base import ReportComponent
from app.modules.orion.context import ReportContext
from app.modules.orion.html import definition_list, paragraph, section, table, text, yes_no
from app.modules.orion.result import validation_result_box, validation_result_cover_sentence, validation_result_label
def render_template_text(content: str, context: ReportContext) -> str:
values = {
"device.manufacturer": context.device.manufacturer if context.device else None,
"device.model": context.device.model if context.device else None,
"device.serial_number": context.device.serial_number if context.device else None,
"customer.name": context.customer.name,
"location.city": context.location.city if context.location else None,
"validation.performed_on": context.validation.performed_on,
"validation.next_validation_on": context.validation.next_validation_on,
"validation.result": context.validation.result,
}
rendered = content
for key, value in values.items():
rendered = rendered.replace("{{ " + key + " }}", text(value))
return rendered
class NumberedComponent(ReportComponent):
anchor = ""
title = ""
def __init__(self, anchor: str | None = None, title: str | None = None, number: str | None = None) -> None:
if anchor is not None:
self.anchor = anchor
if title is not None:
self.title = title
self.number = number
@property
def bookmark_label(self) -> str:
return f"{self.number} {self.title}" if self.number else self.title
class CoverComponent(ReportComponent):
anchor = "cover"
title = "Deckblatt"
def render(self, context: ReportContext) -> str:
validation = context.validation
rows = definition_list(
[
("Hersteller", context.device.manufacturer if context.device else "nicht erfasst"),
("Geraet", context.device.model if context.device else "nicht erfasst"),
(
"Seriennummer",
context.device.serial_number if context.device else "nicht erfasst",
),
("Berichtsnummer", validation.report_number),
("Validierungsart", validation.validation_type),
("Projekt", validation.project),
("Pruefdatum", validation.performed_on),
("Pruefungsort", validation.test_location),
("Pruefer", validation.examiner_name),
("Status", validation.status),
(
"Ansprechpartner",
context.contact.full_name if context.contact else "nicht erfasst",
),
("Mitwirkende Personen", validation.participants or "nicht erfasst"),
]
)
logo_uri = schubamed_logo_uri()
return (
'<section class="cover-page" id="cover">'
'<div class="cover-top">'
'<div class="company-address">SCHUBAMED<br>Validation Suite<br>Medizintechnik und Validierung</div>'
f'<img class="cover-logo" src="{logo_uri}" alt="SCHUBAMED Validation Suite">'
"</div>"
"<h1>PRÜFBERICHT ZUR VALIDIERUNG</h1>"
'<p class="cover-subtitle">Funktions- und Leistungsqualifikation Klein-Sterilisator</p>'
f'<p class="cover-subtitle">{text(context.customer.name)}</p>'
f"{rows}"
'<div class="cover-closing">'
f"{self._cover_result_text(context)}"
f"{self._signature_blocks(context)}"
"</div>"
"</section>"
)
def _cover_result_text(self, context: ReportContext) -> str:
if not context.report_settings.show_cover_result_text:
return ""
return (
'<div class="cover-result-text">'
"<h2>Ergebnis der Validierung</h2>"
f"<p>{text(validation_result_cover_sentence(context.validation.result))}</p>"
"</div>"
)
def _signature_blocks(self, context: ReportContext) -> str:
blocks = [
'<div class="signature-block"><div class="signature-line"></div><div class="signature-label">Unterschrift technische Validierung</div></div>'
]
if context.report_settings.signature_mode == "TECHNICAL_AND_CLIENT":
blocks.append(
'<div class="signature-block"><div class="signature-line"></div><div class="signature-label">Unterschrift Auftraggeber</div></div>'
)
return '<div class="signature-grid">' + "".join(blocks) + "</div>"
class TocComponent(ReportComponent):
anchor = "toc"
title = "Inhaltsverzeichnis"
def __init__(self, sections: list[dict]) -> None:
self.sections = sections
def render(self, context: ReportContext) -> str:
links = "".join(
self._toc_item(item)
for item in self.sections
if item.get("toc")
)
return section(self.anchor, self.title, f'<ol class="toc-list">{links}</ol>')
def _toc_item(self, item: dict) -> str:
number = item.get("number")
title = item.get("title")
label = f"{number} {title}" if number else str(title)
depth = str(number).count(".") + 1 if number else 2
return (
f'<li class="toc-level-{depth}"><a href="#{text(item.get("key"))}">'
f'<span class="toc-label">{text(label)}</span></a></li>'
)
class SummaryComponent(ReportComponent):
anchor = "summary"
title = "Zusammenfassendes Ergebnis der Validierung"
def render(self, context: ReportContext) -> str:
validation = context.validation
block = context.text_blocks.get("summary")
body = validation_result_box(validation.result, compact=True)
body += f"<p>{paragraph(render_template_text(block.content, context) if block else 'nicht erfasst')}</p>"
body += definition_list(
[
("Kunde", context.customer.name),
("Standort", context.location.name if context.location else None),
(
"Geraet",
(
f"{context.device.manufacturer} {context.device.model}"
if context.device
else None
),
),
("Pruefmittel", len(context.equipment)),
("Ergebnis", validation_result_label(validation.result)),
("Mitwirkende Personen", validation.participants),
(
"Hinweis auf naechste Leistungsbeurteilung",
validation.next_validation_on or "nicht erfasst",
),
]
)
return section(self.anchor, self.title, body)
class StaticTextComponent(ReportComponent):
def __init__(
self,
anchor: str,
title: str,
body: str = "nicht erfasst",
block_key: str | None = None,
number: str | None = None,
) -> None:
self.anchor = anchor
self.title = title
self.body = body
self.block_key = block_key
self.number = number
@property
def bookmark_label(self) -> str:
return f"{self.number} {self.title}" if self.number else self.title
def render(self, context: ReportContext) -> str:
if self.anchor == "results":
body = validation_result_box(context.validation.result, compact=True)
body += f"<p>{paragraph(self.body)}</p>"
return section(self.anchor, self.title, body, self.bookmark_label)
if self.block_key and self.block_key in context.text_blocks:
content = render_template_text(context.text_blocks[self.block_key].content, context)
return section(self.anchor, self.title, f"<p>{paragraph(content)}</p>", self.bookmark_label)
return section(self.anchor, self.title, f"<p>{paragraph(self.body)}</p>", self.bookmark_label)
class CustomerComponent(ReportComponent):
anchor = "customer"
title = "Kunde, Standort und Ansprechpartner"
def render(self, context: ReportContext) -> str:
customer = context.customer
location = context.location
contact = context.contact
body = "<h3>Kunde</h3>" + definition_list(
[
("Name", customer.name),
("Typ", customer.customer_type.value),
(
"Adresse",
" ".join(filter(None, [customer.street, customer.postal_code, customer.city])),
),
("Telefon", customer.phone),
("Mail", customer.email),
("Betreiber", context.validation.operator_name),
("QM", customer.quality_manager),
("Hygienebeauftragter", customer.hygiene_officer),
]
)
if location:
body += "<h3>Standort</h3>" + definition_list(
[
("Name", location.name),
(
"Adresse",
" ".join(
filter(None, [location.street, location.postal_code, location.city])
),
),
("Raum", location.room),
]
)
if contact:
body += "<h3>Ansprechpartner</h3>" + definition_list(
[
("Name", contact.full_name),
("Funktion", contact.function),
("Mail", contact.email),
("Telefon", contact.phone),
]
)
return section(self.anchor, self.title, body)
class DeviceComponent(NumberedComponent):
anchor = "device"
title = "Geraet"
def render(self, context: ReportContext) -> str:
device = context.device
if device is None:
return section(self.anchor, self.title, "<p>nicht erfasst</p>", self.bookmark_label)
body = definition_list(
[
("Hersteller", device.manufacturer),
("Modell", device.model),
("Typ", device.device_type),
("Seriennummer", device.serial_number),
("Baujahr", device.year_built),
("Inbetriebnahme", device.commissioned_on),
(
"Kammervolumen",
(
f"{device.chamber_volume_liters} Liter"
if device.chamber_volume_liters
else None
),
),
("Dampferzeugung", device.steam_generation),
("Wasseraufbereitung", device.water_treatment),
("Dokumentation", device.documentation),
("Lieferant", device.supplier),
]
)
return section(self.anchor, self.title, body, self.bookmark_label)
class EquipmentComponent(NumberedComponent):
anchor = "equipment"
title = "Pruefmittel"
def render(self, context: ReportContext) -> str:
rows = [
[
item.kind.value,
item.manufacturer,
item.model,
item.serial_number,
item.calibrated_on,
item.calibration_due_on,
item.status.value,
]
for item in context.equipment
]
return section(
self.anchor,
self.title,
table(
[
"Art",
"Hersteller",
"Modell",
"Seriennummer",
"Kalibriert",
"Gueltig bis",
"Status",
],
rows,
),
self.bookmark_label,
)
class EnvironmentComponent(NumberedComponent):
anchor = "environment"
title = "Umgebungsbedingungen"
def render(self, context: ReportContext) -> str:
data = context.validation.environment_conditions or {}
body = definition_list(
[
("Raumtemperatur", data.get("room_temperature")),
("relative Luftfeuchtigkeit", data.get("humidity")),
("Pruefzeit", data.get("test_time")),
]
)
rows = [
[item.get("text"), yes_no(item.get("value")), item.get("comment")]
for item in data.get("checks", [])
]
if rows:
body += table(["Pruefpunkt", "Bewertung", "Kommentar"], rows)
return section(self.anchor, self.title, body, self.bookmark_label)
class ChecklistComponent(NumberedComponent):
anchor = "checklists"
title = "Dokumentations- und Leistungschecklisten"
def render(self, context: ReportContext) -> str:
body = ""
for checklist in context.checklist_templates:
body += f"<h3>{text(checklist.title)}</h3>"
body += self._render_items(checklist.items)
if not body:
documentation = context.validation.documentation_checklist or []
performance = context.validation.performance_checklist or []
body = "<h3>Dokumentation</h3>" + self._render_items(documentation)
body += "<h3>Leistung</h3>" + self._render_items(performance)
return section(self.anchor, self.title, body, self.bookmark_label)
def _render_items(self, items: list[dict]) -> str:
rows = [
[item.get("number"), item.get("text"), yes_no(item.get("value")), item.get("comment")]
for item in items
]
return table(["Nr.", "Pruefpunkt", "Bewertung", "Kommentar"], rows)
class ProgramComponent(NumberedComponent):
anchor = "programs"
title = "Programme"
def render(self, context: ReportContext) -> str:
programs = [item for item in (context.validation.programs or []) if item.get("selected")]
rows = [
[index + 1, item.get("name"), "Eigenes Programm" if item.get("custom") else "Standard"]
for index, item in enumerate(programs)
]
return section(self.anchor, self.title, table(["Nr.", "Programm", "Typ"], rows), self.bookmark_label)
class LoadingComponent(NumberedComponent):
anchor = "loading"
title = "Beladungsmuster"
def render(self, context: ReportContext) -> str:
rows = [
[
item.get("run"),
item.get("pattern"),
item.get("description"),
len(item.get("images", [])),
]
for item in context.validation.loading_patterns or []
]
return section(
self.anchor,
self.title,
table(["Testlauf", "Beladungsmuster", "Beschreibung", "Bilder"], rows),
self.bookmark_label,
)
class MeasurementComponent(NumberedComponent):
anchor = "measurements"
title = "Messdaten"
def render(self, context: ReportContext) -> str:
if context.confirmed_measurements:
rows = [
[
item.test_run,
item.field_name,
item.corrected_value or item.normalized_value or item.raw_value,
item.unit,
item.source_page,
f"{item.confidence} %",
]
for item in context.confirmed_measurements
]
return section(
self.anchor,
self.title,
table(["Testlauf", "Messwert", "Wert", "Einheit", "Quelle", "Sicherheit"], rows, "compact"),
self.bookmark_label,
)
rows = [
[
item.get("name"),
item.get("start_time"),
item.get("end_time"),
item.get("duration"),
item.get("leak_rate"),
item.get("min_temperature"),
item.get("max_temperature"),
item.get("temperature_band"),
item.get("holding_time"),
item.get("pressure"),
item.get("result"),
]
for item in context.validation.measurement_data or []
]
body = table(
[
"Bereich",
"Start",
"Ende",
"Dauer",
"Leckrate",
"Min. Temp.",
"Max. Temp.",
"Band",
"Haltezeit",
"Druck",
"Ergebnis",
],
rows,
"compact",
)
winlog_rows = []
for item in context.validation.measurement_data or []:
for imported in item.get("imports", []):
winlog_rows.append(
[item.get("name"), imported.get("filename"), imported.get("content_type")]
)
if winlog_rows:
body += "<h3>Winlog-Dateien</h3>" + table(["Bereich", "Datei", "Typ"], winlog_rows)
body += "<p>Messdaten noch nicht bestätigt.</p>"
return section(self.anchor, self.title, body, self.bookmark_label)
class DryingComponent(NumberedComponent):
anchor = "drying"
title = "Trocknung"
def render(self, context: ReportContext) -> str:
data = context.validation.drying or {}
body = definition_list(
[
("Startgewicht", data.get("start_weight")),
("Endgewicht", data.get("end_weight")),
("Differenz", data.get("difference")),
("Bewertung", data.get("rating")),
("Bemerkung", data.get("comment")),
]
)
return section(self.anchor, self.title, body, self.bookmark_label)
class RecommendationComponent(NumberedComponent):
anchor = "recommendations"
title = "Empfehlungen und Auflagen"
def render(self, context: ReportContext) -> str:
rows = [
[item.get("number"), item.get("text"), item.get("deadline"), item.get("status")]
for item in context.validation.recommendations or []
]
return section(self.anchor, self.title, table(["Nr.", "Text", "Frist", "Status"], rows), self.bookmark_label)
class AttachmentComponent(NumberedComponent):
anchor = "attachments"
title = "Bilder und Anlagen"
def render(self, context: ReportContext) -> str:
attachments = sorted(
context.validation.attachments or [], key=lambda row: row.get("order") or 0
)
rows = [
[item.get("order"), item.get("category"), item.get("filename"), item.get("description")]
for item in attachments
]
figures = []
for index, item in enumerate(attachments, start=1):
src = self._image_source(item)
if not src:
continue
caption = (
item.get("description") or item.get("filename") or item.get("category") or "Anlage"
)
figures.append(
'<figure class="report-figure">'
f'<img class="report-image" src="{text(src)}" alt="{text(caption)}">'
f'<figcaption class="image-caption">Abbildung {index}: {text(caption)}</figcaption>'
"</figure>"
)
body = table(["Reihenfolge", "Kategorie", "Datei", "Beschreibung"], rows)
if figures:
body += '<div class="figure-grid">' + "".join(figures) + "</div>"
return section(self.anchor, self.title, body, self.bookmark_label)
def _image_source(self, item: dict) -> str | None:
content_type = str(item.get("content_type") or "")
filename = str(item.get("filename") or "")
if not content_type.startswith("image/") and Path(filename).suffix.lower() not in {
".jpg",
".jpeg",
".png",
".webp",
".svg",
}:
return None
url = item.get("url")
if isinstance(url, str) and url:
if url.startswith(("http://", "https://")):
return url
return f"{settings.public_base_url.rstrip('/')}{quote(url, safe='/:._-')}"
storage_path = item.get("storage_path")
if storage_path:
path = Path(str(storage_path))
if path.exists():
return path.resolve().as_uri()
return None

96
validation-suite/backend/mercury/app/modules/orion/context.py
View file

@ -1,96 +0,0 @@
from __future__ import annotations
from dataclasses import dataclass
from pathlib import Path
from fastapi import HTTPException, status
from sqlalchemy import select
from sqlalchemy.orm import Session
from app.models.contact import Contact
from app.models.customer import Customer
from app.models.device import Device
from app.models.equipment import Equipment
from app.models.report_template import (
ChecklistTemplate,
MeasurementImport,
MeasurementImportValue,
ReportSection,
TextBlock,
)
from app.models.report_settings import OrionReportSettings
from app.models.location import Location
from app.models.validation import Validation
from app.modules.orion.template_service import ReportTemplateService
@dataclass(frozen=True)
class ReportContext:
validation: Validation
customer: Customer
location: Location | None
contact: Contact | None
device: Device | None
equipment: list[Equipment]
generated_dir: Path
report_sections: list[ReportSection]
text_blocks: dict[str, TextBlock]
checklist_templates: list[ChecklistTemplate]
confirmed_measurements: list[MeasurementImportValue]
report_settings: OrionReportSettings
class OrionContextBuilder:
def __init__(self, session: Session, generated_dir: Path) -> None:
self.session = session
self.generated_dir = generated_dir
def build(self, validation_id: str) -> ReportContext:
validation = self.session.get(Validation, validation_id)
if validation is None:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Validation not found")
customer = self.session.get(Customer, validation.customer_id)
if customer is None:
raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail="Validation has no customer")
location = self.session.get(Location, validation.location_id) if validation.location_id else None
contact = self.session.get(Contact, validation.contact_id) if validation.contact_id else None
device = self.session.get(Device, validation.device_id) if validation.device_id else None
equipment = []
if validation.equipment_ids:
equipment = list(
self.session.scalars(
select(Equipment).where(Equipment.id.in_(validation.equipment_ids))
)
)
template_bundle = ReportTemplateService(self.session).ensure_default_template()
from app.services.report_settings import OrionReportSettingsService
report_settings = OrionReportSettingsService(self.session).get_global()
confirmed_measurements = list(
self.session.scalars(
select(MeasurementImportValue)
.join_from(MeasurementImportValue, MeasurementImport)
.where(
MeasurementImport.validation_id == validation.id,
MeasurementImportValue.confirmed.is_(True),
)
)
)
self.generated_dir.mkdir(parents=True, exist_ok=True)
return ReportContext(
validation=validation,
customer=customer,
location=location,
contact=contact,
device=device,
equipment=equipment,
generated_dir=self.generated_dir,
report_sections=template_bundle.sections,
text_blocks=template_bundle.text_blocks,
checklist_templates=template_bundle.checklists,
confirmed_measurements=confirmed_measurements,
report_settings=report_settings,
)

52
validation-suite/backend/mercury/app/modules/orion/html.py
View file

@ -1,52 +0,0 @@
from __future__ import annotations
from datetime import date, datetime
from html import escape
from typing import Any
def text(value: Any) -> str:
if value is None or value == "":
return "nicht erfasst"
if isinstance(value, (date, datetime)):
return value.strftime("%d.%m.%Y")
return escape(str(value))
def paragraph(value: Any) -> str:
content = text(value)
return content.replace("\n", "<br>")
def yes_no(value: Any) -> str:
labels = {"yes": "Ja", "no": "Nein", "na": "Nicht zutreffend", True: "Ja", False: "Nein"}
return text(labels.get(value, value))
def definition_list(rows: list[tuple[str, Any]]) -> str:
items = "".join(
f"<div class=\"definition-row\"><dt>{text(label)}</dt><dd>{paragraph(value)}</dd></div>"
for label, value in rows
if value not in (None, "", [])
)
return f"<dl class=\"definition-list\">{items}</dl>"
def table(headers: list[str], rows: list[list[Any]], css_class: str = "") -> str:
head = "".join(f"<th>{text(header)}</th>" for header in headers)
body = "".join(
"<tr>" + "".join(f"<td>{paragraph(cell)}</td>" for cell in row) + "</tr>"
for row in rows
)
return f"<table class=\"data-table {css_class}\"><thead><tr>{head}</tr></thead><tbody>{body}</tbody></table>"
def section(chapter_id: str, title: str, body: str, bookmark_label: str | None = None) -> str:
bookmark_attr = (
f' data-bookmark-label="{text(bookmark_label)}"' if bookmark_label is not None else ""
)
heading = bookmark_label or title
return (
f'<section class="chapter" id="{text(chapter_id)}">'
f'<h2 class="chapter-title"{bookmark_attr}>{text(heading)}</h2>{body}</section>'
)

77
validation-suite/backend/mercury/app/modules/orion/result.py
View file

@ -1,77 +0,0 @@
from __future__ import annotations
from dataclasses import dataclass
from app.modules.orion.html import text
@dataclass(frozen=True)
class ResultPresentation:
key: str
label: str
css_class: str
color: str
RESULT_PRESENTATIONS: dict[str, ResultPresentation] = {
"BESTANDEN": ResultPresentation("BESTANDEN", "Bestanden", "result-box--passed", "#245C36"),
"BESTANDEN_MIT_AUFLAGEN": ResultPresentation(
"BESTANDEN_MIT_AUFLAGEN",
"Bestanden mit Auflagen",
"result-box--conditional",
"#7A5A00",
),
"NICHT_BESTANDEN": ResultPresentation(
"NICHT_BESTANDEN",
"Nicht bestanden",
"result-box--failed",
"#7A1F26",
),
"OFFEN": ResultPresentation("OFFEN", "Noch nicht bewertet", "result-box--open", "#2E3B40"),
}
RESULT_ALIASES = {
"": "OFFEN",
"OFFEN": "OFFEN",
"BESTANDEN": "BESTANDEN",
"BESTANDEN_MIT_AUFLAGEN": "BESTANDEN_MIT_AUFLAGEN",
"NICHT_BESTANDEN": "NICHT_BESTANDEN",
"offen": "OFFEN",
"bestanden": "BESTANDEN",
"bestanden_mit_auflagen": "BESTANDEN_MIT_AUFLAGEN",
"mit_auflagen": "BESTANDEN_MIT_AUFLAGEN",
"bestanden mit Auflagen": "BESTANDEN_MIT_AUFLAGEN",
"nicht_bestanden": "NICHT_BESTANDEN",
"nicht bestanden": "NICHT_BESTANDEN",
}
def validation_result_presentation(value: str | None) -> ResultPresentation:
key = RESULT_ALIASES.get(str(value or "").strip(), "OFFEN")
return RESULT_PRESENTATIONS[key]
def validation_result_label(value: str | None) -> str:
return validation_result_presentation(value).label
def validation_result_cover_sentence(value: str | None) -> str:
presentation = validation_result_presentation(value)
sentences = {
"BESTANDEN": "Die technische Validierung wurde erfolgreich bestanden.",
"BESTANDEN_MIT_AUFLAGEN": "Die technische Validierung wurde mit Auflagen bestanden.",
"NICHT_BESTANDEN": "Die technische Validierung wurde nicht bestanden.",
"OFFEN": "Die technische Validierung wurde noch nicht bewertet.",
}
return sentences[presentation.key]
def validation_result_box(value: str | None, *, compact: bool = False) -> str:
presentation = validation_result_presentation(value)
size_class = "result-box--compact" if compact else "result-box--cover"
return (
f'<div class="result-box {size_class} {presentation.css_class}">'
'<div class="result-box__label">VALIDIERUNGSERGEBNIS</div>'
f'<div class="result-box__value">{text(presentation.label.upper() if not compact else presentation.label)}</div>'
"</div>"
)

302
validation-suite/backend/mercury/app/modules/orion/service.py
View file

@ -1,292 +1,30 @@
from __future__ import annotations
from pathlib import Path
import logging
from datetime import UTC, date, datetime
from types import SimpleNamespace
from sqlalchemy.orm import Session
from app.modules.orion.assets import ORION_ASSET_DIR
from app.modules.orion.components import (
AttachmentComponent,
ChecklistComponent,
CoverComponent,
CustomerComponent,
DeviceComponent,
DryingComponent,
EnvironmentComponent,
EquipmentComponent,
LoadingComponent,
MeasurementComponent,
ProgramComponent,
RecommendationComponent,
ReportComponent,
StaticTextComponent,
SummaryComponent,
TocComponent,
)
from app.modules.orion.context import OrionContextBuilder, ReportContext
from app.modules.orion.html import section, table, text
from app.modules.orion.templates.report import render_document
from app.modules.orion.template_service import REPORT_SECTIONS
from app.models.report_settings import (
OrionImageSize,
OrionLayoutProfile,
OrionReportSettings,
OrionReportSettingsScope,
OrionSignatureMode,
)
from app.schemas.domain import OrionReportSettingsUpdate
logger = logging.getLogger(__name__)
from weasyprint import HTML
class OrionReportService:
def __init__(self, session: Session, generated_dir: Path | None = None) -> None:
self.session = session
self.generated_dir = generated_dir or Path("/app/reports")
chapters = [
"Deckblatt",
"Inhaltsverzeichnis",
"Zusammenfassung",
"Gerät",
"Kunde",
"Normen",
"Prüfmittel",
"Programme",
"Beladung",
"Messungen",
"Diagramme",
"Empfehlungen",
"Anlagen",
]
def render_html(self, validation_id: str) -> str:
context = OrionContextBuilder(self.session, self.generated_dir).build(validation_id)
components = self._components()
chapters = [component.render(context) for component in components]
return render_document(context, chapters)
def render_pdf(self, validation_id: str) -> Path:
from weasyprint import HTML
context = OrionContextBuilder(self.session, self.generated_dir).build(validation_id)
output_path = context.generated_dir / f"{context.validation.report_number}.pdf"
html = self.render_html(validation_id)
HTML(string=html, base_url=str(ORION_ASSET_DIR)).write_pdf(output_path)
self._append_pdf_attachments(context, output_path)
def render_pdf(self, title: str, output_path: Path) -> Path:
chapter_markup = "".join(f"<section><h2>{chapter}</h2></section>" for chapter in self.chapters)
html = f"<html><body><h1>{title}</h1>{chapter_markup}</body></html>"
HTML(string=html).write_pdf(output_path)
return output_path
def render_settings_preview_pdf(self, settings_override: OrionReportSettingsUpdate | None = None) -> bytes:
from weasyprint import HTML
context = self._preview_context(settings_override)
preview_section = section(
"layout-preview",
"Vorschau Hauptkapitel",
table(
["Bereich", "Darstellung"],
[
["Layoutprofil", context.report_settings.layout_profile],
["Seitenraender", context.report_settings.page_margin],
["Abschnittsabstaende", context.report_settings.section_spacing],
["Tabellenlayout", context.report_settings.table_layout],
["Tabellenschrift", context.report_settings.table_font_size],
["Bildgroesse", context.report_settings.image_size],
["Bildposition", context.report_settings.image_position],
["Bilder pro Seite", context.report_settings.max_images_per_page],
["Kopfzeile", "Ein" if context.report_settings.show_header else "Aus"],
["Fusszeile", "Ein" if context.report_settings.show_footer else "Aus"],
["Logo", context.report_settings.logo_size],
["Kapitelumbruch", "Ein" if context.report_settings.page_break_before_main_chapters else "Aus"],
],
)
+ (
'<div class="figure-grid">'
+ "".join(
'<figure class="report-figure">'
f'<img class="report-image" src="{text((ORION_ASSET_DIR / "schubamed-logo.svg").resolve().as_uri())}" alt="Beispielbild {index}">'
f'<figcaption class="image-caption">Abbildung {index}: Beispielbild fuer die Layoutvorschau</figcaption>'
"</figure>"
for index in range(1, 5)
)
+ "</div>"
),
"1 Vorschau Hauptkapitel",
)
chapters = [
CoverComponent().render(context),
SummaryComponent().render(context),
TocComponent([{"key": "layout-preview", "number": "1", "title": "Vorschau Hauptkapitel", "toc": True}]).render(context),
CustomerComponent().render(context),
preview_section,
StaticTextComponent("results", "Ergebnisse der Validierung", "Die spaetere Ergebnisbox bleibt Bestandteil des Abschlussbereichs.", number="2").render(context),
]
html = render_document(context, chapters)
return HTML(string=html, base_url=str(ORION_ASSET_DIR)).write_pdf()
def _components(self) -> list[ReportComponent]:
chapters = [self._component_for_section(item) for item in REPORT_SECTIONS]
return [CoverComponent(), SummaryComponent(), TocComponent(REPORT_SECTIONS), CustomerComponent(), *chapters]
def _preview_context(self, settings_override: OrionReportSettingsUpdate | None) -> ReportContext:
if settings_override is None:
report_settings = self._settings_clone()
else:
report_settings = OrionReportSettings(
scope=OrionReportSettingsScope.global_.value,
layout_profile=settings_override.layout_profile.value,
show_cover_result_text=settings_override.show_cover_result_text,
signature_mode=settings_override.signature_mode.value,
image_size=settings_override.image_size.value,
page_break_before_main_chapters=settings_override.page_break_before_main_chapters,
page_margin=settings_override.page_margin.value,
section_spacing=settings_override.section_spacing.value,
table_layout=settings_override.table_layout.value,
table_font_size=settings_override.table_font_size.value,
image_position=settings_override.image_position.value,
max_images_per_page=settings_override.max_images_per_page,
show_image_captions=settings_override.show_image_captions,
show_header=settings_override.show_header,
show_footer=settings_override.show_footer,
logo_size=settings_override.logo_size.value,
compact_cover=settings_override.compact_cover,
)
now = datetime.now(UTC)
validation = SimpleNamespace(
id="preview-validation",
report_number="ORION-LAYOUT-PREVIEW",
validation_type="Layoutvorschau",
project="Administrative Orion-Vorschau",
performed_on=date.today(),
test_location="Schubamed Preview",
examiner_name="Technische Validierung",
status="ENTWURF",
result="BESTANDEN_MIT_AUFLAGEN",
participants="Preview Team",
operator_name="Preview Betreiber",
next_validation_on=date(date.today().year + 2, date.today().month, date.today().day),
version=1,
updated_at=now,
equipment_ids=[],
environment_conditions={},
documentation_checklist=[],
performance_checklist=[],
programs=[],
loading_patterns=[],
measurement_data=[],
drying={},
recommendations=[],
attachments=[],
)
customer = SimpleNamespace(
name="Demo-Praxis Orion",
customer_type=SimpleNamespace(value="practice"),
street="Musterstrasse 12",
postal_code="12345",
city="Berlin",
phone="+49 30 123456",
email="preview@schubamed.de",
hygiene_officer="H. Muster",
quality_manager="Q. Beispiel",
)
location = SimpleNamespace(name="Aufbereitungsraum", street="Musterstrasse 12", postal_code="12345", city="Berlin", room="AEMP")
contact = SimpleNamespace(full_name="Dr. Petra Beispiel", function="Praxisleitung", email="kontakt@example.de", phone="+49 30 123456")
device = SimpleNamespace(
manufacturer="MELAG",
model="Vacuklav 44 B+",
serial_number="PREVIEW-12345",
device_type="Klein-Sterilisator",
year_built=2024,
commissioned_on=date(2024, 5, 15),
chamber_volume_liters=22,
steam_generation="integriert",
water_treatment="VE-Wasser",
documentation="vollstaendig",
supplier="Schubamed",
)
return ReportContext(
validation=validation,
customer=customer,
location=location,
contact=contact,
device=device,
equipment=[],
generated_dir=self.generated_dir,
report_sections=[],
text_blocks={
"summary": SimpleNamespace(
content="Diese Vorschau zeigt die aktuell gewaehlten Orion-Berichtseinstellungen ohne Produktivdaten zu veraendern."
)
},
checklist_templates=[],
confirmed_measurements=[],
report_settings=report_settings,
)
def _settings_clone(self) -> OrionReportSettings:
from app.services.report_settings import OrionReportSettingsService
saved = OrionReportSettingsService(self.session).get_global()
return OrionReportSettings(
scope=saved.scope,
layout_profile=saved.layout_profile,
show_cover_result_text=saved.show_cover_result_text,
signature_mode=saved.signature_mode,
image_size=saved.image_size,
page_break_before_main_chapters=saved.page_break_before_main_chapters,
page_margin=saved.page_margin,
section_spacing=saved.section_spacing,
table_layout=saved.table_layout,
table_font_size=saved.table_font_size,
image_position=saved.image_position,
max_images_per_page=saved.max_images_per_page,
show_image_captions=saved.show_image_captions,
show_header=saved.show_header,
show_footer=saved.show_footer,
logo_size=saved.logo_size,
compact_cover=saved.compact_cover,
updated_by_user_id=saved.updated_by_user_id,
)
def _component_for_section(self, item: dict) -> ReportComponent:
component = item.get("component")
key = str(item["key"])
title = str(item["title"])
number = item.get("number")
if component == "device":
return DeviceComponent(key, title, number)
if component == "checklist":
return ChecklistComponent(key, title, number)
if component == "environment":
return EnvironmentComponent(key, title, number)
if component == "programs":
return ProgramComponent(key, title, number)
if component == "loading":
return LoadingComponent(key, title, number)
if component == "equipment":
return EquipmentComponent(key, title, number)
if component == "measurements":
return MeasurementComponent(key, title, number)
if component == "drying":
return DryingComponent(key, title, number)
if component == "recommendations":
return RecommendationComponent(key, title, number)
if component == "attachments":
return AttachmentComponent(key, title, number)
return StaticTextComponent(key, title, block_key=item.get("block_key"), number=number)
def _append_pdf_attachments(self, context: ReportContext, output_path: Path) -> None:
pdf_paths = []
for item in context.validation.attachments or []:
filename = str(item.get("filename") or "")
content_type = str(item.get("content_type") or "")
if not filename.lower().endswith(".pdf") and content_type != "application/pdf":
continue
storage_path = item.get("storage_path")
if storage_path and Path(str(storage_path)).exists():
pdf_paths.append(Path(str(storage_path)))
if not pdf_paths:
return
try:
from pypdf import PdfReader, PdfWriter
writer = PdfWriter()
for page in PdfReader(str(output_path)).pages:
writer.add_page(page)
for pdf_path in pdf_paths:
try:
for page in PdfReader(str(pdf_path)).pages:
writer.add_page(page)
except Exception:
logger.exception("Could not append attachment PDF %s", pdf_path)
with output_path.open("wb") as handle:
writer.write(handle)
except Exception:
logger.exception("Could not merge Orion PDF attachments for validation %s", context.validation.id)

356
validation-suite/backend/mercury/app/modules/orion/template_service.py
View file

@ -1,356 +0,0 @@
from __future__ import annotations
import re
from dataclasses import dataclass
from pathlib import Path
from typing import Any
from zipfile import ZipFile
from xml.etree import ElementTree as ET
from sqlalchemy import select
from sqlalchemy.exc import IntegrityError
from sqlalchemy.orm import Session
from app.models.report_template import ChecklistTemplate, ReportSection, ReportTemplate, TextBlock
from app.modules.orion.html import text
TEMPLATE_KEY = "small_steam_sterilizer_initial_validation"
TEMPLATE_NAME = "Erstvalidierung Klein-Sterilisator"
TEMPLATE_VERSION = "1.0"
REFERENCE_PATH = "docs/reference/reports/Erstvalidierung_Dr.Durmaz_Steri_12-25.docx"
REPORT_SECTIONS: list[dict[str, Any]] = [
{"key": "functional_qualification", "number": "1", "title": "Funktionsqualifikation (BQ)", "toc": True, "component": "static", "block_key": None},
{"key": "purpose", "number": "1.1", "title": "Anlass und Ziel der Prüfung", "toc": True, "component": "static", "block_key": "bq_goal"},
{"key": "legal", "number": "1.2", "title": "Gesetzliche Grundlagen", "toc": True, "component": "static", "block_key": "legal"},
{"key": "device", "number": "1.3", "title": "Angaben zum Gerät", "toc": True, "component": "device"},
{"key": "performance", "number": "1.4", "title": "Leistungsüberprüfung", "toc": True, "component": "static", "block_key": "performance"},
{"key": "performance_checklist", "number": "1.5", "title": "Checkliste Leistungsanforderung", "toc": True, "component": "checklist"},
{"key": "documentation", "number": "1.6", "title": "Dokumentation / Kontrolle", "toc": True, "component": "static"},
{"key": "work_instructions", "number": "1.7", "title": "Arbeitsanweisungen", "toc": True, "component": "static"},
{"key": "environment", "number": "1.8", "title": "Umgebungsbedingungen", "toc": True, "component": "environment"},
{"key": "batch_control", "number": "1.9", "title": "Chargenkontrolle", "toc": True, "component": "static"},
{"key": "programs", "number": "1.10", "title": "Beschreibung der verwendeten Programme", "toc": True, "component": "programs"},
{"key": "loading", "number": "1.11", "title": "Beladungsbeschreibungen", "toc": True, "component": "loading"},
{"key": "reference_load", "number": "1.12", "title": "Referenzbeladung Sterilisator bei Validierung", "toc": True, "component": "static"},
{"key": "equipment_root", "number": "2", "title": "Eingesetzte Prüfmittel", "toc": True, "component": "static"},
{"key": "measurement_devices", "number": "2.1", "title": "Beschreibung der Messgeräte", "toc": True, "component": "equipment"},
{"key": "thermo_equipment", "number": "2.2", "title": "Prüfmittel zur thermoelektrischen Untersuchung", "toc": True, "component": "static"},
{"key": "configuration", "number": "2.3", "title": "Prüfkonfiguration", "toc": True, "component": "static"},
{"key": "lq", "number": "3", "title": "Leistungsqualifikation (LQ)", "toc": True, "component": "static"},
{"key": "thermo_tests", "number": "3.1", "title": "Leistungsbeurteilung – Thermoelektrische Prüfungen", "toc": True, "component": "static"},
{"key": "vacuum_test", "number": "3.1.1", "title": "Vakuumtest", "toc": True, "component": "measurements"},
{"key": "run_1", "number": "3.2", "title": "Standardbeladung (1. Durchlauf)", "toc": True, "component": "static"},
{"key": "test_1", "number": "3.2.1", "title": "Test 1", "toc": True, "component": "static"},
{"key": "run_2", "number": "3.3", "title": "Standardbeladung (2. Durchlauf)", "toc": True, "component": "static"},
{"key": "test_2", "number": "3.3.1", "title": "Test 2", "toc": True, "component": "static"},
{"key": "run_3", "number": "3.4", "title": "Standardbeladung (3. Durchlauf)", "toc": True, "component": "static"},
{"key": "test_3", "number": "3.4.1", "title": "Test 3", "toc": True, "component": "static"},
{"key": "results", "number": "4", "title": "Ergebnisse der Validierung", "toc": True, "component": "static"},
{"key": "results_vacuum", "number": "4.1", "title": "Vakuumtest", "toc": True, "component": "static"},
{"key": "results_runs", "number": "4.1.2", "title": "Testläufe 1 bis 3 Programm 134 °C B", "toc": True, "component": "static"},
{"key": "drying", "number": None, "title": "Nachweis der Trocknungseigenschaften Testläufe 1 bis 3", "toc": True, "component": "drying"},
{"key": "recommendations", "number": "4.2", "title": "Empfehlungen und Auflagen", "toc": True, "component": "recommendations"},
{"key": "appendix", "number": "5", "title": "Anhang", "toc": True, "component": "static"},
{"key": "winlog", "number": "5.1", "title": "Vakuumtest / Winlog-Auswertungen", "toc": True, "component": "attachments"},
{"key": "bd_empty_chamber", "number": None, "title": "Testlauf Leerkammerprofil / Bowie-Dick", "toc": True, "component": "static"},
{"key": "batch_release_docs", "number": None, "title": "Chargen- und Freigabedokumentation", "toc": True, "component": "static"},
{"key": "release_docs", "number": "5.2", "title": "Freigabedokumentation / Routineprüfungen", "toc": True, "component": "static"},
{"key": "indicators", "number": "5.3", "title": "Nachweis der umgeschlagenen Indikatoren", "toc": True, "component": "static"},
{"key": "cycles", "number": "6", "title": "Programmabläufe / Zyklen des Sterilisators", "toc": True, "component": "static"},
{"key": "practice_certificates", "number": "6.1", "title": "Zertifikate Praxis", "toc": True, "component": "static"},
{"key": "risk", "number": "7", "title": "Risikoeinstufung der Praxis nach RKI", "toc": True, "component": "static"},
{"key": "closing_talk", "number": "7.1", "title": "Abschlussgespräch zur Validierung", "toc": True, "component": "static"},
{"key": "certificates", "number": "8", "title": "Zertifikate", "toc": True, "component": "static"},
{"key": "calibration_certificates", "number": "9", "title": "Werkskalibrierzertifikate Sensoren", "toc": True, "component": "static"},
]
TEXT_BLOCK_HEADINGS = {
"summary": "Zusammenfassendes Ergebnis der Validierung",
"bq_goal": "Anlass und Ziel der Prüfung",
"legal": "Gesetzliche Grundlagen",
"performance": "Leistungsüberprüfung",
}
CHECKLIST_DEFINITIONS = [
(
"sterilizer_description",
"Beschreibung Sterilisator",
["Beschreibung", "Ja", "Nein", "Nicht anwendbar", "Kommentar"],
[
"Trennung von Controlling und Monitoring Schaltkreisen",
"Temperaturüberwachung Sterilisationsprozess",
"Drucküberwachung Sterilisationsprozess",
"Wasserzulauf - Ablauf / manuelle Überwachung",
"Automatische Aufzeichnung der Sterilisationsergebnisse",
"Überwachung Wasserqualität",
"Separater Netzanschluss",
"Sichtkontrolle: Kessel, Sensoren, Türbereich",
],
),
(
"documentation_control",
"Dokumentation / Kontrolle",
["Vorliegende Dokumente / Beschreibungen", "vorhanden", "eingesehen", "Kommentar"],
[
"Bedienungshandbuch / Installationsprotokoll",
"Wartungshandbuch",
"Arbeitsanweisungen / Checklisten / reale Beladungsmuster",
"Schulungsnachweise Mitarbeiter zur Aufbereitung",
"Risikoeinstufung der Medizinprodukte nach RKI",
"Protokoll mit Freigabe der Sterilisation durch Mitarbeiter",
"Chargenkontrolle / Indikator für jede Charge",
"Chargendokumentation der letzten 6 Wochen",
"Dokumentation / Bilder der schwierigsten repräsentativen Beladung",
],
),
(
"work_instructions",
"Arbeitsanweisungen",
["Arbeitsanweisung", "vorhanden", "eingesehen", "Prüfintervall", "Kommentar"],
[
"Aufbereitung von Medizinprodukten",
"Beladung Sterilisator",
"Routinekontrollen",
"Freigabe von Chargen",
"Umgang mit Abweichungen",
],
),
(
"environment_conditions",
"Umgebungsbedingungen",
["Prüfpunkt", "Ja", "Nein", "Nicht anwendbar", "Kommentar"],
["Raumbedingungen stabil", "Aufstellort frei zugänglich", "Medienversorgung verfügbar"],
),
(
"batch_documentation",
"Chargendokumentation",
["Prüfpunkt", "vorhanden", "eingesehen", "Kommentar"],
["Vakuumtest", "Testlauf 1", "Testlauf 2", "Testlauf 3", "Freigabedokumentation"],
),
(
"batch_control",
"Chargenkontrolle",
["Prüfpunkt", "Ja", "Nein", "Prüfkörper", "Kommentar"],
["Bowie-Dick / Leerkammerprofil", "Helix-Test", "Indikatoren umgeschlagen"],
),
]
@dataclass(frozen=True)
class TemplateBundle:
template: ReportTemplate
sections: list[ReportSection]
text_blocks: dict[str, TextBlock]
checklists: list[ChecklistTemplate]
class ReportTemplateService:
def __init__(self, session: Session, project_root: Path | None = None) -> None:
self.session = session
self.project_root = project_root or self._discover_project_root()
@property
def reference_path(self) -> Path:
return self.project_root / REFERENCE_PATH
def _discover_project_root(self) -> Path:
current = Path(__file__).resolve()
for parent in current.parents:
if (parent / REFERENCE_PATH).exists():
return parent
return Path("/app")
def ensure_default_template(self) -> TemplateBundle:
if not self.reference_path.exists():
raise FileNotFoundError(f"Required reference report is missing: {self.reference_path}")
template = self.session.scalar(
select(ReportTemplate).where(ReportTemplate.template_key == TEMPLATE_KEY)
)
if template is None:
template = ReportTemplate(
template_key=TEMPLATE_KEY,
name=TEMPLATE_NAME,
version=TEMPLATE_VERSION,
validation_type="Erstvalidierung",
reference_path=REFERENCE_PATH,
active=True,
)
self.session.add(template)
try:
self.session.flush()
except IntegrityError:
self.session.rollback()
template = self.session.scalar(
select(ReportTemplate).where(ReportTemplate.template_key == TEMPLATE_KEY)
)
if template is None:
raise
if not self._has_children(template):
self._create_children(template)
self.session.flush()
return self.load_bundle()
def load_bundle(self) -> TemplateBundle:
template = self.session.scalar(
select(ReportTemplate).where(ReportTemplate.template_key == TEMPLATE_KEY)
)
if template is None:
return self.ensure_default_template()
sections = list(
self.session.scalars(
select(ReportSection)
.where(ReportSection.template_id == template.id, ReportSection.active.is_(True))
.order_by(ReportSection.order_index)
)
)
text_blocks = {
block.block_key: block
for block in self.session.scalars(
select(TextBlock)
.where(TextBlock.template_id == template.id, TextBlock.active.is_(True))
.order_by(TextBlock.order_index)
)
}
checklists = list(
self.session.scalars(
select(ChecklistTemplate)
.where(ChecklistTemplate.template_id == template.id, ChecklistTemplate.active.is_(True))
.order_by(ChecklistTemplate.order_index)
)
)
return TemplateBundle(template=template, sections=sections, text_blocks=text_blocks, checklists=checklists)
def render_block(self, block_key: str, context: Any) -> str:
bundle = self.load_bundle()
block = bundle.text_blocks.get(block_key)
if block is None:
return "nicht erfasst"
return self.render_text(block.content, context)
def render_text(self, content: str, context: Any) -> str:
values = {
"device.manufacturer": context.device.manufacturer if context.device else None,
"device.model": context.device.model if context.device else None,
"device.serial_number": context.device.serial_number if context.device else None,
"customer.name": context.customer.name,
"location.city": context.location.city if context.location else None,
"validation.performed_on": context.validation.performed_on,
"validation.next_validation_on": context.validation.next_validation_on,
"validation.result": context.validation.result,
}
rendered = content
for key, value in values.items():
rendered = rendered.replace("{{ " + key + " }}", text(value))
return rendered
def _has_children(self, template: ReportTemplate) -> bool:
return bool(
self.session.scalar(
select(TextBlock.id).where(TextBlock.template_id == template.id).limit(1)
)
)
def _create_children(self, template: ReportTemplate) -> None:
paragraphs = self._read_docx_paragraphs()
blocks = self._extract_blocks(paragraphs)
for index, section in enumerate(REPORT_SECTIONS, start=1):
self.session.add(
ReportSection(
template_id=template.id,
section_key=str(section["key"]),
number=section["number"],
title=str(section["title"]),
order_index=index,
page_break_before=section["number"] in {"1", "2", "3", "4", "5", "6", "7", "8", "9"},
active=True,
)
)
for index, (block_key, title) in enumerate(TEXT_BLOCK_HEADINGS.items(), start=1):
self.session.add(
TextBlock(
template_id=template.id,
block_key=block_key,
title=title,
content=self._sanitize_reference_text(blocks.get(block_key, "nicht erfasst")),
order_index=index,
version=TEMPLATE_VERSION,
active=True,
)
)
for index, (key, title, columns, items) in enumerate(CHECKLIST_DEFINITIONS, start=1):
self.session.add(
ChecklistTemplate(
template_id=template.id,
checklist_key=key,
title=title,
columns=columns,
items=[
{"number": item_index + 1, "text": item, "value": "na", "comment": ""}
for item_index, item in enumerate(items)
],
order_index=index,
active=True,
)
)
def _read_docx_paragraphs(self) -> list[str]:
ns = {"w": "http://schemas.openxmlformats.org/wordprocessingml/2006/main"}
with ZipFile(self.reference_path) as archive:
root = ET.fromstring(archive.read("word/document.xml"))
paragraphs: list[str] = []
for paragraph in root.findall(".//w:p", ns):
line = "".join(
node.text or "" for node in paragraph.findall(".//w:t", ns)
).strip()
if line:
paragraphs.append(line)
return paragraphs
def _extract_blocks(self, paragraphs: list[str]) -> dict[str, str]:
blocks: dict[str, str] = {}
heading_by_normalized = {self._normalize(value): key for key, value in TEXT_BLOCK_HEADINGS.items()}
active_key: str | None = None
buffer: list[str] = []
for paragraph in paragraphs:
normalized = self._normalize(paragraph)
if normalized in heading_by_normalized:
if active_key:
blocks[active_key] = "\n\n".join(buffer).strip()
active_key = heading_by_normalized[normalized]
buffer = []
continue
if active_key and self._looks_like_next_section(paragraph):
blocks[active_key] = "\n\n".join(buffer).strip()
active_key = None
buffer = []
continue
if active_key:
buffer.append(paragraph)
if active_key:
blocks[active_key] = "\n\n".join(buffer).strip()
return blocks
def _sanitize_reference_text(self, content: str) -> str:
replacements = {
"Euronda E10.7": "{{ device.manufacturer }} {{ device.model }}",
"Euronda / E10.7": "{{ device.manufacturer }} / {{ device.model }}",
"EXN250688": "{{ device.serial_number }}",
"Dr.Durmaz": "{{ customer.name }}",
"Nürnberg": "{{ location.city }}",
"05.12.2025": "{{ validation.performed_on }}",
"November 2027": "{{ validation.next_validation_on }}",
"bestanden": "{{ validation.result }}",
}
sanitized = content
for old, new in replacements.items():
sanitized = sanitized.replace(old, new)
return sanitized or "nicht erfasst"
def _normalize(self, value: str) -> str:
return re.sub(r"[^a-z0-9]+", "", value.lower())
def _looks_like_next_section(self, value: str) -> bool:
if value in {"Inhaltsverzeichnis", "1.3 Angaben zum Gerät"}:
return True
return bool(re.match(r"^\d+(\.\d+)*\s", value))

BIN
validation-suite/backend/mercury/app/modules/orion/templates/__pycache__/report.cpython-313.pyc
View file

Binary file not shown.

710
validation-suite/backend/mercury/app/modules/orion/templates/report.css
View file

@ -1,710 +0,0 @@
@page {
size: A4;
}
@page cover {
margin: 20mm 18mm 20mm 18mm;
@top-left { content: ""; }
@bottom-left { content: ""; }
}
@page report {
margin: 34mm 18mm 24mm 18mm;
@top-left { content: element(report-header); }
@bottom-left { content: element(report-footer); }
}
@page cover-narrow {
margin: 16mm 14mm 16mm 14mm;
@top-left { content: ""; }
@bottom-left { content: ""; }
}
@page cover-wide {
margin: 24mm 22mm 24mm 22mm;
@top-left { content: ""; }
@bottom-left { content: ""; }
}
@page report-narrow {
margin: 30mm 14mm 20mm 14mm;
@top-left { content: element(report-header); }
@bottom-left { content: element(report-footer); }
}
@page report-wide {
margin: 38mm 22mm 28mm 22mm;
@top-left { content: element(report-header); }
@bottom-left { content: element(report-footer); }
}
* {
box-sizing: border-box;
}
html {
color: #2E3B40;
font-family: Inter, Arial, sans-serif;
font-size: 10.5pt;
line-height: 1.45;
}
body {
margin: 0;
}
.report-meta {
display: none;
string-set: report-number attr(data-report-number), report-version attr(data-report-version), report-date attr(data-report-date);
}
.report-header {
align-items: center;
border-bottom: .25mm solid #DCE3E3;
display: grid;
grid-template-columns: 1fr 54mm;
height: 24mm;
left: 0;
padding-bottom: 3mm;
position: running(report-header);
top: 0;
width: 174mm;
}
.report-header-brand {
align-items: center;
display: flex;
gap: 4mm;
min-width: 0;
}
.report-header-brand img {
display: block;
height: 20mm;
width: auto;
}
.report-header-brand strong {
color: #2E3B40;
display: block;
font-size: 15pt;
letter-spacing: 0;
line-height: 1.05;
}
.report-header-brand span {
color: #6B7C85;
display: block;
font-size: 9pt;
line-height: 1.35;
margin-top: 1mm;
}
.report-header-meta {
color: #4F5E63;
display: grid;
gap: 1.2mm;
margin: 0;
text-align: right;
}
.report-header-meta div,
.report-footer {
display: grid;
grid-template-columns: 1fr;
}
.report-header-meta dt {
display: none;
}
.report-header-meta dd {
font-size: 9pt;
margin: 0;
}
.report-header-meta div:first-child dd {
color: #2E3B40;
font-size: 10pt;
font-weight: 700;
}
.report-footer {
align-items: center;
border-top: .25mm solid #DCE3E3;
color: #6B7C85;
font-size: 8pt;
grid-template-columns: 1fr 1fr 1fr;
height: 10mm;
padding-top: 2.5mm;
position: running(report-footer);
width: 174mm;
}
.report-footer span:nth-child(2) {
text-align: center;
}
.report-footer span:nth-child(3) {
text-align: right;
}
.page-number::before {
content: counter(page);
}
.page-count::before {
content: counter(pages);
}
.cover-page {
page: cover;
display: flex;
flex-direction: column;
justify-content: flex-start;
break-after: page;
}
.report-content {
page: report;
}
.page-margin-narrow .cover-page {
page: cover-narrow;
}
.page-margin-wide .cover-page {
page: cover-wide;
}
.page-margin-narrow .report-content {
page: report-narrow;
}
.page-margin-wide .report-content {
page: report-wide;
}
.cover-top {
align-items: flex-start;
display: grid;
gap: 14mm;
grid-template-columns: 1fr 55mm;
margin-bottom: 8mm;
}
.cover-logo {
height: 16mm;
justify-self: end;
width: auto;
}
.logo-size-small .cover-logo {
height: 12mm;
}
.logo-size-large .cover-logo {
height: 22mm;
}
.company-address {
color: #6B7C85;
font-size: 8.5pt;
line-height: 1.35;
text-align: right;
}
.cover-kicker {
color: #6C8A96;
font-size: 11pt;
font-weight: 700;
letter-spacing: .08em;
margin-bottom: 14mm;
text-transform: uppercase;
}
h1 {
color: #2E3B40;
font-size: 28pt;
line-height: 1.05;
margin: 0 0 3mm 0;
}
.cover-subtitle {
color: #4F6A74;
font-size: 12.5pt;
margin: 0 0 3mm 0;
}
.cover-page .definition-row {
grid-template-columns: 36mm 1fr;
padding: .65mm 0;
}
.cover-page .definition-list {
font-size: 9.4pt;
line-height: 1.25;
}
.cover-compact .cover-top {
margin-bottom: 5mm;
}
.cover-compact h1 {
font-size: 24pt;
margin-bottom: 2mm;
}
.cover-compact .cover-subtitle {
font-size: 11.2pt;
margin-bottom: 2mm;
}
.cover-compact .cover-page .definition-row {
padding: .35mm 0;
}
.cover-compact .cover-page .definition-list {
font-size: 8.8pt;
line-height: 1.18;
}
.cover-closing {
break-inside: avoid;
margin-top: 1.5mm;
page-break-inside: avoid;
}
.cover-result-text {
border-top: .25mm solid #DCE3E3;
break-inside: avoid;
margin: 2mm 0 0 0;
page-break-inside: avoid;
padding-top: 2.2mm;
}
.cover-result-text h2 {
border: 0;
color: #4F6A74;
font-size: 10pt;
letter-spacing: .04em;
margin: 0 0 1mm 0;
padding: 0;
text-transform: uppercase;
}
.cover-result-text p {
color: #2E3B40;
font-size: 10.5pt;
font-weight: 700;
margin: 0;
}
.result-box {
border: .65mm solid #8A9498;
border-radius: 1.5mm;
break-inside: avoid;
margin: 4mm 0;
padding: 3mm 6mm;
page-break-inside: avoid;
text-align: center;
width: 100%;
}
.result-box__label {
color: #4F5E63;
font-size: 8.4pt;
font-weight: 700;
letter-spacing: .06em;
margin-bottom: 1.2mm;
}
.result-box__value {
font-weight: 800;
line-height: 1.15;
}
.result-box--cover {
margin: 0 0 2.5mm 0;
padding: 2.8mm 6mm;
}
.result-box--cover .result-box__value {
font-size: 18.5pt;
text-transform: uppercase;
}
.result-box--compact {
margin: 0 0 6mm 0;
padding: 5mm 6mm;
}
.result-box--compact .result-box__value {
font-size: 16pt;
}
.result-box--passed {
background: #EAF5EE;
border-color: #6FA37D;
color: #245C36;
}
.result-box--conditional {
background: #FFF7DD;
border-color: #C9A64A;
color: #7A5A00;
}
.result-box--failed {
background: #FCEBEC;
border-color: #C96A70;
color: #7A1F26;
}
.result-box--open {
background: #F1F3F3;
border-color: #9AA6AA;
color: #2E3B40;
}
.signature-block {
break-inside: avoid;
color: #6B7C85;
page-break-inside: avoid;
width: 82mm;
}
.signature-grid {
break-inside: avoid;
display: flex;
gap: 14mm;
margin-top: 9mm;
page-break-inside: avoid;
}
.signature-line {
border-top: 1px solid #6B7C85;
height: 0;
margin-bottom: 1.5mm;
width: 82mm;
}
.signature-label {
font-size: 8.5pt;
}
.chapter {
break-before: auto;
margin-top: 9mm;
}
.main-chapter-breaks .report-content .chapter {
break-before: page;
}
.main-chapter-breaks .report-content .chapter:first-of-type {
break-before: auto;
}
.main-chapter-flow .report-content .chapter {
break-before: auto;
}
.section-spacing-compact h2 {
margin-bottom: 4mm;
padding-bottom: 2.5mm;
}
.section-spacing-compact h3 {
margin: 5mm 0 2mm 0;
}
.section-spacing-compact p {
margin-top: 2mm;
margin-bottom: 2mm;
}
.section-spacing-compact .chapter,
.section-spacing-compact .chapter + .chapter {
margin-top: 6mm;
}
.section-spacing-compact .data-table {
margin-top: 2.5mm;
}
.section-spacing-compact .figure-grid {
gap: 5mm;
margin-top: 5mm;
}
h2 {
border-bottom: .25mm solid #DCE3E3;
color: #2E3B40;
font-size: 22pt;
font-weight: 700;
letter-spacing: 0;
line-height: 1.15;
margin: 0 0 7mm 0;
padding-bottom: 4mm;
bookmark-level: none;
}
h2[data-bookmark-label] {
bookmark-label: attr(data-bookmark-label);
bookmark-level: 1;
}
.chapter + .chapter {
margin-top: 12mm;
}
.chapter > p:only-child {
margin-bottom: 0;
}
h3 {
color: #4F6A74;
font-size: 12pt;
margin: 8mm 0 3mm 0;
}
.definition-list {
display: block;
margin: 0;
}
.definition-row {
border-bottom: 1px solid #E6EAEA;
display: grid;
grid-template-columns: 42mm 1fr;
gap: 6mm;
padding: 2.5mm 0;
}
dt {
color: #6B7C85;
font-weight: 700;
}
dd {
margin: 0;
}
.data-table {
border-collapse: collapse;
margin-top: 4mm;
table-layout: fixed;
width: 100%;
}
.data-table th {
background: #F7F8F8;
color: #4F6A74;
font-size: 8.5pt;
font-weight: 700;
text-align: left;
}
.data-table th,
.data-table td {
border: 1px solid #E6EAEA;
padding: 2.4mm;
vertical-align: top;
word-wrap: break-word;
}
.data-table.compact {
font-size: 8.5pt;
}
.table-layout-compact .data-table {
margin-top: 2.5mm;
}
.table-layout-compact .data-table th,
.table-layout-compact .data-table td {
padding: 1.5mm;
}
.table-font-small .data-table {
font-size: 8.4pt;
}
.toc-list {
counter-reset: toc;
list-style: none;
margin: 0;
padding: 0;
}
.toc-list li {
border-bottom: 1px solid #E6EAEA;
padding: 3mm 0;
}
.toc-list a {
color: #2E3B40;
display: grid;
gap: 4mm;
grid-template-columns: 1fr 14mm;
text-decoration: none;
}
.toc-level-2 {
padding-left: 6mm;
}
.toc-level-3,
.toc-level-4 {
padding-left: 12mm;
}
.toc-list a::after {
content: target-counter(attr(href), page);
text-align: right;
}
.figure-grid {
display: grid;
gap: 8mm;
grid-template-columns: 1fr 1fr;
margin-top: 8mm;
}
.image-position-stacked .figure-grid {
grid-template-columns: 1fr;
}
.image-position-side-by-side .figure-grid {
grid-template-columns: 1fr 1fr;
}
.image-page-max-1 .report-figure {
break-after: page;
}
.image-page-max-2 .report-figure:nth-child(2n) {
break-after: page;
}
.image-page-max-4 .report-figure:nth-child(4n) {
break-after: page;
}
.report-figure {
break-inside: avoid;
margin: 0;
}
.report-image {
border: 1px solid #E6EAEA;
display: block;
max-height: 90mm;
object-fit: contain;
width: 100%;
}
.image-size-small .report-image {
max-height: 55mm;
}
.image-size-medium .report-image {
max-height: 90mm;
}
.image-size-large .report-image {
max-height: 125mm;
}
.image-captions-off .image-caption {
display: none;
}
.logo-size-small .report-header-brand img {
height: 14mm;
}
.logo-size-large .report-header-brand img {
height: 24mm;
}
.layout-compact html,
.layout-compact {
line-height: 1.32;
}
.layout-compact h2 {
font-size: 18pt;
margin-bottom: 4mm;
padding-bottom: 2.5mm;
}
.layout-compact h3 {
margin: 5mm 0 2mm 0;
}
.layout-compact .chapter,
.layout-compact .chapter + .chapter {
margin-top: 6mm;
}
.layout-compact .definition-row {
padding: 1.4mm 0;
}
.layout-compact .data-table th,
.layout-compact .data-table td {
padding: 1.6mm;
}
.layout-compact .result-box {
margin: 2.5mm 0;
padding: 2.4mm 5mm;
}
figcaption {
color: #6B7C85;
font-size: 8.5pt;
margin-top: 2mm;
}
@media screen {
body {
background: #F7F8F8;
padding: 24px;
}
.report-document {
background: #FFFFFF;
box-shadow: 0 14px 40px rgba(46, 59, 64, 0.08);
margin: 0 auto;
max-width: 960px;
padding: 48px;
}
.report-header,
.report-footer {
left: auto;
margin: 0 auto 32px auto;
position: static;
width: 100%;
}
.cover-page {
min-height: auto;
}
.chapter {
break-before: auto;
margin-top: 48px;
}
.report-footer {
margin: 48px auto 0 auto;
}
.figure-grid {
gap: 24px;
}
}

87
validation-suite/backend/mercury/app/modules/orion/templates/report.py
View file

@ -1,87 +0,0 @@
from __future__ import annotations
from pathlib import Path
from app.modules.orion.assets import schubamed_logo_uri
from app.modules.orion.context import ReportContext
from app.modules.orion.html import text
def render_report_chrome(context: ReportContext, logo_uri: str) -> str:
settings = context.report_settings
report_number = text(context.validation.report_number)
version = text(context.validation.version)
report_date = text(context.validation.updated_at)
header = ""
footer = ""
if settings.show_header:
header = f"""
<header class="report-header" aria-label="Berichtskopf">
<div class="report-header-brand">
<img src="{logo_uri}" alt="SCHUBAMED">
<div>
<strong>SCHUBAMED®</strong>
<span>Aufbereitung mit System</span>
</div>
</div>
<dl class="report-header-meta">
<div><dt>Berichtsnummer</dt><dd>{report_number}</dd></div>
<div><dt>Version</dt><dd>{version}</dd></div>
<div><dt>Datum</dt><dd>{report_date}</dd></div>
</dl>
</header>
"""
if settings.show_footer:
footer = f"""
<footer class="report-footer" aria-label="Berichtsfuß">
<span>Validation Suite</span>
<span>Seite <span class="page-number"></span> von <span class="page-count"></span></span>
<span>Version {version}</span>
</footer>
"""
return header + footer
def render_document(context: ReportContext, chapters: list[str]) -> str:
css = (Path(__file__).resolve().parent / "report.css").read_text(encoding="utf-8")
logo_uri = schubamed_logo_uri()
title = f"Validierungsbericht {context.validation.report_number}"
cover_markup = chapters[0] if chapters else ""
content_markup = "\n".join(chapters[1:])
settings = context.report_settings
body_classes = " ".join(
[
"orion-report",
f"layout-{settings.layout_profile.lower()}",
f"page-margin-{settings.page_margin.lower()}",
f"section-spacing-{settings.section_spacing.lower()}",
f"table-layout-{settings.table_layout.lower()}",
f"table-font-{settings.table_font_size.lower()}",
f"image-size-{settings.image_size.lower()}",
f"image-position-{settings.image_position.lower().replace('_', '-')}",
f"image-page-max-{settings.max_images_per_page}",
f"logo-size-{settings.logo_size.lower()}",
"image-captions-on" if settings.show_image_captions else "image-captions-off",
"cover-compact" if settings.compact_cover else "cover-standard",
"main-chapter-breaks" if settings.page_break_before_main_chapters else "main-chapter-flow",
]
)
return f"""<!doctype html>
<html lang="de">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>{text(title)}</title>
<style>{css}</style>
</head>
<body class="{body_classes}">
<article class="report-document">
{cover_markup}
<section class="report-content">
<div class="report-meta" data-report-number="{text(context.validation.report_number)}" data-report-version="{text(context.validation.version)}" data-report-date="{text(context.validation.updated_at)}"></div>
{render_report_chrome(context, logo_uri)}
{content_markup}
</section>
</article>
</body>
</html>"""

BIN
validation-suite/backend/mercury/app/repositories/__pycache__/base.cpython-313.pyc
View file

Binary file not shown.

BIN
validation-suite/backend/mercury/app/repositories/__pycache__/domain.cpython-313.pyc
View file

Binary file not shown.

22
validation-suite/backend/mercury/app/repositories/domain.py
View file

@ -1,6 +1,6 @@
from __future__ import annotations
from sqlalchemy import or_, select
from sqlalchemy import select
from sqlalchemy.orm import Session
from app.models.customer import Customer
@ -18,28 +18,12 @@ class UserRepository(Repository[User]):
model = User
def by_email(self, email: str) -> User | None:
return self.session.scalar(select(User).where(User.email == email.strip().lower()))
return self.session.scalar(select(User).where(User.email == email.lower()))
class CustomerRepository(Repository[Customer]):
model = Customer
def _search_statement(self, search: str | None = None):
statement = select(Customer)
if search:
term = f"%{search.strip()}%"
statement = statement.where(
or_(
Customer.name.ilike(term),
Customer.external_id.ilike(term),
Customer.city.ilike(term),
Customer.postal_code.ilike(term),
Customer.email.ilike(term),
Customer.phone.ilike(term),
Customer.contacts.any(Contact.full_name.ilike(term)),
)
)
return statement
search_columns = ("name", "city", "email", "phone")
class LocationRepository(Repository[Location]):

BIN
validation-suite/backend/mercury/app/schemas/__pycache__/auth.cpython-313.pyc
View file

Binary file not shown.

BIN
validation-suite/backend/mercury/app/schemas/__pycache__/common.cpython-313.pyc
View file

Binary file not shown.

BIN
validation-suite/backend/mercury/app/schemas/__pycache__/domain.cpython-313.pyc
View file

Binary file not shown.

15
validation-suite/backend/mercury/app/schemas/auth.py
View file

@ -1,7 +1,5 @@
from __future__ import annotations
from datetime import datetime
from pydantic import BaseModel, EmailStr
from app.models.user import UserRole
@ -16,22 +14,11 @@ class LoginRequest(BaseModel):
class TokenResponse(BaseModel):
access_token: str
token_type: str = "bearer"
expires_in: int
user: UserRead
class UserRead(EntityRead):
email: EmailStr
first_name: str
last_name: str
full_name: str
role: UserRole
is_active: bool
must_change_password: bool
last_login_at: datetime | None = None
password_changed_at: datetime | None = None
class ChangePasswordRequest(BaseModel):
current_password: str
new_password: str
new_password_confirmation: str

1
validation-suite/backend/mercury/app/schemas/common.py
View file

@ -23,4 +23,3 @@ class PaginatedResponse(BaseModel, Generic[T]):
total: int
page: int
page_size: int
pages: int

217
validation-suite/backend/mercury/app/schemas/domain.py
View file

@ -1,33 +1,17 @@
from __future__ import annotations
from datetime import date
from datetime import datetime
from typing import Literal
from uuid import UUID
from pydantic import ConfigDict, EmailStr, Field, field_validator
from pydantic import EmailStr, Field
from app.models.customer import CustomerType
from app.models.equipment import EquipmentKind, EquipmentStatus
from app.models.report_settings import (
OrionImagePosition,
OrionImageSize,
OrionLayoutProfile,
OrionLogoSize,
OrionPageMargin,
OrionSignatureMode,
OrionSpacing,
OrionTableFontSize,
)
from app.models.user import UserRole
from app.models.validation import ValidationStatus
from app.schemas.common import EntityRead, ORMModel
class CustomerCreate(ORMModel):
customer_type: CustomerType
source_system: str | None = None
external_id: str | None = None
name: str
street: str | None = None
postal_code: str | None = None
@ -104,32 +88,6 @@ class DeviceUpdate(DeviceCreate):
pass
class OrionReportSettingsUpdate(ORMModel):
model_config = ConfigDict(extra="forbid")
layout_profile: OrionLayoutProfile
show_cover_result_text: bool
signature_mode: OrionSignatureMode
image_size: OrionImageSize
page_break_before_main_chapters: bool
page_margin: OrionPageMargin
section_spacing: OrionSpacing
table_layout: OrionSpacing
table_font_size: OrionTableFontSize
image_position: OrionImagePosition
max_images_per_page: Literal[1, 2, 4]
show_image_captions: bool
show_header: bool
show_footer: bool
logo_size: OrionLogoSize
compact_cover: bool
class OrionReportSettingsRead(OrionReportSettingsUpdate, EntityRead):
scope: str
updated_by_user_id: str | None = None
class EquipmentCreate(ORMModel):
kind: EquipmentKind
manufacturer: str | None = None
@ -150,12 +108,12 @@ class EquipmentUpdate(EquipmentCreate):
class ValidationCreate(ORMModel):
report_number: str | None = None
customer_id: UUID | None = None
location_id: UUID | None = None
contact_id: UUID | None = None
device_id: UUID | None = None
validation_type: str | None = None
report_number: str
customer_id: str
location_id: str | None = None
contact_id: str | None = None
device_id: str | None = None
validation_type: str
project: str | None = None
test_location: str | None = None
examiner_name: str | None = None
@ -164,12 +122,8 @@ class ValidationCreate(ORMModel):
scheduled_on: date | None = None
performed_on: date | None = None
next_validation_on: date | None = None
revalidation_interval_months: int = 24
next_validation_manually_overridden: bool = False
version: int = 1
previous_validation_id: UUID | None = None
examiner_id: UUID | None = None
status: ValidationStatus | str = ValidationStatus.draft
examiner_id: str | None = None
status: ValidationStatus = ValidationStatus.draft
result: str | None = None
notes: str | None = None
equipment_ids: list[str] = Field(default_factory=list)
@ -183,21 +137,6 @@ class ValidationCreate(ORMModel):
recommendations: list[dict] = Field(default_factory=list)
attachments: list[dict] = Field(default_factory=list)
@field_validator(
"customer_id",
"location_id",
"contact_id",
"device_id",
"examiner_id",
"previous_validation_id",
mode="before",
)
@classmethod
def empty_string_to_none(cls, value):
if value == "":
return None
return value
class ValidationRead(ValidationCreate, EntityRead):
pass
@ -205,141 +144,3 @@ class ValidationRead(ValidationCreate, EntityRead):
class ValidationUpdate(ValidationCreate):
pass
class ValidationIssue(ORMModel):
field: str
message: str
section: str
class ValidationReview(ORMModel):
status: str
errors: list[ValidationIssue]
warnings: list[ValidationIssue]
complete_sections: list[str]
class ValidationImportPreviewRow(ORMModel):
row_number: int
data: dict
errors: list[str]
duplicate: bool
resolved_customer_id: str | None = None
resolved_location_id: str | None = None
resolved_device_id: str | None = None
class ValidationImportPreview(ORMModel):
rows: list[ValidationImportPreviewRow]
valid_rows: int
invalid_rows: int
duplicates: int
class ValidationImportRequest(ORMModel):
rows: list[dict]
duplicate_strategy: str = "skip"
class ValidationImportSummary(ORMModel):
successful: int
skipped: int
failed: int
errors: list[str] = Field(default_factory=list)
class MeasurementImportValueRead(ORMModel):
id: str
test_run: str
field_name: str
raw_value: str | None = None
normalized_value: str | None = None
unit: str | None = None
source_page: int | None = None
source_text: str | None = None
confidence: int
confirmed: bool
corrected_value: str | None = None
class MeasurementImportPreviewRead(ORMModel):
id: str
validation_id: str
import_type: str
original_filename: str
sha256: str
parser_version: str
status: str
values: list[MeasurementImportValueRead]
class MeasurementImportValueConfirm(ORMModel):
id: str
confirmed: bool = False
corrected_value: str | None = None
class MeasurementImportConfirmRequest(ORMModel):
values: list[MeasurementImportValueConfirm]
class UserBase(ORMModel):
first_name: str
last_name: str
email: EmailStr
role: UserRole
is_active: bool = True
must_change_password: bool = True
class UserCreate(UserBase):
temporary_password: str
class UserUpdate(UserBase):
pass
class UserRead(UserBase, EntityRead):
last_login_at: datetime | None = None
password_changed_at: datetime | None = None
class UserPasswordResetRequest(ORMModel):
temporary_password: str | None = None
class QuickStartValidationSummary(ORMModel):
id: str
device_id: str
report_number: str
performed_on: date | None = None
result: str | None = None
next_validation_on: date | None = None
status: str
validation_type: str | None = None
equipment_ids: list[str] = Field(default_factory=list)
class QuickStartCustomerData(ORMModel):
customer: CustomerRead
locations: list[LocationRead] = Field(default_factory=list)
contacts: list[ContactRead] = Field(default_factory=list)
devices: list[DeviceRead] = Field(default_factory=list)
validations: list[QuickStartValidationSummary] = Field(default_factory=list)
class QuickStartCreateRequest(ORMModel):
customer_id: UUID
location_id: UUID | None = None
contact_id: UUID | None = None
device_id: UUID | None = None
validation_type: str
@field_validator("location_id", "contact_id", "device_id", mode="before")
@classmethod
def empty_string_to_none(cls, value):
if value == "":
return None
return value

BIN
validation-suite/backend/mercury/app/services/__pycache__/auth_service.cpython-313.pyc
View file

Binary file not shown.

BIN
validation-suite/backend/mercury/app/services/__pycache__/demo_data.cpython-313.pyc
View file

Binary file not shown.

BIN
validation-suite/backend/mercury/app/services/__pycache__/domain_service.cpython-313.pyc
View file

Binary file not shown.

BIN
validation-suite/backend/mercury/app/services/__pycache__/quickstart_service.cpython-313.pyc
View file

Binary file not shown.

BIN
validation-suite/backend/mercury/app/services/__pycache__/reference_masterdata.cpython-313.pyc
View file

Binary file not shown.

BIN
validation-suite/backend/mercury/app/services/__pycache__/validation_workflow.cpython-313.pyc
View file

Binary file not shown.

15
validation-suite/backend/mercury/app/services/auth_service.py
View file

@ -1,13 +1,9 @@
from __future__ import annotations
from datetime import UTC, datetime
from fastapi import HTTPException, status
from sqlalchemy.orm import Session
from app.core.config import settings
from app.core.security import create_access_token, verify_password
from app.models.user import User
from app.repositories.domain import UserRepository
@ -15,16 +11,13 @@ class AuthService:
def __init__(self, session: Session) -> None:
self.users = UserRepository(session)
def login(self, email: str, password: str) -> tuple[str, User]:
def login(self, email: str, password: str) -> str:
user = self.users.by_email(email)
if user is None or not verify_password(password, user.password_hash):
if user is None or not user.is_active or not verify_password(password, user.password_hash):
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Invalid credentials",
headers={"WWW-Authenticate": "Bearer"},
)
if not user.is_active or user.deleted_at is not None:
raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Inactive user")
user.last_login_at = datetime.now(UTC)
self.users.session.commit()
return create_access_token(user.id, user.role), user
return create_access_token(user.id, user.role.value)

505
validation-suite/backend/mercury/app/services/customer_import.py
View file

@ -1,505 +0,0 @@
from __future__ import annotations
import csv
import io
import json
import re
import zipfile
from dataclasses import dataclass
from html import unescape
from typing import Any
from xml.etree import ElementTree
from pydantic import EmailStr, TypeAdapter, ValidationError
from sqlalchemy import and_, func, select
from sqlalchemy.orm import Session
from app.models.contact import Contact
from app.models.customer import Customer, CustomerType
from app.models.location import Location
from app.models.user import User
MAX_IMPORT_BYTES = 5 * 1024 * 1024
SOURCE_SYSTEM = "desk4"
EMAIL_ADAPTER = TypeAdapter(EmailStr)
TARGET_FIELDS: dict[str, str] = {
"ignore": "Nicht importieren",
"customer_number": "Kundennummer",
"customer_name": "Firmenname",
"customer_addition": "Zusatz",
"customer_street": "Straße",
"customer_house_number": "Hausnummer",
"customer_postal_code": "Postleitzahl",
"customer_city": "Ort",
"customer_country": "Land",
"customer_phone": "Telefon",
"customer_mobile": "Mobiltelefon",
"customer_email": "E-Mail",
"customer_website": "Website",
"customer_vat_id": "Umsatzsteuer-ID",
"customer_notes": "Interne Notiz",
"contact_salutation": "Anrede",
"contact_first_name": "Vorname",
"contact_last_name": "Nachname",
"contact_full_name": "Ansprechpartner",
"contact_function": "Funktion",
"contact_phone": "Telefon Ansprechpartner",
"contact_mobile": "Mobil Ansprechpartner",
"contact_email": "E-Mail Ansprechpartner",
"location_name": "Standortbezeichnung",
"location_street": "Straße Standort",
"location_house_number": "Hausnummer Standort",
"location_postal_code": "PLZ Standort",
"location_city": "Ort Standort",
"location_country": "Land Standort",
}
ALIASES: dict[str, list[str]] = {
"customer_number": ["kundennr", "kunden nr", "kunden-nr", "kunden nummer", "kundennummer", "debitor", "debitorennummer", "nummer"],
"customer_name": ["firma", "firmenname", "name", "kunde", "kundenname", "unternehmen"],
"customer_addition": ["zusatz", "name 2", "firmenzusatz"],
"customer_street": ["strasse", "straße", "anschrift", "adresse", "kunde strasse"],
"customer_house_number": ["hausnummer", "hausnr", "nr"],
"customer_postal_code": ["plz", "postleitzahl", "zip"],
"customer_city": ["ort", "stadt"],
"customer_country": ["land"],
"customer_phone": ["telefon", "tel", "festnetz"],
"customer_mobile": ["mobiltelefon", "mobil", "handy"],
"customer_email": ["e-mail", "email", "mail"],
"customer_website": ["web", "website", "homepage"],
"customer_vat_id": ["ust id", "ustid", "umsatzsteuer", "vat"],
"customer_notes": ["notiz", "bemerkung", "interne notiz"],
"contact_salutation": ["anrede"],
"contact_first_name": ["vorname"],
"contact_last_name": ["nachname", "name ansprechpartner"],
"contact_full_name": ["ansprechpartner", "kontakt", "kontaktperson"],
"contact_function": ["funktion", "position"],
"contact_phone": ["telefon ansprechpartner", "kontakt telefon"],
"contact_mobile": ["mobil ansprechpartner", "kontakt mobil"],
"contact_email": ["email ansprechpartner", "e-mail ansprechpartner", "kontakt email"],
"location_name": ["standort", "standortbezeichnung", "filiale"],
"location_street": ["standort strasse", "standort straße", "liefer strasse", "lieferadresse"],
"location_house_number": ["standort hausnummer"],
"location_postal_code": ["standort plz", "liefer plz"],
"location_city": ["standort ort", "liefer ort"],
"location_country": ["standort land"],
}
@dataclass(frozen=True)
class ParsedImportFile:
headers: list[str]
rows: list[dict[str, str]]
warnings: list[str]
def normalize_header(value: str) -> str:
value = value.strip().lower().replace("ß", "ss")
value = re.sub(r"[_./:;]+", " ", value)
value = re.sub(r"\s+", " ", value)
return value
def clean(value: Any) -> str:
if value is None:
return ""
return str(value).strip()
def join_parts(*values: str) -> str:
return " ".join(item for item in (clean(value) for value in values) if item)
class CustomerImportService:
def __init__(self, session: Session) -> None:
self.session = session
def parse_file(self, filename: str, content: bytes) -> ParsedImportFile:
if not content:
raise ValueError("Die Importdatei ist leer.")
if len(content) > MAX_IMPORT_BYTES:
raise ValueError("Die Importdatei ist zu groß.")
suffix = filename.lower().rsplit(".", 1)[-1] if "." in filename else ""
if suffix == "csv":
return self._parse_csv(content)
if suffix == "xlsx":
return self._parse_xlsx(content)
raise ValueError("Nur CSV- und XLSX-Dateien werden unterstützt.")
def suggest_mapping(self, headers: list[str]) -> dict[str, str]:
mapping: dict[str, str] = {}
used: set[str] = set()
for header in headers:
normalized = normalize_header(header)
target = "ignore"
for field, aliases in ALIASES.items():
if field in used:
continue
if normalized in aliases or any(alias in normalized for alias in aliases):
target = field
used.add(field)
break
mapping[header] = target
return mapping
def preview(self, filename: str, content: bytes, mapping: dict[str, str] | None = None) -> dict:
parsed = self.parse_file(filename, content)
final_mapping = mapping or self.suggest_mapping(parsed.headers)
rows = [self._preview_row(index, row, final_mapping) for index, row in enumerate(parsed.rows, start=2)]
summary = self._summary(rows)
return {
"columns": parsed.headers,
"target_fields": TARGET_FIELDS,
"mapping": final_mapping,
"rows": rows,
"summary": summary,
"warnings": parsed.warnings,
}
def confirm(
self,
filename: str,
content: bytes,
mapping: dict[str, str],
row_actions: dict[str, str],
ignore_empty_values: bool,
user: User,
) -> dict:
preview = self.preview(filename, content, mapping)
results = []
counters = {
"total": len(preview["rows"]),
"created_customers": 0,
"updated_customers": 0,
"skipped_rows": 0,
"error_rows": 0,
"created_locations": 0,
"created_contacts": 0,
}
for row in preview["rows"]:
action = row_actions.get(str(row["row_number"]), row["action"])
if row["action"] == "ERROR":
action = "ERROR"
if action not in {"NEU_ANLEGEN", "BESTEHENDEN_AKTUALISIEREN", "UEBERSPRINGEN", "ERROR"}:
action = row["action"]
try:
result = self._apply_row(row, action, ignore_empty_values)
for key in counters:
counters[key] += result.get(key, 0)
results.append(
{
"row_number": row["row_number"],
"customer_name": row["recognized"]["customer"].get("name"),
"action": action,
"result": result["result"],
"message": result["message"],
}
)
except Exception as exc:
self.session.rollback()
counters["error_rows"] += 1
results.append(
{
"row_number": row["row_number"],
"customer_name": row["recognized"]["customer"].get("name"),
"action": action,
"result": "FEHLER",
"message": str(exc),
}
)
self.session.commit()
return {"summary": counters, "rows": results, "executed_by_user_id": user.id}
def _parse_csv(self, content: bytes) -> ParsedImportFile:
text = content.decode("utf-8-sig")
sample = text[:4096]
delimiter = ";"
try:
delimiter = csv.Sniffer().sniff(sample, delimiters=";,").delimiter
except csv.Error:
delimiter = ";" if sample.count(";") >= sample.count(",") else ","
reader = csv.DictReader(io.StringIO(text), delimiter=delimiter)
headers = [clean(item) for item in (reader.fieldnames or []) if clean(item)]
if not headers:
raise ValueError("Die Importdatei enthält keine Spaltenüberschriften.")
rows = [{header: clean(row.get(header)) for header in headers} for row in reader]
rows = [row for row in rows if any(row.values())]
if not rows:
raise ValueError("Die Importdatei enthält keine Datenzeilen.")
return ParsedImportFile(headers=headers, rows=rows, warnings=[])
def _parse_xlsx(self, content: bytes) -> ParsedImportFile:
if not content.startswith(b"PK"):
raise ValueError("Die XLSX-Datei ist ungültig.")
try:
archive = zipfile.ZipFile(io.BytesIO(content))
except zipfile.BadZipFile as exc:
raise ValueError("Die XLSX-Datei ist ungültig.") from exc
names = set(archive.namelist())
if any(name.endswith("vbaProject.bin") for name in names):
raise ValueError("Makro-Dateien werden nicht unterstützt.")
workbook = ElementTree.fromstring(archive.read("xl/workbook.xml"))
ns = {"m": "http://schemas.openxmlformats.org/spreadsheetml/2006/main", "r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships"}
sheets = workbook.findall(".//m:sheet", ns)
warnings = []
if len(sheets) > 1:
warnings.append("Die XLSX-Datei enthält mehrere Tabellenblätter. Es wurde das erste Tabellenblatt verwendet.")
sheet_path = "xl/worksheets/sheet1.xml"
shared = self._xlsx_shared_strings(archive)
sheet = ElementTree.fromstring(archive.read(sheet_path))
matrix: list[list[str]] = []
for row in sheet.findall(".//m:sheetData/m:row", ns):
values: dict[int, str] = {}
for cell in row.findall("m:c", ns):
ref = cell.attrib.get("r", "A1")
col = self._column_index(ref)
value = self._xlsx_cell_value(cell, shared, ns)
values[col] = value
if values:
matrix.append([values.get(index, "") for index in range(max(values) + 1)])
if not matrix:
raise ValueError("Die XLSX-Datei enthält keine Daten.")
headers = [clean(value) for value in matrix[0]]
headers = [value for value in headers if value]
if not headers:
raise ValueError("Die XLSX-Datei enthält keine Spaltenüberschriften.")
rows = []
for raw in matrix[1:]:
row = {header: clean(raw[index] if index < len(raw) else "") for index, header in enumerate(headers)}
if any(row.values()):
rows.append(row)
if not rows:
raise ValueError("Die XLSX-Datei enthält keine Datenzeilen.")
return ParsedImportFile(headers=headers, rows=rows, warnings=warnings)
def _xlsx_shared_strings(self, archive: zipfile.ZipFile) -> list[str]:
if "xl/sharedStrings.xml" not in archive.namelist():
return []
ns = {"m": "http://schemas.openxmlformats.org/spreadsheetml/2006/main"}
root = ElementTree.fromstring(archive.read("xl/sharedStrings.xml"))
values = []
for item in root.findall(".//m:si", ns):
values.append(unescape("".join(node.text or "" for node in item.findall(".//m:t", ns))))
return values
def _xlsx_cell_value(self, cell: ElementTree.Element, shared: list[str], ns: dict[str, str]) -> str:
cell_type = cell.attrib.get("t")
value_node = cell.find("m:v", ns)
if value_node is None:
inline = cell.find(".//m:t", ns)
return clean(inline.text if inline is not None else "")
value = clean(value_node.text)
if cell_type == "s" and value.isdigit() and int(value) < len(shared):
return shared[int(value)]
return value
def _column_index(self, ref: str) -> int:
letters = re.sub(r"[^A-Z]", "", ref.upper())
index = 0
for char in letters:
index = index * 26 + (ord(char) - 64)
return max(index - 1, 0)
def _mapped_values(self, row: dict[str, str], mapping: dict[str, str]) -> dict[str, str]:
values = {field: "" for field in TARGET_FIELDS if field != "ignore"}
for column, target in mapping.items():
if target in values and not values[target]:
values[target] = clean(row.get(column))
return values
def _preview_row(self, row_number: int, row: dict[str, str], mapping: dict[str, str]) -> dict:
values = self._mapped_values(row, mapping)
recognized = self._recognized(values)
errors = self._validate_values(values)
matches = self._find_matches(recognized["customer"])
action = "NEU_ANLEGEN"
message = "Neuer Kunde"
if errors:
action = "ERROR"
message = "Pflichtfeld oder Eingabe ungültig"
elif matches["external_id"]:
action = "BESTEHENDEN_AKTUALISIEREN"
message = "Bestehender Kunde über Kundennummer gefunden"
elif matches["name_postal_code"] or matches["name_city"] or matches["email"]:
action = "UEBERSPRINGEN"
message = "Mögliche Dublette gefunden"
return {
"row_number": row_number,
"source": row,
"recognized": recognized,
"errors": errors,
"action": action,
"message": message,
"matches": {key: self._customer_ref(value) for key, value in matches.items() if value},
"allowed_actions": self._allowed_actions(action, bool(matches["external_id"])),
}
def _recognized(self, values: dict[str, str]) -> dict:
customer_notes = "\n".join(
item
for item in [
values["customer_notes"],
f"Zusatz: {values['customer_addition']}" if values["customer_addition"] else "",
f"Land: {values['customer_country']}" if values["customer_country"] else "",
f"Mobil: {values['customer_mobile']}" if values["customer_mobile"] else "",
f"Website: {values['customer_website']}" if values["customer_website"] else "",
f"USt-ID: {values['customer_vat_id']}" if values["customer_vat_id"] else "",
]
if item
)
first_last = join_parts(values["contact_first_name"], values["contact_last_name"])
full_name = values["contact_full_name"] or first_last
return {
"customer": {
"source_system": SOURCE_SYSTEM if values["customer_number"] else None,
"external_id": values["customer_number"] or None,
"name": values["customer_name"],
"street": join_parts(values["customer_street"], values["customer_house_number"]),
"postal_code": values["customer_postal_code"],
"city": values["customer_city"],
"phone": values["customer_phone"] or values["customer_mobile"],
"email": values["customer_email"],
"notes": customer_notes,
},
"location": {
"name": values["location_name"] or "Hauptstandort",
"street": join_parts(values["location_street"], values["location_house_number"]) or join_parts(values["customer_street"], values["customer_house_number"]),
"postal_code": values["location_postal_code"] or values["customer_postal_code"],
"city": values["location_city"] or values["customer_city"],
},
"contact": {
"full_name": full_name,
"function": values["contact_function"],
"email": values["contact_email"],
"phone": values["contact_phone"] or values["contact_mobile"],
"notes": values["contact_salutation"],
},
}
def _validate_values(self, values: dict[str, str]) -> list[str]:
errors = []
if not values["customer_number"] and not values["customer_name"]:
errors.append("Kundennummer oder Firmenname fehlt.")
for label, value in [("Kunden-E-Mail", values["customer_email"]), ("Ansprechpartner-E-Mail", values["contact_email"])]:
if value:
try:
EMAIL_ADAPTER.validate_python(value)
except ValidationError:
errors.append(f"{label} ist ungültig.")
return errors
def _find_matches(self, customer: dict) -> dict[str, Customer | None]:
external = None
if customer.get("external_id"):
external = self.session.scalar(
select(Customer).where(
Customer.source_system == SOURCE_SYSTEM,
Customer.external_id == customer["external_id"],
)
)
name = customer.get("name")
postal_code = customer.get("postal_code")
city = customer.get("city")
email = customer.get("email")
return {
"external_id": external,
"name_postal_code": self.session.scalar(select(Customer).where(func.lower(Customer.name) == name.lower(), Customer.postal_code == postal_code)) if name and postal_code else None,
"name_city": self.session.scalar(select(Customer).where(func.lower(Customer.name) == name.lower(), func.lower(Customer.city) == city.lower())) if name and city else None,
"email": self.session.scalar(select(Customer).where(func.lower(Customer.email) == email.lower())) if email else None,
}
def _allowed_actions(self, action: str, has_external_match: bool) -> list[str]:
if action == "ERROR":
return ["ERROR"]
if has_external_match:
return ["BESTEHENDEN_AKTUALISIEREN", "UEBERSPRINGEN"]
return ["NEU_ANLEGEN", "UEBERSPRINGEN"]
def _customer_ref(self, customer: Customer) -> dict:
return {"id": customer.id, "name": customer.name, "external_id": customer.external_id, "postal_code": customer.postal_code, "city": customer.city}
def _apply_row(self, row: dict, action: str, ignore_empty_values: bool) -> dict:
if action in {"UEBERSPRINGEN", "ERROR"}:
return {"skipped_rows": 1 if action == "UEBERSPRINGEN" else 0, "error_rows": 1 if action == "ERROR" else 0, "result": "ÜBERSPRUNGEN" if action == "UEBERSPRINGEN" else "FEHLER", "message": row["message"]}
customer_data = row["recognized"]["customer"]
matches = self._find_matches(customer_data)
customer = matches["external_id"]
created_customer = False
if action == "BESTEHENDEN_AKTUALISIEREN":
if customer is None:
raise ValueError("Aktualisierung ist nur mit eindeutiger Kundennummer möglich.")
self._update_customer(customer, customer_data, ignore_empty_values)
else:
if customer is not None:
raise ValueError("Kunde mit dieser Kundennummer existiert bereits.")
customer = Customer(customer_type=CustomerType.practice, name=customer_data["name"] or customer_data["external_id"])
self._update_customer(customer, customer_data, False)
self.session.add(customer)
self.session.flush()
created_customer = True
created_location = self._ensure_location(customer, row["recognized"]["location"])
created_contact = self._ensure_contact(customer, row["recognized"]["contact"])
self.session.flush()
return {
"created_customers": 1 if created_customer else 0,
"updated_customers": 0 if created_customer else 1,
"created_locations": 1 if created_location else 0,
"created_contacts": 1 if created_contact else 0,
"result": "ERFOLGREICH",
"message": "Kunde angelegt" if created_customer else "Kunde aktualisiert",
}
def _update_customer(self, customer: Customer, data: dict, ignore_empty_values: bool) -> None:
for key in ["source_system", "external_id", "name", "street", "postal_code", "city", "phone", "email", "notes"]:
value = data.get(key)
if ignore_empty_values and value in (None, ""):
continue
setattr(customer, key, value or None)
def _ensure_location(self, customer: Customer, data: dict) -> bool:
if not any(data.get(key) for key in ["name", "street", "postal_code", "city"]):
return False
existing = self.session.scalar(
select(Location).where(
Location.customer_id == customer.id,
func.lower(Location.name) == data["name"].lower(),
)
)
if existing:
return False
self.session.add(Location(customer_id=customer.id, **{key: value or None for key, value in data.items()}))
return True
def _ensure_contact(self, customer: Customer, data: dict) -> bool:
if not data.get("full_name"):
return False
existing = self.session.scalar(
select(Contact).where(
Contact.customer_id == customer.id,
func.lower(Contact.full_name) == data["full_name"].lower(),
)
)
if existing:
return False
self.session.add(Contact(customer_id=customer.id, **{key: value or None for key, value in data.items()}))
return True
def _summary(self, rows: list[dict]) -> dict:
return {
"total": len(rows),
"new": sum(1 for row in rows if row["action"] == "NEU_ANLEGEN"),
"update": sum(1 for row in rows if row["action"] == "BESTEHENDEN_AKTUALISIEREN"),
"duplicates": sum(1 for row in rows if row["action"] == "UEBERSPRINGEN" and row["matches"]),
"errors": sum(1 for row in rows if row["action"] == "ERROR"),
"skip": sum(1 for row in rows if row["action"] == "UEBERSPRINGEN"),
}
def parse_json_object(value: str | None, fallback: dict | None = None) -> dict:
if not value:
return fallback or {}
parsed = json.loads(value)
if not isinstance(parsed, dict):
raise ValueError("JSON-Daten müssen ein Objekt sein.")
return parsed

757
validation-suite/backend/mercury/app/services/demo_data.py
View file

@ -1,757 +0,0 @@
from __future__ import annotations
from copy import deepcopy
from dataclasses import dataclass
from datetime import date
from pathlib import Path
import shutil
from typing import Any
from dateutil.relativedelta import relativedelta
from sqlalchemy import delete, select
from sqlalchemy.orm import Session
from app.models.contact import Contact
from app.models.customer import Customer, CustomerType
from app.models.device import Device
from app.models.equipment import Equipment, EquipmentKind, EquipmentStatus
from app.models.location import Location
from app.models.validation import Validation, ValidationStatus
from app.modules.orion.service import OrionReportService
from app.modules.orion.template_service import ReportTemplateService
from app.services.validation_workflow import ValidationWorkflowService
DEMO_TAG = "DEMO_DATA"
DEMO_REPORT_PREFIX = "DEMO-VAL"
DEMO_DEVICE_PREFIX = "DEMO-DEV"
DEMO_EQUIPMENT_PREFIX = "DEMO-EQ"
DEMO_UPLOAD_ROOT = Path("/app/uploads/demo-data")
DEMO_REPORT_ROOT = Path("/app/reports")
@dataclass(frozen=True)
class DemoCustomerTemplate:
name: str
specialty: str
street: str
postal_code: str
city: str
phone: str
email: str
hygiene_officer: str
quality_manager: str
operator: str
locations: list[dict[str, Any]]
contacts: list[dict[str, Any]]
device: dict[str, Any]
CUSTOMER_TEMPLATES: list[DemoCustomerTemplate] = [
DemoCustomerTemplate(
name="Zahnzentrum Alster",
specialty="Zahnarzt",
street="Alsterufer 18",
postal_code="20354",
city="Hamburg",
phone="040 5550010",
email="kontakt@zahnzentrum-alster.schubamed.de",
hygiene_officer="Dr. Jana Peters",
quality_manager="M. Kruse",
operator="Dr. Jana Peters",
locations=[
{"name": "Hauptpraxis", "street": "Alsterufer 18", "postal_code": "20354", "city": "Hamburg", "room": "Steri 1"},
{"name": "OP-Bereich", "street": "Alsterufer 18", "postal_code": "20354", "city": "Hamburg", "room": "OP 2"},
],
contacts=[
{"full_name": "Dr. Jana Peters", "function": "Betreiberin", "email": "jana.peters@schubamed.de", "phone": "040 5550011"},
{"full_name": "M. Kruse", "function": "QM-Beauftragte", "email": "qm.zahnzentrum.alster@schubamed.de", "phone": "040 5550012"},
],
device={
"manufacturer": "Euronda SpA",
"model": "E10.7",
"serial_number": "SN-DEMO-001",
"year_built": 2023,
"commissioned_on": date(2023, 6, 14),
"chamber_volume_liters": 24,
"steam_generation": "Eigendampferzeugung",
"water_treatment": "Vollentsalzung",
"documentation": "CF-Karte und PDF-Protokoll",
"supplier": "schubamed Medizintechnik",
},
),
DemoCustomerTemplate(
name="Urologie Zentrum Elbe",
specialty="Urologie",
street="Mönckebergstr. 11",
postal_code="20095",
city="Hamburg",
phone="040 5550020",
email="kontakt@urologie-elbe.schubamed.de",
hygiene_officer="Dr. Felix Brandt",
quality_manager="S. Lange",
operator="Dr. Felix Brandt",
locations=[
{"name": "Praxis Mitte", "street": "Mönckebergstr. 11", "postal_code": "20095", "city": "Hamburg", "room": "Steri A"},
],
contacts=[
{"full_name": "Dr. Felix Brandt", "function": "Betreiber", "email": "felix.brandt@schubamed.de", "phone": "040 5550021"},
],
device={
"manufacturer": "Euronda SpA",
"model": "E9",
"serial_number": "SN-DEMO-002",
"year_built": 2022,
"commissioned_on": date(2022, 11, 2),
"chamber_volume_liters": 18,
"steam_generation": "Generator integriert",
"water_treatment": "Wasserkonditionierung",
"documentation": "Digitale Dokumentation",
"supplier": "schubamed Medizintechnik",
},
),
DemoCustomerTemplate(
name="Orthopädie am Park",
specialty="Orthopädie",
street="Königsallee 44",
postal_code="40212",
city="Düsseldorf",
phone="0211 5550030",
email="kontakt@orthopaedie-park.schubamed.de",
hygiene_officer="Dr. Lea Sommer",
quality_manager="A. Hoffmann",
operator="Dr. Lea Sommer",
locations=[
{"name": "Ambulanz", "street": "Königsallee 44", "postal_code": "40212", "city": "Düsseldorf", "room": "Steri 1"},
{"name": "Behandlungszentrum", "street": "Kaiserswerther Str. 99", "postal_code": "40474", "city": "Düsseldorf", "room": "Steri 2"},
],
contacts=[
{"full_name": "Dr. Lea Sommer", "function": "Betreiberin", "email": "lea.sommer@schubamed.de", "phone": "0211 5550031"},
{"full_name": "A. Hoffmann", "function": "Hygienebeauftragte", "email": "hygiene.orthopaedie@schubamed.de", "phone": "0211 5550032"},
],
device={
"manufacturer": "MELAG",
"model": "Vacuklav 41 B+",
"serial_number": "SN-DEMO-003",
"year_built": 2021,
"commissioned_on": date(2021, 9, 8),
"chamber_volume_liters": 22,
"steam_generation": "Dampferzeuger intern",
"water_treatment": "VE-Wasser",
"documentation": "CF-Karte, USB-Export",
"supplier": "schubamed Medizintechnik",
},
),
DemoCustomerTemplate(
name="Dermatologie Rhein",
specialty="Dermatologie",
street="Breite Str. 8",
postal_code="50667",
city="Köln",
phone="0221 5550040",
email="kontakt@dermatologie-rhein.schubamed.de",
hygiene_officer="Dr. Sophie Keller",
quality_manager="D. Neumann",
operator="Dr. Sophie Keller",
locations=[
{"name": "Hautpraxis", "street": "Breite Str. 8", "postal_code": "50667", "city": "Köln", "room": "Steri"},
],
contacts=[
{"full_name": "Dr. Sophie Keller", "function": "Betreiberin", "email": "sophie.keller@schubamed.de", "phone": "0221 5550041"},
{"full_name": "D. Neumann", "function": "QM", "email": "qm.dermatologie.rhein@schubamed.de", "phone": "0221 5550042"},
],
device={
"manufacturer": "MELAG",
"model": "Vacuklav 44 B+",
"serial_number": "SN-DEMO-004",
"year_built": 2020,
"commissioned_on": date(2020, 4, 16),
"chamber_volume_liters": 24,
"steam_generation": "Eigendampferzeugung",
"water_treatment": "Osmose",
"documentation": "Digitale Dokumentation und Ausdruck",
"supplier": "schubamed Medizintechnik",
},
),
DemoCustomerTemplate(
name="HNO Zentrum Forum",
specialty="HNO",
street="Theatinerstr. 19",
postal_code="80333",
city="München",
phone="089 5550050",
email="kontakt@hno-forum.schubamed.de",
hygiene_officer="Dr. Tom Berger",
quality_manager="R. Wagner",
operator="Dr. Tom Berger",
locations=[
{"name": "Forum Praxis", "street": "Theatinerstr. 19", "postal_code": "80333", "city": "München", "room": "Steri 1"},
],
contacts=[
{"full_name": "Dr. Tom Berger", "function": "Betreiber", "email": "tom.berger@schubamed.de", "phone": "089 5550051"},
],
device={
"manufacturer": "MELAG",
"model": "PrimeLine",
"serial_number": "SN-DEMO-005",
"year_built": 2024,
"commissioned_on": date(2024, 3, 1),
"chamber_volume_liters": 29,
"steam_generation": "Generator integriert",
"water_treatment": "VE-Wasser",
"documentation": "USB-Export",
"supplier": "schubamed Medizintechnik",
},
),
DemoCustomerTemplate(
name="Gynäkologie Marienhof",
specialty="Gynäkologie",
street="Marienplatz 3",
postal_code="86150",
city="Augsburg",
phone="0821 5550060",
email="kontakt@gyn-marienhof.schubamed.de",
hygiene_officer="Dr. Miriam Wolf",
quality_manager="K. Braun",
operator="Dr. Miriam Wolf",
locations=[
{"name": "Frauenpraxis", "street": "Marienplatz 3", "postal_code": "86150", "city": "Augsburg", "room": "Steri"},
{"name": "Ambulanz Süd", "street": "Bürgermeister-Fischer-Str. 12", "postal_code": "86150", "city": "Augsburg", "room": "Steri 2"},
],
contacts=[
{"full_name": "Dr. Miriam Wolf", "function": "Betreiberin", "email": "miriam.wolf@schubamed.de", "phone": "0821 5550061"},
],
device={
"manufacturer": "MELAG",
"model": "ProLine",
"serial_number": "SN-DEMO-006",
"year_built": 2019,
"commissioned_on": date(2019, 8, 23),
"chamber_volume_liters": 18,
"steam_generation": "Kompaktgenerator",
"water_treatment": "VE-Wasser",
"documentation": "CF-Card",
"supplier": "schubamed Medizintechnik",
},
),
DemoCustomerTemplate(
name="Chirurgie Ost",
specialty="Chirurgie",
street="Lindenstr. 7",
postal_code="04109",
city="Leipzig",
phone="0341 5550070",
email="kontakt@chirurgie-ost.schubamed.de",
hygiene_officer="Dr. Paul Richter",
quality_manager="F. Scholz",
operator="Dr. Paul Richter",
locations=[
{"name": "OP-Zentrum", "street": "Lindenstr. 7", "postal_code": "04109", "city": "Leipzig", "room": "Steri OP"},
],
contacts=[
{"full_name": "Dr. Paul Richter", "function": "Betreiber", "email": "paul.richter@schubamed.de", "phone": "0341 5550071"},
{"full_name": "F. Scholz", "function": "Hygiene", "email": "hygiene.chirurgie.ost@schubamed.de", "phone": "0341 5550072"},
],
device={
"manufacturer": "W&H",
"model": "Lara XL",
"serial_number": "SN-DEMO-007",
"year_built": 2023,
"commissioned_on": date(2023, 2, 15),
"chamber_volume_liters": 17,
"steam_generation": "Dampferzeuger intern",
"water_treatment": "Mikrofiltration",
"documentation": "USB und Ausdruck",
"supplier": "schubamed Medizintechnik",
},
),
DemoCustomerTemplate(
name="Allgemeinmedizin West",
specialty="Allgemeinmedizin",
street="Bergstr. 25",
postal_code="70173",
city="Stuttgart",
phone="0711 5550080",
email="kontakt@allgemeinmedizin-west.schubamed.de",
hygiene_officer="Dr. Nina Beck",
quality_manager="J. Hartmann",
operator="Dr. Nina Beck",
locations=[
{"name": "Hausarztpraxis", "street": "Bergstr. 25", "postal_code": "70173", "city": "Stuttgart", "room": "Steri"},
],
contacts=[
{"full_name": "Dr. Nina Beck", "function": "Betreiberin", "email": "nina.beck@schubamed.de", "phone": "0711 5550081"},
],
device={
"manufacturer": "W&H",
"model": "Lisa",
"serial_number": "SN-DEMO-008",
"year_built": 2022,
"commissioned_on": date(2022, 7, 12),
"chamber_volume_liters": 22,
"steam_generation": "Eigendampferzeugung",
"water_treatment": "VE-Wasser",
"documentation": "Digital und Papier",
"supplier": "schubamed Medizintechnik",
},
),
DemoCustomerTemplate(
name="Augenärzte am Ring",
specialty="Augenarzt",
street="Ringstr. 52",
postal_code="50672",
city="Köln",
phone="0221 5550090",
email="kontakt@augenaerzte-ring.schubamed.de",
hygiene_officer="Dr. Karin Otto",
quality_manager="M. Franke",
operator="Dr. Karin Otto",
locations=[
{"name": "Augenzentrum", "street": "Ringstr. 52", "postal_code": "50672", "city": "Köln", "room": "Steri 1"},
{"name": "Laserzentrum", "street": "Ringstr. 54", "postal_code": "50672", "city": "Köln", "room": "Steri 2"},
],
contacts=[
{"full_name": "Dr. Karin Otto", "function": "Betreiberin", "email": "karin.otto@schubamed.de", "phone": "0221 5550091"},
{"full_name": "M. Franke", "function": "QM", "email": "qm.augen@schubamed.de", "phone": "0221 5550092"},
],
device={
"manufacturer": "Mocom",
"model": "B Classic",
"serial_number": "SN-DEMO-009",
"year_built": 2021,
"commissioned_on": date(2021, 5, 20),
"chamber_volume_liters": 12,
"steam_generation": "Kompaktgenerator",
"water_treatment": "Vollentsalzung",
"documentation": "USB-Export",
"supplier": "schubamed Medizintechnik",
},
),
DemoCustomerTemplate(
name="MVZ Medikon",
specialty="MVZ",
street="Forum 9",
postal_code="90402",
city="Nürnberg",
phone="0911 5550100",
email="kontakt@mvz-medikon.schubamed.de",
hygiene_officer="Dr. Lara Stein",
quality_manager="C. Meier",
operator="Dr. Lara Stein",
locations=[
{"name": "Hauptstandort", "street": "Forum 9", "postal_code": "90402", "city": "Nürnberg", "room": "Steri A"},
{"name": "Nebenstandort", "street": "Forum 11", "postal_code": "90402", "city": "Nürnberg", "room": "Steri B"},
],
contacts=[
{"full_name": "Dr. Lara Stein", "function": "Betreiberin", "email": "lara.stein@schubamed.de", "phone": "0911 5550101"},
{"full_name": "C. Meier", "function": "Hygiene", "email": "hygiene.mvz@schubamed.de", "phone": "0911 5550102"},
],
device={
"manufacturer": "Kronos",
"model": "B23",
"serial_number": "SN-DEMO-010",
"year_built": 2024,
"commissioned_on": date(2024, 1, 11),
"chamber_volume_liters": 23,
"steam_generation": "Eigendampferzeugung",
"water_treatment": "VE-Wasser",
"documentation": "Hybrid",
"supplier": "schubamed Medizintechnik",
},
),
]
EQUIPMENT_TEMPLATES: list[dict[str, Any]] = [
{
"kind": EquipmentKind.temperature_logger,
"manufacturer": "EBRO",
"model": "EBI 11",
"serial_number": "DEMO-EBI11-001",
"calibrated_on": date(2025, 1, 17),
"calibration_due_on": date(2026, 1, 17),
"status": EquipmentStatus.green,
"notes": "Demo-Temperaturlogger",
},
{
"kind": EquipmentKind.temperature_logger,
"manufacturer": "EBRO",
"model": "EBI 11",
"serial_number": "DEMO-EBI11-002",
"calibrated_on": date(2025, 2, 2),
"calibration_due_on": date(2026, 2, 2),
"status": EquipmentStatus.green,
"notes": "Demo-Temperaturlogger",
},
{
"kind": EquipmentKind.pressure_logger,
"manufacturer": "EBRO",
"model": "Drucklogger",
"serial_number": "DEMO-PR-001",
"calibrated_on": date(2025, 1, 21),
"calibration_due_on": date(2026, 1, 21),
"status": EquipmentStatus.green,
"notes": "Demo-Drucklogger",
},
{
"kind": EquipmentKind.sensor,
"manufacturer": "Mettler Toledo",
"model": "Waage",
"serial_number": "DEMO-SCALE-001",
"calibrated_on": date(2024, 12, 12),
"calibration_due_on": date(2025, 12, 12),
"status": EquipmentStatus.yellow,
"notes": "Demo-Waage",
},
{
"kind": EquipmentKind.sensor,
"manufacturer": "Mettler Toledo",
"model": "Leitwertmessgerät",
"serial_number": "DEMO-COND-001",
"calibrated_on": date(2025, 3, 4),
"calibration_due_on": date(2026, 3, 4),
"status": EquipmentStatus.green,
"notes": "Demo-Leitwertmessgerät",
},
{
"kind": EquipmentKind.sensor,
"manufacturer": "Trotec",
"model": "Raumklimamessgerät",
"serial_number": "DEMO-CLIMATE-001",
"calibrated_on": date(2024, 11, 1),
"calibration_due_on": date(2025, 11, 1),
"status": EquipmentStatus.red,
"notes": "Demo-Raumklimamessgerät",
},
]
class DemoDataService:
def __init__(self, session: Session, upload_root: Path | None = None, report_root: Path | None = None) -> None:
self.session = session
self.upload_root = upload_root or DEMO_UPLOAD_ROOT.parent
self.report_root = report_root or DEMO_REPORT_ROOT
self.demo_upload_root = self.upload_root / "demo-data"
def run(
self,
*,
customers: int = 10,
devices: int = 10,
validations: int = 20,
reports: bool = False,
images: bool = False,
reset: bool = False,
) -> dict[str, int]:
if reset:
self.reset()
created_customers = self.ensure_customers(max(customers, 10))
created_equipment = self.ensure_equipment()
created_devices = self.ensure_devices(max(devices, 10), created_customers)
created_validations = self.ensure_validations(max(validations, 20), created_customers, created_devices, images=images)
self.session.commit()
if reports:
self._generate_reports(created_validations)
return {
"customers": len(created_customers),
"devices": len(created_devices),
"validations": len(created_validations),
"equipment": len(created_equipment),
}
def reset(self) -> None:
demo_validation_ids = self.session.scalars(
select(Validation.id).where(
Validation.report_number.like(f"{DEMO_REPORT_PREFIX}%")
| Validation.notes.like(f"%{DEMO_TAG}%")
)
).all()
if demo_validation_ids:
self.session.execute(delete(Validation).where(Validation.id.in_(demo_validation_ids)))
self.session.execute(
delete(Equipment).where(Equipment.serial_number.like("DEMO-%") | Equipment.notes.like(f"%{DEMO_TAG}%"))
)
self.session.execute(
delete(Device).where(Device.serial_number.like("SN-DEMO-%") | Device.notes.like(f"%{DEMO_TAG}%"))
)
self.session.execute(
delete(Contact).where(
Contact.email.like("demo-%@schubamed.de") | Contact.notes.like(f"%{DEMO_TAG}%")
)
)
self.session.execute(
delete(Customer).where(
Customer.email.like("demo-%@schubamed.de") | Customer.notes.like(f"%{DEMO_TAG}%")
)
)
self.session.commit()
if self.demo_upload_root.exists():
shutil.rmtree(self.demo_upload_root)
self.report_root.mkdir(parents=True, exist_ok=True)
for pdf in self.report_root.glob(f"{DEMO_REPORT_PREFIX}*.pdf"):
pdf.unlink()
def ensure_customers(self, count: int) -> list[Customer]:
ensured: list[Customer] = []
for index in range(count):
template = CUSTOMER_TEMPLATES[index % len(CUSTOMER_TEMPLATES)]
occurrence = index // len(CUSTOMER_TEMPLATES)
customer = self._ensure_customer(template, occurrence, index)
ensured.append(customer)
return ensured
def ensure_equipment(self) -> list[Equipment]:
items: list[Equipment] = []
for template in EQUIPMENT_TEMPLATES:
equipment = self.session.scalar(
select(Equipment).where(Equipment.serial_number == template["serial_number"])
)
if equipment is None:
equipment = Equipment(**template)
equipment.notes = f"{template['notes']} {DEMO_TAG}"
self.session.add(equipment)
self.session.flush()
items.append(equipment)
return items
def ensure_devices(self, count: int, customers: list[Customer]) -> list[Device]:
devices: list[Device] = []
all_locations = {customer.id: list(self.session.scalars(select(Location).where(Location.customer_id == customer.id))) for customer in customers}
for index in range(count):
customer = customers[index % len(customers)]
template = CUSTOMER_TEMPLATES[index % len(CUSTOMER_TEMPLATES)].device
occurrence = index // len(CUSTOMER_TEMPLATES)
serial_number = template["serial_number"] if occurrence == 0 else f"{template['serial_number']}-{occurrence + 1}"
device = self.session.scalar(select(Device).where(Device.serial_number == serial_number))
if device is None:
location_candidates = all_locations.get(customer.id, [])
location_id = location_candidates[0].id if location_candidates else None
device_payload = deepcopy(template)
device_payload["serial_number"] = serial_number
device_payload["customer_id"] = customer.id
device_payload["location_id"] = location_id
device = Device(**device_payload)
device.notes = f"{DEMO_TAG} {customer.name}"
self.session.add(device)
self.session.flush()
devices.append(device)
return devices
def ensure_validations(
self,
count: int,
customers: list[Customer],
devices: list[Device],
*,
images: bool = False,
) -> list[Validation]:
validations: list[Validation] = []
report_number_index = 1
for index in range(count):
template = CUSTOMER_TEMPLATES[index % len(CUSTOMER_TEMPLATES)]
customer = customers[index % len(customers)]
device = devices[index % len(devices)]
locations = list(self.session.scalars(select(Location).where(Location.customer_id == customer.id)))
contacts = list(self.session.scalars(select(Contact).where(Contact.customer_id == customer.id)))
location = locations[index % len(locations)] if locations else None
contact = contacts[index % len(contacts)] if contacts else None
report_number = f"{DEMO_REPORT_PREFIX}-{report_number_index:03d}"
report_number_index += 1
validation = self.session.scalar(select(Validation).where(Validation.report_number == report_number))
if validation is None:
validation = Validation(
report_number=report_number,
customer_id=customer.id,
location_id=location.id if location else None,
contact_id=contact.id if contact else None,
device_id=device.id,
validation_type="Erstvalidierung" if index % 2 == 0 else "Revalidierung",
performed_on=date.today() - relativedelta(months=6 + index),
examiner_name="Dr. Lara Stein",
operator_name=template.operator,
participants=f"{customer.name} - Team",
status=[
ValidationStatus.draft.value,
ValidationStatus.approved.value,
ValidationStatus.completed.value,
][index % 3],
result="bestanden" if index % 3 else "bestanden mit Auflagen",
revalidation_interval_months=24,
equipment_ids=[equipment.id for equipment in self.session.scalars(select(Equipment).limit(3))],
environment_conditions={
"room_temperature": 22 + (index % 3),
"humidity": 48 + (index % 5),
"test_time": f"{8 + (index % 3)}:30",
"checks": [
{"text": "Raumbedingungen stabil", "value": "yes", "comment": ""},
{"text": "Aufstellort frei zugänglich", "value": "yes", "comment": ""},
],
},
documentation_checklist=self._checklist("documentation_control", index),
performance_checklist=self._checklist("sterilizer_description", index),
programs=[
{"name": "Vakuumtest", "selected": True, "custom": False},
{"name": "Bowie-Dick / Leerkammerprofil", "selected": index % 2 == 0, "custom": False},
{"name": "134 C hohl verpackt", "selected": True, "custom": False},
],
loading_patterns=self._loading_patterns(index),
measurement_data=self._measurement_data(index),
drying={"start_weight": 12.5, "end_weight": 12.1, "difference": 0.4, "assessment": "in Ordnung", "comment": ""},
recommendations=[
{"number": 1, "text": "Routinekontrolle dokumentieren", "deadline": "6 Monate", "status": "offen"}
] if index % 4 == 0 else [],
attachments=self._attachments_for_validation(index, images=images),
notes=DEMO_TAG,
)
self.session.add(validation)
self.session.flush()
ValidationWorkflowService(self.session).apply_revalidation_date(validation)
validations.append(validation)
return validations
def _ensure_customer(self, template: DemoCustomerTemplate, occurrence: int, index: int) -> Customer:
email = template.email if occurrence == 0 else f"demo-{index + 1:02d}@schubamed.de"
customer = self.session.scalar(select(Customer).where(Customer.email == email))
if customer is None:
customer = Customer(
customer_type=CustomerType.practice,
name=template.name if occurrence == 0 else f"{template.name} {occurrence + 1}",
street=template.street,
postal_code=template.postal_code,
city=template.city,
phone=template.phone,
email=email,
hygiene_officer=template.hygiene_officer,
quality_manager=template.quality_manager,
notes=f"{DEMO_TAG} {template.specialty}",
)
self.session.add(customer)
self.session.flush()
for loc_index, location_payload in enumerate(template.locations, start=1):
location = self.session.scalar(
select(Location).where(
Location.customer_id == customer.id,
Location.name == location_payload["name"],
)
)
if location is None:
self.session.add(Location(customer_id=customer.id, **location_payload))
for contact_payload in template.contacts:
contact = self.session.scalar(
select(Contact).where(
Contact.customer_id == customer.id,
Contact.full_name == contact_payload["full_name"],
)
)
if contact is None:
self.session.add(
Contact(
customer_id=customer.id,
full_name=contact_payload["full_name"],
function=contact_payload["function"],
email=contact_payload["email"],
phone=contact_payload["phone"],
notes=DEMO_TAG,
)
)
self.session.flush()
return customer
def _checklist(self, key: str, index: int) -> list[dict[str, Any]]:
bundle = ReportTemplateService(self.session).ensure_default_template()
template = next((item for item in bundle.checklists if item.checklist_key == key), None)
if template is None:
return []
values = ["yes", "yes", "na"] if index % 2 == 0 else ["yes", "na", "yes"]
return [
{
"number": item["number"],
"text": item["text"],
"value": values[(item["number"] - 1) % len(values)],
"comment": "",
}
for item in template.items
]
def _loading_patterns(self, index: int) -> list[dict[str, Any]]:
return [
{
"run": 1,
"pattern": "Standard",
"description": f"Demo-Beladung {index + 1}",
"images": [],
},
{
"run": 2,
"pattern": "Standard",
"description": "",
"images": [],
},
{
"run": 3,
"pattern": "Standard",
"description": "",
"images": [],
},
]
def _measurement_data(self, index: int) -> list[dict[str, Any]]:
base_temperature = 132 + (index % 3)
return [
{
"test_run": "Vakuumtest",
"start_time": "08:00",
"end_time": "08:08",
"duration": "00:08",
"leak_rate": "0.4",
"result": "bestanden",
},
{
"test_run": "Testlauf 1",
"start_time": "09:00",
"end_time": "09:31",
"duration": "00:31",
"minimum_temperature": base_temperature,
"maximum_temperature": base_temperature + 2,
"temperature_band": "2.0",
"holding_time": "3:00",
"pressure": "2.1",
"result": "bestanden",
},
]
def _attachments_for_validation(self, index: int, *, images: bool) -> list[dict[str, Any]]:
if not images or index >= 5:
return []
image_dir = self.demo_upload_root / "images"
image_dir.mkdir(parents=True, exist_ok=True)
image_path = image_dir / f"demo-figure-{index + 1}.svg"
if not image_path.exists():
image_path.write_text(
"\n".join(
[
'<svg xmlns="http://www.w3.org/2000/svg" width="1200" height="800" viewBox="0 0 1200 800">',
'<rect width="1200" height="800" fill="#f6f7f2"/>',
'<rect x="60" y="60" width="1080" height="680" rx="18" fill="#ffffff" stroke="#bfc5bd" stroke-width="3"/>',
'<text x="100" y="150" font-family="Arial, sans-serif" font-size="44" fill="#2f3b35">SCHUBAMED Demo-Bild</text>',
f'<text x="100" y="230" font-family="Arial, sans-serif" font-size="32" fill="#4d5b54">Validierung {index + 1}</text>',
"</svg>",
]
),
encoding="utf-8",
)
return [
{
"category": "Beladung",
"filename": image_path.name,
"content_type": "image/svg+xml",
"description": f"Demo-Abbildung {index + 1}",
"order": 1,
"storage_path": str(image_path),
}
]
def _generate_reports(self, validations: list[Validation]) -> None:
self.report_root.mkdir(parents=True, exist_ok=True)
ReportTemplateService(self.session).ensure_default_template()
for validation in validations:
OrionReportService(self.session, self.report_root).render_pdf(validation.id)

25
validation-suite/backend/mercury/app/services/domain_service.py
View file

@ -1,7 +1,6 @@
from __future__ import annotations
from typing import TypeVar
from uuid import UUID
from sqlalchemy.orm import Session
@ -12,7 +11,6 @@ from app.models.customer import Customer
from app.models.device import Device
from app.models.equipment import Equipment
from app.models.location import Location
from app.models.user import User, UserRole
from app.models.validation import Validation
from app.repositories.base import Repository
from app.repositories.domain import (
@ -21,7 +19,6 @@ from app.repositories.domain import (
DeviceRepository,
EquipmentRepository,
LocationRepository,
UserRepository,
ValidationRepository,
)
@ -36,43 +33,24 @@ class CrudService:
safe_page = max(page, 1)
safe_page_size = min(max(page_size, 1), 100)
offset = (safe_page - 1) * safe_page_size
total = self.repository.count(search)
return {
"items": self.repository.list(safe_page_size, offset, search),
"total": total,
"total": self.repository.count(search),
"page": safe_page,
"page_size": safe_page_size,
"pages": max((total + safe_page_size - 1) // safe_page_size, 1),
}
def create(self, data: dict) -> ModelT:
data = self._normalize(data)
return self.repository.add(self.repository.model(**data))
def update(self, item_id: str, data: dict) -> ModelT:
data = self._normalize(data)
item = self.repository.get(item_id)
if item is None:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Resource not found")
if isinstance(item, Validation) and item.status in {"FREIGEGEBEN", "ABGESCHLOSSEN"}:
raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail="Freigegebene oder abgeschlossene Validierungen sind schreibgeschuetzt")
for key, value in data.items():
setattr(item, key, value)
return item
def _normalize(self, data: dict) -> dict:
normalized = {}
for key, value in data.items():
if key.endswith("_id") and value == "":
normalized[key] = None
elif isinstance(value, UUID):
normalized[key] = str(value)
elif isinstance(value, list):
normalized[key] = [str(item) if isinstance(item, UUID) else item for item in value]
else:
normalized[key] = value
return normalized
def delete(self, item_id: str) -> None:
item = self.repository.get(item_id)
if item is None:
@ -82,7 +60,6 @@ class CrudService:
class DomainServices:
def __init__(self, session: Session) -> None:
self.users: CrudService[User] = CrudService(UserRepository(session))
self.customers: CrudService[Customer] = CrudService(CustomerRepository(session))
self.locations: CrudService[Location] = CrudService(LocationRepository(session))
self.contacts: CrudService[Contact] = CrudService(ContactRepository(session))

268
validation-suite/backend/mercury/app/services/quickstart_service.py
View file

@ -1,268 +0,0 @@
from __future__ import annotations
from copy import deepcopy
from datetime import date
from sqlalchemy import and_, func, select
from sqlalchemy.orm import Session
from app.models.contact import Contact
from app.models.customer import Customer
from app.models.device import Device
from app.models.equipment import Equipment, EquipmentKind
from app.models.location import Location
from app.models.user import User
from app.models.validation import Validation, ValidationStatus
from app.modules.orion.template_service import ReportTemplateService
from app.schemas.domain import QuickStartCreateRequest, QuickStartCustomerData, QuickStartValidationSummary
from app.services.validation_workflow import ValidationWorkflowService
class QuickStartService:
def __init__(self, session: Session) -> None:
self.session = session
def customer_data(self, customer_id: str) -> QuickStartCustomerData:
customer = self._customer(customer_id)
locations = list(
self.session.scalars(
select(Location).where(Location.customer_id == customer.id).order_by(Location.name.asc())
)
)
contacts = list(
self.session.scalars(
select(Contact).where(Contact.customer_id == customer.id).order_by(Contact.full_name.asc())
)
)
devices = list(
self.session.scalars(
select(Device).where(Device.customer_id == customer.id).order_by(Device.serial_number.asc())
)
)
validations = self._validation_summaries([device.id for device in devices])
return QuickStartCustomerData(
customer=customer,
locations=locations,
contacts=contacts,
devices=devices,
validations=validations,
)
def device_last_validation(self, device_id: str) -> QuickStartValidationSummary | None:
return self._last_validation(device_id)
def create_validation(self, payload: QuickStartCreateRequest, examiner: User) -> Validation:
customer = self._customer(str(payload.customer_id))
devices = list(
self.session.scalars(
select(Device).where(Device.customer_id == customer.id).order_by(Device.serial_number.asc())
)
)
device = self._device(str(payload.device_id)) if payload.device_id else self._single_or_default(devices)
if device is None:
raise ValueError("Kein Gerät verfügbar.")
if device.customer_id != customer.id:
raise ValueError("Gerät gehört nicht zum ausgewählten Kunden.")
locations = list(
self.session.scalars(
select(Location).where(Location.customer_id == customer.id).order_by(Location.name.asc())
)
)
contacts = list(
self.session.scalars(
select(Contact).where(Contact.customer_id == customer.id).order_by(Contact.full_name.asc())
)
)
location = self._location(str(payload.location_id)) if payload.location_id else self._single_or_default(locations)
contact = self._contact(str(payload.contact_id)) if payload.contact_id else self._single_or_default(contacts)
if location is None:
if locations:
raise ValueError("Bitte Standort auswählen.")
raise ValueError("Kein Standort verfügbar.")
if location.customer_id != customer.id:
raise ValueError("Standort gehört nicht zum ausgewählten Kunden.")
if device.location_id and device.location_id != location.id:
raise ValueError("Gerät gehört nicht zum gewählten Standort.")
if contact and contact.customer_id != customer.id:
raise ValueError("Ansprechpartner gehört nicht zum ausgewählten Kunden.")
base = self._base_validation(device.id, payload.validation_type)
bundle = ReportTemplateService(self.session).ensure_default_template()
validation = Validation(
report_number=self._next_report_number(),
customer_id=customer.id,
location_id=location.id,
contact_id=contact.id if contact else None,
device_id=device.id,
validation_type=payload.validation_type,
performed_on=date.today(),
examiner_name=examiner.full_name,
examiner_id=examiner.id,
operator_name=customer.quality_manager or customer.hygiene_officer or examiner.full_name,
status=ValidationStatus.draft.value,
result="offen",
revalidation_interval_months=base.revalidation_interval_months if base else 24,
next_validation_manually_overridden=False,
version=1 if base is None else base.version + 1,
previous_validation_id=base.id if base else None,
equipment_ids=list(base.equipment_ids) if base and base.equipment_ids else self._default_equipment_ids(),
environment_conditions=deepcopy(base.environment_conditions) if base else {},
documentation_checklist=deepcopy(base.documentation_checklist) if base else self._template_checklist(bundle, "documentation_checklist"),
performance_checklist=deepcopy(base.performance_checklist) if base else self._template_checklist(bundle, "performance_checklist"),
programs=deepcopy(base.programs) if base else self._default_programs(),
loading_patterns=deepcopy(base.loading_patterns) if base else self._default_loading_patterns(),
measurement_data=[],
drying={},
recommendations=deepcopy(base.recommendations) if base else [],
attachments=[],
)
self.session.add(validation)
self.session.flush()
ValidationWorkflowService(self.session).apply_revalidation_date(validation)
return validation
def _customer(self, customer_id: str) -> Customer:
customer = self.session.get(Customer, customer_id)
if customer is None:
raise ValueError("Kunde nicht gefunden.")
return customer
def _device(self, device_id: str) -> Device:
device = self.session.get(Device, device_id)
if device is None:
raise ValueError("Gerät nicht gefunden.")
return device
def _location(self, location_id: str) -> Location:
location = self.session.get(Location, location_id)
if location is None:
raise ValueError("Standort nicht gefunden.")
return location
def _contact(self, contact_id: str) -> Contact:
contact = self.session.get(Contact, contact_id)
if contact is None:
raise ValueError("Ansprechpartner nicht gefunden.")
return contact
def _single_or_default(self, items):
if len(items) == 1:
return items[0]
return None
def _last_validation(self, device_id: str) -> QuickStartValidationSummary | None:
validation = self.session.scalar(
select(Validation)
.where(
and_(
Validation.device_id == device_id,
Validation.status.in_([ValidationStatus.approved.value, ValidationStatus.completed.value]),
)
)
.order_by(Validation.performed_on.desc().nulls_last(), Validation.updated_at.desc())
)
if validation is None:
return None
return self._summary(validation)
def _validation_summaries(self, device_ids: list[str]) -> list[QuickStartValidationSummary]:
if not device_ids:
return []
validations = list(
self.session.scalars(
select(Validation)
.where(Validation.device_id.in_(device_ids))
.order_by(Validation.performed_on.desc().nulls_last(), Validation.updated_at.desc())
.limit(10)
)
)
return [self._summary(item) for item in validations]
def _summary(self, validation: Validation) -> QuickStartValidationSummary:
return QuickStartValidationSummary(
id=validation.id,
device_id=validation.device_id,
report_number=validation.report_number,
performed_on=validation.performed_on,
result=validation.result,
next_validation_on=validation.next_validation_on,
status=validation.status,
validation_type=validation.validation_type,
equipment_ids=list(validation.equipment_ids or []),
)
def _base_validation(self, device_id: str, validation_type: str) -> Validation | None:
if validation_type not in {"Revalidierung", "Leistungsbeurteilung"}:
return None
return self.session.scalar(
select(Validation)
.where(
and_(
Validation.device_id == device_id,
Validation.status.in_([ValidationStatus.approved.value, ValidationStatus.completed.value]),
)
)
.order_by(Validation.performed_on.desc().nulls_last(), Validation.updated_at.desc())
)
def _next_report_number(self) -> str:
total = self.session.scalar(select(func.count()).select_from(Validation)) or 0
return f"VAL-{total + 1:05d}"
def _default_equipment_ids(self) -> list[str]:
equipment = list(
self.session.scalars(
select(Equipment).where(Equipment.kind == EquipmentKind.temperature_logger).order_by(Equipment.serial_number.asc())
)
)
equipment.extend(
list(
self.session.scalars(
select(Equipment).where(Equipment.kind == EquipmentKind.pressure_logger).order_by(Equipment.serial_number.asc())
)
)
)
selected: list[str] = []
temp_count = 0
pressure_count = 0
for item in equipment:
if item.kind == EquipmentKind.temperature_logger and temp_count < 5:
selected.append(item.id)
temp_count += 1
elif item.kind == EquipmentKind.pressure_logger and pressure_count < 1:
selected.append(item.id)
pressure_count += 1
return selected
def _template_checklist(self, bundle, key: str) -> list[dict]:
checklist_key = {
"documentation_checklist": "documentation_control",
"performance_checklist": "sterilizer_description",
}.get(key, key)
template = next((item for item in bundle.checklists if item.checklist_key == checklist_key), None)
if template is None:
return []
return [
{
"template_key": template.checklist_key,
"template_title": template.title,
"text": item,
"value": "na",
"comment": "",
}
for item in template.items
]
def _default_programs(self) -> list[dict]:
return [
{"name": "Vakuumtest", "selected": True, "custom": False},
{"name": "Bowie-Dick / Leerkammerprofil", "selected": True, "custom": False},
{"name": "134 C hohl verpackt", "selected": True, "custom": False},
]
def _default_loading_patterns(self) -> list[dict]:
return [
{"run": 1, "pattern": "Standardbeladung", "description": "", "images": []},
{"run": 2, "pattern": "Standardbeladung", "description": "", "images": []},
{"run": 3, "pattern": "Standardbeladung", "description": "", "images": []},
]

380
validation-suite/backend/mercury/app/services/reference_masterdata.py
View file

@ -1,380 +0,0 @@
from __future__ import annotations
from dataclasses import dataclass, field
from datetime import date
from pathlib import Path
import re
from typing import Any
from sqlalchemy import select
from sqlalchemy.orm import Session
from app.models.contact import Contact
from app.models.customer import Customer, CustomerType
from app.models.device import Device
from app.models.equipment import Equipment, EquipmentKind, EquipmentStatus
from app.models.location import Location
from app.models.validation import Validation, ValidationStatus
@dataclass
class ImportResult:
created: list[str] = field(default_factory=list)
updated: list[str] = field(default_factory=list)
unchanged: list[str] = field(default_factory=list)
conflicts: list[str] = field(default_factory=list)
errors: list[str] = field(default_factory=list)
validation_id: str | None = None
def as_dict(self) -> dict[str, Any]:
return {
"created": self.created,
"updated": self.updated,
"unchanged": self.unchanged,
"conflicts": self.conflicts,
"errors": self.errors,
"validation_id": self.validation_id,
}
class ReferenceMasterdataImportService:
def __init__(self, session: Session) -> None:
self.session = session
def import_reference_docx(
self,
reference_path: Path,
*,
dry_run: bool = False,
update_existing: bool = False,
create_validation: bool = False,
) -> ImportResult:
if not reference_path.exists():
raise FileNotFoundError(reference_path)
result = ImportResult()
payload = self._payload()
customer = self._upsert_customer(payload["customer"], result, dry_run, update_existing)
location = self._upsert_location(customer, payload["location"], result, dry_run, update_existing)
self._upsert_contacts(customer, payload["contacts"], result, dry_run, update_existing)
device = self._upsert_device(customer, location, payload["device"], result, dry_run, update_existing)
self._upsert_equipment(payload["equipment"], result, dry_run, update_existing)
if create_validation:
validation = self._create_validation(customer, location, device, result, dry_run)
result.validation_id = validation.id if validation is not None else None
if not dry_run:
self.session.commit()
return result
def _payload(self) -> dict[str, Any]:
return {
"customer": {
"name": "Urologische Praxis Dr. Durmaz",
"customer_type": CustomerType.practice,
"specialty": "Urologie",
"display_name": "Urologie Dr. Durmaz",
},
"location": {
"name": "Praxis Nürnberg",
"street": "Wölckernstr. 5",
"postal_code": "90459",
"city": "Nürnberg",
"country": "Deutschland",
},
"contacts": [
{
"full_name": "Dr. Durmaz",
"function": "Verantwortlicher Betreiber",
"notes": "Arzt; QM-Mitverantwortlicher",
},
{
"full_name": "Frau Bal",
"function": "QM-Beauftragte",
"notes": "Hygienebeauftragte; Sachkunde A / Fachkenntnisse Aufbereitung und Freigabe von Medizinprodukten",
},
],
"device": {
"manufacturer": "Euronda SpA",
"model": "E10.7",
"device_type": "Dampf-Kleinsterilisator Klasse B",
"serial_number": "EXN250688",
"year_built": 2025,
"commissioned_on": date(2025, 12, 5),
"chamber_volume_liters": 23,
"steam_generation": "Eigendampferzeugung",
"water_treatment": "Wasserversorgung über Aquafilter Euronda",
"documentation": "interne CF-Card; Protokollausgabe am PC/Rechner möglich",
"supplier": "schubamed-Medizintechnik, 92421 Schwandorf",
"notes": "Sterilisationsverfahren: Konditionierung mit Wasserdampf; Konditionierung teilweise oberhalb und unterhalb des Umgebungsdruckes; Chargendokumentation über interne CF-Card.",
},
"equipment": [
{
"kind": EquipmentKind.temperature_logger,
"manufacturer": "Ebro",
"model": "EBI 11",
"serial_number": "15102807",
"calibrated_on": date(2025, 1, 17),
"status": EquipmentStatus.green,
"notes": "Bezeichnung T235; Messbereich 0 °C bis +150 °C",
},
{
"kind": EquipmentKind.temperature_logger,
"manufacturer": "Ebro",
"model": "EBI 11",
"serial_number": "15211066",
"calibrated_on": date(2025, 1, 17),
"status": EquipmentStatus.green,
"notes": "Bezeichnung T240; Messbereich 0 °C bis +150 °C",
},
{
"kind": EquipmentKind.temperature_logger,
"manufacturer": "Ebro",
"model": "EBI 11",
"serial_number": "15102538",
"calibrated_on": date(2025, 1, 17),
"status": EquipmentStatus.green,
"notes": "Bezeichnung T240; Messbereich 0 °C bis +150 °C",
},
{
"kind": EquipmentKind.temperature_logger,
"manufacturer": "Ebro",
"model": "EBI 11",
"serial_number": "15211067",
"calibrated_on": date(2025, 1, 17),
"status": EquipmentStatus.green,
"notes": "Bezeichnung T240; Messbereich 0 °C bis +150 °C",
},
{
"kind": EquipmentKind.temperature_logger,
"manufacturer": "Ebro",
"model": "EBI 11",
"serial_number": "15125738",
"calibrated_on": date(2025, 1, 17),
"status": EquipmentStatus.green,
"notes": "Bezeichnung T240; Quellenkonflikt: Referenz nennt auch 1525738, mehrfach belegt ist 15125738.",
},
{
"kind": EquipmentKind.pressure_logger,
"manufacturer": "Ebro",
"model": "EBI 11",
"serial_number": "P111",
"calibrated_on": date(2025, 1, 17),
"status": EquipmentStatus.green,
"notes": "Drucklogger",
},
],
}
def _normalize(self, value: str) -> str:
return re.sub(r"[^a-z0-9]+", "", value.lower())
def _upsert_customer(self, payload: dict[str, Any], result: ImportResult, dry_run: bool, update_existing: bool) -> Customer:
target_name = self._normalize(payload["name"])
customer = next(
(item for item in self.session.scalars(select(Customer)) if self._normalize(item.name) == target_name),
None,
)
if customer is None:
customer = Customer(customer_type=payload["customer_type"], name=payload["name"])
customer.notes = f"Fachrichtung: {payload['specialty']}\nAnzeigename: {payload['display_name']}"
if not dry_run:
self.session.add(customer)
self.session.flush()
result.created.append("customer")
return customer
if update_existing:
changed = False
if customer.notes != f"Fachrichtung: {payload['specialty']}\nAnzeigename: {payload['display_name']}":
customer.notes = f"Fachrichtung: {payload['specialty']}\nAnzeigename: {payload['display_name']}"
changed = True
if customer.customer_type != payload["customer_type"]:
customer.customer_type = payload["customer_type"]
changed = True
if changed:
result.updated.append("customer")
else:
result.unchanged.append("customer")
else:
result.unchanged.append("customer")
return customer
def _upsert_location(self, customer: Customer, payload: dict[str, Any], result: ImportResult, dry_run: bool, update_existing: bool) -> Location:
location = next(
(
item
for item in self.session.scalars(select(Location).where(Location.customer_id == customer.id))
if item.street == payload["street"]
and item.postal_code == payload["postal_code"]
and item.city == payload["city"]
),
None,
)
if location is None:
location = Location(
customer_id=customer.id,
name=payload["name"],
street=payload["street"],
postal_code=payload["postal_code"],
city=payload["city"],
)
if not dry_run:
self.session.add(location)
self.session.flush()
result.created.append("location")
return location
if update_existing:
location.name = payload["name"]
result.updated.append("location")
else:
result.unchanged.append("location")
return location
def _upsert_contacts(
self,
customer: Customer,
contacts: list[dict[str, Any]],
result: ImportResult,
dry_run: bool,
update_existing: bool,
) -> None:
for payload in contacts:
contact = self.session.scalar(
select(Contact).where(
Contact.customer_id == customer.id,
Contact.full_name == payload["full_name"],
)
)
notes = payload["notes"]
if contact is None:
contact = Contact(
customer_id=customer.id,
full_name=payload["full_name"],
function=payload["function"],
notes=notes,
)
if not dry_run:
self.session.add(contact)
self.session.flush()
result.created.append(f"contact:{payload['full_name']}")
continue
if update_existing:
contact.function = payload["function"]
contact.notes = notes
result.updated.append(f"contact:{payload['full_name']}")
else:
result.unchanged.append(f"contact:{payload['full_name']}")
def _upsert_device(
self,
customer: Customer,
location: Location,
payload: dict[str, Any],
result: ImportResult,
dry_run: bool,
update_existing: bool,
) -> Device:
device = self.session.scalar(select(Device).where(Device.serial_number == payload["serial_number"]))
if device is None:
device = Device(
customer_id=customer.id,
location_id=location.id,
manufacturer=payload["manufacturer"],
model=payload["model"],
device_type=payload["device_type"],
serial_number=payload["serial_number"],
year_built=payload["year_built"],
commissioned_on=payload["commissioned_on"],
chamber_volume_liters=payload["chamber_volume_liters"],
steam_generation=payload["steam_generation"],
water_treatment=payload["water_treatment"],
documentation=payload["documentation"],
supplier=payload["supplier"],
notes=payload["notes"],
)
if not dry_run:
self.session.add(device)
self.session.flush()
result.created.append("device")
return device
if update_existing:
for key, value in payload.items():
if hasattr(device, key):
setattr(device, key, value)
result.updated.append("device")
else:
result.unchanged.append("device")
return device
def _upsert_equipment(
self,
items: list[dict[str, Any]],
result: ImportResult,
dry_run: bool,
update_existing: bool,
) -> None:
for payload in items:
equipment = self.session.scalar(
select(Equipment).where(Equipment.serial_number == payload["serial_number"])
)
if equipment is None:
equipment = Equipment(
kind=payload["kind"],
manufacturer=payload["manufacturer"],
model=payload["model"],
serial_number=payload["serial_number"],
calibrated_on=payload["calibrated_on"],
status=payload["status"],
notes=payload["notes"],
)
if not dry_run:
self.session.add(equipment)
self.session.flush()
result.created.append(f"equipment:{payload['serial_number']}")
continue
if update_existing:
equipment.kind = payload["kind"]
equipment.manufacturer = payload["manufacturer"]
equipment.model = payload["model"]
equipment.calibrated_on = payload["calibrated_on"]
equipment.status = payload["status"]
equipment.notes = payload["notes"]
result.updated.append(f"equipment:{payload['serial_number']}")
else:
result.unchanged.append(f"equipment:{payload['serial_number']}")
def _create_validation(
self,
customer: Customer,
location: Location,
device: Device,
result: ImportResult,
dry_run: bool,
) -> Validation | None:
existing = self.session.scalar(
select(Validation).where(
Validation.customer_id == customer.id,
Validation.device_id == device.id,
Validation.validation_type == "Erstvalidierung",
)
)
if existing is not None:
result.unchanged.append("validation")
return existing
validation = Validation(
report_number="REF-IMPORT-1",
customer_id=customer.id,
location_id=location.id,
device_id=device.id,
validation_type="Erstvalidierung",
status=ValidationStatus.draft.value,
examiner_name="nicht erfasst",
)
if not dry_run:
self.session.add(validation)
self.session.flush()
result.created.append("validation")
return validation

77
validation-suite/backend/mercury/app/services/report_settings.py
View file

@ -1,77 +0,0 @@
from __future__ import annotations
from sqlalchemy import select
from sqlalchemy.orm import Session
from app.models.report_settings import (
OrionImagePosition,
OrionImageSize,
OrionLayoutProfile,
OrionLogoSize,
OrionPageMargin,
OrionReportSettings,
OrionReportSettingsScope,
OrionSignatureMode,
OrionSpacing,
OrionTableFontSize,
)
from app.models.user import User
from app.schemas.domain import OrionReportSettingsUpdate
class OrionReportSettingsService:
def __init__(self, session: Session) -> None:
self.session = session
def get_global(self) -> OrionReportSettings:
settings = self.session.scalar(
select(OrionReportSettings).where(
OrionReportSettings.scope == OrionReportSettingsScope.global_.value
)
)
if settings is not None:
return settings
settings = OrionReportSettings(
scope=OrionReportSettingsScope.global_.value,
layout_profile=OrionLayoutProfile.standard.value,
show_cover_result_text=True,
signature_mode=OrionSignatureMode.technical_only.value,
image_size=OrionImageSize.medium.value,
page_break_before_main_chapters=True,
page_margin=OrionPageMargin.standard.value,
section_spacing=OrionSpacing.standard.value,
table_layout=OrionSpacing.standard.value,
table_font_size=OrionTableFontSize.standard.value,
image_position=OrionImagePosition.side_by_side.value,
max_images_per_page=2,
show_image_captions=True,
show_header=True,
show_footer=True,
logo_size=OrionLogoSize.medium.value,
compact_cover=False,
)
self.session.add(settings)
self.session.flush()
return settings
def update_global(self, payload: OrionReportSettingsUpdate, user: User) -> OrionReportSettings:
settings = self.get_global()
settings.layout_profile = payload.layout_profile.value
settings.show_cover_result_text = payload.show_cover_result_text
settings.signature_mode = payload.signature_mode.value
settings.image_size = payload.image_size.value
settings.page_break_before_main_chapters = payload.page_break_before_main_chapters
settings.page_margin = payload.page_margin.value
settings.section_spacing = payload.section_spacing.value
settings.table_layout = payload.table_layout.value
settings.table_font_size = payload.table_font_size.value
settings.image_position = payload.image_position.value
settings.max_images_per_page = payload.max_images_per_page
settings.show_image_captions = payload.show_image_captions
settings.show_header = payload.show_header
settings.show_footer = payload.show_footer
settings.logo_size = payload.logo_size.value
settings.compact_cover = payload.compact_cover
settings.updated_by_user_id = user.id
self.session.flush()
return settings

364
validation-suite/backend/mercury/app/services/validation_workflow.py
View file

@ -1,364 +0,0 @@
from __future__ import annotations
import csv
import io
from dataclasses import dataclass
from datetime import date, datetime
from uuid import uuid4
from dateutil.relativedelta import relativedelta
from sqlalchemy import and_, func, or_, select
from sqlalchemy.orm import Session
from app.models.contact import Contact
from app.models.customer import Customer
from app.models.device import Device
from app.models.equipment import Equipment
from app.models.location import Location
from app.models.validation import Validation, ValidationStatus
REQUIRED_FIELDS = {
"report_number": ("Allgemeine Angaben", "Berichtsnummer"),
"validation_type": ("Allgemeine Angaben", "Validierungsart"),
"performed_on": ("Allgemeine Angaben", "Pruefdatum"),
"customer_id": ("Kunde und Standort", "Kunde"),
"location_id": ("Kunde und Standort", "Standort"),
"device_id": ("Geraet", "Geraet"),
"examiner_name": ("Allgemeine Angaben", "Pruefer"),
}
@dataclass(frozen=True)
class ReviewIssue:
field: str
message: str
section: str
def as_dict(self) -> dict[str, str]:
return {"field": self.field, "message": self.message, "section": self.section}
class ValidationWorkflowService:
def __init__(self, session: Session) -> None:
self.session = session
def review(self, validation: Validation) -> dict:
errors = self._required_errors(validation) + self._reference_errors(validation)
warnings = self._warnings(validation)
complete_sections = self._complete_sections(validation, errors, warnings)
return {
"status": validation.status,
"errors": [issue.as_dict() for issue in errors],
"warnings": [issue.as_dict() for issue in warnings],
"complete_sections": complete_sections,
}
def mark_ready_for_review(self, validation: Validation) -> dict:
review = self.review(validation)
validation.status = (
ValidationStatus.ready_for_review.value
if not review["errors"]
else ValidationStatus.draft.value
)
self.session.flush()
review["status"] = validation.status
return review
def apply_revalidation_date(self, validation: Validation) -> None:
if validation.performed_on and not validation.next_validation_manually_overridden:
validation.next_validation_on = validation.performed_on + relativedelta(
months=validation.revalidation_interval_months or 24
)
def duplicate(self, validation: Validation) -> Validation:
clone = Validation(
report_number=f"{validation.report_number}-KOPIE-{str(uuid4())[:8]}",
customer_id=validation.customer_id,
location_id=validation.location_id,
contact_id=validation.contact_id,
device_id=validation.device_id,
validation_type=validation.validation_type,
project=validation.project,
test_location=validation.test_location,
examiner_name=validation.examiner_name,
participants=validation.participants,
operator_name=validation.operator_name,
scheduled_on=validation.scheduled_on,
performed_on=validation.performed_on,
next_validation_on=validation.next_validation_on,
revalidation_interval_months=validation.revalidation_interval_months,
next_validation_manually_overridden=validation.next_validation_manually_overridden,
version=validation.version + 1,
previous_validation_id=validation.id,
examiner_id=validation.examiner_id,
status=ValidationStatus.draft.value,
result=validation.result,
notes=validation.notes,
equipment_ids=validation.equipment_ids,
environment_conditions=validation.environment_conditions,
documentation_checklist=validation.documentation_checklist,
performance_checklist=validation.performance_checklist,
programs=validation.programs,
loading_patterns=validation.loading_patterns,
measurement_data=validation.measurement_data,
drying=validation.drying,
recommendations=validation.recommendations,
attachments=validation.attachments,
)
self.session.add(clone)
self.session.flush()
return clone
def create_new_version(self, validation: Validation) -> Validation:
clone = self.duplicate(validation)
clone.report_number = f"{validation.report_number}-V{clone.version}"
return clone
def export_json(self, validation: Validation) -> dict:
return {
column.name: getattr(validation, column.name)
for column in Validation.__table__.columns
if column.name not in {"created_at", "updated_at"}
}
def preview_csv(self, content: bytes) -> dict:
rows = []
reader = csv.DictReader(io.StringIO(content.decode("utf-8-sig")))
for index, row in enumerate(reader, start=2):
rows.append(self._preview_import_row(index, row))
return {
"rows": rows,
"valid_rows": sum(1 for row in rows if not row["errors"]),
"invalid_rows": sum(1 for row in rows if row["errors"]),
"duplicates": sum(1 for row in rows if row["duplicate"]),
}
def import_rows(self, rows: list[dict], duplicate_strategy: str) -> dict:
summary = {"successful": 0, "skipped": 0, "failed": 0, "errors": []}
for index, row in enumerate(rows, start=1):
preview = self._preview_import_row(index, row)
if preview["errors"]:
summary["failed"] += 1
summary["errors"].append(f"Zeile {index}: {', '.join(preview['errors'])}")
continue
existing = self.session.scalar(
select(Validation).where(Validation.report_number == row.get("report_number"))
)
if existing and duplicate_strategy == "skip":
summary["skipped"] += 1
continue
target = existing if existing and duplicate_strategy == "update" else Validation()
target.report_number = (
f"{row.get('report_number')}-IMPORT-{str(uuid4())[:8]}"
if existing and duplicate_strategy == "copy"
else row.get("report_number")
)
target.validation_type = row.get("validation_type")
target.performed_on = self._parse_date(row.get("test_date") or row.get("performed_on"))
target.customer_id = preview["resolved_customer_id"]
target.location_id = preview["resolved_location_id"]
target.contact_id = row.get("contact_id")
target.device_id = preview["resolved_device_id"]
target.examiner_name = row.get("examiner") or row.get("examiner_name")
target.project = row.get("project")
target.test_location = row.get("test_location")
target.participants = row.get("participants")
target.operator_name = row.get("operator_name")
target.next_validation_on = self._parse_date(row.get("next_validation_on"))
target.equipment_ids = row.get("equipment_ids") or []
target.environment_conditions = row.get("environment_conditions") or {}
target.documentation_checklist = row.get("documentation_checklist") or []
target.performance_checklist = row.get("performance_checklist") or []
target.programs = row.get("programs") or []
target.loading_patterns = row.get("loading_patterns") or []
target.measurement_data = row.get("measurement_data") or []
target.drying = row.get("drying") or {}
target.recommendations = row.get("recommendations") or []
target.attachments = row.get("attachments") or []
target.status = row.get("status") or ValidationStatus.draft.value
target.result = row.get("result")
target.notes = row.get("notes")
if target.id is None:
self.session.add(target)
summary["successful"] += 1
self.session.flush()
return summary
def query_validations(
self,
search: str | None,
page: int,
page_size: int,
sort_by: str,
sort_order: str,
filters: dict,
) -> dict:
statement = select(Validation)
count_statement = select(Validation)
conditions = []
if search:
term = f"%{search}%"
conditions.append(
or_(
Validation.report_number.ilike(term),
Validation.validation_type.ilike(term),
Validation.examiner_name.ilike(term),
Validation.result.ilike(term),
)
)
for key in ["status", "customer_id", "device_id", "validation_type"]:
if filters.get(key):
conditions.append(getattr(Validation, key) == filters[key])
if filters.get("result"):
result_aliases = {
"OFFEN": ["OFFEN", "offen", ""],
"BESTANDEN": ["BESTANDEN", "bestanden"],
"BESTANDEN_MIT_AUFLAGEN": ["BESTANDEN_MIT_AUFLAGEN", "bestanden_mit_auflagen", "mit_auflagen", "bestanden mit Auflagen"],
"NICHT_BESTANDEN": ["NICHT_BESTANDEN", "nicht_bestanden", "nicht bestanden"],
}
result_values = result_aliases.get(filters["result"], [filters["result"]])
if filters["result"] == "OFFEN":
conditions.append(or_(Validation.result.in_(result_values), Validation.result.is_(None)))
else:
conditions.append(Validation.result.in_(result_values))
if filters.get("date_from"):
conditions.append(Validation.performed_on >= filters["date_from"])
if filters.get("date_to"):
conditions.append(Validation.performed_on <= filters["date_to"])
if filters.get("overdue_only"):
conditions.append(Validation.next_validation_on < date.today())
conditions.append(Validation.status != ValidationStatus.cancelled.value)
if conditions:
statement = statement.where(and_(*conditions))
count_statement = count_statement.where(and_(*conditions))
sort_column = getattr(Validation, sort_by, Validation.updated_at)
if sort_order == "asc":
statement = statement.order_by(sort_column.asc())
else:
statement = statement.order_by(sort_column.desc())
total = self.session.scalar(
select(func.count()).select_from(count_statement.order_by(None).subquery())
) or 0
items = list(self.session.scalars(statement.offset((page - 1) * page_size).limit(page_size)))
return {
"items": items,
"total": total,
"page": page,
"page_size": page_size,
"pages": max((total + page_size - 1) // page_size, 1),
}
def revalidation_status(self, validation: Validation) -> str:
if not validation.next_validation_on:
return "nicht_erfasst"
delta = (validation.next_validation_on - date.today()).days
if delta < 0:
return "ueberfaellig"
if delta <= 30:
return "faellig_30"
if delta <= 90:
return "faellig_90"
return "faellig_spaeter"
def _required_errors(self, validation: Validation) -> list[ReviewIssue]:
issues = []
for field, (section, label) in REQUIRED_FIELDS.items():
if not getattr(validation, field):
issues.append(ReviewIssue(field, f"{label} fehlt.", section))
return issues
def _reference_errors(self, validation: Validation) -> list[ReviewIssue]:
issues = []
customer = self.session.get(Customer, validation.customer_id) if validation.customer_id else None
location = self.session.get(Location, validation.location_id) if validation.location_id else None
device = self.session.get(Device, validation.device_id) if validation.device_id else None
if validation.customer_id and customer is None:
issues.append(ReviewIssue("customer_id", "Kunde existiert nicht.", "Kunde und Standort"))
if validation.location_id and location is None:
issues.append(ReviewIssue("location_id", "Standort existiert nicht.", "Kunde und Standort"))
if validation.device_id and device is None:
issues.append(ReviewIssue("device_id", "Geraet existiert nicht.", "Geraet"))
if location and device and device.location_id != location.id:
issues.append(ReviewIssue("device_id", "Geraet gehoert nicht zum gewaehlten Standort.", "Geraet"))
return issues
def _warnings(self, validation: Validation) -> list[ReviewIssue]:
warnings = []
equipment = []
if validation.equipment_ids:
equipment = list(self.session.scalars(select(Equipment).where(Equipment.id.in_(validation.equipment_ids))))
if not validation.equipment_ids:
warnings.append(ReviewIssue("equipment_ids", "Keine Pruefmittel ausgewaehlt.", "Pruefmittel"))
for item in equipment:
if item.calibration_due_on and item.calibration_due_on < date.today():
warnings.append(ReviewIssue("equipment_ids", f"Pruefmittel {item.serial_number} ist abgelaufen.", "Pruefmittel"))
if not any(item.get("selected") for item in validation.programs or []):
warnings.append(ReviewIssue("programs", "Keine Programme ausgewaehlt.", "Programme"))
if not validation.measurement_data:
warnings.append(ReviewIssue("measurement_data", "Keine Messdaten vorhanden.", "Messdaten"))
if not validation.attachments:
warnings.append(ReviewIssue("attachments", "Keine Bilder oder Anlagen vorhanden.", "Bilder und Anlagen"))
if not validation.recommendations:
warnings.append(ReviewIssue("recommendations", "Keine Empfehlungen oder Auflagen erfasst.", "Empfehlungen"))
winlog_imported = any(item.get("imports") for item in validation.measurement_data or [])
if not winlog_imported:
warnings.append(ReviewIssue("measurement_data", "Winlog-Datei noch nicht importiert.", "Messdaten"))
return warnings
def _complete_sections(
self, validation: Validation, errors: list[ReviewIssue], warnings: list[ReviewIssue]
) -> list[str]:
blocked = {issue.section for issue in [*errors, *warnings]}
sections = [
"Allgemeine Angaben",
"Kunde und Standort",
"Geraet",
"Pruefmittel",
"Programme",
"Messdaten",
"Bilder und Anlagen",
"Empfehlungen",
]
return [section for section in sections if section not in blocked]
def _preview_import_row(self, row_number: int, row: dict) -> dict:
errors = []
customer = self.session.get(Customer, row.get("customer_id")) if row.get("customer_id") else self.session.scalar(select(Customer).where(Customer.name == row.get("customer_reference")))
location = self.session.get(Location, row.get("location_id")) if row.get("location_id") else self.session.scalar(select(Location).where(Location.name == row.get("location_reference")))
device = self.session.get(Device, row.get("device_id")) if row.get("device_id") else self.session.scalar(select(Device).where(Device.serial_number == row.get("device_serial_number")))
duplicate = bool(
row.get("report_number")
and self.session.scalar(select(Validation).where(Validation.report_number == row.get("report_number")))
)
required = [
("report_number", row.get("report_number")),
("validation_type", row.get("validation_type")),
("test_date", row.get("test_date") or row.get("performed_on")),
("customer_reference", row.get("customer_reference") or row.get("customer_id")),
("location_reference", row.get("location_reference") or row.get("location_id")),
("device_serial_number", row.get("device_serial_number") or row.get("device_id")),
("examiner", row.get("examiner") or row.get("examiner_name")),
]
for field, value in required:
if not value:
errors.append(f"{field} fehlt")
if row.get("customer_reference") and not customer:
errors.append("Kunde nicht gefunden")
if row.get("location_reference") and not location:
errors.append("Standort nicht gefunden")
if row.get("device_serial_number") and not device:
errors.append("Geraet nicht gefunden")
return {
"row_number": row_number,
"data": row,
"errors": errors,
"duplicate": duplicate,
"resolved_customer_id": customer.id if customer else None,
"resolved_location_id": location.id if location else None,
"resolved_device_id": device.id if device else None,
}
def _parse_date(self, value: str | None) -> date | None:
if not value:
return None
return datetime.strptime(value, "%Y-%m-%d").date()

Some files were not shown because too many files have changed in this diff Show more