def post(self, request, format=None): serializer = UserSerializer(data=request.data) if serializer.is_valid(): user = serializer.save() user.set_password(raw_password=request.data['password']) user.save() return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request): serializer = UserSerializer(data=request.data) if serializer.is_valid(): # serializer.save() return Response('서버측 유효성 검사 성공', status=status.HTTP_200_OK) # raise serializer.validationError return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request): serializer = UserSerializer(data=request.data) if serializer.is_valid(): serializer.save() data = { 'user': serializer.data, } return Response(data) else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request): serializer = UserSerializer(data=request.data) serializer.is_valid(raise_exception=True) 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 post(self, request): serializer = UserSerializer(data=request.data) if serializer.is_valid(): serializer.save() data = { 'user': serializer.data, 'detail': f'{request.data["email"]}로 새로운 계정을 생성하셨습니다' } return Response(data) else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request): # URL: api/members/auth-token/ # username, password를 받음 # 유저 인증에 성공했을 경우 # 토큰을 생성하거나 있으면 존재하는 걸 가져와서 # Response로 돌려줌 # username = request.data.get('username') # password = request.data.get('password') # user = authenticate(username=username, password=password) # if user is not None: # token, _ = Token.objects.get_or_create(user=user) # data = { # 'token': token.key # } # return Response(data) # raise APIException('authenticate failure') # raise AuthenticationFailed() serializer = self.serializer_class(data=request.data) serializer.is_valid(raise_exception=True) user = serializer.validated_data['user'] token, created = Token.objects.get_or_create(user=user) data = { 'token': token.key, 'user': UserSerializer(user).data, } return Response(data)
def by_token(self, request, pk=None): if pk is not None: instance = Token.objects.get(key=pk) # TODO: This is throwing a pylint error, by pylint is f*****g wrong. Figure this out later. user = Member.objects.get(id=instance.user_id) serializer = UserSerializer(instance=user) return Response(serializer.data)
class PostSerializer(serializers.ModelSerializer): is_like = serializers.SerializerMethodField() author = UserSerializer() comments = CommentSerializer(many=True) class Meta: model = Post fields = ( 'pk', 'author', 'photo', 'created_at', 'is_like', 'comments', ) read_only_fields = ('author', ) def get_is_like(self, obj): user = self.context['request'].user if user.is_authenticated: try: postlike = obj.postlike_set.get(user=user) return PostLikeSerializer(postlike).data except PostLike.DoesNotExist: return
class PostSerializer(serializers.ModelSerializer): author = UserSerializer(read_only=True) images = PostImageSerializer(source='postimage_set', many=True) class Meta: model = Post fields = ( 'pk', 'author', 'images', 'title', 'img_cover', 'content', 'created_date', ) read_only_fields = ('author',) def create(self, validated_data): post = Post( author=self.context['request'].user, title=validated_data['title'], img_cover=validated_data.get('img_cover', None), content=validated_data.get('content', '') ) post.save() files = self.context['request'].FILES.getlist('images') for file in files: PostImage.objects.create( post=post, img=file ) return post
class ArtistSerializer(serializers.ModelSerializer): like_users = UserSerializer(many=True, read_only=True) youtube_links = YoutubeSerializer(many=True, read_only=True) class Meta: model = Artist fields = '__all__'
class Review_Local_Serializer(ModelSerializer): review_user = UserSerializer(read_only=True) review_menu = MenuSerializer(read_only=True) class Meta: model = Review_Local fields = '__all__'
def get(self, request): print(request.user) serializer = UserSerializer(request.user) data = { 'user': serializer.data } return Response(data)
def test_permissions(self): # List요청, 인증필요 response = self.client.get(self.URL_LIST) self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) # Retrieve요청, 인증필요 user = baker.make(User) response = self.client.get(self.URL_DETAIL.format(id=user.id)) self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) # Profile요청, 인증 필요 response = self.client.get(self.URL_LIST + "profile/") self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) # Retrieve요청, 다른사용자일 경우 거부 user2 = baker.make(User) self.client.force_authenticate(user2) response = self.client.get(self.URL_DETAIL.format(id=user.id)) self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) # Update요청, 다른사용자일 경우 거부 data = UserSerializer(user).data data["name"] = "AnotherName" response = self.client.patch( self.URL_DETAIL.format(id=user.id), data=data, format="json" ) self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) # Destroy요청, 허용되지 않는 요청 response = self.client.delete(self.URL_DETAIL.format(id=user.id)) self.assertEqual(response.status_code, status.HTTP_405_METHOD_NOT_ALLOWED)
def post(self, request): username = request.data['username'] # 사용자가 계정으로 로그인.(string) # checker = json.dumps(username) # print('유저네임이 json 데이터인지 확인하기',checker) password = request.data['password'] # 사용자가 계정으로 로그인.(string) user = authenticate(username=username, password=password) # 유효한 사용자인지 검사 print(type(user)) if user: token, _ = Token.objects.get_or_create( user=user) # 유효할 경우 사용자에게 토큰 제공 else: raise AuthenticationFailed() # 존재하지 않은 유저일 경우 인증 실패 오류를 반환 # user 데이터를 serialize 해줘야 하는 이유: # response 로 token 과 사용자의 데이터를 보내줘야 한다. # user 는 User모델의 인스턴스이다. 인스턴스를 JSON 데이터로 보내주기 위해서는 serialize 를 해줘야 한다 # JSON데이터로 보내줘야 하기 때문에 is_valid()를 해줄 필요가 없다 serializer = UserSerializer(user) data = { 'token': token.key, 'data': serializer.data, } return Response(data)
class StudyMembershipSimpleSerializer(serializers.ModelSerializer): user = UserSerializer() role_display = serializers.CharField(source='get_role_display') class Meta: model = StudyMembership fields = STUDY_MEMBER_FIELDS
def post(self, request): access_token = request.data.get('accessToken') url = 'https://kapi.kakao.com/v2/user/me' headers = { 'Authorization': f'Bearer {access_token}', 'Content-type': 'application/x-www-form-urlencoded;charset=utf-8' } kakao_response = requests.post(url, headers=headers) user_data = kakao_response.json() kakao_id = user_data['id'] user_username = user_data['properties']['nickname'] user_first_name = user_username[1:] user_last_name = user_username[0] try: user = User.objects.get(username=kakao_id) except User.DoesNotExist: user = User.objects.create_user( username=kakao_id, first_name=user_first_name, last_name=user_last_name, ) payload = JWT_PAYLOAD_HANDLER(user) jwt_token = JWT_ENCODE_HANDLER(payload) kakao = SocialLogin.objects.filter(type='kakao')[0] user.social.add(kakao) data = { 'token': jwt_token, 'user': UserSerializer(user).data, } return Response(data)
def post(self, request): access_token = request.data.get('accessToken') params = { 'access_token': access_token, 'fields': ','.join([ 'id', 'first_name', 'last_name', 'picture.type(large)', ]) } response = requests.get(self.api_me, params) data = response.json() facebook_id = data['id'] first_name = data['first_name'] last_name = data['last_name'] try: user = User.objects.get(username=facebook_id) except User.DoesNotExist: user = User.objects.create_user( username=facebook_id, email=f'{facebook_id}@facebook.com') payload = JWT_PAYLOAD_HANDLER(user) jwt_token = JWT_ENCODE_HANDLER(payload) facebook = SocialLogin.objects.filter(type='facebook')[0] user.social.add(facebook) data = { 'token': jwt_token, 'user': UserSerializer(user).data, } return Response(data)
def post(self, request): # url: /members/auth-token/ # members.urls를 사용 # config.urls에서는 include # Postman에서 작동되는지 확인 # # Hint # request.data로 전달된 내용을 적절히 사용 # Serializer는 사용하지 않음) # # 1. url과 이 view를 연결, Postman에 작성 # 2. Postman의 body에 작성한 내용이 # Send버튼을 누른 뒤 이 view의 # request.data에 원하는 데이터가 오고 있는지 확인 # 3. 적절한 데이터가 온다면 그 때 authenticate()함수를 사용, # User 객체를 얻어냄 username = request.data['username'] password = request.data['password'] user = authenticate(username=username, password=password) # 4. 얻어낸 User객체와 연결되는 Token을 get_or_create()로 # 가져오거나 생성 if user: token, _ = Token.objects.get_or_create(user=user) else: raise AuthenticationFailed() # 5. 생성된 Token의 'key' 속성을 적절히 반환 data = { 'token': token.key, 'user': UserSerializer(user).data, } return Response(data)
class NoticeSerializer(ModelSerializer): type_display = serializers.CharField(source='get_type_display') team = TeamSerializer() author = UserSerializer() attendance_voted_count = serializers.IntegerField(help_text='투표에 참여한 인원 수', default=None) attendance_count = serializers.IntegerField(help_text='투표 가능한 총 인원 수', default=None) is_voted = serializers.BooleanField(help_text='투표에 참여한 인원 수', default=None) class Meta: model = Notice fields = ( 'id', 'type', 'type_display', 'team', 'title', 'author', 'start_at', 'duration', 'address1', 'address2', 'description', 'attendance_voted_count', 'attendance_count', 'is_voted', )
class BasketSerializer(serializers.ModelSerializer): user = UserSerializer() item = ItemsSimpleSerializer() cart_item_pk = serializers.CharField(source='pk', required=False) class Meta: model = Basket fields = ('cart_item_pk', 'user', 'item', 'amount')
class StudySerializer(serializers.ModelSerializer): category = StudyCategorySerializer() icon = StudyIconSerializer() author = UserSerializer() class Meta: model = Study fields = STUDY_FIELDS
def patch(self, request, user_region): instance = self.get_object() instance.user_region = user_region instance.save() print(instance) serializer = UserSerializer(instance) return Response(serializer.data)
def post(self, request): serializer = AuthTokenSerializer(data=request.data) serializer.is_valid(raise_exception=True) user = serializer.validated_data['user'] token, _ = Token.objects.get_or_create(user=user) data = {'token': token.key, 'user': UserSerializer(user).data} return Response(data)
def get(self, request, pk=None): if pk is not None: user = get_object_or_404(User, pk=pk) else: user = request.user if not user.is_authenticated: raise NotAuthenticated() serializer = UserSerializer(user) return Response(serializer.data)
def jwt(self, request): username = request.data.get('username') userpass = request.data.get('password') user = authenticate(username=username, password=userpass) payload = JWT_PAYLOAD_HANDLER(user) jwt_token = JWT_ENCODE_HANDLER(payload) if user is not None: data = {'token': jwt_token, 'user': UserSerializer(user).data} return Response(data)
class AttendanceSerializer(serializers.ModelSerializer): user = UserSerializer() schedule = ScheduleSerializer() vote_display = serializers.CharField(source='get_vote_display') att_display = serializers.CharField(source='get_att_display') class Meta: model = Attendance fields = ATTENDANCE_FIELDS
def to_representation(self, instance): ret = super().to_representation(instance) # print(ret) token, _ = Token.objects.get_or_create(user=instance) data = { "token": token.key, "user": UserSerializer(instance).data, } return data
class CommentSerializer(serializers.ModelSerializer): author = UserSerializer() class Meta: model = Comment fields = ( 'pk', 'author', 'content', )
def post(self, request): # exceptions serializer = self.get_serializer(data=request.data) serializer.is_valid() try: user = authenticate(request, auth=serializer.data) except AuthenticationFailed: return Response(status=status.HTTP_401_UNAUTHORIZED) return Response(UserSerializer(user).data, status.HTTP_200_OK)
def test_login_api(self): url = '/members/login/' email = '*****@*****.**' username = '******' password = '******' # 유저 생성 user = baker.make(User, email=email, username=username) # password는 set_password 함수를 통해 만듦 (해시된 값으로 생성) # password를 그대로 넣으면 raw string이 들어가게 됨 user.set_password(password) user.save() # 전송될 데이터 data = { 'email': email, 'username': username, 'password': password, } # post 방식으로 요청 보냄 response = self.client.post(url, data) # 상태 코드 확인 self.assertEqual(response.status_code, status.HTTP_200_OK) # 토큰이 왔는지 확인 self.assertIn('token', response.data) # 유저 정보가 왔는지 확인 self.assertIn('user', response.data) # User 인스턴스를 serializer 한 결과가 response.data의 'user' key의 value(object)과 같은지 확인 self.assertEqual(UserSerializer(user).data, response.data['user']) # 토큰이 있는지 확인 # Token 내장 클래스 > user 필드 > related_name='auth_token' self.assertIsNotNone(user.auth_token) # response.data의 'token' key의 value 값이 user와 연결된 Token의 key와 같은지 확인 self.assertEqual(user.auth_token.key, response.data['token']) print('response.data >> ', response.data) print('UserSerializer(user).data >> ', UserSerializer(user).data) print('user.auth_token >> ', user.auth_token)