def __set_post_and_comment_data(self):
_user = self.users[4]
data = {
'user': _user,
'title': '_title',
'text': '_text',
'is_public': True,
'description': '_description',
'keywords': '_post_keyword',
}
post = models.Post()
for key, value in data.items():
setattr(post, key, value)
post.save()
text = 'comment'
data = {
'name': 'comment_user',
'text': text,
'target': post,
}
comment = models.Comment()
for key, value in data.items():
setattr(comment, key, value)
comment.save()
return comment
def form_valid(self, form):
title = form.cleaned_data['title']
text = form.cleaned_data['text']
author = self.request.user
redirect_url = self.request.POST.get('redirect_url', default='/')
models.Post(text=text, title=title, author=author).save()
return redirect(redirect_url)
def setUp(self):
""" Test Setup """
self.browser = Browser("phantomjs")
self.browser.driver.set_window_size(1440, 900) # set browser size.
# set up the tables in the database
Base.metadata.create_all(engine)
# create 2 example users
self.user = models.User(name="Alice",
email="*****@*****.**",
password=generate_password_hash("test"))
session.add(self.user)
session.commit()
self.user2 = models.User(name="Ryan",
email="*****@*****.**",
password=generate_password_hash("test"))
session.add(self.user2)
session.commit()
# Create some sample posts
content = "Acceptance testing content"
for i in range(5):
post = models.Post(title="Acceptance test post #{}".format(i + 1),
content=content,
author=self.user)
session.add(post)
session.commit()
""" gives the ability to start and run other code simultaneously with your own scripts """
self.process = multiprocessing.Process(target=app.run)
self.process.start()
# pause for 1 second
time.sleep(1)
def nodeToPost(n):
'''
Given a Node, this function will return a list of all public posts for that node
'''
posts = []
authentication = {"Authorization": n.authentication}
url = n.service + "/posts"
json_resp = requests.get(url, headers=authentication).json()['posts']
for p in json_resp:
try:
# Only requests posts that come from same the host as the node
if urlparse(n.service).netloc == urlparse(p['source']).netloc:
post_user = auth.models.User(
username=p['author']['displayName'] + " (" +
n.user.username + ")")
post_author = models.Author(id=removeTrailingFS(
p['author']['id']),
user=post_user)
post_date = dateutil.parser.parse(p['published']).date()
posts.append(
models.Post(id=removeTrailingFS(p['source']),
date=post_date,
title=p['title'],
content=p['content'],
author=post_author,
content_type=p['contentType']))
else:
continue
except KeyError:
continue
return posts
def test_edit_post(self):
self.simulate_login()
test_post = models.Post(title="Test Post",
content="Test Content",
author_id=self.user.id)
session.add(test_post)
session.commit()
response = self.client.post("/post/edit/1",
data={
"title": "Edit Post",
"content": "Edit content"
})
self.assertEqual(response.status_code, 302)
self.assertEqual(urlparse(response.location).path, "/")
posts = session.query(models.Post).all()
self.assertEqual(len(posts), 1)
post = posts[0]
self.assertEqual(post.title, "Edit Post")
# self.assertEqual(post.content, "<p>Edit content</p>\n")
self.assertEqual(post.content, "Edit content")
self.assertEqual(post.author, self.user)
def get_object(self):
obj = models.Post()
obj.id = 0
obj.title_text = f'test {self.kwargs["author_name"]}/{self.kwargs["template_name"]}'
obj.template_text = self.kwargs['template_name']
obj.created_date = timezone.now()
return obj
def writeBlog(request):
if request.method == 'POST':
title = request.POST.get('title')
content = request.POST.get('content')
author = request.user.get_full_name()
username = request.user.get_username()
slug = request.POST.get('title').replace(" ", "-")
display_image = request.POST.get('display_image')
if len(content.split()) < 50:
print(content.split())
messages.success(request,
"Your recipe must contain atleast 50 world")
return redirect('writeBlog')
post = models.Post(title=title,
content=content,
author=author,
slug=slug,
display_image=display_image,
username=username)
post.save()
messages.success(
request,
'Thank you for adding your recipe,Your recipe has published successfully.'
)
return render(request, 'home/writeBlog.html')
def share_post(request):
if request.method == 'POST':
user = request.user
post_id = request.POST.get('post_id')
user_exist = models.User.objects.filter(username=user).count()
post_exist = models.Post.objects.filter(pk=post_id).count()
if user_exist > 0 and post_exist > 0:
post_ = models.Post.objects.get(pk=post_id)
user_ = models.User.objects.get(username=user)
post_.post_shares.add(user_)
new_shared_post = models.Post(author=user_, post_content=post_.post_content)
new_shared_post.save()
data_set = dict(user=user_.username,
shared_post={
"post_id": post_.id,
"author": post_.author.username,
"post_content": post_.post_content},
new_post={
"post_id": new_shared_post.id
})
json_response = json.dumps(data_set)
return HttpResponse(json_response)
else:
json_response = json.dumps(dict(detail="User or Post does not exist."))
return HttpResponseNotFound(json_response)
else:
json_response = json.dumps(dict(detail="Bad request."))
return HttpResponseBadRequest(json_response)
def handle(self, *args, **options):
for i in range(10):
p = models.Post(
title=silly.sentence(),
content=silly.markdown(length=5),
)
p.save()
def savePost(request):
id = request.POST.get('id')
title = request.POST.get('title')
content = request.POST.get('content')
summary = request.POST.get('summary')
categories = request.POST.get('category')
tags = request.POST.get('tag')
# 自动从文章正文中查找图片，将第一张图片作为文章的Banner图
banner = None
temp = re.finditer(r'<img\s+.*?\s*src="(?P<url>.*?)".*?>', content)
for match in temp:
url = match.group('url')
print(url)
if re.match('http|https', url) is not None:
localUrl = downloadImage(url)
content = str.replace(content, url, localUrl)
if banner is None:
banner = localUrl
else:
if banner is None:
banner = url
try:
if id is None or id == '':
post = models.Post()
post.Title = title
post.Content = content
post.CreateTime = datetime.datetime.now()
post.CanComment = True
post.Banner = "" if (banner is None) else banner
post.Summary = summary
post.User = request.user
post.save()
post.Categories.set(json.loads(categories))
post.Tags.set(json.loads(tags))
else:
post = models.Post.objects.get(Id=id)
post.Title = title
post.Content = content
post.CanComment = True
post.Banner = "" if (banner is None) else banner
post.Summary = summary
post.save()
post.Categories.set(json.loads(categories))
post.Tags.set(json.loads(tags))
return HttpResponse(json.dumps({'result': True}))
except Exception as err:
return HttpResponse(json.dumps({'result': False, 'err': '保存数据时发生异常！Err:{0}'.format(err)}))
def generate_userpost(user):
post = models.Post()
post.title = fake.sentence(nb_words=5)
post.content = fake.text(max_nb_chars=240)
post.date = fake.date_time()
# Add this post to the user posts
user.posts.append(post)
# commit database
return post
def set_up_reference_posts(self):
tag1 = models.Tag(name="Winemaking")
tag2 = models.Tag(name="Embedded")
tag1.save()
tag2.save()
date1 = datetime.now(tz=timezone.utc)
delta = timedelta(days=1)
date2 = date1 - delta
post1 = models.Post(title='Test Post about Wine',
body="""I'm not an alcoholic""",
pub_date=date1)
post1.save()
post1.tags.add(tag1.pk)
post1.save()
post2 = models.Post(title='Test Post about embedded control',
body="""I sure do love reading manuals""",
pub_date=date2)
post2.save()
post2.tags.add(tag2.pk)
post2.save()
def home():
form = forms.PostForm()
page = request.args.get('page', 1, type=int)
posts = models.Post.query.order_by(models.Post.date.desc()).paginate(
page=page, per_page=5)
if form.validate_on_submit():
post = models.Post(title=form.title.data,
content=form.content.data,
author=current_user)
db.session.add(post)
db.session.commit()
flash('The Post has been publish', 'success')
return redirect(url_for('home'))
return render_template('index.html', posts=posts, form=form)
def test_delete_post(self):
test_post = models.Post(title="Test Post",
content="Test Content",
author_id=self.user.id)
session.add(test_post)
session.commit()
post_id = test_post.id
self.simulate_login()
response = self.client.post("/post/delete/{}".format(post_id))
""" self.assertEqual(response.status_code, 302) AssertionError: 405 != 302 """
self.assertEqual(response.status_code, 302)
self.assertEqual(urlparse(response.location).path, "/")
posts = session.query(models.Post).all()
self.assertEqual(len(posts), 0)
def __set_post_data(self):
_user = self.users[3]
data = {
'user': _user,
'title': '_title',
'text': '_text',
'is_public': True,
'description': '_description',
'keywords': '_post_keyword',
}
post = models.Post()
for key, value in data.items():
setattr(post, key, value)
post.save()
return post
def post_post(request):
if request.method == 'POST':
user = request.user
post_content = request.POST.get('post_content')
user_exist = models.User.objects.filter(username=user).count()
if user_exist > 0:
user_ = models.User.objects.get(username=user)
new_post = models.Post(author=user_, post_content=post_content)
new_post.save()
data_set = dict(
post_id=new_post.id,
author=new_post.author.username,
post_content=new_post.post_content)
json_response = json.dumps(data_set)
return HttpResponse(json_response)
else:
json_response = json.dumps(dict(detail="User does not exist."))
return HttpResponseNotFound(json_response)
else:
json_response = json.dumps(dict(detail="Bad request."))
return HttpResponseBadRequest(json_response)
def newpost():
if not flask_login.current_user.is_authenticated:
flask.flash("You need to be logged in to post something.")
return flask.redirect(flask.url_for('login'))
postform = forms.NewPostForm()
if postform.validate_on_submit():
print("Debug")
title = postform.title.data
content = postform.content.data
post = models.Post(title=title, content=content)
current_user = flask_login.current_user
user_id = current_user.id
post_handler = models.PostHandler(post, user_id)
post_handler.add_to_db()
flask.flash("Your post for the blog has been added!")
return flask.redirect(flask.url_for('homepage'))
return flask.render_template("newpost.html", postform=postform)
def viewextpost(request, post_id):
'''
This function will renders the view post page for remote posts
TODO: Don't think images are working properly. Should check this and fix if it doesn't work
'''
try:
authentication = users.models.Node.URItoAuth(unquote(post_id))
p = requests.get(unquote(post_id), headers=authentication)
if p.status_code == 404:
raise Exception("Page Not Found")
p = p.json()
except Exception as e:
print(e)
# If we can't request the post, return a does not exist
post_user = auth.models.User(username="")
post_author = models.Author(id=" ", user=post_user)
post = models.Post(id=unquote(post_id),
date="",
title="Post Does Not Exist",
content="",
author=post_author,
content_type="text/plain")
return render(request, "blog/viewpost.html", {
"post": post,
"edit": False,
"content": "",
"image": ""
})
# Depending on interpretation of spec
# Accounts for is a single posts is paginated
if "posts" in p:
p = p["posts"][0]
elif "post" in p:
p = p["post"]
post_user = auth.models.User(username=p['author']['displayName'])
post_author = models.Author(id=p['author']['id'], user=post_user)
post_date = date_format_converter(p['published'])
post = models.Post(id=p['source'],
date=post_date,
title=p['title'],
content=p['content'],
author=post_author,
content_type=p['contentType'])
image_path = ''
content = ''
if post.content_type == "text/markdown":
content = commonmark.commonmark(post.content)
elif post.content_type == "text/plain":
content = post.content
else:
if post.image != None:
image = post.image.__str__()
image_path = polarbear.settings.MEDIA_URL + image
is_local = False
return render(
request, "blog/viewpost.html", {
"post": post,
"edit": False,
"content": content,
"image": image_path,
"is_local": is_local
})
