358 lines
9.9 KiB
Python
358 lines
9.9 KiB
Python
|
|
# Serializers. Defines which fields from an object get to the JSON object
|
|
# Also optionally define POST, PATCH methods (create, update)
|
|
|
|
from rest_framework import serializers
|
|
from rowers.models import (
|
|
Workout, Rower, FavoriteChart, VirtualRaceResult,
|
|
VirtualRace, GeoCourse, StandardCollection, CourseStandard,
|
|
GeoCourse, GeoPolygon, GeoPoint, PlannedSession,
|
|
)
|
|
|
|
from django.core.exceptions import PermissionDenied
|
|
|
|
import datetime
|
|
|
|
# Serializers define the API representation.
|
|
|
|
|
|
class RowerSerializer(serializers.HyperlinkedModelSerializer):
|
|
class Meta:
|
|
model = Rower
|
|
fields = (
|
|
'id',
|
|
'weightcategory',
|
|
'max',
|
|
'rest',
|
|
'ut2',
|
|
'ut1',
|
|
'at',
|
|
'tr',
|
|
'an',
|
|
'hrzones',
|
|
'powerzones',
|
|
'pw_ut2', 'pw_ut1', 'pw_at', 'pw_tr', 'pw_an',
|
|
'ftp',
|
|
'hrftp',
|
|
'sex',
|
|
'defaulttimezone',
|
|
'getimportantemails',
|
|
'adaptiveclass',
|
|
)
|
|
|
|
|
|
class FavoriteChartSerializer(serializers.ModelSerializer):
|
|
class Meta:
|
|
model = FavoriteChart
|
|
fields = (
|
|
'id',
|
|
'xparam',
|
|
'yparam1',
|
|
'yparam2',
|
|
'plottype',
|
|
'workouttype',
|
|
'reststrokes',
|
|
'user'
|
|
)
|
|
|
|
|
|
class CourseStandardSerializer(serializers.ModelSerializer):
|
|
|
|
class Meta:
|
|
model = CourseStandard
|
|
fields = (
|
|
'id',
|
|
'name',
|
|
'coursedistance',
|
|
'coursetime',
|
|
'agemin',
|
|
'agemax',
|
|
'boatclass',
|
|
'boattype',
|
|
'sex',
|
|
'weightclass',
|
|
'adaptiveclass',
|
|
'skillclass',
|
|
'standardcollection',
|
|
)
|
|
|
|
|
|
class StandardCollectionSerializer(serializers.ModelSerializer):
|
|
standards = CourseStandardSerializer(many=True, read_only=True)
|
|
|
|
class Meta:
|
|
model = StandardCollection
|
|
fields = (
|
|
'id',
|
|
'name',
|
|
'notes',
|
|
'active',
|
|
'standards'
|
|
)
|
|
|
|
|
|
class ShortEntrySerializer(serializers.ModelSerializer):
|
|
entrycategory = CourseStandardSerializer(read_only=True)
|
|
|
|
class Meta:
|
|
model = VirtualRaceResult
|
|
fields = (
|
|
'id',
|
|
'username',
|
|
'teamname',
|
|
'boattype',
|
|
'sex',
|
|
'age',
|
|
'adaptiveclass',
|
|
'skillclass',
|
|
'coursecompleted',
|
|
'distance',
|
|
'duration',
|
|
'points',
|
|
'entrycategory',
|
|
)
|
|
|
|
|
|
class VirtualRaceSerializer(serializers.ModelSerializer):
|
|
coursestandards = StandardCollectionSerializer(read_only=True)
|
|
entries = ShortEntrySerializer(many=True, read_only=True)
|
|
|
|
class Meta:
|
|
model = VirtualRace
|
|
fields = (
|
|
'id',
|
|
'name',
|
|
'course',
|
|
'registration_closure',
|
|
'evaluation_closure',
|
|
'start_time',
|
|
'end_time',
|
|
'country',
|
|
'timezone',
|
|
'contact_phone',
|
|
'contact_email',
|
|
'entries',
|
|
'coursestandards',
|
|
)
|
|
|
|
|
|
class PlannedSessionSerializer(serializers.ModelSerializer):
|
|
class Meta:
|
|
model = VirtualRace
|
|
fields = (
|
|
'id',
|
|
'name',
|
|
'comment',
|
|
'startdate',
|
|
'enddate',
|
|
'preferreddate',
|
|
'sessiontype',
|
|
'sessionvalue',
|
|
'sessionunit',
|
|
'sessionmode',
|
|
'course',
|
|
'approximate_distance',
|
|
'approximate_duration',
|
|
# 'steps',
|
|
'fitfile'
|
|
)
|
|
|
|
def create(self, validated_data): # pragma: no cover
|
|
if self.context['request'].user.is_authenticated:
|
|
r = Rower.objects.get(user=self.context['request'].user)
|
|
else:
|
|
raise PermissionDenied("Not allowed")
|
|
|
|
ps = PlannedSession.objects.create(manager=r.user, **validated_data)
|
|
ps.rower.add(r)
|
|
ps.save()
|
|
return ps
|
|
|
|
|
|
class EntrySerializer(serializers.ModelSerializer):
|
|
entrycategory = CourseStandardSerializer(read_only=True)
|
|
race = VirtualRaceSerializer(read_only=True)
|
|
|
|
class Meta:
|
|
model = VirtualRaceResult
|
|
fields = (
|
|
'id',
|
|
'teamname',
|
|
'adaptiveclass',
|
|
'skillclass',
|
|
'race',
|
|
'distance',
|
|
'duration',
|
|
'points',
|
|
'boattype',
|
|
'sex',
|
|
'age',
|
|
'entrycategory',
|
|
)
|
|
|
|
|
|
class WorkoutSerializer(serializers.ModelSerializer):
|
|
class Meta:
|
|
model = Workout
|
|
fields = (
|
|
'id',
|
|
'name',
|
|
'date',
|
|
'workouttype',
|
|
'starttime',
|
|
'startdatetime',
|
|
'distance',
|
|
'duration',
|
|
'averagehr',
|
|
'maxhr',
|
|
'notes',
|
|
'summary',
|
|
'boattype',
|
|
'timezone',
|
|
'forceunit',
|
|
'inboard',
|
|
'oarlength',
|
|
'privacy',
|
|
'rankingpiece',
|
|
'trimp',
|
|
'rscore',
|
|
'normp',
|
|
'duplicate',
|
|
)
|
|
|
|
def create(self, validated_data): # pragma: no cover
|
|
if self.context['request'].user.is_authenticated:
|
|
r = Rower.objects.get(user=self.context['request'].user)
|
|
else:
|
|
raise PermissionDenied("Not allowed")
|
|
d = validated_data['date']
|
|
t = validated_data['starttime']
|
|
rowdatetime = datetime.datetime(d.year,
|
|
d.month,
|
|
d.day,
|
|
t.hour,
|
|
t.minute,
|
|
t.second)
|
|
|
|
validated_data['startdatetime'] = rowdatetime
|
|
validated_data['user'] = r
|
|
|
|
return Workout.objects.create(**validated_data)
|
|
|
|
def update(self, instance, validated_data): # pragma: no cover
|
|
d = validated_data['date']
|
|
t = validated_data['starttime']
|
|
rowdatetime = datetime.datetime(d.year,
|
|
d.month,
|
|
d.day,
|
|
t.hour,
|
|
t.minute,
|
|
t.second)
|
|
|
|
instance.name = validated_data['name']
|
|
instance.date = validated_data['date']
|
|
instance.workouttype = validated_data['workouttype']
|
|
instance.duration = validated_data['duration']
|
|
instance.distance = validated_data['distance']
|
|
instance.starttime = validated_data['starttime']
|
|
instance.notes = validated_data['notes']
|
|
instance.summary = validated_data['summary']
|
|
instance.averagehr = validated_data['averagehr']
|
|
instance.maxhr = validated_data['maxhr']
|
|
instance.startdatetime = rowdatetime
|
|
instance.timezone = validated_data['timezone']
|
|
instance.forceunit = validated_data['forceunit']
|
|
instance.inboard = validated_data['inboard']
|
|
instance.oarlength = validated_data['oarlength']
|
|
instance.privacy = validated_data['privacy']
|
|
instance.rankingpiece = validated_data['rankingpiece']
|
|
|
|
instance.save()
|
|
return instance
|
|
|
|
# This is just a fake one for URL registration purposes
|
|
|
|
|
|
class StrokeDataSerializer(serializers.Serializer):
|
|
workoutid = serializers.IntegerField
|
|
strokedata = serializers.JSONField
|
|
|
|
def create(self, workoutid, strokedata): # pragma: no cover
|
|
"""
|
|
Create and enter a new set of stroke data into the DB
|
|
"""
|
|
|
|
# do something
|
|
return 1
|
|
|
|
|
|
class GeoPointSerializer(serializers.ModelSerializer):
|
|
class Meta:
|
|
model = GeoPoint
|
|
fields = (
|
|
'id',
|
|
'latitude',
|
|
'longitude',
|
|
'order_in_poly',
|
|
)
|
|
extra_kwargs = {'id': {'read_only': False, 'required': True}}
|
|
|
|
|
|
class GeoPolygonSerializer(serializers.ModelSerializer):
|
|
points = GeoPointSerializer(many=True)
|
|
|
|
class Meta:
|
|
model = GeoPolygon
|
|
fields = (
|
|
'id',
|
|
'name',
|
|
'order_in_course',
|
|
'points',
|
|
)
|
|
extra_kwargs = {'id': {'read_only': False, 'required': True}}
|
|
|
|
|
|
class GeoCourseSerializer(serializers.ModelSerializer):
|
|
polygons = GeoPolygonSerializer(many=True)
|
|
|
|
class Meta:
|
|
model = GeoCourse
|
|
fields = (
|
|
'id',
|
|
'name',
|
|
'distance',
|
|
'country',
|
|
'notes',
|
|
'polygons',
|
|
)
|
|
|
|
def update(self, instance, validated_data): # pragma: no cover
|
|
instance.name = validated_data.get('name', instance.name)
|
|
instance.country = validated_data.get('country', instance.country)
|
|
instance.notes = validated_data.get('notes', instance.notes)
|
|
instance.save()
|
|
|
|
polygons = validated_data.get('polygons')
|
|
for polygon in polygons:
|
|
polygon_id = polygon.get('id', None)
|
|
if polygon_id:
|
|
p = GeoPolygon.objects.get(id=polygon_id)
|
|
p.name = polygon.get('name', p.name)
|
|
p.order_in_course = polygon.get(
|
|
'order_in_course', p.order_in_course)
|
|
p.save()
|
|
|
|
points = polygon.get('points')
|
|
|
|
for point in points:
|
|
point_id = point.get('id', None)
|
|
if point_id:
|
|
pt = GeoPoint.objects.get(id=point_id)
|
|
pt.latitude = point.get('latitude', pt.latitude)
|
|
pt.longitude = point.get('longitude', pt.longitude)
|
|
pt.order_in_poly = point.get(
|
|
'order_in_poly', pt.order_in_poly)
|
|
pt.save()
|
|
|
|
return instance
|