+from abc import ABC, abstractmethod

+

+class UserRepository(ABC):

+    @abstractmethod

+    def add(self, user): pass

+

+    @abstractmethod

+    def get(self, user_id): pass

+

+    @abstractmethod

+    def find_by_username(self, username): pass

+from commu.infrastructure.memory_post_repository import InMemoryPostRepository

+from commu.entities.post import Post

+

+def test_add_and_get_post():

+    repo = InMemoryPostRepository()

+    post = Post("user1", "content", images=["img.png"])

+    repo.add(post)

+    assert repo.get(post.id) == post

+

+def test_search():

+    repo = InMemoryPostRepository()

+    p1 = Post("u", "hello apple")

+    p2 = Post("u", "banana orange")

+    repo.add(p1)

+    repo.add(p2)

+    results = repo.search("apple")

+    assert len(results) == 1 and results[0].id == p1.id

+

+def test_rate_post():

+    repo = InMemoryPostRepository()

+    p = Post("u", "rate me")

+    repo.add(p)

+    repo.rate_post(p.id, "userA", 3)

+    repo.rate_post(p.id, "userB", 5)

+    # userA updates rating

+    repo.rate_post(p.id, "userA", 4)

+    assert p.ratings == [("userB", 5), ("userA", 4)] or p.ratings == [("userA", 4), ("userB", 5)]

+import pytest

+from commu.usecases.post_service import PostService

+from commu.usecases.user_service import UserService

+from commu.infrastructure.memory_user_repository import InMemoryUserRepository

+from commu.infrastructure.memory_post_repository import InMemoryPostRepository

+from commu.entities.user import UserRole

+

+@pytest.fixture

+def setup_services():

+    user_repo = InMemoryUserRepository()

+    post_repo = InMemoryPostRepository()

+    user_svc = UserService(user_repo)

+    post_svc = PostService(post_repo, user_repo)

+    admin = user_svc.register("admin", UserRole.ADMIN)

+    user = user_svc.register("user", UserRole.USER)

+    guest = user_svc.register("guest", UserRole.GUEST)

+    return user_svc, post_svc, admin, user, guest

+

+def test_create_post(setup_services):

+    user_svc, post_svc, admin, user, guest = setup_services

+    post = post_svc.create_post(user.id, "My post", images=["a.jpg"])

+    assert post.text == "My post"

+    assert post.images == ["a.jpg"]

+

+def test_guest_cannot_create_post(setup_services):

+    user_svc, post_svc, admin, user, guest = setup_services

+    with pytest.raises(PermissionError):

+        post_svc.create_post(guest.id, "forbidden")

+

+def test_search_posts(setup_services):

+    user_svc, post_svc, admin, user, guest = setup_services

+    post1 = post_svc.create_post(user.id, "Hello world")

+    post2 = post_svc.create_post(user.id, "Another post")

+    results = post_svc.search_posts("hello")

+    assert len(results) == 1

+    assert results[0].text == "Hello world"

+

+def test_rate_post(setup_services):

+    user_svc, post_svc, admin, user, guest = setup_services

+    post = post_svc.create_post(user.id, "My post")

+    post_svc.rate_post(post.id, admin.id, 5)

+    post_svc.rate_post(post.id, user.id, 4)

+    assert abs(post.average_rating() - 4.5) < 1e-6

+

+def test_guest_cannot_rate(setup_services):

+    user_svc, post_svc, admin, user, guest = setup_services

+    post = post_svc.create_post(user.id, "Guest can't rate")

+    with pytest.raises(PermissionError):

+        post_svc.rate_post(post.id, guest.id, 5)

+

+def test_rating_bounds(setup_services):

+    user_svc, post_svc, admin, user, guest = setup_services

+    post = post_svc.create_post(user.id, "Test bounds")

+    with pytest.raises(ValueError):

+        post_svc.rate_post(post.id, admin.id, 0)

+    with pytest.raises(ValueError):

+        post_svc.rate_post(post.id, admin.id, 6)

+import pytest

+from commu.usecases.user_service import UserService

+from commu.infrastructure.memory_user_repository import InMemoryUserRepository

+from commu.entities.user import UserRole

+

+def test_register_user():

+    repo = InMemoryUserRepository()

+    svc = UserService(repo)

+    user = svc.register("testuser")

+    assert user.username == "testuser"

+    assert user.role == UserRole.USER

+    assert repo.get(user.id) == user

+

+def test_register_admin():

+    repo = InMemoryUserRepository()

+    svc = UserService(repo)

+    user = svc.register("adminuser", UserRole.ADMIN)

+    assert user.role == UserRole.ADMIN

+

+def test_get_user():

+    repo = InMemoryUserRepository()

+    svc = UserService(repo)

+    user = svc.register("abc")

+    found = svc.get_user(user.id)

+    assert found.username == "abc"

+from commu.entities.post import Post

+from commu.entities.user import UserRole

+

+class PostService:

+    def __init__(self, post_repo, user_repo):

+        self.post_repo = post_repo

+        self.user_repo = user_repo

+

+    def create_post(self, author_id, text, images=None, videos=None):

+        user = self.user_repo.get(author_id)

+        print(f"user = {user}")

+        print(f"role = {user.role}")

+        if not user or user.role == UserRole.GUEST:

+            raise PermissionError("User does not have permission to create posts")

+        post = Post(author_id, text, images, videos)

+        self.post_repo.add(post)

+        return post

+

+    def search_posts(self, query):

+        return self.post_repo.search(query)

+

+    def rate_post(self, post_id, user_id, rating):

+        user = self.user_repo.get(user_id)

+        if not user or user.role == UserRole.GUEST:

+            raise PermissionError("Guests cannot rate posts")

+        if not (1 <= rating <= 5):

+            raise ValueError("Rating must be between 1 and 5")

+        self.post_repo.rate_post(post_id, user_id, rating)

+from commu.entities.user import User, UserRole

+

+class UserService:

+    def __init__(self, user_repo):

+        self.user_repo = user_repo

+

+    def register(self, username, role=UserRole.USER):

+        user = User(username, role)

+        self.user_repo.add(user)

+        return user

+

+    def get_user(self, user_id):

+        return self.user_repo.get(user_id)

+from django.contrib import admin

+

+# Register your models here.

+from django.apps import AppConfig

+

+

+class CoreConfig(AppConfig):

+    default_auto_field = 'django.db.models.BigAutoField'

+    name = 'core'

+# Generated by Django 5.2.4 on 2025-08-03 16:36

+

+import django.db.models.deletion

+from django.conf import settings

+from django.db import migrations, models

+

+

+class Migration(migrations.Migration):

+

+    initial = True

+

+    dependencies = [

+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),

+    ]

+

+    operations = [

+        migrations.CreateModel(

+            name='Post',

+            fields=[

+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),

+                ('text', models.TextField()),

+                ('images', models.JSONField(blank=True, default=list)),

+                ('videos', models.JSONField(blank=True, default=list)),

+                ('created', models.DateTimeField(auto_now_add=True)),

+                ('author', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='posts', to=settings.AUTH_USER_MODEL)),

+            ],

+        ),

+        migrations.CreateModel(

+            name='PostRating',

+            fields=[

+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),

+                ('rating', models.IntegerField()),

+                ('created', models.DateTimeField(auto_now_add=True)),

+                ('post', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='ratings', to='core.post')),

+                ('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),

+            ],

+        ),

+    ]

+from django.db import models

+from django.contrib.auth import get_user_model

+

+User = get_user_model()

+

+class Post(models.Model):

+    author = models.ForeignKey(User, on_delete=models.CASCADE, related_name="posts")

+    text = models.TextField()

+    images = models.JSONField(default=list, blank=True)

+    videos = models.JSONField(default=list, blank=True)

+    created = models.DateTimeField(auto_now_add=True)

+

+class PostRating(models.Model):

+    post = models.ForeignKey(Post, on_delete=models.CASCADE, related_name="ratings")

+    user = models.ForeignKey(User, on_delete=models.CASCADE)

+    rating = models.IntegerField()

+    created = models.DateTimeField(auto_now_add=True)

+

+from commu.interfaces.post_repository import PostRepository

+from core.models import Post, PostRating

+from django.contrib.auth import get_user_model

+

+User = get_user_model()

+

+class DjangoPostRepository(PostRepository):

+    def add(self, post):

+        # post: commu.entities.post.Post

+        try:

+            author = User.objects.get(id=post.author_id)

+        except User.DoesNotExist:

+            raise ValueError("Author not found")

+        obj = Post.objects.create(

+            author=author,

+            text=post.text,

+            images=post.images,

+            videos=post.videos,

+        )

+        post.id = str(obj.id)

+        return post

+

+    def get(self, post_id):

+        try:

+            obj = Post.objects.get(id=post_id)

+            from commu.entities.post import Post as DomainPost

+            domain_post = DomainPost(

+                author_id=str(obj.author.id),

+                text=obj.text,

+                images=obj.images,

+                videos=obj.videos,

+            )

+            domain_post.id = str(obj.id)

+            # Load ratings

+            domain_post.ratings = [

+                (str(r.user.id), r.rating)

+                for r in obj.ratings.all()

+            ]

+            return domain_post

+        except Post.DoesNotExist:

+            return None

+

+    def search(self, query: str):

+        qs = Post.objects.filter(text__icontains=query)

+        from commu.entities.post import Post as DomainPost

+        result = []

+        for obj in qs:

+            domain_post = DomainPost(

+                author_id=str(obj.author.id),

+                text=obj.text,

+                images=obj.images,

+                videos=obj.videos,

+            )

+            domain_post.id = str(obj.id)

+            # Load ratings

+            domain_post.ratings = [

+                (str(r.user.id), r.rating)

+                for r in obj.ratings.all()

+            ]

+            result.append(domain_post)

+        return result

+

+    def rate_post(self, post_id, user_id, rating: int):

+        try:

+            post = Post.objects.get(id=post_id)

+            user = User.objects.get(id=user_id)

+        except (Post.DoesNotExist, User.DoesNotExist):

+            raise ValueError("Post or user not found")

+        # Remove old rating from user, if any

+        PostRating.objects.filter(post=post, user=user).delete()

+        # Create new rating

+        PostRating.objects.create(post=post, user=user, rating=rating)

+

+    def delete(self, post_id):

+        try:

+            obj = Post.objects.get(id=post_id)

+            obj.delete()

+        except Post.DoesNotExist:

+            raise ValueError("Post not found")

+

+    def list(self, page=1, per_page=10, order_by="-created"):

+        qs = Post.objects.all().order_by(order_by)

+        total = qs.count()

+        start = (page - 1) * per_page

+        end = start + per_page

+        from commu.entities.post import Post as DomainPost

+        posts = []

+        for obj in qs[start:end]:

+            domain_post = DomainPost(

+                author_id=str(obj.author.id),

+                text=obj.text,

+                images=obj.images,

+                videos=obj.videos,

+            )

+            domain_post.id = str(obj.id)

+            domain_post.ratings = [

+                (str(r.user.id), r.rating)

+                for r in obj.ratings.all()

+            ]

+            posts.append(domain_post)

+        return posts, total

+

+    def update(self, post):

+        try:

+            obj = Post.objects.get(id=post.id)

+            obj.text = post.text

+            obj.images = post.images

+            obj.videos = post.videos

+            obj.save()

+            # Optionally update ratings (if part of update)

+        except Post.DoesNotExist:

+            raise ValueError("Post not found")

+from commu.interfaces.user_repository import UserRepository

+from django.contrib.auth.models import User as DjangoUser

+

+class DjangoUserRepository(UserRepository):

+    def add(self, user):

+        # user: commu.entities.user.User

+        # Map role to Django flags

+        is_staff = user.role.value in ("admin", "user") if hasattr(user.role, "value") else user.role in ("admin", "user")

+        is_superuser = user.role.value == "admin" if hasattr(user.role, "value") else user.role == "admin"

+        obj = DjangoUser.objects.create_user(

+            username=user.username,

+            password=None,  # You may set/generate a password as needed!

+            is_staff=is_staff,

+            is_superuser=is_superuser,

+        )

+        user.id = str(obj.id)

+        return user

+

+    def get(self, user_id):

+        try:

+            obj = DjangoUser.objects.get(id=user_id)

+            from commu.entities.user import User, UserRole

+            role = self._role_from_django(obj)

+            u = User(

+                username=obj.username,

+                role=role,

+            )

+            u.id = str(obj.id)

+            return u

+        except DjangoUser.DoesNotExist:

+            return None

+

+    def find_by_username(self, username):

+        try:

+            obj = DjangoUser.objects.get(username=username)

+            from commu.entities.user import User, UserRole

+            role = self._role_from_django(obj)

+            u = User(

+                username=obj.username,

+                role=role,

+            )

+            u.id = str(obj.id)

+            return u

+        except DjangoUser.DoesNotExist:

+            return None

+

+    def _role_from_django(self, user_obj):

+        from commu.entities.user import UserRole

+        if user_obj.is_superuser:

+            return UserRole.ADMIN

+        elif user_obj.is_staff:

+            return UserRole.USER

+        else:

+            return UserRole.GUEST

+

+from django.test import TestCase

+

+# Create your tests here.

+import pytest

+from django.test import TestCase

+from django.contrib.auth import get_user_model

+

+from commu.usecases.post_service import PostService

+from commu.entities.user import UserRole

+from core.repositories.django_post_repository import DjangoPostRepository

+from core.repositories.django_user_repository import DjangoUserRepository

+

+User = get_user_model()

+

+class PostServiceIntegrationTest(TestCase):

+

+    def setUp(self):

+        # Use Django's repositories

+        self.user_repo = DjangoUserRepository()

+        self.post_repo = DjangoPostRepository()

+        self.service = PostService(self.post_repo, self.user_repo)

+

+        # Create some users using Django ORM

+        self.admin = User.objects.create_user(username="admin", is_superuser=True, is_staff=True)

+        self.user = User.objects.create_user(username="user", is_staff=True)

+        self.guest = User.objects.create_user(username="guest")  # Not staff or superuser

+

+    def test_create_post_by_user(self):

+        post = self.service.create_post(str(self.user.id), "Hello Django!", ["img1.png"], ["vid1.mp4"])

+        assert post.text == "Hello Django!"

+        assert post.images == ["img1.png"]

+        assert post.videos == ["vid1.mp4"]

+

+    def test_guest_cannot_create_post(self):

+        with self.assertRaises(PermissionError):

+            self.service.create_post(str(self.guest.id), "Forbidden")

+

+    def test_search_posts(self):

+        p1 = self.service.create_post(str(self.user.id), "First Django post")

+        p2 = self.service.create_post(str(self.user.id), "Second hello world")

+        results = self.service.search_posts("hello")

+        assert len(results) == 1

+        assert results[0].text == "Second hello world"

+

+    def test_rate_post(self):

+        post = self.service.create_post(str(self.user.id), "Rate me Django!")

+        self.service.rate_post(post.id, str(self.admin.id), 5)

+        self.service.rate_post(post.id, str(self.user.id), 4)

+        updated_post = self.post_repo.get(post.id)

+        assert abs(updated_post.average_rating() - 4.5) < 1e-6

+

+    def test_guest_cannot_rate_post(self):

+        post = self.service.create_post(str(self.user.id), "No guest rate")

+        with self.assertRaises(PermissionError):

+            self.service.rate_post(post.id, str(self.guest.id), 2)

+

+    def test_rating_bounds(self):

+        post = self.service.create_post(str(self.user.id), "Bounds Django")

+        with self.assertRaises(ValueError):

+            self.service.rate_post(post.id, str(self.admin.id), 0)

+        with self.assertRaises(ValueError):

+            self.service.rate_post(post.id, str(self.admin.id), 6)

+

+from django.urls import path

+from . import views

+

+urlpatterns = [

+    path('posts/create/', views.create_post, name='create_post'),

+    path('posts/search/', views.search_posts, name='search_posts'),

+    path('posts/rate/', views.rate_post, name='rate_post'),

+]

+import json

+from django.http import JsonResponse, HttpResponseBadRequest

+from django.views.decorators.csrf import csrf_exempt

+from django.contrib.auth.decorators import login_required

+from commu.usecases.post_service import PostService

+from core.repositories.django_post_repository import DjangoPostRepository

+from core.repositories.django_user_repository import DjangoUserRepository

+

+# Service setup (could be moved to app config for larger apps)

+user_repo = DjangoUserRepository()

+post_repo = DjangoPostRepository()

+post_service = PostService(post_repo, user_repo)

+

+@csrf_exempt

+@login_required

+def create_post(request):

+    if request.method != 'POST':

+        return HttpResponseBadRequest("POST only")

+    try:

+        data = json.loads(request.body.decode())

+        text = data.get("text")

+        images = data.get("images", [])

+        videos = data.get("videos", [])

+        if not text:

+            return JsonResponse({"error": "Missing post text"}, status=400)

+        # Use logged-in Django user as author

+        user_id = str(request.user.id)

+        post = post_service.create_post(user_id, text, images, videos)

+        return JsonResponse({

+            "id": post.id,

+            "text": post.text,

+            "author_id": post.author_id,

+            "images": post.images,

+            "videos": post.videos

+        })

+    except Exception as e:

+        return JsonResponse({"error": str(e)}, status=400)

+

+def search_posts(request):

+    q = request.GET.get("q", "")

+    results = post_service.search_posts(q)

+    posts = [{

+        "id": p.id,

+        "text": p.text,

+        "author_id": p.author_id,

+        "images": p.images,

+        "videos": p.videos,

+        "avg_rating": p.average_rating()

+    } for p in results]

+    return JsonResponse({"results": posts})

+

+@csrf_exempt

+@login_required

+def rate_post(request):

+    if request.method != 'POST':

+        return HttpResponseBadRequest("POST only")

+    try:

+        data = json.loads(request.body.decode())

+        post_id = data.get("post_id")

+        rating = data.get("rating")

+        if not post_id or rating is None:

+            return JsonResponse({"error": "Missing post_id or rating"}, status=400)

+        user_id = str(request.user.id)

+        post_service.rate_post(post_id, user_id, int(rating))

+        return JsonResponse({"ok": True})

+    except Exception as e:

+        return JsonResponse({"error": str(e)}, status=400)

+

+

+"""

+ASGI config for django_commu project.

+

+It exposes the ASGI callable as a module-level variable named ``application``.

+

+For more information on this file, see

+https://docs.djangoproject.com/en/5.2/howto/deployment/asgi/

+"""

+

+import os

+

+from django.core.asgi import get_asgi_application

+

+os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'django_commu.settings')

+

+application = get_asgi_application()

+"""

+Django settings for django_commu project.

+

+Generated by 'django-admin startproject' using Django 5.2.4.

+

+For more information on this file, see

+https://docs.djangoproject.com/en/5.2/topics/settings/

+

+For the full list of settings and their values, see

+https://docs.djangoproject.com/en/5.2/ref/settings/

+"""

+

+from pathlib import Path

+import os

+

+# Build paths inside the project like this: BASE_DIR / 'subdir'.

+BASE_DIR = Path(__file__).resolve().parent.parent

+

+

+# Quick-start development settings - unsuitable for production

+# See https://docs.djangoproject.com/en/5.2/howto/deployment/checklist/

+

+# SECURITY WARNING: keep the secret key used in production secret!

+SECRET_KEY = 'django-insecure-c$ieo22nwe^v#*e$xlh@fath9*t+f8wtqrt9e!op9-ittc=b_x'

+

+# SECURITY WARNING: don't run with debug turned on in production!

+DEBUG = True

+

+ALLOWED_HOSTS = []

+

+

+# Application definition

+

+INSTALLED_APPS = [

+    'django.contrib.admin',

+    'django.contrib.auth',

+    'django.contrib.contenttypes',

+    'django.contrib.sessions',

+    'django.contrib.messages',

+    'django.contrib.staticfiles',

+    'core',

+]

+

+MIDDLEWARE = [

+    'django.middleware.security.SecurityMiddleware',

+    'django.contrib.sessions.middleware.SessionMiddleware',

+    'django.middleware.common.CommonMiddleware',

+    'django.middleware.csrf.CsrfViewMiddleware',

+    'django.contrib.auth.middleware.AuthenticationMiddleware',

+    'django.contrib.messages.middleware.MessageMiddleware',

+    'django.middleware.clickjacking.XFrameOptionsMiddleware',

+]

+

+ROOT_URLCONF = 'django_commu.urls'

+

+TEMPLATES = [

+    {

+        'BACKEND': 'django.template.backends.django.DjangoTemplates',

+        'DIRS': [],

+        'APP_DIRS': True,

+        'OPTIONS': {

+            'context_processors': [

+                'django.template.context_processors.request',

+                'django.contrib.auth.context_processors.auth',

+                'django.contrib.messages.context_processors.messages',

+            ],

+        },

+    },

+]

+

+WSGI_APPLICATION = 'django_commu.wsgi.application'

+

+

+# Database

+# https://docs.djangoproject.com/en/5.2/ref/settings/#databases

+

+DATABASES = {

+    'default': {

+        'ENGINE': 'django.db.backends.postgresql',

+        'NAME': os.getenv('DB_NAME', 'commudb'),

+        'USER': os.getenv('DB_USER', 'commuuser'),

+        'PASSWORD': os.getenv('DB_PASSWORD', 'commupass'),

+        'HOST': os.getenv('DB_HOST', 'db'),

+        'PORT': os.getenv('DB_PORT', '5432'),

+    }

+}

+

+

+# Password validation

+# https://docs.djangoproject.com/en/5.2/ref/settings/#auth-password-validators

+

+AUTH_PASSWORD_VALIDATORS = [

+    {

+        'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',

+    },

+    {

+        'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',

+    },

+    {

+        'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',

+    },

+    {

+        'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',

+    },

+]

+

+

+# Internationalization

+# https://docs.djangoproject.com/en/5.2/topics/i18n/

+

+LANGUAGE_CODE = 'en-us'

+

+TIME_ZONE = 'UTC'

+

+USE_I18N = True

+

+USE_TZ = True

+

+

+# Static files (CSS, JavaScript, Images)

+# https://docs.djangoproject.com/en/5.2/howto/static-files/

+

+STATIC_URL = 'static/'

+

+# Default primary key field type

+# https://docs.djangoproject.com/en/5.2/ref/settings/#default-auto-field

+

+DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'

+"""

+URL configuration for django_commu project.

+

+The `urlpatterns` list routes URLs to views. For more information please see:

+    https://docs.djangoproject.com/en/5.2/topics/http/urls/

+Examples:

+Function views

+    1. Add an import:  from my_app import views

+    2. Add a URL to urlpatterns:  path('', views.home, name='home')

+Class-based views

+    1. Add an import:  from other_app.views import Home

+    2. Add a URL to urlpatterns:  path('', Home.as_view(), name='home')

+Including another URLconf

+    1. Import the include() function: from django.urls import include, path

+    2. Add a URL to urlpatterns:  path('blog/', include('blog.urls'))

+"""

+from django.contrib import admin

+from django.urls import path, include

+

+urlpatterns = [

+    path('admin/', admin.site.urls),

+    path('core/', include('core.urls')),

+]

+"""

+WSGI config for django_commu project.

+

+It exposes the WSGI callable as a module-level variable named ``application``.

+

+For more information on this file, see

+https://docs.djangoproject.com/en/5.2/howto/deployment/wsgi/

+"""

+

+import os

+

+from django.core.wsgi import get_wsgi_application

+

+os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'django_commu.settings')

+

+application = get_wsgi_application()

+version: '3.9'

+

+services:

+  db:

+    image: postgres:16

+    environment:

+      POSTGRES_DB: commudb

+      POSTGRES_USER: commuuser

+      POSTGRES_PASSWORD: commupass

+    ports:

+      - "5432:5432"

+    volumes:

+      - postgres_data:/var/lib/postgresql/data

+

+  web:

+    build:

+      context: .

+      args:

+        UID: ${UID}

+        GID: ${GID}

+    user: "${UID}:${GID}"

+    command: >

+      sh -c "python manage.py runserver 0.0.0.0:8000"

+    volumes:

+      - .:/app

+    working_dir: /app

+    ports:

+      - "8000:8000"

+    depends_on:

+      - db

+    environment:

+      - DEBUG=1

+      - DB_NAME=commudb

+      - DB_USER=commuuser

+      - DB_PASSWORD=commupass

+      - DB_HOST=db

+      - DB_PORT=5432

+

+volumes:

+  postgres_data:

+from commu.infrastructure.memory_user_repository import InMemoryUserRepository

+from commu.infrastructure.memory_post_repository import InMemoryPostRepository

+from commu.usecases.user_service import UserService

+from commu.usecases.post_service import PostService

+from commu.entities.user import UserRole

+

+def main():

+    user_repo = InMemoryUserRepository()

+    post_repo = InMemoryPostRepository()

+    user_service = UserService(user_repo)

+    post_service = PostService(post_repo, user_repo)

+

+    # Create users

+    admin = user_service.register("alice", UserRole.ADMIN)

+    user = user_service.register("bob", UserRole.USER)

+    guest = user_service.register("guest", UserRole.GUEST)

+

+    # User creates post

+    post = post_service.create_post(user.id, "Hello world!", images=["img1.png"], videos=["vid1.mp4"])

+    print(f"Created Post: {post.text}, by {user.username}")

+

+    # Post search

+    found = post_service.search_posts("hello")

+    print(f"Found {len(found)} posts containing 'hello'.")

+

+    # Post rating

+    post_service.rate_post(post.id, admin.id, 5)

+    post_service.rate_post(post.id, user.id, 4)

+    print(f"Average Rating: {post.average_rating()}")

+

+    # Guest tries to create post (should fail)

+    try:

+        post_service.create_post(guest.id, "I am a guest")

+    except PermissionError as e:

+        print("Guest cannot create post:", e)

+

+if __name__ == "__main__":

+    main()

+#!/usr/bin/env python

+"""Django's command-line utility for administrative tasks."""

+import os

+import sys

+

+

+def main():

+    """Run administrative tasks."""

+    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'django_commu.settings')

+    try:

+        from django.core.management import execute_from_command_line

+    except ImportError as exc:

+        raise ImportError(

+            "Couldn't import Django. Are you sure it's installed and "

+            "available on your PYTHONPATH environment variable? Did you "

+            "forget to activate a virtual environment?"

+        ) from exc

+    execute_from_command_line(sys.argv)

+

+

+if __name__ == '__main__':

+    main()

+pytest

+Django>=4.2

+psycopg2-binary