✨ feat(events-models-admin-serializers-views): add Event and EventRegistration models, serializers, and views with organizer and registration management

This commit is contained in:
sankalp committed 2025-07-12 21:38:38 +05:45
1 parent 17956328bc
commit a8b1c4d9dd
5 files changed
+369 -3

No files matched your search

+99 -1
View File
@@ -1,3 +1,101 @@
from django.contrib import admin
from events.models import Event, EventRegistration
# Register your models here.
class EventRegistrationInline(admin.TabularInline):
model = EventRegistration
extra = 0
readonly_fields = ("user", "status", "registration_date")
can_delete = False
@admin.register(Event)
class EventAdmin(admin.ModelAdmin):
list_display = (
"title",
"event_type",
"organizer",
"start_date",
"end_date",
"status",
"is_virtual",
"is_public",
"requires_approval",
)
list_filter = (
"event_type",
"status",
"is_virtual",
"is_public",
"requires_approval",
"start_date",
"end_date",
"registration_deadline",
)
search_fields = ("title", "description", "location", "organizer__username")
date_hierarchy = "start_date"
inlines = [EventRegistrationInline]
autocomplete_fields = ["organizer"]
readonly_fields = ("created_at", "updated_at")
fieldsets = (
(
"Basic Info",
{
"fields": (
"title",
"description",
"event_type",
"organizer",
"tags",
)
},
),
(
"Schedule & Location",
{
"fields": (
"start_date",
"end_date",
"location",
"is_virtual",
"virtual_link",
)
},
),
(
"Registration & Access",
{
"fields": (
"max_attendess",
"registration_deadline",
"is_public",
"requires_approval",
)
},
),
(
"Status & Media",
{
"fields": (
"status",
"featured_image",
"created_at",
"updated_at",
)
},
),
)
@admin.register(EventRegistration)
class EventRegistrationAdmin(admin.ModelAdmin):
list_display = (
"event",
"user",
"status",
"registration_date",
)
list_filter = ("status", "registration_date", "event")
search_fields = ("event__title", "user__username")
autocomplete_fields = ["event", "user"]
readonly_fields = ("registration_date",)
+93
View File
@@ -1,3 +1,96 @@
import uuid
from django.db import models
from apps.users.models import User
# Create your models here.
EVENT_TYPE_CHOICE = [
("networking", "Networking"),
("reunion", "Reunion"),
("workshop", "Workshop"),
("webinar", "Webinar"),
("social", "Social"),
("career", "Career"),
("fundraising", "Fundraising"),
]
EVENT_STATUS_CHOICE = [
("draft", "Draft"),
("published", "Published"),
("cancelled", "Cancelled"),
("completed", "Completed"),
]
EVENT_REGISTRATION_STATUS_CHOICE = [
("registered", "Registered"),
("attended", "Attended"),
("cancelled", "Cancelled"),
("waitlist", "Waitlist"),
]
class Event(models.Model):
id = models.AutoField(primary_key=True, default=uuid.uuid4)
title = models.CharField(max_length=255)
description = models.TextField(blank=True, null=True)
organizer = models.ForeignKey(
User, on_delete=models.CASCADE, related_name="organized_events"
)
event_type = models.CharField(max_length=50, choices=EVENT_TYPE_CHOICE)
start_date = models.DateTimeField(blank=True, null=True)
end_date = models.DateTimeField(blank=True, null=True)
location = models.CharField(max_length=255, blank=True, null=True)
is_virtual = models.BooleanField(default=False)
virtual_link = models.URLField(blank=True, null=True)
max_attendess = models.PositiveIntegerField(blank=True, null=True)
registration_deadline = models.DateTimeField(blank=True, null=True)
is_public = models.BooleanField(default=True)
requires_approval = models.BooleanField(default=False)
featured_image = models.ImageField(upload_to="events/", blank=True, null=True)
tags = models.JSONFIELD(default=list, blank=True, null=True)
status = models.CharField(
max_length=50, choices=EVENT_STATUS_CHOICE, default="draft"
)
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
def __str__(self):
return self.title
class Meta:
db_table = "events"
indexes = [
models.Index(fields=["title"]),
models.Index(fields=["start_date"]),
models.Index(fields=["end_date"]),
models.Index(fields=["organizer"]),
models.Index(fields=["status"]),
models.Index(fields=["event_type"]),
models.Index(fields=["is_public"]),
models.Index(fields=["tags"]),
models.Index(fields=["created_at"]),
models.Index(fields=["updated_at"]),
models.Index(fields=["registration_deadline"]),
models.Index(fields=["location"]),
]
class EventRegistration(models.Model):
id = models.AutoField(primary_key=True, default=uuid.uuid4)
event = models.ForeignKey(
Event, on_delete=models.CASCADE, related_name="registrations"
)
user = models.ForeignKey(
User, on_delete=models.CASCADE, related_name="event_registrations"
)
status = models.CharField(
max_length=50, choices=EVENT_REGISTRATION_STATUS_CHOICE, default="registered"
)
registration_date = models.DateTimeField(auto_now_add=True)
special_requirements = models.TextField(blank=True, null=True)
class Meta:
db_table = "event_registrations"
unique_together = (("event", "user"),)
def __str__(self):
return f"{self.user.username} - {self.event.title}"
+87
View File
@@ -0,0 +1,87 @@
from events.models import (
Event,
EventRegistration,
)
from rest_framework import serializers
from apps.users.models import User
class OrganizerSerializer(serializers.ModelSerializer):
class Meta:
model = User
fields = ("id", "username", "email")
class EventRegistrationSerializer(serializers.ModelSerializer):
user = OrganizerSerializer(read_only=True)
user_id = serializers.PrimaryKeyRelatedField(
queryset=User.objects.all(), source="user", write_only=True
)
class Meta:
model = EventRegistration
fields = [
"id",
"event",
"user",
"user_id",
"status",
"registration_date",
"special_requirements",
]
read_only_fields = ("id", "registration_date")
class EventSerializer(serializers.ModelSerializer):
organizer = OrganizerSerializer(read_only=True)
organizer_id = serializers.PrimaryKeyRelatedField(
queryset=User.objects.all(), source="organizer", write_only=True
)
registrations = EventRegistrationSerializer(many=True, read_only=True)
class Meta:
model = Event
fields = [
"id",
"title",
"description",
"organizer",
"organizer_id",
"event_type",
"start_date",
"end_date",
"location",
"is_virtual",
"virtual_link",
"max_attendess",
"registration_deadline",
"is_public",
"requires_approval",
"featured_image",
"tags",
"status",
"created_at",
"updated_at",
"registrations",
]
read_only_fields = ("id", "created_at", "updated_at")
# Optional: for event listing only
class EventListSerializer(serializers.ModelSerializer):
organizer = OrganizerSerializer(read_only=True)
class Meta:
model = Event
fields = [
"id",
"title",
"event_type",
"start_date",
"end_date",
"location",
"is_virtual",
"status",
"organizer",
]
+10
View File
@@ -0,0 +1,10 @@
from rest_framework.routers import DefaultRouter
from events.views import EventViewSet, EventRegistrationViewSet
router = DefaultRouter()
router.register(r"events", EventViewSet)
router.register(r"registrations", EventRegistrationViewSet)
urlpatterns = [
*router.urls,
]
+80 -2
View File
@@ -1,3 +1,81 @@
from django.shortcuts import render
from rest_framework import viewsets, permissions, status
from rest_framework.response import Response
from rest_framework.exceptions import PermissionDenied
from rest_framework.decorators import action
# Create your views here.
from events.models import Event, EventRegistration
from events.serializers import (
EventSerializer,
EventListSerializer,
EventRegistrationSerializer,
)
from apps.users.models import User
class EventViewSet(viewsets.ModelViewSet):
queryset = (
Event.objects.all()
.select_related("organizer")
.prefetch_related("registrations")
)
permission_classes = [permissions.IsAuthenticatedOrReadOnly]
def get_serializer_class(self):
if self.action == "list":
return EventListSerializer
return EventSerializer
def perform_create(self, serializer):
# Use authenticated user as organizer if not explicitly set
if not serializer.validated_data.get("organizer"):
serializer.save(organizer=self.request.user)
else:
# If organizer is set manually, check permission
if serializer.validated_data["organizer"] != self.request.user:
raise PermissionDenied("You can only create events for yourself.")
serializer.save()
def perform_update(self, serializer):
if serializer.instance.organizer != self.request.user:
raise PermissionDenied("You can only update your own events.")
serializer.save()
def perform_destroy(self, instance):
if instance.organizer != self.request.user:
raise PermissionDenied("You can only delete your own events.")
instance.delete()
@action(detail=True, methods=["get"], url_path="registrations")
def registrations(self, request, pk=None):
"""Get all registrations for a specific event"""
event = self.get_object()
registrations = event.registrations.select_related("user")
serializer = EventRegistrationSerializer(registrations, many=True)
return Response(serializer.data)
class EventRegistrationViewSet(viewsets.ModelViewSet):
queryset = EventRegistration.objects.all().select_related("event", "user")
serializer_class = EventRegistrationSerializer
permission_classes = [permissions.IsAuthenticated]
def perform_create(self, serializer):
user = self.request.user
event = serializer.validated_data["event"]
# Check for duplicate registration
if EventRegistration.objects.filter(event=event, user=user).exists():
raise PermissionDenied("You have already registered for this event.")
serializer.save(user=user)
def perform_update(self, serializer):
registration = serializer.instance
if registration.user != self.request.user:
raise PermissionDenied("You can only update your own registration.")
serializer.save()
def perform_destroy(self, instance):
if instance.user != self.request.user:
raise PermissionDenied("You can only cancel your own registration.")
instance.delete()