refactor: 重构Flask结构

app/__init__.py

@@ -0,0 +1,2 @@
+from .app import HBlogFlask, Hblog
+

app/about_me.py

@@ -0,0 +1,15 @@
+from flask import Blueprint, render_template
+import app
+
+about_me = Blueprint("about_me", __name__)
+
+
+@about_me.route('/')
+def about_me_page():
+    app.HBlogFlask.print_load_page_log("about me")
+    return render_template("about_me/about_me.html")
+
+
+@about_me.context_processor
+def inject_base():
+    return {"top_nav": ["", "", "", "", "active", ""]}

view/base.py → app/app.py

@@ -1,54 +1,79 @@
 import os.path
 import sys
 
-from flask import Flask, url_for, request, current_app
+from flask import Flask, url_for, request, current_app, g, render_template
 from flask_mail import Mail
 from flask_login import LoginManager, current_user
 from flask.logging import default_handler
-from typing import Optional
+from flask_pagedown import PageDown
+from typing import Optional, Union
 
 import logging.handlers
 import logging
 from configure import conf
-from core.user import AnonymousUser
+from object.user import AnonymousUser, load_user_by_email
 
+from .index import index
+from .archive import archive
+from .docx import docx
+from .msg import msg
+from .oss import oss
+from .auth import auth
+from .about_me import about_me
 
-class App:
-    def __init__(self, import_name: str):
-        self._app = Flask(import_name)
-        self._app.config["SECRET_KEY"] = conf['secret-key']
 
-        self.login_manager = LoginManager()
-        self.login_manager.init_app(self._app)
-        self.login_manager.anonymous_user = AnonymousUser  # 设置未登录的匿名对象
+class HBlogFlask(Flask):
+    def __init__(self, import_name: str, *args, **kwargs):
+        super(HBlogFlask, self).__init__(import_name, *args, **kwargs)
 
-        self._app.config["MAIL_SERVER"] = conf['email_server']
-        self._app.config["MAIL_PORT"] = conf['email_port']
-        self._app.config["MAIL_USE_TLS"] = conf['email_tls']
-        self._app.config["MAIL_USE_SSL"] = conf['email_ssl']
-        self._app.config["MAIL_USERNAME"] = conf['email_name']
-        self._app.config["MAIL_PASSWORD"] = conf['email_passwd']
+        self.register_blueprint(index, url_prefix="/")
+        self.register_blueprint(archive, url_prefix="/archive")
+        self.register_blueprint(docx, url_prefix="/docx")
+        self.register_blueprint(msg, url_prefix="/msg")
+        self.register_blueprint(auth, url_prefix="/auth")
+        self.register_blueprint(about_me, url_prefix="/about-me")
+        self.register_blueprint(oss, url_prefix="/oss")
 
-        self.mail = Mail(self._app)
-
-        self._app.logger.removeHandler(default_handler)
-        self._app.logger.setLevel(conf["log-level"])
-        self._app.logger.propagate = False
+        self.login_manager = LoginManager()
+        self.login_manager.init_app(self)
+        self.login_manager.anonymous_user = AnonymousUser  # 设置未登录的匿名对象
+        self.login_manager.login_view = "auth.login_page"
+
+        self.config["SECRET_KEY"] = conf['secret-key']
+        self.config["MAIL_SERVER"] = conf['email_server']
+        self.config["MAIL_PORT"] = conf['email_port']
+        self.config["MAIL_USE_TLS"] = conf['email_tls']
+        self.config["MAIL_USE_SSL"] = conf['email_ssl']
+        self.config["MAIL_USERNAME"] = conf['email_name']
+        self.config["MAIL_PASSWORD"] = conf['email_passwd']
+
+        self.mail = Mail(self)
+        self.pagedown = PageDown()
+        self.pagedown.init_app(self)
+
+        self.logger.removeHandler(default_handler)
+        self.logger.setLevel(conf["log-level"])
+        self.logger.propagate = False
         if conf["log-home"] is not None:
             handle = logging.handlers.TimedRotatingFileHandler(
                 os.path.join(conf["log-home"], f"flask-{os.getpid()}.log"))
             handle.setFormatter(logging.Formatter(conf["log-format"]))
-            self._app.logger.addHandler(handle)
+            self.logger.addHandler(handle)
         if conf["log-stderr"]:
             handle = logging.StreamHandler(sys.stderr)
             handle.setFormatter(logging.Formatter(conf["log-format"]))
-            self._app.logger.addHandler(handle)
+            self.logger.addHandler(handle)
 
-    def get_app(self) -> Flask:
-        return self._app
+        @self.login_manager.user_loader
+        def user_loader(email: str):
+            return load_user_by_email(email)
 
-    def run(self):
-        self.run()
+        func = {"render_template": render_template, "self": self}
+        for i in [400, 401, 403, 404, 405, 408, 410, 413, 414, 423, 500, 501, 502]:
+            exec(f"def error_{i}(e):\n"
+                 f"\tself.print_load_page_log('{i}')\n"
+                 f"\treturn render_template('error.html', error_code='{i}', error_info=e)", func)
+            self.errorhandler(i)(func[f"error_{i}"])
 
     @staticmethod
     def get_max_page(count: int, count_page: int):
@@ -101,44 +126,48 @@ class App:
     @staticmethod
     def print_load_page_log(page: str):
         current_app.logger.debug(
-            f"[{request.method}] Load - '{page}' " + App.__get_log_request_info())
+            f"[{request.method}] Load - '{page}' " + HBlogFlask.__get_log_request_info())
 
     @staticmethod
     def print_form_error_log(opt: str):
         current_app.logger.warning(
-            f"[{request.method}] '{opt}' - Bad form " + App.__get_log_request_info())
+            f"[{request.method}] '{opt}' - Bad form " + HBlogFlask.__get_log_request_info())
 
     @staticmethod
     def print_sys_opt_fail_log(opt: str):
         current_app.logger.error(
-            f"[{request.method}] System {opt} - fail " + App.__get_log_request_info())
+            f"[{request.method}] System {opt} - fail " + HBlogFlask.__get_log_request_info())
 
     @staticmethod
     def print_sys_opt_success_log(opt: str):
         current_app.logger.warning(
-            f"[{request.method}] System {opt} - success " + App.__get_log_request_info())
+            f"[{request.method}] System {opt} - success " + HBlogFlask.__get_log_request_info())
 
     @staticmethod
     def print_user_opt_fail_log(opt: str):
         current_app.logger.debug(
-            f"[{request.method}] User {opt} - fail " + App.__get_log_request_info())
+            f"[{request.method}] User {opt} - fail " + HBlogFlask.__get_log_request_info())
 
     @staticmethod
     def print_user_opt_success_log(opt: str):
         current_app.logger.debug(
-            f"[{request.method}] User {opt} - success " + App.__get_log_request_info())
+            f"[{request.method}] User {opt} - success " + HBlogFlask.__get_log_request_info())
 
     @staticmethod
     def print_user_opt_error_log(opt: str):
         current_app.logger.warning(
-            f"[{request.method}] User {opt} - system fail " + App.__get_log_request_info())
+            f"[{request.method}] User {opt} - system fail " + HBlogFlask.__get_log_request_info())
 
     @staticmethod
     def print_import_user_opt_success_log(opt: str):
         current_app.logger.info(
-            f"[{request.method}] User {opt} - success " + App.__get_log_request_info())
+            f"[{request.method}] User {opt} - success " + HBlogFlask.__get_log_request_info())
 
     @staticmethod
     def print_user_not_allow_opt_log(opt: str):
         current_app.logger.info(
-            f"[{request.method}] User '{opt}' - reject " + App.__get_log_request_info())
+            f"[{request.method}] User '{opt}' - reject " + HBlogFlask.__get_log_request_info())
+
+
+Hblog = Union[HBlogFlask, Flask]
+

view/archive.py → app/archive.py

@@ -1,15 +1,13 @@
-from flask import Flask, Blueprint, render_template, abort, redirect, url_for, flash, current_app, request
-from typing import Optional
+from flask import Blueprint, render_template, abort, redirect, url_for, flash, current_app, request
 from flask_login import login_required, current_user
 from flask_wtf import FlaskForm
 from wtforms import StringField, SubmitField
 from wtforms.validators import DataRequired, Length
 
-from view.base import App
-from core.archive import Archive
+import app
+from object.archive import Archive
 
 archive = Blueprint("archive", __name__)
-app: Optional[Flask] = None
 
 
 class CreateArchiveForm(FlaskForm):
@@ -21,7 +19,7 @@ class CreateArchiveForm(FlaskForm):
 @archive.route('/')
 def archive_page():
     archive_list = Archive.get_archive_list()
-    ArchiveApp.print_load_page_log("archive list")
+    app.HBlogFlask.print_load_page_log("archive list")
     return render_template("archive/archive.html",
                            archive_list=archive_list,
                            form=CreateArchiveForm(),
@@ -34,15 +32,15 @@ def create_archive_page():
     form = CreateArchiveForm()
     if form.validate_on_submit():
         if not current_user.check_role("WriteBlog"):  # 检查相应的权限
-            ArchiveApp.print_user_not_allow_opt_log("Create archive")
+            app.HBlogFlask.print_user_not_allow_opt_log("Create archive")
             abort(403)
             return
 
         if Archive(form.name.data, form.describe.data, None).create():
-            ArchiveApp.print_sys_opt_success_log(f"Create archive {form.name.data}")
+            app.HBlogFlask.print_sys_opt_success_log(f"Create archive {form.name.data}")
             flash(f"创建归档 {form.name.data} 成功")
         else:
-            ArchiveApp.print_sys_opt_fail_log(f"Create archive {form.name.data}")
+            app.HBlogFlask.print_sys_opt_fail_log(f"Create archive {form.name.data}")
             flash(f"创建归档 {form.name.data} 失败")
         return redirect(url_for("archive.archive_page"))
     current_app.logger.warning("Create archive with error form.")
@@ -53,15 +51,15 @@ def create_archive_page():
 @login_required
 def delete_archive_page(archive_id: int):
     if not current_user.check_role("DeleteBlog"):
-        ArchiveApp.print_user_not_allow_opt_log("Delete archive")
+        app.HBlogFlask.print_user_not_allow_opt_log("Delete archive")
         abort(403)
         return
 
     if Archive(None, None, archive_id).delete():
-        ArchiveApp.print_sys_opt_success_log(f"Delete archive {archive_id}")
+        app.HBlogFlask.print_sys_opt_success_log(f"Delete archive {archive_id}")
         flash("归档删除成功")
     else:
-        ArchiveApp.print_sys_opt_fail_log(f"Delete archive {archive_id}")
+        app.HBlogFlask.print_sys_opt_fail_log(f"Delete archive {archive_id}")
         flash("归档删除失败")
     return redirect(url_for("archive.archive_page"))
 
@@ -69,12 +67,3 @@ def delete_archive_page(archive_id: int):
 @archive.context_processor
 def inject():
     return {"top_nav": ["", "active", "", "", "", ""]}
-
-
-class ArchiveApp(App):
-    def __init__(self, import_name):
-        super(ArchiveApp, self).__init__(import_name)
-
-        global app
-        app = self._app
-        app.register_blueprint(archive, url_prefix="/archive")

view/auth.py → app/auth.py

@@ -1,18 +1,14 @@
-from flask import Flask, Blueprint, render_template, redirect, flash, url_for, request, abort, current_app
+from flask import Blueprint, render_template, redirect, flash, url_for, request, abort, current_app, g
 from flask_login import login_required, login_user, current_user, logout_user
-from flask_mail import Mail
 from flask_wtf import FlaskForm
 from wtforms import StringField, PasswordField, BooleanField, SubmitField, ValidationError
 from wtforms.validators import DataRequired, Length, EqualTo
-from typing import Optional
 
-from view.base import App
-from core.user import User, load_user_by_email
+import app
+from object.user import User, load_user_by_email
 from send_email import send_msg
 
 auth = Blueprint("auth", __name__)
-app: Optional[Flask] = None
-mail: Optional[Mail] = None
 
 
 class LoginForm(FlaskForm):
@@ -74,14 +70,14 @@ class SetRoleForm(FlaskForm):
 @login_required
 def yours_page():
     msg_count, comment_count, blog_count = current_user.count_info()
-    AuthApp.print_load_page_log("user info")
+    app.HBlogFlask.print_load_page_log("user info")
     return render_template("auth/yours.html", msg_count=msg_count, comment_count=comment_count, blog_count=blog_count)
 
 
 @auth.route('/login', methods=["GET", "POST"])
 def login_page():
     if current_user.is_authenticated:
-        AuthApp.print_user_not_allow_opt_log("login")
+        app.HBlogFlask.print_user_not_allow_opt_log("login")
         return redirect(url_for("auth.yours_page"))
 
     form = LoginForm()
@@ -93,30 +89,31 @@ def login_page():
             if next_page is None or not next_page.startswith('/'):
                 next_page = url_for('base.index_page')
             flash("登陆成功")
-            AuthApp.print_user_opt_success_log(f"login {form.email.data}")
+            app.HBlogFlask.print_user_opt_success_log(f"login {form.email.data}")
             return redirect(next_page)
         flash("账号或密码错误")
-        AuthApp.print_user_opt_fail_log(f"login {form.email.data}")
+        app.HBlogFlask.print_user_opt_fail_log(f"login {form.email.data}")
         return redirect(url_for("auth.login_page"))
-    AuthApp.print_load_page_log("user login")
+    app.HBlogFlask.print_load_page_log("user login")
     return render_template("auth/login.html", form=form)
 
 
 @auth.route('/register', methods=["GET", "POST"])
 def register_page():
     if current_user.is_authenticated:
-        AuthApp.print_user_not_allow_opt_log("register")
+        app.HBlogFlask.print_user_not_allow_opt_log("register")
         return redirect(url_for("auth.yours_page"))
 
     form = RegisterForm()
     if form.validate_on_submit():
         token = User.creat_token(form.email.data, form.passwd.data)
         register_url = url_for("auth.confirm_page", token=token, _external=True)
-        send_msg("注册确认", mail, form.email.data, "register", register_url=register_url)
+        hblog: app.Hblog = current_app
+        send_msg("注册确认", hblog.mail, form.email.data, "register", register_url=register_url)
         flash("注册提交成功, 请进入邮箱点击确认注册链接")
-        AuthApp.print_import_user_opt_success_log(f"register {form.email.data}")
+        app.HBlogFlask.print_import_user_opt_success_log(f"register {form.email.data}")
         return redirect(url_for("base.index_page"))
-    AuthApp.print_load_page_log("user register")
+    app.HBlogFlask.print_load_page_log("user register")
     return render_template("auth/register.html", RegisterForm=form)
 
 
@@ -124,24 +121,24 @@ def register_page():
 def confirm_page():
     token = request.args.get("token", None)
     if token is None:
-        AuthApp.print_user_opt_fail_log(f"Confirm (bad token)")
+        app.HBlogFlask.print_user_opt_fail_log(f"Confirm (bad token)")
         abort(404)
         return
 
     token = User.load_token(token)
     if token is None:
-        AuthApp.print_user_opt_fail_log(f"Confirm (bad token)")
+        app.HBlogFlask.print_user_opt_fail_log(f"Confirm (bad token)")
         abort(404)
         return
 
     if load_user_by_email(token[0]) is not None:
-        AuthApp.print_user_opt_fail_log(f"Confirm (bad token)")
+        app.HBlogFlask.print_user_opt_fail_log(f"Confirm (bad token)")
         abort(404)
         return
 
     User(token[0], token[1], None, None).create()
     current_app.logger.info(f"{token[0]} confirm success")
-    AuthApp.print_import_user_opt_success_log(f"confirm {token[0]}")
+    app.HBlogFlask.print_import_user_opt_success_log(f"confirm {token[0]}")
     flash(f"用户{token[0]}认证完成")
     return redirect(url_for("base.index_page"))
 
@@ -149,7 +146,7 @@ def confirm_page():
 @auth.route('/logout')
 @login_required
 def logout_page():
-    AuthApp.print_import_user_opt_success_log(f"logout")
+    app.HBlogFlask.print_import_user_opt_success_log(f"logout")
     logout_user()
     flash("退出登录成功")
     return redirect(url_for("base.index_page"))
@@ -161,17 +158,17 @@ def change_passwd_page():
     form = ChangePasswdForm()
     if form.validate_on_submit():
         if not current_user.check_passwd(form.old_passwd.data):
-            AuthApp.print_user_opt_fail_log("change passwd (old passwd error)")
+            app.HBlogFlask.print_user_opt_fail_log("change passwd (old passwd error)")
             flash("旧密码错误")
             return redirect(url_for("auth.change_passwd_page"))
         if current_user.change_passwd(form.passwd.data):
-            AuthApp.print_user_opt_success_log(f"change passwd")
+            app.HBlogFlask.print_user_opt_success_log(f"change passwd")
             flash("密码修改成功")
         else:
-            AuthApp.print_user_opt_error_log(f"change passwd")
+            app.HBlogFlask.print_user_opt_error_log(f"change passwd")
             flash("密码修改失败")
         return redirect(url_for("auth.yours_page"))
-    AuthApp.print_load_page_log("user change passwd")
+    app.HBlogFlask.print_load_page_log("user change passwd")
     return render_template("auth/passwd.html", ChangePasswdForm=form)
 
 
@@ -179,7 +176,7 @@ def change_passwd_page():
 @login_required
 def delete_user_page():
     if not current_user.check_role("DeleteUser"):
-        AuthApp.print_user_not_allow_opt_log("delete user")
+        app.HBlogFlask.print_user_not_allow_opt_log("delete user")
         abort(403)
         return
 
@@ -187,18 +184,18 @@ def delete_user_page():
     if form.validate_on_submit():
         user = load_user_by_email(form.email.data)
         if user is None:
-            AuthApp.print_sys_opt_fail_log(f"delete user {form.email.data}")
+            app.HBlogFlask.print_sys_opt_fail_log(f"delete user {form.email.data}")
             abort(404)
             return
 
         if user.delete():
-            AuthApp.print_sys_opt_success_log(f"{current_user.email} delete user {form.email.data} success")
+            app.HBlogFlask.print_sys_opt_success_log(f"{current_user.email} delete user {form.email.data} success")
             flash("用户删除成功")
         else:
-            AuthApp.print_sys_opt_fail_log(f"{current_user.email} delete user {form.email.data} fail")
+            app.HBlogFlask.print_sys_opt_fail_log(f"{current_user.email} delete user {form.email.data} fail")
             flash("用户删除失败")
         return redirect(url_for("auth.delete_user_page"))
-    AuthApp.print_load_page_log("delete user")
+    app.HBlogFlask.print_load_page_log("delete user")
     return render_template("auth/delete.html", DeleteUserForm=form)
 
 
@@ -206,11 +203,11 @@ def delete_user_page():
 @login_required
 def role_page():
     if not current_user.check_role("ConfigureSystem"):
-        AuthApp.print_user_not_allow_opt_log("load role setting")
+        app.HBlogFlask.print_user_not_allow_opt_log("load role setting")
         abort(403)
         return
 
-    AuthApp.print_load_page_log("role setting")
+    app.HBlogFlask.print_load_page_log("role setting")
     return render_template("auth/role.html",
                            CreateRoleForm=CreateRoleForm(),
                            DeleteRoleForm=DeleteRoleForm(),
@@ -223,15 +220,15 @@ def role_create_page():
     form = CreateRoleForm()
     if form.validate_on_submit():
         if not current_user.check_role("ConfigureSystem"):
-            AuthApp.print_user_not_allow_opt_log("create role")
+            app.HBlogFlask.print_user_not_allow_opt_log("create role")
             abort(403)
             return
 
         if User.create_role(form.name.data, form.authority.data.replace(" ", "").split(";")):
-            AuthApp.print_sys_opt_success_log(f"Create role success: {form.name.data}")
+            app.HBlogFlask.print_sys_opt_success_log(f"Create role success: {form.name.data}")
             flash("角色创建成功")
         else:
-            AuthApp.print_sys_opt_success_log(f"Create role fail: {form.name.data}")
+            app.HBlogFlask.print_sys_opt_success_log(f"Create role fail: {form.name.data}")
             flash("角色创建失败")
         return redirect(url_for("auth.role_page"))
 
@@ -245,15 +242,15 @@ def role_delete_page():
     form = DeleteRoleForm()
     if form.validate_on_submit():
         if not current_user.check_role("ConfigureSystem"):
-            AuthApp.print_user_not_allow_opt_log("delete role")
+            app.HBlogFlask.print_user_not_allow_opt_log("delete role")
             abort(403)
             return
 
         if User.delete_role(form.name.data):
-            AuthApp.print_sys_opt_success_log(f"Delete role success: {form.name.data}")
+            app.HBlogFlask.print_sys_opt_success_log(f"Delete role success: {form.name.data}")
             flash("角色删除成功")
         else:
-            AuthApp.print_sys_opt_fail_log(f"Delete role fail: {form.name.data}")
+            app.HBlogFlask.print_sys_opt_fail_log(f"Delete role fail: {form.name.data}")
             flash("角色删除失败")
         return redirect(url_for("auth.role_page"))
 
@@ -267,20 +264,20 @@ def role_set_page():
     form = SetRoleForm()
     if form.validate_on_submit():
         if not current_user.check_role("ConfigureSystem"):
-            AuthApp.print_user_not_allow_opt_log("assign user a role")
+            app.HBlogFlask.print_user_not_allow_opt_log("assign user a role")
             abort(403)
             return
 
         user = load_user_by_email(form.email.data)
         if user is not None:
             if user.set_user_role(form.name.data):
-                AuthApp.print_sys_opt_success_log(f"Role assign {form.email.data} -> {form.name.data}")
+                app.HBlogFlask.print_sys_opt_success_log(f"Role assign {form.email.data} -> {form.name.data}")
                 flash("角色设置成功")
             else:
-                AuthApp.print_sys_opt_fail_log(f"Role assign {form.email.data} -> {form.name.data}")
+                app.HBlogFlask.print_sys_opt_fail_log(f"Role assign {form.email.data} -> {form.name.data}")
                 flash("角色设置失败")
         else:
-            AuthApp.print_sys_opt_fail_log(f"Role assign (bad email) {form.email.data} -> {form.name.data}")
+            app.HBlogFlask.print_sys_opt_fail_log(f"Role assign (bad email) {form.email.data} -> {form.name.data}")
             flash("邮箱未注册")
         return redirect(url_for("auth.role_page"))
 
@@ -291,18 +288,3 @@ def role_set_page():
 @auth.context_processor
 def inject_base():
     return {"top_nav": ["", "", "", "", "", "active"]}
-
-
-class AuthApp(App):
-    def __init__(self, import_name):
-        super(AuthApp, self).__init__(import_name)
-
-        global app, mail
-        app = self._app
-        mail = self.mail
-        app.register_blueprint(auth, url_prefix="/auth")
-        self.login_manager.login_view = "auth.login_page"
-
-        @self.login_manager.user_loader
-        def user_loader(email: str):
-            return load_user_by_email(email)

view/docx.py → app/docx.py

@@ -1,23 +1,20 @@
 from flask import Flask, Blueprint, render_template, abort, redirect, url_for, flash, make_response
 from flask_wtf import FlaskForm
-from flask_pagedown import PageDown
 from flask_pagedown.fields import PageDownField
 from flask_login import login_required, current_user
 from wtforms import TextAreaField, StringField, SubmitField
 from wtforms.validators import DataRequired, Length
-from typing import Optional
 import bleach
 from markdown import markdown
 
-from view.base import App
+import app
 from sql.base import DBBit
-from core.blog import BlogArticle, load_blog_by_id
-from core.user import User
-from core.comment import Comment
-from core.archive import load_archive_by_name
+from object.blog import BlogArticle, load_blog_by_id
+from object.user import User
+from object.comment import Comment
+from object.archive import load_archive_by_name
 
 docx = Blueprint("docx", __name__)
-app: Optional[Flask] = None
 allow_tag = ['a', 'abbr', 'acronym', 'b', 'br', 'blockquote', 'code', 'em', 'i', 'li', 'ol', 'pre', 'strong', 'small',
              'ul', 'h1', 'h2', 'h3', 'h4', 'h5' 'h6', 'p']
 
@@ -38,14 +35,14 @@ class WriteCommentForm(FlaskForm):
 @docx.route('/<int:page>')
 def docx_page(page: int = 1):
     if page < 1:
-        DocxApp.print_user_opt_fail_log(f"Load docx list with error page({page})")
+        app.HBlogFlask.print_user_opt_fail_log(f"Load docx list with error page({page})")
         abort(404)
         return
 
     blog_list = BlogArticle.get_blog_list(limit=20, offset=(page - 1) * 20)
-    max_page = App.get_max_page(BlogArticle.get_blog_count(), 20)
-    page_list = App.get_page("docx.docx_page", page, max_page)
-    DocxApp.print_load_page_log(f"docx list (page: {page})")
+    max_page = app.HBlogFlask.get_max_page(BlogArticle.get_blog_count(), 20)
+    page_list = app.HBlogFlask.get_page("docx.docx_page", page, max_page)
+    app.HBlogFlask.print_load_page_log(f"docx list (page: {page})")
     return render_template("docx/docx.html",
                            blog_list=blog_list,
                            is_top=DBBit.BIT_1,
@@ -57,14 +54,14 @@ def docx_page(page: int = 1):
 @docx.route('/<int:archive>/<int:page>')
 def archive_page(archive: int, page: int = 1):
     if page < 1:
-        DocxApp.print_user_opt_fail_log(f"Load archive-docx list with error page({page}) archive: {archive}")
+        app.HBlogFlask.print_user_opt_fail_log(f"Load archive-docx list with error page({page}) archive: {archive}")
         abort(404)
         return
 
     blog_list = BlogArticle.get_blog_list(archive_id=archive, limit=20, offset=(page - 1) * 20)
-    max_page = App.get_max_page(BlogArticle.get_blog_count(archive_id=archive), 20)
-    page_list = App.get_page("docx.archive_page", page, max_page)
-    DocxApp.print_load_page_log(f"archive-docx list (archive-id: {archive} page: {page})")
+    max_page = app.HBlogFlask.get_max_page(BlogArticle.get_blog_count(archive_id=archive), 20)
+    page_list = app.HBlogFlask.get_page("docx.archive_page", page, max_page)
+    app.HBlogFlask.print_load_page_log(f"archive-docx list (archive-id: {archive} page: {page})")
     return render_template("docx/docx.html",
                            blog_list=blog_list,
                            is_top=DBBit.BIT_1,
@@ -76,10 +73,10 @@ def archive_page(archive: int, page: int = 1):
 def article_page(blog_id: int):
     article = load_blog_by_id(blog_id)
     if article is None:
-        DocxApp.print_user_opt_fail_log(f"Load article with error id({blog_id})")
+        app.HBlogFlask.print_user_opt_fail_log(f"Load article with error id({blog_id})")
         abort(404)
         return
-    DocxApp.print_load_page_log(f"article (id: {blog_id})")
+    app.HBlogFlask.print_load_page_log(f"article (id: {blog_id})")
     return render_template("docx/article.html",
                            article=article,
                            archive_list=article.archive,
@@ -92,13 +89,13 @@ def article_page(blog_id: int):
 def article_down_page(blog_id: int):
     article = load_blog_by_id(blog_id)
     if article is None:
-        DocxApp.print_user_opt_fail_log(f"Download article with error id({blog_id})")
+        app.HBlogFlask.print_user_opt_fail_log(f"Download article with error id({blog_id})")
         abort(404)
         return
 
     response = make_response(article.context)
     response.headers["Content-Disposition"] = f"attachment;filename={article.title.encode().decode('latin-1')}.html"
-    DocxApp.print_load_page_log(f"download article (id: {blog_id})")
+    app.HBlogFlask.print_load_page_log(f"download article (id: {blog_id})")
     return response
 
 
@@ -109,19 +106,19 @@ def comment_page(blog: int):
     if form.validate_on_submit():
         auth: User = current_user
         if not auth.check_role("WriteComment"):  # 检查是否具有权限
-            DocxApp.print_user_not_allow_opt_log("comment")
+            app.HBlogFlask.print_user_not_allow_opt_log("comment")
             abort(403)
             return
 
         context = form.context.data
         if Comment(None, blog, auth, context).create():
-            DocxApp.print_user_opt_success_log("comment")
+            app.HBlogFlask.print_user_opt_success_log("comment")
             flash("评论成功")
         else:
-            DocxApp.print_user_opt_error_log("comment")
+            app.HBlogFlask.print_user_opt_error_log("comment")
             flash("评论失败")
         return redirect(url_for("docx.article_page", blog_id=blog))
-    DocxApp.print_form_error_log("comment")
+    app.HBlogFlask.print_form_error_log("comment")
     abort(404)
 
 
@@ -132,7 +129,7 @@ def create_docx_page():
     if form.validate_on_submit():
         auth: User = current_user
         if not auth.check_role("WriteBlog"):  # 检查是否具有写入权限
-            DocxApp.print_user_not_allow_opt_log("write blog")
+            app.HBlogFlask.print_user_not_allow_opt_log("write blog")
             abort(403)
             return
 
@@ -151,13 +148,13 @@ def create_docx_page():
                 markdown(form.context.data, output_format='html'), tags=allow_tag, strip=True))
 
         if BlogArticle(None, current_user, title, subtitle, context, archive=archive_list).create():
-            DocxApp.print_sys_opt_success_log("write blog")
+            app.HBlogFlask.print_sys_opt_success_log("write blog")
             flash(f"博客 {title} 发表成功")
         else:
-            DocxApp.print_sys_opt_fail_log("write blog")
+            app.HBlogFlask.print_sys_opt_fail_log("write blog")
             flash(f"博客 {title} 发表失败")
         return redirect(url_for("docx.docx_page", page=1))
-    DocxApp.print_form_error_log("write blog")
+    app.HBlogFlask.print_form_error_log("write blog")
     abort(404)
 
 
@@ -165,15 +162,15 @@ def create_docx_page():
 @login_required
 def delete_blog_page(blog_id: int):
     if not current_user.check_role("DeleteBlog"):
-        DocxApp.print_user_not_allow_opt_log("delete blog")
+        app.HBlogFlask.print_user_not_allow_opt_log("delete blog")
         abort(403)
         return
 
     if BlogArticle(blog_id, None, None, None, None).delete():
-        DocxApp.print_sys_opt_success_log("delete blog")
+        app.HBlogFlask.print_sys_opt_success_log("delete blog")
         flash("博文删除成功")
     else:
-        DocxApp.print_sys_opt_fail_log("delete blog")
+        app.HBlogFlask.print_sys_opt_fail_log("delete blog")
         flash("博文删除失败")
     return redirect(url_for("docx.docx_page", page=1))
 
@@ -182,30 +179,19 @@ def delete_blog_page(blog_id: int):
 @login_required
 def delete_comment_page(comment_id: int):
     if not current_user.check_role("DeleteComment"):
-        DocxApp.print_user_not_allow_opt_log("delete comment")
+        app.HBlogFlask.print_user_not_allow_opt_log("delete comment")
         abort(403)
         return
 
     if Comment(comment_id, None, None, None).delete():
-        DocxApp.print_sys_opt_success_log("delete comment")
+        app.HBlogFlask.print_sys_opt_success_log("delete comment")
         flash("博文评论成功")
     else:
-        DocxApp.print_sys_opt_fail_log("delete comment")
+        app.HBlogFlask.print_sys_opt_fail_log("delete comment")
         flash("博文评论失败")
     return redirect(url_for("docx.docx_page", page=1))
 
 
 @docx.context_processor
 def inject_base():
-    return {"top_nav": ["", "", "active", "", "", ""]}
-
-
-class DocxApp(App):
-    def __init__(self, import_name):
-        super(DocxApp, self).__init__(import_name)
-
-        global app
-        app = self._app
-        self.pagedown = PageDown()
-        self.pagedown.init_app(app)
-        app.register_blueprint(docx, url_prefix="/docx")
+    return {"top_nav": ["", "", "active", "", "", ""]}

app/index.py

@@ -0,0 +1,39 @@
+from flask import Blueprint, render_template
+from flask_login import current_user
+
+from configure import conf
+import app
+from object.blog import BlogArticle
+from object.msg import load_message_list
+
+index = Blueprint("base", __name__)
+
+
+@index.route('/')
+def hello_page():
+    app.HBlogFlask.print_load_page_log(f"hello")
+    return render_template("index/hello.html")
+
+
+@index.route('/index')
+def index_page():
+    blog_list = BlogArticle.get_blog_list(limit=5, offset=0, not_top=True)
+    msg_list = load_message_list(limit=6, offset=0, show_secret=False)
+    app.HBlogFlask.print_load_page_log(f"index")
+    return render_template("index/index.html",
+                           blog_list=blog_list,
+                           msg_list=msg_list,
+                           show_email=current_user.check_role("ReadUserInfo"))
+
+
+@index.context_processor
+def inject_base():
+    return {"top_nav": ["active", "", "", "", "", ""]}
+
+
+@index.app_context_processor
+def inject_base():
+    return {"blog_name": conf['blog-name'],
+            "top_nav": ["", "", "", "", "", ""],
+            "blog_describe": conf['blog-describe'],
+            "conf": conf}

view/msg.py → app/msg.py

@@ -3,15 +3,13 @@ from flask_wtf import FlaskForm
 from flask_login import login_required, current_user
 from wtforms import TextAreaField, BooleanField, SubmitField
 from wtforms.validators import DataRequired
-from typing import Optional
 
-from view.base import App
+import app
 from sql.base import DBBit
-from core.user import User
-from core.msg import Message, load_message_list
+from object.user import User
+from object.msg import Message, load_message_list
 
 msg = Blueprint("msg", __name__)
-app: Optional[Flask] = None
 
 
 class WriteForm(FlaskForm):
@@ -26,15 +24,15 @@ class WriteForm(FlaskForm):
 @msg.route('/<int:page>')
 def msg_page(page: int = 1):
     if page < 1:
-        MsgApp.print_user_opt_fail_log(f"Load msg list with error page({page})")
+        app.HBlogFlask.print_user_opt_fail_log(f"Load msg list with error page({page})")
         abort(404)
         return
 
     msg_list = load_message_list(20, (page - 1) * 20,
                                  show_secret=current_user.check_role("ReadSecretMsg"))  # 判断是否可读取私密内容
-    max_page = App.get_max_page(Message.get_msg_count(), 20)
-    page_list = App.get_page("docx.docx_page", page, max_page)
-    MsgApp.print_load_page_log(f"msg (page: {page})")
+    max_page = app.HBlogFlask.get_max_page(Message.get_msg_count(), 20)
+    page_list = app.HBlogFlask.get_page("docx.docx_page", page, max_page)
+    app.HBlogFlask.print_load_page_log(f"msg (page: {page})")
     return render_template("msg/msg.html",
                            msg_list=msg_list,
                            page_list=page_list,
@@ -51,17 +49,17 @@ def write_msg_page():
     if form.validate_on_submit():
         auth: User = current_user
         if not auth.check_role("WriteMsg"):  # 检查相应权限
-            MsgApp.print_user_not_allow_opt_log("write msg")
+            app.HBlogFlask.print_user_not_allow_opt_log("write msg")
             abort(403)
             return
 
         context = form.context.data
         secret = form.secret.data
         if Message(None, auth, context, secret, None).create():
-            MsgApp.print_user_opt_success_log("write msg")
+            app.HBlogFlask.print_user_opt_success_log("write msg")
             flash("留言成功")
         else:
-            MsgApp.print_user_opt_fail_log("write msg")
+            app.HBlogFlask.print_user_opt_fail_log("write msg")
             flash("留言失败")
         return redirect(url_for("msg.msg_page", page=1))
     abort(404)
@@ -71,28 +69,19 @@ def write_msg_page():
 @login_required
 def delete_msg_page(msg_id: int):
     if not current_user.check_role("DeleteMsg"):
-        MsgApp.print_user_not_allow_opt_log("delete msg")
+        app.HBlogFlask.print_user_not_allow_opt_log("delete msg")
         abort(403)
         return
 
     if Message(msg_id, None, None).delete():
-        MsgApp.print_user_opt_success_log("delete msg")
+        app.HBlogFlask.print_user_opt_success_log("delete msg")
         flash("留言删除成功")
     else:
-        MsgApp.print_user_opt_fail_log("delete msg")
+        app.HBlogFlask.print_user_opt_fail_log("delete msg")
         flash("留言删除失败")
     return redirect(url_for("msg.msg_page", page=1))
 
 
 @msg.context_processor
 def inject_base():
-    return {"top_nav": ["", "", "", "active", "", ""]}
-
-
-class MsgApp(App):
-    def __init__(self, import_name):
-        super(MsgApp, self).__init__(import_name)
-
-        global app
-        app = self._app
-        app.register_blueprint(msg, url_prefix="/msg")
+    return {"top_nav": ["", "", "", "active", "", ""]}

view/oss.py → app/oss.py

@@ -1,15 +1,13 @@
-from flask import Flask, Blueprint, redirect, render_template, abort, flash, url_for, request
+from flask import Blueprint, redirect, render_template, abort, flash, url_for, request
 from flask_login import login_required, current_user
-from typing import Optional
 from flask_wtf import FlaskForm
 from wtforms import FileField, SubmitField
 from wtforms.validators import DataRequired
 
 from aliyun import aliyun
-from view.base import App
+import app
 
 oss = Blueprint("oss", __name__)
-app: Optional[Flask] = None
 
 
 class UploadForm(FlaskForm):
@@ -20,14 +18,14 @@ class UploadForm(FlaskForm):
 @oss.before_request
 def check_aliyun():
     if aliyun is None:
-        OSSApp.print_user_opt_fail_log("aliyun not used")
+        app.HBlogFlask.print_user_opt_fail_log("aliyun not used")
         abort(404)
         return
 
 
 @oss.route('get/<string:name>')
 def get_page(name: str):
-    OSSApp.print_user_opt_success_log(f"get file {name}")
+    app.HBlogFlask.print_user_opt_success_log(f"get file {name}")
     return redirect(aliyun.shared_obj(name))
 
 
@@ -35,7 +33,7 @@ def get_page(name: str):
 @login_required
 def upload_page():
     if not current_user.check_role("ConfigureSystem"):
-        OSSApp.print_user_not_allow_opt_log("upload file")
+        app.HBlogFlask.print_user_not_allow_opt_log("upload file")
         abort(403)
         return
 
@@ -43,17 +41,8 @@ def upload_page():
     if form.validate_on_submit():
         file = request.files["file"]
         aliyun.upload_file(file.filename, file)
-        OSSApp.print_sys_opt_success_log(f"Upload file {file.filename}")
+        app.HBlogFlask.print_sys_opt_success_log(f"Upload file {file.filename}")
         flash(f"文件 {file.filename} 已上传: {url_for('oss.get_page', name=file.filename, _external=True)}")
         return redirect(url_for("oss.upload_page"))
-    OSSApp.print_load_page_log(f"OSS upload")
+    app.HBlogFlask.print_load_page_log(f"OSS upload")
     return render_template("oss/upload.html", UploadForm=form)
-
-
-class OSSApp(App):
-    def __init__(self, import_name):
-        super(OSSApp, self).__init__(import_name)
-
-        global app
-        app = self._app
-        app.register_blueprint(oss, url_prefix="/oss")

main.py

@@ -11,11 +11,10 @@ else:
     logging.info(f"Configure file {hblog_conf}")
     configure(hblog_conf)
 
-from view import WebApp
+from app import HBlogFlask
 from waitress import serve
 
-web = WebApp(__name__)
-app = web.get_app()
+app = HBlogFlask(__name__)
 
 if conf["server-name"] is not None:
     app.config['SERVER_NAME'] = conf["server-name"]

core/blog.py → object/blog.py

@@ -9,9 +9,9 @@ from sql.blog import (get_blog_list,
                       create_blog,
                       delete_blog,
                       get_user_user_count)
-import core.user
-import core.archive
-import core.comment
+import object.user
+import object.archive
+import object.comment
 
 
 class LoadBlogError(Exception):
@@ -24,7 +24,7 @@ def load_blog_by_id(blog_id) -> "Optional[BlogArticle]":
     if len(blog) == 0:
         return None
 
-    auth = core.user.load_user_by_id(blog[0])
+    auth = object.user.load_user_by_id(blog[0])
     if auth is None:
         return None
 
@@ -33,8 +33,8 @@ def load_blog_by_id(blog_id) -> "Optional[BlogArticle]":
     context = blog[3]
     update_time = blog[6]
     top = blog[7]
-    comment = core.comment.load_comment_list(blog_id)
-    archive = core.archive.Archive.get_blog_archive(blog_id)
+    comment = object.comment.load_comment_list(blog_id)
+    archive = object.archive.Archive.get_blog_archive(blog_id)
     return BlogArticle(blog_id, auth, title, subtitle, context, update_time, top, comment, archive)
 
 

core/comment.py → object/comment.py

@@ -1,5 +1,5 @@
 from sql.comment import read_comment, create_comment, get_user_comment_count, delete_comment
-import core.user
+import object.user
 
 from typing import Optional
 
@@ -8,14 +8,14 @@ def load_comment_list(blog_id: int):
     comment_list = read_comment(blog_id)
     ret = []
     for comment in comment_list:
-        ret.append(Comment(comment[0], blog_id, core.user.User(comment[2], None, None, comment[1]), comment[3], comment[4]))
+        ret.append(Comment(comment[0], blog_id, object.user.User(comment[2], None, None, comment[1]), comment[3], comment[4]))
     return ret
 
 
 class Comment:
     def __init__(self, comment_id,
                  blog_id: Optional[int],
-                 auth: "Optional[core.user.User]",
+                 auth: "Optional[object.user.User]",
                  context: Optional[str], update_time=None):
         self.comment_id = comment_id
         self.blog_id = blog_id
@@ -24,7 +24,7 @@ class Comment:
         self.update_time = update_time
 
     @staticmethod
-    def get_user_comment_count(auth: "core.user"):
+    def get_user_comment_count(auth: "object.user"):
         return get_user_comment_count(auth.get_user_id())
 
     def create(self):

core/msg.py → object/msg.py

@@ -1,19 +1,19 @@
 from typing import Optional
 
 from sql.msg import read_msg, get_msg_count, create_msg, get_user_msg_count, delete_msg
-import core.user
+import object.user
 
 
 def load_message_list(limit: Optional[int] = None, offset: Optional[int] = None, show_secret: bool = False):
     msg = read_msg(limit=limit, offset=offset, show_secret=show_secret)
     ret = []
     for i in msg:
-        ret.append(Message(i[0], core.user.User(i[2], None, None, i[1]), i[3], i[5], i[4]))
+        ret.append(Message(i[0], object.user.User(i[2], None, None, i[1]), i[3], i[5], i[4]))
     return ret
 
 
 class Message:
-    def __init__(self, msg_id, auth: "Optional[core.user.User]", context, secret=False, update_time=None):
+    def __init__(self, msg_id, auth: "Optional[object.user.User]", context, secret=False, update_time=None):
         self.msg_id = msg_id
         self.auth = auth
         self.context = context
@@ -21,7 +21,7 @@ class Message:
         self.update_time = update_time
 
     @staticmethod
-    def get_msg_count(auth: "core.user" = None):
+    def get_msg_count(auth: "object.user" = None):
         if auth is None:
             return get_msg_count()
         return get_user_msg_count(auth.get_user_id())

core/user.py → object/user.py

@@ -15,9 +15,9 @@ from sql.user import (read_user,
                       create_role,
                       delete_role,
                       set_user_role)
-import core.blog
-import core.comment
-import core.msg
+import object.blog
+import object.comment
+import object.msg
 
 
 class AnonymousUser(AnonymousUserMixin):
@@ -64,9 +64,9 @@ class User(UserMixin):
         self.user_id = user_id
 
     def count_info(self):
-        msg = core.msg.Message.get_msg_count(self)
-        comment = core.comment.Comment.get_user_comment_count(self)
-        blog = core.blog.BlogArticle.get_blog_count(None, self)
+        msg = object.msg.Message.get_msg_count(self)
+        comment = object.comment.Comment.get_user_comment_count(self)
+        blog = object.blog.BlogArticle.get_blog_count(None, self)
         return msg, comment, blog
 
     @property

send_email/__init__.py

@@ -1,14 +1,13 @@
 from flask import render_template, current_app
 from flask_mail import Mail, Message
 from configure import conf
-import os
 
 
 def send_msg(title: str, mail: Mail, to, template, **kwargs):
     """ 邮件发送 """
     sender = f"HBlog Admin <{conf['email_sender']}>"
-    template_path = os.path.join("email-msg", f"{template}.txt")
     message = Message(conf['email_prefix'] + title, sender=sender, recipients=[to])
-    message.body = render_template(template_path, **kwargs)
+    message.body = render_template("email-msg/" + template + ".txt", **kwargs)
+    message.html = render_template("email-msg/" + template + ".html", **kwargs)
     mail.send(message)
-    current_app.logger.info(f"Send email to {to} sender: {sender} msg: {template_path} kwargs: {kwargs}")
+    current_app.logger.info(f"Send email to {to} sender: {sender} msg: {template} kwargs: {kwargs}")

sql/blog.py

@@ -1,9 +1,9 @@
 from sql import db
 from typing import Optional, List
-import core.archive
+import object.archive
 
 
-def create_blog(auth_id: int, title: str, subtitle:str, context: str, archive_list: List[core.archive.Archive]) -> bool:
+def create_blog(auth_id: int, title: str, subtitle:str, context: str, archive_list: List[object.archive.Archive]) -> bool:
     """写入新的blog"""
     cur = db.insert(table="blog", columns=["Auth", "Title", "SubTitle", "Context"],
                     values=f"{auth_id}, '{title}', '{subtitle}', '{context}'")

sql/user.py

@@ -1,6 +1,6 @@
 from sql import db
 from sql.base import DBBit
-import core.user
+import object.user
 
 from typing import List
 
@@ -23,7 +23,7 @@ def read_user(email: str):
 def create_user(email: str, passwd: str):
     """ 创建用户 """
     cur = db.search(columns=["count(Email)"], table="user")  # 统计个数
-    passwd = core.user.User.get_passwd_hash(passwd)
+    passwd = object.user.User.get_passwd_hash(passwd)
     if cur is None or cur.rowcount == 0 or cur.fetchone()[0] == 0:
         db.insert(table='user', columns=['Email', 'PasswdHash', 'Role'], values=f"'{email}', '{passwd}', 1")  # 创建为管理员用户
     else:

templates/email-msg/register.html

@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
+
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Noto+Sans+SC:wght@100;400&display=swap" rel="stylesheet">
+
+    <style>
+        html {
+            font-family: 'Noto Sans SC', sans-serif;
+        }
+    </style>
+
+    <title> {{ title }} </title>
+
+</head>
+
+<body>
+    <h1> {{ title }} </h1>
+    <p> 欢迎注册HBlog用户，请点击以下链接完成认证。 <br> 若您未进行过注册操作，请忽略此邮件。 </p>
+    <a href="{{ register_url }}"> 点击完成认证 </a>
+</body>
+</html>

templates/email-msg/register.txt

@@ -1,4 +1,3 @@
 欢迎注册HBlog用户，请点击以下链接完成认证。
-{{ register_url }}
-
 若您未进行过注册操作，请忽略此邮件。
+{{ register_url }}

view/__init__.py

@@ -1,12 +0,0 @@
-from view.index import IndexApp
-from view.docx import DocxApp
-from view.archive import ArchiveApp
-from view.msg import MsgApp
-from view.about_me import AboutMeApp
-from view.auth import AuthApp
-from view.oss import OSSApp
-
-
-class WebApp(IndexApp, DocxApp, ArchiveApp, MsgApp, AboutMeApp, AuthApp, OSSApp):
-    def __init__(self, import_name):
-        super(WebApp, self).__init__(import_name)

view/about_me.py

@@ -1,28 +0,0 @@
-from flask import Flask, Blueprint, render_template, current_app, request
-from typing import Optional
-
-from view.base import App
-
-
-about_me = Blueprint("about_me", __name__)
-app: Optional[Flask] = None
-
-
-@about_me.route('/')
-def about_me_page():
-    AboutMeApp.print_load_page_log("about me")
-    return render_template("about_me/about_me.html")
-
-
-@about_me.context_processor
-def inject_base():
-    return {"top_nav": ["", "", "", "", "active", ""]}
-
-
-class AboutMeApp(App):
-    def __init__(self, import_name):
-        super(AboutMeApp, self).__init__(import_name)
-
-        global app
-        app = self._app
-        app.register_blueprint(about_me, url_prefix="/about-me")

view/index.py

@@ -1,75 +0,0 @@
-from flask import Flask, Blueprint, render_template
-from typing import Optional
-from flask_login import current_user
-
-from configure import conf
-from view.base import App
-from core.blog import BlogArticle
-from core.msg import load_message_list
-
-index = Blueprint("base", __name__)
-app: Optional[Flask] = None
-
-
-@index.route('/')
-def hello_page():
-    IndexApp.print_load_page_log(f"hello")
-    return render_template("index/hello.html")
-
-
-@index.route('/index')
-def index_page():
-    blog_list = BlogArticle.get_blog_list(limit=5, offset=0, not_top=True)
-    msg_list = load_message_list(limit=6, offset=0, show_secret=False)
-    IndexApp.print_load_page_log(f"index")
-    return render_template("index/index.html",
-                           blog_list=blog_list,
-                           msg_list=msg_list,
-                           show_email=current_user.check_role("ReadUserInfo"))
-
-
-@index.app_errorhandler(404)
-def error_404(e):
-    IndexApp.print_load_page_log(f"404")
-    return render_template("index/error.html", error_code="404", error_info=f"你似乎来到一片荒漠：{e}"), 404
-
-
-@index.app_errorhandler(405)
-def error_405(e):
-    IndexApp.print_load_page_log(f"405")
-    return render_template("index/error.html", error_code="404", error_info=f"请求错误：{e}"), 405
-
-
-@index.app_errorhandler(403)
-def error_403(e):
-    IndexApp.print_load_page_log(f"403")
-    return render_template("index/error.html", error_code="404", error_info=f"权限不足：{e}"), 403
-
-
-@index.app_errorhandler(500)
-def error_500(e):
-    IndexApp.print_load_page_log(f"500")
-    return render_template("index/error.html", error_code="404", error_info=f"服务器出问题啦：{e}"), 500
-
-
-@index.context_processor
-def inject_base():
-    return {"top_nav": ["active", "", "", "", "", ""]}
-
-
-@index.app_context_processor
-def inject_base():
-    return {"blog_name": conf['blog-name'],
-            "top_nav": ["", "", "", "", "", ""],
-            "blog_describe": conf['blog-describe'],
-            "conf": conf}
-
-
-class IndexApp(App):
-    def __init__(self, import_name):
-        super(IndexApp, self).__init__(import_name)
-
-        global app
-        app = self._app
-        app.register_blueprint(index, url_prefix="/")
-