From 4d9b5508859f259e5fc403727cf5df49ade627e2 Mon Sep 17 00:00:00 2001
From: quanbisen <1769128867@qq.com>
Date: Sat, 1 Apr 2023 15:54:54 +0800
Subject: [PATCH 1/9] add mongo db type management support

---
 sql/engines/__init__.py            |  20 ++
 sql/engines/mongo.py               |  97 ++++++
 sql/engines/mysql.py               | 102 +++++++
 sql/instance_account.py            | 276 ++++++++---------
 sql/instance_database.py           |  63 ++--
 sql/models.py                      |   3 +-
 sql/templates/database.html        | 121 +++++---
 sql/templates/instanceaccount.html | 468 +++++++++++++++++++++--------
 sql/utils/instance_management.py   |  19 ++
 9 files changed, 817 insertions(+), 352 deletions(-)
 create mode 100644 sql/utils/instance_management.py

diff --git a/sql/engines/__init__.py b/sql/engines/__init__.py
index a101abed13..cbdef337d7 100644
--- a/sql/engines/__init__.py
+++ b/sql/engines/__init__.py
@@ -132,6 +132,26 @@ def get_tables_metas_data(self, db_name, **kwargs):
         """获取数据库所有表格信息，用作数据字典导出接口"""
         return list()
 
+    def get_all_databases_summary(self):
+        """实例数据库管理功能，获取实例所有的数据库描述信息"""
+        return ResultSet()
+
+    def get_instance_users_summary(self):
+        """实例账号管理功能，获取实例所有账号信息"""
+        return ResultSet()
+
+    def create_instance_user(self, **kwargs):
+        """实例账号管理功能，创建实例账号"""
+        return ResultSet()
+
+    def drop_instance_user(self, **kwargs):
+        """实例账号管理功能，删除实例账号"""
+        return ResultSet()
+
+    def reset_instance_user_pwd(self, **kwargs):
+        """实例账号管理功能，重置实例账号密码"""
+        return ResultSet()
+
     def get_all_columns_by_tb(self, db_name, tb_name, **kwargs):
         """获取所有字段, 返回一个ResultSet，rows=list"""
         return ResultSet()
diff --git a/sql/engines/mongo.py b/sql/engines/mongo.py
index 7a0f480a42..23587a1962 100644
--- a/sql/engines/mongo.py
+++ b/sql/engines/mongo.py
@@ -1270,3 +1270,100 @@ def kill_op(self, opids):
                 f"mongodb语句执行killOp报错，语句：db.runCommand({sql}) ，错误信息{traceback.format_exc()}"
             )
             result.error = str(e)
+
+    def get_all_databases_summary(self):
+        """实例数据库管理功能，获取实例所有的数据库描述信息"""
+        query_result = self.get_all_databases()
+        if not query_result.error:
+            dbs = query_result.rows
+            conn = self.get_connection()
+
+            # 获取数据库用户信息
+            rows = []
+            for db_name in dbs:
+                # 执行语句
+                listing = conn[db_name].command(command='usersInfo')
+                grantees = []
+                for user_obj in listing['users']:
+                    grantees.append({
+                        'user': user_obj['user'],
+                        'roles': user_obj['roles']
+                    }.__str__())
+                row = {
+                    "db_name": db_name,
+                    "grantees": grantees,
+                    "saved": False,
+                }
+                rows.append(row)
+            query_result.rows = rows
+        return query_result
+
+    def get_instance_users_summary(self):
+        """实例账号管理功能，获取实例所有账号信息"""
+        query_result = self.get_all_databases()
+        if not query_result.error:
+            dbs = query_result.rows
+            conn = self.get_connection()
+
+            # 获取数据库用户信息
+            rows = []
+            for db_name in dbs:
+                # 执行语句
+                listing = conn[db_name].command(command='usersInfo')
+                for user_obj in listing['users']:
+                    rows.append({
+                        "db_name_user": f"{db_name}.{user_obj['user']}",
+                        "db_name": db_name,
+                        "user": user_obj['user'],
+                        "roles": [role['role'] for role in user_obj['roles']],
+                        "saved": False,
+                    })
+            query_result.rows = rows
+        return query_result
+
+    def create_instance_user(self, **kwargs):
+        """实例账号管理功能，创建实例账号"""
+        exec_result = ResultSet()
+        db_name = kwargs.get("db_name", "")
+        user = kwargs.get("user", "")
+        password1 = kwargs.get("password1", "")
+        remark = kwargs.get("remark", "")
+        try:
+            conn = self.get_connection()
+            conn[db_name].command("createUser", user, pwd=password1, roles=[])
+            exec_result.rows = [{
+                "instance": self.instance,
+                "db_name": db_name,
+                "user": user,
+                "password": password1,
+                "remark": remark
+            }]
+        except Exception as e:
+            exec_result.error = str(e)
+        return exec_result
+
+    def drop_instance_user(self, db_name_user: str, **kwarg):
+        """实例账号管理功能，删除实例账号"""
+        arr = db_name_user.split(".")
+        db_name = arr[0]
+        user = arr[1]
+        exec_result = ResultSet()
+        try:
+            conn = self.get_connection()
+            conn[db_name].command("dropUser", user)
+        except Exception as e:
+            exec_result.error = str(e)
+        return exec_result
+
+    def reset_instance_user_pwd(self, db_name_user: str, reset_pwd: str, **kwargs):
+        """实例账号管理功能，重置实例账号密码"""
+        arr = db_name_user.split(".")
+        db_name = arr[0]
+        user = arr[1]
+        exec_result = ResultSet()
+        try:
+            conn = self.get_connection()
+            conn[db_name].command("updateUser", user, pwd=reset_pwd)
+        except Exception as e:
+            exec_result.error = str(e)
+        return exec_result
diff --git a/sql/engines/mysql.py b/sql/engines/mysql.py
index ee47fd4240..9d42af6c3b 100644
--- a/sql/engines/mysql.py
+++ b/sql/engines/mysql.py
@@ -282,6 +282,108 @@ def get_tables_metas_data(self, db_name, **kwargs):
             table_metas.append(_meta)
         return table_metas
 
+    def get_all_databases_summary(self):
+        """实例数据库管理功能，获取实例所有的数据库描述信息"""
+        # 获取所有数据库
+        sql_get_db = """SELECT SCHEMA_NAME,DEFAULT_CHARACTER_SET_NAME,DEFAULT_COLLATION_NAME 
+        FROM information_schema.SCHEMATA
+        WHERE SCHEMA_NAME NOT IN ('information_schema', 'performance_schema', 'mysql', 'test', 'sys');"""
+        query_result = self.query(
+            "information_schema", sql_get_db, close_conn=False
+        )
+        if not query_result.error:
+            dbs = query_result.rows
+            # 获取数据库关联用户信息
+            rows = []
+            for db in dbs:
+                db_name = db[0]
+                sql_get_bind_users = f"""select group_concat(distinct(GRANTEE)),TABLE_SCHEMA
+        from information_schema.SCHEMA_PRIVILEGES
+        where TABLE_SCHEMA='{db_name}'
+        group by TABLE_SCHEMA;"""
+                bind_users = self.query(
+                    "information_schema", sql_get_bind_users, close_conn=False
+                ).rows
+                row = {
+                    "db_name": db_name,
+                    "charset": db[1],
+                    "collation": db[2],
+                    "grantees": bind_users[0][0].split(",") if bind_users else [],
+                    "saved": False,
+                }
+                rows.append(row)
+            query_result.rows = rows
+        return query_result
+
+    def get_instance_users_summary(self):
+        """实例账号管理功能，获取实例所有账号信息"""
+        server_version = self.server_version
+        # MySQL 5.7.6版本起支持ACCOUNT LOCK
+        if server_version >= (5, 7, 6):
+            sql_get_user = "select concat('`', user, '`', '@', '`', host,'`') as query,user,host,account_locked from mysql.user;"
+        else:
+            sql_get_user = "select concat('`', user, '`', '@', '`', host,'`') as query,user,host from mysql.user;"
+        query_result = self.query("mysql", sql_get_user)
+        if not query_result.error:
+            db_users = query_result.rows
+            # 获取用户权限信息
+            rows = []
+            for db_user in db_users:
+                user_host = db_user[0]
+                user_priv = self.query(
+                    "mysql", "show grants for {};".format(user_host), close_conn=False
+                ).rows
+                row = {
+                    "user_host": user_host,
+                    "user": db_user[1],
+                    "host": db_user[2],
+                    "privileges": user_priv,
+                    "saved": False,
+                    "is_locked": db_user[3] if server_version >= (5, 7, 6) else None,
+                }
+                rows.append(row)
+            query_result.rows = rows
+        return query_result
+
+    def create_instance_user(self, **kwargs):
+        """实例账号管理功能，创建实例账号"""
+        # escape
+        user = MySQLdb.escape_string(kwargs.get("user", "")).decode("utf-8")
+        host = MySQLdb.escape_string(kwargs.get("host", "")).decode("utf-8")
+        password1 = MySQLdb.escape_string(kwargs.get("password1", "")).decode("utf-8")
+        remark = kwargs.get("remark", "")
+        # 在一个事务内执行
+        hosts = host.split("|")
+        create_user_cmd = ""
+        accounts = []
+        for host in hosts:
+            create_user_cmd += f"create user '{user}'@'{host}' identified by '{password1}';"
+            accounts.append({
+                "instance": self.instance,
+                "user": user,
+                "host": host,
+                "password": password1,
+                "remark": remark
+            })
+        exec_result = self.execute(db_name="mysql", sql=create_user_cmd)
+        exec_result.rows = accounts
+        return exec_result
+
+    def drop_instance_user(self, user_host: str, **kwarg):
+        """实例账号管理功能，删除实例账号"""
+        # escape
+        user_host = MySQLdb.escape_string(user_host).decode("utf-8")
+        return self.execute(db_name="mysql", sql=f"DROP USER {user_host};")
+
+    def reset_instance_user_pwd(self, user_host: str, reset_pwd: str, **kwargs):
+        """实例账号管理功能，重置实例账号密码"""
+        # escape
+        user_host = MySQLdb.escape_string(user_host).decode("utf-8")
+        reset_pwd = MySQLdb.escape_string(reset_pwd).decode("utf-8")
+        return self.execute(
+            db_name="mysql", sql=f"ALTER USER {user_host} IDENTIFIED BY '{reset_pwd}';"
+        )
+
     def get_all_columns_by_tb(self, db_name, tb_name, **kwargs):
         """获取所有字段, 返回一个ResultSet"""
         sql = f"""SELECT
diff --git a/sql/instance_account.py b/sql/instance_account.py
index 06b71fe961..20c0f406ae 100644
--- a/sql/instance_account.py
+++ b/sql/instance_account.py
@@ -6,9 +6,10 @@
 from django.core.exceptions import ValidationError
 
 from django.http import HttpResponse, JsonResponse
-
+from sql.utils.instance_management import SUPPORTED_MANAGEMENT_DB_TYPE, \
+    get_instanceaccount_unique_value, get_instanceaccount_unique_key
 from common.utils.extend_json_encoder import ExtendJSONEncoder
-from sql.engines import get_engine
+from sql.engines import get_engine, ResultSet
 from sql.utils.resource_group import user_instances
 from .models import Instance, InstanceAccount
 
@@ -22,46 +23,27 @@ def users(request):
     if not instance_id:
         return JsonResponse({"status": 0, "msg": "", "data": []})
     try:
-        instance = user_instances(request.user, db_type=["mysql"]).get(id=instance_id)
+        instance = user_instances(request.user, db_type=SUPPORTED_MANAGEMENT_DB_TYPE).get(id=instance_id)
     except Instance.DoesNotExist:
         return JsonResponse({"status": 1, "msg": "你所在组未关联该实例", "data": []})
 
     # 获取已录入用户
     cnf_users = dict()
     for user in InstanceAccount.objects.filter(instance=instance).values(
-        "id", "user", "host", "remark"
+        "id", "user", "host", "db_name", "remark"
     ):
         user["saved"] = True
-        cnf_users[f"`{user['user']}`@`{user['host']}`"] = user
+        cnf_users[get_instanceaccount_unique_value(instance.db_type, user)] = user
     # 获取所有用户
     query_engine = get_engine(instance=instance)
-    server_version = query_engine.server_version
-    # MySQL 5.7.6版本起支持ACCOUNT LOCK
-    if server_version >= (5, 7, 6):
-        sql_get_user = "select concat('`', user, '`', '@', '`', host,'`') as query,user,host,account_locked from mysql.user;"
-    else:
-        sql_get_user = "select concat('`', user, '`', '@', '`', host,'`') as query,user,host from mysql.user;"
-    query_result = query_engine.query("mysql", sql_get_user)
+    query_result = query_engine.get_instance_users_summary()
     if not query_result.error:
-        db_users = query_result.rows
-        # 获取用户权限信息
         rows = []
-        for db_user in db_users:
-            user_host = db_user[0]
-            user_priv = query_engine.query(
-                "mysql", "show grants for {};".format(user_host), close_conn=False
-            ).rows
-            row = {
-                "user_host": user_host,
-                "user": db_user[1],
-                "host": db_user[2],
-                "privileges": user_priv,
-                "saved": False,
-                "is_locked": db_user[3] if server_version >= (5, 7, 6) else None,
-            }
+        key = get_instanceaccount_unique_key(db_type=instance.db_type)
+        for row in query_result.rows:
             # 合并数据
-            if user_host in cnf_users.keys():
-                row = dict(row, **cnf_users[user_host])
+            if row[key] in cnf_users.keys():
+                row = dict(row, **cnf_users[row[key]])
             rows.append(row)
         # 过滤参数
         if saved:
@@ -83,6 +65,7 @@ def users(request):
 def create(request):
     """创建数据库账号"""
     instance_id = request.POST.get("instance_id", 0)
+    db_name = request.POST.get("db_name")
     user = request.POST.get("user")
     host = request.POST.get("host")
     password1 = request.POST.get("password1")
@@ -90,11 +73,12 @@ def create(request):
     remark = request.POST.get("remark", "")
 
     try:
-        instance = user_instances(request.user, db_type=["mysql"]).get(id=instance_id)
+        instance = user_instances(request.user, db_type=SUPPORTED_MANAGEMENT_DB_TYPE).get(id=instance_id)
     except Instance.DoesNotExist:
         return JsonResponse({"status": 1, "msg": "你所在组未关联该实例", "data": []})
 
-    if not all([user, host, password1, password2]):
+    if (instance.db_type == 'mysql' and not all([user, host, password1, password2])) or \
+            (instance.db_type == 'mongo' and not all([db_name, user, password1, password2])):
         return JsonResponse({"status": 1, "msg": "参数不完整，请确认后提交", "data": []})
 
     if password1 != password2:
@@ -106,34 +90,18 @@ def create(request):
     except ValidationError as msg:
         return JsonResponse({"status": 1, "msg": f"{msg}", "data": []})
 
-    # escape
-    user = MySQLdb.escape_string(user).decode("utf-8")
-    host = MySQLdb.escape_string(host).decode("utf-8")
-    password1 = MySQLdb.escape_string(password1).decode("utf-8")
-
     engine = get_engine(instance=instance)
-    # 在一个事务内执行
-    hosts = host.split("|")
-    create_user_cmd = ""
-    accounts = []
-    for host in hosts:
-        create_user_cmd += f"create user '{user}'@'{host}' identified by '{password1}';"
-        accounts.append(
-            InstanceAccount(
-                instance=instance,
-                user=user,
-                host=host,
-                password=password1,
-                remark=remark,
-            )
-        )
-    exec_result = engine.execute(db_name="mysql", sql=create_user_cmd)
+    exec_result = engine.create_instance_user(db_name=db_name, user=user, host=host, password1=password1, remark=remark)
+    # 关闭连接
+    engine.close()
     if exec_result.error:
         return JsonResponse({"status": 1, "msg": exec_result.error})
 
     # 保存到数据库
     else:
+        accounts = [InstanceAccount(**row) for row in exec_result.rows]
         InstanceAccount.objects.bulk_create(accounts)
+
     return JsonResponse({"status": 0, "msg": "", "data": []})
 
 
@@ -141,17 +109,19 @@ def create(request):
 def edit(request):
     """修改、录入数据库账号"""
     instance_id = request.POST.get("instance_id", 0)
+    db_name = request.POST.get("db_name", "")
     user = request.POST.get("user")
-    host = request.POST.get("host")
+    host = request.POST.get("host", "")
     password = request.POST.get("password")
     remark = request.POST.get("remark", "")
 
     try:
-        instance = user_instances(request.user, db_type=["mysql"]).get(id=instance_id)
+        instance = user_instances(request.user, db_type=SUPPORTED_MANAGEMENT_DB_TYPE).get(id=instance_id)
     except Instance.DoesNotExist:
         return JsonResponse({"status": 1, "msg": "你所在组未关联该实例", "data": []})
 
-    if not all([user, host]):
+    if (instance.db_type == 'mysql' and not all([user, host])) or \
+            (instance.db_type == 'mongo' and not all([db_name, user])):
         return JsonResponse({"status": 1, "msg": "参数不完整，请确认后提交", "data": []})
 
     # 保存到数据库
@@ -160,11 +130,12 @@ def edit(request):
             instance=instance,
             user=user,
             host=host,
+            db_name=db_name,
             defaults={"password": password, "remark": remark},
         )
     else:
         InstanceAccount.objects.update_or_create(
-            instance=instance, user=user, host=host, defaults={"remark": remark}
+            instance=instance, user=user, host=host, db_name=db_name, defaults={"remark": remark}
         )
     return JsonResponse({"status": 0, "msg": "", "data": []})
 
@@ -173,77 +144,93 @@ def edit(request):
 def grant(request):
     """获取用户权限变更语句，并执行权限变更"""
     instance_id = request.POST.get("instance_id", 0)
-    user_host = request.POST.get("user_host")
-    op_type = int(request.POST.get("op_type"))
-    priv_type = int(request.POST.get("priv_type"))
-    privs = json.loads(request.POST.get("privs"))
     grant_sql = ""
 
-    # escape
-    user_host = MySQLdb.escape_string(user_host).decode("utf-8")
-
-    # 全局权限
-    if priv_type == 0:
-        global_privs = privs["global_privs"]
-        if not all([global_privs]):
-            return JsonResponse({"status": 1, "msg": "信息不完整，请确认后提交", "data": []})
-        global_privs = ["GRANT OPTION" if g == "GRANT" else g for g in global_privs]
-        if op_type == 0:
-            grant_sql = f"GRANT {','.join(global_privs)} ON *.* TO {user_host};"
-        elif op_type == 1:
-            grant_sql = f"REVOKE {','.join(global_privs)} ON *.* FROM {user_host};"
-
-    # 库权限
-    elif priv_type == 1:
-        db_privs = privs["db_privs"]
-        db_name = request.POST.getlist("db_name[]")
-        if not all([db_privs, db_name]):
-            return JsonResponse({"status": 1, "msg": "信息不完整，请确认后提交", "data": []})
-        for db in db_name:
-            db_privs = ["GRANT OPTION" if d == "GRANT" else d for d in db_privs]
-            if op_type == 0:
-                grant_sql += f"GRANT {','.join(db_privs)} ON `{db}`.* TO {user_host};"
-            elif op_type == 1:
-                grant_sql += (
-                    f"REVOKE {','.join(db_privs)} ON `{db}`.* FROM {user_host};"
-                )
-    # 表权限
-    elif priv_type == 2:
-        tb_privs = privs["tb_privs"]
-        db_name = request.POST.get("db_name")
-        tb_name = request.POST.getlist("tb_name[]")
-        if not all([tb_privs, db_name, tb_name]):
-            return JsonResponse({"status": 1, "msg": "信息不完整，请确认后提交", "data": []})
-        for tb in tb_name:
-            tb_privs = ["GRANT OPTION" if t == "GRANT" else t for t in tb_privs]
-            if op_type == 0:
-                grant_sql += (
-                    f"GRANT {','.join(tb_privs)} ON `{db_name}`.`{tb}` TO {user_host};"
-                )
-            elif op_type == 1:
-                grant_sql += f"REVOKE {','.join(tb_privs)} ON `{db_name}`.`{tb}` FROM {user_host};"
-    # 列权限
-    elif priv_type == 3:
-        col_privs = privs["col_privs"]
-        db_name = request.POST.get("db_name")
-        tb_name = request.POST.get("tb_name")
-        col_name = request.POST.getlist("col_name[]")
-        if not all([col_privs, db_name, tb_name, col_name]):
-            return JsonResponse({"status": 1, "msg": "信息不完整，请确认后提交", "data": []})
-        for priv in col_privs:
-            if op_type == 0:
-                grant_sql += f"GRANT {priv}(`{'`,`'.join(col_name)}`) ON `{db_name}`.`{tb_name}` TO {user_host};"
-            elif op_type == 1:
-                grant_sql += f"REVOKE {priv}(`{'`,`'.join(col_name)}`) ON `{db_name}`.`{tb_name}` FROM {user_host};"
-
-    # 执行变更语句
     try:
-        instance = user_instances(request.user, db_type=["mysql"]).get(id=instance_id)
+        instance = user_instances(request.user, db_type=SUPPORTED_MANAGEMENT_DB_TYPE).get(id=instance_id)
     except Instance.DoesNotExist:
         return JsonResponse({"status": 1, "msg": "你所在组未关联该实例", "data": []})
 
     engine = get_engine(instance=instance)
-    exec_result = engine.execute(db_name="mysql", sql=grant_sql)
+    if instance.db_type == 'mysql':
+        user_host = request.POST.get("user_host")
+        op_type = int(request.POST.get("op_type"))
+        priv_type = int(request.POST.get("priv_type"))
+        privs = json.loads(request.POST.get("privs"))
+
+        # escape
+        user_host = MySQLdb.escape_string(user_host).decode("utf-8")
+
+        # 全局权限
+        if priv_type == 0:
+            global_privs = privs["global_privs"]
+            if not all([global_privs]):
+                return JsonResponse({"status": 1, "msg": "信息不完整，请确认后提交", "data": []})
+            global_privs = ["GRANT OPTION" if g == "GRANT" else g for g in global_privs]
+            if op_type == 0:
+                grant_sql = f"GRANT {','.join(global_privs)} ON *.* TO {user_host};"
+            elif op_type == 1:
+                grant_sql = f"REVOKE {','.join(global_privs)} ON *.* FROM {user_host};"
+
+        # 库权限
+        elif priv_type == 1:
+            db_privs = privs["db_privs"]
+            db_name = request.POST.getlist("db_name[]")
+            if not all([db_privs, db_name]):
+                return JsonResponse({"status": 1, "msg": "信息不完整，请确认后提交", "data": []})
+            for db in db_name:
+                db_privs = ["GRANT OPTION" if d == "GRANT" else d for d in db_privs]
+                if op_type == 0:
+                    grant_sql += f"GRANT {','.join(db_privs)} ON `{db}`.* TO {user_host};"
+                elif op_type == 1:
+                    grant_sql += (
+                        f"REVOKE {','.join(db_privs)} ON `{db}`.* FROM {user_host};"
+                    )
+        # 表权限
+        elif priv_type == 2:
+            tb_privs = privs["tb_privs"]
+            db_name = request.POST.get("db_name")
+            tb_name = request.POST.getlist("tb_name[]")
+            if not all([tb_privs, db_name, tb_name]):
+                return JsonResponse({"status": 1, "msg": "信息不完整，请确认后提交", "data": []})
+            for tb in tb_name:
+                tb_privs = ["GRANT OPTION" if t == "GRANT" else t for t in tb_privs]
+                if op_type == 0:
+                    grant_sql += (
+                        f"GRANT {','.join(tb_privs)} ON `{db_name}`.`{tb}` TO {user_host};"
+                    )
+                elif op_type == 1:
+                    grant_sql += f"REVOKE {','.join(tb_privs)} ON `{db_name}`.`{tb}` FROM {user_host};"
+        # 列权限
+        elif priv_type == 3:
+            col_privs = privs["col_privs"]
+            db_name = request.POST.get("db_name")
+            tb_name = request.POST.get("tb_name")
+            col_name = request.POST.getlist("col_name[]")
+            if not all([col_privs, db_name, tb_name, col_name]):
+                return JsonResponse({"status": 1, "msg": "信息不完整，请确认后提交", "data": []})
+            for priv in col_privs:
+                if op_type == 0:
+                    grant_sql += f"GRANT {priv}(`{'`,`'.join(col_name)}`) ON `{db_name}`.`{tb_name}` TO {user_host};"
+                elif op_type == 1:
+                    grant_sql += f"REVOKE {priv}(`{'`,`'.join(col_name)}`) ON `{db_name}`.`{tb_name}` FROM {user_host};"
+        # 执行变更语句
+        exec_result = engine.execute(db_name="mysql", sql=grant_sql)
+    elif instance.db_type == 'mongo':
+        db_name_user = request.POST.get("db_name_user")
+        roles = request.POST.getlist("roles[]")
+        arr = db_name_user.split(".")
+        db_name = arr[0]
+        user = arr[1]
+        exec_result = ResultSet()
+        try:
+            conn = engine.get_connection()
+            conn[db_name].command("updateUser", user, roles=roles)
+        except Exception as e:
+            exec_result.error = str(e)
+
+    # 关闭连接
+    engine.close()
     if exec_result.error:
         return JsonResponse({"status": 1, "msg": exec_result.error})
     return JsonResponse({"status": 0, "msg": "", "data": grant_sql})
@@ -253,26 +240,25 @@ def grant(request):
 def reset_pwd(request):
     """创建数据库账号"""
     instance_id = request.POST.get("instance_id", 0)
+    db_name_user = request.POST.get("db_name_user")
+    db_name = request.POST.get("db_name", "")
     user_host = request.POST.get("user_host")
     user = request.POST.get("user")
-    host = request.POST.get("host")
+    host = request.POST.get("host", "")
     reset_pwd1 = request.POST.get("reset_pwd1")
     reset_pwd2 = request.POST.get("reset_pwd2")
 
-    if not all([user, host, reset_pwd1, reset_pwd2]):
-        return JsonResponse({"status": 1, "msg": "参数不完整，请确认后提交", "data": []})
-
-    if reset_pwd1 != reset_pwd2:
-        return JsonResponse({"status": 1, "msg": "两次输入密码不一致", "data": []})
-
     try:
-        instance = user_instances(request.user, db_type=["mysql"]).get(id=instance_id)
+        instance = user_instances(request.user, db_type=SUPPORTED_MANAGEMENT_DB_TYPE).get(id=instance_id)
     except Instance.DoesNotExist:
         return JsonResponse({"status": 1, "msg": "你所在组未关联该实例", "data": []})
 
-    # escape
-    user_host = MySQLdb.escape_string(user_host).decode("utf-8")
-    reset_pwd1 = MySQLdb.escape_string(reset_pwd1).decode("utf-8")
+    if (instance.db_type == 'mysql' and not all([user, host, reset_pwd1, reset_pwd2])) or \
+            (instance.db_type == 'mongo' and not all([db_name, user, reset_pwd1, reset_pwd2])):
+        return JsonResponse({"status": 1, "msg": "参数不完整，请确认后提交", "data": []})
+
+    if reset_pwd1 != reset_pwd2:
+        return JsonResponse({"status": 1, "msg": "两次输入密码不一致", "data": []})
 
     # TODO 目前使用系统自带验证，后续实现验证器校验
     try:
@@ -281,17 +267,18 @@ def reset_pwd(request):
         return JsonResponse({"status": 1, "msg": f"{msg}", "data": []})
 
     engine = get_engine(instance=instance)
-    exec_result = engine.execute(
-        db_name="mysql", sql=f"ALTER USER {user_host} IDENTIFIED BY '{reset_pwd1}';"
-    )
+    exec_result = engine.reset_instance_user_pwd(user_host=user_host, db_name_user=db_name_user, reset_pwd=reset_pwd1)
+    # 关闭连接
+    engine.close()
     if exec_result.error:
         result = {"status": 1, "msg": exec_result.error}
         return HttpResponse(json.dumps(result), content_type="application/json")
     # 保存到数据库
     else:
         InstanceAccount.objects.update_or_create(
-            instance=instance, user=user, host=host, defaults={"password": reset_pwd1}
+            instance=instance, user=user, host=host, db_name=db_name, defaults={"password": reset_pwd1}
         )
+
     return JsonResponse({"status": 0, "msg": "", "data": []})
 
 
@@ -330,26 +317,29 @@ def lock(request):
 def delete(request):
     """删除账号"""
     instance_id = request.POST.get("instance_id", 0)
+    db_name_user = request.POST.get("db_name_user")
+    db_name = request.POST.get("db_name")
     user_host = request.POST.get("user_host")
     user = request.POST.get("user")
     host = request.POST.get("host")
 
-    if not all([user_host]):
-        return JsonResponse({"status": 1, "msg": "参数不完整，请确认后提交", "data": []})
-
     try:
-        instance = user_instances(request.user, db_type=["mysql"]).get(id=instance_id)
+        instance = user_instances(request.user, db_type=SUPPORTED_MANAGEMENT_DB_TYPE).get(id=instance_id)
     except Instance.DoesNotExist:
         return JsonResponse({"status": 1, "msg": "你所在组未关联该实例", "data": []})
 
-    # escape
-    user_host = MySQLdb.escape_string(user_host).decode("utf-8")
+    if (instance.db_type == 'mysql' and not all([user_host])) or \
+            (instance.db_type == 'mongo' and not all([db_name_user])):
+        return JsonResponse({"status": 1, "msg": "参数不完整，请确认后提交", "data": []})
 
     engine = get_engine(instance=instance)
-    exec_result = engine.execute(db_name="mysql", sql=f"DROP USER {user_host};")
+    exec_result = engine.drop_instance_user(user_host=user_host, db_name_user=db_name_user)
+    # 关闭连接
+    engine.close()
     if exec_result.error:
         return JsonResponse({"status": 1, "msg": exec_result.error})
     # 删除数据库对应记录
     else:
-        InstanceAccount.objects.filter(instance=instance, user=user, host=host).delete()
+        InstanceAccount.objects.filter(instance=instance, user=user, host=host, db_name=db_name).delete()
+
     return JsonResponse({"status": 0, "msg": "", "data": []})
diff --git a/sql/instance_database.py b/sql/instance_database.py
index 15d1572c35..b82ca15849 100644
--- a/sql/instance_database.py
+++ b/sql/instance_database.py
@@ -13,7 +13,7 @@
 from django_redis import get_redis_connection
 
 from common.utils.extend_json_encoder import ExtendJSONEncoder
-from sql.engines import get_engine
+from sql.engines import get_engine, ResultSet
 from sql.models import Instance, InstanceDatabase, Users
 from sql.utils.resource_group import user_instances
 
@@ -30,7 +30,7 @@ def databases(request):
         return JsonResponse({"status": 0, "msg": "", "data": []})
 
     try:
-        instance = user_instances(request.user, db_type=["mysql"]).get(id=instance_id)
+        instance = user_instances(request.user, db_type=["mysql", "mongo"]).get(id=instance_id)
     except Instance.DoesNotExist:
         return JsonResponse({"status": 1, "msg": "你所在组未关联该实例", "data": []})
 
@@ -42,42 +42,17 @@ def databases(request):
         db["saved"] = True
         cnf_dbs[f"{db['db_name']}"] = db
 
-    # 获取所有数据库
-    sql_get_db = """SELECT SCHEMA_NAME,DEFAULT_CHARACTER_SET_NAME,DEFAULT_COLLATION_NAME 
-FROM information_schema.SCHEMATA
-WHERE SCHEMA_NAME NOT IN ('information_schema', 'performance_schema', 'mysql', 'test', 'sys');"""
     query_engine = get_engine(instance=instance)
-    query_result = query_engine.query(
-        "information_schema", sql_get_db, close_conn=False
-    )
+    query_result = query_engine.get_all_databases_summary()
     if not query_result.error:
-        dbs = query_result.rows
         # 获取数据库关联用户信息
         rows = []
-        for db in dbs:
-            db_name = db[0]
-            sql_get_bind_users = f"""select group_concat(distinct(GRANTEE)),TABLE_SCHEMA
-from information_schema.SCHEMA_PRIVILEGES
-where TABLE_SCHEMA='{db_name}'
-group by TABLE_SCHEMA;"""
-            bind_users = query_engine.query(
-                "information_schema", sql_get_bind_users, close_conn=False
-            ).rows
-            row = {
-                "db_name": db_name,
-                "charset": db[1],
-                "collation": db[2],
-                "grantees": bind_users[0][0].split(",") if bind_users else [],
-                "saved": False,
-            }
-            # 合并数据
-            if db_name in cnf_dbs.keys():
-                row = dict(row, **cnf_dbs[db_name])
+        for row in query_result.rows:
+            if row["db_name"] in cnf_dbs.keys():
+                row = dict(row, **cnf_dbs[row["db_name"]])
             rows.append(row)
-        # 过滤参数
         if saved:
             rows = [row for row in rows if row["saved"]]
-
         result = {"status": 0, "msg": "ok", "rows": rows}
     else:
         result = {"status": 1, "msg": query_result.error}
@@ -102,7 +77,7 @@ def create(request):
         return JsonResponse({"status": 1, "msg": "参数不完整，请确认后提交", "data": []})
 
     try:
-        instance = user_instances(request.user, db_type=["mysql"]).get(id=instance_id)
+        instance = user_instances(request.user, db_type=["mysql", "mongo"]).get(id=instance_id)
     except Instance.DoesNotExist:
         return JsonResponse({"status": 1, "msg": "你所在组未关联该实例", "data": []})
 
@@ -111,13 +86,22 @@ def create(request):
     except Users.DoesNotExist:
         return JsonResponse({"status": 1, "msg": "负责人不存在", "data": []})
 
-    # escape
-    db_name = MySQLdb.escape_string(db_name).decode("utf-8")
-
     engine = get_engine(instance=instance)
-    exec_result = engine.execute(
-        db_name="information_schema", sql=f"create database {db_name};"
-    )
+    if instance.db_type == 'mysql':
+        # escape
+        db_name = MySQLdb.escape_string(db_name).decode("utf-8")
+        exec_result = engine.execute(db_name="information_schema", sql=f"create database {db_name};")
+    elif instance.db_type == 'mongo':
+        exec_result = ResultSet()
+        try:
+            conn = engine.get_connection()
+            db = conn[db_name]
+            db.create_collection(name=f'archery-{db_name}')  # mongo创建数据库，需要数据库存在数据才会显示数据库名称，这里创建一个archery-{db_name}的集合
+        except Exception as e:
+            exec_result.error = f'创建数据库失败, 错误信息：{str(e)}'
+
+    # 关闭连接
+    engine.close()
     if exec_result.error:
         return JsonResponse({"status": 1, "msg": exec_result.error})
     # 保存到数据库
@@ -133,6 +117,7 @@ def create(request):
         r = get_redis_connection("default")
         for key in r.scan_iter(match="*insRes*", count=2000):
             r.delete(key)
+
     return JsonResponse({"status": 0, "msg": "", "data": []})
 
 
@@ -148,7 +133,7 @@ def edit(request):
         return JsonResponse({"status": 1, "msg": "参数不完整，请确认后提交", "data": []})
 
     try:
-        instance = user_instances(request.user, db_type=["mysql"]).get(id=instance_id)
+        instance = user_instances(request.user, db_type=["mysql", "mongo"]).get(id=instance_id)
     except Instance.DoesNotExist:
         return JsonResponse({"status": 1, "msg": "你所在组未关联该实例", "data": []})
 
diff --git a/sql/models.py b/sql/models.py
index 4cc7b316db..b66a3048f0 100755
--- a/sql/models.py
+++ b/sql/models.py
@@ -605,7 +605,8 @@ class InstanceAccount(models.Model):
 
     instance = models.ForeignKey(Instance, on_delete=models.CASCADE)
     user = fields.EncryptedCharField(verbose_name="账号", max_length=128)
-    host = models.CharField(verbose_name="主机", max_length=64)
+    host = models.CharField(verbose_name="主机", max_length=64)             # mysql数据库存储主机信息
+    db_name = models.CharField(verbose_name="数据库名称", max_length=128)    # mongo数据库存储数据库名称
     password = fields.EncryptedCharField(
         verbose_name="密码", max_length=128, default="", blank=True
     )
diff --git a/sql/templates/database.html b/sql/templates/database.html
index 995a694ad6..e60bccbef6 100755
--- a/sql/templates/database.html
+++ b/sql/templates/database.html
@@ -7,6 +7,8 @@
             <select id=instance class="form-control selectpicker" name="instance_list"
                     title="请选择实例"
                     data-live-search="true">
+                <optgroup id="optgroup-mysql" label="MySQL"></optgroup>
+                <optgroup id="optgroup-mongo" label="Mongo"></optgroup>
             </select>
         </div>
         <div class="form-group">
@@ -141,8 +143,81 @@ <h4 class="modal-title">编辑/录入数据库信息</h4>
     <script src="{% static 'bootstrap-table/js/bootstrap-table-export.min.js' %}"></script>
     <script src="{% static 'bootstrap-table/js/tableExport.min.js' %}"></script>
     <script>
+        // 根据数据库类型获取显示的字段
+        function get_db_columns(db_type) {
+            switch (db_type) {
+                case 'mysql':
+                    return [
+                        {
+                            title: '数据库名',
+                            field: 'db_name'
+                        }, {
+                            title: '字符集',
+                            field: 'charset'
+                        }, {
+                            title: '排序规则',
+                            field: 'collation'
+                        }, {
+                            title: '授权账号',
+                            field: 'grantees',
+                            formatter: function (value, row, index) {
+                                let grantee = '';
+                                for (let i = 0; i < value.length; i++) {
+                                    grantee = grantee + value[i] + '</br>'
+                                }
+                                return grantee
+                            }
+                        }, {
+                            title: '负责人',
+                            field: 'owner',
+                            visible: false,
+                        }, {
+                            title: '负责人',
+                            field: 'owner_display'
+                        }, {
+                            title: '备注',
+                            field: 'remark'
+                        }
+                    ]
+                case 'mongo':
+                    return [
+                        {
+                            title: '数据库名',
+                            field: 'db_name'
+                        }, {
+                            title: '授权账号',
+                            field: 'grantees',
+                            formatter: function (value, row, index) {
+                                let grantee = '';
+                                for (let i = 0; i < value.length; i++) {
+                                    grantee = grantee + value[i] + '</br>'
+                                }
+                                return grantee
+                            }
+                        }, {
+                            title: '负责人',
+                            field: 'owner',
+                            visible: false,
+                        }, {
+                            title: '负责人',
+                            field: 'owner_display'
+                        }, {
+                            title: '备注',
+                            field: 'remark'
+                        }
+                    ]
+                default:
+                    return []
+            }
+        }
+
         //获取列表
         function database_list() {
+            // 获取选中的数据库实例的类型
+            let db_type = "";
+            if ($("#instance").val()) {
+                db_type = $("#instance")[0].options[$("#instance")[0].selectedIndex].getAttribute("instance-type");
+            }
             //初始化table
             $('#database-list').bootstrapTable('destroy').bootstrapTable({
                 escape: true,
@@ -187,36 +262,8 @@ <h4 class="modal-title">编辑/录入数据库信息</h4>
                         }
                     },
                 columns: [
+                    ...get_db_columns(db_type),
                     {
-                        title: '数据库名',
-                        field: 'db_name'
-                    }, {
-                        title: '字符集',
-                        field: 'charset'
-                    }, {
-                        title: '排序规则',
-                        field: 'collation'
-                    }, {
-                        title: '授权账号',
-                        field: 'grantees',
-                        formatter: function (value, row, index) {
-                            let grantee = '';
-                            for (let i = 0; i < value.length; i++) {
-                                grantee = grantee + value[i] + '</br>'
-                            }
-                            return grantee
-                        }
-                    }, {
-                        title: '负责人',
-                        field: 'owner',
-                        visible: false,
-                    }, {
-                        title: '负责人',
-                        field: 'owner_display'
-                    }, {
-                        title: '备注',
-                        field: 'remark'
-                    }, {
                         title: '操作',
                         field: '',
                         formatter: function (value, row, index) {
@@ -343,20 +390,22 @@ <h4 class="modal-title">编辑/录入数据库信息</h4>
                     url: "/group/user_all_instances/",
                     dataType: "json",
                     data: {
-                        db_type: ['mysql']
+                        db_type: ['mysql', 'mongo']
                     },
                     complete: function () {
                     },
                     success: function (data) {
                         if (data.status === 0) {
                             let result = data['data'];
-                            $("#instance").empty();
-                            for (let i = 0; i < result.length; i++) {
-                                let instance = "<option value=\"" + result[i]['id'] + "\">" + result[i]['instance_name'] + "</option>";
-                                $("#instance").append(instance);
+                            $("optgroup[id^='optgroup']").empty();
+                            const supportDb = ['mysql', 'mongo']
+                            for (let i of result) {
+                                let instance = "<option value=\"" + i.id + "\" instance-id=" + i.id + " instance-type=" + i.db_type + ">" + i.instance_name + "</option>";
+                                if (supportDb.indexOf(i.db_type) !== -1) {
+                                    $("#optgroup-" + i.db_type).append(instance);
+                                }
                             }
-                            $('#instance').selectpicker('render');
-                            $('#instance').selectpicker('refresh');
+                            $('#instance').selectpicker('render').selectpicker('refresh');
                         } else {
                             alert(data.msg);
                         }
diff --git a/sql/templates/instanceaccount.html b/sql/templates/instanceaccount.html
index 353eb95ed6..2c53ec397f 100644
--- a/sql/templates/instanceaccount.html
+++ b/sql/templates/instanceaccount.html
@@ -9,6 +9,8 @@
             <select id=instance class="form-control selectpicker" name="instance_list"
                     title="请选择实例"
                     data-live-search="true">
+                <optgroup id="optgroup-mysql" label="MySQL"></optgroup>
+                <optgroup id="optgroup-mongo" label="Mongo"></optgroup>
             </select>
         </div>
         <div class="form-group">
@@ -20,7 +22,7 @@
         </div>
         <div class="form-group ">
             <button id="btn-create-account" type="button" class="btn btn-default" disabled="disabled"
-                    data-toggle="modal" data-target="#create-account">
+                    data-toggle="modal" onclick="show_create_modal()">
                 <span class="glyphicon glyphicon-plus" aria-hidden="true"></span>
                 创建账号
             </button>
@@ -43,6 +45,17 @@ <h4 class="modal-title">创建账号</h4>
                     <h6 style="color:red">注：新创建的账号无权限，需要使用授权功能授予相关权限</h6>
                 </div>
                 <div class="modal-body form-group">
+                    <!-- 数据库名称 -->
+                    <div class="form-group row" id="db-name1-row">
+                        <label for="db_name1" class="col-sm-3 col-form-label">
+                            <span style="color:red">*</span>数据库</label>
+                        <div class="col-sm-9">
+                            <select id="db_name1" class="form-control selectpicker" name="db_name1"
+                                    title="请选择数据库"
+                                    data-live-search="true">
+                            </select>
+                        </div>
+                    </div>
                     <div class="form-group row">
                         <label for="user" class="col-sm-3 col-form-label">
                             <span style="color:red">*</span>数据库账号</label>
@@ -55,7 +68,7 @@ <h6 style="color:red">注：新创建的账号无权限，需要使用授权功
                             </small>
                         </div>
                     </div>
-                    <div class="form-group row">
+                    <div class="form-group row" id="host-row">
                         <label for="host" class="col-sm-3 col-form-label">
                             <span style="color:red">*</span>主机</label>
                         <div class="col-sm-9">
@@ -116,7 +129,17 @@ <h4 class="modal-title">修改/录入账号 </h4>
                     <h6 style="color:red">注：此操作不会修改账号密码，仅将相关信息录入平台进行管理，如需修改密码请使用改密功能</h6>
                 </div>
                 <div class="modal-body form-group">
-
+                    <!-- 数据库名称 -->
+                    <div class="form-group row" id="edit-db-name1-row">
+                        <label for="edit-db-name1" class="col-sm-3 col-form-label">
+                            <span style="color:red">*</span>数据库</label>
+                        <div class="col-sm-9">
+                            <select id="edit-db-name1" class="form-control selectpicker" name="edit_db_name1"
+                                    title="请选择数据库" disabled
+                                    data-live-search="true">
+                            </select>
+                        </div>
+                    </div>
                     <div class="form-group row">
                         <label for="edit-user" class="col-sm-3 col-form-label">
                             <span style="color:red">*</span>数据库账号</label>
@@ -126,7 +149,7 @@ <h6 style="color:red">注：此操作不会修改账号密码，仅将相关信
                                    placeholder="请输入账号名称">
                         </div>
                     </div>
-                    <div class="form-group row">
+                    <div class="form-group row" id="edit-host-row">
                         <label for="edit-host" class="col-sm-3 col-form-label">
                             <span style="color:red">*</span>主机</label>
                         <div class="col-sm-9">
@@ -171,7 +194,7 @@ <h4 class="modal-title">授权变更
                         账号: <span id="modify-user" style="color: red"></span></h4>
                 </div>
                 <div class="modal-body">
-                    <div class="row">
+                    <div id="mysql-grant-content" class="row">
                         <div class="col-md-3">
                             <div class="panel panel-default">
                                 <div class="panel-heading">
@@ -888,6 +911,33 @@ <h5 class="control-label text-bold">请选择列：</h5>
                             </div>
                         </div>
                     </div>
+                    <div id="mongo-grant-content" class="form-group">
+                        <div class="form-group row">
+                            <label for="db-roles" class="col-sm-3 col-form-label">
+                                <span style="color:red">*</span>数据库角色</label>
+                            <div class="col-sm-9">
+                                <select id="db-roles" class="form-control selectpicker" name="db_roles"
+                                        title="请选择数据库角色"
+                                        multiple
+                                        data-live-search="true">
+                                    <option value="read">read</option>
+                                    <option value="readWrite">readWrite</option>
+                                    <option value="dbAdmin">dbAdmin</option>
+                                    <option value="dbOwner">dbOwner</option>
+                                    <option value="userAdmin">userAdmin</option>
+                                    <option value="clusterAdmin">clusterAdmin</option>
+                                    <option value="clusterManager">clusterManager</option>
+                                    <option value="clusterMonitor">clusterMonitor</option>
+                                    <option value="hostManager">hostManager</option>
+                                    <option value="readAnyDatabase">readAnyDatabase</option>
+                                    <option value="readWriteAnyDatabase">readWriteAnyDatabase</option>
+                                    <option value="userAdminAnyDatabase">userAdminAnyDatabase</option>
+                                    <option value="dbAdminAnyDatabase">dbAdminAnyDatabase</option>
+                                    <option value="root">root</option>
+                                </select>
+                            </div>
+                        </div>
+                    </div>
                 </div>
                 <div class="modal-footer">
                     <button type="button" class="btn btn-default" data-dismiss="modal">取消</button>
@@ -991,6 +1041,29 @@ <h4 class="modal-title">删除账号
     <script src="{% static 'bootstrap-table/js/bootstrap-table-export.min.js' %}"></script>
     <script src="{% static 'bootstrap-table/js/tableExport.min.js' %}"></script>
     <script>
+        function get_db_type() {
+            // 获取选中的数据库实例的类型
+            let db_type = "";
+            if ($("#instance").val()) {
+                db_type = $("#instance")[0].options[$("#instance")[0].selectedIndex].getAttribute("instance-type");
+            }
+            return db_type;
+        }
+
+        // 打开创建modal
+        function show_create_modal() {
+            const db_type = get_db_type();
+            // 根据数据库类型显示不同的form row
+            if (db_type === 'mysql') {
+                $("#db-name1-row").hide();
+                $("#host-row").show();
+            } else if (db_type === 'mongo') {
+                $("#db-name1-row").show();
+                $("#host-row").hide();
+            }
+            $("#create-account").modal('show');
+        }
+
         //权限切换
         $("#priv-type").change(function () {
             let priv_type = $("#priv-type").val();
@@ -1074,8 +1147,111 @@ <h4 class="modal-title">删除账号
             }
         });
 
+        // 根据数据库类型获取显示的字段
+        function get_db_columns(db_type) {
+            switch (db_type) {
+                case 'mysql':
+                    return [
+                        {
+                            title: '账号',
+                            field: 'user_host',
+                            formatter: function (value, row, index) {
+                                if (row.saved) {
+                                    return "<a target=\"_blank\" href=\"/admin/sql/instanceaccount/" + row.id + "/change/\">" + value + "</a>"
+                                } else {
+                                    return value
+                                }
+                            }
+                        }, {
+                            title: '帐号名',
+                            field: 'user',
+                            visible: false
+                        }, {
+                            title: '主机',
+                            field: 'host',
+                            visible: false
+                        }, {
+                            title: '权限',
+                            field: 'privileges',
+                            formatter: function (value, row, index) {
+                                var priv = '';
+                                for (var i = 0; i < value.length; i++) {
+                                    priv = priv + value[i] + ';</br>'
+                                }
+                                return priv
+                            },
+                            width: "60",
+                            widthUnit: "%",
+                        }, {
+                            title: '备注',
+                            field: 'remark'
+                        }, {
+                            title: '操作',
+                            field: '',
+                            formatter: function (value, row, index) {
+                                let btn_edit = "<button class=\"btn btn-info btn-xs\" user_host=\"" + row.user_host + "\" onclick=\"show_edit_modal(this)" + "\">编辑</button>\n";
+                                let btn_modify_grants = "<button class=\"btn btn-primary btn-xs\" user_host=\"" + row.user_host + "\" onclick=\"show_grants_modal(this)" + "\">授权</button>\n";
+                                let btn_reset_passwd = "<button class=\"btn btn-warning btn-xs\" user_host=\"" + row.user_host + "\" onclick=\"show_reset_modal(this)" + "\">改密</button>\n";
+                                let btn_del_account = "<button class=\"btn btn-danger btn-xs\" user_host=\"" + row.user_host + "\" onclick=\"show_delete_modal(this)" + "\">删除</button>\n";
+                                let btn_lock_account = "";
+                                if (row.is_locked === 'N') {
+                                    btn_lock_account = "<button class=\"btn btn-danger btn-xs\" user_host=\"" + row.user_host + "\" is_locked=\"" + row.is_locked + "\" onclick=\"show_lock_modal(this)" + "\">锁定</button>\n";
+                                } else if (row.is_locked === 'Y') {
+                                    btn_lock_account = "<button class=\"btn btn-success btn-xs\" user_host=\"" + row.user_host + "\" is_locked=\"" + row.is_locked + "\"  onclick=\"show_lock_modal(this)" + "\">解锁</button>\n";
+                                }
+                                return btn_edit + btn_modify_grants + btn_reset_passwd + btn_lock_account + btn_del_account
+                            }
+                        }]
+                case 'mongo':
+                    return [
+                        {
+                            title: '数据库名',
+                            field: 'db_name'
+                        }, {
+                            title: '账号',
+                            field: 'user',
+                            formatter: function (value, row, index) {
+                                if (row.saved) {
+                                    return "<a target=\"_blank\" href=\"/admin/sql/instanceaccount/" + row.id + "/change/\">" + value + "</a>"
+                                } else {
+                                    return value
+                                }
+                            }
+                        }, {
+                            title: '角色',
+                            field: 'roles',
+                            formatter: function (value, row, index) {
+                                return value.join(',')
+                            }
+                        }, {
+                            title: '备注',
+                            field: 'remark'
+                        }, {
+                            title: '操作',
+                            field: '',
+                            formatter: function (value, row, index) {
+                                let btn_edit = "<button class=\"btn btn-info btn-xs\" db_name_user=\"" + row.db_name_user + "\" onclick=\"show_edit_modal(this)" + "\">编辑</button>\n";
+                                let btn_modify_grants = "<button class=\"btn btn-primary btn-xs\" db_name_user=\"" + row.db_name_user + "\" onclick=\"show_grants_modal(this)" + "\">授权</button>\n";
+                                let btn_reset_passwd = "<button class=\"btn btn-warning btn-xs\" db_name_user=\"" + row.db_name_user + "\" onclick=\"show_reset_modal(this)" + "\">改密</button>\n";
+                                let btn_del_account = "<button class=\"btn btn-danger btn-xs\" db_name_user=\"" + row.db_name_user + "\" onclick=\"show_delete_modal(this)" + "\">删除</button>\n";
+                                return btn_edit + btn_modify_grants + btn_reset_passwd + btn_del_account
+                            }
+                        }
+                    ]
+                default:
+                    return []
+            }
+        }
+
         //获取账号列表
         function user_list() {
+            const db_type = get_db_type();
+            let uniqueId;
+            if (db_type === 'mysql') {
+                uniqueId = 'user_host';
+            } else if (db_type === 'mongo') {
+                uniqueId = 'db_name_user';
+            }
             //初始化table
             $('#user-list').bootstrapTable('destroy').bootstrapTable({
                 escape: false,
@@ -1101,7 +1277,7 @@ <h4 class="modal-title">删除账号
                 showRefresh: true,                  //是否显示刷新按钮
                 minimumCountColumns: 2,             //最少允许的列数
                 clickToSelect: true,                //是否启用点击选中行
-                uniqueId: "user_host",               //每一行的唯一标识，一般为主键列
+                uniqueId: uniqueId,               //每一行的唯一标识，一般为主键列
                 showToggle: true,                   //是否显示详细视图和列表视图的切换按钮
                 cardView: false,                    //是否显示详细视图
                 detailView: false,                  //是否显示父子表
@@ -1119,57 +1295,7 @@ <h4 class="modal-title">删除账号
                             }
                         }
                     },
-                columns: [
-                    {
-                        title: '账号',
-                        field: 'user_host',
-                        formatter: function (value, row, index) {
-                            if (row.saved) {
-                                return "<a target=\"_blank\" href=\"/admin/sql/instanceaccount/" + row.id + "/change/\">" + value + "</a>"
-                            } else {
-                                return value
-                            }
-                        }
-                    }, {
-                        title: '帐号名',
-                        field: 'user',
-                        visible: false
-                    }, {
-                        title: '主机',
-                        field: 'host',
-                        visible: false
-                    }, {
-                        title: '权限',
-                        field: 'privileges',
-                        formatter: function (value, row, index) {
-                            var priv = '';
-                            for (var i = 0; i < value.length; i++) {
-                                priv = priv + value[i] + ';</br>'
-                            }
-                            return priv
-                        },
-                        width: "60",
-                        widthUnit:"%",
-                    }, {
-                        title: '备注',
-                        field: 'remark'
-                    }, {
-                        title: '操作',
-                        field: '',
-                        formatter: function (value, row, index) {
-                            let btn_edit = "<button class=\"btn btn-info btn-xs\" user_host=\"" + row.user_host + "\" onclick=\"show_edit_modal(this)" + "\">编辑</button>\n";
-                            let btn_modify_grants = "<button class=\"btn btn-primary btn-xs\" user_host=\"" + row.user_host + "\" onclick=\"show_grants_modal(this)" + "\">授权</button>\n";
-                            let btn_reset_passwd = "<button class=\"btn btn-warning btn-xs\" user_host=\"" + row.user_host + "\" onclick=\"show_reset_modal(this)" + "\">改密</button>\n";
-                            let btn_del_account = "<button class=\"btn btn-danger btn-xs\" user_host=\"" + row.user_host + "\" onclick=\"show_delete_modal(this)" + "\">删除</button>\n";
-                            let btn_lock_account = "";
-                            if (row.is_locked === 'N') {
-                                btn_lock_account = "<button class=\"btn btn-danger btn-xs\" user_host=\"" + row.user_host + "\" is_locked=\"" + row.is_locked + "\" onclick=\"show_lock_modal(this)" + "\">锁定</button>\n";
-                            } else if (row.is_locked === 'Y') {
-                                btn_lock_account = "<button class=\"btn btn-success btn-xs\" user_host=\"" + row.user_host + "\" is_locked=\"" + row.is_locked + "\"  onclick=\"show_lock_modal(this)" + "\">解锁</button>\n";
-                            }
-                            return btn_edit + btn_modify_grants + btn_reset_passwd + btn_lock_account + btn_del_account
-                        }
-                    }],
+                columns: get_db_columns(db_type),
                 onLoadSuccess: function (data) {
                     if (data.status !== 0) {
                         alert("数据加载失败！" + data.msg);
@@ -1206,14 +1332,26 @@ <h4 class="modal-title">删除账号
                     if (data.status === 0) {
                         let result = data.data;
                         let db_name = $("#db_name");
+                        let db_name1 = $("#db_name1");
+                        let edit_db_name1 = $("#edit-db-name1");
                         db_name.empty();
+                        db_name1.empty();
+                        edit_db_name1.empty();
                         for (var i = 0; i < result.length; i++) {
                             var name = "<option value=\"" + result[i] + "\">" + result[i] + "</option>";
                             db_name.append(name);
+                            db_name1.append(name);
+                            edit_db_name1.append(name);
                         }
                         db_name.val('');
                         db_name.selectpicker('render');
                         db_name.selectpicker('refresh');
+                        db_name1.val('');
+                        db_name1.selectpicker('render');
+                        db_name1.selectpicker('refresh');
+                        edit_db_name1.val('');
+                        edit_db_name1.selectpicker('render');
+                        edit_db_name1.selectpicker('refresh');
                     } else {
                         alert(data.msg);
                     }
@@ -1343,6 +1481,7 @@ <h4 class="modal-title">删除账号
                     dataType: "json",
                     data: {
                         instance_id: $("#instance").val(),
+                        db_name: $("#db_name1").val(),
                         user: $("#user").val(),
                         host: $("#host").val(),
                         password1: $("#password1").val(),
@@ -1370,11 +1509,28 @@ <h4 class="modal-title">删除账号
 
         //编辑、录入账号
         function show_edit_modal(obj) {
-            let user_host = $(obj).attr("user_host");
-            let row_data = $('#user-list').bootstrapTable('getRowByUniqueId', user_host);
+            const db_type = get_db_type();
+            let user_host;
+            let db_name_user;
+            let row_data;
+            if (db_type === 'mysql') {
+                user_host = $(obj).attr("user_host");
+                row_data = $('#user-list').bootstrapTable('getRowByUniqueId', user_host);
+                $("#edit-db-name1-row").hide();
+                $("#edit-host-row").show();
+            } else {
+                db_name_user = $(obj).attr("db_name_user");
+                row_data = $('#user-list').bootstrapTable('getRowByUniqueId', db_name_user);
+                $("#edit-db-name1-row").show();
+                $("#edit-host-row").hide();
+            }
+
             let user = row_data['user'];
+            let db_name = row_data['db_name'];
             let host = row_data['host'];
             let remark = row_data['remark'];
+            $("#edit-db-name1").val(db_name);
+            $('#edit-db-name1').selectpicker('render').selectpicker('refresh');
             $("#edit-user").val(user);
             $("#edit-host").val(host);
             $("#edit-remark").val(remark);
@@ -1391,6 +1547,8 @@ <h4 class="modal-title">删除账号
                         user_host: user_host,
                         user: user,
                         host: host,
+                        db_name: db_name,
+                        db_name_user: db_name_user,
                         password: $("#edit-password").val(),
                         remark: $("#edit-remark").val()
                     },
@@ -1414,60 +1572,75 @@ <h4 class="modal-title">删除账号
 
         //修改权限
         function show_grants_modal(obj) {
-            let user_host = $(obj).attr("user_host");
-            $("#modify-user").text(user_host);
+            const db_type = get_db_type();
+            let user_host;
+            let db_name_user;
+            if (db_type === 'mysql') {
+                $("#grants-modal").children().addClass("modal-lg");
+                $("#mysql-grant-content").show();
+                $("#mongo-grant-content").hide();
+                user_host = $(obj).attr("user_host");
+                $("#modify-user").text(user_host);
+            } else if (db_type === 'mongo') {
+                $("#grants-modal").children().removeClass("modal-lg");
+                $("#mongo-grant-content").show();
+                $("#mysql-grant-content").hide();
+                db_name_user = $(obj).attr("db_name_user");
+                $("#modify-user").text(db_name_user);
+                let row_data = $('#user-list').bootstrapTable('getRowByUniqueId', db_name_user);
+                $("#db-roles").val(row_data['roles']);
+                $("#db-roles").selectpicker('render').selectpicker('refresh');
+            }
             $("#grants-modal").modal('show');
 
             //变更账号权限
             $("#grantsBtn").unbind("click").click(function () {
-                let op_type = $("#op-type").val();
-                let priv_type = $("#priv-type").val();
-                let db_name = $("#db_name").val();
-                let tb_name = $("#tb_name").val();
-                let col_name = $("#col_name").val();
-                let div_global_priv = $("#div-global-priv");
-                let div_db_priv = $("#div-db-priv");
-                let div_tb_priv = $("#div-tb-priv");
-                let div_col_priv = $("#div-col-priv");
-                let global_privs = [];
-                let db_privs = [];
-                let tb_privs = [];
-                let col_privs = [];
-                div_global_priv.find('input[type="checkbox"]:checked').each(
-                    function () {
-                        let priv_name = $(this).attr("name");
-                        global_privs.push(priv_name);
-                    }
-                );
-                div_db_priv.find('input[type="checkbox"]:checked').each(
-                    function () {
-                        let priv_name = $(this).attr("name");
-                        db_privs.push(priv_name);
-                    }
-                );
-                div_tb_priv.find('input[type="checkbox"]:checked').each(
-                    function () {
-                        let priv_name = $(this).attr("name");
-                        tb_privs.push(priv_name);
-                    }
-                );
-                div_col_priv.find('input[type="checkbox"]:checked').each(
-                    function () {
-                        let priv_name = $(this).attr("name");
-                        col_privs.push(priv_name);
-                    }
-                );
-                let privs = {
-                    "global_privs": global_privs,
-                    "db_privs": db_privs,
-                    "tb_privs": tb_privs,
-                    "col_privs": col_privs
-                };
-                $.ajax({
-                    type: "post",
-                    url: "/instance/user/grant/",
-                    dataType: "json",
-                    data: {
+                let data;
+                if (db_type == 'mysql') {
+                    let op_type = $("#op-type").val();
+                    let priv_type = $("#priv-type").val();
+                    let db_name = $("#db_name").val();
+                    let tb_name = $("#tb_name").val();
+                    let col_name = $("#col_name").val();
+                    let div_global_priv = $("#div-global-priv");
+                    let div_db_priv = $("#div-db-priv");
+                    let div_tb_priv = $("#div-tb-priv");
+                    let div_col_priv = $("#div-col-priv");
+                    let global_privs = [];
+                    let db_privs = [];
+                    let tb_privs = [];
+                    let col_privs = [];
+                    div_global_priv.find('input[type="checkbox"]:checked').each(
+                        function () {
+                            let priv_name = $(this).attr("name");
+                            global_privs.push(priv_name);
+                        }
+                    );
+                    div_db_priv.find('input[type="checkbox"]:checked').each(
+                        function () {
+                            let priv_name = $(this).attr("name");
+                            db_privs.push(priv_name);
+                        }
+                    );
+                    div_tb_priv.find('input[type="checkbox"]:checked').each(
+                        function () {
+                            let priv_name = $(this).attr("name");
+                            tb_privs.push(priv_name);
+                        }
+                    );
+                    div_col_priv.find('input[type="checkbox"]:checked').each(
+                        function () {
+                            let priv_name = $(this).attr("name");
+                            col_privs.push(priv_name);
+                        }
+                    );
+                    let privs = {
+                        "global_privs": global_privs,
+                        "db_privs": db_privs,
+                        "tb_privs": tb_privs,
+                        "col_privs": col_privs
+                    };
+                    data = {
                         instance_id: $("#instance").val(),
                         user_host: $("#modify-user").text(),
                         op_type: op_type,
@@ -1476,7 +1649,20 @@ <h4 class="modal-title">删除账号
                         db_name: db_name,
                         tb_name: tb_name,
                         col_name: col_name
-                    },
+                    }
+                } else if (db_type == 'mongo') {
+                    data = {
+                        instance_id: $("#instance").val(),
+                        db_name_user: db_name_user,
+                        roles: $("#db-roles").val()
+                    }
+                }
+
+                $.ajax({
+                    type: "post",
+                    url: "/instance/user/grant/",
+                    dataType: "json",
+                    data: data,
                     complete: function () {
                     },
                     success: function (data) {
@@ -1503,11 +1689,20 @@ <h4 class="modal-title">删除账号
 
         //变更密码
         function show_reset_modal(obj) {
-            let user_host = $(obj).attr("user_host");
-            let row_data = $('#user-list').bootstrapTable('getRowByUniqueId', user_host);
-            let user = row_data['user'];
-            let host = row_data['host'];
-            $("#reset-user").text(user_host);
+            const db_type = get_db_type();
+            let user_host;
+            let db_name_user;
+            let row_data;
+            if (db_type === 'mysql') {
+                user_host = $(obj).attr("user_host");
+                row_data = $('#user-list').bootstrapTable('getRowByUniqueId', user_host);
+                $("#reset-user").text(user_host);
+            } else {
+                db_name_user = $(obj).attr("db_name_user");
+                row_data = $('#user-list').bootstrapTable('getRowByUniqueId', db_name_user);
+                $("#reset-user").text(db_name_user);
+            }
+
             $("#reset-pwd").modal('show');
 
             //变更密码
@@ -1518,9 +1713,7 @@ <h4 class="modal-title">删除账号
                     dataType: "json",
                     data: {
                         instance_id: $("#instance").val(),
-                        user_host: user_host,
-                        user: user,
-                        host: host,
+                        ...row_data,
                         reset_pwd1: $("#reset-pwd1").val(),
                         reset_pwd2: $("#reset-pwd2").val(),
                     },
@@ -1581,11 +1774,20 @@ <h4 class="modal-title">删除账号
 
         //删除账号
         function show_delete_modal(obj) {
-            let user_host = $(obj).attr("user_host");
-            let row_data = $('#user-list').bootstrapTable('getRowByUniqueId', user_host);
-            let user = row_data['user'];
-            let host = row_data['host'];
-            $("#delete-user").text(user_host);
+            const db_type = get_db_type();
+            let user_host;
+            let db_name_user;
+            let row_data;
+            if (db_type === 'mysql') {
+                user_host = $(obj).attr("user_host");
+                row_data = $('#user-list').bootstrapTable('getRowByUniqueId', user_host);
+                $("#delete-user").text(user_host);
+            } else {
+                db_name_user = $(obj).attr("db_name_user");
+                row_data = $('#user-list').bootstrapTable('getRowByUniqueId', db_name_user);
+                $("#delete-user").text(db_name_user);
+            }
+
             $("#delete-account").modal('show');
 
             $("#deleteBtn").unbind("click").click(function () {
@@ -1595,9 +1797,7 @@ <h4 class="modal-title">删除账号
                     dataType: "json",
                     data: {
                         instance_id: $("#instance").val(),
-                        user_host: user_host,
-                        user: user,
-                        host: host,
+                        ...row_data,
                     },
                     complete: function () {
                     },
@@ -1628,20 +1828,22 @@ <h4 class="modal-title">删除账号
                     url: "/group/user_all_instances/",
                     dataType: "json",
                     data: {
-                        db_type: ['mysql']
+                        db_type: ['mysql', 'mongo']
                     },
                     complete: function () {
                     },
                     success: function (data) {
                         if (data.status === 0) {
                             let result = data['data'];
-                            $("#instance").empty();
-                            for (let i = 0; i < result.length; i++) {
-                                let instance = "<option value=\"" + result[i]['id'] + "\">" + result[i]['instance_name'] + "</option>";
-                                $("#instance").append(instance);
+                            $("optgroup[id^='optgroup']").empty();
+                            const supportDb = ['mysql', 'mongo']
+                            for (let i of result) {
+                                let instance = "<option value=\"" + i.id + "\" instance-id=" + i.id + " instance-type=" + i.db_type + ">" + i.instance_name + "</option>";
+                                if (supportDb.indexOf(i.db_type) !== -1) {
+                                    $("#optgroup-" + i.db_type).append(instance);
+                                }
                             }
-                            $('#instance').selectpicker('render');
-                            $('#instance').selectpicker('refresh');
+                            $('#instance').selectpicker('render').selectpicker('refresh');
                         } else {
                             alert(data.msg);
                         }
diff --git a/sql/utils/instance_management.py b/sql/utils/instance_management.py
new file mode 100644
index 0000000000..2735f81895
--- /dev/null
+++ b/sql/utils/instance_management.py
@@ -0,0 +1,19 @@
+from sql.models import InstanceAccount
+
+
+SUPPORTED_MANAGEMENT_DB_TYPE = ["mysql", "mongo"]
+
+
+def get_instanceaccount_unique_value(db_type: str, account: InstanceAccount) -> str:
+    """根据存储的实例账号数据，返回该实例类型的唯一值"""
+    if db_type == 'mysql':
+        return f"`{account['user']}`@`{account['host']}`"
+    elif db_type == 'mongo':
+        return f"{account['db_name']}.{account['user']}"
+
+
+def get_instanceaccount_unique_key(db_type: str) -> str:
+    if db_type == 'mysql':
+        return "user_host"
+    elif db_type == 'mongo':
+        return "db_name_user"

From 2c2d4b0ddd0ccb6fed29ba7de0b44b29a0d72f11 Mon Sep 17 00:00:00 2001
From: quanbisen <1769128867@qq.com>
Date: Sat, 1 Apr 2023 15:59:28 +0800
Subject: [PATCH 2/9] =?UTF-8?q?=E6=9B=B4=E6=96=B0=E5=8A=9F=E8=83=BD?=
 =?UTF-8?q?=E6=B8=85=E5=8D=95=E6=94=AF=E6=8C=81MongoDB=E8=B4=A6=E5=8F=B7?=
 =?UTF-8?q?=E7=AE=A1=E7=90=86?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 601162914f..f3152b4929 100644
--- a/README.md
+++ b/README.md
@@ -29,7 +29,7 @@
 | Redis | √ | × | √ | × | × | × | × | × | × | × |
 | PgSQL | √ | × | √ | × | × | × | × | × | × | × |
 | Oracle | √ | √ | √ | √ | √ | × | × | × | × | × |
-| MongoDB | √ | √  | √  | × | × | × | × | × | × | × |
+| MongoDB | √ | √  | √  | × | × | × | × | √ | × | × |
 | Phoenix | √ | ×  | √  | × | × | × | × | × | × | × |
 | ODPS | √ | ×  | ×  | × | × | × | × | × | × | × |
 | ClickHouse | √ | √  | √  | × | × | × | × | × | × | × |

From 1708593b77baaddebfc8c1d0dac99e209a8c71bb Mon Sep 17 00:00:00 2001
From: quanbisen <1769128867@qq.com>
Date: Tue, 4 Apr 2023 09:53:36 +0800
Subject: [PATCH 3/9] refomat code by black

---
 sql/engines/mongo.py             | 47 ++++++++--------
 sql/engines/mysql.py             | 24 ++++----
 sql/instance_account.py          | 95 ++++++++++++++++++++++----------
 sql/instance_database.py         | 26 ++++++---
 sql/models.py                    |  4 +-
 sql/utils/instance_management.py |  8 +--
 6 files changed, 129 insertions(+), 75 deletions(-)

diff --git a/sql/engines/mongo.py b/sql/engines/mongo.py
index 23587a1962..13d5f90af0 100644
--- a/sql/engines/mongo.py
+++ b/sql/engines/mongo.py
@@ -1282,13 +1282,12 @@ def get_all_databases_summary(self):
             rows = []
             for db_name in dbs:
                 # 执行语句
-                listing = conn[db_name].command(command='usersInfo')
+                listing = conn[db_name].command(command="usersInfo")
                 grantees = []
-                for user_obj in listing['users']:
-                    grantees.append({
-                        'user': user_obj['user'],
-                        'roles': user_obj['roles']
-                    }.__str__())
+                for user_obj in listing["users"]:
+                    grantees.append(
+                        {"user": user_obj["user"], "roles": user_obj["roles"]}.__str__()
+                    )
                 row = {
                     "db_name": db_name,
                     "grantees": grantees,
@@ -1309,15 +1308,17 @@ def get_instance_users_summary(self):
             rows = []
             for db_name in dbs:
                 # 执行语句
-                listing = conn[db_name].command(command='usersInfo')
-                for user_obj in listing['users']:
-                    rows.append({
-                        "db_name_user": f"{db_name}.{user_obj['user']}",
-                        "db_name": db_name,
-                        "user": user_obj['user'],
-                        "roles": [role['role'] for role in user_obj['roles']],
-                        "saved": False,
-                    })
+                listing = conn[db_name].command(command="usersInfo")
+                for user_obj in listing["users"]:
+                    rows.append(
+                        {
+                            "db_name_user": f"{db_name}.{user_obj['user']}",
+                            "db_name": db_name,
+                            "user": user_obj["user"],
+                            "roles": [role["role"] for role in user_obj["roles"]],
+                            "saved": False,
+                        }
+                    )
             query_result.rows = rows
         return query_result
 
@@ -1331,13 +1332,15 @@ def create_instance_user(self, **kwargs):
         try:
             conn = self.get_connection()
             conn[db_name].command("createUser", user, pwd=password1, roles=[])
-            exec_result.rows = [{
-                "instance": self.instance,
-                "db_name": db_name,
-                "user": user,
-                "password": password1,
-                "remark": remark
-            }]
+            exec_result.rows = [
+                {
+                    "instance": self.instance,
+                    "db_name": db_name,
+                    "user": user,
+                    "password": password1,
+                    "remark": remark,
+                }
+            ]
         except Exception as e:
             exec_result.error = str(e)
         return exec_result
diff --git a/sql/engines/mysql.py b/sql/engines/mysql.py
index 9d42af6c3b..a04946914b 100644
--- a/sql/engines/mysql.py
+++ b/sql/engines/mysql.py
@@ -288,9 +288,7 @@ def get_all_databases_summary(self):
         sql_get_db = """SELECT SCHEMA_NAME,DEFAULT_CHARACTER_SET_NAME,DEFAULT_COLLATION_NAME 
         FROM information_schema.SCHEMATA
         WHERE SCHEMA_NAME NOT IN ('information_schema', 'performance_schema', 'mysql', 'test', 'sys');"""
-        query_result = self.query(
-            "information_schema", sql_get_db, close_conn=False
-        )
+        query_result = self.query("information_schema", sql_get_db, close_conn=False)
         if not query_result.error:
             dbs = query_result.rows
             # 获取数据库关联用户信息
@@ -357,14 +355,18 @@ def create_instance_user(self, **kwargs):
         create_user_cmd = ""
         accounts = []
         for host in hosts:
-            create_user_cmd += f"create user '{user}'@'{host}' identified by '{password1}';"
-            accounts.append({
-                "instance": self.instance,
-                "user": user,
-                "host": host,
-                "password": password1,
-                "remark": remark
-            })
+            create_user_cmd += (
+                f"create user '{user}'@'{host}' identified by '{password1}';"
+            )
+            accounts.append(
+                {
+                    "instance": self.instance,
+                    "user": user,
+                    "host": host,
+                    "password": password1,
+                    "remark": remark,
+                }
+            )
         exec_result = self.execute(db_name="mysql", sql=create_user_cmd)
         exec_result.rows = accounts
         return exec_result
diff --git a/sql/instance_account.py b/sql/instance_account.py
index 20c0f406ae..be3188ed56 100644
--- a/sql/instance_account.py
+++ b/sql/instance_account.py
@@ -6,8 +6,11 @@
 from django.core.exceptions import ValidationError
 
 from django.http import HttpResponse, JsonResponse
-from sql.utils.instance_management import SUPPORTED_MANAGEMENT_DB_TYPE, \
-    get_instanceaccount_unique_value, get_instanceaccount_unique_key
+from sql.utils.instance_management import (
+    SUPPORTED_MANAGEMENT_DB_TYPE,
+    get_instanceaccount_unique_value,
+    get_instanceaccount_unique_key,
+)
 from common.utils.extend_json_encoder import ExtendJSONEncoder
 from sql.engines import get_engine, ResultSet
 from sql.utils.resource_group import user_instances
@@ -23,7 +26,9 @@ def users(request):
     if not instance_id:
         return JsonResponse({"status": 0, "msg": "", "data": []})
     try:
-        instance = user_instances(request.user, db_type=SUPPORTED_MANAGEMENT_DB_TYPE).get(id=instance_id)
+        instance = user_instances(
+            request.user, db_type=SUPPORTED_MANAGEMENT_DB_TYPE
+        ).get(id=instance_id)
     except Instance.DoesNotExist:
         return JsonResponse({"status": 1, "msg": "你所在组未关联该实例", "data": []})
 
@@ -73,12 +78,17 @@ def create(request):
     remark = request.POST.get("remark", "")
 
     try:
-        instance = user_instances(request.user, db_type=SUPPORTED_MANAGEMENT_DB_TYPE).get(id=instance_id)
+        instance = user_instances(
+            request.user, db_type=SUPPORTED_MANAGEMENT_DB_TYPE
+        ).get(id=instance_id)
     except Instance.DoesNotExist:
         return JsonResponse({"status": 1, "msg": "你所在组未关联该实例", "data": []})
 
-    if (instance.db_type == 'mysql' and not all([user, host, password1, password2])) or \
-            (instance.db_type == 'mongo' and not all([db_name, user, password1, password2])):
+    if (
+        instance.db_type == "mysql" and not all([user, host, password1, password2])
+    ) or (
+        instance.db_type == "mongo" and not all([db_name, user, password1, password2])
+    ):
         return JsonResponse({"status": 1, "msg": "参数不完整，请确认后提交", "data": []})
 
     if password1 != password2:
@@ -91,7 +101,9 @@ def create(request):
         return JsonResponse({"status": 1, "msg": f"{msg}", "data": []})
 
     engine = get_engine(instance=instance)
-    exec_result = engine.create_instance_user(db_name=db_name, user=user, host=host, password1=password1, remark=remark)
+    exec_result = engine.create_instance_user(
+        db_name=db_name, user=user, host=host, password1=password1, remark=remark
+    )
     # 关闭连接
     engine.close()
     if exec_result.error:
@@ -116,12 +128,15 @@ def edit(request):
     remark = request.POST.get("remark", "")
 
     try:
-        instance = user_instances(request.user, db_type=SUPPORTED_MANAGEMENT_DB_TYPE).get(id=instance_id)
+        instance = user_instances(
+            request.user, db_type=SUPPORTED_MANAGEMENT_DB_TYPE
+        ).get(id=instance_id)
     except Instance.DoesNotExist:
         return JsonResponse({"status": 1, "msg": "你所在组未关联该实例", "data": []})
 
-    if (instance.db_type == 'mysql' and not all([user, host])) or \
-            (instance.db_type == 'mongo' and not all([db_name, user])):
+    if (instance.db_type == "mysql" and not all([user, host])) or (
+        instance.db_type == "mongo" and not all([db_name, user])
+    ):
         return JsonResponse({"status": 1, "msg": "参数不完整，请确认后提交", "data": []})
 
     # 保存到数据库
@@ -135,7 +150,11 @@ def edit(request):
         )
     else:
         InstanceAccount.objects.update_or_create(
-            instance=instance, user=user, host=host, db_name=db_name, defaults={"remark": remark}
+            instance=instance,
+            user=user,
+            host=host,
+            db_name=db_name,
+            defaults={"remark": remark},
         )
     return JsonResponse({"status": 0, "msg": "", "data": []})
 
@@ -147,12 +166,14 @@ def grant(request):
     grant_sql = ""
 
     try:
-        instance = user_instances(request.user, db_type=SUPPORTED_MANAGEMENT_DB_TYPE).get(id=instance_id)
+        instance = user_instances(
+            request.user, db_type=SUPPORTED_MANAGEMENT_DB_TYPE
+        ).get(id=instance_id)
     except Instance.DoesNotExist:
         return JsonResponse({"status": 1, "msg": "你所在组未关联该实例", "data": []})
 
     engine = get_engine(instance=instance)
-    if instance.db_type == 'mysql':
+    if instance.db_type == "mysql":
         user_host = request.POST.get("user_host")
         op_type = int(request.POST.get("op_type"))
         priv_type = int(request.POST.get("priv_type"))
@@ -181,7 +202,9 @@ def grant(request):
             for db in db_name:
                 db_privs = ["GRANT OPTION" if d == "GRANT" else d for d in db_privs]
                 if op_type == 0:
-                    grant_sql += f"GRANT {','.join(db_privs)} ON `{db}`.* TO {user_host};"
+                    grant_sql += (
+                        f"GRANT {','.join(db_privs)} ON `{db}`.* TO {user_host};"
+                    )
                 elif op_type == 1:
                     grant_sql += (
                         f"REVOKE {','.join(db_privs)} ON `{db}`.* FROM {user_host};"
@@ -196,9 +219,7 @@ def grant(request):
             for tb in tb_name:
                 tb_privs = ["GRANT OPTION" if t == "GRANT" else t for t in tb_privs]
                 if op_type == 0:
-                    grant_sql += (
-                        f"GRANT {','.join(tb_privs)} ON `{db_name}`.`{tb}` TO {user_host};"
-                    )
+                    grant_sql += f"GRANT {','.join(tb_privs)} ON `{db_name}`.`{tb}` TO {user_host};"
                 elif op_type == 1:
                     grant_sql += f"REVOKE {','.join(tb_privs)} ON `{db_name}`.`{tb}` FROM {user_host};"
         # 列权限
@@ -216,7 +237,7 @@ def grant(request):
                     grant_sql += f"REVOKE {priv}(`{'`,`'.join(col_name)}`) ON `{db_name}`.`{tb_name}` FROM {user_host};"
         # 执行变更语句
         exec_result = engine.execute(db_name="mysql", sql=grant_sql)
-    elif instance.db_type == 'mongo':
+    elif instance.db_type == "mongo":
         db_name_user = request.POST.get("db_name_user")
         roles = request.POST.getlist("roles[]")
         arr = db_name_user.split(".")
@@ -249,12 +270,17 @@ def reset_pwd(request):
     reset_pwd2 = request.POST.get("reset_pwd2")
 
     try:
-        instance = user_instances(request.user, db_type=SUPPORTED_MANAGEMENT_DB_TYPE).get(id=instance_id)
+        instance = user_instances(
+            request.user, db_type=SUPPORTED_MANAGEMENT_DB_TYPE
+        ).get(id=instance_id)
     except Instance.DoesNotExist:
         return JsonResponse({"status": 1, "msg": "你所在组未关联该实例", "data": []})
 
-    if (instance.db_type == 'mysql' and not all([user, host, reset_pwd1, reset_pwd2])) or \
-            (instance.db_type == 'mongo' and not all([db_name, user, reset_pwd1, reset_pwd2])):
+    if (
+        instance.db_type == "mysql" and not all([user, host, reset_pwd1, reset_pwd2])
+    ) or (
+        instance.db_type == "mongo" and not all([db_name, user, reset_pwd1, reset_pwd2])
+    ):
         return JsonResponse({"status": 1, "msg": "参数不完整，请确认后提交", "data": []})
 
     if reset_pwd1 != reset_pwd2:
@@ -267,7 +293,9 @@ def reset_pwd(request):
         return JsonResponse({"status": 1, "msg": f"{msg}", "data": []})
 
     engine = get_engine(instance=instance)
-    exec_result = engine.reset_instance_user_pwd(user_host=user_host, db_name_user=db_name_user, reset_pwd=reset_pwd1)
+    exec_result = engine.reset_instance_user_pwd(
+        user_host=user_host, db_name_user=db_name_user, reset_pwd=reset_pwd1
+    )
     # 关闭连接
     engine.close()
     if exec_result.error:
@@ -276,7 +304,11 @@ def reset_pwd(request):
     # 保存到数据库
     else:
         InstanceAccount.objects.update_or_create(
-            instance=instance, user=user, host=host, db_name=db_name, defaults={"password": reset_pwd1}
+            instance=instance,
+            user=user,
+            host=host,
+            db_name=db_name,
+            defaults={"password": reset_pwd1},
         )
 
     return JsonResponse({"status": 0, "msg": "", "data": []})
@@ -324,22 +356,29 @@ def delete(request):
     host = request.POST.get("host")
 
     try:
-        instance = user_instances(request.user, db_type=SUPPORTED_MANAGEMENT_DB_TYPE).get(id=instance_id)
+        instance = user_instances(
+            request.user, db_type=SUPPORTED_MANAGEMENT_DB_TYPE
+        ).get(id=instance_id)
     except Instance.DoesNotExist:
         return JsonResponse({"status": 1, "msg": "你所在组未关联该实例", "data": []})
 
-    if (instance.db_type == 'mysql' and not all([user_host])) or \
-            (instance.db_type == 'mongo' and not all([db_name_user])):
+    if (instance.db_type == "mysql" and not all([user_host])) or (
+        instance.db_type == "mongo" and not all([db_name_user])
+    ):
         return JsonResponse({"status": 1, "msg": "参数不完整，请确认后提交", "data": []})
 
     engine = get_engine(instance=instance)
-    exec_result = engine.drop_instance_user(user_host=user_host, db_name_user=db_name_user)
+    exec_result = engine.drop_instance_user(
+        user_host=user_host, db_name_user=db_name_user
+    )
     # 关闭连接
     engine.close()
     if exec_result.error:
         return JsonResponse({"status": 1, "msg": exec_result.error})
     # 删除数据库对应记录
     else:
-        InstanceAccount.objects.filter(instance=instance, user=user, host=host, db_name=db_name).delete()
+        InstanceAccount.objects.filter(
+            instance=instance, user=user, host=host, db_name=db_name
+        ).delete()
 
     return JsonResponse({"status": 0, "msg": "", "data": []})
diff --git a/sql/instance_database.py b/sql/instance_database.py
index b82ca15849..61418d7e15 100644
--- a/sql/instance_database.py
+++ b/sql/instance_database.py
@@ -30,7 +30,9 @@ def databases(request):
         return JsonResponse({"status": 0, "msg": "", "data": []})
 
     try:
-        instance = user_instances(request.user, db_type=["mysql", "mongo"]).get(id=instance_id)
+        instance = user_instances(request.user, db_type=["mysql", "mongo"]).get(
+            id=instance_id
+        )
     except Instance.DoesNotExist:
         return JsonResponse({"status": 1, "msg": "你所在组未关联该实例", "data": []})
 
@@ -77,7 +79,9 @@ def create(request):
         return JsonResponse({"status": 1, "msg": "参数不完整，请确认后提交", "data": []})
 
     try:
-        instance = user_instances(request.user, db_type=["mysql", "mongo"]).get(id=instance_id)
+        instance = user_instances(request.user, db_type=["mysql", "mongo"]).get(
+            id=instance_id
+        )
     except Instance.DoesNotExist:
         return JsonResponse({"status": 1, "msg": "你所在组未关联该实例", "data": []})
 
@@ -87,18 +91,22 @@ def create(request):
         return JsonResponse({"status": 1, "msg": "负责人不存在", "data": []})
 
     engine = get_engine(instance=instance)
-    if instance.db_type == 'mysql':
+    if instance.db_type == "mysql":
         # escape
         db_name = MySQLdb.escape_string(db_name).decode("utf-8")
-        exec_result = engine.execute(db_name="information_schema", sql=f"create database {db_name};")
-    elif instance.db_type == 'mongo':
+        exec_result = engine.execute(
+            db_name="information_schema", sql=f"create database {db_name};"
+        )
+    elif instance.db_type == "mongo":
         exec_result = ResultSet()
         try:
             conn = engine.get_connection()
             db = conn[db_name]
-            db.create_collection(name=f'archery-{db_name}')  # mongo创建数据库，需要数据库存在数据才会显示数据库名称，这里创建一个archery-{db_name}的集合
+            db.create_collection(
+                name=f"archery-{db_name}"
+            )  # mongo创建数据库，需要数据库存在数据才会显示数据库名称，这里创建一个archery-{db_name}的集合
         except Exception as e:
-            exec_result.error = f'创建数据库失败, 错误信息：{str(e)}'
+            exec_result.error = f"创建数据库失败, 错误信息：{str(e)}"
 
     # 关闭连接
     engine.close()
@@ -133,7 +141,9 @@ def edit(request):
         return JsonResponse({"status": 1, "msg": "参数不完整，请确认后提交", "data": []})
 
     try:
-        instance = user_instances(request.user, db_type=["mysql", "mongo"]).get(id=instance_id)
+        instance = user_instances(request.user, db_type=["mysql", "mongo"]).get(
+            id=instance_id
+        )
     except Instance.DoesNotExist:
         return JsonResponse({"status": 1, "msg": "你所在组未关联该实例", "data": []})
 
diff --git a/sql/models.py b/sql/models.py
index b66a3048f0..5043b5704f 100755
--- a/sql/models.py
+++ b/sql/models.py
@@ -605,8 +605,8 @@ class InstanceAccount(models.Model):
 
     instance = models.ForeignKey(Instance, on_delete=models.CASCADE)
     user = fields.EncryptedCharField(verbose_name="账号", max_length=128)
-    host = models.CharField(verbose_name="主机", max_length=64)             # mysql数据库存储主机信息
-    db_name = models.CharField(verbose_name="数据库名称", max_length=128)    # mongo数据库存储数据库名称
+    host = models.CharField(verbose_name="主机", max_length=64)  # mysql数据库存储主机信息
+    db_name = models.CharField(verbose_name="数据库名称", max_length=128)  # mongo数据库存储数据库名称
     password = fields.EncryptedCharField(
         verbose_name="密码", max_length=128, default="", blank=True
     )
diff --git a/sql/utils/instance_management.py b/sql/utils/instance_management.py
index 2735f81895..ffe27cf05d 100644
--- a/sql/utils/instance_management.py
+++ b/sql/utils/instance_management.py
@@ -6,14 +6,14 @@
 
 def get_instanceaccount_unique_value(db_type: str, account: InstanceAccount) -> str:
     """根据存储的实例账号数据，返回该实例类型的唯一值"""
-    if db_type == 'mysql':
+    if db_type == "mysql":
         return f"`{account['user']}`@`{account['host']}`"
-    elif db_type == 'mongo':
+    elif db_type == "mongo":
         return f"{account['db_name']}.{account['user']}"
 
 
 def get_instanceaccount_unique_key(db_type: str) -> str:
-    if db_type == 'mysql':
+    if db_type == "mysql":
         return "user_host"
-    elif db_type == 'mongo':
+    elif db_type == "mongo":
         return "db_name_user"

From c1c4d3bbf6a0c662c495781a3abea4e397e56534 Mon Sep 17 00:00:00 2001
From: quanbisen <1769128867@qq.com>
Date: Tue, 4 Apr 2023 18:01:01 +0800
Subject: [PATCH 4/9] add unittest for MySQL&MongoDB management function

---
 sql/engines/mysql.py |  20 ++++---
 sql/engines/tests.py | 135 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 146 insertions(+), 9 deletions(-)

diff --git a/sql/engines/mysql.py b/sql/engines/mysql.py
index a04946914b..e2bc7430f6 100644
--- a/sql/engines/mysql.py
+++ b/sql/engines/mysql.py
@@ -282,6 +282,15 @@ def get_tables_metas_data(self, db_name, **kwargs):
             table_metas.append(_meta)
         return table_metas
 
+    def get_bind_users(self, db_name: str):
+        sql_get_bind_users = f"""select group_concat(distinct(GRANTEE)),TABLE_SCHEMA
+                from information_schema.SCHEMA_PRIVILEGES
+                where TABLE_SCHEMA='{db_name}'
+                group by TABLE_SCHEMA;"""
+        return self.query(
+            "information_schema", sql_get_bind_users, close_conn=False
+        ).rows
+
     def get_all_databases_summary(self):
         """实例数据库管理功能，获取实例所有的数据库描述信息"""
         # 获取所有数据库
@@ -294,16 +303,9 @@ def get_all_databases_summary(self):
             # 获取数据库关联用户信息
             rows = []
             for db in dbs:
-                db_name = db[0]
-                sql_get_bind_users = f"""select group_concat(distinct(GRANTEE)),TABLE_SCHEMA
-        from information_schema.SCHEMA_PRIVILEGES
-        where TABLE_SCHEMA='{db_name}'
-        group by TABLE_SCHEMA;"""
-                bind_users = self.query(
-                    "information_schema", sql_get_bind_users, close_conn=False
-                ).rows
+                bind_users = self.get_bind_users(db_name=db[0])
                 row = {
-                    "db_name": db_name,
+                    "db_name": db[0],
                     "charset": db[1],
                     "collation": db[2],
                     "grantees": bind_users[0][0].split(",") if bind_users else [],
diff --git a/sql/engines/tests.py b/sql/engines/tests.py
index 9ae88cabad..0b9e7078d9 100644
--- a/sql/engines/tests.py
+++ b/sql/engines/tests.py
@@ -661,6 +661,59 @@ def test_get_long_transaction(self, _query):
         r = new_engine.get_long_transaction()
         self.assertIsInstance(r, ResultSet)
 
+    @patch.object(MysqlEngine, "get_bind_users")
+    @patch.object(MysqlEngine, "query")
+    def test_get_all_databases_summary(self, _query, _get_bind_users):
+        db_result1 = ResultSet()
+        db_result1.rows = [("some_db", "utf8mb4", "utf8mb4_general_ci")]
+        _query.return_value = db_result1
+        _get_bind_users.return_value = [("'some_user'@'%'", "cooperate_sign")]
+        new_engine = MysqlEngine(instance=self.ins1)
+        dbs = new_engine.get_all_databases_summary()
+        self.assertEqual(
+            dbs.rows,
+            [
+                {
+                    "db_name": "some_db",
+                    "charset": "utf8mb4",
+                    "collation": "utf8mb4_general_ci",
+                    "grantees": ["'some_user'@'%'"],
+                    "saved": False,
+                }
+            ],
+        )
+
+    @patch("MySQLdb.connect")
+    @patch.object(MysqlEngine, "query")
+    def test_get_instance_users_summary(self, _query, _connect):
+        result = ResultSet()
+        result.error = "query error"
+        _query.return_value = result
+        new_engine = MysqlEngine(instance=self.ins1)
+        user_summary = new_engine.get_instance_users_summary()
+        self.assertEqual(user_summary.error, "query error")
+
+    @patch("MySQLdb.connect")
+    @patch.object(MysqlEngine, "execute")
+    def test_create_instance_user(self, _execute, _connect):
+        _execute.return_value = ResultSet()
+        new_engine = MysqlEngine(instance=self.ins1)
+        result = new_engine.create_instance_user(
+            user="some_user", host="%", password1="123456", remark=""
+        )
+        self.assertEqual(
+            result.rows,
+            [
+                {
+                    "instance": self.ins1,
+                    "user": "some_user",
+                    "host": "%",
+                    "password": "123456",
+                    "remark": "",
+                }
+            ],
+        )
+
 
 class TestRedis(TestCase):
     @classmethod
@@ -2132,6 +2185,88 @@ def command(self, *arg, **kwargs):
         self.engine.kill_op(["shards: 111", "shards: 222"])
         mock_conn.admin.command.assert_called()
 
+    @patch("pymongo.database.Database.command")
+    @patch("sql.engines.mongo.MongoEngine.get_all_databases")
+    def test_get_all_databases_summary(self, _mock_all_databases, _mock_command):
+        db_result = ResultSet()
+        db_result.rows = ["admin"]
+        _mock_all_databases.return_value = db_result
+        _mock_command.return_value = {
+            "users": [
+                {
+                    "_id": "admin.root",
+                    "user": "root",
+                    "db": "admin",
+                    "roles": [{"role": "root", "db": "admin"}],
+                    "mechanisms": ["SCRAM-SHA-1", "SCRAM-SHA-256"],
+                }
+            ],
+            "ok": 1.0,
+        }
+        database_summary = self.engine.get_all_databases_summary()
+        self.assertEqual(
+            database_summary.rows,
+            [
+                {
+                    "db_name": "admin",
+                    "grantees": [
+                        "{'user': 'root', 'roles': [{'role': 'root', 'db': 'admin'}]}"
+                    ],
+                    "saved": False,
+                }
+            ],
+        )
+
+    @patch("pymongo.database.Database.command")
+    @patch("sql.engines.mongo.MongoEngine.get_all_databases")
+    def test_get_instance_users_summary(self, _mock_all_databases, _mock_command):
+        db_result = ResultSet()
+        db_result.rows = ["admin"]
+        _mock_all_databases.return_value = db_result
+        _mock_command.return_value = {
+            "users": [
+                {
+                    "_id": "admin.root",
+                    "user": "root",
+                    "db": "admin",
+                    "roles": [{"role": "root", "db": "admin"}],
+                    "mechanisms": ["SCRAM-SHA-1", "SCRAM-SHA-256"],
+                }
+            ],
+            "ok": 1.0,
+        }
+        database_summary = self.engine.get_instance_users_summary()
+        self.assertEqual(
+            database_summary.rows,
+            [
+                {
+                    "db_name_user": "admin.root",
+                    "db_name": "admin",
+                    "user": "root",
+                    "roles": ["root"],
+                    "saved": False,
+                }
+            ],
+        )
+
+    @patch("pymongo.database.Database.command")
+    def test_create_instance_user(self, _mock_command):
+        result = self.engine.create_instance_user(
+            db_name="test", user="some_user", password1="123456", remark=""
+        )
+        self.assertEqual(
+            result.rows,
+            [
+                {
+                    "instance": self.ins,
+                    "db_name": "test",
+                    "user": "some_user",
+                    "password": "123456",
+                    "remark": "",
+                }
+            ],
+        )
+
 
 class TestClickHouse(TestCase):
     def setUp(self):

From f332641c2c56cfcc34d0732b30737d3e51f1bf94 Mon Sep 17 00:00:00 2001
From: quanbisen <1769128867@qq.com>
Date: Thu, 25 May 2023 10:53:01 +0800
Subject: [PATCH 5/9] add dingding login

---
 archery/settings.py                             | 17 ++++++++++++++++-
 archery/urls.py                                 |  1 +
 common/authenticate/__init__.py                 |  0
 common/authenticate/dingding_auth.py            | 10 ++++++++++
 .../auth.py => common/authenticate/oidc_auth.py |  0
 common/middleware/check_login_middleware.py     |  2 ++
 common/templates/login.html                     |  5 +++++
 requirements.txt                                |  1 +
 sql/engines/mysql.py                            |  2 +-
 sql/instance_account.py                         |  2 +-
 sql/instance_database.py                        |  2 +-
 sql/views.py                                    |  5 ++---
 12 files changed, 40 insertions(+), 7 deletions(-)
 create mode 100644 common/authenticate/__init__.py
 create mode 100644 common/authenticate/dingding_auth.py
 rename oidc/auth.py => common/authenticate/oidc_auth.py (100%)

diff --git a/archery/settings.py b/archery/settings.py
index 2f1698423e..04743169e5 100644
--- a/archery/settings.py
+++ b/archery/settings.py
@@ -19,6 +19,7 @@
     CACHE_URL=(str, "redis://127.0.0.1:6379/0"),
     ENABLE_LDAP=(bool, False),
     ENABLE_OIDC=(bool, False),
+    ENABLE_DINGDING=(bool, False),
     AUTH_LDAP_ALWAYS_UPDATE_USER=(bool, True),
     AUTH_LDAP_USER_ATTR_MAP=(
         dict,
@@ -236,7 +237,7 @@
     INSTALLED_APPS += ("mozilla_django_oidc",)
     MIDDLEWARE += ("mozilla_django_oidc.middleware.SessionRefresh",)
     AUTHENTICATION_BACKENDS = (
-        "oidc.auth.OIDCAuthenticationBackend",
+        "common.authenticate.oidc_auth.OIDCAuthenticationBackend",
         "django.contrib.auth.backends.ModelBackend",
     )
 
@@ -260,6 +261,20 @@
 
     LOGIN_REDIRECT_URL = "/"
 
+# Dingding
+ENABLE_DINGDING = env("ENABLE_DINGDING", False)
+if ENABLE_DINGDING:
+    INSTALLED_APPS += ("django_auth_dingding",)
+    AUTHENTICATION_BACKENDS = (
+        "common.authenticate.dingding_auth.DingdingAuthenticationBackend",
+        "django.contrib.auth.backends.ModelBackend",
+    )
+    AUTH_DINGDING_AUTHENTICATION_CALLBACK_URL = env(
+        "AUTH_DINGDING_AUTHENTICATION_CALLBACK_URL"
+    )
+    AUTH_DINGDING_APP_KEY = env("AUTH_DINGDING_APP_KEY")
+    AUTH_DINGDING_APP_SECRET = env("AUTH_DINGDING_APP_SECRET")
+
 # LDAP
 ENABLE_LDAP = env("ENABLE_LDAP", False)
 if ENABLE_LDAP:
diff --git a/archery/urls.py b/archery/urls.py
index cb455ab98a..e24e00eb52 100644
--- a/archery/urls.py
+++ b/archery/urls.py
@@ -6,6 +6,7 @@
     path("admin/", admin.site.urls),
     path("api/", include(("sql_api.urls", "sql_api"), namespace="sql_api")),
     path("oidc/", include("mozilla_django_oidc.urls")),
+    path("dingding/", include("django_auth_dingding.urls")),
     path("", include(("sql.urls", "sql"), namespace="sql")),
 ]
 
diff --git a/common/authenticate/__init__.py b/common/authenticate/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/common/authenticate/dingding_auth.py b/common/authenticate/dingding_auth.py
new file mode 100644
index 0000000000..091ba80b90
--- /dev/null
+++ b/common/authenticate/dingding_auth.py
@@ -0,0 +1,10 @@
+from django_auth_dingding import auth
+from common.auth import init_user
+
+
+class DingdingAuthenticationBackend(auth.DingdingAuthenticationBackend):
+    def create_user(self, claims):
+        """Return object for a newly created user account."""
+        user = super().create_user(claims)
+        init_user(user)
+        return user
diff --git a/oidc/auth.py b/common/authenticate/oidc_auth.py
similarity index 100%
rename from oidc/auth.py
rename to common/authenticate/oidc_auth.py
diff --git a/common/middleware/check_login_middleware.py b/common/middleware/check_login_middleware.py
index ec78d697d9..9d906f9929 100644
--- a/common/middleware/check_login_middleware.py
+++ b/common/middleware/check_login_middleware.py
@@ -12,6 +12,8 @@
     "/oidc/callback/",
     "/oidc/authenticate/",
     "/oidc/logout/",
+    "/dingding/callback/",
+    "/dingding/authenticate/",
 ]
 
 IGNORE_URL_RE = r"/api/(v1|auth)/\w+"
diff --git a/common/templates/login.html b/common/templates/login.html
index 5ef904e1bc..a015074b2f 100644
--- a/common/templates/login.html
+++ b/common/templates/login.html
@@ -43,6 +43,11 @@
                     <a href="/oidc/authenticate/">以OIDC登录</a>
                 </div>
             {% endif %}
+            {% if dingding_enabled %}
+                <div class="form-group">
+                    <a href="/dingding/authenticate/">以钉钉登录</a>
+                </div>
+            {% endif %}
         </form>
     </div>
 </div>
diff --git a/requirements.txt b/requirements.txt
index 9c30bdfda9..dea978ef6c 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -38,3 +38,4 @@ django-environ==0.8.1
 alibabacloud_dysmsapi20170525==2.0.9
 tencentcloud-sdk-python==3.0.656
 mozilla-django-oidc==3.0.0
+django-auth-dingding==0.0.2
\ No newline at end of file
diff --git a/sql/engines/mysql.py b/sql/engines/mysql.py
index 5c1635c7a6..2b05b6488b 100644
--- a/sql/engines/mysql.py
+++ b/sql/engines/mysql.py
@@ -874,4 +874,4 @@ def get_long_transaction(self, thread_time=3):
     def close(self):
         if self.conn:
             self.conn.close()
-            self.conn = None
\ No newline at end of file
+            self.conn = None
diff --git a/sql/instance_account.py b/sql/instance_account.py
index 35337237b1..0e085cd00c 100644
--- a/sql/instance_account.py
+++ b/sql/instance_account.py
@@ -381,4 +381,4 @@ def delete(request):
             instance=instance, user=user, host=host, db_name=db_name
         ).delete()
 
-    return JsonResponse({"status": 0, "msg": "", "data": []})
\ No newline at end of file
+    return JsonResponse({"status": 0, "msg": "", "data": []})
diff --git a/sql/instance_database.py b/sql/instance_database.py
index fc30d9ddcd..223b3f36b2 100644
--- a/sql/instance_database.py
+++ b/sql/instance_database.py
@@ -158,4 +158,4 @@ def edit(request):
         db_name=db_name,
         defaults={"owner": owner, "owner_display": owner_display, "remark": remark},
     )
-    return JsonResponse({"status": 0, "msg": "", "data": []})
\ No newline at end of file
+    return JsonResponse({"status": 0, "msg": "", "data": []})
diff --git a/sql/views.py b/sql/views.py
index a002b5ad66..4c494e69f3 100644
--- a/sql/views.py
+++ b/sql/views.py
@@ -1,8 +1,6 @@
 # -*- coding: UTF-8 -*-
 import os
 import traceback
-
-import simplejson as json
 from django.conf import settings
 
 from django.contrib.auth.decorators import permission_required
@@ -65,7 +63,8 @@ def login(request):
         "login.html",
         context={
             "sign_up_enabled": SysConfig().get("sign_up_enabled"),
-            "oidc_enabled": os.getenv("ENABLE_OIDC"),
+            "oidc_enabled": settings.ENABLE_OIDC,
+            "dingding_enabled": settings.ENABLE_DINGDING,
         },
     )
 

From 4a1a223d461d6680f7bfd127effb584d92d1a2ef Mon Sep 17 00:00:00 2001
From: quanbisen <1769128867@qq.com>
Date: Thu, 25 May 2023 17:40:22 +0800
Subject: [PATCH 6/9] add comment for setting dingding auth

---
 archery/settings.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/archery/settings.py b/archery/settings.py
index 04743169e5..ee9f2e1fed 100644
--- a/archery/settings.py
+++ b/archery/settings.py
@@ -17,9 +17,13 @@
     SECRET_KEY=(str, "hfusaf2m4ot#7)fkw#di2bu6(cv0@opwmafx5n#6=3d%x^hpl6"),
     DATABASE_URL=(str, "mysql://root:@127.0.0.1:3306/archery"),
     CACHE_URL=(str, "redis://127.0.0.1:6379/0"),
+    # 系统外部认证目前支持LDAP、OIDC、DINGDING三种，认证方式只能启用其中一种，如果启用多个，实际生效的只有一个，优先级LDAP > DINGDING > OIDC
     ENABLE_LDAP=(bool, False),
     ENABLE_OIDC=(bool, False),
-    ENABLE_DINGDING=(bool, False),
+    ENABLE_DINGDING=(
+        bool,
+        False,
+    ),  # 钉钉认证方式参考文档：https://open.dingtalk.com/document/orgapp/tutorial-obtaining-user-personal-information
     AUTH_LDAP_ALWAYS_UPDATE_USER=(bool, True),
     AUTH_LDAP_USER_ATTR_MAP=(
         dict,

From d89cb9bc1e63cb764e7b01c9692fecfa48b38649 Mon Sep 17 00:00:00 2001
From: quanbisen <1769128867@qq.com>
Date: Sun, 28 May 2023 21:25:03 +0800
Subject: [PATCH 7/9] add log info for authentication

---
 archery/settings.py | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/archery/settings.py b/archery/settings.py
index ee9f2e1fed..bc94ef97f5 100644
--- a/archery/settings.py
+++ b/archery/settings.py
@@ -7,6 +7,12 @@
 from datetime import timedelta
 import environ
 import requests
+import logging
+
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
 
 BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 
@@ -312,6 +318,18 @@
     )  # 每次登录从ldap同步用户信息
     AUTH_LDAP_USER_ATTR_MAP = env("AUTH_LDAP_USER_ATTR_MAP")
 
+if ENABLE_LDAP or ENABLE_DINGDING or ENABLE_LDAP:
+    logger.info(
+        "系统外部认证目前支持LDAP、OIDC、DINGDING三种，认证方式只能启用其中一种，如果启用多个，实际生效的只有一个，优先级LDAP > DINGDING > OIDC"
+    )
+    authentication = (
+        "LDAP"
+        if ENABLE_LDAP
+        else ("DINGDING" if ENABLE_DINGDING else ("OIDC" if ENABLE_OIDC else ""))
+    )
+    logger.info("当前生效的认证方式：" + authentication)
+    logger.info("认证后端：" + AUTHENTICATION_BACKENDS.__str__())
+
 # LOG配置
 LOGGING = {
     "version": 1,

From e421b355a613d21fe43486822e71726e3dde9a9a Mon Sep 17 00:00:00 2001
From: quanbisen <1769128867@qq.com>
Date: Mon, 29 May 2023 09:22:12 +0800
Subject: [PATCH 8/9] fixed

---
 archery/settings.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/archery/settings.py b/archery/settings.py
index bc94ef97f5..2536101ec9 100644
--- a/archery/settings.py
+++ b/archery/settings.py
@@ -318,7 +318,7 @@
     )  # 每次登录从ldap同步用户信息
     AUTH_LDAP_USER_ATTR_MAP = env("AUTH_LDAP_USER_ATTR_MAP")
 
-if ENABLE_LDAP or ENABLE_DINGDING or ENABLE_LDAP:
+if ENABLE_LDAP or ENABLE_DINGDING or ENABLE_OIDC:
     logger.info(
         "系统外部认证目前支持LDAP、OIDC、DINGDING三种，认证方式只能启用其中一种，如果启用多个，实际生效的只有一个，优先级LDAP > DINGDING > OIDC"
     )

From 6b459ee58c98ed2f05225cde491ac39e10c4d936 Mon Sep 17 00:00:00 2001
From: quanbisen <1769128867@qq.com>
Date: Mon, 29 May 2023 15:21:15 +0800
Subject: [PATCH 9/9] fixed

---
 archery/settings.py | 30 ++++++++++++++++++++----------
 1 file changed, 20 insertions(+), 10 deletions(-)

diff --git a/archery/settings.py b/archery/settings.py
index 2536101ec9..0a01726696 100644
--- a/archery/settings.py
+++ b/archery/settings.py
@@ -318,16 +318,26 @@
     )  # 每次登录从ldap同步用户信息
     AUTH_LDAP_USER_ATTR_MAP = env("AUTH_LDAP_USER_ATTR_MAP")
 
-if ENABLE_LDAP or ENABLE_DINGDING or ENABLE_OIDC:
-    logger.info(
-        "系统外部认证目前支持LDAP、OIDC、DINGDING三种，认证方式只能启用其中一种，如果启用多个，实际生效的只有一个，优先级LDAP > DINGDING > OIDC"
-    )
-    authentication = (
-        "LDAP"
-        if ENABLE_LDAP
-        else ("DINGDING" if ENABLE_DINGDING else ("OIDC" if ENABLE_OIDC else ""))
-    )
-    logger.info("当前生效的认证方式：" + authentication)
+SUPPORTED_AUTHENTICATION = [
+    ("LDAP", ENABLE_LDAP),
+    ("DINGDING", ENABLE_DINGDING),
+    ("OIDC", ENABLE_OIDC),
+]
+# 计算当前启用的外部认证方式数量
+ENABLE_AUTHENTICATION_COUNT = len(
+    [enabled for (name, enabled) in SUPPORTED_AUTHENTICATION if enabled]
+)
+if ENABLE_AUTHENTICATION_COUNT > 0:
+    if ENABLE_AUTHENTICATION_COUNT > 1:
+        logger.warning(
+            "系统外部认证目前支持LDAP、DINGDING、OIDC三种，认证方式只能启用其中一种，如果启用多个，实际生效的只有一个，优先级LDAP > DINGDING > OIDC"
+        )
+    authentication = ""  # 默认为空
+    for name, enabled in SUPPORTED_AUTHENTICATION:
+        if enabled:
+            authentication = name
+            break
+    logger.info("当前生效的外部认证方式：" + authentication)
     logger.info("认证后端：" + AUTHENTICATION_BACKENDS.__str__())
 
 # LOG配置