class MessageSerializer(serializers.ModelSerializer):
from_user = UserSerializer(read_only=True)
def to_representation(self, instance):
ret = super().to_representation(instance)
profile = Profile.objects.get(pk=ret['from_user']['pk'])
image = profile.images.first()
if image:
ret['from_user']['image'] = image.profile_thumbnail.url
else:
ret['from_user']['image'] = None
return ret
def create(self, validated_data):
chat = self.context['chat']
from_user = self.context['from_user']
message = chat.add_message(from_user=from_user,
body=validated_data['body'])
return message
class Meta:
model = Message
fields = (
'from_user',
'body',
'created_at',
)
read_only_fields = ('created_at', )
class EventUserSerializer(serializers.ModelSerializer):
"""
EventUserSerializer
"""
#event = EventSerializer(read_only=True)
answer = EventAnswerSerializer(read_only=True)
user = UserSerializer(read_only=True)
class Meta:
model = EventUser
fields = ('id', 'user', 'answer', 'comment')
class PostSerializer(serializers.ModelSerializer):
author = UserSerializer()
class Meta:
model = Post
fields = (
'pk',
'author',
'photo',
'created_at',
)
def post(self, request):
# request.data에
# access_token
# facebook_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
user_id: str
# token(access_token)을 받아 해당 토큰을 Debug
def get_debug_token_info(token):
app_id = settings.FACEBOOK_APP_ID
app_secret_code = settings.FACEBOOK_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)
print(response)
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('페이스북 토큰이 유효하지 않음')
# 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
return Response(UserSerializer(user).data)
class PostSerializer(serializers.ModelSerializer):
author = UserSerializer(read_only=True)
class Meta:
model = Post
fields = (
'pk',
'author',
'photo',
'content',
'liked',
'created_date',
)
def post(self, request, *args, **kwargs):
if request.method == 'POST':
username = request.data.get('username')
password = request.data.get('password')
user = authenticate(username=username, password=password)
if user:
token, token_created = Token.objects.get_or_create(user=user)
serializer = UserSerializer(user)
data = {"token": token.key, "user": serializer.data},
else:
data = {"error": "user is not authenticated"}
return Response(data, status=status.HTTP_200_OK)
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',
)
def post(self, request, *args, **kwargs):
instance = self.get_object()
user = request.user
if instance in 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)
def post(self, request, *args, **kwargs):
instance = self.get_object()
user = request.user
if user in instance.participants.filter(pk=user.pk):
instance.participants.remove(user)
participate_status = False
else:
instance.participants.add(user)
participate_status = True
data = {
'participant': UserSerializer(user).data,
'event': EventParticipateSerializer(instance).data,
'result': participate_status,
}
return Response(data, status=status.HTTP_200_OK)
class EventSerializer(serializers.ModelSerializer):
author = UserSerializer(read_only=True)
event_date = serializers.DateTimeField(format='%Y-%m-%d %H:%M')
closing_date = serializers.DateTimeField(format='%Y-%m-%d %H:%M')
opening_date = serializers.DateTimeField(format='%Y-%m-%d %H:%M')
wish_status = serializers.SerializerMethodField()
participants_counter = serializers.SerializerMethodField(
'_participants_counter')
class Meta:
model = Event
fields = '__all__'
def get_wish_status(self, obj, **kwargs):
user_pk = self.context.get("user_pk")
if obj.wish_event.filter(pk=user_pk).exists():
return True
return False
def _participants_counter(self, obj):
return obj.participants_counter()
class EventSerializer(serializers.ModelSerializer):
"""
EventSerializer
"""
owner = UserSerializer(read_only=True)
answers = serializers.SerializerMethodField()
users = serializers.SerializerMethodField()
"""
def create(self, validated_data):
answers = validated_data.pop('answers')
event = Event.objects.create(**validated_data)
for answer in answers:
Answer.objects.create(event=event, **answer)
return event
"""
class Meta:
model = Event
fields = ('id', 'date', 'place', 'subject', 'detail', 'owner',
'answers', 'users')
def get_answers(self, obj):
try:
answers = EventAnswerSerializer(
EventAnswer.objects.filter(event=Event.objects.get(id=obj.id)),
many=True).data
return answers
except:
return None
def get_users(self, obj):
try:
users = EventUserFlattenSerializer(
EventUser.objects.filter(event=Event.objects.get(id=obj.id)),
many=True).data
return users
except:
return None
def get_target_user(self, obj):
if self.context['user'] == obj.chat.start_user:
target_user = obj.chat.target_user
else:
target_user = obj.chat.start_user
return UserSerializer(target_user).data