class Tip_Serializer(serializers.HyperlinkedModelSerializer):
author = UserDetailSerializer(read_only=True)
class Meta:
model = Tip
fields = ('url', 'id', 'author', 'category', 'title', 'body',
'photo_field', 'pub_date')
def custom_jwt_response_handler(token, user=None, request=None):
return {
'token': token,
'user': UserDetailSerializer(user, context={
'request': request
}).data
}
class PostDetailSerializer(ModelSerializer):
url = post_detail_url
user = UserDetailSerializer(read_only=True)
image = SerializerMethodField()
html = SerializerMethodField()
comments = SerializerMethodField()
class Meta:
model = Post
fields = [
'url',
'title',
'slug',
'image',
'content',
'html',
'user',
'comments',
]
def get_html(self, obj):
return obj.get_markdown()
def get_image(self, obj):
try:
image = obj.image.url
except:
image = None
return image
def get_comments(self, obj):
c_qs = Comment.objects.filter_by_instance(obj)
comments = CommentSerializer(c_qs, many=True).data
return comments
class AdvertisementInfoSerializer(serializers.ModelSerializer):
user = UserDetailSerializer()
store = StoreSerializer()
class Meta:
model = Advertisement
fields = ['id', 'image', 'user', 'store']
class CommentDetailSerializer(serializers.ModelSerializer):
user = UserDetailSerializer(read_only=True)
replies = serializers.SerializerMethodField()
reply_count = serializers.SerializerMethodField()
class Meta:
model = Comment
fields = [
'id',
'user',
'content',
'timestamp',
'reply_count',
'replies',
]
read_only_fields = [
'reply_count',
'replies',
]
def get_replies(self, obj):
if obj.is_parent:
return CommentChildSerializer(obj.children(), many=True).data
def get_reply_count(self, obj):
if obj.is_parent:
return obj.children().count()
return 0
class CommentDetailSerializer(ModelSerializer):
replies = SerializerMethodField()
reply_count = SerializerMethodField()
user = UserDetailSerializer(read_only=True)
content_object_url = SerializerMethodField()
class Meta:
model = Comment
fields = [
'id',
'user',
'content',
'replies',
'reply_count',
'timestamp',
'content_object_url',
]
read_only_fields = ['reply_count', 'replies']
def get_content_object_url(self, obj):
try:
return obj.content_object.get_absolute_url()
except:
return None
def get_replies(self, obj):
if obj.is_parent:
return CommentChildSerializer(obj.children(), many=True).data
return None
def get_reply_count(self, obj):
if obj.is_parent:
return obj.children().count()
return 0
class CommentDetailSerializer(ModelSerializer):
reply_count = SerializerMethodField()
replies = SerializerMethodField()
author = UserDetailSerializer(read_only=True)
class Meta:
model = Comment
fields = [
'id',
'author',
'post',
'content',
'reply_count',
'replies',
'created',
]
read_only_fields = [
'post',
]
def get_reply_count(self, obj):
if obj.is_parent:
return obj.children().count()
return 0
def get_replies(self, obj):
if obj.is_parent:
return CommentChildSerializer(obj.children(), many=True).data
return None
class Comment_Serializer(serializers.HyperlinkedModelSerializer):
reply_set = RecursiveSerializer(many=True, read_only=True)
author = UserDetailSerializer()
class Meta:
model = Comment
fields = ('url', 'id', 'author', 'body', 'cocktail', 'date', 'parent',
'reply_set')
class FoundPostingDetailSerializer(serializers.ModelSerializer):
thumbnail = serializers.StringRelatedField(many=True)
user = UserDetailSerializer()
class Meta:
model = FoundPosting
fields = ('id', 'color', 'category', 'created', 'modified', 'content',
'status', 'thumbnail', 'user')
class LikeListSerializer(ModelSerializer):
user = UserDetailSerializer()
class Meta:
model = Post
fields = [
'id',
'user',
]
def post(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
if serializer.is_valid(raise_exception=True):
user = UserDetailSerializer(serializer.user).data
serializer.validated_data.update({"user": user})
return Response(serializer.validated_data, )
return Response(serializer.errors, status=status.HTTP_404_NOT_FOUND)
def test_user_can_view_other_effort(self):
self.client.force_login(self.user2)
response = self.client.get(
reverse('user-detail', kwargs={'pk': self.user.pk}))
serialized = UserDetailSerializer(self.user)
self.assertEqual(response.data, serialized.data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
class CommentChildSerializer(ModelSerializer):
user = UserDetailSerializer(read_only=True)
class Meta:
model = Comment
fields = [
'id',
'user',
'content',
'timestamp',
]
def post(self, request, *args, **kwargs):
username = request.data.get("username", "")
password = request.data.get("password", "")
user = authenticate(request, username=username, password=password)
if user is not None:
# login saves the user’s ID in the session,
# using Django’s session framework.
login(request, user)
token_serializer = TokenSerializer(
data={
# using drf jwt utility functions to generate a token
"token": jwt_encode_handler(jwt_payload_handler(user))
})
token_serializer.is_valid()
user_serializer = UserDetailSerializer(user)
if user.is_institution_administrator == True:
try:
related_institution = Institution.objects.get(
created_by=user)
institution = {
"id":
related_institution.pk,
"institution_status":
related_institution.is_institution_active
}
except:
institution = {"status": "No institution created yet"}
elif user.is_loan_officer == True:
institution_staff = InstitutionStaff.objects.get(user_id=user)
assigned_institution = Institution.objects.get(
id=institution_staff.institution_id.pk)
institution = {
"id":
assigned_institution.pk,
"institution_status":
assigned_institution.is_institution_active
}
elif user.is_teller == True:
institution_staff = InstitutionStaff.objects.get(user_id=user)
assigned_institution = Institution.objects.get(
id=institution_staff.institution_id.pk)
institution = {
"id":
assigned_institution.pk,
"institution_status":
assigned_institution.is_institution_active
}
login_data = {
"user_data": user_serializer.data,
"token_data": token_serializer.data,
"institution": institution
}
return Response(login_data)
return Response(status=status.HTTP_404_NOT_FOUND)
class CommentSerializer(serializers.ModelSerializer):
user = UserDetailSerializer(read_only=True)
class Meta:
model = Comment
# fields = ('id','user','content','created_at')
fields = "__all__"
read_only_fields = (
'review',
'like_users',
)
class ItineraryDetailSerializer(ModelSerializer):
city = SerializerMethodField()
image = SerializerMethodField()
user = UserDetailSerializer(read_only=True)
likes = SerializerMethodField()
def get_image(self, obj):
"""
If an image was uploaded, we add its url
"""
try:
image = obj.image.url
except:
image = None
return image
def get_city(self, obj):
return {
'pk': obj.city.pk,
'name': obj.city.name,
'country': obj.city.country,
'currency': obj.city.currency,
'language': obj.city.language
}
def get_likes(self, obj):
return obj.likes.count()
class Meta:
model = Itinerary
fields = [
'pk',
'title',
'budget',
'city',
'day1_morning',
'day1_lunch',
'day1_afternoon',
'day1_diner',
'day2_morning',
'day2_lunch',
'day2_afternoon',
'day2_diner',
'day3_morning',
'day3_lunch',
'day3_afternoon',
'day3_diner',
'image',
'likes',
'number_of_days',
'user',
'views',
'created_date',
]
class CommentChildSerializer(ModelSerializer):
author = UserDetailSerializer()
class Meta:
model = Comment
fields = [
'id',
'author',
'content',
'created',
]
class RecommendationDetailSerializer(ModelSerializer):
city = SerializerMethodField()
comments = SerializerMethodField()
delete_url = recommendation_delete_url
image = SerializerMethodField()
url = recommendation_url
update_url = recommendation_update_url
user = UserDetailSerializer(read_only=True)
def get_image(self, obj):
"""
If an image was uploaded, we add its url
"""
# TODO: the media upload doesn't work !!!!
try:
image = obj.image.url;
except:
image = None
return image
def get_comments(self, obj):
comments_qs = Comment.objects.filter_by_instance(obj)
comments = CommentSerializer(comments_qs, many=True).data
return comments
def get_city(self, obj):
return {
'name': obj.city.name,
'country': obj.city.country,
'currency': obj.city.currency,
'language': obj.city.language
}
class Meta:
model = Recommendation
fields = [
'title',
'budget',
'city',
'comments',
'content_day1',
'content_day2',
'content_day3',
'image',
'likes',
'number_of_days',
'user',
'views',
'created_date',
'url',
'update_url',
'delete_url',
]
def get_user_view(request: Request) -> Response:
"""[summary]
Arguments:
request {Request} -- [description]
Schma:
GET:
POST:
Raises:
PermissionError: [description]
ConnectionRefusedError: [description]
Returns:
Response -- [description]
"""
serializer: Serializer
if request.method == "GET":
queryset = get_user_model().objects.all()
serializer = UserDetailSerializer(queryset, many=True)
raise PermissionError("error", "try Get or post")
return Response(serializer.data)
if request.method == "POST":
serializer = UserCreateSerializer(data=request.data,
status=status.HTTP_200_OK)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
raise ConnectionRefusedError()
class ReviewSerializer(serializers.ModelSerializer):
user = UserDetailSerializer(read_only=True)
movie = MovieDetailSerializer(read_only=True)
comment_set = CommentSerializer(read_only=True, many=True)
comment_count = serializers.IntegerField(source='comment_set.count',
read_only=True)
class Meta:
model = Review
fields = "__all__"
# exclude = ('like_users','funny_users','helpful_users')
read_only_fields = ('movie', 'user', 'like_users', 'funny_users',
'helpful_users')
class PostListSerializer(ModelSerializer):
url = post_detail_url
user = UserDetailSerializer(read_only=True)
class Meta:
model = Post
fields = [
'url',
'title',
'content',
'user',
'publish',
]
class PostDetailSerializer(serializers.ModelSerializer):
user = UserDetailSerializer(read_only=True)
comments = serializers.SerializerMethodField()
class Meta:
model = Post
fields = [
'user', 'id', 'title', 'slug', 'content', 'publish', 'comments'
]
def get_comments(self, obj):
c_qs = Comment.objects.filter_by_instance(obj)
comments = CommentListSerializer(c_qs, many=True).data
return comments
class RecommendationsListSerializer(ModelSerializer):
url = recommendation_url
user = UserDetailSerializer(read_only=True)
class Meta:
model = Recommendation
fields = [
'title',
'city',
'likes',
'number_of_days',
'slug',
'url',
'user',
'views'
]
class PostDetailSerializer(ModelSerializer):
user = UserDetailSerializer(read_only=True)
likes = LikeListSerializer(many=True, read_only=True)
class Meta:
model = Post
fields = [
'id', 'user', 'title', 'content', 'number_of_likes', 'likes',
'is_published', 'updated', 'timestamp'
]
def __init__(self, *args, **kwargs):
fields = kwargs.pop('fields', None)
super(PostDetailSerializer, self).__init__(*args, **kwargs)
show_who_liked = self.context['request'].GET.get('likes')
if not show_who_liked == '1':
self.fields.pop('likes')
class CommentDetailSerializer(ModelSerializer):
replies = SerializerMethodField()
user = UserDetailSerializer(read_only=True)
@staticmethod
def get_replies(obj):
if obj.is_parent:
return CommentChildSerializer(obj.children(), many=True).data
else:
return None
class Meta:
model = Comment
fields = [
'id',
'user',
'content',
'timestamp',
'replies',
]
class CommentSerializer(ModelSerializer):
reply_count = SerializerMethodField()
author = UserDetailSerializer()
class Meta:
model = Comment
fields = [
'id',
'author',
'post',
'content',
'parent',
'reply_count',
'created',
]
def get_reply_count(self, obj):
if obj.is_parent:
return obj.children().count()
return 0
class ItineraryListSerializer(ModelSerializer):
user = UserDetailSerializer(read_only=True)
city = SerializerMethodField()
def get_city(self, obj):
return {
'name': obj.city.name,
}
class Meta:
model = Itinerary
fields = [
'title',
'city',
'image',
'likes',
'number_of_days',
'slug',
'user',
'views'
]
class Cocktail_Serializer(serializers.HyperlinkedModelSerializer):
author = UserDetailSerializer()
tags = StringListField()
comments = serializers.StringRelatedField(many=True)
likes = serializers.StringRelatedField(many=True)
class Meta:
model = Cocktail
fields = ('url', 'id', 'author', 'category', 'title', 'photo_field',
'body', 'method', 'pub_date', 'updated_at', 'ingridient',
'tags', 'comments', 'likes')
def create(self, validated_data):
tags = validated_data.pop('tags')
instance = super(MyModelSerializer, self).create(validated_data)
instance.tags.set(*tags)
return instance
def update(self, instance, validated_data):
tags = validated_data.pop('tags')
instance = super(MyModelSerializer, self).create(validated_data)
instance.tags.set(*tags)
return instance
class OrderDetailSerializer(ModelSerializer):
order_items = SerializerMethodField()
buyer = UserDetailSerializer(read_only=True)
def get_order_items(self, obj):
order_number = obj.pk
items = OrderItem.objects.filter(order=order_number)
order = []
for item in items:
order.append({
"name": item.product.name,
"type": item.product.type,
"price": item.product.price
})
return order
class Meta:
model = Order
fields = [
'pk',
'buyer',
'creation_date',
'order_items',
]
def review_detail(request, review_id):
review = get_object_or_404(Review, id=review_id)
review_list = [review]
reviewserializer = ReviewSerializer(data=review_list, many=True)
likedMovie_users = get_user_model().objects.filter(
review__liked=True, review__movie=review.movie).distinct()
userSerializer = UserDetailSerializer(data=likedMovie_users, many=True)
loginUserSerializer = UserDetailSerializer(data=[request.user], many=True)
print(reviewserializer.is_valid(), userSerializer.is_valid(),
loginUserSerializer.is_valid())
context = {
"0": reviewserializer.data[0],
"1": userSerializer.data,
"2": loginUserSerializer.data,
}
return Response(context)
