def articles_action_view(request, *args, **kwargs):
msg = {}
serializer = ArticleActionSerializer(data=request.data)
if serializer.is_valid(raise_exception=True):
data = serializer.validated_data
article_id = data.get('id')
action = data.get('action')
content = data.get('content') if data.get('content') else ""
qs = Article.objects.filter(id=article_id)
if not qs.exists():
return Response({}, status=404)
obj = qs.first()
if action == "unlike":
obj.likes.remove(request.user)
serializer = ArticleSerializer(obj)
return Response(serializer.data, status=200)
elif action == "like":
obj.likes.add(request.user)
serializer = ArticleSerializer(obj)
return Response(serializer.data, status=200)
elif action == "retweet":
new_tweet = Article.objects.create(user=request.user,
parent=obj,
content=content)
serializer = ArticleSerializer(new_tweet)
return Response(serializer.data, status=200)
# TODO 转发
msg = action + " success"
return Response({'msg': msg}, status=200)
def articles_list_view(request, *args, **kwargs):
title = request.GET.get("title")
if title is not None:
articles = Article.objects.filter(title__icontains=f"{title}") # Article.objects.filter(title=f"{title}")
serializer = ArticleSerializer(articles, many=True)
paginator = Paginator(serializer.data, 10)
page_number = request.GET.get('page')
page_obj = paginator.get_page(page_number)
context = {
"title": title,
"pagination": True,
"articles": page_obj,
"description": "list of articles on this website"
}
return render(request, 'articles.html', context)
else:
articles = Article.objects.all()
serializer = ArticleSerializer(articles, many=True)
paginator = Paginator(serializer.data, 10)
page_number = request.GET.get('page')
page_obj = paginator.get_page(page_number)
context = {
"pagination": True,
'articles': page_obj, # "articles": serializer.data,
"description": "list of articles on this website",
}
return render(request, 'articles.html', context)
def put(self, request, pk):
article = self.get_object(pk)
serializer = ArticleSerializer(article, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=400)
def list(self, request, *args, **kwargs):
queryset = self.filter_queryset(self.get_queryset())
page = self.paginate_queryset(queryset)
if page is not None:
serializer = ArticleSerializer(page, many=True)
return self.get_paginated_response(serializer.data)
serializer = ArticleSerializer(queryset, many=True)
return Response(serializer.data)
def post(self, request):
article = request.data.get('article')
# Create an article from the above data
serializer = ArticleSerializer(data=article)
if serializer.is_valid(raise_exception=True):
article_saved = serializer.save()
return Response({
"success":
"Article '{}' created successfully".format(article_saved.title)
})
def post_list(request,format=None):
if request.method == 'GET':
posts = Article.objects.all()
serializer = ArticleSerializer(posts,many=True)
return Response(serializer.data)
elif request.method == 'POST':
serializer = ArticleSerializer(data=request.DATA)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors,status=status.HTTP_400_BAD_REQUEST)
def articles_create_view(request, *args, **kwargs):
serializer = ArticleCreateSerializer(data=request.POST)
if serializer.is_valid(raise_exception=True):
serializer.save(user=request.user)
aid = serializer.data.get('id')
serializer = ArticleSerializer(Article.objects.get(pk=aid))
return Response(serializer.data, status=201)
def test_get_relation_article_user_rating(self):
""" Тестирование проставления рейтинга """
self.client.force_login(self.user_3)
url = reverse('articlerelation-detail', args=(self.article_2.id,))
data = {
'rating': 4
}
data_json = json.dumps(data)
response = self.client.patch(url, data=data_json, content_type="application/json")
relation = ArticleRelation.objects.get(user=self.user_3, article=self.article_2)
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertEqual(4, relation.rating)
""" Тестирование проставления рейтинга, для тестирования среднего рейтинга """
self.client.force_login(self.user_2)
data = {
'rating': 5
}
data_json = json.dumps(data)
response = self.client.patch(url, data=data_json, content_type="application/json")
relation = ArticleRelation.objects.get(user=self.user_2, article=self.article_2)
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertEqual(5, relation.rating)
""" Тестирование среднего рейтинга """
url = reverse('article-detail', args=(self.article_2.id,))
response = self.client.get(url)
article = Article.objects.filter(id__in=[self.article_2.id, ]).annotate(
count_like_annotate=Count(Case(When(articlerelation__like=True, then=1))))
data_article = ArticleSerializer(article[0]).data
self.assertEqual(data_article, response.data)
self.assertEqual('4.50', response.data['rating'])
self.assertEqual('4.50', data_article['rating'])
def article_list(request):
"""
List all snippets, or create a new article.
"""
if request.method == 'GET':
articles = Article.objects.all()
serializer = ArticleSerializer(articles, many=True)
return Response(serializer.data)
elif request.method == 'POST':
serializer = ArticleSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def createArticle(request):
user = request.user
if user.is_anonymous:
return Response('Anonymous user is not allowed', status=status.HTTP_400_BAD_REQUEST)
data = request.data
interests = list(data['interest'])
for interest in interests:
articleData = data
articleData['interest'] = interest
serializer = ArticleSerializer(data=articleData)
if serializer.is_valid():
article = serializer.save()
article.tags.add(*data['articleTags'])
else:
return Response(data=serializer.errors, status=status.HTTP_400_BAD_REQUEST)
return Response(status=200)
def post_detail(request,pk,format=None):
try:
post = Article.objects.get(pk=pk)
except Post.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
serializer = ArticleSerializer(post)
return Response(serializer.data)
elif request.method == 'PUT':
serializer = ArticleSerializer(post,data=request.DATA)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
post.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
def article_detail(request, pk):
"""
Retrieve, update or delete a code snippet.
"""
try:
article = Article.objects.get(pk=pk)
except Article.DoesNotExist:
return HttpResponse(status=404)
if request.method == 'GET':
serializer = ArticleSerializer(article)
return JSONResponse(serializer.data)
elif request.method == 'PUT':
data = JSONParser().parse(request)
print(data)
serializer = ArticleSerializer(article, data=data)
if serializer.is_valid():
serializer.save()
return JSONResponse(serializer.data)
return JSONResponse(serializer.errors, status=400)
elif request.method == 'DELETE':
article.delete()
return HttpResponse(status=204)
def get(self, request, page, *args, **kwargs):
'''GET request'''
# pagination https://docs.djangoproject.com/en/2.2/topics/pagination/
articles = Article.objects.all()
paginator = Paginator(articles, 10) # How many articles per page
articles_page = paginator.get_page(page)
serializer = ArticleSerializer(articles_page, many=True)
return Response({"articles": serializer.data})
def test_filter(self):
""" Тест фильтрации """
url = reverse('article-list')
response = self.client.get(url, data={'owner__username': self.user_2.username})
articles = Article.objects.filter(id__in=[self.article_2.id, self.article_3.id]).annotate(
count_like_annotate=Count(Case(When(articlerelation__like=True, then=1)))).order_by('id')
serializer = ArticleSerializer(articles, many=True)
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertEqual(serializer.data, response.data)
def getArticleById(request, pk):
user = request.user
if user.is_anonymous:
return Response('Anonymous user is not allowed', status=status.HTTP_400_BAD_REQUEST)
article = Article.objects.filter(pk=pk)
if article.count() == 0:
return Response('Article does not exist', status=status.HTTP_404_NOT_FOUND)
article = article[0]
return Response(data=ArticleSerializer(article).data, status=status.HTTP_200_OK)
def get(self, request, pk):
article = self.get_object(pk)
if is_anon(request):
serializer = AnonArticleSerializer(article).data
else:
serializer = ArticleSerializer(article).data
return Response(serializer)
def get(self, request, format=None):
search = request.query_params.get('search', None)
if search:
snippets = Article.objects.filter(
Q(title__icontains=search) | Q(author__username=search))
else:
snippets = Article.objects.all()
serializer = ArticleSerializer(snippets, many=True)
return Response(serializer.data)
def get(self, request, post_id, *args, **kwargs):
'''GET request'''
post = Article.objects.filter(id=post_id)
if post:
post = post[0]
else:
raise Http404("Статья с этим номером не найдена")
serializer = ArticleSerializer(post)
return Response({"articles": serializer.data})
def retrieve(self, request, pk=None):
if request.user.is_superuser:
tag = Tag.objects.filter(tag_id=pk)
articleset = set()
for t in tag:
articleset = set(
chain(articleset,
TagSerializer(t).data["articles"]))
articles = ArticleSerializer(
Article.objects.filter(article_id__in=articleset),
many=True).data
return Response(ArticleSerializer(articles, many=True).data)
else:
res = {
'error':
'can not authenticate with the given credentials or the account has been deactivated'
}
return Response(res, status=status.HTTP_403_FORBIDDEN)
def articles_list_view(request, *args, **kwargs):
queryset = Article.objects.all()
paginate = ArticlePagination()
uid = request.GET.get('uid')
search = request.GET.get('search')
if uid is not None:
queryset2 = queryset.filter(user__id=uid)
page_obj = paginate.paginate_queryset(queryset2, request)
serializer = ArticleSerializer(page_obj, many=True)
return paginate.get_paginated_response(serializer.data)
if search is not None:
queryset2 = queryset.filter(
Q(user__username__icontains=search) | Q(content__icontains=search))
page_obj = paginate.paginate_queryset(queryset2, request)
serializer = ArticleSerializer(page_obj, many=True)
return paginate.get_paginated_response(serializer.data)
page_obj = paginate.paginate_queryset(queryset, request)
serializer = ArticleSerializer(page_obj, many=True)
return paginate.get_paginated_response(serializer.data)
def article_details_view(request, id=None, *args, **kwargs):
article = get_object_or_404(Article.objects.all(), pk=id)
article_ser = ArticleSerializer(article)
author = get_object_or_404(Author.objects.all(), pk=article.author.pk)
author_ser = AuthorSerializer(author)
context = {
"article": article_ser.data,
"author": author_ser.data
}
return render(request, 'article_details.html', context)
def post(self, request):
if request.user.is_authenticated:
serializer = ArticleSerializer(data=request.data)
if serializer.is_valid():
serializer = ArticleSerializer(data=request.data)
if serializer.is_valid():
serializer.save(writer=request.user)
return JsonResponse(serializer.data,
status=status.HTTP_201_CREATED)
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
return Response(status=status.HTTP_401_UNAUTHORIZED)
def to_representation(self, value):
"""
Serialize bookmark instances using a bookmark serializer,
and note instances using a note serializer.
"""
if isinstance(value, Article):
serializer = ArticleSerializer(value)
else:
raise Exception('Unexpected type of object')
return serializer.data
def get(self, request, *args, **kwargs):
preferenceset =UserPreferencesSerializer(request.user).data["preferences"]
preferences = Preferences.objects.filter(preference_id__in=preferenceset)
tagset = set()
for preference in preferences:
tagset = set(chain(tagset,PreferencesMappingSerializer(preference).data["tags"]))
tags = Tag.objects.filter(tag_id__in=tagset)
articleset = set()
for tag in tags:
articleset = set(chain(articleset,TagSerializer(tag).data["articles"]))
articles = ArticleSerializer(Article.objects.filter(article_id__in= articleset),many=True).data
return Response(articles, status=status.HTTP_200_OK)
def get(self, request, pk, format=None):
article = get_object_or_404(Article, id=pk)
md = markdown.Markdown(extensions=[
'markdown.extensions.extra',
#'markdown.extensions.codehilite',
'markdown.extensions.toc',
])
article.body = md.convert(article.body)
article.body = mark_safe(article.body)
serializer = ArticleSerializer(article, context={'request': request})
context = {'article': serializer.data, 'toc': md.toc}
return Response(context)
def get(self, request):
category = request.query_params.get('category')
if category:
articles = Article.objects.filter(category=category)
else:
articles = Article.objects.all()
if is_anon(request):
serializer = AnonArticleSerializer(articles, many=True).data
else:
serializer = ArticleSerializer(articles, many=True).data
return Response(serializer)
def getArticlesByInterest(request, pk):
limit = request.GET.get('limit', 0)
limit = int(limit)
page = request.GET.get('page', 0)
page = int(page)
user = request.user
if user.is_anonymous:
return Response('Anonymous user is not allowed', status=status.HTTP_400_BAD_REQUEST)
if limit > 0:
articles = Article.objects.filter(interest=pk).order_by('-createdDate')[page:page+limit]
else:
articles = Article.objects.filter(interest=pk).order_by('-createdDate').all()
return Response(data=ArticleSerializer(articles, many = True).data, status=status.HTTP_200_OK)
def post(self, request):
serializer = ArticleSerializer(data=request.data)
if serializer.is_valid() and serializer.check_author_id(request.data):
serializer.save(author=Author.objects.get(
id=request.data["author"]))
return Response(serializer.data)
return Response(serializer.errors, status=400)
def article_detail(request, pk):
"""
Retrieve, update or delete a snippet instance.
"""
try:
article1 = Article.objects.get(pk=pk)
except Article.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
serializer = ArticleSerializer(article1)
return Response(serializer.data)
elif request.method == 'PUT':
serializer = ArticleSerializer(article1, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
article1.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
def search(self, request):
"""
搜索文章，按照标题， 类型， 内容搜索
:param request:
:return:
"""
s = request.data.get('s')
category = request.data.get('category')
q = Q(title__contains=s)
q |= Q(author__username__contains=s)
# q |= Q(category)
article_set = Article.objects.filter(q)
serializer = ArticleSerializer(article_set, many=True)
return JsonResponse(data=serializer.data)
def article_list(request, format=None):
"""List all articles or create a new article"""
if request.method == 'GET':
articles = Article.objects.all()
serializer = ArticleSerializer(articles, many=True)
return Response(serializer.data)
elif request.method == 'POST':
serializer = ArticleSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Reponse(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def test_get(self):
""" Тест получения объекта """
url = reverse('article-detail', args=(self.article_1.id,))
response = self.client.get(url)
article = Article.objects.filter(id__in=[self.article_1.id]).annotate(
count_like_annotate=Count(Case(When(articlerelation__like=True, then=1))))
serializer = ArticleSerializer(article[0])
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertEqual(serializer.data, response.data)
url = reverse('category-detail', args={self.category_1.id})
response = self.client.get(url)
serializer = CategorySerializer(self.category_1)
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertEqual(serializer.data, response.data)
def test_search(self):
""" Тест поиска """
url = reverse('article-list')
response = self.client.get(url, data={'search': 'article-2'})
articles = Article.objects.filter(id__in=[self.article_2.id, ]).annotate(
count_like_annotate=Count(Case(When(articlerelation__like=True, then=1)))).order_by('id')
serializer = ArticleSerializer(articles, many=True)
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertEqual(serializer.data, response.data)
url = reverse('category-list')
response = self.client.get(url, data={'search': 'category-2'})
serializer = CategorySerializer([self.category_2], many=True)
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertEqual(serializer.data, response.data)
def test_ordering(self):
""" Тест сортировки """
url = reverse('article-list')
response = self.client.get(url, data={'ordering': 'title'})
articles = Article.objects.all().annotate(
count_like_annotate=Count(Case(When(articlerelation__like=True, then=1)))).order_by('title')
serializer = ArticleSerializer(articles, many=True)
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertEqual(serializer.data, response.data)
url = reverse('category-list')
response = self.client.get(url, data={'ordering': '-title'})
serializer = CategorySerializer([self.category_3, self.category_2, self.category_1], many=True)
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertEqual(serializer.data, response.data)
