【目录结构】
APPS中的表数据
feeder表（model没有数据）
1 url.py 2 3 4 from django.contrib import admin 5 from django.urls import path, include 6 from rest_framework.routers import SimpleRouter 7 from .views import ( 8 FeederLoginView, 9 FeederInfoView, 10 FeederOrdersView, 11 FeederRemunerationView, 12 ) 13 14 15 router = SimpleRouter() 16 router.register("login", FeederLoginView, "login") 17 router.register("feederinfo", FeederInfoView, "feederinfo") 18 router.register("orders", FeederOrdersView, "orders") 19 router.register("remuneration", FeederRemunerationView, "remuneration") 20 21 22 urlpatterns = [path("", include(router.urls))] 23 24 25 ---------------------------------------------------------------------------- 26 27 view.py 28 29 from utils.common_response import APIResponse 30 from rest_framework.viewsets import GenericViewSet 31 from user.serializer import LoginSerializer 32 from django.contrib import auth 33 from rest_framework.decorators import action 34 from rest_framework_simplejwt.authentication import JWTAuthentication 35 from rest_framework.permissions import IsAuthenticated 36 from user.models import User, FeederRemuneration 37 import json 38 from rest_framework.response import Response 39 from order.models import Order 40 from datetime import datetime 41 from decimal import Decimal 42 43 44 # 多方式登录接口 45 class FeederLoginView(GenericViewSet): 46 serializer_class = LoginSerializer 47 48 def _login(self, request, *args, **kwargs): 49 serializer = self.get_serializer(data=request.data) 50 serializer.is_valid(raise_exception=True) 51 token = serializer.context.get("token") 52 user = serializer.context.get("username") 53 icon = serializer.context.get("icon") 54 if user.is_pet_feeder == 1: 55 auth.login(request, user) 56 return APIResponse( 57 token=token, 58 username=user.username, 59 icon=icon, 60 msg="登录成功!", 61 data=serializer.data, 62 ) 63 else: 64 return APIResponse(code=400, msg="用户不是喂养员，无法登录!") 65 66 @action(methods=["POST"], detail=False) 67 def multiple_login(self, request, *args, **kwargs): 68 return self._login(request, *args, **kwargs) 69 70 71 class FeederInfoView(GenericViewSet): 72 authentication_classes = [JWTAuthentication] 73 permission_classes = [IsAuthenticated] 74 75 def list(self, request, *args, **kwargs): 76 user = request.user 77 feeder = user.feeder 78 if feeder: 79 data = { 80 "id": feeder.id, 81 "name": feeder.name, 82 "icon": "http://192.168.1.38:8000/media/" + str(feeder.icon), 83 "gender": feeder.gender, 84 "desc": feeder.desc, 85 "service_duration": feeder.service_duration, 86 "price": feeder.price, 87 "feed_type": feeder.feed_type, 88 } 89 return Response({"code": 100, "msg": "查询成功!", "result": data}) 90 else: 91 return Response({"code": 400, "msg": "用户不是喂养员"}) 92 93 94 class FeederOrdersView(GenericViewSet): 95 authentication_classes = [JWTAuthentication] 96 permission_classes = [IsAuthenticated] 97 98 # 待接单点击变成待上门 99 @action(methods=["PUT"], detail=False) 100 def jiedan(self, request, *args, **kwargs): 101 feeder_id = request.user.feeder_id 102 order_id = request.data.get("order_id") # 0512046476199352916 103 qs = Order.objects.filter(order_id=order_id).first() 104 qs.feeder_id = feeder_id 105 qs.order_status = 2 106 qs.save() 107 return APIResponse(msg="接单成功!") 108 109 # 待上门点击变成进行中 110 @action(methods=["PUT"], detail=False) 111 def daishangmen(self, request, *args, **kwargs): 112 order_id = request.data.get("order_id") 113 qs = Order.objects.filter(order_id=order_id).first() 114 qs.order_status = 3 115 qs.save() 116 return APIResponse(msg="确认成功!") 117 118 # 进行中点击变成已完成 119 @action(methods=["PUT"], detail=False) 120 def jinxingzhong(self, request, *args, **kwargs): 121 order_id = request.data.get("order_id") 122 qs = Order.objects.filter(order_id=order_id).first() 123 qs.order_status = 4 124 qs.complete_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f") 125 qs.save() 126 127 remuneration = qs.actual_payment - qs.actual_payment * Decimal("0.2") 128 129 feeder_obj = FeederRemuneration.objects.filter(feeder=qs.feeder).first() 130 feeder_obj.remuneration += remuneration 131 feeder_obj.save() 132 133 return APIResponse(msg="订单完成!") 134 135 136 class FeederRemunerationView(GenericViewSet): 137 authentication_classes = [JWTAuthentication] 138 permission_classes = [IsAuthenticated] 139 140 def list(self, request, *args, **kwargs): 141 user = request.user.feeder_id 142 qs = FeederRemuneration.objects.filter(feeder=user).first() 143 remuneration = qs.remuneration 144 return APIResponse(msg="查询成功!", remuneration=remuneration)
home表数据
1 admin.py 2 3 from django.contrib import admin 4 5 # Register your models here. 6 from .models import Banner 7 8 9 @admin.register(Banner) 10 class BannerAdmin(admin.ModelAdmin): 11 list_display = ("title", "image", "link", "info", "description") 12 13 --------------------------------------------------------------------------- 14 apps.py 15 16 from django.apps import AppConfig 17 18 19 class HomeConfig(AppConfig): 20 default_auto_field = "django.db.models.BigAutoField" 21 name = "home" 22 verbose_name = "首页" 23 24 25 ----------------------------------------------------------------------------- 26 models.py 27 28 from django.db import models 29 30 from utils.common_models import BaseModel 31 32 33 class Banner(BaseModel): 34 title = models.CharField(max_length=64, unique=True, verbose_name="名称") 35 image = models.ImageField(upload_to="banner", verbose_name="图片") 36 link = models.CharField(max_length=64, verbose_name="跳转链接") 37 info = models.TextField(verbose_name="详情") 38 description = models.TextField(null=True, blank=True, verbose_name="介绍") 39 40 class Meta: 41 db_table = "puddingpet_banner" 42 verbose_name = "轮播图" 43 verbose_name_plural = verbose_name 44 45 ---------------------------------------------------------------------------------- 46 serializers.py 47 48 from rest_framework import serializers 49 from .models import Banner 50 51 52 class BannerSerializer(serializers.ModelSerializer): 53 class Meta: 54 model = Banner 55 fields = "__all__" 56 57 58 ------------------------------------------------------------------------------------- 59 url.py 60 61 from django.contrib import admin 62 from django.urls import path, include 63 from rest_framework.routers import SimpleRouter 64 from .views import BannerView 65 66 router = SimpleRouter() 67 router.register("banner", BannerView, "banner") 68 69 70 urlpatterns = [path("", include(router.urls))] 71 72 ------------------------------------------------------------------------------------ 73 viwe.py 74 75 from django.shortcuts import render 76 from rest_framework.viewsets import GenericViewSet 77 from utils.common_mixin import CacheListModelMixin 78 from .models import Banner 79 from django.conf import settings 80 from .serializer import BannerSerializer 81 82 83 class BannerView(GenericViewSet, CacheListModelMixin): 84 cache_key = "banner_list" 85 86 87 queryset = ( 88 Banner.objects.all().filter(is_delete=False, is_show=True).order_by("orders") 89 ) 90 91 serializer_class = BannerSerializer
order表数据
1 admin.py 2 3 from django.contrib import admin 4 from .models import Order 5 6 7 @admin.register(Order) 8 class OrderAdmin(admin.ModelAdmin): 9 list_display = ( 10 "order_id", 11 "order_time", 12 "complete_time", 13 "customer", 14 "feeder", 15 "appointment_time", 16 "address", 17 "pet", 18 "remarks", 19 "actual_payment", 20 "payment_method", 21 "review", 22 "order_status", 23 ) 24 25 ------------------------------------------------------------------------------------ 26 apps.py 27 28 from django.apps import AppConfig 29 30 31 class OrderConfig(AppConfig): 32 default_auto_field = "django.db.models.BigAutoField" 33 name = "order" 34 verbose_name = "订单表" 35 36 -------------------------------------------------------------------------------------- 37 models.py 38 39 from django.db import models 40 from user.models import User, PetFeeder, UserAddress 41 import random 42 from pet.models import Pet 43 44 45 def generate_order_id(): 46 """生成19位纯数字的订单ID""" 47 return "".join(random.choices("0123456789", k=19)) 48 49 50 class Order(models.Model): 51 order_id = models.CharField( 52 max_length=19, 53 default=generate_order_id, 54 unique=True, 55 editable=False, 56 verbose_name="订单号码", 57 ) # 订单号码 随机生成 58 order_time = models.DateTimeField( 59 auto_now_add=True, verbose_name="下单时间" 60 ) # 下单时间 61 complete_time = models.DateTimeField( 62 null=True, blank=True, verbose_name="完成时间" 63 ) # 完成时间 64 customer = models.ForeignKey( 65 User, on_delete=models.CASCADE, verbose_name="下单人" 66 ) # 下单人（外键） 67 feeder = models.ForeignKey( 68 PetFeeder, 69 on_delete=models.CASCADE, 70 verbose_name="预约对象", 71 blank=True, 72 null=True, 73 ) # 预约对象（外键） 74 appointment_time = models.CharField( 75 max_length=128, verbose_name="预约上门时间" 76 ) # 预约上门时间 77 address = models.ForeignKey( 78 UserAddress, on_delete=models.CASCADE, verbose_name="预约上门地址" 79 ) # 预约上门地址（外键） 80 pet = models.ForeignKey( 81 Pet, on_delete=models.CASCADE, verbose_name="预约宠物" 82 ) # 预约宠物（外键） 83 remarks = models.TextField(blank=True, null=True, verbose_name="备注") # 备注 84 actual_payment = models.IntegerField( 85 verbose_name="实付款", blank=True, null=True 86 ) # 实付款 87 88 PAYMENT_METHOD_CHOICES = ( 89 (0, "微信支付"), 90 (1, "支付宝"), 91 (2, "当面支付"), 92 ) 93 payment_method = models.IntegerField( 94 choices=PAYMENT_METHOD_CHOICES, 95 verbose_name="支付方式", 96 blank=True, 97 null=True, 98 ) # 支付方式 99 100 review = models.CharField( 101 max_length=128, blank=True, null=True, verbose_name="订单评价" 102 ) # 订单评价 103 104 ORDER_STATUS_CHOICES = ( 105 (0, "待付款"), 106 (1, "待接单"), 107 (2, "待上门"), 108 (3, "进行中"), 109 (4, "已完成"), 110 ) 111 order_status = models.IntegerField( 112 choices=ORDER_STATUS_CHOICES, default=0, verbose_name="订单状态" 113 ) # 订单状态 114 115 class Meta: 116 db_table = "puddingpet_order" 117 verbose_name = "订单表" 118 verbose_name_plural = verbose_name 119 120 def __str__(self): 121 return f"订单{self.order_id} by {self.customer.username}" 122 123 ------------------------------------------------------------------------------ 124 pagination .py 125 126 from rest_framework.pagination import PageNumberPagination 127 128 129 class CommonPagination(PageNumberPagination): 130 page_size = 3 # 每页显示多少条 131 page_query_param = "page" # http://127.0.0.1:8000/book/bookview/?page=2 分页 132 page_size_query_param = ( 133 "size" # http://127.0.0.1:8000/book/bookview/?page=1&size=3 每页显示条数 134 ) 135 max_page_size = 10 # 不管size输入多少，最多显示10条 136 137 -------------------------------------------------------------------------------- 138 serializers.py 139 140 141 from rest_framework import serializers 142 143 from .models import Order 144 145 146 class OrderSerializer(serializers.ModelSerializer): 147 order_id = serializers.CharField(read_only=True) 148 order_time = serializers.CharField(read_only=True) # 2024-06-03 10:12:42 149 150 class Meta: 151 model = Order 152 fields = [ 153 "order_id", # 订单号码 随机生成 154 "order_time", # 下单时间 155 "complete_time", # 完成时间 156 "customer", # 下单人（外键） 157 "feeder", # 预约对象（外键） 158 "appointment_time", # 预约上门时间 159 "address", # 预约上门地址（外键） 160 "pet", # 预约宠物（外键） 161 "remarks", # 备注 162 "actual_payment", # 实付款 163 "payment_method", # 支付方式 164 "review", # 订单评价 165 "order_status", # 订单状态 166 ] 167 168 # 如果有饲养员id，就是选择下单，有price，待付款 169 # 如果没有饲养员id，就是直接下单，price=0，待接单 170 # 等有饲养员接单了，把价格设置进去，让他付款 171 def create(self, validated_data): 172 print(validated_data) 173 # {'customer': <User: heart>, 'feeder': <PetFeeder: 超级喂养员>, 'appointment_time': '2024-06-09 18:41', 174 # 'address': <UserAddress: hearttest>, 'pet': <Pet: 哈基米>, 'remarks': '321', 'actual_payment': 0} 175 feeder_obj = validated_data.get("feeder") 176 if feeder_obj: 177 order = Order.objects.create(**validated_data) 178 return order 179 else: 180 order = Order.objects.create(**validated_data) 181 order.order_status = 1 182 order.save() 183 return order 184 185 186 class OrderReviewSerializer(serializers.Serializer): 187 review = serializers.CharField() 188 189 190 class UserOrderSerializer(serializers.ModelSerializer): 191 order_id = serializers.CharField(read_only=True) 192 order_time = serializers.CharField(read_only=True) # 2024-06-03 10:12:42 193 payment_method = serializers.CharField(source="get_payment_method_display") 194 order_status = serializers.CharField(source="get_order_status_display") 195 196 class Meta: 197 model = Order 198 fields = [ 199 "order_id", # 订单号码 随机生成 200 "order_time", # 下单时间 201 "complete_time", # 完成时间 202 "customer", # 下单人（外键） 203 "feeder", # 预约对象（外键） 204 "appointment_time", # 预约上门时间 205 "address", # 预约上门地址（外键） 206 "pet", # 预约宠物（外键） 207 "remarks", # 备注 208 "actual_payment", # 实付款 209 "payment_method", # 支付方式 210 "review", # 订单评价 211 "order_status", # 订单状态 212 ] 213 depth = 1 214 215 ------------------------------------------------------------------------------ 216 tasks.py 217 218 from celery import shared_task 219 import time 220 from .models import Order, PetFeeder 221 import redis 222 223 redis_client = redis.StrictRedis(host="127.0.0.1", port=6379, db=0) 224 225 226 @shared_task 227 def qiangdan(order_id, feeder_id, feeder_price): 228 # Redis 分布式锁 229 lock_key = f"lock:order:{order_id}" # 生成一个唯一的锁键（key）。 使用订单 ID 作为锁的标识符，这样每个订单都有一个唯一的锁，可以防止同一个订单被多次处理。 230 lock_timeout = 5 # 锁的超时时间，单位是秒 231 lock = redis_client.lock( 232 lock_key, timeout=lock_timeout 233 ) # 创建一个 Redis 锁对象。 初始化锁对象，以便后续操作（获取和释放锁）。 234 235 if lock.acquire( 236 blocking=False 237 ): # 尝试获取锁 blocking=False 表示非阻塞方式获取锁。如果锁当前被其他任务持有，立即返回 False，否则返回 True 并成功获取锁。 238 # 确保任务能在锁可用时立即开始处理订单。如果锁不可用，则不会等待，而是立即返回 False，表示获取锁失败。 239 try: 240 print(f"获取锁成功，开始处理订单") 241 print(f"查询订单是否还存在,耗时2s") 242 time.sleep(2) 243 244 try: 245 order_obj = Order.objects.get( 246 order_id=order_id, order_status=1, feeder__isnull=True 247 ) 248 # 如果订单存在，直接进行处理 249 print("订单存在，开始处理") 250 time.sleep(1) # 模拟处理时间 251 print("下单，耗时2s") 252 feeder_obj = PetFeeder.objects.filter(id=feeder_id).first() 253 order_obj.feeder = feeder_obj 254 order_obj.order_status = 0 255 order_obj.actual_payment = feeder_price 256 order_obj.save() 257 time.sleep(2) 258 return True 259 except ( 260 Order.DoesNotExist 261 ): # 如果数据库中没有满足这些条件的订单对象，就会抛出 Order.DoesNotExist 异常。 262 print("订单不存在或已被抢") 263 return False 264 finally: 265 if lock.locked(): 266 try: 267 lock.release() 268 print("释放锁") 269 except ( 270 redis.exceptions.LockNotOwnedError # type: ignore 271 ): # Redis-Py 库中的一个异常类。当尝试释放一个不再由你持有的锁时，会抛出这个异常。 272 print("锁已经被自动释放或不再拥有，无法释放") 273 else: 274 print("抢单失败") 275 return False 276 277 ------------------------------------------------------------------------------------ 278 urls.py 279 280 from django.contrib import admin 281 from django.urls import path, include 282 from rest_framework.routers import SimpleRouter 283 from .views import OrderView, OrderReviewView, UserOrderView, QiangdanView 284 285 286 router = SimpleRouter() 287 router.register("order", OrderView, "order") 288 router.register("review", OrderReviewView, "review") 289 router.register("userorder", UserOrderView, "userorder") 290 router.register("qiangdan", QiangdanView, "qiangdan") 291 292 293 urlpatterns = [path("", include(router.urls))] 294 295 ---------------------------------------------------------------------------------- 296 views.py 297 298 from django.db.models import Q 299 from django.shortcuts import render 300 from rest_framework.generics import CreateAPIView 301 from .models import Order 302 from utils.common_logger import logger 303 from utils.common_response import APIResponse 304 from rest_framework.viewsets import GenericViewSet, ViewSet 305 from .serializer import OrderSerializer, OrderReviewSerializer, UserOrderSerializer 306 from rest_framework_simplejwt.authentication import JWTAuthentication 307 from rest_framework.permissions import IsAuthenticated 308 from user.models import User 309 from utils.common_mixin import APIListModelMixin 310 from .pagination import CommonPagination 311 from rest_framework.decorators import action 312 from .tasks import qiangdan 313 from celery.result import AsyncResult 314 from user.models import PetFeeder, UserBalance 315 316 317 class OrderView(GenericViewSet): 318 queryset = Order.objects.all() 319 serializer_class = OrderSerializer 320 authentication_classes = [JWTAuthentication] 321 permission_classes = [IsAuthenticated] 322 323 def create(self, request, *args, **kwargs): 324 print( 325 request.data 326 ) # {'customer': 'heart', 'appointment_time': '2024-06-09 18:41', 327 # 'address': 2, 'pet': '2', 'remarks': '123', 'actual_payment': 0} 328 user = User.objects.filter(pk=request.user.id).first() 329 request.data["customer"] = user.id 330 serializer = self.get_serializer(data=request.data) 331 serializer.is_valid(raise_exception=True) 332 serializer.save() 333 return APIResponse(msg="下单成功!") 334 335 # 付款 336 @action(methods=["POST"], detail=False) 337 def pay(self, request, *args, **kwargs): 338 order_id = request.data.get("order_id") 339 actual_payment = int(request.data.get("actual_payment")) 340 user_balance_obj = UserBalance.objects.filter(user=request.user).first() 341 order_obj = Order.objects.filter(order_id=order_id).first() 342 if int(user_balance_obj.balance) < actual_payment: 343 return APIResponse(code=401, msg="余额不足!请先充值!") 344 else: 345 shifukuan = int(user_balance_obj.balance) - int(actual_payment) 346 user_balance_obj.balance = shifukuan 347 user_balance_obj.save() 348 order_obj.order_status = 1 349 order_obj.payment_method = 0 350 order_obj.save() 351 return APIResponse(msg=f"支付成功!剩余金额{shifukuan}元!") 352 353 354 class OrderReviewView(GenericViewSet, APIListModelMixin): 355 queryset = Order.objects.exclude(review__isnull=True) 356 serializer_class = OrderReviewSerializer 357 358 359 class UserOrderView(GenericViewSet): 360 queryset = Order.objects.all() 361 serializer_class = UserOrderSerializer 362 pagination_class = CommonPagination 363 authentication_classes = [JWTAuthentication] 364 permission_classes = [IsAuthenticated] 365 366 def _get_user(self, request): 367 return request.user.id 368 369 def _check_data(self, qs): 370 if qs: 371 serializer = self.get_serializer(instance=qs, many=True) 372 return APIResponse(msg="查询成功!", results=serializer.data) 373 else: 374 return APIResponse(code=400, msg="没有订单哦!") 375 376 def list(self, request, *args, **kwargs): 377 user = self._get_user(request) # type: ignore 378 qs = self.paginate_queryset( 379 Order.objects.filter(customer=user).order_by("-order_time").all() 380 ) 381 return self._check_data(qs) # type: ignore 382 383 @action(methods=["GET"], detail=False) 384 def daifukuanall(self, request, *args, **kwargs): 385 qs = self.paginate_queryset( 386 Order.objects.filter(order_status=0).order_by("-order_time").all() 387 ) 388 if qs: 389 serializer = self.get_serializer(instance=qs, many=True) 390 return APIResponse(msg="查询成功!", results=serializer.data) 391 else: 392 return APIResponse(code=400, msg="没有订单哦!") 393 394 @action(methods=["GET"], detail=False) 395 def daijiedanall(self, request, *args, **kwargs): 396 qs = self.paginate_queryset( 397 Order.objects.filter( 398 Q(order_status=0) | Q(order_status=1), feeder=request.user.feeder 399 ) 400 .order_by("-order_time") 401 .all() 402 ) 403 if qs: 404 serializer = self.get_serializer(instance=qs, many=True) 405 return APIResponse(msg="查询成功!", results=serializer.data) 406 else: 407 return APIResponse(code=400, msg="没有订单哦!") 408 409 @action(methods=["GET"], detail=False) 410 def daishangmenall(self, request, *args, **kwargs): 411 qs = self.paginate_queryset( 412 Order.objects.filter(order_status=2, feeder=request.user.feeder) 413 .order_by("-order_time") 414 .all() 415 ) 416 if qs: 417 serializer = self.get_serializer(instance=qs, many=True) 418 return APIResponse(msg="查询成功!", results=serializer.data) 419 else: 420 return APIResponse(code=400, msg="没有订单哦!") 421 422 @action(methods=["GET"], detail=False) 423 def jinxingzhongall(self, request, *args, **kwargs): 424 qs = self.paginate_queryset( 425 Order.objects.filter(order_status=3, feeder=request.user.feeder) 426 .order_by("-order_time") 427 .all() 428 ) 429 if qs: 430 serializer = self.get_serializer(instance=qs, many=True) 431 return APIResponse(msg="查询成功!", results=serializer.data) 432 else: 433 return APIResponse(code=400, msg="没有订单哦!") 434 435 @action(methods=["GET"], detail=False) 436 def yiwanchengall(self, request, *args, **kwargs): 437 qs = self.paginate_queryset( 438 Order.objects.filter(order_status=4, feeder=request.user.feeder) 439 .order_by("-order_time") 440 .all() 441 ) 442 if qs: 443 serializer = self.get_serializer(instance=qs, many=True) 444 return APIResponse(msg="查询成功!", results=serializer.data) 445 else: 446 return APIResponse(code=400, msg="没有订单哦!") 447 448 # feeder__isnull=True 449 @action(methods=["GET"], detail=False) 450 def daiqiangdanall(self, request, *args, **kwargs): 451 qs = self.paginate_queryset( 452 Order.objects.filter(order_status=1, feeder__isnull=True) 453 .order_by("-order_time") 454 .all() 455 ) 456 if qs: 457 serializer = self.get_serializer(instance=qs, many=True) 458 return APIResponse(msg="查询成功!", results=serializer.data) 459 else: 460 return APIResponse(code=400, msg="没有订单哦!") 461 462 @action(methods=["GET"], detail=False) 463 def daifukuan(self, request, *args, **kwargs): 464 user = self._get_user(request) # type: ignore 465 qs = self.paginate_queryset( 466 Order.objects.filter(customer=user, order_status=0) 467 .order_by("-order_time") 468 .all() 469 ) 470 return self._check_data(qs) # type: ignore 471 472 @action(methods=["GET"], detail=False) 473 def daijiedan(self, request, *args, **kwargs): 474 user = self._get_user(request) # type: ignore 475 qs = self.paginate_queryset( 476 Order.objects.filter(customer=user, order_status=1) 477 .order_by("-order_time") 478 .all() 479 ) 480 481 return self._check_data(qs) # type: ignore 482 483 @action(methods=["GET"], detail=False) 484 def daishangmen(self, request, *args, **kwargs): 485 user = self._get_user(request) # type: ignore 486 qs = self.paginate_queryset( 487 Order.objects.filter(customer=user, order_status=2) 488 .order_by("-order_time") 489 .all() 490 ) 491 return self._check_data(qs) # type: ignore 492 493 @action(methods=["GET"], detail=False) 494 def jinxingzhong(self, request, *args, **kwargs): 495 user = self._get_user(request) # type: ignore 496 qs = self.paginate_queryset( 497 Order.objects.filter(customer=user, order_status=3) 498 .order_by("-order_time") 499 .all() 500 ) 501 return self._check_data(qs) # type: ignore 502 503 @action(methods=["GET"], detail=False) 504 def yiwancheng(self, request, *args, **kwargs): 505 user = self._get_user(request) # type: ignore 506 qs = self.paginate_queryset( 507 Order.objects.filter(customer=user, order_status=4) 508 .order_by("-order_time") 509 .all() 510 ) 511 return self._check_data(qs) # type: ignore 512 513 514 class QiangdanView(ViewSet): 515 authentication_classes = [JWTAuthentication] 516 permission_classes = [IsAuthenticated] 517 518 @action(methods=["POST"], detail=False) 519 def paidui(self, request, *args, **kwargs): 520 order_id = request.data.get("order_id") 521 feeder_price = request.data.get("feeder_price") 522 feeder_id = request.user.feeder.id 523 task_id = qiangdan.delay(str(order_id), feeder_id, feeder_price) 524 return APIResponse(msg="您正在排队", task_id=str(task_id)) 525 526 @action(methods=["GET"], detail=False) 527 def get_result(self, request, *args, **kwargs): 528 task_id = request.GET.get("task_id") 529 a = AsyncResult( 530 id=task_id 531 ) # 使用 Celery 的 AsyncResult 类，根据任务 ID 获取任务结果对象 a。 532 if a.successful(): # 检查任务是否成功完成。 533 result = a.get() # 获取任务的返回结果（True 或 False）。 534 if result: # 如果任务成功（返回 True），返回抢单成功的响应。 535 return APIResponse(success="1", msg="抢单成功!") 536 else: # 如果任务失败（返回 False），返回抢单失败的响应，并告知订单已被抢。 537 return APIResponse(success="0", msg="抢单失败!") 538 elif ( 539 a.status == "PENDING" 540 ): # 如果任务状态为 PENDING，表示任务在等待执行，返回相应的响应。 541 return APIResponse(success="2", msg="任务等待中被执行!") 542 else: 543 return APIResponse(success="3", msg="抢单任务正在执行!")
pet表
1 admin.py 2 3 from django.contrib import admin 4 from .models import * 5 6 7 # Register your models here. 8 @admin.register(Pet) 9 class PetAdmin(admin.ModelAdmin): 10 list_display = ( 11 "name", 12 "icon", 13 "pet_type", 14 "variety", 15 "gender", 16 "birthday", 17 "weight", 18 "character", 19 ) 20 21 --------------------------------------------------------------------------------------- 22 models.py 23 24 from django.db import models 25 from user.models import User 26 27 28 # Create your models here. 29 # 宠物表，一个用户可以有多只宠物，一只宠物只能属于一个用户 30 class Pet(models.Model): 31 GENDER_CHOICES = [ 32 (0, "妹妹"), 33 (1, "弟弟"), 34 ] 35 PETFEEDER_CHOICES = [(0, "猫猫"), (1, "狗狗")] 36 name = models.CharField(max_length=32, verbose_name="名字") # 名字 37 icon = models.ImageField( 38 upload_to="pet_icon", default="pet_icon/default.png", verbose_name="头像" 39 ) # 头像 40 pet_type = models.IntegerField( 41 choices=PETFEEDER_CHOICES, verbose_name="宠物类别" 42 ) # 宠物类别 43 variety = models.CharField(max_length=32, verbose_name="宠物品种") # 宠物品种 44 gender = models.IntegerField(choices=GENDER_CHOICES, verbose_name="性别") # 性别 45 birthday = models.CharField(max_length=32, verbose_name="出生日期") # 出生日期 46 weight = models.IntegerField(verbose_name="体重") # 体重 47 character = models.CharField(max_length=255, verbose_name="性格") # 性格描述 48 user = models.ForeignKey( 49 User, on_delete=models.CASCADE, verbose_name="用户" 50 ) # 对应用户 51 52 class Meta: 53 db_table = "puddingpet_pet" 54 verbose_name = "宠物表" 55 verbose_name_plural = verbose_name 56 57 def __str__(self): 58 return self.name 59 60 61 ----------------------------------------------------------------------------------- 62 serializers 63 64 from rest_framework import serializers 65 from .models import Pet 66 from user.models import User 67 68 69 class PetSerializer(serializers.ModelSerializer): 70 pet_type = serializers.CharField(source="get_pet_type_display", read_only=True) 71 gender = serializers.CharField(source="get_gender_display", read_only=True) 72 user = serializers.CharField(source="user.username", read_only=True) 73 id = serializers.CharField(read_only=True) 74 75 class Meta: 76 model = Pet 77 fields = [ 78 "id", 79 "name", 80 "icon", 81 "pet_type", 82 "variety", 83 "gender", 84 "birthday", 85 "weight", 86 "character", 87 "user", 88 ] 89 90 91 class BindPetSerializer(serializers.ModelSerializer): 92 user = serializers.CharField() 93 94 class Meta: 95 model = Pet 96 fields = [ 97 "name", 98 "icon", 99 "pet_type", 100 "variety", 101 "gender", 102 "birthday", 103 "weight", 104 "character", 105 "user", 106 ] 107 108 def create(self, validated_data): 109 user = validated_data.pop("user") 110 user_obj = User.objects.filter(pk=int(user)).first() 111 pet_obj = Pet.objects.create(**validated_data, user=user_obj) 112 return pet_obj 113 114 ------------------------------------------------------------------------------------ 115 url.py 116 117 from django.contrib import admin 118 from django.urls import path, include 119 from rest_framework.routers import SimpleRouter 120 from .views import PetView, BindPetView, PetAvatarView 121 122 router = SimpleRouter() 123 router.register("petinfo", PetView, "petinfo") 124 router.register("bindpet", BindPetView, "bindpet") 125 router.register("petavatar", PetAvatarView, "petavatar") 126 127 urlpatterns = [path("", include(router.urls))] 128 129 ----------------------------------------------------------------------------------- 130 view.py 131 132 from django.shortcuts import render 133 from rest_framework.viewsets import GenericViewSet 134 from .models import Pet 135 from .serializer import PetSerializer, BindPetSerializer 136 from utils.common_response import APIResponse 137 from rest_framework_simplejwt.authentication import JWTAuthentication 138 from rest_framework.permissions import IsAuthenticated 139 from django.core.files.storage import default_storage 140 from django.core.files.base import ContentFile 141 from rest_framework.exceptions import APIException 142 from rest_framework.decorators import action 143 144 145 class PetView(GenericViewSet): 146 queryset = Pet.objects.all() 147 serializer_class = PetSerializer 148 authentication_classes = [JWTAuthentication] 149 permission_classes = [IsAuthenticated] 150 151 @action(methods=["GET"], detail=False) 152 def all_pet(self, request, *args, **kwargs): 153 queryset = self.get_queryset() 154 serializer = self.get_serializer(queryset, many=True) 155 return APIResponse(data=serializer.data) 156 157 @action(methods=["GET"], detail=False) 158 def user_pet(self, request, *args, **kwargs): 159 user = request.user.id 160 queryset = Pet.objects.filter(user=user) 161 serializer = self.get_serializer(queryset, many=True) 162 return APIResponse(results=serializer.data) 163 164 165 class BindPetView(GenericViewSet): 166 queryset = Pet.objects.all() 167 serializer_class = BindPetSerializer 168 authentication_classes = [JWTAuthentication] 169 permission_classes = [IsAuthenticated] 170 171 # 添加宠物 172 def create(self, request, *args, **kwargs): 173 user = self.request.user.id 174 request.data["user"] = user 175 icon = request.headers.get("Icon").replace("/media/", "") 176 print(request.headers.get("Icon")) 177 print(icon) 178 serializer = self.get_serializer(data=request.data) 179 serializer.is_valid(raise_exception=True) 180 pet_obj = serializer.save() 181 pet_obj.icon = icon 182 pet_obj.save() 183 return APIResponse(msg="添加成功!") 184 185 186 class PetAvatarView(GenericViewSet): 187 def create(self, request, *args, **kwargs): 188 avatar = request.FILES.get("avatar") 189 if avatar: 190 file_name = default_storage.save( 191 f"pet_icon/" + str(avatar)[-15:], ContentFile(avatar.read()) 192 ) 193 # print(file_name) # pet_icon/716f48749ef.jpg 194 file_url = default_storage.url(file_name) # /media/pet_icon/716f48749ef.jpg 195 path = "http://192.168.1.38:8000" + file_url 196 print(path) 197 else: 198 raise APIException("服务器异常!") 199 return APIResponse(msg="上传头像成功!", file_url=path, file_name=file_name)
user表
1 admin.py 2 3 from django.contrib import admin 4 5 # Register your models here. 6 from .models import * 7 8 9 @admin.register(User) 10 class UserAdmin(admin.ModelAdmin): 11 list_display = ("id", "username", "mobile", "gender", "age", "is_pet_feeder") 12 13 14 @admin.register(UserAddress) 15 class UserAddressAdmin(admin.ModelAdmin): 16 list_display = ( 17 "name", 18 "mobile", 19 "province", 20 "city", 21 "detail", 22 "is_default", 23 ) 24 25 26 @admin.register(PetFeeder) 27 class PetFeederAdmin(admin.ModelAdmin): 28 list_display = ( 29 "name", 30 "icon", 31 "gender", 32 "desc", 33 "service_duration", 34 "price", 35 ) 36 37 ---------------------------------------------------------------------------------- 38 apps.py 39 40 from django.apps import AppConfig 41 42 43 class UserConfig(AppConfig): 44 default_auto_field = "django.db.models.BigAutoField" 45 name = "user" 46 verbose_name = "用户" 47 48 ----------------------------------------------------------------------------------- 49 models.py 50 51 from django.db import models 52 from django.contrib.auth.models import AbstractUser 53 54 55 # 用户表 56 class User(AbstractUser): 57 GENDER_CHOICES = [ 58 (0, "女"), 59 (1, "男"), 60 ] 61 PETFEEDER_CHOICES = [(0, "是"), (1, "否")] 62 mobile = models.CharField( 63 max_length=11, unique=True, verbose_name="手机号" 64 ) # 手机号 65 icon = models.ImageField( 66 upload_to="icon", default="icon/default.png", verbose_name="头像" 67 ) # 头像 68 gender = models.IntegerField( 69 choices=GENDER_CHOICES, null=True, verbose_name="性别", blank=True 70 ) # 性别 71 age = models.CharField(max_length=32, null=True, verbose_name="年龄") # 年龄 72 is_pet_feeder = models.IntegerField( 73 choices=PETFEEDER_CHOICES, default=0, verbose_name="是否喂养员" 74 ) # 是否是喂养员 75 feeder = models.OneToOneField( 76 to="PetFeeder", 77 on_delete=models.CASCADE, 78 null=True, 79 blank=True, 80 verbose_name="喂养员id", 81 ) # type: ignore 82 83 class Meta: 84 db_table = "puddingpet_user" 85 verbose_name = "用户表" 86 verbose_name_plural = verbose_name 87 88 def __str__(self): 89 return self.username 90 91 92 # 用户地址表，一个用户可以有多个地址，一个地址只能属于一个用户 93 class UserAddress(models.Model): 94 name = models.CharField(max_length=32, verbose_name="名字") # 名字 95 mobile = models.CharField(max_length=11, verbose_name="手机号") # 手机号 96 province = models.CharField(max_length=32, verbose_name="省") # 省 97 city = models.CharField(max_length=32, verbose_name="市") # 市 98 detail = models.CharField(max_length=128, verbose_name="详细地址") # 详细地址 99 is_default = models.BooleanField(default=False, verbose_name="是否默认") # 是否默认 100 user = models.ForeignKey( 101 User, on_delete=models.CASCADE, verbose_name="对应用户" 102 ) # 对应用户 103 104 class Meta: 105 db_table = "puddingpet_address" 106 verbose_name = "用户地址表" 107 verbose_name_plural = verbose_name 108 109 def __str__(self): 110 return self.name 111 112 113 # 喂养员表 114 class PetFeeder(models.Model): 115 GENDER_CHOICES = [ 116 (0, "女"), 117 (1, "男"), 118 ] 119 FEED_TYPE_CHOICES = [(0, "猫"), (1, "狗")] 120 name = models.CharField(max_length=32, verbose_name="名字") # 名字 121 icon = models.ImageField( 122 upload_to="feeder_icon", default="feeder_icon/default.png", verbose_name="头像" 123 ) # 头像 124 gender = models.IntegerField( 125 choices=GENDER_CHOICES, null=True, verbose_name="性别" 126 ) # 性别 127 desc = models.TextField(blank=True, null=True, verbose_name="简介") # 简介 128 service_duration = models.CharField( 129 max_length=255, verbose_name="服务时长" 130 ) # 服务时长 131 price = models.IntegerField(verbose_name="价格") # 价格 132 feed_type = models.IntegerField( 133 choices=FEED_TYPE_CHOICES, null=True, verbose_name="喂养类型" 134 ) # 喂养类型(猫，狗) 135 136 class Meta: 137 db_table = "puddingpet_feeder" 138 verbose_name = "喂养员表" 139 verbose_name_plural = verbose_name 140 141 def __str__(self): 142 return self.name 143 144 145 # 消息表 146 class Message(models.Model): 147 sender = models.ForeignKey( 148 User, 149 related_name="sent_messages", 150 on_delete=models.CASCADE, 151 verbose_name="发送者", 152 ) # 发送者 153 receiver = models.ForeignKey( 154 User, 155 related_name="received_messages", 156 on_delete=models.CASCADE, 157 verbose_name="接收者", 158 ) # 接收者 159 content = models.TextField(verbose_name="内容") # 内容 160 send_time = models.DateTimeField( 161 auto_now_add=True, verbose_name="发送时间" 162 ) # 发送时间 163 164 class Meta: 165 db_table = "puddingpet_message" 166 verbose_name = "消息表" 167 verbose_name_plural = verbose_name 168 169 def __str__(self): 170 return str(self.sender) 171 172 173 # 用户反馈表 174 class Feedback(models.Model): 175 image = models.ImageField( 176 upload_to="feedback", verbose_name="反馈图片", null=True, blank=True 177 ) 178 content = models.TextField(verbose_name="反馈内容") 179 180 class Meta: 181 db_table = "puddingpet_feedback" 182 verbose_name = "反馈表" 183 verbose_name_plural = verbose_name 184 185 186 class UserBalance(models.Model): 187 user = models.ForeignKey( 188 User, 189 related_name="user_balance", 190 on_delete=models.CASCADE, 191 verbose_name="用户", 192 ) 193 balance = models.IntegerField(verbose_name="用户余额") 194 195 class Meta: 196 db_table = "puddingpet_user_balance" 197 verbose_name = "用户余额表" 198 verbose_name_plural = verbose_name 199 200 201 class FeederRemuneration(models.Model): 202 feeder = models.ForeignKey( 203 PetFeeder, 204 related_name="feeder_remuneration", 205 on_delete=models.CASCADE, 206 verbose_name="喂养员", 207 ) 208 remuneration = models.DecimalField( 209 verbose_name="喂养员酬金", 210 max_digits=10, # Total number of digits (adjust as needed) 211 decimal_places=2, # Number of decimal places (adjust as needed) 212 ) 213 214 class Meta: 215 db_table = "puddingpet_feeder_remuneration" 216 verbose_name = "喂养员酬金表" 217 verbose_name_plural = verbose_name 218 219 -------------------------------------------------------------------------------- 220 serializers.py 221 222 from rest_framework import serializers 223 from django.core.cache import cache 224 from django.conf import settings 225 from rest_framework.exceptions import ValidationError, APIException 226 from rest_framework_simplejwt.tokens import RefreshToken 227 import re 228 from .models import ( 229 User, 230 Message, 231 PetFeeder, 232 UserAddress, 233 Feedback, 234 UserBalance, 235 FeederRemuneration, 236 ) 237 238 239 class CommonLoginSerializer: 240 def _get_user(self, attrs): 241 raise Exception("这个方法必须被重写") 242 243 def _get_token(self, user): 244 refresh = RefreshToken.for_user(user) 245 return str(refresh.access_token) 246 247 def _pre_data(self, token, user): 248 self.context["token"] = token 249 self.context["username"] = user 250 # self.instance=user # 当前用户，放到instance中了 251 self.context["icon"] = ( 252 settings.BACKEND_URL + "media/" + str(user.icon) 253 ) # 不带 域名前缀的 254 255 def validate(self, attrs): 256 # 1 取出用户名(手机号，邮箱)和密码 257 user = self._get_user(attrs) 258 # 2 如果存在：签发token，返回 259 token = self._get_token(user) 260 # 3 把token,用户名和icon放入context 261 self._pre_data(token, user) 262 return attrs 263 264 265 class LoginSerializer(CommonLoginSerializer, serializers.ModelSerializer): 266 username = serializers.CharField() 267 268 class Meta: 269 model = User 270 fields = ["username", "password", "icon"] 271 extra_kwargs = {"password": {"write_only": True}} # 它不做序列化 272 # depth = 1 273 274 def _get_user(self, attrs): 275 username = attrs.get("username") 276 password = attrs.get("password") 277 if re.match(r"^1[3-9][0-9]{9}$", username): 278 user = User.objects.filter(mobile=username).first() 279 elif re.match("^[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+$", username): # type: ignore 280 user = User.objects.filter(email=username).first() 281 else: 282 user = User.objects.filter(username=username).first() 283 284 if user and user.check_password(password): 285 return user 286 else: 287 raise ValidationError("用户名或密码错误") 288 289 290 class SMSLoginSerializer(CommonLoginSerializer, serializers.Serializer): 291 code = serializers.CharField() 292 mobile = serializers.CharField() 293 294 def _get_user(self, attrs): 295 mobile = attrs.get("mobile") 296 code = attrs.get("code") 297 old_code = cache.get(f"cache_code_{mobile}") 298 assert old_code == code or (settings.DEBUG and code == "8888"), ValidationError( 299 "验证码错误" 300 ) 301 user = User.objects.filter(mobile=mobile).first() 302 assert user, ValidationError("该手机号未注册!") 303 return user 304 305 306 class RegisterSerializer(serializers.ModelSerializer): 307 code = serializers.CharField() 308 309 class Meta: 310 model = User 311 fields = ["mobile", "password", "code"] 312 313 def validate(self, attrs): 314 code = attrs.pop("code") 315 mobile = attrs.get("mobile") 316 old_code = cache.get(f"cache_code_{mobile}") 317 assert old_code == code or (settings.DEBUG and code == "8888"), ValidationError( 318 "验证码错误" 319 ) 320 attrs["username"] = mobile 321 return attrs 322 323 def create(self, validated_data): 324 user = User.objects.create_user(**validated_data) # type: ignore 325 UserBalance.objects.create(balance=0, user=user) 326 return user 327 328 329 class CheckMessageSerializer(serializers.Serializer): 330 content = serializers.CharField(read_only=True) 331 send_time = serializers.CharField(read_only=True) 332 sender = serializers.CharField() 333 receiver = serializers.CharField() 334 335 336 class PetFeederSerializer(serializers.ModelSerializer): 337 gender = serializers.CharField(source="get_gender_display") 338 feed_type = serializers.CharField(source="get_feed_type_display") 339 icon = serializers.SerializerMethodField() 340 341 class Meta: 342 model = PetFeeder 343 fields = [ 344 "id", 345 "name", 346 "icon", 347 "gender", 348 "desc", 349 "service_duration", 350 "price", 351 "feed_type", 352 ] 353 354 def get_icon(self, obj): 355 return settings.ICON_URL + obj.icon.url 356 357 358 class UserSerializer(serializers.ModelSerializer): 359 feeder = PetFeederSerializer(read_only=True) 360 gender = serializers.CharField(source="get_gender_display") 361 362 class Meta: 363 model = User 364 fields = ["id", "username", "mobile", "icon", "gender", "age", "feeder"] 365 366 367 class MessageSerializer(serializers.Serializer): 368 content = serializers.CharField() 369 send_time = serializers.SerializerMethodField(read_only=True) 370 sender = serializers.CharField() 371 receiver = serializers.CharField() 372 373 def create(self, validated_data): 374 # {'content': '123', 'sender': 'heart', 'receiver': '1'} 375 sender_name = validated_data.get("sender") 376 receiver_id = validated_data.get("receiver") 377 content = validated_data.get("content") 378 sender_obj = User.objects.filter(username=sender_name).first() 379 feeder_obj = User.objects.filter(feeder=receiver_id).first() 380 msg = Message.objects.create( 381 content=content, sender=sender_obj, receiver=feeder_obj 382 ) 383 return msg 384 385 def get_send_time(self, obj): 386 return obj.send_time.strftime("%Y-%m-%d %H:%M:%S") 387 388 389 # 地址序列化类 390 class AddressSerializer(serializers.ModelSerializer): 391 class Meta: 392 model = UserAddress 393 fields = ["id", "name", "mobile", "province", "city", "detail", "is_default"] 394 395 def create(self, validated_data): 396 user_id = self.context 397 user_obj = User.objects.filter(pk=user_id).first() 398 address = UserAddress.objects.create(**validated_data, user=user_obj) 399 return address 400 401 def update(self, instance, validated_data): 402 user = self.context 403 useraddr_obj = UserAddress.objects.filter(pk=instance.id).first() 404 for attr, value in validated_data.items(): 405 setattr(useraddr_obj, attr, value) 406 useraddr_obj.user = user 407 useraddr_obj.save() 408 return useraddr_obj 409 410 411 class UserEditNameSerializer(serializers.Serializer): 412 username = serializers.CharField() 413 gender = serializers.CharField() 414 mobile = serializers.CharField() 415 416 def update(self, instance, validated_data): 417 new_username = validated_data.get("username") 418 new_gender = validated_data.get("gender") 419 mobile = validated_data.get("mobile") 420 if new_gender == "男": 421 gender = 1 422 elif new_gender == "女": 423 gender = 0 424 user = User.objects.filter(mobile=mobile).update( 425 username=new_username, gender=gender, mobile=mobile 426 ) 427 return user 428 429 430 class UserMsgListSerializer(serializers.Serializer): 431 id = serializers.CharField(read_only=True) 432 content = serializers.CharField(read_only=True) 433 send_time = serializers.SerializerMethodField(read_only=True) 434 sender = UserSerializer(read_only=True) 435 receiver = UserSerializer(read_only=True) 436 437 def get_send_time(self, obj): 438 return obj.send_time.strftime("%Y-%m-%d %H:%M:%S") 439 440 441 class RegFeederSerializer(serializers.Serializer): 442 name = serializers.CharField() 443 gender = serializers.CharField() 444 desc = serializers.CharField() 445 service_duration = serializers.CharField() 446 price = serializers.CharField() 447 feed_type = serializers.CharField() 448 449 def create(self, validated_data): 450 user = self.context 451 petfeeder = PetFeeder.objects.create(**validated_data) 452 user_obj = User.objects.filter(pk=user).first() 453 user_obj.is_pet_feeder = 1 454 user_obj.feeder_id = petfeeder 455 user_obj.save() 456 FeederRemuneration.objects.create(remuneration=0, feeder=petfeeder) 457 return petfeeder 458 459 460 class FeedbackSerializer(serializers.ModelSerializer): 461 class Meta: 462 model = Feedback 463 fields = "__all__" 464 465 def create(self, validated_data): 466 feed_obj = Feedback.objects.create(**validated_data, image=self.context) 467 return feed_obj 468 469 470 # 查询余额序列化类 471 class UserBalanceSerializer(serializers.ModelSerializer): 472 amount = serializers.DecimalField( 473 max_digits=10, decimal_places=2, min_value=0.01, required=True 474 ) 475 476 class Meta: 477 model = UserBalance 478 fields = ["id", "amount", "balance"] 479 480 --------------------------------------------------------------------------------- 481 urls.py 482 483 from django.contrib import admin 484 from django.urls import path, include 485 from rest_framework.routers import DefaultRouter 486 from .views import ( 487 UserRegisterView, 488 UserMobileView, 489 UserLoginView, 490 MessageView, 491 PetFeederView, 492 PetFeederFilterView, 493 AddressView, 494 UserAvatarView, 495 UserInfoView, 496 UserAllAddressView, 497 UserMsgListView, 498 RegisterFeederView, 499 FeedbackView, 500 UserBalanceView, 501 ) 502 503 router = DefaultRouter() 504 505 router.register("register", UserRegisterView, "register") 506 router.register("mobile", UserMobileView, "mobile") 507 router.register("mul_login", UserLoginView, "mul_login") 508 router.register("pet_feeder", PetFeederView, "pet_feeder") 509 router.register("pet_feeder_filter", PetFeederFilterView, "pet_feeder_filter") 510 router.register("message", MessageView, "message") 511 router.register("addr", AddressView, "addr") 512 router.register("avatar", UserAvatarView, "avatar") 513 router.register("userinfo", UserInfoView, "userinfo") 514 router.register("all_addr", UserAllAddressView, "all_addr") 515 router.register("usermsglist", UserMsgListView, "usermsglist") 516 router.register("regfeeder", RegisterFeederView, "regfeeder") 517 router.register("feedback", FeedbackView, "feedback") 518 router.register("recharge", UserBalanceView, "recharge") 519 520 urlpatterns = [ 521 path("", include(router.urls)), 522 ] 523 524 ---------------------------------------------------------------------------------- 525 views.py 526 527 from django.shortcuts import get_object_or_404, render 528 from rest_framework.mixins import CreateModelMixin 529 from utils.common_logger import logger 530 from utils.common_response import APIResponse 531 from rest_framework.viewsets import GenericViewSet, ViewSet, ModelViewSet 532 from rest_framework.decorators import action 533 from .models import User, PetFeeder, UserAddress, Feedback, UserBalance 534 from django.core.cache import cache 535 from libs.tencent_sms import get_code, send_sms as sms 536 from threading import Thread 537 from utils.common_mixin import ( 538 APIListModelMixin, 539 APIRetrieveModelMixin, 540 ) 541 from .serializer import ( 542 RegisterSerializer, 543 LoginSerializer, 544 SMSLoginSerializer, 545 MessageSerializer, 546 PetFeederSerializer, 547 UserSerializer, 548 AddressSerializer, 549 UserEditNameSerializer, 550 UserMsgListSerializer, 551 RegFeederSerializer, 552 FeedbackSerializer, 553 UserBalanceSerializer, 554 ) 555 from .models import User, Message 556 from rest_framework_simplejwt.authentication import JWTAuthentication 557 from rest_framework.permissions import IsAuthenticated 558 from rest_framework.decorators import action 559 from rest_framework.exceptions import APIException 560 from django.core.files.storage import default_storage 561 from django.core.files.base import ContentFile 562 from django.contrib import auth 563 from django.db.models import Q 564 import re 565 566 567 # 发送短信接口 568 class UserMobileView(GenericViewSet): 569 @action(methods=["GET"], detail=False) 570 def check_mobile(self, request, *args, **kwargs): 571 mobile = request.query_params.get("mobile") 572 if mobile: 573 if re.match(r"^1[3-9][0-9]{9}$", mobile): 574 user = User.objects.filter(mobile=mobile).first() 575 else: 576 return APIResponse(code=400, msg="手机号不符合!") 577 if user: 578 return APIResponse(code=400, msg="手机号已存在!") 579 return APIResponse(msg="手机号不存在!") 580 return APIResponse(code=400, msg="还未填写手机号!") 581 582 @action(methods=["GET"], detail=False) 583 def send_sms(self, request, *args, **kwargs): 584 mobile = request.query_params.get("mobile") 585 code = get_code() 586 cache.set(f"cache_code_{mobile}", code) 587 t = Thread(target=sms, args=[mobile, code]) 588 t.start() 589 return APIResponse(msg="短信已发送") 590 591 592 # 多方式登录接口 593 class UserLoginView(GenericViewSet): 594 serializer_class = LoginSerializer 595 596 def get_serializer_class(self): 597 if self.action == "sms_login": 598 return SMSLoginSerializer 599 else: 600 return LoginSerializer 601 602 def _login(self, request, *args, **kwargs): 603 serializer = self.get_serializer(data=request.data) 604 serializer.is_valid(raise_exception=True) 605 token = serializer.context.get("token") 606 user = serializer.context.get("username") 607 icon = serializer.context.get("icon") 608 auth.login(request, user) 609 return APIResponse( 610 token=token, username=user.username, icon=icon, msg="登录成功!" 611 ) 612 613 @action(methods=["POST"], detail=False) 614 def multiple_login(self, request, *args, **kwargs): 615 return self._login(request, *args, **kwargs) 616 617 @action(methods=["POST"], detail=False) 618 def sms_login(self, request, *args, **kwargs): 619 return self._login(request, *args, **kwargs) 620 621 622 # 用户注册接口 623 class UserRegisterView(GenericViewSet): 624 serializer_class = RegisterSerializer 625 626 def create(self, request, *args, **kwargs): 627 serializer = self.get_serializer(data=request.data) 628 serializer.is_valid(raise_exception=True) 629 serializer.save() 630 return APIResponse(msg="注册成功!") 631 632 633 # 消息接口 634 class MessageView(GenericViewSet): 635 queryset = Message.objects.all() 636 serializer_class = MessageSerializer 637 authentication_classes = [JWTAuthentication] 638 permission_classes = [IsAuthenticated] 639 640 def list(self, request, *args, **kwargs): 641 send_name = request.query_params.get("send_name") 642 recv_id = request.query_params.get("recv_id") 643 send_obj = User.objects.filter(username=send_name).first() 644 feeder_obj = User.objects.filter(feeder=recv_id).first() 645 if send_obj and feeder_obj: 646 qs = Message.objects.filter( 647 Q(sender=send_obj, receiver=feeder_obj) 648 | Q(sender=feeder_obj, receiver=send_obj) 649 ).order_by("send_time") 650 serializer = self.get_serializer(instance=qs, many=True) 651 return APIResponse(results=serializer.data) 652 653 def create(self, request, *args, **kwargs): 654 serializer = self.get_serializer(data=request.data) 655 serializer.is_valid(raise_exception=True) 656 serializer.save() 657 return APIResponse(results=serializer.data) 658 659 660 # 查询所有喂养员 661 class PetFeederView(GenericViewSet, APIListModelMixin, APIRetrieveModelMixin): 662 queryset = PetFeeder.objects.all() 663 serializer_class = UserSerializer 664 665 def get_serializer_class(self): 666 if self.action == "list": 667 return UserSerializer 668 elif self.action == "retrieve": 669 return PetFeederSerializer 670 else: 671 return PetFeederSerializer 672 673 def get_object(self): 674 obj_id = self.kwargs.get("pk") 675 user = get_object_or_404(User, feeder=obj_id) 676 feeder_data = user.feeder 677 return feeder_data 678 679 def get_queryset(self): 680 return User.objects.filter(is_pet_feeder=1) 681 682 683 class PetFeederFilterView(ViewSet): 684 def list(self, request, *args, **kwargs): 685 radio = int(request.GET.get("radio")) 686 if radio == 2: 687 queryset = PetFeeder.objects.all() 688 else: 689 queryset = PetFeeder.objects.filter(feed_type=int(radio)) 690 serializer = PetFeederSerializer(queryset, many=True) 691 return APIResponse(results=serializer.data) 692 693 694 # 添加地址接口 695 from rest_framework.decorators import action 696 from rest_framework import status 697 698 699 class AddressView(GenericViewSet): 700 serializer_class = AddressSerializer 701 authentication_classes = [JWTAuthentication] 702 permission_classes = [IsAuthenticated] 703 704 def create(self, request, *args, **kwargs): 705 user = self.request.user.id 706 serializer = self.get_serializer(data=request.data, context=user) 707 serializer.is_valid(raise_exception=True) 708 serializer.save() 709 return APIResponse(msg="添加地址成功!") 710 711 712 # 查询当前登录用户所有地址 all_addr 713 class UserAllAddressView(GenericViewSet): 714 authentication_classes = [JWTAuthentication] 715 permission_classes = [IsAuthenticated] 716 serializer_class = AddressSerializer 717 queryset = UserAddress.objects.all() 718 719 def get_queryset(self): 720 # 获取当前登录的用户,只返回自己的地址 721 user = self.request.user 722 queryset = UserAddress.objects.filter(user=user) 723 return queryset 724 725 def list(self, request, *args, **kwargs): 726 queryset = self.filter_queryset(self.get_queryset()) 727 # 如果查询集为空，则返回一个带有自定义消息的响应 728 if not queryset.exists(): 729 return APIResponse(detail="该用户没有地址") 730 # 序列化查询集并返回响应 731 else: 732 serializer = self.get_serializer(queryset, many=True) 733 return APIResponse(msg="获取地址列表成功!", results=serializer.data) 734 735 # 修改地址 736 def update(self, request, *args, **kwargs): 737 qs = self.get_object() 738 serializer = self.get_serializer( 739 instance=qs, data=request.data, context=self.request.user 740 ) 741 serializer = self.get_serializer( 742 instance=qs, data=request.data, context=self.request.user 743 ) 744 serializer.is_valid(raise_exception=True) 745 serializer.save() 746 return APIResponse(msg="修改地址成功!") 747 748 # 删除地址 749 @action(methods=["delete"], detail=True) 750 # def delete_address(self, request, pk=None): 751 def destroy_info(self, request, *args, **kwargs): 752 print("svi") 753 address = self.get_object() 754 if address.user != request.user: 755 return APIResponse(code=400, msg="无权删除他人地址") 756 address.delete() 757 return APIResponse(msg="删除地址成功!") 758 759 760 class UserAvatarView(GenericViewSet): 761 queryset = User.objects.all() 762 763 def create(self, request, *args, **kwargs): 764 avatar = request.FILES.get("avatar") 765 username = request.data.get("user") 766 if avatar: 767 file_name = default_storage.save( 768 f"user/{username}/" + str(avatar)[-15:], ContentFile(avatar.read()) 769 ) 770 # logger.info(file_name) # logger.info(file_name) 771 file_url = default_storage.url(file_name).replace("/media/", "") 772 # print(file_url) # /media/user/heart/517b8dc72d4.jpg 773 # logger.info(file_url) # /user/heart/43aa2b8998c.jpg 774 user = User.objects.filter(username=username).first() 775 user.icon = file_url # type: ignore 776 user.save() # type: ignore 777 path = f"http://192.168.1.38:8000/media/{file_url}" 778 print(path) # http://192.168.1.38:8000/media/user/heart/237f61825e8.jpg 779 else: 780 raise APIException("服务器异常!") 781 return APIResponse(msg="上传头像成功!", path=path) 782 783 784 class UserInfoView(GenericViewSet): 785 queryset = User.objects.all() 786 serializer_class = UserSerializer 787 permission_classes = [IsAuthenticated] 788 authentication_classes = [JWTAuthentication] 789 790 def get_queryset(self): 791 return User.objects.filter(pk=self.request.user.id) # type: ignore 792 793 def get_serializer_class(self): 794 if self.action == "list": 795 return UserSerializer 796 elif self.action == "update": 797 return UserEditNameSerializer 798 else: 799 return UserEditNameSerializer 800 801 def list(self, request, *args, **kwargs): 802 qs = self.get_queryset().first() 803 serializer = self.get_serializer(instance=qs) 804 return APIResponse(result=serializer.data) 805 806 def put(self, request, *args, **kwargs): 807 serializer = self.get_serializer(data=request.data) 808 user = self.request.user 809 serializer = self.get_serializer(instance=user, data=request.data) 810 serializer.is_valid(raise_exception=True) 811 serializer.save() 812 return APIResponse(msg="修改成功!") 813 814 815 class UserMsgListView(GenericViewSet, APIListModelMixin): 816 queryset = Message.objects.all() 817 serializer_class = UserMsgListSerializer 818 permission_classes = [IsAuthenticated] 819 authentication_classes = [JWTAuthentication] 820 821 def get_queryset(self): 822 user = self.request.user 823 instance = Message.objects.filter(Q(sender=user) | Q(receiver=user)) 824 return instance 825 826 827 class RegisterFeederView(GenericViewSet): 828 serializer_class = RegFeederSerializer 829 permission_classes = [IsAuthenticated] 830 authentication_classes = [JWTAuthentication] 831 832 def create(self, request, *args, **kwargs): 833 user = self.request.user.id 834 user_obj = User.objects.filter(pk=user).first() 835 if user_obj.is_pet_feeder == 1: 836 return APIResponse(code=400, msg="已是喂养员!请勿重复注册!") 837 else: 838 serializer = self.get_serializer(data=request.data, context=user) 839 serializer.is_valid(raise_exception=True) 840 serializer.save() 841 return APIResponse(msg="注册成功!") 842 843 844 class FeedbackView(GenericViewSet): 845 serializer_class = FeedbackSerializer 846 847 def create(self, request, *args, **kwargs): 848 file = request.FILES.get("file") 849 if file: 850 file_name = default_storage.save( 851 f"feedback/" + str(file)[-15:], ContentFile(file.read()) 852 ) 853 file_url = default_storage.url(file_name) # /media/pet_icon/716f48749ef.jpg 854 path = "http://192.168.1.38:8000" + file_url 855 else: 856 raise APIException("服务器异常!") 857 return APIResponse(msg="上传图片成功!", file_name=file_name, file_url=path) 858 859 @action(methods=["POST"], detail=False) 860 def feedback(self, request, *args, **kwargs): 861 image = request.data.pop("image") 862 serializer = self.get_serializer(data=request.data, context=image) 863 serializer.is_valid(raise_exception=True) 864 serializer.save() 865 return APIResponse(msg="反馈成功!") 866 867 868 # 查询用户余额 869 class UserBalanceView(GenericViewSet): 870 serializer_class = UserBalanceSerializer 871 permission_classes = [IsAuthenticated] 872 authentication_classes = [JWTAuthentication] 873 874 def get_queryset(self): 875 return User.objects.filter(pk=self.request.user.id) 876 877 @action(methods=["GET"], detail=False) 878 def get_balance(self, request): 879 user_balance = self.get_queryset().first() 880 if user_balance: 881 from django.forms.models import model_to_dict 882 883 instance = UserBalance.objects.get(user_id=user_balance.id) 884 print(instance.balance) 885 return APIResponse(data=instance.balance) 886 return APIResponse(msg="暂无余额记录") 887 888 @action(methods=["POST"], detail=False) 889 def recharge_balance(self, request, *args, **kwargs): 890 amount = request.data.get("amount") 891 print(amount) 892 obj = self.get_queryset().first() 893 if obj: 894 user_balance = UserBalance.objects.get(user_id=obj.id) 895 print(user_balance) 896 user_balance.balance += int(amount) 897 user_balance.save() 898 return APIResponse(data=user_balance.balance) 899 else: 900 return APIResponse(msg="充值金额未提供")
1 settings.py 2 3 # -*- coding: utf-8 -*- 4 # author : heart 5 # blog_url : https://www.cnblogs.com/ssrheart/ 6 # time : 2024/5/14 7 8 SECRET_ID = 'AKIDrbEk9QZbR6Xq22vuo2A9wshMnBRjx8B1' 9 SECRET_KEY = 'jDZnuunfR1UtEjFslgVG16Tp8JNJ6kCV' 10 SMS_SDK_APPID = "1400635776" 11 SIGN_NAME = '小猿取经公众号' 12 TEMPLATE_ID = "1049981" 13 14 15 --------------------------------------------------------------------------------------- 16 17 sms.py 18 19 # -*- coding: utf-8 -*- 20 # author : heart 21 # blog_url : https://www.cnblogs.com/ssrheart/ 22 # time : 2024/5/14 23 import json 24 25 from tencentcloud.common import credential 26 from tencentcloud.common.exception.tencent_cloud_sdk_exception import TencentCloudSDKException 27 from tencentcloud.sms.v20210111 import sms_client, models 28 from tencentcloud.common.profile.client_profile import ClientProfile 29 from tencentcloud.common.profile.http_profile import HttpProfile 30 from .settings import * 31 import random 32 33 34 # 生成n位数字的随机验证码 35 def get_code(num=4): 36 code = '' 37 for i in range(num): 38 r = random.randint(0, 9) 39 code += str(r) 40 41 return code 42 43 44 # 发送短信函数 45 def send_sms(mobile, code): 46 try: 47 cred = credential.Credential(SECRET_ID, SECRET_KEY) 48 httpProfile = HttpProfile() 49 httpProfile.reqMethod = "POST" # post请求(默认为post请求) 50 httpProfile.reqTimeout = 30 # 请求超时时间，单位为秒(默认60秒) 51 httpProfile.endpoint = "sms.tencentcloudapi.com" # 指定接入地域域名(默认就近接入) 52 53 # 非必要步骤: 54 # 实例化一个客户端配置对象，可以指定超时时间等配置 55 clientProfile = ClientProfile() 56 clientProfile.signMethod = "TC3-HMAC-SHA256" # 指定签名算法 57 clientProfile.language = "en-US" 58 clientProfile.httpProfile = httpProfile 59 60 # 实例化要请求产品(以sms为例)的client对象 61 # 第二个参数是地域信息，可以直接填写字符串ap-guangzhou，支持的地域列表参考 https://cloud.tencent.com/document/api/382/52071#.E5.9C.B0.E5.9F.9F.E5.88.97.E8.A1.A8 62 client = sms_client.SmsClient(cred, "ap-guangzhou", clientProfile) 63 req = models.SendSmsRequest() 64 # 应用 ID 可前往 [短信控制台](https://console.cloud.tencent.com/smsv2/app-manage) 查看 65 req.SmsSdkAppId = SMS_SDK_APPID 66 # 短信签名内容: 使用 UTF-8 编码，必须填写已审核通过的签名 67 # 签名信息可前往 [国内短信](https://console.cloud.tencent.com/smsv2/csms-sign) 或 [国际/港澳台短信](https://console.cloud.tencent.com/smsv2/isms-sign) 的签名管理查看 68 req.SignName = SIGN_NAME 69 # 模板 ID: 必须填写已审核通过的模板 ID 70 # 模板 ID 可前往 [国内短信](https://console.cloud.tencent.com/smsv2/csms-template) 或 [国际/港澳台短信](https://console.cloud.tencent.com/smsv2/isms-template) 的正文模板管理查看 71 req.TemplateId = TEMPLATE_ID 72 # 模板参数: 模板参数的个数需要与 TemplateId 对应模板的变量个数保持一致，，若无模板参数，则设置为空 73 req.TemplateParamSet = [code, '1'] 74 # 下发手机号码，采用 E.164 标准，+[国家或地区码][手机号] 75 req.PhoneNumberSet = [f"+86{mobile}"] 76 # 用户的 session 内容（无需要可忽略）: 可以携带用户侧 ID 等上下文信息，server 会原样返回 77 req.SessionContext = "" 78 # 短信码号扩展号（无需要可忽略）: 默认未开通，如需开通请联系 [腾讯云短信小助手] 79 req.ExtendCode = "" 80 # 国内短信无需填写该项；国际/港澳台短信已申请独立 SenderId 需要填写该字段，默认使用公共 SenderId，无需填写该字段。注：月度使用量达到指定量级可申请独立 SenderId 使用，详情请联系 [腾讯云短信小助手](https://cloud.tencent.com/document/product/382/3773#.E6.8A.80.E6.9C.AF.E4.BA.A4.E6.B5.81)。 81 req.SenderId = "" 82 resp = client.SendSms(req) 83 # 输出json格式的字符串回包 84 res = json.loads(resp.to_json_string(indent=2)) 85 if res.get('SendStatusSet')[0].get('Code') == 'Ok': 86 return True 87 else: 88 return False 89 90 except TencentCloudSDKException as err: 91 print(err) 92 return False 93 94 95 if __name__ == '__main__': 96 print(get_code(3))
1 common_settings.py 2 3 BANNER_COUNT = 3 4 5 # ============== celery配置 ============== # 6 CELERY_BROKER_URL = "redis://127.0.0.1:6379/3" 7 # BACKEND配置，使用redis 8 CELERY_RESULT_BACKEND = "redis://127.0.0.1:6379/4" 9 CELERY_ACCEPT_CONTENT = ["json"] 10 CELERY_TASK_SERIALIZER = "json" 11 # 结果序列化方案 12 CELERY_RESULT_SERIALIZER = "json" 13 # 任务结果过期时间，秒 14 CELERY_TASK_RESULT_EXPIRES = 60 * 60 * 24 15 # 时区配置 16 CELERY_TIMEZONE = "Asia/Shanghai" 17 18 ---------------------------------------------------------------------- 19 dev.py 20 21 # 22 # ┌─┐ ┌─┐ + + 23 # ┌──┘ ┴───────┘ ┴──┐++ 24 # │ │ 25 # │ ─── │++ + + + 26 # ███████───███████ │+ 27 # │ │+ 28 # │ ─┴─ │ 29 # │ │ 30 # └───┐ ┌───┘ 31 # │ │ 32 # │ │ + + 33 # │ │ 34 # │ └──────────────┐ 35 # │ │ 36 # │ ├─┐ 37 # │ ┌─┘ 38 # │ │ 39 # └─┐ ┐ ┌───────┬──┐ ┌──┘ + + + + 40 # │ ─┤ ─┤ │ ─┤ ─┤ 41 # └──┴──┘ └──┴──┘ + + + + 42 # 神兽保佑 43 # 代码无BUG! 44 45 from datetime import timedelta 46 from pathlib import Path 47 import sys, os 48 49 BASE_DIR = Path(__file__).resolve().parent.parent 50 apps = os.path.join(BASE_DIR, "apps") 51 sys.path.insert(0, apps) 52 sys.path.insert(0, str(BASE_DIR)) 53 54 SECRET_KEY = "django-insecure-w^5($((r_4ug)s!k(0xymkhns%mu+4gc%lp_bi(x@yd+8mj1ym" 55 56 DEBUG = True 57 58 ALLOWED_HOSTS = ["*"] 59 60 # ============== APP配置 ============== # 61 INSTALLED_APPS = [ 62 "simpleui", 63 "django.contrib.admin", 64 "django.contrib.auth", 65 "django.contrib.contenttypes", 66 "django.contrib.sessions", 67 "django.contrib.messages", 68 "django.contrib.staticfiles", 69 "corsheaders", # 跨域 70 "rest_framework", # drf 71 "home", 72 "user", 73 "pet", 74 "order", 75 ] 76 # ============== 中间件配置 ============== # 77 MIDDLEWARE = [ 78 "django.middleware.security.SecurityMiddleware", 79 "django.contrib.sessions.middleware.SessionMiddleware", 80 "django.middleware.common.CommonMiddleware", 81 "django.middleware.csrf.CsrfViewMiddleware", 82 "django.contrib.auth.middleware.AuthenticationMiddleware", 83 "django.contrib.messages.middleware.MessageMiddleware", 84 "django.middleware.clickjacking.XFrameOptionsMiddleware", 85 "corsheaders.middleware.CorsMiddleware", # 跨域 86 ] 87 88 ROOT_URLCONF = "puddingpet_api.urls" 89 90 TEMPLATES = [ 91 { 92 "BACKEND": "django.template.backends.django.DjangoTemplates", 93 "DIRS": [], 94 "APP_DIRS": True, 95 "OPTIONS": { 96 "context_processors": [ 97 "django.template.context_processors.debug", 98 "django.template.context_processors.request", 99 "django.contrib.auth.context_processors.auth", 100 "django.contrib.messages.context_processors.messages", 101 ], 102 }, 103 }, 104 ] 105 106 WSGI_APPLICATION = "puddingpet_api.wsgi.application" 107 ASGI_APPLICATION = "puddingpet_api.asgi.application" 108 109 # ============== 数据库配置 ============== # 110 USER_NAME = os.environ.get("MYSQL_USER", "puddingpet") 111 USER_PASSWORD = os.environ.get("MYSQL_PASSWORD", "Pudding123?") 112 113 114 DATABASES = { 115 "default": { 116 "ENGINE": "django.db.backends.mysql", 117 "NAME": "puddingpet", 118 "USER": USER_NAME, 119 "PASSWORD": USER_PASSWORD, 120 "HOST": "1.94.109.143", 121 "PORT": 3306, 122 "CHARSET": "utf8mb4", 123 } 124 } 125 126 AUTH_PASSWORD_VALIDATORS = [ 127 { 128 "NAME": "django.contrib.auth.password_validation.UserAttributeSimilarityValidator", 129 }, 130 { 131 "NAME": "django.contrib.auth.password_validation.MinimumLengthValidator", 132 }, 133 { 134 "NAME": "django.contrib.auth.password_validation.CommonPasswordValidator", 135 }, 136 { 137 "NAME": "django.contrib.auth.password_validation.NumericPasswordValidator", 138 }, 139 ] 140 141 # ============== 时区配置 ============== # 142 LANGUAGE_CODE = "zh-hans" 143 TIME_ZONE = "Asia/Shanghai" 144 USE_I18N = True 145 USE_TZ = False 146 147 # ============== 静态文件配置 ============== # 148 STATIC_URL = "static/" 149 150 # ============== models配置 ============== # 151 # 用于指定模型中自动生成主键字段的默认类型 152 # 如果没有在模型中明确指定主键字段类型，Django 将使用 BigAutoField 作为默认类型。 153 DEFAULT_AUTO_FIELD = "django.db.models.BigAutoField" 154 155 # ============== 跨域配置 ============== # 156 CORS_ORIGIN_ALLOW_ALL = True 157 158 CORS_ALLOW_HEADERS = ( 159 "accept", 160 "accept-encoding", 161 "authorization", 162 "content-type", 163 "dnt", 164 "origin", 165 "user-agent", 166 "x-csrftoken", 167 "x-requested-with", 168 # 额外允许的请求头 169 "token", 170 ) 171 172 # ============== auth表 ============== # 173 AUTH_USER_MODEL = "user.User" 174 175 # ============== media设置 ============== # 176 MEDIA_URL = "/media/" 177 MEDIA_ROOT = os.path.join(BASE_DIR, "media") 178 179 # ============== 日志 ============== # 180 from utils import common_logger 181 182 common_logger.configure_logger() 183 184 185 # ============== 异常捕获 ============== # 186 REST_FRAMEWORK = { 187 "EXCEPTION_HANDLER": "utils.common_exception.exception_handler", 188 "DEFAULT_AUTHENTICATION_CLASSES": ( 189 "rest_framework.authentication.TokenAuthentication", 190 ), 191 } 192 from .common_settings import * 193 194 # import socket 195 196 # ============== 头像拼接路径 ============== # 197 # HOST = socket.gethostbyname(socket.gethostname()) 198 BACKEND_URL = "http://192.168.1.38:8000/" 199 ICON_URL = "http://192.168.1.38:8000" 200 201 # ============== JWT配置 ============== # 202 SIMPLE_JWT = { 203 "ACCESS_TOKEN_LIFETIME": timedelta(days=7), # Access Token的有效期 204 } 205 # ============== django-redis/cache配置 ============== # 206 CACHES = { 207 "default": { 208 "BACKEND": "django_redis.cache.RedisCache", 209 "LOCATION": "redis://127.0.0.1:6379", 210 "OPTIONS": { 211 "CLIENT_CLASS": "django_redis.client.DefaultClient", 212 "CONNECTION_POOL_KWARGS": {"max_connections": 100}, 213 }, 214 } 215 } 216 217 218 ---------------------------------------------------------------------------------- 219 pro.py 220 221 # 222 # ┌─┐ ┌─┐ + + 223 # ┌──┘ ┴───────┘ ┴──┐++ 224 # │ │ 225 # │ ─── │++ + + + 226 # ███████───███████ │+ 227 # │ │+ 228 # │ ─┴─ │ 229 # │ │ 230 # └───┐ ┌───┘ 231 # │ │ 232 # │ │ + + 233 # │ │ 234 # │ └──────────────┐ 235 # │ │ 236 # │ ├─┐ 237 # │ ┌─┘ 238 # │ │ 239 # └─┐ ┐ ┌───────┬──┐ ┌──┘ + + + + 240 # │ ─┤ ─┤ │ ─┤ ─┤ 241 # └──┴──┘ └──┴──┘ + + + + 242 # 神兽保佑 243 # 代码无BUG! 244 245 from datetime import timedelta 246 from pathlib import Path 247 import sys, os 248 249 BASE_DIR = Path(__file__).resolve().parent.parent 250 apps = os.path.join(BASE_DIR, "apps") 251 sys.path.insert(0, apps) 252 sys.path.insert(0, str(BASE_DIR)) 253 254 SECRET_KEY = "django-insecure-w^5($((r_4ug)s!k(0xymkhns%mu+4gc%lp_bi(x@yd+8mj1ym" 255 256 DEBUG = True 257 258 ALLOWED_HOSTS = ["*"] 259 260 # ============== APP配置 ============== # 261 INSTALLED_APPS = [ 262 "simpleui", 263 "django.contrib.admin", 264 "django.contrib.auth", 265 "django.contrib.contenttypes", 266 "django.contrib.sessions", 267 "django.contrib.messages", 268 "django.contrib.staticfiles", 269 "corsheaders", # 跨域 270 "rest_framework", # drf 271 "home", 272 ] 273 # ============== 中间件配置 ============== # 274 MIDDLEWARE = [ 275 "django.middleware.security.SecurityMiddleware", 276 "django.contrib.sessions.middleware.SessionMiddleware", 277 "django.middleware.common.CommonMiddleware", 278 "django.middleware.csrf.CsrfViewMiddleware", 279 "django.contrib.auth.middleware.AuthenticationMiddleware", 280 "django.contrib.messages.middleware.MessageMiddleware", 281 "django.middleware.clickjacking.XFrameOptionsMiddleware", 282 "corsheaders.middleware.CorsMiddleware", # 跨域 283 ] 284 285 ROOT_URLCONF = "puddingpet_api.urls" 286 287 TEMPLATES = [ 288 { 289 "BACKEND": "django.template.backends.django.DjangoTemplates", 290 "DIRS": [], 291 "APP_DIRS": True, 292 "OPTIONS": { 293 "context_processors": [ 294 "django.template.context_processors.debug", 295 "django.template.context_processors.request", 296 "django.contrib.auth.context_processors.auth", 297 "django.contrib.messages.context_processors.messages", 298 ], 299 }, 300 }, 301 ] 302 303 WSGI_APPLICATION = "puddingpet_api.wsgi.application" 304 305 306 # ============== 数据库配置 ============== # 307 USER_NAME = os.environ.get("MYSQL_USER", "puddingpet") 308 USER_PASSWORD = os.environ.get("MYSQL_PASSWORD", "Pudding123?") 309 310 311 DATABASES = { 312 "default": { 313 "ENGINE": "django.db.backends.mysql", 314 "NAME": "puddingpet", 315 "USER": USER_NAME, 316 "PASSWORD": USER_PASSWORD, 317 "HOST": "1.94.109.143", 318 "PORT": 3306, 319 "CHARSET": "utf8mb4", 320 } 321 } 322 323 AUTH_PASSWORD_VALIDATORS = [ 324 { 325 "NAME": "django.contrib.auth.password_validation.UserAttributeSimilarityValidator", 326 }, 327 { 328 "NAME": "django.contrib.auth.password_validation.MinimumLengthValidator", 329 }, 330 { 331 "NAME": "django.contrib.auth.password_validation.CommonPasswordValidator", 332 }, 333 { 334 "NAME": "django.contrib.auth.password_validation.NumericPasswordValidator", 335 }, 336 ] 337 338 # ============== 时区配置 ============== # 339 LANGUAGE_CODE = "zh-hans" 340 TIME_ZONE = "Asia/Shanghai" 341 USE_I18N = True 342 USE_TZ = False 343 344 # ============== 静态文件配置 ============== # 345 STATIC_URL = "static/" 346 347 # ============== models配置 ============== # 348 # 用于指定模型中自动生成主键字段的默认类型 349 # 如果没有在模型中明确指定主键字段类型，Django 将使用 BigAutoField 作为默认类型。 350 DEFAULT_AUTO_FIELD = "django.db.models.BigAutoField" 351 352 # ============== 跨域配置 ============== # 353 CORS_ORIGIN_ALLOW_ALL = True 354 355 CORS_ALLOW_HEADERS = ( 356 "accept", 357 "accept-encoding", 358 "authorization", 359 "content-type", 360 "dnt", 361 "origin", 362 "user-agent", 363 "x-csrftoken", 364 "x-requested-with", 365 # 额外允许的请求头 366 "token", 367 ) 368 369 # 设置auth表 370 # AUTH_USER_MODEL = "user.User" 371 372 # 开启media 373 MEDIA_URL = "/media/" 374 MEDIA_ROOT = os.path.join(BASE_DIR, "media") 375 376 # 日志 377 # from utils import common_logger 378 379 # common_logger.configure_logger() 380 381 382 # ============== 异常捕获 ============== # 383 REST_FRAMEWORK = { 384 "EXCEPTION_HANDLER": "utils.common_exception.exception_handler", 385 } 386 from .common_settings import * 387 388 # ============== 头像拼接路径 ============== # 389 BACKEND_URL = "http://127.0.0.1:8000/" 390 391 # ============== JWT配置 ============== # 392 SIMPLE_JWT = { 393 "ACCESS_TOKEN_LIFETIME": timedelta(days=7), # Access Token的有效期 394 }
1 common_exception.py 2 3 from rest_framework.views import exception_handler as drf_exception_handler 4 from rest_framework.response import Response 5 from utils.common_response import APIResponse 6 from utils.common_logger import logger 7 8 9 # 自定义异常类 10 class PasswordException(Exception): 11 pass 12 13 14 def exception_handler(exc, context): 15 res = drf_exception_handler(exc, context) 16 print(res) 17 request = context.get("request") 18 view = context.get("view") 19 ip = request.META.get("REMOTE_ADDR") 20 path = request.get_full_path() 21 method = request.method 22 user_id = request.user.id or "匿名用户" 23 logger.error( 24 f"操作出错!{str(exc)},视图类:{str(view)},ip:{ip},请求地址:{path},请求方式:{method},用户id:{user_id}" 25 ) 26 27 if res: 28 # drf异常 29 if isinstance(res.data, dict): 30 err = ( 31 res.data.get("detail") 32 or res.data.get("non_field_errors") 33 or "请正确输入!" 34 ) 35 elif isinstance(res.data, list): 36 err = res.data[0] 37 else: 38 err = "服务异常，请稍后再尝试，[drf]" 39 # print(res.data) 40 response = APIResponse(code=4000, msg=err) 41 else: 42 # 非drf异常 43 if isinstance(exc, ZeroDivisionError): 44 err = "数据操作出错,除以0了" 45 code = 4001 46 elif isinstance(exc, PasswordException): 47 err = "密码错误!" 48 code = 4002 49 else: 50 err = f"{str(exc)}" 51 code = 4004 52 response = APIResponse(code=code, msg=err) 53 54 return response 55 56 --------------------------------------------------------------------------------- 57 common_logger.py 58 59 from loguru import logger 60 import os 61 62 LOG_PATH = os.path.join("logs", "puddingpet.log") 63 64 65 def configure_logger(): 66 # logger.remove() # 清除默认的日志处理器 67 # logger.level("CRITICAL") 68 logger.add(f"{LOG_PATH}", rotation="300 MB", level="ERROR") 69 70 ---------------------------------------------------------------------------------- 71 common_mixin.py 72 73 from rest_framework.mixins import ( 74 CreateModelMixin, 75 ListModelMixin, 76 UpdateModelMixin, 77 DestroyModelMixin, 78 RetrieveModelMixin, 79 ) 80 from utils.common_response import APIResponse 81 from django.core.cache import cache 82 from utils.common_logger import logger 83 from rest_framework.exceptions import APIException 84 85 86 class APIListModelMixin(ListModelMixin): 87 def list(self, request, *args, **kwargs): 88 res = super().list(request, *args, **kwargs) 89 return APIResponse(results=res.data) 90 91 92 class CacheListModelMixin(ListModelMixin): 93 cache_key = None 94 95 def list(self, request, *args, **kwargs): 96 assert self.cache_key, APIException( 97 "如果继承CacheListModelMixin，必须要加cache_key!" 98 ) 99 results = cache.get(self.cache_key) 100 if not results: 101 logger.info("走了数据库") 102 res = super().list(request, *args, **kwargs) 103 results = res.data 104 cache.set(self.cache_key, results) 105 return APIResponse(results=results) 106 107 108 class APIRetrieveModelMixin(RetrieveModelMixin): 109 def retrieve(self, request, *args, **kwargs): 110 res = super().retrieve(request, *args, **kwargs) 111 return APIResponse(result=res.data) 112 113 -------------------------------------------------------------------------------------- 114 conmmon_models.py 115 116 from django.db import models 117 118 119 class BaseModel(models.Model): 120 created_time = models.DateTimeField(auto_now_add=True, verbose_name="创建时间") 121 updated_time = models.DateTimeField(auto_now=True, verbose_name="最后更新时间") 122 is_delete = models.BooleanField(default=False, verbose_name="是否删除") 123 is_show = models.BooleanField(default=True, verbose_name="是否上架") 124 orders = models.IntegerField(verbose_name="优先级") 125 126 class Meta: 127 abstract = True # 只用来继承，不在数据库中生成表 128 129 --------------------------------------------------------------------------------- 130 common_response.py 131 132 from rest_framework.response import Response 133 134 135 class APIResponse(Response): 136 137 def __init__(self, code=100, msg="成功!", headers=None, status=None, **kwargs): 138 data = {"code": code, "msg": msg} 139 if kwargs: 140 data.update(kwargs) 141 super().__init__(data=data, status=status, headers=headers)
