ai-first-cli 1.1.5 → 1.2.0

package/test-projects/django-app/blog/serializers.py

@@ -0,0 +1,69 @@
+"""Blog application serializers."""
+
+from rest_framework import serializers
+from django.contrib.auth.models import User
+from .models import Post, Comment, Category
+
+
+class CategorySerializer(serializers.ModelSerializer):
+    """Serializer for Category model."""
+
+    class Meta:
+        model = Category
+        fields = ["id", "name", "description"]
+
+
+class CommentSerializer(serializers.ModelSerializer):
+    """Serializer for Comment model."""
+
+    author_username = serializers.CharField(source="author.username", read_only=True)
+
+    class Meta:
+        model = Comment
+        fields = ["id", "post", "author", "author_username", "content", "created_at"]
+        read_only_fields = ["author"]
+
+
+class PostSerializer(serializers.ModelSerializer):
+    """Serializer for Post model."""
+
+    author_username = serializers.CharField(source="author.username", read_only=True)
+    comments_count = serializers.IntegerField(source="comments.count", read_only=True)
+    categories = CategorySerializer(many=True, read_only=True)
+
+    class Meta:
+        model = Post
+        fields = [
+            "id",
+            "title",
+            "content",
+            "author",
+            "author_username",
+            "created_at",
+            "updated_at",
+            "published",
+            "comments_count",
+            "categories",
+        ]
+        read_only_fields = ["author"]
+
+
+class PostCreateUpdateSerializer(serializers.ModelSerializer):
+    """Serializer for creating and updating posts."""
+
+    category_ids = serializers.ListField(
+        child=serializers.IntegerField(), write_only=True, required=False
+    )
+
+    class Meta:
+        model = Post
+        fields = ["id", "title", "content", "published", "category_ids"]
+
+    def create(self, validated_data):
+        """Create a new post with categories."""
+        category_ids = validated_data.pop("category_ids", [])
+        post = Post.objects.create(**validated_data)
+        if category_ids:
+            categories = Category.objects.filter(id__in=category_ids)
+            post.categories.set(categories)
+        return post

package/test-projects/django-app/blog/urls.py

@@ -0,0 +1,14 @@
+"""Blog application URL configuration."""
+
+from django.urls import path, include
+from rest_framework.routers import DefaultRouter
+from .views import PostViewSet, CommentViewSet, CategoryViewSet
+
+router = DefaultRouter()
+router.register(r"posts", PostViewSet)
+router.register(r"comments", CommentViewSet)
+router.register(r"categories", CategoryViewSet)
+
+urlpatterns = [
+    path("", include(router.urls)),
+]

package/test-projects/django-app/blog/views.py

@@ -0,0 +1,96 @@
+"""Blog application views."""
+
+from rest_framework import viewsets, status
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from rest_framework.permissions import IsAuthenticated, AllowAny
+from django.contrib.auth.models import User
+from .models import Post, Comment, Category
+from .serializers import (
+    PostSerializer,
+    PostCreateUpdateSerializer,
+    CommentSerializer,
+    CategorySerializer,
+)
+
+
+class PostViewSet(viewsets.ModelViewSet):
+    """ViewSet for blog posts."""
+
+    queryset = Post.objects.all()
+    permission_classes = [IsAuthenticated]
+
+    def get_serializer_class(self):
+        """Return appropriate serializer class."""
+        if self.action in ["create", "update", "partial_update"]:
+            return PostCreateUpdateSerializer
+        return PostSerializer
+
+    def get_permissions(self):
+        """Allow anyone to view published posts."""
+        if self.action in ["list", "retrieve"]:
+            return [AllowAny()]
+        return [IsAuthenticated()]
+
+    def perform_create(self, serializer):
+        """Set the author to the current user."""
+        serializer.save(author=self.request.user)
+
+    @action(detail=True, methods=["post"])
+    def publish(self, request, pk=None):
+        """Publish a blog post."""
+        post = self.get_object()
+        post.publish()
+        return Response({"status": "post published"})
+
+    @action(detail=False, methods=["get"])
+    def my_posts(self, request):
+        """Get posts by current user."""
+        posts = Post.objects.filter(author=request.user)
+        serializer = PostSerializer(posts, many=True)
+        return Response(serializer.data)
+
+    @action(detail=False, methods=["get"])
+    def published(self, request):
+        """Get all published posts."""
+        posts = Post.objects.filter(published=True)
+        serializer = PostSerializer(posts, many=True)
+        return Response(serializer.data)
+
+
+class CommentViewSet(viewsets.ModelViewSet):
+    """ViewSet for comments."""
+
+    queryset = Comment.objects.all()
+    serializer_class = CommentSerializer
+    permission_classes = [IsAuthenticated]
+
+    def perform_create(self, serializer):
+        """Set the author to the current user."""
+        serializer.save(author=self.request.user)
+
+    def get_queryset(self):
+        """Filter comments by post if provided."""
+        queryset = Comment.objects.all()
+        post_id = self.request.query_params.get("post", None)
+        if post_id:
+            queryset = queryset.filter(post_id=post_id)
+        return queryset
+
+
+class CategoryViewSet(viewsets.ModelViewSet):
+    """ViewSet for categories."""
+
+    queryset = Category.objects.all()
+    serializer_class = CategorySerializer
+    permission_classes = [AllowAny]
+
+    @action(detail=True, methods=["get"])
+    def posts(self, request, pk=None):
+        """Get posts in this category."""
+        category = self.get_object()
+        posts = category.posts.filter(published=True)
+        from .serializers import PostSerializer
+
+        serializer = PostSerializer(posts, many=True)
+        return Response(serializer.data)

package/test-projects/django-app/django_app/settings.py

@@ -0,0 +1,90 @@
+"""
+Django settings for django_app project.
+"""
+
+from pathlib import Path
+
+BASE_DIR = Path(__file__).resolve().parent.parent
+
+SECRET_KEY = "django-insecure-test-key-not-for-production"
+
+DEBUG = True
+
+ALLOWED_HOSTS = ["localhost", "127.0.0.1"]
+
+INSTALLED_APPS = [
+    "django.contrib.admin",
+    "django.contrib.auth",
+    "django.contrib.contenttypes",
+    "django.contrib.sessions",
+    "django.contrib.messages",
+    "django.contrib.staticfiles",
+    "rest_framework",
+    "blog",
+    "users",
+]
+
+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_app.urls"
+
+TEMPLATES = [
+    {
+        "BACKEND": "django.template.backends.django.DjangoTemplates",
+        "DIRS": [],
+        "APP_DIRS": True,
+        "OPTIONS": {
+            "context_processors": [
+                "django.template.context_processors.debug",
+                "django.template.context_processors.request",
+                "django.contrib.auth.context_processors.auth",
+                "django.contrib.messages.context_processors.messages",
+            ],
+        },
+    },
+]
+
+WSGI_APPLICATION = "django_app.wsgi.application"
+
+DATABASES = {
+    "default": {
+        "ENGINE": "django.db.backends.sqlite3",
+        "NAME": BASE_DIR / "db.sqlite3",
+    }
+}
+
+AUTH_PASSWORD_VALIDATORS = [
+    {
+        "NAME": "django.contrib.auth.password_validation.UserAttributeSimilarityValidator",
+    },
+    {
+        "NAME": "django.contrib.auth.password_validation.MinimumLengthValidator",
+    },
+]
+
+LANGUAGE_CODE = "en-us"
+TIME_ZONE = "UTC"
+USE_I18N = True
+USE_TZ = True
+
+STATIC_URL = "static/"
+
+DEFAULT_AUTO_FIELD = "django.db.models.BigAutoField"
+
+REST_FRAMEWORK = {
+    "DEFAULT_AUTHENTICATION_CLASSES": [
+        "rest_framework.authentication.SessionAuthentication",
+        "rest_framework.authentication.TokenAuthentication",
+    ],
+    "DEFAULT_PERMISSION_CLASSES": [
+        "rest_framework.permissions.IsAuthenticated",
+    ],
+}

package/test-projects/django-app/django_app/urls.py

@@ -0,0 +1,11 @@
+"""django_app URL configuration."""
+
+from django.contrib import admin
+from django.urls import path, include
+
+urlpatterns = [
+    path("admin/", admin.site.urls),
+    path("api/blog/", include("blog.urls")),
+    path("api/users/", include("users.urls")),
+    path("api-auth/", include("rest_framework.urls")),
+]

package/test-projects/django-app/django_app/wsgi.py

@@ -0,0 +1,9 @@
+"""WSGI config for django_app project."""
+
+import os
+
+from django.core.wsgi import get_wsgi_application
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "django_app.settings")
+
+application = get_wsgi_application()

package/test-projects/django-app/manage.py

@@ -0,0 +1,23 @@
+#!/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_app.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()

package/test-projects/django-app/requirements.txt

@@ -0,0 +1,3 @@
+Django>=4.2.0,<5.0
+djangorestframework>=3.14.0
+Pillow>=10.0.0

package/test-projects/django-app/users/admin.py

@@ -0,0 +1,42 @@
+"""Users application admin configuration."""
+
+from django.contrib import admin
+from django.contrib.auth.admin import UserAdmin as BaseUserAdmin
+from django.contrib.auth.models import User
+from .models import UserProfile, Follow
+
+
+class UserProfileInline(admin.StackedInline):
+    """Inline admin for UserProfile."""
+
+    model = UserProfile
+    can_delete = False
+    verbose_name_plural = "Profile"
+
+
+class UserAdmin(BaseUserAdmin):
+    """Extended User admin with profile."""
+
+    inlines = [UserProfileInline]
+    list_display = [
+        "username",
+        "email",
+        "first_name",
+        "last_name",
+        "is_staff",
+        "date_joined",
+    ]
+
+
+# Re-register UserAdmin
+admin.site.unregister(User)
+admin.site.register(User, UserAdmin)
+
+
+@admin.register(Follow)
+class FollowAdmin(admin.ModelAdmin):
+    """Admin configuration for Follow model."""
+
+    list_display = ["follower", "following", "created_at"]
+    list_filter = ["created_at"]
+    search_fields = ["follower__username", "following__username"]

package/test-projects/django-app/users/models.py

@@ -0,0 +1,54 @@
+"""Users application models."""
+
+from django.db import models
+from django.contrib.auth.models import User
+from django.db.models.signals import post_save
+from django.dispatch import receiver
+
+
+class UserProfile(models.Model):
+    """Extended user profile model."""
+
+    user = models.OneToOneField(User, on_delete=models.CASCADE, related_name="profile")
+    bio = models.TextField(max_length=500, blank=True)
+    location = models.CharField(max_length=100, blank=True)
+    birth_date = models.DateField(null=True, blank=True)
+    avatar = models.ImageField(upload_to="avatars/", blank=True)
+    website = models.URLField(blank=True)
+    twitter = models.CharField(max_length=100, blank=True)
+    github = models.CharField(max_length=100, blank=True)
+
+    def __str__(self):
+        return f"{self.user.username} Profile"
+
+
+@receiver(post_save, sender=User)
+def create_user_profile(sender, instance, created, **kwargs):
+    """Create a user profile when a new user is created."""
+    if created:
+        UserProfile.objects.create(user=instance)
+
+
+@receiver(post_save, sender=User)
+def save_user_profile(sender, instance, **kwargs):
+    """Save user profile when user is saved."""
+    instance.profile.save()
+
+
+class Follow(models.Model):
+    """Follow relationship model."""
+
+    follower = models.ForeignKey(
+        User, on_delete=models.CASCADE, related_name="following"
+    )
+    following = models.ForeignKey(
+        User, on_delete=models.CASCADE, related_name="followers"
+    )
+    created_at = models.DateTimeField(auto_now_add=True)
+
+    class Meta:
+        unique_together = ["follower", "following"]
+        ordering = ["-created_at"]
+
+    def __str__(self):
+        return f"{self.follower.username} follows {self.following.username}"

package/test-projects/django-app/users/serializers.py

@@ -0,0 +1,113 @@
+"""Users application serializers."""
+
+from rest_framework import serializers
+from django.contrib.auth.models import User
+from .models import UserProfile, Follow
+
+
+class UserProfileSerializer(serializers.ModelSerializer):
+    """Serializer for UserProfile model."""
+
+    class Meta:
+        model = UserProfile
+        fields = [
+            "bio",
+            "location",
+            "birth_date",
+            "avatar",
+            "website",
+            "twitter",
+            "github",
+        ]
+
+
+class UserSerializer(serializers.ModelSerializer):
+    """Serializer for User model."""
+
+    profile = UserProfileSerializer()
+    posts_count = serializers.IntegerField(source="posts.count", read_only=True)
+    followers_count = serializers.IntegerField(source="followers.count", read_only=True)
+    following_count = serializers.IntegerField(source="following.count", read_only=True)
+
+    class Meta:
+        model = User
+        fields = [
+            "id",
+            "username",
+            "email",
+            "first_name",
+            "last_name",
+            "profile",
+            "posts_count",
+            "followers_count",
+            "following_count",
+            "date_joined",
+        ]
+        read_only_fields = ["date_joined"]
+
+
+class UserCreateSerializer(serializers.ModelSerializer):
+    """Serializer for creating new users."""
+
+    password = serializers.CharField(write_only=True)
+    password_confirm = serializers.CharField(write_only=True)
+
+    class Meta:
+        model = User
+        fields = [
+            "username",
+            "email",
+            "password",
+            "password_confirm",
+            "first_name",
+            "last_name",
+        ]
+
+    def validate(self, data):
+        """Validate that passwords match."""
+        if data["password"] != data["password_confirm"]:
+            raise serializers.ValidationError("Passwords don't match")
+        return data
+
+    def create(self, validated_data):
+        """Create a new user."""
+        validated_data.pop("password_confirm")
+        user = User.objects.create_user(**validated_data)
+        return user
+
+
+class FollowSerializer(serializers.ModelSerializer):
+    """Serializer for Follow model."""
+
+    follower_username = serializers.CharField(
+        source="follower.username", read_only=True
+    )
+    following_username = serializers.CharField(
+        source="following.username", read_only=True
+    )
+
+    class Meta:
+        model = Follow
+        fields = [
+            "id",
+            "follower",
+            "follower_username",
+            "following",
+            "following_username",
+            "created_at",
+        ]
+        read_only_fields = ["follower"]
+
+
+class ChangePasswordSerializer(serializers.Serializer):
+    """Serializer for password change."""
+
+    old_password = serializers.CharField(required=True)
+    new_password = serializers.CharField(required=True)
+    new_password_confirm = serializers.CharField(required=True)
+
+    def validate(self, data):
+        """Validate new passwords match."""
+        if data["new_password"] != data["new_password_confirm"]:
+            raise serializers.ValidationError("New passwords don't match")
+        return data

package/test-projects/django-app/users/urls.py

@@ -0,0 +1,13 @@
+"""Users application URL configuration."""
+
+from django.urls import path, include
+from rest_framework.routers import DefaultRouter
+from .views import UserViewSet, UserProfileViewSet
+
+router = DefaultRouter()
+router.register(r"users", UserViewSet)
+router.register(r"profiles", UserProfileViewSet)
+
+urlpatterns = [
+    path("", include(router.urls)),
+]

package/test-projects/django-app/users/views.py

@@ -0,0 +1,135 @@
+"""Users application views."""
+
+from rest_framework import viewsets, status, generics
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from rest_framework.permissions import IsAuthenticated, AllowAny
+from django.contrib.auth.models import User
+from django.contrib.auth import authenticate
+from .models import UserProfile, Follow
+from .serializers import (
+    UserSerializer,
+    UserCreateSerializer,
+    UserProfileSerializer,
+    FollowSerializer,
+    ChangePasswordSerializer,
+)
+
+
+class UserViewSet(viewsets.ModelViewSet):
+    """ViewSet for users."""
+
+    queryset = User.objects.all()
+    serializer_class = UserSerializer
+
+    def get_permissions(self):
+        """Allow anyone to register, but only authenticated users for other actions."""
+        if self.action == "create":
+            return [AllowAny()]
+        return [IsAuthenticated()]
+
+    def get_serializer_class(self):
+        """Return appropriate serializer class."""
+        if self.action == "create":
+            return UserCreateSerializer
+        return UserSerializer
+
+    @action(detail=False, methods=["get"])
+    def me(self, request):
+        """Get current user profile."""
+        serializer = UserSerializer(request.user)
+        return Response(serializer.data)
+
+    @action(detail=False, methods=["put", "patch"])
+    def update_profile(self, request):
+        """Update current user profile."""
+        user = request.user
+        profile = user.profile
+
+        # Update user data
+        user_serializer = UserSerializer(user, data=request.data, partial=True)
+        if user_serializer.is_valid():
+            user_serializer.save()
+
+        # Update profile data
+        if "profile" in request.data:
+            profile_serializer = UserProfileSerializer(
+                profile, data=request.data["profile"], partial=True
+            )
+            if profile_serializer.is_valid():
+                profile_serializer.save()
+
+        return Response(UserSerializer(user).data)
+
+    @action(detail=False, methods=["post"])
+    def change_password(self, request):
+        """Change user password."""
+        serializer = ChangePasswordSerializer(data=request.data)
+        if serializer.is_valid():
+            user = request.user
+            if user.check_password(serializer.validated_data["old_password"]):
+                user.set_password(serializer.validated_data["new_password"])
+                user.save()
+                return Response({"status": "password changed"})
+            return Response(
+                {"error": "Wrong old password"}, status=status.HTTP_400_BAD_REQUEST
+            )
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    @action(detail=True, methods=["post"])
+    def follow(self, request, pk=None):
+        """Follow a user."""
+        user_to_follow = self.get_object()
+        if user_to_follow == request.user:
+            return Response(
+                {"error": "Cannot follow yourself"}, status=status.HTTP_400_BAD_REQUEST
+            )
+
+        follow, created = Follow.objects.get_or_create(
+            follower=request.user, following=user_to_follow
+        )
+
+        if created:
+            return Response({"status": "following"})
+        return Response({"status": "already following"})
+
+    @action(detail=True, methods=["post"])
+    def unfollow(self, request, pk=None):
+        """Unfollow a user."""
+        user_to_unfollow = self.get_object()
+        Follow.objects.filter(
+            follower=request.user, following=user_to_unfollow
+        ).delete()
+        return Response({"status": "unfollowed"})
+
+    @action(detail=True, methods=["get"])
+    def followers(self, request, pk=None):
+        """Get user followers."""
+        user = self.get_object()
+        followers = Follow.objects.filter(following=user)
+        serializer = FollowSerializer(followers, many=True)
+        return Response(serializer.data)
+
+    @action(detail=True, methods=["get"])
+    def following(self, request, pk=None):
+        """Get who user is following."""
+        user = self.get_object()
+        following = Follow.objects.filter(follower=user)
+        serializer = FollowSerializer(following, many=True)
+        return Response(serializer.data)
+
+
+class UserProfileViewSet(viewsets.ModelViewSet):
+    """ViewSet for user profiles."""
+
+    queryset = UserProfile.objects.all()
+    serializer_class = UserProfileSerializer
+    permission_classes = [IsAuthenticated]
+
+    def get_queryset(self):
+        """Filter by user if provided."""
+        queryset = UserProfile.objects.all()
+        user_id = self.request.query_params.get("user", None)
+        if user_id:
+            queryset = queryset.filter(user_id=user_id)
+        return queryset