core-framework 0.3.0__py3-none-any.whl

core_framework/application/posts/authenticated_service.py

@@ -0,0 +1,72 @@
+from typing import Any
+
+import core_framework.domains.moderation.dependencies as moderation_deps
+import core_framework.domains.post.dependencies as post_deps
+from core_framework.domains.moderation import ReportCategory
+from core_framework.domains.post import PostStatus, PostVisibility
+
+
+async def create_post(
+    *,
+    author_id: str,
+    content: str,
+    visibility: PostVisibility,
+    hashtags: list[str],
+) -> None:
+    await post_deps.post_service.add_post(
+        author_id=author_id,
+        content=content,
+        visibility=visibility,
+        hashtags=hashtags,
+    )
+
+
+async def edit_post(
+    *,
+    post_id: str,
+    author_id: str,
+    validated_update_request: dict[str, Any],
+) -> None:
+    await post_deps.post_service.edit_post(
+        post_id=post_id,
+        author_id=author_id,
+        validated_update_request=validated_update_request,
+    )
+
+
+async def delete_post(*, post_id: str, author_id: str) -> None:
+    await post_deps.post_service.set_post_status_for_author(
+        post_id=post_id,
+        author_id=author_id,
+        status=PostStatus.DELETED,
+    )
+
+
+async def like_post(*, post_id: str, user_id: str) -> None:
+    await post_deps.post_service.add_post_like(post_id=post_id, liker_id=user_id)
+
+
+async def unlike_post(*, post_id: str, user_id: str) -> None:
+    await post_deps.post_service.remove_post_like(post_id=post_id, liker_id=user_id)
+
+
+async def add_post_report(
+    *,
+    reporter_id: str,
+    post_id: str,
+    category: ReportCategory,
+    reason: str,
+) -> None:
+    await moderation_deps.moderation_service.add_post_report(
+        reporter_id=reporter_id,
+        target_id=post_id,
+        category=category,
+        reason=reason,
+    )
+
+
+async def remove_post_report(*, reporter_id: str, post_id: str) -> None:
+    await moderation_deps.moderation_service.remove_post_report_by_reporter(
+        reporter_id=reporter_id,
+        target_id=post_id,
+    )

core_framework/application/posts/public_service.py

@@ -0,0 +1,197 @@
+from asyncio import TaskGroup
+from collections import defaultdict
+from datetime import datetime
+from typing import Any
+
+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.post import Post, PostStats
+from core_framework.domains.user import REDACTED_AUTHOR_ID, UserIdentity
+
+
+async def _retrieve_viewer_context_ids(
+    *,
+    viewer_id: str | None,
+    post_ids: set[str],
+) -> tuple[frozenset[str] | None, frozenset[str] | None]:
+    if viewer_id is None or not post_ids:
+        return None, None
+    async with TaskGroup() as tg:
+        liked_task = tg.create_task(
+            post_deps.post_service.retrieve_post_ids_liked_by_user(
+                liker_id=viewer_id,
+                post_ids=post_ids,
+            )
+        )
+        reported_task = tg.create_task(
+            moderation_deps.moderation_service.retrieve_post_ids_reported_by_user(
+                reporter_id=viewer_id,
+                post_ids=post_ids,
+            )
+        )
+    return liked_task.result(), reported_task.result()
+
+
+def _serialize_post(
+    *,
+    post: Post,
+    post_stats_mapping: defaultdict[str, PostStats],
+    hashtags_mapping: defaultdict[str, list[str]],
+    user_identity_mapping: defaultdict[str, UserIdentity],
+    viewer_id: str | None = None,
+    liked_ids: frozenset[str] | None = None,
+    reported_ids: frozenset[str] | None = None,
+) -> dict[str, Any]:
+    stats = post_stats_mapping[post.id]
+    hashtags = hashtags_mapping[post.id]
+    author_identity = user_identity_mapping[post.author_id]
+    viewer_context = None
+    if liked_ids is not None and reported_ids is not None:
+        viewer_context = {
+            "is_liked": post.id in liked_ids,
+            "is_reported": post.id in reported_ids,
+        }
+    author_context = None
+    if viewer_id is not None and viewer_id == post.author_id:
+        author_context = {
+            "can_edit": post.edited_count < post_deps.post_service.MAX_EDIT_COUNT,
+            "can_delete": True,
+        }
+    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,
+        "stats": {
+            "like_count": stats.like_count,
+            "comment_count": stats.comment_count,
+            "view_count": stats.view_count,
+        },
+        "engagement_allowed": post.author_id != REDACTED_AUTHOR_ID,
+        "edited_at": post.edited_at,
+        "created_at": post.created_at,
+        "viewer_context": viewer_context,
+        "author_context": author_context,
+    }
+
+
+async def retrieve_post_by_id(*, post_id: str, viewer_id: str | None) -> dict[str, Any] | None:
+    post = await post_deps.post_service.retrieve_post_by_id(post_id=post_id, viewer_id=viewer_id)
+    if post is None:
+        return None
+    post_ids = {post.id}
+    async with TaskGroup() as tg:
+        liked_reported_task = tg.create_task(_retrieve_viewer_context_ids(viewer_id=viewer_id, post_ids=post_ids))
+        stats_task = tg.create_task(post_deps.post_service.retrieve_post_stats_mapping(post_ids=post_ids))
+        hashtags_task = tg.create_task(post_deps.post_service.retrieve_hashtags_mapping(post_ids=post_ids))
+        identity_task = tg.create_task(user_deps.user_service.retrieve_user_identity_mapping(user_ids={post.author_id}))
+    liked_ids, reported_ids = liked_reported_task.result()
+    return _serialize_post(
+        post=post,
+        post_stats_mapping=stats_task.result(),
+        hashtags_mapping=hashtags_task.result(),
+        user_identity_mapping=identity_task.result(),
+        viewer_id=viewer_id,
+        liked_ids=liked_ids,
+        reported_ids=reported_ids,
+    )
+
+
+async def retrieve_posts(*, viewer_id: str | None, cursor: datetime, limit: int) -> list[dict[str, Any]]:
+    posts = await post_deps.post_service.retrieve_posts(viewer_id=viewer_id, cursor=cursor, limit=limit)
+    post_ids = {post.id for post in posts}
+    author_ids = {post.author_id for post in posts}
+    async with TaskGroup() as tg:
+        liked_reported_task = tg.create_task(_retrieve_viewer_context_ids(viewer_id=viewer_id, post_ids=post_ids))
+        stats_task = tg.create_task(post_deps.post_service.retrieve_post_stats_mapping(post_ids=post_ids))
+        hashtags_task = tg.create_task(post_deps.post_service.retrieve_hashtags_mapping(post_ids=post_ids))
+        identity_task = tg.create_task(user_deps.user_service.retrieve_user_identity_mapping(user_ids=author_ids))
+    liked_ids, reported_ids = liked_reported_task.result()
+    return [
+        _serialize_post(
+            post=post,
+            post_stats_mapping=stats_task.result(),
+            hashtags_mapping=hashtags_task.result(),
+            user_identity_mapping=identity_task.result(),
+            viewer_id=viewer_id,
+            liked_ids=liked_ids,
+            reported_ids=reported_ids,
+        )
+        for post in posts
+    ]
+
+
+async def retrieve_posts_by_user_id(
+    *,
+    user_id: str,
+    viewer_id: str | None,
+    cursor: datetime,
+    limit: int,
+) -> list[dict[str, Any]]:
+    posts = await post_deps.post_service.retrieve_posts_by_user_id(
+        user_id=user_id,
+        cursor=cursor,
+        limit=limit,
+        viewer_id=viewer_id,
+    )
+    post_ids = {post.id for post in posts}
+    author_ids = {post.author_id for post in posts}
+    async with TaskGroup() as tg:
+        liked_reported_task = tg.create_task(_retrieve_viewer_context_ids(viewer_id=viewer_id, post_ids=post_ids))
+        stats_task = tg.create_task(post_deps.post_service.retrieve_post_stats_mapping(post_ids=post_ids))
+        hashtags_task = tg.create_task(post_deps.post_service.retrieve_hashtags_mapping(post_ids=post_ids))
+        identity_task = tg.create_task(user_deps.user_service.retrieve_user_identity_mapping(user_ids=author_ids))
+    liked_ids, reported_ids = liked_reported_task.result()
+    return [
+        _serialize_post(
+            post=post,
+            post_stats_mapping=stats_task.result(),
+            hashtags_mapping=hashtags_task.result(),
+            user_identity_mapping=identity_task.result(),
+            viewer_id=viewer_id,
+            liked_ids=liked_ids,
+            reported_ids=reported_ids,
+        )
+        for post in posts
+    ]
+
+
+async def retrieve_posts_by_hashtag(
+    *,
+    hashtag: str,
+    viewer_id: str | None,
+    cursor: datetime,
+    limit: int,
+) -> list[dict[str, Any]]:
+    posts = await post_deps.post_service.retrieve_posts_by_hashtag(
+        hashtag=hashtag,
+        cursor=cursor,
+        limit=limit,
+        viewer_id=viewer_id,
+    )
+    post_ids = {post.id for post in posts}
+    author_ids = {post.author_id for post in posts}
+    async with TaskGroup() as tg:
+        liked_reported_task = tg.create_task(_retrieve_viewer_context_ids(viewer_id=viewer_id, post_ids=post_ids))
+        stats_task = tg.create_task(post_deps.post_service.retrieve_post_stats_mapping(post_ids=post_ids))
+        hashtags_task = tg.create_task(post_deps.post_service.retrieve_hashtags_mapping(post_ids=post_ids))
+        identity_task = tg.create_task(user_deps.user_service.retrieve_user_identity_mapping(user_ids=author_ids))
+    liked_ids, reported_ids = liked_reported_task.result()
+    return [
+        _serialize_post(
+            post=post,
+            post_stats_mapping=stats_task.result(),
+            hashtags_mapping=hashtags_task.result(),
+            user_identity_mapping=identity_task.result(),
+            viewer_id=viewer_id,
+            liked_ids=liked_ids,
+            reported_ids=reported_ids,
+        )
+        for post in posts
+    ]

core_framework/application/shared/enums.py

@@ -0,0 +1,16 @@
+from enum import StrEnum
+
+
+class EventType(StrEnum):
+    LOGIN = "login"
+    VIEW = "view"
+
+
+class SubjectType(StrEnum):
+    POST = "post"
+    USER = "user"
+
+
+class RedisKeys(StrEnum):
+    TAKEN_USERNAMES = "taken_usernames"
+    USER_DETAIL = "user_detail"

core_framework/application/shared/exceptions.py

@@ -0,0 +1,16 @@
+class UnauthorizedException(Exception):
+    def __init__(self, message: str = "Unauthorized"):
+        self.message = message
+        super().__init__(self.message)
+
+
+class ForbiddenException(Exception):
+    def __init__(self, message: str = "Forbidden"):
+        self.message = message
+        super().__init__(self.message)
+
+
+class UserNotFoundException(Exception):
+    def __init__(self, message: str = "User not found"):
+        self.message = message
+        super().__init__(self.message)

core_framework/application/shared/user_agent.py

@@ -0,0 +1,24 @@
+from typing import Final
+
+from device_detector import DeviceDetector
+
+MAX_METADATA_STRING_LENGTH: Final[int] = 32
+
+
+def parse_user_agent(user_agent: str | None) -> dict[str, str]:
+    result: dict[str, str] = {}
+    if not user_agent or not user_agent.strip():
+        return result
+    dd = DeviceDetector(user_agent).parse()
+    device = dd.device_type()
+    if device is not None:
+        raw = str(device)
+        if raw:
+            result["client_type"] = raw[:MAX_METADATA_STRING_LENGTH]
+    client_name = dd.client_name()
+    if client_name:
+        result["browser_name"] = client_name[:MAX_METADATA_STRING_LENGTH]
+    os_name = dd.os_name()
+    if os_name:
+        result["os_name"] = os_name[:MAX_METADATA_STRING_LENGTH]
+    return result

core_framework/application/users/admin_service.py

@@ -0,0 +1,298 @@
+import asyncio
+from contextlib import suppress
+from datetime import datetime
+from typing import Any
+
+from async_lru import alru_cache
+from asyncer import asyncify
+from firebase_admin import auth
+from loguru import logger
+from tenacity import retry, retry_if_exception_type, stop_after_attempt
+
+import core_framework.core as core_fw
+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 InternalNote, ModerationActionType, UserModeration
+from core_framework.domains.user import UserIdentity, UserRole, UserWithProfile
+
+
+# User Queries
+@alru_cache(ttl=3600)  # 1 hour
+async def retrieve_admin_user_ids() -> set[str]:
+    return await user_deps.user_service.retrieve_admin_user_ids()
+
+
+async def retrieve_users(
+    *,
+    cursor: datetime,
+    limit: int,
+    username: str | None = None,
+    role: UserRole | None = None,
+) -> list[UserIdentity]:
+    return await user_deps.user_service.retrieve_user_identities(
+        username=username,
+        role=role,
+        cursor=cursor,
+        limit=limit,
+    )
+
+
+async def retrieve_user_detail(*, user_id: str) -> dict[str, Any]:
+    user_data, moderation = await _concurrent_get_user_and_moderation(user_id=user_id)
+
+    if user_data is None:
+        raise UserNotFoundException()
+
+    email: str | None = None
+    email_verified: bool = False
+    with suppress(auth.UserNotFoundError):
+        firebase_user = await asyncify(auth.get_user)(user_id)
+        email = firebase_user.email
+        email_verified = firebase_user.email_verified
+
+    return {
+        "account": {
+            "user_id": user_id,
+            "username": user_data.identity.username,
+            "role": user_data.identity.role,
+            "email": email,
+            "email_verified": email_verified,
+            "deletion_scheduled_for": user_data.deletion_scheduled_for,
+        },
+        "profile": user_data.profile,
+        "moderation": {
+            "restriction": moderation.restriction,
+            "notes": moderation.notes,
+        },
+    }
+
+
+async def _concurrent_get_user_and_moderation(*, user_id: str) -> tuple[UserWithProfile | None, UserModeration]:
+    async with asyncio.TaskGroup() as tg:
+        user_task = tg.create_task(user_deps.user_service.retrieve_user_for_detail(user_id=user_id))
+        moderation_task = tg.create_task(
+            moderation_deps.moderation_service.retrieve_user_moderation_for_detail(user_id=user_id)
+        )
+    return user_task.result(), moderation_task.result()
+
+
+async def retrieve_user_notes(
+    *,
+    user_id: str,
+    cursor: datetime,
+    limit: int,
+) -> list[dict[str, Any]]:
+    notes = await moderation_deps.moderation_service.retrieve_internal_notes_paginated(
+        target_user_id=user_id,
+        cursor=cursor,
+        limit=limit,
+    )
+    actor_ids = {note.actor_id for note in notes}
+    user_identity_mapping = await user_deps.user_service.retrieve_user_identity_mapping(user_ids=actor_ids)
+    return [
+        {
+            "id": note.id,
+            "content": note.content,
+            "created_at": note.created_at,
+            "actor": {
+                "user_id": note.actor_id,
+                "username": user_identity_mapping[note.actor_id].username,
+                "display_name": user_identity_mapping[note.actor_id].display_name,
+            },
+        }
+        for note in notes
+    ]
+
+
+async def retrieve_user_history(
+    *,
+    user_id: str,
+    cursor: datetime,
+    limit: int,
+) -> list[dict[str, Any]]:
+    history = await user_deps.user_service.retrieve_user_change_history(
+        user_id=user_id,
+        cursor=cursor,
+        limit=limit,
+    )
+    actor_ids = {entry.actor_id for entry in 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,
+            "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,
+            "entity_type": entry.entity_type,
+            "field": entry.field,
+            "old_value": entry.old_value,
+            "new_value": entry.new_value,
+            "created_at": entry.created_at,
+        }
+        for entry in history
+    ]
+
+
+# User Management
+async def change_user_username(
+    *,
+    actor_id: str,
+    user_id: str,
+    new_username: str,
+) -> None:
+    identity = await user_deps.user_service.retrieve_user_identity_strong(user_id=user_id)
+    if identity == UserIdentity.DEFAULT:
+        raise UserNotFoundException()
+    if identity.username == new_username:
+        return
+    await user_deps.user_service.change_account(
+        actor_id=actor_id,
+        user_id=user_id,
+        validated_update_request={"username": new_username},
+    )
+    await moderation_deps.moderation_service.record_moderation_action(
+        actor_id=actor_id,
+        action_type=ModerationActionType.CHANGE_USERNAME,
+        target_user_id=user_id,
+        action_metadata={"old_username": identity.username, "new_username": new_username},
+    )
+    await core_fw.redis_cache.sadd(RedisKeys.TAKEN_USERNAMES, new_username)
+    await invalidate_cache(RedisKeys.USER_DETAIL, user_id=user_id)
+
+
+async def change_user_role(
+    *,
+    actor_id: str,
+    user_id: str,
+    new_role: 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 role cannot be changed via API")
+    if identity.role == new_role:
+        return
+    await user_deps.user_service.change_user_role(
+        actor_id=actor_id,
+        user_id=user_id,
+        role=new_role,
+    )
+    await moderation_deps.moderation_service.record_moderation_action(
+        actor_id=actor_id,
+        action_type=ModerationActionType.CHANGE_ROLE,
+        target_user_id=user_id,
+        action_metadata={"old_role": identity.role.value, "new_role": new_role},
+    )
+    await invalidate_cache(RedisKeys.USER_DETAIL, user_id=user_id)
+
+
+async def change_user_profile(
+    *,
+    actor_id: str,
+    user_id: str,
+    validated_update_request: dict[str, Any],
+) -> None:
+    if not validated_update_request:
+        return
+    current_profile = await user_deps.user_service.retrieve_profile_optional_strong(user_id=user_id)
+    if current_profile is None:
+        raise UserNotFoundException()
+    actual_changes = {
+        field: value
+        for field, value in validated_update_request.items()
+        if getattr(current_profile, field, None) != value
+    }
+    if not actual_changes:
+        return
+    await user_deps.user_service.change_profile(
+        actor_id=actor_id,
+        user_id=user_id,
+        validated_update_request=actual_changes,
+    )
+    await moderation_deps.moderation_service.record_moderation_action(
+        actor_id=actor_id,
+        action_type=ModerationActionType.CHANGE_PROFILE,
+        target_user_id=user_id,
+        action_metadata={"fields": list(actual_changes.keys())},
+    )
+    await invalidate_cache(RedisKeys.USER_DETAIL, user_id=user_id)
+
+
+async def add_user_note(*, actor_id: str, user_id: str, content: str) -> InternalNote:
+    identity = await user_deps.user_service.retrieve_user_identity_strong(user_id=user_id)
+    if identity == UserIdentity.DEFAULT:
+        raise UserNotFoundException()
+    note = await moderation_deps.moderation_service.add_internal_note(
+        actor_id=actor_id,
+        target_user_id=user_id,
+        content=content,
+    )
+    await moderation_deps.moderation_service.record_moderation_action(
+        actor_id=actor_id,
+        action_type=ModerationActionType.ADD_NOTE,
+        target_user_id=user_id,
+        action_metadata={"note_id": note.id, "content": content},
+    )
+    return note
+
+
+async def remove_user_note(*, actor_id: str, user_id: str, note_id: int) -> None:
+    note = await moderation_deps.moderation_service.retrieve_internal_note_strong(
+        note_id=note_id,
+        target_user_id=user_id,
+    )
+    if note is None:
+        return
+    await moderation_deps.moderation_service.remove_internal_note(
+        note_id=note_id,
+        target_user_id=user_id,
+    )
+    await moderation_deps.moderation_service.record_moderation_action(
+        actor_id=actor_id,
+        action_type=ModerationActionType.DELETE_NOTE,
+        target_user_id=user_id,
+        action_metadata={"note_id": note_id, "content": note.content},
+    )
+
+
+async def remove_user(*, actor_id: str, user_id: str) -> None:
+    try:
+        identity = await user_deps.user_service.retrieve_user_identity_strong(user_id=user_id)
+        await _remove_user(user_id=user_id)
+        await invalidate_cache(RedisKeys.USER_DETAIL, user_id=user_id)
+        if identity != UserIdentity.DEFAULT:
+            await moderation_deps.moderation_service.record_moderation_action(
+                actor_id=actor_id,
+                action_type=ModerationActionType.DELETE_USER,
+                target_user_id=user_id,
+                action_metadata={"username": identity.username},
+            )
+    except Exception as e:
+        logger.error(f"Error removing user {user_id=}: {e}")
+        raise
+
+
+@retry(
+    stop=stop_after_attempt(3),
+    retry=retry_if_exception_type(Exception),
+    reraise=True,
+)
+async def _remove_user(*, user_id: str) -> None:
+    await moderation_deps.moderation_service.remove_user(user_id=user_id)
+    await comment_deps.comment_service.remove_user(user_id=user_id)
+    await post_deps.post_service.remove_user(user_id=user_id)
+    await user_deps.user_service.remove_user(user_id=user_id)
+    try:
+        await asyncify(auth.revoke_refresh_tokens)(user_id)
+    except Exception as e:
+        logger.error(f"Failed to revoke refresh tokens for deleted user {user_id=}: {e}")