def signup():
form = SignupForm(next=request.args.get('next',None))
if form.validate_on_submit():
code = UserCode.query.filter_by(code=form.code.data).first()
if code:
user = User(role=code.role)
form.populate_obj(user)
db.session.add(user)
db.session.delete(code)
db.session.commit()
identity_changed.send(current_app._get_current_object(),
identity=Identity(user.id))
flash(_("Welcome, %(name)s", name=user.nickname), "success")
next_url = form.next.data
if not next_url or next_url == request.path:
next_url = url_for('frontend.blog', username=user.username)
return redirect(next_url)
else:
form.code.errors.append(_("Code is not allowed"))
return render_template("account/signup.html", form=form)
def template_edit(path):
path = os.path.join(current_app.root_path, 'templates', "%s.html" % path)
html = ""
try:
f = open(path)
html = f.read()
f.close()
except:
flash(_("Template file does not exists"), "error")
form = TemplateForm(html=html.decode('utf8'))
if form.validate_on_submit():
f = open(path, 'w')
f.write(form.html.data.encode('utf8'))
f.close()
flash(_("Saving success"), "success")
return redirect(url_for("frontend.index"))
return render_template("blog/template_edit.html",
form=form,
path=path)
def login():
form = LoginForm(login=request.args.get('login', None),
next=request.args.get('next', None))
if form.validate_on_submit():
user, authenticated = User.query.authenticate(form.login.data,
form.password.data)
if user and authenticated:
session.permanent = form.remember.data
identity_changed.send(current_app._get_current_object(),
identity=Identity(user.id))
flash(_("Welcome back, %(name)s", name=user.username), "success")
next_url = form.next.data
if not next_url or next_url == request.path:
next_url = url_for('frontend.people', username=user.username)
return redirect(next_url)
else:
flash(_("Sorry, invalid login"), "error")
return render_template("account/login.html", form=form)
def login():
form = LoginForm(login=request.args.get('login',None),
next=request.args.get('next',None))
if form.validate_on_submit():
user, authenticated = User.query.authenticate(form.login.data,
form.password.data)
if user and authenticated:
session.permanent = form.remember.data
identity_changed.send(current_app._get_current_object(),
identity=Identity(user.id))
flash(_("Welcome back, %(name)s", name=user.username), "success")
next_url = form.next.data
if not next_url or next_url == request.path:
next_url = url_for('frontend.blog', username=user.username)
return redirect(next_url)
else:
flash(_("Sorry, invalid login"), "error")
return render_template("account/login.html", form=form)
def signup():
form = SignupForm(next=request.args.get('next', None))
if form.validate_on_submit():
code = UserCode.query.filter_by(code=form.code.data).first()
if code:
user = User(role=code.role)
form.populate_obj(user)
db.session.add(user)
db.session.delete(code)
db.session.commit()
identity_changed.send(current_app._get_current_object(),
identity=Identity(user.id))
flash(_("Welcome, %(name)s", name=user.nickname), "success")
next_url = form.next.data
if not next_url or next_url == request.path:
next_url = url_for('frontend.people', username=user.username)
return redirect(next_url)
else:
form.code.errors.append(_("Code is not allowed"))
return render_template("account/signup.html", form=form)
def template_edit(path):
path = os.path.join(current_app.root_path, 'templates', "%s.html" % path)
html = ""
try:
f = open(path)
html = f.read()
f.close()
except:
flash(_("Template file does not exists"), "error")
form = TemplateForm(html=html.decode('utf8'))
if form.validate_on_submit():
f = open(path, 'w')
f.write(form.html.data.encode('utf8'))
f.close()
flash(_("Saving success"), "success")
return redirect(url_for("frontend.index"))
return render_template("blog/template_edit.html", form=form, path=path)
def add_comment(post_id, parent_id=None):
post = Post.query.get_or_404(post_id)
parent = Comment.query.get_or_404(parent_id) if parent_id else None
form = CommentForm()
if form.validate_on_submit():
comment = Comment(post=post,
parent=parent,
ip=ip2long(request.environ['REMOTE_ADDR']))
form.populate_obj(comment)
if g.user:
comment.author = g.user
db.session.add(comment)
db.session.commit()
signals.comment_added.send(post)
flash(_("Thanks for your comment"), "success")
return redirect(comment.url)
return render_template("blog/add_comment.html",
parent=parent,
post=post,
form=form)
def add_comment(post_id, parent_id=None):
post = Post.query.get_or_404(post_id)
parent = Comment.query.get_or_404(parent_id) if parent_id else None
form = CommentForm()
if form.validate_on_submit():
comment = Comment(post=post,
parent=parent,
ip=ip2long(request.environ['REMOTE_ADDR']))
form.populate_obj(comment)
if g.user:
comment.author = g.user
db.session.add(comment)
db.session.commit()
signals.comment_added.send(post)
flash(_("Thanks for your comment"), "success")
return redirect(comment.url)
return render_template("blog/add_comment.html",
parent=parent,
post=post,
form=form)
def people(username,page=1):
people = User.query.get_by_username(username)
form = TwitterForm()
if form.validate_on_submit():
api = people.twitter_api
if api is None:
return redirect(url_for('account.twitter'))
content = form.content.data.encode("utf-8")
status = people.post_twitter(content)
if status:
flash(_("Twitter posting is success"),"success")
return redirect(url_for('frontend.people',
username=username,
page=page))
else:
flash(_("Twitter posting is failed"),"error")
page_obj = Post.query.filter(Post.author_id==people.id).as_list()\
.paginate(page,per_page=Post.PER_PAGE)
page_url = lanbda page: url_for("post.people",
username=username,
page=page)
return render_template("blog/people.html",
form=form,
page_obj=page_obj,
page_url=page_url,
people=people)
def index(page=1):
if page < 1:
page = 1
ups = Upload.query
page_obj = ups.paginate(page=page, per_page=Upload.PER_PAGE)
page_url = lambda page: url_for("uploads.index", page=page)
return render_template("blog/uploads.html", page_obj=page_obj, page_url=page_url)
def tag(slug, page=1):
tag = Tag.query.filter_by(slug=slug).first_or_404()
page_obj = tag.posts.as_list() \
.paginate(page, per_page=Post.PER_PAGE)
page_url = lambda page: url_for("post.tag", slug=slug, page=page)
return render_template("blog/list.html",
page_obj=page_obj,
page_url=page_url)
def index(year=None,month=None,day=None,page=1):
if page<1:page=1
page_obj = Post.query.archive(year,month,day).as_list()\
.paginate(page,per_page=Post.PER_PAGE)
page_url = lambda page:url_for("post.index",
year=year,
month=month,
day=day,
page=page)
return render_template("blog/list.html",
page_obj=page_obj,
page_url=page_url)
def index(year=None, month=None, day=None, page=1):
if page < 1: page = 1
page_obj = Post.query.archive(year,month,day).as_list() \
.paginate(page, per_page=Post.PER_PAGE)
page_url = lambda page: url_for(
"post.index", year=year, month=month, day=day, page=page)
return render_template("blog/list.html",
page_obj=page_obj,
page_url=page_url)
def index(page=1):
links = Link.query
if g.user is None:
links = links.filter(Link.passed == True)
page_obj = links.paginate(page=page, per_page=Link.PER_PAGE)
page_url = lambda page: url_for("link.index", page=page)
return render_template("admin/links.html",
page_obj=page_obj,
page_url=page_url)
def tag(slug, page=1):
tag = Tag.query.filter_by(slug=slug).first_or_404()
page_obj = tag.posts.as_list() \
.paginate(page, per_page=Post.PER_PAGE)
page_url = lambda page: url_for("post.tag",
slug=slug,
page=page)
return render_template("blog/list.html",
page_obj=page_obj,
page_url=page_url)
def index(page=1):
links = Link.query
if g.user is None:
links = links.filter(Link.passed==True)
page_obj = links.paginate(page=page, per_page=Link.PER_PAGE)
page_url = lambda page: url_for("link.index",page=page)
return render_template("blog/links.html",
page_obj=page_obj,
page_url=page_url)
def add():
form = UploadForm()
if "file" in request.files:
filename = uploader.save(request.files["file"])
upload = Upload(file=filename)
db.session.add(upload)
db.session.commit()
flash(_("Upload successful"), "success")
return redirect(url_for("uploads.index"))
return render_template("blog/add_upload.html", form=form)
def submit():
form = PostForm()
if form.validate_on_submit():
post = Post(author=g.user)
form.populate_obj(post)
db.session.add(post)
db.session.commit()
flash(_("Posting success"), "success")
return redirect(post.url)
return render_template("blog/submit.html", form=form)
def edit(post_id):
post = Post.query.get_or_404(post_id)
form = PostForm(title=post.title, slug=post.slug, content=post.content, tags=post.tags, obj=post)
if form.validate_on_submit():
form.populate_obj(post)
db.session.commit()
flash(_("Post has been changed"), "success")
return redirect(post.url)
return render_template("admin/submit.html", form=form)
def submit():
form = PostForm()
if form.validate_on_submit():
post = Post(author=g.user)
form.populate_obj(post)
db.session.add(post)
db.session.commit()
flash(_("Posting success"), "success")
return redirect(post.url)
return render_template("blog/submit.html", form=form)
def search(page=1):
keywords = request.args.get('q','').strip()
if not keywords:
return redirect(url_for("frontend.index"))
page_obj = Post.query.search(keywords).as_list()\
.paginate(page,per_page=Post.PER_PAGE)
if page_obj.total == 1:
post = page_obj.items[0]
return redirect(post.url)
page_url = lambda page:url_for('frontend.search',
page=page,
keywords=keywords)
return render_template("blog/search_result.html",
page_obj=page_obj,
page_url=page_url,
keywords=keywords)
def post(uear,month,day,slug):
post = Post.query.get_by_slug(slug)
date = (post.created_date.year,
post.created_date.month,
post.created_date.day)
if date != (year, month, day):
return redirect(post.url)
prev_post = Post.query.filter(Post.created_date<post.created_date) \
.first()
next_post = Post.query.filter(Post.created_date>post.created_date) \
.order_by('created_date asc').first()
return render_template("blog/view.html",
post=post,
prev_post=prev_post,
next_post=next_post,
comment_form=CommentForm())
def post(year, month, day, slug):
post = Post.query.get_by_slug(slug)
date = (post.created_date.year, post.created_date.month,
post.created_date.day)
if date != (year, month, day):
return redirect(post.url)
prev_post = Post.query.filter(Post.created_date<post.created_date) \
.first()
next_post = Post.query.filter(Post.created_date>post.created_date) \
.order_by('created_date asc').first()
return render_template("blog/view.html",
post=post,
prev_post=prev_post,
next_post=next_post,
comment_form=CommentForm())
def delete(post_id):
post = Post.query.get_or_404(post_id)
post.permissions.delete.test(403)
Comment.query.filter_by(post=post).delete()
db.session.delete(post)
db.session.commit()
if g.user.id != post.author_id:
body = render_template("emails/post_deleted.html", post=post)
message = Message(subject="Your post has been deleted", body=body, recipients=[post.author.email])
mail.send(message)
flash(_("The post has been deleted"), "success")
return jsonify(success=True, redirect_url=url_for("frontend.index"))
def add():
form = LinkForm()
if form.validate_on_submit():
link = Link()
form.populate_obj(link)
if g.user and g.user.is_moderator:
link.passed = True
db.session.add(link)
db.session.commit()
flash(_("Adding success"), "success")
return redirect(url_for('link.index'))
return render_template("admin/add_link.html", form=form)
def add():
form = LinkForm()
if form.validate_on_submit():
link = Link()
form.populate_obj(link)
if g.user and g.user.is_moderator:
link.passed = True
db.session.add(link)
db.session.commit()
flash(_("Adding success"), "success")
return redirect(url_for('link.index'))
return render_template("blog/add_link.html", form=form)
def edit(post_id):
post = Post.query.get_or_404(post_id)
form = PostForm(title=post.title,
slug=post.slug,
content=post.content,
tags=post.tags,
obj=post)
if form.validate_on_submit():
form.populate_obj(post)
db.session.commit()
flash(_("Post has been changed"), "success")
return redirect(post.url)
return render_template("blog/submit.html", form=form)
def search(page=1):
keywords = request.args.get('q', '').strip()
if not keywords:
return redirect(url_for("frontend.index"))
page_obj = Post.query.search(keywords).as_list() \
.paginate(page, per_page=Post.PER_PAGE)
if page_obj.total == 1:
post = page_obj.items[0]
return redirect(post.url)
page_url = lambda page: url_for(
'frontend.search', page=page, keywords=keywords)
return render_template("blog/search_result.html",
page_obj=page_obj,
page_url=page_url,
keywords=keywords)
def delete(post_id):
post = Post.query.get_or_404(post_id)
post.permissions.delete.test(403)
Comment.query.filter_by(post=post).delete()
db.session.delete(post)
db.session.commit()
if g.user.id != post.author_id:
body = render_template("emails/post_deleted.html", post=post)
message = Message(subject="Your post has been deleted",
body=body,
recipients=[post.author.email])
mail.send(message)
flash(_("The post has been deleted"), "success")
return jsonify(success=True, redirect_url=url_for('frontend.index'))
def people(username, page=1):
people = User.query.get_by_username(username)
form = TwitterForm()
if form.validate_on_submit():
api = people.twitter_api
if api is None:
return redirect(url_for('account.twitter'))
content = form.content.data.encode("utf8")
status = people.post_twitter(content)
if status:
flash(_("Twitter posting is success"), "success")
return redirect(
url_for('frontend.people', username=username, page=page))
else:
flash(_("Twitter posting is failed"), "error")
page_obj = Post.query.filter(Post.author_id==people.id).as_list() \
.paginate(page, per_page=Post.PER_PAGE)
page_url = lambda page: url_for(
"post.people", username=username, page=page)
return render_template("blog/people.html",
form=form,
page_obj=page_obj,
page_url=page_url,
people=people)
def about():
return render_template("blog/about.html")
def archive():
return render_template("blog/archive.html")
def tags():
return render_template("blog/tags.html")
db.session.add(user)
db.session.delete(code)
db.session.commit()
identity_changed.send(current_app._get_current_object(),
identity=Identity(user.id))
flash(_("Welcome, %(name)s",name=user.nickname),"success")
next_url = form.next.data
if not next_url or next_url == request.path:
next_url = url_for('frontend.people',username=user.username)
return redirect(next_url)
else:
from.code.errors.append(_("Code is not allowed"))
return render_template("account/signup.html",form=form)
@account.route("/logout/")
def logout():
flash(_("You are now logged out"),"success")
identity_changed.send(current_app._get_current_object(),
identity=AnonymousIdentity())
next_url = request.args.get('next','')
if not next_url or next_url == request.path:
next_url = url_for("frontend.index")
return redirect(next_url)
@aaccount.route("/twitter/")
def display(slug):
post = Post.query.get_by_slug(slug)
return render_template("blog/page.html", post=post)
def page_not_found(error):
if request.is_xhr:
return jsonify(error=_('Sorry, page not found'))
return render_template("errors/404.html", error=error)
def tags():
return render_template("blog/tags.html")
def archive():
return render_template("blog/archive.html")
def page_not_found(error):
if request.is_xhr:
return jsonify(error=_('Sorry, page not found'))
return render_template("errors/404.html", error=error)
def about():
return render_template("blog/about.html")
def server_error(error):
if request.is_xhr:
return jsonify(error=_('Sorry, an error has occurred'))
return render_template("errors/500.html", error=error)
def forbidden(error):
if request.is_xhr:
return jsonify(error=_('Sorry, page not allowed'))
return render_template("errors/403.html", error=error)
def forbidden(error):
if request.is_xhr:
return jsonify(error=_('Sorry, page not allowed'))
return render_template("errors/403.html", error=error)
def server_error(error):
if request.is_xhr:
return jsonify(error=_('Sorry, an error has occurred'))
return render_template("errors/500.html", error=error)
@frontend.route("/tags/")
def tags():
return render_template("blog/tags.html")
@frontend.route("/tags/<slug>/")
@frontend.route("/tags/<slug>/page/<int:page>")
def tag(slug,page=1)
tag = Tag.query.filter_by(slug=slug).first_or_404()
page_obj = tag.posts.as_list()\
.paginate(page,per_page=Post.PER_PAGE)
page_url = lambda page:url_for("post.tag",
slug=sulg,
page=page)
return render_template("blog/list.html",
page_obj=page_obj,
page_url=page_url)
@frontend.route("/people/<username>",methods=("GET","POST"))
@frontend.route("/people/<username>/page/<int:page>/",method=("GET","POST"))
def people(username,page=1):
people = User.query.get_by_username(username)
form = TwitterForm()
if form.validate_on_submit():
api = people.twitter_api
if api is None:
return redirect(url_for('account.twitter'))
content = form.content.data.encode("utf-8")
status = people.post_twitter(content)
if status:
