class InternRoleFullSerializer(InternRoleSerializer): role = RoleSerializer(read_only=True) intern = SimpleInternSerializer(read_only=True) semesters = SemesterSerializer(many=True) created_by = UserSerializer(read_only=True) last_editor = UserSerializer(read_only=True) removed_by = UserSerializer(read_only=True) date_added = serializers.DateField(read_only=True) date_edited = serializers.DateField(read_only=True) date_removed = serializers.DateField(read_only=True) access_given = serializers.BooleanField() date_access_given = serializers.DateTimeField(read_only=True) date_access_revoked = serializers.DateTimeField(read_only=True) class Meta: model = InternRole fields = ( "id", "intern", "role", "semesters", "access_given", "date_access_given", "date_access_revoked", "date_added", "date_removed", "date_edited", "comments", "created_by", "last_editor", "removed_by", "recieved_interncard", )
class InternRoleFullSerializer(InternRoleSerializer): role = RoleSerializer(read_only=True) intern = SimpleInternSerializer(read_only=True) semesters = SemesterSerializer(many=True) created_by = UserSerializer(read_only=True) last_editor = UserSerializer(read_only=True) removed_by = UserSerializer(read_only=True) date_added = serializers.DateField(read_only=True) date_edited = serializers.DateField(read_only=True) date_removed = serializers.DateField(read_only=True) access_given = serializers.BooleanField() date_access_given = serializers.DateTimeField(read_only=True) date_access_revoked = serializers.DateTimeField(read_only=True) class Meta: model = InternRole fields = ( 'id', 'intern', 'role', 'semesters', 'access_given', 'date_access_given', 'date_access_revoked', 'date_added', 'date_removed', 'date_edited', 'comments', 'created_by', 'last_editor', 'removed_by', 'recieved_interncard', )
class TaskSerializer(serializers.ModelSerializer): access_list = UserSerializer(read_only=True, many=True) owner = UserSerializer(read_only=True) class Meta: model = Task fields = ('id', 'name', 'description', 'end_time', 'owner', 'access_list')
class RequestListSerializer(RequestSerializer): request_by = UserSerializer() processed_by = UserSerializer() class Meta: model = EmployeeRequest fields = RequestSerializer.Meta.fields + ( 'request_by', 'processed_by', 'created_at', )
class CardSerializer(serializers.ModelSerializer): """ General purpose Card serializer """ dueño = UserSerializer(read_only=True) miembros = UserSerializer(many=True, read_only=True) class Meta: model = Tarjeta fields = ('nombre', 'miembros', 'lista', 'descripcion', 'dueño')
def test_password_validation(self): """test for password validation""" # true serializer = UserSerializer( data={ 'username': '******', 'first_name': 'first', 'last_name': 'last', 'password': '******' }) self.assertTrue(serializer.is_valid()) # less than 8 chars serializer = UserSerializer( data={ 'username': '******', 'first_name': 'first', 'last_name': 'last', 'password': '******' }) self.assertFalse(serializer.is_valid()) # user attr similar serializer = UserSerializer( data={ 'username': '******', 'first_name': 'first', 'last_name': 'last', 'password': '******' }) self.assertFalse(serializer.is_valid()) # common password serializer = UserSerializer( data={ 'username': '******', 'first_name': 'first', 'last_name': 'last', 'password': '******' }) self.assertFalse(serializer.is_valid()) # numbers only serializer = UserSerializer( data={ 'username': '******', 'first_name': 'first', 'last_name': 'last', 'password': '******' }) self.assertFalse(serializer.is_valid())
class ProfileSerializer(serializers.ModelSerializer): user = UserSerializer() phones = PhoneSerializer(many=True) guardians = UserSerializer(many=True, required=False) class Meta: model = Profile fields = ('id', 'user', 'phones', 'guardians', 'active', 'cpf', 'rg', 'birth_date', 'genre', 'cep', 'logradouro', 'complemento', 'bairro', 'localidade', 'uf') def create(self, validated_data): user_data = validated_data.pop('user') phones_data = validated_data.pop('phones') guardians_data = validated_data.pop( 'guardians') if 'guardians' in validated_data else [] user = User.objects.create(**user_data) profile = Profile.objects.create(user=user, **validated_data) for guardian_data in guardians_data: guardian = User.objects.get_or_create(**guardian_data)[0] guardian.save() profile.guardians.add(guardian) for phone_data in phones_data: phone = Phone.objects.create(**phone_data) profile.phones.add(phone) return profile def update(self, instance, validated_data): user_data = validated_data.pop('user') phones_data = validated_data.pop('phones') guardians_data = validated_data.pop( 'guardians') if 'guardians' in validated_data else [] for field, value in user_data.items(): setattr(instance.user, field, value) for field, value in validated_data.items(): setattr(instance, field, value) for guardian_data in guardians_data: guardian = User.objects.get_or_create(**guardian_data)[0] guardian.save() instance.guardians.add(guardian) # for phone_data in phones_data: # phone = Phone.objects.get_or_create(**phone_data)[0] # phone.save() # instance.phones.add(phone) instance.user.save() instance.save() return instance
class ClassSerializer(serializers.ModelSerializer): user = UserSerializer(many=False, read_only=True) user_id = serializers.IntegerField(write_only=True) class Meta: model = Class fields = '__all__'
class InfoSerializer(serializers.ModelSerializer): user = UserSerializer(read_only=True) class Meta: model = Info fields = '__all__' read_only_fields = ('user', )
def social_login(request): json_body = json.loads(request.body) try: auth_token = json_body["token"] provider = json_body["provider"] except KeyError: return HttpResponseBadRequest("Missing args") try: email = verify_user(auth_token=auth_token, provider=provider) except SocialAuthInvalidTokenException as e: logger.warning("Invalid social auth token provided", exc_info=e) return HttpResponseForbidden() try: user = User.objects.get(email=email) created = False except User.DoesNotExist: user = User.objects.create_user(email) created = True # If there is already a player in the session, set it on the user do_user_player_coherence(request, user) login(request, user) resp = UserSerializer(user).data resp["_created"] = created return JsonResponse(resp)
def put(self, request, pk): user = self.get_object(pk) serializer = UserSerializer(user, data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class UserTeamSerializer(serializers.ModelSerializer): user = UserSerializer(read_only=True) class Meta: model = UserTeam fields = ('id', 'user', 'team')
class ArquivoSerializer(serializers.ModelSerializer): #leituras = LeituraSimplificadoSerializer(source='arquivo', many=True) acelerometro = AcelerometroSimplificadoSerializer() usuario = UserSerializer() class Meta: model = Arquivo fields = ('__all__')
class LoanSerializer(serializers.ModelSerializer): created = serializers.DateTimeField(format=DATETIME_FORMAT, read_only=True) modified = serializers.DateTimeField(format=DATETIME_FORMAT, read_only=True) client = UserSerializer() value = serializers.SerializerMethodField() amount_due = serializers.SerializerMethodField() interest_rate = serializers.SerializerMethodField() balance_due = serializers.SerializerMethodField() class Meta: model = Loan fields = '__all__' def get_value(self, obj): return f'R$ {obj.value:.2f}' def get_amount_due(self, obj): return f'R$ {obj.amount_due:.2f}' def get_interest_rate(self, obj): return f'{100.0 * float(obj.interest_rate):.2f}%' def get_balance_due(self, obj): return f'R$ {obj.make_balance_due():.2f}'
def login_user(request): try: data = json.loads(request.body) except json.JSONDecodeError: return HttpResponseBadRequest() if 'username' not in data: return HttpResponseBadRequest( json.dumps({"username": "******"})) if 'password' not in data: return HttpResponseBadRequest( json.dumps({"password": "******"})) user = authenticate(request, username=data['username'], password=data['password']) if not user: return HttpResponseBadRequest( json.dumps({"password": "******"})) login(request, user) data = UserSerializer( user, context={ 'request': request }, ).data return HttpResponse(JSONRenderer().render(data), content_type="application/json")
def post(self, request): serialized = UserSerializer(data=request.data) if serialized.is_valid(): serialized.save() return Response(serialized.data) else: return Response(serialized._errors, status=400)
def to_representation(self, value): if isinstance(value, User): return UserSerializer(value).data elif isinstance(value, Post): return PostSerializer(value, context={'request': None}).data else: return 'unknown'
class EventSerializer(serializers.HyperlinkedModelSerializer): cause = EventRelatedField(read_only=True) author = UserSerializer() class Meta: model = Event fields = ('object_id', 'cause', 'author', 'created_at', 'causeType', 'id')
def current_user(request): """ Determine the current user by their token, and return their data """ serializer = UserSerializer(request.user) return Response(serializer.data)
def my_jwt_response_handler(token, user=None, request=None): return { "token": token, "user": UserSerializer(user, context={ "request": request }).data, }
def get(self, request): if request.method == 'GET': #get current user serializer = UserSerializer(request.user) #get stories stories = request.GET.get('stories') #get architecture architecture = request.GET.get('architecture') #predict image prediction = predict_image(serializer.data) #build response response_andrei = { 'email': '*****@*****.**', 'img': "image_generated" + list(serializer.data.values())[0] + ".png", } response_andrei.update(serializer.data) response = [] response.append(response_andrei) #return response return JsonResponse(response, safe=False)
class ProjectSerializer(serializers.ModelSerializer): users = UserSerializer(many=True, read_only=True) workspace = WorkspaceSerializer(read_only=True) class Meta: model = Project fields = ('id', 'name', 'description', 'users', 'workspace', 'created_at')
def post(self, request, format='json'): serializer = UserSerializer(data=request.data) if serializer.is_valid(): user = serializer.save() if user: return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class Meta: model = Friendship fields = ("id", "requester_user", "addresser_user", "status", "request_date", "approval_date", "friendship_end_date", "active") requester_user = UserSerializer(source="manager_user", read_only=True) extra_kwargs = { "requester_user": { "read_only": True }, "request_date": { "read_only": True }, "approval_date": { "read_only": True }, "friendship_end_date": { "read_only": True }, "active": { "read_only": True }, "status": { "read_only": True }, }
class InternSerializer(serializers.ModelSerializer): user = UserSerializer() roles = serializers.SerializerMethodField() log = InternLogEntrySerializer(many=True, read_only=True) comments = serializers.CharField(max_length=300, allow_blank=True, required=False) class Meta: model = Intern fields = ( "id", "user", "active", "comments", "roles", "registered", "left", "log", ) def update(self, instance, validated_data): instance.comments = validated_data.get("comments", instance.comments) instance.save() return instance def get_roles(self, obj): roles = InternRole.objects.filter(intern=obj, date_removed__isnull=True) serializer = InternRoleSerializer(instance=roles, many=True) return serializer.data