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)
