def get_user(self, obj):
serializer = UserSerializer(obj)
try:
profile = Profile.objects.select_related('user').filter(user=obj).get()
data = {
"username": serializer.data['nickname'],
"following_url": "/api/member/" + str(serializer.data['pk']) + "/follow/",
"intro": profile.intro,
"web": profile.web,
"achevement": "",
"instagram": profile.instagram,
"facebook": profile.facebook,
"twitter": profile.twitter,
"img": self.image(obj)
}
return data
except ObjectDoesNotExist:
data = {
"username": serializer.data['nickname'],
"following_url": "/api/member/" + str(serializer.data['pk']) + "/follow/",
"intro": "",
"web": "",
"achevement": "",
"instagram": "",
"facebook": "",
"twitter": "",
"img": self.image(obj)
}
return data
class GroupSerializer(serializers.ModelSerializer):
owner = UserSerializer(many=False, read_only=True)
tags = TagSerializer(many=True, read_only=True)
class Meta:
model = MyGroup
fields = (
'pk',
'name',
'owner',
'profile_img',
'group_type',
'description',
'num_of_members',
'tags',
)
read_only_fields = ('num_of_members', )
def to_representation(self, instance):
ret = super().to_representation(instance)
user = self.context['request'].user
if user.is_authenticated:
ret['is_member'] = user.membership_set.filter(
group=instance).exists()
if ret['is_member']:
ret['is_owner'] = instance.owner == user
return ret
def post(self, request):
# 프론트로부터 전달된 token값
token = request.data.get('token')
if not token:
raise APIException('token require')
# 전달받은 token을 debug
result = self.debug_token(token)
# debug후 is_valid가 True일 경우
if result['data']['is_valid']:
# Facebook user id를 가져옴
facebook_user_id = result['data']['user_id']
# 해당 user id가 username인 유저가 있는지 검사
if User.objects.filter(username=facebook_user_id).exists():
user = User.objects.get(username=facebook_user_id)
created = False
else:
user = User.objects.create_user(username=facebook_user_id)
created = True
# user에 해당하는 Token을 가져오거나 새로 만듬
token, _ = Token.objects.get_or_create(user=user)
# 관련 정보들을 dict화
ret = {
'token': token.key,
'user': UserSerializer(user).data,
'user_created': created,
}
# API에서 돌려줌
return Response(ret)
else:
raise APIException('token invalid')
class PostListSerializer(serializers.ModelSerializer):
# User 정보를 author에 표현하기 위해 멤버 모델 완성 후 바꿔줘야함
author = UserSerializer()
# PostList뷰에서 Post의 첫 사진을 커버로 이용하기 위한 필드
# method필드가 아니라 릴레이션필드를 사용해야함.
img = serializers.SerializerMethodField()
class Meta:
model = Post
fields = (
'pk',
'author',
'title',
'start_date',
'end_date',
'img',
'continent',
'liked',
'num_liked',
)
def get_img(self, obj):
s = obj.img.url
return s.split('?')[0]
class PostSerializer(serializers.ModelSerializer):
author = UserSerializer(read_only=True)
my_comment = CommentSerializer(read_only=True)
comments = CommentSerializer(read_only=True,
many=True,
source='comment_set')
class Meta:
model = Post
fields = (
'pk',
'author',
'photo',
'my_comment',
'comments',
)
read_only_fields = (
'author',
'my_comment',
)
def to_representation(self, instance):
ret = super().to_representation(instance)
ret['is_like'] = self.context[
'request'].user in instance.like_users.all()
def post(self, request):
# request.data에 access_token, fackebook_user_id가 전달됨
# Debug 결과의 NamedTuple
class DebugTokenInfo(NamedTuple):
app_id: str
application: str
expires_at: int
is_valid: bool
issued_at: int
scopes: list
type: str
# token(access_token)을 받아 해당 토큰을 Debug
def get_debug_token_info(token):
app_id = settings.FACEBOOK_APP_ID
app_secret_code = settings.FACEBOOK_APP_SECRET_CODE
app_access_token = f'{app_id}|{app_secret_code}'
url_debug_token = 'https://graph.facebook.com/debug_token'
params_debug_token = {
'input_token': token,
'access_token': app_access_token,
}
response = requests.get(url_debug_token, params_debug_token)
return DebugTokenInfo(**response.json()['data'])
# request.data로 전달된 access_token값을 페이스북API쪽에 debug요청, 결과를 받아옴
debug_token_info = get_debug_token_info(request.data['access_token'])
if debug_token_info.user_id != request.data['facebook_user_id']:
raise APIException('페이스북 토큰의 사용자와 전달받은 facebook_user_id가 일치하지 않음')
if not debug_token_info.is_valid:
raise APIException('페이스북 토큰이 유효하지 않음')
user = authenticate(facebook_user_id=request.data['facebook_user_id'])
if not user:
user = User.objects.create_user(
username=f'fb_{request.data["facebook_user_id"]}',
user_type=User.USER_TYPE_FACEBOOK,
)
# 유저 시리얼라이즈 결과를 Response
# token도 추가
data = {'user': UserSerializer(user).data, 'token': user.token}
return Response(UserSerializer(user).data)
class PostSerializer(serializers.ModelSerializer):
author = UserSerializer(read_only=True)
class Meta:
model = Post
fields = (
'pk',
'author',
'photo',
'created_date',
)
class CommentUpdateSerializer(serializers.ModelSerializer):
author = UserSerializer(read_only=True)
content = serializers.CharField(required=True)
class Meta:
model = Comment
fields = ('pk', 'post', 'author', 'content', 'created_date')
read_only_fields = (
'post',
'created_date',
)
class PostSerializer(serializers.ModelSerializer):
author = UserSerializer()
class Meta:
model = Post
fields = (
'pk',
'author',
'photo',
'created_at',
)
class PostSerializer(serializers.ModelSerializer):
# author를 pk값이 아닌 user 객체로 올 수 있도록 세팅
author = UserSerializer()
class Meta:
model = Post
fields = (
'pk',
'author',
'photo',
'created_at',
)
class PostReplySerializer(serializers.ModelSerializer):
author = UserSerializer()
class Meta:
model = PostReply
fields = (
'pk',
'post',
'author',
'content',
'created_at',
)
class PostSerializer(serializers.ModelSerializer):
"""
목표 1.
author필드의 값이 pk가 아닌, 하나의 Object(dict)로 나타나도록 수정
http://www.django-rest-framework.org/api-guide/serializers/#dealing-with-nested-objects
1. 관련 테스트코드 작성
post_list, post_create부분
2. 해당 테스트코드가 작동하도록 PostSerializer를 수정 및 UserSerializer작성
3. 테스트 및 포스트맨 작동 확인
목표 2.
Post에 연결된 PostPhoto를 리스트 내부의 Object형태로 리턴
'author': {<author object>},
'postphoto_set': [
{
'pk': <PostPhoto pk>,
'photo': <PostPhoto photo field url>,
},
{
'pk': <PostPhoto pk>,
'photo': <PostPhoto photo field url>,
},
]
1. 관련 테스트코드 작성
post_list, post_create부분
2. 해당 테스트코드가 작동하도록 PostSerializer를 수정 및 PostPhotoSerializer작성
3. 테스트 및 포스트맨 작동 확인
4. postphoto_set의 이름을 photo_list로 변경
http://www.django-rest-framework.org/api-guide/serializers/#specifying-fields-explicitly
목표 3.
post-list요청시 Pagination될 수 있도록 변경
1. 관련 테스트코드 작성 (가능하면)
2. Pagination문서 보고 CustomPagination구현
3. pagination_class에 지정
4. 요청결과를 확인
"""
author = UserSerializer(read_only=True)
postphoto_set = PostPhotoSerializer(many=True, read_only=True)
class Meta:
model = Post
fields = (
'pk',
'author',
'created_date',
'postphoto_set',
)
read_only_fields = ('created_date', )
class CommentSerializer(serializers.ModelSerializer):
post = PostSerializer(read_only=True)
author = UserSerializer(read_only=True)
class Meta:
model = Comment
fields = (
'id',
'post',
'author',
'content',
'created_date',
)
class AuthorSerializer(serializers.ModelSerializer):
author = UserSerializer()
class Meta:
model = AuthorModel
fields = (
'pk',
'author',
'is_active',
'intro',
'blog',
'created_at'
)
def get(self, request, *args, **kwargs):
import requests
token = self.kwargs.get('token')
def get_debug_token_info(token):
headers = {"Authorization": "Bearer " + token}
r = requests.post(url='https://kapi.kakao.com/v1/user/me',
headers=headers)
# print(json.dumps(list(r)))
return r.json()
debug_token_info = get_debug_token_info(token)
if debug_token_info.get('code'):
return HttpResponseRedirect(redirect_to='/').delete_cookie()
user_id = debug_token_info['id']
user = KakaoBackend.authenticate(user_id=user_id)
if not user:
userinfo = User.objects.filter(
username=debug_token_info['kaccount_email']).count()
if not userinfo == 0:
raise NotAcceptable('Already exists this email')
user = User.objects.create_kakao_user(
username=debug_token_info['kaccount_email'],
nickname=debug_token_info['properties']['nickname'],
social_id=f'k_{user_id}',
)
Profile.objects.create(user=user)
ProfileImage.objects.create(user=user)
else:
user = User.objects.filter(social_id=f'k_{user_id}').get()
data = {
'user': UserSerializer(user).data,
'token': jwt_token_generator(user)
}
response = Response(data, status=status.HTTP_200_OK)
if api_settings.JWT_AUTH_COOKIE:
response.set_cookie(api_settings.JWT_AUTH_COOKIE,
response.data['token'],
max_age=21600,
httponly=True)
return response
class CommentDetailSerializer(serializers.ModelSerializer):
movie = MovieSerializer(read_only=True)
author = UserSerializer(read_only=True)
class Meta:
model = Comment
fields = (
'id',
'movie',
'author',
'star',
'content',
'created_date',
)
def post(self, request):
# request.data 에 facebook_user_id 와 access_token 이 전달되어 옴
print(request.data)
# token 값의 유효성을 검사하기 위한 정보를 저장하는 클래스
class DebugTokenInfo(NamedTuple):
app_id: str
application: str
expires_at: int
is_valid: bool
issued_at: int
scopes: list
type: str
user_id: str
# 받아온 토큰 값이 진짜 토큰인지 확인하는 메서드
def get_debug_token_info(access_token):
app_id = settings.FACEBOOK_APP_ID
app_secret_code = settings.FACEBOOK_APP_SECRET_CODE
app_access_token = f'{app_id}|{app_secret_code}'
params = {
'input_token': access_token,
'access_token': app_access_token,
}
response = requests.get('https://graph.facebook.com/debug_token', params=params)
return DebugTokenInfo(**response.json()['data'])
debug_token_info = get_debug_token_info(request.data['access_token'])
if debug_token_info.user_id != request.data['facebook_user_id']:
raise APIException('페이스북 토큰의 사용자와 전달받은 facebook_user_id가 일치하지 않음')
if not debug_token_info.is_valid:
raise APIException('페이스북 토큰이 유효하지 않음')
# FacebookBackend를 사용해서 유저 인증
user = authenticate(facebook_user_id=request.data['facebook_user_id'])
# 인증에 실패한 경우 페이스북유저 타입으로 유저를 만들어줌
if not user:
user = User.objects.create_user(
username=f'fb_{request.data["facebook_user_id"]}',
user_type=User.USER_TYPE_FACEBOOK,
)
# 유저 시리얼라이즈 결과를 Response
data = {
'user': UserSerializer(user).data,
'token': user.token,
}
return Response(data)
class PhotoCommentSerializer(serializers.ModelSerializer):
"""
UserSerializer를 구현하고, author field를 Nested relation으로 나타냄
author필드에서 UserSerializer를 사용하도록 설정
"""
author = UserSerializer(read_only=True)
class Meta:
model = PhotoComment
fields = (
'id',
'photo',
'author',
'content',
)
class PostSerializer(serializers.ModelSerializer):
author = UserSerializer(read_only=True)
class Meta:
model = Post
fields = (
'pk',
'author',
'title',
'thumbnail',
'post',
'date_created',
'is_published',
'category',
)
def post(self, request, *args, **kwargs):
instance = self.get_object()
user = request.user
if user.like_posts.filter(pk=instance.pk):
user.like_posts.remove(instance)
like_status = False
else:
user.like_posts.add(instance)
like_status = True
data = {
'user': UserSerializer(user).data,
'post': PostSerializer(instance).data,
'result': like_status
}
return Response(data)
class PostSerializer(serializers.ModelSerializer):
author = UserSerializer(read_only=True)
photo_list = PostPhotoSerializer(many=True,
read_only=True,
source='postphoto_set')
class Meta:
model = Post
fields = (
'pk',
'author',
'photo_list',
'created_date',
)
read_only_fields = ('created_date', )
def post(self, request, *args, **kwargs):
instance = self.get_object()
user = request.user
# 이미 유저의 like_posts 목록에 현재 post(instance)가 존재할 경우
if instance in user.like_posts.all():
user.like_posts.remove(instance)
like_status = False
else:
user.like_posts.add(instance)
like_status = True
data = {
'user': UserSerializer(user).data,
'post': PostSerializer(instance).data,
'result': like_status,
}
return Response(data)
def post(self, request, *args, **kwargs):
user = request.user
post = self.get_object()
filtered_like_posts = user.like_posts.filter(pk=post.pk)
if filtered_like_posts.exists():
user.like_posts.remove(post)
like_status = False
else:
user.like_posts.add(post)
like_status = True
data = {
'user': UserSerializer(user).data,
'post': PostSerializer(post).data,
'result': like_status,
}
return Response(data)
def post(self, request, format=None):
data = request.data
user = authenticate(username=username, password=password)
if user is not None and user.is_active:
user.ip_address = request.META.get('REMOTE_ADDR')
user.save()
login(request, user)
serializer = UserSerializer(user, context={'request': request})
return Response(serializer.data, status=HTTP_200_OK)
return Response(
{
'msg': '用户名或密码错误',
'code': HTTP_400_BAD_REQUEST,
'result': 'FAIL'
},
status=HTTP_200_OK)
class PostSerializer(serializers.ModelSerializer):
"""
Mission 1. - 2017.03.17
author필드의 값이 pk가 아닌, 하나의 Object(dict)로 나타나도록 수정
http://www.django-rest-framework.org/api-guide/serializers/#dealing-with-nested-objects
1. 관련 테스트코드 작성
post_list, post_create부분
2. 해당 테스트코드가 작동하도록 PostSerializer를 수정 및 UserSerializer작성
3. 테스트 및 postman 작동 확인
Mission 2. - 2017.03.17
Post에 연결된 PostPhoto를 리스트 내부의 Object형태로 리턴
'author': {<author object>},
'postphoto_set': [
{
'pk': <PostPhoto pk>,
'photo': <PostPhoto photo field url>,
},
{
'pk': <PostPhoto pk>,
'photo': <PostPhoto photo field url>,
},
]
1. 관련 테스트코드 작성
post_list, post_create부분
2. 해당 테스트코드가 작동하도록 PostSerializer를 수정 및 PostPhotoSerializer작성
3. 테스트 및 포스트맨 작동 확인
4. postphoto_set의 이름을 photo_list로 변경
http://www.django-rest-framework.org/api-guide/serializers/#specifying-fields-explicitly
"""
author = UserSerializer(read_only=True)
postphoto_set = PostPhotoSerializer(many=True, read_only=True)
class Meta:
model = Post
fields = (
'pk',
'author',
'created_date',
'postphoto_set',
)
read_only_fields = ('created_date', )
def get(self, request, *args, **kwargs):
try:
talent = Talent.objects.get(pk=kwargs['pk'])
talent.view_count += 1
talent.save()
talent_dict = TalentDetailSerializer(talent).data
user = request.user
try:
user_dict = UserSerializer(user).data
talent_dict["user"] = user_dict
except:
talent_dict["user"] = "******"
return Response(talent_dict)
except Talent.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND,
data={"detail": "찾을 수 없습니다."})
class PostSerializer(serializers.ModelSerializer):
author = UserSerializer(read_only=True)
my_comment = CommentSerializer(read_only=True)
class Meta:
model = Post
fields = (
'pk',
'author',
'photo',
'my_comment',
)
read_only_fields = (
'author',
'my_comment',
)
def post(self, request, *args, **kwargs):
print(request.data)
username = request.data['username']
password = request.data['password']
user = authenticate(username=username, password=password)
if user:
token, is_token_created = Token.objects.get_or_create(user=user)
data = {
'token': token.key,
'user': UserSerializer(user).data,
}
return Response(data, status=status.HTTP_200_OK)
else:
data = {
'message': 'Invalid credentials'
}
return Response(data, status=status.HTTP_401_UNAUTHORIZED)
def post(self, request, *args, **kwargs):
username = request.data['username']
password = request.data['password']
# 전달받은 username, password값으로 authenticate실행
user = authenticate(
username=username,
password=password,
)
# user가 존재할 경우 (authenticate성공)
if user:
# 'user'키에 다른 dict로 user에 대한 모든 정보를 보내줌
token, token_created = Token.objects.get_or_create(user=user)
data = {'token': token.key, 'user': UserSerializer(user).data}
return Response(data, status=status.HTTP_200_OK)
# 인증에 실패한 경우
data = {'message': 'Invalid credentials'}
return Response(data)
class PostSerializer(serializers.ModelSerializer):
author = UserSerializer(read_only=True)
group = GroupSerializer(read_only=True)
class Meta:
model = Post
fields = ('pk', 'author', 'group', 'content', 'image', 'video',
'like_count', 'comment_count', 'created_date')
read_only_fields = (
'author',
'group',
'like_count',
'comment_count',
)
def to_representation(self, obj):
ret = super().to_representation(obj)
ret['is_like'] = self.context['request'].user in obj.like_users.all()
return ret
