Django后端开发笔记

  province_objs = Province.objects.values_list('name', 'code').order_by('code')

  province_objs = Province.objects.values('name', 'code').order_by('code')

 from django.db.models import Count
 # ...
 # 按照省份名称过滤记录
 museum_province_queryset = Museum.objects.filter(province_name=province_name).values('city_name')
# 分组统计每个地级市有多少条记录（博物馆数量）
 province_count_set = museum_province_queryset.annotate(count=Count("city_name"))

BASE_DIR = Path(__file__).resolve().parent.parent
sys.path.insert(0, os.path.join(BASE_DIR, "apps"))

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    "django.contrib.gis",
    'django_admin_listfilter_dropdown',
    'rest_framework',
    "apps.map_basic"
]

django-admin startproject Message
cd Message
django-admin startapp message_form 

    def process_request(self, request):
        path = request.path.lstrip("/")
        if (
            self.redirect
            and not request.is_secure()
            and not any(pattern.search(path) for pattern in self.redirect_exempt)
        ):
            host = self.redirect_host or request.get_host()
            return HttpResponsePermanentRedirect(
                "https://%s%s" % (host, request.get_full_path())
            )

    def process_request(self, request):
        """
        Check for denied User-Agents and rewrite the URL based on
        settings.APPEND_SLASH and settings.PREPEND_WWW
        """

        # Check for denied User-Agents
        user_agent = request.META.get("HTTP_USER_AGENT")
        if user_agent is not None:
            for user_agent_regex in settings.DISALLOWED_USER_AGENTS:
                if user_agent_regex.search(user_agent):
                    raise PermissionDenied("Forbidden user agent")

        # Check for a redirect based on settings.PREPEND_WWW
        host = request.get_host()

        if settings.PREPEND_WWW and host and not host.startswith("www."):
            # Check if we also need to append a slash so we can do it all
            # with a single redirect. (This check may be somewhat expensive,
            # so we only do it if we already know we're sending a redirect,
            # or in process_response if we get a 404.)
            if self.should_redirect_with_slash(request):
                path = self.get_full_path_with_slash(request)
            else:
                path = request.get_full_path()

            return self.response_redirect_class(f"{request.scheme}://www.{host}{path}")

DISALLOWED_USER_AGENTS = [
    re.compile("curl"),
    re.compile("python")
]

# User-Agent黑名单，编译过的正则表达式, 同时配置不区分大小写
DISALLOWED_USER_AGENTS = [
    re.compile("curl", re.IGNORECASE),
    re.compile("python", re.IGNORECASE),
    re.compile("PhantomJS", re.IGNORECASE),
    re.compile("selenium", re.IGNORECASE),
    re.compile("java", re.IGNORECASE),

]

    def process_request(self, request):
        path = request.path.lstrip("/")
        if (
            self.redirect
            and not request.is_secure()
            and not any(pattern.search(path) for pattern in self.redirect_exempt)
        ):
            host = self.redirect_host or request.get_host()
            return HttpResponsePermanentRedirect(
                "https://%s%s" % (host, request.get_full_path())
            )

import time
from django.utils.deprecation import MiddlewareMixin
from django.http import HttpResponse


class AntiCrawlMiddleware(MiddlewareMixin):
    last_id = None
    last_time = 0

    def process_request(self, request):
        print("反爬虫中间件")

        # request META 'HTTP_USER_AGENT'
        # 针对USER_AGENT的拦截已经在common.py的CommonMiddleware有实现

        # IP访问频率限制
        ip = request.META.get("REMOTE_ADDR")
        now = time.time()
        print(now, ip)
        if ip == AntiCrawlMiddleware.last_id and now - AntiCrawlMiddleware.last_time < 1:
            return HttpResponse("your visit frequency is too high, please try again later.")
        AntiCrawlMiddleware.last_id = ip
        AntiCrawlMiddleware.last_time = now

# settings.py
MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
    # 反爬虫中间件
    'middlewares.anticrawl.AntiCrawlMiddleware'
]

def process_request(request):
        # Cookie反爬，以token为例
        print("cookies", request.COOKIES)
        token = request.COOKIES.get("token",None)
        print(token)
        if token is None:
            # 如果token为None 可以考虑重定向到某一个页面
            # return redirect("https://www.baidu.com")
            # return HttpResponseRedirect("your visit is illegal.")
            # 示例；直接返回错误响应
            return HttpResponse("your visit is illegal.")

python manage.py createsuperuser

from django_admin_listfilter_dropdown.filters import (DropdownFilter, ChoiceDropdownFilter, RelatedDropdownFilter)
class CountyAdmin(admin.ModelAdmin):
    # 配置展示什么字段
    fields = ('provincena', 'city_name', 'name', 'code', 'shape_leng', 'shape_area', 'geo')
    # 以列表的形式展示表数据
    list_display = ['city_name', 'provincena', 'name', 'code', 'shape_area']
    # 可搜索的字段
    search_fields = ('name', 'provincena')
    # 过滤字段: https://docs.djangoproject.com/en/4.2/ref/contrib/admin/filters/
    # list_filter = ('provincena', 'city_name')
    list_filter = (
        ('provincena', DropdownFilter),
        ('city_name', DropdownFilter)
    )
    # 排序字段
    ordering = ("-shape_area",)

pip install django-simpleui

  # Application definition

  INSTALLED_APPS = [
      'simpleui',
      'django.contrib.admin',
      'django.contrib.auth',
      'django.contrib.contenttypes',
      'django.contrib.sessions',
      'django.contrib.messages',
      'django.contrib.staticfiles',
      ...
  ]

INSTALLED_APPS = [
    ...
    'rest_framework',
]

uwsgi --http :8090 --chdir projectpath --module museum_geo_api.wsgi

[uwsgi]
http=:8001
chdir=/Users/weirdgiser/文稿/Projects/Cultural/musuem_geo_api_dev/museum_geo_api/museum_geo_api
module=museum_geo_api.wsgi

 uwsgi --ini uwsgi.ini  --enable-threads 

# 指定服务器监听的IP和端口
bind = "0.0.0.0:8010"
# 指定工作进程的数量
workers = 4
# 指定工作进程使用的协程库
worker_class = "gevent"

# ----应用程序的设置
# 指定为项目根目录
chdir = "/Users/weirdgiser/文稿/Projects/Cultural/musuem_geo_api_dev/museum_geo_api/museum_geo_api"
# 指定WSGI应用程序的模块和应用
module = "museum_geo_api.wsgi:application"

class AbstractUser(AbstractBaseUser, PermissionsMixin):
    """
    An abstract base class implementing a fully featured User model with
    admin-compliant permissions.

    Username and password are required. Other fields are optional.
    """

    username_validator = UnicodeUsernameValidator()

    username = models.CharField(
        _("username"),
        max_length=150,
        unique=True,
        help_text=_(
            "Required. 150 characters or fewer. Letters, digits and @/./+/-/_ only."
        ),
        validators=[username_validator],
        error_messages={
            "unique": _("A user with that username already exists."),
        },
    )
    first_name = models.CharField(_("first name"), max_length=150, blank=True)
    last_name = models.CharField(_("last name"), max_length=150, blank=True)
    email = models.EmailField(_("email address"), blank=True)
    is_staff = models.BooleanField(
        _("staff status"),
        default=False,
        help_text=_("Designates whether the user can log into this admin site."),
    )
    is_active = models.BooleanField(
        _("active"),
        default=True,
        help_text=_(
            "Designates whether this user should be treated as active. "
            "Unselect this instead of deleting accounts."
        ),
    )
    date_joined = models.DateTimeField(_("date joined"), default=timezone.now)

    objects = UserManager()

    EMAIL_FIELD = "email"
    USERNAME_FIELD = "username"
    REQUIRED_FIELDS = ["email"]

    class Meta:
        verbose_name = _("user")
        verbose_name_plural = _("users")
        abstract = True

    def clean(self):
        super().clean()
        self.email = self.__class__.objects.normalize_email(self.email)

    def get_full_name(self):
        """
        Return the first_name plus the last_name, with a space in between.
        """
        full_name = "%s %s" % (self.first_name, self.last_name)
        return full_name.strip()

    def get_short_name(self):
        """Return the short name for the user."""
        return self.first_name

    def email_user(self, subject, message, from_email=None, **kwargs):
        """Send an email to this user."""
        send_mail(subject, message, from_email, [self.email], **kwargs)


class User(AbstractUser):
    """
    Users within the Django authentication system are represented by this
    model.

    Username and password are required. Other fields are optional.
    """

    class Meta(AbstractUser.Meta):
        swappable = "AUTH_USER_MODEL"

class ExtendedUser(AbstractUser):
    phone = models.CharField(max_length=32, db_comment="电话号码")
    residential_address = models.CharField(max_length=128, db_comment="住宅地址")
    wechat_openid = models.CharField(max_length=128, db_comment="微信公开ID")
    education = models.CharField(max_length=8, db_comment="教育程度")
    graduate_institution = models.CharField(max_length=8, db_comment="毕业院校")
    vip_effective_time = models.DateTimeField(db_comment="VIP有效日期期限")
    user_permissions = models.ManyToManyField(
        Permission,
        verbose_name= '用户权限',
        blank=True,
        help_text= 'Specific permissions for this user.',
    )

    # 对当前表进行相关设置:
    class Meta:
        managed = True
        db_table = 'extended_users'
        verbose_name = '用户基础表'
        verbose_name_plural = verbose_name

python manage.py makemigrations app_name
python manage.py migrate app_name

# settings.py
# 日志模块配置
LOGGING = {
    "version": 1,
    "disable_existing_loggers": False,
    "formatters": {
        "verbose": {
            "format": "{levelname} {asctime} {module} {process:d} {thread:d} {message}",
            "style": "{",
        },
        "simple": {
            "format": "{levelname} {asctime} {module} {message}",
            "style": "{",
        },
    },
    "handlers": {
        "console": {
            "class": "logging.StreamHandler",
            "formatter": "simple",


        },
        "file": {
            "level": "DEBUG",
            "class": "logging.FileHandler",
            "filename": os.path.join(BASE_DIR, "logs","museum_geo_api.log"),
            "formatter": "verbose",

        },
    },
    "loggers": {
        "django": {
            "handlers": ["console","file"],
            "level": "INFO",
            "propagate": True,
        },
    },
}