Merge branch 'dev'

# Conflicts:
#	Dockerfile

Author: nineaiyu

Dockerfile

@@ -1,4 +1,4 @@
-FROM nineaiyu/xadmin-server-base:20241129_024544 AS stage-build
+FROM nineaiyu/xadmin-server-base:20241129_074632 AS stage-build
 ARG VERSION
 
 WORKDIR /data/xadmin-server

common/base/utils.py

@@ -146,7 +146,7 @@ def format_menu_meta(meta: dict) -> dict:
 def format_menu_data(data):
     new_result = []
     for d in data:
-        if d.get('count', -1) < 2:
+        if d.get('count', -1) < 1:
             route = {
                 'path': f"/default{d.get('path')}",
                 'title': d.get('title'),

common/core/fields.py

@@ -17,6 +17,7 @@
 from rest_framework.serializers import RelatedField, MultipleChoiceField
 
 from common.core.filter import get_filter_queryset
+from server.utils import get_current_request
 
 
 def attr_get(obj, attr, sp='.'):
@@ -81,9 +82,8 @@ class BasePrimaryKeyRelatedField(RelatedField):
         "queryset_none": _("The query set is empty."),
     }
 
-    def __init__(self, request=None, attrs=None, ignore_field_permission=False, **kwargs):
+    def __init__(self, attrs=None, ignore_field_permission=False, **kwargs):
         """
-        :param request:
         :param attrs: 默认为 None，返回默认的 pk， 一般需要自定义
         :param ignore_field_permission: 忽略字段权限控制
         """
@@ -92,16 +92,15 @@ def __init__(self, request=None, attrs=None, ignore_field_permission=False, **kw
         self.input_type = kwargs.pop("input_type", '')
         self.many = kwargs.get("many", False)
         super().__init__(**kwargs)
-        self.request: Request = request or self.context.get("request", None)
+        self.request: Request = get_current_request()
         self.ignore_field_permission = ignore_field_permission
 
     def use_pk_only_optimization(self):
         return False
 
     def __add_request(self):
-        request = self.context.get("request", None)
         if not self.request:
-            self.request = request
+            self.request = get_current_request()
 
     def get_queryset(self):
         self.__add_request()

common/core/middleware.py

@@ -14,7 +14,7 @@
 from rest_framework.utils import encoders
 
 from common.utils import get_logger
-from common.utils.request import get_request_user, get_request_ip, get_request_data, get_request_path, get_os, \
+from common.utils.request import get_request_user, get_request_ip, get_request_data, get_os, \
     get_browser, get_verbose_name
 from system.models import OperationLog
 
@@ -34,7 +34,6 @@ def __init__(self, get_response=None):
     def __handle_request(cls, request):
         request.request_ip = get_request_ip(request)
         request.request_data = get_request_data(request)
-        request.request_path = get_request_path(request)
         request.request_start_time = time.time()
         logger.debug(f"request start. {request.method} {request.path} {getattr(request, 'request_data', {})}")
 
@@ -80,7 +79,7 @@ def __handle_response(self, request, response):
             'dept_belong_id': getattr(request.user, 'dept_id', None),
             'ipaddress': getattr(request, 'request_ip'),
             'method': request.method,
-            'path': request.request_path,
+            'path': request.path,
             'body': json.dumps(body) if isinstance(body, dict) else body,
             'response_code': response.status_code,
             'system': get_os(request),
@@ -105,10 +104,10 @@ def process_view(self, request, view_func, view_args, view_kwargs):
                 if self.methods == 'ALL' or request.method in self.methods:
                     model, v = get_verbose_name(view_func.cls.queryset, view_func.cls)
                     if (model and request.method in self.ignores.get(model._meta.label, [])) or (
-                            request.method in self.ignores.get(request.request_path, [])):
+                            request.method in self.ignores.get(request.path, [])):
                         return
                     if not v:
-                        v = settings.API_MODEL_MAP.get(request.request_path, v)
+                        v = settings.API_MODEL_MAP.get(request.path, v)
                         if not v and model:
                             v = model._meta.label
                     log = OperationLog(module=v)

common/core/modelset.py

@@ -6,11 +6,11 @@
 # date : 6/2/2023
 import itertools
 import json
-import math
 import uuid
 from hashlib import md5
 from typing import Callable
 
+import math
 from django.conf import settings
 from django.db import transaction
 from django.forms.widgets import SelectMultiple, DateTimeInput

common/core/permission.py

@@ -5,6 +5,7 @@
 # author : ly_13
 # date : 6/6/2023
 import re
+import uuid
 
 from django.conf import settings
 from django.db.models import Q
@@ -13,6 +14,7 @@
 from rest_framework.permissions import BasePermission
 
 from common.base.magic import MagicCacheData
+from server.utils import get_current_request, set_current_request
 from system.models import Menu, FieldPermission
 
 
@@ -92,6 +94,9 @@ class IsAuthenticated(BasePermission):
     def has_permission(self, request, view):
         auth = bool(request.user and request.user.is_authenticated)
         if auth:
+            request.request_uuid = getattr(get_current_request(), "request_uuid", uuid.uuid4())
+            set_current_request(request)
+
             if request.user.is_superuser:
                 request.ignore_field_permission = True
                 return True

common/core/response.py

@@ -8,15 +8,15 @@
 from django.utils.translation import gettext_lazy as _
 from rest_framework.response import Response
 
-from server.utils import current_request
+from server.utils import get_current_request
 
 
 class ApiResponse(Response):
     def __init__(self, code=1000, detail=None, data=None, status=None, headers=None, content_type=None, **kwargs):
         dic = {
             'code': code,
             'detail': detail if detail else (_("Operation successful") if code == 1000 else _("Operation failed")),
-            'requestId': str(getattr(current_request, 'request_uuid', ""))
+            'requestId': str(getattr(get_current_request(), 'request_uuid', ""))
         }
         if data is not None:
             dic['data'] = data

common/core/serializers.py

@@ -13,6 +13,7 @@
 from rest_framework.serializers import ModelSerializer
 
 from common.core.fields import BasePrimaryKeyRelatedField, LabeledChoiceField
+from server.utils import get_current_request
 
 
 class BaseModelSerializer(ModelSerializer):
@@ -32,21 +33,6 @@ def get_value(self, dictionary):
         #     return html.parse_html_dict(dictionary, prefix=self.field_name) or empty
         return dictionary.get(self.field_name, empty)
 
-    def get_uniqueness_extra_kwargs(self, field_names, declared_fields, extra_kwargs):
-        """
-        # 该方法是为了让继承BaseModelSerializer的方法，增加request传参,例如下面，为meta这个字段的序列化增加request参数
-        class MenuSerializer(BaseModelSerializer):
-            meta = MenuMetaSerializer()
-        """
-        for field_name in declared_fields:
-            if declared_fields[field_name] and isinstance(declared_fields[field_name],
-                                                          (BaseModelSerializer, BasePrimaryKeyRelatedField)):
-                obj = declared_fields[field_name]
-                declared_fields[field_name] = obj.__class__(*obj._args, **obj._kwargs, request=self.request)
-
-        extra_kwargs, hidden_fields = super().get_uniqueness_extra_kwargs(field_names, declared_fields, extra_kwargs)
-        return super().get_uniqueness_extra_kwargs(field_names, declared_fields, extra_kwargs)
-
     def get_allow_fields(self, fields, ignore_field_permission):
         """
         self.fields: 默认定义的字段
@@ -74,7 +60,7 @@ def get_allow_fields(self, fields, ignore_field_permission):
 
         return set(fields) & _fields & set(allow_fields)
 
-    def __init__(self, instance=None, data=empty, request=None, fields=None, ignore_field_permission=False, **kwargs):
+    def __init__(self, instance=None, data=empty, fields=None, ignore_field_permission=False, **kwargs):
         """
         :param instance:
         :param data:
@@ -83,7 +69,7 @@ def __init__(self, instance=None, data=empty, request=None, fields=None, ignore_
         :param ignore_field_permission: 忽略字段权限控制
         """
         super().__init__(instance, data, **kwargs)
-        self.request: Request = request or self.context.get("request", None)
+        self.request: Request = get_current_request()
         if self.request is None:
             return
         allowed = self.get_allow_fields(fields, ignore_field_permission)
@@ -100,20 +86,3 @@ def build_standard_field(self, field_name, model_field):
             field_kwargs.setdefault("default", default)
         return field_class, field_kwargs
 
-    def create(self, validated_data):
-        if self.request:
-            user = self.request.user
-            if user and user.is_authenticated:
-                if hasattr(self.Meta.model, 'creator') or hasattr(self.instance, 'creator'):
-                    validated_data["creator"] = user
-                if hasattr(self.Meta.model, 'dept_belong') or hasattr(self.instance, 'dept_belong'):
-                    validated_data["dept_belong"] = user.dept
-        return super().create(validated_data)
-
-    def update(self, instance, validated_data):
-        if self.request:
-            user = self.request.user
-            if user and user.is_authenticated:
-                if hasattr(self.instance, 'modifier'):
-                    validated_data["modifier"] = user
-        return super().update(instance, validated_data)

common/local.py

@@ -6,10 +6,9 @@
 # date : 10/18/2024
 
 
-from werkzeug.local import Local
-
-thread_local = Local()
+from asgiref.local import Local
 
+thread_local = Local(thread_critical=True)
 
 def _find(attr):
     return getattr(thread_local, attr, None)

common/signal_handlers.py

@@ -5,11 +5,16 @@
 # author : ly_13
 # date : 6/29/2023
 import logging
+import re
+from collections import defaultdict
 
 from celery import signature
 from celery.signals import worker_ready, worker_shutdown, after_setup_logger
+from django.conf import settings
 from django.core.cache import cache
-from django.db.models.signals import pre_delete
+from django.core.signals import request_finished
+from django.db import connection
+from django.db.models.signals import pre_delete, pre_save
 from django.dispatch import receiver
 from django_celery_beat.models import PeriodicTask
 from django_celery_results.models import TaskResult
@@ -19,10 +24,13 @@
 from common.celery.logger import CeleryThreadTaskFileHandler
 from common.celery.utils import get_celery_task_log_path
 from common.utils import get_logger
+from server.utils import get_current_request
 
 logger = get_logger(__name__)
 safe_str = lambda x: x
 
+pattern = re.compile(r'FROM `(\w+)`')
+
 
 @worker_ready.connect
 def on_app_ready(sender=None, headers=None, **kwargs):
@@ -61,7 +69,6 @@ def delete_file_handler(sender, **kwargs):
             log_path = get_celery_task_log_path(task_id)
             remove_file(log_path)
 
-
 @after_setup_logger.connect
 def on_after_setup_logger(sender=None, logger=None, loglevel=None, format=None, **kwargs):
     if not logger:
@@ -71,3 +78,82 @@ def on_after_setup_logger(sender=None, logger=None, loglevel=None, format=None,
     formatter = logging.Formatter(format)
     task_handler.setFormatter(formatter)
     logger.addHandler(task_handler)
+
+
+class Counter:
+    def __init__(self):
+        self.counter = 0
+        self.time = 0
+
+    def __gt__(self, other):
+        return self.counter > other.counter
+
+    def __lt__(self, other):
+        return self.counter < other.counter
+
+    def __eq__(self, other):
+        return self.counter == other.counter
+
+
+def on_request_finished_logging_db_query(sender, **kwargs):
+    queries = connection.queries
+    counters = defaultdict(Counter)
+    table_queries = defaultdict(list)
+    for query in queries:
+        if not query['sql'] or not query['sql'].startswith('SELECT'):
+            continue
+        tables = pattern.findall(query['sql'])
+        table_name = ''.join(tables)
+        time = query['time']
+        counters[table_name].counter += 1
+        counters[table_name].time += float(time)
+        counters['total'].counter += 1
+        counters['total'].time += float(time)
+        table_queries[table_name].append(query)
+
+    counters = sorted(counters.items(), key=lambda x: x[1])
+    if not counters:
+        return
+
+    method = 'GET'
+    path = '/Unknown'
+    current_request = get_current_request()
+    if current_request:
+        method = current_request.method
+        path = current_request.get_full_path()
+
+    print(">>>. [{}] {}".format(method, path))
+
+    for name, counter in counters:
+        logger.debug("Query {:3} times using {:.2f}s {}".format(
+            counter.counter, counter.time, name)
+        )
+
+
+def _get_request_user():
+    current_request = get_current_request()
+    if current_request and current_request.user and current_request.user.is_authenticated:
+        return current_request.user
+
+
+@receiver(pre_save)
+def on_create_set_creator(sender, instance=None, **kwargs):
+    if getattr(instance, '_ignore_auto_creator', False):
+        return
+    if not hasattr(instance, 'creator') or instance.creator:
+        return
+    instance.creator = _get_request_user()
+    if hasattr(instance, 'dept_belong') and instance.creator:
+        instance.dept_belong = instance.creator.dept
+
+
+@receiver(pre_save)
+def on_update_set_modifier(sender, instance=None, created=False, **kwargs):
+    if getattr(instance, '_ignore_auto_modifier', False):
+        return
+    if hasattr(instance, 'modifier'):
+        instance.modifier = _get_request_user()
+
+
+if settings.DEBUG_DEV:
+    request_finished.connect(on_request_finished_logging_db_query)