def createbbs():
try:
name = request.form["name"]
parent_bbs = int(request.form["parent_bbs"])
bbs = BBS(name, parent_bbs)
db.session.add(bbs)
db.session.commit()
reply = {'result': 'OK', 'id': bbs.id}
return json.dumps(reply)
except IntegrityError:
db.session.rollback()
dbg("createbbs IntegrityError")
print_exception_info()
reply = {'result': 'BBS with the same name exists!', 'id': 0}
return json.dumps(reply)
except:
db.session.rollback()
dbg("createbbs ERROR")
print_exception_info()
reply = {'result': 'ERROR', 'id': 0}
return json.dumps(reply)
def build_thread(post): #build thread tree
dbg("build_thread %d" % post.id)
post_dict = {
'id': post.id,
'parent_post_id': post.parent_post_id,
'view_count': post.view_count,
'post_time': post.post_time,
'comment_count': post.comment_count,
'title': post.title,
'body': post.body,
'like_count': post.like_count,
'dislike_count': post.dislike_count
}
author = post.author
author_dict = {
'id': author.id,
'name': author.name,
'avatar_hash': author.avatar_hash
}
child_posts = db.session.query(Post).filter(Post.parent_post_id == post.id).\
filter(Post.id != post.id).all()
child_posts_list = []
for child_post in child_posts:
child_posts_list.append(build_thread(child_post))
return {
'post': post_dict,
'author': author_dict,
'child_posts': child_posts_list
}
def renamebbs():
dbg("/renamebbs")
try:
name = request.form["name"]
id = int(request.form["id"])
bbs = db.session.query(BBS).filter(BBS.id == id).one()
bbs.name = name
db.session.commit()
reply = {'result': 'OK'}
return json.dumps(reply)
except NoResultFound:
dbg("renamebbs NoResultFound")
reply = {'result': 'NoResultFound'}
except MultipleResultsFound:
dbg("renamebbs MultipleResultsFound")
reply = {'result': 'MultipleResultsFound'}
except IntegrityError:
db.session.rollback()
dbg("renamebbs IntegrityError")
print_exception_info()
reply = {'result': 'IntegrityError'}
except:
db.session.rollback()
dbg("renamebbs except")
print_exception_info()
reply = {'result': 'except'}
finally:
return json.dumps(reply)
def dashboard():
if not current_user.is_god():
return render_template("500.html")
setting = g.platform_setting
form = PlatformSettingForm(mode=setting.mode)
if form.validate_on_submit():
try:
setting.window_title = form.window_title.data
setting.page_title = form.page_title.data
setting.mode = form.mode.data
setting.main_blog = form.main_blog.data
setting.show_blog_link = form.show_blog_link.data
setting.show_about_link = form.show_about_link.data
setting.bbs_posts_per_page = form.bbs_posts_per_page.data
db.session.commit()
except Exception:
dbg("saverightinfo ERROR")
print_exception_info()
return "ERROR"
else:
form.window_title.data = setting.window_title
form.page_title.data = setting.page_title
form.main_blog.data = setting.main_blog
form.show_blog_link.data = setting.show_blog_link
form.show_about_link.data = setting.show_about_link
form.bbs_posts_per_page.data = setting.bbs_posts_per_page
return render_template("dashboard.html", form=form)
def create_roles():
roles = {(1, 'User', True), (100, 'God', False)}
for r in roles:
role = Role()
role.level = r[0]
role.name = r[1]
role.default = r[2]
db.session.add(role)
dbg('create_roles %r' % role)
db.session.commit()
def user(name):
try:
user = db.session.query(User).filter(User.name == name).one()
except NoResultFound:
dbg("NoResultFound")
return render_template("500.html")
except MultipleResultsFound:
dbg("MultipleResultsFound")
return render_template("500.html")
return render_template("user.html", user=user)
def post_id(id):
try:
post = db.session.query(Post).filter(Post.id == id).filter(
Post.is_comment == False).one()
return render_post(post)
except NoResultFound:
dbg("NoResultFound")
return render_template("wrongpost.html")
except MultipleResultsFound:
dbg("MultipleResultsFound")
return "ERROR"
def getrightinfo():
try:
reply = {}
setting = g.platform_setting
reply['title'] = setting.right_info_title
reply['body'] = setting.right_info
return json.dumps(reply)
except Exception:
dbg("getrightinfo ERROR")
print_exception_info()
return "ERROR"
return "ERROR"
def saverightinfo():
try:
title = request.form['title']
body = request.form['body']
setting = g.platform_setting
setting.right_info_title = title
setting.right_info = body
db.session.commit()
return "OK"
except Exception:
dbg("saverightinfo ERROR")
print_exception_info()
return "ERROR"
return "ERROR"
def send_email(to, subject, template, **kwargs):
app = current_app._get_current_object()
msg = Message(app.config['BT_MAIL_SUBJECT_PREFIX'] + ' ' + subject,
sender=app.config['BT_MAIL_SENDER'],
recipients=[to])
msg.body = render_template(template + '.txt', **kwargs)
msg.html = render_template(template + '.html', **kwargs)
dbg('xcc send_email')
dbg('%r %r' % (app.config['BT_MAIL_SENDER'], to))
msg.charset = 'utf8' #xiongchen20140811
thr = Thread(target=send_async_email, args=[app, msg])
thr.start()
return thr
def blog(name):
dbg("blog %s" % name)
content = []
try:
content = db.session.query(
Post, User).filter(Post.author_id == User.id).filter(
User.name == name).filter(Post.is_comment == False).filter(
Post.owner_blog == Post.author_id).order_by(
Post.post_time.desc()).all()
return render_template("blog.html", content=content)
except NoResultFound:
dbg("NoResultFound")
return render_template("blog.html", content=content)
return "ERROR"
def login():
form = LoginForm()
dbg("xcc login")
if form.validate_on_submit():
dbg("xcc login submit")
user = User.query.filter_by(email=form.email_or_name.data).first()
if user is not None and user.verify_password(form.password.data):
login_user(user, form.remember_me.data)
user.last_seen_time = datetime.utcnow()
db.session.commit()
return redirect(request.args.get('next') or url_for('site.dash'))
else:
user = User.query.filter_by(name=form.email_or_name.data).first()
if user is not None and user.verify_password(form.password.data):
login_user(user, form.remember_me.data)
user.last_seen_time = datetime.utcnow()
db.session.commit()
return redirect(
request.args.get('next') or url_for('site.dash'))
flash('Invalid username or password.')
return render_template('auth/login.html', form=form)
def gallery():
dbg("/gallery")
dbg(os.getcwd())
all_files = os.listdir(os.getcwd() + '/app' + config.gallery_dir)
dbg(all_files)
pictures = []
for f in sorted(all_files, reverse=True):
pictures.append(config.gallery_dir + f)
return render_template("gallery.html", pictures=pictures)
def mainbbs():
dbg("/mainbbs")
try:
bbs = db.session.query(BBS).filter(BBS.id == 1).one()
return redirect(url_for('site.bbs', name=bbs.name))
except NoResultFound:
dbg("NoResultFound")
return render_template("404.html")
except MultipleResultsFound:
dbg("MultipleResultsFound")
return render_template("404.html")
def mainblog():
dbg("/mainblog")
try:
user = db.session.query(User).filter(
User.id == g.platform_setting.main_blog).one()
return redirect(url_for('site.blog', name=user.name))
except NoResultFound:
dbg("NoResultFound")
return render_template("404.html")
except MultipleResultsFound:
dbg("MultipleResultsFound")
return render_template("404.html")
def getthread():
post_id = int(request.form['post_id'])
dbg('getthread %d' % post_id)
try:
post = db.session.query(Post).filter(Post.id == post_id).one()
except NoResultFound:
dbg("NoResultFound")
return render_template("wrongpost.html")
except MultipleResultsFound:
dbg("MultipleResultsFound")
return "ERROR"
thread = build_thread(post)
return json.dumps(thread, cls=ComplexEncoder)
def bbs(name):
#dbg("/bbs %s" % name)
page = request.args.get('page', 1, type=int)
try:
bbs = db.session.query(BBS).filter(BBS.name == name).one()
except NoResultFound:
dbg("NoResultFound")
return render_template("404.html")
except MultipleResultsFound:
dbg("MultipleResultsFound")
return render_template("500.html")
try:
children_bbs = db.session.query(BBS).filter(
BBS.parent_bbs == bbs.id).all()
parent_bbs = None
if bbs.parent_bbs == 0:
parent_bbs = bbs
else:
parent_bbs = db.session.query(BBS).filter(
BBS.id == bbs.parent_bbs).one()
can_reply = 0
if current_user.is_authenticated and current_user.confirmed:
can_reply = 1
return render_template("bbs.html",
page=page,
can_reply=can_reply,
bbs=bbs,
parent_bbs=parent_bbs,
children_bbs=children_bbs)
except:
dbg("bbs except 1")
print_exception_info()
return render_template("500.html")
def dash():
dbg("/dash")
try:
bbs = db.session.query(BBS).filter(BBS.id == 1).one()
if g.platform_setting.mode == 0:
user = db.session.query(User).filter(
User.id == g.platform_setting.main_blog).one()
return redirect(url_for('site.blog', name=user.name))
else:
return redirect(url_for('site.bbs', name=bbs.name))
except NoResultFound:
dbg("NoResultFound")
return render_template("404.html")
except MultipleResultsFound:
dbg("MultipleResultsFound")
return render_template("404.html")
def getbbsposts():
dbg("/getbbsposts")
id = int(request.form["bbs_id"])
page = int(request.form["page"])
page_size = g.platform_setting.bbs_posts_per_page
if page < 1:
page = 1
dbg('page %d page_size %d' % (page, page_size))
try:
bbs = db.session.query(BBS).filter(BBS.id == id).one()
except NoResultFound:
dbg("NoResultFound")
return render_template("404.html")
except MultipleResultsFound:
dbg("MultipleResultsFound")
return "MultipleResultsFound"
reply = {}
try:
#################page bar
pagebar = {}
buttons = []
total_posts = db.session.query(Post).filter(
Post.owner_bbs == bbs.id).filter(
Post.is_comment == False).order_by(
Post.last_reply_time.desc()).count()
total_pages = int(total_posts / page_size)
if total_posts % page_size:
total_pages += 1
if page > total_pages:
page = total_pages
pagebar['current_page'] = page
prev_page = page - 1
if prev_page < 1:
prev_page = 1
buttons.append({'title': '上一页', 'page': prev_page})
start = page - 3
if start <= 2:
for p in range(1, page + 1):
buttons.append({'title': str(p), 'page': p})
else:
buttons.append({'title': '1', 'page': 1})
buttons.append({'title': '...', 'page': page})
for p in range(start, page + 1):
buttons.append({'title': str(p), 'page': p})
end = page + 3
if end >= total_pages - 1:
for p in range(page + 1, total_pages + 1):
buttons.append({'title': str(p), 'page': p})
else:
for p in range(page + 1, end + 1):
buttons.append({'title': str(p), 'page': p})
buttons.append({'title': '...', 'page': page})
buttons.append({'title': str(total_pages), 'page': total_pages})
next_page = page + +1
if next_page > total_pages:
next_page = total_pages
buttons.append({'title': '下一页', 'page': next_page})
pagebar['buttons'] = buttons
reply['pagebar'] = pagebar
#########posts
query = db.session.query(Post, User).filter(Post.author_id == User.id)\
.filter(Post.owner_bbs == bbs.id)\
.filter(Post.is_comment == False)\
.order_by(Post.last_reply_time.desc()).offset(page_size * (page - 1)).limit(page_size)
#dbg(query)
content = query.all()
posts = []
for row in content:
last_commenter = db.session.query(User).filter(
row.Post.last_commenter == User.id).one()
post_dict = {
'id': row.Post.id,
'parent_post_id': row.Post.parent_post_id,
'view_count': row.Post.view_count,
'post_time': row.Post.post_time,
'comment_count': row.Post.comment_count,
'title': row.Post.title,
'body': row.Post.body,
'like_count': row.Post.like_count,
'dislike_count': row.Post.dislike_count,
'last_commenter': last_commenter.name,
'last_reply_time': row.Post.last_reply_time
}
author_dict = {
'id': row.User.id,
'name': row.User.name,
'avatar_hash': row.User.avatar_hash
}
posts.append({"post": post_dict, "author": author_dict})
reply['posts'] = posts
except:
dbg("bbs except 2")
print_exception_info()
return json.dumps(reply, cls=ComplexEncoder)
def deletebbs():
dbg("deletebbs")
return "no"
from app.tool.tools import dbg
dbg("email.py")
from threading import Thread
from flask import current_app, render_template
from flask_mail import Message
from app import mail
def send_async_email(app, msg):
with app.app_context():
dbg('mail.send(msg)...')
result = mail.send(msg)
dbg('result = %r' % result)
def send_email(to, subject, template, **kwargs):
app = current_app._get_current_object()
msg = Message(app.config['BT_MAIL_SUBJECT_PREFIX'] + ' ' + subject,
sender=app.config['BT_MAIL_SENDER'],
recipients=[to])
msg.body = render_template(template + '.txt', **kwargs)
msg.html = render_template(template + '.html', **kwargs)
dbg('xcc send_email')
dbg('%r %r' % (app.config['BT_MAIL_SENDER'], to))
msg.charset = 'utf8' #xiongchen20140811
thr = Thread(target=send_async_email, args=[app, msg])
thr.start()
def send_async_email(app, msg):
with app.app_context():
dbg('mail.send(msg)...')
result = mail.send(msg)
dbg('result = %r' % result)
from app.tool.tools import dbg
dbg('model.py')
from werkzeug.security import generate_password_hash, check_password_hash
from itsdangerous import TimedJSONWebSignatureSerializer as Serializer
from flask import current_app
from flask_login import UserMixin
from app import db, login_manager
from datetime import datetime
from sqlalchemy.ext.associationproxy import association_proxy
from sqlalchemy import Column, Integer, String, ForeignKey, Text, Table, Boolean, UniqueConstraint, DateTime
from sqlalchemy.orm import relationship, backref
from sqlalchemy.ext.declarative import declarative_base
Base = declarative_base()
'''
Role-User 1-n
User-Post 1-n
'''
class Role(db.Model): #(Role - User) one to many
__tablename__ = 'roles'
id = db.Column(db.Integer, primary_key=True)
level = db.Column(db.Integer(), unique=True)
name = db.Column(db.String(64), unique=True)
default = db.Column(db.Boolean, default=False, index=True)
def savepost():
title = request.form['title']
body = request.form['body']
parent_post_id = int(request.form['parent_post_id'])
ancestor_post_id = int(request.form['ancestor_post_id'])
is_comment = int(request.form['is_comment'])
owner_bbs = int(request.form['owner_bbs'])
owner_blog = int(request.form['owner_blog'])
editor_mode = request.form['editor_mode']
original_post = int(request.form['original_post'])
if editor_mode == "edit":
try:
post = db.session.query(Post).filter(
Post.id == original_post).one()
#post.title = title title is not allowed to change
post.body = body
post.last_editing_time = datetime.utcnow()
db.session.commit()
return "OK"
except Exception:
dbg("savepost edit ERROR")
db.session.rollback()
print_exception_info()
return "ERROR"
return "ERROR"
else: #new post
if is_comment:
is_comment = True
else:
is_comment = False
author_id = current_user.get_id()
view_count = 0
comment_count = 0
like_count = 0
dislike_count = 0
post = Post(title = title, body = body, author_id = author_id,\
post_time = datetime.utcnow(), last_editing_time = datetime.utcnow(), parent_post_id = parent_post_id,\
ancestor_post_id = ancestor_post_id, is_comment = is_comment, view_count = view_count, \
comment_count = comment_count, like_count = like_count, dislike_count = dislike_count, \
owner_blog = owner_blog, owner_bbs = owner_bbs, last_reply_time = datetime.utcnow(),\
last_commenter = author_id)
#dbg(post.post_time)
try:
db.session.add(post)
db.session.commit()
if not is_comment:
post.parent_post_id = 0 #post.id
post.ancestor_post_id = 0 #post.id
else:
ancestor_post = db.session.query(Post).filter(
Post.id == ancestor_post_id).one()
ancestor_post.comment_count += 1
ancestor_post.last_reply_time = datetime.utcnow()
ancestor_post.last_commenter = author_id
db.session.commit()
#dbg(post.title)
#dbg(post.author_id)
#dbg(post.id)
#dbg(post.like_count)
#dbg(post.parent_post_id)
#dbg(post.ancestor_post_id)
#dbg(post.is_comment)
#dbg(post.comment_count)
return "OK"
except InvalidRequestError:
dbg("savepost InvalidRequestError")
print_exception_info()
return "ERROR"
except Exception:
dbg("savepost ERROR")
print_exception_info()
return "ERROR"
return "ERROR"
def videos():
dbg("/videos")
return render_template("videos.html", videos=source_videos)
from app.tool.tools import dbg, print_exception_info
dbg('site.py')
import os, json, re, time, sys, html
from datetime import datetime
import config as config
#import app.database.model as dbmodel
from .. import db
from app.database.model import Role, User, Post, PlatformSetting, BBS
from sqlalchemy.orm.exc import NoResultFound, MultipleResultsFound
from sqlalchemy.exc import IntegrityError, SQLAlchemyError, InvalidRequestError
from sqlalchemy import * #create_engine
from .forms import PlatformSettingForm
from .sources import source_videos
class ComplexEncoder(json.JSONEncoder):
def default(self, obj):
if isinstance(obj, datetime):
return obj.strftime('%Y-%m-%d %H:%M:%S')
else:
return json.JSONEncoder.default(self, obj)
#main flask
from flask import Flask, Blueprint, request, g, redirect, url_for, abort, render_template, flash, _app_ctx_stack, make_response
#login module
from app.tool.tools import dbg
dbg("app.py")
from flask import Flask
from flask_mail import Mail
#from flask.ext.moment import Moment
from flask_sqlalchemy import SQLAlchemy
from flask_login import LoginManager
from flask_babel import Babel
from .flasksui import *
flasksui = SUI()
mail = Mail()
#moment = Moment()
db = SQLAlchemy(session_options = {'autocommit':False})
login_manager = LoginManager()
login_manager.session_protection = 'strong'
login_manager.login_view = 'auth.login'
import config as config
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config.config_list[config_name])
config.config_list[config_name].init_app(app)
flasksui.init_app(app)
mail.init_app(app)
def about():
dbg("/about")
return render_template("about.html")
from app.tool.tools import dbg
dbg('auth.py')
import config as config
from flask import Blueprint, render_template, redirect, request, url_for, flash, g
from flask_login import login_user, logout_user, login_required, current_user
from .. import db
from app.database.model import User, PlatformSetting
from app.tool.email import send_email
from .forms import LoginForm, RegistrationForm, ChangePasswordForm, PasswordResetRequestForm, PasswordResetForm, ChangeEmailForm
from datetime import datetime
import hashlib
auth_blueprint = Blueprint('auth', __name__)
@auth_blueprint.before_request
def before_request():
setting = db.session.query(PlatformSetting).one()
g.platform_setting = setting
g.config = {}
g.config['jquery_js_url'] = config.jquery_js_url
g.config['semantic_js_url'] = config.semantic_js_url
g.config['semantic_css_url'] = config.semantic_css_url
g.config['background_image'] = config.background_image
"""
beartoday
2014.10.01 beartoday
"""
from app.tool.tools import dbg
dbg('main.py')
import os
from app import create_app
main = create_app(os.getenv('BT_CONFIG') or 'default')
