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)
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', )
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 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", )
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)
def post(self, request): user_serializer = UserSerializer(data=request.data) if user_serializer.is_valid(): user_object = user_serializer.save() return Response(user_serializer.data, status=201) return Response(user_serializer.errors, status=400)
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')
def post(self, request, format='json'): serializer = UserSerializer(data=request.data) if serializer.is_valid(): user = serializer.save() if user: token = Token.objects.create(user=user) json = serializer.data json['token'] = token.key return Response(json, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def signup(request): serialized = UserSerializer(data=request.data) if serialized.is_valid(): serialized.save() created_user = User.objects.get(username=request.data['username']) token = created_user.auth_token.key return Response({"token": token}, status=status.HTTP_201_CREATED) else: return Response({'error': serialized.errors}, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None): if not self.request.POST.get('registration_key', None) == getattr( settings, "REGISTRATION_KEY"): return Response("Update your application.", status=status.HTTP_401_UNAUTHORIZED) serializer = UserSerializer(data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class RequestListSerializer(RequestSerializer): request_by = UserSerializer() processed_by = UserSerializer() class Meta: model = EmployeeRequest fields = RequestSerializer.Meta.fields + ( 'request_by', 'processed_by', 'created_at', )
def put(self, request, pk, format=None): if not self.check_owner(request, pk): return Response( "You cannot update the account details of other users.", status=status.HTTP_403_FORBIDDEN) 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)
def create(self, request, **kwargs): try: password = make_password(request.data['password']) serializer = UserSerializer(data=request.data, context={'request': request}) except Http404: return Response(status=status.HTTP_404_NOT_FOUND) if serializer.is_valid(): serializer.save(password=password) return Response(serializer.data, status=status.HTTP_200_OK) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
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 put(self, request, id=None): try: user_object = User.objects.get(id=id) except User.DoesNotExist: return Response({'errors': 'This user does not exist.'}, status=400) user_serializer = UserSerializer(user_object, data=request.data) if user_serializer.is_valid(): user_object = user_serializer.save() return Response(user_serializer.data, status=200) return Response(user_serializer.errors, status=400)
def post(self, request, format=None): serializer = UserSerializer(request.user, data=request.data, context={'request': request}) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) serializer.save() return Response(serializer.data)
def post(self, request): serializer = UserSerializer(data=request.data) if serializer.is_valid(): User.objects.create_user( username=serializer.validated_data['username'], email=serializer.validated_data['email'], password=serializer.validated_data['password'], first_name=serializer.validated_data['first_name'], last_name=serializer.validated_data['last_name']) return Response({'message': 'Register successful!'}, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class TableroSerializer(serializers.ModelSerializer): """ General purpose """ dueño = UserSerializer(read_only=True) favoritos = UserSerializer(many=True, read_only=True) miembros = UserSerializer(many=True, read_only=True) class Meta: model = Tablero fields = ('nombre', 'descripcion', 'fecha_creacion', 'dueño', 'favoritos', 'miembros')
def test_username_unique(self): """test for username uniqueness""" User.objects.create(username='******', password='******') serializer = UserSerializer( data={ 'username': '******', 'first_name': 'first', 'last_name': 'last', 'password': '******' }) self.assertFalse(serializer.is_valid())
def test_user_serializer_update(active_user_fixture): serializer = UserSerializer( active_user_fixture, { "email": "*****@*****.**", "password": "******", "name": "another name" }) assert serializer.is_valid() assert serializer.errors == {} serializer.save() active_user_fixture.refresh_from_db() assert active_user_fixture.name == "another name" assert active_user_fixture.check_password("new_password")
def update(self, request, pk=None, **kwargs): try: password = make_password(request.data['password']) instance = self.get_object() self.check_object_permissions(self.request, instance) serializer = UserSerializer(instance, data=request.data, context={'request': request}) except Http404: return Response(status=status.HTTP_404_NOT_FOUND) if serializer.is_valid(): serializer.save(password=password) return Response(serializer.data, status=status.HTTP_200_OK) return Response(serializer.errors, status=status.HTTP_403_FORBIDDEN)
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 ProductSerializer(serializers.ModelSerializer): owner = UserSerializer(read_only=True) class Meta: model = Product fields = ('id', 'name', 'price', 'description', 'creation_date', 'category', 'on_auction', 'owner', 'image') read_only_fields = ('owner', 'creation_date')
def get(self, request): if request.user: translation.activate(request.user.language) request.session[ translation.LANGUAGE_SESSION_KEY] = request.user.language return Response(UserSerializer(request.user).data) return HttpResponseForbidden('user is not logged in')
def my_jwt_response_handler(token, user=None, request=None): return { 'token': token, 'user': UserSerializer(user, context={ 'request': request }).data }
class InfoSerializer(serializers.ModelSerializer): user = UserSerializer(read_only=True) class Meta: model = Info fields = '__all__' read_only_fields = ('user', )
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")
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 }, }
def response_payload_handler(token, user=None, request=None): account, member, countries, states, categories = None, None, None, None, None try: account = Account.objects.get(user=user) except Account.DoesNotExist: pass try: member = Member.objects.get(account=account) except Member.DoesNotExist: pass countries = Country.objects.all() categories = Category.objects.all() partners = Business.objects.filter( account=account).order_by('-last_modified_date') cashiers = [] for role in AccountPartnerRole.objects.filter(account=account): cashiers.append(Business.objects.get(id=role.business_id)) return { 'token': token, 'user': UserSerializer(user).data, 'account': AccountSerializer(account).data, 'member': MemberSerializer(member).data if member else member, 'partners': BusinessSerializer(partners, many=True).data, 'cashiers': BusinessSerializer(cashiers, many=True).data, 'countries': CountrySerializer(countries, many=True).data, 'categories': CategorySerializer(categories, many=True).data, 'stripe_key': settings.STRIPE_PUBLIC_KEY }
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)