def test_blog_post_model_unique_slugs(): user = CustomUser(email="*****@*****.**", username="******") user.save() post1 = BlogPost(author=user, title="Test title!", body="post body") post1.save() post2 = BlogPost(author=user, title="Test title", body="post body") post2.save() assert post1.slug == "test-title" assert post1.slug != post2.slug
def setUpTestData(cls): cls.blog1 = BlogPost( title='I am a title 1!', description='Description 1.', author='*****@*****.**' ) cls.blog1.save() cls.blog2 = BlogPost( title='I am a title 2!', description='Description 2.', author='*****@*****.**' ) cls.blog2.save()
def create_post(): form = BlogPostForm() if (form.validate_on_submit() or request.method == "POST"): post = BlogPost(title=form.title.data, category=form.category.data, text=form.text.data, user_id=current_user.id) db.session.add(post) db.session.commit() followers = Followers.query.filter_by( followed_id=current_user.id).all() for follower in followers: notif = Notifications( follower.follower_id, f'{current_user.username} has posted a blog "{form.title.data}"!', post.id, True) db.session.add(notif) db.session.add(post) db.session.commit() flash('Post Created!') return redirect(url_for('core.index')) if (current_user.is_authenticated): notifs = Notifications.query.filter_by( user_id=current_user.id).order_by(Notifications.date.desc()).all() else: notifs = [] return render_template('create_post.html', form=form, notifs=notifs)
def create(request): if request.method == 'POST': BlogPost( title=request.POST.get('title'), body=request.POST.get('body'), ).save() return HttpResponseRedirect('/blog')
def api_create_blog_view(request): blog_post = BlogPost(author=request.user) if request.method == 'POST': try: if request.user.customer.membership: data = request.data data['author'] = request.user.pk serializer = BlogPostCreateSerializer(data=data) data = {} if serializer.is_valid(): blog_post = serializer.save() data['response'] = CREATE_SUCCESS data['pk'] = blog_post.pk data['title'] = blog_post.title data['body'] = blog_post.body data['slug'] = blog_post.slug data['date_updated'] = blog_post.date_updated image_url = str( request.build_absolute_uri(blog_post.image.url)) if "?" in image_url: image_url = image_url[:image_url.rfind("?")] data['image'] = image_url data['username'] = blog_post.author.username return Response(data=data) except Customer.DoesNotExist: return Response({'response': "RESPONSE_MUST_BECOME_T2R_MEMBER"}) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def test_cannot_create_post_without_body(self): blog_post = BlogPost(title="", date=datetime.datetime.now(), body="", visible=True) with self.assertRaises(ValidationError): blog_post.full_clean()
def test_stripped_answers(self): test_tags = ["a new tag", "a new new tag"] tag_keys = self.tags.add(test_tags) ans1 = Answer(p_answer="ans1", is_correct=True) ans2 = Answer(p_answer="ans2", is_correct=False) category_key = self.categories.add("category") summary = "a summmary" title = "a title" body = "here is a body" post_key = BlogPost(title=title, body=body, category=category_key, tags=tag_keys, summary=summary, answers=[ans1, ans2]).put() post = post_key.get() jsoned_answers = [{ "p_answer": "ans1", "is_correct": False }, { "p_answer": "ans2", "is_correct": False }] self.assertItemsEqual(post.strip_answers_jsoned(), jsoned_answers)
def test_get_view_on_site_url__return_link(self): blog_post = BlogPost(slug='test-blog') url = self.admin.get_view_on_site_url(blog_post) self.assertEqual(url, reverse('blog:post', kwargs={'slug': blog_post.slug}))
def publish(request): if request.user.is_authenticated: if request.user.profile.is_verified == "VF" and request.user.profile.is_email_verified == "VF": if request.method == "POST": title = request.POST.get("title") first_heading = request.POST.get("first_heading") first_content = request.POST.get("first_content") second_heading = request.POST.get("second_heading") second_content = request.POST.get("second_content") sub_heading = request.POST.get("sub_heading") sub_content = request.POST.get("sub_content") publish = BlogPost(title=title, heading1=first_heading, content_heading1=first_content, heading2=second_heading, content_heading2=second_content, sub_heading=sub_heading, sub_heading_content=sub_content, author=request.user.first_name) publish.save() messages.success( request, "Your content has been submitted successfully for review. Your content will be published after successful review." ) return HttpResponseRedirect("/blog/publish") else: return HttpResponseRedirect("/home/notVerified") else: return HttpResponseRedirect("/home/cannot_access") return render(request, "blog/publish.html")
def test_with_data_using_obj(self): category_key = self.categories.add("category") test_tags = ["a new tag", "a new new tag"] new_tag_keys = self.tags.add(test_tags) answer = Answer(p_answer="a test answer", is_correct=False) post = BlogPost(title="a title", body="body text", category=category_key, tags=new_tag_keys, summary="this is a summary", answers=[answer]) post.put() with open(os.path.join(TEST_IMAGE)) as f: self.assertTrue(post.add_blob(f.read(), TEST_IMAGE, 'image/jpeg')) form = PostForm(obj=post) # form.answers.append_entry(answer_field) #print (form.answers) self.assertEqual(form.title.data, "a title") self.assertEqual(form.body.data, "body text") self.assertEqual(form.answers[0].p_answer.data, "a test answer") self.assertEqual(form.images[0].filename.data, TEST_IMAGE)
def create_blog(request): form = ArticleForm(request.POST) if request.method == 'POST': # create a form instance and populate it with data from the request: form = ArticleForm(request.POST, request.FILES) # check whether it's valid: if form.is_valid(): title = form.cleaned_data['title'] lead_paragraph = form.cleaned_data['lead_paragraph'] content = form.cleaned_data['content'] title = request.POST['title'] lead_paragraph = request.POST['lead_paragraph'] image = request.FILES['image'] content = request.POST['content'] #create slug from title-input slug = create_slug_text(title) new_article = BlogPost(title=title, lead_paragraph=lead_paragraph, image=image, slug=slug, meta_title=title, meta_description=lead_paragraph, content=content) new_article.save() # redirect to a blog_post_url: return redirect('blog_thanks') # if a GET (or any other method) we'll create a blank form else: form = ArticleForm() context = { 'form': form } return render(request, "blog/edit/form.html", context)
def setUp(self): # Create author author = User.objects.create_superuser('author', '*****@*****.**', 'authorpassword') # Create user for comment user_comment = User.objects.create_user('comment_user', '*****@*****.**', 'commentpassword') self.test_post = BlogPost(title='test_title', slug='test_title', author=author, category='test_category', content='blog_content', status=1) self.test_post.save() self.blog_image = BlogImage(article_id=self.test_post) self.blog_image.image = SimpleUploadedFile(name='test_image.jpg', content=b'', content_type='image/jpeg') self.blog_image.save() self.test_blogcomment = BlogComment(article_id=self.test_post, user_id=user_comment, comment_title='test_comment_title') self.test_blogcomment.save()
def save(self): try: title = self.validated_data['title'] if len(title) < MIN_TITLE_LENGTH: raise serializers.ValidationError({ "response": "Enter a title longer than " + str(MIN_TITLE_LENGTH) + " characters." }) body = self.validated_data['body'] if len(body) < MIN_BODY_LENGTH: raise serializers.ValidationError({ "response": "Enter a body longer than " + str(MIN_BODY_LENGTH) + " characters." }) blog_post = BlogPost( author=self.validated_data['author'], title=title, body=body, ) blog_post.save() return blog_post except KeyError: raise serializers.ValidationError( {"response": "You must have a title, some content."})
def save(self): try: image = self.validated_data['image'] title = self.validated_data['title'] if len(title) < MIN_TITLE_LENGTH: raise serializers.ValidationError({ "response": "Enter a title longer than " + str(MIN_TITLE_LENGTH) + " characters." }) body = self.validated_data['body'] if len(body) < MIN_BODY_LENGTH: raise serializers.ValidationError({ "response": "Enter a body longer than " + str(MIN_BODY_LENGTH) + " characters." }) blog_post = BlogPost( author=self.validated_data['author'], title=title, body=body, image=image, ) url = os.path.join(settings.TEMP, str(image)) storage = FileSystemStorage(location=url) with storage.open('', 'wb+') as destination: for chunk in image.chunks(): destination.write(chunk) destination.close() # Check image size if not is_image_size_valid(url, IMAGE_SIZE_MAX_BYTES): os.remove(url) raise serializers.ValidationError({ "response": "That image is too large. Images must be less than 2 MB. Try a different image." }) # Check image aspect ratio if not is_image_aspect_ratio_valid(url): os.remove(url) raise serializers.ValidationError({ "response": "Image height must not exceed image width. Try a different image." }) os.remove(url) blog_post.save() return blog_post except KeyError: raise serializers.ValidationError({ "response": "You must have a title, some content, and an image." })
def create_blogpost(request): if request.method == 'POST': BlogPost( title=request.POST.get('title'), body=request.POST.get('body'), timestamp=datetime.now(), ).save() return redirect('/blog/')
def setUp(self): # Create an initial object to test with post = BlogPost(title=u'Hello Wørld', text=u'Hello World, this is dynamicresponse. ÆØÅæøå.') post.save() self.post = post
def api_create_blog_view(request): account = request.user blog_post = BlogPost(author=account) if request.method == 'POST': serializer = BlogPostSerializer(blog_post, 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 create(reqeust): if request.method == 'POST': BlogPost( title=reqeust.POST['title'], body1=reqeust.POST['body'], timestamp=datetime.now(), ).save() return render(reqeust, 'archive.html')
def create_blogpost(request): if request.method == 'POST': BlogPost( title=request.POST.get('title'), author=request.POST.get('author'), body=request.POST.get('body'), timestamp=datetime.now(), ).save() return HttpResponseRedirect('/blog/view')
def heartbeats(request): if not request.user.is_authenticated: return HttpResponseRedirect('/login') if request.method == 'POST': is_search = False if request.POST.has_key('search'): is_search = True words = request.POST['search'] search_title = BlogPost.objects.filter(title__contains=words) search_body = BlogPost.objects.filter(body__contains=words) posts = search_body | search_title posts = list(posts) relation_people = [] for post in posts: b = User.objects.get(username=post.author) a = Profile.objects.get(user=b) relation_people.extend([a]) posts = zip(posts, relation_people) return render(request, 'heartbeats.html', { 'posts': posts, 'is_search': is_search, 'word': words }) if request.POST.has_key('body'): bp = BlogPost() bp.title = request.POST['title'] bp.body = request.POST['body'] bp.author = request.user.username bp.timestamp = datetime.now() bp.save() posts = BlogPost.objects.all() posts = list(posts) relation_people = [] for post in posts: b = User.objects.get(username=post.author) a = Profile.objects.get(user=b) relation_people.extend([a]) posts = zip(posts, relation_people) return render( request, 'heartbeats.html', { 'posts': posts, 'is_search': is_search, 'relation_people': relation_people }) else: posts = BlogPost.objects.all() posts = list(posts) relation_people = [] for post in posts: b = User.objects.get(username=post.author) a = Profile.objects.get(user=b) relation_people.extend([a]) posts = zip(posts, relation_people) return render(request, 'heartbeats.html', { 'posts': posts, 'relation_people': relation_people })
def create_blogpost(request): if request.method == 'POST': BlogPost( title=request.POST.get('title'), body=request.POST.get('body'), timestamp=datetime.now(), ).save() #return HttpResponseRedirect('/blog/') return render_to_response('blog/archive.html', {'post': BlogPost}, RequestContext(request))
def add_post(request): if request.method == 'POST': post = BlogPost(title=request.POST.get('title'), body=request.POST.get('body'), timestamp=datetime.now()) post.save() return django.http.HttpResponseRedirect('/blog/') else: return django.http.HttpResponseForbidden()
def api_post_blog_view(request, slug): account = request.user blog_post = BlogPost(author=account) if request.method == "POST": serializer = BlogPostSerializer(blog_post, data=request.data) data = {} if (serializer.is_valid()): serializer.save() return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.erros, status=status.HTTP_400_BAD_REQUEST)
def api_create_blog_view(request): account = Account.objects.get(pk=1) blogpost=BlogPost(author=account) if request.method == "POST": serializer = BlogPostSerializer(blogpost, data=request.data) 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 test_unique_slug(self): """ two post with identical titles should different slugs """ repeated_title = self.post.title post2 = BlogPost() post2.title = repeated_title post2.writer = self.user2 post2.text = "another random text" post2.save() self.assertNotEqual(self.post.slug, post2.slug)
def test_blog_image(self): user_1 = User(username='******') user_1.save() blog = BlogPost(title='blog_title', category='category', author=user_1) blog.save() blog_image = BlogImage(article_id=blog) blog_image.image = SimpleUploadedFile(name='test_image.jpg', content=b'', content_type='image/jpeg') self.assertEqual(str(blog_image), 'test_image.jpg, blog_title, category')
def setUp(self): # Headers for GET requests self.extra_headers = {'HTTP_ACCEPT': 'application/json'} # Create an initial object to test with post = BlogPost(title=u'Hello Wørld', text=u'Hello World, this is dynamicresponse. ÆØÅæøå.') post.save() self.post = post
def api_blog_create_view(request): account = Account.objects.get(pk=1)#query about a random user print(account) blog_post = BlogPost(author=account)#pass the author to BlogPost since it is a required field if request.method =='POST': serializer = BlogPostSerializer(blog_post,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 seed_blog_posts(self): self.stdout.write('Seed Blog posts...\n') BlogPost.objects.all().delete() date = self.fake.date_between(start_date='-30y', end_date='today') for i in range(4): post = BlogPost(author=self.get_random_user(), poster=None, subject=self.fake_fa.sentence(), content=self.fake_fa.text(), published_at=date, updated_at=date) post.save()
def test_save_and_retrieve_blog_posts(self): self.assertEqual(BlogPost.objects.all().count(), 0) blog_post = BlogPost() blog_post.title = "A post" blog_post.date = datetime.datetime(1939, 9, 1, 5, 0, 0) blog_post.body = "Blah blah blah" blog_post.visible = False blog_post.save() self.assertEqual(BlogPost.objects.all().count(), 1) retrieved_post = BlogPost.objects.first() self.assertEqual(retrieved_post, blog_post)