增加多条件查询构造器，删除部分curd层

applications/common/admin/role_curd.py

@@ -1,150 +0,0 @@
-from sqlalchemy import and_
-from applications.common.utils.validate import xss_escape
-from applications.extensions import db
-from applications.models import Role
-from applications.schemas import RoleSchema
-from applications.models.admin_power import Power
-from applications.schemas import PowerSchema2
-from applications.models import User
-
-# 获取角色对象
-from applications.common.curd import model_to_dicts
-
-
-def get_role_data(page, limit, filters):
-    role = Role.query.filter(and_(*[getattr(Role, k).like(v) for k, v in filters.items()])).paginate(page=page,
-                                                                                                     per_page=limit,
-                                                                                                     error_out=False)
-    count = Role.query.count()
-    return role, count
-
-
-# 获取角色dict
-def get_role_data_dict(page, limit, filters):
-    role, count = get_role_data(page, limit, filters)
-    data = model_to_dicts(Schema=RoleSchema, model=role.items)
-    return data, count
-
-
-# 增加角色
-def add_role(req):
-    details = xss_escape(req.get("details"))
-    enable = xss_escape(req.get("enable"))
-    roleCode = xss_escape(req.get("roleCode"))
-    roleName = xss_escape(req.get("roleName"))
-    sort = xss_escape(req.get("sort"))
-    role = Role(
-        details=details,
-        enable=enable,
-        code=roleCode,
-        name=roleName,
-        sort=sort
-    )
-    db.session.add(role)
-    db.session.commit()
-
-
-# 通过id获取角色
-def get_role_by_id(id):
-    r = Role.query.filter_by(id=id).first()
-    return r
-
-
-# 更新角色
-def update_role(req_json):
-    id = req_json.get("roleId")
-    data = {
-        "code": xss_escape(req_json.get("roleCode")),
-        "name": xss_escape(req_json.get("roleName")),
-        "sort": xss_escape(req_json.get("sort")),
-        "enable": xss_escape(req_json.get("enable")),
-        "details": xss_escape(req_json.get("details"))
-    }
-    role = Role.query.filter_by(id=id).update(data)
-    db.session.commit()
-    return role
-
-
-# 获取角色的权限
-def get_role_power(id):
-    role = Role.query.filter_by(id=id).first()
-    check_powers = role.power
-    check_powers_list = []
-    for cp in check_powers:
-        check_powers_list.append(cp.id)
-    powers = Power.query.all()
-    power_schema = PowerSchema2(many=True)  # 用已继承ma.ModelSchema类的自定制类生成序列化类
-    output = power_schema.dump(powers)  # 生成可序列化对象
-    for i in output:
-        if int(i.get("powerId")) in check_powers_list:
-            i["checkArr"] = "1"
-        else:
-            i["checkArr"] = "0"
-    return output
-
-
-# 更新角色权限
-def update_role_power(id, power_list):
-    role = Role.query.filter_by(id=id).first()
-    power_id_list = []
-    for p in role.power:
-        power_id_list.append(p.id)
-        # print(p.id)
-    # print(power_id_list)
-    powers = Power.query.filter(Power.id.in_(power_id_list)).all()
-    for p in powers:
-        role.power.remove(p)
-    powers = Power.query.filter(Power.id.in_(power_list)).all()
-    for p in powers:
-        role.power.append(p)
-    db.session.commit()
-
-
-# 启动角色
-def enable_status(id):
-    enable = 1
-    role = Role.query.filter_by(id=id).update({"enable": enable})
-    if role:
-        db.session.commit()
-        return True
-    return False
-
-
-# 停用角色
-def disable_status(id):
-    enable = 0
-    role = Role.query.filter_by(id=id).update({"enable": enable})
-    if role:
-        db.session.commit()
-        return True
-    return False
-
-
-# 删除角色
-def remove_role(id):
-    role = Role.query.filter_by(id=id).first()
-    # 删除该角色的权限
-    power_id_list = []
-    for p in role.power:
-        power_id_list.append(p.id)
-
-    powers = Power.query.filter(Power.id.in_(power_id_list)).all()
-    for p in powers:
-        role.power.remove(p)
-    user_id_list = []
-    for u in role.user:
-        user_id_list.append(u.id)
-    users = User.query.filter(User.id.in_(user_id_list)).all()
-    for u in users:
-        role.user.remove(u)
-    r = Role.query.filter_by(id=id).delete()
-    db.session.commit()
-    return r
-
-
-# 批量删除
-def batch_remove(ids):
-    # role = Role.query.filter(Role.id.in_(ids)).delete(synchronize_session=False)
-    # db.session.commit()
-    for id in ids:
-        remove_role(id)

applications/common/admin/user_curd.py

@@ -1,160 +0,0 @@
-from flask import jsonify
-from flask_login import current_user
-from sqlalchemy import and_, desc
-from applications.extensions import db
-from applications.models import User
-from applications.schemas import UserSchema
-from applications.models import Role
-from applications.models import AdminLog
-
-# 获取用户的 sqlalchemy 对象分页器
-from applications.common.curd import model_to_dicts
-
-
-def get_user_data(page, limit, filters, deptId):
-    if deptId:
-        user = User.query.filter_by(dept_id=deptId).filter(
-            and_(*[getattr(User, k).like(v) for k, v in filters.items()])).paginate(page=page,
-                                                                                    per_page=limit,
-                                                                                    error_out=False)
-    else:
-        user = User.query.filter(and_(*[getattr(User, k).like(v) for k, v in filters.items()])).paginate(page=page,
-                                                                                                         per_page=limit,
-                                                                                                         error_out=False)
-    count = User.query.count()
-    return user, count
-
-
-# 获取用户的dict数据分页器
-def get_user_data_dict(page, limit, filters, deptId):
-    user, count = get_user_data(page, limit, filters, deptId)
-    data = model_to_dicts(Schema=UserSchema, model=user.items)
-    return data, count
-
-
-# 通过名称获取用户
-def get_user_by_name(username):
-    return User.query.filter_by(username=username).first()
-
-
-# 获取当前用户日志
-def get_current_user_logs():
-    log = AdminLog.query.filter_by(url='/admin/login').filter_by(uid=current_user.id).order_by(
-        desc(AdminLog.create_time)).limit(10)
-    return log
-
-
-# 判断用户是否存在
-def is_user_exists(username):
-    res = User.query.filter_by(username=username).count()
-    return bool(res)
-
-
-# 增加用户
-def add_user(username, realName, password):
-    user = User(username=username, realname=realName)
-    user.set_password(password)
-    db.session.add(user)
-    db.session.commit()
-    return user.id
-
-
-# 增加用户角色
-def add_user_role(id, roles_list):
-    user = User.query.filter_by(id=id).first()
-    roles = Role.query.filter(Role.id.in_(roles_list)).all()
-    for r in roles:
-        user.role.append(r)
-    db.session.commit()
-
-
-# 更新用户头像
-def update_avatar(url):
-    r = User.query.filter_by(id=current_user.id).update({"avatar": url})
-    db.session.commit()
-    return r
-
-
-# 更新用户信息
-def update_user(id, username, realname, deptId):
-    user = User.query.filter_by(id=id).update({'username': username, 'realname': realname, 'dept_id': deptId})
-    db.session.commit()
-    return user
-
-
-# 更新当前用户信息
-def update_current_user_info(req_json):
-    r = User.query.filter_by(id=current_user.id).update(
-        {"realname": req_json.get("realName"), "remark": req_json.get("details")})
-    db.session.commit()
-    return r
-
-
-# 修改当前用户密码
-def edit_password(res_json):
-    if res_json.get("newPassword") == '':
-        return jsonify(success=False, msg="新密码不得为空")
-    if res_json.get("newPassword") != res_json.get("confirmPassword"):
-        return jsonify(success=False, msg="俩次密码不一样")
-    user = current_user
-    is_right = user.validate_password(res_json.get("oldPassword"))
-    if not is_right:
-        return jsonify(success=False, msg="旧密码错误")
-    user.set_password(res_json.get("newPassword"))
-    db.session.add(user)
-    db.session.commit()
-    return jsonify(success=True, msg="更改成功")
-
-
-# 删除用户
-def delete_by_id(id):
-    user = User.query.filter_by(id=id).first()
-    roles_id = []
-    for role in user.role:
-        roles_id.append(role.id)
-    roles = Role.query.filter(Role.id.in_(roles_id)).all()
-    for r in roles:
-        user.role.remove(r)
-    res = User.query.filter_by(id=id).delete()
-    db.session.commit()
-    return res
-
-
-# 启用用户
-def enable_status(id):
-    enable = 1
-    user = User.query.filter_by(id=id).update({"enable": enable})
-    if user:
-        db.session.commit()
-        return True
-    return False
-
-
-# 停用用户
-def disable_status(id):
-    enable = 0
-    user = User.query.filter_by(id=id).update({"enable": enable})
-    if user:
-        db.session.commit()
-        return True
-    return False
-
-
-# 批量删除
-def batch_remove(ids):
-    for id in ids:
-        delete_by_id(id)
-
-
-def update_user_role(id, roles_list):
-    user = User.query.filter_by(id=id).first()
-    roles_id = []
-    for role in user.role:
-        roles_id.append(role.id)
-    roles = Role.query.filter(Role.id.in_(roles_id)).all()
-    for r in roles:
-        user.role.remove(r)
-    roles = Role.query.filter(Role.id.in_(roles_list)).all()
-    for r in roles:
-        user.role.append(r)
-    db.session.commit()

applications/common/curd.py

@@ -1,5 +1,37 @@
+from applications.extensions import db
+
+
 def model_to_dicts(Schema, model):
     # 如果是分页器返回，需要传入model.items
     common_schema = Schema(many=True)  # 用已继承ma.ModelSchema类的自定制类生成序列化类
     output = common_schema.dump(model)  # 生成可序列化对象
     return output
+
+
+def get_one_by_id(model, id):
+    """
+    :param model: 模型类
+    :param id: id
+    :return: 返回单个查询结果
+    """
+    return model.query.filter_by(id=id).first()
+
+
+# 启动状态
+def enable_status(model, id):
+    enable = 1
+    role = model.query.filter_by(id=id).update({"enable": enable})
+    if role:
+        db.session.commit()
+        return True
+    return False
+
+
+# 停用状态
+def disable_status(model, id):
+    enable = 0
+    role = model.query.filter_by(id=id).update({"enable": enable})
+    if role:
+        db.session.commit()
+        return True
+    return False

applications/common/helper.py

@@ -0,0 +1,48 @@
+from sqlalchemy import and_
+
+from applications.extensions import db
+
+
+class ModelFilter:
+    """
+    orm多参数构造器
+    """
+    filter_field = {}
+    filter_list = []
+
+    type_exact = "exact"
+    type_vague = "vague"
+
+    def __init__(self):
+        self.filter_field = {}
+        self.filter_list = []
+
+    def exact(self, field_name, value):
+        """
+        准确查询字段
+        :param field_name: 模型字段名称
+        :param value: 值
+        """
+        if value and value != '':
+            self.filter_field[field_name] = {"data": value, "type": self.type_exact}
+
+    def vague(self, field_name, value: str):
+        """
+        模糊查询字段
+        :param field_name: 模型字段名称
+        :param value: 值
+        """
+        if value and value != '':
+            self.filter_field[field_name] = {"data": ('%' + value + '%'), "type": self.type_vague}
+
+    def get_filter(self, model: db.Model):
+        """
+        获取过滤条件
+        :param model: 模型字段名称
+        """
+        for k, v in self.filter_field.items():
+            if v.get("type") == self.type_vague:
+                self.filter_list.append(getattr(model, k).like(v.get("data")))
+            if v.get("type") == self.type_exact:
+                self.filter_list.append(getattr(model, k) == v.get("data"))
+        return and_(*self.filter_list)

applications/view/admin/role.py

@@ -1,9 +1,13 @@
 from flask import Blueprint, render_template, request, jsonify
 from flask_login import login_required
-from applications.common.admin import role_curd
+from applications.common.curd import model_to_dicts, enable_status, disable_status, get_one_by_id
+from applications.common.helper import ModelFilter
 from applications.common.utils.http import table_api, success_api, fail_api
 from applications.common.utils.rights import authorize
 from applications.common.utils.validate import xss_escape
+from applications.extensions import db
+from applications.models import Role, Power, User
+from applications.schemas import RoleSchema, PowerSchema2
 
 admin_role = Blueprint('adminRole', __name__, url_prefix='/admin/role')
 
@@ -23,19 +27,20 @@ def table():
     limit = request.args.get('limit', type=int)
     role_name = xss_escape(request.args.get('roleName', type=str))
     role_code = xss_escape(request.args.get('roleCode', type=str))
-    filters = {}
+    mf = ModelFilter()
     if role_name:
-        filters["name"] = ('%' + role_name + '%')
+        mf.vague(field_name="name", value=role_name)
     if role_code:
-        filters["code"] = ('%' + role_code + '%')
+        mf.vague(field_name="code", value=role_code)
-    data, count = role_curd.get_role_data_dict(page=page, limit=limit, filters=filters)
+    role = Role.query.filter(mf.get_filter(Role)).paginate(page=page, per_page=limit, error_out=False)
+    count = Role.query.count()
+    data = model_to_dicts(Schema=RoleSchema, model=role.items)
     return table_api(data=data, count=count)
 
 
 # 角色增加
 @admin_role.get('/add')
 @authorize("admin:role:add", log=True)
-@login_required
 def add():
     return render_template('admin/role/add.html')
 
@@ -45,7 +50,20 @@ def add():
 @authorize("admin:role:add", log=True)
 def save():
     req = request.json
-    role_curd.add_role(req=req)
+    details = xss_escape(req.get("details"))
+    enable = xss_escape(req.get("enable"))
+    roleCode = xss_escape(req.get("roleCode"))
+    roleName = xss_escape(req.get("roleName"))
+    sort = xss_escape(req.get("sort"))
+    role = Role(
+        details=details,
+        enable=enable,
+        code=roleCode,
+        name=roleName,
+        sort=sort
+    )
+    db.session.add(role)
+    db.session.commit()
     return success_api(msg="成功")
 
 
@@ -60,9 +78,21 @@ def power(_id):
 @admin_role.get('/getRolePower/<int:id>')
 @authorize("admin:role:main", log=True)
 def get_role_power(id):
-    powers = role_curd.get_role_power(id)
+    role = Role.query.filter_by(id=id).first()
+    check_powers = role.power
+    check_powers_list = []
+    for cp in check_powers:
+        check_powers_list.append(cp.id)
+    powers = Power.query.all()
+    power_schema = PowerSchema2(many=True)  # 用已继承ma.ModelSchema类的自定制类生成序列化类
+    output = power_schema.dump(powers)  # 生成可序列化对象
+    for i in output:
+        if int(i.get("powerId")) in check_powers_list:
+            i["checkArr"] = "1"
+        else:
+            i["checkArr"] = "0"
     res = {
-        "data": powers,
+        "data": output,
         "status": {"code": 200, "message": "默认"}
     }
     return jsonify(res)
@@ -76,7 +106,19 @@ def save_role_power():
     power_ids = req_form.get("powerIds")
     power_list = power_ids.split(',')
     role_id = req_form.get("roleId")
-    role_curd.update_role_power(id=role_id, power_list=power_list)
+    role = Role.query.filter_by(id=role_id).first()
+    power_id_list = []
+    for p in role.power:
+        power_id_list.append(p.id)
+        # print(p.id)
+    # print(power_id_list)
+    powers = Power.query.filter(Power.id.in_(power_id_list)).all()
+    for p in powers:
+        role.power.remove(p)
+    powers = Power.query.filter(Power.id.in_(power_list)).all()
+    for p in powers:
+        role.power.append(p)
+    db.session.commit()
     return success_api(msg="授权成功")
 
 
@@ -84,16 +126,26 @@ def save_role_power():
 @admin_role.get('/edit/<int:_id>')
 @authorize("admin:role:edit", log=True)
 def edit(_id):
-    role = role_curd.get_role_by_id(_id)
+    r = get_one_by_id(model=Role, id=id)
-    return render_template('admin/role/edit.html', role=role)
+    return render_template('admin/role/edit.html', role=r)
 
 
 # 更新角色
 @admin_role.put('/update')
 @authorize("admin:role:edit", log=True)
 def update():
-    res = role_curd.update_role(request.json)
+    req_json = request.json
-    if not res:
+    id = req_json.get("roleId")
+    data = {
+        "code": xss_escape(req_json.get("roleCode")),
+        "name": xss_escape(req_json.get("roleName")),
+        "sort": xss_escape(req_json.get("sort")),
+        "enable": xss_escape(req_json.get("enable")),
+        "details": xss_escape(req_json.get("details"))
+    }
+    role = Role.query.filter_by(id=id).update(data)
+    db.session.commit()
+    if not role:
         return fail_api(msg="更新角色失败")
     return success_api(msg="更新角色成功")
 
@@ -103,9 +155,8 @@ def update():
 @authorize("admin:role:edit", log=True)
 def enable():
     id = request.json.get('roleId')
-    # print(id)
     if id:
-        res = role_curd.enable_status(id)
+        res = enable_status(Role, id)
         if not res:
             return fail_api(msg="出错啦")
         return success_api(msg="启动成功")
@@ -118,7 +169,7 @@ def enable():
 def dis_enable():
     _id = request.json.get('roleId')
     if _id:
-        res = role_curd.disable_status(_id)
+        res = disable_status(Role, _id)
         if not res:
             return fail_api(msg="出错啦")
         return success_api(msg="禁用成功")
@@ -126,11 +177,27 @@ def dis_enable():
 
 
 # 角色删除
-@admin_role.delete('/remove/<int:_id>')
+@admin_role.delete('/remove/<int:id>')
 @authorize("admin:role:remove", log=True)
-def remove(_id):
+def remove(id):
-    res = role_curd.remove_role(_id)
+    role = Role.query.filter_by(id=id).first()
-    if not res:
+    # 删除该角色的权限
+    power_id_list = []
+    for p in role.power:
+        power_id_list.append(p.id)
+
+    powers = Power.query.filter(Power.id.in_(power_id_list)).all()
+    for p in powers:
+        role.power.remove(p)
+    user_id_list = []
+    for u in role.user:
+        user_id_list.append(u.id)
+    users = User.query.filter(User.id.in_(user_id_list)).all()
+    for u in users:
+        role.user.remove(u)
+    r = Role.query.filter_by(id=id).delete()
+    db.session.commit()
+    if not r:
         return fail_api(msg="角色删除失败")
     return success_api(msg="角色删除成功")
 
@@ -141,5 +208,22 @@ def remove(_id):
 @login_required
 def batch_remove():
     ids = request.form.getlist('ids[]')
-    role_curd.batch_remove(ids)
+    for id in ids:
+        role = Role.query.filter_by(id=id).first()
+        # 删除该角色的权限
+        power_id_list = []
+        for p in role.power:
+            power_id_list.append(p.id)
+
+        powers = Power.query.filter(Power.id.in_(power_id_list)).all()
+        for p in powers:
+            role.power.remove(p)
+        user_id_list = []
+        for u in role.user:
+            user_id_list.append(u.id)
+        users = User.query.filter(User.id.in_(user_id_list)).all()
+        for u in users:
+            role.user.remove(u)
+        r = Role.query.filter_by(id=id).delete()
+        db.session.commit()
     return success_api(msg="批量删除成功")

applications/view/admin/user.py

@@ -1,12 +1,16 @@
 from flask import Blueprint, render_template, request
 from flask_login import login_required, current_user
+from sqlalchemy import and_, desc
 
+from applications.common.curd import model_to_dicts, enable_status, disable_status
+from applications.common.helper import ModelFilter
 from applications.common.utils.http import table_api, fail_api, success_api
 from applications.common.utils.rights import authorize
 from applications.common.utils.validate import xss_escape
-from applications.models import User
+from applications.extensions import db
+from applications.models import User, AdminLog
 from applications.models import Role
-from applications.common.admin import user_curd
+from applications.schemas import UserSchema
 
 admin_user = Blueprint('adminUser', __name__, url_prefix='/admin/user')
 
@@ -27,13 +31,19 @@ def data():
     real_name = xss_escape(request.args.get('realName', type=str))
     username = xss_escape(request.args.get('username', type=str))
     dept_id = request.args.get('deptId', type=int)
-    filters = {}
+    mf = ModelFilter()
     if real_name:
-        filters["realname"] = ('%' + real_name + '%')
+        mf.vague(field_name="name", value=real_name)
     if username:
-        filters["username"] = ('%' + username + '%')
+        mf.vague(field_name="username", value=username)
-    user_data, count = user_curd.get_user_data_dict(page=page, limit=limit, filters=filters, deptId=dept_id)
+    if dept_id:
-    return table_api(data=user_data, count=count)
+        mf.exact(field_name="dept_id", value=dept_id)
+    user = User.query.filter(mf.get_filter(model=User)).paginate(page=page,
+                                                                 per_page=limit,
+                                                                 error_out=False)
+    count = User.query.count()
+    data = model_to_dicts(Schema=UserSchema, model=user.items)
+    return table_api(data=data, count=count)
 
 
 # 用户增加
@@ -57,30 +67,42 @@ def save():
     if not username or not real_name or not password:
         return fail_api(msg="账号姓名密码不得为空")
 
-    if user_curd.is_user_exists(username):
+    if bool(User.query.filter_by(username=username).count()):
         return fail_api(msg="用户已经存在")
-
+    user = User(username=username, realname=real_name)
-    _id = user_curd.add_user(username, real_name, password)
+    user.set_password(password)
-    user_curd.add_user_role(_id, role_ids)
+    db.session.add(user)
-
+    user = User.query.filter_by(id=id).first()
+    roles = Role.query.filter(Role.id.in_(role_ids)).all()
+    for r in roles:
+        user.role.append(r)
+    db.session.commit()
     return success_api(msg="增加成功")
 
 
 # 删除用户
-@admin_user.delete('/remove/<int:_id>')
+@admin_user.delete('/remove/<int:id>')
 @authorize("admin:user:remove", log=True)
-def delete(_id):
+def delete(id):
-    res = user_curd.delete_by_id(_id)
+    user = User.query.filter_by(id=id).first()
+    roles_id = []
+    for role in user.role:
+        roles_id.append(role.id)
+    roles = Role.query.filter(Role.id.in_(roles_id)).all()
+    for r in roles:
+        user.role.remove(r)
+    res = User.query.filter_by(id=id).delete()
+    db.session.commit()
     if not res:
         return fail_api(msg="删除失败")
     return success_api(msg="删除成功")
 
 
 #  编辑用户
-@admin_user.get('/edit/<int:_id>')
+@admin_user.get('/edit/<int:id>')
 @authorize("admin:user:edit", log=True)
-def edit(_id):
+def edit(id):
-    user = User.query.filter_by(id=_id).first()
+    user = User.query.filter_by(id=id).first()
     roles = Role.query.all()
     checked_roles = []
     for r in user.role:
@@ -99,8 +121,18 @@ def update():
     real_name = xss_escape(req_json.get('realName'))
     dept_id = xss_escape(req_json.get('deptId'))
     role_ids = a.split(',')
-    user_curd.update_user(id, username, real_name, dept_id)
+    User.query.filter_by(id=id).update({'username': username, 'realname': real_name, 'dept_id': dept_id})
-    user_curd.update_user_role(_id, role_ids)
+    u = User.query.filter_by(id=id).first()
+    roles_id = []
+    for role in u.role:
+        roles_id.append(role.id)
+    roles = Role.query.filter(Role.id.in_(roles_id)).all()
+    for r in roles:
+        u.role.remove(r)
+    roles = Role.query.filter(Role.id.in_(role_ids)).all()
+    for r in roles:
+        u.role.append(r)
+    db.session.commit()
     return success_api(msg="更新成功")
 
 
@@ -109,7 +141,8 @@ def update():
 @login_required
 def center():
     user_info = current_user
-    user_logs = user_curd.get_current_user_logs()
+    user_logs = AdminLog.query.filter_by(url='/admin/login').filter_by(uid=current_user.id).order_by(
+        desc(AdminLog.create_time)).limit(10)
     return render_template('admin/user/center.html', user_info=user_info, user_logs=user_logs)
 
 
@@ -125,7 +158,9 @@ def profile():
 @login_required
 def update_avatar():
     url = request.json.get("avatar").get("src")
-    if not user_curd.update_avatar(url):
+    r = User.query.filter_by(id=current_user.id).update({"avatar": url})
+    db.session.commit()
+    if not r:
         return fail_api(msg="出错啦")
     return success_api(msg="修改成功")
 
@@ -134,8 +169,11 @@ def update_avatar():
 @admin_user.put('/updateInfo')
 @login_required
 def update_info():
-    res_json = request.json
+    req_json = request.json
-    if not user_curd.update_current_user_info(req_json=res_json):
+    r = User.query.filter_by(id=current_user.id).update(
+        {"realname": req_json.get("realName"), "remark": req_json.get("details")})
+    db.session.commit()
+    if not r:
         return fail_api(msg="出错啦")
     return success_api(msg="更新成功")
 
@@ -152,7 +190,18 @@ def edit_password():
 @login_required
 def edit_password_put():
     res_json = request.json
-    return user_curd.edit_password(res_json=res_json)
+    if res_json.get("newPassword") == '':
+        return fail_api("新密码不得为空")
+    if res_json.get("newPassword") != res_json.get("confirmPassword"):
+        return fail_api("俩次密码不一样")
+    user = current_user
+    is_right = user.validate_password(res_json.get("oldPassword"))
+    if not is_right:
+        return fail_api("旧密码错误")
+    user.set_password(res_json.get("newPassword"))
+    db.session.add(user)
+    db.session.commit()
+    return success_api("更改成功")
 
 
 # 启用用户
@@ -161,7 +210,7 @@ def edit_password_put():
 def enable():
     _id = request.json.get('userId')
     if _id:
-        res = user_curd.enable_status(_id)
+        res = enable_status(model=User, id=_id)
         if not res:
             return fail_api(msg="出错啦")
         return success_api(msg="启动成功")
@@ -174,7 +223,7 @@ def enable():
 def dis_enable():
     _id = request.json.get('userId')
     if _id:
-        res = user_curd.disable_status(_id)
+        res = disable_status(model=User,id=_id)
         if not res:
             return fail_api(msg="出错啦")
         return success_api(msg="禁用成功")
@@ -186,5 +235,14 @@ def dis_enable():
 @authorize("admin:user:remove", log=True)
 def batch_remove():
     ids = request.form.getlist('ids[]')
-    user_curd.batch_remove(ids)
+    for id in ids:
+        user = User.query.filter_by(id=id).first()
+        roles_id = []
+        for role in user.role:
+            roles_id.append(role.id)
+        roles = Role.query.filter(Role.id.in_(roles_id)).all()
+        for r in roles:
+            user.role.remove(r)
+        res = User.query.filter_by(id=id).delete()
+        db.session.commit()
     return success_api(msg="批量删除成功")