def listPost():
allRecord = Post.listAllPost()
page = request.args.get('page', 1, type=int)
listPost = Post.numberPostPerPage(page, 10)
return render_template("admin/admin_post_list.html",
listPost=listPost,
allRecord=allRecord)
def post(user):
post = Post()
post.title = "Fast API + GraphQL"
post.body = "this is the post body and can be as long as possible"
user.posts().save(post)
return post
def new_post(self, title, content, date=datetime.datetime.utcnow()):
post = Post(blog_id=self._id,
title=title,
content=content,
author=self.author,
created_date=date)
post.save_to_mongo()
def updatePost():
input = request.form
id = input['id']
post = Post(input['title'], input['content'])
post.updatePost(id)
flash('Update post is successful')
return redirect(url_for('formEditPost', id=id))
def test_posts(self):
# 创建文章
u1 = Post(
dict(
views=100,
title='test post1',
content='test post1 content',
user_id=1,
board_id=1,
))
u2 = Post(
dict(
views=100,
title='test post2',
content='test post2 content',
user_id=1,
board_id=1,
))
db.session.add_all([u1, u2])
db.session.commit()
# 获取文章
response = self.client.get('/post/{}'.format(u1.id))
self.assertEqual(response.status_code, 200)
html_response = response.get_data(as_text=True)
e = pq(html_response)
self.assertEqual(e('#content-md').text(), 'test post1 content')
response = self.client.get('/post/{}'.format(u2.id))
self.assertEqual(response.status_code, 200)
html_response = response.get_data(as_text=True)
e = pq(html_response)
self.assertEqual(e('#content-md').text(), 'test post2 content')
def test_01_post_repr(self):
admin = User.query.get(1)
post = Post(body='Post is editing!',
author=admin,
title='admin\'s post')
post.save()
self.assertTrue('<Post admin\'s post Author Admin>' == post.__repr__())
def post(id_post):
p = Post(id_post)
if not p.e_valido():
abort(404)
elif p.comentario():
return redirect(url_for('post', id_post=p.get_postagem().id_post()))
return render_template("home.html", posts=[p])
def post(self, post_id):
"""
Handles the POST request and updates the blog post
Args:
post_id: the post id from the url
Returns:
A redirect if the validation passed else the form
"""
form = PostForm(request.form)
form.submit.label.text = 'Edit'
if form.validate_on_submit():
post = Post.get_by_id(post_id)
post.update(title=form.title.data,
content=form.post_content.data,
category_id=request.form.get('category'))
flash('Your post has been updated.', 'success')
return redirect(url_for('blog.post', post_id=post.id))
app.logger.info(form.is_submitted() and form.validate())
return render_template('blog/edit.html',
post=Post.get_by_id(post_id),
form=form)
def post(self):
args = post_parser.parse_args()
from app.models.user import User
author = User.query.get_or_404(args.author_id)
post = Post(body=args.body, author=author)
from app import db
db.session.add(post)
db.session.commit()
return jsonify(post.to_json())
def create_post(*, account: Account, title: str, content: str,
skills: list) -> list:
student_account_check(account)
p = Post(student=get_student_account(account),
title=title,
content=content,
published_date=date.today())
p.save()
p.skills.add(*skills)
return list_post(id=account.id)
def test_17_get_followed_posts(self):
user = User.query.first()
self.assertTrue(user.followed_posts.count() == 0)
from app.models.post import Post
post = Post(body='Post is editing!', author=user)
post.save()
self.assertTrue(user.followed_posts.count() == 1)
tester = User.query.get(2)
tester.follow(user)
self.assertTrue(tester.followed_posts.count() == 1)
def add_post(author, title, description, slug):
"""Add New Post"""
p = Post()
p.author = User.objects.get(username=author)
p.title = title
p.slug = p.set_slug(title)
p.description = description
p.category = [Category.objects.get(slug=slug)]
p.save()
print('New Post added.')
def create_post(*, account: Account, content: str) -> list:
user_account_check(account)
p = Post(
user=get_user_account(account),
content=content,
published_date=int(time.time()),
)
p.save()
create_notification(type='post', account=account, post_job_id=p.id)
return p
def index():
if request.method == 'POST':
new_post = Post()
new_post.name = request.json['name']
new_post.price = request.json['price']
new_post.date = datetime.now()
new_post.url = request.json['url']
new_post.description = request.json['description']
new_post.put();
response = JSONEncoder().encode(new_post.getValue())
return response
def add():
form = request.form
u = current_user()
if u is None:
flash('需要进行登陆', 'info')
return redirect(url_for('index.login'))
post = Post(form)
post.user_id = u.id
db.session.add(post)
db.session.commit()
flash('提交成功', 'success')
return redirect(url_for('.detail', id=post.id))
def test_08_tag_save_and_delete(self):
tag = Tag('test')
self.assertTrue(Tag.query.count() == 0)
tag.save()
self.assertEqual(tag.__repr__(), "Tag({id})".format(id=tag.id))
post = Post(tags=[tag])
post.save()
self.assertTrue(Tag.query.count() == 1)
self.assertTrue(tag in post.tags)
tag.delete()
self.assertTrue(Tag.query.count() == 0)
self.assertTrue(len(post.tags) == 0)
def add_event_post(eventId):
user = DB.find_one(collection="Profile",
query={"email": current_user.email})
if user is None:
flash('Please create your profile first!')
return redirect(url_for('edit_profile'))
author_id = user['_id']
timestamp = datetime.now()
post_text = request.form['post_text']
newPost = Post(author_id, timestamp, post_text)
newPostId = newPost.insert()
Event.add_post_by_id(ObjectId(eventId), newPostId)
return redirect(url_for('display_event', id=eventId))
def __post():
post = Post(title=self.text.title(),
summary=text.text(3),
body=text.text(6),
author=user)
category = Category(name=text.word())
category.save()
post.category = category
tag = Tag(name=text.word())
tag.save()
post.tags.append(tag)
post.save()
return post
def new_post():
form = PostForm()
if form.validate_on_submit():
post = Post(author=current_user.id,
title=form.title.data,
body=form.body.data)
post.save()
flash('Post created', 'success')
return redirect(url_for('admin.posts'))
return render_template('admin/form.html',
form=form,
endpoint=url_for('.new_post'))
def post(self):
subject = self.request.get('subject')
content = self.request.get('content')
if subject and content:
post = Post(user=self.user, subject=subject, content=content)
post.put()
self.redirect('/post/%s' % str(post.key().id()))
else:
error = "Subject and content, please!"
self.render("edit_post.html",
subject=subject,
content=content,
error=error)
def new_article():
form = ArticleForm()
if request.method == 'POST' and form.validate():
post_new = Post(
body=request.form['editor-markdown-doc'],
title=form.title.data,
author=current_user,
summary=form.summary.data,
is_draft=form.is_draft.data,
category=Category.query.filter_by(id=form.category.data).first())
tags = [tag.strip() for tag in form.tags.data.split(',')
] if form.tags.data else None
if tags:
for tag in tags:
new_tag = Tag.query.filter_by(content=tag).first()
if not new_tag:
new_tag = Tag(tag)
new_tag.save()
post_new.tag(new_tag)
post_new.ping()
post_new.save()
current_app.logger.info('新文章 %s|%s', post_new.title,
post_new.author.username)
flash('发文成功！')
return redirect(url_for('post.article', post_id=post_new.id))
return render_template('post/editor.html', form=form)
def test_06_category_posts_count(self):
Category.add_none()
none = Category.query.get(1)
category = Category(name='tester',
parent_category=Category.query.get(1))
category.save()
self.assertTrue(none.posts_count() == 0)
post = Post(body='# Post Big title', category=category)
post.save()
self.assertTrue(none.posts_count() == 1)
self.assertTrue(category.posts_count() == 1)
query = Post.query
self.assertTrue(none.posts_count(query) == 1)
self.assertTrue(category.posts_count(query) == 1)
def test_04_category_repr_save_and_delete(self):
self.assertTrue(Category.query.count() == 0)
Category.add_none()
category = Category(name='tester',
parent_category=Category.query.get(1))
category.save()
self.assertTrue(
'<Category tester Parent None Son []>' == category.__repr__())
self.assertTrue(Category.query.count() == 2)
post = Post(body='# Post Big title', category=category)
post.save()
self.assertTrue(category.posts.count() == 1)
category.delete()
self.assertTrue(Category.query.count() == 1)
self.assertTrue(post.category_id == 1)
def new_post():
try:
auth_token = request.json.get('token')
user_id = decode_auth_token(auth_token)
post = Post(text=request.json.get("text"),
user_id=user_id,
created_on=request.json.get("created_on"))
current_app.logger.info('Creating new post')
db.session.add(post)
db.session.commit()
return jsonify(post.to_full_json()), 201
except Exception as e:
current_app.logger.error('new_post' + str(e))
return jsonify({"error": "something went worng"}), 500
def put(self, board_id, post_id):
try:
if not Board.objects(id=board_id, deleted=False).first():
return jsonify(message="존재하지 않는 게시판입니다"), 404
form = PostEditSchema().load(json.loads(request.data))
find_post = Post.objects(id=post_id).first()
find_post.update_post_modified_time()
post = Post(**form)
find_post.update(post)
except ValidationError as err:
return jsonify(err.messages), 422
return jsonify(message='게시판 이름이 변경되었습니다.'), 200
def index():
form = PostForm()
if (form.validate_on_submit()):
body = form.post.data
post = Post(body=body, author=current_user)
db.session.add(post)
db.session.commit()
flash('Your post is now online')
return redirect(url_for('index'))
page = request.args.get('page', 1, type=int)
posts = current_user.get_followed_posts().paginate(
page, app.config["POSTS_PER_PAGE"], False)
if (posts.has_next): next_url = url_for('index', page=posts.next_num)
else: next_url = None
if (posts.has_prev): prev_url = url_for('index', page=posts.prev_num)
else: prev_url = None
return render_template('index.html',
title='Home Page',
posts=posts.items,
form=form,
next_url=next_url,
prev_url=prev_url)
def new_post():
post = Post.from_json(request.json)
post.author = g.current_user
db.session.add(post)
db.session.commit()
return jsonify(post.to_json()), 201, \
{'Location': url_for('api.get_post', id=post.id)}
def recent_posts():
page_index = int(request.args.get('page', "1")) - 1
offset = app.config["PAGENATION_LIMIT"] * page_index
posts, pagenation = Post.get_posts(
limit=app.config["PAGENATION_LIMIT"],
offset=offset,
order_by=PostOrder.update_at_desc,
session=db.session
)
data = {
"posts": list(map(lambda p: p.to_dict(), posts)),
"pagenation": {
k: {
"url": url_for(
'recent_posts',
page=v + 1
),
"index": v + 1
}
for k, v in pagenation.items()
},
}
return render_template(
'posts.j2.html',
data=data
)
def news_from_url(url):
site_url = "http://127.0.0.1:5000"
base_html = cached_url(url)
# 是否有缓存
if base_html[1] is False:
sleep(random() * 10)
e = pq(base_html[0])
p_list = e('article .topicContent p').text()
title = e('.art_tit').text()
time = e('.time_box').text()
content = p_list.replace('。', '。\n')
# 图片的已知几种情况
img_url = e('.vg_insert_img img').attr('src')
if img_url is None:
img_url = e('.vg_short_img_box img').attr('alt')
img_path = download_image(img_url)
if img_path != 'noimage':
content = '\n'.format(site_url + img_path) + p_list.replace(
'。', '。\n')
board_id = Board.query.filter_by(title='games').first()
form = {
'title': title,
'content': content,
'board_id': board_id.id if board_id is not None else 1,
'user_id': 1,
'ct': time,
'image_url': img_path,
}
item = Post(form)
safe_commit(item)
return item
def post():
if request.method == "POST":
try:
title = request.form["title"]
exist_checker = Post.query.filter(Post.title == title).all()
if not exist_checker:
image_path = request.form["image_path"]
description = request.form["description"]
url = request.form["url"]
code = request.form["code"]
if title == "" or image_path == "" or description == "" or url == "" or code == "":
return redirect(url_for("index"))
description = clean_text(description)
post_item = Post(title=title,
image_path=image_path,
description=description,
url=url,
code=code)
db.session.add(post_item)
db.session.commit()
return redirect(url_for("index"))
else:
return redirect(url_for("index"))
except:
return url_for("index")
return redirect(url_for("index"))
def test_herding(self):
Post(title="Pickles").put()
Post(title="Mr. Sparkles").put()
assert Post.query().count() == 2
def api_clear_db(self):
for key in Post.query().fetch(keys_only=True):
key.delete()
return 200
def posts(self, options=None):
return Post.find_all(options, where={'user_id':self.id})
def testQueries(self):
# log in user one
self.loginUser('*****@*****.**')
# create two posts
post1 = Post(title="Post 1")
post1.put()
post2 = Post(title="Post 2")
post2.put()
# log in user two
self.loginUser('*****@*****.**')
# create two more posts
post3 = Post(title="Post 3")
post3.put()
post4 = Post(title="Post 4")
post4.put()
# Get all posts
all_posts = list(Post.all_posts())
# Make sure there are 4 posts in total
assert len(all_posts) == 4
# Make sure they're in the right order
assert all_posts == [post4, post3, post2, post1]
# Make sure we only get two for user2, and that they're the right posts
user2_posts = list(Post.all_posts_by_user())
assert len(user2_posts) == 2
assert user2_posts == [post4, post3]
