WerkoutAPI/workout/serializers.py

from rest_framework import serializers
from .models import *
from exercise.serializers import ExerciseSerializer
from registered_user.serializers import GetRegisteredUserSerializer
from muscle.models import ExerciseMuscle
from equipment.models import WorkoutEquipment
from video.models import Video
from video.serializers import VideoSerializer
from superset.serializers import SupersetSerializer, SupersetExerciseSerializer
from superset.models import Superset, SupersetExercise

class WorkoutExerciseSerializer(serializers.ModelSerializer):
    exercise = ExerciseSerializer(read_only=True)
    duration_audio = serializers.ReadOnlyField()
    weight_audio = serializers.ReadOnlyField()

    class Meta:
        model = WorkoutExercise
        fields = ('workout', 'exercise','weight','reps','duration','duration_audio','weight_audio', 'created_at',)

class CompleteWorkoutSerializer(serializers.ModelSerializer):
    class Meta:
        model = CompletedWorkout
        exclude = ['registered_user']

    def create(self, validated_data):
        registered_user_id = self.context.get("registered_user")
        registered_user = RegisteredUser.objects.get(id=registered_user_id)
        completed_workout = CompletedWorkout.objects.create(
            registered_user=registered_user,
            workout=validated_data['workout'],
            difficulty=validated_data['difficulty'],
            total_time=validated_data['total_time'],
            workout_start_time=validated_data['workout_start_time'],
            notes=validated_data['notes'],
            total_calories=validated_data['total_calories']
        )
        completed_workout.save()
        return completed_workout

class WorkoutSerializer(serializers.ModelSerializer):
    # exercise = WorkoutExerciseSerializer(source='workout_exercise_workout', many=True)
    registered_user = GetRegisteredUserSerializer(many=False, read_only=True)
    muscles = serializers.SerializerMethodField()
    equipment = serializers.SerializerMethodField()
    exercise_count = serializers.SerializerMethodField()

    class Meta:
        model = Workout
        fields = '__all__'
        # depth = 1
    
    def get_muscles(self, obj): 
        superset_ids = Superset.objects.filter(workout=obj).values_list('id')
        exercise_ids = SupersetExercise.objects.filter(superset__id__in=superset_ids).values_list('exercise__id')
        muscles_names = ExerciseMuscle.objects.filter(exercise__id__in=exercise_ids).values_list('muscle__name', flat=True)
        return list(set(muscles_names))
    
        # muscles_names = ExerciseMuscle.objects.filter(exercise__id__in=exercises).values_list('muscle__name', flat=True)
        # return list(set(muscles_names))
    
    def get_equipment(self, obj): 
        superset_ids = Superset.objects.filter(workout=obj).values_list('id')
        exercise_ids = SupersetExercise.objects.filter(superset__id__in=superset_ids).values_list('exercise__id')        
        equipment_names = WorkoutEquipment.objects.filter(exercise__id__in=exercise_ids).values_list('equipment__name', flat=True)
        return list(set(equipment_names))
    
    def get_exercise_count(self, obj): 
        returnValue = 0
        supersets = Superset.objects.filter(workout=obj)
        for superset in supersets: 
            exercise_count = SupersetExercise.objects.filter(superset=superset).count()
            returnValue += (superset.rounds * exercise_count)
        return returnValue

class WorkoutDetailSerializer(serializers.ModelSerializer):
    supersets = serializers.SerializerMethodField()
    registered_user = serializers.SerializerMethodField()
    male_videos = serializers.SerializerMethodField()
    female_videos = serializers.SerializerMethodField()
    both_videos = serializers.SerializerMethodField()
    all_superset_exercise = serializers.SerializerMethodField()

    class Meta:
        model = Workout
        fields = ('id', 'name', 'description', 'supersets', 'registered_user', 'male_videos', 'female_videos', 'both_videos', 'estimated_time', 'all_superset_exercise', )
        depth = 1
   
    def get_all_superset_exercise(self, obj): 
        all_superset_exercise = []
        supersets = Superset.objects.filter(workout=obj).order_by('order')
        for superset in supersets:
            supersetExercises = SupersetExercise.objects.filter(superset=superset).order_by('order')
            for x in range(0, superset.rounds):
                all_superset_exercise += supersetExercises
        data = SupersetExerciseSerializer(all_superset_exercise, many=True).data
        return data
    
    def get_supersets(self, obj): 
        objs = Superset.objects.filter(workout=obj).order_by('order')
        data = SupersetSerializer(objs, many=True).data
        return data
    
    def get_registered_user(self, obj):
        objs = RegisteredUser.objects.get(pk=obj.registered_user.pk)
        data = GetRegisteredUserSerializer(objs, many=False).data
        return data
    
    def get_male_videos(self, obj):
        data = Video.objects.filter(gender=1).values_list('video_file', flat=True)
        return data
    
    def get_female_videos(self, obj):
        data = Video.objects.filter(gender=2).values_list('video_file', flat=True)
        return data
    
    def get_both_videos(self, obj):
        data = Video.objects.filter(gender=3).values_list('video_file', flat=True)
        return data

class GetCompleteWorkoutSerializer(serializers.ModelSerializer):
    workout = WorkoutSerializer(many=False, read_only=True)

    class Meta:
        model = CompletedWorkout
        exclude = ['registered_user']

class POSTCompleteWorkoutSerializer(serializers.ModelSerializer):
    class Meta:
        model = Workout
        exclude = ['registered_user']

class PlannedWorkoutSerializer(serializers.ModelSerializer):
    workout = POSTCompleteWorkoutSerializer(many=False, read_only=True)
    class Meta:
        model = PlannedWorkout
        exclude = ['registered_user']
        depth = 1

class POSTPlannedWorkoutSerializer(serializers.ModelSerializer):
    class Meta:
        model = PlannedWorkout
        exclude = ['registered_user']
        
    def create(self, validated_data):
            print(validated_data)
            registered_user_id = self.context.get("registered_user")
            registered_user = RegisteredUser.objects.get(id=registered_user_id)
            planned_workout = PlannedWorkout.objects.create(
                registered_user=registered_user,
                workout=validated_data['workout'],
                on_date=validated_data['on_date']
            )
            planned_workout.save()
            return planned_workout