WerkoutAPI/workout/views.py

from .models import *
from .serializers import *

from django.shortcuts import render
from rest_framework.decorators import api_view
from rest_framework.decorators import api_view
from rest_framework.response import Response
from rest_framework import status
from django.contrib.auth.models import User
from django.contrib.auth import authenticate
from rest_framework.authentication import TokenAuthentication
from rest_framework.permissions import IsAuthenticated
from rest_framework.decorators import authentication_classes
from rest_framework.decorators import permission_classes
from django.shortcuts import get_object_or_404
from datetime import datetime, timedelta

from django.core.cache import cache
from .tasks import add_from_files_tasks

@api_view(['GET'])
@authentication_classes([TokenAuthentication])
@permission_classes([IsAuthenticated])
def all_workouts(request):
    if 'all_workouts' in cache:
        data = cache.get('all_workouts')
        return Response(data=data, status=status.HTTP_200_OK)
    
    users = Workout.objects.all()
    serializer = WorkoutSerializer(users, many=True)
    data = serializer.data
    cache.set('all_workouts', data, timeout=None)
    return Response(data=data, status=status.HTTP_200_OK)


@api_view(['GET'])
@authentication_classes([TokenAuthentication])
@permission_classes([IsAuthenticated])
def workout_details(request, workout_id):
    cache_name = "wk"+str(workout_id)
    if cache_name in cache:
        data = cache.get(cache_name)
        return Response(data=data, status=status.HTTP_200_OK)
    
    workout = Workout.objects.get(pk=workout_id)
    serializer = WorkoutDetailSerializer(workout, many=False)
    data = serializer.data
    cache.set(cache_name, data, timeout=300)
    return Response(data = data, status=status.HTTP_200_OK)

@api_view(['POST'])
@authentication_classes([TokenAuthentication])
@permission_classes([IsAuthenticated])
def complete_workout(request):
    registered_user = RegisteredUser.objects.get(user=request.user)    
    serializer = CompleteWorkoutSerializer(data=request.data, context = {"registered_user":registered_user.pk})
    if serializer.is_valid():
        serializer.save()
        return Response(serializer.data, status=status.HTTP_201_CREATED)
    return Response(serializer.errors, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

@api_view(['GET'])
@authentication_classes([TokenAuthentication])
@permission_classes([IsAuthenticated])
def workouts_completed_by_logged_in_user(request):
    registered_user = RegisteredUser.objects.get(user=request.user)    
    workouts = CompletedWorkout.objects.filter(registered_user=registered_user)
    serializer = GetCompleteWorkoutSerializer(workouts, many=True)
    return Response(serializer.data, status=status.HTTP_201_CREATED)

@api_view(['POST'])
@authentication_classes([TokenAuthentication])
@permission_classes([IsAuthenticated])
def add_workout(request):
    registered_user = RegisteredUser.objects.get(user=request.user)   
    if registered_user is None:
        return Response(status=status.HTTP_400_BAD_REQUEST)

    # exercise_data = dict(request.POST)["exercise_data"]
    exercise_data = request.data["supersets"]

    if exercise_data is None:
        return Response({"supersets": [ "missing" ] }, status=status.HTTP_400_BAD_REQUEST)
    if len(exercise_data) < 1:
        return Response({"supersets": [ "empty" ] }, status=status.HTTP_400_BAD_REQUEST)

    serializer = POSTCompleteWorkoutSerializer(data=request.data)

    if serializer.is_valid():
        workout = serializer.save(registered_user=registered_user)
        workout.save()

        workout_total_time = 0
        for superset in exercise_data:
            name = superset["name"]
            rounds = superset["rounds"]
            exercises = superset["exercises"]
            superset_order = superset["order"]
            
            superset = Superset.objects.create(
                workout=workout, 
                name=name,
                rounds=rounds,
                order=superset_order
            )
            superset.save()
      
            superset_total_time = 0
            for exercise in exercises:
                exercise_id = exercise["id"]
                exercise_obj = Exercise.objects.get(pk=exercise_id)
                order = exercise["order"]

                supersetExercise = SupersetExercise.objects.create(
                    superset=superset, 
                    exercise=exercise_obj,
                    order=order
                )
                
                if "weight" in exercise:
                    supersetExercise.weight = exercise["weight"]
                if "reps" in exercise:
                    supersetExercise.reps = exercise["reps"]
                    superset_total_time += exercise["reps"] * exercise_obj.estimated_rep_duration
                if "duration" in exercise:
                    supersetExercise.duration = exercise["duration"]
                    superset_total_time += exercise["duration"]

                supersetExercise.save()

            superset.estimated_time = superset_total_time
            superset.save()

            workout_total_time += (superset_total_time * rounds)

            superset_order += 1
        workout.estimated_time = workout_total_time
        workout.save()
        
        cache.delete('all_workouts')

        return Response(serializer.data, status=status.HTTP_201_CREATED)
    return Response(serializer.errors, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

@api_view(['GET'])
@authentication_classes([TokenAuthentication])
@permission_classes([IsAuthenticated])
def workouts_planned_by_logged_in_user(request):
    registered_user = RegisteredUser.objects.get(user=request.user)    
    workouts = PlannedWorkout.objects.filter(registered_user=registered_user, on_date__gte=datetime.now()- timedelta(days=1))
    serializer = PlannedWorkoutSerializer(workouts, many=True)
    return Response(serializer.data, status=status.HTTP_200_OK)

@api_view(['POST'])
@authentication_classes([TokenAuthentication])
@permission_classes([IsAuthenticated])
def plan_workout(request):
    registered_user = RegisteredUser.objects.get(user=request.user)    
    serializer = POSTPlannedWorkoutSerializer(data=request.data, 
                                              context = {"registered_user":registered_user.pk})
    
    if serializer.is_valid():
        serializer.save()
        return Response(serializer.data, status=status.HTTP_201_CREATED)
    return Response(serializer.errors, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

@api_view(['GET'])
@authentication_classes([TokenAuthentication])
@permission_classes([IsAuthenticated])
def add_from_files(request):
    add_from_files_tasks.delay()
    cache.delete('all_workouts')
    return Response(status=status.HTTP_200_OK)