def post(self, request): """ Handles the POST request made to the `/accounts/` URL. This view will take the `data` property from the `request` object, deserialize it into a `User` object and store in the DB. Returns a 201 (successfully created) if the user is successfully created, otherwise returns a 400 (bad request) :param request: :return: """ serializer = UserSerializer(data=request.data) if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) else: data = serializer.data # Create a new user using the username contained in the data dict user = User.objects.create(username=data["username"]) # User the set password method to create a hashed password # using the password provided in the data dict user.set_password(data["password"]) # Finally save the new user object user.save() return Response(data, status=status.HTTP_201_CREATED)
def post(self, request): """ Handles the POST request made to the `/accounts/` URL. This view will take the `data` property from the `request` object, deserialize it into a `User` object and store in the DB. Returns a 201 (successfully created) if the user is successfully created, otherwise returns a 400 (bad request) """ serializer = UserSerializer(data=request.data) # Check to see if the data in the `request` is valid. # If the cannot be deserialized into a Todo object then # a bad request respose will be returned. # Else, save the data and return the data and a successfully # created status if not serializer.is_valid(): return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) else: data = serializer.data # Create a new user using the `username` contained in # the `data` dict user = User.objects.create(username=data["username"]) # Use the `set_password` method to create a hashed password # using the password provided in the `data` dict user.set_password(data["password"]) # Finally, save the new `user` object user.save() return Response(data, status=status.HTTP_201_CREATED)
def post(self, request, format=None): serializer = UserSerializer(data=request.data) if serializer.is_valid(): user = serializer.save() user.set_password(request.data['password']) user.save() return Response(serializer.data, status=201) return Response(serializer.errors, status=400)
def post(self, request): serialized = UserSerializer(data=request.DATA) if serialized.is_valid(): user = User.objects.create_user(**request.DATA) data = {'token': Token.objects.get(user=user).key} return Response(data, status=status.HTTP_201_CREATED) else: return Response(serialized._errors, status=status.HTTP_400_BAD_REQUEST)
def register(self, request): serializer = UserSerializer(data=request.data) if serializer.is_valid(): user = User.objects.create_user(**serializer.validated_data) token = Token.create_token(user.id) data = { 'username': user.username, 'token': token } return Response(data, status=201) return Response(serializer.errors, status=400)
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 setUp(self): self.url = reverse('auth') # User info self.username = '******' self.email = '*****@*****.**' self.password = '******' # make sure our example data is valid serializer = UserSerializer(data={'username': self.username, 'email': self.email, 'password': self.password}) if serializer.is_valid(): self.user = serializer.save() else: self.fail()
class AttendanceSerializer(serializers.ModelSerializer): user = UserSerializer(read_only=True) team = TeamSerializer(read_only=True) class Meta: model = Attendance fields = "__all__" read_only_fields = ('created', 'updated')
class ReferenceSerialaizer(serializers.ModelSerializer): reference_type_id = Reference_Type_Serializer(read_only=True) user = UserSerializer(read_only=True) class Meta: model = Reference fields = ('id', 'reference_type_id', 'user', 'reference_file', 'created_at')
def profile(request,user_pk): user = get_object_or_404(User, pk=user_pk) userserial = UserSerializer(user) likemovies = user.likemovie_set.filter(score__gte=4) likeserial = UserLikeMovieSerializer(likemovies, many=True) return Response([userserial.data,likeserial.data])
class ProductSerializer(serializers.ModelSerializer): # category=CategorySerializer() category = serializers.ReadOnlyField(source='category.name') #get the name likes = UserSerializer(many=True) #nested class Meta: model = Product fields = '__all__'
def test_fields(self): serializer = UserSerializer() self.assert_fields_required(True, serializer, self.required_fields) self.assert_fields_required(False, serializer, self.not_required_fields) self.assertEqual( len(serializer.fields), len(self.required_fields) + len(self.not_required_fields))
def get(self, request, format='json'): username = "******" password = "******" email = "*****@*****.**" user = authenticate(request, username=username, password=password) login(request, user) serializer = UserSerializer(user) return JsonResponse(serializer.data, safe=False)
def tweet_list_view(request, *args, **kwargs): qs = Tweet.objects.all() username = UserSerializer(request.user).data.get('username') print(username) if username != None: qs = qs.filter(user__username__iexact=username) serializer = TweetSerializer(qs, many=True) return Response(serializer.data, status=200)
class ArticleSerializer(serializers.ModelSerializer): user = UserSerializer(required=False) movie = MovieSerializer(required=False) class Meta: model = Article fields = "__all__" read_only_fields = ['id']
def users(request): try: users = User.objects.all() serializer = UserSerializer(users, many=True) return Response(data=serializer.data, status=status.HTTP_200_OK) except: return Response(status=status.HTTP_500_INTERNAL_SERVER_ERROR)
class ChallengeCommentSerializer(serializers.ModelSerializer): author = UserSerializer(read_only=True) replies = RecursiveField(many=True, read_only=True) class Meta: model = ChallengeComment fields = ('id', 'content', 'author', 'replies') read_only_fields = ('id', 'author', 'replies')
class ChanelSerializer(serializers.ModelSerializer): owner = UserSerializer(read_only=True) author = UserSerializer(read_only=True, many=True) def update(self, instance, validated_data): instance.description = validated_data.get('description', instance.description) instance.identifier = validated_data.get('identifier', instance.identifier) instance.law = validated_data.get('law', instance.law) instance.title = validated_data.get('title', instance.title) instance.save() return instance class Meta: model = Chanel fields = '__all__'
def get(self, request, pk, format=None): user_detail = self.get_object(pk) serializer = UserSerializer(user_detail) # data_with_link = dict(serializer.data)#["member"] = 'groups/{}/members/'.format(pk) # links = {'members': 'api/v1/groups/{}/members/'.format(pk)} # data_with_link['links'] = links data_dict = {"data": serializer.data, "status": 200} return Response(data_dict, status=status.HTTP_200_OK)
def post(self, request, *args, **kwargs): serializer = self.serializer_class( data=request.data, context={"request": request} ) serializer.is_valid(raise_exception=True) user = serializer.validated_data["user"] token, created = Token.objects.get_or_create(user=user) return Response({"key": token.key, "user": UserSerializer(instance=user).data})
class QustionSerializer(serializers.ModelSerializer): tags = TagSerializer(many=True) answers = AnswerSerializer(many=True, required=False, allow_null=True) user = UserSerializer() comment = CommentSerializer(many=True) class Meta: model = Question
def enrollusers(self, request, *args, **kwargs): queryset = Enroll.objects.filter( lesson__created_by=self.request.user).values_list('user', flat=True) users = User.objects.filter(email__in=queryset) page = self.paginate_queryset(users) serializers = UserSerializer(page, many=True) return self.get_paginated_response(serializers.data)
def setUp(self): self.user = User.objects.first() Task.objects.create( done=True, content="Test", user=self.user, ) self.serializer = UserSerializer(self.user)
class ArticleSerializer(serializers.ModelSerializer): user = UserSerializer(required=False) created_at = serializers.DateTimeField(required=False) class Meta: model = Article fields = '__all__' read_only_fields = ('id', 'user', 'created_at', 'updated_at')
class RetrieveDeleteSerializer(UpdateCreateTaskSerializer): ''' Serializer for tasks model ''' assigned_to = UserSerializer(many=False) class Meta: model = Task fields = ('id', 'assigned_to', 'team', 'name', 'description', 'status', 'deadline', 'created')
class ReviewDetailSerializer(serializers.ModelSerializer): writer = UserSerializer(required=False) movie = MovieSerializer(required=False) class Meta: model = Review fields = '__all__'
class OrderCreateSerializer(serializers.ModelSerializer): user = UserSerializer(required=False) reward = RewardSerializer(required=False) card = CardSerialiser(required=False) class Meta: model = Order fields = '__all__'
class LikeMovieSerializer(serializers.ModelSerializer): user = UserSerializer(required=False) class Meta: model = LikeMovie fields = '__all__' read_only_fields = ('id', 'user')
class MemesSerializer(serializers.ModelSerializer): owner = UserSerializer(many=True, read_only=True) tags = TagSerializer(many=True, read_only=True) class Meta: model = Memes fields = '__all__' depth = 1
class EmotionSerializer(serializers.ModelSerializer): id = serializers.IntegerField(required=False) user = UserSerializer(read_only=True) name = serializers.CharField(max_length=100) class Meta: model = Emotion fields = ('id', 'name', 'user')
def has_permission(self, request, view): user = UserSerializer(request.user) role = user.data['role'] if role == 'HOD': return True else: return False
def has_permission(self, request, view): user = UserSerializer(request.user) role = user.data['role'] if role == 'HOD' or role == 'student_leader' or role == 'Administrator': return True else: return False
def post(self, request, *args, **kwargs): serializer = self.get_serializer(data=request.data) serializer.is_valid(raise_exception=True) user = serializer.save() return Response({ "user": UserSerializer(user, context=self.get_serializer_context()).data, "token": AuthToken.objects.create(user)[1] })
def has_permission(self, request, view): user = UserSerializer(request.user) role = user.data['role'] id = user.data['id'] if role == 'Administrator' or id == '1': return True else: return False
def jwt_response_payload_handler(token, user=None, request=None): # requset needs to be passed in the context, error otherwise return { 'token': token, 'user': UserSerializer(user, context={ 'request': request }).data }
class OrderSerializer(serializers.ModelSerializer): user = UserSerializer() reward = RewardSerializer() card = CardSerialiser() class Meta: model = Order fields = '__all__'
class AsesorSerializer(serializers.ModelSerializer): reclutador = UserSerializer(read_only=True, default=serializers.CurrentUserDefault()) class Meta: model = Asesor fields = '__all__'
def setUp(self): # url self.user_list = 'api:user-list' self.user_detail = 'api:user-detail' # User info self.username = '******' self.email = '*****@*****.**' self.password = '******' # make sure our example data is valid serializer = UserSerializer(data={'username': self.username, 'email': self.email, 'password': self.password}) if serializer.is_valid(): self.user = serializer.save() else: self.fail()
def post(self, request): logger.info("UpdatePasswordView.post is called. User: {0}".format(request.user.log_guid)) # TODO: check if front end sends a json file or normal request data = request.data update_password_serializer = self.serializer_class(data=data) if update_password_serializer.is_valid(): password = update_password_serializer.validated_data['password'] account = authenticate(email=request.user.email, password=password) if account is not None: if account.is_active: new_password = update_password_serializer.validated_data['new_password'] try: # we use partial to avoid passing required fields into serializer serializer = UserSerializer(account, data={'password': new_password}, partial=True) if serializer.is_valid(): serializer.save() account = authenticate(email=request.user.email, password=new_password) login(request, account) logger.info(self.msgs['finish_success'].format(request.user.log_guid)) return Response({ 'status': _('Success'), 'message': self.msgs['update_pass_success']}, status=status.HTTP_200_OK) else: logger.error(self.errs['ser_not_valid'].format(data)) return Response({'status': _('Bad request'), 'message': serializer.errors}, status=status.HTTP_400_BAD_REQUEST) except Exception as e: logger.exception(self.errs['exception'].format(e.message)) return Response({'status': _('Bad request'), 'message': self.msgs['internal_server_error']}, status=status.HTTP_400_BAD_REQUEST) else: logger.error(self.errs['user_inactive'].format(request.user.log_guid)) return Response({'status': _('Unauthorized'), 'message': self.msgs['cannot_update_pass']}, status=status.HTTP_401_UNAUTHORIZED) else: logger.error(self.errs['combination_invalid']) return Response({ 'status': _('Unauthorized'), 'message': self.msgs['combination_invalid']}, status=status.HTTP_401_UNAUTHORIZED) else: logger.error(update_password_serializer.errors) return Response({'status': 'Bad request', 'message': self.msgs['password_mismatch'], 'errors': 'Validation error'}, status=status.HTTP_400_BAD_REQUEST)
def register(request): """ Endpoint for registration. Does not require any permissions, so that anyone can access it. """ USER_FIELDS = ['username', 'password', 'email', 'role'] serialized = UserSerializer(data=request.data) if serialized.is_valid(raise_exception=True): user_data = { field: data for (field, data) in request.data.items() if field in USER_FIELDS } user = User.objects.create_user( **user_data ) return Response( UserSerializer(instance=user, context={'request': request}).data, status=status.HTTP_201_CREATED, )
def post(self, request, format='json'): serializer = UserSerializer(data=request.data) if serializer.is_valid(): #print("Valid") user = serializer.save() if user: if request.data["isStudent"] == 1: new_student = Student(user=user, contact_no=request.data["contact_no"]) new_student.save() elif request.data["isStudent"] == 0: new_teacher = Teacher(user=user, contact_no=request.data["contact_no"]) new_teacher.save() else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) 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 setUp(self): self.token_list = 'api:token-list' self.token_detail = 'api:token-detail' # Clients cannot be created via view or serialzier self.name = 'reddit' self.api_url = 'https://oauth.reddit.com/api/v1/' self.authorize_url = 'https://www.reddit.com/api/v1/' self.token_url = 'https://www.reddit.com/api/v1/access_token/' self.client_id = 'some-client-id' self.client_secret = 'some-secret' self.redirect_uri = 'http://*****:*****@example.com' self.password = '******' # make sure our example data is valid serializer = UserSerializer(data={'username': self.username, 'email': self.email, 'password': self.password}) if serializer.is_valid(): self.user = serializer.save() else: self.fail()
def post(self, request): data = json.loads(request.body) guid = data.get('guid', None) logger.info("SetPasswordView.post is called. GUID: {0}".format(guid)) password_serializer = PasswordSerializer(data=data, partial=True) if not password_serializer.is_valid(): return Response({ 'status': _('Bad request'), 'message': self.msgs['password_mismatch'], 'errors': 'Validation error' }, status=status.HTTP_400_BAD_REQUEST) try: user_uid = UserUID.objects.get(guid=guid) except ObjectDoesNotExist: logger.exception(self.errs['GUID_invalid'].format(guid)) return Response({ 'status': _('Bad request'), 'message': self.msgs['activation_invalid'] }, status=status.HTTP_400_BAD_REQUEST) now_offset_aware = timezone.make_aware(datetime.datetime.utcnow(), timezone.get_current_timezone()) if user_uid.expiration_date < now_offset_aware: logger.error(self.errs['GUID_expired'].format(guid, user_uid.expiration_date, now_offset_aware)) return Response({ 'status': _('Bad request'), 'message': self.msgs['activation_invalid'] }, status=status.HTTP_400_BAD_REQUEST) try: account = User.objects.get(id=user_uid.user_id) except ObjectDoesNotExist: logger.exception(self.msgs['GUID_invalid'].format(guid)) return Response({ 'status': _('Fail'), 'message': self.msgs['internal_server_error'] }, status=status.HTTP_500_INTERNAL_SERVER_ERROR) if account is not None: se_data = dict() se_data['password'] = password_serializer.validated_data['new_password'] se_data['confirm_password'] = password_serializer.validated_data['confirm_password'] se_data['email'] = account.email se_data['username'] = account.username se_data['log_guid'] = account.log_guid try: with transaction.atomic(): serializer = UserSerializer(account, data=se_data) if serializer.is_valid(): serializer.save() # We need to mark the forgotpassword GUID as expired uid_data = dict() uid_data['guid'] = guid uid_data['user'] = user_uid.user_id uid_data['expiration_date'] = datetime.datetime.utcnow() uidSerializer = UserUIDSerializer(user_uid, data=uid_data) if uidSerializer.is_valid(): uidSerializer.save() logger.info(self.msgs['finish_success'].format(guid)) return Response({ 'status': _('Success'), 'message': self.msgs['update_pass_success'] }, status=status.HTTP_200_OK) else: logger.error(self.errs['ser_not_valid'].format(guid, user_uid.user_id, uid_data['expiration_date'])) return Response({ 'status': _('Fail'), 'message': self.msgs['internal_server_error'] }, status=status.HTTP_500_INTERNAL_SERVER_ERROR) else: logger.error(self.errs['server_error']) return Response({ 'status': _('Fail'), 'message': self.msgs['internal_server_error'] }, status=status.HTTP_500_INTERNAL_SERVER_ERROR) except Exception as e: logger.exception(self.errs['exception'].format(guid, e.message)) return Response({ 'status': _('Bad request'), 'message': self.msgs['internal_server_error'] }, status=status.HTTP_500_INTERNAL_SERVER_ERROR) else: logger.exception(self.errs['GUID_none'].format(guid)) return Response({ 'status': _('Bad request'), 'message': self.msgs['activation_invalid'] }, status=status.HTTP_400_BAD_REQUEST)