def forgot():
error = ''
alias = ''
if request.method == 'POST':
# TODO 设置依据IP可能会有校园网访问的问题
l = Limit.get(LIMIT.FORGOT_PASSWORD % request.remote_addr)
if l.is_limited():
abort(429)
l.touch()
alias = request.form.get('alias')
try:
alias_type = validate_reset_password_asker(alias)
user = Account.get_by_alias(alias)
except AccountAliasValidationError as e:
error = unicode(e)
else:
if alias_type == ACCOUNT_REG_TYPE.EMAIL:
send_reset_password_mail(user)
return render_template(
'accounts/forgot_password_mail_sent.html', alias=alias)
elif alias_type == ACCOUNT_REG_TYPE.MOBILE:
return render_template(
'accounts/reset_mobile_user_password.html', mobile=alias)
return render_template('accounts/forgot_password.html',
alias=alias,
error=error)
def confirm_action(action, token):
serializer = URLSafeTimedSerializer(app.config['SECRET_KEY'])
try:
email, tag = serializer.loads(token, salt=action, max_age=app.config['TOKEN_EXPIRATION'])
except:
return render_template('confirm_failed.mak', reason='other')
# Add or remove db info
from personal_site.app import db
if action == 'subscribe':
# Do not allow subscriptions if e-mail is currently disabled
if not app.config['EMAIL_ENABLED']:
return render_template('confirm_failed.mak', reason='disabled')
tag_info = Tag.query.filter(Tag.tagname == tag).first_or_404()
entry = Email(address=email, tag_id=tag_info.id)
db.session.add(entry)
db.session.commit()
elif action == 'unsubscribe':
tag_info = Tag.query.filter(Tag.tagname == tag).first_or_404()
deletion = Email.query.filter(Email.address == email).filter(Email.tag_id == tag_info.id).first_or_404()
db.session.delete(deletion)
db.session.commit()
return render_template('confirm_succeeded.mak', action=action, tag=tag)
def consulting():
if not g.user:
if not session.get('uuid'):
session['uuid'] = str(uuid.uuid4())
if not session.get('ins_plan_consulting_log'):
rsyslog.send(session['uuid'] + '\t' + request.remote_addr,
tag='ins_plan_consulting')
session['ins_plan_consulting_log'] = 'logged'
session_dict = {}
if session.get('ins_plan'):
session_dict = json.loads(session.get('ins_plan'))
session_dict['is_login'] = False
return render_template('ins/plan_consulting.html',
plan=json.dumps(session_dict))
else:
user_id = g.user.id
plan_id = request.args.get('plan_id')
if not plan_id and not Plan.get_user_plan_dict(user_id):
return render_template('ins/plan_consulting.html',
plan=session.get('ins_plan', '{}'))
if plan_id and Plan.belong_to_user(plan_id, g.user.id):
plan_dict = Plan.get(plan_id).data.data
plan_json_str = session.get('login_ins_plan' + str(plan_id))
if plan_json_str:
session_plan = json.loads(plan_json_str)
plan_dict.update(session_plan)
plan_dict['is_login'] = True
plan_json = json.dumps(plan_dict)
session['plan_id'] = plan_id
return render_template('ins/plan_consulting.html', plan=plan_json)
return redirect(url_for('ins.plan.index'))
def subscribe(slug):
# If e-mail is turned off, you should not be here!
if not app.config['EMAIL_ENABLED']:
return render_template('confirm_failed.mak', reason='disabled')
tag = Tag.query.filter(Tag.slug == slug).first_or_404()
if request.method == 'POST':
form = MailingSubscribeForm(request.form)
if form.validate():
# Generate confirmation token and URL
confirm_token = generate_token(form.email.data, tag.tagname, 'subscribe')
confirm_url = request.url_root.rstrip('/') + url_for('mailing.confirm_action', action='subscribe', token=confirm_token)
# Send confirmation e-mail, display confirmation message
confirm_message = '<p>You are receiving this e-mail because you signed up to receive email updates from kelsilindblad.com. To confirm your interest, please click the link below to complete your registration.<p><p><a href="{}">{}</a></p>'.format(confirm_url, confirm_url)
send_mail([form.email.data], 'kelsilindblad.com Mailing List Confirmation', confirm_message)
return render_template('subscribe_confirm.mak', email=form.email.data)
else:
form = MailingSubscribeForm()
return render_template('subscribe.mak', tag=tag, form=form)
def inner(*args, **kwargs):
try:
return func(*args, **kwargs)
except TemplateError as exc:
app.logger.error(u"Caught exception:\n{0}".format(exc.text))
return render_template("error.mako", traceback=exc.text)
except Exception:
app.logger.exception(u"Caught exception:")
return render_template("error.mako", traceback=format_exc())
def upload():
if request.method == 'POST':
eassy = request.form.get("comment")
if not eassy:
return render_template('index.html')
if eassy[:3] == codecs.BOM_UTF8:
eassy = eassy[3:]
check_result = check_essay(eassy)
print(check_result)
try:
return render_template('demo.html', **check_result)
except Exception as e:
print(e.text)
return render_template('index.html')
def invite():
code = request.args.get('inviter',
None) or request.cookies.get(INVITER_KEY)
is_lottery = request.args.get('lottery', False)
if not code:
return abort(404)
# 兼容已分享错误链接
rs = re.search('^(\d+).*', code)
if not rs:
abort(404)
code = rs.group(1)
user_id = transform_digit(code)
if g.user:
if g.user.id_ == str(user_id):
if not is_lottery:
return redirect(url_for('.mine'))
g.firewood_flow = FirewoodWorkflow(g.user.id_)
if not g.firewood_flow.account_uid:
return redirect(
url_for('profile.auth.supply', next=request.path))
user_lottery = UserLottery.get(g.user.id_)
return render_template('activity/lottery/index.html',
remain_num=user_lottery.remain_num)
else:
return redirect(url_for('.login'))
user = Account.get(user_id)
if not user:
abort(404)
UserLotteryNum.add_by_share(user.id_)
@after_this_request
def set_cookie(response):
response.set_cookie(key=INVITER_KEY,
value=str(code),
expires=datetime.now() +
timedelta(hours=INVITER_KEY_EXPIRE_HOURS))
return response
identity = Identity.get(user_id)
inviter_name = identity.masked_name if identity else generate_nickname(
user.mobile, ACCOUNT_REG_TYPE.MOBILE)
return render_template('invite/invite.html', inviter_name=inviter_name)
def index():
if request.method == 'POST':
uploaded_file = request.files['file']
w = request.form.get('w')
h = request.form.get('h')
if not uploaded_file:
return abort(400)
if w and h:
paste_file = PasteFile.create_file_after_crop(uploaded_file, w, h)
else:
paste_file = PasteFile.create_by_upload_file(uploaded_file)
db.session.add(paste_file)
db.session.commit()
return jsonify({
'url_d': paste_file.url_d,
'url_i': paste_file.url_i,
'url_s': paste_file.url_s,
'url_p': paste_file.url_p,
'filename': paste_file.filename,
'size': paste_file.size_humanize,
'time': str(paste_file.uploadtime),
'type': paste_file.type,
'quoteurl': paste_file.quoteurl
})
return render_template('index.html', **locals())
def weixin(signed_openid):
aliases = g.user.get_type_alias()
is_bound = ACCOUNT_REG_TYPE.WEIXIN_OPENID in aliases
# decrypt the openid (sender) which provided by weixin
serializer = URLSafeSerializer(current_app.secret_key)
try:
openid = serializer.loads(signed_openid)
except BadSignature:
return u'bad signature', 403
if request.method == 'GET':
return render_template('mine/alias/weixin.html', is_bound=is_bound)
# overrides method with a hidden field
if request.method == 'POST':
if request.form['method'] == 'post':
# bind to current account
g.user.add_alias(openid, ACCOUNT_REG_TYPE.WEIXIN_OPENID)
return redirect('/mine/plan')
if request.form['method'] == 'delete':
g.user.remove_alias(ACCOUNT_REG_TYPE.WEIXIN_OPENID)
return redirect(request.path)
abort(400)
def reset_for_mail_user(user_id, code):
error = ''
user = Account.get(user_id)
if not user:
return redirect(url_for('.reset_failed'))
try:
# 当post时才删除验证码
v = Verify.validate(user.id_, code,
VERIFY_CODE_TYPE.FORGOT_PASSWORD_EMAIL)
if request.method == 'POST':
v.delete()
except VerifyCodeException as e:
return redirect(url_for('.reset_failed'))
if request.method == 'POST':
# 校验密码是否合法一致
new_password = request.form.get('new-password')
confirmed_password = request.form.get('confirmed-password')
try:
reset_password(user, new_password, confirmed_password)
except PasswordValidationError as e:
error = unicode(e)
else:
return redirect(url_for('.reset_success'))
return render_template('accounts/reset_mail_user_password.html',
error=error)
def submitted():
return render_template(
"submitted.mako",
data=trackon.submitted_data,
size=len(trackon.submitted_trackers),
active="submitted",
)
def get(self):
url = request.args.get('url', '')
url_pattern = url.rsplit('/', 1)[0]
keyboards = KEYBOARD_URL_MAPS['default']
if url_pattern in KEYBOARD_URL_MAPS:
keyboards += KEYBOARD_URL_MAPS[url_pattern]
return render_template('widgets/keyboard.html', keyboards=keyboards)
def index():
if request.method == 'POST':
uploaded_file = request.files['file']
w = request.form.get('w')
h = request.form.get('h')
if not uploaded_file:
return abort(400)
if w and h:
paste_file = PasteFile.create_file_after_crop(uploaded_file, w, h)
else:
paste_file = PasteFile.create_by_upload_file(uploaded_file)
db.session.add(paste_file)
db.session.commit()
return jsonify({
'url_d': paste_file.url_d,
'url_i': paste_file.url_i,
'url_s': paste_file.url_s,
'url_p': paste_file.url_p,
'filename': paste_file.filename,
'size': paste_file.size_humanize,
'time': str(paste_file.uploadtime),
'type': paste_file.type,
'quoteurl': paste_file.quoteurl
})
return render_template('index.html', **locals())
def test_standard_variables(self):
"""
Tests that the variables generally available to Flask Jinja
templates are also available to Mako templates.
"""
self._add_template(
"vars", """
${config['MAKO_INPUT_ENCODING']}
${request.args}
${session.new}
${url_for('test')}
${get_flashed_messages()}
${injected()}
""")
with self.test_renderer() as (app, mako):
@app.route('/test')
def test():
return "test"
@app.context_processor
def inject():
return {"injected": lambda: "injected"}
result = render_template("vars")
def get(self):
url = request.args.get('url', '')
url_pattern = url.rsplit('/', 1)[0]
keyboards = KEYBOARD_URL_MAPS['default']
if url_pattern in KEYBOARD_URL_MAPS:
keyboards += KEYBOARD_URL_MAPS[url_pattern]
return render_template('widgets/keyboard.html', keyboards=keyboards)
def fetch_digest(asset_id):
error = ''
asset = ZhiwangAsset.get(asset_id)
if not asset:
abort(404)
if not asset.is_owner(g.user):
abort(403)
loans_digest = ZhiwangLoansDigest.get_by_asset_id(asset.id_)
if loans_digest:
l = Limit.get(LIMIT.USER_FETCH_ZW_LOANS % g.user.id_,
timeout=FETCH_LOANS_TIMEOUT,
limit=FETCH_LOANS_LIMIT_TIMES)
loans_digest = fetch_loans_digest(
asset) if not l.is_limited() else loans_digest
l.touch()
else:
try:
loans_digest = fetch_loans_digest(asset)
except FetchLoansDigestError as e:
error = unicode(e)
return render_template('savings/loans.html',
loans_digest=loans_digest,
error=error)
def planning(plan_id):
if g.user:
if Plan.belong_to_user(plan_id, g.user.id):
return render_template('ins/plan_planning.html',
**Plan.get_user_plan_by_id(plan_id))
else:
return redirect(url_for('ins.plan.index'))
def get(self, slug):
category = Category.objects.get_or_404(_slug=slug)
posts = Post.objects.filter(
category=category).order_by("-recent_activity_time")
return render_template('categories/list.html',
category=category.name,
posts=posts)
def xm_contract(order_id):
"""新米购买合同.
reqheader Authorization: OAuth 2.0 Bearer Token
:status 200: 返回 :class:`.XinmiContractSchema`
:status 403: 获取合同失败
:status 404: 无相应产品
"""
contract_schema = XinmiContractSchema(strict=True)
order = obtain_xm_order(order_id)
asset = XMAsset.get_by_order_code(order.order_code)
if not asset or not g.xm_account:
abort(401)
identity = Identity.get(asset.user_id)
upper_amount = num2chn(asset.create_amount)
product = XMFixedDuedayProduct.get(asset.product_id)
if not product:
abort(404)
expect_rate = 100
if product.product_type is XMFixedDuedayProduct.Type.classic:
expect_rate = round_half_up(
(asset.actual_annual_rate * 90 / 365 + 1) * 100, 4)
if not asset:
abort(403, u'资产合同正在准备中')
contract = render_template('savings/agreement_xinmi.html',
asset=asset,
identity=identity,
expect_rate=expect_rate,
product_name=product.name,
product_frozen_days=product.frozen_days,
upper_amount=upper_amount)
data = {'contract': contract}
return jsonify(success=True, data=contract_schema.dump(data).data)
def index() -> str:
"""
The most important view. Currently doesn't do anything :(
"""
return render_template('home/index.mako',
message='Welcome to the dog training app!')
def course_index(courses_url, course_link):
lang = courses.langs[courses_url]
course = courses.get(lang, course_link)
return render_template(f'{courses_url}/{course_link}/index.mako',
course=course,
lang=lang)
def settings():
status = process_settings() if request.method == "POST" else None
update_sites()
default = cache.bot.wiki.get_site()
kwargs = {"status": status, "default_lang": default.lang,
"default_project": default.project}
return render_template("settings.mako", **kwargs)
def result():
if g.user:
report = Report.get_by_user_id(g.user.id)
if not report or report.is_deprecated:
wxplan = session.get('wxplan')
if not wxplan:
return redirect(url_for('.info'))
plan = PlanData.from_dict(wxplan)
plan = plan.assign_to_user(g.user.id)
formula = Formula(plan=plan)
report = formula.gen_report()
else:
plan = PlanData.get_by_user_id(g.user.id)
if not plan:
return redirect(url_for('.info'))
weekly_annual_rates = []
latest_rate = 0
if report.pocket_money > 0:
dashboard = PublicDashboard.today()
weekly_annual_rates = [(unicode(r.date),
round_half_up(r.annual_rate, 2))
for r in dashboard.weekly_annual_rates]
latest_rate = round_half_up(
dashboard.latest_annual_rate.annual_rate, 2)
return render_template(
'plan/detail_result.html',
report=report,
plan=plan,
weekly_annual_rates=weekly_annual_rates,
latest_rate=latest_rate,
monthly_mortgages=report.get_monthly_mortgages(),
rent_data=report.get_rent_data())
return redirect(url_for('.brief'))
def info():
redo = request.args.get('redo')
if not redo:
if g.user:
report = Report.get_by_user_id(g.user.id)
plan = PlanData.get_by_user_id(g.user.id)
if report and not report.is_deprecated:
return redirect(url_for('.result'))
if plan:
session['wxplan'] = plan.to_dict()
return redirect(url_for('.brief'))
wxplan = session.get('wxplan')
if wxplan:
return redirect(url_for('.brief'))
if g.user:
report = Report.get_by_user_id(g.user.id)
if report:
report.deprecate()
show_mask = request.args.get('mask')
china = location.Location.get('100000')
user_count = get_user_count()
wxplan = session.get('wxplan')
return render_template('plan/info.html',
location=china,
user_count=user_count,
wxplan=wxplan,
show_mask=show_mask)
def purchase(product_id):
cur_path = 'record'
partner = Partner.xm
agreement_url = url_for('savings.landing.agreement_xinmi')
banks = iter_banks(g.user.id_)
bankcards = g.xinmi_profile.bankcards.get_all()
raw_product = XMFixedDuedayProduct.get(product_id) or abort(404)
coupons = [
c.to_dict() for c in g.coupon_manager.available_coupons
if c.is_available_for_product(raw_product)
]
context = {
'coupons': coupons,
'banks': banks,
'bankcards': bankcards,
'partner': partner,
'product_type': 'regular',
'user_balance': g.firewood_flow.balance,
'cur_path': cur_path,
'product': raw_product,
'agreement_url': agreement_url
}
return render_template('savings/order.html', **context)
def test_multiple_apps(self):
""" Tests that the Mako plugin works with multiple Flask apps. """
self._add_template("app", "test 1", "alt1")
self._add_template("app", "test 2", "alt2")
alt1_dir = os.path.join(self.root, "alt1")
alt2_dir = os.path.join(self.root, "alt2")
with self.test_renderer() as (app, mako):
app.template_folder = alt1_dir
self.assertEqual(render_template('app'), b'test 1')
with self.test_renderer(MAKO_CACHE_DIR=None) as (app, _):
app.template_folder = alt2_dir
self.assertEqual(render_template('app'), b'test 2')
with self.assertRaises(RuntimeError):
mako.init_app(Flask(__name__))
def login():
login_form = LoginForm()
if request.method == 'POST':
username = request.form.get('username')
password = request.form.get('password')
user = DBUser.query.filter(DBUser.user_id == username).first()
if user and password == user.password:
curr_user = FlaskUser()
curr_user.id = user.index
curr_user.username = username
# 通过Flask-Login的login_user方法登录用户
login_user(curr_user)
return jsonify({
'status': 0,
'message': None,
})
else:
if not user:
return jsonify({
'status': 1,
'message': '用户名不存在',
})
else:
return jsonify({
'status': 1,
'message': '密码错误',
})
# GET 请求
else:
if current_user.is_authenticated:
return redirect(url_for('index'))
return render_template('login.html', form=login_form)
def register():
register_form = RegisterForm()
if request.method == 'POST':
username = request.form.get('username')
password = request.form.get('password')
user = DBUser.query.filter(DBUser.user_id == username).first()
if user:
return jsonify({
'status': 1,
'message': '用户名已经注册',
})
db.session.add(DBUser(
user_id=username,
password=password,
))
curr_user = FlaskUser()
curr_user.id = DBUser.query.filter(
DBUser.user_id == username).first().index
curr_user.username = username
login_user(curr_user)
return jsonify({
'status': 0,
'message': None,
})
# GET 请求
else:
if current_user.is_authenticated:
return redirect(url_for('index'))
return render_template('register.html', form=register_form)
def upload_file():
if request.method == 'POST':
file = request.files['file']
eassy = file.read()
if not eassy:
return render_template('index.html')
if eassy[:3] == codecs.BOM_UTF8:
eassy = eassy[3:]
check_result = check_essay(eassy)
print(check_result)
try:
return render_template('demo.html', **check_result)
except Exception as e:
print(e.text)
return render_template('index.html')
def p2p():
cur_path = 'p2p'
ps = P2P.get_all()
p2p_property = [('预期年化收益率', 'year_rate'), ('返还方式', 'pay_return_type'),
('投资期限', 'deadline'), ('购买起点', 'min_money'),
('保障', 'protect')]
return render_template('product/p2p.html', **locals())
def index():
notice = get_notice()
update_sites()
query = do_check()
return render_template(
"index.mako", notice=notice, query=query, result=query.result,
turnitin_result=query.turnitin_result)
def section(chapter, section):
chapter = secure_filename(chapter)
section = secure_filename(section)
path = os.path.join(BOOK_DIR, chapter, section)
with codecs.open(path, 'r', 'utf-8') as f:
content = f.read()
content = Markup(markdown(content))
return render_template('page.html', **locals())
def tag_index():
from personal_site.app import db
tags = db.session.query(Tag.tagname, Tag.slug, func.count(
Tag.tagname)).group_by(Tag.tagname).order_by(Tag.tagname).all()
return render_template('tags.mak', tags=tags)
def render_page(template_name):
"""
Render templates by template_name.
"""
try:
return render_template(template_name + '.html')
except TopLevelLookupException:
abort(404)
def static_page(page_name):
"""
Template generator.
"""
try:
return render_template('{}.html'.format(page_name))
except (TemplateNotFound, TopLevelLookupException):
abort(404)
def render_by_name(name):
"""
Renders template that matches given name.
"""
try:
return render_template('{}.html'.format(name))
except exceptions.TopLevelLookupException:
abort(404)
def render_page(template_name):
"""
Render templates by template_name.
"""
try:
return render_template(template_name + '.html')
except TopLevelLookupException:
abort(404)
def get(self, slug):
category = Category.objects.get_or_404(_slug=slug)
posts = Post.objects.filter(
category=category
).order_by("-recent_activity_time")
return render_template('categories/list.html',
category=category.name,
posts=posts)
def index():
# not logged in, redirect
# if 'logged_in' not in session:
# return redirect(url_for('login'))
# process POST request
if request.method == 'POST':
pass
return render_template('index.html', error=None)
def _deco(*args, **kwargs):
template_name = template
if template_name is None:
template_name = request.endpoint.replace(".", "/") + ".html"
ctx = f(*args, **kwargs)
if ctx is None:
ctx = {}
elif not isinstance(ctx, dict):
return ctx
return render_template(template_name, **ctx)
def render_templates(template_name):
"""
Render .html file to view.
"""
if not template_name.endswith('.html'):
template_name = '{}.html'.format(template_name)
try:
return render_template(template_name, name=template_name)
except (TemplateError, TopLevelLookupException):
abort(404)
def data():
# not logged in, redirect
# if 'logged_in' not in session:
# return redirect(url_for('login'))
# process POST request
if request.method == 'POST':
pass
available_sources = [name for name in os.listdir('http_server/static/author_corpus/') if not name.startswith('.')]
return render_template('data.html', error=None, sources=available_sources)
def verify_pin():
pin = request.form["pin"]
token = session["token"]
redirect_url = current_app.al.get_redirect_url(token)
try:
current_app.al.create_account_step3(token, pin)
except ALserviceNotAValidPin:
return render_template(
"save_account.mako", form_action="/verify_token", pin_error=True, language=session["language"]
)
return redirect(redirect_url)
def api_json():
if not request.args:
return render_template("api.mako", help=True)
format = request.args.get("format", "json")
if format in ["json", "jsonfm"]:
update_sites()
try:
result = handle_api_request()
except Exception as exc:
result = format_api_error("unhandled_exception", exc)
else:
errmsg = u"Unknown format: '{0}'".format(format)
result = format_api_error("unknown_format", errmsg)
if format == "jsonfm":
return render_template("api.mako", help=False, result=result)
resp = make_response(dumps(result))
resp.mimetype = "application/json"
resp.headers["Access-Control-Allow-Origin"] = "*"
return resp
def render_correct_template(template_name):
"""
Check and render correct template for given url.
"""
try:
return render_template(template_name + '.html')
except TopLevelLookupException:
LOG.debug('Template %s.html not found.', template_name)
abort(404)
except exceptions.html_error_template().render():
LOG.debug('Template error in %s.html.', template_name)
abort(500)
def verify_token():
if not change_language():
token = request.form.get("token", session.get("token"))
if not token:
abort(400)
session["token"] = token
try:
current_app.al.create_account_step2(token)
except (ALserviceTokenError, ALserviceTicketError):
return render_template(
"token_was_sent.mako",
form_action="/verify_token",
email=session["email"],
token_error=True,
language=session["language"],
)
return render_template(
"save_account.mako", form_action="/verify_token", pin_error=False, language=session["language"]
)
def handle_exception(e):
log.exception('Exception during request')
try:
return render_template(current_app.config['STATUS_TEMPLATE'],
status=DummyStatus(500, 'Internal Server Error', ''),
traceback=traceback.format_exc() if app.debug else None,
), 500
except KeyError:
return InternalServerError()
except TemplateError as e2:
text = e2.text.strip()
log.error('Exception during error template rendering\n' + text)
return e
def post(self, id):
context = self.get_context(id)
form = context.get('form')
if form.validate():
comment = Comment()
form.populate_obj(comment)
post = context.get('post')
post.comments.append(comment)
post.save()
return redirect(url_for('post.detail', id=id))
return render_template('posts/detail.html', **context)
def render_consent(language: str, requester_name: str, locked_attr: list, released_claims: dict, state: str,
months: list, select_attributes: bool) -> str:
if not isinstance(locked_attr, list):
locked_attr = [locked_attr]
locked_claims = {k: released_claims.pop(k) for k in locked_attr if k in released_claims}
return render_template(
'consent.mako',
consent_question=None,
state=state,
released_claims=released_claims,
locked_claims=locked_claims,
form_action='/set_language',
language=language,
requester_name=requester_name,
months=months,
select_attributes=select_attributes)
def send_token():
if not change_language():
email = request.form.get("email", session.get("email"))
ticket = session.get("ticket")
if not email or not ticket:
abort(400)
session["email"] = email
current_app.al.create_account_step1(email, ticket)
return render_template(
"token_was_sent.mako",
form_action="/send_token",
email=session["email"],
token_error=False,
language=session["language"],
)
def preview(filehash):
paste_file = PasteFile.get_by_filehash(filehash)
filepath = get_file_path(filehash)
if not paste_file:
if not(os.path.exists(filepath) and (not os.path.islink(filepath))):
return abort(404)
linkfile = get_file_path(filehash.replace('.', '_'))
symlink = None
if os.path.exists(linkfile):
with open(linkfile) as fp:
symlink = fp.read().strip()
paste_file = PasteFile.create_by_old_paste(filehash, symlink)
db.session.add(paste_file)
db.session.commit()
return render_template('success.html', p=paste_file)
def approve(ticket):
template_params = dict(form_action="/approve/%s" % ticket, ticket=ticket, login_failed_message=False)
if not change_language():
session["ticket"] = ticket
# user has approved linking
if request.method == "POST":
email = request.form["email"]
pin = request.form["pin"]
redirect_url = current_app.al.get_redirect_url(ticket)
try:
current_app.al.link_key(email, pin, ticket)
return redirect(redirect_url)
except ALserviceAuthenticationError:
template_params["login_failed_message"] = True
template_params["language"] = session["language"]
return render_template("login.mako", **template_params)
def post(self, id):
if not current_user.is_authenticated():
abort(403)
context = self.get_context(id)
form = context.get('form')
if form.validate():
comment = Comment()
form.populate_obj(comment)
comment.author = User.objects.get_or_404(id=current_user.id)
comment.save()
post = context.get('post')
post.comments.append(comment)
post.save()
return redirect(url_for('post.detail', id=id))
return render_template('posts/detail.html', **context)
def handle_http_exception(e):
# Pass through non errors.
if e.code < 400:
return e
if e.code >= 500:
log.exception(str(e))
else:
log.warning(str(e))
try:
return render_template('/http_status.haml',
status=e,
traceback=traceback.format_exc() if app.debug else None,
), e.code
except TemplateError as e2:
text = e2.text.strip()
print 'HERE', text
log.error('Exception during error template rendering\n' + text)
return e
def get(self, id):
context = self.get_context(id)
Post.objects(id=id).update_one(inc__views=1)
return render_template('posts/detail.html', **context)
def mean_time_weekday():
"""
Renders mean_time_weekday template.
"""
return render_template('mean_time_weekday.html')
def presence_start_end():
"""
Renders presence_start_end template.
"""
return render_template('presence_start_end.html')
def create_account():
change_language()
return render_template("create_account.mako", form_action="/create_account", language=session["language"])
def get(self):
posts = Post.objects.all()
return render_template('index.html', posts=posts)
def api():
return render_template("api.mako", help=True)
