def import_blog_post():
click.echo("Importing BlogPost...", nl=False)
with open("./data/blogposts.json") as data_file:
blogposts = json.load(data_file)
for i, bp in enumerate(blogposts, start=1):
blogpost = BlogPost(
id=i,
title=bp["title"],
author=[get(Author, slug=bp["author"])],
date=parser.parse(bp["date"]),
added=parser.parse(bp["added"]),
slug=bp["slug"],
excerpt=bp["excerpt"],
)
try:
blogpost.series = get(BlogSeries, slug=bp["series"])
blogpost.series_index = bp["series_index"]
except KeyError:
pass
db.session.add(blogpost)
for lang in bp["translations"]:
translators = bp["translations"][lang]
dbtranslator = []
for translator in translators:
dbtranslator += [get(Translator, name=translator)]
blog_translation = BlogPostTranslation(
language=get(Language, ietf=lang),
translators=dbtranslator,
)
blogpost.translations.append(blog_translation)
db.session.add(blogpost)
db.session.commit()
click.echo(DONE)
class TestpostClass(unittest.TestCase):
'''
Test to test the post class/Table in db
'''
def setUp(self):
'''
To set up before each test case
'''
self.new_post = BlogPost(title = 'My post',content = 'I love this game')
def tearDown(self):
'''
Function to clear up after every test case
'''
BlogPost.query.delete()
def test_init(self):
'''
Test if variables are correctly initialzed
'''
self.assertEqual(self.new_post.title, 'My post')
self.assertEqual(self.new_post.content, 'I love this game')
def test_save_post(self):
'''
Test saving to test db
'''
self.new_post.save_post()
self.assertTrue(len(post.query.all())>0)
def delete(post_id):
object_id = ObjectId(post_id)
if BlogPost.objects(id=object_id).count() == 1:
post = BlogPost.objects().with_id(object_id)
post.delete()
else:
flash('Invalid event id')
pass
return redirect(url_for('.index'))
def delete(post_id):
object_id = ObjectId(post_id)
if BlogPost.objects(id=object_id).count() == 1:
post = BlogPost.objects().with_id(object_id)
post.delete()
else:
flash('Invalid event id')
# print "Invalid event id"
pass
return redirect(url_for('.index'))
def post(slug):
if BlogPost.objects(slug=slug).count() != 1:
abort(404)
post = BlogPost.objects().get(slug=slug)
recent_posts = BlogPost.objects(published=True,
id__ne=post.id,
featured_image__ne=None).order_by('-date_published')[:3]
if not post.published:
abort(404)
return render_template('blog/post.html',
post=post,
recent_posts=recent_posts)
def post(slug):
if BlogPost.objects(slug=slug).count() != 1:
abort(404)
post = BlogPost.objects().get(slug=slug)
recent_posts = BlogPost.objects(
published=True, id__ne=post.id,
featured_image__ne=None).order_by('-date_published')[:3]
if not post.published:
abort(404)
return render_template('blog/post.html',
post=post,
recent_posts=recent_posts)
def new():
"""Create a new blog post.
**Route:** ``/admin/posts/new``
**Methods:** ``POST``
"""
form = CreateBlogPostForm(request.form)
form.author.choices = [
(str(u.id), u.name + " (You)" if u == g.user else u.name)
for u in User.objects()]
form.author.data = str(g.user.id)
upload_form = UploadImageForm()
if form.validate_on_submit():
author = User.objects().get(id=ObjectId(form.author.data))
post = BlogPost(title=form.title.data,
slug=form.slug.data,
images=[Image.objects().get(filename=fn) for fn in form.images.data],
markdown_content=form.body.data,
author=author,
posted_by=g.user, tags=form.tags.data)
post.save()
if form.published.data:
post.publish()
else:
post.unpublish()
return redirect(url_for('.index'))
images = Image.objects()
return render_template('admin/posts/edit.html', user=g.user, form=form,
images=images, upload_form=upload_form)
def delete(post_id):
"""Delete an existing blog post.
**Route:** ``/admin/posts/delete/<post_id>``
**Methods:** ``POST``
:param str post_id: The ID of the post to edit.
"""
object_id = ObjectId(post_id)
if BlogPost.objects(id=object_id).count() == 1:
post = BlogPost.objects().with_id(object_id)
post.delete()
else:
flash('Invalid event id', ERROR_FLASH)
return redirect(url_for('.index'))
def blog_post():
form = BlogPostForm()
if form.validate_on_submit():
if form.submit.data:
language = guess_language(form.content.data)
if language == 'UNKNOWN' or len(language) > 5:
language = ''
post = BlogPost(title=form.title.data,
slug=form.slug.data,
content=form.content.data,
blog_author=current_user,
language=language,
published=form.published.data
)
db.session.add(post)
db.session.commit()
flash(_('Your blog post is now live!'))
return redirect(url_for('blog.blog'))
elif form.preview.data:
return render_template('blog/blog_post.html',
title='Blog Posts',
form=form,
preview=True,
blog_post=form.data
)
return render_template('blog/blog_post.html',
title='Blog Posts',
form=form)
def blog_archive(index):
"""View older blog posts.
**Route:** ``/blog/<index>``
**Methods:** ``GET``
"""
if index <= 0:
return redirect(url_for('.index'))
blog_posts = BlogPost.objects(published=True).order_by('-date_published')
# If the index is too high, check the previous page.
if len(blog_posts) <= 10 * index:
return redirect(url_for('blog.blog_archive', index=index - 1))
# Hide the next button if there are no more posts after this page.
if len(blog_posts) <= 10 * (index + 1):
next_index = None
else:
next_index = index + 1
previous_index = index - 1
return render_template('blog/blog.html',
posts=list(blog_posts[10 * index:10 * (index + 1)]),
previous_index=previous_index,
next_index=next_index)
def index():
"""View the ADI homepage.
**Route:** ``/``
**Methods:** ``GET``
"""
this_moment = datetime.now().time()
# cast date.today() to a datetime
today = datetime.combine(date.today(), datetime.min.time())
# Ending on a future date, or today at a future time. The events should be
# published, and should be chronological.
# We limit to four events, one large event and one set of three events.
events = (Event.objects(Q(end_date__gte=today))
# |
# Q(end_date=today, end_time__gt=this_moment)) #
.filter(published=True)
.order_by('start_date', 'start_time')
.limit(ONE_LARGE_AND_TRIPLE))
# sort published posts chronologically back in time
all_blog_posts = (BlogPost.objects(published=True)
.order_by('-date_published'))
latest_blog_post = all_blog_posts[0] if all_blog_posts else None
return render_template('index.html',
events=events,
blog_post=latest_blog_post)
def index():
"""View the ADI homepage.
**Route:** ``/``
**Methods:** ``GET``
"""
this_moment = datetime.now().time()
# Ending on a future date, or today at a future time. The events should be
# published, and should be chronological.
# We limit to four events, one large event and one set of three events.
events = (Event.objects(
Q(end_date__gt=date.today())
| Q(end_date=date.today(), end_time__gt=this_moment)).filter(
published=True).order_by('start_date',
'start_time').limit(ONE_LARGE_AND_TRIPLE))
# sort published posts chronologically back in time
all_blog_posts = (BlogPost.objects(
published=True).order_by('-date_published'))
latest_blog_post = all_blog_posts[0] if all_blog_posts else None
return render_template('index.html',
events=events,
blog_post=latest_blog_post)
def delete(post_id):
"""Delete an existing blog post.
**Route:** ``/admin/posts/delete/<post_id>``
**Methods:** ``POST``
:param str post_id: The ID of the post to edit.
"""
object_id = ObjectId(post_id)
if BlogPost.objects(id=object_id).count() == 1:
post = BlogPost.objects().with_id(object_id)
post.delete()
else:
flash('Invalid event id', ERROR_FLASH)
return redirect(url_for('.index'))
def blog_archive(index):
"""View older blog posts.
**Route:** ``/blog/<index>``
**Methods:** ``GET``
"""
if index <= 0:
return redirect(url_for('.index'))
blog_posts = BlogPost.objects(published=True).order_by('-date_published')
# If the index is too high, check the previous page.
if len(blog_posts) <= 10 * index:
return redirect(url_for('blog.blog_archive', index=index - 1))
# Hide the next button if there are no more posts after this page.
if len(blog_posts) <= 10 * (index + 1):
next_index = None
else:
next_index = index + 1
previous_index = index - 1
return render_template('blog/blog.html',
posts=list(blog_posts[10 * index:10 * (index + 1)]),
previous_index=previous_index,
next_index=next_index)
def add_blog_posts():
print(request.json)
post = BlogPost(title=request.json['title'],
content=request.json['content'])
models.db.session.add(post)
models.db.session.commit()
return request.json
def create():
# Only let authorised blog authors create posts
if not current_user.is_blog_author:
return redirect(url_for("blog.index"))
form = CreateBlogPostForm()
# For a post
if form.validate_on_submit():
slug = re.sub("[^\w]+", "-", form.title.data.lower())
new_post = BlogPost(author=current_user,
title=form.title.data,
slug=slug,
content=form.content.data,
content_preview=form.content_preview.data,
is_published=form.publish.data)
db.session.add(new_post)
db.session.commit()
return redirect(url_for("blog.drafts"))
return render_template("blog/create.html",
title="Create Blog Post",
form=form)
def createpost():
if validate_if_admin_user(current_user):
form = CreateBlogPost.refresh_values()
if form.validate_on_submit():
slug = re.sub('[^\w]+', '-', form.blog_title.data.lower())
blog_entry = BlogPost( \
title=form.blog_title.data, \
slug=slug, \
icon=form.blog_icon.data, \
tag=[BlogPostTags.query.filter(BlogPostTags.id == int(tag)).first() for tag in form.blog_tags.data], \
content=form.blog_content.data
)
db.session.add(blog_entry)
db.session.commit()
flash('Blog Post Created.')
return redirect(url_for('readpost', slug=slug))
return render_template('createpost.html', form=form)
else:
return redirect(url_for('user', username=current_user.username))
def editpost(slug):
if validate_if_admin_user(current_user):
blog_entry = BlogPost.public().filter_by(slug=slug).first_or_404()
form = CreateBlogPost.edit_values(blog_entry)
if form.validate_on_submit():
updated_slug = re.sub('[^\w]+', '-', form.blog_title.data.lower())
blog_entry.title = form.blog_title.data
blog_entry.slug = updated_slug
blog_entry.icon = form.blog_icon.data
blog_entry.tag = [
BlogPostTags.query.filter(BlogPostTags.id == int(tag)).first()
for tag in form.blog_tags.data
]
blog_entry.content = form.blog_content.data
db.session.commit()
flash('Blog Post Updated.')
return redirect(url_for('readpost', slug=updated_slug))
return render_template('createpost.html', form=form)
else:
return redirect(url_for('user', username=current_user.username))
def index():
blog_posts = list(BlogPost.objects(published=True).order_by('-date_published')[:10])
previous_index = None
next_index = 1
return render_template('blog/blog.html',
posts=blog_posts,
previous_index=previous_index,
next_index=next_index)
def get(self):
posts = BlogPost.get_all()
results = []
for post in posts:
obj = post.to_json()
results.append(obj)
return results
def manage_blog():
form = BlogPostForm()
form.category.choices = ([(cat.category, cat.category)
for cat in BlogCategory.query.all()])
# Publish new blog post
if form.validate_on_submit() and form.submit.data:
if 'photo' not in request.files:
flash('Post requires a photo.')
return redirect(url_for('manage_blog'))
file = request.files['photo']
filename = secure_filename(file.filename)
saved = images.save(request.files['photo'], folder="blog_photos/")
post = BlogPost(title=form.post_title.data,
body=form.post_body.data,
category=form.category.data,
photo_filename=filename,
photo_alt_text=form.photo_alt_text.data)
db.session.add(post)
db.session.commit()
if saved:
flash('Post is now live!')
return redirect(url_for('blog'))
post_count = BlogPost.query.count()
comments_count = BlogComment.query.count()
most_pop = BlogPost.query.order_by(
BlogPost.post_score.desc()).first_or_404()
latest = BlogComment.query.order_by(
BlogComment.timestamp.desc()).first_or_404()
latest_comment_post = (BlogPost.query.filter_by(
id=latest.post_id).first_or_404())
page = request.args.get('page', 1, type=int)
posts = BlogPost.query.order_by(BlogPost.timestamp.desc()).paginate(
page, app.config['TITLES_PER_PAGE'], False)
next_url = url_for('manage_blog', page=posts.next_num) \
if posts.has_next else None
prev_url = url_for('manage_blog', page=posts.prev_num) \
if posts.has_prev else None
return render_template('manage_blog.html',
title='Manage Blog',
form=form,
posts=posts.items,
next_url=next_url,
prev_url=prev_url,
post_count=post_count,
comments_count=comments_count,
most_pop=most_pop,
latest=latest,
latest_comment_post=latest_comment_post.title)
def new():
"""Create a new blog post.
**Route:** ``/admin/posts/new``
**Methods:** ``POST``
"""
form = CreateBlogPostForm(request.form)
form.author.choices = [
(str(u.id), u.name + " (You)" if u == g.user else u.name)
for u in User.objects()]
form.author.data = str(g.user.id)
upload_form = UploadImageForm()
if form.validate_on_submit():
author = User.objects().get(id=ObjectId(form.author.data))
post = BlogPost(title=form.title.data,
slug=form.slug.data,
images=[Image.objects().get(filename=fn) for fn in form.images.data],
markdown_content=form.body.data,
author=author,
posted_by=g.user)
post.save()
if form.published.data:
post.publish()
else:
post.unpublish()
return redirect(url_for('.index'))
images = Image.objects()
return render_template('admin/posts/edit.html', user=g.user, form=form,
images=images, upload_form=upload_form)
def preview(slug):
if BlogPost.objects(slug=slug).count() != 1:
abort(404)
post = BlogPost.objects().get(slug=slug)
if not post.date_published:
post.date_published = datetime.now() # just used as placeholder to
# display in preview. Does not get saved to db.
recent_posts = BlogPost.objects(published=True,
id__ne=post.id,
featured_image__ne=None)\
.order_by('-date_published')[:3]
related_posts = post.get_related_posts()[:3]
return render_template('admin/posts/preview.html',
post=post,
recent_posts=recent_posts,
related_posts=related_posts)
def preview(slug):
if BlogPost.objects(slug=slug).count() != 1:
abort(404)
post = BlogPost.objects().get(slug=slug)
if not post.date_published:
post.date_published = datetime.now() # just used as placeholder to
# display in preview. Does not get saved to db.
recent_posts = BlogPost.objects(published=True,
id__ne=post.id,
featured_image__ne=None)\
.order_by('-date_published')[:3]
related_posts = post.get_related_posts()[:3]
return render_template('admin/posts/preview.html',
post=post,
recent_posts=recent_posts,
related_posts=related_posts)
def index():
"""View all of the blog posts.
**Route:** ``/admin/posts``
**Methods:** ``GET``
"""
all_posts = BlogPost.objects().order_by('published', '-date_published')
return render_template('admin/posts/posts.html', posts=all_posts)
def index():
blog_posts = list(
BlogPost.objects(published=True).order_by('-date_published')[:10])
previous_index = None
next_index = 1
return render_template('blog/blog.html',
posts=blog_posts,
previous_index=previous_index,
next_index=next_index)
def index():
"""View all of the blog posts.
**Route:** ``/admin/posts``
**Methods:** ``GET``
"""
all_posts = BlogPost.objects().order_by('published', '-date_published')
return render_template('admin/posts/posts.html', posts=all_posts)
class CommentTest(unittest.TestCase):
def setUp(self):
self.new_blog = BlogPost(title='New Blog',
blogpost='This is the content')
def tearDown(self):
db.session.delete(self.new_blog)
db.session.commit()
def test_instance(self):
self.assertTrue(isinstance(self.new_blog, BlogPost))
def test_check_instance_variables(self):
self.assertEquals(self.new_blog.title, 'New Blog')
self.assertEquals(self.new_blog.blog_content, 'This is the content')
def test_save_blog(self):
self.new_blog.save_blog()
self.assertTrue(len(Blog.query.all()) > 0)
def post(slug):
"""View an individual blog post.
**Route:** ``/blog/post/<slug>``
**Methods:** ``GET``
"""
if BlogPost.objects(slug=slug).count() != 1:
abort(404)
post = BlogPost.objects().get(slug=slug)
recent_posts = BlogPost.objects(
published=True, id__ne=post.id,
featured_image__ne=None).order_by('-date_published')[:3]
if not post.published:
abort(404)
return render_template('blog/post.html',
post=post,
recent_posts=recent_posts)
def set_published_status(post_id, status):
object_id = ObjectId(post_id)
if BlogPost.objects(id=object_id).count() == 1:
post = BlogPost.objects().with_id(object_id)
if status != post.published:
post.published = status
# TODO Actually publish/unpublish the post here
if post.published:
flash('Blogpost published')
else:
flash('Blogpost unpublished')
post.save()
else:
flash("The blog post had not been published. No changes made.")
else:
flash('Invalid post id')
# print "Invalid post id"
pass
return redirect(url_for('.index'))
def create_post():
form = BlogPostForm()
if form.validate_on_submit():
blog_post = BlogPost(title=form.title.data,text=form.text.data,user_id=current_user.id)
db.session.add(blog_post)
db.session.commit()
flash("Blog Post Created")
return redirect(url_for('main.index'))
return render_template('create_post.html',form=form)
def edit(post_id):
try:
object_id = ObjectId(post_id)
except InvalidId:
return abort(404)
try:
post = BlogPost.objects().with_id(object_id)
except (DoesNotExist, ValidationError):
flash('Cannot find blog post with id %s.' % post_id)
return redirect(url_for('.index'))
if request.method == 'POST':
form = CreateBlogPostForm(request.form)
form.author.choices = [
(str(u.id), u.name + " (You)" if u == g.user else u.name)
for u in User.objects()]
form.author.default = str(g.user.id)
if form.validate_on_submit():
was_published = post.published
should_be_published = form.published.data
post.title = form.title.data
post.author = User.objects.get(id=ObjectId(form.author.data))
post.slug = form.slug.data
post.markdown_content = form.body.data
post.images = [Image.objects().get(filename=fn) for fn in form.images.data]
if form.featured_image.data:
post.featured_image = Image.objects().get(filename=form.featured_image.data)
else:
post.featured_image = None
post.save()
if was_published != should_be_published:
if was_published:
set_published_status(post.id, False)
else:
set_published_status(post.id, True)
return redirect(url_for('.index'))
upload_form = UploadImageForm()
featured_image = post.featured_image.filename if post.featured_image else None
form = CreateBlogPostForm(request.form,
title=post.title,
slug=post.slug,
published=post.published,
body=post.markdown_content,
images=[image.filename for image in post.images],
author=str(post.author.id),
featured_image=featured_image)
form.author.choices = [
(str(u.id), u.name + " (You)" if u == g.user else u.name)
for u in User.objects()]
form.author.default = str(g.user.id)
images = [image for image in Image.objects() if image not in post.images]
return render_template('admin/posts/edit.html', user=g.user, form=form,
post=post, images=images, upload_form=upload_form)
def backfill_from_jekyll(path_to_jekyll_posts):
connect('eventum')
author = User.objects().get(gplus_id='super')
filenames = os.listdir(path_to_jekyll_posts)
for filename in filenames:
slug = filename.split('.')[0]
title = None
date_published = None
published = True
markdown_content = ''
with open(os.path.join(path_to_jekyll_posts, filename)) as md_file:
content = False
for line in md_file:
if not title and line.startswith('## '):
title = line.replace('## ', '').strip()
elif not date_published and line.startswith('### '):
datestring = line.replace('### ', '').strip()
date_published = datetime.strptime(datestring, '%d %b %Y')
content = True
elif content:
markdown_content += line
if BlogPost.objects(slug=slug).count() > 0:
bp = BlogPost.objects().get(slug=slug)
bp.delete()
blog_post = BlogPost(title=title,
date_published=date_published,
published=published,
markdown_content=markdown_content,
slug=slug,
author=author)
blog_post.save()
print "Backfilled %s blog posts." % len(filenames)
def index():
all_events = (Event.objects(
Q(published=True, end_date__gt=date.today())
| Q(published=True,
end_date=date.today(),
end_time__gt=datetime.now().time())))
events = all_events.order_by('start_date', 'start_time')[:4]
all_blog_posts = BlogPost.objects(
published=True).order_by('-date_published')
blog_post = all_blog_posts[0] if all_blog_posts else None
return render_template('index.html', events=events, blog_post=blog_post)
def run(self):
"""Run the generation. Uses the configurations passed to
func:`__init__`.
"""
# Setup: db connection, superuser, and printer.
connect(config['MONGODB_SETTINGS']['DB'])
try:
superuser = User.objects().get(gplus_id='super')
except DoesNotExist:
print ('Failed to get superuser. Try running:\n'
'\texport GOOGLE_AUTH_ENABLED=TRUE')
printer = ProgressPrinter(self.quiet)
# Images
if self.should_gen_images:
if self.wipe:
self.warn('Image')
print CLIColor.warning('Wiping Image database.')
Image.drop_collection()
create_images(12, superuser, printer)
# Blog posts
if self.should_gen_posts:
if self.wipe:
self.warn('BlogPost')
print CLIColor.warning('Wiping BlogPost database.')
BlogPost.drop_collection()
create_posts(10, superuser, printer)
# Events and event series
if self.should_gen_events:
if self.wipe:
self.warn('Event and EventSeries')
print CLIColor.warning('Wiping Event database.')
Event.drop_collection()
print CLIColor.warning('Wiping EventSeries database.')
EventSeries.drop_collection()
create_events(superuser, printer)
def new_blogpost(author_id):
error = None
form = MessageForm(request.form)
if form.validate_on_submit():
newpost = BlogPost(title=form.title.data,
description=form.description.data,
author_id=current_user.id)
db.session.add(newpost)
db.session.commit()
flash('your post was successful', 'success')
return redirect(url_for('blog'))
return render_template('create-post.html', form=form, error=error)
def same_tag(tag):
"""View blog posts with the same tag
**Route:** ``/blog/tag/<tag>``
**Methods:** ``GET``
"""
blog_posts = list(BlogPost.objects(tags=tag).order_by('-date_published')[:10])
previous_index = None
next_index = 1
return render_template('blog/blog.html',
posts=blog_posts,
previous_index=previous_index,
next_index=next_index)
def new_posts():
if request.method == 'POST':
post_title = request.form['title']
post_author = request.form['author']
post_content = request.form['content']
new_post = BlogPost(title=post_title,
author=post_author,
content=post_content)
db.session.add(new_post)
db.session.commit()
return redirect(url_for('posts'))
return render_template('new-post.html')
def index():
today = date.today()
last_sunday = datetime.combine(
today - timedelta(days=(today.isoweekday() % 7)), datetime.min.time())
next_sunday = last_sunday + timedelta(days=7)
this_week = Event.objects(
start_date__gt=last_sunday,
start_date__lt=next_sunday).order_by('start_date')
posts = BlogPost.objects().order_by('published', '-date_published')[:5]
return render_template("admin/home.html",
this_week=this_week,
recent_posts=posts)
def post(slug):
"""View an individual blog post.
**Route:** ``/blog/post/<slug>``
**Methods:** ``GET``
"""
if BlogPost.objects(slug=slug).count() != 1:
abort(404)
post = BlogPost.objects().get(slug=slug)
recent_posts = BlogPost.objects(published=True,
id__ne=post.id,
featured_image__ne=None).order_by(
'-date_published')[:3]
related_posts = post.get_related_posts()[:3]
if not post.published:
abort(404)
return render_template('blog/post.html',
post=post,
recent_posts=recent_posts,
related_posts=related_posts)
def index():
"""View recent blog posts.
**Route:** ``/blog``
**Methods:** ``GET``
"""
blog_posts = list(BlogPost.objects(published=True).order_by('-date_published')[:10])
previous_index = None
next_index = 1
return render_template('blog/blog.html',
posts=blog_posts,
previous_index=previous_index,
next_index=next_index)
def home():
posts = BlogPost.get_all()
results = []
for post in posts:
obj = {
"id": post.id,
"title": post.title,
"content": post.content,
"date_created": post.date_created,
"date_modified": post.date_modified
}
results.append(obj)
response = jsonify(results)
response.status_code = 200
return response
def same_tag(tag):
"""View blog posts with the same tag
**Route:** ``/blog/tag/<tag>``
**Methods:** ``GET``
"""
tag = Tag.objects().get(tagname=tag)
blog_posts = list(BlogPost.objects(post_tags=tag, published=True)
.order_by('-date_published')[:10])
previous_index = None
next_index = 1
return render_template('blog/blog.html',
posts=blog_posts,
previous_index=previous_index,
next_index=next_index)
def blog_archive(index):
index = int(index)
if index <= 0:
return redirect(url_for('.index'))
blog_posts = BlogPost.objects(published=True).order_by('-date_published')
if len(blog_posts) < 10 * (index + 1):
next_index = None
else:
next_index = index + 1
previous_index = index - 1
return render_template('blog/blog.html',
posts=list(blog_posts[10 * index:10 * (index + 1)]),
previous_index=previous_index,
next_index=next_index)
def index():
"""View recent blog posts.
**Route:** ``/blog``
**Methods:** ``GET``
"""
blog_posts = BlogPost.objects(published=True).order_by('-date_published')
# Hide the next button if there are <= 10 posts.
next_index = 1 if len(blog_posts) > 10 else None
previous_index = None
return render_template('blog/blog.html',
posts=list(blog_posts[:10]),
previous_index=previous_index,
next_index=next_index)
def index():
"""The homepage of Eventum. Shows the latest blog posts and events.
**Route:** ``/admin/home``
**Methods:** ``GET``
"""
today = date.today()
last_sunday = datetime.combine(today - timedelta(days=(today.isoweekday() % 7)),
datetime.min.time())
next_sunday = last_sunday + timedelta(days=7)
this_week = Event.objects(start_date__gt=last_sunday,
start_date__lt=next_sunday).order_by('start_date')
posts = BlogPost.objects().order_by('published', '-date_published')[:5]
return render_template("admin/home.html", this_week=this_week, recent_posts=posts)
def blog_archive(index):
index = int(index)
if index <= 0:
return redirect(url_for('.index'))
blog_posts = BlogPost.objects(published=True).order_by('-date_published')
if len(blog_posts) < 10*(index+1):
next_index = None
else:
next_index = index + 1
previous_index = index - 1
return render_template('blog/blog.html',
posts=list(blog_posts[10*index:10*(index+1)]),
previous_index=previous_index,
next_index=next_index)
def index():
"""View the client homepage.
**Route:** ``/``
**Methods:** ``GET``
"""
all_events = (Event.objects(
Q(published=True,
end_date__gt=date.today()) |
Q(published=True,
end_date=date.today(),
end_time__gt=datetime.now().time())))
events = all_events.order_by('start_date', 'start_time')[:4]
all_blog_posts = BlogPost.objects(published=True).order_by('-date_published')
blog_post = all_blog_posts[0] if all_blog_posts else None
return render_template('index.html',
events=events,
blog_post=blog_post)
def edit(post_id):
"""Edit an existing blog post.
**Route:** ``/admin/posts/edit/<post_id>``
**Methods:** ``GET, POST``
:param str post_id: The ID of the post to edit.
"""
try:
object_id = ObjectId(post_id)
except InvalidId:
return abort(404)
try:
post = BlogPost.objects().with_id(object_id)
except (DoesNotExist, ValidationError):
flash('Cannot find blog post with id {}.'.format(post_id), ERROR_FLASH)
return redirect(url_for('.index'))
if request.method == 'POST':
form = CreateBlogPostForm(request.form)
form.author.choices = [
(str(u.id), u.name + " (You)" if u == g.user else u.name)
for u in User.objects()]
form.author.default = str(g.user.id)
if form.validate_on_submit():
post.title = form.title.data
post.author = User.objects.get(id=ObjectId(form.author.data))
post.slug = form.slug.data
post.markdown_content = form.body.data
post.images = [
Image.objects().get(filename=fn) for fn in form.images.data
]
post.post_tags = Tag.get_or_create_tags(form.tags.data)
if form.featured_image.data:
post.featured_image = Image.objects().get(
filename=form.featured_image.data)
else:
post.featured_image = None
post.save()
if post.published != form.published.data:
if form.published.data:
post.publish()
flash('Blogpost published', MESSAGE_FLASH)
else:
post.unpublish()
flash('Blogpost unpublished', MESSAGE_FLASH)
if form.preview.data is True:
return redirect(url_for('.preview', slug=post.slug))
upload_form = UploadImageForm()
feat_img = post.featured_image.filename if post.featured_image else None
form = CreateBlogPostForm(request.form,
title=post.title,
slug=post.slug,
published=post.published,
body=post.markdown_content,
images=[image.filename for image in post.images],
author=str(post.author.id),
featured_image=feat_img, tags=post.post_tags)
form.author.choices = [
(str(u.id), u.name + " (You)" if u == g.user else u.name)
for u in User.objects()
]
form.author.default = str(g.user.id)
images = [image for image in Image.objects() if image not in post.images]
return render_template('admin/posts/edit.html',
user=g.user,
form=form,
post=post,
images=images,
upload_form=upload_form)
def dad():
for post in BlogPost.objects():
post.delete()
return "son"
def view_all_posts():
return str(BlogPost.objects())
def index():
all_posts = BlogPost.objects().order_by('published', '-date_published')
return render_template('admin/posts/posts.html', posts=all_posts)
