refactor: 添加DAO层，分离视图函数中数据库相关的业务逻辑

Author: colorful3

app/api/cms/admin.py

@@ -7,17 +7,16 @@
 from itertools import groupby
 from operator import itemgetter
 
-from flask import jsonify, request
+from flask import jsonify
+from lin.core import get_ep_infos, route_meta
+from lin.exception import Success
+from lin.jwt import admin_required
 from lin.log import Logger
-
 from lin.redprint import Redprint
-from lin.core import get_ep_infos, manager, find_auth_module, route_meta, find_user
-from lin.jwt import admin_required
-from lin.util import paginate
-from lin.db import db, get_total_nums
-from lin.enums import UserSuper, UserActive
-from lin.exception import NotFound, Forbidden, Success, ParameterException
 
+from app.dao.auth import AuthDAO
+from app.dao.group import GroupDAO
+from app.dao.user import UserDAO
 from app.validators.forms import NewGroup, DispatchAuth, DispatchAuths, RemoveAuths, UpdateGroup, ResetPasswordForm, \
     UpdateUserInfoForm
 
@@ -35,157 +34,81 @@ def authority():
 @route_meta(auth='查询所有用户', module='管理员', mount=False)
 @admin_required
 def get_admin_users():
-    start, count = paginate()
-    group_id = request.args.get('group_id')
-    condition = {'super': UserSuper.COMMON.value, 'group_id': group_id} if group_id else {
-        'super': UserSuper.COMMON.value}
-    users = db.session.query(manager.user_model, manager.group_model.name) \
-        .filter_by(soft=True, **condition) \
-        .join(manager.group_model, manager.user_model.group_id == manager.group_model.id) \
-        .offset(start).limit(count).all()
-    user_and_group = []
-    for user, group_name in users:
-        setattr(user, 'group_name', group_name)
-        user._fields.append('group_name')
-        user.hide('update_time', 'delete_time')
-        user_and_group.append(user)
-    # 有分组的时候就加入分组条件
-    # total_nums = get_total_nums(manager.user_model, is_soft=True, super=UserSuper.COMMON.value)
-    total_nums = get_total_nums(manager.user_model, is_soft=True, **condition)
+    user_and_group, total_nums = UserDAO().get_all()
     return jsonify({
         "collection": user_and_group,
-        # 超级管理员不算入总数
         'total_nums': total_nums
     })
 
 
-@admin_api.route('/password/<int:id>', methods=['PUT'])
+@admin_api.route('/password/<int:uid>', methods=['PUT'])
 @route_meta(auth='修改用户密码', module='管理员', mount=False)
 @admin_required
-def change_user_password(id):
+def change_user_password(uid):
     form = ResetPasswordForm().validate_for_api()
-    user = find_user(id=id)
-    if user is None:
-        raise NotFound(msg='用户不存在')
-    with db.auto_commit():
-        user.reset_password(form.new_password.data)
+    UserDAO().reset_user_password(uid, form.new_password.data)
     return Success(msg='密码修改成功')
 
 
-@admin_api.route('/<int:id>', methods=['DELETE'])
+@admin_api.route('/<int:uid>', methods=['DELETE'])
 @route_meta(auth='删除用户', module='管理员', mount=False)
 @Logger(template='管理员删除了一个用户')  # 记录日志
 @admin_required
-def delete_user(id):
-    user = manager.user_model.get(id=id)
-    if user is None:
-        raise NotFound(msg='用户不存在')
-    # user.delete(commit=True)
-    # 此处我们使用硬删除，一般情况下，推荐使用软删除即，上一行注释的代码
-    user.hard_delete(commit=True)
+def delete_user(uid):
+    UserDAO().remove_user(uid)
     return Success(msg='操作成功')
 
 
-@admin_api.route('/<int:id>', methods=['PUT'])
+@admin_api.route('/<int:uid>', methods=['PUT'])
 @route_meta(auth='管理员更新用户信息', module='管理员', mount=False)
 @admin_required
-def update_user(id):
+def update_user(uid):
     form = UpdateUserInfoForm().validate_for_api()
-    user = manager.user_model.get(id=id)
-    if user is None:
-        raise NotFound(msg='用户不存在')
-    if user.email != form.email.data:
-        exit = manager.user_model.get(email=form.email.data)
-        if exit:
-            raise ParameterException(msg='邮箱已被注册，请重新输入邮箱')
-    with db.auto_commit():
-        user.email = form.email.data
-        user.group_id = form.group_id.data
+    UserDAO().update(uid, form)
     return Success(msg='操作成功')
 
 
-@admin_api.route('/disable/<int:id>', methods=['PUT'])
+@admin_api.route('/disable/<int:uid>', methods=['PUT'])
 @route_meta(auth='禁用用户', module='管理员', mount=False)
 @admin_required
-def trans2disable(id):
-    user = manager.user_model.get(id=id)
-    if user is None:
-        raise NotFound(msg='用户不存在')
-    if not user.is_active:
-        raise Forbidden(msg='当前用户已处于禁止状态')
-    with db.auto_commit():
-        user.active = UserActive.NOT_ACTIVE.value
+def trans2disable(uid):
+    UserDAO().change_status(uid, 'active')
     return Success(msg='操作成功')
 
 
-@admin_api.route('/active/<int:id>', methods=['PUT'])
+@admin_api.route('/active/<int:uid>', methods=['PUT'])
 @route_meta(auth='激活用户', module='管理员', mount=False)
 @admin_required
-def trans2active(id):
-    user = manager.user_model.get(id=id)
-    if user is None:
-        raise NotFound(msg='用户不存在')
-    if user.is_active:
-        raise Forbidden(msg='当前用户已处于激活状态')
-    with db.auto_commit():
-        user.active = UserActive.ACTIVE.value
+def trans2active(uid):
+    UserDAO().change_status(uid, 'disable')
     return Success(msg='操作成功')
 
 
 @admin_api.route('/groups', methods=['GET'])
 @route_meta(auth='查询所有权限组及其权限', module='管理员', mount=False)
 @admin_required
 def get_admin_groups():
-    start, count = paginate()
-    groups = manager.group_model.query.filter().offset(start).limit(count).all()
-    if groups is None:
-        raise NotFound(msg='不存在任何权限组')
-    for group in groups:
-        auths = db.session.query(manager.auth_model.auth, manager.auth_model.module) \
-            .filter_by(soft=False, group_id=group.id).all()
-        auths = [{'auth': auth[0], 'module': auth[1]} for auth in auths]
-        res = _split_modules(auths)
-        setattr(group, 'auths', res)
-        group._fields.append('auths')
-    total_nums = get_total_nums(manager.group_model)
+    groups_info, total_nums = GroupDAO().get_groups_info()
+
     return jsonify({
-        "collection": groups,
+        "collection": groups_info,
         'total_nums': total_nums
     })
 
 
-def _split_modules(auths):
-    auths.sort(key=itemgetter('module'))
-    tmps = groupby(auths, itemgetter('module'))
-    res = []
-    for key, group in tmps:
-        res.append({key: list(group)})
-    return res
-
-
 @admin_api.route('/group/all', methods=['GET'])
 @route_meta(auth='查询所有权限组', module='管理员', mount=False)
 @admin_required
 def get_all_group():
-    groups = manager.group_model.get(one=False)
-    if groups is None:
-        raise NotFound(msg='不存在任何权限组')
+    groups = GroupDAO().get_all()
     return jsonify(groups)
 
 
-@admin_api.route('/group/<int:id>', methods=['GET'])
+@admin_api.route('/group/<int:gid>', methods=['GET'])
 @route_meta(auth='查询一个权限组及其权限', module='管理员', mount=False)
 @admin_required
-def get_group(id):
-    group = manager.group_model.get(id=id, one=True, soft=False)
-    if group is None:
-        raise NotFound(msg='分组不存在')
-    auths = db.session.query(manager.auth_model.auth, manager.auth_model.module) \
-        .filter_by(soft=False, group_id=group.id).all()
-    auths = [{'auth': auth[0], 'module': auth[1]} for auth in auths]
-    res = _split_modules(auths)
-    setattr(group, 'auths', res)
-    group._fields.append('auths')
+def get_group(gid):
+    group = GroupDAO().get_single_info(gid)
     return jsonify(group)
 
 
@@ -195,73 +118,43 @@ def get_group(id):
 @admin_required
 def create_group():
     form = NewGroup().validate_for_api()
-    exist = manager.group_model.get(name=form.name.data)
-    if exist:
-        raise Forbidden(msg='分组已存在，不可创建同名分组')
-    with db.auto_commit():
-        group = manager.group_model.create(name=form.name.data, info=form.info.data)
-        db.session.flush()
-        for auth in form.auths.data:
-            meta = find_auth_module(auth)
-            if meta:
-                manager.auth_model.create(auth=meta.auth, module=meta.module, group_id=group.id)
+    GroupDAO().new_group(form)
     return Success(msg='新建分组成功')
 
 
-@admin_api.route('/group/<int:id>', methods=['PUT'])
+@admin_api.route('/group/<int:gid>', methods=['PUT'])
 @route_meta(auth='更新一个权限组', module='管理员', mount=False)
 @admin_required
-def update_group(id):
+def update_group(gid):
     form = UpdateGroup().validate_for_api()
-    exist = manager.group_model.get(id=id)
-    if not exist:
-        raise NotFound(msg='分组不存在，更新失败')
-    exist.update(name=form.name.data, info=form.info.data, commit=True)
+    GroupDAO().update_group(gid, form)
     return Success(msg='更新分组成功')
 
 
-@admin_api.route('/group/<int:id>', methods=['DELETE'])
+@admin_api.route('/group/<int:gid>', methods=['DELETE'])
 @route_meta(auth='删除一个权限组', module='管理员', mount=False)
 @Logger(template='管理员删除一个权限组')  # 记录日志
 @admin_required
-def delete_group(id):
-    exist = manager.group_model.get(id=id)
-    if not exist:
-        raise NotFound(msg='分组不存在，删除失败')
-    if manager.user_model.get(group_id=id):
-        raise Forbidden(msg='分组下存在用户，不可删除')
-    # 删除group拥有的权限
-    db.session.query(manager.auth_model).filter(manager.auth_model.group_id == id).delete()
-    exist.delete(commit=True)
+def delete_group(gid):
+    GroupDAO().remove_group(gid)
     return Success(msg='删除分组成功')
 
 
 @admin_api.route('/dispatch', methods=['POST'])
 @route_meta(auth='分配单个权限', module='管理员', mount=False)
 @admin_required
 def dispatch_auth():
-    form = DispatchAuth()
-    form.validate_for_api()
-    one = manager.auth_model.get(group_id=form.group_id.data, auth=form.auth.data)
-    if one:
-        raise Forbidden(msg='已有权限，不可重复添加')
-    meta = find_auth_module(form.auth.data)
-    manager.auth_model.create(group_id=form.group_id.data, auth=meta.auth, module=meta.module, commit=True)
+    form = DispatchAuth().validate_for_api()
+    AuthDAO().patch_one(form)
     return Success(msg='添加权限成功')
 
 
 @admin_api.route('/dispatch/patch', methods=['POST'])
 @route_meta(auth='分配多个权限', module='管理员', mount=False)
 @admin_required
 def dispatch_auths():
-    form = DispatchAuths()
-    form.validate_for_api()
-    with db.auto_commit():
-        for auth in form.auths.data:
-            one = manager.auth_model.get(group_id=form.group_id.data, auth=auth)
-            if not one:
-                meta = find_auth_module(auth)
-                manager.auth_model.create(group_id=form.group_id.data, auth=meta.auth, module=meta.module)
+    form = DispatchAuths().validate_for_api()
+    AuthDAO().patch_all(form)
     return Success(msg='添加权限成功')
 
 
@@ -270,13 +163,18 @@ def dispatch_auths():
 @admin_required
 def remove_auths():
     form = RemoveAuths().validate_for_api()
-    with db.auto_commit():
-        db.session.query(manager.auth_model) \
-            .filter(manager.auth_model.auth.in_(form.auths.data),
-                    manager.auth_model.group_id == form.group_id.data) \
-            .delete(synchronize_session=False)
+    AuthDAO().remove_auths(form)
     return Success(msg='删除权限成功')
 
+
+def _split_modules(auths):
+    auths.sort(key=itemgetter('module'))
+    tmps = groupby(auths, itemgetter('module'))
+    res = []
+    for key, group in tmps:
+        res.append({key: list(group)})
+    return res
+
 # --------------------------------------------------
 # --------------------Abandon-----------------------
 # --------------------------------------------------

app/api/cms/log.py

@@ -3,14 +3,12 @@
     :license: MIT, see LICENSE for more details.
 """
 
-from flask import request, jsonify
-from sqlalchemy import text
-from lin.redprint import Redprint
+from flask import jsonify
+from lin.core import route_meta
 from lin.jwt import group_required
-from lin.exception import NotFound, ParameterException
-from lin.db import db
-from lin.util import paginate
-from lin.core import Log, route_meta
+from lin.redprint import Redprint
+
+from app.dao.log import LogDAO
 from app.validators.forms import LogFindForm
 
 log_api = Redprint('log')
@@ -22,16 +20,7 @@
 @group_required
 def get_logs():
     form = LogFindForm().validate_for_api()
-    start, count = paginate()
-    logs = db.session.query(Log).filter()
-    if form.name.data:
-        logs = logs.filter(Log.user_name == form.name.data)
-    if form.start.data and form.end.data:
-        logs = logs.filter(Log.time.between(form.start.data, form.end.data))
-    total_nums = logs.count()
-    logs = logs.order_by(text('time desc')).offset(start).limit(count).all()
-    if logs is None or len(logs) < 1:
-        raise NotFound(msg='没有找到相关日志')
+    logs, total_nums = LogDAO().get_by_paginate(form)
     return jsonify({
         "total_nums": total_nums,
         "collection": logs
@@ -43,20 +32,8 @@ def get_logs():
 @route_meta(auth='搜索日志', module='日志')
 @group_required
 def get_user_logs():
-    keyword = request.args.get('keyword', default=None, type=str)
-    if keyword is None or '':
-        raise ParameterException(msg='搜索关键字不可为空')
-    start, count = paginate()
     form = LogFindForm().validate_for_api()
-    logs = db.session.query(Log).filter(Log.message.like(f'%{keyword}%'))
-    if form.name.data:
-        logs = logs.filter(Log.user_name == form.name.data)
-    if form.start.data and form.end.data:
-        logs = logs.filter(Log._time.between(form.start.data, form.end.data))
-    total_nums = logs.count()
-    logs = logs.order_by(text('time desc')).offset(start).limit(count).all()
-    if logs is None or len(logs) < 1:
-        raise NotFound(msg='没有找到相关日志')
+    logs, total_nums = LogDAO().search_by_keyword(form)
     return jsonify({
         "total_nums": total_nums,
         "collection": logs
@@ -67,9 +44,5 @@ def get_user_logs():
 @route_meta(auth='查询日志记录的用户', module='日志')
 @group_required
 def get_users():
-    start, count = paginate()
-    user_names = db.session.query(Log.user_name).filter_by(soft=False) \
-        .group_by(text('user_name')).having(text('count(user_name) > 0')).offset(start) \
-        .limit(count).all()
-    res = [user_name[0] for user_name in user_names]
-    return jsonify(res)
+    users = LogDAO().get_users_by_paginate()
+    return jsonify(users)