six_003

django_app/models.py

@@ -5,8 +5,9 @@ from wechat_数据库.企业微信数据库 import 推广二维码数据表, 企
 from wechat_token import token数据库
 from wechat_数据库.地图定位 import 用户定位数据库, 腾讯地图解析数据库
 from wechat_数据库.小程序后端数据库 import 订阅消息
+from wechat_数据库.微信支付券 import 代金券数据库
 from wechat_数据库.支付订单数据库 import 商品订单数据
 from wechat_数据库.洗衣液商品数据库 import 六果洗衣液商品
 from wechat_数据库.测试数据库 import 测试数据表
-from wechat_数据库.用户数据库 import 小程序登陆用户, 小程序用户地址, 小程序积分数据库,企微客服数据库
+from wechat_数据库.用户数据库 import 小程序登陆用户, 小程序用户地址, 小程序积分数据库, 企微客服数据库
-# Create your models here.
+# Create your models here.

django_app/views.py

@@ -16,6 +16,7 @@ from rest_framework.viewsets import ViewSet
 
 from django_jwt_token.jwt认证接口 import Jwt身份认证
 from sixGuoDjango import BaseResponse, ResData, redis_5
+from wechat_token.token工具包 import sixToken
 
 default_channel_layer = cast(BaseChannelLayer, get_channel_layer(alias="default"))
 
@@ -29,21 +30,21 @@ def sync_lock(lock):
         def wrapper(*args, **kwargs):
             with lock:
                 return fn(*args, **kwargs)
-
+        
         return wrapper
-
+    
     return decorator
 
 
 class DemoXiaoViewSets(ViewSet):
     lock = threading.Lock()  # 所有请求 共享这一个 lock对象
-
+    
     @action(detail=False, methods=["get", "post", "put", "delete"], url_path="zizi")
     def 只用于初始化项目测试接口(self, request: Request):
         """"""
         print("测试接口")
         # 可以对用户添加某一类型的积分
-
+        
         # with ThreadPoolExecutor( max_workers=3 ) as executor:
         #     返回值 = executor.map( 请求企微, [ 1, 2, 3 ] )
         #     print( 返回值 )
@@ -51,31 +52,31 @@ class DemoXiaoViewSets(ViewSet):
         #         print( item )
         xiao = request.data.get("xiao", None)
         print(xiao)
-
+        
         商品数据 = request.data.get("商品数据", "")
         data = orjson.loads(商品数据)
         列表 = pydash.get(obj=data, path="列表")
         print(列表, 商品数据)
         fileDataList: list[InMemoryUploadedFile] = request.FILES.getlist("fileDataList", None)  # 接收多个图片或者文件
-
+        
         for file in fileDataList:
             default_storage.save(name=file.name, content=file)
         httpResData = BaseResponse(resData=ResData(listData=[""], dictData={}), ).model_dump()
         return Response(data=httpResData, status=status.HTTP_200_OK)
-
+    
     @action(detail=False, methods=["get", "post", "put", "delete"], url_path="xiao")
     def xiao(self, request: Request):
         """"""
         openid = "oy4Jw6A1T3WkKOOhMxcbQTDSM8rs"
         channels_name = redis_5.get(name="xiaozizi")
         async_to_sync(awaitable=default_channel_layer.send)(channel=channels_name,
-                                                            message={"type": "chat_msg",
+            message={"type": "chat_msg",
-                                                                     "data": {"xiao": "zizi"},
+                "data": {"xiao": "zizi"},
-                                                                     })
+                })
-
+        
         httpResData = BaseResponse(resData=ResData(listData=[""], dictData={"demo": "xiaozizi"}), ).model_dump()
         return Response(data=httpResData, status=status.HTTP_200_OK)
-
+    
     @action(detail=False, methods=["get", "post", "put", "delete"], url_path="eventSource")
     def sse请求处理接口(self, request: Request):
         """"""
@@ -83,27 +84,25 @@ class DemoXiaoViewSets(ViewSet):
             "sse请求处理接口sse请求处理接口sse请求处理接口sse请求处理接口sse请求处理接口sse请求处理接口sse请求处理接口sse请求处理接口sse请求处理接口sse请求处理接口")
         httpResData = BaseResponse(resData=ResData(listData=[""], dictData={"demo": "xiaozizi"}), ).model_dump()
         return Response(data=httpResData, status=status.HTTP_200_OK)
-
+    
     @action(detail=False, methods=["get", "post", "put", "delete"], url_path="xiaozizi",
-            authentication_classes=[Jwt身份认证])
+        authentication_classes=[Jwt身份认证])
     # @sync_lock_线程锁( lock=lock )
     def xiaozizi(self, request: Request):
         pass
         return Response(data={"xiao": "111111111111111111"})
-
+    
     @action(detail=False, methods=["get", "post", "put", "delete"], url_path="redirect")
     # @sync_lock_线程锁( lock=lock )
     def redirect(self, request: Request):
         # 接口是用来测试重定向
         pass
         return HttpResponseRedirect(redirect_to="https://six.sixgou.com/")
-
+    
     # @sync_lock(lock=lock)
     @action(detail=False, methods=["get", "post", "put", "delete"], url_path="中文", )
     def 中文(self, request: Request):
-        print("卡异步的请求")
         xiaozizi = request.data.get("xiaozizi", None)
-        print(xiaozizi)
         return Response(data={"msg": xiaozizi})
 
 

django_app/业务订单接口.py

@@ -13,11 +13,11 @@ from rest_framework.viewsets import ViewSet
 from ulid import ULID
 
 from sixGuoDjango import BaseResponse, ResData
-from wechat_微信支付证书.江苏六果科技有限公司支付证书.江苏六果科技有限公司支付参数 import sixpay六果科技公司
+from wechat_微信支付证书.江苏六果科技有限公司支付证书.六果公司支付类 import sixWechatPay六果泡泡支付
 from wechat_数据库.支付订单数据库.商品订单数据 import order订单
 from wechat_数据库.用户数据库.小程序登陆用户 import weiuser
 from wechat_项目工具包.EMS中国邮政.ems邮政 import ems邮政物流工具
-from wechat_项目工具包.微信支付工具包.微信支付类 import paymentCategory, wechatPay
+from wechat_项目工具包.微信支付工具包.微信支付类 import paymentCategory
 from wechat_项目工具包.数据库的工具包.更新用户积分 import miniUser用户角色, miniUser积分
 
 
@@ -84,7 +84,6 @@ class 业务订单接口ViewSets(ViewSet):
         order订单类型 = request.data.get("order订单类型", None)
         goods标题 = emoji.replace_emoji(pydash.get(obj=pydash.head(order购物车商品数据), path="goods_商品标题"))
         goods_detail_支付优惠券的数据 = self.生成单品优惠券的数据(order购物车商品数据=order购物车商品数据)
-        print("打印一下哪里出问题了", order购物车商品数据)
         out_trade_no商家侧的订单号 = f"OAT{ULID()}"  # 生成商家侧的订单号
         body = {
             "mchid": paymentCategory.mchid,  # 【直连商户号】 直连商户号
@@ -109,8 +108,7 @@ class 业务订单接口ViewSets(ViewSet):
                 },
             "support_fapiao": True,  # 【电子发票入口开放标识】 传入true时，支付成功消息和支付详情页将出现开票入口。需要在微信支付商户平台或微信公众平台开通电子发票功能，传此字段才可生效。
             }  # 请求的数据
-        wechat_data = wechatPay(payment=sixpay六果科技公司).getpay_jsapi(uri=url_pay, body_data=body, method="POST")
+        wechat_pay_data = sixWechatPay六果泡泡支付(pay_methon方法="POST", pay_请求体=body, pay_uri=url_pay).getpay_jsapi发起支付()
-        payData = pydash.get(obj=wechat_data, path="response")
         order订单对象 = order订单.objects.create(order支付商家侧订单号=out_trade_no商家侧的订单号,
             order购物车商品总价=order购物车商品总价, order购物车商品数据=order购物车商品数据,
             order购物车商品数量=order购物车商品数量,
@@ -121,7 +119,7 @@ class 业务订单接口ViewSets(ViewSet):
             order支付者openid=self_mini_openid,
             order支付者unionid=self_mini_unionid,
             )
-        httpResData = BaseResponse(resData=ResData(listData=[""], dictData=payData), ).model_dump()
+        httpResData = BaseResponse(resData=ResData(listData=[""], dictData=wechat_pay_data), ).model_dump()
         # httpResData = BaseResponse(resData=ResData(listData=[""], dictData={}), ).model_dump()
         return Response(data=httpResData, status=status.HTTP_200_OK)
     
@@ -129,9 +127,8 @@ class 业务订单接口ViewSets(ViewSet):
     @action(detail=False, methods=["post"], url_path="mall_callbakc")
     def jsapi支付回调测试接口(self, request: Request) -> Response:
         """ 微信支付成功后的回调接口 """
-        dict_body = request.data
+        wechat_data支付回调数据 = sixWechatPay六果泡泡支付(pay_uri="", pay_请求体={}, pay_methon方法="POST", ).callBack回调解密(headers=request.headers, response_body=request.data)
-        wechat_data支付回调数据 = wechatPay(payment=paymentCategory).callBack回调解密(headers=request.headers,
+        print("支付的回调数据", wechat_data支付回调数据)
-            response_body=dict_body, )
         out_trade_no商家侧支付订单号 = pydash.get(obj=wechat_data支付回调数据, path="out_trade_no")  # 商家侧的订单号
         trade_state_desc = pydash.get(obj=wechat_data支付回调数据, path="trade_state_desc")  # 支付回调的支付状态
         transaction_id = pydash.get(obj=wechat_data支付回调数据, path="transaction_id")
@@ -143,7 +140,7 @@ class 业务订单接口ViewSets(ViewSet):
             order物流订单号=生成商家侧物流的订单号,
             order支付微信官方订单号=transaction_id,
             )
-        (miniUser积分(share分享者unionidID="", click点击者unionidID="")
+        (miniUser积分(share分享者unionidID="", click点击者unionidID="", bind绑定的企微unionidID="")
          .add添加好友助力下单返利积分(order支付商家侧订单号=out_trade_no商家侧支付订单号, share积分类型="好友下单"))
         ems邮政物流工具().生成运单(out_trade_no商家侧支付订单号=out_trade_no商家侧支付订单号)  # 调用方法,生成真实的物流订单号码;
         httpResData = BaseResponse(resData=ResData(listData=[""], dictData={"demo": "xiaozizi"}), ).model_dump()

django_app/实时更新物流数据接口.py

@@ -36,8 +36,7 @@ class 实时更新物流数据ViewSets(ViewSet):
     def 实时更新物流数据(self, request: Request):
         """前端小程序, 物流追踪页面, 左上角 刷新按钮 返回的数据"""
         order物流公司订单编号 = request.data.get("order物流公司订单编号", None)
-        order物流订单号 = request.data.get("order物流订单号", None)
-        print("实时更新数据请求进来了吗")
         ems邮政物流工具().更新物流快递数据(order物流公司订单编号=order物流公司订单编号, )
+        print("调有了实时更新的数据接口,这里更新的数据为ems的物流的数据")
         httpResData = BaseResponse(resData=ResData(listData=[""], dictData={}), ).model_dump()
         return Response(data=httpResData, status=status.HTTP_200_OK)

django_app/小程序发券接口.py

@@ -6,6 +6,7 @@ from rest_framework.request import Request
 from rest_framework.response import Response
 from rest_framework.viewsets import ViewSet
 
+from wechat_数据库.微信支付券.代金券数据库 import stock券数据表
 from wechat_项目工具包.微信支付工具包.领优惠券工具包 import stock发送代金券功能
 
 default_channel_layer = cast(BaseChannelLayer, get_channel_layer(alias="default"))
@@ -31,13 +32,33 @@ class 小程序发优惠券到钱包接口ViewSets(ViewSet):
     
     @action(detail=False, methods=["get", "post", "put", "delete"], url_path="生成优惠券")
     def 生成优惠券(self, request: Request):
-        """"""
+        """这里的接口就是将,券,直接发送给前端用户,"""
-        # stock发券数据 = stock发送代金券功能(stock_id_代金券批次号="22512292").send发券并返回前端需要的数据()
+        self_mini_openid = request.data.get("self_mini_openid", None)
-        stock发券数据 = stock发送代金券功能(stock_id_代金券批次号="22625737").send发券并返回前端需要的数据()
+        self_mini_unionid = request.data.get("self_mini_unionid", None)
-        # 4. 生成签名
+        print(self_mini_openid, self_mini_unionid)
-        return Response(data=stock发券数据)
+        stock查询数据领券成功时的处理: stock券数据表 | None = stock券数据表.objects.filter(mini_unionid=self_mini_unionid, mini_openid=self_mini_openid, stock_use_券状态="已领券").first()
+        if stock查询数据领券成功时的处理 is not None:
+            return Response(data={"stock券状态": "已领券", "stock领券数据": {}})
+        stock查询数据: stock券数据表 | None = stock券数据表.objects.filter(mini_unionid=self_mini_unionid, mini_openid=self_mini_openid, stock_use_券状态="待领券").first()
+        print(stock查询数据, "在这里查询到的结果")
+        if stock查询数据 is None:
+            # 查询数据库,看看用户当前有没有券已发了但是还没有领取的状态
+            # stock发券数据 = stock发送代金券功能(stock_id_代金券批次号="22512292").send发券并返回前端需要的数据()
+            stock发券数据 = stock发送代金券功能(stock_id_代金券批次号="22625737", stock券的状态="待领券").send发券并返回前端需要的数据(self_mini_openid=self_mini_openid, self_mini_unionid=self_mini_unionid)
+            # 4. 生成签名
+            # return Response(data=stock发券数据)
+            return Response(data={"stock券状态": "待领券", "stock领券数据": stock发券数据})
+        else:
+            pass
+            print("查询是这里生效了啦")
+            return Response(data={"stock券状态": stock查询数据.stock_use_券状态, "stock领券数据": stock查询数据.stock_未领取券的数据})
     
-    @action(detail=False, methods=["get", "post", "put", "delete"], url_path="返回当前券的状态")
+    @action(detail=False, methods=["get", "post", "put", "delete"], url_path="领券后更新当前券的状态")
-    def 返回当前券的状态(self, request: Request):
+    def 领券后更新当前券的状态(self, request: Request):
         pass
-        return Response(data={})
+        self_mini_openid = request.data.get("self_mini_openid", None)
+        self_mini_unionid = request.data.get("self_mini_unionid", None)
+        stock券状态 = request.data.get("stock券状态", None)
+        print("用户领券成功了")
+        stock发送代金券功能(stock_id_代金券批次号="22625737", stock券的状态=stock券状态, stock券已领券="已领券").领券后更新当前券的状态(self_mini_openid=self_mini_openid, self_mini_unionid=self_mini_unionid)
+        return Response(data={"stock券状态": stock券状态, "stock领券数据": {}})

django_routes/小程序服务端接口管理列表.py

@@ -16,7 +16,6 @@ from wechat_mini_服务端接口目录.小程序码与小程序链接口列表.s
 from wechat_mini_服务端接口目录.小程序码与小程序链接口列表.小程序码接口 import 小程序码接口ViewSets
 from wechat_mini_服务端接口目录.手机号.获取手机号接口 import 获取手机号ViewSets
 from wechat_mini_服务端接口目录.接口调用凭证.获取稳定版接口调用凭据接口 import 获取稳定版接口调用凭据ViewSets
-from wechat_mini_服务端接口目录.物流账号邮政.物流账号接口 import EMS物流ViewSets
 from wechat_mini_服务端接口目录.用工关系接口列表.用工关系接口 import 用工关系接口ViewSets
 from wechat_mini_服务端接口目录.附近小程序.附近小程序接口 import 附近小程序ViewSets
 
@@ -27,7 +26,6 @@ from wechat_mini_服务端接口目录.附近小程序.附近小程序接口 imp
     basename="获取手机号ViewSets")
 小程序服务端管理接口列表ViewSetsRouter.register(prefix="token", viewset=获取稳定版接口调用凭据ViewSets,
     basename="获取稳定版接口调用凭据ViewSets")
-小程序服务端管理接口列表ViewSetsRouter.register(prefix="ems", viewset=EMS物流ViewSets, basename="EMS物流ViewSets")
 小程序服务端管理接口列表ViewSetsRouter.register(prefix="shipment_information_management", viewset=发货信息录入ViewSets,
     basename="发货信息录入ViewSets")
 小程序服务端管理接口列表ViewSetsRouter.register(prefix="用工关系", viewset=用工关系接口ViewSets, basename="用工关系接口ViewSets")

wechat_mini_服务端接口目录/小程序用户地址定位/小程序用户的位置接口.py

@@ -34,7 +34,6 @@ class 小程序用户的位置接口ViewSets(ViewSet):
             市 = pydash.get(obj=地图解析结果, path="result.address_component.city")
             区 = pydash.get(obj=地图解析结果, path="result.address_component.district")
             街道 = pydash.get(obj=地图解析结果, path="result.address_component.street_number")
-            街道号码 = pydash.get(obj=地图解析结果, path="result.address_component.street")
             # 开始更新数据库
             six六果对象.user_区县 = 区
             six六果对象.user_省份 = 省
@@ -47,9 +46,8 @@ class 小程序用户的位置接口ViewSets(ViewSet):
     @action(detail=False, methods=["post", ], url_path="ip")
     def 解析用户IP地址接口(self, request: Request):
         """ """
-        self_mini_openid = request.data.get("self_mini_openid", None)
         self_mini_unionid = request.data.get("self_mini_unionid", None)
-        x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR', False)
+        x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR', "")
         ip = pydash.head(x_forwarded_for.split(','))
         mini_unionid_user = weiuser.objects.get(unionid=self_mini_unionid, )
         if mini_unionid_user.user_省份 is None or mini_unionid_user.user_城市 is None:

wechat_mini_服务端接口目录/小程序用户地址定位/小程序用户配送地址接口.py

@@ -1,4 +1,3 @@
-import jmespath
 import orjson
 import pydash
 from asgiref.sync import async_to_sync
@@ -11,10 +10,8 @@ from rest_framework.response import Response
 from rest_framework.viewsets import ViewSet
 
 from sixGuoDjango import BaseResponse, RedisClientManager, ResData
-from wechat_数据库.地图定位.用户定位数据库 import weiuser地图定位
 from wechat_数据库.用户数据库.小程序用户地址 import weiuser微信用户地址
 from wechat_数据库.用户数据库.小程序登陆用户 import weiuser
-from wechat_项目工具包.腾讯地图.腾讯地图工具 import OriginPointOptional, wei地图工具
 
 redis_socked = RedisClientManager().get_client(db_name="redis_5")
 
@@ -22,7 +19,7 @@ example通道层实例: BaseChannelLayer = get_channel_layer(alias="default")
 
 
 class 用户配送地址ViewSets(ViewSet):
-    def update更新用户头像事件(self, self_mini_unionid):
+    def send前端发送最新用户数据(self, self_mini_unionid):
         channel_id = redis_socked.get(self_mini_unionid)
         user_obj = weiuser.objects.get(unionid=self_mini_unionid)
         user_data = model_to_dict(instance=user_obj, fields=None, exclude=None)
@@ -33,17 +30,16 @@ class 用户配送地址ViewSets(ViewSet):
                     encoding="utf-8")
                 })
     
-    def update更新用户手机号码方法(self, address, self_mini_openid, self_user_unionid):
+    def update更新用户手机号码方法(self, address, self_user_unionid):
         pass
+        print(address)
         用户手机号码 = pydash.get(obj=address, path="telNumber")
         用户昵称 = pydash.get(obj=address, path="userName")
         用户所在省 = pydash.get(obj=address, path="provinceName")
         用户所在市 = pydash.get(obj=address, path="cityName")
         用户所在区县 = pydash.get(obj=address, path="countyName")
         用户所在街道 = pydash.get(obj=address, path="detailInfo")
-        weiuser.objects.filter(unionid=self_user_unionid).update(
+        weiuser.objects.filter(unionid=self_user_unionid).update(uesr_手机号码=用户手机号码, user_昵称=用户昵称, )
-            uesr_手机号码=用户手机号码, user_昵称=用户昵称,
-            )
         six_user六果对象 = weiuser.objects.get(unionid=self_user_unionid)
         if not six_user六果对象.user_区县 or not six_user六果对象.user_城市 or not six_user六果对象.user_省份:
             six_user六果对象.user_省份 = 用户所在省
@@ -58,17 +54,16 @@ class 用户配送地址ViewSets(ViewSet):
         addressData = request.data.get("addressData", None)
         self_mini_openid = request.data.get("self_mini_openid", None)
         self_mini_unionid = request.data.get("self_mini_unionid", None)
-        self.update更新用户手机号码方法(address=addressData, self_mini_openid=self_mini_openid,
+        # 调用: 更新手机号码的方法,
-            self_user_unionid=self_mini_unionid)
+        self.update更新用户手机号码方法(address=addressData, self_user_unionid=self_mini_unionid)
-        self.update更新用户头像事件(self_mini_unionid=self_mini_unionid)
+        # 调用更新有户头像的方法 此方法:  就是通过channles将最新的数据返回给前端(以便前端用户即时更新)
-        
+        self.send前端发送最新用户数据(self_mini_unionid=self_mini_unionid)
-        a, b = weiuser微信用户地址.objects.update_or_create(
+        weiuser微信用户地址.objects.update_or_create(
             address=addressData, mini_unionid=self_mini_unionid, mini_openid=self_mini_openid,
             isDefaultAddress=weiuser微信用户地址.choicesAddress.是默认地址.value,
             )
         查询当前用户的全部地址 = weiuser微信用户地址.objects.filter(mini_unionid=self_mini_unionid,
-            mini_openid=self_mini_openid, ).values(
+            mini_openid=self_mini_openid, ).values("id_主键_配送地址", "id_str", "address", "isDefaultAddress")
-            "id_主键_配送地址", "id_str", "address", "isDefaultAddress")
         httpResData = BaseResponse(
             resData=ResData(listData=查询当前用户的全部地址, dictData={"demo": "xiaozizi"}), ).model_dump()
         return Response(data=httpResData, status=status.HTTP_200_OK)
@@ -92,10 +87,8 @@ class 用户配送地址ViewSets(ViewSet):
         self_mini_openid = request.data.get("self_mini_openid", None)
         self_mini_unionid = request.data.get("self_mini_unionid", None)
         addressData = request.data.get("addressData", None)
-        self.update更新用户手机号码方法(address=addressData, self_mini_openid=self_mini_openid,
+        self.update更新用户手机号码方法(address=addressData, self_user_unionid=self_mini_unionid)
-            self_user_unionid=self_mini_unionid)
+        self.send前端发送最新用户数据(self_mini_unionid=self_mini_unionid)
-        
-        self.update更新用户头像事件(self_mini_unionid=self_mini_unionid)
         
         是否新存在 = weiuser微信用户地址.objects.filter(address=addressData, mini_unionid=self_mini_unionid,
             mini_openid=self_mini_openid).exists()
@@ -118,7 +111,7 @@ class 用户配送地址ViewSets(ViewSet):
             return Response(data=httpResData, status=status.HTTP_200_OK)
         else:
             # 同时还需要将以前的地址全部更新为非默认地址,
-            创建新对象, 是否首次创建 = weiuser微信用户地址.objects.update_or_create(
+            weiuser微信用户地址.objects.update_or_create(
                 address=addressData, mini_openid=self_mini_openid,
                 mini_unionid=self_mini_unionid)  # 在这里更新了所有的地址都不是 默认的地址
             (weiuser微信用户地址.objects.filter(mini_openid=self_mini_openid, mini_unionid=self_mini_unionid)
@@ -143,7 +136,7 @@ class 用户配送地址ViewSets(ViewSet):
         idKey = request.data.get("idKey", None)
         self_mini_openid = request.data.get("self_mini_openid", None)
         self_mini_unionid = request.data.get("self_mini_unionid", None)
-        a, b = weiuser微信用户地址.objects.filter(id_主键_配送地址=idKey).delete()
+        weiuser微信用户地址.objects.filter(id_主键_配送地址=idKey).delete()
         查询当前用户的全部地址 = weiuser微信用户地址.objects.filter(mini_openid=self_mini_openid,
             mini_unionid=self_mini_unionid).values(
             "id_主键_配送地址", "id_str", "address", "isDefaultAddress")
@@ -170,23 +163,19 @@ class 用户配送地址ViewSets(ViewSet):
         idKey = request.data.get("idKey", None)
         self_mini_openid = request.data.get("self_mini_openid", None)
         self_mini_unionid = request.data.get("self_mini_unionid", None)
+        print("这里没有拿值的是吗", self_mini_openid, self_mini_unionid, idKey)
         addressData = weiuser微信用户地址.objects.get(id_主键_配送地址=idKey).address
-        self.update更新用户手机号码方法(address=addressData,
+        self.update更新用户手机号码方法(address=addressData, self_user_unionid=self_mini_unionid)
-            self_mini_openid=self_mini_openid,
+        self.send前端发送最新用户数据(self_mini_unionid=self_mini_unionid)
-            self_user_unionid=self_mini_unionid)
-        self.update更新用户头像事件(self_mini_unionid=self_mini_unionid)
         
         # 将所有的先更新为非默认地址
         weiuser微信用户地址.objects.filter(mini_unionid=self_mini_unionid, mini_openid=self_mini_openid).update(
             isDefaultAddress=weiuser微信用户地址.choicesAddress.不是默认地址.value)
-        weiuser微信用户地址.objects.filter(id_主键_配送地址=idKey, mini_unionid=self_mini_unionid,
+        weiuser微信用户地址.objects.filter(id_主键_配送地址=idKey, mini_unionid=self_mini_unionid, mini_openid=self_mini_openid).update(
-            mini_openid=self_mini_openid).update(
             isDefaultAddress=weiuser微信用户地址.choicesAddress.是默认地址.value)
         查询当前用户的全部地址 = weiuser微信用户地址.objects.filter(mini_unionid=self_mini_unionid,
-            mini_openid=self_mini_openid).values(
+            mini_openid=self_mini_openid).values("id_主键_配送地址", "id_str", "address", "isDefaultAddress")
-            "id_主键_配送地址", "id_str", "address", "isDefaultAddress")
+        httpResData = BaseResponse(resData=ResData(listData=查询当前用户的全部地址, dictData={"demo": "xiaozizi"}), ).model_dump()
-        httpResData = BaseResponse(
-            resData=ResData(listData=查询当前用户的全部地址, dictData={"demo": "xiaozizi"}), ).model_dump()
         return Response(data=httpResData, status=status.HTTP_200_OK)
     
     @action(detail=False, methods=["post"], url_path="update")
@@ -201,51 +190,16 @@ class 用户配送地址ViewSets(ViewSet):
         对象是否存在 = weiuser微信用户地址.objects.filter(address=addressData,
             mini_unionid=self_mini_unionid,
             mini_openid=self_mini_openid).exists()
-        self.update更新用户头像事件(self_mini_unionid=self_mini_unionid)
+        self.send前端发送最新用户数据(self_mini_unionid=self_mini_unionid)
         if 对象是否存在:
             # 说明用户当前是存在的啦(说明,addressData)是有相同的值存在的
             查询当前用户的全部地址 = weiuser微信用户地址.objects.filter(mini_unionid=self_mini_unionid,
-                mini_openid=self_mini_openid).values(
+                mini_openid=self_mini_openid).values("id_主键_配送地址", "id_str", "address", "isDefaultAddress")
-                "id_主键_配送地址", "id_str", "address", "isDefaultAddress")
+            httpResData = BaseResponse(resData=ResData(listData=查询当前用户的全部地址, dictData={"demo": "没有更新"}), ).model_dump()
-            httpResData = BaseResponse(
-                resData=ResData(listData=查询当前用户的全部地址, dictData={"demo": "没有更新"}), ).model_dump()
             return Response(data=httpResData, status=status.HTTP_200_OK)
         else:
             weiuser微信用户地址.objects.filter(id_主键_配送地址=idkey).update(address=addressData)
             查询当前用户的全部地址 = weiuser微信用户地址.objects.filter(mini_unionid=self_mini_unionid,
-                mini_openid=self_mini_openid).values(
+                mini_openid=self_mini_openid).values("id_主键_配送地址", "id_str", "address", "isDefaultAddress")
-                "id_主键_配送地址", "id_str", "address", "isDefaultAddress")
+            httpResData = BaseResponse(resData=ResData(listData=查询当前用户的全部地址, dictData={"demo": "xiaozizi"}), ).model_dump()
-            httpResData = BaseResponse(
-                resData=ResData(listData=查询当前用户的全部地址, dictData={"demo": "xiaozizi"}), ).model_dump()
             return Response(data=httpResData, status=status.HTTP_200_OK)
-    
-    @action(detail=False, methods=["post"], url_path="locating")
-    def 解析用户的定位(self, request: Request):
-        """"""
-        self_user_unionid = request.data.get("self_user_unionid", None)
-        self_mini_openid = request.data.get("self_mini_openid", None)
-        result = request.data.get("result", None)
-        errMsg = jmespath.search(data=result, expression="errMsg")
-        latitude = jmespath.search(data=result, expression="latitude")
-        longitude = jmespath.search(data=result, expression="longitude")
-        speed = jmespath.search(data=result, expression="speed")
-        accuracy = jmespath.search(data=result, expression="accuracy")
-        altitude = jmespath.search(data=result, expression="altitude")
-        verticalAccuracy = jmespath.search(data=result, expression="verticalAccuracy")
-        horizontalAccuracy = jmespath.search(data=result, expression="horizontalAccuracy")
-        res = wei地图工具.经纬度转换为地址(location=f"{latitude},{longitude}")
-        standard_address = jmespath.search(data=res, expression="result.formatted_addresses.standard_address")
-        省 = jmespath.search(data=res, expression="result.address_component.province")
-        市 = jmespath.search(data=res, expression="result.address_component.city")
-        区 = jmespath.search(data=res, expression="result.address_component.district")
-        # 再计算一下距离
-        起点数据: OriginPointOptional = {"经度": f"{longitude}", "纬度": f"{latitude}", }
-        终点数据: OriginPointOptional = {"经度": str(longitude), "纬度": str(latitude)}
-        两地相多少公里 = wei地图工具.腾讯地图计算二点之间的距离(toData终点=终点数据, fromData起点=起点数据)
-        # print(f"两地相距了{两地相多少公里 / 1000}公里", type(两地相多少公里))
-        weiuser地图定位.objects.update_or_create(
-            map用户openid=self_mini_openid, map用户uniond=self_user_unionid, map两点距离=两地相多少公里,
-            map原点经纬度=起点数据, map终点经纬度=终点数据, map纬度latitude=latitude, map经度longitude=longitude,
-            map省=省, map市=市, map区=区)
-        httpResData = BaseResponse(resData=ResData(listData=[""], dictData={"demo": "xiaozizi"}), ).model_dump()
-        return Response(data=httpResData, status=status.HTTP_200_OK)

wechat_mini_服务端接口目录/小程序码与小程序链接口列表/scheme码接口.py

@@ -19,10 +19,9 @@ class Scheme接口ViewSets(ViewSet):
         """"""
         self_mini_openid = request.data.get("self_mini_openid", None)
         self_mini_unionid = request.data.get("self_mini_unionid", None)
-
         httpResData = BaseResponse(resData=ResData(listData=[""], dictData={"demo": "xiaozizi"}), ).model_dump()
         return Response(data=httpResData, status=status.HTTP_200_OK)
-
+    
     @action(detail=False, methods=["get", "post", "put", "delete"], url_path="generatescheme")
     def 获取加密scheme码(self, request: Request):
         """该接口用于获取小程序 scheme 码，适用于短信、邮件、外部网页、微信内等拉起小程序的业务场景。"""
@@ -36,12 +35,12 @@ class Scheme接口ViewSets(ViewSet):
                 "jump_wxa": {
                     "path": "/pageTabBar/Home/Home",
                     "query": f"superior_unionid={self_mini_unionid}",
-                },
+                    },
                 "is_expire": True,  # 这里好像是必须要填的
                 "expire_interval": 30,  # 有效天数，1-30天
                 "expire_type": 1
-            }
+                }
-        )
+            )
         print(schemeData.json())
         openlink = pydash.get(obj=schemeData.json(), path="openlink")
         print("生成的小程序 scheme 码", openlink)

wechat_mini_服务端接口目录/物流账号邮政/物流账号接口.py

@@ -1,361 +0,0 @@
-import time
-from datetime import datetime
-from typing import Literal
-from zoneinfo import ZoneInfo
-
-import orjson
-import pydash
-import requests
-from django.core.handlers.wsgi import WSGIRequest
-from django.db.models import QuerySet
-from django.forms import model_to_dict
-from pydantic import BaseModel, Field
-from rest_framework import status
-from rest_framework.decorators import action
-from rest_framework.request import Request
-from rest_framework.response import Response
-from rest_framework.viewsets import ViewSet
-from ulid import ULID
-
-from sixGuoDjango import BaseResponse, ResData
-from wechat_token.token工具包 import sixToken
-from wechat_数据库.支付订单数据库.商品订单数据 import order订单
-
-
-class ems物流状态更新模型(BaseModel):
-    """物流状态更新请求模型"""
-
-    biz_id: Literal["test_biz_id", "1100244903172"] = Field(..., description="业务ID，仅允许 xiao 或 zizi")
-    order_id: str = Field(..., description="商家生成的订单号")
-    delivery_id: Literal["EMS"] = Field(..., description="配送商ID（如 TEST、EMS）")
-    waybill_id: str = Field(..., description="物流订单号")
-    action_time: int = Field(..., description="更新时间戳（秒级）")
-    action_type: int = Field(..., description="操作类型编码")
-    action_msg: str = Field(..., description="操作描述")
-
-
-class EMS物流ViewSets(ViewSet):
-    ems_biz_id = "1100244903172"
-    ems_delivery_id = "EMS"
-    ems_password = "xiao792282"
-
-    def ems发件人信息(self):
-        ems发件人信息数据 = {
-            "name": "六果泡泡",  # 否	发/收件人姓名，不超过64字节
-            "tel": "18860891975",  # string	否	发/收件人座机号码，若不填写则必须填写 mobile，不超过32字节
-            "mobile": "18860891970",  # string	否	发/收件人手机号码，若不填写则必须填写 tel，不超过32字节
-            "company": "江苏六果科技有限公司",  # string	否	发/收件人公司名称，不超过64字节
-            "post_code": "225300",  # string	否	发/收件人邮编，不超过10字节
-            "country": "中国",  # string	否	发/收件人国家，不超过64字节
-            "province": "江苏省",  # string	否	发/收件人省份，比如："广东省"，不超过64字节
-            "city": "泰州市",  # string	否	发/收件人市/地区，比如："广州市"，不超过64字节
-            "area": "海陵区",  # string	否	发/收件人区/县，比如："海珠区"，不超过64字节
-            "address": "",  # string	否	发/收件人详细地址，比如："XX路XX号XX大厦XX"，不超过512 字节
-            }
-        return ems发件人信息数据
-
-    def ems收件人信息(self, order订单号):
-        订单对象 = order订单.objects.get(order物流订单号=order订单号)
-        orderData = model_to_dict(instance=订单对象, fields=None)
-        provinceName = pydash.get(obj=orderData, path="order用户配送地址.address.provinceName")
-        cityName = pydash.get(obj=orderData, path="order用户配送地址.address.cityName")  # 市
-        countyName = pydash.get(obj=orderData, path="order用户配送地址.address.countyName")  # 区
-        detailInfoNew = pydash.get(obj=orderData, path="order用户配送地址.address.detailInfoNew")  # 详细地址
-        telNumber = pydash.get(obj=orderData, path="order用户配送地址.address.telNumber")  # 详细地址
-        detailInfo = pydash.get(obj=orderData, path="order用户配送地址.address.detailInfo")  # 详细地址
-        userName = pydash.get(obj=orderData, path="order用户配送地址.address.userName")  # 详细地址
-        nationalCode = pydash.get(obj=orderData, path="order用户配送地址.address.nationalCode")  # 详细地址
-        print("\n🍎 🍏 🍊 🍎 🍏 🍊 🍎 🍏 🍊 🍎 🍏 🍊 🍎 🍏 \n", telNumber)
-        return {
-            "name": userName,  # 否	发/收件人姓名，不超过64字节
-            "tel": telNumber,  # string	否	发/收件人座机号码，若不填写则必须填写 mobile，不超过32字节
-            "mobile": telNumber,  # string	否	发/收件人手机号码，若不填写则必须填写 tel，不超过32字节
-            "company": "",  # string	否	发/收件人公司名称，不超过64字节
-            "post_code": nationalCode,  # string	否	发/收件人邮编，不超过10字节
-            "country": "中国",  # string	否	发/收件人国家，不超过64字节
-            "province": provinceName,  # string	否	发/收件人省份，比如："广东省"，不超过64字节
-            "city": cityName,  # string	否	发/收件人市/地区，比如："广州市"，不超过64字节
-            "area": countyName,  # string	否	发/收件人区/县，比如："海珠区"，不超过64字节
-            "address": detailInfoNew,  # string	否	发/收件人详细地址，比如："XX路XX号XX大厦XX"，不超过512 字节
-            }
-
-    def cargo包裹信息(self):
-        return {
-            "count": 1,  # number	是	包裹数量, 默认为1
-            "weight": 4,  # number	是	货物总重量，比如1.2，单位是千克(kg)
-            "space_x": 1,  # number	是	货物长度，比如20.0，单位是厘米(cm)
-            "space_y": 1,  # number	是	货物宽度，比如15.0，单位是厘米(cm)
-            "space_z": 1,  # number	是	货物高度，比如10.0，单位是厘米(cm)
-            "detail_list": [
-                {
-                    "name": "商品名称",  # string	是	商品名，不超过128字节
-                    "count": 1,  # number	是	商品数量
-                    },
-                ],
-            }
-
-    def shop商品信息(self, order订单号):
-        订单对象 = order订单.objects.get(order物流订单号=order订单号)
-        orderData = model_to_dict(instance=订单对象, fields=None)
-        购物车商品列表: QuerySet[order订单商品数据] = order订单商品数据.objects.filter(wai_订单=订单对象)
-        print(购物车商品列表)
-        detail_list = []
-        for goods in 购物车商品列表:
-            商品数据 = model_to_dict(instance=goods, fields=None, exclude=None)
-            detail_list.append(
-                {
-                    "goods_name": pydash.get(obj=商品数据, path="order_商品标题"),
-                    "goods_img_url": pydash.get(obj=商品数据, path="order_商品详情图片.主图.0"),
-                    "goods_desc": "",
-                    },
-                )
-        goods_count = pydash.get(obj=orderData, path="order购物车商品数量")
-        shop商品信息数据 = {
-            "wxa_path": "/pages/OrderPages/OrderPages",  # string	否	商家小程序的路径，建议为订单页面
-            # "img_url": "",  # string	否	商品缩略图 url；shop.detail_list为空则必传，shop.detail_list非空可不传。
-            # "goods_name": "",  # string	否	商品名称, 不超过128字节；shop.detail_list为空则必传，shop.detail_list非空可不传。
-            # goods_count   否	商品详情列表，适配多商品场景，用以消息落地页展示。（新规范，新接入商家建议用此字段）
-            "goods_count": goods_count,  # 商品数量；shop.detail_list为空则必传。shop.detail_list非空可不传，默认取shop.detail_list的size
-            "detail_list": detail_list,
-            }
-        return shop商品信息数据
-
-    def insured保价信息(self):
-        insured保价信息数据 = {
-            "use_insured": 0,  # number	否	是否保价，0 表示不保价，1 表示保价
-            "insured_value": 0,  # number	否	保价金额，单位是分，比如: 10000 表示 100 元
-            }
-        return insured保价信息数据
-
-    def service服务类型(self):
-        service服务类型数据 = {
-            "service_type": 6,  # number	是	服务类型ID，详见已经支持的快递公司基本信息
-            "service_name": "标准快递",  # string	是	服务名称，详见已经支持的快递公司基本信息
-            }
-        return service服务类型数据
-
-    def 生成最终完整的数据(self, order物流订单号):
-        订单对象 = order订单.objects.get(order物流订单号=order物流订单号)
-        orderData = model_to_dict(instance=订单对象, fields=None)
-        order_id = pydash.get(obj=orderData, path="order物流订单号")
-        收件人openid = pydash.get(obj=orderData, path="order支付者openid")
-        print("\n🍎 🍏 🍊 🍎 🍏 🍊 🍎 🍏 🍊 🍎 🍏 🍊 🍎 🍏 \n", self.ems发件人信息())
-        完整数据 = {
-            "add_source": 0,
-            "order_id": order_id,
-            "openid": 收件人openid,
-            "delivery_id": "TEST",
-            "biz_id": "test_biz_id",
-            "custom_remark": "易碎物品",
-            "sender": self.ems收件人信息(order订单号=order物流订单号),  # 收件人的信息
-            "receiver": self.ems发件人信息(),  # 发件人的信息
-            "shop": self.shop商品信息(order订单号=order物流订单号),  # 商品的信息
-            "cargo": self.cargo包裹信息(),  # 包果的信息
-            "insured": self.insured保价信息(),  # 保价信息
-            "service": self.service服务类型(),  # 服务类型
-            }
-        return 完整数据
-
-    @action(detail=False, methods=["get", "post", "put", "delete"], url_path="bindAccount")
-    def 绑定账号(self, request: WSGIRequest | Request):
-        """"""
-        mini_token = sixToken.get_mini_token()
-        uri = f"https://api.weixin.qq.com/cgi-bin/express/business/account/bind?access_token={mini_token}"
-        ems数据 = {
-            "type": "bind",
-            "biz_id": "1100244903172",
-            "delivery_id": "EMS",
-            "password": "xiao@792282",
-            }
-        data = requests.post(url=uri, json=ems数据)
-        print("🍎 🍏 🍊 🍎 🍏 🍊 绑定账号🍎 🍏 🍊 🍎 🍏 🍊 🍎 🍏 ", data.json())
-        httpResData = BaseResponse(resData=ResData(listData=[""], dictData={"demo": "xiaozizi"}), ).model_dump()
-        return Response(data=httpResData, status=status.HTTP_200_OK)
-
-    @action(detail=False, methods=["get", "post", "put", "delete"], url_path="unbindAccount")
-    def 解绑账号(self, request: WSGIRequest | Request):
-        """"""
-        mini_token = sixToken.get_mini_token()
-        uri = f"https://api.weixin.qq.com/cgi-bin/express/business/account/bind?access_token={mini_token}"
-        ems数据 = {
-            "type": "unbind",
-            "biz_id": "1100244903172",
-            "delivery_id": "EMS",
-            "password": "xiao@792282",
-            }
-        data = requests.post(url=uri, json=ems数据)
-        print("🍎 🍏 🍊 🍎 🍏 🍊 🍎 🍏 🍊 🍎 🍏 🍊 🍎 🍏 ", data.json())
-        httpResData = BaseResponse(resData=ResData(listData=[""], dictData={"demo": "xiaozizi"}), ).model_dump()
-        return Response(data=httpResData, status=status.HTTP_200_OK)
-
-    @action(detail=False, methods=["post", ], url_path="getAllDelivery")
-    def 获取支持的快递公司列表(self, request: Request):
-        """"""
-        self_user_unionid = request.data.get("self_user_unionid", None)
-        self_mini_openid = request.data.get("self_mini_openid", None)
-        mini_token = sixToken.get_mini_token()
-        uri = f"https://api.weixin.qq.com/cgi-bin/express/business/delivery/getall?access_token={mini_token}"
-        data = requests.get(url=uri, )
-        emdData = orjson.loads(data.content.decode(encoding="utf-8"))
-        httpResData = BaseResponse(resData=ResData(listData=[""], dictData=emdData), ).model_dump()
-        return Response(data=httpResData, status=status.HTTP_200_OK)
-
-    @action(detail=False, methods=["post", ], url_path="getAllAccount")
-    def 获取所有绑定的物流账号(self, request: Request):
-        """"""
-        self_user_unionid = request.data.get("self_user_unionid", None)
-        self_mini_openid = request.data.get("self_mini_openid", None)
-        mini_token = sixToken.get_mini_token()
-        uri = f"https://api.weixin.qq.com/cgi-bin/express/business/account/getall?access_token={mini_token}"
-        data = requests.get(url=uri)
-        print(orjson.loads(
-            orjson.dumps(data.content.decode(encoding="utf-8"), option=orjson.OPT_SORT_KEYS, ).decode(
-                encoding="utf-8")))
-        返回数据 = orjson.loads(data.content.decode(encoding="utf-8"))
-        print(返回数据, type(返回数据))
-        print(orjson.loads(data.content.decode(encoding="utf-8")))
-        httpResData = BaseResponse(resData=ResData(listData=[""], dictData=返回数据), ).model_dump()
-        return Response(data=httpResData, status=status.HTTP_200_OK)
-
-    @action(detail=False, methods=["get", "post", "put", "delete"], url_path="addOrder")
-    def 生成运单(self, request: Request):
-        """"""
-        # 需要的参数
-        order物流订单号 = request.data.get("order物流订单号", None)
-        print(order物流订单号, "这里没有值的吗")
-        order订单对象 = order订单.objects.get(order物流订单号=order物流订单号)
-        res = self.生成最终完整的数据(order物流订单号=order物流订单号)
-        print("\n🍎 🍏 🍊 🍎 🍏 🍊 🍎order物流订单号order物流订单号 🍏 🍊 🍎 🍏 🍊 🍎 🍏 \n", order物流订单号)
-        mini_token = sixToken.get_mini_token()
-        运单请求接口 = f"https://api.weixin.qq.com/cgi-bin/express/business/order/add?access_token={mini_token}"
-        json_完整的数据 = orjson.dumps(res).decode(encoding="utf-8")
-        data = requests.post(url=运单请求接口, data=json_完整的数据, )
-        print("请求生成运单的接口,生成数据", data.json())
-        waybill_id = pydash.get(obj=data.json(), path="waybill_id")
-        更新订单对象 = order订单.objects.get(order物流订单号=order物流订单号)
-        更新订单对象.order物流公司订单编号 = waybill_id
-        # 更新订单对象.order物流数据 = 物流订单默认数据
-        更新订单对象.save()
-        # print( "🍎 🍏 🍊 🍎 🍏 🍊 🍎 🍏 🍊 🍎 🍏 🍊 🍎 🍏 运单返回数据", data.json( ) )
-        httpResData = BaseResponse(resData=ResData(listData=[""], dictData={}), ).model_dump()
-        return Response(data=httpResData, status=status.HTTP_200_OK)
-
-    @action(detail=False, methods=["get", "post", "put", "delete"], url_path="testUpdateOrder")
-    def 模拟更新订单状态(self, request: Request):
-        """"""
-        self_user_unionid = request.data.get("self_user_unionid", None)
-        self_mini_openid = request.data.get("self_mini_openid", None)
-        order物流公司订单编号 = request.data.get("order物流公司订单编号", None)
-        order物流订单号 = request.data.get("order物流订单号", None)
-        print(order物流公司订单编号, order物流订单号, "为什么这里没有值啊")
-        mini_token = sixToken.get_mini_token()
-        utcDate = datetime.now(tz=ZoneInfo("utc"))
-        timestamp = int(datetime.now(tz=ZoneInfo("Asia/Shanghai")).timestamp())
-        milliseconds_int = ULID().milliseconds
-        模拟更新物流状态 = f"https://api.weixin.qq.com/cgi-bin/express/business/test_update_order?access_token={mini_token}"
-        模拟数据_揽件成功 = {
-            "biz_id": "test_biz_id",
-            "order_id": order物流订单号,  # 商家生成的订单号
-            "delivery_id": "TEST",  #
-            "waybill_id": order物流公司订单编号,  # 物流订单号
-            "action_time": int(time.time()),  # 这里是更新发的时间戳
-            "action_type": 100001,
-            "action_msg": "揽件阶段-揽件成功",
-            }
-        模拟数据_分配业务员 = {
-            "biz_id": "test_biz_id",
-            "order_id": order物流订单号,  # 商家生成的订单号
-            "delivery_id": "TEST",  #
-            "waybill_id": order物流公司订单编号,  # 物流订单号
-            "action_time": int(time.time()),  # 这里是更新发的时间戳
-            "action_type": 100003,
-            "action_msg": "揽件阶段-分配业务员",
-            }
-        模拟数据_更新运输轨迹 = {
-            "biz_id": "test_biz_id",
-            "order_id": order物流订单号,  # 商家生成的订单号
-            "delivery_id": "TEST",  #
-            "waybill_id": order物流公司订单编号,  # 物流订单号
-            "action_time": int(time.time()),  # 这里是更新发的时间戳
-            "action_type": 200001,
-            "action_msg": "运输阶段-更新运输轨迹",
-            }
-        模拟数据_开始派送 = {
-            "biz_id": "test_biz_id",
-            "order_id": order物流订单号,  # 商家生成的订单号
-            "delivery_id": "TEST",  #
-            "waybill_id": order物流公司订单编号,  # 物流订单号
-            "action_time": int(time.time()),  # 这里是更新发的时间戳
-            "action_type": 300002,
-            "action_msg": "派送阶段-开始派送",
-            }
-        模拟数据_签收成功 = {
-            "biz_id": "test_biz_id",
-            "order_id": order物流订单号,  # 商家生成的订单号
-            "delivery_id": "TEST",  #
-            "waybill_id": order物流公司订单编号,  # 物流订单号
-            "action_time": int(time.time()),  # 这里是更新发的时间戳
-            "action_type": 300003,
-            "action_msg": "派送阶段-签收成功",
-            }
-
-        data = requests.post(url=模拟更新物流状态,
-                             data=orjson.dumps(模拟数据_揽件成功, option=orjson.OPT_SORT_KEYS, ).decode(encoding="utf-8"))
-        print("🍎 🍏 🍊 🍎 🍏 模拟更新物流状态 🍎 ", data.json())
-        httpResData = BaseResponse(resData=ResData(listData=[""], dictData={"demo": "xiaozizi"}), ).model_dump()
-        return Response(data=httpResData, status=status.HTTP_200_OK)
-
-    @action(detail=False, methods=["get", "post", "put", "delete"], url_path="getpath")
-    def 查询运单轨迹(self, request: Request):
-        """查询当前物流订单的轨迹"""
-        self_mini_openid = request.data.get("self_mini_openid", None)
-        self_mini_unionid = request.data.get("self_mini_unionid", None)
-        mini_token = sixToken.get_mini_token()
-        uri = f"https://api.weixin.qq.com/cgi-bin/express/business/path/get?access_token={mini_token}"
-        order物流订单号 = request.data.get("order物流订单号", None)
-        order物流公司订单编号 = request.data.get("order物流公司订单编号", None)
-        postData = requests.post(url=uri, json={"openid": self_mini_openid, "delivery_id": self.ems_delivery_id,
-                                                "waybill_id": order物流公司订单编号})
-        print(postData.json())
-        print("\n🍎 🍏 🍊 🍎 🍏 🍊 🍎 🍏 🍊物流订单查询接口", order物流公司订单编号, order物流订单号)
-        httpResData = BaseResponse(resData=ResData(listData=[""], dictData=postData.json()), ).model_dump()
-        return Response(data=httpResData, status=status.HTTP_200_OK)
-
-    @action(detail=False, methods=["get", "post", "put", "delete"], url_path="update_logistics_information")
-    def 更新物流快递数据(self, request: Request):
-        """这个接口:相当于实时查询当前的 物流的轨迹"""
-        waybill_id = request.data.get("waybill_id", "生成的运单号")
-        order物流公司订单编号 = request.data.get("order物流公司订单编号", None)
-        order物流订单号 = request.data.get("order物流订单号", None)
-        print(order物流公司订单编号, "\n🍎 🍏 🍊 🍎 🍏 🍊 🍎 🍏 🍊 🍎 🍏 🍊 🍎 🍏 \n", waybill_id)
-        查询对象 = order订单.objects.get(order物流公司订单编号=order物流公司订单编号, order物流订单号=order物流订单号)
-        print("查询对象", 查询对象)
-        mini_token = sixToken.get_mini_token()
-        emsGetPathData = requests.post(url="https://api.weixin.qq.com/cgi-bin/express/business/path/get",
-                                       params={"access_token": mini_token, },
-                                       json={
-                                           "openid": 查询对象.order支付者openid,
-                                           "delivery_id": "TEST", "waybill_id": 查询对象.order物流公司订单编号,
-                                           },
-                                       )
-        print(orjson.loads(emsGetPathData.content.decode(encoding="utf-8")), "=================")
-        resData = orjson.loads(emsGetPathData.content.decode(encoding="utf-8"))
-        查询对象.order物流数据 = resData
-        查询对象.save()
-
-        httpResData = BaseResponse(resData=ResData(listData=[""], dictData={"demo": "xiaozizi"}), ).model_dump()
-        return Response(data=httpResData, status=status.HTTP_200_OK)
-
-    @action(detail=False, methods=["post"], url_path="确认收货")
-    def 确认收货(self, request: Request):
-        """"""
-        print(
-            "确认收货请求进来了确认收货请求进来了确认收货请求进来了确认收货请求进来了确认收货请求进来了确认收货请求进来了确认收货请求进来了确认收货请求进来了确认收货请求进来了确认收货请求进来了确认收货请求进来了确认收货请求进来了")
-        order物流公司订单编号 = request.data.get("order物流公司订单编号", None)
-        order物流订单号 = request.data.get("order物流订单号", None)
-        订单更新对象 = order订单.objects.get(order物流公司订单编号=order物流公司订单编号,
-                                             order物流订单号=order物流订单号)
-        订单更新对象.order物流状态 = order订单.order订单choosies物流状态.待评价.value
-        订单更新对象.save()
-        httpResData = BaseResponse(resData=ResData(listData=[], dictData={}), ).model_dump()
-        return Response(data=httpResData, status=status.HTTP_200_OK)

wechat_mini_服务端接口目录/用工关系接口列表/用工关系接口.py

@@ -19,7 +19,6 @@ class 用工关系接口ViewSets(ViewSet):
     def 推送用工消息(self, request: Request):
         """"""
         mini_token = sixToken.get_mini_token()
-        
         template_content = {
             "data": {  # ⚠️ 这个外层 "data" 是微信接口强制要求的嵌套结构
                 "thing1": {"value": "aaaaaaa"},  # 替换为模板实际字段名
@@ -48,14 +47,14 @@ class 用工关系接口ViewSets(ViewSet):
         self_mini_unionid = request.data.get("self_mini_unionid", None)
         openid_list = request.data.get("openid_list", None)
         wecom_token = sixToken.get_wecom_token()
-        infoData = requests.post(url="https://api.weixin.qq.com/wxa/business/unbinduserb2cauthinfo", params={"access_token": wecom_token, }, json={"openid_list": ["oL7T268t3zlOb64IvrN64-XXXXXX"]}, )
+        infoData = requests.post(url="https://api.weixin.qq.com/wxa/business/unbinduserb2cauthinfo", params={"access_token": wecom_token, },
+            json={"openid_list": [self_mini_openid, ]}, )
         print(infoData.json())
         httpResData = BaseResponse(resData=ResData(listData=[""], dictData={"demo": "xiaozizi"}), ).model_dump()
         return Response(data=httpResData, status=status.HTTP_200_OK)
     
     @action(detail=False, methods=["get", "post", "put", "delete"], url_path="绑定用工关系")
     def 绑定用工关系(self, request: Request):
-        pass
         """绑定用工关系, 前端调用成功了, 就会发送请求到本接口,我们只需要更新一下weiuser数据信息就可以了"""
         self_mini_openid = request.data.get("self_mini_openid", None)
         self_mini_unionid = request.data.get("self_mini_unionid", None)
@@ -63,7 +62,6 @@ class 用工关系接口ViewSets(ViewSet):
         print("开始绑定用工关系了")
         if six六果对象.user_绑定用工关系 == miniUser用户角色().用工关系已绑定:
             six_data_user = model_to_dict(instance=six六果对象, fields=None, exclude=None)
-            print("这里的状态为原来已经绑定用工关系了")
             return Response(data=six_data_user)
         else:
             six六果对象.user_绑定用工关系 = miniUser用户角色().用工关系已绑定

wechat_token/token工具包.py

@@ -33,10 +33,11 @@ class sixToken:
     wechat_appid = "wx654fffabd4b1f5cf"  # TODO 服务号的测试的
     # wechat_appsecret = "1c76fbfea91f36bede14e2cf2dc756dc"  #TODO 服务号的appsecret
     wechat_appsecret = "b1017a44b93fb08ae95b408fd19ff9d9"  # 服务号测试的appsecret
-
+    
     @classmethod
     def get_wecom_token(cls):
         """"""
+        print("每次都会被调用的wecom")
         查询对象, 是否存在 = weitoken.objects.get_or_create(token_name="wecom_token")
         if 查询对象.token_value is None:
             print("为空,get_wecom_token 新调用一下")
@@ -52,7 +53,7 @@ class sixToken:
             else:
                 return 查询对象.token_value
         return 查询对象.token_value
-
+    
     @classmethod
     def get_wecom_tick(cls):
         pass
@@ -73,7 +74,7 @@ class sixToken:
                 print("在有效时间内")
                 return 查询对象.tick_value
         return 查询对象.tick_value
-
+    
     @classmethod
     def mini_token(cls):
         """"""
@@ -84,7 +85,7 @@ class sixToken:
         小程序token: str = jmespath.search(data=token, expression="access_token", )
         返回对象, _ = weitoken.objects.update_or_create(token_name="mini_token", defaults={"token_value": 小程序token})
         return 返回对象
-
+    
     @classmethod
     def get_mini_token(cls):
         """
@@ -92,6 +93,7 @@ class sixToken:
         :return:
         :rtype:
         """
+        print("是不是每次都在调用的吗")
         查询对象, 是否存在 = weitoken.objects.get_or_create(token_name="mini_token")
         if 查询对象.token_value is None:
             创建的新对象 = cls.mini_token()
@@ -106,7 +108,7 @@ class sixToken:
             else:
                 return 查询对象.token_value
         return None
-
+    
     @classmethod
     def token统一调服务号(cls):
         """获取了六果服务号的token:注意不是授权时的token"""
@@ -122,11 +124,11 @@ class sixToken:
         ticket服务号 = pydash.get(obj=json_data, path="ticket", default=None)
         返回对象, _ = weitoken.objects.update_or_create(token_name="mini_token", defaults={"token_value": wechat_token服务号, "tick_value": ticket服务号})
         return 返回对象
-
+    
     @classmethod
     def get_wechat_token(cls):
         """"""
-
+        
         查询对象, 是否存在 = weitoken.objects.get_or_create(token_name="wechat_token")
         if 查询对象.token_value is None:
             print("为空,所以需要重 新调用一下")
@@ -143,7 +145,7 @@ class sixToken:
                 print("在有效时间内")
                 return 查询对象.token_value
         return None
-
+    
     @classmethod
     def get_wechat_tick_token(cls):
         查询对象, 是否存在 = weitoken.objects.get_or_create(token_name="wechat_token")
@@ -162,7 +164,7 @@ class sixToken:
                 print("在有效时间内")
                 return 查询对象.tick_value
         return None
-
+    
     @classmethod
     def token统一调用企微获取接口(cls):
         """手机端的token"""
@@ -183,7 +185,7 @@ class sixToken:
             "phone_token_value": phone_token, "token_value": 企微token, "tick_value": wecom_tick_data,
             })
         return 返回对象
-
+    
     @classmethod
     def get_weom_phone_token(cls):
         查询对象, 是否存在 = weitoken.objects.get_or_create(token_name="wecom_token")
@@ -202,7 +204,7 @@ class sixToken:
                 print("在有效时间内")
                 return 查询对象.phone_token_value
         return None
-
+    
     @classmethod
     def 服务号网页授权TOKEN(cls, code: str):
         """用户授权时,需要的token;

wechat_wecom_企业微信管理/客户管理/客户管理接口.py

@@ -15,10 +15,7 @@ class 客户管理接口ViewSets(ViewSet):
     @action(detail=False, methods=["post"], url_path="获取当前企微员工所有添加的客户列表")
     def 获取当前企微员工所有添加的客户列表(self, request: Request):
         """"""
-        userid = request.data.get("userid", None)
-        print("获取当前企微员工所有添加的客户列表获取当前企微员工所有添加的客户列表获取当前企微员工所有添加的客户列表获取当前企微员工所有添加的客户列表获取当前企微员工所有添加的客户列表")
         get_data = wecom客户好友管理().获取客户列表(userid="YuanBao1975")
-        print(get_data)
         httpResData = BaseResponse(resData=ResData(listData=[""], dictData=get_data), ).model_dump()
         return Response(data=httpResData, status=status.HTTP_200_OK)
     

wechat_微信支付证书/江苏六果科技有限公司支付证书/六果公司支付类.py

@@ -31,30 +31,30 @@ django.setup()
 
 
 class sixWechatPay六果泡泡支付(BaseModel):
-    mchid: str = Field("1700383419", alias="商户号", description="微信支付商户号")
+    mchid: str = Field(default="1700383419", alias="商户号", description="微信支付商户号")
-    appid: str = Field("wxf612e825377328f0", alias="商户号", description="微信支付商户号")
+    appid: str = Field(default="wxf612e825377328f0", alias="商户号", description="微信支付商户号")
-    api_v3_key: str = Field("YWMGAIPTJTWZN4YB3YUTHWK34K9U9M1W", alias="APIv3密钥", description="用于回调解密")
+    api_v3_key: str = Field(default="YWMGAIPTJTWZN4YB3YUTHWK34K9U9M1W", alias="APIv3密钥", description="用于回调解密")
-    api_v2_key: Optional[SecretStr] = Field("OXRNKGGUYHGNJSSIHKFGVMAAOHRPXJAT", alias="APIv2密钥", description="仅老接口需要")
+    api_v2_key: str = Field(default="OXRNKGGUYHGNJSSIHKFGVMAAOHRPXJAT", alias="APIv2密钥", description="仅老接口需要")
-    serial_no商户证书的序列号: str = Field("530160D54E8F56726F506DEE40D7FA49A558E8E0", description="商户证书的序列号")
+    serial_no商户证书的序列号: str = Field(default="530160D54E8F56726F506DEE40D7FA49A558E8E0", description="商户证书的序列号")
     # ---------- 小程序密钥 ----------
-    mini_program_app_secret: SecretStr = Field("8691f774e3c0c5a876b21a3e84109ef0", alias="小程序AppSecret")
+    mini_program_app_secret: SecretStr = Field(default="8691f774e3c0c5a876b21a3e84109ef0", alias="小程序AppSecret")
     
     # ---------- 商户API密钥对（用于签名请求） ----------
-    merchant_private_key_pem: str = Field(Path(settings.BASE_DIR).joinpath("wechat_微信支付证书/江苏六果科技有限公司支付证书/apiclient_key.pem").read_text(), alias="商户私钥PEM", description="apiclient_key.pem 内容")
+    merchant_private_key_pem: str = Field(default=Path(settings.BASE_DIR).joinpath("wechat_微信支付证书/江苏六果科技有限公司支付证书/apiclient_key.pem").read_text(), alias="商户私钥PEM", description="apiclient_key.pem 内容")
-    merchant_public_key_pem: str = Field(Path(settings.BASE_DIR).joinpath("wechat_微信支付证书/江苏六果科技有限公司支付证书/微信支付公钥.pem").read_text(), alias="商户公钥PEM", description="apiclient_cert.pem 内容（很少用到）")
+    merchant_public_key_pem: str = Field(default=Path(settings.BASE_DIR).joinpath("wechat_微信支付证书/江苏六果科技有限公司支付证书/微信支付公钥.pem").read_text(), alias="商户公钥PEM", description="apiclient_cert.pem 内容（很少用到）")
     
     # ---------- 微信支付公钥（用于验签和加密敏感字段） ----------
-    wechatpay_public_key_id: str = Field("PUB_KEY_ID_0117003834192026080500181856002000", alias="微信支付公钥ID")
+    wechatpay_public_key_id: str = Field(default="PUB_KEY_ID_0117003834192026080500181856002000", alias="微信支付公钥ID")
-    wechatpay_public_key_pem: str = Field(Path(settings.BASE_DIR).joinpath("wechat_微信支付证书/江苏六果科技有限公司支付证书/微信支付公钥.pem").read_text(), alias="微信支付公钥PEM", description="pub_key.pem 内容")
+    wechatpay_public_key_pem: str = Field(default=Path(settings.BASE_DIR).joinpath("wechat_微信支付证书/江苏六果科技有限公司支付证书/微信支付公钥.pem").read_text(), alias="微信支付公钥PEM", description="pub_key.pem 内容")
     # ---------- 平台证书（灰度过渡期备用） ----------
     platform_cert_pem: Optional[
-        str] = Field(Path(settings.BASE_DIR).joinpath("wechat_微信支付证书/江苏六果科技有限公司支付证书/sixgou_ping_tai_zheng_shu_cert.pem").read_text(), alias="平台证书PEM", description="wechatpay.pem 内容")
+        str] = Field(default=Path(settings.BASE_DIR).joinpath("wechat_微信支付证书/江苏六果科技有限公司支付证书/sixgou_ping_tai_zheng_shu_cert.pem").read_text(), alias="平台证书PEM", description="wechatpay.pem 内容")
     pay_uri: str | None = Field(None, )
     pay_请求体: dict | bytes | str | None = Field(None, description="发请求签名时需要的请求体")
-    pay_methon方法: Literal["GET", "POST", "PATCH"] = Field("POST", description="发请求签名时需要的请求体")
+    pay_methon方法: Literal["GET", "POST", "PATCH"] = Field(default="POST", description="发请求签名时需要的请求体")
     
     def model_post_init(self, __context):
-        print("初始化完成，自动调用 model_post_init")
+        pass
     
     def 验证签名串(self, response_headers, response_data: dict, ):
         """
@@ -71,7 +71,6 @@ class sixWechatPay六果泡泡支付(BaseModel):
         Wechatpay_Signa = pydash.get(response_headers, "Wechatpay-Signature")
         response_data_str = orjson.dumps(response_data, ).decode(encoding="utf-8")
         string_to_verify = f"{Wechatpay_Timestamp}\n{Wechatpay_Nonce}\n{response_data_str}\n"  # 构造验签名串
-        print("最终验证的请求字符串", string_to_verify)
         hash_obj = SHA256.new(string_to_verify.encode())
         # 6. 验证签名
         try:

wechat_接口/商品订单模拟接口/商品数据接口.py

@@ -27,7 +27,6 @@ class 商品接口ViewSets(ViewSet):
         pass
         赢免单商品数据 = Goods.objects.filter(goods_商品销售场景=goods商品Choices.赢免单.value).first()
         data = model_to_dict(instance=赢免单商品数据, fields=None, exclude=None)
-        print("赢免单,商品查询没有结果了吗", data)
         return Response(data=data)
     
     @action(detail=False, methods=["post"], url_path="query")

wechat_接口/微信支付接口/微信支付测试接口.py

@@ -6,6 +6,7 @@ from rest_framework import status
 from rest_framework.decorators import action
 from rest_framework.request import Request
 from rest_framework.response import Response
+from rest_framework.routers import DefaultRouter
 from rest_framework.viewsets import ViewSet
 from ulid import ULID
 
@@ -188,3 +189,7 @@ class 微信支付ViewSets(ViewSet):
                 },
             }
         return Response(data={})
+
+
+微信支付ViewSetsRouter = DefaultRouter()
+微信支付ViewSetsRouter.register(prefix="", viewset=微信支付ViewSets, basename="微信支付ViewSets")

wechat_数据库/微信支付券/代金券数据库.py

@@ -0,0 +1,31 @@
+from django.db import models
+from uuid6 import uuid8
+
+from wechat_数据库.用户数据库.小程序登陆用户 import models_app_name
+
+
+class stock券数据表(models.Model):
+    """城市信息表"""
+    objects = models.Manager()  #
+    
+    stock_id = models.UUIDField(primary_key=True, default=uuid8)
+    stock_商家侧订单号 = models.CharField(max_length=128, )
+    stock_use_券状态 = models.CharField(max_length=128, null=True, blank=True, )
+    stock_use_发券时间 = models.DateTimeField(null=True, blank=True, )
+    stock_use_领券时间 = models.DateTimeField(null=True, blank=True, )
+    mini_openid = models.CharField(max_length=128, null=True, blank=True, )
+    mini_unionid = models.CharField(max_length=128, null=True, blank=True, )
+    stock_归属商户号 = models.CharField(max_length=128)
+    stock_批次号 = models.CharField(max_length=128, null=True, blank=True, )
+    stock_批次名称 = models.CharField(max_length=128, null=True, blank=True, )
+    stock_券金额 = models.IntegerField(null=True, blank=True, )
+    stock_券门槛 = models.CharField(max_length=128, null=True, blank=True, )
+    stock_券有效期开始时间 = models.DateField(null=True, blank=True, )
+    stock_未领取券的数据 = models.JSONField(default=dict, null=True, blank=True, )
+    stock_券有效期结束时间 = models.DateField(null=True, blank=True, )
+    dateAndTime = models.DateTimeField(auto_now_add=True, db_comment="创建时间")  # 数据创建时间
+    updateTime = models.DateTimeField(auto_now=True, db_comment="更新时间")  # 更新时间(需要用 save() )
+    
+    class Meta:
+        db_table = "stock券数据表"  # 给数据表自定义一个名称；默认的会是在 应用名+类名
+        app_label = models_app_name

wechat_数据库/用户数据库/小程序积分数据库.py

@@ -18,7 +18,7 @@ class share积分类型choosies(models.TextChoices):
 class share积分表(models.Model):
     """城市信息表"""
     objects = models.Manager()  #
-
+    
     id_主键 = models.UUIDField(primary_key=True, default=uuid8)
     id_str = models.CharField(max_length=128, default=ULID)
     share分享者unionid = models.CharField(max_length=128, )
@@ -37,12 +37,12 @@ class share积分表(models.Model):
     share支付微信侧返回的提现状态 = models.CharField(max_length=128, null=True, blank=True, )
     share支付提现微信公司生成的转账数据 = models.JSONField(null=True, blank=True, default=dict)
     share积分是否可以提现的状态 = models.CharField(null=True, blank=True, )
-
+    
     share日期 = models.DateField(blank=True, null=True)
     share日期时间 = models.DateTimeField(blank=True, null=True, )
     dateAndTime = models.DateTimeField(auto_now_add=True, db_comment="创建时间")  # 数据创建时间
     updateTime = models.DateTimeField(auto_now=True, db_comment="更新时间")  # 更新时间(需要用 save() )
-
+    
     class Meta:
         db_table = "share积分表"  # 给数据表自定义一个名称；默认的会是在 应用名+类名
         app_label = models_app_name

wechat_项目工具包/EMS中国邮政/ems邮政.py

@@ -33,11 +33,10 @@ class ems_parameters物流的状态(BaseModel):
 
 
 class ems邮政物流工具(BaseModel):
-    # ems_biz_id: str = "1100244903172"
+    # ems_biz_id = Field(default="1100244903172", description="发放代金券是创建的批次号")
-    # ems_delivery_id: str = "EMS"
+    # ems_delivery_id: str = Field(default="EMS", description="发放代金券是创建的批次号")
-    ems_password: str = "xiao@792282"
+    ems_biz_id: str = Field(default="test_biz_id", description="ems_biz_id")
-    ems_biz_id: str = Field("test_biz_id", description="ems_biz_id")
+    ems_delivery_id: str = Field(default="TEST", description="ems_biz_id")
-    ems_delivery_id: str = Field("TEST", description="ems_biz_id")
     
     def ems发件人信息(self):
         ems发件人信息数据 = {
@@ -61,9 +60,9 @@ class ems邮政物流工具(BaseModel):
         cityName = pydash.get(obj=orderData, path="order用户配送地址.address.cityName")  # 市
         countyName = pydash.get(obj=orderData, path="order用户配送地址.address.countyName")  # 区
         detailInfoNew = pydash.get(obj=orderData, path="order用户配送地址.address.detailInfoNew")  # 详细地址
-        telNumber = pydash.get(obj=orderData, path="order用户配送地址.address.telNumber")  # 详细地址
+        telNumber = pydash.get(obj=orderData, path="order用户配送地址.address.telNumber")  # 联系电放
         detailInfo = pydash.get(obj=orderData, path="order用户配送地址.address.detailInfo")  # 详细地址
-        userName = pydash.get(obj=orderData, path="order用户配送地址.address.userName")  # 详细地址
+        userName = pydash.get(obj=orderData, path="order用户配送地址.address.userName")  # 收件人昵称
         nationalCode = pydash.get(obj=orderData, path="order用户配送地址.address.nationalCode")  # 详细地址
         print("\n🍎 🍏 🍊 🍎 🍏 🍊 🍎 🍏 🍊 🍎 🍏 🍊 🍎 🍏 \n", telNumber)
         return {
@@ -213,14 +212,7 @@ class ems邮政物流工具(BaseModel):
             "action_type": action_type,
             "action_msg": action_msg,
             }
-        print("打印 一下模拟的数据,主要就是看一下时间戳的问题", 模拟数据)
+        requests.post(url=模拟更新物流状态, data=orjson.dumps(模拟数据, option=orjson.OPT_SORT_KEYS, ).decode(encoding="utf-8"))
-        data = requests.post(url=模拟更新物流状态,
-            data=orjson.dumps(模拟数据, option=orjson.OPT_SORT_KEYS, ).decode(encoding="utf-8"))
-        print("🍎 🍏 🍊 🍎 🍏 🍊 🍎 🍏 🍊 🍎 🍏 🍊 🍎 🍏 ", data.json())
-    
-    def 查询运单轨迹(self, order物流商家侧订单号):
-        """"""
-        mini_token = sixToken.get_mini_token()
     
     def 更新物流快递数据(self, order物流公司订单编号, ):
         """"""
@@ -292,20 +284,21 @@ class ems邮政物流工具(BaseModel):
         订单更新对象.order物流状态 = "已确认"
         订单更新对象.save()
         # 备注一下返回数据类型
-        responseDataa = {'ToUserName': 'gh_f754c53eb962', 'FromUserName': 'ohQkD7HmLYEYrFjFau6juOhduRU8', 'CreateTime': 1784666355, 'MsgType': 'event', 'Event': 'trade_manage_order_settlement',
+        # responseDataa = {'ToUserName': 'gh_f754c53eb962', 'FromUserName': 'ohQkD7HmLYEYrFjFau6juOhduRU8', 'CreateTime': 1784666355, 'MsgType': 'event', 'Event': 'trade_manage_order_settlement',
-            'transaction_id': '4200003114202607213777723688', 'merchant_id': '1700383419', 'sub_merchant_id': '', 'merchant_trade_no': 'OAT01KY1BZ3T9SFSSRNS10R95B5XH', 'pay_time': 1784605024,
+        #     'transaction_id': '4200003114202607213777723688', 'merchant_id': '1700383419', 'sub_merchant_id': '', 'merchant_trade_no': 'OAT01KY1BZ3T9SFSSRNS10R95B5XH', 'pay_time': 1784605024,
-            'shipped_time': 1784666354,
+        #     'shipped_time': 1784666354,
-            'estimated_settlement_time': 1784839154
+        #     'estimated_settlement_time': 1784839154
-            }
+        #     }
 
 
 if __name__ == "__main__":
     # 当脚本直接运行时执行的代码
     # ems邮政物流工具().生成运单(out_trade_no商家侧支付订单号="")
-    ems邮政物流工具().模拟更新订单状态(order物流公司订单编号="EMS01KZAH47JZA3HCY2R5NS0WD3VN_waybill_id", action_type=100001, action_msg="揽件成功")
+    order物流公司订单编号 = "EMS01KZBJBPHFR9E924DKDW86CGJT_waybill_id"
+    ems邮政物流工具().模拟更新订单状态(order物流公司订单编号=order物流公司订单编号, action_type=100001, action_msg="揽件成功")
     time.sleep(30)
-    ems邮政物流工具().模拟更新订单状态(order物流公司订单编号="EMS01KZAH47JZA3HCY2R5NS0WD3VN_waybill_id", action_type=300002, action_msg="开始派送")
+    ems邮政物流工具().模拟更新订单状态(order物流公司订单编号=order物流公司订单编号, action_type=300002, action_msg="开始派送")
     time.sleep(30)
     
-    ems邮政物流工具().模拟更新订单状态(order物流公司订单编号="EMS01KZAH47JZA3HCY2R5NS0WD3VN_waybill_id", action_type=300003, action_msg="签收成功")
+    ems邮政物流工具().模拟更新订单状态(order物流公司订单编号=order物流公司订单编号, action_type=300003, action_msg="签收成功")
     # ems邮政物流工具().更新物流快递数据(order物流公司订单编号="EMS01KZAD94RDQFQBVVX705YNH6SE_waybill_id")

wechat_项目工具包/企业微信工具包/企业推广二维码接口.py

@@ -1,11 +0,0 @@
-class wecom推广二维码:
-    @classmethod
-    def 设置授权应用可见范围(cls):
-        """
-        调用该接口前提是开启通讯录迁移，收到授权成功通知后可调用。企业注册初始化安装应用后，应用默认可见范围为根部门。
-        如需修改应用可见范围，服务商可以调用该接口设置授权应用的可见范围。
-        该接口只能使用注册完成回调事件或者查询注册状态返回的access_token，
-        调用设置通讯录同步完成后或者access_token超过30分钟失效（即解除通讯录锁定状态）则不能继续调用该接口
-        :return:
-        :rtype:
-        """

wechat_项目工具包/企业微信工具包/企微回调业务处理逻辑.py

@@ -1,63 +0,0 @@
-import dataclasses
-
-import jmespath
-import pydash
-import requests
-from asgiref.sync import async_to_sync
-from channels.layers import get_channel_layer
-
-from sixGuoDjango import redis_5
-from wechat_项目工具包.企业微信工具包.客户管理 import wecom客户管理
-from wechat_项目工具包.企业微信工具包.消息推送工具 import wecom消息推送
-
-
-@dataclasses.dataclass
-class six企微回调业务处理方法():
-    pass
-
-    def 添加企业客户事件(self, as_data):
-        """"""
-        """
-        添加企业客户事件
-        参数	说明 配置了客户联系功能的成员添加外部联系人时，回调该事件
-        ToUserName	企业微信CorpID
-        FromUserName	此事件该值固定为sys，表示该消息由系统生成
-        CreateTime	消息创建时间 （整型）
-        MsgType	消息的类型，此时固定为event
-        Event	事件的类型，此时固定为change_external_contact
-        ChangeType	此时固定为add_external_contact
-        UserID	企业服务人员的UserID
-        ExternalUserID	外部联系人的userid，注意不是企业成员的账号
-        State	添加此用户的「联系我」方式配置的state参数，或在获客链接中指定的customer_channel参数，可用于识别添加此用户的渠道
-        WelcomeCode	欢迎语code，可用于发送欢迎语
-        """
-        # 这是用户在添加企微好友成功时的回调信息;
-        ToUserName = pydash.get(obj=as_data, path="xml.ToUserName")  # toUser 企业微信CorpID
-        FromUserName = pydash.get(obj=as_data, path="xml.FromUserName")  # sys 此事件该值固定为sys，表示该消息由系统生成
-        CreateTime = pydash.get(obj=as_data, path="xml.CreateTime")  # 1403610513 消息创建时间 （整型）
-        MsgType = pydash.get(obj=as_data, path="xml.MsgType")  # event 消息的类型，此时固定为event
-        Event = pydash.get(obj=as_data, path="xml.Event")  # change_external_contact 事件的类型，此时固定为change_external_contact
-        ChangeType = pydash.get(obj=as_data, path="xml.ChangeType")  # add_external_contact 此时固定为add_external_contact
-        UserID = pydash.get(obj=as_data, path="xml.UserID")  # UserID 企业服务人员的UserID
-        ExternalUserID = pydash.get(obj=as_data, path="xml.ExternalUserID", )  # woAJ2GCAAAXtWyujaWJHDDGi0mAAAA 外部联系人的userid，注意不是企业成员的账号
-        State = pydash.get(obj=as_data, path="xml.State", )  # teststate 添加此用户的「联系我」方式配置的state参数，或在获客链接中指定的customer_channel参数，可用于识别添加此用户的渠道
-        WelcomeCode = pydash.get(obj=as_data, path="xml.WelcomeCode")  # WELCOMECODE 欢迎语code，可用于发送欢迎语
-        #      发送欢迎语
-        print("添加企业客户事件")
-
-        res_welcom_code = wecom消息推送.发送新客户欢迎语(CALLBACK_CODE=WelcomeCode)
-        # 获取用户的 unionid (主要就是获取用户的unionid的值)
-        res = wecom客户管理.获取客户详情(external_userid=ExternalUserID)
-        print(res)
-        unionid = jmespath.search(data=res, expression="external_contact.unionid")
-        print(unionid)
-        wecom_pay_data = requests.post(url="https://xiao.sixgou.com/demopay/transfer/", json={"unionid": unionid})
-        # 存储数据(用户添加后的数据)
-        print("打印数据类型", wecom_pay_data.json())
-        print("打印数据类型", type(wecom_pay_data.json()))
-        payData = wecom_pay_data.json()
-        channels_name = redis_5.get(name=unionid)
-        default_channel_layer = get_channel_layer(alias="default")
-        async_to_sync(awaitable=default_channel_layer.send)(channel=channels_name, message={"type": "chat_subMsg", "data": payData})
-        pass
-        # 调用发红包的功能

wechat_项目工具包/企业微信工具包/客户标签管理工具.py

@@ -2,6 +2,7 @@
 import os
 
 import django
+from pydantic import BaseModel, Field
 
 from sixGuoDjango.settings import BASE_DIR
 from wechat_token.token工具包 import sixToken
@@ -9,40 +10,36 @@ from wechat_token.token工具包 import sixToken
 os.environ.setdefault(key="DJANGO_SETTINGS_MODULE", value=f"{BASE_DIR.name}.settings")
 django.setup()
 
-import datetime
-
 import jmespath
 import requests
 
 from requests import post
 
 
-class wecom管理企业标签:
+class wecom管理企业标签(BaseModel):
     """
     管理企业标签
     最后更新：2023/12/01
     企业客户标签是针对企业的外部联系人进行标记和分类的标签，由企业统一配置后，企业成员可使用此标签对客户进行标记。
     """
-
+    wecom_token: str = sixToken.get_wecom_token()
-    @classmethod
+    agentid: str = Field(default="1000025", description="agentid")
-    def 获取企业标签库(cls):
+    
+    def 获取企业标签库(self, ):
         """
         在这里返回结果为:企业微信创建的所有的企业标签,不包含个人标签
         企业可通过此接口获取企业客户标签详情。请求方式: POST(HTTP)
         """
         pass
-        wecom_token = sixToken.get_wecom_token()
+        uri = f"https://qyapi.weixin.qq.com/cgi-bin/externalcontact/get_corp_tag_list?access_token={self.wecom_token}"
-        uri = f"https://qyapi.weixin.qq.com/cgi-bin/externalcontact/get_corp_tag_list?access_token={wecom_token}"
         data = post(url=uri).json()
-        print(data)
         tag_group = jmespath.search(data=data, expression="tag_group")
         for tag in tag_group:
             print(tag)
-
+        
         return data
-
+    
-    @classmethod
+    def 添加企业客户标签(self):
-    def 添加企业客户标签(cls):
         """
         企业可通过此接口向客户标签库中添加新的标签组和标签，每个企业最多可配置10000个企业标签。
         注意:
@@ -55,33 +52,26 @@ class wecom管理企业标签:
         :return:
         :rtype:
         """
-        wecom_token = sixToken.get_wecom_token()
+        uri = f"https://qyapi.weixin.qq.com/cgi-bin/externalcontact/add_corp_tag?access_token={self.wecom_token}"
-        uri = f"https://qyapi.weixin.qq.com/cgi-bin/externalcontact/add_corp_tag?access_token={wecom_token}"
         请求数据示例 = {
-            "group_id": "etj4zANAAA1Zh_RyLIpjOr6IbuMPRB8g",  # 否	标签组id
+            "group_name": "我的新标签组",
-            # "group_name": "泰州市",  # 否	标签组名称，最长为30个字符
             "order": 1,
             "tag": [
-                {
+                {"name": "标签1", "order": 1},
-                    "name": "未知",  # 是	添加的标签名称，最长为30个字符
+                {"name": "标签2", "order": 2}
-                    "order": 1,  # 否	标签次序值。order值大的排序靠前。有效的值范围是[0, 2^32)
+                ]
-                    },
-                ],
-            # "agentid": 1000014,  # 授权方安装的应用agentid。仅旧的第三方多应用套件需要填此参数
             }
         data = post(url=uri, json=请求数据示例).json()
         print(data)
-
+    
-    @classmethod
+    def 编辑客户企业标签(self, userid: str, external_userid: str, add_tag: str):
-    def 编辑客户企业标签(cls, userid: str, external_userid: str, add_tag: str):
         """
         企业可通过此接口为指定成员的客户添加上由企业统一配置的标签；注意，每个成员对同一个客户最多可以添加3000个标签。
         :return:
         :rtype:
         """
-
+        
-        wecom_token = sixToken.get_wecom_token()
+        uri = f"https://qyapi.weixin.qq.com/cgi-bin/externalcontact/mark_tag?access_token={self.wecom_token}"
-        uri = f"https://qyapi.weixin.qq.com/cgi-bin/externalcontact/mark_tag?access_token={wecom_token}"
         请求数据示例 = {
             # "userid": "YuanBao1975",  # 是	添加外部联系人的userid
             "userid": userid,  # 是	添加外部联系人的userid
@@ -93,32 +83,23 @@ class wecom管理企业标签:
             }
         data = post(url=uri, json=请求数据示例).json()
         print(data)
-
+    
-    @classmethod
+    def 删除企业客户标签(self, 标签组ID, 标签子标签ID=None):
-    def 更新所有的企业标签并存储到数据库(cls):
         pass
-        data = cls.获取企业标签库()
+        """删除已经创建的 企业标签 tag_id和group_id不可同时为空。如果一个标签组下所有的标签均被删除，则标签组会被自动删除"""
-        tag_group = jmespath.search(data=data, expression="tag_group", )
+        uri = f"https://qyapi.weixin.qq.com/cgi-bin/externalcontact/del_corp_tag?access_token={self.wecom_token}"
-        for tag_list in tag_group:
+        删除的数据 = {
-            print(tag_list)
+            # "tag_id": [],
-            # tag_list = jmespath.search(data=tag_list, expression="tag", )
+            "group_id": [标签组ID],
-            group_id = jmespath.search(data=tag_list, expression="group_id", )
+            }
-            group_name = jmespath.search(data=tag_list, expression="group_name", )
+        postData = requests.post(url=uri, json=删除的数据)
-            create_time = jmespath.search(data=tag_list, expression="create_time", )
+        print(postData.text)
-            # create_time = pydash.get(obj=tag_list, path="create_time", )
+        # print(postData.json())
-            # 需要将时间戳转为时间格式
+    
-            print(create_time, "========", )
+    def 更新所有的用户性别组标签(self):
-            create_time_1 = datetime.datetime.fromtimestamp(create_time)
-            #
-
-            tag_child_list = jmespath.search(data=tag_list, expression="tag", )
-
-    @classmethod
-    def 更新所有的用户性别组标签(cls):
         pass
-
+    
-    @classmethod
+    def 打标签性别(self, userid: str, external_userid: str, gender: int):
-    def 打标签性别(cls, userid: str, external_userid: str, gender: int):
         """
         :param gender:
         :type gender:
@@ -129,22 +110,24 @@ class wecom管理企业标签:
         """
         print("单独更新用户性别标签")
         if gender == 1:
-            cls.编辑客户企业标签(
+            self.编辑客户企业标签(
                 userid=userid, external_userid=external_userid,
                 add_tag="et74kdKAAAO9rCHIG-GcT7ZU_gsTslkg",
                 )
         if gender == 2:
-            cls.编辑客户企业标签(
+            self.编辑客户企业标签(
                 userid=userid, external_userid=external_userid,
                 add_tag="et74kdKAAAJUou62OZwyu3LeavfmxAhw",
                 )
         if gender == 0:
-            cls.编辑客户企业标签(
+            self.编辑客户企业标签(
                 userid=userid, external_userid=external_userid,
                 add_tag="et74kdKAAAI_VNWc-Gzakmo_jGnK-Glw",
                 )
-
+    
-    def 给个微好友打标签(self):
+    def 给个微好友打标签(self, userID企微员工账号, external_userid要打标签的好友ID, add_tag要给好友添加的标签ID, remove_tag要对好友删除的标签ID=None):
+        if remove_tag要对好友删除的标签ID is None:
+            remove_tag要对好友删除的标签ID = []
         pass
         uri = f"https://qyapi.weixin.qq.com/cgi-bin/externalcontact/mark_tag"
         请求数据 = {
@@ -153,16 +136,13 @@ class wecom管理企业标签:
             "add_tag": ["et74kdKAAAO9rCHIG-GcT7ZU_gsTslkg"],  # 测试标签ID
             # "remove_tag": ["et74kdKAAAO9rCHIG-GcT7ZU_gsTslkg"] # 删除企业微信好友的 标签
             }
-        wecom_token = sixToken.get_wecom_token()
+        response_data = requests.post(url=uri, params={"access_token": self.wecom_token}, json=请求数据)
-        response_data = requests.post(url=uri, params={"access_token": wecom_token}, json=请求数据)
         print(response_data.json())
 
 
 if __name__ == '__main__':
     pass
-    wecom管理企业标签.获取企业标签库()
+    
-    # wecom管理企业标签.添加企业客户标签()
+    wecom管理企业标签().获取企业标签库()
-    # wecom管理企业标签.更新所有的用户性别组标签()
+    # wecom管理企业标签().删除企业客户标签(标签组ID="etj4zANAAA1Zh_RyLIpjOr6IbuMPRB8g")
-    # wecom管理企业标签.更新所有的企业标签并存储到数据库()
+    # wecom管理企业标签().添加企业客户标签()
-    # wecom管理企业标签.获取企业标签库()
-    # wecom管理企业标签().给个微好友打标签()

wechat_项目工具包/微信支付工具包/领优惠券工具包.py

@@ -1,6 +1,7 @@
 import hashlib
 import hmac
 from datetime import datetime
+from typing import Literal
 from zoneinfo import ZoneInfo
 
 import pydash
@@ -8,6 +9,18 @@ from pydantic import BaseModel, Field
 from ulid import ULID
 
 from wechat_微信支付证书.江苏六果科技有限公司支付证书.江苏六果科技有限公司支付参数 import sixpay六果科技公司
+from wechat_数据库.微信支付券.代金券数据库 import stock券数据表
+
+
+class stock券的状态(BaseModel):
+    demo_必填: int = Field(..., description="描述")  # 必传属发生
+    
+    # demo_可选: Optional[int] = None  # 可选值
+    # demo_默认值: int = Field(default=100001, description="描述")  # 有默认值
+    # demo_联合类型: Literal["xiao", "zizi"] = Field(..., description="描述")
+    
+    def model_post_init(self, __context):
+        print("初始化完成，自动调用 model_post_init")
 
 
 class stock发送代金券功能(BaseModel):
@@ -17,8 +30,11 @@ class stock发送代金券功能(BaseModel):
     # demo_联合类型: Literal["xiao", "zizi"] = Field(..., description="描述")
     pass
     stock_id_代金券批次号: str = Field(..., description="发放代金券是创建的批次号")
+    stock券的状态: Literal["待领券", "已领券"] = Field(..., description="stock券的状态")
+    stock券待领券: Literal["待领券", "已领券"] = Field(default="待领券", description="stock券的状态")
+    stock券已领券: Literal["待领券", "已领券"] = Field(default="已领券", description="stock券的状态")
     
-    def send发券并返回前端需要的数据(self):
+    def send发券并返回前端需要的数据(self, self_mini_openid, self_mini_unionid):
         """前端请求:将这个字典对象返回给前端,前端调用小程序原生插件领取券"""
         pass
         # 第一步:准备数据
@@ -35,12 +51,10 @@ class stock发送代金券功能(BaseModel):
             "create_coupon_merchant0": mchid,  # 发券的商家商户号
             "customize_send_time0": rfc3339,  # 当前的领券的时间
             }
-        
         # iteratee为0是按key iteratee是以value的值来排序   reverse=False(从小到大) reverse=True(从大到小)
         sorted_dict = dict(pydash.sort_by(collection=params每一张券需要验名的数据格式.items(), iteratee=0, reverse=False))
-        print(sorted_dict)
         # 拼接组装好的数据
-        sign_str = "&".join([f"{k}={v}" for k, v in sorted_dict.items() if v]) + f"&key={apiv2_key}"
+        sign_str = pydash.join(array=[f"{key}={value}" for key, value in sorted_dict.items()], separator="&") + f"&key={apiv2_key}"
         # # 4. 生成 HMAC-SHA256 签名并转大写
         sign = hmac.new(key=apiv2_key.encode("utf-8"), msg=sign_str.encode("utf-8"), digestmod=hashlib.sha256, ).hexdigest().upper()
         # 3. 拼接参数串
@@ -52,12 +66,24 @@ class stock发送代金券功能(BaseModel):
             "send_coupon_merchant": sixpay六果科技公司.mchid,
             }
         send_coupon_params: list[dict] = [params, ]  # 发放代金券需要返回给前端的参数必须为列表 list[dict]
-        return {
+        生成发券的数据 = {
             "send_coupon_params": send_coupon_params,
             "sign": sign,
             "send_coupon_merchant": sixpay六果科技公司.mchid,
             "suggest_immediate_use": True,
             }
+        # 最后需要处理一下当前用户的 数据库
+        stock券数据表.objects.update_or_create(stock_商家侧订单号=out_request_no,
+            stock_未领取券的数据=生成发券的数据,
+            stock_批次号=self.stock_id_代金券批次号, stock_use_券状态=self.stock券的状态, stock_归属商户号=mchid,
+            mini_openid=self_mini_openid, mini_unionid=self_mini_unionid, defaults={"stock_use_发券时间": rfc3339})
+        return 生成发券的数据
+    
+    def 领券后更新当前券的状态(self, self_mini_openid, self_mini_unionid):
+        pass
+        stock券数据表.objects.filter(mini_openid=self_mini_openid, mini_unionid=self_mini_unionid, stock_批次号=self.stock_id_代金券批次号,
+            stock_use_券状态=self.stock券待领券
+            ).update(stock_use_券状态=self.stock券已领券)
 
 
 if __name__ == "__main__":

wechat_项目工具包/微信支付电子发票/服务商电子发票.py

@@ -13,7 +13,7 @@ class weiPay服务商电子发票(BaseModel):
     # demo_联合类型: Literal["xiao", "zizi"] = Field(..., description="描述")
     
     def model_post_init(self, __context):
-        print("初始化完成，自动调用 model_post_init")
+        pass
     
     def 获取开通服务商电子发票能力邀请链接(self):
         pass
@@ -23,16 +23,16 @@ class weiPay服务商电子发票(BaseModel):
             path="/v3/new-tax-control-fapiao/fapiaomerchant/getspinviteurl",
             query={
                 "operation_type": "AUTH_BINDING",
-                "fapiao_mode":  ["TENCENT_DIGITAL_TAX"],  # 【开票模式】 邀请商户开通服务商电子发票的可选开票模式
+                "fapiao_mode": ["TENCENT_DIGITAL_TAX"],  # 【开票模式】 邀请商户开通服务商电子发票的可选开票模式
                 "fapiao_ability_type_list": ["BASE_ABILITY"],
                 "invite_code": "code_20260805_123",  # 必填 【服务商邀请code】 服务商邀请的唯一标识，由服务商生成，可根据邀请code查询邀请开通情况
                 # "sub_mchid": "1700383419"
-                "taxpayer_id":"91321202MAE608K31Q"
+                "taxpayer_id": "91321202MAE608K31Q"
                 }
             )
         print(uri)
         headers = wechatPay(payment=six六果服务商支付参数).构造签名串(uri=str(uri), method="GET")
-        headers.update({"Wechatpay-Serial":"1880A972F4400AF653A108F5F0C7A71585A4338E"})
+        headers.update({"Wechatpay-Serial": "1880A972F4400AF653A108F5F0C7A71585A4338E"})
         getData = requests.get(url=uri, headers=headers)
         print(getData.text)
 

wechat_项目工具包/数据库的工具包/更新用户积分.py

@@ -24,9 +24,9 @@ class miniUser提现状态(BaseModel):
     # demo_可选: Optional[int] = None  # 可选值
     # demo_默认值: int = Field(default=100001, description="描述")  # 有默认值
     # demo_联合类型: Literal["xiao", "zizi"] = Field(..., description="描述")
-    不可提现: str = Field("不可提现", description="不可提现")
+    不可提现: str = Field(default="不可提现", description="不可提现")
-    可提现: str = Field("可提现", description="可提现")
+    可提现: str = Field(default="可提现", description="可提现")
-    提现中: str = Field("提现中", description="提现中")
+    提现中: str = Field(default="提现中", description="提现中")
 
 
 class miniUser用户角色(BaseModel):
@@ -34,21 +34,21 @@ class miniUser用户角色(BaseModel):
     # demo_可选: Optional[int] = None  # 可选值
     # demo_默认值: int = Field(default=100001, description="描述")  # 有默认值
     # demo_联合类型: Literal["xiao", "zizi"] = Field(..., description="描述")
-    推广员: str = Field("推广员", description="推广员")
+    推广员: str = Field(default="推广员", description="推广员")
-    企微员工: str = Field("企微员工", description="企微员工")
+    企微员工: str = Field(default="企微员工", description="企微员工")
-    代理商: str = Field("代理商", description="代理商")
+    代理商: str = Field(default="代理商", description="代理商")
-    普通会员: str = Field("普通会员", description="普通会员")
+    普通会员: str = Field(default="普通会员", description="普通会员")
-    用工关系已绑定: str = Field("用工关系已绑定", description="用工关系已绑定")
+    用工关系已绑定: str = Field(default="用工关系已绑定", description="用工关系已绑定")
-    新人红包首次添加企微积分值: int = Field(100, description="新人红包首次添加企微积分值")
+    新人红包首次添加企微积分值: int = Field(default=100, description="新人红包首次添加企微积分值")
-    发券奖励积分值: int = Field(10, description="添加通知好友积分")
+    发券奖励积分值: int = Field(default=10, description="添加通知好友积分")
-    每日积分积分值: int = Field(50, description="发券奖励积分值")
+    每日积分积分值: int = Field(default=50, description="发券奖励积分值")
-    小程序分享积分值: int = Field(10, description="小程序分享积分值")
+    小程序分享积分值: int = Field(default=10, description="小程序分享积分值")
 
 
 class miniUser积分(BaseModel):
     share分享者unionidID: str = Field(..., description="分享者的unionid")
     click点击者unionidID: str = Field(..., description="点击者的的openid")
-    bind绑定的企微unionidID: str = Field("", description="click绑定的企微unionidID")
+    bind绑定的企微unionidID: str = Field(default="", description="click绑定的企微unionidID")
     
     def update更新用户头像(self):
         pass
@@ -58,32 +58,38 @@ class miniUser积分(BaseModel):
         # 注意,这里的每日签到: 分享者 同时 也是点击者
         share分享者对象 = weiuser.objects.get(unionid=self.share分享者unionidID)
         click点击都对象 = weiuser.objects.get(unionid=self.click点击者unionidID)
+        wecom绑定的企微ID的员工账号 = weiuser.objects.get(unionid=click点击都对象.user_绑定企微UNIONID)
+        print("打印绑定了企微的对象", wecom绑定的企微ID的员工账号)
+        print("---------", click点击都对象.user_绑定企微UNIONID)
         today当天的日期 = datetime.now(tz=ZoneInfo("Asia/Shanghai")).date()
-        share对象, share布尔值 = share积分表.objects.update_or_create(
+        if wecom绑定的企微ID的员工账号.user_区县 == click点击都对象.user_区县:
-            share分享者unionid=self.share分享者unionidID, share分享者openid=share分享者对象.mini_openid, share点击者openid=click点击都对象.mini_openid, share点击者unionid=self.click点击者unionidID,
+            share对象, share布尔值 = share积分表.objects.update_or_create(
-            share分享者积分值=share分享者积分值, share分享类型=share积分类型, share日期=today当天的日期, share积分是否可以提现的状态=miniUser提现状态().可提现,
+                share分享者unionid=self.share分享者unionidID, share分享者openid=share分享者对象.mini_openid, share点击者openid=click点击都对象.mini_openid, share点击者unionid=self.click点击者unionidID,
-            defaults={"share分享者头像": share分享者对象.user_头像, "share分享者昵称": share分享者对象.user_昵称,
+                share分享者积分值=share分享者积分值, share分享类型=share积分类型, share日期=today当天的日期, share积分是否可以提现的状态=miniUser提现状态().可提现,
-                "share点击者头像": click点击都对象.user_头像, "share点击者昵称": click点击都对象.user_昵称
+                defaults={"share分享者头像": share分享者对象.user_头像, "share分享者昵称": share分享者对象.user_昵称,
-                },
+                    "share点击者头像": click点击都对象.user_头像, "share点击者昵称": click点击都对象.user_昵称
-            )
+                    },
+                )
     
     def add添加通知好友积分(self, share积分类型: Literal["通知好友", "发券奖励"], share分享者积分值: int = miniUser用户角色().发券奖励积分值, ):
         pass
         """这个积分对应的是 小程序主页面 分享3元券的图片 """
         share分享者对象 = weiuser.objects.get(unionid=self.share分享者unionidID)
         click点击都对象 = weiuser.objects.get(unionid=self.click点击者unionidID)
-        share对象, share布尔值 = share积分表.objects.update_or_create(
+        wecom绑定的企微ID的员工账号 = weiuser.objects.get(unionid=click点击都对象.user_绑定企微UNIONID)
-            share分享者unionid=self.share分享者unionidID, share分享者openid=share分享者对象.mini_openid,
+        if share分享者对象.user_区县 == click点击都对象.user_区县 or click点击都对象.user_区县 == wecom绑定的企微ID的员工账号.user_区县:
-            share点击者openid=click点击都对象.mini_openid, share点击者unionid=self.click点击者unionidID,
+            share对象, share布尔值 = share积分表.objects.update_or_create(
-            share分享者积分值=share分享者积分值, share分享类型=share积分类型, share积分是否可以提现的状态=miniUser提现状态().可提现,
+                share分享者unionid=self.share分享者unionidID, share分享者openid=share分享者对象.mini_openid,
-            defaults={"share分享者头像": share分享者对象.user_头像, "share分享者昵称": share分享者对象.user_昵称,
+                share点击者openid=click点击都对象.mini_openid, share点击者unionid=self.click点击者unionidID,
-                "share点击者头像": click点击都对象.user_头像, "share点击者昵称": click点击都对象.user_昵称
+                share分享者积分值=share分享者积分值, share分享类型=share积分类型, share积分是否可以提现的状态=miniUser提现状态().可提现,
-                },
+                defaults={"share分享者头像": share分享者对象.user_头像, "share分享者昵称": share分享者对象.user_昵称,
-            )
+                    "share点击者头像": click点击都对象.user_头像, "share点击者昵称": click点击都对象.user_昵称
-        if share布尔值:
+                    },
-            print("发券奖励积分 添加成功")
+                )
-        else:
+            if share布尔值:
-            print("发券奖励积分    已经存在领过的")
+                print("发券奖励积分 添加成功")
+            else:
+                print("发券奖励积分    已经存在领过的")
     
     def add添加用户分享商品推荐的积分(self, share积分类型: Literal["好物推荐"], share分享者积分值: int, share分享的商品ID: str):
         pass
@@ -91,9 +97,8 @@ class miniUser积分(BaseModel):
         share分享者对象 = weiuser.objects.get(unionid=self.share分享者unionidID)
         click点击都对象 = weiuser.objects.get(unionid=self.click点击者unionidID)
         six六果对象, sixBool = weiuser.objects.get_or_create(unionid="六果")
-        if share分享者对象.parent == six六果对象 or share分享者对象.unionid == click点击都对象.unionid:
+        wecom绑定的企微ID的员工账号 = weiuser.objects.get(unionid=click点击都对象.user_绑定企微UNIONID)
-            pass
+        if share分享者对象.user_区县 == click点击都对象.user_区县 or click点击都对象.user_区县 == wecom绑定的企微ID的员工账号.user_区县:
-        else:
             share对象, share布尔值 = share积分表.objects.update_or_create(
                 share分享者unionid=self.share分享者unionidID, share分享者openid=share分享者对象.mini_openid,
                 share点击者openid=click点击都对象.mini_openid, share点击者unionid=self.click点击者unionidID,
@@ -109,14 +114,16 @@ class miniUser积分(BaseModel):
         pass
         share分享者对象 = weiuser.objects.get(unionid=self.share分享者unionidID)
         click点击都对象 = weiuser.objects.get(unionid=self.click点击者unionidID)
-        share对象, share布尔值 = share积分表.objects.update_or_create(
+        wecom绑定的企微ID的员工账号 = weiuser.objects.get(unionid=click点击都对象.user_绑定企微UNIONID)
-            share分享者unionid=share分享者对象.unionid, share分享者openid=share分享者对象.mini_openid,
+        if share分享者对象.user_区县 == click点击都对象.user_区县 or click点击都对象.user_区县 == wecom绑定的企微ID的员工账号.user_区县:
-            share点击者openid=click点击都对象.mini_openid, share点击者unionid=self.click点击者unionidID,
+            share对象, share布尔值 = share积分表.objects.update_or_create(
-            share分享者积分值=share分享者积分值, share分享类型=share积分类型, share积分是否可以提现的状态=miniUser提现状态().可提现,
+                share分享者unionid=share分享者对象.unionid, share分享者openid=share分享者对象.mini_openid,
-            defaults={"share分享者头像": share分享者对象.user_头像, "share分享者昵称": share分享者对象.user_昵称,
+                share点击者openid=click点击都对象.mini_openid, share点击者unionid=self.click点击者unionidID,
-                "share点击者头像": click点击都对象.user_头像, "share点击者昵称": click点击都对象.user_昵称
+                share分享者积分值=share分享者积分值, share分享类型=share积分类型, share积分是否可以提现的状态=miniUser提现状态().可提现,
-                },
+                defaults={"share分享者头像": share分享者对象.user_头像, "share分享者昵称": share分享者对象.user_昵称,
-            )
+                    "share点击者头像": click点击都对象.user_头像, "share点击者昵称": click点击都对象.user_昵称
+                    },
+                )
     
     def add添加好友助力下单返利积分(self, share积分类型: Literal["好友下单"], order支付商家侧订单号):
         pass
@@ -145,7 +152,6 @@ class miniUser积分(BaseModel):
                 share点击者unionid=click点击者unionidID, share点击者openid=click点击都对象.mini_openid,
                 share分享者积分值=order好友下单助力计算后的积分值, share支付订单商家侧的订单号=order支付商家侧订单号,
                 share分享类型=share积分类型, share积分是否可以提现的状态=miniUser提现状态().可提现,
-                
                 defaults={"share分享者头像": share分享者对象.user_头像, "share分享者昵称": share分享者对象.user_昵称,
                     "share点击者头像": click点击都对象.user_头像, "share点击者昵称": click点击都对象.user_昵称
                     },
@@ -197,7 +203,6 @@ class miniUser积分(BaseModel):
             click点击都对象.save()
         # 第一个逻辑,先判断,当前这个添加企微的 用户,是否已经领过红包了,如果领了过了就直接返回了
         is是否领过红包 = share积分表.objects.filter(share分享者unionid=click点击都对象.unionid, share分享类型="新人红包", share分享者积分值=100).exists()
-        print("打印一下这里的值是不是已经存在了", is是否领过红包)
         if is是否领过红包:
             print("当前添加者已经领过新人红包了,直接return")
             return
@@ -213,7 +218,7 @@ class miniUser积分(BaseModel):
                     "share点击者头像": click点击都对象.user_头像, "share点击者昵称": click点击都对象.user_昵称
                     },
                 )
-            print("添加企微者,并且是同城的情况下,可提现状态,", share布尔值)
+            print("添加企微者,并且是同城的情况下,可提现状态,积分添加成功了", share布尔值)
         # 接着还需要处理,推广员, 并且还得是同城的情况下, 才可以给推广员添加积分了
         if click点击者父元素.user_角色权限 == miniUser用户角色().推广员 and bindRwecom企微员工对象.user_区县 == click点击者父元素.user_区县 == click点击都对象.user_区县:
             # 这里的状态为可以提现
@@ -225,11 +230,11 @@ class miniUser积分(BaseModel):
                     "share点击者头像": click点击都对象.user_头像, "share点击者昵称": click点击都对象.user_昵称
                     },
                 )
-            print("分享者,可提现状态", share布尔值)
+            print("分享者,可提现状态 推广员,分享积分添加成功了", share布尔值)
             return
             # 在这里判断的是 给当前公司的企微推广员, 添加积分
         if bindRwecom企微员工对象.user_企微角色权限 == miniUser用户角色().企微员工 and bindRwecom企微员工对象.user_区县 == click点击都对象.user_区县:
-            # 这里的状态为可以提现 这里的积分是给企微员工添加的,
+            # 这里的状态为可以提现 这里的积分是给企微员工添加的,这里处理的是: 当前用户的是企微员工时的 积分添加;
             share对象, share布尔值 = share积分表.objects.update_or_create(
                 share分享者unionid=bindRwecom企微员工对象.unionid, share分享者openid=bindRwecom企微员工对象.mini_openid,
                 share点击者openid=click点击都对象.mini_openid, share点击者unionid=self.click点击者unionidID,
@@ -238,7 +243,7 @@ class miniUser积分(BaseModel):
                     "share点击者头像": click点击都对象.user_头像, "share点击者昵称": click点击都对象.user_昵称
                     },
                 )
-            print("企微", share布尔值)
+            print("企微员工,积分添加成功", share布尔值)
             return
 
 
@@ -246,5 +251,5 @@ if __name__ == "__main__":
     pass
     # (miniUser积分(share分享者unionidID="", click点击者unionidID="")
     #  .add添加好友助力下单返利积分(order支付商家侧订单号="OAT01KYDESHM9ADEXGY7BW0AVHFSG", share积分类型="好友下单", ))
-    (miniUser积分(share分享者unionidID="oy4Jw6A1T3WkKOOhMxcbQTDSM8rs", click点击者unionidID="oy4Jw6P1FnuTNF-hSoJHNztSAoQ0", bind绑定的企微unionidID="oy4Jw6A1T3WkKOOhMxcbQTDSM8rs")
+    (miniUser积分(share分享者unionidID="oy4Jw6P1FnuTNF-hSoJHNztSAoQ0", click点击者unionidID="oy4Jw6P1FnuTNF-hSoJHNztSAoQ0", bind绑定的企微unionidID="oy4Jw6A1T3WkKOOhMxcbQTDSM8rs")
-     .add添加点击者添加企微员工双向红包积分(share积分类型="新人红包", share分享者二维码state="oy4Jw6A1T3WkKOOhMxcbQTDSM8rs"))
+     .add添加每日积分(share积分类型="每日签到", share分享者积分值=50))

wechat_项目授权/小程序授权接口.py

@@ -104,15 +104,7 @@ class sixmini(ViewSet):
             )
     
     def uploadTempMedia(self, request: WSGIRequest | Request, *args, **kwargs):
-        """
+        
-
-        :param request:
-        :type request:
-        :param args:
-        :type args:
-        :param kwargs:
-        :type kwargs:
-        """
         # 上传图片的接口
         uri = f"https://api.weixin.qq.com/cgi-bin/media/upload"
         wecom_token = sixToken.get_wecom_token()
@@ -150,10 +142,6 @@ class sixmini(ViewSet):
     def 消息解密(self, encrypt: str):
         """
         知识点: 微信请求发送过来的 encrypt 是 b64encode编码后的数据, 是由 iv + 编码数据 组成的
-        :param encrypt:
-        :type encrypt:
-        :return:
-        :rtype:
         """
         aes_key = base64.b64decode(self.EncodingAESKey + "=")  # 补 全 Base64 编码缺失的 '='
         # Step 2: Base64 解码加密数据
@@ -188,22 +176,6 @@ class sixmini(ViewSet):
         if 确认收货的方法:
             print("确认收货的回请求进来了")
             ems邮政物流工具().确认收货(order支付微信侧订单号=order支付微信侧订单号)
-        确认收货的时候数据 = {
-            'ToUserName': 'gh_f754c53eb962',
-            'FromUserName': 'ohQkD7HmLYEYrFjFau6juOhduRU8',
-            'CreateTime': 1784839115,
-            'MsgType': 'event',  # 类型,微信官方默认的
-            'Event': 'trade_manage_order_settlement',  # 接收到消息的类型, 可以判断是不是当前用户 确认收货
-            'transaction_id': '4200003120202607191690098150',  # 微信官方生成的支付订单号
-            'merchant_id': '1700383419',  # 微信官方的商户号
-            'sub_merchant_id': '',  # 子商户有的商户ID
-            'merchant_trade_no': '548663656512',
-            'pay_time': 1784410374,  # 接收到消息的时间戳
-            'shipped_time': 1784666314,  # 商家发货的时间
-            'confirm_receive_method': 2,  # 当前用户 确认收货的方式 2:表示是自动确认收货 1:表示用户主动点击收货
-            'confirm_receive_time': 1784839114,  # 当前用户确认收货的时间
-            'settlement_time': 1784839115,  # 微信官方 确认的 结算时间
-            }
     
     def web_view_auth(self, request: WSGIRequest | Request, ):
         """"""
@@ -213,19 +185,14 @@ class sixmini(ViewSet):
         return HttpResponse(content="8cfc2017094adff8d7c66b94e209456e")
     
     def api_get(self, request: Request, *args, **kwargs):
-        """
+        """微信小程序接口的回调"""
-        :param request:
-        :param args:
-        :param kwargs:
-        :return:
-        """
-        print("认证请求进来了")
         signature = request.query_params.get("signature", "")
         timestamp = request.query_params.get("timestamp", "")
         nonce = request.query_params.get("nonce", "")
         echostr = request.query_params.get("echostr", False)
         #  TODO:sorted([token, timestamp, nonce])这是就是对三个参数进行字典排序
-        hashstr = "".join(sorted([self.token, timestamp, nonce]))  # 这是就是对三个参数进行字典排序
+        # hashstr = "".join(sorted([self.token, timestamp, nonce]))  # 这是就是对三个参数进行字典排序
+        hashstr = pydash.join(array=sorted([self.token, timestamp, nonce]), separator="")
         sig = hashlib.new(name="sha1", data=hashstr.encode("utf-8")).hexdigest()
         if sig == signature:
             # 当上面的值判断正确后 官方要求原样返回 echostr ;
@@ -244,11 +211,8 @@ class sixmini(ViewSet):
         Encrypt = request.data.get("Encrypt", False)  #
         xml_content = self.消息解密(encrypt=Encrypt)
         Event = pydash.get(obj=xml_content, path="Event")
-        FromUserName = pydash.get(obj=xml_content, path="FromUserName")
         MsgType = pydash.get(obj=xml_content, path="MsgType")
-        print("微信官方到底推送了啥信息啊...........为什么", )
+        print("小程序官方推送的消息", xml_content)
-        print(xml_content)
-        print("微信官方到底推送了啥信息啊...........为什么", )
         if Event == "trade_manage_order_settlement":
             # 这里的通知是微信官方发过来的, 同时,是用户没有确认收货时 达到时间后自动触发的
             self.确认收货(data=xml_content)
@@ -257,7 +221,6 @@ class sixmini(ViewSet):
             # subMsgObj = weiuser.objects.get(mini_openid=FromUserName)
         if Event == "add_express_path":
             # 这里发生回调,是说明物流的快递信息有推送
-            pass
             self.更新物流信息(data=xml_content)
         if MsgType == "text":
             pass

测试数据库.py

@@ -1,8 +1,25 @@
 import os
+from datetime import datetime
+from zoneinfo import ZoneInfo
 
 import django
+from pydantic import BaseModel
 
 from sixGuoDjango.settings import base_dir_name
 
 os.environ.setdefault(key="DJANGO_SETTINGS_MODULE", value=f"{base_dir_name}.settings")
 django.setup()
+utc_unix_timestamp = int(datetime.now(tz=ZoneInfo("utc")).timestamp())
+from wechat_token.token工具包 import sixToken
+
+
+class emsParameters(BaseModel):
+    wecom_token: str = sixToken.get_wecom_token()
+    
+    def xiao(self):
+        pass
+
+
+if __name__ == "__main__":
+    pass
+    print(emsParameters().wecom_token)

清除数据.py

@@ -7,12 +7,10 @@ from sixGuoDjango.settings import BASE_DIR
 os.environ.setdefault(key="DJANGO_SETTINGS_MODULE", value=f"{BASE_DIR.name}.settings")
 django.setup()
 from wechat_数据库.用户数据库.小程序登陆用户 import weiuser
-from wechat_数据库.企业微信数据库.企微用户表 import wecom企微用户
+from wechat_数据库.支付订单数据库.商品订单数据 import order订单
-from wechat_数据库.支付订单数据库.商品订单数据 import order订单, order订单商品数据
 
 
 def delete清除所有的订单():
-    order订单商品数据.objects.all().delete()
     order订单.objects.all().delete()