Initialize organizations module

2026-07-10 11:01:37 +02:00
commit 34133ba9cd
20 changed files with 1005 additions and 0 deletions
--- a/src/govoplan_organizations/backend/directory.py
+++ b/src/govoplan_organizations/backend/directory.py
@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+from sqlalchemy import or_
+
+from govoplan_core.core.organizations import (
+    OrganizationDirectory,
+    OrganizationFunctionAssignmentRef,
+    OrganizationFunctionRef,
+    OrganizationUnitRef,
+)
+from govoplan_core.db.session import get_database
+from govoplan_core.security.time import utc_now
+from govoplan_organizations.backend.db.models import (
+    OrganizationFunction,
+    OrganizationFunctionAssignment,
+    OrganizationUnit,
+)
+
+
+def _status(active: bool) -> str:
+    return "active" if active else "inactive"
+
+
+def _unit_ref(item: OrganizationUnit) -> OrganizationUnitRef:
+    return OrganizationUnitRef(
+        id=item.id,
+        tenant_id=item.tenant_id,
+        slug=item.slug,
+        name=item.name,
+        parent_id=item.parent_id,
+        description=item.description,
+        status=_status(item.is_active),  # type: ignore[arg-type]
+    )
+
+
+def _function_ref(item: OrganizationFunction) -> OrganizationFunctionRef:
+    return OrganizationFunctionRef(
+        id=item.id,
+        tenant_id=item.tenant_id,
+        organization_unit_id=item.organization_unit_id,
+        slug=item.slug,
+        name=item.name,
+        description=item.description,
+        delegable=item.delegable,
+        act_in_place_allowed=item.act_in_place_allowed,
+        status=_status(item.is_active),  # type: ignore[arg-type]
+    )
+
+
+def _assignment_ref(item: OrganizationFunctionAssignment) -> OrganizationFunctionAssignmentRef:
+    return OrganizationFunctionAssignmentRef(
+        id=item.id,
+        tenant_id=item.tenant_id,
+        account_id=item.account_id,
+        identity_id=item.identity_id,
+        function_id=item.function_id,
+        organization_unit_id=item.organization_unit_id,
+        applies_to_subunits=item.applies_to_subunits,
+        source=item.source,  # type: ignore[arg-type]
+        delegated_from_assignment_id=item.delegated_from_assignment_id,
+        acting_for_account_id=item.acting_for_account_id,
+        valid_from=item.valid_from,
+        valid_until=item.valid_until,
+        status=_status(item.is_active),  # type: ignore[arg-type]
+    )
+
+
+class SqlOrganizationDirectory(OrganizationDirectory):
+    def get_organization_unit(self, organization_unit_id: str) -> OrganizationUnitRef | None:
+        with get_database().session() as session:
+            item = session.get(OrganizationUnit, organization_unit_id)
+            return _unit_ref(item) if item is not None else None
+
+    def organization_units_for_tenant(self, tenant_id: str) -> tuple[OrganizationUnitRef, ...]:
+        with get_database().session() as session:
+            rows = (
+                session.query(OrganizationUnit)
+                .filter(OrganizationUnit.tenant_id == tenant_id)
+                .order_by(OrganizationUnit.name.asc())
+                .all()
+            )
+            return tuple(_unit_ref(item) for item in rows)
+
+    def get_function(self, function_id: str) -> OrganizationFunctionRef | None:
+        with get_database().session() as session:
+            item = session.get(OrganizationFunction, function_id)
+            return _function_ref(item) if item is not None else None
+
+    def functions_for_organization_unit(
+        self,
+        organization_unit_id: str,
+        *,
+        include_subunits: bool = False,
+    ) -> tuple[OrganizationFunctionRef, ...]:
+        with get_database().session() as session:
+            unit_ids = {organization_unit_id}
+            if include_subunits:
+                pending = [organization_unit_id]
+                while pending:
+                    parent_id = pending.pop()
+                    child_ids = [
+                        row[0]
+                        for row in session.query(OrganizationUnit.id)
+                        .filter(OrganizationUnit.parent_id == parent_id)
+                        .all()
+                    ]
+                    for child_id in child_ids:
+                        if child_id not in unit_ids:
+                            unit_ids.add(child_id)
+                            pending.append(child_id)
+            rows = (
+                session.query(OrganizationFunction)
+                .filter(OrganizationFunction.organization_unit_id.in_(unit_ids))
+                .order_by(OrganizationFunction.name.asc())
+                .all()
+            )
+            return tuple(_function_ref(item) for item in rows)
+
+    def get_function_assignment(self, assignment_id: str) -> OrganizationFunctionAssignmentRef | None:
+        with get_database().session() as session:
+            item = session.get(OrganizationFunctionAssignment, assignment_id)
+            return _assignment_ref(item) if item is not None else None
+
+    def function_assignments_for_account(
+        self,
+        account_id: str,
+        *,
+        tenant_id: str | None = None,
+    ) -> tuple[OrganizationFunctionAssignmentRef, ...]:
+        now = utc_now()
+        with get_database().session() as session:
+            query = (
+                session.query(OrganizationFunctionAssignment)
+                .join(OrganizationFunction, OrganizationFunction.id == OrganizationFunctionAssignment.function_id)
+                .filter(
+                    OrganizationFunctionAssignment.account_id == account_id,
+                    OrganizationFunctionAssignment.is_active.is_(True),
+                    OrganizationFunction.is_active.is_(True),
+                    or_(OrganizationFunctionAssignment.valid_from.is_(None), OrganizationFunctionAssignment.valid_from <= now),
+                    or_(OrganizationFunctionAssignment.valid_until.is_(None), OrganizationFunctionAssignment.valid_until > now),
+                )
+                .order_by(OrganizationFunctionAssignment.created_at.asc())
+            )
+            if tenant_id is not None:
+                query = query.filter(OrganizationFunctionAssignment.tenant_id == tenant_id)
+            return tuple(_assignment_ref(item) for item in query.all())