def delete(self, request):
user = self.request.user
data = self.request.data
try:
comment = Comment.objects.select_related('author', 'post').filter(pk=data['comment_id']).get()
if comment.author == user:
if comment.children().count() is not 0:
comment.is_deleted = True
comment.content = "삭제된 댓글입니다."
comment.save()
return Response({"detail": "success"}, status=status.HTTP_200_OK)
comment.delete()
return Response({"detail": "deleted"}, status=status.HTTP_204_NO_CONTENT)
return Response(
{
"code": 402,
"message": kr_error_code(402)
}
, status=status.HTTP_402_PAYMENT_REQUIRED)
except ObjectDoesNotExist:
return Response(
{
"code": 500,
"message": kr_error_code(500)
}
, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def post(self, request, *args, **kwargs):
user = self.request.user
size = self.request.data['margin']
cover_file_obj = self.base64_content(self.request.data['img'], size)
resizing_image = image_quality_down(cover_file_obj)
try:
profile_image = ProfileImage.objects.select_related('user').filter(
user=user).get()
profile_image.cover_image = resizing_image
profile_image.save()
serializer = ProfileImageSerializer(profile_image)
if serializer:
return Response({"fileUpload": serializer.data},
status=status.HTTP_201_CREATED)
return Response({
"code": 413,
"message": kr_error_code(413)
},
status=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE)
except ObjectDoesNotExist:
serializer = ProfileImageSerializer(
ProfileImage.objects.create(user=user,
cover_image=cover_file_obj))
if serializer:
return Response({"fileUpload": serializer.data},
status=status.HTTP_201_CREATED)
return Response({
"code": 413,
"message": kr_error_code(413)
},
status=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE)
def put(self, request):
user = self.request.user
data = self.request.data
try:
comment = Comment.objects.select_related('author', 'post').filter(pk=data['comment_id']).get()
if comment.author == user:
if not comment.is_deleted:
comment.content = data['content']
comment.save()
return Response({"detail": "success"}, status=status.HTTP_200_OK)
return Response(
{
"code": 423,
"message": kr_error_code(423)
}
, status=status.HTTP_423_LOCKED)
return Response(
{
"code": 402,
"message": kr_error_code(402)
}
, status=status.HTTP_402_PAYMENT_REQUIRED)
except ObjectDoesNotExist:
return Response(
{
"code": 500,
"message": kr_error_code(500)
}
, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def post(self, request, *args, **kwargs):
user = self.request.user
file_obj = self.request.FILES['files[]']
resizing_image = image_quality_down(file_obj)
temp_file = TempFile.objects.create(author=user, file=resizing_image)
# 예외처리
if not temp_file:
return Response(
{
"code": 410,
"message": kr_error_code(410)
}
, status=status.HTTP_410_GONE)
serializer = TempFileSerializer(temp_file)
if serializer:
return Response(
{
"files":
{
"id": serializer.data['id'],
"file": {
"url": serializer.data['file']
}
}
}
, status=status.HTTP_201_CREATED)
return Response(
{
"code": 410,
"message": kr_error_code(410)
}
, status=status.HTTP_410_GONE)
def list(self, request, *args, **kwargs):
post_pk = self.kwargs.get('post_pk')
comment_id = self.kwargs.get('comment_id')
if comment_id is None:
try:
post = Post.objects.select_related('author').filter(pk=post_pk).get()
queryset = Comment.objects.select_related('author', 'post').filter(post=post, parent__isnull=True).order_by('-created_date').all()
page = self.paginate_queryset(queryset)
serializer = CommentSerializer(page, context={'request': request}, many=True)
if page is not None:
serializer = CommentSerializer(page, context={'request': request}, many=True)
return self.get_paginated_response(serializer.data)
return Response(serializer.data)
except ObjectDoesNotExist:
return Response(
{
"code": 409,
"message": kr_error_code(409)
}
, status=status.HTTP_409_CONFLICT)
else:
try:
post = Post.objects.filter(pk=post_pk).get()
try:
parent = Comment.objects.select_related('parent').filter(pk=comment_id).get()
queryset = Comment.objects.select_related('post','parent').filter(post=post, parent=parent).order_by('-created_date').all()
page = self.paginate_queryset(queryset)
serializer = CommentSerializer(page, context={'request': request}, many=True)
if page is not None:
serializer = CommentSerializer(page, context={'request': request}, many=True)
return self.get_paginated_response(serializer.data)
return Response(serializer.data)
except ObjectDoesNotExist:
return Response(
{
"code": 423,
"message": kr_error_code(423)
}
, status=status.HTTP_423_LOCKED)
except ObjectDoesNotExist:
return Response(
{
"code": 409,
"message": kr_error_code(409)
}
, status=status.HTTP_409_CONFLICT)
def post(self, request):
data = self.request.data
user = self.request.user
if not self.request.user.is_authenticated:
return Response({
"code": 401,
"message": kr_error_code(401)
},
status=status.HTTP_401_UNAUTHORIZED)
post_queryset = Post.objects.select_related('author').filter(
id=data['post_id']).get()
# 포인트가 적을시에 오류 발생
if post_queryset.price > user.point:
return Response({
"code": 414,
"message": kr_error_code(414)
},
status=status.HTTP_414_REQUEST_URI_TOO_LONG)
# 구매한 기록이 있는지를 확인
if self.buylist_duplicate(post_queryset):
# 구매내역에 추가
PointHistory.objects.buy(user=user,
point=post_queryset.price,
history=post_queryset.title,
post=post_queryset)
buy_list = BuyList.objects.create(user=user, post=post_queryset)
sell_list = SellList.objects.create(user=user, post=post_queryset)
if buy_list and sell_list:
post_queryset.buy_count += 1
user = post_queryset.author
user.point += post_queryset.price
post_queryset.save()
user.save()
else:
return Response({
"code": 414,
"message": kr_error_code(414)
},
status=status.HTTP_414_REQUEST_URI_TOO_LONG)
# 구매횟수 증가 업데이트
return Response({"detail": "Success buy."},
status=status.HTTP_200_OK)
return Response({
"code": 416,
"message": kr_error_code(416)
},
status=status.HTTP_416_REQUESTED_RANGE_NOT_SATISFIABLE)
def post(self, request):
user = self.request.user
data = self.request.data
if self.request.data.get('temp_id') is None:
raise exceptions.ValidationError({"detail": "Abnormal Connected"}, 406)
if data['temp_id'] is not '':
Temp.objects.filter(author=self.request.user, id=data['temp_id']).update(title=data['title'],
main_content=data['main_content'],
created_date=datetime.now()
)
return Response({"temp": {
"temp_id": data['temp_id']
}}, status=status.HTTP_200_OK)
else:
# 임시 저장 할 수있는 게시물 제한
if not self.check_post_count(user):
return Response(
{
"code": 417,
"message": kr_error_code(417)
}
, status=status.HTTP_417_EXPECTATION_FAILED)
temp = self.queryset.create(author=user, title=data['title'], main_content=data['main_content'])
# 예외처리
if not temp:
return Response(
{
"code": 500,
"message": kr_error_code(500)
}
, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
serializer = self.get_serializer(temp)
if serializer:
return Response({"temp": {
"temp_id": serializer.data['id'],
}}, status=status.HTTP_201_CREATED)
return Response(
{
"code": 500,
"message": kr_error_code(500)
}
, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def list(self, request, *args, **kwargs):
try:
data = request.GET
if len(data['keyword']) < 2:
return Response({
"code": 426,
"message": kr_error_code(426)
},
status=status.HTTP_400_BAD_REQUEST)
post_list = Post.objects.select_related('author').filter(
Q(title__icontains=data['keyword'])
| Q(author__nickname__icontains=data['keyword'])
| Q(tags__tags__icontains=data['keyword'])).distinct(
).order_by('-created_date')
# all_post = sorted(chain(post_list, tag_list), key=attrgetter('created_date'), reverse=True)
page = self.paginate_queryset(post_list)
serializer = PostMoreSerializer(
page, context={'user': self.request.user}, many=True)
if page is not None:
serializer = PostMoreSerializer(
page, context={'user': self.request.user}, many=True)
return self.get_paginated_response(serializer.data)
return Response(serializer.data)
except ObjectDoesNotExist:
return Response('', 200)
def post(self, request, *args, **kwargs):
user = self.request.user
data = self.request.data
# api = BootpayApi("5ab88457b6d49c1aaa550daa", "ja0mQQI+zwpS2YlCqoJuqBXsfPcVfzUlSDLRMigalDg=")
#
# text = api.confirm(data['receipt_id']).text
# json_data = json.loads(text)
#
# if json_data['data']['status'] is 1:
# if json_data['data']['method'] is 'card':
# PayList.objects.card(user=user, price=json_data['data']['price'], content=json_data['data']['price'])
# return Response({1}, status=status.HTTP_200_OK)
# elif json_data['data']['method'] is 'phone':
# PayList.objects.phone(user=user, price=json_data['data']['price'], content=json_data['data']['price'])
# return Response({1}, status=status.HTTP_200_OK)
# return Response({2}, status=status.HTTP_200_OK)
#
# elif json_data['data']['status'] is 0 or 2 or 3:
# return Response({3}, status=status.HTTP_200_OK)
pay = PayList.objects.create(user=user,
price=data['price'],
content=data['price'],
payment_type=None,
order_num=data['receipt_id'])
user.point += int(data['price'])
user.save()
if pay:
return Response({"detail": user.point}, status=status.HTTP_200_OK)
return Response({
"code": 425,
"message": kr_error_code(425)
},
status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
member_id = self.request.data['pk']
decode_pk = int(decode(enc=str(member_id)))
member = User.objects.filter(pk=decode_pk).get()
user = self.request.user
if user == member:
try:
profile = Profile.objects.select_related('user').filter(
user=user).get()
serializer = ProfileSubSerializer(
profile, context={'user': self.request.user})
if serializer:
return Response(serializer.data, status=status.HTTP_200_OK)
return Response({
"code": 500,
"message": kr_error_code(500)
},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
except ObjectDoesNotExist:
return Response({
"username": user.username,
"intro": "-",
},
status=status.HTTP_200_OK)
else:
try:
profile = Profile.objects.select_related('user').filter(
user=member).get()
serializer = ProfileSubSerializer(
profile, context={'user': self.request.user})
if serializer:
return Response(serializer.data, status=status.HTTP_200_OK)
return Response({
"code": 500,
"message": kr_error_code(500)
},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
except ObjectDoesNotExist:
return Response({
"username": member.username,
"intro": "-",
},
status=status.HTTP_200_OK)
def post_exist(self, post_id):
post = Post.objects.prefetch_related('tags', 'recommend').select_related('author').filter(pk=post_id).get()
if not post:
return Response(
{
"code": 409,
"message": kr_error_code(409)
}
, status=status.HTTP_409_CONFLICT)
return post
def delete(self, request):
user = self.request.user
data = self.request.data
# request.data 에 temp_id 없을시 에러 발생
if self.request.data.get('temp_id') is None:
return Response(
{
"code": 500,
"message": kr_error_code(500)
}
, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
if data['temp_id'] is '':
return Response(
{
"code": 409,
"message": kr_error_code(409)
}
, status=status.HTTP_409_CONFLICT)
return self.queryset.filter(author=user).delete(id=data['temp_id'])
def base64_content(self, image, size):
if image is not '':
format, imgstr = image.split(';base64,')
ext = format.split('/')[-1]
data = ContentFile(base64.b64decode(imgstr), name=size + '.' + ext)
return data
return Response({
"code": 412,
"message": kr_error_code(412)
},
status=status.HTTP_412_PRECONDITION_FAILED)
def get(self, request, *args, **kwargs):
param = self.kwargs.get('post_pk')
if param == '':
return Response(
{
"code": 422,
"message": kr_error_code(422)
}
, status=status.HTTP_422_UNPROCESSABLE_ENTITY)
return self.list(request)
def base64_content(self, image):
if image is not '':
format, imgstr = image.split(';base64,')
ext = format.split('/')[-1]
data = ContentFile(base64.b64decode(imgstr), name='temp.' + ext)
return data
return Response(
{
"code": 410,
"message": kr_error_code(410)
}
, status=status.HTTP_410_GONE)
def get(self, request, *args, **kwargs):
param = self.kwargs.get('pk')
post = Post.objects.filter(pk=param).get()
serializer = PostSerializer(post)
if serializer:
return Response(serializer.data['preview_image'], status=status.HTTP_200_OK)
return Response(
{
"code": 500,
"message": kr_error_code(500)
}
, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def search_tag(self, post, tag):
search_tag = tag.split('|~%')
if len(search_tag) > 5:
return Response(
{
"code": 413,
"message": kr_error_code(413)
}
, status=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE)
for i in search_tag:
tags = PreTag.objects.create(tags=i)
post.tags.add(tags)
return True
def post(self, request, *args, **kwargs):
username = request.data['username']
password = request.data['password']
user = authenticate(
username=username,
password=password,
)
if user:
data = {
'token': jwt_token_generator(user),
'user': UserSerializer(user).data,
}
if data['user']['is_active']:
response = Response(data, status=status.HTTP_200_OK)
# response = render_to_response("view/main.html", {"login": True})
# response = HttpResponseRedirect(redirect_to='/')
if api_settings.JWT_AUTH_COOKIE:
response.set_cookie(api_settings.JWT_AUTH_COOKIE,
data['token'],
max_age=21600,
httponly=True)
self.saved_login_log(user)
return response
# return response
return response
return Response({
"code": 406,
"content": kr_error_code(406)
},
status=status.HTTP_406_NOT_ACCEPTABLE)
# return HttpResponseRedirect(redirect_to='/signin/')
return Response({
"code": 401,
"content": kr_error_code(401)
},
status=status.HTTP_401_UNAUTHORIZED)
def recommend_text(self, post, recommend):
recommend_tag = recommend.split('|~%')
if len(recommend_tag) > 3:
return Response(
{
"code": 413,
"message": kr_error_code(413)
}
, status=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE)
for i in recommend_tag:
tags = PreRecommend.objects.create(text=i)
post.recommend.add(tags)
return True
def get(self, request, *args, **kwargs):
param = self.kwargs.get('pk')
user = self.request.user
if param:
try:
temp = Temp.objects.filter(author=user, pk=param).get()
serializer = TempSerializer(temp)
if serializer:
return Response(serializer.data, status=status.HTTP_200_OK)
return Response(
{
"code": 500,
"message": kr_error_code(500)
}
, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
except ObjectDoesNotExist:
return Response(
{
"code": 415,
"message": kr_error_code(415)
}
, status=status.HTTP_415_UNSUPPORTED_MEDIA_TYPE)
else:
try:
temp = Temp.objects.filter(author=user).order_by('-created_date')[:1].get()
serializer = TempSerializer(temp)
if serializer:
return Response(serializer.data, status=status.HTTP_200_OK)
return Response(
{
"code": 500,
"message": kr_error_code(500)
}
, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
except ObjectDoesNotExist:
return Response('', 200)
def get(self, request, *args, **kwargs):
user_pk = self.kwargs.get('user_pk')
user = self.request.user
decode_pk = int(decode(enc=str(user_pk)))
try:
to_user = User.objects.filter(pk=decode_pk).get()
serializer = FollowStatusSerializer(to_user,
context={'request': request})
if serializer:
return Response(serializer.data, status=status.HTTP_200_OK)
return Response({
"code": 500,
"message": kr_error_code(500)
},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
except ObjectDoesNotExist:
return Response({
"code": 500,
"message": kr_error_code(500)
},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def get(self, request, *args, **kwargs):
user = self.request.user
param = self.kwargs.get('comment_pk')
try:
comment_instance = Comment.objects.filter(pk=param).get()
result = Comment.like_toggle(user=user, comment=comment_instance)
if result:
return Response({'detail': 'created'})
return Response({'created': 'deleted'})
except ObjectDoesNotExist:
return Response(
{
"code": 500,
"message": kr_error_code(500)
}
, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def post(self, request):
user = self.request.user
try:
temp = Temp.objects.select_related('author').filter(
author=user).order_by('-created_date').all()
serializer = MyTempSerializer(temp, many=True)
if serializer:
return Response({"post": serializer.data},
status=status.HTTP_200_OK)
return Response({
"code": 500,
"message": kr_error_code(500)
},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
except ObjectDoesNotExist:
return None
def get(self, request, *args, **kwargs):
post_pk = self.kwargs.get('post_pk')
user = self.request.user
try:
post = Post.objects.filter(pk=post_pk).get()
result, relation = Bookmark.objects.get_or_create(user=user,
post=post)
if relation:
return Response({'detail': 'created'})
result.delete()
return Response({'created': 'deleted'})
except ObjectDoesNotExist:
return Response({
"code": 500,
"message": kr_error_code(500)
},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def get(self, request, *args, **kwargs):
user = self.request.user
user_pk = self.kwargs.get('user_pk')
try:
from_user = User.objects.filter(pk=user_pk).get()
result, result_created = WaitingRelation.objects.get_or_create(
receive_user=from_user, send_user=user)
if result_created:
return Response({'detail': 'created'})
result.delete()
return Response({'created': 'deleted'})
except ObjectDoesNotExist:
return Response({
"code": 500,
"message": kr_error_code(500)
},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def list(self, request, *args, **kwargs):
user = self.request.user
try:
# point = PointHistory.objects.select_related('user').filter(user=user).all()
point = user.pointhistory_set.all().order_by('-created_at')
page = self.paginate_queryset(point)
serializer = PointHistorySerializer(page, many=True)
if page is not None:
serializer = PointHistorySerializer(page, many=True)
return self.get_paginated_response(serializer.data)
return Response(serializer.data)
except ObjectDoesNotExist:
return Response(
{
"code": 409,
"message": kr_error_code(409)
}
, status=status.HTTP_409_CONFLICT)
def post(self, request):
user = self.request.user
serializer = UserSerializer(user)
if user.is_authenticated:
try:
profile_image = ProfileImage.objects.select_related(
'user').filter(user=user).get()
profile_serializer = ProfileImageSerializer(profile_image)
if serializer:
return Response(
{
"user": serializer.data,
"profileImg": profile_serializer.data
},
status=status.HTTP_200_OK)
return Response({"detail": "NO User"})
except ObjectDoesNotExist:
return Response(
{
"user": serializer.data,
"profileImg": {
"profile_image":
'https://bycal.azureedge.net/media/example/2_x20_.jpeg',
"cover_image":
'https://bycal.azureedge.net/media/example/1.jpeg'
}
},
status=status.HTTP_200_OK)
else:
response = Response({
"code": 402,
"message": kr_error_code(402)
},
status=status.HTTP_402_PAYMENT_REQUIRED)
response.delete_cookie('sessionid')
response.delete_cookie('token')
return response
def post(self, request):
user = self.request.user
data = self.request.data
try:
profile = Profile.objects.select_related('user').filter(
user=user).get()
profile.intro = data['intro']
profile.birthday = data['birthday']
profile.sex = data['sex']
profile.phone = data['hpNumber']
profile.web = data['web']
profile.jobs = data['jobs']
profile.facebook = data['fb']
profile.instagram = data['ins']
profile.twitter = data['tw']
profile.subjects = data['subject']
profile.save()
return Response('', status=status.HTTP_200_OK)
except ObjectDoesNotExist:
if Profile.objects.create(user=user,
birthday=data['birthday'],
sex=data['sex'],
phone=data['hpNumber'],
age=data['age'],
jobs=data['jobs'],
facebook=data['fb'],
instagram=data['ins'],
twitter=data['tw'],
subjects=data['subject'],
web=data['web'],
intro=data['intro']):
return Response(status=status.HTTP_200_OK)
return Response({
"code": 500,
"message": kr_error_code(500)
},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def post(self, request):
user = self.request.user
try:
post = Post.objects.filter(
author=user).order_by('created_date').all()
serializer = MyPublishPostSerializer(post, many=True)
if serializer:
return Response(
{
"join_date": user.created_at,
"post": serializer.data
},
status=status.HTTP_200_OK)
return Response({
"code": 500,
"message": kr_error_code(500)
},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
except ObjectDoesNotExist:
return None
def post(self, request):
data = self.request.data
post_id = data['post_id']
content = data['content']
try:
parent = self.parent(data['comment_id'])
post = Post.objects.select_related('author').filter(pk=post_id).get()
user = self.request.user
parent_comment = Comment.objects.select_related('author', 'post').filter(pk=parent, post=post).get()
comment = Comment.objects.create(author=user, content=content, post=post)
if comment:
self.comment_notify(parent_comment.author, comment)
if comment.is_parent:
comment.parent = parent_comment
comment.save()
return Response({"detail": comment.pk}, status=status.HTTP_201_CREATED)
return Response(
{
"code": 422,
"message": kr_error_code(422)
}
, status=status.HTTP_422_UNPROCESSABLE_ENTITY)
else:
return Response({"detail": "Already added."}, status=status.HTTP_200_OK)
except ObjectDoesNotExist:
post = Post.objects.filter(pk=post_id).get()
user = self.request.user
comment = Comment.objects.create(author=user, content=content, post=post, parent=None)
if comment:
self.comment_notify(post.author, comment)
return Response({"detail": comment.pk}, status=status.HTTP_201_CREATED)
else:
return Response({"detail": "Already added."}, status=status.HTTP_200_OK)
