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')