class VideoSerializer(serializers.HyperlinkedModelSerializer):
"""VideoSerializer."""
asset = resource_related_field(
Asset,
'video',
'asset',
many=False,
)
session = resource_related_field(
Session,
'video',
'session',
many=False,
)
included_serializers = {
'asset': 'assets.serializers.AssetSerializer',
'session': SessionSerializer,
}
class Meta(object):
"""VideoSerializer Meta class."""
model = Video
fields = ('asset', 'session')
class SessionSerializer(serializers.HyperlinkedModelSerializer):
"""SessionSerializer."""
videos = resource_related_field(
Video,
'session',
'videos',
)
current_stats = resource_related_field(
Stats,
'session',
'current_stats',
many=False,
)
included_serializers = {
'current_stats': StatsSerializer,
'videos': 'sports.serializers.VideoSerializer',
}
class Meta(object):
"""SessionSerializer Meta class."""
model = Session
fields = (
'current_stats',
'data',
'videos',
)
class ExchangeSerializer(serializers.HyperlinkedModelSerializer):
"""ExchangeSerializer."""
start_at = resource_related_field(
VideoPoint,
'exchange',
'start_at',
many=False,
read_only=True,
namespace='tennis',
)
hits = resource_related_field(
Hit,
'exchange',
'hits',
namespace='tennis',
)
included_serializers = {
'start_at': VideoPointSerializer,
'hits': 'tennis.serializers.HitSerializer',
}
class Meta(object):
"""ExchangeSerializer Meta class."""
model = Exchange
fields = ('start_at', 'hits')
class SessionSerializer(BaseSessionSerializer):
"""Tennis session serializer."""
trainings = resource_related_field(
Training,
'session',
'trainings',
namespace='tennis',
)
players = resource_related_field(
Player,
'session',
'players',
namespace='tennis',
)
matches = resource_related_field(
Match,
'session',
'matches',
namespace='tennis',
)
exchanges = resource_related_field(
Exchange,
'session',
'exchanges',
namespace='tennis',
)
included_serializers = {
**BaseSessionSerializer.included_serializers,
'trainings': 'tennis.serializers.TrainingSerializer',
'players': 'tennis.serializers.PlayerSerializer',
'matches': 'tennis.serializers.MatchSerializer',
'exchanges': 'tennis.serializers.ExchangeSerializer',
'videos': 'tennis.serializers.VideoSerializer',
}
label = serializers.SerializerMethodField()
def get_label(self, obj):
"""Serialize session label."""
return 'Session'
class Meta(BaseSessionSerializer.Meta):
"""SessionSerializer Meta class."""
fields = BaseSessionSerializer.Meta.fields + (
'id',
'date',
'place',
'duration',
'trainings',
'matches',
'players',
'label',
'exchanges',
)
class UserSerializer(JPIUserSerializer):
"""User serializer."""
sessions = resource_related_field(
Session,
'user',
'sessions',
)
current_stats = resource_related_field(
Stats,
'user',
'current_stats',
many=False,
)
included_serializers = {
'sessions': SessionSerializer,
'current_stats': StatsSerializer,
'picture': AssetSerializer,
}
picture = resource_related_field(
Asset,
'user',
'picture',
many=False,
)
class Meta(object):
"""UserSerializer Meta class."""
model = User
fields = JPIUserSerializer.Meta.fields + (
'first_name',
'last_name',
'birthday',
'current_stats',
'gender',
'picture',
'dominant_hand',
'sessions',
'club',
'ranking',
)
class JSONAPIMeta(object):
"""UserSerializer JSONAPIMeta class."""
included_resources = ('picture', )
class UserSerializer(serializers.HyperlinkedModelSerializer):
groups = resource_related_field(
Group,
'user',
'groups',
)
providers = resource_related_field(
Provider,
'user',
'providers',
)
included_serializers = {
'groups': GroupSerializer,
'providers': ProviderSerializer,
}
password = serializers.CharField(write_only=True)
old_password = serializers.CharField(write_only=True, required=False)
def validate(self, data):
if self.instance:
user = self.instance
else:
user = User(**data)
password = data.get('password')
if password is None:
# if password is None it means it is not required
# e.g. PATCH request
return super(UserSerializer, self).validate(data)
errors = dict()
try:
validators.validate_password(password=password, user=user)
except core_exceptions.ValidationError as e:
errors['password'] = list(e.messages)
except Exception as e:
raise e
if self.instance and \
not self.instance.check_password(data.get('old_password')):
errors['old_password'] = _('Old password isn\'t valid.')
if errors:
raise serializers.ValidationError(errors)
return super(UserSerializer, self).validate(data)
def create(self, validated_data):
user = User(**validated_data)
user.last_login = datetime.now(timezone.utc)
user.set_password(validated_data['password'])
user.save()
return user
def update(self, instance, validated_data):
instance = super(UserSerializer, self).update(instance, validated_data)
password = validated_data.get('password')
if password is not None:
instance.set_password(password)
instance.save()
return instance
def get_root_meta(self, resource, many):
if hasattr(self, 'token'):
return {'access_token': self.token}
elif many:
return {'size': len(resource)}
return {}
def get_fields(self):
fields = super(UserSerializer, self).get_fields()
limited_fields = getattr(self.Meta, 'limited_fields', fields)
request = self.context.get('request', None)
instance = self.instance
if (instance and request is not None and hasattr(request, 'user')
and request.user != instance) or type(instance) == list:
result = fields.copy()
for field in fields:
if field not in limited_fields:
result.pop(field)
return result
return fields
class Meta:
model = User
fields = ('url', 'email', 'password', 'old_password', 'providers')