예제 #1
0
class CommentSerializer(serializers.ModelSerializer):
    author = ProfileSerializer(required=False)

    createdAt = serializers.SerializerMethodField(method_name='get_created_at')
    updatedAt = serializers.SerializerMethodField(method_name='get_updated_at')

    class Meta:
        model = Comment
        fields = (
            'id',
            'author',
            'body',
            'createdAt',
            'updatedAt',
        )

    def create(self, validated_data):
        article = self.context['article']
        author = self.context['author']

        return Comment.objects.create(author=author,
                                      article=article,
                                      **validated_data)

    def get_created_at(self, instance):
        return instance.created_at.isoformat()

    def get_updated_at(self, instance):
        return instance.updated_at.isoformat()
예제 #2
0
class UserSerializer(serializers.ModelSerializer):
    """Handles serialization and deserialization of User objects."""

    password = serializers.CharField(max_length=128,
                                     min_length=8,
                                     write_only=True)

    profile = ProfileSerializer(write_only=True)
    print(profile)
    bio = serializers.CharField(source='profile.bio', read_only=True)
    image = serializers.CharField(
        source='profile.image',
        read_only=True,
        default='https://avatars.dicebear.com/4.5/api/avataaars/.svg')

    class Meta:
        model = User
        fields = ('id', 'email', 'username', 'password', 'token', 'profile',
                  'bio', 'image', 'is_staff')
        read_only_fields = ('token', )

    def update(self, instance, validated_data):
        """Performs an update on a User."""
        password = validated_data.pop('password', None)
        profile_data = validated_data.pop('profile', {})
        # print(validated_data.pop('profile', {}))
        # print(profile_data)
        for (key, value) in validated_data.items():
            setattr(instance, key, value)

        if password is not None:
            instance.set_password(password)
        instance.save()

        for (key, value) in profile_data.items():
            setattr(instance.profile, key, value)

        instance.profile.save()

        return instance
예제 #3
0
class UserSerializer(serializers.ModelSerializer):

    password = serializers.CharField(max_length=128,
                                     min_length=8,
                                     write_only=True)

    profile = ProfileSerializer(write_only=True)

    bio = serializers.CharField(source='profile.bio', read_only=True)
    image = serializers.CharField(source='profile.image', read_only=True)
    last_seen = serializers.CharField(source='get_last_seen')

    class Meta:
        model = User
        fields = ('id', 'email', 'username', 'password', 'token', 'profile',
                  'bio', 'image', 'is_admin', 'is_active', 'online',
                  'last_seen')

        read_only_fields = ('token', )

    def update(self, instance, validated_data):

        password = validated_data.pop('password', None)
        profile_data = validated_data.pop('profile', {})

        for (key, value) in validated_data.items():
            setattr(instance, key, value)

        if password is not None:
            instance.set_password(password)

        instance.save()

        for (key, value) in profile_data.items():
            setattr(instance.profile, key, value)

        instance.profile.save()

        return instance
예제 #4
0
class TrainingSerializer(serializers.ModelSerializer):
    difficulties = DifficultySerializer(
        many=True, source="exercices_t"
    )  #SOURCE HACE REFERENCIA A RELATED_NAME EN MODELO TRAINING/MODELS.PY DE
    author = ProfileSerializer(read_only=True)

    class Meta:
        model = Training
        fields = [
            'id', 'name', 'slug', 'image', 'description', 'verified', 'author',
            'difficulties'
        ]

    def create(self, validated_data):
        difficulties_data = validated_data.pop('exercices_t')
        author = self.context.get('author', None)

        training = Training.objects.create(author=author, **validated_data)
        for difficultie in difficulties_data:
            d = dict(difficultie)
            Difficulty.objects.create(training=training, **d)
        return training
예제 #5
0
class TrainingSerializer(serializers.ModelSerializer):

    difficulties = DifficultySerializer(many=True, write_only=True)
    # exercices = serializers.ListField(read_only=True)

    exercices = serializers.SerializerMethodField()

    def get_exercices(self, obj):
        print("LELELELELELELELELELELELELELELELE")
        print(self)
        print(obj)
        ##SOLO FUNCIONA EN POST# SOLO MUESTRA EL ID DEL EJERCICIO
        data = self.__dict__.get('_kwargs').get('data').get('difficulties')
        print(data)

        return data
        # list_exer = list()
        # for value, dset in zip(entry[1:], data[entry[0]]):
        # #     list_exer.add(value)
        # for diff in data:
        # exer = Exercice.objects.get(id=diff.get('exercice'))
        #     # exer =Difficulty.objects.bulk_create(diff.get('exercice'))
        #     list_exer.append(exer)
        #     # print(exer)

        # print(list_exer)
        # json_data = json.dumps(list_exer)
        # objects = []
        # for month, sales, expenses in zip(*my_list):
        #     objects.append(MyModel(
        #         month=month,
        #         sales=sales,
        #         expenses=expenses
        #     ))
        # MyModel.objects.bulk_create(objects)

        # exers = Comment.objects.filter(track__in=obj.tracks.all())
        # return CommentSerializer(comments, many=True).data
        # data.set(list_exer)

        # return DifficultySerializer(data, many=True).data

    #declaramos tambien exercices_id para al realizar el insert pongamos solo las ID (write only)
    # exercices_id = serializers.PrimaryKeyRelatedField(queryset=Exercice.objects.all(), write_only=True,many=True)
    # difs = DifficultySerializer(many=True, read_only=True)
    author = ProfileSerializer(read_only=True)
    description = serializers.CharField(required=False)
    verified = serializers.BooleanField(default=False)

    # difs = serializers.SerializerMethodField()
    # def get_difs(self,obj):

    class Meta:
        model = Training
        fields = [
            'id', 'name', 'slug', 'image', 'description', 'verified', 'author',
            'difficulties', 'exercices'
        ]

    def create(self, validated_data):
        difficulties_data = validated_data.pop('difficulties')

        # exercices = Difficulty.objects.create(**exercices_data)

        author = self.context.get('author', None)

        training = Training.objects.create(author=author, **validated_data)
        # for exercice in exercices_data:
        #     exercices_list.append(Difficulty.objects.create(**exercice, training = training))
        # print(exercices_list)
        # training.exercices.set(exercices_list)
        # training.save()

        dif_list = []
        for dif_data in difficulties_data:
            print("EXERCICE")
            # print(dif_data)
            Difficulty.objects.create(**dif_data, training=training)

            # dif_list.append(ex_c)

        # exercices = "holaholahola"
        # ex_c.exercice.all()
        # training.exercices.append(**dif_list)
        # print(dif_list)
        # training.difficulties_set.all()

        # for dif in difficulties_data:

        #     # Exercice.objects.get(="Cheddar Talk")
        #     print(b)

        return training
        # Group.objects.create(member=member, **group)
        # for memberhip in memberships:
        #     Membership.objects.create(group=group, **memberships)
        # print(dict(exercice.exercice_id))
        # print(dict(exercice).get("exercice_id"))
        # exer_id = exercice.exercice_id
        # exercice_c = Difficulty.objects.create( training = training, exercice_id=dict(exercice).get("exercice_id"))
        # dif = Difficulty.objects.create(**diffff, training = training)
        # # training.difs.add(dif)
        # dif_list.append(dif)
        # dif.save()
        # training.difficulties.all()

        # dif.all()
        # print(exercice_c.pk)
        # training.create(**exercice)

        # for exercice in exercices

        # training = TrainingSerializer(exercices = exercice_c)
        # print(exercice_c.exercice.id)
        # training.exercices.create(exercice=exercice_c)
        # training.exercices.append(exercice_c)
        # print("CREATED")
        # print(exercice_c.pk)
        # print(training.exercices)
        # training.save()

        # print(exercice_c.pk)

        # training.exercices.add(exercice_c.pk)

        # print(training.exercices)

        # training.exercices.add(*exercices_data)
        # training.save()
        # training.exercices.append(exercices_data)
        # print(training)

        # a_list = []
        # print(json.loads(json.dumps(exercices_data)))
        # training.exercices.set(exercices)
        # # print(dict(zip(exercices_data,range(len(exercices_data)))))
        # for exercice in exercices_data:
        #     # print(index)
        #     print(exercice)
        #     print(exercice.__hash__())
        #     # a_list.append(exercice)
        #     # training.exercices["uno"].append(exercice)

        #     # print(dict(exercice))

        #     training.exercices.add(exercice)
        #     # print(a_list)
        # # training.exercices.add(a_list)
        # print(training.exercices)
        # training.difficulties.set(dif_list)


# class DifficultySerializer(serializers.ModelSerializer):
#     class Meta:
#         model = Difficulty
#         fields = (
#             "sets",
#             "exercice",
#             "training",
#             'duration',
#             'repetitions'
#         )
# sets = serializers.CharField(required=False)
# duration = serializers.CharField(required=False)
# repetitions = serializers.CharField(required=False)
# exercices = ExerciceSerializer(many=True, read_only=True)
# exercices_id = serializers.PrimaryKeyRelatedField(queryset=Exercice.objects.all(), write_only=True,many=True)
# class Meta:
#     model = Training
#     fields = ['id', 'exercices','exercices_id','sets','duration','repetitions']
# def create(self, validated_data):
#     exercices = validated_data.pop('exercices_id')
#     author = self.context.get('author', None)
#     training = Training.objects.create(author=author, **validated_data)

#     for exercice in exercices:
#         training.exercices.add(exercice)
#     return training
예제 #6
0
class ExerciceSerializer(serializers.ModelSerializer):
    #Declaramos categories como READ ONLY (ya que solo lo gastaremos para mostrar)
    categories = CategorySerializer(many=True, read_only=True)
    #declaramos tambien categories_id para al realizar el insert pongamos solo las ID (write only)
    categories_id = serializers.PrimaryKeyRelatedField(
        queryset=Category.objects.all(), write_only=True, many=True)
    author = ProfileSerializer(read_only=True)
    description = serializers.CharField(required=False)
    verified = serializers.BooleanField(default=False)

    favorited = serializers.SerializerMethodField()
    favoritesCount = serializers.SerializerMethodField(
        method_name='get_favorites_count')

    class Meta:
        model = Exercice
        #añadimos el campo categories y categories_id
        fields = ('id', 'slug', 'name', 'description', 'image', 'favorited',
                  'favoritesCount', 'author', 'verified', 'categories',
                  'categories_id')

    def create(self, validated_data):
        #a categories añadimos las ID insertadas al realizar el POST
        categories = validated_data.pop('categories_id')
        author = self.context.get('author', None)
        exercice = Exercice.objects.create(author=author, **validated_data)

        #hacemos un for por todas las categorias y las añadimos una a una a categories
        for category in categories:
            exercice.categories.add(category)
        return exercice

    def update(self, instance, validated_data):
        print(instance)
        #a categories añadimos las ID insertadas al realizar el POST
        categories = validated_data.pop('categories_id')
        author = self.context.get('author', None)

        for (key, value) in validated_data.items():
            setattr(instance, key, value)
        instance.categories.set(
            [])  #Elimanamos las categorias que tuviera anterioremente
        #hacemos un for por todas las categorias y las añadimos una a una a categories
        for category in categories:
            instance.categories.add(category)
        instance.save()
        return instance

    def get_favorited(self, instance):
        request = self.context.get('request', None)

        if request is None:
            return False

        # if not request.user.is_authenticated():
        if not request.user.is_authenticated:
            return False

        return request.user.profile.has_favorited(instance)

    def get_favorites_count(self, instance):
        return instance.favorited_by.count()
예제 #7
0
class UserSerializer(serializers.ModelSerializer):
    """Handles serialization and deserialization of User objects."""

    # Passwords must be at least 8 characters, but no more than 128
    # characters. These values are the default provided by Django. We could
    # change them, but that would create extra work while introducing no real
    # benefit, so let's just stick with the defaults.
    password = serializers.CharField(max_length=128,
                                     min_length=8,
                                     write_only=True)

    # When a field should be handled as a serializer, we must explicitly say
    # so. Moreover, `UserSerializer` should never expose profile information,
    # so we set `write_only=True`.
    profile = ProfileSerializer(write_only=True)
    # print(profile)

    # We want to get the `bio` and `image` fields from the related Profile
    # model.
    bio = serializers.CharField(source='profile.bio', read_only=True)
    image = serializers.CharField(source='profile.image', read_only=True)

    class Meta:
        model = User
        fields = ('email', 'username', 'password', 'token', 'profile', 'bio',
                  'image')

        # The `read_only_fields` option is an alternative for explicitly
        # specifying the field with `read_only=True` like we did for password
        # above. The reason we want to use `read_only_fields` here is because
        # we don't need to specify anything else about the field. For the
        # password field, we needed to specify the `min_length` and
        # `max_length` properties too, but that isn't the case for the token
        # field.
        read_only_fields = ('token', )

    def update(self, instance, validated_data):
        """Performs an update on a User."""

        # Passwords should not be handled with `setattr`, unlike other fields.
        # This is because Django provides a function that handles hashing and
        # salting passwords, which is important for security. What that means
        # here is that we need to remove the password field from the
        # `validated_data` dictionary before iterating over it.
        password = validated_data.pop('password', None)

        # Like passwords, we have to handle profiles separately. To do that,
        # we remove the profile data from the `validated_data` dictionary.
        profile_data = validated_data.pop('profile', {})
        # print(validated_data.pop('profile', {}))
        # print(profile_data)
        for (key, value) in validated_data.items():
            # For the keys remaining in `validated_data`, we will set them on
            # the current `User` instance one at a time.
            setattr(instance, key, value)

        if password is not None:
            # `.set_password()` is the method mentioned above. It handles all
            # of the security stuff that we shouldn't be concerned with.
            instance.set_password(password)

        # Finally, after everything has been updated, we must explicitly save
        # the model. It's worth pointing out that `.set_password()` does not
        # save the model.
        instance.save()

        for (key, value) in profile_data.items():
            # print(key)
            # print(value)
            # print(profile_data.items())
            # We're doing the same thing as above, but this time we're making
            # changes to the Profile model.
            setattr(instance.profile, key, value)

        # Save the profile just like we saved the user.
        instance.profile.save()

        return instance
예제 #8
0
class ArticleSerializer(serializers.ModelSerializer):
    author = ProfileSerializer(read_only=True)
    description = serializers.CharField(required=False)
    slug = serializers.SlugField(required=False)

    favorited = serializers.SerializerMethodField()
    favoritesCount = serializers.SerializerMethodField(
        method_name='get_favorites_count')

    tagList = TagRelatedField(many=True, required=False, source='tags')

    # Django REST Framework makes it possible to create a read-only field that
    # gets it's value by calling a function. In this case, the client expects
    # `created_at` to be called `createdAt` and `updated_at` to be `updatedAt`.
    # `serializers.SerializerMethodField` is a good way to avoid having the
    # requirements of the client leak into our API.
    createdAt = serializers.SerializerMethodField(method_name='get_created_at')
    updatedAt = serializers.SerializerMethodField(method_name='get_updated_at')

    class Meta:
        model = Article
        fields = (
            'author',
            'body',
            'createdAt',
            'description',
            'favorited',
            'favoritesCount',
            'slug',
            'tagList',
            'title',
            'updatedAt',
        )

    def create(self, validated_data):
        author = self.context.get('author', None)

        tags = validated_data.pop('tags', [])

        article = Article.objects.create(author=author, **validated_data)

        for tag in tags:
            article.tags.add(tag)

        return article

    def get_created_at(self, instance):
        return instance.created_at.isoformat()

    def get_favorited(self, instance):
        request = self.context.get('request', None)

        if request is None:
            return False

        # if not request.user.is_authenticated():
        if not request.user.is_authenticated:
            return False

        return request.user.profile.has_favorited(instance)

    def get_favorites_count(self, instance):
        return instance.favorited_by.count()

    def get_updated_at(self, instance):
        return instance.updated_at.isoformat()