core-framework 0.3.0__py3-none-any.whl

core_framework/domains/moderation/repository.py

@@ -0,0 +1,828 @@
+from datetime import datetime
+from typing import Any
+
+from core_framework.core.database import Postgres
+from core_framework.domains.moderation.enums import (
+    AppealDecision,
+    HistoryAction,
+    ModerationActionType,
+    ReportCategory,
+    RestrictionCategory,
+    RestrictionType,
+)
+from core_framework.domains.moderation.exceptions import (
+    AppealAlreadyDecidedException,
+    AppealNotFoundException,
+    AppealRequirementException,
+    BaseModerationException,
+    ExistingPendingAppealException,
+)
+from core_framework.domains.moderation.models import (
+    Appeal,
+    InternalNote,
+    ModerationAction,
+    Report,
+    RestrictionHistory,
+    UserRestriction,
+)
+
+
+class ModerationRepository:
+    def __init__(self, write_database: Postgres, read_database: Postgres, strong_read_database: Postgres):
+        self.write_database = write_database
+        self.read_database = read_database
+        self.strong_read_database = strong_read_database
+
+    @staticmethod
+    def _record_to_report(record: Any) -> Report:
+        return Report(
+            id=record["id"],
+            reporter_id=record["reporter_id"],
+            target_id=record["target_id"],
+            category=ReportCategory(record["category"]),
+            reason=record["reason"],
+            created_at=record["created_at"],
+        )
+
+    # Restrictions
+    async def upsert_ban_state(
+        self,
+        *,
+        actor_id: str,
+        user_id: str,
+        reason: str,
+        category: RestrictionCategory,
+        expires_at: datetime,
+    ) -> None:
+        query = """
+            merge into moderation.user_restrictions as target
+            using (values ($1, 'banned'::moderation.restriction_type, $2, $3::moderation.restriction_category, $4::timestamptz))
+                as source(user_id, restriction_type, reason, category, expires_at)
+            on target.user_id = source.user_id
+            when matched and target.restriction_type != 'banned'::moderation.restriction_type then
+                update set
+                    restriction_type = source.restriction_type,
+                    reason = source.reason,
+                    category = source.category,
+                    expires_at = source.expires_at,
+                    updated_at = now()
+            when not matched then
+                insert (user_id, restriction_type, reason, category, expires_at)
+                values (source.user_id, source.restriction_type, source.reason, source.category, source.expires_at)
+        """
+        async with self.write_database.get_transaction_with_actor_id(actor_id) as connection:
+            await connection.execute(query, user_id, reason, category, expires_at)
+
+    async def upsert_mute_state(
+        self,
+        *,
+        actor_id: str,
+        user_id: str,
+        reason: str,
+        category: RestrictionCategory,
+        expires_at: datetime,
+    ) -> None:
+        query = """
+            merge into moderation.user_restrictions as target
+            using (values ($1, 'muted'::moderation.restriction_type, $2, $3::moderation.restriction_category, $4::timestamptz))
+                as source(user_id, restriction_type, reason, category, expires_at)
+            on target.user_id = source.user_id
+            when matched and target.restriction_type = 'warned'::moderation.restriction_type then
+                update set
+                    restriction_type = source.restriction_type,
+                    reason = source.reason,
+                    category = source.category,
+                    expires_at = source.expires_at,
+                    updated_at = now()
+            when not matched then
+                insert (user_id, restriction_type, reason, category, expires_at)
+                values (source.user_id, source.restriction_type, source.reason, source.category, source.expires_at)
+        """
+        async with self.write_database.get_transaction_with_actor_id(actor_id) as connection:
+            await connection.execute(query, user_id, reason, category, expires_at)
+
+    async def upsert_warn_state(
+        self,
+        *,
+        actor_id: str,
+        user_id: str,
+        reason: str,
+        category: RestrictionCategory,
+    ) -> None:
+        query = """
+            merge into moderation.user_restrictions as target
+            using (values ($1, 'warned'::moderation.restriction_type, $2, $3::moderation.restriction_category))
+                as source(user_id, restriction_type, reason, category)
+            on target.user_id = source.user_id
+            when matched then
+                do nothing
+            when not matched then
+                insert (user_id, restriction_type, reason, category)
+                values (source.user_id, source.restriction_type, source.reason, source.category)
+        """
+        async with self.write_database.get_transaction_with_actor_id(actor_id) as connection:
+            await connection.execute(query, user_id, reason, category)
+
+    async def delete_user_restriction(self, *, actor_id: str, user_id: str) -> None:
+        query = """
+            delete from moderation.user_restrictions
+            where user_id = $1
+        """
+        async with self.write_database.get_transaction_with_actor_id(actor_id) as connection:
+            await connection.execute(query, user_id)
+
+    async def select_expired_mute_user_ids(self) -> list[str]:
+        query = """
+            select
+                user_id
+            from moderation.user_restrictions
+            where true
+                and restriction_type = 'muted'::moderation.restriction_type
+                and expires_at is not null
+                and expires_at <= now()
+        """
+        async with self.read_database.get_connection() as connection:
+            result = await connection.fetch(query)
+            return [record["user_id"] for record in result]
+
+    # Reports
+    async def insert_user_report(
+        self,
+        *,
+        reporter_id: str,
+        target_id: str,
+        category: ReportCategory,
+        reason: str,
+    ) -> None:
+        query = """
+            insert into moderation.user_reports (reporter_id, target_id, category, reason)
+            values ($1, $2, $3, $4)
+            on conflict (reporter_id, target_id) do nothing
+        """
+        async with self.write_database.get_connection() as connection:
+            await connection.execute(query, reporter_id, target_id, category, reason)
+
+    async def select_user_reports(
+        self,
+        *,
+        reporter_id: str | None,
+        target_id: str | None,
+        cursor: datetime,
+        limit: int,
+    ) -> list[Report]:
+        query = """
+            select
+                id,
+                reporter_id,
+                target_id,
+                category,
+                reason,
+                created_at
+            from moderation.user_reports
+            where true
+                and created_at <= $1
+                and ($3::text is null or reporter_id = $3)
+                and ($4::text is null or target_id = $4)
+            order by created_at desc
+            limit $2
+        """
+        async with self.read_database.get_connection() as connection:
+            result = await connection.fetch(query, cursor, limit, reporter_id, target_id)
+            return [self._record_to_report(record) for record in result]
+
+    async def delete_user_report_by_id(self, *, report_id: int) -> None:
+        query = """
+            delete from moderation.user_reports
+            where id = $1
+        """
+        async with self.write_database.get_connection() as connection:
+            await connection.execute(query, report_id)
+
+    async def delete_user_report_by_reporter_and_target(self, *, reporter_id: str, target_id: str) -> None:
+        query = """
+            delete from moderation.user_reports
+            where true
+                and reporter_id = $1
+                and target_id = $2
+        """
+        async with self.write_database.get_connection() as connection:
+            await connection.execute(query, reporter_id, target_id)
+
+    async def insert_post_report(
+        self,
+        *,
+        reporter_id: str,
+        target_id: str,
+        category: ReportCategory,
+        reason: str,
+    ) -> None:
+        query = """
+            insert into moderation.post_reports (reporter_id, target_id, category, reason)
+            values ($1, $2, $3, $4)
+            on conflict (reporter_id, target_id) do nothing
+        """
+        async with self.write_database.get_connection() as connection:
+            await connection.execute(query, reporter_id, target_id, category, reason)
+
+    async def select_post_report_count(self, *, post_id: str) -> int:
+        query = """
+            select count(*)
+            from moderation.post_reports
+            where target_id = $1
+        """
+        async with self.read_database.get_connection() as connection:
+            return await connection.fetchval(query, post_id)
+
+    async def select_post_reports(
+        self,
+        *,
+        reporter_id: str | None,
+        target_id: str | None,
+        cursor: datetime,
+        limit: int,
+    ) -> list[Report]:
+        query = """
+            select
+                id,
+                reporter_id,
+                target_id,
+                category,
+                reason,
+                created_at
+            from moderation.post_reports
+            where true
+                and created_at <= $1
+                and ($3::text is null or reporter_id = $3)
+                and ($4::text is null or target_id = $4)
+            order by created_at desc
+            limit $2
+        """
+        async with self.read_database.get_connection() as connection:
+            result = await connection.fetch(query, cursor, limit, reporter_id, target_id)
+            return [self._record_to_report(record) for record in result]
+
+    async def delete_post_report_by_id(self, *, report_id: int) -> None:
+        query = """
+            delete from moderation.post_reports
+            where id = $1
+        """
+        async with self.write_database.get_connection() as connection:
+            await connection.execute(query, report_id)
+
+    async def delete_post_report_by_reporter_and_target(self, *, reporter_id: str, target_id: str) -> None:
+        query = """
+            delete from moderation.post_reports
+            where true
+                and reporter_id = $1
+                and target_id = $2
+        """
+        async with self.write_database.get_connection() as connection:
+            await connection.execute(query, reporter_id, target_id)
+
+    async def delete_post_reports_by_target_id(self, *, target_id: str) -> None:
+        query = """
+            delete from moderation.post_reports
+            where target_id = $1
+        """
+        async with self.write_database.get_connection() as connection:
+            await connection.execute(query, target_id)
+
+    async def select_post_ids_reported_by_user(self, *, reporter_id: str, post_ids: set[str]) -> list[str]:
+        if not post_ids:
+            return []
+        query = """
+            select target_id
+            from moderation.post_reports
+            where true
+                and reporter_id = $1
+                and target_id = any($2)
+        """
+        async with self.read_database.get_connection() as connection:
+            rows = await connection.fetch(query, reporter_id, list(post_ids))
+            return [row["target_id"] for row in rows]
+
+    async def select_comment_ids_reported_by_user(self, *, reporter_id: str, comment_ids: set[str]) -> list[str]:
+        if not comment_ids:
+            return []
+        query = """
+            select target_id
+            from moderation.comment_reports
+            where true
+                and reporter_id = $1
+                and target_id = any($2)
+        """
+        async with self.read_database.get_connection() as connection:
+            rows = await connection.fetch(query, reporter_id, list(comment_ids))
+            return [row["target_id"] for row in rows]
+
+    async def select_comment_report_count(self, *, comment_id: str) -> int:
+        query = """
+            select count(*)::int
+            from moderation.comment_reports
+            where target_id = $1
+        """
+        async with self.read_database.get_connection() as connection:
+            return await connection.fetchval(query, comment_id) or 0
+
+    async def select_comment_reports(
+        self,
+        *,
+        reporter_id: str | None,
+        target_id: str | None,
+        cursor: datetime,
+        limit: int,
+    ) -> list[Report]:
+        query = """
+            select
+                id,
+                reporter_id,
+                target_id,
+                category,
+                reason,
+                created_at
+            from moderation.comment_reports
+            where true
+                and created_at <= $1
+                and ($3::text is null or reporter_id = $3)
+                and ($4::text is null or target_id = $4)
+            order by created_at desc
+            limit $2
+        """
+        async with self.read_database.get_connection() as connection:
+            result = await connection.fetch(query, cursor, limit, reporter_id, target_id)
+            return [self._record_to_report(record) for record in result]
+
+    async def insert_comment_report(
+        self,
+        *,
+        reporter_id: str,
+        target_id: str,
+        category: ReportCategory,
+        reason: str,
+    ) -> None:
+        query = """
+            insert into moderation.comment_reports (reporter_id, target_id, category, reason)
+            values ($1, $2, $3, $4)
+            on conflict (reporter_id, target_id) do nothing
+        """
+        async with self.write_database.get_connection() as connection:
+            await connection.execute(query, reporter_id, target_id, category, reason)
+
+    async def delete_comment_report_by_id(self, *, report_id: int) -> None:
+        query = """
+            delete from moderation.comment_reports
+            where id = $1
+        """
+        async with self.write_database.get_connection() as connection:
+            await connection.execute(query, report_id)
+
+    async def delete_comment_report_by_reporter_and_target(
+        self,
+        *,
+        reporter_id: str,
+        target_id: str,
+    ) -> None:
+        query = """
+            delete from moderation.comment_reports
+            where true
+                and reporter_id = $1
+                and target_id = $2
+        """
+        async with self.write_database.get_connection() as connection:
+            await connection.execute(query, reporter_id, target_id)
+
+    async def delete_comment_reports_by_target_ids(self, *, target_ids: set[str]) -> None:
+        if not target_ids:
+            return
+        query = """
+            delete from moderation.comment_reports
+            where target_id = any($1::varchar[])
+        """
+        async with self.write_database.get_connection() as connection:
+            await connection.execute(query, list(target_ids))
+
+    # Appeals
+    async def insert_appeal(self, *, user_id: str, justification: str) -> None:
+        query = """
+            with has_restriction as (
+                select exists (
+                    select 1
+                    from moderation.user_restrictions
+                    where true
+                        and user_id = $1
+                        and restriction_type in ('muted', 'banned')
+                ) as yes
+            ),
+            ins as (
+                insert into moderation.appeals (user_id, justification)
+                select $1, $2
+                where (select yes from has_restriction)
+                on conflict (user_id) where status = 'pending' do nothing
+                returning id
+            )
+            select
+                case when ins.id is not null           then 'success'
+                        when not has_restriction.yes   then 'restriction_required'
+                        else                                'conflict'
+                end as state
+            from has_restriction left join ins on true
+        """
+        async with self.write_database.get_connection() as connection:
+            result = await connection.fetchval(query, user_id, justification)
+            if result == "success":
+                return
+            if result == "conflict":
+                raise ExistingPendingAppealException()
+            if result == "restriction_required":
+                raise AppealRequirementException()
+            raise BaseModerationException("Failed to create appeal")
+
+    async def select_appeal_strong(self, *, appeal_id: int) -> Appeal:
+        query = """
+            select
+                id,
+                user_id,
+                justification,
+                decision_reason,
+                reviewer_id,
+                status,
+                created_at,
+                updated_at
+            from moderation.appeals
+            where id = $1
+        """
+        async with self.strong_read_database.get_connection() as connection:
+            result = await connection.fetchrow(query, appeal_id)
+            if result is None:
+                raise AppealNotFoundException()
+            return Appeal(
+                id=result["id"],
+                user_id=result["user_id"],
+                justification=result["justification"],
+                decision_reason=result["decision_reason"],
+                reviewer_id=result["reviewer_id"],
+                status=AppealDecision(result["status"]),
+                created_at=result["created_at"],
+                updated_at=result["updated_at"],
+            )
+
+    async def update_appeal_decision(
+        self,
+        *,
+        actor_id: str,
+        appeal_id: int,
+        decision: AppealDecision,
+        reason: str,
+    ) -> None:
+        query = """
+            update moderation.appeals
+            set
+                status = $2,
+                decision_reason = $3,
+                reviewer_id = $4
+            where true
+                and id = $1
+                and status = 'pending'
+            returning id
+        """
+        existing_appeal_query = """
+            select 1 from moderation.appeals where id = $1
+        """
+        async with self.write_database.get_connection() as connection:
+            row = await connection.fetchrow(query, appeal_id, decision, reason, actor_id)
+            if row is None:
+                existing = await connection.fetchrow(existing_appeal_query, appeal_id)
+                if existing is None:
+                    raise AppealNotFoundException()
+                else:
+                    raise AppealAlreadyDecidedException()
+
+    async def select_appeals(
+        self,
+        *,
+        cursor: datetime,
+        limit: int,
+        status: AppealDecision | None,
+        user_id: str | None = None,
+    ) -> list[Appeal]:
+        query = """
+            select
+                id,
+                user_id,
+                justification,
+                decision_reason,
+                reviewer_id,
+                status,
+                created_at,
+                updated_at
+            from moderation.appeals
+            where true
+                and updated_at <= $1
+                and ($3::text is null or user_id = $3)
+                and ($4::moderation.appeal_status is null or status = $4::moderation.appeal_status)
+            order by updated_at desc
+            limit $2
+        """
+        async with self.read_database.get_connection() as connection:
+            result = await connection.fetch(query, cursor, limit, user_id, status)
+            return [
+                Appeal(
+                    id=record["id"],
+                    user_id=record["user_id"],
+                    justification=record["justification"],
+                    decision_reason=record["decision_reason"],
+                    reviewer_id=record["reviewer_id"],
+                    status=AppealDecision(record["status"]),
+                    created_at=record["created_at"],
+                    updated_at=record["updated_at"],
+                )
+                for record in result
+            ]
+
+    async def delete_current_appeal_of_user(self, *, user_id: str) -> None:
+        query = """
+            delete from moderation.appeals
+            where true
+                and user_id = $1
+                and status = 'pending'
+        """
+        async with self.write_database.get_connection() as connection:
+            await connection.execute(query, user_id)
+
+    # Internal Notes
+    async def insert_internal_note(
+        self,
+        *,
+        actor_id: str,
+        target_user_id: str,
+        content: str,
+    ) -> InternalNote:
+        query = """
+            insert into moderation.internal_notes (target_user_id, actor_id, content)
+            values ($1, $2, $3)
+            returning id, target_user_id, actor_id, content, created_at
+        """
+        async with self.write_database.get_connection() as connection:
+            result = await connection.fetchrow(query, target_user_id, actor_id, content)
+            assert result is not None
+            return InternalNote(
+                id=result["id"],
+                target_user_id=result["target_user_id"],
+                actor_id=result["actor_id"],
+                content=result["content"],
+                created_at=result["created_at"],
+            )
+
+    async def select_internal_note_by_id_strong(self, *, note_id: int, target_user_id: str) -> InternalNote | None:
+        query = """
+            select
+                id,
+                target_user_id,
+                actor_id,
+                content,
+                created_at
+            from moderation.internal_notes
+            where true
+                and id = $1
+                and target_user_id = $2
+        """
+        async with self.strong_read_database.get_connection() as connection:
+            result = await connection.fetchrow(query, note_id, target_user_id)
+            if result is None:
+                return None
+            return InternalNote(
+                id=result["id"],
+                target_user_id=result["target_user_id"],
+                actor_id=result["actor_id"],
+                content=result["content"],
+                created_at=result["created_at"],
+            )
+
+    async def select_internal_notes(self, *, target_user_id: str) -> list[InternalNote]:
+        query = """
+            select
+                id,
+                target_user_id,
+                actor_id,
+                content,
+                created_at
+            from moderation.internal_notes
+            where target_user_id = $1
+            order by created_at desc
+        """
+        async with self.read_database.get_connection() as connection:
+            result = await connection.fetch(query, target_user_id)
+            return [
+                InternalNote(
+                    id=record["id"],
+                    target_user_id=record["target_user_id"],
+                    actor_id=record["actor_id"],
+                    content=record["content"],
+                    created_at=record["created_at"],
+                )
+                for record in result
+            ]
+
+    async def select_internal_notes_paginated(
+        self,
+        *,
+        target_user_id: str,
+        cursor: datetime,
+        limit: int,
+    ) -> list[InternalNote]:
+        query = """
+            select
+                id,
+                target_user_id,
+                actor_id,
+                content,
+                created_at
+            from moderation.internal_notes
+            where true
+                and target_user_id = $1
+                and created_at <= $2
+            order by created_at desc
+            limit $3
+        """
+        async with self.read_database.get_connection() as connection:
+            result = await connection.fetch(query, target_user_id, cursor, limit)
+            return [
+                InternalNote(
+                    id=record["id"],
+                    target_user_id=record["target_user_id"],
+                    actor_id=record["actor_id"],
+                    content=record["content"],
+                    created_at=record["created_at"],
+                )
+                for record in result
+            ]
+
+    async def delete_internal_note(self, *, note_id: int, target_user_id: str) -> None:
+        query = """
+            delete from moderation.internal_notes
+            where true
+                and id = $1
+                and target_user_id = $2
+        """
+        async with self.write_database.get_connection() as connection:
+            await connection.execute(query, note_id, target_user_id)
+
+    # User Moderation
+    async def _select_user_restriction_mapping_with_database(
+        self, *, user_ids: set[str], database: Postgres
+    ) -> dict[str, UserRestriction]:
+        if not user_ids:
+            return {}
+
+        query = """
+            select
+                user_id,
+                restriction_type,
+                category,
+                expires_at
+            from moderation.user_restrictions
+            where user_id = any($1)
+        """
+        async with database.get_connection() as connection:
+            result = await connection.fetch(query, user_ids)
+            return {
+                record["user_id"]: UserRestriction(
+                    user_id=record["user_id"],
+                    status=RestrictionType(record["restriction_type"]),
+                    category=RestrictionCategory(record["category"]),
+                    expires_at=record["expires_at"],
+                )
+                for record in result
+            }
+
+    async def select_user_restriction_mapping(self, *, user_ids: set[str]) -> dict[str, UserRestriction]:
+        return await self._select_user_restriction_mapping_with_database(
+            user_ids=user_ids,
+            database=self.read_database,
+        )
+
+    async def select_user_restriction_mapping_strong(self, *, user_ids: set[str]) -> dict[str, UserRestriction]:
+        return await self._select_user_restriction_mapping_with_database(
+            user_ids=user_ids,
+            database=self.strong_read_database,
+        )
+
+    async def delete_user(self, *, user_id: str) -> None:
+        restriction_query = """
+            delete from moderation.user_restrictions
+            where user_id = $1
+        """
+        restriction_history_query = """
+            delete from moderation.restriction_history
+            where user_id = $1
+        """
+        report_query = """
+            delete from moderation.user_reports
+            where target_id = $1
+               or reporter_id = $1
+        """
+        appeal_query = """
+            delete from moderation.appeals
+            where user_id = $1
+        """
+        internal_notes_query = """
+            delete from moderation.internal_notes
+            where target_user_id = $1
+        """
+        async with self.write_database.get_transaction() as connection:
+            await connection.execute(restriction_query, user_id)
+            await connection.execute(restriction_history_query, user_id)
+            await connection.execute(report_query, user_id)
+            await connection.execute(appeal_query, user_id)
+            await connection.execute(internal_notes_query, user_id)
+
+    # Moderation Actions
+    async def insert_moderation_action(
+        self,
+        *,
+        actor_id: str,
+        action_type: ModerationActionType,
+        target_user_id: str | None = None,
+        action_metadata: dict[str, Any] | None = None,
+    ) -> None:
+        metadata = action_metadata if action_metadata is not None else {}
+        query = """
+            insert into moderation.moderation_actions (actor_id, action_type, target_user_id, action_metadata)
+            values ($1, $2, $3, $4)
+        """
+        async with self.write_database.get_connection() as connection:
+            await connection.execute(query, actor_id, action_type, target_user_id, metadata)
+
+    async def select_moderation_actions_strong(
+        self,
+        *,
+        actor_id: str,
+        cursor: datetime,
+        limit: int,
+    ) -> list[ModerationAction]:
+        query = """
+            select
+                id,
+                actor_id,
+                action_type,
+                target_user_id,
+                action_metadata,
+                created_at
+            from moderation.moderation_actions
+            where true
+                and actor_id = $3
+                and created_at <= $1
+            order by created_at desc
+            limit $2
+        """
+        async with self.strong_read_database.get_connection() as connection:
+            result = await connection.fetch(query, cursor, limit, actor_id)
+            return [
+                ModerationAction(
+                    id=record["id"],
+                    actor_id=record["actor_id"],
+                    action_type=ModerationActionType(record["action_type"]),
+                    target_user_id=record["target_user_id"],
+                    action_metadata=record["action_metadata"],
+                    created_at=record["created_at"],
+                )
+                for record in result
+            ]
+
+    async def select_restriction_history(
+        self,
+        *,
+        user_id: str,
+        cursor: datetime,
+        limit: int,
+    ) -> list[RestrictionHistory]:
+        query = """
+            select
+                user_id,
+                action,
+                restriction_type,
+                category,
+                reason,
+                actor_id,
+                created_at
+            from moderation.restriction_history
+            where true
+                and user_id = $1
+                and created_at <= $2
+            order by created_at desc
+            limit $3
+        """
+        async with self.read_database.get_connection() as connection:
+            result = await connection.fetch(query, user_id, cursor, limit)
+            return [
+                RestrictionHistory(
+                    user_id=record["user_id"],
+                    action=HistoryAction(record["action"]),
+                    restriction_type=RestrictionType(record["restriction_type"]),
+                    category=RestrictionCategory(record["category"]),
+                    reason=record["reason"],
+                    actor_id=record["actor_id"],
+                    created_at=record["created_at"],
+                )
+                for record in result
+            ]