core-framework 0.3.0__py3-none-any.whl

core_framework/application/events/models.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass
+
+from core_framework.application.shared.enums import SubjectType
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class Event:
+    subject_type: SubjectType
+    subject: str

core_framework/application/moderation/appeal_service.py

@@ -0,0 +1,98 @@
+from datetime import datetime
+from typing import Any
+
+from loguru import logger
+
+import core_framework.domains.moderation.dependencies as moderation_deps
+import core_framework.domains.user.dependencies as user_deps
+from core_framework.application.moderation.user_service import clear_user_restriction
+from core_framework.domains.moderation import AppealDecision, ModerationActionType
+
+
+async def decide_appeal(
+    *,
+    actor_id: str,
+    appeal_id: int,
+    decision: AppealDecision,
+    reason: str,
+) -> dict[str, Any]:
+    raw_appeal = await moderation_deps.moderation_service.decide_appeal(
+        actor_id=actor_id,
+        appeal_id=appeal_id,
+        decision=decision,
+        reason=reason,
+    )
+    await moderation_deps.moderation_service.record_moderation_action(
+        actor_id=actor_id,
+        action_type=ModerationActionType.DECIDE_APPEAL,
+        target_user_id=raw_appeal.user_id,
+        action_metadata={
+            "appeal_id": raw_appeal.id,
+            "decision": decision,
+            "reason": reason,
+        },
+    )
+    user_ids = {raw_appeal.user_id} if raw_appeal.reviewer_id is None else {raw_appeal.user_id, raw_appeal.reviewer_id}
+    user_identity_mapping = await user_deps.user_service.retrieve_user_identity_mapping(user_ids=user_ids)
+
+    if raw_appeal.status == AppealDecision.APPROVED:
+        try:
+            await clear_user_restriction(actor_id=actor_id, user_id=raw_appeal.user_id)
+        except Exception as e:
+            logger.error(f"Failed to clear restriction after appeal approval {appeal_id=} {raw_appeal.user_id=}: {e}")
+
+    return {
+        "id": raw_appeal.id,
+        "user": {
+            "user_id": raw_appeal.user_id,
+            "username": user_identity_mapping[raw_appeal.user_id].username,
+            "display_name": user_identity_mapping[raw_appeal.user_id].display_name,
+        },
+        "justification": raw_appeal.justification,
+        "reviewer": {
+            "user_id": raw_appeal.reviewer_id,
+            "username": user_identity_mapping[raw_appeal.reviewer_id].username,
+            "display_name": user_identity_mapping[raw_appeal.reviewer_id].display_name,
+        }
+        if raw_appeal.reviewer_id is not None
+        else None,
+        "decision_reason": raw_appeal.decision_reason,
+        "status": raw_appeal.status,
+        "created_at": raw_appeal.created_at,
+        "updated_at": raw_appeal.updated_at,
+    }
+
+
+async def retrieve_appeals(*, status: AppealDecision | None, cursor: datetime, limit: int) -> list[dict[str, Any]]:
+    raw_appeals = await moderation_deps.moderation_service.retrieve_appeals(
+        status=status,
+        cursor=cursor,
+        limit=limit,
+    )
+    user_ids = {appeal.user_id for appeal in raw_appeals} | {
+        appeal.reviewer_id for appeal in raw_appeals if appeal.reviewer_id is not None
+    }
+    user_identity_mapping = await user_deps.user_service.retrieve_user_identity_mapping(user_ids=user_ids)
+    return [
+        {
+            "id": appeal.id,
+            "user": {
+                "user_id": appeal.user_id,
+                "username": user_identity_mapping[appeal.user_id].username,
+                "display_name": user_identity_mapping[appeal.user_id].display_name,
+            },
+            "justification": appeal.justification,
+            "reviewer": {
+                "user_id": appeal.reviewer_id,
+                "username": user_identity_mapping[appeal.reviewer_id].username,
+                "display_name": user_identity_mapping[appeal.reviewer_id].display_name,
+            }
+            if appeal.reviewer_id is not None
+            else None,
+            "decision_reason": appeal.decision_reason,
+            "status": appeal.status,
+            "created_at": appeal.created_at,
+            "updated_at": appeal.updated_at,
+        }
+        for appeal in raw_appeals
+    ]

core_framework/application/moderation/moderator_service.py

@@ -0,0 +1,46 @@
+from datetime import datetime
+from typing import Any
+
+import core_framework.domains.moderation.dependencies as moderation_deps
+import core_framework.domains.user.dependencies as user_deps
+
+
+async def retrieve_moderation_actions_strong(
+    *,
+    actor_id: str,
+    cursor: datetime,
+    limit: int,
+) -> list[dict[str, Any]]:
+    actions = await moderation_deps.moderation_service.retrieve_moderation_actions_strong(
+        actor_id=actor_id,
+        cursor=cursor,
+        limit=limit,
+    )
+    actor_ids = {action.actor_id for action in actions}
+    target_user_ids = {action.target_user_id for action in actions if action.target_user_id is not None}
+    user_ids = actor_ids | target_user_ids
+    user_identity_mapping = await user_deps.user_service.retrieve_user_identity_mapping(user_ids=user_ids)
+
+    return [
+        {
+            "id": action.id,
+            "actor": {
+                "user_id": action.actor_id,
+                "username": user_identity_mapping[action.actor_id].username,
+                "display_name": user_identity_mapping[action.actor_id].display_name,
+            },
+            "target_user": (
+                {
+                    "user_id": action.target_user_id,
+                    "username": user_identity_mapping[action.target_user_id].username,
+                    "display_name": user_identity_mapping[action.target_user_id].display_name,
+                }
+                if action.target_user_id is not None
+                else None
+            ),
+            "action_type": action.action_type,
+            "action_metadata": action.action_metadata,
+            "created_at": action.created_at,
+        }
+        for action in actions
+    ]

core_framework/application/moderation/report_service.py

@@ -0,0 +1,180 @@
+from asyncio import TaskGroup
+from datetime import datetime
+from typing import Any
+
+import core_framework.domains.comment.dependencies as comment_deps
+import core_framework.domains.moderation.dependencies as moderation_deps
+import core_framework.domains.post.dependencies as post_deps
+import core_framework.domains.user.dependencies as user_deps
+from core_framework.domains.moderation import Report, ReportType
+
+
+def _build_report_item(
+    report: Report,
+    report_type: ReportType,
+    reporter: dict[str, Any],
+    preview: list[dict[str, str]],
+) -> dict[str, Any]:
+    return {
+        "type": report_type.value,
+        "id": report.id,
+        "reporter": reporter,
+        "target_id": report.target_id,
+        "category": report.category,
+        "reason": report.reason,
+        "created_at": report.created_at,
+        "preview": preview,
+    }
+
+
+async def _retrieve_user_reports(
+    *,
+    reporter_id: str | None,
+    target_id: str | None,
+    cursor: datetime,
+    limit: int,
+) -> list[dict[str, Any]]:
+    raw_reports = await moderation_deps.moderation_service.retrieve_user_reports(
+        reporter_id=reporter_id,
+        target_id=target_id,
+        cursor=cursor,
+        limit=limit,
+    )
+    if not raw_reports:
+        return []
+
+    reporter_ids = {r.reporter_id for r in raw_reports}
+    target_ids = {r.target_id for r in raw_reports}
+    user_identity_mapping = await user_deps.user_service.retrieve_user_identity_mapping(
+        user_ids=reporter_ids | target_ids
+    )
+
+    result: list[dict[str, Any]] = []
+    for report in raw_reports:
+        reporter_identity = user_identity_mapping[report.reporter_id]
+        reporter = {
+            "user_id": report.reporter_id,
+            "username": reporter_identity.username,
+            "display_name": reporter_identity.display_name,
+        }
+        target_identity = user_identity_mapping[report.target_id]
+        preview = [
+            {"key": "username", "value": target_identity.username},
+            {"key": "display_name", "value": target_identity.display_name or ""},
+            {"key": "role", "value": target_identity.role.value},
+        ]
+        result.append(_build_report_item(report, ReportType.USER, reporter, preview))
+
+    return result
+
+
+async def _retrieve_post_reports(
+    *,
+    reporter_id: str | None,
+    target_id: str | None,
+    cursor: datetime,
+    limit: int,
+) -> list[dict[str, Any]]:
+    raw_reports = await moderation_deps.moderation_service.retrieve_post_reports(
+        reporter_id=reporter_id,
+        target_id=target_id,
+        cursor=cursor,
+        limit=limit,
+    )
+    if not raw_reports:
+        return []
+
+    reporter_ids = {r.reporter_id for r in raw_reports}
+    target_ids = {r.target_id for r in raw_reports}
+    async with TaskGroup() as tg:
+        identity_task = tg.create_task(user_deps.user_service.retrieve_user_identity_mapping(user_ids=reporter_ids))
+        content_task = tg.create_task(post_deps.post_service.retrieve_post_content_mapping(post_ids=target_ids))
+    user_identity_mapping = identity_task.result()
+    post_content_mapping = content_task.result()
+
+    result: list[dict[str, Any]] = []
+    for report in raw_reports:
+        reporter_identity = user_identity_mapping[report.reporter_id]
+        reporter = {
+            "user_id": report.reporter_id,
+            "username": reporter_identity.username,
+            "display_name": reporter_identity.display_name,
+        }
+        content = post_content_mapping[report.target_id]
+        preview = [{"key": "post_content", "value": content}]
+        result.append(_build_report_item(report, ReportType.POST, reporter, preview))
+
+    return result
+
+
+async def _retrieve_comment_reports(
+    *,
+    reporter_id: str | None,
+    target_id: str | None,
+    cursor: datetime,
+    limit: int,
+) -> list[dict[str, Any]]:
+    raw_reports = await moderation_deps.moderation_service.retrieve_comment_reports(
+        reporter_id=reporter_id,
+        target_id=target_id,
+        cursor=cursor,
+        limit=limit,
+    )
+    if not raw_reports:
+        return []
+
+    reporter_ids = {r.reporter_id for r in raw_reports}
+    target_ids = {r.target_id for r in raw_reports}
+    async with TaskGroup() as tg:
+        identity_task = tg.create_task(user_deps.user_service.retrieve_user_identity_mapping(user_ids=reporter_ids))
+        content_task = tg.create_task(
+            comment_deps.comment_service.retrieve_comment_content_mapping(comment_ids=target_ids)
+        )
+    user_identity_mapping = identity_task.result()
+    comment_content_mapping = content_task.result()
+
+    result: list[dict[str, Any]] = []
+    for report in raw_reports:
+        reporter_identity = user_identity_mapping[report.reporter_id]
+        reporter = {
+            "user_id": report.reporter_id,
+            "username": reporter_identity.username,
+            "display_name": reporter_identity.display_name,
+        }
+        content = comment_content_mapping[report.target_id]
+        preview = [{"key": "comment_content", "value": content}]
+        result.append(_build_report_item(report, ReportType.COMMENT, reporter, preview))
+
+    return result
+
+
+async def retrieve_reports(
+    *,
+    report_type: ReportType,
+    reporter_id: str | None,
+    target_id: str | None,
+    cursor: datetime,
+    limit: int,
+) -> list[dict[str, Any]]:
+    match report_type:
+        case ReportType.USER:
+            return await _retrieve_user_reports(
+                reporter_id=reporter_id,
+                target_id=target_id,
+                cursor=cursor,
+                limit=limit,
+            )
+        case ReportType.POST:
+            return await _retrieve_post_reports(
+                reporter_id=reporter_id,
+                target_id=target_id,
+                cursor=cursor,
+                limit=limit,
+            )
+        case ReportType.COMMENT:
+            return await _retrieve_comment_reports(
+                reporter_id=reporter_id,
+                target_id=target_id,
+                cursor=cursor,
+                limit=limit,
+            )

core_framework/application/moderation/scheduled_service.py

@@ -0,0 +1,5 @@
+import core_framework.domains.moderation.dependencies as moderation_deps
+
+
+async def retrieve_expired_mute_user_ids() -> list[str]:
+    return await moderation_deps.moderation_service.retrieve_expired_mute_user_ids()

core_framework/application/moderation/user_service.py

@@ -0,0 +1,180 @@
+from asyncio import TaskGroup
+from datetime import datetime
+from typing import Any
+
+import core_framework.domains.comment.dependencies as comment_deps
+import core_framework.domains.moderation.dependencies as moderation_deps
+import core_framework.domains.post.dependencies as post_deps
+import core_framework.domains.user.dependencies as user_deps
+from core_framework.application.shared.enums import RedisKeys
+from core_framework.application.shared.exceptions import ForbiddenException, UserNotFoundException
+from core_framework.core.cache import invalidate_cache
+from core_framework.domains.moderation import ModerationActionType, RestrictionCategory, RestrictionType
+from core_framework.domains.user import UserIdentity, UserRole
+
+
+async def ban_user(
+    *,
+    actor_id: str,
+    user_id: str,
+    category: RestrictionCategory,
+    reason: str,
+) -> None:
+    identity = await user_deps.user_service.retrieve_user_identity_strong(user_id=user_id)
+    if identity == UserIdentity.DEFAULT:
+        raise UserNotFoundException()
+    if identity.role == UserRole.ADMIN:
+        raise ForbiddenException("Admin users cannot be banned")
+    restriction = await moderation_deps.moderation_service.retrieve_user_restriction_strong(user_id=user_id)
+    if restriction.status == RestrictionType.BANNED:
+        await _sync_user_restriction_lookups(user_id=user_id, restriction_status=restriction.status)
+        return
+    await moderation_deps.moderation_service.ban_user(
+        actor_id=actor_id,
+        user_id=user_id,
+        reason=reason,
+        category=category,
+    )
+    await _sync_user_restriction_lookups(user_id=user_id, restriction_status=RestrictionType.BANNED)
+    await moderation_deps.moderation_service.record_moderation_action(
+        actor_id=actor_id,
+        action_type=ModerationActionType.BAN,
+        target_user_id=user_id,
+        action_metadata={"reason": reason, "category": category},
+    )
+    await invalidate_cache(RedisKeys.USER_DETAIL, user_id=user_id)
+
+
+async def mute_user(*, actor_id: str, user_id: str, category: RestrictionCategory, reason: str) -> None:
+    identity = await user_deps.user_service.retrieve_user_identity_strong(user_id=user_id)
+    if identity == UserIdentity.DEFAULT:
+        raise UserNotFoundException()
+    restriction = await moderation_deps.moderation_service.retrieve_user_restriction_strong(user_id=user_id)
+    if restriction.status in (RestrictionType.MUTED, RestrictionType.BANNED):
+        await _sync_user_restriction_lookups(user_id=user_id, restriction_status=restriction.status)
+        return
+    await moderation_deps.moderation_service.mute_user(
+        actor_id=actor_id,
+        user_id=user_id,
+        reason=reason,
+        category=category,
+    )
+    await _sync_user_restriction_lookups(user_id=user_id, restriction_status=RestrictionType.MUTED)
+    await moderation_deps.moderation_service.record_moderation_action(
+        actor_id=actor_id,
+        action_type=ModerationActionType.MUTE,
+        target_user_id=user_id,
+        action_metadata={"reason": reason, "category": category},
+    )
+    await invalidate_cache(RedisKeys.USER_DETAIL, user_id=user_id)
+
+
+async def warn_user(*, actor_id: str, user_id: str, category: RestrictionCategory, reason: str) -> None:
+    identity = await user_deps.user_service.retrieve_user_identity_strong(user_id=user_id)
+    if identity == UserIdentity.DEFAULT:
+        raise UserNotFoundException()
+    restriction = await moderation_deps.moderation_service.retrieve_user_restriction_strong(user_id=user_id)
+    if restriction.status in (RestrictionType.WARNED, RestrictionType.MUTED, RestrictionType.BANNED):
+        await _sync_user_restriction_lookups(user_id=user_id, restriction_status=restriction.status)
+        return
+    await moderation_deps.moderation_service.warn_user(
+        actor_id=actor_id,
+        user_id=user_id,
+        reason=reason,
+        category=category,
+    )
+    await _sync_user_restriction_lookups(user_id=user_id, restriction_status=RestrictionType.WARNED)
+    await moderation_deps.moderation_service.record_moderation_action(
+        actor_id=actor_id,
+        action_type=ModerationActionType.WARN,
+        target_user_id=user_id,
+        action_metadata={"reason": reason, "category": category},
+    )
+    await invalidate_cache(RedisKeys.USER_DETAIL, user_id=user_id)
+
+
+async def clear_user_restriction(*, actor_id: str, user_id: str) -> None:
+    identity = await user_deps.user_service.retrieve_user_identity_strong(user_id=user_id)
+    if identity == UserIdentity.DEFAULT:
+        raise UserNotFoundException()
+    restriction = await moderation_deps.moderation_service.retrieve_user_restriction_strong(user_id=user_id)
+    if restriction.status == RestrictionType.ACTIVE:
+        await _sync_user_restriction_lookups(user_id=user_id, restriction_status=restriction.status)
+        return
+    await moderation_deps.moderation_service.clear_user_restriction(actor_id=actor_id, user_id=user_id)
+    await _sync_user_restriction_lookups(user_id=user_id, restriction_status=RestrictionType.ACTIVE)
+    await moderation_deps.moderation_service.record_moderation_action(
+        actor_id=actor_id,
+        action_type=ModerationActionType.UNRESTRICT,
+        target_user_id=user_id,
+    )
+    await invalidate_cache(RedisKeys.USER_DETAIL, user_id=user_id)
+
+
+async def remove_user_report(*, report_id: int) -> None:
+    await moderation_deps.moderation_service.remove_user_report(report_id=report_id)
+
+
+async def remove_post_report(*, report_id: int) -> None:
+    await moderation_deps.moderation_service.remove_post_report(report_id=report_id)
+
+
+async def remove_comment_report(*, report_id: int) -> None:
+    await moderation_deps.moderation_service.remove_comment_report(report_id=report_id)
+
+
+async def retrieve_restriction_history(
+    *,
+    user_id: str,
+    cursor: datetime,
+    limit: int,
+) -> list[dict[str, Any]]:
+    restriction_history = await moderation_deps.moderation_service.retrieve_restriction_history(
+        user_id=user_id,
+        cursor=cursor,
+        limit=limit,
+    )
+    actor_ids = {entry.actor_id for entry in restriction_history if entry.actor_id is not None}
+    user_identity_mapping = await user_deps.user_service.retrieve_user_identity_mapping(user_ids=actor_ids)
+    return [
+        {
+            "user_id": entry.user_id,
+            "action": entry.action,
+            "restriction_type": entry.restriction_type,
+            "category": entry.category,
+            "reason": entry.reason,
+            "actor": {
+                "user_id": entry.actor_id,
+                "username": user_identity_mapping[entry.actor_id].username,
+                "display_name": user_identity_mapping[entry.actor_id].display_name,
+            }
+            if entry.actor_id is not None
+            else None,
+            "created_at": entry.created_at,
+        }
+        for entry in restriction_history
+    ]
+
+
+async def _sync_user_restriction_lookups(*, user_id: str, restriction_status: RestrictionType) -> None:
+    # Keep post- and comment-domain lookups aligned with moderation truth, including no-op
+    # moderation calls (early returns) so retries can heal cross-domain drift from prior partial failures.
+    if restriction_status in (RestrictionType.MUTED, RestrictionType.BANNED):
+        restriction_type = restriction_status.value
+        async with TaskGroup() as tg:
+            tg.create_task(
+                post_deps.post_service.add_user_restriction_lookup(
+                    user_id=user_id,
+                    restriction_type=restriction_type,
+                )
+            )
+            tg.create_task(
+                comment_deps.comment_service.add_user_restriction_lookup(
+                    user_id=user_id,
+                    restriction_type=restriction_type,
+                )
+            )
+        return
+    async with TaskGroup() as tg:
+        tg.create_task(post_deps.post_service.remove_user_restriction_lookup(user_id=user_id))
+        tg.create_task(comment_deps.comment_service.remove_user_restriction_lookup(user_id=user_id))

core_framework/application/posts/admin_service.py

@@ -0,0 +1,104 @@
+from asyncio import TaskGroup
+from collections import defaultdict
+from datetime import datetime
+from typing import Any
+
+import core_framework.domains.comment.dependencies as comment_deps
+import core_framework.domains.moderation.dependencies as moderation_deps
+import core_framework.domains.post.dependencies as post_deps
+import core_framework.domains.user.dependencies as user_deps
+from core_framework.domains.comment import CommentSubjectType
+from core_framework.domains.post import PostStats, PostStatus, PostWithMetadata
+from core_framework.domains.user import UserIdentity
+
+
+def _serialize_post(
+    post: PostWithMetadata,
+    post_stats_mapping: defaultdict[str, PostStats],
+    hashtags_mapping: defaultdict[str, list[str]],
+    user_identity_mapping: defaultdict[str, UserIdentity],
+) -> dict[str, Any]:
+    stats = post_stats_mapping[post.id]
+    hashtags = hashtags_mapping[post.id]
+    author_identity = user_identity_mapping[post.author_id]
+    return {
+        "id": post.id,
+        "author": {
+            "user_id": post.author_id,
+            "username": author_identity.username,
+            "display_name": author_identity.display_name,
+        },
+        "content": post.content,
+        "hashtags": hashtags,
+        "visibility": post.visibility,
+        "status": post.status,
+        "edited_count": post.edited_count,
+        "stats": {
+            "like_count": stats.like_count,
+            "comment_count": stats.comment_count,
+            "view_count": stats.view_count,
+            "report_count": stats.report_count,
+        },
+        "edited_at": post.edited_at,
+        "created_at": post.created_at,
+    }
+
+
+async def retrieve_all_posts(*, cursor: datetime, limit: int) -> list[dict[str, Any]]:
+    posts = await post_deps.post_service.retrieve_posts_unfiltered(cursor=cursor, limit=limit)
+    post_ids_set = {post.id for post in posts}
+    author_ids = {post.author_id for post in posts}
+    async with TaskGroup() as tg:
+        stats_task = tg.create_task(post_deps.post_service.retrieve_post_stats_mapping(post_ids=post_ids_set))
+        hashtags_task = tg.create_task(post_deps.post_service.retrieve_hashtags_mapping(post_ids=post_ids_set))
+        identity_task = tg.create_task(user_deps.user_service.retrieve_user_identity_mapping(user_ids=author_ids))
+    return [
+        _serialize_post(
+            post,
+            stats_task.result(),
+            hashtags_task.result(),
+            identity_task.result(),
+        )
+        for post in posts
+    ]
+
+
+async def retrieve_post_by_id(*, post_id: str) -> dict[str, Any]:
+    post = await post_deps.post_service.retrieve_post_with_metadata_by_id(post_id=post_id)
+    post_ids_set = {post.id}
+    author_ids = {post.author_id}
+    async with TaskGroup() as tg:
+        stats_task = tg.create_task(post_deps.post_service.retrieve_post_stats_mapping(post_ids=post_ids_set))
+        hashtags_task = tg.create_task(post_deps.post_service.retrieve_hashtags_mapping(post_ids=post_ids_set))
+        identity_task = tg.create_task(user_deps.user_service.retrieve_user_identity_mapping(user_ids=author_ids))
+    return _serialize_post(
+        post,
+        stats_task.result(),
+        hashtags_task.result(),
+        identity_task.result(),
+    )
+
+
+async def set_post_inactive(*, post_id: str) -> None:
+    await post_deps.post_service.set_post_status_by_id(post_id=post_id, status=PostStatus.DELETED)
+
+
+async def restore_post(post_id: str) -> None:
+    await post_deps.post_service.set_post_status_by_id(post_id=post_id, status=PostStatus.ACTIVE)
+
+
+async def remove_post(*, post_id: str) -> None:
+    comment_ids = await comment_deps.comment_service.retrieve_comment_ids_by_subject_strong(
+        subject_type=CommentSubjectType.POST,
+        subject_id=post_id,
+    )
+    async with TaskGroup() as tg:
+        tg.create_task(moderation_deps.moderation_service.remove_post_reports_by_target_id(target_id=post_id))
+        tg.create_task(moderation_deps.moderation_service.remove_comment_reports_by_target_ids(target_ids=comment_ids))
+        tg.create_task(
+            comment_deps.comment_service.remove_comments_by_subject(
+                subject_type=CommentSubjectType.POST,
+                subject_id=post_id,
+            )
+        )
+    await post_deps.post_service.delete_post_by_id(post_id=post_id)

core_framework/application/posts/aggregation_service.py

@@ -0,0 +1,28 @@
+from asyncio import TaskGroup
+
+import core_framework.domains.comment.dependencies as comment_deps
+import core_framework.domains.moderation.dependencies as moderation_deps
+import core_framework.domains.post.dependencies as post_deps
+
+
+async def aggregate_post_view_counts() -> list[str]:
+    return await post_deps.post_service.aggregate_post_view_counts()
+
+
+async def aggregate_post_stats(*, post_id: str) -> None:
+    async with TaskGroup() as tg:
+        like_task = tg.create_task(post_deps.post_service.retrieve_post_like_count(post_id=post_id))
+        report_task = tg.create_task(moderation_deps.moderation_service.retrieve_post_report_count(post_id=post_id))
+        comment_count_task = tg.create_task(comment_deps.comment_service.retrieve_post_comment_count(post_id=post_id))
+
+    counts = {
+        "like_count": like_task.result(),
+        "comment_count": comment_count_task.result(),
+        "report_count": report_task.result(),
+    }
+    await post_deps.post_service.update_post_stats(
+        post_id=post_id,
+        like_count=counts["like_count"],
+        comment_count=counts["comment_count"],
+        report_count=counts["report_count"],
+    )