307 lines
9.0 KiB
Python
307 lines
9.0 KiB
Python
from rest_framework import serializers
|
|
from taggit_serializer.serializers import TagListSerializerField
|
|
from accounts.models import IAmPrincipalLocation
|
|
from manage_cms.api.serializers import TagSerializer
|
|
from taggit.models import Tag
|
|
from manage_events.utils import get_location_info
|
|
from accounts.api.serializers import ProfileSerializer
|
|
from manage_events.models import (
|
|
EventMaster,
|
|
Event,
|
|
EventCategory,
|
|
EventImage,
|
|
EventPrincipalInteraction,
|
|
EventReview,
|
|
Favorites,
|
|
Venue,
|
|
PrincipalPreference,
|
|
)
|
|
|
|
|
|
class EventImageSerializer(serializers.ModelSerializer):
|
|
class Meta:
|
|
model = EventImage
|
|
fields = ["image"]
|
|
|
|
def get_image(self, obj):
|
|
request = self.context.get("request")
|
|
if obj.image and hasattr(obj.image, "url"):
|
|
return request.build_absolute_uri(obj.image.url)
|
|
return None
|
|
|
|
|
|
class VenueSerializer(serializers.ModelSerializer):
|
|
created_by = ProfileSerializer(read_only=True)
|
|
|
|
class Meta:
|
|
model = Venue
|
|
fields = "__all__"
|
|
read_only_fields = ("created_by",)
|
|
|
|
|
|
class EventCategorySerializer(serializers.ModelSerializer):
|
|
class Meta:
|
|
model = EventCategory
|
|
fields = ["id", "title", "image", "description", "video_url"]
|
|
|
|
|
|
class EventListSerializer(serializers.ModelSerializer):
|
|
# category = EventCategorySerializer(read_only=True)
|
|
# venue = VenueSerializer(read_only=True)
|
|
# draft = serializers.BooleanField(read_only=True)
|
|
# tags = TagSerializer(many=True, read_only=True)
|
|
|
|
class Meta:
|
|
model = Event
|
|
fields = [
|
|
"id",
|
|
"title",
|
|
"description",
|
|
"start_date",
|
|
"end_date",
|
|
# "from_time",
|
|
# "to_time",
|
|
# "category",
|
|
# "venue",
|
|
# "venue_capacity",
|
|
"image",
|
|
# "video_url",
|
|
# "entry_type",
|
|
"entry_fee",
|
|
"key_guest",
|
|
# "age_group",
|
|
# "images",
|
|
# "is_favorited",
|
|
# "reviews",
|
|
# "tags",
|
|
# "principal_interaction",
|
|
# "draft",
|
|
]
|
|
|
|
|
|
class EventDetailSerializer(serializers.ModelSerializer):
|
|
tags = TagSerializer(many=True, read_only=True)
|
|
images = serializers.SerializerMethodField()
|
|
venue = VenueSerializer(read_only=True) # Use VenueSerializer for the venue field
|
|
category = EventCategorySerializer(read_only=True)
|
|
is_favorited = serializers.SerializerMethodField()
|
|
reviews = serializers.SerializerMethodField()
|
|
principal_interaction = serializers.SerializerMethodField()
|
|
draft = serializers.BooleanField(read_only=True)
|
|
|
|
class Meta:
|
|
model = Event
|
|
fields = [
|
|
"id",
|
|
"title",
|
|
"description",
|
|
"start_date",
|
|
"end_date",
|
|
"from_time",
|
|
"to_time",
|
|
"category",
|
|
"venue",
|
|
"venue_capacity",
|
|
"image",
|
|
"video_url",
|
|
"entry_type",
|
|
"entry_fee",
|
|
"key_guest",
|
|
"coupon_code",
|
|
"coupon_description",
|
|
"age_group",
|
|
"images",
|
|
"is_favorited",
|
|
"reviews",
|
|
"tags",
|
|
"principal_interaction",
|
|
"draft",
|
|
]
|
|
|
|
def get_images(self, obj):
|
|
images = (
|
|
obj.event_images.all()
|
|
) # Ensure this uses the correct related_name from your model
|
|
return EventImageSerializer(images, many=True, context=self.context).data
|
|
|
|
def get_is_favorited(self, obj):
|
|
request = self.context.get("request")
|
|
if request and hasattr(request, "user"):
|
|
user = request.user
|
|
return Favorites.objects.filter(event=obj, principal=user).exists()
|
|
return False
|
|
|
|
def get_reviews(self, obj):
|
|
# related_name is 'reviews' as defined in EventReview model
|
|
reviews = obj.reviews.all()
|
|
return EventReviewSerializer(reviews, many=True, context=self.context).data
|
|
|
|
def get_principal_interaction(self, obj):
|
|
request = self.context.get("request")
|
|
if request and hasattr(request, "user") and not request.user.is_anonymous:
|
|
user = request.user
|
|
interaction = EventPrincipalInteraction.objects.filter(
|
|
event=obj, principal=user
|
|
).first()
|
|
if interaction:
|
|
return {
|
|
"status": interaction.status,
|
|
"status_display": interaction.get_status_display(),
|
|
}
|
|
return None
|
|
|
|
|
|
class CreateEventSerializer(serializers.ModelSerializer):
|
|
tags = TagListSerializerField(required=False)
|
|
images = serializers.ListField(
|
|
child=serializers.ImageField(), write_only=True, required=False
|
|
)
|
|
|
|
class Meta:
|
|
model = Event
|
|
fields = [
|
|
"id",
|
|
"images",
|
|
"title",
|
|
"description",
|
|
"image",
|
|
"start_date",
|
|
"end_date",
|
|
"from_time",
|
|
"to_time",
|
|
"category",
|
|
"venue_capacity",
|
|
"video_url",
|
|
"entry_type",
|
|
"entry_fee",
|
|
"key_guest",
|
|
"age_group",
|
|
"draft",
|
|
"venue",
|
|
"tags",
|
|
"coupon_code",
|
|
"coupon_description",
|
|
]
|
|
|
|
def create(self, validated_data):
|
|
tags = validated_data.pop("tags", None)
|
|
images_data = validated_data.pop("images", None)
|
|
event = Event.objects.create(**validated_data)
|
|
|
|
if tags:
|
|
event.tags.add(*tags)
|
|
|
|
if images_data:
|
|
for image_data in images_data:
|
|
EventImage.objects.create(event=event, image=image_data)
|
|
|
|
return event
|
|
|
|
def update(self, instance, validated_data):
|
|
tags = validated_data.pop("tags", None)
|
|
images_data = validated_data.pop("images", None)
|
|
|
|
# Update fields if there is any change.
|
|
if tags is not None:
|
|
# Clear existing tags and add the new ones
|
|
instance.tags.clear()
|
|
instance.tags.add(*tags)
|
|
|
|
if images_data is not None:
|
|
# Assuming you want to add new images without deleting the old ones
|
|
# If you want to replace them, you should delete the old images first
|
|
for image_data in images_data:
|
|
EventImage.objects.create(event=instance, image=image_data)
|
|
|
|
# Update other fields
|
|
for attr, value in validated_data.items():
|
|
setattr(instance, attr, value)
|
|
instance.save()
|
|
|
|
return instance
|
|
|
|
|
|
class CreateVenueSerializer(serializers.ModelSerializer):
|
|
class Meta:
|
|
model = Venue
|
|
fields = [
|
|
"title",
|
|
"description",
|
|
"address",
|
|
"image",
|
|
"url",
|
|
"latitude",
|
|
"longitude",
|
|
]
|
|
|
|
|
|
class IAmPrincipalLocationSerializer(serializers.ModelSerializer):
|
|
class Meta:
|
|
model = IAmPrincipalLocation
|
|
fields = ["latitude", "longitude"]
|
|
|
|
|
|
class PrincipalPreferenceSerializer(serializers.ModelSerializer):
|
|
preferred_categories = serializers.PrimaryKeyRelatedField(
|
|
many=True, queryset=EventCategory.objects.all()
|
|
)
|
|
|
|
class Meta:
|
|
model = PrincipalPreference
|
|
fields = ["preferred_categories"] # Removed 'principal' from fields
|
|
|
|
def create(self, validated_data):
|
|
# Accessing the principal from the context
|
|
user = self.context["request"].user
|
|
preferred_categories = validated_data.pop("preferred_categories")
|
|
principal_preference, created = PrincipalPreference.objects.update_or_create(
|
|
principal=user, defaults={}
|
|
)
|
|
principal_preference.preferred_categories.set(preferred_categories)
|
|
return principal_preference
|
|
|
|
def update(self, instance, validated_data):
|
|
instance.preferred_categories.set(
|
|
validated_data.get(
|
|
"preferred_categories", instance.preferred_categories.all()
|
|
)
|
|
)
|
|
instance.save()
|
|
return instance
|
|
|
|
|
|
class EventMasterSearchSerializer(serializers.Serializer):
|
|
title = serializers.CharField(max_length=255)
|
|
|
|
|
|
class EventMasterSerializer(serializers.ModelSerializer):
|
|
class Meta:
|
|
model = EventMaster
|
|
fields = "__all__"
|
|
|
|
|
|
class EventDateRangeSerializer(serializers.Serializer):
|
|
start_date = serializers.DateField(format="%Y-%m-%d", input_formats=["%Y-%m-%d"])
|
|
end_date = serializers.DateField(format="%Y-%m-%d", input_formats=["%Y-%m-%d"])
|
|
|
|
|
|
class EventReviewSerializer(serializers.ModelSerializer):
|
|
principal = ProfileSerializer(read_only=True)
|
|
|
|
class Meta:
|
|
model = EventReview
|
|
fields = ["id", "event", "principal", "review_text", "rating"]
|
|
extra_kwargs = {
|
|
"principal": {"read_only": True},
|
|
}
|
|
|
|
def create(self, validated_data):
|
|
validated_data["principal"] = self.context["request"].user
|
|
return super().create(validated_data)
|
|
|
|
|
|
class TagSerializer(serializers.ModelSerializer):
|
|
class Meta:
|
|
model = Tag
|
|
fields = ["name"]
|