def create(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
if serializer.is_valid():
self.perform_create(serializer)
return success(data=serializer.data)
key = list(serializer.errors.keys())[0]
return error(key + ': ' + serializer.errors[key][0])
def retrieve(self, request, *args, **kwargs):
instance = self.get_object()
if instance:
ApiCli.process_answer(instance, request.user)
serializer = self.get_serializer(instance)
return success(serializer.data)
return error('没有找到该回答')
def readed(self, request, pk=None):
message = self.get_object()
if message is None:
return error('no message found')
message.has_read = True
message.save()
return success()
def get_answers(self, request, pk=None):
topic = self.get_object()
if topic is None:
return error("no such a topic")
questions = topic.questions.all()
answers = []
for question in questions:
answer = question.answers.first()
if answer is not None:
answers.append(answer)
page = self.paginate_queryset(answers)
if page is not None:
for instance in page:
user = request.user
if user.is_authenticated:
instance.has_approve = user.profile.agreed.filter(
id=instance.id).exists()
instance.has_against = user.profile.disagreed.filter(
id=instance.id).exists()
instance.has_favorite = user.profile.favorites.filter(
id=instance.id).exists()
else:
instance.has_approve = False
instance.has_against = False
instance.has_favorite = False
instance.userSummary = instance.author.profile
instance.comment_count = instance.comments.count()
serializer = self.get_serializer(page, many=True)
temp = self.get_paginated_response(serializer.data)
return success(temp.data)
return error('no more data')
def cancel_favorite(self, request, pk=None):
profile = request.user.profile
answer = self.get_object()
if answer is None:
return error('没有找到你想取消收藏的回答')
profile.favorites.remove(answer)
profile.save()
return success()
def messages(self, request):
queryset = self.get_queryset()
page = self.paginate_queryset(queryset)
if page is not None:
serializer = self.get_serializer(page, many=True)
temp = self.get_paginated_response(serializer.data)
return success(temp.data)
return error('no more message')
def cancel_disagree(self, request, pk=None):
profile = request.user.profile
answer = self.get_object()
if answer is None:
return error('没有找到你想取消踩的回答')
answer.against -= 1
answer.save()
profile.disagreed.remove(answer)
profile.save()
return success()
def avatar(self, request):
seri = self.get_serializer(data=request.data)
if seri.is_valid():
avatar = seri.validated_data['file']
profile = request.user.profile
profile.avatar = avatar
profile.save()
return success()
key = list(seri.errors.keys())[0]
return error(key + ': ' + seri.errors[key][0])
def cancel_watch(self, request, pk=None):
if request.user.is_authenticated is False:
return error('please login')
question = self.get_object()
if question is None:
return error('question not exists')
profile = request.user.profile
profile.watchedQuestion.remove(question)
profile.save()
return success()
def update_info(self, request, *args, **kwargs):
profile = request.user.profile
if profile is None:
return error("no profile found")
data = request.data
seri = self.get_serializer(profile, data=data, partial=True)
if seri.is_valid():
seri.save()
return success()
key = list(seri.errors.keys())[0]
return error(key + ': ' + seri.errors[key])
def list(self, request, *args, **kwargs):
queryset = self.filter_queryset(self.get_queryset())
page = self.paginate_queryset(queryset)
if page is not None:
for instance in page:
ApiCli.process_answer(instance, request.user)
serializer = self.get_serializer(page, many=True)
temp = self.get_paginated_response(serializer.data)
return success(temp.data)
return error('no more data')
def reset_password(self, request, *args, **kwargs):
seri = self.get_serializer(data=request.data)
if not seri.is_valid():
return error()
user = request.user
data = seri.validated_data
if user.check_password(data['old']):
user.set_password(data['new'])
user.save()
return success()
return error()
def retrieve(self, request, *args, **kwargs):
profile = self.get_object()
if profile:
if request.user.is_authenticated:
count = request.user.profile \
.watchedUser.filter(profile=profile)
profile.is_watch = count
else:
profile.is_watch = False
seri = self.get_serializer(profile, context={'request': request})
return success(seri.data)
return error("no profile found")
def cancel_watch(self, request, pk=None):
user = self.get_object()
if user is None:
return error('user not exists')
profile = request.user.profile
profile.watchedUser.remove(user)
profile.watchCount -= 1
profile.save()
user.profile.beWatchCount -= 1
user.profile.save()
return success()
def watch(self, request, pk=None):
if request.user.is_authenticated is False:
return error('please login')
question = self.get_object()
if question is None:
return error('question not exists')
profile = request.user.profile
Activity.watchQuestion(request.user.profile, question)
profile.watchedQuestion.add(question)
profile.save()
return success()
def register(self, request, *args, **kwargs):
data = request.data
seri = self.get_serializer(data=data)
if not seri.is_valid():
key = list(seri.errors.keys())[0]
return error(key + ': ' + seri.errors[key][0])
seri.save()
username = seri.validated_data['username']
user = User.objects.get(username=username)
auth.login(request, user)
profile = user.profile
seri = ProfileSerializer(profile, context={'request': request})
return success(seri.data)
def watch(self, request, pk=None):
user = self.get_object()
if user is None:
return error('user not exists')
profile = request.user.profile
profile.watchedUser.add(user)
profile.watchCount += 1
profile.save()
user.profile.beWatchCount += 1
user.profile.save()
if request.user.is_authenticated:
Activity.watchUser(request.user.profile, user.profile)
return success()
def agree(self, request, pk=None):
profile = request.user.profile
answer = self.get_object()
if answer is None:
return error('没有找到你想赞的回答')
if profile.agreed.filter(id=answer.id).exists():
return error('你已经赞过了')
answer.approve += 1
answer.save()
profile.agreed.add(answer)
profile.save()
if request.user.is_authenticated:
Activity.agreeAnswer(request.user.profile, answer)
return success()
def questions(self, request, pk=None):
profile = self.get_object()
if profile is None:
return error('no profile found')
questions = profile.user.published.all()
page = self.paginate_queryset(questions)
if page is not None:
for question in page:
ApiCli.process_question(question)
serializer = QuestionListSerializer(page,
many=True,
context={'request': request})
temp = self.get_paginated_response(serializer.data)
return success(temp.data)
return error('no more data')
def favorites(self, request, pk=None):
profile = self.get_object()
if profile is None:
return error('no profile found')
answers = profile.favorites.all()
page = self.paginate_queryset(answers)
if page is not None:
for answer in page:
ApiCli.process_answer(answer, request.user)
serializer = AnswerSerializer(page,
many=True,
context={'request': request})
temp = self.get_paginated_response(serializer.data)
return success(temp.data)
return error('no more data')
def get_comments(self, request, pk=None):
answer = self.get_object()
if answer is None:
return error("没有找到该评论所在的回答")
queryset = self.filter_queryset(answer.comments.all())
page = self.paginate_queryset(queryset)
if page is not None:
for comment in page:
ApiCli.process_comment(comment)
serializer = self.get_serializer(page, many=True)
temp = self.get_paginated_response(serializer.data)
return success(temp.data)
return error('没有更多了')
def login(self, request):
data = request.data
seri = self.get_serializer(data=data)
if seri.is_valid():
username = seri.validated_data['username']
password = seri.validated_data['password']
user = auth.authenticate(username=username, password=password)
if user:
auth.login(request, user)
profile = user.profile
seri = ProfileSerializer(profile, context={'request': request})
return success(seri.data)
return error('username or password not correct')
key = list(seri.errors.keys())[0]
return error(key + ': ' + seri.errors[key][0])
def create(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
if serializer.is_valid():
question = serializer.validated_data['question']
if question.answers.filter(author=request.user).exists():
return error('你已经回答过该问题了')
answer = self.perform_create(serializer)
answer.userSummary = request.user.profile
answer.has_favorite = False
answer.has_approve = False
answer.has_against = False
answer.comment_count = answer.comments.count()
seri = AnswerSerializer(answer, context={'request': request})
return success(seri.data)
key = list(serializer.errors.keys())[0]
return error(key + ': ' + serializer.errors[key][0])
def get_questions(self, request, pk=None):
topic = self.get_object()
if topic is None:
return error("no topic found")
queryset = self.filter_queryset(topic.questions.all())
page = self.paginate_queryset(queryset)
if page is not None:
for question in page:
question.answer_count = question.answers.count()
question.watch_count = question.watchedUser.count()
serializer = self.get_serializer(page, many=True)
temp = self.get_paginated_response(serializer.data)
return success(temp.data)
return error('no more data')
def be_watched(self, request, pk=None):
profile = self.get_object()
if profile is None:
return error('no profile found')
profiles = profile.user.watchedBy.all()
page = self.paginate_queryset(profiles)
if page is not None:
for profile in page:
profile.is_watch = request.user.profile \
.watchedUser.filter(profile=profile).exists()
serializer = ProfileSerializer(page,
many=True,
context={'request': request})
temp = self.get_paginated_response(serializer.data)
return success(temp.data)
return error('no more data')
def watched_users(self, request, pk=None):
profile = self.get_object()
if profile is None:
return error('no profile found')
users = profile.watchedUser.all()
profiles = []
for user in users:
ApiCli.process_profile(request.user, user)
profiles.append(user.profile)
page = self.paginate_queryset(profiles)
if page is not None:
serializer = ProfileSerializer(page,
many=True,
context={'request': request})
temp = self.get_paginated_response(serializer.data)
return success(temp.data)
return error('no more data')
def get_answers(self, request, pk):
question = self.get_object()
if question is None:
return error("no topic found")
if request.user.is_authenticated:
profile = request.user.profile
profile.history.add(question)
profile.save()
queryset = self.filter_queryset(question.answers.all())
page = self.paginate_queryset(queryset)
if page is not None:
for answer in page:
ApiCli.process_answer(answer, request.user)
serializer = self.get_serializer(page, many=True)
temp = self.get_paginated_response(serializer.data)
return success(temp.data)
return error('no more data')
def retrieve(self, request, *args, **kwargs):
question = self.get_object()
if question is None:
return error('no question found')
if request.user.is_authenticated:
count = request.user.profile \
.watchedQuestion\
.filter(title=question).count()
question.is_watch = count
else:
question.is_watch = False
ApiCli.process_question(question)
seri = self.get_serializer(question)
question.visit_count += 1
question.save()
for topic in question.topics.all():
HeatQueue.put_visited(topic)
return success(seri.data)
def activities(self, request, pk=None):
profile = self.get_object()
if profile is None:
return error('no such profile')
activities = profile.activities.all()
page = self.paginate_queryset(activities)
if page is not None:
for activity in page:
if activity.watch:
user = request.user
ApiCli.process_profile(user, activity.watch.user)
elif activity.question:
ApiCli.process_question(activity.question)
elif activity.answer:
profile = activity.answer.author.profile
instance = activity.answer
user = request.user
ApiCli.process_answer(instance, user)
serializer = self.get_serializer(page, many=True)
temp = self.get_paginated_response(serializer.data)
return success(temp.data)
return error('no more data')
def get(self, request):
#request.query_params['']
q = Auth(settings.access_key, settings.secret_key)
file_name = str(time())
token = q.upload_token(settings.bucket_name, file_name, 3600)
return success({'token': token, 'name': file_name})
