244 lines
9.2 KiB
Python
244 lines
9.2 KiB
Python
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
|
|
import json
|
|
import os
|
|
from django.core.cache import cache
|
|
|
|
|
|
@api_view(['GET'])
|
|
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)
|
|
return Response(data=data, status=status.HTTP_200_OK)
|
|
|
|
|
|
@api_view(['GET'])
|
|
def workout_details(request, workout_id):
|
|
workout = Workout.objects.get(pk=workout_id)
|
|
serializer = WorkoutDetailSerializer(workout, many=False)
|
|
return Response(data=serializer.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())
|
|
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'])
|
|
def add_from_files(request):
|
|
sample_url = os.getcwd() + "/workout/sample_workout.json"
|
|
print(sample_url)
|
|
with open(sample_url) as user_file:
|
|
file_contents = user_file.read()
|
|
parsed_json = json.loads(file_contents)
|
|
|
|
for item in parsed_json:
|
|
workout_name = item["name"]
|
|
workout_description = item["description"]
|
|
workout_created = item["created"]
|
|
|
|
workout_obj = Workout.objects.create(
|
|
registered_user = RegisteredUser.objects.get(pk=2),
|
|
description = workout_description,
|
|
name = workout_name,
|
|
created_at = workout_created
|
|
)
|
|
|
|
workout_obj.save()
|
|
workout_obj.created_at = workout_created
|
|
workout_obj.save(update_fields=['created_at'])
|
|
workout_total_time = 0
|
|
|
|
supersets = item["supersets"]
|
|
superset_order = 1
|
|
for superset in supersets:
|
|
superset_name = superset["name"]
|
|
superset_rounds = superset["rounds"]
|
|
|
|
superset_obj = Superset.objects.create(
|
|
workout=workout_obj,
|
|
name=superset_name,
|
|
rounds=superset_rounds,
|
|
order=superset_order
|
|
)
|
|
|
|
superset_obj.save()
|
|
|
|
superset_order += 1
|
|
|
|
exercises = superset["exercises"]
|
|
exercise_order = 1
|
|
|
|
superset_total_time = 0
|
|
for exercise in exercises:
|
|
side = exercise["side"]
|
|
name = exercise["name"]
|
|
|
|
duration = exercise["duration"]
|
|
reps = exercise["reps"]
|
|
side = exercise["side"]
|
|
|
|
exercise_obj = None
|
|
if len(side) > 0:
|
|
exercise_obj = Exercise.objects.get(name=name, side=side)
|
|
else:
|
|
exercise_obj = Exercise.objects.get(name=name, side="")
|
|
|
|
supersetExercise = SupersetExercise.objects.create(
|
|
superset=superset_obj,
|
|
exercise=exercise_obj,
|
|
order=exercise_order
|
|
)
|
|
|
|
if reps != 0:
|
|
supersetExercise.reps = reps
|
|
superset_total_time += reps * exercise_obj.estimated_rep_duration
|
|
if reps == 0 and duration != 0:
|
|
supersetExercise.duration = duration
|
|
superset_total_time += exercise["duration"]
|
|
supersetExercise.save()
|
|
|
|
exercise_order += 1
|
|
|
|
superset_obj.estimated_time = superset_total_time
|
|
superset_obj.save()
|
|
|
|
workout_total_time += (superset_total_time * superset_rounds)
|
|
|
|
workout_obj.estimated_time = workout_total_time
|
|
workout_obj.save()
|
|
|
|
cache.delete('all_workouts')
|
|
|
|
return Response(status=status.HTTP_200_OK) |