Warne vor bereits eingefügten Quelldokumenten und biete Nicht einfügen, erneut einfügen oder zusätzliches Einbinden an.
Deploy Development / deploy (push) Successful in 44s
Deploy Development / deploy (push) Successful in 44s
Prüfstufen hier, darin, Umfeld stehen als Kontoeinstellung bereit. Der Server antwortet bei einem sicheren Treffer mit 409 und bindet auf Wunsch das vorhandene Element zusätzlich ein. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
a6dc24d8fe
commit
f925661937
19 files changed
+748
-133
No files matched your search
@@ -0,0 +1,52 @@
|
||||
"""Placing a source document into a container: a new reference, or one more binding of an existing element."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from fastapi import APIRouter, Depends
|
||||
from fastapi.responses import JSONResponse
|
||||
from psycopg import Connection
|
||||
|
||||
from app.access.policy import Ctx
|
||||
from app.api.deps import Principal, get_conn, get_principal
|
||||
from app.api.schemas import ExistingIn, ExternalIn
|
||||
from app.ops import bind_existing_external, create_external, existing_externals
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
|
||||
def _ctx_model(value) -> Ctx | None:
|
||||
return None if value is None else Ctx(value.kind, value.id)
|
||||
|
||||
|
||||
def place_external(conn, principal: Principal, body: ExternalIn) -> dict:
|
||||
context = Ctx(body.context.kind, body.context.id)
|
||||
placement = _ctx_model(body.placement)
|
||||
if body.bind_element_id is not None:
|
||||
return bind_existing_external(conn, principal.account_id, principal.scope_id, body.bind_element_id, context, placement, body.chapter_id)
|
||||
return create_external(
|
||||
conn,
|
||||
principal.account_id,
|
||||
principal.scope_id,
|
||||
body.title,
|
||||
body.source,
|
||||
body.external_id,
|
||||
context,
|
||||
placement,
|
||||
body.chapter_id,
|
||||
body.dates.document_on,
|
||||
body.dates.sent_on,
|
||||
body.dates.received_on,
|
||||
body.detail.model_dump(mode="json", exclude_none=True) if body.detail else None,
|
||||
duplicate=body.duplicate,
|
||||
)
|
||||
|
||||
|
||||
@router.post("/api/v1/external-refs/existing")
|
||||
def existing(body: ExistingIn, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
|
||||
"""Read only: which of these documents are already present around the target. Nothing is written."""
|
||||
items = [
|
||||
{"source": item.source, "external_id": item.external_id, "connector_id": str(item.connector_id) if item.connector_id else None}
|
||||
for item in body.items
|
||||
]
|
||||
result = existing_externals(conn, principal.account_id, Ctx(body.context.kind, body.context.id), _ctx_model(body.placement), items)
|
||||
return JSONResponse(result, headers={"Cache-Control": "no-store"})
|
||||
@@ -34,6 +34,7 @@ from app.access.policy import (
|
||||
)
|
||||
from app.access.limits import ensure_can_add_member
|
||||
from app.api.deps import Principal, get_conn, get_principal, get_session
|
||||
from app.api.externals import place_external
|
||||
from app.api.schemas import (
|
||||
AcceptInviteIn,
|
||||
AnnotationIn,
|
||||
@@ -113,7 +114,6 @@ from app.ops import (
|
||||
create_chapter,
|
||||
create_cross_link,
|
||||
create_deadline,
|
||||
create_external,
|
||||
create_file,
|
||||
create_matter,
|
||||
create_note,
|
||||
@@ -860,21 +860,7 @@ def post_annotation(
|
||||
|
||||
@router.post("/api/v1/external-refs")
|
||||
def post_external(body: ExternalIn, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
|
||||
element = create_external(
|
||||
conn,
|
||||
principal.account_id,
|
||||
principal.scope_id,
|
||||
body.title,
|
||||
body.source,
|
||||
body.external_id,
|
||||
Ctx(body.context.kind, body.context.id),
|
||||
_ctx_model(body.placement),
|
||||
body.chapter_id,
|
||||
body.dates.document_on,
|
||||
body.dates.sent_on,
|
||||
body.dates.received_on,
|
||||
body.detail.model_dump(mode="json", exclude_none=True) if body.detail else None,
|
||||
)
|
||||
element = place_external(conn, principal, body)
|
||||
return _created(f"/api/v1/elements/{element['id']}", {"id": str(element["id"]), "title": element["title"]})
|
||||
|
||||
|
||||
|
||||
@@ -352,6 +352,22 @@ class ExternalIn(APIModel):
|
||||
chapter_id: UUID | None = None
|
||||
dates: DatesIn = DatesIn()
|
||||
detail: ExternalDetail | None = None
|
||||
# "ask": a document that is already present at the account's check level answers 409.
|
||||
# "insert": the user chose to insert it again. `bind_element_id` binds that element instead of creating one.
|
||||
duplicate: Literal["ask", "insert"] = "ask"
|
||||
bind_element_id: UUID | None = None
|
||||
|
||||
|
||||
class ExistingItemIn(APIModel):
|
||||
source: str = Field(min_length=1, max_length=40)
|
||||
external_id: str = Field(min_length=1, max_length=200)
|
||||
connector_id: UUID | None = None
|
||||
|
||||
|
||||
class ExistingIn(APIModel):
|
||||
context: ContextIn
|
||||
placement: ContextIn | None = None
|
||||
items: list[ExistingItemIn] = Field(min_length=1, max_length=100)
|
||||
|
||||
|
||||
class ConnectorIn(APIModel):
|
||||
|
||||
@@ -8,15 +8,15 @@ from fastapi import APIRouter, Depends, Request
|
||||
from fastapi.responses import JSONResponse, Response
|
||||
from psycopg import Connection
|
||||
|
||||
from app.access.policy import Ctx, element_rights, get_element, parse_query_context
|
||||
from app.access.policy import element_rights, get_element, parse_query_context
|
||||
from app.api.deps import Principal, get_conn, get_principal
|
||||
from app.api.routes import _created, _ctx_model
|
||||
from app.api.routes import _created
|
||||
from app.api.schemas import ConnectorIn, ExternalIn, SourceAssignmentIn
|
||||
from app.core.errors import DOWNLOAD_REFUSED, forbidden, not_found, unprocessable, unsupported
|
||||
from app.mailpack import _inline_images, parse_mail, sanitize_html
|
||||
from app.remoteimages import RemoteImages
|
||||
from app.media.storage import content_disposition
|
||||
from app.ops import create_external
|
||||
from app.api.externals import place_external
|
||||
from app.retrieval import RetrievalFailure
|
||||
from app.sourcebind import assign_reference
|
||||
from app.sourceport import capability_payload, with_capabilities
|
||||
@@ -370,21 +370,7 @@ def read_mail(
|
||||
def link_source(body: ExternalIn, principal: Principal = Depends(get_principal), conn: Connection = Depends(get_conn)):
|
||||
if get_source(body.source) is None:
|
||||
raise unprocessable("Verknüpft werden registrierte Quellen.")
|
||||
element = create_external(
|
||||
conn,
|
||||
principal.account_id,
|
||||
principal.scope_id,
|
||||
body.title,
|
||||
body.source,
|
||||
body.external_id,
|
||||
Ctx(body.context.kind, body.context.id),
|
||||
_ctx_model(body.placement),
|
||||
body.chapter_id,
|
||||
body.dates.document_on,
|
||||
body.dates.sent_on,
|
||||
body.dates.received_on,
|
||||
body.detail.model_dump(mode="json", exclude_none=True) if body.detail else None,
|
||||
)
|
||||
element = place_external(conn, principal, body)
|
||||
return _created(f"/api/v1/elements/{element['id']}", {"id": str(element["id"]), "title": element["title"]})
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,166 @@
|
||||
"""Documents of a source that are inserted into a container again.
|
||||
|
||||
The same document in different Vorgänge stays allowed. This module only finds where a document is
|
||||
already present around the target, so the dialog can warn and the user can decide. Levels (account
|
||||
preference `duplicate_check`):
|
||||
|
||||
- here: bound directly to the target.
|
||||
- inside: also what the target shows: Teilvorgänge of a Vorgang, the linked Vorgänge of an Akte.
|
||||
- around: also where the target lies: its Vorgang, the Akten it is linked to, the parent Akte.
|
||||
|
||||
Only elements the actor may read are reported. A hit outside the actor's rights does not exist here.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from uuid import UUID
|
||||
|
||||
from app.access.policy import (
|
||||
Ctx,
|
||||
case_rights,
|
||||
element_rights,
|
||||
get_case,
|
||||
get_matter,
|
||||
matter_rights,
|
||||
)
|
||||
from app.core.errors import Problem
|
||||
|
||||
LEVELS = {"off": (), "here": ("here",), "inside": ("here", "inside"), "around": ("here", "inside", "around")}
|
||||
_ORDER = {"here": 0, "inside": 1, "around": 2}
|
||||
|
||||
|
||||
def _stored_connector(row: dict) -> str | None:
|
||||
if row["connector_id"] is not None:
|
||||
return str(row["connector_id"])
|
||||
stored = (row["detail"] or {}).get("connector_id")
|
||||
return str(stored) if stored else None
|
||||
|
||||
|
||||
def _candidates(conn, source: str, external_id: str, connector_id: str | None) -> list[dict]:
|
||||
"""Elements for the same document. `certain` is False when only one side knows the connection."""
|
||||
rows = conn.execute(
|
||||
"""
|
||||
SELECT e.id, e.title, e.owner_subject_id, er.connector_id, er.detail
|
||||
FROM external_references er
|
||||
JOIN elements e ON e.id = er.element_id
|
||||
WHERE er.source = %s AND er.external_id = %s AND e.deleted_at IS NULL
|
||||
""",
|
||||
(source, external_id.strip()[:200]),
|
||||
).fetchall()
|
||||
found = []
|
||||
for row in rows:
|
||||
stored = _stored_connector(row)
|
||||
if stored is not None and connector_id is not None and stored != connector_id:
|
||||
continue
|
||||
found.append(row | {"certain": stored == connector_id})
|
||||
return found
|
||||
|
||||
|
||||
def _children(conn, matter_id: UUID) -> list[UUID]:
|
||||
rows = conn.execute("SELECT id FROM matters WHERE parent_matter_id = %s AND deleted_at IS NULL", (matter_id,)).fetchall()
|
||||
return [row["id"] for row in rows]
|
||||
|
||||
|
||||
def _zones(conn, target: Ctx) -> dict[str, list[Ctx]]:
|
||||
inside: list[Ctx] = []
|
||||
around: list[Ctx] = []
|
||||
if target.kind == "matter":
|
||||
inside = [Ctx("matter", child) for child in _children(conn, target.id)]
|
||||
matter = get_matter(conn, target.id)
|
||||
anchors = [target.id]
|
||||
if matter is not None and matter["parent_matter_id"] is not None:
|
||||
around.append(Ctx("matter", matter["parent_matter_id"]))
|
||||
anchors.append(matter["parent_matter_id"])
|
||||
links = conn.execute("SELECT DISTINCT case_id FROM matter_case_links WHERE matter_id = ANY(%s)", (anchors,)).fetchall()
|
||||
around += [Ctx("case", row["case_id"]) for row in links]
|
||||
else:
|
||||
links = conn.execute("SELECT matter_id FROM matter_case_links WHERE case_id = %s", (target.id,)).fetchall()
|
||||
for row in links:
|
||||
inside.append(Ctx("matter", row["matter_id"]))
|
||||
inside += [Ctx("matter", child) for child in _children(conn, row["matter_id"])]
|
||||
case = get_case(conn, target.id)
|
||||
if case is not None and case["parent_case_id"] is not None:
|
||||
around.append(Ctx("case", case["parent_case_id"]))
|
||||
return {"here": [target], "inside": inside, "around": around}
|
||||
|
||||
|
||||
def _blocked(conn, case_id: UUID, element_id: UUID) -> bool:
|
||||
row = conn.execute(
|
||||
"""
|
||||
SELECT 1 FROM case_link_blocks b JOIN matter_case_links l ON l.id = b.link_id
|
||||
WHERE l.case_id = %s AND b.element_id = %s
|
||||
""",
|
||||
(case_id, element_id),
|
||||
).fetchone()
|
||||
return row is not None
|
||||
|
||||
|
||||
def _title_if_readable(conn, actor: UUID, container: Ctx) -> str | None:
|
||||
if container.kind == "case":
|
||||
case = get_case(conn, container.id)
|
||||
return case["title"] if case is not None and case_rights(conn, actor, case).read else None
|
||||
matter = get_matter(conn, container.id)
|
||||
return matter["title"] if matter is not None and matter_rights(conn, actor, matter, None).read else None
|
||||
|
||||
|
||||
def find_existing(
|
||||
conn,
|
||||
actor: UUID,
|
||||
source: str,
|
||||
external_id: str,
|
||||
connector_id: str | None,
|
||||
target: Ctx,
|
||||
rights_context: Ctx | None,
|
||||
level: str,
|
||||
) -> list[dict]:
|
||||
"""Matches of one document at the chosen level, readable by the actor, nearest zone first."""
|
||||
zones = LEVELS.get(level, ())
|
||||
if not zones:
|
||||
return []
|
||||
candidates = _candidates(conn, source, external_id, connector_id)
|
||||
if not candidates:
|
||||
return []
|
||||
layout = _zones(conn, target)
|
||||
by_element: dict[UUID, dict] = {}
|
||||
for candidate in candidates:
|
||||
bindings = conn.execute(
|
||||
"SELECT b.context_kind, b.context_id, c.title AS chapter FROM bindings b LEFT JOIN chapters c ON c.id = b.chapter_id WHERE b.element_id = %s",
|
||||
(candidate["id"],),
|
||||
).fetchall()
|
||||
for zone in zones:
|
||||
for container in layout[zone]:
|
||||
hit = next((b for b in bindings if b["context_kind"] == container.kind and b["context_id"] == container.id), None)
|
||||
if hit is None:
|
||||
continue
|
||||
if target.kind == "case" and zone == "inside" and _blocked(conn, target.id, candidate["id"]):
|
||||
continue
|
||||
seen_in = [container] if zone == "around" else [c for c in (target, rights_context) if c is not None]
|
||||
rights = [element_rights(conn, actor, candidate, ctx) for ctx in seen_in]
|
||||
if not any(r.read for r in rights):
|
||||
continue
|
||||
match = {
|
||||
"element_id": str(candidate["id"]),
|
||||
"title": candidate["title"],
|
||||
"where": zone,
|
||||
"certain": candidate["certain"],
|
||||
"chapter": hit["chapter"] if zone == "here" else None,
|
||||
"container": {
|
||||
"kind": container.kind,
|
||||
"title": _title_if_readable(conn, actor, container) if zone != "here" else None,
|
||||
},
|
||||
"can_bind": any(r.share for r in rights),
|
||||
}
|
||||
known = by_element.get(candidate["id"])
|
||||
if known is None or _ORDER[zone] < _ORDER[known["where"]]:
|
||||
by_element[candidate["id"]] = match
|
||||
return sorted(by_element.values(), key=lambda item: (_ORDER[item["where"]], item["title"]))
|
||||
|
||||
|
||||
def already_present(matches: list[dict]) -> Problem:
|
||||
where = {"here": "hier", "inside": "in diesem Bestand", "around": "im Umfeld"}[matches[0]["where"]]
|
||||
return Problem(
|
||||
409,
|
||||
"Bereits vorhanden",
|
||||
f"Dieses Dokument ist {where} schon vorhanden. Füge es nur dann erneut ein, wenn das gewollt ist.",
|
||||
"already_present",
|
||||
)
|
||||
@@ -13,6 +13,7 @@ from app.api.accounts import router as accounts_router
|
||||
from app.api.correspondence import router as correspondence_router
|
||||
from app.api.downloads import router as downloads_router
|
||||
from app.api.export import router as export_router
|
||||
from app.api.externals import router as externals_router
|
||||
from app.api.library import router as library_router
|
||||
from app.api.preferences import router as preferences_router
|
||||
from app.api.rooms import router as rooms_router
|
||||
@@ -132,6 +133,7 @@ def create_app() -> FastAPI:
|
||||
app.include_router(export_router)
|
||||
app.include_router(downloads_router)
|
||||
app.include_router(preferences_router)
|
||||
app.include_router(externals_router)
|
||||
app.include_router(correspondence_router)
|
||||
return app
|
||||
|
||||
|
||||
+55
-1
@@ -36,6 +36,8 @@ from app.access.policy import (
|
||||
from app.content.documents import clean_document
|
||||
from app.core.errors import forbidden, not_found, unprocessable, unsupported
|
||||
from app.core.timeutil import utcnow
|
||||
from app.preferences import effective_preference
|
||||
from app.duplicates import already_present, find_existing
|
||||
from app.media.port import LEGACY_PROFILE, StoredHandle, adapter_for, instance_for_write, publish, removal_for
|
||||
from app.media.storage import display_filename, sha256, sniff
|
||||
|
||||
@@ -1142,7 +1144,7 @@ def add_annotation(conn, actor: UUID, binding_id: UUID, body: str, context: Ctx
|
||||
return row
|
||||
|
||||
|
||||
def create_external(conn, actor: UUID, scope_id: UUID, title: str, source: str, external_id: str, context: Ctx, placement: Ctx | None, chapter_id: UUID | None, document_on, sent_on, received_on, detail: dict | None = None, communication_direction: str | None = None) -> dict:
|
||||
def create_external(conn, actor: UUID, scope_id: UUID, title: str, source: str, external_id: str, context: Ctx, placement: Ctx | None, chapter_id: UUID | None, document_on, sent_on, received_on, detail: dict | None = None, communication_direction: str | None = None, duplicate: str = "insert") -> dict:
|
||||
ensure_can_create(conn, actor, scope_id)
|
||||
from app.sourceregistry import accepts_reference
|
||||
|
||||
@@ -1150,6 +1152,13 @@ def create_external(conn, actor: UUID, scope_id: UUID, title: str, source: str,
|
||||
raise unprocessable("Diese Quelle ist nicht registriert.")
|
||||
target, rights_context = _placement(context, placement)
|
||||
require_container_edit(conn, actor, target, rights_context)
|
||||
if duplicate == "ask":
|
||||
# The level is the account's choice. Only a certain match warns: an unclear connection never blocks.
|
||||
connector = (detail or {}).get("connector_id")
|
||||
level = effective_preference(conn, actor, "duplicate_check")
|
||||
found = [item for item in find_existing(conn, actor, source, external_id, str(connector) if connector else None, target, rights_context, level) if item["certain"]]
|
||||
if found:
|
||||
raise already_present(found)
|
||||
element = _new_element(conn, actor, scope_id, title, "external_ref")
|
||||
conn.execute(
|
||||
"INSERT INTO external_references (element_id, source, external_id, detail) VALUES (%s, %s, %s, %s)",
|
||||
@@ -1167,6 +1176,51 @@ def create_external(conn, actor: UUID, scope_id: UUID, title: str, source: str,
|
||||
return element | {"binding_id": binding["id"]}
|
||||
|
||||
|
||||
def existing_externals(conn, actor: UUID, context: Ctx, placement: Ctx | None, items: list[dict]) -> dict:
|
||||
"""For each document: where it is already present around the target, at the account's check level."""
|
||||
target, rights_context = _placement(context, placement)
|
||||
require_container_edit(conn, actor, target, rights_context)
|
||||
level = effective_preference(conn, actor, "duplicate_check")
|
||||
return {
|
||||
"level": level,
|
||||
"items": [
|
||||
item
|
||||
| {"matches": find_existing(conn, actor, item["source"], item["external_id"], item.get("connector_id"), target, rights_context, level)}
|
||||
for item in items
|
||||
],
|
||||
}
|
||||
|
||||
|
||||
def bind_existing_external(conn, actor: UUID, scope_id: UUID, element_id: UUID, context: Ctx, placement: Ctx | None, chapter_id: UUID | None) -> dict:
|
||||
"""Bind an element that already holds the document into a further container: one element, one more binding.
|
||||
|
||||
The element must be a certain match around the target, readable for the actor, and the actor may share it
|
||||
there. Nothing is copied and nothing is handed over: rights stay those of each context.
|
||||
"""
|
||||
ensure_can_create(conn, actor, scope_id)
|
||||
target, rights_context = _placement(context, placement)
|
||||
require_container_edit(conn, actor, target, rights_context)
|
||||
ref = conn.execute(
|
||||
"SELECT source, external_id, connector_id, detail FROM external_references WHERE element_id = %s",
|
||||
(element_id,),
|
||||
).fetchone()
|
||||
if ref is None:
|
||||
raise not_found()
|
||||
connector = ref["connector_id"] or (ref["detail"] or {}).get("connector_id")
|
||||
matches = find_existing(conn, actor, ref["source"], ref["external_id"], str(connector) if connector else None, target, rights_context, "around")
|
||||
match = next((item for item in matches if item["element_id"] == str(element_id) and item["certain"]), None)
|
||||
if match is None:
|
||||
raise not_found()
|
||||
if match["where"] == "here":
|
||||
raise unprocessable("Das Dokument ist hier bereits eingebunden.")
|
||||
if not match["can_bind"]:
|
||||
raise forbidden("Du darfst dieses Element nicht in einen weiteren Zusammenhang einbinden.")
|
||||
element = get_element(conn, element_id)
|
||||
binding = insert_binding(conn, element_id, target.kind, target.id, chapter_id, actor)
|
||||
audit(conn, actor, scope_id, "external_ref_bound", "element", element_id, rights_context or target)
|
||||
return element | {"binding_id": binding["id"]}
|
||||
|
||||
|
||||
def create_file(conn, actor: UUID, scope_id: UUID, title: str, filename: str, data: bytes, context: Ctx, placement: Ctx | None, chapter_id: UUID | None, document_on, sent_on, received_on, media_root: str, max_bytes: int, rollback_files: list[Path], communication_direction: str | None = None) -> dict:
|
||||
ensure_can_create(conn, actor, scope_id)
|
||||
if not data or len(data) > max_bytes:
|
||||
|
||||
@@ -25,7 +25,7 @@ class Preference:
|
||||
|
||||
PREFERENCES: dict[str, Preference] = {
|
||||
# Where an element that is inserted again counts as already present.
|
||||
"duplicate_check": Preference("case", ("off", "case", "case_matters", "case_tree")),
|
||||
"duplicate_check": Preference("here", ("off", "here", "inside", "around")),
|
||||
}
|
||||
|
||||
|
||||
|
||||
@@ -1083,4 +1083,5 @@ LABELS = {
|
||||
"room_download_policy_changed": "Download-Regel des Datenraums geändert",
|
||||
"download_defaults_changed": "Standard für Downloads geändert",
|
||||
"preference_changed": "Einstellung des Kontos geändert",
|
||||
"external_ref_bound": "Vorhandene Referenz zusätzlich eingebunden",
|
||||
}
|
||||
@@ -13,3 +13,6 @@ CREATE TABLE account_preferences (
|
||||
CONSTRAINT account_preferences_key_len CHECK (char_length(key) BETWEEN 1 AND 60),
|
||||
CONSTRAINT account_preferences_team_mode CHECK (team_mode IN ('free', 'locked'))
|
||||
);
|
||||
|
||||
-- Dieselbe Quelle und Kennung: Suche nach bereits eingefügten Dokumenten (app/duplicates.py).
|
||||
CREATE INDEX external_references_identity ON external_references (source, external_id);
|
||||
@@ -0,0 +1,126 @@
|
||||
"""Bereits eingefügte Quelldokumente: Vorabfrage, Warnung (409), erneutes Einfügen und zusätzliches Einbinden."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from uuid import uuid4
|
||||
|
||||
import pytest
|
||||
|
||||
from tests.support import matter_of
|
||||
from tests.test_team import _main
|
||||
|
||||
PREF = "/api/v1/auth/preferences/duplicate_check"
|
||||
EXISTING = "/api/v1/external-refs/existing"
|
||||
CONNECTOR = str(uuid4())
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def ada(client, db):
|
||||
return _main(client, db, "ada", main=True)
|
||||
|
||||
|
||||
def _ref(actor, kind, container, external_id="41", connector=CONNECTOR, status=201, **extra):
|
||||
body = {
|
||||
"title": f"Dokument {external_id}",
|
||||
"source": "paperless",
|
||||
"external_id": external_id,
|
||||
"context": {"kind": kind, "id": container},
|
||||
"detail": {"connector_id": connector},
|
||||
**extra,
|
||||
}
|
||||
return actor.request("POST", "/api/v1/external-refs", json=body, status=status)
|
||||
|
||||
|
||||
def _ask(actor, kind, container, external_id="41", connector=CONNECTOR):
|
||||
body = {
|
||||
"context": {"kind": kind, "id": container},
|
||||
"items": [{"source": "paperless", "external_id": external_id, "connector_id": connector}],
|
||||
}
|
||||
return actor.request("POST", EXISTING, json=body)["items"][0]["matches"]
|
||||
|
||||
|
||||
def _level(actor, value):
|
||||
actor.request("PUT", PREF, json={"value": value})
|
||||
|
||||
|
||||
def test_a_document_in_the_same_container_warns_and_can_be_inserted_anyway(ada):
|
||||
matter = matter_of(ada, "Mietminderung")["id"]
|
||||
first = _ref(ada, "matter", matter)
|
||||
found = _ask(ada, "matter", matter)
|
||||
assert [(m["element_id"], m["where"], m["certain"]) for m in found] == [(first["id"], "here", True)]
|
||||
|
||||
refused = _ref(ada, "matter", matter, status=409)
|
||||
assert refused["code"] == "already_present"
|
||||
# A deliberate second insert goes through. Another document or another connection is no duplicate.
|
||||
_ref(ada, "matter", matter, duplicate="insert")
|
||||
_ref(ada, "matter", matter, external_id="42")
|
||||
_ref(ada, "matter", matter, connector=str(uuid4()))
|
||||
assert _ask(ada, "matter", matter, external_id="42")[0]["where"] == "here"
|
||||
|
||||
|
||||
def test_the_same_document_in_another_vorgang_is_no_duplicate(ada):
|
||||
one = matter_of(ada, "Eins")["id"]
|
||||
two = matter_of(ada, "Zwei")["id"]
|
||||
_ref(ada, "matter", one)
|
||||
assert _ask(ada, "matter", two) == []
|
||||
_ref(ada, "matter", two)
|
||||
|
||||
|
||||
def test_the_check_can_be_switched_off(ada):
|
||||
matter = matter_of(ada, "Mietminderung")["id"]
|
||||
_ref(ada, "matter", matter)
|
||||
_level(ada, "off")
|
||||
assert _ask(ada, "matter", matter) == []
|
||||
_ref(ada, "matter", matter)
|
||||
|
||||
|
||||
def test_levels_reach_into_teilvorgang_vorgang_and_akte(ada):
|
||||
parent = matter_of(ada, "Hauptvorgang")["id"]
|
||||
child = ada.request("POST", "/api/v1/matters", json={"title": "Teil", "parent_matter_id": parent}, status=201)["id"]
|
||||
case = ada.request("POST", "/api/v1/cases", json={"title": "Akte"}, status=201)["id"]
|
||||
ada.request("POST", f"/api/v1/matters/{parent}/case-links", json={"case_id": case}, status=201)
|
||||
_ref(ada, "matter", child, external_id="1")
|
||||
_ref(ada, "matter", parent, external_id="2")
|
||||
_ref(ada, "case", case, external_id="3")
|
||||
|
||||
def where(kind, container, external_id):
|
||||
return [m["where"] for m in _ask(ada, kind, container, external_id)]
|
||||
|
||||
# Standard: only what sits directly in the target.
|
||||
assert where("matter", parent, "1") == []
|
||||
_level(ada, "inside")
|
||||
assert where("matter", parent, "1") == ["inside"]
|
||||
assert where("matter", child, "2") == []
|
||||
assert where("case", case, "2") == ["inside"]
|
||||
assert where("case", case, "3") == ["here"]
|
||||
_level(ada, "around")
|
||||
assert where("matter", child, "2") == ["around"]
|
||||
assert where("matter", parent, "3") == ["around"]
|
||||
assert where("matter", child, "3") == ["around"]
|
||||
# The server warns at the same level.
|
||||
_ref(ada, "matter", child, external_id="3", status=409)
|
||||
|
||||
|
||||
def test_an_existing_element_can_be_bound_instead_of_a_new_one(ada):
|
||||
parent = matter_of(ada, "Hauptvorgang")["id"]
|
||||
child = ada.request("POST", "/api/v1/matters", json={"title": "Teil", "parent_matter_id": parent}, status=201)["id"]
|
||||
original = _ref(ada, "matter", child)
|
||||
_level(ada, "inside")
|
||||
assert _ask(ada, "matter", parent)[0]["can_bind"] is True
|
||||
|
||||
bound = _ref(ada, "matter", parent, bind_element_id=original["id"])
|
||||
assert bound["id"] == original["id"]
|
||||
assert [m["where"] for m in _ask(ada, "matter", parent)] == ["here"]
|
||||
refused = _ref(ada, "matter", parent, bind_element_id=original["id"], status=422)
|
||||
assert "bereits" in refused["detail"]
|
||||
|
||||
|
||||
def test_a_stranger_neither_sees_nor_binds_my_element(client, db, ada):
|
||||
mine = matter_of(ada, "Mein Vorgang")["id"]
|
||||
element = _ref(ada, "matter", mine)
|
||||
ben = _main(client, db, "ben")
|
||||
theirs = matter_of(ben, "Ihr Vorgang")["id"]
|
||||
_level(ben, "around")
|
||||
assert _ask(ben, "matter", theirs) == []
|
||||
_ref(ben, "matter", theirs)
|
||||
_ref(ben, "matter", theirs, bind_element_id=element["id"], status=404)
|
||||
@@ -21,45 +21,45 @@ def world(client, db):
|
||||
def test_the_default_applies_without_any_choice(world):
|
||||
for person in (world["ada"], world["emp"]):
|
||||
state = person.request("GET", PATH)
|
||||
assert (state["value"], state["source"]) == ("case", "default")
|
||||
assert (state["value"], state["source"]) == ("here", "default")
|
||||
assert world["ada"].request("GET", PATH)["can_lock"] is True
|
||||
assert world["emp"].request("GET", PATH)["can_lock"] is False
|
||||
|
||||
|
||||
def test_an_employee_inherits_the_main_user_and_may_override(world):
|
||||
ada, emp = world["ada"], world["emp"]
|
||||
ada.request("PUT", PATH, json={"value": "case_matters"})
|
||||
ada.request("PUT", PATH, json={"value": "inside"})
|
||||
inherited = emp.request("GET", PATH)
|
||||
assert (inherited["value"], inherited["source"]) == ("case_matters", "team")
|
||||
assert (inherited["value"], inherited["source"]) == ("inside", "team")
|
||||
|
||||
own = emp.request("PUT", PATH, json={"value": "off"})
|
||||
assert (own["value"], own["source"]) == ("off", "own")
|
||||
# The main user's change does not touch an own choice.
|
||||
ada.request("PUT", PATH, json={"value": "case_tree"})
|
||||
ada.request("PUT", PATH, json={"value": "around"})
|
||||
assert emp.request("GET", PATH)["value"] == "off"
|
||||
assert ada.request("GET", PATH)["value"] == "case_tree"
|
||||
assert ada.request("GET", PATH)["value"] == "around"
|
||||
|
||||
# Inheriting again.
|
||||
back = emp.request("PUT", PATH, json={"value": None})
|
||||
assert (back["value"], back["source"]) == ("case_tree", "team")
|
||||
assert (back["value"], back["source"]) == ("around", "team")
|
||||
|
||||
|
||||
def test_a_binding_overrides_an_own_value_without_deleting_it(world):
|
||||
ada, emp = world["ada"], world["emp"]
|
||||
emp.request("PUT", PATH, json={"value": "off"})
|
||||
ada.request("PUT", PATH, json={"value": "case_matters", "team_mode": "locked"})
|
||||
ada.request("PUT", PATH, json={"value": "inside", "team_mode": "locked"})
|
||||
|
||||
locked = emp.request("GET", PATH)
|
||||
assert (locked["value"], locked["source"], locked["locked"]) == ("case_matters", "locked", True)
|
||||
refused = emp.request("PUT", PATH, json={"value": "case"}, status=403)
|
||||
assert (locked["value"], locked["source"], locked["locked"]) == ("inside", "locked", True)
|
||||
refused = emp.request("PUT", PATH, json={"value": "here"}, status=403)
|
||||
assert "vorgegeben" in refused["detail"]
|
||||
|
||||
# The main user is not bound by the own binding.
|
||||
assert ada.request("PUT", PATH, json={"value": "case"})["value"] == "case"
|
||||
assert ada.request("PUT", PATH, json={"value": "here"})["value"] == "here"
|
||||
assert ada.request("GET", PATH)["team_mode"] == "locked"
|
||||
assert emp.request("GET", PATH)["value"] == "case"
|
||||
assert emp.request("GET", PATH)["value"] == "here"
|
||||
|
||||
ada.request("PUT", PATH, json={"value": "case", "team_mode": "free"})
|
||||
ada.request("PUT", PATH, json={"value": "here", "team_mode": "free"})
|
||||
again = emp.request("GET", PATH)
|
||||
assert (again["value"], again["source"]) == ("off", "own")
|
||||
|
||||
@@ -76,4 +76,4 @@ def test_only_the_main_user_binds_and_values_are_checked(world):
|
||||
def test_a_binding_of_a_stranger_does_not_reach_my_employee(client, db, world):
|
||||
ben = _main(client, db, "ben")
|
||||
ben.request("PUT", PATH, json={"value": "off", "team_mode": "locked"})
|
||||
assert world["emp"].request("GET", PATH)["value"] == "case"
|
||||
assert world["emp"].request("GET", PATH)["value"] == "here"
|
||||
Reference in new issue
Block a user