gault-millau/apps/news/serializers.py

"""News app common serializers."""
from django.utils.translation import gettext_lazy as _
from rest_framework import serializers

from account.serializers.common import UserBaseSerializer
from gallery.models import Image
from gallery.serializers import ImageSerializer
from location import models as location_models
from location.serializers import CountrySimpleSerializer
from main.serializers import MetaDataContentSerializer
from news import models
from utils.serializers import TranslatedField, ProjectModelSerializer


class NewsCropImageSerializer(ImageSerializer):
    """Serializer for returning crop images of news image."""
    orientation_display = serializers.CharField(source='get_orientation_display',
                                                read_only=True)
    web_url = serializers.SerializerMethodField()
    mobile_url = serializers.SerializerMethodField()

    class Meta:
        model = Image
        fields = [
            'id',
            'title',
            'orientation_display',
            'web_url',
            'mobile_url',
        ]
        extra_kwargs = {
            'orientation': {'write_only': True}
        }

    def get_web_url(self, obj):
        """Return URL of cropped image by thumbnail."""
        return obj.get_image_url('news_promo_horizontal_web')

    def get_mobile_url(self, obj):
        """Return URL of cropped image by thumbnail."""
        return obj.get_image_url('news_promo_horizontal_mobile')


class NewsImageSerializer(ImageSerializer):
    """News images"""
    url = serializers.URLField(source='image.url', read_only=True)
    crops = NewsCropImageSerializer(source='children', allow_null=True, many=True)

    class Meta:
        model = Image
        fields = [
            'id',
            'title',
            'url',
            'crops',
        ]
        extra_kwargs = {
            'orientation': {'write_only': True}
        }


class NewsTypeSerializer(serializers.ModelSerializer):
    """News type serializer."""

    class Meta:
        """Meta class."""

        model = models.NewsType
        fields = ('id', 'name')


class NewsBaseSerializer(ProjectModelSerializer):
    """Base serializer for News model."""

    # read only fields
    title_translated = TranslatedField()
    subtitle_translated = TranslatedField()

    # related fields
    news_type = NewsTypeSerializer(read_only=True)
    tags = MetaDataContentSerializer(read_only=True, many=True)
    gallery = NewsImageSerializer(source='original_images', read_only=True, many=True)

    class Meta:
        """Meta class."""

        model = models.News
        fields = (
            'id',
            'title_translated',
            'subtitle_translated',
            'is_highlighted',
            'news_type',
            'tags',
            'slug',
            'gallery',
        )


class NewsDetailSerializer(NewsBaseSerializer):
    """News detail serializer."""

    description_translated = TranslatedField()
    country = CountrySimpleSerializer(read_only=True)
    author = UserBaseSerializer(source='created_by', read_only=True)
    state_display = serializers.CharField(source='get_state_display',
                                          read_only=True)

    class Meta(NewsBaseSerializer.Meta):
        """Meta class."""

        fields = NewsBaseSerializer.Meta.fields + (
            'description_translated',
            'start',
            'end',
            'playlist',
            'is_publish',
            'state',
            'state_display',
            'author',
            'country',
        )


class NewsDetailWebSerializer(NewsDetailSerializer):
    """News detail serializer for web users.."""

    same_theme = NewsBaseSerializer(many=True, read_only=True)
    should_read = NewsBaseSerializer(many=True, read_only=True)

    class Meta(NewsDetailSerializer.Meta):
        """Meta class."""

        fields = NewsDetailSerializer.Meta.fields + (
            'same_theme',
            'should_read',
        )


class NewsBackOfficeBaseSerializer(NewsBaseSerializer):
    """News back office base serializer."""

    class Meta(NewsBaseSerializer.Meta):
        """Meta class."""

        fields = NewsBaseSerializer.Meta.fields + (
            'title',
            'subtitle',
        )


class NewsBackOfficeDetailSerializer(NewsBackOfficeBaseSerializer,
                                     NewsDetailSerializer):
    """News detail serializer for back-office users."""

    news_type_id = serializers.PrimaryKeyRelatedField(
        source='news_type', write_only=True,
        queryset=models.NewsType.objects.all())
    country_id = serializers.PrimaryKeyRelatedField(
        source='country', write_only=True,
        queryset=location_models.Country.objects.all())
    template_display = serializers.CharField(source='get_template_display',
                                             read_only=True)

    class Meta(NewsBackOfficeBaseSerializer.Meta, NewsDetailSerializer.Meta):
        """Meta class."""

        fields = NewsBackOfficeBaseSerializer.Meta.fields + \
                 NewsDetailSerializer.Meta.fields + (
                    'description',
                    'news_type_id',
                    'country_id',
                    'template',
                    'template_display',
                 )


class NewsBackOfficeGallerySerializer(serializers.ModelSerializer):
    """Serializer class for model NewsGallery."""
    class Meta:
        """Meta class"""
        model = models.NewsGallery
        fields = [
            'id',
        ]

    def get_request_kwargs(self):
        """Get url kwargs from request."""
        return self.context.get('request').parser_context.get('kwargs')

    def validate(self, attrs):
        """Override validate method."""
        news_pk = self.get_request_kwargs().get('pk')
        image_id = self.get_request_kwargs().get('image_id')

        news_qs = models.News.objects.filter(pk=news_pk)
        image_qs = Image.objects.filter(id=image_id)

        if not news_qs.exists():
            raise serializers.ValidationError({'detail': _('News not found')})
        if not image_qs.exists():
            raise serializers.ValidationError({'detail': _('Image not found')})

        news = news_qs.first()
        image = image_qs.first()

        if news.news_gallery.filter(image=image).exists():
            raise serializers.ValidationError({'detail': _('Image is already added')})

        attrs['news'] = news
        attrs['image'] = image

        return attrs